| -- | |
| -- ******************************************************************************* | |
| -- Copyright (c) 2009 Mia-Software and others. | |
| -- All rights reserved. This program and the accompanying materials | |
| -- are made available under the terms of the Eclipse Public License v2.0 | |
| -- which accompanies this distribution, and is available at | |
| -- http://www.eclipse.org/legal/epl-v20.html | |
| -- | |
| -- Contributors: | |
| -- | |
| -- Fabien Giquel (Mia-Software) - initial API and implementation | |
| -- ******************************************************************************* | |
| -- | |
| -- | |
| -- @nsURI http://www.eclipse.org/MoDisco/Java/0.2.incubation/java | |
| -- @nsPrefix java | |
| package java { | |
| abstract class AbstractMethodDeclaration extends BodyDeclaration { | |
| reference body[0-1] container : Block; | |
| reference parameters[*] ordered container : SingleVariableDeclaration oppositeOf methodDeclaration; | |
| reference thrownExceptions[*] ordered container : TypeAccess; | |
| reference typeParameters[*] ordered container : TypeParameter; | |
| reference usagesInDocComments[*] : MethodRef oppositeOf method; -- NamedElementRef substitute opposite | |
| reference usages[*] : AbstractMethodInvocation oppositeOf method; -- NamedElementRef substitute opposite | |
| } | |
| abstract class AbstractMethodInvocation extends ASTNode { | |
| reference method : AbstractMethodDeclaration oppositeOf usages; -- NamedElementRef substitute | |
| reference arguments[*] ordered container : Expression; | |
| reference typeArguments[*] ordered container : TypeAccess; | |
| } | |
| abstract class AbstractTypeDeclaration extends BodyDeclaration, Type { | |
| reference bodyDeclarations[*] ordered container : BodyDeclaration oppositeOf abstractTypeDeclaration; | |
| reference commentsBeforeBody[*] ordered container : Comment; | |
| reference commentsAfterBody[*] ordered container : Comment; | |
| reference "package"[0-1] : Package oppositeOf ownedElements; | |
| reference superInterfaces[*] ordered container : TypeAccess; | |
| } | |
| abstract class AbstractTypeQualifiedExpression extends Expression { | |
| reference qualifier[0-1] container : TypeAccess; | |
| } | |
| abstract class AbstractVariablesContainer extends ASTNode { | |
| reference type[0-1] container : TypeAccess; | |
| reference fragments[*] ordered container : VariableDeclarationFragment oppositeOf variablesContainer; | |
| } | |
| class Annotation extends Expression { | |
| reference type container : TypeAccess; | |
| reference values[*] ordered container : AnnotationMemberValuePair; | |
| } | |
| class Archive extends NamedElement { | |
| attribute originalFilePath : String; | |
| reference classFiles[*] container : ClassFile; | |
| reference manifest[0-1] container : Manifest; | |
| } | |
| class AssertStatement extends Statement { | |
| reference message[0-1] container : Expression; | |
| reference expression container : Expression; | |
| } | |
| abstract class ASTNode { | |
| reference comments[*] ordered container : Comment; | |
| reference originalCompilationUnit[0-1] : CompilationUnit; | |
| reference originalClassFile[0-1] : ClassFile; | |
| } | |
| class AnnotationMemberValuePair extends NamedElement { | |
| reference member[0-1] : AnnotationTypeMemberDeclaration oppositeOf usages; -- NamedElementRef substitute | |
| reference value container : Expression; | |
| } | |
| class AnnotationTypeDeclaration extends AbstractTypeDeclaration { | |
| } | |
| class AnnotationTypeMemberDeclaration extends BodyDeclaration { | |
| reference default[0-1] container : Expression; | |
| reference type container : TypeAccess; | |
| reference usages[*] : AnnotationMemberValuePair oppositeOf member; -- NamedElementRef substitute opposite | |
| } | |
| class AnonymousClassDeclaration extends ASTNode { | |
| reference bodyDeclarations[*] ordered container : BodyDeclaration oppositeOf anonymousClassDeclarationOwner; | |
| reference classInstanceCreation[0-1] : ClassInstanceCreation oppositeOf anonymousClassDeclaration; | |
| } | |
| class ArrayAccess extends Expression { | |
| reference array container : Expression; | |
| reference index container : Expression; | |
| } | |
| class ArrayCreation extends Expression { | |
| reference dimensions[*] ordered container : Expression; | |
| reference initializer[0-1] container : ArrayInitializer; | |
| reference type container : TypeAccess ; | |
| } | |
| class ArrayInitializer extends Expression { | |
| reference expressions[*] ordered container : Expression; | |
| } | |
| class ArrayLengthAccess extends Expression { | |
| reference array container : Expression; | |
| } | |
| class ArrayType extends Type { | |
| attribute dimensions : Integer; | |
| reference elementType container : TypeAccess ; | |
| } | |
| class Assignment extends Expression { | |
| reference leftHandSide container : Expression; | |
| attribute operator : AssignmentKind; | |
| reference rightHandSide container : Expression; | |
| } | |
| enumeration AssignmentKind { | |
| -- @literalValue "=" | |
| literal ASSIGN; | |
| -- @literalValue "+=" | |
| literal PLUS_ASSIGN; | |
| -- @literalValue "-=" | |
| literal MINUS_ASSIGN; | |
| -- @literalValue "*=" | |
| literal TIMES_ASSIGN; | |
| -- @literalValue "/=" | |
| literal DIVIDE_ASSIGN; | |
| -- @literalValue "&=" | |
| literal BIT_AND_ASSIGN; | |
| -- @literalValue "|=" | |
| literal BIT_OR_ASSIGN; | |
| -- @literalValue "^=" | |
| literal BIT_XOR_ASSIGN; | |
| -- @literalValue "%=" | |
| literal REMAINDER_ASSIGN; | |
| -- @literalValue "<<=" | |
| literal LEFT_SHIFT_ASSIGN; | |
| -- @literalValue ">>=" | |
| literal RIGHT_SHIFT_SIGNED_ASSIGN; | |
| -- @literalValue ">>>=" | |
| literal RIGHT_SHIFT_UNSIGNED_ASSIGN; | |
| } | |
| abstract class BodyDeclaration extends NamedElement { | |
| reference abstractTypeDeclaration[0-1] : AbstractTypeDeclaration oppositeOf bodyDeclarations; | |
| reference annotations[*] ordered container : Annotation; | |
| reference anonymousClassDeclarationOwner[0-1] : AnonymousClassDeclaration oppositeOf bodyDeclarations; | |
| reference modifier[0..1] container : Modifier oppositeOf bodyDeclaration; | |
| } | |
| class BooleanLiteral extends Expression { | |
| attribute value : Boolean; | |
| } | |
| class BlockComment extends Comment { | |
| } | |
| class Block extends Statement { | |
| reference statements[*] ordered container : Statement; | |
| } | |
| class BreakStatement extends Statement { | |
| reference label[0-1] : LabeledStatement oppositeOf usagesInBreakStatements; -- NamedElementRef substitute | |
| } | |
| class CastExpression extends Expression { | |
| reference expression container : Expression; | |
| reference type container : TypeAccess ; | |
| } | |
| class CatchClause extends Statement { | |
| reference exception container : SingleVariableDeclaration oppositeOf catchClause; | |
| reference body container : Block; | |
| } | |
| class CharacterLiteral extends Expression { | |
| attribute escapedValue : String; | |
| } | |
| class ClassFile extends NamedElement { | |
| attribute originalFilePath : String; | |
| reference type[0-1] : AbstractTypeDeclaration; | |
| reference attachedSource[0-1] : CompilationUnit; | |
| reference "package"[0-1] : Package; | |
| } | |
| class ClassInstanceCreation extends Expression, AbstractMethodInvocation { | |
| reference anonymousClassDeclaration[0-1] container : AnonymousClassDeclaration oppositeOf classInstanceCreation; | |
| reference expression[0-1] container : Expression; | |
| reference type container : TypeAccess ; | |
| } | |
| class ConstructorDeclaration extends AbstractMethodDeclaration { | |
| } | |
| class ConditionalExpression extends Expression { | |
| reference elseExpression container : Expression; | |
| reference expression container : Expression; | |
| reference thenExpression container : Expression; | |
| } | |
| class ConstructorInvocation extends Statement, AbstractMethodInvocation { | |
| } | |
| class ClassDeclaration extends TypeDeclaration { | |
| reference superClass[0-1] container : TypeAccess ; | |
| } | |
| abstract class Comment extends ASTNode { | |
| attribute content : String; | |
| attribute enclosedByParent : Boolean; | |
| attribute prefixOfParent : Boolean; | |
| } | |
| class CompilationUnit extends NamedElement { | |
| attribute originalFilePath : String; | |
| reference commentList[*] ordered : Comment; | |
| reference imports[*] ordered container : ImportDeclaration; | |
| reference "package"[0-1] : Package; | |
| reference types[*] ordered : AbstractTypeDeclaration; | |
| } | |
| class ContinueStatement extends Statement { | |
| reference label[0-1] : LabeledStatement oppositeOf usagesInContinueStatements; -- NamedElementRef substitute | |
| } | |
| class DoStatement extends Statement { | |
| reference expression container : Expression; | |
| reference body container : Statement; | |
| } | |
| class EmptyStatement extends Statement { | |
| } | |
| class EnhancedForStatement extends Statement { | |
| reference body container : Statement; | |
| reference expression container : Expression; | |
| reference parameter container : SingleVariableDeclaration oppositeOf enhancedForStatement; | |
| } | |
| -- EnumConstantDeclaration is considered as VariableDeclaration to allowing | |
| -- to be referenced by VariableAccess and without introducing more complex VariableDeclaration hierarchy | |
| -- or a new EnumConstantAccess type | |
| class EnumConstantDeclaration extends BodyDeclaration, VariableDeclaration { | |
| reference anonymousClassDeclaration[0-1] container : AnonymousClassDeclaration; | |
| reference arguments[*] ordered container : Expression; | |
| } | |
| class EnumDeclaration extends AbstractTypeDeclaration { | |
| reference enumConstants[*] ordered container : EnumConstantDeclaration; | |
| } | |
| abstract class Expression extends ASTNode { | |
| } | |
| class ExpressionStatement extends Statement { | |
| reference expression container : Expression; | |
| } | |
| class FieldAccess extends Expression { | |
| reference field container : SingleVariableAccess; | |
| reference expression container : Expression; | |
| } | |
| class FieldDeclaration extends BodyDeclaration, AbstractVariablesContainer { | |
| } | |
| class ForStatement extends Statement { | |
| reference expression[0-1] container : Expression; | |
| reference updaters[*] ordered container : Expression; | |
| reference initializers[*] ordered container : Expression; | |
| reference body container : Statement; | |
| } | |
| class IfStatement extends Statement { | |
| reference expression container : Expression; | |
| reference thenStatement container : Statement; | |
| reference elseStatement[0-1] container : Statement; | |
| } | |
| class ImportDeclaration extends ASTNode { | |
| attribute static[0-1] : Boolean; | |
| reference importedElement : NamedElement oppositeOf usagesInImports; -- NamedElementRef substitute | |
| } | |
| class InfixExpression extends Expression { | |
| attribute operator : InfixExpressionKind; | |
| reference rightOperand container : Expression; | |
| reference leftOperand container : Expression; | |
| reference extendedOperands[*] ordered container : Expression; | |
| } | |
| enumeration InfixExpressionKind { | |
| -- @literalValue "*" | |
| literal TIMES; | |
| -- @literalValue "/" | |
| literal DIVIDE; | |
| -- @literalValue "%" | |
| literal REMAINDER; | |
| -- @literalValue "+" | |
| literal PLUS; | |
| -- @literalValue "-" | |
| literal MINUS; | |
| -- @literalValue "<<" | |
| literal LEFT_SHIFT; | |
| -- @literalValue ">>" | |
| literal RIGHT_SHIFT_SIGNED; | |
| -- @literalValue ">>>" | |
| literal RIGHT_SHIFT_UNSIGNED; | |
| -- @literalValue "<" | |
| literal LESS; | |
| -- @literalValue ">" | |
| literal GREATER; | |
| -- @literalValue "<=" | |
| literal LESS_EQUALS; | |
| -- @literalValue ">=" | |
| literal GREATER_EQUALS; | |
| -- @literalValue "==" | |
| literal EQUALS; | |
| -- @literalValue "!=" | |
| literal NOT_EQUALS; | |
| -- @literalValue "^" | |
| literal XOR; | |
| -- @literalValue "&" | |
| literal AND; | |
| -- @literalValue "|" | |
| literal OR; | |
| -- @literalValue "&&" | |
| literal CONDITIONAL_AND; | |
| -- @literalValue "||" | |
| literal CONDITIONAL_OR; | |
| } | |
| enumeration InheritanceKind { | |
| literal "none"; | |
| literal "abstract"; | |
| literal final; | |
| } | |
| class Initializer extends BodyDeclaration { | |
| reference body container : Block; | |
| } | |
| class InstanceofExpression extends Expression { | |
| reference rightOperand container : TypeAccess; | |
| reference leftOperand container : Expression; | |
| } | |
| class InterfaceDeclaration extends TypeDeclaration { | |
| } | |
| class Javadoc extends Comment { | |
| reference tags[*] ordered container : TagElement; | |
| } | |
| class LabeledStatement extends NamedElement, Statement { | |
| reference body container : Statement; | |
| reference usagesInBreakStatements[*] : BreakStatement oppositeOf label; -- NamedElementRef substitute opposite | |
| reference usagesInContinueStatements[*] : ContinueStatement oppositeOf label; -- NamedElementRef substitute opposite | |
| } | |
| class LineComment extends Comment { | |
| } | |
| class Manifest { | |
| reference mainAttributes [*] container : ManifestAttribute; | |
| reference entryAttributes [*] container : ManifestEntry; | |
| } | |
| class ManifestAttribute { | |
| attribute key : String; | |
| attribute value : String; | |
| } | |
| class ManifestEntry { | |
| attribute name[0-1] : String; | |
| reference attributes [*] container : ManifestAttribute; | |
| } | |
| -- member can be a MethodDeclaration/Constructor/VariableDeclarationFragment/Type | |
| class MemberRef extends ASTNode { | |
| reference member : NamedElement; | |
| reference qualifier[0-1] container : TypeAccess ; | |
| } | |
| class MethodDeclaration extends AbstractMethodDeclaration { | |
| attribute extraArrayDimensions : Integer; | |
| reference returnType[0-1] container : TypeAccess ; | |
| reference redefinedMethodDeclaration[0-1] : MethodDeclaration oppositeOf redefinitions; -- NamedElementRef substitute | |
| reference redefinitions[*] : MethodDeclaration oppositeOf redefinedMethodDeclaration;-- NamedElementRef substitute opposite | |
| } | |
| class MethodInvocation extends Expression, AbstractMethodInvocation { | |
| reference expression[0-1] container : Expression; | |
| } | |
| class MethodRef extends ASTNode { | |
| reference method : AbstractMethodDeclaration oppositeOf usagesInDocComments; -- NamedElementRef substitute | |
| reference qualifier[0-1] container : TypeAccess ; | |
| reference parameters[*] ordered container : MethodRefParameter; | |
| } | |
| class MethodRefParameter extends ASTNode { | |
| attribute name[0-1] : String; | |
| attribute varargs : Boolean; | |
| reference type container : TypeAccess ; | |
| } | |
| class Model { | |
| attribute name[0-1] : String; | |
| reference ownedElements[*] container : Package oppositeOf model; | |
| reference orphanTypes[*] container : Type; | |
| reference unresolvedItems[*] container : UnresolvedItem; | |
| reference compilationUnits[*] container : CompilationUnit; | |
| reference classFiles[*] container : ClassFile; | |
| reference archives[*] container : Archive; | |
| } | |
| class Modifier extends ASTNode { | |
| attribute visibility : VisibilityKind; | |
| attribute inheritance : InheritanceKind; | |
| attribute static : Boolean; | |
| attribute transient : Boolean; | |
| attribute volatile : Boolean; | |
| attribute native : Boolean; | |
| attribute strictfp : Boolean; | |
| attribute synchronized : Boolean; | |
| reference bodyDeclaration[0-1] : BodyDeclaration oppositeOf modifier; | |
| reference singleVariableDeclaration[0-1] : SingleVariableDeclaration oppositeOf modifier; | |
| reference variableDeclarationStatement[0-1] : VariableDeclarationStatement oppositeOf modifier; | |
| reference variableDeclarationExpression[0-1] : VariableDeclarationExpression oppositeOf modifier; | |
| } | |
| abstract class NamedElement extends ASTNode { | |
| attribute name[0-1] : String; | |
| attribute proxy : Boolean; | |
| reference usagesInImports[*] : ImportDeclaration oppositeOf importedElement; -- NamedElementRef substitute opposite | |
| } | |
| abstract class NamespaceAccess extends ASTNode { | |
| } | |
| class NumberLiteral extends Expression { | |
| attribute tokenValue : String; | |
| } | |
| class NullLiteral extends Expression { | |
| } | |
| class Package extends NamedElement { | |
| reference ownedElements[*] container : AbstractTypeDeclaration oppositeOf "package"; | |
| reference model[0-1] : Model oppositeOf ownedElements; | |
| reference ownedPackages[*] container : Package oppositeOf "package"; | |
| reference "package"[0-1] : Package oppositeOf ownedPackages; | |
| reference usagesInPackageAccess[*] : PackageAccess oppositeOf "package"; | |
| } | |
| class PackageAccess extends NamespaceAccess { | |
| reference "package" : Package oppositeOf usagesInPackageAccess; | |
| reference qualifier[0-1] container : PackageAccess; | |
| } | |
| -- arguments types are TypeAccess rather than direct Type reference | |
| -- for injector implementation constraints (unicity and ordering) | |
| class ParameterizedType extends Type { | |
| reference type container : TypeAccess ; | |
| reference typeArguments[*] ordered container : TypeAccess; | |
| } | |
| class ParenthesizedExpression extends Expression { | |
| reference expression container : Expression; | |
| } | |
| class PostfixExpression extends Expression { | |
| attribute operator : PostfixExpressionKind; | |
| reference operand container : Expression; | |
| } | |
| enumeration PostfixExpressionKind { | |
| -- @literalValue "++" | |
| literal INCREMENT; | |
| -- @literalValue "--" | |
| literal DECREMENT; | |
| } | |
| class PrefixExpression extends Expression { | |
| attribute operator : PrefixExpressionKind; | |
| reference operand container : Expression; | |
| } | |
| enumeration PrefixExpressionKind { | |
| -- @literalValue "++" | |
| literal INCREMENT; | |
| -- @literalValue "--" | |
| literal DECREMENT; | |
| -- @literalValue "+" | |
| literal PLUS; | |
| -- @literalValue "-" | |
| literal MINUS; | |
| -- @literalValue "~" | |
| literal COMPLEMENT; | |
| -- @literalValue "!" | |
| literal NOT; | |
| } | |
| class PrimitiveType extends Type { | |
| } | |
| class PrimitiveTypeBoolean extends PrimitiveType { | |
| } | |
| class PrimitiveTypeByte extends PrimitiveType { | |
| } | |
| class PrimitiveTypeChar extends PrimitiveType { | |
| } | |
| class PrimitiveTypeDouble extends PrimitiveType { | |
| } | |
| class PrimitiveTypeShort extends PrimitiveType { | |
| } | |
| class PrimitiveTypeFloat extends PrimitiveType { | |
| } | |
| class PrimitiveTypeInt extends PrimitiveType { | |
| } | |
| class PrimitiveTypeLong extends PrimitiveType { | |
| } | |
| class PrimitiveTypeVoid extends PrimitiveType { | |
| } | |
| class ReturnStatement extends Statement { | |
| reference expression[0-1] container : Expression; | |
| } | |
| -- This indirection metaclass is necessary for referencing variables in statements. | |
| -- e.g. method invocations args may be some variable access or other expressions (literal...). So | |
| -- - method invocations args must be Expression instances | |
| -- - method invocations args must be owned (containment reference) by the MethodInvocation instance | |
| -- - it involves injector implementation constraints (args unicity and ordering) | |
| -- | |
| -- qualifier could be a acces to type or to a package --> Expression | |
| class SingleVariableAccess extends Expression { | |
| reference variable : VariableDeclaration oppositeOf usageInVariableAccess; -- NamedElementRef substitute | |
| reference qualifier[0-1] container : Expression; | |
| } | |
| class SingleVariableDeclaration extends VariableDeclaration { | |
| reference modifier[0..1] container : Modifier oppositeOf singleVariableDeclaration; | |
| attribute varargs : Boolean; | |
| reference type container : TypeAccess ; | |
| reference annotations[*] ordered container : Annotation; | |
| reference methodDeclaration[0-1] : AbstractMethodDeclaration oppositeOf parameters; | |
| reference catchClause[0-1] : CatchClause oppositeOf exception; | |
| reference enhancedForStatement[0-1] : EnhancedForStatement oppositeOf parameter; | |
| } | |
| abstract class Statement extends ASTNode { | |
| } | |
| class StringLiteral extends Expression { | |
| attribute escapedValue : String; | |
| } | |
| class SuperConstructorInvocation extends Statement, AbstractMethodInvocation { | |
| reference expression[0-1] container : Expression; | |
| } | |
| class SuperFieldAccess extends AbstractTypeQualifiedExpression { | |
| reference field container : SingleVariableAccess; | |
| } | |
| class SuperMethodInvocation extends AbstractTypeQualifiedExpression, AbstractMethodInvocation { | |
| } | |
| class SwitchCase extends Statement { | |
| attribute "default" : Boolean; | |
| reference expression[0-1] container : Expression; | |
| } | |
| class SwitchStatement extends Statement { | |
| reference expression container : Expression; | |
| reference statements[*] ordered container : Statement; | |
| } | |
| class SynchronizedStatement extends Statement { | |
| reference body container : Block; | |
| reference expression container : Expression; | |
| } | |
| class TagElement extends ASTNode { | |
| attribute tagName[0-1] : String; | |
| reference fragments[*] ordered container : ASTNode; | |
| } | |
| class TextElement extends ASTNode { | |
| attribute text : String; | |
| } | |
| class ThisExpression extends AbstractTypeQualifiedExpression { | |
| } | |
| class ThrowStatement extends Statement { | |
| reference expression container : Expression; | |
| } | |
| class TryStatement extends Statement { | |
| reference body container : Block; | |
| reference finally[0-1] container : Block; | |
| reference catchClauses[*] ordered container : CatchClause; | |
| } | |
| abstract class Type extends NamedElement { | |
| reference usagesInTypeAccess[*] : TypeAccess oppositeOf type; -- NamedElementRef substitute opposite | |
| } | |
| class TypeAccess extends Expression, NamespaceAccess { | |
| reference type : Type oppositeOf usagesInTypeAccess; -- NamedElementRef substitute | |
| -- qualifier is a TypeAcces or PackageAccess | |
| reference qualifier[0-1] container : NamespaceAccess; | |
| } | |
| abstract class TypeDeclaration extends AbstractTypeDeclaration { | |
| reference typeParameters[*] ordered container : TypeParameter; | |
| } | |
| class TypeDeclarationStatement extends Statement { | |
| reference declaration container : AbstractTypeDeclaration; | |
| } | |
| class TypeLiteral extends Expression { | |
| reference type container : TypeAccess; | |
| } | |
| -- TypeParameter must be a Type to be referenced as a type in method parameters | |
| class TypeParameter extends Type { | |
| reference bounds[*] ordered container : TypeAccess; | |
| } | |
| class UnresolvedItem extends NamedElement { | |
| } | |
| class UnresolvedItemAccess extends Expression, NamespaceAccess { | |
| reference element[0-1] : UnresolvedItem; | |
| -- qualifier can be a Expression or a NamespaceAccess | |
| reference qualifier[0-1] container : ASTNode; | |
| } | |
| class UnresolvedAnnotationDeclaration extends AnnotationTypeDeclaration, UnresolvedItem { | |
| } | |
| class UnresolvedAnnotationTypeMemberDeclaration extends AnnotationTypeMemberDeclaration, UnresolvedItem { | |
| } | |
| class UnresolvedClassDeclaration extends ClassDeclaration, UnresolvedItem { | |
| } | |
| class UnresolvedEnumDeclaration extends EnumDeclaration, UnresolvedItem { | |
| } | |
| class UnresolvedInterfaceDeclaration extends InterfaceDeclaration, UnresolvedItem { | |
| } | |
| class UnresolvedLabeledStatement extends LabeledStatement, UnresolvedItem { | |
| } | |
| class UnresolvedMethodDeclaration extends MethodDeclaration, UnresolvedItem { | |
| } | |
| class UnresolvedSingleVariableDeclaration extends SingleVariableDeclaration, UnresolvedItem { | |
| } | |
| class UnresolvedType extends Type, UnresolvedItem { | |
| } | |
| class UnresolvedTypeDeclaration extends AbstractTypeDeclaration, UnresolvedItem { | |
| } | |
| class UnresolvedVariableDeclarationFragment extends VariableDeclarationFragment, UnresolvedItem { | |
| } | |
| abstract class VariableDeclaration extends NamedElement { | |
| attribute extraArrayDimensions : Integer; | |
| reference initializer[0-1] container : Expression; | |
| reference usageInVariableAccess[*] : SingleVariableAccess oppositeOf variable; -- NamedElementRef substitute opposite | |
| } | |
| class VariableDeclarationExpression extends Expression, AbstractVariablesContainer { | |
| reference modifier[0..1] container : Modifier oppositeOf variableDeclarationExpression; | |
| reference annotations[*] ordered container : Annotation; | |
| } | |
| class VariableDeclarationFragment extends VariableDeclaration { | |
| reference variablesContainer[0-1] : AbstractVariablesContainer oppositeOf fragments; | |
| } | |
| class VariableDeclarationStatement extends Statement, AbstractVariablesContainer { | |
| attribute extraArrayDimensions : Integer; | |
| reference modifier[0..1] container : Modifier oppositeOf variableDeclarationStatement; | |
| reference annotations[*] ordered container : Annotation; | |
| } | |
| enumeration VisibilityKind { | |
| literal none; | |
| literal public; | |
| literal private; | |
| literal protected; | |
| } | |
| class WildCardType extends Type { | |
| attribute upperBound : Boolean; | |
| reference bound[0-1] container : TypeAccess; | |
| } | |
| class WhileStatement extends Statement { | |
| reference expression container : Expression; | |
| reference body container : Statement; | |
| } | |
| } | |
| package PrimitiveTypes { | |
| datatype Boolean; | |
| datatype Integer; | |
| datatype String; | |
| } |