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

valaflowanalyzer.c

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

/* valaflowanalyzer.vala
 *
 * Copyright (C) 2008-2010  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>
#include <gobject/gvaluecollector.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_FLOW_ANALYZER (vala_flow_analyzer_get_type ())
#define VALA_FLOW_ANALYZER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_FLOW_ANALYZER, ValaFlowAnalyzer))
#define VALA_FLOW_ANALYZER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_FLOW_ANALYZER, ValaFlowAnalyzerClass))
#define VALA_IS_FLOW_ANALYZER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_FLOW_ANALYZER))
#define VALA_IS_FLOW_ANALYZER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_FLOW_ANALYZER))
#define VALA_FLOW_ANALYZER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_FLOW_ANALYZER, ValaFlowAnalyzerClass))

typedef struct _ValaFlowAnalyzer ValaFlowAnalyzer;
typedef struct _ValaFlowAnalyzerClass ValaFlowAnalyzerClass;
typedef struct _ValaFlowAnalyzerPrivate ValaFlowAnalyzerPrivate;

#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_TYPE_BASIC_BLOCK (vala_basic_block_get_type ())
#define VALA_BASIC_BLOCK(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_BASIC_BLOCK, ValaBasicBlock))
#define VALA_BASIC_BLOCK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_BASIC_BLOCK, ValaBasicBlockClass))
#define VALA_IS_BASIC_BLOCK(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_BASIC_BLOCK))
#define VALA_IS_BASIC_BLOCK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_BASIC_BLOCK))
#define VALA_BASIC_BLOCK_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_BASIC_BLOCK, ValaBasicBlockClass))

typedef struct _ValaBasicBlock ValaBasicBlock;
typedef struct _ValaBasicBlockClass ValaBasicBlockClass;

#define VALA_FLOW_ANALYZER_TYPE_JUMP_TARGET (vala_flow_analyzer_jump_target_get_type ())
#define VALA_FLOW_ANALYZER_JUMP_TARGET(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_FLOW_ANALYZER_TYPE_JUMP_TARGET, ValaFlowAnalyzerJumpTarget))
#define VALA_FLOW_ANALYZER_JUMP_TARGET_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_FLOW_ANALYZER_TYPE_JUMP_TARGET, ValaFlowAnalyzerJumpTargetClass))
#define VALA_FLOW_ANALYZER_IS_JUMP_TARGET(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_FLOW_ANALYZER_TYPE_JUMP_TARGET))
#define VALA_FLOW_ANALYZER_IS_JUMP_TARGET_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_FLOW_ANALYZER_TYPE_JUMP_TARGET))
#define VALA_FLOW_ANALYZER_JUMP_TARGET_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_FLOW_ANALYZER_TYPE_JUMP_TARGET, ValaFlowAnalyzerJumpTargetClass))

typedef struct _ValaFlowAnalyzerJumpTarget ValaFlowAnalyzerJumpTarget;
typedef struct _ValaFlowAnalyzerJumpTargetClass ValaFlowAnalyzerJumpTargetClass;

#define VALA_TYPE_PHI_FUNCTION (vala_phi_function_get_type ())
#define VALA_PHI_FUNCTION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_PHI_FUNCTION, ValaPhiFunction))
#define VALA_PHI_FUNCTION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_PHI_FUNCTION, ValaPhiFunctionClass))
#define VALA_IS_PHI_FUNCTION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_PHI_FUNCTION))
#define VALA_IS_PHI_FUNCTION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_PHI_FUNCTION))
#define VALA_PHI_FUNCTION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_PHI_FUNCTION, ValaPhiFunctionClass))

typedef struct _ValaPhiFunction ValaPhiFunction;
typedef struct _ValaPhiFunctionClass ValaPhiFunctionClass;
#define _vala_code_context_unref0(var) ((var == NULL) ? NULL : (var = (vala_code_context_unref (var), NULL)))
#define _vala_basic_block_unref0(var) ((var == NULL) ? NULL : (var = (vala_basic_block_unref (var), NULL)))
#define _vala_iterable_unref0(var) ((var == NULL) ? NULL : (var = (vala_iterable_unref (var), NULL)))
#define _vala_map_unref0(var) ((var == NULL) ? NULL : (var = (vala_map_unref (var), NULL)))

#define VALA_TYPE_SOURCE_FILE_TYPE (vala_source_file_type_get_type ())
#define _vala_source_file_unref0(var) ((var == NULL) ? NULL : (var = (vala_source_file_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_TYPE_PROFILE (vala_profile_get_type ())
#define _vala_code_node_unref0(var) ((var == NULL) ? NULL : (var = (vala_code_node_unref (var), NULL)))
#define _vala_flow_analyzer_jump_target_unref0(var) ((var == NULL) ? NULL : (var = (vala_flow_analyzer_jump_target_unref (var), NULL)))
#define _vala_iterator_unref0(var) ((var == NULL) ? NULL : (var = (vala_iterator_unref (var), NULL)))
#define _vala_phi_function_unref0(var) ((var == NULL) ? NULL : (var = (vala_phi_function_unref (var), NULL)))

#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;

#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_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_ERROR_TYPE (vala_error_type_get_type ())
#define VALA_ERROR_TYPE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_ERROR_TYPE, ValaErrorType))
#define VALA_ERROR_TYPE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_ERROR_TYPE, ValaErrorTypeClass))
#define VALA_IS_ERROR_TYPE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_ERROR_TYPE))
#define VALA_IS_ERROR_TYPE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_ERROR_TYPE))
#define VALA_ERROR_TYPE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_ERROR_TYPE, ValaErrorTypeClass))

typedef struct _ValaErrorType ValaErrorType;
typedef struct _ValaErrorTypeClass ValaErrorTypeClass;
typedef struct _ValaFlowAnalyzerJumpTargetPrivate ValaFlowAnalyzerJumpTargetPrivate;
typedef struct _ValaFlowAnalyzerParamSpecJumpTarget ValaFlowAnalyzerParamSpecJumpTarget;

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 _ValaFlowAnalyzer {
      ValaCodeVisitor parent_instance;
      ValaFlowAnalyzerPrivate * priv;
};

struct _ValaFlowAnalyzerClass {
      ValaCodeVisitorClass parent_class;
};

01153 struct _ValaFlowAnalyzerPrivate {
      ValaCodeContext* context;
      ValaBasicBlock* current_block;
      gboolean unreachable_reported;
      ValaList* jump_stack;
      ValaMap* var_map;
      ValaSet* used_vars;
      ValaMap* phi_functions;
};

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_PROFILE_POSIX,
      VALA_PROFILE_GOBJECT,
      VALA_PROFILE_DOVA
} ValaProfile;

struct _ValaStatementIface {
      GTypeInterface parent_iface;
};

01180 struct _ValaFlowAnalyzerJumpTarget {
      GTypeInstance parent_instance;
      volatile int ref_count;
      ValaFlowAnalyzerJumpTargetPrivate * priv;
};

01186 struct _ValaFlowAnalyzerJumpTargetClass {
      GTypeClass parent_class;
      void (*finalize) (ValaFlowAnalyzerJumpTarget *self);
};

01191 struct _ValaFlowAnalyzerJumpTargetPrivate {
      gboolean _is_break_target;
      gboolean _is_continue_target;
      gboolean _is_return_target;
      gboolean _is_exit_target;
      gboolean _is_error_target;
      ValaErrorDomain* _error_domain;
      ValaErrorCode* _error_code;
      ValaClass* _error_class;
      gboolean _is_finally_clause;
      ValaBasicBlock* _basic_block;
      ValaBasicBlock* _last_block;
      ValaCatchClause* _catch_clause;
};

01206 struct _ValaFlowAnalyzerParamSpecJumpTarget {
      GParamSpec parent_instance;
};


static gpointer vala_flow_analyzer_parent_class = NULL;
static gpointer vala_flow_analyzer_jump_target_parent_class = 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_flow_analyzer_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;
gpointer vala_basic_block_ref (gpointer instance);
void vala_basic_block_unref (gpointer instance);
GParamSpec* vala_param_spec_basic_block (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
void vala_value_set_basic_block (GValue* value, gpointer v_object);
void vala_value_take_basic_block (GValue* value, gpointer v_object);
gpointer vala_value_get_basic_block (const GValue* value);
GType vala_basic_block_get_type (void) G_GNUC_CONST;
static gpointer vala_flow_analyzer_jump_target_ref (gpointer instance);
static void vala_flow_analyzer_jump_target_unref (gpointer instance);
static GParamSpec* vala_flow_analyzer_param_spec_jump_target (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags) G_GNUC_UNUSED;
static void vala_flow_analyzer_value_set_jump_target (GValue* value, gpointer v_object) G_GNUC_UNUSED;
static void vala_flow_analyzer_value_take_jump_target (GValue* value, gpointer v_object) G_GNUC_UNUSED;
static gpointer vala_flow_analyzer_value_get_jump_target (const GValue* value) G_GNUC_UNUSED;
static GType vala_flow_analyzer_jump_target_get_type (void) G_GNUC_CONST G_GNUC_UNUSED;
gpointer vala_phi_function_ref (gpointer instance);
void vala_phi_function_unref (gpointer instance);
GParamSpec* vala_param_spec_phi_function (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
void vala_value_set_phi_function (GValue* value, gpointer v_object);
void vala_value_take_phi_function (GValue* value, gpointer v_object);
gpointer vala_value_get_phi_function (const GValue* value);
GType vala_phi_function_get_type (void) G_GNUC_CONST;
#define VALA_FLOW_ANALYZER_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), VALA_TYPE_FLOW_ANALYZER, ValaFlowAnalyzerPrivate))
enum  {
      VALA_FLOW_ANALYZER_DUMMY_PROPERTY
};
ValaFlowAnalyzer* vala_flow_analyzer_new (void);
ValaFlowAnalyzer* vala_flow_analyzer_construct (GType object_type);
ValaCodeVisitor* vala_code_visitor_construct (GType object_type);
void vala_flow_analyzer_analyze (ValaFlowAnalyzer* self, ValaCodeContext* context);
ValaList* vala_code_context_get_source_files (ValaCodeContext* self);
GType vala_source_file_type_get_type (void) G_GNUC_CONST;
ValaSourceFileType vala_source_file_get_file_type (ValaSourceFile* self);
void vala_source_file_accept (ValaSourceFile* self, ValaCodeVisitor* visitor);
static void vala_flow_analyzer_real_visit_source_file (ValaCodeVisitor* base, ValaSourceFile* source_file);
void vala_source_file_accept_children (ValaSourceFile* self, ValaCodeVisitor* visitor);
static void vala_flow_analyzer_real_visit_class (ValaCodeVisitor* base, ValaClass* cl);
void vala_code_node_accept_children (ValaCodeNode* self, ValaCodeVisitor* visitor);
static void vala_flow_analyzer_real_visit_struct (ValaCodeVisitor* base, ValaStruct* st);
static void vala_flow_analyzer_real_visit_interface (ValaCodeVisitor* base, ValaInterface* iface);
static void vala_flow_analyzer_real_visit_enum (ValaCodeVisitor* base, ValaEnum* en);
static void vala_flow_analyzer_real_visit_error_domain (ValaCodeVisitor* base, ValaErrorDomain* ed);
static void vala_flow_analyzer_real_visit_field (ValaCodeVisitor* base, ValaField* f);
gboolean vala_symbol_is_internal_symbol (ValaSymbol* self);
gboolean vala_symbol_get_used (ValaSymbol* self);
gboolean vala_symbol_is_private_symbol (ValaSymbol* self);
const gchar* vala_code_context_get_internal_header_filename (ValaCodeContext* self);
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_warning (ValaSourceReference* source, const gchar* message);
ValaSourceReference* vala_code_node_get_source_reference (ValaCodeNode* self);
gchar* vala_symbol_get_full_name (ValaSymbol* self);
static void vala_flow_analyzer_real_visit_lambda_expression (ValaCodeVisitor* base, ValaLambdaExpression* le);
static void vala_flow_analyzer_mark_unreachable (ValaFlowAnalyzer* self);
static void vala_flow_analyzer_real_visit_method (ValaCodeVisitor* base, ValaMethod* m);
gboolean vala_method_get_entry_point (ValaMethod* self);
gboolean vala_method_get_overrides (ValaMethod* self);
ValaMethod* vala_method_get_base_interface_method (ValaMethod* self);
static void vala_flow_analyzer_visit_subroutine (ValaFlowAnalyzer* self, ValaSubroutine* m);
static void vala_flow_analyzer_real_visit_signal (ValaCodeVisitor* base, ValaSignal* sig);
ValaMethod* vala_signal_get_default_handler (ValaSignal* self);
ValaBlock* vala_subroutine_get_body (ValaSubroutine* self);
ValaBasicBlock* vala_basic_block_new_entry (void);
ValaBasicBlock* vala_basic_block_construct_entry (GType object_type);
void vala_subroutine_set_entry_block (ValaSubroutine* self, ValaBasicBlock* value);
ValaBasicBlock* vala_basic_block_new (void);
ValaBasicBlock* vala_basic_block_construct (GType object_type);
void vala_subroutine_set_return_block (ValaSubroutine* self, ValaBasicBlock* value);
ValaBasicBlock* vala_basic_block_new_exit (void);
ValaBasicBlock* vala_basic_block_construct_exit (GType object_type);
void vala_subroutine_set_exit_block (ValaSubroutine* self, ValaBasicBlock* value);
ValaBasicBlock* vala_subroutine_get_return_block (ValaSubroutine* self);
void vala_basic_block_connect (ValaBasicBlock* self, ValaBasicBlock* target);
ValaBasicBlock* vala_subroutine_get_exit_block (ValaSubroutine* self);
GType vala_profile_get_type (void) G_GNUC_CONST;
ValaProfile vala_code_context_get_profile (ValaCodeContext* self);
ValaLocalVariable* vala_subroutine_get_result_var (ValaSubroutine* 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_expression_set_symbol_reference (ValaExpression* self, ValaSymbol* value);
void vala_basic_block_add_node (ValaBasicBlock* self, ValaCodeNode* node);
ValaBasicBlock* vala_subroutine_get_entry_block (ValaSubroutine* self);
static ValaFlowAnalyzerJumpTarget* vala_flow_analyzer_jump_target_new_return_target (ValaBasicBlock* basic_block);
static ValaFlowAnalyzerJumpTarget* vala_flow_analyzer_jump_target_construct_return_target (GType object_type, ValaBasicBlock* basic_block);
static ValaFlowAnalyzerJumpTarget* vala_flow_analyzer_jump_target_new_exit_target (ValaBasicBlock* basic_block);
static ValaFlowAnalyzerJumpTarget* vala_flow_analyzer_jump_target_construct_exit_target (GType object_type, ValaBasicBlock* basic_block);
gboolean vala_subroutine_get_has_result (ValaSubroutine* self);
void vala_report_error (ValaSourceReference* source, const gchar* message);
void vala_code_node_set_error (ValaCodeNode* self, gboolean value);
static void vala_flow_analyzer_analyze_body (ValaFlowAnalyzer* self, ValaBasicBlock* entry_block);
static ValaList* vala_flow_analyzer_get_depth_first_list (ValaFlowAnalyzer* self, ValaBasicBlock* entry_block);
static void vala_flow_analyzer_build_dominator_tree (ValaFlowAnalyzer* self, ValaList* block_list, ValaBasicBlock* entry_block);
static void vala_flow_analyzer_build_dominator_frontier (ValaFlowAnalyzer* self, ValaList* block_list, ValaBasicBlock* entry_block);
static void vala_flow_analyzer_insert_phi_functions (ValaFlowAnalyzer* self, ValaList* block_list, ValaBasicBlock* entry_block);
static void vala_flow_analyzer_check_variables (ValaFlowAnalyzer* self, ValaBasicBlock* entry_block);
static void vala_flow_analyzer_depth_first_traverse (ValaFlowAnalyzer* self, ValaBasicBlock* current, ValaList* list);
gboolean vala_basic_block_get_postorder_visited (ValaBasicBlock* self);
void vala_basic_block_set_postorder_visited (ValaBasicBlock* self, gboolean value);
ValaList* vala_basic_block_get_successors (ValaBasicBlock* self);
void vala_basic_block_set_postorder_number (ValaBasicBlock* self, gint value);
gint vala_basic_block_get_postorder_number (ValaBasicBlock* self);
ValaList* vala_basic_block_get_predecessors (ValaBasicBlock* self);
static ValaBasicBlock* vala_flow_analyzer_intersect (ValaFlowAnalyzer* self, ValaBasicBlock** idoms, int idoms_length1, ValaBasicBlock* b1, ValaBasicBlock* b2);
void vala_basic_block_add_child (ValaBasicBlock* self, ValaBasicBlock* block);
ValaBasicBlock* vala_basic_block_get_parent (ValaBasicBlock* self);
void vala_basic_block_add_dominator_frontier (ValaBasicBlock* self, ValaBasicBlock* block);
ValaList* vala_basic_block_get_children (ValaBasicBlock* self);
ValaSet* vala_basic_block_get_dominator_frontier (ValaBasicBlock* self);
static ValaMap* vala_flow_analyzer_get_assignment_map (ValaFlowAnalyzer* self, ValaList* block_list, ValaBasicBlock* entry_block);
ValaList* vala_basic_block_get_nodes (ValaBasicBlock* self);
void vala_code_node_get_defined_variables (ValaCodeNode* self, ValaCollection* collection);
void vala_basic_block_add_phi_function (ValaBasicBlock* self, ValaPhiFunction* phi);
ValaPhiFunction* vala_phi_function_new (ValaLocalVariable* variable, gint num_of_ops);
ValaPhiFunction* vala_phi_function_construct (GType object_type, ValaLocalVariable* variable, gint num_of_ops);
static void vala_flow_analyzer_check_block_variables (ValaFlowAnalyzer* self, ValaBasicBlock* block);
ValaList* vala_phi_function_get_operands (ValaPhiFunction* self);
const gchar* vala_symbol_get_name (ValaSymbol* self);
void vala_code_node_set_source_reference (ValaCodeNode* self, ValaSourceReference* value);
ValaSet* vala_basic_block_get_phi_functions (ValaBasicBlock* self);
static ValaLocalVariable* vala_flow_analyzer_process_assignment (ValaFlowAnalyzer* self, ValaMap* var_map, ValaLocalVariable* var_symbol);
ValaLocalVariable* vala_phi_function_get_original_variable (ValaPhiFunction* self);
void vala_code_node_get_used_variables (ValaCodeNode* self, ValaCollection* collection);
ValaDataType* vala_variable_get_variable_type (ValaVariable* self);
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);
static void vala_flow_analyzer_real_visit_creation_method (ValaCodeVisitor* base, ValaCreationMethod* m);
void vala_code_visitor_visit_method (ValaCodeVisitor* self, ValaMethod* m);
static void vala_flow_analyzer_real_visit_property (ValaCodeVisitor* base, ValaProperty* prop);
static void vala_flow_analyzer_real_visit_property_accessor (ValaCodeVisitor* base, ValaPropertyAccessor* acc);
static void vala_flow_analyzer_real_visit_block (ValaCodeVisitor* base, ValaBlock* b);
static void vala_flow_analyzer_real_visit_declaration_statement (ValaCodeVisitor* base, ValaDeclarationStatement* stmt);
static gboolean vala_flow_analyzer_unreachable (ValaFlowAnalyzer* self, ValaCodeNode* node);
ValaSymbol* vala_declaration_statement_get_declaration (ValaDeclarationStatement* self);
void vala_code_node_set_unreachable (ValaCodeNode* self, gboolean value);
ValaExpression* vala_variable_get_initializer (ValaVariable* self);
static void vala_flow_analyzer_handle_errors (ValaFlowAnalyzer* self, ValaCodeNode* node, gboolean always_fail);
static void vala_flow_analyzer_real_visit_expression_statement (ValaCodeVisitor* base, ValaExpressionStatement* stmt);
ValaExpression* vala_expression_statement_get_expression (ValaExpressionStatement* self);
ValaExpression* vala_method_call_get_call (ValaMethodCall* self);
ValaSymbol* vala_expression_get_symbol_reference (ValaExpression* self);
GType vala_attribute_get_type (void) G_GNUC_CONST;
ValaAttribute* vala_code_node_get_attribute (ValaCodeNode* self, const gchar* name);
static gboolean vala_flow_analyzer_always_true (ValaFlowAnalyzer* self, ValaExpression* condition);
gboolean vala_boolean_literal_get_value (ValaBooleanLiteral* self);
static gboolean vala_flow_analyzer_always_false (ValaFlowAnalyzer* self, ValaExpression* condition);
static void vala_flow_analyzer_real_visit_if_statement (ValaCodeVisitor* base, ValaIfStatement* stmt);
ValaExpression* vala_if_statement_get_condition (ValaIfStatement* self);
ValaBlock* vala_if_statement_get_true_statement (ValaIfStatement* self);
void vala_code_node_accept (ValaCodeNode* self, ValaCodeVisitor* visitor);
ValaBlock* vala_if_statement_get_false_statement (ValaIfStatement* self);
static void vala_flow_analyzer_real_visit_switch_statement (ValaCodeVisitor* base, ValaSwitchStatement* stmt);
static ValaFlowAnalyzerJumpTarget* vala_flow_analyzer_jump_target_new_break_target (ValaBasicBlock* basic_block);
static ValaFlowAnalyzerJumpTarget* vala_flow_analyzer_jump_target_construct_break_target (GType object_type, ValaBasicBlock* basic_block);
ValaExpression* vala_switch_statement_get_expression (ValaSwitchStatement* self);
ValaList* vala_switch_statement_get_sections (ValaSwitchStatement* self);
GType vala_statement_get_type (void) G_GNUC_CONST;
ValaList* vala_block_get_statements (ValaBlock* self);
gboolean vala_switch_section_has_default_label (ValaSwitchSection* self);
static void vala_flow_analyzer_real_visit_loop (ValaCodeVisitor* base, ValaLoop* stmt);
static ValaFlowAnalyzerJumpTarget* vala_flow_analyzer_jump_target_new_continue_target (ValaBasicBlock* basic_block);
static ValaFlowAnalyzerJumpTarget* vala_flow_analyzer_jump_target_construct_continue_target (GType object_type, ValaBasicBlock* basic_block);
ValaBlock* vala_loop_get_body (ValaLoop* self);
static void vala_flow_analyzer_real_visit_foreach_statement (ValaCodeVisitor* base, ValaForeachStatement* stmt);
ValaExpression* vala_foreach_statement_get_collection (ValaForeachStatement* self);
ValaBlock* vala_foreach_statement_get_body (ValaForeachStatement* self);
static void vala_flow_analyzer_real_visit_break_statement (ValaCodeVisitor* base, ValaBreakStatement* stmt);
static gboolean vala_flow_analyzer_jump_target_get_is_break_target (ValaFlowAnalyzerJumpTarget* self);
static ValaBasicBlock* vala_flow_analyzer_jump_target_get_basic_block (ValaFlowAnalyzerJumpTarget* self);
static gboolean vala_flow_analyzer_jump_target_get_is_finally_clause (ValaFlowAnalyzerJumpTarget* self);
static ValaBasicBlock* vala_flow_analyzer_jump_target_get_last_block (ValaFlowAnalyzerJumpTarget* self);
static void vala_flow_analyzer_real_visit_continue_statement (ValaCodeVisitor* base, ValaContinueStatement* stmt);
static gboolean vala_flow_analyzer_jump_target_get_is_continue_target (ValaFlowAnalyzerJumpTarget* self);
static void vala_flow_analyzer_real_visit_return_statement (ValaCodeVisitor* base, ValaReturnStatement* stmt);
ValaExpression* vala_return_statement_get_return_expression (ValaReturnStatement* self);
static gboolean vala_flow_analyzer_jump_target_get_is_return_target (ValaFlowAnalyzerJumpTarget* self);
gboolean vala_code_node_get_tree_can_fail (ValaCodeNode* self);
ValaList* vala_code_node_get_error_types (ValaCodeNode* self);
GType vala_reference_type_get_type (void) G_GNUC_CONST;
GType vala_error_type_get_type (void) G_GNUC_CONST;
ValaTypeSymbol* vala_data_type_get_data_type (ValaDataType* self);
static gboolean vala_flow_analyzer_jump_target_get_is_exit_target (ValaFlowAnalyzerJumpTarget* self);
static gboolean vala_flow_analyzer_jump_target_get_is_error_target (ValaFlowAnalyzerJumpTarget* self);
static ValaErrorDomain* vala_flow_analyzer_jump_target_get_error_domain (ValaFlowAnalyzerJumpTarget* self);
ValaErrorDomain* vala_error_type_get_error_domain (ValaErrorType* self);
static ValaErrorCode* vala_flow_analyzer_jump_target_get_error_code (ValaFlowAnalyzerJumpTarget* self);
ValaErrorCode* vala_error_type_get_error_code (ValaErrorType* self);
static ValaClass* vala_flow_analyzer_jump_target_get_error_class (ValaFlowAnalyzerJumpTarget* self);
gboolean vala_typesymbol_is_subtype_of (ValaTypeSymbol* self, ValaTypeSymbol* t);
static void vala_flow_analyzer_real_visit_yield_statement (ValaCodeVisitor* base, ValaYieldStatement* stmt);
static void vala_flow_analyzer_real_visit_throw_statement (ValaCodeVisitor* base, ValaThrowStatement* stmt);
static void vala_flow_analyzer_real_visit_try_statement (ValaCodeVisitor* base, ValaTryStatement* stmt);
ValaBlock* vala_try_statement_get_finally_body (ValaTryStatement* self);
static ValaFlowAnalyzerJumpTarget* vala_flow_analyzer_jump_target_new_any_target (ValaBasicBlock* basic_block);
static ValaFlowAnalyzerJumpTarget* vala_flow_analyzer_jump_target_construct_any_target (GType object_type, ValaBasicBlock* basic_block);
static ValaFlowAnalyzerJumpTarget* vala_flow_analyzer_jump_target_new_finally_clause (ValaBasicBlock* basic_block, ValaBasicBlock* last_block);
static ValaFlowAnalyzerJumpTarget* vala_flow_analyzer_jump_target_construct_finally_clause (GType object_type, ValaBasicBlock* basic_block, ValaBasicBlock* last_block);
ValaList* vala_try_statement_get_catch_clauses (ValaTryStatement* self);
ValaDataType* vala_catch_clause_get_error_type (ValaCatchClause* self);
static ValaFlowAnalyzerJumpTarget* vala_flow_analyzer_jump_target_new_error_target (ValaBasicBlock* basic_block, ValaCatchClause* catch_clause, ValaErrorDomain* error_domain, ValaErrorCode* error_code, ValaClass* error_class);
static ValaFlowAnalyzerJumpTarget* vala_flow_analyzer_jump_target_construct_error_target (GType object_type, ValaBasicBlock* basic_block, ValaCatchClause* catch_clause, ValaErrorDomain* error_domain, ValaErrorCode* error_code, ValaClass* error_class);
ValaBlock* vala_try_statement_get_body (ValaTryStatement* self);
static ValaCatchClause* vala_flow_analyzer_jump_target_get_catch_clause (ValaFlowAnalyzerJumpTarget* self);
ValaBlock* vala_catch_clause_get_body (ValaCatchClause* self);
void vala_try_statement_set_after_try_block_reachable (ValaTryStatement* self, gboolean value);
static void vala_flow_analyzer_real_visit_lock_statement (ValaCodeVisitor* base, ValaLockStatement* stmt);
static void vala_flow_analyzer_real_visit_unlock_statement (ValaCodeVisitor* base, ValaUnlockStatement* stmt);
static void vala_flow_analyzer_real_visit_expression (ValaCodeVisitor* base, ValaExpression* expr);
#define VALA_FLOW_ANALYZER_JUMP_TARGET_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), VALA_FLOW_ANALYZER_TYPE_JUMP_TARGET, ValaFlowAnalyzerJumpTargetPrivate))
enum  {
      VALA_FLOW_ANALYZER_JUMP_TARGET_DUMMY_PROPERTY
};
static void vala_flow_analyzer_jump_target_set_basic_block (ValaFlowAnalyzerJumpTarget* self, ValaBasicBlock* value);
static void vala_flow_analyzer_jump_target_set_is_break_target (ValaFlowAnalyzerJumpTarget* self, gboolean value);
static void vala_flow_analyzer_jump_target_set_is_continue_target (ValaFlowAnalyzerJumpTarget* self, gboolean value);
static void vala_flow_analyzer_jump_target_set_is_return_target (ValaFlowAnalyzerJumpTarget* self, gboolean value);
static void vala_flow_analyzer_jump_target_set_is_exit_target (ValaFlowAnalyzerJumpTarget* self, gboolean value);
static void vala_flow_analyzer_jump_target_set_catch_clause (ValaFlowAnalyzerJumpTarget* self, ValaCatchClause* value);
static void vala_flow_analyzer_jump_target_set_error_domain (ValaFlowAnalyzerJumpTarget* self, ValaErrorDomain* value);
static void vala_flow_analyzer_jump_target_set_error_code (ValaFlowAnalyzerJumpTarget* self, ValaErrorCode* value);
static void vala_flow_analyzer_jump_target_set_error_class (ValaFlowAnalyzerJumpTarget* self, ValaClass* value);
static void vala_flow_analyzer_jump_target_set_is_error_target (ValaFlowAnalyzerJumpTarget* self, gboolean value);
static void vala_flow_analyzer_jump_target_set_last_block (ValaFlowAnalyzerJumpTarget* self, ValaBasicBlock* value);
static void vala_flow_analyzer_jump_target_set_is_finally_clause (ValaFlowAnalyzerJumpTarget* self, gboolean value);
static ValaFlowAnalyzerJumpTarget* vala_flow_analyzer_jump_target_new (void);
static ValaFlowAnalyzerJumpTarget* vala_flow_analyzer_jump_target_construct (GType object_type);
static void vala_flow_analyzer_jump_target_finalize (ValaFlowAnalyzerJumpTarget* obj);
static void vala_flow_analyzer_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);


ValaFlowAnalyzer* vala_flow_analyzer_construct (GType object_type) {
      ValaFlowAnalyzer* self = NULL;
      self = (ValaFlowAnalyzer*) vala_code_visitor_construct (object_type);
      return self;
}


ValaFlowAnalyzer* vala_flow_analyzer_new (void) {
      return vala_flow_analyzer_construct (VALA_TYPE_FLOW_ANALYZER);
}


/**
 * Build control flow graph in the specified context.
 *
 * @param context a code context
 */
static gpointer _vala_code_context_ref0 (gpointer self) {
      return self ? vala_code_context_ref (self) : NULL;
}


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


void vala_flow_analyzer_analyze (ValaFlowAnalyzer* self, ValaCodeContext* context) {
      ValaCodeContext* _tmp0_;
      ValaList* _tmp1_ = NULL;
      ValaList* source_files;
      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_;
      _tmp1_ = vala_code_context_get_source_files (context);
      source_files = _tmp1_;
      {
            ValaList* _tmp2_;
            ValaList* _file_list;
            gint _tmp3_;
            gint _file_size;
            gint _file_index;
            _tmp2_ = _vala_iterable_ref0 (source_files);
            _file_list = _tmp2_;
            _tmp3_ = vala_collection_get_size ((ValaCollection*) _file_list);
            _file_size = _tmp3_;
            _file_index = -1;
            while (TRUE) {
                  gpointer _tmp4_ = NULL;
                  ValaSourceFile* file;
                  ValaSourceFileType _tmp5_;
                  _file_index = _file_index + 1;
                  if (!(_file_index < _file_size)) {
                        break;
                  }
                  _tmp4_ = vala_list_get (_file_list, _file_index);
                  file = (ValaSourceFile*) _tmp4_;
                  _tmp5_ = vala_source_file_get_file_type (file);
                  if (_tmp5_ == VALA_SOURCE_FILE_TYPE_SOURCE) {
                        vala_source_file_accept (file, (ValaCodeVisitor*) self);
                  }
                  _vala_source_file_unref0 (file);
            }
            _vala_iterable_unref0 (_file_list);
      }
      _vala_iterable_unref0 (source_files);
}


static void vala_flow_analyzer_real_visit_source_file (ValaCodeVisitor* base, ValaSourceFile* source_file) {
      ValaFlowAnalyzer * self;
      self = (ValaFlowAnalyzer*) base;
      g_return_if_fail (source_file != NULL);
      vala_source_file_accept_children (source_file, (ValaCodeVisitor*) self);
}


static void vala_flow_analyzer_real_visit_class (ValaCodeVisitor* base, ValaClass* cl) {
      ValaFlowAnalyzer * self;
      self = (ValaFlowAnalyzer*) base;
      g_return_if_fail (cl != NULL);
      vala_code_node_accept_children ((ValaCodeNode*) cl, (ValaCodeVisitor*) self);
}


static void vala_flow_analyzer_real_visit_struct (ValaCodeVisitor* base, ValaStruct* st) {
      ValaFlowAnalyzer * self;
      self = (ValaFlowAnalyzer*) base;
      g_return_if_fail (st != NULL);
      vala_code_node_accept_children ((ValaCodeNode*) st, (ValaCodeVisitor*) self);
}


static void vala_flow_analyzer_real_visit_interface (ValaCodeVisitor* base, ValaInterface* iface) {
      ValaFlowAnalyzer * self;
      self = (ValaFlowAnalyzer*) base;
      g_return_if_fail (iface != NULL);
      vala_code_node_accept_children ((ValaCodeNode*) iface, (ValaCodeVisitor*) self);
}


static void vala_flow_analyzer_real_visit_enum (ValaCodeVisitor* base, ValaEnum* en) {
      ValaFlowAnalyzer * self;
      self = (ValaFlowAnalyzer*) base;
      g_return_if_fail (en != NULL);
      vala_code_node_accept_children ((ValaCodeNode*) en, (ValaCodeVisitor*) self);
}


static void vala_flow_analyzer_real_visit_error_domain (ValaCodeVisitor* base, ValaErrorDomain* ed) {
      ValaFlowAnalyzer * self;
      self = (ValaFlowAnalyzer*) base;
      g_return_if_fail (ed != NULL);
      vala_code_node_accept_children ((ValaCodeNode*) ed, (ValaCodeVisitor*) self);
}


static void vala_flow_analyzer_real_visit_field (ValaCodeVisitor* base, ValaField* f) {
      ValaFlowAnalyzer * self;
      gboolean _tmp0_ = FALSE;
      gboolean _tmp1_;
      self = (ValaFlowAnalyzer*) base;
      g_return_if_fail (f != NULL);
      _tmp1_ = vala_symbol_is_internal_symbol ((ValaSymbol*) f);
      if (_tmp1_) {
            gboolean _tmp2_;
            _tmp2_ = vala_symbol_get_used ((ValaSymbol*) f);
            _tmp0_ = !_tmp2_;
      } else {
            _tmp0_ = FALSE;
      }
      if (_tmp0_) {
            gboolean _tmp3_ = FALSE;
            gboolean _tmp4_;
            _tmp4_ = vala_symbol_is_private_symbol ((ValaSymbol*) f);
            if (!_tmp4_) {
                  const gchar* _tmp5_ = NULL;
                  _tmp5_ = vala_code_context_get_internal_header_filename (self->priv->context);
                  _tmp3_ = _tmp5_ != NULL;
            } else {
                  _tmp3_ = FALSE;
            }
            if (_tmp3_) {
            } else {
                  ValaSourceReference* _tmp6_ = NULL;
                  gchar* _tmp7_ = NULL;
                  gchar* _tmp8_;
                  gchar* _tmp9_ = NULL;
                  gchar* _tmp10_;
                  _tmp6_ = vala_code_node_get_source_reference ((ValaCodeNode*) f);
                  _tmp7_ = vala_symbol_get_full_name ((ValaSymbol*) f);
                  _tmp8_ = _tmp7_;
                  _tmp9_ = g_strdup_printf ("field `%s' never used", _tmp8_);
                  _tmp10_ = _tmp9_;
                  vala_report_warning (_tmp6_, _tmp10_);
                  _g_free0 (_tmp10_);
                  _g_free0 (_tmp8_);
            }
      }
}


static gpointer _vala_basic_block_ref0 (gpointer self) {
      return self ? vala_basic_block_ref (self) : NULL;
}


static void vala_flow_analyzer_real_visit_lambda_expression (ValaCodeVisitor* base, ValaLambdaExpression* le) {
      ValaFlowAnalyzer * self;
      ValaBasicBlock* _tmp0_;
      ValaBasicBlock* old_current_block;
      gboolean old_unreachable_reported;
      ValaList* _tmp1_;
      ValaList* old_jump_stack;
      ValaArrayList* _tmp2_ = NULL;
      ValaBasicBlock* _tmp3_;
      ValaList* _tmp4_;
      self = (ValaFlowAnalyzer*) base;
      g_return_if_fail (le != NULL);
      _tmp0_ = _vala_basic_block_ref0 (self->priv->current_block);
      old_current_block = _tmp0_;
      old_unreachable_reported = self->priv->unreachable_reported;
      _tmp1_ = _vala_iterable_ref0 (self->priv->jump_stack);
      old_jump_stack = _tmp1_;
      vala_flow_analyzer_mark_unreachable (self);
      _tmp2_ = vala_array_list_new (VALA_FLOW_ANALYZER_TYPE_JUMP_TARGET, (GBoxedCopyFunc) vala_flow_analyzer_jump_target_ref, vala_flow_analyzer_jump_target_unref, g_direct_equal);
      _vala_iterable_unref0 (self->priv->jump_stack);
      self->priv->jump_stack = (ValaList*) _tmp2_;
      vala_code_node_accept_children ((ValaCodeNode*) le, (ValaCodeVisitor*) self);
      _tmp3_ = _vala_basic_block_ref0 (old_current_block);
      _vala_basic_block_unref0 (self->priv->current_block);
      self->priv->current_block = _tmp3_;
      self->priv->unreachable_reported = old_unreachable_reported;
      _tmp4_ = _vala_iterable_ref0 (old_jump_stack);
      _vala_iterable_unref0 (self->priv->jump_stack);
      self->priv->jump_stack = _tmp4_;
      _vala_iterable_unref0 (old_jump_stack);
      _vala_basic_block_unref0 (old_current_block);
}


static void vala_flow_analyzer_real_visit_method (ValaCodeVisitor* base, ValaMethod* m) {
      ValaFlowAnalyzer * self;
      gboolean _tmp0_ = FALSE;
      gboolean _tmp1_ = FALSE;
      gboolean _tmp2_ = FALSE;
      gboolean _tmp3_ = FALSE;
      gboolean _tmp4_ = FALSE;
      gboolean _tmp5_;
      self = (ValaFlowAnalyzer*) base;
      g_return_if_fail (m != NULL);
      _tmp5_ = vala_symbol_is_internal_symbol ((ValaSymbol*) m);
      if (_tmp5_) {
            gboolean _tmp6_;
            _tmp6_ = vala_symbol_get_used ((ValaSymbol*) m);
            _tmp4_ = !_tmp6_;
      } else {
            _tmp4_ = FALSE;
      }
      if (_tmp4_) {
            gboolean _tmp7_;
            _tmp7_ = vala_method_get_entry_point (m);
            _tmp3_ = !_tmp7_;
      } else {
            _tmp3_ = FALSE;
      }
      if (_tmp3_) {
            gboolean _tmp8_;
            _tmp8_ = vala_method_get_overrides (m);
            _tmp2_ = !_tmp8_;
      } else {
            _tmp2_ = FALSE;
      }
      if (_tmp2_) {
            gboolean _tmp9_ = FALSE;
            ValaMethod* _tmp10_ = NULL;
            _tmp10_ = vala_method_get_base_interface_method (m);
            if (_tmp10_ == NULL) {
                  _tmp9_ = TRUE;
            } else {
                  ValaMethod* _tmp11_ = NULL;
                  _tmp11_ = vala_method_get_base_interface_method (m);
                  _tmp9_ = _tmp11_ == m;
            }
            _tmp1_ = _tmp9_;
      } else {
            _tmp1_ = FALSE;
      }
      if (_tmp1_) {
            _tmp0_ = !VALA_IS_CREATION_METHOD (m);
      } else {
            _tmp0_ = FALSE;
      }
      if (_tmp0_) {
            gboolean _tmp12_ = FALSE;
            gboolean _tmp13_;
            _tmp13_ = vala_symbol_is_private_symbol ((ValaSymbol*) m);
            if (!_tmp13_) {
                  const gchar* _tmp14_ = NULL;
                  _tmp14_ = vala_code_context_get_internal_header_filename (self->priv->context);
                  _tmp12_ = _tmp14_ != NULL;
            } else {
                  _tmp12_ = FALSE;
            }
            if (_tmp12_) {
            } else {
                  ValaSourceReference* _tmp15_ = NULL;
                  gchar* _tmp16_ = NULL;
                  gchar* _tmp17_;
                  gchar* _tmp18_ = NULL;
                  gchar* _tmp19_;
                  _tmp15_ = vala_code_node_get_source_reference ((ValaCodeNode*) m);
                  _tmp16_ = vala_symbol_get_full_name ((ValaSymbol*) m);
                  _tmp17_ = _tmp16_;
                  _tmp18_ = g_strdup_printf ("method `%s' never used", _tmp17_);
                  _tmp19_ = _tmp18_;
                  vala_report_warning (_tmp15_, _tmp19_);
                  _g_free0 (_tmp19_);
                  _g_free0 (_tmp17_);
            }
      }
      vala_flow_analyzer_visit_subroutine (self, (ValaSubroutine*) m);
}


static void vala_flow_analyzer_real_visit_signal (ValaCodeVisitor* base, ValaSignal* sig) {
      ValaFlowAnalyzer * self;
      ValaMethod* _tmp0_ = NULL;
      self = (ValaFlowAnalyzer*) base;
      g_return_if_fail (sig != NULL);
      _tmp0_ = vala_signal_get_default_handler (sig);
      if (_tmp0_ != NULL) {
            ValaMethod* _tmp1_ = NULL;
            _tmp1_ = vala_signal_get_default_handler (sig);
            vala_flow_analyzer_visit_subroutine (self, (ValaSubroutine*) _tmp1_);
      }
}


static void vala_flow_analyzer_visit_subroutine (ValaFlowAnalyzer* self, ValaSubroutine* m) {
      ValaBlock* _tmp0_ = NULL;
      ValaBasicBlock* _tmp1_ = NULL;
      ValaBasicBlock* _tmp2_;
      ValaBasicBlock* _tmp3_ = NULL;
      ValaBasicBlock* _tmp4_;
      ValaBasicBlock* _tmp5_ = NULL;
      ValaBasicBlock* _tmp6_;
      ValaBasicBlock* _tmp7_ = NULL;
      ValaBasicBlock* _tmp8_ = NULL;
      gboolean _tmp9_ = FALSE;
      ValaProfile _tmp10_;
      ValaBasicBlock* _tmp16_ = NULL;
      ValaBasicBlock* _tmp17_ = NULL;
      ValaBasicBlock* _tmp18_ = NULL;
      ValaFlowAnalyzerJumpTarget* _tmp19_ = NULL;
      ValaFlowAnalyzerJumpTarget* _tmp20_;
      ValaBasicBlock* _tmp21_ = NULL;
      ValaFlowAnalyzerJumpTarget* _tmp22_ = NULL;
      ValaFlowAnalyzerJumpTarget* _tmp23_;
      gint _tmp24_;
      ValaBasicBlock* _tmp30_ = NULL;
      g_return_if_fail (self != NULL);
      g_return_if_fail (m != NULL);
      _tmp0_ = vala_subroutine_get_body (m);
      if (_tmp0_ == NULL) {
            return;
      }
      _tmp1_ = vala_basic_block_new_entry ();
      _tmp2_ = _tmp1_;
      vala_subroutine_set_entry_block (m, _tmp2_);
      _vala_basic_block_unref0 (_tmp2_);
      _tmp3_ = vala_basic_block_new ();
      _tmp4_ = _tmp3_;
      vala_subroutine_set_return_block (m, _tmp4_);
      _vala_basic_block_unref0 (_tmp4_);
      _tmp5_ = vala_basic_block_new_exit ();
      _tmp6_ = _tmp5_;
      vala_subroutine_set_exit_block (m, _tmp6_);
      _vala_basic_block_unref0 (_tmp6_);
      _tmp7_ = vala_subroutine_get_return_block (m);
      _tmp8_ = vala_subroutine_get_exit_block (m);
      vala_basic_block_connect (_tmp7_, _tmp8_);
      _tmp10_ = vala_code_context_get_profile (self->priv->context);
      if (_tmp10_ == VALA_PROFILE_DOVA) {
            ValaLocalVariable* _tmp11_ = NULL;
            _tmp11_ = vala_subroutine_get_result_var (m);
            _tmp9_ = _tmp11_ != NULL;
      } else {
            _tmp9_ = FALSE;
      }
      if (_tmp9_) {
            ValaSourceReference* _tmp12_ = NULL;
            ValaMemberAccess* _tmp13_ = NULL;
            ValaMemberAccess* result_ma;
            ValaLocalVariable* _tmp14_ = NULL;
            ValaBasicBlock* _tmp15_ = NULL;
            _tmp12_ = vala_code_node_get_source_reference ((ValaCodeNode*) m);
            _tmp13_ = vala_member_access_new_simple ("result", _tmp12_);
            result_ma = _tmp13_;
            _tmp14_ = vala_subroutine_get_result_var (m);
            vala_expression_set_symbol_reference ((ValaExpression*) result_ma, (ValaSymbol*) _tmp14_);
            _tmp15_ = vala_subroutine_get_return_block (m);
            vala_basic_block_add_node (_tmp15_, (ValaCodeNode*) result_ma);
            _vala_code_node_unref0 (result_ma);
      }
      _tmp16_ = vala_basic_block_new ();
      _vala_basic_block_unref0 (self->priv->current_block);
      self->priv->current_block = _tmp16_;
      _tmp17_ = vala_subroutine_get_entry_block (m);
      vala_basic_block_connect (_tmp17_, self->priv->current_block);
      vala_basic_block_add_node (self->priv->current_block, (ValaCodeNode*) m);
      _tmp18_ = vala_subroutine_get_return_block (m);
      _tmp19_ = vala_flow_analyzer_jump_target_new_return_target (_tmp18_);
      _tmp20_ = _tmp19_;
      vala_collection_add ((ValaCollection*) self->priv->jump_stack, _tmp20_);
      _vala_flow_analyzer_jump_target_unref0 (_tmp20_);
      _tmp21_ = vala_subroutine_get_exit_block (m);
      _tmp22_ = vala_flow_analyzer_jump_target_new_exit_target (_tmp21_);
      _tmp23_ = _tmp22_;
      vala_collection_add ((ValaCollection*) self->priv->jump_stack, _tmp23_);
      _vala_flow_analyzer_jump_target_unref0 (_tmp23_);
      vala_code_node_accept_children ((ValaCodeNode*) m, (ValaCodeVisitor*) self);
      _tmp24_ = vala_collection_get_size ((ValaCollection*) self->priv->jump_stack);
      vala_list_remove_at (self->priv->jump_stack, _tmp24_ - 1);
      if (self->priv->current_block != NULL) {
            gboolean _tmp25_ = FALSE;
            ValaProfile _tmp26_;
            ValaBasicBlock* _tmp29_ = NULL;
            _tmp26_ = vala_code_context_get_profile (self->priv->context);
            if (_tmp26_ != VALA_PROFILE_DOVA) {
                  gboolean _tmp27_;
                  _tmp27_ = vala_subroutine_get_has_result (m);
                  _tmp25_ = _tmp27_;
            } else {
                  _tmp25_ = FALSE;
            }
            if (_tmp25_) {
                  ValaSourceReference* _tmp28_ = NULL;
                  _tmp28_ = vala_code_node_get_source_reference ((ValaCodeNode*) m);
                  vala_report_error (_tmp28_, "missing return statement at end of subroutine body");
                  vala_code_node_set_error ((ValaCodeNode*) m, TRUE);
            }
            _tmp29_ = vala_subroutine_get_return_block (m);
            vala_basic_block_connect (self->priv->current_block, _tmp29_);
      }
      _tmp30_ = vala_subroutine_get_entry_block (m);
      vala_flow_analyzer_analyze_body (self, _tmp30_);
}


static void vala_flow_analyzer_analyze_body (ValaFlowAnalyzer* self, ValaBasicBlock* entry_block) {
      ValaList* _tmp0_ = NULL;
      ValaList* block_list;
      g_return_if_fail (self != NULL);
      g_return_if_fail (entry_block != NULL);
      _tmp0_ = vala_flow_analyzer_get_depth_first_list (self, entry_block);
      block_list = _tmp0_;
      vala_flow_analyzer_build_dominator_tree (self, block_list, entry_block);
      vala_flow_analyzer_build_dominator_frontier (self, block_list, entry_block);
      vala_flow_analyzer_insert_phi_functions (self, block_list, entry_block);
      vala_flow_analyzer_check_variables (self, entry_block);
      _vala_iterable_unref0 (block_list);
}


static ValaList* vala_flow_analyzer_get_depth_first_list (ValaFlowAnalyzer* self, ValaBasicBlock* entry_block) {
      ValaList* result = NULL;
      ValaArrayList* _tmp0_ = NULL;
      ValaArrayList* list;
      g_return_val_if_fail (self != NULL, NULL);
      g_return_val_if_fail (entry_block != NULL, NULL);
      _tmp0_ = vala_array_list_new (VALA_TYPE_BASIC_BLOCK, (GBoxedCopyFunc) vala_basic_block_ref, vala_basic_block_unref, g_direct_equal);
      list = _tmp0_;
      vala_flow_analyzer_depth_first_traverse (self, entry_block, (ValaList*) list);
      result = (ValaList*) list;
      return result;
}


static void vala_flow_analyzer_depth_first_traverse (ValaFlowAnalyzer* self, ValaBasicBlock* current, ValaList* list) {
      gboolean _tmp0_;
      gint _tmp5_;
      g_return_if_fail (self != NULL);
      g_return_if_fail (current != NULL);
      g_return_if_fail (list != NULL);
      _tmp0_ = vala_basic_block_get_postorder_visited (current);
      if (_tmp0_) {
            return;
      }
      vala_basic_block_set_postorder_visited (current, TRUE);
      {
            ValaList* _tmp1_ = NULL;
            ValaList* _succ_list;
            gint _tmp2_;
            gint _succ_size;
            gint _succ_index;
            _tmp1_ = vala_basic_block_get_successors (current);
            _succ_list = _tmp1_;
            _tmp2_ = vala_collection_get_size ((ValaCollection*) _succ_list);
            _succ_size = _tmp2_;
            _succ_index = -1;
            while (TRUE) {
                  gpointer _tmp3_ = NULL;
                  ValaBasicBlock* _tmp4_;
                  ValaBasicBlock* succ;
                  _succ_index = _succ_index + 1;
                  if (!(_succ_index < _succ_size)) {
                        break;
                  }
                  _tmp3_ = vala_list_get (_succ_list, _succ_index);
                  _tmp4_ = _vala_basic_block_ref0 ((ValaBasicBlock*) _tmp3_);
                  succ = _tmp4_;
                  vala_flow_analyzer_depth_first_traverse (self, succ, list);
                  _vala_basic_block_unref0 (succ);
            }
            _vala_iterable_unref0 (_succ_list);
      }
      _tmp5_ = vala_collection_get_size ((ValaCollection*) list);
      vala_basic_block_set_postorder_number (current, _tmp5_);
      vala_list_insert (list, 0, current);
}


static void vala_flow_analyzer_build_dominator_tree (ValaFlowAnalyzer* self, ValaList* block_list, ValaBasicBlock* entry_block) {
      gint _tmp0_;
      ValaBasicBlock** _tmp1_ = NULL;
      ValaBasicBlock** idoms;
      gint idoms_length1;
      gint _idoms_size_;
      gint _tmp2_;
      ValaBasicBlock* _tmp3_;
      ValaBasicBlock* _tmp4_;
      gboolean changed;
      g_return_if_fail (self != NULL);
      g_return_if_fail (block_list != NULL);
      g_return_if_fail (entry_block != NULL);
      _tmp0_ = vala_collection_get_size ((ValaCollection*) block_list);
      _tmp1_ = g_new0 (ValaBasicBlock*, _tmp0_ + 1);
      idoms = _tmp1_;
      idoms_length1 = _tmp0_;
      _idoms_size_ = _tmp0_;
      _tmp2_ = vala_basic_block_get_postorder_number (entry_block);
      _tmp3_ = _vala_basic_block_ref0 (entry_block);
      _tmp4_ = _tmp3_;
      _vala_basic_block_unref0 (idoms[_tmp2_]);
      idoms[_tmp2_] = _tmp4_;
      changed = TRUE;
      while (TRUE) {
            if (!changed) {
                  break;
            }
            changed = FALSE;
            {
                  ValaList* _tmp5_;
                  ValaList* _block_list;
                  gint _tmp6_;
                  gint _block_size;
                  gint _block_index;
                  _tmp5_ = _vala_iterable_ref0 (block_list);
                  _block_list = _tmp5_;
                  _tmp6_ = vala_collection_get_size ((ValaCollection*) _block_list);
                  _block_size = _tmp6_;
                  _block_index = -1;
                  while (TRUE) {
                        gpointer _tmp7_ = NULL;
                        ValaBasicBlock* block;
                        ValaBasicBlock* new_idom;
                        gboolean first;
                        gint _tmp15_;
                        _block_index = _block_index + 1;
                        if (!(_block_index < _block_size)) {
                              break;
                        }
                        _tmp7_ = vala_list_get (_block_list, _block_index);
                        block = (ValaBasicBlock*) _tmp7_;
                        if (block == entry_block) {
                              _vala_basic_block_unref0 (block);
                              continue;
                        }
                        new_idom = NULL;
                        first = TRUE;
                        {
                              ValaList* _tmp8_ = NULL;
                              ValaList* _pred_list;
                              gint _tmp9_;
                              gint _pred_size;
                              gint _pred_index;
                              _tmp8_ = vala_basic_block_get_predecessors (block);
                              _pred_list = _tmp8_;
                              _tmp9_ = vala_collection_get_size ((ValaCollection*) _pred_list);
                              _pred_size = _tmp9_;
                              _pred_index = -1;
                              while (TRUE) {
                                    gpointer _tmp10_ = NULL;
                                    ValaBasicBlock* _tmp11_;
                                    ValaBasicBlock* pred;
                                    gint _tmp12_;
                                    _pred_index = _pred_index + 1;
                                    if (!(_pred_index < _pred_size)) {
                                          break;
                                    }
                                    _tmp10_ = vala_list_get (_pred_list, _pred_index);
                                    _tmp11_ = _vala_basic_block_ref0 ((ValaBasicBlock*) _tmp10_);
                                    pred = _tmp11_;
                                    _tmp12_ = vala_basic_block_get_postorder_number (pred);
                                    if (idoms[_tmp12_] != NULL) {
                                          if (first) {
                                                ValaBasicBlock* _tmp13_;
                                                _tmp13_ = _vala_basic_block_ref0 (pred);
                                                _vala_basic_block_unref0 (new_idom);
                                                new_idom = _tmp13_;
                                                first = FALSE;
                                          } else {
                                                ValaBasicBlock* _tmp14_ = NULL;
                                                _tmp14_ = vala_flow_analyzer_intersect (self, idoms, idoms_length1, pred, new_idom);
                                                _vala_basic_block_unref0 (new_idom);
                                                new_idom = _tmp14_;
                                          }
                                    }
                                    _vala_basic_block_unref0 (pred);
                              }
                              _vala_iterable_unref0 (_pred_list);
                        }
                        _tmp15_ = vala_basic_block_get_postorder_number (block);
                        if (idoms[_tmp15_] != new_idom) {
                              gint _tmp16_;
                              ValaBasicBlock* _tmp17_;
                              ValaBasicBlock* _tmp18_;
                              _tmp16_ = vala_basic_block_get_postorder_number (block);
                              _tmp17_ = _vala_basic_block_ref0 (new_idom);
                              _tmp18_ = _tmp17_;
                              _vala_basic_block_unref0 (idoms[_tmp16_]);
                              idoms[_tmp16_] = _tmp18_;
                              changed = TRUE;
                        }
                        _vala_basic_block_unref0 (new_idom);
                        _vala_basic_block_unref0 (block);
                  }
                  _vala_iterable_unref0 (_block_list);
            }
      }
      {
            ValaList* _tmp19_;
            ValaList* _block_list;
            gint _tmp20_;
            gint _block_size;
            gint _block_index;
            _tmp19_ = _vala_iterable_ref0 (block_list);
            _block_list = _tmp19_;
            _tmp20_ = vala_collection_get_size ((ValaCollection*) _block_list);
            _block_size = _tmp20_;
            _block_index = -1;
            while (TRUE) {
                  gpointer _tmp21_ = NULL;
                  ValaBasicBlock* block;
                  gint _tmp22_;
                  _block_index = _block_index + 1;
                  if (!(_block_index < _block_size)) {
                        break;
                  }
                  _tmp21_ = vala_list_get (_block_list, _block_index);
                  block = (ValaBasicBlock*) _tmp21_;
                  if (block == entry_block) {
                        _vala_basic_block_unref0 (block);
                        continue;
                  }
                  _tmp22_ = vala_basic_block_get_postorder_number (block);
                  vala_basic_block_add_child (idoms[_tmp22_], block);
                  _vala_basic_block_unref0 (block);
            }
            _vala_iterable_unref0 (_block_list);
      }
      idoms = (_vala_array_free (idoms, idoms_length1, (GDestroyNotify) vala_basic_block_unref), NULL);
}


static ValaBasicBlock* vala_flow_analyzer_intersect (ValaFlowAnalyzer* self, ValaBasicBlock** idoms, int idoms_length1, ValaBasicBlock* b1, ValaBasicBlock* b2) {
      ValaBasicBlock* result = NULL;
      ValaBasicBlock* _tmp6_;
      g_return_val_if_fail (self != NULL, NULL);
      g_return_val_if_fail (b1 != NULL, NULL);
      g_return_val_if_fail (b2 != NULL, NULL);
      while (TRUE) {
            if (!(b1 != b2)) {
                  break;
            }
            while (TRUE) {
                  gint _tmp0_;
                  gint _tmp1_;
                  gint _tmp2_;
                  _tmp0_ = vala_basic_block_get_postorder_number (b1);
                  _tmp1_ = vala_basic_block_get_postorder_number (b2);
                  if (!(_tmp0_ < _tmp1_)) {
                        break;
                  }
                  _tmp2_ = vala_basic_block_get_postorder_number (b2);
                  b1 = idoms[_tmp2_];
            }
            while (TRUE) {
                  gint _tmp3_;
                  gint _tmp4_;
                  gint _tmp5_;
                  _tmp3_ = vala_basic_block_get_postorder_number (b2);
                  _tmp4_ = vala_basic_block_get_postorder_number (b1);
                  if (!(_tmp3_ < _tmp4_)) {
                        break;
                  }
                  _tmp5_ = vala_basic_block_get_postorder_number (b2);
                  b2 = idoms[_tmp5_];
            }
      }
      _tmp6_ = _vala_basic_block_ref0 (b1);
      result = _tmp6_;
      return result;
}


static void vala_flow_analyzer_build_dominator_frontier (ValaFlowAnalyzer* self, ValaList* block_list, ValaBasicBlock* entry_block) {
      g_return_if_fail (self != NULL);
      g_return_if_fail (block_list != NULL);
      g_return_if_fail (entry_block != NULL);
      {
            gint _tmp0_;
            gint i;
            _tmp0_ = vala_collection_get_size ((ValaCollection*) block_list);
            i = _tmp0_ - 1;
            {
                  gboolean _tmp1_;
                  _tmp1_ = TRUE;
                  while (TRUE) {
                        gpointer _tmp2_ = NULL;
                        ValaBasicBlock* block;
                        if (!_tmp1_) {
                              i--;
                        }
                        _tmp1_ = FALSE;
                        if (!(i >= 0)) {
                              break;
                        }
                        _tmp2_ = vala_list_get (block_list, i);
                        block = (ValaBasicBlock*) _tmp2_;
                        {
                              ValaList* _tmp3_ = NULL;
                              ValaList* _succ_list;
                              gint _tmp4_;
                              gint _succ_size;
                              gint _succ_index;
                              _tmp3_ = vala_basic_block_get_successors (block);
                              _succ_list = _tmp3_;
                              _tmp4_ = vala_collection_get_size ((ValaCollection*) _succ_list);
                              _succ_size = _tmp4_;
                              _succ_index = -1;
                              while (TRUE) {
                                    gpointer _tmp5_ = NULL;
                                    ValaBasicBlock* _tmp6_;
                                    ValaBasicBlock* succ;
                                    ValaBasicBlock* _tmp7_ = NULL;
                                    _succ_index = _succ_index + 1;
                                    if (!(_succ_index < _succ_size)) {
                                          break;
                                    }
                                    _tmp5_ = vala_list_get (_succ_list, _succ_index);
                                    _tmp6_ = _vala_basic_block_ref0 ((ValaBasicBlock*) _tmp5_);
                                    succ = _tmp6_;
                                    _tmp7_ = vala_basic_block_get_parent (succ);
                                    if (_tmp7_ != block) {
                                          vala_basic_block_add_dominator_frontier (block, succ);
                                    }
                                    _vala_basic_block_unref0 (succ);
                              }
                              _vala_iterable_unref0 (_succ_list);
                        }
                        {
                              ValaList* _tmp8_ = NULL;
                              ValaList* _child_list;
                              gint _tmp9_;
                              gint _child_size;
                              gint _child_index;
                              _tmp8_ = vala_basic_block_get_children (block);
                              _child_list = _tmp8_;
                              _tmp9_ = vala_collection_get_size ((ValaCollection*) _child_list);
                              _child_size = _tmp9_;
                              _child_index = -1;
                              while (TRUE) {
                                    gpointer _tmp10_ = NULL;
                                    ValaBasicBlock* child;
                                    _child_index = _child_index + 1;
                                    if (!(_child_index < _child_size)) {
                                          break;
                                    }
                                    _tmp10_ = vala_list_get (_child_list, _child_index);
                                    child = (ValaBasicBlock*) _tmp10_;
                                    {
                                          ValaSet* _tmp11_ = NULL;
                                          ValaSet* _tmp12_;
                                          ValaIterator* _tmp13_ = NULL;
                                          ValaIterator* _tmp14_;
                                          ValaIterator* _child_frontier_it;
                                          _tmp11_ = vala_basic_block_get_dominator_frontier (child);
                                          _tmp12_ = _tmp11_;
                                          _tmp13_ = vala_iterable_iterator ((ValaIterable*) _tmp12_);
                                          _tmp14_ = _tmp13_;
                                          _vala_iterable_unref0 (_tmp12_);
                                          _child_frontier_it = _tmp14_;
                                          while (TRUE) {
                                                gboolean _tmp15_;
                                                gpointer _tmp16_ = NULL;
                                                ValaBasicBlock* child_frontier;
                                                ValaBasicBlock* _tmp17_ = NULL;
                                                _tmp15_ = vala_iterator_next (_child_frontier_it);
                                                if (!_tmp15_) {
                                                      break;
                                                }
                                                _tmp16_ = vala_iterator_get (_child_frontier_it);
                                                child_frontier = (ValaBasicBlock*) _tmp16_;
                                                _tmp17_ = vala_basic_block_get_parent (child_frontier);
                                                if (_tmp17_ != block) {
                                                      vala_basic_block_add_dominator_frontier (block, child_frontier);
                                                }
                                                _vala_basic_block_unref0 (child_frontier);
                                          }
                                          _vala_iterator_unref0 (_child_frontier_it);
                                    }
                                    _vala_basic_block_unref0 (child);
                              }
                              _vala_iterable_unref0 (_child_list);
                        }
                        _vala_basic_block_unref0 (block);
                  }
            }
      }
}


static ValaMap* vala_flow_analyzer_get_assignment_map (ValaFlowAnalyzer* self, ValaList* block_list, ValaBasicBlock* entry_block) {
      ValaMap* result = NULL;
      ValaHashMap* _tmp0_ = NULL;
      ValaHashMap* map;
      g_return_val_if_fail (self != NULL, NULL);
      g_return_val_if_fail (block_list != NULL, NULL);
      g_return_val_if_fail (entry_block != NULL, NULL);
      _tmp0_ = vala_hash_map_new (VALA_TYPE_LOCAL_VARIABLE, (GBoxedCopyFunc) vala_code_node_ref, vala_code_node_unref, VALA_TYPE_SET, (GBoxedCopyFunc) vala_iterable_ref, vala_iterable_unref, g_direct_hash, g_direct_equal, g_direct_equal);
      map = _tmp0_;
      {
            ValaList* _tmp1_;
            ValaList* _block_list;
            gint _tmp2_;
            gint _block_size;
            gint _block_index;
            _tmp1_ = _vala_iterable_ref0 (block_list);
            _block_list = _tmp1_;
            _tmp2_ = vala_collection_get_size ((ValaCollection*) _block_list);
            _block_size = _tmp2_;
            _block_index = -1;
            while (TRUE) {
                  gpointer _tmp3_ = NULL;
                  ValaBasicBlock* block;
                  ValaArrayList* _tmp4_ = NULL;
                  ValaArrayList* defined_variables;
                  _block_index = _block_index + 1;
                  if (!(_block_index < _block_size)) {
                        break;
                  }
                  _tmp3_ = vala_list_get (_block_list, _block_index);
                  block = (ValaBasicBlock*) _tmp3_;
                  _tmp4_ = vala_array_list_new (VALA_TYPE_LOCAL_VARIABLE, (GBoxedCopyFunc) vala_code_node_ref, vala_code_node_unref, g_direct_equal);
                  defined_variables = _tmp4_;
                  {
                        ValaList* _tmp5_ = NULL;
                        ValaList* _node_list;
                        gint _tmp6_;
                        gint _node_size;
                        gint _node_index;
                        _tmp5_ = vala_basic_block_get_nodes (block);
                        _node_list = _tmp5_;
                        _tmp6_ = vala_collection_get_size ((ValaCollection*) _node_list);
                        _node_size = _tmp6_;
                        _node_index = -1;
                        while (TRUE) {
                              gpointer _tmp7_ = NULL;
                              ValaCodeNode* node;
                              _node_index = _node_index + 1;
                              if (!(_node_index < _node_size)) {
                                    break;
                              }
                              _tmp7_ = vala_list_get (_node_list, _node_index);
                              node = (ValaCodeNode*) _tmp7_;
                              vala_code_node_get_defined_variables (node, (ValaCollection*) defined_variables);
                              _vala_code_node_unref0 (node);
                        }
                        _vala_iterable_unref0 (_node_list);
                  }
                  {
                        ValaArrayList* _tmp8_;
                        ValaArrayList* _local_list;
                        gint _tmp9_;
                        gint _local_size;
                        gint _local_index;
                        _tmp8_ = _vala_iterable_ref0 (defined_variables);
                        _local_list = _tmp8_;
                        _tmp9_ = vala_collection_get_size ((ValaCollection*) _local_list);
                        _local_size = _tmp9_;
                        _local_index = -1;
                        while (TRUE) {
                              gpointer _tmp10_ = NULL;
                              ValaLocalVariable* local;
                              gpointer _tmp11_ = NULL;
                              ValaSet* block_set;
                              _local_index = _local_index + 1;
                              if (!(_local_index < _local_size)) {
                                    break;
                              }
                              _tmp10_ = vala_list_get ((ValaList*) _local_list, _local_index);
                              local = (ValaLocalVariable*) _tmp10_;
                              _tmp11_ = vala_map_get ((ValaMap*) map, local);
                              block_set = (ValaSet*) _tmp11_;
                              if (block_set == NULL) {
                                    ValaHashSet* _tmp12_ = NULL;
                                    _tmp12_ = vala_hash_set_new (VALA_TYPE_BASIC_BLOCK, (GBoxedCopyFunc) vala_basic_block_ref, vala_basic_block_unref, g_direct_hash, g_direct_equal);
                                    _vala_iterable_unref0 (block_set);
                                    block_set = (ValaSet*) _tmp12_;
                                    vala_map_set ((ValaMap*) map, local, block_set);
                              }
                              vala_collection_add ((ValaCollection*) block_set, block);
                              _vala_iterable_unref0 (block_set);
                              _vala_code_node_unref0 (local);
                        }
                        _vala_iterable_unref0 (_local_list);
                  }
                  _vala_iterable_unref0 (defined_variables);
                  _vala_basic_block_unref0 (block);
            }
            _vala_iterable_unref0 (_block_list);
      }
      result = (ValaMap*) map;
      return result;
}


static void vala_flow_analyzer_insert_phi_functions (ValaFlowAnalyzer* self, ValaList* block_list, ValaBasicBlock* entry_block) {
      ValaMap* _tmp0_ = NULL;
      ValaMap* assign;
      gint counter;
      ValaArrayList* _tmp1_ = NULL;
      ValaArrayList* work_list;
      ValaHashMap* _tmp2_ = NULL;
      ValaHashMap* added;
      ValaHashMap* _tmp3_ = NULL;
      ValaHashMap* phi;
      g_return_if_fail (self != NULL);
      g_return_if_fail (block_list != NULL);
      g_return_if_fail (entry_block != NULL);
      _tmp0_ = vala_flow_analyzer_get_assignment_map (self, block_list, entry_block);
      assign = _tmp0_;
      counter = 0;
      _tmp1_ = vala_array_list_new (VALA_TYPE_BASIC_BLOCK, (GBoxedCopyFunc) vala_basic_block_ref, vala_basic_block_unref, g_direct_equal);
      work_list = _tmp1_;
      _tmp2_ = vala_hash_map_new (VALA_TYPE_BASIC_BLOCK, (GBoxedCopyFunc) vala_basic_block_ref, vala_basic_block_unref, G_TYPE_INT, NULL, NULL, g_direct_hash, g_direct_equal, g_direct_equal);
      added = _tmp2_;
      _tmp3_ = vala_hash_map_new (VALA_TYPE_BASIC_BLOCK, (GBoxedCopyFunc) vala_basic_block_ref, vala_basic_block_unref, G_TYPE_INT, NULL, NULL, g_direct_hash, g_direct_equal, g_direct_equal);
      phi = _tmp3_;
      {
            ValaList* _tmp4_;
            ValaList* _block_list;
            gint _tmp5_;
            gint _block_size;
            gint _block_index;
            _tmp4_ = _vala_iterable_ref0 (block_list);
            _block_list = _tmp4_;
            _tmp5_ = vala_collection_get_size ((ValaCollection*) _block_list);
            _block_size = _tmp5_;
            _block_index = -1;
            while (TRUE) {
                  gpointer _tmp6_ = NULL;
                  ValaBasicBlock* block;
                  _block_index = _block_index + 1;
                  if (!(_block_index < _block_size)) {
                        break;
                  }
                  _tmp6_ = vala_list_get (_block_list, _block_index);
                  block = (ValaBasicBlock*) _tmp6_;
                  vala_map_set ((ValaMap*) added, block, GINT_TO_POINTER (0));
                  vala_map_set ((ValaMap*) phi, block, GINT_TO_POINTER (0));
                  _vala_basic_block_unref0 (block);
            }
            _vala_iterable_unref0 (_block_list);
      }
      {
            ValaSet* _tmp7_ = NULL;
            ValaSet* _tmp8_;
            ValaIterator* _tmp9_ = NULL;
            ValaIterator* _tmp10_;
            ValaIterator* _local_it;
            _tmp7_ = vala_map_get_keys (assign);
            _tmp8_ = _tmp7_;
            _tmp9_ = vala_iterable_iterator ((ValaIterable*) _tmp8_);
            _tmp10_ = _tmp9_;
            _vala_iterable_unref0 (_tmp8_);
            _local_it = _tmp10_;
            while (TRUE) {
                  gboolean _tmp11_;
                  gpointer _tmp12_ = NULL;
                  ValaLocalVariable* local;
                  _tmp11_ = vala_iterator_next (_local_it);
                  if (!_tmp11_) {
                        break;
                  }
                  _tmp12_ = vala_iterator_get (_local_it);
                  local = (ValaLocalVariable*) _tmp12_;
                  counter++;
                  {
                        gpointer _tmp13_ = NULL;
                        ValaSet* _tmp14_;
                        ValaIterator* _tmp15_ = NULL;
                        ValaIterator* _tmp16_;
                        ValaIterator* _block_it;
                        _tmp13_ = vala_map_get (assign, local);
                        _tmp14_ = (ValaSet*) _tmp13_;
                        _tmp15_ = vala_iterable_iterator ((ValaIterable*) _tmp14_);
                        _tmp16_ = _tmp15_;
                        _vala_iterable_unref0 (_tmp14_);
                        _block_it = _tmp16_;
                        while (TRUE) {
                              gboolean _tmp17_;
                              gpointer _tmp18_ = NULL;
                              ValaBasicBlock* block;
                              _tmp17_ = vala_iterator_next (_block_it);
                              if (!_tmp17_) {
                                    break;
                              }
                              _tmp18_ = vala_iterator_get (_block_it);
                              block = (ValaBasicBlock*) _tmp18_;
                              vala_collection_add ((ValaCollection*) work_list, block);
                              vala_map_set ((ValaMap*) added, block, GINT_TO_POINTER (counter));
                              _vala_basic_block_unref0 (block);
                        }
                        _vala_iterator_unref0 (_block_it);
                  }
                  while (TRUE) {
                        gint _tmp19_;
                        gpointer _tmp20_ = NULL;
                        ValaBasicBlock* block;
                        _tmp19_ = vala_collection_get_size ((ValaCollection*) work_list);
                        if (!(_tmp19_ > 0)) {
                              break;
                        }
                        _tmp20_ = vala_list_get ((ValaList*) work_list, 0);
                        block = (ValaBasicBlock*) _tmp20_;
                        vala_list_remove_at ((ValaList*) work_list, 0);
                        {
                              ValaSet* _tmp21_ = NULL;
                              ValaSet* _tmp22_;
                              ValaIterator* _tmp23_ = NULL;
                              ValaIterator* _tmp24_;
                              ValaIterator* _frontier_it;
                              _tmp21_ = vala_basic_block_get_dominator_frontier (block);
                              _tmp22_ = _tmp21_;
                              _tmp23_ = vala_iterable_iterator ((ValaIterable*) _tmp22_);
                              _tmp24_ = _tmp23_;
                              _vala_iterable_unref0 (_tmp22_);
                              _frontier_it = _tmp24_;
                              while (TRUE) {
                                    gboolean _tmp25_;
                                    gpointer _tmp26_ = NULL;
                                    ValaBasicBlock* frontier;
                                    gpointer _tmp27_ = NULL;
                                    gint blockPhi;
                                    _tmp25_ = vala_iterator_next (_frontier_it);
                                    if (!_tmp25_) {
                                          break;
                                    }
                                    _tmp26_ = vala_iterator_get (_frontier_it);
                                    frontier = (ValaBasicBlock*) _tmp26_;
                                    _tmp27_ = vala_map_get ((ValaMap*) phi, frontier);
                                    blockPhi = GPOINTER_TO_INT (_tmp27_);
                                    if (blockPhi < counter) {
                                          ValaList* _tmp28_ = NULL;
                                          ValaList* _tmp29_;
                                          gint _tmp30_;
                                          ValaPhiFunction* _tmp31_ = NULL;
                                          ValaPhiFunction* _tmp32_;
                                          gpointer _tmp33_ = NULL;
                                          gint block_added;
                                          _tmp28_ = vala_basic_block_get_predecessors (frontier);
                                          _tmp29_ = _tmp28_;
                                          _tmp30_ = vala_collection_get_size ((ValaCollection*) _tmp29_);
                                          _tmp31_ = vala_phi_function_new (local, _tmp30_);
                                          _tmp32_ = _tmp31_;
                                          vala_basic_block_add_phi_function (frontier, _tmp32_);
                                          _vala_phi_function_unref0 (_tmp32_);
                                          _vala_iterable_unref0 (_tmp29_);
                                          vala_map_set ((ValaMap*) phi, frontier, GINT_TO_POINTER (counter));
                                          _tmp33_ = vala_map_get ((ValaMap*) added, frontier);
                                          block_added = GPOINTER_TO_INT (_tmp33_);
                                          if (block_added < counter) {
                                                vala_map_set ((ValaMap*) added, frontier, GINT_TO_POINTER (counter));
                                                vala_collection_add ((ValaCollection*) work_list, frontier);
                                          }
                                    }
                                    _vala_basic_block_unref0 (frontier);
                              }
                              _vala_iterator_unref0 (_frontier_it);
                        }
                        _vala_basic_block_unref0 (block);
                  }
                  _vala_code_node_unref0 (local);
            }
            _vala_iterator_unref0 (_local_it);
      }
      _vala_map_unref0 (phi);
      _vala_map_unref0 (added);
      _vala_iterable_unref0 (work_list);
      _vala_map_unref0 (assign);
}


static void vala_flow_analyzer_check_variables (ValaFlowAnalyzer* self, ValaBasicBlock* entry_block) {
      ValaHashMap* _tmp0_ = NULL;
      ValaHashSet* _tmp1_ = NULL;
      ValaHashMap* _tmp2_ = NULL;
      ValaArrayList* _tmp3_ = NULL;
      ValaArrayList* used_vars_queue;
      g_return_if_fail (self != NULL);
      g_return_if_fail (entry_block != NULL);
      _tmp0_ = vala_hash_map_new (VALA_TYPE_SYMBOL, (GBoxedCopyFunc) vala_code_node_ref, vala_code_node_unref, VALA_TYPE_LIST, (GBoxedCopyFunc) vala_iterable_ref, vala_iterable_unref, g_direct_hash, g_direct_equal, g_direct_equal);
      _vala_map_unref0 (self->priv->var_map);
      self->priv->var_map = (ValaMap*) _tmp0_;
      _tmp1_ = vala_hash_set_new (VALA_TYPE_LOCAL_VARIABLE, (GBoxedCopyFunc) vala_code_node_ref, vala_code_node_unref, g_direct_hash, g_direct_equal);
      _vala_iterable_unref0 (self->priv->used_vars);
      self->priv->used_vars = (ValaSet*) _tmp1_;
      _tmp2_ = vala_hash_map_new (VALA_TYPE_LOCAL_VARIABLE, (GBoxedCopyFunc) vala_code_node_ref, vala_code_node_unref, VALA_TYPE_PHI_FUNCTION, (GBoxedCopyFunc) vala_phi_function_ref, vala_phi_function_unref, g_direct_hash, g_direct_equal, g_direct_equal);
      _vala_map_unref0 (self->priv->phi_functions);
      self->priv->phi_functions = (ValaMap*) _tmp2_;
      vala_flow_analyzer_check_block_variables (self, entry_block);
      _tmp3_ = vala_array_list_new (VALA_TYPE_LOCAL_VARIABLE, (GBoxedCopyFunc) vala_code_node_ref, vala_code_node_unref, g_direct_equal);
      used_vars_queue = _tmp3_;
      {
            ValaIterator* _tmp4_ = NULL;
            ValaIterator* _local_it;
            _tmp4_ = vala_iterable_iterator ((ValaIterable*) self->priv->used_vars);
            _local_it = _tmp4_;
            while (TRUE) {
                  gboolean _tmp5_;
                  gpointer _tmp6_ = NULL;
                  ValaLocalVariable* local;
                  _tmp5_ = vala_iterator_next (_local_it);
                  if (!_tmp5_) {
                        break;
                  }
                  _tmp6_ = vala_iterator_get (_local_it);
                  local = (ValaLocalVariable*) _tmp6_;
                  vala_collection_add ((ValaCollection*) used_vars_queue, local);
                  _vala_code_node_unref0 (local);
            }
            _vala_iterator_unref0 (_local_it);
      }
      while (TRUE) {
            gint _tmp7_;
            gpointer _tmp8_ = NULL;
            ValaLocalVariable* used_var;
            gpointer _tmp9_ = NULL;
            ValaPhiFunction* phi;
            _tmp7_ = vala_collection_get_size ((ValaCollection*) used_vars_queue);
            if (!(_tmp7_ > 0)) {
                  break;
            }
            _tmp8_ = vala_list_get ((ValaList*) used_vars_queue, 0);
            used_var = (ValaLocalVariable*) _tmp8_;
            vala_list_remove_at ((ValaList*) used_vars_queue, 0);
            _tmp9_ = vala_map_get (self->priv->phi_functions, used_var);
            phi = (ValaPhiFunction*) _tmp9_;
            if (phi != NULL) {
                  {
                        ValaList* _tmp10_ = NULL;
                        ValaList* _tmp11_;
                        ValaList* _local_list;
                        gint _tmp12_;
                        gint _local_size;
                        gint _local_index;
                        _tmp10_ = vala_phi_function_get_operands (phi);
                        _tmp11_ = _vala_iterable_ref0 (_tmp10_);
                        _local_list = _tmp11_;
                        _tmp12_ = vala_collection_get_size ((ValaCollection*) _local_list);
                        _local_size = _tmp12_;
                        _local_index = -1;
                        while (TRUE) {
                              gpointer _tmp13_ = NULL;
                              ValaLocalVariable* local;
                              gboolean _tmp18_;
                              _local_index = _local_index + 1;
                              if (!(_local_index < _local_size)) {
                                    break;
                              }
                              _tmp13_ = vala_list_get (_local_list, _local_index);
                              local = (ValaLocalVariable*) _tmp13_;
                              if (local == NULL) {
                                    ValaSourceReference* _tmp14_ = NULL;
                                    const gchar* _tmp15_ = NULL;
                                    gchar* _tmp16_ = NULL;
                                    gchar* _tmp17_;
                                    _tmp14_ = vala_code_node_get_source_reference ((ValaCodeNode*) used_var);
                                    _tmp15_ = vala_symbol_get_name ((ValaSymbol*) used_var);
                                    _tmp16_ = g_strdup_printf ("use of possibly unassigned local variable `%s'", _tmp15_);
                                    _tmp17_ = _tmp16_;
                                    vala_report_error (_tmp14_, _tmp17_);
                                    _g_free0 (_tmp17_);
                                    _vala_code_node_unref0 (local);
                                    continue;
                              }
                              _tmp18_ = vala_collection_contains ((ValaCollection*) self->priv->used_vars, local);
                              if (!_tmp18_) {
                                    ValaSourceReference* _tmp19_ = NULL;
                                    _tmp19_ = vala_code_node_get_source_reference ((ValaCodeNode*) used_var);
                                    vala_code_node_set_source_reference ((ValaCodeNode*) local, _tmp19_);
                                    vala_collection_add ((ValaCollection*) self->priv->used_vars, local);
                                    vala_collection_add ((ValaCollection*) used_vars_queue, local);
                              }
                              _vala_code_node_unref0 (local);
                        }
                        _vala_iterable_unref0 (_local_list);
                  }
            }
            _vala_phi_function_unref0 (phi);
            _vala_code_node_unref0 (used_var);
      }
      _vala_iterable_unref0 (used_vars_queue);
}


static void vala_flow_analyzer_check_block_variables (ValaFlowAnalyzer* self, ValaBasicBlock* block) {
      g_return_if_fail (self != NULL);
      g_return_if_fail (block != NULL);
      {
            ValaSet* _tmp0_ = NULL;
            ValaSet* _tmp1_;
            ValaIterator* _tmp2_ = NULL;
            ValaIterator* _tmp3_;
            ValaIterator* _phi_it;
            _tmp0_ = vala_basic_block_get_phi_functions (block);
            _tmp1_ = _tmp0_;
            _tmp2_ = vala_iterable_iterator ((ValaIterable*) _tmp1_);
            _tmp3_ = _tmp2_;
            _vala_iterable_unref0 (_tmp1_);
            _phi_it = _tmp3_;
            while (TRUE) {
                  gboolean _tmp4_;
                  gpointer _tmp5_ = NULL;
                  ValaPhiFunction* phi;
                  ValaLocalVariable* _tmp6_ = NULL;
                  ValaLocalVariable* _tmp7_ = NULL;
                  ValaLocalVariable* versioned_var;
                  _tmp4_ = vala_iterator_next (_phi_it);
                  if (!_tmp4_) {
                        break;
                  }
                  _tmp5_ = vala_iterator_get (_phi_it);
                  phi = (ValaPhiFunction*) _tmp5_;
                  _tmp6_ = vala_phi_function_get_original_variable (phi);
                  _tmp7_ = vala_flow_analyzer_process_assignment (self, self->priv->var_map, _tmp6_);
                  versioned_var = _tmp7_;
                  vala_map_set (self->priv->phi_functions, versioned_var, phi);
                  _vala_code_node_unref0 (versioned_var);
                  _vala_phi_function_unref0 (phi);
            }
            _vala_iterator_unref0 (_phi_it);
      }
      {
            ValaList* _tmp8_ = NULL;
            ValaList* _node_list;
            gint _tmp9_;
            gint _node_size;
            gint _node_index;
            _tmp8_ = vala_basic_block_get_nodes (block);
            _node_list = _tmp8_;
            _tmp9_ = vala_collection_get_size ((ValaCollection*) _node_list);
            _node_size = _tmp9_;
            _node_index = -1;
            while (TRUE) {
                  gpointer _tmp10_ = NULL;
                  ValaCodeNode* node;
                  ValaArrayList* _tmp11_ = NULL;
                  ValaArrayList* used_variables;
                  ValaArrayList* _tmp26_ = NULL;
                  ValaArrayList* defined_variables;
                  _node_index = _node_index + 1;
                  if (!(_node_index < _node_size)) {
                        break;
                  }
                  _tmp10_ = vala_list_get (_node_list, _node_index);
                  node = (ValaCodeNode*) _tmp10_;
                  _tmp11_ = vala_array_list_new (VALA_TYPE_LOCAL_VARIABLE, (GBoxedCopyFunc) vala_code_node_ref, vala_code_node_unref, g_direct_equal);
                  used_variables = _tmp11_;
                  vala_code_node_get_used_variables (node, (ValaCollection*) used_variables);
                  {
                        ValaArrayList* _tmp12_;
                        ValaArrayList* _var_symbol_list;
                        gint _tmp13_;
                        gint _var_symbol_size;
                        gint _var_symbol_index;
                        _tmp12_ = _vala_iterable_ref0 (used_variables);
                        _var_symbol_list = _tmp12_;
                        _tmp13_ = vala_collection_get_size ((ValaCollection*) _var_symbol_list);
                        _var_symbol_size = _tmp13_;
                        _var_symbol_index = -1;
                        while (TRUE) {
                              gpointer _tmp14_ = NULL;
                              ValaLocalVariable* var_symbol;
                              gpointer _tmp15_ = NULL;
                              ValaList* variable_stack;
                              gboolean _tmp16_ = FALSE;
                              gint _tmp22_;
                              gpointer _tmp23_ = NULL;
                              ValaLocalVariable* versioned_local;
                              gboolean _tmp24_;
                              _var_symbol_index = _var_symbol_index + 1;
                              if (!(_var_symbol_index < _var_symbol_size)) {
                                    break;
                              }
                              _tmp14_ = vala_list_get ((ValaList*) _var_symbol_list, _var_symbol_index);
                              var_symbol = (ValaLocalVariable*) _tmp14_;
                              _tmp15_ = vala_map_get (self->priv->var_map, (ValaSymbol*) var_symbol);
                              variable_stack = (ValaList*) _tmp15_;
                              if (variable_stack == NULL) {
                                    _tmp16_ = TRUE;
                              } else {
                                    gint _tmp17_;
                                    _tmp17_ = vala_collection_get_size ((ValaCollection*) variable_stack);
                                    _tmp16_ = _tmp17_ == 0;
                              }
                              if (_tmp16_) {
                                    ValaSourceReference* _tmp18_ = NULL;
                                    const gchar* _tmp19_ = NULL;
                                    gchar* _tmp20_ = NULL;
                                    gchar* _tmp21_;
                                    _tmp18_ = vala_code_node_get_source_reference (node);
                                    _tmp19_ = vala_symbol_get_name ((ValaSymbol*) var_symbol);
                                    _tmp20_ = g_strdup_printf ("use of possibly unassigned local variable `%s'", _tmp19_);
                                    _tmp21_ = _tmp20_;
                                    vala_report_error (_tmp18_, _tmp21_);
                                    _g_free0 (_tmp21_);
                                    _vala_iterable_unref0 (variable_stack);
                                    _vala_code_node_unref0 (var_symbol);
                                    continue;
                              }
                              _tmp22_ = vala_collection_get_size ((ValaCollection*) variable_stack);
                              _tmp23_ = vala_list_get (variable_stack, _tmp22_ - 1);
                              versioned_local = (ValaLocalVariable*) _tmp23_;
                              _tmp24_ = vala_collection_contains ((ValaCollection*) self->priv->used_vars, versioned_local);
                              if (!_tmp24_) {
                                    ValaSourceReference* _tmp25_ = NULL;
                                    _tmp25_ = vala_code_node_get_source_reference (node);
                                    vala_code_node_set_source_reference ((ValaCodeNode*) versioned_local, _tmp25_);
                              }
                              vala_collection_add ((ValaCollection*) self->priv->used_vars, versioned_local);
                              _vala_code_node_unref0 (versioned_local);
                              _vala_iterable_unref0 (variable_stack);
                              _vala_code_node_unref0 (var_symbol);
                        }
                        _vala_iterable_unref0 (_var_symbol_list);
                  }
                  _tmp26_ = vala_array_list_new (VALA_TYPE_LOCAL_VARIABLE, (GBoxedCopyFunc) vala_code_node_ref, vala_code_node_unref, g_direct_equal);
                  defined_variables = _tmp26_;
                  vala_code_node_get_defined_variables (node, (ValaCollection*) defined_variables);
                  {
                        ValaArrayList* _tmp27_;
                        ValaArrayList* _local_list;
                        gint _tmp28_;
                        gint _local_size;
                        gint _local_index;
                        _tmp27_ = _vala_iterable_ref0 (defined_variables);
                        _local_list = _tmp27_;
                        _tmp28_ = vala_collection_get_size ((ValaCollection*) _local_list);
                        _local_size = _tmp28_;
                        _local_index = -1;
                        while (TRUE) {
                              gpointer _tmp29_ = NULL;
                              ValaLocalVariable* local;
                              ValaLocalVariable* _tmp30_ = NULL;
                              ValaLocalVariable* _tmp31_;
                              _local_index = _local_index + 1;
                              if (!(_local_index < _local_size)) {
                                    break;
                              }
                              _tmp29_ = vala_list_get ((ValaList*) _local_list, _local_index);
                              local = (ValaLocalVariable*) _tmp29_;
                              _tmp30_ = vala_flow_analyzer_process_assignment (self, self->priv->var_map, local);
                              _tmp31_ = _tmp30_;
                              _vala_code_node_unref0 (_tmp31_);
                              _vala_code_node_unref0 (local);
                        }
                        _vala_iterable_unref0 (_local_list);
                  }
                  _vala_iterable_unref0 (defined_variables);
                  _vala_iterable_unref0 (used_variables);
                  _vala_code_node_unref0 (node);
            }
            _vala_iterable_unref0 (_node_list);
      }
      {
            ValaList* _tmp32_ = NULL;
            ValaList* _succ_list;
            gint _tmp33_;
            gint _succ_size;
            gint _succ_index;
            _tmp32_ = vala_basic_block_get_successors (block);
            _succ_list = _tmp32_;
            _tmp33_ = vala_collection_get_size ((ValaCollection*) _succ_list);
            _succ_size = _tmp33_;
            _succ_index = -1;
            while (TRUE) {
                  gpointer _tmp34_ = NULL;
                  ValaBasicBlock* _tmp35_;
                  ValaBasicBlock* succ;
                  gint j;
                  _succ_index = _succ_index + 1;
                  if (!(_succ_index < _succ_size)) {
                        break;
                  }
                  _tmp34_ = vala_list_get (_succ_list, _succ_index);
                  _tmp35_ = _vala_basic_block_ref0 ((ValaBasicBlock*) _tmp34_);
                  succ = _tmp35_;
                  j = 0;
                  {
                        ValaList* _tmp36_ = NULL;
                        ValaList* _pred_list;
                        gint _tmp37_;
                        gint _pred_size;
                        gint _pred_index;
                        _tmp36_ = vala_basic_block_get_predecessors (succ);
                        _pred_list = _tmp36_;
                        _tmp37_ = vala_collection_get_size ((ValaCollection*) _pred_list);
                        _pred_size = _tmp37_;
                        _pred_index = -1;
                        while (TRUE) {
                              gpointer _tmp38_ = NULL;
                              ValaBasicBlock* _tmp39_;
                              ValaBasicBlock* pred;
                              _pred_index = _pred_index + 1;
                              if (!(_pred_index < _pred_size)) {
                                    break;
                              }
                              _tmp38_ = vala_list_get (_pred_list, _pred_index);
                              _tmp39_ = _vala_basic_block_ref0 ((ValaBasicBlock*) _tmp38_);
                              pred = _tmp39_;
                              if (pred == block) {
                                    _vala_basic_block_unref0 (pred);
                                    break;
                              }
                              j++;
                              _vala_basic_block_unref0 (pred);
                        }
                        _vala_iterable_unref0 (_pred_list);
                  }
                  {
                        ValaSet* _tmp40_ = NULL;
                        ValaSet* _tmp41_;
                        ValaIterator* _tmp42_ = NULL;
                        ValaIterator* _tmp43_;
                        ValaIterator* _phi_it;
                        _tmp40_ = vala_basic_block_get_phi_functions (succ);
                        _tmp41_ = _tmp40_;
                        _tmp42_ = vala_iterable_iterator ((ValaIterable*) _tmp41_);
                        _tmp43_ = _tmp42_;
                        _vala_iterable_unref0 (_tmp41_);
                        _phi_it = _tmp43_;
                        while (TRUE) {
                              gboolean _tmp44_;
                              gpointer _tmp45_ = NULL;
                              ValaPhiFunction* phi;
                              ValaLocalVariable* _tmp46_ = NULL;
                              gpointer _tmp47_ = NULL;
                              ValaList* variable_stack;
                              gboolean _tmp48_ = FALSE;
                              _tmp44_ = vala_iterator_next (_phi_it);
                              if (!_tmp44_) {
                                    break;
                              }
                              _tmp45_ = vala_iterator_get (_phi_it);
                              phi = (ValaPhiFunction*) _tmp45_;
                              _tmp46_ = vala_phi_function_get_original_variable (phi);
                              _tmp47_ = vala_map_get (self->priv->var_map, (ValaSymbol*) _tmp46_);
                              variable_stack = (ValaList*) _tmp47_;
                              if (variable_stack != NULL) {
                                    gint _tmp49_;
                                    _tmp49_ = vala_collection_get_size ((ValaCollection*) variable_stack);
                                    _tmp48_ = _tmp49_ > 0;
                              } else {
                                    _tmp48_ = FALSE;
                              }
                              if (_tmp48_) {
                                    ValaList* _tmp50_ = NULL;
                                    gint _tmp51_;
                                    gpointer _tmp52_ = NULL;
                                    ValaLocalVariable* _tmp53_;
                                    _tmp50_ = vala_phi_function_get_operands (phi);
                                    _tmp51_ = vala_collection_get_size ((ValaCollection*) variable_stack);
                                    _tmp52_ = vala_list_get (variable_stack, _tmp51_ - 1);
                                    _tmp53_ = (ValaLocalVariable*) _tmp52_;
                                    vala_list_set (_tmp50_, j, _tmp53_);
                                    _vala_code_node_unref0 (_tmp53_);
                              }
                              _vala_iterable_unref0 (variable_stack);
                              _vala_phi_function_unref0 (phi);
                        }
                        _vala_iterator_unref0 (_phi_it);
                  }
                  _vala_basic_block_unref0 (succ);
            }
            _vala_iterable_unref0 (_succ_list);
      }
      {
            ValaList* _tmp54_ = NULL;
            ValaList* _child_list;
            gint _tmp55_;
            gint _child_size;
            gint _child_index;
            _tmp54_ = vala_basic_block_get_children (block);
            _child_list = _tmp54_;
            _tmp55_ = vala_collection_get_size ((ValaCollection*) _child_list);
            _child_size = _tmp55_;
            _child_index = -1;
            while (TRUE) {
                  gpointer _tmp56_ = NULL;
                  ValaBasicBlock* child;
                  _child_index = _child_index + 1;
                  if (!(_child_index < _child_size)) {
                        break;
                  }
                  _tmp56_ = vala_list_get (_child_list, _child_index);
                  child = (ValaBasicBlock*) _tmp56_;
                  vala_flow_analyzer_check_block_variables (self, child);
                  _vala_basic_block_unref0 (child);
            }
            _vala_iterable_unref0 (_child_list);
      }
      {
            ValaSet* _tmp57_ = NULL;
            ValaSet* _tmp58_;
            ValaIterator* _tmp59_ = NULL;
            ValaIterator* _tmp60_;
            ValaIterator* _phi_it;
            _tmp57_ = vala_basic_block_get_phi_functions (block);
            _tmp58_ = _tmp57_;
            _tmp59_ = vala_iterable_iterator ((ValaIterable*) _tmp58_);
            _tmp60_ = _tmp59_;
            _vala_iterable_unref0 (_tmp58_);
            _phi_it = _tmp60_;
            while (TRUE) {
                  gboolean _tmp61_;
                  gpointer _tmp62_ = NULL;
                  ValaPhiFunction* phi;
                  ValaLocalVariable* _tmp63_ = NULL;
                  gpointer _tmp64_ = NULL;
                  ValaList* variable_stack;
                  gint _tmp65_;
                  _tmp61_ = vala_iterator_next (_phi_it);
                  if (!_tmp61_) {
                        break;
                  }
                  _tmp62_ = vala_iterator_get (_phi_it);
                  phi = (ValaPhiFunction*) _tmp62_;
                  _tmp63_ = vala_phi_function_get_original_variable (phi);
                  _tmp64_ = vala_map_get (self->priv->var_map, (ValaSymbol*) _tmp63_);
                  variable_stack = (ValaList*) _tmp64_;
                  _tmp65_ = vala_collection_get_size ((ValaCollection*) variable_stack);
                  vala_list_remove_at (variable_stack, _tmp65_ - 1);
                  _vala_iterable_unref0 (variable_stack);
                  _vala_phi_function_unref0 (phi);
            }
            _vala_iterator_unref0 (_phi_it);
      }
      {
            ValaList* _tmp66_ = NULL;
            ValaList* _node_list;
            gint _tmp67_;
            gint _node_size;
            gint _node_index;
            _tmp66_ = vala_basic_block_get_nodes (block);
            _node_list = _tmp66_;
            _tmp67_ = vala_collection_get_size ((ValaCollection*) _node_list);
            _node_size = _tmp67_;
            _node_index = -1;
            while (TRUE) {
                  gpointer _tmp68_ = NULL;
                  ValaCodeNode* node;
                  ValaArrayList* _tmp69_ = NULL;
                  ValaArrayList* defined_variables;
                  _node_index = _node_index + 1;
                  if (!(_node_index < _node_size)) {
                        break;
                  }
                  _tmp68_ = vala_list_get (_node_list, _node_index);
                  node = (ValaCodeNode*) _tmp68_;
                  _tmp69_ = vala_array_list_new (VALA_TYPE_LOCAL_VARIABLE, (GBoxedCopyFunc) vala_code_node_ref, vala_code_node_unref, g_direct_equal);
                  defined_variables = _tmp69_;
                  vala_code_node_get_defined_variables (node, (ValaCollection*) defined_variables);
                  {
                        ValaArrayList* _tmp70_;
                        ValaArrayList* _local_list;
                        gint _tmp71_;
                        gint _local_size;
                        gint _local_index;
                        _tmp70_ = _vala_iterable_ref0 (defined_variables);
                        _local_list = _tmp70_;
                        _tmp71_ = vala_collection_get_size ((ValaCollection*) _local_list);
                        _local_size = _tmp71_;
                        _local_index = -1;
                        while (TRUE) {
                              gpointer _tmp72_ = NULL;
                              ValaLocalVariable* local;
                              gpointer _tmp73_ = NULL;
                              ValaList* variable_stack;
                              gint _tmp74_;
                              _local_index = _local_index + 1;
                              if (!(_local_index < _local_size)) {
                                    break;
                              }
                              _tmp72_ = vala_list_get ((ValaList*) _local_list, _local_index);
                              local = (ValaLocalVariable*) _tmp72_;
                              _tmp73_ = vala_map_get (self->priv->var_map, (ValaSymbol*) local);
                              variable_stack = (ValaList*) _tmp73_;
                              _tmp74_ = vala_collection_get_size ((ValaCollection*) variable_stack);
                              vala_list_remove_at (variable_stack, _tmp74_ - 1);
                              _vala_iterable_unref0 (variable_stack);
                              _vala_code_node_unref0 (local);
                        }
                        _vala_iterable_unref0 (_local_list);
                  }
                  _vala_iterable_unref0 (defined_variables);
                  _vala_code_node_unref0 (node);
            }
            _vala_iterable_unref0 (_node_list);
      }
}


static ValaLocalVariable* vala_flow_analyzer_process_assignment (ValaFlowAnalyzer* self, ValaMap* var_map, ValaLocalVariable* var_symbol) {
      ValaLocalVariable* result = NULL;
      gpointer _tmp0_ = NULL;
      ValaList* variable_stack;
      ValaDataType* _tmp2_ = NULL;
      const gchar* _tmp3_ = NULL;
      ValaSourceReference* _tmp4_ = NULL;
      ValaLocalVariable* _tmp5_ = NULL;
      ValaLocalVariable* versioned_var;
      g_return_val_if_fail (self != NULL, NULL);
      g_return_val_if_fail (var_map != NULL, NULL);
      g_return_val_if_fail (var_symbol != NULL, NULL);
      _tmp0_ = vala_map_get (var_map, (ValaSymbol*) var_symbol);
      variable_stack = (ValaList*) _tmp0_;
      if (variable_stack == NULL) {
            ValaArrayList* _tmp1_ = NULL;
            _tmp1_ = vala_array_list_new (VALA_TYPE_LOCAL_VARIABLE, (GBoxedCopyFunc) vala_code_node_ref, vala_code_node_unref, g_direct_equal);
            _vala_iterable_unref0 (variable_stack);
            variable_stack = (ValaList*) _tmp1_;
            vala_map_set (var_map, (ValaSymbol*) var_symbol, variable_stack);
      }
      _tmp2_ = vala_variable_get_variable_type ((ValaVariable*) var_symbol);
      _tmp3_ = vala_symbol_get_name ((ValaSymbol*) var_symbol);
      _tmp4_ = vala_code_node_get_source_reference ((ValaCodeNode*) var_symbol);
      _tmp5_ = vala_local_variable_new (_tmp2_, _tmp3_, NULL, _tmp4_);
      versioned_var = _tmp5_;
      vala_collection_add ((ValaCollection*) variable_stack, versioned_var);
      result = versioned_var;
      _vala_iterable_unref0 (variable_stack);
      return result;
}


static void vala_flow_analyzer_real_visit_creation_method (ValaCodeVisitor* base, ValaCreationMethod* m) {
      ValaFlowAnalyzer * self;
      self = (ValaFlowAnalyzer*) base;
      g_return_if_fail (m != NULL);
      vala_code_visitor_visit_method ((ValaCodeVisitor*) self, (ValaMethod*) m);
}


static void vala_flow_analyzer_real_visit_property (ValaCodeVisitor* base, ValaProperty* prop) {
      ValaFlowAnalyzer * self;
      self = (ValaFlowAnalyzer*) base;
      g_return_if_fail (prop != NULL);
      vala_code_node_accept_children ((ValaCodeNode*) prop, (ValaCodeVisitor*) self);
}


static void vala_flow_analyzer_real_visit_property_accessor (ValaCodeVisitor* base, ValaPropertyAccessor* acc) {
      ValaFlowAnalyzer * self;
      self = (ValaFlowAnalyzer*) base;
      g_return_if_fail (acc != NULL);
      vala_flow_analyzer_visit_subroutine (self, (ValaSubroutine*) acc);
}


static void vala_flow_analyzer_real_visit_block (ValaCodeVisitor* base, ValaBlock* b) {
      ValaFlowAnalyzer * self;
      self = (ValaFlowAnalyzer*) base;
      g_return_if_fail (b != NULL);
      vala_code_node_accept_children ((ValaCodeNode*) b, (ValaCodeVisitor*) self);
}


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


static void vala_flow_analyzer_real_visit_declaration_statement (ValaCodeVisitor* base, ValaDeclarationStatement* stmt) {
      ValaFlowAnalyzer * self;
      gboolean _tmp0_;
      ValaSymbol* _tmp2_ = NULL;
      gboolean _tmp3_;
      ValaSymbol* _tmp10_ = NULL;
      ValaSymbol* _tmp11_;
      ValaLocalVariable* _tmp12_;
      ValaLocalVariable* local;
      gboolean _tmp13_ = FALSE;
      self = (ValaFlowAnalyzer*) base;
      g_return_if_fail (stmt != NULL);
      _tmp0_ = vala_flow_analyzer_unreachable (self, (ValaCodeNode*) stmt);
      if (_tmp0_) {
            ValaSymbol* _tmp1_ = NULL;
            _tmp1_ = vala_declaration_statement_get_declaration (stmt);
            vala_code_node_set_unreachable ((ValaCodeNode*) _tmp1_, TRUE);
            return;
      }
      _tmp2_ = vala_declaration_statement_get_declaration (stmt);
      _tmp3_ = vala_symbol_get_used (_tmp2_);
      if (!_tmp3_) {
            ValaSymbol* _tmp4_ = NULL;
            ValaSourceReference* _tmp5_ = NULL;
            ValaSymbol* _tmp6_ = NULL;
            const gchar* _tmp7_ = NULL;
            gchar* _tmp8_ = NULL;
            gchar* _tmp9_;
            _tmp4_ = vala_declaration_statement_get_declaration (stmt);
            _tmp5_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp4_);
            _tmp6_ = vala_declaration_statement_get_declaration (stmt);
            _tmp7_ = vala_symbol_get_name (_tmp6_);
            _tmp8_ = g_strdup_printf ("local variable `%s' declared but never used", _tmp7_);
            _tmp9_ = _tmp8_;
            vala_report_warning (_tmp5_, _tmp9_);
            _g_free0 (_tmp9_);
      }
      vala_basic_block_add_node (self->priv->current_block, (ValaCodeNode*) stmt);
      _tmp10_ = vala_declaration_statement_get_declaration (stmt);
      _tmp11_ = _tmp10_;
      _tmp12_ = _vala_code_node_ref0 (VALA_IS_LOCAL_VARIABLE (_tmp11_) ? ((ValaLocalVariable*) _tmp11_) : NULL);
      local = _tmp12_;
      if (local != NULL) {
            ValaExpression* _tmp14_ = NULL;
            _tmp14_ = vala_variable_get_initializer ((ValaVariable*) local);
            _tmp13_ = _tmp14_ != NULL;
      } else {
            _tmp13_ = FALSE;
      }
      if (_tmp13_) {
            ValaExpression* _tmp15_ = NULL;
            _tmp15_ = vala_variable_get_initializer ((ValaVariable*) local);
            vala_flow_analyzer_handle_errors (self, (ValaCodeNode*) _tmp15_, FALSE);
      }
      _vala_code_node_unref0 (local);
}


static void vala_flow_analyzer_real_visit_expression_statement (ValaCodeVisitor* base, ValaExpressionStatement* stmt) {
      ValaFlowAnalyzer * self;
      gboolean _tmp0_;
      ValaExpression* _tmp1_ = NULL;
      self = (ValaFlowAnalyzer*) base;
      g_return_if_fail (stmt != NULL);
      vala_code_node_accept_children ((ValaCodeNode*) stmt, (ValaCodeVisitor*) self);
      _tmp0_ = vala_flow_analyzer_unreachable (self, (ValaCodeNode*) stmt);
      if (_tmp0_) {
            return;
      }
      vala_basic_block_add_node (self->priv->current_block, (ValaCodeNode*) stmt);
      vala_flow_analyzer_handle_errors (self, (ValaCodeNode*) stmt, FALSE);
      _tmp1_ = vala_expression_statement_get_expression (stmt);
      if (VALA_IS_METHOD_CALL (_tmp1_)) {
            ValaExpression* _tmp2_ = NULL;
            ValaMethodCall* _tmp3_;
            ValaMethodCall* expr;
            ValaExpression* _tmp4_ = NULL;
            ValaExpression* _tmp5_;
            ValaMemberAccess* _tmp6_;
            ValaMemberAccess* ma;
            gboolean _tmp7_ = FALSE;
            gboolean _tmp8_ = FALSE;
            _tmp2_ = vala_expression_statement_get_expression (stmt);
            _tmp3_ = _vala_code_node_ref0 (VALA_METHOD_CALL (_tmp2_));
            expr = _tmp3_;
            _tmp4_ = vala_method_call_get_call (expr);
            _tmp5_ = _tmp4_;
            _tmp6_ = _vala_code_node_ref0 (VALA_IS_MEMBER_ACCESS (_tmp5_) ? ((ValaMemberAccess*) _tmp5_) : NULL);
            ma = _tmp6_;
            if (ma != NULL) {
                  ValaSymbol* _tmp9_ = NULL;
                  _tmp9_ = vala_expression_get_symbol_reference ((ValaExpression*) ma);
                  _tmp8_ = _tmp9_ != NULL;
            } else {
                  _tmp8_ = FALSE;
            }
            if (_tmp8_) {
                  ValaSymbol* _tmp10_ = NULL;
                  ValaAttribute* _tmp11_ = NULL;
                  ValaAttribute* _tmp12_;
                  _tmp10_ = vala_expression_get_symbol_reference ((ValaExpression*) ma);
                  _tmp11_ = vala_code_node_get_attribute ((ValaCodeNode*) _tmp10_, "NoReturn");
                  _tmp12_ = _tmp11_;
                  _tmp7_ = _tmp12_ != NULL;
                  _vala_code_node_unref0 (_tmp12_);
            } else {
                  _tmp7_ = FALSE;
            }
            if (_tmp7_) {
                  vala_flow_analyzer_mark_unreachable (self);
                  _vala_code_node_unref0 (ma);
                  _vala_code_node_unref0 (expr);
                  return;
            }
            _vala_code_node_unref0 (ma);
            _vala_code_node_unref0 (expr);
      }
}


static gboolean vala_flow_analyzer_always_true (ValaFlowAnalyzer* self, ValaExpression* condition) {
      gboolean result = FALSE;
      ValaExpression* _tmp0_;
      ValaBooleanLiteral* _tmp1_;
      ValaBooleanLiteral* literal;
      gboolean _tmp2_ = FALSE;
      g_return_val_if_fail (self != NULL, FALSE);
      g_return_val_if_fail (condition != NULL, FALSE);
      _tmp0_ = condition;
      _tmp1_ = _vala_code_node_ref0 (VALA_IS_BOOLEAN_LITERAL (_tmp0_) ? ((ValaBooleanLiteral*) _tmp0_) : NULL);
      literal = _tmp1_;
      if (literal != NULL) {
            gboolean _tmp3_;
            _tmp3_ = vala_boolean_literal_get_value (literal);
            _tmp2_ = _tmp3_;
      } else {
            _tmp2_ = FALSE;
      }
      result = _tmp2_;
      _vala_code_node_unref0 (literal);
      return result;
}


static gboolean vala_flow_analyzer_always_false (ValaFlowAnalyzer* self, ValaExpression* condition) {
      gboolean result = FALSE;
      ValaExpression* _tmp0_;
      ValaBooleanLiteral* _tmp1_;
      ValaBooleanLiteral* literal;
      gboolean _tmp2_ = FALSE;
      g_return_val_if_fail (self != NULL, FALSE);
      g_return_val_if_fail (condition != NULL, FALSE);
      _tmp0_ = condition;
      _tmp1_ = _vala_code_node_ref0 (VALA_IS_BOOLEAN_LITERAL (_tmp0_) ? ((ValaBooleanLiteral*) _tmp0_) : NULL);
      literal = _tmp1_;
      if (literal != NULL) {
            gboolean _tmp3_;
            _tmp3_ = vala_boolean_literal_get_value (literal);
            _tmp2_ = !_tmp3_;
      } else {
            _tmp2_ = FALSE;
      }
      result = _tmp2_;
      _vala_code_node_unref0 (literal);
      return result;
}


static void vala_flow_analyzer_real_visit_if_statement (ValaCodeVisitor* base, ValaIfStatement* stmt) {
      ValaFlowAnalyzer * self;
      gboolean _tmp0_;
      ValaExpression* _tmp1_ = NULL;
      ValaExpression* _tmp2_ = NULL;
      ValaBasicBlock* _tmp3_;
      ValaBasicBlock* last_block;
      ValaExpression* _tmp4_ = NULL;
      gboolean _tmp5_;
      ValaBlock* _tmp7_ = NULL;
      ValaBasicBlock* _tmp8_;
      ValaBasicBlock* last_true_block;
      ValaExpression* _tmp9_ = NULL;
      gboolean _tmp10_;
      ValaBlock* _tmp12_ = NULL;
      ValaBasicBlock* _tmp14_;
      ValaBasicBlock* last_false_block;
      gboolean _tmp15_ = FALSE;
      self = (ValaFlowAnalyzer*) base;
      g_return_if_fail (stmt != NULL);
      _tmp0_ = vala_flow_analyzer_unreachable (self, (ValaCodeNode*) stmt);
      if (_tmp0_) {
            return;
      }
      _tmp1_ = vala_if_statement_get_condition (stmt);
      vala_basic_block_add_node (self->priv->current_block, (ValaCodeNode*) _tmp1_);
      _tmp2_ = vala_if_statement_get_condition (stmt);
      vala_flow_analyzer_handle_errors (self, (ValaCodeNode*) _tmp2_, FALSE);
      _tmp3_ = _vala_basic_block_ref0 (self->priv->current_block);
      last_block = _tmp3_;
      _tmp4_ = vala_if_statement_get_condition (stmt);
      _tmp5_ = vala_flow_analyzer_always_false (self, _tmp4_);
      if (_tmp5_) {
            vala_flow_analyzer_mark_unreachable (self);
      } else {
            ValaBasicBlock* _tmp6_ = NULL;
            _tmp6_ = vala_basic_block_new ();
            _vala_basic_block_unref0 (self->priv->current_block);
            self->priv->current_block = _tmp6_;
            vala_basic_block_connect (last_block, self->priv->current_block);
      }
      _tmp7_ = vala_if_statement_get_true_statement (stmt);
      vala_code_node_accept ((ValaCodeNode*) _tmp7_, (ValaCodeVisitor*) self);
      _tmp8_ = _vala_basic_block_ref0 (self->priv->current_block);
      last_true_block = _tmp8_;
      _tmp9_ = vala_if_statement_get_condition (stmt);
      _tmp10_ = vala_flow_analyzer_always_true (self, _tmp9_);
      if (_tmp10_) {
            vala_flow_analyzer_mark_unreachable (self);
      } else {
            ValaBasicBlock* _tmp11_ = NULL;
            _tmp11_ = vala_basic_block_new ();
            _vala_basic_block_unref0 (self->priv->current_block);
            self->priv->current_block = _tmp11_;
            vala_basic_block_connect (last_block, self->priv->current_block);
      }
      _tmp12_ = vala_if_statement_get_false_statement (stmt);
      if (_tmp12_ != NULL) {
            ValaBlock* _tmp13_ = NULL;
            _tmp13_ = vala_if_statement_get_false_statement (stmt);
            vala_code_node_accept ((ValaCodeNode*) _tmp13_, (ValaCodeVisitor*) self);
      }
      _tmp14_ = _vala_basic_block_ref0 (self->priv->current_block);
      last_false_block = _tmp14_;
      if (last_true_block != NULL) {
            _tmp15_ = TRUE;
      } else {
            _tmp15_ = last_false_block != NULL;
      }
      if (_tmp15_) {
            ValaBasicBlock* _tmp16_ = NULL;
            _tmp16_ = vala_basic_block_new ();
            _vala_basic_block_unref0 (self->priv->current_block);
            self->priv->current_block = _tmp16_;
            if (last_true_block != NULL) {
                  vala_basic_block_connect (last_true_block, self->priv->current_block);
            }
            if (last_false_block != NULL) {
                  vala_basic_block_connect (last_false_block, self->priv->current_block);
            }
      }
      _vala_basic_block_unref0 (last_false_block);
      _vala_basic_block_unref0 (last_true_block);
      _vala_basic_block_unref0 (last_block);
}


static void vala_flow_analyzer_real_visit_switch_statement (ValaCodeVisitor* base, ValaSwitchStatement* stmt) {
      ValaFlowAnalyzer * self;
      gboolean _tmp0_;
      ValaBasicBlock* _tmp1_ = NULL;
      ValaBasicBlock* after_switch_block;
      ValaFlowAnalyzerJumpTarget* _tmp2_ = NULL;
      ValaFlowAnalyzerJumpTarget* _tmp3_;
      ValaExpression* _tmp4_ = NULL;
      ValaBasicBlock* _tmp5_;
      ValaBasicBlock* condition_block;
      ValaExpression* _tmp6_ = NULL;
      gboolean has_default_label;
      ValaList* _tmp16_ = NULL;
      ValaList* _tmp17_;
      gint _tmp18_;
      gboolean _tmp19_;
      gint _tmp21_;
      self = (ValaFlowAnalyzer*) base;
      g_return_if_fail (stmt != NULL);
      _tmp0_ = vala_flow_analyzer_unreachable (self, (ValaCodeNode*) stmt);
      if (_tmp0_) {
            return;
      }
      _tmp1_ = vala_basic_block_new ();
      after_switch_block = _tmp1_;
      _tmp2_ = vala_flow_analyzer_jump_target_new_break_target (after_switch_block);
      _tmp3_ = _tmp2_;
      vala_collection_add ((ValaCollection*) self->priv->jump_stack, _tmp3_);
      _vala_flow_analyzer_jump_target_unref0 (_tmp3_);
      _tmp4_ = vala_switch_statement_get_expression (stmt);
      vala_basic_block_add_node (self->priv->current_block, (ValaCodeNode*) _tmp4_);
      _tmp5_ = _vala_basic_block_ref0 (self->priv->current_block);
      condition_block = _tmp5_;
      _tmp6_ = vala_switch_statement_get_expression (stmt);
      vala_flow_analyzer_handle_errors (self, (ValaCodeNode*) _tmp6_, FALSE);
      has_default_label = FALSE;
      {
            ValaList* _tmp7_ = NULL;
            ValaList* _section_list;
            gint _tmp8_;
            gint _section_size;
            gint _section_index;
            _tmp7_ = vala_switch_statement_get_sections (stmt);
            _section_list = _tmp7_;
            _tmp8_ = vala_collection_get_size ((ValaCollection*) _section_list);
            _section_size = _tmp8_;
            _section_index = -1;
            while (TRUE) {
                  gpointer _tmp9_ = NULL;
                  ValaSwitchSection* section;
                  ValaBasicBlock* _tmp10_ = NULL;
                  gboolean _tmp14_;
                  _section_index = _section_index + 1;
                  if (!(_section_index < _section_size)) {
                        break;
                  }
                  _tmp9_ = vala_list_get (_section_list, _section_index);
                  section = (ValaSwitchSection*) _tmp9_;
                  _tmp10_ = vala_basic_block_new ();
                  _vala_basic_block_unref0 (self->priv->current_block);
                  self->priv->current_block = _tmp10_;
                  vala_basic_block_connect (condition_block, self->priv->current_block);
                  {
                        ValaList* _tmp11_ = NULL;
                        ValaList* _section_stmt_list;
                        gint _tmp12_;
                        gint _section_stmt_size;
                        gint _section_stmt_index;
                        _tmp11_ = vala_block_get_statements ((ValaBlock*) section);
                        _section_stmt_list = _tmp11_;
                        _tmp12_ = vala_collection_get_size ((ValaCollection*) _section_stmt_list);
                        _section_stmt_size = _tmp12_;
                        _section_stmt_index = -1;
                        while (TRUE) {
                              gpointer _tmp13_ = NULL;
                              ValaStatement* section_stmt;
                              _section_stmt_index = _section_stmt_index + 1;
                              if (!(_section_stmt_index < _section_stmt_size)) {
                                    break;
                              }
                              _tmp13_ = vala_list_get (_section_stmt_list, _section_stmt_index);
                              section_stmt = (ValaStatement*) _tmp13_;
                              vala_code_node_accept ((ValaCodeNode*) section_stmt, (ValaCodeVisitor*) self);
                              _vala_code_node_unref0 (section_stmt);
                        }
                        _vala_iterable_unref0 (_section_stmt_list);
                  }
                  _tmp14_ = vala_switch_section_has_default_label (section);
                  if (_tmp14_) {
                        has_default_label = TRUE;
                  }
                  if (self->priv->current_block != NULL) {
                        ValaSourceReference* _tmp15_ = NULL;
                        _tmp15_ = vala_code_node_get_source_reference ((ValaCodeNode*) section);
                        vala_report_error (_tmp15_, "missing break statement at end of switch section");
                        vala_code_node_set_error ((ValaCodeNode*) section, TRUE);
                        vala_basic_block_connect (self->priv->current_block, after_switch_block);
                  }
                  _vala_code_node_unref0 (section);
            }
            _vala_iterable_unref0 (_section_list);
      }
      if (!has_default_label) {
            vala_basic_block_connect (condition_block, after_switch_block);
      }
      _tmp16_ = vala_basic_block_get_predecessors (after_switch_block);
      _tmp17_ = _tmp16_;
      _tmp18_ = vala_collection_get_size ((ValaCollection*) _tmp17_);
      _tmp19_ = _tmp18_ > 0;
      _vala_iterable_unref0 (_tmp17_);
      if (_tmp19_) {
            ValaBasicBlock* _tmp20_;
            _tmp20_ = _vala_basic_block_ref0 (after_switch_block);
            _vala_basic_block_unref0 (self->priv->current_block);
            self->priv->current_block = _tmp20_;
      } else {
            vala_flow_analyzer_mark_unreachable (self);
      }
      _tmp21_ = vala_collection_get_size ((ValaCollection*) self->priv->jump_stack);
      vala_list_remove_at (self->priv->jump_stack, _tmp21_ - 1);
      _vala_basic_block_unref0 (condition_block);
      _vala_basic_block_unref0 (after_switch_block);
}


static void vala_flow_analyzer_real_visit_loop (ValaCodeVisitor* base, ValaLoop* stmt) {
      ValaFlowAnalyzer * self;
      gboolean _tmp0_;
      ValaBasicBlock* _tmp1_ = NULL;
      ValaBasicBlock* loop_block;
      ValaFlowAnalyzerJumpTarget* _tmp2_ = NULL;
      ValaFlowAnalyzerJumpTarget* _tmp3_;
      ValaBasicBlock* _tmp4_ = NULL;
      ValaBasicBlock* after_loop_block;
      ValaFlowAnalyzerJumpTarget* _tmp5_ = NULL;
      ValaFlowAnalyzerJumpTarget* _tmp6_;
      ValaBasicBlock* _tmp7_;
      ValaBasicBlock* last_block;
      ValaBasicBlock* _tmp8_;
      ValaBlock* _tmp9_ = NULL;
      ValaList* _tmp10_ = NULL;
      ValaList* _tmp11_;
      gint _tmp12_;
      gboolean _tmp13_;
      gint _tmp15_;
      gint _tmp16_;
      self = (ValaFlowAnalyzer*) base;
      g_return_if_fail (stmt != NULL);
      _tmp0_ = vala_flow_analyzer_unreachable (self, (ValaCodeNode*) stmt);
      if (_tmp0_) {
            return;
      }
      _tmp1_ = vala_basic_block_new ();
      loop_block = _tmp1_;
      _tmp2_ = vala_flow_analyzer_jump_target_new_continue_target (loop_block);
      _tmp3_ = _tmp2_;
      vala_collection_add ((ValaCollection*) self->priv->jump_stack, _tmp3_);
      _vala_flow_analyzer_jump_target_unref0 (_tmp3_);
      _tmp4_ = vala_basic_block_new ();
      after_loop_block = _tmp4_;
      _tmp5_ = vala_flow_analyzer_jump_target_new_break_target (after_loop_block);
      _tmp6_ = _tmp5_;
      vala_collection_add ((ValaCollection*) self->priv->jump_stack, _tmp6_);
      _vala_flow_analyzer_jump_target_unref0 (_tmp6_);
      _tmp7_ = _vala_basic_block_ref0 (self->priv->current_block);
      last_block = _tmp7_;
      vala_basic_block_connect (last_block, loop_block);
      _tmp8_ = _vala_basic_block_ref0 (loop_block);
      _vala_basic_block_unref0 (self->priv->current_block);
      self->priv->current_block = _tmp8_;
      _tmp9_ = vala_loop_get_body (stmt);
      vala_code_node_accept ((ValaCodeNode*) _tmp9_, (ValaCodeVisitor*) self);
      if (self->priv->current_block != NULL) {
            vala_basic_block_connect (self->priv->current_block, loop_block);
      }
      _tmp10_ = vala_basic_block_get_predecessors (after_loop_block);
      _tmp11_ = _tmp10_;
      _tmp12_ = vala_collection_get_size ((ValaCollection*) _tmp11_);
      _tmp13_ = _tmp12_ == 0;
      _vala_iterable_unref0 (_tmp11_);
      if (_tmp13_) {
            vala_flow_analyzer_mark_unreachable (self);
      } else {
            ValaBasicBlock* _tmp14_;
            _tmp14_ = _vala_basic_block_ref0 (after_loop_block);
            _vala_basic_block_unref0 (self->priv->current_block);
            self->priv->current_block = _tmp14_;
      }
      _tmp15_ = vala_collection_get_size ((ValaCollection*) self->priv->jump_stack);
      vala_list_remove_at (self->priv->jump_stack, _tmp15_ - 1);
      _tmp16_ = vala_collection_get_size ((ValaCollection*) self->priv->jump_stack);
      vala_list_remove_at (self->priv->jump_stack, _tmp16_ - 1);
      _vala_basic_block_unref0 (last_block);
      _vala_basic_block_unref0 (after_loop_block);
      _vala_basic_block_unref0 (loop_block);
}


static void vala_flow_analyzer_real_visit_foreach_statement (ValaCodeVisitor* base, ValaForeachStatement* stmt) {
      ValaFlowAnalyzer * self;
      gboolean _tmp0_;
      ValaExpression* _tmp1_ = NULL;
      ValaExpression* _tmp2_ = NULL;
      ValaBasicBlock* _tmp3_ = NULL;
      ValaBasicBlock* loop_block;
      ValaFlowAnalyzerJumpTarget* _tmp4_ = NULL;
      ValaFlowAnalyzerJumpTarget* _tmp5_;
      ValaBasicBlock* _tmp6_ = NULL;
      ValaBasicBlock* after_loop_block;
      ValaFlowAnalyzerJumpTarget* _tmp7_ = NULL;
      ValaFlowAnalyzerJumpTarget* _tmp8_;
      ValaBasicBlock* _tmp9_;
      ValaBasicBlock* last_block;
      ValaBasicBlock* _tmp10_;
      ValaBlock* _tmp11_ = NULL;
      ValaBasicBlock* _tmp12_;
      gint _tmp13_;
      gint _tmp14_;
      self = (ValaFlowAnalyzer*) base;
      g_return_if_fail (stmt != NULL);
      _tmp0_ = vala_flow_analyzer_unreachable (self, (ValaCodeNode*) stmt);
      if (_tmp0_) {
            return;
      }
      _tmp1_ = vala_foreach_statement_get_collection (stmt);
      vala_basic_block_add_node (self->priv->current_block, (ValaCodeNode*) _tmp1_);
      _tmp2_ = vala_foreach_statement_get_collection (stmt);
      vala_flow_analyzer_handle_errors (self, (ValaCodeNode*) _tmp2_, FALSE);
      _tmp3_ = vala_basic_block_new ();
      loop_block = _tmp3_;
      _tmp4_ = vala_flow_analyzer_jump_target_new_continue_target (loop_block);
      _tmp5_ = _tmp4_;
      vala_collection_add ((ValaCollection*) self->priv->jump_stack, _tmp5_);
      _vala_flow_analyzer_jump_target_unref0 (_tmp5_);
      _tmp6_ = vala_basic_block_new ();
      after_loop_block = _tmp6_;
      _tmp7_ = vala_flow_analyzer_jump_target_new_break_target (after_loop_block);
      _tmp8_ = _tmp7_;
      vala_collection_add ((ValaCollection*) self->priv->jump_stack, _tmp8_);
      _vala_flow_analyzer_jump_target_unref0 (_tmp8_);
      _tmp9_ = _vala_basic_block_ref0 (self->priv->current_block);
      last_block = _tmp9_;
      vala_basic_block_connect (last_block, loop_block);
      _tmp10_ = _vala_basic_block_ref0 (loop_block);
      _vala_basic_block_unref0 (self->priv->current_block);
      self->priv->current_block = _tmp10_;
      vala_basic_block_add_node (self->priv->current_block, (ValaCodeNode*) stmt);
      _tmp11_ = vala_foreach_statement_get_body (stmt);
      vala_code_node_accept ((ValaCodeNode*) _tmp11_, (ValaCodeVisitor*) self);
      if (self->priv->current_block != NULL) {
            vala_basic_block_connect (self->priv->current_block, loop_block);
      }
      vala_basic_block_connect (last_block, after_loop_block);
      if (self->priv->current_block != NULL) {
            vala_basic_block_connect (self->priv->current_block, after_loop_block);
      }
      _tmp12_ = _vala_basic_block_ref0 (after_loop_block);
      _vala_basic_block_unref0 (self->priv->current_block);
      self->priv->current_block = _tmp12_;
      _tmp13_ = vala_collection_get_size ((ValaCollection*) self->priv->jump_stack);
      vala_list_remove_at (self->priv->jump_stack, _tmp13_ - 1);
      _tmp14_ = vala_collection_get_size ((ValaCollection*) self->priv->jump_stack);
      vala_list_remove_at (self->priv->jump_stack, _tmp14_ - 1);
      _vala_basic_block_unref0 (last_block);
      _vala_basic_block_unref0 (after_loop_block);
      _vala_basic_block_unref0 (loop_block);
}


static void vala_flow_analyzer_real_visit_break_statement (ValaCodeVisitor* base, ValaBreakStatement* stmt) {
      ValaFlowAnalyzer * self;
      gboolean _tmp0_;
      ValaSourceReference* _tmp10_ = NULL;
      self = (ValaFlowAnalyzer*) base;
      g_return_if_fail (stmt != NULL);
      _tmp0_ = vala_flow_analyzer_unreachable (self, (ValaCodeNode*) stmt);
      if (_tmp0_) {
            return;
      }
      vala_basic_block_add_node (self->priv->current_block, (ValaCodeNode*) stmt);
      {
            gint _tmp1_;
            gint i;
            _tmp1_ = vala_collection_get_size ((ValaCollection*) self->priv->jump_stack);
            i = _tmp1_ - 1;
            {
                  gboolean _tmp2_;
                  _tmp2_ = TRUE;
                  while (TRUE) {
                        gpointer _tmp3_ = NULL;
                        ValaFlowAnalyzerJumpTarget* jump_target;
                        gboolean _tmp4_;
                        if (!_tmp2_) {
                              i--;
                        }
                        _tmp2_ = FALSE;
                        if (!(i >= 0)) {
                              break;
                        }
                        _tmp3_ = vala_list_get (self->priv->jump_stack, i);
                        jump_target = (ValaFlowAnalyzerJumpTarget*) _tmp3_;
                        _tmp4_ = vala_flow_analyzer_jump_target_get_is_break_target (jump_target);
                        if (_tmp4_) {
                              ValaBasicBlock* _tmp5_ = NULL;
                              _tmp5_ = vala_flow_analyzer_jump_target_get_basic_block (jump_target);
                              vala_basic_block_connect (self->priv->current_block, _tmp5_);
                              vala_flow_analyzer_mark_unreachable (self);
                              _vala_flow_analyzer_jump_target_unref0 (jump_target);
                              return;
                        } else {
                              gboolean _tmp6_;
                              _tmp6_ = vala_flow_analyzer_jump_target_get_is_finally_clause (jump_target);
                              if (_tmp6_) {
                                    ValaBasicBlock* _tmp7_ = NULL;
                                    ValaBasicBlock* _tmp8_ = NULL;
                                    ValaBasicBlock* _tmp9_;
                                    _tmp7_ = vala_flow_analyzer_jump_target_get_basic_block (jump_target);
                                    vala_basic_block_connect (self->priv->current_block, _tmp7_);
                                    _tmp8_ = vala_flow_analyzer_jump_target_get_last_block (jump_target);
                                    _tmp9_ = _vala_basic_block_ref0 (_tmp8_);
                                    _vala_basic_block_unref0 (self->priv->current_block);
                                    self->priv->current_block = _tmp9_;
                              }
                        }
                        _vala_flow_analyzer_jump_target_unref0 (jump_target);
                  }
            }
      }
      _tmp10_ = vala_code_node_get_source_reference ((ValaCodeNode*) stmt);
      vala_report_error (_tmp10_, "no enclosing loop or switch statement found");
      vala_code_node_set_error ((ValaCodeNode*) stmt, TRUE);
}


static void vala_flow_analyzer_real_visit_continue_statement (ValaCodeVisitor* base, ValaContinueStatement* stmt) {
      ValaFlowAnalyzer * self;
      gboolean _tmp0_;
      ValaSourceReference* _tmp10_ = NULL;
      self = (ValaFlowAnalyzer*) base;
      g_return_if_fail (stmt != NULL);
      _tmp0_ = vala_flow_analyzer_unreachable (self, (ValaCodeNode*) stmt);
      if (_tmp0_) {
            return;
      }
      vala_basic_block_add_node (self->priv->current_block, (ValaCodeNode*) stmt);
      {
            gint _tmp1_;
            gint i;
            _tmp1_ = vala_collection_get_size ((ValaCollection*) self->priv->jump_stack);
            i = _tmp1_ - 1;
            {
                  gboolean _tmp2_;
                  _tmp2_ = TRUE;
                  while (TRUE) {
                        gpointer _tmp3_ = NULL;
                        ValaFlowAnalyzerJumpTarget* jump_target;
                        gboolean _tmp4_;
                        if (!_tmp2_) {
                              i--;
                        }
                        _tmp2_ = FALSE;
                        if (!(i >= 0)) {
                              break;
                        }
                        _tmp3_ = vala_list_get (self->priv->jump_stack, i);
                        jump_target = (ValaFlowAnalyzerJumpTarget*) _tmp3_;
                        _tmp4_ = vala_flow_analyzer_jump_target_get_is_continue_target (jump_target);
                        if (_tmp4_) {
                              ValaBasicBlock* _tmp5_ = NULL;
                              _tmp5_ = vala_flow_analyzer_jump_target_get_basic_block (jump_target);
                              vala_basic_block_connect (self->priv->current_block, _tmp5_);
                              vala_flow_analyzer_mark_unreachable (self);
                              _vala_flow_analyzer_jump_target_unref0 (jump_target);
                              return;
                        } else {
                              gboolean _tmp6_;
                              _tmp6_ = vala_flow_analyzer_jump_target_get_is_finally_clause (jump_target);
                              if (_tmp6_) {
                                    ValaBasicBlock* _tmp7_ = NULL;
                                    ValaBasicBlock* _tmp8_ = NULL;
                                    ValaBasicBlock* _tmp9_;
                                    _tmp7_ = vala_flow_analyzer_jump_target_get_basic_block (jump_target);
                                    vala_basic_block_connect (self->priv->current_block, _tmp7_);
                                    _tmp8_ = vala_flow_analyzer_jump_target_get_last_block (jump_target);
                                    _tmp9_ = _vala_basic_block_ref0 (_tmp8_);
                                    _vala_basic_block_unref0 (self->priv->current_block);
                                    self->priv->current_block = _tmp9_;
                              }
                        }
                        _vala_flow_analyzer_jump_target_unref0 (jump_target);
                  }
            }
      }
      _tmp10_ = vala_code_node_get_source_reference ((ValaCodeNode*) stmt);
      vala_report_error (_tmp10_, "no enclosing loop found");
      vala_code_node_set_error ((ValaCodeNode*) stmt, TRUE);
}


static void vala_flow_analyzer_real_visit_return_statement (ValaCodeVisitor* base, ValaReturnStatement* stmt) {
      ValaFlowAnalyzer * self;
      gboolean _tmp0_;
      ValaExpression* _tmp1_ = NULL;
      ValaSourceReference* _tmp12_ = NULL;
      self = (ValaFlowAnalyzer*) base;
      g_return_if_fail (stmt != NULL);
      vala_code_node_accept_children ((ValaCodeNode*) stmt, (ValaCodeVisitor*) self);
      _tmp0_ = vala_flow_analyzer_unreachable (self, (ValaCodeNode*) stmt);
      if (_tmp0_) {
            return;
      }
      vala_basic_block_add_node (self->priv->current_block, (ValaCodeNode*) stmt);
      _tmp1_ = vala_return_statement_get_return_expression (stmt);
      if (_tmp1_ != NULL) {
            ValaExpression* _tmp2_ = NULL;
            _tmp2_ = vala_return_statement_get_return_expression (stmt);
            vala_flow_analyzer_handle_errors (self, (ValaCodeNode*) _tmp2_, FALSE);
      }
      {
            gint _tmp3_;
            gint i;
            _tmp3_ = vala_collection_get_size ((ValaCollection*) self->priv->jump_stack);
            i = _tmp3_ - 1;
            {
                  gboolean _tmp4_;
                  _tmp4_ = TRUE;
                  while (TRUE) {
                        gpointer _tmp5_ = NULL;
                        ValaFlowAnalyzerJumpTarget* jump_target;
                        gboolean _tmp6_;
                        if (!_tmp4_) {
                              i--;
                        }
                        _tmp4_ = FALSE;
                        if (!(i >= 0)) {
                              break;
                        }
                        _tmp5_ = vala_list_get (self->priv->jump_stack, i);
                        jump_target = (ValaFlowAnalyzerJumpTarget*) _tmp5_;
                        _tmp6_ = vala_flow_analyzer_jump_target_get_is_return_target (jump_target);
                        if (_tmp6_) {
                              ValaBasicBlock* _tmp7_ = NULL;
                              _tmp7_ = vala_flow_analyzer_jump_target_get_basic_block (jump_target);
                              vala_basic_block_connect (self->priv->current_block, _tmp7_);
                              vala_flow_analyzer_mark_unreachable (self);
                              _vala_flow_analyzer_jump_target_unref0 (jump_target);
                              return;
                        } else {
                              gboolean _tmp8_;
                              _tmp8_ = vala_flow_analyzer_jump_target_get_is_finally_clause (jump_target);
                              if (_tmp8_) {
                                    ValaBasicBlock* _tmp9_ = NULL;
                                    ValaBasicBlock* _tmp10_ = NULL;
                                    ValaBasicBlock* _tmp11_;
                                    _tmp9_ = vala_flow_analyzer_jump_target_get_basic_block (jump_target);
                                    vala_basic_block_connect (self->priv->current_block, _tmp9_);
                                    _tmp10_ = vala_flow_analyzer_jump_target_get_last_block (jump_target);
                                    _tmp11_ = _vala_basic_block_ref0 (_tmp10_);
                                    _vala_basic_block_unref0 (self->priv->current_block);
                                    self->priv->current_block = _tmp11_;
                              }
                        }
                        _vala_flow_analyzer_jump_target_unref0 (jump_target);
                  }
            }
      }
      _tmp12_ = vala_code_node_get_source_reference ((ValaCodeNode*) stmt);
      vala_report_error (_tmp12_, "no enclosing loop found");
      vala_code_node_set_error ((ValaCodeNode*) stmt, TRUE);
}


static void vala_flow_analyzer_handle_errors (ValaFlowAnalyzer* self, ValaCodeNode* node, gboolean always_fail) {
      gboolean _tmp0_;
      g_return_if_fail (self != NULL);
      g_return_if_fail (node != NULL);
      _tmp0_ = vala_code_node_get_tree_can_fail (node);
      if (_tmp0_) {
            ValaBasicBlock* _tmp1_;
            ValaBasicBlock* last_block;
            _tmp1_ = _vala_basic_block_ref0 (self->priv->current_block);
            last_block = _tmp1_;
            {
                  ValaList* _tmp2_ = NULL;
                  ValaList* _error_data_type_list;
                  gint _tmp3_;
                  gint _error_data_type_size;
                  gint _error_data_type_index;
                  _tmp2_ = vala_code_node_get_error_types (node);
                  _error_data_type_list = _tmp2_;
                  _tmp3_ = vala_collection_get_size ((ValaCollection*) _error_data_type_list);
                  _error_data_type_size = _tmp3_;
                  _error_data_type_index = -1;
                  while (TRUE) {
                        gpointer _tmp4_ = NULL;
                        ValaDataType* error_data_type;
                        ValaDataType* _tmp5_;
                        ValaErrorType* _tmp6_;
                        ValaErrorType* error_type;
                        ValaTypeSymbol* _tmp7_ = NULL;
                        ValaTypeSymbol* _tmp8_;
                        ValaClass* _tmp9_;
                        ValaClass* error_class;
                        ValaBasicBlock* _tmp10_;
                        _error_data_type_index = _error_data_type_index + 1;
                        if (!(_error_data_type_index < _error_data_type_size)) {
                              break;
                        }
                        _tmp4_ = vala_list_get (_error_data_type_list, _error_data_type_index);
                        error_data_type = (ValaDataType*) _tmp4_;
                        _tmp5_ = error_data_type;
                        _tmp6_ = _vala_code_node_ref0 (VALA_IS_ERROR_TYPE (_tmp5_) ? ((ValaErrorType*) _tmp5_) : NULL);
                        error_type = _tmp6_;
                        _tmp7_ = vala_data_type_get_data_type (error_data_type);
                        _tmp8_ = _tmp7_;
                        _tmp9_ = _vala_code_node_ref0 (VALA_IS_CLASS (_tmp8_) ? ((ValaClass*) _tmp8_) : NULL);
                        error_class = _tmp9_;
                        _tmp10_ = _vala_basic_block_ref0 (last_block);
                        _vala_basic_block_unref0 (self->priv->current_block);
                        self->priv->current_block = _tmp10_;
                        self->priv->unreachable_reported = TRUE;
                        {
                              gint _tmp11_;
                              gint i;
                              _tmp11_ = vala_collection_get_size ((ValaCollection*) self->priv->jump_stack);
                              i = _tmp11_ - 1;
                              {
                                    gboolean _tmp12_;
                                    _tmp12_ = TRUE;
                                    while (TRUE) {
                                          gpointer _tmp13_ = NULL;
                                          ValaFlowAnalyzerJumpTarget* jump_target;
                                          gboolean _tmp14_;
                                          if (!_tmp12_) {
                                                i--;
                                          }
                                          _tmp12_ = FALSE;
                                          if (!(i >= 0)) {
                                                break;
                                          }
                                          _tmp13_ = vala_list_get (self->priv->jump_stack, i);
                                          jump_target = (ValaFlowAnalyzerJumpTarget*) _tmp13_;
                                          _tmp14_ = vala_flow_analyzer_jump_target_get_is_exit_target (jump_target);
                                          if (_tmp14_) {
                                                ValaBasicBlock* _tmp15_ = NULL;
                                                _tmp15_ = vala_flow_analyzer_jump_target_get_basic_block (jump_target);
                                                vala_basic_block_connect (self->priv->current_block, _tmp15_);
                                                vala_flow_analyzer_mark_unreachable (self);
                                                _vala_flow_analyzer_jump_target_unref0 (jump_target);
                                                break;
                                          } else {
                                                gboolean _tmp16_;
                                                _tmp16_ = vala_flow_analyzer_jump_target_get_is_error_target (jump_target);
                                                if (_tmp16_) {
                                                      ValaProfile _tmp17_;
                                                      _tmp17_ = vala_code_context_get_profile (self->priv->context);
                                                      if (_tmp17_ == VALA_PROFILE_GOBJECT) {
                                                            gboolean _tmp18_ = FALSE;
                                                            ValaErrorDomain* _tmp19_ = NULL;
                                                            _tmp19_ = vala_flow_analyzer_jump_target_get_error_domain (jump_target);
                                                            if (_tmp19_ == NULL) {
                                                                  _tmp18_ = TRUE;
                                                            } else {
                                                                  gboolean _tmp20_ = FALSE;
                                                                  ValaErrorDomain* _tmp21_ = NULL;
                                                                  ValaErrorDomain* _tmp22_ = NULL;
                                                                  _tmp21_ = vala_flow_analyzer_jump_target_get_error_domain (jump_target);
                                                                  _tmp22_ = vala_error_type_get_error_domain (error_type);
                                                                  if (_tmp21_ == _tmp22_) {
                                                                        gboolean _tmp23_ = FALSE;
                                                                        ValaErrorCode* _tmp24_ = NULL;
                                                                        _tmp24_ = vala_flow_analyzer_jump_target_get_error_code (jump_target);
                                                                        if (_tmp24_ == NULL) {
                                                                              _tmp23_ = TRUE;
                                                                        } else {
                                                                              ValaErrorCode* _tmp25_ = NULL;
                                                                              ValaErrorCode* _tmp26_ = NULL;
                                                                              _tmp25_ = vala_flow_analyzer_jump_target_get_error_code (jump_target);
                                                                              _tmp26_ = vala_error_type_get_error_code (error_type);
                                                                              _tmp23_ = _tmp25_ == _tmp26_;
                                                                        }
                                                                        _tmp20_ = _tmp23_;
                                                                  } else {
                                                                        _tmp20_ = FALSE;
                                                                  }
                                                                  _tmp18_ = _tmp20_;
                                                            }
                                                            if (_tmp18_) {
                                                                  ValaBasicBlock* _tmp27_ = NULL;
                                                                  _tmp27_ = vala_flow_analyzer_jump_target_get_basic_block (jump_target);
                                                                  vala_basic_block_connect (self->priv->current_block, _tmp27_);
                                                                  vala_flow_analyzer_mark_unreachable (self);
                                                                  _vala_flow_analyzer_jump_target_unref0 (jump_target);
                                                                  break;
                                                            } else {
                                                                  gboolean _tmp28_ = FALSE;
                                                                  ValaErrorDomain* _tmp29_ = NULL;
                                                                  _tmp29_ = vala_error_type_get_error_domain (error_type);
                                                                  if (_tmp29_ == NULL) {
                                                                        _tmp28_ = TRUE;
                                                                  } else {
                                                                        gboolean _tmp30_ = FALSE;
                                                                        ValaErrorDomain* _tmp31_ = NULL;
                                                                        ValaErrorDomain* _tmp32_ = NULL;
                                                                        _tmp31_ = vala_error_type_get_error_domain (error_type);
                                                                        _tmp32_ = vala_flow_analyzer_jump_target_get_error_domain (jump_target);
                                                                        if (_tmp31_ == _tmp32_) {
                                                                              gboolean _tmp33_ = FALSE;
                                                                              ValaErrorCode* _tmp34_ = NULL;
                                                                              _tmp34_ = vala_error_type_get_error_code (error_type);
                                                                              if (_tmp34_ == NULL) {
                                                                                    _tmp33_ = TRUE;
                                                                              } else {
                                                                                    ValaErrorCode* _tmp35_ = NULL;
                                                                                    ValaErrorCode* _tmp36_ = NULL;
                                                                                    _tmp35_ = vala_error_type_get_error_code (error_type);
                                                                                    _tmp36_ = vala_flow_analyzer_jump_target_get_error_code (jump_target);
                                                                                    _tmp33_ = _tmp35_ == _tmp36_;
                                                                              }
                                                                              _tmp30_ = _tmp33_;
                                                                        } else {
                                                                              _tmp30_ = FALSE;
                                                                        }
                                                                        _tmp28_ = _tmp30_;
                                                                  }
                                                                  if (_tmp28_) {
                                                                        ValaBasicBlock* _tmp37_ = NULL;
                                                                        _tmp37_ = vala_flow_analyzer_jump_target_get_basic_block (jump_target);
                                                                        vala_basic_block_connect (self->priv->current_block, _tmp37_);
                                                                  }
                                                            }
                                                      } else {
                                                            gboolean _tmp38_ = FALSE;
                                                            ValaClass* _tmp39_ = NULL;
                                                            _tmp39_ = vala_flow_analyzer_jump_target_get_error_class (jump_target);
                                                            if (_tmp39_ == NULL) {
                                                                  _tmp38_ = TRUE;
                                                            } else {
                                                                  ValaClass* _tmp40_ = NULL;
                                                                  _tmp40_ = vala_flow_analyzer_jump_target_get_error_class (jump_target);
                                                                  _tmp38_ = _tmp40_ == error_class;
                                                            }
                                                            if (_tmp38_) {
                                                                  ValaBasicBlock* _tmp41_ = NULL;
                                                                  _tmp41_ = vala_flow_analyzer_jump_target_get_basic_block (jump_target);
                                                                  vala_basic_block_connect (self->priv->current_block, _tmp41_);
                                                                  vala_flow_analyzer_mark_unreachable (self);
                                                                  _vala_flow_analyzer_jump_target_unref0 (jump_target);
                                                                  break;
                                                            } else {
                                                                  ValaClass* _tmp42_ = NULL;
                                                                  gboolean _tmp43_;
                                                                  _tmp42_ = vala_flow_analyzer_jump_target_get_error_class (jump_target);
                                                                  _tmp43_ = vala_typesymbol_is_subtype_of ((ValaTypeSymbol*) _tmp42_, (ValaTypeSymbol*) error_class);
                                                                  if (_tmp43_) {
                                                                        ValaBasicBlock* _tmp44_ = NULL;
                                                                        _tmp44_ = vala_flow_analyzer_jump_target_get_basic_block (jump_target);
                                                                        vala_basic_block_connect (self->priv->current_block, _tmp44_);
                                                                  }
                                                            }
                                                      }
                                                } else {
                                                      gboolean _tmp45_;
                                                      _tmp45_ = vala_flow_analyzer_jump_target_get_is_finally_clause (jump_target);
                                                      if (_tmp45_) {
                                                            ValaBasicBlock* _tmp46_ = NULL;
                                                            ValaBasicBlock* _tmp47_ = NULL;
                                                            ValaBasicBlock* _tmp48_;
                                                            _tmp46_ = vala_flow_analyzer_jump_target_get_basic_block (jump_target);
                                                            vala_basic_block_connect (self->priv->current_block, _tmp46_);
                                                            _tmp47_ = vala_flow_analyzer_jump_target_get_last_block (jump_target);
                                                            _tmp48_ = _vala_basic_block_ref0 (_tmp47_);
                                                            _vala_basic_block_unref0 (self->priv->current_block);
                                                            self->priv->current_block = _tmp48_;
                                                      }
                                                }
                                          }
                                          _vala_flow_analyzer_jump_target_unref0 (jump_target);
                                    }
                              }
                        }
                        _vala_code_node_unref0 (error_class);
                        _vala_code_node_unref0 (error_type);
                        _vala_code_node_unref0 (error_data_type);
                  }
                  _vala_iterable_unref0 (_error_data_type_list);
            }
            if (!always_fail) {
                  ValaBasicBlock* _tmp49_ = NULL;
                  _tmp49_ = vala_basic_block_new ();
                  _vala_basic_block_unref0 (self->priv->current_block);
                  self->priv->current_block = _tmp49_;
                  vala_basic_block_connect (last_block, self->priv->current_block);
            }
            _vala_basic_block_unref0 (last_block);
      }
}


static void vala_flow_analyzer_real_visit_yield_statement (ValaCodeVisitor* base, ValaYieldStatement* stmt) {
      ValaFlowAnalyzer * self;
      gboolean _tmp0_;
      self = (ValaFlowAnalyzer*) base;
      g_return_if_fail (stmt != NULL);
      _tmp0_ = vala_flow_analyzer_unreachable (self, (ValaCodeNode*) stmt);
      if (_tmp0_) {
            return;
      }
      vala_code_node_accept_children ((ValaCodeNode*) stmt, (ValaCodeVisitor*) self);
}


static void vala_flow_analyzer_real_visit_throw_statement (ValaCodeVisitor* base, ValaThrowStatement* stmt) {
      ValaFlowAnalyzer * self;
      gboolean _tmp0_;
      self = (ValaFlowAnalyzer*) base;
      g_return_if_fail (stmt != NULL);
      _tmp0_ = vala_flow_analyzer_unreachable (self, (ValaCodeNode*) stmt);
      if (_tmp0_) {
            return;
      }
      vala_basic_block_add_node (self->priv->current_block, (ValaCodeNode*) stmt);
      vala_flow_analyzer_handle_errors (self, (ValaCodeNode*) stmt, TRUE);
}


static void vala_flow_analyzer_real_visit_try_statement (ValaCodeVisitor* base, ValaTryStatement* stmt) {
      ValaFlowAnalyzer * self;
      gboolean _tmp0_;
      ValaBasicBlock* _tmp1_;
      ValaBasicBlock* before_try_block;
      ValaBasicBlock* _tmp2_ = NULL;
      ValaBasicBlock* after_try_block;
      ValaBasicBlock* finally_block;
      ValaBlock* _tmp3_ = NULL;
      gint _tmp18_;
      gint finally_jump_stack_size;
      ValaList* _tmp19_ = NULL;
      ValaList* catch_clauses;
      ValaBasicBlock* _tmp48_;
      ValaBlock* _tmp49_ = NULL;
      ValaArrayList* _tmp51_ = NULL;
      ValaList* catch_stack;
      ValaList* _tmp85_ = NULL;
      ValaList* _tmp86_;
      gint _tmp87_;
      gboolean _tmp88_;
      self = (ValaFlowAnalyzer*) base;
      g_return_if_fail (stmt != NULL);
      _tmp0_ = vala_flow_analyzer_unreachable (self, (ValaCodeNode*) stmt);
      if (_tmp0_) {
            return;
      }
      _tmp1_ = _vala_basic_block_ref0 (self->priv->current_block);
      before_try_block = _tmp1_;
      _tmp2_ = vala_basic_block_new ();
      after_try_block = _tmp2_;
      finally_block = NULL;
      _tmp3_ = vala_try_statement_get_finally_body (stmt);
      if (_tmp3_ != NULL) {
            ValaBasicBlock* _tmp4_ = NULL;
            ValaBasicBlock* _tmp5_;
            ValaBasicBlock* _tmp6_ = NULL;
            ValaBasicBlock* invalid_block;
            ValaFlowAnalyzerJumpTarget* _tmp7_ = NULL;
            ValaFlowAnalyzerJumpTarget* _tmp8_;
            ValaBlock* _tmp9_ = NULL;
            ValaList* _tmp10_ = NULL;
            ValaList* _tmp11_;
            gint _tmp12_;
            gboolean _tmp13_;
            gint _tmp15_;
            ValaFlowAnalyzerJumpTarget* _tmp16_ = NULL;
            ValaFlowAnalyzerJumpTarget* _tmp17_;
            _tmp4_ = vala_basic_block_new ();
            _vala_basic_block_unref0 (finally_block);
            finally_block = _tmp4_;
            _tmp5_ = _vala_basic_block_ref0 (finally_block);
            _vala_basic_block_unref0 (self->priv->current_block);
            self->priv->current_block = _tmp5_;
            _tmp6_ = vala_basic_block_new ();
            invalid_block = _tmp6_;
            _tmp7_ = vala_flow_analyzer_jump_target_new_any_target (invalid_block);
            _tmp8_ = _tmp7_;
            vala_collection_add ((ValaCollection*) self->priv->jump_stack, _tmp8_);
            _vala_flow_analyzer_jump_target_unref0 (_tmp8_);
            _tmp9_ = vala_try_statement_get_finally_body (stmt);
            vala_code_node_accept ((ValaCodeNode*) _tmp9_, (ValaCodeVisitor*) self);
            _tmp10_ = vala_basic_block_get_predecessors (invalid_block);
            _tmp11_ = _tmp10_;
            _tmp12_ = vala_collection_get_size ((ValaCollection*) _tmp11_);
            _tmp13_ = _tmp12_ > 0;
            _vala_iterable_unref0 (_tmp11_);
            if (_tmp13_) {
                  ValaSourceReference* _tmp14_ = NULL;
                  _tmp14_ = vala_code_node_get_source_reference ((ValaCodeNode*) stmt);
                  vala_report_error (_tmp14_, "jump out of finally block not permitted");
                  vala_code_node_set_error ((ValaCodeNode*) stmt, TRUE);
                  _vala_basic_block_unref0 (invalid_block);
                  _vala_basic_block_unref0 (finally_block);
                  _vala_basic_block_unref0 (after_try_block);
                  _vala_basic_block_unref0 (before_try_block);
                  return;
            }
            _tmp15_ = vala_collection_get_size ((ValaCollection*) self->priv->jump_stack);
            vala_list_remove_at (self->priv->jump_stack, _tmp15_ - 1);
            _tmp16_ = vala_flow_analyzer_jump_target_new_finally_clause (finally_block, self->priv->current_block);
            _tmp17_ = _tmp16_;
            vala_collection_add ((ValaCollection*) self->priv->jump_stack, _tmp17_);
            _vala_flow_analyzer_jump_target_unref0 (_tmp17_);
            _vala_basic_block_unref0 (invalid_block);
      }
      _tmp18_ = vala_collection_get_size ((ValaCollection*) self->priv->jump_stack);
      finally_jump_stack_size = _tmp18_;
      _tmp19_ = vala_try_statement_get_catch_clauses (stmt);
      catch_clauses = _tmp19_;
      {
            gint _tmp20_;
            gint i;
            _tmp20_ = vala_collection_get_size ((ValaCollection*) catch_clauses);
            i = _tmp20_ - 1;
            {
                  gboolean _tmp21_;
                  _tmp21_ = TRUE;
                  while (TRUE) {
                        gpointer _tmp22_ = NULL;
                        ValaCatchClause* catch_clause;
                        ValaDataType* _tmp23_ = NULL;
                        if (!_tmp21_) {
                              i--;
                        }
                        _tmp21_ = FALSE;
                        if (!(i >= 0)) {
                              break;
                        }
                        _tmp22_ = vala_list_get (catch_clauses, i);
                        catch_clause = (ValaCatchClause*) _tmp22_;
                        _tmp23_ = vala_catch_clause_get_error_type (catch_clause);
                        if (_tmp23_ != NULL) {
                              ValaProfile _tmp24_;
                              _tmp24_ = vala_code_context_get_profile (self->priv->context);
                              if (_tmp24_ == VALA_PROFILE_GOBJECT) {
                                    ValaDataType* _tmp25_ = NULL;
                                    ValaDataType* _tmp26_;
                                    ValaErrorType* _tmp27_;
                                    ValaErrorType* error_type;
                                    ValaBasicBlock* _tmp28_ = NULL;
                                    ValaBasicBlock* _tmp29_;
                                    ValaDataType* _tmp30_ = NULL;
                                    ValaTypeSymbol* _tmp31_ = NULL;
                                    ValaTypeSymbol* _tmp32_;
                                    ValaErrorCode* _tmp33_ = NULL;
                                    ValaFlowAnalyzerJumpTarget* _tmp34_ = NULL;
                                    ValaFlowAnalyzerJumpTarget* _tmp35_;
                                    _tmp25_ = vala_catch_clause_get_error_type (catch_clause);
                                    _tmp26_ = _tmp25_;
                                    _tmp27_ = _vala_code_node_ref0 (VALA_IS_ERROR_TYPE (_tmp26_) ? ((ValaErrorType*) _tmp26_) : NULL);
                                    error_type = _tmp27_;
                                    _tmp28_ = vala_basic_block_new ();
                                    _tmp29_ = _tmp28_;
                                    _tmp30_ = vala_catch_clause_get_error_type (catch_clause);
                                    _tmp31_ = vala_data_type_get_data_type (_tmp30_);
                                    _tmp32_ = _tmp31_;
                                    _tmp33_ = vala_error_type_get_error_code (error_type);
                                    _tmp34_ = vala_flow_analyzer_jump_target_new_error_target (_tmp29_, catch_clause, VALA_IS_ERROR_DOMAIN (_tmp32_) ? ((ValaErrorDomain*) _tmp32_) : NULL, _tmp33_, NULL);
                                    _tmp35_ = _tmp34_;
                                    vala_collection_add ((ValaCollection*) self->priv->jump_stack, _tmp35_);
                                    _vala_flow_analyzer_jump_target_unref0 (_tmp35_);
                                    _vala_basic_block_unref0 (_tmp29_);
                                    _vala_code_node_unref0 (error_type);
                              } else {
                                    ValaDataType* _tmp36_ = NULL;
                                    ValaTypeSymbol* _tmp37_ = NULL;
                                    ValaTypeSymbol* _tmp38_;
                                    ValaClass* _tmp39_;
                                    ValaClass* error_class;
                                    ValaBasicBlock* _tmp40_ = NULL;
                                    ValaBasicBlock* _tmp41_;
                                    ValaFlowAnalyzerJumpTarget* _tmp42_ = NULL;
                                    ValaFlowAnalyzerJumpTarget* _tmp43_;
                                    _tmp36_ = vala_catch_clause_get_error_type (catch_clause);
                                    _tmp37_ = vala_data_type_get_data_type (_tmp36_);
                                    _tmp38_ = _tmp37_;
                                    _tmp39_ = _vala_code_node_ref0 (VALA_IS_CLASS (_tmp38_) ? ((ValaClass*) _tmp38_) : NULL);
                                    error_class = _tmp39_;
                                    _tmp40_ = vala_basic_block_new ();
                                    _tmp41_ = _tmp40_;
                                    _tmp42_ = vala_flow_analyzer_jump_target_new_error_target (_tmp41_, catch_clause, NULL, NULL, error_class);
                                    _tmp43_ = _tmp42_;
                                    vala_collection_add ((ValaCollection*) self->priv->jump_stack, _tmp43_);
                                    _vala_flow_analyzer_jump_target_unref0 (_tmp43_);
                                    _vala_basic_block_unref0 (_tmp41_);
                                    _vala_code_node_unref0 (error_class);
                              }
                        } else {
                              ValaBasicBlock* _tmp44_ = NULL;
                              ValaBasicBlock* _tmp45_;
                              ValaFlowAnalyzerJumpTarget* _tmp46_ = NULL;
                              ValaFlowAnalyzerJumpTarget* _tmp47_;
                              _tmp44_ = vala_basic_block_new ();
                              _tmp45_ = _tmp44_;
                              _tmp46_ = vala_flow_analyzer_jump_target_new_error_target (_tmp45_, catch_clause, NULL, NULL, NULL);
                              _tmp47_ = _tmp46_;
                              vala_collection_add ((ValaCollection*) self->priv->jump_stack, _tmp47_);
                              _vala_flow_analyzer_jump_target_unref0 (_tmp47_);
                              _vala_basic_block_unref0 (_tmp45_);
                        }
                        _vala_code_node_unref0 (catch_clause);
                  }
            }
      }
      _tmp48_ = _vala_basic_block_ref0 (before_try_block);
      _vala_basic_block_unref0 (self->priv->current_block);
      self->priv->current_block = _tmp48_;
      _tmp49_ = vala_try_statement_get_body (stmt);
      vala_code_node_accept ((ValaCodeNode*) _tmp49_, (ValaCodeVisitor*) self);
      if (self->priv->current_block != NULL) {
            if (finally_block != NULL) {
                  ValaBasicBlock* _tmp50_;
                  vala_basic_block_connect (self->priv->current_block, finally_block);
                  _tmp50_ = _vala_basic_block_ref0 (finally_block);
                  _vala_basic_block_unref0 (self->priv->current_block);
                  self->priv->current_block = _tmp50_;
            }
            vala_basic_block_connect (self->priv->current_block, after_try_block);
      }
      _tmp51_ = vala_array_list_new (VALA_FLOW_ANALYZER_TYPE_JUMP_TARGET, (GBoxedCopyFunc) vala_flow_analyzer_jump_target_ref, vala_flow_analyzer_jump_target_unref, g_direct_equal);
      catch_stack = (ValaList*) _tmp51_;
      {
            gint _tmp52_;
            gint i;
            _tmp52_ = vala_collection_get_size ((ValaCollection*) self->priv->jump_stack);
            i = _tmp52_ - 1;
            {
                  gboolean _tmp53_;
                  _tmp53_ = TRUE;
                  while (TRUE) {
                        gpointer _tmp54_ = NULL;
                        ValaFlowAnalyzerJumpTarget* jump_target;
                        if (!_tmp53_) {
                              i--;
                        }
                        _tmp53_ = FALSE;
                        if (!(i >= finally_jump_stack_size)) {
                              break;
                        }
                        _tmp54_ = vala_list_get (self->priv->jump_stack, i);
                        jump_target = (ValaFlowAnalyzerJumpTarget*) _tmp54_;
                        vala_collection_add ((ValaCollection*) catch_stack, jump_target);
                        vala_list_remove_at (self->priv->jump_stack, i);
                        _vala_flow_analyzer_jump_target_unref0 (jump_target);
                  }
            }
      }
      {
            ValaList* _tmp55_;
            ValaList* _jump_target_list;
            gint _tmp56_;
            gint _jump_target_size;
            gint _jump_target_index;
            _tmp55_ = _vala_iterable_ref0 (catch_stack);
            _jump_target_list = _tmp55_;
            _tmp56_ = vala_collection_get_size ((ValaCollection*) _jump_target_list);
            _jump_target_size = _tmp56_;
            _jump_target_index = -1;
            while (TRUE) {
                  gpointer _tmp57_ = NULL;
                  ValaFlowAnalyzerJumpTarget* jump_target;
                  ValaBasicBlock* _tmp71_ = NULL;
                  ValaList* _tmp72_ = NULL;
                  ValaList* _tmp73_;
                  gint _tmp74_;
                  gboolean _tmp75_;
                  _jump_target_index = _jump_target_index + 1;
                  if (!(_jump_target_index < _jump_target_size)) {
                        break;
                  }
                  _tmp57_ = vala_list_get (_jump_target_list, _jump_target_index);
                  jump_target = (ValaFlowAnalyzerJumpTarget*) _tmp57_;
                  {
                        ValaList* _tmp58_;
                        ValaList* _prev_target_list;
                        gint _tmp59_;
                        gint _prev_target_size;
                        gint _prev_target_index;
                        _tmp58_ = _vala_iterable_ref0 (catch_stack);
                        _prev_target_list = _tmp58_;
                        _tmp59_ = vala_collection_get_size ((ValaCollection*) _prev_target_list);
                        _prev_target_size = _tmp59_;
                        _prev_target_index = -1;
                        while (TRUE) {
                              gpointer _tmp60_ = NULL;
                              ValaFlowAnalyzerJumpTarget* prev_target;
                              ValaProfile _tmp61_;
                              _prev_target_index = _prev_target_index + 1;
                              if (!(_prev_target_index < _prev_target_size)) {
                                    break;
                              }
                              _tmp60_ = vala_list_get (_prev_target_list, _prev_target_index);
                              prev_target = (ValaFlowAnalyzerJumpTarget*) _tmp60_;
                              if (prev_target == jump_target) {
                                    _vala_flow_analyzer_jump_target_unref0 (prev_target);
                                    break;
                              }
                              _tmp61_ = vala_code_context_get_profile (self->priv->context);
                              if (_tmp61_ == VALA_PROFILE_GOBJECT) {
                                    gboolean _tmp62_ = FALSE;
                                    ValaErrorDomain* _tmp63_ = NULL;
                                    ValaErrorDomain* _tmp64_ = NULL;
                                    _tmp63_ = vala_flow_analyzer_jump_target_get_error_domain (prev_target);
                                    _tmp64_ = vala_flow_analyzer_jump_target_get_error_domain (jump_target);
                                    if (_tmp63_ == _tmp64_) {
                                          ValaErrorCode* _tmp65_ = NULL;
                                          ValaErrorCode* _tmp66_ = NULL;
                                          _tmp65_ = vala_flow_analyzer_jump_target_get_error_code (prev_target);
                                          _tmp66_ = vala_flow_analyzer_jump_target_get_error_code (jump_target);
                                          _tmp62_ = _tmp65_ == _tmp66_;
                                    } else {
                                          _tmp62_ = FALSE;
                                    }
                                    if (_tmp62_) {
                                          ValaSourceReference* _tmp67_ = NULL;
                                          _tmp67_ = vala_code_node_get_source_reference ((ValaCodeNode*) stmt);
                                          vala_report_error (_tmp67_, "double catch clause of same error detected");
                                          vala_code_node_set_error ((ValaCodeNode*) stmt, TRUE);
                                          _vala_flow_analyzer_jump_target_unref0 (prev_target);
                                          _vala_iterable_unref0 (_prev_target_list);
                                          _vala_flow_analyzer_jump_target_unref0 (jump_target);
                                          _vala_iterable_unref0 (_jump_target_list);
                                          _vala_iterable_unref0 (catch_stack);
                                          _vala_iterable_unref0 (catch_clauses);
                                          _vala_basic_block_unref0 (finally_block);
                                          _vala_basic_block_unref0 (after_try_block);
                                          _vala_basic_block_unref0 (before_try_block);
                                          return;
                                    }
                              } else {
                                    ValaClass* _tmp68_ = NULL;
                                    ValaClass* _tmp69_ = NULL;
                                    _tmp68_ = vala_flow_analyzer_jump_target_get_error_class (prev_target);
                                    _tmp69_ = vala_flow_analyzer_jump_target_get_error_class (jump_target);
                                    if (_tmp68_ == _tmp69_) {
                                          ValaSourceReference* _tmp70_ = NULL;
                                          _tmp70_ = vala_code_node_get_source_reference ((ValaCodeNode*) stmt);
                                          vala_report_error (_tmp70_, "double catch clause of same error detected");
                                          vala_code_node_set_error ((ValaCodeNode*) stmt, TRUE);
                                          _vala_flow_analyzer_jump_target_unref0 (prev_target);
                                          _vala_iterable_unref0 (_prev_target_list);
                                          _vala_flow_analyzer_jump_target_unref0 (jump_target);
                                          _vala_iterable_unref0 (_jump_target_list);
                                          _vala_iterable_unref0 (catch_stack);
                                          _vala_iterable_unref0 (catch_clauses);
                                          _vala_basic_block_unref0 (finally_block);
                                          _vala_basic_block_unref0 (after_try_block);
                                          _vala_basic_block_unref0 (before_try_block);
                                          return;
                                    }
                              }
                              _vala_flow_analyzer_jump_target_unref0 (prev_target);
                        }
                        _vala_iterable_unref0 (_prev_target_list);
                  }
                  _tmp71_ = vala_flow_analyzer_jump_target_get_basic_block (jump_target);
                  _tmp72_ = vala_basic_block_get_predecessors (_tmp71_);
                  _tmp73_ = _tmp72_;
                  _tmp74_ = vala_collection_get_size ((ValaCollection*) _tmp73_);
                  _tmp75_ = _tmp74_ == 0;
                  _vala_iterable_unref0 (_tmp73_);
                  if (_tmp75_) {
                        ValaCatchClause* _tmp76_ = NULL;
                        ValaSourceReference* _tmp77_ = NULL;
                        _tmp76_ = vala_flow_analyzer_jump_target_get_catch_clause (jump_target);
                        _tmp77_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp76_);
                        vala_report_warning (_tmp77_, "unreachable catch clause detected");
                  } else {
                        ValaBasicBlock* _tmp78_ = NULL;
                        ValaBasicBlock* _tmp79_;
                        ValaCatchClause* _tmp80_ = NULL;
                        ValaCatchClause* _tmp81_ = NULL;
                        ValaBlock* _tmp82_ = NULL;
                        _tmp78_ = vala_flow_analyzer_jump_target_get_basic_block (jump_target);
                        _tmp79_ = _vala_basic_block_ref0 (_tmp78_);
                        _vala_basic_block_unref0 (self->priv->current_block);
                        self->priv->current_block = _tmp79_;
                        _tmp80_ = vala_flow_analyzer_jump_target_get_catch_clause (jump_target);
                        vala_basic_block_add_node (self->priv->current_block, (ValaCodeNode*) _tmp80_);
                        _tmp81_ = vala_flow_analyzer_jump_target_get_catch_clause (jump_target);
                        _tmp82_ = vala_catch_clause_get_body (_tmp81_);
                        vala_code_node_accept ((ValaCodeNode*) _tmp82_, (ValaCodeVisitor*) self);
                        if (self->priv->current_block != NULL) {
                              if (finally_block != NULL) {
                                    ValaBasicBlock* _tmp83_;
                                    vala_basic_block_connect (self->priv->current_block, finally_block);
                                    _tmp83_ = _vala_basic_block_ref0 (finally_block);
                                    _vala_basic_block_unref0 (self->priv->current_block);
                                    self->priv->current_block = _tmp83_;
                              }
                              vala_basic_block_connect (self->priv->current_block, after_try_block);
                        }
                  }
                  _vala_flow_analyzer_jump_target_unref0 (jump_target);
            }
            _vala_iterable_unref0 (_jump_target_list);
      }
      if (finally_block != NULL) {
            gint _tmp84_;
            _tmp84_ = vala_collection_get_size ((ValaCollection*) self->priv->jump_stack);
            vala_list_remove_at (self->priv->jump_stack, _tmp84_ - 1);
      }
      _tmp85_ = vala_basic_block_get_predecessors (after_try_block);
      _tmp86_ = _tmp85_;
      _tmp87_ = vala_collection_get_size ((ValaCollection*) _tmp86_);
      _tmp88_ = _tmp87_ > 0;
      _vala_iterable_unref0 (_tmp86_);
      if (_tmp88_) {
            ValaBasicBlock* _tmp89_;
            _tmp89_ = _vala_basic_block_ref0 (after_try_block);
            _vala_basic_block_unref0 (self->priv->current_block);
            self->priv->current_block = _tmp89_;
      } else {
            vala_try_statement_set_after_try_block_reachable (stmt, FALSE);
            vala_flow_analyzer_mark_unreachable (self);
      }
      _vala_iterable_unref0 (catch_stack);
      _vala_iterable_unref0 (catch_clauses);
      _vala_basic_block_unref0 (finally_block);
      _vala_basic_block_unref0 (after_try_block);
      _vala_basic_block_unref0 (before_try_block);
}


static void vala_flow_analyzer_real_visit_lock_statement (ValaCodeVisitor* base, ValaLockStatement* stmt) {
      ValaFlowAnalyzer * self;
      gboolean _tmp0_;
      self = (ValaFlowAnalyzer*) base;
      g_return_if_fail (stmt != NULL);
      _tmp0_ = vala_flow_analyzer_unreachable (self, (ValaCodeNode*) stmt);
      if (_tmp0_) {
            return;
      }
}


static void vala_flow_analyzer_real_visit_unlock_statement (ValaCodeVisitor* base, ValaUnlockStatement* stmt) {
      ValaFlowAnalyzer * self;
      gboolean _tmp0_;
      self = (ValaFlowAnalyzer*) base;
      g_return_if_fail (stmt != NULL);
      _tmp0_ = vala_flow_analyzer_unreachable (self, (ValaCodeNode*) stmt);
      if (_tmp0_) {
            return;
      }
}


static void vala_flow_analyzer_real_visit_expression (ValaCodeVisitor* base, ValaExpression* expr) {
      ValaFlowAnalyzer * self;
      self = (ValaFlowAnalyzer*) base;
      g_return_if_fail (expr != NULL);
      if (!VALA_IS_LAMBDA_EXPRESSION (expr)) {
            vala_code_node_accept_children ((ValaCodeNode*) expr, (ValaCodeVisitor*) self);
      }
}


static gboolean vala_flow_analyzer_unreachable (ValaFlowAnalyzer* self, ValaCodeNode* node) {
      gboolean result = FALSE;
      g_return_val_if_fail (self != NULL, FALSE);
      g_return_val_if_fail (node != NULL, FALSE);
      if (self->priv->current_block == NULL) {
            vala_code_node_set_unreachable (node, TRUE);
            if (!self->priv->unreachable_reported) {
                  ValaSourceReference* _tmp0_ = NULL;
                  _tmp0_ = vala_code_node_get_source_reference (node);
                  vala_report_warning (_tmp0_, "unreachable code detected");
                  self->priv->unreachable_reported = TRUE;
            }
            result = TRUE;
            return result;
      }
      result = FALSE;
      return result;
}


static void vala_flow_analyzer_mark_unreachable (ValaFlowAnalyzer* self) {
      g_return_if_fail (self != NULL);
      _vala_basic_block_unref0 (self->priv->current_block);
      self->priv->current_block = NULL;
      self->priv->unreachable_reported = FALSE;
}


static ValaFlowAnalyzerJumpTarget* vala_flow_analyzer_jump_target_construct_break_target (GType object_type, ValaBasicBlock* basic_block) {
      ValaFlowAnalyzerJumpTarget* self = NULL;
      g_return_val_if_fail (basic_block != NULL, NULL);
      self = (ValaFlowAnalyzerJumpTarget*) g_type_create_instance (object_type);
      vala_flow_analyzer_jump_target_set_basic_block (self, basic_block);
      vala_flow_analyzer_jump_target_set_is_break_target (self, TRUE);
      return self;
}


static ValaFlowAnalyzerJumpTarget* vala_flow_analyzer_jump_target_new_break_target (ValaBasicBlock* basic_block) {
      return vala_flow_analyzer_jump_target_construct_break_target (VALA_FLOW_ANALYZER_TYPE_JUMP_TARGET, basic_block);
}


static ValaFlowAnalyzerJumpTarget* vala_flow_analyzer_jump_target_construct_continue_target (GType object_type, ValaBasicBlock* basic_block) {
      ValaFlowAnalyzerJumpTarget* self = NULL;
      g_return_val_if_fail (basic_block != NULL, NULL);
      self = (ValaFlowAnalyzerJumpTarget*) g_type_create_instance (object_type);
      vala_flow_analyzer_jump_target_set_basic_block (self, basic_block);
      vala_flow_analyzer_jump_target_set_is_continue_target (self, TRUE);
      return self;
}


static ValaFlowAnalyzerJumpTarget* vala_flow_analyzer_jump_target_new_continue_target (ValaBasicBlock* basic_block) {
      return vala_flow_analyzer_jump_target_construct_continue_target (VALA_FLOW_ANALYZER_TYPE_JUMP_TARGET, basic_block);
}


static ValaFlowAnalyzerJumpTarget* vala_flow_analyzer_jump_target_construct_return_target (GType object_type, ValaBasicBlock* basic_block) {
      ValaFlowAnalyzerJumpTarget* self = NULL;
      g_return_val_if_fail (basic_block != NULL, NULL);
      self = (ValaFlowAnalyzerJumpTarget*) g_type_create_instance (object_type);
      vala_flow_analyzer_jump_target_set_basic_block (self, basic_block);
      vala_flow_analyzer_jump_target_set_is_return_target (self, TRUE);
      return self;
}


static ValaFlowAnalyzerJumpTarget* vala_flow_analyzer_jump_target_new_return_target (ValaBasicBlock* basic_block) {
      return vala_flow_analyzer_jump_target_construct_return_target (VALA_FLOW_ANALYZER_TYPE_JUMP_TARGET, basic_block);
}


static ValaFlowAnalyzerJumpTarget* vala_flow_analyzer_jump_target_construct_exit_target (GType object_type, ValaBasicBlock* basic_block) {
      ValaFlowAnalyzerJumpTarget* self = NULL;
      g_return_val_if_fail (basic_block != NULL, NULL);
      self = (ValaFlowAnalyzerJumpTarget*) g_type_create_instance (object_type);
      vala_flow_analyzer_jump_target_set_basic_block (self, basic_block);
      vala_flow_analyzer_jump_target_set_is_exit_target (self, TRUE);
      return self;
}


static ValaFlowAnalyzerJumpTarget* vala_flow_analyzer_jump_target_new_exit_target (ValaBasicBlock* basic_block) {
      return vala_flow_analyzer_jump_target_construct_exit_target (VALA_FLOW_ANALYZER_TYPE_JUMP_TARGET, basic_block);
}


static ValaFlowAnalyzerJumpTarget* vala_flow_analyzer_jump_target_construct_error_target (GType object_type, ValaBasicBlock* basic_block, ValaCatchClause* catch_clause, ValaErrorDomain* error_domain, ValaErrorCode* error_code, ValaClass* error_class) {
      ValaFlowAnalyzerJumpTarget* self = NULL;
      g_return_val_if_fail (basic_block != NULL, NULL);
      g_return_val_if_fail (catch_clause != NULL, NULL);
      self = (ValaFlowAnalyzerJumpTarget*) g_type_create_instance (object_type);
      vala_flow_analyzer_jump_target_set_basic_block (self, basic_block);
      vala_flow_analyzer_jump_target_set_catch_clause (self, catch_clause);
      vala_flow_analyzer_jump_target_set_error_domain (self, error_domain);
      vala_flow_analyzer_jump_target_set_error_code (self, error_code);
      vala_flow_analyzer_jump_target_set_error_class (self, error_class);
      vala_flow_analyzer_jump_target_set_is_error_target (self, TRUE);
      return self;
}


static ValaFlowAnalyzerJumpTarget* vala_flow_analyzer_jump_target_new_error_target (ValaBasicBlock* basic_block, ValaCatchClause* catch_clause, ValaErrorDomain* error_domain, ValaErrorCode* error_code, ValaClass* error_class) {
      return vala_flow_analyzer_jump_target_construct_error_target (VALA_FLOW_ANALYZER_TYPE_JUMP_TARGET, basic_block, catch_clause, error_domain, error_code, error_class);
}


static ValaFlowAnalyzerJumpTarget* vala_flow_analyzer_jump_target_construct_any_target (GType object_type, ValaBasicBlock* basic_block) {
      ValaFlowAnalyzerJumpTarget* self = NULL;
      g_return_val_if_fail (basic_block != NULL, NULL);
      self = (ValaFlowAnalyzerJumpTarget*) g_type_create_instance (object_type);
      vala_flow_analyzer_jump_target_set_basic_block (self, basic_block);
      vala_flow_analyzer_jump_target_set_is_break_target (self, TRUE);
      vala_flow_analyzer_jump_target_set_is_continue_target (self, TRUE);
      vala_flow_analyzer_jump_target_set_is_return_target (self, TRUE);
      vala_flow_analyzer_jump_target_set_is_exit_target (self, TRUE);
      vala_flow_analyzer_jump_target_set_is_error_target (self, TRUE);
      return self;
}


static ValaFlowAnalyzerJumpTarget* vala_flow_analyzer_jump_target_new_any_target (ValaBasicBlock* basic_block) {
      return vala_flow_analyzer_jump_target_construct_any_target (VALA_FLOW_ANALYZER_TYPE_JUMP_TARGET, basic_block);
}


static ValaFlowAnalyzerJumpTarget* vala_flow_analyzer_jump_target_construct_finally_clause (GType object_type, ValaBasicBlock* basic_block, ValaBasicBlock* last_block) {
      ValaFlowAnalyzerJumpTarget* self = NULL;
      g_return_val_if_fail (basic_block != NULL, NULL);
      g_return_val_if_fail (last_block != NULL, NULL);
      self = (ValaFlowAnalyzerJumpTarget*) g_type_create_instance (object_type);
      vala_flow_analyzer_jump_target_set_basic_block (self, basic_block);
      vala_flow_analyzer_jump_target_set_last_block (self, last_block);
      vala_flow_analyzer_jump_target_set_is_finally_clause (self, TRUE);
      return self;
}


static ValaFlowAnalyzerJumpTarget* vala_flow_analyzer_jump_target_new_finally_clause (ValaBasicBlock* basic_block, ValaBasicBlock* last_block) {
      return vala_flow_analyzer_jump_target_construct_finally_clause (VALA_FLOW_ANALYZER_TYPE_JUMP_TARGET, basic_block, last_block);
}


static ValaFlowAnalyzerJumpTarget* vala_flow_analyzer_jump_target_construct (GType object_type) {
      ValaFlowAnalyzerJumpTarget* self = NULL;
      self = (ValaFlowAnalyzerJumpTarget*) g_type_create_instance (object_type);
      return self;
}


static ValaFlowAnalyzerJumpTarget* vala_flow_analyzer_jump_target_new (void) {
      return vala_flow_analyzer_jump_target_construct (VALA_FLOW_ANALYZER_TYPE_JUMP_TARGET);
}


static gboolean vala_flow_analyzer_jump_target_get_is_break_target (ValaFlowAnalyzerJumpTarget* self) {
      gboolean result;
      g_return_val_if_fail (self != NULL, FALSE);
      result = self->priv->_is_break_target;
      return result;
}


static void vala_flow_analyzer_jump_target_set_is_break_target (ValaFlowAnalyzerJumpTarget* self, gboolean value) {
      g_return_if_fail (self != NULL);
      self->priv->_is_break_target = value;
}


static gboolean vala_flow_analyzer_jump_target_get_is_continue_target (ValaFlowAnalyzerJumpTarget* self) {
      gboolean result;
      g_return_val_if_fail (self != NULL, FALSE);
      result = self->priv->_is_continue_target;
      return result;
}


static void vala_flow_analyzer_jump_target_set_is_continue_target (ValaFlowAnalyzerJumpTarget* self, gboolean value) {
      g_return_if_fail (self != NULL);
      self->priv->_is_continue_target = value;
}


static gboolean vala_flow_analyzer_jump_target_get_is_return_target (ValaFlowAnalyzerJumpTarget* self) {
      gboolean result;
      g_return_val_if_fail (self != NULL, FALSE);
      result = self->priv->_is_return_target;
      return result;
}


static void vala_flow_analyzer_jump_target_set_is_return_target (ValaFlowAnalyzerJumpTarget* self, gboolean value) {
      g_return_if_fail (self != NULL);
      self->priv->_is_return_target = value;
}


static gboolean vala_flow_analyzer_jump_target_get_is_exit_target (ValaFlowAnalyzerJumpTarget* self) {
      gboolean result;
      g_return_val_if_fail (self != NULL, FALSE);
      result = self->priv->_is_exit_target;
      return result;
}


static void vala_flow_analyzer_jump_target_set_is_exit_target (ValaFlowAnalyzerJumpTarget* self, gboolean value) {
      g_return_if_fail (self != NULL);
      self->priv->_is_exit_target = value;
}


static gboolean vala_flow_analyzer_jump_target_get_is_error_target (ValaFlowAnalyzerJumpTarget* self) {
      gboolean result;
      g_return_val_if_fail (self != NULL, FALSE);
      result = self->priv->_is_error_target;
      return result;
}


static void vala_flow_analyzer_jump_target_set_is_error_target (ValaFlowAnalyzerJumpTarget* self, gboolean value) {
      g_return_if_fail (self != NULL);
      self->priv->_is_error_target = value;
}


static ValaErrorDomain* vala_flow_analyzer_jump_target_get_error_domain (ValaFlowAnalyzerJumpTarget* self) {
      ValaErrorDomain* result;
      g_return_val_if_fail (self != NULL, NULL);
      result = self->priv->_error_domain;
      return result;
}


static void vala_flow_analyzer_jump_target_set_error_domain (ValaFlowAnalyzerJumpTarget* self, ValaErrorDomain* value) {
      ValaErrorDomain* _tmp0_;
      g_return_if_fail (self != NULL);
      _tmp0_ = _vala_code_node_ref0 (value);
      _vala_code_node_unref0 (self->priv->_error_domain);
      self->priv->_error_domain = _tmp0_;
}


static ValaErrorCode* vala_flow_analyzer_jump_target_get_error_code (ValaFlowAnalyzerJumpTarget* self) {
      ValaErrorCode* result;
      g_return_val_if_fail (self != NULL, NULL);
      result = self->priv->_error_code;
      return result;
}


static void vala_flow_analyzer_jump_target_set_error_code (ValaFlowAnalyzerJumpTarget* self, ValaErrorCode* value) {
      ValaErrorCode* _tmp0_;
      g_return_if_fail (self != NULL);
      _tmp0_ = _vala_code_node_ref0 (value);
      _vala_code_node_unref0 (self->priv->_error_code);
      self->priv->_error_code = _tmp0_;
}


static ValaClass* vala_flow_analyzer_jump_target_get_error_class (ValaFlowAnalyzerJumpTarget* self) {
      ValaClass* result;
      g_return_val_if_fail (self != NULL, NULL);
      result = self->priv->_error_class;
      return result;
}


static void vala_flow_analyzer_jump_target_set_error_class (ValaFlowAnalyzerJumpTarget* self, ValaClass* value) {
      ValaClass* _tmp0_;
      g_return_if_fail (self != NULL);
      _tmp0_ = _vala_code_node_ref0 (value);
      _vala_code_node_unref0 (self->priv->_error_class);
      self->priv->_error_class = _tmp0_;
}


static gboolean vala_flow_analyzer_jump_target_get_is_finally_clause (ValaFlowAnalyzerJumpTarget* self) {
      gboolean result;
      g_return_val_if_fail (self != NULL, FALSE);
      result = self->priv->_is_finally_clause;
      return result;
}


static void vala_flow_analyzer_jump_target_set_is_finally_clause (ValaFlowAnalyzerJumpTarget* self, gboolean value) {
      g_return_if_fail (self != NULL);
      self->priv->_is_finally_clause = value;
}


static ValaBasicBlock* vala_flow_analyzer_jump_target_get_basic_block (ValaFlowAnalyzerJumpTarget* self) {
      ValaBasicBlock* result;
      g_return_val_if_fail (self != NULL, NULL);
      result = self->priv->_basic_block;
      return result;
}


static void vala_flow_analyzer_jump_target_set_basic_block (ValaFlowAnalyzerJumpTarget* self, ValaBasicBlock* value) {
      ValaBasicBlock* _tmp0_;
      g_return_if_fail (self != NULL);
      _tmp0_ = _vala_basic_block_ref0 (value);
      _vala_basic_block_unref0 (self->priv->_basic_block);
      self->priv->_basic_block = _tmp0_;
}


static ValaBasicBlock* vala_flow_analyzer_jump_target_get_last_block (ValaFlowAnalyzerJumpTarget* self) {
      ValaBasicBlock* result;
      g_return_val_if_fail (self != NULL, NULL);
      result = self->priv->_last_block;
      return result;
}


static void vala_flow_analyzer_jump_target_set_last_block (ValaFlowAnalyzerJumpTarget* self, ValaBasicBlock* value) {
      ValaBasicBlock* _tmp0_;
      g_return_if_fail (self != NULL);
      _tmp0_ = _vala_basic_block_ref0 (value);
      _vala_basic_block_unref0 (self->priv->_last_block);
      self->priv->_last_block = _tmp0_;
}


static ValaCatchClause* vala_flow_analyzer_jump_target_get_catch_clause (ValaFlowAnalyzerJumpTarget* self) {
      ValaCatchClause* result;
      g_return_val_if_fail (self != NULL, NULL);
      result = self->priv->_catch_clause;
      return result;
}


static void vala_flow_analyzer_jump_target_set_catch_clause (ValaFlowAnalyzerJumpTarget* self, ValaCatchClause* value) {
      ValaCatchClause* _tmp0_;
      g_return_if_fail (self != NULL);
      _tmp0_ = _vala_code_node_ref0 (value);
      _vala_code_node_unref0 (self->priv->_catch_clause);
      self->priv->_catch_clause = _tmp0_;
}


static void vala_flow_analyzer_value_jump_target_init (GValue* value) {
      value->data[0].v_pointer = NULL;
}


static void vala_flow_analyzer_value_jump_target_free_value (GValue* value) {
      if (value->data[0].v_pointer) {
            vala_flow_analyzer_jump_target_unref (value->data[0].v_pointer);
      }
}


static void vala_flow_analyzer_value_jump_target_copy_value (const GValue* src_value, GValue* dest_value) {
      if (src_value->data[0].v_pointer) {
            dest_value->data[0].v_pointer = vala_flow_analyzer_jump_target_ref (src_value->data[0].v_pointer);
      } else {
            dest_value->data[0].v_pointer = NULL;
      }
}


static gpointer vala_flow_analyzer_value_jump_target_peek_pointer (const GValue* value) {
      return value->data[0].v_pointer;
}


static gchar* vala_flow_analyzer_value_jump_target_collect_value (GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
      if (collect_values[0].v_pointer) {
            ValaFlowAnalyzerJumpTarget* object;
            object = collect_values[0].v_pointer;
            if (object->parent_instance.g_class == NULL) {
                  return g_strconcat ("invalid unclassed object pointer for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
            } else if (!g_value_type_compatible (G_TYPE_FROM_INSTANCE (object), G_VALUE_TYPE (value))) {
                  return g_strconcat ("invalid object type `", g_type_name (G_TYPE_FROM_INSTANCE (object)), "' for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
            }
            value->data[0].v_pointer = vala_flow_analyzer_jump_target_ref (object);
      } else {
            value->data[0].v_pointer = NULL;
      }
      return NULL;
}


static gchar* vala_flow_analyzer_value_jump_target_lcopy_value (const GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
      ValaFlowAnalyzerJumpTarget** object_p;
      object_p = collect_values[0].v_pointer;
      if (!object_p) {
            return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
      }
      if (!value->data[0].v_pointer) {
            *object_p = NULL;
      } else if (collect_flags & G_VALUE_NOCOPY_CONTENTS) {
            *object_p = value->data[0].v_pointer;
      } else {
            *object_p = vala_flow_analyzer_jump_target_ref (value->data[0].v_pointer);
      }
      return NULL;
}


static GParamSpec* vala_flow_analyzer_param_spec_jump_target (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags) {
      ValaFlowAnalyzerParamSpecJumpTarget* spec;
      g_return_val_if_fail (g_type_is_a (object_type, VALA_FLOW_ANALYZER_TYPE_JUMP_TARGET), NULL);
      spec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, name, nick, blurb, flags);
      G_PARAM_SPEC (spec)->value_type = object_type;
      return G_PARAM_SPEC (spec);
}


static gpointer vala_flow_analyzer_value_get_jump_target (const GValue* value) {
      g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, VALA_FLOW_ANALYZER_TYPE_JUMP_TARGET), NULL);
      return value->data[0].v_pointer;
}


static void vala_flow_analyzer_value_set_jump_target (GValue* value, gpointer v_object) {
      ValaFlowAnalyzerJumpTarget* old;
      g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, VALA_FLOW_ANALYZER_TYPE_JUMP_TARGET));
      old = value->data[0].v_pointer;
      if (v_object) {
            g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, VALA_FLOW_ANALYZER_TYPE_JUMP_TARGET));
            g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
            value->data[0].v_pointer = v_object;
            vala_flow_analyzer_jump_target_ref (value->data[0].v_pointer);
      } else {
            value->data[0].v_pointer = NULL;
      }
      if (old) {
            vala_flow_analyzer_jump_target_unref (old);
      }
}


static void vala_flow_analyzer_value_take_jump_target (GValue* value, gpointer v_object) {
      ValaFlowAnalyzerJumpTarget* old;
      g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, VALA_FLOW_ANALYZER_TYPE_JUMP_TARGET));
      old = value->data[0].v_pointer;
      if (v_object) {
            g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, VALA_FLOW_ANALYZER_TYPE_JUMP_TARGET));
            g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
            value->data[0].v_pointer = v_object;
      } else {
            value->data[0].v_pointer = NULL;
      }
      if (old) {
            vala_flow_analyzer_jump_target_unref (old);
      }
}


static void vala_flow_analyzer_jump_target_class_init (ValaFlowAnalyzerJumpTargetClass * klass) {
      vala_flow_analyzer_jump_target_parent_class = g_type_class_peek_parent (klass);
      VALA_FLOW_ANALYZER_JUMP_TARGET_CLASS (klass)->finalize = vala_flow_analyzer_jump_target_finalize;
      g_type_class_add_private (klass, sizeof (ValaFlowAnalyzerJumpTargetPrivate));
}


static void vala_flow_analyzer_jump_target_instance_init (ValaFlowAnalyzerJumpTarget * self) {
      self->priv = VALA_FLOW_ANALYZER_JUMP_TARGET_GET_PRIVATE (self);
      self->ref_count = 1;
}


static void vala_flow_analyzer_jump_target_finalize (ValaFlowAnalyzerJumpTarget* obj) {
      ValaFlowAnalyzerJumpTarget * self;
      self = VALA_FLOW_ANALYZER_JUMP_TARGET (obj);
      _vala_code_node_unref0 (self->priv->_error_domain);
      _vala_code_node_unref0 (self->priv->_error_code);
      _vala_code_node_unref0 (self->priv->_error_class);
      _vala_basic_block_unref0 (self->priv->_basic_block);
      _vala_basic_block_unref0 (self->priv->_last_block);
      _vala_code_node_unref0 (self->priv->_catch_clause);
}


static GType vala_flow_analyzer_jump_target_get_type (void) {
      static volatile gsize vala_flow_analyzer_jump_target_type_id__volatile = 0;
      if (g_once_init_enter (&vala_flow_analyzer_jump_target_type_id__volatile)) {
            static const GTypeValueTable g_define_type_value_table = { vala_flow_analyzer_value_jump_target_init, vala_flow_analyzer_value_jump_target_free_value, vala_flow_analyzer_value_jump_target_copy_value, vala_flow_analyzer_value_jump_target_peek_pointer, "p", vala_flow_analyzer_value_jump_target_collect_value, "p", vala_flow_analyzer_value_jump_target_lcopy_value };
            static const GTypeInfo g_define_type_info = { sizeof (ValaFlowAnalyzerJumpTargetClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) vala_flow_analyzer_jump_target_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ValaFlowAnalyzerJumpTarget), 0, (GInstanceInitFunc) vala_flow_analyzer_jump_target_instance_init, &g_define_type_value_table };
            static const GTypeFundamentalInfo g_define_type_fundamental_info = { (G_TYPE_FLAG_CLASSED | G_TYPE_FLAG_INSTANTIATABLE | G_TYPE_FLAG_DERIVABLE | G_TYPE_FLAG_DEEP_DERIVABLE) };
            GType vala_flow_analyzer_jump_target_type_id;
            vala_flow_analyzer_jump_target_type_id = g_type_register_fundamental (g_type_fundamental_next (), "ValaFlowAnalyzerJumpTarget", &g_define_type_info, &g_define_type_fundamental_info, 0);
            g_once_init_leave (&vala_flow_analyzer_jump_target_type_id__volatile, vala_flow_analyzer_jump_target_type_id);
      }
      return vala_flow_analyzer_jump_target_type_id__volatile;
}


static gpointer vala_flow_analyzer_jump_target_ref (gpointer instance) {
      ValaFlowAnalyzerJumpTarget* self;
      self = instance;
      g_atomic_int_inc (&self->ref_count);
      return instance;
}


static void vala_flow_analyzer_jump_target_unref (gpointer instance) {
      ValaFlowAnalyzerJumpTarget* self;
      self = instance;
      if (g_atomic_int_dec_and_test (&self->ref_count)) {
            VALA_FLOW_ANALYZER_JUMP_TARGET_GET_CLASS (self)->finalize (self);
            g_type_free_instance ((GTypeInstance *) self);
      }
}


static void vala_flow_analyzer_class_init (ValaFlowAnalyzerClass * klass) {
      vala_flow_analyzer_parent_class = g_type_class_peek_parent (klass);
      VALA_CODE_VISITOR_CLASS (klass)->finalize = vala_flow_analyzer_finalize;
      g_type_class_add_private (klass, sizeof (ValaFlowAnalyzerPrivate));
      VALA_CODE_VISITOR_CLASS (klass)->visit_source_file = vala_flow_analyzer_real_visit_source_file;
      VALA_CODE_VISITOR_CLASS (klass)->visit_class = vala_flow_analyzer_real_visit_class;
      VALA_CODE_VISITOR_CLASS (klass)->visit_struct = vala_flow_analyzer_real_visit_struct;
      VALA_CODE_VISITOR_CLASS (klass)->visit_interface = vala_flow_analyzer_real_visit_interface;
      VALA_CODE_VISITOR_CLASS (klass)->visit_enum = vala_flow_analyzer_real_visit_enum;
      VALA_CODE_VISITOR_CLASS (klass)->visit_error_domain = vala_flow_analyzer_real_visit_error_domain;
      VALA_CODE_VISITOR_CLASS (klass)->visit_field = vala_flow_analyzer_real_visit_field;
      VALA_CODE_VISITOR_CLASS (klass)->visit_lambda_expression = vala_flow_analyzer_real_visit_lambda_expression;
      VALA_CODE_VISITOR_CLASS (klass)->visit_method = vala_flow_analyzer_real_visit_method;
      VALA_CODE_VISITOR_CLASS (klass)->visit_signal = vala_flow_analyzer_real_visit_signal;
      VALA_CODE_VISITOR_CLASS (klass)->visit_creation_method = vala_flow_analyzer_real_visit_creation_method;
      VALA_CODE_VISITOR_CLASS (klass)->visit_property = vala_flow_analyzer_real_visit_property;
      VALA_CODE_VISITOR_CLASS (klass)->visit_property_accessor = vala_flow_analyzer_real_visit_property_accessor;
      VALA_CODE_VISITOR_CLASS (klass)->visit_block = vala_flow_analyzer_real_visit_block;
      VALA_CODE_VISITOR_CLASS (klass)->visit_declaration_statement = vala_flow_analyzer_real_visit_declaration_statement;
      VALA_CODE_VISITOR_CLASS (klass)->visit_expression_statement = vala_flow_analyzer_real_visit_expression_statement;
      VALA_CODE_VISITOR_CLASS (klass)->visit_if_statement = vala_flow_analyzer_real_visit_if_statement;
      VALA_CODE_VISITOR_CLASS (klass)->visit_switch_statement = vala_flow_analyzer_real_visit_switch_statement;
      VALA_CODE_VISITOR_CLASS (klass)->visit_loop = vala_flow_analyzer_real_visit_loop;
      VALA_CODE_VISITOR_CLASS (klass)->visit_foreach_statement = vala_flow_analyzer_real_visit_foreach_statement;
      VALA_CODE_VISITOR_CLASS (klass)->visit_break_statement = vala_flow_analyzer_real_visit_break_statement;
      VALA_CODE_VISITOR_CLASS (klass)->visit_continue_statement = vala_flow_analyzer_real_visit_continue_statement;
      VALA_CODE_VISITOR_CLASS (klass)->visit_return_statement = vala_flow_analyzer_real_visit_return_statement;
      VALA_CODE_VISITOR_CLASS (klass)->visit_yield_statement = vala_flow_analyzer_real_visit_yield_statement;
      VALA_CODE_VISITOR_CLASS (klass)->visit_throw_statement = vala_flow_analyzer_real_visit_throw_statement;
      VALA_CODE_VISITOR_CLASS (klass)->visit_try_statement = vala_flow_analyzer_real_visit_try_statement;
      VALA_CODE_VISITOR_CLASS (klass)->visit_lock_statement = vala_flow_analyzer_real_visit_lock_statement;
      VALA_CODE_VISITOR_CLASS (klass)->visit_unlock_statement = vala_flow_analyzer_real_visit_unlock_statement;
      VALA_CODE_VISITOR_CLASS (klass)->visit_expression = vala_flow_analyzer_real_visit_expression;
}


static void vala_flow_analyzer_instance_init (ValaFlowAnalyzer * self) {
      ValaArrayList* _tmp0_ = NULL;
      self->priv = VALA_FLOW_ANALYZER_GET_PRIVATE (self);
      _tmp0_ = vala_array_list_new (VALA_FLOW_ANALYZER_TYPE_JUMP_TARGET, (GBoxedCopyFunc) vala_flow_analyzer_jump_target_ref, vala_flow_analyzer_jump_target_unref, g_direct_equal);
      self->priv->jump_stack = (ValaList*) _tmp0_;
}


static void vala_flow_analyzer_finalize (ValaCodeVisitor* obj) {
      ValaFlowAnalyzer * self;
      self = VALA_FLOW_ANALYZER (obj);
      _vala_code_context_unref0 (self->priv->context);
      _vala_basic_block_unref0 (self->priv->current_block);
      _vala_iterable_unref0 (self->priv->jump_stack);
      _vala_map_unref0 (self->priv->var_map);
      _vala_iterable_unref0 (self->priv->used_vars);
      _vala_map_unref0 (self->priv->phi_functions);
      VALA_CODE_VISITOR_CLASS (vala_flow_analyzer_parent_class)->finalize (obj);
}


/**
 * Code visitor building the control flow graph.
 */
GType vala_flow_analyzer_get_type (void) {
      static volatile gsize vala_flow_analyzer_type_id__volatile = 0;
      if (g_once_init_enter (&vala_flow_analyzer_type_id__volatile)) {
            static const GTypeInfo g_define_type_info = { sizeof (ValaFlowAnalyzerClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) vala_flow_analyzer_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ValaFlowAnalyzer), 0, (GInstanceInitFunc) vala_flow_analyzer_instance_init, NULL };
            GType vala_flow_analyzer_type_id;
            vala_flow_analyzer_type_id = g_type_register_static (VALA_TYPE_CODE_VISITOR, "ValaFlowAnalyzer", &g_define_type_info, 0);
            g_once_init_leave (&vala_flow_analyzer_type_id__volatile, vala_flow_analyzer_type_id);
      }
      return vala_flow_analyzer_type_id__volatile;
}


static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func) {
      if ((array != NULL) && (destroy_func != NULL)) {
            int i;
            for (i = 0; i < array_length; i = i + 1) {
                  if (((gpointer*) array)[i] != NULL) {
                        destroy_func (((gpointer*) array)[i]);
                  }
            }
      }
}


static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func) {
      _vala_array_destroy (array, array_length, destroy_func);
      g_free (array);
}




Generated by  Doxygen 1.6.0   Back to index