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/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 diff --git a/javaDSL/build.gradle b/javaDSL/build.gradle index 9db43956..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,11 +51,26 @@ 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" 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" diff --git a/javaDSL/src/main/grammars/de/monticore/java/JavaDSL.mc4 b/javaDSL/src/main/grammars/de/monticore/java/JavaDSL.mc4 index 06cc7ffe..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; @@ -122,10 +124,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,25 +155,25 @@ nokeyword "uses"; nokeyword "provides"; nokeyword "with"; nokeyword "to"; +nokeyword "transitive"; // Type declarations -abstract symbol scope TypeDeclaration implements ClassMemberDeclaration, InterfaceMemberDeclaration, AnnotationTypeElementDeclaration, MCBlockStatement, OOType = Name ; +// TODO: Remove Java-specific Interfaces, reuse component grammars and use CoCos for validation? +abstract symbol scope(shadowing) TypeDeclaration implements ClassMemberDeclaration, InterfaceMemberDeclaration, AnnotationTypeElementDeclaration, MCBlockStatement, OOType = Name ; symbolrule TypeDeclaration = - isAnnotation: boolean ; + isAnnotation: boolean + isRecord: boolean; -symbol 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 || ",")+)? - ClassBody + ClassBody ";"* ; -symbolrule ClassDeclaration = - superInterface:MCType* - constructor: de.monticore.javalight._symboltable.JavaMethodSymbol* - methods: de.monticore.javalight._symboltable.JavaMethodSymbol* ; - +// TODO Replace with MCJavaBlock? -> with CoCos? ClassBody = "{" ClassBodyDeclaration* "}" ; @@ -181,12 +184,17 @@ ClassBody * https://docs.oracle.com/javase/specs/jls/se19/html/jls-8.html#jls-8.10 */ -symbol 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 + RecordBody ";"* ; +// TODO: "record" is a contextual keyword, but setting it to nokeyword creates conflicts with MethodDeclaration +// -> might need to be fixed in MontiCore itself +//nokeyword "record"; + RecordHeader = "(" (RecordComponent || ",")* ")" ; @@ -200,6 +208,7 @@ astrule RecordComponent = return this.isPresentVariableArity(); }; +// TODO Replace with MCJavaBlock? -> with CoCos? RecordBody = "{" (ClassBodyDeclaration | CompactConstructorDeclaration)* "}" ; @@ -208,27 +217,27 @@ CompactConstructorDeclaration = JavaModifier* Name body:MCJavaBlock ; -symbol 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 + InterfaceBody ";"* ; +// TODO Replace with MCJavaBlock? -> with CoCos? InterfaceBody = "{" InterfaceBodyDeclaration* "}" ; -symbol 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? "}" + "{" (EnumConstantDeclaration || ",")* ","? EnumBody? "}" ";"* ; -symbolrule EnumDeclaration = - constructor: de.monticore.javalight._symboltable.JavaMethodSymbol* - methods: de.monticore.javalight._symboltable.JavaMethodSymbol*; - -symbol EnumConstantDeclaration +// TODO: Remove scope duplicate when monticore#4726 is fixed +scope(shadowing) symbol EnumConstantDeclaration implements Field = Annotation* Name Arguments? ClassBody? ; @@ -237,9 +246,12 @@ EnumBody ; ClassBlock implements ClassBodyDeclaration - = (["static"])? JavaBlock + = (["static"])? MCJavaBlock ; +@Override +EmptyStatement implements ClassBodyDeclaration; + interface ClassMemberDeclaration extends ClassBodyDeclaration ; interface MethodBody ; @@ -266,21 +278,25 @@ ArrayInitializer implements VariableInitializer ; // ANNOTATIONS - -symbol 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? | 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 || ",")+ ";" ; @@ -309,6 +325,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 || ".")+ @@ -316,33 +341,9 @@ MCQualifiedType implements MCObjectType // STATEMENTS / BLOCKS -interface Statement extends MCBlockStatement ; - -scope 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 - ; +// TODO: Remove scope duplicate when monticore#4726 is fixed +@Override +scope(shadowing) MCJavaBlock implements MethodBody, ConstructorBody; IdentifierAndTypeArgument = Name TypeArguments? @@ -352,17 +353,16 @@ TypeArguments = "<" (MCTypeArgument || ",")* ">" ; -interface FinallyBlock ; - -LabeledStatement implements Statement - = label:Name ":" Statement - ; - CreatedName = (IdentifierAndTypeArgument || ".")+ | 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 ; @@ -379,6 +379,24 @@ LocalVariableDeclaration @Override LambdaParameter implements Variable = (["var"] | MCType)? Name; +@Override +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; + +EnhancedForControlFormalParameter + = JavaModifier* (["var"] | MCType) Declarator; + nokeyword "var"; /* @@ -395,7 +413,7 @@ JavaAnnotation extends JavaModifier implements ElementValue ( "(" AnnotationArguments? ")" )? ; -AnonymousClass implements Creator +scope(shadowing) AnonymousClass extends ClassCreator implements Creator = MCType Arguments ClassBody? ; diff --git a/javaDSL/src/main/java/de/monticore/java/JavaDSLTool.java b/javaDSL/src/main/java/de/monticore/java/JavaDSLTool.java index 1a13475d..2e593d64 100644 --- a/javaDSL/src/main/java/de/monticore/java/JavaDSLTool.java +++ b/javaDSL/src/main/java/de/monticore/java/JavaDSLTool.java @@ -11,11 +11,13 @@ 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.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.*; @@ -24,22 +26,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 +54,6 @@ public static void main(String[] args) { * * @param args array of the command line arguments */ - @Override public void run(String[] args) { Options options = initOptions(); @@ -72,28 +73,92 @@ public void run(String[] args) { Log.init(); JavaDSLMill.init(); - - BasicSymbolsMill.initializePrimitives(); - BasicSymbolsMill.initializeString(); + + 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); - Collection asts = - 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); - - if (cmd.hasOption("path")) { - String[] paths = splitPathEntries(cmd.getOptionValue("path")); - JavaDSLMill.globalScope().setSymbolPath(new MCPath(paths)); + + Log.info(String.format("Successfully parsed %d files", asts.size()), "JavaDSLTool"); + + if (cmd.hasOption("pp")) { + String[] ppTargets = cmd.getOptionValues("pp"); + if (ppTargets == null || ppTargets.length == 0) { + asts.forEach(ast -> prettyPrintInFolder(ast, SYMBOLS_OUT_DIRECTORY)); + } + else if (ppTargets.length == 1 && isLikelyFolderPath(cmd.getOptionValue("pp"))) { + asts.forEach( + 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++) { + prettyPrintInFolder( + asts.get(i), + 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())); + } } - - Collection scopes = - asts.stream() - .map(ast -> createSymbolTable(ast, cmd)) - .collect(Collectors.toList()); - + + if (cmd.hasOption("s") || cmd.hasOption("o")) { + // Build symbol table and run symbol table completer + JavaDSLSymbolTableUtil.buildSymbolTable(asts); + } + 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 +245,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 +305,92 @@ 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 Java CompilationUnit + * @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 + * Stores the pretty printed result for ast in the specified folder. * - * @param scope symboltable to store - * @param path location of the file or directory containing the printed table + * @param compilationUnit The ast of the Java CompilationUnit + * @param folderPath The folder to store the pret */ - public void storeSymTab(IJavaDSLArtifactScope scope, String path) { - if (Path.of(path).toFile().isFile()) { - this.storeSymbols(scope, path); + 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. + * E.g.: model with qualified name a.b.c + * "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(); + 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("0x7A005: 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("."); + } + } 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..ede439cf --- /dev/null +++ b/javaDSL/src/main/java/de/monticore/java/javadsl/JavaDSLMill.java @@ -0,0 +1,81 @@ +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(); + } + 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/_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/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..3f5f1547 --- /dev/null +++ b/javaDSL/src/main/java/de/monticore/java/javadsl/_prettyprint/JavaDSLPrettyPrinter.java @@ -0,0 +1,198 @@ +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); + } + + @Override + 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()); + } + } + + @Override + 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.getJavaModifierList().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()); + } + } + + @Override + 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()); + } + + } + + @Override + 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()); + } + } +} 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/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/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 { - - - -} 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 new file mode 100644 index 00000000..9dea1342 --- /dev/null +++ b/javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/JavaDSLMCVarDeclarationStatementsSymTabCompletion.java @@ -0,0 +1,30 @@ +package de.monticore.java.javadsl._symboltable; + +import de.monticore.java.javadsl.JavaDSLMill; +import de.monticore.java.javadsl._visitor.JavaDSLVisitor2; +import de.monticore.statements.mcvardeclarationstatements._ast.ASTLocalVariableDeclaration; +import de.monticore.statements.mcvardeclarationstatements._ast.ASTVariableDeclarator; +import de.monticore.statements.mcvardeclarationstatements._symboltable.MCVarDeclarationStatementsSymTabCompletion; + +public class JavaDSLMCVarDeclarationStatementsSymTabCompletion + extends MCVarDeclarationStatementsSymTabCompletion implements JavaDSLVisitor2 { + + @Override + public void endVisit(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 2c435369..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 @@ -1,27 +1,152 @@ 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.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) { 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; - + if (ordinaryCompilationUnit.isPresentPackageDeclaration()) { 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 + artifactScope.addImports(new ImportStatement("java.lang", true)); + // TODO figure out how to map static imports - + return artifactScope; } - + + @Override + public void visit(ASTClassDeclaration node) { + super.visit(node); + + TypeDeclarationSymbol symbol = node.getSymbol(); + symbol.setIsClass(true); + + tryToUpdateScopeName(node, node.getJavaModifierList()); + updateModifiers(symbol, node.getJavaModifierList()); + } + + @Override + public void visit(ASTRecordDeclaration node) { + super.visit(node); + + TypeDeclarationSymbol symbol = node.getSymbol(); + symbol.setIsRecord(true); + + tryToUpdateScopeName(node, node.getJavaModifierList()); + updateModifiers(symbol, node.getJavaModifierList()); + } + + @Override + public void visit(ASTInterfaceDeclaration node) { + super.visit(node); + + TypeDeclarationSymbol symbol = node.getSymbol(); + symbol.setIsInterface(true); + + tryToUpdateScopeName(node, node.getJavaModifierList()); + updateModifiers(symbol, node.getJavaModifierList()); + } + + @Override + public void visit(ASTEnumDeclaration node) { + super.visit(node); + + TypeDeclarationSymbol symbol = node.getSymbol(); + symbol.setIsEnum(true); + + tryToUpdateScopeName(node, node.getJavaModifierList()); + updateModifiers(symbol, node.getJavaModifierList()); + } + + @Override + public void visit(ASTModuleDeclaration node) { + super.visit(node); + IJavaDSLScope enclosingScope = node.getEnclosingScope(); + if (JavaDSLMill.typeDispatcher().isJavaDSLIJavaDSLArtifactScope(enclosingScope)) { + 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/JavaDSLScopesGenitorP2.java b/javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/JavaDSLScopesGenitorP2.java new file mode 100644 index 00000000..f3dcafc2 --- /dev/null +++ b/javaDSL/src/main/java/de/monticore/java/javadsl/_symboltable/JavaDSLScopesGenitorP2.java @@ -0,0 +1,239 @@ +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; +import de.monticore.statements.mcarraystatements._ast.ASTArrayDeclaratorId; +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.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 JavaDSLScopesGenitorP2 implements JavaDSLVisitor2, JavaLightVisitor2 { + + @Override + public void endVisit(ASTEnumDeclaration node) { + TypeDeclarationSymbol symbol = node.getSymbol(); + + List supertypes = + node.getImplementedInterfaceList().stream().map(TypeCheck3::symTypeFromAST) + .collect(Collectors.toList()); + symbol.setSuperTypesList(supertypes); + } + + @Override + public void endVisit(ASTRecordDeclaration node) { + TypeDeclarationSymbol symbol = node.getSymbol(); + + 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); + symbol.setIsEnumConstant(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("0x0x7A003: 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(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 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"); + } + } + + @Override + public void endVisit(ASTClassDeclaration node) { + TypeDeclarationSymbol symbol = node.getSymbol(); + + 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())); + } + + @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) { + 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())); + } + } + } +} 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/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/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/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/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; + } +} 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); + } +} 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..85514bea --- /dev/null +++ b/javaDSL/src/main/java/de/monticore/java/javadsl/types3/JavaDSLTypeCheck3.java @@ -0,0 +1,128 @@ +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.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.*; +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(); + JavaDSLOOWithinTypeBasicSymbolsResolver.init(); + TypeContextCalculator.init(); + TypeVisitorOperatorCalculator.init(); + TypeVisitorLifting.init(); + FunctionRelations.init(); + + JavaDSLTraverser traverser = JavaDSLMill.traverser(); + 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); + 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 + + JavaDSLMCBasicTypesTypeVisitor visJavaDSLMCBasicTypesType = new JavaDSLMCBasicTypesTypeVisitor(); + visJavaDSLMCBasicTypesType.setType4Ast(type4Ast); + traverser.add4MCBasicTypes(visJavaDSLMCBasicTypesType); + + MCCollectionTypesTypeVisitor visMCCollectionTypes = new MCCollectionTypesTypeVisitor(); + visMCCollectionTypes.setType4Ast(type4Ast); + traverser.add4MCCollectionTypes(visMCCollectionTypes); + + MCSimpleGenericTypesTypeVisitor visMCSimpleGenericTypes = new MCSimpleGenericTypesTypeVisitor(); + visMCSimpleGenericTypes.setType4Ast(type4Ast); + traverser.add4MCSimpleGenericTypes(visMCSimpleGenericTypes); + + MCFullGenericTypesTypeVisitor visMCFullGenericTypes = new MCFullGenericTypesTypeVisitor(); + 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(); + } + + 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); + } +} 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..7df7e5ea --- /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("0x7A006 unable to find type " + + name + + " within type " + + prefixType.printFullName(), + mcQType.get_SourcePositionStart(), + mcQType.get_SourcePositionEnd() + ); + } + } + else { + Log.error("0x7A007 unexpected access \"." + + name + + "\" for type " + + prefixType.printFullName(), + mcQType.get_SourcePositionStart(), + mcQType.get_SourcePositionEnd() + ); + } + } + + } while (numberOfPartsUsedForFirstType < mcQType.sizeAnnotatedNames()); + + if (type.isEmpty()) { + Log.error("0x7A008 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()); + } +} 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/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..22aa3662 --- /dev/null +++ b/javaDSL/src/main/java/de/monticore/java/utils/JavaDSLSymbolTableUtil.java @@ -0,0 +1,66 @@ +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; +import de.monticore.java.javadsl._ast.ASTCompilationUnit; +import de.monticore.java.javadsl._symboltable.*; +import de.monticore.symbols.basicsymbols.BasicSymbolsMill; +import de.se_rwth.commons.logging.Log; + +import java.util.List; +import java.util.concurrent.TimeUnit; +import java.util.stream.Collectors; + +public class JavaDSLSymbolTableUtil { + + public static void prepareMill(boolean enableC2MC) { + JavaDSLMill.globalScope().clear(); + + BasicSymbolsMill.initializePrimitives(); + + if (enableC2MC) { + Class2MCResolver resolver = new OOClass2MCResolver(); + JavaDSLMill.globalScope().addAdaptedTypeSymbolResolver(resolver); + } + } + + public static IJavaDSLArtifactScope buildSymbolTable(ASTCompilationUnit ast) { + IJavaDSLArtifactScope as = runSymTabGenitor(ast); + runSymTabCompleter(ast); + return as; + } + + 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; + } + + public static IJavaDSLArtifactScope runSymTabGenitor(ASTCompilationUnit ast) { + JavaDSLScopesGenitorDelegator genitor = JavaDSLMill.scopesGenitorDelegator(); + 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); + } +} 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()); } 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/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); + } +} 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); + } +} 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/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 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 { }