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