moosetechnology / FAST-JAVA / 14759544315

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 >> commentForJavaTypePattern [

        ^ 'This code element defines a type pattern, introduced in Java 16 by [JEP 394](https://openjdk.java.net/jeps/394).

Example:

```language=text

        Object obj = null;

        boolean longerThanTwo = false;

        // String s is the type pattern, declaring a local variable

        if (obj instanceof String s) {

                longerThanTwo = s.length() > 2;

        }

```'

]

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  := self newClassNamed: #Entity.

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

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

        javaFieldAccess withTesting.

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

        javaIdentifier withTesting.

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

        javaInfixOperation withTesting.

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

        javaMethodEntity withTesting.

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

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

        javaThis withTesting.

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

        javaOuterThis withTesting.

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

        javaVariableDeclarator withTesting.

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

        javaClassProperty withTesting.

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

        javaNewArray withTesting.

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

        javaArrayAccess withTesting.

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

        javaInitializer withTesting.

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

        javaArrayInitializer withTesting.

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

        javaModifier withTesting.

        javaEnumConstant := self newClassNamed: #EnumConstant.

        javaEnumConstant withTesting.

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

        javaLambdaExpression withTesting.

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

        javaMethodReference withTesting.

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

        javaSynchronizedStatement withTesting.

        "type name"

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

        javaTypeName withTesting.

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

        javaQualifiedTypeName withTesting.

        "literals"

        javaLiteral := self newClassNamed: #Literal comment: 'abtract class for all literals'.

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

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

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

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

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

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

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

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

        "type expressions"

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

        javaTypeExpression withTesting.

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

        javaArrayTypeExpression withTesting.

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

        javaClassTypeExpression withTesting.

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

        javaPrimitiveTypeExpression withTesting.

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

        javaTypeParameter withTesting.

        "primitive type expressions"

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

        javaBooleanTypeExpression withTesting.

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

        javaByteTypeExpression withTesting.

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

        javaCharTypeExpression withTesting.

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

        javaDoubleTypeExpression withTesting.

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

        javaFloatTypeExpression withTesting.

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

        javaIntTypeExpression withTesting.

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

        javaLongTypeExpression withTesting.

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

        javaShortTypeExpression withTesting.

        javaVarTypeExpression := self newClassNamed: #VarTypeExpression comment: 'I represent a var type (type inference)'.

        javaVarTypeExpression withTesting.

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

        javaVoidTypeExpression withTesting.

        "expressions"

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

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

        javaNewExpression withTesting.

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

        javaNewClassExpression withTesting.

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

        javaAssignmentExpression withTesting.

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

        javaCastExpression withTesting.

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

        javaParameterExpression withTesting.

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

        javaConditionalExpression withTesting.

        javaVariableExpression := self newClassNamed: #VariableExpression.

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

        javaEmptyDimExpression withTesting.

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

        javaAnnotationExpression withTesting.

        javaArrayAnnotationElement := self newClassNamed: #ArrayAnnotationElement comment: 'I represent an array as argument of an annotationExpression'.

        javaArrayAnnotationElement withTesting.

        javaTypePattern := self newClassNamed: #TypePattern comment: self commentForJavaTypePattern.

        javaTypePattern withTesting.

        "statements"

        javaStatement := self newClassNamed: #Statement.

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

        javaIfStatement withTesting.

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

        javaForStatement withTesting.

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

        javaBreakStatement withTesting.

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

        javaSwitchStatement withTesting.

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

        javaCaseStatement withTesting.

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

        javaContinueStatement withTesting.

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

        javaWhileStatement withTesting.

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

        javaDoWhileStatement withTesting.

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

        javaThrowStatement withTesting.

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

        javaTryCatchStatement withTesting.

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

        javaCatchPartStatement withTesting.

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

        javaForEachStatement withTesting.

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

        javaLabeledCaseStatement withTesting.

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

        javaDefaultCaseStatement withTesting.

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

        javaVarDeclStatement withTesting.

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

        javaVarDeclStatement withTesting.

        javaStatementBlock := self newClassNamed: #StatementBlock.

        javaReturnStatement := self newClassNamed: #ReturnStatement.

        javaExpressionStatement := self newClassNamed: #ExpressionStatement.

        javaLabeledStatement := self newClassNamed: #LabeledStatement.

        javaLabeledStatement withTesting.

        "declarations"

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

        javaClassDeclaration withTesting.

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

        javaEnumDeclaration withTesting.

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

        javaInterfaceDeclaration withTesting.

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

        javaEmptyMethodDeclaration withTesting.

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

        compilationUnit withTesting.

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