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