From 3274f1292294503e363da2f06ec89573f8b512c6 Mon Sep 17 00:00:00 2001 From: JanUlrich Date: Tue, 22 Aug 2017 16:45:28 +0200 Subject: [PATCH] Fehler in TypeInsert beheben --- .../SyntaxTreeGenerator/TypeGenerator.java | 3 +- .../syntaxtree/AbstractASTWalker.java | 100 ++++++++++++++++++ .../typecheck/JavaClassRegistry.java | 47 +++++--- .../typedeployment/TypeInsert.java | 3 +- .../typedeployment/TypeInsertFactory.java | 30 +----- .../typedeployment/TypeInsertPlacer.java | 99 +++++++++++++++++ .../typedeployment/TypeInsertPoint.java | 2 +- test/javFiles/mathStruc.jav | 2 + test/typeinference/JavaTXCompilerTest.java | 3 +- 9 files changed, 245 insertions(+), 44 deletions(-) create mode 100644 src/de/dhbwstuttgart/typedeployment/TypeInsertPlacer.java diff --git a/src/de/dhbwstuttgart/parser/SyntaxTreeGenerator/TypeGenerator.java b/src/de/dhbwstuttgart/parser/SyntaxTreeGenerator/TypeGenerator.java index 605e76b5..c1f608de 100644 --- a/src/de/dhbwstuttgart/parser/SyntaxTreeGenerator/TypeGenerator.java +++ b/src/de/dhbwstuttgart/parser/SyntaxTreeGenerator/TypeGenerator.java @@ -18,6 +18,7 @@ import de.dhbwstuttgart.typecheck.JavaClassRegistry; import org.antlr.v4.runtime.Token; import java.util.ArrayList; +import java.util.Arrays; import java.util.List; public class TypeGenerator { @@ -92,7 +93,7 @@ public class TypeGenerator { public static RefTypeOrTPHOrWildcardOrGeneric convertTypeName( String name, Java8Parser.TypeArgumentsContext typeArguments, Token offset, JavaClassRegistry reg, GenericsRegistry generics){ - if(!reg.contains(name)){ //Dann könnte es ein Generische Type sein: + if(!reg.contains(name)){ //Dann könnte es ein Generische Type sein if(generics.keySet().contains(name)){ return new GenericRefType(new GenericTypeName(generics.get(name),name), offset); }else{ diff --git a/src/de/dhbwstuttgart/syntaxtree/AbstractASTWalker.java b/src/de/dhbwstuttgart/syntaxtree/AbstractASTWalker.java index 12696edc..bb200559 100644 --- a/src/de/dhbwstuttgart/syntaxtree/AbstractASTWalker.java +++ b/src/de/dhbwstuttgart/syntaxtree/AbstractASTWalker.java @@ -24,6 +24,11 @@ public abstract class AbstractASTWalker implements ASTVisitor{ } } + @Override + public void visit(GenericTypeVar genericTypeVar) { + + } + @Override public void visit(FormalParameter formalParameter) { formalParameter.getType().accept(this); @@ -87,11 +92,21 @@ public abstract class AbstractASTWalker implements ASTVisitor{ superWildcardType.getInnerType().accept(this); } + @Override + public void visit(TypePlaceholder typePlaceholder) { + + } + @Override public void visit(ExtendsWildcardType extendsWildcardType) { extendsWildcardType.getInnerType().accept(this); } + @Override + public void visit(GenericRefType genericRefType) { + + } + @Override public void visit(LambdaExpression lambdaExpression) { lambdaExpression.params.accept(this); @@ -104,6 +119,11 @@ public abstract class AbstractASTWalker implements ASTVisitor{ assign.rightSide.accept(this); } + @Override + public void visit(Binary binary) { + + } + @Override public void visit(Block block) { for(Statement stmt : block.getStatements()){ @@ -111,11 +131,41 @@ public abstract class AbstractASTWalker implements ASTVisitor{ } } + @Override + public void visit(CastExpr castExpr) { + + } + + @Override + public void visit(EmptyStmt emptyStmt) { + + } + @Override public void visit(FieldVar fieldVar) { fieldVar.receiver.accept(this); } + @Override + public void visit(ForStmt forStmt) { + + } + + @Override + public void visit(IfStmt ifStmt) { + + } + + @Override + public void visit(InstanceOf instanceOf) { + + } + + @Override + public void visit(LocalVar localVar) { + + } + @Override public void visit(LocalVarDecl localVarDecl) { @@ -133,6 +183,11 @@ public abstract class AbstractASTWalker implements ASTVisitor{ visit((MethodCall) methodCall); } + @Override + public void visit(NewArray newArray) { + + } + @Override public void visit(Receiver receiver) { receiver.expr.accept(this); @@ -142,4 +197,49 @@ public abstract class AbstractASTWalker implements ASTVisitor{ public void visit(Return aReturn) { aReturn.retexpr.accept(this); } + + @Override + public void visit(ReturnVoid aReturn) { + + } + + @Override + public void visit(StaticClassName staticClassName) { + + } + + @Override + public void visit(Super aSuper) { + + } + + @Override + public void visit(This aThis) { + + } + + @Override + public void visit(UnaryPlus unaryPlus) { + + } + + @Override + public void visit(WhileStmt whileStmt) { + + } + + @Override + public void visit(DoStmt whileStmt) { + + } + + @Override + public void visit(Null aNull) { + + } + + @Override + public void visit(Literal literal) { + + } } diff --git a/src/de/dhbwstuttgart/typecheck/JavaClassRegistry.java b/src/de/dhbwstuttgart/typecheck/JavaClassRegistry.java index ad86b0bf..cbd66d37 100644 --- a/src/de/dhbwstuttgart/typecheck/JavaClassRegistry.java +++ b/src/de/dhbwstuttgart/typecheck/JavaClassRegistry.java @@ -33,19 +33,12 @@ public class JavaClassRegistry { if(name.equals(new JavaClassName(className)))return name; } //Jetzt noch alle importierten Packages durchsuchen: - ClassLoader loader = Thread.currentThread().getContextClassLoader(); - String shortName = JavaClassName.stripClassName(className); - for(String packageName : importedPackages) { - try { - loader.loadClass(packageName+"."+shortName); - //Keine Exception! Die Klasse existiert: - JavaClassName ret = new JavaClassName(packageName+"."+shortName); - if(ret.equals(new JavaClassName(className)))return ret; - } catch (ClassNotFoundException e) { - //Die Klasse wurde nicht gefunden! - } + JavaClassName ret = getClassFromImportedPackages(className); + if(ret == null){ + throw new TypeNotPresentException(className, new Throwable()); + }else{ + return ret; } - throw new TypeNotPresentException(className, new Throwable()); } @Override @@ -55,7 +48,33 @@ public class JavaClassRegistry { public boolean contains(String whole) { boolean ret = existingClasses.contains(new JavaClassName(whole)); - if(ret == false)existingClasses.add(getName(whole)); - return true; + if(ret == false){ + JavaClassName imported = getClassFromImportedPackages(whole); + if(imported != null){ + existingClasses.add(imported); + return true; + }else { + return false; + } + }else { + return true; + } } + + private JavaClassName getClassFromImportedPackages(String className){ + ClassLoader loader = Thread.currentThread().getContextClassLoader(); + String shortName = JavaClassName.stripClassName(className); + for(String packageName : importedPackages) { + try { + loader.loadClass(packageName+"."+shortName); + //Keine Exception! Die Klasse existiert: + JavaClassName ret = new JavaClassName(packageName+"."+shortName); + if(ret.equals(new JavaClassName(className)))return ret; + } catch (ClassNotFoundException e) { + //Die Klasse wurde nicht gefunden! + } + } + return null; + } + } diff --git a/src/de/dhbwstuttgart/typedeployment/TypeInsert.java b/src/de/dhbwstuttgart/typedeployment/TypeInsert.java index 0bd42b39..4756e49f 100644 --- a/src/de/dhbwstuttgart/typedeployment/TypeInsert.java +++ b/src/de/dhbwstuttgart/typedeployment/TypeInsert.java @@ -20,8 +20,9 @@ public class TypeInsert { } public String insert(String intoSource){ - String ret = intoSource; List offsets = new ArrayList<>(); + String ret = point.insert(intoSource, offsets); + offsets.add(point); for(TypeInsertPoint insertPoint : inserts){ ret = insertPoint.insert(ret, offsets); offsets.add(insertPoint); diff --git a/src/de/dhbwstuttgart/typedeployment/TypeInsertFactory.java b/src/de/dhbwstuttgart/typedeployment/TypeInsertFactory.java index 2c7c6791..7fe7b05d 100644 --- a/src/de/dhbwstuttgart/typedeployment/TypeInsertFactory.java +++ b/src/de/dhbwstuttgart/typedeployment/TypeInsertFactory.java @@ -25,36 +25,14 @@ import java.util.*; * inferieren, wenn A bereits eingesetzt wurde. Es werden dann eben zusätzliche Generics entstehen */ public class TypeInsertFactory { - public static List createTypeInsertPoints(SourceFile forSourcefile, ResultSet withResults){ - List ret = new ArrayList<>(); - for(ClassOrInterface cl : forSourcefile.getClasses()){ - //Felder: - for(Field field : cl.getFieldDecl()){ - if(field.getType() instanceof TypePlaceholder){ - for(Set pairs : withResults.results) - ret.add(createInsertPoints( - field.getType(), field.getType().getOffset(), cl, null, pairs)); - } - } - for(Method m : cl.getMethods()){ - if(m.getReturnType() instanceof TypePlaceholder)for(Set pairs : withResults.results) { - ret.add(createInsertPoints( - m.getReturnType(), m.getReturnType().getOffset(), cl, m, pairs)); - } - for(FormalParameter param : m.getParameterList().getFormalparalist()){ - if(param.getType() instanceof TypePlaceholder)for(Set pairs : withResults.results) - ret.add(createInsertPoints( - param.getType(), param.getType().getOffset(), cl, m, pairs)); - } - } - } - return ret; + public static Set createTypeInsertPoints(SourceFile forSourcefile, ResultSet withResults){ + return new TypeInsertPlacer().getTypeInserts(forSourcefile, withResults); } - private static TypeInsert createInsertPoints(RefTypeOrTPHOrWildcardOrGeneric type, Token offset, ClassOrInterface cl, Method m, - Set pairs) { + public static TypeInsert createInsertPoints(RefTypeOrTPHOrWildcardOrGeneric type, Token offset, ClassOrInterface cl, Method m, + Set pairs) { Set ret = new HashSet<>(); TypeInsertPoint insertPoint = null; Set additionalInserts = new HashSet<>(); diff --git a/src/de/dhbwstuttgart/typedeployment/TypeInsertPlacer.java b/src/de/dhbwstuttgart/typedeployment/TypeInsertPlacer.java new file mode 100644 index 00000000..88e7ad68 --- /dev/null +++ b/src/de/dhbwstuttgart/typedeployment/TypeInsertPlacer.java @@ -0,0 +1,99 @@ +package de.dhbwstuttgart.typedeployment; + +import de.dhbwstuttgart.syntaxtree.*; +import de.dhbwstuttgart.syntaxtree.statement.LambdaExpression; +import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder; +import de.dhbwstuttgart.typeinference.ResultSet; +import de.dhbwstuttgart.typeinference.constraints.Pair; + +import java.util.ArrayList; +import java.util.HashSet; +import java.util.List; +import java.util.Set; + +public class TypeInsertPlacer extends AbstractASTWalker{ + Set inserts = new HashSet<>(); + private ResultSet withResults; + + public Set getTypeInserts(SourceFile forSourceFile, ResultSet withResults){ + this.withResults = withResults; + forSourceFile.accept(this); + return inserts; + } + + @Override + public void visit(ClassOrInterface classOrInterface) { + TypeInsertPlacerClass cl = new TypeInsertPlacerClass(classOrInterface, withResults); + this.inserts.addAll(cl.inserts); + } + + /* + List ret = new ArrayList<>(); + + for(ClassOrInterface cl : forSourcefile.getClasses()){ + //Felder: + for(Field field : cl.getFieldDecl()){ + + } + + for(Method m : cl.getMethods()){ + if(m.getReturnType() instanceof TypePlaceholder)for(Set pairs : withResults.results) { + ret.add(createInsertPoints( + m.getReturnType(), m.getReturnType().getOffset(), cl, m, pairs)); + } + + for(FormalParameter param : m.getParameterList().getFormalparalist()){ + if(param.getType() instanceof TypePlaceholder)for(Set pairs : withResults.results) + ret.add(createInsertPoints( + param.getType(), param.getType().getOffset(), cl, m, pairs)); + } + } + } + return ret; + */ +} + +class TypeInsertPlacerClass extends AbstractASTWalker{ + private final ResultSet results; + private final ClassOrInterface cl; + public final Set inserts = new HashSet<>(); + + TypeInsertPlacerClass(ClassOrInterface forClass, ResultSet withResults){ + this.cl = forClass; + this.results = withResults; + forClass.accept(this); + } + + @Override + public void visit(Method method) { + TypeInsertPlacerMethod mWalker = new TypeInsertPlacerMethod(method); + super.visit(method); + } + + @Override + public void visit(Field field) { + if(field.getType() instanceof TypePlaceholder){ + for(Set pairs : results.results) + inserts.add(TypeInsertFactory.createInsertPoints( + field.getType(), field.getType().getOffset(), cl, null, pairs)); + } + super.visit(field); + } +} + +class TypeInsertPlacerMethod extends AbstractASTWalker{ + TypeInsertPlacerMethod(Method forMethod){ + forMethod.accept(this); + } + + @Override + public void visit(ParameterList params) { + super.visit(params); + } + + @Override + public void visit(LambdaExpression lambdaExpression) { + //Lambda-Ausdrücke brauchen keine Typeinsetzungen + } + +} \ No newline at end of file diff --git a/src/de/dhbwstuttgart/typedeployment/TypeInsertPoint.java b/src/de/dhbwstuttgart/typedeployment/TypeInsertPoint.java index bc649413..816628e6 100644 --- a/src/de/dhbwstuttgart/typedeployment/TypeInsertPoint.java +++ b/src/de/dhbwstuttgart/typedeployment/TypeInsertPoint.java @@ -11,7 +11,7 @@ public class TypeInsertPoint { public TypeInsertPoint(Token point, String toInsert){ this.point = point; - this.insertString = (toInsert.length()>1) ? toInsert + " " : toInsert; + this.insertString = (toInsert.endsWith(" ")) ? toInsert : toInsert + " " ; } public String insert(String intoSource, List additionalOffset){ diff --git a/test/javFiles/mathStruc.jav b/test/javFiles/mathStruc.jav index 2e0620fb..9f7ae92d 100644 --- a/test/javFiles/mathStruc.jav +++ b/test/javFiles/mathStruc.jav @@ -1,5 +1,7 @@ class mathStruc { +a; + mathStruc(A a) { } A model(){ A a; return a; } diff --git a/test/typeinference/JavaTXCompilerTest.java b/test/typeinference/JavaTXCompilerTest.java index dbd924a4..a129b13e 100644 --- a/test/typeinference/JavaTXCompilerTest.java +++ b/test/typeinference/JavaTXCompilerTest.java @@ -22,6 +22,7 @@ import java.nio.file.Files; import java.nio.file.Paths; import java.util.ArrayList; import java.util.List; +import java.util.Set; import static org.junit.Assert.*; @@ -44,7 +45,7 @@ public class JavaTXCompilerTest extends JavaTXCompiler { for(File f : filesToTest){ SourceFile sf = this.parse(f); System.out.println(ASTTypePrinter.print(this.sourceFiles.get(sourceFiles.size()-1))); - List result = TypeInsertFactory.createTypeInsertPoints(sf, this.typeInference()); + Set result = TypeInsertFactory.createTypeInsertPoints(sf, this.typeInference()); String content = readFile(f.getPath(), StandardCharsets.UTF_8); for(TypeInsert tip : result){ System.out.println(tip.insert(content));