From c76916e90ce7743d1a974d4e82b100e46b8f6354 Mon Sep 17 00:00:00 2001 From: Janik Rapp Date: Mon, 14 Jul 2025 16:42:55 +0200 Subject: [PATCH 01/61] remove old DeSer skeletons --- .../AnnotationTypeDeclarationSymbolDeSer.java | 10 ----- .../ClassDeclarationSymbolDeSer.java | 44 ------------------- .../EnumDeclarationSymbolDeSer.java | 31 ------------- .../InterfaceDeclarationSymbolDeSer.java | 13 ------ 4 files changed, 98 deletions(-) delete mode 100644 javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/AnnotationTypeDeclarationSymbolDeSer.java delete mode 100644 javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/ClassDeclarationSymbolDeSer.java delete mode 100644 javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/EnumDeclarationSymbolDeSer.java delete mode 100644 javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/InterfaceDeclarationSymbolDeSer.java diff --git a/javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/AnnotationTypeDeclarationSymbolDeSer.java b/javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/AnnotationTypeDeclarationSymbolDeSer.java deleted file mode 100644 index 4e799469..00000000 --- a/javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/AnnotationTypeDeclarationSymbolDeSer.java +++ /dev/null @@ -1,10 +0,0 @@ -package de.monticore.java.javadsl._symboltable; - -import de.monticore.symboltable.serialization.json.JsonObject; -import de.monticore.types.check.SymTypeExpression; - -import java.util.List; - -public class AnnotationTypeDeclarationSymbolDeSer extends AnnotationTypeDeclarationSymbolDeSerTOP { - -} diff --git a/javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/ClassDeclarationSymbolDeSer.java b/javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/ClassDeclarationSymbolDeSer.java deleted file mode 100644 index 648f4a07..00000000 --- a/javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/ClassDeclarationSymbolDeSer.java +++ /dev/null @@ -1,44 +0,0 @@ -package de.monticore.java.javadsl._symboltable; - -import de.monticore.javalight._symboltable.JavaMethodSymbol; -import de.monticore.symboltable.serialization.json.JsonObject; -import de.monticore.types.check.SymTypeExpression; -import de.monticore.types.mcbasictypes._ast.ASTMCType; - -import java.util.List; -import java.util.Optional; - -public class ClassDeclarationSymbolDeSer extends ClassDeclarationSymbolDeSerTOP { - - - @Override - protected void serializeSuperInterface(List superInterface, JavaDSLSymbols2Json s2j) { - - } - - @Override - protected void serializeConstructor(List constructor, JavaDSLSymbols2Json s2j) { - - } - - @Override - protected void serializeMethods(List methods, JavaDSLSymbols2Json s2j) { - - } - - @Override - protected List deserializeSuperInterface(JsonObject symbolJson) { - return null; - } - - @Override - protected List deserializeConstructor(JsonObject symbolJson) { - return null; - } - - @Override - protected List deserializeMethods(JsonObject symbolJson) { - return null; - } - -} diff --git a/javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/EnumDeclarationSymbolDeSer.java b/javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/EnumDeclarationSymbolDeSer.java deleted file mode 100644 index 6d3dd5e8..00000000 --- a/javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/EnumDeclarationSymbolDeSer.java +++ /dev/null @@ -1,31 +0,0 @@ -package de.monticore.java.javadsl._symboltable; - -import de.monticore.javalight._symboltable.JavaMethodSymbol; -import de.monticore.symboltable.serialization.json.JsonObject; -import de.monticore.types.check.SymTypeExpression; - -import java.util.List; - -public class EnumDeclarationSymbolDeSer extends EnumDeclarationSymbolDeSerTOP { - - @Override - protected void serializeConstructor(List constructor, JavaDSLSymbols2Json s2j) { - - } - - @Override - protected void serializeMethods(List methods, JavaDSLSymbols2Json s2j) { - - } - - @Override - protected List deserializeConstructor(JsonObject symbolJson) { - return null; - } - - @Override - protected List deserializeMethods(JsonObject symbolJson) { - return null; - } - -} \ No newline at end of file diff --git a/javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/InterfaceDeclarationSymbolDeSer.java b/javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/InterfaceDeclarationSymbolDeSer.java deleted file mode 100644 index d407f086..00000000 --- a/javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/InterfaceDeclarationSymbolDeSer.java +++ /dev/null @@ -1,13 +0,0 @@ -package de.monticore.java.javadsl._symboltable; - -import de.monticore.symboltable.serialization.json.JsonObject; -import de.monticore.types.check.SymTypeExpression; -import de.monticore.types.mcbasictypes._ast.ASTMCType; - -import java.util.List; - -public class InterfaceDeclarationSymbolDeSer extends InterfaceDeclarationSymbolDeSerTOP { - - - -} From de940a8646eeae6584848f183b37c4f45cf7a0e4 Mon Sep 17 00:00:00 2001 From: Janik Rapp Date: Mon, 14 Jul 2025 16:43:14 +0200 Subject: [PATCH 02/61] add class2mc and testFixture dependencies --- javaDSL/build.gradle | 2 ++ 1 file changed, 2 insertions(+) diff --git a/javaDSL/build.gradle b/javaDSL/build.gradle index 9db43956..fc5d7d8c 100644 --- a/javaDSL/build.gradle +++ b/javaDSL/build.gradle @@ -49,9 +49,11 @@ tasks.withType(Test).configureEach { dependencies { implementation "de.monticore.lang:cd4analysis:$mc_version" + implementation "de.monticore:class2mc:$mc_version" grammar "de.monticore:monticore-grammar:$mc_version" + testImplementation testFixtures("de.monticore:monticore-grammar:$mc_version") testImplementation "org.junit.jupiter:junit-jupiter-api:$junit_version" testImplementation "org.junit.jupiter:junit-jupiter-params:$junit_version" testRuntimeOnly "org.junit.jupiter:junit-jupiter-engine:$junit_version" From faae84efb4b947b504f2542b2dde55237d763bdc Mon Sep 17 00:00:00 2001 From: Janik Rapp Date: Fri, 18 Jul 2025 14:46:31 +0200 Subject: [PATCH 03/61] add TypeCheck3 initialization --- .../monticore/java/javadsl/JavaDSLMill.java | 17 +++ .../javadsl/types3/JavaDSLTypeCheck3.java | 107 ++++++++++++++++++ 2 files changed, 124 insertions(+) create mode 100644 javaDSL/src/main/java/de/monticore/java/javadsl/JavaDSLMill.java create mode 100644 javaDSL/src/main/java/de/monticore/java/javadsl/types3/JavaDSLTypeCheck3.java diff --git a/javaDSL/src/main/java/de/monticore/java/javadsl/JavaDSLMill.java b/javaDSL/src/main/java/de/monticore/java/javadsl/JavaDSLMill.java new file mode 100644 index 00000000..de1f91da --- /dev/null +++ b/javaDSL/src/main/java/de/monticore/java/javadsl/JavaDSLMill.java @@ -0,0 +1,17 @@ +package de.monticore.java.javadsl; + +import de.monticore.java.javadsl.types3.JavaDSLTypeCheck3; + +public class JavaDSLMill extends JavaDSLMillTOP { + + /** additionally inits the TypeCheck */ + public static void init() { + JavaDSLMillTOP.init(); + JavaDSLTypeCheck3.init(); + } + + public static void reset() { + JavaDSLMillTOP.reset(); + JavaDSLTypeCheck3.reset(); + } +} diff --git a/javaDSL/src/main/java/de/monticore/java/javadsl/types3/JavaDSLTypeCheck3.java b/javaDSL/src/main/java/de/monticore/java/javadsl/types3/JavaDSLTypeCheck3.java new file mode 100644 index 00000000..bb90b6b2 --- /dev/null +++ b/javaDSL/src/main/java/de/monticore/java/javadsl/types3/JavaDSLTypeCheck3.java @@ -0,0 +1,107 @@ +package de.monticore.java.javadsl.types3; + +import de.monticore.expressions.assignmentexpressions.types3.AssignmentExpressionsCTTIVisitor; +import de.monticore.expressions.commonexpressions.types3.CommonExpressionsCTTIVisitor; +import de.monticore.expressions.expressionsbasis.types3.ExpressionBasisCTTIVisitor; +import de.monticore.expressions.uglyexpressions.types3.UglyExpressionsCTTIVisitor; +import de.monticore.java.javadsl.JavaDSLMill; +import de.monticore.java.javadsl._visitor.JavaDSLTraverser; +import de.monticore.literals.mccommonliterals.types3.MCCommonLiteralsTypeVisitor; +import de.monticore.literals.mcjavaliterals.types3.MCJavaLiteralsTypeVisitor; +import de.monticore.symbols.basicsymbols.BasicSymbolsMill; +import de.monticore.types.mcbasictypes.types3.MCBasicTypesTypeVisitor; +import de.monticore.types.mccollectiontypes.types3.MCCollectionTypesTypeVisitor; +import de.monticore.types.mcsimplegenerictypes.types3.MCSimpleGenericTypesTypeVisitor; +import de.monticore.types3.Type4Ast; +import de.monticore.types3.generics.context.InferenceContext4Ast; +import de.monticore.types3.util.*; +import de.monticore.visitor.ITraverser; +import de.se_rwth.commons.logging.Log; + +public class JavaDSLTypeCheck3 extends MapBasedTypeCheck3 { + + public static void init(){ + Log.trace("init JavaDSLTypeCheck3", "TypeCheck setup"); + + // initialize static delegates + BasicSymbolsMill.initializePrimitives(); + OOWithinScopeBasicSymbolsResolver.init(); + OOWithinTypeBasicSymbolsResolver.init(); + TypeContextCalculator.init(); + TypeVisitorOperatorCalculator.init(); + TypeVisitorLifting.init(); + FunctionRelations.init(); + + JavaDSLTraverser traverser = JavaDSLMill.traverser(); + Type4Ast type4Ast = new Type4Ast(); + InferenceContext4Ast ctx4Ast = new InferenceContext4Ast(); + + // Literals + MCJavaLiteralsTypeVisitor visMCJavaLiterals = new MCJavaLiteralsTypeVisitor(); + visMCJavaLiterals.setType4Ast(type4Ast); + traverser.add4MCJavaLiterals(visMCJavaLiterals); + + MCCommonLiteralsTypeVisitor visMCCommonLiterals = new MCCommonLiteralsTypeVisitor(); + visMCCommonLiterals.setType4Ast(type4Ast); + traverser.add4MCCommonLiterals(visMCCommonLiterals); + + + // Expressions + + AssignmentExpressionsCTTIVisitor visAssignmentExpressions = new AssignmentExpressionsCTTIVisitor(); + visAssignmentExpressions.setType4Ast(type4Ast); + visAssignmentExpressions.setContext4Ast(ctx4Ast); + traverser.add4AssignmentExpressions(visAssignmentExpressions); + traverser.setAssignmentExpressionsHandler(visAssignmentExpressions); + + CommonExpressionsCTTIVisitor visCommonExpressions = new CommonExpressionsCTTIVisitor(); + visCommonExpressions.setType4Ast(type4Ast); + visCommonExpressions.setContext4Ast(ctx4Ast); + traverser.add4CommonExpressions(visCommonExpressions); + traverser.setCommonExpressionsHandler(visCommonExpressions); + + ExpressionBasisCTTIVisitor visExpressionBasis = new ExpressionBasisCTTIVisitor(); + visExpressionBasis.setType4Ast(type4Ast); + visExpressionBasis.setContext4Ast(ctx4Ast); + traverser.add4ExpressionsBasis(visExpressionBasis); + traverser.setExpressionsBasisHandler(visExpressionBasis); + + UglyExpressionsCTTIVisitor visUglyExpressions = new UglyExpressionsCTTIVisitor(); + visUglyExpressions.setType4Ast(type4Ast); + visUglyExpressions.setContext4Ast(ctx4Ast); + traverser.add4UglyExpressions(visUglyExpressions); + traverser.setUglyExpressionsHandler(visUglyExpressions); + + // MCTypes + + MCBasicTypesTypeVisitor visMCBasicTypes = new MCBasicTypesTypeVisitor(); + visMCBasicTypes.setType4Ast(type4Ast); + traverser.add4MCBasicTypes(visMCBasicTypes); + + MCCollectionTypesTypeVisitor visMCCollectionTypes = new MCCollectionTypesTypeVisitor(); + visMCCollectionTypes.setType4Ast(type4Ast); + traverser.add4MCCollectionTypes(visMCCollectionTypes); + + MCSimpleGenericTypesTypeVisitor visMCSimpleGenericTypes = new MCSimpleGenericTypesTypeVisitor(); + visMCSimpleGenericTypes.setType4Ast(type4Ast); + traverser.add4MCSimpleGenericTypes(visMCSimpleGenericTypes); + + JavaDSLTypeCheck3 javaDSLTC3 = new JavaDSLTypeCheck3(traverser, type4Ast, ctx4Ast); + javaDSLTC3.setThisAsDelegate(); + } + + public static void reset() { + Log.trace("reset JavaDSLTypeCheck3", "TypeCheck setup"); + JavaDSLTypeCheck3.resetDelegate(); + OOWithinScopeBasicSymbolsResolver.reset(); + OOWithinTypeBasicSymbolsResolver.reset(); + TypeContextCalculator.reset(); + TypeVisitorOperatorCalculator.reset(); + TypeVisitorLifting.reset(); + FunctionRelations.reset(); + } + + protected JavaDSLTypeCheck3(ITraverser typeTraverser, Type4Ast type4Ast, InferenceContext4Ast ctx4Ast){ + super(typeTraverser, type4Ast, ctx4Ast); + } +} From acf065f5284411777937c54727548a6320ada913 Mon Sep 17 00:00:00 2001 From: Janik Rapp Date: Mon, 21 Jul 2025 11:00:48 +0200 Subject: [PATCH 04/61] set artifact name --- .../_symboltable/JavaDSLScopesGenitor.java | 74 +++++++++++++++++-- 1 file changed, 66 insertions(+), 8 deletions(-) diff --git a/javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/JavaDSLScopesGenitor.java b/javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/JavaDSLScopesGenitor.java index 2c435369..a8e7a684 100644 --- a/javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/JavaDSLScopesGenitor.java +++ b/javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/JavaDSLScopesGenitor.java @@ -1,18 +1,19 @@ package de.monticore.java.javadsl._symboltable; -import de.monticore.java.javadsl._ast.ASTCompilationUnit; -import de.monticore.java.javadsl._ast.ASTOrdinaryCompilationUnit; -import de.monticore.java.javadsl._ast.ASTPackageDeclaration; +import de.monticore.java.javadsl.JavaDSLMill; +import de.monticore.java.javadsl._ast.*; +import de.monticore.statements.mccommonstatements._ast.ASTConstantsMCCommonStatements; +import de.monticore.symboltable.ImportStatement; public final class JavaDSLScopesGenitor extends JavaDSLScopesGenitorTOP { - + @Override public IJavaDSLArtifactScope createFromAST(ASTCompilationUnit rootNode) { IJavaDSLArtifactScope artifactScope = super.createFromAST(rootNode); - + if (rootNode instanceof ASTOrdinaryCompilationUnit) { ASTOrdinaryCompilationUnit ordinaryCompilationUnit = (ASTOrdinaryCompilationUnit) rootNode; - + if (ordinaryCompilationUnit.isPresentPackageDeclaration()) { ASTPackageDeclaration packageDeclaration = ordinaryCompilationUnit.getPackageDeclaration(); artifactScope.setPackageName(packageDeclaration.getMCQualifiedName().getQName()); @@ -20,8 +21,65 @@ public IJavaDSLArtifactScope createFromAST(ASTCompilationUnit rootNode) { } // TODO figure out how to map static imports - + return artifactScope; } - + + @Override + public void visit(ASTClassDeclaration node) { + super.visit(node); + if (node.getJavaModifierList().stream() + .anyMatch(x -> x.getModifier() == ASTConstantsMCCommonStatements.PUBLIC)) { + IJavaDSLScope enclosingScope = node.getEnclosingScope(); + if (JavaDSLMill.typeDispatcher().isJavaDSLIJavaDSLArtifactScope(enclosingScope)) { + enclosingScope.setName(node.getName()); + } + } + + } + + @Override + public void visit(ASTRecordDeclaration node) { + super.visit(node); + if (node.getJavaModifierList().stream() + .anyMatch(x -> x.getModifier() == ASTConstantsMCCommonStatements.PUBLIC)) { + IJavaDSLScope enclosingScope = node.getEnclosingScope(); + if (JavaDSLMill.typeDispatcher().isJavaDSLIJavaDSLArtifactScope(enclosingScope)) { + enclosingScope.setName(node.getName()); + } + } + } + + @Override + public void visit(ASTInterfaceDeclaration node) { + super.visit(node); + if (node.getJavaModifierList().stream() + .anyMatch(x -> x.getModifier() == ASTConstantsMCCommonStatements.PUBLIC)) { + IJavaDSLScope enclosingScope = node.getEnclosingScope(); + if (JavaDSLMill.typeDispatcher().isJavaDSLIJavaDSLArtifactScope(enclosingScope)) { + enclosingScope.setName(node.getName()); + } + } + } + + @Override + public void visit(ASTEnumDeclaration node) { + super.visit(node); + if (node.getJavaModifierList().stream() + .anyMatch(x -> x.getModifier() == ASTConstantsMCCommonStatements.PUBLIC)) { + IJavaDSLScope enclosingScope = node.getEnclosingScope(); + if (JavaDSLMill.typeDispatcher().isJavaDSLIJavaDSLArtifactScope(enclosingScope)) { + enclosingScope.setName(node.getName()); + } + } + } + + @Override + public void visit(ASTModuleDeclaration node) { + super.visit(node); + IJavaDSLScope enclosingScope = node.getEnclosingScope(); + if (JavaDSLMill.typeDispatcher().isJavaDSLIJavaDSLArtifactScope(enclosingScope)) { + enclosingScope.setName(node.getName()); + } + } } From b4a92dacfff9d5b7596c9b49eb4ed23a9c4a3987 Mon Sep 17 00:00:00 2001 From: Janik Rapp Date: Mon, 21 Jul 2025 11:01:05 +0200 Subject: [PATCH 05/61] add default import for java.lang --- .../java/javadsl/_symboltable/JavaDSLScopesGenitor.java | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/JavaDSLScopesGenitor.java b/javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/JavaDSLScopesGenitor.java index a8e7a684..ffae94d9 100644 --- a/javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/JavaDSLScopesGenitor.java +++ b/javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/JavaDSLScopesGenitor.java @@ -19,7 +19,10 @@ public IJavaDSLArtifactScope createFromAST(ASTCompilationUnit rootNode) { artifactScope.setPackageName(packageDeclaration.getMCQualifiedName().getQName()); } } - + + // add java.lang import as java imports that package per default + artifactScope.addImports(new ImportStatement("java.lang", true)); + // TODO figure out how to map static imports return artifactScope; From e979fb7cb565a6dca9f5e711f4cd2d872cff711d Mon Sep 17 00:00:00 2001 From: Janik Rapp Date: Mon, 21 Jul 2025 11:16:19 +0200 Subject: [PATCH 06/61] TypeDeclaration symbol cleanup remove additional symbols for all classes extending TypeDeclaration as they get the common TypeDeclarationSymbol --- .../grammars/de/monticore/java/JavaDSL.mc4 | 18 +++++++----------- 1 file changed, 7 insertions(+), 11 deletions(-) diff --git a/javaDSL/src/main/grammars/de/monticore/java/JavaDSL.mc4 b/javaDSL/src/main/grammars/de/monticore/java/JavaDSL.mc4 index a30449f4..69059def 100644 --- a/javaDSL/src/main/grammars/de/monticore/java/JavaDSL.mc4 +++ b/javaDSL/src/main/grammars/de/monticore/java/JavaDSL.mc4 @@ -157,20 +157,16 @@ nokeyword "to"; abstract symbol scope TypeDeclaration implements ClassMemberDeclaration, InterfaceMemberDeclaration, AnnotationTypeElementDeclaration, MCBlockStatement, OOType = Name ; symbolrule TypeDeclaration = - isAnnotation: boolean ; + isAnnotation: boolean + isRecord: boolean; -symbol scope ClassDeclaration extends TypeDeclaration +scope ClassDeclaration extends TypeDeclaration = JavaModifier* "class" Name TypeParameters? ("extends" superClass:MCType)? ("implements" implementedInterface:(MCType || ",")+)? ClassBody ; -symbolrule ClassDeclaration = - superInterface:MCType* - constructor: de.monticore.javalight._symboltable.JavaMethodSymbol* - methods: de.monticore.javalight._symboltable.JavaMethodSymbol* ; - ClassBody = "{" ClassBodyDeclaration* "}" ; @@ -181,7 +177,7 @@ ClassBody * https://docs.oracle.com/javase/specs/jls/se19/html/jls-8.html#jls-8.10 */ -symbol scope RecordDeclaration extends TypeDeclaration +scope RecordDeclaration extends TypeDeclaration = JavaModifier* "record" Name TypeParameters? RecordHeader ("implements" implementedInterface:(MCType || ",")+)? RecordBody @@ -208,7 +204,7 @@ CompactConstructorDeclaration = JavaModifier* Name body:MCJavaBlock ; -symbol scope InterfaceDeclaration extends TypeDeclaration +scope InterfaceDeclaration extends TypeDeclaration = JavaModifier* "interface" Name TypeParameters? ("extends" extendedInterface:(MCType || ",")+)? InterfaceBody @@ -218,7 +214,7 @@ InterfaceBody = "{" InterfaceBodyDeclaration* "}" ; -symbol scope EnumDeclaration extends TypeDeclaration +scope EnumDeclaration extends TypeDeclaration = JavaModifier* "enum" Name ("implements" implementedInterface:(MCType || ",")+)? "{" (EnumConstantDeclaration || ",")* ","? EnumBody? "}" @@ -267,7 +263,7 @@ ArrayInitializer implements VariableInitializer // ANNOTATIONS -symbol scope AnnotationTypeDeclaration extends TypeDeclaration +scope AnnotationTypeDeclaration extends TypeDeclaration = JavaModifier* "@" "interface" Name AnnotationTypeBody ; From 835018df3b61369f8caaf9e8bb8d06edddb48089 Mon Sep 17 00:00:00 2001 From: Janik Rapp Date: Mon, 21 Jul 2025 11:16:48 +0200 Subject: [PATCH 07/61] make EnumConstantDeclaration a Field --- javaDSL/src/main/grammars/de/monticore/java/JavaDSL.mc4 | 6 +----- 1 file changed, 1 insertion(+), 5 deletions(-) diff --git a/javaDSL/src/main/grammars/de/monticore/java/JavaDSL.mc4 b/javaDSL/src/main/grammars/de/monticore/java/JavaDSL.mc4 index 69059def..856e6679 100644 --- a/javaDSL/src/main/grammars/de/monticore/java/JavaDSL.mc4 +++ b/javaDSL/src/main/grammars/de/monticore/java/JavaDSL.mc4 @@ -220,11 +220,7 @@ scope EnumDeclaration extends TypeDeclaration "{" (EnumConstantDeclaration || ",")* ","? EnumBody? "}" ; -symbolrule EnumDeclaration = - constructor: de.monticore.javalight._symboltable.JavaMethodSymbol* - methods: de.monticore.javalight._symboltable.JavaMethodSymbol*; - -symbol EnumConstantDeclaration +symbol EnumConstantDeclaration implements Field = Annotation* Name Arguments? ClassBody? ; From fe52d03b4ffc09880901bc28c42a722282b590c2 Mon Sep 17 00:00:00 2001 From: Janik Rapp Date: Tue, 22 Jul 2025 16:25:27 +0200 Subject: [PATCH 08/61] add more scopes --- .../src/main/grammars/de/monticore/java/JavaDSL.mc4 | 12 +++++++++--- 1 file changed, 9 insertions(+), 3 deletions(-) diff --git a/javaDSL/src/main/grammars/de/monticore/java/JavaDSL.mc4 b/javaDSL/src/main/grammars/de/monticore/java/JavaDSL.mc4 index 856e6679..53444d38 100644 --- a/javaDSL/src/main/grammars/de/monticore/java/JavaDSL.mc4 +++ b/javaDSL/src/main/grammars/de/monticore/java/JavaDSL.mc4 @@ -154,6 +154,7 @@ nokeyword "with"; nokeyword "to"; // Type declarations +// TODO: Remove Java-specific Interfaces, reuse component grammars and use CoCos for validation? abstract symbol scope TypeDeclaration implements ClassMemberDeclaration, InterfaceMemberDeclaration, AnnotationTypeElementDeclaration, MCBlockStatement, OOType = Name ; symbolrule TypeDeclaration = @@ -167,7 +168,8 @@ scope ClassDeclaration extends TypeDeclaration ClassBody ; -ClassBody +// TODO Replace with MCJavaBlock? -> with CoCos? +scope(non_exporting ordered) ClassBody = "{" ClassBodyDeclaration* "}" ; @@ -196,7 +198,8 @@ astrule RecordComponent = return this.isPresentVariableArity(); }; -RecordBody +// TODO Replace with MCJavaBlock? -> with CoCos? +scope(non_exporting ordered) RecordBody = "{" (ClassBodyDeclaration | CompactConstructorDeclaration)* "}" ; @@ -210,7 +213,8 @@ scope InterfaceDeclaration extends TypeDeclaration InterfaceBody ; -InterfaceBody +// TODO Replace with MCJavaBlock? -> with CoCos? +scope(non_exporting ordered) InterfaceBody = "{" InterfaceBodyDeclaration* "}" ; @@ -263,6 +267,7 @@ scope AnnotationTypeDeclaration extends TypeDeclaration = JavaModifier* "@" "interface" Name AnnotationTypeBody ; +// TODO Replace with MCJavaBlock? -> with CoCos? AnnotationTypeBody = "{" (AnnotationTypeElementDeclaration)* "}" ; @@ -308,6 +313,7 @@ MCQualifiedType implements MCObjectType // STATEMENTS / BLOCKS +// TODO: Remove Java-specific Interfaces, reuse component grammars and use CoCos for validation? interface Statement extends MCBlockStatement ; scope JavaBlock implements Statement, MethodBody, ConstructorBody, FinallyBlock From 09926f8ae524c1f61ec2c9d81cdad2f9fa8f6e84 Mon Sep 17 00:00:00 2001 From: Janik Rapp Date: Tue, 22 Jul 2025 16:25:51 +0200 Subject: [PATCH 09/61] fix overridden printWithoutTypeArguments --- javaDSL/src/main/grammars/de/monticore/java/JavaDSL.mc4 | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/javaDSL/src/main/grammars/de/monticore/java/JavaDSL.mc4 b/javaDSL/src/main/grammars/de/monticore/java/JavaDSL.mc4 index 53444d38..f8917048 100644 --- a/javaDSL/src/main/grammars/de/monticore/java/JavaDSL.mc4 +++ b/javaDSL/src/main/grammars/de/monticore/java/JavaDSL.mc4 @@ -306,6 +306,15 @@ MCBasicGenericType implements MCGenericType <20> = (AnnotatedName || ".")+ "<" (MCTypeArgument || ",")* ">" ; +astrule MCBasicGenericType = + method public String printWithoutTypeArguments() { + java.util.List names = new ArrayList<>(); + for(ASTAnnotatedName annotatedName : getAnnotatedNameList()) { + names.add(annotatedName.getName()); + } + return String.join(".", names); + }; + @Override MCQualifiedType implements MCObjectType = (AnnotatedName || ".")+ From bf7e62fab0ffa6042b04991c4af584fc56dedfbf Mon Sep 17 00:00:00 2001 From: Janik Rapp Date: Tue, 22 Jul 2025 16:29:00 +0200 Subject: [PATCH 10/61] add class2mc, pretty print and extended symbol table export options to the JavaDSLTool --- .../java/de/monticore/java/JavaDSLTool.java | 173 ++++++++++++++---- 1 file changed, 133 insertions(+), 40 deletions(-) diff --git a/javaDSL/src/main/java/de/monticore/java/JavaDSLTool.java b/javaDSL/src/main/java/de/monticore/java/JavaDSLTool.java index 1a13475d..42daccee 100644 --- a/javaDSL/src/main/java/de/monticore/java/JavaDSLTool.java +++ b/javaDSL/src/main/java/de/monticore/java/JavaDSLTool.java @@ -11,11 +11,15 @@ import de.monticore.java.java2cd.Java2CDConverter; import de.monticore.java.javadsl.JavaDSLMill; import de.monticore.java.javadsl._ast.ASTCompilationUnit; +import de.monticore.java.javadsl._ast.ASTModularCompilationUnit; +import de.monticore.java.javadsl._ast.ASTOrdinaryCompilationUnit; +import de.monticore.java.javadsl._ast.ASTTypeDeclaration; import de.monticore.java.javadsl._symboltable.IJavaDSLArtifactScope; import de.monticore.java.javadsl._symboltable.JavaDSLScopesGenitorDelegator; import de.monticore.symbols.basicsymbols.BasicSymbolsMill; import de.monticore.symboltable.ImportStatement; import de.se_rwth.commons.Names; +import de.monticore.types.mcbasictypes._ast.ASTMCQualifiedName; import de.se_rwth.commons.logging.Log; import org.apache.commons.cli.*; @@ -24,22 +28,22 @@ import java.nio.file.Files; import java.nio.file.Path; import java.nio.file.Paths; -import java.util.Arrays; -import java.util.Collection; -import java.util.Collections; -import java.util.List; +import java.util.*; import java.util.regex.Pattern; import java.util.stream.Collectors; import java.util.stream.Stream; public class JavaDSLTool extends de.monticore.java.javadsl.JavaDSLTool { - + + + protected static final String SYMBOLS_OUT_DIRECTORY = "target" + File.separator + "symbols"; + + /** * main method of the JavaDSL * * @param args array of the command line arguments */ - public static void main(String[] args) { JavaDSLTool tool = new JavaDSLTool(); tool.run(args); @@ -52,7 +56,6 @@ public static void main(String[] args) { * * @param args array of the command line arguments */ - @Override public void run(String[] args) { Options options = initOptions(); @@ -77,9 +80,37 @@ public void run(String[] args) { BasicSymbolsMill.initializeString(); Log.enableFailQuick(false); - Collection asts = - this.parse(".java", this.createModelPath(cmd).getEntries()); + List asts = + new ArrayList<>(this.parse(".java", this.createModelPath(cmd).getEntries())); Log.enableFailQuick(true); + + if (cmd.hasOption("pp")) { + String[] ppTargets = cmd.getOptionValues("pp"); + if (ppTargets == null || ppTargets.length == 0) { + asts.forEach(ast -> storeSymbolsInFolder(ast, SYMBOLS_OUT_DIRECTORY)); + } + else if (ppTargets.length == 1 && isLikelyFolderPath(cmd.getOptionValue("pp"))) { + asts.forEach( + compUnit -> this.storeSymbolsInFolder(compUnit, cmd.getOptionValue("pp"))); + } + else if (ppTargets.length == asts.size() + && ppTargets.length == cmd.getOptionValues("i").length) { + for (int i = 0; i < asts.size(); i++) { + storeSymbols( + (IJavaDSLArtifactScope) asts.get(i).getEnclosingScope(), + ppTargets[i] + ); + } + } + else { + Log.error(String.format("Received '%s' output files for the prettyprint option. " + + "Expected that '%s' many output files are specified. " + + "If output files for the prettyprint option are specified, then the number " + + "of specified output files must be equal to the number of specified input files, " + + "or one outputfolder should be specified.", + cmd.getOptionValues("pp").length, asts.size())); + } + } if (cmd.hasOption("path")) { String[] paths = splitPathEntries(cmd.getOptionValue("path")); @@ -92,8 +123,32 @@ public void run(String[] args) { .collect(Collectors.toList()); if (cmd.hasOption("s")) { - for (IJavaDSLArtifactScope scope : scopes) { - this.storeSymTab(scope, cmd.getOptionValue("s")); + if (cmd.getOptionValues("s") == null || cmd.getOptionValues("s").length == 0) { + for (ASTCompilationUnit compilationUnit : asts) { + storeSymbolsInFolder(compilationUnit, SYMBOLS_OUT_DIRECTORY); + } + } + else if (cmd.getOptionValues("s").length == 1 && + isLikelyFolderPath(cmd.getOptionValue("s"))) { + asts.forEach( + compUnit -> this.storeSymbolsInFolder(compUnit, cmd.getOptionValue("s"))); + } + else if (cmd.getOptionValues("s").length == asts.size() + && cmd.getOptionValues("s").length == cmd.getOptionValues("i").length) { + for (int i = 0; i < asts.size(); i++) { + storeSymbols( + (IJavaDSLArtifactScope) asts.get(i).getEnclosingScope(), + cmd.getOptionValues("s")[i] + ); + } + } + else { + Log.error(String.format("Received '%s' output files for the storesymbols option. " + + "Expected that '%s' many output files are specified. " + + "If output files for the storesymbols option are specified, then the number " + + "of specified output files must be equal to the number of specified input files, " + + "or one outputfolder should be specified.", + cmd.getOptionValues("s").length, asts.size())); } } @@ -180,11 +235,8 @@ public Options addAdditionalOptions(Options options) { * @return path of all models */ public MCPath createModelPath(CommandLine cmd) { - if (cmd.hasOption("i")) { - return new MCPath(splitPathEntries(cmd.getOptionValues("i"))); - } else { - return new MCPath(); - } + String[] inputPathEntries = cmd.getOptionValues("i"); + return new MCPath(splitPathEntries(inputPathEntries)); } /** @@ -243,38 +295,79 @@ public Collection parse(String fileExt, Path directory) { } return Collections.emptySet(); } - - + /** - * creates the symboltable for the given ast + * Stores the symbols for ast in the specified folder. * - * @param ast the input ast - * @param cmd cli arguments - * @return the symbol-table of the ast + * @param compilationUnit The ast of the SD + * @param folderPath The folder to store the symbols in */ - - public IJavaDSLArtifactScope createSymbolTable(ASTCompilationUnit ast, CommandLine cmd) { - JavaDSLScopesGenitorDelegator genitor = JavaDSLMill.scopesGenitorDelegator(); - IJavaDSLArtifactScope scope = genitor.createFromAST(ast); - if (cmd.hasOption("c2mc")) { - scope.addImports(new ImportStatement("java.lang", true)); - } - return scope; + protected void storeSymbolsInFolder(ASTCompilationUnit compilationUnit, String folderPath) { + String relativeFilePath = getRelativeFilePath(compilationUnit).concat(".javasym"); + Path filePath = Paths.get(folderPath, relativeFilePath); + storeSymbols((IJavaDSLArtifactScope) compilationUnit.getEnclosingScope(), filePath.toString()); } - + /** - * prints the symboltable of the given scope out to a file + * finds the file (without extension) for ast, + * given its package and name. + * E.g.: model with qualified name a.b.c + * "a/b/c" * - * @param scope symboltable to store - * @param path location of the file or directory containing the printed table + * @param compilationUnit The ast of the model */ - public void storeSymTab(IJavaDSLArtifactScope scope, String path) { - if (Path.of(path).toFile().isFile()) { - this.storeSymbols(scope, path); + protected String getRelativeFilePath(ASTCompilationUnit compilationUnit) { + Optional qualifiedName = Optional.empty(); + String artifactName = ""; + if (JavaDSLMill.typeDispatcher().isJavaDSLASTOrdinaryCompilationUnit(compilationUnit)) { + ASTOrdinaryCompilationUnit ast = JavaDSLMill.typeDispatcher().asJavaDSLASTOrdinaryCompilationUnit(compilationUnit); + if (ast.isPresentPackageDeclaration()) { + qualifiedName = Optional.of(ast.getPackageDeclaration().getMCQualifiedName()); + } + if (ast.getTypeDeclarationList().size() == 1) { + artifactName = ast.getTypeDeclarationList().get(0).getName(); + } else { + Optional publicTypeDeclaration = ast.getTypeDeclarationList().stream().filter(x -> x.getSymbol().isIsPublic()).findFirst(); + if (publicTypeDeclaration.isPresent()) { + artifactName = publicTypeDeclaration.get().getName(); + } + } + } else if (JavaDSLMill.typeDispatcher().isJavaDSLASTModularCompilationUnit(compilationUnit)) { + ASTModularCompilationUnit ast = JavaDSLMill.typeDispatcher().asJavaDSLASTModularCompilationUnit(compilationUnit); + qualifiedName = Optional.of(ast.getModuleDeclaration().getMCQualifiedName()); + } + + if (qualifiedName.isPresent()) { + String packagePath = qualifiedName.get().getQName().replace('.', File.separatorChar); + return Paths.get(packagePath, artifactName).toString(); } else { - this.storeSymbols(scope, Paths.get( - path, Names.getPathFromPackage(scope.getFullName()) + ".javasym").toString()); + if (artifactName.isBlank()) { + Log.error("0xTODO: Could not determine symbol table export path. " + + "Make sure that the file contains exactly one public class!"); + } + return Paths.get(artifactName).toString(); } } - + + /** + * heuristic to test if the path seems to be a folder path + * + * @param pathStr the path to check + * @return whether we assume it is a path to a folder + */ + protected boolean isLikelyFolderPath(String pathStr) { + // if it already exists, check: + Path path = Paths.get(pathStr); + File file = path.toFile(); + if (file.exists()) { + return file.isDirectory(); + } + // if it does not exist yet, + // check if the last part ends with an extension + // note that "a/b/.c" is expected to be a folder, + // "a/b/c.d" is not expected to be a folder, + // so we skip the first character + return !path.getFileName().toString().substring(1).contains("."); + } + } From 30e84c96047e7e0dfa0b27c16dd3440ce37273b5 Mon Sep 17 00:00:00 2001 From: Janik Rapp Date: Tue, 22 Jul 2025 16:30:27 +0200 Subject: [PATCH 11/61] add typevisitors for overridden productions --- .../types3/JavaDSLArrayTypesTypeVisitor.java | 13 +++++++++++++ .../JavaDSLSimpleGenericTypesTypeVisitor.java | 13 +++++++++++++ 2 files changed, 26 insertions(+) create mode 100644 javaDSL/src/main/java/de/monticore/java/javadsl/types3/JavaDSLArrayTypesTypeVisitor.java create mode 100644 javaDSL/src/main/java/de/monticore/java/javadsl/types3/JavaDSLSimpleGenericTypesTypeVisitor.java diff --git a/javaDSL/src/main/java/de/monticore/java/javadsl/types3/JavaDSLArrayTypesTypeVisitor.java b/javaDSL/src/main/java/de/monticore/java/javadsl/types3/JavaDSLArrayTypesTypeVisitor.java new file mode 100644 index 00000000..e47bcd14 --- /dev/null +++ b/javaDSL/src/main/java/de/monticore/java/javadsl/types3/JavaDSLArrayTypesTypeVisitor.java @@ -0,0 +1,13 @@ +package de.monticore.java.javadsl.types3; + +import de.monticore.java.javadsl._ast.ASTMCArrayType; +import de.monticore.java.javadsl._visitor.JavaDSLVisitor2; +import de.monticore.types.mcarraytypes.types3.MCArrayTypesTypeVisitor; + +public class JavaDSLArrayTypesTypeVisitor extends MCArrayTypesTypeVisitor implements + JavaDSLVisitor2 { + + public void endVisit(ASTMCArrayType arrayType) { + super.endVisit(arrayType); + } +} diff --git a/javaDSL/src/main/java/de/monticore/java/javadsl/types3/JavaDSLSimpleGenericTypesTypeVisitor.java b/javaDSL/src/main/java/de/monticore/java/javadsl/types3/JavaDSLSimpleGenericTypesTypeVisitor.java new file mode 100644 index 00000000..968c760a --- /dev/null +++ b/javaDSL/src/main/java/de/monticore/java/javadsl/types3/JavaDSLSimpleGenericTypesTypeVisitor.java @@ -0,0 +1,13 @@ +package de.monticore.java.javadsl.types3; + +import de.monticore.java.javadsl._ast.ASTMCBasicGenericType; +import de.monticore.java.javadsl._visitor.JavaDSLVisitor2; +import de.monticore.types.mcsimplegenerictypes.types3.MCSimpleGenericTypesTypeVisitor; + +public class JavaDSLSimpleGenericTypesTypeVisitor extends MCSimpleGenericTypesTypeVisitor implements JavaDSLVisitor2 { + + @Override + public void endVisit(ASTMCBasicGenericType genericType) { + super.endVisit(genericType); + } +} From 17241c07684407657c96b7ad162ed3be7c2b3046 Mon Sep 17 00:00:00 2001 From: Janik Rapp Date: Fri, 25 Jul 2025 14:03:25 +0200 Subject: [PATCH 12/61] fixed scope definitions --- .../grammars/de/monticore/java/JavaDSL.mc4 | 40 ++++++++++++------- 1 file changed, 25 insertions(+), 15 deletions(-) diff --git a/javaDSL/src/main/grammars/de/monticore/java/JavaDSL.mc4 b/javaDSL/src/main/grammars/de/monticore/java/JavaDSL.mc4 index f8917048..f33512bf 100644 --- a/javaDSL/src/main/grammars/de/monticore/java/JavaDSL.mc4 +++ b/javaDSL/src/main/grammars/de/monticore/java/JavaDSL.mc4 @@ -155,13 +155,14 @@ nokeyword "to"; // Type declarations // TODO: Remove Java-specific Interfaces, reuse component grammars and use CoCos for validation? -abstract symbol scope TypeDeclaration implements ClassMemberDeclaration, InterfaceMemberDeclaration, AnnotationTypeElementDeclaration, MCBlockStatement, OOType = Name ; +abstract symbol scope(shadowing) TypeDeclaration implements ClassMemberDeclaration, InterfaceMemberDeclaration, AnnotationTypeElementDeclaration, MCBlockStatement, OOType = Name ; symbolrule TypeDeclaration = isAnnotation: boolean isRecord: boolean; -scope ClassDeclaration extends TypeDeclaration +// TODO: Remove scope duplicate when monticore#4726 is fixed +scope(shadowing) ClassDeclaration extends TypeDeclaration = JavaModifier* "class" Name TypeParameters? ("extends" superClass:MCType)? ("implements" implementedInterface:(MCType || ",")+)? @@ -169,7 +170,7 @@ scope ClassDeclaration extends TypeDeclaration ; // TODO Replace with MCJavaBlock? -> with CoCos? -scope(non_exporting ordered) ClassBody +ClassBody = "{" ClassBodyDeclaration* "}" ; @@ -179,7 +180,8 @@ scope(non_exporting ordered) ClassBody * https://docs.oracle.com/javase/specs/jls/se19/html/jls-8.html#jls-8.10 */ -scope RecordDeclaration extends TypeDeclaration +// TODO: Remove scope duplicate when monticore#4726 is fixed +scope(shadowing) RecordDeclaration extends TypeDeclaration = JavaModifier* "record" Name TypeParameters? RecordHeader ("implements" implementedInterface:(MCType || ",")+)? RecordBody @@ -199,7 +201,7 @@ astrule RecordComponent = }; // TODO Replace with MCJavaBlock? -> with CoCos? -scope(non_exporting ordered) RecordBody +RecordBody = "{" (ClassBodyDeclaration | CompactConstructorDeclaration)* "}" ; @@ -207,24 +209,27 @@ CompactConstructorDeclaration = JavaModifier* Name body:MCJavaBlock ; -scope InterfaceDeclaration extends TypeDeclaration +// TODO: Remove scope duplicate when monticore#4726 is fixed +scope(shadowing) InterfaceDeclaration extends TypeDeclaration = JavaModifier* "interface" Name TypeParameters? ("extends" extendedInterface:(MCType || ",")+)? InterfaceBody ; // TODO Replace with MCJavaBlock? -> with CoCos? -scope(non_exporting ordered) InterfaceBody +InterfaceBody = "{" InterfaceBodyDeclaration* "}" ; -scope EnumDeclaration extends TypeDeclaration +// TODO: Remove scope duplicate when monticore#4726 is fixed +scope(shadowing) EnumDeclaration extends TypeDeclaration = JavaModifier* "enum" Name ("implements" implementedInterface:(MCType || ",")+)? "{" (EnumConstantDeclaration || ",")* ","? EnumBody? "}" ; -symbol EnumConstantDeclaration implements Field +// TODO: Remove scope duplicate when monticore#4726 is fixed +scope(shadowing) symbol EnumConstantDeclaration implements Field = Annotation* Name Arguments? ClassBody? ; @@ -262,22 +267,25 @@ ArrayInitializer implements VariableInitializer ; // ANNOTATIONS - -scope AnnotationTypeDeclaration extends TypeDeclaration +// TODO: Remove scope duplicate when monticore#4726 is fixed +scope(shadowing) AnnotationTypeDeclaration extends TypeDeclaration = JavaModifier* "@" "interface" Name AnnotationTypeBody ; -// TODO Replace with MCJavaBlock? -> with CoCos? +// TODO Replace with MCJavaBlock? -> with CoCos? | Replace with { InterfaceBodyDeclaration } AnnotationTypeBody = "{" (AnnotationTypeElementDeclaration)* "}" ; interface AnnotationTypeElementDeclaration ; -symbol scope AnnotationMethod implements AnnotationTypeElementDeclaration +// TODO Replace with MethodDeclaration? +// TODO: Remove scope duplicate when monticore#4726 is fixed +scope(shadowing non_exporting ordered) AnnotationMethod implements AnnotationTypeElementDeclaration, JavaMethod = JavaModifier* MCType Name "(" ")" DefaultValue? ";" ; +// TODO Replace with ConstDeclaration? AnnotationConstant implements AnnotationTypeElementDeclaration = JavaModifier* MCType (VariableDeclarator || ",")+ ";" ; @@ -325,7 +333,8 @@ MCQualifiedType implements MCObjectType // TODO: Remove Java-specific Interfaces, reuse component grammars and use CoCos for validation? interface Statement extends MCBlockStatement ; -scope JavaBlock implements Statement, MethodBody, ConstructorBody, FinallyBlock +// TODO: Remove scope duplicate when monticore#4726 is fixed +scope(shadowing) JavaBlock implements Statement, MethodBody, ConstructorBody, FinallyBlock = "{" MCBlockStatement* "}" ; @@ -361,6 +370,7 @@ TypeArguments interface FinallyBlock ; +// TODO: Replace with Label from MCLowLevelStatements LabeledStatement implements Statement = label:Name ":" Statement ; @@ -392,7 +402,7 @@ JavaAnnotation extends JavaModifier implements ElementValue ( "(" AnnotationArguments? ")" )? ; -AnonymousClass implements Creator +scope(shadowing) AnonymousClass implements Creator = MCType Arguments ClassBody? ; From 4bdec3c32cc026b693e6b24adc767d16d6c0af3b Mon Sep 17 00:00:00 2001 From: Janik Rapp Date: Fri, 25 Jul 2025 14:04:32 +0200 Subject: [PATCH 13/61] add more type visitors --- .../javadsl/types3/JavaDSLTypeCheck3.java | 17 ++++ .../javadsl/types3/JavaDSLTypeVisitor.java | 85 +++++++++++++++++++ 2 files changed, 102 insertions(+) create mode 100644 javaDSL/src/main/java/de/monticore/java/javadsl/types3/JavaDSLTypeVisitor.java diff --git a/javaDSL/src/main/java/de/monticore/java/javadsl/types3/JavaDSLTypeCheck3.java b/javaDSL/src/main/java/de/monticore/java/javadsl/types3/JavaDSLTypeCheck3.java index bb90b6b2..557a3ee3 100644 --- a/javaDSL/src/main/java/de/monticore/java/javadsl/types3/JavaDSLTypeCheck3.java +++ b/javaDSL/src/main/java/de/monticore/java/javadsl/types3/JavaDSLTypeCheck3.java @@ -11,6 +11,7 @@ import de.monticore.symbols.basicsymbols.BasicSymbolsMill; import de.monticore.types.mcbasictypes.types3.MCBasicTypesTypeVisitor; import de.monticore.types.mccollectiontypes.types3.MCCollectionTypesTypeVisitor; +import de.monticore.types.mcfullgenerictypes.types3.MCFullGenericTypesTypeVisitor; import de.monticore.types.mcsimplegenerictypes.types3.MCSimpleGenericTypesTypeVisitor; import de.monticore.types3.Type4Ast; import de.monticore.types3.generics.context.InferenceContext4Ast; @@ -36,6 +37,18 @@ public static void init(){ Type4Ast type4Ast = new Type4Ast(); InferenceContext4Ast ctx4Ast = new InferenceContext4Ast(); + JavaDSLTypeVisitor visJavaDSL = new JavaDSLTypeVisitor(); + visJavaDSL.setType4Ast(type4Ast); + traverser.add4JavaDSL(visJavaDSL); + + JavaDSLArrayTypesTypeVisitor visJavaDSLArrayTypesType = new JavaDSLArrayTypesTypeVisitor(); + visJavaDSLArrayTypesType.setType4Ast(type4Ast); + traverser.add4JavaDSL(visJavaDSLArrayTypesType); + + JavaDSLSimpleGenericTypesTypeVisitor visSimpleGenericTypesType = new JavaDSLSimpleGenericTypesTypeVisitor(); + visSimpleGenericTypesType.setType4Ast(type4Ast); + traverser.add4JavaDSL(visSimpleGenericTypesType); + // Literals MCJavaLiteralsTypeVisitor visMCJavaLiterals = new MCJavaLiteralsTypeVisitor(); visMCJavaLiterals.setType4Ast(type4Ast); @@ -86,6 +99,10 @@ public static void init(){ visMCSimpleGenericTypes.setType4Ast(type4Ast); traverser.add4MCSimpleGenericTypes(visMCSimpleGenericTypes); + MCFullGenericTypesTypeVisitor visMCFullGenericTypes = new MCFullGenericTypesTypeVisitor(); + visMCFullGenericTypes.setType4Ast(type4Ast); + traverser.add4MCFullGenericTypes(visMCFullGenericTypes); + JavaDSLTypeCheck3 javaDSLTC3 = new JavaDSLTypeCheck3(traverser, type4Ast, ctx4Ast); javaDSLTC3.setThisAsDelegate(); } diff --git a/javaDSL/src/main/java/de/monticore/java/javadsl/types3/JavaDSLTypeVisitor.java b/javaDSL/src/main/java/de/monticore/java/javadsl/types3/JavaDSLTypeVisitor.java new file mode 100644 index 00000000..1dd23f2a --- /dev/null +++ b/javaDSL/src/main/java/de/monticore/java/javadsl/types3/JavaDSLTypeVisitor.java @@ -0,0 +1,85 @@ +package de.monticore.java.javadsl.types3; + +import de.monticore.java.javadsl._ast.ASTAnnotatedName; +import de.monticore.java.javadsl._ast.ASTMCQualifiedType; +import de.monticore.java.javadsl._visitor.JavaDSLVisitor2; +import de.monticore.symbols.basicsymbols._symboltable.IBasicSymbolsScope; +import de.monticore.types.check.SymTypeExpression; +import de.monticore.types.check.SymTypeExpressionFactory; +import de.monticore.types3.AbstractTypeVisitor; +import de.monticore.types3.util.*; +import de.se_rwth.commons.logging.Log; + +import java.util.List; +import java.util.Optional; +import java.util.stream.Collectors; + +public class JavaDSLTypeVisitor extends AbstractTypeVisitor implements JavaDSLVisitor2 { + + @Override + public void endVisit(ASTMCQualifiedType mcQType) { + // adapted from endVisit(ASTMCQualifiedName qName) in MCBasicTypesTypeVisitor + IBasicSymbolsScope enclosingScope = + getAsBasicSymbolsScope(mcQType.getEnclosingScope()); + int numberOfPartsUsedForFirstType = 0; + Optional type = Optional.empty(); + List parts = mcQType.getAnnotatedNameList().stream().map(ASTAnnotatedName::getName).collect(Collectors.toList()); + do { + numberOfPartsUsedForFirstType++; + if (type.isEmpty()) { + String prefix = parts.stream() + .limit(numberOfPartsUsedForFirstType) + .collect(Collectors.joining(".")); + type = OOWithinScopeBasicSymbolsResolver + .resolveType(enclosingScope, prefix); + } + else { + SymTypeExpression prefixType = type.get(); + String name = parts.stream() + .skip(numberOfPartsUsedForFirstType - 1) + .findFirst().get(); + if (prefixType.isObjectType() || prefixType.isGenericType()) { + type = OOWithinTypeBasicSymbolsResolver.resolveType( + prefixType, + name, + TypeContextCalculator.getAccessModifier( + prefixType.getTypeInfo(), + enclosingScope, + false + ), + t -> true + ); + if (type.isEmpty()) { + Log.error("0xFDAE3 unable to find type " + + name + + " within type " + + prefixType.printFullName(), + mcQType.get_SourcePositionStart(), + mcQType.get_SourcePositionEnd() + ); + } + } + else { + Log.error("0xFDA3E unexpected access \"." + + name + + "\" for type " + + prefixType.printFullName(), + mcQType.get_SourcePositionStart(), + mcQType.get_SourcePositionEnd() + ); + } + } + + } while (numberOfPartsUsedForFirstType < mcQType.sizeAnnotatedNames()); + + if (type.isEmpty()) { + Log.error("0xA0324 Cannot find symbol " + mcQType.getAnnotatedNameList().stream().map(ASTAnnotatedName::getName).collect(Collectors.joining(".")), + mcQType.get_SourcePositionStart(), + mcQType.get_SourcePositionEnd() + ); + type = Optional.of(SymTypeExpressionFactory.createObscureType()); + } + + getType4Ast().setTypeOfTypeIdentifier(mcQType, type.get()); + } +} From 19584ef8d81ed8a4d8e7842a1553aff1e6a16067 Mon Sep 17 00:00:00 2001 From: Janik Rapp Date: Fri, 25 Jul 2025 14:05:06 +0200 Subject: [PATCH 14/61] add imports to the artifact scope --- .../java/javadsl/_symboltable/JavaDSLScopesGenitor.java | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/JavaDSLScopesGenitor.java b/javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/JavaDSLScopesGenitor.java index ffae94d9..2eead34d 100644 --- a/javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/JavaDSLScopesGenitor.java +++ b/javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/JavaDSLScopesGenitor.java @@ -18,6 +18,10 @@ public IJavaDSLArtifactScope createFromAST(ASTCompilationUnit rootNode) { ASTPackageDeclaration packageDeclaration = ordinaryCompilationUnit.getPackageDeclaration(); artifactScope.setPackageName(packageDeclaration.getMCQualifiedName().getQName()); } + + for (ASTImportDeclaration importDeclaration : ordinaryCompilationUnit.getImportDeclarationList()) { + artifactScope.addImports(new ImportStatement(importDeclaration.getMCQualifiedName().getQName(), importDeclaration.isSTAR())); + } } // add java.lang import as java imports that package per default From 99344750b3bb2225d9a4cf9c22b39d7f82ed5b9e Mon Sep 17 00:00:00 2001 From: Janik Rapp Date: Fri, 25 Jul 2025 14:05:54 +0200 Subject: [PATCH 15/61] add JavaDSLSymbolTableCompleter --- .../JavaDSLSymbolTableCompleter.java | 244 ++++++++++++++++++ 1 file changed, 244 insertions(+) create mode 100644 javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/JavaDSLSymbolTableCompleter.java diff --git a/javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/JavaDSLSymbolTableCompleter.java b/javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/JavaDSLSymbolTableCompleter.java new file mode 100644 index 00000000..6da8b3b7 --- /dev/null +++ b/javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/JavaDSLSymbolTableCompleter.java @@ -0,0 +1,244 @@ +package de.monticore.java.javadsl._symboltable; + +import de.monticore.java.javadsl.JavaDSLMill; +import de.monticore.java.javadsl._ast.*; +import de.monticore.java.javadsl._visitor.JavaDSLVisitor2; +import de.monticore.javalight._ast.ASTAnnotation; +import de.monticore.javalight._ast.ASTMethodDeclaration; +import de.monticore.javalight._symboltable.JavaMethodSymbol; +import de.monticore.javalight._visitor.JavaLightVisitor2; +import de.monticore.statements.mcarraystatements._ast.ASTArrayDeclaratorId; +import de.monticore.statements.mccommonstatements._ast.ASTConstantsMCCommonStatements; +import de.monticore.statements.mccommonstatements._ast.ASTJavaModifier; +import de.monticore.statements.mcstatementsbasis._ast.ASTMCModifier; +import de.monticore.statements.mcvardeclarationstatements._ast.ASTVariableDeclarator; +import de.monticore.symbols.oosymbols._symboltable.FieldSymbol; +import de.monticore.symbols.oosymbols._symboltable.OOTypeSymbol; +import de.monticore.types.check.SymTypeExpression; +import de.monticore.types.check.SymTypeExpressionFactory; +import de.monticore.types.check.SymTypeOfObject; +import de.monticore.types3.SymTypeRelations; +import de.monticore.types3.TypeCheck3; +import de.se_rwth.commons.logging.Log; + +import java.util.ArrayList; +import java.util.List; +import java.util.Optional; +import java.util.stream.Collectors; + +import static de.monticore.statements.mccommonstatements._ast.ASTConstantsMCCommonStatements.*; +import static de.monticore.statements.mccommonstatements._ast.ASTConstantsMCCommonStatements.ABSTRACT; +import static de.monticore.statements.mccommonstatements._ast.ASTConstantsMCCommonStatements.FINAL; +import static de.monticore.statements.mccommonstatements._ast.ASTConstantsMCCommonStatements.MODIFIER_DEFAULT; +import static de.monticore.statements.mccommonstatements._ast.ASTConstantsMCCommonStatements.NATIVE; +import static de.monticore.statements.mccommonstatements._ast.ASTConstantsMCCommonStatements.STATIC; +import static de.monticore.statements.mccommonstatements._ast.ASTConstantsMCCommonStatements.STRICTFP; +import static de.monticore.statements.mccommonstatements._ast.ASTConstantsMCCommonStatements.SYNCHRONIZED; + +public class JavaDSLSymbolTableCompleter implements JavaDSLVisitor2, JavaLightVisitor2 { + + @Override + public void endVisit(ASTAnnotationTypeDeclaration node) { + TypeDeclarationSymbol symbol = node.getSymbol(); + symbol.setIsAnnotation(true); + + updateModifiers(symbol, node.getJavaModifierList()); + } + + @Override + public void endVisit(ASTEnumDeclaration node) { + TypeDeclarationSymbol symbol = node.getSymbol(); + symbol.setIsEnum(true); + + updateModifiers(symbol, node.getJavaModifierList()); + + List supertypes = + node.getImplementedInterfaceList().stream().map(TypeCheck3::symTypeFromAST) + .collect(Collectors.toList()); + symbol.setSuperTypesList(supertypes); + } + + @Override + public void endVisit(ASTRecordDeclaration node) { + TypeDeclarationSymbol symbol = node.getSymbol(); + + symbol.setIsRecord(true); + + updateModifiers(symbol, node.getJavaModifierList()); + + List supertypes = + node.getImplementedInterfaceList().stream().map(TypeCheck3::symTypeFromAST) + .collect(Collectors.toList()); + symbol.setSuperTypesList(supertypes); + } + + @Override + public void endVisit(ASTEnumConstantDeclaration node) { + EnumConstantDeclarationSymbol symbol = node.getSymbol(); + symbol.setIsStatic(true); + symbol.setIsFinal(true); + symbol.setIsReadOnly(true); + symbol.setIsPublic(true); + + final String enumName = node.getEnclosingScope().getName(); + final Optional enumDeclaration = + node.getEnclosingScope().getEnclosingScope().resolveTypeDeclarationLocally(enumName); + if (enumDeclaration.isPresent()) { + final SymTypeOfObject typeObject = + SymTypeExpressionFactory.createTypeObject(enumDeclaration.get()); + symbol.setType(typeObject); + } + else { + Log.error("0xTODO: Could not resolve enclosing enum declaration", + node.get_SourcePositionStart()); + } + } + + // Temporary fix for missing scope property inheritance + // TODO: Remove when monticore#4729 is fixed + @Override + public void visit(ASTMethodDeclaration node) { + node.getSpannedScope().setShadowing(true); + node.getSpannedScope().setExportingSymbols(false); + node.getSpannedScope().setOrdered(true); + } + + @Override + public void endVisit(ASTClassDeclaration node) { + TypeDeclarationSymbol symbol = node.getSymbol(); + symbol.setIsClass(true); + + updateModifiers(symbol, node.getJavaModifierList()); + + List supertypes = new ArrayList<>(); + if (node.isPresentSuperClass()) { + supertypes.add(TypeCheck3.symTypeFromAST(node.getSuperClass())); + } + supertypes.addAll(node.getImplementedInterfaceList().stream().map(TypeCheck3::symTypeFromAST) + .collect(Collectors.toList())); + symbol.setSuperTypesList(supertypes); + } + + @Override + public void endVisit(ASTFieldDeclaration node) { + for (ASTVariableDeclarator v : node.getVariableDeclaratorList()) { + SymTypeExpression declaratorType = TypeCheck3.symTypeFromAST(node.getMCType()); + if (JavaDSLMill.typeDispatcher().isMCArrayStatementsASTArrayDeclaratorId(v.getDeclarator())) { + ASTArrayDeclaratorId arrayDeclaratorId = JavaDSLMill.typeDispatcher().asMCArrayStatementsASTArrayDeclaratorId(v.getDeclarator()); + declaratorType = SymTypeRelations.normalize(SymTypeExpressionFactory.createTypeArray(declaratorType, arrayDeclaratorId.sizeDim())); + } + v.getDeclarator().getSymbol().setType(declaratorType); + addModifiersToField(v.getDeclarator().getSymbol(), node.getJavaModifierList()); + } + } + + @Override + public void endVisit(ASTAnnotationMethod node) { + // adapted from endVisit(ASTMethodDeclaration) in JavaLightSTCompleteTypes + JavaMethodSymbol symbol = node.getSymbol(); + addModifiersToMethOrConstr(symbol, node.getJavaModifierList()); + symbol.setType(TypeCheck3.symTypeFromAST(node.getMCType())); + } + + protected void addModifiersToField(FieldSymbol fieldSymbol, + Iterable astModifierList) { + for (ASTMCModifier modifier : astModifierList) { + if (modifier instanceof ASTJavaModifier) { + // visibility + switch (((ASTJavaModifier) modifier).getModifier()) { + case PUBLIC: + fieldSymbol.setIsPublic(true); + break; + case PROTECTED: + fieldSymbol.setIsProtected(true); + break; + case PRIVATE: + fieldSymbol.setIsPrivate(true); + // other variable modifiers as in jls7 8.3.1 Field Modifiers + break; + case STATIC: + fieldSymbol.setIsStatic(true); + break; + case FINAL: + fieldSymbol.setIsFinal(true); + break; + default: + break; + } + } else if (modifier instanceof ASTAnnotation) { + ASTAnnotation astAnnotation = (ASTAnnotation) modifier; + //fieldSymbol.addAnnotations(TypeCheck3.symTypeFromAST(astAnnotation.getAnnotationName())); + // TODO: FieldSymbols do not support annotations yet -> annotations are lost + } + } + } + + protected void addModifiersToMethOrConstr(JavaMethodSymbol javaMethodSymbol, + Iterable astModifierList) { + for (ASTMCModifier modifier : astModifierList) { + if (modifier instanceof ASTJavaModifier) { + // visibility + switch (((ASTJavaModifier) modifier).getModifier()) { + case PUBLIC: + javaMethodSymbol.setIsPublic(true); + break; + case PROTECTED: + javaMethodSymbol.setIsProtected(true); + break; + case PRIVATE: + javaMethodSymbol.setIsPrivate(true); + // other variable modifiers as in jls7 8.3.1 Field Modifiers + break; + case ABSTRACT: + javaMethodSymbol.setIsAbstract(true); + break; + case STATIC: + javaMethodSymbol.setIsStatic(true); + break; + case FINAL: + javaMethodSymbol.setIsFinal(true); + break; + case NATIVE: + javaMethodSymbol.setIsNative(true); + break; + case STRICTFP: + javaMethodSymbol.setIsStrictfp(true); + break; + case SYNCHRONIZED: + javaMethodSymbol.setIsSynchronized(true); + break; + case MODIFIER_DEFAULT: + javaMethodSymbol.setIsDefault(true); + default: + break; + } + } else if (modifier instanceof ASTAnnotation) { + ASTAnnotation astAnnotation = (ASTAnnotation) modifier; + javaMethodSymbol.addAnnotations(TypeCheck3.symTypeFromAST(astAnnotation.getAnnotationName())); + } + } + } + + protected void updateModifiers(OOTypeSymbol symbol, List modifiers) { + modifiers.forEach(javaModifier -> { + if (javaModifier.getModifier() == ASTConstantsMCCommonStatements.PUBLIC) { + symbol.setIsPublic(true); + } + else if (javaModifier.getModifier() == ASTConstantsMCCommonStatements.PROTECTED) { + symbol.setIsProtected(true); + } + else if (javaModifier.getModifier() == ASTConstantsMCCommonStatements.PRIVATE) { + symbol.setIsPrivate(true); + } + else if (javaModifier.getModifier() == ASTConstantsMCCommonStatements.ABSTRACT) { + symbol.setIsAbstract(true); + } + else if (javaModifier.getModifier() == ASTConstantsMCCommonStatements.STATIC) { + symbol.setIsStatic(true); + } + else if (javaModifier.getModifier() == ASTConstantsMCCommonStatements.FINAL) { + symbol.setIsFinal(true); + } + }); + } +} From a8f5ec94c685edf87bbb544df037bf11d6230332 Mon Sep 17 00:00:00 2001 From: Janik Rapp Date: Fri, 25 Jul 2025 14:06:22 +0200 Subject: [PATCH 16/61] add JavaDSLSymbolTableUtil --- .../java/de/monticore/java/JavaDSLTool.java | 21 +++--- .../java/utils/JavaDSLSymbolTableUtil.java | 64 +++++++++++++++++++ 2 files changed, 72 insertions(+), 13 deletions(-) create mode 100644 javaDSL/src/main/java/de/monticore/java/utils/JavaDSLSymbolTableUtil.java diff --git a/javaDSL/src/main/java/de/monticore/java/JavaDSLTool.java b/javaDSL/src/main/java/de/monticore/java/JavaDSLTool.java index 42daccee..8fe99e73 100644 --- a/javaDSL/src/main/java/de/monticore/java/JavaDSLTool.java +++ b/javaDSL/src/main/java/de/monticore/java/JavaDSLTool.java @@ -15,10 +15,7 @@ import de.monticore.java.javadsl._ast.ASTOrdinaryCompilationUnit; import de.monticore.java.javadsl._ast.ASTTypeDeclaration; import de.monticore.java.javadsl._symboltable.IJavaDSLArtifactScope; -import de.monticore.java.javadsl._symboltable.JavaDSLScopesGenitorDelegator; -import de.monticore.symbols.basicsymbols.BasicSymbolsMill; -import de.monticore.symboltable.ImportStatement; -import de.se_rwth.commons.Names; +import de.monticore.java.utils.JavaDSLSymbolTableUtil; import de.monticore.types.mcbasictypes._ast.ASTMCQualifiedName; import de.se_rwth.commons.logging.Log; import org.apache.commons.cli.*; @@ -75,9 +72,9 @@ public void run(String[] args) { Log.init(); JavaDSLMill.init(); - - BasicSymbolsMill.initializePrimitives(); - BasicSymbolsMill.initializeString(); + + boolean useClass2MC = cmd.hasOption("c2mc"); + JavaDSLSymbolTableUtil.prepareMill(useClass2MC); Log.enableFailQuick(false); List asts = @@ -116,12 +113,10 @@ else if (ppTargets.length == asts.size() String[] paths = splitPathEntries(cmd.getOptionValue("path")); JavaDSLMill.globalScope().setSymbolPath(new MCPath(paths)); } - - Collection scopes = - asts.stream() - .map(ast -> createSymbolTable(ast, cmd)) - .collect(Collectors.toList()); - + + // Build symbol table and run symbol table completer + asts.forEach(JavaDSLSymbolTableUtil::buildSymbolTable); + if (cmd.hasOption("s")) { if (cmd.getOptionValues("s") == null || cmd.getOptionValues("s").length == 0) { for (ASTCompilationUnit compilationUnit : asts) { diff --git a/javaDSL/src/main/java/de/monticore/java/utils/JavaDSLSymbolTableUtil.java b/javaDSL/src/main/java/de/monticore/java/utils/JavaDSLSymbolTableUtil.java new file mode 100644 index 00000000..97b9067f --- /dev/null +++ b/javaDSL/src/main/java/de/monticore/java/utils/JavaDSLSymbolTableUtil.java @@ -0,0 +1,64 @@ +package de.monticore.java.utils; + +import de.monticore.class2mc.Class2MCResolver; +import de.monticore.expressions.lambdaexpressions._symboltable.LambdaExpressionsSTCompleteTypes2; +import de.monticore.java.javadsl.JavaDSLMill; +import de.monticore.java.javadsl._ast.ASTCompilationUnit; +import de.monticore.java.javadsl._symboltable.IJavaDSLArtifactScope; +import de.monticore.java.javadsl._symboltable.JavaDSLScopesGenitorDelegator; +import de.monticore.java.javadsl._symboltable.JavaDSLSymbolTableCompleter; +import de.monticore.java.javadsl._visitor.JavaDSLTraverser; +import de.monticore.javalight._symboltable.JavaLightSTCompleteTypes; +import de.monticore.statements.mccommonstatements._symboltable.MCCommonStatementsSymTabCompletion; +import de.monticore.statements.mcvardeclarationstatements._symboltable.MCVarDeclarationStatementsSymTabCompletion; +import de.monticore.symbols.basicsymbols.BasicSymbolsMill; +import de.monticore.types.typeparameters._symboltable.TypeParametersSTCompleteTypes; + +public class JavaDSLSymbolTableUtil { + public static void prepareMill(boolean enableC2MC) { + JavaDSLMill.globalScope().clear(); + + BasicSymbolsMill.initializePrimitives(); + + if (enableC2MC) { + Class2MCResolver resolver = new Class2MCResolver(); + JavaDSLMill.globalScope().addAdaptedTypeSymbolResolver(resolver); + } + } + + public static IJavaDSLArtifactScope buildSymbolTable(ASTCompilationUnit ast) { + IJavaDSLArtifactScope as = runSymTabGenitor(ast); + runSymTabCompleter(ast); + return as; + } + + public static IJavaDSLArtifactScope runSymTabGenitor(ASTCompilationUnit ast) { + JavaDSLScopesGenitorDelegator genitor = JavaDSLMill.scopesGenitorDelegator(); + return genitor.createFromAST(ast); + } + + public static void runSymTabCompleter(ASTCompilationUnit ast) { + JavaDSLTraverser traverser = JavaDSLMill.traverser(); + + JavaDSLSymbolTableCompleter javaDslCompleter = new JavaDSLSymbolTableCompleter(); + traverser.add4JavaDSL(javaDslCompleter); + traverser.add4JavaLight(javaDslCompleter); + + JavaLightSTCompleteTypes javaLightSTCompleteTypes = new JavaLightSTCompleteTypes(); + traverser.add4JavaLight(javaLightSTCompleteTypes); + + MCCommonStatementsSymTabCompletion mcCommonStatementsSymTabCompletion = new MCCommonStatementsSymTabCompletion(); + traverser.add4MCCommonStatements(mcCommonStatementsSymTabCompletion); + + LambdaExpressionsSTCompleteTypes2 lambdaExpressionsSTCompleteTypes2 = new LambdaExpressionsSTCompleteTypes2(); + traverser.add4LambdaExpressions(lambdaExpressionsSTCompleteTypes2); + + MCVarDeclarationStatementsSymTabCompletion mcVarDecStmtsSymTabCompletion = new MCVarDeclarationStatementsSymTabCompletion(); + traverser.add4MCVarDeclarationStatements(mcVarDecStmtsSymTabCompletion); + + TypeParametersSTCompleteTypes typeParametersSTCompleteTypes = new TypeParametersSTCompleteTypes(); + traverser.add4TypeParameters(typeParametersSTCompleteTypes); + + ast.accept(traverser); + } +} From 46df2f3840407ef53f62d6790bb068186b1ba9e6 Mon Sep 17 00:00:00 2001 From: Janik Rapp Date: Fri, 25 Jul 2025 14:10:23 +0200 Subject: [PATCH 17/61] add JavaDSLSymbolTableTest The old symbol table tests were removed in 3fe85327d498698bdf38a4afcdc5dddd6a5026d2 with the migration from MontiCore 5.0.6 to 7.4.0 This commit introduces a revamped version of these old tests, adapted to the new version --- .../_symboltable/JavaDSLSymbolTableTest.java | 785 ++++++++++++++++++ .../simpleTestClasses/ExtendsObject.java | 4 +- 2 files changed, 787 insertions(+), 2 deletions(-) create mode 100644 javaDSL/src/test/java/de/monticore/java/_symboltable/JavaDSLSymbolTableTest.java diff --git a/javaDSL/src/test/java/de/monticore/java/_symboltable/JavaDSLSymbolTableTest.java b/javaDSL/src/test/java/de/monticore/java/_symboltable/JavaDSLSymbolTableTest.java new file mode 100644 index 00000000..5bb75aa7 --- /dev/null +++ b/javaDSL/src/test/java/de/monticore/java/_symboltable/JavaDSLSymbolTableTest.java @@ -0,0 +1,785 @@ +package de.monticore.java._symboltable; + +import de.monticore.expressions.uglyexpressions._ast.ASTCreatorExpression; +import de.monticore.java.javadsl.JavaDSLMill; +import de.monticore.java.javadsl._ast.*; +import de.monticore.java.javadsl._symboltable.*; +import de.monticore.java.utils.JavaDSLSymbolTableUtil; +import de.monticore.javalight._ast.ASTConstDeclaration; +import de.monticore.javalight._symboltable.JavaMethodSymbol; +import de.monticore.runtime.junit.TestWithMCLanguage; +import de.monticore.statements.mcvardeclarationstatements._ast.ASTSimpleInit; +import de.monticore.symbols.basicsymbols._symboltable.IBasicSymbolsScope; +import de.monticore.symbols.basicsymbols._symboltable.TypeSymbol; +import de.monticore.symbols.basicsymbols._symboltable.TypeVarSymbol; +import de.monticore.symbols.basicsymbols._symboltable.VariableSymbol; +import de.monticore.symbols.oosymbols._symboltable.FieldSymbol; +import de.monticore.symbols.oosymbols._symboltable.IOOSymbolsScope; +import de.monticore.symbols.oosymbols._symboltable.MethodSymbol; +import de.monticore.symbols.oosymbols._symboltable.OOTypeSymbol; +import de.monticore.symboltable.modifiers.BasicAccessModifier; +import de.monticore.types.check.SymTypeExpression; +import de.monticore.types3.SymTypeRelations; +import org.antlr.v4.runtime.RecognitionException; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Disabled; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; + +import java.io.IOException; +import java.util.*; + +import static de.monticore.java.JavaDSLAssertions.assertParsingSuccess; +import static org.junit.jupiter.api.Assertions.*; + +@TestWithMCLanguage(JavaDSLMill.class) +public class JavaDSLSymbolTableTest { + + @BeforeEach + void setUp() { + JavaDSLSymbolTableUtil.prepareMill(true); + } + + @ParameterizedTest + @ValueSource(strings = { + // Symbol table + "src/test/resources/parsableAndCompilableModels/symbolTable/enums/EnumViaJavaEnum.java", + "src/test/resources/parsableAndCompilableModels/symbolTable/enums/EnumViaJavaInterface.java", + "src/test/resources/parsableAndCompilableModels/symbolTable/resolve/GeneralResolveTestClass.java", + "src/test/resources/parsableAndCompilableModels/symbolTable/resolve/TypeVariableShadowingTestClass.java", + "src/test/resources/parsableAndCompilableModels/symbolTable/typeArgumentsAndParameters/TypeArgumentTestClass.java", + "src/test/resources/parsableAndCompilableModels/symbolTable/typeArgumentsAndParameters/TypeParameterTestClass.java", + "src/test/resources/parsableAndCompilableModels/symbolTable/MethodParametersAndLocalVariablesAreDefinedInSameScope.java", + "src/test/resources/parsableAndCompilableModels/symbolTable/ScopesSymbolTableTestClass.java", + "src/test/resources/parsableAndCompilableModels/symbolTable/VariablesTestClass.java" }) + public void testSymbolTableCreation(String path) { + parseAndCreateST(path); + } + + protected IJavaDSLArtifactScope parseAndCreateST(String path) { + ASTCompilationUnit ast = assertParsingSuccess(path); + return JavaDSLSymbolTableUtil.buildSymbolTable(ast); + } + + // package simpleTestClasses.types.* + @Test + public void test_simpleTestClasses_types_SimpleAnnotationTestModel() + throws RecognitionException, IOException { + IJavaDSLArtifactScope scope = parseAndCreateST( + "src/test/resources/parsableAndCompilableModels/simpleTestClasses/types/SimpleAnnotationTestModel.java"); + + Optional annotationSymbol = + scope.resolveTypeDeclaration("SimpleAnnotationTestModel"); + assertTrue(annotationSymbol.isPresent()); + assertTrue(annotationSymbol.get().isIsAnnotation()); + + assertEquals(1, scope.getSubScopes().size()); + + IJavaDSLScope annotationScope = scope.getSubScopes().get(0); + Optional someMethodSymbol = annotationScope.resolveMethod("someMethod"); + assertTrue(someMethodSymbol.isPresent()); + assertTrue(SymTypeRelations.isStringOrSubType(someMethodSymbol.get().getType())); + + Optional someMethodWithDefaultSymbol = + annotationScope.resolveMethod("someMethodWithDefault"); + assertTrue(someMethodWithDefaultSymbol.isPresent()); + assertTrue(SymTypeRelations.isStringOrSubType(someMethodSymbol.get().getType())); + } + + @Test + public void test_simpleTestClasses_types_SimpleClassTestModel() + throws RecognitionException, IOException { + IJavaDSLArtifactScope scope = parseAndCreateST( + "src/test/resources/parsableAndCompilableModels/simpleTestClasses/types/SimpleClassTestModel.java"); + + Optional classSymbol = scope.resolveTypeLocally("SimpleClassTestModel"); + assertTrue(classSymbol.isPresent()); + assertInstanceOf(ASTClassDeclaration.class, classSymbol.get().getAstNode()); + assertEquals(1, scope.getSubScopes().size()); + IJavaDSLScope classScope = scope.getSubScopes().get(0); + + Optional someFieldSymbol = classScope.resolveField("someField"); + assertTrue(someFieldSymbol.isPresent()); + assertTrue(SymTypeRelations.isInt(someFieldSymbol.get().getType())); + + Optional someMethodSymbol = classScope.resolveMethod("someMethod"); + assertTrue(someMethodSymbol.isPresent()); + assertTrue(someMethodSymbol.get().getFunctionType().getType().isVoidType()); + } + + @Test + public void test_simpleTestClasses_types_SimpleInterfaceTestModel() + throws RecognitionException, IOException { + IJavaDSLArtifactScope scope = parseAndCreateST( + "src/test/resources/parsableAndCompilableModels/simpleTestClasses/types/SimpleInterfaceTestModel.java"); + + assertEquals(1, scope.getSubScopes().size()); + IJavaDSLScope interfaceScope = scope.getSubScopes().get(0); + + Optional const1Symbol = interfaceScope.resolveField("const1"); + assertTrue(const1Symbol.isPresent()); + assertTrue(SymTypeRelations.isStringOrSubType(const1Symbol.get().getType())); + + Optional const2Symbol = interfaceScope.resolveField("const2"); + assertTrue(const2Symbol.isPresent()); + assertTrue(SymTypeRelations.isStringOrSubType(const2Symbol.get().getType())); + + Optional interfaceMethodSymbol = interfaceScope.resolveMethod("interfaceMethod"); + assertTrue(interfaceMethodSymbol.isPresent()); + assertTrue(interfaceMethodSymbol.get().getFunctionType().getType().isVoidType()); + } + + // package simpleTestClasses.* + @Test + public void test_simpleTestClasses_EmptyClass() throws RecognitionException, IOException { + IJavaDSLArtifactScope scope = parseAndCreateST( + "src/test/resources/parsableAndCompilableModels/simpleTestClasses/EmptyClass.java"); + assertEquals(1, scope.getSubScopes().size()); + + IJavaDSLScope classScope = scope.getSubScopes().get(0); + assertEquals(0, classScope.getSubScopes().size()); + // TODO: check + //assertEquals(0, Scopes.getLocalSymbolsAsCollection(classScope).size()); + } + + @Test + public void test_simpleTestClasses_ExtendsObject() throws RecognitionException, IOException { + IJavaDSLArtifactScope scope = parseAndCreateST( + "src/test/resources/parsableAndCompilableModels/simpleTestClasses/ExtendsObject.java"); + assertEquals(2, scope.getSubScopes().size()); + + Optional class1Symbol = scope.resolveType("ExtendsObject"); + assertTrue(class1Symbol.isPresent()); + assertTrue(class1Symbol.get().isPresentSuperClass()); + assertTrue(class1Symbol.get().getSuperClass().isGenericType()); + assertEquals("java.util.ArrayList", + class1Symbol.get().getSuperClass().getTypeInfo().getFullName()); + Optional class2Symbol = scope.resolveType("DoesntExtendObject"); + assertTrue(class2Symbol.isPresent()); + assertFalse(class2Symbol.get().isPresentSuperClass()); + } + + @Test + public void test_simpleTestClasses_ImportJavaLang() throws RecognitionException, IOException { + IJavaDSLArtifactScope scope = parseAndCreateST( + "src/test/resources/parsableAndCompilableModels/simpleTestClasses/ImportJavaLang.java"); + assertEquals(1, scope.getSubScopes().size()); + + IJavaDSLScope classScope = scope.getSubScopes().get(0); + assertEquals(0, classScope.getSymbolsSize()); + assertEquals("java.util.ArrayList", scope.getImportsList().get(0).getStatement()); + assertFalse(scope.getImportsList().get(0).isStar()); + assertEquals("java.lang", scope.getImportsList().get(1).getStatement()); + assertTrue(scope.getImportsList().get(1).isStar()); + } + + @Test + public void test_simpleTestClasses_HelloWorld() throws RecognitionException, IOException { + IJavaDSLArtifactScope scope = parseAndCreateST( + "src/test/resources/parsableAndCompilableModels/simpleTestClasses/HelloWorld.java"); + assertEquals(1, scope.getSubScopes().size()); + IJavaDSLScope classScope = scope.getSubScopes().get(0); + assertEquals(1, classScope.getSubScopes().size()); + IJavaDSLScope methodScope = classScope.getSubScopes().get(0); + assertEquals(1, methodScope.getSymbolsSize()); + + assertEquals(1, methodScope.getLocalFieldSymbols().size()); + FieldSymbol argsSymbol = methodScope.getLocalFieldSymbols().get(0); + + Optional resolvedArgsSymbol = methodScope.resolveField("args"); + assertTrue(resolvedArgsSymbol.isPresent()); + assertEquals(argsSymbol, resolvedArgsSymbol.get()); + assertTrue(resolvedArgsSymbol.get().getType().isArrayType()); + assertEquals(1, resolvedArgsSymbol.get().getType().asArrayType().getDim()); + } + + @Test + public void test_simpleTestClasses_MethodWithEllipsis() throws RecognitionException, IOException { + IJavaDSLArtifactScope scope = parseAndCreateST( + "src/test/resources/parsableAndCompilableModels/simpleTestClasses/MethodWithEllipsis.java"); + assertEquals(1, scope.getSubScopes().size()); + IJavaDSLScope classScope = scope.getSubScopes().get(0); + assertEquals(1, classScope.getSubScopes().size()); + IJavaDSLScope classBodyScope = classScope.getSubScopes().get(0); + assertEquals(1, classBodyScope.getSymbolsSize()); + + Optional methodSymbol = classBodyScope.resolveMethod("m"); + assertTrue(methodSymbol.isPresent()); + assertEquals(1, methodSymbol.get().getParameterList().size()); + assertTrue(methodSymbol.get().isIsElliptic()); + } + + @Test + public void test_simpleTestClasses_OneFieldClass() throws RecognitionException, IOException { + IJavaDSLArtifactScope scope = parseAndCreateST( + "src/test/resources/parsableAndCompilableModels/simpleTestClasses/OneFieldClass.java"); + assertEquals(1, scope.getSubScopes().size()); + IJavaDSLScope classScope = scope.getSubScopes().get(0); + assertEquals(1, classScope.getSymbolsSize()); + + Optional resolvedIntegerSymbol = classScope.resolveField("x"); + assertTrue(resolvedIntegerSymbol.isPresent()); + assertTrue(SymTypeRelations.isInt(resolvedIntegerSymbol.get().getType())); + } + + @Test + public void test_simpleTestClasses_QualifiedNameTestClass() throws RecognitionException { + IJavaDSLArtifactScope scope = parseAndCreateST( + "src/test/resources/parsableAndCompilableModels/simpleTestClasses/QualifiedNameTestClass.java"); + assertEquals(1, scope.getSubScopes().size()); + IJavaDSLScope classScope = scope.getSubScopes().get(0); + assertEquals(5, classScope.getSymbolsSize()); + + Optional symbol = classScope.resolveField("someReference"); + assertTrue(symbol.isPresent()); + assertEquals("QualifiedNameTestClass", symbol.get().getType().print()); + + Optional symbol2 = classScope.resolveField("referenceWithAnInnerClassType"); + assertTrue(symbol2.isPresent()); + assertEquals("InnerClass", symbol2.get().getType().print()); + assertEquals("simpleTestClasses.QualifiedNameTestClass.InnerClass", + symbol2.get().getType().getSourceInfo().getSourceSymbol().get().getFullName()); + + Optional symbol3 = + classScope.resolveField("referenceWithAnInnerClassTypeAndGenericType"); + assertTrue(symbol3.isPresent()); + assertEquals("simpleTestClasses.QualifiedNameTestClass.GenericInnerClass", + symbol3.get().getType().getTypeInfo().getFullName()); + assertTrue(symbol3.get().getType().isGenericType()); + assertEquals(1, symbol3.get().getType().asGenericType().sizeArguments()); + assertTrue(symbol3.get().getType().asGenericType().getArgument(0).isObjectType()); + assertEquals("simpleTestClasses.QualifiedNameTestClass.InnerClass", + symbol3.get().getType().asGenericType().getArgument(0).getTypeInfo().getFullName()); + } + + @Test + public void test_symbolTable_enums_EnumViaJavaEnum() { + IJavaDSLArtifactScope scope = parseAndCreateST( + "src/test/resources/parsableAndCompilableModels/symbolTable/enums/EnumViaJavaEnum.java"); + Optional enumViaJavaEnumSymbol = scope.resolveOOType("EnumViaJavaEnum"); + assertTrue(enumViaJavaEnumSymbol.isPresent()); + + IOOSymbolsScope enumViaJavaEnumSymbolScope = enumViaJavaEnumSymbol.get().getSpannedScope(); + assertEquals(3, enumViaJavaEnumSymbolScope.getSubScopes().size()); + assertEquals(3, enumViaJavaEnumSymbolScope.getSymbolsSize()); + + Optional constant1Symbol = enumViaJavaEnumSymbolScope.resolveField("CONSTANT1"); + assertTrue(constant1Symbol.isPresent()); + assertInstanceOf(ASTEnumConstantDeclaration.class, constant1Symbol.get().getAstNode()); + ASTEnumConstantDeclaration constant1Declaration = + (ASTEnumConstantDeclaration) constant1Symbol.get().getAstNode(); + + IBasicSymbolsScope constant1ClassScope = constant1Declaration.getSpannedScope(); + assertEquals(1, constant1ClassScope.getSymbolsSize()); + + Optional constant2Symbol = enumViaJavaEnumSymbolScope.resolveField("CONSTANT2"); + assertTrue(constant2Symbol.isPresent()); + ASTEnumConstantDeclaration constant2Declaration = + (ASTEnumConstantDeclaration) constant2Symbol.get().getAstNode(); + IBasicSymbolsScope constant2ClassScope = constant2Declaration.getSpannedScope(); + assertEquals(1, constant2ClassScope.getSymbolsSize()); + Optional methodSymbol = enumViaJavaEnumSymbolScope.resolveMethod("method"); + assertTrue(methodSymbol.isPresent()); + } + + @Test + public void test_symbolTable_enums_EnumViaJavaInterface() throws RecognitionException { + IJavaDSLArtifactScope scope = parseAndCreateST( + "src/test/resources/parsableAndCompilableModels/symbolTable/enums/EnumViaJavaInterface.java"); + Optional enumViaJavaInterfaceSymbol = scope.resolveType("EnumViaJavaInterface"); + assertTrue(enumViaJavaInterfaceSymbol.isPresent()); + assertInstanceOf(JavaDSLScope.class, enumViaJavaInterfaceSymbol.get().getSpannedScope()); + IJavaDSLScope interfaceScope = + (IJavaDSLScope) enumViaJavaInterfaceSymbol.get().getSpannedScope(); + assertEquals(3, interfaceScope.getSubScopes().size()); + + Optional constant1Symbol = interfaceScope.resolveField("CONSTANT1"); + assertTrue(constant1Symbol.isPresent()); + Optional constant2Symbol = interfaceScope.resolveField("CONSTANT2"); + assertTrue(constant2Symbol.isPresent()); + Optional methodSymbol = interfaceScope.resolveMethod("method"); + assertTrue(methodSymbol.isPresent()); + Collection methodSymbols = interfaceScope.resolveMethodMany("method"); + assertEquals(1, methodSymbols.size()); + + ASTInterfaceBody interfaceBody = + ((ASTInterfaceDeclaration) interfaceScope.getAstNode()).getInterfaceBody(); + ASTConstDeclaration constant1Decl = + (ASTConstDeclaration) interfaceBody.getInterfaceBodyDeclaration(0); + ASTSimpleInit constant1Init = + (ASTSimpleInit) constant1Decl.getLocalVariableDeclaration().getVariableDeclarator(0) + .getVariableInit(); + ASTAnonymousClass constant1Class = + (ASTAnonymousClass) ((ASTCreatorExpression) constant1Init.getExpression()).getCreator(); + IJavaDSLScope constant1ClassScope = constant1Class.getSpannedScope(); + Optional constant1MethodSymbol = constant1ClassScope.resolveMethod("method"); + assertTrue(constant1MethodSymbol.isPresent()); + assertNotEquals(methodSymbol, constant1MethodSymbol.get()); + } + + @Test //TODO: was disabled + public void test_symbolTable_resolve_GeneralResolveTestClass() + throws RecognitionException, IOException { + // There should be four scopes (not counting global scope) + IJavaDSLArtifactScope scope = parseAndCreateST( + "src/test/resources/parsableAndCompilableModels/symbolTable/resolve/GeneralResolveTestClass.java"); + IJavaDSLScope superClassScope = scope.getSubScopes().get(0); + assertEquals("SuperClass", superClassScope.getSpanningSymbol().getName()); + IJavaDSLScope classScope = scope.getSubScopes().get(1); + assertEquals("GeneralResolveTestClass", classScope.getSpanningSymbol().getName()); + IJavaDSLScope typeVariableScope = classScope.getSubScopes().get(0); + assertEquals("TYPE_VARIABLE", typeVariableScope.getSpanningSymbol().getName()); + + // resolve tests + // resolve: TYPE_VARIABLE + Optional typeVariableSymbol = classScope.resolveType("TYPE_VARIABLE"); + assertTrue(typeVariableSymbol.isPresent()); + assertEquals(typeVariableSymbol.get().getEnclosingScope(), classScope); + assertEquals("TYPE_VARIABLE", typeVariableSymbol.get().getName()); + + // resolve: x + Optional integerAttribute = classScope.resolveField("x"); + assertTrue(integerAttribute.isPresent()); + assertEquals(integerAttribute.get().getEnclosingScope(), classScope); + + // resolve: someReference + Optional someReferenceSymbol = classScope.resolveField("someReference"); + assertTrue(someReferenceSymbol.isPresent()); + assertEquals(someReferenceSymbol.get().getEnclosingScope(), classScope); + assertTrue(someReferenceSymbol.get().getType().isTypeVariable()); + assertEquals("symbolTable.resolve.GeneralResolveTestClass.TYPE_VARIABLE", + someReferenceSymbol.get().getType().asTypeVariable().getTypeVarSymbol().getFullName()); + + // resolve: GeneralResolveTestClass + Optional constructorSymbol = classScope.resolveMethod("GeneralResolveTestClass"); + assertTrue(constructorSymbol.isPresent()); + assertEquals(constructorSymbol.get().getEnclosingScope(), classScope); + Optional initialXSymbol = + constructorSymbol.get().getSpannedScope().resolveField("initialX"); + assertTrue(initialXSymbol.isPresent()); + assertTrue(SymTypeRelations.isInt(initialXSymbol.get().getType())); + + // resolve: variableShadowingMethod + Optional variableShadowingMethodSymbol = + classScope.resolveMethod("variableShadowingMethod"); + assertTrue(variableShadowingMethodSymbol.isPresent()); + assertEquals(variableShadowingMethodSymbol.get().getEnclosingScope(), classScope); + assertEquals(1, variableShadowingMethodSymbol.get().getSpannedScope().getSubScopes().size()); + Optional shadowingXSymbol = + variableShadowingMethodSymbol.get().getSpannedScope().getSubScopes().get(0) + .resolveField("x"); + assertTrue(shadowingXSymbol.isPresent()); + assertTrue(SymTypeRelations.isStringOrSubType(shadowingXSymbol.get().getType())); + assertEquals(variableShadowingMethodSymbol.get().getSpannedScope(), + shadowingXSymbol.get().getEnclosingScope().getEnclosingScope()); + + // resolve: privateSuperMethod + Optional optionalPrivateSuperMethod = + classScope.resolveMethod("privateSuperMethod", BasicAccessModifier.PROTECTED); + assertFalse(optionalPrivateSuperMethod.isPresent()); + + // resolve: protectedSuperMethod + Optional protectedSuperMethod = + classScope.resolveMethod("protectedSuperMethod", BasicAccessModifier.PROTECTED); + assertTrue(protectedSuperMethod.isPresent()); + } + + @Test + public void test_symbolTable_resolve_TypeVariableShadowingTestClass() + throws RecognitionException, IOException { + // There should be nine scopes (not counting global scope) + IJavaDSLArtifactScope scope = parseAndCreateST( + "src/test/resources/parsableAndCompilableModels/symbolTable/resolve/TypeVariableShadowingTestClass.java"); + IJavaDSLScope outerMostTClassScope = scope.getSubScopes().get(0); + assertEquals("symbolTable.resolve.T", outerMostTClassScope.getSpanningSymbol().getFullName()); + + IJavaDSLScope typeVariableShadowingTestClassScope = scope.getSubScopes().get(1); + assertEquals("symbolTable.resolve.TypeVariableShadowingTestClass", + typeVariableShadowingTestClassScope.getSpanningSymbol().getFullName()); + Collection symbols = typeVariableShadowingTestClassScope.resolveTypeMany("T"); + assertEquals(2, symbols.size()); + Iterator iterator = symbols.iterator(); + TypeSymbol symbol1 = iterator.next(); + assertEquals("symbolTable.resolve.TypeVariableShadowingTestClass.T", symbol1.getFullName()); + TypeSymbol symbol2 = iterator.next(); + assertEquals("symbolTable.resolve.TypeVariableShadowingTestClass.T", symbol2.getFullName()); + assertNotEquals(symbol1, symbol2); + + Optional classTInstanceSymbol = + typeVariableShadowingTestClassScope.resolveField("thisIsAnInstanceOfTheInnerClassT"); + assertTrue(classTInstanceSymbol.isPresent()); + assertTrue(classTInstanceSymbol.get().getType().isTypeVariable()); + assertEquals("symbolTable.resolve.TypeVariableShadowingTestClass.T", + classTInstanceSymbol.get().getType().getTypeInfo().getFullName()); + } + + // package symbolTable.typeArgumentsAndParameters.* + @Test + public void test_symbolTable_typeArgumentsAndParameters_TypeArgumentTestClass() + throws RecognitionException, IOException { + IJavaDSLArtifactScope artifactScope = parseAndCreateST( + "src/test/resources/parsableAndCompilableModels/symbolTable/typeArgumentsAndParameters/TypeArgumentTestClass.java"); + IJavaDSLScope globalScope = artifactScope.getEnclosingScope(); + IJavaDSLScope scope = globalScope.getSubScopes().get(0); + IJavaDSLScope classScope = scope.getSubScopes().get(0); + assertEquals(12, classScope.getSymbolsSize()); + + List typeVarSymbols = classScope.getTypeVarSymbols().values(); + assertEquals(1, typeVarSymbols.size()); + + List fieldSymbols = classScope.getFieldSymbols().values(); + assertEquals(11, fieldSymbols.size()); + + FieldSymbol wildcardOnlySymbol = fieldSymbols.get(0); + Optional symbol = classScope.resolveField("wildcardOnly"); + assertTrue(symbol.isPresent()); + assertEquals(wildcardOnlySymbol, symbol.get()); + assertTrue(wildcardOnlySymbol.getType().isGenericType()); + assertTrue(wildcardOnlySymbol.getType().asGenericType().getArgument(0).isWildcard()); + + FieldSymbol typeVariableOnlySymbol = fieldSymbols.get(1); + Optional symbol2 = classScope.resolveField("typeVariableOnly"); + assertTrue(symbol2.isPresent()); + assertEquals(typeVariableOnlySymbol, symbol2.get()); + SymTypeExpression type2 = typeVariableOnlySymbol.getType(); + assertTrue(type2.isGenericType()); + assertEquals(1, type2.asGenericType().sizeArguments()); + assertFalse(type2.asGenericType().getArgument(0).isWildcard()); + assertEquals("symbolTable.typeArgumentsAndParameters.TypeArgumentTestClass.T", + type2.asGenericType().getArgument(0).getTypeInfo().getFullName()); + + FieldSymbol superTypeVariableSymbol = fieldSymbols.get(2); + Optional symbol3 = classScope.resolveField("superTypeVariable"); + assertTrue(symbol3.isPresent()); + assertEquals(superTypeVariableSymbol, symbol3.get()); + SymTypeExpression type3 = superTypeVariableSymbol.getType(); + assertTrue(type3.isGenericType()); + assertEquals(1, type3.asGenericType().sizeArguments()); + assertTrue(type3.asGenericType().getArgument(0).isWildcard()); + assertFalse(type3.asGenericType().getArgument(0).asWildcard().isUpper()); + assertEquals("symbolTable.typeArgumentsAndParameters.TypeArgumentTestClass.T", + type3.asGenericType().getArgument(0).asWildcard().getBound().getTypeInfo().getFullName()); + + FieldSymbol extendsTypeVariableSymbol = fieldSymbols.get(3); + Optional symbol4 = classScope.resolveField("extendsTypeVariable"); + assertTrue(symbol4.isPresent()); + assertEquals(extendsTypeVariableSymbol, symbol4.get()); + SymTypeExpression type4 = extendsTypeVariableSymbol.getType(); + assertTrue(type4.isGenericType()); + assertEquals(1, type4.asGenericType().sizeArguments()); + assertTrue(type4.asGenericType().getArgument(0).isWildcard()); + assertTrue(type4.asGenericType().getArgument(0).asWildcard().isUpper()); + assertEquals("symbolTable.typeArgumentsAndParameters.TypeArgumentTestClass.T", + type4.asGenericType().getArgument(0).asWildcard().getBound().getTypeInfo().getFullName()); + + FieldSymbol superReferenceTypeSymbol = fieldSymbols.get(4); + Optional symbol5 = classScope.resolveField("superReferenceType"); + assertTrue(symbol5.isPresent()); + assertEquals(superReferenceTypeSymbol, symbol5.get()); + SymTypeExpression type5 = superReferenceTypeSymbol.getType(); + assertTrue(type5.isGenericType()); + assertEquals(1, type5.asGenericType().sizeArguments()); + assertTrue(type5.asGenericType().getArgument(0).isWildcard()); + assertFalse(type5.asGenericType().getArgument(0).asWildcard().isUpper()); + assertEquals("java.lang.String", + type5.asGenericType().getArgument(0).asWildcard().getBound().getTypeInfo().getFullName()); + + FieldSymbol extendsReferenceTypeSymbol = fieldSymbols.get(5); + Optional symbol6 = classScope.resolveField("extendsReferenceType"); + assertTrue(symbol6.isPresent()); + assertEquals(extendsReferenceTypeSymbol, symbol6.get()); + SymTypeExpression type6 = extendsReferenceTypeSymbol.getType(); + assertTrue(type6.isGenericType()); + assertEquals(1, type6.asGenericType().sizeArguments()); + assertTrue(type6.asGenericType().getArgument(0).isWildcard()); + assertTrue(type6.asGenericType().getArgument(0).asWildcard().isUpper()); + assertEquals("java.lang.String", + type6.asGenericType().getArgument(0).asWildcard().getBound().getTypeInfo().getFullName()); + + FieldSymbol superIntegerArrayTypeSymbol = fieldSymbols.get(6); + Optional symbol7 = classScope.resolveField("superIntegerArrayType"); + assertTrue(symbol7.isPresent()); + assertEquals(superIntegerArrayTypeSymbol, symbol7.get()); + SymTypeExpression type7 = superIntegerArrayTypeSymbol.getType(); + assertTrue(type7.isGenericType()); + assertEquals(1, type7.asGenericType().sizeArguments()); + assertTrue(type7.asGenericType().getArgument(0).isWildcard()); + assertFalse(type7.asGenericType().getArgument(0).asWildcard().isUpper()); + assertTrue(type7.asGenericType().getArgument(0).asWildcard().getBound().isArrayType()); + assertEquals("java.lang.Integer", + type7.asGenericType().getArgument(0).asWildcard().getBound().asArrayType().getArgument() + .getTypeInfo().getFullName()); + assertEquals(1, + type7.asGenericType().getArgument(0).asWildcard().getBound().asArrayType().getDim()); + + FieldSymbol extendsIntegerArrayTypeSymbol = fieldSymbols.get(7); + Optional symbol8 = classScope.resolveField("extendsIntegerArrayType"); + assertTrue(symbol8.isPresent()); + assertEquals(extendsIntegerArrayTypeSymbol, symbol8.get()); + SymTypeExpression type8 = extendsIntegerArrayTypeSymbol.getType(); + assertTrue(type8.isGenericType()); + assertEquals(1, type8.asGenericType().sizeArguments()); + assertTrue(type8.asGenericType().getArgument(0).isWildcard()); + assertTrue(type8.asGenericType().getArgument(0).asWildcard().isUpper()); + assertTrue(type8.asGenericType().getArgument(0).asWildcard().getBound().isArrayType()); + assertEquals("java.lang.Integer", + type8.asGenericType().getArgument(0).asWildcard().getBound().asArrayType().getArgument() + .getTypeInfo().getFullName()); + assertEquals(1, + type8.asGenericType().getArgument(0).asWildcard().getBound().asArrayType().getDim()); + + FieldSymbol superIntArrayTypeSymbol = fieldSymbols.get(8); + Optional symbol9 = classScope.resolveField("superIntArrayType"); + assertTrue(symbol9.isPresent()); + assertEquals(superIntArrayTypeSymbol, symbol9.get()); + SymTypeExpression type9 = superIntArrayTypeSymbol.getType(); + assertTrue(type9.isGenericType()); + assertEquals(1, type9.asGenericType().sizeArguments()); + assertTrue(type9.asGenericType().getArgument(0).isWildcard()); + assertFalse(type9.asGenericType().getArgument(0).asWildcard().isUpper()); + assertTrue(type9.asGenericType().getArgument(0).asWildcard().getBound().isArrayType()); + assertTrue(SymTypeRelations.isInt( + type9.asGenericType().getArgument(0).asWildcard().getBound().asArrayType().getArgument())); + assertEquals(1, + type9.asGenericType().getArgument(0).asWildcard().getBound().asArrayType().getDim()); + + FieldSymbol extendsIntArrayTypeSymbol = fieldSymbols.get(9); + Optional symbol10 = classScope.resolveField("extendsIntArrayType"); + assertTrue(symbol10.isPresent()); + assertEquals(extendsIntArrayTypeSymbol, symbol10.get()); + SymTypeExpression type10 = extendsIntArrayTypeSymbol.getType(); + assertTrue(type10.isGenericType()); + assertEquals(1, type10.asGenericType().sizeArguments()); + assertTrue(type10.asGenericType().getArgument(0).isWildcard()); + assertTrue(type10.asGenericType().getArgument(0).asWildcard().isUpper()); + assertTrue(type10.asGenericType().getArgument(0).asWildcard().getBound().isArrayType()); + assertTrue(SymTypeRelations.isInt( + type10.asGenericType().getArgument(0).asWildcard().getBound().asArrayType().getArgument())); + assertEquals(1, + type10.asGenericType().getArgument(0).asWildcard().getBound().asArrayType().getDim()); + + FieldSymbol multipleAndRecursiveTypeArgumentsSymbol = fieldSymbols.get(10); + Optional symbol11 = classScope.resolveField("multipleAndRecursiveTypeArguments"); + assertTrue(symbol11.isPresent()); + assertEquals(multipleAndRecursiveTypeArgumentsSymbol, symbol11.get()); + SymTypeExpression type11 = multipleAndRecursiveTypeArgumentsSymbol.getType(); + assertTrue(type11.isGenericType()); + assertEquals(2, type11.asGenericType().sizeArguments()); + assertTrue(type11.asGenericType().getArgument(0).isGenericType()); + assertEquals("java.util.Collection", + type11.asGenericType().getArgument(0).asGenericType().getTypeInfo().getFullName()); + assertTrue(type11.asGenericType().getArgument(0).asGenericType().getArgument(0).isWildcard()); + assertFalse(type11.asGenericType().getArgument(0).asGenericType().getArgument(0).asWildcard() + .isUpper()); + + assertTrue(type11.asGenericType().getArgument(1).isGenericType()); + assertEquals("java.util.Set", + type11.asGenericType().getArgument(1).asGenericType().getTypeInfo().getFullName()); + assertTrue(type11.asGenericType().getArgument(1).asGenericType().getArgument(0).isWildcard()); + assertFalse(type11.asGenericType().getArgument(1).asGenericType().getArgument(0).asWildcard() + .isUpper()); + } + + @Test + @Disabled + public void test_symbolTable_typeArgumentsAndParameters_TypeParameterTestClass() + throws RecognitionException, IOException { + IJavaDSLArtifactScope scope = parseAndCreateST( + "src/test/resources/parsableAndCompilableModels/symbolTable/typeArgumentsAndParameters/TypeParameterTestClass"); + + Optional resolve = scope.resolveType("TypeParameterTestClass"); + assertTrue(resolve.isPresent()); + IJavaDSLScope classScope = scope.getSubScopes().get(0); + // TODO + } + + // package symbolTable.* + @Test + public void test_symbolTable_ScopesSymbolTableTestClass() + throws RecognitionException, IOException { + IJavaDSLArtifactScope scope = parseAndCreateST( + "src/test/resources/parsableAndCompilableModels/symbolTable/ScopesSymbolTableTestClass.java"); + assertEquals(3, scope.getSubScopes().size()); + IJavaDSLScope someInterfaceScope = scope.getSubScopes().get(0); + assertEquals(0, someInterfaceScope.getSymbolsSize()); + IJavaDSLScope someReturnTypeScope = scope.getSubScopes().get(1); + assertEquals(0, someReturnTypeScope.getSymbolsSize()); + IJavaDSLScope generalSymbolTableTestClassScope = scope.getSubScopes().get(2); + assertEquals(3, generalSymbolTableTestClassScope.getSymbolsSize()); + IJavaDSLScope classInitializerScope = generalSymbolTableTestClassScope.getSubScopes().get(0); + assertEquals(1, classInitializerScope.getSymbolsSize()); + + Optional resolvedClassField = + generalSymbolTableTestClassScope.resolveField("field"); + assertTrue(resolvedClassField.isPresent()); + assertEquals(generalSymbolTableTestClassScope.getFieldSymbols().values().get(0), + resolvedClassField.get()); + + Optional resolvedInitializerField = classInitializerScope.resolveField("field"); + assertTrue(resolvedInitializerField.isPresent()); + assertEquals(classInitializerScope.getFieldSymbols().values().get(0), + resolvedInitializerField.get()); + + assertNotEquals(resolvedClassField.get(), resolvedInitializerField.get()); + } + + @Test + public void test_symbolTable_VariablesTestClass() throws RecognitionException, IOException { + IJavaDSLArtifactScope scope = parseAndCreateST( + "src/test/resources/parsableAndCompilableModels/symbolTable/VariablesTestClass.java"); + assertEquals(2, scope.getSubScopes().size()); + IJavaDSLScope classScope = scope.getSubScopes().get(0); + + Optional publicValueSymbol = classScope.resolveField("publicValue"); + assertTrue(publicValueSymbol.isPresent()); + assertTrue(publicValueSymbol.get().isIsPublic()); + assertFalse(publicValueSymbol.get().isIsProtected()); + assertFalse(publicValueSymbol.get().isIsPrivate()); + + Optional protectedValueSymbol = classScope.resolveField("protectedValue"); + assertTrue(protectedValueSymbol.isPresent()); + assertFalse(protectedValueSymbol.get().isIsPublic()); + assertTrue(protectedValueSymbol.get().isIsProtected()); + assertFalse(protectedValueSymbol.get().isIsPrivate()); + + Optional privateValueSymbol = classScope.resolveField("privateValue"); + assertTrue(privateValueSymbol.isPresent()); + assertFalse(privateValueSymbol.get().isIsPublic()); + assertFalse(privateValueSymbol.get().isIsProtected()); + assertTrue(privateValueSymbol.get().isIsPrivate()); + + Optional staticValueSymbol = classScope.resolveField("staticValue"); + assertTrue(staticValueSymbol.isPresent()); + assertTrue(staticValueSymbol.get().isIsStatic()); + + Optional finalValueSymbol = classScope.resolveField("finalValue"); + assertTrue(finalValueSymbol.isPresent()); + assertTrue(finalValueSymbol.get().isIsFinal()); + + // various primitive types and primitive array combination (leading/trailing + // array brackets) + + Optional symbol = classScope.resolveField("integerValue"); + assertTrue(symbol.isPresent()); + assertTrue(SymTypeRelations.isInt(symbol.get().getType())); + + Optional symbol2 = classScope.resolveField("integerArray"); + assertTrue(symbol2.isPresent()); + assertTrue(symbol2.get().getType().isArrayType()); + assertTrue(SymTypeRelations.isInt(symbol2.get().getType().asArrayType().getArgument())); + assertEquals(1, symbol2.get().getType().asArrayType().getDim()); + + Optional symbol3 = classScope.resolveField("integerArrayWithTrailingBrackets"); + assertTrue(symbol3.isPresent()); + assertTrue(symbol3.get().getType().isArrayType()); + assertTrue(SymTypeRelations.isInt(symbol3.get().getType().asArrayType().getArgument())); + assertEquals(1, symbol3.get().getType().asArrayType().getDim()); + + Optional symbol4 = + classScope.resolveField("integerMatrixWithLeadingAndTrailingBrackets"); + assertTrue(symbol4.isPresent()); + assertTrue(symbol4.get().getType().isArrayType()); + assertTrue(SymTypeRelations.isInt(symbol4.get().getType().asArrayType().getArgument())); + assertEquals(2, symbol4.get().getType().asArrayType().getDim()); + + // various reference types and complex array combination (leading/trailing + // array brackets) + + Optional symbol5 = classScope.resolveField("someReference"); + assertTrue(symbol5.isPresent()); + assertTrue(symbol5.get().getType().isObjectType()); + assertEquals("symbolTable.VariablesTestClass", + symbol5.get().getType().asObjectType().getTypeInfo().getFullName()); + + Optional symbol6 = classScope.resolveField("someReferenceArray"); + assertTrue(symbol6.isPresent()); + assertTrue(symbol6.get().getType().isArrayType()); + assertTrue(symbol6.get().getType().asArrayType().getArgument().isObjectType()); + assertEquals("symbolTable.VariablesTestClass", + symbol6.get().getType().asArrayType().getArgument().asObjectType().getTypeInfo() + .getFullName()); + assertEquals(1, symbol6.get().getType().asArrayType().getDim()); + + Optional symbol7 = + classScope.resolveField("someReferenceArrayWithTrailingBrackets"); + assertTrue(symbol7.isPresent()); + assertTrue(symbol7.get().getType().isArrayType()); + assertTrue(symbol7.get().getType().asArrayType().getArgument().isObjectType()); + assertEquals("symbolTable.VariablesTestClass", + symbol7.get().getType().asArrayType().getArgument().asObjectType().getTypeInfo() + .getFullName()); + assertEquals(1, symbol7.get().getType().asArrayType().getDim()); + + Optional symbol8 = + classScope.resolveField("someReferenceMatrixWithLeadingAndTrailingBrackets"); + assertTrue(symbol8.isPresent()); + assertTrue(symbol8.get().getType().isArrayType()); + assertTrue(symbol8.get().getType().asArrayType().getArgument().isObjectType()); + assertEquals("symbolTable.VariablesTestClass", + symbol8.get().getType().asArrayType().getArgument().asObjectType().getTypeInfo() + .getFullName()); + assertEquals(2, symbol8.get().getType().asArrayType().getDim()); + + // someMethod + + Optional methodSymbol = classScope.resolveMethod("someMethod"); + assertTrue(methodSymbol.isPresent()); + assertEquals(1, methodSymbol.get().getParameterList().size()); + VariableSymbol javaParameterSymbol = methodSymbol.get().getParameterList().get(0); + Optional resolvedJavaParameterSymbol = + methodSymbol.get().getSpannedScope().resolveVariable("someMethodParameter"); + assertTrue(resolvedJavaParameterSymbol.isPresent()); + assertEquals(javaParameterSymbol, resolvedJavaParameterSymbol.get()); + IJavaDSLScope methodScope = classScope.getSubScopes().get(0).getSubScopes().get(0); + Optional localVariableSymbol = methodScope.resolveField("localVariable"); + assertTrue(localVariableSymbol.isPresent()); + assertTrue(SymTypeRelations.isInt(localVariableSymbol.get().getType())); + + assertTrue(methodScope.resolveField("i").isEmpty()); + } + + @Test + public void test_symbolTable_typevariableUpperbounds() throws RecognitionException, IOException { + IJavaDSLArtifactScope scope = + parseAndCreateST("src/test/resources/generics/IComplexComponent.java"); + + Optional interf = scope.resolveTypeLocally("IComplexComponent"); + assertTrue(interf.isPresent()); + + assertEquals(2, interf.get().getTypeParameterList().size()); + final TypeVarSymbol kTypeSymbol = interf.get().getTypeParameterList().get(0); + assertEquals("generics.IComplexComponent.K", kTypeSymbol.getFullName()); + assertFalse(kTypeSymbol.isPresentSuperClass()); + final TypeVarSymbol vTypeSymbol = interf.get().getTypeParameterList().get(1); + assertEquals("generics.IComplexComponent.V", vTypeSymbol.getFullName()); + assertTrue(vTypeSymbol.isPresentSuperClass()); + assertEquals(1, vTypeSymbol.getSuperTypesList().size()); + assertEquals("java.lang.Number", vTypeSymbol.getSuperTypes(0).getTypeInfo().getFullName()); + + Optional resolvedK = interf.get().getSpannedScope().resolveTypeVar("K"); + Optional resolvedV = interf.get().getSpannedScope().resolveTypeVar("V"); + assertTrue(resolvedK.isPresent()); + assertTrue(resolvedV.isPresent()); + assertSame(kTypeSymbol, resolvedK.get()); + assertSame(vTypeSymbol, resolvedV.get()); + } + + @Test + public void testMethodParametersAndLocalVariablesAreDefinedInSameScope() throws IOException { + IJavaDSLArtifactScope scope = parseAndCreateST( + "src/test/resources/parsableAndCompilableModels/symbolTable/MethodParametersAndLocalVariablesAreDefinedInSameScope.java"); + + Optional typeSymbol = + scope.resolveType("MethodParametersAndLocalVariablesAreDefinedInSameScope"); + assertTrue(typeSymbol.isPresent()); + + Optional method = + ((JavaDSLScope) typeSymbol.get().getSpannedScope()).resolveJavaMethod("testMethod"); + assertTrue(method.isPresent()); + + assertEquals(1, method.get().getSpannedScope().getSymbolsSize()); + assertEquals(1, method.get().getSpannedScope().getSubScopes().size()); + assertEquals(2, method.get().getSpannedScope().getSubScopes().get(0).getSymbolsSize()); + } +} diff --git a/javaDSL/src/test/resources/parsableAndCompilableModels/simpleTestClasses/ExtendsObject.java b/javaDSL/src/test/resources/parsableAndCompilableModels/simpleTestClasses/ExtendsObject.java index c2c3abef..91e70d98 100644 --- a/javaDSL/src/test/resources/parsableAndCompilableModels/simpleTestClasses/ExtendsObject.java +++ b/javaDSL/src/test/resources/parsableAndCompilableModels/simpleTestClasses/ExtendsObject.java @@ -4,10 +4,10 @@ import java.util.ArrayList; -public class ExtendsObject { +public class ExtendsObject extends ArrayList { } -class DoesntExtendObject extends ArrayList { +class DoesntExtendObject { } From 15da6e23f0cabd37b9487bd22407271210f79011 Mon Sep 17 00:00:00 2001 From: Janik Rapp Date: Mon, 4 Aug 2025 16:44:20 +0200 Subject: [PATCH 18/61] JavaDSLTool path option now required multiple usages instead of pathSeparator separated paths --- javaDSL/src/main/java/de/monticore/java/JavaDSLTool.java | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/javaDSL/src/main/java/de/monticore/java/JavaDSLTool.java b/javaDSL/src/main/java/de/monticore/java/JavaDSLTool.java index 8fe99e73..e9f43815 100644 --- a/javaDSL/src/main/java/de/monticore/java/JavaDSLTool.java +++ b/javaDSL/src/main/java/de/monticore/java/JavaDSLTool.java @@ -108,11 +108,13 @@ else if (ppTargets.length == asts.size() cmd.getOptionValues("pp").length, asts.size())); } } - + + MCPath symbolPath = new MCPath(); if (cmd.hasOption("path")) { - String[] paths = splitPathEntries(cmd.getOptionValue("path")); - JavaDSLMill.globalScope().setSymbolPath(new MCPath(paths)); + String[] paths = cmd.getOptionValues("path"); + Arrays.stream(paths).forEach(p -> symbolPath.addEntry(Paths.get(p))); } + JavaDSLMill.globalScope().setSymbolPath(symbolPath); // Build symbol table and run symbol table completer asts.forEach(JavaDSLSymbolTableUtil::buildSymbolTable); From a3bc1126540fbcb4420cdc7309878affcbee87ff Mon Sep 17 00:00:00 2001 From: Janik Rapp Date: Mon, 4 Aug 2025 16:44:39 +0200 Subject: [PATCH 19/61] fix JavaDSLToolTest --- .../de/monticore/java/JavaDSLToolTest.java | 21 +- .../java/parser/ASTClassDeclaration.java | 322 +++++++----------- 2 files changed, 148 insertions(+), 195 deletions(-) diff --git a/javaDSL/src/test/java/de/monticore/java/JavaDSLToolTest.java b/javaDSL/src/test/java/de/monticore/java/JavaDSLToolTest.java index fc3690c4..909dfea1 100644 --- a/javaDSL/src/test/java/de/monticore/java/JavaDSLToolTest.java +++ b/javaDSL/src/test/java/de/monticore/java/JavaDSLToolTest.java @@ -7,8 +7,13 @@ import org.junit.jupiter.params.provider.Arguments; import org.junit.jupiter.params.provider.MethodSource; +import java.io.File; +import java.net.URISyntaxException; +import java.net.URLClassLoader; import java.nio.file.Path; import java.nio.file.Paths; +import java.util.ArrayList; +import java.util.Arrays; import java.util.List; import java.util.stream.Stream; @@ -28,15 +33,25 @@ public static Stream testTool(){ arguments( Paths.get("src","test","resources","de","monticore","java","parser","ASTClassDeclaration.java"), List.of( - Paths.get("de","monticore","javadsl","javadsl","_ast","ASTClassDeclaration.java"), - Paths.get("de","monticore","javadsl","javadsl","_ast","Builder.java"))) + Paths.get("de","monticore","java","javadsl","_ast","ASTClassDeclaration.java"), + Paths.get("de","monticore","java","javadsl","_ast","Builder.java"))) ); } @ParameterizedTest @MethodSource public void testTool(Path inputPath, List relOutputPaths) { - JavaDSLTool.main(new String[] { "-i", inputPath.toString(), "-o", OUTPUT_DIR.toString() }); + ArrayList path = new ArrayList<>(); + Arrays.stream(System.getProperty("java.class.path").split(File.pathSeparator)).forEach(p -> { + path.add("-path"); + path.add(p); + }); + + String[] cmdBase = + new String[] { "-i", inputPath.toString(), "-o", OUTPUT_DIR.toString(), "-c2mc" }; + String[] toolArgs = Stream.concat(Arrays.stream(cmdBase), path.stream()).toArray(String[]::new); + + JavaDSLTool.main(toolArgs); for (Path relExpectedOutputPath : relOutputPaths) { Path expectedOutput = OUTPUT_DIR.resolve(relExpectedOutputPath); diff --git a/javaDSL/src/test/resources/de/monticore/java/parser/ASTClassDeclaration.java b/javaDSL/src/test/resources/de/monticore/java/parser/ASTClassDeclaration.java index bfae8aa3..1eed7327 100644 --- a/javaDSL/src/test/resources/de/monticore/java/parser/ASTClassDeclaration.java +++ b/javaDSL/src/test/resources/de/monticore/java/parser/ASTClassDeclaration.java @@ -3,71 +3,65 @@ /* generated from model null*/ /* generated by template ast.AstClass*/ -package de.monticore.javadsl.javadsl._ast; +package de.monticore.java.javadsl._ast; /* generated by template ast.AstImports*/ import static com.google.common.base.Preconditions.*; import java.util.Optional; -import de.monticore.symboltable.Symbol; -import de.monticore.symboltable.Scope; +import de.monticore.symboltable.ISymbol; +import de.monticore.symboltable.IScope; import de.se_rwth.commons.logging.Log; public class ASTClassDeclaration extends /* generated by template ast.AstSuperTypes*/ -de.monticore.ast.ASTCNode implements de.monticore.javadsl.javadsl._ast.ASTTypeDeclaration, ASTJavaDSLNode { - /* generated by template ast.Attribute*/ - protected de.monticore.javadsl.javadsl._ast.ASTModifierList modifiers = JavaDSLNodeFactory.createASTModifierList(); - +de.monticore.ast.ASTCNode implements de.monticore.java.javadsl._ast.ASTTypeDeclaration, ASTJavaDSLNode { /* generated by template ast.Attribute*/ protected String name; /* generated by template ast.Attribute*/ - protected Optional typeParameters = Optional.empty(); + protected Optional typeParameters = Optional.empty(); /* generated by template ast.Attribute*/ - protected Optional superClass = Optional.empty(); + protected Optional superClass = Optional.empty(); /* generated by template ast.Attribute*/ - protected de.monticore.types.types._ast.ASTTypeList implementedInterfaces = de.monticore.types.types._ast.TypesNodeFactory.createASTTypeList(); + protected de.monticore.types.mccollectiontypes._ast.ASTMCListType implementedInterfaces = de.monticore.types.types._ast.TypesNodeFactory.createASTTypeList(); /* generated by template ast.Attribute*/ - protected de.monticore.javadsl.javadsl._ast.ASTClassBody classBody; + protected de.monticore.java.javadsl._ast.ASTClassBody classBody; /* generated by template ast.Attribute*/ - public Optional symbol = Optional.empty(); + public Optional symbol = Optional.empty(); /* generated by template ast.Attribute*/ - public Optional enclosingScope = Optional.empty(); + public Optional enclosingScope = Optional.empty(); /* generated by template ast.Constructor*/ protected ASTClassDeclaration (/* generated by template ast.ParametersDeclaration*/ - // Parameters declaration - ) + // Parameters declaration + ) /* generated by template ast.EmptyMethodBody*/ - { // empty body + { // empty body } /* generated by template ast.Constructor*/ protected ASTClassDeclaration (/* generated by template ast.ConstructorParametersDeclaration*/ - de.monticore.javadsl.javadsl._ast.ASTModifierList modifiers - , - String name + String name , - de.monticore.javadsl.javadsl._ast.ASTTypeParameters typeParameters + de.monticore.types.typeparameters._ast.ASTTypeParameters typeParameters , - de.monticore.types.types._ast.ASTType superClass + de.monticore.types.mcbasictypes._ast.ASTMCType superClass , - de.monticore.types.types._ast.ASTTypeList implementedInterfaces + de.monticore.types.mccollectiontypes._ast.ASTMCListType implementedInterfaces , - de.monticore.javadsl.javadsl._ast.ASTClassBody classBody + de.monticore.java.javadsl._ast.ASTClassBody classBody - ) + ) /* generated by template ast.ConstructorAttributesSetter*/ { - setModifiers(modifiers); setName(name); setTypeParameters(typeParameters); setSuperClass(superClass); @@ -79,9 +73,9 @@ protected ASTClassDeclaration (/* generated by template ast.ConstructorParamete /* generated by template ast.ClassMethod*/ - public void accept(de.monticore.javadsl.javadsl._visitor.JavaDSLVisitor visitor) + public void accept(de.monticore.java.javadsl._visitor.JavaDSLVisitor2 visitor) - { + { /* generated by template ast.ErrorIfNull*/ Log.errorIfNull(visitor); @@ -89,13 +83,13 @@ public void accept(de.monticore.javadsl.javadsl._visitor.JavaDSLVisitor visitor visitor.handle(this); - } + } /* generated by template ast.ClassMethod*/ public boolean deepEquals(Object o) - { + { /* generated by template ast.ErrorIfNull*/ Log.errorIfNull(o); @@ -110,53 +104,48 @@ public boolean deepEquals(Object o) if (!equalAttributes(comp)) { return false; } - // comparing modifiers - if ( (this.modifiers == null && comp.modifiers != null) || - (this.modifiers != null && !this.modifiers.deepEquals(comp.modifiers)) ) { - return false; - } - // comparing typeParameters + // comparing typeParameters if ( this.typeParameters.isPresent() != comp.typeParameters.isPresent() || (this.typeParameters.isPresent() && !this.typeParameters.get().deepEquals(comp.typeParameters.get())) ) { return false; } - // comparing superClass + // comparing superClass if ( this.superClass.isPresent() != comp.superClass.isPresent() || (this.superClass.isPresent() && !this.superClass.get().deepEquals(comp.superClass.get())) ) { return false; } // comparing implementedInterfaces - if ( (this.implementedInterfaces == null && comp.implementedInterfaces != null) || + if ( (this.implementedInterfaces == null && comp.implementedInterfaces != null) || (this.implementedInterfaces != null && !this.implementedInterfaces.deepEquals(comp.implementedInterfaces)) ) { return false; } // comparing classBody - if ( (this.classBody == null && comp.classBody != null) || + if ( (this.classBody == null && comp.classBody != null) || (this.classBody != null && !this.classBody.deepEquals(comp.classBody)) ) { return false; } - return true; + return true; - } + } /* generated by template ast.ClassMethod*/ public boolean deepEquals(Object o,boolean forceSameOrder) - { + { /* generated by template ast.ErrorIfNull*/ Log.errorIfNull(o); return deepEquals(o); - } + } /* generated by template ast.ClassMethod*/ public boolean deepEqualsWithComments(Object o) - { + { /* generated by template ast.ErrorIfNull*/ Log.errorIfNull(o); @@ -171,11 +160,6 @@ public boolean deepEqualsWithComments(Object o) if (!equalsWithComments(comp)) { return false; } - // comparing modifiers - if ( (this.modifiers == null && comp.modifiers != null) || - (this.modifiers != null && !this.modifiers.deepEqualsWithComments(comp.modifiers)) ) { - return false; - } // comparing typeParameters if ( this.typeParameters.isPresent() != comp.typeParameters.isPresent() || (this.typeParameters.isPresent() && !this.typeParameters.get().deepEqualsWithComments(comp.typeParameters.get())) ) { @@ -187,36 +171,36 @@ public boolean deepEqualsWithComments(Object o) return false; } // comparing implementedInterfaces - if ( (this.implementedInterfaces == null && comp.implementedInterfaces != null) || + if ( (this.implementedInterfaces == null && comp.implementedInterfaces != null) || (this.implementedInterfaces != null && !this.implementedInterfaces.deepEqualsWithComments(comp.implementedInterfaces)) ) { return false; } // comparing classBody - if ( (this.classBody == null && comp.classBody != null) || + if ( (this.classBody == null && comp.classBody != null) || (this.classBody != null && !this.classBody.deepEqualsWithComments(comp.classBody)) ) { return false; } - return true; + return true; - } + } /* generated by template ast.ClassMethod*/ public boolean deepEqualsWithComments(Object o,boolean forceSameOrder) - { + { /* generated by template ast.ErrorIfNull*/ Log.errorIfNull(o); return deepEqualsWithComments(o); - } + } /* generated by template ast.ClassMethod*/ public boolean equalAttributes(Object o) - { + { /* generated by template ast.ErrorIfNull*/ Log.errorIfNull(o); @@ -228,31 +212,31 @@ public boolean equalAttributes(Object o) } else { return false; } - // comparing name - if ( (this.name == null && comp.name != null) + // comparing name + if ( (this.name == null && comp.name != null) || (this.name != null && !this.name.equals(comp.name)) ) { return false; } - // comparing symbol + // comparing symbol if ( this.symbol.isPresent() != comp.symbol.isPresent() || (this.symbol.isPresent() && !this.symbol.get().equals(comp.symbol.get())) ) { return false; } - // comparing enclosingScope + // comparing enclosingScope if ( this.enclosingScope.isPresent() != comp.enclosingScope.isPresent() || (this.enclosingScope.isPresent() && !this.enclosingScope.get().equals(comp.enclosingScope.get())) ) { return false; } - return true; + return true; - } + } /* generated by template ast.ClassMethod*/ public boolean equalsWithComments(Object o) - { + { /* generated by template ast.ErrorIfNull*/ Log.errorIfNull(o); @@ -295,9 +279,6 @@ public boolean equalsWithComments(Object o) /* generated by template ast.ClassMethod*/ public de.monticore.ast.ASTNode get_Children(){ de.monticore.ast.ASTNode result = new de.monticore.ast.ASTNode(); - if (getModifiers() != null) { - result.add(getModifiers()); - } if ( getTypeParameters().isPresent()) { result.add ( getTypeParameters().get()); } @@ -312,21 +293,18 @@ public de.monticore.ast.ASTNode get_Children(){ } return result; - } + } /* generated by template ast.ClassMethod*/ public void remove_Child(de.monticore.ast.ASTNode child) - { + { /* generated by template ast.ErrorIfNull*/ Log.errorIfNull(child); /* generated by template ast.additionalmethods.RemoveChild*/ - - if (getModifiers() == child) { - setModifiers(null); - } + if (getTypeParameters().get() == child) { setTypeParameters(null); } @@ -340,35 +318,35 @@ public void remove_Child(de.monticore.ast.ASTNode child) setClassBody(null); } - } + } /* generated by template ast.ClassMethod*/ public static Builder getBuilder() - { + { /* generated by template ast.ErrorIfNull*/ return new Builder(); - } + } /* generated by template ast.ClassMethod*/ public ASTClassDeclaration deepClone() - { + { /* generated by template ast.ErrorIfNull*/ return deepClone(_construct()); - } + } /* generated by template ast.ClassMethod*/ public ASTClassDeclaration deepClone(ASTClassDeclaration result) - { + { /* generated by template ast.ErrorIfNull*/ Log.errorIfNull(result); @@ -376,160 +354,130 @@ public ASTClassDeclaration deepClone(ASTClassDeclaration result) super.deepClone(result); - if (this.modifiers != null) { - result.setModifiers(this.modifiers.deepClone()); - } if (this.name != null) { result.name = this.name; } - result.typeParameters = this.typeParameters.isPresent()? Optional.ofNullable((de.monticore.javadsl.javadsl._ast.ASTTypeParameters)this.typeParameters.get().deepClone()) : Optional.empty(); + result.typeParameters = this.typeParameters.isPresent()? Optional.ofNullable((de.monticore.types.typeparameters._ast.ASTTypeParameters)this.typeParameters.get().deepClone()) : Optional.empty(); result.superClass = this.superClass.isPresent()? Optional.ofNullable((de.monticore.types.types._ast.ASTType)this.superClass.get().deepClone()) : Optional.empty(); if (this.implementedInterfaces != null) { result.setImplementedInterfaces(this.implementedInterfaces.deepClone()); } if (this.classBody != null) { - result.setClassBody((de.monticore.javadsl.javadsl._ast.ASTClassBody) this.classBody.deepClone()); + result.setClassBody((de.monticore.java.javadsl._ast.ASTClassBody) this.classBody.deepClone()); } - result.symbol = this.symbol.isPresent()? Optional.ofNullable((Symbol)this.symbol.get()) : Optional.empty(); - result.enclosingScope = this.enclosingScope.isPresent()? Optional.ofNullable((Scope)this.enclosingScope.get()) : Optional.empty(); + result.symbol = this.symbol.isPresent()? Optional.ofNullable((ISymbol)this.symbol.get()) : Optional.empty(); + result.enclosingScope = this.enclosingScope.isPresent()? Optional.ofNullable((IScope)this.enclosingScope.get()) : Optional.empty(); return result; - } + } /* generated by template ast.ClassMethod*/ protected ASTClassDeclaration _construct() - { + { /* generated by template ast.ErrorIfNull*/ return new ASTClassDeclaration(); - } - - /* generated by template ast.ClassMethod*/ - - public de.monticore.javadsl.javadsl._ast.ASTModifierList getModifiers() - - { - /* generated by template ast.ErrorIfNull*/ - - /* generated by template ast.additionalmethods.Get*/ - - return this.modifiers; - - } + } /* generated by template ast.ClassMethod*/ public String getName() - { + { /* generated by template ast.ErrorIfNull*/ /* generated by template ast.additionalmethods.Get*/ return this.name; - } + } /* generated by template ast.ClassMethod*/ - public Optional getTypeParameters() + public Optional getTypeParameters() - { + { /* generated by template ast.ErrorIfNull*/ /* generated by template ast.additionalmethods.Get*/ return this.typeParameters; - } + } /* generated by template ast.ClassMethod*/ - public Optional getSuperClass() + public Optional getSuperClass() - { + { /* generated by template ast.ErrorIfNull*/ /* generated by template ast.additionalmethods.Get*/ return this.superClass; - } + } /* generated by template ast.ClassMethod*/ - public de.monticore.types.types._ast.ASTTypeList getImplementedInterfaces() + public de.monticore.types.mccollectiontypes._ast.ASTMCListType getImplementedInterfaces() - { + { /* generated by template ast.ErrorIfNull*/ /* generated by template ast.additionalmethods.Get*/ return this.implementedInterfaces; - } + } /* generated by template ast.ClassMethod*/ - public de.monticore.javadsl.javadsl._ast.ASTClassBody getClassBody() + public de.monticore.java.javadsl._ast.ASTClassBody getClassBody() - { + { /* generated by template ast.ErrorIfNull*/ /* generated by template ast.additionalmethods.Get*/ return this.classBody; - } + } /* generated by template ast.ClassMethod*/ - public Optional getSymbol() + public Optional getSymbol() - { + { /* generated by template ast.ErrorIfNull*/ /* generated by template ast.additionalmethods.Get*/ return this.symbol; - } + } /* generated by template ast.ClassMethod*/ - public Optional getEnclosingScope() + public Optional getEnclosingScope() - { + { /* generated by template ast.ErrorIfNull*/ /* generated by template ast.additionalmethods.Get*/ return this.enclosingScope; - } - - /* generated by template ast.ClassMethod*/ - - public void setModifiers(de.monticore.javadsl.javadsl._ast.ASTModifierList modifiers) - - { - /* generated by template ast.ErrorIfNull*/ - Log.errorIfNull(modifiers); - - /* generated by template ast.additionalmethods.Set*/ - - this.modifiers = modifiers; - - } + } /* generated by template ast.ClassMethod*/ public void setName(String name) - { + { /* generated by template ast.ErrorIfNull*/ Log.errorIfNull(name); @@ -537,59 +485,59 @@ public void setName(String name) this.name = name; - } + } /* generated by template ast.ClassMethod*/ - public void setTypeParameters(de.monticore.javadsl.javadsl._ast.ASTTypeParameters typeParameters) + public void setTypeParameters(de.monticore.types.typeparameters._ast.ASTTypeParameters typeParameters) - { + { /* generated by template ast.additionalmethods.Set*/ this.typeParameters = Optional.ofNullable(typeParameters); - } + } /* generated by template ast.ClassMethod*/ public boolean typeParametersIsPresent() - { + { /* generated by template ast.ErrorIfNull*/ - return typeParameters.isPresent(); + return typeParameters.isPresent(); - } + } /* generated by template ast.ClassMethod*/ - public void setSuperClass(de.monticore.types.types._ast.ASTType superClass) + public void setSuperClass(de.monticore.types.mcbasictypes._ast.ASTMCType superClass) - { + { /* generated by template ast.additionalmethods.Set*/ this.superClass = Optional.ofNullable(superClass); - } + } /* generated by template ast.ClassMethod*/ public boolean superClassIsPresent() - { + { /* generated by template ast.ErrorIfNull*/ - return superClass.isPresent(); + return superClass.isPresent(); - } + } /* generated by template ast.ClassMethod*/ - public void setImplementedInterfaces(de.monticore.types.types._ast.ASTTypeList implementedInterfaces) + public void setImplementedInterfaces(de.monticore.types.mccollectiontypes._ast.ASTMCListType implementedInterfaces) - { + { /* generated by template ast.ErrorIfNull*/ Log.errorIfNull(implementedInterfaces); @@ -597,13 +545,13 @@ public void setImplementedInterfaces(de.monticore.types.types._ast.ASTTypeList this.implementedInterfaces = implementedInterfaces; - } + } /* generated by template ast.ClassMethod*/ - public void setClassBody(de.monticore.javadsl.javadsl._ast.ASTClassBody classBody) + public void setClassBody(de.monticore.java.javadsl._ast.ASTClassBody classBody) - { + { /* generated by template ast.ErrorIfNull*/ Log.errorIfNull(classBody); @@ -611,55 +559,55 @@ public void setClassBody(de.monticore.javadsl.javadsl._ast.ASTClassBody classBo this.classBody = classBody; - } + } /* generated by template ast.ClassMethod*/ - public void setSymbol(Symbol symbol) + public void setSymbol(ISymbol symbol) - { + { /* generated by template ast.additionalmethods.Set*/ this.symbol = Optional.ofNullable(symbol); - } + } /* generated by template ast.ClassMethod*/ public boolean symbolIsPresent() - { + { /* generated by template ast.ErrorIfNull*/ - return symbol.isPresent(); + return symbol.isPresent(); - } + } /* generated by template ast.ClassMethod*/ - public void setEnclosingScope(Scope enclosingScope) + public void setEnclosingScope(IScope enclosingScope) - { + { /* generated by template ast.additionalmethods.Set*/ this.enclosingScope = Optional.ofNullable(enclosingScope); - } + } /* generated by template ast.ClassMethod*/ public boolean enclosingScopeIsPresent() - { + { /* generated by template ast.ErrorIfNull*/ - return enclosingScope.isPresent(); + return enclosingScope.isPresent(); - } + } - + /* generated by template ast.ClassContent*/ // Class content /* generated by template ast.AstBuilder*/ @@ -668,72 +616,62 @@ public boolean enclosingScopeIsPresent() * Builder for {@link ASTClassDeclaration}. */ public static class Builder { - /* generated by template ast.BuilderAttribute*/ - protected de.monticore.javadsl.javadsl._ast.ASTModifierList modifiers = JavaDSLNodeFactory.createASTModifierList(); - /* generated by template ast.BuilderAttribute*/ protected String name; /* generated by template ast.BuilderAttribute*/ - protected de.monticore.javadsl.javadsl._ast.ASTTypeParameters typeParameters; + protected de.monticore.types.typeparameters._ast.ASTTypeParameters typeParameters; /* generated by template ast.BuilderAttribute*/ - protected de.monticore.types.types._ast.ASTType superClass; + protected de.monticore.types.mcbasictypes._ast.ASTMCType superClass; /* generated by template ast.BuilderAttribute*/ - protected de.monticore.types.types._ast.ASTTypeList implementedInterfaces = de.monticore.types.types._ast.TypesNodeFactory.createASTTypeList(); + protected de.monticore.types.mccollectiontypes._ast.ASTMCListType implementedInterfaces = de.monticore.types.types._ast.TypesNodeFactory.createASTTypeList(); /* generated by template ast.BuilderAttribute*/ - protected de.monticore.javadsl.javadsl._ast.ASTClassBody classBody; + protected de.monticore.java.javadsl._ast.ASTClassBody classBody; public ASTClassDeclaration build() { return new ASTClassDeclaration (/* generated by template ast.BuilderConstructorParametersDeclaration*/ - - this.modifiers - , - this.name + + this.name , - this.typeParameters + this.typeParameters , - this.superClass + this.superClass , - this.implementedInterfaces + this.implementedInterfaces , - this.classBody + this.classBody ); } - /* generated by template ast.AstBuilderAttributeSetter*/ - public Builder modifiers(de.monticore.javadsl.javadsl._ast.ASTModifierList modifiers) { - this.modifiers = modifiers; - return this; - } /* generated by template ast.AstBuilderAttributeSetter*/ public Builder name(String name) { this.name = name; return this; } /* generated by template ast.AstBuilderAttributeSetter*/ - public Builder typeParameters(de.monticore.javadsl.javadsl._ast.ASTTypeParameters typeParameters) { + public Builder typeParameters(de.monticore.types.typeparameters._ast.ASTTypeParameters typeParameters) { this.typeParameters = typeParameters; return this; } /* generated by template ast.AstBuilderAttributeSetter*/ - public Builder superClass(de.monticore.types.types._ast.ASTType superClass) { + public Builder superClass(de.monticore.types.mcbasictypes._ast.ASTMCType superClass) { this.superClass = superClass; return this; } /* generated by template ast.AstBuilderAttributeSetter*/ - public Builder implementedInterfaces(de.monticore.types.types._ast.ASTTypeList implementedInterfaces) { + public Builder implementedInterfaces(de.monticore.types.mccollectiontypes._ast.ASTMCListType implementedInterfaces) { this.implementedInterfaces = implementedInterfaces; return this; } /* generated by template ast.AstBuilderAttributeSetter*/ - public Builder classBody(de.monticore.javadsl.javadsl._ast.ASTClassBody classBody) { + public Builder classBody(de.monticore.java.javadsl._ast.ASTClassBody classBody) { this.classBody = classBody; return this; } - } + } } \ No newline at end of file From 110577f77c75d27ea53d214eea3a9d3ede91e189 Mon Sep 17 00:00:00 2001 From: Janik Rapp Date: Wed, 6 Aug 2025 15:53:25 +0200 Subject: [PATCH 20/61] add unnamed default package if needed --- .../java/javadsl/_symboltable/JavaDSLScopesGenitor.java | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/JavaDSLScopesGenitor.java b/javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/JavaDSLScopesGenitor.java index 2eead34d..69d9b008 100644 --- a/javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/JavaDSLScopesGenitor.java +++ b/javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/JavaDSLScopesGenitor.java @@ -11,6 +11,11 @@ public final class JavaDSLScopesGenitor extends JavaDSLScopesGenitorTOP { public IJavaDSLArtifactScope createFromAST(ASTCompilationUnit rootNode) { IJavaDSLArtifactScope artifactScope = super.createFromAST(rootNode); + // Java allows unnamed packages, so we set a name if needed + if (!artifactScope.isPresentName()) { + artifactScope.setName(""); + } + if (rootNode instanceof ASTOrdinaryCompilationUnit) { ASTOrdinaryCompilationUnit ordinaryCompilationUnit = (ASTOrdinaryCompilationUnit) rootNode; From a7f79dd74839dfeb8caefb90a9957d7e2020826e Mon Sep 17 00:00:00 2001 From: Janik Rapp Date: Tue, 12 Aug 2025 11:08:36 +0200 Subject: [PATCH 21/61] set EnumConstant in the FieldSymbol of EnumConstantDeclarations --- javaDSL/src/main/java/de/monticore/java/JavaDSLTool.java | 1 + .../java/javadsl/_symboltable/JavaDSLSymbolTableCompleter.java | 1 + 2 files changed, 2 insertions(+) diff --git a/javaDSL/src/main/java/de/monticore/java/JavaDSLTool.java b/javaDSL/src/main/java/de/monticore/java/JavaDSLTool.java index e9f43815..dee7e806 100644 --- a/javaDSL/src/main/java/de/monticore/java/JavaDSLTool.java +++ b/javaDSL/src/main/java/de/monticore/java/JavaDSLTool.java @@ -312,6 +312,7 @@ protected void storeSymbolsInFolder(ASTCompilationUnit compilationUnit, String f * "a/b/c" * * @param compilationUnit The ast of the model + * @return the relative file path as String based on the models qualified name */ protected String getRelativeFilePath(ASTCompilationUnit compilationUnit) { Optional qualifiedName = Optional.empty(); diff --git a/javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/JavaDSLSymbolTableCompleter.java b/javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/JavaDSLSymbolTableCompleter.java index 6da8b3b7..0c1c9c31 100644 --- a/javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/JavaDSLSymbolTableCompleter.java +++ b/javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/JavaDSLSymbolTableCompleter.java @@ -79,6 +79,7 @@ public void endVisit(ASTEnumConstantDeclaration node) { symbol.setIsFinal(true); symbol.setIsReadOnly(true); symbol.setIsPublic(true); + symbol.setIsEnumConstant(true); final String enumName = node.getEnclosingScope().getName(); final Optional enumDeclaration = From 36768fbcfc239605ed7e8ca0f30f705ef5bb46cb Mon Sep 17 00:00:00 2001 From: Janik Rapp Date: Wed, 20 Aug 2025 12:17:13 +0200 Subject: [PATCH 22/61] add gradle task for tool compilation --- build.gradle | 1 + javaDSL/build.gradle | 17 +++++++++++++++++ 2 files changed, 18 insertions(+) diff --git a/build.gradle b/build.gradle index f9062ec9..6c1842f9 100644 --- a/build.gradle +++ b/build.gradle @@ -1,5 +1,6 @@ plugins { id "de.monticore.generator" version "$mc_version" apply false + id "com.github.johnrengelman.shadow" version "$shadow_plugin_version" apply false } allprojects { diff --git a/javaDSL/build.gradle b/javaDSL/build.gradle index fc5d7d8c..c177061c 100644 --- a/javaDSL/build.gradle +++ b/javaDSL/build.gradle @@ -1,3 +1,7 @@ +import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar + +apply plugin:"com.github.johnrengelman.shadow" + description = "MontiCore: Java DSL" def grammarsDir = "src/main/grammars" @@ -47,6 +51,19 @@ tasks.withType(Test).configureEach { dependsOn(extractCorpus) } +tasks.register('buildJavaDSLTool', ShadowJar) { + minimize() + group = 'mc' + archiveFileName = 'MCJavaDSL.jar' + archiveClassifier = 'javadsl-mc-tool' + manifest { + attributes('Main-Class':'de.monticore.java.JavaDSLTool') + } + from sourceSets.main.output + configurations = [project.configurations.runtimeClasspath] +} +jar.dependsOn(buildJavaDSLTool) + dependencies { implementation "de.monticore.lang:cd4analysis:$mc_version" implementation "de.monticore:class2mc:$mc_version" From c71cb69a6bb839fb24475e75bbe45641ed4ff1ff Mon Sep 17 00:00:00 2001 From: Janik Rapp Date: Wed, 20 Aug 2025 14:10:43 +0200 Subject: [PATCH 23/61] fix pretty printing option in the JavaDSLTool --- .../java/de/monticore/java/JavaDSLTool.java | 22 ++++++++++++++----- 1 file changed, 17 insertions(+), 5 deletions(-) diff --git a/javaDSL/src/main/java/de/monticore/java/JavaDSLTool.java b/javaDSL/src/main/java/de/monticore/java/JavaDSLTool.java index dee7e806..db32533f 100644 --- a/javaDSL/src/main/java/de/monticore/java/JavaDSLTool.java +++ b/javaDSL/src/main/java/de/monticore/java/JavaDSLTool.java @@ -84,17 +84,17 @@ public void run(String[] args) { if (cmd.hasOption("pp")) { String[] ppTargets = cmd.getOptionValues("pp"); if (ppTargets == null || ppTargets.length == 0) { - asts.forEach(ast -> storeSymbolsInFolder(ast, SYMBOLS_OUT_DIRECTORY)); + asts.forEach(ast -> prettyPrintInFolder(ast, SYMBOLS_OUT_DIRECTORY)); } else if (ppTargets.length == 1 && isLikelyFolderPath(cmd.getOptionValue("pp"))) { asts.forEach( - compUnit -> this.storeSymbolsInFolder(compUnit, cmd.getOptionValue("pp"))); + compUnit -> prettyPrintInFolder(compUnit, cmd.getOptionValue("pp"))); } else if (ppTargets.length == asts.size() && ppTargets.length == cmd.getOptionValues("i").length) { for (int i = 0; i < asts.size(); i++) { - storeSymbols( - (IJavaDSLArtifactScope) asts.get(i).getEnclosingScope(), + prettyPrintInFolder( + asts.get(i), ppTargets[i] ); } @@ -296,7 +296,7 @@ public Collection parse(String fileExt, Path directory) { /** * Stores the symbols for ast in the specified folder. * - * @param compilationUnit The ast of the SD + * @param compilationUnit The ast of the Java CompilationUnit * @param folderPath The folder to store the symbols in */ protected void storeSymbolsInFolder(ASTCompilationUnit compilationUnit, String folderPath) { @@ -305,6 +305,18 @@ protected void storeSymbolsInFolder(ASTCompilationUnit compilationUnit, String f storeSymbols((IJavaDSLArtifactScope) compilationUnit.getEnclosingScope(), filePath.toString()); } + /** + * Stores the pretty printed result for ast in the specified folder. + * + * @param compilationUnit The ast of the Java CompilationUnit + * @param folderPath The folder to store the pret + */ + protected void prettyPrintInFolder(ASTCompilationUnit compilationUnit, String folderPath) { + String relativeFilePath = getRelativeFilePath(compilationUnit).concat(".java"); + Path filePath = Paths.get(folderPath, relativeFilePath); + prettyPrint(compilationUnit, filePath.toString()); + } + /** * finds the file (without extension) for ast, * given its package and name. From 0e493fca6e7407c86a7fceb7e5cce856d5a6a749 Mon Sep 17 00:00:00 2001 From: Janik Rapp Date: Wed, 20 Aug 2025 17:11:39 +0200 Subject: [PATCH 24/61] allow EmptyStatement usage in the class body --- javaDSL/src/main/grammars/de/monticore/java/JavaDSL.mc4 | 3 +++ 1 file changed, 3 insertions(+) diff --git a/javaDSL/src/main/grammars/de/monticore/java/JavaDSL.mc4 b/javaDSL/src/main/grammars/de/monticore/java/JavaDSL.mc4 index f33512bf..56740652 100644 --- a/javaDSL/src/main/grammars/de/monticore/java/JavaDSL.mc4 +++ b/javaDSL/src/main/grammars/de/monticore/java/JavaDSL.mc4 @@ -241,6 +241,9 @@ ClassBlock implements ClassBodyDeclaration = (["static"])? JavaBlock ; +@Override +EmptyStatement implements ClassBodyDeclaration; + interface ClassMemberDeclaration extends ClassBodyDeclaration ; interface MethodBody ; From 291527da9f909abefcd47c240092fe3ac8ba9d66 Mon Sep 17 00:00:00 2001 From: Janik Rapp Date: Wed, 20 Aug 2025 17:12:33 +0200 Subject: [PATCH 25/61] remove transitive keyword as it is a contextual keyword --- .../src/main/grammars/de/monticore/java/JavaDSL.mc4 | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/javaDSL/src/main/grammars/de/monticore/java/JavaDSL.mc4 b/javaDSL/src/main/grammars/de/monticore/java/JavaDSL.mc4 index 56740652..54efd4a6 100644 --- a/javaDSL/src/main/grammars/de/monticore/java/JavaDSL.mc4 +++ b/javaDSL/src/main/grammars/de/monticore/java/JavaDSL.mc4 @@ -122,10 +122,11 @@ RequiresDirective implements ModuleDirective = "requires" RequiresModifier? MCQualifiedName ";" ; -enum RequiresModifier - = "static" - | "transitive" - ; + +interface RequiresModifier; + +StaticModifier implements RequiresModifier = ["static"]; +TransitiveModifier implements RequiresModifier = ["transitive"]; ExportsDirective implements ModuleDirective = "exports" MCQualifiedName ("to" toModules:(MCQualifiedName || ",")+)? ";" @@ -152,6 +153,7 @@ nokeyword "uses"; nokeyword "provides"; nokeyword "with"; nokeyword "to"; +nokeyword "transitive"; // Type declarations // TODO: Remove Java-specific Interfaces, reuse component grammars and use CoCos for validation? From c74c4ae5969ccadef48c2feb70bbb109582c70b7 Mon Sep 17 00:00:00 2001 From: Janik Rapp Date: Wed, 20 Aug 2025 17:14:57 +0200 Subject: [PATCH 26/61] create symbol table only when needed --- .../java/de/monticore/java/JavaDSLTool.java | 18 ++++++++++-------- 1 file changed, 10 insertions(+), 8 deletions(-) diff --git a/javaDSL/src/main/java/de/monticore/java/JavaDSLTool.java b/javaDSL/src/main/java/de/monticore/java/JavaDSLTool.java index db32533f..6d48d3a4 100644 --- a/javaDSL/src/main/java/de/monticore/java/JavaDSLTool.java +++ b/javaDSL/src/main/java/de/monticore/java/JavaDSLTool.java @@ -75,6 +75,13 @@ public void run(String[] args) { boolean useClass2MC = cmd.hasOption("c2mc"); JavaDSLSymbolTableUtil.prepareMill(useClass2MC); + + MCPath symbolPath = new MCPath(); + if (cmd.hasOption("path")) { + String[] paths = cmd.getOptionValues("path"); + Arrays.stream(paths).forEach(p -> symbolPath.addEntry(Paths.get(p))); + } + JavaDSLMill.globalScope().setSymbolPath(symbolPath); Log.enableFailQuick(false); List asts = @@ -109,15 +116,10 @@ else if (ppTargets.length == asts.size() } } - MCPath symbolPath = new MCPath(); - if (cmd.hasOption("path")) { - String[] paths = cmd.getOptionValues("path"); - Arrays.stream(paths).forEach(p -> symbolPath.addEntry(Paths.get(p))); + if (cmd.hasOption("s") || cmd.hasOption("o")) { + // Build symbol table and run symbol table completer + asts.forEach(JavaDSLSymbolTableUtil::buildSymbolTable); } - JavaDSLMill.globalScope().setSymbolPath(symbolPath); - - // Build symbol table and run symbol table completer - asts.forEach(JavaDSLSymbolTableUtil::buildSymbolTable); if (cmd.hasOption("s")) { if (cmd.getOptionValues("s") == null || cmd.getOptionValues("s").length == 0) { From d9dc7e3b7a924508e24965664a7f33385061db9f Mon Sep 17 00:00:00 2001 From: Janik Rapp Date: Wed, 20 Aug 2025 17:15:29 +0200 Subject: [PATCH 27/61] print feedback about parsed and unparsable files --- .../main/java/de/monticore/java/JavaDSLTool.java | 15 +++++++++++++-- 1 file changed, 13 insertions(+), 2 deletions(-) diff --git a/javaDSL/src/main/java/de/monticore/java/JavaDSLTool.java b/javaDSL/src/main/java/de/monticore/java/JavaDSLTool.java index 6d48d3a4..fe01b242 100644 --- a/javaDSL/src/main/java/de/monticore/java/JavaDSLTool.java +++ b/javaDSL/src/main/java/de/monticore/java/JavaDSLTool.java @@ -17,6 +17,7 @@ import de.monticore.java.javadsl._symboltable.IJavaDSLArtifactScope; import de.monticore.java.utils.JavaDSLSymbolTableUtil; import de.monticore.types.mcbasictypes._ast.ASTMCQualifiedName; +import de.se_rwth.commons.logging.Finding; import de.se_rwth.commons.logging.Log; import org.apache.commons.cli.*; @@ -84,10 +85,20 @@ public void run(String[] args) { JavaDSLMill.globalScope().setSymbolPath(symbolPath); Log.enableFailQuick(false); - List asts = - new ArrayList<>(this.parse(".java", this.createModelPath(cmd).getEntries())); + Collection parsed = this.parse(".java", this.createModelPath(cmd).getEntries()); + List asts = parsed.stream().filter(Objects::nonNull).collect(Collectors.toList()); + if (asts.size() < parsed.size()) { + Set errorFiles = + Log.getFindings().stream().map(Finding::getSourcePosition).filter(Optional::isPresent) + .map(x -> x.get().getFileName()).filter(Optional::isPresent).map(Optional::get) + .collect(Collectors.toSet()); + Log.warn(String.format("There are %d files that could not be parsed!", errorFiles.size())); + } + Log.clearFindings(); Log.enableFailQuick(true); + System.out.printf("Successfully parsed %d files%n", asts.size()); + if (cmd.hasOption("pp")) { String[] ppTargets = cmd.getOptionValues("pp"); if (ppTargets == null || ppTargets.length == 0) { From 33633b31ae64376c81e3edbd36c258b9c9901337 Mon Sep 17 00:00:00 2001 From: Janik Rapp Date: Thu, 21 Aug 2025 14:04:51 +0200 Subject: [PATCH 28/61] add missing ASTConstructorDeclaration type --- .../_symboltable/JavaDSLSymbolTableCompleter.java | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/JavaDSLSymbolTableCompleter.java b/javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/JavaDSLSymbolTableCompleter.java index 0c1c9c31..3c9f0a06 100644 --- a/javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/JavaDSLSymbolTableCompleter.java +++ b/javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/JavaDSLSymbolTableCompleter.java @@ -1,9 +1,11 @@ package de.monticore.java.javadsl._symboltable; +import de.monticore.ast.ASTNode; import de.monticore.java.javadsl.JavaDSLMill; import de.monticore.java.javadsl._ast.*; import de.monticore.java.javadsl._visitor.JavaDSLVisitor2; import de.monticore.javalight._ast.ASTAnnotation; +import de.monticore.javalight._ast.ASTConstructorDeclaration; import de.monticore.javalight._ast.ASTMethodDeclaration; import de.monticore.javalight._symboltable.JavaMethodSymbol; import de.monticore.javalight._visitor.JavaLightVisitor2; @@ -104,6 +106,19 @@ public void visit(ASTMethodDeclaration node) { node.getSpannedScope().setOrdered(true); } + @Override + public void endVisit(ASTConstructorDeclaration node) { + JavaMethodSymbol symbol = node.getSymbol(); + IJavaDSLScope enclosingScope = JavaDSLMill.typeDispatcher().asJavaDSLIJavaDSLScope(node.getEnclosingScope()); + ASTNode enclosingScopeNode = enclosingScope.getAstNode(); + if (JavaDSLMill.typeDispatcher().isJavaDSLASTClassDeclaration(enclosingScopeNode)) { + ASTClassDeclaration enclosingClass = JavaDSLMill.typeDispatcher().asJavaDSLASTClassDeclaration(enclosingScopeNode); + symbol.setType(SymTypeExpressionFactory.createFromSymbol(enclosingClass.getSymbol())); + } else { + Log.error("0xTODO: Could not set ASTConstructorDeclaration type as it is not a direct child of a ASTClassDeclaration"); + } + } + @Override public void endVisit(ASTClassDeclaration node) { TypeDeclarationSymbol symbol = node.getSymbol(); From 8aeeffa02f6410fefd8857509271ac6f3306176d Mon Sep 17 00:00:00 2001 From: Janik Rapp Date: Thu, 21 Aug 2025 14:06:35 +0200 Subject: [PATCH 29/61] fix symbol table building in the JavaDSLTool the SymTabCompleter should be delayed until the symbol table has been created for all input asts --- javaDSL/src/main/java/de/monticore/java/JavaDSLTool.java | 2 +- .../de/monticore/java/utils/JavaDSLSymbolTableUtil.java | 9 +++++++++ 2 files changed, 10 insertions(+), 1 deletion(-) diff --git a/javaDSL/src/main/java/de/monticore/java/JavaDSLTool.java b/javaDSL/src/main/java/de/monticore/java/JavaDSLTool.java index fe01b242..eb73384d 100644 --- a/javaDSL/src/main/java/de/monticore/java/JavaDSLTool.java +++ b/javaDSL/src/main/java/de/monticore/java/JavaDSLTool.java @@ -129,7 +129,7 @@ else if (ppTargets.length == asts.size() if (cmd.hasOption("s") || cmd.hasOption("o")) { // Build symbol table and run symbol table completer - asts.forEach(JavaDSLSymbolTableUtil::buildSymbolTable); + JavaDSLSymbolTableUtil.buildSymbolTable(asts); } if (cmd.hasOption("s")) { diff --git a/javaDSL/src/main/java/de/monticore/java/utils/JavaDSLSymbolTableUtil.java b/javaDSL/src/main/java/de/monticore/java/utils/JavaDSLSymbolTableUtil.java index 97b9067f..5c5b5bc4 100644 --- a/javaDSL/src/main/java/de/monticore/java/utils/JavaDSLSymbolTableUtil.java +++ b/javaDSL/src/main/java/de/monticore/java/utils/JavaDSLSymbolTableUtil.java @@ -14,6 +14,9 @@ import de.monticore.symbols.basicsymbols.BasicSymbolsMill; import de.monticore.types.typeparameters._symboltable.TypeParametersSTCompleteTypes; +import java.util.List; +import java.util.stream.Collectors; + public class JavaDSLSymbolTableUtil { public static void prepareMill(boolean enableC2MC) { JavaDSLMill.globalScope().clear(); @@ -32,6 +35,12 @@ public static IJavaDSLArtifactScope buildSymbolTable(ASTCompilationUnit ast) { return as; } + public static List buildSymbolTable(List asts) { + List as = asts.stream().map(JavaDSLSymbolTableUtil::runSymTabGenitor).collect(Collectors.toList()); + asts.forEach(JavaDSLSymbolTableUtil::runSymTabCompleter); + return as; + } + public static IJavaDSLArtifactScope runSymTabGenitor(ASTCompilationUnit ast) { JavaDSLScopesGenitorDelegator genitor = JavaDSLMill.scopesGenitorDelegator(); return genitor.createFromAST(ast); From 15e3aa1fa23afedaf1b8b1ab1269e062f8a6ef7f Mon Sep 17 00:00:00 2001 From: Janik Rapp Date: Mon, 25 Aug 2025 11:19:25 +0200 Subject: [PATCH 30/61] add nokeyword for record, as it is a contextual keyword --- javaDSL/src/main/grammars/de/monticore/java/JavaDSL.mc4 | 2 ++ 1 file changed, 2 insertions(+) diff --git a/javaDSL/src/main/grammars/de/monticore/java/JavaDSL.mc4 b/javaDSL/src/main/grammars/de/monticore/java/JavaDSL.mc4 index 54efd4a6..e841a25a 100644 --- a/javaDSL/src/main/grammars/de/monticore/java/JavaDSL.mc4 +++ b/javaDSL/src/main/grammars/de/monticore/java/JavaDSL.mc4 @@ -189,6 +189,8 @@ scope(shadowing) RecordDeclaration extends TypeDeclaration RecordBody ; +nokeyword "record"; + RecordHeader = "(" (RecordComponent || ",")* ")" ; From 0a83a1ed88765492be82e266536c40daab3fdaba Mon Sep 17 00:00:00 2001 From: Janik Rapp Date: Mon, 25 Aug 2025 13:08:14 +0200 Subject: [PATCH 31/61] temporary rollback of nokeyword record --- javaDSL/src/main/grammars/de/monticore/java/JavaDSL.mc4 | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/javaDSL/src/main/grammars/de/monticore/java/JavaDSL.mc4 b/javaDSL/src/main/grammars/de/monticore/java/JavaDSL.mc4 index e841a25a..fb4729e5 100644 --- a/javaDSL/src/main/grammars/de/monticore/java/JavaDSL.mc4 +++ b/javaDSL/src/main/grammars/de/monticore/java/JavaDSL.mc4 @@ -189,7 +189,8 @@ scope(shadowing) RecordDeclaration extends TypeDeclaration RecordBody ; -nokeyword "record"; +// TODO: "record" is a contextual keyword, but setting it to nokeyword creates conflicts with MethodDeclaration +//nokeyword "record"; RecordHeader = "(" (RecordComponent || ",")* ")" From fb6e0086b7975cd483c7ddfea50c5acb1f4c59b4 Mon Sep 17 00:00:00 2001 From: Janik Rapp Date: Mon, 25 Aug 2025 14:11:07 +0200 Subject: [PATCH 32/61] fix anonymous class creators --- javaDSL/src/main/grammars/de/monticore/java/JavaDSL.mc4 | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/javaDSL/src/main/grammars/de/monticore/java/JavaDSL.mc4 b/javaDSL/src/main/grammars/de/monticore/java/JavaDSL.mc4 index fb4729e5..f4cf801a 100644 --- a/javaDSL/src/main/grammars/de/monticore/java/JavaDSL.mc4 +++ b/javaDSL/src/main/grammars/de/monticore/java/JavaDSL.mc4 @@ -410,7 +410,7 @@ JavaAnnotation extends JavaModifier implements ElementValue ( "(" AnnotationArguments? ")" )? ; -scope(shadowing) AnonymousClass implements Creator +scope(shadowing) AnonymousClass extends ClassCreator implements Creator = MCType Arguments ClassBody? ; From 3a42589895cd7c86f03103dbac5e18a2cf2baf56 Mon Sep 17 00:00:00 2001 From: Janik Rapp Date: Mon, 25 Aug 2025 14:11:23 +0200 Subject: [PATCH 33/61] use OOClass2MCResolver --- .../java/de/monticore/java/utils/JavaDSLSymbolTableUtil.java | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/javaDSL/src/main/java/de/monticore/java/utils/JavaDSLSymbolTableUtil.java b/javaDSL/src/main/java/de/monticore/java/utils/JavaDSLSymbolTableUtil.java index 5c5b5bc4..d171879d 100644 --- a/javaDSL/src/main/java/de/monticore/java/utils/JavaDSLSymbolTableUtil.java +++ b/javaDSL/src/main/java/de/monticore/java/utils/JavaDSLSymbolTableUtil.java @@ -1,6 +1,7 @@ package de.monticore.java.utils; import de.monticore.class2mc.Class2MCResolver; +import de.monticore.class2mc.OOClass2MCResolver; import de.monticore.expressions.lambdaexpressions._symboltable.LambdaExpressionsSTCompleteTypes2; import de.monticore.java.javadsl.JavaDSLMill; import de.monticore.java.javadsl._ast.ASTCompilationUnit; @@ -24,7 +25,7 @@ public static void prepareMill(boolean enableC2MC) { BasicSymbolsMill.initializePrimitives(); if (enableC2MC) { - Class2MCResolver resolver = new Class2MCResolver(); + Class2MCResolver resolver = new OOClass2MCResolver(); JavaDSLMill.globalScope().addAdaptedTypeSymbolResolver(resolver); } } From 3a2f15af07af43a9fa81f9a5b8f9064b6eaf1152 Mon Sep 17 00:00:00 2001 From: Janik Rapp Date: Tue, 26 Aug 2025 16:59:14 +0200 Subject: [PATCH 34/61] fix error codes --- javaDSL/src/main/java/de/monticore/java/JavaDSLTool.java | 2 +- .../javadsl/_symboltable/JavaDSLSymbolTableCompleter.java | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/javaDSL/src/main/java/de/monticore/java/JavaDSLTool.java b/javaDSL/src/main/java/de/monticore/java/JavaDSLTool.java index eb73384d..febef17a 100644 --- a/javaDSL/src/main/java/de/monticore/java/JavaDSLTool.java +++ b/javaDSL/src/main/java/de/monticore/java/JavaDSLTool.java @@ -365,7 +365,7 @@ protected String getRelativeFilePath(ASTCompilationUnit compilationUnit) { return Paths.get(packagePath, artifactName).toString(); } else { if (artifactName.isBlank()) { - Log.error("0xTODO: Could not determine symbol table export path. " + Log.error("0x7A005: Could not determine symbol table export path. " + "Make sure that the file contains exactly one public class!"); } return Paths.get(artifactName).toString(); diff --git a/javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/JavaDSLSymbolTableCompleter.java b/javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/JavaDSLSymbolTableCompleter.java index 3c9f0a06..be18bc02 100644 --- a/javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/JavaDSLSymbolTableCompleter.java +++ b/javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/JavaDSLSymbolTableCompleter.java @@ -92,7 +92,7 @@ public void endVisit(ASTEnumConstantDeclaration node) { symbol.setType(typeObject); } else { - Log.error("0xTODO: Could not resolve enclosing enum declaration", + Log.error("0x0x7A003: Could not resolve enclosing enum declaration", node.get_SourcePositionStart()); } } @@ -115,7 +115,7 @@ public void endVisit(ASTConstructorDeclaration node) { ASTClassDeclaration enclosingClass = JavaDSLMill.typeDispatcher().asJavaDSLASTClassDeclaration(enclosingScopeNode); symbol.setType(SymTypeExpressionFactory.createFromSymbol(enclosingClass.getSymbol())); } else { - Log.error("0xTODO: Could not set ASTConstructorDeclaration type as it is not a direct child of a ASTClassDeclaration"); + Log.error("0x7A004: Could not set ASTConstructorDeclaration type as it is not a direct child of a ASTClassDeclaration"); } } From f45d28f2bb5294eb598982decc98e8d0fb2e2bf5 Mon Sep 17 00:00:00 2001 From: Janik Rapp Date: Tue, 26 Aug 2025 17:00:10 +0200 Subject: [PATCH 35/61] add adapted symtab completer for LocalVariableDeclaration with var support --- ...DeclarationStatementsSymTabCompletion.java | 42 +++++++++++++++++++ .../java/utils/JavaDSLSymbolTableUtil.java | 9 ++-- 2 files changed, 47 insertions(+), 4 deletions(-) create mode 100644 javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/JavaDSLMCVarDeclarationStatementsSymTabCompletion.java diff --git a/javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/JavaDSLMCVarDeclarationStatementsSymTabCompletion.java b/javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/JavaDSLMCVarDeclarationStatementsSymTabCompletion.java new file mode 100644 index 00000000..95ef25f1 --- /dev/null +++ b/javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/JavaDSLMCVarDeclarationStatementsSymTabCompletion.java @@ -0,0 +1,42 @@ +package de.monticore.java.javadsl._symboltable; + +import de.monticore.java.javadsl.JavaDSLMill; +import de.monticore.java.javadsl._ast.ASTLocalVariableDeclaration; +import de.monticore.java.javadsl._visitor.JavaDSLVisitor2; +import de.monticore.statements.mcvardeclarationstatements._ast.ASTSimpleInit; +import de.monticore.statements.mcvardeclarationstatements._ast.ASTVariableDeclarator; +import de.monticore.statements.mcvardeclarationstatements._ast.ASTVariableInit; +import de.monticore.statements.mcvardeclarationstatements._symboltable.MCVarDeclarationStatementsSymTabCompletion; +import de.monticore.types.check.SymTypeExpression; +import de.monticore.types.check.SymTypeExpressionFactory; +import de.monticore.types3.TypeCheck3; +import de.se_rwth.commons.logging.Log; + +public class JavaDSLMCVarDeclarationStatementsSymTabCompletion extends + MCVarDeclarationStatementsSymTabCompletion implements JavaDSLVisitor2 { + + @Override + public void endVisit(ASTLocalVariableDeclaration node) { + if (node.isVar()) { + // we assume that there is just a single VariableDeclarator, as a CoCo prevents the + // declaration of multiple variables with a single var + ASTVariableDeclarator declarator = node.getVariableDeclarator(0); + ASTVariableInit variableInit = declarator.getVariableInit(); + + SymTypeExpression targetType = SymTypeExpressionFactory.createObscureType(); + if (JavaDSLMill.typeDispatcher().isMCVarDeclarationStatementsASTSimpleInit(variableInit)) { + ASTSimpleInit simpleInit = JavaDSLMill.typeDispatcher().asMCVarDeclarationStatementsASTSimpleInit(variableInit); + targetType = TypeCheck3.typeOf(simpleInit.getExpression()); + } else { + Log.error("0x7A001: Unsupported ASTVariableInit type"); + } + + if (targetType.isObscureType()) { + Log.error("0x7A002: Could not determine type of 'var' variable"); + } + declarator.getDeclarator().getSymbol().setType(targetType); + } else { + super.endVisit(node); + } + } +} diff --git a/javaDSL/src/main/java/de/monticore/java/utils/JavaDSLSymbolTableUtil.java b/javaDSL/src/main/java/de/monticore/java/utils/JavaDSLSymbolTableUtil.java index d171879d..24dae687 100644 --- a/javaDSL/src/main/java/de/monticore/java/utils/JavaDSLSymbolTableUtil.java +++ b/javaDSL/src/main/java/de/monticore/java/utils/JavaDSLSymbolTableUtil.java @@ -6,12 +6,12 @@ import de.monticore.java.javadsl.JavaDSLMill; import de.monticore.java.javadsl._ast.ASTCompilationUnit; import de.monticore.java.javadsl._symboltable.IJavaDSLArtifactScope; +import de.monticore.java.javadsl._symboltable.JavaDSLMCVarDeclarationStatementsSymTabCompletion; import de.monticore.java.javadsl._symboltable.JavaDSLScopesGenitorDelegator; import de.monticore.java.javadsl._symboltable.JavaDSLSymbolTableCompleter; import de.monticore.java.javadsl._visitor.JavaDSLTraverser; import de.monticore.javalight._symboltable.JavaLightSTCompleteTypes; import de.monticore.statements.mccommonstatements._symboltable.MCCommonStatementsSymTabCompletion; -import de.monticore.statements.mcvardeclarationstatements._symboltable.MCVarDeclarationStatementsSymTabCompletion; import de.monticore.symbols.basicsymbols.BasicSymbolsMill; import de.monticore.types.typeparameters._symboltable.TypeParametersSTCompleteTypes; @@ -48,7 +48,7 @@ public static IJavaDSLArtifactScope runSymTabGenitor(ASTCompilationUnit ast) { } public static void runSymTabCompleter(ASTCompilationUnit ast) { - JavaDSLTraverser traverser = JavaDSLMill.traverser(); + JavaDSLTraverser traverser = JavaDSLMill.inheritanceTraverser(); JavaDSLSymbolTableCompleter javaDslCompleter = new JavaDSLSymbolTableCompleter(); traverser.add4JavaDSL(javaDslCompleter); @@ -63,8 +63,9 @@ public static void runSymTabCompleter(ASTCompilationUnit ast) { LambdaExpressionsSTCompleteTypes2 lambdaExpressionsSTCompleteTypes2 = new LambdaExpressionsSTCompleteTypes2(); traverser.add4LambdaExpressions(lambdaExpressionsSTCompleteTypes2); - MCVarDeclarationStatementsSymTabCompletion mcVarDecStmtsSymTabCompletion = new MCVarDeclarationStatementsSymTabCompletion(); - traverser.add4MCVarDeclarationStatements(mcVarDecStmtsSymTabCompletion); + JavaDSLMCVarDeclarationStatementsSymTabCompletion javaDSLMCVarDeclarationStatementsSymTabCompletion = new JavaDSLMCVarDeclarationStatementsSymTabCompletion(); + traverser.add4JavaDSL(javaDSLMCVarDeclarationStatementsSymTabCompletion); + traverser.add4MCVarDeclarationStatements(javaDSLMCVarDeclarationStatementsSymTabCompletion); TypeParametersSTCompleteTypes typeParametersSTCompleteTypes = new TypeParametersSTCompleteTypes(); traverser.add4TypeParameters(typeParametersSTCompleteTypes); From 82f9da77484d8e726a02760133cd335d9d391e6c Mon Sep 17 00:00:00 2001 From: Janik Rapp Date: Tue, 26 Aug 2025 17:10:14 +0200 Subject: [PATCH 36/61] more unique error codes --- .../monticore/java/javadsl/types3/JavaDSLTypeVisitor.java | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/javaDSL/src/main/java/de/monticore/java/javadsl/types3/JavaDSLTypeVisitor.java b/javaDSL/src/main/java/de/monticore/java/javadsl/types3/JavaDSLTypeVisitor.java index 1dd23f2a..7df7e5ea 100644 --- a/javaDSL/src/main/java/de/monticore/java/javadsl/types3/JavaDSLTypeVisitor.java +++ b/javaDSL/src/main/java/de/monticore/java/javadsl/types3/JavaDSLTypeVisitor.java @@ -50,7 +50,7 @@ public void endVisit(ASTMCQualifiedType mcQType) { t -> true ); if (type.isEmpty()) { - Log.error("0xFDAE3 unable to find type " + Log.error("0x7A006 unable to find type " + name + " within type " + prefixType.printFullName(), @@ -60,7 +60,7 @@ public void endVisit(ASTMCQualifiedType mcQType) { } } else { - Log.error("0xFDA3E unexpected access \"." + Log.error("0x7A007 unexpected access \"." + name + "\" for type " + prefixType.printFullName(), @@ -73,7 +73,7 @@ public void endVisit(ASTMCQualifiedType mcQType) { } while (numberOfPartsUsedForFirstType < mcQType.sizeAnnotatedNames()); if (type.isEmpty()) { - Log.error("0xA0324 Cannot find symbol " + mcQType.getAnnotatedNameList().stream().map(ASTAnnotatedName::getName).collect(Collectors.joining(".")), + Log.error("0x7A008 Cannot find symbol " + mcQType.getAnnotatedNameList().stream().map(ASTAnnotatedName::getName).collect(Collectors.joining(".")), mcQType.get_SourcePositionStart(), mcQType.get_SourcePositionEnd() ); From 08310bc3cb42c093b04d66813244ec8c31dfbd95 Mon Sep 17 00:00:00 2001 From: Janik Rapp Date: Thu, 28 Aug 2025 11:00:00 +0200 Subject: [PATCH 37/61] set constructor type within EnumDeclaration --- .../_symboltable/JavaDSLSymbolTableCompleter.java | 14 +++++++++++--- 1 file changed, 11 insertions(+), 3 deletions(-) diff --git a/javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/JavaDSLSymbolTableCompleter.java b/javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/JavaDSLSymbolTableCompleter.java index be18bc02..b0b2a24a 100644 --- a/javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/JavaDSLSymbolTableCompleter.java +++ b/javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/JavaDSLSymbolTableCompleter.java @@ -112,10 +112,18 @@ public void endVisit(ASTConstructorDeclaration node) { IJavaDSLScope enclosingScope = JavaDSLMill.typeDispatcher().asJavaDSLIJavaDSLScope(node.getEnclosingScope()); ASTNode enclosingScopeNode = enclosingScope.getAstNode(); if (JavaDSLMill.typeDispatcher().isJavaDSLASTClassDeclaration(enclosingScopeNode)) { - ASTClassDeclaration enclosingClass = JavaDSLMill.typeDispatcher().asJavaDSLASTClassDeclaration(enclosingScopeNode); + ASTClassDeclaration enclosingClass = + JavaDSLMill.typeDispatcher().asJavaDSLASTClassDeclaration(enclosingScopeNode); symbol.setType(SymTypeExpressionFactory.createFromSymbol(enclosingClass.getSymbol())); - } else { - Log.error("0x7A004: Could not set ASTConstructorDeclaration type as it is not a direct child of a ASTClassDeclaration"); + } + else if (JavaDSLMill.typeDispatcher().isJavaDSLASTEnumDeclaration(enclosingScopeNode)) { + ASTEnumDeclaration enclosingEnum = + JavaDSLMill.typeDispatcher().asJavaDSLASTEnumDeclaration(enclosingScopeNode); + symbol.setType(SymTypeExpressionFactory.createFromSymbol(enclosingEnum.getSymbol())); + } + else { + Log.error( + "0x7A004: Could not set ASTConstructorDeclaration type as it is not a direct child of a ASTClassDeclaration"); } } From 63e042cf0edf6c13dc846556ed62cae8c52d91ae Mon Sep 17 00:00:00 2001 From: Janik Rapp Date: Thu, 28 Aug 2025 11:18:12 +0200 Subject: [PATCH 38/61] add cocos for LocalVariableDeclarations using var --- .../_cocos/VarNoCompoundDeclarationCoCo.java | 18 +++++++ .../_cocos/VarUsedWithoutInitializerCoCo.java | 22 ++++++++ .../VarNoCompoundDeclarationCoCoTest.java | 54 +++++++++++++++++++ .../VarUsedWithoutInitializerCoCoTest.java | 51 ++++++++++++++++++ 4 files changed, 145 insertions(+) create mode 100644 javaDSL/src/main/java/de/monticore/java/javadsl/_cocos/VarNoCompoundDeclarationCoCo.java create mode 100644 javaDSL/src/main/java/de/monticore/java/javadsl/_cocos/VarUsedWithoutInitializerCoCo.java create mode 100644 javaDSL/src/test/java/de/monticore/java/_cocos/VarNoCompoundDeclarationCoCoTest.java create mode 100644 javaDSL/src/test/java/de/monticore/java/_cocos/VarUsedWithoutInitializerCoCoTest.java diff --git a/javaDSL/src/main/java/de/monticore/java/javadsl/_cocos/VarNoCompoundDeclarationCoCo.java b/javaDSL/src/main/java/de/monticore/java/javadsl/_cocos/VarNoCompoundDeclarationCoCo.java new file mode 100644 index 00000000..ed8c29b4 --- /dev/null +++ b/javaDSL/src/main/java/de/monticore/java/javadsl/_cocos/VarNoCompoundDeclarationCoCo.java @@ -0,0 +1,18 @@ +package de.monticore.java.javadsl._cocos; + +import de.monticore.java.javadsl._ast.ASTLocalVariableDeclaration; +import de.se_rwth.commons.logging.Log; + +public class VarNoCompoundDeclarationCoCo implements JavaDSLASTLocalVariableDeclarationCoCo{ + + public static final String ERROR_CODE = "0x7A009"; + + public static final String ERROR_MSG_FORMAT = " 'var' is not allowed in a compound declaration"; + + @Override + public void check(ASTLocalVariableDeclaration node) { + if (node.isVar() && node.sizeVariableDeclarators() > 1) { + Log.error(ERROR_CODE + ERROR_MSG_FORMAT, node.get_SourcePositionStart()); + } + } +} diff --git a/javaDSL/src/main/java/de/monticore/java/javadsl/_cocos/VarUsedWithoutInitializerCoCo.java b/javaDSL/src/main/java/de/monticore/java/javadsl/_cocos/VarUsedWithoutInitializerCoCo.java new file mode 100644 index 00000000..bebbd247 --- /dev/null +++ b/javaDSL/src/main/java/de/monticore/java/javadsl/_cocos/VarUsedWithoutInitializerCoCo.java @@ -0,0 +1,22 @@ +package de.monticore.java.javadsl._cocos; + +import de.monticore.java.javadsl._ast.ASTLocalVariableDeclaration; +import de.monticore.statements.mcvardeclarationstatements._ast.ASTVariableDeclarator; +import de.se_rwth.commons.logging.Log; + +public class VarUsedWithoutInitializerCoCo implements JavaDSLASTLocalVariableDeclarationCoCo { + + public static final String ERROR_CODE = "0x7A010"; + + public static final String ERROR_MSG_FORMAT = " 'var' cannot be used without initializer"; + + @Override + public void check(ASTLocalVariableDeclaration node) { + if (node.isVar() && node.sizeVariableDeclarators() > 0) { + ASTVariableDeclarator variableDeclarator = node.getVariableDeclarator(0); + if (!variableDeclarator.isPresentVariableInit()) { + Log.error(ERROR_CODE + ERROR_MSG_FORMAT, node.get_SourcePositionStart()); + } + } + } +} diff --git a/javaDSL/src/test/java/de/monticore/java/_cocos/VarNoCompoundDeclarationCoCoTest.java b/javaDSL/src/test/java/de/monticore/java/_cocos/VarNoCompoundDeclarationCoCoTest.java new file mode 100644 index 00000000..32b98218 --- /dev/null +++ b/javaDSL/src/test/java/de/monticore/java/_cocos/VarNoCompoundDeclarationCoCoTest.java @@ -0,0 +1,54 @@ +package de.monticore.java._cocos; + + +import de.monticore.java.javadsl.JavaDSLMill; +import de.monticore.java.javadsl._ast.ASTJavaDSLNode; +import de.monticore.java.javadsl._ast.ASTLocalVariableDeclaration; +import de.monticore.java.javadsl._cocos.JavaDSLCoCoChecker; +import de.monticore.java.javadsl._cocos.VarNoCompoundDeclarationCoCo; +import de.monticore.runtime.junit.MCAssertions; +import de.monticore.runtime.junit.TestWithMCLanguage; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; + +import java.io.IOException; + +@TestWithMCLanguage(JavaDSLMill.class) +public class VarNoCompoundDeclarationCoCoTest { + + @ParameterizedTest + @ValueSource(strings = { + "String x", + "String x = \"Hello World\"", + "var x = \"Hello World\"", + "var x = 5", + "var x = true", + }) + public void testValidVarStatement(String input) throws IOException { + ASTLocalVariableDeclaration varDec = JavaDSLMill.parser().parse_StringLocalVariableDeclaration(input).orElseGet( + MCAssertions::failAndPrintFindings); + + JavaDSLCoCoChecker checker = new JavaDSLCoCoChecker(); + checker.addCoCo(new VarNoCompoundDeclarationCoCo()); + + checker.checkAll((ASTJavaDSLNode) varDec); + } + + @ParameterizedTest + @ValueSource(strings = { + "var x = 1, y = 2", + "var x = \"Hello\", y = \"World\"", + "var x = 1, y = 2, z = 3", + }) + public void testInvalidVarStatement(String input) throws IOException { + ASTLocalVariableDeclaration varDec = JavaDSLMill.parser().parse_StringLocalVariableDeclaration(input).orElseGet( + MCAssertions::failAndPrintFindings); + + JavaDSLCoCoChecker checker = new JavaDSLCoCoChecker(); + checker.addCoCo(new VarNoCompoundDeclarationCoCo()); + + checker.checkAll((ASTJavaDSLNode) varDec); + + MCAssertions.assertHasFindingStartingWith(VarNoCompoundDeclarationCoCo.ERROR_CODE); + } +} diff --git a/javaDSL/src/test/java/de/monticore/java/_cocos/VarUsedWithoutInitializerCoCoTest.java b/javaDSL/src/test/java/de/monticore/java/_cocos/VarUsedWithoutInitializerCoCoTest.java new file mode 100644 index 00000000..0fe363a6 --- /dev/null +++ b/javaDSL/src/test/java/de/monticore/java/_cocos/VarUsedWithoutInitializerCoCoTest.java @@ -0,0 +1,51 @@ +package de.monticore.java._cocos; + +import de.monticore.java.javadsl.JavaDSLMill; +import de.monticore.java.javadsl._ast.ASTJavaDSLNode; +import de.monticore.java.javadsl._ast.ASTLocalVariableDeclaration; +import de.monticore.java.javadsl._cocos.JavaDSLCoCoChecker; +import de.monticore.java.javadsl._cocos.VarUsedWithoutInitializerCoCo; +import de.monticore.runtime.junit.MCAssertions; +import de.monticore.runtime.junit.TestWithMCLanguage; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; + +import java.io.IOException; + +@TestWithMCLanguage(JavaDSLMill.class) +public class VarUsedWithoutInitializerCoCoTest { + @ParameterizedTest + @ValueSource(strings = { + "String x", + "String x = \"Hello World\"", + "var x = \"Hello World\"", + "var x = 5", + "var x = true", + }) + public void testValidVarStatement(String input) throws IOException { + ASTLocalVariableDeclaration + varDec = JavaDSLMill.parser().parse_StringLocalVariableDeclaration(input).orElseGet( + MCAssertions::failAndPrintFindings); + + JavaDSLCoCoChecker checker = new JavaDSLCoCoChecker(); + checker.addCoCo(new VarUsedWithoutInitializerCoCo()); + + checker.checkAll((ASTJavaDSLNode) varDec); + } + + @ParameterizedTest + @ValueSource(strings = { + "var x" + }) + public void testInvalidVarStatement(String input) throws IOException { + ASTLocalVariableDeclaration varDec = JavaDSLMill.parser().parse_StringLocalVariableDeclaration(input).orElseGet( + MCAssertions::failAndPrintFindings); + + JavaDSLCoCoChecker checker = new JavaDSLCoCoChecker(); + checker.addCoCo(new VarUsedWithoutInitializerCoCo()); + + checker.checkAll((ASTJavaDSLNode) varDec); + + MCAssertions.assertHasFindingStartingWith(VarUsedWithoutInitializerCoCo.ERROR_CODE); + } +} From 1e6b44077e764a193ff0fe607d2ce9c5f75685a8 Mon Sep 17 00:00:00 2001 From: Janik Rapp Date: Tue, 2 Sep 2025 14:48:26 +0200 Subject: [PATCH 39/61] override calculation of qualified names in IJavaDSLArtifactScope to support resolution of inner classes --- .../_symboltable/IJavaDSLArtifactScope.java | 61 +++++++++ .../JavaDSLArtifactScopeTest.java | 123 ++++++++++++++++++ 2 files changed, 184 insertions(+) create mode 100644 javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/IJavaDSLArtifactScope.java create mode 100644 javaDSL/src/test/java/de/monticore/java/_symboltable/JavaDSLArtifactScopeTest.java diff --git a/javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/IJavaDSLArtifactScope.java b/javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/IJavaDSLArtifactScope.java new file mode 100644 index 00000000..d21554a7 --- /dev/null +++ b/javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/IJavaDSLArtifactScope.java @@ -0,0 +1,61 @@ +package de.monticore.java.javadsl._symboltable; + +import com.google.common.collect.FluentIterable; +import de.monticore.symboltable.ImportStatement; +import de.se_rwth.commons.Splitters; + +import java.util.LinkedHashSet; +import java.util.List; +import java.util.Set; + +import static com.google.common.base.Preconditions.checkNotNull; +import static de.se_rwth.commons.Names.getQualifier; +import static de.se_rwth.commons.Names.getSimpleName; +import static de.se_rwth.commons.logging.Log.trace; + +public interface IJavaDSLArtifactScope extends IJavaDSLArtifactScopeTOP { + + @Override + default Set calculateQualifiedNames(String name, String packageName, + List imports) { + final Set potentialSymbolNames = new LinkedHashSet<>(); + + // the simple name (in default package) + potentialSymbolNames.add(name); + + // maybe the model belongs to the same package + if (!packageName.isEmpty()) { + potentialSymbolNames.add(packageName + "." + name); + } + + for (ImportStatement importStatement : imports) { + if (importStatement.isStar()) { + potentialSymbolNames.add(importStatement.getStatement() + "." + name); + } + else if (getSimpleName(importStatement.getStatement()).equals(name)) { + potentialSymbolNames.add(importStatement.getStatement()); + } + else if (getSimpleName(importStatement.getStatement()).equals(getFirstQualifier(name))) { + potentialSymbolNames.add(getQualifier(importStatement.getStatement()) + "." + name); + } + } + trace("Potential qualified names for \"" + name + "\": " + potentialSymbolNames.toString(), + "IArtifactScope"); + + return potentialSymbolNames; + } + + /** + * @return The first part of the given qualified name (e.g. "a" from + * "a.b.c.Name"). Leading or trailing dots are ignored. + */ + default String getFirstQualifier(String qualifiedName) { + + checkNotNull(qualifiedName); + + FluentIterable parts = FluentIterable.from( + Splitters.DOT.split(qualifiedName)); + + return parts.first().get(); + } +} diff --git a/javaDSL/src/test/java/de/monticore/java/_symboltable/JavaDSLArtifactScopeTest.java b/javaDSL/src/test/java/de/monticore/java/_symboltable/JavaDSLArtifactScopeTest.java new file mode 100644 index 00000000..a8b5b217 --- /dev/null +++ b/javaDSL/src/test/java/de/monticore/java/_symboltable/JavaDSLArtifactScopeTest.java @@ -0,0 +1,123 @@ +package de.monticore.java._symboltable; + +import de.monticore.java.javadsl._symboltable.JavaDSLArtifactScope; +import de.monticore.symboltable.ImportStatement; +import org.junit.jupiter.api.Test; + +import java.util.List; +import java.util.Set; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertIterableEquals; + +public class JavaDSLArtifactScopeTest { + + @Test + void testImports1() { + JavaDSLArtifactScope scope = new JavaDSLArtifactScope(); + String name = "List"; + String packageName = "de.monticore.java._symboltable"; + List imports = List.of(new ImportStatement("java.util", true)); + Set calculatedQualifiedNames = + scope.calculateQualifiedNames(name, packageName, imports); + + List expectedQualifiedNames = + List.of(name, packageName + "." + name, "java.util.List"); + assertEquals(expectedQualifiedNames.size(), calculatedQualifiedNames.size()); + assertIterableEquals(expectedQualifiedNames, calculatedQualifiedNames); + } + + @Test + void testImports2() { + JavaDSLArtifactScope scope = new JavaDSLArtifactScope(); + String name = "List"; + String packageName = "de.monticore.java._symboltable"; + List imports = List.of(new ImportStatement("java.util.Iterator", false), + new ImportStatement("java.util.List", false), new ImportStatement("java.util.Set", false)); + Set calculatedQualifiedNames = + scope.calculateQualifiedNames(name, packageName, imports); + + List expectedQualifiedNames = + List.of(name, packageName + "." + name, "java.util.List"); + assertEquals(expectedQualifiedNames.size(), calculatedQualifiedNames.size()); + assertIterableEquals(expectedQualifiedNames, calculatedQualifiedNames); + } + + @Test + void testImports3() { + JavaDSLArtifactScope scope = new JavaDSLArtifactScope(); + String name = "Map"; + String packageName = "de.monticore.java._symboltable"; + List imports = List.of(new ImportStatement("java.util.Map", false)); + Set calculatedQualifiedNames = + scope.calculateQualifiedNames(name, packageName, imports); + + List expectedQualifiedNames = + List.of(name, packageName + "." + name, "java.util.Map"); + assertEquals(expectedQualifiedNames.size(), calculatedQualifiedNames.size()); + assertIterableEquals(expectedQualifiedNames, calculatedQualifiedNames); + } + + @Test + void testImports4() { + JavaDSLArtifactScope scope = new JavaDSLArtifactScope(); + String name = "Map.Entry"; + String packageName = "de.monticore.java._symboltable"; + List imports = List.of(new ImportStatement("java.util", true)); + Set calculatedQualifiedNames = + scope.calculateQualifiedNames(name, packageName, imports); + + List expectedQualifiedNames = + List.of(name, packageName + "." + name, "java.util.Map.Entry"); + assertEquals(expectedQualifiedNames.size(), calculatedQualifiedNames.size()); + assertIterableEquals(expectedQualifiedNames, calculatedQualifiedNames); + } + + @Test + void testImports5() { + JavaDSLArtifactScope scope = new JavaDSLArtifactScope(); + String name = "Map.Entry"; + String packageName = "de.monticore.java._symboltable"; + List imports = List.of(new ImportStatement("java.util.Map", false), + new ImportStatement("java.util.List", false), new ImportStatement("java.util.Set", false)); + Set calculatedQualifiedNames = + scope.calculateQualifiedNames(name, packageName, imports); + + List expectedQualifiedNames = + List.of(name, packageName + "." + name, "java.util.Map.Entry"); + assertEquals(expectedQualifiedNames.size(), calculatedQualifiedNames.size()); + assertIterableEquals(expectedQualifiedNames, calculatedQualifiedNames); + } + + @Test + void testImports6() { + JavaDSLArtifactScope scope = new JavaDSLArtifactScope(); + String name = "Map.Entry"; + String packageName = "de.monticore.java._symboltable"; + List imports = List.of(new ImportStatement("java.util.Map.Entry", false), + new ImportStatement("java.util.List", false), new ImportStatement("java.util.Set", false)); + Set calculatedQualifiedNames = + scope.calculateQualifiedNames(name, packageName, imports); + + List expectedQualifiedNames = + List.of(name, packageName + "." + name); + assertEquals(expectedQualifiedNames.size(), calculatedQualifiedNames.size()); + assertIterableEquals(expectedQualifiedNames, calculatedQualifiedNames); + } + + @Test + void testImports7() { + JavaDSLArtifactScope scope = new JavaDSLArtifactScope(); + String name = "X.Y.Z"; + String packageName = "de.monticore.java._symboltable"; + List imports = List.of(new ImportStatement("A.B", false), + new ImportStatement("A.B.C", false), new ImportStatement("A.B.C.X", false)); + Set calculatedQualifiedNames = + scope.calculateQualifiedNames(name, packageName, imports); + + List expectedQualifiedNames = + List.of(name, packageName + "." + name, "A.B.C.X.Y.Z"); + assertEquals(expectedQualifiedNames.size(), calculatedQualifiedNames.size()); + assertIterableEquals(expectedQualifiedNames, calculatedQualifiedNames); + } +} From f6302037a9b3d41160e1e61f8234ae11697415bf Mon Sep 17 00:00:00 2001 From: Janik Rapp Date: Tue, 2 Sep 2025 14:51:33 +0200 Subject: [PATCH 40/61] override endVisit for inherited LocalVariableDeclarations to prevent unintended type recalculation --- ...DeclarationStatementsSymTabCompletion.java | 26 ++++++++++++++----- 1 file changed, 20 insertions(+), 6 deletions(-) diff --git a/javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/JavaDSLMCVarDeclarationStatementsSymTabCompletion.java b/javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/JavaDSLMCVarDeclarationStatementsSymTabCompletion.java index 95ef25f1..e0b035d6 100644 --- a/javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/JavaDSLMCVarDeclarationStatementsSymTabCompletion.java +++ b/javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/JavaDSLMCVarDeclarationStatementsSymTabCompletion.java @@ -12,8 +12,8 @@ import de.monticore.types3.TypeCheck3; import de.se_rwth.commons.logging.Log; -public class JavaDSLMCVarDeclarationStatementsSymTabCompletion extends - MCVarDeclarationStatementsSymTabCompletion implements JavaDSLVisitor2 { +public class JavaDSLMCVarDeclarationStatementsSymTabCompletion + extends MCVarDeclarationStatementsSymTabCompletion implements JavaDSLVisitor2 { @Override public void endVisit(ASTLocalVariableDeclaration node) { @@ -21,13 +21,15 @@ public void endVisit(ASTLocalVariableDeclaration node) { // we assume that there is just a single VariableDeclarator, as a CoCo prevents the // declaration of multiple variables with a single var ASTVariableDeclarator declarator = node.getVariableDeclarator(0); - ASTVariableInit variableInit = declarator.getVariableInit(); + ASTVariableInit variableInit = declarator.getVariableInit(); SymTypeExpression targetType = SymTypeExpressionFactory.createObscureType(); if (JavaDSLMill.typeDispatcher().isMCVarDeclarationStatementsASTSimpleInit(variableInit)) { - ASTSimpleInit simpleInit = JavaDSLMill.typeDispatcher().asMCVarDeclarationStatementsASTSimpleInit(variableInit); + ASTSimpleInit simpleInit = + JavaDSLMill.typeDispatcher().asMCVarDeclarationStatementsASTSimpleInit(variableInit); targetType = TypeCheck3.typeOf(simpleInit.getExpression()); - } else { + } + else { Log.error("0x7A001: Unsupported ASTVariableInit type"); } @@ -35,8 +37,20 @@ public void endVisit(ASTLocalVariableDeclaration node) { Log.error("0x7A002: Could not determine type of 'var' variable"); } declarator.getDeclarator().getSymbol().setType(targetType); - } else { + } + else { super.endVisit(node); } } + + @Override + public void endVisit( + de.monticore.statements.mcvardeclarationstatements._ast.ASTLocalVariableDeclaration node) { + if (!node.isEmptyVariableDeclarators()) { + ASTVariableDeclarator declarator = node.getVariableDeclarator(0); + if (declarator.getDeclarator().getSymbol().getType() == null) { + super.endVisit(node); + } + } + } } From dd84d04df00fb73fe155bf2dbe0c6c966fcc86d5 Mon Sep 17 00:00:00 2001 From: Janik Rapp Date: Wed, 3 Sep 2025 10:05:56 +0200 Subject: [PATCH 41/61] add overridden MCBasicTypesTypeVisitor to resolve non-static (inner) types --- .../JavaDSLMCBasicTypesTypeVisitor.java | 93 +++++++++++++++++++ .../javadsl/types3/JavaDSLTypeCheck3.java | 6 +- 2 files changed, 96 insertions(+), 3 deletions(-) create mode 100644 javaDSL/src/main/java/de/monticore/java/javadsl/types3/JavaDSLMCBasicTypesTypeVisitor.java diff --git a/javaDSL/src/main/java/de/monticore/java/javadsl/types3/JavaDSLMCBasicTypesTypeVisitor.java b/javaDSL/src/main/java/de/monticore/java/javadsl/types3/JavaDSLMCBasicTypesTypeVisitor.java new file mode 100644 index 00000000..98a7f748 --- /dev/null +++ b/javaDSL/src/main/java/de/monticore/java/javadsl/types3/JavaDSLMCBasicTypesTypeVisitor.java @@ -0,0 +1,93 @@ +package de.monticore.java.javadsl.types3; + +import de.monticore.symbols.basicsymbols._symboltable.IBasicSymbolsScope; +import de.monticore.types.check.SymTypeExpression; +import de.monticore.types.check.SymTypeExpressionFactory; +import de.monticore.types.mcbasictypes._ast.ASTMCQualifiedName; +import de.monticore.types.mcbasictypes.types3.MCBasicTypesTypeVisitor; +import de.monticore.types3.util.TypeContextCalculator; +import de.monticore.types3.util.WithinScopeBasicSymbolsResolver; +import de.monticore.types3.util.WithinTypeBasicSymbolsResolver; +import de.se_rwth.commons.logging.Log; + +import java.util.Optional; +import java.util.stream.Collectors; + +public class JavaDSLMCBasicTypesTypeVisitor extends MCBasicTypesTypeVisitor { + + @Override + public void endVisit(ASTMCQualifiedName qName) { + IBasicSymbolsScope enclosingScope = + getAsBasicSymbolsScope(qName.getEnclosingScope()); + // Note: As the qualified name is a List of Names, + // There is no ASTNode representing each prefix with a type, + // e.g., Assume a.b.c with a being a qualifier, a.b being a type + // and c being an inner type in a.b + // then there is no AST node representing a.b. + // As types are usually stored in Type4AST, + // this cannot be done for a.b in this case. + // The result from a.b will be discarded after this method + + // find the type with the smallest prefix, + // e.g., for a.b.c.d it is a.b, if a.b and a.b.c are types, + // with a and a.b being their qualifiers respectively. + // Afterwards, use the prefix to search for inner types + int numberOfPartsUsedForFirstType = 0; + Optional type = Optional.empty(); + do { + numberOfPartsUsedForFirstType++; + if (type.isEmpty()) { + String prefix = qName.getPartsList().stream() + .limit(numberOfPartsUsedForFirstType) + .collect(Collectors.joining(".")); + type = WithinScopeBasicSymbolsResolver + .resolveType(enclosingScope, prefix); + } + else { + SymTypeExpression prefixType = type.get(); + String name = qName.getParts(numberOfPartsUsedForFirstType - 1); + if (prefixType.isObjectType() || prefixType.isGenericType()) { + type = WithinTypeBasicSymbolsResolver.resolveType( + prefixType, + name, + TypeContextCalculator.getAccessModifier( + prefixType.getTypeInfo(), + enclosingScope, + false // <- difference to the endVisit in the original MCBasicTypesTypeVisitor + ), + t -> true + ); + if (type.isEmpty()) { + Log.error("0x7A012 unable to find type " + + name + + " within type " + + prefixType.printFullName(), + qName.get_SourcePositionStart(), + qName.get_SourcePositionEnd() + ); + } + } + else { + Log.error("0x7A010 unexpected access \"." + + name + + "\" for type " + + prefixType.printFullName(), + qName.get_SourcePositionStart(), + qName.get_SourcePositionEnd() + ); + } + } + + } while (numberOfPartsUsedForFirstType < qName.sizeParts()); + + if (type.isEmpty()) { + Log.error("0x7A011 Cannot find symbol " + qName.getQName(), + qName.get_SourcePositionStart(), + qName.get_SourcePositionEnd() + ); + type = Optional.of(SymTypeExpressionFactory.createObscureType()); + } + + getType4Ast().setTypeOfTypeIdentifier(qName, type.get()); + } +} diff --git a/javaDSL/src/main/java/de/monticore/java/javadsl/types3/JavaDSLTypeCheck3.java b/javaDSL/src/main/java/de/monticore/java/javadsl/types3/JavaDSLTypeCheck3.java index 557a3ee3..7e948918 100644 --- a/javaDSL/src/main/java/de/monticore/java/javadsl/types3/JavaDSLTypeCheck3.java +++ b/javaDSL/src/main/java/de/monticore/java/javadsl/types3/JavaDSLTypeCheck3.java @@ -87,9 +87,9 @@ public static void init(){ // MCTypes - MCBasicTypesTypeVisitor visMCBasicTypes = new MCBasicTypesTypeVisitor(); - visMCBasicTypes.setType4Ast(type4Ast); - traverser.add4MCBasicTypes(visMCBasicTypes); + JavaDSLMCBasicTypesTypeVisitor visJavaDSLMCBasicTypesType = new JavaDSLMCBasicTypesTypeVisitor(); + visJavaDSLMCBasicTypesType.setType4Ast(type4Ast); + traverser.add4MCBasicTypes(visJavaDSLMCBasicTypesType); MCCollectionTypesTypeVisitor visMCCollectionTypes = new MCCollectionTypesTypeVisitor(); visMCCollectionTypes.setType4Ast(type4Ast); From 3b8ced4084db7e9645f29907ab071e4749eb411f Mon Sep 17 00:00:00 2001 From: Janik Rapp Date: Tue, 9 Sep 2025 14:24:49 +0200 Subject: [PATCH 42/61] remove custom java productions in favour of imported library productions --- .../grammars/de/monticore/java/JavaDSL.mc4 | 39 ++----------------- .../reporting/JavaDSLNodeIdentHelper.java | 9 +++-- .../de/monticore/java/JavaDSLParserTest.java | 4 +- 3 files changed, 10 insertions(+), 42 deletions(-) diff --git a/javaDSL/src/main/grammars/de/monticore/java/JavaDSL.mc4 b/javaDSL/src/main/grammars/de/monticore/java/JavaDSL.mc4 index 8fa92f45..1e663ad8 100644 --- a/javaDSL/src/main/grammars/de/monticore/java/JavaDSL.mc4 +++ b/javaDSL/src/main/grammars/de/monticore/java/JavaDSL.mc4 @@ -243,7 +243,7 @@ EnumBody ; ClassBlock implements ClassBodyDeclaration - = (["static"])? JavaBlock + = (["static"])? MCJavaBlock ; @Override @@ -338,35 +338,9 @@ MCQualifiedType implements MCObjectType // STATEMENTS / BLOCKS -// TODO: Remove Java-specific Interfaces, reuse component grammars and use CoCos for validation? -interface Statement extends MCBlockStatement ; - // TODO: Remove scope duplicate when monticore#4726 is fixed -scope(shadowing) JavaBlock implements Statement, MethodBody, ConstructorBody, FinallyBlock - = "{" MCBlockStatement* "}" - ; - -scope TryStatement implements Statement - = "try" JavaBlock ExceptionHandler - ; - -interface ExceptionHandler ; - -CatchExceptionsHandler implements ExceptionHandler - = CatchClause+ ("finally" FinallyBlock)? - ; - -FinallyBlockOnlyHandler implements ExceptionHandler - = ("finally" FinallyBlock) - ; - -TryStatementWithResources implements Statement - = "try" "(" (Resource || ";")+ ";"? ")" JavaBlock CatchClause* ("finally" FinallyBlock)? - ; - -Resource - = JavaModifier* MCType DeclaratorId "=" Expression - ; +@Override +scope(shadowing) MCJavaBlock implements MethodBody, ConstructorBody; IdentifierAndTypeArgument = Name TypeArguments? @@ -376,13 +350,6 @@ TypeArguments = "<" (MCTypeArgument || ",")* ">" ; -interface FinallyBlock ; - -// TODO: Replace with Label from MCLowLevelStatements -LabeledStatement implements Statement - = label:Name ":" Statement - ; - CreatedName = (IdentifierAndTypeArgument || ".")+ | MCPrimitiveType diff --git a/javaDSL/src/main/java/de/monticore/java/reporting/JavaDSLNodeIdentHelper.java b/javaDSL/src/main/java/de/monticore/java/reporting/JavaDSLNodeIdentHelper.java index 87677896..496e496f 100644 --- a/javaDSL/src/main/java/de/monticore/java/reporting/JavaDSLNodeIdentHelper.java +++ b/javaDSL/src/main/java/de/monticore/java/reporting/JavaDSLNodeIdentHelper.java @@ -14,6 +14,7 @@ import de.monticore.literals.mcjavaliterals._ast.ASTIntLiteral; import de.monticore.statements.mccommonstatements._ast.ASTEnumConstantSwitchLabel; import de.monticore.statements.mccommonstatements._ast.ASTFormalParameter; +import de.monticore.statements.mclowlevelstatements._ast.ASTLabel; import de.monticore.statements.mcvardeclarationstatements._ast.ASTDeclaratorId; import de.monticore.statements.mcvardeclarationstatements._ast.ASTVariableDeclarator; import de.monticore.types.mcbasictypes._ast.ASTMCPrimitiveType; @@ -103,9 +104,9 @@ public String getIdent(ASTAnnotationMethod a) { return format(name, type); } - public String getIdent(ASTLabeledStatement a) { + public String getIdent(ASTLabel a) { String type = Layouter.nodeName(a); - String name = a.getLabel(); + String name = a.getName(); return format(name, type); } @@ -178,8 +179,8 @@ else if (a instanceof ASTEnumConstantSwitchLabel) { else if (a instanceof ASTIdentifierAndTypeArgument) { return getIdent((ASTIdentifierAndTypeArgument) a); } - else if (a instanceof ASTLabeledStatement) { - return getIdent((ASTLabeledStatement) a); + else if (a instanceof ASTLabel) { + return getIdent((ASTLabel) a); } else if (a instanceof ASTLastFormalParameter) { return getIdent((ASTLastFormalParameter) a); diff --git a/javaDSL/src/test/java/de/monticore/java/JavaDSLParserTest.java b/javaDSL/src/test/java/de/monticore/java/JavaDSLParserTest.java index b83289f6..8d22972a 100644 --- a/javaDSL/src/test/java/de/monticore/java/JavaDSLParserTest.java +++ b/javaDSL/src/test/java/de/monticore/java/JavaDSLParserTest.java @@ -3,7 +3,7 @@ import de.monticore.expressions.expressionsbasis._ast.ASTExpression; import de.monticore.java.javadsl.JavaDSLMill; -import de.monticore.java.javadsl._ast.ASTJavaBlock; +import de.monticore.java.javadsl._ast.ASTMCJavaBlock; import de.monticore.java.javadsl._ast.ASTTextBlockLiteral; import de.monticore.java.javadsl._parser.JavaDSLParser; import de.monticore.literals.mcliteralsbasis._ast.ASTLiteral; @@ -45,7 +45,7 @@ public void testJavaBlock() throws IOException { buffer.append("}"); buffer.append("} "); JavaDSLParser parser = JavaDSLMill.parser(); - Optional ast = parser.parseJavaBlock(new StringReader(buffer.toString())); + Optional ast = parser.parseMCJavaBlock(new StringReader(buffer.toString())); assertFalse(parser.hasErrors()); assertTrue(ast.isPresent()); } From e1d7b0c92e75769bd0205d0910489e202831cc8b Mon Sep 17 00:00:00 2001 From: Janik Rapp Date: Tue, 9 Sep 2025 14:25:23 +0200 Subject: [PATCH 43/61] reintroduce missing InnerCreatorExpression --- javaDSL/src/main/grammars/de/monticore/java/JavaDSL.mc4 | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/javaDSL/src/main/grammars/de/monticore/java/JavaDSL.mc4 b/javaDSL/src/main/grammars/de/monticore/java/JavaDSL.mc4 index 1e663ad8..ffb60db6 100644 --- a/javaDSL/src/main/grammars/de/monticore/java/JavaDSL.mc4 +++ b/javaDSL/src/main/grammars/de/monticore/java/JavaDSL.mc4 @@ -355,6 +355,11 @@ CreatedName | MCPrimitiveType ; +// TODO: might need some attention...can we do that better? +InnerCreatorExpression implements Expression <275> + = Expression "." "new" InnerCreator + ; + InnerCreator = firstTypeArguments:TypeArguments? Name secondTypeArguments:TypeArguments? ClassCreatorRest ; From dd515e40c36875496dfc58466a1b1bd2f60facc8 Mon Sep 17 00:00:00 2001 From: Janik Rapp Date: Tue, 9 Sep 2025 14:27:57 +0200 Subject: [PATCH 44/61] set basic type symbol properties in the genitor instead of symtab completion --- .../_symboltable/JavaDSLScopesGenitor.java | 107 +++++++++++++----- .../JavaDSLSymbolTableCompleter.java | 41 ------- 2 files changed, 79 insertions(+), 69 deletions(-) diff --git a/javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/JavaDSLScopesGenitor.java b/javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/JavaDSLScopesGenitor.java index 69d9b008..7c9c03de 100644 --- a/javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/JavaDSLScopesGenitor.java +++ b/javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/JavaDSLScopesGenitor.java @@ -3,9 +3,12 @@ import de.monticore.java.javadsl.JavaDSLMill; import de.monticore.java.javadsl._ast.*; import de.monticore.statements.mccommonstatements._ast.ASTConstantsMCCommonStatements; +import de.monticore.statements.mccommonstatements._ast.ASTJavaModifier; +import de.monticore.symbols.oosymbols._symboltable.OOTypeSymbol; import de.monticore.symboltable.ImportStatement; public final class JavaDSLScopesGenitor extends JavaDSLScopesGenitorTOP { +import java.util.List; @Override public IJavaDSLArtifactScope createFromAST(ASTCompilationUnit rootNode) { @@ -40,52 +43,49 @@ public IJavaDSLArtifactScope createFromAST(ASTCompilationUnit rootNode) { @Override public void visit(ASTClassDeclaration node) { super.visit(node); - if (node.getJavaModifierList().stream() - .anyMatch(x -> x.getModifier() == ASTConstantsMCCommonStatements.PUBLIC)) { - IJavaDSLScope enclosingScope = node.getEnclosingScope(); - if (JavaDSLMill.typeDispatcher().isJavaDSLIJavaDSLArtifactScope(enclosingScope)) { - enclosingScope.setName(node.getName()); - } - } + TypeDeclarationSymbol symbol = node.getSymbol(); + symbol.setIsClass(true); + + tryToUpdateScopeName(node, node.getJavaModifierList()); + updateModifiers(symbol, node.getJavaModifierList()); } @Override public void visit(ASTRecordDeclaration node) { super.visit(node); - if (node.getJavaModifierList().stream() - .anyMatch(x -> x.getModifier() == ASTConstantsMCCommonStatements.PUBLIC)) { - IJavaDSLScope enclosingScope = node.getEnclosingScope(); - if (JavaDSLMill.typeDispatcher().isJavaDSLIJavaDSLArtifactScope(enclosingScope)) { - enclosingScope.setName(node.getName()); - } - } + + TypeDeclarationSymbol symbol = node.getSymbol(); + symbol.setIsRecord(true); + + tryToUpdateScopeName(node, node.getJavaModifierList()); + updateModifiers(symbol, node.getJavaModifierList()); } @Override public void visit(ASTInterfaceDeclaration node) { super.visit(node); - if (node.getJavaModifierList().stream() - .anyMatch(x -> x.getModifier() == ASTConstantsMCCommonStatements.PUBLIC)) { - IJavaDSLScope enclosingScope = node.getEnclosingScope(); - if (JavaDSLMill.typeDispatcher().isJavaDSLIJavaDSLArtifactScope(enclosingScope)) { - enclosingScope.setName(node.getName()); - } - } + + TypeDeclarationSymbol symbol = node.getSymbol(); + symbol.setIsInterface(true); + + tryToUpdateScopeName(node, node.getJavaModifierList()); + updateModifiers(symbol, node.getJavaModifierList()); } @Override public void visit(ASTEnumDeclaration node) { super.visit(node); - if (node.getJavaModifierList().stream() - .anyMatch(x -> x.getModifier() == ASTConstantsMCCommonStatements.PUBLIC)) { - IJavaDSLScope enclosingScope = node.getEnclosingScope(); - if (JavaDSLMill.typeDispatcher().isJavaDSLIJavaDSLArtifactScope(enclosingScope)) { - enclosingScope.setName(node.getName()); - } - } + + TypeDeclarationSymbol symbol = node.getSymbol(); + symbol.setIsEnum(true); + + tryToUpdateScopeName(node, node.getJavaModifierList()); + updateModifiers(symbol, node.getJavaModifierList()); } + + @Override public void visit(ASTModuleDeclaration node) { super.visit(node); @@ -94,4 +94,55 @@ public void visit(ASTModuleDeclaration node) { enclosingScope.setName(node.getName()); } } + + @Override + public void visit(ASTAnnotationTypeDeclaration node) { + super.visit(node); + + TypeDeclarationSymbol symbol = node.getSymbol(); + symbol.setIsAnnotation(true); + + tryToUpdateScopeName(node, node.getJavaModifierList()); + updateModifiers(symbol, node.getJavaModifierList()); + } + + /** + * Try to set the name of the ArtifactScope + * The name of the artifact scope should equal the name of + * a public type. + * @param node Candidate for public type + * @param modifiers List of node's modifiers + */ + private void tryToUpdateScopeName(ASTTypeDeclaration node, List modifiers) { + if (modifiers.stream() + .anyMatch(x -> x.getModifier() == ASTConstantsMCCommonStatements.PUBLIC)) { + IJavaDSLScope enclosingScope = node.getEnclosingScope(); + if (JavaDSLMill.typeDispatcher().isJavaDSLIJavaDSLArtifactScope(enclosingScope)) { + enclosingScope.setName(node.getName()); + } + } + } + + private void updateModifiers(OOTypeSymbol symbol, List modifiers) { + modifiers.forEach(javaModifier -> { + if (javaModifier.getModifier() == ASTConstantsMCCommonStatements.PUBLIC) { + symbol.setIsPublic(true); + } + else if (javaModifier.getModifier() == ASTConstantsMCCommonStatements.PROTECTED) { + symbol.setIsProtected(true); + } + else if (javaModifier.getModifier() == ASTConstantsMCCommonStatements.PRIVATE) { + symbol.setIsPrivate(true); + } + else if (javaModifier.getModifier() == ASTConstantsMCCommonStatements.ABSTRACT) { + symbol.setIsAbstract(true); + } + else if (javaModifier.getModifier() == ASTConstantsMCCommonStatements.STATIC) { + symbol.setIsStatic(true); + } + else if (javaModifier.getModifier() == ASTConstantsMCCommonStatements.FINAL) { + symbol.setIsFinal(true); + } + }); + } } diff --git a/javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/JavaDSLSymbolTableCompleter.java b/javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/JavaDSLSymbolTableCompleter.java index b0b2a24a..a7573920 100644 --- a/javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/JavaDSLSymbolTableCompleter.java +++ b/javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/JavaDSLSymbolTableCompleter.java @@ -39,20 +39,9 @@ public class JavaDSLSymbolTableCompleter implements JavaDSLVisitor2, JavaLightVisitor2 { - @Override - public void endVisit(ASTAnnotationTypeDeclaration node) { - TypeDeclarationSymbol symbol = node.getSymbol(); - symbol.setIsAnnotation(true); - - updateModifiers(symbol, node.getJavaModifierList()); - } - @Override public void endVisit(ASTEnumDeclaration node) { TypeDeclarationSymbol symbol = node.getSymbol(); - symbol.setIsEnum(true); - - updateModifiers(symbol, node.getJavaModifierList()); List supertypes = node.getImplementedInterfaceList().stream().map(TypeCheck3::symTypeFromAST) @@ -64,10 +53,6 @@ public void endVisit(ASTEnumDeclaration node) { public void endVisit(ASTRecordDeclaration node) { TypeDeclarationSymbol symbol = node.getSymbol(); - symbol.setIsRecord(true); - - updateModifiers(symbol, node.getJavaModifierList()); - List supertypes = node.getImplementedInterfaceList().stream().map(TypeCheck3::symTypeFromAST) .collect(Collectors.toList()); @@ -130,9 +115,6 @@ else if (JavaDSLMill.typeDispatcher().isJavaDSLASTEnumDeclaration(enclosingScope @Override public void endVisit(ASTClassDeclaration node) { TypeDeclarationSymbol symbol = node.getSymbol(); - symbol.setIsClass(true); - - updateModifiers(symbol, node.getJavaModifierList()); List supertypes = new ArrayList<>(); if (node.isPresentSuperClass()) { @@ -242,27 +224,4 @@ protected void addModifiersToMethOrConstr(JavaMethodSymbol javaMethodSymbol, } } } - - protected void updateModifiers(OOTypeSymbol symbol, List modifiers) { - modifiers.forEach(javaModifier -> { - if (javaModifier.getModifier() == ASTConstantsMCCommonStatements.PUBLIC) { - symbol.setIsPublic(true); - } - else if (javaModifier.getModifier() == ASTConstantsMCCommonStatements.PROTECTED) { - symbol.setIsProtected(true); - } - else if (javaModifier.getModifier() == ASTConstantsMCCommonStatements.PRIVATE) { - symbol.setIsPrivate(true); - } - else if (javaModifier.getModifier() == ASTConstantsMCCommonStatements.ABSTRACT) { - symbol.setIsAbstract(true); - } - else if (javaModifier.getModifier() == ASTConstantsMCCommonStatements.STATIC) { - symbol.setIsStatic(true); - } - else if (javaModifier.getModifier() == ASTConstantsMCCommonStatements.FINAL) { - symbol.setIsFinal(true); - } - }); - } } From d275d8148b4129bed974c9a66a7f08b49423f12e Mon Sep 17 00:00:00 2001 From: Janik Rapp Date: Tue, 9 Sep 2025 15:54:39 +0200 Subject: [PATCH 45/61] rework SymTab completion for `var` types and add a third genitor phase --- .../grammars/de/monticore/java/JavaDSL.mc4 | 11 +++ .../monticore/java/javadsl/JavaDSLMill.java | 38 ++++++++ ...DSLMCCommonStatementsSymTabCompletion.java | 19 ++++ ...DeclarationStatementsSymTabCompletion.java | 46 +++------- .../_symboltable/JavaDSLScopesGenitor.java | 12 ++- .../_symboltable/JavaDSLScopesGenitorP3.java | 89 +++++++++++++++++++ .../JavaDSLScopesGenitorP3Delegator.java | 37 ++++++++ .../JavaDSLSymbolTableCompleter.java | 26 ++++-- .../java/utils/JavaDSLSymbolTableUtil.java | 17 ++-- 9 files changed, 242 insertions(+), 53 deletions(-) create mode 100644 javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/JavaDSLMCCommonStatementsSymTabCompletion.java create mode 100644 javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/JavaDSLScopesGenitorP3.java create mode 100644 javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/JavaDSLScopesGenitorP3Delegator.java diff --git a/javaDSL/src/main/grammars/de/monticore/java/JavaDSL.mc4 b/javaDSL/src/main/grammars/de/monticore/java/JavaDSL.mc4 index ffb60db6..4b639c80 100644 --- a/javaDSL/src/main/grammars/de/monticore/java/JavaDSL.mc4 +++ b/javaDSL/src/main/grammars/de/monticore/java/JavaDSL.mc4 @@ -376,6 +376,17 @@ LocalVariableDeclaration @Override LambdaParameter implements Variable = (["var"] | MCType)? Name; +@Override +TryLocalVariableDeclaration + = JavaModifier* (["var"] | MCType) DeclaratorId "=" Expression ; + +@Override +EnhancedForControl implements ForControl + = EnhancedForControlFormalParameter ":" Expression; + +EnhancedForControlFormalParameter + = JavaModifier* (["var"] | MCType) Declarator; + nokeyword "var"; /* diff --git a/javaDSL/src/main/java/de/monticore/java/javadsl/JavaDSLMill.java b/javaDSL/src/main/java/de/monticore/java/javadsl/JavaDSLMill.java index de1f91da..402f0eb3 100644 --- a/javaDSL/src/main/java/de/monticore/java/javadsl/JavaDSLMill.java +++ b/javaDSL/src/main/java/de/monticore/java/javadsl/JavaDSLMill.java @@ -1,17 +1,55 @@ package de.monticore.java.javadsl; +import de.monticore.java.javadsl._symboltable.JavaDSLScopesGenitorP3; +import de.monticore.java.javadsl._symboltable.JavaDSLScopesGenitorP3Delegator; import de.monticore.java.javadsl.types3.JavaDSLTypeCheck3; public class JavaDSLMill extends JavaDSLMillTOP { + protected static JavaDSLMill millJavaDSLScopesGenitorP3; + + protected static JavaDSLMill millJavaDSLScopesGenitorP3Delegator; + + public static JavaDSLScopesGenitorP3 scopesGenitorP3() { + if (millJavaDSLScopesGenitorP3 == null) { + millJavaDSLScopesGenitorP3 = getMill(); + } + return millJavaDSLScopesGenitorP3._scopesGenitorP3(); + } + + protected JavaDSLScopesGenitorP3 _scopesGenitorP3() { + return new JavaDSLScopesGenitorP3(); + } + + public static JavaDSLScopesGenitorP3Delegator scopesGenitorP3Delegator() { + if (millJavaDSLScopesGenitorP3Delegator == null) { + millJavaDSLScopesGenitorP3Delegator = getMill(); + } + return millJavaDSLScopesGenitorP3Delegator._scopesGenitorP3Delegator(); + } + + protected JavaDSLScopesGenitorP3Delegator _scopesGenitorP3Delegator() { + return new JavaDSLScopesGenitorP3Delegator(); + } + + + /** additionally inits the TypeCheck */ public static void init() { JavaDSLMillTOP.init(); JavaDSLTypeCheck3.init(); } + public static void initMe(JavaDSLMill a) { + JavaDSLMillTOP.initMe(a); + millJavaDSLScopesGenitorP3 = a; + millJavaDSLScopesGenitorP3Delegator = a; + } + public static void reset() { JavaDSLMillTOP.reset(); JavaDSLTypeCheck3.reset(); + millJavaDSLScopesGenitorP3 = null; + millJavaDSLScopesGenitorP3Delegator = null; } } diff --git a/javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/JavaDSLMCCommonStatementsSymTabCompletion.java b/javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/JavaDSLMCCommonStatementsSymTabCompletion.java new file mode 100644 index 00000000..0d9969f1 --- /dev/null +++ b/javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/JavaDSLMCCommonStatementsSymTabCompletion.java @@ -0,0 +1,19 @@ +package de.monticore.java.javadsl._symboltable; + +import de.monticore.java.javadsl._ast.ASTEnhancedForControlFormalParameter; +import de.monticore.java.javadsl._visitor.JavaDSLVisitor2; +import de.monticore.statements.mccommonstatements._symboltable.MCCommonStatementsSymTabCompletion; +import de.monticore.symbols.oosymbols._symboltable.FieldSymbol; +import de.monticore.types3.TypeCheck3; + +public class JavaDSLMCCommonStatementsSymTabCompletion extends MCCommonStatementsSymTabCompletion + implements JavaDSLVisitor2 { + + @Override + public void endVisit(ASTEnhancedForControlFormalParameter node) { + if (!node.isVar()) { + FieldSymbol symbol = node.getDeclarator().getSymbol(); + symbol.setType(TypeCheck3.symTypeFromAST(node.getMCType())); + } + } +} diff --git a/javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/JavaDSLMCVarDeclarationStatementsSymTabCompletion.java b/javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/JavaDSLMCVarDeclarationStatementsSymTabCompletion.java index e0b035d6..9dea1342 100644 --- a/javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/JavaDSLMCVarDeclarationStatementsSymTabCompletion.java +++ b/javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/JavaDSLMCVarDeclarationStatementsSymTabCompletion.java @@ -1,52 +1,26 @@ package de.monticore.java.javadsl._symboltable; import de.monticore.java.javadsl.JavaDSLMill; -import de.monticore.java.javadsl._ast.ASTLocalVariableDeclaration; import de.monticore.java.javadsl._visitor.JavaDSLVisitor2; -import de.monticore.statements.mcvardeclarationstatements._ast.ASTSimpleInit; +import de.monticore.statements.mcvardeclarationstatements._ast.ASTLocalVariableDeclaration; import de.monticore.statements.mcvardeclarationstatements._ast.ASTVariableDeclarator; -import de.monticore.statements.mcvardeclarationstatements._ast.ASTVariableInit; import de.monticore.statements.mcvardeclarationstatements._symboltable.MCVarDeclarationStatementsSymTabCompletion; -import de.monticore.types.check.SymTypeExpression; -import de.monticore.types.check.SymTypeExpressionFactory; -import de.monticore.types3.TypeCheck3; -import de.se_rwth.commons.logging.Log; public class JavaDSLMCVarDeclarationStatementsSymTabCompletion extends MCVarDeclarationStatementsSymTabCompletion implements JavaDSLVisitor2 { @Override public void endVisit(ASTLocalVariableDeclaration node) { - if (node.isVar()) { - // we assume that there is just a single VariableDeclarator, as a CoCo prevents the - // declaration of multiple variables with a single var - ASTVariableDeclarator declarator = node.getVariableDeclarator(0); - ASTVariableInit variableInit = declarator.getVariableInit(); - - SymTypeExpression targetType = SymTypeExpressionFactory.createObscureType(); - if (JavaDSLMill.typeDispatcher().isMCVarDeclarationStatementsASTSimpleInit(variableInit)) { - ASTSimpleInit simpleInit = - JavaDSLMill.typeDispatcher().asMCVarDeclarationStatementsASTSimpleInit(variableInit); - targetType = TypeCheck3.typeOf(simpleInit.getExpression()); - } - else { - Log.error("0x7A001: Unsupported ASTVariableInit type"); - } - - if (targetType.isObscureType()) { - Log.error("0x7A002: Could not determine type of 'var' variable"); - } - declarator.getDeclarator().getSymbol().setType(targetType); - } - else { - super.endVisit(node); - } - } - - @Override - public void endVisit( - de.monticore.statements.mcvardeclarationstatements._ast.ASTLocalVariableDeclaration node) { if (!node.isEmptyVariableDeclarators()) { + boolean isJavaLocalVarDec = + JavaDSLMill.typeDispatcher().isJavaDSLASTLocalVariableDeclaration(node); + if (isJavaLocalVarDec) { + de.monticore.java.javadsl._ast.ASTLocalVariableDeclaration javaVarDec = + JavaDSLMill.typeDispatcher().asJavaDSLASTLocalVariableDeclaration(node); + if (javaVarDec.isVar()) { + return; + } + } ASTVariableDeclarator declarator = node.getVariableDeclarator(0); if (declarator.getDeclarator().getSymbol().getType() == null) { super.endVisit(node); diff --git a/javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/JavaDSLScopesGenitor.java b/javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/JavaDSLScopesGenitor.java index 7c9c03de..f7d67e74 100644 --- a/javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/JavaDSLScopesGenitor.java +++ b/javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/JavaDSLScopesGenitor.java @@ -2,13 +2,16 @@ import de.monticore.java.javadsl.JavaDSLMill; import de.monticore.java.javadsl._ast.*; +import de.monticore.javalight._visitor.JavaLightVisitor2; import de.monticore.statements.mccommonstatements._ast.ASTConstantsMCCommonStatements; import de.monticore.statements.mccommonstatements._ast.ASTJavaModifier; import de.monticore.symbols.oosymbols._symboltable.OOTypeSymbol; import de.monticore.symboltable.ImportStatement; -public final class JavaDSLScopesGenitor extends JavaDSLScopesGenitorTOP { import java.util.List; + +public final class JavaDSLScopesGenitor extends JavaDSLScopesGenitorTOP + implements JavaLightVisitor2 { @Override public IJavaDSLArtifactScope createFromAST(ASTCompilationUnit rootNode) { @@ -28,7 +31,9 @@ public IJavaDSLArtifactScope createFromAST(ASTCompilationUnit rootNode) { } for (ASTImportDeclaration importDeclaration : ordinaryCompilationUnit.getImportDeclarationList()) { - artifactScope.addImports(new ImportStatement(importDeclaration.getMCQualifiedName().getQName(), importDeclaration.isSTAR())); + artifactScope.addImports( + new ImportStatement(importDeclaration.getMCQualifiedName().getQName(), + importDeclaration.isSTAR())); } } @@ -84,8 +89,6 @@ public void visit(ASTEnumDeclaration node) { updateModifiers(symbol, node.getJavaModifierList()); } - - @Override public void visit(ASTModuleDeclaration node) { super.visit(node); @@ -110,6 +113,7 @@ public void visit(ASTAnnotationTypeDeclaration node) { * Try to set the name of the ArtifactScope * The name of the artifact scope should equal the name of * a public type. + * * @param node Candidate for public type * @param modifiers List of node's modifiers */ diff --git a/javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/JavaDSLScopesGenitorP3.java b/javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/JavaDSLScopesGenitorP3.java new file mode 100644 index 00000000..ff2a3b38 --- /dev/null +++ b/javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/JavaDSLScopesGenitorP3.java @@ -0,0 +1,89 @@ +package de.monticore.java.javadsl._symboltable; + +import de.monticore.java.javadsl.JavaDSLMill; +import de.monticore.java.javadsl._ast.ASTEnhancedForControlFormalParameter; +import de.monticore.java.javadsl._ast.ASTLocalVariableDeclaration; +import de.monticore.java.javadsl._ast.ASTTryLocalVariableDeclaration; +import de.monticore.java.javadsl._visitor.JavaDSLVisitor2; +import de.monticore.statements.mccommonstatements._ast.ASTEnhancedForControl; +import de.monticore.statements.mccommonstatements._ast.ASTForControl; +import de.monticore.statements.mccommonstatements._ast.ASTForStatement; +import de.monticore.statements.mcvardeclarationstatements._ast.ASTDeclarator; +import de.monticore.statements.mcvardeclarationstatements._ast.ASTSimpleInit; +import de.monticore.statements.mcvardeclarationstatements._ast.ASTVariableDeclarator; +import de.monticore.statements.mcvardeclarationstatements._ast.ASTVariableInit; +import de.monticore.symbols.oosymbols._symboltable.FieldSymbol; +import de.monticore.types.check.SymTypeExpression; +import de.monticore.types.check.SymTypeExpressionFactory; +import de.monticore.types3.TypeCheck3; +import de.se_rwth.commons.logging.Log; + +public class JavaDSLScopesGenitorP3 implements JavaDSLVisitor2 { + + public JavaDSLScopesGenitorP3() { + } + + @Override + public void endVisit(ASTLocalVariableDeclaration node) { + if (node.isVar()) { + // we assume that there is just a single VariableDeclarator, as a CoCo prevents the + // declaration of multiple variables with a single var + ASTVariableDeclarator declarator = node.getVariableDeclarator(0); + ASTVariableInit variableInit = declarator.getVariableInit(); + + SymTypeExpression targetType = SymTypeExpressionFactory.createObscureType(); + if (JavaDSLMill.typeDispatcher().isMCVarDeclarationStatementsASTSimpleInit(variableInit)) { + ASTSimpleInit simpleInit = + JavaDSLMill.typeDispatcher().asMCVarDeclarationStatementsASTSimpleInit(variableInit); + targetType = TypeCheck3.typeOf(simpleInit.getExpression()); + } + else { + Log.error("0x7A001: Unsupported ASTVariableInit type"); + } + + if (targetType.isObscureType()) { + Log.error("0x7A002: Could not determine type of 'var' variable"); + } + declarator.getDeclarator().getSymbol().setType(targetType); + } + } + + @Override + public void endVisit(ASTEnhancedForControlFormalParameter node) { + if (node.isVar()) { + ASTDeclarator declarator = node.getDeclarator(); + FieldSymbol symbol = declarator.getSymbol(); + IJavaDSLScope enclosingScope = node.getEnclosingScope(); + if (JavaDSLMill.typeDispatcher() + .isMCCommonStatementsASTForStatement(enclosingScope.getAstNode())) { + ASTForStatement forStatement = JavaDSLMill.typeDispatcher() + .asMCCommonStatementsASTForStatement(enclosingScope.getAstNode()); + ASTForControl forControl = forStatement.getForControl(); + + if (JavaDSLMill.typeDispatcher().isMCCommonStatementsASTEnhancedForControl(forControl)) { + ASTEnhancedForControl enhancedForControl = + JavaDSLMill.typeDispatcher().asMCCommonStatementsASTEnhancedForControl(forControl); + SymTypeExpression forExprType = TypeCheck3.typeOf(enhancedForControl.getExpression()); + symbol.setType(forExprType); + } + else { + Log.error("0x7A013: Only EnhancedForControl support the 'var' keyword", + node.get_SourcePositionStart()); + } + } + else { + Log.error("0x7A014: Encountered FormalParameter with 'var' in unsupported position", + node.get_SourcePositionStart()); + } + } + } + + @Override + public void endVisit(ASTTryLocalVariableDeclaration node) { + if (node.isVar()) { + FieldSymbol symbol = node.getDeclaratorId().getSymbol(); + SymTypeExpression expressionType = TypeCheck3.typeOf(node.getExpression()); + symbol.setType(expressionType); + } + } +} diff --git a/javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/JavaDSLScopesGenitorP3Delegator.java b/javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/JavaDSLScopesGenitorP3Delegator.java new file mode 100644 index 00000000..5da608ce --- /dev/null +++ b/javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/JavaDSLScopesGenitorP3Delegator.java @@ -0,0 +1,37 @@ +package de.monticore.java.javadsl._symboltable; + +import de.monticore.java.javadsl.JavaDSLMill; +import de.monticore.java.javadsl._ast.ASTCompilationUnit; +import de.monticore.java.javadsl._visitor.JavaDSLTraverser; +import de.se_rwth.commons.logging.Log; + +public class JavaDSLScopesGenitorP3Delegator { + + protected IJavaDSLGlobalScope globalScope; + + protected JavaDSLTraverser traverser; + + public JavaDSLTraverser getTraverser() { + return traverser; + } + + public JavaDSLScopesGenitorP3Delegator() { + this.globalScope = JavaDSLMill.globalScope(); + this.traverser = JavaDSLMill.traverser(); + this.init(); + } + + protected void init() { + this.initJavaDSL(); + } + + protected void initJavaDSL() { + JavaDSLScopesGenitorP3 javaDSLScopesGenitorP3 = JavaDSLMill.scopesGenitorP3(); + this.getTraverser().add4JavaDSL(javaDSLScopesGenitorP3); + } + + public void createFromAST(ASTCompilationUnit astCompilationUnit) { + Log.errorIfNull(astCompilationUnit, "0x7A015: Called createFromAST with argument null"); + astCompilationUnit.accept(traverser); + } +} diff --git a/javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/JavaDSLSymbolTableCompleter.java b/javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/JavaDSLSymbolTableCompleter.java index a7573920..105d1a40 100644 --- a/javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/JavaDSLSymbolTableCompleter.java +++ b/javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/JavaDSLSymbolTableCompleter.java @@ -94,7 +94,8 @@ public void visit(ASTMethodDeclaration node) { @Override public void endVisit(ASTConstructorDeclaration node) { JavaMethodSymbol symbol = node.getSymbol(); - IJavaDSLScope enclosingScope = JavaDSLMill.typeDispatcher().asJavaDSLIJavaDSLScope(node.getEnclosingScope()); + IJavaDSLScope enclosingScope = + JavaDSLMill.typeDispatcher().asJavaDSLIJavaDSLScope(node.getEnclosingScope()); ASTNode enclosingScopeNode = enclosingScope.getAstNode(); if (JavaDSLMill.typeDispatcher().isJavaDSLASTClassDeclaration(enclosingScopeNode)) { ASTClassDeclaration enclosingClass = @@ -130,8 +131,10 @@ public void endVisit(ASTFieldDeclaration node) { for (ASTVariableDeclarator v : node.getVariableDeclaratorList()) { SymTypeExpression declaratorType = TypeCheck3.symTypeFromAST(node.getMCType()); if (JavaDSLMill.typeDispatcher().isMCArrayStatementsASTArrayDeclaratorId(v.getDeclarator())) { - ASTArrayDeclaratorId arrayDeclaratorId = JavaDSLMill.typeDispatcher().asMCArrayStatementsASTArrayDeclaratorId(v.getDeclarator()); - declaratorType = SymTypeRelations.normalize(SymTypeExpressionFactory.createTypeArray(declaratorType, arrayDeclaratorId.sizeDim())); + ASTArrayDeclaratorId arrayDeclaratorId = + JavaDSLMill.typeDispatcher().asMCArrayStatementsASTArrayDeclaratorId(v.getDeclarator()); + declaratorType = SymTypeRelations.normalize( + SymTypeExpressionFactory.createTypeArray(declaratorType, arrayDeclaratorId.sizeDim())); } v.getDeclarator().getSymbol().setType(declaratorType); addModifiersToField(v.getDeclarator().getSymbol(), node.getJavaModifierList()); @@ -146,6 +149,14 @@ public void endVisit(ASTAnnotationMethod node) { symbol.setType(TypeCheck3.symTypeFromAST(node.getMCType())); } + @Override + public void endVisit(ASTTryLocalVariableDeclaration node) { + if (!node.isVar()) { + FieldSymbol symbol = node.getDeclaratorId().getSymbol(); + symbol.setType(TypeCheck3.symTypeFromAST(node.getMCType())); + } + } + protected void addModifiersToField(FieldSymbol fieldSymbol, Iterable astModifierList) { for (ASTMCModifier modifier : astModifierList) { @@ -171,7 +182,8 @@ protected void addModifiersToField(FieldSymbol fieldSymbol, default: break; } - } else if (modifier instanceof ASTAnnotation) { + } + else if (modifier instanceof ASTAnnotation) { ASTAnnotation astAnnotation = (ASTAnnotation) modifier; //fieldSymbol.addAnnotations(TypeCheck3.symTypeFromAST(astAnnotation.getAnnotationName())); // TODO: FieldSymbols do not support annotations yet -> annotations are lost @@ -218,9 +230,11 @@ protected void addModifiersToMethOrConstr(JavaMethodSymbol javaMethodSymbol, default: break; } - } else if (modifier instanceof ASTAnnotation) { + } + else if (modifier instanceof ASTAnnotation) { ASTAnnotation astAnnotation = (ASTAnnotation) modifier; - javaMethodSymbol.addAnnotations(TypeCheck3.symTypeFromAST(astAnnotation.getAnnotationName())); + javaMethodSymbol.addAnnotations( + TypeCheck3.symTypeFromAST(astAnnotation.getAnnotationName())); } } } diff --git a/javaDSL/src/main/java/de/monticore/java/utils/JavaDSLSymbolTableUtil.java b/javaDSL/src/main/java/de/monticore/java/utils/JavaDSLSymbolTableUtil.java index 24dae687..bbbf340f 100644 --- a/javaDSL/src/main/java/de/monticore/java/utils/JavaDSLSymbolTableUtil.java +++ b/javaDSL/src/main/java/de/monticore/java/utils/JavaDSLSymbolTableUtil.java @@ -5,13 +5,9 @@ import de.monticore.expressions.lambdaexpressions._symboltable.LambdaExpressionsSTCompleteTypes2; import de.monticore.java.javadsl.JavaDSLMill; import de.monticore.java.javadsl._ast.ASTCompilationUnit; -import de.monticore.java.javadsl._symboltable.IJavaDSLArtifactScope; -import de.monticore.java.javadsl._symboltable.JavaDSLMCVarDeclarationStatementsSymTabCompletion; -import de.monticore.java.javadsl._symboltable.JavaDSLScopesGenitorDelegator; -import de.monticore.java.javadsl._symboltable.JavaDSLSymbolTableCompleter; +import de.monticore.java.javadsl._symboltable.*; import de.monticore.java.javadsl._visitor.JavaDSLTraverser; import de.monticore.javalight._symboltable.JavaLightSTCompleteTypes; -import de.monticore.statements.mccommonstatements._symboltable.MCCommonStatementsSymTabCompletion; import de.monticore.symbols.basicsymbols.BasicSymbolsMill; import de.monticore.types.typeparameters._symboltable.TypeParametersSTCompleteTypes; @@ -39,6 +35,7 @@ public static IJavaDSLArtifactScope buildSymbolTable(ASTCompilationUnit ast) { public static List buildSymbolTable(List asts) { List as = asts.stream().map(JavaDSLSymbolTableUtil::runSymTabGenitor).collect(Collectors.toList()); asts.forEach(JavaDSLSymbolTableUtil::runSymTabCompleter); + asts.forEach(JavaDSLSymbolTableUtil::runSymTabFinalization); return as; } @@ -47,6 +44,11 @@ public static IJavaDSLArtifactScope runSymTabGenitor(ASTCompilationUnit ast) { return genitor.createFromAST(ast); } + public static void runSymTabFinalization(ASTCompilationUnit ast) { + JavaDSLScopesGenitorP3Delegator p3Genitor = JavaDSLMill.scopesGenitorP3Delegator(); + p3Genitor.createFromAST(ast); + } + public static void runSymTabCompleter(ASTCompilationUnit ast) { JavaDSLTraverser traverser = JavaDSLMill.inheritanceTraverser(); @@ -57,8 +59,9 @@ public static void runSymTabCompleter(ASTCompilationUnit ast) { JavaLightSTCompleteTypes javaLightSTCompleteTypes = new JavaLightSTCompleteTypes(); traverser.add4JavaLight(javaLightSTCompleteTypes); - MCCommonStatementsSymTabCompletion mcCommonStatementsSymTabCompletion = new MCCommonStatementsSymTabCompletion(); - traverser.add4MCCommonStatements(mcCommonStatementsSymTabCompletion); + JavaDSLMCCommonStatementsSymTabCompletion javaDSLMCCommonStatementsSymTabCompletion = new JavaDSLMCCommonStatementsSymTabCompletion(); + traverser.add4JavaDSL(javaDSLMCCommonStatementsSymTabCompletion); + traverser.add4MCCommonStatements(javaDSLMCCommonStatementsSymTabCompletion); LambdaExpressionsSTCompleteTypes2 lambdaExpressionsSTCompleteTypes2 = new LambdaExpressionsSTCompleteTypes2(); traverser.add4LambdaExpressions(lambdaExpressionsSTCompleteTypes2); From e1be1b47dbb3398ab883ea4d3dd5e9981b4720c5 Mon Sep 17 00:00:00 2001 From: Janik Rapp Date: Tue, 9 Sep 2025 16:59:36 +0200 Subject: [PATCH 46/61] moved SymTabCompletion to ScopesGenitorP2 --- .../monticore/java/javadsl/JavaDSLMill.java | 30 ++++++++- ...leter.java => JavaDSLScopesGenitorP2.java} | 4 +- .../JavaDSLScopesGenitorP2Delegator.java | 67 +++++++++++++++++++ .../java/utils/JavaDSLSymbolTableUtil.java | 36 +++------- 4 files changed, 104 insertions(+), 33 deletions(-) rename javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/{JavaDSLSymbolTableCompleter.java => JavaDSLScopesGenitorP2.java} (97%) create mode 100644 javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/JavaDSLScopesGenitorP2Delegator.java diff --git a/javaDSL/src/main/java/de/monticore/java/javadsl/JavaDSLMill.java b/javaDSL/src/main/java/de/monticore/java/javadsl/JavaDSLMill.java index 402f0eb3..ede439cf 100644 --- a/javaDSL/src/main/java/de/monticore/java/javadsl/JavaDSLMill.java +++ b/javaDSL/src/main/java/de/monticore/java/javadsl/JavaDSLMill.java @@ -1,15 +1,43 @@ package de.monticore.java.javadsl; +import de.monticore.java.javadsl._symboltable.JavaDSLScopesGenitorP2; +import de.monticore.java.javadsl._symboltable.JavaDSLScopesGenitorP2Delegator; import de.monticore.java.javadsl._symboltable.JavaDSLScopesGenitorP3; import de.monticore.java.javadsl._symboltable.JavaDSLScopesGenitorP3Delegator; import de.monticore.java.javadsl.types3.JavaDSLTypeCheck3; public class JavaDSLMill extends JavaDSLMillTOP { + protected static JavaDSLMill millJavaDSLScopesGenitorP2; + + protected static JavaDSLMill millJavaDSLScopesGenitorP2Delegator; + protected static JavaDSLMill millJavaDSLScopesGenitorP3; protected static JavaDSLMill millJavaDSLScopesGenitorP3Delegator; + public static JavaDSLScopesGenitorP2 scopesGenitorP2() { + if (millJavaDSLScopesGenitorP2 == null) { + millJavaDSLScopesGenitorP2 = getMill(); + } + return millJavaDSLScopesGenitorP2._scopesGenitorP2(); + } + + protected JavaDSLScopesGenitorP2 _scopesGenitorP2() { + return new JavaDSLScopesGenitorP2(); + } + + public static JavaDSLScopesGenitorP2Delegator scopesGenitorP2Delegator() { + if (millJavaDSLScopesGenitorP2Delegator == null) { + millJavaDSLScopesGenitorP2Delegator = getMill(); + } + return millJavaDSLScopesGenitorP2Delegator._scopesGenitorP2Delegator(); + } + + protected JavaDSLScopesGenitorP2Delegator _scopesGenitorP2Delegator() { + return new JavaDSLScopesGenitorP2Delegator(); + } + public static JavaDSLScopesGenitorP3 scopesGenitorP3() { if (millJavaDSLScopesGenitorP3 == null) { millJavaDSLScopesGenitorP3 = getMill(); @@ -32,8 +60,6 @@ protected JavaDSLScopesGenitorP3Delegator _scopesGenitorP3Delegator() { return new JavaDSLScopesGenitorP3Delegator(); } - - /** additionally inits the TypeCheck */ public static void init() { JavaDSLMillTOP.init(); diff --git a/javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/JavaDSLSymbolTableCompleter.java b/javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/JavaDSLScopesGenitorP2.java similarity index 97% rename from javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/JavaDSLSymbolTableCompleter.java rename to javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/JavaDSLScopesGenitorP2.java index 105d1a40..f3dcafc2 100644 --- a/javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/JavaDSLSymbolTableCompleter.java +++ b/javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/JavaDSLScopesGenitorP2.java @@ -10,12 +10,10 @@ import de.monticore.javalight._symboltable.JavaMethodSymbol; import de.monticore.javalight._visitor.JavaLightVisitor2; import de.monticore.statements.mcarraystatements._ast.ASTArrayDeclaratorId; -import de.monticore.statements.mccommonstatements._ast.ASTConstantsMCCommonStatements; import de.monticore.statements.mccommonstatements._ast.ASTJavaModifier; import de.monticore.statements.mcstatementsbasis._ast.ASTMCModifier; import de.monticore.statements.mcvardeclarationstatements._ast.ASTVariableDeclarator; import de.monticore.symbols.oosymbols._symboltable.FieldSymbol; -import de.monticore.symbols.oosymbols._symboltable.OOTypeSymbol; import de.monticore.types.check.SymTypeExpression; import de.monticore.types.check.SymTypeExpressionFactory; import de.monticore.types.check.SymTypeOfObject; @@ -37,7 +35,7 @@ import static de.monticore.statements.mccommonstatements._ast.ASTConstantsMCCommonStatements.STRICTFP; import static de.monticore.statements.mccommonstatements._ast.ASTConstantsMCCommonStatements.SYNCHRONIZED; -public class JavaDSLSymbolTableCompleter implements JavaDSLVisitor2, JavaLightVisitor2 { +public class JavaDSLScopesGenitorP2 implements JavaDSLVisitor2, JavaLightVisitor2 { @Override public void endVisit(ASTEnumDeclaration node) { diff --git a/javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/JavaDSLScopesGenitorP2Delegator.java b/javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/JavaDSLScopesGenitorP2Delegator.java new file mode 100644 index 00000000..d13462ff --- /dev/null +++ b/javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/JavaDSLScopesGenitorP2Delegator.java @@ -0,0 +1,67 @@ +package de.monticore.java.javadsl._symboltable; + +import de.monticore.expressions.lambdaexpressions._symboltable.LambdaExpressionsSTCompleteTypes2; +import de.monticore.java.javadsl.JavaDSLMill; +import de.monticore.java.javadsl._ast.ASTCompilationUnit; +import de.monticore.java.javadsl._visitor.JavaDSLTraverser; +import de.monticore.javalight._symboltable.JavaLightSTCompleteTypes; +import de.monticore.types.typeparameters._symboltable.TypeParametersSTCompleteTypes; +import de.se_rwth.commons.logging.Log; + +public class JavaDSLScopesGenitorP2Delegator { + + protected IJavaDSLGlobalScope globalScope; + + protected JavaDSLTraverser traverser; + + public JavaDSLTraverser getTraverser() { + return traverser; + } + + public JavaDSLScopesGenitorP2Delegator() { + this.globalScope = JavaDSLMill.globalScope(); + this.traverser = JavaDSLMill.inheritanceTraverser(); + this.init(); + this.initInheritedCompleters(); + } + + protected void init() { + this.initJavaDSL(); + } + + protected void initJavaDSL() { + JavaDSLScopesGenitorP2 javaDSLScopesGenitorP2 = JavaDSLMill.scopesGenitorP2(); + this.getTraverser().add4JavaDSL(javaDSLScopesGenitorP2); + this.getTraverser().add4JavaLight(javaDSLScopesGenitorP2); + } + + protected void initInheritedCompleters() { + JavaLightSTCompleteTypes javaLightSTCompleteTypes = new JavaLightSTCompleteTypes(); + this.getTraverser().add4JavaLight(javaLightSTCompleteTypes); + + JavaDSLMCCommonStatementsSymTabCompletion javaDSLMCCommonStatementsSymTabCompletion = + new JavaDSLMCCommonStatementsSymTabCompletion(); + this.getTraverser().add4JavaDSL(javaDSLMCCommonStatementsSymTabCompletion); + this.getTraverser().add4MCCommonStatements(javaDSLMCCommonStatementsSymTabCompletion); + + LambdaExpressionsSTCompleteTypes2 lambdaExpressionsSTCompleteTypes2 = + new LambdaExpressionsSTCompleteTypes2(); + this.getTraverser().add4LambdaExpressions(lambdaExpressionsSTCompleteTypes2); + + JavaDSLMCVarDeclarationStatementsSymTabCompletion + javaDSLMCVarDeclarationStatementsSymTabCompletion = + new JavaDSLMCVarDeclarationStatementsSymTabCompletion(); + this.getTraverser().add4JavaDSL(javaDSLMCVarDeclarationStatementsSymTabCompletion); + this.getTraverser() + .add4MCVarDeclarationStatements(javaDSLMCVarDeclarationStatementsSymTabCompletion); + + TypeParametersSTCompleteTypes typeParametersSTCompleteTypes = + new TypeParametersSTCompleteTypes(); + this.getTraverser().add4TypeParameters(typeParametersSTCompleteTypes); + } + + public void createFromAST(ASTCompilationUnit astCompilationUnit) { + Log.errorIfNull(astCompilationUnit, "0x7A016: Called createFromAST with argument null"); + astCompilationUnit.accept(traverser); + } +} diff --git a/javaDSL/src/main/java/de/monticore/java/utils/JavaDSLSymbolTableUtil.java b/javaDSL/src/main/java/de/monticore/java/utils/JavaDSLSymbolTableUtil.java index bbbf340f..7eb231dc 100644 --- a/javaDSL/src/main/java/de/monticore/java/utils/JavaDSLSymbolTableUtil.java +++ b/javaDSL/src/main/java/de/monticore/java/utils/JavaDSLSymbolTableUtil.java @@ -15,6 +15,7 @@ import java.util.stream.Collectors; public class JavaDSLSymbolTableUtil { + public static void prepareMill(boolean enableC2MC) { JavaDSLMill.globalScope().clear(); @@ -33,7 +34,8 @@ public static IJavaDSLArtifactScope buildSymbolTable(ASTCompilationUnit ast) { } public static List buildSymbolTable(List asts) { - List as = asts.stream().map(JavaDSLSymbolTableUtil::runSymTabGenitor).collect(Collectors.toList()); + List as = + asts.stream().map(JavaDSLSymbolTableUtil::runSymTabGenitor).collect(Collectors.toList()); asts.forEach(JavaDSLSymbolTableUtil::runSymTabCompleter); asts.forEach(JavaDSLSymbolTableUtil::runSymTabFinalization); return as; @@ -44,35 +46,13 @@ public static IJavaDSLArtifactScope runSymTabGenitor(ASTCompilationUnit ast) { return genitor.createFromAST(ast); } + public static void runSymTabCompleter(ASTCompilationUnit ast) { + JavaDSLScopesGenitorP2Delegator p2Genitor = new JavaDSLScopesGenitorP2Delegator(); + p2Genitor.createFromAST(ast); + } + public static void runSymTabFinalization(ASTCompilationUnit ast) { JavaDSLScopesGenitorP3Delegator p3Genitor = JavaDSLMill.scopesGenitorP3Delegator(); p3Genitor.createFromAST(ast); } - - public static void runSymTabCompleter(ASTCompilationUnit ast) { - JavaDSLTraverser traverser = JavaDSLMill.inheritanceTraverser(); - - JavaDSLSymbolTableCompleter javaDslCompleter = new JavaDSLSymbolTableCompleter(); - traverser.add4JavaDSL(javaDslCompleter); - traverser.add4JavaLight(javaDslCompleter); - - JavaLightSTCompleteTypes javaLightSTCompleteTypes = new JavaLightSTCompleteTypes(); - traverser.add4JavaLight(javaLightSTCompleteTypes); - - JavaDSLMCCommonStatementsSymTabCompletion javaDSLMCCommonStatementsSymTabCompletion = new JavaDSLMCCommonStatementsSymTabCompletion(); - traverser.add4JavaDSL(javaDSLMCCommonStatementsSymTabCompletion); - traverser.add4MCCommonStatements(javaDSLMCCommonStatementsSymTabCompletion); - - LambdaExpressionsSTCompleteTypes2 lambdaExpressionsSTCompleteTypes2 = new LambdaExpressionsSTCompleteTypes2(); - traverser.add4LambdaExpressions(lambdaExpressionsSTCompleteTypes2); - - JavaDSLMCVarDeclarationStatementsSymTabCompletion javaDSLMCVarDeclarationStatementsSymTabCompletion = new JavaDSLMCVarDeclarationStatementsSymTabCompletion(); - traverser.add4JavaDSL(javaDSLMCVarDeclarationStatementsSymTabCompletion); - traverser.add4MCVarDeclarationStatements(javaDSLMCVarDeclarationStatementsSymTabCompletion); - - TypeParametersSTCompleteTypes typeParametersSTCompleteTypes = new TypeParametersSTCompleteTypes(); - traverser.add4TypeParameters(typeParametersSTCompleteTypes); - - ast.accept(traverser); - } } From 40ed38b8da3d9e149586c1cb7495a628ce095c1f Mon Sep 17 00:00:00 2001 From: Janik Rapp Date: Mon, 1 Dec 2025 13:32:31 +0100 Subject: [PATCH 47/61] log SymbolTable phases --- .../de/monticore/java/utils/JavaDSLSymbolTableUtil.java | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/javaDSL/src/main/java/de/monticore/java/utils/JavaDSLSymbolTableUtil.java b/javaDSL/src/main/java/de/monticore/java/utils/JavaDSLSymbolTableUtil.java index 7eb231dc..a77bd10a 100644 --- a/javaDSL/src/main/java/de/monticore/java/utils/JavaDSLSymbolTableUtil.java +++ b/javaDSL/src/main/java/de/monticore/java/utils/JavaDSLSymbolTableUtil.java @@ -2,14 +2,11 @@ import de.monticore.class2mc.Class2MCResolver; import de.monticore.class2mc.OOClass2MCResolver; -import de.monticore.expressions.lambdaexpressions._symboltable.LambdaExpressionsSTCompleteTypes2; import de.monticore.java.javadsl.JavaDSLMill; import de.monticore.java.javadsl._ast.ASTCompilationUnit; import de.monticore.java.javadsl._symboltable.*; -import de.monticore.java.javadsl._visitor.JavaDSLTraverser; -import de.monticore.javalight._symboltable.JavaLightSTCompleteTypes; import de.monticore.symbols.basicsymbols.BasicSymbolsMill; -import de.monticore.types.typeparameters._symboltable.TypeParametersSTCompleteTypes; +import de.se_rwth.commons.logging.Log; import java.util.List; import java.util.stream.Collectors; @@ -34,9 +31,12 @@ public static IJavaDSLArtifactScope buildSymbolTable(ASTCompilationUnit ast) { } public static List buildSymbolTable(List asts) { + Log.info("Build - Phase 1", "SymbolTableConstruction"); List as = asts.stream().map(JavaDSLSymbolTableUtil::runSymTabGenitor).collect(Collectors.toList()); + Log.info("Build - Phase 2", "SymbolTableConstruction"); asts.forEach(JavaDSLSymbolTableUtil::runSymTabCompleter); + Log.info("Build - Phase 3", "SymbolTableConstruction"); asts.forEach(JavaDSLSymbolTableUtil::runSymTabFinalization); return as; } From f0e1610a772c494881947e6e3839493bd8f69e0f Mon Sep 17 00:00:00 2001 From: Janik Rapp Date: Mon, 1 Dec 2025 16:02:35 +0100 Subject: [PATCH 48/61] reintroduce record nokeyword --- javaDSL/src/main/grammars/de/monticore/java/JavaDSL.mc4 | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/javaDSL/src/main/grammars/de/monticore/java/JavaDSL.mc4 b/javaDSL/src/main/grammars/de/monticore/java/JavaDSL.mc4 index 4b639c80..fd1b3968 100644 --- a/javaDSL/src/main/grammars/de/monticore/java/JavaDSL.mc4 +++ b/javaDSL/src/main/grammars/de/monticore/java/JavaDSL.mc4 @@ -190,7 +190,7 @@ scope(shadowing) RecordDeclaration extends TypeDeclaration ; // TODO: "record" is a contextual keyword, but setting it to nokeyword creates conflicts with MethodDeclaration -//nokeyword "record"; +nokeyword "record"; RecordHeader = "(" (RecordComponent || ",")* ")" From 4eb6866c03131053516052abc1d18fc1d2164107 Mon Sep 17 00:00:00 2001 From: Janik Rapp Date: Mon, 1 Dec 2025 16:03:13 +0100 Subject: [PATCH 49/61] allow additional colons after TypeDeclaration blocks --- javaDSL/src/main/grammars/de/monticore/java/JavaDSL.mc4 | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/javaDSL/src/main/grammars/de/monticore/java/JavaDSL.mc4 b/javaDSL/src/main/grammars/de/monticore/java/JavaDSL.mc4 index fd1b3968..a3f74c22 100644 --- a/javaDSL/src/main/grammars/de/monticore/java/JavaDSL.mc4 +++ b/javaDSL/src/main/grammars/de/monticore/java/JavaDSL.mc4 @@ -173,7 +173,7 @@ scope(shadowing) ClassDeclaration extends TypeDeclaration // TODO Replace with MCJavaBlock? -> with CoCos? ClassBody - = "{" ClassBodyDeclaration* "}" + = "{" ClassBodyDeclaration* "}" ";"* ; /* @@ -207,7 +207,7 @@ astrule RecordComponent = // TODO Replace with MCJavaBlock? -> with CoCos? RecordBody - = "{" (ClassBodyDeclaration | CompactConstructorDeclaration)* "}" + = "{" (ClassBodyDeclaration | CompactConstructorDeclaration)* "}" ";"* ; CompactConstructorDeclaration @@ -223,14 +223,14 @@ scope(shadowing) InterfaceDeclaration extends TypeDeclaration // TODO Replace with MCJavaBlock? -> with CoCos? InterfaceBody - = "{" InterfaceBodyDeclaration* "}" + = "{" InterfaceBodyDeclaration* "}" ";"* ; // TODO: Remove scope duplicate when monticore#4726 is fixed scope(shadowing) EnumDeclaration extends TypeDeclaration = JavaModifier* "enum" Name ("implements" implementedInterface:(MCType || ",")+)? - "{" (EnumConstantDeclaration || ",")* ","? EnumBody? "}" + "{" (EnumConstantDeclaration || ",")* ","? EnumBody? "}" ";"* ; // TODO: Remove scope duplicate when monticore#4726 is fixed From 5ea4067a958637aa246e34faed31b58d16e199dd Mon Sep 17 00:00:00 2001 From: Janik Rapp Date: Mon, 1 Dec 2025 17:30:11 +0100 Subject: [PATCH 50/61] log SymbolTableConstruction timings --- .../de/monticore/java/utils/JavaDSLSymbolTableUtil.java | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/javaDSL/src/main/java/de/monticore/java/utils/JavaDSLSymbolTableUtil.java b/javaDSL/src/main/java/de/monticore/java/utils/JavaDSLSymbolTableUtil.java index a77bd10a..22aa3662 100644 --- a/javaDSL/src/main/java/de/monticore/java/utils/JavaDSLSymbolTableUtil.java +++ b/javaDSL/src/main/java/de/monticore/java/utils/JavaDSLSymbolTableUtil.java @@ -1,5 +1,6 @@ package de.monticore.java.utils; +import com.google.common.base.Stopwatch; import de.monticore.class2mc.Class2MCResolver; import de.monticore.class2mc.OOClass2MCResolver; import de.monticore.java.javadsl.JavaDSLMill; @@ -9,6 +10,7 @@ import de.se_rwth.commons.logging.Log; import java.util.List; +import java.util.concurrent.TimeUnit; import java.util.stream.Collectors; public class JavaDSLSymbolTableUtil { @@ -31,13 +33,19 @@ public static IJavaDSLArtifactScope buildSymbolTable(ASTCompilationUnit ast) { } public static List buildSymbolTable(List asts) { + Stopwatch stopwatch = Stopwatch.createStarted(); Log.info("Build - Phase 1", "SymbolTableConstruction"); List as = asts.stream().map(JavaDSLSymbolTableUtil::runSymTabGenitor).collect(Collectors.toList()); + Log.info("Build - Phase 1 finished in " + stopwatch.elapsed(TimeUnit.MILLISECONDS)+"ms", "SymbolTableConstruction"); + stopwatch.reset().start(); Log.info("Build - Phase 2", "SymbolTableConstruction"); asts.forEach(JavaDSLSymbolTableUtil::runSymTabCompleter); + Log.info("Build - Phase 2 finished in " + stopwatch.elapsed(TimeUnit.MILLISECONDS)+"ms", "SymbolTableConstruction"); + stopwatch.reset().start(); Log.info("Build - Phase 3", "SymbolTableConstruction"); asts.forEach(JavaDSLSymbolTableUtil::runSymTabFinalization); + Log.info("Build - Phase 2 finished in " + stopwatch.elapsed(TimeUnit.MILLISECONDS)+"ms", "SymbolTableConstruction"); return as; } From 2495c71c5b80229c49088cb3f68a8cc8ccdcf73a Mon Sep 17 00:00:00 2001 From: Janik Rapp Date: Mon, 1 Dec 2025 17:30:31 +0100 Subject: [PATCH 51/61] log instead of System.out.printf --- javaDSL/src/main/java/de/monticore/java/JavaDSLTool.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/javaDSL/src/main/java/de/monticore/java/JavaDSLTool.java b/javaDSL/src/main/java/de/monticore/java/JavaDSLTool.java index febef17a..2e593d64 100644 --- a/javaDSL/src/main/java/de/monticore/java/JavaDSLTool.java +++ b/javaDSL/src/main/java/de/monticore/java/JavaDSLTool.java @@ -97,7 +97,7 @@ public void run(String[] args) { Log.clearFindings(); Log.enableFailQuick(true); - System.out.printf("Successfully parsed %d files%n", asts.size()); + Log.info(String.format("Successfully parsed %d files", asts.size()), "JavaDSLTool"); if (cmd.hasOption("pp")) { String[] ppTargets = cmd.getOptionValues("pp"); From 4dae5b41d9281a75bb47ea485828e9d19feffcd8 Mon Sep 17 00:00:00 2001 From: Janik Rapp Date: Mon, 1 Dec 2025 17:31:45 +0100 Subject: [PATCH 52/61] add support for additional colons after TypeDeclarations with correct pretty-printing --- .../grammars/de/monticore/java/JavaDSL.mc4 | 12 +- .../_prettyprint/JavaDSLPrettyPrinter.java | 194 ++++++++++++++++++ 2 files changed, 200 insertions(+), 6 deletions(-) create mode 100644 javaDSL/src/main/java/de/monticore/java/javadsl/_prettyprint/JavaDSLPrettyPrinter.java diff --git a/javaDSL/src/main/grammars/de/monticore/java/JavaDSL.mc4 b/javaDSL/src/main/grammars/de/monticore/java/JavaDSL.mc4 index a3f74c22..5933dd3b 100644 --- a/javaDSL/src/main/grammars/de/monticore/java/JavaDSL.mc4 +++ b/javaDSL/src/main/grammars/de/monticore/java/JavaDSL.mc4 @@ -168,12 +168,12 @@ scope(shadowing) ClassDeclaration extends TypeDeclaration = JavaModifier* "class" Name TypeParameters? ("extends" superClass:MCType)? ("implements" implementedInterface:(MCType || ",")+)? - ClassBody + ClassBody ";"* ; // TODO Replace with MCJavaBlock? -> with CoCos? ClassBody - = "{" ClassBodyDeclaration* "}" ";"* + = "{" ClassBodyDeclaration* "}" ; /* @@ -186,7 +186,7 @@ ClassBody scope(shadowing) RecordDeclaration extends TypeDeclaration = JavaModifier* "record" Name TypeParameters? RecordHeader ("implements" implementedInterface:(MCType || ",")+)? - RecordBody + RecordBody ";"* ; // TODO: "record" is a contextual keyword, but setting it to nokeyword creates conflicts with MethodDeclaration @@ -207,7 +207,7 @@ astrule RecordComponent = // TODO Replace with MCJavaBlock? -> with CoCos? RecordBody - = "{" (ClassBodyDeclaration | CompactConstructorDeclaration)* "}" ";"* + = "{" (ClassBodyDeclaration | CompactConstructorDeclaration)* "}" ; CompactConstructorDeclaration @@ -218,12 +218,12 @@ CompactConstructorDeclaration scope(shadowing) InterfaceDeclaration extends TypeDeclaration = JavaModifier* "interface" Name TypeParameters? ("extends" extendedInterface:(MCType || ",")+)? - InterfaceBody + InterfaceBody ";"* ; // TODO Replace with MCJavaBlock? -> with CoCos? InterfaceBody - = "{" InterfaceBodyDeclaration* "}" ";"* + = "{" InterfaceBodyDeclaration* "}" ; // TODO: Remove scope duplicate when monticore#4726 is fixed diff --git a/javaDSL/src/main/java/de/monticore/java/javadsl/_prettyprint/JavaDSLPrettyPrinter.java b/javaDSL/src/main/java/de/monticore/java/javadsl/_prettyprint/JavaDSLPrettyPrinter.java new file mode 100644 index 00000000..cbb1f32c --- /dev/null +++ b/javaDSL/src/main/java/de/monticore/java/javadsl/_prettyprint/JavaDSLPrettyPrinter.java @@ -0,0 +1,194 @@ +package de.monticore.java.javadsl._prettyprint; + +import de.monticore.prettyprint.IndentPrinter; +import de.monticore.statements.mccommonstatements._ast.ASTJavaModifier; + +import java.util.stream.Collectors; + +public class JavaDSLPrettyPrinter extends JavaDSLPrettyPrinterTOP { + + public JavaDSLPrettyPrinter(IndentPrinter printer, boolean printComments) { + super(printer, printComments); + } + + public void handle(de.monticore.java.javadsl._ast.ASTClassDeclaration node) { + if (this.isPrintComments()) { + de.monticore.prettyprint.CommentPrettyPrinter.printPreComments(node, getPrinter()); + } + java.util.Iterator iter_implementedInterface = + node.getImplementedInterfaceList().iterator(); + + node.getJavaModifierList().forEach(n -> n.accept(getTraverser())); + + getPrinter().print("class "); + + getPrinter().print(node.getName() + " "); + + if (node.isPresentTypeParameters()) { + node.getTypeParameters().accept(getTraverser()); + } + + if (node.isPresentSuperClass()) { + getPrinter().print("extends "); + node.getSuperClass().accept(getTraverser()); + } + + if (iter_implementedInterface.hasNext()) { + getPrinter().print("implements "); + if (iter_implementedInterface.hasNext()) { + iter_implementedInterface.next().accept(getTraverser()); + while (iter_implementedInterface.hasNext()) { + getPrinter().stripTrailing(); + getPrinter().print(","); + iter_implementedInterface.next().accept(getTraverser()); + } + } + } + node.getClassBody().accept(getTraverser()); + + getPrinter().stripTrailing(); + + if (this.isPrintComments()) { + de.monticore.prettyprint.CommentPrettyPrinter.printPostComments(node, getPrinter()); + } + } + + public void handle(de.monticore.java.javadsl._ast.ASTRecordDeclaration node) { + if (this.isPrintComments()) { + de.monticore.prettyprint.CommentPrettyPrinter.printPreComments(node, getPrinter()); + } + java.util.Iterator iter_implementedInterface = + node.getImplementedInterfaceList().iterator(); + + node.getMCModifierList().stream().map(m -> (ASTJavaModifier) m).collect(Collectors.toList()).forEach(n -> n.accept(getTraverser())); + + getPrinter().print("record "); + + getPrinter().print(node.getName() + " "); + + if (node.isPresentTypeParameters()) { + node.getTypeParameters().accept(getTraverser()); + } + + node.getRecordHeader().accept(getTraverser()); + + if (iter_implementedInterface.hasNext()) { + getPrinter().print("implements "); + if (iter_implementedInterface.hasNext()) { + iter_implementedInterface.next().accept(getTraverser()); + while (iter_implementedInterface.hasNext()) { + getPrinter().stripTrailing(); + getPrinter().print(","); + + iter_implementedInterface.next().accept(getTraverser()); + } + } + } + + node.getRecordBody().accept(getTraverser()); + + getPrinter().stripTrailing(); + + if (this.isPrintComments()) { + de.monticore.prettyprint.CommentPrettyPrinter.printPostComments(node, getPrinter()); + } + } + + public void handle(de.monticore.java.javadsl._ast.ASTInterfaceDeclaration node) { + if (this.isPrintComments()) { + de.monticore.prettyprint.CommentPrettyPrinter.printPreComments(node, getPrinter()); + } + java.util.Iterator iter_extendedInterface = + node.getExtendedInterfaceList().iterator(); + + node.getJavaModifierList().forEach(n -> n.accept(getTraverser())); + + getPrinter().print("interface "); + + getPrinter().print(node.getName() + " "); + + if (node.isPresentTypeParameters()) { + node.getTypeParameters().accept(getTraverser()); + } + + if (iter_extendedInterface.hasNext()) { + getPrinter().print("extends "); + if (iter_extendedInterface.hasNext()) { + iter_extendedInterface.next().accept(getTraverser()); + while (iter_extendedInterface.hasNext()) { + getPrinter().stripTrailing(); + getPrinter().print(","); + + iter_extendedInterface.next().accept(getTraverser()); + } + } + } + + node.getInterfaceBody().accept(getTraverser()); + + getPrinter().stripTrailing(); + + if (this.isPrintComments()) { + de.monticore.prettyprint.CommentPrettyPrinter.printPostComments(node, getPrinter()); + } + + } + + public void handle(de.monticore.java.javadsl._ast.ASTEnumDeclaration node) { + if (this.isPrintComments()) { + de.monticore.prettyprint.CommentPrettyPrinter.printPreComments(node, getPrinter()); + } + java.util.Iterator + iter_enumConstantDeclaration = node.getEnumConstantDeclarationList().iterator(); + java.util.Iterator iter_implementedInterface = + node.getImplementedInterfaceList().iterator(); + + node.getJavaModifierList().forEach(n -> n.accept(getTraverser())); + + getPrinter().print("enum "); + + getPrinter().print(node.getName() + " "); + + if (iter_implementedInterface.hasNext()) { + getPrinter().print("implements "); + + if (iter_implementedInterface.hasNext()) { + iter_implementedInterface.next().accept(getTraverser()); + while (iter_implementedInterface.hasNext()) { + getPrinter().stripTrailing(); + getPrinter().print(","); + + iter_implementedInterface.next().accept(getTraverser()); + } + } + } + getPrinter().println("{ "); + getPrinter().indent(); + if (iter_enumConstantDeclaration.hasNext()) { + iter_enumConstantDeclaration.next().accept(getTraverser()); + while (iter_enumConstantDeclaration.hasNext()) { + getPrinter().stripTrailing(); + getPrinter().print(","); + + iter_enumConstantDeclaration.next().accept(getTraverser()); + } + } + + getPrinter().stripTrailing(); + getPrinter().print(","); + + if (node.isPresentEnumBody()) { + node.getEnumBody().accept(getTraverser()); + } + + getPrinter().unindent(); + getPrinter().println(); + getPrinter().println("} "); + + getPrinter().stripTrailing(); + + if (this.isPrintComments()) { + de.monticore.prettyprint.CommentPrettyPrinter.printPostComments(node, getPrinter()); + } + } +} From 72fd228c6e763549a4dfbf31fdaabcfc1aebe3a6 Mon Sep 17 00:00:00 2001 From: Janik Rapp Date: Mon, 1 Dec 2025 17:32:00 +0100 Subject: [PATCH 53/61] add support for try-with-resources with external resources --- javaDSL/src/main/grammars/de/monticore/java/JavaDSL.mc4 | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/javaDSL/src/main/grammars/de/monticore/java/JavaDSL.mc4 b/javaDSL/src/main/grammars/de/monticore/java/JavaDSL.mc4 index 5933dd3b..0715f960 100644 --- a/javaDSL/src/main/grammars/de/monticore/java/JavaDSL.mc4 +++ b/javaDSL/src/main/grammars/de/monticore/java/JavaDSL.mc4 @@ -380,6 +380,13 @@ LambdaParameter implements Variable = (["var"] | MCType)? Name; TryLocalVariableDeclaration = JavaModifier* (["var"] | MCType) DeclaratorId "=" Expression ; +// Add support for try-with-resources with external resources +TryStatement4 implements MCStatement + = "try" "(" resource:Field ")" + core:MCJavaBlock + CatchClause* + ("finally" finally:MCJavaBlock)? ; + @Override EnhancedForControl implements ForControl = EnhancedForControlFormalParameter ":" Expression; From 78a139eed892fb243f636a1b6c2f00d412c5c347 Mon Sep 17 00:00:00 2001 From: Janik Rapp Date: Mon, 1 Dec 2025 17:41:31 +0100 Subject: [PATCH 54/61] fix prettyprinter --- .../java/javadsl/_prettyprint/JavaDSLPrettyPrinter.java | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/javaDSL/src/main/java/de/monticore/java/javadsl/_prettyprint/JavaDSLPrettyPrinter.java b/javaDSL/src/main/java/de/monticore/java/javadsl/_prettyprint/JavaDSLPrettyPrinter.java index cbb1f32c..1faf2c7e 100644 --- a/javaDSL/src/main/java/de/monticore/java/javadsl/_prettyprint/JavaDSLPrettyPrinter.java +++ b/javaDSL/src/main/java/de/monticore/java/javadsl/_prettyprint/JavaDSLPrettyPrinter.java @@ -11,6 +11,7 @@ public JavaDSLPrettyPrinter(IndentPrinter printer, boolean printComments) { super(printer, printComments); } + @Override public void handle(de.monticore.java.javadsl._ast.ASTClassDeclaration node) { if (this.isPrintComments()) { de.monticore.prettyprint.CommentPrettyPrinter.printPreComments(node, getPrinter()); @@ -53,6 +54,7 @@ public void handle(de.monticore.java.javadsl._ast.ASTClassDeclaration node) { } } + @Override public void handle(de.monticore.java.javadsl._ast.ASTRecordDeclaration node) { if (this.isPrintComments()) { de.monticore.prettyprint.CommentPrettyPrinter.printPreComments(node, getPrinter()); @@ -60,7 +62,7 @@ public void handle(de.monticore.java.javadsl._ast.ASTRecordDeclaration node) { java.util.Iterator iter_implementedInterface = node.getImplementedInterfaceList().iterator(); - node.getMCModifierList().stream().map(m -> (ASTJavaModifier) m).collect(Collectors.toList()).forEach(n -> n.accept(getTraverser())); + node.getMCModifierList().forEach(n->n.accept(getTraverser())); getPrinter().print("record "); @@ -94,6 +96,7 @@ public void handle(de.monticore.java.javadsl._ast.ASTRecordDeclaration node) { } } + @Override public void handle(de.monticore.java.javadsl._ast.ASTInterfaceDeclaration node) { if (this.isPrintComments()) { de.monticore.prettyprint.CommentPrettyPrinter.printPreComments(node, getPrinter()); @@ -134,6 +137,7 @@ public void handle(de.monticore.java.javadsl._ast.ASTInterfaceDeclaration node) } + @Override public void handle(de.monticore.java.javadsl._ast.ASTEnumDeclaration node) { if (this.isPrintComments()) { de.monticore.prettyprint.CommentPrettyPrinter.printPreComments(node, getPrinter()); From a15243c910a0fd263c2e2385b84084b0f4dbb32f Mon Sep 17 00:00:00 2001 From: Janik Rapp Date: Mon, 1 Dec 2025 17:47:56 +0100 Subject: [PATCH 55/61] fix prettyprinter --- .../java/javadsl/_prettyprint/JavaDSLPrettyPrinter.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/javaDSL/src/main/java/de/monticore/java/javadsl/_prettyprint/JavaDSLPrettyPrinter.java b/javaDSL/src/main/java/de/monticore/java/javadsl/_prettyprint/JavaDSLPrettyPrinter.java index 1faf2c7e..3f5f1547 100644 --- a/javaDSL/src/main/java/de/monticore/java/javadsl/_prettyprint/JavaDSLPrettyPrinter.java +++ b/javaDSL/src/main/java/de/monticore/java/javadsl/_prettyprint/JavaDSLPrettyPrinter.java @@ -62,7 +62,7 @@ public void handle(de.monticore.java.javadsl._ast.ASTRecordDeclaration node) { java.util.Iterator iter_implementedInterface = node.getImplementedInterfaceList().iterator(); - node.getMCModifierList().forEach(n->n.accept(getTraverser())); + node.getJavaModifierList().forEach(n->n.accept(getTraverser())); getPrinter().print("record "); From df922317a336d52ea392ee53daf002ca65afd89d Mon Sep 17 00:00:00 2001 From: Janik Rapp Date: Tue, 2 Dec 2025 16:32:56 +0100 Subject: [PATCH 56/61] temporary removal of record-nokeyword --- javaDSL/src/main/grammars/de/monticore/java/JavaDSL.mc4 | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/javaDSL/src/main/grammars/de/monticore/java/JavaDSL.mc4 b/javaDSL/src/main/grammars/de/monticore/java/JavaDSL.mc4 index 0715f960..5a63ff08 100644 --- a/javaDSL/src/main/grammars/de/monticore/java/JavaDSL.mc4 +++ b/javaDSL/src/main/grammars/de/monticore/java/JavaDSL.mc4 @@ -190,7 +190,8 @@ scope(shadowing) RecordDeclaration extends TypeDeclaration ; // TODO: "record" is a contextual keyword, but setting it to nokeyword creates conflicts with MethodDeclaration -nokeyword "record"; +// -> might need to be fixed in MontiCore itself +//nokeyword "record"; RecordHeader = "(" (RecordComponent || ",")* ")" From 5118e21a27bbe27569e9c2dc2ffc425ab6d4b58b Mon Sep 17 00:00:00 2001 From: Janik Rapp Date: Thu, 4 Dec 2025 15:24:38 +0100 Subject: [PATCH 57/61] added MCStructuralTypes to support intersection types --- javaDSL/src/main/grammars/de/monticore/java/JavaDSL.mc4 | 4 +++- .../monticore/java/javadsl/types3/JavaDSLTypeCheck3.java | 8 ++++++-- 2 files changed, 9 insertions(+), 3 deletions(-) diff --git a/javaDSL/src/main/grammars/de/monticore/java/JavaDSL.mc4 b/javaDSL/src/main/grammars/de/monticore/java/JavaDSL.mc4 index 5a63ff08..e6b66e35 100644 --- a/javaDSL/src/main/grammars/de/monticore/java/JavaDSL.mc4 +++ b/javaDSL/src/main/grammars/de/monticore/java/JavaDSL.mc4 @@ -71,6 +71,7 @@ package de.monticore.java; * |-> de.monticore.types.MCBasicTypes (*) * |-> de.monticore.types.MCFullGenericTypes (*) * |-> de.monticore.types.TypeParameters (*) + * |-> de.monticore.types.MCStructuralTypes * * (*) Repeated Dependencies are omitted. */ @@ -83,7 +84,8 @@ grammar JavaDSL extends de.monticore.statements.MCFullJavaStatements, de.monticore.types.MCArrayTypes, de.monticore.types.MCFullGenericTypes, - de.monticore.types.TypeParameters { + de.monticore.types.TypeParameters, + de.monticore.types.MCStructuralTypes { start CompilationUnit; diff --git a/javaDSL/src/main/java/de/monticore/java/javadsl/types3/JavaDSLTypeCheck3.java b/javaDSL/src/main/java/de/monticore/java/javadsl/types3/JavaDSLTypeCheck3.java index 7e948918..85514bea 100644 --- a/javaDSL/src/main/java/de/monticore/java/javadsl/types3/JavaDSLTypeCheck3.java +++ b/javaDSL/src/main/java/de/monticore/java/javadsl/types3/JavaDSLTypeCheck3.java @@ -9,10 +9,10 @@ import de.monticore.literals.mccommonliterals.types3.MCCommonLiteralsTypeVisitor; import de.monticore.literals.mcjavaliterals.types3.MCJavaLiteralsTypeVisitor; import de.monticore.symbols.basicsymbols.BasicSymbolsMill; -import de.monticore.types.mcbasictypes.types3.MCBasicTypesTypeVisitor; import de.monticore.types.mccollectiontypes.types3.MCCollectionTypesTypeVisitor; import de.monticore.types.mcfullgenerictypes.types3.MCFullGenericTypesTypeVisitor; import de.monticore.types.mcsimplegenerictypes.types3.MCSimpleGenericTypesTypeVisitor; +import de.monticore.types.mcstructuraltypes.types3.MCStructuralTypesTypeVisitor; import de.monticore.types3.Type4Ast; import de.monticore.types3.generics.context.InferenceContext4Ast; import de.monticore.types3.util.*; @@ -27,7 +27,7 @@ public static void init(){ // initialize static delegates BasicSymbolsMill.initializePrimitives(); OOWithinScopeBasicSymbolsResolver.init(); - OOWithinTypeBasicSymbolsResolver.init(); + JavaDSLOOWithinTypeBasicSymbolsResolver.init(); TypeContextCalculator.init(); TypeVisitorOperatorCalculator.init(); TypeVisitorLifting.init(); @@ -103,6 +103,10 @@ public static void init(){ visMCFullGenericTypes.setType4Ast(type4Ast); traverser.add4MCFullGenericTypes(visMCFullGenericTypes); + MCStructuralTypesTypeVisitor visMCStructuralTypes = new MCStructuralTypesTypeVisitor(); + visMCStructuralTypes.setType4Ast(type4Ast); + traverser.add4MCStructuralTypes(visMCStructuralTypes); + JavaDSLTypeCheck3 javaDSLTC3 = new JavaDSLTypeCheck3(traverser, type4Ast, ctx4Ast); javaDSLTC3.setThisAsDelegate(); } From f96a165027f6774919535e2e4297cf2ab6ca0787 Mon Sep 17 00:00:00 2001 From: Janik Rapp Date: Thu, 4 Dec 2025 15:28:22 +0100 Subject: [PATCH 58/61] increase java thread stack --- gradle.properties | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/gradle.properties b/gradle.properties index d7f65498..70802703 100644 --- a/gradle.properties +++ b/gradle.properties @@ -6,7 +6,7 @@ useLocalRepo=false org.gradle.caching=true org.gradle.welcome=never -org.gradle.jvmargs=-Xms3072m -Dfile.encoding=UTF-8 +org.gradle.jvmargs=-Xms3072m -Xss16m -Dfile.encoding=UTF-8 version=7.9.0-SNAPSHOT From 09c9824104dec1042e56c3dc1f0010162c911951 Mon Sep 17 00:00:00 2001 From: Janik Rapp Date: Thu, 4 Dec 2025 16:33:25 +0100 Subject: [PATCH 59/61] added JavaDSLOOWithinTypeBasicSymbolsResolver --- ...vaDSLOOWithinTypeBasicSymbolsResolver.java | 132 ++++++++++++++++++ 1 file changed, 132 insertions(+) create mode 100644 javaDSL/src/main/java/de/monticore/java/javadsl/types3/JavaDSLOOWithinTypeBasicSymbolsResolver.java diff --git a/javaDSL/src/main/java/de/monticore/java/javadsl/types3/JavaDSLOOWithinTypeBasicSymbolsResolver.java b/javaDSL/src/main/java/de/monticore/java/javadsl/types3/JavaDSLOOWithinTypeBasicSymbolsResolver.java new file mode 100644 index 00000000..ec894d58 --- /dev/null +++ b/javaDSL/src/main/java/de/monticore/java/javadsl/types3/JavaDSLOOWithinTypeBasicSymbolsResolver.java @@ -0,0 +1,132 @@ +package de.monticore.java.javadsl.types3; + +import com.google.common.base.Preconditions; +import de.monticore.symbols.basicsymbols._symboltable.FunctionSymbol; +import de.monticore.symbols.oosymbols._symboltable.OOTypeSymbol; +import de.monticore.symboltable.IScopeSpanningSymbol; +import de.monticore.symboltable.modifiers.AccessModifier; +import de.monticore.types.check.SymTypeExpression; +import de.monticore.types.check.SymTypeOfFunction; +import de.monticore.types3.util.OOWithinTypeBasicSymbolsResolver; +import de.monticore.types3.util.WithinTypeBasicSymbolsResolver; +import de.se_rwth.commons.logging.Log; + +import java.util.ArrayList; +import java.util.List; +import java.util.Optional; +import java.util.function.Predicate; +import java.util.stream.Collectors; + +public class JavaDSLOOWithinTypeBasicSymbolsResolver extends OOWithinTypeBasicSymbolsResolver { + + @Override + protected List resolvedFunctionsInSuperTypes(SymTypeExpression thisType, + String name, AccessModifier accessModifier, Predicate predicate) { + List resolvedFuncsInSuperTypes = + super.resolvedFunctionsInSuperTypes(thisType, name, accessModifier, predicate); + List filteredFuncs = + filterMultipleInterfaceImplementation(resolvedFuncsInSuperTypes); + + return filteredFuncs; + } + + protected List filterMultipleInterfaceImplementation( + List funcs) { + if (funcs.size() < 2) { + return funcs; + } + List functionInheritedFromClasses = funcs.stream() + .filter(x -> getEnclosingType(x).isPresent() && getEnclosingType(x).get().isIsClass()) + .collect(Collectors.toList()); + if (functionInheritedFromClasses.isEmpty()) { + return funcs; + } + else if (functionInheritedFromClasses.size() > 1) { + Log.error("0x7A017: Can not filter inherited functions with multiple superclasses present."); + return funcs; + } + else { + SymTypeOfFunction classFunc = functionInheritedFromClasses.get(0); + Optional classFuncSymbol = getEnclosingType(classFunc); + if (classFuncSymbol.isEmpty()) { + Log.error("0x7A018: Enclosing type of classFunc is empty!"); + return funcs; + } + List classFuncSuperTypes = classFuncSymbol.get().getSuperTypesList(); + List classFuncSuperTypeSymbols = + getOOTypeSymbolsIfAvailable(classFuncSuperTypes); + List functionInheritedFromInterfaces = funcs.stream() + .filter(x -> getEnclosingType(x).isPresent() && getEnclosingType(x).get().isIsInterface()) + .collect(Collectors.toList()); + List filteredFuncs = new ArrayList<>(); + filteredFuncs.add(classFunc); + for (SymTypeOfFunction func : functionInheritedFromInterfaces) { + Optional funcInterface = getEnclosingType(func); + if (funcInterface.isPresent()) { + if (!isInterfaceContainedInSuperClass(classFuncSuperTypeSymbols, funcInterface.get())) { + filteredFuncs.add(func); + } + } + } + return filteredFuncs; + } + } + + protected List getOOTypeSymbolsIfAvailable(List exprs) { + // TODO: Replace with TypeDispatcher when fixed + return exprs.stream().filter(SymTypeExpression::hasTypeInfo).map(SymTypeExpression::getTypeInfo) + .filter(x -> x instanceof OOTypeSymbol).map(x -> (OOTypeSymbol) x) + .collect(Collectors.toList()); + } + + protected boolean isInterfaceContainedInSuperClass(List parents, + OOTypeSymbol testingType) { + if (parents.stream().anyMatch(x -> x.equals(testingType))) { + return true; + } + else { + for (OOTypeSymbol parent : parents) { + List newParents = getOOTypeSymbolsIfAvailable(parent.getSuperTypesList()); + if (isInterfaceContainedInSuperClass(newParents, testingType)) { + return true; + } + } + return false; + } + } + + protected Optional getEnclosingType(SymTypeOfFunction func) { + if (func.hasSymbol()) { + IScopeSpanningSymbol spanningSymbol = + func.getSymbol().getEnclosingScope().getSpanningSymbol(); + if (spanningSymbol instanceof OOTypeSymbol) { + return Optional.of((OOTypeSymbol) spanningSymbol); + } + } + return Optional.empty(); + } + + // static delegate + + public static void init() { + Log.trace("init JavaDSLOOWithinTypeBasicSymbolsResolver", "TypeCheck setup"); + setDelegate(new JavaDSLOOWithinTypeBasicSymbolsResolver()); + } + + public static void reset() { + OOWithinTypeBasicSymbolsResolver.delegate = null; + WithinTypeBasicSymbolsResolver.reset(); + } + + protected static void setDelegate(JavaDSLOOWithinTypeBasicSymbolsResolver newDelegate) { + OOWithinTypeBasicSymbolsResolver.delegate = Preconditions.checkNotNull(newDelegate); + WithinTypeBasicSymbolsResolver.setDelegate(newDelegate); + } + + protected static OOWithinTypeBasicSymbolsResolver getDelegate() { + if (OOWithinTypeBasicSymbolsResolver.delegate == null) { + init(); + } + return OOWithinTypeBasicSymbolsResolver.delegate; + } +} From a3dc87a32daa209a28367e98245a9eb9e4c2e285 Mon Sep 17 00:00:00 2001 From: Janik Rapp Date: Fri, 13 Mar 2026 12:47:00 +0100 Subject: [PATCH 60/61] update gradle shadow plugin for Java 21 --- build.gradle | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/build.gradle b/build.gradle index f174b941..ad647d5a 100644 --- a/build.gradle +++ b/build.gradle @@ -1,6 +1,6 @@ plugins { id "de.monticore.generator" version "$mc_version" apply false - id "com.github.johnrengelman.shadow" version "$shadow_plugin_version" apply false + id "com.gradleup.shadow" version "$shadow_plugin_version" apply false } allprojects { From e9fbc404395f74df9d9c44da5835bc377f1b84bc Mon Sep 17 00:00:00 2001 From: Janik Rapp Date: Fri, 13 Mar 2026 13:55:54 +0100 Subject: [PATCH 61/61] fixed Mill initialization in Java2CD --- .../java/java2cd/Java2CDVisitor.java | 20 +++++++++++++------ .../java/utils/JavaDSLSymbolTableUtil.java | 2 +- 2 files changed, 15 insertions(+), 7 deletions(-) diff --git a/javaDSL/src/main/java/de/monticore/java/java2cd/Java2CDVisitor.java b/javaDSL/src/main/java/de/monticore/java/java2cd/Java2CDVisitor.java index 6dbc02a5..b32d7955 100644 --- a/javaDSL/src/main/java/de/monticore/java/java2cd/Java2CDVisitor.java +++ b/javaDSL/src/main/java/de/monticore/java/java2cd/Java2CDVisitor.java @@ -13,6 +13,7 @@ import de.monticore.cdinterfaceandenum._ast.ASTCDInterface; import de.monticore.generating.templateengine.GlobalExtensionManagement; import de.monticore.generating.templateengine.StringHookPoint; +import de.monticore.java.javadsl.JavaDSLMill; import de.monticore.java.javadsl._ast.*; import de.monticore.java.javadsl._prettyprint.JavaDSLFullPrettyPrinter; import de.monticore.java.javadsl._visitor.JavaDSLVisitor2; @@ -98,7 +99,7 @@ public void visit(ASTClassDeclaration ast) { if (i instanceof ASTMCQualifiedType) { interfaces.add(((ASTMCQualifiedType) i).getMCQualifiedName().getQName()); } else { - interfaces.add(i.printType()); + interfaces.add(printJavaDSLASTMCType(i)); } } } @@ -106,7 +107,7 @@ public void visit(ASTClassDeclaration ast) { if (ast.isPresentSuperClass()) { classBuilder = classBuilder .setCDExtendUsage(CDExtendUsageFacade.getInstance() - .createCDExtendUsage(getMCType(ast.getSuperClass()).printType())); + .createCDExtendUsage(printJavaDSLASTMCType(getMCType(ast.getSuperClass())))); } ASTCDClass cdClass = classBuilder.build(); @@ -127,7 +128,7 @@ public void visit(ASTRecordDeclaration ast) { .createCDInterfaceUsage( ast.getImplementedInterfaceList() .stream() - .map(ASTMCType::printType) + .map(this::printJavaDSLASTMCType) .toArray(String[]::new))); } @@ -168,7 +169,7 @@ public void visit(ASTInterfaceDeclaration ast) { .createCDExtendUsage( ast.getExtendedInterfaceList() .stream() - .map(ASTMCType::printType) + .map(this::printJavaDSLASTMCType) .toArray(String[]::new))) .build(); @@ -185,7 +186,7 @@ public void visit(ASTEnumDeclaration ast) { .createCDInterfaceUsage( ast.getImplementedInterfaceList() .stream() - .map(ASTMCType::printType) + .map(this::printJavaDSLASTMCType) .toArray(String[]::new))) .build(); @@ -257,7 +258,7 @@ protected ASTMCType getMCType(ASTMCType mcType) { @Override public void visit(ASTMethodDeclaration ast) { ASTCDMethod method = CDMethodFacade.getInstance().createMethod( - getModifier(ast.getMCModifierList().stream().map(m -> (ASTJavaModifier) m).collect(Collectors.toList())), + getModifier(ast.getMCModifierList().stream().filter(m -> m instanceof ASTJavaModifier).map(m -> (ASTJavaModifier) m).collect(Collectors.toList())), ast.getName()); if (ast.getMCReturnType().isPresentMCType()) { @@ -399,4 +400,11 @@ protected ASTModifier getModifier(List modifiers) { public ASTCDCompilationUnit getCompilationUnit() { return cdCompilationUnit; } + + public String printJavaDSLASTMCType(ASTMCType type) { + JavaDSLMill.init(); + String printedType = type.printType(); + CD4CodeMill.init(); + return printedType; + } } diff --git a/javaDSL/src/main/java/de/monticore/java/utils/JavaDSLSymbolTableUtil.java b/javaDSL/src/main/java/de/monticore/java/utils/JavaDSLSymbolTableUtil.java index 22aa3662..901da21d 100644 --- a/javaDSL/src/main/java/de/monticore/java/utils/JavaDSLSymbolTableUtil.java +++ b/javaDSL/src/main/java/de/monticore/java/utils/JavaDSLSymbolTableUtil.java @@ -45,7 +45,7 @@ public static List buildSymbolTable(List