Compare commits

..

23 Commits

Author SHA1 Message Date
9dd6c1610a geändert: S2017_Jan-Elric_Neumann.pdf 2017-09-04 09:28:53 +02:00
66bbf9d52d neue Datei: S2017_Jan-Elric_Neumann.pdf
neue Datei:   ../../git_pull_origin_bigRefactoring
	geändert:   ../../test/typeinference/JavaTXCompilerTest.java
2017-09-04 09:26:02 +02:00
8bff427c5c merge 2017-06-30 13:49:53 +02:00
fc6040da39 Fehler in TYPE beseitigen 2017-06-30 13:48:59 +02:00
bd1cfe4e7a Merge 2017-06-30 13:09:59 +02:00
05e4968adb new bransch 2017-06-30 13:04:56 +02:00
d64823ea30 Fehler bei GenericInsertPoints beheben 2017-06-30 12:14:07 +02:00
3b8ef58222 ASTTypePrinter anfügen 2017-06-30 11:13:15 +02:00
0aa18c74ba ASTPrinter verbessern 2017-06-29 01:19:13 +02:00
726eb60eb3 ASTPrinter einführen 2017-06-28 21:10:28 +02:00
afd3f32f23 ASTVisitor implementieren 2017-06-28 17:20:26 +02:00
3173cccefa Typen einsetzen um Wildcards erweitern 2017-06-26 18:19:56 +02:00
e6c58d44c2 Type für Return fixen 2017-06-26 16:59:10 +02:00
1be1bb83ca FunN-Typen erstellen bei Methodenaufrufen 2017-06-23 21:33:27 +02:00
2c25e56a76 Einsetzen von Generics korrigieren 2017-06-20 14:50:27 +02:00
c272688b2d Fehler beim Ausrechnen zusammenhängender Constraints beheben 2017-06-20 01:14:04 +02:00
cf6d9880e3 Generische Parameter einsetzen (nur Test, nicht korrekt eingesetzt) 2017-06-15 04:48:53 +02:00
920eea43ad Lambda Test angepasst 2017-06-15 02:57:49 +02:00
70ca62202d Typeinsetzen erweitert 2017-06-15 02:17:46 +02:00
44481b4140 Merge branch 'bigRefactoring' of ssh://gohorb.ba-horb.de/bahome/projekt/git/JavaCompilerCore into bigRefactoring 2017-06-14 04:07:43 +02:00
7a337843e6 Lambda-TYPE anpassen. Beginnen mit TypeInsert 2017-06-14 04:07:27 +02:00
fcca50ed78 modified: .classpath
modified:   src/de/dhbwstuttgart/parser/SyntaxTreeGenerator/SyntaxTreeGenerator.java
	modified:   src/de/dhbwstuttgart/syntaxtree/SourceFile.java
	modified:   src/de/dhbwstuttgart/syntaxtree/statement/LambdaExpression.java
	modified:   src/de/dhbwstuttgart/typecheck/GenericTypeName.java
	modified:   src/de/dhbwstuttgart/typeinference/typeAlgo/TYPE.java
	modified:   test/astfactory/ASTFactoryTest.java

imports auskommentiert
2017-06-13 17:38:43 +02:00
5f31150dc8 TYPE-Algo für LambdaExpression implementieren 2017-06-12 18:57:12 +02:00
76 changed files with 1276 additions and 443 deletions

@ -7,5 +7,16 @@
<classpathentry kind="lib" path="lib/guava-10.0.1.jar"/>
<classpathentry kind="con" path="org.eclipse.jdt.junit.JUNIT_CONTAINER/4"/>
<classpathentry kind="lib" path="lib/antlr-complete.jar"/>
<classpathentry kind="lib" path="lib/annotations-2.0.1.jar"/>
<classpathentry kind="lib" path="lib/bcel-6.1-SNAPSHOT-sources.jar"/>
<classpathentry kind="lib" path="lib/cloning.jar"/>
<classpathentry kind="lib" path="lib/commons-bcel6-6.0-SNAPSHOT.jar"/>
<classpathentry kind="lib" path="lib/guava-15.0.jar"/>
<classpathentry kind="lib" path="lib/javassist-3.19.0-GA.jar"/>
<classpathentry kind="lib" path="lib/junit-4.0.jar"/>
<classpathentry kind="lib" path="lib/log4j-1.2.12.jar"/>
<classpathentry kind="lib" path="lib/reflections-0.9.10-javadoc.jar"/>
<classpathentry kind="lib" path="lib/reflections-0.9.10-sources.jar"/>
<classpathentry kind="lib" path="lib/reflections-0.9.10.jar"/>
<classpathentry kind="output" path="bin"/>
</classpath>

Binary file not shown.

@ -1,8 +1,21 @@
package de.dhbwstuttgart.core;
import de.dhbwstuttgart.parser.ClassNotFoundException;
import java.io.File;
import java.io.IOException;
import java.util.*;
public class ConsoleInterface {
private static final String directory = System.getProperty("user.dir");
public static void main(String[] args) throws IOException, ClassNotFoundException {
JavaTXCompiler compiler = new JavaTXCompiler();
for(String arg : Arrays.asList(args)){
compiler.parse(new File(arg));
}
compiler.typeInference();
}
}

@ -8,6 +8,7 @@ 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.TypeInsert;
import de.dhbwstuttgart.typedeployment.TypeInsertFactory;
import de.dhbwstuttgart.typedeployment.TypeInsertPoint;
import de.dhbwstuttgart.typeinference.ResultSet;
@ -26,9 +27,9 @@ import java.util.*;
public class JavaTXCompiler {
private List<SourceFile> sourceFiles = new ArrayList<>();
protected List<SourceFile> sourceFiles = new ArrayList<>();
public List<TypeInsertPoint> getTypeInserts(File forFile){
public List<TypeInsert> getTypeInserts(File forFile){
ResultSet result = typeInference();
for(SourceFile sf : sourceFiles){
if(sf.getFile().equals(forFile)){
@ -64,6 +65,7 @@ public class JavaTXCompiler {
results.addAll(result);
}
return new ResultSet(UnifyTypeFactory.convert(results, generateTPHMap(cons)));
//return new ResultSet(new HashSet<>(Arrays.asList(UnifyTypeFactory.convert(results, generateTPHMap(cons)).iterator().next())));
}
private Map<String, TypePlaceholder> generateTPHMap(ConstraintSet<Pair> constraints){

@ -33,7 +33,11 @@ public class JavaTXParser {
}
//TODO: Wieso muss man das händisch anhängen?
ret.add("java.lang.Object");
ret.add("java.lang.Long");
ret.add("java.lang.Integer");
ret.add("java.lang.Boolean");
ret.add("java.lang.String");
ret.add("java.lang.Class");
return ret;
}
}

@ -4,8 +4,6 @@ import de.dhbwstuttgart.exceptions.NotImplementedException;
import de.dhbwstuttgart.parser.NullToken;
import de.dhbwstuttgart.parser.antlr.Java8Parser;
import de.dhbwstuttgart.syntaxtree.*;
import de.dhbwstuttgart.syntaxtree.operator.AndOp;
import de.dhbwstuttgart.syntaxtree.operator.OrOp;
import de.dhbwstuttgart.syntaxtree.statement.*;
import de.dhbwstuttgart.syntaxtree.statement.literal.*;
import de.dhbwstuttgart.syntaxtree.type.RefType;
@ -22,12 +20,13 @@ import java.util.*;
public class StatementGenerator {
private JavaClassRegistry reg;
private Map<String, RefTypeOrTPHOrWildcardOrGeneric> localVars = new HashMap<>();
private Map<String, RefTypeOrTPHOrWildcardOrGeneric> localVars;
private GenericsRegistry generics;
public StatementGenerator(JavaClassRegistry reg, GenericsRegistry generics){
public StatementGenerator(JavaClassRegistry reg, GenericsRegistry generics, Map<String, RefTypeOrTPHOrWildcardOrGeneric> localVars){
this.reg = reg;
this.generics = generics;
this.localVars = localVars;
}
public ParameterList convert(Java8Parser.FormalParameterListContext formalParameterListContext) {
@ -504,7 +503,7 @@ public class StatementGenerator {
return convert(expression.conditionalAndExpression());
}else{
return new Binary(convert(expression.conditionalOrExpression()),
convert(expression.conditionalAndExpression()), new OrOp(null));
convert(expression.conditionalAndExpression()), Binary.Operator.OR);
}
}
@ -513,7 +512,7 @@ public class StatementGenerator {
return convert(expression.inclusiveOrExpression());
}else{
return new Binary(convert(expression.conditionalAndExpression()),
convert(expression.inclusiveOrExpression()), new AndOp(null));
convert(expression.inclusiveOrExpression()), Binary.Operator.AND);
}
}
@ -798,14 +797,21 @@ public class StatementGenerator {
params = new ParameterList(new ArrayList<>(), expression.getStart());
}
HashMap<String,RefTypeOrTPHOrWildcardOrGeneric> lambdaLocals = new HashMap<>();
lambdaLocals.putAll(localVars);
for(FormalParameter param : params.getFormalparalist()){
lambdaLocals.put(param.getName(), param.getType());
}
StatementGenerator lambdaGenerator = new StatementGenerator(reg, generics, lambdaLocals);
Block block;
if(expression.lambdaBody().expression() != null){
List<Statement> statements = new ArrayList<>();
statements.add(new Return(convert(expression.lambdaBody().expression()),
statements.add(new Return(lambdaGenerator.convert(expression.lambdaBody().expression()),
expression.lambdaBody().expression().getStart()));
block = new Block(statements, expression.lambdaBody().getStart());
}else{
block = convert(expression.lambdaBody().block());
block = lambdaGenerator.convert(expression.lambdaBody().block());
}
List<RefTypeOrTPHOrWildcardOrGeneric> funNParams = new ArrayList<>();
funNParams.add(TypePlaceholder.fresh(expression.getStart()));//ret-Type
@ -813,7 +819,7 @@ public class StatementGenerator {
funNParams.add(TypePlaceholder.fresh(expression.getStart())));
RefTypeOrTPHOrWildcardOrGeneric lambdaType = TypePlaceholder.fresh(expression.getStart());
//RefType lambdaType = new RefType(reg.getName("Fun"+params.getFormalparalist().size()),
//funNParams, expression.getStart());
//funNParams, name.getStart());
return new LambdaExpression(lambdaType, params, block, expression.getStart());
}
}

@ -2,6 +2,7 @@ package de.dhbwstuttgart.parser.SyntaxTreeGenerator;
import de.dhbwstuttgart.exceptions.NotImplementedException;
import de.dhbwstuttgart.parser.ClassNotFoundException;
import de.dhbwstuttgart.parser.NullToken;
import de.dhbwstuttgart.parser.PackageCrawler;
import de.dhbwstuttgart.parser.antlr.Java8Parser;
import de.dhbwstuttgart.syntaxtree.*;
@ -18,7 +19,8 @@ import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import jdk.internal.dynalink.support.TypeConverterFactory;
//import jdk.internal.dynalink.support.TypeConverterFactory;
import org.antlr.v4.runtime.CommonToken;
import org.antlr.v4.runtime.Token;
import org.antlr.v4.runtime.tree.TerminalNode;
@ -207,12 +209,14 @@ public class SyntaxTreeGenerator{
private Method convert(int modifiers, Java8Parser.MethodHeaderContext header, Java8Parser.MethodBodyContext body,
JavaClassName parentClass, GenericsRegistry localGenerics) {
StatementGenerator stmtGen = new StatementGenerator(reg, localGenerics);
StatementGenerator stmtGen = new StatementGenerator(reg, localGenerics, new HashMap<>());
String name = header.methodDeclarator().Identifier().getText();
GenericDeclarationList gtvDeclarations = new GenericDeclarationList(new ArrayList<>(), header.getStart());
if(header.typeParameters() != null){
gtvDeclarations = TypeGenerator.convert(header.typeParameters(), parentClass, name,reg, localGenerics);
}else{
gtvDeclarations = new GenericDeclarationList(new ArrayList<>(), header.getStart());
}
RefTypeOrTPHOrWildcardOrGeneric retType;
if(header.result() != null){
@ -233,6 +237,8 @@ public class SyntaxTreeGenerator{
block = stmtGen.convert(body.block());
}
if(parentClass.equals(new JavaClassName(name))){
//TODO: Constructor darf nicht Rückgabetyp void bekommen: Hier als Rückgabetyp die Klasse inklusive generische Variablen
//retType = TypeGenerator.convertTypeName(name, gtvDeclarations, header.getStart(), reg, localGenerics);
return new Constructor(name, retType, modifiers, parameterList, block, gtvDeclarations, header.getStart());
}else{
return new Method(name, retType, modifiers, parameterList,block, gtvDeclarations, header.getStart());
@ -261,7 +267,12 @@ public class SyntaxTreeGenerator{
JavaClassName name = reg.getName(ctx.Identifier().getText());
GenericsRegistry generics = createGenerics(ctx.typeParameters(), name, "");
Token offset = ctx.getStart();
GenericDeclarationList genericClassParameters = TypeGenerator.convert(ctx.typeParameters(), name, "",reg, generics);
GenericDeclarationList genericClassParameters;
if(ctx.typeParameters() == null){
genericClassParameters = createEmptyGenericDeclarationList(ctx.Identifier());
}else{
genericClassParameters = TypeGenerator.convert(ctx.typeParameters(), name, "",reg, generics);
}
List<Field> fielddecl = convertFields(ctx.classBody(), generics);
List<Method> methods = convertMethods(ctx.classBody(), name, generics);
List<Constructor> konstruktoren = new ArrayList<>();
@ -280,13 +291,12 @@ public class SyntaxTreeGenerator{
);
}
RefType superClass = null ;
/*
RefType superClass ;
if(ctx.superclass() != null){
superClass = convert(ctx.superclass());
}else{
superClass = new ASTFactory(reg).createObjectClass().getType();
}*/
}
Boolean isInterface = false;
List<RefTypeOrTPHOrWildcardOrGeneric> implementedInterfaces = convert(ctx.superinterfaces(), generics);
return new ClassOrInterface(modifiers, name, fielddecl, methods, konstruktoren, genericClassParameters, superClass,
@ -463,8 +473,12 @@ public class SyntaxTreeGenerator{
List<Field> fields = convertFields(ctx.interfaceBody());
List<Method> methods = convertMethods(ctx.interfaceBody(), name, generics);
GenericDeclarationList genericParams = TypeGenerator.convert(ctx.typeParameters(), name, "",reg, generics);
GenericDeclarationList genericParams;
if(ctx.typeParameters() != null){
genericParams = TypeGenerator.convert(ctx.typeParameters(), name, "",reg, generics);
}else{
genericParams = createEmptyGenericDeclarationList(ctx.Identifier());
}
RefType superClass = new ASTFactory(reg).createObjectClass().getType();
List<RefTypeOrTPHOrWildcardOrGeneric> extendedInterfaces = convert(ctx.extendsInterfaces(), generics);
@ -473,6 +487,13 @@ public class SyntaxTreeGenerator{
genericParams, superClass, true, extendedInterfaces, ctx.getStart());
}
private GenericDeclarationList createEmptyGenericDeclarationList(TerminalNode classNameIdentifier) {
CommonToken gtvOffset = new CommonToken(classNameIdentifier.getSymbol());
gtvOffset.setCharPositionInLine(gtvOffset.getCharPositionInLine()+classNameIdentifier.getText().length());
gtvOffset.setStartIndex(gtvOffset.getStopIndex()+1);
return new GenericDeclarationList(new ArrayList<>(), gtvOffset);
}
private GenericsRegistry createGenerics(Java8Parser.TypeParametersContext ctx, JavaClassName parentClass, String parentMethod) {
GenericsRegistry ret = new GenericsRegistry();
if(ctx == null || ctx.typeParameterList() == null)return ret;

@ -4,7 +4,6 @@ import de.dhbwstuttgart.exceptions.NotImplementedException;
import de.dhbwstuttgart.exceptions.TypeinferenceException;
import de.dhbwstuttgart.parser.NullToken;
import de.dhbwstuttgart.parser.antlr.Java8Parser;
import de.dhbwstuttgart.syntaxtree.GTVDeclarationContext;
import de.dhbwstuttgart.syntaxtree.GenericDeclarationList;
import de.dhbwstuttgart.syntaxtree.GenericTypeVar;
import de.dhbwstuttgart.syntaxtree.factory.ASTFactory;
@ -55,9 +54,6 @@ public class TypeGenerator {
}
public static GenericDeclarationList convert(Java8Parser.TypeParametersContext typeParametersContext, JavaClassName parentClass, String parentMethod, JavaClassRegistry reg, GenericsRegistry generics) {
if(typeParametersContext == null){
return new GenericDeclarationList(new ArrayList<>(), new NullToken());
}
Token endOffset = typeParametersContext.getStop();
List<GenericTypeVar> typeVars = new ArrayList<>();
for(Java8Parser.TypeParameterContext typeParameter : typeParametersContext.typeParameterList().typeParameter()){

@ -180,7 +180,7 @@ public class Java8Parser extends Parser {
"methodInvocation_lf_primary", "methodInvocation_lfno_primary", "argumentList",
"methodReference", "methodReference_lf_primary", "methodReference_lfno_primary",
"arrayCreationExpression", "dimExprs", "dimExpr", "constantExpression",
"expression", "lambdaExpression", "lambdaParameters", "inferredFormalParameterList",
"name", "lambdaExpression", "lambdaParameters", "inferredFormalParameterList",
"lambdaBody", "assignmentExpression", "assignment", "leftHandSide", "assignmentOperator",
"conditionalExpression", "conditionalOrExpression", "conditionalAndExpression",
"inclusiveOrExpression", "exclusiveOrExpression", "andExpression", "equalityExpression",

@ -0,0 +1,37 @@
package de.dhbwstuttgart.syntaxtree;
import de.dhbwstuttgart.syntaxtree.statement.*;
import de.dhbwstuttgart.syntaxtree.statement.literal.Literal;
import de.dhbwstuttgart.syntaxtree.statement.literal.Null;
import de.dhbwstuttgart.syntaxtree.type.*;
public interface ASTVisitor extends StatementVisitor{
void visit(SourceFile sourceFile);
void visit(ArgumentList argumentList);
void visit(GenericTypeVar genericTypeVar);
void visit(FormalParameter formalParameter);
void visit(GenericDeclarationList genericTypeVars);
void visit(Field field);
void visit(Method field);
void visit(ParameterList formalParameters);
void visit(ClassOrInterface classOrInterface);
void visit(RefType refType);
void visit(SuperWildcardType superWildcardType);
void visit(TypePlaceholder typePlaceholder);
void visit(ExtendsWildcardType extendsWildcardType);
void visit(GenericRefType genericRefType);
}

@ -0,0 +1,145 @@
package de.dhbwstuttgart.syntaxtree;
import de.dhbwstuttgart.syntaxtree.statement.*;
import de.dhbwstuttgart.syntaxtree.statement.literal.Literal;
import de.dhbwstuttgart.syntaxtree.statement.literal.Null;
import de.dhbwstuttgart.syntaxtree.type.*;
import java.lang.reflect.Modifier;
import java.util.Iterator;
public abstract class AbstractASTWalker implements ASTVisitor{
@Override
public void visit(SourceFile sourceFile) {
for(ClassOrInterface cl : sourceFile.getClasses()){
cl.accept(this);
}
}
@Override
public void visit(ArgumentList argumentList) {
for(Expression expr : argumentList.getArguments()){
expr.accept(this);
}
}
@Override
public void visit(FormalParameter formalParameter) {
formalParameter.getType().accept(this);
}
@Override
public void visit(GenericDeclarationList genericTypeVars) {
Iterator<GenericTypeVar> genericIterator = genericTypeVars.iterator();
if(genericIterator.hasNext()){
while(genericIterator.hasNext()){
genericIterator.next().accept(this);
}
}
}
@Override
public void visit(Field field) {
field.getType().accept(this);
}
@Override
public void visit(Method method) {
method.getType().accept(this);
method.getParameterList().accept(this);
method.block.accept(this);
}
@Override
public void visit(ParameterList formalParameters) {
Iterator<FormalParameter> genericIterator = formalParameters.getFormalparalist().iterator();
if(genericIterator.hasNext()){
while(genericIterator.hasNext()){
genericIterator.next().accept(this);
}
}
}
@Override
public void visit(ClassOrInterface classOrInterface) {
classOrInterface.getGenerics().accept(this);
for(Field f : classOrInterface.getFieldDecl()){
f.accept(this);
}
for(Method m : classOrInterface.getMethods()){
m.accept(this);
}
}
@Override
public void visit(RefType refType) {
Iterator<RefTypeOrTPHOrWildcardOrGeneric> genericIterator = refType.getParaList().iterator();
if(genericIterator.hasNext()){
while(genericIterator.hasNext()){
genericIterator.next().accept(this);
}
}
}
@Override
public void visit(SuperWildcardType superWildcardType) {
superWildcardType.getInnerType().accept(this);
}
@Override
public void visit(ExtendsWildcardType extendsWildcardType) {
extendsWildcardType.getInnerType().accept(this);
}
@Override
public void visit(LambdaExpression lambdaExpression) {
lambdaExpression.params.accept(this);
lambdaExpression.methodBody.accept(this);
}
@Override
public void visit(Assign assign) {
assign.lefSide.accept(this);
assign.rightSide.accept(this);
}
@Override
public void visit(Block block) {
for(Statement stmt : block.getStatements()){
stmt.accept(this);
}
}
@Override
public void visit(FieldVar fieldVar) {
fieldVar.receiver.accept(this);
}
@Override
public void visit(LocalVarDecl localVarDecl) {
localVarDecl.getType().accept(this);
}
@Override
public void visit(MethodCall methodCall) {
methodCall.receiver.accept(this);
methodCall.getArgumentList().accept(this);
}
@Override
public void visit(NewClass methodCall) {
visit((MethodCall) methodCall);
}
@Override
public void visit(Receiver receiver) {
receiver.expr.accept(this);
}
@Override
public void visit(Return aReturn) {
aReturn.retexpr.accept(this);
}
}

@ -2,6 +2,7 @@ package de.dhbwstuttgart.syntaxtree;
import de.dhbwstuttgart.core.IItemWithOffset;
import de.dhbwstuttgart.syntaxtree.type.RefType;
import de.dhbwstuttgart.syntaxtree.visual.ASTPrinter;
import de.dhbwstuttgart.typecheck.JavaClassName;
import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
import de.dhbwstuttgart.typeinference.constraints.Constraint;
@ -15,13 +16,12 @@ import java.util.List;
/**
* Stellt jede Art von Klasse dar. Auch abstrakte Klassen und Interfaces
*/
public class ClassOrInterface extends GTVDeclarationContext implements IItemWithOffset, Generic{
public class ClassOrInterface extends SyntaxTreeNode {
protected int modifiers;
protected JavaClassName name;
private List<Field> fields = new ArrayList<>();
private List<Method> methods = new ArrayList<>();
private GenericDeclarationList genericClassParameters;
private Token offset;
private RefTypeOrTPHOrWildcardOrGeneric superClass;
protected boolean isInterface;
private List<? extends RefTypeOrTPHOrWildcardOrGeneric> implementedInterfaces;
@ -31,23 +31,12 @@ public class ClassOrInterface extends GTVDeclarationContext implements IItemWith
RefTypeOrTPHOrWildcardOrGeneric superClass, Boolean isInterface, List<? extends RefTypeOrTPHOrWildcardOrGeneric> implementedInterfaces, Token offset){
super(offset);
this.modifiers = modifiers;
if(name != null){
this.name = name;
}
if(fielddecl != null){
this.fields = fielddecl;
}
if(genericClassParameters != null){
this.genericClassParameters = genericClassParameters;
}
this.offset = offset;
if(superClass != null){
this.genericClassParameters = genericClassParameters;
this.superClass = superClass;
}
this.isInterface = isInterface;
if(implementedInterfaces != null){
this.implementedInterfaces = implementedInterfaces;
}
this.methods = methods;
this.constructors = constructors;
}
@ -96,4 +85,9 @@ public class ClassOrInterface extends GTVDeclarationContext implements IItemWith
public List<? extends Method> getConstructors() {
return constructors;
}
@Override
public void accept(ASTVisitor visitor) {
visitor.visit(this);
}
}

@ -3,7 +3,7 @@ package de.dhbwstuttgart.syntaxtree;
import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
import org.antlr.v4.runtime.Token;
public class Field extends GTVDeclarationContext implements Generic {
public class Field extends SyntaxTreeNode{
private String name;
private RefTypeOrTPHOrWildcardOrGeneric type;
@ -24,5 +24,10 @@ public class Field extends GTVDeclarationContext implements Generic {
public RefTypeOrTPHOrWildcardOrGeneric getType() {
return type;
}
@Override
public void accept(ASTVisitor visitor) {
visitor.visit(this);
}
}

@ -17,4 +17,13 @@ public class FormalParameter extends SyntaxTreeNode
public RefTypeOrTPHOrWildcardOrGeneric getType() {
return type;
}
public String getName() {
return name;
}
@Override
public void accept(ASTVisitor visitor) {
visitor.visit(this);
}
}

@ -1,13 +0,0 @@
package de.dhbwstuttgart.syntaxtree;
import org.antlr.v4.runtime.Token;
/**
* Beischreibt eine SyntaxTreeNode, welcher die Eigenschaft besitzt,
* dass bei seiner Deklaration auch Generische Typvariablen deklariert wurden.
*/
public abstract class GTVDeclarationContext extends SyntaxTreeNode {
public GTVDeclarationContext(Token offset) {
super(offset);
}
}

@ -1,9 +0,0 @@
package de.dhbwstuttgart.syntaxtree;
/**
* Wird von allen Klassen implementiert, welche generische Parameter halten können. (Class, Method und Field)
* @author janulrich
*
*/
public interface Generic {
}

@ -26,4 +26,9 @@ public class GenericDeclarationList extends SyntaxTreeNode implements Iterable<G
public Iterator<GenericTypeVar> iterator() {
return gtvs.iterator();
}
@Override
public void accept(ASTVisitor visitor) {
visitor.visit(this);
}
}

@ -51,4 +51,9 @@ public class GenericTypeVar extends SyntaxTreeNode
public GenericTypeName getName() {
return name;
}
@Override
public void accept(ASTVisitor visitor) {
visitor.visit(this);
}
}

@ -23,7 +23,7 @@ import de.dhbwstuttgart.syntaxtree.statement.Block;
*/
public class Method extends Field implements IItemWithOffset, TypeScope
{
private Block block;
public final Block block;
private ParameterList parameterlist = new ParameterList(new ArrayList<>(), new NullToken());
private ExceptionList exceptionlist;
private GenericDeclarationList generics;
@ -56,4 +56,9 @@ public class Method extends Field implements IItemWithOffset, TypeScope
public RefTypeOrTPHOrWildcardOrGeneric getReturnType() {
return this.getType();
}
@Override
public void accept(ASTVisitor visitor) {
visitor.visit(this);
}
}

@ -32,6 +32,11 @@ public class ParameterList extends SyntaxTreeNode implements Iterable<FormalPara
@Override
public Iterator<FormalParameter> iterator() {
return null;
return formalparameter.iterator();
}
@Override
public void accept(ASTVisitor visitor) {
visitor.visit(this);
}
}

@ -7,7 +7,7 @@ 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;
//import sun.security.x509.X509CertInfo;
public class SourceFile extends SyntaxTreeNode{
@ -62,4 +62,9 @@ public class SourceFile extends SyntaxTreeNode{
public File getFile() {
return file;
}
@Override
public void accept(ASTVisitor visitor) {
visitor.visit(this);
}
}

@ -27,8 +27,6 @@ public interface StatementVisitor {
void visit(InstanceOf instanceOf);
void visit(InstVar instVar);
void visit(LocalVar localVar);
void visit(LocalVarDecl localVarDecl);

@ -19,4 +19,5 @@ public abstract class SyntaxTreeNode implements IItemWithOffset{
return offset;
}
public abstract void accept(ASTVisitor visitor);
}

@ -118,16 +118,15 @@ public class UnifyTypeFactory {
}
public static UnifyPair convert(Pair p) {
if(p.OperatorSmaller()) {
if(p.GetOperator().equals(PairOperator.SMALLERDOT)) {
UnifyPair ret = generateSmallerDotPair(UnifyTypeFactory.convert(p.TA1)
, UnifyTypeFactory.convert(p.TA2));
return ret;
}else if(p.OperatorEqual()){
}else if(p.GetOperator().equals(PairOperator.EQUALSDOT)){
UnifyPair ret = generateEqualDotPair(UnifyTypeFactory.convert(p.TA1)
, UnifyTypeFactory.convert(p.TA2));
return ret;
}else throw new NotImplementedException();
}else throw new NotImplementedException();
}
/**
@ -150,7 +149,7 @@ public class UnifyTypeFactory {
public static RefTypeOrTPHOrWildcardOrGeneric convert(ReferenceType t, Map<String,TypePlaceholder> tphs) {
if(JavaClassName.Void.equals(t.getName()))return new Void(new NullToken());
RefType ret = new RefType(JavaClassName.Void,convert(t.getTypeParams(), tphs),new NullToken());
RefType ret = new RefType(new JavaClassName(t.getName()),convert(t.getTypeParams(), tphs),new NullToken());
return ret;
}
@ -173,6 +172,7 @@ public class UnifyTypeFactory {
TypePlaceholder ret = tphs.get(t.getName());
if(ret == null){ //Dieser TPH wurde vom Unifikationsalgorithmus erstellt
ret = TypePlaceholder.fresh(new NullToken());
tphs.put(t.getName(), ret);
}
return ret;
}

@ -1,23 +0,0 @@
package de.dhbwstuttgart.syntaxtree.operator;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Iterator;
import org.antlr.v4.runtime.Token;
import org.apache.bcel.Constants;
import org.apache.bcel.generic.ArithmeticInstruction;
import org.apache.bcel.generic.DUP;
import org.apache.bcel.generic.IADD;
import org.apache.bcel.generic.InstructionList;
import org.apache.bcel.generic.InvokeInstruction;
import org.apache.bcel.generic.ObjectType;
public abstract class AddOp extends Operator
{
public AddOp(Token offset) {
super(offset);
}
}

@ -1,18 +0,0 @@
package de.dhbwstuttgart.syntaxtree.operator;
import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode;
import de.dhbwstuttgart.syntaxtree.statement.Binary;
import org.antlr.v4.runtime.Token;
import org.apache.bcel.generic.InstructionList;
public class AndOp extends LogOp
{
public AndOp(Token offset)
{
super(offset);
}
}

@ -1,12 +0,0 @@
package de.dhbwstuttgart.syntaxtree.operator;
import org.antlr.v4.runtime.Token;
public class DivideOp extends MulOp
{
public DivideOp(Token offset) {
super(offset);
}
}

@ -1,15 +0,0 @@
package de.dhbwstuttgart.syntaxtree.operator;
import org.antlr.v4.runtime.Token;
import org.apache.bcel.generic.BranchInstruction;
import org.apache.bcel.generic.IF_ICMPNE;
public class EqualOp extends RelOp
{
public EqualOp(Token offset) {
super(offset);
}
}

@ -1,13 +0,0 @@
package de.dhbwstuttgart.syntaxtree.operator;
import org.antlr.v4.runtime.Token;
public class GreaterEquOp extends RelOp
{
public GreaterEquOp(Token offset) {
super(offset);
}
}

@ -1,14 +0,0 @@
package de.dhbwstuttgart.syntaxtree.operator;
import org.antlr.v4.runtime.Token;
public class GreaterOp extends RelOp
{
public GreaterOp(Token offset) {
super(offset);
}
}

@ -1,15 +0,0 @@
package de.dhbwstuttgart.syntaxtree.operator;
import org.antlr.v4.runtime.Token;
public class LessEquOp extends RelOp
{
public LessEquOp(Token offset) {
super(offset);
}
}

@ -1,14 +0,0 @@
package de.dhbwstuttgart.syntaxtree.operator;
import org.antlr.v4.runtime.Token;
public class LessOp extends RelOp
{
public LessOp(Token offset)
{
super(offset);
}
}

@ -1,18 +0,0 @@
package de.dhbwstuttgart.syntaxtree.operator;
import org.antlr.v4.runtime.Token;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Iterator;
public abstract class LogOp extends Operator
{
public LogOp(Token offset)
{
super(offset);
}
}

@ -1,11 +0,0 @@
package de.dhbwstuttgart.syntaxtree.operator;
import org.antlr.v4.runtime.Token;
public class MinusOp extends AddOp
{
public MinusOp(Token offset) {
super(offset);
}
}

@ -1,15 +0,0 @@
package de.dhbwstuttgart.syntaxtree.operator;
import org.antlr.v4.runtime.Token;
public class ModuloOp extends MulOp
{
public ModuloOp(Token offset)
{
super(offset);
}
}

@ -1,10 +0,0 @@
package de.dhbwstuttgart.syntaxtree.operator;
import org.antlr.v4.runtime.Token;
public abstract class MulOp extends Operator
{
public MulOp(Token offset) {
super(offset);
}
}

@ -1,11 +0,0 @@
package de.dhbwstuttgart.syntaxtree.operator;
import org.antlr.v4.runtime.Token;
public class NotEqualOp extends RelOp
{
public NotEqualOp(Token offset) {
super(offset);
}
}

@ -1,13 +0,0 @@
package de.dhbwstuttgart.syntaxtree.operator;
import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode;
import org.antlr.v4.runtime.Token;
public abstract class Operator extends SyntaxTreeNode
{
public Operator(Token offset) {
super(offset);
}
}

@ -1,15 +0,0 @@
package de.dhbwstuttgart.syntaxtree.operator;
import org.antlr.v4.runtime.Token;
public class OrOp extends LogOp
{
public OrOp(Token offset)
{
super(offset);
}
}

@ -1,12 +0,0 @@
package de.dhbwstuttgart.syntaxtree.operator;
import org.antlr.v4.runtime.Token;
public class PlusOp extends AddOp
{
public PlusOp(Token offset)
{
super(offset);
}
}

@ -1,11 +0,0 @@
package de.dhbwstuttgart.syntaxtree.operator;
import org.antlr.v4.runtime.Token;
public abstract class RelOp extends Operator
{
public RelOp(Token offset) {
super(offset);
}
}

@ -1,11 +0,0 @@
package de.dhbwstuttgart.syntaxtree.operator;
import org.antlr.v4.runtime.Token;
public class TimesOp extends MulOp
{
public TimesOp(Token offset)
{
super(offset);
}
}

@ -1,6 +1,7 @@
package de.dhbwstuttgart.syntaxtree.statement;
import de.dhbwstuttgart.syntaxtree.ASTVisitor;
import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode;
import org.antlr.v4.runtime.Token;
@ -19,4 +20,8 @@ public class ArgumentList extends SyntaxTreeNode
return expr;
}
@Override
public void accept(ASTVisitor visitor) {
visitor.visit(this);
}
}

@ -6,12 +6,16 @@ import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceBlockInformation;
import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceInformation;
import de.dhbwstuttgart.syntaxtree.operator.Operator;
// neu von Felix
public class Binary extends Expression
{
public enum Operator{
ADD,
SUB,
MUL,
AND, OR, DIV
}
public Binary(Expression expr1, Expression expr2, Operator op){
super(null, null);
}

@ -1,6 +1,7 @@
package de.dhbwstuttgart.syntaxtree.statement;
import de.dhbwstuttgart.syntaxtree.ASTVisitor;
import de.dhbwstuttgart.syntaxtree.StatementVisitor;
import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode;
import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
@ -23,4 +24,12 @@ public abstract class Expression extends SyntaxTreeNode
}
public abstract void accept(StatementVisitor visitor);
@Override
public void accept(ASTVisitor visitor) {
this.accept((StatementVisitor)visitor);
}
public String toString() { return this.getClass().getName() + ":" + type.toString(); }
}

@ -1,24 +0,0 @@
package de.dhbwstuttgart.syntaxtree.statement;
import de.dhbwstuttgart.exceptions.NotImplementedException;
import de.dhbwstuttgart.syntaxtree.StatementVisitor;
import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceBlockInformation;
import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceInformation;
import org.antlr.v4.runtime.Token;
public class InstVar extends Expression
{
private Expression expr;
public InstVar(Expression instanz, String name, Token offset)
{
super(instanz.getType(),offset);
expr = instanz;
}
@Override
public void accept(StatementVisitor visitor) {
visitor.visit(this);
}
}

@ -8,7 +8,7 @@ import de.dhbwstuttgart.typeinference.constraints.Constraint;
import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
import de.dhbwstuttgart.typeinference.constraints.Pair;
import org.antlr.v4.runtime.Token;
import sun.reflect.generics.reflectiveObjects.NotImplementedException;
//import sun.reflect.generics.reflectiveObjects.NotImplementedException;
import java.util.ArrayList;

@ -1,28 +1,23 @@
package de.dhbwstuttgart.syntaxtree.statement;
import de.dhbwstuttgart.exceptions.NotImplementedException;
import de.dhbwstuttgart.syntaxtree.StatementVisitor;
import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceBlockInformation;
import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceInformation;
import org.antlr.v4.runtime.Token;
public class LocalVar extends Statement{
protected final String expression;
public final String name;
public LocalVar(String n, RefTypeOrTPHOrWildcardOrGeneric type, Token offset)
{
super(type,offset);
this.expression = n;
this.name = n;
}
public LocalVar(Expression e1, RefTypeOrTPHOrWildcardOrGeneric type, String access)
{
super(type,e1.getOffset());
this.expression = access;
this.name = access;
}
@Override

@ -31,7 +31,7 @@ public class NewClass extends MethodCall
* @param start
*/
public NewClass(RefType newClass, ArgumentList args, Token start) {
super(newClass, new Receiver(new EmptyStmt(start)), "new "+newClass.getName().toString(), args, start);
super(newClass, new Receiver(new EmptyStmt(start)), newClass.getName().toString(), args, start);
}
@Override

@ -1,7 +1,6 @@
package de.dhbwstuttgart.syntaxtree.statement;
import de.dhbwstuttgart.syntaxtree.StatementVisitor;
import de.dhbwstuttgart.syntaxtree.operator.Operator;
import de.dhbwstuttgart.syntaxtree.type.RefType;
import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceBlockInformation;

@ -1,6 +1,7 @@
package de.dhbwstuttgart.syntaxtree.type;
import de.dhbwstuttgart.syntaxtree.ASTVisitor;
import org.antlr.v4.runtime.Token;
/**
@ -33,4 +34,8 @@ public class ExtendsWildcardType extends WildcardType{
}
@Override
public void accept(ASTVisitor visitor) {
visitor.visit(this);
}
}

@ -1,6 +1,9 @@
package de.dhbwstuttgart.syntaxtree.type;
import de.dhbwstuttgart.parser.NullToken;
import de.dhbwstuttgart.typecheck.JavaClassName;
import java.util.List;
/**
@ -13,22 +16,17 @@ import java.util.List;
*
*/
public class FunN extends RefType {
private RefTypeOrTPHOrWildcardOrGeneric R;
private List<? extends RefTypeOrTPHOrWildcardOrGeneric> T;
/**
* @author Andreas Stadelmeier, a10023
* Benötigt für den Typinferenzalgorithmus für Java 8
* Generiert einen RefType auf eine FunN<R,T1,...,TN> - Klasse.
* @param R
* @param T
* @param params
* @return
*/
public FunN(RefTypeOrTPHOrWildcardOrGeneric R, List<? extends RefTypeOrTPHOrWildcardOrGeneric> T) {
super(null,null);
public FunN(List<RefTypeOrTPHOrWildcardOrGeneric> params) {
super(new JavaClassName("Fun"+params.size()), params, new NullToken());
}
/**
* Spezieller Konstruktor um eine FunN ohne Returntype zu generieren

@ -1,5 +1,6 @@
package de.dhbwstuttgart.syntaxtree.type;
import de.dhbwstuttgart.syntaxtree.ASTVisitor;
import de.dhbwstuttgart.typecheck.GenericTypeName;
import de.dhbwstuttgart.typecheck.JavaClassName;
import org.antlr.v4.runtime.Token;
@ -20,5 +21,10 @@ public class GenericRefType extends RefTypeOrTPHOrWildcardOrGeneric
public String getUniqueIdentifier(){
return name.toString();
}
@Override
public void accept(ASTVisitor visitor) {
visitor.visit(this);
}
}

@ -1,5 +1,6 @@
package de.dhbwstuttgart.syntaxtree.type;
import de.dhbwstuttgart.syntaxtree.ASTVisitor;
import de.dhbwstuttgart.typecheck.JavaClassName;
import org.antlr.v4.runtime.Token;
@ -100,5 +101,9 @@ public class RefType extends RefTypeOrTPHOrWildcardOrGeneric
}
@Override
public void accept(ASTVisitor visitor) {
visitor.visit(this);
}
}

@ -1,10 +1,14 @@
package de.dhbwstuttgart.syntaxtree.type;
import de.dhbwstuttgart.syntaxtree.ASTVisitor;
import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode;
import org.antlr.v4.runtime.Token;
public class RefTypeOrTPHOrWildcardOrGeneric extends SyntaxTreeNode{
public abstract class RefTypeOrTPHOrWildcardOrGeneric extends SyntaxTreeNode{
public RefTypeOrTPHOrWildcardOrGeneric(Token offset) {
super(offset);
}
@Override
public abstract void accept(ASTVisitor visitor);
}

@ -1,6 +1,7 @@
package de.dhbwstuttgart.syntaxtree.type;
import de.dhbwstuttgart.syntaxtree.ASTVisitor;
import org.antlr.v4.runtime.Token;
/**
@ -42,4 +43,9 @@ public class SuperWildcardType extends WildcardType{
public boolean isSuper() {
return true;
}
@Override
public void accept(ASTVisitor visitor) {
visitor.visit(this);
}
}

@ -1,6 +1,7 @@
package de.dhbwstuttgart.syntaxtree.type;
import java.util.Hashtable;
import de.dhbwstuttgart.syntaxtree.ASTVisitor;
import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode;
import de.dhbwstuttgart.syntaxtree.factory.NameGenerator;
import org.antlr.v4.runtime.Token;
@ -65,4 +66,9 @@ public class TypePlaceholder extends RefTypeOrTPHOrWildcardOrGeneric
public String getName() {
return name;
}
@Override
public void accept(ASTVisitor visitor) {
visitor.visit(this);
}
}

@ -0,0 +1,13 @@
package de.dhbwstuttgart.syntaxtree.visual;
import de.dhbwstuttgart.syntaxtree.*;
public class ASTPrinter {
public static String print(SourceFile toPrint){
StringBuilder output = new StringBuilder();
new OutputGenerator(output).visit(toPrint);
return output.toString();
}
}

@ -0,0 +1,20 @@
package de.dhbwstuttgart.syntaxtree.visual;
import de.dhbwstuttgart.syntaxtree.*;
import de.dhbwstuttgart.syntaxtree.statement.*;
import de.dhbwstuttgart.syntaxtree.statement.literal.Literal;
import de.dhbwstuttgart.syntaxtree.statement.literal.Null;
import de.dhbwstuttgart.syntaxtree.type.*;
import java.lang.reflect.Modifier;
import java.util.Iterator;
public class ASTTypePrinter extends ASTPrinter{
public static String print(SourceFile toPrint){
StringBuilder output = new StringBuilder();
new TypeOutputGenerator(output).visit(toPrint);
return output.toString();
}
}

@ -0,0 +1,307 @@
package de.dhbwstuttgart.syntaxtree.visual;
import de.dhbwstuttgart.syntaxtree.*;
import de.dhbwstuttgart.syntaxtree.statement.*;
import de.dhbwstuttgart.syntaxtree.statement.literal.Literal;
import de.dhbwstuttgart.syntaxtree.statement.literal.Null;
import de.dhbwstuttgart.syntaxtree.type.*;
import java.lang.reflect.Modifier;
import java.util.Iterator;
public class OutputGenerator implements ASTVisitor {
private static final String TAB = " ";
String tabs = "";
protected final StringBuilder out;
public OutputGenerator(StringBuilder out){
this.out = out;
}
public void tab() {
tabs += TAB;
}
public void untab() {
tabs = tabs.substring(0,tabs.length()-TAB.length());
}
@Override
public void visit(SourceFile sourceFile) {
for(ClassOrInterface cl : sourceFile.getClasses()){
cl.accept(this);
}
}
@Override
public void visit(ArgumentList argumentList) {
out.append("(");
Iterator<Expression> expressionIterator = argumentList.getArguments().iterator();
while(expressionIterator.hasNext()){
expressionIterator.next().accept(this);
if(expressionIterator.hasNext())out.append(", ");
}
out.append(")");
}
@Override
public void visit(GenericTypeVar genericTypeVar) {
out.append(genericTypeVar.getName().toString());
}
@Override
public void visit(FormalParameter formalParameter) {
formalParameter.getType().accept(this);
out.append(" ");
out.append(formalParameter.getName());
}
@Override
public void visit(GenericDeclarationList genericTypeVars) {
Iterator<GenericTypeVar> genericIterator = genericTypeVars.iterator();
if(genericIterator.hasNext()){
out.append("<");
while(genericIterator.hasNext()){
genericIterator.next().accept(this);
if(genericIterator.hasNext())out.append(", ");
}
out.append(">");
}
}
@Override
public void visit(Field field) {
field.getType().accept(this);
out.append(" ");
out.append(field.getName());
out.append(";");
}
@Override
public void visit(Method method) {
method.getType().accept(this);
out.append(" " + method.getName());
method.getParameterList().accept(this);
method.block.accept(this);
out.append("\n");
}
@Override
public void visit(ParameterList formalParameters) {
out.append("(");
Iterator<FormalParameter> genericIterator = formalParameters.getFormalparalist().iterator();
if(genericIterator.hasNext()){
while(genericIterator.hasNext()){
genericIterator.next().accept(this);
if(genericIterator.hasNext())out.append(", ");
}
}
out.append(")");
}
@Override
public void visit(ClassOrInterface classOrInterface) {
if((Modifier.INTERFACE & classOrInterface.getModifiers()) == 1){
out.append("interface ");
}else{
out.append("class ");
}
out.append(classOrInterface.getClassName().toString());
classOrInterface.getGenerics().accept(this);
out.append(" {\n\n");
tab();
for(Field f : classOrInterface.getFieldDecl()){
out.append(tabs);
f.accept(this);
out.append("\n");
}
for(Method m : classOrInterface.getMethods()){
out.append(tabs);
m.accept(this);
out.append("\n");
}
untab();
out.append("}");
}
@Override
public void visit(RefType refType) {
out.append(refType.getName().toString());
Iterator<RefTypeOrTPHOrWildcardOrGeneric> genericIterator = refType.getParaList().iterator();
if(genericIterator.hasNext()){
out.append("<");
while(genericIterator.hasNext()){
genericIterator.next().accept(this);
if(genericIterator.hasNext())out.append(", ");
}
out.append(">");
}
}
@Override
public void visit(SuperWildcardType superWildcardType) {
out.append("? super ");
superWildcardType.getInnerType().accept(this);
}
@Override
public void visit(TypePlaceholder typePlaceholder) {
out.append("TPH "+ typePlaceholder.getName());
}
@Override
public void visit(ExtendsWildcardType extendsWildcardType) {
out.append("? extends ");
extendsWildcardType.getInnerType().accept(this);
}
@Override
public void visit(GenericRefType genericRefType) {
out.append(genericRefType.getName().toString());
}
@Override
public void visit(LambdaExpression lambdaExpression) {
lambdaExpression.params.accept(this);
out.append(" -> ");
lambdaExpression.methodBody.accept(this);
}
@Override
public void visit(Assign assign) {
assign.lefSide.accept(this);
out.append(" = ");
assign.rightSide.accept(this);
}
@Override
public void visit(Binary binary) {
}
@Override
public void visit(Block block) {
tab();
out.append("{\n");
for(Statement stmt : block.getStatements()){
out.append(tabs);
stmt.accept(this);
out.append(";\n");
}
untab();
out.append(tabs);
out.append("}");
}
@Override
public void visit(CastExpr castExpr) {
}
@Override
public void visit(EmptyStmt emptyStmt) {
}
@Override
public void visit(FieldVar fieldVar) {
fieldVar.receiver.accept(this);
out.append("." + fieldVar.fieldVarName);
}
@Override
public void visit(ForStmt forStmt) {
}
@Override
public void visit(IfStmt ifStmt) {
}
@Override
public void visit(InstanceOf instanceOf) {
}
@Override
public void visit(LocalVar localVar) {
out.append(localVar.name);
}
@Override
public void visit(LocalVarDecl localVarDecl) {
localVarDecl.getType().accept(this);
out.append(" " + localVarDecl.getName());
}
@Override
public void visit(MethodCall methodCall) {
methodCall.receiver.accept(this);
out.append("."+methodCall.name);
methodCall.getArgumentList().accept(this);
}
@Override
public void visit(NewClass methodCall) {
out.append("new ");
out.append(methodCall.name);
methodCall.getArgumentList().accept(this);
}
@Override
public void visit(NewArray newArray) {
}
@Override
public void visit(Receiver receiver) {
receiver.expr.accept(this);
}
@Override
public void visit(Return aReturn) {
out.append("return ");
aReturn.retexpr.accept(this);
}
@Override
public void visit(ReturnVoid aReturn) {
out.append("return");
}
@Override
public void visit(StaticClassName staticClassName) {
}
@Override
public void visit(Super aSuper) {
}
@Override
public void visit(This aThis) {
out.append("this");
}
@Override
public void visit(UnaryPlus unaryPlus) {
}
@Override
public void visit(WhileStmt whileStmt) {
}
@Override
public void visit(Null aNull) {
}
@Override
public void visit(Literal literal) {
}
}

@ -0,0 +1,236 @@
package de.dhbwstuttgart.syntaxtree.visual;
import de.dhbwstuttgart.syntaxtree.*;
import de.dhbwstuttgart.syntaxtree.statement.*;
import de.dhbwstuttgart.syntaxtree.statement.literal.Literal;
import de.dhbwstuttgart.syntaxtree.statement.literal.Null;
import de.dhbwstuttgart.syntaxtree.type.*;
import java.lang.reflect.Modifier;
import java.util.Iterator;
public class TypeOutputGenerator extends OutputGenerator {
TypeOutputGenerator(StringBuilder out){
super(out);
}
@Override
public void visit(SourceFile sourceFile) {
super.visit(sourceFile);
}
@Override
public void visit(ArgumentList argumentList) {
super.visit(argumentList);
}
@Override
public void visit(GenericTypeVar genericTypeVar) {
super.visit(genericTypeVar);
}
@Override
public void visit(FormalParameter formalParameter) {
super.visit(formalParameter);
}
@Override
public void visit(GenericDeclarationList genericTypeVars) {
super.visit(genericTypeVars);
}
@Override
public void visit(Field field) {
super.visit(field);
}
@Override
public void visit(Method method) {
super.visit(method);
}
@Override
public void visit(ParameterList formalParameters) {
super.visit(formalParameters);
}
@Override
public void visit(ClassOrInterface classOrInterface) {
super.visit(classOrInterface);
}
@Override
public void visit(RefType refType) {
super.visit(refType);
}
@Override
public void visit(SuperWildcardType superWildcardType) {
super.visit(superWildcardType);
}
@Override
public void visit(TypePlaceholder typePlaceholder) {
super.visit(typePlaceholder);
}
@Override
public void visit(ExtendsWildcardType extendsWildcardType) {
super.visit(extendsWildcardType);
}
@Override
public void visit(GenericRefType genericRefType) {
super.visit(genericRefType);
}
@Override
public void visit(LambdaExpression lambdaExpression) {
out.append("(");
super.visit(lambdaExpression);
out.append(")");
this.out.append("::");
lambdaExpression.getType().accept(this);
}
@Override
public void visit(Assign assign) {
super.visit(assign);
}
@Override
public void visit(Binary binary) {
super.visit(binary);
}
@Override
public void visit(Block block) {
out.append("(");
super.visit(block);
out.append(")");
this.out.append("::");
block.getType().accept(this);
}
@Override
public void visit(CastExpr castExpr) {
super.visit(castExpr);
}
@Override
public void visit(EmptyStmt emptyStmt) {
super.visit(emptyStmt);
}
@Override
public void visit(FieldVar fieldVar) {
out.append("(");
super.visit(fieldVar);
out.append(")");
this.out.append("::");
fieldVar.getType().accept(this);
}
@Override
public void visit(ForStmt forStmt) {
super.visit(forStmt);
}
@Override
public void visit(IfStmt ifStmt) {
super.visit(ifStmt);
}
@Override
public void visit(InstanceOf instanceOf) {
super.visit(instanceOf);
}
@Override
public void visit(LocalVar localVar) {
out.append("(");
super.visit(localVar);
out.append(")");
this.out.append("::");
localVar.getType().accept(this);
}
@Override
public void visit(LocalVarDecl localVarDecl) {
super.visit(localVarDecl);
}
@Override
public void visit(MethodCall methodCall) {
out.append("(");
super.visit(methodCall);
out.append(")");
this.out.append("::");
methodCall.getType().accept(this);
}
@Override
public void visit(NewClass methodCall) {
super.visit(methodCall);
}
@Override
public void visit(NewArray newArray) {
super.visit(newArray);
}
@Override
public void visit(Receiver receiver) {
super.visit(receiver);
}
@Override
public void visit(Return aReturn) {
super.visit(aReturn);
}
@Override
public void visit(ReturnVoid aReturn) {
super.visit(aReturn);
}
@Override
public void visit(StaticClassName staticClassName) {
super.visit(staticClassName);
}
@Override
public void visit(Super aSuper) {
super.visit(aSuper);
}
@Override
public void visit(This aThis) {
out.append("(");
super.visit(aThis);
out.append(")");
this.out.append("::");
aThis.getType().accept(this);
}
@Override
public void visit(UnaryPlus unaryPlus) {
super.visit(unaryPlus);
}
@Override
public void visit(WhileStmt whileStmt) {
super.visit(whileStmt);
}
@Override
public void visit(Null aNull) {
super.visit(aNull);
}
@Override
public void visit(Literal literal) {
super.visit(literal);
}
}

@ -1,7 +1,7 @@
package de.dhbwstuttgart.typecheck;
import de.dhbwstuttgart.parser.SyntaxTreeGenerator.GenericContext;
import jdk.nashorn.internal.ir.Node;
//import jdk.nashorn.internal.ir.Node;
public class GenericTypeName extends JavaClassName {
private final static String DELIMITER = "%";

@ -0,0 +1,31 @@
package de.dhbwstuttgart.typedeployment;
import org.antlr.v4.runtime.Token;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
public class TypeInsert {
Set<TypeInsertPoint> inserts;
public TypeInsert(Token point, String toInsert){
inserts = new HashSet<>();
inserts.add(new TypeInsertPoint(point, toInsert));
}
public TypeInsert(Set<TypeInsertPoint> points){
inserts = points;
}
public String insert(String intoSource){
String ret = intoSource;
List<TypeInsertPoint> offsets = new ArrayList<>();
for(TypeInsertPoint insertPoint : inserts){
ret = insertPoint.insert(ret, offsets);
offsets.add(insertPoint);
}
return ret;
}
}

@ -2,53 +2,175 @@ package de.dhbwstuttgart.typedeployment;
import de.dhbwstuttgart.exceptions.NotImplementedException;
import de.dhbwstuttgart.syntaxtree.*;
import de.dhbwstuttgart.syntaxtree.type.GenericRefType;
import de.dhbwstuttgart.syntaxtree.type.RefType;
import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
import de.dhbwstuttgart.syntaxtree.type.*;
import de.dhbwstuttgart.typeinference.ResultSet;
import de.dhbwstuttgart.typeinference.constraints.Pair;
import org.antlr.v4.runtime.Token;
import java.util.ArrayList;
import java.util.List;
import java.lang.reflect.Type;
import java.util.*;
/**
* TODO:
* Falls in Feldern Generics entstehen, dann werden diese als Klassenparameter eingesetzt
* Für die Instanzierung von Klassen kann man dann beispielsweise nur noch den Diamond-Operator verwenden
*
* Es müssen zu einem TPH alle in Beziehung stehenden Constraints gefunden werden
*/
public class TypeInsertFactory {
public static List<TypeInsertPoint> createTypeInsertPoints(SourceFile forSourcefile, ResultSet withResults){
List<TypeInsertPoint> ret = new ArrayList<>();
public static List<TypeInsert> createTypeInsertPoints(SourceFile forSourcefile, ResultSet withResults){
List<TypeInsert> 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));
for(Set<Pair> pairs : withResults.results)
ret.add(new TypeInsert(createInsertPoints(
field.getType(), field.getType().getOffset(), cl, null, pairs)));
}
}
for(Method m : cl.getMethods()){
RefTypeOrTPHOrWildcardOrGeneric resolved = withResults.resolveType(m.getReturnType());
String toInsert = getString(resolved) + " ";
ret.add(new TypeInsertPoint(m.getReturnType().getOffset(), toInsert));
for(Set<Pair> pairs : withResults.results)
ret.add(new TypeInsert(createInsertPoints(
m.getReturnType(), m.getReturnType().getOffset(), cl, m, pairs)));
for(FormalParameter param : m.getParameterList().getFormalparalist()){
resolved = withResults.resolveType(param.getType());
toInsert = getString(resolved) + " ";
ret.add(new TypeInsertPoint(param.getType().getOffset(), toInsert));
for(Set<Pair> pairs : withResults.results)
ret.add(new TypeInsert(createInsertPoints(
param.getType(), param.getType().getOffset(), cl, m, pairs)));
}
}
}
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 if(resolved instanceof GenericRefType){
return ((GenericRefType)resolved).getName().getShortName().toString();
}else{
throw new NotImplementedException();
private static Set<TypeInsertPoint> createInsertPoints(RefTypeOrTPHOrWildcardOrGeneric type, Token offset, ClassOrInterface cl, Method m,
Set<Pair> pairs) {
Set<TypeInsertPoint> ret = new HashSet<>();
Set<TypePlaceholder> additionalInserts = new HashSet<>();
for (Pair pair : pairs) {
RefTypeOrTPHOrWildcardOrGeneric relatedType = null;
if (pair.TA1.equals(type)) {
relatedType = pair.TA2;
} else if (pair.TA2.equals(type)) {
relatedType = pair.TA1;
}
if (relatedType != null) {
//Es wurde ein direkter Treffer gefunden:
if (pair.OperatorEqual()) { //resolved ist vom Typ RefType
RefType resolved = ((RefType) relatedType);
String insert = createInsertString(resolved, additionalInserts);
ret.add(new TypeInsertPoint(offset, insert));
} else { //Ansonsten ist es ein TPH
additionalInserts.add((TypePlaceholder) type);
//Dann wurde er nicht aufgelöst und es kann nur der TPH als Generic eingesetzt werden:
ret.add(new TypeInsertPoint(offset, ((TypePlaceholder) type).getName()));
}
}
}
//Alle Bounds finden:
Set<Pair> newGenerics = new HashSet<>();
boolean added = true;
while(added){
added = false;
for(Pair pair : pairs){
if (additionalInserts.contains(pair.TA1) || additionalInserts.contains(pair.TA2)) {
newGenerics.add(pair);
added |= additionalInserts.add((TypePlaceholder) pair.TA1);
added |= additionalInserts.add((TypePlaceholder) pair.TA2);
}
}
}
//Alle TPHs die man noch als Generics anfügen muss einsetzen:
additionalInserts.clear();
for(Pair subtypings : newGenerics){
if(additionalInserts.contains(subtypings.TA1)){
additionalInserts.remove(subtypings.TA1);
}
}
for(TypePlaceholder tph : additionalInserts){
newGenerics.add(new Pair(tph, null));
}
ret.add(createGenericInsert(newGenerics, cl, m));
return ret;
}
}
private static String createInsertString(RefType resolved, Set<TypePlaceholder> additionalInserts) {
String insert = resolved.getName().toString();
if(resolved.getParaList().size() > 0){
insert += "<";
Iterator<RefTypeOrTPHOrWildcardOrGeneric> iterator = resolved.getParaList().iterator();
while(iterator.hasNext()){
RefTypeOrTPHOrWildcardOrGeneric typeParam = iterator.next();
if(typeParam instanceof TypePlaceholder){
insert += ((TypePlaceholder) typeParam).getName();
additionalInserts.add((TypePlaceholder) typeParam);
}else if(typeParam instanceof RefType) {
insert += createInsertString((RefType) typeParam, additionalInserts);
}else if(typeParam instanceof SuperWildcardType){
insert += "? super " + createInsertString(((SuperWildcardType) typeParam).getInnerType(), additionalInserts);
}else if(typeParam instanceof ExtendsWildcardType){
insert += "? extends " + createInsertString(((ExtendsWildcardType) typeParam).getInnerType(), additionalInserts);
}else throw new NotImplementedException();
if(iterator.hasNext())insert += ", ";
}
insert += ">";
}
return insert;
}
private static TypeInsertPoint createGenericInsert(Set<Pair> toInsert, ClassOrInterface cl, Method m){
//Momentan wird Methode ignoriert. Parameter werden immer als Klassenparameter angefügt:
//Offset zum Einstzen bestimmen:
Token offset;
String insert = "";
String end;
if(cl.getGenerics().iterator().hasNext()){
//offset = cl.getGenerics().iterator().next().getOffset();
offset = cl.getGenerics().getOffset();
end=",";
}else{
offset = cl.getGenerics().getOffset();
insert += "<";
end = ">";
}
//Alle einzusetzenden Generics und deren Bounds bestimmen:
HashMap<TypePlaceholder, HashSet<TypePlaceholder>> genericsAndBounds = new HashMap<>();
for(Pair p : toInsert){
if(!genericsAndBounds.containsKey(p.TA1)){
genericsAndBounds.put((TypePlaceholder) p.TA1, new HashSet<>());
}
if(p.TA2 != null){
genericsAndBounds.get(p.TA1).add((TypePlaceholder) p.TA2);
if(!genericsAndBounds.containsKey(p.TA2)){
genericsAndBounds.put((TypePlaceholder) p.TA2, new HashSet<>());
}
}
}
//String zum Einsetzen (Generics mit bounds) generieren:
Iterator<TypePlaceholder> it = genericsAndBounds.keySet().iterator();
if(! it.hasNext())return new TypeInsertPoint(offset, "");
while(it.hasNext()){
TypePlaceholder tph = it.next();
insert += tph.getName();
Set<TypePlaceholder> bounds = genericsAndBounds.get(tph);
if(bounds.size() > 0){
insert += " extends ";
Iterator<TypePlaceholder> boundIt = bounds.iterator();
while(boundIt.hasNext()){
TypePlaceholder bound = boundIt.next();
insert += bound.getName();
if(boundIt.hasNext())insert += " & ";
}
}
if(it.hasNext())insert+=",";
}
return new TypeInsertPoint(offset, insert + end);
}
}

@ -2,16 +2,23 @@ package de.dhbwstuttgart.typedeployment;
import org.antlr.v4.runtime.Token;
import java.util.List;
import java.util.stream.Collectors;
public class TypeInsertPoint {
Token point;
private String insertString;
public TypeInsertPoint(Token point, String toInsert){
this.point = point;
this.insertString = toInsert;
this.insertString = (toInsert.length()>1) ? toInsert + " " : toInsert;
}
public String insert(String intoSource){
return new StringBuilder(intoSource).insert(point.getStartIndex(), insertString).toString();
public String insert(String intoSource, List<TypeInsertPoint> additionalOffset){
int offset = additionalOffset.stream().filter((token ->
//token.point.getLine() != point.getLine() && token.point.getCharPositionInLine() <= point.getCharPositionInLine()))
token.point.getStartIndex() <= point.getStartIndex()))
.mapToInt((typeInsertPoint -> typeInsertPoint.insertString.length())).sum();
return new StringBuilder(intoSource).insert(point.getStartIndex()+offset, insertString).toString();
}
}

@ -7,30 +7,30 @@ import de.dhbwstuttgart.typeinference.constraints.Pair;
import de.dhbwstuttgart.typeinference.unify.model.PairOperator;
import de.dhbwstuttgart.typeinference.unify.model.UnifyPair;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;
public class ResultSet {
Set<Set<Pair>> results;
public final Set<Set<Pair>> results;
public ResultSet(Set<Set<Pair>> results){
this.results = results;
}
public RefTypeOrTPHOrWildcardOrGeneric resolveType(RefTypeOrTPHOrWildcardOrGeneric type) {
public List<Pair> 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;
final List<Pair> ret = new ArrayList<>();
for(Set<Pair> 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;
}
//if(pair.OperatorEqual()){ //type ist vom Typ TypePlaceholder
if(pair.TA1.equals(type) || pair.TA2.equals(type)){
ret.add(pair);
}
//}
}
return type;
return ret;
}
}

@ -14,7 +14,7 @@ import java.util.List;
public class ConstraintsFactory {
public static Pair createPair(RefTypeOrTPHOrWildcardOrGeneric t1, RefTypeOrTPHOrWildcardOrGeneric t2, PairOperator equalsdot, TypeInferenceBlockInformation info){
//Check whether Generics are in the same class:
return new Pair(checkGeneric(t1, info), checkGeneric(t2, info));
return new Pair(checkGeneric(t1, info), checkGeneric(t2, info), equalsdot);
}
public static Pair createPair(RefTypeOrTPHOrWildcardOrGeneric t1,
RefTypeOrTPHOrWildcardOrGeneric t2, TypeInferenceBlockInformation info){

@ -1,13 +1,17 @@
package de.dhbwstuttgart.typeinference.typeAlgo;
//import com.sun.org.apache.xpath.internal.Arg;
import de.dhbwstuttgart.exceptions.NotImplementedException;
import de.dhbwstuttgart.exceptions.TypeinferenceException;
import de.dhbwstuttgart.parser.NullToken;
import de.dhbwstuttgart.syntaxtree.*;
import de.dhbwstuttgart.syntaxtree.statement.*;
import de.dhbwstuttgart.syntaxtree.statement.literal.Literal;
import de.dhbwstuttgart.syntaxtree.statement.literal.Null;
import de.dhbwstuttgart.syntaxtree.type.FunN;
import de.dhbwstuttgart.syntaxtree.type.RefType;
import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
import de.dhbwstuttgart.typeinference.assumptions.FieldAssumption;
import de.dhbwstuttgart.typeinference.assumptions.MethodAssumption;
import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceBlockInformation;
@ -18,6 +22,7 @@ import de.dhbwstuttgart.typeinference.constraints.Pair;
import de.dhbwstuttgart.typeinference.unify.model.PairOperator;
import java.util.*;
import java.util.stream.Collectors;
public class TYPE implements StatementVisitor{
@ -34,6 +39,18 @@ public class TYPE implements StatementVisitor{
@Override
public void visit(LambdaExpression lambdaExpression) {
TypePlaceholder tphRetType = TypePlaceholder.fresh(new NullToken());
List<RefTypeOrTPHOrWildcardOrGeneric> lambdaParams = lambdaExpression.params.getFormalparalist().stream().map((formalParameter -> formalParameter.getType())).collect(Collectors.toList());
//lambdaParams.add(tphRetType);
lambdaParams.add(0,tphRetType);
constraintsSet.addUndConstraint(
ConstraintsFactory.createPair(lambdaExpression.getType(),
new FunN(lambdaParams),PairOperator.EQUALSDOT,info));
constraintsSet.addUndConstraint(
ConstraintsFactory.createPair(lambdaExpression.getReturnType(),
tphRetType,info));
//Constraints des Bodys generieren:
TYPE lambdaScope = new TYPE(new TypeInferenceBlockInformation(info, lambdaExpression));
lambdaExpression.methodBody.accept(lambdaScope);
constraintsSet.addAll(lambdaScope.getConstraints());
@ -101,11 +118,6 @@ public class TYPE implements StatementVisitor{
throw new NotImplementedException();
}
@Override
public void visit(InstVar instVar) {
throw new NotImplementedException();
}
@Override
public void visit(LocalVar localVar) {
// Es werden nur bei Feldvariablen Constraints generiert. Lokale Variablen sind eindeutig
@ -159,7 +171,7 @@ public class TYPE implements StatementVisitor{
public void visit(Return returnExpr) {
returnExpr.retexpr.accept(this);
constraintsSet.addUndConstraint(ConstraintsFactory.createPair(
returnExpr.getType(),info.getCurrentTypeScope().getReturnType(), info));
returnExpr.getType(),info.getCurrentTypeScope().getReturnType(), PairOperator.EQUALSDOT, info));
}
@Override
@ -209,7 +221,7 @@ public class TYPE implements StatementVisitor{
protected Constraint<Pair> generateConstraint(MethodCall forMethod, MethodAssumption assumption, TypeInferenceBlockInformation info){
Constraint methodConstraint = new Constraint();
methodConstraint.add(ConstraintsFactory.createPair(forMethod.receiver.getType(), assumption.getReceiverType(), PairOperator.SMALLERDOT, info));
methodConstraint.add(ConstraintsFactory.createPair(assumption.getReturnType(), forMethod.getType(), PairOperator.SMALLERDOT, info));
methodConstraint.add(ConstraintsFactory.createPair(assumption.getReturnType(), forMethod.getType(), PairOperator.EQUALSDOT, info));
methodConstraint.addAll(generateParameterConstraints(forMethod, assumption, info));
return methodConstraint;
}
@ -217,19 +229,26 @@ public class TYPE implements StatementVisitor{
protected Set<Pair> generateParameterConstraints(MethodCall foMethod, MethodAssumption assumption, TypeInferenceBlockInformation info) {
Set<Pair> ret = new HashSet<>();
for(int i = 0;i<foMethod.arglist.getArguments().size();i++){
ret.add(ConstraintsFactory.createPair(assumption.getArgTypes().get(i),
foMethod.arglist.getArguments().get(i).getType(), PairOperator.SMALLERDOT, info));
ret.add(ConstraintsFactory.createPair(foMethod.arglist.getArguments().get(i).getType(),
assumption.getArgTypes().get(i), PairOperator.SMALLERDOT, info));
}
return ret;
}
public static List<MethodAssumption> getMethods(String name, ArgumentList arglist, TypeInferenceBlockInformation info) {
public static List<MethodAssumption> getMethods(String name, int numArgs, TypeInferenceBlockInformation info) {
List<MethodAssumption> ret = new ArrayList<>();
if(name.equals("apply")){
List<RefTypeOrTPHOrWildcardOrGeneric> funNParams = new ArrayList<>();
for(int i = 0; i< numArgs + 1 ; i++){
funNParams.add(TypePlaceholder.fresh(new NullToken()));
}
ret.add(new MethodAssumption(new FunN(funNParams), funNParams.get(0), funNParams.subList(1, funNParams.size())));
}
for(ClassOrInterface cl : info.getAvailableClasses()){
for(Method m : cl.getMethods()){
if(m.getName().equals(name) &&
m.getParameterList().getFormalparalist().size() == arglist.getArguments().size()){
m.getParameterList().getFormalparalist().size() == numArgs){
RefTypeOrTPHOrWildcardOrGeneric retType = info.checkGTV(m.getType());
ret.add(new MethodAssumption(cl.getType(), retType, convertParams(m.getParameterList(),info)));
@ -239,7 +258,11 @@ public class TYPE implements StatementVisitor{
return ret;
}
protected static List<RefTypeOrTPHOrWildcardOrGeneric> convertParams(ParameterList parameterList, TypeInferenceBlockInformation info){
public static List<MethodAssumption> getMethods(String name, ArgumentList arglist, TypeInferenceBlockInformation info) {
return getMethods(name, arglist.getArguments().size(), info);
}
protected static List<RefTypeOrTPHOrWildcardOrGeneric> convertParams(ParameterList parameterList, TypeInferenceBlockInformation info){
List<RefTypeOrTPHOrWildcardOrGeneric> params = new ArrayList<>();
for(FormalParameter fp : parameterList.getFormalparalist()){
params.add(info.checkGTV(fp.getType()));

@ -1,6 +1,6 @@
package astfactory;
import javafx.collections.ObservableList;
//import javafx.collections.ObservableList;
import org.junit.Test;
import java.lang.reflect.ParameterizedType;

13
test/javFiles/Faculty.jav Normal file

@ -0,0 +1,13 @@
class Faculty {
Integer mul(Integer x, Integer y) {
return x;
}
m () {
auto fact = (Integer x) -> {
return mul(x, fact.apply(x));
};
return fact;
}
}

@ -1,20 +1,18 @@
class Lambda{
String var;
methode(){
return () -> (f) -> {
f.apply(this, var);
return var;
};
return ((f) -> f);
}
}
/*
interface Fun0<A>{
A apply();
}
interface Fun1<A,B>{
A apply(B b);
}
*/
interface Fun2<A,B,C>{
A apply(B b, C c);
}

@ -4,8 +4,14 @@ public class Lambda2
public static void main(List<String> args){
auto listOfStrings = new List<String>();
auto listOfObjects;
//listOfObjects = map(listOfStrings, (a) -> a);
listOfObjects = map(listOfStrings, (a) -> a);
}
public map(a , b){
b.apply(a);
return a;
}
/*
public static <I,O> List<O> map(List<I> input, Function<I,O> func) {
List<O> output;

23
test/javFiles/Lambda3.jav Normal file

@ -0,0 +1,23 @@
public class Lambda2
{
/*
public static <A> List<A> map(List<? extends A> input,
Function<? super A, ? extends A> func){
input.add(func.apply(input.get()));
}
*/
public map(input,func){
input.add(func.apply(input.get()));
return map(new List<String>(), func);
}
}
class List<A>{
A get();
void add(A);
}
class Function<A,B>{
B apply(A a);
}

@ -0,0 +1,12 @@
class mathStruc<A> {
mathStruc(A a) { }
A model(){ A a; return a; }
methode(){
auto innerOp = o -> ms ->
new mathStruc<A>(o.apply(this.model(),ms.model()));
return innerOp;
}
}

@ -3,6 +3,11 @@ package typeinference;
import de.dhbwstuttgart.core.JavaTXCompiler;
import de.dhbwstuttgart.parser.ClassNotFoundException;
import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode;
import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
import de.dhbwstuttgart.syntaxtree.visual.ASTPrinter;
import de.dhbwstuttgart.syntaxtree.visual.ASTTypePrinter;
import de.dhbwstuttgart.syntaxtree.visual.OutputGenerator;
import de.dhbwstuttgart.typedeployment.TypeInsert;
import de.dhbwstuttgart.typedeployment.TypeInsertPoint;
import de.dhbwstuttgart.typeinference.ResultSet;
import org.junit.Test;
@ -18,25 +23,29 @@ import java.util.List;
import static org.junit.Assert.*;
public class JavaTXCompilerTest {
public class JavaTXCompilerTest extends JavaTXCompiler {
private static final String rootDirectory = System.getProperty("user.dir")+"/test/javFiles/";
private static final List<File> filesToTest = new ArrayList<>();
@Test
public void test() throws IOException, ClassNotFoundException {
filesToTest.add(new File(rootDirectory+"Lambda2.jav"));
//filesToTest.add(new File(rootDirectory+"Faculty.jav"));
filesToTest.add(new File(rootDirectory+"mathStruc.jav"));
//filesToTest.add(new File(rootDirectory+"Faculty.jav"));
//filesToTest.add(new File(rootDirectory+"Lambda.jav"));
//filesToTest.add(new File(rootDirectory+"Lambda2.jav"));
//filesToTest.add(new File(rootDirectory+"Lambda3.jav"));
//filesToTest.add(new File(rootDirectory+"Vector.jav"));
//filesToTest.add(new File(rootDirectory+"Generics.jav"));
//filesToTest.add(new File(rootDirectory+"MethodsEasy.jav"));
//filesToTest.add(new File(rootDirectory+"Lambda.jav"));
//filesToTest.add(new File(rootDirectory+"Matrix.jav"));
JavaTXCompiler compiler = new JavaTXCompiler();
for(File f : filesToTest){
compiler.parse(f);
List<TypeInsertPoint> result = compiler.getTypeInserts(f);
this.parse(f);
System.out.println(ASTTypePrinter.print(this.sourceFiles.get(sourceFiles.size()-1)));
List<TypeInsert> result = this.getTypeInserts(f);
String content = readFile(f.getPath(), StandardCharsets.UTF_8);
for(TypeInsertPoint tip : result){
for(TypeInsert tip : result){
System.out.println(tip.insert(content));
}
}
@ -49,4 +58,5 @@ public class JavaTXCompilerTest {
byte[] encoded = Files.readAllBytes(Paths.get(path));
return new String(encoded, encoding);
}
}
}