ast.model.boo

"""
The classes in this module model the entire AST for the language.

The actual AST classes and supporting modules are generated
by a boo script.
"""
namespace Boo.Ast

classCompileUnit(Node):
 Modules as ModuleCollection 

[Flags]
enum TypeMemberModifiers:
 None =0
 Private =1
 Internal =2
 Protected =4
 Public =8
 Transient =16
 Static =32
 Final =64
 Virtual =128
 Override =256
 Abstract =512
 Partial =1024
 New =2048
 VisibilityMask =15

enum MethodImplementationFlags:
 None =0
 Runtime =1

enum ParameterModifiers:
 None =0
 Val =0
 Ref =1

[Flags]
enum ExceptionHandlerFlags:
 None =0
 Anonymous =1
 Untyped =2
 Filter =4

[Flags]
enum GenericParameterConstraints:
 None =0
 ValueType =1
 ReferenceType =2
 Constructable =4
 Covariant =8
 Contravariant =16

abstract classTypeMember(Node, INodeWithAttributes):
 Modifiers as TypeMemberModifiers
 Name asstring
 Attributes as AttributeCollection

classTypeMemberStatement(Statement):
 TypeMember as TypeMember

classExplicitMemberInfo(Node):
 InterfaceType as SimpleTypeReference

[collection(TypeMember)]
classTypeMemberCollection:
pass

abstract classTypeReference(Node):
 IsPointer asbool

classSimpleTypeReference(TypeReference):
 Name asstring

classArrayTypeReference(TypeReference):
 ElementType as TypeReference
 Rank as IntegerLiteralExpression

classCallableTypeReference(TypeReference, INodeWithParameters):
 Parameters as ParameterDeclarationCollection
 ReturnType as TypeReference

classGenericTypeReference(SimpleTypeReference):
 GenericArguments as TypeReferenceCollection

classGenericTypeDefinitionReference(SimpleTypeReference):
 GenericPlaceholders asint

[collection(TypeReference)]
classTypeReferenceCollection:
pass

classCallableDefinition(TypeMember, INodeWithParameters, INodeWithGenericParameters):
 Parameters as ParameterDeclarationCollection
 GenericParameters as GenericParameterDeclarationCollection
 ReturnType as TypeReference
 ReturnTypeAttributes as AttributeCollection

abstract classTypeDefinition(TypeMember, INodeWithGenericParameters):
 Members as TypeMemberCollection
 BaseTypes as TypeReferenceCollection
 GenericParameters as GenericParameterDeclarationCollection

[collection(TypeDefinition)]
classTypeDefinitionCollection:
pass

classNamespaceDeclaration(Node):
 Name asstring

classImport(Node):
 Expression as Expression
 AssemblyReference as ReferenceExpression
 Alias as ReferenceExpression

[collection(Import)]
classImportCollection:
pass

classModule(TypeDefinition):
 Namespace as NamespaceDeclaration
 Imports as ImportCollection
 [auto]
 Globals as Block
 AssemblyAttributes as AttributeCollection

[collection(Module)]
classModuleCollection:
pass

classClassDefinition(TypeDefinition):
pass

classStructDefinition(TypeDefinition):
pass

classInterfaceDefinition(TypeDefinition):
pass

classEnumDefinition(TypeDefinition):
pass

classEnumMember(TypeMember):
 Initializer as Expression

classField(TypeMember):
 Type as TypeReference
 Initializer as Expression
 IsVolatile asbool

classProperty(TypeMember, INodeWithParameters, IExplicitMember):
 Parameters as ParameterDeclarationCollection
 Getter as Method
 Setter as Method
 Type as TypeReference
 ExplicitInfo as ExplicitMemberInfo

classEvent(TypeMember):
 Add as Method
 Remove as Method
 Raise as Method
 Type as TypeReference

classLocal(Node):
 Name asstring

[collection(Local)]
classLocalCollection:
pass

classBlockExpression(Expression, INodeWithParameters, INodeWithBody):
 Parameters as ParameterDeclarationCollection
 ReturnType as TypeReference
 [auto]
 Body as Block

classMethod(CallableDefinition, IExplicitMember, INodeWithBody):
 [auto]
 Body as Block
 Locals as LocalCollection
 ImplementationFlags as MethodImplementationFlags
 ExplicitInfo as ExplicitMemberInfo

classConstructor(Method):
pass

classDestructor(Method):
pass

classParameterDeclaration(Node, INodeWithAttributes):
 Name asstring
 Type as TypeReference
 Modifiers as ParameterModifiers
 Attributes as AttributeCollection

[collection(ParameterDeclaration)]
classParameterDeclarationCollection:
pass

classGenericParameterDeclaration(Node):
 Name asstring
 BaseTypes as TypeReferenceCollection
 Constraints as GenericParameterConstraints

[collection(GenericParameterDeclaration)]
classGenericParameterDeclarationCollection:
pass

classDeclaration(Node):
 Name asstring
 Type as TypeReference

[collection(Declaration)]
classDeclarationCollection:
pass

classAttribute(Node, INodeWithArguments):
 Name asstring
 Arguments as ExpressionCollection
 NamedArguments as ExpressionPairCollection

[collection(Attribute)]
classAttributeCollection:
pass

enum StatementModifierType:
 None
 If
 Unless
 While

classStatementModifier(Node):
 Type as StatementModifierType
 Condition as Expression

abstract classStatement(Node):
 Modifier as StatementModifier

classGotoStatement(Statement):
 Label as ReferenceExpression

classLabelStatement(Statement):
 Name asstring

classBlock(Statement):
 Statements as StatementCollection

[collection(Statement)]
classStatementCollection:
pass

classDeclarationStatement(Statement):
 Declaration as Declaration
 Initializer as Expression

classMacroStatement(Statement, INodeWithBody):
 Name asstring
 Arguments as ExpressionCollection
 [auto]
 Body as Block

classTryStatement(Statement):
 [auto]
 ProtectedBlock as Block
 ExceptionHandlers as ExceptionHandlerCollection
 FailureBlock as Block
 EnsureBlock as Block

classExceptionHandler(Node):
 Declaration as Declaration
 FilterCondition as Expression
 Flags as ExceptionHandlerFlags

 [auto]
 Block as Block

[collection(ExceptionHandler)]
classExceptionHandlerCollection:
pass

abstract classConditionalStatement(Statement):
 Condition as Expression

classIfStatement(ConditionalStatement):
 TrueBlock as Block
 FalseBlock as Block

classUnlessStatement(ConditionalStatement):
 [auto]
 Block as Block

classForStatement(Statement):
 Declarations as DeclarationCollection
 Iterator as Expression
 [auto]
 Block as Block
 OrBlock as Block
 ThenBlock as Block

classWhileStatement(ConditionalStatement):
 [auto]
 Block as Block
 OrBlock as Block
 ThenBlock as Block

classBreakStatement(Statement):
pass

classContinueStatement(Statement):
pass

classReturnStatement(Statement):
 Expression as Expression

classYieldStatement(Statement):
 Expression as Expression

classRaiseStatement(Statement):
 Exception as Expression

classUnpackStatement(Statement):
 Declarations as DeclarationCollection
 Expression as Expression

classExpressionStatement(Statement):
 [LexicalInfo]
 Expression as Expression

abstract classExpression(Node):
pass

[collection(Expression)]
classExpressionCollection:
pass

[ignore]
classOmittedExpression(Expression):
pass

classExpressionPair(Node):
 First as Expression
 Second as Expression

[collection(ExpressionPair)]
classExpressionPairCollection:
pass

classMethodInvocationExpression(Expression, INodeWithArguments):
 Target as Expression
 Arguments as ExpressionCollection
 NamedArguments as ExpressionPairCollection

enum BinaryOperatorType:
 None
 Addition
 Subtraction
 Multiply
 Division
 Modulus
 Exponentiation
 LessThan
 LessThanOrEqual
 GreaterThan
 GreaterThanOrEqual
 Equality
 Inequality
 Match
 NotMatch
 Assign
 InPlaceAddition
 InPlaceSubtraction
 InPlaceMultiply
 InPlaceDivision
 InPlaceModulus
 InPlaceBitwiseAnd
 InPlaceBitwiseOr
 ReferenceEquality
 ReferenceInequality
 TypeTest
 Member
 NotMember
 Or
 And
 BitwiseOr
 BitwiseAnd
 ExclusiveOr
 InPlaceExclusiveOr
 ShiftLeft
 InPlaceShiftLeft
 ShiftRight
 InPlaceShiftRight

#values are ready to be used as mask if/when BinaryOperatorType
#is changed as in patch attached to BOO-1123 (breaking change)
enum BinaryOperatorKind:
 Arithmetic = 0xF
 Comparison = 0xFF0
 TypeComparison = 0xF00
 Assignment = 0xFF000
 InPlaceAssignment = 0xF0000
 Logical = 0x0F00000
 Bitwise = 0xF000000

enum UnaryOperatorType:
 None
 UnaryNegation
 Increment
 Decrement
 PostIncrement
 PostDecrement
 LogicalNot
 Explode
 OnesComplement
 AddressOf
 Indirection
 SafeAccess

classUnaryExpression(Expression):
 Operator as UnaryOperatorType
 Operand as Expression

classBinaryExpression(Expression):
 Operator as BinaryOperatorType
 Left as Expression
 Right as Expression

classConditionalExpression(Expression):
 Condition as Expression
 TrueValue as Expression
 FalseValue as Expression

classReferenceExpression(Expression):
 Name asstring

classMemberReferenceExpression(ReferenceExpression):
 Target as Expression

classGenericReferenceExpression(Expression):
 Target as Expression
 GenericArguments as TypeReferenceCollection

abstract classLiteralExpression(Expression):
pass

classQuasiquoteExpression(LiteralExpression):
 Node as Node

classStringLiteralExpression(LiteralExpression):
 Value asstring

classCharLiteralExpression(StringLiteralExpression):
pass

classTimeSpanLiteralExpression(LiteralExpression):
 Value as System.TimeSpan

classIntegerLiteralExpression(LiteralExpression):
 Value aslong
 IsLong asbool

classDoubleLiteralExpression(LiteralExpression):
 Value asdouble
 IsSingle asbool

classNullLiteralExpression(LiteralExpression):
pass

classSelfLiteralExpression(LiteralExpression):
pass

classSuperLiteralExpression(LiteralExpression):
pass

classBoolLiteralExpression(LiteralExpression):
 Value asbool

classRELiteralExpression(LiteralExpression):
 Value asstring

classSpliceExpression(Expression):
 Expression as Expression

classSpliceTypeReference(TypeReference):
 Expression as Expression

classSpliceMemberReferenceExpression(Expression):
 Target as Expression
 NameExpression as Expression

classSpliceTypeMember(TypeMember):
 TypeMember as TypeMember
 NameExpression as Expression

classSpliceTypeDefinitionBody(TypeMember):
 Expression as Expression

classSpliceParameterDeclaration(ParameterDeclaration):
 ParameterDeclaration as ParameterDeclaration
 NameExpression as Expression

classExpressionInterpolationExpression(Expression):
 Expressions as ExpressionCollection

classHashLiteralExpression(LiteralExpression):
 Items as ExpressionPairCollection

classListLiteralExpression(LiteralExpression):
 Items as ExpressionCollection

classCollectionInitializationExpression(Expression):
 Collection as Expression
 Initializer as Expression

classArrayLiteralExpression(ListLiteralExpression):
 Type as ArrayTypeReference

classGeneratorExpression(Expression):
 Expression as Expression
 Declarations as DeclarationCollection
 Iterator as Expression
 Filter as StatementModifier

classExtendedGeneratorExpression(Expression):
 Items as GeneratorExpressionCollection

[collection(GeneratorExpression)]
classGeneratorExpressionCollection:
pass

classSlice(Node):
 Begin as Expression
 End as Expression
 Step as Expression

[collection(Slice)]
classSliceCollection:
pass

classSlicingExpression(Expression):
 Target as Expression
 Indices as SliceCollection

classTryCastExpression(Expression):
 Target as Expression
 Type as TypeReference

classCastExpression(Expression):
 Target as Expression
 Type as TypeReference

classTypeofExpression(Expression):
 Type as TypeReference

classAsyncBlockExpression(BlockExpression):
 Block as BlockExpression

classAwaitExpression(Expression):
 BaseExpression as Expression

classCustomStatement(Statement):
pass

classCustomExpression(Expression):
pass

classStatementTypeMember(TypeMember):
"""
Allow for macros and initializing statements inside type definition bodies.
"""
 Statement as Statement