Require Import String List Coq.FSets.FMapList Coq.Structures.OrderedTypeEx.
Module Import F := FMapList.Make(Nat_as_OT).

Inductive named_node_data : Set :=
  | Named_Node : 
      nat (* reference *)
      -> named_node_data

with named_node : Set :=
  | NN_Library : library -> named_node
  | NN_Class : class -> named_node
  | NN_Member : member -> named_node


with reference : Set :=
  | Reference : 
      named_node (* node *)
      -> reference

with library : Set :=
  | Library : 
      named_node_data
      -> string (* name *)
      -> library_dependency_list (* dependencies *)
      -> reference_list (* additionalExports *)
      -> class_list (* classes *)
      -> procedure_list (* procedures *)
      -> field_list (* fields *)
      -> library

with library_dependency : Set :=
  | Library_Dependency : 
      nat (* importedLibraryReference *)
      -> string (* name *)
      -> combinator_list (* combinators *)
      -> library_dependency

with combinator : Set :=
  | Combinator : 
      bool (* isShow *)
      -> list string (* names *)
      -> combinator

with class : Set :=
  | Class : 
      named_node_data
      -> string (* name *)
      -> bool (* isAbstract *)
      -> type_parameter_list (* typeParameters *)
      -> supertype_option (* supertype *)
      -> supertype_option (* mixedInType *)
      -> supertype_list (* implementedTypes *)
      -> field_list (* fields *)
      -> constructor_list (* constructors *)
      -> procedure_list (* procedures *)
      -> interface_type (* _rawType *)
      -> interface_type (* _thisType *)
      -> interface_type (* _bottomType *)
      -> class

with member_data : Set :=
  | Member : 
      named_node_data
      -> name (* name *)
      -> member_data

with member : Set :=
  | M_Field : field -> member
  | M_Constructor : constructor -> member
  | M_Procedure : procedure -> member


with field : Set :=
  | Field : 
      member_data
      -> named_node_data
      -> dart_type (* type *)
      -> expression_option (* initializer *)
      -> field

with constructor : Set :=
  | Constructor : 
      member_data
      -> named_node_data
      -> function_node (* function *)
      -> initializer_list (* initializers *)
      -> constructor

with procedure : Set :=
  | Procedure : 
      member_data
      -> named_node_data
      -> procedure_kind (* kind *)
      -> function_node (* function *)
      -> procedure

with procedure_kind : Set := Method | Getter | Setter | Operator | Factory

with initializer : Set :=
  | I_Field_Initializer : field_initializer -> initializer
  | I_Super_Initializer : super_initializer -> initializer
  | I_Redirecting_Initializer : redirecting_initializer -> initializer
  | I_Local_Initializer : local_initializer -> initializer


with field_initializer : Set :=
  | Field_Initializer : 
      nat (* fieldReference *)
      -> expression (* value *)
      -> field_initializer

with super_initializer : Set :=
  | Super_Initializer : 
      nat (* targetReference *)
      -> arguments (* arguments *)
      -> super_initializer

with redirecting_initializer : Set :=
  | Redirecting_Initializer : 
      nat (* targetReference *)
      -> arguments (* arguments *)
      -> redirecting_initializer

with local_initializer : Set :=
  | Local_Initializer : 
      nat (* variable *)
      -> local_initializer

with function_node : Set :=
  | Function_Node : 
      async_marker (* asyncMarker *)
      -> type_parameter_list (* typeParameters *)
      -> nat (* requiredParameterCount *)
      -> variable_declaration_list (* positionalParameters *)
      -> variable_declaration_list (* namedParameters *)
      -> dart_type (* returnType *)
      -> statement (* body *)
      -> function_node

with async_marker : Set := Sync | Sync_Star | Async | Async_Star | Sync_Yielding

with expression : Set :=
  | E_Variable_Get : variable_get -> expression
  | E_Variable_Set : variable_set -> expression
  | E_Property_Get : property_get -> expression
  | E_Property_Set : property_set -> expression
  | E_Direct_Property_Get : direct_property_get -> expression
  | E_Direct_Property_Set : direct_property_set -> expression
  | E_Super_Property_Get : super_property_get -> expression
  | E_Super_Property_Set : super_property_set -> expression
  | E_Static_Get : static_get -> expression
  | E_Static_Set : static_set -> expression
  | E_Invocation_Expression : invocation_expression -> expression
  | E_Not : not -> expression
  | E_Logical_Expression : logical_expression -> expression
  | E_Conditional_Expression : conditional_expression -> expression
  | E_Is_Expression : is_expression -> expression
  | E_As_Expression : as_expression -> expression
  | E_Basic_Literal : basic_literal -> expression
  | E_Type_Literal : type_literal -> expression
  | E_This_Expression : this_expression -> expression
  | E_Rethrow : rethrow -> expression
  | E_Throw : throw -> expression
  | E_Function_Expression : function_expression -> expression
  | E_Let : dart_let -> expression
  | E_Vector_Creation : vector_creation -> expression
  | E_Vector_Get : vector_get -> expression
  | E_Vector_Set : vector_set -> expression
  | E_Vector_Copy : vector_copy -> expression
  | E_Closure_Creation : closure_creation -> expression


with variable_get : Set :=
  | Variable_Get : 
      nat (* variable *)
      -> dart_type_option (* promotedType *)
      -> variable_get

with variable_set : Set :=
  | Variable_Set : 
      nat (* variable *)
      -> expression (* value *)
      -> variable_set

with property_get : Set :=
  | Property_Get : 
      expression (* receiver *)
      -> name (* name *)
      -> property_get

with property_set : Set :=
  | Property_Set : 
      expression (* receiver *)
      -> name (* name *)
      -> expression (* value *)
      -> property_set

with direct_property_get : Set :=
  | Direct_Property_Get : 
      expression (* receiver *)
      -> nat (* targetReference *)
      -> direct_property_get

with direct_property_set : Set :=
  | Direct_Property_Set : 
      expression (* receiver *)
      -> nat (* targetReference *)
      -> expression (* value *)
      -> direct_property_set

with direct_method_invocation : Set :=
  | Direct_Method_Invocation : 
      expression (* receiver *)
      -> nat (* targetReference *)
      -> arguments (* arguments *)
      -> direct_method_invocation

with super_property_get : Set :=
  | Super_Property_Get : 
      name (* name *)
      -> super_property_get

with super_property_set : Set :=
  | Super_Property_Set : 
      name (* name *)
      -> expression (* value *)
      -> super_property_set

with static_get : Set :=
  | Static_Get : 
      nat (* targetReference *)
      -> static_get

with static_set : Set :=
  | Static_Set : 
      nat (* targetReference *)
      -> expression (* value *)
      -> static_set

with arguments : Set :=
  | Arguments : 
      dart_type_list (* types *)
      -> expression_list (* positional *)
      -> named_expression_list (* named *)
      -> arguments

with named_expression : Set :=
  | Named_Expression : 
      string (* name *)
      -> expression (* value *)
      -> named_expression

with invocation_expression : Set :=
  | IE_Direct_Method_Invocation : direct_method_invocation -> invocation_expression
  | IE_Method_Invocation : method_invocation -> invocation_expression
  | IE_Super_Method_Invocation : super_method_invocation -> invocation_expression
  | IE_Static_Invocation : static_invocation -> invocation_expression
  | IE_Constructor_Invocation : constructor_invocation -> invocation_expression


with method_invocation : Set :=
  | Method_Invocation : 
      expression (* receiver *)
      -> name (* name *)
      -> arguments (* arguments *)
      -> method_invocation

with super_method_invocation : Set :=
  | Super_Method_Invocation : 
      name (* name *)
      -> arguments (* arguments *)
      -> super_method_invocation

with static_invocation : Set :=
  | Static_Invocation : 
      nat (* targetReference *)
      -> arguments (* arguments *)
      -> bool (* isConst *)
      -> static_invocation

with constructor_invocation : Set :=
  | Constructor_Invocation : 
      nat (* targetReference *)
      -> arguments (* arguments *)
      -> bool (* isConst *)
      -> constructor_invocation

with not : Set :=
  | Not : 
      expression (* operand *)
      -> not

with logical_expression : Set :=
  | Logical_Expression : 
      expression (* left *)
      -> string (* operator *)
      -> expression (* right *)
      -> logical_expression

with conditional_expression : Set :=
  | Conditional_Expression : 
      expression (* condition *)
      -> expression (* then *)
      -> expression (* otherwise *)
      -> dart_type (* staticType *)
      -> conditional_expression

with is_expression : Set :=
  | Is_Expression : 
      expression (* operand *)
      -> dart_type (* type *)
      -> is_expression

with as_expression : Set :=
  | As_Expression : 
      expression (* operand *)
      -> dart_type (* type *)
      -> as_expression

with basic_literal : Set :=
  | BL_Bool_Literal : bool_literal -> basic_literal
  | BL_Null_Literal : null_literal -> basic_literal


with bool_literal : Set :=
  | Bool_Literal : 
      bool (* value *)
      -> bool_literal

with null_literal : Set :=
  | Null_Literal : 
      null_literal

with type_literal : Set :=
  | Type_Literal : 
      dart_type (* type *)
      -> type_literal

with this_expression : Set :=
  | This_Expression : 
      this_expression

with rethrow : Set :=
  | Rethrow : 
      rethrow

with throw : Set :=
  | Throw : 
      expression (* expression *)
      -> throw

with function_expression : Set :=
  | Function_Expression : 
      function_node (* function *)
      -> function_expression

with dart_let : Set :=
  | Let : 
      nat (* variable *)
      -> expression (* body *)
      -> dart_let

with vector_creation : Set :=
  | Vector_Creation : 
      nat (* length *)
      -> vector_creation

with vector_get : Set :=
  | Vector_Get : 
      expression (* vectorExpression *)
      -> nat (* index *)
      -> vector_get

with vector_set : Set :=
  | Vector_Set : 
      expression (* vectorExpression *)
      -> nat (* index *)
      -> expression (* value *)
      -> vector_set

with vector_copy : Set :=
  | Vector_Copy : 
      expression (* vectorExpression *)
      -> vector_copy

with closure_creation : Set :=
  | Closure_Creation : 
      nat (* topLevelFunctionReference *)
      -> expression (* contextVector *)
      -> function_type (* functionType *)
      -> dart_type_list (* typeArguments *)
      -> closure_creation

with statement : Set :=
  | S_Expression_Statement : expression_statement -> statement
  | S_Block : block -> statement
  | S_Empty_Statement : empty_statement -> statement
  | S_Labeled_Statement : labeled_statement -> statement
  | S_Break_Statement : break_statement -> statement
  | S_While_Statement : while_statement -> statement
  | S_Do_Statement : do_statement -> statement
  | S_For_Statement : for_statement -> statement
  | S_If_Statement : if_statement -> statement
  | S_Return_Statement : return_statement -> statement
  | S_Try_Catch : try_catch -> statement
  | S_Try_Finally : try_finally -> statement
  | S_Variable_Declaration : variable_declaration -> statement
  | S_Function_Declaration : function_declaration -> statement


with expression_statement : Set :=
  | Expression_Statement : 
      expression (* expression *)
      -> expression_statement

with block : Set :=
  | Block : 
      statement_list (* statements *)
      -> block

with empty_statement : Set :=
  | Empty_Statement : 
      empty_statement

with labeled_statement : Set :=
  | Labeled_Statement : 
      statement (* body *)
      -> labeled_statement

with break_statement : Set :=
  | Break_Statement : 
      nat (* target *)
      -> break_statement

with while_statement : Set :=
  | While_Statement : 
      expression (* condition *)
      -> statement (* body *)
      -> while_statement

with do_statement : Set :=
  | Do_Statement : 
      statement (* body *)
      -> expression (* condition *)
      -> do_statement

with for_statement : Set :=
  | For_Statement : 
      variable_declaration_list (* variables *)
      -> expression (* condition *)
      -> expression_list (* updates *)
      -> statement (* body *)
      -> for_statement

with if_statement : Set :=
  | If_Statement : 
      expression (* condition *)
      -> statement (* then *)
      -> statement (* otherwise *)
      -> if_statement

with return_statement : Set :=
  | Return_Statement : 
      expression (* expression *)
      -> return_statement

with try_catch : Set :=
  | Try_Catch : 
      statement (* body *)
      -> catch_list (* catches *)
      -> try_catch

with catch : Set :=
  | Catch : 
      dart_type (* guard *)
      -> nat (* exception *)
      -> statement (* body *)
      -> catch

with try_finally : Set :=
  | Try_Finally : 
      statement (* body *)
      -> statement (* finalizer *)
      -> try_finally

with variable_declaration : Set :=
  | Variable_Declaration : 
      string (* name *)
      -> dart_type (* type *)
      -> expression_option (* initializer *)
      -> variable_declaration

with function_declaration : Set :=
  | Function_Declaration : 
      nat (* variable *)
      -> function_node (* function *)
      -> function_declaration

with name_data : Set :=
  | Name : 
      string (* name *)
      -> name_data

with name : Set :=
  | N__Private_Name : _private_name -> name
  | N__Public_Name : _public_name -> name


with _private_name : Set :=
  | _Private_Name : 
      name_data
      -> nat (* libraryName *)
      -> _private_name

with _public_name : Set :=
  | _Public_Name : 
      name_data
      -> _public_name

with dart_type : Set :=
  | DT_Dynamic_Type : dynamic_type -> dart_type
  | DT_Void_Type : void_type -> dart_type
  | DT_Bottom_Type : bottom_type -> dart_type
  | DT_Interface_Type : interface_type -> dart_type
  | DT_Vector_Type : vector_type -> dart_type
  | DT_Function_Type : function_type -> dart_type
  | DT_Type_Parameter_Type : type_parameter_type -> dart_type


with dynamic_type : Set :=
  | Dynamic_Type : 
      dynamic_type

with void_type : Set :=
  | Void_Type : 
      void_type

with bottom_type : Set :=
  | Bottom_Type : 
      bottom_type

with interface_type : Set :=
  | Interface_Type : 
      nat (* className *)
      -> dart_type_list (* typeArguments *)
      -> interface_type

with vector_type : Set :=
  | Vector_Type : 
      vector_type

with function_type : Set :=
  | Function_Type : 
      type_parameter_list (* typeParameters *)
      -> dart_type_list (* positionalParameters *)
      -> named_type_list (* namedParameters *)
      -> dart_type (* returnType *)
      -> function_type

with named_type : Set :=
  | Named_Type : 
      string (* name *)
      -> dart_type (* type *)
      -> named_type

with type_parameter_type : Set :=
  | Type_Parameter_Type : 
      nat (* parameter *)
      -> dart_type_option (* promotedBound *)
      -> type_parameter_type

with type_parameter : Set :=
  | Type_Parameter : 
      string (* name *)
      -> dart_type (* bound *)
      -> type_parameter

with supertype : Set :=
  | Supertype : 
      nat (* className *)
      -> dart_type_list (* typeArguments *)
      -> supertype

with program : Set :=
  | Program : 
      library_list (* libraries *)
      -> nat (* mainMethodName *)
      -> program

with reference_list : Set :=
  | reference_nil : reference_list
  | reference_cons : nat -> reference_list -> reference_list

with library_list : Set :=
  | library_nil : library_list
  | library_cons : library -> library_list -> library_list

with library_dependency_list : Set :=
  | library_dependency_nil : library_dependency_list
  | library_dependency_cons : library_dependency -> library_dependency_list -> library_dependency_list

with combinator_list : Set :=
  | combinator_nil : combinator_list
  | combinator_cons : combinator -> combinator_list -> combinator_list

with class_list : Set :=
  | class_nil : class_list
  | class_cons : class -> class_list -> class_list

with field_list : Set :=
  | field_nil : field_list
  | field_cons : field -> field_list -> field_list

with constructor_list : Set :=
  | constructor_nil : constructor_list
  | constructor_cons : constructor -> constructor_list -> constructor_list

with procedure_list : Set :=
  | procedure_nil : procedure_list
  | procedure_cons : procedure -> procedure_list -> procedure_list

with procedure_kind_list : Set :=
  | procedure_kind_nil : procedure_kind_list
  | procedure_kind_cons : procedure_kind -> procedure_kind_list -> procedure_kind_list

with initializer_list : Set :=
  | initializer_nil : initializer_list
  | initializer_cons : initializer -> initializer_list -> initializer_list

with async_marker_list : Set :=
  | async_marker_nil : async_marker_list
  | async_marker_cons : async_marker -> async_marker_list -> async_marker_list

with expression_list : Set :=
  | expression_nil : expression_list
  | expression_cons : expression -> expression_list -> expression_list

with expression_option : Set :=
  | expression_none : expression_option
  | expression_some : expression -> expression_option

with named_expression_list : Set :=
  | named_expression_nil : named_expression_list
  | named_expression_cons : named_expression -> named_expression_list -> named_expression_list

with statement_list : Set :=
  | statement_nil : statement_list
  | statement_cons : statement -> statement_list -> statement_list

with catch_list : Set :=
  | catch_nil : catch_list
  | catch_cons : catch -> catch_list -> catch_list

with variable_declaration_list : Set :=
  | variable_declaration_nil : variable_declaration_list
  | variable_declaration_cons : nat -> variable_declaration_list -> variable_declaration_list

with dart_type_list : Set :=
  | dart_type_nil : dart_type_list
  | dart_type_cons : dart_type -> dart_type_list -> dart_type_list

with dart_type_option : Set :=
  | dart_type_none : dart_type_option
  | dart_type_some : dart_type -> dart_type_option

with named_type_list : Set :=
  | named_type_nil : named_type_list
  | named_type_cons : named_type -> named_type_list -> named_type_list

with type_parameter_list : Set :=
  | type_parameter_nil : type_parameter_list
  | type_parameter_cons : nat -> type_parameter_list -> type_parameter_list

with supertype_list : Set :=
  | supertype_nil : supertype_list
  | supertype_cons : supertype -> supertype_list -> supertype_list

with supertype_option : Set :=
  | supertype_none : supertype_option
  | supertype_some : supertype -> supertype_option

.

Record ast_store : Type := Ast_Store {
  r_refs : F.t reference;
  ls_refs : F.t labeled_statement;
  vd_refs : F.t variable_declaration;
  tp_refs : F.t type_parameter;
}.

Fixpoint named_node_validity (ast : ast_store) (T : named_node) {struct T} : Prop :=
  match T with
    | NN_Library ST => library_validity ast ST
    | NN_Class ST => class_validity ast ST
    | NN_Member ST => member_validity ast ST
end
with named_node_data_validity (ast : ast_store) (T : named_node_data) {struct T}: Prop :=
  match T with
    | Named_Node f0 =>
        F.In f0 (r_refs ast)
  end
with reference_validity (ast : ast_store) (T : reference) {struct T} : Prop :=
  match T with
    | Reference f0 =>
        named_node_validity ast f0
  end
with library_validity (ast : ast_store) (T : library) {struct T} : Prop :=
  match T with
    | Library f0 _ f1 f2 f3 f4 f5 =>
        named_node_data_validity ast f0 /\
        library_dependency_list_validity ast f1 /\
        reference_list_validity ast f2 /\
        class_list_validity ast f3 /\
        procedure_list_validity ast f4 /\
        field_list_validity ast f5
  end
with library_dependency_validity (ast : ast_store) (T : library_dependency) {struct T} : Prop :=
  match T with
    | Library_Dependency f0 _ f1 =>
        F.In f0 (r_refs ast) /\
        combinator_list_validity ast f1
  end
with combinator_validity (ast : ast_store) (T : combinator) {struct T} : Prop :=
  match T with
    | Combinator _ _ =>
        True
  end
with class_validity (ast : ast_store) (T : class) {struct T} : Prop :=
  match T with
    | Class f0 _ _ f1 f2 f3 f4 f5 f6 f7 f8 f9 f10 =>
        named_node_data_validity ast f0 /\
        type_parameter_list_validity ast f1 /\
        supertype_option_validity ast f2 /\
        supertype_option_validity ast f3 /\
        supertype_list_validity ast f4 /\
        field_list_validity ast f5 /\
        constructor_list_validity ast f6 /\
        procedure_list_validity ast f7 /\
        interface_type_validity ast f8 /\
        interface_type_validity ast f9 /\
        interface_type_validity ast f10
  end
with member_validity (ast : ast_store) (T : member) {struct T} : Prop :=
  match T with
    | M_Field ST => field_validity ast ST
    | M_Constructor ST => constructor_validity ast ST
    | M_Procedure ST => procedure_validity ast ST
end
with member_data_validity (ast : ast_store) (T : member_data) {struct T}: Prop :=
  match T with
    | Member f0 f1 =>
        named_node_data_validity ast f0 /\
        name_validity ast f1
  end
with field_validity (ast : ast_store) (T : field) {struct T} : Prop :=
  match T with
    | Field f0 f1 f2 f3 =>
        member_data_validity ast f0 /\
        named_node_data_validity ast f1 /\
        dart_type_validity ast f2 /\
        expression_option_validity ast f3
  end
with constructor_validity (ast : ast_store) (T : constructor) {struct T} : Prop :=
  match T with
    | Constructor f0 f1 f2 f3 =>
        member_data_validity ast f0 /\
        named_node_data_validity ast f1 /\
        function_node_validity ast f2 /\
        initializer_list_validity ast f3
  end
with procedure_validity (ast : ast_store) (T : procedure) {struct T} : Prop :=
  match T with
    | Procedure f0 f1 f2 f3 =>
        member_data_validity ast f0 /\
        named_node_data_validity ast f1 /\
        procedure_kind_validity ast f2 /\
        function_node_validity ast f3
  end
with procedure_kind_validity (ast : ast_store) (T : procedure_kind) {struct T} : Prop := True
with initializer_validity (ast : ast_store) (T : initializer) {struct T} : Prop :=
  match T with
    | I_Field_Initializer ST => field_initializer_validity ast ST
    | I_Super_Initializer ST => super_initializer_validity ast ST
    | I_Redirecting_Initializer ST => redirecting_initializer_validity ast ST
    | I_Local_Initializer ST => local_initializer_validity ast ST
end
with field_initializer_validity (ast : ast_store) (T : field_initializer) {struct T} : Prop :=
  match T with
    | Field_Initializer f0 f1 =>
        F.In f0 (r_refs ast) /\
        expression_validity ast f1
  end
with super_initializer_validity (ast : ast_store) (T : super_initializer) {struct T} : Prop :=
  match T with
    | Super_Initializer f0 f1 =>
        F.In f0 (r_refs ast) /\
        arguments_validity ast f1
  end
with redirecting_initializer_validity (ast : ast_store) (T : redirecting_initializer) {struct T} : Prop :=
  match T with
    | Redirecting_Initializer f0 f1 =>
        F.In f0 (r_refs ast) /\
        arguments_validity ast f1
  end
with local_initializer_validity (ast : ast_store) (T : local_initializer) {struct T} : Prop :=
  match T with
    | Local_Initializer f0 =>
        F.In f0 (vd_refs ast)
  end
with function_node_validity (ast : ast_store) (T : function_node) {struct T} : Prop :=
  match T with
    | Function_Node f0 f1 _ f2 f3 f4 f5 =>
        async_marker_validity ast f0 /\
        type_parameter_list_validity ast f1 /\
        variable_declaration_list_validity ast f2 /\
        variable_declaration_list_validity ast f3 /\
        dart_type_validity ast f4 /\
        statement_validity ast f5
  end
with async_marker_validity (ast : ast_store) (T : async_marker) {struct T} : Prop := True
with expression_validity (ast : ast_store) (T : expression) {struct T} : Prop :=
  match T with
    | E_Variable_Get ST => variable_get_validity ast ST
    | E_Variable_Set ST => variable_set_validity ast ST
    | E_Property_Get ST => property_get_validity ast ST
    | E_Property_Set ST => property_set_validity ast ST
    | E_Direct_Property_Get ST => direct_property_get_validity ast ST
    | E_Direct_Property_Set ST => direct_property_set_validity ast ST
    | E_Super_Property_Get ST => super_property_get_validity ast ST
    | E_Super_Property_Set ST => super_property_set_validity ast ST
    | E_Static_Get ST => static_get_validity ast ST
    | E_Static_Set ST => static_set_validity ast ST
    | E_Invocation_Expression ST => invocation_expression_validity ast ST
    | E_Not ST => not_validity ast ST
    | E_Logical_Expression ST => logical_expression_validity ast ST
    | E_Conditional_Expression ST => conditional_expression_validity ast ST
    | E_Is_Expression ST => is_expression_validity ast ST
    | E_As_Expression ST => as_expression_validity ast ST
    | E_Basic_Literal ST => basic_literal_validity ast ST
    | E_Type_Literal ST => type_literal_validity ast ST
    | E_This_Expression ST => this_expression_validity ast ST
    | E_Rethrow ST => rethrow_validity ast ST
    | E_Throw ST => throw_validity ast ST
    | E_Function_Expression ST => function_expression_validity ast ST
    | E_Let ST => dart_let_validity ast ST
    | E_Vector_Creation ST => vector_creation_validity ast ST
    | E_Vector_Get ST => vector_get_validity ast ST
    | E_Vector_Set ST => vector_set_validity ast ST
    | E_Vector_Copy ST => vector_copy_validity ast ST
    | E_Closure_Creation ST => closure_creation_validity ast ST
end
with variable_get_validity (ast : ast_store) (T : variable_get) {struct T} : Prop :=
  match T with
    | Variable_Get f0 f1 =>
        F.In f0 (vd_refs ast) /\
        dart_type_option_validity ast f1
  end
with variable_set_validity (ast : ast_store) (T : variable_set) {struct T} : Prop :=
  match T with
    | Variable_Set f0 f1 =>
        F.In f0 (vd_refs ast) /\
        expression_validity ast f1
  end
with property_get_validity (ast : ast_store) (T : property_get) {struct T} : Prop :=
  match T with
    | Property_Get f0 f1 =>
        expression_validity ast f0 /\
        name_validity ast f1
  end
with property_set_validity (ast : ast_store) (T : property_set) {struct T} : Prop :=
  match T with
    | Property_Set f0 f1 f2 =>
        expression_validity ast f0 /\
        name_validity ast f1 /\
        expression_validity ast f2
  end
with direct_property_get_validity (ast : ast_store) (T : direct_property_get) {struct T} : Prop :=
  match T with
    | Direct_Property_Get f0 f1 =>
        expression_validity ast f0 /\
        F.In f1 (r_refs ast)
  end
with direct_property_set_validity (ast : ast_store) (T : direct_property_set) {struct T} : Prop :=
  match T with
    | Direct_Property_Set f0 f1 f2 =>
        expression_validity ast f0 /\
        F.In f1 (r_refs ast) /\
        expression_validity ast f2
  end
with direct_method_invocation_validity (ast : ast_store) (T : direct_method_invocation) {struct T} : Prop :=
  match T with
    | Direct_Method_Invocation f0 f1 f2 =>
        expression_validity ast f0 /\
        F.In f1 (r_refs ast) /\
        arguments_validity ast f2
  end
with super_property_get_validity (ast : ast_store) (T : super_property_get) {struct T} : Prop :=
  match T with
    | Super_Property_Get f0 =>
        name_validity ast f0
  end
with super_property_set_validity (ast : ast_store) (T : super_property_set) {struct T} : Prop :=
  match T with
    | Super_Property_Set f0 f1 =>
        name_validity ast f0 /\
        expression_validity ast f1
  end
with static_get_validity (ast : ast_store) (T : static_get) {struct T} : Prop :=
  match T with
    | Static_Get f0 =>
        F.In f0 (r_refs ast)
  end
with static_set_validity (ast : ast_store) (T : static_set) {struct T} : Prop :=
  match T with
    | Static_Set f0 f1 =>
        F.In f0 (r_refs ast) /\
        expression_validity ast f1
  end
with arguments_validity (ast : ast_store) (T : arguments) {struct T} : Prop :=
  match T with
    | Arguments f0 f1 f2 =>
        dart_type_list_validity ast f0 /\
        expression_list_validity ast f1 /\
        named_expression_list_validity ast f2
  end
with named_expression_validity (ast : ast_store) (T : named_expression) {struct T} : Prop :=
  match T with
    | Named_Expression _ f0 =>
        expression_validity ast f0
  end
with invocation_expression_validity (ast : ast_store) (T : invocation_expression) {struct T} : Prop :=
  match T with
    | IE_Direct_Method_Invocation ST => direct_method_invocation_validity ast ST
    | IE_Method_Invocation ST => method_invocation_validity ast ST
    | IE_Super_Method_Invocation ST => super_method_invocation_validity ast ST
    | IE_Static_Invocation ST => static_invocation_validity ast ST
    | IE_Constructor_Invocation ST => constructor_invocation_validity ast ST
end
with method_invocation_validity (ast : ast_store) (T : method_invocation) {struct T} : Prop :=
  match T with
    | Method_Invocation f0 f1 f2 =>
        expression_validity ast f0 /\
        name_validity ast f1 /\
        arguments_validity ast f2
  end
with super_method_invocation_validity (ast : ast_store) (T : super_method_invocation) {struct T} : Prop :=
  match T with
    | Super_Method_Invocation f0 f1 =>
        name_validity ast f0 /\
        arguments_validity ast f1
  end
with static_invocation_validity (ast : ast_store) (T : static_invocation) {struct T} : Prop :=
  match T with
    | Static_Invocation f0 f1 _ =>
        F.In f0 (r_refs ast) /\
        arguments_validity ast f1
  end
with constructor_invocation_validity (ast : ast_store) (T : constructor_invocation) {struct T} : Prop :=
  match T with
    | Constructor_Invocation f0 f1 _ =>
        F.In f0 (r_refs ast) /\
        arguments_validity ast f1
  end
with not_validity (ast : ast_store) (T : not) {struct T} : Prop :=
  match T with
    | Not f0 =>
        expression_validity ast f0
  end
with logical_expression_validity (ast : ast_store) (T : logical_expression) {struct T} : Prop :=
  match T with
    | Logical_Expression f0 _ f1 =>
        expression_validity ast f0 /\
        expression_validity ast f1
  end
with conditional_expression_validity (ast : ast_store) (T : conditional_expression) {struct T} : Prop :=
  match T with
    | Conditional_Expression f0 f1 f2 f3 =>
        expression_validity ast f0 /\
        expression_validity ast f1 /\
        expression_validity ast f2 /\
        dart_type_validity ast f3
  end
with is_expression_validity (ast : ast_store) (T : is_expression) {struct T} : Prop :=
  match T with
    | Is_Expression f0 f1 =>
        expression_validity ast f0 /\
        dart_type_validity ast f1
  end
with as_expression_validity (ast : ast_store) (T : as_expression) {struct T} : Prop :=
  match T with
    | As_Expression f0 f1 =>
        expression_validity ast f0 /\
        dart_type_validity ast f1
  end
with basic_literal_validity (ast : ast_store) (T : basic_literal) {struct T} : Prop :=
  match T with
    | BL_Bool_Literal ST => bool_literal_validity ast ST
    | BL_Null_Literal ST => null_literal_validity ast ST
end
with bool_literal_validity (ast : ast_store) (T : bool_literal) {struct T} : Prop :=
  match T with
    | Bool_Literal _ =>
        True
  end
with null_literal_validity (ast : ast_store) (T : null_literal) {struct T} : Prop :=
  match T with
    | Null_Literal  =>
        True
  end
with type_literal_validity (ast : ast_store) (T : type_literal) {struct T} : Prop :=
  match T with
    | Type_Literal f0 =>
        dart_type_validity ast f0
  end
with this_expression_validity (ast : ast_store) (T : this_expression) {struct T} : Prop :=
  match T with
    | This_Expression  =>
        True
  end
with rethrow_validity (ast : ast_store) (T : rethrow) {struct T} : Prop :=
  match T with
    | Rethrow  =>
        True
  end
with throw_validity (ast : ast_store) (T : throw) {struct T} : Prop :=
  match T with
    | Throw f0 =>
        expression_validity ast f0
  end
with function_expression_validity (ast : ast_store) (T : function_expression) {struct T} : Prop :=
  match T with
    | Function_Expression f0 =>
        function_node_validity ast f0
  end
with dart_let_validity (ast : ast_store) (T : dart_let) {struct T} : Prop :=
  match T with
    | Let f0 f1 =>
        F.In f0 (vd_refs ast) /\
        expression_validity ast f1
  end
with vector_creation_validity (ast : ast_store) (T : vector_creation) {struct T} : Prop :=
  match T with
    | Vector_Creation _ =>
        True
  end
with vector_get_validity (ast : ast_store) (T : vector_get) {struct T} : Prop :=
  match T with
    | Vector_Get f0 _ =>
        expression_validity ast f0
  end
with vector_set_validity (ast : ast_store) (T : vector_set) {struct T} : Prop :=
  match T with
    | Vector_Set f0 _ f1 =>
        expression_validity ast f0 /\
        expression_validity ast f1
  end
with vector_copy_validity (ast : ast_store) (T : vector_copy) {struct T} : Prop :=
  match T with
    | Vector_Copy f0 =>
        expression_validity ast f0
  end
with closure_creation_validity (ast : ast_store) (T : closure_creation) {struct T} : Prop :=
  match T with
    | Closure_Creation f0 f1 f2 f3 =>
        F.In f0 (r_refs ast) /\
        expression_validity ast f1 /\
        function_type_validity ast f2 /\
        dart_type_list_validity ast f3
  end
with statement_validity (ast : ast_store) (T : statement) {struct T} : Prop :=
  match T with
    | S_Expression_Statement ST => expression_statement_validity ast ST
    | S_Block ST => block_validity ast ST
    | S_Empty_Statement ST => empty_statement_validity ast ST
    | S_Labeled_Statement ST => labeled_statement_validity ast ST
    | S_Break_Statement ST => break_statement_validity ast ST
    | S_While_Statement ST => while_statement_validity ast ST
    | S_Do_Statement ST => do_statement_validity ast ST
    | S_For_Statement ST => for_statement_validity ast ST
    | S_If_Statement ST => if_statement_validity ast ST
    | S_Return_Statement ST => return_statement_validity ast ST
    | S_Try_Catch ST => try_catch_validity ast ST
    | S_Try_Finally ST => try_finally_validity ast ST
    | S_Variable_Declaration ST => variable_declaration_validity ast ST
    | S_Function_Declaration ST => function_declaration_validity ast ST
end
with expression_statement_validity (ast : ast_store) (T : expression_statement) {struct T} : Prop :=
  match T with
    | Expression_Statement f0 =>
        expression_validity ast f0
  end
with block_validity (ast : ast_store) (T : block) {struct T} : Prop :=
  match T with
    | Block f0 =>
        statement_list_validity ast f0
  end
with empty_statement_validity (ast : ast_store) (T : empty_statement) {struct T} : Prop :=
  match T with
    | Empty_Statement  =>
        True
  end
with labeled_statement_validity (ast : ast_store) (T : labeled_statement) {struct T} : Prop :=
  match T with
    | Labeled_Statement f0 =>
        statement_validity ast f0
  end
with break_statement_validity (ast : ast_store) (T : break_statement) {struct T} : Prop :=
  match T with
    | Break_Statement f0 =>
        F.In f0 (ls_refs ast)
  end
with while_statement_validity (ast : ast_store) (T : while_statement) {struct T} : Prop :=
  match T with
    | While_Statement f0 f1 =>
        expression_validity ast f0 /\
        statement_validity ast f1
  end
with do_statement_validity (ast : ast_store) (T : do_statement) {struct T} : Prop :=
  match T with
    | Do_Statement f0 f1 =>
        statement_validity ast f0 /\
        expression_validity ast f1
  end
with for_statement_validity (ast : ast_store) (T : for_statement) {struct T} : Prop :=
  match T with
    | For_Statement f0 f1 f2 f3 =>
        variable_declaration_list_validity ast f0 /\
        expression_validity ast f1 /\
        expression_list_validity ast f2 /\
        statement_validity ast f3
  end
with if_statement_validity (ast : ast_store) (T : if_statement) {struct T} : Prop :=
  match T with
    | If_Statement f0 f1 f2 =>
        expression_validity ast f0 /\
        statement_validity ast f1 /\
        statement_validity ast f2
  end
with return_statement_validity (ast : ast_store) (T : return_statement) {struct T} : Prop :=
  match T with
    | Return_Statement f0 =>
        expression_validity ast f0
  end
with try_catch_validity (ast : ast_store) (T : try_catch) {struct T} : Prop :=
  match T with
    | Try_Catch f0 f1 =>
        statement_validity ast f0 /\
        catch_list_validity ast f1
  end
with catch_validity (ast : ast_store) (T : catch) {struct T} : Prop :=
  match T with
    | Catch f0 f1 f2 =>
        dart_type_validity ast f0 /\
        F.In f1 (vd_refs ast) /\
        statement_validity ast f2
  end
with try_finally_validity (ast : ast_store) (T : try_finally) {struct T} : Prop :=
  match T with
    | Try_Finally f0 f1 =>
        statement_validity ast f0 /\
        statement_validity ast f1
  end
with variable_declaration_validity (ast : ast_store) (T : variable_declaration) {struct T} : Prop :=
  match T with
    | Variable_Declaration _ f0 f1 =>
        dart_type_validity ast f0 /\
        expression_option_validity ast f1
  end
with function_declaration_validity (ast : ast_store) (T : function_declaration) {struct T} : Prop :=
  match T with
    | Function_Declaration f0 f1 =>
        F.In f0 (vd_refs ast) /\
        function_node_validity ast f1
  end
with name_validity (ast : ast_store) (T : name) {struct T} : Prop :=
  match T with
    | N__Private_Name ST => _private_name_validity ast ST
    | N__Public_Name ST => _public_name_validity ast ST
end
with name_data_validity (ast : ast_store) (T : name_data) {struct T}: Prop :=
  match T with
    | Name _ =>
        True
  end
with _private_name_validity (ast : ast_store) (T : _private_name) {struct T} : Prop :=
  match T with
    | _Private_Name f0 f1 =>
        name_data_validity ast f0 /\
        F.In f1 (r_refs ast)
  end
with _public_name_validity (ast : ast_store) (T : _public_name) {struct T} : Prop :=
  match T with
    | _Public_Name f0 =>
        name_data_validity ast f0
  end
with dart_type_validity (ast : ast_store) (T : dart_type) {struct T} : Prop :=
  match T with
    | DT_Dynamic_Type ST => dynamic_type_validity ast ST
    | DT_Void_Type ST => void_type_validity ast ST
    | DT_Bottom_Type ST => bottom_type_validity ast ST
    | DT_Interface_Type ST => interface_type_validity ast ST
    | DT_Vector_Type ST => vector_type_validity ast ST
    | DT_Function_Type ST => function_type_validity ast ST
    | DT_Type_Parameter_Type ST => type_parameter_type_validity ast ST
end
with dynamic_type_validity (ast : ast_store) (T : dynamic_type) {struct T} : Prop :=
  match T with
    | Dynamic_Type  =>
        True
  end
with void_type_validity (ast : ast_store) (T : void_type) {struct T} : Prop :=
  match T with
    | Void_Type  =>
        True
  end
with bottom_type_validity (ast : ast_store) (T : bottom_type) {struct T} : Prop :=
  match T with
    | Bottom_Type  =>
        True
  end
with interface_type_validity (ast : ast_store) (T : interface_type) {struct T} : Prop :=
  match T with
    | Interface_Type f0 f1 =>
        F.In f0 (r_refs ast) /\
        dart_type_list_validity ast f1
  end
with vector_type_validity (ast : ast_store) (T : vector_type) {struct T} : Prop :=
  match T with
    | Vector_Type  =>
        True
  end
with function_type_validity (ast : ast_store) (T : function_type) {struct T} : Prop :=
  match T with
    | Function_Type f0 f1 f2 f3 =>
        type_parameter_list_validity ast f0 /\
        dart_type_list_validity ast f1 /\
        named_type_list_validity ast f2 /\
        dart_type_validity ast f3
  end
with named_type_validity (ast : ast_store) (T : named_type) {struct T} : Prop :=
  match T with
    | Named_Type _ f0 =>
        dart_type_validity ast f0
  end
with type_parameter_type_validity (ast : ast_store) (T : type_parameter_type) {struct T} : Prop :=
  match T with
    | Type_Parameter_Type f0 f1 =>
        F.In f0 (tp_refs ast) /\
        dart_type_option_validity ast f1
  end
with type_parameter_validity (ast : ast_store) (T : type_parameter) {struct T} : Prop :=
  match T with
    | Type_Parameter _ f0 =>
        dart_type_validity ast f0
  end
with supertype_validity (ast : ast_store) (T : supertype) {struct T} : Prop :=
  match T with
    | Supertype f0 f1 =>
        F.In f0 (r_refs ast) /\
        dart_type_list_validity ast f1
  end
with program_validity (ast : ast_store) (T : program) {struct T} : Prop :=
  match T with
    | Program f0 f1 =>
        library_list_validity ast f0 /\
        F.In f1 (r_refs ast)
  end
with reference_list_validity (ast : ast_store) (L : reference_list) {struct L} : Prop :=
  match L with
    | reference_nil => True
    | reference_cons X XS => F.In X (r_refs ast) /\ reference_list_validity ast XS
  end
with library_list_validity (ast : ast_store) (L : library_list) {struct L} : Prop :=
  match L with
    | library_nil => True
    | library_cons X XS => library_validity ast X /\ library_list_validity ast XS
  end
with library_dependency_list_validity (ast : ast_store) (L : library_dependency_list) {struct L} : Prop :=
  match L with
    | library_dependency_nil => True
    | library_dependency_cons X XS => library_dependency_validity ast X /\ library_dependency_list_validity ast XS
  end
with combinator_list_validity (ast : ast_store) (L : combinator_list) {struct L} : Prop :=
  match L with
    | combinator_nil => True
    | combinator_cons X XS => combinator_validity ast X /\ combinator_list_validity ast XS
  end
with class_list_validity (ast : ast_store) (L : class_list) {struct L} : Prop :=
  match L with
    | class_nil => True
    | class_cons X XS => class_validity ast X /\ class_list_validity ast XS
  end
with field_list_validity (ast : ast_store) (L : field_list) {struct L} : Prop :=
  match L with
    | field_nil => True
    | field_cons X XS => field_validity ast X /\ field_list_validity ast XS
  end
with constructor_list_validity (ast : ast_store) (L : constructor_list) {struct L} : Prop :=
  match L with
    | constructor_nil => True
    | constructor_cons X XS => constructor_validity ast X /\ constructor_list_validity ast XS
  end
with procedure_list_validity (ast : ast_store) (L : procedure_list) {struct L} : Prop :=
  match L with
    | procedure_nil => True
    | procedure_cons X XS => procedure_validity ast X /\ procedure_list_validity ast XS
  end
with procedure_kind_list_validity (ast : ast_store) (L : procedure_kind_list) {struct L} : Prop :=
  match L with
    | procedure_kind_nil => True
    | procedure_kind_cons X XS => procedure_kind_validity ast X /\ procedure_kind_list_validity ast XS
  end
with initializer_list_validity (ast : ast_store) (L : initializer_list) {struct L} : Prop :=
  match L with
    | initializer_nil => True
    | initializer_cons X XS => initializer_validity ast X /\ initializer_list_validity ast XS
  end
with async_marker_list_validity (ast : ast_store) (L : async_marker_list) {struct L} : Prop :=
  match L with
    | async_marker_nil => True
    | async_marker_cons X XS => async_marker_validity ast X /\ async_marker_list_validity ast XS
  end
with expression_list_validity (ast : ast_store) (L : expression_list) {struct L} : Prop :=
  match L with
    | expression_nil => True
    | expression_cons X XS => expression_validity ast X /\ expression_list_validity ast XS
  end
with expression_option_validity (ast : ast_store) (O : expression_option) {struct O} : Prop :=
  match O with
    | expression_none => True
    | expression_some X => expression_validity ast X
  end
with named_expression_list_validity (ast : ast_store) (L : named_expression_list) {struct L} : Prop :=
  match L with
    | named_expression_nil => True
    | named_expression_cons X XS => named_expression_validity ast X /\ named_expression_list_validity ast XS
  end
with statement_list_validity (ast : ast_store) (L : statement_list) {struct L} : Prop :=
  match L with
    | statement_nil => True
    | statement_cons X XS => statement_validity ast X /\ statement_list_validity ast XS
  end
with catch_list_validity (ast : ast_store) (L : catch_list) {struct L} : Prop :=
  match L with
    | catch_nil => True
    | catch_cons X XS => catch_validity ast X /\ catch_list_validity ast XS
  end
with variable_declaration_list_validity (ast : ast_store) (L : variable_declaration_list) {struct L} : Prop :=
  match L with
    | variable_declaration_nil => True
    | variable_declaration_cons X XS => F.In X (vd_refs ast) /\ variable_declaration_list_validity ast XS
  end
with dart_type_list_validity (ast : ast_store) (L : dart_type_list) {struct L} : Prop :=
  match L with
    | dart_type_nil => True
    | dart_type_cons X XS => dart_type_validity ast X /\ dart_type_list_validity ast XS
  end
with dart_type_option_validity (ast : ast_store) (O : dart_type_option) {struct O} : Prop :=
  match O with
    | dart_type_none => True
    | dart_type_some X => dart_type_validity ast X
  end
with named_type_list_validity (ast : ast_store) (L : named_type_list) {struct L} : Prop :=
  match L with
    | named_type_nil => True
    | named_type_cons X XS => named_type_validity ast X /\ named_type_list_validity ast XS
  end
with type_parameter_list_validity (ast : ast_store) (L : type_parameter_list) {struct L} : Prop :=
  match L with
    | type_parameter_nil => True
    | type_parameter_cons X XS => F.In X (tp_refs ast) /\ type_parameter_list_validity ast XS
  end
with supertype_list_validity (ast : ast_store) (L : supertype_list) {struct L} : Prop :=
  match L with
    | supertype_nil => True
    | supertype_cons X XS => supertype_validity ast X /\ supertype_list_validity ast XS
  end
with supertype_option_validity (ast : ast_store) (O : supertype_option) {struct O} : Prop :=
  match O with
    | supertype_none => True
    | supertype_some X => supertype_validity ast X
  end
.

Definition ast_store_validity (ast : ast_store) : Prop := 
  forall (n : nat), forall (X : reference), F.MapsTo n X (r_refs ast) -> reference_validity ast X /\
  forall (n : nat), forall (X : labeled_statement), F.MapsTo n X (ls_refs ast) -> labeled_statement_validity ast X /\
  forall (n : nat), forall (X : variable_declaration), F.MapsTo n X (vd_refs ast) -> variable_declaration_validity ast X /\
  forall (n : nat), forall (X : type_parameter), F.MapsTo n X (tp_refs ast) -> type_parameter_validity ast X
.