Logo Search packages:      
Sourcecode: vala-0.14 version File versions  Download package

valaparser.c

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

/* valaparser.vala
 *
 * Copyright (C) 2006-2011  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 <valagee.h>
#include <stdlib.h>
#include <string.h>


#define VALA_TYPE_CODE_VISITOR (vala_code_visitor_get_type ())
#define VALA_CODE_VISITOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CODE_VISITOR, ValaCodeVisitor))
#define VALA_CODE_VISITOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CODE_VISITOR, ValaCodeVisitorClass))
#define VALA_IS_CODE_VISITOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CODE_VISITOR))
#define VALA_IS_CODE_VISITOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CODE_VISITOR))
#define VALA_CODE_VISITOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CODE_VISITOR, ValaCodeVisitorClass))

typedef struct _ValaCodeVisitor ValaCodeVisitor;
typedef struct _ValaCodeVisitorClass ValaCodeVisitorClass;
typedef struct _ValaCodeVisitorPrivate ValaCodeVisitorPrivate;

#define VALA_TYPE_SOURCE_FILE (vala_source_file_get_type ())
#define VALA_SOURCE_FILE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_SOURCE_FILE, ValaSourceFile))
#define VALA_SOURCE_FILE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_SOURCE_FILE, ValaSourceFileClass))
#define VALA_IS_SOURCE_FILE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_SOURCE_FILE))
#define VALA_IS_SOURCE_FILE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_SOURCE_FILE))
#define VALA_SOURCE_FILE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_SOURCE_FILE, ValaSourceFileClass))

typedef struct _ValaSourceFile ValaSourceFile;
typedef struct _ValaSourceFileClass ValaSourceFileClass;

#define VALA_TYPE_CODE_NODE (vala_code_node_get_type ())
#define VALA_CODE_NODE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CODE_NODE, ValaCodeNode))
#define VALA_CODE_NODE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CODE_NODE, ValaCodeNodeClass))
#define VALA_IS_CODE_NODE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CODE_NODE))
#define VALA_IS_CODE_NODE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CODE_NODE))
#define VALA_CODE_NODE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CODE_NODE, ValaCodeNodeClass))

typedef struct _ValaCodeNode ValaCodeNode;
typedef struct _ValaCodeNodeClass ValaCodeNodeClass;

#define VALA_TYPE_SYMBOL (vala_symbol_get_type ())
#define VALA_SYMBOL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_SYMBOL, ValaSymbol))
#define VALA_SYMBOL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_SYMBOL, ValaSymbolClass))
#define VALA_IS_SYMBOL(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_SYMBOL))
#define VALA_IS_SYMBOL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_SYMBOL))
#define VALA_SYMBOL_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_SYMBOL, ValaSymbolClass))

typedef struct _ValaSymbol ValaSymbol;
typedef struct _ValaSymbolClass ValaSymbolClass;

#define VALA_TYPE_NAMESPACE (vala_namespace_get_type ())
#define VALA_NAMESPACE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_NAMESPACE, ValaNamespace))
#define VALA_NAMESPACE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_NAMESPACE, ValaNamespaceClass))
#define VALA_IS_NAMESPACE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_NAMESPACE))
#define VALA_IS_NAMESPACE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_NAMESPACE))
#define VALA_NAMESPACE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_NAMESPACE, ValaNamespaceClass))

typedef struct _ValaNamespace ValaNamespace;
typedef struct _ValaNamespaceClass ValaNamespaceClass;

#define VALA_TYPE_TYPESYMBOL (vala_typesymbol_get_type ())
#define VALA_TYPESYMBOL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_TYPESYMBOL, ValaTypeSymbol))
#define VALA_TYPESYMBOL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_TYPESYMBOL, ValaTypeSymbolClass))
#define VALA_IS_TYPESYMBOL(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_TYPESYMBOL))
#define VALA_IS_TYPESYMBOL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_TYPESYMBOL))
#define VALA_TYPESYMBOL_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_TYPESYMBOL, ValaTypeSymbolClass))

typedef struct _ValaTypeSymbol ValaTypeSymbol;
typedef struct _ValaTypeSymbolClass ValaTypeSymbolClass;

#define VALA_TYPE_OBJECT_TYPE_SYMBOL (vala_object_type_symbol_get_type ())
#define VALA_OBJECT_TYPE_SYMBOL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_OBJECT_TYPE_SYMBOL, ValaObjectTypeSymbol))
#define VALA_OBJECT_TYPE_SYMBOL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_OBJECT_TYPE_SYMBOL, ValaObjectTypeSymbolClass))
#define VALA_IS_OBJECT_TYPE_SYMBOL(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_OBJECT_TYPE_SYMBOL))
#define VALA_IS_OBJECT_TYPE_SYMBOL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_OBJECT_TYPE_SYMBOL))
#define VALA_OBJECT_TYPE_SYMBOL_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_OBJECT_TYPE_SYMBOL, ValaObjectTypeSymbolClass))

typedef struct _ValaObjectTypeSymbol ValaObjectTypeSymbol;
typedef struct _ValaObjectTypeSymbolClass ValaObjectTypeSymbolClass;

#define VALA_TYPE_CLASS (vala_class_get_type ())
#define VALA_CLASS(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CLASS, ValaClass))
#define VALA_CLASS_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CLASS, ValaClassClass))
#define VALA_IS_CLASS(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CLASS))
#define VALA_IS_CLASS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CLASS))
#define VALA_CLASS_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CLASS, ValaClassClass))

typedef struct _ValaClass ValaClass;
typedef struct _ValaClassClass ValaClassClass;

#define VALA_TYPE_STRUCT (vala_struct_get_type ())
#define VALA_STRUCT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_STRUCT, ValaStruct))
#define VALA_STRUCT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_STRUCT, ValaStructClass))
#define VALA_IS_STRUCT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_STRUCT))
#define VALA_IS_STRUCT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_STRUCT))
#define VALA_STRUCT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_STRUCT, ValaStructClass))

typedef struct _ValaStruct ValaStruct;
typedef struct _ValaStructClass ValaStructClass;

#define VALA_TYPE_INTERFACE (vala_interface_get_type ())
#define VALA_INTERFACE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_INTERFACE, ValaInterface))
#define VALA_INTERFACE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_INTERFACE, ValaInterfaceClass))
#define VALA_IS_INTERFACE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_INTERFACE))
#define VALA_IS_INTERFACE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_INTERFACE))
#define VALA_INTERFACE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_INTERFACE, ValaInterfaceClass))

typedef struct _ValaInterface ValaInterface;
typedef struct _ValaInterfaceClass ValaInterfaceClass;

#define VALA_TYPE_ENUM (vala_enum_get_type ())
#define VALA_ENUM(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_ENUM, ValaEnum))
#define VALA_ENUM_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_ENUM, ValaEnumClass))
#define VALA_IS_ENUM(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_ENUM))
#define VALA_IS_ENUM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_ENUM))
#define VALA_ENUM_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_ENUM, ValaEnumClass))

typedef struct _ValaEnum ValaEnum;
typedef struct _ValaEnumClass ValaEnumClass;

#define VALA_TYPE_CONSTANT (vala_constant_get_type ())
#define VALA_CONSTANT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CONSTANT, ValaConstant))
#define VALA_CONSTANT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CONSTANT, ValaConstantClass))
#define VALA_IS_CONSTANT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CONSTANT))
#define VALA_IS_CONSTANT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CONSTANT))
#define VALA_CONSTANT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CONSTANT, ValaConstantClass))

typedef struct _ValaConstant ValaConstant;
typedef struct _ValaConstantClass ValaConstantClass;

#define VALA_TYPE_ENUM_VALUE (vala_enum_value_get_type ())
#define VALA_ENUM_VALUE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_ENUM_VALUE, ValaEnumValue))
#define VALA_ENUM_VALUE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_ENUM_VALUE, ValaEnumValueClass))
#define VALA_IS_ENUM_VALUE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_ENUM_VALUE))
#define VALA_IS_ENUM_VALUE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_ENUM_VALUE))
#define VALA_ENUM_VALUE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_ENUM_VALUE, ValaEnumValueClass))

typedef struct _ValaEnumValue ValaEnumValue;
typedef struct _ValaEnumValueClass ValaEnumValueClass;

#define VALA_TYPE_ERROR_DOMAIN (vala_error_domain_get_type ())
#define VALA_ERROR_DOMAIN(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_ERROR_DOMAIN, ValaErrorDomain))
#define VALA_ERROR_DOMAIN_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_ERROR_DOMAIN, ValaErrorDomainClass))
#define VALA_IS_ERROR_DOMAIN(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_ERROR_DOMAIN))
#define VALA_IS_ERROR_DOMAIN_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_ERROR_DOMAIN))
#define VALA_ERROR_DOMAIN_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_ERROR_DOMAIN, ValaErrorDomainClass))

typedef struct _ValaErrorDomain ValaErrorDomain;
typedef struct _ValaErrorDomainClass ValaErrorDomainClass;

#define VALA_TYPE_ERROR_CODE (vala_error_code_get_type ())
#define VALA_ERROR_CODE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_ERROR_CODE, ValaErrorCode))
#define VALA_ERROR_CODE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_ERROR_CODE, ValaErrorCodeClass))
#define VALA_IS_ERROR_CODE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_ERROR_CODE))
#define VALA_IS_ERROR_CODE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_ERROR_CODE))
#define VALA_ERROR_CODE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_ERROR_CODE, ValaErrorCodeClass))

typedef struct _ValaErrorCode ValaErrorCode;
typedef struct _ValaErrorCodeClass ValaErrorCodeClass;

#define VALA_TYPE_DELEGATE (vala_delegate_get_type ())
#define VALA_DELEGATE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_DELEGATE, ValaDelegate))
#define VALA_DELEGATE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_DELEGATE, ValaDelegateClass))
#define VALA_IS_DELEGATE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_DELEGATE))
#define VALA_IS_DELEGATE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_DELEGATE))
#define VALA_DELEGATE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_DELEGATE, ValaDelegateClass))

typedef struct _ValaDelegate ValaDelegate;
typedef struct _ValaDelegateClass ValaDelegateClass;

#define VALA_TYPE_VARIABLE (vala_variable_get_type ())
#define VALA_VARIABLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_VARIABLE, ValaVariable))
#define VALA_VARIABLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_VARIABLE, ValaVariableClass))
#define VALA_IS_VARIABLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_VARIABLE))
#define VALA_IS_VARIABLE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_VARIABLE))
#define VALA_VARIABLE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_VARIABLE, ValaVariableClass))

typedef struct _ValaVariable ValaVariable;
typedef struct _ValaVariableClass ValaVariableClass;

#define VALA_TYPE_FIELD (vala_field_get_type ())
#define VALA_FIELD(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_FIELD, ValaField))
#define VALA_FIELD_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_FIELD, ValaFieldClass))
#define VALA_IS_FIELD(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_FIELD))
#define VALA_IS_FIELD_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_FIELD))
#define VALA_FIELD_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_FIELD, ValaFieldClass))

typedef struct _ValaField ValaField;
typedef struct _ValaFieldClass ValaFieldClass;

#define VALA_TYPE_SUBROUTINE (vala_subroutine_get_type ())
#define VALA_SUBROUTINE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_SUBROUTINE, ValaSubroutine))
#define VALA_SUBROUTINE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_SUBROUTINE, ValaSubroutineClass))
#define VALA_IS_SUBROUTINE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_SUBROUTINE))
#define VALA_IS_SUBROUTINE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_SUBROUTINE))
#define VALA_SUBROUTINE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_SUBROUTINE, ValaSubroutineClass))

typedef struct _ValaSubroutine ValaSubroutine;
typedef struct _ValaSubroutineClass ValaSubroutineClass;

#define VALA_TYPE_METHOD (vala_method_get_type ())
#define VALA_METHOD(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_METHOD, ValaMethod))
#define VALA_METHOD_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_METHOD, ValaMethodClass))
#define VALA_IS_METHOD(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_METHOD))
#define VALA_IS_METHOD_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_METHOD))
#define VALA_METHOD_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_METHOD, ValaMethodClass))

typedef struct _ValaMethod ValaMethod;
typedef struct _ValaMethodClass ValaMethodClass;

#define VALA_TYPE_CREATION_METHOD (vala_creation_method_get_type ())
#define VALA_CREATION_METHOD(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CREATION_METHOD, ValaCreationMethod))
#define VALA_CREATION_METHOD_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CREATION_METHOD, ValaCreationMethodClass))
#define VALA_IS_CREATION_METHOD(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CREATION_METHOD))
#define VALA_IS_CREATION_METHOD_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CREATION_METHOD))
#define VALA_CREATION_METHOD_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CREATION_METHOD, ValaCreationMethodClass))

typedef struct _ValaCreationMethod ValaCreationMethod;
typedef struct _ValaCreationMethodClass ValaCreationMethodClass;

#define VALA_TYPE_PARAMETER (vala_parameter_get_type ())
#define VALA_PARAMETER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_PARAMETER, ValaParameter))
#define VALA_PARAMETER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_PARAMETER, ValaParameterClass))
#define VALA_IS_PARAMETER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_PARAMETER))
#define VALA_IS_PARAMETER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_PARAMETER))
#define VALA_PARAMETER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_PARAMETER, ValaParameterClass))

typedef struct _ValaParameter ValaParameter;
typedef struct _ValaParameterClass ValaParameterClass;

#define VALA_TYPE_PROPERTY (vala_property_get_type ())
#define VALA_PROPERTY(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_PROPERTY, ValaProperty))
#define VALA_PROPERTY_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_PROPERTY, ValaPropertyClass))
#define VALA_IS_PROPERTY(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_PROPERTY))
#define VALA_IS_PROPERTY_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_PROPERTY))
#define VALA_PROPERTY_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_PROPERTY, ValaPropertyClass))

typedef struct _ValaProperty ValaProperty;
typedef struct _ValaPropertyClass ValaPropertyClass;

#define VALA_TYPE_PROPERTY_ACCESSOR (vala_property_accessor_get_type ())
#define VALA_PROPERTY_ACCESSOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_PROPERTY_ACCESSOR, ValaPropertyAccessor))
#define VALA_PROPERTY_ACCESSOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_PROPERTY_ACCESSOR, ValaPropertyAccessorClass))
#define VALA_IS_PROPERTY_ACCESSOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_PROPERTY_ACCESSOR))
#define VALA_IS_PROPERTY_ACCESSOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_PROPERTY_ACCESSOR))
#define VALA_PROPERTY_ACCESSOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_PROPERTY_ACCESSOR, ValaPropertyAccessorClass))

typedef struct _ValaPropertyAccessor ValaPropertyAccessor;
typedef struct _ValaPropertyAccessorClass ValaPropertyAccessorClass;

#define VALA_TYPE_SIGNAL (vala_signal_get_type ())
#define VALA_SIGNAL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_SIGNAL, ValaSignal))
#define VALA_SIGNAL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_SIGNAL, ValaSignalClass))
#define VALA_IS_SIGNAL(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_SIGNAL))
#define VALA_IS_SIGNAL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_SIGNAL))
#define VALA_SIGNAL_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_SIGNAL, ValaSignalClass))

typedef struct _ValaSignal ValaSignal;
typedef struct _ValaSignalClass ValaSignalClass;

#define VALA_TYPE_CONSTRUCTOR (vala_constructor_get_type ())
#define VALA_CONSTRUCTOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CONSTRUCTOR, ValaConstructor))
#define VALA_CONSTRUCTOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CONSTRUCTOR, ValaConstructorClass))
#define VALA_IS_CONSTRUCTOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CONSTRUCTOR))
#define VALA_IS_CONSTRUCTOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CONSTRUCTOR))
#define VALA_CONSTRUCTOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CONSTRUCTOR, ValaConstructorClass))

typedef struct _ValaConstructor ValaConstructor;
typedef struct _ValaConstructorClass ValaConstructorClass;

#define VALA_TYPE_DESTRUCTOR (vala_destructor_get_type ())
#define VALA_DESTRUCTOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_DESTRUCTOR, ValaDestructor))
#define VALA_DESTRUCTOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_DESTRUCTOR, ValaDestructorClass))
#define VALA_IS_DESTRUCTOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_DESTRUCTOR))
#define VALA_IS_DESTRUCTOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_DESTRUCTOR))
#define VALA_DESTRUCTOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_DESTRUCTOR, ValaDestructorClass))

typedef struct _ValaDestructor ValaDestructor;
typedef struct _ValaDestructorClass ValaDestructorClass;

#define VALA_TYPE_TYPEPARAMETER (vala_typeparameter_get_type ())
#define VALA_TYPEPARAMETER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_TYPEPARAMETER, ValaTypeParameter))
#define VALA_TYPEPARAMETER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_TYPEPARAMETER, ValaTypeParameterClass))
#define VALA_IS_TYPEPARAMETER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_TYPEPARAMETER))
#define VALA_IS_TYPEPARAMETER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_TYPEPARAMETER))
#define VALA_TYPEPARAMETER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_TYPEPARAMETER, ValaTypeParameterClass))

typedef struct _ValaTypeParameter ValaTypeParameter;
typedef struct _ValaTypeParameterClass ValaTypeParameterClass;

#define VALA_TYPE_USING_DIRECTIVE (vala_using_directive_get_type ())
#define VALA_USING_DIRECTIVE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_USING_DIRECTIVE, ValaUsingDirective))
#define VALA_USING_DIRECTIVE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_USING_DIRECTIVE, ValaUsingDirectiveClass))
#define VALA_IS_USING_DIRECTIVE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_USING_DIRECTIVE))
#define VALA_IS_USING_DIRECTIVE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_USING_DIRECTIVE))
#define VALA_USING_DIRECTIVE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_USING_DIRECTIVE, ValaUsingDirectiveClass))

typedef struct _ValaUsingDirective ValaUsingDirective;
typedef struct _ValaUsingDirectiveClass ValaUsingDirectiveClass;

#define VALA_TYPE_DATA_TYPE (vala_data_type_get_type ())
#define VALA_DATA_TYPE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_DATA_TYPE, ValaDataType))
#define VALA_DATA_TYPE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_DATA_TYPE, ValaDataTypeClass))
#define VALA_IS_DATA_TYPE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_DATA_TYPE))
#define VALA_IS_DATA_TYPE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_DATA_TYPE))
#define VALA_DATA_TYPE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_DATA_TYPE, ValaDataTypeClass))

typedef struct _ValaDataType ValaDataType;
typedef struct _ValaDataTypeClass ValaDataTypeClass;

#define VALA_TYPE_BLOCK (vala_block_get_type ())
#define VALA_BLOCK(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_BLOCK, ValaBlock))
#define VALA_BLOCK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_BLOCK, ValaBlockClass))
#define VALA_IS_BLOCK(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_BLOCK))
#define VALA_IS_BLOCK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_BLOCK))
#define VALA_BLOCK_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_BLOCK, ValaBlockClass))

typedef struct _ValaBlock ValaBlock;
typedef struct _ValaBlockClass ValaBlockClass;

#define VALA_TYPE_EMPTY_STATEMENT (vala_empty_statement_get_type ())
#define VALA_EMPTY_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_EMPTY_STATEMENT, ValaEmptyStatement))
#define VALA_EMPTY_STATEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_EMPTY_STATEMENT, ValaEmptyStatementClass))
#define VALA_IS_EMPTY_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_EMPTY_STATEMENT))
#define VALA_IS_EMPTY_STATEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_EMPTY_STATEMENT))
#define VALA_EMPTY_STATEMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_EMPTY_STATEMENT, ValaEmptyStatementClass))

typedef struct _ValaEmptyStatement ValaEmptyStatement;
typedef struct _ValaEmptyStatementClass ValaEmptyStatementClass;

#define VALA_TYPE_DECLARATION_STATEMENT (vala_declaration_statement_get_type ())
#define VALA_DECLARATION_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_DECLARATION_STATEMENT, ValaDeclarationStatement))
#define VALA_DECLARATION_STATEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_DECLARATION_STATEMENT, ValaDeclarationStatementClass))
#define VALA_IS_DECLARATION_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_DECLARATION_STATEMENT))
#define VALA_IS_DECLARATION_STATEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_DECLARATION_STATEMENT))
#define VALA_DECLARATION_STATEMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_DECLARATION_STATEMENT, ValaDeclarationStatementClass))

typedef struct _ValaDeclarationStatement ValaDeclarationStatement;
typedef struct _ValaDeclarationStatementClass ValaDeclarationStatementClass;

#define VALA_TYPE_LOCAL_VARIABLE (vala_local_variable_get_type ())
#define VALA_LOCAL_VARIABLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_LOCAL_VARIABLE, ValaLocalVariable))
#define VALA_LOCAL_VARIABLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_LOCAL_VARIABLE, ValaLocalVariableClass))
#define VALA_IS_LOCAL_VARIABLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_LOCAL_VARIABLE))
#define VALA_IS_LOCAL_VARIABLE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_LOCAL_VARIABLE))
#define VALA_LOCAL_VARIABLE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_LOCAL_VARIABLE, ValaLocalVariableClass))

typedef struct _ValaLocalVariable ValaLocalVariable;
typedef struct _ValaLocalVariableClass ValaLocalVariableClass;

#define VALA_TYPE_EXPRESSION (vala_expression_get_type ())
#define VALA_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_EXPRESSION, ValaExpression))
#define VALA_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_EXPRESSION, ValaExpressionClass))
#define VALA_IS_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_EXPRESSION))
#define VALA_IS_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_EXPRESSION))
#define VALA_EXPRESSION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_EXPRESSION, ValaExpressionClass))

typedef struct _ValaExpression ValaExpression;
typedef struct _ValaExpressionClass ValaExpressionClass;

#define VALA_TYPE_INITIALIZER_LIST (vala_initializer_list_get_type ())
#define VALA_INITIALIZER_LIST(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_INITIALIZER_LIST, ValaInitializerList))
#define VALA_INITIALIZER_LIST_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_INITIALIZER_LIST, ValaInitializerListClass))
#define VALA_IS_INITIALIZER_LIST(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_INITIALIZER_LIST))
#define VALA_IS_INITIALIZER_LIST_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_INITIALIZER_LIST))
#define VALA_INITIALIZER_LIST_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_INITIALIZER_LIST, ValaInitializerListClass))

typedef struct _ValaInitializerList ValaInitializerList;
typedef struct _ValaInitializerListClass ValaInitializerListClass;

#define VALA_TYPE_EXPRESSION_STATEMENT (vala_expression_statement_get_type ())
#define VALA_EXPRESSION_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_EXPRESSION_STATEMENT, ValaExpressionStatement))
#define VALA_EXPRESSION_STATEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_EXPRESSION_STATEMENT, ValaExpressionStatementClass))
#define VALA_IS_EXPRESSION_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_EXPRESSION_STATEMENT))
#define VALA_IS_EXPRESSION_STATEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_EXPRESSION_STATEMENT))
#define VALA_EXPRESSION_STATEMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_EXPRESSION_STATEMENT, ValaExpressionStatementClass))

typedef struct _ValaExpressionStatement ValaExpressionStatement;
typedef struct _ValaExpressionStatementClass ValaExpressionStatementClass;

#define VALA_TYPE_IF_STATEMENT (vala_if_statement_get_type ())
#define VALA_IF_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_IF_STATEMENT, ValaIfStatement))
#define VALA_IF_STATEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_IF_STATEMENT, ValaIfStatementClass))
#define VALA_IS_IF_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_IF_STATEMENT))
#define VALA_IS_IF_STATEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_IF_STATEMENT))
#define VALA_IF_STATEMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_IF_STATEMENT, ValaIfStatementClass))

typedef struct _ValaIfStatement ValaIfStatement;
typedef struct _ValaIfStatementClass ValaIfStatementClass;

#define VALA_TYPE_SWITCH_STATEMENT (vala_switch_statement_get_type ())
#define VALA_SWITCH_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_SWITCH_STATEMENT, ValaSwitchStatement))
#define VALA_SWITCH_STATEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_SWITCH_STATEMENT, ValaSwitchStatementClass))
#define VALA_IS_SWITCH_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_SWITCH_STATEMENT))
#define VALA_IS_SWITCH_STATEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_SWITCH_STATEMENT))
#define VALA_SWITCH_STATEMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_SWITCH_STATEMENT, ValaSwitchStatementClass))

typedef struct _ValaSwitchStatement ValaSwitchStatement;
typedef struct _ValaSwitchStatementClass ValaSwitchStatementClass;

#define VALA_TYPE_SWITCH_SECTION (vala_switch_section_get_type ())
#define VALA_SWITCH_SECTION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_SWITCH_SECTION, ValaSwitchSection))
#define VALA_SWITCH_SECTION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_SWITCH_SECTION, ValaSwitchSectionClass))
#define VALA_IS_SWITCH_SECTION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_SWITCH_SECTION))
#define VALA_IS_SWITCH_SECTION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_SWITCH_SECTION))
#define VALA_SWITCH_SECTION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_SWITCH_SECTION, ValaSwitchSectionClass))

typedef struct _ValaSwitchSection ValaSwitchSection;
typedef struct _ValaSwitchSectionClass ValaSwitchSectionClass;

#define VALA_TYPE_SWITCH_LABEL (vala_switch_label_get_type ())
#define VALA_SWITCH_LABEL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_SWITCH_LABEL, ValaSwitchLabel))
#define VALA_SWITCH_LABEL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_SWITCH_LABEL, ValaSwitchLabelClass))
#define VALA_IS_SWITCH_LABEL(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_SWITCH_LABEL))
#define VALA_IS_SWITCH_LABEL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_SWITCH_LABEL))
#define VALA_SWITCH_LABEL_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_SWITCH_LABEL, ValaSwitchLabelClass))

typedef struct _ValaSwitchLabel ValaSwitchLabel;
typedef struct _ValaSwitchLabelClass ValaSwitchLabelClass;

#define VALA_TYPE_LOOP (vala_loop_get_type ())
#define VALA_LOOP(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_LOOP, ValaLoop))
#define VALA_LOOP_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_LOOP, ValaLoopClass))
#define VALA_IS_LOOP(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_LOOP))
#define VALA_IS_LOOP_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_LOOP))
#define VALA_LOOP_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_LOOP, ValaLoopClass))

typedef struct _ValaLoop ValaLoop;
typedef struct _ValaLoopClass ValaLoopClass;

#define VALA_TYPE_WHILE_STATEMENT (vala_while_statement_get_type ())
#define VALA_WHILE_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_WHILE_STATEMENT, ValaWhileStatement))
#define VALA_WHILE_STATEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_WHILE_STATEMENT, ValaWhileStatementClass))
#define VALA_IS_WHILE_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_WHILE_STATEMENT))
#define VALA_IS_WHILE_STATEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_WHILE_STATEMENT))
#define VALA_WHILE_STATEMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_WHILE_STATEMENT, ValaWhileStatementClass))

typedef struct _ValaWhileStatement ValaWhileStatement;
typedef struct _ValaWhileStatementClass ValaWhileStatementClass;

#define VALA_TYPE_DO_STATEMENT (vala_do_statement_get_type ())
#define VALA_DO_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_DO_STATEMENT, ValaDoStatement))
#define VALA_DO_STATEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_DO_STATEMENT, ValaDoStatementClass))
#define VALA_IS_DO_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_DO_STATEMENT))
#define VALA_IS_DO_STATEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_DO_STATEMENT))
#define VALA_DO_STATEMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_DO_STATEMENT, ValaDoStatementClass))

typedef struct _ValaDoStatement ValaDoStatement;
typedef struct _ValaDoStatementClass ValaDoStatementClass;

#define VALA_TYPE_FOR_STATEMENT (vala_for_statement_get_type ())
#define VALA_FOR_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_FOR_STATEMENT, ValaForStatement))
#define VALA_FOR_STATEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_FOR_STATEMENT, ValaForStatementClass))
#define VALA_IS_FOR_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_FOR_STATEMENT))
#define VALA_IS_FOR_STATEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_FOR_STATEMENT))
#define VALA_FOR_STATEMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_FOR_STATEMENT, ValaForStatementClass))

typedef struct _ValaForStatement ValaForStatement;
typedef struct _ValaForStatementClass ValaForStatementClass;

#define VALA_TYPE_FOREACH_STATEMENT (vala_foreach_statement_get_type ())
#define VALA_FOREACH_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_FOREACH_STATEMENT, ValaForeachStatement))
#define VALA_FOREACH_STATEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_FOREACH_STATEMENT, ValaForeachStatementClass))
#define VALA_IS_FOREACH_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_FOREACH_STATEMENT))
#define VALA_IS_FOREACH_STATEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_FOREACH_STATEMENT))
#define VALA_FOREACH_STATEMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_FOREACH_STATEMENT, ValaForeachStatementClass))

typedef struct _ValaForeachStatement ValaForeachStatement;
typedef struct _ValaForeachStatementClass ValaForeachStatementClass;

#define VALA_TYPE_BREAK_STATEMENT (vala_break_statement_get_type ())
#define VALA_BREAK_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_BREAK_STATEMENT, ValaBreakStatement))
#define VALA_BREAK_STATEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_BREAK_STATEMENT, ValaBreakStatementClass))
#define VALA_IS_BREAK_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_BREAK_STATEMENT))
#define VALA_IS_BREAK_STATEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_BREAK_STATEMENT))
#define VALA_BREAK_STATEMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_BREAK_STATEMENT, ValaBreakStatementClass))

typedef struct _ValaBreakStatement ValaBreakStatement;
typedef struct _ValaBreakStatementClass ValaBreakStatementClass;

#define VALA_TYPE_CONTINUE_STATEMENT (vala_continue_statement_get_type ())
#define VALA_CONTINUE_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CONTINUE_STATEMENT, ValaContinueStatement))
#define VALA_CONTINUE_STATEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CONTINUE_STATEMENT, ValaContinueStatementClass))
#define VALA_IS_CONTINUE_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CONTINUE_STATEMENT))
#define VALA_IS_CONTINUE_STATEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CONTINUE_STATEMENT))
#define VALA_CONTINUE_STATEMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CONTINUE_STATEMENT, ValaContinueStatementClass))

typedef struct _ValaContinueStatement ValaContinueStatement;
typedef struct _ValaContinueStatementClass ValaContinueStatementClass;

#define VALA_TYPE_RETURN_STATEMENT (vala_return_statement_get_type ())
#define VALA_RETURN_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_RETURN_STATEMENT, ValaReturnStatement))
#define VALA_RETURN_STATEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_RETURN_STATEMENT, ValaReturnStatementClass))
#define VALA_IS_RETURN_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_RETURN_STATEMENT))
#define VALA_IS_RETURN_STATEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_RETURN_STATEMENT))
#define VALA_RETURN_STATEMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_RETURN_STATEMENT, ValaReturnStatementClass))

typedef struct _ValaReturnStatement ValaReturnStatement;
typedef struct _ValaReturnStatementClass ValaReturnStatementClass;

#define VALA_TYPE_YIELD_STATEMENT (vala_yield_statement_get_type ())
#define VALA_YIELD_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_YIELD_STATEMENT, ValaYieldStatement))
#define VALA_YIELD_STATEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_YIELD_STATEMENT, ValaYieldStatementClass))
#define VALA_IS_YIELD_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_YIELD_STATEMENT))
#define VALA_IS_YIELD_STATEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_YIELD_STATEMENT))
#define VALA_YIELD_STATEMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_YIELD_STATEMENT, ValaYieldStatementClass))

typedef struct _ValaYieldStatement ValaYieldStatement;
typedef struct _ValaYieldStatementClass ValaYieldStatementClass;

#define VALA_TYPE_THROW_STATEMENT (vala_throw_statement_get_type ())
#define VALA_THROW_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_THROW_STATEMENT, ValaThrowStatement))
#define VALA_THROW_STATEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_THROW_STATEMENT, ValaThrowStatementClass))
#define VALA_IS_THROW_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_THROW_STATEMENT))
#define VALA_IS_THROW_STATEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_THROW_STATEMENT))
#define VALA_THROW_STATEMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_THROW_STATEMENT, ValaThrowStatementClass))

typedef struct _ValaThrowStatement ValaThrowStatement;
typedef struct _ValaThrowStatementClass ValaThrowStatementClass;

#define VALA_TYPE_TRY_STATEMENT (vala_try_statement_get_type ())
#define VALA_TRY_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_TRY_STATEMENT, ValaTryStatement))
#define VALA_TRY_STATEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_TRY_STATEMENT, ValaTryStatementClass))
#define VALA_IS_TRY_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_TRY_STATEMENT))
#define VALA_IS_TRY_STATEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_TRY_STATEMENT))
#define VALA_TRY_STATEMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_TRY_STATEMENT, ValaTryStatementClass))

typedef struct _ValaTryStatement ValaTryStatement;
typedef struct _ValaTryStatementClass ValaTryStatementClass;

#define VALA_TYPE_CATCH_CLAUSE (vala_catch_clause_get_type ())
#define VALA_CATCH_CLAUSE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CATCH_CLAUSE, ValaCatchClause))
#define VALA_CATCH_CLAUSE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CATCH_CLAUSE, ValaCatchClauseClass))
#define VALA_IS_CATCH_CLAUSE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CATCH_CLAUSE))
#define VALA_IS_CATCH_CLAUSE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CATCH_CLAUSE))
#define VALA_CATCH_CLAUSE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CATCH_CLAUSE, ValaCatchClauseClass))

typedef struct _ValaCatchClause ValaCatchClause;
typedef struct _ValaCatchClauseClass ValaCatchClauseClass;

#define VALA_TYPE_LOCK_STATEMENT (vala_lock_statement_get_type ())
#define VALA_LOCK_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_LOCK_STATEMENT, ValaLockStatement))
#define VALA_LOCK_STATEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_LOCK_STATEMENT, ValaLockStatementClass))
#define VALA_IS_LOCK_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_LOCK_STATEMENT))
#define VALA_IS_LOCK_STATEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_LOCK_STATEMENT))
#define VALA_LOCK_STATEMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_LOCK_STATEMENT, ValaLockStatementClass))

typedef struct _ValaLockStatement ValaLockStatement;
typedef struct _ValaLockStatementClass ValaLockStatementClass;

#define VALA_TYPE_UNLOCK_STATEMENT (vala_unlock_statement_get_type ())
#define VALA_UNLOCK_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_UNLOCK_STATEMENT, ValaUnlockStatement))
#define VALA_UNLOCK_STATEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_UNLOCK_STATEMENT, ValaUnlockStatementClass))
#define VALA_IS_UNLOCK_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_UNLOCK_STATEMENT))
#define VALA_IS_UNLOCK_STATEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_UNLOCK_STATEMENT))
#define VALA_UNLOCK_STATEMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_UNLOCK_STATEMENT, ValaUnlockStatementClass))

typedef struct _ValaUnlockStatement ValaUnlockStatement;
typedef struct _ValaUnlockStatementClass ValaUnlockStatementClass;

#define VALA_TYPE_DELETE_STATEMENT (vala_delete_statement_get_type ())
#define VALA_DELETE_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_DELETE_STATEMENT, ValaDeleteStatement))
#define VALA_DELETE_STATEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_DELETE_STATEMENT, ValaDeleteStatementClass))
#define VALA_IS_DELETE_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_DELETE_STATEMENT))
#define VALA_IS_DELETE_STATEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_DELETE_STATEMENT))
#define VALA_DELETE_STATEMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_DELETE_STATEMENT, ValaDeleteStatementClass))

typedef struct _ValaDeleteStatement ValaDeleteStatement;
typedef struct _ValaDeleteStatementClass ValaDeleteStatementClass;

#define VALA_TYPE_ARRAY_CREATION_EXPRESSION (vala_array_creation_expression_get_type ())
#define VALA_ARRAY_CREATION_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_ARRAY_CREATION_EXPRESSION, ValaArrayCreationExpression))
#define VALA_ARRAY_CREATION_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_ARRAY_CREATION_EXPRESSION, ValaArrayCreationExpressionClass))
#define VALA_IS_ARRAY_CREATION_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_ARRAY_CREATION_EXPRESSION))
#define VALA_IS_ARRAY_CREATION_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_ARRAY_CREATION_EXPRESSION))
#define VALA_ARRAY_CREATION_EXPRESSION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_ARRAY_CREATION_EXPRESSION, ValaArrayCreationExpressionClass))

typedef struct _ValaArrayCreationExpression ValaArrayCreationExpression;
typedef struct _ValaArrayCreationExpressionClass ValaArrayCreationExpressionClass;

#define VALA_TYPE_LITERAL (vala_literal_get_type ())
#define VALA_LITERAL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_LITERAL, ValaLiteral))
#define VALA_LITERAL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_LITERAL, ValaLiteralClass))
#define VALA_IS_LITERAL(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_LITERAL))
#define VALA_IS_LITERAL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_LITERAL))
#define VALA_LITERAL_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_LITERAL, ValaLiteralClass))

typedef struct _ValaLiteral ValaLiteral;
typedef struct _ValaLiteralClass ValaLiteralClass;

#define VALA_TYPE_BOOLEAN_LITERAL (vala_boolean_literal_get_type ())
#define VALA_BOOLEAN_LITERAL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_BOOLEAN_LITERAL, ValaBooleanLiteral))
#define VALA_BOOLEAN_LITERAL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_BOOLEAN_LITERAL, ValaBooleanLiteralClass))
#define VALA_IS_BOOLEAN_LITERAL(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_BOOLEAN_LITERAL))
#define VALA_IS_BOOLEAN_LITERAL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_BOOLEAN_LITERAL))
#define VALA_BOOLEAN_LITERAL_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_BOOLEAN_LITERAL, ValaBooleanLiteralClass))

typedef struct _ValaBooleanLiteral ValaBooleanLiteral;
typedef struct _ValaBooleanLiteralClass ValaBooleanLiteralClass;

#define VALA_TYPE_CHARACTER_LITERAL (vala_character_literal_get_type ())
#define VALA_CHARACTER_LITERAL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CHARACTER_LITERAL, ValaCharacterLiteral))
#define VALA_CHARACTER_LITERAL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CHARACTER_LITERAL, ValaCharacterLiteralClass))
#define VALA_IS_CHARACTER_LITERAL(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CHARACTER_LITERAL))
#define VALA_IS_CHARACTER_LITERAL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CHARACTER_LITERAL))
#define VALA_CHARACTER_LITERAL_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CHARACTER_LITERAL, ValaCharacterLiteralClass))

typedef struct _ValaCharacterLiteral ValaCharacterLiteral;
typedef struct _ValaCharacterLiteralClass ValaCharacterLiteralClass;

#define VALA_TYPE_INTEGER_LITERAL (vala_integer_literal_get_type ())
#define VALA_INTEGER_LITERAL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_INTEGER_LITERAL, ValaIntegerLiteral))
#define VALA_INTEGER_LITERAL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_INTEGER_LITERAL, ValaIntegerLiteralClass))
#define VALA_IS_INTEGER_LITERAL(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_INTEGER_LITERAL))
#define VALA_IS_INTEGER_LITERAL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_INTEGER_LITERAL))
#define VALA_INTEGER_LITERAL_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_INTEGER_LITERAL, ValaIntegerLiteralClass))

typedef struct _ValaIntegerLiteral ValaIntegerLiteral;
typedef struct _ValaIntegerLiteralClass ValaIntegerLiteralClass;

#define VALA_TYPE_REAL_LITERAL (vala_real_literal_get_type ())
#define VALA_REAL_LITERAL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_REAL_LITERAL, ValaRealLiteral))
#define VALA_REAL_LITERAL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_REAL_LITERAL, ValaRealLiteralClass))
#define VALA_IS_REAL_LITERAL(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_REAL_LITERAL))
#define VALA_IS_REAL_LITERAL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_REAL_LITERAL))
#define VALA_REAL_LITERAL_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_REAL_LITERAL, ValaRealLiteralClass))

typedef struct _ValaRealLiteral ValaRealLiteral;
typedef struct _ValaRealLiteralClass ValaRealLiteralClass;

#define VALA_TYPE_REGEX_LITERAL (vala_regex_literal_get_type ())
#define VALA_REGEX_LITERAL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_REGEX_LITERAL, ValaRegexLiteral))
#define VALA_REGEX_LITERAL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_REGEX_LITERAL, ValaRegexLiteralClass))
#define VALA_IS_REGEX_LITERAL(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_REGEX_LITERAL))
#define VALA_IS_REGEX_LITERAL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_REGEX_LITERAL))
#define VALA_REGEX_LITERAL_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_REGEX_LITERAL, ValaRegexLiteralClass))

typedef struct _ValaRegexLiteral ValaRegexLiteral;
typedef struct _ValaRegexLiteralClass ValaRegexLiteralClass;

#define VALA_TYPE_STRING_LITERAL (vala_string_literal_get_type ())
#define VALA_STRING_LITERAL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_STRING_LITERAL, ValaStringLiteral))
#define VALA_STRING_LITERAL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_STRING_LITERAL, ValaStringLiteralClass))
#define VALA_IS_STRING_LITERAL(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_STRING_LITERAL))
#define VALA_IS_STRING_LITERAL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_STRING_LITERAL))
#define VALA_STRING_LITERAL_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_STRING_LITERAL, ValaStringLiteralClass))

typedef struct _ValaStringLiteral ValaStringLiteral;
typedef struct _ValaStringLiteralClass ValaStringLiteralClass;

#define VALA_TYPE_TEMPLATE (vala_template_get_type ())
#define VALA_TEMPLATE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_TEMPLATE, ValaTemplate))
#define VALA_TEMPLATE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_TEMPLATE, ValaTemplateClass))
#define VALA_IS_TEMPLATE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_TEMPLATE))
#define VALA_IS_TEMPLATE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_TEMPLATE))
#define VALA_TEMPLATE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_TEMPLATE, ValaTemplateClass))

typedef struct _ValaTemplate ValaTemplate;
typedef struct _ValaTemplateClass ValaTemplateClass;

#define VALA_TYPE_LIST_LITERAL (vala_list_literal_get_type ())
#define VALA_LIST_LITERAL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_LIST_LITERAL, ValaListLiteral))
#define VALA_LIST_LITERAL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_LIST_LITERAL, ValaListLiteralClass))
#define VALA_IS_LIST_LITERAL(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_LIST_LITERAL))
#define VALA_IS_LIST_LITERAL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_LIST_LITERAL))
#define VALA_LIST_LITERAL_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_LIST_LITERAL, ValaListLiteralClass))

typedef struct _ValaListLiteral ValaListLiteral;
typedef struct _ValaListLiteralClass ValaListLiteralClass;

#define VALA_TYPE_SET_LITERAL (vala_set_literal_get_type ())
#define VALA_SET_LITERAL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_SET_LITERAL, ValaSetLiteral))
#define VALA_SET_LITERAL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_SET_LITERAL, ValaSetLiteralClass))
#define VALA_IS_SET_LITERAL(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_SET_LITERAL))
#define VALA_IS_SET_LITERAL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_SET_LITERAL))
#define VALA_SET_LITERAL_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_SET_LITERAL, ValaSetLiteralClass))

typedef struct _ValaSetLiteral ValaSetLiteral;
typedef struct _ValaSetLiteralClass ValaSetLiteralClass;

#define VALA_TYPE_MAP_LITERAL (vala_map_literal_get_type ())
#define VALA_MAP_LITERAL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_MAP_LITERAL, ValaMapLiteral))
#define VALA_MAP_LITERAL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_MAP_LITERAL, ValaMapLiteralClass))
#define VALA_IS_MAP_LITERAL(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_MAP_LITERAL))
#define VALA_IS_MAP_LITERAL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_MAP_LITERAL))
#define VALA_MAP_LITERAL_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_MAP_LITERAL, ValaMapLiteralClass))

typedef struct _ValaMapLiteral ValaMapLiteral;
typedef struct _ValaMapLiteralClass ValaMapLiteralClass;

#define VALA_TYPE_TUPLE (vala_tuple_get_type ())
#define VALA_TUPLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_TUPLE, ValaTuple))
#define VALA_TUPLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_TUPLE, ValaTupleClass))
#define VALA_IS_TUPLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_TUPLE))
#define VALA_IS_TUPLE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_TUPLE))
#define VALA_TUPLE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_TUPLE, ValaTupleClass))

typedef struct _ValaTuple ValaTuple;
typedef struct _ValaTupleClass ValaTupleClass;

#define VALA_TYPE_NULL_LITERAL (vala_null_literal_get_type ())
#define VALA_NULL_LITERAL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_NULL_LITERAL, ValaNullLiteral))
#define VALA_NULL_LITERAL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_NULL_LITERAL, ValaNullLiteralClass))
#define VALA_IS_NULL_LITERAL(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_NULL_LITERAL))
#define VALA_IS_NULL_LITERAL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_NULL_LITERAL))
#define VALA_NULL_LITERAL_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_NULL_LITERAL, ValaNullLiteralClass))

typedef struct _ValaNullLiteral ValaNullLiteral;
typedef struct _ValaNullLiteralClass ValaNullLiteralClass;

#define VALA_TYPE_MEMBER_ACCESS (vala_member_access_get_type ())
#define VALA_MEMBER_ACCESS(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_MEMBER_ACCESS, ValaMemberAccess))
#define VALA_MEMBER_ACCESS_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_MEMBER_ACCESS, ValaMemberAccessClass))
#define VALA_IS_MEMBER_ACCESS(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_MEMBER_ACCESS))
#define VALA_IS_MEMBER_ACCESS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_MEMBER_ACCESS))
#define VALA_MEMBER_ACCESS_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_MEMBER_ACCESS, ValaMemberAccessClass))

typedef struct _ValaMemberAccess ValaMemberAccess;
typedef struct _ValaMemberAccessClass ValaMemberAccessClass;

#define VALA_TYPE_METHOD_CALL (vala_method_call_get_type ())
#define VALA_METHOD_CALL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_METHOD_CALL, ValaMethodCall))
#define VALA_METHOD_CALL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_METHOD_CALL, ValaMethodCallClass))
#define VALA_IS_METHOD_CALL(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_METHOD_CALL))
#define VALA_IS_METHOD_CALL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_METHOD_CALL))
#define VALA_METHOD_CALL_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_METHOD_CALL, ValaMethodCallClass))

typedef struct _ValaMethodCall ValaMethodCall;
typedef struct _ValaMethodCallClass ValaMethodCallClass;

#define VALA_TYPE_ELEMENT_ACCESS (vala_element_access_get_type ())
#define VALA_ELEMENT_ACCESS(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_ELEMENT_ACCESS, ValaElementAccess))
#define VALA_ELEMENT_ACCESS_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_ELEMENT_ACCESS, ValaElementAccessClass))
#define VALA_IS_ELEMENT_ACCESS(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_ELEMENT_ACCESS))
#define VALA_IS_ELEMENT_ACCESS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_ELEMENT_ACCESS))
#define VALA_ELEMENT_ACCESS_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_ELEMENT_ACCESS, ValaElementAccessClass))

typedef struct _ValaElementAccess ValaElementAccess;
typedef struct _ValaElementAccessClass ValaElementAccessClass;

#define VALA_TYPE_SLICE_EXPRESSION (vala_slice_expression_get_type ())
#define VALA_SLICE_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_SLICE_EXPRESSION, ValaSliceExpression))
#define VALA_SLICE_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_SLICE_EXPRESSION, ValaSliceExpressionClass))
#define VALA_IS_SLICE_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_SLICE_EXPRESSION))
#define VALA_IS_SLICE_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_SLICE_EXPRESSION))
#define VALA_SLICE_EXPRESSION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_SLICE_EXPRESSION, ValaSliceExpressionClass))

typedef struct _ValaSliceExpression ValaSliceExpression;
typedef struct _ValaSliceExpressionClass ValaSliceExpressionClass;

#define VALA_TYPE_BASE_ACCESS (vala_base_access_get_type ())
#define VALA_BASE_ACCESS(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_BASE_ACCESS, ValaBaseAccess))
#define VALA_BASE_ACCESS_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_BASE_ACCESS, ValaBaseAccessClass))
#define VALA_IS_BASE_ACCESS(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_BASE_ACCESS))
#define VALA_IS_BASE_ACCESS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_BASE_ACCESS))
#define VALA_BASE_ACCESS_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_BASE_ACCESS, ValaBaseAccessClass))

typedef struct _ValaBaseAccess ValaBaseAccess;
typedef struct _ValaBaseAccessClass ValaBaseAccessClass;

#define VALA_TYPE_POSTFIX_EXPRESSION (vala_postfix_expression_get_type ())
#define VALA_POSTFIX_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_POSTFIX_EXPRESSION, ValaPostfixExpression))
#define VALA_POSTFIX_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_POSTFIX_EXPRESSION, ValaPostfixExpressionClass))
#define VALA_IS_POSTFIX_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_POSTFIX_EXPRESSION))
#define VALA_IS_POSTFIX_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_POSTFIX_EXPRESSION))
#define VALA_POSTFIX_EXPRESSION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_POSTFIX_EXPRESSION, ValaPostfixExpressionClass))

typedef struct _ValaPostfixExpression ValaPostfixExpression;
typedef struct _ValaPostfixExpressionClass ValaPostfixExpressionClass;

#define VALA_TYPE_OBJECT_CREATION_EXPRESSION (vala_object_creation_expression_get_type ())
#define VALA_OBJECT_CREATION_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_OBJECT_CREATION_EXPRESSION, ValaObjectCreationExpression))
#define VALA_OBJECT_CREATION_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_OBJECT_CREATION_EXPRESSION, ValaObjectCreationExpressionClass))
#define VALA_IS_OBJECT_CREATION_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_OBJECT_CREATION_EXPRESSION))
#define VALA_IS_OBJECT_CREATION_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_OBJECT_CREATION_EXPRESSION))
#define VALA_OBJECT_CREATION_EXPRESSION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_OBJECT_CREATION_EXPRESSION, ValaObjectCreationExpressionClass))

typedef struct _ValaObjectCreationExpression ValaObjectCreationExpression;
typedef struct _ValaObjectCreationExpressionClass ValaObjectCreationExpressionClass;

#define VALA_TYPE_SIZEOF_EXPRESSION (vala_sizeof_expression_get_type ())
#define VALA_SIZEOF_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_SIZEOF_EXPRESSION, ValaSizeofExpression))
#define VALA_SIZEOF_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_SIZEOF_EXPRESSION, ValaSizeofExpressionClass))
#define VALA_IS_SIZEOF_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_SIZEOF_EXPRESSION))
#define VALA_IS_SIZEOF_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_SIZEOF_EXPRESSION))
#define VALA_SIZEOF_EXPRESSION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_SIZEOF_EXPRESSION, ValaSizeofExpressionClass))

typedef struct _ValaSizeofExpression ValaSizeofExpression;
typedef struct _ValaSizeofExpressionClass ValaSizeofExpressionClass;

#define VALA_TYPE_TYPEOF_EXPRESSION (vala_typeof_expression_get_type ())
#define VALA_TYPEOF_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_TYPEOF_EXPRESSION, ValaTypeofExpression))
#define VALA_TYPEOF_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_TYPEOF_EXPRESSION, ValaTypeofExpressionClass))
#define VALA_IS_TYPEOF_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_TYPEOF_EXPRESSION))
#define VALA_IS_TYPEOF_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_TYPEOF_EXPRESSION))
#define VALA_TYPEOF_EXPRESSION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_TYPEOF_EXPRESSION, ValaTypeofExpressionClass))

typedef struct _ValaTypeofExpression ValaTypeofExpression;
typedef struct _ValaTypeofExpressionClass ValaTypeofExpressionClass;

#define VALA_TYPE_UNARY_EXPRESSION (vala_unary_expression_get_type ())
#define VALA_UNARY_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_UNARY_EXPRESSION, ValaUnaryExpression))
#define VALA_UNARY_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_UNARY_EXPRESSION, ValaUnaryExpressionClass))
#define VALA_IS_UNARY_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_UNARY_EXPRESSION))
#define VALA_IS_UNARY_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_UNARY_EXPRESSION))
#define VALA_UNARY_EXPRESSION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_UNARY_EXPRESSION, ValaUnaryExpressionClass))

typedef struct _ValaUnaryExpression ValaUnaryExpression;
typedef struct _ValaUnaryExpressionClass ValaUnaryExpressionClass;

#define VALA_TYPE_CAST_EXPRESSION (vala_cast_expression_get_type ())
#define VALA_CAST_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CAST_EXPRESSION, ValaCastExpression))
#define VALA_CAST_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CAST_EXPRESSION, ValaCastExpressionClass))
#define VALA_IS_CAST_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CAST_EXPRESSION))
#define VALA_IS_CAST_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CAST_EXPRESSION))
#define VALA_CAST_EXPRESSION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CAST_EXPRESSION, ValaCastExpressionClass))

typedef struct _ValaCastExpression ValaCastExpression;
typedef struct _ValaCastExpressionClass ValaCastExpressionClass;

#define VALA_TYPE_NAMED_ARGUMENT (vala_named_argument_get_type ())
#define VALA_NAMED_ARGUMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_NAMED_ARGUMENT, ValaNamedArgument))
#define VALA_NAMED_ARGUMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_NAMED_ARGUMENT, ValaNamedArgumentClass))
#define VALA_IS_NAMED_ARGUMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_NAMED_ARGUMENT))
#define VALA_IS_NAMED_ARGUMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_NAMED_ARGUMENT))
#define VALA_NAMED_ARGUMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_NAMED_ARGUMENT, ValaNamedArgumentClass))

typedef struct _ValaNamedArgument ValaNamedArgument;
typedef struct _ValaNamedArgumentClass ValaNamedArgumentClass;

#define VALA_TYPE_POINTER_INDIRECTION (vala_pointer_indirection_get_type ())
#define VALA_POINTER_INDIRECTION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_POINTER_INDIRECTION, ValaPointerIndirection))
#define VALA_POINTER_INDIRECTION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_POINTER_INDIRECTION, ValaPointerIndirectionClass))
#define VALA_IS_POINTER_INDIRECTION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_POINTER_INDIRECTION))
#define VALA_IS_POINTER_INDIRECTION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_POINTER_INDIRECTION))
#define VALA_POINTER_INDIRECTION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_POINTER_INDIRECTION, ValaPointerIndirectionClass))

typedef struct _ValaPointerIndirection ValaPointerIndirection;
typedef struct _ValaPointerIndirectionClass ValaPointerIndirectionClass;

#define VALA_TYPE_ADDRESSOF_EXPRESSION (vala_addressof_expression_get_type ())
#define VALA_ADDRESSOF_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_ADDRESSOF_EXPRESSION, ValaAddressofExpression))
#define VALA_ADDRESSOF_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_ADDRESSOF_EXPRESSION, ValaAddressofExpressionClass))
#define VALA_IS_ADDRESSOF_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_ADDRESSOF_EXPRESSION))
#define VALA_IS_ADDRESSOF_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_ADDRESSOF_EXPRESSION))
#define VALA_ADDRESSOF_EXPRESSION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_ADDRESSOF_EXPRESSION, ValaAddressofExpressionClass))

typedef struct _ValaAddressofExpression ValaAddressofExpression;
typedef struct _ValaAddressofExpressionClass ValaAddressofExpressionClass;

#define VALA_TYPE_REFERENCE_TRANSFER_EXPRESSION (vala_reference_transfer_expression_get_type ())
#define VALA_REFERENCE_TRANSFER_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_REFERENCE_TRANSFER_EXPRESSION, ValaReferenceTransferExpression))
#define VALA_REFERENCE_TRANSFER_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_REFERENCE_TRANSFER_EXPRESSION, ValaReferenceTransferExpressionClass))
#define VALA_IS_REFERENCE_TRANSFER_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_REFERENCE_TRANSFER_EXPRESSION))
#define VALA_IS_REFERENCE_TRANSFER_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_REFERENCE_TRANSFER_EXPRESSION))
#define VALA_REFERENCE_TRANSFER_EXPRESSION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_REFERENCE_TRANSFER_EXPRESSION, ValaReferenceTransferExpressionClass))

typedef struct _ValaReferenceTransferExpression ValaReferenceTransferExpression;
typedef struct _ValaReferenceTransferExpressionClass ValaReferenceTransferExpressionClass;

#define VALA_TYPE_BINARY_EXPRESSION (vala_binary_expression_get_type ())
#define VALA_BINARY_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_BINARY_EXPRESSION, ValaBinaryExpression))
#define VALA_BINARY_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_BINARY_EXPRESSION, ValaBinaryExpressionClass))
#define VALA_IS_BINARY_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_BINARY_EXPRESSION))
#define VALA_IS_BINARY_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_BINARY_EXPRESSION))
#define VALA_BINARY_EXPRESSION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_BINARY_EXPRESSION, ValaBinaryExpressionClass))

typedef struct _ValaBinaryExpression ValaBinaryExpression;
typedef struct _ValaBinaryExpressionClass ValaBinaryExpressionClass;

#define VALA_TYPE_TYPECHECK (vala_typecheck_get_type ())
#define VALA_TYPECHECK(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_TYPECHECK, ValaTypeCheck))
#define VALA_TYPECHECK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_TYPECHECK, ValaTypeCheckClass))
#define VALA_IS_TYPECHECK(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_TYPECHECK))
#define VALA_IS_TYPECHECK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_TYPECHECK))
#define VALA_TYPECHECK_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_TYPECHECK, ValaTypeCheckClass))

typedef struct _ValaTypeCheck ValaTypeCheck;
typedef struct _ValaTypeCheckClass ValaTypeCheckClass;

#define VALA_TYPE_CONDITIONAL_EXPRESSION (vala_conditional_expression_get_type ())
#define VALA_CONDITIONAL_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CONDITIONAL_EXPRESSION, ValaConditionalExpression))
#define VALA_CONDITIONAL_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CONDITIONAL_EXPRESSION, ValaConditionalExpressionClass))
#define VALA_IS_CONDITIONAL_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CONDITIONAL_EXPRESSION))
#define VALA_IS_CONDITIONAL_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CONDITIONAL_EXPRESSION))
#define VALA_CONDITIONAL_EXPRESSION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CONDITIONAL_EXPRESSION, ValaConditionalExpressionClass))

typedef struct _ValaConditionalExpression ValaConditionalExpression;
typedef struct _ValaConditionalExpressionClass ValaConditionalExpressionClass;

#define VALA_TYPE_LAMBDA_EXPRESSION (vala_lambda_expression_get_type ())
#define VALA_LAMBDA_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_LAMBDA_EXPRESSION, ValaLambdaExpression))
#define VALA_LAMBDA_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_LAMBDA_EXPRESSION, ValaLambdaExpressionClass))
#define VALA_IS_LAMBDA_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_LAMBDA_EXPRESSION))
#define VALA_IS_LAMBDA_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_LAMBDA_EXPRESSION))
#define VALA_LAMBDA_EXPRESSION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_LAMBDA_EXPRESSION, ValaLambdaExpressionClass))

typedef struct _ValaLambdaExpression ValaLambdaExpression;
typedef struct _ValaLambdaExpressionClass ValaLambdaExpressionClass;

#define VALA_TYPE_ASSIGNMENT (vala_assignment_get_type ())
#define VALA_ASSIGNMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_ASSIGNMENT, ValaAssignment))
#define VALA_ASSIGNMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_ASSIGNMENT, ValaAssignmentClass))
#define VALA_IS_ASSIGNMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_ASSIGNMENT))
#define VALA_IS_ASSIGNMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_ASSIGNMENT))
#define VALA_ASSIGNMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_ASSIGNMENT, ValaAssignmentClass))

typedef struct _ValaAssignment ValaAssignment;
typedef struct _ValaAssignmentClass ValaAssignmentClass;

#define VALA_TYPE_PARSER (vala_parser_get_type ())
#define VALA_PARSER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_PARSER, ValaParser))
#define VALA_PARSER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_PARSER, ValaParserClass))
#define VALA_IS_PARSER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_PARSER))
#define VALA_IS_PARSER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_PARSER))
#define VALA_PARSER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_PARSER, ValaParserClass))

typedef struct _ValaParser ValaParser;
typedef struct _ValaParserClass ValaParserClass;
typedef struct _ValaParserPrivate ValaParserPrivate;

#define VALA_TYPE_SCANNER (vala_scanner_get_type ())
#define VALA_SCANNER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_SCANNER, ValaScanner))
#define VALA_SCANNER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_SCANNER, ValaScannerClass))
#define VALA_IS_SCANNER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_SCANNER))
#define VALA_IS_SCANNER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_SCANNER))
#define VALA_SCANNER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_SCANNER, ValaScannerClass))

typedef struct _ValaScanner ValaScanner;
typedef struct _ValaScannerClass ValaScannerClass;

#define VALA_TYPE_CODE_CONTEXT (vala_code_context_get_type ())
#define VALA_CODE_CONTEXT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CODE_CONTEXT, ValaCodeContext))
#define VALA_CODE_CONTEXT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CODE_CONTEXT, ValaCodeContextClass))
#define VALA_IS_CODE_CONTEXT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CODE_CONTEXT))
#define VALA_IS_CODE_CONTEXT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CODE_CONTEXT))
#define VALA_CODE_CONTEXT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CODE_CONTEXT, ValaCodeContextClass))

typedef struct _ValaCodeContext ValaCodeContext;
typedef struct _ValaCodeContextClass ValaCodeContextClass;

#define VALA_PARSER_TYPE_TOKEN_INFO (vala_parser_token_info_get_type ())

#define VALA_TYPE_TOKEN_TYPE (vala_token_type_get_type ())

#define VALA_TYPE_SOURCE_LOCATION (vala_source_location_get_type ())
typedef struct _ValaSourceLocation ValaSourceLocation;
typedef struct _ValaParserTokenInfo ValaParserTokenInfo;

#define VALA_TYPE_COMMENT (vala_comment_get_type ())
#define VALA_COMMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_COMMENT, ValaComment))
#define VALA_COMMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_COMMENT, ValaCommentClass))
#define VALA_IS_COMMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_COMMENT))
#define VALA_IS_COMMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_COMMENT))
#define VALA_COMMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_COMMENT, ValaCommentClass))

typedef struct _ValaComment ValaComment;
typedef struct _ValaCommentClass ValaCommentClass;

#define VALA_PARSER_TYPE_MODIFIER_FLAGS (vala_parser_modifier_flags_get_type ())

#define VALA_PARSER_TYPE_RECOVERY_STATE (vala_parser_recovery_state_get_type ())
#define _vala_scanner_unref0(var) ((var == NULL) ? NULL : (var = (vala_scanner_unref (var), NULL)))
#define _vala_code_context_unref0(var) ((var == NULL) ? NULL : (var = (vala_code_context_unref (var), NULL)))
#define _vala_comment_unref0(var) ((var == NULL) ? NULL : (var = (vala_comment_unref (var), NULL)))

#define VALA_TYPE_SOURCE_REFERENCE (vala_source_reference_get_type ())
#define VALA_SOURCE_REFERENCE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_SOURCE_REFERENCE, ValaSourceReference))
#define VALA_SOURCE_REFERENCE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_SOURCE_REFERENCE, ValaSourceReferenceClass))
#define VALA_IS_SOURCE_REFERENCE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_SOURCE_REFERENCE))
#define VALA_IS_SOURCE_REFERENCE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_SOURCE_REFERENCE))
#define VALA_SOURCE_REFERENCE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_SOURCE_REFERENCE, ValaSourceReferenceClass))

typedef struct _ValaSourceReference ValaSourceReference;
typedef struct _ValaSourceReferenceClass ValaSourceReferenceClass;
#define _g_free0(var) (var = (g_free (var), NULL))
#define _vala_source_reference_unref0(var) ((var == NULL) ? NULL : (var = (vala_source_reference_unref (var), NULL)))
#define _vala_code_node_unref0(var) ((var == NULL) ? NULL : (var = (vala_code_node_unref (var), NULL)))

#define VALA_TYPE_REPORT (vala_report_get_type ())
#define VALA_REPORT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_REPORT, ValaReport))
#define VALA_REPORT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_REPORT, ValaReportClass))
#define VALA_IS_REPORT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_REPORT))
#define VALA_IS_REPORT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_REPORT))
#define VALA_REPORT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_REPORT, ValaReportClass))

typedef struct _ValaReport ValaReport;
typedef struct _ValaReportClass ValaReportClass;
#define _g_error_free0(var) ((var == NULL) ? NULL : (var = (g_error_free (var), NULL)))

#define VALA_TYPE_UNRESOLVED_SYMBOL (vala_unresolved_symbol_get_type ())
#define VALA_UNRESOLVED_SYMBOL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_UNRESOLVED_SYMBOL, ValaUnresolvedSymbol))
#define VALA_UNRESOLVED_SYMBOL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_UNRESOLVED_SYMBOL, ValaUnresolvedSymbolClass))
#define VALA_IS_UNRESOLVED_SYMBOL(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_UNRESOLVED_SYMBOL))
#define VALA_IS_UNRESOLVED_SYMBOL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_UNRESOLVED_SYMBOL))
#define VALA_UNRESOLVED_SYMBOL_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_UNRESOLVED_SYMBOL, ValaUnresolvedSymbolClass))

typedef struct _ValaUnresolvedSymbol ValaUnresolvedSymbol;
typedef struct _ValaUnresolvedSymbolClass ValaUnresolvedSymbolClass;

#define VALA_TYPE_PROFILE (vala_profile_get_type ())

#define VALA_TYPE_VOID_TYPE (vala_void_type_get_type ())
#define VALA_VOID_TYPE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_VOID_TYPE, ValaVoidType))
#define VALA_VOID_TYPE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_VOID_TYPE, ValaVoidTypeClass))
#define VALA_IS_VOID_TYPE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_VOID_TYPE))
#define VALA_IS_VOID_TYPE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_VOID_TYPE))
#define VALA_VOID_TYPE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_VOID_TYPE, ValaVoidTypeClass))

typedef struct _ValaVoidType ValaVoidType;
typedef struct _ValaVoidTypeClass ValaVoidTypeClass;

#define VALA_TYPE_UNRESOLVED_TYPE (vala_unresolved_type_get_type ())
#define VALA_UNRESOLVED_TYPE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_UNRESOLVED_TYPE, ValaUnresolvedType))
#define VALA_UNRESOLVED_TYPE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_UNRESOLVED_TYPE, ValaUnresolvedTypeClass))
#define VALA_IS_UNRESOLVED_TYPE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_UNRESOLVED_TYPE))
#define VALA_IS_UNRESOLVED_TYPE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_UNRESOLVED_TYPE))
#define VALA_UNRESOLVED_TYPE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_UNRESOLVED_TYPE, ValaUnresolvedTypeClass))

typedef struct _ValaUnresolvedType ValaUnresolvedType;
typedef struct _ValaUnresolvedTypeClass ValaUnresolvedTypeClass;
#define _vala_iterable_unref0(var) ((var == NULL) ? NULL : (var = (vala_iterable_unref (var), NULL)))

#define VALA_TYPE_POINTER_TYPE (vala_pointer_type_get_type ())
#define VALA_POINTER_TYPE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_POINTER_TYPE, ValaPointerType))
#define VALA_POINTER_TYPE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_POINTER_TYPE, ValaPointerTypeClass))
#define VALA_IS_POINTER_TYPE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_POINTER_TYPE))
#define VALA_IS_POINTER_TYPE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_POINTER_TYPE))
#define VALA_POINTER_TYPE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_POINTER_TYPE, ValaPointerTypeClass))

typedef struct _ValaPointerType ValaPointerType;
typedef struct _ValaPointerTypeClass ValaPointerTypeClass;

#define VALA_TYPE_REFERENCE_TYPE (vala_reference_type_get_type ())
#define VALA_REFERENCE_TYPE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_REFERENCE_TYPE, ValaReferenceType))
#define VALA_REFERENCE_TYPE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_REFERENCE_TYPE, ValaReferenceTypeClass))
#define VALA_IS_REFERENCE_TYPE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_REFERENCE_TYPE))
#define VALA_IS_REFERENCE_TYPE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_REFERENCE_TYPE))
#define VALA_REFERENCE_TYPE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_REFERENCE_TYPE, ValaReferenceTypeClass))

typedef struct _ValaReferenceType ValaReferenceType;
typedef struct _ValaReferenceTypeClass ValaReferenceTypeClass;

#define VALA_TYPE_ARRAY_TYPE (vala_array_type_get_type ())
#define VALA_ARRAY_TYPE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_ARRAY_TYPE, ValaArrayType))
#define VALA_ARRAY_TYPE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_ARRAY_TYPE, ValaArrayTypeClass))
#define VALA_IS_ARRAY_TYPE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_ARRAY_TYPE))
#define VALA_IS_ARRAY_TYPE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_ARRAY_TYPE))
#define VALA_ARRAY_TYPE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_ARRAY_TYPE, ValaArrayTypeClass))

typedef struct _ValaArrayType ValaArrayType;
typedef struct _ValaArrayTypeClass ValaArrayTypeClass;

#define VALA_TYPE_UNARY_OPERATOR (vala_unary_operator_get_type ())

#define VALA_TYPE_MEMBER_INITIALIZER (vala_member_initializer_get_type ())
#define VALA_MEMBER_INITIALIZER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_MEMBER_INITIALIZER, ValaMemberInitializer))
#define VALA_MEMBER_INITIALIZER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_MEMBER_INITIALIZER, ValaMemberInitializerClass))
#define VALA_IS_MEMBER_INITIALIZER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_MEMBER_INITIALIZER))
#define VALA_IS_MEMBER_INITIALIZER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_MEMBER_INITIALIZER))
#define VALA_MEMBER_INITIALIZER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_MEMBER_INITIALIZER, ValaMemberInitializerClass))

typedef struct _ValaMemberInitializer ValaMemberInitializer;
typedef struct _ValaMemberInitializerClass ValaMemberInitializerClass;

#define VALA_TYPE_BINARY_OPERATOR (vala_binary_operator_get_type ())
typedef struct _ValaCodeNodePrivate ValaCodeNodePrivate;

#define VALA_TYPE_CODE_GENERATOR (vala_code_generator_get_type ())
#define VALA_CODE_GENERATOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CODE_GENERATOR, ValaCodeGenerator))
#define VALA_CODE_GENERATOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CODE_GENERATOR, ValaCodeGeneratorClass))
#define VALA_IS_CODE_GENERATOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CODE_GENERATOR))
#define VALA_IS_CODE_GENERATOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CODE_GENERATOR))
#define VALA_CODE_GENERATOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CODE_GENERATOR, ValaCodeGeneratorClass))

typedef struct _ValaCodeGenerator ValaCodeGenerator;
typedef struct _ValaCodeGeneratorClass ValaCodeGeneratorClass;

#define VALA_TYPE_ATTRIBUTE (vala_attribute_get_type ())
#define VALA_ATTRIBUTE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_ATTRIBUTE, ValaAttribute))
#define VALA_ATTRIBUTE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_ATTRIBUTE, ValaAttributeClass))
#define VALA_IS_ATTRIBUTE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_ATTRIBUTE))
#define VALA_IS_ATTRIBUTE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_ATTRIBUTE))
#define VALA_ATTRIBUTE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_ATTRIBUTE, ValaAttributeClass))

typedef struct _ValaAttribute ValaAttribute;
typedef struct _ValaAttributeClass ValaAttributeClass;
typedef struct _ValaExpressionPrivate ValaExpressionPrivate;
typedef struct _ValaBinaryExpressionPrivate ValaBinaryExpressionPrivate;

#define VALA_TYPE_PARAMETER_DIRECTION (vala_parameter_direction_get_type ())

#define VALA_TYPE_ASSIGNMENT_OPERATOR (vala_assignment_operator_get_type ())

#define VALA_TYPE_STATEMENT (vala_statement_get_type ())
#define VALA_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_STATEMENT, ValaStatement))
#define VALA_IS_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_STATEMENT))
#define VALA_STATEMENT_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), VALA_TYPE_STATEMENT, ValaStatementIface))

typedef struct _ValaStatement ValaStatement;
typedef struct _ValaStatementIface ValaStatementIface;

#define VALA_TYPE_SYMBOL_ACCESSIBILITY (vala_symbol_accessibility_get_type ())

#define VALA_TYPE_SOURCE_FILE_TYPE (vala_source_file_type_get_type ())

#define VALA_TYPE_MEMBER_BINDING (vala_member_binding_get_type ())

struct _ValaCodeVisitor {
      GTypeInstance parent_instance;
      volatile int ref_count;
      ValaCodeVisitorPrivate * priv;
};

struct _ValaCodeVisitorClass {
      GTypeClass parent_class;
      void (*finalize) (ValaCodeVisitor *self);
      void (*visit_source_file) (ValaCodeVisitor* self, ValaSourceFile* source_file);
      void (*visit_namespace) (ValaCodeVisitor* self, ValaNamespace* ns);
      void (*visit_class) (ValaCodeVisitor* self, ValaClass* cl);
      void (*visit_struct) (ValaCodeVisitor* self, ValaStruct* st);
      void (*visit_interface) (ValaCodeVisitor* self, ValaInterface* iface);
      void (*visit_enum) (ValaCodeVisitor* self, ValaEnum* en);
      void (*visit_enum_value) (ValaCodeVisitor* self, ValaEnumValue* ev);
      void (*visit_error_domain) (ValaCodeVisitor* self, ValaErrorDomain* edomain);
      void (*visit_error_code) (ValaCodeVisitor* self, ValaErrorCode* ecode);
      void (*visit_delegate) (ValaCodeVisitor* self, ValaDelegate* d);
      void (*visit_constant) (ValaCodeVisitor* self, ValaConstant* c);
      void (*visit_field) (ValaCodeVisitor* self, ValaField* f);
      void (*visit_method) (ValaCodeVisitor* self, ValaMethod* m);
      void (*visit_creation_method) (ValaCodeVisitor* self, ValaCreationMethod* m);
      void (*visit_formal_parameter) (ValaCodeVisitor* self, ValaParameter* p);
      void (*visit_property) (ValaCodeVisitor* self, ValaProperty* prop);
      void (*visit_property_accessor) (ValaCodeVisitor* self, ValaPropertyAccessor* acc);
      void (*visit_signal) (ValaCodeVisitor* self, ValaSignal* sig);
      void (*visit_constructor) (ValaCodeVisitor* self, ValaConstructor* c);
      void (*visit_destructor) (ValaCodeVisitor* self, ValaDestructor* d);
      void (*visit_type_parameter) (ValaCodeVisitor* self, ValaTypeParameter* p);
      void (*visit_using_directive) (ValaCodeVisitor* self, ValaUsingDirective* ns);
      void (*visit_data_type) (ValaCodeVisitor* self, ValaDataType* type);
      void (*visit_block) (ValaCodeVisitor* self, ValaBlock* b);
      void (*visit_empty_statement) (ValaCodeVisitor* self, ValaEmptyStatement* stmt);
      void (*visit_declaration_statement) (ValaCodeVisitor* self, ValaDeclarationStatement* stmt);
      void (*visit_local_variable) (ValaCodeVisitor* self, ValaLocalVariable* local);
      void (*visit_initializer_list) (ValaCodeVisitor* self, ValaInitializerList* list);
      void (*visit_expression_statement) (ValaCodeVisitor* self, ValaExpressionStatement* stmt);
      void (*visit_if_statement) (ValaCodeVisitor* self, ValaIfStatement* stmt);
      void (*visit_switch_statement) (ValaCodeVisitor* self, ValaSwitchStatement* stmt);
      void (*visit_switch_section) (ValaCodeVisitor* self, ValaSwitchSection* section);
      void (*visit_switch_label) (ValaCodeVisitor* self, ValaSwitchLabel* label);
      void (*visit_loop) (ValaCodeVisitor* self, ValaLoop* stmt);
      void (*visit_while_statement) (ValaCodeVisitor* self, ValaWhileStatement* stmt);
      void (*visit_do_statement) (ValaCodeVisitor* self, ValaDoStatement* stmt);
      void (*visit_for_statement) (ValaCodeVisitor* self, ValaForStatement* stmt);
      void (*visit_foreach_statement) (ValaCodeVisitor* self, ValaForeachStatement* stmt);
      void (*visit_break_statement) (ValaCodeVisitor* self, ValaBreakStatement* stmt);
      void (*visit_continue_statement) (ValaCodeVisitor* self, ValaContinueStatement* stmt);
      void (*visit_return_statement) (ValaCodeVisitor* self, ValaReturnStatement* stmt);
      void (*visit_yield_statement) (ValaCodeVisitor* self, ValaYieldStatement* y);
      void (*visit_throw_statement) (ValaCodeVisitor* self, ValaThrowStatement* stmt);
      void (*visit_try_statement) (ValaCodeVisitor* self, ValaTryStatement* stmt);
      void (*visit_catch_clause) (ValaCodeVisitor* self, ValaCatchClause* clause);
      void (*visit_lock_statement) (ValaCodeVisitor* self, ValaLockStatement* stmt);
      void (*visit_unlock_statement) (ValaCodeVisitor* self, ValaUnlockStatement* stmt);
      void (*visit_delete_statement) (ValaCodeVisitor* self, ValaDeleteStatement* stmt);
      void (*visit_expression) (ValaCodeVisitor* self, ValaExpression* expr);
      void (*visit_array_creation_expression) (ValaCodeVisitor* self, ValaArrayCreationExpression* expr);
      void (*visit_boolean_literal) (ValaCodeVisitor* self, ValaBooleanLiteral* lit);
      void (*visit_character_literal) (ValaCodeVisitor* self, ValaCharacterLiteral* lit);
      void (*visit_integer_literal) (ValaCodeVisitor* self, ValaIntegerLiteral* lit);
      void (*visit_real_literal) (ValaCodeVisitor* self, ValaRealLiteral* lit);
      void (*visit_regex_literal) (ValaCodeVisitor* self, ValaRegexLiteral* lit);
      void (*visit_string_literal) (ValaCodeVisitor* self, ValaStringLiteral* lit);
      void (*visit_template) (ValaCodeVisitor* self, ValaTemplate* tmpl);
      void (*visit_list_literal) (ValaCodeVisitor* self, ValaListLiteral* lit);
      void (*visit_set_literal) (ValaCodeVisitor* self, ValaSetLiteral* lit);
      void (*visit_map_literal) (ValaCodeVisitor* self, ValaMapLiteral* lit);
      void (*visit_tuple) (ValaCodeVisitor* self, ValaTuple* tuple);
      void (*visit_null_literal) (ValaCodeVisitor* self, ValaNullLiteral* lit);
      void (*visit_member_access) (ValaCodeVisitor* self, ValaMemberAccess* expr);
      void (*visit_method_call) (ValaCodeVisitor* self, ValaMethodCall* expr);
      void (*visit_element_access) (ValaCodeVisitor* self, ValaElementAccess* expr);
      void (*visit_slice_expression) (ValaCodeVisitor* self, ValaSliceExpression* expr);
      void (*visit_base_access) (ValaCodeVisitor* self, ValaBaseAccess* expr);
      void (*visit_postfix_expression) (ValaCodeVisitor* self, ValaPostfixExpression* expr);
      void (*visit_object_creation_expression) (ValaCodeVisitor* self, ValaObjectCreationExpression* expr);
      void (*visit_sizeof_expression) (ValaCodeVisitor* self, ValaSizeofExpression* expr);
      void (*visit_typeof_expression) (ValaCodeVisitor* self, ValaTypeofExpression* expr);
      void (*visit_unary_expression) (ValaCodeVisitor* self, ValaUnaryExpression* expr);
      void (*visit_cast_expression) (ValaCodeVisitor* self, ValaCastExpression* expr);
      void (*visit_named_argument) (ValaCodeVisitor* self, ValaNamedArgument* expr);
      void (*visit_pointer_indirection) (ValaCodeVisitor* self, ValaPointerIndirection* expr);
      void (*visit_addressof_expression) (ValaCodeVisitor* self, ValaAddressofExpression* expr);
      void (*visit_reference_transfer_expression) (ValaCodeVisitor* self, ValaReferenceTransferExpression* expr);
      void (*visit_binary_expression) (ValaCodeVisitor* self, ValaBinaryExpression* expr);
      void (*visit_type_check) (ValaCodeVisitor* self, ValaTypeCheck* expr);
      void (*visit_conditional_expression) (ValaCodeVisitor* self, ValaConditionalExpression* expr);
      void (*visit_lambda_expression) (ValaCodeVisitor* self, ValaLambdaExpression* expr);
      void (*visit_assignment) (ValaCodeVisitor* self, ValaAssignment* a);
      void (*visit_end_full_expression) (ValaCodeVisitor* self, ValaExpression* expr);
};

struct _ValaParser {
      ValaCodeVisitor parent_instance;
      ValaParserPrivate * priv;
};

struct _ValaParserClass {
      ValaCodeVisitorClass parent_class;
};

typedef enum  {
      VALA_TOKEN_TYPE_NONE,
      VALA_TOKEN_TYPE_ABSTRACT,
      VALA_TOKEN_TYPE_AS,
      VALA_TOKEN_TYPE_ASSIGN,
      VALA_TOKEN_TYPE_ASSIGN_ADD,
      VALA_TOKEN_TYPE_ASSIGN_BITWISE_AND,
      VALA_TOKEN_TYPE_ASSIGN_BITWISE_OR,
      VALA_TOKEN_TYPE_ASSIGN_BITWISE_XOR,
      VALA_TOKEN_TYPE_ASSIGN_DIV,
      VALA_TOKEN_TYPE_ASSIGN_MUL,
      VALA_TOKEN_TYPE_ASSIGN_PERCENT,
      VALA_TOKEN_TYPE_ASSIGN_SHIFT_LEFT,
      VALA_TOKEN_TYPE_ASSIGN_SUB,
      VALA_TOKEN_TYPE_ASYNC,
      VALA_TOKEN_TYPE_BASE,
      VALA_TOKEN_TYPE_BITWISE_AND,
      VALA_TOKEN_TYPE_BITWISE_OR,
      VALA_TOKEN_TYPE_BREAK,
      VALA_TOKEN_TYPE_CARRET,
      VALA_TOKEN_TYPE_CASE,
      VALA_TOKEN_TYPE_CATCH,
      VALA_TOKEN_TYPE_CHARACTER_LITERAL,
      VALA_TOKEN_TYPE_CLASS,
      VALA_TOKEN_TYPE_CLOSE_BRACE,
      VALA_TOKEN_TYPE_CLOSE_BRACKET,
      VALA_TOKEN_TYPE_CLOSE_PARENS,
      VALA_TOKEN_TYPE_CLOSE_REGEX_LITERAL,
      VALA_TOKEN_TYPE_CLOSE_TEMPLATE,
      VALA_TOKEN_TYPE_COLON,
      VALA_TOKEN_TYPE_COMMA,
      VALA_TOKEN_TYPE_CONST,
      VALA_TOKEN_TYPE_CONSTRUCT,
      VALA_TOKEN_TYPE_CONTINUE,
      VALA_TOKEN_TYPE_DEFAULT,
      VALA_TOKEN_TYPE_DELEGATE,
      VALA_TOKEN_TYPE_DELETE,
      VALA_TOKEN_TYPE_DIV,
      VALA_TOKEN_TYPE_DO,
      VALA_TOKEN_TYPE_DOUBLE_COLON,
      VALA_TOKEN_TYPE_DOT,
      VALA_TOKEN_TYPE_DYNAMIC,
      VALA_TOKEN_TYPE_ELLIPSIS,
      VALA_TOKEN_TYPE_ELSE,
      VALA_TOKEN_TYPE_ENUM,
      VALA_TOKEN_TYPE_ENSURES,
      VALA_TOKEN_TYPE_ERRORDOMAIN,
      VALA_TOKEN_TYPE_EOF,
      VALA_TOKEN_TYPE_EXTERN,
      VALA_TOKEN_TYPE_FALSE,
      VALA_TOKEN_TYPE_FINALLY,
      VALA_TOKEN_TYPE_FOR,
      VALA_TOKEN_TYPE_FOREACH,
      VALA_TOKEN_TYPE_GET,
      VALA_TOKEN_TYPE_HASH,
      VALA_TOKEN_TYPE_IDENTIFIER,
      VALA_TOKEN_TYPE_IF,
      VALA_TOKEN_TYPE_IN,
      VALA_TOKEN_TYPE_INLINE,
      VALA_TOKEN_TYPE_INTEGER_LITERAL,
      VALA_TOKEN_TYPE_INTERFACE,
      VALA_TOKEN_TYPE_INTERNAL,
      VALA_TOKEN_TYPE_INTERR,
      VALA_TOKEN_TYPE_IS,
      VALA_TOKEN_TYPE_LAMBDA,
      VALA_TOKEN_TYPE_LOCK,
      VALA_TOKEN_TYPE_MINUS,
      VALA_TOKEN_TYPE_NAMESPACE,
      VALA_TOKEN_TYPE_NEW,
      VALA_TOKEN_TYPE_NULL,
      VALA_TOKEN_TYPE_OUT,
      VALA_TOKEN_TYPE_OP_AND,
      VALA_TOKEN_TYPE_OP_COALESCING,
      VALA_TOKEN_TYPE_OP_DEC,
      VALA_TOKEN_TYPE_OP_EQ,
      VALA_TOKEN_TYPE_OP_GE,
      VALA_TOKEN_TYPE_OP_GT,
      VALA_TOKEN_TYPE_OP_INC,
      VALA_TOKEN_TYPE_OP_LE,
      VALA_TOKEN_TYPE_OP_LT,
      VALA_TOKEN_TYPE_OP_NE,
      VALA_TOKEN_TYPE_OP_NEG,
      VALA_TOKEN_TYPE_OP_OR,
      VALA_TOKEN_TYPE_OP_PTR,
      VALA_TOKEN_TYPE_OP_SHIFT_LEFT,
      VALA_TOKEN_TYPE_OPEN_BRACE,
      VALA_TOKEN_TYPE_OPEN_BRACKET,
      VALA_TOKEN_TYPE_OPEN_PARENS,
      VALA_TOKEN_TYPE_OPEN_REGEX_LITERAL,
      VALA_TOKEN_TYPE_OPEN_TEMPLATE,
      VALA_TOKEN_TYPE_OVERRIDE,
      VALA_TOKEN_TYPE_OWNED,
      VALA_TOKEN_TYPE_PARAMS,
      VALA_TOKEN_TYPE_PERCENT,
      VALA_TOKEN_TYPE_PLUS,
      VALA_TOKEN_TYPE_PRIVATE,
      VALA_TOKEN_TYPE_PROTECTED,
      VALA_TOKEN_TYPE_PUBLIC,
      VALA_TOKEN_TYPE_REAL_LITERAL,
      VALA_TOKEN_TYPE_REF,
      VALA_TOKEN_TYPE_REGEX_LITERAL,
      VALA_TOKEN_TYPE_REQUIRES,
      VALA_TOKEN_TYPE_RETURN,
      VALA_TOKEN_TYPE_SEALED,
      VALA_TOKEN_TYPE_SEMICOLON,
      VALA_TOKEN_TYPE_SET,
      VALA_TOKEN_TYPE_SIGNAL,
      VALA_TOKEN_TYPE_SIZEOF,
      VALA_TOKEN_TYPE_STAR,
      VALA_TOKEN_TYPE_STATIC,
      VALA_TOKEN_TYPE_STRING_LITERAL,
      VALA_TOKEN_TYPE_STRUCT,
      VALA_TOKEN_TYPE_SWITCH,
      VALA_TOKEN_TYPE_TEMPLATE_STRING_LITERAL,
      VALA_TOKEN_TYPE_THIS,
      VALA_TOKEN_TYPE_THROW,
      VALA_TOKEN_TYPE_THROWS,
      VALA_TOKEN_TYPE_TILDE,
      VALA_TOKEN_TYPE_TRUE,
      VALA_TOKEN_TYPE_TRY,
      VALA_TOKEN_TYPE_TYPEOF,
      VALA_TOKEN_TYPE_UNOWNED,
      VALA_TOKEN_TYPE_USING,
      VALA_TOKEN_TYPE_VAR,
      VALA_TOKEN_TYPE_VERBATIM_STRING_LITERAL,
      VALA_TOKEN_TYPE_VIRTUAL,
      VALA_TOKEN_TYPE_VOID,
      VALA_TOKEN_TYPE_VOLATILE,
      VALA_TOKEN_TYPE_WEAK,
      VALA_TOKEN_TYPE_WHILE,
      VALA_TOKEN_TYPE_YIELD
} ValaTokenType;

struct _ValaSourceLocation {
      gchar* pos;
      gint line;
      gint column;
};

01374 struct _ValaParserTokenInfo {
      ValaTokenType type;
      ValaSourceLocation begin;
      ValaSourceLocation end;
};

01380 struct _ValaParserPrivate {
      ValaScanner* scanner;
      ValaCodeContext* context;
      ValaParserTokenInfo* tokens;
      gint tokens_length1;
      gint _tokens_size_;
      gint index;
      gint size;
      ValaComment* comment;
};

typedef enum  {
      VALA_PARSER_MODIFIER_FLAGS_NONE,
      VALA_PARSER_MODIFIER_FLAGS_ABSTRACT = 1 << 0,
      VALA_PARSER_MODIFIER_FLAGS_CLASS = 1 << 1,
      VALA_PARSER_MODIFIER_FLAGS_EXTERN = 1 << 2,
      VALA_PARSER_MODIFIER_FLAGS_INLINE = 1 << 3,
      VALA_PARSER_MODIFIER_FLAGS_NEW = 1 << 4,
      VALA_PARSER_MODIFIER_FLAGS_OVERRIDE = 1 << 5,
      VALA_PARSER_MODIFIER_FLAGS_STATIC = 1 << 6,
      VALA_PARSER_MODIFIER_FLAGS_VIRTUAL = 1 << 7,
      VALA_PARSER_MODIFIER_FLAGS_ASYNC = 1 << 8,
      VALA_PARSER_MODIFIER_FLAGS_SEALED = 1 << 9
} ValaParserModifierFlags;

typedef enum  {
      VALA_PARSER_RECOVERY_STATE_EOF,
      VALA_PARSER_RECOVERY_STATE_DECLARATION_BEGIN,
      VALA_PARSER_RECOVERY_STATE_STATEMENT_BEGIN
} ValaParserRecoveryState;

typedef enum  {
      VALA_PARSE_ERROR_FAILED,
      VALA_PARSE_ERROR_SYNTAX
} ValaParseError;
#define VALA_PARSE_ERROR vala_parse_error_quark ()
typedef enum  {
      VALA_PROFILE_POSIX,
      VALA_PROFILE_GOBJECT,
      VALA_PROFILE_DOVA
} ValaProfile;

typedef enum  {
      VALA_UNARY_OPERATOR_NONE,
      VALA_UNARY_OPERATOR_PLUS,
      VALA_UNARY_OPERATOR_MINUS,
      VALA_UNARY_OPERATOR_LOGICAL_NEGATION,
      VALA_UNARY_OPERATOR_BITWISE_COMPLEMENT,
      VALA_UNARY_OPERATOR_INCREMENT,
      VALA_UNARY_OPERATOR_DECREMENT,
      VALA_UNARY_OPERATOR_REF,
      VALA_UNARY_OPERATOR_OUT
} ValaUnaryOperator;

typedef enum  {
      VALA_BINARY_OPERATOR_NONE,
      VALA_BINARY_OPERATOR_PLUS,
      VALA_BINARY_OPERATOR_MINUS,
      VALA_BINARY_OPERATOR_MUL,
      VALA_BINARY_OPERATOR_DIV,
      VALA_BINARY_OPERATOR_MOD,
      VALA_BINARY_OPERATOR_SHIFT_LEFT,
      VALA_BINARY_OPERATOR_SHIFT_RIGHT,
      VALA_BINARY_OPERATOR_LESS_THAN,
      VALA_BINARY_OPERATOR_GREATER_THAN,
      VALA_BINARY_OPERATOR_LESS_THAN_OR_EQUAL,
      VALA_BINARY_OPERATOR_GREATER_THAN_OR_EQUAL,
      VALA_BINARY_OPERATOR_EQUALITY,
      VALA_BINARY_OPERATOR_INEQUALITY,
      VALA_BINARY_OPERATOR_BITWISE_AND,
      VALA_BINARY_OPERATOR_BITWISE_OR,
      VALA_BINARY_OPERATOR_BITWISE_XOR,
      VALA_BINARY_OPERATOR_AND,
      VALA_BINARY_OPERATOR_OR,
      VALA_BINARY_OPERATOR_IN,
      VALA_BINARY_OPERATOR_COALESCE
} ValaBinaryOperator;

struct _ValaCodeNode {
      GTypeInstance parent_instance;
      volatile int ref_count;
      ValaCodeNodePrivate * priv;
      GList* attributes;
};

struct _ValaCodeNodeClass {
      GTypeClass parent_class;
      void (*finalize) (ValaCodeNode *self);
      void (*accept) (ValaCodeNode* self, ValaCodeVisitor* visitor);
      void (*accept_children) (ValaCodeNode* self, ValaCodeVisitor* visitor);
      gboolean (*check) (ValaCodeNode* self, ValaCodeContext* context);
      void (*emit) (ValaCodeNode* self, ValaCodeGenerator* codegen);
      void (*replace_type) (ValaCodeNode* self, ValaDataType* old_type, ValaDataType* new_type);
      void (*replace_expression) (ValaCodeNode* self, ValaExpression* old_node, ValaExpression* new_node);
      gchar* (*to_string) (ValaCodeNode* self);
      void (*get_defined_variables) (ValaCodeNode* self, ValaCollection* collection);
      void (*get_used_variables) (ValaCodeNode* self, ValaCollection* collection);
};

struct _ValaExpression {
      ValaCodeNode parent_instance;
      ValaExpressionPrivate * priv;
};

struct _ValaExpressionClass {
      ValaCodeNodeClass parent_class;
      gboolean (*is_constant) (ValaExpression* self);
      gboolean (*is_pure) (ValaExpression* self);
      gboolean (*is_non_null) (ValaExpression* self);
};

struct _ValaBinaryExpression {
      ValaExpression parent_instance;
      ValaBinaryExpressionPrivate * priv;
      gboolean chained;
};

struct _ValaBinaryExpressionClass {
      ValaExpressionClass parent_class;
};

typedef enum  {
      VALA_PARAMETER_DIRECTION_IN,
      VALA_PARAMETER_DIRECTION_OUT,
      VALA_PARAMETER_DIRECTION_REF
} ValaParameterDirection;

typedef enum  {
      VALA_ASSIGNMENT_OPERATOR_NONE,
      VALA_ASSIGNMENT_OPERATOR_SIMPLE,
      VALA_ASSIGNMENT_OPERATOR_BITWISE_OR,
      VALA_ASSIGNMENT_OPERATOR_BITWISE_AND,
      VALA_ASSIGNMENT_OPERATOR_BITWISE_XOR,
      VALA_ASSIGNMENT_OPERATOR_ADD,
      VALA_ASSIGNMENT_OPERATOR_SUB,
      VALA_ASSIGNMENT_OPERATOR_MUL,
      VALA_ASSIGNMENT_OPERATOR_DIV,
      VALA_ASSIGNMENT_OPERATOR_PERCENT,
      VALA_ASSIGNMENT_OPERATOR_SHIFT_LEFT,
      VALA_ASSIGNMENT_OPERATOR_SHIFT_RIGHT
} ValaAssignmentOperator;

struct _ValaStatementIface {
      GTypeInterface parent_iface;
};

typedef enum  {
      VALA_SYMBOL_ACCESSIBILITY_PRIVATE,
      VALA_SYMBOL_ACCESSIBILITY_INTERNAL,
      VALA_SYMBOL_ACCESSIBILITY_PROTECTED,
      VALA_SYMBOL_ACCESSIBILITY_PUBLIC
} ValaSymbolAccessibility;

typedef enum  {
      VALA_SOURCE_FILE_TYPE_NONE,
      VALA_SOURCE_FILE_TYPE_SOURCE,
      VALA_SOURCE_FILE_TYPE_PACKAGE,
      VALA_SOURCE_FILE_TYPE_FAST
} ValaSourceFileType;

typedef enum  {
      VALA_MEMBER_BINDING_INSTANCE,
      VALA_MEMBER_BINDING_CLASS,
      VALA_MEMBER_BINDING_STATIC
} ValaMemberBinding;


static gpointer vala_parser_parent_class = NULL;
static ValaList* vala_parser__empty_type_parameter_list;
static ValaList* vala_parser__empty_type_parameter_list = NULL;

gpointer vala_code_visitor_ref (gpointer instance);
void vala_code_visitor_unref (gpointer instance);
GParamSpec* vala_param_spec_code_visitor (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
void vala_value_set_code_visitor (GValue* value, gpointer v_object);
void vala_value_take_code_visitor (GValue* value, gpointer v_object);
gpointer vala_value_get_code_visitor (const GValue* value);
GType vala_code_visitor_get_type (void) G_GNUC_CONST;
gpointer vala_source_file_ref (gpointer instance);
void vala_source_file_unref (gpointer instance);
GParamSpec* vala_param_spec_source_file (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
void vala_value_set_source_file (GValue* value, gpointer v_object);
void vala_value_take_source_file (GValue* value, gpointer v_object);
gpointer vala_value_get_source_file (const GValue* value);
GType vala_source_file_get_type (void) G_GNUC_CONST;
gpointer vala_code_node_ref (gpointer instance);
void vala_code_node_unref (gpointer instance);
GParamSpec* vala_param_spec_code_node (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
void vala_value_set_code_node (GValue* value, gpointer v_object);
void vala_value_take_code_node (GValue* value, gpointer v_object);
gpointer vala_value_get_code_node (const GValue* value);
GType vala_code_node_get_type (void) G_GNUC_CONST;
GType vala_symbol_get_type (void) G_GNUC_CONST;
GType vala_namespace_get_type (void) G_GNUC_CONST;
GType vala_typesymbol_get_type (void) G_GNUC_CONST;
GType vala_object_type_symbol_get_type (void) G_GNUC_CONST;
GType vala_class_get_type (void) G_GNUC_CONST;
GType vala_struct_get_type (void) G_GNUC_CONST;
GType vala_interface_get_type (void) G_GNUC_CONST;
GType vala_enum_get_type (void) G_GNUC_CONST;
GType vala_constant_get_type (void) G_GNUC_CONST;
GType vala_enum_value_get_type (void) G_GNUC_CONST;
GType vala_error_domain_get_type (void) G_GNUC_CONST;
GType vala_error_code_get_type (void) G_GNUC_CONST;
GType vala_delegate_get_type (void) G_GNUC_CONST;
GType vala_variable_get_type (void) G_GNUC_CONST;
GType vala_field_get_type (void) G_GNUC_CONST;
GType vala_subroutine_get_type (void) G_GNUC_CONST;
GType vala_method_get_type (void) G_GNUC_CONST;
GType vala_creation_method_get_type (void) G_GNUC_CONST;
GType vala_parameter_get_type (void) G_GNUC_CONST;
GType vala_property_get_type (void) G_GNUC_CONST;
GType vala_property_accessor_get_type (void) G_GNUC_CONST;
GType vala_signal_get_type (void) G_GNUC_CONST;
GType vala_constructor_get_type (void) G_GNUC_CONST;
GType vala_destructor_get_type (void) G_GNUC_CONST;
GType vala_typeparameter_get_type (void) G_GNUC_CONST;
GType vala_using_directive_get_type (void) G_GNUC_CONST;
GType vala_data_type_get_type (void) G_GNUC_CONST;
GType vala_block_get_type (void) G_GNUC_CONST;
GType vala_empty_statement_get_type (void) G_GNUC_CONST;
GType vala_declaration_statement_get_type (void) G_GNUC_CONST;
GType vala_local_variable_get_type (void) G_GNUC_CONST;
GType vala_expression_get_type (void) G_GNUC_CONST;
GType vala_initializer_list_get_type (void) G_GNUC_CONST;
GType vala_expression_statement_get_type (void) G_GNUC_CONST;
GType vala_if_statement_get_type (void) G_GNUC_CONST;
GType vala_switch_statement_get_type (void) G_GNUC_CONST;
GType vala_switch_section_get_type (void) G_GNUC_CONST;
GType vala_switch_label_get_type (void) G_GNUC_CONST;
GType vala_loop_get_type (void) G_GNUC_CONST;
GType vala_while_statement_get_type (void) G_GNUC_CONST;
GType vala_do_statement_get_type (void) G_GNUC_CONST;
GType vala_for_statement_get_type (void) G_GNUC_CONST;
GType vala_foreach_statement_get_type (void) G_GNUC_CONST;
GType vala_break_statement_get_type (void) G_GNUC_CONST;
GType vala_continue_statement_get_type (void) G_GNUC_CONST;
GType vala_return_statement_get_type (void) G_GNUC_CONST;
GType vala_yield_statement_get_type (void) G_GNUC_CONST;
GType vala_throw_statement_get_type (void) G_GNUC_CONST;
GType vala_try_statement_get_type (void) G_GNUC_CONST;
GType vala_catch_clause_get_type (void) G_GNUC_CONST;
GType vala_lock_statement_get_type (void) G_GNUC_CONST;
GType vala_unlock_statement_get_type (void) G_GNUC_CONST;
GType vala_delete_statement_get_type (void) G_GNUC_CONST;
GType vala_array_creation_expression_get_type (void) G_GNUC_CONST;
GType vala_literal_get_type (void) G_GNUC_CONST;
GType vala_boolean_literal_get_type (void) G_GNUC_CONST;
GType vala_character_literal_get_type (void) G_GNUC_CONST;
GType vala_integer_literal_get_type (void) G_GNUC_CONST;
GType vala_real_literal_get_type (void) G_GNUC_CONST;
GType vala_regex_literal_get_type (void) G_GNUC_CONST;
GType vala_string_literal_get_type (void) G_GNUC_CONST;
GType vala_template_get_type (void) G_GNUC_CONST;
GType vala_list_literal_get_type (void) G_GNUC_CONST;
GType vala_set_literal_get_type (void) G_GNUC_CONST;
GType vala_map_literal_get_type (void) G_GNUC_CONST;
GType vala_tuple_get_type (void) G_GNUC_CONST;
GType vala_null_literal_get_type (void) G_GNUC_CONST;
GType vala_member_access_get_type (void) G_GNUC_CONST;
GType vala_method_call_get_type (void) G_GNUC_CONST;
GType vala_element_access_get_type (void) G_GNUC_CONST;
GType vala_slice_expression_get_type (void) G_GNUC_CONST;
GType vala_base_access_get_type (void) G_GNUC_CONST;
GType vala_postfix_expression_get_type (void) G_GNUC_CONST;
GType vala_object_creation_expression_get_type (void) G_GNUC_CONST;
GType vala_sizeof_expression_get_type (void) G_GNUC_CONST;
GType vala_typeof_expression_get_type (void) G_GNUC_CONST;
GType vala_unary_expression_get_type (void) G_GNUC_CONST;
GType vala_cast_expression_get_type (void) G_GNUC_CONST;
GType vala_named_argument_get_type (void) G_GNUC_CONST;
GType vala_pointer_indirection_get_type (void) G_GNUC_CONST;
GType vala_addressof_expression_get_type (void) G_GNUC_CONST;
GType vala_reference_transfer_expression_get_type (void) G_GNUC_CONST;
GType vala_binary_expression_get_type (void) G_GNUC_CONST;
GType vala_typecheck_get_type (void) G_GNUC_CONST;
GType vala_conditional_expression_get_type (void) G_GNUC_CONST;
GType vala_lambda_expression_get_type (void) G_GNUC_CONST;
GType vala_assignment_get_type (void) G_GNUC_CONST;
GType vala_parser_get_type (void) G_GNUC_CONST;
gpointer vala_scanner_ref (gpointer instance);
void vala_scanner_unref (gpointer instance);
GParamSpec* vala_param_spec_scanner (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
void vala_value_set_scanner (GValue* value, gpointer v_object);
void vala_value_take_scanner (GValue* value, gpointer v_object);
gpointer vala_value_get_scanner (const GValue* value);
GType vala_scanner_get_type (void) G_GNUC_CONST;
gpointer vala_code_context_ref (gpointer instance);
void vala_code_context_unref (gpointer instance);
GParamSpec* vala_param_spec_code_context (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
void vala_value_set_code_context (GValue* value, gpointer v_object);
void vala_value_take_code_context (GValue* value, gpointer v_object);
gpointer vala_value_get_code_context (const GValue* value);
GType vala_code_context_get_type (void) G_GNUC_CONST;
static GType vala_parser_token_info_get_type (void) G_GNUC_CONST G_GNUC_UNUSED;
GType vala_token_type_get_type (void) G_GNUC_CONST;
GType vala_source_location_get_type (void) G_GNUC_CONST;
ValaSourceLocation* vala_source_location_dup (const ValaSourceLocation* self);
void vala_source_location_free (ValaSourceLocation* self);
static ValaParserTokenInfo* vala_parser_token_info_dup (const ValaParserTokenInfo* self);
static void vala_parser_token_info_free (ValaParserTokenInfo* self);
gpointer vala_comment_ref (gpointer instance);
void vala_comment_unref (gpointer instance);
GParamSpec* vala_param_spec_comment (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
void vala_value_set_comment (GValue* value, gpointer v_object);
void vala_value_take_comment (GValue* value, gpointer v_object);
gpointer vala_value_get_comment (const GValue* value);
GType vala_comment_get_type (void) G_GNUC_CONST;
#define VALA_PARSER_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), VALA_TYPE_PARSER, ValaParserPrivate))
enum  {
      VALA_PARSER_DUMMY_PROPERTY
};
static GType vala_parser_modifier_flags_get_type (void) G_GNUC_UNUSED;
static GType vala_parser_recovery_state_get_type (void) G_GNUC_UNUSED;
#define VALA_PARSER_BUFFER_SIZE 32
ValaParser* vala_parser_new (void);
ValaParser* vala_parser_construct (GType object_type);
ValaCodeVisitor* vala_code_visitor_construct (GType object_type);
void vala_parser_parse (ValaParser* self, ValaCodeContext* context);
void vala_code_context_accept (ValaCodeContext* self, ValaCodeVisitor* visitor);
static void vala_parser_real_visit_source_file (ValaCodeVisitor* base, ValaSourceFile* source_file);
gboolean vala_code_context_get_run_output (ValaCodeContext* self);
const gchar* vala_source_file_get_filename (ValaSourceFile* self);
void vala_parser_parse_file (ValaParser* self, ValaSourceFile* source_file);
static inline gboolean vala_parser_next (ValaParser* self);
ValaTokenType vala_scanner_read_token (ValaScanner* self, ValaSourceLocation* token_begin, ValaSourceLocation* token_end);
static inline void vala_parser_prev (ValaParser* self);
static inline ValaTokenType vala_parser_current (ValaParser* self);
static inline gboolean vala_parser_accept (ValaParser* self, ValaTokenType type);
static gchar* vala_parser_get_error (ValaParser* self, const gchar* msg);
static inline void vala_parser_get_location (ValaParser* self, ValaSourceLocation* result);
gpointer vala_source_reference_ref (gpointer instance);
void vala_source_reference_unref (gpointer instance);
GParamSpec* vala_param_spec_source_reference (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
void vala_value_set_source_reference (GValue* value, gpointer v_object);
void vala_value_take_source_reference (GValue* value, gpointer v_object);
gpointer vala_value_get_source_reference (const GValue* value);
GType vala_source_reference_get_type (void) G_GNUC_CONST;
void vala_report_error (ValaSourceReference* source, const gchar* message);
static ValaSourceReference* vala_parser_get_src (ValaParser* self, ValaSourceLocation* begin);
GQuark vala_parse_error_quark (void);
static inline gboolean vala_parser_expect (ValaParser* self, ValaTokenType type, GError** error);
const gchar* vala_token_type_to_string (ValaTokenType self);
static gchar* vala_parser_get_current_string (ValaParser* self);
static gchar* vala_parser_get_last_string (ValaParser* self);
ValaSourceFile* vala_scanner_get_source_file (ValaScanner* self);
ValaSourceReference* vala_source_reference_new (ValaSourceFile* _file, gint _first_line, gint _first_column, gint _last_line, gint _last_column);
ValaSourceReference* vala_source_reference_construct (GType object_type, ValaSourceFile* _file, gint _first_line, gint _first_column, gint _last_line, gint _last_column);
static ValaSourceReference* vala_parser_get_current_src (ValaParser* self);
static ValaSourceReference* vala_parser_get_last_src (ValaParser* self);
static void vala_parser_rollback (ValaParser* self, ValaSourceLocation* location);
void vala_scanner_seek (ValaScanner* self, ValaSourceLocation* location);
static void vala_parser_skip_identifier (ValaParser* self, GError** error);
static gchar* vala_parser_parse_identifier (ValaParser* self, GError** error);
static ValaExpression* vala_parser_parse_literal (ValaParser* self, GError** error);
ValaBooleanLiteral* vala_boolean_literal_new (gboolean b, ValaSourceReference* source);
ValaBooleanLiteral* vala_boolean_literal_construct (GType object_type, gboolean b, ValaSourceReference* source);
ValaIntegerLiteral* vala_integer_literal_new (const gchar* i, ValaSourceReference* source);
ValaIntegerLiteral* vala_integer_literal_construct (GType object_type, const gchar* i, ValaSourceReference* source);
ValaRealLiteral* vala_real_literal_new (const gchar* r, ValaSourceReference* source);
ValaRealLiteral* vala_real_literal_construct (GType object_type, const gchar* r, ValaSourceReference* source);
ValaCharacterLiteral* vala_character_literal_new (const gchar* c, ValaSourceReference* source);
ValaCharacterLiteral* vala_character_literal_construct (GType object_type, const gchar* c, ValaSourceReference* source);
gboolean vala_code_node_get_error (ValaCodeNode* self);
ValaSourceReference* vala_code_node_get_source_reference (ValaCodeNode* self);
ValaRegexLiteral* vala_regex_literal_new (const gchar* value, ValaSourceReference* source_reference);
ValaRegexLiteral* vala_regex_literal_construct (GType object_type, const gchar* value, ValaSourceReference* source_reference);
ValaStringLiteral* vala_string_literal_new (const gchar* value, ValaSourceReference* source_reference);
ValaStringLiteral* vala_string_literal_construct (GType object_type, const gchar* value, ValaSourceReference* source_reference);
ValaNullLiteral* vala_null_literal_new (ValaSourceReference* source);
ValaNullLiteral* vala_null_literal_construct (GType object_type, ValaSourceReference* source);
ValaScanner* vala_scanner_new (ValaSourceFile* source_file);
ValaScanner* vala_scanner_construct (GType object_type, ValaSourceFile* source_file);
static void vala_parser_parse_file_comments (ValaParser* self);
static void vala_parser_parse_using_directives (ValaParser* self, ValaNamespace* ns, GError** error);
ValaNamespace* vala_code_context_get_root (ValaCodeContext* self);
static void vala_parser_parse_declarations (ValaParser* self, ValaSymbol* parent, gboolean root, GError** error);
GType vala_report_get_type (void) G_GNUC_CONST;
ValaReport* vala_code_context_get_report (ValaCodeContext* self);
gint vala_report_get_errors (ValaReport* self);
void vala_scanner_parse_file_comments (ValaScanner* self);
static void vala_parser_skip_symbol_name (ValaParser* self, GError** error);
GType vala_unresolved_symbol_get_type (void) G_GNUC_CONST;
static ValaUnresolvedSymbol* vala_parser_parse_symbol_name (ValaParser* self, GError** error);
ValaUnresolvedSymbol* vala_unresolved_symbol_new (ValaUnresolvedSymbol* inner, const gchar* name, ValaSourceReference* source_reference);
ValaUnresolvedSymbol* vala_unresolved_symbol_construct (GType object_type, ValaUnresolvedSymbol* inner, const gchar* name, ValaSourceReference* source_reference);
void vala_unresolved_symbol_set_qualified (ValaUnresolvedSymbol* self, gboolean value);
static void vala_parser_skip_type (ValaParser* self, GError** error);
static void vala_parser_skip_type_argument_list (ValaParser* self, GError** error);
static ValaExpression* vala_parser_parse_expression (ValaParser* self, GError** error);
static ValaDataType* vala_parser_parse_type (ValaParser* self, gboolean owned_by_default, gboolean can_weak_ref, GError** error);
GType vala_profile_get_type (void) G_GNUC_CONST;
ValaProfile vala_code_context_get_profile (ValaCodeContext* self);
gboolean vala_code_context_get_deprecated (ValaCodeContext* self);
void vala_report_warning (ValaSourceReference* source, const gchar* message);
ValaVoidType* vala_void_type_new (ValaSourceReference* source_reference);
ValaVoidType* vala_void_type_construct (GType object_type, ValaSourceReference* source_reference);
GType vala_void_type_get_type (void) G_GNUC_CONST;
static ValaList* vala_parser_parse_type_argument_list (ValaParser* self, gboolean maybe_expression, GError** error);
ValaUnresolvedType* vala_unresolved_type_new_from_symbol (ValaUnresolvedSymbol* symbol, ValaSourceReference* source);
ValaUnresolvedType* vala_unresolved_type_construct_from_symbol (GType object_type, ValaUnresolvedSymbol* symbol, ValaSourceReference* source);
GType vala_unresolved_type_get_type (void) G_GNUC_CONST;
void vala_data_type_add_type_argument (ValaDataType* self, ValaDataType* arg);
ValaPointerType* vala_pointer_type_new (ValaDataType* base_type, ValaSourceReference* source_reference);
ValaPointerType* vala_pointer_type_construct (GType object_type, ValaDataType* base_type, ValaSourceReference* source_reference);
GType vala_pointer_type_get_type (void) G_GNUC_CONST;
void vala_data_type_set_nullable (ValaDataType* self, gboolean value);
void vala_data_type_set_value_owned (ValaDataType* self, gboolean value);
ValaArrayType* vala_array_type_new (ValaDataType* element_type, gint rank, ValaSourceReference* source_reference);
ValaArrayType* vala_array_type_construct (GType object_type, ValaDataType* element_type, gint rank, ValaSourceReference* source_reference);
GType vala_reference_type_get_type (void) G_GNUC_CONST;
GType vala_array_type_get_type (void) G_GNUC_CONST;
void vala_array_type_set_invalid_syntax (ValaArrayType* self, gboolean value);
void vala_data_type_set_is_dynamic (ValaDataType* self, gboolean value);
static ValaDataType* vala_parser_parse_inline_array_type (ValaParser* self, ValaDataType* type, GError** error);
const gchar* vala_integer_literal_get_value (ValaIntegerLiteral* self);
void vala_array_type_set_inline_allocated (ValaArrayType* self, gboolean value);
void vala_array_type_set_fixed_length (ValaArrayType* self, gboolean value);
void vala_array_type_set_length (ValaArrayType* self, gint value);
gboolean vala_data_type_get_value_owned (ValaDataType* self);
static ValaList* vala_parser_parse_argument_list (ValaParser* self, GError** error);
static ValaExpression* vala_parser_parse_argument (ValaParser* self, GError** error);
GType vala_unary_operator_get_type (void) G_GNUC_CONST;
ValaUnaryExpression* vala_unary_expression_new (ValaUnaryOperator op, ValaExpression* _inner, ValaSourceReference* source);
ValaUnaryExpression* vala_unary_expression_construct (GType object_type, ValaUnaryOperator op, ValaExpression* _inner, ValaSourceReference* source);
ValaExpression* vala_member_access_get_inner (ValaMemberAccess* self);
const gchar* vala_member_access_get_member_name (ValaMemberAccess* self);
ValaNamedArgument* vala_named_argument_new (const gchar* name, ValaExpression* inner, ValaSourceReference* source_reference);
ValaNamedArgument* vala_named_argument_construct (GType object_type, const gchar* name, ValaExpression* inner, ValaSourceReference* source_reference);
static ValaExpression* vala_parser_parse_primary_expression (ValaParser* self, GError** error);
static ValaExpression* vala_parser_parse_set_literal (ValaParser* self, GError** error);
static ValaInitializerList* vala_parser_parse_initializer (ValaParser* self, GError** error);
static ValaListLiteral* vala_parser_parse_list_literal (ValaParser* self, GError** error);
static ValaExpression* vala_parser_parse_simple_name (ValaParser* self, GError** error);
static ValaExpression* vala_parser_parse_tuple (ValaParser* self, GError** error);
static ValaExpression* vala_parser_parse_template (ValaParser* self, GError** error);
static ValaExpression* vala_parser_parse_regex_literal (ValaParser* self, GError** error);
static ValaExpression* vala_parser_parse_this_access (ValaParser* self, GError** error);
static ValaExpression* vala_parser_parse_base_access (ValaParser* self, GError** error);
static ValaExpression* vala_parser_parse_object_or_array_creation_expression (ValaParser* self, GError** error);
static ValaExpression* vala_parser_parse_yield_expression (ValaParser* self, GError** error);
static ValaExpression* vala_parser_parse_sizeof_expression (ValaParser* self, GError** error);
static ValaExpression* vala_parser_parse_typeof_expression (ValaParser* self, GError** error);
static ValaExpression* vala_parser_parse_member_access (ValaParser* self, ValaSourceLocation* begin, ValaExpression* inner, GError** error);
static ValaExpression* vala_parser_parse_pointer_member_access (ValaParser* self, ValaSourceLocation* begin, ValaExpression* inner, GError** error);
static ValaExpression* vala_parser_parse_method_call (ValaParser* self, ValaSourceLocation* begin, ValaExpression* inner, GError** error);
static ValaExpression* vala_parser_parse_element_access (ValaParser* self, ValaSourceLocation* begin, ValaExpression* inner, GError** error);
static ValaExpression* vala_parser_parse_object_literal (ValaParser* self, ValaSourceLocation* begin, ValaMemberAccess* member, GError** error);
static ValaExpression* vala_parser_parse_post_increment_expression (ValaParser* self, ValaSourceLocation* begin, ValaExpression* inner, GError** error);
static ValaExpression* vala_parser_parse_post_decrement_expression (ValaParser* self, ValaSourceLocation* begin, ValaExpression* inner, GError** error);
ValaMemberAccess* vala_member_access_new (ValaExpression* inner, const gchar* member_name, ValaSourceReference* source_reference);
ValaMemberAccess* vala_member_access_construct (GType object_type, ValaExpression* inner, const gchar* member_name, ValaSourceReference* source_reference);
void vala_member_access_set_qualified (ValaMemberAccess* self, gboolean value);
void vala_member_access_add_type_argument (ValaMemberAccess* self, ValaDataType* arg);
ValaTuple* vala_tuple_new (ValaSourceReference* source_reference);
ValaTuple* vala_tuple_construct (GType object_type, ValaSourceReference* source_reference);
void vala_tuple_add_expression (ValaTuple* self, ValaExpression* expr);
ValaTemplate* vala_template_new (ValaSourceReference* source_reference);
ValaTemplate* vala_template_construct (GType object_type, ValaSourceReference* source_reference);
void vala_template_add_expression (ValaTemplate* self, ValaExpression* expr);
void vala_code_node_set_source_reference (ValaCodeNode* self, ValaSourceReference* value);
ValaMemberAccess* vala_member_access_new_pointer (ValaExpression* inner, const gchar* member_name, ValaSourceReference* source_reference);
ValaMemberAccess* vala_member_access_construct_pointer (GType object_type, ValaExpression* inner, const gchar* member_name, ValaSourceReference* source_reference);
GType vala_member_initializer_get_type (void) G_GNUC_CONST;
static ValaList* vala_parser_parse_object_initializer (ValaParser* self, GError** error);
void vala_member_access_set_creation_member (ValaMemberAccess* self, gboolean value);
ValaObjectCreationExpression* vala_object_creation_expression_new (ValaMemberAccess* member_name, ValaSourceReference* source_reference);
ValaObjectCreationExpression* vala_object_creation_expression_construct (GType object_type, ValaMemberAccess* member_name, ValaSourceReference* source_reference);
void vala_object_creation_expression_set_struct_creation (ValaObjectCreationExpression* self, gboolean value);
void vala_object_creation_expression_add_argument (ValaObjectCreationExpression* self, ValaExpression* arg);
void vala_object_creation_expression_add_member_initializer (ValaObjectCreationExpression* self, ValaMemberInitializer* init);
ValaMethodCall* vala_method_call_new (ValaExpression* call, ValaSourceReference* source_reference);
ValaMethodCall* vala_method_call_construct (GType object_type, ValaExpression* call, ValaSourceReference* source_reference);
void vala_method_call_add_argument (ValaMethodCall* self, ValaExpression* arg);
static ValaList* vala_parser_parse_expression_list (ValaParser* self, GError** error);
ValaElementAccess* vala_element_access_new (ValaExpression* container, ValaSourceReference* source_reference);
ValaElementAccess* vala_element_access_construct (GType object_type, ValaExpression* container, ValaSourceReference* source_reference);
void vala_element_access_append_index (ValaElementAccess* self, ValaExpression* index);
ValaSliceExpression* vala_slice_expression_new (ValaExpression* container, ValaExpression* start, ValaExpression* stop, ValaSourceReference* source_reference);
ValaSliceExpression* vala_slice_expression_construct (GType object_type, ValaExpression* container, ValaExpression* start, ValaExpression* stop, ValaSourceReference* source_reference);
ValaBaseAccess* vala_base_access_new (ValaSourceReference* source);
ValaBaseAccess* vala_base_access_construct (GType object_type, ValaSourceReference* source);
ValaPostfixExpression* vala_postfix_expression_new (ValaExpression* _inner, gboolean inc, ValaSourceReference* source);
ValaPostfixExpression* vala_postfix_expression_construct (GType object_type, ValaExpression* _inner, gboolean inc, ValaSourceReference* source);
static ValaMemberAccess* vala_parser_parse_member_name (ValaParser* self, ValaExpression* base_expr, GError** error);
static ValaExpression* vala_parser_parse_object_creation_expression (ValaParser* self, ValaSourceLocation* begin, ValaMemberAccess* member, GError** error);
static ValaExpression* vala_parser_parse_array_creation_expression (ValaParser* self, ValaSourceLocation* begin, ValaMemberAccess* member, GError** error);
ValaMemberInitializer* vala_member_initializer_new (const gchar* name, ValaExpression* initializer, ValaSourceReference* source_reference);
ValaMemberInitializer* vala_member_initializer_construct (GType object_type, const gchar* name, ValaExpression* initializer, ValaSourceReference* source_reference);
ValaUnresolvedType* vala_unresolved_type_new_from_expression (ValaExpression* expr);
ValaArrayCreationExpression* vala_array_creation_expression_new (ValaDataType* element_type, gint rank, ValaInitializerList* initializer_list, ValaSourceReference* source_reference);
ValaArrayCreationExpression* vala_array_creation_expression_construct (GType object_type, ValaDataType* element_type, gint rank, ValaInitializerList* initializer_list, ValaSourceReference* source_reference);
void vala_array_creation_expression_append_size (ValaArrayCreationExpression* self, ValaExpression* size);
static ValaMemberInitializer* vala_parser_parse_member_initializer (ValaParser* self, GError** error);
void vala_method_call_set_is_yield_expression (ValaMethodCall* self, gboolean value);
ValaSizeofExpression* vala_sizeof_expression_new (ValaDataType* type, ValaSourceReference* source);
ValaSizeofExpression* vala_sizeof_expression_construct (GType object_type, ValaDataType* type, ValaSourceReference* source);
ValaTypeofExpression* vala_typeof_expression_new (ValaDataType* type, ValaSourceReference* source);
ValaTypeofExpression* vala_typeof_expression_construct (GType object_type, ValaDataType* type, ValaSourceReference* source);
static ValaUnaryOperator vala_parser_get_unary_operator (ValaParser* self, ValaTokenType token_type);
static ValaExpression* vala_parser_parse_unary_expression (ValaParser* self, GError** error);
ValaReferenceTransferExpression* vala_reference_transfer_expression_new (ValaExpression* inner, ValaSourceReference* source_reference);
ValaReferenceTransferExpression* vala_reference_transfer_expression_construct (GType object_type, ValaExpression* inner, ValaSourceReference* source_reference);
ValaCastExpression* vala_cast_expression_new (ValaExpression* inner, ValaDataType* type_reference, ValaSourceReference* source_reference, gboolean is_silent_cast);
ValaCastExpression* vala_cast_expression_construct (GType object_type, ValaExpression* inner, ValaDataType* type_reference, ValaSourceReference* source_reference, gboolean is_silent_cast);
ValaCastExpression* vala_cast_expression_new_non_null (ValaExpression* inner, ValaSourceReference* source_reference);
ValaCastExpression* vala_cast_expression_construct_non_null (GType object_type, ValaExpression* inner, ValaSourceReference* source_reference);
ValaPointerIndirection* vala_pointer_indirection_new (ValaExpression* inner, ValaSourceReference* source_reference);
ValaPointerIndirection* vala_pointer_indirection_construct (GType object_type, ValaExpression* inner, ValaSourceReference* source_reference);
ValaAddressofExpression* vala_addressof_expression_new (ValaExpression* inner, ValaSourceReference* source_reference);
ValaAddressofExpression* vala_addressof_expression_construct (GType object_type, ValaExpression* inner, ValaSourceReference* source_reference);
GType vala_binary_operator_get_type (void) G_GNUC_CONST;
static ValaBinaryOperator vala_parser_get_binary_operator (ValaParser* self, ValaTokenType token_type);
static ValaExpression* vala_parser_parse_multiplicative_expression (ValaParser* self, GError** error);
ValaBinaryExpression* vala_binary_expression_new (ValaBinaryOperator op, ValaExpression* _left, ValaExpression* _right, ValaSourceReference* source);
ValaBinaryExpression* vala_binary_expression_construct (GType object_type, ValaBinaryOperator op, ValaExpression* _left, ValaExpression* _right, ValaSourceReference* source);
static ValaExpression* vala_parser_parse_additive_expression (ValaParser* self, GError** error);
static ValaExpression* vala_parser_parse_shift_expression (ValaParser* self, GError** error);
static ValaExpression* vala_parser_parse_relational_expression (ValaParser* self, GError** error);
GType vala_code_generator_get_type (void) G_GNUC_CONST;
GType vala_attribute_get_type (void) G_GNUC_CONST;
gboolean vala_code_context_get_experimental (ValaCodeContext* self);
ValaTypeCheck* vala_typecheck_new (ValaExpression* expr, ValaDataType* type, ValaSourceReference* source);
ValaTypeCheck* vala_typecheck_construct (GType object_type, ValaExpression* expr, ValaDataType* type, ValaSourceReference* source);
static ValaExpression* vala_parser_parse_equality_expression (ValaParser* self, GError** error);
static ValaExpression* vala_parser_parse_and_expression (ValaParser* self, GError** error);
static ValaExpression* vala_parser_parse_exclusive_or_expression (ValaParser* self, GError** error);
static ValaExpression* vala_parser_parse_inclusive_or_expression (ValaParser* self, GError** error);
static ValaExpression* vala_parser_parse_in_expression (ValaParser* self, GError** error);
static ValaExpression* vala_parser_parse_conditional_and_expression (ValaParser* self, GError** error);
static ValaExpression* vala_parser_parse_conditional_or_expression (ValaParser* self, GError** error);
static ValaExpression* vala_parser_parse_coalescing_expression (ValaParser* self, GError** error);
static ValaExpression* vala_parser_parse_conditional_expression (ValaParser* self, GError** error);
ValaConditionalExpression* vala_conditional_expression_new (ValaExpression* cond, ValaExpression* true_expr, ValaExpression* false_expr, ValaSourceReference* source);
ValaConditionalExpression* vala_conditional_expression_construct (GType object_type, ValaExpression* cond, ValaExpression* true_expr, ValaExpression* false_expr, ValaSourceReference* source);
static ValaParameter* vala_parser_parse_lambda_parameter (ValaParser* self, GError** error);
GType vala_parameter_direction_get_type (void) G_GNUC_CONST;
ValaParameter* vala_parameter_new (const gchar* name, ValaDataType* variable_type, ValaSourceReference* source_reference);
ValaParameter* vala_parameter_construct (GType object_type, const gchar* name, ValaDataType* variable_type, ValaSourceReference* source_reference);
void vala_parameter_set_direction (ValaParameter* self, ValaParameterDirection value);
static ValaExpression* vala_parser_parse_lambda_expression (ValaParser* self, GError** error);
static ValaBlock* vala_parser_parse_block (ValaParser* self, GError** error);
ValaLambdaExpression* vala_lambda_expression_new_with_statement_body (ValaBlock* statement_body, ValaSourceReference* source_reference);
ValaLambdaExpression* vala_lambda_expression_construct_with_statement_body (GType object_type, ValaBlock* statement_body, ValaSourceReference* source_reference);
ValaLambdaExpression* vala_lambda_expression_new (ValaExpression* expression_body, ValaSourceReference* source_reference);
ValaLambdaExpression* vala_lambda_expression_construct (GType object_type, ValaExpression* expression_body, ValaSourceReference* source_reference);
void vala_lambda_expression_add_parameter (ValaLambdaExpression* self, ValaParameter* param);
GType vala_assignment_operator_get_type (void) G_GNUC_CONST;
static ValaAssignmentOperator vala_parser_get_assignment_operator (ValaParser* self, ValaTokenType token_type);
static gboolean vala_parser_is_lambda_expression (ValaParser* self);
ValaAssignment* vala_assignment_new (ValaExpression* left, ValaExpression* right, ValaAssignmentOperator operator, ValaSourceReference* source_reference);
ValaAssignment* vala_assignment_construct (GType object_type, ValaExpression* left, ValaExpression* right, ValaAssignmentOperator operator, ValaSourceReference* source_reference);
static void vala_parser_parse_statements (ValaParser* self, ValaBlock* block, GError** error);
GType vala_statement_get_type (void) G_GNUC_CONST;
ValaComment* vala_scanner_pop_comment (ValaScanner* self);
static ValaStatement* vala_parser_parse_empty_statement (ValaParser* self, GError** error);
static ValaStatement* vala_parser_parse_if_statement (ValaParser* self, GError** error);
static ValaStatement* vala_parser_parse_switch_statement (ValaParser* self, GError** error);
static ValaStatement* vala_parser_parse_while_statement (ValaParser* self, GError** error);
static ValaStatement* vala_parser_parse_do_statement (ValaParser* self, GError** error);
static ValaStatement* vala_parser_parse_for_statement (ValaParser* self, GError** error);
static ValaStatement* vala_parser_parse_foreach_statement (ValaParser* self, GError** error);
static ValaStatement* vala_parser_parse_break_statement (ValaParser* self, GError** error);
static ValaStatement* vala_parser_parse_continue_statement (ValaParser* self, GError** error);
static ValaStatement* vala_parser_parse_return_statement (ValaParser* self, GError** error);
static ValaStatement* vala_parser_parse_yield_statement (ValaParser* self, GError** error);
static ValaStatement* vala_parser_parse_throw_statement (ValaParser* self, GError** error);
static ValaStatement* vala_parser_parse_try_statement (ValaParser* self, GError** error);
static ValaStatement* vala_parser_parse_lock_statement (ValaParser* self, GError** error);
static ValaStatement* vala_parser_parse_delete_statement (ValaParser* self, GError** error);
static void vala_parser_parse_local_variable_declarations (ValaParser* self, ValaBlock* block, GError** error);
static void vala_parser_parse_local_constant_declarations (ValaParser* self, ValaBlock* block, GError** error);
static ValaStatement* vala_parser_parse_expression_statement (ValaParser* self, GError** error);
static gboolean vala_parser_is_expression (ValaParser* self, GError** error);
ValaExpression* vala_return_statement_get_return_expression (ValaReturnStatement* self);
ValaMemberAccess* vala_member_access_new_simple (const gchar* member_name, ValaSourceReference* source_reference);
ValaMemberAccess* vala_member_access_construct_simple (GType object_type, const gchar* member_name, ValaSourceReference* source_reference);
void vala_return_statement_set_return_expression (ValaReturnStatement* self, ValaExpression* value);
void vala_block_add_statement (ValaBlock* self, ValaStatement* stmt);
ValaExpressionStatement* vala_expression_statement_new (ValaExpression* expression, ValaSourceReference* source_reference);
ValaExpressionStatement* vala_expression_statement_construct (GType object_type, ValaExpression* expression, ValaSourceReference* source_reference);
static ValaParserRecoveryState vala_parser_recover (ValaParser* self);
static ValaBlock* vala_parser_parse_embedded_statement (ValaParser* self, GError** error);
ValaBlock* vala_block_new (ValaSourceReference* source_reference);
ValaBlock* vala_block_construct (GType object_type, ValaSourceReference* source_reference);
static ValaStatement* vala_parser_parse_embedded_statement_without_block (ValaParser* self, GError** error);
gint vala_source_reference_get_last_line (ValaSourceReference* self);
void vala_source_reference_set_last_line (ValaSourceReference* self, gint value);
gint vala_source_reference_get_last_column (ValaSourceReference* self);
void vala_source_reference_set_last_column (ValaSourceReference* self, gint value);
ValaEmptyStatement* vala_empty_statement_new (ValaSourceReference* source);
ValaEmptyStatement* vala_empty_statement_construct (GType object_type, ValaSourceReference* source);
static void _vala_array_add12 (gchar*** array, int* length, int* size, gchar* value);
gchar* vala_code_node_get_temp_name (void);
ValaLocalVariable* vala_local_variable_new (ValaDataType* variable_type, const gchar* name, ValaExpression* initializer, ValaSourceReference* source_reference);
ValaLocalVariable* vala_local_variable_construct (GType object_type, ValaDataType* variable_type, const gchar* name, ValaExpression* initializer, ValaSourceReference* source_reference);
ValaDeclarationStatement* vala_declaration_statement_new (ValaSymbol* declaration, ValaSourceReference* source_reference);
ValaDeclarationStatement* vala_declaration_statement_construct (GType object_type, ValaSymbol* declaration, ValaSourceReference* source_reference);
const gchar* vala_symbol_get_name (ValaSymbol* self);
ValaDataType* vala_data_type_copy (ValaDataType* self);
static ValaLocalVariable* vala_parser_parse_local_variable (ValaParser* self, ValaDataType* variable_type, GError** error);
static ValaConstant* vala_parser_parse_local_constant (ValaParser* self, ValaDataType* constant_type, GError** error);
void vala_block_add_local_constant (ValaBlock* self, ValaConstant* constant);
void vala_symbol_set_active (ValaSymbol* self, gboolean value);
ValaConstant* vala_constant_new (const gchar* name, ValaDataType* type_reference, ValaExpression* value, ValaSourceReference* source_reference, ValaComment* comment);
ValaConstant* vala_constant_construct (GType object_type, const gchar* name, ValaDataType* type_reference, ValaExpression* value, ValaSourceReference* source_reference, ValaComment* comment);
static ValaExpression* vala_parser_parse_statement_expression (ValaParser* self, GError** error);
ValaIfStatement* vala_if_statement_new (ValaExpression* cond, ValaBlock* true_stmt, ValaBlock* false_stmt, ValaSourceReference* source);
ValaIfStatement* vala_if_statement_construct (GType object_type, ValaExpression* cond, ValaBlock* true_stmt, ValaBlock* false_stmt, ValaSourceReference* source);
ValaSwitchStatement* vala_switch_statement_new (ValaExpression* expression, ValaSourceReference* source_reference);
ValaSwitchStatement* vala_switch_statement_construct (GType object_type, ValaExpression* expression, ValaSourceReference* source_reference);
ValaSwitchSection* vala_switch_section_new (ValaSourceReference* source_reference);
ValaSwitchSection* vala_switch_section_construct (GType object_type, ValaSourceReference* source_reference);
void vala_switch_section_add_label (ValaSwitchSection* self, ValaSwitchLabel* label);
ValaSwitchLabel* vala_switch_label_new (ValaExpression* expr, ValaSourceReference* source);
ValaSwitchLabel* vala_switch_label_construct (GType object_type, ValaExpression* expr, ValaSourceReference* source);
ValaSwitchLabel* vala_switch_label_new_with_default (ValaSourceReference* source);
ValaSwitchLabel* vala_switch_label_construct_with_default (GType object_type, ValaSourceReference* source);
void vala_switch_statement_add_section (ValaSwitchStatement* self, ValaSwitchSection* section);
ValaWhileStatement* vala_while_statement_new (ValaExpression* condition, ValaBlock* body, ValaSourceReference* source_reference);
ValaWhileStatement* vala_while_statement_construct (GType object_type, ValaExpression* condition, ValaBlock* body, ValaSourceReference* source_reference);
ValaDoStatement* vala_do_statement_new (ValaBlock* body, ValaExpression* condition, ValaSourceReference* source_reference);
ValaDoStatement* vala_do_statement_construct (GType object_type, ValaBlock* body, ValaExpression* condition, ValaSourceReference* source_reference);
ValaForStatement* vala_for_statement_new (ValaExpression* condition, ValaBlock* body, ValaSourceReference* source_reference);
ValaForStatement* vala_for_statement_construct (GType object_type, ValaExpression* condition, ValaBlock* body, ValaSourceReference* source_reference);
void vala_for_statement_add_initializer (ValaForStatement* self, ValaExpression* init);
void vala_for_statement_add_iterator (ValaForStatement* self, ValaExpression* iter);
ValaForeachStatement* vala_foreach_statement_new (ValaDataType* type_reference, const gchar* variable_name, ValaExpression* collection, ValaBlock* body, ValaSourceReference* source_reference);
ValaForeachStatement* vala_foreach_statement_construct (GType object_type, ValaDataType* type_reference, const gchar* variable_name, ValaExpression* collection, ValaBlock* body, ValaSourceReference* source_reference);
ValaBreakStatement* vala_break_statement_new (ValaSourceReference* source);
ValaBreakStatement* vala_break_statement_construct (GType object_type, ValaSourceReference* source);
ValaContinueStatement* vala_continue_statement_new (ValaSourceReference* source);
ValaContinueStatement* vala_continue_statement_construct (GType object_type, ValaSourceReference* source);
ValaReturnStatement* vala_return_statement_new (ValaExpression* return_expression, ValaSourceReference* source_reference);
ValaReturnStatement* vala_return_statement_construct (GType object_type, ValaExpression* return_expression, ValaSourceReference* source_reference);
ValaYieldStatement* vala_yield_statement_new (ValaExpression* yield_expression, ValaSourceReference* source_reference);
ValaYieldStatement* vala_yield_statement_construct (GType object_type, ValaExpression* yield_expression, ValaSourceReference* source_reference);
ValaThrowStatement* vala_throw_statement_new (ValaExpression* error_expression, ValaSourceReference* source_reference);
ValaThrowStatement* vala_throw_statement_construct (GType object_type, ValaExpression* error_expression, ValaSourceReference* source_reference);
static void vala_parser_parse_catch_clauses (ValaParser* self, ValaList* catch_clauses, GError** error);
static ValaBlock* vala_parser_parse_finally_clause (ValaParser* self, GError** error);
ValaTryStatement* vala_try_statement_new (ValaBlock* body, ValaBlock* finally_body, ValaSourceReference* source_reference);
ValaTryStatement* vala_try_statement_construct (GType object_type, ValaBlock* body, ValaBlock* finally_body, ValaSourceReference* source_reference);
void vala_try_statement_add_catch_clause (ValaTryStatement* self, ValaCatchClause* clause);
ValaCatchClause* vala_catch_clause_new (ValaDataType* error_type, const gchar* variable_name, ValaBlock* body, ValaSourceReference* source_reference);
ValaCatchClause* vala_catch_clause_construct (GType object_type, ValaDataType* error_type, const gchar* variable_name, ValaBlock* body, ValaSourceReference* source_reference);
ValaLockStatement* vala_lock_statement_new (ValaExpression* resource, ValaBlock* body, ValaSourceReference* source_reference);
ValaLockStatement* vala_lock_statement_construct (GType object_type, ValaExpression* resource, ValaBlock* body, ValaSourceReference* source_reference);
ValaDeleteStatement* vala_delete_statement_new (ValaExpression* expression, ValaSourceReference* source_reference);
ValaDeleteStatement* vala_delete_statement_construct (GType object_type, ValaExpression* expression, ValaSourceReference* source_reference);
static gchar* vala_parser_parse_attribute_value (ValaParser* self, GError** error);
static ValaList* vala_parser_parse_attributes (ValaParser* self, GError** error);
ValaAttribute* vala_attribute_new (const gchar* name, ValaSourceReference* source_reference);
ValaAttribute* vala_attribute_construct (GType object_type, const gchar* name, ValaSourceReference* source_reference);
void vala_attribute_add_argument (ValaAttribute* self, const gchar* key, const gchar* value);
static void vala_parser_set_attributes (ValaParser* self, ValaCodeNode* node, ValaList* attributes);
static void vala_parser_parse_main_block (ValaParser* self, ValaSymbol* parent, GError** error);
ValaMethod* vala_method_new (const gchar* name, ValaDataType* return_type, ValaSourceReference* source_reference, ValaComment* comment);
ValaMethod* vala_method_construct (GType object_type, const gchar* name, ValaDataType* return_type, ValaSourceReference* source_reference, ValaComment* comment);
void vala_subroutine_set_body (ValaSubroutine* self, ValaBlock* value);
ValaBlock* vala_subroutine_get_body (ValaSubroutine* self);
void vala_symbol_add_method (ValaSymbol* self, ValaMethod* m);
static void vala_parser_parse_declaration (ValaParser* self, ValaSymbol* parent, gboolean root, GError** error);
static gboolean vala_parser_is_declaration_keyword (ValaParser* self, ValaTokenType type);
static void vala_parser_parse_constructor_declaration (ValaParser* self, ValaSymbol* parent, ValaList* attrs, GError** error);
static void vala_parser_parse_destructor_declaration (ValaParser* self, ValaSymbol* parent, ValaList* attrs, GError** error);
static void vala_parser_parse_class_declaration (ValaParser* self, ValaSymbol* parent, ValaList* attrs, GError** error);
static void vala_parser_parse_enum_declaration (ValaParser* self, ValaSymbol* parent, ValaList* attrs, GError** error);
static void vala_parser_parse_errordomain_declaration (ValaParser* self, ValaSymbol* parent, ValaList* attrs, GError** error);
static void vala_parser_parse_interface_declaration (ValaParser* self, ValaSymbol* parent, ValaList* attrs, GError** error);
static void vala_parser_parse_namespace_declaration (ValaParser* self, ValaSymbol* parent, ValaList* attrs, GError** error);
static void vala_parser_parse_struct_declaration (ValaParser* self, ValaSymbol* parent, ValaList* attrs, GError** error);
static void vala_parser_parse_creation_method_declaration (ValaParser* self, ValaSymbol* parent, ValaList* attrs, GError** error);
static void vala_parser_parse_delegate_declaration (ValaParser* self, ValaSymbol* parent, ValaList* attrs, GError** error);
static void vala_parser_parse_signal_declaration (ValaParser* self, ValaSymbol* parent, ValaList* attrs, GError** error);
static void vala_parser_parse_method_declaration (ValaParser* self, ValaSymbol* parent, ValaList* attrs, GError** error);
static void vala_parser_parse_constant_declaration (ValaParser* self, ValaSymbol* parent, ValaList* attrs, GError** error);
static void vala_parser_parse_field_declaration (ValaParser* self, ValaSymbol* parent, ValaList* attrs, GError** error);
static void vala_parser_parse_property_declaration (ValaParser* self, ValaSymbol* parent, ValaList* attrs, GError** error);
ValaNamespace* vala_namespace_new (const gchar* name, ValaSourceReference* source_reference);
ValaNamespace* vala_namespace_construct (GType object_type, const gchar* name, ValaSourceReference* source_reference);
void vala_namespace_add_comment (ValaNamespace* self, ValaComment* comment);
ValaList* vala_source_file_get_current_using_directives (ValaSourceFile* self);
void vala_source_file_set_current_using_directives (ValaSourceFile* self, ValaList* value);
ValaUnresolvedSymbol* vala_unresolved_symbol_get_inner (ValaUnresolvedSymbol* self);
void vala_symbol_add_namespace (ValaSymbol* self, ValaNamespace* ns);
ValaUsingDirective* vala_using_directive_new (ValaSymbol* namespace_symbol, ValaSourceReference* source_reference);
ValaUsingDirective* vala_using_directive_construct (GType object_type, ValaSymbol* namespace_symbol, ValaSourceReference* source_reference);
void vala_source_file_add_using_directive (ValaSourceFile* self, ValaUsingDirective* ns);
void vala_namespace_add_using_directive (ValaNamespace* self, ValaUsingDirective* ns);
GType vala_symbol_accessibility_get_type (void) G_GNUC_CONST;
static ValaSymbolAccessibility vala_parser_parse_access_modifier (ValaParser* self, ValaSymbolAccessibility default_access);
static ValaParserModifierFlags vala_parser_parse_type_declaration_modifiers (ValaParser* self);
static ValaList* vala_parser_parse_type_parameter_list (ValaParser* self, GError** error);
ValaClass* vala_class_new (const gchar* name, ValaSourceReference* source_reference, ValaComment* comment);
ValaClass* vala_class_construct (GType object_type, const gchar* name, ValaSourceReference* source_reference, ValaComment* comment);
void vala_symbol_set_access (ValaSymbol* self, ValaSymbolAccessibility value);
void vala_class_set_is_abstract (ValaClass* self, gboolean value);
GType vala_source_file_type_get_type (void) G_GNUC_CONST;
ValaSourceFileType vala_source_file_get_file_type (ValaSourceFile* self);
void vala_symbol_set_external (ValaSymbol* self, gboolean value);
void vala_object_type_symbol_add_type_parameter (ValaObjectTypeSymbol* self, ValaTypeParameter* p);
void vala_class_add_base_type (ValaClass* self, ValaDataType* type);
ValaMethod* vala_class_get_default_construction_method (ValaClass* self);
ValaCreationMethod* vala_creation_method_new (const gchar* class_name, const gchar* name, ValaSourceReference* source_reference, ValaComment* comment);
ValaCreationMethod* vala_creation_method_construct (GType object_type, const gchar* class_name, const gchar* name, ValaSourceReference* source_reference, ValaComment* comment);
void vala_symbol_add_class (ValaSymbol* self, ValaClass* cl);
static ValaParserModifierFlags vala_parser_parse_member_declaration_modifiers (ValaParser* self);
ValaDataType* vala_array_type_get_element_type (ValaArrayType* self);
void vala_symbol_set_hides (ValaSymbol* self, gboolean value);
void vala_symbol_add_constant (ValaSymbol* self, ValaConstant* constant);
ValaField* vala_field_new (const gchar* name, ValaDataType* variable_type, ValaExpression* initializer, ValaSourceReference* source_reference, ValaComment* comment);
ValaField* vala_field_construct (GType object_type, const gchar* name, ValaDataType* variable_type, ValaExpression* initializer, ValaSourceReference* source_reference, ValaComment* comment);
GType vala_member_binding_get_type (void) G_GNUC_CONST;
void vala_field_set_binding (ValaField* self, ValaMemberBinding value);
void vala_variable_set_initializer (ValaVariable* self, ValaExpression* value);
void vala_symbol_add_field (ValaSymbol* self, ValaField* f);
ValaInitializerList* vala_initializer_list_new (ValaSourceReference* source_reference);
ValaInitializerList* vala_initializer_list_construct (GType object_type, ValaSourceReference* source_reference);
void vala_initializer_list_append (ValaInitializerList* self, ValaExpression* expr);
ValaListLiteral* vala_list_literal_new (ValaSourceReference* source_reference);
ValaListLiteral* vala_list_literal_construct (GType object_type, ValaSourceReference* source_reference);
void vala_list_literal_add_expression (ValaListLiteral* self, ValaExpression* expr);
ValaSetLiteral* vala_set_literal_new (ValaSourceReference* source_reference);
ValaSetLiteral* vala_set_literal_construct (GType object_type, ValaSourceReference* source_reference);
static ValaExpression* vala_parser_parse_map_literal (ValaParser* self, GError** error);
void vala_set_literal_add_expression (ValaSetLiteral* self, ValaExpression* expr);
ValaMapLiteral* vala_map_literal_new (ValaSourceReference* source_reference);
ValaMapLiteral* vala_map_literal_construct (GType object_type, ValaSourceReference* source_reference);
void vala_map_literal_add_key (ValaMapLiteral* self, ValaExpression* expr);
void vala_map_literal_add_value (ValaMapLiteral* self, ValaExpression* expr);
void vala_method_add_type_parameter (ValaMethod* self, ValaTypeParameter* p);
void vala_method_set_binding (ValaMethod* self, ValaMemberBinding value);
void vala_method_set_coroutine (ValaMethod* self, gboolean value);
ValaMemberBinding vala_method_get_binding (ValaMethod* self);
void vala_method_set_is_abstract (ValaMethod* self, gboolean value);
void vala_method_set_is_virtual (ValaMethod* self, gboolean value);
void vala_method_set_overrides (ValaMethod* self, gboolean value);
gboolean vala_method_get_is_abstract (ValaMethod* self);
gboolean vala_method_get_is_virtual (ValaMethod* self);
gboolean vala_method_get_overrides (ValaMethod* self);
void vala_method_set_is_inline (ValaMethod* self, gboolean value);
static ValaParameter* vala_parser_parse_parameter (ValaParser* self, GError** error);
void vala_method_add_parameter (ValaMethod* self, ValaParameter* param);
void vala_code_node_add_error_type (ValaCodeNode* self, ValaDataType* error_type);
void vala_method_add_precondition (ValaMethod* self, ValaExpression* precondition);
void vala_method_add_postcondition (ValaMethod* self, ValaExpression* postcondition);
ValaProperty* vala_property_new (const gchar* name, ValaDataType* property_type, ValaPropertyAccessor* get_accessor, ValaPropertyAccessor* set_accessor, ValaSourceReference* source_reference, ValaComment* comment);
ValaProperty* vala_property_construct (GType object_type, const gchar* name, ValaDataType* property_type, ValaPropertyAccessor* get_accessor, ValaPropertyAccessor* set_accessor, ValaSourceReference* source_reference, ValaComment* comment);
void vala_property_set_binding (ValaProperty* self, ValaMemberBinding value);
void vala_property_set_is_abstract (ValaProperty* self, gboolean value);
void vala_property_set_is_virtual (ValaProperty* self, gboolean value);
void vala_property_set_overrides (ValaProperty* self, gboolean value);
ValaExpression* vala_property_get_initializer (ValaProperty* self);
void vala_property_set_initializer (ValaProperty* self, ValaExpression* value);
ValaPropertyAccessor* vala_property_get_get_accessor (ValaProperty* self);
ValaPropertyAccessor* vala_property_accessor_new (gboolean readable, gboolean writable, gboolean construction, ValaDataType* value_type, ValaBlock* body, ValaSourceReference* source_reference, ValaComment* comment);
ValaPropertyAccessor* vala_property_accessor_construct (GType object_type, gboolean readable, gboolean writable, gboolean construction, ValaDataType* value_type, ValaBlock* body, ValaSourceReference* source_reference, ValaComment* comment);
void vala_property_set_get_accessor (ValaProperty* self, ValaPropertyAccessor* value);
ValaPropertyAccessor* vala_property_get_set_accessor (ValaProperty* self);
void vala_property_set_set_accessor (ValaProperty* self, ValaPropertyAccessor* value);
gboolean vala_property_get_is_abstract (ValaProperty* self);
ValaSourceFileType vala_symbol_get_source_type (ValaSymbol* self);
void vala_code_node_set_error (ValaCodeNode* self, gboolean value);
ValaDataType* vala_property_get_property_type (ValaProperty* self);
void vala_property_set_field (ValaProperty* self, ValaField* value);
ValaField* vala_property_get_field (ValaProperty* self);
ValaMemberBinding vala_property_get_binding (ValaProperty* self);
void vala_symbol_add_property (ValaSymbol* self, ValaProperty* prop);
ValaSignal* vala_signal_new (const gchar* name, ValaDataType* return_type, ValaSourceReference* source_reference, ValaComment* comment);
ValaSignal* vala_signal_construct (GType object_type, const gchar* name, ValaDataType* return_type, ValaSourceReference* source_reference, ValaComment* comment);
void vala_signal_set_is_virtual (ValaSignal* self, gboolean value);
void vala_signal_add_parameter (ValaSignal* self, ValaParameter* param);
void vala_signal_set_body (ValaSignal* self, ValaBlock* value);
void vala_symbol_add_signal (ValaSymbol* self, ValaSignal* sig);
ValaConstructor* vala_constructor_new (ValaSourceReference* source);
ValaConstructor* vala_constructor_construct (GType object_type, ValaSourceReference* source);
void vala_constructor_set_binding (ValaConstructor* self, ValaMemberBinding value);
void vala_symbol_add_constructor (ValaSymbol* self, ValaConstructor* c);
ValaDestructor* vala_destructor_new (ValaSourceReference* source_reference);
ValaDestructor* vala_destructor_construct (GType object_type, ValaSourceReference* source_reference);
void vala_destructor_set_binding (ValaDestructor* self, ValaMemberBinding value);
void vala_symbol_add_destructor (ValaSymbol* self, ValaDestructor* d);
ValaStruct* vala_struct_new (const gchar* name, ValaSourceReference* source_reference, ValaComment* comment);
ValaStruct* vala_struct_construct (GType object_type, const gchar* name, ValaSourceReference* source_reference, ValaComment* comment);
void vala_struct_add_type_parameter (ValaStruct* self, ValaTypeParameter* p);
void vala_struct_set_base_type (ValaStruct* self, ValaDataType* value);
void vala_symbol_add_struct (ValaSymbol* self, ValaStruct* st);
ValaInterface* vala_interface_new (const gchar* name, ValaSourceReference* source_reference, ValaComment* comment);
ValaInterface* vala_interface_construct (GType object_type, const gchar* name, ValaSourceReference* source_reference, ValaComment* comment);
void vala_interface_add_prerequisite (ValaInterface* self, ValaDataType* type);
void vala_symbol_add_interface (ValaSymbol* self, ValaInterface* iface);
ValaEnum* vala_enum_new (const gchar* name, ValaSourceReference* source_reference, ValaComment* comment);
ValaEnum* vala_enum_construct (GType object_type, const gchar* name, ValaSourceReference* source_reference, ValaComment* comment);
ValaList* vala_enum_get_values (ValaEnum* self);
ValaEnumValue* vala_enum_value_new (const gchar* name, ValaExpression* value, ValaSourceReference* source_reference, ValaComment* comment);
ValaEnumValue* vala_enum_value_construct (GType object_type, const gchar* name, ValaExpression* value, ValaSourceReference* source_reference, ValaComment* comment);
void vala_enum_add_value (ValaEnum* self, ValaEnumValue* value);
void vala_symbol_add_enum (ValaSymbol* self, ValaEnum* en);
ValaErrorDomain* vala_error_domain_new (const gchar* name, ValaSourceReference* source_reference, ValaComment* comment);
ValaErrorDomain* vala_error_domain_construct (GType object_type, const gchar* name, ValaSourceReference* source_reference, ValaComment* comment);
ValaList* vala_error_domain_get_codes (ValaErrorDomain* self);
ValaErrorCode* vala_error_code_new (const gchar* name, ValaSourceReference* source_reference, ValaComment* comment);
ValaErrorCode* vala_error_code_construct (GType object_type, const gchar* name, ValaSourceReference* source_reference, ValaComment* comment);
void vala_error_code_set_value (ValaErrorCode* self, ValaExpression* value);
void vala_error_domain_add_code (ValaErrorDomain* self, ValaErrorCode* ecode);
void vala_symbol_add_error_domain (ValaSymbol* self, ValaErrorDomain* edomain);
ValaParameter* vala_parameter_new_with_ellipsis (ValaSourceReference* source_reference);
ValaParameter* vala_parameter_construct_with_ellipsis (GType object_type, ValaSourceReference* source_reference);
void vala_parameter_set_params_array (ValaParameter* self, gboolean value);
ValaDelegate* vala_delegate_new (const gchar* name, ValaDataType* return_type, ValaSourceReference* source_reference, ValaComment* comment);
ValaDelegate* vala_delegate_construct (GType object_type, const gchar* name, ValaDataType* return_type, ValaSourceReference* source_reference, ValaComment* comment);
void vala_delegate_set_has_target (ValaDelegate* self, gboolean value);
void vala_delegate_add_type_parameter (ValaDelegate* self, ValaTypeParameter* p);
void vala_delegate_add_parameter (ValaDelegate* self, ValaParameter* param);
void vala_symbol_add_delegate (ValaSymbol* self, ValaDelegate* d);
ValaTypeParameter* vala_typeparameter_new (const gchar* name, ValaSourceReference* source_reference);
ValaTypeParameter* vala_typeparameter_construct (GType object_type, const gchar* name, ValaSourceReference* source_reference);
static void vala_parser_finalize (ValaCodeVisitor* obj);
static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func);
static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func);


static GType vala_parser_modifier_flags_get_type (void) {
      static volatile gsize vala_parser_modifier_flags_type_id__volatile = 0;
      if (g_once_init_enter (&vala_parser_modifier_flags_type_id__volatile)) {
            static const GEnumValue values[] = {{VALA_PARSER_MODIFIER_FLAGS_NONE, "VALA_PARSER_MODIFIER_FLAGS_NONE", "none"}, {VALA_PARSER_MODIFIER_FLAGS_ABSTRACT, "VALA_PARSER_MODIFIER_FLAGS_ABSTRACT", "abstract"}, {VALA_PARSER_MODIFIER_FLAGS_CLASS, "VALA_PARSER_MODIFIER_FLAGS_CLASS", "class"}, {VALA_PARSER_MODIFIER_FLAGS_EXTERN, "VALA_PARSER_MODIFIER_FLAGS_EXTERN", "extern"}, {VALA_PARSER_MODIFIER_FLAGS_INLINE, "VALA_PARSER_MODIFIER_FLAGS_INLINE", "inline"}, {VALA_PARSER_MODIFIER_FLAGS_NEW, "VALA_PARSER_MODIFIER_FLAGS_NEW", "new"}, {VALA_PARSER_MODIFIER_FLAGS_OVERRIDE, "VALA_PARSER_MODIFIER_FLAGS_OVERRIDE", "override"}, {VALA_PARSER_MODIFIER_FLAGS_STATIC, "VALA_PARSER_MODIFIER_FLAGS_STATIC", "static"}, {VALA_PARSER_MODIFIER_FLAGS_VIRTUAL, "VALA_PARSER_MODIFIER_FLAGS_VIRTUAL", "virtual"}, {VALA_PARSER_MODIFIER_FLAGS_ASYNC, "VALA_PARSER_MODIFIER_FLAGS_ASYNC", "async"}, {VALA_PARSER_MODIFIER_FLAGS_SEALED, "VALA_PARSER_MODIFIER_FLAGS_SEALED", "sealed"}, {0, NULL, NULL}};
            GType vala_parser_modifier_flags_type_id;
            vala_parser_modifier_flags_type_id = g_enum_register_static ("ValaParserModifierFlags", values);
            g_once_init_leave (&vala_parser_modifier_flags_type_id__volatile, vala_parser_modifier_flags_type_id);
      }
      return vala_parser_modifier_flags_type_id__volatile;
}


static GType vala_parser_recovery_state_get_type (void) {
      static volatile gsize vala_parser_recovery_state_type_id__volatile = 0;
      if (g_once_init_enter (&vala_parser_recovery_state_type_id__volatile)) {
            static const GEnumValue values[] = {{VALA_PARSER_RECOVERY_STATE_EOF, "VALA_PARSER_RECOVERY_STATE_EOF", "eof"}, {VALA_PARSER_RECOVERY_STATE_DECLARATION_BEGIN, "VALA_PARSER_RECOVERY_STATE_DECLARATION_BEGIN", "declaration-begin"}, {VALA_PARSER_RECOVERY_STATE_STATEMENT_BEGIN, "VALA_PARSER_RECOVERY_STATE_STATEMENT_BEGIN", "statement-begin"}, {0, NULL, NULL}};
            GType vala_parser_recovery_state_type_id;
            vala_parser_recovery_state_type_id = g_enum_register_static ("ValaParserRecoveryState", values);
            g_once_init_leave (&vala_parser_recovery_state_type_id__volatile, vala_parser_recovery_state_type_id);
      }
      return vala_parser_recovery_state_type_id__volatile;
}


ValaParser* vala_parser_construct (GType object_type) {
      ValaParser* self = NULL;
      ValaParserTokenInfo* _tmp0_ = NULL;
      self = (ValaParser*) vala_code_visitor_construct (object_type);
      _tmp0_ = g_new0 (ValaParserTokenInfo, VALA_PARSER_BUFFER_SIZE);
      self->priv->tokens = (g_free (self->priv->tokens), NULL);
      self->priv->tokens = _tmp0_;
      self->priv->tokens_length1 = VALA_PARSER_BUFFER_SIZE;
      self->priv->_tokens_size_ = self->priv->tokens_length1;
      return self;
}


ValaParser* vala_parser_new (void) {
      return vala_parser_construct (VALA_TYPE_PARSER);
}


/**
 * Parses all .vala and .vapi source files in the specified code
 * context and builds a code tree.
 *
 * @param context a code context
 */
static gpointer _vala_code_context_ref0 (gpointer self) {
      return self ? vala_code_context_ref (self) : NULL;
}


void vala_parser_parse (ValaParser* self, ValaCodeContext* context) {
      ValaCodeContext* _tmp0_;
      g_return_if_fail (self != NULL);
      g_return_if_fail (context != NULL);
      _tmp0_ = _vala_code_context_ref0 (context);
      _vala_code_context_unref0 (self->priv->context);
      self->priv->context = _tmp0_;
      vala_code_context_accept (context, (ValaCodeVisitor*) self);
}


static void vala_parser_real_visit_source_file (ValaCodeVisitor* base, ValaSourceFile* source_file) {
      ValaParser * self;
      gboolean _tmp0_ = FALSE;
      gboolean _tmp1_ = FALSE;
      gboolean _tmp2_;
      self = (ValaParser*) base;
      g_return_if_fail (source_file != NULL);
      _tmp2_ = vala_code_context_get_run_output (self->priv->context);
      if (_tmp2_) {
            _tmp1_ = TRUE;
      } else {
            const gchar* _tmp3_ = NULL;
            gboolean _tmp4_;
            _tmp3_ = vala_source_file_get_filename (source_file);
            _tmp4_ = g_str_has_suffix (_tmp3_, ".vala");
            _tmp1_ = _tmp4_;
      }
      if (_tmp1_) {
            _tmp0_ = TRUE;
      } else {
            const gchar* _tmp5_ = NULL;
            gboolean _tmp6_;
            _tmp5_ = vala_source_file_get_filename (source_file);
            _tmp6_ = g_str_has_suffix (_tmp5_, ".vapi");
            _tmp0_ = _tmp6_;
      }
      if (_tmp0_) {
            vala_parser_parse_file (self, source_file);
      }
}


static inline gboolean vala_parser_next (ValaParser* self) {
      gboolean result = FALSE;
      g_return_val_if_fail (self != NULL, FALSE);
      self->priv->index = (self->priv->index + 1) % VALA_PARSER_BUFFER_SIZE;
      self->priv->size--;
      if (self->priv->size <= 0) {
            ValaSourceLocation begin = {0};
            ValaSourceLocation end = {0};
            ValaSourceLocation _tmp0_ = {0};
            ValaSourceLocation _tmp1_ = {0};
            ValaTokenType _tmp2_;
            ValaTokenType type;
            _tmp2_ = vala_scanner_read_token (self->priv->scanner, &_tmp0_, &_tmp1_);
            begin = _tmp0_;
            end = _tmp1_;
            type = _tmp2_;
            self->priv->tokens[self->priv->index].type = type;
            self->priv->tokens[self->priv->index].begin = begin;
            self->priv->tokens[self->priv->index].end = end;
            self->priv->size = 1;
      }
      result = self->priv->tokens[self->priv->index].type != VALA_TOKEN_TYPE_EOF;
      return result;
}


static inline void vala_parser_prev (ValaParser* self) {
      g_return_if_fail (self != NULL);
      self->priv->index = ((self->priv->index - 1) + VALA_PARSER_BUFFER_SIZE) % VALA_PARSER_BUFFER_SIZE;
      self->priv->size++;
      g_assert (self->priv->size <= VALA_PARSER_BUFFER_SIZE);
}


static inline ValaTokenType vala_parser_current (ValaParser* self) {
      ValaTokenType result = 0;
      g_return_val_if_fail (self != NULL, 0);
      result = self->priv->tokens[self->priv->index].type;
      return result;
}


static inline gboolean vala_parser_accept (ValaParser* self, ValaTokenType type) {
      gboolean result = FALSE;
      ValaTokenType _tmp0_;
      g_return_val_if_fail (self != NULL, FALSE);
      _tmp0_ = vala_parser_current (self);
      if (_tmp0_ == type) {
            vala_parser_next (self);
            result = TRUE;
            return result;
      }
      result = FALSE;
      return result;
}


static gchar* vala_parser_get_error (ValaParser* self, const gchar* msg) {
      gchar* result = NULL;
      ValaSourceLocation _tmp0_ = {0};
      ValaSourceLocation _tmp1_ = {0};
      ValaSourceLocation begin;
      ValaSourceReference* _tmp2_ = NULL;
      ValaSourceReference* _tmp3_;
      gchar* _tmp4_;
      gchar* _tmp5_;
      gchar* _tmp6_;
      g_return_val_if_fail (self != NULL, NULL);
      g_return_val_if_fail (msg != NULL, NULL);
      vala_parser_get_location (self, &_tmp0_);
      _tmp1_ = _tmp0_;
      begin = _tmp1_;
      vala_parser_next (self);
      _tmp2_ = vala_parser_get_src (self, &begin);
      _tmp3_ = _tmp2_;
      _tmp4_ = g_strconcat ("syntax error, ", msg, NULL);
      _tmp5_ = _tmp4_;
      vala_report_error (_tmp3_, _tmp5_);
      _g_free0 (_tmp5_);
      _vala_source_reference_unref0 (_tmp3_);
      _tmp6_ = g_strdup (msg);
      result = _tmp6_;
      return result;
}


static inline gboolean vala_parser_expect (ValaParser* self, ValaTokenType type, GError** error) {
      gboolean result = FALSE;
      gboolean _tmp0_;
      const gchar* _tmp1_ = NULL;
      gchar* _tmp2_ = NULL;
      gchar* _tmp3_;
      gchar* _tmp4_ = NULL;
      gchar* _tmp5_;
      GError* _tmp6_ = NULL;
      GError* _tmp7_;
      GError * _inner_error_ = NULL;
      g_return_val_if_fail (self != NULL, FALSE);
      _tmp0_ = vala_parser_accept (self, type);
      if (_tmp0_) {
            result = TRUE;
            return result;
      }
      _tmp1_ = vala_token_type_to_string (type);
      _tmp2_ = g_strdup_printf ("expected %s", _tmp1_);
      _tmp3_ = _tmp2_;
      _tmp4_ = vala_parser_get_error (self, _tmp3_);
      _tmp5_ = _tmp4_;
      _tmp6_ = g_error_new_literal (VALA_PARSE_ERROR, VALA_PARSE_ERROR_SYNTAX, _tmp5_);
      _tmp7_ = _tmp6_;
      _g_free0 (_tmp5_);
      _g_free0 (_tmp3_);
      _inner_error_ = _tmp7_;
      if (_inner_error_->domain == VALA_PARSE_ERROR) {
            g_propagate_error (error, _inner_error_);
            return FALSE;
      } else {
            g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
            g_clear_error (&_inner_error_);
            return FALSE;
      }
}


static inline void vala_parser_get_location (ValaParser* self, ValaSourceLocation* result) {
      g_return_if_fail (self != NULL);
      *result = self->priv->tokens[self->priv->index].begin;
      return;
}


static glong string_strnlen (gchar* str, glong maxlen) {
      glong result = 0L;
      gchar* _tmp0_ = NULL;
      gchar* end;
      _tmp0_ = memchr (str, 0, (gsize) maxlen);
      end = _tmp0_;
      if (end == NULL) {
            result = maxlen;
            return result;
      } else {
            result = (glong) (end - str);
            return result;
      }
}


static gchar* string_substring (const gchar* self, glong offset, glong len) {
      gchar* result = NULL;
      glong string_length = 0L;
      gboolean _tmp0_ = FALSE;
      gchar* _tmp3_ = NULL;
      g_return_val_if_fail (self != NULL, NULL);
      if (offset >= ((glong) 0)) {
            _tmp0_ = len >= ((glong) 0);
      } else {
            _tmp0_ = FALSE;
      }
      if (_tmp0_) {
            glong _tmp1_;
            _tmp1_ = string_strnlen ((gchar*) self, offset + len);
            string_length = _tmp1_;
      } else {
            gint _tmp2_;
            _tmp2_ = strlen (self);
            string_length = (glong) _tmp2_;
      }
      if (offset < ((glong) 0)) {
            offset = string_length + offset;
            g_return_val_if_fail (offset >= ((glong) 0), NULL);
      } else {
            g_return_val_if_fail (offset <= string_length, NULL);
      }
      if (len < ((glong) 0)) {
            len = string_length - offset;
      }
      g_return_val_if_fail ((offset + len) <= string_length, NULL);
      _tmp3_ = g_strndup (((gchar*) self) + offset, (gsize) len);
      result = _tmp3_;
      return result;
}


static gchar* vala_parser_get_current_string (ValaParser* self) {
      gchar* result = NULL;
      gchar* _tmp0_ = NULL;
      g_return_val_if_fail (self != NULL, NULL);
      _tmp0_ = string_substring ((const gchar*) self->priv->tokens[self->priv->index].begin.pos, (glong) 0, (glong) ((gint) (self->priv->tokens[self->priv->index].end.pos - self->priv->tokens[self->priv->index].begin.pos)));
      result = _tmp0_;
      return result;
}


static gchar* vala_parser_get_last_string (ValaParser* self) {
      gchar* result = NULL;
      gint last_index;
      gchar* _tmp0_ = NULL;
      g_return_val_if_fail (self != NULL, NULL);
      last_index = ((self->priv->index + VALA_PARSER_BUFFER_SIZE) - 1) % VALA_PARSER_BUFFER_SIZE;
      _tmp0_ = string_substring ((const gchar*) self->priv->tokens[last_index].begin.pos, (glong) 0, (glong) ((gint) (self->priv->tokens[last_index].end.pos - self->priv->tokens[last_index].begin.pos)));
      result = _tmp0_;
      return result;
}


static ValaSourceReference* vala_parser_get_src (ValaParser* self, ValaSourceLocation* begin) {
      ValaSourceReference* result = NULL;
      gint last_index;
      ValaSourceFile* _tmp0_ = NULL;
      ValaSourceReference* _tmp1_ = NULL;
      g_return_val_if_fail (self != NULL, NULL);
      last_index = ((self->priv->index + VALA_PARSER_BUFFER_SIZE) - 1) % VALA_PARSER_BUFFER_SIZE;
      _tmp0_ = vala_scanner_get_source_file (self->priv->scanner);
      _tmp1_ = vala_source_reference_new (_tmp0_, (*begin).line, (*begin).column, self->priv->tokens[last_index].end.line, self->priv->tokens[last_index].end.column);
      result = _tmp1_;
      return result;
}


static ValaSourceReference* vala_parser_get_current_src (ValaParser* self) {
      ValaSourceReference* result = NULL;
      ValaSourceFile* _tmp0_ = NULL;
      ValaSourceReference* _tmp1_ = NULL;
      g_return_val_if_fail (self != NULL, NULL);
      _tmp0_ = vala_scanner_get_source_file (self->priv->scanner);
      _tmp1_ = vala_source_reference_new (_tmp0_, self->priv->tokens[self->priv->index].begin.line, self->priv->tokens[self->priv->index].begin.column, self->priv->tokens[self->priv->index].end.line, self->priv->tokens[self->priv->index].end.column);
      result = _tmp1_;
      return result;
}


static ValaSourceReference* vala_parser_get_last_src (ValaParser* self) {
      ValaSourceReference* result = NULL;
      gint last_index;
      ValaSourceFile* _tmp0_ = NULL;
      ValaSourceReference* _tmp1_ = NULL;
      g_return_val_if_fail (self != NULL, NULL);
      last_index = ((self->priv->index + VALA_PARSER_BUFFER_SIZE) - 1) % VALA_PARSER_BUFFER_SIZE;
      _tmp0_ = vala_scanner_get_source_file (self->priv->scanner);
      _tmp1_ = vala_source_reference_new (_tmp0_, self->priv->tokens[last_index].begin.line, self->priv->tokens[last_index].begin.column, self->priv->tokens[last_index].end.line, self->priv->tokens[last_index].end.column);
      result = _tmp1_;
      return result;
}


static void vala_parser_rollback (ValaParser* self, ValaSourceLocation* location) {
      g_return_if_fail (self != NULL);
      while (TRUE) {
            if (!(self->priv->tokens[self->priv->index].begin.pos != (*location).pos)) {
                  break;
            }
            self->priv->index = ((self->priv->index - 1) + VALA_PARSER_BUFFER_SIZE) % VALA_PARSER_BUFFER_SIZE;
            self->priv->size++;
            if (self->priv->size > VALA_PARSER_BUFFER_SIZE) {
                  vala_scanner_seek (self->priv->scanner, location);
                  self->priv->size = 0;
                  self->priv->index = 0;
                  vala_parser_next (self);
            }
      }
}


static gchar string_get (const gchar* self, glong index) {
      gchar result = '\0';
      g_return_val_if_fail (self != NULL, '\0');
      result = ((gchar*) self)[index];
      return result;
}


static gboolean string_contains (const gchar* self, const gchar* needle) {
      gboolean result = FALSE;
      gchar* _tmp0_ = NULL;
      g_return_val_if_fail (self != NULL, FALSE);
      g_return_val_if_fail (needle != NULL, FALSE);
      _tmp0_ = strstr ((gchar*) self, (gchar*) needle);
      result = _tmp0_ != NULL;
      return result;
}


static void vala_parser_skip_identifier (ValaParser* self, GError** error) {
      ValaTokenType _tmp0_;
      GError * _inner_error_ = NULL;
      g_return_if_fail (self != NULL);
      _tmp0_ = vala_parser_current (self);
      switch (_tmp0_) {
            case VALA_TOKEN_TYPE_ABSTRACT:
            case VALA_TOKEN_TYPE_AS:
            case VALA_TOKEN_TYPE_ASYNC:
            case VALA_TOKEN_TYPE_BASE:
            case VALA_TOKEN_TYPE_BREAK:
            case VALA_TOKEN_TYPE_CASE:
            case VALA_TOKEN_TYPE_CATCH:
            case VALA_TOKEN_TYPE_CLASS:
            case VALA_TOKEN_TYPE_CONST:
            case VALA_TOKEN_TYPE_CONSTRUCT:
            case VALA_TOKEN_TYPE_CONTINUE:
            case VALA_TOKEN_TYPE_DEFAULT:
            case VALA_TOKEN_TYPE_DELEGATE:
            case VALA_TOKEN_TYPE_DELETE:
            case VALA_TOKEN_TYPE_DO:
            case VALA_TOKEN_TYPE_DYNAMIC:
            case VALA_TOKEN_TYPE_ELSE:
            case VALA_TOKEN_TYPE_ENUM:
            case VALA_TOKEN_TYPE_ENSURES:
            case VALA_TOKEN_TYPE_ERRORDOMAIN:
            case VALA_TOKEN_TYPE_EXTERN:
            case VALA_TOKEN_TYPE_FALSE:
            case VALA_TOKEN_TYPE_FINALLY:
            case VALA_TOKEN_TYPE_FOR:
            case VALA_TOKEN_TYPE_FOREACH:
            case VALA_TOKEN_TYPE_GET:
            case VALA_TOKEN_TYPE_IDENTIFIER:
            case VALA_TOKEN_TYPE_IF:
            case VALA_TOKEN_TYPE_IN:
            case VALA_TOKEN_TYPE_INLINE:
            case VALA_TOKEN_TYPE_INTERFACE:
            case VALA_TOKEN_TYPE_INTERNAL:
            case VALA_TOKEN_TYPE_IS:
            case VALA_TOKEN_TYPE_LOCK:
            case VALA_TOKEN_TYPE_NAMESPACE:
            case VALA_TOKEN_TYPE_NEW:
            case VALA_TOKEN_TYPE_NULL:
            case VALA_TOKEN_TYPE_OUT:
            case VALA_TOKEN_TYPE_OVERRIDE:
            case VALA_TOKEN_TYPE_OWNED:
            case VALA_TOKEN_TYPE_PARAMS:
            case VALA_TOKEN_TYPE_PRIVATE:
            case VALA_TOKEN_TYPE_PROTECTED:
            case VALA_TOKEN_TYPE_PUBLIC:
            case VALA_TOKEN_TYPE_REF:
            case VALA_TOKEN_TYPE_REQUIRES:
            case VALA_TOKEN_TYPE_RETURN:
            case VALA_TOKEN_TYPE_SEALED:
            case VALA_TOKEN_TYPE_SET:
            case VALA_TOKEN_TYPE_SIGNAL:
            case VALA_TOKEN_TYPE_SIZEOF:
            case VALA_TOKEN_TYPE_STATIC:
            case VALA_TOKEN_TYPE_STRUCT:
            case VALA_TOKEN_TYPE_SWITCH:
            case VALA_TOKEN_TYPE_THIS:
            case VALA_TOKEN_TYPE_THROW:
            case VALA_TOKEN_TYPE_THROWS:
            case VALA_TOKEN_TYPE_TRUE:
            case VALA_TOKEN_TYPE_TRY:
            case VALA_TOKEN_TYPE_TYPEOF:
            case VALA_TOKEN_TYPE_UNOWNED:
            case VALA_TOKEN_TYPE_USING:
            case VALA_TOKEN_TYPE_VAR:
            case VALA_TOKEN_TYPE_VIRTUAL:
            case VALA_TOKEN_TYPE_VOID:
            case VALA_TOKEN_TYPE_VOLATILE:
            case VALA_TOKEN_TYPE_WEAK:
            case VALA_TOKEN_TYPE_WHILE:
            case VALA_TOKEN_TYPE_YIELD:
            {
                  vala_parser_next (self);
                  return;
            }
            case VALA_TOKEN_TYPE_INTEGER_LITERAL:
            case VALA_TOKEN_TYPE_REAL_LITERAL:
            {
                  gchar* _tmp1_ = NULL;
                  gchar* id;
                  gboolean _tmp2_ = FALSE;
                  gint _tmp3_;
                  gchar _tmp4_;
                  gboolean _tmp5_;
                  _tmp1_ = vala_parser_get_current_string (self);
                  id = _tmp1_;
                  _tmp3_ = strlen (id);
                  _tmp4_ = string_get (id, (glong) (_tmp3_ - 1));
                  _tmp5_ = g_ascii_isalpha (_tmp4_);
                  if (_tmp5_) {
                        gboolean _tmp6_;
                        _tmp6_ = string_contains (id, ".");
                        _tmp2_ = !_tmp6_;
                  } else {
                        _tmp2_ = FALSE;
                  }
                  if (_tmp2_) {
                        vala_parser_next (self);
                        _g_free0 (id);
                        return;
                  }
                  _g_free0 (id);
                  break;
            }
            default:
            {
                  gchar* _tmp7_ = NULL;
                  gchar* _tmp8_;
                  GError* _tmp9_ = NULL;
                  GError* _tmp10_;
                  _tmp7_ = vala_parser_get_error (self, "expected identifier");
                  _tmp8_ = _tmp7_;
                  _tmp9_ = g_error_new_literal (VALA_PARSE_ERROR, VALA_PARSE_ERROR_SYNTAX, _tmp8_);
                  _tmp10_ = _tmp9_;
                  _g_free0 (_tmp8_);
                  _inner_error_ = _tmp10_;
                  if (_inner_error_->domain == VALA_PARSE_ERROR) {
                        g_propagate_error (error, _inner_error_);
                        return;
                  } else {
                        g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                        g_clear_error (&_inner_error_);
                        return;
                  }
            }
      }
}


static gchar* vala_parser_parse_identifier (ValaParser* self, GError** error) {
      gchar* result = NULL;
      gchar* _tmp0_ = NULL;
      GError * _inner_error_ = NULL;
      g_return_val_if_fail (self != NULL, NULL);
      vala_parser_skip_identifier (self, &_inner_error_);
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  return NULL;
            } else {
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      _tmp0_ = vala_parser_get_last_string (self);
      result = _tmp0_;
      return result;
}


static ValaExpression* vala_parser_parse_literal (ValaParser* self, GError** error) {
      ValaExpression* result = NULL;
      ValaSourceLocation _tmp0_ = {0};
      ValaSourceLocation _tmp1_ = {0};
      ValaSourceLocation begin;
      ValaTokenType _tmp2_;
      GError * _inner_error_ = NULL;
      g_return_val_if_fail (self != NULL, NULL);
      vala_parser_get_location (self, &_tmp0_);
      _tmp1_ = _tmp0_;
      begin = _tmp1_;
      _tmp2_ = vala_parser_current (self);
      switch (_tmp2_) {
            case VALA_TOKEN_TYPE_TRUE:
            {
                  ValaSourceReference* _tmp3_ = NULL;
                  ValaSourceReference* _tmp4_;
                  ValaBooleanLiteral* _tmp5_ = NULL;
                  ValaExpression* _tmp6_;
                  vala_parser_next (self);
                  _tmp3_ = vala_parser_get_src (self, &begin);
                  _tmp4_ = _tmp3_;
                  _tmp5_ = vala_boolean_literal_new (TRUE, _tmp4_);
                  _tmp6_ = (ValaExpression*) _tmp5_;
                  _vala_source_reference_unref0 (_tmp4_);
                  result = _tmp6_;
                  return result;
            }
            case VALA_TOKEN_TYPE_FALSE:
            {
                  ValaSourceReference* _tmp7_ = NULL;
                  ValaSourceReference* _tmp8_;
                  ValaBooleanLiteral* _tmp9_ = NULL;
                  ValaExpression* _tmp10_;
                  vala_parser_next (self);
                  _tmp7_ = vala_parser_get_src (self, &begin);
                  _tmp8_ = _tmp7_;
                  _tmp9_ = vala_boolean_literal_new (FALSE, _tmp8_);
                  _tmp10_ = (ValaExpression*) _tmp9_;
                  _vala_source_reference_unref0 (_tmp8_);
                  result = _tmp10_;
                  return result;
            }
            case VALA_TOKEN_TYPE_INTEGER_LITERAL:
            {
                  gchar* _tmp11_ = NULL;
                  gchar* _tmp12_;
                  ValaSourceReference* _tmp13_ = NULL;
                  ValaSourceReference* _tmp14_;
                  ValaIntegerLiteral* _tmp15_ = NULL;
                  ValaExpression* _tmp16_;
                  vala_parser_next (self);
                  _tmp11_ = vala_parser_get_last_string (self);
                  _tmp12_ = _tmp11_;
                  _tmp13_ = vala_parser_get_src (self, &begin);
                  _tmp14_ = _tmp13_;
                  _tmp15_ = vala_integer_literal_new (_tmp12_, _tmp14_);
                  _tmp16_ = (ValaExpression*) _tmp15_;
                  _vala_source_reference_unref0 (_tmp14_);
                  _g_free0 (_tmp12_);
                  result = _tmp16_;
                  return result;
            }
            case VALA_TOKEN_TYPE_REAL_LITERAL:
            {
                  gchar* _tmp17_ = NULL;
                  gchar* _tmp18_;
                  ValaSourceReference* _tmp19_ = NULL;
                  ValaSourceReference* _tmp20_;
                  ValaRealLiteral* _tmp21_ = NULL;
                  ValaExpression* _tmp22_;
                  vala_parser_next (self);
                  _tmp17_ = vala_parser_get_last_string (self);
                  _tmp18_ = _tmp17_;
                  _tmp19_ = vala_parser_get_src (self, &begin);
                  _tmp20_ = _tmp19_;
                  _tmp21_ = vala_real_literal_new (_tmp18_, _tmp20_);
                  _tmp22_ = (ValaExpression*) _tmp21_;
                  _vala_source_reference_unref0 (_tmp20_);
                  _g_free0 (_tmp18_);
                  result = _tmp22_;
                  return result;
            }
            case VALA_TOKEN_TYPE_CHARACTER_LITERAL:
            {
                  gchar* _tmp23_ = NULL;
                  gchar* _tmp24_;
                  ValaSourceReference* _tmp25_ = NULL;
                  ValaSourceReference* _tmp26_;
                  ValaCharacterLiteral* _tmp27_ = NULL;
                  ValaCharacterLiteral* _tmp28_;
                  ValaCharacterLiteral* lit;
                  gboolean _tmp29_;
                  vala_parser_next (self);
                  _tmp23_ = vala_parser_get_last_string (self);
                  _tmp24_ = _tmp23_;
                  _tmp25_ = vala_parser_get_src (self, &begin);
                  _tmp26_ = _tmp25_;
                  _tmp27_ = vala_character_literal_new (_tmp24_, _tmp26_);
                  _tmp28_ = _tmp27_;
                  _vala_source_reference_unref0 (_tmp26_);
                  _g_free0 (_tmp24_);
                  lit = _tmp28_;
                  _tmp29_ = vala_code_node_get_error ((ValaCodeNode*) lit);
                  if (_tmp29_) {
                        ValaSourceReference* _tmp30_ = NULL;
                        _tmp30_ = vala_code_node_get_source_reference ((ValaCodeNode*) lit);
                        vala_report_error (_tmp30_, "invalid character literal");
                  }
                  result = (ValaExpression*) lit;
                  return result;
            }
            case VALA_TOKEN_TYPE_REGEX_LITERAL:
            {
                  gchar* _tmp31_ = NULL;
                  gchar* match_part;
                  ValaSourceReference* _tmp32_ = NULL;
                  ValaSourceReference* src_begin;
                  gchar* _tmp33_ = NULL;
                  gchar* close_token;
                  gchar* _tmp34_ = NULL;
                  gchar* _tmp35_;
                  ValaRegexLiteral* _tmp36_ = NULL;
                  ValaExpression* _tmp37_;
                  vala_parser_next (self);
                  _tmp31_ = vala_parser_get_last_string (self);
                  match_part = _tmp31_;
                  _tmp32_ = vala_parser_get_src (self, &begin);
                  src_begin = _tmp32_;
                  vala_parser_expect (self, VALA_TOKEN_TYPE_CLOSE_REGEX_LITERAL, &_inner_error_);
                  if (_inner_error_ != NULL) {
                        if (_inner_error_->domain == VALA_PARSE_ERROR) {
                              g_propagate_error (error, _inner_error_);
                              _vala_source_reference_unref0 (src_begin);
                              _g_free0 (match_part);
                              return NULL;
                        } else {
                              _vala_source_reference_unref0 (src_begin);
                              _g_free0 (match_part);
                              g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                              g_clear_error (&_inner_error_);
                              return NULL;
                        }
                  }
                  _tmp33_ = vala_parser_get_last_string (self);
                  close_token = _tmp33_;
                  _tmp34_ = g_strdup_printf ("%s/%s", close_token, match_part);
                  _tmp35_ = _tmp34_;
                  _tmp36_ = vala_regex_literal_new (_tmp35_, src_begin);
                  _tmp37_ = (ValaExpression*) _tmp36_;
                  _g_free0 (_tmp35_);
                  result = _tmp37_;
                  _g_free0 (close_token);
                  _vala_source_reference_unref0 (src_begin);
                  _g_free0 (match_part);
                  return result;
            }
            case VALA_TOKEN_TYPE_STRING_LITERAL:
            {
                  gchar* _tmp38_ = NULL;
                  gchar* _tmp39_;
                  ValaSourceReference* _tmp40_ = NULL;
                  ValaSourceReference* _tmp41_;
                  ValaStringLiteral* _tmp42_ = NULL;
                  ValaExpression* _tmp43_;
                  vala_parser_next (self);
                  _tmp38_ = vala_parser_get_last_string (self);
                  _tmp39_ = _tmp38_;
                  _tmp40_ = vala_parser_get_src (self, &begin);
                  _tmp41_ = _tmp40_;
                  _tmp42_ = vala_string_literal_new (_tmp39_, _tmp41_);
                  _tmp43_ = (ValaExpression*) _tmp42_;
                  _vala_source_reference_unref0 (_tmp41_);
                  _g_free0 (_tmp39_);
                  result = _tmp43_;
                  return result;
            }
            case VALA_TOKEN_TYPE_TEMPLATE_STRING_LITERAL:
            {
                  gchar* _tmp44_ = NULL;
                  gchar* _tmp45_;
                  gchar* _tmp46_ = NULL;
                  gchar* _tmp47_;
                  ValaSourceReference* _tmp48_ = NULL;
                  ValaSourceReference* _tmp49_;
                  ValaStringLiteral* _tmp50_ = NULL;
                  ValaExpression* _tmp51_;
                  vala_parser_next (self);
                  _tmp44_ = vala_parser_get_last_string (self);
                  _tmp45_ = _tmp44_;
                  _tmp46_ = g_strdup_printf ("\"%s\"", _tmp45_);
                  _tmp47_ = _tmp46_;
                  _tmp48_ = vala_parser_get_src (self, &begin);
                  _tmp49_ = _tmp48_;
                  _tmp50_ = vala_string_literal_new (_tmp47_, _tmp49_);
                  _tmp51_ = (ValaExpression*) _tmp50_;
                  _vala_source_reference_unref0 (_tmp49_);
                  _g_free0 (_tmp47_);
                  _g_free0 (_tmp45_);
                  result = _tmp51_;
                  return result;
            }
            case VALA_TOKEN_TYPE_VERBATIM_STRING_LITERAL:
            {
                  gchar* _tmp52_ = NULL;
                  gchar* raw_string;
                  gint _tmp53_;
                  gchar* _tmp54_ = NULL;
                  gchar* _tmp55_;
                  gchar* _tmp56_ = NULL;
                  gchar* _tmp57_;
                  gchar* escaped_string;
                  gchar* _tmp58_ = NULL;
                  gchar* _tmp59_;
                  ValaSourceReference* _tmp60_ = NULL;
                  ValaSourceReference* _tmp61_;
                  ValaStringLiteral* _tmp62_ = NULL;
                  ValaExpression* _tmp63_;
                  vala_parser_next (self);
                  _tmp52_ = vala_parser_get_last_string (self);
                  raw_string = _tmp52_;
                  _tmp53_ = strlen (raw_string);
                  _tmp54_ = string_substring (raw_string, (glong) 3, (glong) (_tmp53_ - 6));
                  _tmp55_ = _tmp54_;
                  _tmp56_ = g_strescape (_tmp55_, "");
                  _tmp57_ = _tmp56_;
                  _g_free0 (_tmp55_);
                  escaped_string = _tmp57_;
                  _tmp58_ = g_strdup_printf ("\"%s\"", escaped_string);
                  _tmp59_ = _tmp58_;
                  _tmp60_ = vala_parser_get_src (self, &begin);
                  _tmp61_ = _tmp60_;
                  _tmp62_ = vala_string_literal_new (_tmp59_, _tmp61_);
                  _tmp63_ = (ValaExpression*) _tmp62_;
                  _vala_source_reference_unref0 (_tmp61_);
                  _g_free0 (_tmp59_);
                  result = _tmp63_;
                  _g_free0 (escaped_string);
                  _g_free0 (raw_string);
                  return result;
            }
            case VALA_TOKEN_TYPE_NULL:
            {
                  ValaSourceReference* _tmp64_ = NULL;
                  ValaSourceReference* _tmp65_;
                  ValaNullLiteral* _tmp66_ = NULL;
                  ValaExpression* _tmp67_;
                  vala_parser_next (self);
                  _tmp64_ = vala_parser_get_src (self, &begin);
                  _tmp65_ = _tmp64_;
                  _tmp66_ = vala_null_literal_new (_tmp65_);
                  _tmp67_ = (ValaExpression*) _tmp66_;
                  _vala_source_reference_unref0 (_tmp65_);
                  result = _tmp67_;
                  return result;
            }
            default:
            {
                  gchar* _tmp68_ = NULL;
                  gchar* _tmp69_;
                  GError* _tmp70_ = NULL;
                  GError* _tmp71_;
                  _tmp68_ = vala_parser_get_error (self, "expected literal");
                  _tmp69_ = _tmp68_;
                  _tmp70_ = g_error_new_literal (VALA_PARSE_ERROR, VALA_PARSE_ERROR_SYNTAX, _tmp69_);
                  _tmp71_ = _tmp70_;
                  _g_free0 (_tmp69_);
                  _inner_error_ = _tmp71_;
                  if (_inner_error_->domain == VALA_PARSE_ERROR) {
                        g_propagate_error (error, _inner_error_);
                        return NULL;
                  } else {
                        g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                        g_clear_error (&_inner_error_);
                        return NULL;
                  }
            }
      }
}


void vala_parser_parse_file (ValaParser* self, ValaSourceFile* source_file) {
      ValaScanner* _tmp0_ = NULL;
      GError * _inner_error_ = NULL;
      g_return_if_fail (self != NULL);
      g_return_if_fail (source_file != NULL);
      _tmp0_ = vala_scanner_new (source_file);
      _vala_scanner_unref0 (self->priv->scanner);
      self->priv->scanner = _tmp0_;
      vala_parser_parse_file_comments (self);
      self->priv->index = -1;
      self->priv->size = 0;
      vala_parser_next (self);
      {
            ValaNamespace* _tmp1_ = NULL;
            ValaNamespace* _tmp2_ = NULL;
            gboolean _tmp3_;
            _tmp1_ = vala_code_context_get_root (self->priv->context);
            vala_parser_parse_using_directives (self, _tmp1_, &_inner_error_);
            if (_inner_error_ != NULL) {
                  if (_inner_error_->domain == VALA_PARSE_ERROR) {
                        goto __catch9_vala_parse_error;
                  }
                  g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return;
            }
            _tmp2_ = vala_code_context_get_root (self->priv->context);
            vala_parser_parse_declarations (self, (ValaSymbol*) _tmp2_, TRUE, &_inner_error_);
            if (_inner_error_ != NULL) {
                  if (_inner_error_->domain == VALA_PARSE_ERROR) {
                        goto __catch9_vala_parse_error;
                  }
                  g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return;
            }
            _tmp3_ = vala_parser_accept (self, VALA_TOKEN_TYPE_CLOSE_BRACE);
            if (_tmp3_) {
                  ValaReport* _tmp4_ = NULL;
                  gint _tmp5_;
                  _tmp4_ = vala_code_context_get_report (self->priv->context);
                  _tmp5_ = vala_report_get_errors (_tmp4_);
                  if (_tmp5_ == 0) {
                        ValaSourceReference* _tmp6_ = NULL;
                        ValaSourceReference* _tmp7_;
                        _tmp6_ = vala_parser_get_last_src (self);
                        _tmp7_ = _tmp6_;
                        vala_report_error (_tmp7_, "unexpected `}'");
                        _vala_source_reference_unref0 (_tmp7_);
                  }
            }
      }
      goto __finally9;
      __catch9_vala_parse_error:
      {
            GError* e = NULL;
            e = _inner_error_;
            _inner_error_ = NULL;
            _g_error_free0 (e);
      }
      __finally9:
      if (_inner_error_ != NULL) {
            g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
            g_clear_error (&_inner_error_);
            return;
      }
      _vala_scanner_unref0 (self->priv->scanner);
      self->priv->scanner = NULL;
}


static void vala_parser_parse_file_comments (ValaParser* self) {
      g_return_if_fail (self != NULL);
      vala_scanner_parse_file_comments (self->priv->scanner);
}


static void vala_parser_skip_symbol_name (ValaParser* self, GError** error) {
      GError * _inner_error_ = NULL;
      g_return_if_fail (self != NULL);
      {
            gboolean _tmp0_;
            _tmp0_ = TRUE;
            while (TRUE) {
                  if (!_tmp0_) {
                        gboolean _tmp1_ = FALSE;
                        gboolean _tmp2_;
                        _tmp2_ = vala_parser_accept (self, VALA_TOKEN_TYPE_DOT);
                        if (_tmp2_) {
                              _tmp1_ = TRUE;
                        } else {
                              gboolean _tmp3_;
                              _tmp3_ = vala_parser_accept (self, VALA_TOKEN_TYPE_DOUBLE_COLON);
                              _tmp1_ = _tmp3_;
                        }
                        if (!_tmp1_) {
                              break;
                        }
                  }
                  _tmp0_ = FALSE;
                  vala_parser_skip_identifier (self, &_inner_error_);
                  if (_inner_error_ != NULL) {
                        if (_inner_error_->domain == VALA_PARSE_ERROR) {
                              g_propagate_error (error, _inner_error_);
                              return;
                        } else {
                              g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                              g_clear_error (&_inner_error_);
                              return;
                        }
                  }
            }
      }
}


static ValaUnresolvedSymbol* vala_parser_parse_symbol_name (ValaParser* self, GError** error) {
      ValaUnresolvedSymbol* result = NULL;
      ValaSourceLocation _tmp0_ = {0};
      ValaSourceLocation _tmp1_ = {0};
      ValaSourceLocation begin;
      ValaUnresolvedSymbol* sym;
      GError * _inner_error_ = NULL;
      g_return_val_if_fail (self != NULL, NULL);
      vala_parser_get_location (self, &_tmp0_);
      _tmp1_ = _tmp0_;
      begin = _tmp1_;
      sym = NULL;
      {
            gboolean _tmp2_;
            _tmp2_ = TRUE;
            while (TRUE) {
                  gchar* _tmp4_ = NULL;
                  gchar* name;
                  gboolean _tmp5_ = FALSE;
                  ValaSourceReference* _tmp12_ = NULL;
                  ValaSourceReference* _tmp13_;
                  ValaUnresolvedSymbol* _tmp14_ = NULL;
                  if (!_tmp2_) {
                        gboolean _tmp3_;
                        _tmp3_ = vala_parser_accept (self, VALA_TOKEN_TYPE_DOT);
                        if (!_tmp3_) {
                              break;
                        }
                  }
                  _tmp2_ = FALSE;
                  _tmp4_ = vala_parser_parse_identifier (self, &_inner_error_);
                  name = _tmp4_;
                  if (_inner_error_ != NULL) {
                        if (_inner_error_->domain == VALA_PARSE_ERROR) {
                              g_propagate_error (error, _inner_error_);
                              _vala_code_node_unref0 (sym);
                              return NULL;
                        } else {
                              _vala_code_node_unref0 (sym);
                              g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                              g_clear_error (&_inner_error_);
                              return NULL;
                        }
                  }
                  if (g_strcmp0 (name, "global") == 0) {
                        gboolean _tmp6_;
                        _tmp6_ = vala_parser_accept (self, VALA_TOKEN_TYPE_DOUBLE_COLON);
                        _tmp5_ = _tmp6_;
                  } else {
                        _tmp5_ = FALSE;
                  }
                  if (_tmp5_) {
                        gchar* _tmp7_ = NULL;
                        gchar* _tmp8_;
                        ValaSourceReference* _tmp9_ = NULL;
                        ValaSourceReference* _tmp10_;
                        ValaUnresolvedSymbol* _tmp11_ = NULL;
                        _tmp7_ = vala_parser_parse_identifier (self, &_inner_error_);
                        _tmp8_ = _tmp7_;
                        if (_inner_error_ != NULL) {
                              if (_inner_error_->domain == VALA_PARSE_ERROR) {
                                    g_propagate_error (error, _inner_error_);
                                    _g_free0 (name);
                                    _vala_code_node_unref0 (sym);
                                    return NULL;
                              } else {
                                    _g_free0 (name);
                                    _vala_code_node_unref0 (sym);
                                    g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                                    g_clear_error (&_inner_error_);
                                    return NULL;
                              }
                        }
                        _g_free0 (name);
                        name = _tmp8_;
                        _tmp9_ = vala_parser_get_src (self, &begin);
                        _tmp10_ = _tmp9_;
                        _tmp11_ = vala_unresolved_symbol_new (sym, name, _tmp10_);
                        _vala_code_node_unref0 (sym);
                        sym = _tmp11_;
                        _vala_source_reference_unref0 (_tmp10_);
                        vala_unresolved_symbol_set_qualified (sym, TRUE);
                        _g_free0 (name);
                        continue;
                  }
                  _tmp12_ = vala_parser_get_src (self, &begin);
                  _tmp13_ = _tmp12_;
                  _tmp14_ = vala_unresolved_symbol_new (sym, name, _tmp13_);
                  _vala_code_node_unref0 (sym);
                  sym = _tmp14_;
                  _vala_source_reference_unref0 (_tmp13_);
                  _g_free0 (name);
            }
      }
      result = sym;
      return result;
}


static void vala_parser_skip_type (ValaParser* self, GError** error) {
      gboolean _tmp0_;
      GError * _inner_error_ = NULL;
      g_return_if_fail (self != NULL);
      vala_parser_accept (self, VALA_TOKEN_TYPE_DYNAMIC);
      vala_parser_accept (self, VALA_TOKEN_TYPE_OWNED);
      vala_parser_accept (self, VALA_TOKEN_TYPE_UNOWNED);
      vala_parser_accept (self, VALA_TOKEN_TYPE_WEAK);
      _tmp0_ = vala_parser_accept (self, VALA_TOKEN_TYPE_VOID);
      if (_tmp0_) {
      } else {
            vala_parser_skip_symbol_name (self, &_inner_error_);
            if (_inner_error_ != NULL) {
                  if (_inner_error_->domain == VALA_PARSE_ERROR) {
                        g_propagate_error (error, _inner_error_);
                        return;
                  } else {
                        g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                        g_clear_error (&_inner_error_);
                        return;
                  }
            }
            vala_parser_skip_type_argument_list (self, &_inner_error_);
            if (_inner_error_ != NULL) {
                  if (_inner_error_->domain == VALA_PARSE_ERROR) {
                        g_propagate_error (error, _inner_error_);
                        return;
                  } else {
                        g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                        g_clear_error (&_inner_error_);
                        return;
                  }
            }
      }
      while (TRUE) {
            gboolean _tmp1_;
            _tmp1_ = vala_parser_accept (self, VALA_TOKEN_TYPE_STAR);
            if (!_tmp1_) {
                  break;
            }
      }
      vala_parser_accept (self, VALA_TOKEN_TYPE_INTERR);
      while (TRUE) {
            gboolean _tmp2_;
            _tmp2_ = vala_parser_accept (self, VALA_TOKEN_TYPE_OPEN_BRACKET);
            if (!_tmp2_) {
                  break;
            }
            {
                  gboolean _tmp3_;
                  _tmp3_ = TRUE;
                  while (TRUE) {
                        gboolean _tmp5_ = FALSE;
                        ValaTokenType _tmp6_;
                        if (!_tmp3_) {
                              gboolean _tmp4_;
                              _tmp4_ = vala_parser_accept (self, VALA_TOKEN_TYPE_COMMA);
                              if (!_tmp4_) {
                                    break;
                              }
                        }
                        _tmp3_ = FALSE;
                        _tmp6_ = vala_parser_current (self);
                        if (_tmp6_ != VALA_TOKEN_TYPE_COMMA) {
                              ValaTokenType _tmp7_;
                              _tmp7_ = vala_parser_current (self);
                              _tmp5_ = _tmp7_ != VALA_TOKEN_TYPE_CLOSE_BRACKET;
                        } else {
                              _tmp5_ = FALSE;
                        }
                        if (_tmp5_) {
                              ValaExpression* _tmp8_ = NULL;
                              ValaExpression* _tmp9_;
                              _tmp8_ = vala_parser_parse_expression (self, &_inner_error_);
                              _tmp9_ = _tmp8_;
                              _vala_code_node_unref0 (_tmp9_);
                              if (_inner_error_ != NULL) {
                                    if (_inner_error_->domain == VALA_PARSE_ERROR) {
                                          g_propagate_error (error, _inner_error_);
                                          return;
                                    } else {
                                          g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                                          g_clear_error (&_inner_error_);
                                          return;
                                    }
                              }
                        }
                  }
            }
            vala_parser_expect (self, VALA_TOKEN_TYPE_CLOSE_BRACKET, &_inner_error_);
            if (_inner_error_ != NULL) {
                  if (_inner_error_->domain == VALA_PARSE_ERROR) {
                        g_propagate_error (error, _inner_error_);
                        return;
                  } else {
                        g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                        g_clear_error (&_inner_error_);
                        return;
                  }
            }
            vala_parser_accept (self, VALA_TOKEN_TYPE_INTERR);
      }
      vala_parser_accept (self, VALA_TOKEN_TYPE_OP_NEG);
      vala_parser_accept (self, VALA_TOKEN_TYPE_HASH);
}


static gpointer _vala_iterable_ref0 (gpointer self) {
      return self ? vala_iterable_ref (self) : NULL;
}


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


static ValaDataType* vala_parser_parse_type (ValaParser* self, gboolean owned_by_default, gboolean can_weak_ref, GError** error) {
      ValaDataType* result = NULL;
      ValaSourceLocation _tmp0_ = {0};
      ValaSourceLocation _tmp1_ = {0};
      ValaSourceLocation begin;
      gboolean _tmp2_;
      gboolean is_dynamic;
      gboolean value_owned;
      ValaDataType* type = NULL;
      gboolean _tmp15_ = FALSE;
      gboolean _tmp16_ = FALSE;
      gboolean _tmp50_;
      GError * _inner_error_ = NULL;
      g_return_val_if_fail (self != NULL, NULL);
      vala_parser_get_location (self, &_tmp0_);
      _tmp1_ = _tmp0_;
      begin = _tmp1_;
      _tmp2_ = vala_parser_accept (self, VALA_TOKEN_TYPE_DYNAMIC);
      is_dynamic = _tmp2_;
      value_owned = owned_by_default;
      if (owned_by_default) {
            ValaProfile _tmp3_;
            _tmp3_ = vala_code_context_get_profile (self->priv->context);
            if (_tmp3_ == VALA_PROFILE_DOVA) {
                  gboolean _tmp4_ = FALSE;
                  if (can_weak_ref) {
                        gboolean _tmp5_;
                        _tmp5_ = vala_parser_accept (self, VALA_TOKEN_TYPE_WEAK);
                        _tmp4_ = _tmp5_;
                  } else {
                        _tmp4_ = FALSE;
                  }
                  if (_tmp4_) {
                        value_owned = FALSE;
                  }
            } else {
                  gboolean _tmp6_;
                  _tmp6_ = vala_parser_accept (self, VALA_TOKEN_TYPE_UNOWNED);
                  if (_tmp6_) {
                        value_owned = FALSE;
                  } else {
                        gboolean _tmp7_;
                        _tmp7_ = vala_parser_accept (self, VALA_TOKEN_TYPE_WEAK);
                        if (_tmp7_) {
                              gboolean _tmp8_ = FALSE;
                              if (!can_weak_ref) {
                                    gboolean _tmp9_;
                                    _tmp9_ = vala_code_context_get_deprecated (self->priv->context);
                                    _tmp8_ = !_tmp9_;
                              } else {
                                    _tmp8_ = FALSE;
                              }
                              if (_tmp8_) {
                                    ValaSourceReference* _tmp10_ = NULL;
                                    ValaSourceReference* _tmp11_;
                                    _tmp10_ = vala_parser_get_last_src (self);
                                    _tmp11_ = _tmp10_;
                                    vala_report_warning (_tmp11_, "deprecated syntax, use `unowned` modifier");
                                    _vala_source_reference_unref0 (_tmp11_);
                              }
                              value_owned = FALSE;
                        }
                  }
            }
      } else {
            gboolean _tmp12_ = FALSE;
            ValaProfile _tmp13_;
            _tmp13_ = vala_code_context_get_profile (self->priv->context);
            if (_tmp13_ != VALA_PROFILE_DOVA) {
                  gboolean _tmp14_;
                  _tmp14_ = vala_parser_accept (self, VALA_TOKEN_TYPE_OWNED);
                  _tmp12_ = _tmp14_;
            } else {
                  _tmp12_ = FALSE;
            }
            value_owned = _tmp12_;
      }
      if (!is_dynamic) {
            _tmp16_ = value_owned == owned_by_default;
      } else {
            _tmp16_ = FALSE;
      }
      if (_tmp16_) {
            gboolean _tmp17_;
            _tmp17_ = vala_parser_accept (self, VALA_TOKEN_TYPE_VOID);
            _tmp15_ = _tmp17_;
      } else {
            _tmp15_ = FALSE;
      }
      if (_tmp15_) {
            ValaSourceReference* _tmp18_ = NULL;
            ValaSourceReference* _tmp19_;
            ValaVoidType* _tmp20_ = NULL;
            _tmp18_ = vala_parser_get_src (self, &begin);
            _tmp19_ = _tmp18_;
            _tmp20_ = vala_void_type_new (_tmp19_);
            _vala_code_node_unref0 (type);
            type = (ValaDataType*) _tmp20_;
            _vala_source_reference_unref0 (_tmp19_);
      } else {
            ValaUnresolvedSymbol* _tmp21_ = NULL;
            ValaUnresolvedSymbol* sym;
            ValaList* _tmp22_ = NULL;
            ValaList* type_arg_list;
            ValaSourceReference* _tmp23_ = NULL;
            ValaSourceReference* _tmp24_;
            ValaUnresolvedType* _tmp25_ = NULL;
            _tmp21_ = vala_parser_parse_symbol_name (self, &_inner_error_);
            sym = _tmp21_;
            if (_inner_error_ != NULL) {
                  if (_inner_error_->domain == VALA_PARSE_ERROR) {
                        g_propagate_error (error, _inner_error_);
                        _vala_code_node_unref0 (type);
                        return NULL;
                  } else {
                        _vala_code_node_unref0 (type);
                        g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                        g_clear_error (&_inner_error_);
                        return NULL;
                  }
            }
            _tmp22_ = vala_parser_parse_type_argument_list (self, FALSE, &_inner_error_);
            type_arg_list = _tmp22_;
            if (_inner_error_ != NULL) {
                  if (_inner_error_->domain == VALA_PARSE_ERROR) {
                        g_propagate_error (error, _inner_error_);
                        _vala_code_node_unref0 (sym);
                        _vala_code_node_unref0 (type);
                        return NULL;
                  } else {
                        _vala_code_node_unref0 (sym);
                        _vala_code_node_unref0 (type);
                        g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                        g_clear_error (&_inner_error_);
                        return NULL;
                  }
            }
            _tmp23_ = vala_parser_get_src (self, &begin);
            _tmp24_ = _tmp23_;
            _tmp25_ = vala_unresolved_type_new_from_symbol (sym, _tmp24_);
            _vala_code_node_unref0 (type);
            type = (ValaDataType*) _tmp25_;
            _vala_source_reference_unref0 (_tmp24_);
            if (type_arg_list != NULL) {
                  {
                        ValaList* _tmp26_;
                        ValaList* _type_arg_list;
                        gint _tmp27_;
                        gint _type_arg_size;
                        gint _type_arg_index;
                        _tmp26_ = _vala_iterable_ref0 (type_arg_list);
                        _type_arg_list = _tmp26_;
                        _tmp27_ = vala_collection_get_size ((ValaCollection*) _type_arg_list);
                        _type_arg_size = _tmp27_;
                        _type_arg_index = -1;
                        while (TRUE) {
                              gpointer _tmp28_ = NULL;
                              ValaDataType* type_arg;
                              _type_arg_index = _type_arg_index + 1;
                              if (!(_type_arg_index < _type_arg_size)) {
                                    break;
                              }
                              _tmp28_ = vala_list_get (_type_arg_list, _type_arg_index);
                              type_arg = (ValaDataType*) _tmp28_;
                              vala_data_type_add_type_argument (type, type_arg);
                              _vala_code_node_unref0 (type_arg);
                        }
                        _vala_iterable_unref0 (_type_arg_list);
                  }
            }
            _vala_iterable_unref0 (type_arg_list);
            _vala_code_node_unref0 (sym);
      }
      while (TRUE) {
            gboolean _tmp29_;
            ValaSourceReference* _tmp30_ = NULL;
            ValaSourceReference* _tmp31_;
            ValaPointerType* _tmp32_ = NULL;
            _tmp29_ = vala_parser_accept (self, VALA_TOKEN_TYPE_STAR);
            if (!_tmp29_) {
                  break;
            }
            _tmp30_ = vala_parser_get_src (self, &begin);
            _tmp31_ = _tmp30_;
            _tmp32_ = vala_pointer_type_new (type, _tmp31_);
            _vala_code_node_unref0 (type);
            type = (ValaDataType*) _tmp32_;
            _vala_source_reference_unref0 (_tmp31_);
      }
      if (!VALA_IS_POINTER_TYPE (type)) {
            gboolean _tmp33_;
            _tmp33_ = vala_parser_accept (self, VALA_TOKEN_TYPE_INTERR);
            vala_data_type_set_nullable (type, _tmp33_);
      }
      while (TRUE) {
            gboolean _tmp34_;
            gboolean invalid_array;
            gint array_rank;
            ValaSourceReference* _tmp44_ = NULL;
            ValaSourceReference* _tmp45_;
            ValaArrayType* _tmp46_ = NULL;
            ValaArrayType* _tmp47_;
            ValaArrayType* array_type;
            gboolean _tmp48_;
            ValaDataType* _tmp49_;
            _tmp34_ = vala_parser_accept (self, VALA_TOKEN_TYPE_OPEN_BRACKET);
            if (!_tmp34_) {
                  break;
            }
            invalid_array = FALSE;
            array_rank = 0;
            {
                  gboolean _tmp35_;
                  _tmp35_ = TRUE;
                  while (TRUE) {
                        gboolean _tmp39_ = FALSE;
                        ValaTokenType _tmp40_;
                        if (!_tmp35_) {
                              gboolean _tmp36_ = FALSE;
                              ValaProfile _tmp37_;
                              _tmp37_ = vala_code_context_get_profile (self->priv->context);
                              if (_tmp37_ != VALA_PROFILE_DOVA) {
                                    gboolean _tmp38_;
                                    _tmp38_ = vala_parser_accept (self, VALA_TOKEN_TYPE_COMMA);
                                    _tmp36_ = _tmp38_;
                              } else {
                                    _tmp36_ = FALSE;
                              }
                              if (!_tmp36_) {
                                    break;
                              }
                        }
                        _tmp35_ = FALSE;
                        array_rank++;
                        _tmp40_ = vala_parser_current (self);
                        if (_tmp40_ != VALA_TOKEN_TYPE_COMMA) {
                              ValaTokenType _tmp41_;
                              _tmp41_ = vala_parser_current (self);
                              _tmp39_ = _tmp41_ != VALA_TOKEN_TYPE_CLOSE_BRACKET;
                        } else {
                              _tmp39_ = FALSE;
                        }
                        if (_tmp39_) {
                              ValaExpression* _tmp42_ = NULL;
                              ValaExpression* _tmp43_;
                              _tmp42_ = vala_parser_parse_expression (self, &_inner_error_);
                              _tmp43_ = _tmp42_;
                              _vala_code_node_unref0 (_tmp43_);
                              if (_inner_error_ != NULL) {
                                    if (_inner_error_->domain == VALA_PARSE_ERROR) {
                                          g_propagate_error (error, _inner_error_);
                                          _vala_code_node_unref0 (type);
                                          return NULL;
                                    } else {
                                          _vala_code_node_unref0 (type);
                                          g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                                          g_clear_error (&_inner_error_);
                                          return NULL;
                                    }
                              }
                              invalid_array = TRUE;
                        }
                  }
            }
            vala_parser_expect (self, VALA_TOKEN_TYPE_CLOSE_BRACKET, &_inner_error_);
            if (_inner_error_ != NULL) {
                  if (_inner_error_->domain == VALA_PARSE_ERROR) {
                        g_propagate_error (error, _inner_error_);
                        _vala_code_node_unref0 (type);
                        return NULL;
                  } else {
                        _vala_code_node_unref0 (type);
                        g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                        g_clear_error (&_inner_error_);
                        return NULL;
                  }
            }
            vala_data_type_set_value_owned (type, TRUE);
            _tmp44_ = vala_parser_get_src (self, &begin);
            _tmp45_ = _tmp44_;
            _tmp46_ = vala_array_type_new (type, array_rank, _tmp45_);
            _tmp47_ = _tmp46_;
            _vala_source_reference_unref0 (_tmp45_);
            array_type = _tmp47_;
            _tmp48_ = vala_parser_accept (self, VALA_TOKEN_TYPE_INTERR);
            vala_data_type_set_nullable ((ValaDataType*) array_type, _tmp48_);
            vala_array_type_set_invalid_syntax (array_type, invalid_array);
            _tmp49_ = _vala_code_node_ref0 ((ValaDataType*) array_type);
            _vala_code_node_unref0 (type);
            type = _tmp49_;
            _vala_code_node_unref0 (array_type);
      }
      _tmp50_ = vala_parser_accept (self, VALA_TOKEN_TYPE_OP_NEG);
      if (_tmp50_) {
            ValaSourceReference* _tmp51_ = NULL;
            ValaSourceReference* _tmp52_;
            _tmp51_ = vala_parser_get_last_src (self);
            _tmp52_ = _tmp51_;
            vala_report_warning (_tmp52_, "obsolete syntax, types are non-null by default");
            _vala_source_reference_unref0 (_tmp52_);
      }
      if (!owned_by_default) {
            gboolean _tmp53_ = FALSE;
            ValaProfile _tmp54_;
            _tmp54_ = vala_code_context_get_profile (self->priv->context);
            if (_tmp54_ != VALA_PROFILE_DOVA) {
                  gboolean _tmp55_;
                  _tmp55_ = vala_parser_accept (self, VALA_TOKEN_TYPE_HASH);
                  _tmp53_ = _tmp55_;
            } else {
                  _tmp53_ = FALSE;
            }
            if (_tmp53_) {
                  gboolean _tmp56_;
                  _tmp56_ = vala_code_context_get_deprecated (self->priv->context);
                  if (!_tmp56_) {
                        ValaSourceReference* _tmp57_ = NULL;
                        ValaSourceReference* _tmp58_;
                        _tmp57_ = vala_parser_get_last_src (self);
                        _tmp58_ = _tmp57_;
                        vala_report_warning (_tmp58_, "deprecated syntax, use `owned` modifier");
                        _vala_source_reference_unref0 (_tmp58_);
                  }
                  value_owned = TRUE;
            }
      }
      if (VALA_IS_POINTER_TYPE (type)) {
            value_owned = FALSE;
      }
      vala_data_type_set_is_dynamic (type, is_dynamic);
      vala_data_type_set_value_owned (type, value_owned);
      result = type;
      return result;
}


static ValaDataType* vala_parser_parse_inline_array_type (ValaParser* self, ValaDataType* type, GError** error) {
      ValaDataType* result = NULL;
      ValaSourceLocation _tmp0_ = {0};
      ValaSourceLocation _tmp1_ = {0};
      ValaSourceLocation begin;
      gboolean _tmp2_ = FALSE;
      ValaDataType* _tmp19_;
      GError * _inner_error_ = NULL;
      g_return_val_if_fail (self != NULL, NULL);
      vala_parser_get_location (self, &_tmp0_);
      _tmp1_ = _tmp0_;
      begin = _tmp1_;
      if (type != NULL) {
            gboolean _tmp3_;
            _tmp3_ = vala_parser_accept (self, VALA_TOKEN_TYPE_OPEN_BRACKET);
            _tmp2_ = _tmp3_;
      } else {
            _tmp2_ = FALSE;
      }
      if (_tmp2_) {
            gint array_length;
            ValaTokenType _tmp4_;
            ValaSourceReference* _tmp14_ = NULL;
            ValaSourceReference* _tmp15_;
            ValaArrayType* _tmp16_ = NULL;
            ValaArrayType* _tmp17_;
            ValaArrayType* array_type;
            gboolean _tmp18_;
            array_length = -1;
            _tmp4_ = vala_parser_current (self);
            if (_tmp4_ != VALA_TOKEN_TYPE_CLOSE_BRACKET) {
                  ValaTokenType _tmp5_;
                  ValaExpression* _tmp10_ = NULL;
                  ValaExpression* _tmp11_;
                  ValaIntegerLiteral* length_literal;
                  const gchar* _tmp12_ = NULL;
                  gint _tmp13_;
                  _tmp5_ = vala_parser_current (self);
                  if (_tmp5_ != VALA_TOKEN_TYPE_INTEGER_LITERAL) {
                        gchar* _tmp6_ = NULL;
                        gchar* _tmp7_;
                        GError* _tmp8_ = NULL;
                        GError* _tmp9_;
                        _tmp6_ = vala_parser_get_error (self, "expected `]' or integer literal");
                        _tmp7_ = _tmp6_;
                        _tmp8_ = g_error_new_literal (VALA_PARSE_ERROR, VALA_PARSE_ERROR_SYNTAX, _tmp7_);
                        _tmp9_ = _tmp8_;
                        _g_free0 (_tmp7_);
                        _inner_error_ = _tmp9_;
                        if (_inner_error_->domain == VALA_PARSE_ERROR) {
                              g_propagate_error (error, _inner_error_);
                              return NULL;
                        } else {
                              g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                              g_clear_error (&_inner_error_);
                              return NULL;
                        }
                  }
                  _tmp10_ = vala_parser_parse_literal (self, &_inner_error_);
                  _tmp11_ = _tmp10_;
                  if (_inner_error_ != NULL) {
                        if (_inner_error_->domain == VALA_PARSE_ERROR) {
                              g_propagate_error (error, _inner_error_);
                              return NULL;
                        } else {
                              g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                              g_clear_error (&_inner_error_);
                              return NULL;
                        }
                  }
                  length_literal = VALA_INTEGER_LITERAL (_tmp11_);
                  _tmp12_ = vala_integer_literal_get_value (length_literal);
                  _tmp13_ = atoi (_tmp12_);
                  array_length = _tmp13_;
                  _vala_code_node_unref0 (length_literal);
            }
            vala_parser_expect (self, VALA_TOKEN_TYPE_CLOSE_BRACKET, &_inner_error_);
            if (_inner_error_ != NULL) {
                  if (_inner_error_->domain == VALA_PARSE_ERROR) {
                        g_propagate_error (error, _inner_error_);
                        return NULL;
                  } else {
                        g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                        g_clear_error (&_inner_error_);
                        return NULL;
                  }
            }
            _tmp14_ = vala_parser_get_src (self, &begin);
            _tmp15_ = _tmp14_;
            _tmp16_ = vala_array_type_new (type, 1, _tmp15_);
            _tmp17_ = _tmp16_;
            _vala_source_reference_unref0 (_tmp15_);
            array_type = _tmp17_;
            vala_array_type_set_inline_allocated (array_type, TRUE);
            if (array_length > 0) {
                  vala_array_type_set_fixed_length (array_type, TRUE);
                  vala_array_type_set_length (array_type, array_length);
            }
            _tmp18_ = vala_data_type_get_value_owned (type);
            vala_data_type_set_value_owned ((ValaDataType*) array_type, _tmp18_);
            result = (ValaDataType*) array_type;
            return result;
      }
      _tmp19_ = _vala_code_node_ref0 (type);
      result = _tmp19_;
      return result;
}


static ValaList* vala_parser_parse_argument_list (ValaParser* self, GError** error) {
      ValaList* result = NULL;
      ValaArrayList* _tmp0_ = NULL;
      ValaArrayList* list;
      ValaTokenType _tmp1_;
      GError * _inner_error_ = NULL;
      g_return_val_if_fail (self != NULL, NULL);
      _tmp0_ = vala_array_list_new (VALA_TYPE_EXPRESSION, (GBoxedCopyFunc) vala_code_node_ref, vala_code_node_unref, g_direct_equal);
      list = _tmp0_;
      _tmp1_ = vala_parser_current (self);
      if (_tmp1_ != VALA_TOKEN_TYPE_CLOSE_PARENS) {
            {
                  gboolean _tmp2_;
                  _tmp2_ = TRUE;
                  while (TRUE) {
                        ValaExpression* _tmp4_ = NULL;
                        ValaExpression* _tmp5_;
                        ValaExpression* _tmp6_;
                        if (!_tmp2_) {
                              gboolean _tmp3_;
                              _tmp3_ = vala_parser_accept (self, VALA_TOKEN_TYPE_COMMA);
                              if (!_tmp3_) {
                                    break;
                              }
                        }
                        _tmp2_ = FALSE;
                        _tmp4_ = vala_parser_parse_argument (self, &_inner_error_);
                        _tmp5_ = _tmp4_;
                        if (_inner_error_ != NULL) {
                              if (_inner_error_->domain == VALA_PARSE_ERROR) {
                                    g_propagate_error (error, _inner_error_);
                                    _vala_iterable_unref0 (list);
                                    return NULL;
                              } else {
                                    _vala_iterable_unref0 (list);
                                    g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                                    g_clear_error (&_inner_error_);
                                    return NULL;
                              }
                        }
                        _tmp6_ = _tmp5_;
                        vala_collection_add ((ValaCollection*) list, _tmp6_);
                        _vala_code_node_unref0 (_tmp6_);
                  }
            }
      }
      result = (ValaList*) list;
      return result;
}


static ValaExpression* vala_parser_parse_argument (ValaParser* self, GError** error) {
      ValaExpression* result = NULL;
      ValaSourceLocation _tmp0_ = {0};
      ValaSourceLocation _tmp1_ = {0};
      ValaSourceLocation begin;
      gboolean _tmp2_;
      GError * _inner_error_ = NULL;
      g_return_val_if_fail (self != NULL, NULL);
      vala_parser_get_location (self, &_tmp0_);
      _tmp1_ = _tmp0_;
      begin = _tmp1_;
      _tmp2_ = vala_parser_accept (self, VALA_TOKEN_TYPE_REF);
      if (_tmp2_) {
            ValaExpression* _tmp3_ = NULL;
            ValaExpression* inner;
            ValaSourceReference* _tmp4_ = NULL;
            ValaSourceReference* _tmp5_;
            ValaUnaryExpression* _tmp6_ = NULL;
            ValaExpression* _tmp7_;
            _tmp3_ = vala_parser_parse_expression (self, &_inner_error_);
            inner = _tmp3_;
            if (_inner_error_ != NULL) {
                  if (_inner_error_->domain == VALA_PARSE_ERROR) {
                        g_propagate_error (error, _inner_error_);
                        return NULL;
                  } else {
                        g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                        g_clear_error (&_inner_error_);
                        return NULL;
                  }
            }
            _tmp4_ = vala_parser_get_src (self, &begin);
            _tmp5_ = _tmp4_;
            _tmp6_ = vala_unary_expression_new (VALA_UNARY_OPERATOR_REF, inner, _tmp5_);
            _tmp7_ = (ValaExpression*) _tmp6_;
            _vala_source_reference_unref0 (_tmp5_);
            result = _tmp7_;
            _vala_code_node_unref0 (inner);
            return result;
      } else {
            gboolean _tmp8_;
            _tmp8_ = vala_parser_accept (self, VALA_TOKEN_TYPE_OUT);
            if (_tmp8_) {
                  ValaExpression* _tmp9_ = NULL;
                  ValaExpression* inner;
                  ValaSourceReference* _tmp10_ = NULL;
                  ValaSourceReference* _tmp11_;
                  ValaUnaryExpression* _tmp12_ = NULL;
                  ValaExpression* _tmp13_;
                  _tmp9_ = vala_parser_parse_expression (self, &_inner_error_);
                  inner = _tmp9_;
                  if (_inner_error_ != NULL) {
                        if (_inner_error_->domain == VALA_PARSE_ERROR) {
                              g_propagate_error (error, _inner_error_);
                              return NULL;
                        } else {
                              g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                              g_clear_error (&_inner_error_);
                              return NULL;
                        }
                  }
                  _tmp10_ = vala_parser_get_src (self, &begin);
                  _tmp11_ = _tmp10_;
                  _tmp12_ = vala_unary_expression_new (VALA_UNARY_OPERATOR_OUT, inner, _tmp11_);
                  _tmp13_ = (ValaExpression*) _tmp12_;
                  _vala_source_reference_unref0 (_tmp11_);
                  result = _tmp13_;
                  _vala_code_node_unref0 (inner);
                  return result;
            } else {
                  ValaExpression* _tmp14_ = NULL;
                  ValaExpression* expr;
                  ValaExpression* _tmp15_;
                  ValaMemberAccess* _tmp16_;
                  ValaMemberAccess* ma;
                  gboolean _tmp17_ = FALSE;
                  gboolean _tmp18_ = FALSE;
                  _tmp14_ = vala_parser_parse_expression (self, &_inner_error_);
                  expr = _tmp14_;
                  if (_inner_error_ != NULL) {
                        if (_inner_error_->domain == VALA_PARSE_ERROR) {
                              g_propagate_error (error, _inner_error_);
                              return NULL;
                        } else {
                              g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                              g_clear_error (&_inner_error_);
                              return NULL;
                        }
                  }
                  _tmp15_ = expr;
                  _tmp16_ = _vala_code_node_ref0 (VALA_IS_MEMBER_ACCESS (_tmp15_) ? ((ValaMemberAccess*) _tmp15_) : NULL);
                  ma = _tmp16_;
                  if (ma != NULL) {
                        ValaExpression* _tmp19_ = NULL;
                        _tmp19_ = vala_member_access_get_inner (ma);
                        _tmp18_ = _tmp19_ == NULL;
                  } else {
                        _tmp18_ = FALSE;
                  }
                  if (_tmp18_) {
                        gboolean _tmp20_;
                        _tmp20_ = vala_parser_accept (self, VALA_TOKEN_TYPE_COLON);
                        _tmp17_ = _tmp20_;
                  } else {
                        _tmp17_ = FALSE;
                  }
                  if (_tmp17_) {
                        ValaExpression* _tmp21_ = NULL;
                        ValaExpression* _tmp22_;
                        const gchar* _tmp23_ = NULL;
                        ValaSourceReference* _tmp24_ = NULL;
                        ValaSourceReference* _tmp25_;
                        ValaNamedArgument* _tmp26_ = NULL;
                        ValaExpression* _tmp27_;
                        _tmp21_ = vala_parser_parse_expression (self, &_inner_error_);
                        _tmp22_ = _tmp21_;
                        if (_inner_error_ != NULL) {
                              if (_inner_error_->domain == VALA_PARSE_ERROR) {
                                    g_propagate_error (error, _inner_error_);
                                    _vala_code_node_unref0 (ma);
                                    _vala_code_node_unref0 (expr);
                                    return NULL;
                              } else {
                                    _vala_code_node_unref0 (ma);
                                    _vala_code_node_unref0 (expr);
                                    g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                                    g_clear_error (&_inner_error_);
                                    return NULL;
                              }
                        }
                        _vala_code_node_unref0 (expr);
                        expr = _tmp22_;
                        _tmp23_ = vala_member_access_get_member_name (ma);
                        _tmp24_ = vala_parser_get_src (self, &begin);
                        _tmp25_ = _tmp24_;
                        _tmp26_ = vala_named_argument_new (_tmp23_, expr, _tmp25_);
                        _tmp27_ = (ValaExpression*) _tmp26_;
                        _vala_source_reference_unref0 (_tmp25_);
                        result = _tmp27_;
                        _vala_code_node_unref0 (ma);
                        _vala_code_node_unref0 (expr);
                        return result;
                  } else {
                        result = expr;
                        _vala_code_node_unref0 (ma);
                        return result;
                  }
                  _vala_code_node_unref0 (ma);
                  _vala_code_node_unref0 (expr);
            }
      }
}


static ValaExpression* vala_parser_parse_primary_expression (ValaParser* self, GError** error) {
      ValaExpression* result = NULL;
      ValaSourceLocation _tmp0_ = {0};
      ValaSourceLocation _tmp1_ = {0};
      ValaSourceLocation begin;
      ValaExpression* expr = NULL;
      ValaTokenType _tmp2_;
      gboolean found;
      GError * _inner_error_ = NULL;
      g_return_val_if_fail (self != NULL, NULL);
      vala_parser_get_location (self, &_tmp0_);
      _tmp1_ = _tmp0_;
      begin = _tmp1_;
      _tmp2_ = vala_parser_current (self);
      switch (_tmp2_) {
            case VALA_TOKEN_TYPE_TRUE:
            case VALA_TOKEN_TYPE_FALSE:
            case VALA_TOKEN_TYPE_INTEGER_LITERAL:
            case VALA_TOKEN_TYPE_REAL_LITERAL:
            case VALA_TOKEN_TYPE_CHARACTER_LITERAL:
            case VALA_TOKEN_TYPE_STRING_LITERAL:
            case VALA_TOKEN_TYPE_REGEX_LITERAL:
            case VALA_TOKEN_TYPE_TEMPLATE_STRING_LITERAL:
            case VALA_TOKEN_TYPE_VERBATIM_STRING_LITERAL:
            case VALA_TOKEN_TYPE_NULL:
            {
                  ValaExpression* _tmp3_ = NULL;
                  ValaExpression* _tmp4_;
                  _tmp3_ = vala_parser_parse_literal (self, &_inner_error_);
                  _tmp4_ = _tmp3_;
                  if (_inner_error_ != NULL) {
                        if (_inner_error_->domain == VALA_PARSE_ERROR) {
                              g_propagate_error (error, _inner_error_);
                              _vala_code_node_unref0 (expr);
                              return NULL;
                        } else {
                              _vala_code_node_unref0 (expr);
                              g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                              g_clear_error (&_inner_error_);
                              return NULL;
                        }
                  }
                  _vala_code_node_unref0 (expr);
                  expr = _tmp4_;
                  break;
            }
            case VALA_TOKEN_TYPE_OPEN_BRACE:
            {
                  ValaProfile _tmp5_;
                  _tmp5_ = vala_code_context_get_profile (self->priv->context);
                  if (_tmp5_ == VALA_PROFILE_DOVA) {
                        ValaExpression* _tmp6_ = NULL;
                        ValaExpression* _tmp7_;
                        _tmp6_ = vala_parser_parse_set_literal (self, &_inner_error_);
                        _tmp7_ = _tmp6_;
                        if (_inner_error_ != NULL) {
                              if (_inner_error_->domain == VALA_PARSE_ERROR) {
                                    g_propagate_error (error, _inner_error_);
                                    _vala_code_node_unref0 (expr);
                                    return NULL;
                              } else {
                                    _vala_code_node_unref0 (expr);
                                    g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                                    g_clear_error (&_inner_error_);
                                    return NULL;
                              }
                        }
                        _vala_code_node_unref0 (expr);
                        expr = _tmp7_;
                  } else {
                        ValaInitializerList* _tmp8_ = NULL;
                        ValaInitializerList* _tmp9_;
                        _tmp8_ = vala_parser_parse_initializer (self, &_inner_error_);
                        _tmp9_ = _tmp8_;
                        if (_inner_error_ != NULL) {
                              if (_inner_error_->domain == VALA_PARSE_ERROR) {
                                    g_propagate_error (error, _inner_error_);
                                    _vala_code_node_unref0 (expr);
                                    return NULL;
                              } else {
                                    _vala_code_node_unref0 (expr);
                                    g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                                    g_clear_error (&_inner_error_);
                                    return NULL;
                              }
                        }
                        _vala_code_node_unref0 (expr);
                        expr = (ValaExpression*) _tmp9_;
                  }
                  break;
            }
            case VALA_TOKEN_TYPE_OPEN_BRACKET:
            {
                  ValaProfile _tmp10_;
                  _tmp10_ = vala_code_context_get_profile (self->priv->context);
                  if (_tmp10_ == VALA_PROFILE_DOVA) {
                        ValaListLiteral* _tmp11_ = NULL;
                        ValaListLiteral* _tmp12_;
                        _tmp11_ = vala_parser_parse_list_literal (self, &_inner_error_);
                        _tmp12_ = _tmp11_;
                        if (_inner_error_ != NULL) {
                              if (_inner_error_->domain == VALA_PARSE_ERROR) {
                                    g_propagate_error (error, _inner_error_);
                                    _vala_code_node_unref0 (expr);
                                    return NULL;
                              } else {
                                    _vala_code_node_unref0 (expr);
                                    g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                                    g_clear_error (&_inner_error_);
                                    return NULL;
                              }
                        }
                        _vala_code_node_unref0 (expr);
                        expr = (ValaExpression*) _tmp12_;
                  } else {
                        ValaExpression* _tmp13_ = NULL;
                        ValaExpression* _tmp14_;
                        _tmp13_ = vala_parser_parse_simple_name (self, &_inner_error_);
                        _tmp14_ = _tmp13_;
                        if (_inner_error_ != NULL) {
                              if (_inner_error_->domain == VALA_PARSE_ERROR) {
                                    g_propagate_error (error, _inner_error_);
                                    _vala_code_node_unref0 (expr);
                                    return NULL;
                              } else {
                                    _vala_code_node_unref0 (expr);
                                    g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                                    g_clear_error (&_inner_error_);
                                    return NULL;
                              }
                        }
                        _vala_code_node_unref0 (expr);
                        expr = _tmp14_;
                  }
                  break;
            }
            case VALA_TOKEN_TYPE_OPEN_PARENS:
            {
                  ValaExpression* _tmp15_ = NULL;
                  ValaExpression* _tmp16_;
                  _tmp15_ = vala_parser_parse_tuple (self, &_inner_error_);
                  _tmp16_ = _tmp15_;
                  if (_inner_error_ != NULL) {
                        if (_inner_error_->domain == VALA_PARSE_ERROR) {
                              g_propagate_error (error, _inner_error_);
                              _vala_code_node_unref0 (expr);
                              return NULL;
                        } else {
                              _vala_code_node_unref0 (expr);
                              g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                              g_clear_error (&_inner_error_);
                              return NULL;
                        }
                  }
                  _vala_code_node_unref0 (expr);
                  expr = _tmp16_;
                  break;
            }
            case VALA_TOKEN_TYPE_OPEN_TEMPLATE:
            {
                  ValaExpression* _tmp17_ = NULL;
                  ValaExpression* _tmp18_;
                  _tmp17_ = vala_parser_parse_template (self, &_inner_error_);
                  _tmp18_ = _tmp17_;
                  if (_inner_error_ != NULL) {
                        if (_inner_error_->domain == VALA_PARSE_ERROR) {
                              g_propagate_error (error, _inner_error_);
                              _vala_code_node_unref0 (expr);
                              return NULL;
                        } else {
                              _vala_code_node_unref0 (expr);
                              g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                              g_clear_error (&_inner_error_);
                              return NULL;
                        }
                  }
                  _vala_code_node_unref0 (expr);
                  expr = _tmp18_;
                  break;
            }
            case VALA_TOKEN_TYPE_OPEN_REGEX_LITERAL:
            {
                  ValaExpression* _tmp19_ = NULL;
                  ValaExpression* _tmp20_;
                  _tmp19_ = vala_parser_parse_regex_literal (self, &_inner_error_);
                  _tmp20_ = _tmp19_;
                  if (_inner_error_ != NULL) {
                        if (_inner_error_->domain == VALA_PARSE_ERROR) {
                              g_propagate_error (error, _inner_error_);
                              _vala_code_node_unref0 (expr);
                              return NULL;
                        } else {
                              _vala_code_node_unref0 (expr);
                              g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                              g_clear_error (&_inner_error_);
                              return NULL;
                        }
                  }
                  _vala_code_node_unref0 (expr);
                  expr = _tmp20_;
                  break;
            }
            case VALA_TOKEN_TYPE_THIS:
            {
                  ValaExpression* _tmp21_ = NULL;
                  ValaExpression* _tmp22_;
                  _tmp21_ = vala_parser_parse_this_access (self, &_inner_error_);
                  _tmp22_ = _tmp21_;
                  if (_inner_error_ != NULL) {
                        if (_inner_error_->domain == VALA_PARSE_ERROR) {
                              g_propagate_error (error, _inner_error_);
                              _vala_code_node_unref0 (expr);
                              return NULL;
                        } else {
                              _vala_code_node_unref0 (expr);
                              g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                              g_clear_error (&_inner_error_);
                              return NULL;
                        }
                  }
                  _vala_code_node_unref0 (expr);
                  expr = _tmp22_;
                  break;
            }
            case VALA_TOKEN_TYPE_BASE:
            {
                  ValaExpression* _tmp23_ = NULL;
                  ValaExpression* _tmp24_;
                  _tmp23_ = vala_parser_parse_base_access (self, &_inner_error_);
                  _tmp24_ = _tmp23_;
                  if (_inner_error_ != NULL) {
                        if (_inner_error_->domain == VALA_PARSE_ERROR) {
                              g_propagate_error (error, _inner_error_);
                              _vala_code_node_unref0 (expr);
                              return NULL;
                        } else {
                              _vala_code_node_unref0 (expr);
                              g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                              g_clear_error (&_inner_error_);
                              return NULL;
                        }
                  }
                  _vala_code_node_unref0 (expr);
                  expr = _tmp24_;
                  break;
            }
            case VALA_TOKEN_TYPE_NEW:
            {
                  ValaExpression* _tmp25_ = NULL;
                  ValaExpression* _tmp26_;
                  _tmp25_ = vala_parser_parse_object_or_array_creation_expression (self, &_inner_error_);
                  _tmp26_ = _tmp25_;
                  if (_inner_error_ != NULL) {
                        if (_inner_error_->domain == VALA_PARSE_ERROR) {
                              g_propagate_error (error, _inner_error_);
                              _vala_code_node_unref0 (expr);
                              return NULL;
                        } else {
                              _vala_code_node_unref0 (expr);
                              g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                              g_clear_error (&_inner_error_);
                              return NULL;
                        }
                  }
                  _vala_code_node_unref0 (expr);
                  expr = _tmp26_;
                  break;
            }
            case VALA_TOKEN_TYPE_YIELD:
            {
                  ValaExpression* _tmp27_ = NULL;
                  ValaExpression* _tmp28_;
                  _tmp27_ = vala_parser_parse_yield_expression (self, &_inner_error_);
                  _tmp28_ = _tmp27_;
                  if (_inner_error_ != NULL) {
                        if (_inner_error_->domain == VALA_PARSE_ERROR) {
                              g_propagate_error (error, _inner_error_);
                              _vala_code_node_unref0 (expr);
                              return NULL;
                        } else {
                              _vala_code_node_unref0 (expr);
                              g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                              g_clear_error (&_inner_error_);
                              return NULL;
                        }
                  }
                  _vala_code_node_unref0 (expr);
                  expr = _tmp28_;
                  break;
            }
            case VALA_TOKEN_TYPE_SIZEOF:
            {
                  ValaExpression* _tmp29_ = NULL;
                  ValaExpression* _tmp30_;
                  _tmp29_ = vala_parser_parse_sizeof_expression (self, &_inner_error_);
                  _tmp30_ = _tmp29_;
                  if (_inner_error_ != NULL) {
                        if (_inner_error_->domain == VALA_PARSE_ERROR) {
                              g_propagate_error (error, _inner_error_);
                              _vala_code_node_unref0 (expr);
                              return NULL;
                        } else {
                              _vala_code_node_unref0 (expr);
                              g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                              g_clear_error (&_inner_error_);
                              return NULL;
                        }
                  }
                  _vala_code_node_unref0 (expr);
                  expr = _tmp30_;
                  break;
            }
            case VALA_TOKEN_TYPE_TYPEOF:
            {
                  ValaExpression* _tmp31_ = NULL;
                  ValaExpression* _tmp32_;
                  _tmp31_ = vala_parser_parse_typeof_expression (self, &_inner_error_);
                  _tmp32_ = _tmp31_;
                  if (_inner_error_ != NULL) {
                        if (_inner_error_->domain == VALA_PARSE_ERROR) {
                              g_propagate_error (error, _inner_error_);
                              _vala_code_node_unref0 (expr);
                              return NULL;
                        } else {
                              _vala_code_node_unref0 (expr);
                              g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                              g_clear_error (&_inner_error_);
                              return NULL;
                        }
                  }
                  _vala_code_node_unref0 (expr);
                  expr = _tmp32_;
                  break;
            }
            default:
            {
                  ValaExpression* _tmp33_ = NULL;
                  ValaExpression* _tmp34_;
                  _tmp33_ = vala_parser_parse_simple_name (self, &_inner_error_);
                  _tmp34_ = _tmp33_;
                  if (_inner_error_ != NULL) {
                        if (_inner_error_->domain == VALA_PARSE_ERROR) {
                              g_propagate_error (error, _inner_error_);
                              _vala_code_node_unref0 (expr);
                              return NULL;
                        } else {
                              _vala_code_node_unref0 (expr);
                              g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                              g_clear_error (&_inner_error_);
                              return NULL;
                        }
                  }
                  _vala_code_node_unref0 (expr);
                  expr = _tmp34_;
                  break;
            }
      }
      found = TRUE;
      while (TRUE) {
            ValaTokenType _tmp35_;
            if (!found) {
                  break;
            }
            _tmp35_ = vala_parser_current (self);
            switch (_tmp35_) {
                  case VALA_TOKEN_TYPE_DOT:
                  {
                        ValaExpression* _tmp36_ = NULL;
                        ValaExpression* _tmp37_;
                        _tmp36_ = vala_parser_parse_member_access (self, &begin, expr, &_inner_error_);
                        _tmp37_ = _tmp36_;
                        if (_inner_error_ != NULL) {
                              if (_inner_error_->domain == VALA_PARSE_ERROR) {
                                    g_propagate_error (error, _inner_error_);
                                    _vala_code_node_unref0 (expr);
                                    return NULL;
                              } else {
                                    _vala_code_node_unref0 (expr);
                                    g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                                    g_clear_error (&_inner_error_);
                                    return NULL;
                              }
                        }
                        _vala_code_node_unref0 (expr);
                        expr = _tmp37_;
                        break;
                  }
                  case VALA_TOKEN_TYPE_OP_PTR:
                  {
                        ValaProfile _tmp38_;
                        _tmp38_ = vala_code_context_get_profile (self->priv->context);
                        if (_tmp38_ == VALA_PROFILE_DOVA) {
                              found = FALSE;
                        } else {
                              ValaExpression* _tmp39_ = NULL;
                              ValaExpression* _tmp40_;
                              _tmp39_ = vala_parser_parse_pointer_member_access (self, &begin, expr, &_inner_error_);
                              _tmp40_ = _tmp39_;
                              if (_inner_error_ != NULL) {
                                    if (_inner_error_->domain == VALA_PARSE_ERROR) {
                                          g_propagate_error (error, _inner_error_);
                                          _vala_code_node_unref0 (expr);
                                          return NULL;
                                    } else {
                                          _vala_code_node_unref0 (expr);
                                          g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                                          g_clear_error (&_inner_error_);
                                          return NULL;
                                    }
                              }
                              _vala_code_node_unref0 (expr);
                              expr = _tmp40_;
                        }
                        break;
                  }
                  case VALA_TOKEN_TYPE_OPEN_PARENS:
                  {
                        ValaExpression* _tmp41_ = NULL;
                        ValaExpression* _tmp42_;
                        _tmp41_ = vala_parser_parse_method_call (self, &begin, expr, &_inner_error_);
                        _tmp42_ = _tmp41_;
                        if (_inner_error_ != NULL) {
                              if (_inner_error_->domain == VALA_PARSE_ERROR) {
                                    g_propagate_error (error, _inner_error_);
                                    _vala_code_node_unref0 (expr);
                                    return NULL;
                              } else {
                                    _vala_code_node_unref0 (expr);
                                    g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                                    g_clear_error (&_inner_error_);
                                    return NULL;
                              }
                        }
                        _vala_code_node_unref0 (expr);
                        expr = _tmp42_;
                        break;
                  }
                  case VALA_TOKEN_TYPE_OPEN_BRACKET:
                  {
                        ValaExpression* _tmp43_ = NULL;
                        ValaExpression* _tmp44_;
                        _tmp43_ = vala_parser_parse_element_access (self, &begin, expr, &_inner_error_);
                        _tmp44_ = _tmp43_;
                        if (_inner_error_ != NULL) {
                              if (_inner_error_->domain == VALA_PARSE_ERROR) {
                                    g_propagate_error (error, _inner_error_);
                                    _vala_code_node_unref0 (expr);
                                    return NULL;
                              } else {
                                    _vala_code_node_unref0 (expr);
                                    g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                                    g_clear_error (&_inner_error_);
                                    return NULL;
                              }
                        }
                        _vala_code_node_unref0 (expr);
                        expr = _tmp44_;
                        break;
                  }
                  case VALA_TOKEN_TYPE_OPEN_BRACE:
                  {
                        ValaExpression* _tmp45_;
                        ValaMemberAccess* _tmp46_;
                        ValaMemberAccess* ma;
                        gboolean _tmp47_ = FALSE;
                        ValaProfile _tmp48_;
                        _tmp45_ = expr;
                        _tmp46_ = _vala_code_node_ref0 (VALA_IS_MEMBER_ACCESS (_tmp45_) ? ((ValaMemberAccess*) _tmp45_) : NULL);
                        ma = _tmp46_;
                        _tmp48_ = vala_code_context_get_profile (self->priv->context);
                        if (_tmp48_ == VALA_PROFILE_DOVA) {
                              _tmp47_ = ma != NULL;
                        } else {
                              _tmp47_ = FALSE;
                        }
                        if (_tmp47_) {
                              ValaExpression* _tmp49_ = NULL;
                              ValaExpression* _tmp50_;
                              _tmp49_ = vala_parser_parse_object_literal (self, &begin, ma, &_inner_error_);
                              _tmp50_ = _tmp49_;
                              if (_inner_error_ != NULL) {
                                    if (_inner_error_->domain == VALA_PARSE_ERROR) {
                                          g_propagate_error (error, _inner_error_);
                                          _vala_code_node_unref0 (ma);
                                          _vala_code_node_unref0 (expr);
                                          return NULL;
                                    } else {
                                          _vala_code_node_unref0 (ma);
                                          _vala_code_node_unref0 (expr);
                                          g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                                          g_clear_error (&_inner_error_);
                                          return NULL;
                                    }
                              }
                              _vala_code_node_unref0 (expr);
                              expr = _tmp50_;
                        } else {
                              found = FALSE;
                        }
                        _vala_code_node_unref0 (ma);
                        break;
                  }
                  case VALA_TOKEN_TYPE_OP_INC:
                  {
                        ValaExpression* _tmp51_ = NULL;
                        ValaExpression* _tmp52_;
                        _tmp51_ = vala_parser_parse_post_increment_expression (self, &begin, expr, &_inner_error_);
                        _tmp52_ = _tmp51_;
                        if (_inner_error_ != NULL) {
                              if (_inner_error_->domain == VALA_PARSE_ERROR) {
                                    g_propagate_error (error, _inner_error_);
                                    _vala_code_node_unref0 (expr);
                                    return NULL;
                              } else {
                                    _vala_code_node_unref0 (expr);
                                    g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                                    g_clear_error (&_inner_error_);
                                    return NULL;
                              }
                        }
                        _vala_code_node_unref0 (expr);
                        expr = _tmp52_;
                        break;
                  }
                  case VALA_TOKEN_TYPE_OP_DEC:
                  {
                        ValaExpression* _tmp53_ = NULL;
                        ValaExpression* _tmp54_;
                        _tmp53_ = vala_parser_parse_post_decrement_expression (self, &begin, expr, &_inner_error_);
                        _tmp54_ = _tmp53_;
                        if (_inner_error_ != NULL) {
                              if (_inner_error_->domain == VALA_PARSE_ERROR) {
                                    g_propagate_error (error, _inner_error_);
                                    _vala_code_node_unref0 (expr);
                                    return NULL;
                              } else {
                                    _vala_code_node_unref0 (expr);
                                    g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                                    g_clear_error (&_inner_error_);
                                    return NULL;
                              }
                        }
                        _vala_code_node_unref0 (expr);
                        expr = _tmp54_;
                        break;
                  }
                  default:
                  {
                        found = FALSE;
                        break;
                  }
            }
      }
      result = expr;
      return result;
}


static ValaExpression* vala_parser_parse_simple_name (ValaParser* self, GError** error) {
      ValaExpression* result = NULL;
      ValaSourceLocation _tmp0_ = {0};
      ValaSourceLocation _tmp1_ = {0};
      ValaSourceLocation begin;
      gchar* _tmp2_ = NULL;
      gchar* id;
      gboolean qualified;
      gboolean _tmp3_ = FALSE;
      ValaList* _tmp7_ = NULL;
      ValaList* type_arg_list;
      ValaSourceReference* _tmp8_ = NULL;
      ValaSourceReference* _tmp9_;
      ValaMemberAccess* _tmp10_ = NULL;
      ValaMemberAccess* _tmp11_;
      ValaMemberAccess* expr;
      GError * _inner_error_ = NULL;
      g_return_val_if_fail (self != NULL, NULL);
      vala_parser_get_location (self, &_tmp0_);
      _tmp1_ = _tmp0_;
      begin = _tmp1_;
      _tmp2_ = vala_parser_parse_identifier (self, &_inner_error_);
      id = _tmp2_;
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  return NULL;
            } else {
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      qualified = FALSE;
      if (g_strcmp0 (id, "global") == 0) {
            gboolean _tmp4_;
            _tmp4_ = vala_parser_accept (self, VALA_TOKEN_TYPE_DOUBLE_COLON);
            _tmp3_ = _tmp4_;
      } else {
            _tmp3_ = FALSE;
      }
      if (_tmp3_) {
            gchar* _tmp5_ = NULL;
            gchar* _tmp6_;
            _tmp5_ = vala_parser_parse_identifier (self, &_inner_error_);
            _tmp6_ = _tmp5_;
            if (_inner_error_ != NULL) {
                  if (_inner_error_->domain == VALA_PARSE_ERROR) {
                        g_propagate_error (error, _inner_error_);
                        _g_free0 (id);
                        return NULL;
                  } else {
                        _g_free0 (id);
                        g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                        g_clear_error (&_inner_error_);
                        return NULL;
                  }
            }
            _g_free0 (id);
            id = _tmp6_;
            qualified = TRUE;
      }
      _tmp7_ = vala_parser_parse_type_argument_list (self, TRUE, &_inner_error_);
      type_arg_list = _tmp7_;
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  _g_free0 (id);
                  return NULL;
            } else {
                  _g_free0 (id);
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      _tmp8_ = vala_parser_get_src (self, &begin);
      _tmp9_ = _tmp8_;
      _tmp10_ = vala_member_access_new (NULL, id, _tmp9_);
      _tmp11_ = _tmp10_;
      _vala_source_reference_unref0 (_tmp9_);
      expr = _tmp11_;
      vala_member_access_set_qualified (expr, qualified);
      if (type_arg_list != NULL) {
            {
                  ValaList* _tmp12_;
                  ValaList* _type_arg_list;
                  gint _tmp13_;
                  gint _type_arg_size;
                  gint _type_arg_index;
                  _tmp12_ = _vala_iterable_ref0 (type_arg_list);
                  _type_arg_list = _tmp12_;
                  _tmp13_ = vala_collection_get_size ((ValaCollection*) _type_arg_list);
                  _type_arg_size = _tmp13_;
                  _type_arg_index = -1;
                  while (TRUE) {
                        gpointer _tmp14_ = NULL;
                        ValaDataType* type_arg;
                        _type_arg_index = _type_arg_index + 1;
                        if (!(_type_arg_index < _type_arg_size)) {
                              break;
                        }
                        _tmp14_ = vala_list_get (_type_arg_list, _type_arg_index);
                        type_arg = (ValaDataType*) _tmp14_;
                        vala_member_access_add_type_argument (expr, type_arg);
                        _vala_code_node_unref0 (type_arg);
                  }
                  _vala_iterable_unref0 (_type_arg_list);
            }
      }
      result = (ValaExpression*) expr;
      _vala_iterable_unref0 (type_arg_list);
      _g_free0 (id);
      return result;
}


static ValaExpression* vala_parser_parse_tuple (ValaParser* self, GError** error) {
      ValaExpression* result = NULL;
      ValaSourceLocation _tmp0_ = {0};
      ValaSourceLocation _tmp1_ = {0};
      ValaSourceLocation begin;
      ValaArrayList* _tmp2_ = NULL;
      ValaArrayList* expr_list;
      ValaTokenType _tmp3_;
      gint _tmp9_;
      gpointer _tmp17_ = NULL;
      GError * _inner_error_ = NULL;
      g_return_val_if_fail (self != NULL, NULL);
      vala_parser_get_location (self, &_tmp0_);
      _tmp1_ = _tmp0_;
      begin = _tmp1_;
      vala_parser_expect (self, VALA_TOKEN_TYPE_OPEN_PARENS, &_inner_error_);
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  return NULL;
            } else {
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      _tmp2_ = vala_array_list_new (VALA_TYPE_EXPRESSION, (GBoxedCopyFunc) vala_code_node_ref, vala_code_node_unref, g_direct_equal);
      expr_list = _tmp2_;
      _tmp3_ = vala_parser_current (self);
      if (_tmp3_ != VALA_TOKEN_TYPE_CLOSE_PARENS) {
            {
                  gboolean _tmp4_;
                  _tmp4_ = TRUE;
                  while (TRUE) {
                        ValaExpression* _tmp6_ = NULL;
                        ValaExpression* _tmp7_;
                        ValaExpression* _tmp8_;
                        if (!_tmp4_) {
                              gboolean _tmp5_;
                              _tmp5_ = vala_parser_accept (self, VALA_TOKEN_TYPE_COMMA);
                              if (!_tmp5_) {
                                    break;
                              }
                        }
                        _tmp4_ = FALSE;
                        _tmp6_ = vala_parser_parse_expression (self, &_inner_error_);
                        _tmp7_ = _tmp6_;
                        if (_inner_error_ != NULL) {
                              if (_inner_error_->domain == VALA_PARSE_ERROR) {
                                    g_propagate_error (error, _inner_error_);
                                    _vala_iterable_unref0 (expr_list);
                                    return NULL;
                              } else {
                                    _vala_iterable_unref0 (expr_list);
                                    g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                                    g_clear_error (&_inner_error_);
                                    return NULL;
                              }
                        }
                        _tmp8_ = _tmp7_;
                        vala_collection_add ((ValaCollection*) expr_list, _tmp8_);
                        _vala_code_node_unref0 (_tmp8_);
                  }
            }
      }
      vala_parser_expect (self, VALA_TOKEN_TYPE_CLOSE_PARENS, &_inner_error_);
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  _vala_iterable_unref0 (expr_list);
                  return NULL;
            } else {
                  _vala_iterable_unref0 (expr_list);
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      _tmp9_ = vala_collection_get_size ((ValaCollection*) expr_list);
      if (_tmp9_ != 1) {
            ValaSourceReference* _tmp10_ = NULL;
            ValaSourceReference* _tmp11_;
            ValaTuple* _tmp12_ = NULL;
            ValaTuple* _tmp13_;
            ValaTuple* tuple;
            _tmp10_ = vala_parser_get_src (self, &begin);
            _tmp11_ = _tmp10_;
            _tmp12_ = vala_tuple_new (_tmp11_);
            _tmp13_ = _tmp12_;
            _vala_source_reference_unref0 (_tmp11_);
            tuple = _tmp13_;
            {
                  ValaArrayList* _tmp14_;
                  ValaArrayList* _expr_list;
                  gint _tmp15_;
                  gint _expr_size;
                  gint _expr_index;
                  _tmp14_ = _vala_iterable_ref0 (expr_list);
                  _expr_list = _tmp14_;
                  _tmp15_ = vala_collection_get_size ((ValaCollection*) _expr_list);
                  _expr_size = _tmp15_;
                  _expr_index = -1;
                  while (TRUE) {
                        gpointer _tmp16_ = NULL;
                        ValaExpression* expr;
                        _expr_index = _expr_index + 1;
                        if (!(_expr_index < _expr_size)) {
                              break;
                        }
                        _tmp16_ = vala_list_get ((ValaList*) _expr_list, _expr_index);
                        expr = (ValaExpression*) _tmp16_;
                        vala_tuple_add_expression (tuple, expr);
                        _vala_code_node_unref0 (expr);
                  }
                  _vala_iterable_unref0 (_expr_list);
            }
            result = (ValaExpression*) tuple;
            _vala_iterable_unref0 (expr_list);
            return result;
      }
      _tmp17_ = vala_list_get ((ValaList*) expr_list, 0);
      result = (ValaExpression*) _tmp17_;
      _vala_iterable_unref0 (expr_list);
      return result;
}


static ValaExpression* vala_parser_parse_template (ValaParser* self, GError** error) {
      ValaExpression* result = NULL;
      ValaSourceLocation _tmp0_ = {0};
      ValaSourceLocation _tmp1_ = {0};
      ValaSourceLocation begin;
      ValaTemplate* _tmp2_ = NULL;
      ValaTemplate* template;
      ValaSourceReference* _tmp7_ = NULL;
      ValaSourceReference* _tmp8_;
      GError * _inner_error_ = NULL;
      g_return_val_if_fail (self != NULL, NULL);
      vala_parser_get_location (self, &_tmp0_);
      _tmp1_ = _tmp0_;
      begin = _tmp1_;
      _tmp2_ = vala_template_new (NULL);
      template = _tmp2_;
      vala_parser_expect (self, VALA_TOKEN_TYPE_OPEN_TEMPLATE, &_inner_error_);
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  _vala_code_node_unref0 (template);
                  return NULL;
            } else {
                  _vala_code_node_unref0 (template);
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      while (TRUE) {
            ValaTokenType _tmp3_;
            ValaExpression* _tmp4_ = NULL;
            ValaExpression* _tmp5_;
            ValaExpression* _tmp6_;
            _tmp3_ = vala_parser_current (self);
            if (!(_tmp3_ != VALA_TOKEN_TYPE_CLOSE_TEMPLATE)) {
                  break;
            }
            _tmp4_ = vala_parser_parse_expression (self, &_inner_error_);
            _tmp5_ = _tmp4_;
            if (_inner_error_ != NULL) {
                  if (_inner_error_->domain == VALA_PARSE_ERROR) {
                        g_propagate_error (error, _inner_error_);
                        _vala_code_node_unref0 (template);
                        return NULL;
                  } else {
                        _vala_code_node_unref0 (template);
                        g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                        g_clear_error (&_inner_error_);
                        return NULL;
                  }
            }
            _tmp6_ = _tmp5_;
            vala_template_add_expression (template, _tmp6_);
            _vala_code_node_unref0 (_tmp6_);
            vala_parser_expect (self, VALA_TOKEN_TYPE_COMMA, &_inner_error_);
            if (_inner_error_ != NULL) {
                  if (_inner_error_->domain == VALA_PARSE_ERROR) {
                        g_propagate_error (error, _inner_error_);
                        _vala_code_node_unref0 (template);
                        return NULL;
                  } else {
                        _vala_code_node_unref0 (template);
                        g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                        g_clear_error (&_inner_error_);
                        return NULL;
                  }
            }
      }
      vala_parser_expect (self, VALA_TOKEN_TYPE_CLOSE_TEMPLATE, &_inner_error_);
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  _vala_code_node_unref0 (template);
                  return NULL;
            } else {
                  _vala_code_node_unref0 (template);
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      _tmp7_ = vala_parser_get_src (self, &begin);
      _tmp8_ = _tmp7_;
      vala_code_node_set_source_reference ((ValaCodeNode*) template, _tmp8_);
      _vala_source_reference_unref0 (_tmp8_);
      result = (ValaExpression*) template;
      return result;
}


static ValaExpression* vala_parser_parse_regex_literal (ValaParser* self, GError** error) {
      ValaExpression* result = NULL;
      ValaExpression* _tmp0_ = NULL;
      ValaExpression* expr;
      GError * _inner_error_ = NULL;
      g_return_val_if_fail (self != NULL, NULL);
      vala_parser_expect (self, VALA_TOKEN_TYPE_OPEN_REGEX_LITERAL, &_inner_error_);
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  return NULL;
            } else {
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      _tmp0_ = vala_parser_parse_literal (self, &_inner_error_);
      expr = _tmp0_;
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  return NULL;
            } else {
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      result = expr;
      return result;
}


static ValaExpression* vala_parser_parse_member_access (ValaParser* self, ValaSourceLocation* begin, ValaExpression* inner, GError** error) {
      ValaExpression* result = NULL;
      gchar* _tmp0_ = NULL;
      gchar* id;
      ValaList* _tmp1_ = NULL;
      ValaList* type_arg_list;
      ValaSourceReference* _tmp2_ = NULL;
      ValaSourceReference* _tmp3_;
      ValaMemberAccess* _tmp4_ = NULL;
      ValaMemberAccess* _tmp5_;
      ValaMemberAccess* expr;
      GError * _inner_error_ = NULL;
      g_return_val_if_fail (self != NULL, NULL);
      g_return_val_if_fail (inner != NULL, NULL);
      vala_parser_expect (self, VALA_TOKEN_TYPE_DOT, &_inner_error_);
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  return NULL;
            } else {
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      _tmp0_ = vala_parser_parse_identifier (self, &_inner_error_);
      id = _tmp0_;
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  return NULL;
            } else {
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      _tmp1_ = vala_parser_parse_type_argument_list (self, TRUE, &_inner_error_);
      type_arg_list = _tmp1_;
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  _g_free0 (id);
                  return NULL;
            } else {
                  _g_free0 (id);
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      _tmp2_ = vala_parser_get_src (self, begin);
      _tmp3_ = _tmp2_;
      _tmp4_ = vala_member_access_new (inner, id, _tmp3_);
      _tmp5_ = _tmp4_;
      _vala_source_reference_unref0 (_tmp3_);
      expr = _tmp5_;
      if (type_arg_list != NULL) {
            {
                  ValaList* _tmp6_;
                  ValaList* _type_arg_list;
                  gint _tmp7_;
                  gint _type_arg_size;
                  gint _type_arg_index;
                  _tmp6_ = _vala_iterable_ref0 (type_arg_list);
                  _type_arg_list = _tmp6_;
                  _tmp7_ = vala_collection_get_size ((ValaCollection*) _type_arg_list);
                  _type_arg_size = _tmp7_;
                  _type_arg_index = -1;
                  while (TRUE) {
                        gpointer _tmp8_ = NULL;
                        ValaDataType* type_arg;
                        _type_arg_index = _type_arg_index + 1;
                        if (!(_type_arg_index < _type_arg_size)) {
                              break;
                        }
                        _tmp8_ = vala_list_get (_type_arg_list, _type_arg_index);
                        type_arg = (ValaDataType*) _tmp8_;
                        vala_member_access_add_type_argument (expr, type_arg);
                        _vala_code_node_unref0 (type_arg);
                  }
                  _vala_iterable_unref0 (_type_arg_list);
            }
      }
      result = (ValaExpression*) expr;
      _vala_iterable_unref0 (type_arg_list);
      _g_free0 (id);
      return result;
}


static ValaExpression* vala_parser_parse_pointer_member_access (ValaParser* self, ValaSourceLocation* begin, ValaExpression* inner, GError** error) {
      ValaExpression* result = NULL;
      gchar* _tmp0_ = NULL;
      gchar* id;
      ValaList* _tmp1_ = NULL;
      ValaList* type_arg_list;
      ValaSourceReference* _tmp2_ = NULL;
      ValaSourceReference* _tmp3_;
      ValaMemberAccess* _tmp4_ = NULL;
      ValaMemberAccess* _tmp5_;
      ValaMemberAccess* expr;
      GError * _inner_error_ = NULL;
      g_return_val_if_fail (self != NULL, NULL);
      g_return_val_if_fail (inner != NULL, NULL);
      vala_parser_expect (self, VALA_TOKEN_TYPE_OP_PTR, &_inner_error_);
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  return NULL;
            } else {
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      _tmp0_ = vala_parser_parse_identifier (self, &_inner_error_);
      id = _tmp0_;
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  return NULL;
            } else {
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      _tmp1_ = vala_parser_parse_type_argument_list (self, TRUE, &_inner_error_);
      type_arg_list = _tmp1_;
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  _g_free0 (id);
                  return NULL;
            } else {
                  _g_free0 (id);
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      _tmp2_ = vala_parser_get_src (self, begin);
      _tmp3_ = _tmp2_;
      _tmp4_ = vala_member_access_new_pointer (inner, id, _tmp3_);
      _tmp5_ = _tmp4_;
      _vala_source_reference_unref0 (_tmp3_);
      expr = _tmp5_;
      if (type_arg_list != NULL) {
            {
                  ValaList* _tmp6_;
                  ValaList* _type_arg_list;
                  gint _tmp7_;
                  gint _type_arg_size;
                  gint _type_arg_index;
                  _tmp6_ = _vala_iterable_ref0 (type_arg_list);
                  _type_arg_list = _tmp6_;
                  _tmp7_ = vala_collection_get_size ((ValaCollection*) _type_arg_list);
                  _type_arg_size = _tmp7_;
                  _type_arg_index = -1;
                  while (TRUE) {
                        gpointer _tmp8_ = NULL;
                        ValaDataType* type_arg;
                        _type_arg_index = _type_arg_index + 1;
                        if (!(_type_arg_index < _type_arg_size)) {
                              break;
                        }
                        _tmp8_ = vala_list_get (_type_arg_list, _type_arg_index);
                        type_arg = (ValaDataType*) _tmp8_;
                        vala_member_access_add_type_argument (expr, type_arg);
                        _vala_code_node_unref0 (type_arg);
                  }
                  _vala_iterable_unref0 (_type_arg_list);
            }
      }
      result = (ValaExpression*) expr;
      _vala_iterable_unref0 (type_arg_list);
      _g_free0 (id);
      return result;
}


static ValaExpression* vala_parser_parse_method_call (ValaParser* self, ValaSourceLocation* begin, ValaExpression* inner, GError** error) {
      ValaExpression* result = NULL;
      ValaList* _tmp0_ = NULL;
      ValaList* arg_list;
      ValaList* _tmp1_ = NULL;
      ValaList* init_list;
      gboolean _tmp2_ = FALSE;
      gint _tmp3_;
      GError * _inner_error_ = NULL;
      g_return_val_if_fail (self != NULL, NULL);
      g_return_val_if_fail (inner != NULL, NULL);
      vala_parser_expect (self, VALA_TOKEN_TYPE_OPEN_PARENS, &_inner_error_);
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  return NULL;
            } else {
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      _tmp0_ = vala_parser_parse_argument_list (self, &_inner_error_);
      arg_list = _tmp0_;
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  return NULL;
            } else {
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      vala_parser_expect (self, VALA_TOKEN_TYPE_CLOSE_PARENS, &_inner_error_);
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  _vala_iterable_unref0 (arg_list);
                  return NULL;
            } else {
                  _vala_iterable_unref0 (arg_list);
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      _tmp1_ = vala_parser_parse_object_initializer (self, &_inner_error_);
      init_list = _tmp1_;
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  _vala_iterable_unref0 (arg_list);
                  return NULL;
            } else {
                  _vala_iterable_unref0 (arg_list);
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      _tmp3_ = vala_collection_get_size ((ValaCollection*) init_list);
      if (_tmp3_ > 0) {
            _tmp2_ = VALA_IS_MEMBER_ACCESS (inner);
      } else {
            _tmp2_ = FALSE;
      }
      if (_tmp2_) {
            ValaMemberAccess* _tmp4_;
            ValaMemberAccess* member;
            ValaSourceReference* _tmp5_ = NULL;
            ValaSourceReference* _tmp6_;
            ValaObjectCreationExpression* _tmp7_ = NULL;
            ValaObjectCreationExpression* _tmp8_;
            ValaObjectCreationExpression* expr;
            _tmp4_ = _vala_code_node_ref0 (VALA_MEMBER_ACCESS (inner));
            member = _tmp4_;
            vala_member_access_set_creation_member (member, TRUE);
            _tmp5_ = vala_parser_get_src (self, begin);
            _tmp6_ = _tmp5_;
            _tmp7_ = vala_object_creation_expression_new (member, _tmp6_);
            _tmp8_ = _tmp7_;
            _vala_source_reference_unref0 (_tmp6_);
            expr = _tmp8_;
            vala_object_creation_expression_set_struct_creation (expr, TRUE);
            {
                  ValaList* _tmp9_;
                  ValaList* _arg_list;
                  gint _tmp10_;
                  gint _arg_size;
                  gint _arg_index;
                  _tmp9_ = _vala_iterable_ref0 (arg_list);
                  _arg_list = _tmp9_;
                  _tmp10_ = vala_collection_get_size ((ValaCollection*) _arg_list);
                  _arg_size = _tmp10_;
                  _arg_index = -1;
                  while (TRUE) {
                        gpointer _tmp11_ = NULL;
                        ValaExpression* arg;
                        _arg_index = _arg_index + 1;
                        if (!(_arg_index < _arg_size)) {
                              break;
                        }
                        _tmp11_ = vala_list_get (_arg_list, _arg_index);
                        arg = (ValaExpression*) _tmp11_;
                        vala_object_creation_expression_add_argument (expr, arg);
                        _vala_code_node_unref0 (arg);
                  }
                  _vala_iterable_unref0 (_arg_list);
            }
            {
                  ValaList* _tmp12_;
                  ValaList* _initializer_list;
                  gint _tmp13_;
                  gint _initializer_size;
                  gint _initializer_index;
                  _tmp12_ = _vala_iterable_ref0 (init_list);
                  _initializer_list = _tmp12_;
                  _tmp13_ = vala_collection_get_size ((ValaCollection*) _initializer_list);
                  _initializer_size = _tmp13_;
                  _initializer_index = -1;
                  while (TRUE) {
                        gpointer _tmp14_ = NULL;
                        ValaMemberInitializer* initializer;
                        _initializer_index = _initializer_index + 1;
                        if (!(_initializer_index < _initializer_size)) {
                              break;
                        }
                        _tmp14_ = vala_list_get (_initializer_list, _initializer_index);
                        initializer = (ValaMemberInitializer*) _tmp14_;
                        vala_object_creation_expression_add_member_initializer (expr, initializer);
                        _vala_code_node_unref0 (initializer);
                  }
                  _vala_iterable_unref0 (_initializer_list);
            }
            result = (ValaExpression*) expr;
            _vala_code_node_unref0 (member);
            _vala_iterable_unref0 (init_list);
            _vala_iterable_unref0 (arg_list);
            return result;
      } else {
            ValaSourceReference* _tmp15_ = NULL;
            ValaSourceReference* _tmp16_;
            ValaMethodCall* _tmp17_ = NULL;
            ValaMethodCall* _tmp18_;
            ValaMethodCall* expr;
            _tmp15_ = vala_parser_get_src (self, begin);
            _tmp16_ = _tmp15_;
            _tmp17_ = vala_method_call_new (inner, _tmp16_);
            _tmp18_ = _tmp17_;
            _vala_source_reference_unref0 (_tmp16_);
            expr = _tmp18_;
            {
                  ValaList* _tmp19_;
                  ValaList* _arg_list;
                  gint _tmp20_;
                  gint _arg_size;
                  gint _arg_index;
                  _tmp19_ = _vala_iterable_ref0 (arg_list);
                  _arg_list = _tmp19_;
                  _tmp20_ = vala_collection_get_size ((ValaCollection*) _arg_list);
                  _arg_size = _tmp20_;
                  _arg_index = -1;
                  while (TRUE) {
                        gpointer _tmp21_ = NULL;
                        ValaExpression* arg;
                        _arg_index = _arg_index + 1;
                        if (!(_arg_index < _arg_size)) {
                              break;
                        }
                        _tmp21_ = vala_list_get (_arg_list, _arg_index);
                        arg = (ValaExpression*) _tmp21_;
                        vala_method_call_add_argument (expr, arg);
                        _vala_code_node_unref0 (arg);
                  }
                  _vala_iterable_unref0 (_arg_list);
            }
            result = (ValaExpression*) expr;
            _vala_iterable_unref0 (init_list);
            _vala_iterable_unref0 (arg_list);
            return result;
      }
      _vala_iterable_unref0 (init_list);
      _vala_iterable_unref0 (arg_list);
}


static ValaExpression* vala_parser_parse_element_access (ValaParser* self, ValaSourceLocation* begin, ValaExpression* inner, GError** error) {
      ValaExpression* result = NULL;
      ValaList* _tmp0_ = NULL;
      ValaList* index_list;
      ValaExpression* stop;
      gboolean _tmp1_ = FALSE;
      gint _tmp2_;
      GError * _inner_error_ = NULL;
      g_return_val_if_fail (self != NULL, NULL);
      g_return_val_if_fail (inner != NULL, NULL);
      vala_parser_expect (self, VALA_TOKEN_TYPE_OPEN_BRACKET, &_inner_error_);
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  return NULL;
            } else {
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      _tmp0_ = vala_parser_parse_expression_list (self, &_inner_error_);
      index_list = _tmp0_;
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  return NULL;
            } else {
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      stop = NULL;
      _tmp2_ = vala_collection_get_size ((ValaCollection*) index_list);
      if (_tmp2_ == 1) {
            gboolean _tmp3_;
            _tmp3_ = vala_parser_accept (self, VALA_TOKEN_TYPE_COLON);
            _tmp1_ = _tmp3_;
      } else {
            _tmp1_ = FALSE;
      }
      if (_tmp1_) {
            ValaExpression* _tmp4_ = NULL;
            ValaExpression* _tmp5_;
            _tmp4_ = vala_parser_parse_expression (self, &_inner_error_);
            _tmp5_ = _tmp4_;
            if (_inner_error_ != NULL) {
                  if (_inner_error_->domain == VALA_PARSE_ERROR) {
                        g_propagate_error (error, _inner_error_);
                        _vala_code_node_unref0 (stop);
                        _vala_iterable_unref0 (index_list);
                        return NULL;
                  } else {
                        _vala_code_node_unref0 (stop);
                        _vala_iterable_unref0 (index_list);
                        g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                        g_clear_error (&_inner_error_);
                        return NULL;
                  }
            }
            _vala_code_node_unref0 (stop);
            stop = _tmp5_;
      }
      vala_parser_expect (self, VALA_TOKEN_TYPE_CLOSE_BRACKET, &_inner_error_);
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  _vala_code_node_unref0 (stop);
                  _vala_iterable_unref0 (index_list);
                  return NULL;
            } else {
                  _vala_code_node_unref0 (stop);
                  _vala_iterable_unref0 (index_list);
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      if (stop == NULL) {
            ValaSourceReference* _tmp6_ = NULL;
            ValaSourceReference* _tmp7_;
            ValaElementAccess* _tmp8_ = NULL;
            ValaElementAccess* _tmp9_;
            ValaElementAccess* expr;
            _tmp6_ = vala_parser_get_src (self, begin);
            _tmp7_ = _tmp6_;
            _tmp8_ = vala_element_access_new (inner, _tmp7_);
            _tmp9_ = _tmp8_;
            _vala_source_reference_unref0 (_tmp7_);
            expr = _tmp9_;
            {
                  ValaList* _tmp10_;
                  ValaList* _index_list;
                  gint _tmp11_;
                  gint _index_size;
                  gint _index_index;
                  _tmp10_ = _vala_iterable_ref0 (index_list);
                  _index_list = _tmp10_;
                  _tmp11_ = vala_collection_get_size ((ValaCollection*) _index_list);
                  _index_size = _tmp11_;
                  _index_index = -1;
                  while (TRUE) {
                        gpointer _tmp12_ = NULL;
                        ValaExpression* index;
                        _index_index = _index_index + 1;
                        if (!(_index_index < _index_size)) {
                              break;
                        }
                        _tmp12_ = vala_list_get (_index_list, _index_index);
                        index = (ValaExpression*) _tmp12_;
                        vala_element_access_append_index (expr, index);
                        _vala_code_node_unref0 (index);
                  }
                  _vala_iterable_unref0 (_index_list);
            }
            result = (ValaExpression*) expr;
            _vala_code_node_unref0 (stop);
            _vala_iterable_unref0 (index_list);
            return result;
      } else {
            gpointer _tmp13_ = NULL;
            ValaExpression* _tmp14_;
            ValaSourceReference* _tmp15_ = NULL;
            ValaSourceReference* _tmp16_;
            ValaSliceExpression* _tmp17_ = NULL;
            ValaExpression* _tmp18_;
            _tmp13_ = vala_list_get (index_list, 0);
            _tmp14_ = (ValaExpression*) _tmp13_;
            _tmp15_ = vala_parser_get_src (self, begin);
            _tmp16_ = _tmp15_;
            _tmp17_ = vala_slice_expression_new (inner, _tmp14_, stop, _tmp16_);
            _tmp18_ = (ValaExpression*) _tmp17_;
            _vala_source_reference_unref0 (_tmp16_);
            _vala_code_node_unref0 (_tmp14_);
            result = _tmp18_;
            _vala_code_node_unref0 (stop);
            _vala_iterable_unref0 (index_list);
            return result;
      }
      _vala_code_node_unref0 (stop);
      _vala_iterable_unref0 (index_list);
}


static ValaList* vala_parser_parse_expression_list (ValaParser* self, GError** error) {
      ValaList* result = NULL;
      ValaArrayList* _tmp0_ = NULL;
      ValaArrayList* list;
      GError * _inner_error_ = NULL;
      g_return_val_if_fail (self != NULL, NULL);
      _tmp0_ = vala_array_list_new (VALA_TYPE_EXPRESSION, (GBoxedCopyFunc) vala_code_node_ref, vala_code_node_unref, g_direct_equal);
      list = _tmp0_;
      {
            gboolean _tmp1_;
            _tmp1_ = TRUE;
            while (TRUE) {
                  ValaExpression* _tmp3_ = NULL;
                  ValaExpression* _tmp4_;
                  ValaExpression* _tmp5_;
                  if (!_tmp1_) {
                        gboolean _tmp2_;
                        _tmp2_ = vala_parser_accept (self, VALA_TOKEN_TYPE_COMMA);
                        if (!_tmp2_) {
                              break;
                        }
                  }
                  _tmp1_ = FALSE;
                  _tmp3_ = vala_parser_parse_expression (self, &_inner_error_);
                  _tmp4_ = _tmp3_;
                  if (_inner_error_ != NULL) {
                        if (_inner_error_->domain == VALA_PARSE_ERROR) {
                              g_propagate_error (error, _inner_error_);
                              _vala_iterable_unref0 (list);
                              return NULL;
                        } else {
                              _vala_iterable_unref0 (list);
                              g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                              g_clear_error (&_inner_error_);
                              return NULL;
                        }
                  }
                  _tmp5_ = _tmp4_;
                  vala_collection_add ((ValaCollection*) list, _tmp5_);
                  _vala_code_node_unref0 (_tmp5_);
            }
      }
      result = (ValaList*) list;
      return result;
}


static ValaExpression* vala_parser_parse_this_access (ValaParser* self, GError** error) {
      ValaExpression* result = NULL;
      ValaSourceLocation _tmp0_ = {0};
      ValaSourceLocation _tmp1_ = {0};
      ValaSourceLocation begin;
      ValaSourceReference* _tmp2_ = NULL;
      ValaSourceReference* _tmp3_;
      ValaMemberAccess* _tmp4_ = NULL;
      ValaExpression* _tmp5_;
      GError * _inner_error_ = NULL;
      g_return_val_if_fail (self != NULL, NULL);
      vala_parser_get_location (self, &_tmp0_);
      _tmp1_ = _tmp0_;
      begin = _tmp1_;
      vala_parser_expect (self, VALA_TOKEN_TYPE_THIS, &_inner_error_);
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  return NULL;
            } else {
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      _tmp2_ = vala_parser_get_src (self, &begin);
      _tmp3_ = _tmp2_;
      _tmp4_ = vala_member_access_new (NULL, "this", _tmp3_);
      _tmp5_ = (ValaExpression*) _tmp4_;
      _vala_source_reference_unref0 (_tmp3_);
      result = _tmp5_;
      return result;
}


static ValaExpression* vala_parser_parse_base_access (ValaParser* self, GError** error) {
      ValaExpression* result = NULL;
      ValaSourceLocation _tmp0_ = {0};
      ValaSourceLocation _tmp1_ = {0};
      ValaSourceLocation begin;
      ValaSourceReference* _tmp2_ = NULL;
      ValaSourceReference* _tmp3_;
      ValaBaseAccess* _tmp4_ = NULL;
      ValaExpression* _tmp5_;
      GError * _inner_error_ = NULL;
      g_return_val_if_fail (self != NULL, NULL);
      vala_parser_get_location (self, &_tmp0_);
      _tmp1_ = _tmp0_;
      begin = _tmp1_;
      vala_parser_expect (self, VALA_TOKEN_TYPE_BASE, &_inner_error_);
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  return NULL;
            } else {
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      _tmp2_ = vala_parser_get_src (self, &begin);
      _tmp3_ = _tmp2_;
      _tmp4_ = vala_base_access_new (_tmp3_);
      _tmp5_ = (ValaExpression*) _tmp4_;
      _vala_source_reference_unref0 (_tmp3_);
      result = _tmp5_;
      return result;
}


static ValaExpression* vala_parser_parse_post_increment_expression (ValaParser* self, ValaSourceLocation* begin, ValaExpression* inner, GError** error) {
      ValaExpression* result = NULL;
      ValaSourceReference* _tmp0_ = NULL;
      ValaSourceReference* _tmp1_;
      ValaPostfixExpression* _tmp2_ = NULL;
      ValaExpression* _tmp3_;
      GError * _inner_error_ = NULL;
      g_return_val_if_fail (self != NULL, NULL);
      g_return_val_if_fail (inner != NULL, NULL);
      vala_parser_expect (self, VALA_TOKEN_TYPE_OP_INC, &_inner_error_);
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  return NULL;
            } else {
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      _tmp0_ = vala_parser_get_src (self, begin);
      _tmp1_ = _tmp0_;
      _tmp2_ = vala_postfix_expression_new (inner, TRUE, _tmp1_);
      _tmp3_ = (ValaExpression*) _tmp2_;
      _vala_source_reference_unref0 (_tmp1_);
      result = _tmp3_;
      return result;
}


static ValaExpression* vala_parser_parse_post_decrement_expression (ValaParser* self, ValaSourceLocation* begin, ValaExpression* inner, GError** error) {
      ValaExpression* result = NULL;
      ValaSourceReference* _tmp0_ = NULL;
      ValaSourceReference* _tmp1_;
      ValaPostfixExpression* _tmp2_ = NULL;
      ValaExpression* _tmp3_;
      GError * _inner_error_ = NULL;
      g_return_val_if_fail (self != NULL, NULL);
      g_return_val_if_fail (inner != NULL, NULL);
      vala_parser_expect (self, VALA_TOKEN_TYPE_OP_DEC, &_inner_error_);
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  return NULL;
            } else {
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      _tmp0_ = vala_parser_get_src (self, begin);
      _tmp1_ = _tmp0_;
      _tmp2_ = vala_postfix_expression_new (inner, FALSE, _tmp1_);
      _tmp3_ = (ValaExpression*) _tmp2_;
      _vala_source_reference_unref0 (_tmp1_);
      result = _tmp3_;
      return result;
}


static ValaExpression* vala_parser_parse_object_or_array_creation_expression (ValaParser* self, GError** error) {
      ValaExpression* result = NULL;
      ValaSourceLocation _tmp0_ = {0};
      ValaSourceLocation _tmp1_ = {0};
      ValaSourceLocation begin;
      ValaMemberAccess* _tmp2_ = NULL;
      ValaMemberAccess* member;
      gboolean _tmp3_;
      GError * _inner_error_ = NULL;
      g_return_val_if_fail (self != NULL, NULL);
      vala_parser_get_location (self, &_tmp0_);
      _tmp1_ = _tmp0_;
      begin = _tmp1_;
      vala_parser_expect (self, VALA_TOKEN_TYPE_NEW, &_inner_error_);
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  return NULL;
            } else {
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      _tmp2_ = vala_parser_parse_member_name (self, NULL, &_inner_error_);
      member = _tmp2_;
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  return NULL;
            } else {
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      _tmp3_ = vala_parser_accept (self, VALA_TOKEN_TYPE_OPEN_PARENS);
      if (_tmp3_) {
            ValaExpression* _tmp4_ = NULL;
            ValaExpression* expr;
            _tmp4_ = vala_parser_parse_object_creation_expression (self, &begin, member, &_inner_error_);
            expr = _tmp4_;
            if (_inner_error_ != NULL) {
                  if (_inner_error_->domain == VALA_PARSE_ERROR) {
                        g_propagate_error (error, _inner_error_);
                        _vala_code_node_unref0 (member);
                        return NULL;
                  } else {
                        _vala_code_node_unref0 (member);
                        g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                        g_clear_error (&_inner_error_);
                        return NULL;
                  }
            }
            result = expr;
            _vala_code_node_unref0 (member);
            return result;
      } else {
            gboolean _tmp5_;
            _tmp5_ = vala_parser_accept (self, VALA_TOKEN_TYPE_OPEN_BRACKET);
            if (_tmp5_) {
                  ValaExpression* _tmp6_ = NULL;
                  ValaExpression* expr;
                  _tmp6_ = vala_parser_parse_array_creation_expression (self, &begin, member, &_inner_error_);
                  expr = _tmp6_;
                  if (_inner_error_ != NULL) {
                        if (_inner_error_->domain == VALA_PARSE_ERROR) {
                              g_propagate_error (error, _inner_error_);
                              _vala_code_node_unref0 (member);
                              return NULL;
                        } else {
                              _vala_code_node_unref0 (member);
                              g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                              g_clear_error (&_inner_error_);
                              return NULL;
                        }
                  }
                  result = expr;
                  _vala_code_node_unref0 (member);
                  return result;
            } else {
                  gchar* _tmp7_ = NULL;
                  gchar* _tmp8_;
                  GError* _tmp9_ = NULL;
                  GError* _tmp10_;
                  _tmp7_ = vala_parser_get_error (self, "expected ( or [");
                  _tmp8_ = _tmp7_;
                  _tmp9_ = g_error_new_literal (VALA_PARSE_ERROR, VALA_PARSE_ERROR_SYNTAX, _tmp8_);
                  _tmp10_ = _tmp9_;
                  _g_free0 (_tmp8_);
                  _inner_error_ = _tmp10_;
                  if (_inner_error_->domain == VALA_PARSE_ERROR) {
                        g_propagate_error (error, _inner_error_);
                        _vala_code_node_unref0 (member);
                        return NULL;
                  } else {
                        _vala_code_node_unref0 (member);
                        g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                        g_clear_error (&_inner_error_);
                        return NULL;
                  }
            }
      }
      _vala_code_node_unref0 (member);
}


static ValaExpression* vala_parser_parse_object_creation_expression (ValaParser* self, ValaSourceLocation* begin, ValaMemberAccess* member, GError** error) {
      ValaExpression* result = NULL;
      ValaList* _tmp0_ = NULL;
      ValaList* arg_list;
      ValaList* _tmp1_ = NULL;
      ValaList* init_list;
      ValaSourceReference* _tmp2_ = NULL;
      ValaSourceReference* _tmp3_;
      ValaObjectCreationExpression* _tmp4_ = NULL;
      ValaObjectCreationExpression* _tmp5_;
      ValaObjectCreationExpression* expr;
      GError * _inner_error_ = NULL;
      g_return_val_if_fail (self != NULL, NULL);
      g_return_val_if_fail (member != NULL, NULL);
      vala_member_access_set_creation_member (member, TRUE);
      _tmp0_ = vala_parser_parse_argument_list (self, &_inner_error_);
      arg_list = _tmp0_;
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  return NULL;
            } else {
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      vala_parser_expect (self, VALA_TOKEN_TYPE_CLOSE_PARENS, &_inner_error_);
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  _vala_iterable_unref0 (arg_list);
                  return NULL;
            } else {
                  _vala_iterable_unref0 (arg_list);
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      _tmp1_ = vala_parser_parse_object_initializer (self, &_inner_error_);
      init_list = _tmp1_;
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  _vala_iterable_unref0 (arg_list);
                  return NULL;
            } else {
                  _vala_iterable_unref0 (arg_list);
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      _tmp2_ = vala_parser_get_src (self, begin);
      _tmp3_ = _tmp2_;
      _tmp4_ = vala_object_creation_expression_new (member, _tmp3_);
      _tmp5_ = _tmp4_;
      _vala_source_reference_unref0 (_tmp3_);
      expr = _tmp5_;
      {
            ValaList* _tmp6_;
            ValaList* _arg_list;
            gint _tmp7_;
            gint _arg_size;
            gint _arg_index;
            _tmp6_ = _vala_iterable_ref0 (arg_list);
            _arg_list = _tmp6_;
            _tmp7_ = vala_collection_get_size ((ValaCollection*) _arg_list);
            _arg_size = _tmp7_;
            _arg_index = -1;
            while (TRUE) {
                  gpointer _tmp8_ = NULL;
                  ValaExpression* arg;
                  _arg_index = _arg_index + 1;
                  if (!(_arg_index < _arg_size)) {
                        break;
                  }
                  _tmp8_ = vala_list_get (_arg_list, _arg_index);
                  arg = (ValaExpression*) _tmp8_;
                  vala_object_creation_expression_add_argument (expr, arg);
                  _vala_code_node_unref0 (arg);
            }
            _vala_iterable_unref0 (_arg_list);
      }
      {
            ValaList* _tmp9_;
            ValaList* _initializer_list;
            gint _tmp10_;
            gint _initializer_size;
            gint _initializer_index;
            _tmp9_ = _vala_iterable_ref0 (init_list);
            _initializer_list = _tmp9_;
            _tmp10_ = vala_collection_get_size ((ValaCollection*) _initializer_list);
            _initializer_size = _tmp10_;
            _initializer_index = -1;
            while (TRUE) {
                  gpointer _tmp11_ = NULL;
                  ValaMemberInitializer* initializer;
                  _initializer_index = _initializer_index + 1;
                  if (!(_initializer_index < _initializer_size)) {
                        break;
                  }
                  _tmp11_ = vala_list_get (_initializer_list, _initializer_index);
                  initializer = (ValaMemberInitializer*) _tmp11_;
                  vala_object_creation_expression_add_member_initializer (expr, initializer);
                  _vala_code_node_unref0 (initializer);
            }
            _vala_iterable_unref0 (_initializer_list);
      }
      result = (ValaExpression*) expr;
      _vala_iterable_unref0 (init_list);
      _vala_iterable_unref0 (arg_list);
      return result;
}


static ValaExpression* vala_parser_parse_object_literal (ValaParser* self, ValaSourceLocation* begin, ValaMemberAccess* member, GError** error) {
      ValaExpression* result = NULL;
      ValaSourceReference* _tmp0_ = NULL;
      ValaSourceReference* _tmp1_;
      ValaObjectCreationExpression* _tmp2_ = NULL;
      ValaObjectCreationExpression* _tmp3_;
      ValaObjectCreationExpression* expr;
      GError * _inner_error_ = NULL;
      g_return_val_if_fail (self != NULL, NULL);
      g_return_val_if_fail (member != NULL, NULL);
      vala_member_access_set_creation_member (member, TRUE);
      _tmp0_ = vala_parser_get_src (self, begin);
      _tmp1_ = _tmp0_;
      _tmp2_ = vala_object_creation_expression_new (member, _tmp1_);
      _tmp3_ = _tmp2_;
      _vala_source_reference_unref0 (_tmp1_);
      expr = _tmp3_;
      vala_parser_expect (self, VALA_TOKEN_TYPE_OPEN_BRACE, &_inner_error_);
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  _vala_code_node_unref0 (expr);
                  return NULL;
            } else {
                  _vala_code_node_unref0 (expr);
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      {
            gboolean _tmp4_;
            _tmp4_ = TRUE;
            while (TRUE) {
                  ValaSourceLocation _tmp6_ = {0};
                  ValaSourceLocation _tmp7_ = {0};
                  ValaSourceLocation member_begin;
                  gchar* _tmp8_ = NULL;
                  gchar* id;
                  ValaExpression* _tmp9_ = NULL;
                  ValaExpression* member_expr;
                  ValaSourceReference* _tmp10_ = NULL;
                  ValaSourceReference* _tmp11_;
                  ValaMemberInitializer* _tmp12_ = NULL;
                  ValaMemberInitializer* _tmp13_;
                  if (!_tmp4_) {
                        gboolean _tmp5_;
                        _tmp5_ = vala_parser_accept (self, VALA_TOKEN_TYPE_COMMA);
                        if (!_tmp5_) {
                              break;
                        }
                  }
                  _tmp4_ = FALSE;
                  vala_parser_get_location (self, &_tmp6_);
                  _tmp7_ = _tmp6_;
                  member_begin = _tmp7_;
                  _tmp8_ = vala_parser_parse_identifier (self, &_inner_error_);
                  id = _tmp8_;
                  if (_inner_error_ != NULL) {
                        if (_inner_error_->domain == VALA_PARSE_ERROR) {
                              g_propagate_error (error, _inner_error_);
                              _vala_code_node_unref0 (expr);
                              return NULL;
                        } else {
                              _vala_code_node_unref0 (expr);
                              g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                              g_clear_error (&_inner_error_);
                              return NULL;
                        }
                  }
                  vala_parser_expect (self, VALA_TOKEN_TYPE_COLON, &_inner_error_);
                  if (_inner_error_ != NULL) {
                        if (_inner_error_->domain == VALA_PARSE_ERROR) {
                              g_propagate_error (error, _inner_error_);
                              _g_free0 (id);
                              _vala_code_node_unref0 (expr);
                              return NULL;
                        } else {
                              _g_free0 (id);
                              _vala_code_node_unref0 (expr);
                              g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                              g_clear_error (&_inner_error_);
                              return NULL;
                        }
                  }
                  _tmp9_ = vala_parser_parse_expression (self, &_inner_error_);
                  member_expr = _tmp9_;
                  if (_inner_error_ != NULL) {
                        if (_inner_error_->domain == VALA_PARSE_ERROR) {
                              g_propagate_error (error, _inner_error_);
                              _g_free0 (id);
                              _vala_code_node_unref0 (expr);
                              return NULL;
                        } else {
                              _g_free0 (id);
                              _vala_code_node_unref0 (expr);
                              g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                              g_clear_error (&_inner_error_);
                              return NULL;
                        }
                  }
                  _tmp10_ = vala_parser_get_src (self, &member_begin);
                  _tmp11_ = _tmp10_;
                  _tmp12_ = vala_member_initializer_new (id, member_expr, _tmp11_);
                  _tmp13_ = _tmp12_;
                  vala_object_creation_expression_add_member_initializer (expr, _tmp13_);
                  _vala_code_node_unref0 (_tmp13_);
                  _vala_source_reference_unref0 (_tmp11_);
                  _vala_code_node_unref0 (member_expr);
                  _g_free0 (id);
            }
      }
      vala_parser_expect (self, VALA_TOKEN_TYPE_CLOSE_BRACE, &_inner_error_);
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  _vala_code_node_unref0 (expr);
                  return NULL;
            } else {
                  _vala_code_node_unref0 (expr);
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      result = (ValaExpression*) expr;
      return result;
}


static ValaExpression* vala_parser_parse_array_creation_expression (ValaParser* self, ValaSourceLocation* begin, ValaMemberAccess* member, GError** error) {
      ValaExpression* result = NULL;
      gboolean size_specified;
      ValaList* size_specifier_list;
      gboolean first;
      ValaUnresolvedType* _tmp0_ = NULL;
      ValaDataType* element_type;
      ValaInitializerList* initializer;
      gboolean _tmp20_ = FALSE;
      ValaProfile _tmp21_;
      gint _tmp25_;
      ValaSourceReference* _tmp26_ = NULL;
      ValaSourceReference* _tmp27_;
      ValaArrayCreationExpression* _tmp28_ = NULL;
      ValaArrayCreationExpression* _tmp29_;
      ValaArrayCreationExpression* expr;
      GError * _inner_error_ = NULL;
      g_return_val_if_fail (self != NULL, NULL);
      g_return_val_if_fail (member != NULL, NULL);
      size_specified = FALSE;
      size_specifier_list = NULL;
      first = TRUE;
      _tmp0_ = vala_unresolved_type_new_from_expression ((ValaExpression*) member);
      element_type = (ValaDataType*) _tmp0_;
      {
            gboolean _tmp1_;
            _tmp1_ = TRUE;
            while (TRUE) {
                  ValaArrayList* _tmp10_ = NULL;
                  if (!_tmp1_) {
                        gboolean _tmp2_;
                        _tmp2_ = vala_parser_accept (self, VALA_TOKEN_TYPE_OPEN_BRACKET);
                        if (!_tmp2_) {
                              break;
                        }
                  }
                  _tmp1_ = FALSE;
                  if (!first) {
                        gint _tmp7_;
                        ValaSourceReference* _tmp8_ = NULL;
                        ValaArrayType* _tmp9_ = NULL;
                        if (size_specified) {
                              gchar* _tmp3_ = NULL;
                              gchar* _tmp4_;
                              GError* _tmp5_ = NULL;
                              GError* _tmp6_;
                              _tmp3_ = vala_parser_get_error (self, "size of inner arrays must not be specified in array creation expressio" \
"n");
                              _tmp4_ = _tmp3_;
                              _tmp5_ = g_error_new_literal (VALA_PARSE_ERROR, VALA_PARSE_ERROR_SYNTAX, _tmp4_);
                              _tmp6_ = _tmp5_;
                              _g_free0 (_tmp4_);
                              _inner_error_ = _tmp6_;
                              if (_inner_error_->domain == VALA_PARSE_ERROR) {
                                    g_propagate_error (error, _inner_error_);
                                    _vala_code_node_unref0 (element_type);
                                    _vala_iterable_unref0 (size_specifier_list);
                                    return NULL;
                              } else {
                                    _vala_code_node_unref0 (element_type);
                                    _vala_iterable_unref0 (size_specifier_list);
                                    g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                                    g_clear_error (&_inner_error_);
                                    return NULL;
                              }
                        }
                        _tmp7_ = vala_collection_get_size ((ValaCollection*) size_specifier_list);
                        _tmp8_ = vala_code_node_get_source_reference ((ValaCodeNode*) element_type);
                        _tmp9_ = vala_array_type_new (element_type, _tmp7_, _tmp8_);
                        _vala_code_node_unref0 (element_type);
                        element_type = (ValaDataType*) _tmp9_;
                  } else {
                        first = FALSE;
                  }
                  _tmp10_ = vala_array_list_new (VALA_TYPE_EXPRESSION, (GBoxedCopyFunc) vala_code_node_ref, vala_code_node_unref, g_direct_equal);
                  _vala_iterable_unref0 (size_specifier_list);
                  size_specifier_list = (ValaList*) _tmp10_;
                  {
                        gboolean _tmp11_;
                        _tmp11_ = TRUE;
                        while (TRUE) {
                              ValaExpression* size;
                              gboolean _tmp15_ = FALSE;
                              ValaTokenType _tmp16_;
                              if (!_tmp11_) {
                                    gboolean _tmp12_ = FALSE;
                                    ValaProfile _tmp13_;
                                    _tmp13_ = vala_code_context_get_profile (self->priv->context);
                                    if (_tmp13_ != VALA_PROFILE_DOVA) {
                                          gboolean _tmp14_;
                                          _tmp14_ = vala_parser_accept (self, VALA_TOKEN_TYPE_COMMA);
                                          _tmp12_ = _tmp14_;
                                    } else {
                                          _tmp12_ = FALSE;
                                    }
                                    if (!_tmp12_) {
                                          break;
                                    }
                              }
                              _tmp11_ = FALSE;
                              size = NULL;
                              _tmp16_ = vala_parser_current (self);
                              if (_tmp16_ != VALA_TOKEN_TYPE_CLOSE_BRACKET) {
                                    ValaTokenType _tmp17_;
                                    _tmp17_ = vala_parser_current (self);
                                    _tmp15_ = _tmp17_ != VALA_TOKEN_TYPE_COMMA;
                              } else {
                                    _tmp15_ = FALSE;
                              }
                              if (_tmp15_) {
                                    ValaExpression* _tmp18_ = NULL;
                                    ValaExpression* _tmp19_;
                                    _tmp18_ = vala_parser_parse_expression (self, &_inner_error_);
                                    _tmp19_ = _tmp18_;
                                    if (_inner_error_ != NULL) {
                                          if (_inner_error_->domain == VALA_PARSE_ERROR) {
                                                g_propagate_error (error, _inner_error_);
                                                _vala_code_node_unref0 (size);
                                                _vala_code_node_unref0 (element_type);
                                                _vala_iterable_unref0 (size_specifier_list);
                                                return NULL;
                                          } else {
                                                _vala_code_node_unref0 (size);
                                                _vala_code_node_unref0 (element_type);
                                                _vala_iterable_unref0 (size_specifier_list);
                                                g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                                                g_clear_error (&_inner_error_);
                                                return NULL;
                                          }
                                    }
                                    _vala_code_node_unref0 (size);
                                    size = _tmp19_;
                                    size_specified = TRUE;
                              }
                              vala_collection_add ((ValaCollection*) size_specifier_list, size);
                              _vala_code_node_unref0 (size);
                        }
                  }
                  vala_parser_expect (self, VALA_TOKEN_TYPE_CLOSE_BRACKET, &_inner_error_);
                  if (_inner_error_ != NULL) {
                        if (_inner_error_->domain == VALA_PARSE_ERROR) {
                              g_propagate_error (error, _inner_error_);
                              _vala_code_node_unref0 (element_type);
                              _vala_iterable_unref0 (size_specifier_list);
                              return NULL;
                        } else {
                              _vala_code_node_unref0 (element_type);
                              _vala_iterable_unref0 (size_specifier_list);
                              g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                              g_clear_error (&_inner_error_);
                              return NULL;
                        }
                  }
            }
      }
      initializer = NULL;
      _tmp21_ = vala_code_context_get_profile (self->priv->context);
      if (_tmp21_ != VALA_PROFILE_DOVA) {
            ValaTokenType _tmp22_;
            _tmp22_ = vala_parser_current (self);
            _tmp20_ = _tmp22_ == VALA_TOKEN_TYPE_OPEN_BRACE;
      } else {
            _tmp20_ = FALSE;
      }
      if (_tmp20_) {
            ValaInitializerList* _tmp23_ = NULL;
            ValaInitializerList* _tmp24_;
            _tmp23_ = vala_parser_parse_initializer (self, &_inner_error_);
            _tmp24_ = _tmp23_;
            if (_inner_error_ != NULL) {
                  if (_inner_error_->domain == VALA_PARSE_ERROR) {
                        g_propagate_error (error, _inner_error_);
                        _vala_code_node_unref0 (initializer);
                        _vala_code_node_unref0 (element_type);
                        _vala_iterable_unref0 (size_specifier_list);
                        return NULL;
                  } else {
                        _vala_code_node_unref0 (initializer);
                        _vala_code_node_unref0 (element_type);
                        _vala_iterable_unref0 (size_specifier_list);
                        g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                        g_clear_error (&_inner_error_);
                        return NULL;
                  }
            }
            _vala_code_node_unref0 (initializer);
            initializer = _tmp24_;
      }
      _tmp25_ = vala_collection_get_size ((ValaCollection*) size_specifier_list);
      _tmp26_ = vala_parser_get_src (self, begin);
      _tmp27_ = _tmp26_;
      _tmp28_ = vala_array_creation_expression_new (element_type, _tmp25_, initializer, _tmp27_);
      _tmp29_ = _tmp28_;
      _vala_source_reference_unref0 (_tmp27_);
      expr = _tmp29_;
      if (size_specified) {
            {
                  ValaList* _tmp30_;
                  ValaList* _size_list;
                  gint _tmp31_;
                  gint _size_size;
                  gint _size_index;
                  _tmp30_ = _vala_iterable_ref0 (size_specifier_list);
                  _size_list = _tmp30_;
                  _tmp31_ = vala_collection_get_size ((ValaCollection*) _size_list);
                  _size_size = _tmp31_;
                  _size_index = -1;
                  while (TRUE) {
                        gpointer _tmp32_ = NULL;
                        ValaExpression* size;
                        _size_index = _size_index + 1;
                        if (!(_size_index < _size_size)) {
                              break;
                        }
                        _tmp32_ = vala_list_get (_size_list, _size_index);
                        size = (ValaExpression*) _tmp32_;
                        vala_array_creation_expression_append_size (expr, size);
                        _vala_code_node_unref0 (size);
                  }
                  _vala_iterable_unref0 (_size_list);
            }
      }
      result = (ValaExpression*) expr;
      _vala_code_node_unref0 (initializer);
      _vala_code_node_unref0 (element_type);
      _vala_iterable_unref0 (size_specifier_list);
      return result;
}


static ValaList* vala_parser_parse_object_initializer (ValaParser* self, GError** error) {
      ValaList* result = NULL;
      ValaArrayList* _tmp0_ = NULL;
      ValaArrayList* list;
      gboolean _tmp1_ = FALSE;
      ValaProfile _tmp2_;
      GError * _inner_error_ = NULL;
      g_return_val_if_fail (self != NULL, NULL);
      _tmp0_ = vala_array_list_new (VALA_TYPE_MEMBER_INITIALIZER, (GBoxedCopyFunc) vala_code_node_ref, vala_code_node_unref, g_direct_equal);
      list = _tmp0_;
      _tmp2_ = vala_code_context_get_profile (self->priv->context);
      if (_tmp2_ != VALA_PROFILE_DOVA) {
            gboolean _tmp3_;
            _tmp3_ = vala_parser_accept (self, VALA_TOKEN_TYPE_OPEN_BRACE);
            _tmp1_ = _tmp3_;
      } else {
            _tmp1_ = FALSE;
      }
      if (_tmp1_) {
            {
                  gboolean _tmp4_;
                  _tmp4_ = TRUE;
                  while (TRUE) {
                        ValaMemberInitializer* _tmp6_ = NULL;
                        ValaMemberInitializer* _tmp7_;
                        ValaMemberInitializer* _tmp8_;
                        if (!_tmp4_) {
                              gboolean _tmp5_;
                              _tmp5_ = vala_parser_accept (self, VALA_TOKEN_TYPE_COMMA);
                              if (!_tmp5_) {
                                    break;
                              }
                        }
                        _tmp4_ = FALSE;
                        _tmp6_ = vala_parser_parse_member_initializer (self, &_inner_error_);
                        _tmp7_ = _tmp6_;
                        if (_inner_error_ != NULL) {
                              if (_inner_error_->domain == VALA_PARSE_ERROR) {
                                    g_propagate_error (error, _inner_error_);
                                    _vala_iterable_unref0 (list);
                                    return NULL;
                              } else {
                                    _vala_iterable_unref0 (list);
                                    g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                                    g_clear_error (&_inner_error_);
                                    return NULL;
                              }
                        }
                        _tmp8_ = _tmp7_;
                        vala_collection_add ((ValaCollection*) list, _tmp8_);
                        _vala_code_node_unref0 (_tmp8_);
                  }
            }
            vala_parser_expect (self, VALA_TOKEN_TYPE_CLOSE_BRACE, &_inner_error_);
            if (_inner_error_ != NULL) {
                  if (_inner_error_->domain == VALA_PARSE_ERROR) {
                        g_propagate_error (error, _inner_error_);
                        _vala_iterable_unref0 (list);
                        return NULL;
                  } else {
                        _vala_iterable_unref0 (list);
                        g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                        g_clear_error (&_inner_error_);
                        return NULL;
                  }
            }
      }
      result = (ValaList*) list;
      return result;
}


static ValaMemberInitializer* vala_parser_parse_member_initializer (ValaParser* self, GError** error) {
      ValaMemberInitializer* result = NULL;
      ValaSourceLocation _tmp0_ = {0};
      ValaSourceLocation _tmp1_ = {0};
      ValaSourceLocation begin;
      gchar* _tmp2_ = NULL;
      gchar* id;
      ValaExpression* _tmp3_ = NULL;
      ValaExpression* expr;
      ValaSourceReference* _tmp4_ = NULL;
      ValaSourceReference* _tmp5_;
      ValaMemberInitializer* _tmp6_ = NULL;
      ValaMemberInitializer* _tmp7_;
      GError * _inner_error_ = NULL;
      g_return_val_if_fail (self != NULL, NULL);
      vala_parser_get_location (self, &_tmp0_);
      _tmp1_ = _tmp0_;
      begin = _tmp1_;
      _tmp2_ = vala_parser_parse_identifier (self, &_inner_error_);
      id = _tmp2_;
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  return NULL;
            } else {
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      vala_parser_expect (self, VALA_TOKEN_TYPE_ASSIGN, &_inner_error_);
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  _g_free0 (id);
                  return NULL;
            } else {
                  _g_free0 (id);
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      _tmp3_ = vala_parser_parse_expression (self, &_inner_error_);
      expr = _tmp3_;
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  _g_free0 (id);
                  return NULL;
            } else {
                  _g_free0 (id);
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      _tmp4_ = vala_parser_get_src (self, &begin);
      _tmp5_ = _tmp4_;
      _tmp6_ = vala_member_initializer_new (id, expr, _tmp5_);
      _tmp7_ = _tmp6_;
      _vala_source_reference_unref0 (_tmp5_);
      result = _tmp7_;
      _vala_code_node_unref0 (expr);
      _g_free0 (id);
      return result;
}


static ValaExpression* vala_parser_parse_yield_expression (ValaParser* self, GError** error) {
      ValaExpression* result = NULL;
      ValaExpression* _tmp0_ = NULL;
      ValaExpression* expr;
      ValaExpression* _tmp1_;
      ValaMethodCall* _tmp2_;
      ValaMethodCall* call;
      GError * _inner_error_ = NULL;
      g_return_val_if_fail (self != NULL, NULL);
      vala_parser_expect (self, VALA_TOKEN_TYPE_YIELD, &_inner_error_);
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  return NULL;
            } else {
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      _tmp0_ = vala_parser_parse_expression (self, &_inner_error_);
      expr = _tmp0_;
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  return NULL;
            } else {
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      _tmp1_ = expr;
      _tmp2_ = _vala_code_node_ref0 (VALA_IS_METHOD_CALL (_tmp1_) ? ((ValaMethodCall*) _tmp1_) : NULL);
      call = _tmp2_;
      if (call == NULL) {
            ValaSourceReference* _tmp3_ = NULL;
            GError* _tmp4_ = NULL;
            _tmp3_ = vala_code_node_get_source_reference ((ValaCodeNode*) expr);
            vala_report_error (_tmp3_, "syntax error, expected method call");
            _tmp4_ = g_error_new_literal (VALA_PARSE_ERROR, VALA_PARSE_ERROR_SYNTAX, "expected method call");
            _inner_error_ = _tmp4_;
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  _vala_code_node_unref0 (call);
                  _vala_code_node_unref0 (expr);
                  return NULL;
            } else {
                  _vala_code_node_unref0 (call);
                  _vala_code_node_unref0 (expr);
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      vala_method_call_set_is_yield_expression (call, TRUE);
      result = (ValaExpression*) call;
      _vala_code_node_unref0 (expr);
      return result;
}


static ValaExpression* vala_parser_parse_sizeof_expression (ValaParser* self, GError** error) {
      ValaExpression* result = NULL;
      ValaSourceLocation _tmp0_ = {0};
      ValaSourceLocation _tmp1_ = {0};
      ValaSourceLocation begin;
      ValaDataType* _tmp2_ = NULL;
      ValaDataType* type;
      ValaSourceReference* _tmp3_ = NULL;
      ValaSourceReference* _tmp4_;
      ValaSizeofExpression* _tmp5_ = NULL;
      ValaExpression* _tmp6_;
      GError * _inner_error_ = NULL;
      g_return_val_if_fail (self != NULL, NULL);
      vala_parser_get_location (self, &_tmp0_);
      _tmp1_ = _tmp0_;
      begin = _tmp1_;
      vala_parser_expect (self, VALA_TOKEN_TYPE_SIZEOF, &_inner_error_);
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  return NULL;
            } else {
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      vala_parser_expect (self, VALA_TOKEN_TYPE_OPEN_PARENS, &_inner_error_);
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  return NULL;
            } else {
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      _tmp2_ = vala_parser_parse_type (self, TRUE, FALSE, &_inner_error_);
      type = _tmp2_;
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  return NULL;
            } else {
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      vala_parser_expect (self, VALA_TOKEN_TYPE_CLOSE_PARENS, &_inner_error_);
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  _vala_code_node_unref0 (type);
                  return NULL;
            } else {
                  _vala_code_node_unref0 (type);
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      _tmp3_ = vala_parser_get_src (self, &begin);
      _tmp4_ = _tmp3_;
      _tmp5_ = vala_sizeof_expression_new (type, _tmp4_);
      _tmp6_ = (ValaExpression*) _tmp5_;
      _vala_source_reference_unref0 (_tmp4_);
      result = _tmp6_;
      _vala_code_node_unref0 (type);
      return result;
}


static ValaExpression* vala_parser_parse_typeof_expression (ValaParser* self, GError** error) {
      ValaExpression* result = NULL;
      ValaSourceLocation _tmp0_ = {0};
      ValaSourceLocation _tmp1_ = {0};
      ValaSourceLocation begin;
      ValaDataType* _tmp2_ = NULL;
      ValaDataType* type;
      ValaSourceReference* _tmp3_ = NULL;
      ValaSourceReference* _tmp4_;
      ValaTypeofExpression* _tmp5_ = NULL;
      ValaExpression* _tmp6_;
      GError * _inner_error_ = NULL;
      g_return_val_if_fail (self != NULL, NULL);
      vala_parser_get_location (self, &_tmp0_);
      _tmp1_ = _tmp0_;
      begin = _tmp1_;
      vala_parser_expect (self, VALA_TOKEN_TYPE_TYPEOF, &_inner_error_);
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  return NULL;
            } else {
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      vala_parser_expect (self, VALA_TOKEN_TYPE_OPEN_PARENS, &_inner_error_);
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  return NULL;
            } else {
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      _tmp2_ = vala_parser_parse_type (self, TRUE, FALSE, &_inner_error_);
      type = _tmp2_;
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  return NULL;
            } else {
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      vala_parser_expect (self, VALA_TOKEN_TYPE_CLOSE_PARENS, &_inner_error_);
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  _vala_code_node_unref0 (type);
                  return NULL;
            } else {
                  _vala_code_node_unref0 (type);
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      _tmp3_ = vala_parser_get_src (self, &begin);
      _tmp4_ = _tmp3_;
      _tmp5_ = vala_typeof_expression_new (type, _tmp4_);
      _tmp6_ = (ValaExpression*) _tmp5_;
      _vala_source_reference_unref0 (_tmp4_);
      result = _tmp6_;
      _vala_code_node_unref0 (type);
      return result;
}


static ValaUnaryOperator vala_parser_get_unary_operator (ValaParser* self, ValaTokenType token_type) {
      ValaUnaryOperator result = 0;
      g_return_val_if_fail (self != NULL, 0);
      switch (token_type) {
            case VALA_TOKEN_TYPE_PLUS:
            {
                  result = VALA_UNARY_OPERATOR_PLUS;
                  return result;
            }
            case VALA_TOKEN_TYPE_MINUS:
            {
                  result = VALA_UNARY_OPERATOR_MINUS;
                  return result;
            }
            case VALA_TOKEN_TYPE_OP_NEG:
            {
                  result = VALA_UNARY_OPERATOR_LOGICAL_NEGATION;
                  return result;
            }
            case VALA_TOKEN_TYPE_TILDE:
            {
                  result = VALA_UNARY_OPERATOR_BITWISE_COMPLEMENT;
                  return result;
            }
            case VALA_TOKEN_TYPE_OP_INC:
            {
                  result = VALA_UNARY_OPERATOR_INCREMENT;
                  return result;
            }
            case VALA_TOKEN_TYPE_OP_DEC:
            {
                  result = VALA_UNARY_OPERATOR_DECREMENT;
                  return result;
            }
            default:
            {
                  result = VALA_UNARY_OPERATOR_NONE;
                  return result;
            }
      }
}


static ValaExpression* vala_parser_parse_unary_expression (ValaParser* self, GError** error) {
      ValaExpression* result = NULL;
      ValaSourceLocation _tmp0_ = {0};
      ValaSourceLocation _tmp1_ = {0};
      ValaSourceLocation begin;
      ValaTokenType _tmp2_;
      ValaUnaryOperator _tmp3_;
      ValaUnaryOperator operator;
      ValaTokenType _tmp9_;
      ValaExpression* _tmp49_ = NULL;
      ValaExpression* expr;
      GError * _inner_error_ = NULL;
      g_return_val_if_fail (self != NULL, NULL);
      vala_parser_get_location (self, &_tmp0_);
      _tmp1_ = _tmp0_;
      begin = _tmp1_;
      _tmp2_ = vala_parser_current (self);
      _tmp3_ = vala_parser_get_unary_operator (self, _tmp2_);
      operator = _tmp3_;
      if (operator != VALA_UNARY_OPERATOR_NONE) {
            ValaExpression* _tmp4_ = NULL;
            ValaExpression* op;
            ValaSourceReference* _tmp5_ = NULL;
            ValaSourceReference* _tmp6_;
            ValaUnaryExpression* _tmp7_ = NULL;
            ValaExpression* _tmp8_;
            vala_parser_next (self);
            _tmp4_ = vala_parser_parse_unary_expression (self, &_inner_error_);
            op = _tmp4_;
            if (_inner_error_ != NULL) {
                  if (_inner_error_->domain == VALA_PARSE_ERROR) {
                        g_propagate_error (error, _inner_error_);
                        return NULL;
                  } else {
                        g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                        g_clear_error (&_inner_error_);
                        return NULL;
                  }
            }
            _tmp5_ = vala_parser_get_src (self, &begin);
            _tmp6_ = _tmp5_;
            _tmp7_ = vala_unary_expression_new (operator, op, _tmp6_);
            _tmp8_ = (ValaExpression*) _tmp7_;
            _vala_source_reference_unref0 (_tmp6_);
            result = _tmp8_;
            _vala_code_node_unref0 (op);
            return result;
      }
      _tmp9_ = vala_parser_current (self);
      switch (_tmp9_) {
            case VALA_TOKEN_TYPE_HASH:
            {
                  gboolean _tmp10_;
                  ValaExpression* _tmp13_ = NULL;
                  ValaExpression* op;
                  ValaSourceReference* _tmp14_ = NULL;
                  ValaSourceReference* _tmp15_;
                  ValaReferenceTransferExpression* _tmp16_ = NULL;
                  ValaExpression* _tmp17_;
                  _tmp10_ = vala_code_context_get_deprecated (self->priv->context);
                  if (!_tmp10_) {
                        ValaSourceReference* _tmp11_ = NULL;
                        ValaSourceReference* _tmp12_;
                        _tmp11_ = vala_parser_get_last_src (self);
                        _tmp12_ = _tmp11_;
                        vala_report_warning (_tmp12_, "deprecated syntax, use `(owned)` cast");
                        _vala_source_reference_unref0 (_tmp12_);
                  }
                  vala_parser_next (self);
                  _tmp13_ = vala_parser_parse_unary_expression (self, &_inner_error_);
                  op = _tmp13_;
                  if (_inner_error_ != NULL) {
                        if (_inner_error_->domain == VALA_PARSE_ERROR) {
                              g_propagate_error (error, _inner_error_);
                              return NULL;
                        } else {
                              g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                              g_clear_error (&_inner_error_);
                              return NULL;
                        }
                  }
                  _tmp14_ = vala_parser_get_src (self, &begin);
                  _tmp15_ = _tmp14_;
                  _tmp16_ = vala_reference_transfer_expression_new (op, _tmp15_);
                  _tmp17_ = (ValaExpression*) _tmp16_;
                  _vala_source_reference_unref0 (_tmp15_);
                  result = _tmp17_;
                  _vala_code_node_unref0 (op);
                  return result;
            }
            case VALA_TOKEN_TYPE_OPEN_PARENS:
            {
                  ValaTokenType _tmp18_;
                  vala_parser_next (self);
                  _tmp18_ = vala_parser_current (self);
                  switch (_tmp18_) {
                        case VALA_TOKEN_TYPE_OWNED:
                        {
                              gboolean _tmp19_;
                              vala_parser_next (self);
                              _tmp19_ = vala_parser_accept (self, VALA_TOKEN_TYPE_CLOSE_PARENS);
                              if (_tmp19_) {
                                    ValaExpression* _tmp20_ = NULL;
                                    ValaExpression* op;
                                    ValaSourceReference* _tmp21_ = NULL;
                                    ValaSourceReference* _tmp22_;
                                    ValaReferenceTransferExpression* _tmp23_ = NULL;
                                    ValaExpression* _tmp24_;
                                    _tmp20_ = vala_parser_parse_unary_expression (self, &_inner_error_);
                                    op = _tmp20_;
                                    if (_inner_error_ != NULL) {
                                          if (_inner_error_->domain == VALA_PARSE_ERROR) {
                                                g_propagate_error (error, _inner_error_);
                                                return NULL;
                                          } else {
                                                g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                                                g_clear_error (&_inner_error_);
                                                return NULL;
                                          }
                                    }
                                    _tmp21_ = vala_parser_get_src (self, &begin);
                                    _tmp22_ = _tmp21_;
                                    _tmp23_ = vala_reference_transfer_expression_new (op, _tmp22_);
                                    _tmp24_ = (ValaExpression*) _tmp23_;
                                    _vala_source_reference_unref0 (_tmp22_);
                                    result = _tmp24_;
                                    _vala_code_node_unref0 (op);
                                    return result;
                              }
                              break;
                        }
                        case VALA_TOKEN_TYPE_VOID:
                        case VALA_TOKEN_TYPE_DYNAMIC:
                        case VALA_TOKEN_TYPE_IDENTIFIER:
                        {
                              ValaDataType* _tmp25_ = NULL;
                              ValaDataType* type;
                              gboolean _tmp26_;
                              _tmp25_ = vala_parser_parse_type (self, TRUE, FALSE, &_inner_error_);
                              type = _tmp25_;
                              if (_inner_error_ != NULL) {
                                    if (_inner_error_->domain == VALA_PARSE_ERROR) {
                                          g_propagate_error (error, _inner_error_);
                                          return NULL;
                                    } else {
                                          g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                                          g_clear_error (&_inner_error_);
                                          return NULL;
                                    }
                              }
                              _tmp26_ = vala_parser_accept (self, VALA_TOKEN_TYPE_CLOSE_PARENS);
                              if (_tmp26_) {
                                    ValaTokenType _tmp27_;
                                    _tmp27_ = vala_parser_current (self);
                                    switch (_tmp27_) {
                                          case VALA_TOKEN_TYPE_OP_NEG:
                                          case VALA_TOKEN_TYPE_TILDE:
                                          case VALA_TOKEN_TYPE_OPEN_PARENS:
                                          case VALA_TOKEN_TYPE_TRUE:
                                          case VALA_TOKEN_TYPE_FALSE:
                                          case VALA_TOKEN_TYPE_INTEGER_LITERAL:
                                          case VALA_TOKEN_TYPE_REAL_LITERAL:
                                          case VALA_TOKEN_TYPE_CHARACTER_LITERAL:
                                          case VALA_TOKEN_TYPE_STRING_LITERAL:
                                          case VALA_TOKEN_TYPE_TEMPLATE_STRING_LITERAL:
                                          case VALA_TOKEN_TYPE_VERBATIM_STRING_LITERAL:
                                          case VALA_TOKEN_TYPE_REGEX_LITERAL:
                                          case VALA_TOKEN_TYPE_NULL:
                                          case VALA_TOKEN_TYPE_THIS:
                                          case VALA_TOKEN_TYPE_BASE:
                                          case VALA_TOKEN_TYPE_NEW:
                                          case VALA_TOKEN_TYPE_YIELD:
                                          case VALA_TOKEN_TYPE_SIZEOF:
                                          case VALA_TOKEN_TYPE_TYPEOF:
                                          case VALA_TOKEN_TYPE_IDENTIFIER:
                                          case VALA_TOKEN_TYPE_PARAMS:
                                          {
                                                ValaExpression* _tmp28_ = NULL;
                                                ValaExpression* inner;
                                                ValaSourceReference* _tmp29_ = NULL;
                                                ValaSourceReference* _tmp30_;
                                                ValaCastExpression* _tmp31_ = NULL;
                                                ValaExpression* _tmp32_;
                                                _tmp28_ = vala_parser_parse_unary_expression (self, &_inner_error_);
                                                inner = _tmp28_;
                                                if (_inner_error_ != NULL) {
                                                      if (_inner_error_->domain == VALA_PARSE_ERROR) {
                                                            g_propagate_error (error, _inner_error_);
                                                            _vala_code_node_unref0 (type);
                                                            return NULL;
                                                      } else {
                                                            _vala_code_node_unref0 (type);
                                                            g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                                                            g_clear_error (&_inner_error_);
                                                            return NULL;
                                                      }
                                                }
                                                _tmp29_ = vala_parser_get_src (self, &begin);
                                                _tmp30_ = _tmp29_;
                                                _tmp31_ = vala_cast_expression_new (inner, type, _tmp30_, FALSE);
                                                _tmp32_ = (ValaExpression*) _tmp31_;
                                                _vala_source_reference_unref0 (_tmp30_);
                                                result = _tmp32_;
                                                _vala_code_node_unref0 (inner);
                                                _vala_code_node_unref0 (type);
                                                return result;
                                          }
                                          default:
                                          {
                                                break;
                                          }
                                    }
                              }
                              _vala_code_node_unref0 (type);
                              break;
                        }
                        case VALA_TOKEN_TYPE_OP_NEG:
                        {
                              gboolean _tmp33_;
                              vala_parser_next (self);
                              _tmp33_ = vala_parser_accept (self, VALA_TOKEN_TYPE_CLOSE_PARENS);
                              if (_tmp33_) {
                                    ValaExpression* _tmp34_ = NULL;
                                    ValaExpression* inner;
                                    ValaSourceReference* _tmp35_ = NULL;
                                    ValaSourceReference* _tmp36_;
                                    ValaCastExpression* _tmp37_ = NULL;
                                    ValaExpression* _tmp38_;
                                    _tmp34_ = vala_parser_parse_unary_expression (self, &_inner_error_);
                                    inner = _tmp34_;
                                    if (_inner_error_ != NULL) {
                                          if (_inner_error_->domain == VALA_PARSE_ERROR) {
                                                g_propagate_error (error, _inner_error_);
                                                return NULL;
                                          } else {
                                                g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                                                g_clear_error (&_inner_error_);
                                                return NULL;
                                          }
                                    }
                                    _tmp35_ = vala_parser_get_src (self, &begin);
                                    _tmp36_ = _tmp35_;
                                    _tmp37_ = vala_cast_expression_new_non_null (inner, _tmp36_);
                                    _tmp38_ = (ValaExpression*) _tmp37_;
                                    _vala_source_reference_unref0 (_tmp36_);
                                    result = _tmp38_;
                                    _vala_code_node_unref0 (inner);
                                    return result;
                              }
                              break;
                        }
                        default:
                        {
                              break;
                        }
                  }
                  vala_parser_rollback (self, &begin);
                  break;
            }
            case VALA_TOKEN_TYPE_STAR:
            {
                  ValaExpression* _tmp39_ = NULL;
                  ValaExpression* op;
                  ValaSourceReference* _tmp40_ = NULL;
                  ValaSourceReference* _tmp41_;
                  ValaPointerIndirection* _tmp42_ = NULL;
                  ValaExpression* _tmp43_;
                  vala_parser_next (self);
                  _tmp39_ = vala_parser_parse_unary_expression (self, &_inner_error_);
                  op = _tmp39_;
                  if (_inner_error_ != NULL) {
                        if (_inner_error_->domain == VALA_PARSE_ERROR) {
                              g_propagate_error (error, _inner_error_);
                              return NULL;
                        } else {
                              g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                              g_clear_error (&_inner_error_);
                              return NULL;
                        }
                  }
                  _tmp40_ = vala_parser_get_src (self, &begin);
                  _tmp41_ = _tmp40_;
                  _tmp42_ = vala_pointer_indirection_new (op, _tmp41_);
                  _tmp43_ = (ValaExpression*) _tmp42_;
                  _vala_source_reference_unref0 (_tmp41_);
                  result = _tmp43_;
                  _vala_code_node_unref0 (op);
                  return result;
            }
            case VALA_TOKEN_TYPE_BITWISE_AND:
            {
                  ValaExpression* _tmp44_ = NULL;
                  ValaExpression* op;
                  ValaSourceReference* _tmp45_ = NULL;
                  ValaSourceReference* _tmp46_;
                  ValaAddressofExpression* _tmp47_ = NULL;
                  ValaExpression* _tmp48_;
                  vala_parser_next (self);
                  _tmp44_ = vala_parser_parse_unary_expression (self, &_inner_error_);
                  op = _tmp44_;
                  if (_inner_error_ != NULL) {
                        if (_inner_error_->domain == VALA_PARSE_ERROR) {
                              g_propagate_error (error, _inner_error_);
                              return NULL;
                        } else {
                              g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                              g_clear_error (&_inner_error_);
                              return NULL;
                        }
                  }
                  _tmp45_ = vala_parser_get_src (self, &begin);
                  _tmp46_ = _tmp45_;
                  _tmp47_ = vala_addressof_expression_new (op, _tmp46_);
                  _tmp48_ = (ValaExpression*) _tmp47_;
                  _vala_source_reference_unref0 (_tmp46_);
                  result = _tmp48_;
                  _vala_code_node_unref0 (op);
                  return result;
            }
            default:
            {
                  break;
            }
      }
      _tmp49_ = vala_parser_parse_primary_expression (self, &_inner_error_);
      expr = _tmp49_;
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  return NULL;
            } else {
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      result = expr;
      return result;
}


static ValaBinaryOperator vala_parser_get_binary_operator (ValaParser* self, ValaTokenType token_type) {
      ValaBinaryOperator result = 0;
      g_return_val_if_fail (self != NULL, 0);
      switch (token_type) {
            case VALA_TOKEN_TYPE_STAR:
            {
                  result = VALA_BINARY_OPERATOR_MUL;
                  return result;
            }
            case VALA_TOKEN_TYPE_DIV:
            {
                  result = VALA_BINARY_OPERATOR_DIV;
                  return result;
            }
            case VALA_TOKEN_TYPE_PERCENT:
            {
                  result = VALA_BINARY_OPERATOR_MOD;
                  return result;
            }
            case VALA_TOKEN_TYPE_PLUS:
            {
                  result = VALA_BINARY_OPERATOR_PLUS;
                  return result;
            }
            case VALA_TOKEN_TYPE_MINUS:
            {
                  result = VALA_BINARY_OPERATOR_MINUS;
                  return result;
            }
            case VALA_TOKEN_TYPE_OP_LT:
            {
                  result = VALA_BINARY_OPERATOR_LESS_THAN;
                  return result;
            }
            case VALA_TOKEN_TYPE_OP_GT:
            {
                  result = VALA_BINARY_OPERATOR_GREATER_THAN;
                  return result;
            }
            case VALA_TOKEN_TYPE_OP_LE:
            {
                  result = VALA_BINARY_OPERATOR_LESS_THAN_OR_EQUAL;
                  return result;
            }
            case VALA_TOKEN_TYPE_OP_GE:
            {
                  result = VALA_BINARY_OPERATOR_GREATER_THAN_OR_EQUAL;
                  return result;
            }
            case VALA_TOKEN_TYPE_OP_EQ:
            {
                  result = VALA_BINARY_OPERATOR_EQUALITY;
                  return result;
            }
            case VALA_TOKEN_TYPE_OP_NE:
            {
                  result = VALA_BINARY_OPERATOR_INEQUALITY;
                  return result;
            }
            default:
            {
                  result = VALA_BINARY_OPERATOR_NONE;
                  return result;
            }
      }
}


static ValaExpression* vala_parser_parse_multiplicative_expression (ValaParser* self, GError** error) {
      ValaExpression* result = NULL;
      ValaSourceLocation _tmp0_ = {0};
      ValaSourceLocation _tmp1_ = {0};
      ValaSourceLocation begin;
      ValaExpression* _tmp2_ = NULL;
      ValaExpression* left;
      gboolean found;
      GError * _inner_error_ = NULL;
      g_return_val_if_fail (self != NULL, NULL);
      vala_parser_get_location (self, &_tmp0_);
      _tmp1_ = _tmp0_;
      begin = _tmp1_;
      _tmp2_ = vala_parser_parse_unary_expression (self, &_inner_error_);
      left = _tmp2_;
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  return NULL;
            } else {
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      found = TRUE;
      while (TRUE) {
            ValaTokenType _tmp3_;
            ValaBinaryOperator _tmp4_;
            ValaBinaryOperator operator;
            if (!found) {
                  break;
            }
            _tmp3_ = vala_parser_current (self);
            _tmp4_ = vala_parser_get_binary_operator (self, _tmp3_);
            operator = _tmp4_;
            switch (operator) {
                  case VALA_BINARY_OPERATOR_MUL:
                  case VALA_BINARY_OPERATOR_DIV:
                  case VALA_BINARY_OPERATOR_MOD:
                  {
                        ValaExpression* _tmp5_ = NULL;
                        ValaExpression* right;
                        ValaSourceReference* _tmp6_ = NULL;
                        ValaSourceReference* _tmp7_;
                        ValaBinaryExpression* _tmp8_ = NULL;
                        vala_parser_next (self);
                        _tmp5_ = vala_parser_parse_unary_expression (self, &_inner_error_);
                        right = _tmp5_;
                        if (_inner_error_ != NULL) {
                              if (_inner_error_->domain == VALA_PARSE_ERROR) {
                                    g_propagate_error (error, _inner_error_);
                                    _vala_code_node_unref0 (left);
                                    return NULL;
                              } else {
                                    _vala_code_node_unref0 (left);
                                    g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                                    g_clear_error (&_inner_error_);
                                    return NULL;
                              }
                        }
                        _tmp6_ = vala_parser_get_src (self, &begin);
                        _tmp7_ = _tmp6_;
                        _tmp8_ = vala_binary_expression_new (operator, left, right, _tmp7_);
                        _vala_code_node_unref0 (left);
                        left = (ValaExpression*) _tmp8_;
                        _vala_source_reference_unref0 (_tmp7_);
                        _vala_code_node_unref0 (right);
                        break;
                  }
                  default:
                  {
                        found = FALSE;
                        break;
                  }
            }
      }
      result = left;
      return result;
}


static ValaExpression* vala_parser_parse_additive_expression (ValaParser* self, GError** error) {
      ValaExpression* result = NULL;
      ValaSourceLocation _tmp0_ = {0};
      ValaSourceLocation _tmp1_ = {0};
      ValaSourceLocation begin;
      ValaExpression* _tmp2_ = NULL;
      ValaExpression* left;
      gboolean found;
      GError * _inner_error_ = NULL;
      g_return_val_if_fail (self != NULL, NULL);
      vala_parser_get_location (self, &_tmp0_);
      _tmp1_ = _tmp0_;
      begin = _tmp1_;
      _tmp2_ = vala_parser_parse_multiplicative_expression (self, &_inner_error_);
      left = _tmp2_;
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  return NULL;
            } else {
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      found = TRUE;
      while (TRUE) {
            ValaTokenType _tmp3_;
            ValaBinaryOperator _tmp4_;
            ValaBinaryOperator operator;
            if (!found) {
                  break;
            }
            _tmp3_ = vala_parser_current (self);
            _tmp4_ = vala_parser_get_binary_operator (self, _tmp3_);
            operator = _tmp4_;
            switch (operator) {
                  case VALA_BINARY_OPERATOR_PLUS:
                  case VALA_BINARY_OPERATOR_MINUS:
                  {
                        ValaExpression* _tmp5_ = NULL;
                        ValaExpression* right;
                        ValaSourceReference* _tmp6_ = NULL;
                        ValaSourceReference* _tmp7_;
                        ValaBinaryExpression* _tmp8_ = NULL;
                        vala_parser_next (self);
                        _tmp5_ = vala_parser_parse_multiplicative_expression (self, &_inner_error_);
                        right = _tmp5_;
                        if (_inner_error_ != NULL) {
                              if (_inner_error_->domain == VALA_PARSE_ERROR) {
                                    g_propagate_error (error, _inner_error_);
                                    _vala_code_node_unref0 (left);
                                    return NULL;
                              } else {
                                    _vala_code_node_unref0 (left);
                                    g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                                    g_clear_error (&_inner_error_);
                                    return NULL;
                              }
                        }
                        _tmp6_ = vala_parser_get_src (self, &begin);
                        _tmp7_ = _tmp6_;
                        _tmp8_ = vala_binary_expression_new (operator, left, right, _tmp7_);
                        _vala_code_node_unref0 (left);
                        left = (ValaExpression*) _tmp8_;
                        _vala_source_reference_unref0 (_tmp7_);
                        _vala_code_node_unref0 (right);
                        break;
                  }
                  default:
                  {
                        found = FALSE;
                        break;
                  }
            }
      }
      result = left;
      return result;
}


static ValaExpression* vala_parser_parse_shift_expression (ValaParser* self, GError** error) {
      ValaExpression* result = NULL;
      ValaSourceLocation _tmp0_ = {0};
      ValaSourceLocation _tmp1_ = {0};
      ValaSourceLocation begin;
      ValaExpression* _tmp2_ = NULL;
      ValaExpression* left;
      gboolean found;
      GError * _inner_error_ = NULL;
      g_return_val_if_fail (self != NULL, NULL);
      vala_parser_get_location (self, &_tmp0_);
      _tmp1_ = _tmp0_;
      begin = _tmp1_;
      _tmp2_ = vala_parser_parse_additive_expression (self, &_inner_error_);
      left = _tmp2_;
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  return NULL;
            } else {
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      found = TRUE;
      while (TRUE) {
            ValaTokenType _tmp3_;
            if (!found) {
                  break;
            }
            _tmp3_ = vala_parser_current (self);
            switch (_tmp3_) {
                  case VALA_TOKEN_TYPE_OP_SHIFT_LEFT:
                  {
                        ValaExpression* _tmp4_ = NULL;
                        ValaExpression* right;
                        ValaSourceReference* _tmp5_ = NULL;
                        ValaSourceReference* _tmp6_;
                        ValaBinaryExpression* _tmp7_ = NULL;
                        vala_parser_next (self);
                        _tmp4_ = vala_parser_parse_additive_expression (self, &_inner_error_);
                        right = _tmp4_;
                        if (_inner_error_ != NULL) {
                              if (_inner_error_->domain == VALA_PARSE_ERROR) {
                                    g_propagate_error (error, _inner_error_);
                                    _vala_code_node_unref0 (left);
                                    return NULL;
                              } else {
                                    _vala_code_node_unref0 (left);
                                    g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                                    g_clear_error (&_inner_error_);
                                    return NULL;
                              }
                        }
                        _tmp5_ = vala_parser_get_src (self, &begin);
                        _tmp6_ = _tmp5_;
                        _tmp7_ = vala_binary_expression_new (VALA_BINARY_OPERATOR_SHIFT_LEFT, left, right, _tmp6_);
                        _vala_code_node_unref0 (left);
                        left = (ValaExpression*) _tmp7_;
                        _vala_source_reference_unref0 (_tmp6_);
                        _vala_code_node_unref0 (right);
                        break;
                  }
                  case VALA_TOKEN_TYPE_OP_GT:
                  {
                        gchar* first_gt_pos;
                        gboolean _tmp8_ = FALSE;
                        ValaTokenType _tmp9_;
                        first_gt_pos = self->priv->tokens[self->priv->index].begin.pos;
                        vala_parser_next (self);
                        _tmp9_ = vala_parser_current (self);
                        if (_tmp9_ == VALA_TOKEN_TYPE_OP_GT) {
                              _tmp8_ = self->priv->tokens[self->priv->index].begin.pos == (first_gt_pos + 1);
                        } else {
                              _tmp8_ = FALSE;
                        }
                        if (_tmp8_) {
                              ValaExpression* _tmp10_ = NULL;
                              ValaExpression* right;
                              ValaSourceReference* _tmp11_ = NULL;
                              ValaSourceReference* _tmp12_;
                              ValaBinaryExpression* _tmp13_ = NULL;
                              vala_parser_next (self);
                              _tmp10_ = vala_parser_parse_additive_expression (self, &_inner_error_);
                              right = _tmp10_;
                              if (_inner_error_ != NULL) {
                                    if (_inner_error_->domain == VALA_PARSE_ERROR) {
                                          g_propagate_error (error, _inner_error_);
                                          _vala_code_node_unref0 (left);
                                          return NULL;
                                    } else {
                                          _vala_code_node_unref0 (left);
                                          g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                                          g_clear_error (&_inner_error_);
                                          return NULL;
                                    }
                              }
                              _tmp11_ = vala_parser_get_src (self, &begin);
                              _tmp12_ = _tmp11_;
                              _tmp13_ = vala_binary_expression_new (VALA_BINARY_OPERATOR_SHIFT_RIGHT, left, right, _tmp12_);
                              _vala_code_node_unref0 (left);
                              left = (ValaExpression*) _tmp13_;
                              _vala_source_reference_unref0 (_tmp12_);
                              _vala_code_node_unref0 (right);
                        } else {
                              vala_parser_prev (self);
                              found = FALSE;
                        }
                        break;
                  }
                  default:
                  {
                        found = FALSE;
                        break;
                  }
            }
      }
      result = left;
      return result;
}


static ValaExpression* vala_parser_parse_relational_expression (ValaParser* self, GError** error) {
      ValaExpression* result = NULL;
      ValaSourceLocation _tmp0_ = {0};
      ValaSourceLocation _tmp1_ = {0};
      ValaSourceLocation begin;
      ValaExpression* _tmp2_ = NULL;
      ValaExpression* left;
      gboolean first;
      gboolean found;
      GError * _inner_error_ = NULL;
      g_return_val_if_fail (self != NULL, NULL);
      vala_parser_get_location (self, &_tmp0_);
      _tmp1_ = _tmp0_;
      begin = _tmp1_;
      _tmp2_ = vala_parser_parse_shift_expression (self, &_inner_error_);
      left = _tmp2_;
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  return NULL;
            } else {
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      first = TRUE;
      found = TRUE;
      while (TRUE) {
            ValaTokenType _tmp3_;
            ValaBinaryOperator _tmp4_;
            ValaBinaryOperator operator;
            if (!found) {
                  break;
            }
            _tmp3_ = vala_parser_current (self);
            _tmp4_ = vala_parser_get_binary_operator (self, _tmp3_);
            operator = _tmp4_;
            switch (operator) {
                  case VALA_BINARY_OPERATOR_LESS_THAN:
                  case VALA_BINARY_OPERATOR_LESS_THAN_OR_EQUAL:
                  case VALA_BINARY_OPERATOR_GREATER_THAN_OR_EQUAL:
                  {
                        ValaExpression* _tmp5_ = NULL;
                        ValaExpression* right;
                        ValaSourceReference* _tmp6_ = NULL;
                        ValaSourceReference* _tmp7_;
                        ValaBinaryExpression* _tmp8_ = NULL;
                        vala_parser_next (self);
                        _tmp5_ = vala_parser_parse_shift_expression (self, &_inner_error_);
                        right = _tmp5_;
                        if (_inner_error_ != NULL) {
                              if (_inner_error_->domain == VALA_PARSE_ERROR) {
                                    g_propagate_error (error, _inner_error_);
                                    _vala_code_node_unref0 (left);
                                    return NULL;
                              } else {
                                    _vala_code_node_unref0 (left);
                                    g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                                    g_clear_error (&_inner_error_);
                                    return NULL;
                              }
                        }
                        _tmp6_ = vala_parser_get_src (self, &begin);
                        _tmp7_ = _tmp6_;
                        _tmp8_ = vala_binary_expression_new (operator, left, right, _tmp7_);
                        _vala_code_node_unref0 (left);
                        left = (ValaExpression*) _tmp8_;
                        _vala_source_reference_unref0 (_tmp7_);
                        if (!first) {
                              ValaBinaryExpression* _tmp9_;
                              ValaBinaryExpression* be;
                              gboolean _tmp10_;
                              _tmp9_ = _vala_code_node_ref0 (VALA_BINARY_EXPRESSION (left));
                              be = _tmp9_;
                              be->chained = TRUE;
                              _tmp10_ = vala_code_context_get_experimental (self->priv->context);
                              if (!_tmp10_) {
                                    ValaSourceReference* _tmp11_ = NULL;
                                    _tmp11_ = vala_code_node_get_source_reference ((ValaCodeNode*) left);
                                    vala_report_warning (_tmp11_, "chained relational expressions are experimental");
                              }
                              _vala_code_node_unref0 (be);
                        }
                        first = FALSE;
                        _vala_code_node_unref0 (right);
                        break;
                  }
                  case VALA_BINARY_OPERATOR_GREATER_THAN:
                  {
                        gboolean _tmp12_ = FALSE;
                        ValaTokenType _tmp13_;
                        vala_parser_next (self);
                        _tmp13_ = vala_parser_current (self);
                        if (_tmp13_ != VALA_TOKEN_TYPE_OP_GT) {
                              ValaTokenType _tmp14_;
                              _tmp14_ = vala_parser_current (self);
                              _tmp12_ = _tmp14_ != VALA_TOKEN_TYPE_OP_GE;
                        } else {
                              _tmp12_ = FALSE;
                        }
                        if (_tmp12_) {
                              ValaExpression* _tmp15_ = NULL;
                              ValaExpression* right;
                              ValaSourceReference* _tmp16_ = NULL;
                              ValaSourceReference* _tmp17_;
                              ValaBinaryExpression* _tmp18_ = NULL;
                              _tmp15_ = vala_parser_parse_shift_expression (self, &_inner_error_);
                              right = _tmp15_;
                              if (_inner_error_ != NULL) {
                                    if (_inner_error_->domain == VALA_PARSE_ERROR) {
                                          g_propagate_error (error, _inner_error_);
                                          _vala_code_node_unref0 (left);
                                          return NULL;
                                    } else {
                                          _vala_code_node_unref0 (left);
                                          g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                                          g_clear_error (&_inner_error_);
                                          return NULL;
                                    }
                              }
                              _tmp16_ = vala_parser_get_src (self, &begin);
                              _tmp17_ = _tmp16_;
                              _tmp18_ = vala_binary_expression_new (operator, left, right, _tmp17_);
                              _vala_code_node_unref0 (left);
                              left = (ValaExpression*) _tmp18_;
                              _vala_source_reference_unref0 (_tmp17_);
                              if (!first) {
                                    ValaBinaryExpression* _tmp19_;
                                    ValaBinaryExpression* be;
                                    gboolean _tmp20_;
                                    _tmp19_ = _vala_code_node_ref0 (VALA_BINARY_EXPRESSION (left));
                                    be = _tmp19_;
                                    be->chained = TRUE;
                                    _tmp20_ = vala_code_context_get_experimental (self->priv->context);
                                    if (!_tmp20_) {
                                          ValaSourceReference* _tmp21_ = NULL;
                                          _tmp21_ = vala_code_node_get_source_reference ((ValaCodeNode*) left);
                                          vala_report_warning (_tmp21_, "chained relational expressions are experimental");
                                    }
                                    _vala_code_node_unref0 (be);
                              }
                              first = FALSE;
                              _vala_code_node_unref0 (right);
                        } else {
                              vala_parser_prev (self);
                              found = FALSE;
                        }
                        break;
                  }
                  default:
                  {
                        ValaTokenType _tmp22_;
                        _tmp22_ = vala_parser_current (self);
                        switch (_tmp22_) {
                              case VALA_TOKEN_TYPE_IS:
                              {
                                    ValaDataType* _tmp23_ = NULL;
                                    ValaDataType* type;
                                    ValaSourceReference* _tmp24_ = NULL;
                                    ValaSourceReference* _tmp25_;
                                    ValaTypeCheck* _tmp26_ = NULL;
                                    vala_parser_next (self);
                                    _tmp23_ = vala_parser_parse_type (self, TRUE, FALSE, &_inner_error_);
                                    type = _tmp23_;
                                    if (_inner_error_ != NULL) {
                                          if (_inner_error_->domain == VALA_PARSE_ERROR) {
                                                g_propagate_error (error, _inner_error_);
                                                _vala_code_node_unref0 (left);
                                                return NULL;
                                          } else {
                                                _vala_code_node_unref0 (left);
                                                g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                                                g_clear_error (&_inner_error_);
                                                return NULL;
                                          }
                                    }
                                    _tmp24_ = vala_parser_get_src (self, &begin);
                                    _tmp25_ = _tmp24_;
                                    _tmp26_ = vala_typecheck_new (left, type, _tmp25_);
                                    _vala_code_node_unref0 (left);
                                    left = (ValaExpression*) _tmp26_;
                                    _vala_source_reference_unref0 (_tmp25_);
                                    _vala_code_node_unref0 (type);
                                    break;
                              }
                              case VALA_TOKEN_TYPE_AS:
                              {
                                    ValaDataType* _tmp27_ = NULL;
                                    ValaDataType* type;
                                    ValaSourceReference* _tmp28_ = NULL;
                                    ValaSourceReference* _tmp29_;
                                    ValaCastExpression* _tmp30_ = NULL;
                                    vala_parser_next (self);
                                    _tmp27_ = vala_parser_parse_type (self, TRUE, FALSE, &_inner_error_);
                                    type = _tmp27_;
                                    if (_inner_error_ != NULL) {
                                          if (_inner_error_->domain == VALA_PARSE_ERROR) {
                                                g_propagate_error (error, _inner_error_);
                                                _vala_code_node_unref0 (left);
                                                return NULL;
                                          } else {
                                                _vala_code_node_unref0 (left);
                                                g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                                                g_clear_error (&_inner_error_);
                                                return NULL;
                                          }
                                    }
                                    _tmp28_ = vala_parser_get_src (self, &begin);
                                    _tmp29_ = _tmp28_;
                                    _tmp30_ = vala_cast_expression_new (left, type, _tmp29_, TRUE);
                                    _vala_code_node_unref0 (left);
                                    left = (ValaExpression*) _tmp30_;
                                    _vala_source_reference_unref0 (_tmp29_);
                                    _vala_code_node_unref0 (type);
                                    break;
                              }
                              default:
                              {
                                    found = FALSE;
                                    break;
                              }
                        }
                        break;
                  }
            }
      }
      result = left;
      return result;
}


static ValaExpression* vala_parser_parse_equality_expression (ValaParser* self, GError** error) {
      ValaExpression* result = NULL;
      ValaSourceLocation _tmp0_ = {0};
      ValaSourceLocation _tmp1_ = {0};
      ValaSourceLocation begin;
      ValaExpression* _tmp2_ = NULL;
      ValaExpression* left;
      gboolean found;
      GError * _inner_error_ = NULL;
      g_return_val_if_fail (self != NULL, NULL);
      vala_parser_get_location (self, &_tmp0_);
      _tmp1_ = _tmp0_;
      begin = _tmp1_;
      _tmp2_ = vala_parser_parse_relational_expression (self, &_inner_error_);
      left = _tmp2_;
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  return NULL;
            } else {
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      found = TRUE;
      while (TRUE) {
            ValaTokenType _tmp3_;
            ValaBinaryOperator _tmp4_;
            ValaBinaryOperator operator;
            if (!found) {
                  break;
            }
            _tmp3_ = vala_parser_current (self);
            _tmp4_ = vala_parser_get_binary_operator (self, _tmp3_);
            operator = _tmp4_;
            switch (operator) {
                  case VALA_BINARY_OPERATOR_EQUALITY:
                  case VALA_BINARY_OPERATOR_INEQUALITY:
                  {
                        ValaExpression* _tmp5_ = NULL;
                        ValaExpression* right;
                        ValaSourceReference* _tmp6_ = NULL;
                        ValaSourceReference* _tmp7_;
                        ValaBinaryExpression* _tmp8_ = NULL;
                        vala_parser_next (self);
                        _tmp5_ = vala_parser_parse_relational_expression (self, &_inner_error_);
                        right = _tmp5_;
                        if (_inner_error_ != NULL) {
                              if (_inner_error_->domain == VALA_PARSE_ERROR) {
                                    g_propagate_error (error, _inner_error_);
                                    _vala_code_node_unref0 (left);
                                    return NULL;
                              } else {
                                    _vala_code_node_unref0 (left);
                                    g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                                    g_clear_error (&_inner_error_);
                                    return NULL;
                              }
                        }
                        _tmp6_ = vala_parser_get_src (self, &begin);
                        _tmp7_ = _tmp6_;
                        _tmp8_ = vala_binary_expression_new (operator, left, right, _tmp7_);
                        _vala_code_node_unref0 (left);
                        left = (ValaExpression*) _tmp8_;
                        _vala_source_reference_unref0 (_tmp7_);
                        _vala_code_node_unref0 (right);
                        break;
                  }
                  default:
                  {
                        found = FALSE;
                        break;
                  }
            }
      }
      result = left;
      return result;
}


static ValaExpression* vala_parser_parse_and_expression (ValaParser* self, GError** error) {
      ValaExpression* result = NULL;
      ValaSourceLocation _tmp0_ = {0};
      ValaSourceLocation _tmp1_ = {0};
      ValaSourceLocation begin;
      ValaExpression* _tmp2_ = NULL;
      ValaExpression* left;
      GError * _inner_error_ = NULL;
      g_return_val_if_fail (self != NULL, NULL);
      vala_parser_get_location (self, &_tmp0_);
      _tmp1_ = _tmp0_;
      begin = _tmp1_;
      _tmp2_ = vala_parser_parse_equality_expression (self, &_inner_error_);
      left = _tmp2_;
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  return NULL;
            } else {
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      while (TRUE) {
            gboolean _tmp3_;
            ValaExpression* _tmp4_ = NULL;
            ValaExpression* right;
            ValaSourceReference* _tmp5_ = NULL;
            ValaSourceReference* _tmp6_;
            ValaBinaryExpression* _tmp7_ = NULL;
            _tmp3_ = vala_parser_accept (self, VALA_TOKEN_TYPE_BITWISE_AND);
            if (!_tmp3_) {
                  break;
            }
            _tmp4_ = vala_parser_parse_equality_expression (self, &_inner_error_);
            right = _tmp4_;
            if (_inner_error_ != NULL) {
                  if (_inner_error_->domain == VALA_PARSE_ERROR) {
                        g_propagate_error (error, _inner_error_);
                        _vala_code_node_unref0 (left);
                        return NULL;
                  } else {
                        _vala_code_node_unref0 (left);
                        g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                        g_clear_error (&_inner_error_);
                        return NULL;
                  }
            }
            _tmp5_ = vala_parser_get_src (self, &begin);
            _tmp6_ = _tmp5_;
            _tmp7_ = vala_binary_expression_new (VALA_BINARY_OPERATOR_BITWISE_AND, left, right, _tmp6_);
            _vala_code_node_unref0 (left);
            left = (ValaExpression*) _tmp7_;
            _vala_source_reference_unref0 (_tmp6_);
            _vala_code_node_unref0 (right);
      }
      result = left;
      return result;
}


static ValaExpression* vala_parser_parse_exclusive_or_expression (ValaParser* self, GError** error) {
      ValaExpression* result = NULL;
      ValaSourceLocation _tmp0_ = {0};
      ValaSourceLocation _tmp1_ = {0};
      ValaSourceLocation begin;
      ValaExpression* _tmp2_ = NULL;
      ValaExpression* left;
      GError * _inner_error_ = NULL;
      g_return_val_if_fail (self != NULL, NULL);
      vala_parser_get_location (self, &_tmp0_);
      _tmp1_ = _tmp0_;
      begin = _tmp1_;
      _tmp2_ = vala_parser_parse_and_expression (self, &_inner_error_);
      left = _tmp2_;
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  return NULL;
            } else {
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      while (TRUE) {
            gboolean _tmp3_;
            ValaExpression* _tmp4_ = NULL;
            ValaExpression* right;
            ValaSourceReference* _tmp5_ = NULL;
            ValaSourceReference* _tmp6_;
            ValaBinaryExpression* _tmp7_ = NULL;
            _tmp3_ = vala_parser_accept (self, VALA_TOKEN_TYPE_CARRET);
            if (!_tmp3_) {
                  break;
            }
            _tmp4_ = vala_parser_parse_and_expression (self, &_inner_error_);
            right = _tmp4_;
            if (_inner_error_ != NULL) {
                  if (_inner_error_->domain == VALA_PARSE_ERROR) {
                        g_propagate_error (error, _inner_error_);
                        _vala_code_node_unref0 (left);
                        return NULL;
                  } else {
                        _vala_code_node_unref0 (left);
                        g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                        g_clear_error (&_inner_error_);
                        return NULL;
                  }
            }
            _tmp5_ = vala_parser_get_src (self, &begin);
            _tmp6_ = _tmp5_;
            _tmp7_ = vala_binary_expression_new (VALA_BINARY_OPERATOR_BITWISE_XOR, left, right, _tmp6_);
            _vala_code_node_unref0 (left);
            left = (ValaExpression*) _tmp7_;
            _vala_source_reference_unref0 (_tmp6_);
            _vala_code_node_unref0 (right);
      }
      result = left;
      return result;
}


static ValaExpression* vala_parser_parse_inclusive_or_expression (ValaParser* self, GError** error) {
      ValaExpression* result = NULL;
      ValaSourceLocation _tmp0_ = {0};
      ValaSourceLocation _tmp1_ = {0};
      ValaSourceLocation begin;
      ValaExpression* _tmp2_ = NULL;
      ValaExpression* left;
      GError * _inner_error_ = NULL;
      g_return_val_if_fail (self != NULL, NULL);
      vala_parser_get_location (self, &_tmp0_);
      _tmp1_ = _tmp0_;
      begin = _tmp1_;
      _tmp2_ = vala_parser_parse_exclusive_or_expression (self, &_inner_error_);
      left = _tmp2_;
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  return NULL;
            } else {
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      while (TRUE) {
            gboolean _tmp3_;
            ValaExpression* _tmp4_ = NULL;
            ValaExpression* right;
            ValaSourceReference* _tmp5_ = NULL;
            ValaSourceReference* _tmp6_;
            ValaBinaryExpression* _tmp7_ = NULL;
            _tmp3_ = vala_parser_accept (self, VALA_TOKEN_TYPE_BITWISE_OR);
            if (!_tmp3_) {
                  break;
            }
            _tmp4_ = vala_parser_parse_exclusive_or_expression (self, &_inner_error_);
            right = _tmp4_;
            if (_inner_error_ != NULL) {
                  if (_inner_error_->domain == VALA_PARSE_ERROR) {
                        g_propagate_error (error, _inner_error_);
                        _vala_code_node_unref0 (left);
                        return NULL;
                  } else {
                        _vala_code_node_unref0 (left);
                        g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                        g_clear_error (&_inner_error_);
                        return NULL;
                  }
            }
            _tmp5_ = vala_parser_get_src (self, &begin);
            _tmp6_ = _tmp5_;
            _tmp7_ = vala_binary_expression_new (VALA_BINARY_OPERATOR_BITWISE_OR, left, right, _tmp6_);
            _vala_code_node_unref0 (left);
            left = (ValaExpression*) _tmp7_;
            _vala_source_reference_unref0 (_tmp6_);
            _vala_code_node_unref0 (right);
      }
      result = left;
      return result;
}


static ValaExpression* vala_parser_parse_in_expression (ValaParser* self, GError** error) {
      ValaExpression* result = NULL;
      ValaSourceLocation _tmp0_ = {0};
      ValaSourceLocation _tmp1_ = {0};
      ValaSourceLocation begin;
      ValaExpression* _tmp2_ = NULL;
      ValaExpression* left;
      GError * _inner_error_ = NULL;
      g_return_val_if_fail (self != NULL, NULL);
      vala_parser_get_location (self, &_tmp0_);
      _tmp1_ = _tmp0_;
      begin = _tmp1_;
      _tmp2_ = vala_parser_parse_inclusive_or_expression (self, &_inner_error_);
      left = _tmp2_;
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  return NULL;
            } else {
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      while (TRUE) {
            gboolean _tmp3_;
            ValaExpression* _tmp4_ = NULL;
            ValaExpression* right;
            ValaSourceReference* _tmp5_ = NULL;
            ValaSourceReference* _tmp6_;
            ValaBinaryExpression* _tmp7_ = NULL;
            _tmp3_ = vala_parser_accept (self, VALA_TOKEN_TYPE_IN);
            if (!_tmp3_) {
                  break;
            }
            _tmp4_ = vala_parser_parse_inclusive_or_expression (self, &_inner_error_);
            right = _tmp4_;
            if (_inner_error_ != NULL) {
                  if (_inner_error_->domain == VALA_PARSE_ERROR) {
                        g_propagate_error (error, _inner_error_);
                        _vala_code_node_unref0 (left);
                        return NULL;
                  } else {
                        _vala_code_node_unref0 (left);
                        g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                        g_clear_error (&_inner_error_);
                        return NULL;
                  }
            }
            _tmp5_ = vala_parser_get_src (self, &begin);
            _tmp6_ = _tmp5_;
            _tmp7_ = vala_binary_expression_new (VALA_BINARY_OPERATOR_IN, left, right, _tmp6_);
            _vala_code_node_unref0 (left);
            left = (ValaExpression*) _tmp7_;
            _vala_source_reference_unref0 (_tmp6_);
            _vala_code_node_unref0 (right);
      }
      result = left;
      return result;
}


static ValaExpression* vala_parser_parse_conditional_and_expression (ValaParser* self, GError** error) {
      ValaExpression* result = NULL;
      ValaSourceLocation _tmp0_ = {0};
      ValaSourceLocation _tmp1_ = {0};
      ValaSourceLocation begin;
      ValaExpression* _tmp2_ = NULL;
      ValaExpression* left;
      GError * _inner_error_ = NULL;
      g_return_val_if_fail (self != NULL, NULL);
      vala_parser_get_location (self, &_tmp0_);
      _tmp1_ = _tmp0_;
      begin = _tmp1_;
      _tmp2_ = vala_parser_parse_in_expression (self, &_inner_error_);
      left = _tmp2_;
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  return NULL;
            } else {
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      while (TRUE) {
            gboolean _tmp3_;
            ValaExpression* _tmp4_ = NULL;
            ValaExpression* right;
            ValaSourceReference* _tmp5_ = NULL;
            ValaSourceReference* _tmp6_;
            ValaBinaryExpression* _tmp7_ = NULL;
            _tmp3_ = vala_parser_accept (self, VALA_TOKEN_TYPE_OP_AND);
            if (!_tmp3_) {
                  break;
            }
            _tmp4_ = vala_parser_parse_in_expression (self, &_inner_error_);
            right = _tmp4_;
            if (_inner_error_ != NULL) {
                  if (_inner_error_->domain == VALA_PARSE_ERROR) {
                        g_propagate_error (error, _inner_error_);
                        _vala_code_node_unref0 (left);
                        return NULL;
                  } else {
                        _vala_code_node_unref0 (left);
                        g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                        g_clear_error (&_inner_error_);
                        return NULL;
                  }
            }
            _tmp5_ = vala_parser_get_src (self, &begin);
            _tmp6_ = _tmp5_;
            _tmp7_ = vala_binary_expression_new (VALA_BINARY_OPERATOR_AND, left, right, _tmp6_);
            _vala_code_node_unref0 (left);
            left = (ValaExpression*) _tmp7_;
            _vala_source_reference_unref0 (_tmp6_);
            _vala_code_node_unref0 (right);
      }
      result = left;
      return result;
}


static ValaExpression* vala_parser_parse_conditional_or_expression (ValaParser* self, GError** error) {
      ValaExpression* result = NULL;
      ValaSourceLocation _tmp0_ = {0};
      ValaSourceLocation _tmp1_ = {0};
      ValaSourceLocation begin;
      ValaExpression* _tmp2_ = NULL;
      ValaExpression* left;
      GError * _inner_error_ = NULL;
      g_return_val_if_fail (self != NULL, NULL);
      vala_parser_get_location (self, &_tmp0_);
      _tmp1_ = _tmp0_;
      begin = _tmp1_;
      _tmp2_ = vala_parser_parse_conditional_and_expression (self, &_inner_error_);
      left = _tmp2_;
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  return NULL;
            } else {
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      while (TRUE) {
            gboolean _tmp3_;
            ValaExpression* _tmp4_ = NULL;
            ValaExpression* right;
            ValaSourceReference* _tmp5_ = NULL;
            ValaSourceReference* _tmp6_;
            ValaBinaryExpression* _tmp7_ = NULL;
            _tmp3_ = vala_parser_accept (self, VALA_TOKEN_TYPE_OP_OR);
            if (!_tmp3_) {
                  break;
            }
            _tmp4_ = vala_parser_parse_conditional_and_expression (self, &_inner_error_);
            right = _tmp4_;
            if (_inner_error_ != NULL) {
                  if (_inner_error_->domain == VALA_PARSE_ERROR) {
                        g_propagate_error (error, _inner_error_);
                        _vala_code_node_unref0 (left);
                        return NULL;
                  } else {
                        _vala_code_node_unref0 (left);
                        g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                        g_clear_error (&_inner_error_);
                        return NULL;
                  }
            }
            _tmp5_ = vala_parser_get_src (self, &begin);
            _tmp6_ = _tmp5_;
            _tmp7_ = vala_binary_expression_new (VALA_BINARY_OPERATOR_OR, left, right, _tmp6_);
            _vala_code_node_unref0 (left);
            left = (ValaExpression*) _tmp7_;
            _vala_source_reference_unref0 (_tmp6_);
            _vala_code_node_unref0 (right);
      }
      result = left;
      return result;
}


static ValaExpression* vala_parser_parse_coalescing_expression (ValaParser* self, GError** error) {
      ValaExpression* result = NULL;
      ValaSourceLocation _tmp0_ = {0};
      ValaSourceLocation _tmp1_ = {0};
      ValaSourceLocation begin;
      ValaExpression* _tmp2_ = NULL;
      ValaExpression* left;
      gboolean _tmp3_;
      GError * _inner_error_ = NULL;
      g_return_val_if_fail (self != NULL, NULL);
      vala_parser_get_location (self, &_tmp0_);
      _tmp1_ = _tmp0_;
      begin = _tmp1_;
      _tmp2_ = vala_parser_parse_conditional_or_expression (self, &_inner_error_);
      left = _tmp2_;
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  return NULL;
            } else {
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      _tmp3_ = vala_parser_accept (self, VALA_TOKEN_TYPE_OP_COALESCING);
      if (_tmp3_) {
            ValaExpression* _tmp4_ = NULL;
            ValaExpression* right;
            ValaSourceReference* _tmp5_ = NULL;
            ValaSourceReference* _tmp6_;
            ValaBinaryExpression* _tmp7_ = NULL;
            ValaExpression* _tmp8_;
            _tmp4_ = vala_parser_parse_coalescing_expression (self, &_inner_error_);
            right = _tmp4_;
            if (_inner_error_ != NULL) {
                  if (_inner_error_->domain == VALA_PARSE_ERROR) {
                        g_propagate_error (error, _inner_error_);
                        _vala_code_node_unref0 (left);
                        return NULL;
                  } else {
                        _vala_code_node_unref0 (left);
                        g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                        g_clear_error (&_inner_error_);
                        return NULL;
                  }
            }
            _tmp5_ = vala_parser_get_src (self, &begin);
            _tmp6_ = _tmp5_;
            _tmp7_ = vala_binary_expression_new (VALA_BINARY_OPERATOR_COALESCE, left, right, _tmp6_);
            _tmp8_ = (ValaExpression*) _tmp7_;
            _vala_source_reference_unref0 (_tmp6_);
            result = _tmp8_;
            _vala_code_node_unref0 (right);
            _vala_code_node_unref0 (left);
            return result;
      } else {
            result = left;
            return result;
      }
      _vala_code_node_unref0 (left);
}


static ValaExpression* vala_parser_parse_conditional_expression (ValaParser* self, GError** error) {
      ValaExpression* result = NULL;
      ValaSourceLocation _tmp0_ = {0};
      ValaSourceLocation _tmp1_ = {0};
      ValaSourceLocation begin;
      ValaExpression* _tmp2_ = NULL;
      ValaExpression* condition;
      gboolean _tmp3_;
      GError * _inner_error_ = NULL;
      g_return_val_if_fail (self != NULL, NULL);
      vala_parser_get_location (self, &_tmp0_);
      _tmp1_ = _tmp0_;
      begin = _tmp1_;
      _tmp2_ = vala_parser_parse_coalescing_expression (self, &_inner_error_);
      condition = _tmp2_;
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  return NULL;
            } else {
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      _tmp3_ = vala_parser_accept (self, VALA_TOKEN_TYPE_INTERR);
      if (_tmp3_) {
            ValaExpression* _tmp4_ = NULL;
            ValaExpression* true_expr;
            ValaExpression* _tmp5_ = NULL;
            ValaExpression* false_expr;
            ValaSourceReference* _tmp6_ = NULL;
            ValaSourceReference* _tmp7_;
            ValaConditionalExpression* _tmp8_ = NULL;
            ValaExpression* _tmp9_;
            _tmp4_ = vala_parser_parse_expression (self, &_inner_error_);
            true_expr = _tmp4_;
            if (_inner_error_ != NULL) {
                  if (_inner_error_->domain == VALA_PARSE_ERROR) {
                        g_propagate_error (error, _inner_error_);
                        _vala_code_node_unref0 (condition);
                        return NULL;
                  } else {
                        _vala_code_node_unref0 (condition);
                        g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                        g_clear_error (&_inner_error_);
                        return NULL;
                  }
            }
            vala_parser_expect (self, VALA_TOKEN_TYPE_COLON, &_inner_error_);
            if (_inner_error_ != NULL) {
                  if (_inner_error_->domain == VALA_PARSE_ERROR) {
                        g_propagate_error (error, _inner_error_);
                        _vala_code_node_unref0 (true_expr);
                        _vala_code_node_unref0 (condition);
                        return NULL;
                  } else {
                        _vala_code_node_unref0 (true_expr);
                        _vala_code_node_unref0 (condition);
                        g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                        g_clear_error (&_inner_error_);
                        return NULL;
                  }
            }
            _tmp5_ = vala_parser_parse_expression (self, &_inner_error_);
            false_expr = _tmp5_;
            if (_inner_error_ != NULL) {
                  if (_inner_error_->domain == VALA_PARSE_ERROR) {
                        g_propagate_error (error, _inner_error_);
                        _vala_code_node_unref0 (true_expr);
                        _vala_code_node_unref0 (condition);
                        return NULL;
                  } else {
                        _vala_code_node_unref0 (true_expr);
                        _vala_code_node_unref0 (condition);
                        g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                        g_clear_error (&_inner_error_);
                        return NULL;
                  }
            }
            _tmp6_ = vala_parser_get_src (self, &begin);
            _tmp7_ = _tmp6_;
            _tmp8_ = vala_conditional_expression_new (condition, true_expr, false_expr, _tmp7_);
            _tmp9_ = (ValaExpression*) _tmp8_;
            _vala_source_reference_unref0 (_tmp7_);
            result = _tmp9_;
            _vala_code_node_unref0 (false_expr);
            _vala_code_node_unref0 (true_expr);
            _vala_code_node_unref0 (condition);
            return result;
      } else {
            result = condition;
            return result;
      }
      _vala_code_node_unref0 (condition);
}


static ValaParameter* vala_parser_parse_lambda_parameter (ValaParser* self, GError** error) {
      ValaParameter* result = NULL;
      ValaSourceLocation _tmp0_ = {0};
      ValaSourceLocation _tmp1_ = {0};
      ValaSourceLocation begin;
      ValaParameterDirection direction;
      gboolean _tmp2_;
      gchar* _tmp4_ = NULL;
      gchar* id;
      ValaSourceReference* _tmp5_ = NULL;
      ValaSourceReference* _tmp6_;
      ValaParameter* _tmp7_ = NULL;
      ValaParameter* _tmp8_;
      ValaParameter* param;
      GError * _inner_error_ = NULL;
      g_return_val_if_fail (self != NULL, NULL);
      vala_parser_get_location (self, &_tmp0_);
      _tmp1_ = _tmp0_;
      begin = _tmp1_;
      direction = VALA_PARAMETER_DIRECTION_IN;
      _tmp2_ = vala_parser_accept (self, VALA_TOKEN_TYPE_OUT);
      if (_tmp2_) {
            direction = VALA_PARAMETER_DIRECTION_OUT;
      } else {
            gboolean _tmp3_;
            _tmp3_ = vala_parser_accept (self, VALA_TOKEN_TYPE_REF);
            if (_tmp3_) {
                  direction = VALA_PARAMETER_DIRECTION_REF;
            }
      }
      _tmp4_ = vala_parser_parse_identifier (self, &_inner_error_);
      id = _tmp4_;
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  return NULL;
            } else {
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      _tmp5_ = vala_parser_get_src (self, &begin);
      _tmp6_ = _tmp5_;
      _tmp7_ = vala_parameter_new (id, NULL, _tmp6_);
      _tmp8_ = _tmp7_;
      _vala_source_reference_unref0 (_tmp6_);
      param = _tmp8_;
      vala_parameter_set_direction (param, direction);
      result = param;
      _g_free0 (id);
      return result;
}


static ValaExpression* vala_parser_parse_lambda_expression (ValaParser* self, GError** error) {
      ValaExpression* result = NULL;
      ValaSourceLocation _tmp0_ = {0};
      ValaSourceLocation _tmp1_ = {0};
      ValaSourceLocation begin;
      ValaArrayList* _tmp2_ = NULL;
      ValaList* params;
      gboolean _tmp3_;
      ValaLambdaExpression* lambda = NULL;
      ValaTokenType _tmp13_;
      GError * _inner_error_ = NULL;
      g_return_val_if_fail (self != NULL, NULL);
      vala_parser_get_location (self, &_tmp0_);
      _tmp1_ = _tmp0_;
      begin = _tmp1_;
      _tmp2_ = vala_array_list_new (VALA_TYPE_PARAMETER, (GBoxedCopyFunc) vala_code_node_ref, vala_code_node_unref, g_direct_equal);
      params = (ValaList*) _tmp2_;
      _tmp3_ = vala_parser_accept (self, VALA_TOKEN_TYPE_OPEN_PARENS);
      if (_tmp3_) {
            ValaTokenType _tmp4_;
            _tmp4_ = vala_parser_current (self);
            if (_tmp4_ != VALA_TOKEN_TYPE_CLOSE_PARENS) {
                  {
                        gboolean _tmp5_;
                        _tmp5_ = TRUE;
                        while (TRUE) {
                              ValaParameter* _tmp7_ = NULL;
                              ValaParameter* _tmp8_;
                              ValaParameter* _tmp9_;
                              if (!_tmp5_) {
                                    gboolean _tmp6_;
                                    _tmp6_ = vala_parser_accept (self, VALA_TOKEN_TYPE_COMMA);
                                    if (!_tmp6_) {
                                          break;
                                    }
                              }
                              _tmp5_ = FALSE;
                              _tmp7_ = vala_parser_parse_lambda_parameter (self, &_inner_error_);
                              _tmp8_ = _tmp7_;
                              if (_inner_error_ != NULL) {
                                    if (_inner_error_->domain == VALA_PARSE_ERROR) {
                                          g_propagate_error (error, _inner_error_);
                                          _vala_iterable_unref0 (params);
                                          return NULL;
                                    } else {
                                          _vala_iterable_unref0 (params);
                                          g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                                          g_clear_error (&_inner_error_);
                                          return NULL;
                                    }
                              }
                              _tmp9_ = _tmp8_;
                              vala_collection_add ((ValaCollection*) params, _tmp9_);
                              _vala_code_node_unref0 (_tmp9_);
                        }
                  }
            }
            vala_parser_expect (self, VALA_TOKEN_TYPE_CLOSE_PARENS, &_inner_error_);
            if (_inner_error_ != NULL) {
                  if (_inner_error_->domain == VALA_PARSE_ERROR) {
                        g_propagate_error (error, _inner_error_);
                        _vala_iterable_unref0 (params);
                        return NULL;
                  } else {
                        _vala_iterable_unref0 (params);
                        g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                        g_clear_error (&_inner_error_);
                        return NULL;
                  }
            }
      } else {
            ValaParameter* _tmp10_ = NULL;
            ValaParameter* _tmp11_;
            ValaParameter* _tmp12_;
            _tmp10_ = vala_parser_parse_lambda_parameter (self, &_inner_error_);
            _tmp11_ = _tmp10_;
            if (_inner_error_ != NULL) {
                  if (_inner_error_->domain == VALA_PARSE_ERROR) {
                        g_propagate_error (error, _inner_error_);
                        _vala_iterable_unref0 (params);
                        return NULL;
                  } else {
                        _vala_iterable_unref0 (params);
                        g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                        g_clear_error (&_inner_error_);
                        return NULL;
                  }
            }
            _tmp12_ = _tmp11_;
            vala_collection_add ((ValaCollection*) params, _tmp12_);
            _vala_code_node_unref0 (_tmp12_);
      }
      vala_parser_expect (self, VALA_TOKEN_TYPE_LAMBDA, &_inner_error_);
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  _vala_iterable_unref0 (params);
                  return NULL;
            } else {
                  _vala_iterable_unref0 (params);
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      _tmp13_ = vala_parser_current (self);
      if (_tmp13_ == VALA_TOKEN_TYPE_OPEN_BRACE) {
            ValaBlock* _tmp14_ = NULL;
            ValaBlock* block;
            ValaSourceReference* _tmp15_ = NULL;
            ValaSourceReference* _tmp16_;
            ValaLambdaExpression* _tmp17_ = NULL;
            _tmp14_ = vala_parser_parse_block (self, &_inner_error_);
            block = _tmp14_;
            if (_inner_error_ != NULL) {
                  if (_inner_error_->domain == VALA_PARSE_ERROR) {
                        g_propagate_error (error, _inner_error_);
                        _vala_code_node_unref0 (lambda);
                        _vala_iterable_unref0 (params);
                        return NULL;
                  } else {
                        _vala_code_node_unref0 (lambda);
                        _vala_iterable_unref0 (params);
                        g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                        g_clear_error (&_inner_error_);
                        return NULL;
                  }
            }
            _tmp15_ = vala_parser_get_src (self, &begin);
            _tmp16_ = _tmp15_;
            _tmp17_ = vala_lambda_expression_new_with_statement_body (block, _tmp16_);
            _vala_code_node_unref0 (lambda);
            lambda = _tmp17_;
            _vala_source_reference_unref0 (_tmp16_);
            _vala_code_node_unref0 (block);
      } else {
            ValaExpression* _tmp18_ = NULL;
            ValaExpression* expr;
            ValaSourceReference* _tmp19_ = NULL;
            ValaSourceReference* _tmp20_;
            ValaLambdaExpression* _tmp21_ = NULL;
            _tmp18_ = vala_parser_parse_expression (self, &_inner_error_);
            expr = _tmp18_;
            if (_inner_error_ != NULL) {
                  if (_inner_error_->domain == VALA_PARSE_ERROR) {
                        g_propagate_error (error, _inner_error_);
                        _vala_code_node_unref0 (lambda);
                        _vala_iterable_unref0 (params);
                        return NULL;
                  } else {
                        _vala_code_node_unref0 (lambda);
                        _vala_iterable_unref0 (params);
                        g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                        g_clear_error (&_inner_error_);
                        return NULL;
                  }
            }
            _tmp19_ = vala_parser_get_src (self, &begin);
            _tmp20_ = _tmp19_;
            _tmp21_ = vala_lambda_expression_new (expr, _tmp20_);
            _vala_code_node_unref0 (lambda);
            lambda = _tmp21_;
            _vala_source_reference_unref0 (_tmp20_);
            _vala_code_node_unref0 (expr);
      }
      {
            ValaList* _tmp22_;
            ValaList* _param_list;
            gint _tmp23_;
            gint _param_size;
            gint _param_index;
            _tmp22_ = _vala_iterable_ref0 (params);
            _param_list = _tmp22_;
            _tmp23_ = vala_collection_get_size ((ValaCollection*) _param_list);
            _param_size = _tmp23_;
            _param_index = -1;
            while (TRUE) {
                  gpointer _tmp24_ = NULL;
                  ValaParameter* param;
                  _param_index = _param_index + 1;
                  if (!(_param_index < _param_size)) {
                        break;
                  }
                  _tmp24_ = vala_list_get (_param_list, _param_index);
                  param = (ValaParameter*) _tmp24_;
                  vala_lambda_expression_add_parameter (lambda, param);
                  _vala_code_node_unref0 (param);
            }
            _vala_iterable_unref0 (_param_list);
      }
      result = (ValaExpression*) lambda;
      _vala_iterable_unref0 (params);
      return result;
}


static ValaAssignmentOperator vala_parser_get_assignment_operator (ValaParser* self, ValaTokenType token_type) {
      ValaAssignmentOperator result = 0;
      g_return_val_if_fail (self != NULL, 0);
      switch (token_type) {
            case VALA_TOKEN_TYPE_ASSIGN:
            {
                  result = VALA_ASSIGNMENT_OPERATOR_SIMPLE;
                  return result;
            }
            case VALA_TOKEN_TYPE_ASSIGN_ADD:
            {
                  result = VALA_ASSIGNMENT_OPERATOR_ADD;
                  return result;
            }
            case VALA_TOKEN_TYPE_ASSIGN_SUB:
            {
                  result = VALA_ASSIGNMENT_OPERATOR_SUB;
                  return result;
            }
            case VALA_TOKEN_TYPE_ASSIGN_BITWISE_OR:
            {
                  result = VALA_ASSIGNMENT_OPERATOR_BITWISE_OR;
                  return result;
            }
            case VALA_TOKEN_TYPE_ASSIGN_BITWISE_AND:
            {
                  result = VALA_ASSIGNMENT_OPERATOR_BITWISE_AND;
                  return result;
            }
            case VALA_TOKEN_TYPE_ASSIGN_BITWISE_XOR:
            {
                  result = VALA_ASSIGNMENT_OPERATOR_BITWISE_XOR;
                  return result;
            }
            case VALA_TOKEN_TYPE_ASSIGN_DIV:
            {
                  result = VALA_ASSIGNMENT_OPERATOR_DIV;
                  return result;
            }
            case VALA_TOKEN_TYPE_ASSIGN_MUL:
            {
                  result = VALA_ASSIGNMENT_OPERATOR_MUL;
                  return result;
            }
            case VALA_TOKEN_TYPE_ASSIGN_PERCENT:
            {
                  result = VALA_ASSIGNMENT_OPERATOR_PERCENT;
                  return result;
            }
            case VALA_TOKEN_TYPE_ASSIGN_SHIFT_LEFT:
            {
                  result = VALA_ASSIGNMENT_OPERATOR_SHIFT_LEFT;
                  return result;
            }
            default:
            {
                  result = VALA_ASSIGNMENT_OPERATOR_NONE;
                  return result;
            }
      }
}


static ValaExpression* vala_parser_parse_expression (ValaParser* self, GError** error) {
      ValaExpression* result = NULL;
      gboolean _tmp0_;
      ValaSourceLocation _tmp3_ = {0};
      ValaSourceLocation _tmp4_ = {0};
      ValaSourceLocation begin;
      ValaExpression* _tmp5_ = NULL;
      ValaExpression* expr;
      GError * _inner_error_ = NULL;
      g_return_val_if_fail (self != NULL, NULL);
      _tmp0_ = vala_parser_is_lambda_expression (self);
      if (_tmp0_) {
            ValaExpression* _tmp1_ = NULL;
            ValaExpression* _tmp2_;
            _tmp1_ = vala_parser_parse_lambda_expression (self, &_inner_error_);
            _tmp2_ = _tmp1_;
            if (_inner_error_ != NULL) {
                  if (_inner_error_->domain == VALA_PARSE_ERROR) {
                        g_propagate_error (error, _inner_error_);
                        return NULL;
                  } else {
                        g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                        g_clear_error (&_inner_error_);
                        return NULL;
                  }
            }
            result = _tmp2_;
            return result;
      }
      vala_parser_get_location (self, &_tmp3_);
      _tmp4_ = _tmp3_;
      begin = _tmp4_;
      _tmp5_ = vala_parser_parse_conditional_expression (self, &_inner_error_);
      expr = _tmp5_;
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  return NULL;
            } else {
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      while (TRUE) {
            ValaTokenType _tmp6_;
            ValaAssignmentOperator _tmp7_;
            ValaAssignmentOperator operator;
            _tmp6_ = vala_parser_current (self);
            _tmp7_ = vala_parser_get_assignment_operator (self, _tmp6_);
            operator = _tmp7_;
            if (operator != VALA_ASSIGNMENT_OPERATOR_NONE) {
                  ValaExpression* _tmp8_ = NULL;
                  ValaExpression* rhs;
                  ValaSourceReference* _tmp9_ = NULL;
                  ValaSourceReference* _tmp10_;
                  ValaAssignment* _tmp11_ = NULL;
                  vala_parser_next (self);
                  _tmp8_ = vala_parser_parse_expression (self, &_inner_error_);
                  rhs = _tmp8_;
                  if (_inner_error_ != NULL) {
                        if (_inner_error_->domain == VALA_PARSE_ERROR) {
                              g_propagate_error (error, _inner_error_);
                              _vala_code_node_unref0 (expr);
                              return NULL;
                        } else {
                              _vala_code_node_unref0 (expr);
                              g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                              g_clear_error (&_inner_error_);
                              return NULL;
                        }
                  }
                  _tmp9_ = vala_parser_get_src (self, &begin);
                  _tmp10_ = _tmp9_;
                  _tmp11_ = vala_assignment_new (expr, rhs, operator, _tmp10_);
                  _vala_code_node_unref0 (expr);
                  expr = (ValaExpression*) _tmp11_;
                  _vala_source_reference_unref0 (_tmp10_);
                  _vala_code_node_unref0 (rhs);
            } else {
                  ValaTokenType _tmp12_;
                  _tmp12_ = vala_parser_current (self);
                  if (_tmp12_ == VALA_TOKEN_TYPE_OP_GT) {
                        gchar* first_gt_pos;
                        gboolean _tmp13_ = FALSE;
                        ValaTokenType _tmp14_;
                        first_gt_pos = self->priv->tokens[self->priv->index].begin.pos;
                        vala_parser_next (self);
                        _tmp14_ = vala_parser_current (self);
                        if (_tmp14_ == VALA_TOKEN_TYPE_OP_GE) {
                              _tmp13_ = self->priv->tokens[self->priv->index].begin.pos == (first_gt_pos + 1);
                        } else {
                              _tmp13_ = FALSE;
                        }
                        if (_tmp13_) {
                              ValaExpression* _tmp15_ = NULL;
                              ValaExpression* rhs;
                              ValaSourceReference* _tmp16_ = NULL;
                              ValaSourceReference* _tmp17_;
                              ValaAssignment* _tmp18_ = NULL;
                              vala_parser_next (self);
                              _tmp15_ = vala_parser_parse_expression (self, &_inner_error_);
                              rhs = _tmp15_;
                              if (_inner_error_ != NULL) {
                                    if (_inner_error_->domain == VALA_PARSE_ERROR) {
                                          g_propagate_error (error, _inner_error_);
                                          _vala_code_node_unref0 (expr);
                                          return NULL;
                                    } else {
                                          _vala_code_node_unref0 (expr);
                                          g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                                          g_clear_error (&_inner_error_);
                                          return NULL;
                                    }
                              }
                              _tmp16_ = vala_parser_get_src (self, &begin);
                              _tmp17_ = _tmp16_;
                              _tmp18_ = vala_assignment_new (expr, rhs, VALA_ASSIGNMENT_OPERATOR_SHIFT_RIGHT, _tmp17_);
                              _vala_code_node_unref0 (expr);
                              expr = (ValaExpression*) _tmp18_;
                              _vala_source_reference_unref0 (_tmp17_);
                              _vala_code_node_unref0 (rhs);
                        } else {
                              vala_parser_prev (self);
                              break;
                        }
                  } else {
                        break;
                  }
            }
      }
      result = expr;
      return result;
}


static void vala_parser_parse_statements (ValaParser* self, ValaBlock* block, GError** error) {
      GError * _inner_error_ = NULL;
      g_return_if_fail (self != NULL);
      g_return_if_fail (block != NULL);
      while (TRUE) {
            gboolean _tmp0_ = FALSE;
            gboolean _tmp1_ = FALSE;
            gboolean _tmp2_ = FALSE;
            ValaTokenType _tmp3_;
            _tmp3_ = vala_parser_current (self);
            if (_tmp3_ != VALA_TOKEN_TYPE_CLOSE_BRACE) {
                  ValaTokenType _tmp4_;
                  _tmp4_ = vala_parser_current (self);
                  _tmp2_ = _tmp4_ != VALA_TOKEN_TYPE_CASE;
            } else {
                  _tmp2_ = FALSE;
            }
            if (_tmp2_) {
                  ValaTokenType _tmp5_;
                  _tmp5_ = vala_parser_current (self);
                  _tmp1_ = _tmp5_ != VALA_TOKEN_TYPE_DEFAULT;
            } else {
                  _tmp1_ = FALSE;
            }
            if (_tmp1_) {
                  ValaTokenType _tmp6_;
                  _tmp6_ = vala_parser_current (self);
                  _tmp0_ = _tmp6_ != VALA_TOKEN_TYPE_EOF;
            } else {
                  _tmp0_ = FALSE;
            }
            if (!_tmp0_) {
                  break;
            }
            {
                  ValaStatement* stmt;
                  gboolean is_decl;
                  ValaComment* _tmp7_ = NULL;
                  ValaTokenType _tmp8_;
                  stmt = NULL;
                  is_decl = FALSE;
                  _tmp7_ = vala_scanner_pop_comment (self->priv->scanner);
                  _vala_comment_unref0 (self->priv->comment);
                  self->priv->comment = _tmp7_;
                  _tmp8_ = vala_parser_current (self);
                  switch (_tmp8_) {
                        case VALA_TOKEN_TYPE_OPEN_BRACE:
                        {
                              ValaBlock* _tmp9_ = NULL;
                              ValaBlock* _tmp10_;
                              _tmp9_ = vala_parser_parse_block (self, &_inner_error_);
                              _tmp10_ = _tmp9_;
                              if (_inner_error_ != NULL) {
                                    _vala_code_node_unref0 (stmt);
                                    if (_inner_error_->domain == VALA_PARSE_ERROR) {
                                          goto __catch10_vala_parse_error;
                                    }
                                    _vala_code_node_unref0 (stmt);
                                    g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                                    g_clear_error (&_inner_error_);
                                    return;
                              }
                              _vala_code_node_unref0 (stmt);
                              stmt = (ValaStatement*) _tmp10_;
                              break;
                        }
                        case VALA_TOKEN_TYPE_SEMICOLON:
                        {
                              ValaStatement* _tmp11_ = NULL;
                              ValaStatement* _tmp12_;
                              _tmp11_ = vala_parser_parse_empty_statement (self, &_inner_error_);
                              _tmp12_ = _tmp11_;
                              if (_inner_error_ != NULL) {
                                    _vala_code_node_unref0 (stmt);
                                    if (_inner_error_->domain == VALA_PARSE_ERROR) {
                                          goto __catch10_vala_parse_error;
                                    }
                                    _vala_code_node_unref0 (stmt);
                                    g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                                    g_clear_error (&_inner_error_);
                                    return;
                              }
                              _vala_code_node_unref0 (stmt);
                              stmt = _tmp12_;
                              break;
                        }
                        case VALA_TOKEN_TYPE_IF:
                        {
                              ValaStatement* _tmp13_ = NULL;
                              ValaStatement* _tmp14_;
                              _tmp13_ = vala_parser_parse_if_statement (self, &_inner_error_);
                              _tmp14_ = _tmp13_;
                              if (_inner_error_ != NULL) {
                                    _vala_code_node_unref0 (stmt);
                                    if (_inner_error_->domain == VALA_PARSE_ERROR) {
                                          goto __catch10_vala_parse_error;
                                    }
                                    _vala_code_node_unref0 (stmt);
                                    g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                                    g_clear_error (&_inner_error_);
                                    return;
                              }
                              _vala_code_node_unref0 (stmt);
                              stmt = _tmp14_;
                              break;
                        }
                        case VALA_TOKEN_TYPE_SWITCH:
                        {
                              ValaStatement* _tmp15_ = NULL;
                              ValaStatement* _tmp16_;
                              _tmp15_ = vala_parser_parse_switch_statement (self, &_inner_error_);
                              _tmp16_ = _tmp15_;
                              if (_inner_error_ != NULL) {
                                    _vala_code_node_unref0 (stmt);
                                    if (_inner_error_->domain == VALA_PARSE_ERROR) {
                                          goto __catch10_vala_parse_error;
                                    }
                                    _vala_code_node_unref0 (stmt);
                                    g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                                    g_clear_error (&_inner_error_);
                                    return;
                              }
                              _vala_code_node_unref0 (stmt);
                              stmt = _tmp16_;
                              break;
                        }
                        case VALA_TOKEN_TYPE_WHILE:
                        {
                              ValaStatement* _tmp17_ = NULL;
                              ValaStatement* _tmp18_;
                              _tmp17_ = vala_parser_parse_while_statement (self, &_inner_error_);
                              _tmp18_ = _tmp17_;
                              if (_inner_error_ != NULL) {
                                    _vala_code_node_unref0 (stmt);
                                    if (_inner_error_->domain == VALA_PARSE_ERROR) {
                                          goto __catch10_vala_parse_error;
                                    }
                                    _vala_code_node_unref0 (stmt);
                                    g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                                    g_clear_error (&_inner_error_);
                                    return;
                              }
                              _vala_code_node_unref0 (stmt);
                              stmt = _tmp18_;
                              break;
                        }
                        case VALA_TOKEN_TYPE_DO:
                        {
                              ValaStatement* _tmp19_ = NULL;
                              ValaStatement* _tmp20_;
                              _tmp19_ = vala_parser_parse_do_statement (self, &_inner_error_);
                              _tmp20_ = _tmp19_;
                              if (_inner_error_ != NULL) {
                                    _vala_code_node_unref0 (stmt);
                                    if (_inner_error_->domain == VALA_PARSE_ERROR) {
                                          goto __catch10_vala_parse_error;
                                    }
                                    _vala_code_node_unref0 (stmt);
                                    g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                                    g_clear_error (&_inner_error_);
                                    return;
                              }
                              _vala_code_node_unref0 (stmt);
                              stmt = _tmp20_;
                              break;
                        }
                        case VALA_TOKEN_TYPE_FOR:
                        {
                              ValaStatement* _tmp21_ = NULL;
                              ValaStatement* _tmp22_;
                              _tmp21_ = vala_parser_parse_for_statement (self, &_inner_error_);
                              _tmp22_ = _tmp21_;
                              if (_inner_error_ != NULL) {
                                    _vala_code_node_unref0 (stmt);
                                    if (_inner_error_->domain == VALA_PARSE_ERROR) {
                                          goto __catch10_vala_parse_error;
                                    }
                                    _vala_code_node_unref0 (stmt);
                                    g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                                    g_clear_error (&_inner_error_);
                                    return;
                              }
                              _vala_code_node_unref0 (stmt);
                              stmt = _tmp22_;
                              break;
                        }
                        case VALA_TOKEN_TYPE_FOREACH:
                        {
                              ValaStatement* _tmp23_ = NULL;
                              ValaStatement* _tmp24_;
                              _tmp23_ = vala_parser_parse_foreach_statement (self, &_inner_error_);
                              _tmp24_ = _tmp23_;
                              if (_inner_error_ != NULL) {
                                    _vala_code_node_unref0 (stmt);
                                    if (_inner_error_->domain == VALA_PARSE_ERROR) {
                                          goto __catch10_vala_parse_error;
                                    }
                                    _vala_code_node_unref0 (stmt);
                                    g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                                    g_clear_error (&_inner_error_);
                                    return;
                              }
                              _vala_code_node_unref0 (stmt);
                              stmt = _tmp24_;
                              break;
                        }
                        case VALA_TOKEN_TYPE_BREAK:
                        {
                              ValaStatement* _tmp25_ = NULL;
                              ValaStatement* _tmp26_;
                              _tmp25_ = vala_parser_parse_break_statement (self, &_inner_error_);
                              _tmp26_ = _tmp25_;
                              if (_inner_error_ != NULL) {
                                    _vala_code_node_unref0 (stmt);
                                    if (_inner_error_->domain == VALA_PARSE_ERROR) {
                                          goto __catch10_vala_parse_error;
                                    }
                                    _vala_code_node_unref0 (stmt);
                                    g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                                    g_clear_error (&_inner_error_);
                                    return;
                              }
                              _vala_code_node_unref0 (stmt);
                              stmt = _tmp26_;
                              break;
                        }
                        case VALA_TOKEN_TYPE_CONTINUE:
                        {
                              ValaStatement* _tmp27_ = NULL;
                              ValaStatement* _tmp28_;
                              _tmp27_ = vala_parser_parse_continue_statement (self, &_inner_error_);
                              _tmp28_ = _tmp27_;
                              if (_inner_error_ != NULL) {
                                    _vala_code_node_unref0 (stmt);
                                    if (_inner_error_->domain == VALA_PARSE_ERROR) {
                                          goto __catch10_vala_parse_error;
                                    }
                                    _vala_code_node_unref0 (stmt);
                                    g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                                    g_clear_error (&_inner_error_);
                                    return;
                              }
                              _vala_code_node_unref0 (stmt);
                              stmt = _tmp28_;
                              break;
                        }
                        case VALA_TOKEN_TYPE_RETURN:
                        {
                              ValaStatement* _tmp29_ = NULL;
                              ValaStatement* _tmp30_;
                              _tmp29_ = vala_parser_parse_return_statement (self, &_inner_error_);
                              _tmp30_ = _tmp29_;
                              if (_inner_error_ != NULL) {
                                    _vala_code_node_unref0 (stmt);
                                    if (_inner_error_->domain == VALA_PARSE_ERROR) {
                                          goto __catch10_vala_parse_error;
                                    }
                                    _vala_code_node_unref0 (stmt);
                                    g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                                    g_clear_error (&_inner_error_);
                                    return;
                              }
                              _vala_code_node_unref0 (stmt);
                              stmt = _tmp30_;
                              break;
                        }
                        case VALA_TOKEN_TYPE_YIELD:
                        {
                              ValaStatement* _tmp31_ = NULL;
                              ValaStatement* _tmp32_;
                              _tmp31_ = vala_parser_parse_yield_statement (self, &_inner_error_);
                              _tmp32_ = _tmp31_;
                              if (_inner_error_ != NULL) {
                                    _vala_code_node_unref0 (stmt);
                                    if (_inner_error_->domain == VALA_PARSE_ERROR) {
                                          goto __catch10_vala_parse_error;
                                    }
                                    _vala_code_node_unref0 (stmt);
                                    g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                                    g_clear_error (&_inner_error_);
                                    return;
                              }
                              _vala_code_node_unref0 (stmt);
                              stmt = _tmp32_;
                              break;
                        }
                        case VALA_TOKEN_TYPE_THROW:
                        {
                              ValaStatement* _tmp33_ = NULL;
                              ValaStatement* _tmp34_;
                              _tmp33_ = vala_parser_parse_throw_statement (self, &_inner_error_);
                              _tmp34_ = _tmp33_;
                              if (_inner_error_ != NULL) {
                                    _vala_code_node_unref0 (stmt);
                                    if (_inner_error_->domain == VALA_PARSE_ERROR) {
                                          goto __catch10_vala_parse_error;
                                    }
                                    _vala_code_node_unref0 (stmt);
                                    g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                                    g_clear_error (&_inner_error_);
                                    return;
                              }
                              _vala_code_node_unref0 (stmt);
                              stmt = _tmp34_;
                              break;
                        }
                        case VALA_TOKEN_TYPE_TRY:
                        {
                              ValaStatement* _tmp35_ = NULL;
                              ValaStatement* _tmp36_;
                              _tmp35_ = vala_parser_parse_try_statement (self, &_inner_error_);
                              _tmp36_ = _tmp35_;
                              if (_inner_error_ != NULL) {
                                    _vala_code_node_unref0 (stmt);
                                    if (_inner_error_->domain == VALA_PARSE_ERROR) {
                                          goto __catch10_vala_parse_error;
                                    }
                                    _vala_code_node_unref0 (stmt);
                                    g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                                    g_clear_error (&_inner_error_);
                                    return;
                              }
                              _vala_code_node_unref0 (stmt);
                              stmt = _tmp36_;
                              break;
                        }
                        case VALA_TOKEN_TYPE_LOCK:
                        {
                              ValaStatement* _tmp37_ = NULL;
                              ValaStatement* _tmp38_;
                              _tmp37_ = vala_parser_parse_lock_statement (self, &_inner_error_);
                              _tmp38_ = _tmp37_;
                              if (_inner_error_ != NULL) {
                                    _vala_code_node_unref0 (stmt);
                                    if (_inner_error_->domain == VALA_PARSE_ERROR) {
                                          goto __catch10_vala_parse_error;
                                    }
                                    _vala_code_node_unref0 (stmt);
                                    g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                                    g_clear_error (&_inner_error_);
                                    return;
                              }
                              _vala_code_node_unref0 (stmt);
                              stmt = _tmp38_;
                              break;
                        }
                        case VALA_TOKEN_TYPE_DELETE:
                        {
                              ValaStatement* _tmp39_ = NULL;
                              ValaStatement* _tmp40_;
                              _tmp39_ = vala_parser_parse_delete_statement (self, &_inner_error_);
                              _tmp40_ = _tmp39_;
                              if (_inner_error_ != NULL) {
                                    _vala_code_node_unref0 (stmt);
                                    if (_inner_error_->domain == VALA_PARSE_ERROR) {
                                          goto __catch10_vala_parse_error;
                                    }
                                    _vala_code_node_unref0 (stmt);
                                    g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                                    g_clear_error (&_inner_error_);
                                    return;
                              }
                              _vala_code_node_unref0 (stmt);
                              stmt = _tmp40_;
                              break;
                        }
                        case VALA_TOKEN_TYPE_VAR:
                        {
                              is_decl = TRUE;
                              vala_parser_parse_local_variable_declarations (self, block, &_inner_error_);
                              if (_inner_error_ != NULL) {
                                    _vala_code_node_unref0 (stmt);
                                    if (_inner_error_->domain == VALA_PARSE_ERROR) {
                                          goto __catch10_vala_parse_error;
                                    }
                                    _vala_code_node_unref0 (stmt);
                                    g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                                    g_clear_error (&_inner_error_);
                                    return;
                              }
                              break;
                        }
                        case VALA_TOKEN_TYPE_CONST:
                        {
                              is_decl = TRUE;
                              vala_parser_parse_local_constant_declarations (self, block, &_inner_error_);
                              if (_inner_error_ != NULL) {
                                    _vala_code_node_unref0 (stmt);
                                    if (_inner_error_->domain == VALA_PARSE_ERROR) {
                                          goto __catch10_vala_parse_error;
                                    }
                                    _vala_code_node_unref0 (stmt);
                                    g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                                    g_clear_error (&_inner_error_);
                                    return;
                              }
                              break;
                        }
                        case VALA_TOKEN_TYPE_OP_INC:
                        case VALA_TOKEN_TYPE_OP_DEC:
                        case VALA_TOKEN_TYPE_BASE:
                        case VALA_TOKEN_TYPE_THIS:
                        case VALA_TOKEN_TYPE_OPEN_PARENS:
                        case VALA_TOKEN_TYPE_STAR:
                        case VALA_TOKEN_TYPE_NEW:
                        {
                              ValaStatement* _tmp41_ = NULL;
                              ValaStatement* _tmp42_;
                              _tmp41_ = vala_parser_parse_expression_statement (self, &_inner_error_);
                              _tmp42_ = _tmp41_;
                              if (_inner_error_ != NULL) {
                                    _vala_code_node_unref0 (stmt);
                                    if (_inner_error_->domain == VALA_PARSE_ERROR) {
                                          goto __catch10_vala_parse_error;
                                    }
                                    _vala_code_node_unref0 (stmt);
                                    g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                                    g_clear_error (&_inner_error_);
                                    return;
                              }
                              _vala_code_node_unref0 (stmt);
                              stmt = _tmp42_;
                              break;
                        }
                        default:
                        {
                              gboolean _tmp43_;
                              gboolean is_expr;
                              _tmp43_ = vala_parser_is_expression (self, &_inner_error_);
                              is_expr = _tmp43_;
                              if (_inner_error_ != NULL) {
                                    _vala_code_node_unref0 (stmt);
                                    if (_inner_error_->domain == VALA_PARSE_ERROR) {
                                          goto __catch10_vala_parse_error;
                                    }
                                    _vala_code_node_unref0 (stmt);
                                    g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                                    g_clear_error (&_inner_error_);
                                    return;
                              }
                              if (is_expr) {
                                    ValaStatement* _tmp44_ = NULL;
                                    ValaStatement* _tmp45_;
                                    _tmp44_ = vala_parser_parse_expression_statement (self, &_inner_error_);
                                    _tmp45_ = _tmp44_;
                                    if (_inner_error_ != NULL) {
                                          _vala_code_node_unref0 (stmt);
                                          if (_inner_error_->domain == VALA_PARSE_ERROR) {
                                                goto __catch10_vala_parse_error;
                                          }
                                          _vala_code_node_unref0 (stmt);
                                          g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                                          g_clear_error (&_inner_error_);
                                          return;
                                    }
                                    _vala_code_node_unref0 (stmt);
                                    stmt = _tmp45_;
                              } else {
                                    is_decl = TRUE;
                                    vala_parser_parse_local_variable_declarations (self, block, &_inner_error_);
                                    if (_inner_error_ != NULL) {
                                          _vala_code_node_unref0 (stmt);
                                          if (_inner_error_->domain == VALA_PARSE_ERROR) {
                                                goto __catch10_vala_parse_error;
                                          }
                                          _vala_code_node_unref0 (stmt);
                                          g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                                          g_clear_error (&_inner_error_);
                                          return;
                                    }
                              }
                              break;
                        }
                  }
                  if (!is_decl) {
                        gboolean _tmp46_ = FALSE;
                        ValaProfile _tmp47_;
                        _tmp47_ = vala_code_context_get_profile (self->priv->context);
                        if (_tmp47_ == VALA_PROFILE_DOVA) {
                              _tmp46_ = VALA_IS_RETURN_STATEMENT (stmt);
                        } else {
                              _tmp46_ = FALSE;
                        }
                        if (_tmp46_) {
                              ValaReturnStatement* _tmp48_;
                              ValaReturnStatement* ret_stmt;
                              ValaExpression* _tmp49_ = NULL;
                              _tmp48_ = _vala_code_node_ref0 (VALA_RETURN_STATEMENT (stmt));
                              ret_stmt = _tmp48_;
                              _tmp49_ = vala_return_statement_get_return_expression (ret_stmt);
                              if (_tmp49_ != NULL) {
                                    ValaSourceReference* _tmp50_ = NULL;
                                    ValaMemberAccess* _tmp51_ = NULL;
                                    ValaMemberAccess* _tmp52_;
                                    ValaExpression* _tmp53_ = NULL;
                                    ValaSourceReference* _tmp54_ = NULL;
                                    ValaAssignment* _tmp55_ = NULL;
                                    ValaAssignment* _tmp56_;
                                    ValaAssignment* assignment;
                                    ValaSourceReference* _tmp57_ = NULL;
                                    ValaExpressionStatement* _tmp58_ = NULL;
                                    ValaExpressionStatement* _tmp59_;
                                    _tmp50_ = vala_code_node_get_source_reference ((ValaCodeNode*) stmt);
                                    _tmp51_ = vala_member_access_new_simple ("result", _tmp50_);
                                    _tmp52_ = _tmp51_;
                                    _tmp53_ = vala_return_statement_get_return_expression (ret_stmt);
                                    _tmp54_ = vala_code_node_get_source_reference ((ValaCodeNode*) stmt);
                                    _tmp55_ = vala_assignment_new ((ValaExpression*) _tmp52_, _tmp53_, VALA_ASSIGNMENT_OPERATOR_SIMPLE, _tmp54_);
                                    _tmp56_ = _tmp55_;
                                    _vala_code_node_unref0 (_tmp52_);
                                    assignment = _tmp56_;
                                    vala_return_statement_set_return_expression (ret_stmt, NULL);
                                    _tmp57_ = vala_code_node_get_source_reference ((ValaCodeNode*) stmt);
                                    _tmp58_ = vala_expression_statement_new ((ValaExpression*) assignment, _tmp57_);
                                    _tmp59_ = _tmp58_;
                                    vala_block_add_statement (block, (ValaStatement*) _tmp59_);
                                    _vala_code_node_unref0 (_tmp59_);
                                    _vala_code_node_unref0 (assignment);
                              }
                              _vala_code_node_unref0 (ret_stmt);
                        }
                        vala_block_add_statement (block, stmt);
                  }
                  _vala_code_node_unref0 (stmt);
            }
            goto __finally10;
            __catch10_vala_parse_error:
            {
                  GError* e = NULL;
                  ValaParserRecoveryState _tmp60_;
                  e = _inner_error_;
                  _inner_error_ = NULL;
                  _tmp60_ = vala_parser_recover (self);
                  if (_tmp60_ != VALA_PARSER_RECOVERY_STATE_STATEMENT_BEGIN) {
                        _g_error_free0 (e);
                        break;
                  }
                  _g_error_free0 (e);
            }
            __finally10:
            if (_inner_error_ != NULL) {
                  if (_inner_error_->domain == VALA_PARSE_ERROR) {
                        g_propagate_error (error, _inner_error_);
                        return;
                  } else {
                        g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                        g_clear_error (&_inner_error_);
                        return;
                  }
            }
      }
}


static gboolean vala_parser_is_expression (ValaParser* self, GError** error) {
      gboolean result = FALSE;
      ValaSourceLocation _tmp0_ = {0};
      ValaSourceLocation _tmp1_ = {0};
      ValaSourceLocation begin;
      ValaTokenType _tmp2_;
      GError * _inner_error_ = NULL;
      g_return_val_if_fail (self != NULL, FALSE);
      vala_parser_get_location (self, &_tmp0_);
      _tmp1_ = _tmp0_;
      begin = _tmp1_;
      vala_parser_skip_type (self, &_inner_error_);
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  return FALSE;
            } else {
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return FALSE;
            }
      }
      _tmp2_ = vala_parser_current (self);
      switch (_tmp2_) {
            case VALA_TOKEN_TYPE_OPEN_PARENS:
            case VALA_TOKEN_TYPE_OP_INC:
            case VALA_TOKEN_TYPE_OP_DEC:
            case VALA_TOKEN_TYPE_ASSIGN:
            case VALA_TOKEN_TYPE_ASSIGN_ADD:
            case VALA_TOKEN_TYPE_ASSIGN_BITWISE_AND:
            case VALA_TOKEN_TYPE_ASSIGN_BITWISE_OR:
            case VALA_TOKEN_TYPE_ASSIGN_BITWISE_XOR:
            case VALA_TOKEN_TYPE_ASSIGN_DIV:
            case VALA_TOKEN_TYPE_ASSIGN_MUL:
            case VALA_TOKEN_TYPE_ASSIGN_PERCENT:
            case VALA_TOKEN_TYPE_ASSIGN_SHIFT_LEFT:
            case VALA_TOKEN_TYPE_ASSIGN_SUB:
            case VALA_TOKEN_TYPE_OP_GT:
            case VALA_TOKEN_TYPE_DOT:
            case VALA_TOKEN_TYPE_OP_PTR:
            {
                  vala_parser_rollback (self, &begin);
                  result = TRUE;
                  return result;
            }
            default:
            {
                  vala_parser_rollback (self, &begin);
                  result = FALSE;
                  return result;
            }
      }
}


static gboolean vala_parser_is_lambda_expression (ValaParser* self) {
      gboolean result = FALSE;
      ValaSourceLocation _tmp0_ = {0};
      ValaSourceLocation _tmp1_ = {0};
      ValaSourceLocation begin;
      ValaTokenType _tmp2_;
      g_return_val_if_fail (self != NULL, FALSE);
      vala_parser_get_location (self, &_tmp0_);
      _tmp1_ = _tmp0_;
      begin = _tmp1_;
      _tmp2_ = vala_parser_current (self);
      switch (_tmp2_) {
            case VALA_TOKEN_TYPE_OUT:
            case VALA_TOKEN_TYPE_REF:
            {
                  gboolean _tmp3_ = FALSE;
                  gboolean _tmp4_;
                  vala_parser_next (self);
                  _tmp4_ = vala_parser_accept (self, VALA_TOKEN_TYPE_IDENTIFIER);
                  if (_tmp4_) {
                        gboolean _tmp5_;
                        _tmp5_ = vala_parser_accept (self, VALA_TOKEN_TYPE_LAMBDA);
                        _tmp3_ = _tmp5_;
                  } else {
                        _tmp3_ = FALSE;
                  }
                  if (_tmp3_) {
                        vala_parser_rollback (self, &begin);
                        result = TRUE;
                        return result;
                  }
                  break;
            }
            case VALA_TOKEN_TYPE_IDENTIFIER:
            {
                  gboolean _tmp6_;
                  vala_parser_next (self);
                  _tmp6_ = vala_parser_accept (self, VALA_TOKEN_TYPE_LAMBDA);
                  if (_tmp6_) {
                        vala_parser_rollback (self, &begin);
                        result = TRUE;
                        return result;
                  }
                  break;
            }
            case VALA_TOKEN_TYPE_OPEN_PARENS:
            {
                  ValaTokenType _tmp7_;
                  gboolean _tmp14_ = FALSE;
                  gboolean _tmp15_;
                  vala_parser_next (self);
                  _tmp7_ = vala_parser_current (self);
                  if (_tmp7_ != VALA_TOKEN_TYPE_CLOSE_PARENS) {
                        {
                              gboolean _tmp8_;
                              _tmp8_ = TRUE;
                              while (TRUE) {
                                    gboolean _tmp10_ = FALSE;
                                    ValaTokenType _tmp11_;
                                    gboolean _tmp13_;
                                    if (!_tmp8_) {
                                          gboolean _tmp9_;
                                          _tmp9_ = vala_parser_accept (self, VALA_TOKEN_TYPE_COMMA);
                                          if (!_tmp9_) {
                                                break;
                                          }
                                    }
                                    _tmp8_ = FALSE;
                                    _tmp11_ = vala_parser_current (self);
                                    if (_tmp11_ == VALA_TOKEN_TYPE_OUT) {
                                          _tmp10_ = TRUE;
                                    } else {
                                          ValaTokenType _tmp12_;
                                          _tmp12_ = vala_parser_current (self);
                                          _tmp10_ = _tmp12_ == VALA_TOKEN_TYPE_REF;
                                    }
                                    if (_tmp10_) {
                                          vala_parser_next (self);
                                    }
                                    _tmp13_ = vala_parser_accept (self, VALA_TOKEN_TYPE_IDENTIFIER);
                                    if (!_tmp13_) {
                                          vala_parser_rollback (self, &begin);
                                          result = FALSE;
                                          return result;
                                    }
                              }
                        }
                  }
                  _tmp15_ = vala_parser_accept (self, VALA_TOKEN_TYPE_CLOSE_PARENS);
                  if (_tmp15_) {
                        gboolean _tmp16_;
                        _tmp16_ = vala_parser_accept (self, VALA_TOKEN_TYPE_LAMBDA);
                        _tmp14_ = _tmp16_;
                  } else {
                        _tmp14_ = FALSE;
                  }
                  if (_tmp14_) {
                        vala_parser_rollback (self, &begin);
                        result = TRUE;
                        return result;
                  }
                  break;
            }
            default:
            break;
      }
      vala_parser_rollback (self, &begin);
      result = FALSE;
      return result;
}


static ValaBlock* vala_parser_parse_embedded_statement (ValaParser* self, GError** error) {
      ValaBlock* result = NULL;
      ValaTokenType _tmp0_;
      ValaComment* _tmp2_ = NULL;
      ValaSourceLocation _tmp3_ = {0};
      ValaSourceLocation _tmp4_ = {0};
      ValaSourceReference* _tmp5_ = NULL;
      ValaSourceReference* _tmp6_;
      ValaBlock* _tmp7_ = NULL;
      ValaBlock* _tmp8_;
      ValaBlock* block;
      ValaStatement* _tmp9_ = NULL;
      ValaStatement* stmt;
      gboolean _tmp10_ = FALSE;
      ValaProfile _tmp11_;
      GError * _inner_error_ = NULL;
      g_return_val_if_fail (self != NULL, NULL);
      _tmp0_ = vala_parser_current (self);
      if (_tmp0_ == VALA_TOKEN_TYPE_OPEN_BRACE) {
            ValaBlock* _tmp1_ = NULL;
            ValaBlock* block;
            _tmp1_ = vala_parser_parse_block (self, &_inner_error_);
            block = _tmp1_;
            if (_inner_error_ != NULL) {
                  if (_inner_error_->domain == VALA_PARSE_ERROR) {
                        g_propagate_error (error, _inner_error_);
                        return NULL;
                  } else {
                        g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                        g_clear_error (&_inner_error_);
                        return NULL;
                  }
            }
            result = block;
            return result;
      }
      _tmp2_ = vala_scanner_pop_comment (self->priv->scanner);
      _vala_comment_unref0 (self->priv->comment);
      self->priv->comment = _tmp2_;
      vala_parser_get_location (self, &_tmp3_);
      _tmp4_ = _tmp3_;
      _tmp5_ = vala_parser_get_src (self, &_tmp4_);
      _tmp6_ = _tmp5_;
      _tmp7_ = vala_block_new (_tmp6_);
      _tmp8_ = _tmp7_;
      _vala_source_reference_unref0 (_tmp6_);
      block = _tmp8_;
      _tmp9_ = vala_parser_parse_embedded_statement_without_block (self, &_inner_error_);
      stmt = _tmp9_;
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  _vala_code_node_unref0 (block);
                  return NULL;
            } else {
                  _vala_code_node_unref0 (block);
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      _tmp11_ = vala_code_context_get_profile (self->priv->context);
      if (_tmp11_ == VALA_PROFILE_DOVA) {
            _tmp10_ = VALA_IS_RETURN_STATEMENT (stmt);
      } else {
            _tmp10_ = FALSE;
      }
      if (_tmp10_) {
            ValaReturnStatement* _tmp12_;
            ValaReturnStatement* ret_stmt;
            ValaExpression* _tmp13_ = NULL;
            _tmp12_ = _vala_code_node_ref0 (VALA_RETURN_STATEMENT (stmt));
            ret_stmt = _tmp12_;
            _tmp13_ = vala_return_statement_get_return_expression (ret_stmt);
            if (_tmp13_ != NULL) {
                  ValaMemberAccess* _tmp14_ = NULL;
                  ValaMemberAccess* _tmp15_;
                  ValaExpression* _tmp16_ = NULL;
                  ValaAssignment* _tmp17_ = NULL;
                  ValaAssignment* _tmp18_;
                  ValaAssignment* assignment;
                  ValaExpressionStatement* _tmp19_ = NULL;
                  ValaExpressionStatement* _tmp20_;
                  _tmp14_ = vala_member_access_new_simple ("result", NULL);
                  _tmp15_ = _tmp14_;
                  _tmp16_ = vala_return_statement_get_return_expression (ret_stmt);
                  _tmp17_ = vala_assignment_new ((ValaExpression*) _tmp15_, _tmp16_, VALA_ASSIGNMENT_OPERATOR_SIMPLE, NULL);
                  _tmp18_ = _tmp17_;
                  _vala_code_node_unref0 (_tmp15_);
                  assignment = _tmp18_;
                  vala_return_statement_set_return_expression (ret_stmt, NULL);
                  _tmp19_ = vala_expression_statement_new ((ValaExpression*) assignment, NULL);
                  _tmp20_ = _tmp19_;
                  vala_block_add_statement (block, (ValaStatement*) _tmp20_);
                  _vala_code_node_unref0 (_tmp20_);
                  _vala_code_node_unref0 (assignment);
            }
            _vala_code_node_unref0 (ret_stmt);
      }
      vala_block_add_statement (block, stmt);
      result = block;
      _vala_code_node_unref0 (stmt);
      return result;
}


static ValaStatement* vala_parser_parse_embedded_statement_without_block (ValaParser* self, GError** error) {
      ValaStatement* result = NULL;
      ValaTokenType _tmp0_;
      GError * _inner_error_ = NULL;
      g_return_val_if_fail (self != NULL, NULL);
      _tmp0_ = vala_parser_current (self);
      switch (_tmp0_) {
            case VALA_TOKEN_TYPE_SEMICOLON:
            {
                  ValaStatement* _tmp1_ = NULL;
                  ValaStatement* _tmp2_;
                  _tmp1_ = vala_parser_parse_empty_statement (self, &_inner_error_);
                  _tmp2_ = _tmp1_;
                  if (_inner_error_ != NULL) {
                        if (_inner_error_->domain == VALA_PARSE_ERROR) {
                              g_propagate_error (error, _inner_error_);
                              return NULL;
                        } else {
                              g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                              g_clear_error (&_inner_error_);
                              return NULL;
                        }
                  }
                  result = _tmp2_;
                  return result;
            }
            case VALA_TOKEN_TYPE_IF:
            {
                  ValaStatement* _tmp3_ = NULL;
                  ValaStatement* _tmp4_;
                  _tmp3_ = vala_parser_parse_if_statement (self, &_inner_error_);
                  _tmp4_ = _tmp3_;
                  if (_inner_error_ != NULL) {
                        if (_inner_error_->domain == VALA_PARSE_ERROR) {
                              g_propagate_error (error, _inner_error_);
                              return NULL;
                        } else {
                              g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                              g_clear_error (&_inner_error_);
                              return NULL;
                        }
                  }
                  result = _tmp4_;
                  return result;
            }
            case VALA_TOKEN_TYPE_SWITCH:
            {
                  ValaStatement* _tmp5_ = NULL;
                  ValaStatement* _tmp6_;
                  _tmp5_ = vala_parser_parse_switch_statement (self, &_inner_error_);
                  _tmp6_ = _tmp5_;
                  if (_inner_error_ != NULL) {
                        if (_inner_error_->domain == VALA_PARSE_ERROR) {
                              g_propagate_error (error, _inner_error_);
                              return NULL;
                        } else {
                              g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                              g_clear_error (&_inner_error_);
                              return NULL;
                        }
                  }
                  result = _tmp6_;
                  return result;
            }
            case VALA_TOKEN_TYPE_WHILE:
            {
                  ValaStatement* _tmp7_ = NULL;
                  ValaStatement* _tmp8_;
                  _tmp7_ = vala_parser_parse_while_statement (self, &_inner_error_);
                  _tmp8_ = _tmp7_;
                  if (_inner_error_ != NULL) {
                        if (_inner_error_->domain == VALA_PARSE_ERROR) {
                              g_propagate_error (error, _inner_error_);
                              return NULL;
                        } else {
                              g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                              g_clear_error (&_inner_error_);
                              return NULL;
                        }
                  }
                  result = _tmp8_;
                  return result;
            }
            case VALA_TOKEN_TYPE_DO:
            {
                  ValaStatement* _tmp9_ = NULL;
                  ValaStatement* _tmp10_;
                  _tmp9_ = vala_parser_parse_do_statement (self, &_inner_error_);
                  _tmp10_ = _tmp9_;
                  if (_inner_error_ != NULL) {
                        if (_inner_error_->domain == VALA_PARSE_ERROR) {
                              g_propagate_error (error, _inner_error_);
                              return NULL;
                        } else {
                              g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                              g_clear_error (&_inner_error_);
                              return NULL;
                        }
                  }
                  result = _tmp10_;
                  return result;
            }
            case VALA_TOKEN_TYPE_FOR:
            {
                  ValaStatement* _tmp11_ = NULL;
                  ValaStatement* _tmp12_;
                  _tmp11_ = vala_parser_parse_for_statement (self, &_inner_error_);
                  _tmp12_ = _tmp11_;
                  if (_inner_error_ != NULL) {
                        if (_inner_error_->domain == VALA_PARSE_ERROR) {
                              g_propagate_error (error, _inner_error_);
                              return NULL;
                        } else {
                              g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                              g_clear_error (&_inner_error_);
                              return NULL;
                        }
                  }
                  result = _tmp12_;
                  return result;
            }
            case VALA_TOKEN_TYPE_FOREACH:
            {
                  ValaStatement* _tmp13_ = NULL;
                  ValaStatement* _tmp14_;
                  _tmp13_ = vala_parser_parse_foreach_statement (self, &_inner_error_);
                  _tmp14_ = _tmp13_;
                  if (_inner_error_ != NULL) {
                        if (_inner_error_->domain == VALA_PARSE_ERROR) {
                              g_propagate_error (error, _inner_error_);
                              return NULL;
                        } else {
                              g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                              g_clear_error (&_inner_error_);
                              return NULL;
                        }
                  }
                  result = _tmp14_;
                  return result;
            }
            case VALA_TOKEN_TYPE_BREAK:
            {
                  ValaStatement* _tmp15_ = NULL;
                  ValaStatement* _tmp16_;
                  _tmp15_ = vala_parser_parse_break_statement (self, &_inner_error_);
                  _tmp16_ = _tmp15_;
                  if (_inner_error_ != NULL) {
                        if (_inner_error_->domain == VALA_PARSE_ERROR) {
                              g_propagate_error (error, _inner_error_);
                              return NULL;
                        } else {
                              g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                              g_clear_error (&_inner_error_);
                              return NULL;
                        }
                  }
                  result = _tmp16_;
                  return result;
            }
            case VALA_TOKEN_TYPE_CONTINUE:
            {
                  ValaStatement* _tmp17_ = NULL;
                  ValaStatement* _tmp18_;
                  _tmp17_ = vala_parser_parse_continue_statement (self, &_inner_error_);
                  _tmp18_ = _tmp17_;
                  if (_inner_error_ != NULL) {
                        if (_inner_error_->domain == VALA_PARSE_ERROR) {
                              g_propagate_error (error, _inner_error_);
                              return NULL;
                        } else {
                              g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                              g_clear_error (&_inner_error_);
                              return NULL;
                        }
                  }
                  result = _tmp18_;
                  return result;
            }
            case VALA_TOKEN_TYPE_RETURN:
            {
                  ValaStatement* _tmp19_ = NULL;
                  ValaStatement* _tmp20_;
                  _tmp19_ = vala_parser_parse_return_statement (self, &_inner_error_);
                  _tmp20_ = _tmp19_;
                  if (_inner_error_ != NULL) {
                        if (_inner_error_->domain == VALA_PARSE_ERROR) {
                              g_propagate_error (error, _inner_error_);
                              return NULL;
                        } else {
                              g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                              g_clear_error (&_inner_error_);
                              return NULL;
                        }
                  }
                  result = _tmp20_;
                  return result;
            }
            case VALA_TOKEN_TYPE_YIELD:
            {
                  ValaStatement* _tmp21_ = NULL;
                  ValaStatement* _tmp22_;
                  _tmp21_ = vala_parser_parse_yield_statement (self, &_inner_error_);
                  _tmp22_ = _tmp21_;
                  if (_inner_error_ != NULL) {
                        if (_inner_error_->domain == VALA_PARSE_ERROR) {
                              g_propagate_error (error, _inner_error_);
                              return NULL;
                        } else {
                              g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                              g_clear_error (&_inner_error_);
                              return NULL;
                        }
                  }
                  result = _tmp22_;
                  return result;
            }
            case VALA_TOKEN_TYPE_THROW:
            {
                  ValaStatement* _tmp23_ = NULL;
                  ValaStatement* _tmp24_;
                  _tmp23_ = vala_parser_parse_throw_statement (self, &_inner_error_);
                  _tmp24_ = _tmp23_;
                  if (_inner_error_ != NULL) {
                        if (_inner_error_->domain == VALA_PARSE_ERROR) {
                              g_propagate_error (error, _inner_error_);
                              return NULL;
                        } else {
                              g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                              g_clear_error (&_inner_error_);
                              return NULL;
                        }
                  }
                  result = _tmp24_;
                  return result;
            }
            case VALA_TOKEN_TYPE_TRY:
            {
                  ValaStatement* _tmp25_ = NULL;
                  ValaStatement* _tmp26_;
                  _tmp25_ = vala_parser_parse_try_statement (self, &_inner_error_);
                  _tmp26_ = _tmp25_;
                  if (_inner_error_ != NULL) {
                        if (_inner_error_->domain == VALA_PARSE_ERROR) {
                              g_propagate_error (error, _inner_error_);
                              return NULL;
                        } else {
                              g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                              g_clear_error (&_inner_error_);
                              return NULL;
                        }
                  }
                  result = _tmp26_;
                  return result;
            }
            case VALA_TOKEN_TYPE_LOCK:
            {
                  ValaStatement* _tmp27_ = NULL;
                  ValaStatement* _tmp28_;
                  _tmp27_ = vala_parser_parse_lock_statement (self, &_inner_error_);
                  _tmp28_ = _tmp27_;
                  if (_inner_error_ != NULL) {
                        if (_inner_error_->domain == VALA_PARSE_ERROR) {
                              g_propagate_error (error, _inner_error_);
                              return NULL;
                        } else {
                              g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                              g_clear_error (&_inner_error_);
                              return NULL;
                        }
                  }
                  result = _tmp28_;
                  return result;
            }
            case VALA_TOKEN_TYPE_DELETE:
            {
                  ValaStatement* _tmp29_ = NULL;
                  ValaStatement* _tmp30_;
                  _tmp29_ = vala_parser_parse_delete_statement (self, &_inner_error_);
                  _tmp30_ = _tmp29_;
                  if (_inner_error_ != NULL) {
                        if (_inner_error_->domain == VALA_PARSE_ERROR) {
                              g_propagate_error (error, _inner_error_);
                              return NULL;
                        } else {
                              g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                              g_clear_error (&_inner_error_);
                              return NULL;
                        }
                  }
                  result = _tmp30_;
                  return result;
            }
            case VALA_TOKEN_TYPE_VAR:
            case VALA_TOKEN_TYPE_CONST:
            {
                  gchar* _tmp31_ = NULL;
                  gchar* _tmp32_;
                  GError* _tmp33_ = NULL;
                  GError* _tmp34_;
                  _tmp31_ = vala_parser_get_error (self, "embedded statement cannot be declaration ");
                  _tmp32_ = _tmp31_;
                  _tmp33_ = g_error_new_literal (VALA_PARSE_ERROR, VALA_PARSE_ERROR_SYNTAX, _tmp32_);
                  _tmp34_ = _tmp33_;
                  _g_free0 (_tmp32_);
                  _inner_error_ = _tmp34_;
                  if (_inner_error_->domain == VALA_PARSE_ERROR) {
                        g_propagate_error (error, _inner_error_);
                        return NULL;
                  } else {
                        g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                        g_clear_error (&_inner_error_);
                        return NULL;
                  }
            }
            case VALA_TOKEN_TYPE_OP_INC:
            case VALA_TOKEN_TYPE_OP_DEC:
            case VALA_TOKEN_TYPE_BASE:
            case VALA_TOKEN_TYPE_THIS:
            case VALA_TOKEN_TYPE_OPEN_PARENS:
            case VALA_TOKEN_TYPE_STAR:
            case VALA_TOKEN_TYPE_NEW:
            {
                  ValaStatement* _tmp35_ = NULL;
                  ValaStatement* _tmp36_;
                  _tmp35_ = vala_parser_parse_expression_statement (self, &_inner_error_);
                  _tmp36_ = _tmp35_;
                  if (_inner_error_ != NULL) {
                        if (_inner_error_->domain == VALA_PARSE_ERROR) {
                              g_propagate_error (error, _inner_error_);
                              return NULL;
                        } else {
                              g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                              g_clear_error (&_inner_error_);
                              return NULL;
                        }
                  }
                  result = _tmp36_;
                  return result;
            }
            default:
            {
                  gboolean _tmp37_;
                  gboolean _tmp38_;
                  _tmp37_ = vala_parser_is_expression (self, &_inner_error_);
                  _tmp38_ = _tmp37_;
                  if (_inner_error_ != NULL) {
                        if (_inner_error_->domain == VALA_PARSE_ERROR) {
                              g_propagate_error (error, _inner_error_);
                              return NULL;
                        } else {
                              g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                              g_clear_error (&_inner_error_);
                              return NULL;
                        }
                  }
                  if (_tmp38_) {
                        ValaStatement* _tmp39_ = NULL;
                        ValaStatement* _tmp40_;
                        _tmp39_ = vala_parser_parse_expression_statement (self, &_inner_error_);
                        _tmp40_ = _tmp39_;
                        if (_inner_error_ != NULL) {
                              if (_inner_error_->domain == VALA_PARSE_ERROR) {
                                    g_propagate_error (error, _inner_error_);
                                    return NULL;
                              } else {
                                    g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                                    g_clear_error (&_inner_error_);
                                    return NULL;
                              }
                        }
                        result = _tmp40_;
                        return result;
                  } else {
                        gchar* _tmp41_ = NULL;
                        gchar* _tmp42_;
                        GError* _tmp43_ = NULL;
                        GError* _tmp44_;
                        _tmp41_ = vala_parser_get_error (self, "embedded statement cannot be declaration");
                        _tmp42_ = _tmp41_;
                        _tmp43_ = g_error_new_literal (VALA_PARSE_ERROR, VALA_PARSE_ERROR_SYNTAX, _tmp42_);
                        _tmp44_ = _tmp43_;
                        _g_free0 (_tmp42_);
                        _inner_error_ = _tmp44_;
                        if (_inner_error_->domain == VALA_PARSE_ERROR) {
                              g_propagate_error (error, _inner_error_);
                              return NULL;
                        } else {
                              g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                              g_clear_error (&_inner_error_);
                              return NULL;
                        }
                  }
            }
      }
}


static ValaBlock* vala_parser_parse_block (ValaParser* self, GError** error) {
      ValaBlock* result = NULL;
      ValaSourceLocation _tmp0_ = {0};
      ValaSourceLocation _tmp1_ = {0};
      ValaSourceLocation begin;
      ValaSourceReference* _tmp2_ = NULL;
      ValaSourceReference* _tmp3_;
      ValaBlock* _tmp4_ = NULL;
      ValaBlock* _tmp5_;
      ValaBlock* block;
      gboolean _tmp6_;
      ValaSourceReference* _tmp11_ = NULL;
      ValaSourceReference* _tmp12_ = NULL;
      ValaSourceReference* _tmp13_;
      gint _tmp14_;
      ValaSourceReference* _tmp15_ = NULL;
      ValaSourceReference* _tmp16_ = NULL;
      ValaSourceReference* _tmp17_;
      gint _tmp18_;
      GError * _inner_error_ = NULL;
      g_return_val_if_fail (self != NULL, NULL);
      vala_parser_get_location (self, &_tmp0_);
      _tmp1_ = _tmp0_;
      begin = _tmp1_;
      vala_parser_expect (self, VALA_TOKEN_TYPE_OPEN_BRACE, &_inner_error_);
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  return NULL;
            } else {
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      _tmp2_ = vala_parser_get_src (self, &begin);
      _tmp3_ = _tmp2_;
      _tmp4_ = vala_block_new (_tmp3_);
      _tmp5_ = _tmp4_;
      _vala_source_reference_unref0 (_tmp3_);
      block = _tmp5_;
      vala_parser_parse_statements (self, block, &_inner_error_);
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  _vala_code_node_unref0 (block);
                  return NULL;
            } else {
                  _vala_code_node_unref0 (block);
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      _tmp6_ = vala_parser_accept (self, VALA_TOKEN_TYPE_CLOSE_BRACE);
      if (!_tmp6_) {
            ValaReport* _tmp7_ = NULL;
            gint _tmp8_;
            _tmp7_ = vala_code_context_get_report (self->priv->context);
            _tmp8_ = vala_report_get_errors (_tmp7_);
            if (_tmp8_ == 0) {
                  ValaSourceReference* _tmp9_ = NULL;
                  ValaSourceReference* _tmp10_;
                  _tmp9_ = vala_parser_get_current_src (self);
                  _tmp10_ = _tmp9_;
                  vala_report_error (_tmp10_, "expected `}'");
                  _vala_source_reference_unref0 (_tmp10_);
            }
      }
      _tmp11_ = vala_code_node_get_source_reference ((ValaCodeNode*) block);
      _tmp12_ = vala_parser_get_current_src (self);
      _tmp13_ = _tmp12_;
      _tmp14_ = vala_source_reference_get_last_line (_tmp13_);
      vala_source_reference_set_last_line (_tmp11_, _tmp14_);
      _vala_source_reference_unref0 (_tmp13_);
      _tmp15_ = vala_code_node_get_source_reference ((ValaCodeNode*) block);
      _tmp16_ = vala_parser_get_current_src (self);
      _tmp17_ = _tmp16_;
      _tmp18_ = vala_source_reference_get_last_column (_tmp17_);
      vala_source_reference_set_last_column (_tmp15_, _tmp18_);
      _vala_source_reference_unref0 (_tmp17_);
      result = block;
      return result;
}


static ValaStatement* vala_parser_parse_empty_statement (ValaParser* self, GError** error) {
      ValaStatement* result = NULL;
      ValaSourceLocation _tmp0_ = {0};
      ValaSourceLocation _tmp1_ = {0};
      ValaSourceLocation begin;
      ValaSourceReference* _tmp2_ = NULL;
      ValaSourceReference* _tmp3_;
      ValaEmptyStatement* _tmp4_ = NULL;
      ValaStatement* _tmp5_;
      GError * _inner_error_ = NULL;
      g_return_val_if_fail (self != NULL, NULL);
      vala_parser_get_location (self, &_tmp0_);
      _tmp1_ = _tmp0_;
      begin = _tmp1_;
      vala_parser_expect (self, VALA_TOKEN_TYPE_SEMICOLON, &_inner_error_);
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  return NULL;
            } else {
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      _tmp2_ = vala_parser_get_src (self, &begin);
      _tmp3_ = _tmp2_;
      _tmp4_ = vala_empty_statement_new (_tmp3_);
      _tmp5_ = (ValaStatement*) _tmp4_;
      _vala_source_reference_unref0 (_tmp3_);
      result = _tmp5_;
      return result;
}


static void _vala_array_add12 (gchar*** array, int* length, int* size, gchar* value) {
      if ((*length) == (*size)) {
            *size = (*size) ? (2 * (*size)) : 4;
            *array = g_renew (gchar*, *array, (*size) + 1);
      }
      (*array)[(*length)++] = value;
      (*array)[*length] = NULL;
}


static void vala_parser_parse_local_variable_declarations (ValaParser* self, ValaBlock* block, GError** error) {
      ValaDataType* variable_type = NULL;
      gboolean _tmp0_;
      GError * _inner_error_ = NULL;
      g_return_if_fail (self != NULL);
      g_return_if_fail (block != NULL);
      _tmp0_ = vala_parser_accept (self, VALA_TOKEN_TYPE_VAR);
      if (_tmp0_) {
            _vala_code_node_unref0 (variable_type);
            variable_type = NULL;
      } else {
            ValaDataType* _tmp1_ = NULL;
            ValaDataType* _tmp2_;
            _tmp1_ = vala_parser_parse_type (self, TRUE, TRUE, &_inner_error_);
            _tmp2_ = _tmp1_;
            if (_inner_error_ != NULL) {
                  if (_inner_error_->domain == VALA_PARSE_ERROR) {
                        g_propagate_error (error, _inner_error_);
                        _vala_code_node_unref0 (variable_type);
                        return;
                  } else {
                        _vala_code_node_unref0 (variable_type);
                        g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                        g_clear_error (&_inner_error_);
                        return;
                  }
            }
            _vala_code_node_unref0 (variable_type);
            variable_type = _tmp2_;
      }
      {
            gboolean _tmp3_;
            _tmp3_ = TRUE;
            while (TRUE) {
                  gboolean _tmp5_ = FALSE;
                  ValaDataType* type_copy;
                  ValaLocalVariable* _tmp40_ = NULL;
                  ValaLocalVariable* local;
                  ValaSourceReference* _tmp41_ = NULL;
                  ValaDeclarationStatement* _tmp42_ = NULL;
                  ValaDeclarationStatement* _tmp43_;
                  if (!_tmp3_) {
                        gboolean _tmp4_;
                        _tmp4_ = vala_parser_accept (self, VALA_TOKEN_TYPE_COMMA);
                        if (!_tmp4_) {
                              break;
                        }
                  }
                  _tmp3_ = FALSE;
                  if (variable_type == NULL) {
                        gboolean _tmp6_;
                        _tmp6_ = vala_parser_accept (self, VALA_TOKEN_TYPE_OPEN_PARENS);
                        _tmp5_ = _tmp6_;
                  } else {
                        _tmp5_ = FALSE;
                  }
                  if (_tmp5_) {
                        ValaSourceLocation _tmp7_ = {0};
                        ValaSourceLocation _tmp8_ = {0};
                        ValaSourceLocation begin;
                        gchar** _tmp9_ = NULL;
                        gchar** identifiers;
                        gint identifiers_length1;
                        gint _identifiers_size_;
                        ValaExpression* _tmp14_ = NULL;
                        ValaExpression* tuple;
                        gchar* _tmp15_ = NULL;
                        gchar* _tmp16_;
                        ValaSourceReference* _tmp17_ = NULL;
                        ValaSourceReference* _tmp18_;
                        ValaLocalVariable* _tmp19_ = NULL;
                        ValaLocalVariable* _tmp20_;
                        ValaLocalVariable* tuple_local;
                        ValaSourceReference* _tmp21_ = NULL;
                        ValaDeclarationStatement* _tmp22_ = NULL;
                        ValaDeclarationStatement* _tmp23_;
                        vala_parser_get_location (self, &_tmp7_);
                        _tmp8_ = _tmp7_;
                        begin = _tmp8_;
                        _tmp9_ = g_new0 (gchar*, 0 + 1);
                        identifiers = _tmp9_;
                        identifiers_length1 = 0;
                        _identifiers_size_ = identifiers_length1;
                        {
                              gboolean _tmp10_;
                              _tmp10_ = TRUE;
                              while (TRUE) {
                                    gchar* _tmp12_ = NULL;
                                    gchar* _tmp13_;
                                    if (!_tmp10_) {
                                          gboolean _tmp11_;
                                          _tmp11_ = vala_parser_accept (self, VALA_TOKEN_TYPE_COMMA);
                                          if (!_tmp11_) {
                                                break;
                                          }
                                    }
                                    _tmp10_ = FALSE;
                                    _tmp12_ = vala_parser_parse_identifier (self, &_inner_error_);
                                    _tmp13_ = _tmp12_;
                                    if (_inner_error_ != NULL) {
                                          if (_inner_error_->domain == VALA_PARSE_ERROR) {
                                                g_propagate_error (error, _inner_error_);
                                                identifiers = (_vala_array_free (identifiers, identifiers_length1, (GDestroyNotify) g_free), NULL);
                                                _vala_code_node_unref0 (variable_type);
                                                return;
                                          } else {
                                                identifiers = (_vala_array_free (identifiers, identifiers_length1, (GDestroyNotify) g_free), NULL);
                                                _vala_code_node_unref0 (variable_type);
                                                g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                                                g_clear_error (&_inner_error_);
                                                return;
                                          }
                                    }
                                    _vala_array_add12 (&identifiers, &identifiers_length1, &_identifiers_size_, _tmp13_);
                              }
                        }
                        vala_parser_expect (self, VALA_TOKEN_TYPE_CLOSE_PARENS, &_inner_error_);
                        if (_inner_error_ != NULL) {
                              if (_inner_error_->domain == VALA_PARSE_ERROR) {
                                    g_propagate_error (error, _inner_error_);
                                    identifiers = (_vala_array_free (identifiers, identifiers_length1, (GDestroyNotify) g_free), NULL);
                                    _vala_code_node_unref0 (variable_type);
                                    return;
                              } else {
                                    identifiers = (_vala_array_free (identifiers, identifiers_length1, (GDestroyNotify) g_free), NULL);
                                    _vala_code_node_unref0 (variable_type);
                                    g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                                    g_clear_error (&_inner_error_);
                                    return;
                              }
                        }
                        vala_parser_expect (self, VALA_TOKEN_TYPE_ASSIGN, &_inner_error_);
                        if (_inner_error_ != NULL) {
                              if (_inner_error_->domain == VALA_PARSE_ERROR) {
                                    g_propagate_error (error, _inner_error_);
                                    identifiers = (_vala_array_free (identifiers, identifiers_length1, (GDestroyNotify) g_free), NULL);
                                    _vala_code_node_unref0 (variable_type);
                                    return;
                              } else {
                                    identifiers = (_vala_array_free (identifiers, identifiers_length1, (GDestroyNotify) g_free), NULL);
                                    _vala_code_node_unref0 (variable_type);
                                    g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                                    g_clear_error (&_inner_error_);
                                    return;
                              }
                        }
                        _tmp14_ = vala_parser_parse_expression (self, &_inner_error_);
                        tuple = _tmp14_;
                        if (_inner_error_ != NULL) {
                              if (_inner_error_->domain == VALA_PARSE_ERROR) {
                                    g_propagate_error (error, _inner_error_);
                                    identifiers = (_vala_array_free (identifiers, identifiers_length1, (GDestroyNotify) g_free), NULL);
                                    _vala_code_node_unref0 (variable_type);
                                    return;
                              } else {
                                    identifiers = (_vala_array_free (identifiers, identifiers_length1, (GDestroyNotify) g_free), NULL);
                                    _vala_code_node_unref0 (variable_type);
                                    g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                                    g_clear_error (&_inner_error_);
                                    return;
                              }
                        }
                        _tmp15_ = vala_code_node_get_temp_name ();
                        _tmp16_ = _tmp15_;
                        _tmp17_ = vala_parser_get_src (self, &begin);
                        _tmp18_ = _tmp17_;
                        _tmp19_ = vala_local_variable_new (NULL, _tmp16_, tuple, _tmp18_);
                        _tmp20_ = _tmp19_;
                        _vala_source_reference_unref0 (_tmp18_);
                        _g_free0 (_tmp16_);
                        tuple_local = _tmp20_;
                        _tmp21_ = vala_code_node_get_source_reference ((ValaCodeNode*) tuple_local);
                        _tmp22_ = vala_declaration_statement_new ((ValaSymbol*) tuple_local, _tmp21_);
                        _tmp23_ = _tmp22_;
                        vala_block_add_statement (block, (ValaStatement*) _tmp23_);
                        _vala_code_node_unref0 (_tmp23_);
                        {
                              gint i;
                              i = 0;
                              {
                                    gboolean _tmp24_;
                                    _tmp24_ = TRUE;
                                    while (TRUE) {
                                          const gchar* _tmp25_ = NULL;
                                          ValaSourceReference* _tmp26_ = NULL;
                                          ValaMemberAccess* _tmp27_ = NULL;
                                          ValaMemberAccess* temp_access;
                                          ValaSourceReference* _tmp28_ = NULL;
                                          ValaElementAccess* _tmp29_ = NULL;
                                          ValaElementAccess* ea;
                                          gchar* _tmp30_ = NULL;
                                          gchar* _tmp31_;
                                          ValaIntegerLiteral* _tmp32_ = NULL;
                                          ValaIntegerLiteral* _tmp33_;
                                          ValaSourceReference* _tmp34_ = NULL;
                                          ValaLocalVariable* _tmp35_ = NULL;
                                          ValaLocalVariable* local;
                                          ValaSourceReference* _tmp36_ = NULL;
                                          ValaDeclarationStatement* _tmp37_ = NULL;
                                          ValaDeclarationStatement* _tmp38_;
                                          if (!_tmp24_) {
                                                i++;
                                          }
                                          _tmp24_ = FALSE;
                                          if (!(i < identifiers_length1)) {
                                                break;
                                          }
                                          _tmp25_ = vala_symbol_get_name ((ValaSymbol*) tuple_local);
                                          _tmp26_ = vala_code_node_get_source_reference ((ValaCodeNode*) tuple_local);
                                          _tmp27_ = vala_member_access_new_simple (_tmp25_, _tmp26_);
                                          temp_access = _tmp27_;
                                          _tmp28_ = vala_code_node_get_source_reference ((ValaCodeNode*) tuple_local);
                                          _tmp29_ = vala_element_access_new ((ValaExpression*) temp_access, _tmp28_);
                                          ea = _tmp29_;
                                          _tmp30_ = g_strdup_printf ("%i", i);
                                          _tmp31_ = _tmp30_;
                                          _tmp32_ = vala_integer_literal_new (_tmp31_, NULL);
                                          _tmp33_ = _tmp32_;
                                          vala_element_access_append_index (ea, (ValaExpression*) _tmp33_);
                                          _vala_code_node_unref0 (_tmp33_);
                                          _g_free0 (_tmp31_);
                                          _tmp34_ = vala_code_node_get_source_reference ((ValaCodeNode*) tuple_local);
                                          _tmp35_ = vala_local_variable_new (NULL, identifiers[i], (ValaExpression*) ea, _tmp34_);
                                          local = _tmp35_;
                                          _tmp36_ = vala_code_node_get_source_reference ((ValaCodeNode*) local);
                                          _tmp37_ = vala_declaration_statement_new ((ValaSymbol*) local, _tmp36_);
                                          _tmp38_ = _tmp37_;
                                          vala_block_add_statement (block, (ValaStatement*) _tmp38_);
                                          _vala_code_node_unref0 (_tmp38_);
                                          _vala_code_node_unref0 (local);
                                          _vala_code_node_unref0 (ea);
                                          _vala_code_node_unref0 (temp_access);
                                    }
                              }
                        }
                        _vala_code_node_unref0 (tuple_local);
                        _vala_code_node_unref0 (tuple);
                        identifiers = (_vala_array_free (identifiers, identifiers_length1, (GDestroyNotify) g_free), NULL);
                        continue;
                  }
                  type_copy = NULL;
                  if (variable_type != NULL) {
                        ValaDataType* _tmp39_ = NULL;
                        _tmp39_ = vala_data_type_copy (variable_type);
                        _vala_code_node_unref0 (type_copy);
                        type_copy = _tmp39_;
                  }
                  _tmp40_ = vala_parser_parse_local_variable (self, type_copy, &_inner_error_);
                  local = _tmp40_;
                  if (_inner_error_ != NULL) {
                        if (_inner_error_->domain == VALA_PARSE_ERROR) {
                              g_propagate_error (error, _inner_error_);
                              _vala_code_node_unref0 (type_copy);
                              _vala_code_node_unref0 (variable_type);
                              return;
                        } else {
                              _vala_code_node_unref0 (type_copy);
                              _vala_code_node_unref0 (variable_type);
                              g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                              g_clear_error (&_inner_error_);
                              return;
                        }
                  }
                  _tmp41_ = vala_code_node_get_source_reference ((ValaCodeNode*) local);
                  _tmp42_ = vala_declaration_statement_new ((ValaSymbol*) local, _tmp41_);
                  _tmp43_ = _tmp42_;
                  vala_block_add_statement (block, (ValaStatement*) _tmp43_);
                  _vala_code_node_unref0 (_tmp43_);
                  _vala_code_node_unref0 (local);
                  _vala_code_node_unref0 (type_copy);
            }
      }
      vala_parser_expect (self, VALA_TOKEN_TYPE_SEMICOLON, &_inner_error_);
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  _vala_code_node_unref0 (variable_type);
                  return;
            } else {
                  _vala_code_node_unref0 (variable_type);
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return;
            }
      }
      _vala_code_node_unref0 (variable_type);
}


static ValaLocalVariable* vala_parser_parse_local_variable (ValaParser* self, ValaDataType* variable_type, GError** error) {
      ValaLocalVariable* result = NULL;
      ValaSourceLocation _tmp0_ = {0};
      ValaSourceLocation _tmp1_ = {0};
      ValaSourceLocation begin;
      gchar* _tmp2_ = NULL;
      gchar* id;
      ValaDataType* _tmp3_ = NULL;
      ValaDataType* type;
      ValaExpression* initializer;
      gboolean _tmp4_;
      ValaSourceReference* _tmp7_ = NULL;
      ValaSourceReference* _tmp8_;
      ValaLocalVariable* _tmp9_ = NULL;
      ValaLocalVariable* _tmp10_;
      GError * _inner_error_ = NULL;
      g_return_val_if_fail (self != NULL, NULL);
      vala_parser_get_location (self, &_tmp0_);
      _tmp1_ = _tmp0_;
      begin = _tmp1_;
      _tmp2_ = vala_parser_parse_identifier (self, &_inner_error_);
      id = _tmp2_;
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  return NULL;
            } else {
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      _tmp3_ = vala_parser_parse_inline_array_type (self, variable_type, &_inner_error_);
      type = _tmp3_;
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  _g_free0 (id);
                  return NULL;
            } else {
                  _g_free0 (id);
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      initializer = NULL;
      _tmp4_ = vala_parser_accept (self, VALA_TOKEN_TYPE_ASSIGN);
      if (_tmp4_) {
            ValaExpression* _tmp5_ = NULL;
            ValaExpression* _tmp6_;
            _tmp5_ = vala_parser_parse_expression (self, &_inner_error_);
            _tmp6_ = _tmp5_;
            if (_inner_error_ != NULL) {
                  if (_inner_error_->domain == VALA_PARSE_ERROR) {
                        g_propagate_error (error, _inner_error_);
                        _vala_code_node_unref0 (initializer);
                        _vala_code_node_unref0 (type);
                        _g_free0 (id);
                        return NULL;
                  } else {
                        _vala_code_node_unref0 (initializer);
                        _vala_code_node_unref0 (type);
                        _g_free0 (id);
                        g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                        g_clear_error (&_inner_error_);
                        return NULL;
                  }
            }
            _vala_code_node_unref0 (initializer);
            initializer = _tmp6_;
      }
      _tmp7_ = vala_parser_get_src (self, &begin);
      _tmp8_ = _tmp7_;
      _tmp9_ = vala_local_variable_new (type, id, initializer, _tmp8_);
      _tmp10_ = _tmp9_;
      _vala_source_reference_unref0 (_tmp8_);
      result = _tmp10_;
      _vala_code_node_unref0 (initializer);
      _vala_code_node_unref0 (type);
      _g_free0 (id);
      return result;
}


static void vala_parser_parse_local_constant_declarations (ValaParser* self, ValaBlock* block, GError** error) {
      ValaDataType* _tmp0_ = NULL;
      ValaDataType* constant_type;
      GError * _inner_error_ = NULL;
      g_return_if_fail (self != NULL);
      g_return_if_fail (block != NULL);
      vala_parser_expect (self, VALA_TOKEN_TYPE_CONST, &_inner_error_);
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  return;
            } else {
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return;
            }
      }
      _tmp0_ = vala_parser_parse_type (self, FALSE, FALSE, &_inner_error_);
      constant_type = _tmp0_;
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  return;
            } else {
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return;
            }
      }
      {
            gboolean _tmp1_;
            _tmp1_ = TRUE;
            while (TRUE) {
                  ValaDataType* _tmp3_ = NULL;
                  ValaDataType* type_copy;
                  ValaConstant* _tmp4_ = NULL;
                  ValaConstant* local;
                  ValaSourceReference* _tmp5_ = NULL;
                  ValaDeclarationStatement* _tmp6_ = NULL;
                  ValaDeclarationStatement* _tmp7_;
                  if (!_tmp1_) {
                        gboolean _tmp2_;
                        _tmp2_ = vala_parser_accept (self, VALA_TOKEN_TYPE_COMMA);
                        if (!_tmp2_) {
                              break;
                        }
                  }
                  _tmp1_ = FALSE;
                  _tmp3_ = vala_data_type_copy (constant_type);
                  type_copy = _tmp3_;
                  _tmp4_ = vala_parser_parse_local_constant (self, type_copy, &_inner_error_);
                  local = _tmp4_;
                  if (_inner_error_ != NULL) {
                        if (_inner_error_->domain == VALA_PARSE_ERROR) {
                              g_propagate_error (error, _inner_error_);
                              _vala_code_node_unref0 (type_copy);
                              _vala_code_node_unref0 (constant_type);
                              return;
                        } else {
                              _vala_code_node_unref0 (type_copy);
                              _vala_code_node_unref0 (constant_type);
                              g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                              g_clear_error (&_inner_error_);
                              return;
                        }
                  }
                  _tmp5_ = vala_code_node_get_source_reference ((ValaCodeNode*) local);
                  _tmp6_ = vala_declaration_statement_new ((ValaSymbol*) local, _tmp5_);
                  _tmp7_ = _tmp6_;
                  vala_block_add_statement (block, (ValaStatement*) _tmp7_);
                  _vala_code_node_unref0 (_tmp7_);
                  vala_block_add_local_constant (block, local);
                  vala_symbol_set_active ((ValaSymbol*) local, FALSE);
                  _vala_code_node_unref0 (local);
                  _vala_code_node_unref0 (type_copy);
            }
      }
      vala_parser_expect (self, VALA_TOKEN_TYPE_SEMICOLON, &_inner_error_);
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  _vala_code_node_unref0 (constant_type);
                  return;
            } else {
                  _vala_code_node_unref0 (constant_type);
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return;
            }
      }
      _vala_code_node_unref0 (constant_type);
}


static ValaConstant* vala_parser_parse_local_constant (ValaParser* self, ValaDataType* constant_type, GError** error) {
      ValaConstant* result = NULL;
      ValaSourceLocation _tmp0_ = {0};
      ValaSourceLocation _tmp1_ = {0};
      ValaSourceLocation begin;
      gchar* _tmp2_ = NULL;
      gchar* id;
      ValaDataType* _tmp3_ = NULL;
      ValaDataType* type;
      ValaExpression* _tmp4_ = NULL;
      ValaExpression* initializer;
      ValaSourceReference* _tmp5_ = NULL;
      ValaSourceReference* _tmp6_;
      ValaConstant* _tmp7_ = NULL;
      ValaConstant* _tmp8_;
      GError * _inner_error_ = NULL;
      g_return_val_if_fail (self != NULL, NULL);
      g_return_val_if_fail (constant_type != NULL, NULL);
      vala_parser_get_location (self, &_tmp0_);
      _tmp1_ = _tmp0_;
      begin = _tmp1_;
      _tmp2_ = vala_parser_parse_identifier (self, &_inner_error_);
      id = _tmp2_;
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  return NULL;
            } else {
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      _tmp3_ = vala_parser_parse_inline_array_type (self, constant_type, &_inner_error_);
      type = _tmp3_;
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  _g_free0 (id);
                  return NULL;
            } else {
                  _g_free0 (id);
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      vala_parser_expect (self, VALA_TOKEN_TYPE_ASSIGN, &_inner_error_);
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  _vala_code_node_unref0 (type);
                  _g_free0 (id);
                  return NULL;
            } else {
                  _vala_code_node_unref0 (type);
                  _g_free0 (id);
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      _tmp4_ = vala_parser_parse_expression (self, &_inner_error_);
      initializer = _tmp4_;
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  _vala_code_node_unref0 (type);
                  _g_free0 (id);
                  return NULL;
            } else {
                  _vala_code_node_unref0 (type);
                  _g_free0 (id);
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      _tmp5_ = vala_parser_get_src (self, &begin);
      _tmp6_ = _tmp5_;
      _tmp7_ = vala_constant_new (id, type, initializer, _tmp6_, NULL);
      _tmp8_ = _tmp7_;
      _vala_source_reference_unref0 (_tmp6_);
      result = _tmp8_;
      _vala_code_node_unref0 (initializer);
      _vala_code_node_unref0 (type);
      _g_free0 (id);
      return result;
}


static ValaStatement* vala_parser_parse_expression_statement (ValaParser* self, GError** error) {
      ValaStatement* result = NULL;
      ValaSourceLocation _tmp0_ = {0};
      ValaSourceLocation _tmp1_ = {0};
      ValaSourceLocation begin;
      ValaExpression* _tmp2_ = NULL;
      ValaExpression* expr;
      ValaSourceReference* _tmp3_ = NULL;
      ValaSourceReference* _tmp4_;
      ValaExpressionStatement* _tmp5_ = NULL;
      ValaStatement* _tmp6_;
      GError * _inner_error_ = NULL;
      g_return_val_if_fail (self != NULL, NULL);
      vala_parser_get_location (self, &_tmp0_);
      _tmp1_ = _tmp0_;
      begin = _tmp1_;
      _tmp2_ = vala_parser_parse_statement_expression (self, &_inner_error_);
      expr = _tmp2_;
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  return NULL;
            } else {
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      vala_parser_expect (self, VALA_TOKEN_TYPE_SEMICOLON, &_inner_error_);
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  _vala_code_node_unref0 (expr);
                  return NULL;
            } else {
                  _vala_code_node_unref0 (expr);
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      _tmp3_ = vala_parser_get_src (self, &begin);
      _tmp4_ = _tmp3_;
      _tmp5_ = vala_expression_statement_new (expr, _tmp4_);
      _tmp6_ = (ValaStatement*) _tmp5_;
      _vala_source_reference_unref0 (_tmp4_);
      result = _tmp6_;
      _vala_code_node_unref0 (expr);
      return result;
}


static ValaExpression* vala_parser_parse_statement_expression (ValaParser* self, GError** error) {
      ValaExpression* result = NULL;
      ValaExpression* _tmp0_ = NULL;
      ValaExpression* expr;
      GError * _inner_error_ = NULL;
      g_return_val_if_fail (self != NULL, NULL);
      _tmp0_ = vala_parser_parse_expression (self, &_inner_error_);
      expr = _tmp0_;
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  return NULL;
            } else {
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      result = expr;
      return result;
}


static ValaStatement* vala_parser_parse_if_statement (ValaParser* self, GError** error) {
      ValaStatement* result = NULL;
      ValaSourceLocation _tmp0_ = {0};
      ValaSourceLocation _tmp1_ = {0};
      ValaSourceLocation begin;
      ValaExpression* _tmp2_ = NULL;
      ValaExpression* condition;
      ValaSourceReference* _tmp3_ = NULL;
      ValaSourceReference* src;
      ValaBlock* _tmp4_ = NULL;
      ValaBlock* true_stmt;
      ValaBlock* false_stmt;
      gboolean _tmp5_;
      ValaIfStatement* _tmp8_ = NULL;
      GError * _inner_error_ = NULL;
      g_return_val_if_fail (self != NULL, NULL);
      vala_parser_get_location (self, &_tmp0_);
      _tmp1_ = _tmp0_;
      begin = _tmp1_;
      vala_parser_expect (self, VALA_TOKEN_TYPE_IF, &_inner_error_);
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  return NULL;
            } else {
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      vala_parser_expect (self, VALA_TOKEN_TYPE_OPEN_PARENS, &_inner_error_);
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  return NULL;
            } else {
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      _tmp2_ = vala_parser_parse_expression (self, &_inner_error_);
      condition = _tmp2_;
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  return NULL;
            } else {
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      vala_parser_expect (self, VALA_TOKEN_TYPE_CLOSE_PARENS, &_inner_error_);
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  _vala_code_node_unref0 (condition);
                  return NULL;
            } else {
                  _vala_code_node_unref0 (condition);
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      _tmp3_ = vala_parser_get_src (self, &begin);
      src = _tmp3_;
      _tmp4_ = vala_parser_parse_embedded_statement (self, &_inner_error_);
      true_stmt = _tmp4_;
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  _vala_source_reference_unref0 (src);
                  _vala_code_node_unref0 (condition);
                  return NULL;
            } else {
                  _vala_source_reference_unref0 (src);
                  _vala_code_node_unref0 (condition);
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      false_stmt = NULL;
      _tmp5_ = vala_parser_accept (self, VALA_TOKEN_TYPE_ELSE);
      if (_tmp5_) {
            ValaBlock* _tmp6_ = NULL;
            ValaBlock* _tmp7_;
            _tmp6_ = vala_parser_parse_embedded_statement (self, &_inner_error_);
            _tmp7_ = _tmp6_;
            if (_inner_error_ != NULL) {
                  if (_inner_error_->domain == VALA_PARSE_ERROR) {
                        g_propagate_error (error, _inner_error_);
                        _vala_code_node_unref0 (false_stmt);
                        _vala_code_node_unref0 (true_stmt);
                        _vala_source_reference_unref0 (src);
                        _vala_code_node_unref0 (condition);
                        return NULL;
                  } else {
                        _vala_code_node_unref0 (false_stmt);
                        _vala_code_node_unref0 (true_stmt);
                        _vala_source_reference_unref0 (src);
                        _vala_code_node_unref0 (condition);
                        g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                        g_clear_error (&_inner_error_);
                        return NULL;
                  }
            }
            _vala_code_node_unref0 (false_stmt);
            false_stmt = _tmp7_;
      }
      _tmp8_ = vala_if_statement_new (condition, true_stmt, false_stmt, src);
      result = (ValaStatement*) _tmp8_;
      _vala_code_node_unref0 (false_stmt);
      _vala_code_node_unref0 (true_stmt);
      _vala_source_reference_unref0 (src);
      _vala_code_node_unref0 (condition);
      return result;
}


static ValaStatement* vala_parser_parse_switch_statement (ValaParser* self, GError** error) {
      ValaStatement* result = NULL;
      ValaSourceLocation _tmp0_ = {0};
      ValaSourceLocation _tmp1_ = {0};
      ValaSourceLocation begin;
      ValaExpression* _tmp2_ = NULL;
      ValaExpression* condition;
      ValaSourceReference* _tmp3_ = NULL;
      ValaSourceReference* _tmp4_;
      ValaSwitchStatement* _tmp5_ = NULL;
      ValaSwitchStatement* _tmp6_;
      ValaSwitchStatement* stmt;
      GError * _inner_error_ = NULL;
      g_return_val_if_fail (self != NULL, NULL);
      vala_parser_get_location (self, &_tmp0_);
      _tmp1_ = _tmp0_;
      begin = _tmp1_;
      vala_parser_expect (self, VALA_TOKEN_TYPE_SWITCH, &_inner_error_);
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  return NULL;
            } else {
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      vala_parser_expect (self, VALA_TOKEN_TYPE_OPEN_PARENS, &_inner_error_);
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  return NULL;
            } else {
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      _tmp2_ = vala_parser_parse_expression (self, &_inner_error_);
      condition = _tmp2_;
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  return NULL;
            } else {
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      vala_parser_expect (self, VALA_TOKEN_TYPE_CLOSE_PARENS, &_inner_error_);
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  _vala_code_node_unref0 (condition);
                  return NULL;
            } else {
                  _vala_code_node_unref0 (condition);
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      _tmp3_ = vala_parser_get_src (self, &begin);
      _tmp4_ = _tmp3_;
      _tmp5_ = vala_switch_statement_new (condition, _tmp4_);
      _tmp6_ = _tmp5_;
      _vala_source_reference_unref0 (_tmp4_);
      stmt = _tmp6_;
      vala_parser_expect (self, VALA_TOKEN_TYPE_OPEN_BRACE, &_inner_error_);
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  _vala_code_node_unref0 (stmt);
                  _vala_code_node_unref0 (condition);
                  return NULL;
            } else {
                  _vala_code_node_unref0 (stmt);
                  _vala_code_node_unref0 (condition);
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      while (TRUE) {
            ValaTokenType _tmp7_;
            ValaSourceReference* _tmp8_ = NULL;
            ValaSourceReference* _tmp9_;
            ValaSwitchSection* _tmp10_ = NULL;
            ValaSwitchSection* _tmp11_;
            ValaSwitchSection* section;
            _tmp7_ = vala_parser_current (self);
            if (!(_tmp7_ != VALA_TOKEN_TYPE_CLOSE_BRACE)) {
                  break;
            }
            _tmp8_ = vala_parser_get_src (self, &begin);
            _tmp9_ = _tmp8_;
            _tmp10_ = vala_switch_section_new (_tmp9_);
            _tmp11_ = _tmp10_;
            _vala_source_reference_unref0 (_tmp9_);
            section = _tmp11_;
            {
                  gboolean _tmp12_;
                  _tmp12_ = TRUE;
                  while (TRUE) {
                        gboolean _tmp16_;
                        if (!_tmp12_) {
                              gboolean _tmp13_ = FALSE;
                              ValaTokenType _tmp14_;
                              _tmp14_ = vala_parser_current (self);
                              if (_tmp14_ == VALA_TOKEN_TYPE_CASE) {
                                    _tmp13_ = TRUE;
                              } else {
                                    ValaTokenType _tmp15_;
                                    _tmp15_ = vala_parser_current (self);
                                    _tmp13_ = _tmp15_ == VALA_TOKEN_TYPE_DEFAULT;
                              }
                              if (!_tmp13_) {
                                    break;
                              }
                        }
                        _tmp12_ = FALSE;
                        _tmp16_ = vala_parser_accept (self, VALA_TOKEN_TYPE_CASE);
                        if (_tmp16_) {
                              ValaExpression* _tmp17_ = NULL;
                              ValaExpression* _tmp18_;
                              ValaExpression* _tmp19_;
                              ValaSourceReference* _tmp20_ = NULL;
                              ValaSourceReference* _tmp21_;
                              ValaSwitchLabel* _tmp22_ = NULL;
                              ValaSwitchLabel* _tmp23_;
                              _tmp17_ = vala_parser_parse_expression (self, &_inner_error_);
                              _tmp18_ = _tmp17_;
                              if (_inner_error_ != NULL) {
                                    if (_inner_error_->domain == VALA_PARSE_ERROR) {
                                          g_propagate_error (error, _inner_error_);
                                          _vala_code_node_unref0 (section);
                                          _vala_code_node_unref0 (stmt);
                                          _vala_code_node_unref0 (condition);
                                          return NULL;
                                    } else {
                                          _vala_code_node_unref0 (section);
                                          _vala_code_node_unref0 (stmt);
                                          _vala_code_node_unref0 (condition);
                                          g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                                          g_clear_error (&_inner_error_);
                                          return NULL;
                                    }
                              }
                              _tmp19_ = _tmp18_;
                              _tmp20_ = vala_parser_get_src (self, &begin);
                              _tmp21_ = _tmp20_;
                              _tmp22_ = vala_switch_label_new (_tmp19_, _tmp21_);
                              _tmp23_ = _tmp22_;
                              vala_switch_section_add_label (section, _tmp23_);
                              _vala_code_node_unref0 (_tmp23_);
                              _vala_source_reference_unref0 (_tmp21_);
                              _vala_code_node_unref0 (_tmp19_);
                        } else {
                              ValaSourceReference* _tmp24_ = NULL;
                              ValaSourceReference* _tmp25_;
                              ValaSwitchLabel* _tmp26_ = NULL;
                              ValaSwitchLabel* _tmp27_;
                              vala_parser_expect (self, VALA_TOKEN_TYPE_DEFAULT, &_inner_error_);
                              if (_inner_error_ != NULL) {
                                    if (_inner_error_->domain == VALA_PARSE_ERROR) {
                                          g_propagate_error (error, _inner_error_);
                                          _vala_code_node_unref0 (section);
                                          _vala_code_node_unref0 (stmt);
                                          _vala_code_node_unref0 (condition);
                                          return NULL;
                                    } else {
                                          _vala_code_node_unref0 (section);
                                          _vala_code_node_unref0 (stmt);
                                          _vala_code_node_unref0 (condition);
                                          g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                                          g_clear_error (&_inner_error_);
                                          return NULL;
                                    }
                              }
                              _tmp24_ = vala_parser_get_src (self, &begin);
                              _tmp25_ = _tmp24_;
                              _tmp26_ = vala_switch_label_new_with_default (_tmp25_);
                              _tmp27_ = _tmp26_;
                              vala_switch_section_add_label (section, _tmp27_);
                              _vala_code_node_unref0 (_tmp27_);
                              _vala_source_reference_unref0 (_tmp25_);
                        }
                        vala_parser_expect (self, VALA_TOKEN_TYPE_COLON, &_inner_error_);
                        if (_inner_error_ != NULL) {
                              if (_inner_error_->domain == VALA_PARSE_ERROR) {
                                    g_propagate_error (error, _inner_error_);
                                    _vala_code_node_unref0 (section);
                                    _vala_code_node_unref0 (stmt);
                                    _vala_code_node_unref0 (condition);
                                    return NULL;
                              } else {
                                    _vala_code_node_unref0 (section);
                                    _vala_code_node_unref0 (stmt);
                                    _vala_code_node_unref0 (condition);
                                    g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                                    g_clear_error (&_inner_error_);
                                    return NULL;
                              }
                        }
                  }
            }
            vala_parser_parse_statements (self, (ValaBlock*) section, &_inner_error_);
            if (_inner_error_ != NULL) {
                  if (_inner_error_->domain == VALA_PARSE_ERROR) {
                        g_propagate_error (error, _inner_error_);
                        _vala_code_node_unref0 (section);
                        _vala_code_node_unref0 (stmt);
                        _vala_code_node_unref0 (condition);
                        return NULL;
                  } else {
                        _vala_code_node_unref0 (section);
                        _vala_code_node_unref0 (stmt);
                        _vala_code_node_unref0 (condition);
                        g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                        g_clear_error (&_inner_error_);
                        return NULL;
                  }
            }
            vala_switch_statement_add_section (stmt, section);
            _vala_code_node_unref0 (section);
      }
      vala_parser_expect (self, VALA_TOKEN_TYPE_CLOSE_BRACE, &_inner_error_);
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  _vala_code_node_unref0 (stmt);
                  _vala_code_node_unref0 (condition);
                  return NULL;
            } else {
                  _vala_code_node_unref0 (stmt);
                  _vala_code_node_unref0 (condition);
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      result = (ValaStatement*) stmt;
      _vala_code_node_unref0 (condition);
      return result;
}


static ValaStatement* vala_parser_parse_while_statement (ValaParser* self, GError** error) {
      ValaStatement* result = NULL;
      ValaSourceLocation _tmp0_ = {0};
      ValaSourceLocation _tmp1_ = {0};
      ValaSourceLocation begin;
      ValaExpression* _tmp2_ = NULL;
      ValaExpression* condition;
      ValaBlock* _tmp3_ = NULL;
      ValaBlock* body;
      ValaSourceReference* _tmp4_ = NULL;
      ValaSourceReference* _tmp5_;
      ValaWhileStatement* _tmp6_ = NULL;
      ValaStatement* _tmp7_;
      GError * _inner_error_ = NULL;
      g_return_val_if_fail (self != NULL, NULL);
      vala_parser_get_location (self, &_tmp0_);
      _tmp1_ = _tmp0_;
      begin = _tmp1_;
      vala_parser_expect (self, VALA_TOKEN_TYPE_WHILE, &_inner_error_);
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  return NULL;
            } else {
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      vala_parser_expect (self, VALA_TOKEN_TYPE_OPEN_PARENS, &_inner_error_);
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  return NULL;
            } else {
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      _tmp2_ = vala_parser_parse_expression (self, &_inner_error_);
      condition = _tmp2_;
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  return NULL;
            } else {
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      vala_parser_expect (self, VALA_TOKEN_TYPE_CLOSE_PARENS, &_inner_error_);
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  _vala_code_node_unref0 (condition);
                  return NULL;
            } else {
                  _vala_code_node_unref0 (condition);
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      _tmp3_ = vala_parser_parse_embedded_statement (self, &_inner_error_);
      body = _tmp3_;
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  _vala_code_node_unref0 (condition);
                  return NULL;
            } else {
                  _vala_code_node_unref0 (condition);
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      _tmp4_ = vala_parser_get_src (self, &begin);
      _tmp5_ = _tmp4_;
      _tmp6_ = vala_while_statement_new (condition, body, _tmp5_);
      _tmp7_ = (ValaStatement*) _tmp6_;
      _vala_source_reference_unref0 (_tmp5_);
      result = _tmp7_;
      _vala_code_node_unref0 (body);
      _vala_code_node_unref0 (condition);
      return result;
}


static ValaStatement* vala_parser_parse_do_statement (ValaParser* self, GError** error) {
      ValaStatement* result = NULL;
      ValaSourceLocation _tmp0_ = {0};
      ValaSourceLocation _tmp1_ = {0};
      ValaSourceLocation begin;
      ValaBlock* _tmp2_ = NULL;
      ValaBlock* body;
      ValaExpression* _tmp3_ = NULL;
      ValaExpression* condition;
      ValaSourceReference* _tmp4_ = NULL;
      ValaSourceReference* _tmp5_;
      ValaDoStatement* _tmp6_ = NULL;
      ValaStatement* _tmp7_;
      GError * _inner_error_ = NULL;
      g_return_val_if_fail (self != NULL, NULL);
      vala_parser_get_location (self, &_tmp0_);
      _tmp1_ = _tmp0_;
      begin = _tmp1_;
      vala_parser_expect (self, VALA_TOKEN_TYPE_DO, &_inner_error_);
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  return NULL;
            } else {
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      _tmp2_ = vala_parser_parse_embedded_statement (self, &_inner_error_);
      body = _tmp2_;
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  return NULL;
            } else {
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      vala_parser_expect (self, VALA_TOKEN_TYPE_WHILE, &_inner_error_);
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  _vala_code_node_unref0 (body);
                  return NULL;
            } else {
                  _vala_code_node_unref0 (body);
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      vala_parser_expect (self, VALA_TOKEN_TYPE_OPEN_PARENS, &_inner_error_);
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  _vala_code_node_unref0 (body);
                  return NULL;
            } else {
                  _vala_code_node_unref0 (body);
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      _tmp3_ = vala_parser_parse_expression (self, &_inner_error_);
      condition = _tmp3_;
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  _vala_code_node_unref0 (body);
                  return NULL;
            } else {
                  _vala_code_node_unref0 (body);
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      vala_parser_expect (self, VALA_TOKEN_TYPE_CLOSE_PARENS, &_inner_error_);
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  _vala_code_node_unref0 (condition);
                  _vala_code_node_unref0 (body);
                  return NULL;
            } else {
                  _vala_code_node_unref0 (condition);
                  _vala_code_node_unref0 (body);
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      vala_parser_expect (self, VALA_TOKEN_TYPE_SEMICOLON, &_inner_error_);
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  _vala_code_node_unref0 (condition);
                  _vala_code_node_unref0 (body);
                  return NULL;
            } else {
                  _vala_code_node_unref0 (condition);
                  _vala_code_node_unref0 (body);
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      _tmp4_ = vala_parser_get_src (self, &begin);
      _tmp5_ = _tmp4_;
      _tmp6_ = vala_do_statement_new (body, condition, _tmp5_);
      _tmp7_ = (ValaStatement*) _tmp6_;
      _vala_source_reference_unref0 (_tmp5_);
      result = _tmp7_;
      _vala_code_node_unref0 (condition);
      _vala_code_node_unref0 (body);
      return result;
}


static ValaStatement* vala_parser_parse_for_statement (ValaParser* self, GError** error) {
      ValaStatement* result = NULL;
      ValaSourceLocation _tmp0_ = {0};
      ValaSourceLocation _tmp1_ = {0};
      ValaSourceLocation begin;
      ValaBlock* block;
      ValaArrayList* _tmp2_ = NULL;
      ValaArrayList* initializer_list;
      gboolean _tmp3_;
      ValaExpression* condition;
      ValaTokenType _tmp15_;
      ValaArrayList* _tmp18_ = NULL;
      ValaArrayList* iterator_list;
      ValaTokenType _tmp19_;
      ValaSourceReference* _tmp25_ = NULL;
      ValaSourceReference* src;
      ValaBlock* _tmp26_ = NULL;
      ValaBlock* body;
      ValaForStatement* _tmp27_ = NULL;
      ValaForStatement* stmt;
      GError * _inner_error_ = NULL;
      g_return_val_if_fail (self != NULL, NULL);
      vala_parser_get_location (self, &_tmp0_);
      _tmp1_ = _tmp0_;
      begin = _tmp1_;
      block = NULL;
      vala_parser_expect (self, VALA_TOKEN_TYPE_FOR, &_inner_error_);
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  _vala_code_node_unref0 (block);
                  return NULL;
            } else {
                  _vala_code_node_unref0 (block);
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      vala_parser_expect (self, VALA_TOKEN_TYPE_OPEN_PARENS, &_inner_error_);
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  _vala_code_node_unref0 (block);
                  return NULL;
            } else {
                  _vala_code_node_unref0 (block);
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      _tmp2_ = vala_array_list_new (VALA_TYPE_EXPRESSION, (GBoxedCopyFunc) vala_code_node_ref, vala_code_node_unref, g_direct_equal);
      initializer_list = _tmp2_;
      _tmp3_ = vala_parser_accept (self, VALA_TOKEN_TYPE_SEMICOLON);
      if (!_tmp3_) {
            gboolean is_expr = FALSE;
            ValaTokenType _tmp4_;
            _tmp4_ = vala_parser_current (self);
            switch (_tmp4_) {
                  case VALA_TOKEN_TYPE_VAR:
                  {
                        is_expr = FALSE;
                        break;
                  }
                  case VALA_TOKEN_TYPE_OP_INC:
                  case VALA_TOKEN_TYPE_OP_DEC:
                  {
                        is_expr = TRUE;
                        break;
                  }
                  default:
                  {
                        gboolean _tmp5_;
                        gboolean _tmp6_;
                        _tmp5_ = vala_parser_is_expression (self, &_inner_error_);
                        _tmp6_ = _tmp5_;
                        if (_inner_error_ != NULL) {
                              if (_inner_error_->domain == VALA_PARSE_ERROR) {
                                    g_propagate_error (error, _inner_error_);
                                    _vala_iterable_unref0 (initializer_list);
                                    _vala_code_node_unref0 (block);
                                    return NULL;
                              } else {
                                    _vala_iterable_unref0 (initializer_list);
                                    _vala_code_node_unref0 (block);
                                    g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                                    g_clear_error (&_inner_error_);
                                    return NULL;
                              }
                        }
                        is_expr = _tmp6_;
                        break;
                  }
            }
            if (is_expr) {
                  {
                        gboolean _tmp7_;
                        _tmp7_ = TRUE;
                        while (TRUE) {
                              ValaExpression* _tmp9_ = NULL;
                              ValaExpression* _tmp10_;
                              ValaExpression* _tmp11_;
                              if (!_tmp7_) {
                                    gboolean _tmp8_;
                                    _tmp8_ = vala_parser_accept (self, VALA_TOKEN_TYPE_COMMA);
                                    if (!_tmp8_) {
                                          break;
                                    }
                              }
                              _tmp7_ = FALSE;
                              _tmp9_ = vala_parser_parse_statement_expression (self, &_inner_error_);
                              _tmp10_ = _tmp9_;
                              if (_inner_error_ != NULL) {
                                    if (_inner_error_->domain == VALA_PARSE_ERROR) {
                                          g_propagate_error (error, _inner_error_);
                                          _vala_iterable_unref0 (initializer_list);
                                          _vala_code_node_unref0 (block);
                                          return NULL;
                                    } else {
                                          _vala_iterable_unref0 (initializer_list);
                                          _vala_code_node_unref0 (block);
                                          g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                                          g_clear_error (&_inner_error_);
                                          return NULL;
                                    }
                              }
                              _tmp11_ = _tmp10_;
                              vala_collection_add ((ValaCollection*) initializer_list, _tmp11_);
                              _vala_code_node_unref0 (_tmp11_);
                        }
                  }
                  vala_parser_expect (self, VALA_TOKEN_TYPE_SEMICOLON, &_inner_error_);
                  if (_inner_error_ != NULL) {
                        if (_inner_error_->domain == VALA_PARSE_ERROR) {
                              g_propagate_error (error, _inner_error_);
                              _vala_iterable_unref0 (initializer_list);
                              _vala_code_node_unref0 (block);
                              return NULL;
                        } else {
                              _vala_iterable_unref0 (initializer_list);
                              _vala_code_node_unref0 (block);
                              g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                              g_clear_error (&_inner_error_);
                              return NULL;
                        }
                  }
            } else {
                  ValaSourceReference* _tmp12_ = NULL;
                  ValaSourceReference* _tmp13_;
                  ValaBlock* _tmp14_ = NULL;
                  _tmp12_ = vala_parser_get_src (self, &begin);
                  _tmp13_ = _tmp12_;
                  _tmp14_ = vala_block_new (_tmp13_);
                  _vala_code_node_unref0 (block);
                  block = _tmp14_;
                  _vala_source_reference_unref0 (_tmp13_);
                  vala_parser_parse_local_variable_declarations (self, block, &_inner_error_);
                  if (_inner_error_ != NULL) {
                        if (_inner_error_->domain == VALA_PARSE_ERROR) {
                              g_propagate_error (error, _inner_error_);
                              _vala_iterable_unref0 (initializer_list);
                              _vala_code_node_unref0 (block);
                              return NULL;
                        } else {
                              _vala_iterable_unref0 (initializer_list);
                              _vala_code_node_unref0 (block);
                              g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                              g_clear_error (&_inner_error_);
                              return NULL;
                        }
                  }
            }
      }
      condition = NULL;
      _tmp15_ = vala_parser_current (self);
      if (_tmp15_ != VALA_TOKEN_TYPE_SEMICOLON) {
            ValaExpression* _tmp16_ = NULL;
            ValaExpression* _tmp17_;
            _tmp16_ = vala_parser_parse_expression (self, &_inner_error_);
            _tmp17_ = _tmp16_;
            if (_inner_error_ != NULL) {
                  if (_inner_error_->domain == VALA_PARSE_ERROR) {
                        g_propagate_error (error, _inner_error_);
                        _vala_code_node_unref0 (condition);
                        _vala_iterable_unref0 (initializer_list);
                        _vala_code_node_unref0 (block);
                        return NULL;
                  } else {
                        _vala_code_node_unref0 (condition);
                        _vala_iterable_unref0 (initializer_list);
                        _vala_code_node_unref0 (block);
                        g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                        g_clear_error (&_inner_error_);
                        return NULL;
                  }
            }
            _vala_code_node_unref0 (condition);
            condition = _tmp17_;
      }
      vala_parser_expect (self, VALA_TOKEN_TYPE_SEMICOLON, &_inner_error_);
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  _vala_code_node_unref0 (condition);
                  _vala_iterable_unref0 (initializer_list);
                  _vala_code_node_unref0 (block);
                  return NULL;
            } else {
                  _vala_code_node_unref0 (condition);
                  _vala_iterable_unref0 (initializer_list);
                  _vala_code_node_unref0 (block);
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      _tmp18_ = vala_array_list_new (VALA_TYPE_EXPRESSION, (GBoxedCopyFunc) vala_code_node_ref, vala_code_node_unref, g_direct_equal);
      iterator_list = _tmp18_;
      _tmp19_ = vala_parser_current (self);
      if (_tmp19_ != VALA_TOKEN_TYPE_CLOSE_PARENS) {
            {
                  gboolean _tmp20_;
                  _tmp20_ = TRUE;
                  while (TRUE) {
                        ValaExpression* _tmp22_ = NULL;
                        ValaExpression* _tmp23_;
                        ValaExpression* _tmp24_;
                        if (!_tmp20_) {
                              gboolean _tmp21_;
                              _tmp21_ = vala_parser_accept (self, VALA_TOKEN_TYPE_COMMA);
                              if (!_tmp21_) {
                                    break;
                              }
                        }
                        _tmp20_ = FALSE;
                        _tmp22_ = vala_parser_parse_statement_expression (self, &_inner_error_);
                        _tmp23_ = _tmp22_;
                        if (_inner_error_ != NULL) {
                              if (_inner_error_->domain == VALA_PARSE_ERROR) {
                                    g_propagate_error (error, _inner_error_);
                                    _vala_iterable_unref0 (iterator_list);
                                    _vala_code_node_unref0 (condition);
                                    _vala_iterable_unref0 (initializer_list);
                                    _vala_code_node_unref0 (block);
                                    return NULL;
                              } else {
                                    _vala_iterable_unref0 (iterator_list);
                                    _vala_code_node_unref0 (condition);
                                    _vala_iterable_unref0 (initializer_list);
                                    _vala_code_node_unref0 (block);
                                    g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                                    g_clear_error (&_inner_error_);
                                    return NULL;
                              }
                        }
                        _tmp24_ = _tmp23_;
                        vala_collection_add ((ValaCollection*) iterator_list, _tmp24_);
                        _vala_code_node_unref0 (_tmp24_);
                  }
            }
      }
      vala_parser_expect (self, VALA_TOKEN_TYPE_CLOSE_PARENS, &_inner_error_);
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  _vala_iterable_unref0 (iterator_list);
                  _vala_code_node_unref0 (condition);
                  _vala_iterable_unref0 (initializer_list);
                  _vala_code_node_unref0 (block);
                  return NULL;
            } else {
                  _vala_iterable_unref0 (iterator_list);
                  _vala_code_node_unref0 (condition);
                  _vala_iterable_unref0 (initializer_list);
                  _vala_code_node_unref0 (block);
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      _tmp25_ = vala_parser_get_src (self, &begin);
      src = _tmp25_;
      _tmp26_ = vala_parser_parse_embedded_statement (self, &_inner_error_);
      body = _tmp26_;
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  _vala_source_reference_unref0 (src);
                  _vala_iterable_unref0 (iterator_list);
                  _vala_code_node_unref0 (condition);
                  _vala_iterable_unref0 (initializer_list);
                  _vala_code_node_unref0 (block);
                  return NULL;
            } else {
                  _vala_source_reference_unref0 (src);
                  _vala_iterable_unref0 (iterator_list);
                  _vala_code_node_unref0 (condition);
                  _vala_iterable_unref0 (initializer_list);
                  _vala_code_node_unref0 (block);
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      _tmp27_ = vala_for_statement_new (condition, body, src);
      stmt = _tmp27_;
      {
            ValaArrayList* _tmp28_;
            ValaArrayList* _init_list;
            gint _tmp29_;
            gint _init_size;
            gint _init_index;
            _tmp28_ = _vala_iterable_ref0 (initializer_list);
            _init_list = _tmp28_;
            _tmp29_ = vala_collection_get_size ((ValaCollection*) _init_list);
            _init_size = _tmp29_;
            _init_index = -1;
            while (TRUE) {
                  gpointer _tmp30_ = NULL;
                  ValaExpression* init;
                  _init_index = _init_index + 1;
                  if (!(_init_index < _init_size)) {
                        break;
                  }
                  _tmp30_ = vala_list_get ((ValaList*) _init_list, _init_index);
                  init = (ValaExpression*) _tmp30_;
                  vala_for_statement_add_initializer (stmt, init);
                  _vala_code_node_unref0 (init);
            }
            _vala_iterable_unref0 (_init_list);
      }
      {
            ValaArrayList* _tmp31_;
            ValaArrayList* _iter_list;
            gint _tmp32_;
            gint _iter_size;
            gint _iter_index;
            _tmp31_ = _vala_iterable_ref0 (iterator_list);
            _iter_list = _tmp31_;
            _tmp32_ = vala_collection_get_size ((ValaCollection*) _iter_list);
            _iter_size = _tmp32_;
            _iter_index = -1;
            while (TRUE) {
                  gpointer _tmp33_ = NULL;
                  ValaExpression* iter;
                  _iter_index = _iter_index + 1;
                  if (!(_iter_index < _iter_size)) {
                        break;
                  }
                  _tmp33_ = vala_list_get ((ValaList*) _iter_list, _iter_index);
                  iter = (ValaExpression*) _tmp33_;
                  vala_for_statement_add_iterator (stmt, iter);
                  _vala_code_node_unref0 (iter);
            }
            _vala_iterable_unref0 (_iter_list);
      }
      if (block != NULL) {
            vala_block_add_statement (block, (ValaStatement*) stmt);
            result = (ValaStatement*) block;
            _vala_code_node_unref0 (stmt);
            _vala_code_node_unref0 (body);
            _vala_source_reference_unref0 (src);
            _vala_iterable_unref0 (iterator_list);
            _vala_code_node_unref0 (condition);
            _vala_iterable_unref0 (initializer_list);
            return result;
      } else {
            result = (ValaStatement*) stmt;
            _vala_code_node_unref0 (body);
            _vala_source_reference_unref0 (src);
            _vala_iterable_unref0 (iterator_list);
            _vala_code_node_unref0 (condition);
            _vala_iterable_unref0 (initializer_list);
            _vala_code_node_unref0 (block);
            return result;
      }
      _vala_code_node_unref0 (stmt);
      _vala_code_node_unref0 (body);
      _vala_source_reference_unref0 (src);
      _vala_iterable_unref0 (iterator_list);
      _vala_code_node_unref0 (condition);
      _vala_iterable_unref0 (initializer_list);
      _vala_code_node_unref0 (block);
}


static ValaStatement* vala_parser_parse_foreach_statement (ValaParser* self, GError** error) {
      ValaStatement* result = NULL;
      ValaSourceLocation _tmp0_ = {0};
      ValaSourceLocation _tmp1_ = {0};
      ValaSourceLocation begin;
      ValaDataType* type;
      gboolean _tmp2_;
      gchar* _tmp8_ = NULL;
      gchar* id;
      ValaExpression* _tmp9_ = NULL;
      ValaExpression* collection;
      ValaSourceReference* _tmp10_ = NULL;
      ValaSourceReference* src;
      ValaBlock* _tmp11_ = NULL;
      ValaBlock* body;
      ValaForeachStatement* _tmp12_ = NULL;
      GError * _inner_error_ = NULL;
      g_return_val_if_fail (self != NULL, NULL);
      vala_parser_get_location (self, &_tmp0_);
      _tmp1_ = _tmp0_;
      begin = _tmp1_;
      vala_parser_expect (self, VALA_TOKEN_TYPE_FOREACH, &_inner_error_);
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  return NULL;
            } else {
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      vala_parser_expect (self, VALA_TOKEN_TYPE_OPEN_PARENS, &_inner_error_);
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  return NULL;
            } else {
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      type = NULL;
      _tmp2_ = vala_parser_accept (self, VALA_TOKEN_TYPE_VAR);
      if (!_tmp2_) {
            ValaDataType* _tmp3_ = NULL;
            ValaDataType* _tmp4_;
            gboolean _tmp5_;
            _tmp3_ = vala_parser_parse_type (self, TRUE, TRUE, &_inner_error_);
            _tmp4_ = _tmp3_;
            if (_inner_error_ != NULL) {
                  if (_inner_error_->domain == VALA_PARSE_ERROR) {
                        g_propagate_error (error, _inner_error_);
                        _vala_code_node_unref0 (type);
                        return NULL;
                  } else {
                        _vala_code_node_unref0 (type);
                        g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                        g_clear_error (&_inner_error_);
                        return NULL;
                  }
            }
            _vala_code_node_unref0 (type);
            type = _tmp4_;
            _tmp5_ = vala_parser_accept (self, VALA_TOKEN_TYPE_IN);
            if (_tmp5_) {
                  ValaSourceReference* _tmp6_ = NULL;
                  GError* _tmp7_ = NULL;
                  _tmp6_ = vala_code_node_get_source_reference ((ValaCodeNode*) type);
                  vala_report_error (_tmp6_, "syntax error, expected var or type");
                  _tmp7_ = g_error_new_literal (VALA_PARSE_ERROR, VALA_PARSE_ERROR_SYNTAX, "expected var or type");
                  _inner_error_ = _tmp7_;
                  if (_inner_error_->domain == VALA_PARSE_ERROR) {
                        g_propagate_error (error, _inner_error_);
                        _vala_code_node_unref0 (type);
                        return NULL;
                  } else {
                        _vala_code_node_unref0 (type);
                        g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                        g_clear_error (&_inner_error_);
                        return NULL;
                  }
            }
      }
      _tmp8_ = vala_parser_parse_identifier (self, &_inner_error_);
      id = _tmp8_;
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  _vala_code_node_unref0 (type);
                  return NULL;
            } else {
                  _vala_code_node_unref0 (type);
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      vala_parser_expect (self, VALA_TOKEN_TYPE_IN, &_inner_error_);
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  _g_free0 (id);
                  _vala_code_node_unref0 (type);
                  return NULL;
            } else {
                  _g_free0 (id);
                  _vala_code_node_unref0 (type);
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      _tmp9_ = vala_parser_parse_expression (self, &_inner_error_);
      collection = _tmp9_;
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  _g_free0 (id);
                  _vala_code_node_unref0 (type);
                  return NULL;
            } else {
                  _g_free0 (id);
                  _vala_code_node_unref0 (type);
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      vala_parser_expect (self, VALA_TOKEN_TYPE_CLOSE_PARENS, &_inner_error_);
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  _vala_code_node_unref0 (collection);
                  _g_free0 (id);
                  _vala_code_node_unref0 (type);
                  return NULL;
            } else {
                  _vala_code_node_unref0 (collection);
                  _g_free0 (id);
                  _vala_code_node_unref0 (type);
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      _tmp10_ = vala_parser_get_src (self, &begin);
      src = _tmp10_;
      _tmp11_ = vala_parser_parse_embedded_statement (self, &_inner_error_);
      body = _tmp11_;
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  _vala_source_reference_unref0 (src);
                  _vala_code_node_unref0 (collection);
                  _g_free0 (id);
                  _vala_code_node_unref0 (type);
                  return NULL;
            } else {
                  _vala_source_reference_unref0 (src);
                  _vala_code_node_unref0 (collection);
                  _g_free0 (id);
                  _vala_code_node_unref0 (type);
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      _tmp12_ = vala_foreach_statement_new (type, id, collection, body, src);
      result = (ValaStatement*) _tmp12_;
      _vala_code_node_unref0 (body);
      _vala_source_reference_unref0 (src);
      _vala_code_node_unref0 (collection);
      _g_free0 (id);
      _vala_code_node_unref0 (type);
      return result;
}


static ValaStatement* vala_parser_parse_break_statement (ValaParser* self, GError** error) {
      ValaStatement* result = NULL;
      ValaSourceLocation _tmp0_ = {0};
      ValaSourceLocation _tmp1_ = {0};
      ValaSourceLocation begin;
      ValaSourceReference* _tmp2_ = NULL;
      ValaSourceReference* _tmp3_;
      ValaBreakStatement* _tmp4_ = NULL;
      ValaStatement* _tmp5_;
      GError * _inner_error_ = NULL;
      g_return_val_if_fail (self != NULL, NULL);
      vala_parser_get_location (self, &_tmp0_);
      _tmp1_ = _tmp0_;
      begin = _tmp1_;
      vala_parser_expect (self, VALA_TOKEN_TYPE_BREAK, &_inner_error_);
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  return NULL;
            } else {
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      vala_parser_expect (self, VALA_TOKEN_TYPE_SEMICOLON, &_inner_error_);
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  return NULL;
            } else {
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      _tmp2_ = vala_parser_get_src (self, &begin);
      _tmp3_ = _tmp2_;
      _tmp4_ = vala_break_statement_new (_tmp3_);
      _tmp5_ = (ValaStatement*) _tmp4_;
      _vala_source_reference_unref0 (_tmp3_);
      result = _tmp5_;
      return result;
}


static ValaStatement* vala_parser_parse_continue_statement (ValaParser* self, GError** error) {
      ValaStatement* result = NULL;
      ValaSourceLocation _tmp0_ = {0};
      ValaSourceLocation _tmp1_ = {0};
      ValaSourceLocation begin;
      ValaSourceReference* _tmp2_ = NULL;
      ValaSourceReference* _tmp3_;
      ValaContinueStatement* _tmp4_ = NULL;
      ValaStatement* _tmp5_;
      GError * _inner_error_ = NULL;
      g_return_val_if_fail (self != NULL, NULL);
      vala_parser_get_location (self, &_tmp0_);
      _tmp1_ = _tmp0_;
      begin = _tmp1_;
      vala_parser_expect (self, VALA_TOKEN_TYPE_CONTINUE, &_inner_error_);
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  return NULL;
            } else {
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      vala_parser_expect (self, VALA_TOKEN_TYPE_SEMICOLON, &_inner_error_);
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  return NULL;
            } else {
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      _tmp2_ = vala_parser_get_src (self, &begin);
      _tmp3_ = _tmp2_;
      _tmp4_ = vala_continue_statement_new (_tmp3_);
      _tmp5_ = (ValaStatement*) _tmp4_;
      _vala_source_reference_unref0 (_tmp3_);
      result = _tmp5_;
      return result;
}


static ValaStatement* vala_parser_parse_return_statement (ValaParser* self, GError** error) {
      ValaStatement* result = NULL;
      ValaSourceLocation _tmp0_ = {0};
      ValaSourceLocation _tmp1_ = {0};
      ValaSourceLocation begin;
      ValaExpression* expr;
      ValaTokenType _tmp2_;
      ValaSourceReference* _tmp5_ = NULL;
      ValaSourceReference* _tmp6_;
      ValaReturnStatement* _tmp7_ = NULL;
      ValaStatement* _tmp8_;
      GError * _inner_error_ = NULL;
      g_return_val_if_fail (self != NULL, NULL);
      vala_parser_get_location (self, &_tmp0_);
      _tmp1_ = _tmp0_;
      begin = _tmp1_;
      vala_parser_expect (self, VALA_TOKEN_TYPE_RETURN, &_inner_error_);
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  return NULL;
            } else {
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      expr = NULL;
      _tmp2_ = vala_parser_current (self);
      if (_tmp2_ != VALA_TOKEN_TYPE_SEMICOLON) {
            ValaExpression* _tmp3_ = NULL;
            ValaExpression* _tmp4_;
            _tmp3_ = vala_parser_parse_expression (self, &_inner_error_);
            _tmp4_ = _tmp3_;
            if (_inner_error_ != NULL) {
                  if (_inner_error_->domain == VALA_PARSE_ERROR) {
                        g_propagate_error (error, _inner_error_);
                        _vala_code_node_unref0 (expr);
                        return NULL;
                  } else {
                        _vala_code_node_unref0 (expr);
                        g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                        g_clear_error (&_inner_error_);
                        return NULL;
                  }
            }
            _vala_code_node_unref0 (expr);
            expr = _tmp4_;
      }
      vala_parser_expect (self, VALA_TOKEN_TYPE_SEMICOLON, &_inner_error_);
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  _vala_code_node_unref0 (expr);
                  return NULL;
            } else {
                  _vala_code_node_unref0 (expr);
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      _tmp5_ = vala_parser_get_src (self, &begin);
      _tmp6_ = _tmp5_;
      _tmp7_ = vala_return_statement_new (expr, _tmp6_);
      _tmp8_ = (ValaStatement*) _tmp7_;
      _vala_source_reference_unref0 (_tmp6_);
      result = _tmp8_;
      _vala_code_node_unref0 (expr);
      return result;
}


static ValaStatement* vala_parser_parse_yield_statement (ValaParser* self, GError** error) {
      ValaStatement* result = NULL;
      ValaSourceLocation _tmp0_ = {0};
      ValaSourceLocation _tmp1_ = {0};
      ValaSourceLocation begin;
      gboolean _tmp2_ = FALSE;
      ValaTokenType _tmp3_;
      ValaExpression* expr;
      gboolean _tmp7_;
      ValaSourceReference* _tmp10_ = NULL;
      ValaSourceReference* _tmp11_;
      ValaYieldStatement* _tmp12_ = NULL;
      ValaStatement* _tmp13_;
      GError * _inner_error_ = NULL;
      g_return_val_if_fail (self != NULL, NULL);
      vala_parser_get_location (self, &_tmp0_);
      _tmp1_ = _tmp0_;
      begin = _tmp1_;
      vala_parser_expect (self, VALA_TOKEN_TYPE_YIELD, &_inner_error_);
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  return NULL;
            } else {
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      _tmp3_ = vala_parser_current (self);
      if (_tmp3_ != VALA_TOKEN_TYPE_SEMICOLON) {
            ValaTokenType _tmp4_;
            _tmp4_ = vala_parser_current (self);
            _tmp2_ = _tmp4_ != VALA_TOKEN_TYPE_RETURN;
      } else {
            _tmp2_ = FALSE;
      }
      if (_tmp2_) {
            ValaStatement* _tmp5_ = NULL;
            ValaStatement* _tmp6_;
            vala_parser_prev (self);
            _tmp5_ = vala_parser_parse_expression_statement (self, &_inner_error_);
            _tmp6_ = _tmp5_;
            if (_inner_error_ != NULL) {
                  if (_inner_error_->domain == VALA_PARSE_ERROR) {
                        g_propagate_error (error, _inner_error_);
                        return NULL;
                  } else {
                        g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                        g_clear_error (&_inner_error_);
                        return NULL;
                  }
            }
            result = _tmp6_;
            return result;
      }
      expr = NULL;
      _tmp7_ = vala_parser_accept (self, VALA_TOKEN_TYPE_RETURN);
      if (_tmp7_) {
            ValaExpression* _tmp8_ = NULL;
            ValaExpression* _tmp9_;
            _tmp8_ = vala_parser_parse_expression (self, &_inner_error_);
            _tmp9_ = _tmp8_;
            if (_inner_error_ != NULL) {
                  if (_inner_error_->domain == VALA_PARSE_ERROR) {
                        g_propagate_error (error, _inner_error_);
                        _vala_code_node_unref0 (expr);
                        return NULL;
                  } else {
                        _vala_code_node_unref0 (expr);
                        g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                        g_clear_error (&_inner_error_);
                        return NULL;
                  }
            }
            _vala_code_node_unref0 (expr);
            expr = _tmp9_;
      }
      vala_parser_expect (self, VALA_TOKEN_TYPE_SEMICOLON, &_inner_error_);
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  _vala_code_node_unref0 (expr);
                  return NULL;
            } else {
                  _vala_code_node_unref0 (expr);
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      _tmp10_ = vala_parser_get_src (self, &begin);
      _tmp11_ = _tmp10_;
      _tmp12_ = vala_yield_statement_new (expr, _tmp11_);
      _tmp13_ = (ValaStatement*) _tmp12_;
      _vala_source_reference_unref0 (_tmp11_);
      result = _tmp13_;
      _vala_code_node_unref0 (expr);
      return result;
}


static ValaStatement* vala_parser_parse_throw_statement (ValaParser* self, GError** error) {
      ValaStatement* result = NULL;
      ValaSourceLocation _tmp0_ = {0};
      ValaSourceLocation _tmp1_ = {0};
      ValaSourceLocation begin;
      ValaExpression* _tmp2_ = NULL;
      ValaExpression* expr;
      ValaSourceReference* _tmp3_ = NULL;
      ValaSourceReference* _tmp4_;
      ValaThrowStatement* _tmp5_ = NULL;
      ValaStatement* _tmp6_;
      GError * _inner_error_ = NULL;
      g_return_val_if_fail (self != NULL, NULL);
      vala_parser_get_location (self, &_tmp0_);
      _tmp1_ = _tmp0_;
      begin = _tmp1_;
      vala_parser_expect (self, VALA_TOKEN_TYPE_THROW, &_inner_error_);
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  return NULL;
            } else {
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      _tmp2_ = vala_parser_parse_expression (self, &_inner_error_);
      expr = _tmp2_;
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  return NULL;
            } else {
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      vala_parser_expect (self, VALA_TOKEN_TYPE_SEMICOLON, &_inner_error_);
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  _vala_code_node_unref0 (expr);
                  return NULL;
            } else {
                  _vala_code_node_unref0 (expr);
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      _tmp3_ = vala_parser_get_src (self, &begin);
      _tmp4_ = _tmp3_;
      _tmp5_ = vala_throw_statement_new (expr, _tmp4_);
      _tmp6_ = (ValaStatement*) _tmp5_;
      _vala_source_reference_unref0 (_tmp4_);
      result = _tmp6_;
      _vala_code_node_unref0 (expr);
      return result;
}


static ValaStatement* vala_parser_parse_try_statement (ValaParser* self, GError** error) {
      ValaStatement* result = NULL;
      ValaSourceLocation _tmp0_ = {0};
      ValaSourceLocation _tmp1_ = {0};
      ValaSourceLocation begin;
      ValaBlock* _tmp2_ = NULL;
      ValaBlock* try_block;
      ValaBlock* finally_clause;
      ValaArrayList* _tmp3_ = NULL;
      ValaArrayList* catch_clauses;
      ValaTokenType _tmp4_;
      ValaSourceReference* _tmp10_ = NULL;
      ValaSourceReference* _tmp11_;
      ValaTryStatement* _tmp12_ = NULL;
      ValaTryStatement* _tmp13_;
      ValaTryStatement* stmt;
      GError * _inner_error_ = NULL;
      g_return_val_if_fail (self != NULL, NULL);
      vala_parser_get_location (self, &_tmp0_);
      _tmp1_ = _tmp0_;
      begin = _tmp1_;
      vala_parser_expect (self, VALA_TOKEN_TYPE_TRY, &_inner_error_);
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  return NULL;
            } else {
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      _tmp2_ = vala_parser_parse_block (self, &_inner_error_);
      try_block = _tmp2_;
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  return NULL;
            } else {
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      finally_clause = NULL;
      _tmp3_ = vala_array_list_new (VALA_TYPE_CATCH_CLAUSE, (GBoxedCopyFunc) vala_code_node_ref, vala_code_node_unref, g_direct_equal);
      catch_clauses = _tmp3_;
      _tmp4_ = vala_parser_current (self);
      if (_tmp4_ == VALA_TOKEN_TYPE_CATCH) {
            ValaTokenType _tmp5_;
            vala_parser_parse_catch_clauses (self, (ValaList*) catch_clauses, &_inner_error_);
            if (_inner_error_ != NULL) {
                  if (_inner_error_->domain == VALA_PARSE_ERROR) {
                        g_propagate_error (error, _inner_error_);
                        _vala_iterable_unref0 (catch_clauses);
                        _vala_code_node_unref0 (finally_clause);
                        _vala_code_node_unref0 (try_block);
                        return NULL;
                  } else {
                        _vala_iterable_unref0 (catch_clauses);
                        _vala_code_node_unref0 (finally_clause);
                        _vala_code_node_unref0 (try_block);
                        g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                        g_clear_error (&_inner_error_);
                        return NULL;
                  }
            }
            _tmp5_ = vala_parser_current (self);
            if (_tmp5_ == VALA_TOKEN_TYPE_FINALLY) {
                  ValaBlock* _tmp6_ = NULL;
                  ValaBlock* _tmp7_;
                  _tmp6_ = vala_parser_parse_finally_clause (self, &_inner_error_);
                  _tmp7_ = _tmp6_;
                  if (_inner_error_ != NULL) {
                        if (_inner_error_->domain == VALA_PARSE_ERROR) {
                              g_propagate_error (error, _inner_error_);
                              _vala_iterable_unref0 (catch_clauses);
                              _vala_code_node_unref0 (finally_clause);
                              _vala_code_node_unref0 (try_block);
                              return NULL;
                        } else {
                              _vala_iterable_unref0 (catch_clauses);
                              _vala_code_node_unref0 (finally_clause);
                              _vala_code_node_unref0 (try_block);
                              g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                              g_clear_error (&_inner_error_);
                              return NULL;
                        }
                  }
                  _vala_code_node_unref0 (finally_clause);
                  finally_clause = _tmp7_;
            }
      } else {
            ValaBlock* _tmp8_ = NULL;
            ValaBlock* _tmp9_;
            _tmp8_ = vala_parser_parse_finally_clause (self, &_inner_error_);
            _tmp9_ = _tmp8_;
            if (_inner_error_ != NULL) {
                  if (_inner_error_->domain == VALA_PARSE_ERROR) {
                        g_propagate_error (error, _inner_error_);
                        _vala_iterable_unref0 (catch_clauses);
                        _vala_code_node_unref0 (finally_clause);
                        _vala_code_node_unref0 (try_block);
                        return NULL;
                  } else {
                        _vala_iterable_unref0 (catch_clauses);
                        _vala_code_node_unref0 (finally_clause);
                        _vala_code_node_unref0 (try_block);
                        g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                        g_clear_error (&_inner_error_);
                        return NULL;
                  }
            }
            _vala_code_node_unref0 (finally_clause);
            finally_clause = _tmp9_;
      }
      _tmp10_ = vala_parser_get_src (self, &begin);
      _tmp11_ = _tmp10_;
      _tmp12_ = vala_try_statement_new (try_block, finally_clause, _tmp11_);
      _tmp13_ = _tmp12_;
      _vala_source_reference_unref0 (_tmp11_);
      stmt = _tmp13_;
      {
            ValaArrayList* _tmp14_;
            ValaArrayList* _clause_list;
            gint _tmp15_;
            gint _clause_size;
            gint _clause_index;
            _tmp14_ = _vala_iterable_ref0 (catch_clauses);
            _clause_list = _tmp14_;
            _tmp15_ = vala_collection_get_size ((ValaCollection*) _clause_list);
            _clause_size = _tmp15_;
            _clause_index = -1;
            while (TRUE) {
                  gpointer _tmp16_ = NULL;
                  ValaCatchClause* clause;
                  _clause_index = _clause_index + 1;
                  if (!(_clause_index < _clause_size)) {
                        break;
                  }
                  _tmp16_ = vala_list_get ((ValaList*) _clause_list, _clause_index);
                  clause = (ValaCatchClause*) _tmp16_;
                  vala_try_statement_add_catch_clause (stmt, clause);
                  _vala_code_node_unref0 (clause);
            }
            _vala_iterable_unref0 (_clause_list);
      }
      result = (ValaStatement*) stmt;
      _vala_iterable_unref0 (catch_clauses);
      _vala_code_node_unref0 (finally_clause);
      _vala_code_node_unref0 (try_block);
      return result;
}


static void vala_parser_parse_catch_clauses (ValaParser* self, ValaList* catch_clauses, GError** error) {
      GError * _inner_error_ = NULL;
      g_return_if_fail (self != NULL);
      g_return_if_fail (catch_clauses != NULL);
      while (TRUE) {
            gboolean _tmp0_;
            ValaSourceLocation _tmp1_ = {0};
            ValaSourceLocation _tmp2_ = {0};
            ValaSourceLocation begin;
            ValaDataType* type;
            gchar* id;
            gboolean _tmp3_;
            ValaBlock* _tmp8_ = NULL;
            ValaBlock* block;
            ValaSourceReference* _tmp9_ = NULL;
            ValaSourceReference* _tmp10_;
            ValaCatchClause* _tmp11_ = NULL;
            ValaCatchClause* _tmp12_;
            _tmp0_ = vala_parser_accept (self, VALA_TOKEN_TYPE_CATCH);
            if (!_tmp0_) {
                  break;
            }
            vala_parser_get_location (self, &_tmp1_);
            _tmp2_ = _tmp1_;
            begin = _tmp2_;
            type = NULL;
            id = NULL;
            _tmp3_ = vala_parser_accept (self, VALA_TOKEN_TYPE_OPEN_PARENS);
            if (_tmp3_) {
                  ValaDataType* _tmp4_ = NULL;
                  ValaDataType* _tmp5_;
                  gchar* _tmp6_ = NULL;
                  gchar* _tmp7_;
                  _tmp4_ = vala_parser_parse_type (self, TRUE, TRUE, &_inner_error_);
                  _tmp5_ = _tmp4_;
                  if (_inner_error_ != NULL) {
                        if (_inner_error_->domain == VALA_PARSE_ERROR) {
                              g_propagate_error (error, _inner_error_);
                              _g_free0 (id);
                              _vala_code_node_unref0 (type);
                              return;
                        } else {
                              _g_free0 (id);
                              _vala_code_node_unref0 (type);
                              g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                              g_clear_error (&_inner_error_);
                              return;
                        }
                  }
                  _vala_code_node_unref0 (type);
                  type = _tmp5_;
                  _tmp6_ = vala_parser_parse_identifier (self, &_inner_error_);
                  _tmp7_ = _tmp6_;
                  if (_inner_error_ != NULL) {
                        if (_inner_error_->domain == VALA_PARSE_ERROR) {
                              g_propagate_error (error, _inner_error_);
                              _g_free0 (id);
                              _vala_code_node_unref0 (type);
                              return;
                        } else {
                              _g_free0 (id);
                              _vala_code_node_unref0 (type);
                              g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                              g_clear_error (&_inner_error_);
                              return;
                        }
                  }
                  _g_free0 (id);
                  id = _tmp7_;
                  vala_parser_expect (self, VALA_TOKEN_TYPE_CLOSE_PARENS, &_inner_error_);
                  if (_inner_error_ != NULL) {
                        if (_inner_error_->domain == VALA_PARSE_ERROR) {
                              g_propagate_error (error, _inner_error_);
                              _g_free0 (id);
                              _vala_code_node_unref0 (type);
                              return;
                        } else {
                              _g_free0 (id);
                              _vala_code_node_unref0 (type);
                              g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                              g_clear_error (&_inner_error_);
                              return;
                        }
                  }
            }
            _tmp8_ = vala_parser_parse_block (self, &_inner_error_);
            block = _tmp8_;
            if (_inner_error_ != NULL) {
                  if (_inner_error_->domain == VALA_PARSE_ERROR) {
                        g_propagate_error (error, _inner_error_);
                        _g_free0 (id);
                        _vala_code_node_unref0 (type);
                        return;
                  } else {
                        _g_free0 (id);
                        _vala_code_node_unref0 (type);
                        g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                        g_clear_error (&_inner_error_);
                        return;
                  }
            }
            _tmp9_ = vala_parser_get_src (self, &begin);
            _tmp10_ = _tmp9_;
            _tmp11_ = vala_catch_clause_new (type, id, block, _tmp10_);
            _tmp12_ = _tmp11_;
            vala_collection_add ((ValaCollection*) catch_clauses, _tmp12_);
            _vala_code_node_unref0 (_tmp12_);
            _vala_source_reference_unref0 (_tmp10_);
            _vala_code_node_unref0 (block);
            _g_free0 (id);
            _vala_code_node_unref0 (type);
      }
}


static ValaBlock* vala_parser_parse_finally_clause (ValaParser* self, GError** error) {
      ValaBlock* result = NULL;
      ValaBlock* _tmp0_ = NULL;
      ValaBlock* block;
      GError * _inner_error_ = NULL;
      g_return_val_if_fail (self != NULL, NULL);
      vala_parser_expect (self, VALA_TOKEN_TYPE_FINALLY, &_inner_error_);
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  return NULL;
            } else {
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      _tmp0_ = vala_parser_parse_block (self, &_inner_error_);
      block = _tmp0_;
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  return NULL;
            } else {
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      result = block;
      return result;
}


static ValaStatement* vala_parser_parse_lock_statement (ValaParser* self, GError** error) {
      ValaStatement* result = NULL;
      ValaSourceLocation _tmp0_ = {0};
      ValaSourceLocation _tmp1_ = {0};
      ValaSourceLocation begin;
      ValaExpression* _tmp2_ = NULL;
      ValaExpression* expr;
      ValaBlock* _tmp3_ = NULL;
      ValaBlock* stmt;
      ValaSourceReference* _tmp4_ = NULL;
      ValaSourceReference* _tmp5_;
      ValaLockStatement* _tmp6_ = NULL;
      ValaStatement* _tmp7_;
      GError * _inner_error_ = NULL;
      g_return_val_if_fail (self != NULL, NULL);
      vala_parser_get_location (self, &_tmp0_);
      _tmp1_ = _tmp0_;
      begin = _tmp1_;
      vala_parser_expect (self, VALA_TOKEN_TYPE_LOCK, &_inner_error_);
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  return NULL;
            } else {
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      vala_parser_expect (self, VALA_TOKEN_TYPE_OPEN_PARENS, &_inner_error_);
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  return NULL;
            } else {
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      _tmp2_ = vala_parser_parse_expression (self, &_inner_error_);
      expr = _tmp2_;
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  return NULL;
            } else {
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                  g_clear_error (&_inner_error_);
                  return NULL;
            }
      }
      vala_parser_expect (self, VALA_TOKEN_TYPE_CLOSE_PARENS, &_inner_error_);
      if (_inner_error_ != NULL) {
            if (_inner_error_->domain == VALA_PARSE_ERROR) {
                  g_propagate_error (error, _inner_error_);
                  _vala_code_node_unref0 (expr);
                  return NULL;
            } else {
                  _vala_code_node_unref0 (expr);
                  g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_strin