?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
tests: Add "while (false)" test to increase coverage
[vala-gnome.git] / vala / valamemberaccess.vala
blobc00f5fca55c52305c0b09ba05e6588addf34633d
1 /* valamemberaccess.vala
2 *
3 * Copyright (C) 2006-2012 Jürg Billeter
4 *
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2.1 of the License, or (at your option) any later version.
9
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
14
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
18 *
19 * Author:
20 * Jürg Billeter <j@bitron.ch>
21 */
22
23 using GLib;
24
25 /**
26 * Represents an access to a type member in the source code.
27 */
28 public class Vala.MemberAccess : Expression {
29 /**
30 * The parent of the member.
31 */
32 public Expression? inner {
33 get {
34 return _inner;
35 }
36 set {
37 _inner = value;
38 if (_inner != null) {
39 _inner.parent_node = this;
40 }
41 }
42 }
43
44 /**
45 * The name of the member.
46 */
47 public string member_name { get; set; }
48
49 /**
50 * Pointer member access.
51 */
52 public bool pointer_member_access { get; set; }
53
54 /**
55 * Represents access to an instance member without an actual instance,
56 * e.g. `MyClass.an_instance_method`.
57 */
58 public bool prototype_access { get; set; }
59
60 /**
61 * Specifies whether the member is used for object creation.
62 */
63 public bool creation_member { get; set; }
64
65 /**
66 * Qualified access to global symbol.
67 */
68 public bool qualified { get; set; }
69
70 private Expression? _inner;
71 private List<DataType> type_argument_list = new ArrayList<DataType> ();
72
73 /**
74 * Creates a new member access expression.
75 *
76 * @param inner parent of the member
77 * @param member_name member name
78 * @param source_reference reference to source code
79 * @return newly created member access expression
80 */
81 public MemberAccess (Expression? inner, string member_name, SourceReference? source_reference = null) {
82 this.inner = inner;
83 this.member_name = member_name;
84 this.source_reference = source_reference;
85 }
86
87 public MemberAccess.simple (string member_name, SourceReference? source_reference = null) {
88 this.member_name = member_name;
89 this.source_reference = source_reference;
90 }
91
92 public MemberAccess.pointer (Expression inner, string member_name, SourceReference? source_reference = null) {
93 this.inner = inner;
94 this.member_name = member_name;
95 this.source_reference = source_reference;
96 pointer_member_access = true;
97 }
98
99 /**
100 * Appends the specified type as generic type argument.
101 *
102 * @param arg a type reference
103 */
104 public void add_type_argument (DataType arg) {
105 type_argument_list.add (arg);
106 arg.parent_node = this;
107 }
108
109 /**
110 * Returns a copy of the list of generic type arguments.
111 *
112 * @return type argument list
113 */
114 public List<DataType> get_type_arguments () {
115 return type_argument_list;
116 }
117
118 public override void accept (CodeVisitor visitor) {
119 visitor.visit_member_access (this);
120
121 visitor.visit_expression (this);
122 }
123
124 public override void accept_children (CodeVisitor visitor) {
125 if (inner != null) {
126 inner.accept (visitor);
127 }
128
129 foreach (DataType type_arg in type_argument_list) {
130 type_arg.accept (visitor);
131 }
132 }
133
134 public override string to_string () {
135 if (symbol_reference == null || symbol_reference.is_instance_member ()) {
136 if (inner == null) {
137 return member_name;
138 } else {
139 return "%s.%s".printf (inner.to_string (), member_name);
140 }
141 } else {
142 // ensure to always use fully-qualified name
143 // to refer to static members
144 return symbol_reference.get_full_name ();
145 }
146 }
147
148 public override void replace_expression (Expression old_node, Expression new_node) {
149 if (inner == old_node) {
150 inner = new_node;
151 }
152 }
153
154 public override bool is_pure () {
155 // accessing property could have side-effects
156 return (inner == null || inner.is_pure ()) && !(symbol_reference is Property);
157 }
158
159 public override bool is_accessible (Symbol sym) {
160 return (inner == null || inner.is_accessible (sym)) && symbol_reference.is_accessible (sym);
161 }
162
163 public override void replace_type (DataType old_type, DataType new_type) {
164 for (int i = 0; i < type_argument_list.size; i++) {
165 if (type_argument_list[i] == old_type) {
166 type_argument_list[i] = new_type;
167 return;
168 }
169 }
170 }
171
172 public override bool is_constant () {
173 var method = symbol_reference as Method;
174 if (symbol_reference is Constant) {
175 return true;
176 } else if (symbol_reference is ArrayLengthField && inner != null && inner.symbol_reference is Constant) {
177 // length of constant array
178 return true;
179 } else if (method != null &&
180 (method.binding == MemberBinding.STATIC || prototype_access)) {
181 return true;
182 } else {
183 return false;
184 }
185 }
186
187 public override bool is_non_null () {
188 var c = symbol_reference as Constant;
189 if (c != null) {
190 return (c is EnumValue || !c.type_reference.nullable);
191 } else {
192 return false;
193 }
194 }
195
196 public override bool check (CodeContext context) {
197 if (checked) {
198 return !error;
199 }
200
201 checked = true;
202
203 if (inner != null) {
204 inner.check (context);
205 }
206
207 foreach (DataType type_arg in type_argument_list) {
208 type_arg.check (context);
209 }
210
211 Symbol base_symbol = null;
212 Parameter this_parameter = null;
213 bool may_access_instance_members = false;
214 bool may_access_klass_members = false;
215
216 symbol_reference = null;
217
218 if (qualified) {
219 base_symbol = context.analyzer.root_symbol;
220 symbol_reference = context.analyzer.root_symbol.scope.lookup (member_name);
221 } else if (inner == null) {
222 if (member_name == "this") {
223 if (!context.analyzer.is_in_instance_method ()) {
224 error = true;
225 Report.error (source_reference, "This access invalid outside of instance methods");
226 return false;
227 }
228 }
229
230 base_symbol = context.analyzer.current_symbol;
231
232 // track whether method has been found to make sure that access
233 // to instance member is denied from within static lambda expressions
234 bool method_found = false;
235
236 var sym = context.analyzer.current_symbol;
237 while (sym != null && symbol_reference == null) {
238 if (!method_found) {
239 if (sym is CreationMethod) {
240 var cm = (CreationMethod) sym;
241 this_parameter = cm.this_parameter;
242 may_access_instance_members = true;
243 may_access_klass_members = true;
244 method_found = true;
245 } else if (sym is Property) {
246 var prop = (Property) sym;
247 this_parameter = prop.this_parameter;
248 may_access_instance_members = (prop.binding == MemberBinding.INSTANCE);
249 may_access_klass_members = (prop.binding != MemberBinding.STATIC);
250 method_found = true;
251 } else if (sym is Constructor) {
252 var c = (Constructor) sym;
253 this_parameter = c.this_parameter;
254 may_access_instance_members = (c.binding == MemberBinding.INSTANCE);
255 may_access_klass_members = true;
256 method_found = true;
257 } else if (sym is Destructor) {
258 var d = (Destructor) sym;
259 this_parameter = d.this_parameter;
260 may_access_instance_members = (d.binding == MemberBinding.INSTANCE);
261 may_access_klass_members = true;
262 method_found = true;
263 } else if (sym is Method) {
264 var m = (Method) sym;
265 this_parameter = m.this_parameter;
266 may_access_instance_members = (m.binding == MemberBinding.INSTANCE);
267 may_access_klass_members = (m.binding != MemberBinding.STATIC);
268 method_found = true;
269 }
270 }
271
272 symbol_reference = SemanticAnalyzer.symbol_lookup_inherited (sym, member_name);
273
274 if (symbol_reference == null && sym is TypeSymbol && may_access_instance_members) {
275 // used for generated to_string methods in enums
276 symbol_reference = this_parameter.variable_type.get_member (member_name);
277
278 if (symbol_reference != null && is_instance_symbol (symbol_reference)) {
279 // implicit this
280 inner = new MemberAccess (null, "this", source_reference);
281 inner.value_type = this_parameter.variable_type.copy ();
282 inner.value_type.value_owned = false;
283 inner.symbol_reference = this_parameter;
284
285 symbol_reference = inner.value_type.get_member (member_name);
286 }
287 }
288
289 if (symbol_reference == null) {
290 if (sym is TypeSymbol) {
291 // do not allow instance access to outer classes
292 this_parameter = null;
293 may_access_instance_members = false;
294 may_access_klass_members = false;
295 }
296 }
297
298 sym = sym.parent_symbol;
299 }
300
301 if (symbol_reference == null && source_reference != null) {
302 foreach (UsingDirective ns in source_reference.using_directives) {
303 var local_sym = ns.namespace_symbol.scope.lookup (member_name);
304 if (local_sym != null) {
305 if (symbol_reference != null && symbol_reference != local_sym) {
306 error = true;
307 Report.error (source_reference, "`%s' is an ambiguous reference between `%s' and `%s'".printf (member_name, symbol_reference.get_full_name (), local_sym.get_full_name ()));
308 return false;
309 }
310 symbol_reference = local_sym;
311 }
312 }
313 }
314 } else {
315 if (inner.error) {
316 /* if there was an error in the inner expression, skip this check */
317 error = true;
318 return false;
319 }
320
321 if (inner.value_type is PointerType) {
322 var pointer_type = inner.value_type as PointerType;
323 if (pointer_type != null && pointer_type.base_type is ValueType) {
324 // transform foo->bar to (*foo).bar
325 inner = new PointerIndirection (inner, source_reference);
326 inner.check (context);
327 pointer_member_access = false;
328 }
329 }
330
331 if (inner is MemberAccess) {
332 var ma = (MemberAccess) inner;
333 if (ma.prototype_access) {
334 error = true;
335 Report.error (source_reference, "Access to instance member `%s' denied".printf (inner.symbol_reference.get_full_name ()));
336 return false;
337 }
338 }
339
340 if (inner is MemberAccess || inner is BaseAccess) {
341 base_symbol = inner.symbol_reference;
342
343 if (symbol_reference == null && (base_symbol is Namespace || base_symbol is TypeSymbol)) {
344 symbol_reference = base_symbol.scope.lookup (member_name);
345 if (inner is BaseAccess) {
346 // inner expression is base access
347 // access to instance members of the base type possible
348 may_access_instance_members = true;
349 may_access_klass_members = true;
350 }
351 }
352 }
353
354 if (symbol_reference == null && inner.value_type != null) {
355 if (pointer_member_access) {
356 symbol_reference = inner.value_type.get_pointer_member (member_name);
357 } else {
358 if (inner.value_type.data_type != null) {
359 base_symbol = inner.value_type.data_type;
360 }
361 symbol_reference = inner.value_type.get_member (member_name);
362 }
363 if (symbol_reference != null) {
364 // inner expression is variable, field, or parameter
365 // access to instance members of the corresponding type possible
366 may_access_instance_members = true;
367 may_access_klass_members = true;
368 }
369 }
370
371 if (symbol_reference == null && inner.value_type != null && inner.value_type.is_dynamic) {
372 // allow late bound members for dynamic types
373 var dynamic_object_type = (ObjectType) inner.value_type;
374 if (parent_node is MethodCall) {
375 var invoc = (MethodCall) parent_node;
376 if (invoc.call == this) {
377 // dynamic method
378 DataType ret_type;
379 if (invoc.target_type != null) {
380 ret_type = invoc.target_type.copy ();
381 ret_type.value_owned = true;
382 } else if (invoc.parent_node is ExpressionStatement) {
383 ret_type = new VoidType ();
384 } else {
385 // expect dynamic object of the same type
386 ret_type = inner.value_type.copy ();
387 }
388 var m = new DynamicMethod (inner.value_type, member_name, ret_type, source_reference);
389 m.invocation = invoc;
390 var err = new ErrorType (null, null);
391 err.dynamic_error = true;
392 m.add_error_type (err);
393 m.access = SymbolAccessibility.PUBLIC;
394 m.add_parameter (new Parameter.with_ellipsis ());
395 dynamic_object_type.type_symbol.scope.add (null, m);
396 symbol_reference = m;
397 }
398 } else if (parent_node is Assignment) {
399 var a = (Assignment) parent_node;
400 if (a.left == this
401 && (a.operator == AssignmentOperator.ADD
402 || a.operator == AssignmentOperator.SUB)) {
403 // dynamic signal
404 var s = new DynamicSignal (inner.value_type, member_name, new VoidType (), source_reference);
405 s.handler = a.right;
406 s.access = SymbolAccessibility.PUBLIC;
407 dynamic_object_type.type_symbol.scope.add (null, s);
408 symbol_reference = s;
409 } else if (a.left == this) {
410 // dynamic property assignment
411 var prop = new DynamicProperty (inner.value_type, member_name, source_reference);
412 prop.access = SymbolAccessibility.PUBLIC;
413 prop.set_accessor = new PropertyAccessor (false, true, false, null, null, prop.source_reference);
414 prop.owner = inner.value_type.data_type.scope;
415 dynamic_object_type.type_symbol.scope.add (null, prop);
416 symbol_reference = prop;
417 }
418 } else if (parent_node is MemberAccess && inner is MemberAccess && parent_node.parent_node is MethodCall) {
419 var ma = (MemberAccess) parent_node;
420 if (ma.member_name == "connect" || ma.member_name == "connect_after") {
421 // dynamic signal
422 var s = new DynamicSignal (inner.value_type, member_name, new VoidType (), source_reference);
423 var mcall = (MethodCall) parent_node.parent_node;
424 // the first argument is the handler
425 if (mcall.get_argument_list().size > 0) {
426 s.handler = mcall.get_argument_list()[0];
427 }
428 s.access = SymbolAccessibility.PUBLIC;
429 dynamic_object_type.type_symbol.scope.add (null, s);
430 symbol_reference = s;
431 }
432 }
433 if (symbol_reference == null) {
434 // dynamic property read access
435 var prop = new DynamicProperty (inner.value_type, member_name, source_reference);
436 if (target_type != null) {
437 prop.property_type = target_type;
438 } else {
439 // expect dynamic object of the same type
440 prop.property_type = inner.value_type.copy ();
441 }
442 prop.access = SymbolAccessibility.PUBLIC;
443 prop.get_accessor = new PropertyAccessor (true, false, false, prop.property_type.copy (), null, prop.source_reference);
444 prop.owner = inner.value_type.data_type.scope;
445 dynamic_object_type.type_symbol.scope.add (null, prop);
446 symbol_reference = prop;
447 }
448 if (symbol_reference != null) {
449 may_access_instance_members = true;
450 may_access_klass_members = true;
451 }
452 }
453 }
454
455 if (symbol_reference == null) {
456 error = true;
457
458 string base_type_name = "(null)";
459 if (inner != null && inner.value_type != null) {
460 base_type_name = inner.value_type.to_string ();
461 } else if (base_symbol != null) {
462 base_type_name = base_symbol.get_full_name ();
463 }
464
465 Report.error (source_reference, "The name `%s' does not exist in the context of `%s'".printf (member_name, base_type_name));
466 return false;
467 }
468
469 var member = symbol_reference;
470 var access = SymbolAccessibility.PUBLIC;
471 bool instance = false;
472 bool klass = false;
473 bool generics = false;
474
475 if (!member.check (context)) {
476 return false;
477 }
478
479 if (member is LocalVariable) {
480 var local = (LocalVariable) member;
481 var block = local.parent_symbol as Block;
482 if (block != null && context.analyzer.find_parent_method_or_property_accessor (block) != context.analyzer.current_method_or_property_accessor) {
483 // mark all methods between current method and the captured
484 // block as closures (to support nested closures)
485 Symbol sym = context.analyzer.current_method_or_property_accessor;
486 while (sym != block) {
487 var method = sym as Method;
488 if (method != null) {
489 method.closure = true;
490 // consider captured variables as used
491 // as we require captured variables to be initialized
492 method.add_captured_variable (local);
493 }
494 sym = sym.parent_symbol;
495 }
496
497 local.captured = true;
498 block.captured = true;
499 }
500 } else if (member is Parameter) {
501 var param = (Parameter) member;
502 var m = param.parent_symbol as Method;
503 if (m != null && m != context.analyzer.current_method_or_property_accessor && param != m.this_parameter) {
504 // mark all methods between current method and the captured
505 // parameter as closures (to support nested closures)
506 Symbol sym = context.analyzer.current_method_or_property_accessor;
507 while (sym != m) {
508 var method = sym as Method;
509 if (method != null) {
510 method.closure = true;
511 }
512 sym = sym.parent_symbol;
513 }
514
515 param.captured = true;
516 m.body.captured = true;
517
518 if (param.direction != ParameterDirection.IN) {
519 error = true;
520 Report.error (source_reference, "Cannot capture reference or output parameter `%s'".printf (param.get_full_name ()));
521 }
522 } else {
523 var acc = param.parent_symbol.parent_symbol as PropertyAccessor;
524 if (acc != null && acc != context.analyzer.current_method_or_property_accessor && param != acc.prop.this_parameter) {
525 // mark all methods between current method and the captured
526 // parameter as closures (to support nested closures)
527 Symbol sym = context.analyzer.current_method_or_property_accessor;
528 while (sym != m) {
529 var method = sym as Method;
530 if (method != null) {
531 method.closure = true;
532 }
533 sym = sym.parent_symbol;
534 }
535
536 param.captured = true;
537 acc.body.captured = true;
538 }
539 }
540 } else if (member is Field) {
541 var f = (Field) member;
542 access = f.access;
543 instance = (f.binding == MemberBinding.INSTANCE);
544 klass = (f.binding == MemberBinding.CLASS);
545
546 // do not allow access to fields of generic types
547 // if instance type does not specify type arguments
548 if (f.variable_type is GenericType) {
549 generics = true;
550 }
551 } else if (member is Constant) {
552 var c = (Constant) member;
553 access = c.access;
554
555 var block = c.parent_symbol as Block;
556 if (block != null && context.analyzer.find_parent_method_or_property_accessor (block) != context.analyzer.current_method_or_property_accessor) {
557 error = true;
558 Report.error (source_reference, "internal error: accessing local constants of outer methods is not supported yet");
559 return false;
560 }
561 } else if (member is Method) {
562 var m = (Method) member;
563 if (m.is_async_callback) {
564 // ensure to use right callback method for virtual/abstract async methods
565 // and also for lambda expressions within async methods
566 var async_method = context.analyzer.current_async_method;
567
568 bool is_valid_access = false;
569 if (async_method != null) {
570 if (m == async_method.get_callback_method ()) {
571 is_valid_access = true;
572 } else if (async_method.base_method != null && m == async_method.base_method.get_callback_method ()) {
573 is_valid_access = true;
574 } else if (async_method.base_interface_method != null && m == async_method.base_interface_method.get_callback_method ()) {
575 is_valid_access = true;
576 }
577 }
578 if (!is_valid_access) {
579 error = true;
580 Report.error (source_reference, "Access to async callback `%s' not allowed in this context".printf (m.get_full_name ()));
581 return false;
582 }
583
584 if (async_method != context.analyzer.current_method) {
585 Symbol sym = context.analyzer.current_method;
586 while (sym != async_method) {
587 var method = sym as Method;
588 if (method != null) {
589 method.closure = true;
590 }
591 sym = sym.parent_symbol;
592 }
593 async_method.body.captured = true;
594 }
595
596 m = async_method.get_callback_method ();
597 symbol_reference = m;
598 member = symbol_reference;
599 } else if (m.base_method != null) {
600 // refer to base method to inherit default arguments
601 m = m.base_method;
602
603 if (m.signal_reference != null) {
604 // method is class/default handler for a signal
605 // let signal deal with member access
606 symbol_reference = m.signal_reference;
607 } else {
608 symbol_reference = m;
609 }
610
611 member = symbol_reference;
612 } else if (m.base_interface_method != null) {
613 // refer to base method to inherit default arguments
614 m = m.base_interface_method;
615
616 if (m.signal_reference != null) {
617 // method is class/default handler for a signal
618 // let signal deal with member access
619 symbol_reference = m.signal_reference;
620 } else {
621 symbol_reference = m;
622 }
623
624 member = symbol_reference;
625 }
626 access = m.access;
627 if (!(m is CreationMethod)) {
628 instance = (m.binding == MemberBinding.INSTANCE);
629 }
630 klass = (m.binding == MemberBinding.CLASS);
631
632 // do not allow access to methods using generic type parameters
633 // if instance type does not specify type arguments
634 foreach (var param in m.get_parameters ()) {
635 var generic_type = param.variable_type as GenericType;
636 if (generic_type != null && generic_type.type_parameter.parent_symbol is TypeSymbol) {
637 generics = true;
638 break;
639 }
640 }
641 var generic_type = m.return_type as GenericType;
642 if (generic_type != null && generic_type.type_parameter.parent_symbol is TypeSymbol) {
643 generics = true;
644 }
645 } else if (member is Property) {
646 var prop = (Property) member;
647 if (!prop.check (context)) {
648 error = true;
649 return false;
650 }
651 if (prop.base_property != null) {
652 // refer to base property
653 prop = prop.base_property;
654 symbol_reference = prop;
655 member = symbol_reference;
656 } else if (prop.base_interface_property != null) {
657 // refer to base property
658 prop = prop.base_interface_property;
659 symbol_reference = prop;
660 member = symbol_reference;
661 }
662 access = prop.access;
663 if (lvalue) {
664 if (prop.set_accessor == null) {
665 error = true;
666 Report.error (source_reference, "Property `%s' is read-only".printf (prop.get_full_name ()));
667 return false;
668 }
669 if (prop.access == SymbolAccessibility.PUBLIC) {
670 access = prop.set_accessor.access;
671 } else if (prop.access == SymbolAccessibility.PROTECTED
672 && prop.set_accessor.access != SymbolAccessibility.PUBLIC) {
673 access = prop.set_accessor.access;
674 }
675 } else {
676 if (prop.get_accessor == null) {
677 error = true;
678 Report.error (source_reference, "Property `%s' is write-only".printf (prop.get_full_name ()));
679 return false;
680 }
681 if (prop.access == SymbolAccessibility.PUBLIC) {
682 access = prop.get_accessor.access;
683 } else if (prop.access == SymbolAccessibility.PROTECTED
684 && prop.get_accessor.access != SymbolAccessibility.PUBLIC) {
685 access = prop.get_accessor.access;
686 }
687 }
688 instance = (prop.binding == MemberBinding.INSTANCE);
689
690 // do not allow access to properties of generic types
691 // if instance type does not specify type arguments
692 if (prop.property_type is GenericType) {
693 generics = true;
694 }
695 } else if (member is Signal) {
696 instance = true;
697 access = member.access;
698 }
699
700 member.used = true;
701 member.version.check (source_reference);
702
703 if (access == SymbolAccessibility.PROTECTED) {
704 var target_type = (TypeSymbol) member.parent_symbol;
705
706 bool in_subtype = false;
707 for (Symbol this_symbol = context.analyzer.current_symbol; this_symbol != null; this_symbol = this_symbol.parent_symbol) {
708 if (this_symbol == target_type) {
709 // required for interfaces with non-abstract methods
710 // accessing protected interface members
711 in_subtype = true;
712 break;
713 }
714
715 var cl = this_symbol as Class;
716 if (cl != null && cl.is_subtype_of (target_type)) {
717 in_subtype = true;
718 break;
719 }
720 }
721
722 if (!in_subtype) {
723 error = true;
724 Report.error (source_reference, "Access to protected member `%s' denied".printf (member.get_full_name ()));
725 return false;
726 }
727 } else if (access == SymbolAccessibility.PRIVATE) {
728 var target_type = member.parent_symbol;
729
730 bool in_target_type = false;
731 for (Symbol this_symbol = context.analyzer.current_symbol; this_symbol != null; this_symbol = this_symbol.parent_symbol) {
732 if (target_type == this_symbol) {
733 in_target_type = true;
734 break;
735 }
736 }
737
738 if (!in_target_type) {
739 error = true;
740 Report.error (source_reference, "Access to private member `%s' denied".printf (member.get_full_name ()));
741 return false;
742 }
743 }
744
745 if (generics && inner != null) {
746 var instance_type = inner.value_type;
747 var pointer_type = inner.value_type as PointerType;
748 if (pointer_type != null) {
749 instance_type = pointer_type.base_type;
750 }
751
752 // instance type might be a subtype of the parent symbol of the member
753 // that subtype might not be generic, so do not report an error in that case
754 var object_type = instance_type as ObjectType;
755 if (object_type != null && object_type.type_symbol.get_type_parameters ().size > 0 &&
756 instance_type.get_type_arguments ().size == 0) {
757 error = true;
758 Report.error (inner.source_reference, "missing generic type arguments");
759 return false;
760 }
761 }
762
763 if ((instance && !may_access_instance_members) ||
764 (klass && !may_access_klass_members)) {
765 prototype_access = true;
766
767 if (symbol_reference is Method) {
768 // also set static type for prototype access
769 // required when using instance methods as delegates in constants
770 // TODO replace by MethodPrototype
771 value_type = context.analyzer.get_value_type_for_symbol (symbol_reference, lvalue);
772 } else if (symbol_reference is Field) {
773 value_type = new FieldPrototype ((Field) symbol_reference);
774 } else {
775 value_type = new InvalidType ();
776 }
777
778 if (target_type != null) {
779 value_type.value_owned = target_type.value_owned;
780 }
781 } else {
782 // implicit this access
783 if (instance && inner == null) {
784 inner = new MemberAccess (null, "this", source_reference);
785 inner.value_type = this_parameter.variable_type.copy ();
786 inner.value_type.value_owned = false;
787 inner.symbol_reference = this_parameter;
788 } else {
789 check_lvalue_access ();
790 }
791
792 if (!instance && !klass && !(symbol_reference is CreationMethod) && may_access_instance_members && inner != null) {
793 if (inner.symbol_reference is Method) {
794 // do not warn when calling .begin or .end on static async method
795 } else {
796 Report.warning (source_reference, "Access to static member `%s' with an instance reference".printf (symbol_reference.get_full_name ()));
797 }
798 }
799
800 if (context.experimental_non_null && instance && inner.value_type.nullable &&
801 !(inner.value_type is PointerType) && !(inner.value_type is GenericType) &&
802 !(inner.value_type is ArrayType)) {
803 Report.error (source_reference, "Access to instance member `%s' from nullable reference denied".printf (symbol_reference.get_full_name ()));
804 }
805
806 var m = symbol_reference as Method;
807 var inner_ma = inner as MemberAccess;
808 if (m != null && m.binding == MemberBinding.STATIC && m.parent_symbol is ObjectTypeSymbol &&
809 inner != null && inner.value_type == null && inner_ma.type_argument_list.size > 0) {
810 // support static methods in generic classes
811 inner.value_type = new ObjectType ((ObjectTypeSymbol) m.parent_symbol);
812
813 foreach (var type_argument in inner_ma.type_argument_list) {
814 inner.value_type.add_type_argument (type_argument);
815 }
816 }
817
818 formal_value_type = context.analyzer.get_value_type_for_symbol (symbol_reference, lvalue);
819 if (inner != null && formal_value_type != null) {
820 value_type = formal_value_type.get_actual_type (inner.value_type, null, this);
821 } else {
822 value_type = formal_value_type;
823 }
824
825 if (symbol_reference is Method) {
826 var method = (Method) symbol_reference;
827 if (target_type != null) {
828 value_type.value_owned = target_type.value_owned;
829 }
830 if (instance && method.parent_symbol is TypeSymbol) {
831 inner.target_type = SemanticAnalyzer.get_data_type_for_symbol ((TypeSymbol) method.parent_symbol);
832 inner.target_type.value_owned = method.this_parameter.variable_type.value_owned;
833 }
834 } else if (symbol_reference is Property) {
835 var prop = (Property) symbol_reference;
836 if (instance && prop.parent_symbol != null) {
837 inner.target_type = SemanticAnalyzer.get_data_type_for_symbol ((TypeSymbol) prop.parent_symbol);
838 }
839 } else if ((symbol_reference is Field
840 || symbol_reference is Signal)
841 && instance && symbol_reference.parent_symbol != null) {
842 var parent_type = SemanticAnalyzer.get_data_type_for_symbol ((TypeSymbol) symbol_reference.parent_symbol);
843 inner.target_type = parent_type.get_actual_type (inner.value_type, null, this);
844 }
845 }
846
847 return !error;
848 }
849
850 static bool is_instance_symbol (Symbol symbol) {
851 if (symbol is Field && ((Field) symbol).binding == MemberBinding.INSTANCE) {
852 return true;
853 } else if (symbol is Method && !(symbol is CreationMethod) && ((Method) symbol).binding == MemberBinding.INSTANCE) {
854 return true;
855 } else if (symbol is Property && ((Property) symbol).binding == MemberBinding.INSTANCE) {
856 return true;
857 } else if (symbol is Signal) {
858 return true;
859 } else {
860 return false;
861 }
862 }
863
864 public void check_lvalue_access () {
865 if (inner == null) {
866 return;
867 }
868 var instance = symbol_reference is Field && ((Field) symbol_reference).binding == MemberBinding.INSTANCE;
869 if (!instance) {
870 instance = symbol_reference is Method && ((Method) symbol_reference).binding == MemberBinding.INSTANCE;
871 }
872 if (!instance) {
873 instance = symbol_reference is Property && ((Property) symbol_reference).binding == MemberBinding.INSTANCE;
874 }
875
876 var this_access = inner.symbol_reference is Parameter && inner.symbol_reference.name == "this";
877 var struct_or_array = (inner.value_type is StructValueType && !inner.value_type.nullable) || inner.value_type is ArrayType;
878
879 var ma = inner as MemberAccess;
880 if (ma == null && struct_or_array && inner is PointerIndirection) {
881 // (*struct)->method()
882 ma = ((PointerIndirection) inner).inner as MemberAccess;
883 }
884
885 if (instance && struct_or_array && (symbol_reference is Method || lvalue) && ((ma != null && ma.symbol_reference is Variable) || inner is ElementAccess) && !this_access) {
886 inner.lvalue = true;
887 if (ma != null) {
888 ma.lvalue = true;
889 ma.check_lvalue_access ();
890 }
891 }
892 }
893
894 public override void emit (CodeGenerator codegen) {
895 if (inner != null) {
896 inner.emit (codegen);
897 }
898
899 codegen.visit_member_access (this);
900
901 codegen.visit_expression (this);
902 }
903
904 public override void get_defined_variables (Collection<Variable> collection) {
905 if (inner != null) {
906 inner.get_defined_variables (collection);
907 }
908 }
909
910 public override void get_used_variables (Collection<Variable> collection) {
911 if (inner != null) {
912 inner.get_used_variables (collection);
913 }
914 var local = symbol_reference as LocalVariable;
915 var param = symbol_reference as Parameter;
916 if (local != null) {
917 collection.add (local);
918 } else if (param != null && param.direction == ParameterDirection.OUT) {
919 collection.add (param);
920 }
921 }
922 }
Gnome vala