From 4a52bc0e6edd185a9f5afc7ecb0ce3a524f0418c Mon Sep 17 00:00:00 2001 From: JanUlrich Date: Thu, 18 May 2017 13:17:52 +0200 Subject: [PATCH] =?UTF-8?q?TypeInsertFactory=20anf=C3=BCgen,=20convert=20U?= =?UTF-8?q?nifyPair->Pair=20implementieren?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/de/dhbwstuttgart/core/JavaTXCompiler.java | 32 +++++++- src/de/dhbwstuttgart/parser/JavaTXParser.java | 2 +- .../SyntaxTreeGenerator.java | 5 +- .../dhbwstuttgart/syntaxtree/SourceFile.java | 36 ++++----- .../syntaxtree/factory/UnifyTypeFactory.java | 74 ++++++++++--------- .../syntaxtree/type/SuperWildcardType.java | 2 +- .../syntaxtree/type/TypePlaceholder.java | 29 +------- .../typedeployment/TypeInsertFactory.java | 40 ++++++++++ .../typeinference/ResultSet.java | 27 ++++++- .../typeinference/constraints/Pair.java | 9 +-- .../typeinference/unify/model/UnifyPair.java | 4 +- test/typeinference/JavaTXCompilerTest.java | 22 +++++- 12 files changed, 182 insertions(+), 100 deletions(-) create mode 100644 src/de/dhbwstuttgart/typedeployment/TypeInsertFactory.java diff --git a/src/de/dhbwstuttgart/core/JavaTXCompiler.java b/src/de/dhbwstuttgart/core/JavaTXCompiler.java index 644865d6..0fdcbb77 100644 --- a/src/de/dhbwstuttgart/core/JavaTXCompiler.java +++ b/src/de/dhbwstuttgart/core/JavaTXCompiler.java @@ -1,15 +1,19 @@ package de.dhbwstuttgart.core; +import de.dhbwstuttgart.exceptions.DebugException; import de.dhbwstuttgart.parser.ClassNotFoundException; import de.dhbwstuttgart.parser.JavaTXParser; import de.dhbwstuttgart.syntaxtree.ClassOrInterface; import de.dhbwstuttgart.syntaxtree.SourceFile; import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode; import de.dhbwstuttgart.syntaxtree.factory.UnifyTypeFactory; +import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder; +import de.dhbwstuttgart.typedeployment.TypeInsertFactory; import de.dhbwstuttgart.typedeployment.TypeInsertPoint; import de.dhbwstuttgart.typeinference.ResultSet; import de.dhbwstuttgart.typeinference.constraints.Constraint; import de.dhbwstuttgart.typeinference.constraints.ConstraintSet; +import de.dhbwstuttgart.typeinference.constraints.Pair; import de.dhbwstuttgart.typeinference.unify.TypeUnify; import de.dhbwstuttgart.typeinference.unify.interfaces.IFiniteClosure; import de.dhbwstuttgart.typeinference.unify.model.FiniteClosure; @@ -24,12 +28,18 @@ public class JavaTXCompiler { private List sourceFiles = new ArrayList<>(); - public List getTypeInserts(File forSourceFile){ - return null; + public List getTypeInserts(File forFile){ + ResultSet result = typeInference(); + for(SourceFile sf : sourceFiles){ + if(sf.getFile().equals(forFile)){ + return TypeInsertFactory.createTypeInsertPoints(sf, result); + } + } + throw new DebugException("Die Datei "+forFile+" wurde nicht geparst"); } public ResultSet typeInference(){ - ConstraintSet cons = new ConstraintSet(); + ConstraintSet cons = new ConstraintSet<>(); List allClasses = new ArrayList<>(); for(SourceFile sf : sourceFiles){ allClasses.addAll(sf.getClasses()); @@ -53,7 +63,21 @@ public class JavaTXCompiler { System.out.println("RESULT: " + result); results.addAll(result); } - return new ResultSet(results); + return new ResultSet(UnifyTypeFactory.convert(results, generateTPHMap(cons))); + } + + private Map generateTPHMap(ConstraintSet constraints){ + HashMap ret = new HashMap<>(); + constraints.map((Pair p)->{ + if(p.TA1 instanceof TypePlaceholder){ + ret.put(((TypePlaceholder)p.TA1).getName(), (TypePlaceholder) p.TA1); + } + if(p.TA2 instanceof TypePlaceholder){ + ret.put(((TypePlaceholder)p.TA2).getName(), (TypePlaceholder) p.TA2); + } + return null; + }); + return ret; } public void parse(File sourceFile) throws IOException, ClassNotFoundException { diff --git a/src/de/dhbwstuttgart/parser/JavaTXParser.java b/src/de/dhbwstuttgart/parser/JavaTXParser.java index 38f92d6b..8d320ecb 100644 --- a/src/de/dhbwstuttgart/parser/JavaTXParser.java +++ b/src/de/dhbwstuttgart/parser/JavaTXParser.java @@ -22,7 +22,7 @@ public class JavaTXParser { Java8Parser.CompilationUnitContext tree = parser.compilationUnit(); SyntaxTreeGenerator generator = new SyntaxTreeGenerator(new JavaClassRegistry(generateJavaLangNames())); - return generator.convert(tree); + return generator.convert(tree, sourceFile); } private List generateJavaLangNames() throws IOException, ClassNotFoundException { diff --git a/src/de/dhbwstuttgart/parser/SyntaxTreeGenerator/SyntaxTreeGenerator.java b/src/de/dhbwstuttgart/parser/SyntaxTreeGenerator/SyntaxTreeGenerator.java index ee5b2cf2..0f2f8e51 100644 --- a/src/de/dhbwstuttgart/parser/SyntaxTreeGenerator/SyntaxTreeGenerator.java +++ b/src/de/dhbwstuttgart/parser/SyntaxTreeGenerator/SyntaxTreeGenerator.java @@ -12,6 +12,7 @@ import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric; import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder; import de.dhbwstuttgart.typecheck.*; +import java.io.File; import java.lang.reflect.Modifier; import java.util.ArrayList; import java.util.HashMap; @@ -167,7 +168,7 @@ public class SyntaxTreeGenerator{ return ret; } - public SourceFile convert(Java8Parser.CompilationUnitContext ctx) throws ClassNotFoundException{ + public SourceFile convert(Java8Parser.CompilationUnitContext ctx, File parsedFile) throws ClassNotFoundException{ List classes = new ArrayList<>(); this.getNames(ctx); this.setImports(ctx); @@ -181,7 +182,7 @@ public class SyntaxTreeGenerator{ } classes.add(newClass); } - return new SourceFile(this.pkgName, classes, this.imports); + return new SourceFile(parsedFile, this.pkgName, classes, this.imports); } public Method convert(Java8Parser.MethodDeclarationContext methodDeclarationContext, JavaClassName parentClass, GenericsRegistry generics) { diff --git a/src/de/dhbwstuttgart/syntaxtree/SourceFile.java b/src/de/dhbwstuttgart/syntaxtree/SourceFile.java index e1f0fb44..ad51faa3 100755 --- a/src/de/dhbwstuttgart/syntaxtree/SourceFile.java +++ b/src/de/dhbwstuttgart/syntaxtree/SourceFile.java @@ -1,4 +1,5 @@ package de.dhbwstuttgart.syntaxtree; +import java.io.File; import java.util.*; @@ -6,39 +7,26 @@ import de.dhbwstuttgart.parser.NullToken; import de.dhbwstuttgart.typecheck.JavaClassName; import de.dhbwstuttgart.typeinference.constraints.ConstraintSet; import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceInformation; +import sun.security.x509.X509CertInfo; public class SourceFile extends SyntaxTreeNode{ private String pkgName; - private List KlassenVektor = new ArrayList<>(); - private List imports; + private final List KlassenVektor; + private final List imports; + private final File file; - /** + /** * Die SourceFile repräsntiert eine zu einem Syntaxbaum eingelesene Java-Datei. * SourceFile stellt dabei den Wurzelknoten des Syntaxbaumes dar. */ - public SourceFile(String pkgName,List classDefinitions,List imports){ + public SourceFile(File file, String pkgName, List classDefinitions, List imports){ super(new NullToken()); this.KlassenVektor = classDefinitions; - if(pkgName != null){ - this.pkgName = pkgName; - } - if(imports != null){ - this.imports = imports; - } - } - - public SourceFile(List classDefinitions){ - this(null, classDefinitions, null); - } - - public SourceFile(String pkgName, List classDefinitions){ - this(pkgName, classDefinitions, null); - } - - public SourceFile(List classDefinitions, List imports){ - this(null, classDefinitions, imports); + this.pkgName = pkgName; + this.imports = imports; + this.file = file; } public String getPkgName(){ @@ -70,4 +58,8 @@ public class SourceFile extends SyntaxTreeNode{ public List getClasses() { return KlassenVektor; } + + public File getFile() { + return file; + } } diff --git a/src/de/dhbwstuttgart/syntaxtree/factory/UnifyTypeFactory.java b/src/de/dhbwstuttgart/syntaxtree/factory/UnifyTypeFactory.java index 9d26ab90..1961b778 100644 --- a/src/de/dhbwstuttgart/syntaxtree/factory/UnifyTypeFactory.java +++ b/src/de/dhbwstuttgart/syntaxtree/factory/UnifyTypeFactory.java @@ -1,12 +1,14 @@ package de.dhbwstuttgart.syntaxtree.factory; -import java.util.ArrayList; -import java.util.HashSet; -import java.util.List; +import java.util.*; +import java.util.stream.Collectors; import de.dhbwstuttgart.exceptions.NotImplementedException; +import de.dhbwstuttgart.parser.NullToken; import de.dhbwstuttgart.syntaxtree.ClassOrInterface; import de.dhbwstuttgart.syntaxtree.type.*; +import de.dhbwstuttgart.syntaxtree.type.Void; +import de.dhbwstuttgart.typecheck.JavaClassName; import de.dhbwstuttgart.typeinference.constraints.ConstraintSet; import de.dhbwstuttgart.typeinference.constraints.Pair; import de.dhbwstuttgart.typeinference.unify.model.ExtendsType; @@ -133,61 +135,65 @@ public class UnifyTypeFactory { * Convert from * UnifyType -> ASTType */ -/* - public static Pair convert(UnifyPair mp) { - Type tl = UnifyTypeFactory.convert(mp.getLhsType()); - Type tr = UnifyTypeFactory.convert(mp.getRhsType()); + public static Set> convert(Set> unifyPairSet, Map tphs) { + return unifyPairSet.stream().map( + set -> set.stream().map( + unifyPair -> convert(unifyPair, tphs)) + .collect(Collectors.toSet())) + .collect(Collectors.toSet()); + } + + public static Pair convert(UnifyPair mp, Map tphs) { + RefTypeOrTPHOrWildcardOrGeneric tl = UnifyTypeFactory.convert(mp.getLhsType(), tphs); + RefTypeOrTPHOrWildcardOrGeneric tr = UnifyTypeFactory.convert(mp.getRhsType(), tphs); return new Pair(tl, tr, mp.getPairOp()); } - public static Type convert(ReferenceType t) { - //TODO: Hier kann man die GTVs extrahieren - if(t.getName().toString().equals(Void.VOID_NAME))return new Void( 0); - RefType ret = new RefType(t.getName(),0); - ret.set_ParaList(convert(t.getTypeParams())); + public static RefTypeOrTPHOrWildcardOrGeneric convert(ReferenceType t, Map tphs) { + if(JavaClassName.Void.equals(t.getName()))return new Void(new NullToken()); + RefType ret = new RefType(JavaClassName.Void,convert(t.getTypeParams(), tphs),new NullToken()); return ret; } - public static Type convert(FunNType t) { - RefType ret = new RefType(t.getName(),0); - ret.set_ParaList(convert(t.getTypeParams())); + public static RefTypeOrTPHOrWildcardOrGeneric convert(FunNType t, Map tphs) { + RefType ret = new RefType(new JavaClassName(t.getName()), convert(t.getTypeParams(), tphs), new NullToken()); return ret; } - public static Type convert(SuperType t) { - RefType innerType = new RefType(t.getSuperedType().getName(),0); - return new SuperWildcardType(innerType); + public static RefTypeOrTPHOrWildcardOrGeneric convert(SuperType t, Map tphs) { + RefType innerType = new RefType(new JavaClassName(t.getSuperedType().getName()), new NullToken()); + return new SuperWildcardType(innerType, new NullToken()); } - public static Type convert(ExtendsType t) { - RefType innerType = new RefType(t.getExtendedType().getName(),0); - return new ExtendsWildcardType(innerType); + public static RefTypeOrTPHOrWildcardOrGeneric convert(ExtendsType t, Map tphs) { + RefType innerType = new RefType(new JavaClassName(t.getExtendedType().getName()), new NullToken()); + return new ExtendsWildcardType(innerType, new NullToken()); } - public static Type convert(PlaceholderType t) { - TypePlaceholder ret = TypePlaceholder.getInstance(t.getName()); + public static RefTypeOrTPHOrWildcardOrGeneric convert(PlaceholderType t, Map tphs) { + TypePlaceholder ret = tphs.get(t.getName()); if(ret == null){ //Dieser TPH wurde vom Unifikationsalgorithmus erstellt - ret = TypePlaceholder.fresh(t.getName(), NULL_NODE); + ret = TypePlaceholder.fresh(new NullToken()); } return ret; } - public static Type convert(UnifyType t) { - if(t instanceof FunNType)return convert((FunNType) t); - if(t instanceof ReferenceType)return convert((ReferenceType) t); - if(t instanceof SuperType)return convert((SuperType) t); - if(t instanceof ExtendsType)return convert((ExtendsType) t); - if(t instanceof PlaceholderType)return convert((PlaceholderType) t); + public static RefTypeOrTPHOrWildcardOrGeneric convert(UnifyType t, Map tphs) { + if(t instanceof FunNType)return convert((FunNType) t, tphs); + if(t instanceof ReferenceType)return convert((ReferenceType) t, tphs); + if(t instanceof SuperType)return convert((SuperType) t, tphs); + if(t instanceof ExtendsType)return convert((ExtendsType) t, tphs); + if(t instanceof PlaceholderType)return convert((PlaceholderType) t, tphs); throw new NotImplementedException("Der Typ "+t+" kann nicht umgewandelt werden"); } - private static List convert(TypeParams typeParams) { - List ret = new ArrayList<>(); + private static List convert(TypeParams typeParams, Map tphs) { + List ret = new ArrayList<>(); for(UnifyType uT : typeParams){ - Type toAdd = convert(uT); + RefTypeOrTPHOrWildcardOrGeneric toAdd = convert(uT, tphs); ret.add(toAdd); } return ret; } -*/ + } diff --git a/src/de/dhbwstuttgart/syntaxtree/type/SuperWildcardType.java b/src/de/dhbwstuttgart/syntaxtree/type/SuperWildcardType.java index fdb36193..babc0a31 100755 --- a/src/de/dhbwstuttgart/syntaxtree/type/SuperWildcardType.java +++ b/src/de/dhbwstuttgart/syntaxtree/type/SuperWildcardType.java @@ -17,7 +17,7 @@ public class SuperWildcardType extends WildcardType{ * Author: Arne Lüdtke
* Standard Konstruktor für eine SuperWildcard */ - public SuperWildcardType(Token offset, RefType innerType) + public SuperWildcardType( RefType innerType, Token offset) { super(innerType, offset); } diff --git a/src/de/dhbwstuttgart/syntaxtree/type/TypePlaceholder.java b/src/de/dhbwstuttgart/syntaxtree/type/TypePlaceholder.java index 7759fdf8..82f7e298 100755 --- a/src/de/dhbwstuttgart/syntaxtree/type/TypePlaceholder.java +++ b/src/de/dhbwstuttgart/syntaxtree/type/TypePlaceholder.java @@ -15,10 +15,7 @@ import org.antlr.v4.runtime.Token; */ public class TypePlaceholder extends RefTypeOrTPHOrWildcardOrGeneric { - - private static Hashtable m_TypePlaceholdersRegistry = new Hashtable(); - - private final String name; + private final String name; @@ -32,30 +29,6 @@ public class TypePlaceholder extends RefTypeOrTPHOrWildcardOrGeneric super(offset); this.name = name; } - - /** - * Statische Methode, um einen TypePlaceholder aus der Registry zu holen. - *
Author: J�rg B�uerle - * @param name Der Name des TypePlaceholders - * @return Der TypePlaceholder oder null, falls er nicht in der - * Registry existiert - - public static TypePlaceholder getInstance(String name) - { - return m_TypePlaceholdersRegistry.get(name); - } - */ - - /** - * Generiert einen neuen TPH mit einem bestimmten Namen. - * Wird benötigt, wenn aus Generischen Variablen TPH generiert werden. - * @param name - * @return - */ - public static TypePlaceholder fresh(String name, SyntaxTreeNode parent) - { - return null; - } /** diff --git a/src/de/dhbwstuttgart/typedeployment/TypeInsertFactory.java b/src/de/dhbwstuttgart/typedeployment/TypeInsertFactory.java new file mode 100644 index 00000000..9933195f --- /dev/null +++ b/src/de/dhbwstuttgart/typedeployment/TypeInsertFactory.java @@ -0,0 +1,40 @@ +package de.dhbwstuttgart.typedeployment; + +import de.dhbwstuttgart.exceptions.NotImplementedException; +import de.dhbwstuttgart.syntaxtree.ClassOrInterface; +import de.dhbwstuttgart.syntaxtree.Field; +import de.dhbwstuttgart.syntaxtree.SourceFile; +import de.dhbwstuttgart.syntaxtree.type.RefType; +import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric; +import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder; +import de.dhbwstuttgart.typeinference.ResultSet; + +import java.util.ArrayList; +import java.util.List; + +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){ + RefTypeOrTPHOrWildcardOrGeneric resolved = withResults.resolveType(field.getType()); + String toInsert = getString(resolved) + " "; + ret.add(new TypeInsertPoint(field.getType().getOffset(), toInsert)); + } + } + } + return ret; + } + + private static String getString(RefTypeOrTPHOrWildcardOrGeneric resolved) { + if(resolved instanceof RefType){ + return ((RefType) resolved).getName().toString(); + }else if(resolved instanceof TypePlaceholder){ + return ((TypePlaceholder) resolved).getName(); + }else{ + throw new NotImplementedException(); + } + } +} diff --git a/src/de/dhbwstuttgart/typeinference/ResultSet.java b/src/de/dhbwstuttgart/typeinference/ResultSet.java index e8dbb6d7..44890576 100644 --- a/src/de/dhbwstuttgart/typeinference/ResultSet.java +++ b/src/de/dhbwstuttgart/typeinference/ResultSet.java @@ -1,11 +1,36 @@ package de.dhbwstuttgart.typeinference; +import de.dhbwstuttgart.exceptions.NotImplementedException; +import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric; +import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder; +import de.dhbwstuttgart.typeinference.constraints.Pair; +import de.dhbwstuttgart.typeinference.unify.model.PairOperator; import de.dhbwstuttgart.typeinference.unify.model.UnifyPair; import java.util.Set; public class ResultSet { - public ResultSet(Set> results){ + Set> results; + public ResultSet(Set> results){ + this.results = results; + } + public RefTypeOrTPHOrWildcardOrGeneric resolveType(RefTypeOrTPHOrWildcardOrGeneric type) { + /*//Probleme: + * Es müssen teilweise mehrere TPH eingesetzt werden + * Es werden alle eingesetzt, welch in der Kette stehen! + * TPHs müssen zu eindeutigen Namen aufgelöst werden + */ + final RefTypeOrTPHOrWildcardOrGeneric ret; + for(Set pairs : results)for(Pair pair : pairs){ + if(pair.OperatorEqual()){ //type ist vom Typ TypePlaceholder + if(pair.TA1.equals(type)){ + return pair.TA2; + }else if(pair.TA2.equals(type)){ + return pair.TA1; + } + } + } + return type; } } diff --git a/src/de/dhbwstuttgart/typeinference/constraints/Pair.java b/src/de/dhbwstuttgart/typeinference/constraints/Pair.java index a1986c50..c7e1f6b6 100644 --- a/src/de/dhbwstuttgart/typeinference/constraints/Pair.java +++ b/src/de/dhbwstuttgart/typeinference/constraints/Pair.java @@ -3,17 +3,16 @@ import java.io.Serializable; import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric; import de.dhbwstuttgart.typeinference.unify.model.PairOperator; -import de.dhbwstuttgart.typeinference.unify.model.UnifyPair; public class Pair implements Serializable { - public RefTypeOrTPHOrWildcardOrGeneric TA1; - public RefTypeOrTPHOrWildcardOrGeneric TA2; + public final RefTypeOrTPHOrWildcardOrGeneric TA1; + public final RefTypeOrTPHOrWildcardOrGeneric TA2; private PairOperator eOperator = PairOperator.SMALLER; - Pair(RefTypeOrTPHOrWildcardOrGeneric TA1, RefTypeOrTPHOrWildcardOrGeneric TA2 ) + public Pair(RefTypeOrTPHOrWildcardOrGeneric TA1, RefTypeOrTPHOrWildcardOrGeneric TA2 ) { this.TA1 = TA1; this.TA2 = TA2; @@ -22,7 +21,7 @@ public class Pair implements Serializable eOperator = PairOperator.SMALLER; } - Pair(RefTypeOrTPHOrWildcardOrGeneric TA1, RefTypeOrTPHOrWildcardOrGeneric TA2, PairOperator eOp) + public Pair(RefTypeOrTPHOrWildcardOrGeneric TA1, RefTypeOrTPHOrWildcardOrGeneric TA2, PairOperator eOp) { // Konstruktor this(TA1,TA2); diff --git a/src/de/dhbwstuttgart/typeinference/unify/model/UnifyPair.java b/src/de/dhbwstuttgart/typeinference/unify/model/UnifyPair.java index 988f9b7a..0909690a 100644 --- a/src/de/dhbwstuttgart/typeinference/unify/model/UnifyPair.java +++ b/src/de/dhbwstuttgart/typeinference/unify/model/UnifyPair.java @@ -8,7 +8,7 @@ import java.util.List; * A pair which contains two types and an operator, e.q. (Integer <. a). * @author Florian Steurer */ -public class UnifyPair { +public class UnifyPair { /** * The type on the left hand side of the pair. @@ -88,12 +88,14 @@ public class UnifyPair { return "(" + lhs + " " + pairOp + " " + rhs + ")"; } + /* public List getInvolvedPlaceholderTypes() { ArrayList ret = new ArrayList<>(); ret.addAll(lhs.getInvolvedPlaceholderTypes()); ret.addAll(rhs.getInvolvedPlaceholderTypes()); return ret; } + */ } diff --git a/test/typeinference/JavaTXCompilerTest.java b/test/typeinference/JavaTXCompilerTest.java index 2f1f7293..f6b46a0c 100644 --- a/test/typeinference/JavaTXCompilerTest.java +++ b/test/typeinference/JavaTXCompilerTest.java @@ -2,10 +2,18 @@ package typeinference; import de.dhbwstuttgart.core.JavaTXCompiler; import de.dhbwstuttgart.parser.ClassNotFoundException; +import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode; +import de.dhbwstuttgart.typedeployment.TypeInsertPoint; +import de.dhbwstuttgart.typeinference.ResultSet; import org.junit.Test; import java.io.File; import java.io.IOException; +import java.nio.charset.Charset; +import java.nio.charset.StandardCharsets; +import java.nio.file.Files; +import java.nio.file.Paths; +import java.util.List; import static org.junit.Assert.*; @@ -21,6 +29,18 @@ public class JavaTXCompilerTest { //compiler.parse(new File(rootDirectory+"Generics.jav")); compiler.parse(new File(rootDirectory+"MethodsEasy.jav")); //compiler.parse(new File(rootDirectory+"Lambda.jav")); - compiler.typeInference(); + + List result = compiler.getTypeInserts(new File(rootDirectory+"Methods.jav")); + String content = readFile(rootDirectory+"Methods.jav", StandardCharsets.UTF_8); + for(TypeInsertPoint tip : result){ + System.out.println(tip.insert(content)); + } + } + + static String readFile(String path, Charset encoding) + throws IOException + { + byte[] encoded = Files.readAllBytes(Paths.get(path)); + return new String(encoded, encoding); } } \ No newline at end of file