1 /* valamethodcall.c generated by valac, the Vala compiler
2 * generated from valamethodcall.vala, do not modify */
3
4 /* valamethodcall.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 <glib.h>
28 #include <valagee.h>
29 #include <glib-object.h>
30 #include <stdlib.h>
31 #include <string.h>
32
33 #define _vala_code_node_unref0(var) ((var == NULL) ? NULL : (var = (vala_code_node_unref (var), NULL)))
34 #define _vala_iterable_unref0(var) ((var == NULL) ? NULL : (var = (vala_iterable_unref (var), NULL)))
35 #define _g_free0(var) (var = (g_free (var), NULL))
36 #define _vala_iterator_unref0(var) ((var == NULL) ? NULL : (var = (vala_iterator_unref (var), NULL)))
37 #define _g_string_free0(var) ((var == NULL) ? NULL : (var = (g_string_free (var, TRUE), NULL)))
38
39 struct _ValaMethodCallPrivate {
40 gboolean _is_yield_expression;
41 gboolean _is_assert;
42 gboolean _is_constructv_chainup;
43 gboolean _is_chainup;
44 ValaExpression* _call;
45 ValaList* argument_list;
46 };
47
48 static gint ValaMethodCall_private_offset;
49 static gpointer vala_method_call_parent_class = NULL;
50
51 static void vala_method_call_set_is_assert (ValaMethodCall* self,
52 gboolean value);
53 static void vala_method_call_set_is_constructv_chainup (ValaMethodCall* self,
54 gboolean value);
55 static void vala_method_call_set_is_chainup (ValaMethodCall* self,
56 gboolean value);
57 static void vala_method_call_real_accept (ValaCodeNode* base,
58 ValaCodeVisitor* visitor);
59 static void vala_method_call_real_accept_children (ValaCodeNode* base,
60 ValaCodeVisitor* visitor);
61 static void vala_method_call_real_replace_expression (ValaCodeNode* base,
62 ValaExpression* old_node,
63 ValaExpression* new_node);
64 static gboolean vala_method_call_real_is_constant (ValaExpression* base);
65 static gboolean vala_method_call_real_is_pure (ValaExpression* base);
66 static gboolean vala_method_call_real_is_accessible (ValaExpression* base,
67 ValaSymbol* sym);
68 static void vala_method_call_real_get_error_types (ValaCodeNode* base,
69 ValaCollection* collection,
70 ValaSourceReference* source_reference);
71 static gboolean vala_method_call_real_check (ValaCodeNode* base,
72 ValaCodeContext* context);
73 static void vala_method_call_real_emit (ValaCodeNode* base,
74 ValaCodeGenerator* codegen);
75 static void vala_method_call_real_get_defined_variables (ValaCodeNode* base,
76 ValaCollection* collection);
77 static void vala_method_call_real_get_used_variables (ValaCodeNode* base,
78 ValaCollection* collection);
79 static gchar* vala_method_call_real_to_string (ValaCodeNode* base);
80 static void vala_method_call_finalize (ValaCodeNode * obj);
81 static GType vala_method_call_get_type_once (void);
82
83 static inline gpointer
vala_method_call_get_instance_private(ValaMethodCall * self)84 vala_method_call_get_instance_private (ValaMethodCall* self)
85 {
86 return G_STRUCT_MEMBER_P (self, ValaMethodCall_private_offset);
87 }
88
89 ValaExpression*
vala_method_call_get_call(ValaMethodCall * self)90 vala_method_call_get_call (ValaMethodCall* self)
91 {
92 ValaExpression* result;
93 ValaExpression* _tmp0_;
94 g_return_val_if_fail (self != NULL, NULL);
95 _tmp0_ = self->priv->_call;
96 result = _tmp0_;
97 return result;
98 }
99
100 static gpointer
_vala_code_node_ref0(gpointer self)101 _vala_code_node_ref0 (gpointer self)
102 {
103 return self ? vala_code_node_ref (self) : NULL;
104 }
105
106 void
vala_method_call_set_call(ValaMethodCall * self,ValaExpression * value)107 vala_method_call_set_call (ValaMethodCall* self,
108 ValaExpression* value)
109 {
110 ValaExpression* _tmp0_;
111 ValaExpression* _tmp1_;
112 g_return_if_fail (self != NULL);
113 _tmp0_ = _vala_code_node_ref0 (value);
114 _vala_code_node_unref0 (self->priv->_call);
115 self->priv->_call = _tmp0_;
116 _tmp1_ = self->priv->_call;
117 vala_code_node_set_parent_node ((ValaCodeNode*) _tmp1_, (ValaCodeNode*) self);
118 }
119
120 gboolean
vala_method_call_get_is_yield_expression(ValaMethodCall * self)121 vala_method_call_get_is_yield_expression (ValaMethodCall* self)
122 {
123 gboolean result;
124 g_return_val_if_fail (self != NULL, FALSE);
125 result = self->priv->_is_yield_expression;
126 return result;
127 }
128
129 void
vala_method_call_set_is_yield_expression(ValaMethodCall * self,gboolean value)130 vala_method_call_set_is_yield_expression (ValaMethodCall* self,
131 gboolean value)
132 {
133 g_return_if_fail (self != NULL);
134 self->priv->_is_yield_expression = value;
135 }
136
137 gboolean
vala_method_call_get_is_assert(ValaMethodCall * self)138 vala_method_call_get_is_assert (ValaMethodCall* self)
139 {
140 gboolean result;
141 g_return_val_if_fail (self != NULL, FALSE);
142 result = self->priv->_is_assert;
143 return result;
144 }
145
146 static void
vala_method_call_set_is_assert(ValaMethodCall * self,gboolean value)147 vala_method_call_set_is_assert (ValaMethodCall* self,
148 gboolean value)
149 {
150 g_return_if_fail (self != NULL);
151 self->priv->_is_assert = value;
152 }
153
154 gboolean
vala_method_call_get_is_constructv_chainup(ValaMethodCall * self)155 vala_method_call_get_is_constructv_chainup (ValaMethodCall* self)
156 {
157 gboolean result;
158 g_return_val_if_fail (self != NULL, FALSE);
159 result = self->priv->_is_constructv_chainup;
160 return result;
161 }
162
163 static void
vala_method_call_set_is_constructv_chainup(ValaMethodCall * self,gboolean value)164 vala_method_call_set_is_constructv_chainup (ValaMethodCall* self,
165 gboolean value)
166 {
167 g_return_if_fail (self != NULL);
168 self->priv->_is_constructv_chainup = value;
169 }
170
171 gboolean
vala_method_call_get_is_chainup(ValaMethodCall * self)172 vala_method_call_get_is_chainup (ValaMethodCall* self)
173 {
174 gboolean result;
175 g_return_val_if_fail (self != NULL, FALSE);
176 result = self->priv->_is_chainup;
177 return result;
178 }
179
180 static void
vala_method_call_set_is_chainup(ValaMethodCall * self,gboolean value)181 vala_method_call_set_is_chainup (ValaMethodCall* self,
182 gboolean value)
183 {
184 g_return_if_fail (self != NULL);
185 self->priv->_is_chainup = value;
186 }
187
188 /**
189 * Creates a new invocation expression.
190 *
191 * @param call method to call
192 * @param source_reference reference to source code
193 * @return newly created invocation expression
194 */
195 ValaMethodCall*
vala_method_call_construct(GType object_type,ValaExpression * call,ValaSourceReference * source_reference)196 vala_method_call_construct (GType object_type,
197 ValaExpression* call,
198 ValaSourceReference* source_reference)
199 {
200 ValaMethodCall* self = NULL;
201 g_return_val_if_fail (call != NULL, NULL);
202 self = (ValaMethodCall*) vala_expression_construct (object_type);
203 vala_code_node_set_source_reference ((ValaCodeNode*) self, source_reference);
204 vala_method_call_set_call (self, call);
205 return self;
206 }
207
208 ValaMethodCall*
vala_method_call_new(ValaExpression * call,ValaSourceReference * source_reference)209 vala_method_call_new (ValaExpression* call,
210 ValaSourceReference* source_reference)
211 {
212 return vala_method_call_construct (VALA_TYPE_METHOD_CALL, call, source_reference);
213 }
214
215 /**
216 * Appends the specified expression to the list of arguments.
217 *
218 * @param arg an argument
219 */
220 void
vala_method_call_add_argument(ValaMethodCall * self,ValaExpression * arg)221 vala_method_call_add_argument (ValaMethodCall* self,
222 ValaExpression* arg)
223 {
224 ValaList* _tmp0_;
225 g_return_if_fail (self != NULL);
226 g_return_if_fail (arg != NULL);
227 _tmp0_ = self->priv->argument_list;
228 vala_collection_add ((ValaCollection*) _tmp0_, arg);
229 vala_code_node_set_parent_node ((ValaCodeNode*) arg, (ValaCodeNode*) self);
230 }
231
232 /**
233 * Returns the argument list.
234 *
235 * @return argument list
236 */
237 ValaList*
vala_method_call_get_argument_list(ValaMethodCall * self)238 vala_method_call_get_argument_list (ValaMethodCall* self)
239 {
240 ValaList* _tmp0_;
241 ValaList* result = NULL;
242 g_return_val_if_fail (self != NULL, NULL);
243 _tmp0_ = self->priv->argument_list;
244 result = _tmp0_;
245 return result;
246 }
247
248 static void
vala_method_call_real_accept(ValaCodeNode * base,ValaCodeVisitor * visitor)249 vala_method_call_real_accept (ValaCodeNode* base,
250 ValaCodeVisitor* visitor)
251 {
252 ValaMethodCall * self;
253 self = (ValaMethodCall*) base;
254 g_return_if_fail (visitor != NULL);
255 vala_code_visitor_visit_method_call (visitor, self);
256 vala_code_visitor_visit_expression (visitor, (ValaExpression*) self);
257 }
258
259 static gpointer
_vala_iterable_ref0(gpointer self)260 _vala_iterable_ref0 (gpointer self)
261 {
262 return self ? vala_iterable_ref (self) : NULL;
263 }
264
265 static void
vala_method_call_real_accept_children(ValaCodeNode * base,ValaCodeVisitor * visitor)266 vala_method_call_real_accept_children (ValaCodeNode* base,
267 ValaCodeVisitor* visitor)
268 {
269 ValaMethodCall * self;
270 ValaExpression* _tmp0_;
271 ValaExpression* _tmp1_;
272 self = (ValaMethodCall*) base;
273 g_return_if_fail (visitor != NULL);
274 _tmp0_ = vala_method_call_get_call (self);
275 _tmp1_ = _tmp0_;
276 vala_code_node_accept ((ValaCodeNode*) _tmp1_, visitor);
277 {
278 ValaList* _expr_list = NULL;
279 ValaList* _tmp2_;
280 ValaList* _tmp3_;
281 gint _expr_size = 0;
282 ValaList* _tmp4_;
283 gint _tmp5_;
284 gint _tmp6_;
285 gint _expr_index = 0;
286 _tmp2_ = self->priv->argument_list;
287 _tmp3_ = _vala_iterable_ref0 (_tmp2_);
288 _expr_list = _tmp3_;
289 _tmp4_ = _expr_list;
290 _tmp5_ = vala_collection_get_size ((ValaCollection*) _tmp4_);
291 _tmp6_ = _tmp5_;
292 _expr_size = _tmp6_;
293 _expr_index = -1;
294 while (TRUE) {
295 gint _tmp7_;
296 gint _tmp8_;
297 ValaExpression* expr = NULL;
298 ValaList* _tmp9_;
299 gpointer _tmp10_;
300 ValaExpression* _tmp11_;
301 _expr_index = _expr_index + 1;
302 _tmp7_ = _expr_index;
303 _tmp8_ = _expr_size;
304 if (!(_tmp7_ < _tmp8_)) {
305 break;
306 }
307 _tmp9_ = _expr_list;
308 _tmp10_ = vala_list_get (_tmp9_, _expr_index);
309 expr = (ValaExpression*) _tmp10_;
310 _tmp11_ = expr;
311 vala_code_node_accept ((ValaCodeNode*) _tmp11_, visitor);
312 _vala_code_node_unref0 (expr);
313 }
314 _vala_iterable_unref0 (_expr_list);
315 }
316 }
317
318 static void
vala_method_call_real_replace_expression(ValaCodeNode * base,ValaExpression * old_node,ValaExpression * new_node)319 vala_method_call_real_replace_expression (ValaCodeNode* base,
320 ValaExpression* old_node,
321 ValaExpression* new_node)
322 {
323 ValaMethodCall * self;
324 ValaExpression* _tmp0_;
325 ValaExpression* _tmp1_;
326 gint index = 0;
327 ValaList* _tmp2_;
328 self = (ValaMethodCall*) base;
329 g_return_if_fail (old_node != NULL);
330 g_return_if_fail (new_node != NULL);
331 _tmp0_ = vala_method_call_get_call (self);
332 _tmp1_ = _tmp0_;
333 if (_tmp1_ == old_node) {
334 vala_method_call_set_call (self, new_node);
335 }
336 _tmp2_ = self->priv->argument_list;
337 index = vala_list_index_of (_tmp2_, old_node);
338 if (index >= 0) {
339 ValaList* _tmp3_;
340 _tmp3_ = self->priv->argument_list;
341 vala_list_set (_tmp3_, index, new_node);
342 vala_code_node_set_parent_node ((ValaCodeNode*) new_node, (ValaCodeNode*) self);
343 }
344 }
345
346 static gboolean
vala_method_call_real_is_constant(ValaExpression * base)347 vala_method_call_real_is_constant (ValaExpression* base)
348 {
349 ValaMethodCall * self;
350 ValaMethodType* method_type = NULL;
351 ValaExpression* _tmp0_;
352 ValaExpression* _tmp1_;
353 ValaDataType* _tmp2_;
354 ValaDataType* _tmp3_;
355 ValaMethodType* _tmp4_;
356 gboolean result = FALSE;
357 self = (ValaMethodCall*) base;
358 _tmp0_ = vala_method_call_get_call (self);
359 _tmp1_ = _tmp0_;
360 _tmp2_ = vala_expression_get_value_type (_tmp1_);
361 _tmp3_ = _tmp2_;
362 method_type = VALA_IS_METHOD_TYPE (_tmp3_) ? ((ValaMethodType*) _tmp3_) : NULL;
363 _tmp4_ = method_type;
364 if (_tmp4_ != NULL) {
365 ValaMethodType* _tmp5_;
366 ValaMethod* _tmp6_;
367 ValaMethod* _tmp7_;
368 gchar* _tmp8_;
369 gchar* _tmp9_;
370 gboolean _tmp10_;
371 _tmp5_ = method_type;
372 _tmp6_ = vala_method_type_get_method_symbol (_tmp5_);
373 _tmp7_ = _tmp6_;
374 _tmp8_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp7_);
375 _tmp9_ = _tmp8_;
376 _tmp10_ = g_strcmp0 (_tmp9_, "GLib.N_") == 0;
377 _g_free0 (_tmp9_);
378 if (_tmp10_) {
379 ValaList* _tmp11_;
380 gpointer _tmp12_;
381 ValaExpression* _tmp13_;
382 gboolean _tmp14_;
383 _tmp11_ = self->priv->argument_list;
384 _tmp12_ = vala_list_get (_tmp11_, 0);
385 _tmp13_ = (ValaExpression*) _tmp12_;
386 _tmp14_ = vala_expression_is_constant (_tmp13_);
387 _vala_code_node_unref0 (_tmp13_);
388 result = _tmp14_;
389 return result;
390 } else {
391 ValaMethodType* _tmp15_;
392 ValaMethod* _tmp16_;
393 ValaMethod* _tmp17_;
394 gchar* _tmp18_;
395 gchar* _tmp19_;
396 gboolean _tmp20_;
397 _tmp15_ = method_type;
398 _tmp16_ = vala_method_type_get_method_symbol (_tmp15_);
399 _tmp17_ = _tmp16_;
400 _tmp18_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp17_);
401 _tmp19_ = _tmp18_;
402 _tmp20_ = g_strcmp0 (_tmp19_, "GLib.NC_") == 0;
403 _g_free0 (_tmp19_);
404 if (_tmp20_) {
405 gboolean _tmp21_ = FALSE;
406 ValaList* _tmp22_;
407 gpointer _tmp23_;
408 ValaExpression* _tmp24_;
409 gboolean _tmp25_;
410 _tmp22_ = self->priv->argument_list;
411 _tmp23_ = vala_list_get (_tmp22_, 0);
412 _tmp24_ = (ValaExpression*) _tmp23_;
413 _tmp25_ = vala_expression_is_constant (_tmp24_);
414 _vala_code_node_unref0 (_tmp24_);
415 if (_tmp25_) {
416 ValaList* _tmp26_;
417 gpointer _tmp27_;
418 ValaExpression* _tmp28_;
419 _tmp26_ = self->priv->argument_list;
420 _tmp27_ = vala_list_get (_tmp26_, 1);
421 _tmp28_ = (ValaExpression*) _tmp27_;
422 _tmp21_ = vala_expression_is_constant (_tmp28_);
423 _vala_code_node_unref0 (_tmp28_);
424 } else {
425 _tmp21_ = FALSE;
426 }
427 result = _tmp21_;
428 return result;
429 }
430 }
431 }
432 result = FALSE;
433 return result;
434 }
435
436 static gboolean
vala_method_call_real_is_pure(ValaExpression * base)437 vala_method_call_real_is_pure (ValaExpression* base)
438 {
439 ValaMethodCall * self;
440 gboolean result = FALSE;
441 self = (ValaMethodCall*) base;
442 result = FALSE;
443 return result;
444 }
445
446 static gboolean
vala_method_call_real_is_accessible(ValaExpression * base,ValaSymbol * sym)447 vala_method_call_real_is_accessible (ValaExpression* base,
448 ValaSymbol* sym)
449 {
450 ValaMethodCall * self;
451 ValaExpression* _tmp10_;
452 ValaExpression* _tmp11_;
453 gboolean result = FALSE;
454 self = (ValaMethodCall*) base;
455 g_return_val_if_fail (sym != NULL, FALSE);
456 {
457 ValaList* _arg_list = NULL;
458 ValaList* _tmp0_;
459 ValaList* _tmp1_;
460 gint _arg_size = 0;
461 ValaList* _tmp2_;
462 gint _tmp3_;
463 gint _tmp4_;
464 gint _arg_index = 0;
465 _tmp0_ = self->priv->argument_list;
466 _tmp1_ = _vala_iterable_ref0 (_tmp0_);
467 _arg_list = _tmp1_;
468 _tmp2_ = _arg_list;
469 _tmp3_ = vala_collection_get_size ((ValaCollection*) _tmp2_);
470 _tmp4_ = _tmp3_;
471 _arg_size = _tmp4_;
472 _arg_index = -1;
473 while (TRUE) {
474 gint _tmp5_;
475 gint _tmp6_;
476 ValaExpression* arg = NULL;
477 ValaList* _tmp7_;
478 gpointer _tmp8_;
479 ValaExpression* _tmp9_;
480 _arg_index = _arg_index + 1;
481 _tmp5_ = _arg_index;
482 _tmp6_ = _arg_size;
483 if (!(_tmp5_ < _tmp6_)) {
484 break;
485 }
486 _tmp7_ = _arg_list;
487 _tmp8_ = vala_list_get (_tmp7_, _arg_index);
488 arg = (ValaExpression*) _tmp8_;
489 _tmp9_ = arg;
490 if (!vala_expression_is_accessible (_tmp9_, sym)) {
491 result = FALSE;
492 _vala_code_node_unref0 (arg);
493 _vala_iterable_unref0 (_arg_list);
494 return result;
495 }
496 _vala_code_node_unref0 (arg);
497 }
498 _vala_iterable_unref0 (_arg_list);
499 }
500 _tmp10_ = vala_method_call_get_call (self);
501 _tmp11_ = _tmp10_;
502 result = vala_expression_is_accessible (_tmp11_, sym);
503 return result;
504 }
505
506 static void
vala_method_call_real_get_error_types(ValaCodeNode * base,ValaCollection * collection,ValaSourceReference * source_reference)507 vala_method_call_real_get_error_types (ValaCodeNode* base,
508 ValaCollection* collection,
509 ValaSourceReference* source_reference)
510 {
511 ValaMethodCall * self;
512 ValaDataType* mtype = NULL;
513 ValaExpression* _tmp2_;
514 ValaExpression* _tmp3_;
515 ValaDataType* _tmp4_;
516 ValaDataType* _tmp5_;
517 ValaDataType* _tmp6_;
518 self = (ValaMethodCall*) base;
519 g_return_if_fail (collection != NULL);
520 if (source_reference == NULL) {
521 ValaSourceReference* _tmp0_;
522 ValaSourceReference* _tmp1_;
523 _tmp0_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
524 _tmp1_ = _tmp0_;
525 source_reference = _tmp1_;
526 }
527 _tmp2_ = vala_method_call_get_call (self);
528 _tmp3_ = _tmp2_;
529 _tmp4_ = vala_expression_get_value_type (_tmp3_);
530 _tmp5_ = _tmp4_;
531 mtype = _tmp5_;
532 _tmp6_ = mtype;
533 if (VALA_IS_METHOD_TYPE (_tmp6_)) {
534 ValaMethod* m = NULL;
535 ValaDataType* _tmp7_;
536 ValaMethod* _tmp8_;
537 ValaMethod* _tmp9_;
538 gboolean _tmp10_ = FALSE;
539 gboolean _tmp11_ = FALSE;
540 ValaMethod* _tmp12_;
541 gboolean _tmp13_;
542 gboolean _tmp14_;
543 _tmp7_ = mtype;
544 _tmp8_ = vala_method_type_get_method_symbol (G_TYPE_CHECK_INSTANCE_CAST (_tmp7_, VALA_TYPE_METHOD_TYPE, ValaMethodType));
545 _tmp9_ = _tmp8_;
546 m = _tmp9_;
547 _tmp12_ = m;
548 _tmp13_ = vala_method_get_coroutine (_tmp12_);
549 _tmp14_ = _tmp13_;
550 if (_tmp14_) {
551 gboolean _tmp15_;
552 _tmp15_ = self->priv->_is_yield_expression;
553 _tmp11_ = !_tmp15_;
554 } else {
555 _tmp11_ = FALSE;
556 }
557 if (_tmp11_) {
558 ValaExpression* _tmp16_;
559 ValaExpression* _tmp17_;
560 const gchar* _tmp18_;
561 const gchar* _tmp19_;
562 _tmp16_ = vala_method_call_get_call (self);
563 _tmp17_ = _tmp16_;
564 _tmp18_ = vala_member_access_get_member_name (G_TYPE_CHECK_INSTANCE_CAST (_tmp17_, VALA_TYPE_MEMBER_ACCESS, ValaMemberAccess));
565 _tmp19_ = _tmp18_;
566 _tmp10_ = g_strcmp0 (_tmp19_, "end") != 0;
567 } else {
568 _tmp10_ = FALSE;
569 }
570 if (!_tmp10_) {
571 ValaMethod* _tmp20_;
572 _tmp20_ = m;
573 vala_code_node_get_error_types ((ValaCodeNode*) _tmp20_, collection, source_reference);
574 }
575 } else {
576 ValaDataType* _tmp21_;
577 _tmp21_ = mtype;
578 if (VALA_IS_OBJECT_TYPE (_tmp21_)) {
579 ValaClass* cl = NULL;
580 ValaDataType* _tmp22_;
581 ValaTypeSymbol* _tmp23_;
582 ValaTypeSymbol* _tmp24_;
583 ValaMethod* m = NULL;
584 ValaClass* _tmp25_;
585 ValaCreationMethod* _tmp26_;
586 ValaCreationMethod* _tmp27_;
587 ValaMethod* _tmp28_;
588 _tmp22_ = mtype;
589 _tmp23_ = vala_data_type_get_type_symbol ((ValaDataType*) G_TYPE_CHECK_INSTANCE_CAST (_tmp22_, VALA_TYPE_OBJECT_TYPE, ValaObjectType));
590 _tmp24_ = _tmp23_;
591 cl = G_TYPE_CHECK_INSTANCE_CAST (_tmp24_, VALA_TYPE_CLASS, ValaClass);
592 _tmp25_ = cl;
593 _tmp26_ = vala_class_get_default_construction_method (_tmp25_);
594 _tmp27_ = _tmp26_;
595 m = (ValaMethod*) _tmp27_;
596 _tmp28_ = m;
597 vala_code_node_get_error_types ((ValaCodeNode*) _tmp28_, collection, source_reference);
598 } else {
599 ValaDataType* _tmp29_;
600 _tmp29_ = mtype;
601 if (VALA_IS_DELEGATE_TYPE (_tmp29_)) {
602 ValaDelegate* d = NULL;
603 ValaDataType* _tmp30_;
604 ValaDelegate* _tmp31_;
605 ValaDelegate* _tmp32_;
606 ValaDelegate* _tmp33_;
607 _tmp30_ = mtype;
608 _tmp31_ = vala_delegate_type_get_delegate_symbol (G_TYPE_CHECK_INSTANCE_CAST (_tmp30_, VALA_TYPE_DELEGATE_TYPE, ValaDelegateType));
609 _tmp32_ = _tmp31_;
610 d = _tmp32_;
611 _tmp33_ = d;
612 vala_code_node_get_error_types ((ValaCodeNode*) _tmp33_, collection, source_reference);
613 }
614 }
615 }
616 {
617 ValaList* _expr_list = NULL;
618 ValaList* _tmp34_;
619 ValaList* _tmp35_;
620 gint _expr_size = 0;
621 ValaList* _tmp36_;
622 gint _tmp37_;
623 gint _tmp38_;
624 gint _expr_index = 0;
625 _tmp34_ = self->priv->argument_list;
626 _tmp35_ = _vala_iterable_ref0 (_tmp34_);
627 _expr_list = _tmp35_;
628 _tmp36_ = _expr_list;
629 _tmp37_ = vala_collection_get_size ((ValaCollection*) _tmp36_);
630 _tmp38_ = _tmp37_;
631 _expr_size = _tmp38_;
632 _expr_index = -1;
633 while (TRUE) {
634 gint _tmp39_;
635 gint _tmp40_;
636 ValaExpression* expr = NULL;
637 ValaList* _tmp41_;
638 gpointer _tmp42_;
639 ValaExpression* _tmp43_;
640 _expr_index = _expr_index + 1;
641 _tmp39_ = _expr_index;
642 _tmp40_ = _expr_size;
643 if (!(_tmp39_ < _tmp40_)) {
644 break;
645 }
646 _tmp41_ = _expr_list;
647 _tmp42_ = vala_list_get (_tmp41_, _expr_index);
648 expr = (ValaExpression*) _tmp42_;
649 _tmp43_ = expr;
650 vala_code_node_get_error_types ((ValaCodeNode*) _tmp43_, collection, source_reference);
651 _vala_code_node_unref0 (expr);
652 }
653 _vala_iterable_unref0 (_expr_list);
654 }
655 }
656
657 static gboolean
vala_method_call_real_check(ValaCodeNode * base,ValaCodeContext * context)658 vala_method_call_real_check (ValaCodeNode* base,
659 ValaCodeContext* context)
660 {
661 ValaMethodCall * self;
662 gboolean _tmp0_;
663 gboolean _tmp1_;
664 ValaExpression* _tmp4_;
665 ValaExpression* _tmp5_;
666 ValaDataType* target_object_type = NULL;
667 ValaList* method_type_args = NULL;
668 ValaExpression* _tmp6_;
669 ValaExpression* _tmp7_;
670 ValaDataType* _tmp8_;
671 ValaDataType* _tmp9_;
672 ValaDataType* mtype = NULL;
673 ValaExpression* _tmp104_;
674 ValaExpression* _tmp105_;
675 ValaDataType* _tmp106_;
676 ValaDataType* _tmp107_;
677 ValaDataType* _tmp108_;
678 gboolean _tmp109_ = FALSE;
679 ValaProfile _tmp110_;
680 ValaProfile _tmp111_;
681 gboolean gobject_chainup = FALSE;
682 ValaCreationMethod* base_cm = NULL;
683 gboolean _tmp137_;
684 gboolean _tmp223_ = FALSE;
685 ValaExpression* _tmp224_;
686 ValaExpression* _tmp225_;
687 gboolean _tmp297_ = FALSE;
688 gboolean _tmp298_;
689 ValaDataType* ret_type = NULL;
690 ValaDataType* _tmp313_;
691 ValaDataType* _tmp314_;
692 ValaDataType* _tmp315_;
693 ValaList* params = NULL;
694 ValaDataType* _tmp316_;
695 ValaList* _tmp317_;
696 ValaList* _tmp318_;
697 ValaDataType* _tmp319_;
698 ValaExpression* last_arg = NULL;
699 ValaIterator* arg_it = NULL;
700 ValaList* _tmp374_;
701 ValaIterator* _tmp375_;
702 gboolean _tmp426_ = FALSE;
703 ValaDataType* _tmp427_;
704 gboolean _tmp449_ = FALSE;
705 ValaDataType* _tmp450_;
706 gboolean force_lambda_method_closure = FALSE;
707 gboolean _tmp532_ = FALSE;
708 gboolean _tmp533_;
709 gboolean _tmp534_;
710 ValaDataType* _tmp555_;
711 ValaDataType* _tmp566_;
712 ValaDataType* _tmp567_;
713 ValaDataType* _tmp568_;
714 ValaDataType* _tmp569_;
715 ValaDataType* _tmp570_;
716 ValaDataType* _tmp571_;
717 ValaList* _tmp572_;
718 ValaDataType* _tmp573_;
719 ValaDataType* _tmp574_;
720 gboolean _tmp575_;
721 ValaDataType* _tmp598_;
722 ValaSemanticAnalyzer* _tmp845_;
723 ValaSemanticAnalyzer* _tmp846_;
724 ValaDataType* _tmp847_;
725 ValaList* _tmp848_;
726 ValaList* _tmp849_;
727 gboolean _tmp877_ = FALSE;
728 gboolean _tmp878_ = FALSE;
729 ValaCreationMethod* _tmp879_;
730 ValaDataType* _tmp907_;
731 ValaDataType* _tmp908_;
732 gboolean _tmp909_;
733 gboolean _tmp910_;
734 gboolean _tmp971_;
735 gboolean _tmp972_;
736 gboolean result = FALSE;
737 self = (ValaMethodCall*) base;
738 g_return_val_if_fail (context != NULL, FALSE);
739 _tmp0_ = vala_code_node_get_checked ((ValaCodeNode*) self);
740 _tmp1_ = _tmp0_;
741 if (_tmp1_) {
742 gboolean _tmp2_;
743 gboolean _tmp3_;
744 _tmp2_ = vala_code_node_get_error ((ValaCodeNode*) self);
745 _tmp3_ = _tmp2_;
746 result = !_tmp3_;
747 return result;
748 }
749 vala_code_node_set_checked ((ValaCodeNode*) self, TRUE);
750 _tmp4_ = vala_method_call_get_call (self);
751 _tmp5_ = _tmp4_;
752 if (!vala_code_node_check ((ValaCodeNode*) _tmp5_, context)) {
753 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
754 result = FALSE;
755 return result;
756 }
757 target_object_type = NULL;
758 method_type_args = NULL;
759 _tmp6_ = vala_method_call_get_call (self);
760 _tmp7_ = _tmp6_;
761 _tmp8_ = vala_expression_get_value_type (_tmp7_);
762 _tmp9_ = _tmp8_;
763 if (VALA_IS_DELEGATE_TYPE (_tmp9_)) {
764 ValaExpression* _tmp10_;
765 ValaExpression* _tmp11_;
766 ValaDataType* _tmp12_;
767 ValaDataType* _tmp13_;
768 ValaDataType* _tmp14_;
769 _tmp10_ = vala_method_call_get_call (self);
770 _tmp11_ = _tmp10_;
771 _tmp12_ = vala_expression_get_value_type (_tmp11_);
772 _tmp13_ = _tmp12_;
773 _tmp14_ = _vala_code_node_ref0 (_tmp13_);
774 _vala_code_node_unref0 (target_object_type);
775 target_object_type = _tmp14_;
776 } else {
777 ValaExpression* _tmp15_;
778 ValaExpression* _tmp16_;
779 _tmp15_ = vala_method_call_get_call (self);
780 _tmp16_ = _tmp15_;
781 if (VALA_IS_MEMBER_ACCESS (_tmp16_)) {
782 ValaMemberAccess* ma = NULL;
783 ValaExpression* _tmp17_;
784 ValaExpression* _tmp18_;
785 ValaMemberAccess* _tmp19_;
786 gboolean _tmp20_;
787 gboolean _tmp21_;
788 ValaMemberAccess* _tmp32_;
789 ValaList* _tmp33_;
790 ValaList* _tmp34_;
791 ValaMemberAccess* _tmp35_;
792 ValaExpression* _tmp36_;
793 ValaExpression* _tmp37_;
794 gboolean _tmp88_ = FALSE;
795 ValaMemberAccess* _tmp89_;
796 ValaSymbol* _tmp90_;
797 ValaSymbol* _tmp91_;
798 _tmp17_ = vala_method_call_get_call (self);
799 _tmp18_ = _tmp17_;
800 ma = G_TYPE_CHECK_INSTANCE_CAST (_tmp18_, VALA_TYPE_MEMBER_ACCESS, ValaMemberAccess);
801 _tmp19_ = ma;
802 _tmp20_ = vala_member_access_get_prototype_access (_tmp19_);
803 _tmp21_ = _tmp20_;
804 if (_tmp21_) {
805 ValaSourceReference* _tmp22_;
806 ValaSourceReference* _tmp23_;
807 ValaExpression* _tmp24_;
808 ValaExpression* _tmp25_;
809 ValaSymbol* _tmp26_;
810 ValaSymbol* _tmp27_;
811 gchar* _tmp28_;
812 gchar* _tmp29_;
813 gchar* _tmp30_;
814 gchar* _tmp31_;
815 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
816 _tmp22_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
817 _tmp23_ = _tmp22_;
818 _tmp24_ = vala_method_call_get_call (self);
819 _tmp25_ = _tmp24_;
820 _tmp26_ = vala_expression_get_symbol_reference (_tmp25_);
821 _tmp27_ = _tmp26_;
822 _tmp28_ = vala_symbol_get_full_name (_tmp27_);
823 _tmp29_ = _tmp28_;
824 _tmp30_ = g_strdup_printf ("Access to instance member `%s' denied", _tmp29_);
825 _tmp31_ = _tmp30_;
826 vala_report_error (_tmp23_, _tmp31_);
827 _g_free0 (_tmp31_);
828 _g_free0 (_tmp29_);
829 result = FALSE;
830 _vala_iterable_unref0 (method_type_args);
831 _vala_code_node_unref0 (target_object_type);
832 return result;
833 }
834 _tmp32_ = ma;
835 _tmp33_ = vala_member_access_get_type_arguments (_tmp32_);
836 _tmp34_ = _vala_iterable_ref0 (_tmp33_);
837 _vala_iterable_unref0 (method_type_args);
838 method_type_args = _tmp34_;
839 _tmp35_ = ma;
840 _tmp36_ = vala_member_access_get_inner (_tmp35_);
841 _tmp37_ = _tmp36_;
842 if (_tmp37_ != NULL) {
843 ValaMemberAccess* _tmp38_;
844 ValaExpression* _tmp39_;
845 ValaExpression* _tmp40_;
846 ValaDataType* _tmp41_;
847 ValaDataType* _tmp42_;
848 ValaDataType* _tmp43_;
849 ValaMemberAccess* _tmp44_;
850 ValaExpression* _tmp45_;
851 ValaExpression* _tmp46_;
852 ValaSymbol* _tmp47_;
853 ValaSymbol* _tmp48_;
854 ValaMethod* m = NULL;
855 ValaMemberAccess* _tmp59_;
856 ValaSymbol* _tmp60_;
857 ValaSymbol* _tmp61_;
858 gboolean _tmp62_ = FALSE;
859 ValaMethod* _tmp63_;
860 _tmp38_ = ma;
861 _tmp39_ = vala_member_access_get_inner (_tmp38_);
862 _tmp40_ = _tmp39_;
863 _tmp41_ = vala_expression_get_value_type (_tmp40_);
864 _tmp42_ = _tmp41_;
865 _tmp43_ = _vala_code_node_ref0 (_tmp42_);
866 _vala_code_node_unref0 (target_object_type);
867 target_object_type = _tmp43_;
868 _tmp44_ = ma;
869 _tmp45_ = vala_member_access_get_inner (_tmp44_);
870 _tmp46_ = _tmp45_;
871 _tmp47_ = vala_expression_get_symbol_reference (_tmp46_);
872 _tmp48_ = _tmp47_;
873 if (VALA_IS_SIGNAL (_tmp48_)) {
874 ValaMemberAccess* sig = NULL;
875 ValaMemberAccess* _tmp49_;
876 ValaExpression* _tmp50_;
877 ValaExpression* _tmp51_;
878 ValaMemberAccess* _tmp52_;
879 _tmp49_ = ma;
880 _tmp50_ = vala_member_access_get_inner (_tmp49_);
881 _tmp51_ = _tmp50_;
882 sig = VALA_IS_MEMBER_ACCESS (_tmp51_) ? ((ValaMemberAccess*) _tmp51_) : NULL;
883 _tmp52_ = sig;
884 if (_tmp52_ != NULL) {
885 ValaMemberAccess* _tmp53_;
886 ValaExpression* _tmp54_;
887 ValaExpression* _tmp55_;
888 ValaDataType* _tmp56_;
889 ValaDataType* _tmp57_;
890 ValaDataType* _tmp58_;
891 _tmp53_ = sig;
892 _tmp54_ = vala_member_access_get_inner (_tmp53_);
893 _tmp55_ = _tmp54_;
894 _tmp56_ = vala_expression_get_value_type (_tmp55_);
895 _tmp57_ = _tmp56_;
896 _tmp58_ = _vala_code_node_ref0 (_tmp57_);
897 _vala_code_node_unref0 (target_object_type);
898 target_object_type = _tmp58_;
899 }
900 }
901 _tmp59_ = ma;
902 _tmp60_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp59_);
903 _tmp61_ = _tmp60_;
904 m = VALA_IS_METHOD (_tmp61_) ? ((ValaMethod*) _tmp61_) : NULL;
905 _tmp63_ = m;
906 if (_tmp63_ != NULL) {
907 ValaMethod* _tmp64_;
908 gboolean _tmp65_;
909 gboolean _tmp66_;
910 _tmp64_ = m;
911 _tmp65_ = vala_method_get_coroutine (_tmp64_);
912 _tmp66_ = _tmp65_;
913 _tmp62_ = _tmp66_;
914 } else {
915 _tmp62_ = FALSE;
916 }
917 if (_tmp62_) {
918 gboolean _tmp67_ = FALSE;
919 ValaMemberAccess* _tmp68_;
920 const gchar* _tmp69_;
921 const gchar* _tmp70_;
922 _tmp68_ = ma;
923 _tmp69_ = vala_member_access_get_member_name (_tmp68_);
924 _tmp70_ = _tmp69_;
925 if (g_strcmp0 (_tmp70_, "begin") == 0) {
926 _tmp67_ = TRUE;
927 } else {
928 ValaMemberAccess* _tmp71_;
929 const gchar* _tmp72_;
930 const gchar* _tmp73_;
931 _tmp71_ = ma;
932 _tmp72_ = vala_member_access_get_member_name (_tmp71_);
933 _tmp73_ = _tmp72_;
934 _tmp67_ = g_strcmp0 (_tmp73_, "end") == 0;
935 }
936 if (_tmp67_) {
937 ValaMemberAccess* method_access = NULL;
938 ValaMemberAccess* _tmp74_;
939 ValaExpression* _tmp75_;
940 ValaExpression* _tmp76_;
941 gboolean _tmp77_ = FALSE;
942 ValaMemberAccess* _tmp78_;
943 _tmp74_ = ma;
944 _tmp75_ = vala_member_access_get_inner (_tmp74_);
945 _tmp76_ = _tmp75_;
946 method_access = VALA_IS_MEMBER_ACCESS (_tmp76_) ? ((ValaMemberAccess*) _tmp76_) : NULL;
947 _tmp78_ = method_access;
948 if (_tmp78_ != NULL) {
949 ValaMemberAccess* _tmp79_;
950 ValaExpression* _tmp80_;
951 ValaExpression* _tmp81_;
952 _tmp79_ = method_access;
953 _tmp80_ = vala_member_access_get_inner (_tmp79_);
954 _tmp81_ = _tmp80_;
955 _tmp77_ = _tmp81_ != NULL;
956 } else {
957 _tmp77_ = FALSE;
958 }
959 if (_tmp77_) {
960 ValaMemberAccess* _tmp82_;
961 ValaExpression* _tmp83_;
962 ValaExpression* _tmp84_;
963 ValaDataType* _tmp85_;
964 ValaDataType* _tmp86_;
965 ValaDataType* _tmp87_;
966 _tmp82_ = method_access;
967 _tmp83_ = vala_member_access_get_inner (_tmp82_);
968 _tmp84_ = _tmp83_;
969 _tmp85_ = vala_expression_get_value_type (_tmp84_);
970 _tmp86_ = _tmp85_;
971 _tmp87_ = _vala_code_node_ref0 (_tmp86_);
972 _vala_code_node_unref0 (target_object_type);
973 target_object_type = _tmp87_;
974 } else {
975 _vala_code_node_unref0 (target_object_type);
976 target_object_type = NULL;
977 }
978 }
979 }
980 }
981 _tmp89_ = ma;
982 _tmp90_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp89_);
983 _tmp91_ = _tmp90_;
984 if (_tmp91_ != NULL) {
985 ValaMemberAccess* _tmp92_;
986 ValaSymbol* _tmp93_;
987 ValaSymbol* _tmp94_;
988 ValaAttribute* _tmp95_;
989 _tmp92_ = ma;
990 _tmp93_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp92_);
991 _tmp94_ = _tmp93_;
992 _tmp95_ = vala_code_node_get_attribute ((ValaCodeNode*) _tmp94_, "Assert");
993 _tmp88_ = _tmp95_ != NULL;
994 } else {
995 _tmp88_ = FALSE;
996 }
997 if (_tmp88_) {
998 ValaList* _tmp96_;
999 gint _tmp97_;
1000 gint _tmp98_;
1001 vala_method_call_set_is_assert (self, TRUE);
1002 _tmp96_ = self->priv->argument_list;
1003 _tmp97_ = vala_collection_get_size ((ValaCollection*) _tmp96_);
1004 _tmp98_ = _tmp97_;
1005 if (_tmp98_ == 1) {
1006 ValaList* _tmp99_;
1007 gpointer _tmp100_;
1008 ValaExpression* _tmp101_;
1009 ValaSourceReference* _tmp102_;
1010 ValaSourceReference* _tmp103_;
1011 _tmp99_ = self->priv->argument_list;
1012 _tmp100_ = vala_list_get (_tmp99_, 0);
1013 _tmp101_ = (ValaExpression*) _tmp100_;
1014 _tmp102_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp101_);
1015 _tmp103_ = _tmp102_;
1016 vala_code_node_set_source_reference ((ValaCodeNode*) self, _tmp103_);
1017 _vala_code_node_unref0 (_tmp101_);
1018 }
1019 }
1020 }
1021 }
1022 _tmp104_ = vala_method_call_get_call (self);
1023 _tmp105_ = _tmp104_;
1024 _tmp106_ = vala_expression_get_value_type (_tmp105_);
1025 _tmp107_ = _tmp106_;
1026 _tmp108_ = _vala_code_node_ref0 (_tmp107_);
1027 mtype = _tmp108_;
1028 _tmp110_ = vala_code_context_get_profile (context);
1029 _tmp111_ = _tmp110_;
1030 if (_tmp111_ == VALA_PROFILE_GOBJECT) {
1031 ValaExpression* _tmp112_;
1032 ValaExpression* _tmp113_;
1033 ValaSymbol* _tmp114_;
1034 ValaSymbol* _tmp115_;
1035 ValaSemanticAnalyzer* _tmp116_;
1036 ValaSemanticAnalyzer* _tmp117_;
1037 ValaClass* _tmp118_;
1038 _tmp112_ = vala_method_call_get_call (self);
1039 _tmp113_ = _tmp112_;
1040 _tmp114_ = vala_expression_get_symbol_reference (_tmp113_);
1041 _tmp115_ = _tmp114_;
1042 _tmp116_ = vala_code_context_get_analyzer (context);
1043 _tmp117_ = _tmp116_;
1044 _tmp118_ = _tmp117_->object_type;
1045 _tmp109_ = _tmp115_ == G_TYPE_CHECK_INSTANCE_CAST (_tmp118_, VALA_TYPE_SYMBOL, ValaSymbol);
1046 } else {
1047 _tmp109_ = FALSE;
1048 }
1049 gobject_chainup = _tmp109_;
1050 vala_method_call_set_is_chainup (self, gobject_chainup);
1051 if (!gobject_chainup) {
1052 ValaExpression* expr = NULL;
1053 ValaExpression* _tmp119_;
1054 ValaExpression* _tmp120_;
1055 ValaMemberAccess* ma = NULL;
1056 ValaExpression* _tmp121_;
1057 gboolean _tmp122_ = FALSE;
1058 ValaMemberAccess* _tmp123_;
1059 gboolean _tmp131_ = FALSE;
1060 ValaMemberAccess* _tmp132_;
1061 _tmp119_ = vala_method_call_get_call (self);
1062 _tmp120_ = _tmp119_;
1063 expr = _tmp120_;
1064 _tmp121_ = expr;
1065 ma = VALA_IS_MEMBER_ACCESS (_tmp121_) ? ((ValaMemberAccess*) _tmp121_) : NULL;
1066 _tmp123_ = ma;
1067 if (_tmp123_ != NULL) {
1068 ValaMemberAccess* _tmp124_;
1069 ValaSymbol* _tmp125_;
1070 ValaSymbol* _tmp126_;
1071 _tmp124_ = ma;
1072 _tmp125_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp124_);
1073 _tmp126_ = _tmp125_;
1074 _tmp122_ = VALA_IS_CREATION_METHOD (_tmp126_);
1075 } else {
1076 _tmp122_ = FALSE;
1077 }
1078 if (_tmp122_) {
1079 ValaMemberAccess* _tmp127_;
1080 ValaExpression* _tmp128_;
1081 ValaExpression* _tmp129_;
1082 ValaExpression* _tmp130_;
1083 _tmp127_ = ma;
1084 _tmp128_ = vala_member_access_get_inner (_tmp127_);
1085 _tmp129_ = _tmp128_;
1086 expr = _tmp129_;
1087 _tmp130_ = expr;
1088 ma = VALA_IS_MEMBER_ACCESS (_tmp130_) ? ((ValaMemberAccess*) _tmp130_) : NULL;
1089 }
1090 _tmp132_ = ma;
1091 if (_tmp132_ != NULL) {
1092 ValaMemberAccess* _tmp133_;
1093 const gchar* _tmp134_;
1094 const gchar* _tmp135_;
1095 _tmp133_ = ma;
1096 _tmp134_ = vala_member_access_get_member_name (_tmp133_);
1097 _tmp135_ = _tmp134_;
1098 _tmp131_ = g_strcmp0 (_tmp135_, "this") == 0;
1099 } else {
1100 _tmp131_ = FALSE;
1101 }
1102 if (_tmp131_) {
1103 vala_method_call_set_is_chainup (self, TRUE);
1104 } else {
1105 ValaExpression* _tmp136_;
1106 _tmp136_ = expr;
1107 if (VALA_IS_BASE_ACCESS (_tmp136_)) {
1108 vala_method_call_set_is_chainup (self, TRUE);
1109 }
1110 }
1111 }
1112 base_cm = NULL;
1113 _tmp137_ = self->priv->_is_chainup;
1114 if (_tmp137_) {
1115 ValaCreationMethod* cm = NULL;
1116 ValaSemanticAnalyzer* _tmp138_;
1117 ValaSemanticAnalyzer* _tmp139_;
1118 ValaMethod* _tmp140_;
1119 ValaCreationMethod* _tmp141_;
1120 ValaCreationMethod* _tmp149_;
1121 ValaDataType* _tmp150_;
1122 _tmp138_ = vala_code_context_get_analyzer (context);
1123 _tmp139_ = _tmp138_;
1124 _tmp140_ = vala_semantic_analyzer_find_current_method (_tmp139_);
1125 cm = VALA_IS_CREATION_METHOD (_tmp140_) ? ((ValaCreationMethod*) _tmp140_) : NULL;
1126 _tmp141_ = cm;
1127 if (_tmp141_ == NULL) {
1128 ValaSourceReference* _tmp142_;
1129 ValaSourceReference* _tmp143_;
1130 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
1131 _tmp142_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
1132 _tmp143_ = _tmp142_;
1133 vala_report_error (_tmp143_, "invocation not supported in this context");
1134 result = FALSE;
1135 _vala_code_node_unref0 (mtype);
1136 _vala_iterable_unref0 (method_type_args);
1137 _vala_code_node_unref0 (target_object_type);
1138 return result;
1139 } else {
1140 ValaCreationMethod* _tmp144_;
1141 gboolean _tmp145_;
1142 gboolean _tmp146_;
1143 _tmp144_ = cm;
1144 _tmp145_ = vala_creation_method_get_chain_up (_tmp144_);
1145 _tmp146_ = _tmp145_;
1146 if (_tmp146_) {
1147 ValaSourceReference* _tmp147_;
1148 ValaSourceReference* _tmp148_;
1149 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
1150 _tmp147_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
1151 _tmp148_ = _tmp147_;
1152 vala_report_error (_tmp148_, "Multiple constructor calls in the same constructor are not permitted");
1153 result = FALSE;
1154 _vala_code_node_unref0 (mtype);
1155 _vala_iterable_unref0 (method_type_args);
1156 _vala_code_node_unref0 (target_object_type);
1157 return result;
1158 }
1159 }
1160 _tmp149_ = cm;
1161 vala_creation_method_set_chain_up (_tmp149_, TRUE);
1162 _tmp150_ = mtype;
1163 if (VALA_IS_OBJECT_TYPE (_tmp150_)) {
1164 ValaClass* cl = NULL;
1165 ValaDataType* _tmp151_;
1166 ValaTypeSymbol* _tmp152_;
1167 ValaTypeSymbol* _tmp153_;
1168 ValaClass* _tmp154_;
1169 ValaCreationMethod* _tmp155_;
1170 ValaCreationMethod* _tmp156_;
1171 ValaCreationMethod* _tmp157_;
1172 _tmp151_ = mtype;
1173 _tmp152_ = vala_data_type_get_type_symbol ((ValaDataType*) G_TYPE_CHECK_INSTANCE_CAST (_tmp151_, VALA_TYPE_OBJECT_TYPE, ValaObjectType));
1174 _tmp153_ = _tmp152_;
1175 cl = G_TYPE_CHECK_INSTANCE_CAST (_tmp153_, VALA_TYPE_CLASS, ValaClass);
1176 _tmp154_ = cl;
1177 _tmp155_ = vala_class_get_default_construction_method (_tmp154_);
1178 _tmp156_ = _tmp155_;
1179 base_cm = _tmp156_;
1180 _tmp157_ = base_cm;
1181 if (_tmp157_ == NULL) {
1182 ValaSourceReference* _tmp158_;
1183 ValaSourceReference* _tmp159_;
1184 ValaClass* _tmp160_;
1185 gchar* _tmp161_;
1186 gchar* _tmp162_;
1187 gchar* _tmp163_;
1188 gchar* _tmp164_;
1189 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
1190 _tmp158_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
1191 _tmp159_ = _tmp158_;
1192 _tmp160_ = cl;
1193 _tmp161_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp160_);
1194 _tmp162_ = _tmp161_;
1195 _tmp163_ = g_strdup_printf ("chain up to `%s' not supported", _tmp162_);
1196 _tmp164_ = _tmp163_;
1197 vala_report_error (_tmp159_, _tmp164_);
1198 _g_free0 (_tmp164_);
1199 _g_free0 (_tmp162_);
1200 result = FALSE;
1201 _vala_code_node_unref0 (mtype);
1202 _vala_iterable_unref0 (method_type_args);
1203 _vala_code_node_unref0 (target_object_type);
1204 return result;
1205 } else {
1206 ValaCreationMethod* _tmp165_;
1207 gboolean _tmp166_;
1208 gboolean _tmp167_;
1209 _tmp165_ = base_cm;
1210 _tmp166_ = vala_method_get_has_construct_function ((ValaMethod*) _tmp165_);
1211 _tmp167_ = _tmp166_;
1212 if (!_tmp167_) {
1213 ValaSourceReference* _tmp168_;
1214 ValaSourceReference* _tmp169_;
1215 ValaCreationMethod* _tmp170_;
1216 gchar* _tmp171_;
1217 gchar* _tmp172_;
1218 gchar* _tmp173_;
1219 gchar* _tmp174_;
1220 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
1221 _tmp168_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
1222 _tmp169_ = _tmp168_;
1223 _tmp170_ = base_cm;
1224 _tmp171_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp170_);
1225 _tmp172_ = _tmp171_;
1226 _tmp173_ = g_strdup_printf ("chain up to `%s' not supported", _tmp172_);
1227 _tmp174_ = _tmp173_;
1228 vala_report_error (_tmp169_, _tmp174_);
1229 _g_free0 (_tmp174_);
1230 _g_free0 (_tmp172_);
1231 result = FALSE;
1232 _vala_code_node_unref0 (mtype);
1233 _vala_iterable_unref0 (method_type_args);
1234 _vala_code_node_unref0 (target_object_type);
1235 return result;
1236 }
1237 }
1238 } else {
1239 gboolean _tmp175_ = FALSE;
1240 ValaExpression* _tmp176_;
1241 ValaExpression* _tmp177_;
1242 ValaSymbol* _tmp178_;
1243 ValaSymbol* _tmp179_;
1244 _tmp176_ = vala_method_call_get_call (self);
1245 _tmp177_ = _tmp176_;
1246 _tmp178_ = vala_expression_get_symbol_reference (_tmp177_);
1247 _tmp179_ = _tmp178_;
1248 if (VALA_IS_CREATION_METHOD (_tmp179_)) {
1249 ValaExpression* _tmp180_;
1250 ValaExpression* _tmp181_;
1251 ValaSymbol* _tmp182_;
1252 ValaSymbol* _tmp183_;
1253 ValaSymbol* _tmp184_;
1254 ValaSymbol* _tmp185_;
1255 _tmp180_ = vala_method_call_get_call (self);
1256 _tmp181_ = _tmp180_;
1257 _tmp182_ = vala_expression_get_symbol_reference (_tmp181_);
1258 _tmp183_ = _tmp182_;
1259 _tmp184_ = vala_symbol_get_parent_symbol (_tmp183_);
1260 _tmp185_ = _tmp184_;
1261 _tmp175_ = VALA_IS_CLASS (_tmp185_);
1262 } else {
1263 _tmp175_ = FALSE;
1264 }
1265 if (_tmp175_) {
1266 ValaExpression* _tmp186_;
1267 ValaExpression* _tmp187_;
1268 ValaSymbol* _tmp188_;
1269 ValaSymbol* _tmp189_;
1270 ValaCreationMethod* _tmp190_;
1271 gboolean _tmp191_;
1272 gboolean _tmp192_;
1273 _tmp186_ = vala_method_call_get_call (self);
1274 _tmp187_ = _tmp186_;
1275 _tmp188_ = vala_expression_get_symbol_reference (_tmp187_);
1276 _tmp189_ = _tmp188_;
1277 base_cm = G_TYPE_CHECK_INSTANCE_CAST (_tmp189_, VALA_TYPE_CREATION_METHOD, ValaCreationMethod);
1278 _tmp190_ = base_cm;
1279 _tmp191_ = vala_method_get_has_construct_function ((ValaMethod*) _tmp190_);
1280 _tmp192_ = _tmp191_;
1281 if (!_tmp192_) {
1282 ValaSourceReference* _tmp193_;
1283 ValaSourceReference* _tmp194_;
1284 ValaCreationMethod* _tmp195_;
1285 gchar* _tmp196_;
1286 gchar* _tmp197_;
1287 gchar* _tmp198_;
1288 gchar* _tmp199_;
1289 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
1290 _tmp193_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
1291 _tmp194_ = _tmp193_;
1292 _tmp195_ = base_cm;
1293 _tmp196_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp195_);
1294 _tmp197_ = _tmp196_;
1295 _tmp198_ = g_strdup_printf ("chain up to `%s' not supported", _tmp197_);
1296 _tmp199_ = _tmp198_;
1297 vala_report_error (_tmp194_, _tmp199_);
1298 _g_free0 (_tmp199_);
1299 _g_free0 (_tmp197_);
1300 result = FALSE;
1301 _vala_code_node_unref0 (mtype);
1302 _vala_iterable_unref0 (method_type_args);
1303 _vala_code_node_unref0 (target_object_type);
1304 return result;
1305 }
1306 } else {
1307 if (gobject_chainup) {
1308 ValaClass* cl = NULL;
1309 ValaCreationMethod* _tmp200_;
1310 ValaSymbol* _tmp201_;
1311 ValaSymbol* _tmp202_;
1312 gboolean _tmp203_ = FALSE;
1313 ValaClass* _tmp204_;
1314 ValaExpression* _tmp211_;
1315 ValaExpression* _tmp212_;
1316 ValaSemanticAnalyzer* _tmp213_;
1317 ValaSemanticAnalyzer* _tmp214_;
1318 ValaClass* _tmp215_;
1319 ValaObjectType* _tmp216_;
1320 ValaObjectType* _tmp217_;
1321 ValaExpression* _tmp218_;
1322 ValaExpression* _tmp219_;
1323 ValaDataType* _tmp220_;
1324 ValaDataType* _tmp221_;
1325 ValaDataType* _tmp222_;
1326 _tmp200_ = cm;
1327 _tmp201_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp200_);
1328 _tmp202_ = _tmp201_;
1329 cl = VALA_IS_CLASS (_tmp202_) ? ((ValaClass*) _tmp202_) : NULL;
1330 _tmp204_ = cl;
1331 if (_tmp204_ == NULL) {
1332 _tmp203_ = TRUE;
1333 } else {
1334 ValaClass* _tmp205_;
1335 ValaSemanticAnalyzer* _tmp206_;
1336 ValaSemanticAnalyzer* _tmp207_;
1337 ValaClass* _tmp208_;
1338 _tmp205_ = cl;
1339 _tmp206_ = vala_code_context_get_analyzer (context);
1340 _tmp207_ = _tmp206_;
1341 _tmp208_ = _tmp207_->object_type;
1342 _tmp203_ = !vala_typesymbol_is_subtype_of ((ValaTypeSymbol*) _tmp205_, (ValaTypeSymbol*) _tmp208_);
1343 }
1344 if (_tmp203_) {
1345 ValaSourceReference* _tmp209_;
1346 ValaSourceReference* _tmp210_;
1347 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
1348 _tmp209_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
1349 _tmp210_ = _tmp209_;
1350 vala_report_error (_tmp210_, "chain up to `GLib.Object' not supported");
1351 result = FALSE;
1352 _vala_code_node_unref0 (mtype);
1353 _vala_iterable_unref0 (method_type_args);
1354 _vala_code_node_unref0 (target_object_type);
1355 return result;
1356 }
1357 _tmp211_ = vala_method_call_get_call (self);
1358 _tmp212_ = _tmp211_;
1359 _tmp213_ = vala_code_context_get_analyzer (context);
1360 _tmp214_ = _tmp213_;
1361 _tmp215_ = _tmp214_->object_type;
1362 _tmp216_ = vala_object_type_new ((ValaObjectTypeSymbol*) _tmp215_);
1363 _tmp217_ = _tmp216_;
1364 vala_expression_set_value_type (_tmp212_, (ValaDataType*) _tmp217_);
1365 _vala_code_node_unref0 (_tmp217_);
1366 _tmp218_ = vala_method_call_get_call (self);
1367 _tmp219_ = _tmp218_;
1368 _tmp220_ = vala_expression_get_value_type (_tmp219_);
1369 _tmp221_ = _tmp220_;
1370 _tmp222_ = _vala_code_node_ref0 (_tmp221_);
1371 _vala_code_node_unref0 (mtype);
1372 mtype = _tmp222_;
1373 }
1374 }
1375 }
1376 }
1377 _tmp224_ = vala_method_call_get_call (self);
1378 _tmp225_ = _tmp224_;
1379 if (VALA_IS_MEMBER_ACCESS (_tmp225_)) {
1380 gboolean _tmp226_ = FALSE;
1381 gboolean _tmp227_ = FALSE;
1382 ValaExpression* _tmp228_;
1383 ValaExpression* _tmp229_;
1384 ValaSymbol* _tmp230_;
1385 ValaSymbol* _tmp231_;
1386 _tmp228_ = vala_method_call_get_call (self);
1387 _tmp229_ = _tmp228_;
1388 _tmp230_ = vala_expression_get_symbol_reference (_tmp229_);
1389 _tmp231_ = _tmp230_;
1390 if (VALA_IS_CREATION_METHOD (_tmp231_)) {
1391 ValaExpression* _tmp232_;
1392 ValaExpression* _tmp233_;
1393 ValaSymbol* _tmp234_;
1394 ValaSymbol* _tmp235_;
1395 ValaSymbol* _tmp236_;
1396 ValaSymbol* _tmp237_;
1397 _tmp232_ = vala_method_call_get_call (self);
1398 _tmp233_ = _tmp232_;
1399 _tmp234_ = vala_expression_get_symbol_reference (_tmp233_);
1400 _tmp235_ = _tmp234_;
1401 _tmp236_ = vala_symbol_get_parent_symbol (_tmp235_);
1402 _tmp237_ = _tmp236_;
1403 _tmp227_ = VALA_IS_STRUCT (_tmp237_);
1404 } else {
1405 _tmp227_ = FALSE;
1406 }
1407 if (_tmp227_) {
1408 _tmp226_ = TRUE;
1409 } else {
1410 ValaExpression* _tmp238_;
1411 ValaExpression* _tmp239_;
1412 ValaSymbol* _tmp240_;
1413 ValaSymbol* _tmp241_;
1414 _tmp238_ = vala_method_call_get_call (self);
1415 _tmp239_ = _tmp238_;
1416 _tmp240_ = vala_expression_get_symbol_reference (_tmp239_);
1417 _tmp241_ = _tmp240_;
1418 _tmp226_ = VALA_IS_STRUCT (_tmp241_);
1419 }
1420 _tmp223_ = _tmp226_;
1421 } else {
1422 _tmp223_ = FALSE;
1423 }
1424 if (_tmp223_) {
1425 ValaStruct* st = NULL;
1426 ValaExpression* _tmp242_;
1427 ValaExpression* _tmp243_;
1428 ValaSymbol* _tmp244_;
1429 ValaSymbol* _tmp245_;
1430 gboolean _tmp246_ = FALSE;
1431 gboolean _tmp247_ = FALSE;
1432 ValaStruct* _tmp248_;
1433 ValaObjectCreationExpression* struct_creation_expression = NULL;
1434 ValaExpression* _tmp259_;
1435 ValaExpression* _tmp260_;
1436 ValaSourceReference* _tmp261_;
1437 ValaSourceReference* _tmp262_;
1438 ValaObjectCreationExpression* _tmp263_;
1439 ValaObjectCreationExpression* _tmp264_;
1440 ValaObjectCreationExpression* _tmp276_;
1441 ValaDataType* _tmp277_;
1442 ValaDataType* _tmp278_;
1443 ValaSemanticAnalyzer* _tmp279_;
1444 ValaSemanticAnalyzer* _tmp280_;
1445 ValaList* _tmp281_;
1446 ValaCodeNode* _tmp282_;
1447 ValaCodeNode* _tmp283_;
1448 ValaObjectCreationExpression* _tmp284_;
1449 ValaObjectCreationExpression* _tmp285_;
1450 _tmp242_ = vala_method_call_get_call (self);
1451 _tmp243_ = _tmp242_;
1452 _tmp244_ = vala_expression_get_symbol_reference (_tmp243_);
1453 _tmp245_ = _tmp244_;
1454 st = VALA_IS_STRUCT (_tmp245_) ? ((ValaStruct*) _tmp245_) : NULL;
1455 _tmp248_ = st;
1456 if (_tmp248_ != NULL) {
1457 ValaStruct* _tmp249_;
1458 ValaCreationMethod* _tmp250_;
1459 ValaCreationMethod* _tmp251_;
1460 _tmp249_ = st;
1461 _tmp250_ = vala_struct_get_default_construction_method (_tmp249_);
1462 _tmp251_ = _tmp250_;
1463 _tmp247_ = _tmp251_ == NULL;
1464 } else {
1465 _tmp247_ = FALSE;
1466 }
1467 if (_tmp247_) {
1468 gboolean _tmp252_ = FALSE;
1469 gboolean _tmp253_ = FALSE;
1470 ValaStruct* _tmp254_;
1471 _tmp254_ = st;
1472 if (vala_struct_is_boolean_type (_tmp254_)) {
1473 _tmp253_ = TRUE;
1474 } else {
1475 ValaStruct* _tmp255_;
1476 _tmp255_ = st;
1477 _tmp253_ = vala_struct_is_integer_type (_tmp255_);
1478 }
1479 if (_tmp253_) {
1480 _tmp252_ = TRUE;
1481 } else {
1482 ValaStruct* _tmp256_;
1483 _tmp256_ = st;
1484 _tmp252_ = vala_struct_is_floating_type (_tmp256_);
1485 }
1486 _tmp246_ = _tmp252_;
1487 } else {
1488 _tmp246_ = FALSE;
1489 }
1490 if (_tmp246_) {
1491 ValaSourceReference* _tmp257_;
1492 ValaSourceReference* _tmp258_;
1493 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
1494 _tmp257_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
1495 _tmp258_ = _tmp257_;
1496 vala_report_error (_tmp258_, "invocation not supported in this context");
1497 result = FALSE;
1498 _vala_code_node_unref0 (mtype);
1499 _vala_iterable_unref0 (method_type_args);
1500 _vala_code_node_unref0 (target_object_type);
1501 return result;
1502 }
1503 _tmp259_ = vala_method_call_get_call (self);
1504 _tmp260_ = _tmp259_;
1505 _tmp261_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
1506 _tmp262_ = _tmp261_;
1507 _tmp263_ = vala_object_creation_expression_new (G_TYPE_CHECK_INSTANCE_CAST (_tmp260_, VALA_TYPE_MEMBER_ACCESS, ValaMemberAccess), _tmp262_);
1508 struct_creation_expression = _tmp263_;
1509 _tmp264_ = struct_creation_expression;
1510 vala_object_creation_expression_set_struct_creation (_tmp264_, TRUE);
1511 {
1512 ValaList* _arg_list = NULL;
1513 ValaList* _tmp265_;
1514 ValaList* _tmp266_;
1515 gint _arg_size = 0;
1516 ValaList* _tmp267_;
1517 gint _tmp268_;
1518 gint _tmp269_;
1519 gint _arg_index = 0;
1520 _tmp265_ = self->priv->argument_list;
1521 _tmp266_ = _vala_iterable_ref0 (_tmp265_);
1522 _arg_list = _tmp266_;
1523 _tmp267_ = _arg_list;
1524 _tmp268_ = vala_collection_get_size ((ValaCollection*) _tmp267_);
1525 _tmp269_ = _tmp268_;
1526 _arg_size = _tmp269_;
1527 _arg_index = -1;
1528 while (TRUE) {
1529 gint _tmp270_;
1530 gint _tmp271_;
1531 ValaExpression* arg = NULL;
1532 ValaList* _tmp272_;
1533 gpointer _tmp273_;
1534 ValaObjectCreationExpression* _tmp274_;
1535 ValaExpression* _tmp275_;
1536 _arg_index = _arg_index + 1;
1537 _tmp270_ = _arg_index;
1538 _tmp271_ = _arg_size;
1539 if (!(_tmp270_ < _tmp271_)) {
1540 break;
1541 }
1542 _tmp272_ = _arg_list;
1543 _tmp273_ = vala_list_get (_tmp272_, _arg_index);
1544 arg = (ValaExpression*) _tmp273_;
1545 _tmp274_ = struct_creation_expression;
1546 _tmp275_ = arg;
1547 vala_object_creation_expression_add_argument (_tmp274_, _tmp275_);
1548 _vala_code_node_unref0 (arg);
1549 }
1550 _vala_iterable_unref0 (_arg_list);
1551 }
1552 _tmp276_ = struct_creation_expression;
1553 _tmp277_ = vala_expression_get_target_type ((ValaExpression*) self);
1554 _tmp278_ = _tmp277_;
1555 vala_expression_set_target_type ((ValaExpression*) _tmp276_, _tmp278_);
1556 _tmp279_ = vala_code_context_get_analyzer (context);
1557 _tmp280_ = _tmp279_;
1558 _tmp281_ = _tmp280_->replaced_nodes;
1559 vala_collection_add ((ValaCollection*) _tmp281_, (ValaCodeNode*) self);
1560 _tmp282_ = vala_code_node_get_parent_node ((ValaCodeNode*) self);
1561 _tmp283_ = _tmp282_;
1562 _tmp284_ = struct_creation_expression;
1563 vala_code_node_replace_expression (_tmp283_, (ValaExpression*) self, (ValaExpression*) _tmp284_);
1564 _tmp285_ = struct_creation_expression;
1565 vala_code_node_check ((ValaCodeNode*) _tmp285_, context);
1566 result = TRUE;
1567 _vala_code_node_unref0 (struct_creation_expression);
1568 _vala_code_node_unref0 (mtype);
1569 _vala_iterable_unref0 (method_type_args);
1570 _vala_code_node_unref0 (target_object_type);
1571 return result;
1572 } else {
1573 gboolean _tmp286_ = FALSE;
1574 gboolean _tmp287_ = FALSE;
1575 gboolean _tmp288_;
1576 _tmp288_ = self->priv->_is_chainup;
1577 if (!_tmp288_) {
1578 ValaExpression* _tmp289_;
1579 ValaExpression* _tmp290_;
1580 _tmp289_ = vala_method_call_get_call (self);
1581 _tmp290_ = _tmp289_;
1582 _tmp287_ = VALA_IS_MEMBER_ACCESS (_tmp290_);
1583 } else {
1584 _tmp287_ = FALSE;
1585 }
1586 if (_tmp287_) {
1587 ValaExpression* _tmp291_;
1588 ValaExpression* _tmp292_;
1589 ValaSymbol* _tmp293_;
1590 ValaSymbol* _tmp294_;
1591 _tmp291_ = vala_method_call_get_call (self);
1592 _tmp292_ = _tmp291_;
1593 _tmp293_ = vala_expression_get_symbol_reference (_tmp292_);
1594 _tmp294_ = _tmp293_;
1595 _tmp286_ = VALA_IS_CREATION_METHOD (_tmp294_);
1596 } else {
1597 _tmp286_ = FALSE;
1598 }
1599 if (_tmp286_) {
1600 ValaSourceReference* _tmp295_;
1601 ValaSourceReference* _tmp296_;
1602 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
1603 _tmp295_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
1604 _tmp296_ = _tmp295_;
1605 vala_report_error (_tmp296_, "use `new' operator to create new objects");
1606 result = FALSE;
1607 _vala_code_node_unref0 (mtype);
1608 _vala_iterable_unref0 (method_type_args);
1609 _vala_code_node_unref0 (target_object_type);
1610 return result;
1611 }
1612 }
1613 _tmp298_ = self->priv->_is_chainup;
1614 if (!_tmp298_) {
1615 ValaDataType* _tmp299_;
1616 _tmp299_ = mtype;
1617 _tmp297_ = VALA_IS_OBJECT_TYPE (_tmp299_);
1618 } else {
1619 _tmp297_ = FALSE;
1620 }
1621 if (_tmp297_) {
1622 ValaSourceReference* _tmp300_;
1623 ValaSourceReference* _tmp301_;
1624 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
1625 _tmp300_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
1626 _tmp301_ = _tmp300_;
1627 vala_report_error (_tmp301_, "invocation not supported in this context");
1628 result = FALSE;
1629 _vala_code_node_unref0 (mtype);
1630 _vala_iterable_unref0 (method_type_args);
1631 _vala_code_node_unref0 (target_object_type);
1632 return result;
1633 } else {
1634 gboolean _tmp302_ = FALSE;
1635 ValaDataType* _tmp303_;
1636 _tmp303_ = mtype;
1637 if (_tmp303_ != NULL) {
1638 ValaDataType* _tmp304_;
1639 _tmp304_ = mtype;
1640 _tmp302_ = vala_data_type_is_invokable (_tmp304_);
1641 } else {
1642 _tmp302_ = FALSE;
1643 }
1644 if (_tmp302_) {
1645 } else {
1646 ValaExpression* _tmp305_;
1647 ValaExpression* _tmp306_;
1648 ValaSymbol* _tmp307_;
1649 ValaSymbol* _tmp308_;
1650 _tmp305_ = vala_method_call_get_call (self);
1651 _tmp306_ = _tmp305_;
1652 _tmp307_ = vala_expression_get_symbol_reference (_tmp306_);
1653 _tmp308_ = _tmp307_;
1654 if (VALA_IS_CLASS (_tmp308_)) {
1655 ValaSourceReference* _tmp309_;
1656 ValaSourceReference* _tmp310_;
1657 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
1658 _tmp309_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
1659 _tmp310_ = _tmp309_;
1660 vala_report_error (_tmp310_, "use `new' operator to create new objects");
1661 result = FALSE;
1662 _vala_code_node_unref0 (mtype);
1663 _vala_iterable_unref0 (method_type_args);
1664 _vala_code_node_unref0 (target_object_type);
1665 return result;
1666 } else {
1667 ValaSourceReference* _tmp311_;
1668 ValaSourceReference* _tmp312_;
1669 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
1670 _tmp311_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
1671 _tmp312_ = _tmp311_;
1672 vala_report_error (_tmp312_, "invocation not supported in this context");
1673 result = FALSE;
1674 _vala_code_node_unref0 (mtype);
1675 _vala_iterable_unref0 (method_type_args);
1676 _vala_code_node_unref0 (target_object_type);
1677 return result;
1678 }
1679 }
1680 }
1681 _tmp313_ = mtype;
1682 _tmp314_ = vala_data_type_get_return_type (_tmp313_);
1683 _tmp315_ = _vala_code_node_ref0 (_tmp314_);
1684 ret_type = _tmp315_;
1685 _tmp316_ = mtype;
1686 _tmp317_ = vala_data_type_get_parameters (_tmp316_);
1687 _tmp318_ = _vala_iterable_ref0 (_tmp317_);
1688 params = _tmp318_;
1689 _tmp319_ = mtype;
1690 if (VALA_IS_METHOD_TYPE (_tmp319_)) {
1691 ValaMemberAccess* ma = NULL;
1692 ValaExpression* _tmp320_;
1693 ValaExpression* _tmp321_;
1694 ValaMethod* m = NULL;
1695 ValaDataType* _tmp322_;
1696 ValaMethod* _tmp323_;
1697 ValaMethod* _tmp324_;
1698 ValaMethod* _tmp325_;
1699 gboolean _tmp326_;
1700 gboolean _tmp327_;
1701 gint n_type_params = 0;
1702 ValaMethod* _tmp358_;
1703 ValaList* _tmp359_;
1704 gint _tmp360_;
1705 gint _tmp361_;
1706 gint n_type_args = 0;
1707 ValaMemberAccess* _tmp362_;
1708 ValaList* _tmp363_;
1709 gint _tmp364_;
1710 gint _tmp365_;
1711 gboolean _tmp366_ = FALSE;
1712 _tmp320_ = vala_method_call_get_call (self);
1713 _tmp321_ = _tmp320_;
1714 ma = G_TYPE_CHECK_INSTANCE_CAST (_tmp321_, VALA_TYPE_MEMBER_ACCESS, ValaMemberAccess);
1715 _tmp322_ = mtype;
1716 _tmp323_ = vala_method_type_get_method_symbol (G_TYPE_CHECK_INSTANCE_CAST (_tmp322_, VALA_TYPE_METHOD_TYPE, ValaMethodType));
1717 _tmp324_ = _tmp323_;
1718 m = _tmp324_;
1719 _tmp325_ = m;
1720 _tmp326_ = vala_method_get_coroutine (_tmp325_);
1721 _tmp327_ = _tmp326_;
1722 if (_tmp327_) {
1723 gboolean _tmp328_;
1724 _tmp328_ = self->priv->_is_yield_expression;
1725 if (!_tmp328_) {
1726 ValaMemberAccess* _tmp329_;
1727 const gchar* _tmp330_;
1728 const gchar* _tmp331_;
1729 _tmp329_ = ma;
1730 _tmp330_ = vala_member_access_get_member_name (_tmp329_);
1731 _tmp331_ = _tmp330_;
1732 if (g_strcmp0 (_tmp331_, "end") != 0) {
1733 ValaMemberAccess* _tmp332_;
1734 const gchar* _tmp333_;
1735 const gchar* _tmp334_;
1736 ValaMethod* _tmp338_;
1737 ValaList* _tmp339_;
1738 ValaVoidType* _tmp340_;
1739 _tmp332_ = ma;
1740 _tmp333_ = vala_member_access_get_member_name (_tmp332_);
1741 _tmp334_ = _tmp333_;
1742 if (g_strcmp0 (_tmp334_, "begin") != 0) {
1743 ValaMemberAccess* _tmp335_;
1744 ValaSourceReference* _tmp336_;
1745 ValaSourceReference* _tmp337_;
1746 _tmp335_ = ma;
1747 _tmp336_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp335_);
1748 _tmp337_ = _tmp336_;
1749 vala_report_deprecated (_tmp337_, "implicit .begin is deprecated");
1750 }
1751 _tmp338_ = m;
1752 _tmp339_ = vala_method_get_async_begin_parameters (_tmp338_);
1753 _vala_iterable_unref0 (params);
1754 params = _tmp339_;
1755 _tmp340_ = vala_void_type_new (NULL);
1756 _vala_code_node_unref0 (ret_type);
1757 ret_type = (ValaDataType*) _tmp340_;
1758 } else {
1759 ValaMethod* _tmp341_;
1760 ValaList* _tmp342_;
1761 _tmp341_ = m;
1762 _tmp342_ = vala_method_get_async_end_parameters (_tmp341_);
1763 _vala_iterable_unref0 (params);
1764 params = _tmp342_;
1765 }
1766 } else {
1767 gboolean _tmp343_ = FALSE;
1768 ValaMemberAccess* _tmp344_;
1769 const gchar* _tmp345_;
1770 const gchar* _tmp346_;
1771 _tmp344_ = ma;
1772 _tmp345_ = vala_member_access_get_member_name (_tmp344_);
1773 _tmp346_ = _tmp345_;
1774 if (g_strcmp0 (_tmp346_, "begin") == 0) {
1775 _tmp343_ = TRUE;
1776 } else {
1777 ValaMemberAccess* _tmp347_;
1778 const gchar* _tmp348_;
1779 const gchar* _tmp349_;
1780 _tmp347_ = ma;
1781 _tmp348_ = vala_member_access_get_member_name (_tmp347_);
1782 _tmp349_ = _tmp348_;
1783 _tmp343_ = g_strcmp0 (_tmp349_, "end") == 0;
1784 }
1785 if (_tmp343_) {
1786 ValaMemberAccess* _tmp350_;
1787 ValaSourceReference* _tmp351_;
1788 ValaSourceReference* _tmp352_;
1789 ValaMemberAccess* _tmp353_;
1790 const gchar* _tmp354_;
1791 const gchar* _tmp355_;
1792 gchar* _tmp356_;
1793 gchar* _tmp357_;
1794 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
1795 _tmp350_ = ma;
1796 _tmp351_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp350_);
1797 _tmp352_ = _tmp351_;
1798 _tmp353_ = ma;
1799 _tmp354_ = vala_member_access_get_member_name (_tmp353_);
1800 _tmp355_ = _tmp354_;
1801 _tmp356_ = g_strdup_printf ("use of `%s' not allowed in yield statement", _tmp355_);
1802 _tmp357_ = _tmp356_;
1803 vala_report_error (_tmp352_, _tmp357_);
1804 _g_free0 (_tmp357_);
1805 }
1806 }
1807 }
1808 _tmp358_ = m;
1809 _tmp359_ = vala_method_get_type_parameters (_tmp358_);
1810 _tmp360_ = vala_collection_get_size ((ValaCollection*) _tmp359_);
1811 _tmp361_ = _tmp360_;
1812 n_type_params = _tmp361_;
1813 _tmp362_ = ma;
1814 _tmp363_ = vala_member_access_get_type_arguments (_tmp362_);
1815 _tmp364_ = vala_collection_get_size ((ValaCollection*) _tmp363_);
1816 _tmp365_ = _tmp364_;
1817 n_type_args = _tmp365_;
1818 if (n_type_args > 0) {
1819 _tmp366_ = n_type_args < n_type_params;
1820 } else {
1821 _tmp366_ = FALSE;
1822 }
1823 if (_tmp366_) {
1824 ValaMemberAccess* _tmp367_;
1825 ValaSourceReference* _tmp368_;
1826 ValaSourceReference* _tmp369_;
1827 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
1828 _tmp367_ = ma;
1829 _tmp368_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp367_);
1830 _tmp369_ = _tmp368_;
1831 vala_report_error (_tmp369_, "too few type arguments");
1832 result = FALSE;
1833 _vala_iterable_unref0 (params);
1834 _vala_code_node_unref0 (ret_type);
1835 _vala_code_node_unref0 (mtype);
1836 _vala_iterable_unref0 (method_type_args);
1837 _vala_code_node_unref0 (target_object_type);
1838 return result;
1839 } else {
1840 gboolean _tmp370_ = FALSE;
1841 if (n_type_args > 0) {
1842 _tmp370_ = n_type_args > n_type_params;
1843 } else {
1844 _tmp370_ = FALSE;
1845 }
1846 if (_tmp370_) {
1847 ValaMemberAccess* _tmp371_;
1848 ValaSourceReference* _tmp372_;
1849 ValaSourceReference* _tmp373_;
1850 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
1851 _tmp371_ = ma;
1852 _tmp372_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp371_);
1853 _tmp373_ = _tmp372_;
1854 vala_report_error (_tmp373_, "too many type arguments");
1855 result = FALSE;
1856 _vala_iterable_unref0 (params);
1857 _vala_code_node_unref0 (ret_type);
1858 _vala_code_node_unref0 (mtype);
1859 _vala_iterable_unref0 (method_type_args);
1860 _vala_code_node_unref0 (target_object_type);
1861 return result;
1862 }
1863 }
1864 }
1865 last_arg = NULL;
1866 _tmp374_ = self->priv->argument_list;
1867 _tmp375_ = vala_iterable_iterator ((ValaIterable*) _tmp374_);
1868 arg_it = _tmp375_;
1869 {
1870 ValaList* _param_list = NULL;
1871 ValaList* _tmp376_;
1872 ValaList* _tmp377_;
1873 gint _param_size = 0;
1874 ValaList* _tmp378_;
1875 gint _tmp379_;
1876 gint _tmp380_;
1877 gint _param_index = 0;
1878 _tmp376_ = params;
1879 _tmp377_ = _vala_iterable_ref0 (_tmp376_);
1880 _param_list = _tmp377_;
1881 _tmp378_ = _param_list;
1882 _tmp379_ = vala_collection_get_size ((ValaCollection*) _tmp378_);
1883 _tmp380_ = _tmp379_;
1884 _param_size = _tmp380_;
1885 _param_index = -1;
1886 while (TRUE) {
1887 gint _tmp381_;
1888 gint _tmp382_;
1889 ValaParameter* param = NULL;
1890 ValaList* _tmp383_;
1891 gpointer _tmp384_;
1892 ValaParameter* _tmp385_;
1893 ValaParameter* _tmp386_;
1894 gboolean _tmp387_;
1895 gboolean _tmp388_;
1896 ValaParameter* _tmp389_;
1897 gboolean _tmp390_;
1898 gboolean _tmp391_;
1899 ValaIterator* _tmp409_;
1900 _param_index = _param_index + 1;
1901 _tmp381_ = _param_index;
1902 _tmp382_ = _param_size;
1903 if (!(_tmp381_ < _tmp382_)) {
1904 break;
1905 }
1906 _tmp383_ = _param_list;
1907 _tmp384_ = vala_list_get (_tmp383_, _param_index);
1908 param = (ValaParameter*) _tmp384_;
1909 _tmp385_ = param;
1910 if (!vala_code_node_check ((ValaCodeNode*) _tmp385_, context)) {
1911 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
1912 }
1913 _tmp386_ = param;
1914 _tmp387_ = vala_parameter_get_ellipsis (_tmp386_);
1915 _tmp388_ = _tmp387_;
1916 if (_tmp388_) {
1917 _vala_code_node_unref0 (param);
1918 break;
1919 }
1920 _tmp389_ = param;
1921 _tmp390_ = vala_parameter_get_params_array (_tmp389_);
1922 _tmp391_ = _tmp390_;
1923 if (_tmp391_) {
1924 ValaArrayType* array_type = NULL;
1925 ValaParameter* _tmp392_;
1926 ValaDataType* _tmp393_;
1927 ValaDataType* _tmp394_;
1928 ValaArrayType* _tmp395_;
1929 _tmp392_ = param;
1930 _tmp393_ = vala_variable_get_variable_type ((ValaVariable*) _tmp392_);
1931 _tmp394_ = _tmp393_;
1932 _tmp395_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp394_, VALA_TYPE_ARRAY_TYPE, ValaArrayType));
1933 array_type = _tmp395_;
1934 while (TRUE) {
1935 ValaIterator* _tmp396_;
1936 ValaExpression* arg = NULL;
1937 ValaIterator* _tmp397_;
1938 gpointer _tmp398_;
1939 ValaExpression* _tmp399_;
1940 ValaArrayType* _tmp400_;
1941 ValaDataType* _tmp401_;
1942 ValaDataType* _tmp402_;
1943 ValaExpression* _tmp403_;
1944 ValaDataType* _tmp404_;
1945 ValaDataType* _tmp405_;
1946 ValaArrayType* _tmp406_;
1947 gboolean _tmp407_;
1948 gboolean _tmp408_;
1949 _tmp396_ = arg_it;
1950 if (!vala_iterator_next (_tmp396_)) {
1951 break;
1952 }
1953 _tmp397_ = arg_it;
1954 _tmp398_ = vala_iterator_get (_tmp397_);
1955 arg = (ValaExpression*) _tmp398_;
1956 _tmp399_ = arg;
1957 _tmp400_ = array_type;
1958 _tmp401_ = vala_array_type_get_element_type (_tmp400_);
1959 _tmp402_ = _tmp401_;
1960 vala_expression_set_target_type (_tmp399_, _tmp402_);
1961 _tmp403_ = arg;
1962 _tmp404_ = vala_expression_get_target_type (_tmp403_);
1963 _tmp405_ = _tmp404_;
1964 _tmp406_ = array_type;
1965 _tmp407_ = vala_data_type_get_value_owned ((ValaDataType*) _tmp406_);
1966 _tmp408_ = _tmp407_;
1967 vala_data_type_set_value_owned (_tmp405_, _tmp408_);
1968 _vala_code_node_unref0 (arg);
1969 }
1970 _vala_code_node_unref0 (array_type);
1971 _vala_code_node_unref0 (param);
1972 break;
1973 }
1974 _tmp409_ = arg_it;
1975 if (vala_iterator_next (_tmp409_)) {
1976 ValaExpression* arg = NULL;
1977 ValaIterator* _tmp410_;
1978 gpointer _tmp411_;
1979 ValaExpression* _tmp412_;
1980 ValaParameter* _tmp413_;
1981 ValaDataType* _tmp414_;
1982 ValaDataType* _tmp415_;
1983 ValaExpression* _tmp416_;
1984 ValaExpression* _tmp417_;
1985 ValaDataType* _tmp418_;
1986 ValaDataType* _tmp419_;
1987 ValaDataType* _tmp420_;
1988 ValaList* _tmp421_;
1989 ValaDataType* _tmp422_;
1990 ValaDataType* _tmp423_;
1991 ValaExpression* _tmp424_;
1992 ValaExpression* _tmp425_;
1993 _tmp410_ = arg_it;
1994 _tmp411_ = vala_iterator_get (_tmp410_);
1995 arg = (ValaExpression*) _tmp411_;
1996 _tmp412_ = arg;
1997 _tmp413_ = param;
1998 _tmp414_ = vala_variable_get_variable_type ((ValaVariable*) _tmp413_);
1999 _tmp415_ = _tmp414_;
2000 vala_expression_set_formal_target_type (_tmp412_, _tmp415_);
2001 _tmp416_ = arg;
2002 _tmp417_ = arg;
2003 _tmp418_ = vala_expression_get_formal_target_type (_tmp417_);
2004 _tmp419_ = _tmp418_;
2005 _tmp420_ = target_object_type;
2006 _tmp421_ = method_type_args;
2007 _tmp422_ = vala_data_type_get_actual_type (_tmp419_, _tmp420_, _tmp421_, (ValaCodeNode*) self);
2008 _tmp423_ = _tmp422_;
2009 vala_expression_set_target_type (_tmp416_, _tmp423_);
2010 _vala_code_node_unref0 (_tmp423_);
2011 _tmp424_ = arg;
2012 _tmp425_ = _vala_code_node_ref0 (_tmp424_);
2013 _vala_code_node_unref0 (last_arg);
2014 last_arg = _tmp425_;
2015 _vala_code_node_unref0 (arg);
2016 }
2017 _vala_code_node_unref0 (param);
2018 }
2019 _vala_iterable_unref0 (_param_list);
2020 }
2021 _tmp427_ = mtype;
2022 if (VALA_IS_METHOD_TYPE (_tmp427_)) {
2023 ValaDataType* _tmp428_;
2024 ValaMethod* _tmp429_;
2025 ValaMethod* _tmp430_;
2026 ValaAttribute* _tmp431_;
2027 _tmp428_ = mtype;
2028 _tmp429_ = vala_method_type_get_method_symbol (G_TYPE_CHECK_INSTANCE_CAST (_tmp428_, VALA_TYPE_METHOD_TYPE, ValaMethodType));
2029 _tmp430_ = _tmp429_;
2030 _tmp431_ = vala_code_node_get_attribute ((ValaCodeNode*) _tmp430_, "Print");
2031 _tmp426_ = _tmp431_ != NULL;
2032 } else {
2033 _tmp426_ = FALSE;
2034 }
2035 if (_tmp426_) {
2036 ValaTemplate* template = NULL;
2037 ValaSourceReference* _tmp432_;
2038 ValaSourceReference* _tmp433_;
2039 ValaTemplate* _tmp434_;
2040 ValaList* _tmp447_;
2041 ValaTemplate* _tmp448_;
2042 _tmp432_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
2043 _tmp433_ = _tmp432_;
2044 _tmp434_ = vala_template_new (_tmp433_);
2045 template = _tmp434_;
2046 {
2047 ValaList* _arg_list = NULL;
2048 ValaList* _tmp435_;
2049 ValaList* _tmp436_;
2050 gint _arg_size = 0;
2051 ValaList* _tmp437_;
2052 gint _tmp438_;
2053 gint _tmp439_;
2054 gint _arg_index = 0;
2055 _tmp435_ = self->priv->argument_list;
2056 _tmp436_ = _vala_iterable_ref0 (_tmp435_);
2057 _arg_list = _tmp436_;
2058 _tmp437_ = _arg_list;
2059 _tmp438_ = vala_collection_get_size ((ValaCollection*) _tmp437_);
2060 _tmp439_ = _tmp438_;
2061 _arg_size = _tmp439_;
2062 _arg_index = -1;
2063 while (TRUE) {
2064 gint _tmp440_;
2065 gint _tmp441_;
2066 ValaExpression* arg = NULL;
2067 ValaList* _tmp442_;
2068 gpointer _tmp443_;
2069 ValaExpression* _tmp444_;
2070 ValaTemplate* _tmp445_;
2071 ValaExpression* _tmp446_;
2072 _arg_index = _arg_index + 1;
2073 _tmp440_ = _arg_index;
2074 _tmp441_ = _arg_size;
2075 if (!(_tmp440_ < _tmp441_)) {
2076 break;
2077 }
2078 _tmp442_ = _arg_list;
2079 _tmp443_ = vala_list_get (_tmp442_, _arg_index);
2080 arg = (ValaExpression*) _tmp443_;
2081 _tmp444_ = arg;
2082 vala_code_node_set_parent_node ((ValaCodeNode*) _tmp444_, NULL);
2083 _tmp445_ = template;
2084 _tmp446_ = arg;
2085 vala_template_add_expression (_tmp445_, _tmp446_);
2086 _vala_code_node_unref0 (arg);
2087 }
2088 _vala_iterable_unref0 (_arg_list);
2089 }
2090 _tmp447_ = self->priv->argument_list;
2091 vala_collection_clear ((ValaCollection*) _tmp447_);
2092 _tmp448_ = template;
2093 vala_method_call_add_argument (self, (ValaExpression*) _tmp448_);
2094 _vala_code_node_unref0 (template);
2095 }
2096 _tmp450_ = mtype;
2097 if (VALA_IS_METHOD_TYPE (_tmp450_)) {
2098 ValaDataType* _tmp451_;
2099 ValaMethod* _tmp452_;
2100 ValaMethod* _tmp453_;
2101 gboolean _tmp454_;
2102 gboolean _tmp455_;
2103 _tmp451_ = mtype;
2104 _tmp452_ = vala_method_type_get_method_symbol (G_TYPE_CHECK_INSTANCE_CAST (_tmp451_, VALA_TYPE_METHOD_TYPE, ValaMethodType));
2105 _tmp453_ = _tmp452_;
2106 _tmp454_ = vala_method_get_printf_format (_tmp453_);
2107 _tmp455_ = _tmp454_;
2108 _tmp449_ = _tmp455_;
2109 } else {
2110 _tmp449_ = FALSE;
2111 }
2112 if (_tmp449_) {
2113 ValaStringLiteral* format_literal = NULL;
2114 ValaExpression* _tmp456_;
2115 ValaStringLiteral* _tmp506_;
2116 format_literal = NULL;
2117 _tmp456_ = last_arg;
2118 if (VALA_IS_NULL_LITERAL (_tmp456_)) {
2119 } else {
2120 ValaExpression* _tmp457_;
2121 _tmp457_ = last_arg;
2122 if (_tmp457_ != NULL) {
2123 ValaExpression* _tmp458_;
2124 ValaStringLiteral* _tmp459_;
2125 gboolean _tmp460_ = FALSE;
2126 ValaStringLiteral* _tmp461_;
2127 _tmp458_ = last_arg;
2128 _tmp459_ = vala_string_literal_get_format_literal (_tmp458_);
2129 _vala_code_node_unref0 (format_literal);
2130 format_literal = _tmp459_;
2131 _tmp461_ = format_literal;
2132 if (_tmp461_ == NULL) {
2133 ValaList* _tmp462_;
2134 gint _tmp463_;
2135 gint _tmp464_;
2136 ValaList* _tmp465_;
2137 gint _tmp466_;
2138 gint _tmp467_;
2139 _tmp462_ = self->priv->argument_list;
2140 _tmp463_ = vala_collection_get_size ((ValaCollection*) _tmp462_);
2141 _tmp464_ = _tmp463_;
2142 _tmp465_ = params;
2143 _tmp466_ = vala_collection_get_size ((ValaCollection*) _tmp465_);
2144 _tmp467_ = _tmp466_;
2145 _tmp460_ = _tmp464_ == (_tmp467_ - 1);
2146 } else {
2147 _tmp460_ = FALSE;
2148 }
2149 if (_tmp460_) {
2150 ValaStringLiteral* _tmp468_;
2151 ValaStringLiteral* _tmp469_;
2152 ValaSemanticAnalyzer* _tmp470_;
2153 ValaSemanticAnalyzer* _tmp471_;
2154 ValaDataType* _tmp472_;
2155 ValaDataType* _tmp473_;
2156 ValaDataType* _tmp474_;
2157 ValaList* _tmp475_;
2158 ValaList* _tmp476_;
2159 gint _tmp477_;
2160 gint _tmp478_;
2161 ValaStringLiteral* _tmp479_;
2162 ValaList* _tmp480_;
2163 ValaIterator* _tmp481_;
2164 _tmp468_ = vala_string_literal_new ("\"%s\"", NULL);
2165 _vala_code_node_unref0 (format_literal);
2166 format_literal = _tmp468_;
2167 _tmp469_ = format_literal;
2168 _tmp470_ = vala_code_context_get_analyzer (context);
2169 _tmp471_ = _tmp470_;
2170 _tmp472_ = _tmp471_->string_type;
2171 _tmp473_ = vala_data_type_copy (_tmp472_);
2172 _tmp474_ = _tmp473_;
2173 vala_expression_set_target_type ((ValaExpression*) _tmp469_, _tmp474_);
2174 _vala_code_node_unref0 (_tmp474_);
2175 _tmp475_ = self->priv->argument_list;
2176 _tmp476_ = self->priv->argument_list;
2177 _tmp477_ = vala_collection_get_size ((ValaCollection*) _tmp476_);
2178 _tmp478_ = _tmp477_;
2179 _tmp479_ = format_literal;
2180 vala_list_insert (_tmp475_, _tmp478_ - 1, (ValaExpression*) _tmp479_);
2181 _tmp480_ = self->priv->argument_list;
2182 _tmp481_ = vala_iterable_iterator ((ValaIterable*) _tmp480_);
2183 _vala_iterator_unref0 (arg_it);
2184 arg_it = _tmp481_;
2185 {
2186 ValaList* _param_list = NULL;
2187 ValaList* _tmp482_;
2188 ValaList* _tmp483_;
2189 gint _param_size = 0;
2190 ValaList* _tmp484_;
2191 gint _tmp485_;
2192 gint _tmp486_;
2193 gint _param_index = 0;
2194 _tmp482_ = params;
2195 _tmp483_ = _vala_iterable_ref0 (_tmp482_);
2196 _param_list = _tmp483_;
2197 _tmp484_ = _param_list;
2198 _tmp485_ = vala_collection_get_size ((ValaCollection*) _tmp484_);
2199 _tmp486_ = _tmp485_;
2200 _param_size = _tmp486_;
2201 _param_index = -1;
2202 while (TRUE) {
2203 gint _tmp487_;
2204 gint _tmp488_;
2205 ValaParameter* param = NULL;
2206 ValaList* _tmp489_;
2207 gpointer _tmp490_;
2208 gboolean _tmp491_ = FALSE;
2209 ValaParameter* _tmp492_;
2210 gboolean _tmp493_;
2211 gboolean _tmp494_;
2212 ValaIterator* _tmp498_;
2213 _param_index = _param_index + 1;
2214 _tmp487_ = _param_index;
2215 _tmp488_ = _param_size;
2216 if (!(_tmp487_ < _tmp488_)) {
2217 break;
2218 }
2219 _tmp489_ = _param_list;
2220 _tmp490_ = vala_list_get (_tmp489_, _param_index);
2221 param = (ValaParameter*) _tmp490_;
2222 _tmp492_ = param;
2223 _tmp493_ = vala_parameter_get_ellipsis (_tmp492_);
2224 _tmp494_ = _tmp493_;
2225 if (_tmp494_) {
2226 _tmp491_ = TRUE;
2227 } else {
2228 ValaParameter* _tmp495_;
2229 gboolean _tmp496_;
2230 gboolean _tmp497_;
2231 _tmp495_ = param;
2232 _tmp496_ = vala_parameter_get_params_array (_tmp495_);
2233 _tmp497_ = _tmp496_;
2234 _tmp491_ = _tmp497_;
2235 }
2236 if (_tmp491_) {
2237 _vala_code_node_unref0 (param);
2238 break;
2239 }
2240 _tmp498_ = arg_it;
2241 vala_iterator_next (_tmp498_);
2242 _vala_code_node_unref0 (param);
2243 }
2244 _vala_iterable_unref0 (_param_list);
2245 }
2246 }
2247 } else {
2248 ValaMemberAccess* ma = NULL;
2249 ValaExpression* _tmp499_;
2250 ValaExpression* _tmp500_;
2251 ValaMemberAccess* _tmp501_;
2252 _tmp499_ = vala_method_call_get_call (self);
2253 _tmp500_ = _tmp499_;
2254 ma = VALA_IS_MEMBER_ACCESS (_tmp500_) ? ((ValaMemberAccess*) _tmp500_) : NULL;
2255 _tmp501_ = ma;
2256 if (_tmp501_ != NULL) {
2257 ValaMemberAccess* _tmp502_;
2258 ValaExpression* _tmp503_;
2259 ValaExpression* _tmp504_;
2260 ValaStringLiteral* _tmp505_;
2261 _tmp502_ = ma;
2262 _tmp503_ = vala_member_access_get_inner (_tmp502_);
2263 _tmp504_ = _tmp503_;
2264 _tmp505_ = vala_string_literal_get_format_literal (_tmp504_);
2265 _vala_code_node_unref0 (format_literal);
2266 format_literal = _tmp505_;
2267 }
2268 }
2269 }
2270 _tmp506_ = format_literal;
2271 if (_tmp506_ != NULL) {
2272 gchar* format = NULL;
2273 ValaStringLiteral* _tmp507_;
2274 gchar* _tmp508_;
2275 ValaSemanticAnalyzer* _tmp509_;
2276 ValaSemanticAnalyzer* _tmp510_;
2277 const gchar* _tmp511_;
2278 ValaIterator* _tmp512_;
2279 ValaSourceReference* _tmp513_;
2280 ValaSourceReference* _tmp514_;
2281 _tmp507_ = format_literal;
2282 _tmp508_ = vala_string_literal_eval (_tmp507_);
2283 format = _tmp508_;
2284 _tmp509_ = vala_code_context_get_analyzer (context);
2285 _tmp510_ = _tmp509_;
2286 _tmp511_ = format;
2287 _tmp512_ = arg_it;
2288 _tmp513_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
2289 _tmp514_ = _tmp513_;
2290 if (!vala_semantic_analyzer_check_print_format (_tmp510_, _tmp511_, _tmp512_, _tmp514_)) {
2291 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
2292 result = FALSE;
2293 _g_free0 (format);
2294 _vala_code_node_unref0 (format_literal);
2295 _vala_iterator_unref0 (arg_it);
2296 _vala_code_node_unref0 (last_arg);
2297 _vala_iterable_unref0 (params);
2298 _vala_code_node_unref0 (ret_type);
2299 _vala_code_node_unref0 (mtype);
2300 _vala_iterable_unref0 (method_type_args);
2301 _vala_code_node_unref0 (target_object_type);
2302 return result;
2303 }
2304 _g_free0 (format);
2305 }
2306 _vala_code_node_unref0 (format_literal);
2307 }
2308 force_lambda_method_closure = FALSE;
2309 {
2310 ValaList* _arg_list = NULL;
2311 ValaList* _tmp515_;
2312 ValaList* _tmp516_;
2313 gint _arg_size = 0;
2314 ValaList* _tmp517_;
2315 gint _tmp518_;
2316 gint _tmp519_;
2317 gint _arg_index = 0;
2318 _tmp515_ = self->priv->argument_list;
2319 _tmp516_ = _vala_iterable_ref0 (_tmp515_);
2320 _arg_list = _tmp516_;
2321 _tmp517_ = _arg_list;
2322 _tmp518_ = vala_collection_get_size ((ValaCollection*) _tmp517_);
2323 _tmp519_ = _tmp518_;
2324 _arg_size = _tmp519_;
2325 _arg_index = -1;
2326 while (TRUE) {
2327 gint _tmp520_;
2328 gint _tmp521_;
2329 ValaExpression* arg = NULL;
2330 ValaList* _tmp522_;
2331 gpointer _tmp523_;
2332 ValaExpression* _tmp524_;
2333 gboolean _tmp525_ = FALSE;
2334 ValaExpression* _tmp526_;
2335 _arg_index = _arg_index + 1;
2336 _tmp520_ = _arg_index;
2337 _tmp521_ = _arg_size;
2338 if (!(_tmp520_ < _tmp521_)) {
2339 break;
2340 }
2341 _tmp522_ = _arg_list;
2342 _tmp523_ = vala_list_get (_tmp522_, _arg_index);
2343 arg = (ValaExpression*) _tmp523_;
2344 _tmp524_ = arg;
2345 if (!vala_code_node_check ((ValaCodeNode*) _tmp524_, context)) {
2346 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
2347 _vala_code_node_unref0 (arg);
2348 continue;
2349 }
2350 _tmp526_ = arg;
2351 if (VALA_IS_LAMBDA_EXPRESSION (_tmp526_)) {
2352 ValaExpression* _tmp527_;
2353 ValaMethod* _tmp528_;
2354 ValaMethod* _tmp529_;
2355 gboolean _tmp530_;
2356 gboolean _tmp531_;
2357 _tmp527_ = arg;
2358 _tmp528_ = vala_lambda_expression_get_method (G_TYPE_CHECK_INSTANCE_CAST (_tmp527_, VALA_TYPE_LAMBDA_EXPRESSION, ValaLambdaExpression));
2359 _tmp529_ = _tmp528_;
2360 _tmp530_ = vala_method_get_closure (_tmp529_);
2361 _tmp531_ = _tmp530_;
2362 _tmp525_ = _tmp531_;
2363 } else {
2364 _tmp525_ = FALSE;
2365 }
2366 if (_tmp525_) {
2367 force_lambda_method_closure = TRUE;
2368 }
2369 _vala_code_node_unref0 (arg);
2370 }
2371 _vala_iterable_unref0 (_arg_list);
2372 }
2373 _tmp533_ = vala_code_node_get_error ((ValaCodeNode*) self);
2374 _tmp534_ = _tmp533_;
2375 if (!_tmp534_) {
2376 _tmp532_ = force_lambda_method_closure;
2377 } else {
2378 _tmp532_ = FALSE;
2379 }
2380 if (_tmp532_) {
2381 {
2382 ValaList* _arg_list = NULL;
2383 ValaList* _tmp535_;
2384 ValaList* _tmp536_;
2385 gint _arg_size = 0;
2386 ValaList* _tmp537_;
2387 gint _tmp538_;
2388 gint _tmp539_;
2389 gint _arg_index = 0;
2390 _tmp535_ = self->priv->argument_list;
2391 _tmp536_ = _vala_iterable_ref0 (_tmp535_);
2392 _arg_list = _tmp536_;
2393 _tmp537_ = _arg_list;
2394 _tmp538_ = vala_collection_get_size ((ValaCollection*) _tmp537_);
2395 _tmp539_ = _tmp538_;
2396 _arg_size = _tmp539_;
2397 _arg_index = -1;
2398 while (TRUE) {
2399 gint _tmp540_;
2400 gint _tmp541_;
2401 ValaExpression* arg = NULL;
2402 ValaList* _tmp542_;
2403 gpointer _tmp543_;
2404 ValaLambdaExpression* lambda = NULL;
2405 ValaExpression* _tmp544_;
2406 gboolean _tmp545_ = FALSE;
2407 ValaLambdaExpression* _tmp546_;
2408 _arg_index = _arg_index + 1;
2409 _tmp540_ = _arg_index;
2410 _tmp541_ = _arg_size;
2411 if (!(_tmp540_ < _tmp541_)) {
2412 break;
2413 }
2414 _tmp542_ = _arg_list;
2415 _tmp543_ = vala_list_get (_tmp542_, _arg_index);
2416 arg = (ValaExpression*) _tmp543_;
2417 _tmp544_ = arg;
2418 lambda = VALA_IS_LAMBDA_EXPRESSION (_tmp544_) ? ((ValaLambdaExpression*) _tmp544_) : NULL;
2419 _tmp546_ = lambda;
2420 if (_tmp546_ != NULL) {
2421 ValaLambdaExpression* _tmp547_;
2422 ValaMethod* _tmp548_;
2423 ValaMethod* _tmp549_;
2424 ValaMemberBinding _tmp550_;
2425 ValaMemberBinding _tmp551_;
2426 _tmp547_ = lambda;
2427 _tmp548_ = vala_lambda_expression_get_method (_tmp547_);
2428 _tmp549_ = _tmp548_;
2429 _tmp550_ = vala_method_get_binding (_tmp549_);
2430 _tmp551_ = _tmp550_;
2431 _tmp545_ = _tmp551_ != VALA_MEMBER_BINDING_STATIC;
2432 } else {
2433 _tmp545_ = FALSE;
2434 }
2435 if (_tmp545_) {
2436 ValaLambdaExpression* _tmp552_;
2437 ValaMethod* _tmp553_;
2438 ValaMethod* _tmp554_;
2439 _tmp552_ = lambda;
2440 _tmp553_ = vala_lambda_expression_get_method (_tmp552_);
2441 _tmp554_ = _tmp553_;
2442 vala_method_set_closure (_tmp554_, TRUE);
2443 }
2444 _vala_code_node_unref0 (arg);
2445 }
2446 _vala_iterable_unref0 (_arg_list);
2447 }
2448 }
2449 _tmp555_ = ret_type;
2450 if (VALA_IS_VOID_TYPE (_tmp555_)) {
2451 gboolean _tmp556_ = FALSE;
2452 gboolean _tmp557_ = FALSE;
2453 ValaCodeNode* _tmp558_;
2454 ValaCodeNode* _tmp559_;
2455 _tmp558_ = vala_code_node_get_parent_node ((ValaCodeNode*) self);
2456 _tmp559_ = _tmp558_;
2457 if (!VALA_IS_EXPRESSION_STATEMENT (_tmp559_)) {
2458 ValaCodeNode* _tmp560_;
2459 ValaCodeNode* _tmp561_;
2460 _tmp560_ = vala_code_node_get_parent_node ((ValaCodeNode*) self);
2461 _tmp561_ = _tmp560_;
2462 _tmp557_ = !VALA_IS_FOR_STATEMENT (_tmp561_);
2463 } else {
2464 _tmp557_ = FALSE;
2465 }
2466 if (_tmp557_) {
2467 ValaCodeNode* _tmp562_;
2468 ValaCodeNode* _tmp563_;
2469 _tmp562_ = vala_code_node_get_parent_node ((ValaCodeNode*) self);
2470 _tmp563_ = _tmp562_;
2471 _tmp556_ = !VALA_IS_YIELD_STATEMENT (_tmp563_);
2472 } else {
2473 _tmp556_ = FALSE;
2474 }
2475 if (_tmp556_) {
2476 ValaSourceReference* _tmp564_;
2477 ValaSourceReference* _tmp565_;
2478 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
2479 _tmp564_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
2480 _tmp565_ = _tmp564_;
2481 vala_report_error (_tmp565_, "invocation of void method not allowed as expression");
2482 result = FALSE;
2483 _vala_iterator_unref0 (arg_it);
2484 _vala_code_node_unref0 (last_arg);
2485 _vala_iterable_unref0 (params);
2486 _vala_code_node_unref0 (ret_type);
2487 _vala_code_node_unref0 (mtype);
2488 _vala_iterable_unref0 (method_type_args);
2489 _vala_code_node_unref0 (target_object_type);
2490 return result;
2491 }
2492 }
2493 _tmp566_ = ret_type;
2494 _tmp567_ = vala_data_type_copy (_tmp566_);
2495 _tmp568_ = _tmp567_;
2496 vala_expression_set_formal_value_type ((ValaExpression*) self, _tmp568_);
2497 _vala_code_node_unref0 (_tmp568_);
2498 _tmp569_ = vala_expression_get_formal_value_type ((ValaExpression*) self);
2499 _tmp570_ = _tmp569_;
2500 _tmp571_ = target_object_type;
2501 _tmp572_ = method_type_args;
2502 _tmp573_ = vala_data_type_get_actual_type (_tmp570_, _tmp571_, _tmp572_, (ValaCodeNode*) self);
2503 _tmp574_ = _tmp573_;
2504 vala_expression_set_value_type ((ValaExpression*) self, _tmp574_);
2505 _vala_code_node_unref0 (_tmp574_);
2506 _tmp575_ = self->priv->_is_yield_expression;
2507 if (_tmp575_) {
2508 gboolean _tmp576_ = FALSE;
2509 ValaDataType* _tmp577_;
2510 gboolean _tmp585_ = FALSE;
2511 ValaSemanticAnalyzer* _tmp586_;
2512 ValaSemanticAnalyzer* _tmp587_;
2513 ValaMethod* _tmp588_;
2514 ValaMethod* _tmp589_;
2515 _tmp577_ = mtype;
2516 if (!VALA_IS_METHOD_TYPE (_tmp577_)) {
2517 _tmp576_ = TRUE;
2518 } else {
2519 ValaDataType* _tmp578_;
2520 ValaMethod* _tmp579_;
2521 ValaMethod* _tmp580_;
2522 gboolean _tmp581_;
2523 gboolean _tmp582_;
2524 _tmp578_ = mtype;
2525 _tmp579_ = vala_method_type_get_method_symbol (G_TYPE_CHECK_INSTANCE_CAST (_tmp578_, VALA_TYPE_METHOD_TYPE, ValaMethodType));
2526 _tmp580_ = _tmp579_;
2527 _tmp581_ = vala_method_get_coroutine (_tmp580_);
2528 _tmp582_ = _tmp581_;
2529 _tmp576_ = !_tmp582_;
2530 }
2531 if (_tmp576_) {
2532 ValaSourceReference* _tmp583_;
2533 ValaSourceReference* _tmp584_;
2534 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
2535 _tmp583_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
2536 _tmp584_ = _tmp583_;
2537 vala_report_error (_tmp584_, "yield expression requires async method");
2538 }
2539 _tmp586_ = vala_code_context_get_analyzer (context);
2540 _tmp587_ = _tmp586_;
2541 _tmp588_ = vala_semantic_analyzer_get_current_method (_tmp587_);
2542 _tmp589_ = _tmp588_;
2543 if (_tmp589_ == NULL) {
2544 _tmp585_ = TRUE;
2545 } else {
2546 ValaSemanticAnalyzer* _tmp590_;
2547 ValaSemanticAnalyzer* _tmp591_;
2548 ValaMethod* _tmp592_;
2549 ValaMethod* _tmp593_;
2550 gboolean _tmp594_;
2551 gboolean _tmp595_;
2552 _tmp590_ = vala_code_context_get_analyzer (context);
2553 _tmp591_ = _tmp590_;
2554 _tmp592_ = vala_semantic_analyzer_get_current_method (_tmp591_);
2555 _tmp593_ = _tmp592_;
2556 _tmp594_ = vala_method_get_coroutine (_tmp593_);
2557 _tmp595_ = _tmp594_;
2558 _tmp585_ = !_tmp595_;
2559 }
2560 if (_tmp585_) {
2561 ValaSourceReference* _tmp596_;
2562 ValaSourceReference* _tmp597_;
2563 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
2564 _tmp596_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
2565 _tmp597_ = _tmp596_;
2566 vala_report_error (_tmp597_, "yield expression not available outside async method");
2567 }
2568 }
2569 _tmp598_ = mtype;
2570 if (VALA_IS_METHOD_TYPE (_tmp598_)) {
2571 ValaMethod* m = NULL;
2572 ValaDataType* _tmp599_;
2573 ValaMethod* _tmp600_;
2574 ValaMethod* _tmp601_;
2575 ValaMethod* _tmp602_;
2576 gboolean _tmp603_;
2577 gboolean _tmp604_;
2578 ValaMethod* _tmp607_;
2579 gboolean _tmp608_;
2580 gboolean _tmp609_;
2581 gboolean _tmp637_ = FALSE;
2582 gboolean _tmp638_ = FALSE;
2583 gboolean _tmp639_ = FALSE;
2584 gboolean _tmp640_;
2585 gboolean _tmp641_;
2586 ValaSignal* sig = NULL;
2587 ValaMethod* _tmp653_;
2588 ValaSymbol* _tmp654_;
2589 ValaSymbol* _tmp655_;
2590 gboolean _tmp656_ = FALSE;
2591 ValaSignal* _tmp657_;
2592 ValaDynamicSignal* dynamic_sig = NULL;
2593 ValaMethod* _tmp670_;
2594 ValaSymbol* _tmp671_;
2595 ValaSymbol* _tmp672_;
2596 gboolean _tmp673_ = FALSE;
2597 ValaDynamicSignal* _tmp674_;
2598 gboolean _tmp718_ = FALSE;
2599 ValaMethod* _tmp719_;
2600 gboolean _tmp832_ = FALSE;
2601 ValaMethod* _tmp833_;
2602 _tmp599_ = mtype;
2603 _tmp600_ = vala_method_type_get_method_symbol (G_TYPE_CHECK_INSTANCE_CAST (_tmp599_, VALA_TYPE_METHOD_TYPE, ValaMethodType));
2604 _tmp601_ = _tmp600_;
2605 m = _tmp601_;
2606 _tmp602_ = m;
2607 _tmp603_ = vala_method_get_returns_floating_reference (_tmp602_);
2608 _tmp604_ = _tmp603_;
2609 if (_tmp604_) {
2610 ValaDataType* _tmp605_;
2611 ValaDataType* _tmp606_;
2612 _tmp605_ = vala_expression_get_value_type ((ValaExpression*) self);
2613 _tmp606_ = _tmp605_;
2614 vala_data_type_set_floating_reference (_tmp606_, TRUE);
2615 }
2616 _tmp607_ = m;
2617 _tmp608_ = vala_method_get_returns_modified_pointer (_tmp607_);
2618 _tmp609_ = _tmp608_;
2619 if (_tmp609_) {
2620 ValaExpression* inner = NULL;
2621 ValaExpression* _tmp610_;
2622 ValaExpression* _tmp611_;
2623 ValaExpression* _tmp612_;
2624 ValaExpression* _tmp613_;
2625 ValaExpression* _tmp614_;
2626 ValaProperty* prop = NULL;
2627 ValaExpression* _tmp615_;
2628 ValaSymbol* _tmp616_;
2629 ValaSymbol* _tmp617_;
2630 gboolean _tmp618_ = FALSE;
2631 ValaProperty* _tmp619_;
2632 _tmp610_ = vala_method_call_get_call (self);
2633 _tmp611_ = _tmp610_;
2634 _tmp612_ = vala_member_access_get_inner (G_TYPE_CHECK_INSTANCE_CAST (_tmp611_, VALA_TYPE_MEMBER_ACCESS, ValaMemberAccess));
2635 _tmp613_ = _tmp612_;
2636 inner = _tmp613_;
2637 _tmp614_ = inner;
2638 vala_expression_set_lvalue (_tmp614_, TRUE);
2639 _tmp615_ = inner;
2640 _tmp616_ = vala_expression_get_symbol_reference (_tmp615_);
2641 _tmp617_ = _tmp616_;
2642 prop = VALA_IS_PROPERTY (_tmp617_) ? ((ValaProperty*) _tmp617_) : NULL;
2643 _tmp619_ = prop;
2644 if (_tmp619_ != NULL) {
2645 gboolean _tmp620_ = FALSE;
2646 ValaProperty* _tmp621_;
2647 ValaPropertyAccessor* _tmp622_;
2648 ValaPropertyAccessor* _tmp623_;
2649 _tmp621_ = prop;
2650 _tmp622_ = vala_property_get_set_accessor (_tmp621_);
2651 _tmp623_ = _tmp622_;
2652 if (_tmp623_ == NULL) {
2653 _tmp620_ = TRUE;
2654 } else {
2655 ValaProperty* _tmp624_;
2656 ValaPropertyAccessor* _tmp625_;
2657 ValaPropertyAccessor* _tmp626_;
2658 gboolean _tmp627_;
2659 gboolean _tmp628_;
2660 _tmp624_ = prop;
2661 _tmp625_ = vala_property_get_set_accessor (_tmp624_);
2662 _tmp626_ = _tmp625_;
2663 _tmp627_ = vala_property_accessor_get_writable (_tmp626_);
2664 _tmp628_ = _tmp627_;
2665 _tmp620_ = !_tmp628_;
2666 }
2667 _tmp618_ = _tmp620_;
2668 } else {
2669 _tmp618_ = FALSE;
2670 }
2671 if (_tmp618_) {
2672 ValaExpression* _tmp629_;
2673 ValaSourceReference* _tmp630_;
2674 ValaSourceReference* _tmp631_;
2675 ValaProperty* _tmp632_;
2676 gchar* _tmp633_;
2677 gchar* _tmp634_;
2678 gchar* _tmp635_;
2679 gchar* _tmp636_;
2680 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
2681 _tmp629_ = inner;
2682 _tmp630_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp629_);
2683 _tmp631_ = _tmp630_;
2684 _tmp632_ = prop;
2685 _tmp633_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp632_);
2686 _tmp634_ = _tmp633_;
2687 _tmp635_ = g_strdup_printf ("Property `%s' is read-only", _tmp634_);
2688 _tmp636_ = _tmp635_;
2689 vala_report_error (_tmp631_, _tmp636_);
2690 _g_free0 (_tmp636_);
2691 _g_free0 (_tmp634_);
2692 }
2693 }
2694 _tmp640_ = vala_code_node_get_tree_can_fail ((ValaCodeNode*) self);
2695 _tmp641_ = _tmp640_;
2696 if (_tmp641_) {
2697 ValaDataType* _tmp642_;
2698 ValaDataType* _tmp643_;
2699 gboolean _tmp644_;
2700 gboolean _tmp645_;
2701 _tmp642_ = vala_expression_get_value_type ((ValaExpression*) self);
2702 _tmp643_ = _tmp642_;
2703 _tmp644_ = vala_data_type_get_nullable (_tmp643_);
2704 _tmp645_ = _tmp644_;
2705 _tmp639_ = !_tmp645_;
2706 } else {
2707 _tmp639_ = FALSE;
2708 }
2709 if (_tmp639_) {
2710 ValaDataType* _tmp646_;
2711 ValaDataType* _tmp647_;
2712 gboolean _tmp648_;
2713 gboolean _tmp649_;
2714 _tmp646_ = vala_expression_get_value_type ((ValaExpression*) self);
2715 _tmp647_ = _tmp646_;
2716 _tmp648_ = vala_data_type_get_floating_reference (_tmp647_);
2717 _tmp649_ = _tmp648_;
2718 _tmp638_ = _tmp649_;
2719 } else {
2720 _tmp638_ = FALSE;
2721 }
2722 if (_tmp638_) {
2723 ValaDataType* _tmp650_;
2724 _tmp650_ = ret_type;
2725 _tmp637_ = VALA_IS_OBJECT_TYPE (_tmp650_);
2726 } else {
2727 _tmp637_ = FALSE;
2728 }
2729 if (_tmp637_) {
2730 ValaDataType* _tmp651_;
2731 ValaDataType* _tmp652_;
2732 _tmp651_ = vala_expression_get_value_type ((ValaExpression*) self);
2733 _tmp652_ = _tmp651_;
2734 vala_data_type_set_nullable (_tmp652_, TRUE);
2735 }
2736 _tmp653_ = m;
2737 _tmp654_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp653_);
2738 _tmp655_ = _tmp654_;
2739 sig = VALA_IS_SIGNAL (_tmp655_) ? ((ValaSignal*) _tmp655_) : NULL;
2740 _tmp657_ = sig;
2741 if (_tmp657_ != NULL) {
2742 ValaMethod* _tmp658_;
2743 const gchar* _tmp659_;
2744 const gchar* _tmp660_;
2745 _tmp658_ = m;
2746 _tmp659_ = vala_symbol_get_name ((ValaSymbol*) _tmp658_);
2747 _tmp660_ = _tmp659_;
2748 _tmp656_ = g_strcmp0 (_tmp660_, "disconnect") == 0;
2749 } else {
2750 _tmp656_ = FALSE;
2751 }
2752 if (_tmp656_) {
2753 gboolean _tmp661_ = FALSE;
2754 ValaList* _tmp662_;
2755 gboolean _tmp663_;
2756 gboolean _tmp664_;
2757 _tmp662_ = self->priv->argument_list;
2758 _tmp663_ = vala_collection_get_is_empty ((ValaCollection*) _tmp662_);
2759 _tmp664_ = _tmp663_;
2760 if (!_tmp664_) {
2761 ValaList* _tmp665_;
2762 gpointer _tmp666_;
2763 ValaExpression* _tmp667_;
2764 _tmp665_ = self->priv->argument_list;
2765 _tmp666_ = vala_list_get (_tmp665_, 0);
2766 _tmp667_ = (ValaExpression*) _tmp666_;
2767 _tmp661_ = VALA_IS_LAMBDA_EXPRESSION (_tmp667_);
2768 _vala_code_node_unref0 (_tmp667_);
2769 } else {
2770 _tmp661_ = FALSE;
2771 }
2772 if (_tmp661_) {
2773 ValaSourceReference* _tmp668_;
2774 ValaSourceReference* _tmp669_;
2775 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
2776 _tmp668_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
2777 _tmp669_ = _tmp668_;
2778 vala_report_error (_tmp669_, "Cannot disconnect lambda expression from signal");
2779 result = FALSE;
2780 _vala_iterator_unref0 (arg_it);
2781 _vala_code_node_unref0 (last_arg);
2782 _vala_iterable_unref0 (params);
2783 _vala_code_node_unref0 (ret_type);
2784 _vala_code_node_unref0 (mtype);
2785 _vala_iterable_unref0 (method_type_args);
2786 _vala_code_node_unref0 (target_object_type);
2787 return result;
2788 }
2789 }
2790 _tmp670_ = m;
2791 _tmp671_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp670_);
2792 _tmp672_ = _tmp671_;
2793 dynamic_sig = VALA_IS_DYNAMIC_SIGNAL (_tmp672_) ? ((ValaDynamicSignal*) _tmp672_) : NULL;
2794 _tmp674_ = dynamic_sig;
2795 if (_tmp674_ != NULL) {
2796 ValaDynamicSignal* _tmp675_;
2797 ValaExpression* _tmp676_;
2798 ValaExpression* _tmp677_;
2799 _tmp675_ = dynamic_sig;
2800 _tmp676_ = vala_dynamic_signal_get_handler (_tmp675_);
2801 _tmp677_ = _tmp676_;
2802 _tmp673_ = _tmp677_ != NULL;
2803 } else {
2804 _tmp673_ = FALSE;
2805 }
2806 if (_tmp673_) {
2807 ValaDynamicSignal* _tmp678_;
2808 ValaDynamicSignal* _tmp679_;
2809 ValaExpression* _tmp680_;
2810 ValaExpression* _tmp681_;
2811 ValaDataType* _tmp682_;
2812 ValaDataType* _tmp683_;
2813 ValaDataType* _tmp684_;
2814 ValaDataType* _tmp685_;
2815 ValaDataType* _tmp686_;
2816 gboolean first = FALSE;
2817 ValaDynamicSignal* _tmp705_;
2818 ValaExpression* _tmp706_;
2819 ValaExpression* _tmp707_;
2820 ValaDynamicSignal* _tmp708_;
2821 ValaDynamicSignal* _tmp709_;
2822 ValaSymbol* _tmp710_;
2823 ValaSymbol* _tmp711_;
2824 ValaObjectType* _tmp712_;
2825 ValaObjectType* _tmp713_;
2826 ValaDelegate* _tmp714_;
2827 ValaDelegate* _tmp715_;
2828 ValaDelegateType* _tmp716_;
2829 ValaDelegateType* _tmp717_;
2830 _tmp678_ = dynamic_sig;
2831 _tmp679_ = dynamic_sig;
2832 _tmp680_ = vala_dynamic_signal_get_handler (_tmp679_);
2833 _tmp681_ = _tmp680_;
2834 _tmp682_ = vala_expression_get_value_type (_tmp681_);
2835 _tmp683_ = _tmp682_;
2836 _tmp684_ = vala_data_type_get_return_type (_tmp683_);
2837 _tmp685_ = vala_data_type_copy (_tmp684_);
2838 _tmp686_ = _tmp685_;
2839 vala_callable_set_return_type ((ValaCallable*) _tmp678_, _tmp686_);
2840 _vala_code_node_unref0 (_tmp686_);
2841 first = TRUE;
2842 {
2843 ValaList* _param_list = NULL;
2844 ValaDynamicSignal* _tmp687_;
2845 ValaExpression* _tmp688_;
2846 ValaExpression* _tmp689_;
2847 ValaDataType* _tmp690_;
2848 ValaDataType* _tmp691_;
2849 ValaList* _tmp692_;
2850 ValaList* _tmp693_;
2851 gint _param_size = 0;
2852 ValaList* _tmp694_;
2853 gint _tmp695_;
2854 gint _tmp696_;
2855 gint _param_index = 0;
2856 _tmp687_ = dynamic_sig;
2857 _tmp688_ = vala_dynamic_signal_get_handler (_tmp687_);
2858 _tmp689_ = _tmp688_;
2859 _tmp690_ = vala_expression_get_value_type (_tmp689_);
2860 _tmp691_ = _tmp690_;
2861 _tmp692_ = vala_data_type_get_parameters (_tmp691_);
2862 _tmp693_ = _vala_iterable_ref0 (_tmp692_);
2863 _param_list = _tmp693_;
2864 _tmp694_ = _param_list;
2865 _tmp695_ = vala_collection_get_size ((ValaCollection*) _tmp694_);
2866 _tmp696_ = _tmp695_;
2867 _param_size = _tmp696_;
2868 _param_index = -1;
2869 while (TRUE) {
2870 gint _tmp697_;
2871 gint _tmp698_;
2872 ValaParameter* param = NULL;
2873 ValaList* _tmp699_;
2874 gpointer _tmp700_;
2875 _param_index = _param_index + 1;
2876 _tmp697_ = _param_index;
2877 _tmp698_ = _param_size;
2878 if (!(_tmp697_ < _tmp698_)) {
2879 break;
2880 }
2881 _tmp699_ = _param_list;
2882 _tmp700_ = vala_list_get (_tmp699_, _param_index);
2883 param = (ValaParameter*) _tmp700_;
2884 if (first) {
2885 first = FALSE;
2886 } else {
2887 ValaDynamicSignal* _tmp701_;
2888 ValaParameter* _tmp702_;
2889 ValaParameter* _tmp703_;
2890 ValaParameter* _tmp704_;
2891 _tmp701_ = dynamic_sig;
2892 _tmp702_ = param;
2893 _tmp703_ = vala_parameter_copy (_tmp702_);
2894 _tmp704_ = _tmp703_;
2895 vala_callable_add_parameter ((ValaCallable*) _tmp701_, _tmp704_);
2896 _vala_code_node_unref0 (_tmp704_);
2897 }
2898 _vala_code_node_unref0 (param);
2899 }
2900 _vala_iterable_unref0 (_param_list);
2901 }
2902 _tmp705_ = dynamic_sig;
2903 _tmp706_ = vala_dynamic_signal_get_handler (_tmp705_);
2904 _tmp707_ = _tmp706_;
2905 _tmp708_ = dynamic_sig;
2906 _tmp709_ = dynamic_sig;
2907 _tmp710_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp709_);
2908 _tmp711_ = _tmp710_;
2909 _tmp712_ = vala_object_type_new (G_TYPE_CHECK_INSTANCE_CAST (_tmp711_, VALA_TYPE_OBJECT_TYPE_SYMBOL, ValaObjectTypeSymbol));
2910 _tmp713_ = _tmp712_;
2911 _tmp714_ = vala_signal_get_delegate ((ValaSignal*) _tmp708_, (ValaDataType*) _tmp713_, (ValaCodeNode*) self);
2912 _tmp715_ = _tmp714_;
2913 _tmp716_ = vala_delegate_type_new (_tmp715_);
2914 _tmp717_ = _tmp716_;
2915 vala_expression_set_target_type (_tmp707_, (ValaDataType*) _tmp717_);
2916 _vala_code_node_unref0 (_tmp717_);
2917 _vala_code_node_unref0 (_tmp715_);
2918 _vala_code_node_unref0 (_tmp713_);
2919 }
2920 _tmp719_ = m;
2921 if (_tmp719_ != NULL) {
2922 ValaMethod* _tmp720_;
2923 _tmp720_ = m;
2924 _tmp718_ = vala_method_has_type_parameters (_tmp720_);
2925 } else {
2926 _tmp718_ = FALSE;
2927 }
2928 if (_tmp718_) {
2929 ValaMemberAccess* ma = NULL;
2930 ValaExpression* _tmp721_;
2931 ValaExpression* _tmp722_;
2932 ValaMemberAccess* _tmp723_;
2933 ValaList* _tmp724_;
2934 gint _tmp725_;
2935 gint _tmp726_;
2936 _tmp721_ = vala_method_call_get_call (self);
2937 _tmp722_ = _tmp721_;
2938 ma = G_TYPE_CHECK_INSTANCE_CAST (_tmp722_, VALA_TYPE_MEMBER_ACCESS, ValaMemberAccess);
2939 _tmp723_ = ma;
2940 _tmp724_ = vala_member_access_get_type_arguments (_tmp723_);
2941 _tmp725_ = vala_collection_get_size ((ValaCollection*) _tmp724_);
2942 _tmp726_ = _tmp725_;
2943 if (_tmp726_ == 0) {
2944 ValaList* _tmp797_;
2945 ValaIterator* _tmp798_;
2946 ValaDataType* _tmp826_;
2947 ValaDataType* _tmp827_;
2948 ValaDataType* _tmp828_;
2949 ValaList* _tmp829_;
2950 ValaDataType* _tmp830_;
2951 ValaDataType* _tmp831_;
2952 {
2953 ValaList* _type_param_list = NULL;
2954 ValaMethod* _tmp727_;
2955 ValaList* _tmp728_;
2956 ValaList* _tmp729_;
2957 gint _type_param_size = 0;
2958 ValaList* _tmp730_;
2959 gint _tmp731_;
2960 gint _tmp732_;
2961 gint _type_param_index = 0;
2962 _tmp727_ = m;
2963 _tmp728_ = vala_method_get_type_parameters (_tmp727_);
2964 _tmp729_ = _vala_iterable_ref0 (_tmp728_);
2965 _type_param_list = _tmp729_;
2966 _tmp730_ = _type_param_list;
2967 _tmp731_ = vala_collection_get_size ((ValaCollection*) _tmp730_);
2968 _tmp732_ = _tmp731_;
2969 _type_param_size = _tmp732_;
2970 _type_param_index = -1;
2971 while (TRUE) {
2972 gint _tmp733_;
2973 gint _tmp734_;
2974 ValaTypeParameter* type_param = NULL;
2975 ValaList* _tmp735_;
2976 gpointer _tmp736_;
2977 ValaDataType* type_arg = NULL;
2978 ValaList* _tmp737_;
2979 ValaIterator* _tmp738_;
2980 gboolean _tmp775_ = FALSE;
2981 ValaDataType* _tmp776_;
2982 ValaDataType* _tmp786_;
2983 ValaMemberAccess* _tmp795_;
2984 ValaDataType* _tmp796_;
2985 _type_param_index = _type_param_index + 1;
2986 _tmp733_ = _type_param_index;
2987 _tmp734_ = _type_param_size;
2988 if (!(_tmp733_ < _tmp734_)) {
2989 break;
2990 }
2991 _tmp735_ = _type_param_list;
2992 _tmp736_ = vala_list_get (_tmp735_, _type_param_index);
2993 type_param = (ValaTypeParameter*) _tmp736_;
2994 type_arg = NULL;
2995 _tmp737_ = self->priv->argument_list;
2996 _tmp738_ = vala_iterable_iterator ((ValaIterable*) _tmp737_);
2997 _vala_iterator_unref0 (arg_it);
2998 arg_it = _tmp738_;
2999 {
3000 ValaList* _param_list = NULL;
3001 ValaList* _tmp739_;
3002 ValaList* _tmp740_;
3003 gint _param_size = 0;
3004 ValaList* _tmp741_;
3005 gint _tmp742_;
3006 gint _tmp743_;
3007 gint _param_index = 0;
3008 _tmp739_ = params;
3009 _tmp740_ = _vala_iterable_ref0 (_tmp739_);
3010 _param_list = _tmp740_;
3011 _tmp741_ = _param_list;
3012 _tmp742_ = vala_collection_get_size ((ValaCollection*) _tmp741_);
3013 _tmp743_ = _tmp742_;
3014 _param_size = _tmp743_;
3015 _param_index = -1;
3016 while (TRUE) {
3017 gint _tmp744_;
3018 gint _tmp745_;
3019 ValaParameter* param = NULL;
3020 ValaList* _tmp746_;
3021 gpointer _tmp747_;
3022 gboolean _tmp748_ = FALSE;
3023 ValaParameter* _tmp749_;
3024 gboolean _tmp750_;
3025 gboolean _tmp751_;
3026 ValaIterator* _tmp755_;
3027 _param_index = _param_index + 1;
3028 _tmp744_ = _param_index;
3029 _tmp745_ = _param_size;
3030 if (!(_tmp744_ < _tmp745_)) {
3031 break;
3032 }
3033 _tmp746_ = _param_list;
3034 _tmp747_ = vala_list_get (_tmp746_, _param_index);
3035 param = (ValaParameter*) _tmp747_;
3036 _tmp749_ = param;
3037 _tmp750_ = vala_parameter_get_ellipsis (_tmp749_);
3038 _tmp751_ = _tmp750_;
3039 if (_tmp751_) {
3040 _tmp748_ = TRUE;
3041 } else {
3042 ValaParameter* _tmp752_;
3043 gboolean _tmp753_;
3044 gboolean _tmp754_;
3045 _tmp752_ = param;
3046 _tmp753_ = vala_parameter_get_params_array (_tmp752_);
3047 _tmp754_ = _tmp753_;
3048 _tmp748_ = _tmp754_;
3049 }
3050 if (_tmp748_) {
3051 _vala_code_node_unref0 (param);
3052 break;
3053 }
3054 _tmp755_ = arg_it;
3055 if (vala_iterator_next (_tmp755_)) {
3056 ValaExpression* arg = NULL;
3057 ValaIterator* _tmp756_;
3058 gpointer _tmp757_;
3059 ValaParameter* _tmp758_;
3060 ValaDataType* _tmp759_;
3061 ValaDataType* _tmp760_;
3062 ValaTypeParameter* _tmp761_;
3063 ValaExpression* _tmp762_;
3064 ValaDataType* _tmp763_;
3065 ValaDataType* _tmp764_;
3066 ValaDataType* _tmp765_;
3067 ValaDataType* _tmp766_;
3068 ValaExpression* _tmp767_;
3069 ValaExpression* _tmp768_;
3070 ValaDataType* _tmp769_;
3071 ValaDataType* _tmp770_;
3072 ValaDataType* _tmp771_;
3073 ValaList* _tmp772_;
3074 ValaDataType* _tmp773_;
3075 ValaDataType* _tmp774_;
3076 _tmp756_ = arg_it;
3077 _tmp757_ = vala_iterator_get (_tmp756_);
3078 arg = (ValaExpression*) _tmp757_;
3079 _tmp758_ = param;
3080 _tmp759_ = vala_variable_get_variable_type ((ValaVariable*) _tmp758_);
3081 _tmp760_ = _tmp759_;
3082 _tmp761_ = type_param;
3083 _tmp762_ = arg;
3084 _tmp763_ = vala_expression_get_value_type (_tmp762_);
3085 _tmp764_ = _tmp763_;
3086 _tmp765_ = vala_data_type_infer_type_argument (_tmp760_, _tmp761_, _tmp764_);
3087 _vala_code_node_unref0 (type_arg);
3088 type_arg = _tmp765_;
3089 _tmp766_ = type_arg;
3090 if (_tmp766_ != NULL) {
3091 _vala_code_node_unref0 (arg);
3092 _vala_code_node_unref0 (param);
3093 break;
3094 }
3095 _tmp767_ = arg;
3096 _tmp768_ = arg;
3097 _tmp769_ = vala_expression_get_formal_target_type (_tmp768_);
3098 _tmp770_ = _tmp769_;
3099 _tmp771_ = target_object_type;
3100 _tmp772_ = method_type_args;
3101 _tmp773_ = vala_data_type_get_actual_type (_tmp770_, _tmp771_, _tmp772_, (ValaCodeNode*) self);
3102 _tmp774_ = _tmp773_;
3103 vala_expression_set_target_type (_tmp767_, _tmp774_);
3104 _vala_code_node_unref0 (_tmp774_);
3105 _vala_code_node_unref0 (arg);
3106 }
3107 _vala_code_node_unref0 (param);
3108 }
3109 _vala_iterable_unref0 (_param_list);
3110 }
3111 _tmp776_ = type_arg;
3112 if (_tmp776_ == NULL) {
3113 ValaDataType* _tmp777_;
3114 ValaDataType* _tmp778_;
3115 _tmp777_ = vala_expression_get_target_type ((ValaExpression*) self);
3116 _tmp778_ = _tmp777_;
3117 _tmp775_ = _tmp778_ != NULL;
3118 } else {
3119 _tmp775_ = FALSE;
3120 }
3121 if (_tmp775_) {
3122 ValaMethod* _tmp779_;
3123 ValaDataType* _tmp780_;
3124 ValaDataType* _tmp781_;
3125 ValaTypeParameter* _tmp782_;
3126 ValaDataType* _tmp783_;
3127 ValaDataType* _tmp784_;
3128 ValaDataType* _tmp785_;
3129 _tmp779_ = m;
3130 _tmp780_ = vala_callable_get_return_type ((ValaCallable*) _tmp779_);
3131 _tmp781_ = _tmp780_;
3132 _tmp782_ = type_param;
3133 _tmp783_ = vala_expression_get_target_type ((ValaExpression*) self);
3134 _tmp784_ = _tmp783_;
3135 _tmp785_ = vala_data_type_infer_type_argument (_tmp781_, _tmp782_, _tmp784_);
3136 _vala_code_node_unref0 (type_arg);
3137 type_arg = _tmp785_;
3138 }
3139 _tmp786_ = type_arg;
3140 if (_tmp786_ == NULL) {
3141 ValaMemberAccess* _tmp787_;
3142 ValaSourceReference* _tmp788_;
3143 ValaSourceReference* _tmp789_;
3144 ValaTypeParameter* _tmp790_;
3145 gchar* _tmp791_;
3146 gchar* _tmp792_;
3147 gchar* _tmp793_;
3148 gchar* _tmp794_;
3149 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
3150 _tmp787_ = ma;
3151 _tmp788_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp787_);
3152 _tmp789_ = _tmp788_;
3153 _tmp790_ = type_param;
3154 _tmp791_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp790_);
3155 _tmp792_ = _tmp791_;
3156 _tmp793_ = g_strdup_printf ("cannot infer generic type argument for type parameter `%s'", _tmp792_);
3157 _tmp794_ = _tmp793_;
3158 vala_report_error (_tmp789_, _tmp794_);
3159 _g_free0 (_tmp794_);
3160 _g_free0 (_tmp792_);
3161 result = FALSE;
3162 _vala_code_node_unref0 (type_arg);
3163 _vala_code_node_unref0 (type_param);
3164 _vala_iterable_unref0 (_type_param_list);
3165 _vala_iterator_unref0 (arg_it);
3166 _vala_code_node_unref0 (last_arg);
3167 _vala_iterable_unref0 (params);
3168 _vala_code_node_unref0 (ret_type);
3169 _vala_code_node_unref0 (mtype);
3170 _vala_iterable_unref0 (method_type_args);
3171 _vala_code_node_unref0 (target_object_type);
3172 return result;
3173 }
3174 _tmp795_ = ma;
3175 _tmp796_ = type_arg;
3176 vala_member_access_add_type_argument (_tmp795_, _tmp796_);
3177 _vala_code_node_unref0 (type_arg);
3178 _vala_code_node_unref0 (type_param);
3179 }
3180 _vala_iterable_unref0 (_type_param_list);
3181 }
3182 _tmp797_ = self->priv->argument_list;
3183 _tmp798_ = vala_iterable_iterator ((ValaIterable*) _tmp797_);
3184 _vala_iterator_unref0 (arg_it);
3185 arg_it = _tmp798_;
3186 {
3187 ValaList* _param_list = NULL;
3188 ValaList* _tmp799_;
3189 ValaList* _tmp800_;
3190 gint _param_size = 0;
3191 ValaList* _tmp801_;
3192 gint _tmp802_;
3193 gint _tmp803_;
3194 gint _param_index = 0;
3195 _tmp799_ = params;
3196 _tmp800_ = _vala_iterable_ref0 (_tmp799_);
3197 _param_list = _tmp800_;
3198 _tmp801_ = _param_list;
3199 _tmp802_ = vala_collection_get_size ((ValaCollection*) _tmp801_);
3200 _tmp803_ = _tmp802_;
3201 _param_size = _tmp803_;
3202 _param_index = -1;
3203 while (TRUE) {
3204 gint _tmp804_;
3205 gint _tmp805_;
3206 ValaParameter* param = NULL;
3207 ValaList* _tmp806_;
3208 gpointer _tmp807_;
3209 gboolean _tmp808_ = FALSE;
3210 ValaParameter* _tmp809_;
3211 gboolean _tmp810_;
3212 gboolean _tmp811_;
3213 ValaIterator* _tmp815_;
3214 _param_index = _param_index + 1;
3215 _tmp804_ = _param_index;
3216 _tmp805_ = _param_size;
3217 if (!(_tmp804_ < _tmp805_)) {
3218 break;
3219 }
3220 _tmp806_ = _param_list;
3221 _tmp807_ = vala_list_get (_tmp806_, _param_index);
3222 param = (ValaParameter*) _tmp807_;
3223 _tmp809_ = param;
3224 _tmp810_ = vala_parameter_get_ellipsis (_tmp809_);
3225 _tmp811_ = _tmp810_;
3226 if (_tmp811_) {
3227 _tmp808_ = TRUE;
3228 } else {
3229 ValaParameter* _tmp812_;
3230 gboolean _tmp813_;
3231 gboolean _tmp814_;
3232 _tmp812_ = param;
3233 _tmp813_ = vala_parameter_get_params_array (_tmp812_);
3234 _tmp814_ = _tmp813_;
3235 _tmp808_ = _tmp814_;
3236 }
3237 if (_tmp808_) {
3238 _vala_code_node_unref0 (param);
3239 break;
3240 }
3241 _tmp815_ = arg_it;
3242 if (vala_iterator_next (_tmp815_)) {
3243 ValaExpression* arg = NULL;
3244 ValaIterator* _tmp816_;
3245 gpointer _tmp817_;
3246 ValaExpression* _tmp818_;
3247 ValaExpression* _tmp819_;
3248 ValaDataType* _tmp820_;
3249 ValaDataType* _tmp821_;
3250 ValaDataType* _tmp822_;
3251 ValaList* _tmp823_;
3252 ValaDataType* _tmp824_;
3253 ValaDataType* _tmp825_;
3254 _tmp816_ = arg_it;
3255 _tmp817_ = vala_iterator_get (_tmp816_);
3256 arg = (ValaExpression*) _tmp817_;
3257 _tmp818_ = arg;
3258 _tmp819_ = arg;
3259 _tmp820_ = vala_expression_get_formal_target_type (_tmp819_);
3260 _tmp821_ = _tmp820_;
3261 _tmp822_ = target_object_type;
3262 _tmp823_ = method_type_args;
3263 _tmp824_ = vala_data_type_get_actual_type (_tmp821_, _tmp822_, _tmp823_, (ValaCodeNode*) self);
3264 _tmp825_ = _tmp824_;
3265 vala_expression_set_target_type (_tmp818_, _tmp825_);
3266 _vala_code_node_unref0 (_tmp825_);
3267 _vala_code_node_unref0 (arg);
3268 }
3269 _vala_code_node_unref0 (param);
3270 }
3271 _vala_iterable_unref0 (_param_list);
3272 }
3273 _tmp826_ = vala_expression_get_formal_value_type ((ValaExpression*) self);
3274 _tmp827_ = _tmp826_;
3275 _tmp828_ = target_object_type;
3276 _tmp829_ = method_type_args;
3277 _tmp830_ = vala_data_type_get_actual_type (_tmp827_, _tmp828_, _tmp829_, (ValaCodeNode*) self);
3278 _tmp831_ = _tmp830_;
3279 vala_expression_set_value_type ((ValaExpression*) self, _tmp831_);
3280 _vala_code_node_unref0 (_tmp831_);
3281 }
3282 }
3283 _tmp833_ = m;
3284 if (_tmp833_ != NULL) {
3285 ValaMethod* _tmp834_;
3286 gboolean _tmp835_;
3287 gboolean _tmp836_;
3288 _tmp834_ = m;
3289 _tmp835_ = vala_method_get_coroutine (_tmp834_);
3290 _tmp836_ = _tmp835_;
3291 _tmp832_ = _tmp836_;
3292 } else {
3293 _tmp832_ = FALSE;
3294 }
3295 if (_tmp832_) {
3296 ValaMemberAccess* ma = NULL;
3297 ValaExpression* _tmp837_;
3298 ValaExpression* _tmp838_;
3299 ValaMemberAccess* _tmp839_;
3300 const gchar* _tmp840_;
3301 const gchar* _tmp841_;
3302 _tmp837_ = vala_method_call_get_call (self);
3303 _tmp838_ = _tmp837_;
3304 ma = G_TYPE_CHECK_INSTANCE_CAST (_tmp838_, VALA_TYPE_MEMBER_ACCESS, ValaMemberAccess);
3305 _tmp839_ = ma;
3306 _tmp840_ = vala_member_access_get_member_name (_tmp839_);
3307 _tmp841_ = _tmp840_;
3308 if (g_strcmp0 (_tmp841_, "end") == 0) {
3309 ValaMethod* _tmp842_;
3310 ValaMethod* _tmp843_;
3311 ValaMethodType* _tmp844_;
3312 _tmp842_ = m;
3313 _tmp843_ = vala_method_get_end_method (_tmp842_);
3314 _tmp844_ = vala_method_type_new (_tmp843_);
3315 _vala_code_node_unref0 (mtype);
3316 mtype = (ValaDataType*) _tmp844_;
3317 }
3318 }
3319 }
3320 _tmp845_ = vala_code_context_get_analyzer (context);
3321 _tmp846_ = _tmp845_;
3322 _tmp847_ = mtype;
3323 _tmp848_ = params;
3324 _tmp849_ = self->priv->argument_list;
3325 if (!vala_semantic_analyzer_check_arguments (_tmp846_, (ValaExpression*) self, _tmp847_, _tmp848_, _tmp849_)) {
3326 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
3327 result = FALSE;
3328 _vala_iterator_unref0 (arg_it);
3329 _vala_code_node_unref0 (last_arg);
3330 _vala_iterable_unref0 (params);
3331 _vala_code_node_unref0 (ret_type);
3332 _vala_code_node_unref0 (mtype);
3333 _vala_iterable_unref0 (method_type_args);
3334 _vala_code_node_unref0 (target_object_type);
3335 return result;
3336 }
3337 {
3338 ValaList* _arg_list = NULL;
3339 ValaList* _tmp850_;
3340 ValaList* _tmp851_;
3341 gint _arg_size = 0;
3342 ValaList* _tmp852_;
3343 gint _tmp853_;
3344 gint _tmp854_;
3345 gint _arg_index = 0;
3346 _tmp850_ = self->priv->argument_list;
3347 _tmp851_ = _vala_iterable_ref0 (_tmp850_);
3348 _arg_list = _tmp851_;
3349 _tmp852_ = _arg_list;
3350 _tmp853_ = vala_collection_get_size ((ValaCollection*) _tmp852_);
3351 _tmp854_ = _tmp853_;
3352 _arg_size = _tmp854_;
3353 _arg_index = -1;
3354 while (TRUE) {
3355 gint _tmp855_;
3356 gint _tmp856_;
3357 ValaExpression* arg = NULL;
3358 ValaList* _tmp857_;
3359 gpointer _tmp858_;
3360 ValaSizeofExpression* sizeof_expr = NULL;
3361 ValaExpression* _tmp859_;
3362 gboolean _tmp860_ = FALSE;
3363 ValaSizeofExpression* _tmp861_;
3364 _arg_index = _arg_index + 1;
3365 _tmp855_ = _arg_index;
3366 _tmp856_ = _arg_size;
3367 if (!(_tmp855_ < _tmp856_)) {
3368 break;
3369 }
3370 _tmp857_ = _arg_list;
3371 _tmp858_ = vala_list_get (_tmp857_, _arg_index);
3372 arg = (ValaExpression*) _tmp858_;
3373 _tmp859_ = arg;
3374 sizeof_expr = VALA_IS_SIZEOF_EXPRESSION (_tmp859_) ? ((ValaSizeofExpression*) _tmp859_) : NULL;
3375 _tmp861_ = sizeof_expr;
3376 if (_tmp861_ != NULL) {
3377 ValaSizeofExpression* _tmp862_;
3378 ValaDataType* _tmp863_;
3379 ValaDataType* _tmp864_;
3380 _tmp862_ = sizeof_expr;
3381 _tmp863_ = vala_sizeof_expression_get_type_reference (_tmp862_);
3382 _tmp864_ = _tmp863_;
3383 _tmp860_ = VALA_IS_GENERIC_TYPE (_tmp864_);
3384 } else {
3385 _tmp860_ = FALSE;
3386 }
3387 if (_tmp860_) {
3388 ValaDataType* sizeof_type = NULL;
3389 ValaSizeofExpression* _tmp865_;
3390 ValaDataType* _tmp866_;
3391 ValaDataType* _tmp867_;
3392 ValaDataType* _tmp868_;
3393 ValaList* _tmp869_;
3394 ValaDataType* _tmp870_;
3395 ValaExpression* _tmp871_;
3396 ValaDataType* _tmp872_;
3397 ValaSourceReference* _tmp873_;
3398 ValaSourceReference* _tmp874_;
3399 ValaSizeofExpression* _tmp875_;
3400 ValaSizeofExpression* _tmp876_;
3401 _tmp865_ = sizeof_expr;
3402 _tmp866_ = vala_sizeof_expression_get_type_reference (_tmp865_);
3403 _tmp867_ = _tmp866_;
3404 _tmp868_ = target_object_type;
3405 _tmp869_ = method_type_args;
3406 _tmp870_ = vala_data_type_get_actual_type (_tmp867_, _tmp868_, _tmp869_, (ValaCodeNode*) self);
3407 sizeof_type = _tmp870_;
3408 _tmp871_ = arg;
3409 _tmp872_ = sizeof_type;
3410 _tmp873_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
3411 _tmp874_ = _tmp873_;
3412 _tmp875_ = vala_sizeof_expression_new (_tmp872_, _tmp874_);
3413 _tmp876_ = _tmp875_;
3414 vala_code_node_replace_expression ((ValaCodeNode*) self, _tmp871_, (ValaExpression*) _tmp876_);
3415 _vala_code_node_unref0 (_tmp876_);
3416 _vala_code_node_unref0 (sizeof_type);
3417 }
3418 _vala_code_node_unref0 (arg);
3419 }
3420 _vala_iterable_unref0 (_arg_list);
3421 }
3422 _tmp879_ = base_cm;
3423 if (_tmp879_ != NULL) {
3424 ValaCreationMethod* _tmp880_;
3425 _tmp880_ = base_cm;
3426 _tmp878_ = vala_method_is_variadic ((ValaMethod*) _tmp880_);
3427 } else {
3428 _tmp878_ = FALSE;
3429 }
3430 if (_tmp878_) {
3431 ValaList* _tmp881_;
3432 gint _tmp882_;
3433 gint _tmp883_;
3434 ValaCreationMethod* _tmp884_;
3435 ValaList* _tmp885_;
3436 gint _tmp886_;
3437 gint _tmp887_;
3438 _tmp881_ = self->priv->argument_list;
3439 _tmp882_ = vala_collection_get_size ((ValaCollection*) _tmp881_);
3440 _tmp883_ = _tmp882_;
3441 _tmp884_ = base_cm;
3442 _tmp885_ = vala_callable_get_parameters ((ValaCallable*) _tmp884_);
3443 _tmp886_ = vala_collection_get_size ((ValaCollection*) _tmp885_);
3444 _tmp887_ = _tmp886_;
3445 _tmp877_ = _tmp883_ == _tmp887_;
3446 } else {
3447 _tmp877_ = FALSE;
3448 }
3449 if (_tmp877_) {
3450 ValaExpression* this_last_arg = NULL;
3451 ValaList* _tmp888_;
3452 ValaList* _tmp889_;
3453 gint _tmp890_;
3454 gint _tmp891_;
3455 gpointer _tmp892_;
3456 gboolean _tmp893_ = FALSE;
3457 ValaExpression* _tmp894_;
3458 ValaDataType* _tmp895_;
3459 ValaDataType* _tmp896_;
3460 _tmp888_ = self->priv->argument_list;
3461 _tmp889_ = self->priv->argument_list;
3462 _tmp890_ = vala_collection_get_size ((ValaCollection*) _tmp889_);
3463 _tmp891_ = _tmp890_;
3464 _tmp892_ = vala_list_get (_tmp888_, _tmp891_ - 1);
3465 this_last_arg = (ValaExpression*) _tmp892_;
3466 _tmp894_ = this_last_arg;
3467 _tmp895_ = vala_expression_get_value_type (_tmp894_);
3468 _tmp896_ = _tmp895_;
3469 if (VALA_IS_STRUCT_VALUE_TYPE (_tmp896_)) {
3470 ValaExpression* _tmp897_;
3471 ValaDataType* _tmp898_;
3472 ValaDataType* _tmp899_;
3473 ValaTypeSymbol* _tmp900_;
3474 ValaTypeSymbol* _tmp901_;
3475 ValaSemanticAnalyzer* _tmp902_;
3476 ValaSemanticAnalyzer* _tmp903_;
3477 ValaDataType* _tmp904_;
3478 ValaTypeSymbol* _tmp905_;
3479 ValaTypeSymbol* _tmp906_;
3480 _tmp897_ = this_last_arg;
3481 _tmp898_ = vala_expression_get_value_type (_tmp897_);
3482 _tmp899_ = _tmp898_;
3483 _tmp900_ = vala_data_type_get_type_symbol (_tmp899_);
3484 _tmp901_ = _tmp900_;
3485 _tmp902_ = vala_code_context_get_analyzer (context);
3486 _tmp903_ = _tmp902_;
3487 _tmp904_ = _tmp903_->va_list_type;
3488 _tmp905_ = vala_data_type_get_type_symbol (_tmp904_);
3489 _tmp906_ = _tmp905_;
3490 _tmp893_ = _tmp901_ == _tmp906_;
3491 } else {
3492 _tmp893_ = FALSE;
3493 }
3494 if (_tmp893_) {
3495 vala_method_call_set_is_constructv_chainup (self, TRUE);
3496 }
3497 _vala_code_node_unref0 (this_last_arg);
3498 }
3499 _tmp907_ = vala_expression_get_value_type ((ValaExpression*) self);
3500 _tmp908_ = _tmp907_;
3501 vala_code_node_check ((ValaCodeNode*) _tmp908_, context);
3502 _tmp909_ = vala_code_node_get_tree_can_fail ((ValaCodeNode*) self);
3503 _tmp910_ = _tmp909_;
3504 if (_tmp910_) {
3505 gboolean _tmp911_ = FALSE;
3506 ValaCodeNode* _tmp912_;
3507 ValaCodeNode* _tmp913_;
3508 _tmp912_ = vala_code_node_get_parent_node ((ValaCodeNode*) self);
3509 _tmp913_ = _tmp912_;
3510 if (VALA_IS_LOCAL_VARIABLE (_tmp913_)) {
3511 _tmp911_ = TRUE;
3512 } else {
3513 ValaCodeNode* _tmp914_;
3514 ValaCodeNode* _tmp915_;
3515 _tmp914_ = vala_code_node_get_parent_node ((ValaCodeNode*) self);
3516 _tmp915_ = _tmp914_;
3517 _tmp911_ = VALA_IS_EXPRESSION_STATEMENT (_tmp915_);
3518 }
3519 if (_tmp911_) {
3520 } else {
3521 ValaSemanticAnalyzer* _tmp916_;
3522 ValaSemanticAnalyzer* _tmp917_;
3523 ValaSymbol* _tmp918_;
3524 ValaSymbol* _tmp919_;
3525 _tmp916_ = vala_code_context_get_analyzer (context);
3526 _tmp917_ = _tmp916_;
3527 _tmp918_ = vala_semantic_analyzer_get_current_symbol (_tmp917_);
3528 _tmp919_ = _tmp918_;
3529 if (!VALA_IS_BLOCK (_tmp919_)) {
3530 ValaSourceReference* _tmp920_;
3531 ValaSourceReference* _tmp921_;
3532 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
3533 _tmp920_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
3534 _tmp921_ = _tmp920_;
3535 vala_report_error (_tmp921_, "Field initializers must not throw errors");
3536 } else {
3537 ValaCodeNode* old_parent_node = NULL;
3538 ValaCodeNode* _tmp922_;
3539 ValaCodeNode* _tmp923_;
3540 ValaCodeNode* _tmp924_;
3541 ValaLocalVariable* local = NULL;
3542 ValaDataType* _tmp925_;
3543 ValaDataType* _tmp926_;
3544 ValaDataType* _tmp927_;
3545 ValaDataType* _tmp928_;
3546 gchar* _tmp929_;
3547 gchar* _tmp930_;
3548 ValaSourceReference* _tmp931_;
3549 ValaSourceReference* _tmp932_;
3550 ValaLocalVariable* _tmp933_;
3551 ValaLocalVariable* _tmp934_;
3552 ValaDeclarationStatement* decl = NULL;
3553 ValaLocalVariable* _tmp935_;
3554 ValaSourceReference* _tmp936_;
3555 ValaSourceReference* _tmp937_;
3556 ValaDeclarationStatement* _tmp938_;
3557 ValaDataType* _tmp939_;
3558 ValaDataType* _tmp940_;
3559 ValaSemanticAnalyzer* _tmp944_;
3560 ValaSemanticAnalyzer* _tmp945_;
3561 ValaBlock* _tmp946_;
3562 ValaDeclarationStatement* _tmp947_;
3563 ValaExpression* temp_access = NULL;
3564 ValaLocalVariable* _tmp948_;
3565 ValaDataType* _tmp949_;
3566 ValaDataType* _tmp950_;
3567 ValaExpression* _tmp951_;
3568 ValaExpression* _tmp952_;
3569 ValaDataType* _tmp953_;
3570 ValaDataType* _tmp954_;
3571 ValaLocalVariable* _tmp955_;
3572 ValaDeclarationStatement* _tmp956_;
3573 ValaBlock* block = NULL;
3574 ValaSemanticAnalyzer* _tmp957_;
3575 ValaSemanticAnalyzer* _tmp958_;
3576 ValaSymbol* _tmp959_;
3577 ValaSymbol* _tmp960_;
3578 ValaBlock* _tmp961_;
3579 ValaBlock* _tmp962_;
3580 ValaLocalVariable* _tmp963_;
3581 ValaSemanticAnalyzer* _tmp964_;
3582 ValaSemanticAnalyzer* _tmp965_;
3583 ValaBlock* _tmp966_;
3584 ValaLocalVariable* _tmp967_;
3585 ValaCodeNode* _tmp968_;
3586 ValaExpression* _tmp969_;
3587 ValaExpression* _tmp970_;
3588 _tmp922_ = vala_code_node_get_parent_node ((ValaCodeNode*) self);
3589 _tmp923_ = _tmp922_;
3590 _tmp924_ = _vala_code_node_ref0 (_tmp923_);
3591 old_parent_node = _tmp924_;
3592 _tmp925_ = vala_expression_get_value_type ((ValaExpression*) self);
3593 _tmp926_ = _tmp925_;
3594 _tmp927_ = vala_data_type_copy (_tmp926_);
3595 _tmp928_ = _tmp927_;
3596 _tmp929_ = vala_code_node_get_temp_name ();
3597 _tmp930_ = _tmp929_;
3598 _tmp931_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
3599 _tmp932_ = _tmp931_;
3600 _tmp933_ = vala_local_variable_new (_tmp928_, _tmp930_, NULL, _tmp932_);
3601 _tmp934_ = _tmp933_;
3602 _g_free0 (_tmp930_);
3603 _vala_code_node_unref0 (_tmp928_);
3604 local = _tmp934_;
3605 _tmp935_ = local;
3606 _tmp936_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
3607 _tmp937_ = _tmp936_;
3608 _tmp938_ = vala_declaration_statement_new ((ValaSymbol*) _tmp935_, _tmp937_);
3609 decl = _tmp938_;
3610 _tmp939_ = vala_expression_get_target_type ((ValaExpression*) self);
3611 _tmp940_ = _tmp939_;
3612 if (_tmp940_ == NULL) {
3613 ValaLocalVariable* _tmp941_;
3614 ValaDataType* _tmp942_;
3615 ValaDataType* _tmp943_;
3616 _tmp941_ = local;
3617 _tmp942_ = vala_variable_get_variable_type ((ValaVariable*) _tmp941_);
3618 _tmp943_ = _tmp942_;
3619 vala_data_type_set_floating_reference (_tmp943_, FALSE);
3620 }
3621 _tmp944_ = vala_code_context_get_analyzer (context);
3622 _tmp945_ = _tmp944_;
3623 _tmp946_ = _tmp945_->insert_block;
3624 _tmp947_ = decl;
3625 vala_expression_insert_statement ((ValaExpression*) self, _tmp946_, (ValaStatement*) _tmp947_);
3626 _tmp948_ = local;
3627 _tmp949_ = vala_expression_get_target_type ((ValaExpression*) self);
3628 _tmp950_ = _tmp949_;
3629 _tmp951_ = vala_semantic_analyzer_create_temp_access (_tmp948_, _tmp950_);
3630 temp_access = _tmp951_;
3631 _tmp952_ = temp_access;
3632 _tmp953_ = vala_expression_get_formal_target_type ((ValaExpression*) self);
3633 _tmp954_ = _tmp953_;
3634 vala_expression_set_formal_target_type (_tmp952_, _tmp954_);
3635 _tmp955_ = local;
3636 vala_variable_set_initializer ((ValaVariable*) _tmp955_, (ValaExpression*) self);
3637 _tmp956_ = decl;
3638 vala_code_node_check ((ValaCodeNode*) _tmp956_, context);
3639 _tmp957_ = vala_code_context_get_analyzer (context);
3640 _tmp958_ = _tmp957_;
3641 _tmp959_ = vala_semantic_analyzer_get_current_symbol (_tmp958_);
3642 _tmp960_ = _tmp959_;
3643 _tmp961_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp960_, VALA_TYPE_BLOCK, ValaBlock));
3644 block = _tmp961_;
3645 _tmp962_ = block;
3646 _tmp963_ = local;
3647 vala_block_remove_local_variable (_tmp962_, _tmp963_);
3648 _tmp964_ = vala_code_context_get_analyzer (context);
3649 _tmp965_ = _tmp964_;
3650 _tmp966_ = _tmp965_->insert_block;
3651 _tmp967_ = local;
3652 vala_block_add_local_variable (_tmp966_, _tmp967_);
3653 _tmp968_ = old_parent_node;
3654 _tmp969_ = temp_access;
3655 vala_code_node_replace_expression (_tmp968_, (ValaExpression*) self, _tmp969_);
3656 _tmp970_ = temp_access;
3657 vala_code_node_check ((ValaCodeNode*) _tmp970_, context);
3658 _vala_code_node_unref0 (block);
3659 _vala_code_node_unref0 (temp_access);
3660 _vala_code_node_unref0 (decl);
3661 _vala_code_node_unref0 (local);
3662 _vala_code_node_unref0 (old_parent_node);
3663 }
3664 }
3665 }
3666 _tmp971_ = vala_code_node_get_error ((ValaCodeNode*) self);
3667 _tmp972_ = _tmp971_;
3668 result = !_tmp972_;
3669 _vala_iterator_unref0 (arg_it);
3670 _vala_code_node_unref0 (last_arg);
3671 _vala_iterable_unref0 (params);
3672 _vala_code_node_unref0 (ret_type);
3673 _vala_code_node_unref0 (mtype);
3674 _vala_iterable_unref0 (method_type_args);
3675 _vala_code_node_unref0 (target_object_type);
3676 return result;
3677 }
3678
3679 static void
vala_method_call_real_emit(ValaCodeNode * base,ValaCodeGenerator * codegen)3680 vala_method_call_real_emit (ValaCodeNode* base,
3681 ValaCodeGenerator* codegen)
3682 {
3683 ValaMethodCall * self;
3684 ValaMethodType* method_type = NULL;
3685 ValaExpression* _tmp0_;
3686 ValaExpression* _tmp1_;
3687 ValaDataType* _tmp2_;
3688 ValaDataType* _tmp3_;
3689 gboolean _tmp4_ = FALSE;
3690 ValaMethodType* _tmp5_;
3691 self = (ValaMethodCall*) base;
3692 g_return_if_fail (codegen != NULL);
3693 _tmp0_ = vala_method_call_get_call (self);
3694 _tmp1_ = _tmp0_;
3695 _tmp2_ = vala_expression_get_value_type (_tmp1_);
3696 _tmp3_ = _tmp2_;
3697 method_type = VALA_IS_METHOD_TYPE (_tmp3_) ? ((ValaMethodType*) _tmp3_) : NULL;
3698 _tmp5_ = method_type;
3699 if (_tmp5_ != NULL) {
3700 ValaMethodType* _tmp6_;
3701 ValaMethod* _tmp7_;
3702 ValaMethod* _tmp8_;
3703 ValaSymbol* _tmp9_;
3704 ValaSymbol* _tmp10_;
3705 _tmp6_ = method_type;
3706 _tmp7_ = vala_method_type_get_method_symbol (_tmp6_);
3707 _tmp8_ = _tmp7_;
3708 _tmp9_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp8_);
3709 _tmp10_ = _tmp9_;
3710 _tmp4_ = VALA_IS_SIGNAL (_tmp10_);
3711 } else {
3712 _tmp4_ = FALSE;
3713 }
3714 if (_tmp4_) {
3715 ValaExpression* _tmp11_;
3716 ValaExpression* _tmp12_;
3717 ValaExpression* _tmp13_;
3718 ValaExpression* _tmp14_;
3719 _tmp11_ = vala_method_call_get_call (self);
3720 _tmp12_ = _tmp11_;
3721 _tmp13_ = vala_member_access_get_inner (G_TYPE_CHECK_INSTANCE_CAST (_tmp12_, VALA_TYPE_MEMBER_ACCESS, ValaMemberAccess));
3722 _tmp14_ = _tmp13_;
3723 vala_code_node_emit ((ValaCodeNode*) _tmp14_, codegen);
3724 } else {
3725 ValaExpression* _tmp15_;
3726 ValaExpression* _tmp16_;
3727 _tmp15_ = vala_method_call_get_call (self);
3728 _tmp16_ = _tmp15_;
3729 vala_code_node_emit ((ValaCodeNode*) _tmp16_, codegen);
3730 }
3731 {
3732 ValaList* _expr_list = NULL;
3733 ValaList* _tmp17_;
3734 ValaList* _tmp18_;
3735 gint _expr_size = 0;
3736 ValaList* _tmp19_;
3737 gint _tmp20_;
3738 gint _tmp21_;
3739 gint _expr_index = 0;
3740 _tmp17_ = self->priv->argument_list;
3741 _tmp18_ = _vala_iterable_ref0 (_tmp17_);
3742 _expr_list = _tmp18_;
3743 _tmp19_ = _expr_list;
3744 _tmp20_ = vala_collection_get_size ((ValaCollection*) _tmp19_);
3745 _tmp21_ = _tmp20_;
3746 _expr_size = _tmp21_;
3747 _expr_index = -1;
3748 while (TRUE) {
3749 gint _tmp22_;
3750 gint _tmp23_;
3751 ValaExpression* expr = NULL;
3752 ValaList* _tmp24_;
3753 gpointer _tmp25_;
3754 ValaExpression* _tmp26_;
3755 _expr_index = _expr_index + 1;
3756 _tmp22_ = _expr_index;
3757 _tmp23_ = _expr_size;
3758 if (!(_tmp22_ < _tmp23_)) {
3759 break;
3760 }
3761 _tmp24_ = _expr_list;
3762 _tmp25_ = vala_list_get (_tmp24_, _expr_index);
3763 expr = (ValaExpression*) _tmp25_;
3764 _tmp26_ = expr;
3765 vala_code_node_emit ((ValaCodeNode*) _tmp26_, codegen);
3766 _vala_code_node_unref0 (expr);
3767 }
3768 _vala_iterable_unref0 (_expr_list);
3769 }
3770 vala_code_visitor_visit_method_call ((ValaCodeVisitor*) codegen, self);
3771 vala_code_visitor_visit_expression ((ValaCodeVisitor*) codegen, (ValaExpression*) self);
3772 }
3773
3774 static void
vala_method_call_real_get_defined_variables(ValaCodeNode * base,ValaCollection * collection)3775 vala_method_call_real_get_defined_variables (ValaCodeNode* base,
3776 ValaCollection* collection)
3777 {
3778 ValaMethodCall * self;
3779 ValaExpression* _tmp0_;
3780 ValaExpression* _tmp1_;
3781 self = (ValaMethodCall*) base;
3782 g_return_if_fail (collection != NULL);
3783 _tmp0_ = vala_method_call_get_call (self);
3784 _tmp1_ = _tmp0_;
3785 vala_code_node_get_defined_variables ((ValaCodeNode*) _tmp1_, collection);
3786 {
3787 ValaList* _arg_list = NULL;
3788 ValaList* _tmp2_;
3789 ValaList* _tmp3_;
3790 gint _arg_size = 0;
3791 ValaList* _tmp4_;
3792 gint _tmp5_;
3793 gint _tmp6_;
3794 gint _arg_index = 0;
3795 _tmp2_ = self->priv->argument_list;
3796 _tmp3_ = _vala_iterable_ref0 (_tmp2_);
3797 _arg_list = _tmp3_;
3798 _tmp4_ = _arg_list;
3799 _tmp5_ = vala_collection_get_size ((ValaCollection*) _tmp4_);
3800 _tmp6_ = _tmp5_;
3801 _arg_size = _tmp6_;
3802 _arg_index = -1;
3803 while (TRUE) {
3804 gint _tmp7_;
3805 gint _tmp8_;
3806 ValaExpression* arg = NULL;
3807 ValaList* _tmp9_;
3808 gpointer _tmp10_;
3809 ValaExpression* _tmp11_;
3810 _arg_index = _arg_index + 1;
3811 _tmp7_ = _arg_index;
3812 _tmp8_ = _arg_size;
3813 if (!(_tmp7_ < _tmp8_)) {
3814 break;
3815 }
3816 _tmp9_ = _arg_list;
3817 _tmp10_ = vala_list_get (_tmp9_, _arg_index);
3818 arg = (ValaExpression*) _tmp10_;
3819 _tmp11_ = arg;
3820 vala_code_node_get_defined_variables ((ValaCodeNode*) _tmp11_, collection);
3821 _vala_code_node_unref0 (arg);
3822 }
3823 _vala_iterable_unref0 (_arg_list);
3824 }
3825 }
3826
3827 static void
vala_method_call_real_get_used_variables(ValaCodeNode * base,ValaCollection * collection)3828 vala_method_call_real_get_used_variables (ValaCodeNode* base,
3829 ValaCollection* collection)
3830 {
3831 ValaMethodCall * self;
3832 ValaExpression* _tmp0_;
3833 ValaExpression* _tmp1_;
3834 self = (ValaMethodCall*) base;
3835 g_return_if_fail (collection != NULL);
3836 _tmp0_ = vala_method_call_get_call (self);
3837 _tmp1_ = _tmp0_;
3838 vala_code_node_get_used_variables ((ValaCodeNode*) _tmp1_, collection);
3839 {
3840 ValaList* _arg_list = NULL;
3841 ValaList* _tmp2_;
3842 ValaList* _tmp3_;
3843 gint _arg_size = 0;
3844 ValaList* _tmp4_;
3845 gint _tmp5_;
3846 gint _tmp6_;
3847 gint _arg_index = 0;
3848 _tmp2_ = self->priv->argument_list;
3849 _tmp3_ = _vala_iterable_ref0 (_tmp2_);
3850 _arg_list = _tmp3_;
3851 _tmp4_ = _arg_list;
3852 _tmp5_ = vala_collection_get_size ((ValaCollection*) _tmp4_);
3853 _tmp6_ = _tmp5_;
3854 _arg_size = _tmp6_;
3855 _arg_index = -1;
3856 while (TRUE) {
3857 gint _tmp7_;
3858 gint _tmp8_;
3859 ValaExpression* arg = NULL;
3860 ValaList* _tmp9_;
3861 gpointer _tmp10_;
3862 ValaExpression* _tmp11_;
3863 _arg_index = _arg_index + 1;
3864 _tmp7_ = _arg_index;
3865 _tmp8_ = _arg_size;
3866 if (!(_tmp7_ < _tmp8_)) {
3867 break;
3868 }
3869 _tmp9_ = _arg_list;
3870 _tmp10_ = vala_list_get (_tmp9_, _arg_index);
3871 arg = (ValaExpression*) _tmp10_;
3872 _tmp11_ = arg;
3873 vala_code_node_get_used_variables ((ValaCodeNode*) _tmp11_, collection);
3874 _vala_code_node_unref0 (arg);
3875 }
3876 _vala_iterable_unref0 (_arg_list);
3877 }
3878 }
3879
3880 ValaStringLiteral*
vala_method_call_get_format_literal(ValaMethodCall * self)3881 vala_method_call_get_format_literal (ValaMethodCall* self)
3882 {
3883 ValaMethodType* mtype = NULL;
3884 ValaExpression* _tmp0_;
3885 ValaExpression* _tmp1_;
3886 ValaDataType* _tmp2_;
3887 ValaDataType* _tmp3_;
3888 ValaMethodType* _tmp4_;
3889 ValaStringLiteral* result = NULL;
3890 g_return_val_if_fail (self != NULL, NULL);
3891 _tmp0_ = vala_method_call_get_call (self);
3892 _tmp1_ = _tmp0_;
3893 _tmp2_ = vala_expression_get_value_type (_tmp1_);
3894 _tmp3_ = _tmp2_;
3895 mtype = VALA_IS_METHOD_TYPE (_tmp3_) ? ((ValaMethodType*) _tmp3_) : NULL;
3896 _tmp4_ = mtype;
3897 if (_tmp4_ != NULL) {
3898 gint format_arg = 0;
3899 ValaMethodType* _tmp5_;
3900 ValaMethod* _tmp6_;
3901 ValaMethod* _tmp7_;
3902 gboolean _tmp8_ = FALSE;
3903 _tmp5_ = mtype;
3904 _tmp6_ = vala_method_type_get_method_symbol (_tmp5_);
3905 _tmp7_ = _tmp6_;
3906 format_arg = vala_method_get_format_arg_index (_tmp7_);
3907 if (format_arg >= 0) {
3908 ValaList* _tmp9_;
3909 gint _tmp10_;
3910 gint _tmp11_;
3911 _tmp9_ = self->priv->argument_list;
3912 _tmp10_ = vala_collection_get_size ((ValaCollection*) _tmp9_);
3913 _tmp11_ = _tmp10_;
3914 _tmp8_ = format_arg < _tmp11_;
3915 } else {
3916 _tmp8_ = FALSE;
3917 }
3918 if (_tmp8_) {
3919 ValaList* _tmp12_;
3920 gpointer _tmp13_;
3921 ValaExpression* _tmp14_;
3922 ValaStringLiteral* _tmp15_;
3923 ValaStringLiteral* _tmp16_;
3924 _tmp12_ = self->priv->argument_list;
3925 _tmp13_ = vala_list_get (_tmp12_, format_arg);
3926 _tmp14_ = (ValaExpression*) _tmp13_;
3927 _tmp15_ = vala_string_literal_get_format_literal (_tmp14_);
3928 _tmp16_ = _tmp15_;
3929 _vala_code_node_unref0 (_tmp14_);
3930 result = _tmp16_;
3931 return result;
3932 }
3933 }
3934 result = NULL;
3935 return result;
3936 }
3937
3938 static gchar*
vala_method_call_real_to_string(ValaCodeNode * base)3939 vala_method_call_real_to_string (ValaCodeNode* base)
3940 {
3941 ValaMethodCall * self;
3942 GString* b = NULL;
3943 GString* _tmp0_;
3944 GString* _tmp1_;
3945 gboolean _tmp2_;
3946 GString* _tmp4_;
3947 ValaExpression* _tmp5_;
3948 ValaExpression* _tmp6_;
3949 gchar* _tmp7_;
3950 gchar* _tmp8_;
3951 GString* _tmp9_;
3952 gboolean first = FALSE;
3953 GString* _tmp24_;
3954 GString* _tmp25_;
3955 const gchar* _tmp26_;
3956 gchar* _tmp27_;
3957 gchar* result = NULL;
3958 self = (ValaMethodCall*) base;
3959 _tmp0_ = g_string_new ("");
3960 b = _tmp0_;
3961 _tmp1_ = b;
3962 g_string_append_c (_tmp1_, '(');
3963 _tmp2_ = self->priv->_is_yield_expression;
3964 if (_tmp2_) {
3965 GString* _tmp3_;
3966 _tmp3_ = b;
3967 g_string_append (_tmp3_, "yield ");
3968 }
3969 _tmp4_ = b;
3970 _tmp5_ = vala_method_call_get_call (self);
3971 _tmp6_ = _tmp5_;
3972 _tmp7_ = vala_code_node_to_string ((ValaCodeNode*) _tmp6_);
3973 _tmp8_ = _tmp7_;
3974 g_string_append (_tmp4_, _tmp8_);
3975 _g_free0 (_tmp8_);
3976 _tmp9_ = b;
3977 g_string_append_c (_tmp9_, '(');
3978 first = TRUE;
3979 {
3980 ValaList* _expr_list = NULL;
3981 ValaList* _tmp10_;
3982 ValaList* _tmp11_;
3983 gint _expr_size = 0;
3984 ValaList* _tmp12_;
3985 gint _tmp13_;
3986 gint _tmp14_;
3987 gint _expr_index = 0;
3988 _tmp10_ = self->priv->argument_list;
3989 _tmp11_ = _vala_iterable_ref0 (_tmp10_);
3990 _expr_list = _tmp11_;
3991 _tmp12_ = _expr_list;
3992 _tmp13_ = vala_collection_get_size ((ValaCollection*) _tmp12_);
3993 _tmp14_ = _tmp13_;
3994 _expr_size = _tmp14_;
3995 _expr_index = -1;
3996 while (TRUE) {
3997 gint _tmp15_;
3998 gint _tmp16_;
3999 ValaExpression* expr = NULL;
4000 ValaList* _tmp17_;
4001 gpointer _tmp18_;
4002 GString* _tmp20_;
4003 ValaExpression* _tmp21_;
4004 gchar* _tmp22_;
4005 gchar* _tmp23_;
4006 _expr_index = _expr_index + 1;
4007 _tmp15_ = _expr_index;
4008 _tmp16_ = _expr_size;
4009 if (!(_tmp15_ < _tmp16_)) {
4010 break;
4011 }
4012 _tmp17_ = _expr_list;
4013 _tmp18_ = vala_list_get (_tmp17_, _expr_index);
4014 expr = (ValaExpression*) _tmp18_;
4015 if (!first) {
4016 GString* _tmp19_;
4017 _tmp19_ = b;
4018 g_string_append (_tmp19_, ", ");
4019 }
4020 _tmp20_ = b;
4021 _tmp21_ = expr;
4022 _tmp22_ = vala_code_node_to_string ((ValaCodeNode*) _tmp21_);
4023 _tmp23_ = _tmp22_;
4024 g_string_append (_tmp20_, _tmp23_);
4025 _g_free0 (_tmp23_);
4026 first = FALSE;
4027 _vala_code_node_unref0 (expr);
4028 }
4029 _vala_iterable_unref0 (_expr_list);
4030 }
4031 _tmp24_ = b;
4032 g_string_append (_tmp24_, "))");
4033 _tmp25_ = b;
4034 _tmp26_ = _tmp25_->str;
4035 _tmp27_ = g_strdup (_tmp26_);
4036 result = _tmp27_;
4037 _g_string_free0 (b);
4038 return result;
4039 }
4040
4041 static void
vala_method_call_class_init(ValaMethodCallClass * klass,gpointer klass_data)4042 vala_method_call_class_init (ValaMethodCallClass * klass,
4043 gpointer klass_data)
4044 {
4045 vala_method_call_parent_class = g_type_class_peek_parent (klass);
4046 ((ValaCodeNodeClass *) klass)->finalize = vala_method_call_finalize;
4047 g_type_class_adjust_private_offset (klass, &ValaMethodCall_private_offset);
4048 ((ValaCodeNodeClass *) klass)->accept = (void (*) (ValaCodeNode*, ValaCodeVisitor*)) vala_method_call_real_accept;
4049 ((ValaCodeNodeClass *) klass)->accept_children = (void (*) (ValaCodeNode*, ValaCodeVisitor*)) vala_method_call_real_accept_children;
4050 ((ValaCodeNodeClass *) klass)->replace_expression = (void (*) (ValaCodeNode*, ValaExpression*, ValaExpression*)) vala_method_call_real_replace_expression;
4051 ((ValaExpressionClass *) klass)->is_constant = (gboolean (*) (ValaExpression*)) vala_method_call_real_is_constant;
4052 ((ValaExpressionClass *) klass)->is_pure = (gboolean (*) (ValaExpression*)) vala_method_call_real_is_pure;
4053 ((ValaExpressionClass *) klass)->is_accessible = (gboolean (*) (ValaExpression*, ValaSymbol*)) vala_method_call_real_is_accessible;
4054 ((ValaCodeNodeClass *) klass)->get_error_types = (void (*) (ValaCodeNode*, ValaCollection*, ValaSourceReference*)) vala_method_call_real_get_error_types;
4055 ((ValaCodeNodeClass *) klass)->check = (gboolean (*) (ValaCodeNode*, ValaCodeContext*)) vala_method_call_real_check;
4056 ((ValaCodeNodeClass *) klass)->emit = (void (*) (ValaCodeNode*, ValaCodeGenerator*)) vala_method_call_real_emit;
4057 ((ValaCodeNodeClass *) klass)->get_defined_variables = (void (*) (ValaCodeNode*, ValaCollection*)) vala_method_call_real_get_defined_variables;
4058 ((ValaCodeNodeClass *) klass)->get_used_variables = (void (*) (ValaCodeNode*, ValaCollection*)) vala_method_call_real_get_used_variables;
4059 ((ValaCodeNodeClass *) klass)->to_string = (gchar* (*) (ValaCodeNode*)) vala_method_call_real_to_string;
4060 }
4061
4062 static void
vala_method_call_instance_init(ValaMethodCall * self,gpointer klass)4063 vala_method_call_instance_init (ValaMethodCall * self,
4064 gpointer klass)
4065 {
4066 GEqualFunc _tmp0_;
4067 ValaArrayList* _tmp1_;
4068 self->priv = vala_method_call_get_instance_private (self);
4069 _tmp0_ = g_direct_equal;
4070 _tmp1_ = vala_array_list_new (VALA_TYPE_EXPRESSION, (GBoxedCopyFunc) vala_code_node_ref, (GDestroyNotify) vala_code_node_unref, _tmp0_);
4071 self->priv->argument_list = (ValaList*) _tmp1_;
4072 }
4073
4074 static void
vala_method_call_finalize(ValaCodeNode * obj)4075 vala_method_call_finalize (ValaCodeNode * obj)
4076 {
4077 ValaMethodCall * self;
4078 self = G_TYPE_CHECK_INSTANCE_CAST (obj, VALA_TYPE_METHOD_CALL, ValaMethodCall);
4079 _vala_code_node_unref0 (self->priv->_call);
4080 _vala_iterable_unref0 (self->priv->argument_list);
4081 VALA_CODE_NODE_CLASS (vala_method_call_parent_class)->finalize (obj);
4082 }
4083
4084 /**
4085 * Represents an invocation expression in the source code.
4086 */
4087 static GType
vala_method_call_get_type_once(void)4088 vala_method_call_get_type_once (void)
4089 {
4090 static const GTypeInfo g_define_type_info = { sizeof (ValaMethodCallClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) vala_method_call_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ValaMethodCall), 0, (GInstanceInitFunc) vala_method_call_instance_init, NULL };
4091 GType vala_method_call_type_id;
4092 vala_method_call_type_id = g_type_register_static (VALA_TYPE_EXPRESSION, "ValaMethodCall", &g_define_type_info, 0);
4093 ValaMethodCall_private_offset = g_type_add_instance_private (vala_method_call_type_id, sizeof (ValaMethodCallPrivate));
4094 return vala_method_call_type_id;
4095 }
4096
4097 GType
vala_method_call_get_type(void)4098 vala_method_call_get_type (void)
4099 {
4100 static volatile gsize vala_method_call_type_id__volatile = 0;
4101 if (g_once_init_enter (&vala_method_call_type_id__volatile)) {
4102 GType vala_method_call_type_id;
4103 vala_method_call_type_id = vala_method_call_get_type_once ();
4104 g_once_init_leave (&vala_method_call_type_id__volatile, vala_method_call_type_id);
4105 }
4106 return vala_method_call_type_id__volatile;
4107 }
4108
4109