ast.model.boo

   1 """
   2 The classes in this module model the entire AST for the language.
   3
   4 The actual AST classes and supporting modules are generated
   5 by a boo script.
   6 """
   7 namespace Boo.Ast
   8
   9 class CompileUnit(Node):
  10         Modules as ModuleCollection
  11
  12 enum TypeMemberModifiers:
  13         None = 0
  14         Private = 1
  15         Internal = 2
  16         Protected = 4
  17         Public = 8
  18         Transient = 16
  19         Static = 32
  20         Final = 64
  21         Virtual = 128
  22         Override = 256
  23         Abstract = 512
  24         Partial = 1024
  25         VisibilityMask = 15
  26
  27 enum MethodImplementationFlags:
  28         None = 0
  29         Runtime = 1
  30
  31 enum ParameterModifiers:
  32         None = 0
  33         Val = 0
  34         Ref = 1
  35
  36 [Flags]
  37 enum ExceptionHandlerFlags:
  38         None = 0
  39         Anonymous = 1
  40         Untyped = 2
  41         Filter = 4
  42
  43 abstract class TypeMember(Node, INodeWithAttributes):
  44         Modifiers as TypeMemberModifiers
  45         Name as string
  46         Attributes as AttributeCollection
  47
  48 class ExplicitMemberInfo(Node):
  49         InterfaceType as SimpleTypeReference
  50
  51 [collection(TypeMember)]
  52 class TypeMemberCollection:
  53         pass
  54
  55 abstract class TypeReference(Node):
  56         pass
  57
  58 class SimpleTypeReference(TypeReference):
  59         Name as string
  60
  61 class ArrayTypeReference(TypeReference):
  62         ElementType as TypeReference
  63         Rank as IntegerLiteralExpression
  64
  65 class CallableTypeReference(TypeReference):
  66         Parameters as ParameterDeclarationCollection
  67         ReturnType as TypeReference
  68
  69 class GenericTypeReference(SimpleTypeReference):
  70         GenericArguments as TypeReferenceCollection
  71
  72 class GenericTypeDefinitionReference(SimpleTypeReference):
  73         GenericPlaceholders as int
  74
  75 [collection(TypeReference)]
  76 class TypeReferenceCollection:
  77         pass
  78
  79 class CallableDefinition(TypeMember, INodeWithParameters):
  80         Parameters as ParameterDeclarationCollection
  81         GenericParameters as GenericParameterDeclarationCollection
  82         ReturnType as TypeReference
  83         ReturnTypeAttributes as AttributeCollection
  84
  85 abstract class TypeDefinition(TypeMember):
  86         Members as TypeMemberCollection
  87         BaseTypes as TypeReferenceCollection
  88         GenericParameters as GenericParameterDeclarationCollection
  89
  90 [collection(TypeDefinition)]
  91 class TypeDefinitionCollection:
  92         pass
  93
  94 class NamespaceDeclaration(Node):
  95         Name as string
  96
  97 class Import(Node):
  98         Namespace as string
  99         AssemblyReference as ReferenceExpression
 100         Alias as ReferenceExpression
 101
 102 [collection(Import)]
 103 class ImportCollection:
 104         pass
 105
 106 class Module(TypeDefinition):
 107         Namespace as NamespaceDeclaration
 108         Imports as ImportCollection
 109         [auto]
 110         Globals as Block
 111         AssemblyAttributes as AttributeCollection
 112
 113 [collection(Module)]
 114 class ModuleCollection:
 115         pass
 116
 117 class ClassDefinition(TypeDefinition):
 118         pass
 119
 120 class StructDefinition(TypeDefinition):
 121         pass
 122
 123 class InterfaceDefinition(TypeDefinition):
 124         pass
 125
 126 class EnumDefinition(TypeDefinition):
 127         pass
 128
 129 class EnumMember(TypeMember):
 130         Initializer as IntegerLiteralExpression
 131
 132 class Field(TypeMember):
 133         Type as TypeReference
 134         Initializer as Expression
 135
 136 class Property(TypeMember, INodeWithParameters, IExplicitMember):
 137         Parameters as ParameterDeclarationCollection
 138         Getter as Method
 139         Setter as Method
 140         Type as TypeReference
 141         ExplicitInfo as ExplicitMemberInfo
 142
 143 class Event(TypeMember):
 144         Add as Method
 145         Remove as Method
 146         Raise as Method
 147         Type as TypeReference
 148
 149 class Local(Node):
 150         Name as string
 151
 152 [collection(Local)]
 153 class LocalCollection:
 154         pass
 155
 156 class BlockExpression(Expression, INodeWithParameters):
 157         Parameters as ParameterDeclarationCollection
 158         ReturnType as TypeReference
 159         [auto]
 160         Body as Block
 161
 162 class Method(CallableDefinition, IExplicitMember):
 163         [auto]
 164         Body as Block
 165         Locals as LocalCollection
 166         ImplementationFlags as MethodImplementationFlags
 167         ExplicitInfo as ExplicitMemberInfo
 168
 169 class Constructor(Method):
 170         pass
 171
 172 class Destructor(Method):
 173         pass
 174
 175 class ParameterDeclaration(Node, INodeWithAttributes):
 176         Name as string
 177         Type as TypeReference
 178         Modifiers as ParameterModifiers
 179         Attributes as AttributeCollection
 180
 181 [collection(ParameterDeclaration)]
 182 class ParameterDeclarationCollection:
 183         pass
 184
 185 class GenericParameterDeclaration(Node):
 186         Name as string
 187
 188 [collection(GenericParameterDeclaration)]
 189 class GenericParameterDeclarationCollection:
 190         pass
 191
 192 class Declaration(Node):
 193         Name as string
 194         Type as TypeReference
 195
 196 [collection(Declaration)]
 197 class DeclarationCollection:
 198         pass
 199
 200 class Attribute(Node, INodeWithArguments):
 201         Name as string
 202         Arguments as ExpressionCollection
 203         NamedArguments as ExpressionPairCollection
 204
 205 [collection(Attribute)]
 206 class AttributeCollection:
 207         pass
 208
 209 enum StatementModifierType:
 210         None
 211         If
 212         Unless
 213         While
 214
 215 class StatementModifier(Node):
 216         Type as StatementModifierType
 217         Condition as Expression
 218
 219 abstract class Statement(Node):
 220         Modifier as StatementModifier
 221
 222 class GotoStatement(Statement):
 223         Label as ReferenceExpression
 224
 225 class LabelStatement(Statement):
 226         Name as string
 227
 228 class Block(Statement):
 229         Statements as StatementCollection
 230
 231 [collection(Statement)]
 232 class StatementCollection:
 233         pass
 234
 235 class DeclarationStatement(Statement):
 236         Declaration as Declaration
 237         Initializer as Expression
 238
 239 class MacroStatement(Statement):
 240         Name as string
 241         Arguments as ExpressionCollection
 242
 243         [auto]
 244         Block as Block
 245
 246 class TryStatement(Statement):
 247         [auto]
 248         ProtectedBlock as Block
 249         ExceptionHandlers as ExceptionHandlerCollection
 250         FailureBlock as Block
 251         EnsureBlock as Block
 252
 253 class ExceptionHandler(Node):
 254         Declaration as Declaration
 255         FilterCondition as Expression
 256         Flags as ExceptionHandlerFlags
 257
 258         [auto]
 259         Block as Block
 260
 261 [collection(ExceptionHandler)]
 262 class ExceptionHandlerCollection:
 263         pass
 264
 265 class IfStatement(Statement):
 266         Condition as Expression
 267         TrueBlock as Block
 268         FalseBlock as Block
 269
 270 class UnlessStatement(Statement):
 271         Condition as Expression
 272
 273         [auto]
 274         Block as Block
 275
 276 class ForStatement(Statement):
 277         Declarations as DeclarationCollection
 278         Iterator as Expression
 279
 280         [auto]
 281         Block as Block
 282         ElseBlock as Block
 283
 284 class WhileStatement(Statement):
 285         Condition as Expression
 286
 287         [auto]
 288         Block as Block
 289         ElseBlock as Block
 290
 291 class BreakStatement(Statement):
 292         pass
 293
 294 class ContinueStatement(Statement):
 295         pass
 296
 297 class ReturnStatement(Statement):
 298         Expression as Expression
 299
 300 class YieldStatement(Statement):
 301         Expression as Expression
 302
 303 class RaiseStatement(Statement):
 304         Exception as Expression
 305
 306 class UnpackStatement(Statement):
 307         Declarations as DeclarationCollection
 308         Expression as Expression
 309
 310 class ExpressionStatement(Statement):
 311         [LexicalInfo]
 312         Expression as Expression
 313
 314 abstract class Expression(Node):
 315         pass
 316
 317 [collection(Expression)]
 318 class ExpressionCollection:
 319         pass
 320
 321 [ignore]
 322 class OmittedExpression(Expression):
 323         pass
 324
 325 class ExpressionPair(Node):
 326         First as Expression
 327         Second as Expression
 328
 329 [collection(ExpressionPair)]
 330 class ExpressionPairCollection:
 331         pass
 332
 333 class MethodInvocationExpression(Expression, INodeWithArguments):
 334         Target as Expression
 335         Arguments as ExpressionCollection
 336         NamedArguments as ExpressionPairCollection
 337
 338 enum BinaryOperatorType:
 339         None
 340         Addition
 341         Subtraction
 342         Multiply
 343         Division
 344         Modulus
 345         Exponentiation
 346         LessThan
 347         LessThanOrEqual
 348         GreaterThan
 349         GreaterThanOrEqual
 350         Equality
 351         Inequality
 352         Match
 353         NotMatch
 354         Assign
 355         InPlaceAddition
 356         InPlaceSubtraction
 357         InPlaceMultiply
 358         InPlaceDivision
 359         InPlaceBitwiseAnd
 360         InPlaceBitwiseOr
 361         ReferenceEquality
 362         ReferenceInequality
 363         TypeTest
 364         Member
 365         NotMember
 366         Or
 367         And
 368         BitwiseOr
 369         BitwiseAnd
 370         ExclusiveOr
 371         InPlaceExclusiveOr
 372         ShiftLeft
 373         InPlaceShiftLeft
 374         ShiftRight
 375         InPlaceShiftRight
 376
 377 enum UnaryOperatorType:
 378         None
 379         UnaryNegation
 380         Increment
 381         Decrement
 382         PostIncrement
 383         PostDecrement
 384         LogicalNot
 385         Explode
 386         OnesComplement
 387
 388 class UnaryExpression(Expression):
 389         Operator as UnaryOperatorType
 390         Operand as Expression
 391
 392 class BinaryExpression(Expression):
 393         Operator as BinaryOperatorType
 394         Left as Expression
 395         Right as Expression
 396
 397 class ConditionalExpression(Expression):
 398         Condition as Expression
 399         TrueValue as Expression
 400         FalseValue as Expression
 401
 402 class ReferenceExpression(Expression):
 403         Name as string
 404
 405 class MemberReferenceExpression(ReferenceExpression):
 406         Target as Expression
 407
 408 class GenericReferenceExpression(Expression):
 409         Target as Expression
 410         GenericArguments as TypeReferenceCollection
 411
 412 abstract class LiteralExpression(Expression):
 413         pass
 414
 415 class QuasiquoteExpression(LiteralExpression):
 416         Node as Node
 417
 418 class StringLiteralExpression(LiteralExpression):
 419         Value as string
 420
 421 class CharLiteralExpression(StringLiteralExpression):
 422         pass
 423
 424 class TimeSpanLiteralExpression(LiteralExpression):
 425         Value as System.TimeSpan
 426
 427 class IntegerLiteralExpression(LiteralExpression):
 428         Value as long
 429         IsLong as bool
 430
 431 class DoubleLiteralExpression(LiteralExpression):
 432         Value as double
 433         IsSingle as bool
 434
 435 class NullLiteralExpression(LiteralExpression):
 436         pass
 437
 438 class SelfLiteralExpression(LiteralExpression):
 439         pass
 440
 441 class SuperLiteralExpression(LiteralExpression):
 442         pass
 443
 444 class BoolLiteralExpression(LiteralExpression):
 445         Value as bool
 446
 447 class RELiteralExpression(LiteralExpression):
 448         Value as string
 449
 450 class SpliceExpression(Expression):
 451         Expression as Expression
 452
 453 class SpliceTypeReference(TypeReference):
 454         Expression as Expression
 455
 456 class SpliceMemberReferenceExpression(Expression):
 457         Target as Expression
 458         NameExpression as Expression
 459
 460 class SpliceTypeMember(TypeMember):
 461         TypeMember as TypeMember
 462         NameExpression as Expression
 463
 464 class SpliceParameterDeclaration(ParameterDeclaration):
 465         ParameterDeclaration as ParameterDeclaration
 466         NameExpression as Expression
 467
 468 class ExpressionInterpolationExpression(Expression):
 469         Expressions as ExpressionCollection
 470
 471 class HashLiteralExpression(LiteralExpression):
 472         Items as ExpressionPairCollection
 473
 474 class ListLiteralExpression(LiteralExpression):
 475         Items as ExpressionCollection
 476
 477 class ArrayLiteralExpression(ListLiteralExpression):
 478         Type as ArrayTypeReference
 479
 480 class GeneratorExpression(Expression):
 481         Expression as Expression
 482         Declarations as DeclarationCollection
 483         Iterator as Expression
 484         Filter as StatementModifier
 485
 486 class ExtendedGeneratorExpression(Expression):
 487         Items as GeneratorExpressionCollection
 488
 489 [collection(GeneratorExpression)]
 490 class GeneratorExpressionCollection:
 491         pass
 492
 493 class Slice(Node):
 494         Begin as Expression
 495         End as Expression
 496         Step as Expression
 497
 498 [collection(Slice)]
 499 class SliceCollection:
 500         pass
 501
 502 class SlicingExpression(Expression):
 503         Target as Expression
 504         Indices as SliceCollection
 505
 506 class TryCastExpression(Expression):
 507         Target as Expression
 508         Type as TypeReference
 509
 510 class CastExpression(Expression):
 511         Target as Expression
 512         Type as TypeReference
 513
 514 class TypeofExpression(Expression):
 515         Type as TypeReference
 516
 517