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
 283 class WhileStatement(Statement):
 284         Condition as Expression
 285
 286         [auto]
 287         Block as Block
 288
 289 class BreakStatement(Statement):
 290         pass
 291
 292 class ContinueStatement(Statement):
 293         pass
 294
 295 class ReturnStatement(Statement):
 296         Expression as Expression
 297
 298 class YieldStatement(Statement):
 299         Expression as Expression
 300
 301 class RaiseStatement(Statement):
 302         Exception as Expression
 303
 304 class UnpackStatement(Statement):
 305         Declarations as DeclarationCollection
 306         Expression as Expression
 307
 308 class ExpressionStatement(Statement):
 309         [LexicalInfo]
 310         Expression as Expression
 311
 312 abstract class Expression(Node):
 313         pass
 314
 315 [collection(Expression)]
 316 class ExpressionCollection:
 317         pass
 318
 319 [ignore]
 320 class OmittedExpression(Expression):
 321         pass
 322
 323 class ExpressionPair(Node):
 324         First as Expression
 325         Second as Expression
 326
 327 [collection(ExpressionPair)]
 328 class ExpressionPairCollection:
 329         pass
 330
 331 class MethodInvocationExpression(Expression, INodeWithArguments):
 332         Target as Expression
 333         Arguments as ExpressionCollection
 334         NamedArguments as ExpressionPairCollection
 335
 336 enum BinaryOperatorType:
 337         None
 338         Addition
 339         Subtraction
 340         Multiply
 341         Division
 342         Modulus
 343         Exponentiation
 344         LessThan
 345         LessThanOrEqual
 346         GreaterThan
 347         GreaterThanOrEqual
 348         Equality
 349         Inequality
 350         Match
 351         NotMatch
 352         Assign
 353         InPlaceAddition
 354         InPlaceSubtraction
 355         InPlaceMultiply
 356         InPlaceDivision
 357         InPlaceBitwiseAnd
 358         InPlaceBitwiseOr
 359         ReferenceEquality
 360         ReferenceInequality
 361         TypeTest
 362         Member
 363         NotMember
 364         Or
 365         And
 366         BitwiseOr
 367         BitwiseAnd
 368         ExclusiveOr
 369         InPlaceExclusiveOr
 370         ShiftLeft
 371         InPlaceShiftLeft
 372         ShiftRight
 373         InPlaceShiftRight
 374
 375 enum UnaryOperatorType:
 376         None
 377         UnaryNegation
 378         Increment
 379         Decrement
 380         PostIncrement
 381         PostDecrement
 382         LogicalNot
 383         Explode
 384         OnesComplement
 385
 386 class UnaryExpression(Expression):
 387         Operator as UnaryOperatorType
 388         Operand as Expression
 389
 390 class BinaryExpression(Expression):
 391         Operator as BinaryOperatorType
 392         Left as Expression
 393         Right as Expression
 394
 395 class ConditionalExpression(Expression):
 396         Condition as Expression
 397         TrueValue as Expression
 398         FalseValue as Expression
 399
 400 class ReferenceExpression(Expression):
 401         Name as string
 402
 403 class MemberReferenceExpression(ReferenceExpression):
 404         Target as Expression
 405
 406 class GenericReferenceExpression(Expression):
 407         Target as Expression
 408         GenericArguments as TypeReferenceCollection
 409
 410 abstract class LiteralExpression(Expression):
 411         pass
 412
 413 class QuasiquoteExpression(LiteralExpression):
 414         Node as Node
 415
 416 class StringLiteralExpression(LiteralExpression):
 417         Value as string
 418
 419 class CharLiteralExpression(StringLiteralExpression):
 420         pass
 421
 422 class TimeSpanLiteralExpression(LiteralExpression):
 423         Value as System.TimeSpan
 424
 425 class IntegerLiteralExpression(LiteralExpression):
 426         Value as long
 427         IsLong as bool
 428
 429 class DoubleLiteralExpression(LiteralExpression):
 430         Value as double
 431         IsSingle as bool
 432
 433 class NullLiteralExpression(LiteralExpression):
 434         pass
 435
 436 class SelfLiteralExpression(LiteralExpression):
 437         pass
 438
 439 class SuperLiteralExpression(LiteralExpression):
 440         pass
 441
 442 class BoolLiteralExpression(LiteralExpression):
 443         Value as bool
 444
 445 class RELiteralExpression(LiteralExpression):
 446         Value as string
 447
 448 class SpliceExpression(Expression):
 449         Expression as Expression
 450
 451 class SpliceTypeReference(TypeReference):
 452         Expression as Expression
 453
 454 class SpliceMemberReferenceExpression(Expression):
 455         Target as Expression
 456         NameExpression as Expression
 457
 458 class SpliceTypeMember(TypeMember):
 459         TypeMember as TypeMember
 460         NameExpression as Expression
 461
 462 class SpliceParameterDeclaration(ParameterDeclaration):
 463         ParameterDeclaration as ParameterDeclaration
 464         NameExpression as Expression
 465
 466 class ExpressionInterpolationExpression(Expression):
 467         Expressions as ExpressionCollection
 468
 469 class HashLiteralExpression(LiteralExpression):
 470         Items as ExpressionPairCollection
 471
 472 class ListLiteralExpression(LiteralExpression):
 473         Items as ExpressionCollection
 474
 475 class ArrayLiteralExpression(ListLiteralExpression):
 476         Type as ArrayTypeReference
 477
 478 class GeneratorExpression(Expression):
 479         Expression as Expression
 480         Declarations as DeclarationCollection
 481         Iterator as Expression
 482         Filter as StatementModifier
 483
 484 class ExtendedGeneratorExpression(Expression):
 485         Items as GeneratorExpressionCollection
 486
 487 [collection(GeneratorExpression)]
 488 class GeneratorExpressionCollection:
 489         pass
 490
 491 class Slice(Node):
 492         Begin as Expression
 493         End as Expression
 494         Step as Expression
 495
 496 [collection(Slice)]
 497 class SliceCollection:
 498         pass
 499
 500 class SlicingExpression(Expression):
 501         Target as Expression
 502         Indices as SliceCollection
 503
 504 class TryCastExpression(Expression):
 505         Target as Expression
 506         Type as TypeReference
 507
 508 class CastExpression(Expression):
 509         Target as Expression
 510         Type as TypeReference
 511
 512 class TypeofExpression(Expression):
 513         Type as TypeReference
 514
 515