i21012/JavaPatternMatching
1
0
Fork 0
forked from JavaTX/JavaCompilerCore
Code Pull Requests Activity

Type implementiert

Browse Source
This commit is contained in:
Aldaron7 2018-03-14 13:02:10 +01:00
parent 9e14473975
commit 7e88ddc3d5
27 changed files with 560 additions and 393 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

32
src/de/dhbwstuttgart/strucTypes/CheckTypeVisitor.java
View File

@ -1,32 +0,0 @@
package de.dhbwstuttgart.strucTypes;
import de.dhbwstuttgart.syntaxtree.type.RefType;
import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
public class CheckTypeVisitor extends DefaultASTVisitor {
private boolean isTypeVariable;
private String name;
@Override
public void visit(RefType refType) {
this.isTypeVariable = true;
this.name = refType.getName().toString();
}
@Override
public void visit(TypePlaceholder typePlaceholder) {
this.isTypeVariable = false;
this.name = typePlaceholder.getName();
}
public boolean isTypeVariable() {
return isTypeVariable;
}
public String getName() {
return name;
}
}

25
src/de/dhbwstuttgart/strucTypes/ClassOrInterfaceFactory.java Normal file
View File

@ -0,0 +1,25 @@
package de.dhbwstuttgart.strucTypes;
import java.util.Optional;
import de.dhbwstuttgart.parser.scope.JavaClassName;
import de.dhbwstuttgart.syntaxtree.ClassOrInterface;
import de.dhbwstuttgart.syntaxtree.factory.ASTFactory;
import de.dhbwstuttgart.syntaxtree.type.RefType;
public class ClassOrInterfaceFactory {
public static Optional<ClassOrInterface> createClass(JavaClassName name) {
try {
return Optional.of(ASTFactory.createClass(ClassLoader.getSystemClassLoader().loadClass(name.toString())));
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return Optional.empty();
}
public static Optional<ClassOrInterface> createClass(RefType refType) {
return ClassOrInterfaceFactory.createClass(refType.getName());
}
}

2
src/de/dhbwstuttgart/strucTypes/DefaultASTVisitor.java
View File

@ -47,7 +47,7 @@ import de.dhbwstuttgart.syntaxtree.type.RefType;
import de.dhbwstuttgart.syntaxtree.type.SuperWildcardType;
import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
public class DefaultASTVisitor implements ASTVisitor {
public abstract class DefaultASTVisitor implements ASTVisitor {
@Override
public void visit(ArgumentList argumentList) {

44
src/de/dhbwstuttgart/strucTypes/StrucTYPE.java
View File

@ -1,16 +1,52 @@
package de.dhbwstuttgart.strucTypes;
import java.util.HashMap;
import java.util.Map;
import de.dhbwstuttgart.strucTypes.constraint.ConstraintsSet;
import de.dhbwstuttgart.syntaxtree.ClassOrInterface;
import de.dhbwstuttgart.syntaxtree.Method;
import de.dhbwstuttgart.syntaxtree.SourceFile;
import de.dhbwstuttgart.syntaxtree.statement.Expression;
import de.dhbwstuttgart.syntaxtree.statement.Return;
import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
public class StrucTYPE {
public class StrucTYPE extends DefaultASTVisitor {
private TypeAssumptions assumptions;
private SourceFile sourceFile;
private ConstraintsSet constraintsSet = new ConstraintsSet();
private Map<TypePlaceholder, RefTypeOrTPHOrWildcardOrGeneric> inferredTypes = new HashMap<>();
public StrucTYPE(TypeAssumptions assumptions, SourceFile sourceFile) {
this.assumptions = assumptions;
public StrucTYPE(SourceFile sourceFile) {
this.sourceFile = sourceFile;
}
public ConstraintsSet getConstraints() {
for (ClassOrInterface cls : sourceFile.getClasses()) {
TYPEExpr typeExpr = new TYPEExpr();
cls.accept(typeExpr);
this.evaluateTypeExpr(typeExpr);
cls.getMethods().forEach(m -> m.accept(this));
}
return this.constraintsSet;
}
public Map<TypePlaceholder, RefTypeOrTPHOrWildcardOrGeneric> getInferredTypes() {
return inferredTypes;
}
@Override
public void visit(Method method) {
// Es gibt nur ein Return Statement
Expression retexpr = ((Return) method.block.statements.get(0)).retexpr;
// ordnet dem Methodentyp den Returntyp zu [sigma(Mt)]
this.inferredTypes.put((TypePlaceholder) method.getReturnType(), retexpr.getType());
}
private void evaluateTypeExpr(TYPEExpr typeExpr) {
this.inferredTypes.putAll(typeExpr.getInferredTypes());
this.constraintsSet.addConstraintsSet(typeExpr.getConstraints());
}
}

187
src/de/dhbwstuttgart/strucTypes/StrucTypeVisitor.java
View File

@ -1,187 +0,0 @@
package de.dhbwstuttgart.strucTypes;
import de.dhbwstuttgart.exceptions.NotImplementedException;
import de.dhbwstuttgart.parser.SyntaxTreeGenerator.AssignToLocal;
import de.dhbwstuttgart.syntaxtree.ASTVisitor;
import de.dhbwstuttgart.syntaxtree.Constructor;
import de.dhbwstuttgart.syntaxtree.GenericDeclarationList;
import de.dhbwstuttgart.syntaxtree.GenericTypeVar;
import de.dhbwstuttgart.syntaxtree.statement.Assign;
import de.dhbwstuttgart.syntaxtree.statement.AssignToField;
import de.dhbwstuttgart.syntaxtree.statement.Binary;
import de.dhbwstuttgart.syntaxtree.statement.DoStmt;
import de.dhbwstuttgart.syntaxtree.statement.EmptyStmt;
import de.dhbwstuttgart.syntaxtree.statement.ForStmt;
import de.dhbwstuttgart.syntaxtree.statement.IfStmt;
import de.dhbwstuttgart.syntaxtree.statement.InstanceOf;
import de.dhbwstuttgart.syntaxtree.statement.LambdaExpression;
import de.dhbwstuttgart.syntaxtree.statement.LocalVarDecl;
import de.dhbwstuttgart.syntaxtree.statement.NewArray;
import de.dhbwstuttgart.syntaxtree.statement.ReturnVoid;
import de.dhbwstuttgart.syntaxtree.statement.StaticClassName;
import de.dhbwstuttgart.syntaxtree.statement.Super;
import de.dhbwstuttgart.syntaxtree.statement.SuperCall;
import de.dhbwstuttgart.syntaxtree.statement.UnaryPlus;
import de.dhbwstuttgart.syntaxtree.statement.WhileStmt;
import de.dhbwstuttgart.syntaxtree.statement.literal.Literal;
import de.dhbwstuttgart.syntaxtree.statement.literal.Null;
import de.dhbwstuttgart.syntaxtree.type.ExtendsWildcardType;
import de.dhbwstuttgart.syntaxtree.type.GenericRefType;
import de.dhbwstuttgart.syntaxtree.type.SuperWildcardType;
public abstract class StrucTypeVisitor implements ASTVisitor {
@Override
public void visit(LambdaExpression lambdaExpression) {
throw new NotImplementedException();
}
@Override
public void visit(Assign assign) {
throw new NotImplementedException();
}
@Override
public void visit(Binary binary) {
throw new NotImplementedException();
}
@Override
public void visit(EmptyStmt emptyStmt) {
throw new NotImplementedException();
}
@Override
public void visit(ForStmt forStmt) {
throw new NotImplementedException();
}
@Override
public void visit(IfStmt ifStmt) {
throw new NotImplementedException();
}
@Override
public void visit(InstanceOf instanceOf) {
throw new NotImplementedException();
}
@Override
public void visit(LocalVarDecl localVarDecl) {
throw new NotImplementedException();
}
@Override
public void visit(NewArray newArray) {
throw new NotImplementedException();
}
@Override
public void visit(ReturnVoid aReturn) {
throw new NotImplementedException();
}
@Override
public void visit(StaticClassName staticClassName) {
throw new NotImplementedException();
}
@Override
public void visit(Super aSuper) {
throw new NotImplementedException();
}
@Override
public void visit(UnaryPlus unaryPlus) {
throw new NotImplementedException();
}
@Override
public void visit(WhileStmt whileStmt) {
throw new NotImplementedException();
}
@Override
public void visit(DoStmt whileStmt) {
throw new NotImplementedException();
}
@Override
public void visit(Null aNull) {
throw new NotImplementedException();
}
@Override
public void visit(Literal literal) {
throw new NotImplementedException();
}
@Override
public void visit(AssignToField assignLeftSide) {
throw new NotImplementedException();
}
@Override
public void visit(AssignToLocal assignLeftSide) {
throw new NotImplementedException();
}
@Override
public void visit(SuperCall superCall) {
throw new NotImplementedException();
}
@Override
public void visit(GenericTypeVar genericTypeVar) {
throw new NotImplementedException();
}
@Override
public void visit(GenericDeclarationList genericTypeVars) {
throw new NotImplementedException();
}
@Override
public void visit(Constructor field) {
throw new NotImplementedException();
}
@Override
public void visit(SuperWildcardType superWildcardType) {
throw new NotImplementedException();
}
@Override
public void visit(ExtendsWildcardType extendsWildcardType) {
throw new NotImplementedException();
}
@Override
public void visit(GenericRefType genericRefType) {
throw new NotImplementedException();
}
}

232
src/de/dhbwstuttgart/strucTypes/TYPEExpr.java
View File

@ -1,188 +1,192 @@
package de.dhbwstuttgart.strucTypes;
import de.dhbwstuttgart.exceptions.NotImplementedException;
import de.dhbwstuttgart.parser.SyntaxTreeGenerator.AssignToLocal;
import de.dhbwstuttgart.syntaxtree.ASTVisitor;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import de.dhbwstuttgart.strucTypes.constraint.ConstraintsSet;
import de.dhbwstuttgart.strucTypes.constraint.FieldConstraint;
import de.dhbwstuttgart.strucTypes.constraint.MethodConstraint;
import de.dhbwstuttgart.strucTypes.constraint.SubTypeConstraint;
import de.dhbwstuttgart.syntaxtree.ClassOrInterface;
import de.dhbwstuttgart.syntaxtree.Constructor;
import de.dhbwstuttgart.syntaxtree.Field;
import de.dhbwstuttgart.syntaxtree.FormalParameter;
import de.dhbwstuttgart.syntaxtree.GenericDeclarationList;
import de.dhbwstuttgart.syntaxtree.GenericTypeVar;
import de.dhbwstuttgart.syntaxtree.Method;
import de.dhbwstuttgart.syntaxtree.ParameterList;
import de.dhbwstuttgart.syntaxtree.SourceFile;
import de.dhbwstuttgart.syntaxtree.statement.ArgumentList;
import de.dhbwstuttgart.syntaxtree.statement.Assign;
import de.dhbwstuttgart.syntaxtree.statement.AssignToField;
import de.dhbwstuttgart.syntaxtree.statement.Binary;
import de.dhbwstuttgart.syntaxtree.statement.Block;
import de.dhbwstuttgart.syntaxtree.statement.CastExpr;
import de.dhbwstuttgart.syntaxtree.statement.DoStmt;
import de.dhbwstuttgart.syntaxtree.statement.EmptyStmt;
import de.dhbwstuttgart.syntaxtree.statement.Expression;
import de.dhbwstuttgart.syntaxtree.statement.ExpressionReceiver;
import de.dhbwstuttgart.syntaxtree.statement.FieldVar;
import de.dhbwstuttgart.syntaxtree.statement.ForStmt;
import de.dhbwstuttgart.syntaxtree.statement.IfStmt;
import de.dhbwstuttgart.syntaxtree.statement.InstanceOf;
import de.dhbwstuttgart.syntaxtree.statement.LambdaExpression;
import de.dhbwstuttgart.syntaxtree.statement.LocalVar;
import de.dhbwstuttgart.syntaxtree.statement.LocalVarDecl;
import de.dhbwstuttgart.syntaxtree.statement.MethodCall;
import de.dhbwstuttgart.syntaxtree.statement.NewArray;
import de.dhbwstuttgart.syntaxtree.statement.NewClass;
import de.dhbwstuttgart.syntaxtree.statement.Return;
import de.dhbwstuttgart.syntaxtree.statement.ReturnVoid;
import de.dhbwstuttgart.syntaxtree.statement.StaticClassName;
import de.dhbwstuttgart.syntaxtree.statement.Super;
import de.dhbwstuttgart.syntaxtree.statement.SuperCall;
import de.dhbwstuttgart.syntaxtree.statement.This;
import de.dhbwstuttgart.syntaxtree.statement.UnaryPlus;
import de.dhbwstuttgart.syntaxtree.statement.WhileStmt;
import de.dhbwstuttgart.syntaxtree.statement.literal.Literal;
import de.dhbwstuttgart.syntaxtree.statement.literal.Null;
import de.dhbwstuttgart.syntaxtree.type.ExtendsWildcardType;
import de.dhbwstuttgart.syntaxtree.type.GenericRefType;
import de.dhbwstuttgart.syntaxtree.type.RefType;
import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
import de.dhbwstuttgart.syntaxtree.type.SuperWildcardType;
import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
public class TYPEExpr extends StrucTypeVisitor {
public class TYPEExpr extends DefaultASTVisitor {
private TypeAssumptions assumptions;
private ConstraintsSet constraints;
private ClassOrInterface aThis;
private ConstraintsSet constraints = new ConstraintsSet();
private Map<TypePlaceholder, RefTypeOrTPHOrWildcardOrGeneric> inferredTypes = new HashMap<>();
public TYPEExpr(TypeAssumptions assumptions) {
this.assumptions = assumptions;
public TYPEExpr() {
}
public ConstraintsSet getConstraints() {
return this.constraints;
}
@Override
public void visit(SourceFile sourceFile) {
// TODO Auto-generated method stub
throw new NotImplementedException();
public Map<TypePlaceholder, RefTypeOrTPHOrWildcardOrGeneric> getInferredTypes() {
return inferredTypes;
}
@Override
public void visit(ClassOrInterface classOrInterface) {
// TODO Auto-generated method stub
throw new NotImplementedException();
}
@Override
public void visit(Field field) {
// TODO Auto-generated method stub
throw new NotImplementedException();
}
@Override
public void visit(Method method) {
// TODO Auto-generated method stub
throw new NotImplementedException();
}
@Override
public void visit(ParameterList formalParameters) {
// TODO Auto-generated method stub
}
@Override
public void visit(FormalParameter formalParameter) {
// TODO Auto-generated method stub
}
@Override
public void visit(Block block) {
// TODO Auto-generated method stub
throw new NotImplementedException();
}
@Override
public void visit(Return aReturn) {
// TODO Auto-generated method stub
throw new NotImplementedException();
}
@Override
public void visit(ExpressionReceiver expressionReceiver) {
// TODO Auto-generated method stub
this.aThis = classOrInterface;
classOrInterface.getMethods().forEach(m -> m.accept(this));
}
@Override
public void visit(LocalVar localVar) {
// keine neuen Constraints
// keine neuen Constraints. Typisierung bereits im SyntaxTree vorhanden.
}
@Override
public void visit(FieldVar fieldVar) {
fieldVar.receiver.accept(this);
CheckTypeVisitor fieldTypeVisitor = new CheckTypeVisitor();
fieldVar.getType().accept(fieldTypeVisitor);
//TODO check ty in Ass && rty f in fields(ty)
if(!fieldTypeVisitor.isTypeVariable()){} // keine neuen Constraints
// Löst Typen zwischen Feld und Feldvariable auf
this.inferFieldVarTypes(fieldVar);
// Ermittelt den Typ ty von fieldVar.receiver und fields(f)
TypeExtract fieldTypeVisitor = new TypeExtract();
fieldVar.receiver.getType().accept(fieldTypeVisitor);
if (!fieldTypeVisitor.isTypeVariable()) {
fieldTypeVisitor.getField(fieldVar.fieldVarName).ifPresent(
f -> this.inferredTypes.put((TypePlaceholder) fieldVar.receiver.getType(), (RefType) f.getType()));
} // keine neuen Constraints
else {
FieldConstraint fieldConstraint = new FieldConstraint(fieldVar.receiver.getType(), fieldVar.getType(), fieldVar.fieldVarName);
FieldConstraint fieldConstraint = new FieldConstraint(fieldVar.receiver.getType(), fieldVar.fieldVarName,
fieldVar.getType());
this.constraints.addConstraint(fieldConstraint);
}
}
private void inferFieldVarTypes(FieldVar fieldVar) {
if (fieldVar.receiver instanceof This) {
this.aThis.getFieldDecl().stream().filter(f -> f.getName().equals(fieldVar.fieldVarName))
// keine statische Polymorphie zugelassen
.findFirst()
.ifPresent(f -> this.inferredTypes.put((TypePlaceholder) fieldVar.getType(), f.getType()));
}
}
@Override
public void visit(MethodCall methodCall) {
// TODO Auto-generated method stub
methodCall.receiver.accept(this);
methodCall.arglist.accept(this);
// ermittelt den Typ ty0 von methodCall.receiver und mtype(m, ty0)
TypeExtract methodTypeVisitor = new TypeExtract();
methodCall.receiver.getType().accept(methodTypeVisitor);
List<Expression> arguments = methodCall.getArgumentList().getArguments();
if (!methodTypeVisitor.isTypeVariable()) {
methodTypeVisitor.getMethod(methodCall.name, arguments.size()).ifPresent(m -> {
for (int i = 0; i < arguments.size(); i++) {
this.constraints.addConstraint(new SubTypeConstraint(arguments.get(i).getType(),
m.getParameterList().getParameterAt(i).getType()));
}
this.inferredTypes.put((TypePlaceholder) methodCall.getType(), (RefType) m.getReturnType());
});
} else {
MethodConstraint methodConstraint = new MethodConstraint(methodCall.receiver.getType(), methodCall.name,
new ArrayList<SubTypeConstraint>(), methodCall.getType());
arguments.forEach(e -> methodConstraint.addArguments(e.getType()));
this.constraints.addConstraint(methodConstraint);
}
}
@Override
public void visit(ArgumentList argumentList) {
// TODO Auto-generated method stub
argumentList.getArguments().forEach(a -> a.accept(this));
}
@Override
public void visit(CastExpr castExpr) {
// TODO Auto-generated method stub
castExpr.expr.accept(this);
// TODO RefType equals implementieren
if (((RefType) castExpr.getType()).getName().equals(this.aThis.getClassName())) {
// keine neuen Constraints
} else {
// TODO implement generics
}
}
@Override
public void visit(NewClass newClass) {
// TODO Auto-generated method stub
newClass.getArgumentList().accept(this);
RefType type = (RefType) newClass.getType();
TypeExtract typeExtract = new TypeExtract();
// TODO RefType equals implementieren
if (type.getName().equals(this.aThis.getType().getName())) {
this.aThis.accept(typeExtract);
} else {
type.accept(typeExtract);
// TODO implement generics
}
this.createNewClassSubTypeConstraints(newClass, typeExtract);
}
@Override
public void visit(RefType refType) {
// TODO Auto-generated method stub
private void createNewClassSubTypeConstraints(NewClass newClass, TypeExtract typeExtract) {
List<Expression> arguments = newClass.getArgumentList().getArguments();
List<Field> fields = typeExtract.getFields();
int argumentsSize = arguments.size();
int fieldsSize = fields.size();
if (argumentsSize != fieldsSize) {
throw new IllegalArgumentException(String.format(
"The number of fields (%d) in %s doesn't match the number of arguments (%d) passed to its constructor.",
fieldsSize, newClass.name, argumentsSize));
}
for (int i = 0; i < argumentsSize; i++) {
SubTypeConstraint subTypeConstraint = new SubTypeConstraint(arguments.get(i).getType(),
fields.get(i).getType());
this.constraints.addConstraint(subTypeConstraint);
}
@Override
public void visit(TypePlaceholder typePlaceholder) {
// TODO Auto-generated method stub
}
@Override
public void visit(This aThis) {
// TODO Auto-generated method stub
if (this.aThis != null) {
this.inferredTypes.put((TypePlaceholder) aThis.getType(), (RefType) this.aThis.getType());
}
}
@Override
public void visit(ExpressionReceiver expressionReceiver) {
expressionReceiver.expr.accept(this);
}
@Override
public void visit(Method method) {
method.block.accept(this);
}
@Override
public void visit(Block block) {
// Es gibt nur ein Statement: Return
block.getStatements().forEach(s -> s.accept(this));
}
@Override
public void visit(Return aReturn) {
aReturn.retexpr.accept(this);
}
}

5
src/de/dhbwstuttgart/strucTypes/TypeAssumptions.java
View File

@ -1,5 +0,0 @@
package de.dhbwstuttgart.strucTypes;
public class TypeAssumptions {
}

98
src/de/dhbwstuttgart/strucTypes/TypeExtract.java Normal file
View File

@ -0,0 +1,98 @@
package de.dhbwstuttgart.strucTypes;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import de.dhbwstuttgart.parser.scope.JavaClassName;
import de.dhbwstuttgart.syntaxtree.ClassOrInterface;
import de.dhbwstuttgart.syntaxtree.Constructor;
import de.dhbwstuttgart.syntaxtree.Field;
import de.dhbwstuttgart.syntaxtree.Method;
import de.dhbwstuttgart.syntaxtree.type.RefType;
import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
/**
* Extrahiert die typisierten Felder und Methoden von ClassOrInterface bzw. von
* RefType rekursiv über alle Superklassen und implementierten Interfaces.
*
* @author mvr
*
*/
public class TypeExtract extends DefaultASTVisitor {
private List<Field> fields = new ArrayList<>();
private List<Method> methods = new ArrayList<>();
private List<Constructor> constructors = new ArrayList<>();
private boolean typeVariable = false;
private boolean initialClass = true;
public List<Field> getFields() {
return this.fields;
}
public List<Method> getMethods() {
return this.methods;
}
public List<Constructor> getConstructors() {
return constructors;
}
public Optional<Field> getField(String fieldName) {
return this.fields.stream().filter(f -> f.getName().equals(fieldName))
// keine statische Polymorphie zugelassen
.findFirst();
}
public Optional<Method> getMethod(String methodName, int parameterCount) {
return this.methods.stream()
.filter(m -> m.getName().equals(methodName) && m.getParameterList().getFormalparalist().size() == parameterCount)
// keine statische Polymorphie zugelassen
.findFirst();
}
public boolean isTypeVariable() {
return this.typeVariable;
}
@Override
public void visit(ClassOrInterface classOrInterface) {
classOrInterface.getFieldDecl().forEach(f -> f.accept(this));
classOrInterface.getMethods().forEach(m -> m.accept(this));
classOrInterface.getConstructors().forEach(c -> {if(c != null && this.initialClass) c.accept(this);});
this.initialClass = false;
// superClass(Object) -> Object => unendliche Rekursionstiefe!
if (!classOrInterface.getClassName().equals(new JavaClassName("java.lang.Object"))) {
classOrInterface.getSuperClass().accept(this);
classOrInterface.implementedInterfaces.forEach(i -> i.accept(this));
}
}
@Override
public void visit(RefType refType) {
this.typeVariable = false;
ClassOrInterfaceFactory.createClass(refType).ifPresent(c -> c.accept(this));
}
@Override
public void visit(Field field) {
this.fields.add(field);
}
@Override
public void visit(Method method) {
this.methods.add(method);
}
@Override
public void visit(TypePlaceholder typePlaceholder) {
this.typeVariable = true;
}
@Override
public void visit(Constructor constructor) {
this.constructors.add(constructor);
}
}

8
src/de/dhbwstuttgart/strucTypes/ConstraintsSet.java → src/de/dhbwstuttgart/strucTypes/constraint/ConstraintsSet.java
View File

@ -1,4 +1,4 @@
package de.dhbwstuttgart.strucTypes;
package de.dhbwstuttgart.strucTypes.constraint;
import java.util.ArrayList;
import java.util.List;
@ -39,6 +39,12 @@ public class ConstraintsSet {
this.methodConstraints.add(constraint);
}
public void addConstraintsSet(ConstraintsSet constraintsSet){
constraintsSet.getSubTypeConstraints().forEach(this::addConstraint);
constraintsSet.getFieldConstraints().forEach(this::addConstraint);
constraintsSet.getMethodConstraints().forEach(this::addConstraint);
}
}

19
src/de/dhbwstuttgart/strucTypes/FieldConstraint.java → src/de/dhbwstuttgart/strucTypes/constraint/FieldConstraint.java
View File

@ -1,18 +1,24 @@
package de.dhbwstuttgart.strucTypes;
package de.dhbwstuttgart.strucTypes.constraint;
import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
/**
* fc(c, f, c') : Klasse/Typ c hat ein Feld f mit Typ c'
*
* @author mvr
*
*/
public class FieldConstraint {
private RefTypeOrTPHOrWildcardOrGeneric classType;
private RefTypeOrTPHOrWildcardOrGeneric fieldType;
private String fieldName;
private RefTypeOrTPHOrWildcardOrGeneric fieldType;
public FieldConstraint(RefTypeOrTPHOrWildcardOrGeneric classType, RefTypeOrTPHOrWildcardOrGeneric fieldType,
String fieldName) {
public FieldConstraint(RefTypeOrTPHOrWildcardOrGeneric classType, String fieldName,
RefTypeOrTPHOrWildcardOrGeneric fieldType) {
this.classType = classType;
this.fieldType = fieldType;
this.fieldName = fieldName;
this.fieldType = fieldType;
}
public RefTypeOrTPHOrWildcardOrGeneric getClassType() {
@ -27,7 +33,4 @@ public class FieldConstraint {
return fieldName;
}
}

18
src/de/dhbwstuttgart/strucTypes/MethodConstraint.java → src/de/dhbwstuttgart/strucTypes/constraint/MethodConstraint.java
View File

@ -1,4 +1,4 @@
package de.dhbwstuttgart.strucTypes;
package de.dhbwstuttgart.strucTypes.constraint;
import java.util.List;
@ -7,6 +7,13 @@ import org.antlr.v4.runtime.Token;
import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
/**
* mc(c, m, C, (c', C')) : Klasse/Typ c hat Methode m mit Argumenten von Typ C
* mit Rückgabewert c' und Subtyp-Constraints C <. C' wobei C = {c1,... , cn)
*
* @author mvr
*
*/
public class MethodConstraint {
private RefTypeOrTPHOrWildcardOrGeneric classType;
@ -14,8 +21,8 @@ public class MethodConstraint {
private String methodName;
private List<SubTypeConstraint> arguments;
public MethodConstraint(RefTypeOrTPHOrWildcardOrGeneric classType, RefTypeOrTPHOrWildcardOrGeneric returnType,
String methodName, List<SubTypeConstraint> arguments) {
public MethodConstraint(RefTypeOrTPHOrWildcardOrGeneric classType, String methodName,
List<SubTypeConstraint> arguments, RefTypeOrTPHOrWildcardOrGeneric returnType) {
this.classType = classType;
this.returnType = returnType;
this.methodName = methodName;
@ -38,13 +45,13 @@ public class MethodConstraint {
return arguments;
}
public void addArgument(SubTypeConstraint... subTypeConstraints){
public void addArguments(SubTypeConstraint... subTypeConstraints) {
for (SubTypeConstraint subTypeConstraint : subTypeConstraints) {
this.arguments.add(subTypeConstraint);
}
}
public void addArgument(RefTypeOrTPHOrWildcardOrGeneric... parameters){
public void addArguments(RefTypeOrTPHOrWildcardOrGeneric... parameters) {
for (RefTypeOrTPHOrWildcardOrGeneric parameter : parameters) {
Token offset = parameter.getOffset();
TypePlaceholder tph = TypePlaceholder.fresh(offset);
@ -53,5 +60,4 @@ public class MethodConstraint {
}
}
}

11
src/de/dhbwstuttgart/strucTypes/SubTypeConstraint.java → src/de/dhbwstuttgart/strucTypes/constraint/SubTypeConstraint.java
View File

@ -1,7 +1,13 @@
package de.dhbwstuttgart.strucTypes;
package de.dhbwstuttgart.strucTypes.constraint;
import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
/**
* c <. c' : c ist subtyp von c'
*
* @author mvr
*
*/
public class SubTypeConstraint {
private RefTypeOrTPHOrWildcardOrGeneric subtype;
@ -11,12 +17,13 @@ public class SubTypeConstraint {
this.subtype = subtype;
this.supertype = supertype;
}
public RefTypeOrTPHOrWildcardOrGeneric getSubtype() {
return subtype;
}
public RefTypeOrTPHOrWildcardOrGeneric getSupertype() {
return supertype;
}
}

42
src/de/dhbwstuttgart/strucTypes/printutils/PrintConstraints.java Normal file
View File

@ -0,0 +1,42 @@
package de.dhbwstuttgart.strucTypes.printutils;
import java.util.List;
import de.dhbwstuttgart.strucTypes.constraint.ConstraintsSet;
import de.dhbwstuttgart.strucTypes.constraint.FieldConstraint;
import de.dhbwstuttgart.strucTypes.constraint.MethodConstraint;
import de.dhbwstuttgart.strucTypes.constraint.SubTypeConstraint;
public class PrintConstraints {
public static void print(ConstraintsSet constraintsSet){
printSubTypeConstraints(constraintsSet.getSubTypeConstraints());
printFieldConstraints(constraintsSet.getFieldConstraints());
printMethodConstraints(constraintsSet.getMethodConstraints());
}
public static void printSubTypeConstraints(List<SubTypeConstraint> constraints) {
System.out.println("\n SubTypeConstraints:");
constraints.forEach(c-> System.out.println(c.getSubtype() + " < " + c.getSupertype()));
}
public static void printFieldConstraints(List<FieldConstraint> constraints){
System.out.println("\n FieldConstraints:");
constraints.forEach(c -> System.out.println(String.format("F(%s,%s,%s)", c.getClassType() , c.getFieldName() , c.getFieldType())));
}
public static void printMethodConstraints(List<MethodConstraint> constraints){
System.out.println("\n MethodConstraints:");
constraints.forEach(c-> {
StringBuilder sb = new StringBuilder("M(");
sb.append(c.getClassType() + ",");
sb.append(c.getMethodName() + ",[");
c.getArguments().forEach(a -> sb.append(a.getSubtype() + ","));
sb.append("],(" + c.getReturnType() + ",[");
c.getArguments().forEach(a-> sb.append(a.getSupertype() + ","));
sb.append("]))");
System.out.println(sb.toString());
});
}
}

14
src/de/dhbwstuttgart/strucTypes/printutils/PrintInferredTypes.java Normal file
View File

@ -0,0 +1,14 @@
package de.dhbwstuttgart.strucTypes.printutils;
import java.util.Map;
import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
public class PrintInferredTypes {
public static void print(Map<TypePlaceholder, RefTypeOrTPHOrWildcardOrGeneric> inferredTypes){
System.out.println("\n Inferred Types:");
inferredTypes.keySet().forEach(key -> System.out.println(key + " <=> " + inferredTypes.get(key)));
}
}

19
src/de/dhbwstuttgart/strucTypes/SyntaxTreePrinter.java → src/de/dhbwstuttgart/strucTypes/printutils/SyntaxTreePrinter.java
View File

@ -1,4 +1,4 @@
package de.dhbwstuttgart.strucTypes;
package de.dhbwstuttgart.strucTypes.printutils;
import java.util.List;
@ -66,16 +66,18 @@ public class SyntaxTreePrinter implements ASTVisitor {
@Override
public void visit(ClassOrInterface classOrInterface) {
JavaClassName className = classOrInterface.getClassName();
RefTypeOrTPHOrWildcardOrGeneric type = classOrInterface.getType();
List<Field> fields = classOrInterface.getFieldDecl();
List<Method> methods = classOrInterface.getMethods();
RefType superClass = classOrInterface.getSuperClass();
List<? extends RefTypeOrTPHOrWildcardOrGeneric> implementedInterfaces = classOrInterface.implementedInterfaces;
System.out.println("class: " + className);
System.out.print("class: " + className + " : ");
type.accept(this);
fields.forEach(f->f.accept(this));
methods.forEach(m->m.accept(this));
System.out.print("superClass: ");
System.out.print("\n superClass: ");
superClass.accept(this);
System.out.println("implemented Interfaces: ");
System.out.println("\n implemented Interfaces: ");
implementedInterfaces.forEach(i -> i.accept(this));
}
@ -94,7 +96,7 @@ public class SyntaxTreePrinter implements ASTVisitor {
String name = method.getName();
RefTypeOrTPHOrWildcardOrGeneric returnType = method.getReturnType();
ParameterList parameterList = method.getParameterList();
System.out.print("method: " + name + " : ");
System.out.print("\n method: " + name + " : ");
returnType.accept(this);
parameterList.accept(this);
method.block.accept(this);
@ -199,7 +201,7 @@ public class SyntaxTreePrinter implements ASTVisitor {
public void visit(This aThis) {
ArgumentList arglist = aThis.arglist;
RefTypeOrTPHOrWildcardOrGeneric type = aThis.getType();
System.out.print("this: " + " : ");
System.out.print("this : ");
type.accept(this);
if( arglist != null) arglist.accept(this);
}
@ -208,7 +210,10 @@ public class SyntaxTreePrinter implements ASTVisitor {
public void visit(RefType refType) {
JavaClassName name = refType.getName();
System.out.println(name);
if(!refType.getParaList().isEmpty()){
System.out.println(" generics: ");
refType.getParaList().forEach(p->p.accept(this));
}
}
@Override

49
test/strucType/TestStrucType.java Normal file
View File

@ -0,0 +1,49 @@
package strucType;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Map;
import de.dhbwstuttgart.core.JavaTXCompiler;
import de.dhbwstuttgart.strucTypes.StrucTYPE;
import de.dhbwstuttgart.strucTypes.constraint.ConstraintsSet;
import de.dhbwstuttgart.strucTypes.printutils.PrintConstraints;
import de.dhbwstuttgart.strucTypes.printutils.PrintInferredTypes;
import de.dhbwstuttgart.strucTypes.printutils.SyntaxTreePrinter;
import de.dhbwstuttgart.syntaxtree.SourceFile;
import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
public class TestStrucType {
public static final String rootDirectory = System.getProperty("user.dir") + "/test/strucType/javFiles/";
@org.junit.Test
public void test() throws ClassNotFoundException, IOException {
ArrayList<File> files = new ArrayList<>();
// files.add(new File(rootDirectory + "testLocalVar.jav"));
// files.add(new File(rootDirectory + "testCast.jav"));
files.add(new File(rootDirectory + "testNew.jav"));
// files.add(new File(rootDirectory + "testFieldVar.jav"));
// files.add(new File(rootDirectory + "testFieldMethod.jav"));
// files.add(new File(rootDirectory + "testPaperExample.jav"));
JavaTXCompiler compiler = new JavaTXCompiler(files);
for (File f : compiler.sourceFiles.keySet()) {
String name = f.getName();
System.out.println("Filename: " + name);
SourceFile sourceFile = compiler.sourceFiles.get(f);
//Print SourceFile Infos
sourceFile.accept(new SyntaxTreePrinter());
StrucTYPE strucTYPE = new StrucTYPE(sourceFile);
ConstraintsSet constraints = strucTYPE.getConstraints();
PrintConstraints.print(constraints);
Map<TypePlaceholder, RefTypeOrTPHOrWildcardOrGeneric> inferredTypes = strucTYPE.getInferredTypes();
PrintInferredTypes.print(inferredTypes);
System.out.println("____________________________________________________________________________");
}
}
}

2
test/strucType/TestSyntaxTreePrinter.java
View File

@ -8,7 +8,7 @@ import java.util.ArrayList;
import de.dhbwstuttgart.core.JavaTXCompiler;
import de.dhbwstuttgart.strucTypes.SyntaxTreePrinter;
import de.dhbwstuttgart.strucTypes.printutils.SyntaxTreePrinter;
public class TestSyntaxTreePrinter {
public static final String rootDirectory = System.getProperty("user.dir")+"/test/strucType/javFiles/";

8
test/strucType/javFiles/testCast.jav
View File

@ -1,4 +1,10 @@
package strucType.input;
import strucType.typedtestclasses.A;
import strucType.typedtestclasses.A2;
import strucType.typedtestclasses.B;
class C
{
mC(x){return (Integer)x; }
mA(A x){return (A2)x; }
mB(c) { return (B)c; }
}

5
test/strucType/javFiles/testFieldMethod.jav
View File

@ -1,5 +1,10 @@
package strucType.input;
import java.lang.Integer;
class M
{
f;
mM(x, y) { return f.mF(x, y); }
mInt(Integer x) { return x.doubleValue(); }
}

2
test/strucType/javFiles/testFieldVar.jav
View File

@ -1,3 +1,5 @@
package strucType.input;
class F
{
f;

4
test/strucType/javFiles/testLocalVar.jav
View File

@ -1,6 +1,6 @@
import java.util.List;
package strucType.input;
class C1 implements List
class C
{
m(x) { return x; }
}

8
test/strucType/javFiles/testNew.jav
View File

@ -1,4 +1,10 @@
package strucType.input;
import strucType.typedtestclasses.A;
import strucType.typedtestclasses.B;
class N
{
mN(s) {return new String(s); }
a;
mA(){ return new A(a); }
mB(x){ return new B(x,a); }
}

2
test/strucType/javFiles/testPaperExample.jav
View File

@ -1,3 +1,5 @@
package strucType.input;
class A
{
mt(x, y, z) { return x.sub(y).add(z); }

19
test/strucType/typedtestclasses/A.java Normal file
View File

@ -0,0 +1,19 @@
package strucType.typedtestclasses;
public class A {
public A a;
public A(A a) {
this.a = a;
}
public A getA() {
return this.a;
}
public <E> B<E> getB(B<E> b) {
return b;
}
}

9
test/strucType/typedtestclasses/A2.java Normal file
View File

@ -0,0 +1,9 @@
package strucType.typedtestclasses;
public class A2 extends A {
public A2(A a) {
super(a);
}
}

20
test/strucType/typedtestclasses/B.java Normal file
View File

@ -0,0 +1,20 @@
package strucType.typedtestclasses;
public class B<E> {
public E e;
public A a;
public B(E e, A a) {
this.e = e;
this.a = a;
}
public E getGeneric(){
return this.e;
}
public A getInput(){
return this.a;
}
}

27
test/strucType/typedtestclasses/C.java Normal file
View File

@ -0,0 +1,27 @@
package strucType.typedtestclasses;
public class C<E,F> {
public E e;
public F f;
public C(E e, F f) {
this.e = e;
this.f = f;
}
public E getGeneric1(){
return this.e;
}
public F getGeneric2(){
return this.f;
}
public C<A, B<E>> convert(A a, B<E> b){
return new C<>(a,b);
}
}