1 /* valamemberaccess.c generated by valac, the Vala compiler
2 * generated from valamemberaccess.vala, do not modify */
3
4 /* valamemberaccess.vala
5 *
6 * Copyright (C) 2006-2012 Jürg Billeter
7 *
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
12
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
17
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21 *
22 * Author:
23 * Jürg Billeter <j@bitron.ch>
24 */
25
26 #include "vala.h"
27 #include <stdlib.h>
28 #include <string.h>
29 #include <glib.h>
30 #include <valagee.h>
31 #include <glib-object.h>
32
33 #define _vala_code_node_unref0(var) ((var == NULL) ? NULL : (var = (vala_code_node_unref (var), NULL)))
34 #define _g_free0(var) (var = (g_free (var), NULL))
35 #define _vala_iterable_unref0(var) ((var == NULL) ? NULL : (var = (vala_iterable_unref (var), NULL)))
36 typedef struct _Block1Data Block1Data;
37 #define _vala_code_visitor_unref0(var) ((var == NULL) ? NULL : (var = (vala_code_visitor_unref (var), NULL)))
38
39 struct _ValaMemberAccessPrivate {
40 gchar* _member_name;
41 gboolean _pointer_member_access;
42 gboolean _prototype_access;
43 gboolean _tainted_access;
44 gboolean _creation_member;
45 gboolean _qualified;
46 ValaExpression* _inner;
47 ValaList* type_argument_list;
48 };
49
50 struct _Block1Data {
51 int _ref_count_;
52 ValaMemberAccess* self;
53 gboolean found;
54 };
55
56 static gint ValaMemberAccess_private_offset;
57 static gpointer vala_member_access_parent_class = NULL;
58
59 static void vala_member_access_real_accept (ValaCodeNode* base,
60 ValaCodeVisitor* visitor);
61 static void vala_member_access_real_accept_children (ValaCodeNode* base,
62 ValaCodeVisitor* visitor);
63 static gchar* vala_member_access_real_to_string (ValaCodeNode* base);
64 static void vala_member_access_real_replace_expression (ValaCodeNode* base,
65 ValaExpression* old_node,
66 ValaExpression* new_node);
67 static gboolean vala_member_access_real_is_pure (ValaExpression* base);
68 static gboolean vala_member_access_real_is_accessible (ValaExpression* base,
69 ValaSymbol* sym);
70 static void vala_member_access_real_replace_type (ValaCodeNode* base,
71 ValaDataType* old_type,
72 ValaDataType* new_type);
73 static gboolean vala_member_access_real_is_constant (ValaExpression* base);
74 static gboolean vala_member_access_real_is_non_null (ValaExpression* base);
75 static void vala_member_access_real_get_error_types (ValaCodeNode* base,
76 ValaCollection* collection,
77 ValaSourceReference* source_reference);
78 static gboolean vala_member_access_real_check (ValaCodeNode* base,
79 ValaCodeContext* context);
80 static gboolean vala_member_access_is_instance_symbol (ValaSymbol* symbol);
81 static gboolean vala_member_access_is_tainted (ValaMemberAccess* self);
82 static void vala_member_access_real_emit (ValaCodeNode* base,
83 ValaCodeGenerator* codegen);
84 static void vala_member_access_real_get_defined_variables (ValaCodeNode* base,
85 ValaCollection* collection);
86 static void vala_member_access_real_get_used_variables (ValaCodeNode* base,
87 ValaCollection* collection);
88 static Block1Data* block1_data_ref (Block1Data* _data1_);
89 static void block1_data_unref (void * _userdata_);
90 static ValaTraverseStatus __lambda4_ (Block1Data* _data1_,
91 ValaCodeNode* n);
92 static ValaTraverseStatus ___lambda4__vala_traverse_func (ValaCodeNode* node,
93 gpointer self);
94 static void vala_member_access_finalize (ValaCodeNode * obj);
95 static GType vala_member_access_get_type_once (void);
96
97 static inline gpointer
vala_member_access_get_instance_private(ValaMemberAccess * self)98 vala_member_access_get_instance_private (ValaMemberAccess* self)
99 {
100 return G_STRUCT_MEMBER_P (self, ValaMemberAccess_private_offset);
101 }
102
103 ValaExpression*
vala_member_access_get_inner(ValaMemberAccess * self)104 vala_member_access_get_inner (ValaMemberAccess* self)
105 {
106 ValaExpression* result;
107 ValaExpression* _tmp0_;
108 g_return_val_if_fail (self != NULL, NULL);
109 _tmp0_ = self->priv->_inner;
110 result = _tmp0_;
111 return result;
112 }
113
114 static gpointer
_vala_code_node_ref0(gpointer self)115 _vala_code_node_ref0 (gpointer self)
116 {
117 return self ? vala_code_node_ref (self) : NULL;
118 }
119
120 void
vala_member_access_set_inner(ValaMemberAccess * self,ValaExpression * value)121 vala_member_access_set_inner (ValaMemberAccess* self,
122 ValaExpression* value)
123 {
124 ValaExpression* _tmp0_;
125 ValaExpression* _tmp1_;
126 g_return_if_fail (self != NULL);
127 _tmp0_ = _vala_code_node_ref0 (value);
128 _vala_code_node_unref0 (self->priv->_inner);
129 self->priv->_inner = _tmp0_;
130 _tmp1_ = self->priv->_inner;
131 if (_tmp1_ != NULL) {
132 ValaExpression* _tmp2_;
133 _tmp2_ = self->priv->_inner;
134 vala_code_node_set_parent_node ((ValaCodeNode*) _tmp2_, (ValaCodeNode*) self);
135 }
136 }
137
138 const gchar*
vala_member_access_get_member_name(ValaMemberAccess * self)139 vala_member_access_get_member_name (ValaMemberAccess* self)
140 {
141 const gchar* result;
142 const gchar* _tmp0_;
143 g_return_val_if_fail (self != NULL, NULL);
144 _tmp0_ = self->priv->_member_name;
145 result = _tmp0_;
146 return result;
147 }
148
149 void
vala_member_access_set_member_name(ValaMemberAccess * self,const gchar * value)150 vala_member_access_set_member_name (ValaMemberAccess* self,
151 const gchar* value)
152 {
153 gchar* _tmp0_;
154 g_return_if_fail (self != NULL);
155 _tmp0_ = g_strdup (value);
156 _g_free0 (self->priv->_member_name);
157 self->priv->_member_name = _tmp0_;
158 }
159
160 gboolean
vala_member_access_get_pointer_member_access(ValaMemberAccess * self)161 vala_member_access_get_pointer_member_access (ValaMemberAccess* self)
162 {
163 gboolean result;
164 g_return_val_if_fail (self != NULL, FALSE);
165 result = self->priv->_pointer_member_access;
166 return result;
167 }
168
169 void
vala_member_access_set_pointer_member_access(ValaMemberAccess * self,gboolean value)170 vala_member_access_set_pointer_member_access (ValaMemberAccess* self,
171 gboolean value)
172 {
173 g_return_if_fail (self != NULL);
174 self->priv->_pointer_member_access = value;
175 }
176
177 gboolean
vala_member_access_get_prototype_access(ValaMemberAccess * self)178 vala_member_access_get_prototype_access (ValaMemberAccess* self)
179 {
180 gboolean result;
181 g_return_val_if_fail (self != NULL, FALSE);
182 result = self->priv->_prototype_access;
183 return result;
184 }
185
186 void
vala_member_access_set_prototype_access(ValaMemberAccess * self,gboolean value)187 vala_member_access_set_prototype_access (ValaMemberAccess* self,
188 gboolean value)
189 {
190 g_return_if_fail (self != NULL);
191 self->priv->_prototype_access = value;
192 }
193
194 gboolean
vala_member_access_get_tainted_access(ValaMemberAccess * self)195 vala_member_access_get_tainted_access (ValaMemberAccess* self)
196 {
197 gboolean result;
198 g_return_val_if_fail (self != NULL, FALSE);
199 result = self->priv->_tainted_access;
200 return result;
201 }
202
203 void
vala_member_access_set_tainted_access(ValaMemberAccess * self,gboolean value)204 vala_member_access_set_tainted_access (ValaMemberAccess* self,
205 gboolean value)
206 {
207 g_return_if_fail (self != NULL);
208 self->priv->_tainted_access = value;
209 }
210
211 gboolean
vala_member_access_get_creation_member(ValaMemberAccess * self)212 vala_member_access_get_creation_member (ValaMemberAccess* self)
213 {
214 gboolean result;
215 g_return_val_if_fail (self != NULL, FALSE);
216 result = self->priv->_creation_member;
217 return result;
218 }
219
220 void
vala_member_access_set_creation_member(ValaMemberAccess * self,gboolean value)221 vala_member_access_set_creation_member (ValaMemberAccess* self,
222 gboolean value)
223 {
224 g_return_if_fail (self != NULL);
225 self->priv->_creation_member = value;
226 }
227
228 gboolean
vala_member_access_get_qualified(ValaMemberAccess * self)229 vala_member_access_get_qualified (ValaMemberAccess* self)
230 {
231 gboolean result;
232 g_return_val_if_fail (self != NULL, FALSE);
233 result = self->priv->_qualified;
234 return result;
235 }
236
237 void
vala_member_access_set_qualified(ValaMemberAccess * self,gboolean value)238 vala_member_access_set_qualified (ValaMemberAccess* self,
239 gboolean value)
240 {
241 g_return_if_fail (self != NULL);
242 self->priv->_qualified = value;
243 }
244
245 /**
246 * Creates a new member access expression.
247 *
248 * @param inner parent of the member
249 * @param member_name member name
250 * @param source_reference reference to source code
251 * @return newly created member access expression
252 */
253 ValaMemberAccess*
vala_member_access_construct(GType object_type,ValaExpression * inner,const gchar * member_name,ValaSourceReference * source_reference)254 vala_member_access_construct (GType object_type,
255 ValaExpression* inner,
256 const gchar* member_name,
257 ValaSourceReference* source_reference)
258 {
259 ValaMemberAccess* self = NULL;
260 g_return_val_if_fail (member_name != NULL, NULL);
261 self = (ValaMemberAccess*) vala_expression_construct (object_type);
262 vala_member_access_set_inner (self, inner);
263 vala_member_access_set_member_name (self, member_name);
264 vala_code_node_set_source_reference ((ValaCodeNode*) self, source_reference);
265 return self;
266 }
267
268 ValaMemberAccess*
vala_member_access_new(ValaExpression * inner,const gchar * member_name,ValaSourceReference * source_reference)269 vala_member_access_new (ValaExpression* inner,
270 const gchar* member_name,
271 ValaSourceReference* source_reference)
272 {
273 return vala_member_access_construct (VALA_TYPE_MEMBER_ACCESS, inner, member_name, source_reference);
274 }
275
276 ValaMemberAccess*
vala_member_access_construct_simple(GType object_type,const gchar * member_name,ValaSourceReference * source_reference)277 vala_member_access_construct_simple (GType object_type,
278 const gchar* member_name,
279 ValaSourceReference* source_reference)
280 {
281 ValaMemberAccess* self = NULL;
282 g_return_val_if_fail (member_name != NULL, NULL);
283 self = (ValaMemberAccess*) vala_expression_construct (object_type);
284 vala_member_access_set_inner (self, NULL);
285 vala_member_access_set_member_name (self, member_name);
286 vala_code_node_set_source_reference ((ValaCodeNode*) self, source_reference);
287 return self;
288 }
289
290 ValaMemberAccess*
vala_member_access_new_simple(const gchar * member_name,ValaSourceReference * source_reference)291 vala_member_access_new_simple (const gchar* member_name,
292 ValaSourceReference* source_reference)
293 {
294 return vala_member_access_construct_simple (VALA_TYPE_MEMBER_ACCESS, member_name, source_reference);
295 }
296
297 ValaMemberAccess*
vala_member_access_construct_pointer(GType object_type,ValaExpression * inner,const gchar * member_name,ValaSourceReference * source_reference)298 vala_member_access_construct_pointer (GType object_type,
299 ValaExpression* inner,
300 const gchar* member_name,
301 ValaSourceReference* source_reference)
302 {
303 ValaMemberAccess* self = NULL;
304 g_return_val_if_fail (inner != NULL, NULL);
305 g_return_val_if_fail (member_name != NULL, NULL);
306 self = (ValaMemberAccess*) vala_expression_construct (object_type);
307 vala_member_access_set_inner (self, inner);
308 vala_member_access_set_member_name (self, member_name);
309 vala_code_node_set_source_reference ((ValaCodeNode*) self, source_reference);
310 vala_member_access_set_pointer_member_access (self, TRUE);
311 return self;
312 }
313
314 ValaMemberAccess*
vala_member_access_new_pointer(ValaExpression * inner,const gchar * member_name,ValaSourceReference * source_reference)315 vala_member_access_new_pointer (ValaExpression* inner,
316 const gchar* member_name,
317 ValaSourceReference* source_reference)
318 {
319 return vala_member_access_construct_pointer (VALA_TYPE_MEMBER_ACCESS, inner, member_name, source_reference);
320 }
321
322 /**
323 * Appends the specified type as generic type argument.
324 *
325 * @param arg a type reference
326 */
327 void
vala_member_access_add_type_argument(ValaMemberAccess * self,ValaDataType * arg)328 vala_member_access_add_type_argument (ValaMemberAccess* self,
329 ValaDataType* arg)
330 {
331 ValaList* _tmp0_;
332 g_return_if_fail (self != NULL);
333 g_return_if_fail (arg != NULL);
334 _tmp0_ = self->priv->type_argument_list;
335 vala_collection_add ((ValaCollection*) _tmp0_, arg);
336 vala_code_node_set_parent_node ((ValaCodeNode*) arg, (ValaCodeNode*) self);
337 }
338
339 /**
340 * Returns the list of generic type arguments.
341 *
342 * @return type argument list
343 */
344 ValaList*
vala_member_access_get_type_arguments(ValaMemberAccess * self)345 vala_member_access_get_type_arguments (ValaMemberAccess* self)
346 {
347 ValaList* _tmp0_;
348 ValaList* result = NULL;
349 g_return_val_if_fail (self != NULL, NULL);
350 _tmp0_ = self->priv->type_argument_list;
351 result = _tmp0_;
352 return result;
353 }
354
355 static void
vala_member_access_real_accept(ValaCodeNode * base,ValaCodeVisitor * visitor)356 vala_member_access_real_accept (ValaCodeNode* base,
357 ValaCodeVisitor* visitor)
358 {
359 ValaMemberAccess * self;
360 self = (ValaMemberAccess*) base;
361 g_return_if_fail (visitor != NULL);
362 vala_code_visitor_visit_member_access (visitor, self);
363 vala_code_visitor_visit_expression (visitor, (ValaExpression*) self);
364 }
365
366 static gpointer
_vala_iterable_ref0(gpointer self)367 _vala_iterable_ref0 (gpointer self)
368 {
369 return self ? vala_iterable_ref (self) : NULL;
370 }
371
372 static void
vala_member_access_real_accept_children(ValaCodeNode * base,ValaCodeVisitor * visitor)373 vala_member_access_real_accept_children (ValaCodeNode* base,
374 ValaCodeVisitor* visitor)
375 {
376 ValaMemberAccess * self;
377 ValaExpression* _tmp0_;
378 ValaExpression* _tmp1_;
379 self = (ValaMemberAccess*) base;
380 g_return_if_fail (visitor != NULL);
381 _tmp0_ = vala_member_access_get_inner (self);
382 _tmp1_ = _tmp0_;
383 if (_tmp1_ != NULL) {
384 ValaExpression* _tmp2_;
385 ValaExpression* _tmp3_;
386 _tmp2_ = vala_member_access_get_inner (self);
387 _tmp3_ = _tmp2_;
388 vala_code_node_accept ((ValaCodeNode*) _tmp3_, visitor);
389 }
390 {
391 ValaList* _type_arg_list = NULL;
392 ValaList* _tmp4_;
393 ValaList* _tmp5_;
394 gint _type_arg_size = 0;
395 ValaList* _tmp6_;
396 gint _tmp7_;
397 gint _tmp8_;
398 gint _type_arg_index = 0;
399 _tmp4_ = self->priv->type_argument_list;
400 _tmp5_ = _vala_iterable_ref0 (_tmp4_);
401 _type_arg_list = _tmp5_;
402 _tmp6_ = _type_arg_list;
403 _tmp7_ = vala_collection_get_size ((ValaCollection*) _tmp6_);
404 _tmp8_ = _tmp7_;
405 _type_arg_size = _tmp8_;
406 _type_arg_index = -1;
407 while (TRUE) {
408 gint _tmp9_;
409 gint _tmp10_;
410 ValaDataType* type_arg = NULL;
411 ValaList* _tmp11_;
412 gpointer _tmp12_;
413 ValaDataType* _tmp13_;
414 _type_arg_index = _type_arg_index + 1;
415 _tmp9_ = _type_arg_index;
416 _tmp10_ = _type_arg_size;
417 if (!(_tmp9_ < _tmp10_)) {
418 break;
419 }
420 _tmp11_ = _type_arg_list;
421 _tmp12_ = vala_list_get (_tmp11_, _type_arg_index);
422 type_arg = (ValaDataType*) _tmp12_;
423 _tmp13_ = type_arg;
424 vala_code_node_accept ((ValaCodeNode*) _tmp13_, visitor);
425 _vala_code_node_unref0 (type_arg);
426 }
427 _vala_iterable_unref0 (_type_arg_list);
428 }
429 }
430
431 static gchar*
vala_member_access_real_to_string(ValaCodeNode * base)432 vala_member_access_real_to_string (ValaCodeNode* base)
433 {
434 ValaMemberAccess * self;
435 gboolean _tmp0_ = FALSE;
436 ValaSymbol* _tmp1_;
437 ValaSymbol* _tmp2_;
438 gchar* result = NULL;
439 self = (ValaMemberAccess*) base;
440 _tmp1_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
441 _tmp2_ = _tmp1_;
442 if (_tmp2_ == NULL) {
443 _tmp0_ = TRUE;
444 } else {
445 ValaSymbol* _tmp3_;
446 ValaSymbol* _tmp4_;
447 _tmp3_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
448 _tmp4_ = _tmp3_;
449 _tmp0_ = vala_symbol_is_instance_member (_tmp4_);
450 }
451 if (_tmp0_) {
452 ValaExpression* _tmp5_;
453 ValaExpression* _tmp6_;
454 _tmp5_ = vala_member_access_get_inner (self);
455 _tmp6_ = _tmp5_;
456 if (_tmp6_ == NULL) {
457 const gchar* _tmp7_;
458 gchar* _tmp8_;
459 _tmp7_ = self->priv->_member_name;
460 _tmp8_ = g_strdup (_tmp7_);
461 result = _tmp8_;
462 return result;
463 } else {
464 const gchar* _tmp9_ = NULL;
465 gboolean _tmp10_;
466 ValaExpression* _tmp11_;
467 ValaExpression* _tmp12_;
468 gchar* _tmp13_;
469 gchar* _tmp14_;
470 const gchar* _tmp15_;
471 gchar* _tmp16_;
472 gchar* _tmp17_;
473 _tmp10_ = self->priv->_pointer_member_access;
474 if (_tmp10_) {
475 _tmp9_ = "->";
476 } else {
477 _tmp9_ = ".";
478 }
479 _tmp11_ = vala_member_access_get_inner (self);
480 _tmp12_ = _tmp11_;
481 _tmp13_ = vala_code_node_to_string ((ValaCodeNode*) _tmp12_);
482 _tmp14_ = _tmp13_;
483 _tmp15_ = self->priv->_member_name;
484 _tmp16_ = g_strdup_printf ("%s%s%s", _tmp14_, _tmp9_, _tmp15_);
485 _tmp17_ = _tmp16_;
486 _g_free0 (_tmp14_);
487 result = _tmp17_;
488 return result;
489 }
490 } else {
491 ValaSymbol* _tmp18_;
492 ValaSymbol* _tmp19_;
493 gchar* _tmp20_;
494 _tmp18_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
495 _tmp19_ = _tmp18_;
496 _tmp20_ = vala_symbol_get_full_name (_tmp19_);
497 result = _tmp20_;
498 return result;
499 }
500 }
501
502 static void
vala_member_access_real_replace_expression(ValaCodeNode * base,ValaExpression * old_node,ValaExpression * new_node)503 vala_member_access_real_replace_expression (ValaCodeNode* base,
504 ValaExpression* old_node,
505 ValaExpression* new_node)
506 {
507 ValaMemberAccess * self;
508 ValaExpression* _tmp0_;
509 ValaExpression* _tmp1_;
510 self = (ValaMemberAccess*) base;
511 g_return_if_fail (old_node != NULL);
512 g_return_if_fail (new_node != NULL);
513 _tmp0_ = vala_member_access_get_inner (self);
514 _tmp1_ = _tmp0_;
515 if (_tmp1_ == old_node) {
516 vala_member_access_set_inner (self, new_node);
517 }
518 }
519
520 static gboolean
vala_member_access_real_is_pure(ValaExpression * base)521 vala_member_access_real_is_pure (ValaExpression* base)
522 {
523 ValaMemberAccess * self;
524 gboolean _tmp0_ = FALSE;
525 gboolean _tmp1_ = FALSE;
526 ValaExpression* _tmp2_;
527 ValaExpression* _tmp3_;
528 gboolean result = FALSE;
529 self = (ValaMemberAccess*) base;
530 _tmp2_ = vala_member_access_get_inner (self);
531 _tmp3_ = _tmp2_;
532 if (_tmp3_ == NULL) {
533 _tmp1_ = TRUE;
534 } else {
535 ValaExpression* _tmp4_;
536 ValaExpression* _tmp5_;
537 _tmp4_ = vala_member_access_get_inner (self);
538 _tmp5_ = _tmp4_;
539 _tmp1_ = vala_expression_is_pure (_tmp5_);
540 }
541 if (_tmp1_) {
542 ValaSymbol* _tmp6_;
543 ValaSymbol* _tmp7_;
544 _tmp6_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
545 _tmp7_ = _tmp6_;
546 _tmp0_ = !VALA_IS_PROPERTY (_tmp7_);
547 } else {
548 _tmp0_ = FALSE;
549 }
550 result = _tmp0_;
551 return result;
552 }
553
554 static gboolean
vala_member_access_real_is_accessible(ValaExpression * base,ValaSymbol * sym)555 vala_member_access_real_is_accessible (ValaExpression* base,
556 ValaSymbol* sym)
557 {
558 ValaMemberAccess * self;
559 gboolean _tmp0_ = FALSE;
560 gboolean _tmp1_ = FALSE;
561 ValaExpression* _tmp2_;
562 ValaExpression* _tmp3_;
563 gboolean result = FALSE;
564 self = (ValaMemberAccess*) base;
565 g_return_val_if_fail (sym != NULL, FALSE);
566 _tmp2_ = vala_member_access_get_inner (self);
567 _tmp3_ = _tmp2_;
568 if (_tmp3_ == NULL) {
569 _tmp1_ = TRUE;
570 } else {
571 ValaExpression* _tmp4_;
572 ValaExpression* _tmp5_;
573 _tmp4_ = vala_member_access_get_inner (self);
574 _tmp5_ = _tmp4_;
575 _tmp1_ = vala_expression_is_accessible (_tmp5_, sym);
576 }
577 if (_tmp1_) {
578 ValaSymbol* _tmp6_;
579 ValaSymbol* _tmp7_;
580 _tmp6_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
581 _tmp7_ = _tmp6_;
582 _tmp0_ = vala_symbol_is_accessible (_tmp7_, sym);
583 } else {
584 _tmp0_ = FALSE;
585 }
586 result = _tmp0_;
587 return result;
588 }
589
590 static void
vala_member_access_real_replace_type(ValaCodeNode * base,ValaDataType * old_type,ValaDataType * new_type)591 vala_member_access_real_replace_type (ValaCodeNode* base,
592 ValaDataType* old_type,
593 ValaDataType* new_type)
594 {
595 ValaMemberAccess * self;
596 self = (ValaMemberAccess*) base;
597 g_return_if_fail (old_type != NULL);
598 g_return_if_fail (new_type != NULL);
599 {
600 gint i = 0;
601 i = 0;
602 {
603 gboolean _tmp0_ = FALSE;
604 _tmp0_ = TRUE;
605 while (TRUE) {
606 ValaList* _tmp2_;
607 gint _tmp3_;
608 gint _tmp4_;
609 ValaList* _tmp5_;
610 gpointer _tmp6_;
611 ValaDataType* _tmp7_;
612 gboolean _tmp8_;
613 if (!_tmp0_) {
614 gint _tmp1_;
615 _tmp1_ = i;
616 i = _tmp1_ + 1;
617 }
618 _tmp0_ = FALSE;
619 _tmp2_ = self->priv->type_argument_list;
620 _tmp3_ = vala_collection_get_size ((ValaCollection*) _tmp2_);
621 _tmp4_ = _tmp3_;
622 if (!(i < _tmp4_)) {
623 break;
624 }
625 _tmp5_ = self->priv->type_argument_list;
626 _tmp6_ = vala_list_get (_tmp5_, i);
627 _tmp7_ = (ValaDataType*) _tmp6_;
628 _tmp8_ = _tmp7_ == old_type;
629 _vala_code_node_unref0 (_tmp7_);
630 if (_tmp8_) {
631 ValaList* _tmp9_;
632 _tmp9_ = self->priv->type_argument_list;
633 vala_list_set (_tmp9_, i, new_type);
634 return;
635 }
636 }
637 }
638 }
639 }
640
641 static gboolean
vala_member_access_real_is_constant(ValaExpression * base)642 vala_member_access_real_is_constant (ValaExpression* base)
643 {
644 ValaMemberAccess * self;
645 ValaMethod* method = NULL;
646 ValaSymbol* _tmp0_;
647 ValaSymbol* _tmp1_;
648 ValaSymbol* _tmp2_;
649 ValaSymbol* _tmp3_;
650 gboolean result = FALSE;
651 self = (ValaMemberAccess*) base;
652 _tmp0_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
653 _tmp1_ = _tmp0_;
654 method = VALA_IS_METHOD (_tmp1_) ? ((ValaMethod*) _tmp1_) : NULL;
655 _tmp2_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
656 _tmp3_ = _tmp2_;
657 if (VALA_IS_CONSTANT (_tmp3_)) {
658 result = TRUE;
659 return result;
660 } else {
661 gboolean _tmp4_ = FALSE;
662 gboolean _tmp5_ = FALSE;
663 ValaSymbol* _tmp6_;
664 ValaSymbol* _tmp7_;
665 _tmp6_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
666 _tmp7_ = _tmp6_;
667 if (VALA_IS_ARRAY_LENGTH_FIELD (_tmp7_)) {
668 ValaExpression* _tmp8_;
669 ValaExpression* _tmp9_;
670 _tmp8_ = vala_member_access_get_inner (self);
671 _tmp9_ = _tmp8_;
672 _tmp5_ = _tmp9_ != NULL;
673 } else {
674 _tmp5_ = FALSE;
675 }
676 if (_tmp5_) {
677 ValaExpression* _tmp10_;
678 ValaExpression* _tmp11_;
679 ValaSymbol* _tmp12_;
680 ValaSymbol* _tmp13_;
681 _tmp10_ = vala_member_access_get_inner (self);
682 _tmp11_ = _tmp10_;
683 _tmp12_ = vala_expression_get_symbol_reference (_tmp11_);
684 _tmp13_ = _tmp12_;
685 _tmp4_ = VALA_IS_CONSTANT (_tmp13_);
686 } else {
687 _tmp4_ = FALSE;
688 }
689 if (_tmp4_) {
690 result = TRUE;
691 return result;
692 } else {
693 gboolean _tmp14_ = FALSE;
694 ValaMethod* _tmp15_;
695 _tmp15_ = method;
696 if (_tmp15_ != NULL) {
697 gboolean _tmp16_ = FALSE;
698 ValaMethod* _tmp17_;
699 ValaMemberBinding _tmp18_;
700 ValaMemberBinding _tmp19_;
701 _tmp17_ = method;
702 _tmp18_ = vala_method_get_binding (_tmp17_);
703 _tmp19_ = _tmp18_;
704 if (_tmp19_ == VALA_MEMBER_BINDING_STATIC) {
705 _tmp16_ = TRUE;
706 } else {
707 gboolean _tmp20_;
708 _tmp20_ = self->priv->_prototype_access;
709 _tmp16_ = _tmp20_;
710 }
711 _tmp14_ = _tmp16_;
712 } else {
713 _tmp14_ = FALSE;
714 }
715 if (_tmp14_) {
716 result = TRUE;
717 return result;
718 } else {
719 result = FALSE;
720 return result;
721 }
722 }
723 }
724 }
725
726 static gboolean
vala_member_access_real_is_non_null(ValaExpression * base)727 vala_member_access_real_is_non_null (ValaExpression* base)
728 {
729 ValaMemberAccess * self;
730 ValaConstant* c = NULL;
731 ValaSymbol* _tmp0_;
732 ValaSymbol* _tmp1_;
733 ValaConstant* _tmp2_;
734 gboolean result = FALSE;
735 self = (ValaMemberAccess*) base;
736 _tmp0_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
737 _tmp1_ = _tmp0_;
738 c = VALA_IS_CONSTANT (_tmp1_) ? ((ValaConstant*) _tmp1_) : NULL;
739 _tmp2_ = c;
740 if (_tmp2_ != NULL) {
741 gboolean _tmp3_ = FALSE;
742 ValaConstant* _tmp4_;
743 _tmp4_ = c;
744 if (VALA_IS_ENUM_VALUE (_tmp4_)) {
745 _tmp3_ = TRUE;
746 } else {
747 ValaConstant* _tmp5_;
748 ValaDataType* _tmp6_;
749 ValaDataType* _tmp7_;
750 gboolean _tmp8_;
751 gboolean _tmp9_;
752 _tmp5_ = c;
753 _tmp6_ = vala_constant_get_type_reference (_tmp5_);
754 _tmp7_ = _tmp6_;
755 _tmp8_ = vala_data_type_get_nullable (_tmp7_);
756 _tmp9_ = _tmp8_;
757 _tmp3_ = !_tmp9_;
758 }
759 result = _tmp3_;
760 return result;
761 } else {
762 result = FALSE;
763 return result;
764 }
765 }
766
767 static void
vala_member_access_real_get_error_types(ValaCodeNode * base,ValaCollection * collection,ValaSourceReference * source_reference)768 vala_member_access_real_get_error_types (ValaCodeNode* base,
769 ValaCollection* collection,
770 ValaSourceReference* source_reference)
771 {
772 ValaMemberAccess * self;
773 ValaExpression* _tmp0_;
774 ValaExpression* _tmp1_;
775 self = (ValaMemberAccess*) base;
776 g_return_if_fail (collection != NULL);
777 _tmp0_ = vala_member_access_get_inner (self);
778 _tmp1_ = _tmp0_;
779 if (_tmp1_ != NULL) {
780 ValaExpression* _tmp2_;
781 ValaExpression* _tmp3_;
782 _tmp2_ = vala_member_access_get_inner (self);
783 _tmp3_ = _tmp2_;
784 vala_code_node_get_error_types ((ValaCodeNode*) _tmp3_, collection, source_reference);
785 }
786 }
787
788 static gboolean
vala_member_access_real_check(ValaCodeNode * base,ValaCodeContext * context)789 vala_member_access_real_check (ValaCodeNode* base,
790 ValaCodeContext* context)
791 {
792 ValaMemberAccess * self;
793 gboolean _tmp0_;
794 gboolean _tmp1_;
795 ValaExpression* _tmp4_;
796 ValaExpression* _tmp5_;
797 ValaSymbol* base_symbol = NULL;
798 ValaParameter* this_parameter = NULL;
799 gboolean may_access_instance_members = FALSE;
800 gboolean may_access_klass_members = FALSE;
801 gboolean _tmp18_;
802 gboolean _tmp622_ = FALSE;
803 gboolean _tmp623_ = FALSE;
804 gboolean _tmp624_ = FALSE;
805 ValaExpression* _tmp625_;
806 ValaExpression* _tmp626_;
807 ValaSymbol* _tmp654_;
808 ValaSymbol* _tmp655_;
809 ValaSymbol* _tmp709_;
810 ValaSymbol* _tmp710_;
811 ValaSymbol* member = NULL;
812 ValaSymbol* _tmp748_;
813 ValaSymbol* _tmp749_;
814 ValaSymbolAccessibility access = 0;
815 gboolean instance = FALSE;
816 gboolean klass = FALSE;
817 gboolean generics = FALSE;
818 ValaSymbol* _tmp750_;
819 ValaSymbol* _tmp751_;
820 ValaCodeNode* parent = NULL;
821 ValaCodeNode* _tmp1214_;
822 ValaSymbol* _tmp1215_;
823 ValaSymbol* _tmp1217_;
824 ValaVersionAttribute* _tmp1218_;
825 ValaVersionAttribute* _tmp1219_;
826 ValaSourceReference* _tmp1220_;
827 ValaSourceReference* _tmp1221_;
828 gboolean _tmp1222_ = FALSE;
829 ValaSymbolAccessibility _tmp1223_;
830 gboolean _tmp1279_ = FALSE;
831 gboolean _tmp1306_ = FALSE;
832 gboolean _tmp1307_ = FALSE;
833 ValaDataType* _tmp1587_;
834 ValaDataType* _tmp1588_;
835 gboolean _tmp1591_;
836 gboolean _tmp1592_;
837 gboolean _tmp1593_;
838 gboolean result = FALSE;
839 self = (ValaMemberAccess*) base;
840 g_return_val_if_fail (context != NULL, FALSE);
841 _tmp0_ = vala_code_node_get_checked ((ValaCodeNode*) self);
842 _tmp1_ = _tmp0_;
843 if (_tmp1_) {
844 gboolean _tmp2_;
845 gboolean _tmp3_;
846 _tmp2_ = vala_code_node_get_error ((ValaCodeNode*) self);
847 _tmp3_ = _tmp2_;
848 result = !_tmp3_;
849 return result;
850 }
851 vala_code_node_set_checked ((ValaCodeNode*) self, TRUE);
852 _tmp4_ = vala_member_access_get_inner (self);
853 _tmp5_ = _tmp4_;
854 if (_tmp5_ != NULL) {
855 ValaExpression* _tmp6_;
856 ValaExpression* _tmp7_;
857 _tmp6_ = vala_member_access_get_inner (self);
858 _tmp7_ = _tmp6_;
859 vala_code_node_check ((ValaCodeNode*) _tmp7_, context);
860 }
861 {
862 ValaList* _type_arg_list = NULL;
863 ValaList* _tmp8_;
864 ValaList* _tmp9_;
865 gint _type_arg_size = 0;
866 ValaList* _tmp10_;
867 gint _tmp11_;
868 gint _tmp12_;
869 gint _type_arg_index = 0;
870 _tmp8_ = self->priv->type_argument_list;
871 _tmp9_ = _vala_iterable_ref0 (_tmp8_);
872 _type_arg_list = _tmp9_;
873 _tmp10_ = _type_arg_list;
874 _tmp11_ = vala_collection_get_size ((ValaCollection*) _tmp10_);
875 _tmp12_ = _tmp11_;
876 _type_arg_size = _tmp12_;
877 _type_arg_index = -1;
878 while (TRUE) {
879 gint _tmp13_;
880 gint _tmp14_;
881 ValaDataType* type_arg = NULL;
882 ValaList* _tmp15_;
883 gpointer _tmp16_;
884 ValaDataType* _tmp17_;
885 _type_arg_index = _type_arg_index + 1;
886 _tmp13_ = _type_arg_index;
887 _tmp14_ = _type_arg_size;
888 if (!(_tmp13_ < _tmp14_)) {
889 break;
890 }
891 _tmp15_ = _type_arg_list;
892 _tmp16_ = vala_list_get (_tmp15_, _type_arg_index);
893 type_arg = (ValaDataType*) _tmp16_;
894 _tmp17_ = type_arg;
895 vala_code_node_check ((ValaCodeNode*) _tmp17_, context);
896 _vala_code_node_unref0 (type_arg);
897 }
898 _vala_iterable_unref0 (_type_arg_list);
899 }
900 base_symbol = NULL;
901 this_parameter = NULL;
902 may_access_instance_members = FALSE;
903 may_access_klass_members = FALSE;
904 vala_expression_set_symbol_reference ((ValaExpression*) self, NULL);
905 _tmp18_ = self->priv->_qualified;
906 if (_tmp18_) {
907 ValaNamespace* _tmp19_;
908 ValaNamespace* _tmp20_;
909 ValaSymbol* _tmp21_;
910 ValaScope* _tmp22_;
911 ValaScope* _tmp23_;
912 const gchar* _tmp24_;
913 ValaSymbol* _tmp25_;
914 ValaSymbol* _tmp26_;
915 _tmp19_ = vala_code_context_get_root (context);
916 _tmp20_ = _tmp19_;
917 base_symbol = (ValaSymbol*) _tmp20_;
918 _tmp21_ = base_symbol;
919 _tmp22_ = vala_symbol_get_scope (_tmp21_);
920 _tmp23_ = _tmp22_;
921 _tmp24_ = self->priv->_member_name;
922 _tmp25_ = vala_scope_lookup (_tmp23_, _tmp24_);
923 _tmp26_ = _tmp25_;
924 vala_expression_set_symbol_reference ((ValaExpression*) self, _tmp26_);
925 _vala_code_node_unref0 (_tmp26_);
926 } else {
927 ValaExpression* _tmp27_;
928 ValaExpression* _tmp28_;
929 _tmp27_ = vala_member_access_get_inner (self);
930 _tmp28_ = _tmp27_;
931 if (_tmp28_ == NULL) {
932 const gchar* _tmp29_;
933 ValaSemanticAnalyzer* _tmp34_;
934 ValaSemanticAnalyzer* _tmp35_;
935 ValaSymbol* _tmp36_;
936 ValaSymbol* _tmp37_;
937 gboolean method_found = FALSE;
938 ValaSymbol* sym = NULL;
939 ValaSemanticAnalyzer* _tmp38_;
940 ValaSemanticAnalyzer* _tmp39_;
941 ValaSymbol* _tmp40_;
942 ValaSymbol* _tmp41_;
943 gboolean _tmp140_ = FALSE;
944 ValaSymbol* _tmp141_;
945 ValaSymbol* _tmp142_;
946 _tmp29_ = self->priv->_member_name;
947 if (g_strcmp0 (_tmp29_, "this") == 0) {
948 ValaSemanticAnalyzer* _tmp30_;
949 ValaSemanticAnalyzer* _tmp31_;
950 _tmp30_ = vala_code_context_get_analyzer (context);
951 _tmp31_ = _tmp30_;
952 if (!vala_semantic_analyzer_is_in_instance_method (_tmp31_)) {
953 ValaSourceReference* _tmp32_;
954 ValaSourceReference* _tmp33_;
955 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
956 _tmp32_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
957 _tmp33_ = _tmp32_;
958 vala_report_error (_tmp33_, "This access invalid outside of instance methods");
959 result = FALSE;
960 return result;
961 }
962 }
963 _tmp34_ = vala_code_context_get_analyzer (context);
964 _tmp35_ = _tmp34_;
965 _tmp36_ = vala_semantic_analyzer_get_current_symbol (_tmp35_);
966 _tmp37_ = _tmp36_;
967 base_symbol = _tmp37_;
968 method_found = FALSE;
969 _tmp38_ = vala_code_context_get_analyzer (context);
970 _tmp39_ = _tmp38_;
971 _tmp40_ = vala_semantic_analyzer_get_current_symbol (_tmp39_);
972 _tmp41_ = _tmp40_;
973 sym = _tmp41_;
974 while (TRUE) {
975 gboolean _tmp42_ = FALSE;
976 ValaSymbol* _tmp43_;
977 ValaSymbol* _tmp89_;
978 const gchar* _tmp90_;
979 ValaSymbol* _tmp91_;
980 ValaSymbol* _tmp92_;
981 gboolean _tmp93_ = FALSE;
982 gboolean _tmp94_ = FALSE;
983 ValaSymbol* _tmp95_;
984 ValaSymbol* _tmp96_;
985 ValaSymbol* _tmp134_;
986 ValaSymbol* _tmp135_;
987 ValaSymbol* _tmp137_;
988 ValaSymbol* _tmp138_;
989 ValaSymbol* _tmp139_;
990 _tmp43_ = sym;
991 if (_tmp43_ != NULL) {
992 ValaSymbol* _tmp44_;
993 ValaSymbol* _tmp45_;
994 _tmp44_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
995 _tmp45_ = _tmp44_;
996 _tmp42_ = _tmp45_ == NULL;
997 } else {
998 _tmp42_ = FALSE;
999 }
1000 if (!_tmp42_) {
1001 break;
1002 }
1003 if (!method_found) {
1004 ValaSymbol* _tmp46_;
1005 _tmp46_ = sym;
1006 if (VALA_IS_CREATION_METHOD (_tmp46_)) {
1007 ValaCreationMethod* cm = NULL;
1008 ValaSymbol* _tmp47_;
1009 ValaCreationMethod* _tmp48_;
1010 ValaParameter* _tmp49_;
1011 ValaParameter* _tmp50_;
1012 _tmp47_ = sym;
1013 cm = G_TYPE_CHECK_INSTANCE_CAST (_tmp47_, VALA_TYPE_CREATION_METHOD, ValaCreationMethod);
1014 _tmp48_ = cm;
1015 _tmp49_ = vala_method_get_this_parameter ((ValaMethod*) _tmp48_);
1016 _tmp50_ = _tmp49_;
1017 this_parameter = _tmp50_;
1018 may_access_instance_members = TRUE;
1019 may_access_klass_members = TRUE;
1020 method_found = TRUE;
1021 } else {
1022 ValaSymbol* _tmp51_;
1023 _tmp51_ = sym;
1024 if (VALA_IS_PROPERTY (_tmp51_)) {
1025 ValaProperty* prop = NULL;
1026 ValaSymbol* _tmp52_;
1027 ValaProperty* _tmp53_;
1028 ValaParameter* _tmp54_;
1029 ValaParameter* _tmp55_;
1030 ValaProperty* _tmp56_;
1031 ValaMemberBinding _tmp57_;
1032 ValaMemberBinding _tmp58_;
1033 ValaProperty* _tmp59_;
1034 ValaMemberBinding _tmp60_;
1035 ValaMemberBinding _tmp61_;
1036 _tmp52_ = sym;
1037 prop = G_TYPE_CHECK_INSTANCE_CAST (_tmp52_, VALA_TYPE_PROPERTY, ValaProperty);
1038 _tmp53_ = prop;
1039 _tmp54_ = vala_property_get_this_parameter (_tmp53_);
1040 _tmp55_ = _tmp54_;
1041 this_parameter = _tmp55_;
1042 _tmp56_ = prop;
1043 _tmp57_ = vala_property_get_binding (_tmp56_);
1044 _tmp58_ = _tmp57_;
1045 may_access_instance_members = _tmp58_ == VALA_MEMBER_BINDING_INSTANCE;
1046 _tmp59_ = prop;
1047 _tmp60_ = vala_property_get_binding (_tmp59_);
1048 _tmp61_ = _tmp60_;
1049 may_access_klass_members = _tmp61_ != VALA_MEMBER_BINDING_STATIC;
1050 method_found = TRUE;
1051 } else {
1052 ValaSymbol* _tmp62_;
1053 _tmp62_ = sym;
1054 if (VALA_IS_CONSTRUCTOR (_tmp62_)) {
1055 ValaConstructor* c = NULL;
1056 ValaSymbol* _tmp63_;
1057 ValaConstructor* _tmp64_;
1058 ValaParameter* _tmp65_;
1059 ValaParameter* _tmp66_;
1060 ValaConstructor* _tmp67_;
1061 ValaMemberBinding _tmp68_;
1062 ValaMemberBinding _tmp69_;
1063 _tmp63_ = sym;
1064 c = G_TYPE_CHECK_INSTANCE_CAST (_tmp63_, VALA_TYPE_CONSTRUCTOR, ValaConstructor);
1065 _tmp64_ = c;
1066 _tmp65_ = vala_constructor_get_this_parameter (_tmp64_);
1067 _tmp66_ = _tmp65_;
1068 this_parameter = _tmp66_;
1069 _tmp67_ = c;
1070 _tmp68_ = vala_constructor_get_binding (_tmp67_);
1071 _tmp69_ = _tmp68_;
1072 may_access_instance_members = _tmp69_ == VALA_MEMBER_BINDING_INSTANCE;
1073 may_access_klass_members = TRUE;
1074 method_found = TRUE;
1075 } else {
1076 ValaSymbol* _tmp70_;
1077 _tmp70_ = sym;
1078 if (VALA_IS_DESTRUCTOR (_tmp70_)) {
1079 ValaDestructor* d = NULL;
1080 ValaSymbol* _tmp71_;
1081 ValaDestructor* _tmp72_;
1082 ValaParameter* _tmp73_;
1083 ValaParameter* _tmp74_;
1084 ValaDestructor* _tmp75_;
1085 ValaMemberBinding _tmp76_;
1086 ValaMemberBinding _tmp77_;
1087 _tmp71_ = sym;
1088 d = G_TYPE_CHECK_INSTANCE_CAST (_tmp71_, VALA_TYPE_DESTRUCTOR, ValaDestructor);
1089 _tmp72_ = d;
1090 _tmp73_ = vala_destructor_get_this_parameter (_tmp72_);
1091 _tmp74_ = _tmp73_;
1092 this_parameter = _tmp74_;
1093 _tmp75_ = d;
1094 _tmp76_ = vala_destructor_get_binding (_tmp75_);
1095 _tmp77_ = _tmp76_;
1096 may_access_instance_members = _tmp77_ == VALA_MEMBER_BINDING_INSTANCE;
1097 may_access_klass_members = TRUE;
1098 method_found = TRUE;
1099 } else {
1100 ValaSymbol* _tmp78_;
1101 _tmp78_ = sym;
1102 if (VALA_IS_METHOD (_tmp78_)) {
1103 ValaMethod* m = NULL;
1104 ValaSymbol* _tmp79_;
1105 ValaMethod* _tmp80_;
1106 ValaParameter* _tmp81_;
1107 ValaParameter* _tmp82_;
1108 ValaMethod* _tmp83_;
1109 ValaMemberBinding _tmp84_;
1110 ValaMemberBinding _tmp85_;
1111 ValaMethod* _tmp86_;
1112 ValaMemberBinding _tmp87_;
1113 ValaMemberBinding _tmp88_;
1114 _tmp79_ = sym;
1115 m = G_TYPE_CHECK_INSTANCE_CAST (_tmp79_, VALA_TYPE_METHOD, ValaMethod);
1116 _tmp80_ = m;
1117 _tmp81_ = vala_method_get_this_parameter (_tmp80_);
1118 _tmp82_ = _tmp81_;
1119 this_parameter = _tmp82_;
1120 _tmp83_ = m;
1121 _tmp84_ = vala_method_get_binding (_tmp83_);
1122 _tmp85_ = _tmp84_;
1123 may_access_instance_members = _tmp85_ == VALA_MEMBER_BINDING_INSTANCE;
1124 _tmp86_ = m;
1125 _tmp87_ = vala_method_get_binding (_tmp86_);
1126 _tmp88_ = _tmp87_;
1127 may_access_klass_members = _tmp88_ != VALA_MEMBER_BINDING_STATIC;
1128 method_found = TRUE;
1129 }
1130 }
1131 }
1132 }
1133 }
1134 }
1135 _tmp89_ = sym;
1136 _tmp90_ = self->priv->_member_name;
1137 _tmp91_ = vala_semantic_analyzer_symbol_lookup_inherited (_tmp89_, _tmp90_);
1138 _tmp92_ = _tmp91_;
1139 vala_expression_set_symbol_reference ((ValaExpression*) self, _tmp92_);
1140 _vala_code_node_unref0 (_tmp92_);
1141 _tmp95_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
1142 _tmp96_ = _tmp95_;
1143 if (_tmp96_ == NULL) {
1144 ValaSymbol* _tmp97_;
1145 _tmp97_ = sym;
1146 _tmp94_ = VALA_IS_TYPESYMBOL (_tmp97_);
1147 } else {
1148 _tmp94_ = FALSE;
1149 }
1150 if (_tmp94_) {
1151 _tmp93_ = may_access_instance_members;
1152 } else {
1153 _tmp93_ = FALSE;
1154 }
1155 if (_tmp93_) {
1156 ValaParameter* _tmp98_;
1157 ValaDataType* _tmp99_;
1158 ValaDataType* _tmp100_;
1159 const gchar* _tmp101_;
1160 ValaSymbol* _tmp102_;
1161 ValaSymbol* _tmp103_;
1162 gboolean _tmp104_ = FALSE;
1163 ValaSymbol* _tmp105_;
1164 ValaSymbol* _tmp106_;
1165 _tmp98_ = this_parameter;
1166 _tmp99_ = vala_variable_get_variable_type ((ValaVariable*) _tmp98_);
1167 _tmp100_ = _tmp99_;
1168 _tmp101_ = self->priv->_member_name;
1169 _tmp102_ = vala_data_type_get_member (_tmp100_, _tmp101_);
1170 _tmp103_ = _tmp102_;
1171 vala_expression_set_symbol_reference ((ValaExpression*) self, _tmp103_);
1172 _vala_code_node_unref0 (_tmp103_);
1173 _tmp105_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
1174 _tmp106_ = _tmp105_;
1175 if (_tmp106_ != NULL) {
1176 ValaSymbol* _tmp107_;
1177 ValaSymbol* _tmp108_;
1178 _tmp107_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
1179 _tmp108_ = _tmp107_;
1180 _tmp104_ = vala_member_access_is_instance_symbol (_tmp108_);
1181 } else {
1182 _tmp104_ = FALSE;
1183 }
1184 if (_tmp104_) {
1185 ValaSourceReference* _tmp109_;
1186 ValaSourceReference* _tmp110_;
1187 ValaMemberAccess* _tmp111_;
1188 ValaMemberAccess* _tmp112_;
1189 ValaExpression* _tmp113_;
1190 ValaExpression* _tmp114_;
1191 ValaParameter* _tmp115_;
1192 ValaDataType* _tmp116_;
1193 ValaDataType* _tmp117_;
1194 ValaDataType* _tmp118_;
1195 ValaDataType* _tmp119_;
1196 ValaExpression* _tmp120_;
1197 ValaExpression* _tmp121_;
1198 ValaDataType* _tmp122_;
1199 ValaDataType* _tmp123_;
1200 ValaExpression* _tmp124_;
1201 ValaExpression* _tmp125_;
1202 ValaParameter* _tmp126_;
1203 ValaExpression* _tmp127_;
1204 ValaExpression* _tmp128_;
1205 ValaDataType* _tmp129_;
1206 ValaDataType* _tmp130_;
1207 const gchar* _tmp131_;
1208 ValaSymbol* _tmp132_;
1209 ValaSymbol* _tmp133_;
1210 _tmp109_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
1211 _tmp110_ = _tmp109_;
1212 _tmp111_ = vala_member_access_new (NULL, "this", _tmp110_);
1213 _tmp112_ = _tmp111_;
1214 vala_member_access_set_inner (self, (ValaExpression*) _tmp112_);
1215 _vala_code_node_unref0 (_tmp112_);
1216 _tmp113_ = vala_member_access_get_inner (self);
1217 _tmp114_ = _tmp113_;
1218 _tmp115_ = this_parameter;
1219 _tmp116_ = vala_variable_get_variable_type ((ValaVariable*) _tmp115_);
1220 _tmp117_ = _tmp116_;
1221 _tmp118_ = vala_data_type_copy (_tmp117_);
1222 _tmp119_ = _tmp118_;
1223 vala_expression_set_value_type (_tmp114_, _tmp119_);
1224 _vala_code_node_unref0 (_tmp119_);
1225 _tmp120_ = vala_member_access_get_inner (self);
1226 _tmp121_ = _tmp120_;
1227 _tmp122_ = vala_expression_get_value_type (_tmp121_);
1228 _tmp123_ = _tmp122_;
1229 vala_data_type_set_value_owned (_tmp123_, FALSE);
1230 _tmp124_ = vala_member_access_get_inner (self);
1231 _tmp125_ = _tmp124_;
1232 _tmp126_ = this_parameter;
1233 vala_expression_set_symbol_reference (_tmp125_, (ValaSymbol*) _tmp126_);
1234 _tmp127_ = vala_member_access_get_inner (self);
1235 _tmp128_ = _tmp127_;
1236 _tmp129_ = vala_expression_get_value_type (_tmp128_);
1237 _tmp130_ = _tmp129_;
1238 _tmp131_ = self->priv->_member_name;
1239 _tmp132_ = vala_data_type_get_member (_tmp130_, _tmp131_);
1240 _tmp133_ = _tmp132_;
1241 vala_expression_set_symbol_reference ((ValaExpression*) self, _tmp133_);
1242 _vala_code_node_unref0 (_tmp133_);
1243 }
1244 }
1245 _tmp134_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
1246 _tmp135_ = _tmp134_;
1247 if (_tmp135_ == NULL) {
1248 ValaSymbol* _tmp136_;
1249 _tmp136_ = sym;
1250 if (VALA_IS_TYPESYMBOL (_tmp136_)) {
1251 this_parameter = NULL;
1252 may_access_instance_members = FALSE;
1253 may_access_klass_members = FALSE;
1254 }
1255 }
1256 _tmp137_ = sym;
1257 _tmp138_ = vala_symbol_get_parent_symbol (_tmp137_);
1258 _tmp139_ = _tmp138_;
1259 sym = _tmp139_;
1260 }
1261 _tmp141_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
1262 _tmp142_ = _tmp141_;
1263 if (_tmp142_ == NULL) {
1264 ValaSourceReference* _tmp143_;
1265 ValaSourceReference* _tmp144_;
1266 _tmp143_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
1267 _tmp144_ = _tmp143_;
1268 _tmp140_ = _tmp144_ != NULL;
1269 } else {
1270 _tmp140_ = FALSE;
1271 }
1272 if (_tmp140_) {
1273 {
1274 ValaList* _ns_list = NULL;
1275 ValaSourceReference* _tmp145_;
1276 ValaSourceReference* _tmp146_;
1277 ValaList* _tmp147_;
1278 ValaList* _tmp148_;
1279 ValaList* _tmp149_;
1280 gint _ns_size = 0;
1281 ValaList* _tmp150_;
1282 gint _tmp151_;
1283 gint _tmp152_;
1284 gint _ns_index = 0;
1285 _tmp145_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
1286 _tmp146_ = _tmp145_;
1287 _tmp147_ = vala_source_reference_get_using_directives (_tmp146_);
1288 _tmp148_ = _tmp147_;
1289 _tmp149_ = _vala_iterable_ref0 (_tmp148_);
1290 _ns_list = _tmp149_;
1291 _tmp150_ = _ns_list;
1292 _tmp151_ = vala_collection_get_size ((ValaCollection*) _tmp150_);
1293 _tmp152_ = _tmp151_;
1294 _ns_size = _tmp152_;
1295 _ns_index = -1;
1296 while (TRUE) {
1297 gint _tmp153_;
1298 gint _tmp154_;
1299 ValaUsingDirective* ns = NULL;
1300 ValaList* _tmp155_;
1301 gpointer _tmp156_;
1302 ValaUsingDirective* _tmp157_;
1303 gboolean _tmp158_;
1304 gboolean _tmp159_;
1305 ValaSymbol* local_sym = NULL;
1306 ValaUsingDirective* _tmp160_;
1307 ValaSymbol* _tmp161_;
1308 ValaSymbol* _tmp162_;
1309 ValaScope* _tmp163_;
1310 ValaScope* _tmp164_;
1311 const gchar* _tmp165_;
1312 ValaSymbol* _tmp166_;
1313 ValaSymbol* _tmp167_;
1314 _ns_index = _ns_index + 1;
1315 _tmp153_ = _ns_index;
1316 _tmp154_ = _ns_size;
1317 if (!(_tmp153_ < _tmp154_)) {
1318 break;
1319 }
1320 _tmp155_ = _ns_list;
1321 _tmp156_ = vala_list_get (_tmp155_, _ns_index);
1322 ns = (ValaUsingDirective*) _tmp156_;
1323 _tmp157_ = ns;
1324 _tmp158_ = vala_code_node_get_error ((ValaCodeNode*) _tmp157_);
1325 _tmp159_ = _tmp158_;
1326 if (_tmp159_) {
1327 _vala_code_node_unref0 (ns);
1328 continue;
1329 }
1330 _tmp160_ = ns;
1331 _tmp161_ = vala_using_directive_get_namespace_symbol (_tmp160_);
1332 _tmp162_ = _tmp161_;
1333 _tmp163_ = vala_symbol_get_scope (_tmp162_);
1334 _tmp164_ = _tmp163_;
1335 _tmp165_ = self->priv->_member_name;
1336 _tmp166_ = vala_scope_lookup (_tmp164_, _tmp165_);
1337 local_sym = _tmp166_;
1338 _tmp167_ = local_sym;
1339 if (_tmp167_ != NULL) {
1340 gboolean _tmp168_ = FALSE;
1341 ValaSymbol* _tmp169_;
1342 ValaSymbol* _tmp170_;
1343 ValaSymbol* inner_sym = NULL;
1344 ValaSymbol* _tmp186_;
1345 ValaSymbol* _tmp187_;
1346 ValaSymbol* _tmp188_;
1347 ValaMemberAccess* inner_ma = NULL;
1348 ValaMemberAccess* _tmp208_;
1349 ValaExpression* _tmp209_;
1350 ValaExpression* _tmp210_;
1351 ValaSymbol* _tmp211_;
1352 _tmp169_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
1353 _tmp170_ = _tmp169_;
1354 if (_tmp170_ != NULL) {
1355 ValaSymbol* _tmp171_;
1356 ValaSymbol* _tmp172_;
1357 ValaSymbol* _tmp173_;
1358 _tmp171_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
1359 _tmp172_ = _tmp171_;
1360 _tmp173_ = local_sym;
1361 _tmp168_ = _tmp172_ != _tmp173_;
1362 } else {
1363 _tmp168_ = FALSE;
1364 }
1365 if (_tmp168_) {
1366 ValaSourceReference* _tmp174_;
1367 ValaSourceReference* _tmp175_;
1368 const gchar* _tmp176_;
1369 ValaSymbol* _tmp177_;
1370 ValaSymbol* _tmp178_;
1371 gchar* _tmp179_;
1372 gchar* _tmp180_;
1373 ValaSymbol* _tmp181_;
1374 gchar* _tmp182_;
1375 gchar* _tmp183_;
1376 gchar* _tmp184_;
1377 gchar* _tmp185_;
1378 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
1379 _tmp174_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
1380 _tmp175_ = _tmp174_;
1381 _tmp176_ = self->priv->_member_name;
1382 _tmp177_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
1383 _tmp178_ = _tmp177_;
1384 _tmp179_ = vala_symbol_get_full_name (_tmp178_);
1385 _tmp180_ = _tmp179_;
1386 _tmp181_ = local_sym;
1387 _tmp182_ = vala_symbol_get_full_name (_tmp181_);
1388 _tmp183_ = _tmp182_;
1389 _tmp184_ = g_strdup_printf ("`%s' is an ambiguous reference between `%s' and `%s'", _tmp176_, _tmp180_, _tmp183_);
1390 _tmp185_ = _tmp184_;
1391 vala_report_error (_tmp175_, _tmp185_);
1392 _g_free0 (_tmp185_);
1393 _g_free0 (_tmp183_);
1394 _g_free0 (_tmp180_);
1395 result = FALSE;
1396 _vala_code_node_unref0 (local_sym);
1397 _vala_code_node_unref0 (ns);
1398 _vala_iterable_unref0 (_ns_list);
1399 return result;
1400 }
1401 _tmp186_ = local_sym;
1402 _tmp187_ = vala_symbol_get_parent_symbol (_tmp186_);
1403 _tmp188_ = _tmp187_;
1404 inner_sym = _tmp188_;
1405 inner_ma = self;
1406 while (TRUE) {
1407 gboolean _tmp189_ = FALSE;
1408 ValaSymbol* _tmp190_;
1409 ValaMemberAccess* _tmp194_;
1410 ValaSymbol* _tmp195_;
1411 const gchar* _tmp196_;
1412 const gchar* _tmp197_;
1413 ValaSourceReference* _tmp198_;
1414 ValaSourceReference* _tmp199_;
1415 ValaMemberAccess* _tmp200_;
1416 ValaMemberAccess* _tmp201_;
1417 ValaMemberAccess* _tmp202_;
1418 ValaExpression* _tmp203_;
1419 ValaExpression* _tmp204_;
1420 ValaSymbol* _tmp205_;
1421 ValaSymbol* _tmp206_;
1422 ValaSymbol* _tmp207_;
1423 _tmp190_ = inner_sym;
1424 if (_tmp190_ != NULL) {
1425 ValaSymbol* _tmp191_;
1426 const gchar* _tmp192_;
1427 const gchar* _tmp193_;
1428 _tmp191_ = inner_sym;
1429 _tmp192_ = vala_symbol_get_name (_tmp191_);
1430 _tmp193_ = _tmp192_;
1431 _tmp189_ = _tmp193_ != NULL;
1432 } else {
1433 _tmp189_ = FALSE;
1434 }
1435 if (!_tmp189_) {
1436 break;
1437 }
1438 _tmp194_ = inner_ma;
1439 _tmp195_ = inner_sym;
1440 _tmp196_ = vala_symbol_get_name (_tmp195_);
1441 _tmp197_ = _tmp196_;
1442 _tmp198_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
1443 _tmp199_ = _tmp198_;
1444 _tmp200_ = vala_member_access_new (NULL, _tmp197_, _tmp199_);
1445 _tmp201_ = _tmp200_;
1446 vala_member_access_set_inner (_tmp194_, (ValaExpression*) _tmp201_);
1447 _vala_code_node_unref0 (_tmp201_);
1448 _tmp202_ = inner_ma;
1449 _tmp203_ = vala_member_access_get_inner (_tmp202_);
1450 _tmp204_ = _tmp203_;
1451 inner_ma = G_TYPE_CHECK_INSTANCE_CAST (_tmp204_, VALA_TYPE_MEMBER_ACCESS, ValaMemberAccess);
1452 _tmp205_ = inner_sym;
1453 _tmp206_ = vala_symbol_get_parent_symbol (_tmp205_);
1454 _tmp207_ = _tmp206_;
1455 inner_sym = _tmp207_;
1456 }
1457 _tmp208_ = inner_ma;
1458 vala_member_access_set_qualified (_tmp208_, TRUE);
1459 _tmp209_ = vala_member_access_get_inner (self);
1460 _tmp210_ = _tmp209_;
1461 vala_code_node_check ((ValaCodeNode*) _tmp210_, context);
1462 _tmp211_ = local_sym;
1463 vala_expression_set_symbol_reference ((ValaExpression*) self, _tmp211_);
1464 }
1465 _vala_code_node_unref0 (local_sym);
1466 _vala_code_node_unref0 (ns);
1467 }
1468 _vala_iterable_unref0 (_ns_list);
1469 }
1470 }
1471 } else {
1472 ValaExpression* _tmp212_;
1473 ValaExpression* _tmp213_;
1474 gboolean _tmp214_;
1475 gboolean _tmp215_;
1476 ValaExpression* _tmp216_;
1477 ValaExpression* _tmp217_;
1478 ValaDataType* _tmp218_;
1479 ValaDataType* _tmp219_;
1480 ValaExpression* _tmp250_;
1481 ValaExpression* _tmp251_;
1482 gboolean _tmp266_ = FALSE;
1483 ValaExpression* _tmp267_;
1484 ValaExpression* _tmp268_;
1485 gboolean _tmp275_ = FALSE;
1486 ValaExpression* _tmp276_;
1487 ValaExpression* _tmp277_;
1488 gboolean _tmp298_ = FALSE;
1489 ValaExpression* _tmp299_;
1490 ValaExpression* _tmp300_;
1491 gboolean _tmp319_ = FALSE;
1492 ValaSymbol* _tmp320_;
1493 ValaSymbol* _tmp321_;
1494 gboolean _tmp355_ = FALSE;
1495 gboolean _tmp356_ = FALSE;
1496 ValaSymbol* _tmp357_;
1497 ValaSymbol* _tmp358_;
1498 gboolean _tmp593_ = FALSE;
1499 ValaSymbol* _tmp594_;
1500 ValaSymbol* _tmp595_;
1501 _tmp212_ = vala_member_access_get_inner (self);
1502 _tmp213_ = _tmp212_;
1503 _tmp214_ = vala_code_node_get_error ((ValaCodeNode*) _tmp213_);
1504 _tmp215_ = _tmp214_;
1505 if (_tmp215_) {
1506 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
1507 result = FALSE;
1508 return result;
1509 }
1510 _tmp216_ = vala_member_access_get_inner (self);
1511 _tmp217_ = _tmp216_;
1512 _tmp218_ = vala_expression_get_value_type (_tmp217_);
1513 _tmp219_ = _tmp218_;
1514 if (VALA_IS_POINTER_TYPE (_tmp219_)) {
1515 ValaPointerType* pointer_type = NULL;
1516 ValaExpression* _tmp220_;
1517 ValaExpression* _tmp221_;
1518 ValaDataType* _tmp222_;
1519 ValaDataType* _tmp223_;
1520 gboolean _tmp224_ = FALSE;
1521 ValaPointerType* _tmp225_;
1522 _tmp220_ = vala_member_access_get_inner (self);
1523 _tmp221_ = _tmp220_;
1524 _tmp222_ = vala_expression_get_value_type (_tmp221_);
1525 _tmp223_ = _tmp222_;
1526 pointer_type = VALA_IS_POINTER_TYPE (_tmp223_) ? ((ValaPointerType*) _tmp223_) : NULL;
1527 _tmp225_ = pointer_type;
1528 if (_tmp225_ != NULL) {
1529 ValaPointerType* _tmp226_;
1530 ValaDataType* _tmp227_;
1531 ValaDataType* _tmp228_;
1532 _tmp226_ = pointer_type;
1533 _tmp227_ = vala_pointer_type_get_base_type (_tmp226_);
1534 _tmp228_ = _tmp227_;
1535 _tmp224_ = VALA_IS_VALUE_TYPE (_tmp228_);
1536 } else {
1537 _tmp224_ = FALSE;
1538 }
1539 if (_tmp224_) {
1540 ValaExpression* _tmp229_;
1541 ValaExpression* _tmp230_;
1542 ValaDataType* _tmp231_;
1543 ValaDataType* _tmp232_;
1544 ValaExpression* _tmp242_;
1545 ValaExpression* _tmp243_;
1546 ValaSourceReference* _tmp244_;
1547 ValaSourceReference* _tmp245_;
1548 ValaPointerIndirection* _tmp246_;
1549 ValaPointerIndirection* _tmp247_;
1550 ValaExpression* _tmp248_;
1551 ValaExpression* _tmp249_;
1552 _tmp229_ = vala_member_access_get_inner (self);
1553 _tmp230_ = _tmp229_;
1554 _tmp231_ = vala_expression_get_formal_value_type (_tmp230_);
1555 _tmp232_ = _tmp231_;
1556 if (VALA_IS_GENERIC_TYPE (_tmp232_)) {
1557 ValaExpression* _tmp233_;
1558 ValaExpression* _tmp234_;
1559 ValaPointerType* _tmp235_;
1560 ValaDataType* _tmp236_;
1561 ValaDataType* _tmp237_;
1562 ValaSourceReference* _tmp238_;
1563 ValaSourceReference* _tmp239_;
1564 ValaCastExpression* _tmp240_;
1565 ValaCastExpression* _tmp241_;
1566 _tmp233_ = vala_member_access_get_inner (self);
1567 _tmp234_ = _tmp233_;
1568 _tmp235_ = pointer_type;
1569 _tmp236_ = vala_data_type_copy ((ValaDataType*) _tmp235_);
1570 _tmp237_ = _tmp236_;
1571 _tmp238_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
1572 _tmp239_ = _tmp238_;
1573 _tmp240_ = vala_cast_expression_new (_tmp234_, _tmp237_, _tmp239_);
1574 _tmp241_ = _tmp240_;
1575 vala_member_access_set_inner (self, (ValaExpression*) _tmp241_);
1576 _vala_code_node_unref0 (_tmp241_);
1577 _vala_code_node_unref0 (_tmp237_);
1578 }
1579 _tmp242_ = vala_member_access_get_inner (self);
1580 _tmp243_ = _tmp242_;
1581 _tmp244_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
1582 _tmp245_ = _tmp244_;
1583 _tmp246_ = vala_pointer_indirection_new (_tmp243_, _tmp245_);
1584 _tmp247_ = _tmp246_;
1585 vala_member_access_set_inner (self, (ValaExpression*) _tmp247_);
1586 _vala_code_node_unref0 (_tmp247_);
1587 _tmp248_ = vala_member_access_get_inner (self);
1588 _tmp249_ = _tmp248_;
1589 vala_code_node_check ((ValaCodeNode*) _tmp249_, context);
1590 vala_member_access_set_pointer_member_access (self, FALSE);
1591 }
1592 }
1593 _tmp250_ = vala_member_access_get_inner (self);
1594 _tmp251_ = _tmp250_;
1595 if (VALA_IS_MEMBER_ACCESS (_tmp251_)) {
1596 ValaMemberAccess* ma = NULL;
1597 ValaExpression* _tmp252_;
1598 ValaExpression* _tmp253_;
1599 ValaMemberAccess* _tmp254_;
1600 gboolean _tmp255_;
1601 _tmp252_ = vala_member_access_get_inner (self);
1602 _tmp253_ = _tmp252_;
1603 ma = G_TYPE_CHECK_INSTANCE_CAST (_tmp253_, VALA_TYPE_MEMBER_ACCESS, ValaMemberAccess);
1604 _tmp254_ = ma;
1605 _tmp255_ = _tmp254_->priv->_prototype_access;
1606 if (_tmp255_) {
1607 ValaSourceReference* _tmp256_;
1608 ValaSourceReference* _tmp257_;
1609 ValaExpression* _tmp258_;
1610 ValaExpression* _tmp259_;
1611 ValaSymbol* _tmp260_;
1612 ValaSymbol* _tmp261_;
1613 gchar* _tmp262_;
1614 gchar* _tmp263_;
1615 gchar* _tmp264_;
1616 gchar* _tmp265_;
1617 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
1618 _tmp256_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
1619 _tmp257_ = _tmp256_;
1620 _tmp258_ = vala_member_access_get_inner (self);
1621 _tmp259_ = _tmp258_;
1622 _tmp260_ = vala_expression_get_symbol_reference (_tmp259_);
1623 _tmp261_ = _tmp260_;
1624 _tmp262_ = vala_symbol_get_full_name (_tmp261_);
1625 _tmp263_ = _tmp262_;
1626 _tmp264_ = g_strdup_printf ("Access to instance member `%s' denied", _tmp263_);
1627 _tmp265_ = _tmp264_;
1628 vala_report_error (_tmp257_, _tmp265_);
1629 _g_free0 (_tmp265_);
1630 _g_free0 (_tmp263_);
1631 result = FALSE;
1632 return result;
1633 }
1634 }
1635 _tmp267_ = vala_member_access_get_inner (self);
1636 _tmp268_ = _tmp267_;
1637 if (VALA_IS_CAST_EXPRESSION (_tmp268_)) {
1638 ValaExpression* _tmp269_;
1639 ValaExpression* _tmp270_;
1640 gboolean _tmp271_;
1641 gboolean _tmp272_;
1642 _tmp269_ = vala_member_access_get_inner (self);
1643 _tmp270_ = _tmp269_;
1644 _tmp271_ = vala_cast_expression_get_is_silent_cast (G_TYPE_CHECK_INSTANCE_CAST (_tmp270_, VALA_TYPE_CAST_EXPRESSION, ValaCastExpression));
1645 _tmp272_ = _tmp271_;
1646 _tmp266_ = _tmp272_;
1647 } else {
1648 _tmp266_ = FALSE;
1649 }
1650 if (_tmp266_) {
1651 ValaSourceReference* _tmp273_;
1652 ValaSourceReference* _tmp274_;
1653 _tmp273_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
1654 _tmp274_ = _tmp273_;
1655 vala_report_warning (_tmp274_, "Access to possible `null'. Perform a check or use an unsafe cast.");
1656 }
1657 _tmp276_ = vala_member_access_get_inner (self);
1658 _tmp277_ = _tmp276_;
1659 if (VALA_IS_MEMBER_ACCESS (_tmp277_)) {
1660 _tmp275_ = TRUE;
1661 } else {
1662 ValaExpression* _tmp278_;
1663 ValaExpression* _tmp279_;
1664 _tmp278_ = vala_member_access_get_inner (self);
1665 _tmp279_ = _tmp278_;
1666 _tmp275_ = VALA_IS_BASE_ACCESS (_tmp279_);
1667 }
1668 if (_tmp275_) {
1669 ValaExpression* _tmp280_;
1670 ValaExpression* _tmp281_;
1671 ValaSymbol* _tmp282_;
1672 ValaSymbol* _tmp283_;
1673 gboolean _tmp284_ = FALSE;
1674 ValaSymbol* _tmp285_;
1675 ValaSymbol* _tmp286_;
1676 _tmp280_ = vala_member_access_get_inner (self);
1677 _tmp281_ = _tmp280_;
1678 _tmp282_ = vala_expression_get_symbol_reference (_tmp281_);
1679 _tmp283_ = _tmp282_;
1680 base_symbol = _tmp283_;
1681 _tmp285_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
1682 _tmp286_ = _tmp285_;
1683 if (_tmp286_ == NULL) {
1684 gboolean _tmp287_ = FALSE;
1685 ValaSymbol* _tmp288_;
1686 _tmp288_ = base_symbol;
1687 if (VALA_IS_NAMESPACE (_tmp288_)) {
1688 _tmp287_ = TRUE;
1689 } else {
1690 ValaSymbol* _tmp289_;
1691 _tmp289_ = base_symbol;
1692 _tmp287_ = VALA_IS_TYPESYMBOL (_tmp289_);
1693 }
1694 _tmp284_ = _tmp287_;
1695 } else {
1696 _tmp284_ = FALSE;
1697 }
1698 if (_tmp284_) {
1699 ValaSymbol* _tmp290_;
1700 ValaScope* _tmp291_;
1701 ValaScope* _tmp292_;
1702 const gchar* _tmp293_;
1703 ValaSymbol* _tmp294_;
1704 ValaSymbol* _tmp295_;
1705 ValaExpression* _tmp296_;
1706 ValaExpression* _tmp297_;
1707 _tmp290_ = base_symbol;
1708 _tmp291_ = vala_symbol_get_scope (_tmp290_);
1709 _tmp292_ = _tmp291_;
1710 _tmp293_ = self->priv->_member_name;
1711 _tmp294_ = vala_scope_lookup (_tmp292_, _tmp293_);
1712 _tmp295_ = _tmp294_;
1713 vala_expression_set_symbol_reference ((ValaExpression*) self, _tmp295_);
1714 _vala_code_node_unref0 (_tmp295_);
1715 _tmp296_ = vala_member_access_get_inner (self);
1716 _tmp297_ = _tmp296_;
1717 if (VALA_IS_BASE_ACCESS (_tmp297_)) {
1718 may_access_instance_members = TRUE;
1719 may_access_klass_members = TRUE;
1720 }
1721 }
1722 }
1723 _tmp299_ = vala_member_access_get_inner (self);
1724 _tmp300_ = _tmp299_;
1725 if (VALA_IS_MEMBER_ACCESS (_tmp300_)) {
1726 ValaExpression* _tmp301_;
1727 ValaExpression* _tmp302_;
1728 ValaSymbol* _tmp303_;
1729 ValaSymbol* _tmp304_;
1730 _tmp301_ = vala_member_access_get_inner (self);
1731 _tmp302_ = _tmp301_;
1732 _tmp303_ = vala_expression_get_symbol_reference (_tmp302_);
1733 _tmp304_ = _tmp303_;
1734 _tmp298_ = VALA_IS_TYPEPARAMETER (_tmp304_);
1735 } else {
1736 _tmp298_ = FALSE;
1737 }
1738 if (_tmp298_) {
1739 ValaExpression* _tmp305_;
1740 ValaExpression* _tmp306_;
1741 ValaExpression* _tmp307_;
1742 ValaExpression* _tmp308_;
1743 ValaSymbol* _tmp309_;
1744 ValaSymbol* _tmp310_;
1745 ValaGenericType* _tmp311_;
1746 ValaGenericType* _tmp312_;
1747 ValaExpression* _tmp313_;
1748 ValaExpression* _tmp314_;
1749 ValaDataType* _tmp315_;
1750 ValaDataType* _tmp316_;
1751 ValaSourceReference* _tmp317_;
1752 ValaSourceReference* _tmp318_;
1753 _tmp305_ = vala_member_access_get_inner (self);
1754 _tmp306_ = _tmp305_;
1755 _tmp307_ = vala_member_access_get_inner (self);
1756 _tmp308_ = _tmp307_;
1757 _tmp309_ = vala_expression_get_symbol_reference (_tmp308_);
1758 _tmp310_ = _tmp309_;
1759 _tmp311_ = vala_generic_type_new (G_TYPE_CHECK_INSTANCE_CAST (_tmp310_, VALA_TYPE_TYPEPARAMETER, ValaTypeParameter));
1760 _tmp312_ = _tmp311_;
1761 vala_expression_set_value_type (_tmp306_, (ValaDataType*) _tmp312_);
1762 _vala_code_node_unref0 (_tmp312_);
1763 _tmp313_ = vala_member_access_get_inner (self);
1764 _tmp314_ = _tmp313_;
1765 _tmp315_ = vala_expression_get_value_type (_tmp314_);
1766 _tmp316_ = _tmp315_;
1767 _tmp317_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
1768 _tmp318_ = _tmp317_;
1769 vala_code_node_set_source_reference ((ValaCodeNode*) _tmp316_, _tmp318_);
1770 }
1771 _tmp320_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
1772 _tmp321_ = _tmp320_;
1773 if (_tmp321_ == NULL) {
1774 ValaExpression* _tmp322_;
1775 ValaExpression* _tmp323_;
1776 ValaDataType* _tmp324_;
1777 ValaDataType* _tmp325_;
1778 _tmp322_ = vala_member_access_get_inner (self);
1779 _tmp323_ = _tmp322_;
1780 _tmp324_ = vala_expression_get_value_type (_tmp323_);
1781 _tmp325_ = _tmp324_;
1782 _tmp319_ = _tmp325_ != NULL;
1783 } else {
1784 _tmp319_ = FALSE;
1785 }
1786 if (_tmp319_) {
1787 gboolean _tmp326_;
1788 ValaSymbol* _tmp353_;
1789 ValaSymbol* _tmp354_;
1790 _tmp326_ = self->priv->_pointer_member_access;
1791 if (_tmp326_) {
1792 ValaExpression* _tmp327_;
1793 ValaExpression* _tmp328_;
1794 ValaDataType* _tmp329_;
1795 ValaDataType* _tmp330_;
1796 const gchar* _tmp331_;
1797 ValaSymbol* _tmp332_;
1798 ValaSymbol* _tmp333_;
1799 _tmp327_ = vala_member_access_get_inner (self);
1800 _tmp328_ = _tmp327_;
1801 _tmp329_ = vala_expression_get_value_type (_tmp328_);
1802 _tmp330_ = _tmp329_;
1803 _tmp331_ = self->priv->_member_name;
1804 _tmp332_ = vala_data_type_get_pointer_member (_tmp330_, _tmp331_);
1805 _tmp333_ = _tmp332_;
1806 vala_expression_set_symbol_reference ((ValaExpression*) self, _tmp333_);
1807 _vala_code_node_unref0 (_tmp333_);
1808 } else {
1809 ValaExpression* _tmp334_;
1810 ValaExpression* _tmp335_;
1811 ValaDataType* _tmp336_;
1812 ValaDataType* _tmp337_;
1813 ValaTypeSymbol* _tmp338_;
1814 ValaTypeSymbol* _tmp339_;
1815 ValaExpression* _tmp346_;
1816 ValaExpression* _tmp347_;
1817 ValaDataType* _tmp348_;
1818 ValaDataType* _tmp349_;
1819 const gchar* _tmp350_;
1820 ValaSymbol* _tmp351_;
1821 ValaSymbol* _tmp352_;
1822 _tmp334_ = vala_member_access_get_inner (self);
1823 _tmp335_ = _tmp334_;
1824 _tmp336_ = vala_expression_get_value_type (_tmp335_);
1825 _tmp337_ = _tmp336_;
1826 _tmp338_ = vala_data_type_get_type_symbol (_tmp337_);
1827 _tmp339_ = _tmp338_;
1828 if (_tmp339_ != NULL) {
1829 ValaExpression* _tmp340_;
1830 ValaExpression* _tmp341_;
1831 ValaDataType* _tmp342_;
1832 ValaDataType* _tmp343_;
1833 ValaTypeSymbol* _tmp344_;
1834 ValaTypeSymbol* _tmp345_;
1835 _tmp340_ = vala_member_access_get_inner (self);
1836 _tmp341_ = _tmp340_;
1837 _tmp342_ = vala_expression_get_value_type (_tmp341_);
1838 _tmp343_ = _tmp342_;
1839 _tmp344_ = vala_data_type_get_type_symbol (_tmp343_);
1840 _tmp345_ = _tmp344_;
1841 base_symbol = (ValaSymbol*) _tmp345_;
1842 }
1843 _tmp346_ = vala_member_access_get_inner (self);
1844 _tmp347_ = _tmp346_;
1845 _tmp348_ = vala_expression_get_value_type (_tmp347_);
1846 _tmp349_ = _tmp348_;
1847 _tmp350_ = self->priv->_member_name;
1848 _tmp351_ = vala_data_type_get_member (_tmp349_, _tmp350_);
1849 _tmp352_ = _tmp351_;
1850 vala_expression_set_symbol_reference ((ValaExpression*) self, _tmp352_);
1851 _vala_code_node_unref0 (_tmp352_);
1852 }
1853 _tmp353_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
1854 _tmp354_ = _tmp353_;
1855 if (_tmp354_ != NULL) {
1856 may_access_instance_members = TRUE;
1857 may_access_klass_members = TRUE;
1858 }
1859 }
1860 _tmp357_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
1861 _tmp358_ = _tmp357_;
1862 if (_tmp358_ == NULL) {
1863 ValaExpression* _tmp359_;
1864 ValaExpression* _tmp360_;
1865 ValaDataType* _tmp361_;
1866 ValaDataType* _tmp362_;
1867 _tmp359_ = vala_member_access_get_inner (self);
1868 _tmp360_ = _tmp359_;
1869 _tmp361_ = vala_expression_get_value_type (_tmp360_);
1870 _tmp362_ = _tmp361_;
1871 _tmp356_ = _tmp362_ != NULL;
1872 } else {
1873 _tmp356_ = FALSE;
1874 }
1875 if (_tmp356_) {
1876 ValaExpression* _tmp363_;
1877 ValaExpression* _tmp364_;
1878 ValaDataType* _tmp365_;
1879 ValaDataType* _tmp366_;
1880 gboolean _tmp367_;
1881 gboolean _tmp368_;
1882 _tmp363_ = vala_member_access_get_inner (self);
1883 _tmp364_ = _tmp363_;
1884 _tmp365_ = vala_expression_get_value_type (_tmp364_);
1885 _tmp366_ = _tmp365_;
1886 _tmp367_ = vala_data_type_get_is_dynamic (_tmp366_);
1887 _tmp368_ = _tmp367_;
1888 _tmp355_ = _tmp368_;
1889 } else {
1890 _tmp355_ = FALSE;
1891 }
1892 if (_tmp355_) {
1893 ValaObjectType* dynamic_object_type = NULL;
1894 ValaExpression* _tmp369_;
1895 ValaExpression* _tmp370_;
1896 ValaDataType* _tmp371_;
1897 ValaDataType* _tmp372_;
1898 ValaObjectType* _tmp373_;
1899 ValaCodeNode* _tmp374_;
1900 ValaCodeNode* _tmp375_;
1901 ValaSymbol* _tmp541_;
1902 ValaSymbol* _tmp542_;
1903 ValaSymbol* _tmp591_;
1904 ValaSymbol* _tmp592_;
1905 _tmp369_ = vala_member_access_get_inner (self);
1906 _tmp370_ = _tmp369_;
1907 _tmp371_ = vala_expression_get_value_type (_tmp370_);
1908 _tmp372_ = _tmp371_;
1909 _tmp373_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp372_, VALA_TYPE_OBJECT_TYPE, ValaObjectType));
1910 dynamic_object_type = _tmp373_;
1911 _tmp374_ = vala_code_node_get_parent_node ((ValaCodeNode*) self);
1912 _tmp375_ = _tmp374_;
1913 if (VALA_IS_METHOD_CALL (_tmp375_)) {
1914 ValaMethodCall* invoc = NULL;
1915 ValaCodeNode* _tmp376_;
1916 ValaCodeNode* _tmp377_;
1917 ValaMethodCall* _tmp378_;
1918 ValaExpression* _tmp379_;
1919 ValaExpression* _tmp380_;
1920 _tmp376_ = vala_code_node_get_parent_node ((ValaCodeNode*) self);
1921 _tmp377_ = _tmp376_;
1922 invoc = G_TYPE_CHECK_INSTANCE_CAST (_tmp377_, VALA_TYPE_METHOD_CALL, ValaMethodCall);
1923 _tmp378_ = invoc;
1924 _tmp379_ = vala_method_call_get_call (_tmp378_);
1925 _tmp380_ = _tmp379_;
1926 if (_tmp380_ == G_TYPE_CHECK_INSTANCE_CAST (self, VALA_TYPE_EXPRESSION, ValaExpression)) {
1927 ValaDataType* ret_type = NULL;
1928 ValaMethodCall* _tmp381_;
1929 ValaDataType* _tmp382_;
1930 ValaDataType* _tmp383_;
1931 ValaDynamicMethod* m = NULL;
1932 ValaExpression* _tmp398_;
1933 ValaExpression* _tmp399_;
1934 ValaDataType* _tmp400_;
1935 ValaDataType* _tmp401_;
1936 const gchar* _tmp402_;
1937 ValaDataType* _tmp403_;
1938 ValaSourceReference* _tmp404_;
1939 ValaSourceReference* _tmp405_;
1940 ValaDynamicMethod* _tmp406_;
1941 ValaDynamicMethod* _tmp407_;
1942 ValaMethodCall* _tmp408_;
1943 ValaErrorType* err = NULL;
1944 ValaErrorType* _tmp409_;
1945 ValaErrorType* _tmp410_;
1946 ValaDynamicMethod* _tmp411_;
1947 ValaErrorType* _tmp412_;
1948 ValaDynamicMethod* _tmp413_;
1949 ValaDynamicMethod* _tmp414_;
1950 ValaParameter* _tmp415_;
1951 ValaParameter* _tmp416_;
1952 ValaDynamicMethod* _tmp417_;
1953 ValaObjectType* _tmp418_;
1954 ValaDataType* _tmp419_;
1955 ValaDataType* _tmp420_;
1956 ValaDynamicMethod* _tmp421_;
1957 ValaSourceReference* _tmp422_;
1958 ValaSourceReference* _tmp423_;
1959 ValaParameter* _tmp424_;
1960 ValaParameter* _tmp425_;
1961 ValaObjectType* _tmp426_;
1962 ValaTypeSymbol* _tmp427_;
1963 ValaTypeSymbol* _tmp428_;
1964 ValaScope* _tmp429_;
1965 ValaScope* _tmp430_;
1966 ValaDynamicMethod* _tmp431_;
1967 ValaDynamicMethod* _tmp432_;
1968 _tmp381_ = invoc;
1969 _tmp382_ = vala_expression_get_target_type ((ValaExpression*) _tmp381_);
1970 _tmp383_ = _tmp382_;
1971 if (_tmp383_ != NULL) {
1972 ValaMethodCall* _tmp384_;
1973 ValaDataType* _tmp385_;
1974 ValaDataType* _tmp386_;
1975 ValaDataType* _tmp387_;
1976 ValaDataType* _tmp388_;
1977 _tmp384_ = invoc;
1978 _tmp385_ = vala_expression_get_target_type ((ValaExpression*) _tmp384_);
1979 _tmp386_ = _tmp385_;
1980 _tmp387_ = vala_data_type_copy (_tmp386_);
1981 _vala_code_node_unref0 (ret_type);
1982 ret_type = _tmp387_;
1983 _tmp388_ = ret_type;
1984 vala_data_type_set_value_owned (_tmp388_, TRUE);
1985 } else {
1986 ValaMethodCall* _tmp389_;
1987 ValaCodeNode* _tmp390_;
1988 ValaCodeNode* _tmp391_;
1989 _tmp389_ = invoc;
1990 _tmp390_ = vala_code_node_get_parent_node ((ValaCodeNode*) _tmp389_);
1991 _tmp391_ = _tmp390_;
1992 if (VALA_IS_EXPRESSION_STATEMENT (_tmp391_)) {
1993 ValaVoidType* _tmp392_;
1994 _tmp392_ = vala_void_type_new (NULL);
1995 _vala_code_node_unref0 (ret_type);
1996 ret_type = (ValaDataType*) _tmp392_;
1997 } else {
1998 ValaExpression* _tmp393_;
1999 ValaExpression* _tmp394_;
2000 ValaDataType* _tmp395_;
2001 ValaDataType* _tmp396_;
2002 ValaDataType* _tmp397_;
2003 _tmp393_ = vala_member_access_get_inner (self);
2004 _tmp394_ = _tmp393_;
2005 _tmp395_ = vala_expression_get_value_type (_tmp394_);
2006 _tmp396_ = _tmp395_;
2007 _tmp397_ = vala_data_type_copy (_tmp396_);
2008 _vala_code_node_unref0 (ret_type);
2009 ret_type = _tmp397_;
2010 }
2011 }
2012 _tmp398_ = vala_member_access_get_inner (self);
2013 _tmp399_ = _tmp398_;
2014 _tmp400_ = vala_expression_get_value_type (_tmp399_);
2015 _tmp401_ = _tmp400_;
2016 _tmp402_ = self->priv->_member_name;
2017 _tmp403_ = ret_type;
2018 _tmp404_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
2019 _tmp405_ = _tmp404_;
2020 _tmp406_ = vala_dynamic_method_new (_tmp401_, _tmp402_, _tmp403_, _tmp405_, NULL);
2021 m = _tmp406_;
2022 _tmp407_ = m;
2023 _tmp408_ = invoc;
2024 vala_dynamic_method_set_invocation (_tmp407_, _tmp408_);
2025 _tmp409_ = vala_error_type_new (NULL, NULL, NULL);
2026 err = _tmp409_;
2027 _tmp410_ = err;
2028 vala_error_type_set_dynamic_error (_tmp410_, TRUE);
2029 _tmp411_ = m;
2030 _tmp412_ = err;
2031 vala_method_add_error_type ((ValaMethod*) _tmp411_, (ValaDataType*) _tmp412_);
2032 _tmp413_ = m;
2033 vala_symbol_set_access ((ValaSymbol*) _tmp413_, VALA_SYMBOL_ACCESSIBILITY_PUBLIC);
2034 _tmp414_ = m;
2035 _tmp415_ = vala_parameter_new_with_ellipsis (NULL);
2036 _tmp416_ = _tmp415_;
2037 vala_callable_add_parameter ((ValaCallable*) _tmp414_, _tmp416_);
2038 _vala_code_node_unref0 (_tmp416_);
2039 _tmp417_ = m;
2040 _tmp418_ = dynamic_object_type;
2041 _tmp419_ = vala_data_type_copy ((ValaDataType*) _tmp418_);
2042 _tmp420_ = _tmp419_;
2043 _tmp421_ = m;
2044 _tmp422_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp421_);
2045 _tmp423_ = _tmp422_;
2046 _tmp424_ = vala_parameter_new ("this", _tmp420_, _tmp423_);
2047 _tmp425_ = _tmp424_;
2048 vala_method_set_this_parameter ((ValaMethod*) _tmp417_, _tmp425_);
2049 _vala_code_node_unref0 (_tmp425_);
2050 _vala_code_node_unref0 (_tmp420_);
2051 _tmp426_ = dynamic_object_type;
2052 _tmp427_ = vala_data_type_get_type_symbol ((ValaDataType*) _tmp426_);
2053 _tmp428_ = _tmp427_;
2054 _tmp429_ = vala_symbol_get_scope ((ValaSymbol*) _tmp428_);
2055 _tmp430_ = _tmp429_;
2056 _tmp431_ = m;
2057 vala_scope_add (_tmp430_, NULL, (ValaSymbol*) _tmp431_);
2058 _tmp432_ = m;
2059 vala_expression_set_symbol_reference ((ValaExpression*) self, (ValaSymbol*) _tmp432_);
2060 _vala_code_node_unref0 (err);
2061 _vala_code_node_unref0 (m);
2062 _vala_code_node_unref0 (ret_type);
2063 }
2064 } else {
2065 ValaCodeNode* _tmp433_;
2066 ValaCodeNode* _tmp434_;
2067 _tmp433_ = vala_code_node_get_parent_node ((ValaCodeNode*) self);
2068 _tmp434_ = _tmp433_;
2069 if (VALA_IS_ASSIGNMENT (_tmp434_)) {
2070 ValaAssignment* a = NULL;
2071 ValaCodeNode* _tmp435_;
2072 ValaCodeNode* _tmp436_;
2073 ValaAssignment* _tmp437_;
2074 ValaExpression* _tmp438_;
2075 ValaExpression* _tmp439_;
2076 _tmp435_ = vala_code_node_get_parent_node ((ValaCodeNode*) self);
2077 _tmp436_ = _tmp435_;
2078 a = G_TYPE_CHECK_INSTANCE_CAST (_tmp436_, VALA_TYPE_ASSIGNMENT, ValaAssignment);
2079 _tmp437_ = a;
2080 _tmp438_ = vala_assignment_get_left (_tmp437_);
2081 _tmp439_ = _tmp438_;
2082 if (_tmp439_ == G_TYPE_CHECK_INSTANCE_CAST (self, VALA_TYPE_EXPRESSION, ValaExpression)) {
2083 ValaDynamicProperty* prop = NULL;
2084 ValaExpression* _tmp440_;
2085 ValaExpression* _tmp441_;
2086 ValaDataType* _tmp442_;
2087 ValaDataType* _tmp443_;
2088 const gchar* _tmp444_;
2089 ValaSourceReference* _tmp445_;
2090 ValaSourceReference* _tmp446_;
2091 ValaDynamicProperty* _tmp447_;
2092 ValaDynamicProperty* _tmp448_;
2093 ValaDynamicProperty* _tmp449_;
2094 ValaDynamicProperty* _tmp450_;
2095 ValaSourceReference* _tmp451_;
2096 ValaSourceReference* _tmp452_;
2097 ValaPropertyAccessor* _tmp453_;
2098 ValaPropertyAccessor* _tmp454_;
2099 ValaDynamicProperty* _tmp455_;
2100 ValaExpression* _tmp456_;
2101 ValaExpression* _tmp457_;
2102 ValaDataType* _tmp458_;
2103 ValaDataType* _tmp459_;
2104 ValaTypeSymbol* _tmp460_;
2105 ValaTypeSymbol* _tmp461_;
2106 ValaScope* _tmp462_;
2107 ValaScope* _tmp463_;
2108 ValaObjectType* _tmp464_;
2109 ValaTypeSymbol* _tmp465_;
2110 ValaTypeSymbol* _tmp466_;
2111 ValaScope* _tmp467_;
2112 ValaScope* _tmp468_;
2113 ValaDynamicProperty* _tmp469_;
2114 ValaDynamicProperty* _tmp470_;
2115 _tmp440_ = vala_member_access_get_inner (self);
2116 _tmp441_ = _tmp440_;
2117 _tmp442_ = vala_expression_get_value_type (_tmp441_);
2118 _tmp443_ = _tmp442_;
2119 _tmp444_ = self->priv->_member_name;
2120 _tmp445_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
2121 _tmp446_ = _tmp445_;
2122 _tmp447_ = vala_dynamic_property_new (_tmp443_, _tmp444_, _tmp446_, NULL);
2123 prop = _tmp447_;
2124 _tmp448_ = prop;
2125 vala_symbol_set_access ((ValaSymbol*) _tmp448_, VALA_SYMBOL_ACCESSIBILITY_PUBLIC);
2126 _tmp449_ = prop;
2127 _tmp450_ = prop;
2128 _tmp451_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp450_);
2129 _tmp452_ = _tmp451_;
2130 _tmp453_ = vala_property_accessor_new (FALSE, TRUE, FALSE, NULL, NULL, _tmp452_, NULL);
2131 _tmp454_ = _tmp453_;
2132 vala_property_set_set_accessor ((ValaProperty*) _tmp449_, _tmp454_);
2133 _vala_code_node_unref0 (_tmp454_);
2134 _tmp455_ = prop;
2135 _tmp456_ = vala_member_access_get_inner (self);
2136 _tmp457_ = _tmp456_;
2137 _tmp458_ = vala_expression_get_value_type (_tmp457_);
2138 _tmp459_ = _tmp458_;
2139 _tmp460_ = vala_data_type_get_type_symbol (_tmp459_);
2140 _tmp461_ = _tmp460_;
2141 _tmp462_ = vala_symbol_get_scope ((ValaSymbol*) _tmp461_);
2142 _tmp463_ = _tmp462_;
2143 vala_symbol_set_owner ((ValaSymbol*) _tmp455_, _tmp463_);
2144 _tmp464_ = dynamic_object_type;
2145 _tmp465_ = vala_data_type_get_type_symbol ((ValaDataType*) _tmp464_);
2146 _tmp466_ = _tmp465_;
2147 _tmp467_ = vala_symbol_get_scope ((ValaSymbol*) _tmp466_);
2148 _tmp468_ = _tmp467_;
2149 _tmp469_ = prop;
2150 vala_scope_add (_tmp468_, NULL, (ValaSymbol*) _tmp469_);
2151 _tmp470_ = prop;
2152 vala_expression_set_symbol_reference ((ValaExpression*) self, (ValaSymbol*) _tmp470_);
2153 _vala_code_node_unref0 (prop);
2154 }
2155 } else {
2156 gboolean _tmp471_ = FALSE;
2157 gboolean _tmp472_ = FALSE;
2158 ValaCodeNode* _tmp473_;
2159 ValaCodeNode* _tmp474_;
2160 _tmp473_ = vala_code_node_get_parent_node ((ValaCodeNode*) self);
2161 _tmp474_ = _tmp473_;
2162 if (VALA_IS_MEMBER_ACCESS (_tmp474_)) {
2163 ValaExpression* _tmp475_;
2164 ValaExpression* _tmp476_;
2165 _tmp475_ = vala_member_access_get_inner (self);
2166 _tmp476_ = _tmp475_;
2167 _tmp472_ = VALA_IS_MEMBER_ACCESS (_tmp476_);
2168 } else {
2169 _tmp472_ = FALSE;
2170 }
2171 if (_tmp472_) {
2172 ValaCodeNode* _tmp477_;
2173 ValaCodeNode* _tmp478_;
2174 ValaCodeNode* _tmp479_;
2175 ValaCodeNode* _tmp480_;
2176 _tmp477_ = vala_code_node_get_parent_node ((ValaCodeNode*) self);
2177 _tmp478_ = _tmp477_;
2178 _tmp479_ = vala_code_node_get_parent_node (_tmp478_);
2179 _tmp480_ = _tmp479_;
2180 _tmp471_ = VALA_IS_METHOD_CALL (_tmp480_);
2181 } else {
2182 _tmp471_ = FALSE;
2183 }
2184 if (_tmp471_) {
2185 ValaMemberAccess* ma = NULL;
2186 ValaCodeNode* _tmp481_;
2187 ValaCodeNode* _tmp482_;
2188 gboolean _tmp483_ = FALSE;
2189 ValaMemberAccess* _tmp484_;
2190 const gchar* _tmp485_;
2191 _tmp481_ = vala_code_node_get_parent_node ((ValaCodeNode*) self);
2192 _tmp482_ = _tmp481_;
2193 ma = G_TYPE_CHECK_INSTANCE_CAST (_tmp482_, VALA_TYPE_MEMBER_ACCESS, ValaMemberAccess);
2194 _tmp484_ = ma;
2195 _tmp485_ = _tmp484_->priv->_member_name;
2196 if (g_strcmp0 (_tmp485_, "connect") == 0) {
2197 _tmp483_ = TRUE;
2198 } else {
2199 ValaMemberAccess* _tmp486_;
2200 const gchar* _tmp487_;
2201 _tmp486_ = ma;
2202 _tmp487_ = _tmp486_->priv->_member_name;
2203 _tmp483_ = g_strcmp0 (_tmp487_, "connect_after") == 0;
2204 }
2205 if (_tmp483_) {
2206 ValaDynamicSignal* s = NULL;
2207 ValaExpression* _tmp488_;
2208 ValaExpression* _tmp489_;
2209 ValaDataType* _tmp490_;
2210 ValaDataType* _tmp491_;
2211 const gchar* _tmp492_;
2212 ValaVoidType* _tmp493_;
2213 ValaVoidType* _tmp494_;
2214 ValaSourceReference* _tmp495_;
2215 ValaSourceReference* _tmp496_;
2216 ValaDynamicSignal* _tmp497_;
2217 ValaDynamicSignal* _tmp498_;
2218 ValaMethodCall* mcall = NULL;
2219 ValaCodeNode* _tmp499_;
2220 ValaCodeNode* _tmp500_;
2221 ValaCodeNode* _tmp501_;
2222 ValaCodeNode* _tmp502_;
2223 ValaMethodCall* _tmp503_;
2224 ValaMethodCall* _tmp504_;
2225 ValaList* _tmp505_;
2226 gint _tmp506_;
2227 gint _tmp507_;
2228 ValaDynamicSignal* _tmp533_;
2229 ValaObjectType* _tmp534_;
2230 ValaTypeSymbol* _tmp535_;
2231 ValaTypeSymbol* _tmp536_;
2232 ValaScope* _tmp537_;
2233 ValaScope* _tmp538_;
2234 ValaDynamicSignal* _tmp539_;
2235 ValaDynamicSignal* _tmp540_;
2236 _tmp488_ = vala_member_access_get_inner (self);
2237 _tmp489_ = _tmp488_;
2238 _tmp490_ = vala_expression_get_value_type (_tmp489_);
2239 _tmp491_ = _tmp490_;
2240 _tmp492_ = self->priv->_member_name;
2241 _tmp493_ = vala_void_type_new (NULL);
2242 _tmp494_ = _tmp493_;
2243 _tmp495_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
2244 _tmp496_ = _tmp495_;
2245 _tmp497_ = vala_dynamic_signal_new (_tmp491_, _tmp492_, (ValaDataType*) _tmp494_, _tmp496_, NULL);
2246 _tmp498_ = _tmp497_;
2247 _vala_code_node_unref0 (_tmp494_);
2248 s = _tmp498_;
2249 _tmp499_ = vala_code_node_get_parent_node ((ValaCodeNode*) self);
2250 _tmp500_ = _tmp499_;
2251 _tmp501_ = vala_code_node_get_parent_node (_tmp500_);
2252 _tmp502_ = _tmp501_;
2253 _tmp503_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp502_, VALA_TYPE_METHOD_CALL, ValaMethodCall));
2254 mcall = _tmp503_;
2255 _tmp504_ = mcall;
2256 _tmp505_ = vala_method_call_get_argument_list (_tmp504_);
2257 _tmp506_ = vala_collection_get_size ((ValaCollection*) _tmp505_);
2258 _tmp507_ = _tmp506_;
2259 if (_tmp507_ > 0) {
2260 ValaDynamicSignal* _tmp508_;
2261 ValaMethodCall* _tmp509_;
2262 ValaList* _tmp510_;
2263 gpointer _tmp511_;
2264 ValaExpression* _tmp512_;
2265 ValaMemberAccess* arg = NULL;
2266 ValaDynamicSignal* _tmp513_;
2267 ValaExpression* _tmp514_;
2268 ValaExpression* _tmp515_;
2269 gboolean _tmp516_ = FALSE;
2270 gboolean _tmp517_ = FALSE;
2271 ValaMemberAccess* _tmp518_;
2272 _tmp508_ = s;
2273 _tmp509_ = mcall;
2274 _tmp510_ = vala_method_call_get_argument_list (_tmp509_);
2275 _tmp511_ = vala_list_get (_tmp510_, 0);
2276 _tmp512_ = (ValaExpression*) _tmp511_;
2277 vala_dynamic_signal_set_handler (_tmp508_, _tmp512_);
2278 _vala_code_node_unref0 (_tmp512_);
2279 _tmp513_ = s;
2280 _tmp514_ = vala_dynamic_signal_get_handler (_tmp513_);
2281 _tmp515_ = _tmp514_;
2282 arg = VALA_IS_MEMBER_ACCESS (_tmp515_) ? ((ValaMemberAccess*) _tmp515_) : NULL;
2283 _tmp518_ = arg;
2284 if (_tmp518_ == NULL) {
2285 _tmp517_ = TRUE;
2286 } else {
2287 ValaMemberAccess* _tmp519_;
2288 _tmp519_ = arg;
2289 _tmp517_ = !vala_code_node_check ((ValaCodeNode*) _tmp519_, context);
2290 }
2291 if (_tmp517_) {
2292 _tmp516_ = TRUE;
2293 } else {
2294 ValaMemberAccess* _tmp520_;
2295 ValaSymbol* _tmp521_;
2296 ValaSymbol* _tmp522_;
2297 _tmp520_ = arg;
2298 _tmp521_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp520_);
2299 _tmp522_ = _tmp521_;
2300 _tmp516_ = !VALA_IS_METHOD (_tmp522_);
2301 }
2302 if (_tmp516_) {
2303 ValaDynamicSignal* _tmp523_;
2304 ValaExpression* _tmp524_;
2305 ValaExpression* _tmp525_;
2306 ValaSourceReference* _tmp526_;
2307 ValaSourceReference* _tmp527_;
2308 ValaDynamicSignal* _tmp528_;
2309 gchar* _tmp529_;
2310 gchar* _tmp530_;
2311 gchar* _tmp531_;
2312 gchar* _tmp532_;
2313 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
2314 _tmp523_ = s;
2315 _tmp524_ = vala_dynamic_signal_get_handler (_tmp523_);
2316 _tmp525_ = _tmp524_;
2317 _tmp526_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp525_);
2318 _tmp527_ = _tmp526_;
2319 _tmp528_ = s;
2320 _tmp529_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp528_);
2321 _tmp530_ = _tmp529_;
2322 _tmp531_ = g_strdup_printf ("Invalid handler for `%s'", _tmp530_);
2323 _tmp532_ = _tmp531_;
2324 vala_report_error (_tmp527_, _tmp532_);
2325 _g_free0 (_tmp532_);
2326 _g_free0 (_tmp530_);
2327 }
2328 }
2329 _tmp533_ = s;
2330 vala_symbol_set_access ((ValaSymbol*) _tmp533_, VALA_SYMBOL_ACCESSIBILITY_PUBLIC);
2331 _tmp534_ = dynamic_object_type;
2332 _tmp535_ = vala_data_type_get_type_symbol ((ValaDataType*) _tmp534_);
2333 _tmp536_ = _tmp535_;
2334 _tmp537_ = vala_symbol_get_scope ((ValaSymbol*) _tmp536_);
2335 _tmp538_ = _tmp537_;
2336 _tmp539_ = s;
2337 vala_scope_add (_tmp538_, NULL, (ValaSymbol*) _tmp539_);
2338 _tmp540_ = s;
2339 vala_expression_set_symbol_reference ((ValaExpression*) self, (ValaSymbol*) _tmp540_);
2340 _vala_code_node_unref0 (mcall);
2341 _vala_code_node_unref0 (s);
2342 }
2343 }
2344 }
2345 }
2346 _tmp541_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
2347 _tmp542_ = _tmp541_;
2348 if (_tmp542_ == NULL) {
2349 ValaDynamicProperty* prop = NULL;
2350 ValaExpression* _tmp543_;
2351 ValaExpression* _tmp544_;
2352 ValaDataType* _tmp545_;
2353 ValaDataType* _tmp546_;
2354 const gchar* _tmp547_;
2355 ValaSourceReference* _tmp548_;
2356 ValaSourceReference* _tmp549_;
2357 ValaDynamicProperty* _tmp550_;
2358 ValaDataType* _tmp551_;
2359 ValaDataType* _tmp552_;
2360 ValaDynamicProperty* _tmp563_;
2361 ValaDynamicProperty* _tmp564_;
2362 ValaDynamicProperty* _tmp565_;
2363 ValaDataType* _tmp566_;
2364 ValaDataType* _tmp567_;
2365 ValaDataType* _tmp568_;
2366 ValaDataType* _tmp569_;
2367 ValaDynamicProperty* _tmp570_;
2368 ValaSourceReference* _tmp571_;
2369 ValaSourceReference* _tmp572_;
2370 ValaPropertyAccessor* _tmp573_;
2371 ValaPropertyAccessor* _tmp574_;
2372 ValaDynamicProperty* _tmp575_;
2373 ValaExpression* _tmp576_;
2374 ValaExpression* _tmp577_;
2375 ValaDataType* _tmp578_;
2376 ValaDataType* _tmp579_;
2377 ValaTypeSymbol* _tmp580_;
2378 ValaTypeSymbol* _tmp581_;
2379 ValaScope* _tmp582_;
2380 ValaScope* _tmp583_;
2381 ValaObjectType* _tmp584_;
2382 ValaTypeSymbol* _tmp585_;
2383 ValaTypeSymbol* _tmp586_;
2384 ValaScope* _tmp587_;
2385 ValaScope* _tmp588_;
2386 ValaDynamicProperty* _tmp589_;
2387 ValaDynamicProperty* _tmp590_;
2388 _tmp543_ = vala_member_access_get_inner (self);
2389 _tmp544_ = _tmp543_;
2390 _tmp545_ = vala_expression_get_value_type (_tmp544_);
2391 _tmp546_ = _tmp545_;
2392 _tmp547_ = self->priv->_member_name;
2393 _tmp548_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
2394 _tmp549_ = _tmp548_;
2395 _tmp550_ = vala_dynamic_property_new (_tmp546_, _tmp547_, _tmp549_, NULL);
2396 prop = _tmp550_;
2397 _tmp551_ = vala_expression_get_target_type ((ValaExpression*) self);
2398 _tmp552_ = _tmp551_;
2399 if (_tmp552_ != NULL) {
2400 ValaDynamicProperty* _tmp553_;
2401 ValaDataType* _tmp554_;
2402 ValaDataType* _tmp555_;
2403 _tmp553_ = prop;
2404 _tmp554_ = vala_expression_get_target_type ((ValaExpression*) self);
2405 _tmp555_ = _tmp554_;
2406 vala_property_set_property_type ((ValaProperty*) _tmp553_, _tmp555_);
2407 } else {
2408 ValaDynamicProperty* _tmp556_;
2409 ValaExpression* _tmp557_;
2410 ValaExpression* _tmp558_;
2411 ValaDataType* _tmp559_;
2412 ValaDataType* _tmp560_;
2413 ValaDataType* _tmp561_;
2414 ValaDataType* _tmp562_;
2415 _tmp556_ = prop;
2416 _tmp557_ = vala_member_access_get_inner (self);
2417 _tmp558_ = _tmp557_;
2418 _tmp559_ = vala_expression_get_value_type (_tmp558_);
2419 _tmp560_ = _tmp559_;
2420 _tmp561_ = vala_data_type_copy (_tmp560_);
2421 _tmp562_ = _tmp561_;
2422 vala_property_set_property_type ((ValaProperty*) _tmp556_, _tmp562_);
2423 _vala_code_node_unref0 (_tmp562_);
2424 }
2425 _tmp563_ = prop;
2426 vala_symbol_set_access ((ValaSymbol*) _tmp563_, VALA_SYMBOL_ACCESSIBILITY_PUBLIC);
2427 _tmp564_ = prop;
2428 _tmp565_ = prop;
2429 _tmp566_ = vala_property_get_property_type ((ValaProperty*) _tmp565_);
2430 _tmp567_ = _tmp566_;
2431 _tmp568_ = vala_data_type_copy (_tmp567_);
2432 _tmp569_ = _tmp568_;
2433 _tmp570_ = prop;
2434 _tmp571_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp570_);
2435 _tmp572_ = _tmp571_;
2436 _tmp573_ = vala_property_accessor_new (TRUE, FALSE, FALSE, _tmp569_, NULL, _tmp572_, NULL);
2437 _tmp574_ = _tmp573_;
2438 vala_property_set_get_accessor ((ValaProperty*) _tmp564_, _tmp574_);
2439 _vala_code_node_unref0 (_tmp574_);
2440 _vala_code_node_unref0 (_tmp569_);
2441 _tmp575_ = prop;
2442 _tmp576_ = vala_member_access_get_inner (self);
2443 _tmp577_ = _tmp576_;
2444 _tmp578_ = vala_expression_get_value_type (_tmp577_);
2445 _tmp579_ = _tmp578_;
2446 _tmp580_ = vala_data_type_get_type_symbol (_tmp579_);
2447 _tmp581_ = _tmp580_;
2448 _tmp582_ = vala_symbol_get_scope ((ValaSymbol*) _tmp581_);
2449 _tmp583_ = _tmp582_;
2450 vala_symbol_set_owner ((ValaSymbol*) _tmp575_, _tmp583_);
2451 _tmp584_ = dynamic_object_type;
2452 _tmp585_ = vala_data_type_get_type_symbol ((ValaDataType*) _tmp584_);
2453 _tmp586_ = _tmp585_;
2454 _tmp587_ = vala_symbol_get_scope ((ValaSymbol*) _tmp586_);
2455 _tmp588_ = _tmp587_;
2456 _tmp589_ = prop;
2457 vala_scope_add (_tmp588_, NULL, (ValaSymbol*) _tmp589_);
2458 _tmp590_ = prop;
2459 vala_expression_set_symbol_reference ((ValaExpression*) self, (ValaSymbol*) _tmp590_);
2460 _vala_code_node_unref0 (prop);
2461 }
2462 _tmp591_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
2463 _tmp592_ = _tmp591_;
2464 if (_tmp592_ != NULL) {
2465 may_access_instance_members = TRUE;
2466 may_access_klass_members = TRUE;
2467 }
2468 _vala_code_node_unref0 (dynamic_object_type);
2469 }
2470 _tmp594_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
2471 _tmp595_ = _tmp594_;
2472 if (VALA_IS_ARRAY_RESIZE_METHOD (_tmp595_)) {
2473 ValaExpression* _tmp596_;
2474 ValaExpression* _tmp597_;
2475 ValaSymbol* _tmp598_;
2476 ValaSymbol* _tmp599_;
2477 _tmp596_ = vala_member_access_get_inner (self);
2478 _tmp597_ = _tmp596_;
2479 _tmp598_ = vala_expression_get_symbol_reference (_tmp597_);
2480 _tmp599_ = _tmp598_;
2481 _tmp593_ = VALA_IS_VARIABLE (_tmp599_);
2482 } else {
2483 _tmp593_ = FALSE;
2484 }
2485 if (_tmp593_) {
2486 ValaArrayType* inner_type = NULL;
2487 ValaSemanticAnalyzer* _tmp600_;
2488 ValaSemanticAnalyzer* _tmp601_;
2489 ValaExpression* _tmp602_;
2490 ValaExpression* _tmp603_;
2491 ValaSymbol* _tmp604_;
2492 ValaSymbol* _tmp605_;
2493 ValaDataType* _tmp606_;
2494 ValaArrayType* _tmp607_;
2495 gboolean _tmp608_ = FALSE;
2496 ValaArrayType* _tmp609_;
2497 _tmp600_ = vala_code_context_get_analyzer (context);
2498 _tmp601_ = _tmp600_;
2499 _tmp602_ = vala_member_access_get_inner (self);
2500 _tmp603_ = _tmp602_;
2501 _tmp604_ = vala_expression_get_symbol_reference (_tmp603_);
2502 _tmp605_ = _tmp604_;
2503 _tmp606_ = vala_semantic_analyzer_get_value_type_for_symbol (_tmp601_, _tmp605_, TRUE);
2504 _tmp607_ = VALA_IS_ARRAY_TYPE (_tmp606_) ? ((ValaArrayType*) _tmp606_) : NULL;
2505 if (_tmp607_ == NULL) {
2506 _vala_code_node_unref0 (_tmp606_);
2507 }
2508 inner_type = _tmp607_;
2509 _tmp609_ = inner_type;
2510 if (_tmp609_ != NULL) {
2511 ValaArrayType* _tmp610_;
2512 gboolean _tmp611_;
2513 gboolean _tmp612_;
2514 _tmp610_ = inner_type;
2515 _tmp611_ = vala_array_type_get_inline_allocated (_tmp610_);
2516 _tmp612_ = _tmp611_;
2517 _tmp608_ = _tmp612_;
2518 } else {
2519 _tmp608_ = FALSE;
2520 }
2521 if (_tmp608_) {
2522 ValaSourceReference* _tmp613_;
2523 ValaSourceReference* _tmp614_;
2524 _tmp613_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
2525 _tmp614_ = _tmp613_;
2526 vala_report_error (_tmp614_, "`resize' is not supported for arrays with fixed length");
2527 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
2528 } else {
2529 gboolean _tmp615_ = FALSE;
2530 ValaArrayType* _tmp616_;
2531 _tmp616_ = inner_type;
2532 if (_tmp616_ != NULL) {
2533 ValaArrayType* _tmp617_;
2534 gboolean _tmp618_;
2535 gboolean _tmp619_;
2536 _tmp617_ = inner_type;
2537 _tmp618_ = vala_data_type_get_value_owned ((ValaDataType*) _tmp617_);
2538 _tmp619_ = _tmp618_;
2539 _tmp615_ = !_tmp619_;
2540 } else {
2541 _tmp615_ = FALSE;
2542 }
2543 if (_tmp615_) {
2544 ValaSourceReference* _tmp620_;
2545 ValaSourceReference* _tmp621_;
2546 _tmp620_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
2547 _tmp621_ = _tmp620_;
2548 vala_report_error (_tmp621_, "`resize' is not allowed for unowned array references");
2549 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
2550 }
2551 }
2552 _vala_code_node_unref0 (inner_type);
2553 }
2554 }
2555 }
2556 _tmp625_ = vala_member_access_get_inner (self);
2557 _tmp626_ = _tmp625_;
2558 if (_tmp626_ == NULL) {
2559 ValaSymbol* _tmp627_;
2560 ValaSymbol* _tmp628_;
2561 _tmp627_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
2562 _tmp628_ = _tmp627_;
2563 _tmp624_ = _tmp628_ == NULL;
2564 } else {
2565 _tmp624_ = FALSE;
2566 }
2567 if (_tmp624_) {
2568 ValaDataType* _tmp629_;
2569 ValaDataType* _tmp630_;
2570 _tmp629_ = vala_expression_get_target_type ((ValaExpression*) self);
2571 _tmp630_ = _tmp629_;
2572 _tmp623_ = _tmp630_ != NULL;
2573 } else {
2574 _tmp623_ = FALSE;
2575 }
2576 if (_tmp623_) {
2577 ValaDataType* _tmp631_;
2578 ValaDataType* _tmp632_;
2579 ValaTypeSymbol* _tmp633_;
2580 ValaTypeSymbol* _tmp634_;
2581 _tmp631_ = vala_expression_get_target_type ((ValaExpression*) self);
2582 _tmp632_ = _tmp631_;
2583 _tmp633_ = vala_data_type_get_type_symbol (_tmp632_);
2584 _tmp634_ = _tmp633_;
2585 _tmp622_ = VALA_IS_ENUM (_tmp634_);
2586 } else {
2587 _tmp622_ = FALSE;
2588 }
2589 if (_tmp622_) {
2590 ValaEnum* enum_type = NULL;
2591 ValaDataType* _tmp635_;
2592 ValaDataType* _tmp636_;
2593 ValaTypeSymbol* _tmp637_;
2594 ValaTypeSymbol* _tmp638_;
2595 _tmp635_ = vala_expression_get_target_type ((ValaExpression*) self);
2596 _tmp636_ = _tmp635_;
2597 _tmp637_ = vala_data_type_get_type_symbol (_tmp636_);
2598 _tmp638_ = _tmp637_;
2599 enum_type = G_TYPE_CHECK_INSTANCE_CAST (_tmp638_, VALA_TYPE_ENUM, ValaEnum);
2600 {
2601 ValaList* _val_list = NULL;
2602 ValaEnum* _tmp639_;
2603 ValaList* _tmp640_;
2604 ValaList* _tmp641_;
2605 gint _val_size = 0;
2606 ValaList* _tmp642_;
2607 gint _tmp643_;
2608 gint _tmp644_;
2609 gint _val_index = 0;
2610 _tmp639_ = enum_type;
2611 _tmp640_ = vala_enum_get_values (_tmp639_);
2612 _tmp641_ = _vala_iterable_ref0 (_tmp640_);
2613 _val_list = _tmp641_;
2614 _tmp642_ = _val_list;
2615 _tmp643_ = vala_collection_get_size ((ValaCollection*) _tmp642_);
2616 _tmp644_ = _tmp643_;
2617 _val_size = _tmp644_;
2618 _val_index = -1;
2619 while (TRUE) {
2620 gint _tmp645_;
2621 gint _tmp646_;
2622 ValaEnumValue* val = NULL;
2623 ValaList* _tmp647_;
2624 gpointer _tmp648_;
2625 const gchar* _tmp649_;
2626 ValaEnumValue* _tmp650_;
2627 const gchar* _tmp651_;
2628 const gchar* _tmp652_;
2629 _val_index = _val_index + 1;
2630 _tmp645_ = _val_index;
2631 _tmp646_ = _val_size;
2632 if (!(_tmp645_ < _tmp646_)) {
2633 break;
2634 }
2635 _tmp647_ = _val_list;
2636 _tmp648_ = vala_list_get (_tmp647_, _val_index);
2637 val = (ValaEnumValue*) _tmp648_;
2638 _tmp649_ = self->priv->_member_name;
2639 _tmp650_ = val;
2640 _tmp651_ = vala_symbol_get_name ((ValaSymbol*) _tmp650_);
2641 _tmp652_ = _tmp651_;
2642 if (g_strcmp0 (_tmp649_, _tmp652_) == 0) {
2643 ValaEnumValue* _tmp653_;
2644 _tmp653_ = val;
2645 vala_expression_set_symbol_reference ((ValaExpression*) self, (ValaSymbol*) _tmp653_);
2646 _vala_code_node_unref0 (val);
2647 break;
2648 }
2649 _vala_code_node_unref0 (val);
2650 }
2651 _vala_iterable_unref0 (_val_list);
2652 }
2653 }
2654 _tmp654_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
2655 _tmp655_ = _tmp654_;
2656 if (_tmp655_ == NULL) {
2657 gchar* base_type_name = NULL;
2658 gchar* _tmp656_;
2659 ValaSymbol* base_type = NULL;
2660 gboolean _tmp657_ = FALSE;
2661 ValaExpression* _tmp658_;
2662 ValaExpression* _tmp659_;
2663 gchar* base_type_package = NULL;
2664 gchar* _tmp679_;
2665 gboolean _tmp680_ = FALSE;
2666 ValaSymbol* _tmp681_;
2667 ValaSourceReference* _tmp696_;
2668 ValaSourceReference* _tmp697_;
2669 const gchar* _tmp698_;
2670 const gchar* _tmp699_;
2671 const gchar* _tmp700_;
2672 gchar* _tmp701_;
2673 gchar* _tmp702_;
2674 ValaInvalidType* _tmp703_;
2675 ValaInvalidType* _tmp704_;
2676 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
2677 _tmp656_ = g_strdup ("(null)");
2678 base_type_name = _tmp656_;
2679 base_type = NULL;
2680 _tmp658_ = vala_member_access_get_inner (self);
2681 _tmp659_ = _tmp658_;
2682 if (_tmp659_ != NULL) {
2683 ValaExpression* _tmp660_;
2684 ValaExpression* _tmp661_;
2685 ValaDataType* _tmp662_;
2686 ValaDataType* _tmp663_;
2687 _tmp660_ = vala_member_access_get_inner (self);
2688 _tmp661_ = _tmp660_;
2689 _tmp662_ = vala_expression_get_value_type (_tmp661_);
2690 _tmp663_ = _tmp662_;
2691 _tmp657_ = _tmp663_ != NULL;
2692 } else {
2693 _tmp657_ = FALSE;
2694 }
2695 if (_tmp657_) {
2696 ValaExpression* _tmp664_;
2697 ValaExpression* _tmp665_;
2698 ValaDataType* _tmp666_;
2699 ValaDataType* _tmp667_;
2700 gchar* _tmp668_;
2701 ValaExpression* _tmp669_;
2702 ValaExpression* _tmp670_;
2703 ValaDataType* _tmp671_;
2704 ValaDataType* _tmp672_;
2705 ValaTypeSymbol* _tmp673_;
2706 ValaTypeSymbol* _tmp674_;
2707 _tmp664_ = vala_member_access_get_inner (self);
2708 _tmp665_ = _tmp664_;
2709 _tmp666_ = vala_expression_get_value_type (_tmp665_);
2710 _tmp667_ = _tmp666_;
2711 _tmp668_ = vala_code_node_to_string ((ValaCodeNode*) _tmp667_);
2712 _g_free0 (base_type_name);
2713 base_type_name = _tmp668_;
2714 _tmp669_ = vala_member_access_get_inner (self);
2715 _tmp670_ = _tmp669_;
2716 _tmp671_ = vala_expression_get_value_type (_tmp670_);
2717 _tmp672_ = _tmp671_;
2718 _tmp673_ = vala_data_type_get_type_symbol (_tmp672_);
2719 _tmp674_ = _tmp673_;
2720 base_type = (ValaSymbol*) _tmp674_;
2721 } else {
2722 ValaSymbol* _tmp675_;
2723 _tmp675_ = base_symbol;
2724 if (_tmp675_ != NULL) {
2725 ValaSymbol* _tmp676_;
2726 gchar* _tmp677_;
2727 ValaSymbol* _tmp678_;
2728 _tmp676_ = base_symbol;
2729 _tmp677_ = vala_symbol_get_full_name (_tmp676_);
2730 _g_free0 (base_type_name);
2731 base_type_name = _tmp677_;
2732 _tmp678_ = base_symbol;
2733 base_type = _tmp678_;
2734 }
2735 }
2736 _tmp679_ = g_strdup ("");
2737 base_type_package = _tmp679_;
2738 _tmp681_ = base_type;
2739 if (_tmp681_ != NULL) {
2740 ValaSymbol* _tmp682_;
2741 gboolean _tmp683_;
2742 gboolean _tmp684_;
2743 _tmp682_ = base_type;
2744 _tmp683_ = vala_symbol_get_external_package (_tmp682_);
2745 _tmp684_ = _tmp683_;
2746 _tmp680_ = _tmp684_;
2747 } else {
2748 _tmp680_ = FALSE;
2749 }
2750 if (_tmp680_) {
2751 ValaSymbol* _tmp685_;
2752 ValaSourceReference* _tmp686_;
2753 ValaSourceReference* _tmp687_;
2754 ValaSourceFile* _tmp688_;
2755 ValaSourceFile* _tmp689_;
2756 const gchar* _tmp690_;
2757 const gchar* _tmp691_;
2758 gchar* _tmp692_;
2759 const gchar* _tmp693_;
2760 _tmp685_ = base_symbol;
2761 _tmp686_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp685_);
2762 _tmp687_ = _tmp686_;
2763 _tmp688_ = vala_source_reference_get_file (_tmp687_);
2764 _tmp689_ = _tmp688_;
2765 _tmp690_ = vala_source_file_get_package_name (_tmp689_);
2766 _tmp691_ = _tmp690_;
2767 _tmp692_ = g_strdup (_tmp691_);
2768 _g_free0 (base_type_package);
2769 base_type_package = _tmp692_;
2770 _tmp693_ = base_type_package;
2771 if (_tmp693_ != NULL) {
2772 const gchar* _tmp694_;
2773 gchar* _tmp695_;
2774 _tmp694_ = base_type_package;
2775 _tmp695_ = g_strdup_printf (" (%s)", _tmp694_);
2776 _g_free0 (base_type_package);
2777 base_type_package = _tmp695_;
2778 }
2779 }
2780 _tmp696_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
2781 _tmp697_ = _tmp696_;
2782 _tmp698_ = self->priv->_member_name;
2783 _tmp699_ = base_type_name;
2784 _tmp700_ = base_type_package;
2785 _tmp701_ = g_strdup_printf ("The name `%s' does not exist in the context of `%s'%s", _tmp698_, _tmp699_, _tmp700_);
2786 _tmp702_ = _tmp701_;
2787 vala_report_error (_tmp697_, _tmp702_);
2788 _g_free0 (_tmp702_);
2789 _tmp703_ = vala_invalid_type_new ();
2790 _tmp704_ = _tmp703_;
2791 vala_expression_set_value_type ((ValaExpression*) self, (ValaDataType*) _tmp704_);
2792 _vala_code_node_unref0 (_tmp704_);
2793 result = FALSE;
2794 _g_free0 (base_type_package);
2795 _g_free0 (base_type_name);
2796 return result;
2797 } else {
2798 ValaSymbol* _tmp705_;
2799 ValaSymbol* _tmp706_;
2800 gboolean _tmp707_;
2801 gboolean _tmp708_;
2802 _tmp705_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
2803 _tmp706_ = _tmp705_;
2804 _tmp707_ = vala_code_node_get_error ((ValaCodeNode*) _tmp706_);
2805 _tmp708_ = _tmp707_;
2806 if (_tmp708_) {
2807 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
2808 result = FALSE;
2809 return result;
2810 }
2811 }
2812 _tmp709_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
2813 _tmp710_ = _tmp709_;
2814 if (VALA_IS_SIGNAL (_tmp710_)) {
2815 ValaSignal* sig = NULL;
2816 ValaSymbol* _tmp711_;
2817 ValaSymbol* _tmp712_;
2818 ValaCodeNode* ma = NULL;
2819 ValaCodeNode* parent = NULL;
2820 ValaCodeNode* _tmp719_;
2821 ValaCodeNode* _tmp720_;
2822 ValaCodeNode* _tmp721_;
2823 gboolean _tmp722_ = FALSE;
2824 gboolean _tmp723_ = FALSE;
2825 gboolean _tmp724_ = FALSE;
2826 ValaCodeNode* _tmp725_;
2827 _tmp711_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
2828 _tmp712_ = _tmp711_;
2829 sig = G_TYPE_CHECK_INSTANCE_CAST (_tmp712_, VALA_TYPE_SIGNAL, ValaSignal);
2830 ma = (ValaCodeNode*) self;
2831 while (TRUE) {
2832 ValaCodeNode* _tmp713_;
2833 ValaCodeNode* _tmp714_;
2834 ValaCodeNode* _tmp715_;
2835 ValaCodeNode* _tmp716_;
2836 ValaCodeNode* _tmp717_;
2837 ValaCodeNode* _tmp718_;
2838 _tmp713_ = ma;
2839 _tmp714_ = vala_code_node_get_parent_node (_tmp713_);
2840 _tmp715_ = _tmp714_;
2841 if (!VALA_IS_MEMBER_ACCESS (_tmp715_)) {
2842 break;
2843 }
2844 _tmp716_ = ma;
2845 _tmp717_ = vala_code_node_get_parent_node (_tmp716_);
2846 _tmp718_ = _tmp717_;
2847 ma = _tmp718_;
2848 }
2849 _tmp719_ = ma;
2850 _tmp720_ = vala_code_node_get_parent_node (_tmp719_);
2851 _tmp721_ = _tmp720_;
2852 parent = _tmp721_;
2853 _tmp725_ = parent;
2854 if (_tmp725_ != NULL) {
2855 ValaCodeNode* _tmp726_;
2856 _tmp726_ = parent;
2857 _tmp724_ = !VALA_IS_ELEMENT_ACCESS (_tmp726_);
2858 } else {
2859 _tmp724_ = FALSE;
2860 }
2861 if (_tmp724_) {
2862 ValaCodeNode* _tmp727_;
2863 ValaExpression* _tmp728_;
2864 ValaExpression* _tmp729_;
2865 _tmp727_ = ma;
2866 _tmp728_ = vala_member_access_get_inner (G_TYPE_CHECK_INSTANCE_CAST (_tmp727_, VALA_TYPE_MEMBER_ACCESS, ValaMemberAccess));
2867 _tmp729_ = _tmp728_;
2868 _tmp723_ = !VALA_IS_BASE_ACCESS (_tmp729_);
2869 } else {
2870 _tmp723_ = FALSE;
2871 }
2872 if (_tmp723_) {
2873 gboolean _tmp730_ = FALSE;
2874 ValaCodeNode* _tmp731_;
2875 _tmp731_ = parent;
2876 if (!VALA_IS_METHOD_CALL (_tmp731_)) {
2877 _tmp730_ = TRUE;
2878 } else {
2879 ValaCodeNode* _tmp732_;
2880 ValaList* _tmp733_;
2881 _tmp732_ = parent;
2882 _tmp733_ = vala_method_call_get_argument_list (G_TYPE_CHECK_INSTANCE_CAST (_tmp732_, VALA_TYPE_METHOD_CALL, ValaMethodCall));
2883 _tmp730_ = vala_collection_contains ((ValaCollection*) _tmp733_, (ValaExpression*) self);
2884 }
2885 _tmp722_ = _tmp730_;
2886 } else {
2887 _tmp722_ = FALSE;
2888 }
2889 if (_tmp722_) {
2890 ValaSignal* _tmp734_;
2891 ValaAttribute* _tmp735_;
2892 _tmp734_ = sig;
2893 _tmp735_ = vala_code_node_get_attribute ((ValaCodeNode*) _tmp734_, "HasEmitter");
2894 if (_tmp735_ != NULL) {
2895 ValaSignal* _tmp736_;
2896 ValaSignal* _tmp737_;
2897 ValaMethod* _tmp738_;
2898 ValaMethod* _tmp739_;
2899 _tmp736_ = sig;
2900 if (!vala_code_node_check ((ValaCodeNode*) _tmp736_, context)) {
2901 result = FALSE;
2902 return result;
2903 }
2904 _tmp737_ = sig;
2905 _tmp738_ = vala_signal_get_emitter (_tmp737_);
2906 _tmp739_ = _tmp738_;
2907 vala_expression_set_symbol_reference ((ValaExpression*) self, (ValaSymbol*) _tmp739_);
2908 } else {
2909 ValaSourceReference* _tmp740_;
2910 ValaSourceReference* _tmp741_;
2911 ValaSymbol* _tmp742_;
2912 ValaSymbol* _tmp743_;
2913 gchar* _tmp744_;
2914 gchar* _tmp745_;
2915 gchar* _tmp746_;
2916 gchar* _tmp747_;
2917 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
2918 _tmp740_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
2919 _tmp741_ = _tmp740_;
2920 _tmp742_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
2921 _tmp743_ = _tmp742_;
2922 _tmp744_ = vala_symbol_get_full_name (_tmp743_);
2923 _tmp745_ = _tmp744_;
2924 _tmp746_ = g_strdup_printf ("Signal `%s' requires emitter in this context", _tmp745_);
2925 _tmp747_ = _tmp746_;
2926 vala_report_error (_tmp741_, _tmp747_);
2927 _g_free0 (_tmp747_);
2928 _g_free0 (_tmp745_);
2929 result = FALSE;
2930 return result;
2931 }
2932 }
2933 }
2934 _tmp748_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
2935 _tmp749_ = _tmp748_;
2936 member = _tmp749_;
2937 access = VALA_SYMBOL_ACCESSIBILITY_PUBLIC;
2938 instance = FALSE;
2939 klass = FALSE;
2940 generics = FALSE;
2941 _tmp750_ = member;
2942 if (!vala_code_node_check ((ValaCodeNode*) _tmp750_, context)) {
2943 result = FALSE;
2944 return result;
2945 }
2946 _tmp751_ = member;
2947 if (VALA_IS_LOCAL_VARIABLE (_tmp751_)) {
2948 ValaLocalVariable* local = NULL;
2949 ValaSymbol* _tmp752_;
2950 ValaBlock* block = NULL;
2951 ValaLocalVariable* _tmp753_;
2952 ValaSymbol* _tmp754_;
2953 ValaSymbol* _tmp755_;
2954 gboolean _tmp756_ = FALSE;
2955 ValaBlock* _tmp757_;
2956 _tmp752_ = member;
2957 local = G_TYPE_CHECK_INSTANCE_CAST (_tmp752_, VALA_TYPE_LOCAL_VARIABLE, ValaLocalVariable);
2958 _tmp753_ = local;
2959 _tmp754_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp753_);
2960 _tmp755_ = _tmp754_;
2961 block = VALA_IS_BLOCK (_tmp755_) ? ((ValaBlock*) _tmp755_) : NULL;
2962 _tmp757_ = block;
2963 if (_tmp757_ != NULL) {
2964 ValaBlock* _tmp758_;
2965 ValaSymbol* _tmp759_;
2966 ValaSemanticAnalyzer* _tmp760_;
2967 ValaSemanticAnalyzer* _tmp761_;
2968 ValaSymbol* _tmp762_;
2969 ValaSymbol* _tmp763_;
2970 _tmp758_ = block;
2971 _tmp759_ = vala_semantic_analyzer_find_parent_method_or_property_accessor ((ValaSymbol*) _tmp758_);
2972 _tmp760_ = vala_code_context_get_analyzer (context);
2973 _tmp761_ = _tmp760_;
2974 _tmp762_ = vala_semantic_analyzer_get_current_method_or_property_accessor (_tmp761_);
2975 _tmp763_ = _tmp762_;
2976 _tmp756_ = _tmp759_ != _tmp763_;
2977 } else {
2978 _tmp756_ = FALSE;
2979 }
2980 if (_tmp756_) {
2981 ValaSymbol* sym = NULL;
2982 ValaSemanticAnalyzer* _tmp764_;
2983 ValaSemanticAnalyzer* _tmp765_;
2984 ValaSymbol* _tmp766_;
2985 ValaSymbol* _tmp767_;
2986 ValaLocalVariable* _tmp778_;
2987 ValaBlock* _tmp779_;
2988 ValaLocalVariable* _tmp780_;
2989 ValaDataType* _tmp781_;
2990 ValaDataType* _tmp782_;
2991 ValaTypeSymbol* _tmp783_;
2992 ValaTypeSymbol* _tmp784_;
2993 ValaSemanticAnalyzer* _tmp785_;
2994 ValaSemanticAnalyzer* _tmp786_;
2995 ValaDataType* _tmp787_;
2996 ValaTypeSymbol* _tmp788_;
2997 ValaTypeSymbol* _tmp789_;
2998 _tmp764_ = vala_code_context_get_analyzer (context);
2999 _tmp765_ = _tmp764_;
3000 _tmp766_ = vala_semantic_analyzer_get_current_method_or_property_accessor (_tmp765_);
3001 _tmp767_ = _tmp766_;
3002 sym = _tmp767_;
3003 while (TRUE) {
3004 ValaSymbol* _tmp768_;
3005 ValaBlock* _tmp769_;
3006 ValaMethod* method = NULL;
3007 ValaSymbol* _tmp770_;
3008 ValaMethod* _tmp771_;
3009 ValaSymbol* _tmp775_;
3010 ValaSymbol* _tmp776_;
3011 ValaSymbol* _tmp777_;
3012 _tmp768_ = sym;
3013 _tmp769_ = block;
3014 if (!(_tmp768_ != G_TYPE_CHECK_INSTANCE_CAST (_tmp769_, VALA_TYPE_SYMBOL, ValaSymbol))) {
3015 break;
3016 }
3017 _tmp770_ = sym;
3018 method = VALA_IS_METHOD (_tmp770_) ? ((ValaMethod*) _tmp770_) : NULL;
3019 _tmp771_ = method;
3020 if (_tmp771_ != NULL) {
3021 ValaMethod* _tmp772_;
3022 ValaMethod* _tmp773_;
3023 ValaLocalVariable* _tmp774_;
3024 _tmp772_ = method;
3025 vala_method_set_closure (_tmp772_, TRUE);
3026 _tmp773_ = method;
3027 _tmp774_ = local;
3028 vala_method_add_captured_variable (_tmp773_, _tmp774_);
3029 }
3030 _tmp775_ = sym;
3031 _tmp776_ = vala_symbol_get_parent_symbol (_tmp775_);
3032 _tmp777_ = _tmp776_;
3033 sym = _tmp777_;
3034 }
3035 _tmp778_ = local;
3036 vala_local_variable_set_captured (_tmp778_, TRUE);
3037 _tmp779_ = block;
3038 vala_block_set_captured (_tmp779_, TRUE);
3039 _tmp780_ = local;
3040 _tmp781_ = vala_variable_get_variable_type ((ValaVariable*) _tmp780_);
3041 _tmp782_ = _tmp781_;
3042 _tmp783_ = vala_data_type_get_type_symbol (_tmp782_);
3043 _tmp784_ = _tmp783_;
3044 _tmp785_ = vala_code_context_get_analyzer (context);
3045 _tmp786_ = _tmp785_;
3046 _tmp787_ = _tmp786_->va_list_type;
3047 _tmp788_ = vala_data_type_get_type_symbol (_tmp787_);
3048 _tmp789_ = _tmp788_;
3049 if (_tmp784_ == _tmp789_) {
3050 ValaSourceReference* _tmp790_;
3051 ValaSourceReference* _tmp791_;
3052 ValaLocalVariable* _tmp792_;
3053 gchar* _tmp793_;
3054 gchar* _tmp794_;
3055 gchar* _tmp795_;
3056 gchar* _tmp796_;
3057 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
3058 _tmp790_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
3059 _tmp791_ = _tmp790_;
3060 _tmp792_ = local;
3061 _tmp793_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp792_);
3062 _tmp794_ = _tmp793_;
3063 _tmp795_ = g_strdup_printf ("Capturing `va_list' variable `%s' is not allowed", _tmp794_);
3064 _tmp796_ = _tmp795_;
3065 vala_report_error (_tmp791_, _tmp796_);
3066 _g_free0 (_tmp796_);
3067 _g_free0 (_tmp794_);
3068 }
3069 }
3070 } else {
3071 ValaSymbol* _tmp797_;
3072 _tmp797_ = member;
3073 if (VALA_IS_PARAMETER (_tmp797_)) {
3074 ValaParameter* param = NULL;
3075 ValaSymbol* _tmp798_;
3076 ValaMethod* m = NULL;
3077 ValaParameter* _tmp799_;
3078 ValaSymbol* _tmp800_;
3079 ValaSymbol* _tmp801_;
3080 gboolean _tmp802_ = FALSE;
3081 gboolean _tmp803_ = FALSE;
3082 ValaMethod* _tmp804_;
3083 _tmp798_ = member;
3084 param = G_TYPE_CHECK_INSTANCE_CAST (_tmp798_, VALA_TYPE_PARAMETER, ValaParameter);
3085 _tmp799_ = param;
3086 _tmp800_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp799_);
3087 _tmp801_ = _tmp800_;
3088 m = VALA_IS_METHOD (_tmp801_) ? ((ValaMethod*) _tmp801_) : NULL;
3089 _tmp804_ = m;
3090 if (_tmp804_ != NULL) {
3091 ValaMethod* _tmp805_;
3092 ValaSemanticAnalyzer* _tmp806_;
3093 ValaSemanticAnalyzer* _tmp807_;
3094 ValaSymbol* _tmp808_;
3095 ValaSymbol* _tmp809_;
3096 _tmp805_ = m;
3097 _tmp806_ = vala_code_context_get_analyzer (context);
3098 _tmp807_ = _tmp806_;
3099 _tmp808_ = vala_semantic_analyzer_get_current_method_or_property_accessor (_tmp807_);
3100 _tmp809_ = _tmp808_;
3101 _tmp803_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp805_, VALA_TYPE_SYMBOL, ValaSymbol) != _tmp809_;
3102 } else {
3103 _tmp803_ = FALSE;
3104 }
3105 if (_tmp803_) {
3106 ValaParameter* _tmp810_;
3107 ValaMethod* _tmp811_;
3108 ValaParameter* _tmp812_;
3109 ValaParameter* _tmp813_;
3110 _tmp810_ = param;
3111 _tmp811_ = m;
3112 _tmp812_ = vala_method_get_this_parameter (_tmp811_);
3113 _tmp813_ = _tmp812_;
3114 _tmp802_ = _tmp810_ != _tmp813_;
3115 } else {
3116 _tmp802_ = FALSE;
3117 }
3118 if (_tmp802_) {
3119 ValaSymbol* sym = NULL;
3120 ValaSemanticAnalyzer* _tmp814_;
3121 ValaSemanticAnalyzer* _tmp815_;
3122 ValaSymbol* _tmp816_;
3123 ValaSymbol* _tmp817_;
3124 ValaParameter* _tmp826_;
3125 ValaMethod* _tmp827_;
3126 ValaBlock* _tmp828_;
3127 ValaBlock* _tmp829_;
3128 ValaParameter* _tmp830_;
3129 ValaParameterDirection _tmp831_;
3130 ValaParameterDirection _tmp832_;
3131 ValaParameter* _tmp840_;
3132 ValaDataType* _tmp841_;
3133 ValaDataType* _tmp842_;
3134 ValaTypeSymbol* _tmp843_;
3135 ValaTypeSymbol* _tmp844_;
3136 ValaSemanticAnalyzer* _tmp845_;
3137 ValaSemanticAnalyzer* _tmp846_;
3138 ValaDataType* _tmp847_;
3139 ValaTypeSymbol* _tmp848_;
3140 ValaTypeSymbol* _tmp849_;
3141 _tmp814_ = vala_code_context_get_analyzer (context);
3142 _tmp815_ = _tmp814_;
3143 _tmp816_ = vala_semantic_analyzer_get_current_method_or_property_accessor (_tmp815_);
3144 _tmp817_ = _tmp816_;
3145 sym = _tmp817_;
3146 while (TRUE) {
3147 ValaSymbol* _tmp818_;
3148 ValaMethod* _tmp819_;
3149 ValaMethod* method = NULL;
3150 ValaSymbol* _tmp820_;
3151 ValaMethod* _tmp821_;
3152 ValaSymbol* _tmp823_;
3153 ValaSymbol* _tmp824_;
3154 ValaSymbol* _tmp825_;
3155 _tmp818_ = sym;
3156 _tmp819_ = m;
3157 if (!(_tmp818_ != G_TYPE_CHECK_INSTANCE_CAST (_tmp819_, VALA_TYPE_SYMBOL, ValaSymbol))) {
3158 break;
3159 }
3160 _tmp820_ = sym;
3161 method = VALA_IS_METHOD (_tmp820_) ? ((ValaMethod*) _tmp820_) : NULL;
3162 _tmp821_ = method;
3163 if (_tmp821_ != NULL) {
3164 ValaMethod* _tmp822_;
3165 _tmp822_ = method;
3166 vala_method_set_closure (_tmp822_, TRUE);
3167 }
3168 _tmp823_ = sym;
3169 _tmp824_ = vala_symbol_get_parent_symbol (_tmp823_);
3170 _tmp825_ = _tmp824_;
3171 sym = _tmp825_;
3172 }
3173 _tmp826_ = param;
3174 vala_parameter_set_captured (_tmp826_, TRUE);
3175 _tmp827_ = m;
3176 _tmp828_ = vala_subroutine_get_body ((ValaSubroutine*) _tmp827_);
3177 _tmp829_ = _tmp828_;
3178 vala_block_set_captured (_tmp829_, TRUE);
3179 _tmp830_ = param;
3180 _tmp831_ = vala_parameter_get_direction (_tmp830_);
3181 _tmp832_ = _tmp831_;
3182 if (_tmp832_ != VALA_PARAMETER_DIRECTION_IN) {
3183 ValaSourceReference* _tmp833_;
3184 ValaSourceReference* _tmp834_;
3185 ValaParameter* _tmp835_;
3186 gchar* _tmp836_;
3187 gchar* _tmp837_;
3188 gchar* _tmp838_;
3189 gchar* _tmp839_;
3190 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
3191 _tmp833_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
3192 _tmp834_ = _tmp833_;
3193 _tmp835_ = param;
3194 _tmp836_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp835_);
3195 _tmp837_ = _tmp836_;
3196 _tmp838_ = g_strdup_printf ("Cannot capture reference or output parameter `%s'", _tmp837_);
3197 _tmp839_ = _tmp838_;
3198 vala_report_error (_tmp834_, _tmp839_);
3199 _g_free0 (_tmp839_);
3200 _g_free0 (_tmp837_);
3201 }
3202 _tmp840_ = param;
3203 _tmp841_ = vala_variable_get_variable_type ((ValaVariable*) _tmp840_);
3204 _tmp842_ = _tmp841_;
3205 _tmp843_ = vala_data_type_get_type_symbol (_tmp842_);
3206 _tmp844_ = _tmp843_;
3207 _tmp845_ = vala_code_context_get_analyzer (context);
3208 _tmp846_ = _tmp845_;
3209 _tmp847_ = _tmp846_->va_list_type;
3210 _tmp848_ = vala_data_type_get_type_symbol (_tmp847_);
3211 _tmp849_ = _tmp848_;
3212 if (_tmp844_ == _tmp849_) {
3213 ValaSourceReference* _tmp850_;
3214 ValaSourceReference* _tmp851_;
3215 ValaParameter* _tmp852_;
3216 gchar* _tmp853_;
3217 gchar* _tmp854_;
3218 gchar* _tmp855_;
3219 gchar* _tmp856_;
3220 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
3221 _tmp850_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
3222 _tmp851_ = _tmp850_;
3223 _tmp852_ = param;
3224 _tmp853_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp852_);
3225 _tmp854_ = _tmp853_;
3226 _tmp855_ = g_strdup_printf ("Capturing `va_list' parameter `%s' is not allowed", _tmp854_);
3227 _tmp856_ = _tmp855_;
3228 vala_report_error (_tmp851_, _tmp856_);
3229 _g_free0 (_tmp856_);
3230 _g_free0 (_tmp854_);
3231 }
3232 } else {
3233 ValaPropertyAccessor* acc = NULL;
3234 ValaParameter* _tmp857_;
3235 ValaSymbol* _tmp858_;
3236 ValaSymbol* _tmp859_;
3237 ValaSymbol* _tmp860_;
3238 ValaSymbol* _tmp861_;
3239 gboolean _tmp862_ = FALSE;
3240 gboolean _tmp863_ = FALSE;
3241 ValaPropertyAccessor* _tmp864_;
3242 _tmp857_ = param;
3243 _tmp858_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp857_);
3244 _tmp859_ = _tmp858_;
3245 _tmp860_ = vala_symbol_get_parent_symbol (_tmp859_);
3246 _tmp861_ = _tmp860_;
3247 acc = VALA_IS_PROPERTY_ACCESSOR (_tmp861_) ? ((ValaPropertyAccessor*) _tmp861_) : NULL;
3248 _tmp864_ = acc;
3249 if (_tmp864_ != NULL) {
3250 ValaPropertyAccessor* _tmp865_;
3251 ValaSemanticAnalyzer* _tmp866_;
3252 ValaSemanticAnalyzer* _tmp867_;
3253 ValaSymbol* _tmp868_;
3254 ValaSymbol* _tmp869_;
3255 _tmp865_ = acc;
3256 _tmp866_ = vala_code_context_get_analyzer (context);
3257 _tmp867_ = _tmp866_;
3258 _tmp868_ = vala_semantic_analyzer_get_current_method_or_property_accessor (_tmp867_);
3259 _tmp869_ = _tmp868_;
3260 _tmp863_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp865_, VALA_TYPE_SYMBOL, ValaSymbol) != _tmp869_;
3261 } else {
3262 _tmp863_ = FALSE;
3263 }
3264 if (_tmp863_) {
3265 ValaParameter* _tmp870_;
3266 ValaPropertyAccessor* _tmp871_;
3267 ValaProperty* _tmp872_;
3268 ValaProperty* _tmp873_;
3269 ValaParameter* _tmp874_;
3270 ValaParameter* _tmp875_;
3271 _tmp870_ = param;
3272 _tmp871_ = acc;
3273 _tmp872_ = vala_property_accessor_get_prop (_tmp871_);
3274 _tmp873_ = _tmp872_;
3275 _tmp874_ = vala_property_get_this_parameter (_tmp873_);
3276 _tmp875_ = _tmp874_;
3277 _tmp862_ = _tmp870_ != _tmp875_;
3278 } else {
3279 _tmp862_ = FALSE;
3280 }
3281 if (_tmp862_) {
3282 ValaSymbol* sym = NULL;
3283 ValaSemanticAnalyzer* _tmp876_;
3284 ValaSemanticAnalyzer* _tmp877_;
3285 ValaSymbol* _tmp878_;
3286 ValaSymbol* _tmp879_;
3287 ValaParameter* _tmp888_;
3288 ValaPropertyAccessor* _tmp889_;
3289 ValaBlock* _tmp890_;
3290 ValaBlock* _tmp891_;
3291 _tmp876_ = vala_code_context_get_analyzer (context);
3292 _tmp877_ = _tmp876_;
3293 _tmp878_ = vala_semantic_analyzer_get_current_method_or_property_accessor (_tmp877_);
3294 _tmp879_ = _tmp878_;
3295 sym = _tmp879_;
3296 while (TRUE) {
3297 ValaSymbol* _tmp880_;
3298 ValaMethod* _tmp881_;
3299 ValaMethod* method = NULL;
3300 ValaSymbol* _tmp882_;
3301 ValaMethod* _tmp883_;
3302 ValaSymbol* _tmp885_;
3303 ValaSymbol* _tmp886_;
3304 ValaSymbol* _tmp887_;
3305 _tmp880_ = sym;
3306 _tmp881_ = m;
3307 if (!(_tmp880_ != G_TYPE_CHECK_INSTANCE_CAST (_tmp881_, VALA_TYPE_SYMBOL, ValaSymbol))) {
3308 break;
3309 }
3310 _tmp882_ = sym;
3311 method = VALA_IS_METHOD (_tmp882_) ? ((ValaMethod*) _tmp882_) : NULL;
3312 _tmp883_ = method;
3313 if (_tmp883_ != NULL) {
3314 ValaMethod* _tmp884_;
3315 _tmp884_ = method;
3316 vala_method_set_closure (_tmp884_, TRUE);
3317 }
3318 _tmp885_ = sym;
3319 _tmp886_ = vala_symbol_get_parent_symbol (_tmp885_);
3320 _tmp887_ = _tmp886_;
3321 sym = _tmp887_;
3322 }
3323 _tmp888_ = param;
3324 vala_parameter_set_captured (_tmp888_, TRUE);
3325 _tmp889_ = acc;
3326 _tmp890_ = vala_subroutine_get_body ((ValaSubroutine*) _tmp889_);
3327 _tmp891_ = _tmp890_;
3328 vala_block_set_captured (_tmp891_, TRUE);
3329 }
3330 }
3331 } else {
3332 ValaSymbol* _tmp892_;
3333 _tmp892_ = member;
3334 if (VALA_IS_FIELD (_tmp892_)) {
3335 ValaField* f = NULL;
3336 ValaSymbol* _tmp893_;
3337 ValaField* _tmp894_;
3338 ValaSymbolAccessibility _tmp895_;
3339 ValaSymbolAccessibility _tmp896_;
3340 ValaField* _tmp897_;
3341 ValaMemberBinding _tmp898_;
3342 ValaMemberBinding _tmp899_;
3343 ValaField* _tmp900_;
3344 ValaMemberBinding _tmp901_;
3345 ValaMemberBinding _tmp902_;
3346 ValaField* _tmp903_;
3347 ValaDataType* _tmp904_;
3348 ValaDataType* _tmp905_;
3349 _tmp893_ = member;
3350 f = G_TYPE_CHECK_INSTANCE_CAST (_tmp893_, VALA_TYPE_FIELD, ValaField);
3351 _tmp894_ = f;
3352 _tmp895_ = vala_symbol_get_access ((ValaSymbol*) _tmp894_);
3353 _tmp896_ = _tmp895_;
3354 access = _tmp896_;
3355 _tmp897_ = f;
3356 _tmp898_ = vala_field_get_binding (_tmp897_);
3357 _tmp899_ = _tmp898_;
3358 instance = _tmp899_ == VALA_MEMBER_BINDING_INSTANCE;
3359 _tmp900_ = f;
3360 _tmp901_ = vala_field_get_binding (_tmp900_);
3361 _tmp902_ = _tmp901_;
3362 klass = _tmp902_ == VALA_MEMBER_BINDING_CLASS;
3363 _tmp903_ = f;
3364 _tmp904_ = vala_variable_get_variable_type ((ValaVariable*) _tmp903_);
3365 _tmp905_ = _tmp904_;
3366 if (VALA_IS_GENERIC_TYPE (_tmp905_)) {
3367 generics = TRUE;
3368 }
3369 } else {
3370 ValaSymbol* _tmp906_;
3371 _tmp906_ = member;
3372 if (VALA_IS_CONSTANT (_tmp906_)) {
3373 ValaConstant* c = NULL;
3374 ValaSymbol* _tmp907_;
3375 ValaConstant* _tmp908_;
3376 ValaSymbolAccessibility _tmp909_;
3377 ValaSymbolAccessibility _tmp910_;
3378 ValaBlock* block = NULL;
3379 ValaConstant* _tmp911_;
3380 ValaSymbol* _tmp912_;
3381 ValaSymbol* _tmp913_;
3382 gboolean _tmp914_ = FALSE;
3383 ValaBlock* _tmp915_;
3384 _tmp907_ = member;
3385 c = G_TYPE_CHECK_INSTANCE_CAST (_tmp907_, VALA_TYPE_CONSTANT, ValaConstant);
3386 _tmp908_ = c;
3387 _tmp909_ = vala_symbol_get_access ((ValaSymbol*) _tmp908_);
3388 _tmp910_ = _tmp909_;
3389 access = _tmp910_;
3390 _tmp911_ = c;
3391 _tmp912_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp911_);
3392 _tmp913_ = _tmp912_;
3393 block = VALA_IS_BLOCK (_tmp913_) ? ((ValaBlock*) _tmp913_) : NULL;
3394 _tmp915_ = block;
3395 if (_tmp915_ != NULL) {
3396 ValaBlock* _tmp916_;
3397 ValaSymbol* _tmp917_;
3398 ValaSemanticAnalyzer* _tmp918_;
3399 ValaSemanticAnalyzer* _tmp919_;
3400 ValaSymbol* _tmp920_;
3401 ValaSymbol* _tmp921_;
3402 _tmp916_ = block;
3403 _tmp917_ = vala_semantic_analyzer_find_parent_method_or_property_accessor ((ValaSymbol*) _tmp916_);
3404 _tmp918_ = vala_code_context_get_analyzer (context);
3405 _tmp919_ = _tmp918_;
3406 _tmp920_ = vala_semantic_analyzer_get_current_method_or_property_accessor (_tmp919_);
3407 _tmp921_ = _tmp920_;
3408 _tmp914_ = _tmp917_ != _tmp921_;
3409 } else {
3410 _tmp914_ = FALSE;
3411 }
3412 if (_tmp914_) {
3413 ValaSourceReference* _tmp922_;
3414 ValaSourceReference* _tmp923_;
3415 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
3416 _tmp922_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
3417 _tmp923_ = _tmp922_;
3418 vala_report_error (_tmp923_, "internal error: accessing local constants of outer methods is not supp" \
3419 "orted yet");
3420 result = FALSE;
3421 return result;
3422 }
3423 } else {
3424 ValaSymbol* _tmp924_;
3425 _tmp924_ = member;
3426 if (VALA_IS_METHOD (_tmp924_)) {
3427 ValaMethod* m = NULL;
3428 ValaSymbol* _tmp925_;
3429 ValaMethod* _tmp926_;
3430 gboolean _tmp927_;
3431 gboolean _tmp928_;
3432 ValaMethod* _tmp1017_;
3433 ValaSymbolAccessibility _tmp1018_;
3434 ValaSymbolAccessibility _tmp1019_;
3435 ValaMethod* _tmp1020_;
3436 ValaMethod* _tmp1024_;
3437 ValaMemberBinding _tmp1025_;
3438 ValaMemberBinding _tmp1026_;
3439 ValaGenericType* generic_type = NULL;
3440 ValaMethod* _tmp1047_;
3441 ValaDataType* _tmp1048_;
3442 ValaDataType* _tmp1049_;
3443 gboolean _tmp1050_ = FALSE;
3444 ValaGenericType* _tmp1051_;
3445 _tmp925_ = member;
3446 m = G_TYPE_CHECK_INSTANCE_CAST (_tmp925_, VALA_TYPE_METHOD, ValaMethod);
3447 _tmp926_ = m;
3448 _tmp927_ = vala_method_get_is_async_callback (_tmp926_);
3449 _tmp928_ = _tmp927_;
3450 if (_tmp928_) {
3451 ValaMethod* async_method = NULL;
3452 ValaSemanticAnalyzer* _tmp929_;
3453 ValaSemanticAnalyzer* _tmp930_;
3454 ValaMethod* _tmp931_;
3455 ValaMethod* _tmp932_;
3456 gboolean is_valid_access = FALSE;
3457 ValaMethod* _tmp933_;
3458 ValaMethod* _tmp962_;
3459 ValaSemanticAnalyzer* _tmp963_;
3460 ValaSemanticAnalyzer* _tmp964_;
3461 ValaMethod* _tmp965_;
3462 ValaMethod* _tmp966_;
3463 ValaMethod* _tmp982_;
3464 ValaMethod* _tmp983_;
3465 ValaMethod* _tmp984_;
3466 ValaSymbol* _tmp985_;
3467 ValaSymbol* _tmp986_;
3468 _tmp929_ = vala_code_context_get_analyzer (context);
3469 _tmp930_ = _tmp929_;
3470 _tmp931_ = vala_semantic_analyzer_get_current_async_method (_tmp930_);
3471 _tmp932_ = _tmp931_;
3472 async_method = _tmp932_;
3473 is_valid_access = FALSE;
3474 _tmp933_ = async_method;
3475 if (_tmp933_ != NULL) {
3476 ValaMethod* _tmp934_;
3477 ValaMethod* _tmp935_;
3478 ValaMethod* _tmp936_;
3479 _tmp934_ = m;
3480 _tmp935_ = async_method;
3481 _tmp936_ = vala_method_get_callback_method (_tmp935_);
3482 if (_tmp934_ == _tmp936_) {
3483 is_valid_access = TRUE;
3484 } else {
3485 gboolean _tmp937_ = FALSE;
3486 ValaMethod* _tmp938_;
3487 ValaMethod* _tmp939_;
3488 ValaMethod* _tmp940_;
3489 _tmp938_ = async_method;
3490 _tmp939_ = vala_method_get_base_method (_tmp938_);
3491 _tmp940_ = _tmp939_;
3492 if (_tmp940_ != NULL) {
3493 ValaMethod* _tmp941_;
3494 ValaMethod* _tmp942_;
3495 ValaMethod* _tmp943_;
3496 ValaMethod* _tmp944_;
3497 ValaMethod* _tmp945_;
3498 _tmp941_ = m;
3499 _tmp942_ = async_method;
3500 _tmp943_ = vala_method_get_base_method (_tmp942_);
3501 _tmp944_ = _tmp943_;
3502 _tmp945_ = vala_method_get_callback_method (_tmp944_);
3503 _tmp937_ = _tmp941_ == _tmp945_;
3504 } else {
3505 _tmp937_ = FALSE;
3506 }
3507 if (_tmp937_) {
3508 is_valid_access = TRUE;
3509 } else {
3510 gboolean _tmp946_ = FALSE;
3511 ValaMethod* _tmp947_;
3512 ValaMethod* _tmp948_;
3513 ValaMethod* _tmp949_;
3514 _tmp947_ = async_method;
3515 _tmp948_ = vala_method_get_base_interface_method (_tmp947_);
3516 _tmp949_ = _tmp948_;
3517 if (_tmp949_ != NULL) {
3518 ValaMethod* _tmp950_;
3519 ValaMethod* _tmp951_;
3520 ValaMethod* _tmp952_;
3521 ValaMethod* _tmp953_;
3522 ValaMethod* _tmp954_;
3523 _tmp950_ = m;
3524 _tmp951_ = async_method;
3525 _tmp952_ = vala_method_get_base_interface_method (_tmp951_);
3526 _tmp953_ = _tmp952_;
3527 _tmp954_ = vala_method_get_callback_method (_tmp953_);
3528 _tmp946_ = _tmp950_ == _tmp954_;
3529 } else {
3530 _tmp946_ = FALSE;
3531 }
3532 if (_tmp946_) {
3533 is_valid_access = TRUE;
3534 }
3535 }
3536 }
3537 }
3538 if (!is_valid_access) {
3539 ValaSourceReference* _tmp955_;
3540 ValaSourceReference* _tmp956_;
3541 ValaMethod* _tmp957_;
3542 gchar* _tmp958_;
3543 gchar* _tmp959_;
3544 gchar* _tmp960_;
3545 gchar* _tmp961_;
3546 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
3547 _tmp955_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
3548 _tmp956_ = _tmp955_;
3549 _tmp957_ = m;
3550 _tmp958_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp957_);
3551 _tmp959_ = _tmp958_;
3552 _tmp960_ = g_strdup_printf ("Access to async callback `%s' not allowed in this context", _tmp959_);
3553 _tmp961_ = _tmp960_;
3554 vala_report_error (_tmp956_, _tmp961_);
3555 _g_free0 (_tmp961_);
3556 _g_free0 (_tmp959_);
3557 result = FALSE;
3558 return result;
3559 }
3560 _tmp962_ = async_method;
3561 _tmp963_ = vala_code_context_get_analyzer (context);
3562 _tmp964_ = _tmp963_;
3563 _tmp965_ = vala_semantic_analyzer_get_current_method (_tmp964_);
3564 _tmp966_ = _tmp965_;
3565 if (_tmp962_ != _tmp966_) {
3566 ValaSymbol* sym = NULL;
3567 ValaSemanticAnalyzer* _tmp967_;
3568 ValaSemanticAnalyzer* _tmp968_;
3569 ValaMethod* _tmp969_;
3570 ValaMethod* _tmp970_;
3571 ValaMethod* _tmp979_;
3572 ValaBlock* _tmp980_;
3573 ValaBlock* _tmp981_;
3574 _tmp967_ = vala_code_context_get_analyzer (context);
3575 _tmp968_ = _tmp967_;
3576 _tmp969_ = vala_semantic_analyzer_get_current_method (_tmp968_);
3577 _tmp970_ = _tmp969_;
3578 sym = (ValaSymbol*) _tmp970_;
3579 while (TRUE) {
3580 ValaSymbol* _tmp971_;
3581 ValaMethod* _tmp972_;
3582 ValaMethod* method = NULL;
3583 ValaSymbol* _tmp973_;
3584 ValaMethod* _tmp974_;
3585 ValaSymbol* _tmp976_;
3586 ValaSymbol* _tmp977_;
3587 ValaSymbol* _tmp978_;
3588 _tmp971_ = sym;
3589 _tmp972_ = async_method;
3590 if (!(_tmp971_ != G_TYPE_CHECK_INSTANCE_CAST (_tmp972_, VALA_TYPE_SYMBOL, ValaSymbol))) {
3591 break;
3592 }
3593 _tmp973_ = sym;
3594 method = VALA_IS_METHOD (_tmp973_) ? ((ValaMethod*) _tmp973_) : NULL;
3595 _tmp974_ = method;
3596 if (_tmp974_ != NULL) {
3597 ValaMethod* _tmp975_;
3598 _tmp975_ = method;
3599 vala_method_set_closure (_tmp975_, TRUE);
3600 }
3601 _tmp976_ = sym;
3602 _tmp977_ = vala_symbol_get_parent_symbol (_tmp976_);
3603 _tmp978_ = _tmp977_;
3604 sym = _tmp978_;
3605 }
3606 _tmp979_ = async_method;
3607 _tmp980_ = vala_subroutine_get_body ((ValaSubroutine*) _tmp979_);
3608 _tmp981_ = _tmp980_;
3609 vala_block_set_captured (_tmp981_, TRUE);
3610 }
3611 _tmp982_ = async_method;
3612 _tmp983_ = vala_method_get_callback_method (_tmp982_);
3613 m = _tmp983_;
3614 _tmp984_ = m;
3615 vala_expression_set_symbol_reference ((ValaExpression*) self, (ValaSymbol*) _tmp984_);
3616 _tmp985_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
3617 _tmp986_ = _tmp985_;
3618 member = _tmp986_;
3619 } else {
3620 ValaMethod* _tmp987_;
3621 ValaMethod* _tmp988_;
3622 ValaMethod* _tmp989_;
3623 _tmp987_ = m;
3624 _tmp988_ = vala_method_get_base_method (_tmp987_);
3625 _tmp989_ = _tmp988_;
3626 if (_tmp989_ != NULL) {
3627 ValaMethod* _tmp990_;
3628 ValaMethod* _tmp991_;
3629 ValaMethod* _tmp992_;
3630 ValaMethod* _tmp993_;
3631 ValaSignal* _tmp994_;
3632 ValaSignal* _tmp995_;
3633 ValaSymbol* _tmp1000_;
3634 ValaSymbol* _tmp1001_;
3635 _tmp990_ = m;
3636 _tmp991_ = vala_method_get_base_method (_tmp990_);
3637 _tmp992_ = _tmp991_;
3638 m = _tmp992_;
3639 _tmp993_ = m;
3640 _tmp994_ = vala_method_get_signal_reference (_tmp993_);
3641 _tmp995_ = _tmp994_;
3642 if (_tmp995_ != NULL) {
3643 ValaMethod* _tmp996_;
3644 ValaSignal* _tmp997_;
3645 ValaSignal* _tmp998_;
3646 _tmp996_ = m;
3647 _tmp997_ = vala_method_get_signal_reference (_tmp996_);
3648 _tmp998_ = _tmp997_;
3649 vala_expression_set_symbol_reference ((ValaExpression*) self, (ValaSymbol*) _tmp998_);
3650 } else {
3651 ValaMethod* _tmp999_;
3652 _tmp999_ = m;
3653 vala_expression_set_symbol_reference ((ValaExpression*) self, (ValaSymbol*) _tmp999_);
3654 }
3655 _tmp1000_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
3656 _tmp1001_ = _tmp1000_;
3657 member = _tmp1001_;
3658 } else {
3659 ValaMethod* _tmp1002_;
3660 ValaMethod* _tmp1003_;
3661 ValaMethod* _tmp1004_;
3662 _tmp1002_ = m;
3663 _tmp1003_ = vala_method_get_base_interface_method (_tmp1002_);
3664 _tmp1004_ = _tmp1003_;
3665 if (_tmp1004_ != NULL) {
3666 ValaMethod* _tmp1005_;
3667 ValaMethod* _tmp1006_;
3668 ValaMethod* _tmp1007_;
3669 ValaMethod* _tmp1008_;
3670 ValaSignal* _tmp1009_;
3671 ValaSignal* _tmp1010_;
3672 ValaSymbol* _tmp1015_;
3673 ValaSymbol* _tmp1016_;
3674 _tmp1005_ = m;
3675 _tmp1006_ = vala_method_get_base_interface_method (_tmp1005_);
3676 _tmp1007_ = _tmp1006_;
3677 m = _tmp1007_;
3678 _tmp1008_ = m;
3679 _tmp1009_ = vala_method_get_signal_reference (_tmp1008_);
3680 _tmp1010_ = _tmp1009_;
3681 if (_tmp1010_ != NULL) {
3682 ValaMethod* _tmp1011_;
3683 ValaSignal* _tmp1012_;
3684 ValaSignal* _tmp1013_;
3685 _tmp1011_ = m;
3686 _tmp1012_ = vala_method_get_signal_reference (_tmp1011_);
3687 _tmp1013_ = _tmp1012_;
3688 vala_expression_set_symbol_reference ((ValaExpression*) self, (ValaSymbol*) _tmp1013_);
3689 } else {
3690 ValaMethod* _tmp1014_;
3691 _tmp1014_ = m;
3692 vala_expression_set_symbol_reference ((ValaExpression*) self, (ValaSymbol*) _tmp1014_);
3693 }
3694 _tmp1015_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
3695 _tmp1016_ = _tmp1015_;
3696 member = _tmp1016_;
3697 }
3698 }
3699 }
3700 _tmp1017_ = m;
3701 _tmp1018_ = vala_symbol_get_access ((ValaSymbol*) _tmp1017_);
3702 _tmp1019_ = _tmp1018_;
3703 access = _tmp1019_;
3704 _tmp1020_ = m;
3705 if (!VALA_IS_CREATION_METHOD (_tmp1020_)) {
3706 ValaMethod* _tmp1021_;
3707 ValaMemberBinding _tmp1022_;
3708 ValaMemberBinding _tmp1023_;
3709 _tmp1021_ = m;
3710 _tmp1022_ = vala_method_get_binding (_tmp1021_);
3711 _tmp1023_ = _tmp1022_;
3712 instance = _tmp1023_ == VALA_MEMBER_BINDING_INSTANCE;
3713 }
3714 _tmp1024_ = m;
3715 _tmp1025_ = vala_method_get_binding (_tmp1024_);
3716 _tmp1026_ = _tmp1025_;
3717 klass = _tmp1026_ == VALA_MEMBER_BINDING_CLASS;
3718 {
3719 ValaList* _param_list = NULL;
3720 ValaMethod* _tmp1027_;
3721 ValaList* _tmp1028_;
3722 ValaList* _tmp1029_;
3723 gint _param_size = 0;
3724 ValaList* _tmp1030_;
3725 gint _tmp1031_;
3726 gint _tmp1032_;
3727 gint _param_index = 0;
3728 _tmp1027_ = m;
3729 _tmp1028_ = vala_callable_get_parameters ((ValaCallable*) _tmp1027_);
3730 _tmp1029_ = _vala_iterable_ref0 (_tmp1028_);
3731 _param_list = _tmp1029_;
3732 _tmp1030_ = _param_list;
3733 _tmp1031_ = vala_collection_get_size ((ValaCollection*) _tmp1030_);
3734 _tmp1032_ = _tmp1031_;
3735 _param_size = _tmp1032_;
3736 _param_index = -1;
3737 while (TRUE) {
3738 gint _tmp1033_;
3739 gint _tmp1034_;
3740 ValaParameter* param = NULL;
3741 ValaList* _tmp1035_;
3742 gpointer _tmp1036_;
3743 ValaGenericType* generic_type = NULL;
3744 ValaParameter* _tmp1037_;
3745 ValaDataType* _tmp1038_;
3746 ValaDataType* _tmp1039_;
3747 gboolean _tmp1040_ = FALSE;
3748 ValaGenericType* _tmp1041_;
3749 _param_index = _param_index + 1;
3750 _tmp1033_ = _param_index;
3751 _tmp1034_ = _param_size;
3752 if (!(_tmp1033_ < _tmp1034_)) {
3753 break;
3754 }
3755 _tmp1035_ = _param_list;
3756 _tmp1036_ = vala_list_get (_tmp1035_, _param_index);
3757 param = (ValaParameter*) _tmp1036_;
3758 _tmp1037_ = param;
3759 _tmp1038_ = vala_variable_get_variable_type ((ValaVariable*) _tmp1037_);
3760 _tmp1039_ = _tmp1038_;
3761 generic_type = VALA_IS_GENERIC_TYPE (_tmp1039_) ? ((ValaGenericType*) _tmp1039_) : NULL;
3762 _tmp1041_ = generic_type;
3763 if (_tmp1041_ != NULL) {
3764 ValaGenericType* _tmp1042_;
3765 ValaTypeParameter* _tmp1043_;
3766 ValaTypeParameter* _tmp1044_;
3767 ValaSymbol* _tmp1045_;
3768 ValaSymbol* _tmp1046_;
3769 _tmp1042_ = generic_type;
3770 _tmp1043_ = vala_generic_type_get_type_parameter (_tmp1042_);
3771 _tmp1044_ = _tmp1043_;
3772 _tmp1045_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp1044_);
3773 _tmp1046_ = _tmp1045_;
3774 _tmp1040_ = VALA_IS_TYPESYMBOL (_tmp1046_);
3775 } else {
3776 _tmp1040_ = FALSE;
3777 }
3778 if (_tmp1040_) {
3779 generics = TRUE;
3780 _vala_code_node_unref0 (param);
3781 break;
3782 }
3783 _vala_code_node_unref0 (param);
3784 }
3785 _vala_iterable_unref0 (_param_list);
3786 }
3787 _tmp1047_ = m;
3788 _tmp1048_ = vala_callable_get_return_type ((ValaCallable*) _tmp1047_);
3789 _tmp1049_ = _tmp1048_;
3790 generic_type = VALA_IS_GENERIC_TYPE (_tmp1049_) ? ((ValaGenericType*) _tmp1049_) : NULL;
3791 _tmp1051_ = generic_type;
3792 if (_tmp1051_ != NULL) {
3793 ValaGenericType* _tmp1052_;
3794 ValaTypeParameter* _tmp1053_;
3795 ValaTypeParameter* _tmp1054_;
3796 ValaSymbol* _tmp1055_;
3797 ValaSymbol* _tmp1056_;
3798 _tmp1052_ = generic_type;
3799 _tmp1053_ = vala_generic_type_get_type_parameter (_tmp1052_);
3800 _tmp1054_ = _tmp1053_;
3801 _tmp1055_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp1054_);
3802 _tmp1056_ = _tmp1055_;
3803 _tmp1050_ = VALA_IS_TYPESYMBOL (_tmp1056_);
3804 } else {
3805 _tmp1050_ = FALSE;
3806 }
3807 if (_tmp1050_) {
3808 generics = TRUE;
3809 }
3810 } else {
3811 ValaSymbol* _tmp1057_;
3812 _tmp1057_ = member;
3813 if (VALA_IS_PROPERTY (_tmp1057_)) {
3814 ValaProperty* prop = NULL;
3815 ValaSymbol* _tmp1058_;
3816 ValaProperty* _tmp1059_;
3817 ValaProperty* _tmp1060_;
3818 ValaProperty* _tmp1061_;
3819 ValaProperty* _tmp1062_;
3820 ValaProperty* _tmp1078_;
3821 ValaSymbolAccessibility _tmp1079_;
3822 ValaSymbolAccessibility _tmp1080_;
3823 gboolean _tmp1081_;
3824 gboolean _tmp1082_;
3825 ValaProperty* _tmp1187_;
3826 ValaMemberBinding _tmp1188_;
3827 ValaMemberBinding _tmp1189_;
3828 ValaProperty* _tmp1190_;
3829 ValaDataType* _tmp1191_;
3830 ValaDataType* _tmp1192_;
3831 _tmp1058_ = member;
3832 prop = G_TYPE_CHECK_INSTANCE_CAST (_tmp1058_, VALA_TYPE_PROPERTY, ValaProperty);
3833 _tmp1059_ = prop;
3834 if (!vala_code_node_check ((ValaCodeNode*) _tmp1059_, context)) {
3835 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
3836 result = FALSE;
3837 return result;
3838 }
3839 _tmp1060_ = prop;
3840 _tmp1061_ = vala_property_get_base_property (_tmp1060_);
3841 _tmp1062_ = _tmp1061_;
3842 if (_tmp1062_ != NULL) {
3843 ValaProperty* _tmp1063_;
3844 ValaProperty* _tmp1064_;
3845 ValaProperty* _tmp1065_;
3846 ValaProperty* _tmp1066_;
3847 ValaSymbol* _tmp1067_;
3848 ValaSymbol* _tmp1068_;
3849 _tmp1063_ = prop;
3850 _tmp1064_ = vala_property_get_base_property (_tmp1063_);
3851 _tmp1065_ = _tmp1064_;
3852 prop = _tmp1065_;
3853 _tmp1066_ = prop;
3854 vala_expression_set_symbol_reference ((ValaExpression*) self, (ValaSymbol*) _tmp1066_);
3855 _tmp1067_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
3856 _tmp1068_ = _tmp1067_;
3857 member = _tmp1068_;
3858 } else {
3859 ValaProperty* _tmp1069_;
3860 ValaProperty* _tmp1070_;
3861 ValaProperty* _tmp1071_;
3862 _tmp1069_ = prop;
3863 _tmp1070_ = vala_property_get_base_interface_property (_tmp1069_);
3864 _tmp1071_ = _tmp1070_;
3865 if (_tmp1071_ != NULL) {
3866 ValaProperty* _tmp1072_;
3867 ValaProperty* _tmp1073_;
3868 ValaProperty* _tmp1074_;
3869 ValaProperty* _tmp1075_;
3870 ValaSymbol* _tmp1076_;
3871 ValaSymbol* _tmp1077_;
3872 _tmp1072_ = prop;
3873 _tmp1073_ = vala_property_get_base_interface_property (_tmp1072_);
3874 _tmp1074_ = _tmp1073_;
3875 prop = _tmp1074_;
3876 _tmp1075_ = prop;
3877 vala_expression_set_symbol_reference ((ValaExpression*) self, (ValaSymbol*) _tmp1075_);
3878 _tmp1076_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
3879 _tmp1077_ = _tmp1076_;
3880 member = _tmp1077_;
3881 }
3882 }
3883 _tmp1078_ = prop;
3884 _tmp1079_ = vala_symbol_get_access ((ValaSymbol*) _tmp1078_);
3885 _tmp1080_ = _tmp1079_;
3886 access = _tmp1080_;
3887 _tmp1081_ = vala_expression_get_lvalue ((ValaExpression*) self);
3888 _tmp1082_ = _tmp1081_;
3889 if (_tmp1082_) {
3890 ValaProperty* _tmp1083_;
3891 ValaPropertyAccessor* _tmp1084_;
3892 ValaPropertyAccessor* _tmp1085_;
3893 ValaProperty* _tmp1133_;
3894 ValaSymbolAccessibility _tmp1134_;
3895 ValaSymbolAccessibility _tmp1135_;
3896 _tmp1083_ = prop;
3897 _tmp1084_ = vala_property_get_set_accessor (_tmp1083_);
3898 _tmp1085_ = _tmp1084_;
3899 if (_tmp1085_ == NULL) {
3900 ValaSourceReference* _tmp1086_;
3901 ValaSourceReference* _tmp1087_;
3902 ValaProperty* _tmp1088_;
3903 gchar* _tmp1089_;
3904 gchar* _tmp1090_;
3905 gchar* _tmp1091_;
3906 gchar* _tmp1092_;
3907 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
3908 _tmp1086_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
3909 _tmp1087_ = _tmp1086_;
3910 _tmp1088_ = prop;
3911 _tmp1089_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp1088_);
3912 _tmp1090_ = _tmp1089_;
3913 _tmp1091_ = g_strdup_printf ("Property `%s' is read-only", _tmp1090_);
3914 _tmp1092_ = _tmp1091_;
3915 vala_report_error (_tmp1087_, _tmp1092_);
3916 _g_free0 (_tmp1092_);
3917 _g_free0 (_tmp1090_);
3918 result = FALSE;
3919 return result;
3920 } else {
3921 gboolean _tmp1093_ = FALSE;
3922 ValaProperty* _tmp1094_;
3923 ValaPropertyAccessor* _tmp1095_;
3924 ValaPropertyAccessor* _tmp1096_;
3925 gboolean _tmp1097_;
3926 gboolean _tmp1098_;
3927 _tmp1094_ = prop;
3928 _tmp1095_ = vala_property_get_set_accessor (_tmp1094_);
3929 _tmp1096_ = _tmp1095_;
3930 _tmp1097_ = vala_property_accessor_get_writable (_tmp1096_);
3931 _tmp1098_ = _tmp1097_;
3932 if (!_tmp1098_) {
3933 ValaProperty* _tmp1099_;
3934 ValaPropertyAccessor* _tmp1100_;
3935 ValaPropertyAccessor* _tmp1101_;
3936 gboolean _tmp1102_;
3937 gboolean _tmp1103_;
3938 _tmp1099_ = prop;
3939 _tmp1100_ = vala_property_get_set_accessor (_tmp1099_);
3940 _tmp1101_ = _tmp1100_;
3941 _tmp1102_ = vala_property_accessor_get_construction (_tmp1101_);
3942 _tmp1103_ = _tmp1102_;
3943 _tmp1093_ = _tmp1103_;
3944 } else {
3945 _tmp1093_ = FALSE;
3946 }
3947 if (_tmp1093_) {
3948 ValaSemanticAnalyzer* _tmp1104_;
3949 ValaSemanticAnalyzer* _tmp1105_;
3950 ValaMethod* _tmp1106_;
3951 _tmp1104_ = vala_code_context_get_analyzer (context);
3952 _tmp1105_ = _tmp1104_;
3953 _tmp1106_ = vala_semantic_analyzer_find_current_method (_tmp1105_);
3954 if (VALA_IS_CREATION_METHOD (_tmp1106_)) {
3955 ValaSourceReference* _tmp1107_;
3956 ValaSourceReference* _tmp1108_;
3957 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
3958 _tmp1107_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
3959 _tmp1108_ = _tmp1107_;
3960 vala_report_error (_tmp1108_, "Cannot assign to construct-only properties, use Object (property: valu" \
3961 "e) constructor chain up");
3962 result = FALSE;
3963 return result;
3964 } else {
3965 ValaSemanticAnalyzer* _tmp1109_;
3966 ValaSemanticAnalyzer* _tmp1110_;
3967 _tmp1109_ = vala_code_context_get_analyzer (context);
3968 _tmp1110_ = _tmp1109_;
3969 if (vala_semantic_analyzer_is_in_constructor (_tmp1110_)) {
3970 ValaSemanticAnalyzer* _tmp1111_;
3971 ValaSemanticAnalyzer* _tmp1112_;
3972 ValaTypeSymbol* _tmp1113_;
3973 ValaTypeSymbol* _tmp1114_;
3974 ValaProperty* _tmp1115_;
3975 ValaSymbol* _tmp1116_;
3976 ValaSymbol* _tmp1117_;
3977 _tmp1111_ = vala_code_context_get_analyzer (context);
3978 _tmp1112_ = _tmp1111_;
3979 _tmp1113_ = vala_semantic_analyzer_get_current_type_symbol (_tmp1112_);
3980 _tmp1114_ = _tmp1113_;
3981 _tmp1115_ = prop;
3982 _tmp1116_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp1115_);
3983 _tmp1117_ = _tmp1116_;
3984 if (!vala_typesymbol_is_subtype_of (_tmp1114_, G_TYPE_CHECK_INSTANCE_CAST (_tmp1117_, VALA_TYPE_TYPESYMBOL, ValaTypeSymbol))) {
3985 ValaSourceReference* _tmp1118_;
3986 ValaSourceReference* _tmp1119_;
3987 ValaProperty* _tmp1120_;
3988 gchar* _tmp1121_;
3989 gchar* _tmp1122_;
3990 ValaSemanticAnalyzer* _tmp1123_;
3991 ValaSemanticAnalyzer* _tmp1124_;
3992 ValaTypeSymbol* _tmp1125_;
3993 ValaTypeSymbol* _tmp1126_;
3994 gchar* _tmp1127_;
3995 gchar* _tmp1128_;
3996 gchar* _tmp1129_;
3997 gchar* _tmp1130_;
3998 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
3999 _tmp1118_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
4000 _tmp1119_ = _tmp1118_;
4001 _tmp1120_ = prop;
4002 _tmp1121_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp1120_);
4003 _tmp1122_ = _tmp1121_;
4004 _tmp1123_ = vala_code_context_get_analyzer (context);
4005 _tmp1124_ = _tmp1123_;
4006 _tmp1125_ = vala_semantic_analyzer_get_current_type_symbol (_tmp1124_);
4007 _tmp1126_ = _tmp1125_;
4008 _tmp1127_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp1126_);
4009 _tmp1128_ = _tmp1127_;
4010 _tmp1129_ = g_strdup_printf ("Cannot assign to construct-only property `%s' in `construct' of `%s'", _tmp1122_, _tmp1128_);
4011 _tmp1130_ = _tmp1129_;
4012 vala_report_error (_tmp1119_, _tmp1130_);
4013 _g_free0 (_tmp1130_);
4014 _g_free0 (_tmp1128_);
4015 _g_free0 (_tmp1122_);
4016 result = FALSE;
4017 return result;
4018 }
4019 } else {
4020 ValaSourceReference* _tmp1131_;
4021 ValaSourceReference* _tmp1132_;
4022 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
4023 _tmp1131_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
4024 _tmp1132_ = _tmp1131_;
4025 vala_report_error (_tmp1132_, "Cannot assign to construct-only property in this context");
4026 result = FALSE;
4027 return result;
4028 }
4029 }
4030 }
4031 }
4032 _tmp1133_ = prop;
4033 _tmp1134_ = vala_symbol_get_access ((ValaSymbol*) _tmp1133_);
4034 _tmp1135_ = _tmp1134_;
4035 if (_tmp1135_ == VALA_SYMBOL_ACCESSIBILITY_PUBLIC) {
4036 ValaProperty* _tmp1136_;
4037 ValaPropertyAccessor* _tmp1137_;
4038 ValaPropertyAccessor* _tmp1138_;
4039 ValaSymbolAccessibility _tmp1139_;
4040 ValaSymbolAccessibility _tmp1140_;
4041 _tmp1136_ = prop;
4042 _tmp1137_ = vala_property_get_set_accessor (_tmp1136_);
4043 _tmp1138_ = _tmp1137_;
4044 _tmp1139_ = vala_symbol_get_access ((ValaSymbol*) _tmp1138_);
4045 _tmp1140_ = _tmp1139_;
4046 access = _tmp1140_;
4047 } else {
4048 gboolean _tmp1141_ = FALSE;
4049 ValaProperty* _tmp1142_;
4050 ValaSymbolAccessibility _tmp1143_;
4051 ValaSymbolAccessibility _tmp1144_;
4052 _tmp1142_ = prop;
4053 _tmp1143_ = vala_symbol_get_access ((ValaSymbol*) _tmp1142_);
4054 _tmp1144_ = _tmp1143_;
4055 if (_tmp1144_ == VALA_SYMBOL_ACCESSIBILITY_PROTECTED) {
4056 ValaProperty* _tmp1145_;
4057 ValaPropertyAccessor* _tmp1146_;
4058 ValaPropertyAccessor* _tmp1147_;
4059 ValaSymbolAccessibility _tmp1148_;
4060 ValaSymbolAccessibility _tmp1149_;
4061 _tmp1145_ = prop;
4062 _tmp1146_ = vala_property_get_set_accessor (_tmp1145_);
4063 _tmp1147_ = _tmp1146_;
4064 _tmp1148_ = vala_symbol_get_access ((ValaSymbol*) _tmp1147_);
4065 _tmp1149_ = _tmp1148_;
4066 _tmp1141_ = _tmp1149_ != VALA_SYMBOL_ACCESSIBILITY_PUBLIC;
4067 } else {
4068 _tmp1141_ = FALSE;
4069 }
4070 if (_tmp1141_) {
4071 ValaProperty* _tmp1150_;
4072 ValaPropertyAccessor* _tmp1151_;
4073 ValaPropertyAccessor* _tmp1152_;
4074 ValaSymbolAccessibility _tmp1153_;
4075 ValaSymbolAccessibility _tmp1154_;
4076 _tmp1150_ = prop;
4077 _tmp1151_ = vala_property_get_set_accessor (_tmp1150_);
4078 _tmp1152_ = _tmp1151_;
4079 _tmp1153_ = vala_symbol_get_access ((ValaSymbol*) _tmp1152_);
4080 _tmp1154_ = _tmp1153_;
4081 access = _tmp1154_;
4082 }
4083 }
4084 } else {
4085 ValaProperty* _tmp1155_;
4086 ValaPropertyAccessor* _tmp1156_;
4087 ValaPropertyAccessor* _tmp1157_;
4088 ValaProperty* _tmp1165_;
4089 ValaSymbolAccessibility _tmp1166_;
4090 ValaSymbolAccessibility _tmp1167_;
4091 _tmp1155_ = prop;
4092 _tmp1156_ = vala_property_get_get_accessor (_tmp1155_);
4093 _tmp1157_ = _tmp1156_;
4094 if (_tmp1157_ == NULL) {
4095 ValaSourceReference* _tmp1158_;
4096 ValaSourceReference* _tmp1159_;
4097 ValaProperty* _tmp1160_;
4098 gchar* _tmp1161_;
4099 gchar* _tmp1162_;
4100 gchar* _tmp1163_;
4101 gchar* _tmp1164_;
4102 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
4103 _tmp1158_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
4104 _tmp1159_ = _tmp1158_;
4105 _tmp1160_ = prop;
4106 _tmp1161_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp1160_);
4107 _tmp1162_ = _tmp1161_;
4108 _tmp1163_ = g_strdup_printf ("Property `%s' is write-only", _tmp1162_);
4109 _tmp1164_ = _tmp1163_;
4110 vala_report_error (_tmp1159_, _tmp1164_);
4111 _g_free0 (_tmp1164_);
4112 _g_free0 (_tmp1162_);
4113 result = FALSE;
4114 return result;
4115 }
4116 _tmp1165_ = prop;
4117 _tmp1166_ = vala_symbol_get_access ((ValaSymbol*) _tmp1165_);
4118 _tmp1167_ = _tmp1166_;
4119 if (_tmp1167_ == VALA_SYMBOL_ACCESSIBILITY_PUBLIC) {
4120 ValaProperty* _tmp1168_;
4121 ValaPropertyAccessor* _tmp1169_;
4122 ValaPropertyAccessor* _tmp1170_;
4123 ValaSymbolAccessibility _tmp1171_;
4124 ValaSymbolAccessibility _tmp1172_;
4125 _tmp1168_ = prop;
4126 _tmp1169_ = vala_property_get_get_accessor (_tmp1168_);
4127 _tmp1170_ = _tmp1169_;
4128 _tmp1171_ = vala_symbol_get_access ((ValaSymbol*) _tmp1170_);
4129 _tmp1172_ = _tmp1171_;
4130 access = _tmp1172_;
4131 } else {
4132 gboolean _tmp1173_ = FALSE;
4133 ValaProperty* _tmp1174_;
4134 ValaSymbolAccessibility _tmp1175_;
4135 ValaSymbolAccessibility _tmp1176_;
4136 _tmp1174_ = prop;
4137 _tmp1175_ = vala_symbol_get_access ((ValaSymbol*) _tmp1174_);
4138 _tmp1176_ = _tmp1175_;
4139 if (_tmp1176_ == VALA_SYMBOL_ACCESSIBILITY_PROTECTED) {
4140 ValaProperty* _tmp1177_;
4141 ValaPropertyAccessor* _tmp1178_;
4142 ValaPropertyAccessor* _tmp1179_;
4143 ValaSymbolAccessibility _tmp1180_;
4144 ValaSymbolAccessibility _tmp1181_;
4145 _tmp1177_ = prop;
4146 _tmp1178_ = vala_property_get_get_accessor (_tmp1177_);
4147 _tmp1179_ = _tmp1178_;
4148 _tmp1180_ = vala_symbol_get_access ((ValaSymbol*) _tmp1179_);
4149 _tmp1181_ = _tmp1180_;
4150 _tmp1173_ = _tmp1181_ != VALA_SYMBOL_ACCESSIBILITY_PUBLIC;
4151 } else {
4152 _tmp1173_ = FALSE;
4153 }
4154 if (_tmp1173_) {
4155 ValaProperty* _tmp1182_;
4156 ValaPropertyAccessor* _tmp1183_;
4157 ValaPropertyAccessor* _tmp1184_;
4158 ValaSymbolAccessibility _tmp1185_;
4159 ValaSymbolAccessibility _tmp1186_;
4160 _tmp1182_ = prop;
4161 _tmp1183_ = vala_property_get_get_accessor (_tmp1182_);
4162 _tmp1184_ = _tmp1183_;
4163 _tmp1185_ = vala_symbol_get_access ((ValaSymbol*) _tmp1184_);
4164 _tmp1186_ = _tmp1185_;
4165 access = _tmp1186_;
4166 }
4167 }
4168 }
4169 _tmp1187_ = prop;
4170 _tmp1188_ = vala_property_get_binding (_tmp1187_);
4171 _tmp1189_ = _tmp1188_;
4172 instance = _tmp1189_ == VALA_MEMBER_BINDING_INSTANCE;
4173 _tmp1190_ = prop;
4174 _tmp1191_ = vala_property_get_property_type (_tmp1190_);
4175 _tmp1192_ = _tmp1191_;
4176 if (VALA_IS_GENERIC_TYPE (_tmp1192_)) {
4177 generics = TRUE;
4178 }
4179 } else {
4180 ValaSymbol* _tmp1193_;
4181 _tmp1193_ = member;
4182 if (VALA_IS_SIGNAL (_tmp1193_)) {
4183 ValaSymbol* _tmp1194_;
4184 ValaSymbolAccessibility _tmp1195_;
4185 ValaSymbolAccessibility _tmp1196_;
4186 instance = TRUE;
4187 _tmp1194_ = member;
4188 _tmp1195_ = vala_symbol_get_access (_tmp1194_);
4189 _tmp1196_ = _tmp1195_;
4190 access = _tmp1196_;
4191 } else {
4192 gboolean _tmp1197_ = FALSE;
4193 gboolean _tmp1198_;
4194 _tmp1198_ = self->priv->_creation_member;
4195 if (!_tmp1198_) {
4196 ValaSymbol* _tmp1199_;
4197 _tmp1199_ = member;
4198 _tmp1197_ = VALA_IS_ERROR_CODE (_tmp1199_);
4199 } else {
4200 _tmp1197_ = FALSE;
4201 }
4202 if (_tmp1197_) {
4203 ValaSymbol* _tmp1200_;
4204 ValaConstant* _tmp1201_;
4205 ValaConstant* _tmp1202_;
4206 ValaSymbol* _tmp1203_;
4207 ValaSymbol* _tmp1204_;
4208 _tmp1200_ = member;
4209 _tmp1201_ = vala_error_code_get_code (G_TYPE_CHECK_INSTANCE_CAST (_tmp1200_, VALA_TYPE_ERROR_CODE, ValaErrorCode));
4210 _tmp1202_ = _tmp1201_;
4211 vala_expression_set_symbol_reference ((ValaExpression*) self, (ValaSymbol*) _tmp1202_);
4212 _tmp1203_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
4213 _tmp1204_ = _tmp1203_;
4214 member = _tmp1204_;
4215 }
4216 }
4217 }
4218 }
4219 }
4220 }
4221 }
4222 }
4223 parent = (ValaCodeNode*) self;
4224 while (TRUE) {
4225 ValaCodeNode* _tmp1205_;
4226 ValaSymbol* _tmp1206_;
4227 ValaCodeNode* _tmp1207_;
4228 ValaCodeNode* _tmp1208_;
4229 ValaCodeNode* _tmp1209_;
4230 gboolean _tmp1210_ = FALSE;
4231 ValaCodeNode* _tmp1211_;
4232 _tmp1205_ = parent;
4233 _tmp1206_ = member;
4234 if (!(_tmp1205_ != G_TYPE_CHECK_INSTANCE_CAST (_tmp1206_, VALA_TYPE_CODE_NODE, ValaCodeNode))) {
4235 break;
4236 }
4237 _tmp1207_ = parent;
4238 _tmp1208_ = vala_code_node_get_parent_node (_tmp1207_);
4239 _tmp1209_ = _tmp1208_;
4240 parent = _tmp1209_;
4241 _tmp1211_ = parent;
4242 if (_tmp1211_ == NULL) {
4243 _tmp1210_ = TRUE;
4244 } else {
4245 ValaCodeNode* _tmp1212_;
4246 ValaSymbol* _tmp1213_;
4247 _tmp1212_ = parent;
4248 _tmp1213_ = member;
4249 _tmp1210_ = _tmp1212_ == G_TYPE_CHECK_INSTANCE_CAST (_tmp1213_, VALA_TYPE_CODE_NODE, ValaCodeNode);
4250 }
4251 if (_tmp1210_) {
4252 break;
4253 }
4254 }
4255 _tmp1214_ = parent;
4256 _tmp1215_ = member;
4257 if (_tmp1214_ != G_TYPE_CHECK_INSTANCE_CAST (_tmp1215_, VALA_TYPE_CODE_NODE, ValaCodeNode)) {
4258 ValaSymbol* _tmp1216_;
4259 _tmp1216_ = member;
4260 vala_symbol_set_used (_tmp1216_, TRUE);
4261 }
4262 _tmp1217_ = member;
4263 _tmp1218_ = vala_symbol_get_version (_tmp1217_);
4264 _tmp1219_ = _tmp1218_;
4265 _tmp1220_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
4266 _tmp1221_ = _tmp1220_;
4267 vala_version_attribute_check (_tmp1219_, _tmp1221_);
4268 _tmp1223_ = access;
4269 if (_tmp1223_ == VALA_SYMBOL_ACCESSIBILITY_PROTECTED) {
4270 ValaSymbol* _tmp1224_;
4271 ValaSymbol* _tmp1225_;
4272 ValaSymbol* _tmp1226_;
4273 _tmp1224_ = member;
4274 _tmp1225_ = vala_symbol_get_parent_symbol (_tmp1224_);
4275 _tmp1226_ = _tmp1225_;
4276 _tmp1222_ = VALA_IS_TYPESYMBOL (_tmp1226_);
4277 } else {
4278 _tmp1222_ = FALSE;
4279 }
4280 if (_tmp1222_) {
4281 ValaTypeSymbol* target_type = NULL;
4282 ValaSymbol* _tmp1227_;
4283 ValaSymbol* _tmp1228_;
4284 ValaSymbol* _tmp1229_;
4285 gboolean in_subtype = FALSE;
4286 _tmp1227_ = member;
4287 _tmp1228_ = vala_symbol_get_parent_symbol (_tmp1227_);
4288 _tmp1229_ = _tmp1228_;
4289 target_type = G_TYPE_CHECK_INSTANCE_CAST (_tmp1229_, VALA_TYPE_TYPESYMBOL, ValaTypeSymbol);
4290 in_subtype = FALSE;
4291 {
4292 ValaSymbol* this_symbol = NULL;
4293 ValaSemanticAnalyzer* _tmp1230_;
4294 ValaSemanticAnalyzer* _tmp1231_;
4295 ValaSymbol* _tmp1232_;
4296 ValaSymbol* _tmp1233_;
4297 ValaSymbol* _tmp1234_;
4298 _tmp1230_ = vala_code_context_get_analyzer (context);
4299 _tmp1231_ = _tmp1230_;
4300 _tmp1232_ = vala_semantic_analyzer_get_current_symbol (_tmp1231_);
4301 _tmp1233_ = _tmp1232_;
4302 _tmp1234_ = _vala_code_node_ref0 (_tmp1233_);
4303 this_symbol = _tmp1234_;
4304 {
4305 gboolean _tmp1235_ = FALSE;
4306 _tmp1235_ = TRUE;
4307 while (TRUE) {
4308 ValaSymbol* _tmp1240_;
4309 ValaSymbol* _tmp1241_;
4310 ValaTypeSymbol* _tmp1242_;
4311 ValaClass* cl = NULL;
4312 ValaSymbol* _tmp1243_;
4313 gboolean _tmp1244_ = FALSE;
4314 ValaClass* _tmp1245_;
4315 if (!_tmp1235_) {
4316 ValaSymbol* _tmp1236_;
4317 ValaSymbol* _tmp1237_;
4318 ValaSymbol* _tmp1238_;
4319 ValaSymbol* _tmp1239_;
4320 _tmp1236_ = this_symbol;
4321 _tmp1237_ = vala_symbol_get_parent_symbol (_tmp1236_);
4322 _tmp1238_ = _tmp1237_;
4323 _tmp1239_ = _vala_code_node_ref0 (_tmp1238_);
4324 _vala_code_node_unref0 (this_symbol);
4325 this_symbol = _tmp1239_;
4326 }
4327 _tmp1235_ = FALSE;
4328 _tmp1240_ = this_symbol;
4329 if (!(_tmp1240_ != NULL)) {
4330 break;
4331 }
4332 _tmp1241_ = this_symbol;
4333 _tmp1242_ = target_type;
4334 if (_tmp1241_ == G_TYPE_CHECK_INSTANCE_CAST (_tmp1242_, VALA_TYPE_SYMBOL, ValaSymbol)) {
4335 in_subtype = TRUE;
4336 break;
4337 }
4338 _tmp1243_ = this_symbol;
4339 cl = VALA_IS_CLASS (_tmp1243_) ? ((ValaClass*) _tmp1243_) : NULL;
4340 _tmp1245_ = cl;
4341 if (_tmp1245_ != NULL) {
4342 ValaClass* _tmp1246_;
4343 ValaTypeSymbol* _tmp1247_;
4344 _tmp1246_ = cl;
4345 _tmp1247_ = target_type;
4346 _tmp1244_ = vala_typesymbol_is_subtype_of ((ValaTypeSymbol*) _tmp1246_, _tmp1247_);
4347 } else {
4348 _tmp1244_ = FALSE;
4349 }
4350 if (_tmp1244_) {
4351 in_subtype = TRUE;
4352 break;
4353 }
4354 }
4355 }
4356 _vala_code_node_unref0 (this_symbol);
4357 }
4358 if (!in_subtype) {
4359 ValaSourceReference* _tmp1248_;
4360 ValaSourceReference* _tmp1249_;
4361 ValaSymbol* _tmp1250_;
4362 gchar* _tmp1251_;
4363 gchar* _tmp1252_;
4364 gchar* _tmp1253_;
4365 gchar* _tmp1254_;
4366 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
4367 _tmp1248_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
4368 _tmp1249_ = _tmp1248_;
4369 _tmp1250_ = member;
4370 _tmp1251_ = vala_symbol_get_full_name (_tmp1250_);
4371 _tmp1252_ = _tmp1251_;
4372 _tmp1253_ = g_strdup_printf ("Access to protected member `%s' denied", _tmp1252_);
4373 _tmp1254_ = _tmp1253_;
4374 vala_report_error (_tmp1249_, _tmp1254_);
4375 _g_free0 (_tmp1254_);
4376 _g_free0 (_tmp1252_);
4377 result = FALSE;
4378 return result;
4379 }
4380 } else {
4381 ValaSymbolAccessibility _tmp1255_;
4382 _tmp1255_ = access;
4383 if (_tmp1255_ == VALA_SYMBOL_ACCESSIBILITY_PRIVATE) {
4384 ValaSymbol* target_type = NULL;
4385 ValaSymbol* _tmp1256_;
4386 ValaSymbol* _tmp1257_;
4387 ValaSymbol* _tmp1258_;
4388 gboolean in_target_type = FALSE;
4389 _tmp1256_ = member;
4390 _tmp1257_ = vala_symbol_get_parent_symbol (_tmp1256_);
4391 _tmp1258_ = _tmp1257_;
4392 target_type = _tmp1258_;
4393 in_target_type = FALSE;
4394 {
4395 ValaSymbol* this_symbol = NULL;
4396 ValaSemanticAnalyzer* _tmp1259_;
4397 ValaSemanticAnalyzer* _tmp1260_;
4398 ValaSymbol* _tmp1261_;
4399 ValaSymbol* _tmp1262_;
4400 ValaSymbol* _tmp1263_;
4401 _tmp1259_ = vala_code_context_get_analyzer (context);
4402 _tmp1260_ = _tmp1259_;
4403 _tmp1261_ = vala_semantic_analyzer_get_current_symbol (_tmp1260_);
4404 _tmp1262_ = _tmp1261_;
4405 _tmp1263_ = _vala_code_node_ref0 (_tmp1262_);
4406 this_symbol = _tmp1263_;
4407 {
4408 gboolean _tmp1264_ = FALSE;
4409 _tmp1264_ = TRUE;
4410 while (TRUE) {
4411 ValaSymbol* _tmp1269_;
4412 ValaSymbol* _tmp1270_;
4413 ValaSymbol* _tmp1271_;
4414 if (!_tmp1264_) {
4415 ValaSymbol* _tmp1265_;
4416 ValaSymbol* _tmp1266_;
4417 ValaSymbol* _tmp1267_;
4418 ValaSymbol* _tmp1268_;
4419 _tmp1265_ = this_symbol;
4420 _tmp1266_ = vala_symbol_get_parent_symbol (_tmp1265_);
4421 _tmp1267_ = _tmp1266_;
4422 _tmp1268_ = _vala_code_node_ref0 (_tmp1267_);
4423 _vala_code_node_unref0 (this_symbol);
4424 this_symbol = _tmp1268_;
4425 }
4426 _tmp1264_ = FALSE;
4427 _tmp1269_ = this_symbol;
4428 if (!(_tmp1269_ != NULL)) {
4429 break;
4430 }
4431 _tmp1270_ = target_type;
4432 _tmp1271_ = this_symbol;
4433 if (_tmp1270_ == _tmp1271_) {
4434 in_target_type = TRUE;
4435 break;
4436 }
4437 }
4438 }
4439 _vala_code_node_unref0 (this_symbol);
4440 }
4441 if (!in_target_type) {
4442 ValaSourceReference* _tmp1272_;
4443 ValaSourceReference* _tmp1273_;
4444 ValaSymbol* _tmp1274_;
4445 gchar* _tmp1275_;
4446 gchar* _tmp1276_;
4447 gchar* _tmp1277_;
4448 gchar* _tmp1278_;
4449 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
4450 _tmp1272_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
4451 _tmp1273_ = _tmp1272_;
4452 _tmp1274_ = member;
4453 _tmp1275_ = vala_symbol_get_full_name (_tmp1274_);
4454 _tmp1276_ = _tmp1275_;
4455 _tmp1277_ = g_strdup_printf ("Access to private member `%s' denied", _tmp1276_);
4456 _tmp1278_ = _tmp1277_;
4457 vala_report_error (_tmp1273_, _tmp1278_);
4458 _g_free0 (_tmp1278_);
4459 _g_free0 (_tmp1276_);
4460 result = FALSE;
4461 return result;
4462 }
4463 }
4464 }
4465 if (generics) {
4466 ValaExpression* _tmp1280_;
4467 ValaExpression* _tmp1281_;
4468 _tmp1280_ = vala_member_access_get_inner (self);
4469 _tmp1281_ = _tmp1280_;
4470 _tmp1279_ = _tmp1281_ != NULL;
4471 } else {
4472 _tmp1279_ = FALSE;
4473 }
4474 if (_tmp1279_) {
4475 ValaDataType* instance_type = NULL;
4476 ValaExpression* _tmp1282_;
4477 ValaExpression* _tmp1283_;
4478 ValaDataType* _tmp1284_;
4479 ValaDataType* _tmp1285_;
4480 ValaPointerType* pointer_type = NULL;
4481 ValaExpression* _tmp1286_;
4482 ValaExpression* _tmp1287_;
4483 ValaDataType* _tmp1288_;
4484 ValaDataType* _tmp1289_;
4485 ValaPointerType* _tmp1290_;
4486 ValaObjectType* object_type = NULL;
4487 ValaDataType* _tmp1294_;
4488 gboolean _tmp1295_ = FALSE;
4489 gboolean _tmp1296_ = FALSE;
4490 ValaObjectType* _tmp1297_;
4491 _tmp1282_ = vala_member_access_get_inner (self);
4492 _tmp1283_ = _tmp1282_;
4493 _tmp1284_ = vala_expression_get_value_type (_tmp1283_);
4494 _tmp1285_ = _tmp1284_;
4495 instance_type = _tmp1285_;
4496 _tmp1286_ = vala_member_access_get_inner (self);
4497 _tmp1287_ = _tmp1286_;
4498 _tmp1288_ = vala_expression_get_value_type (_tmp1287_);
4499 _tmp1289_ = _tmp1288_;
4500 pointer_type = VALA_IS_POINTER_TYPE (_tmp1289_) ? ((ValaPointerType*) _tmp1289_) : NULL;
4501 _tmp1290_ = pointer_type;
4502 if (_tmp1290_ != NULL) {
4503 ValaPointerType* _tmp1291_;
4504 ValaDataType* _tmp1292_;
4505 ValaDataType* _tmp1293_;
4506 _tmp1291_ = pointer_type;
4507 _tmp1292_ = vala_pointer_type_get_base_type (_tmp1291_);
4508 _tmp1293_ = _tmp1292_;
4509 instance_type = _tmp1293_;
4510 }
4511 _tmp1294_ = instance_type;
4512 object_type = VALA_IS_OBJECT_TYPE (_tmp1294_) ? ((ValaObjectType*) _tmp1294_) : NULL;
4513 _tmp1297_ = object_type;
4514 if (_tmp1297_ != NULL) {
4515 ValaObjectType* _tmp1298_;
4516 ValaObjectTypeSymbol* _tmp1299_;
4517 ValaObjectTypeSymbol* _tmp1300_;
4518 _tmp1298_ = object_type;
4519 _tmp1299_ = vala_object_type_get_object_type_symbol (_tmp1298_);
4520 _tmp1300_ = _tmp1299_;
4521 _tmp1296_ = vala_object_type_symbol_has_type_parameters (_tmp1300_);
4522 } else {
4523 _tmp1296_ = FALSE;
4524 }
4525 if (_tmp1296_) {
4526 ValaDataType* _tmp1301_;
4527 _tmp1301_ = instance_type;
4528 _tmp1295_ = !vala_data_type_has_type_arguments (_tmp1301_);
4529 } else {
4530 _tmp1295_ = FALSE;
4531 }
4532 if (_tmp1295_) {
4533 ValaExpression* _tmp1302_;
4534 ValaExpression* _tmp1303_;
4535 ValaSourceReference* _tmp1304_;
4536 ValaSourceReference* _tmp1305_;
4537 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
4538 _tmp1302_ = vala_member_access_get_inner (self);
4539 _tmp1303_ = _tmp1302_;
4540 _tmp1304_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp1303_);
4541 _tmp1305_ = _tmp1304_;
4542 vala_report_error (_tmp1305_, "missing generic type arguments");
4543 result = FALSE;
4544 return result;
4545 }
4546 }
4547 if (instance) {
4548 _tmp1307_ = !may_access_instance_members;
4549 } else {
4550 _tmp1307_ = FALSE;
4551 }
4552 if (_tmp1307_) {
4553 _tmp1306_ = TRUE;
4554 } else {
4555 gboolean _tmp1308_ = FALSE;
4556 if (klass) {
4557 _tmp1308_ = !may_access_klass_members;
4558 } else {
4559 _tmp1308_ = FALSE;
4560 }
4561 _tmp1306_ = _tmp1308_;
4562 }
4563 if (_tmp1306_) {
4564 ValaSymbol* _tmp1309_;
4565 ValaSymbol* _tmp1310_;
4566 ValaDataType* _tmp1333_;
4567 ValaDataType* _tmp1334_;
4568 vala_member_access_set_prototype_access (self, TRUE);
4569 _tmp1309_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
4570 _tmp1310_ = _tmp1309_;
4571 if (VALA_IS_METHOD (_tmp1310_)) {
4572 ValaSemanticAnalyzer* _tmp1311_;
4573 ValaSemanticAnalyzer* _tmp1312_;
4574 ValaSymbol* _tmp1313_;
4575 ValaSymbol* _tmp1314_;
4576 gboolean _tmp1315_;
4577 gboolean _tmp1316_;
4578 ValaDataType* _tmp1317_;
4579 ValaDataType* _tmp1318_;
4580 _tmp1311_ = vala_code_context_get_analyzer (context);
4581 _tmp1312_ = _tmp1311_;
4582 _tmp1313_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
4583 _tmp1314_ = _tmp1313_;
4584 _tmp1315_ = vala_expression_get_lvalue ((ValaExpression*) self);
4585 _tmp1316_ = _tmp1315_;
4586 _tmp1317_ = vala_semantic_analyzer_get_value_type_for_symbol (_tmp1312_, _tmp1314_, _tmp1316_);
4587 _tmp1318_ = _tmp1317_;
4588 vala_expression_set_value_type ((ValaExpression*) self, _tmp1318_);
4589 _vala_code_node_unref0 (_tmp1318_);
4590 } else {
4591 ValaSymbol* _tmp1319_;
4592 ValaSymbol* _tmp1320_;
4593 _tmp1319_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
4594 _tmp1320_ = _tmp1319_;
4595 if (VALA_IS_FIELD (_tmp1320_)) {
4596 ValaSymbol* _tmp1321_;
4597 ValaSymbol* _tmp1322_;
4598 ValaFieldPrototype* _tmp1323_;
4599 ValaFieldPrototype* _tmp1324_;
4600 _tmp1321_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
4601 _tmp1322_ = _tmp1321_;
4602 _tmp1323_ = vala_field_prototype_new (G_TYPE_CHECK_INSTANCE_CAST (_tmp1322_, VALA_TYPE_FIELD, ValaField));
4603 _tmp1324_ = _tmp1323_;
4604 vala_expression_set_value_type ((ValaExpression*) self, (ValaDataType*) _tmp1324_);
4605 _vala_code_node_unref0 (_tmp1324_);
4606 } else {
4607 ValaSymbol* _tmp1325_;
4608 ValaSymbol* _tmp1326_;
4609 _tmp1325_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
4610 _tmp1326_ = _tmp1325_;
4611 if (VALA_IS_PROPERTY (_tmp1326_)) {
4612 ValaSymbol* _tmp1327_;
4613 ValaSymbol* _tmp1328_;
4614 ValaPropertyPrototype* _tmp1329_;
4615 ValaPropertyPrototype* _tmp1330_;
4616 _tmp1327_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
4617 _tmp1328_ = _tmp1327_;
4618 _tmp1329_ = vala_property_prototype_new (G_TYPE_CHECK_INSTANCE_CAST (_tmp1328_, VALA_TYPE_PROPERTY, ValaProperty));
4619 _tmp1330_ = _tmp1329_;
4620 vala_expression_set_value_type ((ValaExpression*) self, (ValaDataType*) _tmp1330_);
4621 _vala_code_node_unref0 (_tmp1330_);
4622 } else {
4623 ValaInvalidType* _tmp1331_;
4624 ValaInvalidType* _tmp1332_;
4625 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
4626 _tmp1331_ = vala_invalid_type_new ();
4627 _tmp1332_ = _tmp1331_;
4628 vala_expression_set_value_type ((ValaExpression*) self, (ValaDataType*) _tmp1332_);
4629 _vala_code_node_unref0 (_tmp1332_);
4630 }
4631 }
4632 }
4633 _tmp1333_ = vala_expression_get_target_type ((ValaExpression*) self);
4634 _tmp1334_ = _tmp1333_;
4635 if (_tmp1334_ != NULL) {
4636 ValaDataType* _tmp1335_;
4637 ValaDataType* _tmp1336_;
4638 ValaDataType* _tmp1337_;
4639 ValaDataType* _tmp1338_;
4640 gboolean _tmp1339_;
4641 gboolean _tmp1340_;
4642 _tmp1335_ = vala_expression_get_value_type ((ValaExpression*) self);
4643 _tmp1336_ = _tmp1335_;
4644 _tmp1337_ = vala_expression_get_target_type ((ValaExpression*) self);
4645 _tmp1338_ = _tmp1337_;
4646 _tmp1339_ = vala_data_type_get_value_owned (_tmp1338_);
4647 _tmp1340_ = _tmp1339_;
4648 vala_data_type_set_value_owned (_tmp1336_, _tmp1340_);
4649 }
4650 } else {
4651 gboolean _tmp1341_ = FALSE;
4652 gboolean _tmp1362_ = FALSE;
4653 gboolean _tmp1363_ = FALSE;
4654 gboolean _tmp1364_ = FALSE;
4655 gboolean _tmp1365_ = FALSE;
4656 gboolean _tmp1408_ = FALSE;
4657 gboolean _tmp1409_ = FALSE;
4658 gboolean _tmp1410_ = FALSE;
4659 gboolean _tmp1411_ = FALSE;
4660 gboolean _tmp1412_ = FALSE;
4661 gboolean _tmp1413_;
4662 gboolean _tmp1414_;
4663 ValaMethod* m = NULL;
4664 ValaSymbol* _tmp1441_;
4665 ValaSymbol* _tmp1442_;
4666 ValaMemberAccess* inner_ma = NULL;
4667 ValaExpression* _tmp1443_;
4668 ValaExpression* _tmp1444_;
4669 gboolean _tmp1445_ = FALSE;
4670 gboolean _tmp1446_ = FALSE;
4671 gboolean _tmp1447_ = FALSE;
4672 gboolean _tmp1448_ = FALSE;
4673 gboolean _tmp1449_ = FALSE;
4674 ValaMethod* _tmp1450_;
4675 ValaSemanticAnalyzer* _tmp1489_;
4676 ValaSemanticAnalyzer* _tmp1490_;
4677 ValaSymbol* _tmp1491_;
4678 ValaSymbol* _tmp1492_;
4679 gboolean _tmp1493_;
4680 gboolean _tmp1494_;
4681 ValaDataType* _tmp1495_;
4682 ValaDataType* _tmp1496_;
4683 gboolean _tmp1497_ = FALSE;
4684 ValaExpression* _tmp1498_;
4685 ValaExpression* _tmp1499_;
4686 ValaSymbol* _tmp1512_;
4687 ValaSymbol* _tmp1513_;
4688 if (instance) {
4689 ValaExpression* _tmp1342_;
4690 ValaExpression* _tmp1343_;
4691 _tmp1342_ = vala_member_access_get_inner (self);
4692 _tmp1343_ = _tmp1342_;
4693 _tmp1341_ = _tmp1343_ == NULL;
4694 } else {
4695 _tmp1341_ = FALSE;
4696 }
4697 if (_tmp1341_) {
4698 ValaSourceReference* _tmp1344_;
4699 ValaSourceReference* _tmp1345_;
4700 ValaMemberAccess* _tmp1346_;
4701 ValaMemberAccess* _tmp1347_;
4702 ValaExpression* _tmp1348_;
4703 ValaExpression* _tmp1349_;
4704 ValaParameter* _tmp1350_;
4705 ValaDataType* _tmp1351_;
4706 ValaDataType* _tmp1352_;
4707 ValaDataType* _tmp1353_;
4708 ValaDataType* _tmp1354_;
4709 ValaExpression* _tmp1355_;
4710 ValaExpression* _tmp1356_;
4711 ValaDataType* _tmp1357_;
4712 ValaDataType* _tmp1358_;
4713 ValaExpression* _tmp1359_;
4714 ValaExpression* _tmp1360_;
4715 ValaParameter* _tmp1361_;
4716 _tmp1344_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
4717 _tmp1345_ = _tmp1344_;
4718 _tmp1346_ = vala_member_access_new (NULL, "this", _tmp1345_);
4719 _tmp1347_ = _tmp1346_;
4720 vala_member_access_set_inner (self, (ValaExpression*) _tmp1347_);
4721 _vala_code_node_unref0 (_tmp1347_);
4722 _tmp1348_ = vala_member_access_get_inner (self);
4723 _tmp1349_ = _tmp1348_;
4724 _tmp1350_ = this_parameter;
4725 _tmp1351_ = vala_variable_get_variable_type ((ValaVariable*) _tmp1350_);
4726 _tmp1352_ = _tmp1351_;
4727 _tmp1353_ = vala_data_type_copy (_tmp1352_);
4728 _tmp1354_ = _tmp1353_;
4729 vala_expression_set_value_type (_tmp1349_, _tmp1354_);
4730 _vala_code_node_unref0 (_tmp1354_);
4731 _tmp1355_ = vala_member_access_get_inner (self);
4732 _tmp1356_ = _tmp1355_;
4733 _tmp1357_ = vala_expression_get_value_type (_tmp1356_);
4734 _tmp1358_ = _tmp1357_;
4735 vala_data_type_set_value_owned (_tmp1358_, FALSE);
4736 _tmp1359_ = vala_member_access_get_inner (self);
4737 _tmp1360_ = _tmp1359_;
4738 _tmp1361_ = this_parameter;
4739 vala_expression_set_symbol_reference (_tmp1360_, (ValaSymbol*) _tmp1361_);
4740 } else {
4741 vala_member_access_check_lvalue_access (self);
4742 }
4743 if (!instance) {
4744 _tmp1365_ = !klass;
4745 } else {
4746 _tmp1365_ = FALSE;
4747 }
4748 if (_tmp1365_) {
4749 ValaSymbol* _tmp1366_;
4750 ValaSymbol* _tmp1367_;
4751 _tmp1366_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
4752 _tmp1367_ = _tmp1366_;
4753 _tmp1364_ = !VALA_IS_CREATION_METHOD (_tmp1367_);
4754 } else {
4755 _tmp1364_ = FALSE;
4756 }
4757 if (_tmp1364_) {
4758 _tmp1363_ = may_access_instance_members;
4759 } else {
4760 _tmp1363_ = FALSE;
4761 }
4762 if (_tmp1363_) {
4763 ValaExpression* _tmp1368_;
4764 ValaExpression* _tmp1369_;
4765 _tmp1368_ = vala_member_access_get_inner (self);
4766 _tmp1369_ = _tmp1368_;
4767 _tmp1362_ = _tmp1369_ != NULL;
4768 } else {
4769 _tmp1362_ = FALSE;
4770 }
4771 if (_tmp1362_) {
4772 ValaExpression* _tmp1370_;
4773 ValaExpression* _tmp1371_;
4774 ValaSymbol* _tmp1372_;
4775 ValaSymbol* _tmp1373_;
4776 _tmp1370_ = vala_member_access_get_inner (self);
4777 _tmp1371_ = _tmp1370_;
4778 _tmp1372_ = vala_expression_get_symbol_reference (_tmp1371_);
4779 _tmp1373_ = _tmp1372_;
4780 if (VALA_IS_METHOD (_tmp1373_)) {
4781 } else {
4782 ValaSourceReference* _tmp1374_;
4783 ValaSourceReference* _tmp1375_;
4784 ValaSymbol* _tmp1376_;
4785 ValaSymbol* _tmp1377_;
4786 gchar* _tmp1378_;
4787 gchar* _tmp1379_;
4788 gchar* _tmp1380_;
4789 gchar* _tmp1381_;
4790 ValaSymbol* inner_sym = NULL;
4791 ValaSymbol* _tmp1382_;
4792 ValaSymbol* _tmp1383_;
4793 ValaSymbol* _tmp1384_;
4794 ValaSymbol* _tmp1385_;
4795 ValaMemberAccess* inner_ma = NULL;
4796 ValaMemberAccess* _tmp1405_;
4797 ValaExpression* _tmp1406_;
4798 ValaExpression* _tmp1407_;
4799 _tmp1374_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
4800 _tmp1375_ = _tmp1374_;
4801 _tmp1376_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
4802 _tmp1377_ = _tmp1376_;
4803 _tmp1378_ = vala_symbol_get_full_name (_tmp1377_);
4804 _tmp1379_ = _tmp1378_;
4805 _tmp1380_ = g_strdup_printf ("Access to static member `%s' with an instance reference", _tmp1379_);
4806 _tmp1381_ = _tmp1380_;
4807 vala_report_warning (_tmp1375_, _tmp1381_);
4808 _g_free0 (_tmp1381_);
4809 _g_free0 (_tmp1379_);
4810 _tmp1382_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
4811 _tmp1383_ = _tmp1382_;
4812 _tmp1384_ = vala_symbol_get_parent_symbol (_tmp1383_);
4813 _tmp1385_ = _tmp1384_;
4814 inner_sym = _tmp1385_;
4815 inner_ma = self;
4816 while (TRUE) {
4817 gboolean _tmp1386_ = FALSE;
4818 ValaSymbol* _tmp1387_;
4819 ValaMemberAccess* _tmp1391_;
4820 ValaSymbol* _tmp1392_;
4821 const gchar* _tmp1393_;
4822 const gchar* _tmp1394_;
4823 ValaSourceReference* _tmp1395_;
4824 ValaSourceReference* _tmp1396_;
4825 ValaMemberAccess* _tmp1397_;
4826 ValaMemberAccess* _tmp1398_;
4827 ValaMemberAccess* _tmp1399_;
4828 ValaExpression* _tmp1400_;
4829 ValaExpression* _tmp1401_;
4830 ValaSymbol* _tmp1402_;
4831 ValaSymbol* _tmp1403_;
4832 ValaSymbol* _tmp1404_;
4833 _tmp1387_ = inner_sym;
4834 if (_tmp1387_ != NULL) {
4835 ValaSymbol* _tmp1388_;
4836 const gchar* _tmp1389_;
4837 const gchar* _tmp1390_;
4838 _tmp1388_ = inner_sym;
4839 _tmp1389_ = vala_symbol_get_name (_tmp1388_);
4840 _tmp1390_ = _tmp1389_;
4841 _tmp1386_ = _tmp1390_ != NULL;
4842 } else {
4843 _tmp1386_ = FALSE;
4844 }
4845 if (!_tmp1386_) {
4846 break;
4847 }
4848 _tmp1391_ = inner_ma;
4849 _tmp1392_ = inner_sym;
4850 _tmp1393_ = vala_symbol_get_name (_tmp1392_);
4851 _tmp1394_ = _tmp1393_;
4852 _tmp1395_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
4853 _tmp1396_ = _tmp1395_;
4854 _tmp1397_ = vala_member_access_new (NULL, _tmp1394_, _tmp1396_);
4855 _tmp1398_ = _tmp1397_;
4856 vala_member_access_set_inner (_tmp1391_, (ValaExpression*) _tmp1398_);
4857 _vala_code_node_unref0 (_tmp1398_);
4858 _tmp1399_ = inner_ma;
4859 _tmp1400_ = vala_member_access_get_inner (_tmp1399_);
4860 _tmp1401_ = _tmp1400_;
4861 inner_ma = G_TYPE_CHECK_INSTANCE_CAST (_tmp1401_, VALA_TYPE_MEMBER_ACCESS, ValaMemberAccess);
4862 _tmp1402_ = inner_sym;
4863 _tmp1403_ = vala_symbol_get_parent_symbol (_tmp1402_);
4864 _tmp1404_ = _tmp1403_;
4865 inner_sym = _tmp1404_;
4866 }
4867 _tmp1405_ = inner_ma;
4868 vala_member_access_set_qualified (_tmp1405_, TRUE);
4869 _tmp1406_ = vala_member_access_get_inner (self);
4870 _tmp1407_ = _tmp1406_;
4871 vala_code_node_check ((ValaCodeNode*) _tmp1407_, context);
4872 }
4873 }
4874 _tmp1413_ = vala_code_context_get_experimental_non_null (context);
4875 _tmp1414_ = _tmp1413_;
4876 if (_tmp1414_) {
4877 _tmp1412_ = instance;
4878 } else {
4879 _tmp1412_ = FALSE;
4880 }
4881 if (_tmp1412_) {
4882 ValaExpression* _tmp1415_;
4883 ValaExpression* _tmp1416_;
4884 ValaDataType* _tmp1417_;
4885 ValaDataType* _tmp1418_;
4886 gboolean _tmp1419_;
4887 gboolean _tmp1420_;
4888 _tmp1415_ = vala_member_access_get_inner (self);
4889 _tmp1416_ = _tmp1415_;
4890 _tmp1417_ = vala_expression_get_value_type (_tmp1416_);
4891 _tmp1418_ = _tmp1417_;
4892 _tmp1419_ = vala_data_type_get_nullable (_tmp1418_);
4893 _tmp1420_ = _tmp1419_;
4894 _tmp1411_ = _tmp1420_;
4895 } else {
4896 _tmp1411_ = FALSE;
4897 }
4898 if (_tmp1411_) {
4899 ValaExpression* _tmp1421_;
4900 ValaExpression* _tmp1422_;
4901 ValaDataType* _tmp1423_;
4902 ValaDataType* _tmp1424_;
4903 _tmp1421_ = vala_member_access_get_inner (self);
4904 _tmp1422_ = _tmp1421_;
4905 _tmp1423_ = vala_expression_get_value_type (_tmp1422_);
4906 _tmp1424_ = _tmp1423_;
4907 _tmp1410_ = !VALA_IS_POINTER_TYPE (_tmp1424_);
4908 } else {
4909 _tmp1410_ = FALSE;
4910 }
4911 if (_tmp1410_) {
4912 ValaExpression* _tmp1425_;
4913 ValaExpression* _tmp1426_;
4914 ValaDataType* _tmp1427_;
4915 ValaDataType* _tmp1428_;
4916 _tmp1425_ = vala_member_access_get_inner (self);
4917 _tmp1426_ = _tmp1425_;
4918 _tmp1427_ = vala_expression_get_value_type (_tmp1426_);
4919 _tmp1428_ = _tmp1427_;
4920 _tmp1409_ = !VALA_IS_GENERIC_TYPE (_tmp1428_);
4921 } else {
4922 _tmp1409_ = FALSE;
4923 }
4924 if (_tmp1409_) {
4925 ValaExpression* _tmp1429_;
4926 ValaExpression* _tmp1430_;
4927 ValaDataType* _tmp1431_;
4928 ValaDataType* _tmp1432_;
4929 _tmp1429_ = vala_member_access_get_inner (self);
4930 _tmp1430_ = _tmp1429_;
4931 _tmp1431_ = vala_expression_get_value_type (_tmp1430_);
4932 _tmp1432_ = _tmp1431_;
4933 _tmp1408_ = !VALA_IS_ARRAY_TYPE (_tmp1432_);
4934 } else {
4935 _tmp1408_ = FALSE;
4936 }
4937 if (_tmp1408_) {
4938 ValaSourceReference* _tmp1433_;
4939 ValaSourceReference* _tmp1434_;
4940 ValaSymbol* _tmp1435_;
4941 ValaSymbol* _tmp1436_;
4942 gchar* _tmp1437_;
4943 gchar* _tmp1438_;
4944 gchar* _tmp1439_;
4945 gchar* _tmp1440_;
4946 _tmp1433_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
4947 _tmp1434_ = _tmp1433_;
4948 _tmp1435_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
4949 _tmp1436_ = _tmp1435_;
4950 _tmp1437_ = vala_symbol_get_full_name (_tmp1436_);
4951 _tmp1438_ = _tmp1437_;
4952 _tmp1439_ = g_strdup_printf ("Access to instance member `%s' from nullable reference denied", _tmp1438_);
4953 _tmp1440_ = _tmp1439_;
4954 vala_report_error (_tmp1434_, _tmp1440_);
4955 _g_free0 (_tmp1440_);
4956 _g_free0 (_tmp1438_);
4957 }
4958 _tmp1441_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
4959 _tmp1442_ = _tmp1441_;
4960 m = VALA_IS_METHOD (_tmp1442_) ? ((ValaMethod*) _tmp1442_) : NULL;
4961 _tmp1443_ = vala_member_access_get_inner (self);
4962 _tmp1444_ = _tmp1443_;
4963 inner_ma = VALA_IS_MEMBER_ACCESS (_tmp1444_) ? ((ValaMemberAccess*) _tmp1444_) : NULL;
4964 _tmp1450_ = m;
4965 if (_tmp1450_ != NULL) {
4966 ValaMethod* _tmp1451_;
4967 ValaMemberBinding _tmp1452_;
4968 ValaMemberBinding _tmp1453_;
4969 _tmp1451_ = m;
4970 _tmp1452_ = vala_method_get_binding (_tmp1451_);
4971 _tmp1453_ = _tmp1452_;
4972 _tmp1449_ = _tmp1453_ == VALA_MEMBER_BINDING_STATIC;
4973 } else {
4974 _tmp1449_ = FALSE;
4975 }
4976 if (_tmp1449_) {
4977 ValaMethod* _tmp1454_;
4978 ValaSymbol* _tmp1455_;
4979 ValaSymbol* _tmp1456_;
4980 _tmp1454_ = m;
4981 _tmp1455_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp1454_);
4982 _tmp1456_ = _tmp1455_;
4983 _tmp1448_ = VALA_IS_OBJECT_TYPE_SYMBOL (_tmp1456_);
4984 } else {
4985 _tmp1448_ = FALSE;
4986 }
4987 if (_tmp1448_) {
4988 ValaExpression* _tmp1457_;
4989 ValaExpression* _tmp1458_;
4990 _tmp1457_ = vala_member_access_get_inner (self);
4991 _tmp1458_ = _tmp1457_;
4992 _tmp1447_ = _tmp1458_ != NULL;
4993 } else {
4994 _tmp1447_ = FALSE;
4995 }
4996 if (_tmp1447_) {
4997 ValaExpression* _tmp1459_;
4998 ValaExpression* _tmp1460_;
4999 ValaDataType* _tmp1461_;
5000 ValaDataType* _tmp1462_;
5001 _tmp1459_ = vala_member_access_get_inner (self);
5002 _tmp1460_ = _tmp1459_;
5003 _tmp1461_ = vala_expression_get_value_type (_tmp1460_);
5004 _tmp1462_ = _tmp1461_;
5005 _tmp1446_ = _tmp1462_ == NULL;
5006 } else {
5007 _tmp1446_ = FALSE;
5008 }
5009 if (_tmp1446_) {
5010 ValaMemberAccess* _tmp1463_;
5011 ValaList* _tmp1464_;
5012 gint _tmp1465_;
5013 gint _tmp1466_;
5014 _tmp1463_ = inner_ma;
5015 _tmp1464_ = _tmp1463_->priv->type_argument_list;
5016 _tmp1465_ = vala_collection_get_size ((ValaCollection*) _tmp1464_);
5017 _tmp1466_ = _tmp1465_;
5018 _tmp1445_ = _tmp1466_ > 0;
5019 } else {
5020 _tmp1445_ = FALSE;
5021 }
5022 if (_tmp1445_) {
5023 ValaExpression* _tmp1467_;
5024 ValaExpression* _tmp1468_;
5025 ValaMethod* _tmp1469_;
5026 ValaSymbol* _tmp1470_;
5027 ValaSymbol* _tmp1471_;
5028 ValaObjectType* _tmp1472_;
5029 ValaObjectType* _tmp1473_;
5030 _tmp1467_ = vala_member_access_get_inner (self);
5031 _tmp1468_ = _tmp1467_;
5032 _tmp1469_ = m;
5033 _tmp1470_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp1469_);
5034 _tmp1471_ = _tmp1470_;
5035 _tmp1472_ = vala_object_type_new (G_TYPE_CHECK_INSTANCE_CAST (_tmp1471_, VALA_TYPE_OBJECT_TYPE_SYMBOL, ValaObjectTypeSymbol));
5036 _tmp1473_ = _tmp1472_;
5037 vala_expression_set_value_type (_tmp1468_, (ValaDataType*) _tmp1473_);
5038 _vala_code_node_unref0 (_tmp1473_);
5039 {
5040 ValaList* _type_argument_list = NULL;
5041 ValaMemberAccess* _tmp1474_;
5042 ValaList* _tmp1475_;
5043 ValaList* _tmp1476_;
5044 gint _type_argument_size = 0;
5045 ValaList* _tmp1477_;
5046 gint _tmp1478_;
5047 gint _tmp1479_;
5048 gint _type_argument_index = 0;
5049 _tmp1474_ = inner_ma;
5050 _tmp1475_ = _tmp1474_->priv->type_argument_list;
5051 _tmp1476_ = _vala_iterable_ref0 (_tmp1475_);
5052 _type_argument_list = _tmp1476_;
5053 _tmp1477_ = _type_argument_list;
5054 _tmp1478_ = vala_collection_get_size ((ValaCollection*) _tmp1477_);
5055 _tmp1479_ = _tmp1478_;
5056 _type_argument_size = _tmp1479_;
5057 _type_argument_index = -1;
5058 while (TRUE) {
5059 gint _tmp1480_;
5060 gint _tmp1481_;
5061 ValaDataType* type_argument = NULL;
5062 ValaList* _tmp1482_;
5063 gpointer _tmp1483_;
5064 ValaExpression* _tmp1484_;
5065 ValaExpression* _tmp1485_;
5066 ValaDataType* _tmp1486_;
5067 ValaDataType* _tmp1487_;
5068 ValaDataType* _tmp1488_;
5069 _type_argument_index = _type_argument_index + 1;
5070 _tmp1480_ = _type_argument_index;
5071 _tmp1481_ = _type_argument_size;
5072 if (!(_tmp1480_ < _tmp1481_)) {
5073 break;
5074 }
5075 _tmp1482_ = _type_argument_list;
5076 _tmp1483_ = vala_list_get (_tmp1482_, _type_argument_index);
5077 type_argument = (ValaDataType*) _tmp1483_;
5078 _tmp1484_ = vala_member_access_get_inner (self);
5079 _tmp1485_ = _tmp1484_;
5080 _tmp1486_ = vala_expression_get_value_type (_tmp1485_);
5081 _tmp1487_ = _tmp1486_;
5082 _tmp1488_ = type_argument;
5083 vala_data_type_add_type_argument (_tmp1487_, _tmp1488_);
5084 _vala_code_node_unref0 (type_argument);
5085 }
5086 _vala_iterable_unref0 (_type_argument_list);
5087 }
5088 }
5089 _tmp1489_ = vala_code_context_get_analyzer (context);
5090 _tmp1490_ = _tmp1489_;
5091 _tmp1491_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
5092 _tmp1492_ = _tmp1491_;
5093 _tmp1493_ = vala_expression_get_lvalue ((ValaExpression*) self);
5094 _tmp1494_ = _tmp1493_;
5095 _tmp1495_ = vala_semantic_analyzer_get_value_type_for_symbol (_tmp1490_, _tmp1492_, _tmp1494_);
5096 _tmp1496_ = _tmp1495_;
5097 vala_expression_set_formal_value_type ((ValaExpression*) self, _tmp1496_);
5098 _vala_code_node_unref0 (_tmp1496_);
5099 _tmp1498_ = vala_member_access_get_inner (self);
5100 _tmp1499_ = _tmp1498_;
5101 if (_tmp1499_ != NULL) {
5102 ValaDataType* _tmp1500_;
5103 ValaDataType* _tmp1501_;
5104 _tmp1500_ = vala_expression_get_formal_value_type ((ValaExpression*) self);
5105 _tmp1501_ = _tmp1500_;
5106 _tmp1497_ = _tmp1501_ != NULL;
5107 } else {
5108 _tmp1497_ = FALSE;
5109 }
5110 if (_tmp1497_) {
5111 ValaDataType* _tmp1502_;
5112 ValaDataType* _tmp1503_;
5113 ValaExpression* _tmp1504_;
5114 ValaExpression* _tmp1505_;
5115 ValaDataType* _tmp1506_;
5116 ValaDataType* _tmp1507_;
5117 ValaDataType* _tmp1508_;
5118 ValaDataType* _tmp1509_;
5119 _tmp1502_ = vala_expression_get_formal_value_type ((ValaExpression*) self);
5120 _tmp1503_ = _tmp1502_;
5121 _tmp1504_ = vala_member_access_get_inner (self);
5122 _tmp1505_ = _tmp1504_;
5123 _tmp1506_ = vala_expression_get_value_type (_tmp1505_);
5124 _tmp1507_ = _tmp1506_;
5125 _tmp1508_ = vala_data_type_get_actual_type (_tmp1503_, _tmp1507_, NULL, (ValaCodeNode*) self);
5126 _tmp1509_ = _tmp1508_;
5127 vala_expression_set_value_type ((ValaExpression*) self, _tmp1509_);
5128 _vala_code_node_unref0 (_tmp1509_);
5129 } else {
5130 ValaDataType* _tmp1510_;
5131 ValaDataType* _tmp1511_;
5132 _tmp1510_ = vala_expression_get_formal_value_type ((ValaExpression*) self);
5133 _tmp1511_ = _tmp1510_;
5134 vala_expression_set_value_type ((ValaExpression*) self, _tmp1511_);
5135 }
5136 _tmp1512_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
5137 _tmp1513_ = _tmp1512_;
5138 if (VALA_IS_METHOD (_tmp1513_)) {
5139 ValaMethod* method = NULL;
5140 ValaSymbol* _tmp1514_;
5141 ValaSymbol* _tmp1515_;
5142 ValaDataType* _tmp1516_;
5143 ValaDataType* _tmp1517_;
5144 gboolean _tmp1524_ = FALSE;
5145 _tmp1514_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
5146 _tmp1515_ = _tmp1514_;
5147 method = G_TYPE_CHECK_INSTANCE_CAST (_tmp1515_, VALA_TYPE_METHOD, ValaMethod);
5148 _tmp1516_ = vala_expression_get_target_type ((ValaExpression*) self);
5149 _tmp1517_ = _tmp1516_;
5150 if (_tmp1517_ != NULL) {
5151 ValaDataType* _tmp1518_;
5152 ValaDataType* _tmp1519_;
5153 ValaDataType* _tmp1520_;
5154 ValaDataType* _tmp1521_;
5155 gboolean _tmp1522_;
5156 gboolean _tmp1523_;
5157 _tmp1518_ = vala_expression_get_value_type ((ValaExpression*) self);
5158 _tmp1519_ = _tmp1518_;
5159 _tmp1520_ = vala_expression_get_target_type ((ValaExpression*) self);
5160 _tmp1521_ = _tmp1520_;
5161 _tmp1522_ = vala_data_type_get_value_owned (_tmp1521_);
5162 _tmp1523_ = _tmp1522_;
5163 vala_data_type_set_value_owned (_tmp1519_, _tmp1523_);
5164 }
5165 if (instance) {
5166 ValaMethod* _tmp1525_;
5167 ValaSymbol* _tmp1526_;
5168 ValaSymbol* _tmp1527_;
5169 _tmp1525_ = method;
5170 _tmp1526_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp1525_);
5171 _tmp1527_ = _tmp1526_;
5172 _tmp1524_ = VALA_IS_TYPESYMBOL (_tmp1527_);
5173 } else {
5174 _tmp1524_ = FALSE;
5175 }
5176 if (_tmp1524_) {
5177 ValaExpression* _tmp1528_;
5178 ValaExpression* _tmp1529_;
5179 ValaMethod* _tmp1530_;
5180 ValaSymbol* _tmp1531_;
5181 ValaSymbol* _tmp1532_;
5182 ValaDataType* _tmp1533_;
5183 ValaDataType* _tmp1534_;
5184 ValaExpression* _tmp1535_;
5185 ValaExpression* _tmp1536_;
5186 ValaDataType* _tmp1537_;
5187 ValaDataType* _tmp1538_;
5188 ValaMethod* _tmp1539_;
5189 ValaParameter* _tmp1540_;
5190 ValaParameter* _tmp1541_;
5191 ValaDataType* _tmp1542_;
5192 ValaDataType* _tmp1543_;
5193 gboolean _tmp1544_;
5194 gboolean _tmp1545_;
5195 _tmp1528_ = vala_member_access_get_inner (self);
5196 _tmp1529_ = _tmp1528_;
5197 _tmp1530_ = method;
5198 _tmp1531_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp1530_);
5199 _tmp1532_ = _tmp1531_;
5200 _tmp1533_ = vala_semantic_analyzer_get_data_type_for_symbol (_tmp1532_);
5201 _tmp1534_ = _tmp1533_;
5202 vala_expression_set_target_type (_tmp1529_, _tmp1534_);
5203 _vala_code_node_unref0 (_tmp1534_);
5204 _tmp1535_ = vala_member_access_get_inner (self);
5205 _tmp1536_ = _tmp1535_;
5206 _tmp1537_ = vala_expression_get_target_type (_tmp1536_);
5207 _tmp1538_ = _tmp1537_;
5208 _tmp1539_ = method;
5209 _tmp1540_ = vala_method_get_this_parameter (_tmp1539_);
5210 _tmp1541_ = _tmp1540_;
5211 _tmp1542_ = vala_variable_get_variable_type ((ValaVariable*) _tmp1541_);
5212 _tmp1543_ = _tmp1542_;
5213 _tmp1544_ = vala_data_type_get_value_owned (_tmp1543_);
5214 _tmp1545_ = _tmp1544_;
5215 vala_data_type_set_value_owned (_tmp1538_, _tmp1545_);
5216 }
5217 } else {
5218 gboolean _tmp1546_ = FALSE;
5219 gboolean _tmp1547_ = FALSE;
5220 ValaSymbol* _tmp1548_;
5221 ValaSymbol* _tmp1549_;
5222 _tmp1548_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
5223 _tmp1549_ = _tmp1548_;
5224 if (VALA_IS_PROPERTY (_tmp1549_)) {
5225 _tmp1547_ = instance;
5226 } else {
5227 _tmp1547_ = FALSE;
5228 }
5229 if (_tmp1547_) {
5230 ValaSymbol* _tmp1550_;
5231 ValaSymbol* _tmp1551_;
5232 ValaSymbol* _tmp1552_;
5233 ValaSymbol* _tmp1553_;
5234 _tmp1550_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
5235 _tmp1551_ = _tmp1550_;
5236 _tmp1552_ = vala_symbol_get_parent_symbol (_tmp1551_);
5237 _tmp1553_ = _tmp1552_;
5238 _tmp1546_ = _tmp1553_ != NULL;
5239 } else {
5240 _tmp1546_ = FALSE;
5241 }
5242 if (_tmp1546_) {
5243 ValaExpression* _tmp1554_;
5244 ValaExpression* _tmp1555_;
5245 ValaSymbol* _tmp1556_;
5246 ValaSymbol* _tmp1557_;
5247 ValaSymbol* _tmp1558_;
5248 ValaSymbol* _tmp1559_;
5249 ValaDataType* _tmp1560_;
5250 ValaDataType* _tmp1561_;
5251 _tmp1554_ = vala_member_access_get_inner (self);
5252 _tmp1555_ = _tmp1554_;
5253 _tmp1556_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
5254 _tmp1557_ = _tmp1556_;
5255 _tmp1558_ = vala_symbol_get_parent_symbol (_tmp1557_);
5256 _tmp1559_ = _tmp1558_;
5257 _tmp1560_ = vala_semantic_analyzer_get_data_type_for_symbol (_tmp1559_);
5258 _tmp1561_ = _tmp1560_;
5259 vala_expression_set_target_type (_tmp1555_, _tmp1561_);
5260 _vala_code_node_unref0 (_tmp1561_);
5261 } else {
5262 gboolean _tmp1562_ = FALSE;
5263 gboolean _tmp1563_ = FALSE;
5264 gboolean _tmp1564_ = FALSE;
5265 ValaSymbol* _tmp1565_;
5266 ValaSymbol* _tmp1566_;
5267 _tmp1565_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
5268 _tmp1566_ = _tmp1565_;
5269 if (VALA_IS_FIELD (_tmp1566_)) {
5270 _tmp1564_ = TRUE;
5271 } else {
5272 ValaSymbol* _tmp1567_;
5273 ValaSymbol* _tmp1568_;
5274 _tmp1567_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
5275 _tmp1568_ = _tmp1567_;
5276 _tmp1564_ = VALA_IS_SIGNAL (_tmp1568_);
5277 }
5278 if (_tmp1564_) {
5279 _tmp1563_ = instance;
5280 } else {
5281 _tmp1563_ = FALSE;
5282 }
5283 if (_tmp1563_) {
5284 ValaSymbol* _tmp1569_;
5285 ValaSymbol* _tmp1570_;
5286 ValaSymbol* _tmp1571_;
5287 ValaSymbol* _tmp1572_;
5288 _tmp1569_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
5289 _tmp1570_ = _tmp1569_;
5290 _tmp1571_ = vala_symbol_get_parent_symbol (_tmp1570_);
5291 _tmp1572_ = _tmp1571_;
5292 _tmp1562_ = _tmp1572_ != NULL;
5293 } else {
5294 _tmp1562_ = FALSE;
5295 }
5296 if (_tmp1562_) {
5297 ValaDataType* parent_type = NULL;
5298 ValaSymbol* _tmp1573_;
5299 ValaSymbol* _tmp1574_;
5300 ValaSymbol* _tmp1575_;
5301 ValaSymbol* _tmp1576_;
5302 ValaDataType* _tmp1577_;
5303 ValaExpression* _tmp1578_;
5304 ValaExpression* _tmp1579_;
5305 ValaDataType* _tmp1580_;
5306 ValaExpression* _tmp1581_;
5307 ValaExpression* _tmp1582_;
5308 ValaDataType* _tmp1583_;
5309 ValaDataType* _tmp1584_;
5310 ValaDataType* _tmp1585_;
5311 ValaDataType* _tmp1586_;
5312 _tmp1573_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
5313 _tmp1574_ = _tmp1573_;
5314 _tmp1575_ = vala_symbol_get_parent_symbol (_tmp1574_);
5315 _tmp1576_ = _tmp1575_;
5316 _tmp1577_ = vala_semantic_analyzer_get_data_type_for_symbol (_tmp1576_);
5317 parent_type = _tmp1577_;
5318 _tmp1578_ = vala_member_access_get_inner (self);
5319 _tmp1579_ = _tmp1578_;
5320 _tmp1580_ = parent_type;
5321 _tmp1581_ = vala_member_access_get_inner (self);
5322 _tmp1582_ = _tmp1581_;
5323 _tmp1583_ = vala_expression_get_value_type (_tmp1582_);
5324 _tmp1584_ = _tmp1583_;
5325 _tmp1585_ = vala_data_type_get_actual_type (_tmp1580_, _tmp1584_, NULL, (ValaCodeNode*) self);
5326 _tmp1586_ = _tmp1585_;
5327 vala_expression_set_target_type (_tmp1579_, _tmp1586_);
5328 _vala_code_node_unref0 (_tmp1586_);
5329 _vala_code_node_unref0 (parent_type);
5330 }
5331 }
5332 }
5333 }
5334 _tmp1587_ = vala_expression_get_value_type ((ValaExpression*) self);
5335 _tmp1588_ = _tmp1587_;
5336 if (_tmp1588_ != NULL) {
5337 ValaDataType* _tmp1589_;
5338 ValaDataType* _tmp1590_;
5339 _tmp1589_ = vala_expression_get_value_type ((ValaExpression*) self);
5340 _tmp1590_ = _tmp1589_;
5341 vala_code_node_check ((ValaCodeNode*) _tmp1590_, context);
5342 }
5343 _tmp1591_ = self->priv->_tainted_access;
5344 if (!_tmp1591_) {
5345 vala_member_access_set_tainted_access (self, vala_member_access_is_tainted (self));
5346 }
5347 _tmp1592_ = vala_code_node_get_error ((ValaCodeNode*) self);
5348 _tmp1593_ = _tmp1592_;
5349 result = !_tmp1593_;
5350 return result;
5351 }
5352
5353 static gboolean
vala_member_access_is_instance_symbol(ValaSymbol * symbol)5354 vala_member_access_is_instance_symbol (ValaSymbol* symbol)
5355 {
5356 gboolean _tmp0_ = FALSE;
5357 gboolean result = FALSE;
5358 g_return_val_if_fail (symbol != NULL, FALSE);
5359 if (VALA_IS_FIELD (symbol)) {
5360 ValaMemberBinding _tmp1_;
5361 ValaMemberBinding _tmp2_;
5362 _tmp1_ = vala_field_get_binding (G_TYPE_CHECK_INSTANCE_CAST (symbol, VALA_TYPE_FIELD, ValaField));
5363 _tmp2_ = _tmp1_;
5364 _tmp0_ = _tmp2_ == VALA_MEMBER_BINDING_INSTANCE;
5365 } else {
5366 _tmp0_ = FALSE;
5367 }
5368 if (_tmp0_) {
5369 result = TRUE;
5370 return result;
5371 } else {
5372 gboolean _tmp3_ = FALSE;
5373 gboolean _tmp4_ = FALSE;
5374 if (VALA_IS_METHOD (symbol)) {
5375 _tmp4_ = !VALA_IS_CREATION_METHOD (symbol);
5376 } else {
5377 _tmp4_ = FALSE;
5378 }
5379 if (_tmp4_) {
5380 ValaMemberBinding _tmp5_;
5381 ValaMemberBinding _tmp6_;
5382 _tmp5_ = vala_method_get_binding (G_TYPE_CHECK_INSTANCE_CAST (symbol, VALA_TYPE_METHOD, ValaMethod));
5383 _tmp6_ = _tmp5_;
5384 _tmp3_ = _tmp6_ == VALA_MEMBER_BINDING_INSTANCE;
5385 } else {
5386 _tmp3_ = FALSE;
5387 }
5388 if (_tmp3_) {
5389 result = TRUE;
5390 return result;
5391 } else {
5392 gboolean _tmp7_ = FALSE;
5393 if (VALA_IS_PROPERTY (symbol)) {
5394 ValaMemberBinding _tmp8_;
5395 ValaMemberBinding _tmp9_;
5396 _tmp8_ = vala_property_get_binding (G_TYPE_CHECK_INSTANCE_CAST (symbol, VALA_TYPE_PROPERTY, ValaProperty));
5397 _tmp9_ = _tmp8_;
5398 _tmp7_ = _tmp9_ == VALA_MEMBER_BINDING_INSTANCE;
5399 } else {
5400 _tmp7_ = FALSE;
5401 }
5402 if (_tmp7_) {
5403 result = TRUE;
5404 return result;
5405 } else {
5406 if (VALA_IS_SIGNAL (symbol)) {
5407 result = TRUE;
5408 return result;
5409 } else {
5410 result = FALSE;
5411 return result;
5412 }
5413 }
5414 }
5415 }
5416 }
5417
5418 void
vala_member_access_check_lvalue_access(ValaMemberAccess * self)5419 vala_member_access_check_lvalue_access (ValaMemberAccess* self)
5420 {
5421 ValaExpression* _tmp0_;
5422 ValaExpression* _tmp1_;
5423 gboolean _tmp2_ = FALSE;
5424 ValaSymbol* _tmp3_;
5425 ValaSymbol* _tmp4_;
5426 gboolean instance = FALSE;
5427 gboolean _tmp23_ = FALSE;
5428 ValaExpression* _tmp24_;
5429 ValaExpression* _tmp25_;
5430 ValaSymbol* _tmp26_;
5431 ValaSymbol* _tmp27_;
5432 gboolean this_access = FALSE;
5433 gboolean _tmp34_ = FALSE;
5434 gboolean _tmp35_ = FALSE;
5435 ValaExpression* _tmp36_;
5436 ValaExpression* _tmp37_;
5437 ValaDataType* _tmp38_;
5438 ValaDataType* _tmp39_;
5439 gboolean struct_or_array = FALSE;
5440 ValaMemberAccess* ma = NULL;
5441 ValaExpression* _tmp50_;
5442 ValaExpression* _tmp51_;
5443 gboolean _tmp52_ = FALSE;
5444 gboolean _tmp53_ = FALSE;
5445 ValaMemberAccess* _tmp54_;
5446 gboolean _tmp61_ = FALSE;
5447 gboolean _tmp62_ = FALSE;
5448 gboolean _tmp63_ = FALSE;
5449 gboolean _tmp64_ = FALSE;
5450 gboolean _tmp83_ = FALSE;
5451 ValaSymbol* _tmp84_;
5452 ValaSymbol* _tmp85_;
5453 g_return_if_fail (self != NULL);
5454 _tmp0_ = vala_member_access_get_inner (self);
5455 _tmp1_ = _tmp0_;
5456 if (_tmp1_ == NULL) {
5457 return;
5458 }
5459 _tmp3_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
5460 _tmp4_ = _tmp3_;
5461 if (VALA_IS_FIELD (_tmp4_)) {
5462 ValaSymbol* _tmp5_;
5463 ValaSymbol* _tmp6_;
5464 ValaMemberBinding _tmp7_;
5465 ValaMemberBinding _tmp8_;
5466 _tmp5_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
5467 _tmp6_ = _tmp5_;
5468 _tmp7_ = vala_field_get_binding (G_TYPE_CHECK_INSTANCE_CAST (_tmp6_, VALA_TYPE_FIELD, ValaField));
5469 _tmp8_ = _tmp7_;
5470 _tmp2_ = _tmp8_ == VALA_MEMBER_BINDING_INSTANCE;
5471 } else {
5472 _tmp2_ = FALSE;
5473 }
5474 instance = _tmp2_;
5475 if (!instance) {
5476 gboolean _tmp9_ = FALSE;
5477 ValaSymbol* _tmp10_;
5478 ValaSymbol* _tmp11_;
5479 _tmp10_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
5480 _tmp11_ = _tmp10_;
5481 if (VALA_IS_METHOD (_tmp11_)) {
5482 ValaSymbol* _tmp12_;
5483 ValaSymbol* _tmp13_;
5484 ValaMemberBinding _tmp14_;
5485 ValaMemberBinding _tmp15_;
5486 _tmp12_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
5487 _tmp13_ = _tmp12_;
5488 _tmp14_ = vala_method_get_binding (G_TYPE_CHECK_INSTANCE_CAST (_tmp13_, VALA_TYPE_METHOD, ValaMethod));
5489 _tmp15_ = _tmp14_;
5490 _tmp9_ = _tmp15_ == VALA_MEMBER_BINDING_INSTANCE;
5491 } else {
5492 _tmp9_ = FALSE;
5493 }
5494 instance = _tmp9_;
5495 }
5496 if (!instance) {
5497 gboolean _tmp16_ = FALSE;
5498 ValaSymbol* _tmp17_;
5499 ValaSymbol* _tmp18_;
5500 _tmp17_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
5501 _tmp18_ = _tmp17_;
5502 if (VALA_IS_PROPERTY (_tmp18_)) {
5503 ValaSymbol* _tmp19_;
5504 ValaSymbol* _tmp20_;
5505 ValaMemberBinding _tmp21_;
5506 ValaMemberBinding _tmp22_;
5507 _tmp19_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
5508 _tmp20_ = _tmp19_;
5509 _tmp21_ = vala_property_get_binding (G_TYPE_CHECK_INSTANCE_CAST (_tmp20_, VALA_TYPE_PROPERTY, ValaProperty));
5510 _tmp22_ = _tmp21_;
5511 _tmp16_ = _tmp22_ == VALA_MEMBER_BINDING_INSTANCE;
5512 } else {
5513 _tmp16_ = FALSE;
5514 }
5515 instance = _tmp16_;
5516 }
5517 _tmp24_ = vala_member_access_get_inner (self);
5518 _tmp25_ = _tmp24_;
5519 _tmp26_ = vala_expression_get_symbol_reference (_tmp25_);
5520 _tmp27_ = _tmp26_;
5521 if (VALA_IS_PARAMETER (_tmp27_)) {
5522 ValaExpression* _tmp28_;
5523 ValaExpression* _tmp29_;
5524 ValaSymbol* _tmp30_;
5525 ValaSymbol* _tmp31_;
5526 const gchar* _tmp32_;
5527 const gchar* _tmp33_;
5528 _tmp28_ = vala_member_access_get_inner (self);
5529 _tmp29_ = _tmp28_;
5530 _tmp30_ = vala_expression_get_symbol_reference (_tmp29_);
5531 _tmp31_ = _tmp30_;
5532 _tmp32_ = vala_symbol_get_name (_tmp31_);
5533 _tmp33_ = _tmp32_;
5534 _tmp23_ = g_strcmp0 (_tmp33_, "this") == 0;
5535 } else {
5536 _tmp23_ = FALSE;
5537 }
5538 this_access = _tmp23_;
5539 _tmp36_ = vala_member_access_get_inner (self);
5540 _tmp37_ = _tmp36_;
5541 _tmp38_ = vala_expression_get_value_type (_tmp37_);
5542 _tmp39_ = _tmp38_;
5543 if (VALA_IS_STRUCT_VALUE_TYPE (_tmp39_)) {
5544 ValaExpression* _tmp40_;
5545 ValaExpression* _tmp41_;
5546 ValaDataType* _tmp42_;
5547 ValaDataType* _tmp43_;
5548 gboolean _tmp44_;
5549 gboolean _tmp45_;
5550 _tmp40_ = vala_member_access_get_inner (self);
5551 _tmp41_ = _tmp40_;
5552 _tmp42_ = vala_expression_get_value_type (_tmp41_);
5553 _tmp43_ = _tmp42_;
5554 _tmp44_ = vala_data_type_get_nullable (_tmp43_);
5555 _tmp45_ = _tmp44_;
5556 _tmp35_ = !_tmp45_;
5557 } else {
5558 _tmp35_ = FALSE;
5559 }
5560 if (_tmp35_) {
5561 _tmp34_ = TRUE;
5562 } else {
5563 ValaExpression* _tmp46_;
5564 ValaExpression* _tmp47_;
5565 ValaDataType* _tmp48_;
5566 ValaDataType* _tmp49_;
5567 _tmp46_ = vala_member_access_get_inner (self);
5568 _tmp47_ = _tmp46_;
5569 _tmp48_ = vala_expression_get_value_type (_tmp47_);
5570 _tmp49_ = _tmp48_;
5571 _tmp34_ = VALA_IS_ARRAY_TYPE (_tmp49_);
5572 }
5573 struct_or_array = _tmp34_;
5574 _tmp50_ = vala_member_access_get_inner (self);
5575 _tmp51_ = _tmp50_;
5576 ma = VALA_IS_MEMBER_ACCESS (_tmp51_) ? ((ValaMemberAccess*) _tmp51_) : NULL;
5577 _tmp54_ = ma;
5578 if (_tmp54_ == NULL) {
5579 _tmp53_ = struct_or_array;
5580 } else {
5581 _tmp53_ = FALSE;
5582 }
5583 if (_tmp53_) {
5584 ValaExpression* _tmp55_;
5585 ValaExpression* _tmp56_;
5586 _tmp55_ = vala_member_access_get_inner (self);
5587 _tmp56_ = _tmp55_;
5588 _tmp52_ = VALA_IS_POINTER_INDIRECTION (_tmp56_);
5589 } else {
5590 _tmp52_ = FALSE;
5591 }
5592 if (_tmp52_) {
5593 ValaExpression* _tmp57_;
5594 ValaExpression* _tmp58_;
5595 ValaExpression* _tmp59_;
5596 ValaExpression* _tmp60_;
5597 _tmp57_ = vala_member_access_get_inner (self);
5598 _tmp58_ = _tmp57_;
5599 _tmp59_ = vala_pointer_indirection_get_inner (G_TYPE_CHECK_INSTANCE_CAST (_tmp58_, VALA_TYPE_POINTER_INDIRECTION, ValaPointerIndirection));
5600 _tmp60_ = _tmp59_;
5601 ma = VALA_IS_MEMBER_ACCESS (_tmp60_) ? ((ValaMemberAccess*) _tmp60_) : NULL;
5602 }
5603 if (instance) {
5604 _tmp64_ = struct_or_array;
5605 } else {
5606 _tmp64_ = FALSE;
5607 }
5608 if (_tmp64_) {
5609 gboolean _tmp65_ = FALSE;
5610 ValaSymbol* _tmp66_;
5611 ValaSymbol* _tmp67_;
5612 _tmp66_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
5613 _tmp67_ = _tmp66_;
5614 if (VALA_IS_METHOD (_tmp67_)) {
5615 _tmp65_ = TRUE;
5616 } else {
5617 gboolean _tmp68_;
5618 gboolean _tmp69_;
5619 _tmp68_ = vala_expression_get_lvalue ((ValaExpression*) self);
5620 _tmp69_ = _tmp68_;
5621 _tmp65_ = _tmp69_;
5622 }
5623 _tmp63_ = _tmp65_;
5624 } else {
5625 _tmp63_ = FALSE;
5626 }
5627 if (_tmp63_) {
5628 gboolean _tmp70_ = FALSE;
5629 gboolean _tmp71_ = FALSE;
5630 ValaMemberAccess* _tmp72_;
5631 _tmp72_ = ma;
5632 if (_tmp72_ != NULL) {
5633 ValaMemberAccess* _tmp73_;
5634 ValaSymbol* _tmp74_;
5635 ValaSymbol* _tmp75_;
5636 _tmp73_ = ma;
5637 _tmp74_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp73_);
5638 _tmp75_ = _tmp74_;
5639 _tmp71_ = VALA_IS_VARIABLE (_tmp75_);
5640 } else {
5641 _tmp71_ = FALSE;
5642 }
5643 if (_tmp71_) {
5644 _tmp70_ = TRUE;
5645 } else {
5646 ValaExpression* _tmp76_;
5647 ValaExpression* _tmp77_;
5648 _tmp76_ = vala_member_access_get_inner (self);
5649 _tmp77_ = _tmp76_;
5650 _tmp70_ = VALA_IS_ELEMENT_ACCESS (_tmp77_);
5651 }
5652 _tmp62_ = _tmp70_;
5653 } else {
5654 _tmp62_ = FALSE;
5655 }
5656 if (_tmp62_) {
5657 _tmp61_ = !this_access;
5658 } else {
5659 _tmp61_ = FALSE;
5660 }
5661 if (_tmp61_) {
5662 ValaExpression* _tmp78_;
5663 ValaExpression* _tmp79_;
5664 ValaMemberAccess* _tmp80_;
5665 _tmp78_ = vala_member_access_get_inner (self);
5666 _tmp79_ = _tmp78_;
5667 vala_expression_set_lvalue (_tmp79_, TRUE);
5668 _tmp80_ = ma;
5669 if (_tmp80_ != NULL) {
5670 ValaMemberAccess* _tmp81_;
5671 ValaMemberAccess* _tmp82_;
5672 _tmp81_ = ma;
5673 vala_expression_set_lvalue ((ValaExpression*) _tmp81_, TRUE);
5674 _tmp82_ = ma;
5675 vala_member_access_check_lvalue_access (_tmp82_);
5676 }
5677 }
5678 _tmp84_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
5679 _tmp85_ = _tmp84_;
5680 if (VALA_IS_METHOD (_tmp85_)) {
5681 ValaSymbol* _tmp86_;
5682 ValaSymbol* _tmp87_;
5683 ValaAttribute* _tmp88_;
5684 _tmp86_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
5685 _tmp87_ = _tmp86_;
5686 _tmp88_ = vala_code_node_get_attribute ((ValaCodeNode*) G_TYPE_CHECK_INSTANCE_CAST (_tmp87_, VALA_TYPE_METHOD, ValaMethod), "DestroysInstance");
5687 _tmp83_ = _tmp88_ != NULL;
5688 } else {
5689 _tmp83_ = FALSE;
5690 }
5691 if (_tmp83_) {
5692 ValaClass* cl = NULL;
5693 ValaSymbol* _tmp89_;
5694 ValaSymbol* _tmp90_;
5695 ValaSymbol* _tmp91_;
5696 ValaSymbol* _tmp92_;
5697 gboolean _tmp93_ = FALSE;
5698 gboolean _tmp94_ = FALSE;
5699 ValaClass* _tmp95_;
5700 _tmp89_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
5701 _tmp90_ = _tmp89_;
5702 _tmp91_ = vala_symbol_get_parent_symbol ((ValaSymbol*) G_TYPE_CHECK_INSTANCE_CAST (_tmp90_, VALA_TYPE_METHOD, ValaMethod));
5703 _tmp92_ = _tmp91_;
5704 cl = VALA_IS_CLASS (_tmp92_) ? ((ValaClass*) _tmp92_) : NULL;
5705 _tmp95_ = cl;
5706 if (_tmp95_ != NULL) {
5707 ValaClass* _tmp96_;
5708 gboolean _tmp97_;
5709 gboolean _tmp98_;
5710 _tmp96_ = cl;
5711 _tmp97_ = vala_class_get_is_compact (_tmp96_);
5712 _tmp98_ = _tmp97_;
5713 _tmp94_ = _tmp98_;
5714 } else {
5715 _tmp94_ = FALSE;
5716 }
5717 if (_tmp94_) {
5718 ValaMemberAccess* _tmp99_;
5719 _tmp99_ = ma;
5720 _tmp93_ = _tmp99_ != NULL;
5721 } else {
5722 _tmp93_ = FALSE;
5723 }
5724 if (_tmp93_) {
5725 ValaMemberAccess* _tmp100_;
5726 ValaMemberAccess* _tmp101_;
5727 _tmp100_ = ma;
5728 vala_expression_set_lvalue ((ValaExpression*) _tmp100_, TRUE);
5729 _tmp101_ = ma;
5730 vala_member_access_check_lvalue_access (_tmp101_);
5731 }
5732 }
5733 }
5734
5735 static void
vala_member_access_real_emit(ValaCodeNode * base,ValaCodeGenerator * codegen)5736 vala_member_access_real_emit (ValaCodeNode* base,
5737 ValaCodeGenerator* codegen)
5738 {
5739 ValaMemberAccess * self;
5740 ValaExpression* _tmp0_;
5741 ValaExpression* _tmp1_;
5742 self = (ValaMemberAccess*) base;
5743 g_return_if_fail (codegen != NULL);
5744 _tmp0_ = vala_member_access_get_inner (self);
5745 _tmp1_ = _tmp0_;
5746 if (_tmp1_ != NULL) {
5747 ValaExpression* _tmp2_;
5748 ValaExpression* _tmp3_;
5749 _tmp2_ = vala_member_access_get_inner (self);
5750 _tmp3_ = _tmp2_;
5751 vala_code_node_emit ((ValaCodeNode*) _tmp3_, codegen);
5752 }
5753 vala_code_visitor_visit_member_access ((ValaCodeVisitor*) codegen, self);
5754 vala_code_visitor_visit_expression ((ValaCodeVisitor*) codegen, (ValaExpression*) self);
5755 }
5756
5757 static void
vala_member_access_real_get_defined_variables(ValaCodeNode * base,ValaCollection * collection)5758 vala_member_access_real_get_defined_variables (ValaCodeNode* base,
5759 ValaCollection* collection)
5760 {
5761 ValaMemberAccess * self;
5762 ValaExpression* _tmp0_;
5763 ValaExpression* _tmp1_;
5764 self = (ValaMemberAccess*) base;
5765 g_return_if_fail (collection != NULL);
5766 _tmp0_ = vala_member_access_get_inner (self);
5767 _tmp1_ = _tmp0_;
5768 if (_tmp1_ != NULL) {
5769 ValaExpression* _tmp2_;
5770 ValaExpression* _tmp3_;
5771 _tmp2_ = vala_member_access_get_inner (self);
5772 _tmp3_ = _tmp2_;
5773 vala_code_node_get_defined_variables ((ValaCodeNode*) _tmp3_, collection);
5774 }
5775 }
5776
5777 static void
vala_member_access_real_get_used_variables(ValaCodeNode * base,ValaCollection * collection)5778 vala_member_access_real_get_used_variables (ValaCodeNode* base,
5779 ValaCollection* collection)
5780 {
5781 ValaMemberAccess * self;
5782 ValaExpression* _tmp0_;
5783 ValaExpression* _tmp1_;
5784 ValaLocalVariable* local = NULL;
5785 ValaSymbol* _tmp4_;
5786 ValaSymbol* _tmp5_;
5787 ValaParameter* param = NULL;
5788 ValaSymbol* _tmp6_;
5789 ValaSymbol* _tmp7_;
5790 ValaLocalVariable* _tmp8_;
5791 self = (ValaMemberAccess*) base;
5792 g_return_if_fail (collection != NULL);
5793 _tmp0_ = vala_member_access_get_inner (self);
5794 _tmp1_ = _tmp0_;
5795 if (_tmp1_ != NULL) {
5796 ValaExpression* _tmp2_;
5797 ValaExpression* _tmp3_;
5798 _tmp2_ = vala_member_access_get_inner (self);
5799 _tmp3_ = _tmp2_;
5800 vala_code_node_get_used_variables ((ValaCodeNode*) _tmp3_, collection);
5801 }
5802 _tmp4_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
5803 _tmp5_ = _tmp4_;
5804 local = VALA_IS_LOCAL_VARIABLE (_tmp5_) ? ((ValaLocalVariable*) _tmp5_) : NULL;
5805 _tmp6_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
5806 _tmp7_ = _tmp6_;
5807 param = VALA_IS_PARAMETER (_tmp7_) ? ((ValaParameter*) _tmp7_) : NULL;
5808 _tmp8_ = local;
5809 if (_tmp8_ != NULL) {
5810 ValaLocalVariable* _tmp9_;
5811 _tmp9_ = local;
5812 vala_collection_add (collection, (ValaVariable*) _tmp9_);
5813 } else {
5814 gboolean _tmp10_ = FALSE;
5815 ValaParameter* _tmp11_;
5816 _tmp11_ = param;
5817 if (_tmp11_ != NULL) {
5818 ValaParameter* _tmp12_;
5819 ValaParameterDirection _tmp13_;
5820 ValaParameterDirection _tmp14_;
5821 _tmp12_ = param;
5822 _tmp13_ = vala_parameter_get_direction (_tmp12_);
5823 _tmp14_ = _tmp13_;
5824 _tmp10_ = _tmp14_ == VALA_PARAMETER_DIRECTION_OUT;
5825 } else {
5826 _tmp10_ = FALSE;
5827 }
5828 if (_tmp10_) {
5829 ValaParameter* _tmp15_;
5830 _tmp15_ = param;
5831 vala_collection_add (collection, (ValaVariable*) _tmp15_);
5832 }
5833 }
5834 }
5835
5836 static Block1Data*
block1_data_ref(Block1Data * _data1_)5837 block1_data_ref (Block1Data* _data1_)
5838 {
5839 g_atomic_int_inc (&_data1_->_ref_count_);
5840 return _data1_;
5841 }
5842
5843 static void
block1_data_unref(void * _userdata_)5844 block1_data_unref (void * _userdata_)
5845 {
5846 Block1Data* _data1_;
5847 _data1_ = (Block1Data*) _userdata_;
5848 if (g_atomic_int_dec_and_test (&_data1_->_ref_count_)) {
5849 ValaMemberAccess* self;
5850 self = _data1_->self;
5851 _vala_code_node_unref0 (self);
5852 g_slice_free (Block1Data, _data1_);
5853 }
5854 }
5855
5856 static ValaTraverseStatus
__lambda4_(Block1Data * _data1_,ValaCodeNode * n)5857 __lambda4_ (Block1Data* _data1_,
5858 ValaCodeNode* n)
5859 {
5860 ValaMemberAccess* self;
5861 ValaTraverseStatus result = 0;
5862 self = _data1_->self;
5863 g_return_val_if_fail (n != NULL, 0);
5864 if (VALA_IS_POSTFIX_EXPRESSION (n)) {
5865 _data1_->found = TRUE;
5866 result = VALA_TRAVERSE_STATUS_STOP;
5867 return result;
5868 } else {
5869 if (VALA_IS_UNARY_EXPRESSION (n)) {
5870 ValaUnaryExpression* e = NULL;
5871 gboolean _tmp0_ = FALSE;
5872 ValaUnaryExpression* _tmp1_;
5873 ValaUnaryOperator _tmp2_;
5874 ValaUnaryOperator _tmp3_;
5875 e = G_TYPE_CHECK_INSTANCE_CAST (n, VALA_TYPE_UNARY_EXPRESSION, ValaUnaryExpression);
5876 _tmp1_ = e;
5877 _tmp2_ = vala_unary_expression_get_operator (_tmp1_);
5878 _tmp3_ = _tmp2_;
5879 if (_tmp3_ == VALA_UNARY_OPERATOR_INCREMENT) {
5880 _tmp0_ = TRUE;
5881 } else {
5882 ValaUnaryExpression* _tmp4_;
5883 ValaUnaryOperator _tmp5_;
5884 ValaUnaryOperator _tmp6_;
5885 _tmp4_ = e;
5886 _tmp5_ = vala_unary_expression_get_operator (_tmp4_);
5887 _tmp6_ = _tmp5_;
5888 _tmp0_ = _tmp6_ == VALA_UNARY_OPERATOR_DECREMENT;
5889 }
5890 if (_tmp0_) {
5891 _data1_->found = TRUE;
5892 result = VALA_TRAVERSE_STATUS_STOP;
5893 return result;
5894 }
5895 }
5896 }
5897 result = VALA_TRAVERSE_STATUS_CONTINUE;
5898 return result;
5899 }
5900
5901 static ValaTraverseStatus
___lambda4__vala_traverse_func(ValaCodeNode * node,gpointer self)5902 ___lambda4__vala_traverse_func (ValaCodeNode* node,
5903 gpointer self)
5904 {
5905 ValaTraverseStatus result;
5906 result = __lambda4_ (self, node);
5907 return result;
5908 }
5909
5910 static gboolean
vala_member_access_is_tainted(ValaMemberAccess * self)5911 vala_member_access_is_tainted (ValaMemberAccess* self)
5912 {
5913 Block1Data* _data1_;
5914 ValaCodeNode* node = NULL;
5915 ValaCodeNode* _tmp0_;
5916 ValaCodeNode* _tmp1_;
5917 ValaCodeNode* _tmp2_;
5918 ValaTraverseVisitor* traverse = NULL;
5919 ValaTraverseVisitor* _tmp14_;
5920 ValaCodeNode* _tmp15_;
5921 ValaTraverseVisitor* _tmp16_;
5922 gboolean result = FALSE;
5923 g_return_val_if_fail (self != NULL, FALSE);
5924 _data1_ = g_slice_new0 (Block1Data);
5925 _data1_->_ref_count_ = 1;
5926 _data1_->self = vala_code_node_ref (self);
5927 node = (ValaCodeNode*) self;
5928 _tmp0_ = node;
5929 _tmp1_ = vala_code_node_get_parent_node (_tmp0_);
5930 _tmp2_ = _tmp1_;
5931 if (VALA_IS_MEMBER_ACCESS (_tmp2_)) {
5932 result = FALSE;
5933 block1_data_unref (_data1_);
5934 _data1_ = NULL;
5935 return result;
5936 }
5937 while (TRUE) {
5938 ValaCodeNode* _tmp3_;
5939 ValaCodeNode* _tmp4_;
5940 ValaCodeNode* _tmp5_;
5941 ValaCodeNode* _tmp6_;
5942 ValaCodeNode* _tmp7_;
5943 ValaCodeNode* _tmp8_;
5944 gboolean _tmp9_ = FALSE;
5945 gboolean _tmp10_ = FALSE;
5946 ValaCodeNode* _tmp11_;
5947 _tmp3_ = node;
5948 _tmp4_ = vala_code_node_get_parent_node (_tmp3_);
5949 _tmp5_ = _tmp4_;
5950 if (!VALA_IS_EXPRESSION (_tmp5_)) {
5951 break;
5952 }
5953 _tmp6_ = node;
5954 _tmp7_ = vala_code_node_get_parent_node (_tmp6_);
5955 _tmp8_ = _tmp7_;
5956 node = _tmp8_;
5957 _tmp11_ = node;
5958 if (VALA_IS_ASSIGNMENT (_tmp11_)) {
5959 _tmp10_ = TRUE;
5960 } else {
5961 ValaCodeNode* _tmp12_;
5962 _tmp12_ = node;
5963 _tmp10_ = VALA_IS_METHOD_CALL (_tmp12_);
5964 }
5965 if (_tmp10_) {
5966 _tmp9_ = TRUE;
5967 } else {
5968 ValaCodeNode* _tmp13_;
5969 _tmp13_ = node;
5970 _tmp9_ = VALA_IS_OBJECT_CREATION_EXPRESSION (_tmp13_);
5971 }
5972 if (_tmp9_) {
5973 break;
5974 }
5975 }
5976 _data1_->found = FALSE;
5977 _tmp14_ = vala_traverse_visitor_new (___lambda4__vala_traverse_func, block1_data_ref (_data1_), block1_data_unref);
5978 traverse = _tmp14_;
5979 _tmp15_ = node;
5980 _tmp16_ = traverse;
5981 vala_code_node_accept (_tmp15_, (ValaCodeVisitor*) _tmp16_);
5982 result = _data1_->found;
5983 _vala_code_visitor_unref0 (traverse);
5984 block1_data_unref (_data1_);
5985 _data1_ = NULL;
5986 return result;
5987 }
5988
5989 static void
vala_member_access_class_init(ValaMemberAccessClass * klass,gpointer klass_data)5990 vala_member_access_class_init (ValaMemberAccessClass * klass,
5991 gpointer klass_data)
5992 {
5993 vala_member_access_parent_class = g_type_class_peek_parent (klass);
5994 ((ValaCodeNodeClass *) klass)->finalize = vala_member_access_finalize;
5995 g_type_class_adjust_private_offset (klass, &ValaMemberAccess_private_offset);
5996 ((ValaCodeNodeClass *) klass)->accept = (void (*) (ValaCodeNode*, ValaCodeVisitor*)) vala_member_access_real_accept;
5997 ((ValaCodeNodeClass *) klass)->accept_children = (void (*) (ValaCodeNode*, ValaCodeVisitor*)) vala_member_access_real_accept_children;
5998 ((ValaCodeNodeClass *) klass)->to_string = (gchar* (*) (ValaCodeNode*)) vala_member_access_real_to_string;
5999 ((ValaCodeNodeClass *) klass)->replace_expression = (void (*) (ValaCodeNode*, ValaExpression*, ValaExpression*)) vala_member_access_real_replace_expression;
6000 ((ValaExpressionClass *) klass)->is_pure = (gboolean (*) (ValaExpression*)) vala_member_access_real_is_pure;
6001 ((ValaExpressionClass *) klass)->is_accessible = (gboolean (*) (ValaExpression*, ValaSymbol*)) vala_member_access_real_is_accessible;
6002 ((ValaCodeNodeClass *) klass)->replace_type = (void (*) (ValaCodeNode*, ValaDataType*, ValaDataType*)) vala_member_access_real_replace_type;
6003 ((ValaExpressionClass *) klass)->is_constant = (gboolean (*) (ValaExpression*)) vala_member_access_real_is_constant;
6004 ((ValaExpressionClass *) klass)->is_non_null = (gboolean (*) (ValaExpression*)) vala_member_access_real_is_non_null;
6005 ((ValaCodeNodeClass *) klass)->get_error_types = (void (*) (ValaCodeNode*, ValaCollection*, ValaSourceReference*)) vala_member_access_real_get_error_types;
6006 ((ValaCodeNodeClass *) klass)->check = (gboolean (*) (ValaCodeNode*, ValaCodeContext*)) vala_member_access_real_check;
6007 ((ValaCodeNodeClass *) klass)->emit = (void (*) (ValaCodeNode*, ValaCodeGenerator*)) vala_member_access_real_emit;
6008 ((ValaCodeNodeClass *) klass)->get_defined_variables = (void (*) (ValaCodeNode*, ValaCollection*)) vala_member_access_real_get_defined_variables;
6009 ((ValaCodeNodeClass *) klass)->get_used_variables = (void (*) (ValaCodeNode*, ValaCollection*)) vala_member_access_real_get_used_variables;
6010 }
6011
6012 static void
vala_member_access_instance_init(ValaMemberAccess * self,gpointer klass)6013 vala_member_access_instance_init (ValaMemberAccess * self,
6014 gpointer klass)
6015 {
6016 GEqualFunc _tmp0_;
6017 ValaArrayList* _tmp1_;
6018 self->priv = vala_member_access_get_instance_private (self);
6019 _tmp0_ = g_direct_equal;
6020 _tmp1_ = vala_array_list_new (VALA_TYPE_DATA_TYPE, (GBoxedCopyFunc) vala_code_node_ref, (GDestroyNotify) vala_code_node_unref, _tmp0_);
6021 self->priv->type_argument_list = (ValaList*) _tmp1_;
6022 }
6023
6024 static void
vala_member_access_finalize(ValaCodeNode * obj)6025 vala_member_access_finalize (ValaCodeNode * obj)
6026 {
6027 ValaMemberAccess * self;
6028 self = G_TYPE_CHECK_INSTANCE_CAST (obj, VALA_TYPE_MEMBER_ACCESS, ValaMemberAccess);
6029 _g_free0 (self->priv->_member_name);
6030 _vala_code_node_unref0 (self->priv->_inner);
6031 _vala_iterable_unref0 (self->priv->type_argument_list);
6032 VALA_CODE_NODE_CLASS (vala_member_access_parent_class)->finalize (obj);
6033 }
6034
6035 /**
6036 * Represents an access to a type member in the source code.
6037 */
6038 static GType
vala_member_access_get_type_once(void)6039 vala_member_access_get_type_once (void)
6040 {
6041 static const GTypeInfo g_define_type_info = { sizeof (ValaMemberAccessClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) vala_member_access_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ValaMemberAccess), 0, (GInstanceInitFunc) vala_member_access_instance_init, NULL };
6042 GType vala_member_access_type_id;
6043 vala_member_access_type_id = g_type_register_static (VALA_TYPE_EXPRESSION, "ValaMemberAccess", &g_define_type_info, 0);
6044 ValaMemberAccess_private_offset = g_type_add_instance_private (vala_member_access_type_id, sizeof (ValaMemberAccessPrivate));
6045 return vala_member_access_type_id;
6046 }
6047
6048 GType
vala_member_access_get_type(void)6049 vala_member_access_get_type (void)
6050 {
6051 static volatile gsize vala_member_access_type_id__volatile = 0;
6052 if (g_once_init_enter (&vala_member_access_type_id__volatile)) {
6053 GType vala_member_access_type_id;
6054 vala_member_access_type_id = vala_member_access_get_type_once ();
6055 g_once_init_leave (&vala_member_access_type_id__volatile, vala_member_access_type_id);
6056 }
6057 return vala_member_access_type_id__volatile;
6058 }
6059
6060