1 /* valadatatype.c generated by valac, the Vala compiler
2 * generated from valadatatype.vala, do not modify */
3
4 /* valadatatype.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 <glib.h>
30 #include <valagee.h>
31 #include <glib-object.h>
32 #include <stdlib.h>
33 #include <string.h>
34
35 #define _vala_iterable_unref0(var) ((var == NULL) ? NULL : (var = (vala_iterable_unref (var), NULL)))
36 #define _vala_code_node_unref0(var) ((var == NULL) ? NULL : (var = (vala_code_node_unref (var), NULL)))
37 #define _vala_scope_unref0(var) ((var == NULL) ? NULL : (var = (vala_scope_unref (var), NULL)))
38 #define _g_free0(var) (var = (g_free (var), NULL))
39 #define _vala_code_context_unref0(var) ((var == NULL) ? NULL : (var = (vala_code_context_unref (var), NULL)))
40 #define _vala_iterator_unref0(var) ((var == NULL) ? NULL : (var = (vala_iterator_unref (var), NULL)))
41 #define _g_string_free0(var) ((var == NULL) ? NULL : (var = (g_string_free (var, TRUE), NULL)))
42 #define _g_regex_unref0(var) ((var == NULL) ? NULL : (var = (g_regex_unref (var), NULL)))
43
44 struct _ValaDataTypePrivate {
45 gboolean _value_owned;
46 gboolean _nullable;
47 ValaSymbol* _symbol;
48 gboolean _floating_reference;
49 gboolean _is_dynamic;
50 ValaList* type_argument_list;
51 };
52
53 static gint ValaDataType_private_offset;
54 static gpointer vala_data_type_parent_class = NULL;
55 static ValaList* vala_data_type__empty_type_list;
56 static ValaList* vala_data_type__empty_type_list = NULL;
57
58 static void vala_data_type_set_symbol (ValaDataType* self,
59 ValaSymbol* value);
60 static void vala_data_type_real_accept (ValaCodeNode* base,
61 ValaCodeVisitor* visitor);
62 static void vala_data_type_real_accept_children (ValaCodeNode* base,
63 ValaCodeVisitor* visitor);
64 static gchar* vala_data_type_real_to_string (ValaCodeNode* base);
65 static gchar* vala_data_type_real_to_qualified_string (ValaDataType* self,
66 ValaScope* scope);
67 static ValaDataType* vala_data_type_real_copy (ValaDataType* self);
68 static gboolean vala_data_type_real_equals (ValaDataType* self,
69 ValaDataType* type2);
70 static gboolean vala_data_type_real_stricter (ValaDataType* self,
71 ValaDataType* type2);
72 static void vala_data_type_real_replace_type (ValaCodeNode* base,
73 ValaDataType* old_type,
74 ValaDataType* new_type);
75 static gboolean vala_data_type_real_compatible (ValaDataType* self,
76 ValaDataType* target_type);
77 G_GNUC_INTERNAL ValaDataType* vala_semantic_analyzer_get_instance_base_type_for_member (ValaDataType* derived_instance_type,
78 ValaTypeSymbol* type_symbol,
79 ValaCodeNode* node_reference);
80 static gboolean vala_data_type_real_is_invokable (ValaDataType* self);
81 static ValaDataType* vala_data_type_real_get_return_type (ValaDataType* self);
82 static ValaList* vala_data_type_real_get_parameters (ValaDataType* self);
83 static gboolean vala_data_type_real_is_reference_type_or_type_parameter (ValaDataType* self);
84 static gboolean vala_data_type_real_is_accessible (ValaDataType* self,
85 ValaSymbol* sym);
86 static ValaSymbol* vala_data_type_real_get_member (ValaDataType* self,
87 const gchar* member_name);
88 static ValaSymbol* vala_data_type_real_get_pointer_member (ValaDataType* self,
89 const gchar* member_name);
90 static gboolean vala_data_type_real_is_real_struct_type (ValaDataType* self);
91 static gboolean vala_data_type_real_is_disposable (ValaDataType* self);
92 static ValaDataType* vala_data_type_real_get_actual_type (ValaDataType* self,
93 ValaDataType* derived_instance_type,
94 ValaList* method_type_arguments,
95 ValaCodeNode* node_reference);
96 static ValaDataType* vala_data_type_real_infer_type_argument (ValaDataType* self,
97 ValaTypeParameter* type_param,
98 ValaDataType* value_type);
99 static gchar* vala_data_type_real_to_prototype_string (ValaDataType* self,
100 const gchar* override_name);
101 static void vala_data_type_finalize (ValaCodeNode * obj);
102 static GType vala_data_type_get_type_once (void);
103
104 static inline gpointer
vala_data_type_get_instance_private(ValaDataType * self)105 vala_data_type_get_instance_private (ValaDataType* self)
106 {
107 return G_STRUCT_MEMBER_P (self, ValaDataType_private_offset);
108 }
109
110 gboolean
vala_data_type_get_value_owned(ValaDataType * self)111 vala_data_type_get_value_owned (ValaDataType* self)
112 {
113 gboolean result;
114 g_return_val_if_fail (self != NULL, FALSE);
115 result = self->priv->_value_owned;
116 return result;
117 }
118
119 void
vala_data_type_set_value_owned(ValaDataType * self,gboolean value)120 vala_data_type_set_value_owned (ValaDataType* self,
121 gboolean value)
122 {
123 g_return_if_fail (self != NULL);
124 self->priv->_value_owned = value;
125 }
126
127 gboolean
vala_data_type_get_nullable(ValaDataType * self)128 vala_data_type_get_nullable (ValaDataType* self)
129 {
130 gboolean result;
131 g_return_val_if_fail (self != NULL, FALSE);
132 result = self->priv->_nullable;
133 return result;
134 }
135
136 void
vala_data_type_set_nullable(ValaDataType * self,gboolean value)137 vala_data_type_set_nullable (ValaDataType* self,
138 gboolean value)
139 {
140 g_return_if_fail (self != NULL);
141 self->priv->_nullable = value;
142 }
143
144 ValaSymbol*
vala_data_type_get_symbol(ValaDataType * self)145 vala_data_type_get_symbol (ValaDataType* self)
146 {
147 ValaSymbol* result;
148 ValaSymbol* _tmp0_;
149 g_return_val_if_fail (self != NULL, NULL);
150 _tmp0_ = self->priv->_symbol;
151 result = _tmp0_;
152 return result;
153 }
154
155 static void
vala_data_type_set_symbol(ValaDataType * self,ValaSymbol * value)156 vala_data_type_set_symbol (ValaDataType* self,
157 ValaSymbol* value)
158 {
159 g_return_if_fail (self != NULL);
160 self->priv->_symbol = value;
161 }
162
163 ValaTypeSymbol*
vala_data_type_get_type_symbol(ValaDataType * self)164 vala_data_type_get_type_symbol (ValaDataType* self)
165 {
166 ValaTypeSymbol* result;
167 ValaSymbol* _tmp0_;
168 g_return_val_if_fail (self != NULL, NULL);
169 _tmp0_ = self->priv->_symbol;
170 result = VALA_IS_TYPESYMBOL (_tmp0_) ? ((ValaTypeSymbol*) _tmp0_) : NULL;
171 return result;
172 }
173
174 gboolean
vala_data_type_get_floating_reference(ValaDataType * self)175 vala_data_type_get_floating_reference (ValaDataType* self)
176 {
177 gboolean result;
178 g_return_val_if_fail (self != NULL, FALSE);
179 result = self->priv->_floating_reference;
180 return result;
181 }
182
183 void
vala_data_type_set_floating_reference(ValaDataType * self,gboolean value)184 vala_data_type_set_floating_reference (ValaDataType* self,
185 gboolean value)
186 {
187 g_return_if_fail (self != NULL);
188 self->priv->_floating_reference = value;
189 }
190
191 gboolean
vala_data_type_get_is_dynamic(ValaDataType * self)192 vala_data_type_get_is_dynamic (ValaDataType* self)
193 {
194 gboolean result;
195 g_return_val_if_fail (self != NULL, FALSE);
196 result = self->priv->_is_dynamic;
197 return result;
198 }
199
200 void
vala_data_type_set_is_dynamic(ValaDataType * self,gboolean value)201 vala_data_type_set_is_dynamic (ValaDataType* self,
202 gboolean value)
203 {
204 g_return_if_fail (self != NULL);
205 self->priv->_is_dynamic = value;
206 }
207
208 ValaDataType*
vala_data_type_construct_with_symbol(GType object_type,ValaSymbol * symbol)209 vala_data_type_construct_with_symbol (GType object_type,
210 ValaSymbol* symbol)
211 {
212 ValaDataType* self = NULL;
213 self = (ValaDataType*) vala_code_node_construct (object_type);
214 vala_data_type_set_symbol (self, symbol);
215 return self;
216 }
217
218 /**
219 * Appends the specified type as generic type argument.
220 *
221 * @param arg a type reference
222 */
223 void
vala_data_type_add_type_argument(ValaDataType * self,ValaDataType * arg)224 vala_data_type_add_type_argument (ValaDataType* self,
225 ValaDataType* arg)
226 {
227 ValaList* _tmp0_;
228 ValaList* _tmp3_;
229 g_return_if_fail (self != NULL);
230 g_return_if_fail (arg != NULL);
231 _tmp0_ = self->priv->type_argument_list;
232 if (_tmp0_ == NULL) {
233 GEqualFunc _tmp1_;
234 ValaArrayList* _tmp2_;
235 _tmp1_ = g_direct_equal;
236 _tmp2_ = vala_array_list_new (VALA_TYPE_DATA_TYPE, (GBoxedCopyFunc) vala_code_node_ref, (GDestroyNotify) vala_code_node_unref, _tmp1_);
237 _vala_iterable_unref0 (self->priv->type_argument_list);
238 self->priv->type_argument_list = (ValaList*) _tmp2_;
239 }
240 _tmp3_ = self->priv->type_argument_list;
241 vala_collection_add ((ValaCollection*) _tmp3_, arg);
242 vala_code_node_set_parent_node ((ValaCodeNode*) arg, (ValaCodeNode*) self);
243 }
244
245 /**
246 * Returns the list of generic type arguments.
247 *
248 * @return type argument list
249 */
250 ValaList*
vala_data_type_get_type_arguments(ValaDataType * self)251 vala_data_type_get_type_arguments (ValaDataType* self)
252 {
253 ValaList* _tmp0_;
254 ValaList* _tmp2_;
255 ValaList* _tmp5_;
256 ValaList* result = NULL;
257 g_return_val_if_fail (self != NULL, NULL);
258 _tmp0_ = self->priv->type_argument_list;
259 if (_tmp0_ != NULL) {
260 ValaList* _tmp1_;
261 _tmp1_ = self->priv->type_argument_list;
262 result = _tmp1_;
263 return result;
264 }
265 _tmp2_ = vala_data_type__empty_type_list;
266 if (_tmp2_ == NULL) {
267 GEqualFunc _tmp3_;
268 ValaArrayList* _tmp4_;
269 _tmp3_ = g_direct_equal;
270 _tmp4_ = vala_array_list_new (VALA_TYPE_DATA_TYPE, (GBoxedCopyFunc) vala_code_node_ref, (GDestroyNotify) vala_code_node_unref, _tmp3_);
271 _vala_iterable_unref0 (vala_data_type__empty_type_list);
272 vala_data_type__empty_type_list = (ValaList*) _tmp4_;
273 }
274 _tmp5_ = vala_data_type__empty_type_list;
275 result = _tmp5_;
276 return result;
277 }
278
279 gboolean
vala_data_type_has_type_arguments(ValaDataType * self)280 vala_data_type_has_type_arguments (ValaDataType* self)
281 {
282 ValaList* _tmp0_;
283 ValaList* _tmp1_;
284 gint _tmp2_;
285 gint _tmp3_;
286 gboolean result = FALSE;
287 g_return_val_if_fail (self != NULL, FALSE);
288 _tmp0_ = self->priv->type_argument_list;
289 if (_tmp0_ == NULL) {
290 result = FALSE;
291 return result;
292 }
293 _tmp1_ = self->priv->type_argument_list;
294 _tmp2_ = vala_collection_get_size ((ValaCollection*) _tmp1_);
295 _tmp3_ = _tmp2_;
296 result = _tmp3_ > 0;
297 return result;
298 }
299
300 /**
301 * Removes all generic type arguments.
302 */
303 void
vala_data_type_remove_all_type_arguments(ValaDataType * self)304 vala_data_type_remove_all_type_arguments (ValaDataType* self)
305 {
306 g_return_if_fail (self != NULL);
307 _vala_iterable_unref0 (self->priv->type_argument_list);
308 self->priv->type_argument_list = NULL;
309 }
310
311 static void
vala_data_type_real_accept(ValaCodeNode * base,ValaCodeVisitor * visitor)312 vala_data_type_real_accept (ValaCodeNode* base,
313 ValaCodeVisitor* visitor)
314 {
315 ValaDataType * self;
316 self = (ValaDataType*) base;
317 g_return_if_fail (visitor != NULL);
318 vala_code_visitor_visit_data_type (visitor, self);
319 }
320
321 static gpointer
_vala_iterable_ref0(gpointer self)322 _vala_iterable_ref0 (gpointer self)
323 {
324 return self ? vala_iterable_ref (self) : NULL;
325 }
326
327 static void
vala_data_type_real_accept_children(ValaCodeNode * base,ValaCodeVisitor * visitor)328 vala_data_type_real_accept_children (ValaCodeNode* base,
329 ValaCodeVisitor* visitor)
330 {
331 ValaDataType * self;
332 gboolean _tmp0_ = FALSE;
333 ValaList* _tmp1_;
334 self = (ValaDataType*) base;
335 g_return_if_fail (visitor != NULL);
336 _tmp1_ = self->priv->type_argument_list;
337 if (_tmp1_ != NULL) {
338 ValaList* _tmp2_;
339 gint _tmp3_;
340 gint _tmp4_;
341 _tmp2_ = self->priv->type_argument_list;
342 _tmp3_ = vala_collection_get_size ((ValaCollection*) _tmp2_);
343 _tmp4_ = _tmp3_;
344 _tmp0_ = _tmp4_ > 0;
345 } else {
346 _tmp0_ = FALSE;
347 }
348 if (_tmp0_) {
349 {
350 ValaList* _type_arg_list = NULL;
351 ValaList* _tmp5_;
352 ValaList* _tmp6_;
353 gint _type_arg_size = 0;
354 ValaList* _tmp7_;
355 gint _tmp8_;
356 gint _tmp9_;
357 gint _type_arg_index = 0;
358 _tmp5_ = self->priv->type_argument_list;
359 _tmp6_ = _vala_iterable_ref0 (_tmp5_);
360 _type_arg_list = _tmp6_;
361 _tmp7_ = _type_arg_list;
362 _tmp8_ = vala_collection_get_size ((ValaCollection*) _tmp7_);
363 _tmp9_ = _tmp8_;
364 _type_arg_size = _tmp9_;
365 _type_arg_index = -1;
366 while (TRUE) {
367 gint _tmp10_;
368 gint _tmp11_;
369 ValaDataType* type_arg = NULL;
370 ValaList* _tmp12_;
371 gpointer _tmp13_;
372 ValaDataType* _tmp14_;
373 _type_arg_index = _type_arg_index + 1;
374 _tmp10_ = _type_arg_index;
375 _tmp11_ = _type_arg_size;
376 if (!(_tmp10_ < _tmp11_)) {
377 break;
378 }
379 _tmp12_ = _type_arg_list;
380 _tmp13_ = vala_list_get (_tmp12_, _type_arg_index);
381 type_arg = (ValaDataType*) _tmp13_;
382 _tmp14_ = type_arg;
383 vala_code_node_accept ((ValaCodeNode*) _tmp14_, visitor);
384 _vala_code_node_unref0 (type_arg);
385 }
386 _vala_iterable_unref0 (_type_arg_list);
387 }
388 }
389 }
390
391 static gchar*
vala_data_type_real_to_string(ValaCodeNode * base)392 vala_data_type_real_to_string (ValaCodeNode* base)
393 {
394 ValaDataType * self;
395 gchar* _tmp0_;
396 gchar* result = NULL;
397 self = (ValaDataType*) base;
398 _tmp0_ = vala_data_type_to_qualified_string (self, NULL);
399 result = _tmp0_;
400 return result;
401 }
402
403 static gpointer
_vala_code_node_ref0(gpointer self)404 _vala_code_node_ref0 (gpointer self)
405 {
406 return self ? vala_code_node_ref (self) : NULL;
407 }
408
409 static gpointer
_vala_scope_ref0(gpointer self)410 _vala_scope_ref0 (gpointer self)
411 {
412 return self ? vala_scope_ref (self) : NULL;
413 }
414
415 static gchar*
vala_data_type_real_to_qualified_string(ValaDataType * self,ValaScope * scope)416 vala_data_type_real_to_qualified_string (ValaDataType* self,
417 ValaScope* scope)
418 {
419 gchar* s = NULL;
420 ValaTypeSymbol* _tmp0_;
421 ValaTypeSymbol* _tmp1_;
422 ValaList* type_args = NULL;
423 ValaList* _tmp44_;
424 ValaList* _tmp45_;
425 ValaList* _tmp46_;
426 gint _tmp47_;
427 gint _tmp48_;
428 gboolean _tmp72_;
429 gchar* result = NULL;
430 _tmp0_ = vala_data_type_get_type_symbol (self);
431 _tmp1_ = _tmp0_;
432 if (_tmp1_ != NULL) {
433 ValaSymbol* global_symbol = NULL;
434 ValaTypeSymbol* _tmp2_;
435 ValaTypeSymbol* _tmp3_;
436 ValaSymbol* _tmp4_;
437 ValaSymbol* sym = NULL;
438 ValaScope* parent_scope = NULL;
439 ValaScope* _tmp18_;
440 gboolean _tmp31_ = FALSE;
441 ValaSymbol* _tmp32_;
442 _tmp2_ = vala_data_type_get_type_symbol (self);
443 _tmp3_ = _tmp2_;
444 _tmp4_ = _vala_code_node_ref0 ((ValaSymbol*) _tmp3_);
445 global_symbol = _tmp4_;
446 while (TRUE) {
447 gboolean _tmp5_ = FALSE;
448 ValaSymbol* _tmp6_;
449 ValaSymbol* _tmp7_;
450 ValaSymbol* _tmp8_;
451 ValaSymbol* _tmp14_;
452 ValaSymbol* _tmp15_;
453 ValaSymbol* _tmp16_;
454 ValaSymbol* _tmp17_;
455 _tmp6_ = global_symbol;
456 _tmp7_ = vala_symbol_get_parent_symbol (_tmp6_);
457 _tmp8_ = _tmp7_;
458 if (_tmp8_ != NULL) {
459 ValaSymbol* _tmp9_;
460 ValaSymbol* _tmp10_;
461 ValaSymbol* _tmp11_;
462 const gchar* _tmp12_;
463 const gchar* _tmp13_;
464 _tmp9_ = global_symbol;
465 _tmp10_ = vala_symbol_get_parent_symbol (_tmp9_);
466 _tmp11_ = _tmp10_;
467 _tmp12_ = vala_symbol_get_name (_tmp11_);
468 _tmp13_ = _tmp12_;
469 _tmp5_ = _tmp13_ != NULL;
470 } else {
471 _tmp5_ = FALSE;
472 }
473 if (!_tmp5_) {
474 break;
475 }
476 _tmp14_ = global_symbol;
477 _tmp15_ = vala_symbol_get_parent_symbol (_tmp14_);
478 _tmp16_ = _tmp15_;
479 _tmp17_ = _vala_code_node_ref0 (_tmp16_);
480 _vala_code_node_unref0 (global_symbol);
481 global_symbol = _tmp17_;
482 }
483 sym = NULL;
484 _tmp18_ = _vala_scope_ref0 (scope);
485 parent_scope = _tmp18_;
486 while (TRUE) {
487 gboolean _tmp19_ = FALSE;
488 ValaSymbol* _tmp20_;
489 ValaScope* _tmp22_;
490 ValaSymbol* _tmp23_;
491 const gchar* _tmp24_;
492 const gchar* _tmp25_;
493 ValaSymbol* _tmp26_;
494 ValaScope* _tmp27_;
495 ValaScope* _tmp28_;
496 ValaScope* _tmp29_;
497 ValaScope* _tmp30_;
498 _tmp20_ = sym;
499 if (_tmp20_ == NULL) {
500 ValaScope* _tmp21_;
501 _tmp21_ = parent_scope;
502 _tmp19_ = _tmp21_ != NULL;
503 } else {
504 _tmp19_ = FALSE;
505 }
506 if (!_tmp19_) {
507 break;
508 }
509 _tmp22_ = parent_scope;
510 _tmp23_ = global_symbol;
511 _tmp24_ = vala_symbol_get_name (_tmp23_);
512 _tmp25_ = _tmp24_;
513 _tmp26_ = vala_scope_lookup (_tmp22_, _tmp25_);
514 _vala_code_node_unref0 (sym);
515 sym = _tmp26_;
516 _tmp27_ = parent_scope;
517 _tmp28_ = vala_scope_get_parent_scope (_tmp27_);
518 _tmp29_ = _tmp28_;
519 _tmp30_ = _vala_scope_ref0 (_tmp29_);
520 _vala_scope_unref0 (parent_scope);
521 parent_scope = _tmp30_;
522 }
523 _tmp32_ = sym;
524 if (_tmp32_ != NULL) {
525 ValaSymbol* _tmp33_;
526 ValaSymbol* _tmp34_;
527 _tmp33_ = global_symbol;
528 _tmp34_ = sym;
529 _tmp31_ = _tmp33_ != _tmp34_;
530 } else {
531 _tmp31_ = FALSE;
532 }
533 if (_tmp31_) {
534 ValaTypeSymbol* _tmp35_;
535 ValaTypeSymbol* _tmp36_;
536 gchar* _tmp37_;
537 gchar* _tmp38_;
538 gchar* _tmp39_;
539 _tmp35_ = vala_data_type_get_type_symbol (self);
540 _tmp36_ = _tmp35_;
541 _tmp37_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp36_);
542 _tmp38_ = _tmp37_;
543 _tmp39_ = g_strconcat ("global::", _tmp38_, NULL);
544 _g_free0 (s);
545 s = _tmp39_;
546 _g_free0 (_tmp38_);
547 } else {
548 ValaTypeSymbol* _tmp40_;
549 ValaTypeSymbol* _tmp41_;
550 gchar* _tmp42_;
551 _tmp40_ = vala_data_type_get_type_symbol (self);
552 _tmp41_ = _tmp40_;
553 _tmp42_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp41_);
554 _g_free0 (s);
555 s = _tmp42_;
556 }
557 _vala_scope_unref0 (parent_scope);
558 _vala_code_node_unref0 (sym);
559 _vala_code_node_unref0 (global_symbol);
560 } else {
561 gchar* _tmp43_;
562 _tmp43_ = g_strdup ("null");
563 _g_free0 (s);
564 s = _tmp43_;
565 }
566 _tmp44_ = vala_data_type_get_type_arguments (self);
567 _tmp45_ = _vala_iterable_ref0 (_tmp44_);
568 type_args = _tmp45_;
569 _tmp46_ = type_args;
570 _tmp47_ = vala_collection_get_size ((ValaCollection*) _tmp46_);
571 _tmp48_ = _tmp47_;
572 if (_tmp48_ > 0) {
573 const gchar* _tmp49_;
574 gchar* _tmp50_;
575 gboolean first = FALSE;
576 const gchar* _tmp70_;
577 gchar* _tmp71_;
578 _tmp49_ = s;
579 _tmp50_ = g_strconcat (_tmp49_, "<", NULL);
580 _g_free0 (s);
581 s = _tmp50_;
582 first = TRUE;
583 {
584 ValaList* _type_arg_list = NULL;
585 ValaList* _tmp51_;
586 ValaList* _tmp52_;
587 gint _type_arg_size = 0;
588 ValaList* _tmp53_;
589 gint _tmp54_;
590 gint _tmp55_;
591 gint _type_arg_index = 0;
592 _tmp51_ = type_args;
593 _tmp52_ = _vala_iterable_ref0 (_tmp51_);
594 _type_arg_list = _tmp52_;
595 _tmp53_ = _type_arg_list;
596 _tmp54_ = vala_collection_get_size ((ValaCollection*) _tmp53_);
597 _tmp55_ = _tmp54_;
598 _type_arg_size = _tmp55_;
599 _type_arg_index = -1;
600 while (TRUE) {
601 gint _tmp56_;
602 gint _tmp57_;
603 ValaDataType* type_arg = NULL;
604 ValaList* _tmp58_;
605 gpointer _tmp59_;
606 ValaDataType* _tmp62_;
607 const gchar* _tmp65_;
608 ValaDataType* _tmp66_;
609 gchar* _tmp67_;
610 gchar* _tmp68_;
611 gchar* _tmp69_;
612 _type_arg_index = _type_arg_index + 1;
613 _tmp56_ = _type_arg_index;
614 _tmp57_ = _type_arg_size;
615 if (!(_tmp56_ < _tmp57_)) {
616 break;
617 }
618 _tmp58_ = _type_arg_list;
619 _tmp59_ = vala_list_get (_tmp58_, _type_arg_index);
620 type_arg = (ValaDataType*) _tmp59_;
621 if (!first) {
622 const gchar* _tmp60_;
623 gchar* _tmp61_;
624 _tmp60_ = s;
625 _tmp61_ = g_strconcat (_tmp60_, ",", NULL);
626 _g_free0 (s);
627 s = _tmp61_;
628 } else {
629 first = FALSE;
630 }
631 _tmp62_ = type_arg;
632 if (vala_data_type_is_weak (_tmp62_)) {
633 const gchar* _tmp63_;
634 gchar* _tmp64_;
635 _tmp63_ = s;
636 _tmp64_ = g_strconcat (_tmp63_, "weak ", NULL);
637 _g_free0 (s);
638 s = _tmp64_;
639 }
640 _tmp65_ = s;
641 _tmp66_ = type_arg;
642 _tmp67_ = vala_data_type_to_qualified_string (_tmp66_, scope);
643 _tmp68_ = _tmp67_;
644 _tmp69_ = g_strconcat (_tmp65_, _tmp68_, NULL);
645 _g_free0 (s);
646 s = _tmp69_;
647 _g_free0 (_tmp68_);
648 _vala_code_node_unref0 (type_arg);
649 }
650 _vala_iterable_unref0 (_type_arg_list);
651 }
652 _tmp70_ = s;
653 _tmp71_ = g_strconcat (_tmp70_, ">", NULL);
654 _g_free0 (s);
655 s = _tmp71_;
656 }
657 _tmp72_ = self->priv->_nullable;
658 if (_tmp72_) {
659 const gchar* _tmp73_;
660 gchar* _tmp74_;
661 _tmp73_ = s;
662 _tmp74_ = g_strconcat (_tmp73_, "?", NULL);
663 _g_free0 (s);
664 s = _tmp74_;
665 }
666 result = s;
667 _vala_iterable_unref0 (type_args);
668 return result;
669 }
670
671 gchar*
vala_data_type_to_qualified_string(ValaDataType * self,ValaScope * scope)672 vala_data_type_to_qualified_string (ValaDataType* self,
673 ValaScope* scope)
674 {
675 g_return_val_if_fail (self != NULL, NULL);
676 return VALA_DATA_TYPE_GET_CLASS (self)->to_qualified_string (self, scope);
677 }
678
679 /**
680 * Creates a shallow copy of this type reference.
681 *
682 * @return copy of this type reference
683 */
684 static ValaDataType*
vala_data_type_real_copy(ValaDataType * self)685 vala_data_type_real_copy (ValaDataType* self)
686 {
687 g_critical ("Type `%s' does not implement abstract method `vala_data_type_copy'", g_type_name (G_TYPE_FROM_INSTANCE (self)));
688 return NULL;
689 }
690
691 ValaDataType*
vala_data_type_copy(ValaDataType * self)692 vala_data_type_copy (ValaDataType* self)
693 {
694 g_return_val_if_fail (self != NULL, NULL);
695 return VALA_DATA_TYPE_GET_CLASS (self)->copy (self);
696 }
697
698 /**
699 * Checks two type references for equality. May only be used with
700 * resolved type references.
701 *
702 * @param type2 a type reference
703 * @return true if this type reference is equal to type2, false
704 * otherwise
705 */
706 static gboolean
vala_data_type_real_equals(ValaDataType * self,ValaDataType * type2)707 vala_data_type_real_equals (ValaDataType* self,
708 ValaDataType* type2)
709 {
710 gboolean _tmp0_;
711 gboolean _tmp1_;
712 ValaTypeSymbol* _tmp2_;
713 ValaTypeSymbol* _tmp3_;
714 ValaTypeSymbol* _tmp4_;
715 ValaTypeSymbol* _tmp5_;
716 gboolean _tmp6_ = FALSE;
717 gboolean _tmp12_;
718 gboolean _tmp13_;
719 ValaList* type_args = NULL;
720 ValaList* _tmp14_;
721 ValaList* _tmp15_;
722 ValaList* type2_args = NULL;
723 ValaList* _tmp16_;
724 ValaList* _tmp17_;
725 ValaList* _tmp18_;
726 gint _tmp19_;
727 gint _tmp20_;
728 ValaList* _tmp21_;
729 gint _tmp22_;
730 gint _tmp23_;
731 gboolean result = FALSE;
732 g_return_val_if_fail (type2 != NULL, FALSE);
733 if (vala_data_type_is_disposable (type2) != vala_data_type_is_disposable (self)) {
734 result = FALSE;
735 return result;
736 }
737 _tmp0_ = type2->priv->_nullable;
738 _tmp1_ = self->priv->_nullable;
739 if (_tmp0_ != _tmp1_) {
740 result = FALSE;
741 return result;
742 }
743 _tmp2_ = vala_data_type_get_type_symbol (type2);
744 _tmp3_ = _tmp2_;
745 _tmp4_ = vala_data_type_get_type_symbol (self);
746 _tmp5_ = _tmp4_;
747 if (_tmp3_ != _tmp5_) {
748 result = FALSE;
749 return result;
750 }
751 if (VALA_IS_GENERIC_TYPE (type2)) {
752 _tmp6_ = TRUE;
753 } else {
754 _tmp6_ = VALA_IS_GENERIC_TYPE (self);
755 }
756 if (_tmp6_) {
757 gboolean _tmp7_ = FALSE;
758 ValaTypeParameter* _tmp8_;
759 ValaTypeParameter* _tmp9_;
760 ValaTypeParameter* _tmp10_;
761 ValaTypeParameter* _tmp11_;
762 if (!VALA_IS_GENERIC_TYPE (type2)) {
763 _tmp7_ = TRUE;
764 } else {
765 _tmp7_ = !VALA_IS_GENERIC_TYPE (self);
766 }
767 if (_tmp7_) {
768 result = FALSE;
769 return result;
770 }
771 _tmp8_ = vala_generic_type_get_type_parameter (G_TYPE_CHECK_INSTANCE_CAST (type2, VALA_TYPE_GENERIC_TYPE, ValaGenericType));
772 _tmp9_ = _tmp8_;
773 _tmp10_ = vala_generic_type_get_type_parameter (G_TYPE_CHECK_INSTANCE_CAST (self, VALA_TYPE_GENERIC_TYPE, ValaGenericType));
774 _tmp11_ = _tmp10_;
775 if (!vala_typeparameter_equals (_tmp9_, _tmp11_)) {
776 result = FALSE;
777 return result;
778 }
779 }
780 _tmp12_ = type2->priv->_floating_reference;
781 _tmp13_ = self->priv->_floating_reference;
782 if (_tmp12_ != _tmp13_) {
783 result = FALSE;
784 return result;
785 }
786 _tmp14_ = vala_data_type_get_type_arguments (self);
787 _tmp15_ = _vala_iterable_ref0 (_tmp14_);
788 type_args = _tmp15_;
789 _tmp16_ = vala_data_type_get_type_arguments (type2);
790 _tmp17_ = _vala_iterable_ref0 (_tmp16_);
791 type2_args = _tmp17_;
792 _tmp18_ = type2_args;
793 _tmp19_ = vala_collection_get_size ((ValaCollection*) _tmp18_);
794 _tmp20_ = _tmp19_;
795 _tmp21_ = type_args;
796 _tmp22_ = vala_collection_get_size ((ValaCollection*) _tmp21_);
797 _tmp23_ = _tmp22_;
798 if (_tmp20_ != _tmp23_) {
799 result = FALSE;
800 _vala_iterable_unref0 (type2_args);
801 _vala_iterable_unref0 (type_args);
802 return result;
803 }
804 {
805 gint i = 0;
806 i = 0;
807 {
808 gboolean _tmp24_ = FALSE;
809 _tmp24_ = TRUE;
810 while (TRUE) {
811 ValaList* _tmp26_;
812 gint _tmp27_;
813 gint _tmp28_;
814 ValaList* _tmp29_;
815 gpointer _tmp30_;
816 ValaDataType* _tmp31_;
817 ValaList* _tmp32_;
818 gpointer _tmp33_;
819 ValaDataType* _tmp34_;
820 gboolean _tmp35_;
821 if (!_tmp24_) {
822 gint _tmp25_;
823 _tmp25_ = i;
824 i = _tmp25_ + 1;
825 }
826 _tmp24_ = FALSE;
827 _tmp26_ = type_args;
828 _tmp27_ = vala_collection_get_size ((ValaCollection*) _tmp26_);
829 _tmp28_ = _tmp27_;
830 if (!(i < _tmp28_)) {
831 break;
832 }
833 _tmp29_ = type2_args;
834 _tmp30_ = vala_list_get (_tmp29_, i);
835 _tmp31_ = (ValaDataType*) _tmp30_;
836 _tmp32_ = type_args;
837 _tmp33_ = vala_list_get (_tmp32_, i);
838 _tmp34_ = (ValaDataType*) _tmp33_;
839 _tmp35_ = !vala_data_type_equals (_tmp31_, _tmp34_);
840 _vala_code_node_unref0 (_tmp34_);
841 _vala_code_node_unref0 (_tmp31_);
842 if (_tmp35_) {
843 result = FALSE;
844 _vala_iterable_unref0 (type2_args);
845 _vala_iterable_unref0 (type_args);
846 return result;
847 }
848 }
849 }
850 }
851 result = TRUE;
852 _vala_iterable_unref0 (type2_args);
853 _vala_iterable_unref0 (type_args);
854 return result;
855 }
856
857 gboolean
vala_data_type_equals(ValaDataType * self,ValaDataType * type2)858 vala_data_type_equals (ValaDataType* self,
859 ValaDataType* type2)
860 {
861 g_return_val_if_fail (self != NULL, FALSE);
862 return VALA_DATA_TYPE_GET_CLASS (self)->equals (self, type2);
863 }
864
865 /**
866 * Checks whether this type reference is at least as strict as the
867 * specified type reference type2.
868 *
869 * @param type2 a type reference
870 * @return true if this type reference is stricter or equal
871 */
872 static gboolean
vala_data_type_real_stricter(ValaDataType * self,ValaDataType * type2)873 vala_data_type_real_stricter (ValaDataType* self,
874 ValaDataType* type2)
875 {
876 gboolean _tmp0_ = FALSE;
877 gboolean _tmp1_;
878 gboolean _tmp3_ = FALSE;
879 ValaTypeSymbol* _tmp4_;
880 ValaTypeSymbol* _tmp5_;
881 ValaTypeSymbol* _tmp6_;
882 ValaTypeSymbol* _tmp7_;
883 gboolean _tmp8_;
884 gboolean _tmp9_;
885 gboolean result = FALSE;
886 g_return_val_if_fail (type2 != NULL, FALSE);
887 if (vala_data_type_is_disposable (type2) != vala_data_type_is_disposable (self)) {
888 result = FALSE;
889 return result;
890 }
891 _tmp1_ = type2->priv->_nullable;
892 if (!_tmp1_) {
893 gboolean _tmp2_;
894 _tmp2_ = self->priv->_nullable;
895 _tmp0_ = _tmp2_;
896 } else {
897 _tmp0_ = FALSE;
898 }
899 if (_tmp0_) {
900 result = FALSE;
901 return result;
902 }
903 if (VALA_IS_GENERIC_TYPE (self)) {
904 _tmp3_ = TRUE;
905 } else {
906 _tmp3_ = VALA_IS_GENERIC_TYPE (type2);
907 }
908 if (_tmp3_) {
909 result = TRUE;
910 return result;
911 }
912 _tmp4_ = vala_data_type_get_type_symbol (type2);
913 _tmp5_ = _tmp4_;
914 _tmp6_ = vala_data_type_get_type_symbol (self);
915 _tmp7_ = _tmp6_;
916 if (_tmp5_ != _tmp7_) {
917 result = FALSE;
918 return result;
919 }
920 _tmp8_ = type2->priv->_floating_reference;
921 _tmp9_ = self->priv->_floating_reference;
922 if (_tmp8_ != _tmp9_) {
923 result = FALSE;
924 return result;
925 }
926 result = TRUE;
927 return result;
928 }
929
930 gboolean
vala_data_type_stricter(ValaDataType * self,ValaDataType * type2)931 vala_data_type_stricter (ValaDataType* self,
932 ValaDataType* type2)
933 {
934 g_return_val_if_fail (self != NULL, FALSE);
935 return VALA_DATA_TYPE_GET_CLASS (self)->stricter (self, type2);
936 }
937
938 static void
vala_data_type_real_replace_type(ValaCodeNode * base,ValaDataType * old_type,ValaDataType * new_type)939 vala_data_type_real_replace_type (ValaCodeNode* base,
940 ValaDataType* old_type,
941 ValaDataType* new_type)
942 {
943 ValaDataType * self;
944 ValaList* _tmp0_;
945 self = (ValaDataType*) base;
946 g_return_if_fail (old_type != NULL);
947 g_return_if_fail (new_type != NULL);
948 _tmp0_ = self->priv->type_argument_list;
949 if (_tmp0_ != NULL) {
950 {
951 gint i = 0;
952 i = 0;
953 {
954 gboolean _tmp1_ = FALSE;
955 _tmp1_ = TRUE;
956 while (TRUE) {
957 ValaList* _tmp3_;
958 gint _tmp4_;
959 gint _tmp5_;
960 ValaList* _tmp6_;
961 gpointer _tmp7_;
962 ValaDataType* _tmp8_;
963 gboolean _tmp9_;
964 if (!_tmp1_) {
965 gint _tmp2_;
966 _tmp2_ = i;
967 i = _tmp2_ + 1;
968 }
969 _tmp1_ = FALSE;
970 _tmp3_ = self->priv->type_argument_list;
971 _tmp4_ = vala_collection_get_size ((ValaCollection*) _tmp3_);
972 _tmp5_ = _tmp4_;
973 if (!(i < _tmp5_)) {
974 break;
975 }
976 _tmp6_ = self->priv->type_argument_list;
977 _tmp7_ = vala_list_get (_tmp6_, i);
978 _tmp8_ = (ValaDataType*) _tmp7_;
979 _tmp9_ = _tmp8_ == old_type;
980 _vala_code_node_unref0 (_tmp8_);
981 if (_tmp9_) {
982 ValaList* _tmp10_;
983 _tmp10_ = self->priv->type_argument_list;
984 vala_list_set (_tmp10_, i, new_type);
985 return;
986 }
987 }
988 }
989 }
990 }
991 }
992
993 static gboolean
vala_data_type_real_compatible(ValaDataType * self,ValaDataType * target_type)994 vala_data_type_real_compatible (ValaDataType* self,
995 ValaDataType* target_type)
996 {
997 ValaCodeContext* context = NULL;
998 ValaCodeContext* _tmp0_;
999 gboolean _tmp1_ = FALSE;
1000 gboolean _tmp2_ = FALSE;
1001 ValaCodeContext* _tmp3_;
1002 gboolean _tmp4_;
1003 gboolean _tmp5_;
1004 gboolean _tmp8_ = FALSE;
1005 ValaCodeContext* _tmp9_;
1006 ValaProfile _tmp10_;
1007 ValaProfile _tmp11_;
1008 gboolean _tmp43_ = FALSE;
1009 gboolean _tmp44_ = FALSE;
1010 ValaTypeSymbol* _tmp45_;
1011 ValaTypeSymbol* _tmp46_;
1012 ValaList* type_args = NULL;
1013 ValaList* _tmp51_;
1014 ValaList* _tmp52_;
1015 ValaList* target_type_args = NULL;
1016 ValaList* _tmp53_;
1017 ValaList* _tmp54_;
1018 ValaList* _tmp55_;
1019 gint _tmp56_;
1020 gint _tmp57_;
1021 ValaList* _tmp58_;
1022 gint _tmp59_;
1023 gint _tmp60_;
1024 gboolean _tmp74_ = FALSE;
1025 gboolean _tmp75_ = FALSE;
1026 ValaTypeSymbol* _tmp76_;
1027 ValaTypeSymbol* _tmp77_;
1028 gboolean _tmp108_ = FALSE;
1029 ValaTypeSymbol* _tmp109_;
1030 ValaTypeSymbol* _tmp110_;
1031 gboolean result = FALSE;
1032 g_return_val_if_fail (target_type != NULL, FALSE);
1033 _tmp0_ = vala_code_context_get ();
1034 context = _tmp0_;
1035 _tmp3_ = context;
1036 _tmp4_ = vala_code_context_get_experimental_non_null (_tmp3_);
1037 _tmp5_ = _tmp4_;
1038 if (_tmp5_) {
1039 gboolean _tmp6_;
1040 _tmp6_ = self->priv->_nullable;
1041 _tmp2_ = _tmp6_;
1042 } else {
1043 _tmp2_ = FALSE;
1044 }
1045 if (_tmp2_) {
1046 gboolean _tmp7_;
1047 _tmp7_ = target_type->priv->_nullable;
1048 _tmp1_ = !_tmp7_;
1049 } else {
1050 _tmp1_ = FALSE;
1051 }
1052 if (_tmp1_) {
1053 result = FALSE;
1054 _vala_code_context_unref0 (context);
1055 return result;
1056 }
1057 _tmp9_ = context;
1058 _tmp10_ = vala_code_context_get_profile (_tmp9_);
1059 _tmp11_ = _tmp10_;
1060 if (_tmp11_ == VALA_PROFILE_GOBJECT) {
1061 ValaTypeSymbol* _tmp12_;
1062 ValaTypeSymbol* _tmp13_;
1063 _tmp12_ = vala_data_type_get_type_symbol (target_type);
1064 _tmp13_ = _tmp12_;
1065 _tmp8_ = _tmp13_ != NULL;
1066 } else {
1067 _tmp8_ = FALSE;
1068 }
1069 if (_tmp8_) {
1070 ValaDataType* gvalue_type = NULL;
1071 ValaCodeContext* _tmp14_;
1072 ValaSemanticAnalyzer* _tmp15_;
1073 ValaSemanticAnalyzer* _tmp16_;
1074 ValaStructValueType* _tmp17_;
1075 gboolean _tmp18_ = FALSE;
1076 ValaDataType* _tmp19_;
1077 ValaDataType* gvariant_type = NULL;
1078 ValaCodeContext* _tmp25_;
1079 ValaSemanticAnalyzer* _tmp26_;
1080 ValaSemanticAnalyzer* _tmp27_;
1081 ValaObjectType* _tmp28_;
1082 gboolean _tmp29_ = FALSE;
1083 ValaDataType* _tmp30_;
1084 _tmp14_ = context;
1085 _tmp15_ = vala_code_context_get_analyzer (_tmp14_);
1086 _tmp16_ = _tmp15_;
1087 _tmp17_ = _tmp16_->gvalue_type;
1088 gvalue_type = (ValaDataType*) _tmp17_;
1089 _tmp19_ = gvalue_type;
1090 if (_tmp19_ != NULL) {
1091 ValaTypeSymbol* _tmp20_;
1092 ValaTypeSymbol* _tmp21_;
1093 ValaDataType* _tmp22_;
1094 ValaTypeSymbol* _tmp23_;
1095 ValaTypeSymbol* _tmp24_;
1096 _tmp20_ = vala_data_type_get_type_symbol (target_type);
1097 _tmp21_ = _tmp20_;
1098 _tmp22_ = gvalue_type;
1099 _tmp23_ = vala_data_type_get_type_symbol (_tmp22_);
1100 _tmp24_ = _tmp23_;
1101 _tmp18_ = vala_typesymbol_is_subtype_of (_tmp21_, _tmp24_);
1102 } else {
1103 _tmp18_ = FALSE;
1104 }
1105 if (_tmp18_) {
1106 result = TRUE;
1107 _vala_code_context_unref0 (context);
1108 return result;
1109 }
1110 _tmp25_ = context;
1111 _tmp26_ = vala_code_context_get_analyzer (_tmp25_);
1112 _tmp27_ = _tmp26_;
1113 _tmp28_ = _tmp27_->gvariant_type;
1114 gvariant_type = (ValaDataType*) _tmp28_;
1115 _tmp30_ = gvariant_type;
1116 if (_tmp30_ != NULL) {
1117 ValaTypeSymbol* _tmp31_;
1118 ValaTypeSymbol* _tmp32_;
1119 ValaDataType* _tmp33_;
1120 ValaTypeSymbol* _tmp34_;
1121 ValaTypeSymbol* _tmp35_;
1122 _tmp31_ = vala_data_type_get_type_symbol (target_type);
1123 _tmp32_ = _tmp31_;
1124 _tmp33_ = gvariant_type;
1125 _tmp34_ = vala_data_type_get_type_symbol (_tmp33_);
1126 _tmp35_ = _tmp34_;
1127 _tmp29_ = vala_typesymbol_is_subtype_of (_tmp32_, _tmp35_);
1128 } else {
1129 _tmp29_ = FALSE;
1130 }
1131 if (_tmp29_) {
1132 result = TRUE;
1133 _vala_code_context_unref0 (context);
1134 return result;
1135 }
1136 }
1137 if (VALA_IS_POINTER_TYPE (target_type)) {
1138 gboolean _tmp36_ = FALSE;
1139 if (VALA_IS_GENERIC_TYPE (self)) {
1140 _tmp36_ = TRUE;
1141 } else {
1142 gboolean _tmp37_ = FALSE;
1143 ValaTypeSymbol* _tmp38_;
1144 ValaTypeSymbol* _tmp39_;
1145 _tmp38_ = vala_data_type_get_type_symbol (self);
1146 _tmp39_ = _tmp38_;
1147 if (_tmp39_ != NULL) {
1148 gboolean _tmp40_ = FALSE;
1149 ValaTypeSymbol* _tmp41_;
1150 ValaTypeSymbol* _tmp42_;
1151 _tmp41_ = vala_data_type_get_type_symbol (self);
1152 _tmp42_ = _tmp41_;
1153 if (vala_typesymbol_is_reference_type (_tmp42_)) {
1154 _tmp40_ = TRUE;
1155 } else {
1156 _tmp40_ = VALA_IS_DELEGATE_TYPE (self);
1157 }
1158 _tmp37_ = _tmp40_;
1159 } else {
1160 _tmp37_ = FALSE;
1161 }
1162 _tmp36_ = _tmp37_;
1163 }
1164 if (_tmp36_) {
1165 result = TRUE;
1166 _vala_code_context_unref0 (context);
1167 return result;
1168 }
1169 result = FALSE;
1170 _vala_code_context_unref0 (context);
1171 return result;
1172 }
1173 if (VALA_IS_GENERIC_TYPE (target_type)) {
1174 result = TRUE;
1175 _vala_code_context_unref0 (context);
1176 return result;
1177 }
1178 if (VALA_IS_ARRAY_TYPE (self) != VALA_IS_ARRAY_TYPE (target_type)) {
1179 result = FALSE;
1180 _vala_code_context_unref0 (context);
1181 return result;
1182 }
1183 _tmp45_ = vala_data_type_get_type_symbol (self);
1184 _tmp46_ = _tmp45_;
1185 if (VALA_IS_ENUM (_tmp46_)) {
1186 ValaTypeSymbol* _tmp47_;
1187 ValaTypeSymbol* _tmp48_;
1188 _tmp47_ = vala_data_type_get_type_symbol (target_type);
1189 _tmp48_ = _tmp47_;
1190 _tmp44_ = VALA_IS_STRUCT (_tmp48_);
1191 } else {
1192 _tmp44_ = FALSE;
1193 }
1194 if (_tmp44_) {
1195 ValaTypeSymbol* _tmp49_;
1196 ValaTypeSymbol* _tmp50_;
1197 _tmp49_ = vala_data_type_get_type_symbol (target_type);
1198 _tmp50_ = _tmp49_;
1199 _tmp43_ = vala_struct_is_integer_type (G_TYPE_CHECK_INSTANCE_CAST (_tmp50_, VALA_TYPE_STRUCT, ValaStruct));
1200 } else {
1201 _tmp43_ = FALSE;
1202 }
1203 if (_tmp43_) {
1204 result = TRUE;
1205 _vala_code_context_unref0 (context);
1206 return result;
1207 }
1208 _tmp51_ = vala_data_type_get_type_arguments (self);
1209 _tmp52_ = _vala_iterable_ref0 (_tmp51_);
1210 type_args = _tmp52_;
1211 _tmp53_ = vala_data_type_get_type_arguments (target_type);
1212 _tmp54_ = _vala_iterable_ref0 (_tmp53_);
1213 target_type_args = _tmp54_;
1214 _tmp55_ = type_args;
1215 _tmp56_ = vala_collection_get_size ((ValaCollection*) _tmp55_);
1216 _tmp57_ = _tmp56_;
1217 _tmp58_ = target_type_args;
1218 _tmp59_ = vala_collection_get_size ((ValaCollection*) _tmp58_);
1219 _tmp60_ = _tmp59_;
1220 if (_tmp57_ == _tmp60_) {
1221 {
1222 gint i = 0;
1223 i = 0;
1224 {
1225 gboolean _tmp61_ = FALSE;
1226 _tmp61_ = TRUE;
1227 while (TRUE) {
1228 ValaList* _tmp63_;
1229 gint _tmp64_;
1230 gint _tmp65_;
1231 ValaDataType* type_arg = NULL;
1232 ValaList* _tmp66_;
1233 gpointer _tmp67_;
1234 ValaDataType* target_type_arg = NULL;
1235 ValaList* _tmp68_;
1236 gpointer _tmp69_;
1237 gboolean _tmp70_ = FALSE;
1238 ValaDataType* _tmp71_;
1239 if (!_tmp61_) {
1240 gint _tmp62_;
1241 _tmp62_ = i;
1242 i = _tmp62_ + 1;
1243 }
1244 _tmp61_ = FALSE;
1245 _tmp63_ = type_args;
1246 _tmp64_ = vala_collection_get_size ((ValaCollection*) _tmp63_);
1247 _tmp65_ = _tmp64_;
1248 if (!(i < _tmp65_)) {
1249 break;
1250 }
1251 _tmp66_ = type_args;
1252 _tmp67_ = vala_list_get (_tmp66_, i);
1253 type_arg = (ValaDataType*) _tmp67_;
1254 _tmp68_ = target_type_args;
1255 _tmp69_ = vala_list_get (_tmp68_, i);
1256 target_type_arg = (ValaDataType*) _tmp69_;
1257 _tmp71_ = type_arg;
1258 if (!vala_data_type_is_non_null_simple_type (_tmp71_)) {
1259 ValaDataType* _tmp72_;
1260 ValaDataType* _tmp73_;
1261 _tmp72_ = type_arg;
1262 _tmp73_ = target_type_arg;
1263 _tmp70_ = vala_data_type_is_weak (_tmp72_) != vala_data_type_is_weak (_tmp73_);
1264 } else {
1265 _tmp70_ = FALSE;
1266 }
1267 if (_tmp70_) {
1268 result = FALSE;
1269 _vala_code_node_unref0 (target_type_arg);
1270 _vala_code_node_unref0 (type_arg);
1271 _vala_iterable_unref0 (target_type_args);
1272 _vala_iterable_unref0 (type_args);
1273 _vala_code_context_unref0 (context);
1274 return result;
1275 }
1276 _vala_code_node_unref0 (target_type_arg);
1277 _vala_code_node_unref0 (type_arg);
1278 }
1279 }
1280 }
1281 }
1282 _tmp76_ = vala_data_type_get_type_symbol (self);
1283 _tmp77_ = _tmp76_;
1284 if (_tmp77_ != NULL) {
1285 ValaTypeSymbol* _tmp78_;
1286 ValaTypeSymbol* _tmp79_;
1287 _tmp78_ = vala_data_type_get_type_symbol (target_type);
1288 _tmp79_ = _tmp78_;
1289 _tmp75_ = _tmp79_ != NULL;
1290 } else {
1291 _tmp75_ = FALSE;
1292 }
1293 if (_tmp75_) {
1294 ValaTypeSymbol* _tmp80_;
1295 ValaTypeSymbol* _tmp81_;
1296 ValaTypeSymbol* _tmp82_;
1297 ValaTypeSymbol* _tmp83_;
1298 _tmp80_ = vala_data_type_get_type_symbol (self);
1299 _tmp81_ = _tmp80_;
1300 _tmp82_ = vala_data_type_get_type_symbol (target_type);
1301 _tmp83_ = _tmp82_;
1302 _tmp74_ = vala_typesymbol_is_subtype_of (_tmp81_, _tmp83_);
1303 } else {
1304 _tmp74_ = FALSE;
1305 }
1306 if (_tmp74_) {
1307 ValaDataType* base_type = NULL;
1308 ValaTypeSymbol* _tmp84_;
1309 ValaTypeSymbol* _tmp85_;
1310 ValaDataType* _tmp86_;
1311 ValaList* base_type_args = NULL;
1312 ValaDataType* _tmp87_;
1313 ValaList* _tmp88_;
1314 ValaList* _tmp89_;
1315 ValaList* _tmp90_;
1316 gint _tmp91_;
1317 gint _tmp92_;
1318 ValaList* _tmp93_;
1319 gint _tmp94_;
1320 gint _tmp95_;
1321 _tmp84_ = vala_data_type_get_type_symbol (target_type);
1322 _tmp85_ = _tmp84_;
1323 _tmp86_ = vala_semantic_analyzer_get_instance_base_type_for_member (self, _tmp85_, (ValaCodeNode*) self);
1324 base_type = _tmp86_;
1325 _tmp87_ = base_type;
1326 _tmp88_ = vala_data_type_get_type_arguments (_tmp87_);
1327 _tmp89_ = _vala_iterable_ref0 (_tmp88_);
1328 base_type_args = _tmp89_;
1329 _tmp90_ = base_type_args;
1330 _tmp91_ = vala_collection_get_size ((ValaCollection*) _tmp90_);
1331 _tmp92_ = _tmp91_;
1332 _tmp93_ = target_type_args;
1333 _tmp94_ = vala_collection_get_size ((ValaCollection*) _tmp93_);
1334 _tmp95_ = _tmp94_;
1335 if (_tmp92_ == _tmp95_) {
1336 {
1337 gint i = 0;
1338 i = 0;
1339 {
1340 gboolean _tmp96_ = FALSE;
1341 _tmp96_ = TRUE;
1342 while (TRUE) {
1343 ValaList* _tmp98_;
1344 gint _tmp99_;
1345 gint _tmp100_;
1346 ValaList* _tmp101_;
1347 gpointer _tmp102_;
1348 ValaDataType* _tmp103_;
1349 ValaList* _tmp104_;
1350 gpointer _tmp105_;
1351 ValaDataType* _tmp106_;
1352 gboolean _tmp107_;
1353 if (!_tmp96_) {
1354 gint _tmp97_;
1355 _tmp97_ = i;
1356 i = _tmp97_ + 1;
1357 }
1358 _tmp96_ = FALSE;
1359 _tmp98_ = base_type_args;
1360 _tmp99_ = vala_collection_get_size ((ValaCollection*) _tmp98_);
1361 _tmp100_ = _tmp99_;
1362 if (!(i < _tmp100_)) {
1363 break;
1364 }
1365 _tmp101_ = base_type_args;
1366 _tmp102_ = vala_list_get (_tmp101_, i);
1367 _tmp103_ = (ValaDataType*) _tmp102_;
1368 _tmp104_ = target_type_args;
1369 _tmp105_ = vala_list_get (_tmp104_, i);
1370 _tmp106_ = (ValaDataType*) _tmp105_;
1371 _tmp107_ = !vala_data_type_compatible (_tmp103_, _tmp106_);
1372 _vala_code_node_unref0 (_tmp106_);
1373 _vala_code_node_unref0 (_tmp103_);
1374 if (_tmp107_) {
1375 result = FALSE;
1376 _vala_iterable_unref0 (base_type_args);
1377 _vala_code_node_unref0 (base_type);
1378 _vala_iterable_unref0 (target_type_args);
1379 _vala_iterable_unref0 (type_args);
1380 _vala_code_context_unref0 (context);
1381 return result;
1382 }
1383 }
1384 }
1385 }
1386 }
1387 result = TRUE;
1388 _vala_iterable_unref0 (base_type_args);
1389 _vala_code_node_unref0 (base_type);
1390 _vala_iterable_unref0 (target_type_args);
1391 _vala_iterable_unref0 (type_args);
1392 _vala_code_context_unref0 (context);
1393 return result;
1394 }
1395 _tmp109_ = vala_data_type_get_type_symbol (self);
1396 _tmp110_ = _tmp109_;
1397 if (VALA_IS_STRUCT (_tmp110_)) {
1398 ValaTypeSymbol* _tmp111_;
1399 ValaTypeSymbol* _tmp112_;
1400 _tmp111_ = vala_data_type_get_type_symbol (target_type);
1401 _tmp112_ = _tmp111_;
1402 _tmp108_ = VALA_IS_STRUCT (_tmp112_);
1403 } else {
1404 _tmp108_ = FALSE;
1405 }
1406 if (_tmp108_) {
1407 ValaStruct* expr_struct = NULL;
1408 ValaTypeSymbol* _tmp113_;
1409 ValaTypeSymbol* _tmp114_;
1410 ValaStruct* expect_struct = NULL;
1411 ValaTypeSymbol* _tmp115_;
1412 ValaTypeSymbol* _tmp116_;
1413 gboolean _tmp117_ = FALSE;
1414 ValaStruct* _tmp118_;
1415 gboolean _tmp120_ = FALSE;
1416 gboolean _tmp121_ = FALSE;
1417 ValaStruct* _tmp122_;
1418 gboolean _tmp133_ = FALSE;
1419 ValaStruct* _tmp134_;
1420 ValaStruct* _tmp136_;
1421 ValaStruct* _tmp137_;
1422 _tmp113_ = vala_data_type_get_type_symbol (self);
1423 _tmp114_ = _tmp113_;
1424 expr_struct = G_TYPE_CHECK_INSTANCE_CAST (_tmp114_, VALA_TYPE_STRUCT, ValaStruct);
1425 _tmp115_ = vala_data_type_get_type_symbol (target_type);
1426 _tmp116_ = _tmp115_;
1427 expect_struct = G_TYPE_CHECK_INSTANCE_CAST (_tmp116_, VALA_TYPE_STRUCT, ValaStruct);
1428 _tmp118_ = expr_struct;
1429 if (vala_struct_is_integer_type (_tmp118_)) {
1430 ValaStruct* _tmp119_;
1431 _tmp119_ = expect_struct;
1432 _tmp117_ = vala_struct_is_floating_type (_tmp119_);
1433 } else {
1434 _tmp117_ = FALSE;
1435 }
1436 if (_tmp117_) {
1437 result = TRUE;
1438 _vala_iterable_unref0 (target_type_args);
1439 _vala_iterable_unref0 (type_args);
1440 _vala_code_context_unref0 (context);
1441 return result;
1442 }
1443 _tmp122_ = expr_struct;
1444 if (vala_struct_is_integer_type (_tmp122_)) {
1445 ValaStruct* _tmp123_;
1446 _tmp123_ = expect_struct;
1447 _tmp121_ = vala_struct_is_integer_type (_tmp123_);
1448 } else {
1449 _tmp121_ = FALSE;
1450 }
1451 if (_tmp121_) {
1452 _tmp120_ = TRUE;
1453 } else {
1454 gboolean _tmp124_ = FALSE;
1455 ValaStruct* _tmp125_;
1456 _tmp125_ = expr_struct;
1457 if (vala_struct_is_floating_type (_tmp125_)) {
1458 ValaStruct* _tmp126_;
1459 _tmp126_ = expect_struct;
1460 _tmp124_ = vala_struct_is_floating_type (_tmp126_);
1461 } else {
1462 _tmp124_ = FALSE;
1463 }
1464 _tmp120_ = _tmp124_;
1465 }
1466 if (_tmp120_) {
1467 ValaStruct* _tmp127_;
1468 gint _tmp128_;
1469 gint _tmp129_;
1470 ValaStruct* _tmp130_;
1471 gint _tmp131_;
1472 gint _tmp132_;
1473 _tmp127_ = expr_struct;
1474 _tmp128_ = vala_struct_get_rank (_tmp127_);
1475 _tmp129_ = _tmp128_;
1476 _tmp130_ = expect_struct;
1477 _tmp131_ = vala_struct_get_rank (_tmp130_);
1478 _tmp132_ = _tmp131_;
1479 if (_tmp129_ <= _tmp132_) {
1480 result = TRUE;
1481 _vala_iterable_unref0 (target_type_args);
1482 _vala_iterable_unref0 (type_args);
1483 _vala_code_context_unref0 (context);
1484 return result;
1485 }
1486 }
1487 _tmp134_ = expr_struct;
1488 if (vala_struct_is_boolean_type (_tmp134_)) {
1489 ValaStruct* _tmp135_;
1490 _tmp135_ = expect_struct;
1491 _tmp133_ = vala_struct_is_boolean_type (_tmp135_);
1492 } else {
1493 _tmp133_ = FALSE;
1494 }
1495 if (_tmp133_) {
1496 result = TRUE;
1497 _vala_iterable_unref0 (target_type_args);
1498 _vala_iterable_unref0 (type_args);
1499 _vala_code_context_unref0 (context);
1500 return result;
1501 }
1502 _tmp136_ = expect_struct;
1503 _tmp137_ = expr_struct;
1504 if (vala_typesymbol_is_subtype_of ((ValaTypeSymbol*) _tmp136_, (ValaTypeSymbol*) _tmp137_)) {
1505 result = TRUE;
1506 _vala_iterable_unref0 (target_type_args);
1507 _vala_iterable_unref0 (type_args);
1508 _vala_code_context_unref0 (context);
1509 return result;
1510 }
1511 }
1512 result = FALSE;
1513 _vala_iterable_unref0 (target_type_args);
1514 _vala_iterable_unref0 (type_args);
1515 _vala_code_context_unref0 (context);
1516 return result;
1517 }
1518
1519 gboolean
vala_data_type_compatible(ValaDataType * self,ValaDataType * target_type)1520 vala_data_type_compatible (ValaDataType* self,
1521 ValaDataType* target_type)
1522 {
1523 g_return_val_if_fail (self != NULL, FALSE);
1524 return VALA_DATA_TYPE_GET_CLASS (self)->compatible (self, target_type);
1525 }
1526
1527 /**
1528 * Returns whether instances of this type are invokable.
1529 *
1530 * @return true if invokable, false otherwise
1531 */
1532 static gboolean
vala_data_type_real_is_invokable(ValaDataType * self)1533 vala_data_type_real_is_invokable (ValaDataType* self)
1534 {
1535 gboolean result = FALSE;
1536 result = FALSE;
1537 return result;
1538 }
1539
1540 gboolean
vala_data_type_is_invokable(ValaDataType * self)1541 vala_data_type_is_invokable (ValaDataType* self)
1542 {
1543 g_return_val_if_fail (self != NULL, FALSE);
1544 return VALA_DATA_TYPE_GET_CLASS (self)->is_invokable (self);
1545 }
1546
1547 /**
1548 * Returns the return type of this invokable.
1549 *
1550 * @return return type
1551 */
1552 static ValaDataType*
vala_data_type_real_get_return_type(ValaDataType * self)1553 vala_data_type_real_get_return_type (ValaDataType* self)
1554 {
1555 ValaDataType* result = NULL;
1556 result = NULL;
1557 return result;
1558 }
1559
1560 ValaDataType*
vala_data_type_get_return_type(ValaDataType * self)1561 vala_data_type_get_return_type (ValaDataType* self)
1562 {
1563 g_return_val_if_fail (self != NULL, NULL);
1564 return VALA_DATA_TYPE_GET_CLASS (self)->get_return_type (self);
1565 }
1566
1567 /**
1568 * Returns the list of invocation parameters.
1569 *
1570 * @return parameter list
1571 */
1572 static ValaList*
vala_data_type_real_get_parameters(ValaDataType * self)1573 vala_data_type_real_get_parameters (ValaDataType* self)
1574 {
1575 ValaList* result = NULL;
1576 result = NULL;
1577 return result;
1578 }
1579
1580 ValaList*
vala_data_type_get_parameters(ValaDataType * self)1581 vala_data_type_get_parameters (ValaDataType* self)
1582 {
1583 g_return_val_if_fail (self != NULL, NULL);
1584 return VALA_DATA_TYPE_GET_CLASS (self)->get_parameters (self);
1585 }
1586
1587 static gboolean
vala_data_type_real_is_reference_type_or_type_parameter(ValaDataType * self)1588 vala_data_type_real_is_reference_type_or_type_parameter (ValaDataType* self)
1589 {
1590 gboolean _tmp0_ = FALSE;
1591 gboolean _tmp1_ = FALSE;
1592 ValaTypeSymbol* _tmp2_;
1593 ValaTypeSymbol* _tmp3_;
1594 gboolean result = FALSE;
1595 _tmp2_ = vala_data_type_get_type_symbol (self);
1596 _tmp3_ = _tmp2_;
1597 if (_tmp3_ != NULL) {
1598 ValaTypeSymbol* _tmp4_;
1599 ValaTypeSymbol* _tmp5_;
1600 _tmp4_ = vala_data_type_get_type_symbol (self);
1601 _tmp5_ = _tmp4_;
1602 _tmp1_ = vala_typesymbol_is_reference_type (_tmp5_);
1603 } else {
1604 _tmp1_ = FALSE;
1605 }
1606 if (_tmp1_) {
1607 _tmp0_ = TRUE;
1608 } else {
1609 _tmp0_ = VALA_IS_GENERIC_TYPE (self);
1610 }
1611 result = _tmp0_;
1612 return result;
1613 }
1614
1615 gboolean
vala_data_type_is_reference_type_or_type_parameter(ValaDataType * self)1616 vala_data_type_is_reference_type_or_type_parameter (ValaDataType* self)
1617 {
1618 g_return_val_if_fail (self != NULL, FALSE);
1619 return VALA_DATA_TYPE_GET_CLASS (self)->is_reference_type_or_type_parameter (self);
1620 }
1621
1622 static gboolean
vala_data_type_real_is_accessible(ValaDataType * self,ValaSymbol * sym)1623 vala_data_type_real_is_accessible (ValaDataType* self,
1624 ValaSymbol* sym)
1625 {
1626 ValaTypeSymbol* _tmp10_;
1627 ValaTypeSymbol* _tmp11_;
1628 gboolean result = FALSE;
1629 g_return_val_if_fail (sym != NULL, FALSE);
1630 {
1631 ValaList* _type_arg_list = NULL;
1632 ValaList* _tmp0_;
1633 ValaList* _tmp1_;
1634 gint _type_arg_size = 0;
1635 ValaList* _tmp2_;
1636 gint _tmp3_;
1637 gint _tmp4_;
1638 gint _type_arg_index = 0;
1639 _tmp0_ = vala_data_type_get_type_arguments (self);
1640 _tmp1_ = _vala_iterable_ref0 (_tmp0_);
1641 _type_arg_list = _tmp1_;
1642 _tmp2_ = _type_arg_list;
1643 _tmp3_ = vala_collection_get_size ((ValaCollection*) _tmp2_);
1644 _tmp4_ = _tmp3_;
1645 _type_arg_size = _tmp4_;
1646 _type_arg_index = -1;
1647 while (TRUE) {
1648 gint _tmp5_;
1649 gint _tmp6_;
1650 ValaDataType* type_arg = NULL;
1651 ValaList* _tmp7_;
1652 gpointer _tmp8_;
1653 ValaDataType* _tmp9_;
1654 _type_arg_index = _type_arg_index + 1;
1655 _tmp5_ = _type_arg_index;
1656 _tmp6_ = _type_arg_size;
1657 if (!(_tmp5_ < _tmp6_)) {
1658 break;
1659 }
1660 _tmp7_ = _type_arg_list;
1661 _tmp8_ = vala_list_get (_tmp7_, _type_arg_index);
1662 type_arg = (ValaDataType*) _tmp8_;
1663 _tmp9_ = type_arg;
1664 if (!vala_data_type_is_accessible (_tmp9_, sym)) {
1665 result = FALSE;
1666 _vala_code_node_unref0 (type_arg);
1667 _vala_iterable_unref0 (_type_arg_list);
1668 return result;
1669 }
1670 _vala_code_node_unref0 (type_arg);
1671 }
1672 _vala_iterable_unref0 (_type_arg_list);
1673 }
1674 _tmp10_ = vala_data_type_get_type_symbol (self);
1675 _tmp11_ = _tmp10_;
1676 if (_tmp11_ != NULL) {
1677 ValaTypeSymbol* _tmp12_;
1678 ValaTypeSymbol* _tmp13_;
1679 _tmp12_ = vala_data_type_get_type_symbol (self);
1680 _tmp13_ = _tmp12_;
1681 result = vala_symbol_is_accessible ((ValaSymbol*) _tmp13_, sym);
1682 return result;
1683 }
1684 result = TRUE;
1685 return result;
1686 }
1687
1688 gboolean
vala_data_type_is_accessible(ValaDataType * self,ValaSymbol * sym)1689 vala_data_type_is_accessible (ValaDataType* self,
1690 ValaSymbol* sym)
1691 {
1692 g_return_val_if_fail (self != NULL, FALSE);
1693 return VALA_DATA_TYPE_GET_CLASS (self)->is_accessible (self, sym);
1694 }
1695
1696 static ValaSymbol*
vala_data_type_real_get_member(ValaDataType * self,const gchar * member_name)1697 vala_data_type_real_get_member (ValaDataType* self,
1698 const gchar* member_name)
1699 {
1700 ValaTypeSymbol* _tmp0_;
1701 ValaTypeSymbol* _tmp1_;
1702 ValaSymbol* result = NULL;
1703 g_return_val_if_fail (member_name != NULL, NULL);
1704 _tmp0_ = vala_data_type_get_type_symbol (self);
1705 _tmp1_ = _tmp0_;
1706 if (_tmp1_ != NULL) {
1707 ValaTypeSymbol* _tmp2_;
1708 ValaTypeSymbol* _tmp3_;
1709 ValaSymbol* _tmp4_;
1710 _tmp2_ = vala_data_type_get_type_symbol (self);
1711 _tmp3_ = _tmp2_;
1712 _tmp4_ = vala_semantic_analyzer_symbol_lookup_inherited ((ValaSymbol*) _tmp3_, member_name);
1713 result = _tmp4_;
1714 return result;
1715 }
1716 result = NULL;
1717 return result;
1718 }
1719
1720 ValaSymbol*
vala_data_type_get_member(ValaDataType * self,const gchar * member_name)1721 vala_data_type_get_member (ValaDataType* self,
1722 const gchar* member_name)
1723 {
1724 g_return_val_if_fail (self != NULL, NULL);
1725 return VALA_DATA_TYPE_GET_CLASS (self)->get_member (self, member_name);
1726 }
1727
1728 static ValaSymbol*
vala_data_type_real_get_pointer_member(ValaDataType * self,const gchar * member_name)1729 vala_data_type_real_get_pointer_member (ValaDataType* self,
1730 const gchar* member_name)
1731 {
1732 ValaSymbol* result = NULL;
1733 g_return_val_if_fail (member_name != NULL, NULL);
1734 result = NULL;
1735 return result;
1736 }
1737
1738 ValaSymbol*
vala_data_type_get_pointer_member(ValaDataType * self,const gchar * member_name)1739 vala_data_type_get_pointer_member (ValaDataType* self,
1740 const gchar* member_name)
1741 {
1742 g_return_val_if_fail (self != NULL, NULL);
1743 return VALA_DATA_TYPE_GET_CLASS (self)->get_pointer_member (self, member_name);
1744 }
1745
1746 /**
1747 * Checks whether this data type references a real struct. A real struct
1748 * is a struct which is not a simple (fundamental) type.
1749 */
1750 static gboolean
vala_data_type_real_is_real_struct_type(ValaDataType * self)1751 vala_data_type_real_is_real_struct_type (ValaDataType* self)
1752 {
1753 ValaStruct* s = NULL;
1754 ValaTypeSymbol* _tmp0_;
1755 ValaTypeSymbol* _tmp1_;
1756 gboolean _tmp2_ = FALSE;
1757 ValaStruct* _tmp3_;
1758 gboolean result = FALSE;
1759 _tmp0_ = vala_data_type_get_type_symbol (self);
1760 _tmp1_ = _tmp0_;
1761 s = VALA_IS_STRUCT (_tmp1_) ? ((ValaStruct*) _tmp1_) : NULL;
1762 _tmp3_ = s;
1763 if (_tmp3_ != NULL) {
1764 ValaStruct* _tmp4_;
1765 _tmp4_ = s;
1766 _tmp2_ = !vala_struct_is_simple_type (_tmp4_);
1767 } else {
1768 _tmp2_ = FALSE;
1769 }
1770 if (_tmp2_) {
1771 result = TRUE;
1772 return result;
1773 }
1774 result = FALSE;
1775 return result;
1776 }
1777
1778 gboolean
vala_data_type_is_real_struct_type(ValaDataType * self)1779 vala_data_type_is_real_struct_type (ValaDataType* self)
1780 {
1781 g_return_val_if_fail (self != NULL, FALSE);
1782 return VALA_DATA_TYPE_GET_CLASS (self)->is_real_struct_type (self);
1783 }
1784
1785 gboolean
vala_data_type_is_real_non_null_struct_type(ValaDataType * self)1786 vala_data_type_is_real_non_null_struct_type (ValaDataType* self)
1787 {
1788 gboolean _tmp0_ = FALSE;
1789 gboolean result = FALSE;
1790 g_return_val_if_fail (self != NULL, FALSE);
1791 if (vala_data_type_is_real_struct_type (self)) {
1792 gboolean _tmp1_;
1793 _tmp1_ = self->priv->_nullable;
1794 _tmp0_ = !_tmp1_;
1795 } else {
1796 _tmp0_ = FALSE;
1797 }
1798 result = _tmp0_;
1799 return result;
1800 }
1801
1802 gboolean
vala_data_type_is_non_null_simple_type(ValaDataType * self)1803 vala_data_type_is_non_null_simple_type (ValaDataType* self)
1804 {
1805 ValaStruct* s = NULL;
1806 ValaTypeSymbol* _tmp0_;
1807 ValaTypeSymbol* _tmp1_;
1808 gboolean _tmp2_ = FALSE;
1809 ValaStruct* _tmp3_;
1810 gboolean result = FALSE;
1811 g_return_val_if_fail (self != NULL, FALSE);
1812 _tmp0_ = vala_data_type_get_type_symbol (self);
1813 _tmp1_ = _tmp0_;
1814 s = VALA_IS_STRUCT (_tmp1_) ? ((ValaStruct*) _tmp1_) : NULL;
1815 _tmp3_ = s;
1816 if (_tmp3_ != NULL) {
1817 ValaStruct* _tmp4_;
1818 _tmp4_ = s;
1819 _tmp2_ = vala_struct_is_simple_type (_tmp4_);
1820 } else {
1821 _tmp2_ = FALSE;
1822 }
1823 if (_tmp2_) {
1824 gboolean _tmp5_;
1825 _tmp5_ = self->priv->_nullable;
1826 result = !_tmp5_;
1827 return result;
1828 }
1829 result = FALSE;
1830 return result;
1831 }
1832
1833 /**
1834 * Returns whether the value needs to be disposed, i.e. whether
1835 * allocated memory or other resources need to be released when
1836 * the value is no longer needed.
1837 */
1838 static gboolean
vala_data_type_real_is_disposable(ValaDataType * self)1839 vala_data_type_real_is_disposable (ValaDataType* self)
1840 {
1841 gboolean _tmp0_;
1842 gboolean result = FALSE;
1843 _tmp0_ = self->priv->_value_owned;
1844 if (!_tmp0_) {
1845 result = FALSE;
1846 return result;
1847 }
1848 if (vala_data_type_is_reference_type_or_type_parameter (self)) {
1849 result = TRUE;
1850 return result;
1851 }
1852 result = FALSE;
1853 return result;
1854 }
1855
1856 gboolean
vala_data_type_is_disposable(ValaDataType * self)1857 vala_data_type_is_disposable (ValaDataType* self)
1858 {
1859 g_return_val_if_fail (self != NULL, FALSE);
1860 return VALA_DATA_TYPE_GET_CLASS (self)->is_disposable (self);
1861 }
1862
1863 static ValaDataType*
vala_data_type_real_get_actual_type(ValaDataType * self,ValaDataType * derived_instance_type,ValaList * method_type_arguments,ValaCodeNode * node_reference)1864 vala_data_type_real_get_actual_type (ValaDataType* self,
1865 ValaDataType* derived_instance_type,
1866 ValaList* method_type_arguments,
1867 ValaCodeNode* node_reference)
1868 {
1869 ValaDataType* _result_ = NULL;
1870 ValaDataType* _tmp0_;
1871 gboolean _tmp1_ = FALSE;
1872 ValaDataType* _tmp2_;
1873 ValaList* _tmp3_;
1874 ValaDataType* result = NULL;
1875 _tmp0_ = vala_data_type_copy (self);
1876 _result_ = _tmp0_;
1877 if (derived_instance_type == NULL) {
1878 _tmp1_ = method_type_arguments == NULL;
1879 } else {
1880 _tmp1_ = FALSE;
1881 }
1882 if (_tmp1_) {
1883 result = _result_;
1884 return result;
1885 }
1886 _tmp2_ = _result_;
1887 _tmp3_ = _tmp2_->priv->type_argument_list;
1888 if (_tmp3_ != NULL) {
1889 {
1890 gint i = 0;
1891 i = 0;
1892 {
1893 gboolean _tmp4_ = FALSE;
1894 _tmp4_ = TRUE;
1895 while (TRUE) {
1896 ValaDataType* _tmp6_;
1897 ValaList* _tmp7_;
1898 gint _tmp8_;
1899 gint _tmp9_;
1900 ValaDataType* _tmp10_;
1901 ValaList* _tmp11_;
1902 ValaDataType* _tmp12_;
1903 ValaList* _tmp13_;
1904 gpointer _tmp14_;
1905 ValaDataType* _tmp15_;
1906 ValaDataType* _tmp16_;
1907 ValaDataType* _tmp17_;
1908 if (!_tmp4_) {
1909 gint _tmp5_;
1910 _tmp5_ = i;
1911 i = _tmp5_ + 1;
1912 }
1913 _tmp4_ = FALSE;
1914 _tmp6_ = _result_;
1915 _tmp7_ = _tmp6_->priv->type_argument_list;
1916 _tmp8_ = vala_collection_get_size ((ValaCollection*) _tmp7_);
1917 _tmp9_ = _tmp8_;
1918 if (!(i < _tmp9_)) {
1919 break;
1920 }
1921 _tmp10_ = _result_;
1922 _tmp11_ = _tmp10_->priv->type_argument_list;
1923 _tmp12_ = _result_;
1924 _tmp13_ = _tmp12_->priv->type_argument_list;
1925 _tmp14_ = vala_list_get (_tmp13_, i);
1926 _tmp15_ = (ValaDataType*) _tmp14_;
1927 _tmp16_ = vala_data_type_get_actual_type (_tmp15_, derived_instance_type, method_type_arguments, node_reference);
1928 _tmp17_ = _tmp16_;
1929 vala_list_set (_tmp11_, i, _tmp17_);
1930 _vala_code_node_unref0 (_tmp17_);
1931 _vala_code_node_unref0 (_tmp15_);
1932 }
1933 }
1934 }
1935 }
1936 result = _result_;
1937 return result;
1938 }
1939
1940 ValaDataType*
vala_data_type_get_actual_type(ValaDataType * self,ValaDataType * derived_instance_type,ValaList * method_type_arguments,ValaCodeNode * node_reference)1941 vala_data_type_get_actual_type (ValaDataType* self,
1942 ValaDataType* derived_instance_type,
1943 ValaList* method_type_arguments,
1944 ValaCodeNode* node_reference)
1945 {
1946 g_return_val_if_fail (self != NULL, NULL);
1947 return VALA_DATA_TYPE_GET_CLASS (self)->get_actual_type (self, derived_instance_type, method_type_arguments, node_reference);
1948 }
1949
1950 gboolean
vala_data_type_is_generic(ValaDataType * self)1951 vala_data_type_is_generic (ValaDataType* self)
1952 {
1953 gboolean result = FALSE;
1954 g_return_val_if_fail (self != NULL, FALSE);
1955 if (VALA_IS_GENERIC_TYPE (self)) {
1956 result = TRUE;
1957 return result;
1958 }
1959 if (!vala_data_type_has_type_arguments (self)) {
1960 result = FALSE;
1961 return result;
1962 }
1963 {
1964 ValaList* _type_arg_list = NULL;
1965 ValaList* _tmp0_;
1966 ValaList* _tmp1_;
1967 gint _type_arg_size = 0;
1968 ValaList* _tmp2_;
1969 gint _tmp3_;
1970 gint _tmp4_;
1971 gint _type_arg_index = 0;
1972 _tmp0_ = self->priv->type_argument_list;
1973 _tmp1_ = _vala_iterable_ref0 (_tmp0_);
1974 _type_arg_list = _tmp1_;
1975 _tmp2_ = _type_arg_list;
1976 _tmp3_ = vala_collection_get_size ((ValaCollection*) _tmp2_);
1977 _tmp4_ = _tmp3_;
1978 _type_arg_size = _tmp4_;
1979 _type_arg_index = -1;
1980 while (TRUE) {
1981 gint _tmp5_;
1982 gint _tmp6_;
1983 ValaDataType* type_arg = NULL;
1984 ValaList* _tmp7_;
1985 gpointer _tmp8_;
1986 ValaDataType* _tmp9_;
1987 _type_arg_index = _type_arg_index + 1;
1988 _tmp5_ = _type_arg_index;
1989 _tmp6_ = _type_arg_size;
1990 if (!(_tmp5_ < _tmp6_)) {
1991 break;
1992 }
1993 _tmp7_ = _type_arg_list;
1994 _tmp8_ = vala_list_get (_tmp7_, _type_arg_index);
1995 type_arg = (ValaDataType*) _tmp8_;
1996 _tmp9_ = type_arg;
1997 if (vala_data_type_is_generic (_tmp9_)) {
1998 result = TRUE;
1999 _vala_code_node_unref0 (type_arg);
2000 _vala_iterable_unref0 (_type_arg_list);
2001 return result;
2002 }
2003 _vala_code_node_unref0 (type_arg);
2004 }
2005 _vala_iterable_unref0 (_type_arg_list);
2006 }
2007 result = FALSE;
2008 return result;
2009 }
2010
2011 void
vala_data_type_replace_type_parameter(ValaDataType * self,ValaTypeParameter * old_type_param,ValaTypeParameter * new_type_param)2012 vala_data_type_replace_type_parameter (ValaDataType* self,
2013 ValaTypeParameter* old_type_param,
2014 ValaTypeParameter* new_type_param)
2015 {
2016 g_return_if_fail (self != NULL);
2017 g_return_if_fail (old_type_param != NULL);
2018 g_return_if_fail (new_type_param != NULL);
2019 if (VALA_IS_GENERIC_TYPE (self)) {
2020 ValaGenericType* generic_type = NULL;
2021 ValaGenericType* _tmp0_;
2022 ValaTypeParameter* _tmp1_;
2023 ValaTypeParameter* _tmp2_;
2024 generic_type = G_TYPE_CHECK_INSTANCE_CAST (self, VALA_TYPE_GENERIC_TYPE, ValaGenericType);
2025 _tmp0_ = generic_type;
2026 _tmp1_ = vala_generic_type_get_type_parameter (_tmp0_);
2027 _tmp2_ = _tmp1_;
2028 if (_tmp2_ == old_type_param) {
2029 ValaGenericType* _tmp3_;
2030 _tmp3_ = generic_type;
2031 vala_generic_type_set_type_parameter (_tmp3_, new_type_param);
2032 }
2033 return;
2034 }
2035 if (!vala_data_type_has_type_arguments (self)) {
2036 return;
2037 }
2038 {
2039 ValaList* _type_arg_list = NULL;
2040 ValaList* _tmp4_;
2041 ValaList* _tmp5_;
2042 gint _type_arg_size = 0;
2043 ValaList* _tmp6_;
2044 gint _tmp7_;
2045 gint _tmp8_;
2046 gint _type_arg_index = 0;
2047 _tmp4_ = self->priv->type_argument_list;
2048 _tmp5_ = _vala_iterable_ref0 (_tmp4_);
2049 _type_arg_list = _tmp5_;
2050 _tmp6_ = _type_arg_list;
2051 _tmp7_ = vala_collection_get_size ((ValaCollection*) _tmp6_);
2052 _tmp8_ = _tmp7_;
2053 _type_arg_size = _tmp8_;
2054 _type_arg_index = -1;
2055 while (TRUE) {
2056 gint _tmp9_;
2057 gint _tmp10_;
2058 ValaDataType* type_arg = NULL;
2059 ValaList* _tmp11_;
2060 gpointer _tmp12_;
2061 ValaDataType* _tmp13_;
2062 _type_arg_index = _type_arg_index + 1;
2063 _tmp9_ = _type_arg_index;
2064 _tmp10_ = _type_arg_size;
2065 if (!(_tmp9_ < _tmp10_)) {
2066 break;
2067 }
2068 _tmp11_ = _type_arg_list;
2069 _tmp12_ = vala_list_get (_tmp11_, _type_arg_index);
2070 type_arg = (ValaDataType*) _tmp12_;
2071 _tmp13_ = type_arg;
2072 vala_data_type_replace_type_parameter (_tmp13_, old_type_param, new_type_param);
2073 _vala_code_node_unref0 (type_arg);
2074 }
2075 _vala_iterable_unref0 (_type_arg_list);
2076 }
2077 }
2078
2079 /**
2080 * Search for the type parameter in this formal type and match it in
2081 * value_type.
2082 */
2083 static ValaDataType*
vala_data_type_real_infer_type_argument(ValaDataType * self,ValaTypeParameter * type_param,ValaDataType * value_type)2084 vala_data_type_real_infer_type_argument (ValaDataType* self,
2085 ValaTypeParameter* type_param,
2086 ValaDataType* value_type)
2087 {
2088 ValaIterator* value_type_arg_it = NULL;
2089 ValaList* _tmp0_;
2090 ValaIterator* _tmp1_;
2091 ValaDataType* result = NULL;
2092 g_return_val_if_fail (type_param != NULL, NULL);
2093 g_return_val_if_fail (value_type != NULL, NULL);
2094 _tmp0_ = vala_data_type_get_type_arguments (value_type);
2095 _tmp1_ = vala_iterable_iterator ((ValaIterable*) _tmp0_);
2096 value_type_arg_it = _tmp1_;
2097 {
2098 ValaList* _formal_type_arg_list = NULL;
2099 ValaList* _tmp2_;
2100 ValaList* _tmp3_;
2101 gint _formal_type_arg_size = 0;
2102 ValaList* _tmp4_;
2103 gint _tmp5_;
2104 gint _tmp6_;
2105 gint _formal_type_arg_index = 0;
2106 _tmp2_ = vala_data_type_get_type_arguments (self);
2107 _tmp3_ = _vala_iterable_ref0 (_tmp2_);
2108 _formal_type_arg_list = _tmp3_;
2109 _tmp4_ = _formal_type_arg_list;
2110 _tmp5_ = vala_collection_get_size ((ValaCollection*) _tmp4_);
2111 _tmp6_ = _tmp5_;
2112 _formal_type_arg_size = _tmp6_;
2113 _formal_type_arg_index = -1;
2114 while (TRUE) {
2115 gint _tmp7_;
2116 gint _tmp8_;
2117 ValaDataType* formal_type_arg = NULL;
2118 ValaList* _tmp9_;
2119 gpointer _tmp10_;
2120 ValaIterator* _tmp11_;
2121 _formal_type_arg_index = _formal_type_arg_index + 1;
2122 _tmp7_ = _formal_type_arg_index;
2123 _tmp8_ = _formal_type_arg_size;
2124 if (!(_tmp7_ < _tmp8_)) {
2125 break;
2126 }
2127 _tmp9_ = _formal_type_arg_list;
2128 _tmp10_ = vala_list_get (_tmp9_, _formal_type_arg_index);
2129 formal_type_arg = (ValaDataType*) _tmp10_;
2130 _tmp11_ = value_type_arg_it;
2131 if (vala_iterator_next (_tmp11_)) {
2132 ValaDataType* inferred_type = NULL;
2133 ValaDataType* _tmp12_;
2134 ValaIterator* _tmp13_;
2135 gpointer _tmp14_;
2136 ValaDataType* _tmp15_;
2137 ValaDataType* _tmp16_;
2138 ValaDataType* _tmp17_;
2139 ValaDataType* _tmp18_;
2140 _tmp12_ = formal_type_arg;
2141 _tmp13_ = value_type_arg_it;
2142 _tmp14_ = vala_iterator_get (_tmp13_);
2143 _tmp15_ = (ValaDataType*) _tmp14_;
2144 _tmp16_ = vala_data_type_infer_type_argument (_tmp12_, type_param, _tmp15_);
2145 _tmp17_ = _tmp16_;
2146 _vala_code_node_unref0 (_tmp15_);
2147 inferred_type = _tmp17_;
2148 _tmp18_ = inferred_type;
2149 if (_tmp18_ != NULL) {
2150 result = inferred_type;
2151 _vala_code_node_unref0 (formal_type_arg);
2152 _vala_iterable_unref0 (_formal_type_arg_list);
2153 _vala_iterator_unref0 (value_type_arg_it);
2154 return result;
2155 }
2156 _vala_code_node_unref0 (inferred_type);
2157 }
2158 _vala_code_node_unref0 (formal_type_arg);
2159 }
2160 _vala_iterable_unref0 (_formal_type_arg_list);
2161 }
2162 result = NULL;
2163 _vala_iterator_unref0 (value_type_arg_it);
2164 return result;
2165 }
2166
2167 ValaDataType*
vala_data_type_infer_type_argument(ValaDataType * self,ValaTypeParameter * type_param,ValaDataType * value_type)2168 vala_data_type_infer_type_argument (ValaDataType* self,
2169 ValaTypeParameter* type_param,
2170 ValaDataType* value_type)
2171 {
2172 g_return_val_if_fail (self != NULL, NULL);
2173 return VALA_DATA_TYPE_GET_CLASS (self)->infer_type_argument (self, type_param, value_type);
2174 }
2175
2176 /**
2177 * Returns a stringified representation used for detailed error output
2178 *
2179 * @param override_name used as name if given
2180 * @return stringified representation
2181 */
2182 static gchar*
vala_data_type_real_to_prototype_string(ValaDataType * self,const gchar * override_name)2183 vala_data_type_real_to_prototype_string (ValaDataType* self,
2184 const gchar* override_name)
2185 {
2186 const gchar* _tmp0_ = NULL;
2187 gchar* _tmp1_;
2188 gchar* _tmp2_;
2189 gchar* _tmp3_;
2190 gchar* _tmp4_;
2191 gchar* result = NULL;
2192 if (vala_data_type_is_weak (self)) {
2193 _tmp0_ = "unowned ";
2194 } else {
2195 _tmp0_ = "";
2196 }
2197 _tmp1_ = vala_data_type_to_qualified_string (self, NULL);
2198 _tmp2_ = _tmp1_;
2199 _tmp3_ = g_strdup_printf ("%s%s", _tmp0_, _tmp2_);
2200 _tmp4_ = _tmp3_;
2201 _g_free0 (_tmp2_);
2202 result = _tmp4_;
2203 return result;
2204 }
2205
2206 gchar*
vala_data_type_to_prototype_string(ValaDataType * self,const gchar * override_name)2207 vala_data_type_to_prototype_string (ValaDataType* self,
2208 const gchar* override_name)
2209 {
2210 g_return_val_if_fail (self != NULL, NULL);
2211 return VALA_DATA_TYPE_GET_CLASS (self)->to_prototype_string (self, override_name);
2212 }
2213
2214 gboolean
vala_data_type_is_weak(ValaDataType * self)2215 vala_data_type_is_weak (ValaDataType* self)
2216 {
2217 gboolean _tmp0_;
2218 gboolean result = FALSE;
2219 g_return_val_if_fail (self != NULL, FALSE);
2220 _tmp0_ = self->priv->_value_owned;
2221 if (_tmp0_) {
2222 result = FALSE;
2223 return result;
2224 } else {
2225 gboolean _tmp1_ = FALSE;
2226 if (VALA_IS_VOID_TYPE (self)) {
2227 _tmp1_ = TRUE;
2228 } else {
2229 _tmp1_ = VALA_IS_POINTER_TYPE (self);
2230 }
2231 if (_tmp1_) {
2232 result = FALSE;
2233 return result;
2234 } else {
2235 if (VALA_IS_VALUE_TYPE (self)) {
2236 gboolean _tmp2_;
2237 _tmp2_ = self->priv->_nullable;
2238 if (_tmp2_) {
2239 result = TRUE;
2240 return result;
2241 }
2242 result = FALSE;
2243 return result;
2244 }
2245 }
2246 }
2247 result = TRUE;
2248 return result;
2249 }
2250
2251 static gboolean
string_contains(const gchar * self,const gchar * needle)2252 string_contains (const gchar* self,
2253 const gchar* needle)
2254 {
2255 gchar* _tmp0_;
2256 gboolean result = FALSE;
2257 g_return_val_if_fail (self != NULL, FALSE);
2258 g_return_val_if_fail (needle != NULL, FALSE);
2259 _tmp0_ = strstr ((gchar*) self, (gchar*) needle);
2260 result = _tmp0_ != NULL;
2261 return result;
2262 }
2263
2264 static gchar*
string_replace(const gchar * self,const gchar * old,const gchar * replacement)2265 string_replace (const gchar* self,
2266 const gchar* old,
2267 const gchar* replacement)
2268 {
2269 gboolean _tmp0_ = FALSE;
2270 gboolean _tmp1_ = FALSE;
2271 GError* _inner_error0_ = NULL;
2272 gchar* result = NULL;
2273 g_return_val_if_fail (self != NULL, NULL);
2274 g_return_val_if_fail (old != NULL, NULL);
2275 g_return_val_if_fail (replacement != NULL, NULL);
2276 if ((*((gchar*) self)) == '\0') {
2277 _tmp1_ = TRUE;
2278 } else {
2279 _tmp1_ = (*((gchar*) old)) == '\0';
2280 }
2281 if (_tmp1_) {
2282 _tmp0_ = TRUE;
2283 } else {
2284 _tmp0_ = g_strcmp0 (old, replacement) == 0;
2285 }
2286 if (_tmp0_) {
2287 gchar* _tmp2_;
2288 _tmp2_ = g_strdup (self);
2289 result = _tmp2_;
2290 return result;
2291 }
2292 {
2293 GRegex* regex = NULL;
2294 gchar* _tmp3_;
2295 gchar* _tmp4_;
2296 GRegex* _tmp5_;
2297 GRegex* _tmp6_;
2298 gchar* _tmp7_ = NULL;
2299 GRegex* _tmp8_;
2300 gchar* _tmp9_;
2301 gchar* _tmp10_;
2302 _tmp3_ = g_regex_escape_string (old, -1);
2303 _tmp4_ = _tmp3_;
2304 _tmp5_ = g_regex_new (_tmp4_, 0, 0, &_inner_error0_);
2305 _tmp6_ = _tmp5_;
2306 _g_free0 (_tmp4_);
2307 regex = _tmp6_;
2308 if (G_UNLIKELY (_inner_error0_ != NULL)) {
2309 if (_inner_error0_->domain == G_REGEX_ERROR) {
2310 goto __catch0_g_regex_error;
2311 }
2312 g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error0_->message, g_quark_to_string (_inner_error0_->domain), _inner_error0_->code);
2313 g_clear_error (&_inner_error0_);
2314 return NULL;
2315 }
2316 _tmp8_ = regex;
2317 _tmp9_ = g_regex_replace_literal (_tmp8_, self, (gssize) -1, 0, replacement, 0, &_inner_error0_);
2318 _tmp7_ = _tmp9_;
2319 if (G_UNLIKELY (_inner_error0_ != NULL)) {
2320 _g_regex_unref0 (regex);
2321 if (_inner_error0_->domain == G_REGEX_ERROR) {
2322 goto __catch0_g_regex_error;
2323 }
2324 g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error0_->message, g_quark_to_string (_inner_error0_->domain), _inner_error0_->code);
2325 g_clear_error (&_inner_error0_);
2326 return NULL;
2327 }
2328 _tmp10_ = _tmp7_;
2329 _tmp7_ = NULL;
2330 result = _tmp10_;
2331 _g_free0 (_tmp7_);
2332 _g_regex_unref0 (regex);
2333 return result;
2334 }
2335 goto __finally0;
2336 __catch0_g_regex_error:
2337 {
2338 g_clear_error (&_inner_error0_);
2339 g_assert_not_reached ();
2340 }
2341 __finally0:
2342 g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error0_->message, g_quark_to_string (_inner_error0_->domain), _inner_error0_->code);
2343 g_clear_error (&_inner_error0_);
2344 return NULL;
2345 }
2346
2347 gchar*
vala_data_type_get_type_signature(ValaDataType * self,ValaSymbol * symbol)2348 vala_data_type_get_type_signature (ValaDataType* self,
2349 ValaSymbol* symbol)
2350 {
2351 ValaArrayType* array_type = NULL;
2352 ValaArrayType* _tmp2_;
2353 gchar* result = NULL;
2354 g_return_val_if_fail (self != NULL, NULL);
2355 if (symbol != NULL) {
2356 gchar* sig = NULL;
2357 gchar* _tmp0_;
2358 const gchar* _tmp1_;
2359 _tmp0_ = vala_code_node_get_attribute_string ((ValaCodeNode*) symbol, "DBus", "signature", NULL);
2360 sig = _tmp0_;
2361 _tmp1_ = sig;
2362 if (_tmp1_ != NULL) {
2363 result = sig;
2364 return result;
2365 }
2366 _g_free0 (sig);
2367 }
2368 array_type = VALA_IS_ARRAY_TYPE (self) ? ((ValaArrayType*) self) : NULL;
2369 _tmp2_ = array_type;
2370 if (_tmp2_ != NULL) {
2371 gchar* element_type_signature = NULL;
2372 ValaArrayType* _tmp3_;
2373 ValaDataType* _tmp4_;
2374 ValaDataType* _tmp5_;
2375 gchar* _tmp6_;
2376 const gchar* _tmp7_;
2377 ValaArrayType* _tmp8_;
2378 gint _tmp9_;
2379 gint _tmp10_;
2380 gchar* _tmp11_;
2381 gchar* _tmp12_;
2382 const gchar* _tmp13_;
2383 gchar* _tmp14_;
2384 gchar* _tmp15_;
2385 _tmp3_ = array_type;
2386 _tmp4_ = vala_array_type_get_element_type (_tmp3_);
2387 _tmp5_ = _tmp4_;
2388 _tmp6_ = vala_data_type_get_type_signature (_tmp5_, NULL);
2389 element_type_signature = _tmp6_;
2390 _tmp7_ = element_type_signature;
2391 if (_tmp7_ == NULL) {
2392 result = NULL;
2393 _g_free0 (element_type_signature);
2394 return result;
2395 }
2396 _tmp8_ = array_type;
2397 _tmp9_ = vala_array_type_get_rank (_tmp8_);
2398 _tmp10_ = _tmp9_;
2399 _tmp11_ = g_strnfill ((gsize) _tmp10_, 'a');
2400 _tmp12_ = _tmp11_;
2401 _tmp13_ = element_type_signature;
2402 _tmp14_ = g_strconcat (_tmp12_, _tmp13_, NULL);
2403 _tmp15_ = _tmp14_;
2404 _g_free0 (_tmp12_);
2405 result = _tmp15_;
2406 _g_free0 (element_type_signature);
2407 return result;
2408 } else {
2409 gboolean _tmp16_ = FALSE;
2410 ValaTypeSymbol* _tmp17_;
2411 ValaTypeSymbol* _tmp18_;
2412 _tmp17_ = vala_data_type_get_type_symbol (self);
2413 _tmp18_ = _tmp17_;
2414 if (VALA_IS_ENUM (_tmp18_)) {
2415 ValaTypeSymbol* _tmp19_;
2416 ValaTypeSymbol* _tmp20_;
2417 _tmp19_ = vala_data_type_get_type_symbol (self);
2418 _tmp20_ = _tmp19_;
2419 _tmp16_ = vala_code_node_get_attribute_bool ((ValaCodeNode*) _tmp20_, "DBus", "use_string_marshalling", FALSE);
2420 } else {
2421 _tmp16_ = FALSE;
2422 }
2423 if (_tmp16_) {
2424 gchar* _tmp21_;
2425 _tmp21_ = g_strdup ("s");
2426 result = _tmp21_;
2427 return result;
2428 } else {
2429 ValaTypeSymbol* _tmp22_;
2430 ValaTypeSymbol* _tmp23_;
2431 _tmp22_ = vala_data_type_get_type_symbol (self);
2432 _tmp23_ = _tmp22_;
2433 if (_tmp23_ != NULL) {
2434 gchar* sig = NULL;
2435 ValaTypeSymbol* _tmp24_;
2436 ValaTypeSymbol* _tmp25_;
2437 gchar* _tmp26_;
2438 ValaStruct* st = NULL;
2439 ValaTypeSymbol* _tmp27_;
2440 ValaTypeSymbol* _tmp28_;
2441 ValaEnum* en = NULL;
2442 ValaTypeSymbol* _tmp29_;
2443 ValaTypeSymbol* _tmp30_;
2444 gboolean _tmp31_ = FALSE;
2445 const gchar* _tmp32_;
2446 ValaList* type_args = NULL;
2447 ValaList* _tmp69_;
2448 ValaList* _tmp70_;
2449 gboolean _tmp71_ = FALSE;
2450 gboolean _tmp72_ = FALSE;
2451 const gchar* _tmp73_;
2452 gboolean _tmp97_ = FALSE;
2453 const gchar* _tmp98_;
2454 _tmp24_ = vala_data_type_get_type_symbol (self);
2455 _tmp25_ = _tmp24_;
2456 _tmp26_ = vala_code_node_get_attribute_string ((ValaCodeNode*) _tmp25_, "CCode", "type_signature", NULL);
2457 sig = _tmp26_;
2458 _tmp27_ = vala_data_type_get_type_symbol (self);
2459 _tmp28_ = _tmp27_;
2460 st = VALA_IS_STRUCT (_tmp28_) ? ((ValaStruct*) _tmp28_) : NULL;
2461 _tmp29_ = vala_data_type_get_type_symbol (self);
2462 _tmp30_ = _tmp29_;
2463 en = VALA_IS_ENUM (_tmp30_) ? ((ValaEnum*) _tmp30_) : NULL;
2464 _tmp32_ = sig;
2465 if (_tmp32_ == NULL) {
2466 ValaStruct* _tmp33_;
2467 _tmp33_ = st;
2468 _tmp31_ = _tmp33_ != NULL;
2469 } else {
2470 _tmp31_ = FALSE;
2471 }
2472 if (_tmp31_) {
2473 GString* str = NULL;
2474 GString* _tmp34_;
2475 GString* _tmp35_;
2476 GString* _tmp57_;
2477 GString* _tmp58_;
2478 const gchar* _tmp59_;
2479 gchar* _tmp60_;
2480 _tmp34_ = g_string_new ("");
2481 str = _tmp34_;
2482 _tmp35_ = str;
2483 g_string_append_c (_tmp35_, '(');
2484 {
2485 ValaList* _f_list = NULL;
2486 ValaStruct* _tmp36_;
2487 ValaList* _tmp37_;
2488 ValaList* _tmp38_;
2489 gint _f_size = 0;
2490 ValaList* _tmp39_;
2491 gint _tmp40_;
2492 gint _tmp41_;
2493 gint _f_index = 0;
2494 _tmp36_ = st;
2495 _tmp37_ = vala_struct_get_fields (_tmp36_);
2496 _tmp38_ = _vala_iterable_ref0 (_tmp37_);
2497 _f_list = _tmp38_;
2498 _tmp39_ = _f_list;
2499 _tmp40_ = vala_collection_get_size ((ValaCollection*) _tmp39_);
2500 _tmp41_ = _tmp40_;
2501 _f_size = _tmp41_;
2502 _f_index = -1;
2503 while (TRUE) {
2504 gint _tmp42_;
2505 gint _tmp43_;
2506 ValaField* f = NULL;
2507 ValaList* _tmp44_;
2508 gpointer _tmp45_;
2509 ValaField* _tmp46_;
2510 ValaMemberBinding _tmp47_;
2511 ValaMemberBinding _tmp48_;
2512 _f_index = _f_index + 1;
2513 _tmp42_ = _f_index;
2514 _tmp43_ = _f_size;
2515 if (!(_tmp42_ < _tmp43_)) {
2516 break;
2517 }
2518 _tmp44_ = _f_list;
2519 _tmp45_ = vala_list_get (_tmp44_, _f_index);
2520 f = (ValaField*) _tmp45_;
2521 _tmp46_ = f;
2522 _tmp47_ = vala_field_get_binding (_tmp46_);
2523 _tmp48_ = _tmp47_;
2524 if (_tmp48_ == VALA_MEMBER_BINDING_INSTANCE) {
2525 gchar* s = NULL;
2526 ValaField* _tmp49_;
2527 ValaDataType* _tmp50_;
2528 ValaDataType* _tmp51_;
2529 ValaField* _tmp52_;
2530 gchar* _tmp53_;
2531 const gchar* _tmp54_;
2532 _tmp49_ = f;
2533 _tmp50_ = vala_variable_get_variable_type ((ValaVariable*) _tmp49_);
2534 _tmp51_ = _tmp50_;
2535 _tmp52_ = f;
2536 _tmp53_ = vala_data_type_get_type_signature (_tmp51_, (ValaSymbol*) _tmp52_);
2537 s = _tmp53_;
2538 _tmp54_ = s;
2539 if (_tmp54_ != NULL) {
2540 GString* _tmp55_;
2541 const gchar* _tmp56_;
2542 _tmp55_ = str;
2543 _tmp56_ = s;
2544 g_string_append (_tmp55_, _tmp56_);
2545 } else {
2546 result = NULL;
2547 _g_free0 (s);
2548 _vala_code_node_unref0 (f);
2549 _vala_iterable_unref0 (_f_list);
2550 _g_string_free0 (str);
2551 _g_free0 (sig);
2552 return result;
2553 }
2554 _g_free0 (s);
2555 }
2556 _vala_code_node_unref0 (f);
2557 }
2558 _vala_iterable_unref0 (_f_list);
2559 }
2560 _tmp57_ = str;
2561 g_string_append_c (_tmp57_, ')');
2562 _tmp58_ = str;
2563 _tmp59_ = _tmp58_->str;
2564 _tmp60_ = g_strdup (_tmp59_);
2565 _g_free0 (sig);
2566 sig = _tmp60_;
2567 _g_string_free0 (str);
2568 } else {
2569 gboolean _tmp61_ = FALSE;
2570 const gchar* _tmp62_;
2571 _tmp62_ = sig;
2572 if (_tmp62_ == NULL) {
2573 ValaEnum* _tmp63_;
2574 _tmp63_ = en;
2575 _tmp61_ = _tmp63_ != NULL;
2576 } else {
2577 _tmp61_ = FALSE;
2578 }
2579 if (_tmp61_) {
2580 ValaEnum* _tmp64_;
2581 gboolean _tmp65_;
2582 gboolean _tmp66_;
2583 _tmp64_ = en;
2584 _tmp65_ = vala_enum_get_is_flags (_tmp64_);
2585 _tmp66_ = _tmp65_;
2586 if (_tmp66_) {
2587 gchar* _tmp67_;
2588 _tmp67_ = g_strdup ("u");
2589 result = _tmp67_;
2590 _g_free0 (sig);
2591 return result;
2592 } else {
2593 gchar* _tmp68_;
2594 _tmp68_ = g_strdup ("i");
2595 result = _tmp68_;
2596 _g_free0 (sig);
2597 return result;
2598 }
2599 }
2600 }
2601 _tmp69_ = vala_data_type_get_type_arguments (self);
2602 _tmp70_ = _vala_iterable_ref0 (_tmp69_);
2603 type_args = _tmp70_;
2604 _tmp73_ = sig;
2605 if (_tmp73_ != NULL) {
2606 const gchar* _tmp74_;
2607 _tmp74_ = sig;
2608 _tmp72_ = string_contains (_tmp74_, "%s");
2609 } else {
2610 _tmp72_ = FALSE;
2611 }
2612 if (_tmp72_) {
2613 ValaList* _tmp75_;
2614 gint _tmp76_;
2615 gint _tmp77_;
2616 _tmp75_ = type_args;
2617 _tmp76_ = vala_collection_get_size ((ValaCollection*) _tmp75_);
2618 _tmp77_ = _tmp76_;
2619 _tmp71_ = _tmp77_ > 0;
2620 } else {
2621 _tmp71_ = FALSE;
2622 }
2623 if (_tmp71_) {
2624 gchar* element_sig = NULL;
2625 gchar* _tmp78_;
2626 const gchar* _tmp94_;
2627 const gchar* _tmp95_;
2628 gchar* _tmp96_;
2629 _tmp78_ = g_strdup ("");
2630 element_sig = _tmp78_;
2631 {
2632 ValaList* _type_arg_list = NULL;
2633 ValaList* _tmp79_;
2634 ValaList* _tmp80_;
2635 gint _type_arg_size = 0;
2636 ValaList* _tmp81_;
2637 gint _tmp82_;
2638 gint _tmp83_;
2639 gint _type_arg_index = 0;
2640 _tmp79_ = type_args;
2641 _tmp80_ = _vala_iterable_ref0 (_tmp79_);
2642 _type_arg_list = _tmp80_;
2643 _tmp81_ = _type_arg_list;
2644 _tmp82_ = vala_collection_get_size ((ValaCollection*) _tmp81_);
2645 _tmp83_ = _tmp82_;
2646 _type_arg_size = _tmp83_;
2647 _type_arg_index = -1;
2648 while (TRUE) {
2649 gint _tmp84_;
2650 gint _tmp85_;
2651 ValaDataType* type_arg = NULL;
2652 ValaList* _tmp86_;
2653 gpointer _tmp87_;
2654 gchar* s = NULL;
2655 ValaDataType* _tmp88_;
2656 gchar* _tmp89_;
2657 const gchar* _tmp90_;
2658 _type_arg_index = _type_arg_index + 1;
2659 _tmp84_ = _type_arg_index;
2660 _tmp85_ = _type_arg_size;
2661 if (!(_tmp84_ < _tmp85_)) {
2662 break;
2663 }
2664 _tmp86_ = _type_arg_list;
2665 _tmp87_ = vala_list_get (_tmp86_, _type_arg_index);
2666 type_arg = (ValaDataType*) _tmp87_;
2667 _tmp88_ = type_arg;
2668 _tmp89_ = vala_data_type_get_type_signature (_tmp88_, NULL);
2669 s = _tmp89_;
2670 _tmp90_ = s;
2671 if (_tmp90_ != NULL) {
2672 const gchar* _tmp91_;
2673 const gchar* _tmp92_;
2674 gchar* _tmp93_;
2675 _tmp91_ = element_sig;
2676 _tmp92_ = s;
2677 _tmp93_ = g_strconcat (_tmp91_, _tmp92_, NULL);
2678 _g_free0 (element_sig);
2679 element_sig = _tmp93_;
2680 }
2681 _g_free0 (s);
2682 _vala_code_node_unref0 (type_arg);
2683 }
2684 _vala_iterable_unref0 (_type_arg_list);
2685 }
2686 _tmp94_ = sig;
2687 _tmp95_ = element_sig;
2688 _tmp96_ = string_replace (_tmp94_, "%s", _tmp95_);
2689 _g_free0 (sig);
2690 sig = _tmp96_;
2691 _g_free0 (element_sig);
2692 }
2693 _tmp98_ = sig;
2694 if (_tmp98_ == NULL) {
2695 gboolean _tmp99_ = FALSE;
2696 gboolean _tmp100_ = FALSE;
2697 ValaTypeSymbol* _tmp101_;
2698 ValaTypeSymbol* _tmp102_;
2699 gchar* _tmp103_;
2700 gchar* _tmp104_;
2701 gboolean _tmp105_;
2702 _tmp101_ = vala_data_type_get_type_symbol (self);
2703 _tmp102_ = _tmp101_;
2704 _tmp103_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp102_);
2705 _tmp104_ = _tmp103_;
2706 _tmp105_ = g_strcmp0 (_tmp104_, "GLib.UnixInputStream") == 0;
2707 _g_free0 (_tmp104_);
2708 if (_tmp105_) {
2709 _tmp100_ = TRUE;
2710 } else {
2711 ValaTypeSymbol* _tmp106_;
2712 ValaTypeSymbol* _tmp107_;
2713 gchar* _tmp108_;
2714 gchar* _tmp109_;
2715 _tmp106_ = vala_data_type_get_type_symbol (self);
2716 _tmp107_ = _tmp106_;
2717 _tmp108_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp107_);
2718 _tmp109_ = _tmp108_;
2719 _tmp100_ = g_strcmp0 (_tmp109_, "GLib.UnixOutputStream") == 0;
2720 _g_free0 (_tmp109_);
2721 }
2722 if (_tmp100_) {
2723 _tmp99_ = TRUE;
2724 } else {
2725 ValaTypeSymbol* _tmp110_;
2726 ValaTypeSymbol* _tmp111_;
2727 gchar* _tmp112_;
2728 gchar* _tmp113_;
2729 _tmp110_ = vala_data_type_get_type_symbol (self);
2730 _tmp111_ = _tmp110_;
2731 _tmp112_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp111_);
2732 _tmp113_ = _tmp112_;
2733 _tmp99_ = g_strcmp0 (_tmp113_, "GLib.Socket") == 0;
2734 _g_free0 (_tmp113_);
2735 }
2736 _tmp97_ = _tmp99_;
2737 } else {
2738 _tmp97_ = FALSE;
2739 }
2740 if (_tmp97_) {
2741 gchar* _tmp114_;
2742 _tmp114_ = g_strdup ("h");
2743 result = _tmp114_;
2744 _vala_iterable_unref0 (type_args);
2745 _g_free0 (sig);
2746 return result;
2747 }
2748 result = sig;
2749 _vala_iterable_unref0 (type_args);
2750 return result;
2751 } else {
2752 result = NULL;
2753 return result;
2754 }
2755 }
2756 }
2757 }
2758
2759 /**
2760 * Returns whether the given amount of type-argument matches the symbol's count of type-parameters
2761 *
2762 * @param context a CodeContext
2763 * @param allow_none whether no type-argments are allowed
2764 * @return true if successful
2765 */
2766 gboolean
vala_data_type_check_type_arguments(ValaDataType * self,ValaCodeContext * context,gboolean allow_none)2767 vala_data_type_check_type_arguments (ValaDataType* self,
2768 ValaCodeContext* context,
2769 gboolean allow_none)
2770 {
2771 gint n_type_args = 0;
2772 ValaList* _tmp0_;
2773 gint _tmp1_;
2774 gint _tmp2_;
2775 gint expected_n_type_args = 0;
2776 ValaTypeSymbol* _tmp3_;
2777 ValaTypeSymbol* _tmp4_;
2778 gboolean _tmp32_ = FALSE;
2779 gboolean _tmp33_ = FALSE;
2780 gboolean result = FALSE;
2781 g_return_val_if_fail (self != NULL, FALSE);
2782 g_return_val_if_fail (context != NULL, FALSE);
2783 _tmp0_ = vala_data_type_get_type_arguments (self);
2784 _tmp1_ = vala_collection_get_size ((ValaCollection*) _tmp0_);
2785 _tmp2_ = _tmp1_;
2786 n_type_args = _tmp2_;
2787 expected_n_type_args = 0;
2788 _tmp3_ = vala_data_type_get_type_symbol (self);
2789 _tmp4_ = _tmp3_;
2790 if (VALA_IS_OBJECT_TYPE_SYMBOL (_tmp4_)) {
2791 ValaTypeSymbol* _tmp5_;
2792 ValaTypeSymbol* _tmp6_;
2793 ValaList* _tmp7_;
2794 gint _tmp8_;
2795 gint _tmp9_;
2796 _tmp5_ = vala_data_type_get_type_symbol (self);
2797 _tmp6_ = _tmp5_;
2798 _tmp7_ = vala_object_type_symbol_get_type_parameters (G_TYPE_CHECK_INSTANCE_CAST (_tmp6_, VALA_TYPE_OBJECT_TYPE_SYMBOL, ValaObjectTypeSymbol));
2799 _tmp8_ = vala_collection_get_size ((ValaCollection*) _tmp7_);
2800 _tmp9_ = _tmp8_;
2801 expected_n_type_args = _tmp9_;
2802 } else {
2803 ValaTypeSymbol* _tmp10_;
2804 ValaTypeSymbol* _tmp11_;
2805 _tmp10_ = vala_data_type_get_type_symbol (self);
2806 _tmp11_ = _tmp10_;
2807 if (VALA_IS_STRUCT (_tmp11_)) {
2808 ValaTypeSymbol* _tmp12_;
2809 ValaTypeSymbol* _tmp13_;
2810 ValaList* _tmp14_;
2811 gint _tmp15_;
2812 gint _tmp16_;
2813 _tmp12_ = vala_data_type_get_type_symbol (self);
2814 _tmp13_ = _tmp12_;
2815 _tmp14_ = vala_struct_get_type_parameters (G_TYPE_CHECK_INSTANCE_CAST (_tmp13_, VALA_TYPE_STRUCT, ValaStruct));
2816 _tmp15_ = vala_collection_get_size ((ValaCollection*) _tmp14_);
2817 _tmp16_ = _tmp15_;
2818 expected_n_type_args = _tmp16_;
2819 } else {
2820 ValaTypeSymbol* _tmp17_;
2821 ValaTypeSymbol* _tmp18_;
2822 _tmp17_ = vala_data_type_get_type_symbol (self);
2823 _tmp18_ = _tmp17_;
2824 if (VALA_IS_DELEGATE (_tmp18_)) {
2825 ValaTypeSymbol* _tmp19_;
2826 ValaTypeSymbol* _tmp20_;
2827 ValaList* _tmp21_;
2828 gint _tmp22_;
2829 gint _tmp23_;
2830 _tmp19_ = vala_data_type_get_type_symbol (self);
2831 _tmp20_ = _tmp19_;
2832 _tmp21_ = vala_delegate_get_type_parameters (G_TYPE_CHECK_INSTANCE_CAST (_tmp20_, VALA_TYPE_DELEGATE, ValaDelegate));
2833 _tmp22_ = vala_collection_get_size ((ValaCollection*) _tmp21_);
2834 _tmp23_ = _tmp22_;
2835 expected_n_type_args = _tmp23_;
2836 } else {
2837 if (n_type_args > 0) {
2838 ValaSourceReference* _tmp24_;
2839 ValaSourceReference* _tmp25_;
2840 ValaTypeSymbol* _tmp26_;
2841 ValaTypeSymbol* _tmp27_;
2842 gchar* _tmp28_;
2843 gchar* _tmp29_;
2844 gchar* _tmp30_;
2845 gchar* _tmp31_;
2846 _tmp24_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
2847 _tmp25_ = _tmp24_;
2848 _tmp26_ = vala_data_type_get_type_symbol (self);
2849 _tmp27_ = _tmp26_;
2850 _tmp28_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp27_);
2851 _tmp29_ = _tmp28_;
2852 _tmp30_ = g_strdup_printf ("`%s' does not support type arguments", _tmp29_);
2853 _tmp31_ = _tmp30_;
2854 vala_report_error (_tmp25_, _tmp31_);
2855 _g_free0 (_tmp31_);
2856 _g_free0 (_tmp29_);
2857 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
2858 result = FALSE;
2859 return result;
2860 } else {
2861 result = TRUE;
2862 return result;
2863 }
2864 }
2865 }
2866 }
2867 if (!allow_none) {
2868 _tmp33_ = TRUE;
2869 } else {
2870 _tmp33_ = n_type_args > 0;
2871 }
2872 if (_tmp33_) {
2873 _tmp32_ = n_type_args < expected_n_type_args;
2874 } else {
2875 _tmp32_ = FALSE;
2876 }
2877 if (_tmp32_) {
2878 ValaSourceReference* _tmp34_;
2879 ValaSourceReference* _tmp35_;
2880 ValaTypeSymbol* _tmp36_;
2881 ValaTypeSymbol* _tmp37_;
2882 gchar* _tmp38_;
2883 gchar* _tmp39_;
2884 gchar* _tmp40_;
2885 gchar* _tmp41_;
2886 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
2887 _tmp34_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
2888 _tmp35_ = _tmp34_;
2889 _tmp36_ = vala_data_type_get_type_symbol (self);
2890 _tmp37_ = _tmp36_;
2891 _tmp38_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp37_);
2892 _tmp39_ = _tmp38_;
2893 _tmp40_ = g_strdup_printf ("too few type arguments for `%s'", _tmp39_);
2894 _tmp41_ = _tmp40_;
2895 vala_report_error (_tmp35_, _tmp41_);
2896 _g_free0 (_tmp41_);
2897 _g_free0 (_tmp39_);
2898 result = FALSE;
2899 return result;
2900 } else {
2901 gboolean _tmp42_ = FALSE;
2902 gboolean _tmp43_ = FALSE;
2903 if (!allow_none) {
2904 _tmp43_ = TRUE;
2905 } else {
2906 _tmp43_ = n_type_args > 0;
2907 }
2908 if (_tmp43_) {
2909 _tmp42_ = n_type_args > expected_n_type_args;
2910 } else {
2911 _tmp42_ = FALSE;
2912 }
2913 if (_tmp42_) {
2914 ValaSourceReference* _tmp44_;
2915 ValaSourceReference* _tmp45_;
2916 ValaTypeSymbol* _tmp46_;
2917 ValaTypeSymbol* _tmp47_;
2918 gchar* _tmp48_;
2919 gchar* _tmp49_;
2920 gchar* _tmp50_;
2921 gchar* _tmp51_;
2922 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
2923 _tmp44_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
2924 _tmp45_ = _tmp44_;
2925 _tmp46_ = vala_data_type_get_type_symbol (self);
2926 _tmp47_ = _tmp46_;
2927 _tmp48_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp47_);
2928 _tmp49_ = _tmp48_;
2929 _tmp50_ = g_strdup_printf ("too many type arguments for `%s'", _tmp49_);
2930 _tmp51_ = _tmp50_;
2931 vala_report_error (_tmp45_, _tmp51_);
2932 _g_free0 (_tmp51_);
2933 _g_free0 (_tmp49_);
2934 result = FALSE;
2935 return result;
2936 }
2937 }
2938 {
2939 ValaList* _type_list = NULL;
2940 ValaList* _tmp52_;
2941 ValaList* _tmp53_;
2942 gint _type_size = 0;
2943 ValaList* _tmp54_;
2944 gint _tmp55_;
2945 gint _tmp56_;
2946 gint _type_index = 0;
2947 _tmp52_ = vala_data_type_get_type_arguments (self);
2948 _tmp53_ = _vala_iterable_ref0 (_tmp52_);
2949 _type_list = _tmp53_;
2950 _tmp54_ = _type_list;
2951 _tmp55_ = vala_collection_get_size ((ValaCollection*) _tmp54_);
2952 _tmp56_ = _tmp55_;
2953 _type_size = _tmp56_;
2954 _type_index = -1;
2955 while (TRUE) {
2956 gint _tmp57_;
2957 gint _tmp58_;
2958 ValaDataType* type = NULL;
2959 ValaList* _tmp59_;
2960 gpointer _tmp60_;
2961 ValaDataType* _tmp61_;
2962 _type_index = _type_index + 1;
2963 _tmp57_ = _type_index;
2964 _tmp58_ = _type_size;
2965 if (!(_tmp57_ < _tmp58_)) {
2966 break;
2967 }
2968 _tmp59_ = _type_list;
2969 _tmp60_ = vala_list_get (_tmp59_, _type_index);
2970 type = (ValaDataType*) _tmp60_;
2971 _tmp61_ = type;
2972 if (!vala_code_node_check ((ValaCodeNode*) _tmp61_, context)) {
2973 result = FALSE;
2974 _vala_code_node_unref0 (type);
2975 _vala_iterable_unref0 (_type_list);
2976 return result;
2977 }
2978 _vala_code_node_unref0 (type);
2979 }
2980 _vala_iterable_unref0 (_type_list);
2981 }
2982 result = TRUE;
2983 return result;
2984 }
2985
2986 ValaDataType*
vala_data_type_construct(GType object_type)2987 vala_data_type_construct (GType object_type)
2988 {
2989 ValaDataType* self = NULL;
2990 self = (ValaDataType*) vala_code_node_construct (object_type);
2991 return self;
2992 }
2993
2994 static void
vala_data_type_class_init(ValaDataTypeClass * klass,gpointer klass_data)2995 vala_data_type_class_init (ValaDataTypeClass * klass,
2996 gpointer klass_data)
2997 {
2998 vala_data_type_parent_class = g_type_class_peek_parent (klass);
2999 ((ValaCodeNodeClass *) klass)->finalize = vala_data_type_finalize;
3000 g_type_class_adjust_private_offset (klass, &ValaDataType_private_offset);
3001 ((ValaCodeNodeClass *) klass)->accept = (void (*) (ValaCodeNode*, ValaCodeVisitor*)) vala_data_type_real_accept;
3002 ((ValaCodeNodeClass *) klass)->accept_children = (void (*) (ValaCodeNode*, ValaCodeVisitor*)) vala_data_type_real_accept_children;
3003 ((ValaCodeNodeClass *) klass)->to_string = (gchar* (*) (ValaCodeNode*)) vala_data_type_real_to_string;
3004 ((ValaDataTypeClass *) klass)->to_qualified_string = (gchar* (*) (ValaDataType*, ValaScope*)) vala_data_type_real_to_qualified_string;
3005 ((ValaDataTypeClass *) klass)->copy = (ValaDataType* (*) (ValaDataType*)) vala_data_type_real_copy;
3006 ((ValaDataTypeClass *) klass)->equals = (gboolean (*) (ValaDataType*, ValaDataType*)) vala_data_type_real_equals;
3007 ((ValaDataTypeClass *) klass)->stricter = (gboolean (*) (ValaDataType*, ValaDataType*)) vala_data_type_real_stricter;
3008 ((ValaCodeNodeClass *) klass)->replace_type = (void (*) (ValaCodeNode*, ValaDataType*, ValaDataType*)) vala_data_type_real_replace_type;
3009 ((ValaDataTypeClass *) klass)->compatible = (gboolean (*) (ValaDataType*, ValaDataType*)) vala_data_type_real_compatible;
3010 ((ValaDataTypeClass *) klass)->is_invokable = (gboolean (*) (ValaDataType*)) vala_data_type_real_is_invokable;
3011 ((ValaDataTypeClass *) klass)->get_return_type = (ValaDataType* (*) (ValaDataType*)) vala_data_type_real_get_return_type;
3012 ((ValaDataTypeClass *) klass)->get_parameters = (ValaList* (*) (ValaDataType*)) vala_data_type_real_get_parameters;
3013 ((ValaDataTypeClass *) klass)->is_reference_type_or_type_parameter = (gboolean (*) (ValaDataType*)) vala_data_type_real_is_reference_type_or_type_parameter;
3014 ((ValaDataTypeClass *) klass)->is_accessible = (gboolean (*) (ValaDataType*, ValaSymbol*)) vala_data_type_real_is_accessible;
3015 ((ValaDataTypeClass *) klass)->get_member = (ValaSymbol* (*) (ValaDataType*, const gchar*)) vala_data_type_real_get_member;
3016 ((ValaDataTypeClass *) klass)->get_pointer_member = (ValaSymbol* (*) (ValaDataType*, const gchar*)) vala_data_type_real_get_pointer_member;
3017 ((ValaDataTypeClass *) klass)->is_real_struct_type = (gboolean (*) (ValaDataType*)) vala_data_type_real_is_real_struct_type;
3018 ((ValaDataTypeClass *) klass)->is_disposable = (gboolean (*) (ValaDataType*)) vala_data_type_real_is_disposable;
3019 ((ValaDataTypeClass *) klass)->get_actual_type = (ValaDataType* (*) (ValaDataType*, ValaDataType*, ValaList*, ValaCodeNode*)) vala_data_type_real_get_actual_type;
3020 ((ValaDataTypeClass *) klass)->infer_type_argument = (ValaDataType* (*) (ValaDataType*, ValaTypeParameter*, ValaDataType*)) vala_data_type_real_infer_type_argument;
3021 ((ValaDataTypeClass *) klass)->to_prototype_string = (gchar* (*) (ValaDataType*, const gchar*)) vala_data_type_real_to_prototype_string;
3022 }
3023
3024 static void
vala_data_type_instance_init(ValaDataType * self,gpointer klass)3025 vala_data_type_instance_init (ValaDataType * self,
3026 gpointer klass)
3027 {
3028 self->priv = vala_data_type_get_instance_private (self);
3029 }
3030
3031 static void
vala_data_type_finalize(ValaCodeNode * obj)3032 vala_data_type_finalize (ValaCodeNode * obj)
3033 {
3034 ValaDataType * self;
3035 self = G_TYPE_CHECK_INSTANCE_CAST (obj, VALA_TYPE_DATA_TYPE, ValaDataType);
3036 _vala_iterable_unref0 (self->priv->type_argument_list);
3037 VALA_CODE_NODE_CLASS (vala_data_type_parent_class)->finalize (obj);
3038 }
3039
3040 /**
3041 * A reference to a data type. This is used to specify static types of
3042 * expressions.
3043 */
3044 static GType
vala_data_type_get_type_once(void)3045 vala_data_type_get_type_once (void)
3046 {
3047 static const GTypeInfo g_define_type_info = { sizeof (ValaDataTypeClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) vala_data_type_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ValaDataType), 0, (GInstanceInitFunc) vala_data_type_instance_init, NULL };
3048 GType vala_data_type_type_id;
3049 vala_data_type_type_id = g_type_register_static (VALA_TYPE_CODE_NODE, "ValaDataType", &g_define_type_info, G_TYPE_FLAG_ABSTRACT);
3050 ValaDataType_private_offset = g_type_add_instance_private (vala_data_type_type_id, sizeof (ValaDataTypePrivate));
3051 return vala_data_type_type_id;
3052 }
3053
3054 GType
vala_data_type_get_type(void)3055 vala_data_type_get_type (void)
3056 {
3057 static volatile gsize vala_data_type_type_id__volatile = 0;
3058 if (g_once_init_enter (&vala_data_type_type_id__volatile)) {
3059 GType vala_data_type_type_id;
3060 vala_data_type_type_id = vala_data_type_get_type_once ();
3061 g_once_init_leave (&vala_data_type_type_id__volatile, vala_data_type_type_id);
3062 }
3063 return vala_data_type_type_id__volatile;
3064 }
3065
3066