# instructions used to assemble the execution tree

use org.ternlang.tree.literal {
   binary = NumberLiteral,
   boolean = BooleanLiteral,
   class = TextLiteral,
   constructor = TextLiteral,
   decimal = NumberLiteral,
   hexadecimal = NumberLiteral,
   identifier = TextLiteral,
   module = TextLiteral,
   null = NullLiteral,
   text = TextLiteral,
   type = TextLiteral
}

use org.ternlang.tree {
   access-modifier = Modifier,
   access-modifier-list = ModifierList,
   argument = Argument,
   argument-entry = Argument,
   argument-list = ArgumentList,
   assert-statement = AssertStatement,
   break-statement = BreakStatement,
   cast = Cast,
   catch-block = CatchBlock,
   catch-block-list = CatchBlockList,
   closure-modifier = Modifier,
   closure-modifier-list = ModifierList,
   compound-statement = CompoundStatement,
   continue-statement = ContinueStatement,
   debug-statement = DebugStatement,
   declaration = Declaration,
   declaration-modifier = Modifier,
   declaration-statement = DeclarationStatement,
   empty-statement = EmptyStatement,
   expression = Expression,
   expression-statement = ExpressionStatement,
   field-modifier = Modifier,
   field-modifier-list = ModifierList,
   for-assignment-list = Expression,
   for-in-declaration = Declaration,
   full-qualifier = FullQualifier,
   function-modifier = Modifier,
   function-modifier-list = ModifierList,
   global = Global,
   global-statement = DeclarationStatement,
   import = Import,
   import-list = ImportList,
   import-static = ImportStatic,
   list-entry = Argument,
   list-entry-list = ArgumentList,
   module-modifier = Modifier,
   module-modifier-list = ModifierList,
   parameter-modifier = Modifier,
   parameter-modifier-list = ModifierList,
   place-holder = PlaceHolder,
   return-statement = ReturnStatement,
   script-modifier = Modifier,
   script-modifier-list = ModifierList,
   set-entry = Argument,
   set-entry-list = ArgumentList,
   super = Super,
   synchronized-statement = SynchronizedStatement,
   terminal-statement = EmptyStatement,
   this = This,
   throw-statement = ThrowStatement,
   try-statement = TryStatement,
   variable-argument = Modifier,
   wild-qualifier = WildQualifier
}

use org.ternlang.tree.annotation {
   annotation-declaration = AnnotationDeclaration,
   annotation-list = AnnotationList,
   annotation-name = AnnotationName
}

use org.ternlang.tree.closure {
   closure = Closure,
   closure-parameter-list = ClosureParameterList
}

use org.ternlang.tree.collection {
   collection-index = CollectionIndex,
   range = Range
}

use org.ternlang.tree.condition {
   choice = Choice,
   combination = Combination,
   comparison = Comparison,
   for-in-statement = ForInStatement,
   for-statement = ForStatement,
   if-statement = IfStatement,
   loop-statement = LoopStatement,
   match-case = ValueCase,
   match-default = DefaultCase,
   match-statement = MatchStatement,
   null-coalesce = NullCoalesce,
   switch-case = ValueCase,
   switch-default = DefaultCase,
   switch-statement = SwitchStatement,
   unless-statement = UnlessStatement,
   until-statement = UntilStatement,
   while-statement = WhileStatement
}

use org.ternlang.tree.constraint {
   alias-name = AliasName,
   class-constraint = ClassConstraint,
   class-name = ClassName,
   enum-name = EnumName,
   function-name = FunctionName,
   generic-parameter = GenericParameter,
   generic-parameter-list = GenericParameterList,
   trait-constraint = TraitConstraint,
   trait-name = TraitName,
   type-constraint = TypeConstraint
}

use org.ternlang.tree.construct {
   construct-array = ConstructArray,
   construct-list = ConstructList,
   construct-map = ConstructMap,
   construct-object = ConstructObject,
   construct-set = ConstructSet,
   list-entry-data = ElementData,
   map-entry = MapEntry,
   map-entry-data = MapEntryData,
   map-key = MapKey,
   set-entry-data = ElementData
}

use org.ternlang.tree.define {
   abstract-class-definition = AbstractClassDefinition,
   abstract-class-name = AbstractClassName,
   alias-definition = AliasDefinition,
   alias-hierarchy = AliasHierarchy,
   class-constructor = ClassConstructor,
   class-definition = ClassDefinition,
   class-field = MemberField,
   class-field-declaration = MemberFieldDeclaration,
   class-function = MemberFunction,
   class-hierarchy = ClassHierarchy,
   class-implicit-constructor = ClassImplicitConstructor,
   enum-constructor = EnumConstructor,
   enum-definition = EnumDefinition,
   enum-field = MemberField,
   enum-field-declaration = MemberFieldDeclaration,
   enum-function = MemberFunction,
   enum-hierarchy = EnumHierarchy,
   enum-implicit-constructor = EnumImplicitConstructor,
   enum-key = EnumKey,
   enum-list = EnumList,
   enum-value = EnumValue,
   inner-abstract-class-definition = InnerTypeDefinition,
   inner-alias-definition = InnerTypeDefinition,
   inner-class-definition = InnerTypeDefinition,
   inner-enum-definition = InnerTypeDefinition,
   inner-trait-definition = InnerTypeDefinition,
   module-declaration = ModuleDeclaration,
   module-definition = ModuleDefinition,
   module-function = ModuleFunction,
   module-import = ModuleStatement,
   module-name = ModuleName,
   module-property = ModuleProperty,
   module-statement = ModuleStatement,
   super-constructor = SuperConstructor,
   this-constructor = ThisConstructor,
   trait-constant = TraitConstant,
   trait-definition = TraitDefinition,
   trait-function = TraitFunction,
   trait-hierarchy = TraitHierarchy
}

use org.ternlang.tree.function {
   function-curry = FunctionCurry,
   function-handle = FunctionHandle,
   function-invocation = FunctionInvocation,
   parameter-blank = ParameterBlank,
   parameter-declaration = ParameterDeclaration,
   parameter-list = ParameterList
}

use org.ternlang.tree.operation {
   assignment = Assignment,
   assignment-list = AssignmentList,
   assignment-list-statement = AssignmentListStatement,
   assignment-statement = AssignmentStatement,
   calculation-list = CalculationList,
   calculation-operand = CalculationOperand,
   calculation-operator = CalculationOperator,
   number = SignedNumber,
   postfix-decrement = PostfixDecrement,
   postfix-increment = PostfixIncrement,
   prefix-decrement = PrefixDecrement,
   prefix-increment = PrefixIncrement,
   prefix-operation = PrefixOperation
}

use org.ternlang.tree.reference {
   array-reference = ArrayReference,
   function-reference = FunctionReference,
   generic-argument = GenericArgument,
   generic-argument-list = GenericArgumentList,
   generic-reference = GenericReference,
   list-reference = ListReference,
   map-reference = MapReference,
   reference = ReferenceNavigation,
   reference-invocation = ReferenceInvocation,
   reference-navigation = ReferenceNavigation,
   reference-part = ReferencePart,
   reference-property = ReferenceProperty,
   reference-variable = ReferencePart,
   set-reference = SetReference,
   type-reference = TypeReference,
   type-reference-part = TypeReferencePart
}

use org.ternlang.tree.resume {
   await-assignment-statement = AwaitStatement,
   await-declaration = AwaitDeclaration,
   await-declaration-statement = AwaitStatement,
   await-return-statement = AwaitReturnStatement,
   await-statement = AwaitStatement,
   yield-statement = YieldStatement
}

use org.ternlang.tree.script {
   script = Script,
   script-function = ScriptFunction,
   script-package = ScriptPackage
}

use org.ternlang.tree.template {
   template = TextTemplate
}

use org.ternlang.tree.variable {
   variable = Variable,
   variable-reference = VariableReference
}

