| -- |
| -- ******************************************************************************* |
| -- Copyright (c) 2009 Mia-Software. |
| -- All rights reserved. This program and the accompanying materials |
| -- are made available under the terms of the Eclipse Public License v1.0 |
| -- which accompanies this distribution, and is available at |
| -- http://www.eclipse.org/legal/epl-v10.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; |
| } |