1 /* valamethod.c generated by valac, the Vala compiler
2 * generated from valamethod.vala, do not modify */
3
4 /* valamethod.vala
5 *
6 * Copyright (C) 2006-2010 Jürg Billeter
7 * Copyright (C) 2006-2008 Raffaele Sandrini
8 *
9 * This library is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
13
14 * This library is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
18
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with this library; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22 *
23 * Author:
24 * Jürg Billeter <j@bitron.ch>
25 * Raffaele Sandrini <raffaele@sandrini.ch>
26 */
27
28 #include "vala.h"
29 #include <valagee.h>
30 #include <glib-object.h>
31 #include <glib.h>
32 #include <stdlib.h>
33 #include <string.h>
34 #include <float.h>
35 #include <math.h>
36
37 #define _vala_iterable_unref0(var) ((var == NULL) ? NULL : (var = (vala_iterable_unref (var), NULL)))
38 #define _vala_code_node_unref0(var) ((var == NULL) ? NULL : (var = (vala_code_node_unref (var), NULL)))
39 #define _g_free0(var) (var = (g_free (var), NULL))
40 #define _vala_iterator_unref0(var) ((var == NULL) ? NULL : (var = (vala_iterator_unref (var), NULL)))
41 #define _vala_source_file_unref0(var) ((var == NULL) ? NULL : (var = (vala_source_file_unref (var), NULL)))
42 #define _vala_code_context_unref0(var) ((var == NULL) ? NULL : (var = (vala_code_context_unref (var), NULL)))
43 #define _vala_assert(expr, msg) if G_LIKELY (expr) ; else g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, msg);
44 #define _vala_return_if_fail(expr, msg) if G_LIKELY (expr) ; else { g_return_if_fail_warning (G_LOG_DOMAIN, G_STRFUNC, msg); return; }
45 #define _vala_return_val_if_fail(expr, msg, val) if G_LIKELY (expr) ; else { g_return_if_fail_warning (G_LOG_DOMAIN, G_STRFUNC, msg); return val; }
46 #define _vala_warn_if_fail(expr, msg) if G_LIKELY (expr) ; else g_warn_message (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, msg);
47
48 struct _ValaMethodPrivate {
49 ValaList* type_parameters;
50 ValaMemberBinding _binding;
51 gboolean _is_abstract;
52 gboolean _is_virtual;
53 gboolean _overrides;
54 gboolean _is_inline;
55 gboolean _entry_point;
56 ValaParameter* _this_parameter;
57 ValaLocalVariable* _params_array_var;
58 ValaSignal* _signal_reference;
59 gboolean _closure;
60 gboolean _coroutine;
61 gboolean _is_async_callback;
62 ValaList* parameters;
63 ValaList* preconditions;
64 ValaList* postconditions;
65 ValaDataType* _return_type;
66 ValaMethod* _base_method;
67 ValaMethod* _base_interface_method;
68 ValaDataType* _base_interface_type;
69 gboolean base_methods_valid;
70 ValaMethod* callback_method;
71 ValaMethod* end_method;
72 ValaList* captured_variables;
73 };
74
75 static gint ValaMethod_private_offset;
76 static gpointer vala_method_parent_class = NULL;
77 static ValaList* vala_method__empty_expression_list;
78 static ValaList* vala_method__empty_expression_list = NULL;
79 static ValaList* vala_method__empty_type_parameter_list;
80 static ValaList* vala_method__empty_type_parameter_list = NULL;
81 static ValaCallableIface * vala_method_vala_callable_parent_iface = NULL;
82
83 static void vala_method_find_base_methods (ValaMethod* self);
84 static void vala_method_set_entry_point (ValaMethod* self,
85 gboolean value);
86 static void vala_method_real_add_parameter (ValaCallable* base,
87 ValaParameter* param);
88 static ValaList* vala_method_real_get_parameters (ValaCallable* base);
89 static void vala_method_real_accept (ValaCodeNode* base,
90 ValaCodeVisitor* visitor);
91 static void vala_method_real_accept_children (ValaCodeNode* base,
92 ValaCodeVisitor* visitor);
93 static gboolean vala_method_compatible_internal (ValaMethod* self,
94 ValaMethod* base_method,
95 gchar* * invalid_match,
96 ValaCodeNode* node_reference);
97 static void vala_method_real_get_error_types (ValaCodeNode* base,
98 ValaCollection* collection,
99 ValaSourceReference* source_reference);
100 static void vala_method_real_replace_type (ValaCodeNode* base,
101 ValaDataType* old_type,
102 ValaDataType* new_type);
103 static void vala_method_find_base_interface_method (ValaMethod* self,
104 ValaClass* cl);
105 static void vala_method_find_base_class_method (ValaMethod* self,
106 ValaClass* cl);
107 static gboolean vala_method_real_check (ValaCodeNode* base,
108 ValaCodeContext* context);
109 static gboolean vala_method_is_possible_entry_point (ValaMethod* self,
110 ValaCodeContext* context);
111 static void vala_method_real_get_defined_variables (ValaCodeNode* base,
112 ValaCollection* collection);
113 static void vala_method_finalize (ValaCodeNode * obj);
114 static GType vala_method_get_type_once (void);
115
116 static inline gpointer
vala_method_get_instance_private(ValaMethod * self)117 vala_method_get_instance_private (ValaMethod* self)
118 {
119 return G_STRUCT_MEMBER_P (self, ValaMethod_private_offset);
120 }
121
122 static ValaDataType*
vala_method_real_get_return_type(ValaCallable * base)123 vala_method_real_get_return_type (ValaCallable* base)
124 {
125 ValaDataType* result;
126 ValaMethod* self;
127 ValaDataType* _tmp0_;
128 self = (ValaMethod*) base;
129 _tmp0_ = self->priv->_return_type;
130 result = _tmp0_;
131 return result;
132 }
133
134 static gpointer
_vala_code_node_ref0(gpointer self)135 _vala_code_node_ref0 (gpointer self)
136 {
137 return self ? vala_code_node_ref (self) : NULL;
138 }
139
140 static void
vala_method_real_set_return_type(ValaCallable * base,ValaDataType * value)141 vala_method_real_set_return_type (ValaCallable* base,
142 ValaDataType* value)
143 {
144 ValaMethod* self;
145 ValaDataType* _tmp0_;
146 ValaDataType* _tmp1_;
147 self = (ValaMethod*) base;
148 _tmp0_ = _vala_code_node_ref0 (value);
149 _vala_code_node_unref0 (self->priv->_return_type);
150 self->priv->_return_type = _tmp0_;
151 _tmp1_ = self->priv->_return_type;
152 vala_code_node_set_parent_node ((ValaCodeNode*) _tmp1_, (ValaCodeNode*) self);
153 }
154
155 static gboolean
vala_method_real_get_has_result(ValaSubroutine * base)156 vala_method_real_get_has_result (ValaSubroutine* base)
157 {
158 gboolean result;
159 ValaMethod* self;
160 ValaDataType* _tmp0_;
161 ValaDataType* _tmp1_;
162 self = (ValaMethod*) base;
163 _tmp0_ = vala_callable_get_return_type ((ValaCallable*) self);
164 _tmp1_ = _tmp0_;
165 result = !VALA_IS_VOID_TYPE (_tmp1_);
166 return result;
167 }
168
169 ValaMemberBinding
vala_method_get_binding(ValaMethod * self)170 vala_method_get_binding (ValaMethod* self)
171 {
172 ValaMemberBinding result;
173 ValaMemberBinding _tmp0_;
174 g_return_val_if_fail (self != NULL, 0);
175 _tmp0_ = self->priv->_binding;
176 result = _tmp0_;
177 return result;
178 }
179
180 void
vala_method_set_binding(ValaMethod * self,ValaMemberBinding value)181 vala_method_set_binding (ValaMethod* self,
182 ValaMemberBinding value)
183 {
184 g_return_if_fail (self != NULL);
185 self->priv->_binding = value;
186 }
187
188 gboolean
vala_method_get_is_abstract(ValaMethod * self)189 vala_method_get_is_abstract (ValaMethod* self)
190 {
191 gboolean result;
192 g_return_val_if_fail (self != NULL, FALSE);
193 result = self->priv->_is_abstract;
194 return result;
195 }
196
197 void
vala_method_set_is_abstract(ValaMethod * self,gboolean value)198 vala_method_set_is_abstract (ValaMethod* self,
199 gboolean value)
200 {
201 g_return_if_fail (self != NULL);
202 self->priv->_is_abstract = value;
203 }
204
205 gboolean
vala_method_get_is_virtual(ValaMethod * self)206 vala_method_get_is_virtual (ValaMethod* self)
207 {
208 gboolean result;
209 g_return_val_if_fail (self != NULL, FALSE);
210 result = self->priv->_is_virtual;
211 return result;
212 }
213
214 void
vala_method_set_is_virtual(ValaMethod * self,gboolean value)215 vala_method_set_is_virtual (ValaMethod* self,
216 gboolean value)
217 {
218 g_return_if_fail (self != NULL);
219 self->priv->_is_virtual = value;
220 }
221
222 gboolean
vala_method_get_overrides(ValaMethod * self)223 vala_method_get_overrides (ValaMethod* self)
224 {
225 gboolean result;
226 g_return_val_if_fail (self != NULL, FALSE);
227 result = self->priv->_overrides;
228 return result;
229 }
230
231 void
vala_method_set_overrides(ValaMethod * self,gboolean value)232 vala_method_set_overrides (ValaMethod* self,
233 gboolean value)
234 {
235 g_return_if_fail (self != NULL);
236 self->priv->_overrides = value;
237 }
238
239 gboolean
vala_method_get_is_inline(ValaMethod * self)240 vala_method_get_is_inline (ValaMethod* self)
241 {
242 gboolean result;
243 g_return_val_if_fail (self != NULL, FALSE);
244 result = self->priv->_is_inline;
245 return result;
246 }
247
248 void
vala_method_set_is_inline(ValaMethod * self,gboolean value)249 vala_method_set_is_inline (ValaMethod* self,
250 gboolean value)
251 {
252 g_return_if_fail (self != NULL);
253 self->priv->_is_inline = value;
254 }
255
256 gboolean
vala_method_get_returns_floating_reference(ValaMethod * self)257 vala_method_get_returns_floating_reference (ValaMethod* self)
258 {
259 gboolean result;
260 g_return_val_if_fail (self != NULL, FALSE);
261 result = vala_code_node_get_attribute_bool ((ValaCodeNode*) self, "CCode", "returns_floating_reference", FALSE);
262 return result;
263 }
264
265 void
vala_method_set_returns_floating_reference(ValaMethod * self,gboolean value)266 vala_method_set_returns_floating_reference (ValaMethod* self,
267 gboolean value)
268 {
269 g_return_if_fail (self != NULL);
270 vala_code_node_set_attribute_bool ((ValaCodeNode*) self, "CCode", "returns_floating_reference", value, NULL);
271 }
272
273 gboolean
vala_method_get_returns_modified_pointer(ValaMethod * self)274 vala_method_get_returns_modified_pointer (ValaMethod* self)
275 {
276 gboolean result;
277 ValaAttribute* _tmp0_;
278 g_return_val_if_fail (self != NULL, FALSE);
279 _tmp0_ = vala_code_node_get_attribute ((ValaCodeNode*) self, "ReturnsModifiedPointer");
280 result = _tmp0_ != NULL;
281 return result;
282 }
283
284 void
vala_method_set_returns_modified_pointer(ValaMethod * self,gboolean value)285 vala_method_set_returns_modified_pointer (ValaMethod* self,
286 gboolean value)
287 {
288 g_return_if_fail (self != NULL);
289 vala_code_node_set_attribute ((ValaCodeNode*) self, "ReturnsModifiedPointer", value, NULL);
290 }
291
292 ValaMethod*
vala_method_get_base_method(ValaMethod * self)293 vala_method_get_base_method (ValaMethod* self)
294 {
295 ValaMethod* result;
296 ValaMethod* _tmp0_;
297 g_return_val_if_fail (self != NULL, NULL);
298 vala_method_find_base_methods (self);
299 _tmp0_ = self->priv->_base_method;
300 result = _tmp0_;
301 return result;
302 }
303
304 ValaMethod*
vala_method_get_base_interface_method(ValaMethod * self)305 vala_method_get_base_interface_method (ValaMethod* self)
306 {
307 ValaMethod* result;
308 ValaMethod* _tmp0_;
309 g_return_val_if_fail (self != NULL, NULL);
310 vala_method_find_base_methods (self);
311 _tmp0_ = self->priv->_base_interface_method;
312 result = _tmp0_;
313 return result;
314 }
315
316 ValaDataType*
vala_method_get_base_interface_type(ValaMethod * self)317 vala_method_get_base_interface_type (ValaMethod* self)
318 {
319 ValaDataType* result;
320 ValaDataType* _tmp0_;
321 g_return_val_if_fail (self != NULL, NULL);
322 _tmp0_ = self->priv->_base_interface_type;
323 result = _tmp0_;
324 return result;
325 }
326
327 void
vala_method_set_base_interface_type(ValaMethod * self,ValaDataType * value)328 vala_method_set_base_interface_type (ValaMethod* self,
329 ValaDataType* value)
330 {
331 ValaDataType* _tmp0_;
332 ValaDataType* _tmp1_;
333 g_return_if_fail (self != NULL);
334 _tmp0_ = _vala_code_node_ref0 (value);
335 _vala_code_node_unref0 (self->priv->_base_interface_type);
336 self->priv->_base_interface_type = _tmp0_;
337 _tmp1_ = self->priv->_base_interface_type;
338 vala_code_node_set_parent_node ((ValaCodeNode*) _tmp1_, (ValaCodeNode*) self);
339 }
340
341 gboolean
vala_method_get_entry_point(ValaMethod * self)342 vala_method_get_entry_point (ValaMethod* self)
343 {
344 gboolean result;
345 g_return_val_if_fail (self != NULL, FALSE);
346 result = self->priv->_entry_point;
347 return result;
348 }
349
350 static void
vala_method_set_entry_point(ValaMethod * self,gboolean value)351 vala_method_set_entry_point (ValaMethod* self,
352 gboolean value)
353 {
354 g_return_if_fail (self != NULL);
355 self->priv->_entry_point = value;
356 }
357
358 ValaParameter*
vala_method_get_this_parameter(ValaMethod * self)359 vala_method_get_this_parameter (ValaMethod* self)
360 {
361 ValaParameter* result;
362 ValaParameter* _tmp0_;
363 g_return_val_if_fail (self != NULL, NULL);
364 _tmp0_ = self->priv->_this_parameter;
365 result = _tmp0_;
366 return result;
367 }
368
369 void
vala_method_set_this_parameter(ValaMethod * self,ValaParameter * value)370 vala_method_set_this_parameter (ValaMethod* self,
371 ValaParameter* value)
372 {
373 ValaParameter* _tmp0_;
374 g_return_if_fail (self != NULL);
375 _tmp0_ = _vala_code_node_ref0 (value);
376 _vala_code_node_unref0 (self->priv->_this_parameter);
377 self->priv->_this_parameter = _tmp0_;
378 }
379
380 gboolean
vala_method_get_printf_format(ValaMethod * self)381 vala_method_get_printf_format (ValaMethod* self)
382 {
383 gboolean result;
384 ValaAttribute* _tmp0_;
385 g_return_val_if_fail (self != NULL, FALSE);
386 _tmp0_ = vala_code_node_get_attribute ((ValaCodeNode*) self, "PrintfFormat");
387 result = _tmp0_ != NULL;
388 return result;
389 }
390
391 void
vala_method_set_printf_format(ValaMethod * self,gboolean value)392 vala_method_set_printf_format (ValaMethod* self,
393 gboolean value)
394 {
395 g_return_if_fail (self != NULL);
396 vala_code_node_set_attribute ((ValaCodeNode*) self, "PrintfFormat", value, NULL);
397 }
398
399 gboolean
vala_method_get_scanf_format(ValaMethod * self)400 vala_method_get_scanf_format (ValaMethod* self)
401 {
402 gboolean result;
403 ValaAttribute* _tmp0_;
404 g_return_val_if_fail (self != NULL, FALSE);
405 _tmp0_ = vala_code_node_get_attribute ((ValaCodeNode*) self, "ScanfFormat");
406 result = _tmp0_ != NULL;
407 return result;
408 }
409
410 void
vala_method_set_scanf_format(ValaMethod * self,gboolean value)411 vala_method_set_scanf_format (ValaMethod* self,
412 gboolean value)
413 {
414 g_return_if_fail (self != NULL);
415 vala_code_node_set_attribute ((ValaCodeNode*) self, "ScanfFormat", value, NULL);
416 }
417
418 gboolean
vala_method_get_has_construct_function(ValaMethod * self)419 vala_method_get_has_construct_function (ValaMethod* self)
420 {
421 gboolean result;
422 g_return_val_if_fail (self != NULL, FALSE);
423 result = vala_code_node_get_attribute_bool ((ValaCodeNode*) self, "CCode", "has_construct_function", TRUE);
424 return result;
425 }
426
427 void
vala_method_set_has_construct_function(ValaMethod * self,gboolean value)428 vala_method_set_has_construct_function (ValaMethod* self,
429 gboolean value)
430 {
431 g_return_if_fail (self != NULL);
432 vala_code_node_set_attribute_bool ((ValaCodeNode*) self, "CCode", "has_construct_function", value, NULL);
433 }
434
435 ValaLocalVariable*
vala_method_get_params_array_var(ValaMethod * self)436 vala_method_get_params_array_var (ValaMethod* self)
437 {
438 ValaLocalVariable* result;
439 ValaLocalVariable* _tmp0_;
440 g_return_val_if_fail (self != NULL, NULL);
441 _tmp0_ = self->priv->_params_array_var;
442 result = _tmp0_;
443 return result;
444 }
445
446 void
vala_method_set_params_array_var(ValaMethod * self,ValaLocalVariable * value)447 vala_method_set_params_array_var (ValaMethod* self,
448 ValaLocalVariable* value)
449 {
450 ValaLocalVariable* _tmp0_;
451 g_return_if_fail (self != NULL);
452 _tmp0_ = _vala_code_node_ref0 (value);
453 _vala_code_node_unref0 (self->priv->_params_array_var);
454 self->priv->_params_array_var = _tmp0_;
455 }
456
457 ValaSignal*
vala_method_get_signal_reference(ValaMethod * self)458 vala_method_get_signal_reference (ValaMethod* self)
459 {
460 ValaSignal* result;
461 ValaSignal* _tmp0_;
462 g_return_val_if_fail (self != NULL, NULL);
463 _tmp0_ = self->priv->_signal_reference;
464 result = _tmp0_;
465 return result;
466 }
467
468 void
vala_method_set_signal_reference(ValaMethod * self,ValaSignal * value)469 vala_method_set_signal_reference (ValaMethod* self,
470 ValaSignal* value)
471 {
472 g_return_if_fail (self != NULL);
473 self->priv->_signal_reference = value;
474 }
475
476 gboolean
vala_method_get_closure(ValaMethod * self)477 vala_method_get_closure (ValaMethod* self)
478 {
479 gboolean result;
480 g_return_val_if_fail (self != NULL, FALSE);
481 result = self->priv->_closure;
482 return result;
483 }
484
485 void
vala_method_set_closure(ValaMethod * self,gboolean value)486 vala_method_set_closure (ValaMethod* self,
487 gboolean value)
488 {
489 g_return_if_fail (self != NULL);
490 self->priv->_closure = value;
491 }
492
493 gboolean
vala_method_get_coroutine(ValaMethod * self)494 vala_method_get_coroutine (ValaMethod* self)
495 {
496 gboolean result;
497 g_return_val_if_fail (self != NULL, FALSE);
498 result = self->priv->_coroutine;
499 return result;
500 }
501
502 void
vala_method_set_coroutine(ValaMethod * self,gboolean value)503 vala_method_set_coroutine (ValaMethod* self,
504 gboolean value)
505 {
506 g_return_if_fail (self != NULL);
507 self->priv->_coroutine = value;
508 }
509
510 gboolean
vala_method_get_is_async_callback(ValaMethod * self)511 vala_method_get_is_async_callback (ValaMethod* self)
512 {
513 gboolean result;
514 g_return_val_if_fail (self != NULL, FALSE);
515 result = self->priv->_is_async_callback;
516 return result;
517 }
518
519 void
vala_method_set_is_async_callback(ValaMethod * self,gboolean value)520 vala_method_set_is_async_callback (ValaMethod* self,
521 gboolean value)
522 {
523 g_return_if_fail (self != NULL);
524 self->priv->_is_async_callback = value;
525 }
526
527 /**
528 * Creates a new method.
529 *
530 * @param name method name
531 * @param return_type method return type
532 * @param source_reference reference to source code
533 * @return newly created method
534 */
535 ValaMethod*
vala_method_construct(GType object_type,const gchar * name,ValaDataType * return_type,ValaSourceReference * source_reference,ValaComment * comment)536 vala_method_construct (GType object_type,
537 const gchar* name,
538 ValaDataType* return_type,
539 ValaSourceReference* source_reference,
540 ValaComment* comment)
541 {
542 ValaMethod* self = NULL;
543 g_return_val_if_fail (return_type != NULL, NULL);
544 self = (ValaMethod*) vala_subroutine_construct (object_type, name, source_reference, comment);
545 vala_callable_set_return_type ((ValaCallable*) self, return_type);
546 return self;
547 }
548
549 ValaMethod*
vala_method_new(const gchar * name,ValaDataType * return_type,ValaSourceReference * source_reference,ValaComment * comment)550 vala_method_new (const gchar* name,
551 ValaDataType* return_type,
552 ValaSourceReference* source_reference,
553 ValaComment* comment)
554 {
555 return vala_method_construct (VALA_TYPE_METHOD, name, return_type, source_reference, comment);
556 }
557
558 /**
559 * Appends parameter to this method.
560 *
561 * @param param a formal parameter
562 */
563 static void
vala_method_real_add_parameter(ValaCallable * base,ValaParameter * param)564 vala_method_real_add_parameter (ValaCallable* base,
565 ValaParameter* param)
566 {
567 ValaMethod * self;
568 ValaList* _tmp0_;
569 ValaScope* _tmp1_;
570 ValaScope* _tmp2_;
571 const gchar* _tmp3_;
572 const gchar* _tmp4_;
573 self = (ValaMethod*) base;
574 g_return_if_fail (param != NULL);
575 _tmp0_ = self->priv->parameters;
576 vala_collection_add ((ValaCollection*) _tmp0_, param);
577 _tmp1_ = vala_symbol_get_scope ((ValaSymbol*) self);
578 _tmp2_ = _tmp1_;
579 _tmp3_ = vala_symbol_get_name ((ValaSymbol*) param);
580 _tmp4_ = _tmp3_;
581 vala_scope_add (_tmp2_, _tmp4_, (ValaSymbol*) param);
582 }
583
584 static ValaList*
vala_method_real_get_parameters(ValaCallable * base)585 vala_method_real_get_parameters (ValaCallable* base)
586 {
587 ValaMethod * self;
588 ValaList* _tmp0_;
589 ValaList* result = NULL;
590 self = (ValaMethod*) base;
591 _tmp0_ = self->priv->parameters;
592 result = _tmp0_;
593 return result;
594 }
595
596 /**
597 * Remove all parameters from this method.
598 */
599 static gpointer
_vala_iterable_ref0(gpointer self)600 _vala_iterable_ref0 (gpointer self)
601 {
602 return self ? vala_iterable_ref (self) : NULL;
603 }
604
605 void
vala_method_clear_parameters(ValaMethod * self)606 vala_method_clear_parameters (ValaMethod* self)
607 {
608 ValaList* _tmp17_;
609 g_return_if_fail (self != NULL);
610 {
611 ValaList* _param_list = NULL;
612 ValaList* _tmp0_;
613 ValaList* _tmp1_;
614 gint _param_size = 0;
615 ValaList* _tmp2_;
616 gint _tmp3_;
617 gint _tmp4_;
618 gint _param_index = 0;
619 _tmp0_ = self->priv->parameters;
620 _tmp1_ = _vala_iterable_ref0 (_tmp0_);
621 _param_list = _tmp1_;
622 _tmp2_ = _param_list;
623 _tmp3_ = vala_collection_get_size ((ValaCollection*) _tmp2_);
624 _tmp4_ = _tmp3_;
625 _param_size = _tmp4_;
626 _param_index = -1;
627 while (TRUE) {
628 gint _tmp5_;
629 gint _tmp6_;
630 ValaParameter* param = NULL;
631 ValaList* _tmp7_;
632 gpointer _tmp8_;
633 ValaParameter* _tmp9_;
634 gboolean _tmp10_;
635 gboolean _tmp11_;
636 _param_index = _param_index + 1;
637 _tmp5_ = _param_index;
638 _tmp6_ = _param_size;
639 if (!(_tmp5_ < _tmp6_)) {
640 break;
641 }
642 _tmp7_ = _param_list;
643 _tmp8_ = vala_list_get (_tmp7_, _param_index);
644 param = (ValaParameter*) _tmp8_;
645 _tmp9_ = param;
646 _tmp10_ = vala_parameter_get_ellipsis (_tmp9_);
647 _tmp11_ = _tmp10_;
648 if (!_tmp11_) {
649 ValaScope* _tmp12_;
650 ValaScope* _tmp13_;
651 ValaParameter* _tmp14_;
652 const gchar* _tmp15_;
653 const gchar* _tmp16_;
654 _tmp12_ = vala_symbol_get_scope ((ValaSymbol*) self);
655 _tmp13_ = _tmp12_;
656 _tmp14_ = param;
657 _tmp15_ = vala_symbol_get_name ((ValaSymbol*) _tmp14_);
658 _tmp16_ = _tmp15_;
659 vala_scope_remove (_tmp13_, _tmp16_);
660 }
661 _vala_code_node_unref0 (param);
662 }
663 _vala_iterable_unref0 (_param_list);
664 }
665 _tmp17_ = self->priv->parameters;
666 vala_collection_clear ((ValaCollection*) _tmp17_);
667 }
668
669 gboolean
vala_method_is_variadic(ValaMethod * self)670 vala_method_is_variadic (ValaMethod* self)
671 {
672 gboolean result = FALSE;
673 g_return_val_if_fail (self != NULL, FALSE);
674 {
675 ValaList* _param_list = NULL;
676 ValaList* _tmp0_;
677 ValaList* _tmp1_;
678 gint _param_size = 0;
679 ValaList* _tmp2_;
680 gint _tmp3_;
681 gint _tmp4_;
682 gint _param_index = 0;
683 _tmp0_ = self->priv->parameters;
684 _tmp1_ = _vala_iterable_ref0 (_tmp0_);
685 _param_list = _tmp1_;
686 _tmp2_ = _param_list;
687 _tmp3_ = vala_collection_get_size ((ValaCollection*) _tmp2_);
688 _tmp4_ = _tmp3_;
689 _param_size = _tmp4_;
690 _param_index = -1;
691 while (TRUE) {
692 gint _tmp5_;
693 gint _tmp6_;
694 ValaParameter* param = NULL;
695 ValaList* _tmp7_;
696 gpointer _tmp8_;
697 gboolean _tmp9_ = FALSE;
698 ValaParameter* _tmp10_;
699 gboolean _tmp11_;
700 gboolean _tmp12_;
701 _param_index = _param_index + 1;
702 _tmp5_ = _param_index;
703 _tmp6_ = _param_size;
704 if (!(_tmp5_ < _tmp6_)) {
705 break;
706 }
707 _tmp7_ = _param_list;
708 _tmp8_ = vala_list_get (_tmp7_, _param_index);
709 param = (ValaParameter*) _tmp8_;
710 _tmp10_ = param;
711 _tmp11_ = vala_parameter_get_ellipsis (_tmp10_);
712 _tmp12_ = _tmp11_;
713 if (_tmp12_) {
714 _tmp9_ = TRUE;
715 } else {
716 ValaParameter* _tmp13_;
717 gboolean _tmp14_;
718 gboolean _tmp15_;
719 _tmp13_ = param;
720 _tmp14_ = vala_parameter_get_params_array (_tmp13_);
721 _tmp15_ = _tmp14_;
722 _tmp9_ = _tmp15_;
723 }
724 if (_tmp9_) {
725 result = TRUE;
726 _vala_code_node_unref0 (param);
727 _vala_iterable_unref0 (_param_list);
728 return result;
729 }
730 _vala_code_node_unref0 (param);
731 }
732 _vala_iterable_unref0 (_param_list);
733 }
734 result = FALSE;
735 return result;
736 }
737
738 static void
vala_method_real_accept(ValaCodeNode * base,ValaCodeVisitor * visitor)739 vala_method_real_accept (ValaCodeNode* base,
740 ValaCodeVisitor* visitor)
741 {
742 ValaMethod * self;
743 self = (ValaMethod*) base;
744 g_return_if_fail (visitor != NULL);
745 vala_code_visitor_visit_method (visitor, self);
746 }
747
748 static void
vala_method_real_accept_children(ValaCodeNode * base,ValaCodeVisitor * visitor)749 vala_method_real_accept_children (ValaCodeNode* base,
750 ValaCodeVisitor* visitor)
751 {
752 ValaMethod * self;
753 ValaDataType* _tmp10_;
754 ValaDataType* _tmp11_;
755 ValaDataType* _tmp14_;
756 ValaDataType* _tmp15_;
757 ValaList* _tmp28_;
758 ValaLocalVariable* _tmp39_;
759 ValaLocalVariable* _tmp40_;
760 ValaList* _tmp43_;
761 ValaList* _tmp54_;
762 ValaBlock* _tmp65_;
763 ValaBlock* _tmp66_;
764 self = (ValaMethod*) base;
765 g_return_if_fail (visitor != NULL);
766 {
767 ValaList* _p_list = NULL;
768 ValaList* _tmp0_;
769 ValaList* _tmp1_;
770 gint _p_size = 0;
771 ValaList* _tmp2_;
772 gint _tmp3_;
773 gint _tmp4_;
774 gint _p_index = 0;
775 _tmp0_ = vala_method_get_type_parameters (self);
776 _tmp1_ = _vala_iterable_ref0 (_tmp0_);
777 _p_list = _tmp1_;
778 _tmp2_ = _p_list;
779 _tmp3_ = vala_collection_get_size ((ValaCollection*) _tmp2_);
780 _tmp4_ = _tmp3_;
781 _p_size = _tmp4_;
782 _p_index = -1;
783 while (TRUE) {
784 gint _tmp5_;
785 gint _tmp6_;
786 ValaTypeParameter* p = NULL;
787 ValaList* _tmp7_;
788 gpointer _tmp8_;
789 ValaTypeParameter* _tmp9_;
790 _p_index = _p_index + 1;
791 _tmp5_ = _p_index;
792 _tmp6_ = _p_size;
793 if (!(_tmp5_ < _tmp6_)) {
794 break;
795 }
796 _tmp7_ = _p_list;
797 _tmp8_ = vala_list_get (_tmp7_, _p_index);
798 p = (ValaTypeParameter*) _tmp8_;
799 _tmp9_ = p;
800 vala_code_node_accept ((ValaCodeNode*) _tmp9_, visitor);
801 _vala_code_node_unref0 (p);
802 }
803 _vala_iterable_unref0 (_p_list);
804 }
805 _tmp10_ = vala_method_get_base_interface_type (self);
806 _tmp11_ = _tmp10_;
807 if (_tmp11_ != NULL) {
808 ValaDataType* _tmp12_;
809 ValaDataType* _tmp13_;
810 _tmp12_ = vala_method_get_base_interface_type (self);
811 _tmp13_ = _tmp12_;
812 vala_code_node_accept ((ValaCodeNode*) _tmp13_, visitor);
813 }
814 _tmp14_ = vala_callable_get_return_type ((ValaCallable*) self);
815 _tmp15_ = _tmp14_;
816 if (_tmp15_ != NULL) {
817 ValaDataType* _tmp16_;
818 ValaDataType* _tmp17_;
819 _tmp16_ = vala_callable_get_return_type ((ValaCallable*) self);
820 _tmp17_ = _tmp16_;
821 vala_code_node_accept ((ValaCodeNode*) _tmp17_, visitor);
822 }
823 {
824 ValaList* _param_list = NULL;
825 ValaList* _tmp18_;
826 ValaList* _tmp19_;
827 gint _param_size = 0;
828 ValaList* _tmp20_;
829 gint _tmp21_;
830 gint _tmp22_;
831 gint _param_index = 0;
832 _tmp18_ = self->priv->parameters;
833 _tmp19_ = _vala_iterable_ref0 (_tmp18_);
834 _param_list = _tmp19_;
835 _tmp20_ = _param_list;
836 _tmp21_ = vala_collection_get_size ((ValaCollection*) _tmp20_);
837 _tmp22_ = _tmp21_;
838 _param_size = _tmp22_;
839 _param_index = -1;
840 while (TRUE) {
841 gint _tmp23_;
842 gint _tmp24_;
843 ValaParameter* param = NULL;
844 ValaList* _tmp25_;
845 gpointer _tmp26_;
846 ValaParameter* _tmp27_;
847 _param_index = _param_index + 1;
848 _tmp23_ = _param_index;
849 _tmp24_ = _param_size;
850 if (!(_tmp23_ < _tmp24_)) {
851 break;
852 }
853 _tmp25_ = _param_list;
854 _tmp26_ = vala_list_get (_tmp25_, _param_index);
855 param = (ValaParameter*) _tmp26_;
856 _tmp27_ = param;
857 vala_code_node_accept ((ValaCodeNode*) _tmp27_, visitor);
858 _vala_code_node_unref0 (param);
859 }
860 _vala_iterable_unref0 (_param_list);
861 }
862 _tmp28_ = self->error_types;
863 if (_tmp28_ != NULL) {
864 {
865 ValaList* _error_type_list = NULL;
866 ValaList* _tmp29_;
867 ValaList* _tmp30_;
868 gint _error_type_size = 0;
869 ValaList* _tmp31_;
870 gint _tmp32_;
871 gint _tmp33_;
872 gint _error_type_index = 0;
873 _tmp29_ = self->error_types;
874 _tmp30_ = _vala_iterable_ref0 (_tmp29_);
875 _error_type_list = _tmp30_;
876 _tmp31_ = _error_type_list;
877 _tmp32_ = vala_collection_get_size ((ValaCollection*) _tmp31_);
878 _tmp33_ = _tmp32_;
879 _error_type_size = _tmp33_;
880 _error_type_index = -1;
881 while (TRUE) {
882 gint _tmp34_;
883 gint _tmp35_;
884 ValaDataType* error_type = NULL;
885 ValaList* _tmp36_;
886 gpointer _tmp37_;
887 ValaDataType* _tmp38_;
888 _error_type_index = _error_type_index + 1;
889 _tmp34_ = _error_type_index;
890 _tmp35_ = _error_type_size;
891 if (!(_tmp34_ < _tmp35_)) {
892 break;
893 }
894 _tmp36_ = _error_type_list;
895 _tmp37_ = vala_list_get (_tmp36_, _error_type_index);
896 error_type = (ValaDataType*) _tmp37_;
897 _tmp38_ = error_type;
898 vala_code_node_accept ((ValaCodeNode*) _tmp38_, visitor);
899 _vala_code_node_unref0 (error_type);
900 }
901 _vala_iterable_unref0 (_error_type_list);
902 }
903 }
904 _tmp39_ = vala_subroutine_get_result_var ((ValaSubroutine*) self);
905 _tmp40_ = _tmp39_;
906 if (_tmp40_ != NULL) {
907 ValaLocalVariable* _tmp41_;
908 ValaLocalVariable* _tmp42_;
909 _tmp41_ = vala_subroutine_get_result_var ((ValaSubroutine*) self);
910 _tmp42_ = _tmp41_;
911 vala_code_node_accept ((ValaCodeNode*) _tmp42_, visitor);
912 }
913 _tmp43_ = self->priv->preconditions;
914 if (_tmp43_ != NULL) {
915 {
916 ValaList* _precondition_list = NULL;
917 ValaList* _tmp44_;
918 ValaList* _tmp45_;
919 gint _precondition_size = 0;
920 ValaList* _tmp46_;
921 gint _tmp47_;
922 gint _tmp48_;
923 gint _precondition_index = 0;
924 _tmp44_ = self->priv->preconditions;
925 _tmp45_ = _vala_iterable_ref0 (_tmp44_);
926 _precondition_list = _tmp45_;
927 _tmp46_ = _precondition_list;
928 _tmp47_ = vala_collection_get_size ((ValaCollection*) _tmp46_);
929 _tmp48_ = _tmp47_;
930 _precondition_size = _tmp48_;
931 _precondition_index = -1;
932 while (TRUE) {
933 gint _tmp49_;
934 gint _tmp50_;
935 ValaExpression* precondition = NULL;
936 ValaList* _tmp51_;
937 gpointer _tmp52_;
938 ValaExpression* _tmp53_;
939 _precondition_index = _precondition_index + 1;
940 _tmp49_ = _precondition_index;
941 _tmp50_ = _precondition_size;
942 if (!(_tmp49_ < _tmp50_)) {
943 break;
944 }
945 _tmp51_ = _precondition_list;
946 _tmp52_ = vala_list_get (_tmp51_, _precondition_index);
947 precondition = (ValaExpression*) _tmp52_;
948 _tmp53_ = precondition;
949 vala_code_node_accept ((ValaCodeNode*) _tmp53_, visitor);
950 _vala_code_node_unref0 (precondition);
951 }
952 _vala_iterable_unref0 (_precondition_list);
953 }
954 }
955 _tmp54_ = self->priv->postconditions;
956 if (_tmp54_ != NULL) {
957 {
958 ValaList* _postcondition_list = NULL;
959 ValaList* _tmp55_;
960 ValaList* _tmp56_;
961 gint _postcondition_size = 0;
962 ValaList* _tmp57_;
963 gint _tmp58_;
964 gint _tmp59_;
965 gint _postcondition_index = 0;
966 _tmp55_ = self->priv->postconditions;
967 _tmp56_ = _vala_iterable_ref0 (_tmp55_);
968 _postcondition_list = _tmp56_;
969 _tmp57_ = _postcondition_list;
970 _tmp58_ = vala_collection_get_size ((ValaCollection*) _tmp57_);
971 _tmp59_ = _tmp58_;
972 _postcondition_size = _tmp59_;
973 _postcondition_index = -1;
974 while (TRUE) {
975 gint _tmp60_;
976 gint _tmp61_;
977 ValaExpression* postcondition = NULL;
978 ValaList* _tmp62_;
979 gpointer _tmp63_;
980 ValaExpression* _tmp64_;
981 _postcondition_index = _postcondition_index + 1;
982 _tmp60_ = _postcondition_index;
983 _tmp61_ = _postcondition_size;
984 if (!(_tmp60_ < _tmp61_)) {
985 break;
986 }
987 _tmp62_ = _postcondition_list;
988 _tmp63_ = vala_list_get (_tmp62_, _postcondition_index);
989 postcondition = (ValaExpression*) _tmp63_;
990 _tmp64_ = postcondition;
991 vala_code_node_accept ((ValaCodeNode*) _tmp64_, visitor);
992 _vala_code_node_unref0 (postcondition);
993 }
994 _vala_iterable_unref0 (_postcondition_list);
995 }
996 }
997 _tmp65_ = vala_subroutine_get_body ((ValaSubroutine*) self);
998 _tmp66_ = _tmp65_;
999 if (_tmp66_ != NULL) {
1000 ValaBlock* _tmp67_;
1001 ValaBlock* _tmp68_;
1002 _tmp67_ = vala_subroutine_get_body ((ValaSubroutine*) self);
1003 _tmp68_ = _tmp67_;
1004 vala_code_node_accept ((ValaCodeNode*) _tmp68_, visitor);
1005 }
1006 }
1007
1008 /**
1009 * Checks whether the parameters and return type of this method are
1010 * compatible with the specified method
1011 *
1012 * @param base_method a method
1013 * @param invalid_match error string about which check failed
1014 * @return true if the specified method is compatible to this method
1015 */
1016 gboolean
vala_method_compatible(ValaMethod * self,ValaMethod * base_method,gchar ** invalid_match)1017 vala_method_compatible (ValaMethod* self,
1018 ValaMethod* base_method,
1019 gchar* * invalid_match)
1020 {
1021 gchar* _vala_invalid_match = NULL;
1022 gchar* _tmp0_ = NULL;
1023 gboolean _tmp1_;
1024 gboolean result = FALSE;
1025 g_return_val_if_fail (self != NULL, FALSE);
1026 g_return_val_if_fail (base_method != NULL, FALSE);
1027 _tmp1_ = vala_method_compatible_internal (self, base_method, &_tmp0_, (ValaCodeNode*) self);
1028 _g_free0 (_vala_invalid_match);
1029 _vala_invalid_match = _tmp0_;
1030 result = _tmp1_;
1031 if (invalid_match) {
1032 *invalid_match = _vala_invalid_match;
1033 } else {
1034 _g_free0 (_vala_invalid_match);
1035 }
1036 return result;
1037 }
1038
1039 /**
1040 * Checks whether the parameters and return type of this method are
1041 * compatible with the specified method
1042 *
1043 * @param base_method a method
1044 * @return true if the specified method is compatible to this method
1045 */
1046 gboolean
vala_method_compatible_no_error(ValaMethod * self,ValaMethod * base_method)1047 vala_method_compatible_no_error (ValaMethod* self,
1048 ValaMethod* base_method)
1049 {
1050 gboolean result = FALSE;
1051 g_return_val_if_fail (self != NULL, FALSE);
1052 g_return_val_if_fail (base_method != NULL, FALSE);
1053 result = vala_method_compatible_internal (self, base_method, NULL, NULL);
1054 return result;
1055 }
1056
1057 static gboolean
vala_method_compatible_internal(ValaMethod * self,ValaMethod * base_method,gchar ** invalid_match,ValaCodeNode * node_reference)1058 vala_method_compatible_internal (ValaMethod* self,
1059 ValaMethod* base_method,
1060 gchar* * invalid_match,
1061 ValaCodeNode* node_reference)
1062 {
1063 gchar* _vala_invalid_match = NULL;
1064 ValaMemberBinding _tmp0_;
1065 ValaMemberBinding _tmp1_;
1066 ValaObjectType* object_type = NULL;
1067 ValaSymbol* _tmp3_;
1068 ValaSymbol* _tmp4_;
1069 ValaList* _tmp25_;
1070 gint _tmp26_;
1071 gint _tmp27_;
1072 ValaList* _tmp28_;
1073 gint _tmp29_;
1074 gint _tmp30_;
1075 ValaList* method_type_args = NULL;
1076 ValaDataType* return_type = NULL;
1077 ValaDataType* _tmp55_;
1078 ValaDataType* _tmp56_;
1079 ValaDataType* _tmp57_;
1080 ValaDataType* actual_base_type = NULL;
1081 ValaDataType* _tmp64_;
1082 ValaDataType* _tmp65_;
1083 ValaObjectType* _tmp66_;
1084 ValaList* _tmp67_;
1085 ValaDataType* _tmp68_;
1086 ValaDataType* _tmp69_;
1087 ValaDataType* _tmp70_;
1088 ValaIterator* method_params_it = NULL;
1089 ValaList* _tmp78_;
1090 ValaIterator* _tmp79_;
1091 gint param_index = 0;
1092 ValaIterator* _tmp129_;
1093 ValaArrayList* base_method_errors = NULL;
1094 GEqualFunc _tmp131_;
1095 ValaArrayList* _tmp132_;
1096 ValaArrayList* _tmp133_;
1097 ValaList* _tmp134_;
1098 gboolean _tmp159_;
1099 gboolean _tmp160_;
1100 gboolean result = FALSE;
1101 g_return_val_if_fail (self != NULL, FALSE);
1102 g_return_val_if_fail (base_method != NULL, FALSE);
1103 if (self == base_method) {
1104 _g_free0 (_vala_invalid_match);
1105 _vala_invalid_match = NULL;
1106 result = TRUE;
1107 if (invalid_match) {
1108 *invalid_match = _vala_invalid_match;
1109 } else {
1110 _g_free0 (_vala_invalid_match);
1111 }
1112 return result;
1113 }
1114 _tmp0_ = self->priv->_binding;
1115 _tmp1_ = base_method->priv->_binding;
1116 if (_tmp0_ != _tmp1_) {
1117 gchar* _tmp2_;
1118 _tmp2_ = g_strdup ("incompatible binding");
1119 _g_free0 (_vala_invalid_match);
1120 _vala_invalid_match = _tmp2_;
1121 result = FALSE;
1122 if (invalid_match) {
1123 *invalid_match = _vala_invalid_match;
1124 } else {
1125 _g_free0 (_vala_invalid_match);
1126 }
1127 return result;
1128 }
1129 object_type = NULL;
1130 _tmp3_ = vala_symbol_get_parent_symbol ((ValaSymbol*) self);
1131 _tmp4_ = _tmp3_;
1132 if (VALA_IS_OBJECT_TYPE_SYMBOL (_tmp4_)) {
1133 ValaSymbol* _tmp5_;
1134 ValaSymbol* _tmp6_;
1135 ValaObjectType* _tmp7_;
1136 _tmp5_ = vala_symbol_get_parent_symbol ((ValaSymbol*) self);
1137 _tmp6_ = _tmp5_;
1138 _tmp7_ = vala_object_type_new (G_TYPE_CHECK_INSTANCE_CAST (_tmp6_, VALA_TYPE_OBJECT_TYPE_SYMBOL, ValaObjectTypeSymbol));
1139 _vala_code_node_unref0 (object_type);
1140 object_type = _tmp7_;
1141 {
1142 ValaList* _type_parameter_list = NULL;
1143 ValaObjectType* _tmp8_;
1144 ValaObjectTypeSymbol* _tmp9_;
1145 ValaObjectTypeSymbol* _tmp10_;
1146 ValaList* _tmp11_;
1147 ValaList* _tmp12_;
1148 gint _type_parameter_size = 0;
1149 ValaList* _tmp13_;
1150 gint _tmp14_;
1151 gint _tmp15_;
1152 gint _type_parameter_index = 0;
1153 _tmp8_ = object_type;
1154 _tmp9_ = vala_object_type_get_object_type_symbol (_tmp8_);
1155 _tmp10_ = _tmp9_;
1156 _tmp11_ = vala_object_type_symbol_get_type_parameters (_tmp10_);
1157 _tmp12_ = _vala_iterable_ref0 (_tmp11_);
1158 _type_parameter_list = _tmp12_;
1159 _tmp13_ = _type_parameter_list;
1160 _tmp14_ = vala_collection_get_size ((ValaCollection*) _tmp13_);
1161 _tmp15_ = _tmp14_;
1162 _type_parameter_size = _tmp15_;
1163 _type_parameter_index = -1;
1164 while (TRUE) {
1165 gint _tmp16_;
1166 gint _tmp17_;
1167 ValaTypeParameter* type_parameter = NULL;
1168 ValaList* _tmp18_;
1169 gpointer _tmp19_;
1170 ValaGenericType* type_arg = NULL;
1171 ValaTypeParameter* _tmp20_;
1172 ValaGenericType* _tmp21_;
1173 ValaGenericType* _tmp22_;
1174 ValaObjectType* _tmp23_;
1175 ValaGenericType* _tmp24_;
1176 _type_parameter_index = _type_parameter_index + 1;
1177 _tmp16_ = _type_parameter_index;
1178 _tmp17_ = _type_parameter_size;
1179 if (!(_tmp16_ < _tmp17_)) {
1180 break;
1181 }
1182 _tmp18_ = _type_parameter_list;
1183 _tmp19_ = vala_list_get (_tmp18_, _type_parameter_index);
1184 type_parameter = (ValaTypeParameter*) _tmp19_;
1185 _tmp20_ = type_parameter;
1186 _tmp21_ = vala_generic_type_new (_tmp20_);
1187 type_arg = _tmp21_;
1188 _tmp22_ = type_arg;
1189 vala_data_type_set_value_owned ((ValaDataType*) _tmp22_, TRUE);
1190 _tmp23_ = object_type;
1191 _tmp24_ = type_arg;
1192 vala_data_type_add_type_argument ((ValaDataType*) _tmp23_, (ValaDataType*) _tmp24_);
1193 _vala_code_node_unref0 (type_arg);
1194 _vala_code_node_unref0 (type_parameter);
1195 }
1196 _vala_iterable_unref0 (_type_parameter_list);
1197 }
1198 }
1199 _tmp25_ = vala_method_get_type_parameters (self);
1200 _tmp26_ = vala_collection_get_size ((ValaCollection*) _tmp25_);
1201 _tmp27_ = _tmp26_;
1202 _tmp28_ = vala_method_get_type_parameters (base_method);
1203 _tmp29_ = vala_collection_get_size ((ValaCollection*) _tmp28_);
1204 _tmp30_ = _tmp29_;
1205 if (_tmp27_ < _tmp30_) {
1206 gchar* _tmp31_;
1207 _tmp31_ = g_strdup ("too few type parameters");
1208 _g_free0 (_vala_invalid_match);
1209 _vala_invalid_match = _tmp31_;
1210 result = FALSE;
1211 _vala_code_node_unref0 (object_type);
1212 if (invalid_match) {
1213 *invalid_match = _vala_invalid_match;
1214 } else {
1215 _g_free0 (_vala_invalid_match);
1216 }
1217 return result;
1218 } else {
1219 ValaList* _tmp32_;
1220 gint _tmp33_;
1221 gint _tmp34_;
1222 ValaList* _tmp35_;
1223 gint _tmp36_;
1224 gint _tmp37_;
1225 _tmp32_ = vala_method_get_type_parameters (self);
1226 _tmp33_ = vala_collection_get_size ((ValaCollection*) _tmp32_);
1227 _tmp34_ = _tmp33_;
1228 _tmp35_ = vala_method_get_type_parameters (base_method);
1229 _tmp36_ = vala_collection_get_size ((ValaCollection*) _tmp35_);
1230 _tmp37_ = _tmp36_;
1231 if (_tmp34_ > _tmp37_) {
1232 gchar* _tmp38_;
1233 _tmp38_ = g_strdup ("too many type parameters");
1234 _g_free0 (_vala_invalid_match);
1235 _vala_invalid_match = _tmp38_;
1236 result = FALSE;
1237 _vala_code_node_unref0 (object_type);
1238 if (invalid_match) {
1239 *invalid_match = _vala_invalid_match;
1240 } else {
1241 _g_free0 (_vala_invalid_match);
1242 }
1243 return result;
1244 }
1245 }
1246 method_type_args = NULL;
1247 if (vala_method_has_type_parameters (self)) {
1248 GEqualFunc _tmp39_;
1249 ValaArrayList* _tmp40_;
1250 _tmp39_ = g_direct_equal;
1251 _tmp40_ = vala_array_list_new (VALA_TYPE_DATA_TYPE, (GBoxedCopyFunc) vala_code_node_ref, (GDestroyNotify) vala_code_node_unref, _tmp39_);
1252 _vala_iterable_unref0 (method_type_args);
1253 method_type_args = (ValaList*) _tmp40_;
1254 {
1255 ValaList* _type_parameter_list = NULL;
1256 ValaList* _tmp41_;
1257 ValaList* _tmp42_;
1258 gint _type_parameter_size = 0;
1259 ValaList* _tmp43_;
1260 gint _tmp44_;
1261 gint _tmp45_;
1262 gint _type_parameter_index = 0;
1263 _tmp41_ = vala_method_get_type_parameters (self);
1264 _tmp42_ = _vala_iterable_ref0 (_tmp41_);
1265 _type_parameter_list = _tmp42_;
1266 _tmp43_ = _type_parameter_list;
1267 _tmp44_ = vala_collection_get_size ((ValaCollection*) _tmp43_);
1268 _tmp45_ = _tmp44_;
1269 _type_parameter_size = _tmp45_;
1270 _type_parameter_index = -1;
1271 while (TRUE) {
1272 gint _tmp46_;
1273 gint _tmp47_;
1274 ValaTypeParameter* type_parameter = NULL;
1275 ValaList* _tmp48_;
1276 gpointer _tmp49_;
1277 ValaGenericType* type_arg = NULL;
1278 ValaTypeParameter* _tmp50_;
1279 ValaGenericType* _tmp51_;
1280 ValaGenericType* _tmp52_;
1281 ValaList* _tmp53_;
1282 ValaGenericType* _tmp54_;
1283 _type_parameter_index = _type_parameter_index + 1;
1284 _tmp46_ = _type_parameter_index;
1285 _tmp47_ = _type_parameter_size;
1286 if (!(_tmp46_ < _tmp47_)) {
1287 break;
1288 }
1289 _tmp48_ = _type_parameter_list;
1290 _tmp49_ = vala_list_get (_tmp48_, _type_parameter_index);
1291 type_parameter = (ValaTypeParameter*) _tmp49_;
1292 _tmp50_ = type_parameter;
1293 _tmp51_ = vala_generic_type_new (_tmp50_);
1294 type_arg = _tmp51_;
1295 _tmp52_ = type_arg;
1296 vala_data_type_set_value_owned ((ValaDataType*) _tmp52_, TRUE);
1297 _tmp53_ = method_type_args;
1298 _tmp54_ = type_arg;
1299 vala_collection_add ((ValaCollection*) _tmp53_, (ValaDataType*) _tmp54_);
1300 _vala_code_node_unref0 (type_arg);
1301 _vala_code_node_unref0 (type_parameter);
1302 }
1303 _vala_iterable_unref0 (_type_parameter_list);
1304 }
1305 }
1306 _tmp55_ = vala_callable_get_return_type ((ValaCallable*) self);
1307 _tmp56_ = _tmp55_;
1308 _tmp57_ = vala_data_type_copy (_tmp56_);
1309 return_type = _tmp57_;
1310 if (vala_code_node_has_attribute_argument ((ValaCodeNode*) self, "CCode", "returns_floating_reference")) {
1311 ValaDataType* _tmp58_;
1312 gboolean _tmp59_;
1313 gboolean _tmp60_;
1314 _tmp58_ = return_type;
1315 _tmp59_ = vala_method_get_returns_floating_reference (self);
1316 _tmp60_ = _tmp59_;
1317 vala_data_type_set_floating_reference (_tmp58_, _tmp60_);
1318 } else {
1319 ValaDataType* _tmp61_;
1320 gboolean _tmp62_;
1321 gboolean _tmp63_;
1322 _tmp61_ = return_type;
1323 _tmp62_ = vala_method_get_returns_floating_reference (base_method);
1324 _tmp63_ = _tmp62_;
1325 vala_data_type_set_floating_reference (_tmp61_, _tmp63_);
1326 }
1327 _tmp64_ = vala_callable_get_return_type ((ValaCallable*) base_method);
1328 _tmp65_ = _tmp64_;
1329 _tmp66_ = object_type;
1330 _tmp67_ = method_type_args;
1331 _tmp68_ = vala_data_type_get_actual_type (_tmp65_, (ValaDataType*) _tmp66_, _tmp67_, node_reference);
1332 actual_base_type = _tmp68_;
1333 _tmp69_ = return_type;
1334 _tmp70_ = actual_base_type;
1335 if (!vala_data_type_equals (_tmp69_, _tmp70_)) {
1336 ValaDataType* _tmp71_;
1337 gchar* _tmp72_;
1338 gchar* _tmp73_;
1339 ValaDataType* _tmp74_;
1340 gchar* _tmp75_;
1341 gchar* _tmp76_;
1342 gchar* _tmp77_;
1343 _tmp71_ = actual_base_type;
1344 _tmp72_ = vala_data_type_to_prototype_string (_tmp71_, NULL);
1345 _tmp73_ = _tmp72_;
1346 _tmp74_ = return_type;
1347 _tmp75_ = vala_data_type_to_prototype_string (_tmp74_, NULL);
1348 _tmp76_ = _tmp75_;
1349 _tmp77_ = g_strdup_printf ("Base method expected return type `%s', but `%s' was provided", _tmp73_, _tmp76_);
1350 _g_free0 (_vala_invalid_match);
1351 _vala_invalid_match = _tmp77_;
1352 _g_free0 (_tmp76_);
1353 _g_free0 (_tmp73_);
1354 result = FALSE;
1355 _vala_code_node_unref0 (actual_base_type);
1356 _vala_code_node_unref0 (return_type);
1357 _vala_iterable_unref0 (method_type_args);
1358 _vala_code_node_unref0 (object_type);
1359 if (invalid_match) {
1360 *invalid_match = _vala_invalid_match;
1361 } else {
1362 _g_free0 (_vala_invalid_match);
1363 }
1364 return result;
1365 }
1366 _tmp78_ = self->priv->parameters;
1367 _tmp79_ = vala_iterable_iterator ((ValaIterable*) _tmp78_);
1368 method_params_it = _tmp79_;
1369 param_index = 1;
1370 {
1371 ValaList* _base_param_list = NULL;
1372 ValaList* _tmp80_;
1373 ValaList* _tmp81_;
1374 gint _base_param_size = 0;
1375 ValaList* _tmp82_;
1376 gint _tmp83_;
1377 gint _tmp84_;
1378 gint _base_param_index = 0;
1379 _tmp80_ = base_method->priv->parameters;
1380 _tmp81_ = _vala_iterable_ref0 (_tmp80_);
1381 _base_param_list = _tmp81_;
1382 _tmp82_ = _base_param_list;
1383 _tmp83_ = vala_collection_get_size ((ValaCollection*) _tmp82_);
1384 _tmp84_ = _tmp83_;
1385 _base_param_size = _tmp84_;
1386 _base_param_index = -1;
1387 while (TRUE) {
1388 gint _tmp85_;
1389 gint _tmp86_;
1390 ValaParameter* base_param = NULL;
1391 ValaList* _tmp87_;
1392 gpointer _tmp88_;
1393 ValaIterator* _tmp89_;
1394 ValaParameter* param = NULL;
1395 ValaIterator* _tmp91_;
1396 gpointer _tmp92_;
1397 ValaParameter* _tmp93_;
1398 gboolean _tmp94_;
1399 gboolean _tmp95_;
1400 ValaParameter* _tmp96_;
1401 gboolean _tmp97_;
1402 gboolean _tmp98_;
1403 ValaParameter* _tmp100_;
1404 gboolean _tmp101_;
1405 gboolean _tmp102_;
1406 ValaParameter* _tmp103_;
1407 gboolean _tmp104_;
1408 gboolean _tmp105_;
1409 ValaParameter* _tmp107_;
1410 gboolean _tmp108_;
1411 gboolean _tmp109_;
1412 gint _tmp128_;
1413 _base_param_index = _base_param_index + 1;
1414 _tmp85_ = _base_param_index;
1415 _tmp86_ = _base_param_size;
1416 if (!(_tmp85_ < _tmp86_)) {
1417 break;
1418 }
1419 _tmp87_ = _base_param_list;
1420 _tmp88_ = vala_list_get (_tmp87_, _base_param_index);
1421 base_param = (ValaParameter*) _tmp88_;
1422 _tmp89_ = method_params_it;
1423 if (!vala_iterator_next (_tmp89_)) {
1424 gchar* _tmp90_;
1425 _tmp90_ = g_strdup ("too few parameters");
1426 _g_free0 (_vala_invalid_match);
1427 _vala_invalid_match = _tmp90_;
1428 result = FALSE;
1429 _vala_code_node_unref0 (base_param);
1430 _vala_iterable_unref0 (_base_param_list);
1431 _vala_iterator_unref0 (method_params_it);
1432 _vala_code_node_unref0 (actual_base_type);
1433 _vala_code_node_unref0 (return_type);
1434 _vala_iterable_unref0 (method_type_args);
1435 _vala_code_node_unref0 (object_type);
1436 if (invalid_match) {
1437 *invalid_match = _vala_invalid_match;
1438 } else {
1439 _g_free0 (_vala_invalid_match);
1440 }
1441 return result;
1442 }
1443 _tmp91_ = method_params_it;
1444 _tmp92_ = vala_iterator_get (_tmp91_);
1445 param = (ValaParameter*) _tmp92_;
1446 _tmp93_ = base_param;
1447 _tmp94_ = vala_parameter_get_ellipsis (_tmp93_);
1448 _tmp95_ = _tmp94_;
1449 _tmp96_ = param;
1450 _tmp97_ = vala_parameter_get_ellipsis (_tmp96_);
1451 _tmp98_ = _tmp97_;
1452 if (_tmp95_ != _tmp98_) {
1453 gchar* _tmp99_;
1454 _tmp99_ = g_strdup ("ellipsis parameter mismatch");
1455 _g_free0 (_vala_invalid_match);
1456 _vala_invalid_match = _tmp99_;
1457 result = FALSE;
1458 _vala_code_node_unref0 (param);
1459 _vala_code_node_unref0 (base_param);
1460 _vala_iterable_unref0 (_base_param_list);
1461 _vala_iterator_unref0 (method_params_it);
1462 _vala_code_node_unref0 (actual_base_type);
1463 _vala_code_node_unref0 (return_type);
1464 _vala_iterable_unref0 (method_type_args);
1465 _vala_code_node_unref0 (object_type);
1466 if (invalid_match) {
1467 *invalid_match = _vala_invalid_match;
1468 } else {
1469 _g_free0 (_vala_invalid_match);
1470 }
1471 return result;
1472 }
1473 _tmp100_ = base_param;
1474 _tmp101_ = vala_parameter_get_params_array (_tmp100_);
1475 _tmp102_ = _tmp101_;
1476 _tmp103_ = param;
1477 _tmp104_ = vala_parameter_get_params_array (_tmp103_);
1478 _tmp105_ = _tmp104_;
1479 if (_tmp102_ != _tmp105_) {
1480 gchar* _tmp106_;
1481 _tmp106_ = g_strdup ("params array parameter mismatch");
1482 _g_free0 (_vala_invalid_match);
1483 _vala_invalid_match = _tmp106_;
1484 result = FALSE;
1485 _vala_code_node_unref0 (param);
1486 _vala_code_node_unref0 (base_param);
1487 _vala_iterable_unref0 (_base_param_list);
1488 _vala_iterator_unref0 (method_params_it);
1489 _vala_code_node_unref0 (actual_base_type);
1490 _vala_code_node_unref0 (return_type);
1491 _vala_iterable_unref0 (method_type_args);
1492 _vala_code_node_unref0 (object_type);
1493 if (invalid_match) {
1494 *invalid_match = _vala_invalid_match;
1495 } else {
1496 _g_free0 (_vala_invalid_match);
1497 }
1498 return result;
1499 }
1500 _tmp107_ = base_param;
1501 _tmp108_ = vala_parameter_get_ellipsis (_tmp107_);
1502 _tmp109_ = _tmp108_;
1503 if (!_tmp109_) {
1504 ValaParameter* _tmp110_;
1505 ValaParameterDirection _tmp111_;
1506 ValaParameterDirection _tmp112_;
1507 ValaParameter* _tmp113_;
1508 ValaParameterDirection _tmp114_;
1509 ValaParameterDirection _tmp115_;
1510 ValaParameter* _tmp117_;
1511 ValaDataType* _tmp118_;
1512 ValaDataType* _tmp119_;
1513 ValaObjectType* _tmp120_;
1514 ValaList* _tmp121_;
1515 ValaDataType* _tmp122_;
1516 ValaDataType* _tmp123_;
1517 ValaParameter* _tmp124_;
1518 ValaDataType* _tmp125_;
1519 ValaDataType* _tmp126_;
1520 _tmp110_ = base_param;
1521 _tmp111_ = vala_parameter_get_direction (_tmp110_);
1522 _tmp112_ = _tmp111_;
1523 _tmp113_ = param;
1524 _tmp114_ = vala_parameter_get_direction (_tmp113_);
1525 _tmp115_ = _tmp114_;
1526 if (_tmp112_ != _tmp115_) {
1527 gchar* _tmp116_;
1528 _tmp116_ = g_strdup_printf ("incompatible direction of parameter %d", param_index);
1529 _g_free0 (_vala_invalid_match);
1530 _vala_invalid_match = _tmp116_;
1531 result = FALSE;
1532 _vala_code_node_unref0 (param);
1533 _vala_code_node_unref0 (base_param);
1534 _vala_iterable_unref0 (_base_param_list);
1535 _vala_iterator_unref0 (method_params_it);
1536 _vala_code_node_unref0 (actual_base_type);
1537 _vala_code_node_unref0 (return_type);
1538 _vala_iterable_unref0 (method_type_args);
1539 _vala_code_node_unref0 (object_type);
1540 if (invalid_match) {
1541 *invalid_match = _vala_invalid_match;
1542 } else {
1543 _g_free0 (_vala_invalid_match);
1544 }
1545 return result;
1546 }
1547 _tmp117_ = base_param;
1548 _tmp118_ = vala_variable_get_variable_type ((ValaVariable*) _tmp117_);
1549 _tmp119_ = _tmp118_;
1550 _tmp120_ = object_type;
1551 _tmp121_ = method_type_args;
1552 _tmp122_ = vala_data_type_get_actual_type (_tmp119_, (ValaDataType*) _tmp120_, _tmp121_, node_reference);
1553 _vala_code_node_unref0 (actual_base_type);
1554 actual_base_type = _tmp122_;
1555 _tmp123_ = actual_base_type;
1556 _tmp124_ = param;
1557 _tmp125_ = vala_variable_get_variable_type ((ValaVariable*) _tmp124_);
1558 _tmp126_ = _tmp125_;
1559 if (!vala_data_type_equals (_tmp123_, _tmp126_)) {
1560 gchar* _tmp127_;
1561 _tmp127_ = g_strdup_printf ("incompatible type of parameter %d", param_index);
1562 _g_free0 (_vala_invalid_match);
1563 _vala_invalid_match = _tmp127_;
1564 result = FALSE;
1565 _vala_code_node_unref0 (param);
1566 _vala_code_node_unref0 (base_param);
1567 _vala_iterable_unref0 (_base_param_list);
1568 _vala_iterator_unref0 (method_params_it);
1569 _vala_code_node_unref0 (actual_base_type);
1570 _vala_code_node_unref0 (return_type);
1571 _vala_iterable_unref0 (method_type_args);
1572 _vala_code_node_unref0 (object_type);
1573 if (invalid_match) {
1574 *invalid_match = _vala_invalid_match;
1575 } else {
1576 _g_free0 (_vala_invalid_match);
1577 }
1578 return result;
1579 }
1580 }
1581 _tmp128_ = param_index;
1582 param_index = _tmp128_ + 1;
1583 _vala_code_node_unref0 (param);
1584 _vala_code_node_unref0 (base_param);
1585 }
1586 _vala_iterable_unref0 (_base_param_list);
1587 }
1588 _tmp129_ = method_params_it;
1589 if (vala_iterator_next (_tmp129_)) {
1590 gchar* _tmp130_;
1591 _tmp130_ = g_strdup ("too many parameters");
1592 _g_free0 (_vala_invalid_match);
1593 _vala_invalid_match = _tmp130_;
1594 result = FALSE;
1595 _vala_iterator_unref0 (method_params_it);
1596 _vala_code_node_unref0 (actual_base_type);
1597 _vala_code_node_unref0 (return_type);
1598 _vala_iterable_unref0 (method_type_args);
1599 _vala_code_node_unref0 (object_type);
1600 if (invalid_match) {
1601 *invalid_match = _vala_invalid_match;
1602 } else {
1603 _g_free0 (_vala_invalid_match);
1604 }
1605 return result;
1606 }
1607 _tmp131_ = g_direct_equal;
1608 _tmp132_ = vala_array_list_new (VALA_TYPE_DATA_TYPE, (GBoxedCopyFunc) vala_code_node_ref, (GDestroyNotify) vala_code_node_unref, _tmp131_);
1609 base_method_errors = _tmp132_;
1610 _tmp133_ = base_method_errors;
1611 vala_code_node_get_error_types ((ValaCodeNode*) base_method, (ValaCollection*) _tmp133_, NULL);
1612 _tmp134_ = self->error_types;
1613 if (_tmp134_ != NULL) {
1614 {
1615 ValaList* _method_error_type_list = NULL;
1616 ValaList* _tmp135_;
1617 ValaList* _tmp136_;
1618 gint _method_error_type_size = 0;
1619 ValaList* _tmp137_;
1620 gint _tmp138_;
1621 gint _tmp139_;
1622 gint _method_error_type_index = 0;
1623 _tmp135_ = self->error_types;
1624 _tmp136_ = _vala_iterable_ref0 (_tmp135_);
1625 _method_error_type_list = _tmp136_;
1626 _tmp137_ = _method_error_type_list;
1627 _tmp138_ = vala_collection_get_size ((ValaCollection*) _tmp137_);
1628 _tmp139_ = _tmp138_;
1629 _method_error_type_size = _tmp139_;
1630 _method_error_type_index = -1;
1631 while (TRUE) {
1632 gint _tmp140_;
1633 gint _tmp141_;
1634 ValaDataType* method_error_type = NULL;
1635 ValaList* _tmp142_;
1636 gpointer _tmp143_;
1637 gboolean match = FALSE;
1638 _method_error_type_index = _method_error_type_index + 1;
1639 _tmp140_ = _method_error_type_index;
1640 _tmp141_ = _method_error_type_size;
1641 if (!(_tmp140_ < _tmp141_)) {
1642 break;
1643 }
1644 _tmp142_ = _method_error_type_list;
1645 _tmp143_ = vala_list_get (_tmp142_, _method_error_type_index);
1646 method_error_type = (ValaDataType*) _tmp143_;
1647 match = FALSE;
1648 {
1649 ValaArrayList* _base_method_error_type_list = NULL;
1650 ValaArrayList* _tmp144_;
1651 ValaArrayList* _tmp145_;
1652 gint _base_method_error_type_size = 0;
1653 ValaArrayList* _tmp146_;
1654 gint _tmp147_;
1655 gint _tmp148_;
1656 gint _base_method_error_type_index = 0;
1657 _tmp144_ = base_method_errors;
1658 _tmp145_ = _vala_iterable_ref0 (_tmp144_);
1659 _base_method_error_type_list = _tmp145_;
1660 _tmp146_ = _base_method_error_type_list;
1661 _tmp147_ = vala_collection_get_size ((ValaCollection*) _tmp146_);
1662 _tmp148_ = _tmp147_;
1663 _base_method_error_type_size = _tmp148_;
1664 _base_method_error_type_index = -1;
1665 while (TRUE) {
1666 gint _tmp149_;
1667 gint _tmp150_;
1668 ValaDataType* base_method_error_type = NULL;
1669 ValaArrayList* _tmp151_;
1670 gpointer _tmp152_;
1671 ValaDataType* _tmp153_;
1672 ValaDataType* _tmp154_;
1673 _base_method_error_type_index = _base_method_error_type_index + 1;
1674 _tmp149_ = _base_method_error_type_index;
1675 _tmp150_ = _base_method_error_type_size;
1676 if (!(_tmp149_ < _tmp150_)) {
1677 break;
1678 }
1679 _tmp151_ = _base_method_error_type_list;
1680 _tmp152_ = vala_list_get ((ValaList*) _tmp151_, _base_method_error_type_index);
1681 base_method_error_type = (ValaDataType*) _tmp152_;
1682 _tmp153_ = method_error_type;
1683 _tmp154_ = base_method_error_type;
1684 if (vala_data_type_compatible (_tmp153_, _tmp154_)) {
1685 match = TRUE;
1686 _vala_code_node_unref0 (base_method_error_type);
1687 break;
1688 }
1689 _vala_code_node_unref0 (base_method_error_type);
1690 }
1691 _vala_iterable_unref0 (_base_method_error_type_list);
1692 }
1693 if (!match) {
1694 ValaDataType* _tmp155_;
1695 gchar* _tmp156_;
1696 gchar* _tmp157_;
1697 gchar* _tmp158_;
1698 _tmp155_ = method_error_type;
1699 _tmp156_ = vala_code_node_to_string ((ValaCodeNode*) _tmp155_);
1700 _tmp157_ = _tmp156_;
1701 _tmp158_ = g_strdup_printf ("incompatible error type `%s'", _tmp157_);
1702 _g_free0 (_vala_invalid_match);
1703 _vala_invalid_match = _tmp158_;
1704 _g_free0 (_tmp157_);
1705 result = FALSE;
1706 _vala_code_node_unref0 (method_error_type);
1707 _vala_iterable_unref0 (_method_error_type_list);
1708 _vala_iterable_unref0 (base_method_errors);
1709 _vala_iterator_unref0 (method_params_it);
1710 _vala_code_node_unref0 (actual_base_type);
1711 _vala_code_node_unref0 (return_type);
1712 _vala_iterable_unref0 (method_type_args);
1713 _vala_code_node_unref0 (object_type);
1714 if (invalid_match) {
1715 *invalid_match = _vala_invalid_match;
1716 } else {
1717 _g_free0 (_vala_invalid_match);
1718 }
1719 return result;
1720 }
1721 _vala_code_node_unref0 (method_error_type);
1722 }
1723 _vala_iterable_unref0 (_method_error_type_list);
1724 }
1725 }
1726 _tmp159_ = base_method->priv->_coroutine;
1727 _tmp160_ = self->priv->_coroutine;
1728 if (_tmp159_ != _tmp160_) {
1729 gchar* _tmp161_;
1730 _tmp161_ = g_strdup ("async mismatch");
1731 _g_free0 (_vala_invalid_match);
1732 _vala_invalid_match = _tmp161_;
1733 result = FALSE;
1734 _vala_iterable_unref0 (base_method_errors);
1735 _vala_iterator_unref0 (method_params_it);
1736 _vala_code_node_unref0 (actual_base_type);
1737 _vala_code_node_unref0 (return_type);
1738 _vala_iterable_unref0 (method_type_args);
1739 _vala_code_node_unref0 (object_type);
1740 if (invalid_match) {
1741 *invalid_match = _vala_invalid_match;
1742 } else {
1743 _g_free0 (_vala_invalid_match);
1744 }
1745 return result;
1746 }
1747 _g_free0 (_vala_invalid_match);
1748 _vala_invalid_match = NULL;
1749 result = TRUE;
1750 _vala_iterable_unref0 (base_method_errors);
1751 _vala_iterator_unref0 (method_params_it);
1752 _vala_code_node_unref0 (actual_base_type);
1753 _vala_code_node_unref0 (return_type);
1754 _vala_iterable_unref0 (method_type_args);
1755 _vala_code_node_unref0 (object_type);
1756 if (invalid_match) {
1757 *invalid_match = _vala_invalid_match;
1758 } else {
1759 _g_free0 (_vala_invalid_match);
1760 }
1761 return result;
1762 }
1763
1764 /**
1765 * Appends the specified parameter to the list of type parameters.
1766 *
1767 * @param p a type parameter
1768 */
1769 void
vala_method_add_type_parameter(ValaMethod * self,ValaTypeParameter * p)1770 vala_method_add_type_parameter (ValaMethod* self,
1771 ValaTypeParameter* p)
1772 {
1773 ValaList* _tmp0_;
1774 ValaList* _tmp3_;
1775 ValaScope* _tmp4_;
1776 ValaScope* _tmp5_;
1777 const gchar* _tmp6_;
1778 const gchar* _tmp7_;
1779 g_return_if_fail (self != NULL);
1780 g_return_if_fail (p != NULL);
1781 _tmp0_ = self->priv->type_parameters;
1782 if (_tmp0_ == NULL) {
1783 GEqualFunc _tmp1_;
1784 ValaArrayList* _tmp2_;
1785 _tmp1_ = g_direct_equal;
1786 _tmp2_ = vala_array_list_new (VALA_TYPE_TYPEPARAMETER, (GBoxedCopyFunc) vala_code_node_ref, (GDestroyNotify) vala_code_node_unref, _tmp1_);
1787 _vala_iterable_unref0 (self->priv->type_parameters);
1788 self->priv->type_parameters = (ValaList*) _tmp2_;
1789 }
1790 _tmp3_ = self->priv->type_parameters;
1791 vala_collection_add ((ValaCollection*) _tmp3_, p);
1792 _tmp4_ = vala_symbol_get_scope ((ValaSymbol*) self);
1793 _tmp5_ = _tmp4_;
1794 _tmp6_ = vala_symbol_get_name ((ValaSymbol*) p);
1795 _tmp7_ = _tmp6_;
1796 vala_scope_add (_tmp5_, _tmp7_, (ValaSymbol*) p);
1797 }
1798
1799 /**
1800 * Returns the type parameter list.
1801 *
1802 * @return list of type parameters
1803 */
1804 ValaList*
vala_method_get_type_parameters(ValaMethod * self)1805 vala_method_get_type_parameters (ValaMethod* self)
1806 {
1807 ValaList* _tmp0_;
1808 ValaList* _tmp2_;
1809 ValaList* _tmp5_;
1810 ValaList* result = NULL;
1811 g_return_val_if_fail (self != NULL, NULL);
1812 _tmp0_ = self->priv->type_parameters;
1813 if (_tmp0_ != NULL) {
1814 ValaList* _tmp1_;
1815 _tmp1_ = self->priv->type_parameters;
1816 result = _tmp1_;
1817 return result;
1818 }
1819 _tmp2_ = vala_method__empty_type_parameter_list;
1820 if (_tmp2_ == NULL) {
1821 GEqualFunc _tmp3_;
1822 ValaArrayList* _tmp4_;
1823 _tmp3_ = g_direct_equal;
1824 _tmp4_ = vala_array_list_new (VALA_TYPE_TYPEPARAMETER, (GBoxedCopyFunc) vala_code_node_ref, (GDestroyNotify) vala_code_node_unref, _tmp3_);
1825 _vala_iterable_unref0 (vala_method__empty_type_parameter_list);
1826 vala_method__empty_type_parameter_list = (ValaList*) _tmp4_;
1827 }
1828 _tmp5_ = vala_method__empty_type_parameter_list;
1829 result = _tmp5_;
1830 return result;
1831 }
1832
1833 gint
vala_method_get_type_parameter_index(ValaMethod * self,const gchar * name)1834 vala_method_get_type_parameter_index (ValaMethod* self,
1835 const gchar* name)
1836 {
1837 ValaList* _tmp0_;
1838 gint i = 0;
1839 gint result = 0;
1840 g_return_val_if_fail (self != NULL, 0);
1841 g_return_val_if_fail (name != NULL, 0);
1842 _tmp0_ = self->priv->type_parameters;
1843 if (_tmp0_ == NULL) {
1844 result = -1;
1845 return result;
1846 }
1847 i = 0;
1848 {
1849 ValaList* _parameter_list = NULL;
1850 ValaList* _tmp1_;
1851 ValaList* _tmp2_;
1852 gint _parameter_size = 0;
1853 ValaList* _tmp3_;
1854 gint _tmp4_;
1855 gint _tmp5_;
1856 gint _parameter_index = 0;
1857 _tmp1_ = self->priv->type_parameters;
1858 _tmp2_ = _vala_iterable_ref0 (_tmp1_);
1859 _parameter_list = _tmp2_;
1860 _tmp3_ = _parameter_list;
1861 _tmp4_ = vala_collection_get_size ((ValaCollection*) _tmp3_);
1862 _tmp5_ = _tmp4_;
1863 _parameter_size = _tmp5_;
1864 _parameter_index = -1;
1865 while (TRUE) {
1866 gint _tmp6_;
1867 gint _tmp7_;
1868 ValaTypeParameter* parameter = NULL;
1869 ValaList* _tmp8_;
1870 gpointer _tmp9_;
1871 ValaTypeParameter* _tmp10_;
1872 const gchar* _tmp11_;
1873 const gchar* _tmp12_;
1874 gint _tmp13_;
1875 _parameter_index = _parameter_index + 1;
1876 _tmp6_ = _parameter_index;
1877 _tmp7_ = _parameter_size;
1878 if (!(_tmp6_ < _tmp7_)) {
1879 break;
1880 }
1881 _tmp8_ = _parameter_list;
1882 _tmp9_ = vala_list_get (_tmp8_, _parameter_index);
1883 parameter = (ValaTypeParameter*) _tmp9_;
1884 _tmp10_ = parameter;
1885 _tmp11_ = vala_symbol_get_name ((ValaSymbol*) _tmp10_);
1886 _tmp12_ = _tmp11_;
1887 if (g_strcmp0 (_tmp12_, name) == 0) {
1888 result = i;
1889 _vala_code_node_unref0 (parameter);
1890 _vala_iterable_unref0 (_parameter_list);
1891 return result;
1892 }
1893 _tmp13_ = i;
1894 i = _tmp13_ + 1;
1895 _vala_code_node_unref0 (parameter);
1896 }
1897 _vala_iterable_unref0 (_parameter_list);
1898 }
1899 result = -1;
1900 return result;
1901 }
1902
1903 gboolean
vala_method_has_type_parameters(ValaMethod * self)1904 vala_method_has_type_parameters (ValaMethod* self)
1905 {
1906 gboolean _tmp0_ = FALSE;
1907 ValaList* _tmp1_;
1908 gboolean result = FALSE;
1909 g_return_val_if_fail (self != NULL, FALSE);
1910 _tmp1_ = self->priv->type_parameters;
1911 if (_tmp1_ != NULL) {
1912 ValaList* _tmp2_;
1913 gint _tmp3_;
1914 gint _tmp4_;
1915 _tmp2_ = self->priv->type_parameters;
1916 _tmp3_ = vala_collection_get_size ((ValaCollection*) _tmp2_);
1917 _tmp4_ = _tmp3_;
1918 _tmp0_ = _tmp4_ > 0;
1919 } else {
1920 _tmp0_ = FALSE;
1921 }
1922 result = _tmp0_;
1923 return result;
1924 }
1925
1926 /**
1927 * Adds a precondition to this method.
1928 *
1929 * @param precondition a boolean precondition expression
1930 */
1931 void
vala_method_add_precondition(ValaMethod * self,ValaExpression * precondition)1932 vala_method_add_precondition (ValaMethod* self,
1933 ValaExpression* precondition)
1934 {
1935 ValaList* _tmp0_;
1936 ValaList* _tmp3_;
1937 g_return_if_fail (self != NULL);
1938 g_return_if_fail (precondition != NULL);
1939 _tmp0_ = self->priv->preconditions;
1940 if (_tmp0_ == NULL) {
1941 GEqualFunc _tmp1_;
1942 ValaArrayList* _tmp2_;
1943 _tmp1_ = g_direct_equal;
1944 _tmp2_ = vala_array_list_new (VALA_TYPE_EXPRESSION, (GBoxedCopyFunc) vala_code_node_ref, (GDestroyNotify) vala_code_node_unref, _tmp1_);
1945 _vala_iterable_unref0 (self->priv->preconditions);
1946 self->priv->preconditions = (ValaList*) _tmp2_;
1947 }
1948 _tmp3_ = self->priv->preconditions;
1949 vala_collection_add ((ValaCollection*) _tmp3_, precondition);
1950 vala_code_node_set_parent_node ((ValaCodeNode*) precondition, (ValaCodeNode*) self);
1951 }
1952
1953 /**
1954 * Returns the list of preconditions of this method.
1955 *
1956 * @return list of preconditions
1957 */
1958 ValaList*
vala_method_get_preconditions(ValaMethod * self)1959 vala_method_get_preconditions (ValaMethod* self)
1960 {
1961 ValaList* _tmp0_;
1962 ValaList* _tmp2_;
1963 ValaList* _tmp5_;
1964 ValaList* result = NULL;
1965 g_return_val_if_fail (self != NULL, NULL);
1966 _tmp0_ = self->priv->preconditions;
1967 if (_tmp0_ != NULL) {
1968 ValaList* _tmp1_;
1969 _tmp1_ = self->priv->preconditions;
1970 result = _tmp1_;
1971 return result;
1972 }
1973 _tmp2_ = vala_method__empty_expression_list;
1974 if (_tmp2_ == NULL) {
1975 GEqualFunc _tmp3_;
1976 ValaArrayList* _tmp4_;
1977 _tmp3_ = g_direct_equal;
1978 _tmp4_ = vala_array_list_new (VALA_TYPE_EXPRESSION, (GBoxedCopyFunc) vala_code_node_ref, (GDestroyNotify) vala_code_node_unref, _tmp3_);
1979 _vala_iterable_unref0 (vala_method__empty_expression_list);
1980 vala_method__empty_expression_list = (ValaList*) _tmp4_;
1981 }
1982 _tmp5_ = vala_method__empty_expression_list;
1983 result = _tmp5_;
1984 return result;
1985 }
1986
1987 /**
1988 * Adds a postcondition to this method.
1989 *
1990 * @param postcondition a boolean postcondition expression
1991 */
1992 void
vala_method_add_postcondition(ValaMethod * self,ValaExpression * postcondition)1993 vala_method_add_postcondition (ValaMethod* self,
1994 ValaExpression* postcondition)
1995 {
1996 ValaList* _tmp0_;
1997 ValaList* _tmp3_;
1998 g_return_if_fail (self != NULL);
1999 g_return_if_fail (postcondition != NULL);
2000 _tmp0_ = self->priv->postconditions;
2001 if (_tmp0_ == NULL) {
2002 GEqualFunc _tmp1_;
2003 ValaArrayList* _tmp2_;
2004 _tmp1_ = g_direct_equal;
2005 _tmp2_ = vala_array_list_new (VALA_TYPE_EXPRESSION, (GBoxedCopyFunc) vala_code_node_ref, (GDestroyNotify) vala_code_node_unref, _tmp1_);
2006 _vala_iterable_unref0 (self->priv->postconditions);
2007 self->priv->postconditions = (ValaList*) _tmp2_;
2008 }
2009 _tmp3_ = self->priv->postconditions;
2010 vala_collection_add ((ValaCollection*) _tmp3_, postcondition);
2011 vala_code_node_set_parent_node ((ValaCodeNode*) postcondition, (ValaCodeNode*) self);
2012 }
2013
2014 /**
2015 * Returns the list of postconditions of this method.
2016 *
2017 * @return list of postconditions
2018 */
2019 ValaList*
vala_method_get_postconditions(ValaMethod * self)2020 vala_method_get_postconditions (ValaMethod* self)
2021 {
2022 ValaList* _tmp0_;
2023 ValaList* _tmp2_;
2024 ValaList* _tmp5_;
2025 ValaList* result = NULL;
2026 g_return_val_if_fail (self != NULL, NULL);
2027 _tmp0_ = self->priv->postconditions;
2028 if (_tmp0_ != NULL) {
2029 ValaList* _tmp1_;
2030 _tmp1_ = self->priv->postconditions;
2031 result = _tmp1_;
2032 return result;
2033 }
2034 _tmp2_ = vala_method__empty_expression_list;
2035 if (_tmp2_ == NULL) {
2036 GEqualFunc _tmp3_;
2037 ValaArrayList* _tmp4_;
2038 _tmp3_ = g_direct_equal;
2039 _tmp4_ = vala_array_list_new (VALA_TYPE_EXPRESSION, (GBoxedCopyFunc) vala_code_node_ref, (GDestroyNotify) vala_code_node_unref, _tmp3_);
2040 _vala_iterable_unref0 (vala_method__empty_expression_list);
2041 vala_method__empty_expression_list = (ValaList*) _tmp4_;
2042 }
2043 _tmp5_ = vala_method__empty_expression_list;
2044 result = _tmp5_;
2045 return result;
2046 }
2047
2048 /**
2049 * Adds an error type to the exceptions that can be
2050 * thrown by this method.
2051 */
2052 void
vala_method_add_error_type(ValaMethod * self,ValaDataType * error_type)2053 vala_method_add_error_type (ValaMethod* self,
2054 ValaDataType* error_type)
2055 {
2056 ValaList* _tmp0_;
2057 ValaList* _tmp3_;
2058 g_return_if_fail (self != NULL);
2059 g_return_if_fail (error_type != NULL);
2060 _tmp0_ = self->error_types;
2061 if (_tmp0_ == NULL) {
2062 GEqualFunc _tmp1_;
2063 ValaArrayList* _tmp2_;
2064 _tmp1_ = g_direct_equal;
2065 _tmp2_ = vala_array_list_new (VALA_TYPE_DATA_TYPE, (GBoxedCopyFunc) vala_code_node_ref, (GDestroyNotify) vala_code_node_unref, _tmp1_);
2066 _vala_iterable_unref0 (self->error_types);
2067 self->error_types = (ValaList*) _tmp2_;
2068 }
2069 _tmp3_ = self->error_types;
2070 vala_collection_add ((ValaCollection*) _tmp3_, error_type);
2071 vala_code_node_set_parent_node ((ValaCodeNode*) error_type, (ValaCodeNode*) self);
2072 }
2073
2074 static void
vala_method_real_get_error_types(ValaCodeNode * base,ValaCollection * collection,ValaSourceReference * source_reference)2075 vala_method_real_get_error_types (ValaCodeNode* base,
2076 ValaCollection* collection,
2077 ValaSourceReference* source_reference)
2078 {
2079 ValaMethod * self;
2080 ValaList* _tmp0_;
2081 self = (ValaMethod*) base;
2082 g_return_if_fail (collection != NULL);
2083 _tmp0_ = self->error_types;
2084 if (_tmp0_ != NULL) {
2085 {
2086 ValaList* _error_type_list = NULL;
2087 ValaList* _tmp1_;
2088 ValaList* _tmp2_;
2089 gint _error_type_size = 0;
2090 ValaList* _tmp3_;
2091 gint _tmp4_;
2092 gint _tmp5_;
2093 gint _error_type_index = 0;
2094 _tmp1_ = self->error_types;
2095 _tmp2_ = _vala_iterable_ref0 (_tmp1_);
2096 _error_type_list = _tmp2_;
2097 _tmp3_ = _error_type_list;
2098 _tmp4_ = vala_collection_get_size ((ValaCollection*) _tmp3_);
2099 _tmp5_ = _tmp4_;
2100 _error_type_size = _tmp5_;
2101 _error_type_index = -1;
2102 while (TRUE) {
2103 gint _tmp6_;
2104 gint _tmp7_;
2105 ValaDataType* error_type = NULL;
2106 ValaList* _tmp8_;
2107 gpointer _tmp9_;
2108 _error_type_index = _error_type_index + 1;
2109 _tmp6_ = _error_type_index;
2110 _tmp7_ = _error_type_size;
2111 if (!(_tmp6_ < _tmp7_)) {
2112 break;
2113 }
2114 _tmp8_ = _error_type_list;
2115 _tmp9_ = vala_list_get (_tmp8_, _error_type_index);
2116 error_type = (ValaDataType*) _tmp9_;
2117 if (source_reference != NULL) {
2118 ValaDataType* type = NULL;
2119 ValaDataType* _tmp10_;
2120 ValaDataType* _tmp11_;
2121 ValaDataType* _tmp12_;
2122 ValaDataType* _tmp13_;
2123 _tmp10_ = error_type;
2124 _tmp11_ = vala_data_type_copy (_tmp10_);
2125 type = _tmp11_;
2126 _tmp12_ = type;
2127 vala_code_node_set_source_reference ((ValaCodeNode*) _tmp12_, source_reference);
2128 _tmp13_ = type;
2129 vala_collection_add (collection, _tmp13_);
2130 _vala_code_node_unref0 (type);
2131 } else {
2132 ValaDataType* _tmp14_;
2133 _tmp14_ = error_type;
2134 vala_collection_add (collection, _tmp14_);
2135 }
2136 _vala_code_node_unref0 (error_type);
2137 }
2138 _vala_iterable_unref0 (_error_type_list);
2139 }
2140 }
2141 }
2142
2143 static void
vala_method_real_replace_type(ValaCodeNode * base,ValaDataType * old_type,ValaDataType * new_type)2144 vala_method_real_replace_type (ValaCodeNode* base,
2145 ValaDataType* old_type,
2146 ValaDataType* new_type)
2147 {
2148 ValaMethod * self;
2149 ValaDataType* _tmp0_;
2150 ValaDataType* _tmp1_;
2151 ValaDataType* _tmp2_;
2152 ValaDataType* _tmp3_;
2153 ValaList* _tmp4_;
2154 self = (ValaMethod*) base;
2155 g_return_if_fail (old_type != NULL);
2156 g_return_if_fail (new_type != NULL);
2157 _tmp0_ = vala_method_get_base_interface_type (self);
2158 _tmp1_ = _tmp0_;
2159 if (_tmp1_ == old_type) {
2160 vala_method_set_base_interface_type (self, new_type);
2161 return;
2162 }
2163 _tmp2_ = vala_callable_get_return_type ((ValaCallable*) self);
2164 _tmp3_ = _tmp2_;
2165 if (_tmp3_ == old_type) {
2166 vala_callable_set_return_type ((ValaCallable*) self, new_type);
2167 return;
2168 }
2169 _tmp4_ = self->error_types;
2170 if (_tmp4_ != NULL) {
2171 {
2172 gint i = 0;
2173 i = 0;
2174 {
2175 gboolean _tmp5_ = FALSE;
2176 _tmp5_ = TRUE;
2177 while (TRUE) {
2178 ValaList* _tmp7_;
2179 gint _tmp8_;
2180 gint _tmp9_;
2181 ValaList* _tmp10_;
2182 gpointer _tmp11_;
2183 ValaDataType* _tmp12_;
2184 gboolean _tmp13_;
2185 if (!_tmp5_) {
2186 gint _tmp6_;
2187 _tmp6_ = i;
2188 i = _tmp6_ + 1;
2189 }
2190 _tmp5_ = FALSE;
2191 _tmp7_ = self->error_types;
2192 _tmp8_ = vala_collection_get_size ((ValaCollection*) _tmp7_);
2193 _tmp9_ = _tmp8_;
2194 if (!(i < _tmp9_)) {
2195 break;
2196 }
2197 _tmp10_ = self->error_types;
2198 _tmp11_ = vala_list_get (_tmp10_, i);
2199 _tmp12_ = (ValaDataType*) _tmp11_;
2200 _tmp13_ = _tmp12_ == old_type;
2201 _vala_code_node_unref0 (_tmp12_);
2202 if (_tmp13_) {
2203 ValaList* _tmp14_;
2204 _tmp14_ = self->error_types;
2205 vala_list_set (_tmp14_, i, new_type);
2206 return;
2207 }
2208 }
2209 }
2210 }
2211 }
2212 }
2213
2214 static void
vala_method_find_base_methods(ValaMethod * self)2215 vala_method_find_base_methods (ValaMethod* self)
2216 {
2217 ValaSymbol* _tmp0_;
2218 ValaSymbol* _tmp1_;
2219 g_return_if_fail (self != NULL);
2220 if (self->priv->base_methods_valid) {
2221 return;
2222 }
2223 _tmp0_ = vala_symbol_get_parent_symbol ((ValaSymbol*) self);
2224 _tmp1_ = _tmp0_;
2225 if (VALA_IS_CLASS (_tmp1_)) {
2226 if (!VALA_IS_CREATION_METHOD (self)) {
2227 ValaSymbol* _tmp2_;
2228 ValaSymbol* _tmp3_;
2229 gboolean _tmp4_ = FALSE;
2230 gboolean _tmp5_ = FALSE;
2231 gboolean _tmp6_;
2232 _tmp2_ = vala_symbol_get_parent_symbol ((ValaSymbol*) self);
2233 _tmp3_ = _tmp2_;
2234 vala_method_find_base_interface_method (self, G_TYPE_CHECK_INSTANCE_CAST (_tmp3_, VALA_TYPE_CLASS, ValaClass));
2235 _tmp6_ = self->priv->_is_virtual;
2236 if (_tmp6_) {
2237 _tmp5_ = TRUE;
2238 } else {
2239 gboolean _tmp7_;
2240 _tmp7_ = self->priv->_is_abstract;
2241 _tmp5_ = _tmp7_;
2242 }
2243 if (_tmp5_) {
2244 _tmp4_ = TRUE;
2245 } else {
2246 gboolean _tmp8_;
2247 _tmp8_ = self->priv->_overrides;
2248 _tmp4_ = _tmp8_;
2249 }
2250 if (_tmp4_) {
2251 ValaSymbol* _tmp9_;
2252 ValaSymbol* _tmp10_;
2253 _tmp9_ = vala_symbol_get_parent_symbol ((ValaSymbol*) self);
2254 _tmp10_ = _tmp9_;
2255 vala_method_find_base_class_method (self, G_TYPE_CHECK_INSTANCE_CAST (_tmp10_, VALA_TYPE_CLASS, ValaClass));
2256 }
2257 }
2258 } else {
2259 ValaSymbol* _tmp11_;
2260 ValaSymbol* _tmp12_;
2261 _tmp11_ = vala_symbol_get_parent_symbol ((ValaSymbol*) self);
2262 _tmp12_ = _tmp11_;
2263 if (VALA_IS_INTERFACE (_tmp12_)) {
2264 gboolean _tmp13_ = FALSE;
2265 gboolean _tmp14_;
2266 _tmp14_ = self->priv->_is_virtual;
2267 if (_tmp14_) {
2268 _tmp13_ = TRUE;
2269 } else {
2270 gboolean _tmp15_;
2271 _tmp15_ = self->priv->_is_abstract;
2272 _tmp13_ = _tmp15_;
2273 }
2274 if (_tmp13_) {
2275 self->priv->_base_interface_method = self;
2276 }
2277 }
2278 }
2279 self->priv->base_methods_valid = TRUE;
2280 }
2281
2282 static void
vala_method_find_base_class_method(ValaMethod * self,ValaClass * cl)2283 vala_method_find_base_class_method (ValaMethod* self,
2284 ValaClass* cl)
2285 {
2286 ValaSymbol* sym = NULL;
2287 ValaScope* _tmp0_;
2288 ValaScope* _tmp1_;
2289 const gchar* _tmp2_;
2290 const gchar* _tmp3_;
2291 ValaSymbol* _tmp4_;
2292 ValaSymbol* _tmp5_;
2293 ValaSymbol* _tmp11_;
2294 ValaClass* _tmp36_;
2295 ValaClass* _tmp37_;
2296 g_return_if_fail (self != NULL);
2297 g_return_if_fail (cl != NULL);
2298 _tmp0_ = vala_symbol_get_scope ((ValaSymbol*) cl);
2299 _tmp1_ = _tmp0_;
2300 _tmp2_ = vala_symbol_get_name ((ValaSymbol*) self);
2301 _tmp3_ = _tmp2_;
2302 _tmp4_ = vala_scope_lookup (_tmp1_, _tmp3_);
2303 sym = _tmp4_;
2304 _tmp5_ = sym;
2305 if (VALA_IS_SIGNAL (_tmp5_)) {
2306 ValaSignal* sig = NULL;
2307 ValaSymbol* _tmp6_;
2308 ValaSignal* _tmp7_;
2309 ValaMethod* _tmp8_;
2310 ValaMethod* _tmp9_;
2311 ValaSymbol* _tmp10_;
2312 _tmp6_ = sym;
2313 sig = G_TYPE_CHECK_INSTANCE_CAST (_tmp6_, VALA_TYPE_SIGNAL, ValaSignal);
2314 _tmp7_ = sig;
2315 _tmp8_ = vala_signal_get_default_handler (_tmp7_);
2316 _tmp9_ = _tmp8_;
2317 _tmp10_ = _vala_code_node_ref0 ((ValaSymbol*) _tmp9_);
2318 _vala_code_node_unref0 (sym);
2319 sym = _tmp10_;
2320 }
2321 _tmp11_ = sym;
2322 if (VALA_IS_METHOD (_tmp11_)) {
2323 ValaMethod* base_method = NULL;
2324 ValaSymbol* _tmp12_;
2325 gboolean _tmp13_ = FALSE;
2326 ValaMethod* _tmp14_;
2327 gboolean _tmp15_;
2328 _tmp12_ = sym;
2329 base_method = G_TYPE_CHECK_INSTANCE_CAST (_tmp12_, VALA_TYPE_METHOD, ValaMethod);
2330 _tmp14_ = base_method;
2331 _tmp15_ = _tmp14_->priv->_is_abstract;
2332 if (_tmp15_) {
2333 _tmp13_ = TRUE;
2334 } else {
2335 ValaMethod* _tmp16_;
2336 gboolean _tmp17_;
2337 _tmp16_ = base_method;
2338 _tmp17_ = _tmp16_->priv->_is_virtual;
2339 _tmp13_ = _tmp17_;
2340 }
2341 if (_tmp13_) {
2342 gchar* invalid_match = NULL;
2343 ValaMethod* _tmp18_;
2344 gchar* _tmp19_ = NULL;
2345 gboolean _tmp20_;
2346 ValaMethod* _tmp33_;
2347 ValaMethod* _tmp34_;
2348 ValaMethod* _tmp35_;
2349 _tmp18_ = base_method;
2350 _tmp20_ = vala_method_compatible (self, _tmp18_, &_tmp19_);
2351 _g_free0 (invalid_match);
2352 invalid_match = _tmp19_;
2353 if (!_tmp20_) {
2354 ValaMethodType* base_method_type = NULL;
2355 ValaMethod* _tmp21_;
2356 ValaMethodType* _tmp22_;
2357 ValaSourceReference* _tmp23_;
2358 ValaSourceReference* _tmp24_;
2359 gchar* _tmp25_;
2360 gchar* _tmp26_;
2361 ValaMethodType* _tmp27_;
2362 gchar* _tmp28_;
2363 gchar* _tmp29_;
2364 const gchar* _tmp30_;
2365 gchar* _tmp31_;
2366 gchar* _tmp32_;
2367 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
2368 _tmp21_ = base_method;
2369 _tmp22_ = vala_method_type_new (_tmp21_);
2370 base_method_type = _tmp22_;
2371 _tmp23_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
2372 _tmp24_ = _tmp23_;
2373 _tmp25_ = vala_symbol_get_full_name ((ValaSymbol*) self);
2374 _tmp26_ = _tmp25_;
2375 _tmp27_ = base_method_type;
2376 _tmp28_ = vala_data_type_to_prototype_string ((ValaDataType*) _tmp27_, NULL);
2377 _tmp29_ = _tmp28_;
2378 _tmp30_ = invalid_match;
2379 _tmp31_ = g_strdup_printf ("overriding method `%s' is incompatible with base method `%s': %s.", _tmp26_, _tmp29_, _tmp30_);
2380 _tmp32_ = _tmp31_;
2381 vala_report_error (_tmp24_, _tmp32_);
2382 _g_free0 (_tmp32_);
2383 _g_free0 (_tmp29_);
2384 _g_free0 (_tmp26_);
2385 _vala_code_node_unref0 (base_method_type);
2386 _g_free0 (invalid_match);
2387 _vala_code_node_unref0 (sym);
2388 return;
2389 }
2390 _tmp33_ = base_method;
2391 self->priv->_base_method = _tmp33_;
2392 _tmp34_ = base_method;
2393 vala_code_node_copy_attribute_double ((ValaCodeNode*) self, (ValaCodeNode*) _tmp34_, "CCode", "instance_pos");
2394 _tmp35_ = base_method;
2395 vala_code_node_copy_attribute_bool ((ValaCodeNode*) self, (ValaCodeNode*) _tmp35_, "CCode", "returns_floating_reference");
2396 _g_free0 (invalid_match);
2397 _vala_code_node_unref0 (sym);
2398 return;
2399 }
2400 }
2401 _tmp36_ = vala_class_get_base_class (cl);
2402 _tmp37_ = _tmp36_;
2403 if (_tmp37_ != NULL) {
2404 ValaClass* _tmp38_;
2405 ValaClass* _tmp39_;
2406 _tmp38_ = vala_class_get_base_class (cl);
2407 _tmp39_ = _tmp38_;
2408 vala_method_find_base_class_method (self, _tmp39_);
2409 }
2410 _vala_code_node_unref0 (sym);
2411 }
2412
2413 static void
vala_method_find_base_interface_method(ValaMethod * self,ValaClass * cl)2414 vala_method_find_base_interface_method (ValaMethod* self,
2415 ValaClass* cl)
2416 {
2417 ValaMethod* base_match = NULL;
2418 gchar* invalid_error = NULL;
2419 ValaMethod* invalid_base_match = NULL;
2420 ValaMethod* _tmp71_;
2421 ValaDataType* _tmp91_;
2422 ValaDataType* _tmp92_;
2423 g_return_if_fail (self != NULL);
2424 g_return_if_fail (cl != NULL);
2425 base_match = NULL;
2426 invalid_error = NULL;
2427 invalid_base_match = NULL;
2428 {
2429 ValaList* _type_list = NULL;
2430 ValaList* _tmp0_;
2431 ValaList* _tmp1_;
2432 gint _type_size = 0;
2433 ValaList* _tmp2_;
2434 gint _tmp3_;
2435 gint _tmp4_;
2436 gint _type_index = 0;
2437 _tmp0_ = vala_class_get_base_types (cl);
2438 _tmp1_ = _vala_iterable_ref0 (_tmp0_);
2439 _type_list = _tmp1_;
2440 _tmp2_ = _type_list;
2441 _tmp3_ = vala_collection_get_size ((ValaCollection*) _tmp2_);
2442 _tmp4_ = _tmp3_;
2443 _type_size = _tmp4_;
2444 _type_index = -1;
2445 while (TRUE) {
2446 gint _tmp5_;
2447 gint _tmp6_;
2448 ValaDataType* type = NULL;
2449 ValaList* _tmp7_;
2450 gpointer _tmp8_;
2451 ValaDataType* _tmp9_;
2452 ValaTypeSymbol* _tmp10_;
2453 ValaTypeSymbol* _tmp11_;
2454 _type_index = _type_index + 1;
2455 _tmp5_ = _type_index;
2456 _tmp6_ = _type_size;
2457 if (!(_tmp5_ < _tmp6_)) {
2458 break;
2459 }
2460 _tmp7_ = _type_list;
2461 _tmp8_ = vala_list_get (_tmp7_, _type_index);
2462 type = (ValaDataType*) _tmp8_;
2463 _tmp9_ = type;
2464 _tmp10_ = vala_data_type_get_type_symbol (_tmp9_);
2465 _tmp11_ = _tmp10_;
2466 if (VALA_IS_INTERFACE (_tmp11_)) {
2467 gboolean _tmp12_ = FALSE;
2468 ValaDataType* _tmp13_;
2469 ValaDataType* _tmp14_;
2470 ValaSymbol* sym = NULL;
2471 ValaDataType* _tmp22_;
2472 ValaTypeSymbol* _tmp23_;
2473 ValaTypeSymbol* _tmp24_;
2474 ValaScope* _tmp25_;
2475 ValaScope* _tmp26_;
2476 const gchar* _tmp27_;
2477 const gchar* _tmp28_;
2478 ValaSymbol* _tmp29_;
2479 ValaSymbol* _tmp30_;
2480 ValaSymbol* _tmp36_;
2481 _tmp13_ = vala_method_get_base_interface_type (self);
2482 _tmp14_ = _tmp13_;
2483 if (_tmp14_ != NULL) {
2484 ValaDataType* _tmp15_;
2485 ValaDataType* _tmp16_;
2486 ValaTypeSymbol* _tmp17_;
2487 ValaTypeSymbol* _tmp18_;
2488 ValaDataType* _tmp19_;
2489 ValaTypeSymbol* _tmp20_;
2490 ValaTypeSymbol* _tmp21_;
2491 _tmp15_ = vala_method_get_base_interface_type (self);
2492 _tmp16_ = _tmp15_;
2493 _tmp17_ = vala_data_type_get_type_symbol (_tmp16_);
2494 _tmp18_ = _tmp17_;
2495 _tmp19_ = type;
2496 _tmp20_ = vala_data_type_get_type_symbol (_tmp19_);
2497 _tmp21_ = _tmp20_;
2498 _tmp12_ = _tmp18_ != _tmp21_;
2499 } else {
2500 _tmp12_ = FALSE;
2501 }
2502 if (_tmp12_) {
2503 _vala_code_node_unref0 (type);
2504 continue;
2505 }
2506 _tmp22_ = type;
2507 _tmp23_ = vala_data_type_get_type_symbol (_tmp22_);
2508 _tmp24_ = _tmp23_;
2509 _tmp25_ = vala_symbol_get_scope ((ValaSymbol*) _tmp24_);
2510 _tmp26_ = _tmp25_;
2511 _tmp27_ = vala_symbol_get_name ((ValaSymbol*) self);
2512 _tmp28_ = _tmp27_;
2513 _tmp29_ = vala_scope_lookup (_tmp26_, _tmp28_);
2514 sym = _tmp29_;
2515 _tmp30_ = sym;
2516 if (VALA_IS_SIGNAL (_tmp30_)) {
2517 ValaSignal* sig = NULL;
2518 ValaSymbol* _tmp31_;
2519 ValaSignal* _tmp32_;
2520 ValaMethod* _tmp33_;
2521 ValaMethod* _tmp34_;
2522 ValaSymbol* _tmp35_;
2523 _tmp31_ = sym;
2524 sig = G_TYPE_CHECK_INSTANCE_CAST (_tmp31_, VALA_TYPE_SIGNAL, ValaSignal);
2525 _tmp32_ = sig;
2526 _tmp33_ = vala_signal_get_default_handler (_tmp32_);
2527 _tmp34_ = _tmp33_;
2528 _tmp35_ = _vala_code_node_ref0 ((ValaSymbol*) _tmp34_);
2529 _vala_code_node_unref0 (sym);
2530 sym = _tmp35_;
2531 }
2532 _tmp36_ = sym;
2533 if (VALA_IS_METHOD (_tmp36_)) {
2534 ValaMethod* base_method = NULL;
2535 ValaSymbol* _tmp37_;
2536 gboolean _tmp38_ = FALSE;
2537 ValaMethod* _tmp39_;
2538 gboolean _tmp40_;
2539 _tmp37_ = sym;
2540 base_method = G_TYPE_CHECK_INSTANCE_CAST (_tmp37_, VALA_TYPE_METHOD, ValaMethod);
2541 _tmp39_ = base_method;
2542 _tmp40_ = _tmp39_->priv->_is_abstract;
2543 if (_tmp40_) {
2544 _tmp38_ = TRUE;
2545 } else {
2546 ValaMethod* _tmp41_;
2547 gboolean _tmp42_;
2548 _tmp41_ = base_method;
2549 _tmp42_ = _tmp41_->priv->_is_virtual;
2550 _tmp38_ = _tmp42_;
2551 }
2552 if (_tmp38_) {
2553 ValaDataType* _tmp43_;
2554 ValaDataType* _tmp44_;
2555 gchar* invalid_match = NULL;
2556 ValaMethod* _tmp62_;
2557 gchar* _tmp63_ = NULL;
2558 gboolean _tmp64_;
2559 _tmp43_ = vala_method_get_base_interface_type (self);
2560 _tmp44_ = _tmp43_;
2561 if (_tmp44_ == NULL) {
2562 gboolean has_explicit_implementation = FALSE;
2563 has_explicit_implementation = FALSE;
2564 {
2565 ValaList* _m_list = NULL;
2566 ValaList* _tmp45_;
2567 ValaList* _tmp46_;
2568 gint _m_size = 0;
2569 ValaList* _tmp47_;
2570 gint _tmp48_;
2571 gint _tmp49_;
2572 gint _m_index = 0;
2573 _tmp45_ = vala_object_type_symbol_get_methods ((ValaObjectTypeSymbol*) cl);
2574 _tmp46_ = _vala_iterable_ref0 (_tmp45_);
2575 _m_list = _tmp46_;
2576 _tmp47_ = _m_list;
2577 _tmp48_ = vala_collection_get_size ((ValaCollection*) _tmp47_);
2578 _tmp49_ = _tmp48_;
2579 _m_size = _tmp49_;
2580 _m_index = -1;
2581 while (TRUE) {
2582 gint _tmp50_;
2583 gint _tmp51_;
2584 ValaMethod* m = NULL;
2585 ValaList* _tmp52_;
2586 gpointer _tmp53_;
2587 gboolean _tmp54_ = FALSE;
2588 ValaMethod* _tmp55_;
2589 ValaDataType* _tmp56_;
2590 ValaDataType* _tmp57_;
2591 _m_index = _m_index + 1;
2592 _tmp50_ = _m_index;
2593 _tmp51_ = _m_size;
2594 if (!(_tmp50_ < _tmp51_)) {
2595 break;
2596 }
2597 _tmp52_ = _m_list;
2598 _tmp53_ = vala_list_get (_tmp52_, _m_index);
2599 m = (ValaMethod*) _tmp53_;
2600 _tmp55_ = m;
2601 _tmp56_ = vala_method_get_base_interface_type (_tmp55_);
2602 _tmp57_ = _tmp56_;
2603 if (_tmp57_ != NULL) {
2604 ValaMethod* _tmp58_;
2605 ValaMethod* _tmp59_;
2606 ValaMethod* _tmp60_;
2607 ValaMethod* _tmp61_;
2608 _tmp58_ = base_method;
2609 _tmp59_ = m;
2610 _tmp60_ = vala_method_get_base_interface_method (_tmp59_);
2611 _tmp61_ = _tmp60_;
2612 _tmp54_ = _tmp58_ == _tmp61_;
2613 } else {
2614 _tmp54_ = FALSE;
2615 }
2616 if (_tmp54_) {
2617 has_explicit_implementation = TRUE;
2618 _vala_code_node_unref0 (m);
2619 break;
2620 }
2621 _vala_code_node_unref0 (m);
2622 }
2623 _vala_iterable_unref0 (_m_list);
2624 }
2625 if (has_explicit_implementation) {
2626 _vala_code_node_unref0 (sym);
2627 _vala_code_node_unref0 (type);
2628 continue;
2629 }
2630 }
2631 invalid_match = NULL;
2632 _tmp62_ = base_method;
2633 _tmp64_ = vala_method_compatible (self, _tmp62_, &_tmp63_);
2634 _g_free0 (invalid_match);
2635 invalid_match = _tmp63_;
2636 if (!_tmp64_) {
2637 const gchar* _tmp65_;
2638 gchar* _tmp66_;
2639 ValaMethod* _tmp67_;
2640 ValaMethod* _tmp68_;
2641 _tmp65_ = invalid_match;
2642 _tmp66_ = g_strdup (_tmp65_);
2643 _g_free0 (invalid_error);
2644 invalid_error = _tmp66_;
2645 _tmp67_ = base_method;
2646 _tmp68_ = _vala_code_node_ref0 (_tmp67_);
2647 _vala_code_node_unref0 (invalid_base_match);
2648 invalid_base_match = _tmp68_;
2649 } else {
2650 ValaMethod* _tmp69_;
2651 ValaMethod* _tmp70_;
2652 _tmp69_ = base_method;
2653 _tmp70_ = _vala_code_node_ref0 (_tmp69_);
2654 _vala_code_node_unref0 (base_match);
2655 base_match = _tmp70_;
2656 _g_free0 (invalid_match);
2657 _vala_code_node_unref0 (sym);
2658 _vala_code_node_unref0 (type);
2659 break;
2660 }
2661 _g_free0 (invalid_match);
2662 }
2663 }
2664 _vala_code_node_unref0 (sym);
2665 }
2666 _vala_code_node_unref0 (type);
2667 }
2668 _vala_iterable_unref0 (_type_list);
2669 }
2670 _tmp71_ = base_match;
2671 if (_tmp71_ != NULL) {
2672 ValaMethod* _tmp72_;
2673 ValaMethod* _tmp73_;
2674 ValaMethod* _tmp74_;
2675 _tmp72_ = base_match;
2676 self->priv->_base_interface_method = _tmp72_;
2677 _tmp73_ = base_match;
2678 vala_code_node_copy_attribute_double ((ValaCodeNode*) self, (ValaCodeNode*) _tmp73_, "CCode", "instance_pos");
2679 _tmp74_ = base_match;
2680 vala_code_node_copy_attribute_bool ((ValaCodeNode*) self, (ValaCodeNode*) _tmp74_, "CCode", "returns_floating_reference");
2681 _vala_code_node_unref0 (invalid_base_match);
2682 _g_free0 (invalid_error);
2683 _vala_code_node_unref0 (base_match);
2684 return;
2685 } else {
2686 gboolean _tmp75_ = FALSE;
2687 gboolean _tmp76_;
2688 gboolean _tmp77_;
2689 _tmp76_ = vala_symbol_get_hides ((ValaSymbol*) self);
2690 _tmp77_ = _tmp76_;
2691 if (!_tmp77_) {
2692 ValaMethod* _tmp78_;
2693 _tmp78_ = invalid_base_match;
2694 _tmp75_ = _tmp78_ != NULL;
2695 } else {
2696 _tmp75_ = FALSE;
2697 }
2698 if (_tmp75_) {
2699 ValaMethodType* base_method_type = NULL;
2700 ValaMethod* _tmp79_;
2701 ValaMethodType* _tmp80_;
2702 ValaSourceReference* _tmp81_;
2703 ValaSourceReference* _tmp82_;
2704 gchar* _tmp83_;
2705 gchar* _tmp84_;
2706 ValaMethodType* _tmp85_;
2707 gchar* _tmp86_;
2708 gchar* _tmp87_;
2709 const gchar* _tmp88_;
2710 gchar* _tmp89_;
2711 gchar* _tmp90_;
2712 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
2713 _tmp79_ = invalid_base_match;
2714 _tmp80_ = vala_method_type_new (_tmp79_);
2715 base_method_type = _tmp80_;
2716 _tmp81_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
2717 _tmp82_ = _tmp81_;
2718 _tmp83_ = vala_symbol_get_full_name ((ValaSymbol*) self);
2719 _tmp84_ = _tmp83_;
2720 _tmp85_ = base_method_type;
2721 _tmp86_ = vala_data_type_to_prototype_string ((ValaDataType*) _tmp85_, NULL);
2722 _tmp87_ = _tmp86_;
2723 _tmp88_ = invalid_error;
2724 _tmp89_ = g_strdup_printf ("overriding method `%s' is incompatible with base method `%s': %s.", _tmp84_, _tmp87_, _tmp88_);
2725 _tmp90_ = _tmp89_;
2726 vala_report_error (_tmp82_, _tmp90_);
2727 _g_free0 (_tmp90_);
2728 _g_free0 (_tmp87_);
2729 _g_free0 (_tmp84_);
2730 _vala_code_node_unref0 (base_method_type);
2731 _vala_code_node_unref0 (invalid_base_match);
2732 _g_free0 (invalid_error);
2733 _vala_code_node_unref0 (base_match);
2734 return;
2735 }
2736 }
2737 _tmp91_ = vala_method_get_base_interface_type (self);
2738 _tmp92_ = _tmp91_;
2739 if (_tmp92_ != NULL) {
2740 ValaSourceReference* _tmp93_;
2741 ValaSourceReference* _tmp94_;
2742 gchar* _tmp95_;
2743 gchar* _tmp96_;
2744 gchar* _tmp97_;
2745 gchar* _tmp98_;
2746 _tmp93_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
2747 _tmp94_ = _tmp93_;
2748 _tmp95_ = vala_symbol_get_full_name ((ValaSymbol*) self);
2749 _tmp96_ = _tmp95_;
2750 _tmp97_ = g_strdup_printf ("`%s': no suitable interface method found to implement", _tmp96_);
2751 _tmp98_ = _tmp97_;
2752 vala_report_error (_tmp94_, _tmp98_);
2753 _g_free0 (_tmp98_);
2754 _g_free0 (_tmp96_);
2755 }
2756 _vala_code_node_unref0 (invalid_base_match);
2757 _g_free0 (invalid_error);
2758 _vala_code_node_unref0 (base_match);
2759 }
2760
2761 static gpointer
_vala_source_file_ref0(gpointer self)2762 _vala_source_file_ref0 (gpointer self)
2763 {
2764 return self ? vala_source_file_ref (self) : NULL;
2765 }
2766
2767 static gboolean
vala_method_real_check(ValaCodeNode * base,ValaCodeContext * context)2768 vala_method_real_check (ValaCodeNode* base,
2769 ValaCodeContext* context)
2770 {
2771 ValaMethod * self;
2772 gboolean _tmp0_;
2773 gboolean _tmp1_;
2774 ValaParameter* _tmp4_;
2775 ValaAttribute* _tmp6_;
2776 ValaAttribute* _tmp10_;
2777 gboolean _tmp11_ = FALSE;
2778 ValaSymbol* _tmp12_;
2779 ValaSymbol* _tmp13_;
2780 gboolean _tmp28_ = FALSE;
2781 gboolean _tmp34_ = FALSE;
2782 ValaAttribute* _tmp35_;
2783 gboolean _tmp41_;
2784 gboolean _tmp77_ = FALSE;
2785 gboolean _tmp78_;
2786 gboolean _tmp110_ = FALSE;
2787 gboolean _tmp111_ = FALSE;
2788 gboolean _tmp112_;
2789 ValaSourceFile* old_source_file = NULL;
2790 ValaSemanticAnalyzer* _tmp117_;
2791 ValaSemanticAnalyzer* _tmp118_;
2792 ValaSourceFile* _tmp119_;
2793 ValaSourceFile* _tmp120_;
2794 ValaSourceFile* _tmp121_;
2795 ValaSymbol* old_symbol = NULL;
2796 ValaSemanticAnalyzer* _tmp122_;
2797 ValaSemanticAnalyzer* _tmp123_;
2798 ValaSymbol* _tmp124_;
2799 ValaSymbol* _tmp125_;
2800 ValaSymbol* _tmp126_;
2801 ValaSourceReference* _tmp127_;
2802 ValaSourceReference* _tmp128_;
2803 ValaSemanticAnalyzer* _tmp135_;
2804 ValaSemanticAnalyzer* _tmp136_;
2805 ValaDataType* _tmp137_;
2806 ValaDataType* _tmp138_;
2807 gboolean _tmp139_;
2808 gboolean _tmp140_;
2809 ValaDataType* _tmp141_;
2810 ValaDataType* _tmp142_;
2811 gboolean _tmp143_;
2812 gboolean _tmp144_;
2813 ValaDataType* _tmp149_;
2814 ValaDataType* _tmp150_;
2815 ValaTypeSymbol* _tmp151_;
2816 ValaTypeSymbol* _tmp152_;
2817 ValaSemanticAnalyzer* _tmp153_;
2818 ValaSemanticAnalyzer* _tmp154_;
2819 ValaDataType* _tmp155_;
2820 ValaTypeSymbol* _tmp156_;
2821 ValaTypeSymbol* _tmp157_;
2822 ValaAttribute* init_attr = NULL;
2823 ValaAttribute* _tmp168_;
2824 ValaAttribute* _tmp169_;
2825 ValaAttribute* _tmp170_;
2826 ValaDataType* _tmp177_;
2827 ValaDataType* _tmp178_;
2828 gboolean _tmp181_ = FALSE;
2829 gboolean _tmp182_ = FALSE;
2830 gboolean _tmp183_ = FALSE;
2831 ValaList* _tmp184_;
2832 gint _tmp185_;
2833 gint _tmp186_;
2834 gboolean _tmp200_ = FALSE;
2835 ValaAttribute* _tmp201_;
2836 gboolean optional_param = FALSE;
2837 gboolean params_array_param = FALSE;
2838 gboolean _tmp346_;
2839 ValaList* _tmp360_;
2840 ValaLocalVariable* _tmp383_;
2841 ValaLocalVariable* _tmp384_;
2842 ValaList* _tmp387_;
2843 ValaList* _tmp398_;
2844 ValaBlock* _tmp409_;
2845 ValaBlock* _tmp410_;
2846 ValaSemanticAnalyzer* _tmp413_;
2847 ValaSemanticAnalyzer* _tmp414_;
2848 ValaStruct* _tmp415_;
2849 ValaStruct* _tmp416_;
2850 gboolean _tmp474_ = FALSE;
2851 gboolean _tmp475_ = FALSE;
2852 ValaDataType* _tmp476_;
2853 ValaDataType* _tmp477_;
2854 ValaSemanticAnalyzer* _tmp523_;
2855 ValaSemanticAnalyzer* _tmp524_;
2856 ValaSourceFile* _tmp525_;
2857 ValaSemanticAnalyzer* _tmp526_;
2858 ValaSemanticAnalyzer* _tmp527_;
2859 ValaSymbol* _tmp528_;
2860 gboolean _tmp529_ = FALSE;
2861 gboolean _tmp530_ = FALSE;
2862 gboolean _tmp531_ = FALSE;
2863 gboolean _tmp532_;
2864 gboolean _tmp533_;
2865 ValaSemanticAnalyzer* _tmp549_;
2866 ValaSemanticAnalyzer* _tmp550_;
2867 ValaDataType* _tmp551_;
2868 ValaDataType* _tmp552_;
2869 gboolean _tmp605_ = FALSE;
2870 ValaBlock* _tmp606_;
2871 ValaBlock* _tmp607_;
2872 gboolean _tmp652_ = FALSE;
2873 gboolean _tmp653_ = FALSE;
2874 gboolean _tmp654_ = FALSE;
2875 gboolean _tmp655_ = FALSE;
2876 gboolean _tmp656_ = FALSE;
2877 ValaAttribute* _tmp716_;
2878 gboolean _tmp717_;
2879 gboolean _tmp718_;
2880 gboolean result = FALSE;
2881 self = (ValaMethod*) base;
2882 g_return_val_if_fail (context != NULL, FALSE);
2883 _tmp0_ = vala_code_node_get_checked ((ValaCodeNode*) self);
2884 _tmp1_ = _tmp0_;
2885 if (_tmp1_) {
2886 gboolean _tmp2_;
2887 gboolean _tmp3_;
2888 _tmp2_ = vala_code_node_get_error ((ValaCodeNode*) self);
2889 _tmp3_ = _tmp2_;
2890 result = !_tmp3_;
2891 return result;
2892 }
2893 vala_code_node_set_checked ((ValaCodeNode*) self, TRUE);
2894 _tmp4_ = self->priv->_this_parameter;
2895 if (_tmp4_ != NULL) {
2896 ValaParameter* _tmp5_;
2897 _tmp5_ = self->priv->_this_parameter;
2898 vala_code_node_check ((ValaCodeNode*) _tmp5_, context);
2899 }
2900 _tmp6_ = vala_code_node_get_attribute ((ValaCodeNode*) self, "DestroysInstance");
2901 if (_tmp6_ != NULL) {
2902 ValaParameter* _tmp7_;
2903 ValaDataType* _tmp8_;
2904 ValaDataType* _tmp9_;
2905 _tmp7_ = self->priv->_this_parameter;
2906 _tmp8_ = vala_variable_get_variable_type ((ValaVariable*) _tmp7_);
2907 _tmp9_ = _tmp8_;
2908 vala_data_type_set_value_owned (_tmp9_, TRUE);
2909 }
2910 _tmp10_ = vala_code_node_get_attribute ((ValaCodeNode*) self, "NoThrow");
2911 if (_tmp10_ != NULL) {
2912 _vala_iterable_unref0 (self->error_types);
2913 self->error_types = NULL;
2914 }
2915 _tmp12_ = vala_symbol_get_parent_symbol ((ValaSymbol*) self);
2916 _tmp13_ = _tmp12_;
2917 if (VALA_IS_CLASS (_tmp13_)) {
2918 gboolean _tmp14_ = FALSE;
2919 gboolean _tmp15_;
2920 _tmp15_ = self->priv->_is_abstract;
2921 if (_tmp15_) {
2922 _tmp14_ = TRUE;
2923 } else {
2924 gboolean _tmp16_;
2925 _tmp16_ = self->priv->_is_virtual;
2926 _tmp14_ = _tmp16_;
2927 }
2928 _tmp11_ = _tmp14_;
2929 } else {
2930 _tmp11_ = FALSE;
2931 }
2932 if (_tmp11_) {
2933 ValaClass* cl = NULL;
2934 ValaSymbol* _tmp17_;
2935 ValaSymbol* _tmp18_;
2936 gboolean _tmp19_ = FALSE;
2937 ValaClass* _tmp20_;
2938 gboolean _tmp21_;
2939 gboolean _tmp22_;
2940 _tmp17_ = vala_symbol_get_parent_symbol ((ValaSymbol*) self);
2941 _tmp18_ = _tmp17_;
2942 cl = G_TYPE_CHECK_INSTANCE_CAST (_tmp18_, VALA_TYPE_CLASS, ValaClass);
2943 _tmp20_ = cl;
2944 _tmp21_ = vala_class_get_is_compact (_tmp20_);
2945 _tmp22_ = _tmp21_;
2946 if (_tmp22_) {
2947 ValaClass* _tmp23_;
2948 ValaClass* _tmp24_;
2949 ValaClass* _tmp25_;
2950 _tmp23_ = cl;
2951 _tmp24_ = vala_class_get_base_class (_tmp23_);
2952 _tmp25_ = _tmp24_;
2953 _tmp19_ = _tmp25_ != NULL;
2954 } else {
2955 _tmp19_ = FALSE;
2956 }
2957 if (_tmp19_) {
2958 ValaSourceReference* _tmp26_;
2959 ValaSourceReference* _tmp27_;
2960 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
2961 _tmp26_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
2962 _tmp27_ = _tmp26_;
2963 vala_report_error (_tmp27_, "Abstract and virtual methods may not be declared in derived compact cl" \
2964 "asses");
2965 result = FALSE;
2966 return result;
2967 }
2968 }
2969 if (vala_method_is_variadic (self)) {
2970 gboolean _tmp29_ = FALSE;
2971 gboolean _tmp30_;
2972 _tmp30_ = self->priv->_is_abstract;
2973 if (_tmp30_) {
2974 _tmp29_ = TRUE;
2975 } else {
2976 gboolean _tmp31_;
2977 _tmp31_ = self->priv->_is_virtual;
2978 _tmp29_ = _tmp31_;
2979 }
2980 _tmp28_ = _tmp29_;
2981 } else {
2982 _tmp28_ = FALSE;
2983 }
2984 if (_tmp28_) {
2985 ValaSourceReference* _tmp32_;
2986 ValaSourceReference* _tmp33_;
2987 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
2988 _tmp32_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
2989 _tmp33_ = _tmp32_;
2990 vala_report_error (_tmp33_, "Abstract and virtual methods may not be variadic. Use a `va_list' para" \
2991 "meter instead of `...' or params-array.");
2992 result = FALSE;
2993 return result;
2994 }
2995 _tmp35_ = vala_code_node_get_attribute ((ValaCodeNode*) self, "NoWrapper");
2996 if (_tmp35_ != NULL) {
2997 gboolean _tmp36_ = FALSE;
2998 gboolean _tmp37_;
2999 _tmp37_ = self->priv->_is_abstract;
3000 if (_tmp37_) {
3001 _tmp36_ = TRUE;
3002 } else {
3003 gboolean _tmp38_;
3004 _tmp38_ = self->priv->_is_virtual;
3005 _tmp36_ = _tmp38_;
3006 }
3007 _tmp34_ = !_tmp36_;
3008 } else {
3009 _tmp34_ = FALSE;
3010 }
3011 if (_tmp34_) {
3012 ValaSourceReference* _tmp39_;
3013 ValaSourceReference* _tmp40_;
3014 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
3015 _tmp39_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
3016 _tmp40_ = _tmp39_;
3017 vala_report_error (_tmp40_, "[NoWrapper] methods must be declared abstract or virtual");
3018 result = FALSE;
3019 return result;
3020 }
3021 _tmp41_ = self->priv->_is_abstract;
3022 if (_tmp41_) {
3023 ValaSymbol* _tmp42_;
3024 ValaSymbol* _tmp43_;
3025 _tmp42_ = vala_symbol_get_parent_symbol ((ValaSymbol*) self);
3026 _tmp43_ = _tmp42_;
3027 if (VALA_IS_CLASS (_tmp43_)) {
3028 ValaClass* cl = NULL;
3029 ValaSymbol* _tmp44_;
3030 ValaSymbol* _tmp45_;
3031 ValaClass* _tmp46_;
3032 gboolean _tmp47_;
3033 gboolean _tmp48_;
3034 _tmp44_ = vala_symbol_get_parent_symbol ((ValaSymbol*) self);
3035 _tmp45_ = _tmp44_;
3036 cl = G_TYPE_CHECK_INSTANCE_CAST (_tmp45_, VALA_TYPE_CLASS, ValaClass);
3037 _tmp46_ = cl;
3038 _tmp47_ = vala_class_get_is_abstract (_tmp46_);
3039 _tmp48_ = _tmp47_;
3040 if (!_tmp48_) {
3041 ValaSourceReference* _tmp49_;
3042 ValaSourceReference* _tmp50_;
3043 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
3044 _tmp49_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
3045 _tmp50_ = _tmp49_;
3046 vala_report_error (_tmp50_, "Abstract methods may not be declared in non-abstract classes");
3047 result = FALSE;
3048 return result;
3049 }
3050 } else {
3051 ValaSymbol* _tmp51_;
3052 ValaSymbol* _tmp52_;
3053 _tmp51_ = vala_symbol_get_parent_symbol ((ValaSymbol*) self);
3054 _tmp52_ = _tmp51_;
3055 if (!VALA_IS_INTERFACE (_tmp52_)) {
3056 ValaSourceReference* _tmp53_;
3057 ValaSourceReference* _tmp54_;
3058 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
3059 _tmp53_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
3060 _tmp54_ = _tmp53_;
3061 vala_report_error (_tmp54_, "Abstract methods may not be declared outside of classes and interfaces");
3062 result = FALSE;
3063 return result;
3064 }
3065 }
3066 } else {
3067 gboolean _tmp55_;
3068 _tmp55_ = self->priv->_is_virtual;
3069 if (_tmp55_) {
3070 gboolean _tmp56_ = FALSE;
3071 ValaSymbol* _tmp57_;
3072 ValaSymbol* _tmp58_;
3073 _tmp57_ = vala_symbol_get_parent_symbol ((ValaSymbol*) self);
3074 _tmp58_ = _tmp57_;
3075 if (!VALA_IS_CLASS (_tmp58_)) {
3076 ValaSymbol* _tmp59_;
3077 ValaSymbol* _tmp60_;
3078 _tmp59_ = vala_symbol_get_parent_symbol ((ValaSymbol*) self);
3079 _tmp60_ = _tmp59_;
3080 _tmp56_ = !VALA_IS_INTERFACE (_tmp60_);
3081 } else {
3082 _tmp56_ = FALSE;
3083 }
3084 if (_tmp56_) {
3085 ValaSourceReference* _tmp61_;
3086 ValaSourceReference* _tmp62_;
3087 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
3088 _tmp61_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
3089 _tmp62_ = _tmp61_;
3090 vala_report_error (_tmp62_, "Virtual methods may not be declared outside of classes and interfaces");
3091 result = FALSE;
3092 return result;
3093 }
3094 } else {
3095 gboolean _tmp63_;
3096 _tmp63_ = self->priv->_overrides;
3097 if (_tmp63_) {
3098 ValaSymbol* _tmp64_;
3099 ValaSymbol* _tmp65_;
3100 _tmp64_ = vala_symbol_get_parent_symbol ((ValaSymbol*) self);
3101 _tmp65_ = _tmp64_;
3102 if (!VALA_IS_CLASS (_tmp65_)) {
3103 ValaSourceReference* _tmp66_;
3104 ValaSourceReference* _tmp67_;
3105 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
3106 _tmp66_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
3107 _tmp67_ = _tmp66_;
3108 vala_report_error (_tmp67_, "Methods may not be overridden outside of classes");
3109 result = FALSE;
3110 return result;
3111 }
3112 } else {
3113 ValaSymbolAccessibility _tmp68_;
3114 ValaSymbolAccessibility _tmp69_;
3115 _tmp68_ = vala_symbol_get_access ((ValaSymbol*) self);
3116 _tmp69_ = _tmp68_;
3117 if (_tmp69_ == VALA_SYMBOL_ACCESSIBILITY_PROTECTED) {
3118 gboolean _tmp70_ = FALSE;
3119 ValaSymbol* _tmp71_;
3120 ValaSymbol* _tmp72_;
3121 _tmp71_ = vala_symbol_get_parent_symbol ((ValaSymbol*) self);
3122 _tmp72_ = _tmp71_;
3123 if (!VALA_IS_CLASS (_tmp72_)) {
3124 ValaSymbol* _tmp73_;
3125 ValaSymbol* _tmp74_;
3126 _tmp73_ = vala_symbol_get_parent_symbol ((ValaSymbol*) self);
3127 _tmp74_ = _tmp73_;
3128 _tmp70_ = !VALA_IS_INTERFACE (_tmp74_);
3129 } else {
3130 _tmp70_ = FALSE;
3131 }
3132 if (_tmp70_) {
3133 ValaSourceReference* _tmp75_;
3134 ValaSourceReference* _tmp76_;
3135 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
3136 _tmp75_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
3137 _tmp76_ = _tmp75_;
3138 vala_report_error (_tmp76_, "Protected methods may not be declared outside of classes and interface" \
3139 "s");
3140 result = FALSE;
3141 return result;
3142 }
3143 }
3144 }
3145 }
3146 }
3147 _tmp78_ = self->priv->_is_abstract;
3148 if (_tmp78_) {
3149 ValaBlock* _tmp79_;
3150 ValaBlock* _tmp80_;
3151 _tmp79_ = vala_subroutine_get_body ((ValaSubroutine*) self);
3152 _tmp80_ = _tmp79_;
3153 _tmp77_ = _tmp80_ != NULL;
3154 } else {
3155 _tmp77_ = FALSE;
3156 }
3157 if (_tmp77_) {
3158 ValaSourceReference* _tmp81_;
3159 ValaSourceReference* _tmp82_;
3160 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
3161 _tmp81_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
3162 _tmp82_ = _tmp81_;
3163 vala_report_error (_tmp82_, "Abstract methods cannot have bodies");
3164 } else {
3165 gboolean _tmp83_ = FALSE;
3166 gboolean _tmp84_ = FALSE;
3167 gboolean _tmp85_;
3168 _tmp85_ = self->priv->_is_abstract;
3169 if (_tmp85_) {
3170 _tmp84_ = TRUE;
3171 } else {
3172 gboolean _tmp86_;
3173 _tmp86_ = self->priv->_is_virtual;
3174 _tmp84_ = _tmp86_;
3175 }
3176 if (_tmp84_) {
3177 gboolean _tmp87_;
3178 gboolean _tmp88_;
3179 _tmp87_ = vala_symbol_get_is_extern ((ValaSymbol*) self);
3180 _tmp88_ = _tmp87_;
3181 _tmp83_ = _tmp88_;
3182 } else {
3183 _tmp83_ = FALSE;
3184 }
3185 if (_tmp83_) {
3186 ValaSourceReference* _tmp89_;
3187 ValaSourceReference* _tmp90_;
3188 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
3189 _tmp89_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
3190 _tmp90_ = _tmp89_;
3191 vala_report_error (_tmp90_, "Extern methods cannot be abstract or virtual");
3192 } else {
3193 gboolean _tmp91_ = FALSE;
3194 gboolean _tmp92_;
3195 gboolean _tmp93_;
3196 _tmp92_ = vala_symbol_get_is_extern ((ValaSymbol*) self);
3197 _tmp93_ = _tmp92_;
3198 if (_tmp93_) {
3199 ValaBlock* _tmp94_;
3200 ValaBlock* _tmp95_;
3201 _tmp94_ = vala_subroutine_get_body ((ValaSubroutine*) self);
3202 _tmp95_ = _tmp94_;
3203 _tmp91_ = _tmp95_ != NULL;
3204 } else {
3205 _tmp91_ = FALSE;
3206 }
3207 if (_tmp91_) {
3208 ValaSourceReference* _tmp96_;
3209 ValaSourceReference* _tmp97_;
3210 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
3211 _tmp96_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
3212 _tmp97_ = _tmp96_;
3213 vala_report_error (_tmp97_, "Extern methods cannot have bodies");
3214 } else {
3215 gboolean _tmp98_ = FALSE;
3216 gboolean _tmp99_ = FALSE;
3217 gboolean _tmp100_ = FALSE;
3218 gboolean _tmp101_;
3219 _tmp101_ = self->priv->_is_abstract;
3220 if (!_tmp101_) {
3221 gboolean _tmp102_;
3222 gboolean _tmp103_;
3223 _tmp102_ = vala_symbol_get_external ((ValaSymbol*) self);
3224 _tmp103_ = _tmp102_;
3225 _tmp100_ = !_tmp103_;
3226 } else {
3227 _tmp100_ = FALSE;
3228 }
3229 if (_tmp100_) {
3230 ValaSourceFileType _tmp104_;
3231 ValaSourceFileType _tmp105_;
3232 _tmp104_ = vala_symbol_get_source_type ((ValaSymbol*) self);
3233 _tmp105_ = _tmp104_;
3234 _tmp99_ = _tmp105_ == VALA_SOURCE_FILE_TYPE_SOURCE;
3235 } else {
3236 _tmp99_ = FALSE;
3237 }
3238 if (_tmp99_) {
3239 ValaBlock* _tmp106_;
3240 ValaBlock* _tmp107_;
3241 _tmp106_ = vala_subroutine_get_body ((ValaSubroutine*) self);
3242 _tmp107_ = _tmp106_;
3243 _tmp98_ = _tmp107_ == NULL;
3244 } else {
3245 _tmp98_ = FALSE;
3246 }
3247 if (_tmp98_) {
3248 ValaSourceReference* _tmp108_;
3249 ValaSourceReference* _tmp109_;
3250 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
3251 _tmp108_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
3252 _tmp109_ = _tmp108_;
3253 vala_report_error (_tmp109_, "Non-abstract, non-extern methods must have bodies");
3254 }
3255 }
3256 }
3257 }
3258 _tmp112_ = self->priv->_coroutine;
3259 if (_tmp112_) {
3260 gboolean _tmp113_;
3261 gboolean _tmp114_;
3262 _tmp113_ = vala_symbol_get_external_package ((ValaSymbol*) self);
3263 _tmp114_ = _tmp113_;
3264 _tmp111_ = !_tmp114_;
3265 } else {
3266 _tmp111_ = FALSE;
3267 }
3268 if (_tmp111_) {
3269 _tmp110_ = !vala_code_context_has_package (context, "gio-2.0");
3270 } else {
3271 _tmp110_ = FALSE;
3272 }
3273 if (_tmp110_) {
3274 ValaSourceReference* _tmp115_;
3275 ValaSourceReference* _tmp116_;
3276 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
3277 _tmp115_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
3278 _tmp116_ = _tmp115_;
3279 vala_report_error (_tmp116_, "gio-2.0 package required for async methods");
3280 result = FALSE;
3281 return result;
3282 }
3283 _tmp117_ = vala_code_context_get_analyzer (context);
3284 _tmp118_ = _tmp117_;
3285 _tmp119_ = vala_semantic_analyzer_get_current_source_file (_tmp118_);
3286 _tmp120_ = _tmp119_;
3287 _tmp121_ = _vala_source_file_ref0 (_tmp120_);
3288 old_source_file = _tmp121_;
3289 _tmp122_ = vala_code_context_get_analyzer (context);
3290 _tmp123_ = _tmp122_;
3291 _tmp124_ = vala_semantic_analyzer_get_current_symbol (_tmp123_);
3292 _tmp125_ = _tmp124_;
3293 _tmp126_ = _vala_code_node_ref0 (_tmp125_);
3294 old_symbol = _tmp126_;
3295 _tmp127_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
3296 _tmp128_ = _tmp127_;
3297 if (_tmp128_ != NULL) {
3298 ValaSemanticAnalyzer* _tmp129_;
3299 ValaSemanticAnalyzer* _tmp130_;
3300 ValaSourceReference* _tmp131_;
3301 ValaSourceReference* _tmp132_;
3302 ValaSourceFile* _tmp133_;
3303 ValaSourceFile* _tmp134_;
3304 _tmp129_ = vala_code_context_get_analyzer (context);
3305 _tmp130_ = _tmp129_;
3306 _tmp131_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
3307 _tmp132_ = _tmp131_;
3308 _tmp133_ = vala_source_reference_get_file (_tmp132_);
3309 _tmp134_ = _tmp133_;
3310 vala_semantic_analyzer_set_current_source_file (_tmp130_, _tmp134_);
3311 }
3312 _tmp135_ = vala_code_context_get_analyzer (context);
3313 _tmp136_ = _tmp135_;
3314 vala_semantic_analyzer_set_current_symbol (_tmp136_, (ValaSymbol*) self);
3315 _tmp137_ = vala_callable_get_return_type ((ValaCallable*) self);
3316 _tmp138_ = _tmp137_;
3317 _tmp139_ = vala_method_get_returns_floating_reference (self);
3318 _tmp140_ = _tmp139_;
3319 vala_data_type_set_floating_reference (_tmp138_, _tmp140_);
3320 _tmp141_ = vala_callable_get_return_type ((ValaCallable*) self);
3321 _tmp142_ = _tmp141_;
3322 vala_code_node_check ((ValaCodeNode*) _tmp142_, context);
3323 _tmp143_ = vala_symbol_get_external_package ((ValaSymbol*) self);
3324 _tmp144_ = _tmp143_;
3325 if (!_tmp144_) {
3326 ValaSemanticAnalyzer* _tmp145_;
3327 ValaSemanticAnalyzer* _tmp146_;
3328 ValaDataType* _tmp147_;
3329 ValaDataType* _tmp148_;
3330 _tmp145_ = vala_code_context_get_analyzer (context);
3331 _tmp146_ = _tmp145_;
3332 _tmp147_ = vala_callable_get_return_type ((ValaCallable*) self);
3333 _tmp148_ = _tmp147_;
3334 vala_semantic_analyzer_check_type (_tmp146_, _tmp148_);
3335 }
3336 _tmp149_ = vala_callable_get_return_type ((ValaCallable*) self);
3337 _tmp150_ = _tmp149_;
3338 _tmp151_ = vala_data_type_get_type_symbol (_tmp150_);
3339 _tmp152_ = _tmp151_;
3340 _tmp153_ = vala_code_context_get_analyzer (context);
3341 _tmp154_ = _tmp153_;
3342 _tmp155_ = _tmp154_->va_list_type;
3343 _tmp156_ = vala_data_type_get_type_symbol (_tmp155_);
3344 _tmp157_ = _tmp156_;
3345 if (_tmp152_ == _tmp157_) {
3346 ValaSourceReference* _tmp158_;
3347 ValaSourceReference* _tmp159_;
3348 ValaDataType* _tmp160_;
3349 ValaDataType* _tmp161_;
3350 ValaTypeSymbol* _tmp162_;
3351 ValaTypeSymbol* _tmp163_;
3352 gchar* _tmp164_;
3353 gchar* _tmp165_;
3354 gchar* _tmp166_;
3355 gchar* _tmp167_;
3356 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
3357 _tmp158_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
3358 _tmp159_ = _tmp158_;
3359 _tmp160_ = vala_callable_get_return_type ((ValaCallable*) self);
3360 _tmp161_ = _tmp160_;
3361 _tmp162_ = vala_data_type_get_type_symbol (_tmp161_);
3362 _tmp163_ = _tmp162_;
3363 _tmp164_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp163_);
3364 _tmp165_ = _tmp164_;
3365 _tmp166_ = g_strdup_printf ("`%s' not supported as return type", _tmp165_);
3366 _tmp167_ = _tmp166_;
3367 vala_report_error (_tmp159_, _tmp167_);
3368 _g_free0 (_tmp167_);
3369 _g_free0 (_tmp165_);
3370 result = FALSE;
3371 _vala_code_node_unref0 (old_symbol);
3372 _vala_source_file_unref0 (old_source_file);
3373 return result;
3374 }
3375 _tmp168_ = vala_code_node_get_attribute ((ValaCodeNode*) self, "ModuleInit");
3376 _tmp169_ = _vala_code_node_ref0 (_tmp168_);
3377 init_attr = _tmp169_;
3378 _tmp170_ = init_attr;
3379 if (_tmp170_ != NULL) {
3380 ValaSourceReference* _tmp171_;
3381 ValaSourceReference* _tmp172_;
3382 ValaSourceFile* _tmp173_;
3383 ValaSourceFile* _tmp174_;
3384 ValaCodeContext* _tmp175_;
3385 ValaCodeContext* _tmp176_;
3386 _tmp171_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
3387 _tmp172_ = _tmp171_;
3388 _tmp173_ = vala_source_reference_get_file (_tmp172_);
3389 _tmp174_ = _tmp173_;
3390 _tmp175_ = vala_source_file_get_context (_tmp174_);
3391 _tmp176_ = _tmp175_;
3392 vala_code_context_set_module_init_method (_tmp176_, self);
3393 }
3394 _tmp177_ = vala_callable_get_return_type ((ValaCallable*) self);
3395 _tmp178_ = _tmp177_;
3396 if (_tmp178_ != NULL) {
3397 ValaDataType* _tmp179_;
3398 ValaDataType* _tmp180_;
3399 _tmp179_ = vala_callable_get_return_type ((ValaCallable*) self);
3400 _tmp180_ = _tmp179_;
3401 vala_code_node_check ((ValaCodeNode*) _tmp180_, context);
3402 }
3403 _tmp184_ = self->priv->parameters;
3404 _tmp185_ = vala_collection_get_size ((ValaCollection*) _tmp184_);
3405 _tmp186_ = _tmp185_;
3406 if (_tmp186_ == 1) {
3407 ValaList* _tmp187_;
3408 gpointer _tmp188_;
3409 ValaParameter* _tmp189_;
3410 gboolean _tmp190_;
3411 gboolean _tmp191_;
3412 _tmp187_ = self->priv->parameters;
3413 _tmp188_ = vala_list_get (_tmp187_, 0);
3414 _tmp189_ = (ValaParameter*) _tmp188_;
3415 _tmp190_ = vala_parameter_get_ellipsis (_tmp189_);
3416 _tmp191_ = _tmp190_;
3417 _tmp183_ = _tmp191_;
3418 _vala_code_node_unref0 (_tmp189_);
3419 } else {
3420 _tmp183_ = FALSE;
3421 }
3422 if (_tmp183_) {
3423 ValaBlock* _tmp192_;
3424 ValaBlock* _tmp193_;
3425 _tmp192_ = vala_subroutine_get_body ((ValaSubroutine*) self);
3426 _tmp193_ = _tmp192_;
3427 _tmp182_ = _tmp193_ != NULL;
3428 } else {
3429 _tmp182_ = FALSE;
3430 }
3431 if (_tmp182_) {
3432 ValaMemberBinding _tmp194_;
3433 _tmp194_ = self->priv->_binding;
3434 _tmp181_ = _tmp194_ != VALA_MEMBER_BINDING_INSTANCE;
3435 } else {
3436 _tmp181_ = FALSE;
3437 }
3438 if (_tmp181_) {
3439 ValaList* _tmp195_;
3440 gpointer _tmp196_;
3441 ValaParameter* _tmp197_;
3442 ValaSourceReference* _tmp198_;
3443 ValaSourceReference* _tmp199_;
3444 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
3445 _tmp195_ = self->priv->parameters;
3446 _tmp196_ = vala_list_get (_tmp195_, 0);
3447 _tmp197_ = (ValaParameter*) _tmp196_;
3448 _tmp198_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp197_);
3449 _tmp199_ = _tmp198_;
3450 vala_report_error (_tmp199_, "Named parameter required before `...'");
3451 _vala_code_node_unref0 (_tmp197_);
3452 }
3453 _tmp201_ = vala_code_node_get_attribute ((ValaCodeNode*) self, "Print");
3454 if (_tmp201_ != NULL) {
3455 gboolean _tmp202_ = FALSE;
3456 ValaList* _tmp203_;
3457 gint _tmp204_;
3458 gint _tmp205_;
3459 _tmp203_ = self->priv->parameters;
3460 _tmp204_ = vala_collection_get_size ((ValaCollection*) _tmp203_);
3461 _tmp205_ = _tmp204_;
3462 if (_tmp205_ != 1) {
3463 _tmp202_ = TRUE;
3464 } else {
3465 ValaList* _tmp206_;
3466 gpointer _tmp207_;
3467 ValaParameter* _tmp208_;
3468 ValaDataType* _tmp209_;
3469 ValaDataType* _tmp210_;
3470 ValaTypeSymbol* _tmp211_;
3471 ValaTypeSymbol* _tmp212_;
3472 ValaSemanticAnalyzer* _tmp213_;
3473 ValaSemanticAnalyzer* _tmp214_;
3474 ValaDataType* _tmp215_;
3475 ValaTypeSymbol* _tmp216_;
3476 ValaTypeSymbol* _tmp217_;
3477 _tmp206_ = self->priv->parameters;
3478 _tmp207_ = vala_list_get (_tmp206_, 0);
3479 _tmp208_ = (ValaParameter*) _tmp207_;
3480 _tmp209_ = vala_variable_get_variable_type ((ValaVariable*) _tmp208_);
3481 _tmp210_ = _tmp209_;
3482 _tmp211_ = vala_data_type_get_type_symbol (_tmp210_);
3483 _tmp212_ = _tmp211_;
3484 _tmp213_ = vala_code_context_get_analyzer (context);
3485 _tmp214_ = _tmp213_;
3486 _tmp215_ = _tmp214_->string_type;
3487 _tmp216_ = vala_data_type_get_type_symbol (_tmp215_);
3488 _tmp217_ = _tmp216_;
3489 _tmp202_ = _tmp212_ != _tmp217_;
3490 _vala_code_node_unref0 (_tmp208_);
3491 }
3492 _tmp200_ = _tmp202_;
3493 } else {
3494 _tmp200_ = FALSE;
3495 }
3496 if (_tmp200_) {
3497 ValaSourceReference* _tmp218_;
3498 ValaSourceReference* _tmp219_;
3499 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
3500 _tmp218_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
3501 _tmp219_ = _tmp218_;
3502 vala_report_error (_tmp219_, "[Print] methods must have exactly one parameter of type `string'");
3503 }
3504 optional_param = FALSE;
3505 params_array_param = FALSE;
3506 {
3507 ValaList* _param_list = NULL;
3508 ValaList* _tmp220_;
3509 ValaList* _tmp221_;
3510 gint _param_size = 0;
3511 ValaList* _tmp222_;
3512 gint _tmp223_;
3513 gint _tmp224_;
3514 gint _param_index = 0;
3515 _tmp220_ = self->priv->parameters;
3516 _tmp221_ = _vala_iterable_ref0 (_tmp220_);
3517 _param_list = _tmp221_;
3518 _tmp222_ = _param_list;
3519 _tmp223_ = vala_collection_get_size ((ValaCollection*) _tmp222_);
3520 _tmp224_ = _tmp223_;
3521 _param_size = _tmp224_;
3522 _param_index = -1;
3523 while (TRUE) {
3524 gint _tmp225_;
3525 gint _tmp226_;
3526 ValaParameter* param = NULL;
3527 ValaList* _tmp227_;
3528 gpointer _tmp228_;
3529 ValaParameter* _tmp229_;
3530 gboolean _tmp230_ = FALSE;
3531 gboolean _tmp231_;
3532 gboolean _tmp238_ = FALSE;
3533 gboolean _tmp239_ = FALSE;
3534 gboolean _tmp240_;
3535 gboolean _tmp241_;
3536 gboolean _tmp264_;
3537 gboolean _tmp265_ = FALSE;
3538 gboolean _tmp266_ = FALSE;
3539 gboolean _tmp285_ = FALSE;
3540 ValaParameter* _tmp286_;
3541 gboolean _tmp287_;
3542 gboolean _tmp288_;
3543 _param_index = _param_index + 1;
3544 _tmp225_ = _param_index;
3545 _tmp226_ = _param_size;
3546 if (!(_tmp225_ < _tmp226_)) {
3547 break;
3548 }
3549 _tmp227_ = _param_list;
3550 _tmp228_ = vala_list_get (_tmp227_, _param_index);
3551 param = (ValaParameter*) _tmp228_;
3552 _tmp229_ = param;
3553 if (!vala_code_node_check ((ValaCodeNode*) _tmp229_, context)) {
3554 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
3555 _vala_code_node_unref0 (param);
3556 continue;
3557 }
3558 _tmp231_ = self->priv->_coroutine;
3559 if (_tmp231_) {
3560 ValaParameter* _tmp232_;
3561 ValaParameterDirection _tmp233_;
3562 ValaParameterDirection _tmp234_;
3563 _tmp232_ = param;
3564 _tmp233_ = vala_parameter_get_direction (_tmp232_);
3565 _tmp234_ = _tmp233_;
3566 _tmp230_ = _tmp234_ == VALA_PARAMETER_DIRECTION_REF;
3567 } else {
3568 _tmp230_ = FALSE;
3569 }
3570 if (_tmp230_) {
3571 ValaParameter* _tmp235_;
3572 ValaSourceReference* _tmp236_;
3573 ValaSourceReference* _tmp237_;
3574 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
3575 _tmp235_ = param;
3576 _tmp236_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp235_);
3577 _tmp237_ = _tmp236_;
3578 vala_report_error (_tmp237_, "Reference parameters are not supported for async methods");
3579 }
3580 _tmp240_ = vala_symbol_get_external_package ((ValaSymbol*) self);
3581 _tmp241_ = _tmp240_;
3582 if (!_tmp241_) {
3583 gboolean _tmp242_;
3584 _tmp242_ = self->priv->_coroutine;
3585 _tmp239_ = _tmp242_;
3586 } else {
3587 _tmp239_ = FALSE;
3588 }
3589 if (_tmp239_) {
3590 gboolean _tmp243_ = FALSE;
3591 gboolean _tmp244_ = FALSE;
3592 ValaParameter* _tmp245_;
3593 gboolean _tmp246_;
3594 gboolean _tmp247_;
3595 _tmp245_ = param;
3596 _tmp246_ = vala_parameter_get_ellipsis (_tmp245_);
3597 _tmp247_ = _tmp246_;
3598 if (_tmp247_) {
3599 _tmp244_ = TRUE;
3600 } else {
3601 ValaParameter* _tmp248_;
3602 gboolean _tmp249_;
3603 gboolean _tmp250_;
3604 _tmp248_ = param;
3605 _tmp249_ = vala_parameter_get_params_array (_tmp248_);
3606 _tmp250_ = _tmp249_;
3607 _tmp244_ = _tmp250_;
3608 }
3609 if (_tmp244_) {
3610 _tmp243_ = TRUE;
3611 } else {
3612 ValaParameter* _tmp251_;
3613 ValaDataType* _tmp252_;
3614 ValaDataType* _tmp253_;
3615 ValaTypeSymbol* _tmp254_;
3616 ValaTypeSymbol* _tmp255_;
3617 ValaSemanticAnalyzer* _tmp256_;
3618 ValaSemanticAnalyzer* _tmp257_;
3619 ValaDataType* _tmp258_;
3620 ValaTypeSymbol* _tmp259_;
3621 ValaTypeSymbol* _tmp260_;
3622 _tmp251_ = param;
3623 _tmp252_ = vala_variable_get_variable_type ((ValaVariable*) _tmp251_);
3624 _tmp253_ = _tmp252_;
3625 _tmp254_ = vala_data_type_get_type_symbol (_tmp253_);
3626 _tmp255_ = _tmp254_;
3627 _tmp256_ = vala_code_context_get_analyzer (context);
3628 _tmp257_ = _tmp256_;
3629 _tmp258_ = _tmp257_->va_list_type;
3630 _tmp259_ = vala_data_type_get_type_symbol (_tmp258_);
3631 _tmp260_ = _tmp259_;
3632 _tmp243_ = _tmp255_ == _tmp260_;
3633 }
3634 _tmp238_ = _tmp243_;
3635 } else {
3636 _tmp238_ = FALSE;
3637 }
3638 if (_tmp238_) {
3639 ValaParameter* _tmp261_;
3640 ValaSourceReference* _tmp262_;
3641 ValaSourceReference* _tmp263_;
3642 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
3643 _tmp261_ = param;
3644 _tmp262_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp261_);
3645 _tmp263_ = _tmp262_;
3646 vala_report_error (_tmp263_, "Variadic parameters are not supported for async methods");
3647 result = FALSE;
3648 _vala_code_node_unref0 (param);
3649 _vala_iterable_unref0 (_param_list);
3650 _vala_code_node_unref0 (init_attr);
3651 _vala_code_node_unref0 (old_symbol);
3652 _vala_source_file_unref0 (old_source_file);
3653 return result;
3654 }
3655 _tmp264_ = self->priv->_coroutine;
3656 if (_tmp264_) {
3657 _vala_code_node_unref0 (param);
3658 continue;
3659 }
3660 if (optional_param) {
3661 ValaParameter* _tmp267_;
3662 ValaExpression* _tmp268_;
3663 ValaExpression* _tmp269_;
3664 _tmp267_ = param;
3665 _tmp268_ = vala_variable_get_initializer ((ValaVariable*) _tmp267_);
3666 _tmp269_ = _tmp268_;
3667 _tmp266_ = _tmp269_ == NULL;
3668 } else {
3669 _tmp266_ = FALSE;
3670 }
3671 if (_tmp266_) {
3672 ValaParameter* _tmp270_;
3673 gboolean _tmp271_;
3674 gboolean _tmp272_;
3675 _tmp270_ = param;
3676 _tmp271_ = vala_parameter_get_ellipsis (_tmp270_);
3677 _tmp272_ = _tmp271_;
3678 _tmp265_ = !_tmp272_;
3679 } else {
3680 _tmp265_ = FALSE;
3681 }
3682 if (_tmp265_) {
3683 ValaParameter* _tmp273_;
3684 ValaSourceReference* _tmp274_;
3685 ValaSourceReference* _tmp275_;
3686 _tmp273_ = param;
3687 _tmp274_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp273_);
3688 _tmp275_ = _tmp274_;
3689 vala_report_warning (_tmp275_, "parameter without default follows parameter with default");
3690 } else {
3691 ValaParameter* _tmp276_;
3692 ValaExpression* _tmp277_;
3693 ValaExpression* _tmp278_;
3694 _tmp276_ = param;
3695 _tmp277_ = vala_variable_get_initializer ((ValaVariable*) _tmp276_);
3696 _tmp278_ = _tmp277_;
3697 if (_tmp278_ != NULL) {
3698 optional_param = TRUE;
3699 }
3700 }
3701 if (params_array_param) {
3702 ValaParameter* _tmp279_;
3703 ValaSourceReference* _tmp280_;
3704 ValaSourceReference* _tmp281_;
3705 _tmp279_ = param;
3706 _tmp280_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp279_);
3707 _tmp281_ = _tmp280_;
3708 vala_report_error (_tmp281_, "parameter follows params-array parameter");
3709 } else {
3710 ValaParameter* _tmp282_;
3711 gboolean _tmp283_;
3712 gboolean _tmp284_;
3713 _tmp282_ = param;
3714 _tmp283_ = vala_parameter_get_params_array (_tmp282_);
3715 _tmp284_ = _tmp283_;
3716 if (_tmp284_) {
3717 params_array_param = TRUE;
3718 }
3719 }
3720 _tmp286_ = param;
3721 _tmp287_ = vala_parameter_get_params_array (_tmp286_);
3722 _tmp288_ = _tmp287_;
3723 if (_tmp288_) {
3724 ValaBlock* _tmp289_;
3725 ValaBlock* _tmp290_;
3726 _tmp289_ = vala_subroutine_get_body ((ValaSubroutine*) self);
3727 _tmp290_ = _tmp289_;
3728 _tmp285_ = _tmp290_ != NULL;
3729 } else {
3730 _tmp285_ = FALSE;
3731 }
3732 if (_tmp285_) {
3733 ValaLocalVariable* _tmp291_;
3734 gboolean _tmp295_;
3735 gboolean _tmp296_;
3736 ValaArrayType* type = NULL;
3737 ValaParameter* _tmp300_;
3738 ValaDataType* _tmp301_;
3739 ValaDataType* _tmp302_;
3740 ValaDataType* _tmp303_;
3741 ValaArrayType* _tmp304_;
3742 ValaDataType* _tmp305_;
3743 ValaDataType* _tmp306_;
3744 ValaArrayType* _tmp307_;
3745 gboolean _tmp308_;
3746 gboolean _tmp309_;
3747 ValaArrayType* _tmp310_;
3748 gboolean _tmp311_ = FALSE;
3749 ValaArrayType* _tmp312_;
3750 ValaDataType* _tmp313_;
3751 ValaDataType* _tmp314_;
3752 ValaArrayType* _tmp323_;
3753 ValaExpression* _tmp324_;
3754 ValaExpression* _tmp325_;
3755 ValaArrayType* _tmp329_;
3756 ValaParameter* _tmp330_;
3757 const gchar* _tmp331_;
3758 const gchar* _tmp332_;
3759 ValaParameter* _tmp333_;
3760 ValaSourceReference* _tmp334_;
3761 ValaSourceReference* _tmp335_;
3762 ValaLocalVariable* _tmp336_;
3763 ValaLocalVariable* _tmp337_;
3764 ValaBlock* _tmp338_;
3765 ValaBlock* _tmp339_;
3766 ValaLocalVariable* _tmp340_;
3767 ValaParameter* _tmp341_;
3768 ValaSourceReference* _tmp342_;
3769 ValaSourceReference* _tmp343_;
3770 ValaDeclarationStatement* _tmp344_;
3771 ValaDeclarationStatement* _tmp345_;
3772 _tmp291_ = self->priv->_params_array_var;
3773 if (_tmp291_ != NULL) {
3774 ValaParameter* _tmp292_;
3775 ValaSourceReference* _tmp293_;
3776 ValaSourceReference* _tmp294_;
3777 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
3778 _tmp292_ = param;
3779 _tmp293_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp292_);
3780 _tmp294_ = _tmp293_;
3781 vala_report_error (_tmp294_, "Only one params-array parameter is allowed");
3782 _vala_code_node_unref0 (param);
3783 continue;
3784 }
3785 _tmp295_ = vala_code_context_get_experimental (context);
3786 _tmp296_ = _tmp295_;
3787 if (!_tmp296_) {
3788 ValaParameter* _tmp297_;
3789 ValaSourceReference* _tmp298_;
3790 ValaSourceReference* _tmp299_;
3791 _tmp297_ = param;
3792 _tmp298_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp297_);
3793 _tmp299_ = _tmp298_;
3794 vala_report_warning (_tmp299_, "Support of params-arrays is experimental");
3795 }
3796 _tmp300_ = param;
3797 _tmp301_ = vala_variable_get_variable_type ((ValaVariable*) _tmp300_);
3798 _tmp302_ = _tmp301_;
3799 _tmp303_ = vala_data_type_copy (_tmp302_);
3800 type = G_TYPE_CHECK_INSTANCE_CAST (_tmp303_, VALA_TYPE_ARRAY_TYPE, ValaArrayType);
3801 _tmp304_ = type;
3802 _tmp305_ = vala_array_type_get_element_type (_tmp304_);
3803 _tmp306_ = _tmp305_;
3804 _tmp307_ = type;
3805 _tmp308_ = vala_data_type_get_value_owned ((ValaDataType*) _tmp307_);
3806 _tmp309_ = _tmp308_;
3807 vala_data_type_set_value_owned (_tmp306_, _tmp309_);
3808 _tmp310_ = type;
3809 vala_data_type_set_value_owned ((ValaDataType*) _tmp310_, TRUE);
3810 _tmp312_ = type;
3811 _tmp313_ = vala_array_type_get_element_type (_tmp312_);
3812 _tmp314_ = _tmp313_;
3813 if (vala_data_type_is_real_struct_type (_tmp314_)) {
3814 ValaArrayType* _tmp315_;
3815 ValaDataType* _tmp316_;
3816 ValaDataType* _tmp317_;
3817 gboolean _tmp318_;
3818 gboolean _tmp319_;
3819 _tmp315_ = type;
3820 _tmp316_ = vala_array_type_get_element_type (_tmp315_);
3821 _tmp317_ = _tmp316_;
3822 _tmp318_ = vala_data_type_get_nullable (_tmp317_);
3823 _tmp319_ = _tmp318_;
3824 _tmp311_ = !_tmp319_;
3825 } else {
3826 _tmp311_ = FALSE;
3827 }
3828 if (_tmp311_) {
3829 ValaParameter* _tmp320_;
3830 ValaSourceReference* _tmp321_;
3831 ValaSourceReference* _tmp322_;
3832 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
3833 _tmp320_ = param;
3834 _tmp321_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp320_);
3835 _tmp322_ = _tmp321_;
3836 vala_report_error (_tmp322_, "Only nullable struct elements are supported in params-array");
3837 }
3838 _tmp323_ = type;
3839 _tmp324_ = vala_array_type_get_length (_tmp323_);
3840 _tmp325_ = _tmp324_;
3841 if (_tmp325_ != NULL) {
3842 ValaParameter* _tmp326_;
3843 ValaSourceReference* _tmp327_;
3844 ValaSourceReference* _tmp328_;
3845 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
3846 _tmp326_ = param;
3847 _tmp327_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp326_);
3848 _tmp328_ = _tmp327_;
3849 vala_report_error (_tmp328_, "Passing length to params-array is not supported yet");
3850 }
3851 _tmp329_ = type;
3852 _tmp330_ = param;
3853 _tmp331_ = vala_symbol_get_name ((ValaSymbol*) _tmp330_);
3854 _tmp332_ = _tmp331_;
3855 _tmp333_ = param;
3856 _tmp334_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp333_);
3857 _tmp335_ = _tmp334_;
3858 _tmp336_ = vala_local_variable_new ((ValaDataType*) _tmp329_, _tmp332_, NULL, _tmp335_);
3859 _tmp337_ = _tmp336_;
3860 vala_method_set_params_array_var (self, _tmp337_);
3861 _vala_code_node_unref0 (_tmp337_);
3862 _tmp338_ = vala_subroutine_get_body ((ValaSubroutine*) self);
3863 _tmp339_ = _tmp338_;
3864 _tmp340_ = self->priv->_params_array_var;
3865 _tmp341_ = param;
3866 _tmp342_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp341_);
3867 _tmp343_ = _tmp342_;
3868 _tmp344_ = vala_declaration_statement_new ((ValaSymbol*) _tmp340_, _tmp343_);
3869 _tmp345_ = _tmp344_;
3870 vala_block_insert_statement (_tmp339_, 0, (ValaStatement*) _tmp345_);
3871 _vala_code_node_unref0 (_tmp345_);
3872 _vala_code_node_unref0 (type);
3873 }
3874 _vala_code_node_unref0 (param);
3875 }
3876 _vala_iterable_unref0 (_param_list);
3877 }
3878 _tmp346_ = self->priv->_coroutine;
3879 if (_tmp346_) {
3880 gboolean requires_pointer = FALSE;
3881 requires_pointer = FALSE;
3882 {
3883 gint i = 0;
3884 ValaList* _tmp347_;
3885 gint _tmp348_;
3886 gint _tmp349_;
3887 _tmp347_ = self->priv->parameters;
3888 _tmp348_ = vala_collection_get_size ((ValaCollection*) _tmp347_);
3889 _tmp349_ = _tmp348_;
3890 i = _tmp349_ - 1;
3891 {
3892 gboolean _tmp350_ = FALSE;
3893 _tmp350_ = TRUE;
3894 while (TRUE) {
3895 ValaParameter* param = NULL;
3896 ValaList* _tmp352_;
3897 gpointer _tmp353_;
3898 ValaParameter* _tmp354_;
3899 ValaParameterDirection _tmp355_;
3900 ValaParameterDirection _tmp356_;
3901 if (!_tmp350_) {
3902 gint _tmp351_;
3903 _tmp351_ = i;
3904 i = _tmp351_ - 1;
3905 }
3906 _tmp350_ = FALSE;
3907 if (!(i >= 0)) {
3908 break;
3909 }
3910 _tmp352_ = self->priv->parameters;
3911 _tmp353_ = vala_list_get (_tmp352_, i);
3912 param = (ValaParameter*) _tmp353_;
3913 _tmp354_ = param;
3914 _tmp355_ = vala_parameter_get_direction (_tmp354_);
3915 _tmp356_ = _tmp355_;
3916 if (_tmp356_ == VALA_PARAMETER_DIRECTION_IN) {
3917 requires_pointer = TRUE;
3918 } else {
3919 if (requires_pointer) {
3920 ValaParameter* _tmp357_;
3921 ValaSourceReference* _tmp358_;
3922 ValaSourceReference* _tmp359_;
3923 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
3924 _tmp357_ = param;
3925 _tmp358_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp357_);
3926 _tmp359_ = _tmp358_;
3927 vala_report_error (_tmp359_, "Synchronous out-parameters are not supported in async methods");
3928 }
3929 }
3930 _vala_code_node_unref0 (param);
3931 }
3932 }
3933 }
3934 }
3935 _tmp360_ = self->error_types;
3936 if (_tmp360_ != NULL) {
3937 {
3938 ValaList* _error_type_list = NULL;
3939 ValaList* _tmp361_;
3940 ValaList* _tmp362_;
3941 gint _error_type_size = 0;
3942 ValaList* _tmp363_;
3943 gint _tmp364_;
3944 gint _tmp365_;
3945 gint _error_type_index = 0;
3946 _tmp361_ = self->error_types;
3947 _tmp362_ = _vala_iterable_ref0 (_tmp361_);
3948 _error_type_list = _tmp362_;
3949 _tmp363_ = _error_type_list;
3950 _tmp364_ = vala_collection_get_size ((ValaCollection*) _tmp363_);
3951 _tmp365_ = _tmp364_;
3952 _error_type_size = _tmp365_;
3953 _error_type_index = -1;
3954 while (TRUE) {
3955 gint _tmp366_;
3956 gint _tmp367_;
3957 ValaDataType* error_type = NULL;
3958 ValaList* _tmp368_;
3959 gpointer _tmp369_;
3960 ValaDataType* _tmp370_;
3961 ValaSemanticAnalyzer* _tmp371_;
3962 ValaSemanticAnalyzer* _tmp372_;
3963 ValaDataType* _tmp373_;
3964 _error_type_index = _error_type_index + 1;
3965 _tmp366_ = _error_type_index;
3966 _tmp367_ = _error_type_size;
3967 if (!(_tmp366_ < _tmp367_)) {
3968 break;
3969 }
3970 _tmp368_ = _error_type_list;
3971 _tmp369_ = vala_list_get (_tmp368_, _error_type_index);
3972 error_type = (ValaDataType*) _tmp369_;
3973 _tmp370_ = error_type;
3974 vala_code_node_check ((ValaCodeNode*) _tmp370_, context);
3975 _tmp371_ = vala_code_context_get_analyzer (context);
3976 _tmp372_ = _tmp371_;
3977 _tmp373_ = error_type;
3978 if (!vala_semantic_analyzer_is_type_accessible (_tmp372_, (ValaSymbol*) self, _tmp373_)) {
3979 ValaSourceReference* _tmp374_;
3980 ValaSourceReference* _tmp375_;
3981 ValaDataType* _tmp376_;
3982 gchar* _tmp377_;
3983 gchar* _tmp378_;
3984 gchar* _tmp379_;
3985 gchar* _tmp380_;
3986 gchar* _tmp381_;
3987 gchar* _tmp382_;
3988 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
3989 _tmp374_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
3990 _tmp375_ = _tmp374_;
3991 _tmp376_ = error_type;
3992 _tmp377_ = vala_code_node_to_string ((ValaCodeNode*) _tmp376_);
3993 _tmp378_ = _tmp377_;
3994 _tmp379_ = vala_symbol_get_full_name ((ValaSymbol*) self);
3995 _tmp380_ = _tmp379_;
3996 _tmp381_ = g_strdup_printf ("error type `%s' is less accessible than method `%s'", _tmp378_, _tmp380_);
3997 _tmp382_ = _tmp381_;
3998 vala_report_error (_tmp375_, _tmp382_);
3999 _g_free0 (_tmp382_);
4000 _g_free0 (_tmp380_);
4001 _g_free0 (_tmp378_);
4002 result = FALSE;
4003 _vala_code_node_unref0 (error_type);
4004 _vala_iterable_unref0 (_error_type_list);
4005 _vala_code_node_unref0 (init_attr);
4006 _vala_code_node_unref0 (old_symbol);
4007 _vala_source_file_unref0 (old_source_file);
4008 return result;
4009 }
4010 _vala_code_node_unref0 (error_type);
4011 }
4012 _vala_iterable_unref0 (_error_type_list);
4013 }
4014 }
4015 _tmp383_ = vala_subroutine_get_result_var ((ValaSubroutine*) self);
4016 _tmp384_ = _tmp383_;
4017 if (_tmp384_ != NULL) {
4018 ValaLocalVariable* _tmp385_;
4019 ValaLocalVariable* _tmp386_;
4020 _tmp385_ = vala_subroutine_get_result_var ((ValaSubroutine*) self);
4021 _tmp386_ = _tmp385_;
4022 vala_code_node_check ((ValaCodeNode*) _tmp386_, context);
4023 }
4024 _tmp387_ = self->priv->preconditions;
4025 if (_tmp387_ != NULL) {
4026 {
4027 ValaList* _precondition_list = NULL;
4028 ValaList* _tmp388_;
4029 ValaList* _tmp389_;
4030 gint _precondition_size = 0;
4031 ValaList* _tmp390_;
4032 gint _tmp391_;
4033 gint _tmp392_;
4034 gint _precondition_index = 0;
4035 _tmp388_ = self->priv->preconditions;
4036 _tmp389_ = _vala_iterable_ref0 (_tmp388_);
4037 _precondition_list = _tmp389_;
4038 _tmp390_ = _precondition_list;
4039 _tmp391_ = vala_collection_get_size ((ValaCollection*) _tmp390_);
4040 _tmp392_ = _tmp391_;
4041 _precondition_size = _tmp392_;
4042 _precondition_index = -1;
4043 while (TRUE) {
4044 gint _tmp393_;
4045 gint _tmp394_;
4046 ValaExpression* precondition = NULL;
4047 ValaList* _tmp395_;
4048 gpointer _tmp396_;
4049 ValaExpression* _tmp397_;
4050 _precondition_index = _precondition_index + 1;
4051 _tmp393_ = _precondition_index;
4052 _tmp394_ = _precondition_size;
4053 if (!(_tmp393_ < _tmp394_)) {
4054 break;
4055 }
4056 _tmp395_ = _precondition_list;
4057 _tmp396_ = vala_list_get (_tmp395_, _precondition_index);
4058 precondition = (ValaExpression*) _tmp396_;
4059 _tmp397_ = precondition;
4060 vala_code_node_check ((ValaCodeNode*) _tmp397_, context);
4061 _vala_code_node_unref0 (precondition);
4062 }
4063 _vala_iterable_unref0 (_precondition_list);
4064 }
4065 }
4066 _tmp398_ = self->priv->postconditions;
4067 if (_tmp398_ != NULL) {
4068 {
4069 ValaList* _postcondition_list = NULL;
4070 ValaList* _tmp399_;
4071 ValaList* _tmp400_;
4072 gint _postcondition_size = 0;
4073 ValaList* _tmp401_;
4074 gint _tmp402_;
4075 gint _tmp403_;
4076 gint _postcondition_index = 0;
4077 _tmp399_ = self->priv->postconditions;
4078 _tmp400_ = _vala_iterable_ref0 (_tmp399_);
4079 _postcondition_list = _tmp400_;
4080 _tmp401_ = _postcondition_list;
4081 _tmp402_ = vala_collection_get_size ((ValaCollection*) _tmp401_);
4082 _tmp403_ = _tmp402_;
4083 _postcondition_size = _tmp403_;
4084 _postcondition_index = -1;
4085 while (TRUE) {
4086 gint _tmp404_;
4087 gint _tmp405_;
4088 ValaExpression* postcondition = NULL;
4089 ValaList* _tmp406_;
4090 gpointer _tmp407_;
4091 ValaExpression* _tmp408_;
4092 _postcondition_index = _postcondition_index + 1;
4093 _tmp404_ = _postcondition_index;
4094 _tmp405_ = _postcondition_size;
4095 if (!(_tmp404_ < _tmp405_)) {
4096 break;
4097 }
4098 _tmp406_ = _postcondition_list;
4099 _tmp407_ = vala_list_get (_tmp406_, _postcondition_index);
4100 postcondition = (ValaExpression*) _tmp407_;
4101 _tmp408_ = postcondition;
4102 vala_code_node_check ((ValaCodeNode*) _tmp408_, context);
4103 _vala_code_node_unref0 (postcondition);
4104 }
4105 _vala_iterable_unref0 (_postcondition_list);
4106 }
4107 }
4108 _tmp409_ = vala_subroutine_get_body ((ValaSubroutine*) self);
4109 _tmp410_ = _tmp409_;
4110 if (_tmp410_ != NULL) {
4111 ValaBlock* _tmp411_;
4112 ValaBlock* _tmp412_;
4113 _tmp411_ = vala_subroutine_get_body ((ValaSubroutine*) self);
4114 _tmp412_ = _tmp411_;
4115 vala_code_node_check ((ValaCodeNode*) _tmp412_, context);
4116 }
4117 _tmp413_ = vala_code_context_get_analyzer (context);
4118 _tmp414_ = _tmp413_;
4119 _tmp415_ = vala_semantic_analyzer_get_current_struct (_tmp414_);
4120 _tmp416_ = _tmp415_;
4121 if (_tmp416_ != NULL) {
4122 gboolean _tmp417_ = FALSE;
4123 gboolean _tmp418_ = FALSE;
4124 gboolean _tmp419_;
4125 _tmp419_ = self->priv->_is_abstract;
4126 if (_tmp419_) {
4127 _tmp418_ = TRUE;
4128 } else {
4129 gboolean _tmp420_;
4130 _tmp420_ = self->priv->_is_virtual;
4131 _tmp418_ = _tmp420_;
4132 }
4133 if (_tmp418_) {
4134 _tmp417_ = TRUE;
4135 } else {
4136 gboolean _tmp421_;
4137 _tmp421_ = self->priv->_overrides;
4138 _tmp417_ = _tmp421_;
4139 }
4140 if (_tmp417_) {
4141 ValaSourceReference* _tmp422_;
4142 ValaSourceReference* _tmp423_;
4143 gchar* _tmp424_;
4144 gchar* _tmp425_;
4145 gchar* _tmp426_;
4146 gchar* _tmp427_;
4147 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
4148 _tmp422_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
4149 _tmp423_ = _tmp422_;
4150 _tmp424_ = vala_symbol_get_full_name ((ValaSymbol*) self);
4151 _tmp425_ = _tmp424_;
4152 _tmp426_ = g_strdup_printf ("A struct member `%s' cannot be marked as override, virtual, or abstrac" \
4153 "t", _tmp425_);
4154 _tmp427_ = _tmp426_;
4155 vala_report_error (_tmp423_, _tmp427_);
4156 _g_free0 (_tmp427_);
4157 _g_free0 (_tmp425_);
4158 result = FALSE;
4159 _vala_code_node_unref0 (init_attr);
4160 _vala_code_node_unref0 (old_symbol);
4161 _vala_source_file_unref0 (old_source_file);
4162 return result;
4163 }
4164 } else {
4165 gboolean _tmp428_ = FALSE;
4166 gboolean _tmp429_ = FALSE;
4167 gboolean _tmp430_ = FALSE;
4168 gboolean _tmp431_;
4169 _tmp431_ = self->priv->_overrides;
4170 if (_tmp431_) {
4171 ValaMethod* _tmp432_;
4172 ValaMethod* _tmp433_;
4173 _tmp432_ = vala_method_get_base_method (self);
4174 _tmp433_ = _tmp432_;
4175 _tmp430_ = _tmp433_ == NULL;
4176 } else {
4177 _tmp430_ = FALSE;
4178 }
4179 if (_tmp430_) {
4180 ValaMethod* _tmp434_;
4181 ValaMethod* _tmp435_;
4182 _tmp434_ = vala_method_get_base_interface_method (self);
4183 _tmp435_ = _tmp434_;
4184 _tmp429_ = _tmp435_ != NULL;
4185 } else {
4186 _tmp429_ = FALSE;
4187 }
4188 if (_tmp429_) {
4189 ValaMethod* _tmp436_;
4190 ValaMethod* _tmp437_;
4191 gboolean _tmp438_;
4192 _tmp436_ = vala_method_get_base_interface_method (self);
4193 _tmp437_ = _tmp436_;
4194 _tmp438_ = _tmp437_->priv->_is_abstract;
4195 _tmp428_ = _tmp438_;
4196 } else {
4197 _tmp428_ = FALSE;
4198 }
4199 if (_tmp428_) {
4200 ValaSourceReference* _tmp439_;
4201 ValaSourceReference* _tmp440_;
4202 ValaMethod* _tmp441_;
4203 ValaMethod* _tmp442_;
4204 gchar* _tmp443_;
4205 gchar* _tmp444_;
4206 gchar* _tmp445_;
4207 gchar* _tmp446_;
4208 _tmp439_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
4209 _tmp440_ = _tmp439_;
4210 _tmp441_ = vala_method_get_base_interface_method (self);
4211 _tmp442_ = _tmp441_;
4212 _tmp443_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp442_);
4213 _tmp444_ = _tmp443_;
4214 _tmp445_ = g_strdup_printf ("`override' not required to implement `abstract' interface method `%s'", _tmp444_);
4215 _tmp446_ = _tmp445_;
4216 vala_report_warning (_tmp440_, _tmp446_);
4217 _g_free0 (_tmp446_);
4218 _g_free0 (_tmp444_);
4219 vala_method_set_overrides (self, FALSE);
4220 } else {
4221 gboolean _tmp447_ = FALSE;
4222 gboolean _tmp448_ = FALSE;
4223 gboolean _tmp449_;
4224 _tmp449_ = self->priv->_overrides;
4225 if (_tmp449_) {
4226 ValaMethod* _tmp450_;
4227 ValaMethod* _tmp451_;
4228 _tmp450_ = vala_method_get_base_method (self);
4229 _tmp451_ = _tmp450_;
4230 _tmp448_ = _tmp451_ == NULL;
4231 } else {
4232 _tmp448_ = FALSE;
4233 }
4234 if (_tmp448_) {
4235 ValaMethod* _tmp452_;
4236 ValaMethod* _tmp453_;
4237 _tmp452_ = vala_method_get_base_interface_method (self);
4238 _tmp453_ = _tmp452_;
4239 _tmp447_ = _tmp453_ == NULL;
4240 } else {
4241 _tmp447_ = FALSE;
4242 }
4243 if (_tmp447_) {
4244 ValaSourceReference* _tmp454_;
4245 ValaSourceReference* _tmp455_;
4246 gchar* _tmp456_;
4247 gchar* _tmp457_;
4248 gchar* _tmp458_;
4249 gchar* _tmp459_;
4250 _tmp454_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
4251 _tmp455_ = _tmp454_;
4252 _tmp456_ = vala_symbol_get_full_name ((ValaSymbol*) self);
4253 _tmp457_ = _tmp456_;
4254 _tmp458_ = g_strdup_printf ("`%s': no suitable method found to override", _tmp457_);
4255 _tmp459_ = _tmp458_;
4256 vala_report_error (_tmp455_, _tmp459_);
4257 _g_free0 (_tmp459_);
4258 _g_free0 (_tmp457_);
4259 } else {
4260 gboolean _tmp460_ = FALSE;
4261 gboolean _tmp461_ = FALSE;
4262 gboolean _tmp462_ = FALSE;
4263 gboolean _tmp463_;
4264 _tmp463_ = self->priv->_is_abstract;
4265 if (_tmp463_) {
4266 _tmp462_ = TRUE;
4267 } else {
4268 gboolean _tmp464_;
4269 _tmp464_ = self->priv->_is_virtual;
4270 _tmp462_ = _tmp464_;
4271 }
4272 if (_tmp462_) {
4273 _tmp461_ = TRUE;
4274 } else {
4275 gboolean _tmp465_;
4276 _tmp465_ = self->priv->_overrides;
4277 _tmp461_ = _tmp465_;
4278 }
4279 if (_tmp461_) {
4280 ValaSymbolAccessibility _tmp466_;
4281 ValaSymbolAccessibility _tmp467_;
4282 _tmp466_ = vala_symbol_get_access ((ValaSymbol*) self);
4283 _tmp467_ = _tmp466_;
4284 _tmp460_ = _tmp467_ == VALA_SYMBOL_ACCESSIBILITY_PRIVATE;
4285 } else {
4286 _tmp460_ = FALSE;
4287 }
4288 if (_tmp460_) {
4289 ValaSourceReference* _tmp468_;
4290 ValaSourceReference* _tmp469_;
4291 gchar* _tmp470_;
4292 gchar* _tmp471_;
4293 gchar* _tmp472_;
4294 gchar* _tmp473_;
4295 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
4296 _tmp468_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
4297 _tmp469_ = _tmp468_;
4298 _tmp470_ = vala_symbol_get_full_name ((ValaSymbol*) self);
4299 _tmp471_ = _tmp470_;
4300 _tmp472_ = g_strdup_printf ("Private member `%s' cannot be marked as override, virtual, or abstract", _tmp471_);
4301 _tmp473_ = _tmp472_;
4302 vala_report_error (_tmp469_, _tmp473_);
4303 _g_free0 (_tmp473_);
4304 _g_free0 (_tmp471_);
4305 result = FALSE;
4306 _vala_code_node_unref0 (init_attr);
4307 _vala_code_node_unref0 (old_symbol);
4308 _vala_source_file_unref0 (old_source_file);
4309 return result;
4310 }
4311 }
4312 }
4313 }
4314 _tmp476_ = vala_method_get_base_interface_type (self);
4315 _tmp477_ = _tmp476_;
4316 if (_tmp477_ != NULL) {
4317 ValaMethod* _tmp478_;
4318 ValaMethod* _tmp479_;
4319 _tmp478_ = vala_method_get_base_interface_method (self);
4320 _tmp479_ = _tmp478_;
4321 _tmp475_ = _tmp479_ != NULL;
4322 } else {
4323 _tmp475_ = FALSE;
4324 }
4325 if (_tmp475_) {
4326 ValaSymbol* _tmp480_;
4327 ValaSymbol* _tmp481_;
4328 _tmp480_ = vala_symbol_get_parent_symbol ((ValaSymbol*) self);
4329 _tmp481_ = _tmp480_;
4330 _tmp474_ = VALA_IS_CLASS (_tmp481_);
4331 } else {
4332 _tmp474_ = FALSE;
4333 }
4334 if (_tmp474_) {
4335 ValaClass* cl = NULL;
4336 ValaSymbol* _tmp482_;
4337 ValaSymbol* _tmp483_;
4338 _tmp482_ = vala_symbol_get_parent_symbol ((ValaSymbol*) self);
4339 _tmp483_ = _tmp482_;
4340 cl = G_TYPE_CHECK_INSTANCE_CAST (_tmp483_, VALA_TYPE_CLASS, ValaClass);
4341 {
4342 ValaList* _m_list = NULL;
4343 ValaClass* _tmp484_;
4344 ValaList* _tmp485_;
4345 ValaList* _tmp486_;
4346 gint _m_size = 0;
4347 ValaList* _tmp487_;
4348 gint _tmp488_;
4349 gint _tmp489_;
4350 gint _m_index = 0;
4351 _tmp484_ = cl;
4352 _tmp485_ = vala_object_type_symbol_get_methods ((ValaObjectTypeSymbol*) _tmp484_);
4353 _tmp486_ = _vala_iterable_ref0 (_tmp485_);
4354 _m_list = _tmp486_;
4355 _tmp487_ = _m_list;
4356 _tmp488_ = vala_collection_get_size ((ValaCollection*) _tmp487_);
4357 _tmp489_ = _tmp488_;
4358 _m_size = _tmp489_;
4359 _m_index = -1;
4360 while (TRUE) {
4361 gint _tmp490_;
4362 gint _tmp491_;
4363 ValaMethod* m = NULL;
4364 ValaList* _tmp492_;
4365 gpointer _tmp493_;
4366 gboolean _tmp494_ = FALSE;
4367 ValaMethod* _tmp495_;
4368 _m_index = _m_index + 1;
4369 _tmp490_ = _m_index;
4370 _tmp491_ = _m_size;
4371 if (!(_tmp490_ < _tmp491_)) {
4372 break;
4373 }
4374 _tmp492_ = _m_list;
4375 _tmp493_ = vala_list_get (_tmp492_, _m_index);
4376 m = (ValaMethod*) _tmp493_;
4377 _tmp495_ = m;
4378 if (_tmp495_ != self) {
4379 ValaMethod* _tmp496_;
4380 ValaMethod* _tmp497_;
4381 ValaMethod* _tmp498_;
4382 ValaMethod* _tmp499_;
4383 ValaMethod* _tmp500_;
4384 _tmp496_ = m;
4385 _tmp497_ = vala_method_get_base_interface_method (_tmp496_);
4386 _tmp498_ = _tmp497_;
4387 _tmp499_ = vala_method_get_base_interface_method (self);
4388 _tmp500_ = _tmp499_;
4389 _tmp494_ = _tmp498_ == _tmp500_;
4390 } else {
4391 _tmp494_ = FALSE;
4392 }
4393 if (_tmp494_) {
4394 ValaMethod* _tmp501_;
4395 ValaMethod* _tmp502_;
4396 ValaSourceReference* _tmp503_;
4397 ValaSourceReference* _tmp504_;
4398 ValaClass* _tmp505_;
4399 gchar* _tmp506_;
4400 gchar* _tmp507_;
4401 ValaMethod* _tmp508_;
4402 ValaMethod* _tmp509_;
4403 gchar* _tmp510_;
4404 gchar* _tmp511_;
4405 gchar* _tmp512_;
4406 gchar* _tmp513_;
4407 ValaMethod* _tmp514_;
4408 ValaSourceReference* _tmp515_;
4409 ValaSourceReference* _tmp516_;
4410 ValaMethod* _tmp517_;
4411 ValaMethod* _tmp518_;
4412 gchar* _tmp519_;
4413 gchar* _tmp520_;
4414 gchar* _tmp521_;
4415 gchar* _tmp522_;
4416 _tmp501_ = m;
4417 vala_code_node_set_checked ((ValaCodeNode*) _tmp501_, TRUE);
4418 _tmp502_ = m;
4419 vala_code_node_set_error ((ValaCodeNode*) _tmp502_, TRUE);
4420 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
4421 _tmp503_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
4422 _tmp504_ = _tmp503_;
4423 _tmp505_ = cl;
4424 _tmp506_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp505_);
4425 _tmp507_ = _tmp506_;
4426 _tmp508_ = vala_method_get_base_interface_method (self);
4427 _tmp509_ = _tmp508_;
4428 _tmp510_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp509_);
4429 _tmp511_ = _tmp510_;
4430 _tmp512_ = g_strdup_printf ("`%s' already contains an implementation for `%s'", _tmp507_, _tmp511_);
4431 _tmp513_ = _tmp512_;
4432 vala_report_error (_tmp504_, _tmp513_);
4433 _g_free0 (_tmp513_);
4434 _g_free0 (_tmp511_);
4435 _g_free0 (_tmp507_);
4436 _tmp514_ = m;
4437 _tmp515_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp514_);
4438 _tmp516_ = _tmp515_;
4439 _tmp517_ = vala_method_get_base_interface_method (self);
4440 _tmp518_ = _tmp517_;
4441 _tmp519_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp518_);
4442 _tmp520_ = _tmp519_;
4443 _tmp521_ = g_strdup_printf ("previous implementation of `%s' was here", _tmp520_);
4444 _tmp522_ = _tmp521_;
4445 vala_report_notice (_tmp516_, _tmp522_);
4446 _g_free0 (_tmp522_);
4447 _g_free0 (_tmp520_);
4448 result = FALSE;
4449 _vala_code_node_unref0 (m);
4450 _vala_iterable_unref0 (_m_list);
4451 _vala_code_node_unref0 (init_attr);
4452 _vala_code_node_unref0 (old_symbol);
4453 _vala_source_file_unref0 (old_source_file);
4454 return result;
4455 }
4456 _vala_code_node_unref0 (m);
4457 }
4458 _vala_iterable_unref0 (_m_list);
4459 }
4460 }
4461 _tmp523_ = vala_code_context_get_analyzer (context);
4462 _tmp524_ = _tmp523_;
4463 _tmp525_ = old_source_file;
4464 vala_semantic_analyzer_set_current_source_file (_tmp524_, _tmp525_);
4465 _tmp526_ = vala_code_context_get_analyzer (context);
4466 _tmp527_ = _tmp526_;
4467 _tmp528_ = old_symbol;
4468 vala_semantic_analyzer_set_current_symbol (_tmp527_, _tmp528_);
4469 _tmp532_ = vala_symbol_get_external_package ((ValaSymbol*) self);
4470 _tmp533_ = _tmp532_;
4471 if (!_tmp533_) {
4472 gboolean _tmp534_;
4473 _tmp534_ = self->priv->_overrides;
4474 _tmp531_ = !_tmp534_;
4475 } else {
4476 _tmp531_ = FALSE;
4477 }
4478 if (_tmp531_) {
4479 gboolean _tmp535_;
4480 gboolean _tmp536_;
4481 _tmp535_ = vala_symbol_get_hides ((ValaSymbol*) self);
4482 _tmp536_ = _tmp535_;
4483 _tmp530_ = !_tmp536_;
4484 } else {
4485 _tmp530_ = FALSE;
4486 }
4487 if (_tmp530_) {
4488 ValaSymbol* _tmp537_;
4489 ValaSymbol* _tmp538_;
4490 _tmp537_ = vala_symbol_get_hidden_member ((ValaSymbol*) self);
4491 _tmp538_ = _tmp537_;
4492 _tmp529_ = _tmp538_ != NULL;
4493 _vala_code_node_unref0 (_tmp538_);
4494 } else {
4495 _tmp529_ = FALSE;
4496 }
4497 if (_tmp529_) {
4498 ValaSourceReference* _tmp539_;
4499 ValaSourceReference* _tmp540_;
4500 gchar* _tmp541_;
4501 gchar* _tmp542_;
4502 ValaSymbol* _tmp543_;
4503 ValaSymbol* _tmp544_;
4504 gchar* _tmp545_;
4505 gchar* _tmp546_;
4506 gchar* _tmp547_;
4507 gchar* _tmp548_;
4508 _tmp539_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
4509 _tmp540_ = _tmp539_;
4510 _tmp541_ = vala_symbol_get_full_name ((ValaSymbol*) self);
4511 _tmp542_ = _tmp541_;
4512 _tmp543_ = vala_symbol_get_hidden_member ((ValaSymbol*) self);
4513 _tmp544_ = _tmp543_;
4514 _tmp545_ = vala_symbol_get_full_name (_tmp544_);
4515 _tmp546_ = _tmp545_;
4516 _tmp547_ = g_strdup_printf ("%s hides inherited method `%s'. Use the `new' keyword if hiding was in" \
4517 "tentional", _tmp542_, _tmp546_);
4518 _tmp548_ = _tmp547_;
4519 vala_report_warning (_tmp540_, _tmp548_);
4520 _g_free0 (_tmp548_);
4521 _g_free0 (_tmp546_);
4522 _vala_code_node_unref0 (_tmp544_);
4523 _g_free0 (_tmp542_);
4524 }
4525 _tmp549_ = vala_code_context_get_analyzer (context);
4526 _tmp550_ = _tmp549_;
4527 _tmp551_ = vala_callable_get_return_type ((ValaCallable*) self);
4528 _tmp552_ = _tmp551_;
4529 if (!vala_semantic_analyzer_is_type_accessible (_tmp550_, (ValaSymbol*) self, _tmp552_)) {
4530 ValaSourceReference* _tmp553_;
4531 ValaSourceReference* _tmp554_;
4532 ValaDataType* _tmp555_;
4533 ValaDataType* _tmp556_;
4534 gchar* _tmp557_;
4535 gchar* _tmp558_;
4536 gchar* _tmp559_;
4537 gchar* _tmp560_;
4538 gchar* _tmp561_;
4539 gchar* _tmp562_;
4540 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
4541 _tmp553_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
4542 _tmp554_ = _tmp553_;
4543 _tmp555_ = vala_callable_get_return_type ((ValaCallable*) self);
4544 _tmp556_ = _tmp555_;
4545 _tmp557_ = vala_code_node_to_string ((ValaCodeNode*) _tmp556_);
4546 _tmp558_ = _tmp557_;
4547 _tmp559_ = vala_symbol_get_full_name ((ValaSymbol*) self);
4548 _tmp560_ = _tmp559_;
4549 _tmp561_ = g_strdup_printf ("return type `%s' is less accessible than method `%s'", _tmp558_, _tmp560_);
4550 _tmp562_ = _tmp561_;
4551 vala_report_error (_tmp554_, _tmp562_);
4552 _g_free0 (_tmp562_);
4553 _g_free0 (_tmp560_);
4554 _g_free0 (_tmp558_);
4555 result = FALSE;
4556 _vala_code_node_unref0 (init_attr);
4557 _vala_code_node_unref0 (old_symbol);
4558 _vala_source_file_unref0 (old_source_file);
4559 return result;
4560 }
4561 {
4562 ValaList* _precondition_list = NULL;
4563 ValaList* _tmp563_;
4564 ValaList* _tmp564_;
4565 gint _precondition_size = 0;
4566 ValaList* _tmp565_;
4567 gint _tmp566_;
4568 gint _tmp567_;
4569 gint _precondition_index = 0;
4570 _tmp563_ = vala_method_get_preconditions (self);
4571 _tmp564_ = _vala_iterable_ref0 (_tmp563_);
4572 _precondition_list = _tmp564_;
4573 _tmp565_ = _precondition_list;
4574 _tmp566_ = vala_collection_get_size ((ValaCollection*) _tmp565_);
4575 _tmp567_ = _tmp566_;
4576 _precondition_size = _tmp567_;
4577 _precondition_index = -1;
4578 while (TRUE) {
4579 gint _tmp568_;
4580 gint _tmp569_;
4581 ValaExpression* precondition = NULL;
4582 ValaList* _tmp570_;
4583 gpointer _tmp571_;
4584 ValaExpression* _tmp572_;
4585 gboolean _tmp573_;
4586 gboolean _tmp574_;
4587 ValaExpression* _tmp575_;
4588 ValaDataType* _tmp576_;
4589 ValaDataType* _tmp577_;
4590 ValaSemanticAnalyzer* _tmp578_;
4591 ValaSemanticAnalyzer* _tmp579_;
4592 ValaDataType* _tmp580_;
4593 _precondition_index = _precondition_index + 1;
4594 _tmp568_ = _precondition_index;
4595 _tmp569_ = _precondition_size;
4596 if (!(_tmp568_ < _tmp569_)) {
4597 break;
4598 }
4599 _tmp570_ = _precondition_list;
4600 _tmp571_ = vala_list_get (_tmp570_, _precondition_index);
4601 precondition = (ValaExpression*) _tmp571_;
4602 _tmp572_ = precondition;
4603 _tmp573_ = vala_code_node_get_error ((ValaCodeNode*) _tmp572_);
4604 _tmp574_ = _tmp573_;
4605 if (_tmp574_) {
4606 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
4607 result = FALSE;
4608 _vala_code_node_unref0 (precondition);
4609 _vala_iterable_unref0 (_precondition_list);
4610 _vala_code_node_unref0 (init_attr);
4611 _vala_code_node_unref0 (old_symbol);
4612 _vala_source_file_unref0 (old_source_file);
4613 return result;
4614 }
4615 _tmp575_ = precondition;
4616 _tmp576_ = vala_expression_get_value_type (_tmp575_);
4617 _tmp577_ = _tmp576_;
4618 _tmp578_ = vala_code_context_get_analyzer (context);
4619 _tmp579_ = _tmp578_;
4620 _tmp580_ = _tmp579_->bool_type;
4621 if (!vala_data_type_compatible (_tmp577_, _tmp580_)) {
4622 ValaExpression* _tmp581_;
4623 ValaSourceReference* _tmp582_;
4624 ValaSourceReference* _tmp583_;
4625 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
4626 _tmp581_ = precondition;
4627 _tmp582_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp581_);
4628 _tmp583_ = _tmp582_;
4629 vala_report_error (_tmp583_, "Precondition must be boolean");
4630 result = FALSE;
4631 _vala_code_node_unref0 (precondition);
4632 _vala_iterable_unref0 (_precondition_list);
4633 _vala_code_node_unref0 (init_attr);
4634 _vala_code_node_unref0 (old_symbol);
4635 _vala_source_file_unref0 (old_source_file);
4636 return result;
4637 }
4638 _vala_code_node_unref0 (precondition);
4639 }
4640 _vala_iterable_unref0 (_precondition_list);
4641 }
4642 {
4643 ValaList* _postcondition_list = NULL;
4644 ValaList* _tmp584_;
4645 ValaList* _tmp585_;
4646 gint _postcondition_size = 0;
4647 ValaList* _tmp586_;
4648 gint _tmp587_;
4649 gint _tmp588_;
4650 gint _postcondition_index = 0;
4651 _tmp584_ = vala_method_get_postconditions (self);
4652 _tmp585_ = _vala_iterable_ref0 (_tmp584_);
4653 _postcondition_list = _tmp585_;
4654 _tmp586_ = _postcondition_list;
4655 _tmp587_ = vala_collection_get_size ((ValaCollection*) _tmp586_);
4656 _tmp588_ = _tmp587_;
4657 _postcondition_size = _tmp588_;
4658 _postcondition_index = -1;
4659 while (TRUE) {
4660 gint _tmp589_;
4661 gint _tmp590_;
4662 ValaExpression* postcondition = NULL;
4663 ValaList* _tmp591_;
4664 gpointer _tmp592_;
4665 ValaExpression* _tmp593_;
4666 gboolean _tmp594_;
4667 gboolean _tmp595_;
4668 ValaExpression* _tmp596_;
4669 ValaDataType* _tmp597_;
4670 ValaDataType* _tmp598_;
4671 ValaSemanticAnalyzer* _tmp599_;
4672 ValaSemanticAnalyzer* _tmp600_;
4673 ValaDataType* _tmp601_;
4674 _postcondition_index = _postcondition_index + 1;
4675 _tmp589_ = _postcondition_index;
4676 _tmp590_ = _postcondition_size;
4677 if (!(_tmp589_ < _tmp590_)) {
4678 break;
4679 }
4680 _tmp591_ = _postcondition_list;
4681 _tmp592_ = vala_list_get (_tmp591_, _postcondition_index);
4682 postcondition = (ValaExpression*) _tmp592_;
4683 _tmp593_ = postcondition;
4684 _tmp594_ = vala_code_node_get_error ((ValaCodeNode*) _tmp593_);
4685 _tmp595_ = _tmp594_;
4686 if (_tmp595_) {
4687 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
4688 result = FALSE;
4689 _vala_code_node_unref0 (postcondition);
4690 _vala_iterable_unref0 (_postcondition_list);
4691 _vala_code_node_unref0 (init_attr);
4692 _vala_code_node_unref0 (old_symbol);
4693 _vala_source_file_unref0 (old_source_file);
4694 return result;
4695 }
4696 _tmp596_ = postcondition;
4697 _tmp597_ = vala_expression_get_value_type (_tmp596_);
4698 _tmp598_ = _tmp597_;
4699 _tmp599_ = vala_code_context_get_analyzer (context);
4700 _tmp600_ = _tmp599_;
4701 _tmp601_ = _tmp600_->bool_type;
4702 if (!vala_data_type_compatible (_tmp598_, _tmp601_)) {
4703 ValaExpression* _tmp602_;
4704 ValaSourceReference* _tmp603_;
4705 ValaSourceReference* _tmp604_;
4706 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
4707 _tmp602_ = postcondition;
4708 _tmp603_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp602_);
4709 _tmp604_ = _tmp603_;
4710 vala_report_error (_tmp604_, "Postcondition must be boolean");
4711 result = FALSE;
4712 _vala_code_node_unref0 (postcondition);
4713 _vala_iterable_unref0 (_postcondition_list);
4714 _vala_code_node_unref0 (init_attr);
4715 _vala_code_node_unref0 (old_symbol);
4716 _vala_source_file_unref0 (old_source_file);
4717 return result;
4718 }
4719 _vala_code_node_unref0 (postcondition);
4720 }
4721 _vala_iterable_unref0 (_postcondition_list);
4722 }
4723 _tmp606_ = vala_subroutine_get_body ((ValaSubroutine*) self);
4724 _tmp607_ = _tmp606_;
4725 if (_tmp607_ != NULL) {
4726 ValaBlock* _tmp608_;
4727 ValaBlock* _tmp609_;
4728 gboolean _tmp610_;
4729 gboolean _tmp611_;
4730 _tmp608_ = vala_subroutine_get_body ((ValaSubroutine*) self);
4731 _tmp609_ = _tmp608_;
4732 _tmp610_ = vala_code_node_get_error ((ValaCodeNode*) _tmp609_);
4733 _tmp611_ = _tmp610_;
4734 _tmp605_ = !_tmp611_;
4735 } else {
4736 _tmp605_ = FALSE;
4737 }
4738 if (_tmp605_) {
4739 ValaArrayList* body_errors = NULL;
4740 GEqualFunc _tmp612_;
4741 ValaArrayList* _tmp613_;
4742 ValaBlock* _tmp614_;
4743 ValaBlock* _tmp615_;
4744 ValaArrayList* _tmp616_;
4745 _tmp612_ = g_direct_equal;
4746 _tmp613_ = vala_array_list_new (VALA_TYPE_DATA_TYPE, (GBoxedCopyFunc) vala_code_node_ref, (GDestroyNotify) vala_code_node_unref, _tmp612_);
4747 body_errors = _tmp613_;
4748 _tmp614_ = vala_subroutine_get_body ((ValaSubroutine*) self);
4749 _tmp615_ = _tmp614_;
4750 _tmp616_ = body_errors;
4751 vala_code_node_get_error_types ((ValaCodeNode*) _tmp615_, (ValaCollection*) _tmp616_, NULL);
4752 {
4753 ValaArrayList* _body_error_type_list = NULL;
4754 ValaArrayList* _tmp617_;
4755 ValaArrayList* _tmp618_;
4756 gint _body_error_type_size = 0;
4757 ValaArrayList* _tmp619_;
4758 gint _tmp620_;
4759 gint _tmp621_;
4760 gint _body_error_type_index = 0;
4761 _tmp617_ = body_errors;
4762 _tmp618_ = _vala_iterable_ref0 (_tmp617_);
4763 _body_error_type_list = _tmp618_;
4764 _tmp619_ = _body_error_type_list;
4765 _tmp620_ = vala_collection_get_size ((ValaCollection*) _tmp619_);
4766 _tmp621_ = _tmp620_;
4767 _body_error_type_size = _tmp621_;
4768 _body_error_type_index = -1;
4769 while (TRUE) {
4770 gint _tmp622_;
4771 gint _tmp623_;
4772 ValaDataType* body_error_type = NULL;
4773 ValaArrayList* _tmp624_;
4774 gpointer _tmp625_;
4775 gboolean can_propagate_error = FALSE;
4776 ValaList* _tmp626_;
4777 gboolean _tmp638_ = FALSE;
4778 ValaDataType* _tmp639_;
4779 gboolean is_dynamic_error = FALSE;
4780 gboolean _tmp643_ = FALSE;
4781 _body_error_type_index = _body_error_type_index + 1;
4782 _tmp622_ = _body_error_type_index;
4783 _tmp623_ = _body_error_type_size;
4784 if (!(_tmp622_ < _tmp623_)) {
4785 break;
4786 }
4787 _tmp624_ = _body_error_type_list;
4788 _tmp625_ = vala_list_get ((ValaList*) _tmp624_, _body_error_type_index);
4789 body_error_type = (ValaDataType*) _tmp625_;
4790 can_propagate_error = FALSE;
4791 _tmp626_ = self->error_types;
4792 if (_tmp626_ != NULL) {
4793 {
4794 ValaList* _method_error_type_list = NULL;
4795 ValaList* _tmp627_;
4796 ValaList* _tmp628_;
4797 gint _method_error_type_size = 0;
4798 ValaList* _tmp629_;
4799 gint _tmp630_;
4800 gint _tmp631_;
4801 gint _method_error_type_index = 0;
4802 _tmp627_ = self->error_types;
4803 _tmp628_ = _vala_iterable_ref0 (_tmp627_);
4804 _method_error_type_list = _tmp628_;
4805 _tmp629_ = _method_error_type_list;
4806 _tmp630_ = vala_collection_get_size ((ValaCollection*) _tmp629_);
4807 _tmp631_ = _tmp630_;
4808 _method_error_type_size = _tmp631_;
4809 _method_error_type_index = -1;
4810 while (TRUE) {
4811 gint _tmp632_;
4812 gint _tmp633_;
4813 ValaDataType* method_error_type = NULL;
4814 ValaList* _tmp634_;
4815 gpointer _tmp635_;
4816 ValaDataType* _tmp636_;
4817 ValaDataType* _tmp637_;
4818 _method_error_type_index = _method_error_type_index + 1;
4819 _tmp632_ = _method_error_type_index;
4820 _tmp633_ = _method_error_type_size;
4821 if (!(_tmp632_ < _tmp633_)) {
4822 break;
4823 }
4824 _tmp634_ = _method_error_type_list;
4825 _tmp635_ = vala_list_get (_tmp634_, _method_error_type_index);
4826 method_error_type = (ValaDataType*) _tmp635_;
4827 _tmp636_ = body_error_type;
4828 _tmp637_ = method_error_type;
4829 if (vala_data_type_compatible (_tmp636_, _tmp637_)) {
4830 can_propagate_error = TRUE;
4831 }
4832 _vala_code_node_unref0 (method_error_type);
4833 }
4834 _vala_iterable_unref0 (_method_error_type_list);
4835 }
4836 }
4837 _tmp639_ = body_error_type;
4838 if (VALA_IS_ERROR_TYPE (_tmp639_)) {
4839 ValaDataType* _tmp640_;
4840 gboolean _tmp641_;
4841 gboolean _tmp642_;
4842 _tmp640_ = body_error_type;
4843 _tmp641_ = vala_error_type_get_dynamic_error (G_TYPE_CHECK_INSTANCE_CAST (_tmp640_, VALA_TYPE_ERROR_TYPE, ValaErrorType));
4844 _tmp642_ = _tmp641_;
4845 _tmp638_ = _tmp642_;
4846 } else {
4847 _tmp638_ = FALSE;
4848 }
4849 is_dynamic_error = _tmp638_;
4850 if (!can_propagate_error) {
4851 _tmp643_ = !is_dynamic_error;
4852 } else {
4853 _tmp643_ = FALSE;
4854 }
4855 if (_tmp643_) {
4856 ValaDataType* _tmp644_;
4857 ValaSourceReference* _tmp645_;
4858 ValaSourceReference* _tmp646_;
4859 ValaDataType* _tmp647_;
4860 gchar* _tmp648_;
4861 gchar* _tmp649_;
4862 gchar* _tmp650_;
4863 gchar* _tmp651_;
4864 _tmp644_ = body_error_type;
4865 _tmp645_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp644_);
4866 _tmp646_ = _tmp645_;
4867 _tmp647_ = body_error_type;
4868 _tmp648_ = vala_code_node_to_string ((ValaCodeNode*) _tmp647_);
4869 _tmp649_ = _tmp648_;
4870 _tmp650_ = g_strdup_printf ("unhandled error `%s'", _tmp649_);
4871 _tmp651_ = _tmp650_;
4872 vala_report_warning (_tmp646_, _tmp651_);
4873 _g_free0 (_tmp651_);
4874 _g_free0 (_tmp649_);
4875 }
4876 _vala_code_node_unref0 (body_error_type);
4877 }
4878 _vala_iterable_unref0 (_body_error_type_list);
4879 }
4880 _vala_iterable_unref0 (body_errors);
4881 }
4882 if (!VALA_IS_CREATION_METHOD (self)) {
4883 ValaMemberBinding _tmp657_;
4884 _tmp657_ = self->priv->_binding;
4885 _tmp656_ = _tmp657_ == VALA_MEMBER_BINDING_INSTANCE;
4886 } else {
4887 _tmp656_ = FALSE;
4888 }
4889 if (_tmp656_) {
4890 gboolean _tmp658_;
4891 _tmp658_ = self->priv->_overrides;
4892 _tmp655_ = !_tmp658_;
4893 } else {
4894 _tmp655_ = FALSE;
4895 }
4896 if (_tmp655_) {
4897 ValaSymbolAccessibility _tmp659_;
4898 ValaSymbolAccessibility _tmp660_;
4899 _tmp659_ = vala_symbol_get_access ((ValaSymbol*) self);
4900 _tmp660_ = _tmp659_;
4901 _tmp654_ = _tmp660_ == VALA_SYMBOL_ACCESSIBILITY_PUBLIC;
4902 } else {
4903 _tmp654_ = FALSE;
4904 }
4905 if (_tmp654_) {
4906 ValaSymbol* _tmp661_;
4907 ValaSymbol* _tmp662_;
4908 _tmp661_ = vala_symbol_get_parent_symbol ((ValaSymbol*) self);
4909 _tmp662_ = _tmp661_;
4910 _tmp653_ = VALA_IS_OBJECT_TYPE_SYMBOL (_tmp662_);
4911 } else {
4912 _tmp653_ = FALSE;
4913 }
4914 if (_tmp653_) {
4915 ValaSymbol* _tmp663_;
4916 ValaSymbol* _tmp664_;
4917 ValaAttribute* _tmp665_;
4918 _tmp663_ = vala_symbol_get_parent_symbol ((ValaSymbol*) self);
4919 _tmp664_ = _tmp663_;
4920 _tmp665_ = vala_code_node_get_attribute ((ValaCodeNode*) _tmp664_, "DBus");
4921 _tmp652_ = _tmp665_ != NULL;
4922 } else {
4923 _tmp652_ = FALSE;
4924 }
4925 if (_tmp652_) {
4926 ValaAttribute* dbus_attr = NULL;
4927 ValaAttribute* _tmp666_;
4928 ValaAttribute* _tmp667_;
4929 gboolean _tmp668_ = FALSE;
4930 ValaAttribute* _tmp669_;
4931 _tmp666_ = vala_code_node_get_attribute ((ValaCodeNode*) self, "DBus");
4932 _tmp667_ = _vala_code_node_ref0 (_tmp666_);
4933 dbus_attr = _tmp667_;
4934 _tmp669_ = dbus_attr;
4935 if (_tmp669_ == NULL) {
4936 _tmp668_ = TRUE;
4937 } else {
4938 ValaAttribute* _tmp670_;
4939 _tmp670_ = dbus_attr;
4940 _tmp668_ = vala_attribute_get_bool (_tmp670_, "visible", TRUE);
4941 }
4942 if (_tmp668_) {
4943 gboolean throws_gerror = FALSE;
4944 gboolean throws_gioerror = FALSE;
4945 gboolean throws_gdbuserror = FALSE;
4946 ValaArrayList* error_types = NULL;
4947 GEqualFunc _tmp671_;
4948 ValaArrayList* _tmp672_;
4949 ValaArrayList* _tmp673_;
4950 gboolean _tmp692_ = FALSE;
4951 throws_gerror = FALSE;
4952 throws_gioerror = FALSE;
4953 throws_gdbuserror = FALSE;
4954 _tmp671_ = g_direct_equal;
4955 _tmp672_ = vala_array_list_new (VALA_TYPE_DATA_TYPE, (GBoxedCopyFunc) vala_code_node_ref, (GDestroyNotify) vala_code_node_unref, _tmp671_);
4956 error_types = _tmp672_;
4957 _tmp673_ = error_types;
4958 vala_code_node_get_error_types ((ValaCodeNode*) self, (ValaCollection*) _tmp673_, NULL);
4959 {
4960 ValaArrayList* _error_type_list = NULL;
4961 ValaArrayList* _tmp674_;
4962 ValaArrayList* _tmp675_;
4963 gint _error_type_size = 0;
4964 ValaArrayList* _tmp676_;
4965 gint _tmp677_;
4966 gint _tmp678_;
4967 gint _error_type_index = 0;
4968 _tmp674_ = error_types;
4969 _tmp675_ = _vala_iterable_ref0 (_tmp674_);
4970 _error_type_list = _tmp675_;
4971 _tmp676_ = _error_type_list;
4972 _tmp677_ = vala_collection_get_size ((ValaCollection*) _tmp676_);
4973 _tmp678_ = _tmp677_;
4974 _error_type_size = _tmp678_;
4975 _error_type_index = -1;
4976 while (TRUE) {
4977 gint _tmp679_;
4978 gint _tmp680_;
4979 ValaDataType* error_type = NULL;
4980 ValaArrayList* _tmp681_;
4981 gpointer _tmp682_;
4982 ValaDataType* _tmp683_;
4983 ValaErrorDomain* error_domain = NULL;
4984 ValaDataType* _tmp684_;
4985 ValaErrorDomain* _tmp685_;
4986 ValaErrorDomain* _tmp686_;
4987 ValaErrorDomain* _tmp687_;
4988 gchar* full_error_domain = NULL;
4989 ValaErrorDomain* _tmp688_;
4990 gchar* _tmp689_;
4991 const gchar* _tmp690_;
4992 _error_type_index = _error_type_index + 1;
4993 _tmp679_ = _error_type_index;
4994 _tmp680_ = _error_type_size;
4995 if (!(_tmp679_ < _tmp680_)) {
4996 break;
4997 }
4998 _tmp681_ = _error_type_list;
4999 _tmp682_ = vala_list_get ((ValaList*) _tmp681_, _error_type_index);
5000 error_type = (ValaDataType*) _tmp682_;
5001 _tmp683_ = error_type;
5002 if (!VALA_IS_ERROR_TYPE (_tmp683_)) {
5003 _vala_code_node_unref0 (error_type);
5004 continue;
5005 }
5006 _tmp684_ = error_type;
5007 _tmp685_ = vala_error_type_get_error_domain (G_TYPE_CHECK_INSTANCE_CAST (_tmp684_, VALA_TYPE_ERROR_TYPE, ValaErrorType));
5008 _tmp686_ = _tmp685_;
5009 error_domain = _tmp686_;
5010 _tmp687_ = error_domain;
5011 if (_tmp687_ == NULL) {
5012 throws_gerror = TRUE;
5013 _vala_code_node_unref0 (error_type);
5014 break;
5015 }
5016 _tmp688_ = error_domain;
5017 _tmp689_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp688_);
5018 full_error_domain = _tmp689_;
5019 _tmp690_ = full_error_domain;
5020 if (g_strcmp0 (_tmp690_, "GLib.IOError") == 0) {
5021 throws_gioerror = TRUE;
5022 } else {
5023 const gchar* _tmp691_;
5024 _tmp691_ = full_error_domain;
5025 if (g_strcmp0 (_tmp691_, "GLib.DBusError") == 0) {
5026 throws_gdbuserror = TRUE;
5027 }
5028 }
5029 _g_free0 (full_error_domain);
5030 _vala_code_node_unref0 (error_type);
5031 }
5032 _vala_iterable_unref0 (_error_type_list);
5033 }
5034 if (!throws_gerror) {
5035 gboolean _tmp693_ = FALSE;
5036 if (throws_gioerror) {
5037 _tmp693_ = throws_gdbuserror;
5038 } else {
5039 _tmp693_ = FALSE;
5040 }
5041 _tmp692_ = !_tmp693_;
5042 } else {
5043 _tmp692_ = FALSE;
5044 }
5045 if (_tmp692_) {
5046 ValaSourceReference* _tmp694_;
5047 ValaSourceReference* _tmp695_;
5048 _tmp694_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
5049 _tmp695_ = _tmp694_;
5050 vala_report_warning (_tmp695_, "DBus methods are recommended to throw at least `GLib.Error' or `GLib.D" \
5051 "BusError, GLib.IOError'");
5052 }
5053 _vala_iterable_unref0 (error_types);
5054 }
5055 _vala_code_node_unref0 (dbus_attr);
5056 }
5057 if (vala_method_is_possible_entry_point (self, context)) {
5058 ValaMethod* _tmp696_;
5059 ValaMethod* _tmp697_;
5060 gboolean _tmp706_;
5061 gboolean _tmp707_;
5062 gboolean _tmp710_;
5063 gboolean _tmp713_;
5064 _tmp696_ = vala_code_context_get_entry_point (context);
5065 _tmp697_ = _tmp696_;
5066 if (_tmp697_ != NULL) {
5067 ValaSourceReference* _tmp698_;
5068 ValaSourceReference* _tmp699_;
5069 ValaMethod* _tmp700_;
5070 ValaMethod* _tmp701_;
5071 gchar* _tmp702_;
5072 gchar* _tmp703_;
5073 gchar* _tmp704_;
5074 gchar* _tmp705_;
5075 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
5076 _tmp698_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
5077 _tmp699_ = _tmp698_;
5078 _tmp700_ = vala_code_context_get_entry_point (context);
5079 _tmp701_ = _tmp700_;
5080 _tmp702_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp701_);
5081 _tmp703_ = _tmp702_;
5082 _tmp704_ = g_strdup_printf ("program already has an entry point `%s'", _tmp703_);
5083 _tmp705_ = _tmp704_;
5084 vala_report_error (_tmp699_, _tmp705_);
5085 _g_free0 (_tmp705_);
5086 _g_free0 (_tmp703_);
5087 result = FALSE;
5088 _vala_code_node_unref0 (init_attr);
5089 _vala_code_node_unref0 (old_symbol);
5090 _vala_source_file_unref0 (old_source_file);
5091 return result;
5092 }
5093 vala_method_set_entry_point (self, TRUE);
5094 vala_code_context_set_entry_point (context, self);
5095 _tmp706_ = vala_code_node_get_tree_can_fail ((ValaCodeNode*) self);
5096 _tmp707_ = _tmp706_;
5097 if (_tmp707_) {
5098 ValaSourceReference* _tmp708_;
5099 ValaSourceReference* _tmp709_;
5100 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
5101 _tmp708_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
5102 _tmp709_ = _tmp708_;
5103 vala_report_error (_tmp709_, "\"main\" method cannot throw errors");
5104 }
5105 _tmp710_ = self->priv->_is_inline;
5106 if (_tmp710_) {
5107 ValaSourceReference* _tmp711_;
5108 ValaSourceReference* _tmp712_;
5109 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
5110 _tmp711_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
5111 _tmp712_ = _tmp711_;
5112 vala_report_error (_tmp712_, "\"main\" method cannot be inline");
5113 }
5114 _tmp713_ = self->priv->_coroutine;
5115 if (_tmp713_) {
5116 ValaSourceReference* _tmp714_;
5117 ValaSourceReference* _tmp715_;
5118 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
5119 _tmp714_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
5120 _tmp715_ = _tmp714_;
5121 vala_report_error (_tmp715_, "\"main\" method cannot be async");
5122 }
5123 }
5124 _tmp716_ = vala_code_node_get_attribute ((ValaCodeNode*) self, "GtkCallback");
5125 if (_tmp716_ != NULL) {
5126 vala_symbol_set_used ((ValaSymbol*) self, TRUE);
5127 }
5128 _tmp717_ = vala_code_node_get_error ((ValaCodeNode*) self);
5129 _tmp718_ = _tmp717_;
5130 result = !_tmp718_;
5131 _vala_code_node_unref0 (init_attr);
5132 _vala_code_node_unref0 (old_symbol);
5133 _vala_source_file_unref0 (old_source_file);
5134 return result;
5135 }
5136
5137 static gboolean
vala_method_is_possible_entry_point(ValaMethod * self,ValaCodeContext * context)5138 vala_method_is_possible_entry_point (ValaMethod* self,
5139 ValaCodeContext* context)
5140 {
5141 gboolean _tmp0_;
5142 gboolean _tmp1_;
5143 const gchar* _tmp2_;
5144 const gchar* _tmp3_;
5145 ValaMemberBinding _tmp14_;
5146 ValaDataType* _tmp15_;
5147 ValaDataType* _tmp16_;
5148 ValaList* params = NULL;
5149 ValaList* _tmp26_;
5150 ValaList* _tmp27_;
5151 ValaList* _tmp28_;
5152 gint _tmp29_;
5153 gint _tmp30_;
5154 ValaList* _tmp31_;
5155 gint _tmp32_;
5156 gint _tmp33_;
5157 ValaIterator* params_it = NULL;
5158 ValaList* _tmp34_;
5159 ValaIterator* _tmp35_;
5160 ValaIterator* _tmp36_;
5161 ValaParameter* param = NULL;
5162 ValaIterator* _tmp37_;
5163 gpointer _tmp38_;
5164 ValaParameter* _tmp39_;
5165 ValaParameterDirection _tmp40_;
5166 ValaParameterDirection _tmp41_;
5167 ValaParameter* _tmp42_;
5168 ValaDataType* _tmp43_;
5169 ValaDataType* _tmp44_;
5170 ValaArrayType* array_type = NULL;
5171 ValaParameter* _tmp45_;
5172 ValaDataType* _tmp46_;
5173 ValaDataType* _tmp47_;
5174 ValaArrayType* _tmp48_;
5175 ValaDataType* _tmp49_;
5176 ValaDataType* _tmp50_;
5177 ValaTypeSymbol* _tmp51_;
5178 ValaTypeSymbol* _tmp52_;
5179 ValaSemanticAnalyzer* _tmp53_;
5180 ValaSemanticAnalyzer* _tmp54_;
5181 ValaDataType* _tmp55_;
5182 ValaTypeSymbol* _tmp56_;
5183 ValaTypeSymbol* _tmp57_;
5184 gboolean result = FALSE;
5185 g_return_val_if_fail (self != NULL, FALSE);
5186 g_return_val_if_fail (context != NULL, FALSE);
5187 _tmp0_ = vala_symbol_get_external_package ((ValaSymbol*) self);
5188 _tmp1_ = _tmp0_;
5189 if (_tmp1_) {
5190 result = FALSE;
5191 return result;
5192 }
5193 _tmp2_ = vala_code_context_get_entry_point_name (context);
5194 _tmp3_ = _tmp2_;
5195 if (_tmp3_ == NULL) {
5196 gboolean _tmp4_ = FALSE;
5197 const gchar* _tmp5_;
5198 const gchar* _tmp6_;
5199 _tmp5_ = vala_symbol_get_name ((ValaSymbol*) self);
5200 _tmp6_ = _tmp5_;
5201 if (_tmp6_ == NULL) {
5202 _tmp4_ = TRUE;
5203 } else {
5204 const gchar* _tmp7_;
5205 const gchar* _tmp8_;
5206 _tmp7_ = vala_symbol_get_name ((ValaSymbol*) self);
5207 _tmp8_ = _tmp7_;
5208 _tmp4_ = g_strcmp0 (_tmp8_, "main") != 0;
5209 }
5210 if (_tmp4_) {
5211 result = FALSE;
5212 return result;
5213 }
5214 } else {
5215 gchar* _tmp9_;
5216 gchar* _tmp10_;
5217 const gchar* _tmp11_;
5218 const gchar* _tmp12_;
5219 gboolean _tmp13_;
5220 _tmp9_ = vala_symbol_get_full_name ((ValaSymbol*) self);
5221 _tmp10_ = _tmp9_;
5222 _tmp11_ = vala_code_context_get_entry_point_name (context);
5223 _tmp12_ = _tmp11_;
5224 _tmp13_ = g_strcmp0 (_tmp10_, _tmp12_) != 0;
5225 _g_free0 (_tmp10_);
5226 if (_tmp13_) {
5227 result = FALSE;
5228 return result;
5229 }
5230 }
5231 _tmp14_ = self->priv->_binding;
5232 if (_tmp14_ == VALA_MEMBER_BINDING_INSTANCE) {
5233 result = FALSE;
5234 return result;
5235 }
5236 _tmp15_ = vala_callable_get_return_type ((ValaCallable*) self);
5237 _tmp16_ = _tmp15_;
5238 if (VALA_IS_VOID_TYPE (_tmp16_)) {
5239 } else {
5240 ValaDataType* _tmp17_;
5241 ValaDataType* _tmp18_;
5242 ValaTypeSymbol* _tmp19_;
5243 ValaTypeSymbol* _tmp20_;
5244 ValaSemanticAnalyzer* _tmp21_;
5245 ValaSemanticAnalyzer* _tmp22_;
5246 ValaDataType* _tmp23_;
5247 ValaTypeSymbol* _tmp24_;
5248 ValaTypeSymbol* _tmp25_;
5249 _tmp17_ = vala_callable_get_return_type ((ValaCallable*) self);
5250 _tmp18_ = _tmp17_;
5251 _tmp19_ = vala_data_type_get_type_symbol (_tmp18_);
5252 _tmp20_ = _tmp19_;
5253 _tmp21_ = vala_code_context_get_analyzer (context);
5254 _tmp22_ = _tmp21_;
5255 _tmp23_ = _tmp22_->int_type;
5256 _tmp24_ = vala_data_type_get_type_symbol (_tmp23_);
5257 _tmp25_ = _tmp24_;
5258 if (_tmp20_ == _tmp25_) {
5259 } else {
5260 result = FALSE;
5261 return result;
5262 }
5263 }
5264 _tmp26_ = vala_callable_get_parameters ((ValaCallable*) self);
5265 _tmp27_ = _vala_iterable_ref0 (_tmp26_);
5266 params = _tmp27_;
5267 _tmp28_ = params;
5268 _tmp29_ = vala_collection_get_size ((ValaCollection*) _tmp28_);
5269 _tmp30_ = _tmp29_;
5270 if (_tmp30_ == 0) {
5271 result = TRUE;
5272 _vala_iterable_unref0 (params);
5273 return result;
5274 }
5275 _tmp31_ = params;
5276 _tmp32_ = vala_collection_get_size ((ValaCollection*) _tmp31_);
5277 _tmp33_ = _tmp32_;
5278 if (_tmp33_ > 1) {
5279 result = FALSE;
5280 _vala_iterable_unref0 (params);
5281 return result;
5282 }
5283 _tmp34_ = params;
5284 _tmp35_ = vala_iterable_iterator ((ValaIterable*) _tmp34_);
5285 params_it = _tmp35_;
5286 _tmp36_ = params_it;
5287 vala_iterator_next (_tmp36_);
5288 _tmp37_ = params_it;
5289 _tmp38_ = vala_iterator_get (_tmp37_);
5290 param = (ValaParameter*) _tmp38_;
5291 _tmp39_ = param;
5292 _tmp40_ = vala_parameter_get_direction (_tmp39_);
5293 _tmp41_ = _tmp40_;
5294 if (_tmp41_ == VALA_PARAMETER_DIRECTION_OUT) {
5295 result = FALSE;
5296 _vala_code_node_unref0 (param);
5297 _vala_iterator_unref0 (params_it);
5298 _vala_iterable_unref0 (params);
5299 return result;
5300 }
5301 _tmp42_ = param;
5302 _tmp43_ = vala_variable_get_variable_type ((ValaVariable*) _tmp42_);
5303 _tmp44_ = _tmp43_;
5304 if (!VALA_IS_ARRAY_TYPE (_tmp44_)) {
5305 result = FALSE;
5306 _vala_code_node_unref0 (param);
5307 _vala_iterator_unref0 (params_it);
5308 _vala_iterable_unref0 (params);
5309 return result;
5310 }
5311 _tmp45_ = param;
5312 _tmp46_ = vala_variable_get_variable_type ((ValaVariable*) _tmp45_);
5313 _tmp47_ = _tmp46_;
5314 array_type = G_TYPE_CHECK_INSTANCE_CAST (_tmp47_, VALA_TYPE_ARRAY_TYPE, ValaArrayType);
5315 _tmp48_ = array_type;
5316 _tmp49_ = vala_array_type_get_element_type (_tmp48_);
5317 _tmp50_ = _tmp49_;
5318 _tmp51_ = vala_data_type_get_type_symbol (_tmp50_);
5319 _tmp52_ = _tmp51_;
5320 _tmp53_ = vala_code_context_get_analyzer (context);
5321 _tmp54_ = _tmp53_;
5322 _tmp55_ = _tmp54_->string_type;
5323 _tmp56_ = vala_data_type_get_type_symbol (_tmp55_);
5324 _tmp57_ = _tmp56_;
5325 if (_tmp52_ != _tmp57_) {
5326 result = FALSE;
5327 _vala_code_node_unref0 (param);
5328 _vala_iterator_unref0 (params_it);
5329 _vala_iterable_unref0 (params);
5330 return result;
5331 }
5332 result = TRUE;
5333 _vala_code_node_unref0 (param);
5334 _vala_iterator_unref0 (params_it);
5335 _vala_iterable_unref0 (params);
5336 return result;
5337 }
5338
5339 gint
vala_method_get_required_arguments(ValaMethod * self)5340 vala_method_get_required_arguments (ValaMethod* self)
5341 {
5342 gint n = 0;
5343 gint result = 0;
5344 g_return_val_if_fail (self != NULL, 0);
5345 n = 0;
5346 {
5347 ValaList* _param_list = NULL;
5348 ValaList* _tmp0_;
5349 ValaList* _tmp1_;
5350 gint _param_size = 0;
5351 ValaList* _tmp2_;
5352 gint _tmp3_;
5353 gint _tmp4_;
5354 gint _param_index = 0;
5355 _tmp0_ = self->priv->parameters;
5356 _tmp1_ = _vala_iterable_ref0 (_tmp0_);
5357 _param_list = _tmp1_;
5358 _tmp2_ = _param_list;
5359 _tmp3_ = vala_collection_get_size ((ValaCollection*) _tmp2_);
5360 _tmp4_ = _tmp3_;
5361 _param_size = _tmp4_;
5362 _param_index = -1;
5363 while (TRUE) {
5364 gint _tmp5_;
5365 gint _tmp6_;
5366 ValaParameter* param = NULL;
5367 ValaList* _tmp7_;
5368 gpointer _tmp8_;
5369 gboolean _tmp9_ = FALSE;
5370 ValaParameter* _tmp10_;
5371 ValaExpression* _tmp11_;
5372 ValaExpression* _tmp12_;
5373 gint _tmp16_;
5374 _param_index = _param_index + 1;
5375 _tmp5_ = _param_index;
5376 _tmp6_ = _param_size;
5377 if (!(_tmp5_ < _tmp6_)) {
5378 break;
5379 }
5380 _tmp7_ = _param_list;
5381 _tmp8_ = vala_list_get (_tmp7_, _param_index);
5382 param = (ValaParameter*) _tmp8_;
5383 _tmp10_ = param;
5384 _tmp11_ = vala_variable_get_initializer ((ValaVariable*) _tmp10_);
5385 _tmp12_ = _tmp11_;
5386 if (_tmp12_ != NULL) {
5387 _tmp9_ = TRUE;
5388 } else {
5389 ValaParameter* _tmp13_;
5390 gboolean _tmp14_;
5391 gboolean _tmp15_;
5392 _tmp13_ = param;
5393 _tmp14_ = vala_parameter_get_ellipsis (_tmp13_);
5394 _tmp15_ = _tmp14_;
5395 _tmp9_ = _tmp15_;
5396 }
5397 if (_tmp9_) {
5398 _vala_code_node_unref0 (param);
5399 break;
5400 }
5401 _tmp16_ = n;
5402 n = _tmp16_ + 1;
5403 _vala_code_node_unref0 (param);
5404 }
5405 _vala_iterable_unref0 (_param_list);
5406 }
5407 result = n;
5408 return result;
5409 }
5410
5411 ValaMethod*
vala_method_get_end_method(ValaMethod * self)5412 vala_method_get_end_method (ValaMethod* self)
5413 {
5414 gboolean _tmp0_;
5415 ValaMethod* _tmp1_;
5416 ValaMethod* _tmp36_;
5417 ValaMethod* result = NULL;
5418 g_return_val_if_fail (self != NULL, NULL);
5419 _tmp0_ = self->priv->_coroutine;
5420 _vala_assert (_tmp0_, "this.coroutine");
5421 _tmp1_ = self->priv->end_method;
5422 if (_tmp1_ == NULL) {
5423 ValaDataType* _tmp2_;
5424 ValaDataType* _tmp3_;
5425 ValaSourceReference* _tmp4_;
5426 ValaSourceReference* _tmp5_;
5427 ValaMethod* _tmp6_;
5428 ValaMethod* _tmp7_;
5429 ValaMethod* _tmp8_;
5430 ValaMethod* _tmp9_;
5431 ValaScope* _tmp10_;
5432 ValaScope* _tmp11_;
5433 ValaMethod* _tmp35_;
5434 _tmp2_ = vala_callable_get_return_type ((ValaCallable*) self);
5435 _tmp3_ = _tmp2_;
5436 _tmp4_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
5437 _tmp5_ = _tmp4_;
5438 _tmp6_ = vala_method_new ("end", _tmp3_, _tmp5_, NULL);
5439 _vala_code_node_unref0 (self->priv->end_method);
5440 self->priv->end_method = _tmp6_;
5441 _tmp7_ = self->priv->end_method;
5442 vala_symbol_set_access ((ValaSymbol*) _tmp7_, VALA_SYMBOL_ACCESSIBILITY_PUBLIC);
5443 _tmp8_ = self->priv->end_method;
5444 vala_symbol_set_external ((ValaSymbol*) _tmp8_, TRUE);
5445 _tmp9_ = self->priv->end_method;
5446 _tmp10_ = vala_symbol_get_scope ((ValaSymbol*) self);
5447 _tmp11_ = _tmp10_;
5448 vala_symbol_set_owner ((ValaSymbol*) _tmp9_, _tmp11_);
5449 {
5450 ValaList* _param_list = NULL;
5451 ValaList* _tmp12_;
5452 gint _param_size = 0;
5453 ValaList* _tmp13_;
5454 gint _tmp14_;
5455 gint _tmp15_;
5456 gint _param_index = 0;
5457 _tmp12_ = vala_method_get_async_end_parameters (self);
5458 _param_list = _tmp12_;
5459 _tmp13_ = _param_list;
5460 _tmp14_ = vala_collection_get_size ((ValaCollection*) _tmp13_);
5461 _tmp15_ = _tmp14_;
5462 _param_size = _tmp15_;
5463 _param_index = -1;
5464 while (TRUE) {
5465 gint _tmp16_;
5466 gint _tmp17_;
5467 ValaParameter* param = NULL;
5468 ValaList* _tmp18_;
5469 gpointer _tmp19_;
5470 ValaMethod* _tmp20_;
5471 ValaParameter* _tmp21_;
5472 ValaParameter* _tmp22_;
5473 ValaParameter* _tmp23_;
5474 _param_index = _param_index + 1;
5475 _tmp16_ = _param_index;
5476 _tmp17_ = _param_size;
5477 if (!(_tmp16_ < _tmp17_)) {
5478 break;
5479 }
5480 _tmp18_ = _param_list;
5481 _tmp19_ = vala_list_get (_tmp18_, _param_index);
5482 param = (ValaParameter*) _tmp19_;
5483 _tmp20_ = self->priv->end_method;
5484 _tmp21_ = param;
5485 _tmp22_ = vala_parameter_copy (_tmp21_);
5486 _tmp23_ = _tmp22_;
5487 vala_callable_add_parameter ((ValaCallable*) _tmp20_, _tmp23_);
5488 _vala_code_node_unref0 (_tmp23_);
5489 _vala_code_node_unref0 (param);
5490 }
5491 _vala_iterable_unref0 (_param_list);
5492 }
5493 {
5494 ValaList* _param_list = NULL;
5495 ValaList* _tmp24_;
5496 ValaList* _tmp25_;
5497 gint _param_size = 0;
5498 ValaList* _tmp26_;
5499 gint _tmp27_;
5500 gint _tmp28_;
5501 gint _param_index = 0;
5502 _tmp24_ = vala_method_get_type_parameters (self);
5503 _tmp25_ = _vala_iterable_ref0 (_tmp24_);
5504 _param_list = _tmp25_;
5505 _tmp26_ = _param_list;
5506 _tmp27_ = vala_collection_get_size ((ValaCollection*) _tmp26_);
5507 _tmp28_ = _tmp27_;
5508 _param_size = _tmp28_;
5509 _param_index = -1;
5510 while (TRUE) {
5511 gint _tmp29_;
5512 gint _tmp30_;
5513 ValaTypeParameter* param = NULL;
5514 ValaList* _tmp31_;
5515 gpointer _tmp32_;
5516 ValaMethod* _tmp33_;
5517 ValaTypeParameter* _tmp34_;
5518 _param_index = _param_index + 1;
5519 _tmp29_ = _param_index;
5520 _tmp30_ = _param_size;
5521 if (!(_tmp29_ < _tmp30_)) {
5522 break;
5523 }
5524 _tmp31_ = _param_list;
5525 _tmp32_ = vala_list_get (_tmp31_, _param_index);
5526 param = (ValaTypeParameter*) _tmp32_;
5527 _tmp33_ = self->priv->end_method;
5528 _tmp34_ = param;
5529 vala_method_add_type_parameter (_tmp33_, _tmp34_);
5530 _vala_code_node_unref0 (param);
5531 }
5532 _vala_iterable_unref0 (_param_list);
5533 }
5534 _tmp35_ = self->priv->end_method;
5535 vala_code_node_copy_attribute_double ((ValaCodeNode*) _tmp35_, (ValaCodeNode*) self, "CCode", "async_result_pos");
5536 }
5537 _tmp36_ = self->priv->end_method;
5538 result = _tmp36_;
5539 return result;
5540 }
5541
5542 ValaMethod*
vala_method_get_callback_method(ValaMethod * self)5543 vala_method_get_callback_method (ValaMethod* self)
5544 {
5545 gboolean _tmp0_;
5546 ValaMethod* _tmp1_;
5547 ValaMethod* _tmp24_;
5548 ValaMethod* result = NULL;
5549 g_return_val_if_fail (self != NULL, NULL);
5550 _tmp0_ = self->priv->_coroutine;
5551 _vala_assert (_tmp0_, "this.coroutine");
5552 _tmp1_ = self->priv->callback_method;
5553 if (_tmp1_ == NULL) {
5554 ValaBooleanType* bool_type = NULL;
5555 ValaCodeContext* _tmp2_;
5556 ValaCodeContext* _tmp3_;
5557 ValaNamespace* _tmp4_;
5558 ValaNamespace* _tmp5_;
5559 ValaScope* _tmp6_;
5560 ValaScope* _tmp7_;
5561 ValaSymbol* _tmp8_;
5562 ValaStruct* _tmp9_;
5563 ValaBooleanType* _tmp10_;
5564 ValaBooleanType* _tmp11_;
5565 ValaBooleanType* _tmp12_;
5566 ValaBooleanType* _tmp13_;
5567 ValaSourceReference* _tmp14_;
5568 ValaSourceReference* _tmp15_;
5569 ValaMethod* _tmp16_;
5570 ValaMethod* _tmp17_;
5571 ValaMethod* _tmp18_;
5572 ValaMethod* _tmp19_;
5573 ValaMethod* _tmp20_;
5574 ValaScope* _tmp21_;
5575 ValaScope* _tmp22_;
5576 ValaMethod* _tmp23_;
5577 _tmp2_ = vala_code_context_get ();
5578 _tmp3_ = _tmp2_;
5579 _tmp4_ = vala_code_context_get_root (_tmp3_);
5580 _tmp5_ = _tmp4_;
5581 _tmp6_ = vala_symbol_get_scope ((ValaSymbol*) _tmp5_);
5582 _tmp7_ = _tmp6_;
5583 _tmp8_ = vala_scope_lookup (_tmp7_, "bool");
5584 _tmp9_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp8_, VALA_TYPE_STRUCT, ValaStruct);
5585 _tmp10_ = vala_boolean_type_new (_tmp9_);
5586 _tmp11_ = _tmp10_;
5587 _vala_code_node_unref0 (_tmp9_);
5588 _vala_code_context_unref0 (_tmp3_);
5589 bool_type = _tmp11_;
5590 _tmp12_ = bool_type;
5591 vala_data_type_set_value_owned ((ValaDataType*) _tmp12_, TRUE);
5592 _tmp13_ = bool_type;
5593 _tmp14_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
5594 _tmp15_ = _tmp14_;
5595 _tmp16_ = vala_method_new ("callback", (ValaDataType*) _tmp13_, _tmp15_, NULL);
5596 _vala_code_node_unref0 (self->priv->callback_method);
5597 self->priv->callback_method = _tmp16_;
5598 _tmp17_ = self->priv->callback_method;
5599 vala_symbol_set_access ((ValaSymbol*) _tmp17_, VALA_SYMBOL_ACCESSIBILITY_PUBLIC);
5600 _tmp18_ = self->priv->callback_method;
5601 vala_symbol_set_external ((ValaSymbol*) _tmp18_, TRUE);
5602 _tmp19_ = self->priv->callback_method;
5603 vala_method_set_binding (_tmp19_, VALA_MEMBER_BINDING_INSTANCE);
5604 _tmp20_ = self->priv->callback_method;
5605 _tmp21_ = vala_symbol_get_scope ((ValaSymbol*) self);
5606 _tmp22_ = _tmp21_;
5607 vala_symbol_set_owner ((ValaSymbol*) _tmp20_, _tmp22_);
5608 _tmp23_ = self->priv->callback_method;
5609 vala_method_set_is_async_callback (_tmp23_, TRUE);
5610 _vala_code_node_unref0 (bool_type);
5611 }
5612 _tmp24_ = self->priv->callback_method;
5613 result = _tmp24_;
5614 return result;
5615 }
5616
5617 ValaList*
vala_method_get_async_begin_parameters(ValaMethod * self)5618 vala_method_get_async_begin_parameters (ValaMethod* self)
5619 {
5620 gboolean _tmp0_;
5621 ValaSymbol* glib_ns = NULL;
5622 ValaCodeContext* _tmp1_;
5623 ValaCodeContext* _tmp2_;
5624 ValaNamespace* _tmp3_;
5625 ValaNamespace* _tmp4_;
5626 ValaScope* _tmp5_;
5627 ValaScope* _tmp6_;
5628 ValaSymbol* _tmp7_;
5629 ValaSymbol* _tmp8_;
5630 ValaArrayList* params = NULL;
5631 GEqualFunc _tmp9_;
5632 ValaArrayList* _tmp10_;
5633 ValaParameter* ellipsis = NULL;
5634 ValaDelegateType* callback_type = NULL;
5635 ValaSymbol* _tmp30_;
5636 ValaScope* _tmp31_;
5637 ValaScope* _tmp32_;
5638 ValaSymbol* _tmp33_;
5639 ValaDelegate* _tmp34_;
5640 ValaDelegateType* _tmp35_;
5641 ValaDelegateType* _tmp36_;
5642 ValaDelegateType* _tmp37_;
5643 ValaDelegateType* _tmp38_;
5644 ValaDelegateType* _tmp39_;
5645 ValaParameter* callback_param = NULL;
5646 ValaDelegateType* _tmp40_;
5647 ValaParameter* _tmp41_;
5648 ValaParameter* _tmp42_;
5649 ValaSourceReference* _tmp43_;
5650 ValaSourceReference* _tmp44_;
5651 ValaNullLiteral* _tmp45_;
5652 ValaNullLiteral* _tmp46_;
5653 ValaParameter* _tmp47_;
5654 ValaExpression* _tmp48_;
5655 ValaExpression* _tmp49_;
5656 ValaDelegateType* _tmp50_;
5657 ValaDataType* _tmp51_;
5658 ValaDataType* _tmp52_;
5659 ValaParameter* _tmp53_;
5660 ValaParameter* _tmp54_;
5661 ValaArrayList* _tmp55_;
5662 ValaParameter* _tmp56_;
5663 ValaParameter* _tmp57_;
5664 ValaList* result = NULL;
5665 g_return_val_if_fail (self != NULL, NULL);
5666 _tmp0_ = self->priv->_coroutine;
5667 _vala_assert (_tmp0_, "this.coroutine");
5668 _tmp1_ = vala_code_context_get ();
5669 _tmp2_ = _tmp1_;
5670 _tmp3_ = vala_code_context_get_root (_tmp2_);
5671 _tmp4_ = _tmp3_;
5672 _tmp5_ = vala_symbol_get_scope ((ValaSymbol*) _tmp4_);
5673 _tmp6_ = _tmp5_;
5674 _tmp7_ = vala_scope_lookup (_tmp6_, "GLib");
5675 _tmp8_ = _tmp7_;
5676 _vala_code_context_unref0 (_tmp2_);
5677 glib_ns = _tmp8_;
5678 _tmp9_ = g_direct_equal;
5679 _tmp10_ = vala_array_list_new (VALA_TYPE_PARAMETER, (GBoxedCopyFunc) vala_code_node_ref, (GDestroyNotify) vala_code_node_unref, _tmp9_);
5680 params = _tmp10_;
5681 ellipsis = NULL;
5682 {
5683 ValaList* _param_list = NULL;
5684 ValaList* _tmp11_;
5685 ValaList* _tmp12_;
5686 gint _param_size = 0;
5687 ValaList* _tmp13_;
5688 gint _tmp14_;
5689 gint _tmp15_;
5690 gint _param_index = 0;
5691 _tmp11_ = self->priv->parameters;
5692 _tmp12_ = _vala_iterable_ref0 (_tmp11_);
5693 _param_list = _tmp12_;
5694 _tmp13_ = _param_list;
5695 _tmp14_ = vala_collection_get_size ((ValaCollection*) _tmp13_);
5696 _tmp15_ = _tmp14_;
5697 _param_size = _tmp15_;
5698 _param_index = -1;
5699 while (TRUE) {
5700 gint _tmp16_;
5701 gint _tmp17_;
5702 ValaParameter* param = NULL;
5703 ValaList* _tmp18_;
5704 gpointer _tmp19_;
5705 ValaParameter* _tmp20_;
5706 gboolean _tmp21_;
5707 gboolean _tmp22_;
5708 _param_index = _param_index + 1;
5709 _tmp16_ = _param_index;
5710 _tmp17_ = _param_size;
5711 if (!(_tmp16_ < _tmp17_)) {
5712 break;
5713 }
5714 _tmp18_ = _param_list;
5715 _tmp19_ = vala_list_get (_tmp18_, _param_index);
5716 param = (ValaParameter*) _tmp19_;
5717 _tmp20_ = param;
5718 _tmp21_ = vala_parameter_get_ellipsis (_tmp20_);
5719 _tmp22_ = _tmp21_;
5720 if (_tmp22_) {
5721 ValaParameter* _tmp23_;
5722 ValaParameter* _tmp24_;
5723 _tmp23_ = param;
5724 _tmp24_ = _vala_code_node_ref0 (_tmp23_);
5725 _vala_code_node_unref0 (ellipsis);
5726 ellipsis = _tmp24_;
5727 } else {
5728 ValaParameter* _tmp25_;
5729 ValaParameterDirection _tmp26_;
5730 ValaParameterDirection _tmp27_;
5731 _tmp25_ = param;
5732 _tmp26_ = vala_parameter_get_direction (_tmp25_);
5733 _tmp27_ = _tmp26_;
5734 if (_tmp27_ == VALA_PARAMETER_DIRECTION_IN) {
5735 ValaArrayList* _tmp28_;
5736 ValaParameter* _tmp29_;
5737 _tmp28_ = params;
5738 _tmp29_ = param;
5739 vala_collection_add ((ValaCollection*) _tmp28_, _tmp29_);
5740 }
5741 }
5742 _vala_code_node_unref0 (param);
5743 }
5744 _vala_iterable_unref0 (_param_list);
5745 }
5746 _tmp30_ = glib_ns;
5747 _tmp31_ = vala_symbol_get_scope (_tmp30_);
5748 _tmp32_ = _tmp31_;
5749 _tmp33_ = vala_scope_lookup (_tmp32_, "AsyncReadyCallback");
5750 _tmp34_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp33_, VALA_TYPE_DELEGATE, ValaDelegate);
5751 _tmp35_ = vala_delegate_type_new (_tmp34_);
5752 _tmp36_ = _tmp35_;
5753 _vala_code_node_unref0 (_tmp34_);
5754 callback_type = _tmp36_;
5755 _tmp37_ = callback_type;
5756 vala_data_type_set_nullable ((ValaDataType*) _tmp37_, TRUE);
5757 _tmp38_ = callback_type;
5758 vala_data_type_set_value_owned ((ValaDataType*) _tmp38_, TRUE);
5759 _tmp39_ = callback_type;
5760 vala_delegate_type_set_is_called_once (_tmp39_, TRUE);
5761 _tmp40_ = callback_type;
5762 _tmp41_ = vala_parameter_new ("_callback_", (ValaDataType*) _tmp40_, NULL);
5763 callback_param = _tmp41_;
5764 _tmp42_ = callback_param;
5765 _tmp43_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
5766 _tmp44_ = _tmp43_;
5767 _tmp45_ = vala_null_literal_new (_tmp44_);
5768 _tmp46_ = _tmp45_;
5769 vala_variable_set_initializer ((ValaVariable*) _tmp42_, (ValaExpression*) _tmp46_);
5770 _vala_code_node_unref0 (_tmp46_);
5771 _tmp47_ = callback_param;
5772 _tmp48_ = vala_variable_get_initializer ((ValaVariable*) _tmp47_);
5773 _tmp49_ = _tmp48_;
5774 _tmp50_ = callback_type;
5775 _tmp51_ = vala_data_type_copy ((ValaDataType*) _tmp50_);
5776 _tmp52_ = _tmp51_;
5777 vala_expression_set_target_type (_tmp49_, _tmp52_);
5778 _vala_code_node_unref0 (_tmp52_);
5779 _tmp53_ = callback_param;
5780 vala_code_node_set_attribute_double ((ValaCodeNode*) _tmp53_, "CCode", "pos", (gdouble) -1, NULL);
5781 _tmp54_ = callback_param;
5782 vala_code_node_set_attribute_double ((ValaCodeNode*) _tmp54_, "CCode", "delegate_target_pos", -0.9, NULL);
5783 _tmp55_ = params;
5784 _tmp56_ = callback_param;
5785 vala_collection_add ((ValaCollection*) _tmp55_, _tmp56_);
5786 _tmp57_ = ellipsis;
5787 if (_tmp57_ != NULL) {
5788 ValaArrayList* _tmp58_;
5789 ValaParameter* _tmp59_;
5790 _tmp58_ = params;
5791 _tmp59_ = ellipsis;
5792 vala_collection_add ((ValaCollection*) _tmp58_, _tmp59_);
5793 }
5794 result = (ValaList*) params;
5795 _vala_code_node_unref0 (callback_param);
5796 _vala_code_node_unref0 (callback_type);
5797 _vala_code_node_unref0 (ellipsis);
5798 _vala_code_node_unref0 (glib_ns);
5799 return result;
5800 }
5801
5802 ValaList*
vala_method_get_async_end_parameters(ValaMethod * self)5803 vala_method_get_async_end_parameters (ValaMethod* self)
5804 {
5805 gboolean _tmp0_;
5806 ValaArrayList* params = NULL;
5807 GEqualFunc _tmp1_;
5808 ValaArrayList* _tmp2_;
5809 ValaSymbol* glib_ns = NULL;
5810 ValaCodeContext* _tmp3_;
5811 ValaCodeContext* _tmp4_;
5812 ValaNamespace* _tmp5_;
5813 ValaNamespace* _tmp6_;
5814 ValaScope* _tmp7_;
5815 ValaScope* _tmp8_;
5816 ValaSymbol* _tmp9_;
5817 ValaSymbol* _tmp10_;
5818 ValaObjectType* result_type = NULL;
5819 ValaSymbol* _tmp11_;
5820 ValaScope* _tmp12_;
5821 ValaScope* _tmp13_;
5822 ValaSymbol* _tmp14_;
5823 ValaObjectTypeSymbol* _tmp15_;
5824 ValaObjectType* _tmp16_;
5825 ValaObjectType* _tmp17_;
5826 ValaParameter* result_param = NULL;
5827 ValaObjectType* _tmp18_;
5828 ValaParameter* _tmp19_;
5829 ValaParameter* _tmp20_;
5830 ValaArrayList* _tmp21_;
5831 ValaParameter* _tmp22_;
5832 ValaList* result = NULL;
5833 g_return_val_if_fail (self != NULL, NULL);
5834 _tmp0_ = self->priv->_coroutine;
5835 _vala_assert (_tmp0_, "this.coroutine");
5836 _tmp1_ = g_direct_equal;
5837 _tmp2_ = vala_array_list_new (VALA_TYPE_PARAMETER, (GBoxedCopyFunc) vala_code_node_ref, (GDestroyNotify) vala_code_node_unref, _tmp1_);
5838 params = _tmp2_;
5839 _tmp3_ = vala_code_context_get ();
5840 _tmp4_ = _tmp3_;
5841 _tmp5_ = vala_code_context_get_root (_tmp4_);
5842 _tmp6_ = _tmp5_;
5843 _tmp7_ = vala_symbol_get_scope ((ValaSymbol*) _tmp6_);
5844 _tmp8_ = _tmp7_;
5845 _tmp9_ = vala_scope_lookup (_tmp8_, "GLib");
5846 _tmp10_ = _tmp9_;
5847 _vala_code_context_unref0 (_tmp4_);
5848 glib_ns = _tmp10_;
5849 _tmp11_ = glib_ns;
5850 _tmp12_ = vala_symbol_get_scope (_tmp11_);
5851 _tmp13_ = _tmp12_;
5852 _tmp14_ = vala_scope_lookup (_tmp13_, "AsyncResult");
5853 _tmp15_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp14_, VALA_TYPE_OBJECT_TYPE_SYMBOL, ValaObjectTypeSymbol);
5854 _tmp16_ = vala_object_type_new (_tmp15_);
5855 _tmp17_ = _tmp16_;
5856 _vala_code_node_unref0 (_tmp15_);
5857 result_type = _tmp17_;
5858 _tmp18_ = result_type;
5859 _tmp19_ = vala_parameter_new ("_res_", (ValaDataType*) _tmp18_, NULL);
5860 result_param = _tmp19_;
5861 _tmp20_ = result_param;
5862 vala_code_node_set_attribute_double ((ValaCodeNode*) _tmp20_, "CCode", "pos", vala_code_node_get_attribute_double ((ValaCodeNode*) self, "CCode", "async_result_pos", 0.1), NULL);
5863 _tmp21_ = params;
5864 _tmp22_ = result_param;
5865 vala_collection_add ((ValaCollection*) _tmp21_, _tmp22_);
5866 {
5867 ValaList* _param_list = NULL;
5868 ValaList* _tmp23_;
5869 ValaList* _tmp24_;
5870 gint _param_size = 0;
5871 ValaList* _tmp25_;
5872 gint _tmp26_;
5873 gint _tmp27_;
5874 gint _param_index = 0;
5875 _tmp23_ = self->priv->parameters;
5876 _tmp24_ = _vala_iterable_ref0 (_tmp23_);
5877 _param_list = _tmp24_;
5878 _tmp25_ = _param_list;
5879 _tmp26_ = vala_collection_get_size ((ValaCollection*) _tmp25_);
5880 _tmp27_ = _tmp26_;
5881 _param_size = _tmp27_;
5882 _param_index = -1;
5883 while (TRUE) {
5884 gint _tmp28_;
5885 gint _tmp29_;
5886 ValaParameter* param = NULL;
5887 ValaList* _tmp30_;
5888 gpointer _tmp31_;
5889 ValaParameter* _tmp32_;
5890 ValaParameterDirection _tmp33_;
5891 ValaParameterDirection _tmp34_;
5892 _param_index = _param_index + 1;
5893 _tmp28_ = _param_index;
5894 _tmp29_ = _param_size;
5895 if (!(_tmp28_ < _tmp29_)) {
5896 break;
5897 }
5898 _tmp30_ = _param_list;
5899 _tmp31_ = vala_list_get (_tmp30_, _param_index);
5900 param = (ValaParameter*) _tmp31_;
5901 _tmp32_ = param;
5902 _tmp33_ = vala_parameter_get_direction (_tmp32_);
5903 _tmp34_ = _tmp33_;
5904 if (_tmp34_ == VALA_PARAMETER_DIRECTION_OUT) {
5905 ValaArrayList* _tmp35_;
5906 ValaParameter* _tmp36_;
5907 _tmp35_ = params;
5908 _tmp36_ = param;
5909 vala_collection_add ((ValaCollection*) _tmp35_, _tmp36_);
5910 }
5911 _vala_code_node_unref0 (param);
5912 }
5913 _vala_iterable_unref0 (_param_list);
5914 }
5915 result = (ValaList*) params;
5916 _vala_code_node_unref0 (result_param);
5917 _vala_code_node_unref0 (result_type);
5918 _vala_code_node_unref0 (glib_ns);
5919 return result;
5920 }
5921
5922 void
vala_method_add_captured_variable(ValaMethod * self,ValaLocalVariable * local)5923 vala_method_add_captured_variable (ValaMethod* self,
5924 ValaLocalVariable* local)
5925 {
5926 gboolean _tmp0_;
5927 ValaList* _tmp1_;
5928 ValaList* _tmp4_;
5929 g_return_if_fail (self != NULL);
5930 g_return_if_fail (local != NULL);
5931 _tmp0_ = self->priv->_closure;
5932 _vala_assert (_tmp0_, "this.closure");
5933 _tmp1_ = self->priv->captured_variables;
5934 if (_tmp1_ == NULL) {
5935 GEqualFunc _tmp2_;
5936 ValaArrayList* _tmp3_;
5937 _tmp2_ = g_direct_equal;
5938 _tmp3_ = vala_array_list_new (VALA_TYPE_LOCAL_VARIABLE, (GBoxedCopyFunc) vala_code_node_ref, (GDestroyNotify) vala_code_node_unref, _tmp2_);
5939 _vala_iterable_unref0 (self->priv->captured_variables);
5940 self->priv->captured_variables = (ValaList*) _tmp3_;
5941 }
5942 _tmp4_ = self->priv->captured_variables;
5943 vala_collection_add ((ValaCollection*) _tmp4_, local);
5944 }
5945
5946 void
vala_method_get_captured_variables(ValaMethod * self,ValaCollection * variables)5947 vala_method_get_captured_variables (ValaMethod* self,
5948 ValaCollection* variables)
5949 {
5950 ValaList* _tmp0_;
5951 g_return_if_fail (self != NULL);
5952 g_return_if_fail (variables != NULL);
5953 _tmp0_ = self->priv->captured_variables;
5954 if (_tmp0_ != NULL) {
5955 {
5956 ValaList* _local_list = NULL;
5957 ValaList* _tmp1_;
5958 ValaList* _tmp2_;
5959 gint _local_size = 0;
5960 ValaList* _tmp3_;
5961 gint _tmp4_;
5962 gint _tmp5_;
5963 gint _local_index = 0;
5964 _tmp1_ = self->priv->captured_variables;
5965 _tmp2_ = _vala_iterable_ref0 (_tmp1_);
5966 _local_list = _tmp2_;
5967 _tmp3_ = _local_list;
5968 _tmp4_ = vala_collection_get_size ((ValaCollection*) _tmp3_);
5969 _tmp5_ = _tmp4_;
5970 _local_size = _tmp5_;
5971 _local_index = -1;
5972 while (TRUE) {
5973 gint _tmp6_;
5974 gint _tmp7_;
5975 ValaLocalVariable* local = NULL;
5976 ValaList* _tmp8_;
5977 gpointer _tmp9_;
5978 ValaLocalVariable* _tmp10_;
5979 _local_index = _local_index + 1;
5980 _tmp6_ = _local_index;
5981 _tmp7_ = _local_size;
5982 if (!(_tmp6_ < _tmp7_)) {
5983 break;
5984 }
5985 _tmp8_ = _local_list;
5986 _tmp9_ = vala_list_get (_tmp8_, _local_index);
5987 local = (ValaLocalVariable*) _tmp9_;
5988 _tmp10_ = local;
5989 vala_collection_add (variables, _tmp10_);
5990 _vala_code_node_unref0 (local);
5991 }
5992 _vala_iterable_unref0 (_local_list);
5993 }
5994 }
5995 }
5996
5997 static void
vala_method_real_get_defined_variables(ValaCodeNode * base,ValaCollection * collection)5998 vala_method_real_get_defined_variables (ValaCodeNode* base,
5999 ValaCollection* collection)
6000 {
6001 ValaMethod * self;
6002 ValaLocalVariable* _tmp0_;
6003 ValaLocalVariable* _tmp1_;
6004 ValaLocalVariable* _tmp4_;
6005 gboolean _tmp6_;
6006 self = (ValaMethod*) base;
6007 g_return_if_fail (collection != NULL);
6008 _tmp0_ = vala_subroutine_get_result_var ((ValaSubroutine*) self);
6009 _tmp1_ = _tmp0_;
6010 if (_tmp1_ != NULL) {
6011 ValaLocalVariable* _tmp2_;
6012 ValaLocalVariable* _tmp3_;
6013 _tmp2_ = vala_subroutine_get_result_var ((ValaSubroutine*) self);
6014 _tmp3_ = _tmp2_;
6015 vala_collection_add (collection, (ValaVariable*) _tmp3_);
6016 }
6017 _tmp4_ = self->priv->_params_array_var;
6018 if (_tmp4_ != NULL) {
6019 ValaLocalVariable* _tmp5_;
6020 _tmp5_ = self->priv->_params_array_var;
6021 vala_collection_add (collection, (ValaVariable*) _tmp5_);
6022 }
6023 _tmp6_ = self->priv->_closure;
6024 if (_tmp6_) {
6025 vala_method_get_captured_variables (self, G_TYPE_CHECK_INSTANCE_CAST (collection, VALA_TYPE_COLLECTION, ValaCollection));
6026 }
6027 }
6028
6029 gint
vala_method_get_format_arg_index(ValaMethod * self)6030 vala_method_get_format_arg_index (ValaMethod* self)
6031 {
6032 gint result = 0;
6033 g_return_val_if_fail (self != NULL, 0);
6034 {
6035 gint i = 0;
6036 i = 0;
6037 {
6038 gboolean _tmp0_ = FALSE;
6039 _tmp0_ = TRUE;
6040 while (TRUE) {
6041 ValaList* _tmp2_;
6042 gint _tmp3_;
6043 gint _tmp4_;
6044 ValaList* _tmp5_;
6045 gpointer _tmp6_;
6046 ValaParameter* _tmp7_;
6047 gboolean _tmp8_;
6048 gboolean _tmp9_;
6049 gboolean _tmp10_;
6050 if (!_tmp0_) {
6051 gint _tmp1_;
6052 _tmp1_ = i;
6053 i = _tmp1_ + 1;
6054 }
6055 _tmp0_ = FALSE;
6056 _tmp2_ = self->priv->parameters;
6057 _tmp3_ = vala_collection_get_size ((ValaCollection*) _tmp2_);
6058 _tmp4_ = _tmp3_;
6059 if (!(i < _tmp4_)) {
6060 break;
6061 }
6062 _tmp5_ = self->priv->parameters;
6063 _tmp6_ = vala_list_get (_tmp5_, i);
6064 _tmp7_ = (ValaParameter*) _tmp6_;
6065 _tmp8_ = vala_parameter_get_format_arg (_tmp7_);
6066 _tmp9_ = _tmp8_;
6067 _tmp10_ = _tmp9_;
6068 _vala_code_node_unref0 (_tmp7_);
6069 if (_tmp10_) {
6070 result = i;
6071 return result;
6072 }
6073 }
6074 }
6075 }
6076 result = -1;
6077 return result;
6078 }
6079
6080 gboolean
vala_method_has_error_type_parameter(ValaMethod * self)6081 vala_method_has_error_type_parameter (ValaMethod* self)
6082 {
6083 gboolean _tmp0_;
6084 gboolean _tmp1_;
6085 gboolean _tmp2_ = FALSE;
6086 gboolean _tmp3_ = FALSE;
6087 ValaMethod* _tmp4_;
6088 ValaMethod* _tmp5_;
6089 gboolean _tmp10_ = FALSE;
6090 gboolean _tmp11_ = FALSE;
6091 ValaMethod* _tmp12_;
6092 ValaMethod* _tmp13_;
6093 gboolean result = FALSE;
6094 g_return_val_if_fail (self != NULL, FALSE);
6095 _tmp0_ = vala_code_node_get_tree_can_fail ((ValaCodeNode*) self);
6096 _tmp1_ = _tmp0_;
6097 if (_tmp1_) {
6098 result = TRUE;
6099 return result;
6100 }
6101 _tmp4_ = vala_method_get_base_method (self);
6102 _tmp5_ = _tmp4_;
6103 if (_tmp5_ != NULL) {
6104 ValaMethod* _tmp6_;
6105 ValaMethod* _tmp7_;
6106 _tmp6_ = vala_method_get_base_method (self);
6107 _tmp7_ = _tmp6_;
6108 _tmp3_ = _tmp7_ != self;
6109 } else {
6110 _tmp3_ = FALSE;
6111 }
6112 if (_tmp3_) {
6113 ValaMethod* _tmp8_;
6114 ValaMethod* _tmp9_;
6115 _tmp8_ = vala_method_get_base_method (self);
6116 _tmp9_ = _tmp8_;
6117 _tmp2_ = vala_method_has_error_type_parameter (_tmp9_);
6118 } else {
6119 _tmp2_ = FALSE;
6120 }
6121 if (_tmp2_) {
6122 result = TRUE;
6123 return result;
6124 }
6125 _tmp12_ = vala_method_get_base_interface_method (self);
6126 _tmp13_ = _tmp12_;
6127 if (_tmp13_ != NULL) {
6128 ValaMethod* _tmp14_;
6129 ValaMethod* _tmp15_;
6130 _tmp14_ = vala_method_get_base_interface_method (self);
6131 _tmp15_ = _tmp14_;
6132 _tmp11_ = _tmp15_ != self;
6133 } else {
6134 _tmp11_ = FALSE;
6135 }
6136 if (_tmp11_) {
6137 ValaMethod* _tmp16_;
6138 ValaMethod* _tmp17_;
6139 _tmp16_ = vala_method_get_base_interface_method (self);
6140 _tmp17_ = _tmp16_;
6141 _tmp10_ = vala_method_has_error_type_parameter (_tmp17_);
6142 } else {
6143 _tmp10_ = FALSE;
6144 }
6145 if (_tmp10_) {
6146 result = TRUE;
6147 return result;
6148 }
6149 result = FALSE;
6150 return result;
6151 }
6152
6153 static void
vala_method_class_init(ValaMethodClass * klass,gpointer klass_data)6154 vala_method_class_init (ValaMethodClass * klass,
6155 gpointer klass_data)
6156 {
6157 vala_method_parent_class = g_type_class_peek_parent (klass);
6158 ((ValaCodeNodeClass *) klass)->finalize = vala_method_finalize;
6159 g_type_class_adjust_private_offset (klass, &ValaMethod_private_offset);
6160 ((ValaCodeNodeClass *) klass)->accept = (void (*) (ValaCodeNode*, ValaCodeVisitor*)) vala_method_real_accept;
6161 ((ValaCodeNodeClass *) klass)->accept_children = (void (*) (ValaCodeNode*, ValaCodeVisitor*)) vala_method_real_accept_children;
6162 ((ValaCodeNodeClass *) klass)->get_error_types = (void (*) (ValaCodeNode*, ValaCollection*, ValaSourceReference*)) vala_method_real_get_error_types;
6163 ((ValaCodeNodeClass *) klass)->replace_type = (void (*) (ValaCodeNode*, ValaDataType*, ValaDataType*)) vala_method_real_replace_type;
6164 ((ValaCodeNodeClass *) klass)->check = (gboolean (*) (ValaCodeNode*, ValaCodeContext*)) vala_method_real_check;
6165 ((ValaCodeNodeClass *) klass)->get_defined_variables = (void (*) (ValaCodeNode*, ValaCollection*)) vala_method_real_get_defined_variables;
6166 VALA_SUBROUTINE_CLASS (klass)->get_has_result = vala_method_real_get_has_result;
6167 }
6168
6169 static void
vala_method_vala_callable_interface_init(ValaCallableIface * iface,gpointer iface_data)6170 vala_method_vala_callable_interface_init (ValaCallableIface * iface,
6171 gpointer iface_data)
6172 {
6173 vala_method_vala_callable_parent_iface = g_type_interface_peek_parent (iface);
6174 iface->add_parameter = (void (*) (ValaCallable*, ValaParameter*)) vala_method_real_add_parameter;
6175 iface->get_parameters = (ValaList* (*) (ValaCallable*)) vala_method_real_get_parameters;
6176 iface->get_return_type = vala_method_real_get_return_type;
6177 iface->set_return_type = vala_method_real_set_return_type;
6178 }
6179
6180 static void
vala_method_instance_init(ValaMethod * self,gpointer klass)6181 vala_method_instance_init (ValaMethod * self,
6182 gpointer klass)
6183 {
6184 GEqualFunc _tmp0_;
6185 ValaArrayList* _tmp1_;
6186 self->priv = vala_method_get_instance_private (self);
6187 self->priv->_binding = VALA_MEMBER_BINDING_INSTANCE;
6188 _tmp0_ = g_direct_equal;
6189 _tmp1_ = vala_array_list_new (VALA_TYPE_PARAMETER, (GBoxedCopyFunc) vala_code_node_ref, (GDestroyNotify) vala_code_node_unref, _tmp0_);
6190 self->priv->parameters = (ValaList*) _tmp1_;
6191 }
6192
6193 static void
vala_method_finalize(ValaCodeNode * obj)6194 vala_method_finalize (ValaCodeNode * obj)
6195 {
6196 ValaMethod * self;
6197 self = G_TYPE_CHECK_INSTANCE_CAST (obj, VALA_TYPE_METHOD, ValaMethod);
6198 _vala_iterable_unref0 (self->priv->type_parameters);
6199 _vala_code_node_unref0 (self->priv->_this_parameter);
6200 _vala_code_node_unref0 (self->priv->_params_array_var);
6201 _vala_iterable_unref0 (self->priv->parameters);
6202 _vala_iterable_unref0 (self->priv->preconditions);
6203 _vala_iterable_unref0 (self->priv->postconditions);
6204 _vala_code_node_unref0 (self->priv->_return_type);
6205 _vala_iterable_unref0 (self->error_types);
6206 _vala_code_node_unref0 (self->priv->_base_interface_type);
6207 _vala_code_node_unref0 (self->priv->callback_method);
6208 _vala_code_node_unref0 (self->priv->end_method);
6209 _vala_iterable_unref0 (self->priv->captured_variables);
6210 VALA_CODE_NODE_CLASS (vala_method_parent_class)->finalize (obj);
6211 }
6212
6213 /**
6214 * Represents a type or namespace method.
6215 */
6216 static GType
vala_method_get_type_once(void)6217 vala_method_get_type_once (void)
6218 {
6219 static const GTypeInfo g_define_type_info = { sizeof (ValaMethodClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) vala_method_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ValaMethod), 0, (GInstanceInitFunc) vala_method_instance_init, NULL };
6220 static const GInterfaceInfo vala_callable_info = { (GInterfaceInitFunc) vala_method_vala_callable_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
6221 GType vala_method_type_id;
6222 vala_method_type_id = g_type_register_static (VALA_TYPE_SUBROUTINE, "ValaMethod", &g_define_type_info, 0);
6223 g_type_add_interface_static (vala_method_type_id, VALA_TYPE_CALLABLE, &vala_callable_info);
6224 ValaMethod_private_offset = g_type_add_instance_private (vala_method_type_id, sizeof (ValaMethodPrivate));
6225 return vala_method_type_id;
6226 }
6227
6228 GType
vala_method_get_type(void)6229 vala_method_get_type (void)
6230 {
6231 static volatile gsize vala_method_type_id__volatile = 0;
6232 if (g_once_init_enter (&vala_method_type_id__volatile)) {
6233 GType vala_method_type_id;
6234 vala_method_type_id = vala_method_get_type_once ();
6235 g_once_init_leave (&vala_method_type_id__volatile, vala_method_type_id);
6236 }
6237 return vala_method_type_id__volatile;
6238 }
6239
6240