moosetechnology / FAST-JAVA / 6736545635

FASTJavaMetamodelGenerator class >> packageName [

        ^ #'FAST-Java-Model'

]

FASTJavaMetamodelGenerator class >> prefix [

        ^ #FASTJava

]

FASTJavaMetamodelGenerator class >> submetamodels [

        ^ { FASTMetamodelGenerator }

]

FASTJavaMetamodelGenerator >> commentForAssertStatement [

        ^ 'I represent an assert statement

example:

void method (){

        assert condition1 || condition2 : "error message"

}

'

]

FASTJavaMetamodelGenerator >> commentForJavaAnnotation [

        ^ 'I reprensent a Java Annotation

example:

@Override'

]

FASTJavaMetamodelGenerator >> commentForJavaArrayAccess [

        ^ 'I represent a java array access

ex:

liste[i]'

]

FASTJavaMetamodelGenerator >> commentForJavaArrayInitializer [

        ^ 'I represent the array initializer and I have many initializers

ex:

String patate = {"hello", "world"}

I am : {"hello", "world"} 

My initializers are 

"hello" and "world"

 '

]

{ #category : #comments }

FASTJavaMetamodelGenerator >> commentForJavaAssignmentExpression [

        ^ 'An assignment expression mode.

Contains a referances to an assignee assignee and the expression that''s being assigned.'

]

{ #category : #comments }

FASTJavaMetamodelGenerator >> commentForJavaBooleanLiteral [

        ^ 'I represent a boolean literal node.'

]

{ #category : #comments }

FASTJavaMetamodelGenerator >> commentForJavaBreakStatement [

        ^ 'A node representing break statement in java'

]

{ #category : #comments }

FASTJavaMetamodelGenerator >> commentForJavaCaseStatement [

        ^ 'case part of switch statement'

]

{ #category : #comments }

FASTJavaMetamodelGenerator >> commentForJavaCharacterLiteral [

        ^ 'I represent a character literal node.

example:

```java

char c = ''a'';

```

`''a''` is the literal'

]

{ #category : #comments }

FASTJavaMetamodelGenerator >> commentForJavaClassDeclaration [

        ^ 'I represent a class declaration

example

public class ClassName extends SomeClass implements OneClass, TwoClass {

        int oneDeclaration;

        void methodDeclaration(){

        }

}'

]

{ #category : #comments }

FASTJavaMetamodelGenerator >> commentForJavaClassProperty [

        ^ 'A FASTJavaClassProperty corresponds to the access to a class property

        It is not the same as the field access because there are some specific usage of class property to access the current object.

ex.

class Enclosing {

    void method(Enclosing other) {

        // ...

    }

    void otherMethod() {

        new Runnable() {

            public void run() {

                method(this);

                                                                --> Does not compile. ''this'' is a Runnable!

                method(Enclosing.this);

                                                                --> Compiles fine.

            }

        }.run();

    }

}

'

]

{ #category : #comments }

FASTJavaMetamodelGenerator >> commentForJavaComment [

        ^ 'I represent a Java comment (block or line comment)'

]

{ #category : #comments }

FASTJavaMetamodelGenerator >> commentForJavaConditionalStatement [

        ^ 'I represent a Java conditionnal Statement

ex:

(h.get() == 2) ? thenPart : elsePart'

]

{ #category : #comments }

FASTJavaMetamodelGenerator >> commentForJavaContinueStatement [

        ^ 'A node representing continue statement in java'

]

{ #category : #comments }

FASTJavaMetamodelGenerator >> commentForJavaDefaultCaseStatement [

        ^ 'I represent a default case

ex.:

default:'

]

{ #category : #comments }

FASTJavaMetamodelGenerator >> commentForJavaDoWhileStatement [

        ^ 'A node of a do-while statement.

eg.

do {

...

} while(...);'

]

{ #category : #comments }

FASTJavaMetamodelGenerator >> commentForJavaDoubleLiteral [

        ^ 'I represent a double literal node.

example:

```java

double d1 = 12.3;

double d2 = 12.3d;

```

`12.3` and `12.3d` are double literals'

]

{ #category : #comments }

FASTJavaMetamodelGenerator >> commentForJavaEmptyDimExpression [

        ^ 'A node representing an empty expression when creating an array, for example:

        new String[] {"a"};'

]

{ #category : #comments }

FASTJavaMetamodelGenerator >> commentForJavaEmptyMethodDeclaration [

        ^ 'I reprensent an empty method declaration

ex.:

void newMethod() {

        new Patate() {

                //The empty method declaration is ";" 

                ;

        };

}'

]

{ #category : #comments }

FASTJavaMetamodelGenerator >> commentForJavaEnumDeclaration [

        ^ 'I represent an enum declaration

example

public enum MyEnum {

        HELLO;

        int oneDeclaration;

        void methodDeclaration(){

        }

}'

]

{ #category : #comments }

FASTJavaMetamodelGenerator >> commentForJavaFieldAccess [

        ^ 'A FASTJavaFieldAccess corresponds to an access to an instance variable (field)'

]

{ #category : #comments }

FASTJavaMetamodelGenerator >> commentForJavaFloatLiteral [

        ^ 'I represent a float literal node.

example:

```java

float f = 12.3f;

```

`12.3f` is the literal'

]

{ #category : #comments }

FASTJavaMetamodelGenerator >> commentForJavaForEachStatement [

        ^ 'A node of a for loop statement.

eg.

for(Patate p : list) {

...

}'

]

{ #category : #comments }

FASTJavaMetamodelGenerator >> commentForJavaForStatement [

        ^ 'A node of a for loop statement.

eg.

for(_;_;_) {

...

}'

]

{ #category : #comments }

FASTJavaMetamodelGenerator >> commentForJavaIdentifier [

        ^ 'A FASTJavaIdentifier is an identifier in a Java program'

]

{ #category : #comments }

FASTJavaMetamodelGenerator >> commentForJavaIfStatement [

        ^ 'A node of a if statement or an if-else statement.

eg.

if(...) {

...

} else {

...

}'

]

{ #category : #comments }

FASTJavaMetamodelGenerator >> commentForJavaInfixOperation [

        ^ 'Binary java operations in  format: <expr> <operator> <expr>

ex:

        a + b

        3 == 6

        a = 6'

]

{ #category : #comments }

FASTJavaMetamodelGenerator >> commentForJavaInitializer [

        ^ 'I represent a Java initializer

ex.:

new Button(){

{ something }

}

'

]

{ #category : #comments }

FASTJavaMetamodelGenerator >> commentForJavaIntegerLiteral [

        ^ 'I represent an integer literal node.'

]

{ #category : #comments }

FASTJavaMetamodelGenerator >> commentForJavaInterfaceDeclaration [

        ^ 'I represent an interface declaration

example

```java

public interface MyInterface {

    public static final String CODE = "SEME";

}

```

'

]

{ #category : #comments }

FASTJavaMetamodelGenerator >> commentForJavaLabeledCaseStatement [

        ^ 'I represent a Labeled case

ex.:

case LABEL:'

]

{ #category : #comments }

FASTJavaMetamodelGenerator >> commentForJavaLongLiteral [

        ^ 'I represent a long literal node.

example:

```java

long l = 2147483648L;

```

`2147483648L` is the literal'

]

{ #category : #comments }

FASTJavaMetamodelGenerator >> commentForJavaMethodEntity [

        ^ 'Represents a Java method'

]

{ #category : #comments }

FASTJavaMetamodelGenerator >> commentForJavaMethodInvocation [

        ^ 'A node representing method invocation'

]

{ #category : #comments }

FASTJavaMetamodelGenerator >> commentForJavaModifier [

        ^ 'I am a Java modifier

example: 

for classes: 

- public

- default

- final

- abstract

for methods:

- public

- private

- default

- protected

- final

- static

- abstract

- transient

- synchronized

- volatile

'

]

{ #category : #comments }

FASTJavaMetamodelGenerator >> commentForJavaNewArray [

        ^ 'I represent a java new array node.

ex.

new String()["10px", "Hello world"]'

]

{ #category : #comments }

FASTJavaMetamodelGenerator >> commentForJavaNewClassExpression [

        ^ 'I represent a new class expression (which is most of the time a new anonymous class)

ex. for SecureAsyncCallback

new SecureAsyncCallback<Void>() {

        @Override

        public void onSuccess(final Void result) {}

        @Override

        public void onFailure(final Throwable caught) {

                super.onFailure(caught);

        }

}'

]

{ #category : #comments }

FASTJavaMetamodelGenerator >> commentForJavaNewExpression [

        ^ 'I represent the invocation of a Class constructor with the keyword ''new''

ex.

new Patate()'

]

{ #category : #comments }

FASTJavaMetamodelGenerator >> commentForJavaNullLiteral [

        ^ 'I represent a `null` literal node.'

]

{ #category : #comments }

FASTJavaMetamodelGenerator >> commentForJavaOuterThis [

        ^ 'I represent a java outer this (only a call to ''this'' to a class)

ex.:

hello(MyClass.this)'

]

{ #category : #comments }

FASTJavaMetamodelGenerator >> commentForJavaQualifiedTypeName [

        ^ 'I represent a qualified name for a type

example:

new Canard.Poulet(){

}

"Canard.Poulet" is the qualified name

"Poulet" is the main name

"Canard" is the namespace of the main name 

'

]

FASTJavaMetamodelGenerator >> commentForJavaStringLiteral [

        ^ 'I represent a string literal node.'

]

FASTJavaMetamodelGenerator >> commentForJavaSwitchStatement [

        ^ 'A node representing switch statement

eg.

switch (_) {

...

}'

]

FASTJavaMetamodelGenerator >> commentForJavaTAssignable [

        ^ 'You can assign something to me

example:

this.hello = "hello"'

]

FASTJavaMetamodelGenerator >> commentForJavaTModifier [

        ^ 'I am a modifier in java

example:

public, proctected, private'

]

FASTJavaMetamodelGenerator >> commentForJavaThis [

        ^ 'A FASTJavaThis corresponds to ''this'' in Java'

]

FASTJavaMetamodelGenerator >> commentForJavaThrowStatement [

        ^ 'I represent a java throw statement

ex:

throw new Hello();'

]

FASTJavaMetamodelGenerator >> commentForJavaTryCatchStatement [

        ^ 'I represent the java try catch statement. I must have two parts: the ''Try'' part and the ''catch'' part. 

ex.

void tryCatch() {

        int x;

        try {

                x = 1;

   } catch (Exception e) {

                Patate.displayError(e.getMessage());

        };

}

'

]

FASTJavaMetamodelGenerator >> commentForJavaUnaryExpression [

        ^ 'I represent a Java Unary Expression

It can be :

++i

i++

--i

i--

!b

+i

-i

see: https://docs.oracle.com/javase/tutorial/java/nutsandbolts/op1.html'

]

FASTJavaMetamodelGenerator >> commentForJavaVarDeclStatement [

        ^ 'A statement of variable declaration.

A variable declaration statement can contain several declarators.

eg.

int d = 3, e, f = 5;

statement has 3 declarators separated by commas. Second declarator has no expression.'

]

FASTJavaMetamodelGenerator >> commentForJavaVariableDeclarator [

        ^ 'A part of variable declaration statement containing a variable (named entity) and an expression (optional) that is assigned to it.

A variable declaration statement can contain several declarators.

eg.

int d = 3, e, f = 5;

statement has 3 declarators separated by commas. Second declarator has no expression.'

]

FASTJavaMetamodelGenerator >> commentForJavaWhileStatement [

        ^ 'A node of a while statement.

eg.

while(...) {

...

}'

]

FASTJavaMetamodelGenerator >> defineClasses [

        super defineClasses.

        javaEntity  := builder newClassNamed: #Entity.

        javaComment := builder newClassNamed: #Comment comment: self commentForJavaComment.

        javaFieldAccess := builder newClassNamed: #FieldAccess comment: self commentForJavaFieldAccess.

        javaIdentifier := builder newClassNamed: #Identifier comment: self commentForJavaIdentifier.

        javaInfixOperation := builder newClassNamed: #InfixOperation comment: self commentForJavaInfixOperation.

        javaMethodEntity := builder newClassNamed: #MethodEntity comment: self commentForJavaMethodEntity.

        javaMethodInvocation := builder newClassNamed: #MethodInvocation comment: self commentForJavaMethodInvocation.

        javaThis := builder newClassNamed: #This comment: self commentForJavaThis.

        javaOuterThis := builder newClassNamed: #OuterThis comment: self commentForJavaOuterThis.

        javaVariableDeclarator := builder newClassNamed: #VariableDeclarator comment: self commentForJavaVariableDeclarator.

        javaClassProperty := builder newClassNamed: #ClassProperty comment: self commentForJavaClassProperty.

        javaNewArray := builder newClassNamed: #NewArray comment: self commentForJavaNewArray.

        javaArrayAccess := builder newClassNamed: #ArrayAccess comment: self commentForJavaArrayAccess.

        javaInitializer := builder newClassNamed: #Initializer comment: self commentForJavaInitializer.

        javaArrayInitializer :=  builder newClassNamed: #ArrayInitializer comment: self commentForJavaArrayInitializer.

        javaModifier := builder newClassNamed: #Modifier comment: self commentForJavaModifier.        

        javaEnumConstant := builder newClassNamed: #EnumConstant.

        javaLambdaExpression := builder newClassNamed: #LambdaExpression comment: 'I represent a lambda expression'.

        javaMethodReference := builder newClassNamed: #MethodReference comment: 'I represent a method reference'.

        javaSynchronizedStatement := builder newClassNamed: #SynchronizedStatement comment: 'I represent a ''synchronized'' statement'.

        "type name"

        javaTypeName := builder newClassNamed: #TypeName comment: 'I represent the name of a type'.

        javaQualifiedTypeName := builder newClassNamed: #QualifiedTypeName comment: self commentForJavaQualifiedTypeName.

        "literals"

        javaCharacterLiteral := builder newClassNamed: #CharacterLiteral comment: self commentForJavaCharacterLiteral.

        javaFloatLiteral := builder newClassNamed: #FloatLiteral comment: self commentForJavaFloatLiteral.

        javaIntegerLiteral := builder newClassNamed: #IntegerLiteral comment: self commentForJavaIntegerLiteral.

        javaNullLiteral := builder newClassNamed: #NullLiteral comment: self commentForJavaNullLiteral.

        javaStringLiteral := builder newClassNamed: #StringLiteral comment: self commentForJavaStringLiteral.

        javaBooleanLiteral := builder newClassNamed: #BooleanLiteral comment: self commentForJavaBooleanLiteral.

        javaLongLiteral := builder newClassNamed: #LongLiteral comment: self commentForJavaLongLiteral.

        javaDoubleLiteral := builder newClassNamed: #DoubleLiteral comment: self commentForJavaDoubleLiteral.

        "type expressions"

        javaTypeExpression := builder newClassNamed: #TypeExpression comment: 'I am an abstract class representing a type'.

        javaArrayTypeExpression := builder newClassNamed: #ArrayTypeExpression comment: 'I represent an array type'.

        javaClassTypeExpression := builder newClassNamed: #ClassTypeExpression comment: 'I represent a class type'.

        javaPrimitiveTypeExpression := builder newClassNamed: #PrimitiveTypeExpression comment: 'I represent a primitive type'.

        javaTypeParameter := builder newClassNamed: #TypeParameterExpression comment: 'I represent JavaTypeParameter such as `void <T extends Hello> T myMethod()`'.

        "primitive type expressions"

        javaBooleanTypeExpression := builder newClassNamed: #BooleanTypeExpression comment: 'I represent a boolean type'.

        javaByteTypeExpression := builder newClassNamed: #ByteTypeExpression comment: 'I represent a byte type'.

        javaCharTypeExpression := builder newClassNamed: #CharTypeExpression comment: 'I represent a char type'.

        javaDoubleTypeExpression := builder newClassNamed: #DoubleTypeExpression comment: 'I represent a double type'.

        javaFloatTypeExpression := builder newClassNamed: #FloatTypeExpression comment: 'I represent a float type'.

        javaIntTypeExpression := builder newClassNamed: #IntTypeExpression comment: 'I represent an int type'.

        javaLongTypeExpression := builder newClassNamed: #LongTypeExpression comment: 'I represent a long type'.

        javaShortTypeExpression := builder newClassNamed: #ShortTypeExpression comment: 'I represent a short type'.

        javaVoidTypeExpression := builder newClassNamed: #VoidTypeExpression comment: 'I represent a short type'.

        "expressions"

        javaUnaryExpression := builder newClassNamed: #UnaryExpression comment: self commentForJavaUnaryExpression.

        javaNewExpression := builder newClassNamed: #NewExpression comment: self commentForJavaNewExpression.

        javaNewClassExpression := builder newClassNamed: #NewClassExpression comment: self commentForJavaNewClassExpression.

        javaAssignmentExpression := builder newClassNamed: #AssignmentExpression comment: self commentForJavaAssignmentExpression.

        javaCastExpression := builder newClassNamed: #CastExpression comment: 'I represent a cast expression, e.g. `(int) 0.5`'.

        javaParameterExpression := builder newClassNamed: #Parameter comment: 'I represent a parameter of a method declaration'.

        javaConditionalExpression := builder newClassNamed: #ConditionalExpression comment: self commentForJavaConditionalStatement.

        javaAnnotationExpression := builder newClassNamed: #Annotation comment: self commentForJavaAnnotation.

        javaVariableExpression := builder newClassNamed: #VariableExpression.

        javaEmptyDimExpression := builder newClassNamed: #EmptyDimExpression comment: self commentForJavaEmptyDimExpression.

        "statements"

        javaStatement := builder newClassNamed: #Statement.

        javaIfStatement := builder newClassNamed: #IfStatement comment: self commentForJavaIfStatement.

        javaForStatement := builder newClassNamed: #ForStatement comment: self commentForJavaForStatement.

        javaBreakStatement := builder newClassNamed: #BreakStatement comment: self commentForJavaBreakStatement.

        javaSwitchStatement := builder newClassNamed: #SwitchStatement comment: self commentForJavaSwitchStatement.

        javaCaseStatement := builder newClassNamed: #CaseStatement comment: self commentForJavaCaseStatement.

        javaContinueStatement := builder newClassNamed: #ContinueStatement comment: self commentForJavaContinueStatement.

        javaWhileStatement := builder newClassNamed: #WhileStatement comment: self commentForJavaWhileStatement.

        javaDoWhileStatement := builder newClassNamed: #DoWhileStatement comment: self commentForJavaDoWhileStatement.

        javaThrowStatement := builder newClassNamed: #ThrowStatement comment: self commentForJavaThrowStatement.

        javaTryCatchStatement := builder newClassNamed: #TryCatchStatement comment: self commentForJavaTryCatchStatement.

        javaCatchPartStatement := builder newClassNamed: #CatchPartStatement comment: 'I represent the ''catch'' part of the TryCatch Statement'.

        javaForEachStatement := builder newClassNamed: #ForEachStatement comment: self commentForJavaForEachStatement.

        javaLabeledCaseStatement := builder newClassNamed: #LabeledCaseStatement comment: self commentForJavaLabeledCaseStatement.

        javaDefaultCaseStatement := builder newClassNamed: #DefaultCaseStatement comment: self commentForJavaDefaultCaseStatement.

        javaVarDeclStatement := builder newClassNamed: #VarDeclStatement comment: self commentForJavaVarDeclStatement.

        javaAssertStatement := builder newClassNamed: #AssertStatement comment: self commentForAssertStatement. 

        javaStatementBlock := builder newClassNamed: #StatementBlock.

        javaReturnStatement := builder newClassNamed: #ReturnStatement.

        javaExpressionStatement := builder newClassNamed: #ExpressionStatement.

        javaLabeledStatement := builder newClassNamed: #LabeledStatement.

        "declarations"

        javaClassDeclaration := builder newClassNamed: #ClassDeclaration comment: self commentForJavaClassDeclaration.

        javaEnumDeclaration := builder newClassNamed: #EnumDeclaration comment: self commentForJavaEnumDeclaration.

        javaInterfaceDeclaration := builder newClassNamed: #InterfaceDeclaration comment: self commentForJavaInterfaceDeclaration.

        javaEmptyMethodDeclaration := builder newClassNamed: #EmptyMethodDeclaration comment: self commentForJavaEmptyMethodDeclaration.

        compilationUnit := builder newClassNamed: #CompilationUnit comment: 'I represent a compilation unit, I can contain declarations for a package, imports, and types'.

        packageDeclaration := builder newClassNamed: #PackageDeclaration comment: 'I represent a package declaration, e.g. `package fr.inria;`'.

        importDeclaration := builder newClassNamed: #ImportDeclaration comment: 'I represent an import declaration, e.g. `import java.util.List;`'.

        qualifiedName := builder newClassNamed: #QualifiedName.

]

FASTJavaMetamodelGenerator >> defineHierarchy [

        "define class hierarchy"

        super defineHierarchy.

        javaEntity --|> tEntity.

        javaEntity --|> tWithComments.

        javaComment --|> tComment.

        javaAssignmentExpression --|> tExpression.

        javaAssignmentExpression --|> tReceiver.

        javaAssignmentExpression --|> tWithAssignable.

        javaFieldAccess --|> tExpression.

        javaFieldAccess --|> tAssignable.

        javaFieldAccess --|> tWithReceiver.

        javaFieldAccess --|> tReceiver.

        javaInfixOperation --|> tExpression.

        javaInfixOperation --|> tReceiver.

        javaBreakStatement --|> tStatement.

        javaCaseStatement --|> tStatementBlock.

        javaContinueStatement --|> tStatement.

        javaDoWhileStatement --|> tStatement.

        javaForStatement --|> tStatement.

        javaIdentifier --|> javaVariableExpression.

        javaIdentifier --|> tReceiver.

        javaIfStatement --|> tStatement.

        javaNullLiteral --|> tNullPointerLiteral.

        javaCharacterLiteral --|> tCharacterLiteral.

        javaCharacterLiteral --|> tReceiver.

        javaStringLiteral --|> tStringLiteral.

        javaStringLiteral --|> tReceiver.

        javaIntegerLiteral --|> tLiteral.

        javaIntegerLiteral --|> tReceiver.

        javaFloatLiteral --|> tLiteral.

        javaFloatLiteral --|> tReceiver.

        javaBooleanLiteral --|> tLiteral.

        javaBooleanLiteral --|> tReceiver.

        javaLongLiteral --|> tLiteral.

        javaLongLiteral --|> tReceiver.

        javaDoubleLiteral --|> tLiteral.

        javaDoubleLiteral --|> tReceiver.

        javaMethodEntity --|> tNamedBehaviouralEntity.

        javaMethodEntity --|> #THasImmediateSource.

        javaMethodEntity --|> tDeclaration.

        javaMethodEntity --|> tWithModifiers.

        javaClassDeclaration --|> tStatement.

        javaClassDeclaration --|> tDeclaration.

        javaClassDeclaration --|> tWithDeclarations.

        javaClassDeclaration --|> tWithModifiers.

        javaClassDeclaration --|> tNamedEntity.

        javaClassDeclaration --|> #THasImmediateSource.

        javaClassDeclaration withPrecedenceOf: #THasImmediateSource.

        javaEnumDeclaration --|> tStatement.

        javaEnumDeclaration --|> tDeclaration.

        javaEnumDeclaration --|> tWithDeclarations.

        javaEnumDeclaration --|> tWithModifiers.

        javaEnumDeclaration --|> tNamedEntity.

        javaEnumDeclaration --|> #THasImmediateSource.

        javaEnumDeclaration withPrecedenceOf: #THasImmediateSource.

        javaEnumConstant --|> javaVariableExpression.

        javaInterfaceDeclaration --|> tStatement.

        javaInterfaceDeclaration --|> tDeclaration.

        javaInterfaceDeclaration --|> tWithDeclarations.

        javaInterfaceDeclaration --|> tWithModifiers.

        javaInterfaceDeclaration --|> tNamedEntity.

        javaInterfaceDeclaration --|> #THasImmediateSource.

        javaInterfaceDeclaration withPrecedenceOf: #THasImmediateSource.

        javaMethodInvocation --|> tInvocation.

        javaMethodInvocation --|> tWithReceiver.

        javaMethodInvocation --|> tReceiver.

        javaSwitchStatement --|> tStatement.

        javaThis --|> javaVariableExpression.

        javaVarDeclStatement --|> tStatement.

        javaVarDeclStatement --|> tDeclaration.

        javaVarDeclStatement --|> tScopableEntity.

        javaVarDeclStatement --|> tWithModifiers.

        javaVariableDeclarator --|> tEntity.

        javaWhileStatement --|> tStatement.

        javaMethodInvocation --|> tNamedEntity.

        javaCastExpression --|> tExpression.