Compare commits
23 Commits
Author | SHA1 | Date | |
---|---|---|---|
9dd6c1610a | |||
66bbf9d52d | |||
8bff427c5c | |||
fc6040da39 | |||
bd1cfe4e7a | |||
05e4968adb | |||
d64823ea30 | |||
3b8ef58222 | |||
0aa18c74ba | |||
726eb60eb3 | |||
afd3f32f23 | |||
3173cccefa | |||
e6c58d44c2 | |||
1be1bb83ca | |||
2c25e56a76 | |||
c272688b2d | |||
cf6d9880e3 | |||
920eea43ad | |||
70ca62202d | |||
44481b4140 | |||
7a337843e6 | |||
fcca50ed78 | |||
5f31150dc8 |
.classpath
doc/Studienarbeiten
git_pull_origin_bigRefactoringsrc/de/dhbwstuttgart
core
parser
syntaxtree
ASTVisitor.javaAbstractASTWalker.javaClassOrInterface.javaField.javaFormalParameter.javaGTVDeclarationContext.javaGeneric.javaGenericDeclarationList.javaGenericTypeVar.javaMethod.javaParameterList.javaSourceFile.javaStatementVisitor.javaSyntaxTreeNode.java
factory
operator
AddOp.javaAndOp.javaDivideOp.javaEqualOp.javaGreaterEquOp.javaGreaterOp.javaLessEquOp.javaLessOp.javaLogOp.javaMinusOp.javaModuloOp.javaMulOp.javaNotEqualOp.javaOperator.javaOrOp.javaPlusOp.javaRelOp.javaTimesOp.java
statement
ArgumentList.javaBinary.javaExpression.javaInstVar.javaLambdaExpression.javaLocalVar.javaNewClass.javaThis.java
type
ExtendsWildcardType.javaFunN.javaGenericRefType.javaRefType.javaRefTypeOrTPHOrWildcardOrGeneric.javaSuperWildcardType.javaTypePlaceholder.java
visual
typecheck
typedeployment
typeinference
test
astfactory
javFiles
typeinference
11
.classpath
11
.classpath
@ -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>
|
||||
|
BIN
doc/Studienarbeiten/S2017_Jan-Elric_Neumann.pdf
Executable file
BIN
doc/Studienarbeiten/S2017_Jan-Elric_Neumann.pdf
Executable file
Binary file not shown.
0
git_pull_origin_bigRefactoring
Normal file
0
git_pull_origin_bigRefactoring
Normal file
@ -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",
|
||||
|
37
src/de/dhbwstuttgart/syntaxtree/ASTVisitor.java
Normal file
37
src/de/dhbwstuttgart/syntaxtree/ASTVisitor.java
Normal file
@ -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);
|
||||
}
|
145
src/de/dhbwstuttgart/syntaxtree/AbstractASTWalker.java
Normal file
145
src/de/dhbwstuttgart/syntaxtree/AbstractASTWalker.java
Normal file
@ -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);
|
||||
}
|
||||
}
|
||||
|
13
src/de/dhbwstuttgart/syntaxtree/visual/ASTPrinter.java
Normal file
13
src/de/dhbwstuttgart/syntaxtree/visual/ASTPrinter.java
Normal file
@ -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();
|
||||
}
|
||||
|
||||
}
|
20
src/de/dhbwstuttgart/syntaxtree/visual/ASTTypePrinter.java
Normal file
20
src/de/dhbwstuttgart/syntaxtree/visual/ASTTypePrinter.java
Normal file
@ -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();
|
||||
}
|
||||
|
||||
}
|
307
src/de/dhbwstuttgart/syntaxtree/visual/OutputGenerator.java
Normal file
307
src/de/dhbwstuttgart/syntaxtree/visual/OutputGenerator.java
Normal file
@ -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) {
|
||||
|
||||
}
|
||||
}
|
236
src/de/dhbwstuttgart/syntaxtree/visual/TypeOutputGenerator.java
Normal file
236
src/de/dhbwstuttgart/syntaxtree/visual/TypeOutputGenerator.java
Normal file
@ -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 = "%";
|
||||
|
31
src/de/dhbwstuttgart/typedeployment/TypeInsert.java
Normal file
31
src/de/dhbwstuttgart/typedeployment/TypeInsert.java
Normal file
@ -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
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
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);
|
||||
}
|
12
test/javFiles/mathStruc.jav
Normal file
12
test/javFiles/mathStruc.jav
Normal file
@ -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);
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
Reference in New Issue
Block a user