/* valamemberaccess.c generated by valac, the Vala compiler
 * generated from valamemberaccess.vala, do not modify */

/* valamemberaccess.vala
 *
 * Copyright (C) 2006-2012  Jürg Billeter
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.

 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.

 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
 *
 * Author:
 * 	Jürg Billeter <j@bitron.ch>
 */

#include <glib.h>
#include <glib-object.h>
#include "vala.h"
#include <stdlib.h>
#include <string.h>
#include <valagee.h>

#define _g_free0(var) (var = (g_free (var), NULL))
#define _vala_code_node_unref0(var) ((var == NULL) ? NULL : (var = (vala_code_node_unref (var), NULL)))
#define _vala_iterable_unref0(var) ((var == NULL) ? NULL : (var = (vala_iterable_unref (var), NULL)))

struct _ValaMemberAccessPrivate {
	gchar* _member_name;
	gboolean _pointer_member_access;
	gboolean _prototype_access;
	gboolean _creation_member;
	gboolean _qualified;
	ValaExpression* _inner;
	ValaList* type_argument_list;
};


static gpointer vala_member_access_parent_class = NULL;

#define VALA_MEMBER_ACCESS_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), VALA_TYPE_MEMBER_ACCESS, ValaMemberAccessPrivate))
static void vala_member_access_real_accept (ValaCodeNode* base, ValaCodeVisitor* visitor);
static void vala_member_access_real_accept_children (ValaCodeNode* base, ValaCodeVisitor* visitor);
static gchar* vala_member_access_real_to_string (ValaCodeNode* base);
static void vala_member_access_real_replace_expression (ValaCodeNode* base, ValaExpression* old_node, ValaExpression* new_node);
static gboolean vala_member_access_real_is_pure (ValaExpression* base);
static gboolean vala_member_access_real_is_accessible (ValaExpression* base, ValaSymbol* sym);
static void vala_member_access_real_replace_type (ValaCodeNode* base, ValaDataType* old_type, ValaDataType* new_type);
static gboolean vala_member_access_real_is_constant (ValaExpression* base);
static gboolean vala_member_access_real_is_non_null (ValaExpression* base);
static gboolean vala_member_access_real_check (ValaCodeNode* base, ValaCodeContext* context);
static gboolean vala_member_access_is_instance_symbol (ValaSymbol* symbol);
static void vala_member_access_real_emit (ValaCodeNode* base, ValaCodeGenerator* codegen);
static void vala_member_access_real_get_defined_variables (ValaCodeNode* base, ValaCollection* collection);
static void vala_member_access_real_get_used_variables (ValaCodeNode* base, ValaCollection* collection);
static void vala_member_access_finalize (ValaCodeNode * obj);


/**
 * Creates a new member access expression.
 *
 * @param inner            parent of the member
 * @param member_name      member name
 * @param source_reference reference to source code
 * @return                 newly created member access expression
 */
ValaMemberAccess* vala_member_access_construct (GType object_type, ValaExpression* inner, const gchar* member_name, ValaSourceReference* source_reference) {
	ValaMemberAccess* self = NULL;
	ValaExpression* _tmp0_;
	const gchar* _tmp1_;
	ValaSourceReference* _tmp2_;
	g_return_val_if_fail (member_name != NULL, NULL);
	self = (ValaMemberAccess*) vala_expression_construct (object_type);
	_tmp0_ = inner;
	vala_member_access_set_inner (self, _tmp0_);
	_tmp1_ = member_name;
	vala_member_access_set_member_name (self, _tmp1_);
	_tmp2_ = source_reference;
	vala_code_node_set_source_reference ((ValaCodeNode*) self, _tmp2_);
	return self;
}


ValaMemberAccess* vala_member_access_new (ValaExpression* inner, const gchar* member_name, ValaSourceReference* source_reference) {
	return vala_member_access_construct (VALA_TYPE_MEMBER_ACCESS, inner, member_name, source_reference);
}


ValaMemberAccess* vala_member_access_construct_simple (GType object_type, const gchar* member_name, ValaSourceReference* source_reference) {
	ValaMemberAccess* self = NULL;
	const gchar* _tmp0_;
	ValaSourceReference* _tmp1_;
	g_return_val_if_fail (member_name != NULL, NULL);
	self = (ValaMemberAccess*) vala_expression_construct (object_type);
	_tmp0_ = member_name;
	vala_member_access_set_member_name (self, _tmp0_);
	_tmp1_ = source_reference;
	vala_code_node_set_source_reference ((ValaCodeNode*) self, _tmp1_);
	return self;
}


ValaMemberAccess* vala_member_access_new_simple (const gchar* member_name, ValaSourceReference* source_reference) {
	return vala_member_access_construct_simple (VALA_TYPE_MEMBER_ACCESS, member_name, source_reference);
}


ValaMemberAccess* vala_member_access_construct_pointer (GType object_type, ValaExpression* inner, const gchar* member_name, ValaSourceReference* source_reference) {
	ValaMemberAccess* self = NULL;
	ValaExpression* _tmp0_;
	const gchar* _tmp1_;
	ValaSourceReference* _tmp2_;
	g_return_val_if_fail (inner != NULL, NULL);
	g_return_val_if_fail (member_name != NULL, NULL);
	self = (ValaMemberAccess*) vala_expression_construct (object_type);
	_tmp0_ = inner;
	vala_member_access_set_inner (self, _tmp0_);
	_tmp1_ = member_name;
	vala_member_access_set_member_name (self, _tmp1_);
	_tmp2_ = source_reference;
	vala_code_node_set_source_reference ((ValaCodeNode*) self, _tmp2_);
	vala_member_access_set_pointer_member_access (self, TRUE);
	return self;
}


ValaMemberAccess* vala_member_access_new_pointer (ValaExpression* inner, const gchar* member_name, ValaSourceReference* source_reference) {
	return vala_member_access_construct_pointer (VALA_TYPE_MEMBER_ACCESS, inner, member_name, source_reference);
}


/**
 * Appends the specified type as generic type argument.
 *
 * @param arg a type reference
 */
void vala_member_access_add_type_argument (ValaMemberAccess* self, ValaDataType* arg) {
	ValaList* _tmp0_;
	ValaDataType* _tmp1_;
	ValaDataType* _tmp2_;
	g_return_if_fail (self != NULL);
	g_return_if_fail (arg != NULL);
	_tmp0_ = self->priv->type_argument_list;
	_tmp1_ = arg;
	vala_collection_add ((ValaCollection*) _tmp0_, _tmp1_);
	_tmp2_ = arg;
	vala_code_node_set_parent_node ((ValaCodeNode*) _tmp2_, (ValaCodeNode*) self);
}


/**
 * Returns a copy of the list of generic type arguments.
 *
 * @return type argument list
 */
static gpointer _vala_iterable_ref0 (gpointer self) {
	return self ? vala_iterable_ref (self) : NULL;
}


ValaList* vala_member_access_get_type_arguments (ValaMemberAccess* self) {
	ValaList* result = NULL;
	ValaList* _tmp0_;
	ValaList* _tmp1_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->type_argument_list;
	_tmp1_ = _vala_iterable_ref0 (_tmp0_);
	result = _tmp1_;
	return result;
}


static void vala_member_access_real_accept (ValaCodeNode* base, ValaCodeVisitor* visitor) {
	ValaMemberAccess * self;
	ValaCodeVisitor* _tmp0_;
	ValaCodeVisitor* _tmp1_;
	self = (ValaMemberAccess*) base;
	g_return_if_fail (visitor != NULL);
	_tmp0_ = visitor;
	vala_code_visitor_visit_member_access (_tmp0_, self);
	_tmp1_ = visitor;
	vala_code_visitor_visit_expression (_tmp1_, (ValaExpression*) self);
}


static void vala_member_access_real_accept_children (ValaCodeNode* base, ValaCodeVisitor* visitor) {
	ValaMemberAccess * self;
	ValaExpression* _tmp0_;
	ValaExpression* _tmp1_;
	self = (ValaMemberAccess*) base;
	g_return_if_fail (visitor != NULL);
	_tmp0_ = vala_member_access_get_inner (self);
	_tmp1_ = _tmp0_;
	if (_tmp1_ != NULL) {
		ValaExpression* _tmp2_;
		ValaExpression* _tmp3_;
		ValaCodeVisitor* _tmp4_;
		_tmp2_ = vala_member_access_get_inner (self);
		_tmp3_ = _tmp2_;
		_tmp4_ = visitor;
		vala_code_node_accept ((ValaCodeNode*) _tmp3_, _tmp4_);
	}
	{
		ValaList* _type_arg_list = NULL;
		ValaList* _tmp5_;
		ValaList* _tmp6_;
		gint _type_arg_size = 0;
		ValaList* _tmp7_;
		gint _tmp8_;
		gint _tmp9_;
		gint _type_arg_index = 0;
		_tmp5_ = self->priv->type_argument_list;
		_tmp6_ = _vala_iterable_ref0 (_tmp5_);
		_type_arg_list = _tmp6_;
		_tmp7_ = _type_arg_list;
		_tmp8_ = vala_collection_get_size ((ValaCollection*) _tmp7_);
		_tmp9_ = _tmp8_;
		_type_arg_size = _tmp9_;
		_type_arg_index = -1;
		while (TRUE) {
			gint _tmp10_;
			gint _tmp11_;
			gint _tmp12_;
			ValaDataType* type_arg = NULL;
			ValaList* _tmp13_;
			gint _tmp14_;
			gpointer _tmp15_;
			ValaDataType* _tmp16_;
			ValaCodeVisitor* _tmp17_;
			_tmp10_ = _type_arg_index;
			_type_arg_index = _tmp10_ + 1;
			_tmp11_ = _type_arg_index;
			_tmp12_ = _type_arg_size;
			if (!(_tmp11_ < _tmp12_)) {
				break;
			}
			_tmp13_ = _type_arg_list;
			_tmp14_ = _type_arg_index;
			_tmp15_ = vala_list_get (_tmp13_, _tmp14_);
			type_arg = (ValaDataType*) _tmp15_;
			_tmp16_ = type_arg;
			_tmp17_ = visitor;
			vala_code_node_accept ((ValaCodeNode*) _tmp16_, _tmp17_);
			_vala_code_node_unref0 (type_arg);
		}
		_vala_iterable_unref0 (_type_arg_list);
	}
}


static gchar* vala_member_access_real_to_string (ValaCodeNode* base) {
	ValaMemberAccess * self;
	gchar* result = NULL;
	gboolean _tmp0_ = FALSE;
	ValaSymbol* _tmp1_;
	ValaSymbol* _tmp2_;
	self = (ValaMemberAccess*) base;
	_tmp1_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
	_tmp2_ = _tmp1_;
	if (_tmp2_ == NULL) {
		_tmp0_ = TRUE;
	} else {
		ValaSymbol* _tmp3_;
		ValaSymbol* _tmp4_;
		gboolean _tmp5_;
		_tmp3_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
		_tmp4_ = _tmp3_;
		_tmp5_ = vala_symbol_is_instance_member (_tmp4_);
		_tmp0_ = _tmp5_;
	}
	if (_tmp0_) {
		ValaExpression* _tmp6_;
		ValaExpression* _tmp7_;
		_tmp6_ = vala_member_access_get_inner (self);
		_tmp7_ = _tmp6_;
		if (_tmp7_ == NULL) {
			const gchar* _tmp8_;
			gchar* _tmp9_;
			_tmp8_ = self->priv->_member_name;
			_tmp9_ = g_strdup (_tmp8_);
			result = _tmp9_;
			return result;
		} else {
			ValaExpression* _tmp10_;
			ValaExpression* _tmp11_;
			gchar* _tmp12_;
			gchar* _tmp13_;
			const gchar* _tmp14_;
			gchar* _tmp15_;
			gchar* _tmp16_;
			_tmp10_ = vala_member_access_get_inner (self);
			_tmp11_ = _tmp10_;
			_tmp12_ = vala_code_node_to_string ((ValaCodeNode*) _tmp11_);
			_tmp13_ = _tmp12_;
			_tmp14_ = self->priv->_member_name;
			_tmp15_ = g_strdup_printf ("%s.%s", _tmp13_, _tmp14_);
			_tmp16_ = _tmp15_;
			_g_free0 (_tmp13_);
			result = _tmp16_;
			return result;
		}
	} else {
		ValaSymbol* _tmp17_;
		ValaSymbol* _tmp18_;
		gchar* _tmp19_;
		_tmp17_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
		_tmp18_ = _tmp17_;
		_tmp19_ = vala_symbol_get_full_name (_tmp18_);
		result = _tmp19_;
		return result;
	}
}


static void vala_member_access_real_replace_expression (ValaCodeNode* base, ValaExpression* old_node, ValaExpression* new_node) {
	ValaMemberAccess * self;
	ValaExpression* _tmp0_;
	ValaExpression* _tmp1_;
	ValaExpression* _tmp2_;
	self = (ValaMemberAccess*) base;
	g_return_if_fail (old_node != NULL);
	g_return_if_fail (new_node != NULL);
	_tmp0_ = vala_member_access_get_inner (self);
	_tmp1_ = _tmp0_;
	_tmp2_ = old_node;
	if (_tmp1_ == _tmp2_) {
		ValaExpression* _tmp3_;
		_tmp3_ = new_node;
		vala_member_access_set_inner (self, _tmp3_);
	}
}


static gboolean vala_member_access_real_is_pure (ValaExpression* base) {
	ValaMemberAccess * self;
	gboolean result = FALSE;
	gboolean _tmp0_ = FALSE;
	gboolean _tmp1_ = FALSE;
	ValaExpression* _tmp2_;
	ValaExpression* _tmp3_;
	self = (ValaMemberAccess*) base;
	_tmp2_ = vala_member_access_get_inner (self);
	_tmp3_ = _tmp2_;
	if (_tmp3_ == NULL) {
		_tmp1_ = TRUE;
	} else {
		ValaExpression* _tmp4_;
		ValaExpression* _tmp5_;
		gboolean _tmp6_;
		_tmp4_ = vala_member_access_get_inner (self);
		_tmp5_ = _tmp4_;
		_tmp6_ = vala_expression_is_pure (_tmp5_);
		_tmp1_ = _tmp6_;
	}
	if (_tmp1_) {
		ValaSymbol* _tmp7_;
		ValaSymbol* _tmp8_;
		_tmp7_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
		_tmp8_ = _tmp7_;
		_tmp0_ = !G_TYPE_CHECK_INSTANCE_TYPE (_tmp8_, VALA_TYPE_PROPERTY);
	} else {
		_tmp0_ = FALSE;
	}
	result = _tmp0_;
	return result;
}


static gboolean vala_member_access_real_is_accessible (ValaExpression* base, ValaSymbol* sym) {
	ValaMemberAccess * self;
	gboolean result = FALSE;
	gboolean _tmp0_ = FALSE;
	gboolean _tmp1_ = FALSE;
	ValaExpression* _tmp2_;
	ValaExpression* _tmp3_;
	self = (ValaMemberAccess*) base;
	g_return_val_if_fail (sym != NULL, FALSE);
	_tmp2_ = vala_member_access_get_inner (self);
	_tmp3_ = _tmp2_;
	if (_tmp3_ == NULL) {
		_tmp1_ = TRUE;
	} else {
		ValaExpression* _tmp4_;
		ValaExpression* _tmp5_;
		ValaSymbol* _tmp6_;
		gboolean _tmp7_;
		_tmp4_ = vala_member_access_get_inner (self);
		_tmp5_ = _tmp4_;
		_tmp6_ = sym;
		_tmp7_ = vala_expression_is_accessible (_tmp5_, _tmp6_);
		_tmp1_ = _tmp7_;
	}
	if (_tmp1_) {
		ValaSymbol* _tmp8_;
		ValaSymbol* _tmp9_;
		ValaSymbol* _tmp10_;
		gboolean _tmp11_;
		_tmp8_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
		_tmp9_ = _tmp8_;
		_tmp10_ = sym;
		_tmp11_ = vala_symbol_is_accessible (_tmp9_, _tmp10_);
		_tmp0_ = _tmp11_;
	} else {
		_tmp0_ = FALSE;
	}
	result = _tmp0_;
	return result;
}


static void vala_member_access_real_replace_type (ValaCodeNode* base, ValaDataType* old_type, ValaDataType* new_type) {
	ValaMemberAccess * self;
	self = (ValaMemberAccess*) base;
	g_return_if_fail (old_type != NULL);
	g_return_if_fail (new_type != NULL);
	{
		gint i = 0;
		i = 0;
		{
			gboolean _tmp0_ = FALSE;
			_tmp0_ = TRUE;
			while (TRUE) {
				gint _tmp2_;
				ValaList* _tmp3_;
				gint _tmp4_;
				gint _tmp5_;
				ValaList* _tmp6_;
				gint _tmp7_;
				gpointer _tmp8_;
				ValaDataType* _tmp9_;
				ValaDataType* _tmp10_;
				gboolean _tmp11_;
				if (!_tmp0_) {
					gint _tmp1_;
					_tmp1_ = i;
					i = _tmp1_ + 1;
				}
				_tmp0_ = FALSE;
				_tmp2_ = i;
				_tmp3_ = self->priv->type_argument_list;
				_tmp4_ = vala_collection_get_size ((ValaCollection*) _tmp3_);
				_tmp5_ = _tmp4_;
				if (!(_tmp2_ < _tmp5_)) {
					break;
				}
				_tmp6_ = self->priv->type_argument_list;
				_tmp7_ = i;
				_tmp8_ = vala_list_get (_tmp6_, _tmp7_);
				_tmp9_ = (ValaDataType*) _tmp8_;
				_tmp10_ = old_type;
				_tmp11_ = _tmp9_ == _tmp10_;
				_vala_code_node_unref0 (_tmp9_);
				if (_tmp11_) {
					ValaList* _tmp12_;
					gint _tmp13_;
					ValaDataType* _tmp14_;
					_tmp12_ = self->priv->type_argument_list;
					_tmp13_ = i;
					_tmp14_ = new_type;
					vala_list_set (_tmp12_, _tmp13_, _tmp14_);
					return;
				}
			}
		}
	}
}


static gpointer _vala_code_node_ref0 (gpointer self) {
	return self ? vala_code_node_ref (self) : NULL;
}


static gboolean vala_member_access_real_is_constant (ValaExpression* base) {
	ValaMemberAccess * self;
	gboolean result = FALSE;
	ValaMethod* method = NULL;
	ValaSymbol* _tmp0_;
	ValaSymbol* _tmp1_;
	ValaMethod* _tmp2_;
	ValaSymbol* _tmp3_;
	ValaSymbol* _tmp4_;
	self = (ValaMemberAccess*) base;
	_tmp0_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
	_tmp1_ = _tmp0_;
	_tmp2_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp1_, VALA_TYPE_METHOD) ? ((ValaMethod*) _tmp1_) : NULL);
	method = _tmp2_;
	_tmp3_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
	_tmp4_ = _tmp3_;
	if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp4_, VALA_TYPE_CONSTANT)) {
		result = TRUE;
		_vala_code_node_unref0 (method);
		return result;
	} else {
		gboolean _tmp5_ = FALSE;
		gboolean _tmp6_ = FALSE;
		ValaSymbol* _tmp7_;
		ValaSymbol* _tmp8_;
		_tmp7_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
		_tmp8_ = _tmp7_;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp8_, VALA_TYPE_ARRAY_LENGTH_FIELD)) {
			ValaExpression* _tmp9_;
			ValaExpression* _tmp10_;
			_tmp9_ = vala_member_access_get_inner (self);
			_tmp10_ = _tmp9_;
			_tmp6_ = _tmp10_ != NULL;
		} else {
			_tmp6_ = FALSE;
		}
		if (_tmp6_) {
			ValaExpression* _tmp11_;
			ValaExpression* _tmp12_;
			ValaSymbol* _tmp13_;
			ValaSymbol* _tmp14_;
			_tmp11_ = vala_member_access_get_inner (self);
			_tmp12_ = _tmp11_;
			_tmp13_ = vala_expression_get_symbol_reference (_tmp12_);
			_tmp14_ = _tmp13_;
			_tmp5_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp14_, VALA_TYPE_CONSTANT);
		} else {
			_tmp5_ = FALSE;
		}
		if (_tmp5_) {
			result = TRUE;
			_vala_code_node_unref0 (method);
			return result;
		} else {
			gboolean _tmp15_ = FALSE;
			ValaMethod* _tmp16_;
			_tmp16_ = method;
			if (_tmp16_ != NULL) {
				gboolean _tmp17_ = FALSE;
				ValaMethod* _tmp18_;
				ValaMemberBinding _tmp19_;
				ValaMemberBinding _tmp20_;
				_tmp18_ = method;
				_tmp19_ = vala_method_get_binding (_tmp18_);
				_tmp20_ = _tmp19_;
				if (_tmp20_ == VALA_MEMBER_BINDING_STATIC) {
					_tmp17_ = TRUE;
				} else {
					gboolean _tmp21_;
					_tmp21_ = self->priv->_prototype_access;
					_tmp17_ = _tmp21_;
				}
				_tmp15_ = _tmp17_;
			} else {
				_tmp15_ = FALSE;
			}
			if (_tmp15_) {
				result = TRUE;
				_vala_code_node_unref0 (method);
				return result;
			} else {
				result = FALSE;
				_vala_code_node_unref0 (method);
				return result;
			}
		}
	}
	_vala_code_node_unref0 (method);
}


static gboolean vala_member_access_real_is_non_null (ValaExpression* base) {
	ValaMemberAccess * self;
	gboolean result = FALSE;
	ValaConstant* c = NULL;
	ValaSymbol* _tmp0_;
	ValaSymbol* _tmp1_;
	ValaConstant* _tmp2_;
	ValaConstant* _tmp3_;
	self = (ValaMemberAccess*) base;
	_tmp0_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
	_tmp1_ = _tmp0_;
	_tmp2_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp1_, VALA_TYPE_CONSTANT) ? ((ValaConstant*) _tmp1_) : NULL);
	c = _tmp2_;
	_tmp3_ = c;
	if (_tmp3_ != NULL) {
		gboolean _tmp4_ = FALSE;
		ValaConstant* _tmp5_;
		_tmp5_ = c;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp5_, VALA_TYPE_ENUM_VALUE)) {
			_tmp4_ = TRUE;
		} else {
			ValaConstant* _tmp6_;
			ValaDataType* _tmp7_;
			ValaDataType* _tmp8_;
			gboolean _tmp9_;
			gboolean _tmp10_;
			_tmp6_ = c;
			_tmp7_ = vala_constant_get_type_reference (_tmp6_);
			_tmp8_ = _tmp7_;
			_tmp9_ = vala_data_type_get_nullable (_tmp8_);
			_tmp10_ = _tmp9_;
			_tmp4_ = !_tmp10_;
		}
		result = _tmp4_;
		_vala_code_node_unref0 (c);
		return result;
	} else {
		result = FALSE;
		_vala_code_node_unref0 (c);
		return result;
	}
	_vala_code_node_unref0 (c);
}


static gboolean vala_member_access_real_check (ValaCodeNode* base, ValaCodeContext* context) {
	ValaMemberAccess * self;
	gboolean result = FALSE;
	gboolean _tmp0_;
	gboolean _tmp1_;
	ValaExpression* _tmp4_;
	ValaExpression* _tmp5_;
	ValaSymbol* base_symbol = NULL;
	ValaParameter* this_parameter = NULL;
	gboolean may_access_instance_members = FALSE;
	gboolean may_access_klass_members = FALSE;
	gboolean _tmp22_;
	ValaSymbol* _tmp570_;
	ValaSymbol* _tmp571_;
	ValaSymbol* member = NULL;
	ValaSymbol* _tmp594_;
	ValaSymbol* _tmp595_;
	ValaSymbol* _tmp596_;
	ValaSymbolAccessibility access = 0;
	gboolean instance = FALSE;
	gboolean klass = FALSE;
	gboolean generics = FALSE;
	ValaSymbol* _tmp597_;
	ValaCodeContext* _tmp598_;
	gboolean _tmp599_;
	ValaSymbol* _tmp600_;
	ValaSymbol* _tmp1032_;
	ValaSymbol* _tmp1033_;
	ValaVersionAttribute* _tmp1034_;
	ValaVersionAttribute* _tmp1035_;
	ValaSourceReference* _tmp1036_;
	ValaSourceReference* _tmp1037_;
	ValaSymbolAccessibility _tmp1038_;
	gboolean _tmp1099_ = FALSE;
	gboolean _tmp1100_;
	gboolean _tmp1139_ = FALSE;
	gboolean _tmp1140_ = FALSE;
	gboolean _tmp1141_;
	gboolean _tmp1408_;
	gboolean _tmp1409_;
	self = (ValaMemberAccess*) base;
	g_return_val_if_fail (context != NULL, FALSE);
	_tmp0_ = vala_code_node_get_checked ((ValaCodeNode*) self);
	_tmp1_ = _tmp0_;
	if (_tmp1_) {
		gboolean _tmp2_;
		gboolean _tmp3_;
		_tmp2_ = vala_code_node_get_error ((ValaCodeNode*) self);
		_tmp3_ = _tmp2_;
		result = !_tmp3_;
		return result;
	}
	vala_code_node_set_checked ((ValaCodeNode*) self, TRUE);
	_tmp4_ = vala_member_access_get_inner (self);
	_tmp5_ = _tmp4_;
	if (_tmp5_ != NULL) {
		ValaExpression* _tmp6_;
		ValaExpression* _tmp7_;
		ValaCodeContext* _tmp8_;
		_tmp6_ = vala_member_access_get_inner (self);
		_tmp7_ = _tmp6_;
		_tmp8_ = context;
		vala_code_node_check ((ValaCodeNode*) _tmp7_, _tmp8_);
	}
	{
		ValaList* _type_arg_list = NULL;
		ValaList* _tmp9_;
		ValaList* _tmp10_;
		gint _type_arg_size = 0;
		ValaList* _tmp11_;
		gint _tmp12_;
		gint _tmp13_;
		gint _type_arg_index = 0;
		_tmp9_ = self->priv->type_argument_list;
		_tmp10_ = _vala_iterable_ref0 (_tmp9_);
		_type_arg_list = _tmp10_;
		_tmp11_ = _type_arg_list;
		_tmp12_ = vala_collection_get_size ((ValaCollection*) _tmp11_);
		_tmp13_ = _tmp12_;
		_type_arg_size = _tmp13_;
		_type_arg_index = -1;
		while (TRUE) {
			gint _tmp14_;
			gint _tmp15_;
			gint _tmp16_;
			ValaDataType* type_arg = NULL;
			ValaList* _tmp17_;
			gint _tmp18_;
			gpointer _tmp19_;
			ValaDataType* _tmp20_;
			ValaCodeContext* _tmp21_;
			_tmp14_ = _type_arg_index;
			_type_arg_index = _tmp14_ + 1;
			_tmp15_ = _type_arg_index;
			_tmp16_ = _type_arg_size;
			if (!(_tmp15_ < _tmp16_)) {
				break;
			}
			_tmp17_ = _type_arg_list;
			_tmp18_ = _type_arg_index;
			_tmp19_ = vala_list_get (_tmp17_, _tmp18_);
			type_arg = (ValaDataType*) _tmp19_;
			_tmp20_ = type_arg;
			_tmp21_ = context;
			vala_code_node_check ((ValaCodeNode*) _tmp20_, _tmp21_);
			_vala_code_node_unref0 (type_arg);
		}
		_vala_iterable_unref0 (_type_arg_list);
	}
	base_symbol = NULL;
	this_parameter = NULL;
	may_access_instance_members = FALSE;
	may_access_klass_members = FALSE;
	vala_expression_set_symbol_reference ((ValaExpression*) self, NULL);
	_tmp22_ = self->priv->_qualified;
	if (_tmp22_) {
		ValaCodeContext* _tmp23_;
		ValaSemanticAnalyzer* _tmp24_;
		ValaSemanticAnalyzer* _tmp25_;
		ValaSymbol* _tmp26_;
		ValaSymbol* _tmp27_;
		ValaCodeContext* _tmp28_;
		ValaSemanticAnalyzer* _tmp29_;
		ValaSemanticAnalyzer* _tmp30_;
		ValaSymbol* _tmp31_;
		ValaScope* _tmp32_;
		ValaScope* _tmp33_;
		const gchar* _tmp34_;
		ValaSymbol* _tmp35_;
		ValaSymbol* _tmp36_;
		_tmp23_ = context;
		_tmp24_ = vala_code_context_get_analyzer (_tmp23_);
		_tmp25_ = _tmp24_;
		_tmp26_ = _tmp25_->root_symbol;
		_tmp27_ = _vala_code_node_ref0 (_tmp26_);
		_vala_code_node_unref0 (base_symbol);
		base_symbol = _tmp27_;
		_tmp28_ = context;
		_tmp29_ = vala_code_context_get_analyzer (_tmp28_);
		_tmp30_ = _tmp29_;
		_tmp31_ = _tmp30_->root_symbol;
		_tmp32_ = vala_symbol_get_scope (_tmp31_);
		_tmp33_ = _tmp32_;
		_tmp34_ = self->priv->_member_name;
		_tmp35_ = vala_scope_lookup (_tmp33_, _tmp34_);
		_tmp36_ = _tmp35_;
		vala_expression_set_symbol_reference ((ValaExpression*) self, _tmp36_);
		_vala_code_node_unref0 (_tmp36_);
	} else {
		ValaExpression* _tmp37_;
		ValaExpression* _tmp38_;
		_tmp37_ = vala_member_access_get_inner (self);
		_tmp38_ = _tmp37_;
		if (_tmp38_ == NULL) {
			const gchar* _tmp39_;
			ValaCodeContext* _tmp46_;
			ValaSemanticAnalyzer* _tmp47_;
			ValaSemanticAnalyzer* _tmp48_;
			ValaSymbol* _tmp49_;
			ValaSymbol* _tmp50_;
			ValaSymbol* _tmp51_;
			gboolean method_found = FALSE;
			ValaSymbol* sym = NULL;
			ValaCodeContext* _tmp52_;
			ValaSemanticAnalyzer* _tmp53_;
			ValaSemanticAnalyzer* _tmp54_;
			ValaSymbol* _tmp55_;
			ValaSymbol* _tmp56_;
			ValaSymbol* _tmp57_;
			gboolean _tmp170_ = FALSE;
			ValaSymbol* _tmp171_;
			ValaSymbol* _tmp172_;
			_tmp39_ = self->priv->_member_name;
			if (g_strcmp0 (_tmp39_, "this") == 0) {
				ValaCodeContext* _tmp40_;
				ValaSemanticAnalyzer* _tmp41_;
				ValaSemanticAnalyzer* _tmp42_;
				gboolean _tmp43_;
				_tmp40_ = context;
				_tmp41_ = vala_code_context_get_analyzer (_tmp40_);
				_tmp42_ = _tmp41_;
				_tmp43_ = vala_semantic_analyzer_is_in_instance_method (_tmp42_);
				if (!_tmp43_) {
					ValaSourceReference* _tmp44_;
					ValaSourceReference* _tmp45_;
					vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
					_tmp44_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
					_tmp45_ = _tmp44_;
					vala_report_error (_tmp45_, "This access invalid outside of instance methods");
					result = FALSE;
					_vala_code_node_unref0 (this_parameter);
					_vala_code_node_unref0 (base_symbol);
					return result;
				}
			}
			_tmp46_ = context;
			_tmp47_ = vala_code_context_get_analyzer (_tmp46_);
			_tmp48_ = _tmp47_;
			_tmp49_ = vala_semantic_analyzer_get_current_symbol (_tmp48_);
			_tmp50_ = _tmp49_;
			_tmp51_ = _vala_code_node_ref0 (_tmp50_);
			_vala_code_node_unref0 (base_symbol);
			base_symbol = _tmp51_;
			method_found = FALSE;
			_tmp52_ = context;
			_tmp53_ = vala_code_context_get_analyzer (_tmp52_);
			_tmp54_ = _tmp53_;
			_tmp55_ = vala_semantic_analyzer_get_current_symbol (_tmp54_);
			_tmp56_ = _tmp55_;
			_tmp57_ = _vala_code_node_ref0 (_tmp56_);
			sym = _tmp57_;
			while (TRUE) {
				gboolean _tmp58_ = FALSE;
				ValaSymbol* _tmp59_;
				gboolean _tmp62_;
				ValaSymbol* _tmp116_;
				const gchar* _tmp117_;
				ValaSymbol* _tmp118_;
				ValaSymbol* _tmp119_;
				gboolean _tmp120_ = FALSE;
				gboolean _tmp121_ = FALSE;
				ValaSymbol* _tmp122_;
				ValaSymbol* _tmp123_;
				ValaSymbol* _tmp163_;
				ValaSymbol* _tmp164_;
				ValaSymbol* _tmp166_;
				ValaSymbol* _tmp167_;
				ValaSymbol* _tmp168_;
				ValaSymbol* _tmp169_;
				_tmp59_ = sym;
				if (_tmp59_ != NULL) {
					ValaSymbol* _tmp60_;
					ValaSymbol* _tmp61_;
					_tmp60_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
					_tmp61_ = _tmp60_;
					_tmp58_ = _tmp61_ == NULL;
				} else {
					_tmp58_ = FALSE;
				}
				if (!_tmp58_) {
					break;
				}
				_tmp62_ = method_found;
				if (!_tmp62_) {
					ValaSymbol* _tmp63_;
					_tmp63_ = sym;
					if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp63_, VALA_TYPE_CREATION_METHOD)) {
						ValaCreationMethod* cm = NULL;
						ValaSymbol* _tmp64_;
						ValaCreationMethod* _tmp65_;
						ValaCreationMethod* _tmp66_;
						ValaParameter* _tmp67_;
						ValaParameter* _tmp68_;
						ValaParameter* _tmp69_;
						_tmp64_ = sym;
						_tmp65_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp64_, VALA_TYPE_CREATION_METHOD, ValaCreationMethod));
						cm = _tmp65_;
						_tmp66_ = cm;
						_tmp67_ = vala_method_get_this_parameter ((ValaMethod*) _tmp66_);
						_tmp68_ = _tmp67_;
						_tmp69_ = _vala_code_node_ref0 (_tmp68_);
						_vala_code_node_unref0 (this_parameter);
						this_parameter = _tmp69_;
						may_access_instance_members = TRUE;
						may_access_klass_members = TRUE;
						method_found = TRUE;
						_vala_code_node_unref0 (cm);
					} else {
						ValaSymbol* _tmp70_;
						_tmp70_ = sym;
						if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp70_, VALA_TYPE_PROPERTY)) {
							ValaProperty* prop = NULL;
							ValaSymbol* _tmp71_;
							ValaProperty* _tmp72_;
							ValaProperty* _tmp73_;
							ValaParameter* _tmp74_;
							ValaParameter* _tmp75_;
							ValaParameter* _tmp76_;
							ValaProperty* _tmp77_;
							ValaMemberBinding _tmp78_;
							ValaMemberBinding _tmp79_;
							ValaProperty* _tmp80_;
							ValaMemberBinding _tmp81_;
							ValaMemberBinding _tmp82_;
							_tmp71_ = sym;
							_tmp72_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp71_, VALA_TYPE_PROPERTY, ValaProperty));
							prop = _tmp72_;
							_tmp73_ = prop;
							_tmp74_ = vala_property_get_this_parameter (_tmp73_);
							_tmp75_ = _tmp74_;
							_tmp76_ = _vala_code_node_ref0 (_tmp75_);
							_vala_code_node_unref0 (this_parameter);
							this_parameter = _tmp76_;
							_tmp77_ = prop;
							_tmp78_ = vala_property_get_binding (_tmp77_);
							_tmp79_ = _tmp78_;
							may_access_instance_members = _tmp79_ == VALA_MEMBER_BINDING_INSTANCE;
							_tmp80_ = prop;
							_tmp81_ = vala_property_get_binding (_tmp80_);
							_tmp82_ = _tmp81_;
							may_access_klass_members = _tmp82_ != VALA_MEMBER_BINDING_STATIC;
							method_found = TRUE;
							_vala_code_node_unref0 (prop);
						} else {
							ValaSymbol* _tmp83_;
							_tmp83_ = sym;
							if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp83_, VALA_TYPE_CONSTRUCTOR)) {
								ValaConstructor* c = NULL;
								ValaSymbol* _tmp84_;
								ValaConstructor* _tmp85_;
								ValaConstructor* _tmp86_;
								ValaParameter* _tmp87_;
								ValaParameter* _tmp88_;
								ValaParameter* _tmp89_;
								ValaConstructor* _tmp90_;
								ValaMemberBinding _tmp91_;
								ValaMemberBinding _tmp92_;
								_tmp84_ = sym;
								_tmp85_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp84_, VALA_TYPE_CONSTRUCTOR, ValaConstructor));
								c = _tmp85_;
								_tmp86_ = c;
								_tmp87_ = vala_constructor_get_this_parameter (_tmp86_);
								_tmp88_ = _tmp87_;
								_tmp89_ = _vala_code_node_ref0 (_tmp88_);
								_vala_code_node_unref0 (this_parameter);
								this_parameter = _tmp89_;
								_tmp90_ = c;
								_tmp91_ = vala_constructor_get_binding (_tmp90_);
								_tmp92_ = _tmp91_;
								may_access_instance_members = _tmp92_ == VALA_MEMBER_BINDING_INSTANCE;
								may_access_klass_members = TRUE;
								method_found = TRUE;
								_vala_code_node_unref0 (c);
							} else {
								ValaSymbol* _tmp93_;
								_tmp93_ = sym;
								if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp93_, VALA_TYPE_DESTRUCTOR)) {
									ValaDestructor* d = NULL;
									ValaSymbol* _tmp94_;
									ValaDestructor* _tmp95_;
									ValaDestructor* _tmp96_;
									ValaParameter* _tmp97_;
									ValaParameter* _tmp98_;
									ValaParameter* _tmp99_;
									ValaDestructor* _tmp100_;
									ValaMemberBinding _tmp101_;
									ValaMemberBinding _tmp102_;
									_tmp94_ = sym;
									_tmp95_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp94_, VALA_TYPE_DESTRUCTOR, ValaDestructor));
									d = _tmp95_;
									_tmp96_ = d;
									_tmp97_ = vala_destructor_get_this_parameter (_tmp96_);
									_tmp98_ = _tmp97_;
									_tmp99_ = _vala_code_node_ref0 (_tmp98_);
									_vala_code_node_unref0 (this_parameter);
									this_parameter = _tmp99_;
									_tmp100_ = d;
									_tmp101_ = vala_destructor_get_binding (_tmp100_);
									_tmp102_ = _tmp101_;
									may_access_instance_members = _tmp102_ == VALA_MEMBER_BINDING_INSTANCE;
									may_access_klass_members = TRUE;
									method_found = TRUE;
									_vala_code_node_unref0 (d);
								} else {
									ValaSymbol* _tmp103_;
									_tmp103_ = sym;
									if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp103_, VALA_TYPE_METHOD)) {
										ValaMethod* m = NULL;
										ValaSymbol* _tmp104_;
										ValaMethod* _tmp105_;
										ValaMethod* _tmp106_;
										ValaParameter* _tmp107_;
										ValaParameter* _tmp108_;
										ValaParameter* _tmp109_;
										ValaMethod* _tmp110_;
										ValaMemberBinding _tmp111_;
										ValaMemberBinding _tmp112_;
										ValaMethod* _tmp113_;
										ValaMemberBinding _tmp114_;
										ValaMemberBinding _tmp115_;
										_tmp104_ = sym;
										_tmp105_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp104_, VALA_TYPE_METHOD, ValaMethod));
										m = _tmp105_;
										_tmp106_ = m;
										_tmp107_ = vala_method_get_this_parameter (_tmp106_);
										_tmp108_ = _tmp107_;
										_tmp109_ = _vala_code_node_ref0 (_tmp108_);
										_vala_code_node_unref0 (this_parameter);
										this_parameter = _tmp109_;
										_tmp110_ = m;
										_tmp111_ = vala_method_get_binding (_tmp110_);
										_tmp112_ = _tmp111_;
										may_access_instance_members = _tmp112_ == VALA_MEMBER_BINDING_INSTANCE;
										_tmp113_ = m;
										_tmp114_ = vala_method_get_binding (_tmp113_);
										_tmp115_ = _tmp114_;
										may_access_klass_members = _tmp115_ != VALA_MEMBER_BINDING_STATIC;
										method_found = TRUE;
										_vala_code_node_unref0 (m);
									}
								}
							}
						}
					}
				}
				_tmp116_ = sym;
				_tmp117_ = self->priv->_member_name;
				_tmp118_ = vala_semantic_analyzer_symbol_lookup_inherited (_tmp116_, _tmp117_);
				_tmp119_ = _tmp118_;
				vala_expression_set_symbol_reference ((ValaExpression*) self, _tmp119_);
				_vala_code_node_unref0 (_tmp119_);
				_tmp122_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
				_tmp123_ = _tmp122_;
				if (_tmp123_ == NULL) {
					ValaSymbol* _tmp124_;
					_tmp124_ = sym;
					_tmp121_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp124_, VALA_TYPE_TYPESYMBOL);
				} else {
					_tmp121_ = FALSE;
				}
				if (_tmp121_) {
					gboolean _tmp125_;
					_tmp125_ = may_access_instance_members;
					_tmp120_ = _tmp125_;
				} else {
					_tmp120_ = FALSE;
				}
				if (_tmp120_) {
					ValaParameter* _tmp126_;
					ValaDataType* _tmp127_;
					ValaDataType* _tmp128_;
					const gchar* _tmp129_;
					ValaSymbol* _tmp130_;
					ValaSymbol* _tmp131_;
					gboolean _tmp132_ = FALSE;
					ValaSymbol* _tmp133_;
					ValaSymbol* _tmp134_;
					_tmp126_ = this_parameter;
					_tmp127_ = vala_variable_get_variable_type ((ValaVariable*) _tmp126_);
					_tmp128_ = _tmp127_;
					_tmp129_ = self->priv->_member_name;
					_tmp130_ = vala_data_type_get_member (_tmp128_, _tmp129_);
					_tmp131_ = _tmp130_;
					vala_expression_set_symbol_reference ((ValaExpression*) self, _tmp131_);
					_vala_code_node_unref0 (_tmp131_);
					_tmp133_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
					_tmp134_ = _tmp133_;
					if (_tmp134_ != NULL) {
						ValaSymbol* _tmp135_;
						ValaSymbol* _tmp136_;
						gboolean _tmp137_;
						_tmp135_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
						_tmp136_ = _tmp135_;
						_tmp137_ = vala_member_access_is_instance_symbol (_tmp136_);
						_tmp132_ = _tmp137_;
					} else {
						_tmp132_ = FALSE;
					}
					if (_tmp132_) {
						ValaSourceReference* _tmp138_;
						ValaSourceReference* _tmp139_;
						ValaMemberAccess* _tmp140_;
						ValaMemberAccess* _tmp141_;
						ValaExpression* _tmp142_;
						ValaExpression* _tmp143_;
						ValaParameter* _tmp144_;
						ValaDataType* _tmp145_;
						ValaDataType* _tmp146_;
						ValaDataType* _tmp147_;
						ValaDataType* _tmp148_;
						ValaExpression* _tmp149_;
						ValaExpression* _tmp150_;
						ValaDataType* _tmp151_;
						ValaDataType* _tmp152_;
						ValaExpression* _tmp153_;
						ValaExpression* _tmp154_;
						ValaParameter* _tmp155_;
						ValaExpression* _tmp156_;
						ValaExpression* _tmp157_;
						ValaDataType* _tmp158_;
						ValaDataType* _tmp159_;
						const gchar* _tmp160_;
						ValaSymbol* _tmp161_;
						ValaSymbol* _tmp162_;
						_tmp138_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
						_tmp139_ = _tmp138_;
						_tmp140_ = vala_member_access_new (NULL, "this", _tmp139_);
						_tmp141_ = _tmp140_;
						vala_member_access_set_inner (self, (ValaExpression*) _tmp141_);
						_vala_code_node_unref0 (_tmp141_);
						_tmp142_ = vala_member_access_get_inner (self);
						_tmp143_ = _tmp142_;
						_tmp144_ = this_parameter;
						_tmp145_ = vala_variable_get_variable_type ((ValaVariable*) _tmp144_);
						_tmp146_ = _tmp145_;
						_tmp147_ = vala_data_type_copy (_tmp146_);
						_tmp148_ = _tmp147_;
						vala_expression_set_value_type (_tmp143_, _tmp148_);
						_vala_code_node_unref0 (_tmp148_);
						_tmp149_ = vala_member_access_get_inner (self);
						_tmp150_ = _tmp149_;
						_tmp151_ = vala_expression_get_value_type (_tmp150_);
						_tmp152_ = _tmp151_;
						vala_data_type_set_value_owned (_tmp152_, FALSE);
						_tmp153_ = vala_member_access_get_inner (self);
						_tmp154_ = _tmp153_;
						_tmp155_ = this_parameter;
						vala_expression_set_symbol_reference (_tmp154_, (ValaSymbol*) _tmp155_);
						_tmp156_ = vala_member_access_get_inner (self);
						_tmp157_ = _tmp156_;
						_tmp158_ = vala_expression_get_value_type (_tmp157_);
						_tmp159_ = _tmp158_;
						_tmp160_ = self->priv->_member_name;
						_tmp161_ = vala_data_type_get_member (_tmp159_, _tmp160_);
						_tmp162_ = _tmp161_;
						vala_expression_set_symbol_reference ((ValaExpression*) self, _tmp162_);
						_vala_code_node_unref0 (_tmp162_);
					}
				}
				_tmp163_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
				_tmp164_ = _tmp163_;
				if (_tmp164_ == NULL) {
					ValaSymbol* _tmp165_;
					_tmp165_ = sym;
					if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp165_, VALA_TYPE_TYPESYMBOL)) {
						_vala_code_node_unref0 (this_parameter);
						this_parameter = NULL;
						may_access_instance_members = FALSE;
						may_access_klass_members = FALSE;
					}
				}
				_tmp166_ = sym;
				_tmp167_ = vala_symbol_get_parent_symbol (_tmp166_);
				_tmp168_ = _tmp167_;
				_tmp169_ = _vala_code_node_ref0 (_tmp168_);
				_vala_code_node_unref0 (sym);
				sym = _tmp169_;
			}
			_tmp171_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
			_tmp172_ = _tmp171_;
			if (_tmp172_ == NULL) {
				ValaSourceReference* _tmp173_;
				ValaSourceReference* _tmp174_;
				_tmp173_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
				_tmp174_ = _tmp173_;
				_tmp170_ = _tmp174_ != NULL;
			} else {
				_tmp170_ = FALSE;
			}
			if (_tmp170_) {
				{
					ValaList* _ns_list = NULL;
					ValaSourceReference* _tmp175_;
					ValaSourceReference* _tmp176_;
					ValaList* _tmp177_;
					ValaList* _tmp178_;
					ValaList* _tmp179_;
					gint _ns_size = 0;
					ValaList* _tmp180_;
					gint _tmp181_;
					gint _tmp182_;
					gint _ns_index = 0;
					_tmp175_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
					_tmp176_ = _tmp175_;
					_tmp177_ = vala_source_reference_get_using_directives (_tmp176_);
					_tmp178_ = _tmp177_;
					_tmp179_ = _vala_iterable_ref0 (_tmp178_);
					_ns_list = _tmp179_;
					_tmp180_ = _ns_list;
					_tmp181_ = vala_collection_get_size ((ValaCollection*) _tmp180_);
					_tmp182_ = _tmp181_;
					_ns_size = _tmp182_;
					_ns_index = -1;
					while (TRUE) {
						gint _tmp183_;
						gint _tmp184_;
						gint _tmp185_;
						ValaUsingDirective* ns = NULL;
						ValaList* _tmp186_;
						gint _tmp187_;
						gpointer _tmp188_;
						ValaSymbol* local_sym = NULL;
						ValaUsingDirective* _tmp189_;
						ValaSymbol* _tmp190_;
						ValaSymbol* _tmp191_;
						ValaScope* _tmp192_;
						ValaScope* _tmp193_;
						const gchar* _tmp194_;
						ValaSymbol* _tmp195_;
						ValaSymbol* _tmp196_;
						_tmp183_ = _ns_index;
						_ns_index = _tmp183_ + 1;
						_tmp184_ = _ns_index;
						_tmp185_ = _ns_size;
						if (!(_tmp184_ < _tmp185_)) {
							break;
						}
						_tmp186_ = _ns_list;
						_tmp187_ = _ns_index;
						_tmp188_ = vala_list_get (_tmp186_, _tmp187_);
						ns = (ValaUsingDirective*) _tmp188_;
						_tmp189_ = ns;
						_tmp190_ = vala_using_directive_get_namespace_symbol (_tmp189_);
						_tmp191_ = _tmp190_;
						_tmp192_ = vala_symbol_get_scope (_tmp191_);
						_tmp193_ = _tmp192_;
						_tmp194_ = self->priv->_member_name;
						_tmp195_ = vala_scope_lookup (_tmp193_, _tmp194_);
						local_sym = _tmp195_;
						_tmp196_ = local_sym;
						if (_tmp196_ != NULL) {
							gboolean _tmp197_ = FALSE;
							ValaSymbol* _tmp198_;
							ValaSymbol* _tmp199_;
							ValaSymbol* _tmp215_;
							_tmp198_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
							_tmp199_ = _tmp198_;
							if (_tmp199_ != NULL) {
								ValaSymbol* _tmp200_;
								ValaSymbol* _tmp201_;
								ValaSymbol* _tmp202_;
								_tmp200_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
								_tmp201_ = _tmp200_;
								_tmp202_ = local_sym;
								_tmp197_ = _tmp201_ != _tmp202_;
							} else {
								_tmp197_ = FALSE;
							}
							if (_tmp197_) {
								ValaSourceReference* _tmp203_;
								ValaSourceReference* _tmp204_;
								const gchar* _tmp205_;
								ValaSymbol* _tmp206_;
								ValaSymbol* _tmp207_;
								gchar* _tmp208_;
								gchar* _tmp209_;
								ValaSymbol* _tmp210_;
								gchar* _tmp211_;
								gchar* _tmp212_;
								gchar* _tmp213_;
								gchar* _tmp214_;
								vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
								_tmp203_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
								_tmp204_ = _tmp203_;
								_tmp205_ = self->priv->_member_name;
								_tmp206_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
								_tmp207_ = _tmp206_;
								_tmp208_ = vala_symbol_get_full_name (_tmp207_);
								_tmp209_ = _tmp208_;
								_tmp210_ = local_sym;
								_tmp211_ = vala_symbol_get_full_name (_tmp210_);
								_tmp212_ = _tmp211_;
								_tmp213_ = g_strdup_printf ("`%s' is an ambiguous reference between `%s' and `%s'", _tmp205_, _tmp209_, _tmp212_);
								_tmp214_ = _tmp213_;
								vala_report_error (_tmp204_, _tmp214_);
								_g_free0 (_tmp214_);
								_g_free0 (_tmp212_);
								_g_free0 (_tmp209_);
								result = FALSE;
								_vala_code_node_unref0 (local_sym);
								_vala_code_node_unref0 (ns);
								_vala_iterable_unref0 (_ns_list);
								_vala_code_node_unref0 (sym);
								_vala_code_node_unref0 (this_parameter);
								_vala_code_node_unref0 (base_symbol);
								return result;
							}
							_tmp215_ = local_sym;
							vala_expression_set_symbol_reference ((ValaExpression*) self, _tmp215_);
						}
						_vala_code_node_unref0 (local_sym);
						_vala_code_node_unref0 (ns);
					}
					_vala_iterable_unref0 (_ns_list);
				}
			}
			_vala_code_node_unref0 (sym);
		} else {
			ValaExpression* _tmp216_;
			ValaExpression* _tmp217_;
			gboolean _tmp218_;
			gboolean _tmp219_;
			ValaExpression* _tmp220_;
			ValaExpression* _tmp221_;
			ValaDataType* _tmp222_;
			ValaDataType* _tmp223_;
			ValaExpression* _tmp243_;
			ValaExpression* _tmp244_;
			gboolean _tmp260_ = FALSE;
			ValaExpression* _tmp261_;
			ValaExpression* _tmp262_;
			gboolean _tmp284_ = FALSE;
			ValaSymbol* _tmp285_;
			ValaSymbol* _tmp286_;
			gboolean _tmp321_ = FALSE;
			gboolean _tmp322_ = FALSE;
			ValaSymbol* _tmp323_;
			ValaSymbol* _tmp324_;
			_tmp216_ = vala_member_access_get_inner (self);
			_tmp217_ = _tmp216_;
			_tmp218_ = vala_code_node_get_error ((ValaCodeNode*) _tmp217_);
			_tmp219_ = _tmp218_;
			if (_tmp219_) {
				vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
				result = FALSE;
				_vala_code_node_unref0 (this_parameter);
				_vala_code_node_unref0 (base_symbol);
				return result;
			}
			_tmp220_ = vala_member_access_get_inner (self);
			_tmp221_ = _tmp220_;
			_tmp222_ = vala_expression_get_value_type (_tmp221_);
			_tmp223_ = _tmp222_;
			if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp223_, VALA_TYPE_POINTER_TYPE)) {
				ValaPointerType* pointer_type = NULL;
				ValaExpression* _tmp224_;
				ValaExpression* _tmp225_;
				ValaDataType* _tmp226_;
				ValaDataType* _tmp227_;
				ValaPointerType* _tmp228_;
				gboolean _tmp229_ = FALSE;
				ValaPointerType* _tmp230_;
				_tmp224_ = vala_member_access_get_inner (self);
				_tmp225_ = _tmp224_;
				_tmp226_ = vala_expression_get_value_type (_tmp225_);
				_tmp227_ = _tmp226_;
				_tmp228_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp227_, VALA_TYPE_POINTER_TYPE) ? ((ValaPointerType*) _tmp227_) : NULL);
				pointer_type = _tmp228_;
				_tmp230_ = pointer_type;
				if (_tmp230_ != NULL) {
					ValaPointerType* _tmp231_;
					ValaDataType* _tmp232_;
					ValaDataType* _tmp233_;
					_tmp231_ = pointer_type;
					_tmp232_ = vala_pointer_type_get_base_type (_tmp231_);
					_tmp233_ = _tmp232_;
					_tmp229_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp233_, VALA_TYPE_VALUE_TYPE);
				} else {
					_tmp229_ = FALSE;
				}
				if (_tmp229_) {
					ValaExpression* _tmp234_;
					ValaExpression* _tmp235_;
					ValaSourceReference* _tmp236_;
					ValaSourceReference* _tmp237_;
					ValaPointerIndirection* _tmp238_;
					ValaPointerIndirection* _tmp239_;
					ValaExpression* _tmp240_;
					ValaExpression* _tmp241_;
					ValaCodeContext* _tmp242_;
					_tmp234_ = vala_member_access_get_inner (self);
					_tmp235_ = _tmp234_;
					_tmp236_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
					_tmp237_ = _tmp236_;
					_tmp238_ = vala_pointer_indirection_new (_tmp235_, _tmp237_);
					_tmp239_ = _tmp238_;
					vala_member_access_set_inner (self, (ValaExpression*) _tmp239_);
					_vala_code_node_unref0 (_tmp239_);
					_tmp240_ = vala_member_access_get_inner (self);
					_tmp241_ = _tmp240_;
					_tmp242_ = context;
					vala_code_node_check ((ValaCodeNode*) _tmp241_, _tmp242_);
					vala_member_access_set_pointer_member_access (self, FALSE);
				}
				_vala_code_node_unref0 (pointer_type);
			}
			_tmp243_ = vala_member_access_get_inner (self);
			_tmp244_ = _tmp243_;
			if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp244_, VALA_TYPE_MEMBER_ACCESS)) {
				ValaMemberAccess* ma = NULL;
				ValaExpression* _tmp245_;
				ValaExpression* _tmp246_;
				ValaMemberAccess* _tmp247_;
				ValaMemberAccess* _tmp248_;
				gboolean _tmp249_;
				_tmp245_ = vala_member_access_get_inner (self);
				_tmp246_ = _tmp245_;
				_tmp247_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp246_, VALA_TYPE_MEMBER_ACCESS, ValaMemberAccess));
				ma = _tmp247_;
				_tmp248_ = ma;
				_tmp249_ = _tmp248_->priv->_prototype_access;
				if (_tmp249_) {
					ValaSourceReference* _tmp250_;
					ValaSourceReference* _tmp251_;
					ValaExpression* _tmp252_;
					ValaExpression* _tmp253_;
					ValaSymbol* _tmp254_;
					ValaSymbol* _tmp255_;
					gchar* _tmp256_;
					gchar* _tmp257_;
					gchar* _tmp258_;
					gchar* _tmp259_;
					vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
					_tmp250_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
					_tmp251_ = _tmp250_;
					_tmp252_ = vala_member_access_get_inner (self);
					_tmp253_ = _tmp252_;
					_tmp254_ = vala_expression_get_symbol_reference (_tmp253_);
					_tmp255_ = _tmp254_;
					_tmp256_ = vala_symbol_get_full_name (_tmp255_);
					_tmp257_ = _tmp256_;
					_tmp258_ = g_strdup_printf ("Access to instance member `%s' denied", _tmp257_);
					_tmp259_ = _tmp258_;
					vala_report_error (_tmp251_, _tmp259_);
					_g_free0 (_tmp259_);
					_g_free0 (_tmp257_);
					result = FALSE;
					_vala_code_node_unref0 (ma);
					_vala_code_node_unref0 (this_parameter);
					_vala_code_node_unref0 (base_symbol);
					return result;
				}
				_vala_code_node_unref0 (ma);
			}
			_tmp261_ = vala_member_access_get_inner (self);
			_tmp262_ = _tmp261_;
			if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp262_, VALA_TYPE_MEMBER_ACCESS)) {
				_tmp260_ = TRUE;
			} else {
				ValaExpression* _tmp263_;
				ValaExpression* _tmp264_;
				_tmp263_ = vala_member_access_get_inner (self);
				_tmp264_ = _tmp263_;
				_tmp260_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp264_, VALA_TYPE_BASE_ACCESS);
			}
			if (_tmp260_) {
				ValaExpression* _tmp265_;
				ValaExpression* _tmp266_;
				ValaSymbol* _tmp267_;
				ValaSymbol* _tmp268_;
				ValaSymbol* _tmp269_;
				gboolean _tmp270_ = FALSE;
				ValaSymbol* _tmp271_;
				ValaSymbol* _tmp272_;
				_tmp265_ = vala_member_access_get_inner (self);
				_tmp266_ = _tmp265_;
				_tmp267_ = vala_expression_get_symbol_reference (_tmp266_);
				_tmp268_ = _tmp267_;
				_tmp269_ = _vala_code_node_ref0 (_tmp268_);
				_vala_code_node_unref0 (base_symbol);
				base_symbol = _tmp269_;
				_tmp271_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
				_tmp272_ = _tmp271_;
				if (_tmp272_ == NULL) {
					gboolean _tmp273_ = FALSE;
					ValaSymbol* _tmp274_;
					_tmp274_ = base_symbol;
					if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp274_, VALA_TYPE_NAMESPACE)) {
						_tmp273_ = TRUE;
					} else {
						ValaSymbol* _tmp275_;
						_tmp275_ = base_symbol;
						_tmp273_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp275_, VALA_TYPE_TYPESYMBOL);
					}
					_tmp270_ = _tmp273_;
				} else {
					_tmp270_ = FALSE;
				}
				if (_tmp270_) {
					ValaSymbol* _tmp276_;
					ValaScope* _tmp277_;
					ValaScope* _tmp278_;
					const gchar* _tmp279_;
					ValaSymbol* _tmp280_;
					ValaSymbol* _tmp281_;
					ValaExpression* _tmp282_;
					ValaExpression* _tmp283_;
					_tmp276_ = base_symbol;
					_tmp277_ = vala_symbol_get_scope (_tmp276_);
					_tmp278_ = _tmp277_;
					_tmp279_ = self->priv->_member_name;
					_tmp280_ = vala_scope_lookup (_tmp278_, _tmp279_);
					_tmp281_ = _tmp280_;
					vala_expression_set_symbol_reference ((ValaExpression*) self, _tmp281_);
					_vala_code_node_unref0 (_tmp281_);
					_tmp282_ = vala_member_access_get_inner (self);
					_tmp283_ = _tmp282_;
					if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp283_, VALA_TYPE_BASE_ACCESS)) {
						may_access_instance_members = TRUE;
						may_access_klass_members = TRUE;
					}
				}
			}
			_tmp285_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
			_tmp286_ = _tmp285_;
			if (_tmp286_ == NULL) {
				ValaExpression* _tmp287_;
				ValaExpression* _tmp288_;
				ValaDataType* _tmp289_;
				ValaDataType* _tmp290_;
				_tmp287_ = vala_member_access_get_inner (self);
				_tmp288_ = _tmp287_;
				_tmp289_ = vala_expression_get_value_type (_tmp288_);
				_tmp290_ = _tmp289_;
				_tmp284_ = _tmp290_ != NULL;
			} else {
				_tmp284_ = FALSE;
			}
			if (_tmp284_) {
				gboolean _tmp291_;
				ValaSymbol* _tmp319_;
				ValaSymbol* _tmp320_;
				_tmp291_ = self->priv->_pointer_member_access;
				if (_tmp291_) {
					ValaExpression* _tmp292_;
					ValaExpression* _tmp293_;
					ValaDataType* _tmp294_;
					ValaDataType* _tmp295_;
					const gchar* _tmp296_;
					ValaSymbol* _tmp297_;
					ValaSymbol* _tmp298_;
					_tmp292_ = vala_member_access_get_inner (self);
					_tmp293_ = _tmp292_;
					_tmp294_ = vala_expression_get_value_type (_tmp293_);
					_tmp295_ = _tmp294_;
					_tmp296_ = self->priv->_member_name;
					_tmp297_ = vala_data_type_get_pointer_member (_tmp295_, _tmp296_);
					_tmp298_ = _tmp297_;
					vala_expression_set_symbol_reference ((ValaExpression*) self, _tmp298_);
					_vala_code_node_unref0 (_tmp298_);
				} else {
					ValaExpression* _tmp299_;
					ValaExpression* _tmp300_;
					ValaDataType* _tmp301_;
					ValaDataType* _tmp302_;
					ValaTypeSymbol* _tmp303_;
					ValaTypeSymbol* _tmp304_;
					ValaExpression* _tmp312_;
					ValaExpression* _tmp313_;
					ValaDataType* _tmp314_;
					ValaDataType* _tmp315_;
					const gchar* _tmp316_;
					ValaSymbol* _tmp317_;
					ValaSymbol* _tmp318_;
					_tmp299_ = vala_member_access_get_inner (self);
					_tmp300_ = _tmp299_;
					_tmp301_ = vala_expression_get_value_type (_tmp300_);
					_tmp302_ = _tmp301_;
					_tmp303_ = vala_data_type_get_data_type (_tmp302_);
					_tmp304_ = _tmp303_;
					if (_tmp304_ != NULL) {
						ValaExpression* _tmp305_;
						ValaExpression* _tmp306_;
						ValaDataType* _tmp307_;
						ValaDataType* _tmp308_;
						ValaTypeSymbol* _tmp309_;
						ValaTypeSymbol* _tmp310_;
						ValaSymbol* _tmp311_;
						_tmp305_ = vala_member_access_get_inner (self);
						_tmp306_ = _tmp305_;
						_tmp307_ = vala_expression_get_value_type (_tmp306_);
						_tmp308_ = _tmp307_;
						_tmp309_ = vala_data_type_get_data_type (_tmp308_);
						_tmp310_ = _tmp309_;
						_tmp311_ = _vala_code_node_ref0 ((ValaSymbol*) _tmp310_);
						_vala_code_node_unref0 (base_symbol);
						base_symbol = _tmp311_;
					}
					_tmp312_ = vala_member_access_get_inner (self);
					_tmp313_ = _tmp312_;
					_tmp314_ = vala_expression_get_value_type (_tmp313_);
					_tmp315_ = _tmp314_;
					_tmp316_ = self->priv->_member_name;
					_tmp317_ = vala_data_type_get_member (_tmp315_, _tmp316_);
					_tmp318_ = _tmp317_;
					vala_expression_set_symbol_reference ((ValaExpression*) self, _tmp318_);
					_vala_code_node_unref0 (_tmp318_);
				}
				_tmp319_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
				_tmp320_ = _tmp319_;
				if (_tmp320_ != NULL) {
					may_access_instance_members = TRUE;
					may_access_klass_members = TRUE;
				}
			}
			_tmp323_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
			_tmp324_ = _tmp323_;
			if (_tmp324_ == NULL) {
				ValaExpression* _tmp325_;
				ValaExpression* _tmp326_;
				ValaDataType* _tmp327_;
				ValaDataType* _tmp328_;
				_tmp325_ = vala_member_access_get_inner (self);
				_tmp326_ = _tmp325_;
				_tmp327_ = vala_expression_get_value_type (_tmp326_);
				_tmp328_ = _tmp327_;
				_tmp322_ = _tmp328_ != NULL;
			} else {
				_tmp322_ = FALSE;
			}
			if (_tmp322_) {
				ValaExpression* _tmp329_;
				ValaExpression* _tmp330_;
				ValaDataType* _tmp331_;
				ValaDataType* _tmp332_;
				gboolean _tmp333_;
				gboolean _tmp334_;
				_tmp329_ = vala_member_access_get_inner (self);
				_tmp330_ = _tmp329_;
				_tmp331_ = vala_expression_get_value_type (_tmp330_);
				_tmp332_ = _tmp331_;
				_tmp333_ = vala_data_type_get_is_dynamic (_tmp332_);
				_tmp334_ = _tmp333_;
				_tmp321_ = _tmp334_;
			} else {
				_tmp321_ = FALSE;
			}
			if (_tmp321_) {
				ValaObjectType* dynamic_object_type = NULL;
				ValaExpression* _tmp335_;
				ValaExpression* _tmp336_;
				ValaDataType* _tmp337_;
				ValaDataType* _tmp338_;
				ValaObjectType* _tmp339_;
				ValaCodeNode* _tmp340_;
				ValaCodeNode* _tmp341_;
				ValaSymbol* _tmp518_;
				ValaSymbol* _tmp519_;
				ValaSymbol* _tmp568_;
				ValaSymbol* _tmp569_;
				_tmp335_ = vala_member_access_get_inner (self);
				_tmp336_ = _tmp335_;
				_tmp337_ = vala_expression_get_value_type (_tmp336_);
				_tmp338_ = _tmp337_;
				_tmp339_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp338_, VALA_TYPE_OBJECT_TYPE, ValaObjectType));
				dynamic_object_type = _tmp339_;
				_tmp340_ = vala_code_node_get_parent_node ((ValaCodeNode*) self);
				_tmp341_ = _tmp340_;
				if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp341_, VALA_TYPE_METHOD_CALL)) {
					ValaMethodCall* invoc = NULL;
					ValaCodeNode* _tmp342_;
					ValaCodeNode* _tmp343_;
					ValaMethodCall* _tmp344_;
					ValaMethodCall* _tmp345_;
					ValaExpression* _tmp346_;
					ValaExpression* _tmp347_;
					_tmp342_ = vala_code_node_get_parent_node ((ValaCodeNode*) self);
					_tmp343_ = _tmp342_;
					_tmp344_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp343_, VALA_TYPE_METHOD_CALL, ValaMethodCall));
					invoc = _tmp344_;
					_tmp345_ = invoc;
					_tmp346_ = vala_method_call_get_call (_tmp345_);
					_tmp347_ = _tmp346_;
					if (_tmp347_ == G_TYPE_CHECK_INSTANCE_CAST (self, VALA_TYPE_EXPRESSION, ValaExpression)) {
						ValaDataType* ret_type = NULL;
						ValaMethodCall* _tmp348_;
						ValaDataType* _tmp349_;
						ValaDataType* _tmp350_;
						ValaDynamicMethod* m = NULL;
						ValaExpression* _tmp365_;
						ValaExpression* _tmp366_;
						ValaDataType* _tmp367_;
						ValaDataType* _tmp368_;
						const gchar* _tmp369_;
						ValaDataType* _tmp370_;
						ValaSourceReference* _tmp371_;
						ValaSourceReference* _tmp372_;
						ValaDynamicMethod* _tmp373_;
						ValaDynamicMethod* _tmp374_;
						ValaMethodCall* _tmp375_;
						ValaErrorType* err = NULL;
						ValaErrorType* _tmp376_;
						ValaErrorType* _tmp377_;
						ValaDynamicMethod* _tmp378_;
						ValaErrorType* _tmp379_;
						ValaDynamicMethod* _tmp380_;
						ValaDynamicMethod* _tmp381_;
						ValaParameter* _tmp382_;
						ValaParameter* _tmp383_;
						ValaObjectType* _tmp384_;
						ValaObjectTypeSymbol* _tmp385_;
						ValaObjectTypeSymbol* _tmp386_;
						ValaScope* _tmp387_;
						ValaScope* _tmp388_;
						ValaDynamicMethod* _tmp389_;
						ValaDynamicMethod* _tmp390_;
						_tmp348_ = invoc;
						_tmp349_ = vala_expression_get_target_type ((ValaExpression*) _tmp348_);
						_tmp350_ = _tmp349_;
						if (_tmp350_ != NULL) {
							ValaMethodCall* _tmp351_;
							ValaDataType* _tmp352_;
							ValaDataType* _tmp353_;
							ValaDataType* _tmp354_;
							ValaDataType* _tmp355_;
							_tmp351_ = invoc;
							_tmp352_ = vala_expression_get_target_type ((ValaExpression*) _tmp351_);
							_tmp353_ = _tmp352_;
							_tmp354_ = vala_data_type_copy (_tmp353_);
							_vala_code_node_unref0 (ret_type);
							ret_type = _tmp354_;
							_tmp355_ = ret_type;
							vala_data_type_set_value_owned (_tmp355_, TRUE);
						} else {
							ValaMethodCall* _tmp356_;
							ValaCodeNode* _tmp357_;
							ValaCodeNode* _tmp358_;
							_tmp356_ = invoc;
							_tmp357_ = vala_code_node_get_parent_node ((ValaCodeNode*) _tmp356_);
							_tmp358_ = _tmp357_;
							if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp358_, VALA_TYPE_EXPRESSION_STATEMENT)) {
								ValaVoidType* _tmp359_;
								_tmp359_ = vala_void_type_new (NULL);
								_vala_code_node_unref0 (ret_type);
								ret_type = (ValaDataType*) _tmp359_;
							} else {
								ValaExpression* _tmp360_;
								ValaExpression* _tmp361_;
								ValaDataType* _tmp362_;
								ValaDataType* _tmp363_;
								ValaDataType* _tmp364_;
								_tmp360_ = vala_member_access_get_inner (self);
								_tmp361_ = _tmp360_;
								_tmp362_ = vala_expression_get_value_type (_tmp361_);
								_tmp363_ = _tmp362_;
								_tmp364_ = vala_data_type_copy (_tmp363_);
								_vala_code_node_unref0 (ret_type);
								ret_type = _tmp364_;
							}
						}
						_tmp365_ = vala_member_access_get_inner (self);
						_tmp366_ = _tmp365_;
						_tmp367_ = vala_expression_get_value_type (_tmp366_);
						_tmp368_ = _tmp367_;
						_tmp369_ = self->priv->_member_name;
						_tmp370_ = ret_type;
						_tmp371_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
						_tmp372_ = _tmp371_;
						_tmp373_ = vala_dynamic_method_new (_tmp368_, _tmp369_, _tmp370_, _tmp372_, NULL);
						m = _tmp373_;
						_tmp374_ = m;
						_tmp375_ = invoc;
						vala_dynamic_method_set_invocation (_tmp374_, _tmp375_);
						_tmp376_ = vala_error_type_new (NULL, NULL, NULL);
						err = _tmp376_;
						_tmp377_ = err;
						vala_error_type_set_dynamic_error (_tmp377_, TRUE);
						_tmp378_ = m;
						_tmp379_ = err;
						vala_code_node_add_error_type ((ValaCodeNode*) _tmp378_, (ValaDataType*) _tmp379_);
						_tmp380_ = m;
						vala_symbol_set_access ((ValaSymbol*) _tmp380_, VALA_SYMBOL_ACCESSIBILITY_PUBLIC);
						_tmp381_ = m;
						_tmp382_ = vala_parameter_new_with_ellipsis (NULL);
						_tmp383_ = _tmp382_;
						vala_callable_add_parameter ((ValaCallable*) _tmp381_, _tmp383_);
						_vala_code_node_unref0 (_tmp383_);
						_tmp384_ = dynamic_object_type;
						_tmp385_ = vala_object_type_get_type_symbol (_tmp384_);
						_tmp386_ = _tmp385_;
						_tmp387_ = vala_symbol_get_scope ((ValaSymbol*) _tmp386_);
						_tmp388_ = _tmp387_;
						_tmp389_ = m;
						vala_scope_add (_tmp388_, NULL, (ValaSymbol*) _tmp389_);
						_tmp390_ = m;
						vala_expression_set_symbol_reference ((ValaExpression*) self, (ValaSymbol*) _tmp390_);
						_vala_code_node_unref0 (err);
						_vala_code_node_unref0 (m);
						_vala_code_node_unref0 (ret_type);
					}
					_vala_code_node_unref0 (invoc);
				} else {
					ValaCodeNode* _tmp391_;
					ValaCodeNode* _tmp392_;
					_tmp391_ = vala_code_node_get_parent_node ((ValaCodeNode*) self);
					_tmp392_ = _tmp391_;
					if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp392_, VALA_TYPE_ASSIGNMENT)) {
						ValaAssignment* a = NULL;
						ValaCodeNode* _tmp393_;
						ValaCodeNode* _tmp394_;
						ValaAssignment* _tmp395_;
						gboolean _tmp396_ = FALSE;
						ValaAssignment* _tmp397_;
						ValaExpression* _tmp398_;
						ValaExpression* _tmp399_;
						_tmp393_ = vala_code_node_get_parent_node ((ValaCodeNode*) self);
						_tmp394_ = _tmp393_;
						_tmp395_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp394_, VALA_TYPE_ASSIGNMENT, ValaAssignment));
						a = _tmp395_;
						_tmp397_ = a;
						_tmp398_ = vala_assignment_get_left (_tmp397_);
						_tmp399_ = _tmp398_;
						if (_tmp399_ == G_TYPE_CHECK_INSTANCE_CAST (self, VALA_TYPE_EXPRESSION, ValaExpression)) {
							gboolean _tmp400_ = FALSE;
							ValaAssignment* _tmp401_;
							ValaAssignmentOperator _tmp402_;
							ValaAssignmentOperator _tmp403_;
							_tmp401_ = a;
							_tmp402_ = vala_assignment_get_operator (_tmp401_);
							_tmp403_ = _tmp402_;
							if (_tmp403_ == VALA_ASSIGNMENT_OPERATOR_ADD) {
								_tmp400_ = TRUE;
							} else {
								ValaAssignment* _tmp404_;
								ValaAssignmentOperator _tmp405_;
								ValaAssignmentOperator _tmp406_;
								_tmp404_ = a;
								_tmp405_ = vala_assignment_get_operator (_tmp404_);
								_tmp406_ = _tmp405_;
								_tmp400_ = _tmp406_ == VALA_ASSIGNMENT_OPERATOR_SUB;
							}
							_tmp396_ = _tmp400_;
						} else {
							_tmp396_ = FALSE;
						}
						if (_tmp396_) {
							ValaDynamicSignal* s = NULL;
							ValaExpression* _tmp407_;
							ValaExpression* _tmp408_;
							ValaDataType* _tmp409_;
							ValaDataType* _tmp410_;
							const gchar* _tmp411_;
							ValaVoidType* _tmp412_;
							ValaVoidType* _tmp413_;
							ValaSourceReference* _tmp414_;
							ValaSourceReference* _tmp415_;
							ValaDynamicSignal* _tmp416_;
							ValaDynamicSignal* _tmp417_;
							ValaDynamicSignal* _tmp418_;
							ValaAssignment* _tmp419_;
							ValaExpression* _tmp420_;
							ValaExpression* _tmp421_;
							ValaDynamicSignal* _tmp422_;
							ValaObjectType* _tmp423_;
							ValaObjectTypeSymbol* _tmp424_;
							ValaObjectTypeSymbol* _tmp425_;
							ValaScope* _tmp426_;
							ValaScope* _tmp427_;
							ValaDynamicSignal* _tmp428_;
							ValaDynamicSignal* _tmp429_;
							_tmp407_ = vala_member_access_get_inner (self);
							_tmp408_ = _tmp407_;
							_tmp409_ = vala_expression_get_value_type (_tmp408_);
							_tmp410_ = _tmp409_;
							_tmp411_ = self->priv->_member_name;
							_tmp412_ = vala_void_type_new (NULL);
							_tmp413_ = _tmp412_;
							_tmp414_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
							_tmp415_ = _tmp414_;
							_tmp416_ = vala_dynamic_signal_new (_tmp410_, _tmp411_, (ValaDataType*) _tmp413_, _tmp415_, NULL);
							_tmp417_ = _tmp416_;
							_vala_code_node_unref0 (_tmp413_);
							s = _tmp417_;
							_tmp418_ = s;
							_tmp419_ = a;
							_tmp420_ = vala_assignment_get_right (_tmp419_);
							_tmp421_ = _tmp420_;
							vala_dynamic_signal_set_handler (_tmp418_, _tmp421_);
							_tmp422_ = s;
							vala_symbol_set_access ((ValaSymbol*) _tmp422_, VALA_SYMBOL_ACCESSIBILITY_PUBLIC);
							_tmp423_ = dynamic_object_type;
							_tmp424_ = vala_object_type_get_type_symbol (_tmp423_);
							_tmp425_ = _tmp424_;
							_tmp426_ = vala_symbol_get_scope ((ValaSymbol*) _tmp425_);
							_tmp427_ = _tmp426_;
							_tmp428_ = s;
							vala_scope_add (_tmp427_, NULL, (ValaSymbol*) _tmp428_);
							_tmp429_ = s;
							vala_expression_set_symbol_reference ((ValaExpression*) self, (ValaSymbol*) _tmp429_);
							_vala_code_node_unref0 (s);
						} else {
							ValaAssignment* _tmp430_;
							ValaExpression* _tmp431_;
							ValaExpression* _tmp432_;
							_tmp430_ = a;
							_tmp431_ = vala_assignment_get_left (_tmp430_);
							_tmp432_ = _tmp431_;
							if (_tmp432_ == G_TYPE_CHECK_INSTANCE_CAST (self, VALA_TYPE_EXPRESSION, ValaExpression)) {
								ValaDynamicProperty* prop = NULL;
								ValaExpression* _tmp433_;
								ValaExpression* _tmp434_;
								ValaDataType* _tmp435_;
								ValaDataType* _tmp436_;
								const gchar* _tmp437_;
								ValaSourceReference* _tmp438_;
								ValaSourceReference* _tmp439_;
								ValaDynamicProperty* _tmp440_;
								ValaDynamicProperty* _tmp441_;
								ValaDynamicProperty* _tmp442_;
								ValaDynamicProperty* _tmp443_;
								ValaSourceReference* _tmp444_;
								ValaSourceReference* _tmp445_;
								ValaPropertyAccessor* _tmp446_;
								ValaPropertyAccessor* _tmp447_;
								ValaDynamicProperty* _tmp448_;
								ValaExpression* _tmp449_;
								ValaExpression* _tmp450_;
								ValaDataType* _tmp451_;
								ValaDataType* _tmp452_;
								ValaTypeSymbol* _tmp453_;
								ValaTypeSymbol* _tmp454_;
								ValaScope* _tmp455_;
								ValaScope* _tmp456_;
								ValaObjectType* _tmp457_;
								ValaObjectTypeSymbol* _tmp458_;
								ValaObjectTypeSymbol* _tmp459_;
								ValaScope* _tmp460_;
								ValaScope* _tmp461_;
								ValaDynamicProperty* _tmp462_;
								ValaDynamicProperty* _tmp463_;
								_tmp433_ = vala_member_access_get_inner (self);
								_tmp434_ = _tmp433_;
								_tmp435_ = vala_expression_get_value_type (_tmp434_);
								_tmp436_ = _tmp435_;
								_tmp437_ = self->priv->_member_name;
								_tmp438_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
								_tmp439_ = _tmp438_;
								_tmp440_ = vala_dynamic_property_new (_tmp436_, _tmp437_, _tmp439_, NULL);
								prop = _tmp440_;
								_tmp441_ = prop;
								vala_symbol_set_access ((ValaSymbol*) _tmp441_, VALA_SYMBOL_ACCESSIBILITY_PUBLIC);
								_tmp442_ = prop;
								_tmp443_ = prop;
								_tmp444_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp443_);
								_tmp445_ = _tmp444_;
								_tmp446_ = vala_property_accessor_new (FALSE, TRUE, FALSE, NULL, NULL, _tmp445_, NULL);
								_tmp447_ = _tmp446_;
								vala_property_set_set_accessor ((ValaProperty*) _tmp442_, _tmp447_);
								_vala_code_node_unref0 (_tmp447_);
								_tmp448_ = prop;
								_tmp449_ = vala_member_access_get_inner (self);
								_tmp450_ = _tmp449_;
								_tmp451_ = vala_expression_get_value_type (_tmp450_);
								_tmp452_ = _tmp451_;
								_tmp453_ = vala_data_type_get_data_type (_tmp452_);
								_tmp454_ = _tmp453_;
								_tmp455_ = vala_symbol_get_scope ((ValaSymbol*) _tmp454_);
								_tmp456_ = _tmp455_;
								vala_symbol_set_owner ((ValaSymbol*) _tmp448_, _tmp456_);
								_tmp457_ = dynamic_object_type;
								_tmp458_ = vala_object_type_get_type_symbol (_tmp457_);
								_tmp459_ = _tmp458_;
								_tmp460_ = vala_symbol_get_scope ((ValaSymbol*) _tmp459_);
								_tmp461_ = _tmp460_;
								_tmp462_ = prop;
								vala_scope_add (_tmp461_, NULL, (ValaSymbol*) _tmp462_);
								_tmp463_ = prop;
								vala_expression_set_symbol_reference ((ValaExpression*) self, (ValaSymbol*) _tmp463_);
								_vala_code_node_unref0 (prop);
							}
						}
						_vala_code_node_unref0 (a);
					} else {
						gboolean _tmp464_ = FALSE;
						gboolean _tmp465_ = FALSE;
						ValaCodeNode* _tmp466_;
						ValaCodeNode* _tmp467_;
						_tmp466_ = vala_code_node_get_parent_node ((ValaCodeNode*) self);
						_tmp467_ = _tmp466_;
						if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp467_, VALA_TYPE_MEMBER_ACCESS)) {
							ValaExpression* _tmp468_;
							ValaExpression* _tmp469_;
							_tmp468_ = vala_member_access_get_inner (self);
							_tmp469_ = _tmp468_;
							_tmp465_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp469_, VALA_TYPE_MEMBER_ACCESS);
						} else {
							_tmp465_ = FALSE;
						}
						if (_tmp465_) {
							ValaCodeNode* _tmp470_;
							ValaCodeNode* _tmp471_;
							ValaCodeNode* _tmp472_;
							ValaCodeNode* _tmp473_;
							_tmp470_ = vala_code_node_get_parent_node ((ValaCodeNode*) self);
							_tmp471_ = _tmp470_;
							_tmp472_ = vala_code_node_get_parent_node (_tmp471_);
							_tmp473_ = _tmp472_;
							_tmp464_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp473_, VALA_TYPE_METHOD_CALL);
						} else {
							_tmp464_ = FALSE;
						}
						if (_tmp464_) {
							ValaMemberAccess* ma = NULL;
							ValaCodeNode* _tmp474_;
							ValaCodeNode* _tmp475_;
							ValaMemberAccess* _tmp476_;
							gboolean _tmp477_ = FALSE;
							ValaMemberAccess* _tmp478_;
							const gchar* _tmp479_;
							_tmp474_ = vala_code_node_get_parent_node ((ValaCodeNode*) self);
							_tmp475_ = _tmp474_;
							_tmp476_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp475_, VALA_TYPE_MEMBER_ACCESS, ValaMemberAccess));
							ma = _tmp476_;
							_tmp478_ = ma;
							_tmp479_ = _tmp478_->priv->_member_name;
							if (g_strcmp0 (_tmp479_, "connect") == 0) {
								_tmp477_ = TRUE;
							} else {
								ValaMemberAccess* _tmp480_;
								const gchar* _tmp481_;
								_tmp480_ = ma;
								_tmp481_ = _tmp480_->priv->_member_name;
								_tmp477_ = g_strcmp0 (_tmp481_, "connect_after") == 0;
							}
							if (_tmp477_) {
								ValaDynamicSignal* s = NULL;
								ValaExpression* _tmp482_;
								ValaExpression* _tmp483_;
								ValaDataType* _tmp484_;
								ValaDataType* _tmp485_;
								const gchar* _tmp486_;
								ValaVoidType* _tmp487_;
								ValaVoidType* _tmp488_;
								ValaSourceReference* _tmp489_;
								ValaSourceReference* _tmp490_;
								ValaDynamicSignal* _tmp491_;
								ValaDynamicSignal* _tmp492_;
								ValaMethodCall* mcall = NULL;
								ValaCodeNode* _tmp493_;
								ValaCodeNode* _tmp494_;
								ValaCodeNode* _tmp495_;
								ValaCodeNode* _tmp496_;
								ValaMethodCall* _tmp497_;
								ValaMethodCall* _tmp498_;
								ValaList* _tmp499_;
								ValaList* _tmp500_;
								gint _tmp501_;
								gint _tmp502_;
								gboolean _tmp503_;
								ValaDynamicSignal* _tmp510_;
								ValaObjectType* _tmp511_;
								ValaObjectTypeSymbol* _tmp512_;
								ValaObjectTypeSymbol* _tmp513_;
								ValaScope* _tmp514_;
								ValaScope* _tmp515_;
								ValaDynamicSignal* _tmp516_;
								ValaDynamicSignal* _tmp517_;
								_tmp482_ = vala_member_access_get_inner (self);
								_tmp483_ = _tmp482_;
								_tmp484_ = vala_expression_get_value_type (_tmp483_);
								_tmp485_ = _tmp484_;
								_tmp486_ = self->priv->_member_name;
								_tmp487_ = vala_void_type_new (NULL);
								_tmp488_ = _tmp487_;
								_tmp489_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
								_tmp490_ = _tmp489_;
								_tmp491_ = vala_dynamic_signal_new (_tmp485_, _tmp486_, (ValaDataType*) _tmp488_, _tmp490_, NULL);
								_tmp492_ = _tmp491_;
								_vala_code_node_unref0 (_tmp488_);
								s = _tmp492_;
								_tmp493_ = vala_code_node_get_parent_node ((ValaCodeNode*) self);
								_tmp494_ = _tmp493_;
								_tmp495_ = vala_code_node_get_parent_node (_tmp494_);
								_tmp496_ = _tmp495_;
								_tmp497_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp496_, VALA_TYPE_METHOD_CALL, ValaMethodCall));
								mcall = _tmp497_;
								_tmp498_ = mcall;
								_tmp499_ = vala_method_call_get_argument_list (_tmp498_);
								_tmp500_ = _tmp499_;
								_tmp501_ = vala_collection_get_size ((ValaCollection*) _tmp500_);
								_tmp502_ = _tmp501_;
								_tmp503_ = _tmp502_ > 0;
								_vala_iterable_unref0 (_tmp500_);
								if (_tmp503_) {
									ValaDynamicSignal* _tmp504_;
									ValaMethodCall* _tmp505_;
									ValaList* _tmp506_;
									ValaList* _tmp507_;
									gpointer _tmp508_;
									ValaExpression* _tmp509_;
									_tmp504_ = s;
									_tmp505_ = mcall;
									_tmp506_ = vala_method_call_get_argument_list (_tmp505_);
									_tmp507_ = _tmp506_;
									_tmp508_ = vala_list_get (_tmp507_, 0);
									_tmp509_ = (ValaExpression*) _tmp508_;
									vala_dynamic_signal_set_handler (_tmp504_, _tmp509_);
									_vala_code_node_unref0 (_tmp509_);
									_vala_iterable_unref0 (_tmp507_);
								}
								_tmp510_ = s;
								vala_symbol_set_access ((ValaSymbol*) _tmp510_, VALA_SYMBOL_ACCESSIBILITY_PUBLIC);
								_tmp511_ = dynamic_object_type;
								_tmp512_ = vala_object_type_get_type_symbol (_tmp511_);
								_tmp513_ = _tmp512_;
								_tmp514_ = vala_symbol_get_scope ((ValaSymbol*) _tmp513_);
								_tmp515_ = _tmp514_;
								_tmp516_ = s;
								vala_scope_add (_tmp515_, NULL, (ValaSymbol*) _tmp516_);
								_tmp517_ = s;
								vala_expression_set_symbol_reference ((ValaExpression*) self, (ValaSymbol*) _tmp517_);
								_vala_code_node_unref0 (mcall);
								_vala_code_node_unref0 (s);
							}
							_vala_code_node_unref0 (ma);
						}
					}
				}
				_tmp518_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
				_tmp519_ = _tmp518_;
				if (_tmp519_ == NULL) {
					ValaDynamicProperty* prop = NULL;
					ValaExpression* _tmp520_;
					ValaExpression* _tmp521_;
					ValaDataType* _tmp522_;
					ValaDataType* _tmp523_;
					const gchar* _tmp524_;
					ValaSourceReference* _tmp525_;
					ValaSourceReference* _tmp526_;
					ValaDynamicProperty* _tmp527_;
					ValaDataType* _tmp528_;
					ValaDataType* _tmp529_;
					ValaDynamicProperty* _tmp540_;
					ValaDynamicProperty* _tmp541_;
					ValaDynamicProperty* _tmp542_;
					ValaDataType* _tmp543_;
					ValaDataType* _tmp544_;
					ValaDataType* _tmp545_;
					ValaDataType* _tmp546_;
					ValaDynamicProperty* _tmp547_;
					ValaSourceReference* _tmp548_;
					ValaSourceReference* _tmp549_;
					ValaPropertyAccessor* _tmp550_;
					ValaPropertyAccessor* _tmp551_;
					ValaDynamicProperty* _tmp552_;
					ValaExpression* _tmp553_;
					ValaExpression* _tmp554_;
					ValaDataType* _tmp555_;
					ValaDataType* _tmp556_;
					ValaTypeSymbol* _tmp557_;
					ValaTypeSymbol* _tmp558_;
					ValaScope* _tmp559_;
					ValaScope* _tmp560_;
					ValaObjectType* _tmp561_;
					ValaObjectTypeSymbol* _tmp562_;
					ValaObjectTypeSymbol* _tmp563_;
					ValaScope* _tmp564_;
					ValaScope* _tmp565_;
					ValaDynamicProperty* _tmp566_;
					ValaDynamicProperty* _tmp567_;
					_tmp520_ = vala_member_access_get_inner (self);
					_tmp521_ = _tmp520_;
					_tmp522_ = vala_expression_get_value_type (_tmp521_);
					_tmp523_ = _tmp522_;
					_tmp524_ = self->priv->_member_name;
					_tmp525_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
					_tmp526_ = _tmp525_;
					_tmp527_ = vala_dynamic_property_new (_tmp523_, _tmp524_, _tmp526_, NULL);
					prop = _tmp527_;
					_tmp528_ = vala_expression_get_target_type ((ValaExpression*) self);
					_tmp529_ = _tmp528_;
					if (_tmp529_ != NULL) {
						ValaDynamicProperty* _tmp530_;
						ValaDataType* _tmp531_;
						ValaDataType* _tmp532_;
						_tmp530_ = prop;
						_tmp531_ = vala_expression_get_target_type ((ValaExpression*) self);
						_tmp532_ = _tmp531_;
						vala_property_set_property_type ((ValaProperty*) _tmp530_, _tmp532_);
					} else {
						ValaDynamicProperty* _tmp533_;
						ValaExpression* _tmp534_;
						ValaExpression* _tmp535_;
						ValaDataType* _tmp536_;
						ValaDataType* _tmp537_;
						ValaDataType* _tmp538_;
						ValaDataType* _tmp539_;
						_tmp533_ = prop;
						_tmp534_ = vala_member_access_get_inner (self);
						_tmp535_ = _tmp534_;
						_tmp536_ = vala_expression_get_value_type (_tmp535_);
						_tmp537_ = _tmp536_;
						_tmp538_ = vala_data_type_copy (_tmp537_);
						_tmp539_ = _tmp538_;
						vala_property_set_property_type ((ValaProperty*) _tmp533_, _tmp539_);
						_vala_code_node_unref0 (_tmp539_);
					}
					_tmp540_ = prop;
					vala_symbol_set_access ((ValaSymbol*) _tmp540_, VALA_SYMBOL_ACCESSIBILITY_PUBLIC);
					_tmp541_ = prop;
					_tmp542_ = prop;
					_tmp543_ = vala_property_get_property_type ((ValaProperty*) _tmp542_);
					_tmp544_ = _tmp543_;
					_tmp545_ = vala_data_type_copy (_tmp544_);
					_tmp546_ = _tmp545_;
					_tmp547_ = prop;
					_tmp548_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp547_);
					_tmp549_ = _tmp548_;
					_tmp550_ = vala_property_accessor_new (TRUE, FALSE, FALSE, _tmp546_, NULL, _tmp549_, NULL);
					_tmp551_ = _tmp550_;
					vala_property_set_get_accessor ((ValaProperty*) _tmp541_, _tmp551_);
					_vala_code_node_unref0 (_tmp551_);
					_vala_code_node_unref0 (_tmp546_);
					_tmp552_ = prop;
					_tmp553_ = vala_member_access_get_inner (self);
					_tmp554_ = _tmp553_;
					_tmp555_ = vala_expression_get_value_type (_tmp554_);
					_tmp556_ = _tmp555_;
					_tmp557_ = vala_data_type_get_data_type (_tmp556_);
					_tmp558_ = _tmp557_;
					_tmp559_ = vala_symbol_get_scope ((ValaSymbol*) _tmp558_);
					_tmp560_ = _tmp559_;
					vala_symbol_set_owner ((ValaSymbol*) _tmp552_, _tmp560_);
					_tmp561_ = dynamic_object_type;
					_tmp562_ = vala_object_type_get_type_symbol (_tmp561_);
					_tmp563_ = _tmp562_;
					_tmp564_ = vala_symbol_get_scope ((ValaSymbol*) _tmp563_);
					_tmp565_ = _tmp564_;
					_tmp566_ = prop;
					vala_scope_add (_tmp565_, NULL, (ValaSymbol*) _tmp566_);
					_tmp567_ = prop;
					vala_expression_set_symbol_reference ((ValaExpression*) self, (ValaSymbol*) _tmp567_);
					_vala_code_node_unref0 (prop);
				}
				_tmp568_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
				_tmp569_ = _tmp568_;
				if (_tmp569_ != NULL) {
					may_access_instance_members = TRUE;
					may_access_klass_members = TRUE;
				}
				_vala_code_node_unref0 (dynamic_object_type);
			}
		}
	}
	_tmp570_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
	_tmp571_ = _tmp570_;
	if (_tmp571_ == NULL) {
		gchar* base_type_name = NULL;
		gchar* _tmp572_;
		gboolean _tmp573_ = FALSE;
		ValaExpression* _tmp574_;
		ValaExpression* _tmp575_;
		ValaSourceReference* _tmp588_;
		ValaSourceReference* _tmp589_;
		const gchar* _tmp590_;
		const gchar* _tmp591_;
		gchar* _tmp592_;
		gchar* _tmp593_;
		vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
		_tmp572_ = g_strdup ("(null)");
		base_type_name = _tmp572_;
		_tmp574_ = vala_member_access_get_inner (self);
		_tmp575_ = _tmp574_;
		if (_tmp575_ != NULL) {
			ValaExpression* _tmp576_;
			ValaExpression* _tmp577_;
			ValaDataType* _tmp578_;
			ValaDataType* _tmp579_;
			_tmp576_ = vala_member_access_get_inner (self);
			_tmp577_ = _tmp576_;
			_tmp578_ = vala_expression_get_value_type (_tmp577_);
			_tmp579_ = _tmp578_;
			_tmp573_ = _tmp579_ != NULL;
		} else {
			_tmp573_ = FALSE;
		}
		if (_tmp573_) {
			ValaExpression* _tmp580_;
			ValaExpression* _tmp581_;
			ValaDataType* _tmp582_;
			ValaDataType* _tmp583_;
			gchar* _tmp584_;
			_tmp580_ = vala_member_access_get_inner (self);
			_tmp581_ = _tmp580_;
			_tmp582_ = vala_expression_get_value_type (_tmp581_);
			_tmp583_ = _tmp582_;
			_tmp584_ = vala_code_node_to_string ((ValaCodeNode*) _tmp583_);
			_g_free0 (base_type_name);
			base_type_name = _tmp584_;
		} else {
			ValaSymbol* _tmp585_;
			_tmp585_ = base_symbol;
			if (_tmp585_ != NULL) {
				ValaSymbol* _tmp586_;
				gchar* _tmp587_;
				_tmp586_ = base_symbol;
				_tmp587_ = vala_symbol_get_full_name (_tmp586_);
				_g_free0 (base_type_name);
				base_type_name = _tmp587_;
			}
		}
		_tmp588_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
		_tmp589_ = _tmp588_;
		_tmp590_ = self->priv->_member_name;
		_tmp591_ = base_type_name;
		_tmp592_ = g_strdup_printf ("The name `%s' does not exist in the context of `%s'", _tmp590_, _tmp591_);
		_tmp593_ = _tmp592_;
		vala_report_error (_tmp589_, _tmp593_);
		_g_free0 (_tmp593_);
		result = FALSE;
		_g_free0 (base_type_name);
		_vala_code_node_unref0 (this_parameter);
		_vala_code_node_unref0 (base_symbol);
		return result;
	}
	_tmp594_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
	_tmp595_ = _tmp594_;
	_tmp596_ = _vala_code_node_ref0 (_tmp595_);
	member = _tmp596_;
	access = VALA_SYMBOL_ACCESSIBILITY_PUBLIC;
	instance = FALSE;
	klass = FALSE;
	generics = FALSE;
	_tmp597_ = member;
	_tmp598_ = context;
	_tmp599_ = vala_code_node_check ((ValaCodeNode*) _tmp597_, _tmp598_);
	if (!_tmp599_) {
		result = FALSE;
		_vala_code_node_unref0 (member);
		_vala_code_node_unref0 (this_parameter);
		_vala_code_node_unref0 (base_symbol);
		return result;
	}
	_tmp600_ = member;
	if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp600_, VALA_TYPE_LOCAL_VARIABLE)) {
		ValaLocalVariable* local = NULL;
		ValaSymbol* _tmp601_;
		ValaLocalVariable* _tmp602_;
		ValaBlock* block = NULL;
		ValaLocalVariable* _tmp603_;
		ValaSymbol* _tmp604_;
		ValaSymbol* _tmp605_;
		ValaBlock* _tmp606_;
		gboolean _tmp607_ = FALSE;
		ValaBlock* _tmp608_;
		_tmp601_ = member;
		_tmp602_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp601_, VALA_TYPE_LOCAL_VARIABLE, ValaLocalVariable));
		local = _tmp602_;
		_tmp603_ = local;
		_tmp604_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp603_);
		_tmp605_ = _tmp604_;
		_tmp606_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp605_, VALA_TYPE_BLOCK) ? ((ValaBlock*) _tmp605_) : NULL);
		block = _tmp606_;
		_tmp608_ = block;
		if (_tmp608_ != NULL) {
			ValaCodeContext* _tmp609_;
			ValaSemanticAnalyzer* _tmp610_;
			ValaSemanticAnalyzer* _tmp611_;
			ValaBlock* _tmp612_;
			ValaSymbol* _tmp613_;
			ValaSymbol* _tmp614_;
			ValaCodeContext* _tmp615_;
			ValaSemanticAnalyzer* _tmp616_;
			ValaSemanticAnalyzer* _tmp617_;
			ValaSymbol* _tmp618_;
			ValaSymbol* _tmp619_;
			_tmp609_ = context;
			_tmp610_ = vala_code_context_get_analyzer (_tmp609_);
			_tmp611_ = _tmp610_;
			_tmp612_ = block;
			_tmp613_ = vala_semantic_analyzer_find_parent_method_or_property_accessor (_tmp611_, (ValaSymbol*) _tmp612_);
			_tmp614_ = _tmp613_;
			_tmp615_ = context;
			_tmp616_ = vala_code_context_get_analyzer (_tmp615_);
			_tmp617_ = _tmp616_;
			_tmp618_ = vala_semantic_analyzer_get_current_method_or_property_accessor (_tmp617_);
			_tmp619_ = _tmp618_;
			_tmp607_ = _tmp614_ != _tmp619_;
			_vala_code_node_unref0 (_tmp614_);
		} else {
			_tmp607_ = FALSE;
		}
		if (_tmp607_) {
			ValaSymbol* sym = NULL;
			ValaCodeContext* _tmp620_;
			ValaSemanticAnalyzer* _tmp621_;
			ValaSemanticAnalyzer* _tmp622_;
			ValaSymbol* _tmp623_;
			ValaSymbol* _tmp624_;
			ValaSymbol* _tmp625_;
			ValaLocalVariable* _tmp638_;
			ValaBlock* _tmp639_;
			_tmp620_ = context;
			_tmp621_ = vala_code_context_get_analyzer (_tmp620_);
			_tmp622_ = _tmp621_;
			_tmp623_ = vala_semantic_analyzer_get_current_method_or_property_accessor (_tmp622_);
			_tmp624_ = _tmp623_;
			_tmp625_ = _vala_code_node_ref0 (_tmp624_);
			sym = _tmp625_;
			while (TRUE) {
				ValaSymbol* _tmp626_;
				ValaBlock* _tmp627_;
				ValaMethod* method = NULL;
				ValaSymbol* _tmp628_;
				ValaMethod* _tmp629_;
				ValaMethod* _tmp630_;
				ValaSymbol* _tmp634_;
				ValaSymbol* _tmp635_;
				ValaSymbol* _tmp636_;
				ValaSymbol* _tmp637_;
				_tmp626_ = sym;
				_tmp627_ = block;
				if (!(_tmp626_ != G_TYPE_CHECK_INSTANCE_CAST (_tmp627_, VALA_TYPE_SYMBOL, ValaSymbol))) {
					break;
				}
				_tmp628_ = sym;
				_tmp629_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp628_, VALA_TYPE_METHOD) ? ((ValaMethod*) _tmp628_) : NULL);
				method = _tmp629_;
				_tmp630_ = method;
				if (_tmp630_ != NULL) {
					ValaMethod* _tmp631_;
					ValaMethod* _tmp632_;
					ValaLocalVariable* _tmp633_;
					_tmp631_ = method;
					vala_method_set_closure (_tmp631_, TRUE);
					_tmp632_ = method;
					_tmp633_ = local;
					vala_method_add_captured_variable (_tmp632_, _tmp633_);
				}
				_tmp634_ = sym;
				_tmp635_ = vala_symbol_get_parent_symbol (_tmp634_);
				_tmp636_ = _tmp635_;
				_tmp637_ = _vala_code_node_ref0 (_tmp636_);
				_vala_code_node_unref0 (sym);
				sym = _tmp637_;
				_vala_code_node_unref0 (method);
			}
			_tmp638_ = local;
			vala_local_variable_set_captured (_tmp638_, TRUE);
			_tmp639_ = block;
			vala_block_set_captured (_tmp639_, TRUE);
			_vala_code_node_unref0 (sym);
		}
		_vala_code_node_unref0 (block);
		_vala_code_node_unref0 (local);
	} else {
		ValaSymbol* _tmp640_;
		_tmp640_ = member;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp640_, VALA_TYPE_PARAMETER)) {
			ValaParameter* param = NULL;
			ValaSymbol* _tmp641_;
			ValaParameter* _tmp642_;
			ValaMethod* m = NULL;
			ValaParameter* _tmp643_;
			ValaSymbol* _tmp644_;
			ValaSymbol* _tmp645_;
			ValaMethod* _tmp646_;
			gboolean _tmp647_ = FALSE;
			gboolean _tmp648_ = FALSE;
			ValaMethod* _tmp649_;
			_tmp641_ = member;
			_tmp642_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp641_, VALA_TYPE_PARAMETER, ValaParameter));
			param = _tmp642_;
			_tmp643_ = param;
			_tmp644_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp643_);
			_tmp645_ = _tmp644_;
			_tmp646_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp645_, VALA_TYPE_METHOD) ? ((ValaMethod*) _tmp645_) : NULL);
			m = _tmp646_;
			_tmp649_ = m;
			if (_tmp649_ != NULL) {
				ValaMethod* _tmp650_;
				ValaCodeContext* _tmp651_;
				ValaSemanticAnalyzer* _tmp652_;
				ValaSemanticAnalyzer* _tmp653_;
				ValaSymbol* _tmp654_;
				ValaSymbol* _tmp655_;
				_tmp650_ = m;
				_tmp651_ = context;
				_tmp652_ = vala_code_context_get_analyzer (_tmp651_);
				_tmp653_ = _tmp652_;
				_tmp654_ = vala_semantic_analyzer_get_current_method_or_property_accessor (_tmp653_);
				_tmp655_ = _tmp654_;
				_tmp648_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp650_, VALA_TYPE_SYMBOL, ValaSymbol) != _tmp655_;
			} else {
				_tmp648_ = FALSE;
			}
			if (_tmp648_) {
				ValaParameter* _tmp656_;
				ValaMethod* _tmp657_;
				ValaParameter* _tmp658_;
				ValaParameter* _tmp659_;
				_tmp656_ = param;
				_tmp657_ = m;
				_tmp658_ = vala_method_get_this_parameter (_tmp657_);
				_tmp659_ = _tmp658_;
				_tmp647_ = _tmp656_ != _tmp659_;
			} else {
				_tmp647_ = FALSE;
			}
			if (_tmp647_) {
				ValaSymbol* sym = NULL;
				ValaCodeContext* _tmp660_;
				ValaSemanticAnalyzer* _tmp661_;
				ValaSemanticAnalyzer* _tmp662_;
				ValaSymbol* _tmp663_;
				ValaSymbol* _tmp664_;
				ValaSymbol* _tmp665_;
				ValaParameter* _tmp676_;
				ValaMethod* _tmp677_;
				ValaBlock* _tmp678_;
				ValaBlock* _tmp679_;
				ValaParameter* _tmp680_;
				ValaParameterDirection _tmp681_;
				ValaParameterDirection _tmp682_;
				_tmp660_ = context;
				_tmp661_ = vala_code_context_get_analyzer (_tmp660_);
				_tmp662_ = _tmp661_;
				_tmp663_ = vala_semantic_analyzer_get_current_method_or_property_accessor (_tmp662_);
				_tmp664_ = _tmp663_;
				_tmp665_ = _vala_code_node_ref0 (_tmp664_);
				sym = _tmp665_;
				while (TRUE) {
					ValaSymbol* _tmp666_;
					ValaMethod* _tmp667_;
					ValaMethod* method = NULL;
					ValaSymbol* _tmp668_;
					ValaMethod* _tmp669_;
					ValaMethod* _tmp670_;
					ValaSymbol* _tmp672_;
					ValaSymbol* _tmp673_;
					ValaSymbol* _tmp674_;
					ValaSymbol* _tmp675_;
					_tmp666_ = sym;
					_tmp667_ = m;
					if (!(_tmp666_ != G_TYPE_CHECK_INSTANCE_CAST (_tmp667_, VALA_TYPE_SYMBOL, ValaSymbol))) {
						break;
					}
					_tmp668_ = sym;
					_tmp669_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp668_, VALA_TYPE_METHOD) ? ((ValaMethod*) _tmp668_) : NULL);
					method = _tmp669_;
					_tmp670_ = method;
					if (_tmp670_ != NULL) {
						ValaMethod* _tmp671_;
						_tmp671_ = method;
						vala_method_set_closure (_tmp671_, TRUE);
					}
					_tmp672_ = sym;
					_tmp673_ = vala_symbol_get_parent_symbol (_tmp672_);
					_tmp674_ = _tmp673_;
					_tmp675_ = _vala_code_node_ref0 (_tmp674_);
					_vala_code_node_unref0 (sym);
					sym = _tmp675_;
					_vala_code_node_unref0 (method);
				}
				_tmp676_ = param;
				vala_parameter_set_captured (_tmp676_, TRUE);
				_tmp677_ = m;
				_tmp678_ = vala_subroutine_get_body ((ValaSubroutine*) _tmp677_);
				_tmp679_ = _tmp678_;
				vala_block_set_captured (_tmp679_, TRUE);
				_tmp680_ = param;
				_tmp681_ = vala_parameter_get_direction (_tmp680_);
				_tmp682_ = _tmp681_;
				if (_tmp682_ != VALA_PARAMETER_DIRECTION_IN) {
					ValaSourceReference* _tmp683_;
					ValaSourceReference* _tmp684_;
					ValaParameter* _tmp685_;
					gchar* _tmp686_;
					gchar* _tmp687_;
					gchar* _tmp688_;
					gchar* _tmp689_;
					vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
					_tmp683_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
					_tmp684_ = _tmp683_;
					_tmp685_ = param;
					_tmp686_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp685_);
					_tmp687_ = _tmp686_;
					_tmp688_ = g_strdup_printf ("Cannot capture reference or output parameter `%s'", _tmp687_);
					_tmp689_ = _tmp688_;
					vala_report_error (_tmp684_, _tmp689_);
					_g_free0 (_tmp689_);
					_g_free0 (_tmp687_);
				}
				_vala_code_node_unref0 (sym);
			} else {
				ValaPropertyAccessor* acc = NULL;
				ValaParameter* _tmp690_;
				ValaSymbol* _tmp691_;
				ValaSymbol* _tmp692_;
				ValaSymbol* _tmp693_;
				ValaSymbol* _tmp694_;
				ValaPropertyAccessor* _tmp695_;
				gboolean _tmp696_ = FALSE;
				gboolean _tmp697_ = FALSE;
				ValaPropertyAccessor* _tmp698_;
				_tmp690_ = param;
				_tmp691_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp690_);
				_tmp692_ = _tmp691_;
				_tmp693_ = vala_symbol_get_parent_symbol (_tmp692_);
				_tmp694_ = _tmp693_;
				_tmp695_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp694_, VALA_TYPE_PROPERTY_ACCESSOR) ? ((ValaPropertyAccessor*) _tmp694_) : NULL);
				acc = _tmp695_;
				_tmp698_ = acc;
				if (_tmp698_ != NULL) {
					ValaPropertyAccessor* _tmp699_;
					ValaCodeContext* _tmp700_;
					ValaSemanticAnalyzer* _tmp701_;
					ValaSemanticAnalyzer* _tmp702_;
					ValaSymbol* _tmp703_;
					ValaSymbol* _tmp704_;
					_tmp699_ = acc;
					_tmp700_ = context;
					_tmp701_ = vala_code_context_get_analyzer (_tmp700_);
					_tmp702_ = _tmp701_;
					_tmp703_ = vala_semantic_analyzer_get_current_method_or_property_accessor (_tmp702_);
					_tmp704_ = _tmp703_;
					_tmp697_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp699_, VALA_TYPE_SYMBOL, ValaSymbol) != _tmp704_;
				} else {
					_tmp697_ = FALSE;
				}
				if (_tmp697_) {
					ValaParameter* _tmp705_;
					ValaPropertyAccessor* _tmp706_;
					ValaProperty* _tmp707_;
					ValaProperty* _tmp708_;
					ValaParameter* _tmp709_;
					ValaParameter* _tmp710_;
					_tmp705_ = param;
					_tmp706_ = acc;
					_tmp707_ = vala_property_accessor_get_prop (_tmp706_);
					_tmp708_ = _tmp707_;
					_tmp709_ = vala_property_get_this_parameter (_tmp708_);
					_tmp710_ = _tmp709_;
					_tmp696_ = _tmp705_ != _tmp710_;
				} else {
					_tmp696_ = FALSE;
				}
				if (_tmp696_) {
					ValaSymbol* sym = NULL;
					ValaCodeContext* _tmp711_;
					ValaSemanticAnalyzer* _tmp712_;
					ValaSemanticAnalyzer* _tmp713_;
					ValaSymbol* _tmp714_;
					ValaSymbol* _tmp715_;
					ValaSymbol* _tmp716_;
					ValaParameter* _tmp727_;
					ValaPropertyAccessor* _tmp728_;
					ValaBlock* _tmp729_;
					ValaBlock* _tmp730_;
					_tmp711_ = context;
					_tmp712_ = vala_code_context_get_analyzer (_tmp711_);
					_tmp713_ = _tmp712_;
					_tmp714_ = vala_semantic_analyzer_get_current_method_or_property_accessor (_tmp713_);
					_tmp715_ = _tmp714_;
					_tmp716_ = _vala_code_node_ref0 (_tmp715_);
					sym = _tmp716_;
					while (TRUE) {
						ValaSymbol* _tmp717_;
						ValaMethod* _tmp718_;
						ValaMethod* method = NULL;
						ValaSymbol* _tmp719_;
						ValaMethod* _tmp720_;
						ValaMethod* _tmp721_;
						ValaSymbol* _tmp723_;
						ValaSymbol* _tmp724_;
						ValaSymbol* _tmp725_;
						ValaSymbol* _tmp726_;
						_tmp717_ = sym;
						_tmp718_ = m;
						if (!(_tmp717_ != G_TYPE_CHECK_INSTANCE_CAST (_tmp718_, VALA_TYPE_SYMBOL, ValaSymbol))) {
							break;
						}
						_tmp719_ = sym;
						_tmp720_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp719_, VALA_TYPE_METHOD) ? ((ValaMethod*) _tmp719_) : NULL);
						method = _tmp720_;
						_tmp721_ = method;
						if (_tmp721_ != NULL) {
							ValaMethod* _tmp722_;
							_tmp722_ = method;
							vala_method_set_closure (_tmp722_, TRUE);
						}
						_tmp723_ = sym;
						_tmp724_ = vala_symbol_get_parent_symbol (_tmp723_);
						_tmp725_ = _tmp724_;
						_tmp726_ = _vala_code_node_ref0 (_tmp725_);
						_vala_code_node_unref0 (sym);
						sym = _tmp726_;
						_vala_code_node_unref0 (method);
					}
					_tmp727_ = param;
					vala_parameter_set_captured (_tmp727_, TRUE);
					_tmp728_ = acc;
					_tmp729_ = vala_subroutine_get_body ((ValaSubroutine*) _tmp728_);
					_tmp730_ = _tmp729_;
					vala_block_set_captured (_tmp730_, TRUE);
					_vala_code_node_unref0 (sym);
				}
				_vala_code_node_unref0 (acc);
			}
			_vala_code_node_unref0 (m);
			_vala_code_node_unref0 (param);
		} else {
			ValaSymbol* _tmp731_;
			_tmp731_ = member;
			if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp731_, VALA_TYPE_FIELD)) {
				ValaField* f = NULL;
				ValaSymbol* _tmp732_;
				ValaField* _tmp733_;
				ValaField* _tmp734_;
				ValaSymbolAccessibility _tmp735_;
				ValaSymbolAccessibility _tmp736_;
				ValaField* _tmp737_;
				ValaMemberBinding _tmp738_;
				ValaMemberBinding _tmp739_;
				ValaField* _tmp740_;
				ValaMemberBinding _tmp741_;
				ValaMemberBinding _tmp742_;
				ValaField* _tmp743_;
				ValaDataType* _tmp744_;
				ValaDataType* _tmp745_;
				_tmp732_ = member;
				_tmp733_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp732_, VALA_TYPE_FIELD, ValaField));
				f = _tmp733_;
				_tmp734_ = f;
				_tmp735_ = vala_symbol_get_access ((ValaSymbol*) _tmp734_);
				_tmp736_ = _tmp735_;
				access = _tmp736_;
				_tmp737_ = f;
				_tmp738_ = vala_field_get_binding (_tmp737_);
				_tmp739_ = _tmp738_;
				instance = _tmp739_ == VALA_MEMBER_BINDING_INSTANCE;
				_tmp740_ = f;
				_tmp741_ = vala_field_get_binding (_tmp740_);
				_tmp742_ = _tmp741_;
				klass = _tmp742_ == VALA_MEMBER_BINDING_CLASS;
				_tmp743_ = f;
				_tmp744_ = vala_variable_get_variable_type ((ValaVariable*) _tmp743_);
				_tmp745_ = _tmp744_;
				if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp745_, VALA_TYPE_GENERIC_TYPE)) {
					generics = TRUE;
				}
				_vala_code_node_unref0 (f);
			} else {
				ValaSymbol* _tmp746_;
				_tmp746_ = member;
				if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp746_, VALA_TYPE_CONSTANT)) {
					ValaConstant* c = NULL;
					ValaSymbol* _tmp747_;
					ValaConstant* _tmp748_;
					ValaConstant* _tmp749_;
					ValaSymbolAccessibility _tmp750_;
					ValaSymbolAccessibility _tmp751_;
					ValaBlock* block = NULL;
					ValaConstant* _tmp752_;
					ValaSymbol* _tmp753_;
					ValaSymbol* _tmp754_;
					ValaBlock* _tmp755_;
					gboolean _tmp756_ = FALSE;
					ValaBlock* _tmp757_;
					_tmp747_ = member;
					_tmp748_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp747_, VALA_TYPE_CONSTANT, ValaConstant));
					c = _tmp748_;
					_tmp749_ = c;
					_tmp750_ = vala_symbol_get_access ((ValaSymbol*) _tmp749_);
					_tmp751_ = _tmp750_;
					access = _tmp751_;
					_tmp752_ = c;
					_tmp753_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp752_);
					_tmp754_ = _tmp753_;
					_tmp755_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp754_, VALA_TYPE_BLOCK) ? ((ValaBlock*) _tmp754_) : NULL);
					block = _tmp755_;
					_tmp757_ = block;
					if (_tmp757_ != NULL) {
						ValaCodeContext* _tmp758_;
						ValaSemanticAnalyzer* _tmp759_;
						ValaSemanticAnalyzer* _tmp760_;
						ValaBlock* _tmp761_;
						ValaSymbol* _tmp762_;
						ValaSymbol* _tmp763_;
						ValaCodeContext* _tmp764_;
						ValaSemanticAnalyzer* _tmp765_;
						ValaSemanticAnalyzer* _tmp766_;
						ValaSymbol* _tmp767_;
						ValaSymbol* _tmp768_;
						_tmp758_ = context;
						_tmp759_ = vala_code_context_get_analyzer (_tmp758_);
						_tmp760_ = _tmp759_;
						_tmp761_ = block;
						_tmp762_ = vala_semantic_analyzer_find_parent_method_or_property_accessor (_tmp760_, (ValaSymbol*) _tmp761_);
						_tmp763_ = _tmp762_;
						_tmp764_ = context;
						_tmp765_ = vala_code_context_get_analyzer (_tmp764_);
						_tmp766_ = _tmp765_;
						_tmp767_ = vala_semantic_analyzer_get_current_method_or_property_accessor (_tmp766_);
						_tmp768_ = _tmp767_;
						_tmp756_ = _tmp763_ != _tmp768_;
						_vala_code_node_unref0 (_tmp763_);
					} else {
						_tmp756_ = FALSE;
					}
					if (_tmp756_) {
						ValaSourceReference* _tmp769_;
						ValaSourceReference* _tmp770_;
						vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
						_tmp769_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
						_tmp770_ = _tmp769_;
						vala_report_error (_tmp770_, "internal error: accessing local constants of outer methods is not supp" \
"orted yet");
						result = FALSE;
						_vala_code_node_unref0 (block);
						_vala_code_node_unref0 (c);
						_vala_code_node_unref0 (member);
						_vala_code_node_unref0 (this_parameter);
						_vala_code_node_unref0 (base_symbol);
						return result;
					}
					_vala_code_node_unref0 (block);
					_vala_code_node_unref0 (c);
				} else {
					ValaSymbol* _tmp771_;
					_tmp771_ = member;
					if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp771_, VALA_TYPE_METHOD)) {
						ValaMethod* m = NULL;
						ValaSymbol* _tmp772_;
						ValaMethod* _tmp773_;
						ValaMethod* _tmp774_;
						gboolean _tmp775_;
						gboolean _tmp776_;
						ValaMethod* _tmp882_;
						ValaSymbolAccessibility _tmp883_;
						ValaSymbolAccessibility _tmp884_;
						ValaMethod* _tmp885_;
						ValaMethod* _tmp889_;
						ValaMemberBinding _tmp890_;
						ValaMemberBinding _tmp891_;
						ValaGenericType* generic_type = NULL;
						ValaMethod* _tmp914_;
						ValaDataType* _tmp915_;
						ValaDataType* _tmp916_;
						ValaGenericType* _tmp917_;
						gboolean _tmp918_ = FALSE;
						ValaGenericType* _tmp919_;
						_tmp772_ = member;
						_tmp773_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp772_, VALA_TYPE_METHOD, ValaMethod));
						m = _tmp773_;
						_tmp774_ = m;
						_tmp775_ = vala_method_get_is_async_callback (_tmp774_);
						_tmp776_ = _tmp775_;
						if (_tmp776_) {
							ValaMethod* async_method = NULL;
							ValaCodeContext* _tmp777_;
							ValaSemanticAnalyzer* _tmp778_;
							ValaSemanticAnalyzer* _tmp779_;
							ValaMethod* _tmp780_;
							ValaMethod* _tmp781_;
							ValaMethod* _tmp782_;
							gboolean is_valid_access = FALSE;
							ValaMethod* _tmp783_;
							gboolean _tmp809_;
							ValaMethod* _tmp817_;
							ValaCodeContext* _tmp818_;
							ValaSemanticAnalyzer* _tmp819_;
							ValaSemanticAnalyzer* _tmp820_;
							ValaMethod* _tmp821_;
							ValaMethod* _tmp822_;
							ValaMethod* _tmp842_;
							ValaMethod* _tmp843_;
							ValaMethod* _tmp844_;
							ValaSymbol* _tmp845_;
							ValaSymbol* _tmp846_;
							ValaSymbol* _tmp847_;
							_tmp777_ = context;
							_tmp778_ = vala_code_context_get_analyzer (_tmp777_);
							_tmp779_ = _tmp778_;
							_tmp780_ = vala_semantic_analyzer_get_current_async_method (_tmp779_);
							_tmp781_ = _tmp780_;
							_tmp782_ = _vala_code_node_ref0 (_tmp781_);
							async_method = _tmp782_;
							is_valid_access = FALSE;
							_tmp783_ = async_method;
							if (_tmp783_ != NULL) {
								ValaMethod* _tmp784_;
								ValaMethod* _tmp785_;
								ValaMethod* _tmp786_;
								ValaMethod* _tmp787_;
								gboolean _tmp788_;
								_tmp784_ = m;
								_tmp785_ = async_method;
								_tmp786_ = vala_method_get_callback_method (_tmp785_);
								_tmp787_ = _tmp786_;
								_tmp788_ = _tmp784_ == _tmp787_;
								_vala_code_node_unref0 (_tmp787_);
								if (_tmp788_) {
									is_valid_access = TRUE;
								} else {
									gboolean _tmp789_ = FALSE;
									ValaMethod* _tmp790_;
									ValaMethod* _tmp791_;
									ValaMethod* _tmp792_;
									_tmp790_ = async_method;
									_tmp791_ = vala_method_get_base_method (_tmp790_);
									_tmp792_ = _tmp791_;
									if (_tmp792_ != NULL) {
										ValaMethod* _tmp793_;
										ValaMethod* _tmp794_;
										ValaMethod* _tmp795_;
										ValaMethod* _tmp796_;
										ValaMethod* _tmp797_;
										ValaMethod* _tmp798_;
										_tmp793_ = m;
										_tmp794_ = async_method;
										_tmp795_ = vala_method_get_base_method (_tmp794_);
										_tmp796_ = _tmp795_;
										_tmp797_ = vala_method_get_callback_method (_tmp796_);
										_tmp798_ = _tmp797_;
										_tmp789_ = _tmp793_ == _tmp798_;
										_vala_code_node_unref0 (_tmp798_);
									} else {
										_tmp789_ = FALSE;
									}
									if (_tmp789_) {
										is_valid_access = TRUE;
									} else {
										gboolean _tmp799_ = FALSE;
										ValaMethod* _tmp800_;
										ValaMethod* _tmp801_;
										ValaMethod* _tmp802_;
										_tmp800_ = async_method;
										_tmp801_ = vala_method_get_base_interface_method (_tmp800_);
										_tmp802_ = _tmp801_;
										if (_tmp802_ != NULL) {
											ValaMethod* _tmp803_;
											ValaMethod* _tmp804_;
											ValaMethod* _tmp805_;
											ValaMethod* _tmp806_;
											ValaMethod* _tmp807_;
											ValaMethod* _tmp808_;
											_tmp803_ = m;
											_tmp804_ = async_method;
											_tmp805_ = vala_method_get_base_interface_method (_tmp804_);
											_tmp806_ = _tmp805_;
											_tmp807_ = vala_method_get_callback_method (_tmp806_);
											_tmp808_ = _tmp807_;
											_tmp799_ = _tmp803_ == _tmp808_;
											_vala_code_node_unref0 (_tmp808_);
										} else {
											_tmp799_ = FALSE;
										}
										if (_tmp799_) {
											is_valid_access = TRUE;
										}
									}
								}
							}
							_tmp809_ = is_valid_access;
							if (!_tmp809_) {
								ValaSourceReference* _tmp810_;
								ValaSourceReference* _tmp811_;
								ValaMethod* _tmp812_;
								gchar* _tmp813_;
								gchar* _tmp814_;
								gchar* _tmp815_;
								gchar* _tmp816_;
								vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
								_tmp810_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
								_tmp811_ = _tmp810_;
								_tmp812_ = m;
								_tmp813_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp812_);
								_tmp814_ = _tmp813_;
								_tmp815_ = g_strdup_printf ("Access to async callback `%s' not allowed in this context", _tmp814_);
								_tmp816_ = _tmp815_;
								vala_report_error (_tmp811_, _tmp816_);
								_g_free0 (_tmp816_);
								_g_free0 (_tmp814_);
								result = FALSE;
								_vala_code_node_unref0 (async_method);
								_vala_code_node_unref0 (m);
								_vala_code_node_unref0 (member);
								_vala_code_node_unref0 (this_parameter);
								_vala_code_node_unref0 (base_symbol);
								return result;
							}
							_tmp817_ = async_method;
							_tmp818_ = context;
							_tmp819_ = vala_code_context_get_analyzer (_tmp818_);
							_tmp820_ = _tmp819_;
							_tmp821_ = vala_semantic_analyzer_get_current_method (_tmp820_);
							_tmp822_ = _tmp821_;
							if (_tmp817_ != _tmp822_) {
								ValaSymbol* sym = NULL;
								ValaCodeContext* _tmp823_;
								ValaSemanticAnalyzer* _tmp824_;
								ValaSemanticAnalyzer* _tmp825_;
								ValaMethod* _tmp826_;
								ValaMethod* _tmp827_;
								ValaSymbol* _tmp828_;
								ValaMethod* _tmp839_;
								ValaBlock* _tmp840_;
								ValaBlock* _tmp841_;
								_tmp823_ = context;
								_tmp824_ = vala_code_context_get_analyzer (_tmp823_);
								_tmp825_ = _tmp824_;
								_tmp826_ = vala_semantic_analyzer_get_current_method (_tmp825_);
								_tmp827_ = _tmp826_;
								_tmp828_ = _vala_code_node_ref0 ((ValaSymbol*) _tmp827_);
								sym = _tmp828_;
								while (TRUE) {
									ValaSymbol* _tmp829_;
									ValaMethod* _tmp830_;
									ValaMethod* method = NULL;
									ValaSymbol* _tmp831_;
									ValaMethod* _tmp832_;
									ValaMethod* _tmp833_;
									ValaSymbol* _tmp835_;
									ValaSymbol* _tmp836_;
									ValaSymbol* _tmp837_;
									ValaSymbol* _tmp838_;
									_tmp829_ = sym;
									_tmp830_ = async_method;
									if (!(_tmp829_ != G_TYPE_CHECK_INSTANCE_CAST (_tmp830_, VALA_TYPE_SYMBOL, ValaSymbol))) {
										break;
									}
									_tmp831_ = sym;
									_tmp832_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp831_, VALA_TYPE_METHOD) ? ((ValaMethod*) _tmp831_) : NULL);
									method = _tmp832_;
									_tmp833_ = method;
									if (_tmp833_ != NULL) {
										ValaMethod* _tmp834_;
										_tmp834_ = method;
										vala_method_set_closure (_tmp834_, TRUE);
									}
									_tmp835_ = sym;
									_tmp836_ = vala_symbol_get_parent_symbol (_tmp835_);
									_tmp837_ = _tmp836_;
									_tmp838_ = _vala_code_node_ref0 (_tmp837_);
									_vala_code_node_unref0 (sym);
									sym = _tmp838_;
									_vala_code_node_unref0 (method);
								}
								_tmp839_ = async_method;
								_tmp840_ = vala_subroutine_get_body ((ValaSubroutine*) _tmp839_);
								_tmp841_ = _tmp840_;
								vala_block_set_captured (_tmp841_, TRUE);
								_vala_code_node_unref0 (sym);
							}
							_tmp842_ = async_method;
							_tmp843_ = vala_method_get_callback_method (_tmp842_);
							_vala_code_node_unref0 (m);
							m = _tmp843_;
							_tmp844_ = m;
							vala_expression_set_symbol_reference ((ValaExpression*) self, (ValaSymbol*) _tmp844_);
							_tmp845_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
							_tmp846_ = _tmp845_;
							_tmp847_ = _vala_code_node_ref0 (_tmp846_);
							_vala_code_node_unref0 (member);
							member = _tmp847_;
							_vala_code_node_unref0 (async_method);
						} else {
							ValaMethod* _tmp848_;
							ValaMethod* _tmp849_;
							ValaMethod* _tmp850_;
							_tmp848_ = m;
							_tmp849_ = vala_method_get_base_method (_tmp848_);
							_tmp850_ = _tmp849_;
							if (_tmp850_ != NULL) {
								ValaMethod* _tmp851_;
								ValaMethod* _tmp852_;
								ValaMethod* _tmp853_;
								ValaMethod* _tmp854_;
								ValaMethod* _tmp855_;
								ValaSignal* _tmp856_;
								ValaSignal* _tmp857_;
								ValaSymbol* _tmp862_;
								ValaSymbol* _tmp863_;
								ValaSymbol* _tmp864_;
								_tmp851_ = m;
								_tmp852_ = vala_method_get_base_method (_tmp851_);
								_tmp853_ = _tmp852_;
								_tmp854_ = _vala_code_node_ref0 (_tmp853_);
								_vala_code_node_unref0 (m);
								m = _tmp854_;
								_tmp855_ = m;
								_tmp856_ = vala_method_get_signal_reference (_tmp855_);
								_tmp857_ = _tmp856_;
								if (_tmp857_ != NULL) {
									ValaMethod* _tmp858_;
									ValaSignal* _tmp859_;
									ValaSignal* _tmp860_;
									_tmp858_ = m;
									_tmp859_ = vala_method_get_signal_reference (_tmp858_);
									_tmp860_ = _tmp859_;
									vala_expression_set_symbol_reference ((ValaExpression*) self, (ValaSymbol*) _tmp860_);
								} else {
									ValaMethod* _tmp861_;
									_tmp861_ = m;
									vala_expression_set_symbol_reference ((ValaExpression*) self, (ValaSymbol*) _tmp861_);
								}
								_tmp862_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
								_tmp863_ = _tmp862_;
								_tmp864_ = _vala_code_node_ref0 (_tmp863_);
								_vala_code_node_unref0 (member);
								member = _tmp864_;
							} else {
								ValaMethod* _tmp865_;
								ValaMethod* _tmp866_;
								ValaMethod* _tmp867_;
								_tmp865_ = m;
								_tmp866_ = vala_method_get_base_interface_method (_tmp865_);
								_tmp867_ = _tmp866_;
								if (_tmp867_ != NULL) {
									ValaMethod* _tmp868_;
									ValaMethod* _tmp869_;
									ValaMethod* _tmp870_;
									ValaMethod* _tmp871_;
									ValaMethod* _tmp872_;
									ValaSignal* _tmp873_;
									ValaSignal* _tmp874_;
									ValaSymbol* _tmp879_;
									ValaSymbol* _tmp880_;
									ValaSymbol* _tmp881_;
									_tmp868_ = m;
									_tmp869_ = vala_method_get_base_interface_method (_tmp868_);
									_tmp870_ = _tmp869_;
									_tmp871_ = _vala_code_node_ref0 (_tmp870_);
									_vala_code_node_unref0 (m);
									m = _tmp871_;
									_tmp872_ = m;
									_tmp873_ = vala_method_get_signal_reference (_tmp872_);
									_tmp874_ = _tmp873_;
									if (_tmp874_ != NULL) {
										ValaMethod* _tmp875_;
										ValaSignal* _tmp876_;
										ValaSignal* _tmp877_;
										_tmp875_ = m;
										_tmp876_ = vala_method_get_signal_reference (_tmp875_);
										_tmp877_ = _tmp876_;
										vala_expression_set_symbol_reference ((ValaExpression*) self, (ValaSymbol*) _tmp877_);
									} else {
										ValaMethod* _tmp878_;
										_tmp878_ = m;
										vala_expression_set_symbol_reference ((ValaExpression*) self, (ValaSymbol*) _tmp878_);
									}
									_tmp879_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
									_tmp880_ = _tmp879_;
									_tmp881_ = _vala_code_node_ref0 (_tmp880_);
									_vala_code_node_unref0 (member);
									member = _tmp881_;
								}
							}
						}
						_tmp882_ = m;
						_tmp883_ = vala_symbol_get_access ((ValaSymbol*) _tmp882_);
						_tmp884_ = _tmp883_;
						access = _tmp884_;
						_tmp885_ = m;
						if (!G_TYPE_CHECK_INSTANCE_TYPE (_tmp885_, VALA_TYPE_CREATION_METHOD)) {
							ValaMethod* _tmp886_;
							ValaMemberBinding _tmp887_;
							ValaMemberBinding _tmp888_;
							_tmp886_ = m;
							_tmp887_ = vala_method_get_binding (_tmp886_);
							_tmp888_ = _tmp887_;
							instance = _tmp888_ == VALA_MEMBER_BINDING_INSTANCE;
						}
						_tmp889_ = m;
						_tmp890_ = vala_method_get_binding (_tmp889_);
						_tmp891_ = _tmp890_;
						klass = _tmp891_ == VALA_MEMBER_BINDING_CLASS;
						{
							ValaList* _param_list = NULL;
							ValaMethod* _tmp892_;
							ValaList* _tmp893_;
							gint _param_size = 0;
							ValaList* _tmp894_;
							gint _tmp895_;
							gint _tmp896_;
							gint _param_index = 0;
							_tmp892_ = m;
							_tmp893_ = vala_callable_get_parameters ((ValaCallable*) _tmp892_);
							_param_list = _tmp893_;
							_tmp894_ = _param_list;
							_tmp895_ = vala_collection_get_size ((ValaCollection*) _tmp894_);
							_tmp896_ = _tmp895_;
							_param_size = _tmp896_;
							_param_index = -1;
							while (TRUE) {
								gint _tmp897_;
								gint _tmp898_;
								gint _tmp899_;
								ValaParameter* param = NULL;
								ValaList* _tmp900_;
								gint _tmp901_;
								gpointer _tmp902_;
								ValaGenericType* generic_type = NULL;
								ValaParameter* _tmp903_;
								ValaDataType* _tmp904_;
								ValaDataType* _tmp905_;
								ValaGenericType* _tmp906_;
								gboolean _tmp907_ = FALSE;
								ValaGenericType* _tmp908_;
								_tmp897_ = _param_index;
								_param_index = _tmp897_ + 1;
								_tmp898_ = _param_index;
								_tmp899_ = _param_size;
								if (!(_tmp898_ < _tmp899_)) {
									break;
								}
								_tmp900_ = _param_list;
								_tmp901_ = _param_index;
								_tmp902_ = vala_list_get (_tmp900_, _tmp901_);
								param = (ValaParameter*) _tmp902_;
								_tmp903_ = param;
								_tmp904_ = vala_variable_get_variable_type ((ValaVariable*) _tmp903_);
								_tmp905_ = _tmp904_;
								_tmp906_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp905_, VALA_TYPE_GENERIC_TYPE) ? ((ValaGenericType*) _tmp905_) : NULL);
								generic_type = _tmp906_;
								_tmp908_ = generic_type;
								if (_tmp908_ != NULL) {
									ValaGenericType* _tmp909_;
									ValaTypeParameter* _tmp910_;
									ValaTypeParameter* _tmp911_;
									ValaSymbol* _tmp912_;
									ValaSymbol* _tmp913_;
									_tmp909_ = generic_type;
									_tmp910_ = vala_data_type_get_type_parameter ((ValaDataType*) _tmp909_);
									_tmp911_ = _tmp910_;
									_tmp912_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp911_);
									_tmp913_ = _tmp912_;
									_tmp907_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp913_, VALA_TYPE_TYPESYMBOL);
								} else {
									_tmp907_ = FALSE;
								}
								if (_tmp907_) {
									generics = TRUE;
									_vala_code_node_unref0 (generic_type);
									_vala_code_node_unref0 (param);
									break;
								}
								_vala_code_node_unref0 (generic_type);
								_vala_code_node_unref0 (param);
							}
							_vala_iterable_unref0 (_param_list);
						}
						_tmp914_ = m;
						_tmp915_ = vala_callable_get_return_type ((ValaCallable*) _tmp914_);
						_tmp916_ = _tmp915_;
						_tmp917_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp916_, VALA_TYPE_GENERIC_TYPE) ? ((ValaGenericType*) _tmp916_) : NULL);
						generic_type = _tmp917_;
						_tmp919_ = generic_type;
						if (_tmp919_ != NULL) {
							ValaGenericType* _tmp920_;
							ValaTypeParameter* _tmp921_;
							ValaTypeParameter* _tmp922_;
							ValaSymbol* _tmp923_;
							ValaSymbol* _tmp924_;
							_tmp920_ = generic_type;
							_tmp921_ = vala_data_type_get_type_parameter ((ValaDataType*) _tmp920_);
							_tmp922_ = _tmp921_;
							_tmp923_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp922_);
							_tmp924_ = _tmp923_;
							_tmp918_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp924_, VALA_TYPE_TYPESYMBOL);
						} else {
							_tmp918_ = FALSE;
						}
						if (_tmp918_) {
							generics = TRUE;
						}
						_vala_code_node_unref0 (generic_type);
						_vala_code_node_unref0 (m);
					} else {
						ValaSymbol* _tmp925_;
						_tmp925_ = member;
						if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp925_, VALA_TYPE_PROPERTY)) {
							ValaProperty* prop = NULL;
							ValaSymbol* _tmp926_;
							ValaProperty* _tmp927_;
							ValaProperty* _tmp928_;
							ValaCodeContext* _tmp929_;
							gboolean _tmp930_;
							ValaProperty* _tmp931_;
							ValaProperty* _tmp932_;
							ValaProperty* _tmp933_;
							ValaProperty* _tmp953_;
							ValaSymbolAccessibility _tmp954_;
							ValaSymbolAccessibility _tmp955_;
							gboolean _tmp956_;
							gboolean _tmp957_;
							ValaProperty* _tmp1022_;
							ValaMemberBinding _tmp1023_;
							ValaMemberBinding _tmp1024_;
							ValaProperty* _tmp1025_;
							ValaDataType* _tmp1026_;
							ValaDataType* _tmp1027_;
							_tmp926_ = member;
							_tmp927_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp926_, VALA_TYPE_PROPERTY, ValaProperty));
							prop = _tmp927_;
							_tmp928_ = prop;
							_tmp929_ = context;
							_tmp930_ = vala_code_node_check ((ValaCodeNode*) _tmp928_, _tmp929_);
							if (!_tmp930_) {
								vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
								result = FALSE;
								_vala_code_node_unref0 (prop);
								_vala_code_node_unref0 (member);
								_vala_code_node_unref0 (this_parameter);
								_vala_code_node_unref0 (base_symbol);
								return result;
							}
							_tmp931_ = prop;
							_tmp932_ = vala_property_get_base_property (_tmp931_);
							_tmp933_ = _tmp932_;
							if (_tmp933_ != NULL) {
								ValaProperty* _tmp934_;
								ValaProperty* _tmp935_;
								ValaProperty* _tmp936_;
								ValaProperty* _tmp937_;
								ValaProperty* _tmp938_;
								ValaSymbol* _tmp939_;
								ValaSymbol* _tmp940_;
								ValaSymbol* _tmp941_;
								_tmp934_ = prop;
								_tmp935_ = vala_property_get_base_property (_tmp934_);
								_tmp936_ = _tmp935_;
								_tmp937_ = _vala_code_node_ref0 (_tmp936_);
								_vala_code_node_unref0 (prop);
								prop = _tmp937_;
								_tmp938_ = prop;
								vala_expression_set_symbol_reference ((ValaExpression*) self, (ValaSymbol*) _tmp938_);
								_tmp939_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
								_tmp940_ = _tmp939_;
								_tmp941_ = _vala_code_node_ref0 (_tmp940_);
								_vala_code_node_unref0 (member);
								member = _tmp941_;
							} else {
								ValaProperty* _tmp942_;
								ValaProperty* _tmp943_;
								ValaProperty* _tmp944_;
								_tmp942_ = prop;
								_tmp943_ = vala_property_get_base_interface_property (_tmp942_);
								_tmp944_ = _tmp943_;
								if (_tmp944_ != NULL) {
									ValaProperty* _tmp945_;
									ValaProperty* _tmp946_;
									ValaProperty* _tmp947_;
									ValaProperty* _tmp948_;
									ValaProperty* _tmp949_;
									ValaSymbol* _tmp950_;
									ValaSymbol* _tmp951_;
									ValaSymbol* _tmp952_;
									_tmp945_ = prop;
									_tmp946_ = vala_property_get_base_interface_property (_tmp945_);
									_tmp947_ = _tmp946_;
									_tmp948_ = _vala_code_node_ref0 (_tmp947_);
									_vala_code_node_unref0 (prop);
									prop = _tmp948_;
									_tmp949_ = prop;
									vala_expression_set_symbol_reference ((ValaExpression*) self, (ValaSymbol*) _tmp949_);
									_tmp950_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
									_tmp951_ = _tmp950_;
									_tmp952_ = _vala_code_node_ref0 (_tmp951_);
									_vala_code_node_unref0 (member);
									member = _tmp952_;
								}
							}
							_tmp953_ = prop;
							_tmp954_ = vala_symbol_get_access ((ValaSymbol*) _tmp953_);
							_tmp955_ = _tmp954_;
							access = _tmp955_;
							_tmp956_ = vala_expression_get_lvalue ((ValaExpression*) self);
							_tmp957_ = _tmp956_;
							if (_tmp957_) {
								ValaProperty* _tmp958_;
								ValaPropertyAccessor* _tmp959_;
								ValaPropertyAccessor* _tmp960_;
								ValaProperty* _tmp968_;
								ValaSymbolAccessibility _tmp969_;
								ValaSymbolAccessibility _tmp970_;
								_tmp958_ = prop;
								_tmp959_ = vala_property_get_set_accessor (_tmp958_);
								_tmp960_ = _tmp959_;
								if (_tmp960_ == NULL) {
									ValaSourceReference* _tmp961_;
									ValaSourceReference* _tmp962_;
									ValaProperty* _tmp963_;
									gchar* _tmp964_;
									gchar* _tmp965_;
									gchar* _tmp966_;
									gchar* _tmp967_;
									vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
									_tmp961_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
									_tmp962_ = _tmp961_;
									_tmp963_ = prop;
									_tmp964_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp963_);
									_tmp965_ = _tmp964_;
									_tmp966_ = g_strdup_printf ("Property `%s' is read-only", _tmp965_);
									_tmp967_ = _tmp966_;
									vala_report_error (_tmp962_, _tmp967_);
									_g_free0 (_tmp967_);
									_g_free0 (_tmp965_);
									result = FALSE;
									_vala_code_node_unref0 (prop);
									_vala_code_node_unref0 (member);
									_vala_code_node_unref0 (this_parameter);
									_vala_code_node_unref0 (base_symbol);
									return result;
								}
								_tmp968_ = prop;
								_tmp969_ = vala_symbol_get_access ((ValaSymbol*) _tmp968_);
								_tmp970_ = _tmp969_;
								if (_tmp970_ == VALA_SYMBOL_ACCESSIBILITY_PUBLIC) {
									ValaProperty* _tmp971_;
									ValaPropertyAccessor* _tmp972_;
									ValaPropertyAccessor* _tmp973_;
									ValaSymbolAccessibility _tmp974_;
									ValaSymbolAccessibility _tmp975_;
									_tmp971_ = prop;
									_tmp972_ = vala_property_get_set_accessor (_tmp971_);
									_tmp973_ = _tmp972_;
									_tmp974_ = vala_symbol_get_access ((ValaSymbol*) _tmp973_);
									_tmp975_ = _tmp974_;
									access = _tmp975_;
								} else {
									gboolean _tmp976_ = FALSE;
									ValaProperty* _tmp977_;
									ValaSymbolAccessibility _tmp978_;
									ValaSymbolAccessibility _tmp979_;
									_tmp977_ = prop;
									_tmp978_ = vala_symbol_get_access ((ValaSymbol*) _tmp977_);
									_tmp979_ = _tmp978_;
									if (_tmp979_ == VALA_SYMBOL_ACCESSIBILITY_PROTECTED) {
										ValaProperty* _tmp980_;
										ValaPropertyAccessor* _tmp981_;
										ValaPropertyAccessor* _tmp982_;
										ValaSymbolAccessibility _tmp983_;
										ValaSymbolAccessibility _tmp984_;
										_tmp980_ = prop;
										_tmp981_ = vala_property_get_set_accessor (_tmp980_);
										_tmp982_ = _tmp981_;
										_tmp983_ = vala_symbol_get_access ((ValaSymbol*) _tmp982_);
										_tmp984_ = _tmp983_;
										_tmp976_ = _tmp984_ != VALA_SYMBOL_ACCESSIBILITY_PUBLIC;
									} else {
										_tmp976_ = FALSE;
									}
									if (_tmp976_) {
										ValaProperty* _tmp985_;
										ValaPropertyAccessor* _tmp986_;
										ValaPropertyAccessor* _tmp987_;
										ValaSymbolAccessibility _tmp988_;
										ValaSymbolAccessibility _tmp989_;
										_tmp985_ = prop;
										_tmp986_ = vala_property_get_set_accessor (_tmp985_);
										_tmp987_ = _tmp986_;
										_tmp988_ = vala_symbol_get_access ((ValaSymbol*) _tmp987_);
										_tmp989_ = _tmp988_;
										access = _tmp989_;
									}
								}
							} else {
								ValaProperty* _tmp990_;
								ValaPropertyAccessor* _tmp991_;
								ValaPropertyAccessor* _tmp992_;
								ValaProperty* _tmp1000_;
								ValaSymbolAccessibility _tmp1001_;
								ValaSymbolAccessibility _tmp1002_;
								_tmp990_ = prop;
								_tmp991_ = vala_property_get_get_accessor (_tmp990_);
								_tmp992_ = _tmp991_;
								if (_tmp992_ == NULL) {
									ValaSourceReference* _tmp993_;
									ValaSourceReference* _tmp994_;
									ValaProperty* _tmp995_;
									gchar* _tmp996_;
									gchar* _tmp997_;
									gchar* _tmp998_;
									gchar* _tmp999_;
									vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
									_tmp993_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
									_tmp994_ = _tmp993_;
									_tmp995_ = prop;
									_tmp996_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp995_);
									_tmp997_ = _tmp996_;
									_tmp998_ = g_strdup_printf ("Property `%s' is write-only", _tmp997_);
									_tmp999_ = _tmp998_;
									vala_report_error (_tmp994_, _tmp999_);
									_g_free0 (_tmp999_);
									_g_free0 (_tmp997_);
									result = FALSE;
									_vala_code_node_unref0 (prop);
									_vala_code_node_unref0 (member);
									_vala_code_node_unref0 (this_parameter);
									_vala_code_node_unref0 (base_symbol);
									return result;
								}
								_tmp1000_ = prop;
								_tmp1001_ = vala_symbol_get_access ((ValaSymbol*) _tmp1000_);
								_tmp1002_ = _tmp1001_;
								if (_tmp1002_ == VALA_SYMBOL_ACCESSIBILITY_PUBLIC) {
									ValaProperty* _tmp1003_;
									ValaPropertyAccessor* _tmp1004_;
									ValaPropertyAccessor* _tmp1005_;
									ValaSymbolAccessibility _tmp1006_;
									ValaSymbolAccessibility _tmp1007_;
									_tmp1003_ = prop;
									_tmp1004_ = vala_property_get_get_accessor (_tmp1003_);
									_tmp1005_ = _tmp1004_;
									_tmp1006_ = vala_symbol_get_access ((ValaSymbol*) _tmp1005_);
									_tmp1007_ = _tmp1006_;
									access = _tmp1007_;
								} else {
									gboolean _tmp1008_ = FALSE;
									ValaProperty* _tmp1009_;
									ValaSymbolAccessibility _tmp1010_;
									ValaSymbolAccessibility _tmp1011_;
									_tmp1009_ = prop;
									_tmp1010_ = vala_symbol_get_access ((ValaSymbol*) _tmp1009_);
									_tmp1011_ = _tmp1010_;
									if (_tmp1011_ == VALA_SYMBOL_ACCESSIBILITY_PROTECTED) {
										ValaProperty* _tmp1012_;
										ValaPropertyAccessor* _tmp1013_;
										ValaPropertyAccessor* _tmp1014_;
										ValaSymbolAccessibility _tmp1015_;
										ValaSymbolAccessibility _tmp1016_;
										_tmp1012_ = prop;
										_tmp1013_ = vala_property_get_get_accessor (_tmp1012_);
										_tmp1014_ = _tmp1013_;
										_tmp1015_ = vala_symbol_get_access ((ValaSymbol*) _tmp1014_);
										_tmp1016_ = _tmp1015_;
										_tmp1008_ = _tmp1016_ != VALA_SYMBOL_ACCESSIBILITY_PUBLIC;
									} else {
										_tmp1008_ = FALSE;
									}
									if (_tmp1008_) {
										ValaProperty* _tmp1017_;
										ValaPropertyAccessor* _tmp1018_;
										ValaPropertyAccessor* _tmp1019_;
										ValaSymbolAccessibility _tmp1020_;
										ValaSymbolAccessibility _tmp1021_;
										_tmp1017_ = prop;
										_tmp1018_ = vala_property_get_get_accessor (_tmp1017_);
										_tmp1019_ = _tmp1018_;
										_tmp1020_ = vala_symbol_get_access ((ValaSymbol*) _tmp1019_);
										_tmp1021_ = _tmp1020_;
										access = _tmp1021_;
									}
								}
							}
							_tmp1022_ = prop;
							_tmp1023_ = vala_property_get_binding (_tmp1022_);
							_tmp1024_ = _tmp1023_;
							instance = _tmp1024_ == VALA_MEMBER_BINDING_INSTANCE;
							_tmp1025_ = prop;
							_tmp1026_ = vala_property_get_property_type (_tmp1025_);
							_tmp1027_ = _tmp1026_;
							if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp1027_, VALA_TYPE_GENERIC_TYPE)) {
								generics = TRUE;
							}
							_vala_code_node_unref0 (prop);
						} else {
							ValaSymbol* _tmp1028_;
							_tmp1028_ = member;
							if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp1028_, VALA_TYPE_SIGNAL)) {
								ValaSymbol* _tmp1029_;
								ValaSymbolAccessibility _tmp1030_;
								ValaSymbolAccessibility _tmp1031_;
								instance = TRUE;
								_tmp1029_ = member;
								_tmp1030_ = vala_symbol_get_access (_tmp1029_);
								_tmp1031_ = _tmp1030_;
								access = _tmp1031_;
							}
						}
					}
				}
			}
		}
	}
	_tmp1032_ = member;
	vala_symbol_set_used (_tmp1032_, TRUE);
	_tmp1033_ = member;
	_tmp1034_ = vala_symbol_get_version (_tmp1033_);
	_tmp1035_ = _tmp1034_;
	_tmp1036_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
	_tmp1037_ = _tmp1036_;
	vala_version_attribute_check (_tmp1035_, _tmp1037_);
	_tmp1038_ = access;
	if (_tmp1038_ == VALA_SYMBOL_ACCESSIBILITY_PROTECTED) {
		ValaTypeSymbol* target_type = NULL;
		ValaSymbol* _tmp1039_;
		ValaSymbol* _tmp1040_;
		ValaSymbol* _tmp1041_;
		ValaTypeSymbol* _tmp1042_;
		gboolean in_subtype = FALSE;
		gboolean _tmp1064_;
		_tmp1039_ = member;
		_tmp1040_ = vala_symbol_get_parent_symbol (_tmp1039_);
		_tmp1041_ = _tmp1040_;
		_tmp1042_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp1041_, VALA_TYPE_TYPESYMBOL, ValaTypeSymbol));
		target_type = _tmp1042_;
		in_subtype = FALSE;
		{
			ValaSymbol* this_symbol = NULL;
			ValaCodeContext* _tmp1043_;
			ValaSemanticAnalyzer* _tmp1044_;
			ValaSemanticAnalyzer* _tmp1045_;
			ValaSymbol* _tmp1046_;
			ValaSymbol* _tmp1047_;
			ValaSymbol* _tmp1048_;
			_tmp1043_ = context;
			_tmp1044_ = vala_code_context_get_analyzer (_tmp1043_);
			_tmp1045_ = _tmp1044_;
			_tmp1046_ = vala_semantic_analyzer_get_current_symbol (_tmp1045_);
			_tmp1047_ = _tmp1046_;
			_tmp1048_ = _vala_code_node_ref0 (_tmp1047_);
			this_symbol = _tmp1048_;
			{
				gboolean _tmp1049_ = FALSE;
				_tmp1049_ = TRUE;
				while (TRUE) {
					ValaSymbol* _tmp1054_;
					ValaSymbol* _tmp1055_;
					ValaTypeSymbol* _tmp1056_;
					ValaClass* cl = NULL;
					ValaSymbol* _tmp1057_;
					ValaClass* _tmp1058_;
					gboolean _tmp1059_ = FALSE;
					ValaClass* _tmp1060_;
					if (!_tmp1049_) {
						ValaSymbol* _tmp1050_;
						ValaSymbol* _tmp1051_;
						ValaSymbol* _tmp1052_;
						ValaSymbol* _tmp1053_;
						_tmp1050_ = this_symbol;
						_tmp1051_ = vala_symbol_get_parent_symbol (_tmp1050_);
						_tmp1052_ = _tmp1051_;
						_tmp1053_ = _vala_code_node_ref0 (_tmp1052_);
						_vala_code_node_unref0 (this_symbol);
						this_symbol = _tmp1053_;
					}
					_tmp1049_ = FALSE;
					_tmp1054_ = this_symbol;
					if (!(_tmp1054_ != NULL)) {
						break;
					}
					_tmp1055_ = this_symbol;
					_tmp1056_ = target_type;
					if (_tmp1055_ == G_TYPE_CHECK_INSTANCE_CAST (_tmp1056_, VALA_TYPE_SYMBOL, ValaSymbol)) {
						in_subtype = TRUE;
						break;
					}
					_tmp1057_ = this_symbol;
					_tmp1058_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp1057_, VALA_TYPE_CLASS) ? ((ValaClass*) _tmp1057_) : NULL);
					cl = _tmp1058_;
					_tmp1060_ = cl;
					if (_tmp1060_ != NULL) {
						ValaClass* _tmp1061_;
						ValaTypeSymbol* _tmp1062_;
						gboolean _tmp1063_;
						_tmp1061_ = cl;
						_tmp1062_ = target_type;
						_tmp1063_ = vala_typesymbol_is_subtype_of ((ValaTypeSymbol*) _tmp1061_, _tmp1062_);
						_tmp1059_ = _tmp1063_;
					} else {
						_tmp1059_ = FALSE;
					}
					if (_tmp1059_) {
						in_subtype = TRUE;
						_vala_code_node_unref0 (cl);
						break;
					}
					_vala_code_node_unref0 (cl);
				}
			}
			_vala_code_node_unref0 (this_symbol);
		}
		_tmp1064_ = in_subtype;
		if (!_tmp1064_) {
			ValaSourceReference* _tmp1065_;
			ValaSourceReference* _tmp1066_;
			ValaSymbol* _tmp1067_;
			gchar* _tmp1068_;
			gchar* _tmp1069_;
			gchar* _tmp1070_;
			gchar* _tmp1071_;
			vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
			_tmp1065_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
			_tmp1066_ = _tmp1065_;
			_tmp1067_ = member;
			_tmp1068_ = vala_symbol_get_full_name (_tmp1067_);
			_tmp1069_ = _tmp1068_;
			_tmp1070_ = g_strdup_printf ("Access to protected member `%s' denied", _tmp1069_);
			_tmp1071_ = _tmp1070_;
			vala_report_error (_tmp1066_, _tmp1071_);
			_g_free0 (_tmp1071_);
			_g_free0 (_tmp1069_);
			result = FALSE;
			_vala_code_node_unref0 (target_type);
			_vala_code_node_unref0 (member);
			_vala_code_node_unref0 (this_parameter);
			_vala_code_node_unref0 (base_symbol);
			return result;
		}
		_vala_code_node_unref0 (target_type);
	} else {
		ValaSymbolAccessibility _tmp1072_;
		_tmp1072_ = access;
		if (_tmp1072_ == VALA_SYMBOL_ACCESSIBILITY_PRIVATE) {
			ValaSymbol* target_type = NULL;
			ValaSymbol* _tmp1073_;
			ValaSymbol* _tmp1074_;
			ValaSymbol* _tmp1075_;
			ValaSymbol* _tmp1076_;
			gboolean in_target_type = FALSE;
			gboolean _tmp1091_;
			_tmp1073_ = member;
			_tmp1074_ = vala_symbol_get_parent_symbol (_tmp1073_);
			_tmp1075_ = _tmp1074_;
			_tmp1076_ = _vala_code_node_ref0 (_tmp1075_);
			target_type = _tmp1076_;
			in_target_type = FALSE;
			{
				ValaSymbol* this_symbol = NULL;
				ValaCodeContext* _tmp1077_;
				ValaSemanticAnalyzer* _tmp1078_;
				ValaSemanticAnalyzer* _tmp1079_;
				ValaSymbol* _tmp1080_;
				ValaSymbol* _tmp1081_;
				ValaSymbol* _tmp1082_;
				_tmp1077_ = context;
				_tmp1078_ = vala_code_context_get_analyzer (_tmp1077_);
				_tmp1079_ = _tmp1078_;
				_tmp1080_ = vala_semantic_analyzer_get_current_symbol (_tmp1079_);
				_tmp1081_ = _tmp1080_;
				_tmp1082_ = _vala_code_node_ref0 (_tmp1081_);
				this_symbol = _tmp1082_;
				{
					gboolean _tmp1083_ = FALSE;
					_tmp1083_ = TRUE;
					while (TRUE) {
						ValaSymbol* _tmp1088_;
						ValaSymbol* _tmp1089_;
						ValaSymbol* _tmp1090_;
						if (!_tmp1083_) {
							ValaSymbol* _tmp1084_;
							ValaSymbol* _tmp1085_;
							ValaSymbol* _tmp1086_;
							ValaSymbol* _tmp1087_;
							_tmp1084_ = this_symbol;
							_tmp1085_ = vala_symbol_get_parent_symbol (_tmp1084_);
							_tmp1086_ = _tmp1085_;
							_tmp1087_ = _vala_code_node_ref0 (_tmp1086_);
							_vala_code_node_unref0 (this_symbol);
							this_symbol = _tmp1087_;
						}
						_tmp1083_ = FALSE;
						_tmp1088_ = this_symbol;
						if (!(_tmp1088_ != NULL)) {
							break;
						}
						_tmp1089_ = target_type;
						_tmp1090_ = this_symbol;
						if (_tmp1089_ == _tmp1090_) {
							in_target_type = TRUE;
							break;
						}
					}
				}
				_vala_code_node_unref0 (this_symbol);
			}
			_tmp1091_ = in_target_type;
			if (!_tmp1091_) {
				ValaSourceReference* _tmp1092_;
				ValaSourceReference* _tmp1093_;
				ValaSymbol* _tmp1094_;
				gchar* _tmp1095_;
				gchar* _tmp1096_;
				gchar* _tmp1097_;
				gchar* _tmp1098_;
				vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
				_tmp1092_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
				_tmp1093_ = _tmp1092_;
				_tmp1094_ = member;
				_tmp1095_ = vala_symbol_get_full_name (_tmp1094_);
				_tmp1096_ = _tmp1095_;
				_tmp1097_ = g_strdup_printf ("Access to private member `%s' denied", _tmp1096_);
				_tmp1098_ = _tmp1097_;
				vala_report_error (_tmp1093_, _tmp1098_);
				_g_free0 (_tmp1098_);
				_g_free0 (_tmp1096_);
				result = FALSE;
				_vala_code_node_unref0 (target_type);
				_vala_code_node_unref0 (member);
				_vala_code_node_unref0 (this_parameter);
				_vala_code_node_unref0 (base_symbol);
				return result;
			}
			_vala_code_node_unref0 (target_type);
		}
	}
	_tmp1100_ = generics;
	if (_tmp1100_) {
		ValaExpression* _tmp1101_;
		ValaExpression* _tmp1102_;
		_tmp1101_ = vala_member_access_get_inner (self);
		_tmp1102_ = _tmp1101_;
		_tmp1099_ = _tmp1102_ != NULL;
	} else {
		_tmp1099_ = FALSE;
	}
	if (_tmp1099_) {
		ValaDataType* instance_type = NULL;
		ValaExpression* _tmp1103_;
		ValaExpression* _tmp1104_;
		ValaDataType* _tmp1105_;
		ValaDataType* _tmp1106_;
		ValaDataType* _tmp1107_;
		ValaPointerType* pointer_type = NULL;
		ValaExpression* _tmp1108_;
		ValaExpression* _tmp1109_;
		ValaDataType* _tmp1110_;
		ValaDataType* _tmp1111_;
		ValaPointerType* _tmp1112_;
		ValaPointerType* _tmp1113_;
		ValaObjectType* object_type = NULL;
		ValaDataType* _tmp1118_;
		ValaObjectType* _tmp1119_;
		gboolean _tmp1120_ = FALSE;
		gboolean _tmp1121_ = FALSE;
		ValaObjectType* _tmp1122_;
		_tmp1103_ = vala_member_access_get_inner (self);
		_tmp1104_ = _tmp1103_;
		_tmp1105_ = vala_expression_get_value_type (_tmp1104_);
		_tmp1106_ = _tmp1105_;
		_tmp1107_ = _vala_code_node_ref0 (_tmp1106_);
		instance_type = _tmp1107_;
		_tmp1108_ = vala_member_access_get_inner (self);
		_tmp1109_ = _tmp1108_;
		_tmp1110_ = vala_expression_get_value_type (_tmp1109_);
		_tmp1111_ = _tmp1110_;
		_tmp1112_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp1111_, VALA_TYPE_POINTER_TYPE) ? ((ValaPointerType*) _tmp1111_) : NULL);
		pointer_type = _tmp1112_;
		_tmp1113_ = pointer_type;
		if (_tmp1113_ != NULL) {
			ValaPointerType* _tmp1114_;
			ValaDataType* _tmp1115_;
			ValaDataType* _tmp1116_;
			ValaDataType* _tmp1117_;
			_tmp1114_ = pointer_type;
			_tmp1115_ = vala_pointer_type_get_base_type (_tmp1114_);
			_tmp1116_ = _tmp1115_;
			_tmp1117_ = _vala_code_node_ref0 (_tmp1116_);
			_vala_code_node_unref0 (instance_type);
			instance_type = _tmp1117_;
		}
		_tmp1118_ = instance_type;
		_tmp1119_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp1118_, VALA_TYPE_OBJECT_TYPE) ? ((ValaObjectType*) _tmp1118_) : NULL);
		object_type = _tmp1119_;
		_tmp1122_ = object_type;
		if (_tmp1122_ != NULL) {
			ValaObjectType* _tmp1123_;
			ValaObjectTypeSymbol* _tmp1124_;
			ValaObjectTypeSymbol* _tmp1125_;
			ValaList* _tmp1126_;
			ValaList* _tmp1127_;
			gint _tmp1128_;
			gint _tmp1129_;
			_tmp1123_ = object_type;
			_tmp1124_ = vala_object_type_get_type_symbol (_tmp1123_);
			_tmp1125_ = _tmp1124_;
			_tmp1126_ = vala_object_type_symbol_get_type_parameters (_tmp1125_);
			_tmp1127_ = _tmp1126_;
			_tmp1128_ = vala_collection_get_size ((ValaCollection*) _tmp1127_);
			_tmp1129_ = _tmp1128_;
			_tmp1121_ = _tmp1129_ > 0;
			_vala_iterable_unref0 (_tmp1127_);
		} else {
			_tmp1121_ = FALSE;
		}
		if (_tmp1121_) {
			ValaDataType* _tmp1130_;
			ValaList* _tmp1131_;
			ValaList* _tmp1132_;
			gint _tmp1133_;
			gint _tmp1134_;
			_tmp1130_ = instance_type;
			_tmp1131_ = vala_data_type_get_type_arguments (_tmp1130_);
			_tmp1132_ = _tmp1131_;
			_tmp1133_ = vala_collection_get_size ((ValaCollection*) _tmp1132_);
			_tmp1134_ = _tmp1133_;
			_tmp1120_ = _tmp1134_ == 0;
			_vala_iterable_unref0 (_tmp1132_);
		} else {
			_tmp1120_ = FALSE;
		}
		if (_tmp1120_) {
			ValaExpression* _tmp1135_;
			ValaExpression* _tmp1136_;
			ValaSourceReference* _tmp1137_;
			ValaSourceReference* _tmp1138_;
			vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
			_tmp1135_ = vala_member_access_get_inner (self);
			_tmp1136_ = _tmp1135_;
			_tmp1137_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp1136_);
			_tmp1138_ = _tmp1137_;
			vala_report_error (_tmp1138_, "missing generic type arguments");
			result = FALSE;
			_vala_code_node_unref0 (object_type);
			_vala_code_node_unref0 (pointer_type);
			_vala_code_node_unref0 (instance_type);
			_vala_code_node_unref0 (member);
			_vala_code_node_unref0 (this_parameter);
			_vala_code_node_unref0 (base_symbol);
			return result;
		}
		_vala_code_node_unref0 (object_type);
		_vala_code_node_unref0 (pointer_type);
		_vala_code_node_unref0 (instance_type);
	}
	_tmp1141_ = instance;
	if (_tmp1141_) {
		gboolean _tmp1142_;
		_tmp1142_ = may_access_instance_members;
		_tmp1140_ = !_tmp1142_;
	} else {
		_tmp1140_ = FALSE;
	}
	if (_tmp1140_) {
		_tmp1139_ = TRUE;
	} else {
		gboolean _tmp1143_ = FALSE;
		gboolean _tmp1144_;
		_tmp1144_ = klass;
		if (_tmp1144_) {
			gboolean _tmp1145_;
			_tmp1145_ = may_access_klass_members;
			_tmp1143_ = !_tmp1145_;
		} else {
			_tmp1143_ = FALSE;
		}
		_tmp1139_ = _tmp1143_;
	}
	if (_tmp1139_) {
		ValaSymbol* _tmp1146_;
		ValaSymbol* _tmp1147_;
		ValaDataType* _tmp1165_;
		ValaDataType* _tmp1166_;
		vala_member_access_set_prototype_access (self, TRUE);
		_tmp1146_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
		_tmp1147_ = _tmp1146_;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp1147_, VALA_TYPE_METHOD)) {
			ValaCodeContext* _tmp1148_;
			ValaSemanticAnalyzer* _tmp1149_;
			ValaSemanticAnalyzer* _tmp1150_;
			ValaSymbol* _tmp1151_;
			ValaSymbol* _tmp1152_;
			gboolean _tmp1153_;
			gboolean _tmp1154_;
			ValaDataType* _tmp1155_;
			ValaDataType* _tmp1156_;
			_tmp1148_ = context;
			_tmp1149_ = vala_code_context_get_analyzer (_tmp1148_);
			_tmp1150_ = _tmp1149_;
			_tmp1151_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
			_tmp1152_ = _tmp1151_;
			_tmp1153_ = vala_expression_get_lvalue ((ValaExpression*) self);
			_tmp1154_ = _tmp1153_;
			_tmp1155_ = vala_semantic_analyzer_get_value_type_for_symbol (_tmp1150_, _tmp1152_, _tmp1154_);
			_tmp1156_ = _tmp1155_;
			vala_expression_set_value_type ((ValaExpression*) self, _tmp1156_);
			_vala_code_node_unref0 (_tmp1156_);
		} else {
			ValaSymbol* _tmp1157_;
			ValaSymbol* _tmp1158_;
			_tmp1157_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
			_tmp1158_ = _tmp1157_;
			if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp1158_, VALA_TYPE_FIELD)) {
				ValaSymbol* _tmp1159_;
				ValaSymbol* _tmp1160_;
				ValaFieldPrototype* _tmp1161_;
				ValaFieldPrototype* _tmp1162_;
				_tmp1159_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
				_tmp1160_ = _tmp1159_;
				_tmp1161_ = vala_field_prototype_new (G_TYPE_CHECK_INSTANCE_CAST (_tmp1160_, VALA_TYPE_FIELD, ValaField));
				_tmp1162_ = _tmp1161_;
				vala_expression_set_value_type ((ValaExpression*) self, (ValaDataType*) _tmp1162_);
				_vala_code_node_unref0 (_tmp1162_);
			} else {
				ValaInvalidType* _tmp1163_;
				ValaInvalidType* _tmp1164_;
				_tmp1163_ = vala_invalid_type_new ();
				_tmp1164_ = _tmp1163_;
				vala_expression_set_value_type ((ValaExpression*) self, (ValaDataType*) _tmp1164_);
				_vala_code_node_unref0 (_tmp1164_);
			}
		}
		_tmp1165_ = vala_expression_get_target_type ((ValaExpression*) self);
		_tmp1166_ = _tmp1165_;
		if (_tmp1166_ != NULL) {
			ValaDataType* _tmp1167_;
			ValaDataType* _tmp1168_;
			ValaDataType* _tmp1169_;
			ValaDataType* _tmp1170_;
			gboolean _tmp1171_;
			gboolean _tmp1172_;
			_tmp1167_ = vala_expression_get_value_type ((ValaExpression*) self);
			_tmp1168_ = _tmp1167_;
			_tmp1169_ = vala_expression_get_target_type ((ValaExpression*) self);
			_tmp1170_ = _tmp1169_;
			_tmp1171_ = vala_data_type_get_value_owned (_tmp1170_);
			_tmp1172_ = _tmp1171_;
			vala_data_type_set_value_owned (_tmp1168_, _tmp1172_);
		}
	} else {
		gboolean _tmp1173_ = FALSE;
		gboolean _tmp1174_;
		gboolean _tmp1195_ = FALSE;
		gboolean _tmp1196_ = FALSE;
		gboolean _tmp1197_ = FALSE;
		gboolean _tmp1198_ = FALSE;
		gboolean _tmp1199_;
		gboolean _tmp1218_ = FALSE;
		gboolean _tmp1219_ = FALSE;
		gboolean _tmp1220_ = FALSE;
		gboolean _tmp1221_ = FALSE;
		gboolean _tmp1222_ = FALSE;
		ValaCodeContext* _tmp1223_;
		gboolean _tmp1224_;
		gboolean _tmp1225_;
		ValaMethod* m = NULL;
		ValaSymbol* _tmp1253_;
		ValaSymbol* _tmp1254_;
		ValaMethod* _tmp1255_;
		ValaMemberAccess* inner_ma = NULL;
		ValaExpression* _tmp1256_;
		ValaExpression* _tmp1257_;
		ValaMemberAccess* _tmp1258_;
		gboolean _tmp1259_ = FALSE;
		gboolean _tmp1260_ = FALSE;
		gboolean _tmp1261_ = FALSE;
		gboolean _tmp1262_ = FALSE;
		gboolean _tmp1263_ = FALSE;
		ValaMethod* _tmp1264_;
		ValaCodeContext* _tmp1305_;
		ValaSemanticAnalyzer* _tmp1306_;
		ValaSemanticAnalyzer* _tmp1307_;
		ValaSymbol* _tmp1308_;
		ValaSymbol* _tmp1309_;
		gboolean _tmp1310_;
		gboolean _tmp1311_;
		ValaDataType* _tmp1312_;
		ValaDataType* _tmp1313_;
		gboolean _tmp1314_ = FALSE;
		ValaExpression* _tmp1315_;
		ValaExpression* _tmp1316_;
		ValaSymbol* _tmp1329_;
		ValaSymbol* _tmp1330_;
		_tmp1174_ = instance;
		if (_tmp1174_) {
			ValaExpression* _tmp1175_;
			ValaExpression* _tmp1176_;
			_tmp1175_ = vala_member_access_get_inner (self);
			_tmp1176_ = _tmp1175_;
			_tmp1173_ = _tmp1176_ == NULL;
		} else {
			_tmp1173_ = FALSE;
		}
		if (_tmp1173_) {
			ValaSourceReference* _tmp1177_;
			ValaSourceReference* _tmp1178_;
			ValaMemberAccess* _tmp1179_;
			ValaMemberAccess* _tmp1180_;
			ValaExpression* _tmp1181_;
			ValaExpression* _tmp1182_;
			ValaParameter* _tmp1183_;
			ValaDataType* _tmp1184_;
			ValaDataType* _tmp1185_;
			ValaDataType* _tmp1186_;
			ValaDataType* _tmp1187_;
			ValaExpression* _tmp1188_;
			ValaExpression* _tmp1189_;
			ValaDataType* _tmp1190_;
			ValaDataType* _tmp1191_;
			ValaExpression* _tmp1192_;
			ValaExpression* _tmp1193_;
			ValaParameter* _tmp1194_;
			_tmp1177_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
			_tmp1178_ = _tmp1177_;
			_tmp1179_ = vala_member_access_new (NULL, "this", _tmp1178_);
			_tmp1180_ = _tmp1179_;
			vala_member_access_set_inner (self, (ValaExpression*) _tmp1180_);
			_vala_code_node_unref0 (_tmp1180_);
			_tmp1181_ = vala_member_access_get_inner (self);
			_tmp1182_ = _tmp1181_;
			_tmp1183_ = this_parameter;
			_tmp1184_ = vala_variable_get_variable_type ((ValaVariable*) _tmp1183_);
			_tmp1185_ = _tmp1184_;
			_tmp1186_ = vala_data_type_copy (_tmp1185_);
			_tmp1187_ = _tmp1186_;
			vala_expression_set_value_type (_tmp1182_, _tmp1187_);
			_vala_code_node_unref0 (_tmp1187_);
			_tmp1188_ = vala_member_access_get_inner (self);
			_tmp1189_ = _tmp1188_;
			_tmp1190_ = vala_expression_get_value_type (_tmp1189_);
			_tmp1191_ = _tmp1190_;
			vala_data_type_set_value_owned (_tmp1191_, FALSE);
			_tmp1192_ = vala_member_access_get_inner (self);
			_tmp1193_ = _tmp1192_;
			_tmp1194_ = this_parameter;
			vala_expression_set_symbol_reference (_tmp1193_, (ValaSymbol*) _tmp1194_);
		} else {
			vala_member_access_check_lvalue_access (self);
		}
		_tmp1199_ = instance;
		if (!_tmp1199_) {
			gboolean _tmp1200_;
			_tmp1200_ = klass;
			_tmp1198_ = !_tmp1200_;
		} else {
			_tmp1198_ = FALSE;
		}
		if (_tmp1198_) {
			ValaSymbol* _tmp1201_;
			ValaSymbol* _tmp1202_;
			_tmp1201_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
			_tmp1202_ = _tmp1201_;
			_tmp1197_ = !G_TYPE_CHECK_INSTANCE_TYPE (_tmp1202_, VALA_TYPE_CREATION_METHOD);
		} else {
			_tmp1197_ = FALSE;
		}
		if (_tmp1197_) {
			gboolean _tmp1203_;
			_tmp1203_ = may_access_instance_members;
			_tmp1196_ = _tmp1203_;
		} else {
			_tmp1196_ = FALSE;
		}
		if (_tmp1196_) {
			ValaExpression* _tmp1204_;
			ValaExpression* _tmp1205_;
			_tmp1204_ = vala_member_access_get_inner (self);
			_tmp1205_ = _tmp1204_;
			_tmp1195_ = _tmp1205_ != NULL;
		} else {
			_tmp1195_ = FALSE;
		}
		if (_tmp1195_) {
			ValaExpression* _tmp1206_;
			ValaExpression* _tmp1207_;
			ValaSymbol* _tmp1208_;
			ValaSymbol* _tmp1209_;
			_tmp1206_ = vala_member_access_get_inner (self);
			_tmp1207_ = _tmp1206_;
			_tmp1208_ = vala_expression_get_symbol_reference (_tmp1207_);
			_tmp1209_ = _tmp1208_;
			if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp1209_, VALA_TYPE_METHOD)) {
			} else {
				ValaSourceReference* _tmp1210_;
				ValaSourceReference* _tmp1211_;
				ValaSymbol* _tmp1212_;
				ValaSymbol* _tmp1213_;
				gchar* _tmp1214_;
				gchar* _tmp1215_;
				gchar* _tmp1216_;
				gchar* _tmp1217_;
				_tmp1210_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
				_tmp1211_ = _tmp1210_;
				_tmp1212_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
				_tmp1213_ = _tmp1212_;
				_tmp1214_ = vala_symbol_get_full_name (_tmp1213_);
				_tmp1215_ = _tmp1214_;
				_tmp1216_ = g_strdup_printf ("Access to static member `%s' with an instance reference", _tmp1215_);
				_tmp1217_ = _tmp1216_;
				vala_report_warning (_tmp1211_, _tmp1217_);
				_g_free0 (_tmp1217_);
				_g_free0 (_tmp1215_);
			}
		}
		_tmp1223_ = context;
		_tmp1224_ = vala_code_context_get_experimental_non_null (_tmp1223_);
		_tmp1225_ = _tmp1224_;
		if (_tmp1225_) {
			gboolean _tmp1226_;
			_tmp1226_ = instance;
			_tmp1222_ = _tmp1226_;
		} else {
			_tmp1222_ = FALSE;
		}
		if (_tmp1222_) {
			ValaExpression* _tmp1227_;
			ValaExpression* _tmp1228_;
			ValaDataType* _tmp1229_;
			ValaDataType* _tmp1230_;
			gboolean _tmp1231_;
			gboolean _tmp1232_;
			_tmp1227_ = vala_member_access_get_inner (self);
			_tmp1228_ = _tmp1227_;
			_tmp1229_ = vala_expression_get_value_type (_tmp1228_);
			_tmp1230_ = _tmp1229_;
			_tmp1231_ = vala_data_type_get_nullable (_tmp1230_);
			_tmp1232_ = _tmp1231_;
			_tmp1221_ = _tmp1232_;
		} else {
			_tmp1221_ = FALSE;
		}
		if (_tmp1221_) {
			ValaExpression* _tmp1233_;
			ValaExpression* _tmp1234_;
			ValaDataType* _tmp1235_;
			ValaDataType* _tmp1236_;
			_tmp1233_ = vala_member_access_get_inner (self);
			_tmp1234_ = _tmp1233_;
			_tmp1235_ = vala_expression_get_value_type (_tmp1234_);
			_tmp1236_ = _tmp1235_;
			_tmp1220_ = !G_TYPE_CHECK_INSTANCE_TYPE (_tmp1236_, VALA_TYPE_POINTER_TYPE);
		} else {
			_tmp1220_ = FALSE;
		}
		if (_tmp1220_) {
			ValaExpression* _tmp1237_;
			ValaExpression* _tmp1238_;
			ValaDataType* _tmp1239_;
			ValaDataType* _tmp1240_;
			_tmp1237_ = vala_member_access_get_inner (self);
			_tmp1238_ = _tmp1237_;
			_tmp1239_ = vala_expression_get_value_type (_tmp1238_);
			_tmp1240_ = _tmp1239_;
			_tmp1219_ = !G_TYPE_CHECK_INSTANCE_TYPE (_tmp1240_, VALA_TYPE_GENERIC_TYPE);
		} else {
			_tmp1219_ = FALSE;
		}
		if (_tmp1219_) {
			ValaExpression* _tmp1241_;
			ValaExpression* _tmp1242_;
			ValaDataType* _tmp1243_;
			ValaDataType* _tmp1244_;
			_tmp1241_ = vala_member_access_get_inner (self);
			_tmp1242_ = _tmp1241_;
			_tmp1243_ = vala_expression_get_value_type (_tmp1242_);
			_tmp1244_ = _tmp1243_;
			_tmp1218_ = !G_TYPE_CHECK_INSTANCE_TYPE (_tmp1244_, VALA_TYPE_ARRAY_TYPE);
		} else {
			_tmp1218_ = FALSE;
		}
		if (_tmp1218_) {
			ValaSourceReference* _tmp1245_;
			ValaSourceReference* _tmp1246_;
			ValaSymbol* _tmp1247_;
			ValaSymbol* _tmp1248_;
			gchar* _tmp1249_;
			gchar* _tmp1250_;
			gchar* _tmp1251_;
			gchar* _tmp1252_;
			_tmp1245_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
			_tmp1246_ = _tmp1245_;
			_tmp1247_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
			_tmp1248_ = _tmp1247_;
			_tmp1249_ = vala_symbol_get_full_name (_tmp1248_);
			_tmp1250_ = _tmp1249_;
			_tmp1251_ = g_strdup_printf ("Access to instance member `%s' from nullable reference denied", _tmp1250_);
			_tmp1252_ = _tmp1251_;
			vala_report_error (_tmp1246_, _tmp1252_);
			_g_free0 (_tmp1252_);
			_g_free0 (_tmp1250_);
		}
		_tmp1253_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
		_tmp1254_ = _tmp1253_;
		_tmp1255_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp1254_, VALA_TYPE_METHOD) ? ((ValaMethod*) _tmp1254_) : NULL);
		m = _tmp1255_;
		_tmp1256_ = vala_member_access_get_inner (self);
		_tmp1257_ = _tmp1256_;
		_tmp1258_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp1257_, VALA_TYPE_MEMBER_ACCESS) ? ((ValaMemberAccess*) _tmp1257_) : NULL);
		inner_ma = _tmp1258_;
		_tmp1264_ = m;
		if (_tmp1264_ != NULL) {
			ValaMethod* _tmp1265_;
			ValaMemberBinding _tmp1266_;
			ValaMemberBinding _tmp1267_;
			_tmp1265_ = m;
			_tmp1266_ = vala_method_get_binding (_tmp1265_);
			_tmp1267_ = _tmp1266_;
			_tmp1263_ = _tmp1267_ == VALA_MEMBER_BINDING_STATIC;
		} else {
			_tmp1263_ = FALSE;
		}
		if (_tmp1263_) {
			ValaMethod* _tmp1268_;
			ValaSymbol* _tmp1269_;
			ValaSymbol* _tmp1270_;
			_tmp1268_ = m;
			_tmp1269_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp1268_);
			_tmp1270_ = _tmp1269_;
			_tmp1262_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp1270_, VALA_TYPE_OBJECT_TYPE_SYMBOL);
		} else {
			_tmp1262_ = FALSE;
		}
		if (_tmp1262_) {
			ValaExpression* _tmp1271_;
			ValaExpression* _tmp1272_;
			_tmp1271_ = vala_member_access_get_inner (self);
			_tmp1272_ = _tmp1271_;
			_tmp1261_ = _tmp1272_ != NULL;
		} else {
			_tmp1261_ = FALSE;
		}
		if (_tmp1261_) {
			ValaExpression* _tmp1273_;
			ValaExpression* _tmp1274_;
			ValaDataType* _tmp1275_;
			ValaDataType* _tmp1276_;
			_tmp1273_ = vala_member_access_get_inner (self);
			_tmp1274_ = _tmp1273_;
			_tmp1275_ = vala_expression_get_value_type (_tmp1274_);
			_tmp1276_ = _tmp1275_;
			_tmp1260_ = _tmp1276_ == NULL;
		} else {
			_tmp1260_ = FALSE;
		}
		if (_tmp1260_) {
			ValaMemberAccess* _tmp1277_;
			ValaList* _tmp1278_;
			gint _tmp1279_;
			gint _tmp1280_;
			_tmp1277_ = inner_ma;
			_tmp1278_ = _tmp1277_->priv->type_argument_list;
			_tmp1279_ = vala_collection_get_size ((ValaCollection*) _tmp1278_);
			_tmp1280_ = _tmp1279_;
			_tmp1259_ = _tmp1280_ > 0;
		} else {
			_tmp1259_ = FALSE;
		}
		if (_tmp1259_) {
			ValaExpression* _tmp1281_;
			ValaExpression* _tmp1282_;
			ValaMethod* _tmp1283_;
			ValaSymbol* _tmp1284_;
			ValaSymbol* _tmp1285_;
			ValaObjectType* _tmp1286_;
			ValaObjectType* _tmp1287_;
			_tmp1281_ = vala_member_access_get_inner (self);
			_tmp1282_ = _tmp1281_;
			_tmp1283_ = m;
			_tmp1284_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp1283_);
			_tmp1285_ = _tmp1284_;
			_tmp1286_ = vala_object_type_new (G_TYPE_CHECK_INSTANCE_CAST (_tmp1285_, VALA_TYPE_OBJECT_TYPE_SYMBOL, ValaObjectTypeSymbol));
			_tmp1287_ = _tmp1286_;
			vala_expression_set_value_type (_tmp1282_, (ValaDataType*) _tmp1287_);
			_vala_code_node_unref0 (_tmp1287_);
			{
				ValaList* _type_argument_list = NULL;
				ValaMemberAccess* _tmp1288_;
				ValaList* _tmp1289_;
				ValaList* _tmp1290_;
				gint _type_argument_size = 0;
				ValaList* _tmp1291_;
				gint _tmp1292_;
				gint _tmp1293_;
				gint _type_argument_index = 0;
				_tmp1288_ = inner_ma;
				_tmp1289_ = _tmp1288_->priv->type_argument_list;
				_tmp1290_ = _vala_iterable_ref0 (_tmp1289_);
				_type_argument_list = _tmp1290_;
				_tmp1291_ = _type_argument_list;
				_tmp1292_ = vala_collection_get_size ((ValaCollection*) _tmp1291_);
				_tmp1293_ = _tmp1292_;
				_type_argument_size = _tmp1293_;
				_type_argument_index = -1;
				while (TRUE) {
					gint _tmp1294_;
					gint _tmp1295_;
					gint _tmp1296_;
					ValaDataType* type_argument = NULL;
					ValaList* _tmp1297_;
					gint _tmp1298_;
					gpointer _tmp1299_;
					ValaExpression* _tmp1300_;
					ValaExpression* _tmp1301_;
					ValaDataType* _tmp1302_;
					ValaDataType* _tmp1303_;
					ValaDataType* _tmp1304_;
					_tmp1294_ = _type_argument_index;
					_type_argument_index = _tmp1294_ + 1;
					_tmp1295_ = _type_argument_index;
					_tmp1296_ = _type_argument_size;
					if (!(_tmp1295_ < _tmp1296_)) {
						break;
					}
					_tmp1297_ = _type_argument_list;
					_tmp1298_ = _type_argument_index;
					_tmp1299_ = vala_list_get (_tmp1297_, _tmp1298_);
					type_argument = (ValaDataType*) _tmp1299_;
					_tmp1300_ = vala_member_access_get_inner (self);
					_tmp1301_ = _tmp1300_;
					_tmp1302_ = vala_expression_get_value_type (_tmp1301_);
					_tmp1303_ = _tmp1302_;
					_tmp1304_ = type_argument;
					vala_data_type_add_type_argument (_tmp1303_, _tmp1304_);
					_vala_code_node_unref0 (type_argument);
				}
				_vala_iterable_unref0 (_type_argument_list);
			}
		}
		_tmp1305_ = context;
		_tmp1306_ = vala_code_context_get_analyzer (_tmp1305_);
		_tmp1307_ = _tmp1306_;
		_tmp1308_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
		_tmp1309_ = _tmp1308_;
		_tmp1310_ = vala_expression_get_lvalue ((ValaExpression*) self);
		_tmp1311_ = _tmp1310_;
		_tmp1312_ = vala_semantic_analyzer_get_value_type_for_symbol (_tmp1307_, _tmp1309_, _tmp1311_);
		_tmp1313_ = _tmp1312_;
		vala_expression_set_formal_value_type ((ValaExpression*) self, _tmp1313_);
		_vala_code_node_unref0 (_tmp1313_);
		_tmp1315_ = vala_member_access_get_inner (self);
		_tmp1316_ = _tmp1315_;
		if (_tmp1316_ != NULL) {
			ValaDataType* _tmp1317_;
			ValaDataType* _tmp1318_;
			_tmp1317_ = vala_expression_get_formal_value_type ((ValaExpression*) self);
			_tmp1318_ = _tmp1317_;
			_tmp1314_ = _tmp1318_ != NULL;
		} else {
			_tmp1314_ = FALSE;
		}
		if (_tmp1314_) {
			ValaDataType* _tmp1319_;
			ValaDataType* _tmp1320_;
			ValaExpression* _tmp1321_;
			ValaExpression* _tmp1322_;
			ValaDataType* _tmp1323_;
			ValaDataType* _tmp1324_;
			ValaDataType* _tmp1325_;
			ValaDataType* _tmp1326_;
			_tmp1319_ = vala_expression_get_formal_value_type ((ValaExpression*) self);
			_tmp1320_ = _tmp1319_;
			_tmp1321_ = vala_member_access_get_inner (self);
			_tmp1322_ = _tmp1321_;
			_tmp1323_ = vala_expression_get_value_type (_tmp1322_);
			_tmp1324_ = _tmp1323_;
			_tmp1325_ = vala_data_type_get_actual_type (_tmp1320_, _tmp1324_, NULL, (ValaCodeNode*) self);
			_tmp1326_ = _tmp1325_;
			vala_expression_set_value_type ((ValaExpression*) self, _tmp1326_);
			_vala_code_node_unref0 (_tmp1326_);
		} else {
			ValaDataType* _tmp1327_;
			ValaDataType* _tmp1328_;
			_tmp1327_ = vala_expression_get_formal_value_type ((ValaExpression*) self);
			_tmp1328_ = _tmp1327_;
			vala_expression_set_value_type ((ValaExpression*) self, _tmp1328_);
		}
		_tmp1329_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
		_tmp1330_ = _tmp1329_;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp1330_, VALA_TYPE_METHOD)) {
			ValaMethod* method = NULL;
			ValaSymbol* _tmp1331_;
			ValaSymbol* _tmp1332_;
			ValaMethod* _tmp1333_;
			ValaDataType* _tmp1334_;
			ValaDataType* _tmp1335_;
			gboolean _tmp1342_ = FALSE;
			gboolean _tmp1343_;
			_tmp1331_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
			_tmp1332_ = _tmp1331_;
			_tmp1333_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp1332_, VALA_TYPE_METHOD, ValaMethod));
			method = _tmp1333_;
			_tmp1334_ = vala_expression_get_target_type ((ValaExpression*) self);
			_tmp1335_ = _tmp1334_;
			if (_tmp1335_ != NULL) {
				ValaDataType* _tmp1336_;
				ValaDataType* _tmp1337_;
				ValaDataType* _tmp1338_;
				ValaDataType* _tmp1339_;
				gboolean _tmp1340_;
				gboolean _tmp1341_;
				_tmp1336_ = vala_expression_get_value_type ((ValaExpression*) self);
				_tmp1337_ = _tmp1336_;
				_tmp1338_ = vala_expression_get_target_type ((ValaExpression*) self);
				_tmp1339_ = _tmp1338_;
				_tmp1340_ = vala_data_type_get_value_owned (_tmp1339_);
				_tmp1341_ = _tmp1340_;
				vala_data_type_set_value_owned (_tmp1337_, _tmp1341_);
			}
			_tmp1343_ = instance;
			if (_tmp1343_) {
				ValaMethod* _tmp1344_;
				ValaSymbol* _tmp1345_;
				ValaSymbol* _tmp1346_;
				_tmp1344_ = method;
				_tmp1345_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp1344_);
				_tmp1346_ = _tmp1345_;
				_tmp1342_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp1346_, VALA_TYPE_TYPESYMBOL);
			} else {
				_tmp1342_ = FALSE;
			}
			if (_tmp1342_) {
				ValaExpression* _tmp1347_;
				ValaExpression* _tmp1348_;
				ValaMethod* _tmp1349_;
				ValaSymbol* _tmp1350_;
				ValaSymbol* _tmp1351_;
				ValaDataType* _tmp1352_;
				ValaDataType* _tmp1353_;
				ValaExpression* _tmp1354_;
				ValaExpression* _tmp1355_;
				ValaDataType* _tmp1356_;
				ValaDataType* _tmp1357_;
				ValaMethod* _tmp1358_;
				ValaParameter* _tmp1359_;
				ValaParameter* _tmp1360_;
				ValaDataType* _tmp1361_;
				ValaDataType* _tmp1362_;
				gboolean _tmp1363_;
				gboolean _tmp1364_;
				_tmp1347_ = vala_member_access_get_inner (self);
				_tmp1348_ = _tmp1347_;
				_tmp1349_ = method;
				_tmp1350_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp1349_);
				_tmp1351_ = _tmp1350_;
				_tmp1352_ = vala_semantic_analyzer_get_data_type_for_symbol (G_TYPE_CHECK_INSTANCE_CAST (_tmp1351_, VALA_TYPE_TYPESYMBOL, ValaTypeSymbol));
				_tmp1353_ = _tmp1352_;
				vala_expression_set_target_type (_tmp1348_, _tmp1353_);
				_vala_code_node_unref0 (_tmp1353_);
				_tmp1354_ = vala_member_access_get_inner (self);
				_tmp1355_ = _tmp1354_;
				_tmp1356_ = vala_expression_get_target_type (_tmp1355_);
				_tmp1357_ = _tmp1356_;
				_tmp1358_ = method;
				_tmp1359_ = vala_method_get_this_parameter (_tmp1358_);
				_tmp1360_ = _tmp1359_;
				_tmp1361_ = vala_variable_get_variable_type ((ValaVariable*) _tmp1360_);
				_tmp1362_ = _tmp1361_;
				_tmp1363_ = vala_data_type_get_value_owned (_tmp1362_);
				_tmp1364_ = _tmp1363_;
				vala_data_type_set_value_owned (_tmp1357_, _tmp1364_);
			}
			_vala_code_node_unref0 (method);
		} else {
			ValaSymbol* _tmp1365_;
			ValaSymbol* _tmp1366_;
			_tmp1365_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
			_tmp1366_ = _tmp1365_;
			if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp1366_, VALA_TYPE_PROPERTY)) {
				ValaProperty* prop = NULL;
				ValaSymbol* _tmp1367_;
				ValaSymbol* _tmp1368_;
				ValaProperty* _tmp1369_;
				gboolean _tmp1370_ = FALSE;
				gboolean _tmp1371_;
				_tmp1367_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
				_tmp1368_ = _tmp1367_;
				_tmp1369_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp1368_, VALA_TYPE_PROPERTY, ValaProperty));
				prop = _tmp1369_;
				_tmp1371_ = instance;
				if (_tmp1371_) {
					ValaProperty* _tmp1372_;
					ValaSymbol* _tmp1373_;
					ValaSymbol* _tmp1374_;
					_tmp1372_ = prop;
					_tmp1373_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp1372_);
					_tmp1374_ = _tmp1373_;
					_tmp1370_ = _tmp1374_ != NULL;
				} else {
					_tmp1370_ = FALSE;
				}
				if (_tmp1370_) {
					ValaExpression* _tmp1375_;
					ValaExpression* _tmp1376_;
					ValaProperty* _tmp1377_;
					ValaSymbol* _tmp1378_;
					ValaSymbol* _tmp1379_;
					ValaDataType* _tmp1380_;
					ValaDataType* _tmp1381_;
					_tmp1375_ = vala_member_access_get_inner (self);
					_tmp1376_ = _tmp1375_;
					_tmp1377_ = prop;
					_tmp1378_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp1377_);
					_tmp1379_ = _tmp1378_;
					_tmp1380_ = vala_semantic_analyzer_get_data_type_for_symbol (G_TYPE_CHECK_INSTANCE_CAST (_tmp1379_, VALA_TYPE_TYPESYMBOL, ValaTypeSymbol));
					_tmp1381_ = _tmp1380_;
					vala_expression_set_target_type (_tmp1376_, _tmp1381_);
					_vala_code_node_unref0 (_tmp1381_);
				}
				_vala_code_node_unref0 (prop);
			} else {
				gboolean _tmp1382_ = FALSE;
				gboolean _tmp1383_ = FALSE;
				gboolean _tmp1384_ = FALSE;
				ValaSymbol* _tmp1385_;
				ValaSymbol* _tmp1386_;
				_tmp1385_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
				_tmp1386_ = _tmp1385_;
				if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp1386_, VALA_TYPE_FIELD)) {
					_tmp1384_ = TRUE;
				} else {
					ValaSymbol* _tmp1387_;
					ValaSymbol* _tmp1388_;
					_tmp1387_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
					_tmp1388_ = _tmp1387_;
					_tmp1384_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp1388_, VALA_TYPE_SIGNAL);
				}
				if (_tmp1384_) {
					gboolean _tmp1389_;
					_tmp1389_ = instance;
					_tmp1383_ = _tmp1389_;
				} else {
					_tmp1383_ = FALSE;
				}
				if (_tmp1383_) {
					ValaSymbol* _tmp1390_;
					ValaSymbol* _tmp1391_;
					ValaSymbol* _tmp1392_;
					ValaSymbol* _tmp1393_;
					_tmp1390_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
					_tmp1391_ = _tmp1390_;
					_tmp1392_ = vala_symbol_get_parent_symbol (_tmp1391_);
					_tmp1393_ = _tmp1392_;
					_tmp1382_ = _tmp1393_ != NULL;
				} else {
					_tmp1382_ = FALSE;
				}
				if (_tmp1382_) {
					ValaDataType* parent_type = NULL;
					ValaSymbol* _tmp1394_;
					ValaSymbol* _tmp1395_;
					ValaSymbol* _tmp1396_;
					ValaSymbol* _tmp1397_;
					ValaDataType* _tmp1398_;
					ValaExpression* _tmp1399_;
					ValaExpression* _tmp1400_;
					ValaDataType* _tmp1401_;
					ValaExpression* _tmp1402_;
					ValaExpression* _tmp1403_;
					ValaDataType* _tmp1404_;
					ValaDataType* _tmp1405_;
					ValaDataType* _tmp1406_;
					ValaDataType* _tmp1407_;
					_tmp1394_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
					_tmp1395_ = _tmp1394_;
					_tmp1396_ = vala_symbol_get_parent_symbol (_tmp1395_);
					_tmp1397_ = _tmp1396_;
					_tmp1398_ = vala_semantic_analyzer_get_data_type_for_symbol (G_TYPE_CHECK_INSTANCE_CAST (_tmp1397_, VALA_TYPE_TYPESYMBOL, ValaTypeSymbol));
					parent_type = _tmp1398_;
					_tmp1399_ = vala_member_access_get_inner (self);
					_tmp1400_ = _tmp1399_;
					_tmp1401_ = parent_type;
					_tmp1402_ = vala_member_access_get_inner (self);
					_tmp1403_ = _tmp1402_;
					_tmp1404_ = vala_expression_get_value_type (_tmp1403_);
					_tmp1405_ = _tmp1404_;
					_tmp1406_ = vala_data_type_get_actual_type (_tmp1401_, _tmp1405_, NULL, (ValaCodeNode*) self);
					_tmp1407_ = _tmp1406_;
					vala_expression_set_target_type (_tmp1400_, _tmp1407_);
					_vala_code_node_unref0 (_tmp1407_);
					_vala_code_node_unref0 (parent_type);
				}
			}
		}
		_vala_code_node_unref0 (inner_ma);
		_vala_code_node_unref0 (m);
	}
	_tmp1408_ = vala_code_node_get_error ((ValaCodeNode*) self);
	_tmp1409_ = _tmp1408_;
	result = !_tmp1409_;
	_vala_code_node_unref0 (member);
	_vala_code_node_unref0 (this_parameter);
	_vala_code_node_unref0 (base_symbol);
	return result;
}


static gboolean vala_member_access_is_instance_symbol (ValaSymbol* symbol) {
	gboolean result = FALSE;
	gboolean _tmp0_ = FALSE;
	ValaSymbol* _tmp1_;
	g_return_val_if_fail (symbol != NULL, FALSE);
	_tmp1_ = symbol;
	if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp1_, VALA_TYPE_FIELD)) {
		ValaSymbol* _tmp2_;
		ValaMemberBinding _tmp3_;
		ValaMemberBinding _tmp4_;
		_tmp2_ = symbol;
		_tmp3_ = vala_field_get_binding (G_TYPE_CHECK_INSTANCE_CAST (_tmp2_, VALA_TYPE_FIELD, ValaField));
		_tmp4_ = _tmp3_;
		_tmp0_ = _tmp4_ == VALA_MEMBER_BINDING_INSTANCE;
	} else {
		_tmp0_ = FALSE;
	}
	if (_tmp0_) {
		result = TRUE;
		return result;
	} else {
		gboolean _tmp5_ = FALSE;
		gboolean _tmp6_ = FALSE;
		ValaSymbol* _tmp7_;
		_tmp7_ = symbol;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp7_, VALA_TYPE_METHOD)) {
			ValaSymbol* _tmp8_;
			_tmp8_ = symbol;
			_tmp6_ = !G_TYPE_CHECK_INSTANCE_TYPE (_tmp8_, VALA_TYPE_CREATION_METHOD);
		} else {
			_tmp6_ = FALSE;
		}
		if (_tmp6_) {
			ValaSymbol* _tmp9_;
			ValaMemberBinding _tmp10_;
			ValaMemberBinding _tmp11_;
			_tmp9_ = symbol;
			_tmp10_ = vala_method_get_binding (G_TYPE_CHECK_INSTANCE_CAST (_tmp9_, VALA_TYPE_METHOD, ValaMethod));
			_tmp11_ = _tmp10_;
			_tmp5_ = _tmp11_ == VALA_MEMBER_BINDING_INSTANCE;
		} else {
			_tmp5_ = FALSE;
		}
		if (_tmp5_) {
			result = TRUE;
			return result;
		} else {
			gboolean _tmp12_ = FALSE;
			ValaSymbol* _tmp13_;
			_tmp13_ = symbol;
			if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp13_, VALA_TYPE_PROPERTY)) {
				ValaSymbol* _tmp14_;
				ValaMemberBinding _tmp15_;
				ValaMemberBinding _tmp16_;
				_tmp14_ = symbol;
				_tmp15_ = vala_property_get_binding (G_TYPE_CHECK_INSTANCE_CAST (_tmp14_, VALA_TYPE_PROPERTY, ValaProperty));
				_tmp16_ = _tmp15_;
				_tmp12_ = _tmp16_ == VALA_MEMBER_BINDING_INSTANCE;
			} else {
				_tmp12_ = FALSE;
			}
			if (_tmp12_) {
				result = TRUE;
				return result;
			} else {
				ValaSymbol* _tmp17_;
				_tmp17_ = symbol;
				if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp17_, VALA_TYPE_SIGNAL)) {
					result = TRUE;
					return result;
				} else {
					result = FALSE;
					return result;
				}
			}
		}
	}
}


void vala_member_access_check_lvalue_access (ValaMemberAccess* self) {
	ValaExpression* _tmp0_;
	ValaExpression* _tmp1_;
	gboolean _tmp2_ = FALSE;
	ValaSymbol* _tmp3_;
	ValaSymbol* _tmp4_;
	gboolean instance = FALSE;
	gboolean _tmp9_;
	gboolean _tmp17_;
	gboolean _tmp25_ = FALSE;
	ValaExpression* _tmp26_;
	ValaExpression* _tmp27_;
	ValaSymbol* _tmp28_;
	ValaSymbol* _tmp29_;
	gboolean this_access = FALSE;
	gboolean _tmp36_ = FALSE;
	gboolean _tmp37_ = FALSE;
	ValaExpression* _tmp38_;
	ValaExpression* _tmp39_;
	ValaDataType* _tmp40_;
	ValaDataType* _tmp41_;
	gboolean struct_or_array = FALSE;
	ValaMemberAccess* ma = NULL;
	ValaExpression* _tmp52_;
	ValaExpression* _tmp53_;
	ValaMemberAccess* _tmp54_;
	gboolean _tmp55_ = FALSE;
	gboolean _tmp56_ = FALSE;
	ValaMemberAccess* _tmp57_;
	gboolean _tmp66_ = FALSE;
	gboolean _tmp67_ = FALSE;
	gboolean _tmp68_ = FALSE;
	gboolean _tmp69_ = FALSE;
	gboolean _tmp70_;
	g_return_if_fail (self != NULL);
	_tmp0_ = vala_member_access_get_inner (self);
	_tmp1_ = _tmp0_;
	if (_tmp1_ == NULL) {
		return;
	}
	_tmp3_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
	_tmp4_ = _tmp3_;
	if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp4_, VALA_TYPE_FIELD)) {
		ValaSymbol* _tmp5_;
		ValaSymbol* _tmp6_;
		ValaMemberBinding _tmp7_;
		ValaMemberBinding _tmp8_;
		_tmp5_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
		_tmp6_ = _tmp5_;
		_tmp7_ = vala_field_get_binding (G_TYPE_CHECK_INSTANCE_CAST (_tmp6_, VALA_TYPE_FIELD, ValaField));
		_tmp8_ = _tmp7_;
		_tmp2_ = _tmp8_ == VALA_MEMBER_BINDING_INSTANCE;
	} else {
		_tmp2_ = FALSE;
	}
	instance = _tmp2_;
	_tmp9_ = instance;
	if (!_tmp9_) {
		gboolean _tmp10_ = FALSE;
		ValaSymbol* _tmp11_;
		ValaSymbol* _tmp12_;
		_tmp11_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
		_tmp12_ = _tmp11_;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp12_, VALA_TYPE_METHOD)) {
			ValaSymbol* _tmp13_;
			ValaSymbol* _tmp14_;
			ValaMemberBinding _tmp15_;
			ValaMemberBinding _tmp16_;
			_tmp13_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
			_tmp14_ = _tmp13_;
			_tmp15_ = vala_method_get_binding (G_TYPE_CHECK_INSTANCE_CAST (_tmp14_, VALA_TYPE_METHOD, ValaMethod));
			_tmp16_ = _tmp15_;
			_tmp10_ = _tmp16_ == VALA_MEMBER_BINDING_INSTANCE;
		} else {
			_tmp10_ = FALSE;
		}
		instance = _tmp10_;
	}
	_tmp17_ = instance;
	if (!_tmp17_) {
		gboolean _tmp18_ = FALSE;
		ValaSymbol* _tmp19_;
		ValaSymbol* _tmp20_;
		_tmp19_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
		_tmp20_ = _tmp19_;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp20_, VALA_TYPE_PROPERTY)) {
			ValaSymbol* _tmp21_;
			ValaSymbol* _tmp22_;
			ValaMemberBinding _tmp23_;
			ValaMemberBinding _tmp24_;
			_tmp21_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
			_tmp22_ = _tmp21_;
			_tmp23_ = vala_property_get_binding (G_TYPE_CHECK_INSTANCE_CAST (_tmp22_, VALA_TYPE_PROPERTY, ValaProperty));
			_tmp24_ = _tmp23_;
			_tmp18_ = _tmp24_ == VALA_MEMBER_BINDING_INSTANCE;
		} else {
			_tmp18_ = FALSE;
		}
		instance = _tmp18_;
	}
	_tmp26_ = vala_member_access_get_inner (self);
	_tmp27_ = _tmp26_;
	_tmp28_ = vala_expression_get_symbol_reference (_tmp27_);
	_tmp29_ = _tmp28_;
	if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp29_, VALA_TYPE_PARAMETER)) {
		ValaExpression* _tmp30_;
		ValaExpression* _tmp31_;
		ValaSymbol* _tmp32_;
		ValaSymbol* _tmp33_;
		const gchar* _tmp34_;
		const gchar* _tmp35_;
		_tmp30_ = vala_member_access_get_inner (self);
		_tmp31_ = _tmp30_;
		_tmp32_ = vala_expression_get_symbol_reference (_tmp31_);
		_tmp33_ = _tmp32_;
		_tmp34_ = vala_symbol_get_name (_tmp33_);
		_tmp35_ = _tmp34_;
		_tmp25_ = g_strcmp0 (_tmp35_, "this") == 0;
	} else {
		_tmp25_ = FALSE;
	}
	this_access = _tmp25_;
	_tmp38_ = vala_member_access_get_inner (self);
	_tmp39_ = _tmp38_;
	_tmp40_ = vala_expression_get_value_type (_tmp39_);
	_tmp41_ = _tmp40_;
	if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp41_, VALA_TYPE_STRUCT_VALUE_TYPE)) {
		ValaExpression* _tmp42_;
		ValaExpression* _tmp43_;
		ValaDataType* _tmp44_;
		ValaDataType* _tmp45_;
		gboolean _tmp46_;
		gboolean _tmp47_;
		_tmp42_ = vala_member_access_get_inner (self);
		_tmp43_ = _tmp42_;
		_tmp44_ = vala_expression_get_value_type (_tmp43_);
		_tmp45_ = _tmp44_;
		_tmp46_ = vala_data_type_get_nullable (_tmp45_);
		_tmp47_ = _tmp46_;
		_tmp37_ = !_tmp47_;
	} else {
		_tmp37_ = FALSE;
	}
	if (_tmp37_) {
		_tmp36_ = TRUE;
	} else {
		ValaExpression* _tmp48_;
		ValaExpression* _tmp49_;
		ValaDataType* _tmp50_;
		ValaDataType* _tmp51_;
		_tmp48_ = vala_member_access_get_inner (self);
		_tmp49_ = _tmp48_;
		_tmp50_ = vala_expression_get_value_type (_tmp49_);
		_tmp51_ = _tmp50_;
		_tmp36_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp51_, VALA_TYPE_ARRAY_TYPE);
	}
	struct_or_array = _tmp36_;
	_tmp52_ = vala_member_access_get_inner (self);
	_tmp53_ = _tmp52_;
	_tmp54_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp53_, VALA_TYPE_MEMBER_ACCESS) ? ((ValaMemberAccess*) _tmp53_) : NULL);
	ma = _tmp54_;
	_tmp57_ = ma;
	if (_tmp57_ == NULL) {
		gboolean _tmp58_;
		_tmp58_ = struct_or_array;
		_tmp56_ = _tmp58_;
	} else {
		_tmp56_ = FALSE;
	}
	if (_tmp56_) {
		ValaExpression* _tmp59_;
		ValaExpression* _tmp60_;
		_tmp59_ = vala_member_access_get_inner (self);
		_tmp60_ = _tmp59_;
		_tmp55_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp60_, VALA_TYPE_POINTER_INDIRECTION);
	} else {
		_tmp55_ = FALSE;
	}
	if (_tmp55_) {
		ValaExpression* _tmp61_;
		ValaExpression* _tmp62_;
		ValaExpression* _tmp63_;
		ValaExpression* _tmp64_;
		ValaMemberAccess* _tmp65_;
		_tmp61_ = vala_member_access_get_inner (self);
		_tmp62_ = _tmp61_;
		_tmp63_ = vala_pointer_indirection_get_inner (G_TYPE_CHECK_INSTANCE_CAST (_tmp62_, VALA_TYPE_POINTER_INDIRECTION, ValaPointerIndirection));
		_tmp64_ = _tmp63_;
		_tmp65_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp64_, VALA_TYPE_MEMBER_ACCESS) ? ((ValaMemberAccess*) _tmp64_) : NULL);
		_vala_code_node_unref0 (ma);
		ma = _tmp65_;
	}
	_tmp70_ = instance;
	if (_tmp70_) {
		gboolean _tmp71_;
		_tmp71_ = struct_or_array;
		_tmp69_ = _tmp71_;
	} else {
		_tmp69_ = FALSE;
	}
	if (_tmp69_) {
		gboolean _tmp72_ = FALSE;
		ValaSymbol* _tmp73_;
		ValaSymbol* _tmp74_;
		_tmp73_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
		_tmp74_ = _tmp73_;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp74_, VALA_TYPE_METHOD)) {
			_tmp72_ = TRUE;
		} else {
			gboolean _tmp75_;
			gboolean _tmp76_;
			_tmp75_ = vala_expression_get_lvalue ((ValaExpression*) self);
			_tmp76_ = _tmp75_;
			_tmp72_ = _tmp76_;
		}
		_tmp68_ = _tmp72_;
	} else {
		_tmp68_ = FALSE;
	}
	if (_tmp68_) {
		gboolean _tmp77_ = FALSE;
		gboolean _tmp78_ = FALSE;
		ValaMemberAccess* _tmp79_;
		_tmp79_ = ma;
		if (_tmp79_ != NULL) {
			ValaMemberAccess* _tmp80_;
			ValaSymbol* _tmp81_;
			ValaSymbol* _tmp82_;
			_tmp80_ = ma;
			_tmp81_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp80_);
			_tmp82_ = _tmp81_;
			_tmp78_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp82_, VALA_TYPE_VARIABLE);
		} else {
			_tmp78_ = FALSE;
		}
		if (_tmp78_) {
			_tmp77_ = TRUE;
		} else {
			ValaExpression* _tmp83_;
			ValaExpression* _tmp84_;
			_tmp83_ = vala_member_access_get_inner (self);
			_tmp84_ = _tmp83_;
			_tmp77_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp84_, VALA_TYPE_ELEMENT_ACCESS);
		}
		_tmp67_ = _tmp77_;
	} else {
		_tmp67_ = FALSE;
	}
	if (_tmp67_) {
		gboolean _tmp85_;
		_tmp85_ = this_access;
		_tmp66_ = !_tmp85_;
	} else {
		_tmp66_ = FALSE;
	}
	if (_tmp66_) {
		ValaExpression* _tmp86_;
		ValaExpression* _tmp87_;
		ValaMemberAccess* _tmp88_;
		_tmp86_ = vala_member_access_get_inner (self);
		_tmp87_ = _tmp86_;
		vala_expression_set_lvalue (_tmp87_, TRUE);
		_tmp88_ = ma;
		if (_tmp88_ != NULL) {
			ValaMemberAccess* _tmp89_;
			ValaMemberAccess* _tmp90_;
			_tmp89_ = ma;
			vala_expression_set_lvalue ((ValaExpression*) _tmp89_, TRUE);
			_tmp90_ = ma;
			vala_member_access_check_lvalue_access (_tmp90_);
		}
	}
	_vala_code_node_unref0 (ma);
}


static void vala_member_access_real_emit (ValaCodeNode* base, ValaCodeGenerator* codegen) {
	ValaMemberAccess * self;
	ValaExpression* _tmp0_;
	ValaExpression* _tmp1_;
	ValaCodeGenerator* _tmp5_;
	ValaCodeGenerator* _tmp6_;
	self = (ValaMemberAccess*) base;
	g_return_if_fail (codegen != NULL);
	_tmp0_ = vala_member_access_get_inner (self);
	_tmp1_ = _tmp0_;
	if (_tmp1_ != NULL) {
		ValaExpression* _tmp2_;
		ValaExpression* _tmp3_;
		ValaCodeGenerator* _tmp4_;
		_tmp2_ = vala_member_access_get_inner (self);
		_tmp3_ = _tmp2_;
		_tmp4_ = codegen;
		vala_code_node_emit ((ValaCodeNode*) _tmp3_, _tmp4_);
	}
	_tmp5_ = codegen;
	vala_code_visitor_visit_member_access ((ValaCodeVisitor*) _tmp5_, self);
	_tmp6_ = codegen;
	vala_code_visitor_visit_expression ((ValaCodeVisitor*) _tmp6_, (ValaExpression*) self);
}


static void vala_member_access_real_get_defined_variables (ValaCodeNode* base, ValaCollection* collection) {
	ValaMemberAccess * self;
	ValaExpression* _tmp0_;
	ValaExpression* _tmp1_;
	self = (ValaMemberAccess*) base;
	g_return_if_fail (collection != NULL);
	_tmp0_ = vala_member_access_get_inner (self);
	_tmp1_ = _tmp0_;
	if (_tmp1_ != NULL) {
		ValaExpression* _tmp2_;
		ValaExpression* _tmp3_;
		ValaCollection* _tmp4_;
		_tmp2_ = vala_member_access_get_inner (self);
		_tmp3_ = _tmp2_;
		_tmp4_ = collection;
		vala_code_node_get_defined_variables ((ValaCodeNode*) _tmp3_, _tmp4_);
	}
}


static void vala_member_access_real_get_used_variables (ValaCodeNode* base, ValaCollection* collection) {
	ValaMemberAccess * self;
	ValaExpression* _tmp0_;
	ValaExpression* _tmp1_;
	ValaLocalVariable* local = NULL;
	ValaSymbol* _tmp5_;
	ValaSymbol* _tmp6_;
	ValaLocalVariable* _tmp7_;
	ValaParameter* param = NULL;
	ValaSymbol* _tmp8_;
	ValaSymbol* _tmp9_;
	ValaParameter* _tmp10_;
	ValaLocalVariable* _tmp11_;
	self = (ValaMemberAccess*) base;
	g_return_if_fail (collection != NULL);
	_tmp0_ = vala_member_access_get_inner (self);
	_tmp1_ = _tmp0_;
	if (_tmp1_ != NULL) {
		ValaExpression* _tmp2_;
		ValaExpression* _tmp3_;
		ValaCollection* _tmp4_;
		_tmp2_ = vala_member_access_get_inner (self);
		_tmp3_ = _tmp2_;
		_tmp4_ = collection;
		vala_code_node_get_used_variables ((ValaCodeNode*) _tmp3_, _tmp4_);
	}
	_tmp5_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
	_tmp6_ = _tmp5_;
	_tmp7_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp6_, VALA_TYPE_LOCAL_VARIABLE) ? ((ValaLocalVariable*) _tmp6_) : NULL);
	local = _tmp7_;
	_tmp8_ = vala_expression_get_symbol_reference ((ValaExpression*) self);
	_tmp9_ = _tmp8_;
	_tmp10_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp9_, VALA_TYPE_PARAMETER) ? ((ValaParameter*) _tmp9_) : NULL);
	param = _tmp10_;
	_tmp11_ = local;
	if (_tmp11_ != NULL) {
		ValaCollection* _tmp12_;
		ValaLocalVariable* _tmp13_;
		_tmp12_ = collection;
		_tmp13_ = local;
		vala_collection_add (_tmp12_, (ValaVariable*) _tmp13_);
	} else {
		gboolean _tmp14_ = FALSE;
		ValaParameter* _tmp15_;
		_tmp15_ = param;
		if (_tmp15_ != NULL) {
			ValaParameter* _tmp16_;
			ValaParameterDirection _tmp17_;
			ValaParameterDirection _tmp18_;
			_tmp16_ = param;
			_tmp17_ = vala_parameter_get_direction (_tmp16_);
			_tmp18_ = _tmp17_;
			_tmp14_ = _tmp18_ == VALA_PARAMETER_DIRECTION_OUT;
		} else {
			_tmp14_ = FALSE;
		}
		if (_tmp14_) {
			ValaCollection* _tmp19_;
			ValaParameter* _tmp20_;
			_tmp19_ = collection;
			_tmp20_ = param;
			vala_collection_add (_tmp19_, (ValaVariable*) _tmp20_);
		}
	}
	_vala_code_node_unref0 (param);
	_vala_code_node_unref0 (local);
}


ValaExpression* vala_member_access_get_inner (ValaMemberAccess* self) {
	ValaExpression* result;
	ValaExpression* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_inner;
	result = _tmp0_;
	return result;
}


void vala_member_access_set_inner (ValaMemberAccess* self, ValaExpression* value) {
	ValaExpression* _tmp0_;
	ValaExpression* _tmp1_;
	ValaExpression* _tmp2_;
	g_return_if_fail (self != NULL);
	_tmp0_ = value;
	_tmp1_ = _vala_code_node_ref0 (_tmp0_);
	_vala_code_node_unref0 (self->priv->_inner);
	self->priv->_inner = _tmp1_;
	_tmp2_ = self->priv->_inner;
	if (_tmp2_ != NULL) {
		ValaExpression* _tmp3_;
		_tmp3_ = self->priv->_inner;
		vala_code_node_set_parent_node ((ValaCodeNode*) _tmp3_, (ValaCodeNode*) self);
	}
}


const gchar* vala_member_access_get_member_name (ValaMemberAccess* self) {
	const gchar* result;
	const gchar* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_member_name;
	result = _tmp0_;
	return result;
}


void vala_member_access_set_member_name (ValaMemberAccess* self, const gchar* value) {
	const gchar* _tmp0_;
	gchar* _tmp1_;
	g_return_if_fail (self != NULL);
	_tmp0_ = value;
	_tmp1_ = g_strdup (_tmp0_);
	_g_free0 (self->priv->_member_name);
	self->priv->_member_name = _tmp1_;
}


gboolean vala_member_access_get_pointer_member_access (ValaMemberAccess* self) {
	gboolean result;
	gboolean _tmp0_;
	g_return_val_if_fail (self != NULL, FALSE);
	_tmp0_ = self->priv->_pointer_member_access;
	result = _tmp0_;
	return result;
}


void vala_member_access_set_pointer_member_access (ValaMemberAccess* self, gboolean value) {
	gboolean _tmp0_;
	g_return_if_fail (self != NULL);
	_tmp0_ = value;
	self->priv->_pointer_member_access = _tmp0_;
}


gboolean vala_member_access_get_prototype_access (ValaMemberAccess* self) {
	gboolean result;
	gboolean _tmp0_;
	g_return_val_if_fail (self != NULL, FALSE);
	_tmp0_ = self->priv->_prototype_access;
	result = _tmp0_;
	return result;
}


void vala_member_access_set_prototype_access (ValaMemberAccess* self, gboolean value) {
	gboolean _tmp0_;
	g_return_if_fail (self != NULL);
	_tmp0_ = value;
	self->priv->_prototype_access = _tmp0_;
}


gboolean vala_member_access_get_creation_member (ValaMemberAccess* self) {
	gboolean result;
	gboolean _tmp0_;
	g_return_val_if_fail (self != NULL, FALSE);
	_tmp0_ = self->priv->_creation_member;
	result = _tmp0_;
	return result;
}


void vala_member_access_set_creation_member (ValaMemberAccess* self, gboolean value) {
	gboolean _tmp0_;
	g_return_if_fail (self != NULL);
	_tmp0_ = value;
	self->priv->_creation_member = _tmp0_;
}


gboolean vala_member_access_get_qualified (ValaMemberAccess* self) {
	gboolean result;
	gboolean _tmp0_;
	g_return_val_if_fail (self != NULL, FALSE);
	_tmp0_ = self->priv->_qualified;
	result = _tmp0_;
	return result;
}


void vala_member_access_set_qualified (ValaMemberAccess* self, gboolean value) {
	gboolean _tmp0_;
	g_return_if_fail (self != NULL);
	_tmp0_ = value;
	self->priv->_qualified = _tmp0_;
}


static void vala_member_access_class_init (ValaMemberAccessClass * klass) {
	vala_member_access_parent_class = g_type_class_peek_parent (klass);
	((ValaCodeNodeClass *) klass)->finalize = vala_member_access_finalize;
	g_type_class_add_private (klass, sizeof (ValaMemberAccessPrivate));
	((ValaCodeNodeClass *) klass)->accept = (void (*) (ValaCodeNode *, ValaCodeVisitor*)) vala_member_access_real_accept;
	((ValaCodeNodeClass *) klass)->accept_children = (void (*) (ValaCodeNode *, ValaCodeVisitor*)) vala_member_access_real_accept_children;
	((ValaCodeNodeClass *) klass)->to_string = (gchar* (*) (ValaCodeNode *)) vala_member_access_real_to_string;
	((ValaCodeNodeClass *) klass)->replace_expression = (void (*) (ValaCodeNode *, ValaExpression*, ValaExpression*)) vala_member_access_real_replace_expression;
	((ValaExpressionClass *) klass)->is_pure = (gboolean (*) (ValaExpression *)) vala_member_access_real_is_pure;
	((ValaExpressionClass *) klass)->is_accessible = (gboolean (*) (ValaExpression *, ValaSymbol*)) vala_member_access_real_is_accessible;
	((ValaCodeNodeClass *) klass)->replace_type = (void (*) (ValaCodeNode *, ValaDataType*, ValaDataType*)) vala_member_access_real_replace_type;
	((ValaExpressionClass *) klass)->is_constant = (gboolean (*) (ValaExpression *)) vala_member_access_real_is_constant;
	((ValaExpressionClass *) klass)->is_non_null = (gboolean (*) (ValaExpression *)) vala_member_access_real_is_non_null;
	((ValaCodeNodeClass *) klass)->check = (gboolean (*) (ValaCodeNode *, ValaCodeContext*)) vala_member_access_real_check;
	((ValaCodeNodeClass *) klass)->emit = (void (*) (ValaCodeNode *, ValaCodeGenerator*)) vala_member_access_real_emit;
	((ValaCodeNodeClass *) klass)->get_defined_variables = (void (*) (ValaCodeNode *, ValaCollection*)) vala_member_access_real_get_defined_variables;
	((ValaCodeNodeClass *) klass)->get_used_variables = (void (*) (ValaCodeNode *, ValaCollection*)) vala_member_access_real_get_used_variables;
}


static void vala_member_access_instance_init (ValaMemberAccess * self) {
	GEqualFunc _tmp0_;
	ValaArrayList* _tmp1_;
	self->priv = VALA_MEMBER_ACCESS_GET_PRIVATE (self);
	_tmp0_ = g_direct_equal;
	_tmp1_ = vala_array_list_new (VALA_TYPE_DATA_TYPE, (GBoxedCopyFunc) vala_code_node_ref, (GDestroyNotify) vala_code_node_unref, _tmp0_);
	self->priv->type_argument_list = (ValaList*) _tmp1_;
}


static void vala_member_access_finalize (ValaCodeNode * obj) {
	ValaMemberAccess * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (obj, VALA_TYPE_MEMBER_ACCESS, ValaMemberAccess);
	_g_free0 (self->priv->_member_name);
	_vala_code_node_unref0 (self->priv->_inner);
	_vala_iterable_unref0 (self->priv->type_argument_list);
	VALA_CODE_NODE_CLASS (vala_member_access_parent_class)->finalize (obj);
}


/**
 * Represents an access to a type member in the source code.
 */
GType vala_member_access_get_type (void) {
	static volatile gsize vala_member_access_type_id__volatile = 0;
	if (g_once_init_enter (&vala_member_access_type_id__volatile)) {
		static const GTypeInfo g_define_type_info = { sizeof (ValaMemberAccessClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) vala_member_access_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ValaMemberAccess), 0, (GInstanceInitFunc) vala_member_access_instance_init, NULL };
		GType vala_member_access_type_id;
		vala_member_access_type_id = g_type_register_static (VALA_TYPE_EXPRESSION, "ValaMemberAccess", &g_define_type_info, 0);
		g_once_init_leave (&vala_member_access_type_id__volatile, vala_member_access_type_id);
	}
	return vala_member_access_type_id__volatile;
}



