Compare commits
45 Commits
Author | SHA1 | Date | |
---|---|---|---|
998c146f4b | |||
88c78342d5 | |||
86b2118770 | |||
03080c43cb | |||
df1c19e60d | |||
07303ffa71 | |||
881830235a | |||
b88b9e2534 | |||
8e1c1765ff | |||
201a0978bc | |||
98331af3c0 | |||
a355fe7786 | |||
ea1e81bb95 | |||
b6f62b48eb | |||
5c66212afb | |||
7c3181c3f0 | |||
b251a646ca | |||
4b21f03a5a | |||
a7e1a5e2c2 | |||
932b277dcc | |||
45c85b7686 | |||
ff59b585bd | |||
397ac3cd58 | |||
77c59de0f0 | |||
9a7e717c25 | |||
6b98bf6a58 | |||
bbc61c67a9 | |||
1023ed8557 | |||
3274f12922 | |||
52f562b570 | |||
a9c49676a9 | |||
856f9b059d | |||
0cf8f82283 | |||
1e6f046eff | |||
841ac5fcbf | |||
3b95cdd76f | |||
057df7c702 | |||
86f29f1396 | |||
0f6381f30b | |||
adda1db195 | |||
2167a4288e | |||
0ad97251ca | |||
87d2edaaa6 | |||
a48cbae5a5 | |||
b395f6e137 |
.classpath
.idea/libraries
classes
doc
src
JavaCompilerCore1.iml
de
dhbwstuttgart
core
parser
syntaxtree
ASTVisitor.javaAbstractASTWalker.javaClassOrInterface.javaConstructor.javaMethod.javaSourceFile.javaStatementVisitor.javaSyntaxTreeNode.java
factory
statement
AssertStmt.javaAssign.javaAssignLeftSide.javaAssignToField.javaBreakStmt.javaCatchesStatement.javaContinueStmt.javaDoStmt.javaExpression.javaIfStmt.javaLambdaParameter.javaPostDecExpr.javaPostIncExpr.javaPreDecExpr.javaPreIncExpr.javaSuperCall.javaSwitchStmt.javaTypableStatement.javaWhileStmt.java
type
ExtendsWildcardType.javaGenericRefType.javaRefType.javaRefTypeOrTPHOrWildcardOrGeneric.javaSuperWildcardType.javaTypePlaceholder.javaWildcardType.java
visual
typecheck
typedeployment
typeinference
test
javFiles
parser
AssertTest.javBreakTest.javFeatherWeightJavaTest.javaFieldTest.javaIfTest.javPrePostOperationTest.javRunParserTest.javaSwitchTest.javTryCatchTest.javWhileTest.jav
test.imltypeinference
tools
@ -4,19 +4,18 @@
|
||||
<classpathentry kind="src" path="test"/>
|
||||
<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8"/>
|
||||
<classpathentry kind="lib" path="lib/bcel-6.1-SNAPSHOT.jar" sourcepath="lib/bcel-6.1-SNAPSHOT-sources.jar"/>
|
||||
<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="lib" path="lib/reflections-0.9.10.jar" sourcepath="/reflections/src"/>
|
||||
<classpathentry kind="lib" path="lib/guava-22.0.jar" sourcepath="lib/guava-22.0-sources.jar"/>
|
||||
<classpathentry kind="output" path="bin"/>
|
||||
</classpath>
|
||||
|
22
.idea/libraries/lib.xml
generated
Normal file
22
.idea/libraries/lib.xml
generated
Normal file
@ -0,0 +1,22 @@
|
||||
<component name="libraryTable">
|
||||
<library name="lib">
|
||||
<CLASSES>
|
||||
<root url="jar://$PROJECT_DIR$/lib/log4j-1.2.12.jar!/" />
|
||||
<root url="jar://$PROJECT_DIR$/lib/guava-10.0.1.jar!/" />
|
||||
<root url="jar://$PROJECT_DIR$/lib/bcel-6.1-SNAPSHOT.jar!/" />
|
||||
<root url="jar://$PROJECT_DIR$/lib/bcel-6.1-SNAPSHOT-sources.jar!/" />
|
||||
<root url="jar://$PROJECT_DIR$/lib/annotations-2.0.1.jar!/" />
|
||||
<root url="jar://$PROJECT_DIR$/lib/guava-15.0.jar!/" />
|
||||
<root url="jar://$PROJECT_DIR$/lib/junit-4.0.jar!/" />
|
||||
<root url="jar://$PROJECT_DIR$/lib/commons-bcel6-6.0-SNAPSHOT.jar!/" />
|
||||
<root url="jar://$PROJECT_DIR$/lib/reflections-0.9.10-javadoc.jar!/" />
|
||||
<root url="jar://$PROJECT_DIR$/lib/reflections-0.9.10.jar!/" />
|
||||
<root url="jar://$PROJECT_DIR$/lib/cloning.jar!/" />
|
||||
<root url="jar://$PROJECT_DIR$/lib/javassist-3.19.0-GA.jar!/" />
|
||||
<root url="jar://$PROJECT_DIR$/lib/reflections-0.9.10-sources.jar!/" />
|
||||
<root url="jar://$PROJECT_DIR$/lib/antlr-complete.jar!/" />
|
||||
</CLASSES>
|
||||
<JAVADOC />
|
||||
<SOURCES />
|
||||
</library>
|
||||
</component>
|
9
classes/classes.iml
Normal file
9
classes/classes.iml
Normal file
@ -0,0 +1,9 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<module type="WEB_MODULE" version="4">
|
||||
<component name="NewModuleRootManager" inherit-compiler-output="true">
|
||||
<exclude-output />
|
||||
<content url="file://$MODULE_DIR$" />
|
||||
<orderEntry type="inheritedJdk" />
|
||||
<orderEntry type="sourceFolder" forTests="false" />
|
||||
</component>
|
||||
</module>
|
@ -100,7 +100,7 @@ var activeTableTab = "activeTableTab";
|
||||
<li>java.lang.Object</li>
|
||||
<li>
|
||||
<ul class="inheritance">
|
||||
<li>de.dhbwstuttgart.typeinference.ResultSet</li>
|
||||
<li>de.dhbwstuttgart.typeinference.result.ResultSet</li>
|
||||
</ul>
|
||||
</li>
|
||||
</ul>
|
||||
|
@ -3,7 +3,7 @@
|
||||
<html lang="de">
|
||||
<head>
|
||||
<!-- Generated by javadoc (1.8.0_05) on Tue May 12 19:56:24 CEST 2015 -->
|
||||
<title>Uses of Class de.dhbwstuttgart.typeinference.ResultSet</title>
|
||||
<title>Uses of Class de.dhbwstuttgart.typeinference.result.ResultSet</title>
|
||||
<meta name="date" content="2015-05-12">
|
||||
<link rel="stylesheet" type="text/css" href="../../../../stylesheet.css" title="Style">
|
||||
<script type="text/javascript" src="../../../../script.js"></script>
|
||||
@ -70,7 +70,7 @@
|
||||
</a></div>
|
||||
<!-- ========= END OF TOP NAVBAR ========= -->
|
||||
<div class="header">
|
||||
<h2 title="Uses of Class de.dhbwstuttgart.typeinference.ResultSet" class="title">Uses of Class<br>de.dhbwstuttgart.typeinference.ResultSet</h2>
|
||||
<h2 title="Uses of Class de.dhbwstuttgart.typeinference.result.ResultSet" class="title">Uses of Class<br>de.dhbwstuttgart.typeinference.ResultSet</h2>
|
||||
</div>
|
||||
<div class="classUseContainer">
|
||||
<ul class="blockList">
|
||||
|
BIN
doc/Studienarbeiten/S2017_Jan-Elric_Neumann.pdf
Executable file
BIN
doc/Studienarbeiten/S2017_Jan-Elric_Neumann.pdf
Executable file
Binary file not shown.
9
doc/doc.iml
Normal file
9
doc/doc.iml
Normal file
@ -0,0 +1,9 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<module type="WEB_MODULE" version="4">
|
||||
<component name="NewModuleRootManager" inherit-compiler-output="true">
|
||||
<exclude-output />
|
||||
<content url="file://$MODULE_DIR$" />
|
||||
<orderEntry type="inheritedJdk" />
|
||||
<orderEntry type="sourceFolder" forTests="false" />
|
||||
</component>
|
||||
</module>
|
11
src/JavaCompilerCore1.iml
Normal file
11
src/JavaCompilerCore1.iml
Normal file
@ -0,0 +1,11 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<module type="JAVA_MODULE" version="4">
|
||||
<component name="NewModuleRootManager" inherit-compiler-output="true">
|
||||
<exclude-output />
|
||||
<content url="file://$MODULE_DIR$">
|
||||
<sourceFolder url="file://$MODULE_DIR$" isTestSource="false" />
|
||||
</content>
|
||||
<orderEntry type="inheritedJdk" />
|
||||
<orderEntry type="sourceFolder" forTests="false" />
|
||||
</component>
|
||||
</module>
|
@ -1,8 +1,5 @@
|
||||
package de.dhbwstuttgart.core;
|
||||
|
||||
|
||||
import de.dhbwstuttgart.parser.ClassNotFoundException;
|
||||
|
||||
import java.io.File;
|
||||
import java.io.IOException;
|
||||
import java.util.*;
|
||||
|
@ -1,54 +1,35 @@
|
||||
package de.dhbwstuttgart.core;
|
||||
|
||||
import de.dhbwstuttgart.exceptions.DebugException;
|
||||
import de.dhbwstuttgart.parser.ClassNotFoundException;
|
||||
import de.dhbwstuttgart.parser.JavaTXParser;
|
||||
import de.dhbwstuttgart.syntaxtree.ClassOrInterface;
|
||||
import de.dhbwstuttgart.syntaxtree.SourceFile;
|
||||
import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode;
|
||||
import de.dhbwstuttgart.syntaxtree.factory.UnifyTypeFactory;
|
||||
import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
|
||||
import de.dhbwstuttgart.typedeployment.TypeInsert;
|
||||
import de.dhbwstuttgart.typedeployment.TypeInsertFactory;
|
||||
import de.dhbwstuttgart.typedeployment.TypeInsertPoint;
|
||||
import de.dhbwstuttgart.typeinference.ResultSet;
|
||||
import de.dhbwstuttgart.typeinference.constraints.Constraint;
|
||||
import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
|
||||
import de.dhbwstuttgart.typeinference.constraints.Pair;
|
||||
import de.dhbwstuttgart.typeinference.result.ResultSet;
|
||||
import de.dhbwstuttgart.typeinference.typeAlgo.TYPE;
|
||||
import de.dhbwstuttgart.typeinference.unify.TypeUnify;
|
||||
import de.dhbwstuttgart.typeinference.unify.interfaces.IFiniteClosure;
|
||||
import de.dhbwstuttgart.typeinference.unify.model.FiniteClosure;
|
||||
import de.dhbwstuttgart.typeinference.unify.model.UnifyPair;
|
||||
import de.dhbwstuttgart.typeinference.unify.model.UnifyType;
|
||||
|
||||
import java.io.File;
|
||||
import java.io.IOException;
|
||||
import java.util.*;
|
||||
import java.util.stream.Collectors;
|
||||
|
||||
public class JavaTXCompiler {
|
||||
|
||||
protected List<SourceFile> sourceFiles = new ArrayList<>();
|
||||
|
||||
public List<TypeInsert> getTypeInserts(File forFile){
|
||||
ResultSet result = typeInference();
|
||||
for(SourceFile sf : sourceFiles){
|
||||
if(sf.getFile().equals(forFile)){
|
||||
return TypeInsertFactory.createTypeInsertPoints(sf, result);
|
||||
}
|
||||
}
|
||||
throw new DebugException("Die Datei "+forFile+" wurde nicht geparst");
|
||||
}
|
||||
|
||||
public ResultSet typeInference(){
|
||||
ConstraintSet<Pair> cons = new ConstraintSet<>();
|
||||
public List<ResultSet> typeInference(){
|
||||
List<ClassOrInterface> allClasses = new ArrayList<>();
|
||||
for(SourceFile sf : sourceFiles){
|
||||
allClasses.addAll(sf.getClasses());
|
||||
}
|
||||
FiniteClosure finiteClosure = UnifyTypeFactory.generateFC(allClasses);
|
||||
for(SourceFile sf : sourceFiles){
|
||||
cons.addAll(sf.getConstraints(sf.getTypeInferenceInformation(sourceFiles)));
|
||||
}
|
||||
final ConstraintSet<Pair> cons = new TYPE(sourceFiles).getConstraints();
|
||||
ConstraintSet<UnifyPair> unifyCons = UnifyTypeFactory.convert(cons);
|
||||
|
||||
TypeUnify unify = new TypeUnify();
|
||||
@ -64,9 +45,9 @@ public class JavaTXCompiler {
|
||||
System.out.println("RESULT: " + result);
|
||||
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())));
|
||||
}
|
||||
return results.stream().map((unifyPairs ->
|
||||
new ResultSet(UnifyTypeFactory.convert(unifyPairs, generateTPHMap(cons))))).collect(Collectors.toList());
|
||||
}
|
||||
|
||||
private Map<String, TypePlaceholder> generateTPHMap(ConstraintSet<Pair> constraints){
|
||||
HashMap<String, TypePlaceholder> ret = new HashMap<>();
|
||||
@ -82,8 +63,16 @@ public class JavaTXCompiler {
|
||||
return ret;
|
||||
}
|
||||
|
||||
public void parse(File sourceFile) throws IOException, ClassNotFoundException {
|
||||
sourceFiles.add(new JavaTXParser().parse(sourceFile));
|
||||
public SourceFile parse(File sourceFile) throws IOException, java.lang.ClassNotFoundException {
|
||||
SourceFile ret = new JavaTXParser().parse(sourceFile);
|
||||
sourceFiles.add(ret);
|
||||
return ret;
|
||||
}
|
||||
|
||||
public SourceFile parse(String source) throws IOException, java.lang.ClassNotFoundException {
|
||||
SourceFile ret = new JavaTXParser().parse(source);
|
||||
sourceFiles.add(ret);
|
||||
return ret;
|
||||
}
|
||||
|
||||
}
|
||||
|
@ -1,4 +0,0 @@
|
||||
package de.dhbwstuttgart.parser;
|
||||
public class ClassNotFoundException extends Exception{
|
||||
|
||||
}
|
@ -9,31 +9,30 @@ import org.antlr.v4.runtime.ANTLRInputStream;
|
||||
import org.antlr.v4.runtime.CommonTokenStream;
|
||||
|
||||
import java.io.*;
|
||||
import java.nio.charset.StandardCharsets;
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
|
||||
public class JavaTXParser {
|
||||
public SourceFile parse(File sourceFile) throws IOException, ClassNotFoundException {
|
||||
InputStream stream = new FileInputStream(sourceFile);
|
||||
public SourceFile parse(InputStream source) throws IOException, java.lang.ClassNotFoundException {
|
||||
InputStream stream = source;//new FileInputStream(sourceFile);
|
||||
ANTLRInputStream input = new ANTLRInputStream(stream);
|
||||
Java8Lexer lexer = new Java8Lexer(input);
|
||||
CommonTokenStream tokens = new CommonTokenStream(lexer);
|
||||
Java8Parser parser = new Java8Parser(tokens);
|
||||
Java8Parser.CompilationUnitContext tree = parser.compilationUnit();
|
||||
|
||||
SyntaxTreeGenerator generator = new SyntaxTreeGenerator(new JavaClassRegistry(generateJavaLangNames()));
|
||||
return generator.convert(tree, sourceFile);
|
||||
|
||||
JavaClassRegistry reg = new JavaClassRegistry(new ArrayList<>());
|
||||
reg.addPackage("java.lang");
|
||||
SyntaxTreeGenerator generator = new SyntaxTreeGenerator(reg);
|
||||
return generator.convert(tree);
|
||||
}
|
||||
|
||||
private List<String> generateJavaLangNames() throws IOException, ClassNotFoundException {
|
||||
List<String> ret = new ArrayList<>();
|
||||
public SourceFile parse(File file) throws IOException, java.lang.ClassNotFoundException {
|
||||
return this.parse(new FileInputStream(file));
|
||||
}
|
||||
|
||||
for(Class cl : PackageCrawler.getClassesInPackage("java.lang")){
|
||||
ret.add(cl.getName());
|
||||
}
|
||||
//TODO: Wieso muss man das händisch anhängen?
|
||||
ret.add("java.lang.Object");
|
||||
|
||||
return ret;
|
||||
public SourceFile parse(String fileContent) throws IOException, java.lang.ClassNotFoundException {
|
||||
return this.parse(new ByteArrayInputStream(fileContent.getBytes(StandardCharsets.UTF_8)));
|
||||
}
|
||||
}
|
||||
|
@ -1,48 +0,0 @@
|
||||
package de.dhbwstuttgart.parser;
|
||||
|
||||
import de.dhbwstuttgart.typecheck.JavaClassName;
|
||||
import org.reflections.Reflections;
|
||||
import org.reflections.scanners.ResourcesScanner;
|
||||
import org.reflections.scanners.SubTypesScanner;
|
||||
import org.reflections.util.ClasspathHelper;
|
||||
import org.reflections.util.ConfigurationBuilder;
|
||||
import org.reflections.util.FilterBuilder;
|
||||
|
||||
import java.util.LinkedList;
|
||||
import java.util.List;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Set;
|
||||
import java.lang.InterruptedException;
|
||||
/**
|
||||
* Hilft beim Durchsuchen von Packages
|
||||
* Benutzt die Reflections-Library (https://github.com/ronmamo/reflections)
|
||||
* Hilfe dazu: http://stackoverflow.com/a/9571146
|
||||
*/
|
||||
public class PackageCrawler {
|
||||
|
||||
public static Set<Class<?>> getClassesInPackage(String packageName){
|
||||
List<ClassLoader> classLoadersList = new LinkedList<ClassLoader>();
|
||||
classLoadersList.add(Thread.currentThread().getContextClassLoader());
|
||||
classLoadersList.add(ClasspathHelper.staticClassLoader());
|
||||
classLoadersList.add(Thread.currentThread().getContextClassLoader().getParent());
|
||||
|
||||
Reflections reflections = new Reflections(new ConfigurationBuilder()
|
||||
.setScanners(new SubTypesScanner(false /* don't exclude Object.class */), new ResourcesScanner())
|
||||
.setUrls(ClasspathHelper.forClassLoader(classLoadersList.toArray(new ClassLoader[0])))
|
||||
.filterInputsBy(new FilterBuilder().include(FilterBuilder.prefix(packageName))));
|
||||
|
||||
Set<Class<?>> classes = reflections.getSubTypesOf(Object.class);
|
||||
|
||||
return classes;
|
||||
}
|
||||
|
||||
// Returns a list of JavaClassNames.
|
||||
public static List<JavaClassName> getClassNames(String packageName){
|
||||
List<JavaClassName> nameList = new ArrayList();
|
||||
Set<Class<?>> classes = getClassesInPackage(packageName);
|
||||
for(Class c : classes){
|
||||
nameList.add(new JavaClassName(c.getName()));
|
||||
}
|
||||
return nameList;
|
||||
}
|
||||
}
|
@ -1,57 +0,0 @@
|
||||
package de.dhbwstuttgart.parser;
|
||||
import de.dhbwstuttgart.parser.SyntaxTreeGenerator.SyntaxTreeGenerator;
|
||||
import de.dhbwstuttgart.parser.antlr.Java8Lexer;
|
||||
import de.dhbwstuttgart.parser.antlr.Java8Parser;
|
||||
import de.dhbwstuttgart.typecheck.JavaClassName;
|
||||
import de.dhbwstuttgart.typecheck.JavaClassRegistry;
|
||||
import org.antlr.v4.runtime.ANTLRInputStream;
|
||||
import org.antlr.v4.runtime.CommonTokenStream;
|
||||
import de.dhbwstuttgart.syntaxtree.*;
|
||||
|
||||
import java.lang.reflect.Modifier;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Scanner;
|
||||
import java.io.File;
|
||||
import java.io.FileNotFoundException;
|
||||
import java.io.ByteArrayInputStream;
|
||||
import java.io.InputStream;
|
||||
import java.io.IOException;
|
||||
import java.nio.charset.StandardCharsets;
|
||||
public class RunTXParser{
|
||||
public static void main(String[] args){
|
||||
try{
|
||||
JavaTXParser parser = new JavaTXParser();
|
||||
SourceFile f = parser.parse(new File(args[0]));
|
||||
String pkgName = f.getPkgName();
|
||||
System.out.println("package: " + pkgName);
|
||||
System.out.println("Imports:");
|
||||
for(JavaClassName c : f.getImports()){
|
||||
System.out.println(c.toString());
|
||||
}
|
||||
System.out.println("classes:");
|
||||
for(ClassOrInterface c : f.getClasses()){
|
||||
int mod = c.getModifiers();
|
||||
System.out.println(Modifier.toString(mod));
|
||||
System.out.println(c.getClassName().toString());
|
||||
System.out.println("{");
|
||||
for(Field field : c.getFieldDecl()){
|
||||
System.out.println(field.getName());
|
||||
}
|
||||
System.out.println("}");
|
||||
}
|
||||
}
|
||||
catch(java.util.NoSuchElementException e){
|
||||
System.out.println("Error: Source seems to be empty.");
|
||||
}
|
||||
catch(ClassNotFoundException e){
|
||||
System.out.println("Class not found.");
|
||||
}
|
||||
catch(FileNotFoundException e){
|
||||
System.out.println("File not found.");
|
||||
}
|
||||
catch(IOException e){
|
||||
System.out.println("An exception occured which is on our TODO list.");
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
}
|
@ -0,0 +1,20 @@
|
||||
package de.dhbwstuttgart.parser.SyntaxTreeGenerator;
|
||||
|
||||
import de.dhbwstuttgart.syntaxtree.StatementVisitor;
|
||||
import de.dhbwstuttgart.syntaxtree.statement.AssignLeftSide;
|
||||
import de.dhbwstuttgart.syntaxtree.statement.Expression;
|
||||
import de.dhbwstuttgart.syntaxtree.statement.LocalVar;
|
||||
|
||||
public class AssignToLocal extends AssignLeftSide {
|
||||
public final LocalVar localVar;
|
||||
|
||||
public AssignToLocal(LocalVar leftSide) {
|
||||
super(leftSide.getType(), leftSide.getOffset());
|
||||
localVar = leftSide;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void accept(StatementVisitor visitor) {
|
||||
visitor.visit(this);
|
||||
}
|
||||
}
|
@ -1,5 +1,6 @@
|
||||
package de.dhbwstuttgart.parser.SyntaxTreeGenerator;
|
||||
|
||||
import com.sun.javafx.fxml.expression.UnaryExpression;
|
||||
import de.dhbwstuttgart.exceptions.NotImplementedException;
|
||||
import de.dhbwstuttgart.parser.NullToken;
|
||||
import de.dhbwstuttgart.parser.antlr.Java8Parser;
|
||||
@ -9,12 +10,11 @@ import de.dhbwstuttgart.syntaxtree.statement.literal.*;
|
||||
import de.dhbwstuttgart.syntaxtree.type.RefType;
|
||||
import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
|
||||
import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
|
||||
import de.dhbwstuttgart.typecheck.JavaClassName;
|
||||
import de.dhbwstuttgart.syntaxtree.type.Void;
|
||||
import de.dhbwstuttgart.typecheck.JavaClassRegistry;
|
||||
import org.antlr.v4.runtime.Token;
|
||||
import org.antlr.v4.runtime.tree.TerminalNode;
|
||||
|
||||
import java.lang.reflect.Modifier;
|
||||
import java.util.*;
|
||||
|
||||
public class StatementGenerator {
|
||||
@ -267,64 +267,78 @@ public class StatementGenerator {
|
||||
//TODO
|
||||
throw new NotImplementedException();
|
||||
}
|
||||
|
||||
//TODO Felix_K
|
||||
private Statement convert(Java8Parser.PreIncrementExpressionContext stmt) {
|
||||
//TODO
|
||||
throw new NotImplementedException();
|
||||
return new PreIncExpr(convert(stmt.unaryExpression()),stmt.getStart());
|
||||
}
|
||||
|
||||
//TODO Felix_K
|
||||
private Statement convert(Java8Parser.PreDecrementExpressionContext stmt) {
|
||||
//TODO
|
||||
throw new NotImplementedException();
|
||||
return new PreDecExpr(convert(stmt.unaryExpression()),stmt.getStart());
|
||||
}
|
||||
|
||||
//TODO Felix_K
|
||||
private Statement convert(Java8Parser.PostIncrementExpressionContext stmt) {
|
||||
//TODO
|
||||
throw new NotImplementedException();
|
||||
return new PostIncExpr(convert(stmt.postfixExpression()));
|
||||
}
|
||||
|
||||
//TODO Felix_K
|
||||
private Statement convert(Java8Parser.PostDecrementExpressionContext stmt) {
|
||||
//TODO
|
||||
throw new NotImplementedException();
|
||||
return new PostDecExpr(convert(stmt.postfixExpression()));
|
||||
}
|
||||
|
||||
private Statement convert(Java8Parser.AssignmentContext stmt) {
|
||||
Expression leftHandSide = convert(stmt.leftHandSide());
|
||||
AssignLeftSide leftHandSide = convert(stmt.leftHandSide());
|
||||
return new Assign(leftHandSide, convert(stmt.expression()), stmt.getStart());
|
||||
}
|
||||
|
||||
private Expression convert(Java8Parser.LeftHandSideContext leftHandSide) {
|
||||
return generateLocalOrFieldVarOrClassName(leftHandSide.getText(), leftHandSide.getStart());
|
||||
private AssignLeftSide convert(Java8Parser.LeftHandSideContext leftHandSide) {
|
||||
Expression leftSide = generateLocalOrFieldVarOrClassName(leftHandSide.getText(), leftHandSide.getStart());
|
||||
if(leftSide instanceof FieldVar)return new AssignToField((FieldVar) leftSide);
|
||||
else if (leftSide instanceof LocalVar)return new AssignToLocal((LocalVar) leftSide);
|
||||
else throw new NotImplementedException();
|
||||
}
|
||||
|
||||
//TODO Felix_K
|
||||
private Statement convert(Java8Parser.IfThenStatementContext stmt){
|
||||
//TODO
|
||||
throw new NotImplementedException();
|
||||
Expression expr = convert(stmt.expression());
|
||||
Statement thenBlock = convert(stmt.statement());
|
||||
Statement elseBlock = new EmptyStmt(stmt.getStart());
|
||||
return new IfStmt(TypePlaceholder.fresh(stmt.getStart()),expr,thenBlock,elseBlock,stmt.getStart());
|
||||
}
|
||||
|
||||
//TODO Felix_K
|
||||
private Statement convert(Java8Parser.IfThenElseStatementContext stmt){
|
||||
//TODO
|
||||
throw new NotImplementedException();
|
||||
Expression expr = convert(stmt.expression());
|
||||
Statement thenBlock = convert(stmt.statementNoShortIf());
|
||||
Statement elseBlock = convert(stmt.statement());
|
||||
return new IfStmt(TypePlaceholder.fresh(stmt.getStart()),expr,thenBlock,elseBlock,stmt.getStart());
|
||||
}
|
||||
|
||||
//TODO Felix_K
|
||||
private Statement convert(Java8Parser.IfThenElseStatementNoShortIfContext stmt){
|
||||
//TODO
|
||||
throw new NotImplementedException();
|
||||
Expression expr = convert(stmt.expression());
|
||||
Statement thenBlock = convert(stmt.statementNoShortIf().get(0));
|
||||
Statement elseBlock = convert(stmt.statementNoShortIf().get(1));
|
||||
return new IfStmt(TypePlaceholder.fresh(stmt.getStart()),expr,thenBlock,elseBlock,stmt.getStart());
|
||||
}
|
||||
|
||||
private Statement convert(Java8Parser.AssertStatementContext stmt){
|
||||
//TODO
|
||||
throw new NotImplementedException();
|
||||
//TODO Felix_K
|
||||
private Statement convert(Java8Parser.AssertStatementContext stmt)
|
||||
{
|
||||
List<Expression> exprList= new ArrayList<Expression>();
|
||||
for (int i =0; i<stmt.expression().size();i++){
|
||||
exprList.add(convert(stmt.expression(i)));
|
||||
}
|
||||
return new AssertStmt(TypePlaceholder.fresh(stmt.getStart()),exprList,stmt.getStart());
|
||||
}
|
||||
|
||||
//TODO Felix_K
|
||||
private Statement convert(Java8Parser.SwitchStatementContext stmt){
|
||||
//TODO
|
||||
throw new NotImplementedException();
|
||||
Expression expr = convert(stmt.expression());
|
||||
List<Statement> statementList = new ArrayList<Statement>();
|
||||
statementList.add( convert(stmt.switchBlock()));
|
||||
statementList.add(new BreakStmt(TypePlaceholder.fresh(stmt.getStart()),"",stmt.getStart()));
|
||||
Block block = new Block(statementList, stmt.getStart());
|
||||
return new SwitchStmt(TypePlaceholder.fresh(stmt.getStart()),expr,block,stmt.getStart());
|
||||
|
||||
}
|
||||
|
||||
private Statement convert(Java8Parser.SwitchBlockContext stmt){
|
||||
//TODO
|
||||
throw new NotImplementedException();
|
||||
throw new NotImplementedException();
|
||||
}
|
||||
|
||||
private Statement convert(Java8Parser.SwitchBlockStatementGroupContext stmt){
|
||||
@ -333,18 +347,21 @@ public class StatementGenerator {
|
||||
}
|
||||
|
||||
private Statement convert(Java8Parser.WhileStatementContext stmt){
|
||||
//TODO
|
||||
throw new NotImplementedException();
|
||||
Expression expr = convert(stmt.expression());
|
||||
Statement block = convert(stmt.statement());
|
||||
return new WhileStmt(expr, block,stmt.getStart());
|
||||
}
|
||||
|
||||
//TODO Felix_K
|
||||
private Statement convert(Java8Parser.WhileStatementNoShortIfContext stmt){
|
||||
//TODO
|
||||
throw new NotImplementedException();
|
||||
Expression expr = convert(stmt.expression());
|
||||
Statement block = convert(stmt.statementNoShortIf());
|
||||
return new WhileStmt(expr, block, stmt.getStart());
|
||||
}
|
||||
|
||||
//TODO Felix_K
|
||||
private Statement convert(Java8Parser.DoStatementContext stmt){
|
||||
//TODO
|
||||
throw new NotImplementedException();
|
||||
Statement block = convert(stmt.statement());
|
||||
Expression expr = convert(stmt.expression());
|
||||
return new DoStmt(expr,block,stmt.getStart());
|
||||
}
|
||||
|
||||
private Statement convert(Java8Parser.ForStatementContext stmt){
|
||||
@ -362,15 +379,43 @@ public class StatementGenerator {
|
||||
return convert(stmt.enhancedForStatementNoShortIf());
|
||||
}else throw new NotImplementedException();
|
||||
}
|
||||
|
||||
//TODO Felix_K
|
||||
private Statement convert(Java8Parser.BasicForStatementContext stmt){
|
||||
//TODO
|
||||
throw new NotImplementedException();
|
||||
List<Statement> stateList = new ArrayList<>();
|
||||
List<Statement> whileList = new ArrayList<>();
|
||||
if (stmt.forInit().localVariableDeclaration()==null)
|
||||
{
|
||||
whileList.addAll(convert(stmt.forInit().localVariableDeclaration()));
|
||||
}
|
||||
else
|
||||
{
|
||||
whileList.add(convert(stmt.forInit().statementExpressionList()));
|
||||
}
|
||||
Expression expr = convert(stmt.expression());
|
||||
stateList.add(convert(stmt.statement()));
|
||||
stateList.add(convert(stmt.forUpdate()));
|
||||
Block forBlock = new Block(stateList,stmt.getStart());
|
||||
whileList.add(new WhileStmt(expr,forBlock,stmt.getStart()));
|
||||
return new Block(whileList,stmt.getStart());
|
||||
}
|
||||
|
||||
//TODO Felix_K
|
||||
private Statement convert(Java8Parser.BasicForStatementNoShortIfContext stmt){
|
||||
//TODO
|
||||
throw new NotImplementedException();
|
||||
List<Statement> stateList = new ArrayList<>();
|
||||
List<Statement> whileList = new ArrayList<>();
|
||||
if (stmt.forInit().localVariableDeclaration()==null)
|
||||
{
|
||||
whileList.addAll(convert(stmt.forInit().localVariableDeclaration()));
|
||||
}
|
||||
else
|
||||
{
|
||||
whileList.add(convert(stmt.forInit().statementExpressionList()));
|
||||
}
|
||||
Expression expr = convert(stmt.expression());
|
||||
stateList.add(convert(stmt.statementNoShortIf()));
|
||||
stateList.add(convert(stmt.forUpdate()));
|
||||
Block forBlock = new Block(stateList,stmt.getStart());
|
||||
whileList.add(new WhileStmt(expr,forBlock,stmt.getStart()));
|
||||
return new Block(whileList,stmt.getStart());
|
||||
}
|
||||
|
||||
private List<Statement> convert(Java8Parser.ForInitContext stmt){
|
||||
@ -380,7 +425,7 @@ public class StatementGenerator {
|
||||
return convert(stmt.localVariableDeclaration());
|
||||
}else throw new NotImplementedException();
|
||||
}
|
||||
|
||||
//TODO Felix_K
|
||||
private List<Statement> convert(Java8Parser.LocalVariableDeclarationContext declaration) {
|
||||
List<Statement> ret = new ArrayList<>();
|
||||
if(declaration.variableModifier() != null && declaration.variableModifier().size() > 0){
|
||||
@ -393,7 +438,13 @@ public class StatementGenerator {
|
||||
}else{
|
||||
type = TypeGenerator.convert(declaration.unannTypeOrAuto().unannType(), reg, generics);
|
||||
}
|
||||
for(Java8Parser.VariableDeclaratorContext varDecl : declaration.variableDeclaratorList().variableDeclarator()){
|
||||
ret.addAll(generateLocalVariableAssignments(declaration.variableDeclaratorList().variableDeclarator(), type));
|
||||
return ret;
|
||||
}
|
||||
|
||||
private List<Statement> generateLocalVariableAssignments(List<Java8Parser.VariableDeclaratorContext> varDeclarators, RefTypeOrTPHOrWildcardOrGeneric type){
|
||||
List<Statement> ret = new ArrayList<>();
|
||||
for(Java8Parser.VariableDeclaratorContext varDecl : varDeclarators){
|
||||
TerminalNode name = varDecl.variableDeclaratorId().Identifier();
|
||||
|
||||
ret.add(new LocalVarDecl(name.getText(), type, name.getSymbol()));
|
||||
@ -405,12 +456,27 @@ public class StatementGenerator {
|
||||
}else{
|
||||
initValue = convert(varDecl.variableInitializer().expression());
|
||||
}
|
||||
ret.add(new Assign(new LocalVar(name.getText(), type, name.getSymbol()), initValue, name.getSymbol()));
|
||||
ret.add(new Assign(new AssignToLocal(new LocalVar(name.getText(), type, name.getSymbol()))
|
||||
, initValue, name.getSymbol()));
|
||||
}
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
public Statement generateFieldAssignment(Java8Parser.VariableDeclaratorContext varDecl, RefTypeOrTPHOrWildcardOrGeneric type){
|
||||
TerminalNode name = varDecl.variableDeclaratorId().Identifier();
|
||||
Expression initValue;
|
||||
if(varDecl.variableInitializer().arrayInitializer() != null){
|
||||
throw new NotImplementedException();
|
||||
}else{
|
||||
initValue = convert(varDecl.variableInitializer().expression());
|
||||
}
|
||||
return (new Assign(new AssignToField(
|
||||
new FieldVar(new This(varDecl.getStart()), name.getText(),
|
||||
new Void(varDecl.getStart()), varDecl.getStart())),
|
||||
initValue, name.getSymbol()));
|
||||
}
|
||||
|
||||
private Statement convert(Java8Parser.ForUpdateContext stmt){
|
||||
return convert(stmt.statementExpressionList());
|
||||
}
|
||||
@ -429,20 +495,30 @@ public class StatementGenerator {
|
||||
//TODO
|
||||
throw new NotImplementedException();
|
||||
}
|
||||
|
||||
//TODO Felix_K
|
||||
private Statement convert(Java8Parser.BreakStatementContext stmt){
|
||||
//TODO
|
||||
throw new NotImplementedException();
|
||||
if (stmt.Identifier()==null)
|
||||
{
|
||||
String indentifier = "";
|
||||
return new BreakStmt(TypePlaceholder.fresh(stmt.getStart()),indentifier,stmt.getStart());
|
||||
}
|
||||
return new BreakStmt(TypePlaceholder.fresh(stmt.getStart()),stmt.Identifier().getText(),stmt.getStart());
|
||||
}
|
||||
|
||||
//TODO Felix_K
|
||||
private Statement convert(Java8Parser.ContinueStatementContext stmt){
|
||||
//TODO
|
||||
throw new NotImplementedException();
|
||||
if (stmt.Identifier()==null){
|
||||
String indentifier = "";
|
||||
return new ContinueStmt(TypePlaceholder.fresh(stmt.getStart()),indentifier, stmt.getStart());
|
||||
}
|
||||
return new BreakStmt(TypePlaceholder.fresh(stmt.getStart()),stmt.Identifier().getText(),stmt.getStart());
|
||||
}
|
||||
|
||||
private Statement convert(Java8Parser.ReturnStatementContext stmt){
|
||||
return new Return(convert(stmt.expression()),stmt.getStart());
|
||||
//throw new NotImplementedException();
|
||||
if(stmt.expression() != null){
|
||||
return new Return( convert(stmt.expression()),stmt.getStart() );
|
||||
}else{
|
||||
return new ReturnVoid(stmt.getStart());
|
||||
}
|
||||
}
|
||||
|
||||
private Statement convert(Java8Parser.ThrowStatementContext stmt){
|
||||
@ -460,7 +536,8 @@ public class StatementGenerator {
|
||||
throw new NotImplementedException();
|
||||
}
|
||||
|
||||
private Statement convert(Java8Parser.CatchesContext stmt){
|
||||
private Statement convert(Java8Parser.CatchesContext stmt)
|
||||
{
|
||||
//TODO
|
||||
throw new NotImplementedException();
|
||||
}
|
||||
|
@ -12,10 +12,11 @@ public class SyntacticSugar {
|
||||
Statement lastStmt = statements.get(statements.size() - 1);
|
||||
if (lastStmt instanceof Return) return statements;
|
||||
if (lastStmt instanceof WhileStmt) {
|
||||
if (hasReturn(((WhileStmt) lastStmt).loop_block)) return statements;
|
||||
//TODO
|
||||
//if (hasReturn(((WhileStmt) lastStmt).loopBlock)) return statements;
|
||||
} else if (lastStmt instanceof IfStmt) {
|
||||
if (hasReturn(((IfStmt) lastStmt).then_block)
|
||||
&& hasReturn(((IfStmt) lastStmt).else_block)) return statements;
|
||||
//if (hasReturn(((IfStmt) lastStmt).then_block)
|
||||
//&& hasReturn(((IfStmt) lastStmt).else_block)) return statements;
|
||||
} else if (lastStmt instanceof ForStmt) {
|
||||
if (hasReturn(((ForStmt) lastStmt).body_Loop_block)) return statements;
|
||||
} else {
|
||||
|
@ -1,9 +1,8 @@
|
||||
package de.dhbwstuttgart.parser.SyntaxTreeGenerator;
|
||||
|
||||
import de.dhbwstuttgart.exceptions.NotImplementedException;
|
||||
import de.dhbwstuttgart.parser.ClassNotFoundException;
|
||||
import java.lang.ClassNotFoundException;
|
||||
import de.dhbwstuttgart.parser.NullToken;
|
||||
import de.dhbwstuttgart.parser.PackageCrawler;
|
||||
import de.dhbwstuttgart.parser.antlr.Java8Parser;
|
||||
import de.dhbwstuttgart.syntaxtree.*;
|
||||
import de.dhbwstuttgart.syntaxtree.factory.ASTFactory;
|
||||
@ -15,6 +14,7 @@ import de.dhbwstuttgart.typecheck.*;
|
||||
|
||||
import java.io.File;
|
||||
import java.lang.reflect.Modifier;
|
||||
import java.sql.Ref;
|
||||
import java.util.ArrayList;
|
||||
import java.util.HashMap;
|
||||
import java.util.List;
|
||||
@ -29,6 +29,8 @@ public class SyntaxTreeGenerator{
|
||||
private String pkgName = "";
|
||||
List<JavaClassName> imports = new ArrayList();
|
||||
|
||||
List<Statement> fieldInitializations = new ArrayList<>();
|
||||
|
||||
public SyntaxTreeGenerator(JavaClassRegistry reg){
|
||||
this.reg = reg;
|
||||
}
|
||||
@ -136,16 +138,10 @@ public class SyntaxTreeGenerator{
|
||||
|
||||
private JavaClassName convertSingleTypeImportDeclaration(Java8Parser.SingleTypeImportDeclarationContext ctx) throws ClassNotFoundException{
|
||||
String typeName = convertTypeName(ctx.typeName());
|
||||
String packageName = getPackageFromClass(typeName);
|
||||
List<JavaClassName> classes = PackageCrawler.getClassNames(packageName);
|
||||
reg.add(typeName);
|
||||
JavaClassName ret = reg.getName(typeName);
|
||||
if(classes.contains(ret)){
|
||||
return ret;
|
||||
}
|
||||
else{
|
||||
throw new ClassNotFoundException();
|
||||
}
|
||||
Thread.currentThread().getContextClassLoader().loadClass(typeName);
|
||||
reg.add(typeName);
|
||||
JavaClassName ret = reg.getName(typeName);
|
||||
return ret;
|
||||
}
|
||||
|
||||
private JavaClassName convertTypeImportOnDemandDeclaration(Java8Parser.TypeImportOnDemandDeclarationContext ctx){
|
||||
@ -170,7 +166,7 @@ public class SyntaxTreeGenerator{
|
||||
return ret;
|
||||
}
|
||||
|
||||
public SourceFile convert(Java8Parser.CompilationUnitContext ctx, File parsedFile) throws ClassNotFoundException{
|
||||
public SourceFile convert(Java8Parser.CompilationUnitContext ctx) throws ClassNotFoundException{
|
||||
List<ClassOrInterface> classes = new ArrayList<>();
|
||||
this.getNames(ctx);
|
||||
this.setImports(ctx);
|
||||
@ -184,30 +180,30 @@ public class SyntaxTreeGenerator{
|
||||
}
|
||||
classes.add(newClass);
|
||||
}
|
||||
return new SourceFile(parsedFile, this.pkgName, classes, this.imports);
|
||||
return new SourceFile(this.pkgName, classes, this.imports);
|
||||
}
|
||||
|
||||
public Method convert(Java8Parser.MethodDeclarationContext methodDeclarationContext, JavaClassName parentClass, GenericsRegistry generics) {
|
||||
public Method convert(Java8Parser.MethodDeclarationContext methodDeclarationContext, JavaClassName parentClass, RefType superClass, GenericsRegistry generics) {
|
||||
Java8Parser.MethodHeaderContext header = methodDeclarationContext.methodHeader();
|
||||
int modifiers = SyntaxTreeGenerator.convert(methodDeclarationContext.methodModifier());
|
||||
GenericsRegistry localGenerics = createGenerics(methodDeclarationContext.methodHeader().typeParameters(),
|
||||
parentClass, header.methodDeclarator().Identifier().getText());
|
||||
localGenerics.putAll(generics);
|
||||
return convert(modifiers, header, methodDeclarationContext.methodBody(),parentClass, localGenerics);
|
||||
return convert(modifiers, header, methodDeclarationContext.methodBody(),parentClass, superClass, localGenerics);
|
||||
}
|
||||
|
||||
public Method convert(Java8Parser.InterfaceMethodDeclarationContext ctx, JavaClassName parentClass, GenericsRegistry generics) {
|
||||
public Method convert(Java8Parser.InterfaceMethodDeclarationContext ctx, JavaClassName parentClass, RefType superClass, GenericsRegistry generics) {
|
||||
Java8Parser.MethodHeaderContext header = ctx.methodHeader();
|
||||
int modifiers = SyntaxTreeGenerator.convertInterfaceModifier(ctx.interfaceMethodModifier());
|
||||
|
||||
GenericsRegistry localGenerics = createGenerics(header.typeParameters(), parentClass, header.methodDeclarator().Identifier().getText());
|
||||
localGenerics.putAll(generics);
|
||||
|
||||
return convert(modifiers, header, ctx.methodBody(),parentClass, localGenerics);
|
||||
return convert(modifiers, header, ctx.methodBody(),parentClass, superClass, localGenerics);
|
||||
}
|
||||
|
||||
private Method convert(int modifiers, Java8Parser.MethodHeaderContext header, Java8Parser.MethodBodyContext body,
|
||||
JavaClassName parentClass, GenericsRegistry localGenerics) {
|
||||
JavaClassName parentClass, RefType superClass, GenericsRegistry localGenerics) {
|
||||
|
||||
StatementGenerator stmtGen = new StatementGenerator(reg, localGenerics, new HashMap<>());
|
||||
|
||||
@ -237,9 +233,7 @@ 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());
|
||||
return new Constructor(name, retType, modifiers, parameterList, block, gtvDeclarations, header.getStart(), fieldInitializations, superClass);
|
||||
}else{
|
||||
return new Method(name, retType, modifiers, parameterList,block, gtvDeclarations, header.getStart());
|
||||
}
|
||||
@ -273,8 +267,14 @@ public class SyntaxTreeGenerator{
|
||||
}else{
|
||||
genericClassParameters = TypeGenerator.convert(ctx.typeParameters(), name, "",reg, generics);
|
||||
}
|
||||
RefType superClass ;
|
||||
if(ctx.superclass() != null){
|
||||
superClass = convert(ctx.superclass());
|
||||
}else{
|
||||
superClass = ASTFactory.createObjectClass().getType();
|
||||
}
|
||||
List<Field> fielddecl = convertFields(ctx.classBody(), generics);
|
||||
List<Method> methods = convertMethods(ctx.classBody(), name, generics);
|
||||
List<Method> methods = convertMethods(ctx.classBody(), name, superClass, generics);
|
||||
List<Constructor> konstruktoren = new ArrayList<>();
|
||||
for(int i = 0; i<methods.size();i++){
|
||||
Method m = methods.get(i);
|
||||
@ -286,17 +286,11 @@ public class SyntaxTreeGenerator{
|
||||
if(konstruktoren.size()<1){//Standardkonstruktor anfügen:
|
||||
konstruktoren.add(
|
||||
generateStandardConstructor(
|
||||
ctx.Identifier().getText(),
|
||||
ctx.Identifier().getText(), name, superClass,
|
||||
genericClassParameters, offset)
|
||||
);
|
||||
}
|
||||
|
||||
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,
|
||||
@ -316,13 +310,12 @@ public class SyntaxTreeGenerator{
|
||||
return ret;
|
||||
}
|
||||
|
||||
private Constructor generateStandardConstructor(String className, GenericDeclarationList classGenerics, Token offset){
|
||||
private Constructor generateStandardConstructor(String className, JavaClassName parentClass, RefType superClass, GenericDeclarationList classGenerics, Token offset){
|
||||
RefType classType = ClassOrInterface.generateTypeOfClass(reg.getName(className), classGenerics, offset);
|
||||
int modifiers = 0;
|
||||
ParameterList params = new ParameterList(new ArrayList<>(), offset);
|
||||
//TODO: Konstruktor muss Felder initialisieren:
|
||||
Block block = new Block(new ArrayList<>(), offset);
|
||||
return new Constructor(className, classType, modifiers, params, block, classGenerics, offset);
|
||||
return new Constructor(className, classType, modifiers, params, block, classGenerics, offset, fieldInitializations, superClass);
|
||||
}
|
||||
|
||||
private RefType convert(Java8Parser.SuperclassContext superclass) {
|
||||
@ -330,7 +323,7 @@ public class SyntaxTreeGenerator{
|
||||
}
|
||||
|
||||
private List<Method> convertMethods(Java8Parser.ClassBodyContext classBodyContext,
|
||||
JavaClassName parentClass, GenericsRegistry generics) {
|
||||
JavaClassName parentClass, RefType superClass, GenericsRegistry generics) {
|
||||
List<Method> ret = new ArrayList<>();
|
||||
for(Java8Parser.ClassBodyDeclarationContext classMember : classBodyContext.classBodyDeclaration()){
|
||||
if(classMember.classMemberDeclaration() != null){
|
||||
@ -339,7 +332,7 @@ public class SyntaxTreeGenerator{
|
||||
//Do nothing!
|
||||
}else if(classMemberDeclarationContext.methodDeclaration()!= null){
|
||||
|
||||
ret.add(this.convert(classMemberDeclarationContext.methodDeclaration(), parentClass, generics));
|
||||
ret.add(this.convert(classMemberDeclarationContext.methodDeclaration(), parentClass, superClass, generics));
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -392,7 +385,7 @@ public class SyntaxTreeGenerator{
|
||||
for(Java8Parser.VariableDeclaratorContext varCtx : fieldDeclarationContext.variableDeclaratorList().variableDeclarator()){
|
||||
String fieldName = convert(varCtx.variableDeclaratorId());
|
||||
if(varCtx.variableInitializer() != null){
|
||||
initializeField(fieldDeclarationContext);
|
||||
initializeField(varCtx, fieldType, generics);
|
||||
}
|
||||
else{
|
||||
ret.add(new Field(fieldName,fieldType,modifiers,varCtx.getStart()));
|
||||
@ -406,9 +399,9 @@ public class SyntaxTreeGenerator{
|
||||
}
|
||||
|
||||
// Initialize a field by creating implicit constructor.
|
||||
private void initializeField(Java8Parser.FieldDeclarationContext ctx){
|
||||
//TODO
|
||||
throw new NotImplementedException();
|
||||
private void initializeField(Java8Parser.VariableDeclaratorContext ctx, RefTypeOrTPHOrWildcardOrGeneric typeOfField, GenericsRegistry generics){
|
||||
StatementGenerator statementGenerator = new StatementGenerator(reg, generics, new HashMap<>());
|
||||
fieldInitializations.add(statementGenerator.generateFieldAssignment(ctx, typeOfField));
|
||||
}
|
||||
|
||||
public static int convertModifier(String modifier){
|
||||
@ -471,15 +464,16 @@ public class SyntaxTreeGenerator{
|
||||
|
||||
GenericsRegistry generics = createGenerics(ctx.typeParameters(), name, "");
|
||||
|
||||
List<Field> fields = convertFields(ctx.interfaceBody());
|
||||
List<Method> methods = convertMethods(ctx.interfaceBody(), name, 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();
|
||||
RefType superClass = ASTFactory.createObjectClass().getType();
|
||||
|
||||
List<Field> fields = convertFields(ctx.interfaceBody());
|
||||
List<Method> methods = convertMethods(ctx.interfaceBody(), name, superClass, generics);
|
||||
|
||||
List<RefTypeOrTPHOrWildcardOrGeneric> extendedInterfaces = convert(ctx.extendsInterfaces(), generics);
|
||||
|
||||
@ -509,11 +503,11 @@ public class SyntaxTreeGenerator{
|
||||
}
|
||||
|
||||
private List<Method> convertMethods(Java8Parser.InterfaceBodyContext interfaceBodyContext,
|
||||
JavaClassName parentClass, GenericsRegistry generics) {
|
||||
JavaClassName parentClass, RefType superClass, GenericsRegistry generics) {
|
||||
List<Method> ret = new ArrayList<>();
|
||||
for(Java8Parser.InterfaceMemberDeclarationContext member : interfaceBodyContext.interfaceMemberDeclaration()){
|
||||
if(member.interfaceMethodDeclaration() != null){
|
||||
ret.add(this.convert(member.interfaceMethodDeclaration(), parentClass, generics));
|
||||
ret.add(this.convert(member.interfaceMethodDeclaration(), parentClass, superClass, generics));
|
||||
//new Method(name, type, modifier, params, null, genericDecls, member.interfaceMethodDeclaration().getStart());
|
||||
}else{
|
||||
throw new NotImplementedException();
|
||||
|
@ -18,6 +18,7 @@ import de.dhbwstuttgart.typecheck.JavaClassRegistry;
|
||||
import org.antlr.v4.runtime.Token;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Arrays;
|
||||
import java.util.List;
|
||||
|
||||
public class TypeGenerator {
|
||||
@ -53,7 +54,8 @@ public class TypeGenerator {
|
||||
return TypeGenerator.convert(unannTypeContext.unannReferenceType().unannClassOrInterfaceType(), reg, genericsRegistry);
|
||||
}
|
||||
|
||||
public static GenericDeclarationList convert(Java8Parser.TypeParametersContext typeParametersContext, JavaClassName parentClass, String parentMethod, JavaClassRegistry reg, GenericsRegistry generics) {
|
||||
public static GenericDeclarationList convert(Java8Parser.TypeParametersContext typeParametersContext,
|
||||
JavaClassName parentClass, String parentMethod, JavaClassRegistry reg, GenericsRegistry generics) {
|
||||
Token endOffset = typeParametersContext.getStop();
|
||||
List<GenericTypeVar> typeVars = new ArrayList<>();
|
||||
for(Java8Parser.TypeParameterContext typeParameter : typeParametersContext.typeParameterList().typeParameter()){
|
||||
@ -75,7 +77,7 @@ public class TypeGenerator {
|
||||
public static List<RefTypeOrTPHOrWildcardOrGeneric> convert(Java8Parser.TypeBoundContext typeBoundContext, JavaClassRegistry reg, GenericsRegistry generics) {
|
||||
if(typeBoundContext == null){
|
||||
List<RefTypeOrTPHOrWildcardOrGeneric> ret = new ArrayList<>();
|
||||
ret.add(new ASTFactory(reg).createObjectClass().getType());
|
||||
ret.add(ASTFactory.createObjectClass().getType());
|
||||
return ret;
|
||||
}
|
||||
|
||||
@ -92,7 +94,7 @@ public class TypeGenerator {
|
||||
|
||||
public static RefTypeOrTPHOrWildcardOrGeneric convertTypeName(
|
||||
String name, Java8Parser.TypeArgumentsContext typeArguments, Token offset, JavaClassRegistry reg, GenericsRegistry generics){
|
||||
if(!reg.contains(name)){ //Dann könnte es ein Generische Type sein:
|
||||
if(!reg.contains(name)){ //Dann könnte es ein Generische Type sein
|
||||
if(generics.keySet().contains(name)){
|
||||
return new GenericRefType(new GenericTypeName(generics.get(name),name), offset);
|
||||
}else{
|
||||
|
@ -4,13 +4,12 @@ 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 de.dhbwstuttgart.typeinference.constraints.Constraint;
|
||||
|
||||
public interface ASTVisitor extends StatementVisitor{
|
||||
|
||||
void visit(SourceFile sourceFile);
|
||||
|
||||
void visit(ArgumentList argumentList);
|
||||
|
||||
void visit(GenericTypeVar genericTypeVar);
|
||||
|
||||
void visit(FormalParameter formalParameter);
|
||||
@ -21,6 +20,8 @@ public interface ASTVisitor extends StatementVisitor{
|
||||
|
||||
void visit(Method field);
|
||||
|
||||
void visit(Constructor field);
|
||||
|
||||
void visit(ParameterList formalParameters);
|
||||
|
||||
void visit(ClassOrInterface classOrInterface);
|
||||
@ -34,4 +35,6 @@ public interface ASTVisitor extends StatementVisitor{
|
||||
void visit(ExtendsWildcardType extendsWildcardType);
|
||||
|
||||
void visit(GenericRefType genericRefType);
|
||||
|
||||
void visit(BreakStmt breakStmt);
|
||||
}
|
||||
|
@ -1,5 +1,7 @@
|
||||
package de.dhbwstuttgart.syntaxtree;
|
||||
|
||||
import de.dhbwstuttgart.exceptions.NotImplementedException;
|
||||
import de.dhbwstuttgart.parser.SyntaxTreeGenerator.AssignToLocal;
|
||||
import de.dhbwstuttgart.syntaxtree.statement.*;
|
||||
import de.dhbwstuttgart.syntaxtree.statement.literal.Literal;
|
||||
import de.dhbwstuttgart.syntaxtree.statement.literal.Null;
|
||||
@ -9,6 +11,10 @@ import java.lang.reflect.Modifier;
|
||||
import java.util.Iterator;
|
||||
|
||||
public abstract class AbstractASTWalker implements ASTVisitor{
|
||||
@Override
|
||||
public void visit(Constructor cons) {
|
||||
visitMethod(cons);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(SourceFile sourceFile) {
|
||||
@ -24,6 +30,11 @@ public abstract class AbstractASTWalker implements ASTVisitor{
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(GenericTypeVar genericTypeVar) {
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(FormalParameter formalParameter) {
|
||||
formalParameter.getType().accept(this);
|
||||
@ -46,9 +57,14 @@ public abstract class AbstractASTWalker implements ASTVisitor{
|
||||
|
||||
@Override
|
||||
public void visit(Method method) {
|
||||
visitMethod(method);
|
||||
}
|
||||
|
||||
private void visitMethod(Method method){
|
||||
method.getType().accept(this);
|
||||
method.getParameterList().accept(this);
|
||||
method.block.accept(this);
|
||||
if(method.block != null)
|
||||
method.block.accept(this);
|
||||
}
|
||||
|
||||
@Override
|
||||
@ -87,11 +103,21 @@ public abstract class AbstractASTWalker implements ASTVisitor{
|
||||
superWildcardType.getInnerType().accept(this);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(TypePlaceholder typePlaceholder) {
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(ExtendsWildcardType extendsWildcardType) {
|
||||
extendsWildcardType.getInnerType().accept(this);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(GenericRefType genericRefType) {
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(LambdaExpression lambdaExpression) {
|
||||
lambdaExpression.params.accept(this);
|
||||
@ -104,6 +130,11 @@ public abstract class AbstractASTWalker implements ASTVisitor{
|
||||
assign.rightSide.accept(this);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(Binary binary) {
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(Block block) {
|
||||
for(Statement stmt : block.getStatements()){
|
||||
@ -111,11 +142,41 @@ public abstract class AbstractASTWalker implements ASTVisitor{
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(CastExpr castExpr) {
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(EmptyStmt emptyStmt) {
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(FieldVar fieldVar) {
|
||||
fieldVar.receiver.accept(this);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(ForStmt forStmt) {
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(IfStmt ifStmt) {
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(InstanceOf instanceOf) {
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(LocalVar localVar) {
|
||||
|
||||
}
|
||||
|
||||
|
||||
@Override
|
||||
public void visit(LocalVarDecl localVarDecl) {
|
||||
@ -133,6 +194,11 @@ public abstract class AbstractASTWalker implements ASTVisitor{
|
||||
visit((MethodCall) methodCall);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(NewArray newArray) {
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(Receiver receiver) {
|
||||
receiver.expr.accept(this);
|
||||
@ -142,4 +208,68 @@ public abstract class AbstractASTWalker implements ASTVisitor{
|
||||
public void visit(Return aReturn) {
|
||||
aReturn.retexpr.accept(this);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(ReturnVoid aReturn) {
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(StaticClassName staticClassName) {
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(Super aSuper) {
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(This aThis) {
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(UnaryPlus unaryPlus) {
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(WhileStmt whileStmt) {
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(DoStmt whileStmt) {
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(Null aNull) {
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(Literal literal) {
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(AssignToField assignLeftSide) {
|
||||
assignLeftSide.field.accept(this);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(AssignToLocal assignLeftSide) {
|
||||
assignLeftSide.localVar.accept(this);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(SuperCall superCall) {
|
||||
this.visit((MethodCall)superCall);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(BreakStmt breakStmt) {
|
||||
}
|
||||
}
|
||||
|
@ -58,14 +58,6 @@ public class ClassOrInterface extends SyntaxTreeNode {
|
||||
return this.methods;
|
||||
}
|
||||
|
||||
public ConstraintSet getConstraints(TypeInferenceInformation info) {
|
||||
ConstraintSet ret = new ConstraintSet();
|
||||
for(Method m : this.getMethods()){
|
||||
ret.addAll(m.getConstraints(info, this));
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
public RefType getType() {
|
||||
return generateTypeOfClass(this.getClassName(), this.getGenerics(), this.getOffset());
|
||||
}
|
||||
@ -82,7 +74,7 @@ public class ClassOrInterface extends SyntaxTreeNode {
|
||||
return this.genericClassParameters;
|
||||
}
|
||||
|
||||
public List<? extends Method> getConstructors() {
|
||||
public List<Constructor> getConstructors() {
|
||||
return constructors;
|
||||
}
|
||||
|
||||
|
@ -1,14 +1,38 @@
|
||||
package de.dhbwstuttgart.syntaxtree;
|
||||
|
||||
import de.dhbwstuttgart.syntaxtree.statement.Statement;
|
||||
import de.dhbwstuttgart.syntaxtree.statement.SuperCall;
|
||||
import de.dhbwstuttgart.syntaxtree.type.RefType;
|
||||
import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
|
||||
import org.antlr.v4.runtime.Token;
|
||||
|
||||
import de.dhbwstuttgart.syntaxtree.statement.Block;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
public class Constructor extends Method {
|
||||
|
||||
|
||||
public Constructor(String name, RefTypeOrTPHOrWildcardOrGeneric returnType, int modifiers, ParameterList parameterList, Block block, GenericDeclarationList gtvDeclarations, Token offset) {
|
||||
super(name, returnType, modifiers, parameterList, block, gtvDeclarations, offset);
|
||||
//TODO: Constructor braucht ein super-Statement
|
||||
public Constructor(String name, RefTypeOrTPHOrWildcardOrGeneric returnType, int modifiers, ParameterList parameterList, Block codeInsideConstructor,
|
||||
GenericDeclarationList gtvDeclarations, Token offset, List<Statement> fieldInitializations, RefType superClass) {
|
||||
super(name, returnType, modifiers, parameterList, prepareBlock(codeInsideConstructor,fieldInitializations, superClass), gtvDeclarations, offset);
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
* @param fieldInitializations - Das sind die Statements,
|
||||
* welche die Felder der zugehörigen Klasse dieses
|
||||
* Konstruktor initialisieren
|
||||
*/
|
||||
protected static Block prepareBlock(Block constructorBlock, List<Statement> fieldInitializations, RefType superClass){
|
||||
List<Statement> statements = constructorBlock.getStatements();
|
||||
statements.add(0, new SuperCall(constructorBlock.getOffset()));
|
||||
return new Block(statements, constructorBlock.getOffset());
|
||||
}
|
||||
|
||||
@Override
|
||||
public void accept(ASTVisitor visitor) {
|
||||
visitor.visit(this);
|
||||
}
|
||||
}
|
||||
|
@ -8,6 +8,7 @@ import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceBlockInformation;
|
||||
import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
|
||||
import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceInformation;
|
||||
import de.dhbwstuttgart.typeinference.typeAlgo.TYPE;
|
||||
import de.dhbwstuttgart.typeinference.typeAlgo.TYPEStmt;
|
||||
import org.antlr.v4.runtime.Token;
|
||||
|
||||
import de.dhbwstuttgart.core.IItemWithOffset;
|
||||
@ -36,14 +37,6 @@ public class Method extends Field implements IItemWithOffset, TypeScope
|
||||
this.generics = gtvDeclarations;
|
||||
}
|
||||
|
||||
public ConstraintSet getConstraints(TypeInferenceInformation info, ClassOrInterface currentClass) {
|
||||
if(block == null)return new ConstraintSet(); //Abstrakte Methoden generieren keine Constraints
|
||||
TypeInferenceBlockInformation blockInfo = new TypeInferenceBlockInformation(info.getAvailableClasses(), currentClass, this);
|
||||
TYPE methodScope = new TYPE(blockInfo);
|
||||
block.accept(methodScope);
|
||||
return methodScope.getConstraints();
|
||||
}
|
||||
|
||||
public ParameterList getParameterList() {
|
||||
return parameterlist;
|
||||
}
|
||||
|
@ -13,20 +13,18 @@ import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceInformation;
|
||||
public class SourceFile extends SyntaxTreeNode{
|
||||
private String pkgName;
|
||||
|
||||
private final List<ClassOrInterface> KlassenVektor;
|
||||
private final List<JavaClassName> imports;
|
||||
private final File file;
|
||||
public final List<ClassOrInterface> KlassenVektor;
|
||||
public final List<JavaClassName> imports;
|
||||
|
||||
/**
|
||||
* Die SourceFile repräsntiert eine zu einem Syntaxbaum eingelesene Java-Datei.
|
||||
* SourceFile stellt dabei den Wurzelknoten des Syntaxbaumes dar.
|
||||
*/
|
||||
public SourceFile(File file, String pkgName, List<ClassOrInterface> classDefinitions, List<JavaClassName> imports){
|
||||
public SourceFile(String pkgName, List<ClassOrInterface> classDefinitions, List<JavaClassName> imports){
|
||||
super(new NullToken());
|
||||
this.KlassenVektor = classDefinitions;
|
||||
this.pkgName = pkgName;
|
||||
this.imports = imports;
|
||||
this.file = file;
|
||||
}
|
||||
|
||||
public String getPkgName(){
|
||||
@ -38,31 +36,10 @@ public class SourceFile extends SyntaxTreeNode{
|
||||
return this.imports;
|
||||
}
|
||||
|
||||
public ConstraintSet getConstraints(TypeInferenceInformation info) {
|
||||
ConstraintSet ret = new ConstraintSet();
|
||||
for (ClassOrInterface cl : this.KlassenVektor) {
|
||||
ret.addAll(cl.getConstraints(info));
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
public TypeInferenceInformation getTypeInferenceInformation(List<SourceFile> sourceFiles){
|
||||
Set<ClassOrInterface> classes = new HashSet<>();
|
||||
for(SourceFile sourceFile : sourceFiles){
|
||||
classes.addAll(sourceFile.KlassenVektor);
|
||||
}
|
||||
|
||||
return new TypeInferenceInformation(classes);
|
||||
}
|
||||
|
||||
public List<ClassOrInterface> getClasses() {
|
||||
return KlassenVektor;
|
||||
}
|
||||
|
||||
public File getFile() {
|
||||
return file;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void accept(ASTVisitor visitor) {
|
||||
visitor.visit(this);
|
||||
|
@ -1,5 +1,6 @@
|
||||
package de.dhbwstuttgart.syntaxtree;
|
||||
|
||||
import de.dhbwstuttgart.parser.SyntaxTreeGenerator.AssignToLocal;
|
||||
import de.dhbwstuttgart.syntaxtree.statement.*;
|
||||
import de.dhbwstuttgart.syntaxtree.statement.literal.Literal;
|
||||
import de.dhbwstuttgart.syntaxtree.statement.literal.Null;
|
||||
@ -7,6 +8,8 @@ import de.dhbwstuttgart.syntaxtree.statement.literal.StringLiteral;
|
||||
|
||||
public interface StatementVisitor {
|
||||
|
||||
void visit(ArgumentList argumentList);
|
||||
|
||||
void visit(LambdaExpression lambdaExpression);
|
||||
|
||||
void visit(Assign assign);
|
||||
@ -15,6 +18,8 @@ public interface StatementVisitor {
|
||||
|
||||
void visit(Block block);
|
||||
|
||||
void visit(BreakStmt breakStmt);
|
||||
|
||||
void visit(CastExpr castExpr);
|
||||
|
||||
void visit(EmptyStmt emptyStmt);
|
||||
@ -53,7 +58,15 @@ public interface StatementVisitor {
|
||||
|
||||
void visit(WhileStmt whileStmt);
|
||||
|
||||
void visit(DoStmt whileStmt);
|
||||
|
||||
void visit(Null aNull);
|
||||
|
||||
void visit(Literal literal);
|
||||
|
||||
void visit(AssignToField assignLeftSide);
|
||||
|
||||
void visit(AssignToLocal assignLeftSide);
|
||||
|
||||
void visit(SuperCall superCall);
|
||||
}
|
||||
|
@ -6,7 +6,7 @@ import java.util.List;
|
||||
import de.dhbwstuttgart.core.IItemWithOffset;
|
||||
import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceInformation;
|
||||
import org.antlr.v4.runtime.Token;
|
||||
import org.antlr.v4.runtime.misc.Pair;
|
||||
//import org.antlr.v4.runtime.misc.Pair;
|
||||
|
||||
public abstract class SyntaxTreeNode implements IItemWithOffset{
|
||||
private final Token offset;
|
||||
|
@ -25,15 +25,9 @@ import org.antlr.v4.runtime.Token;
|
||||
* dass alle Imports und Typnamen korrekt sind und müssen diese nicht überprüfen.
|
||||
*/
|
||||
public class ASTFactory {
|
||||
private final JavaClassRegistry names;
|
||||
|
||||
|
||||
public ASTFactory(JavaClassRegistry scope){
|
||||
names = scope;
|
||||
}
|
||||
|
||||
public ClassOrInterface createClass(java.lang.Class jreClass){
|
||||
JavaClassName name = names.getName(jreClass.getName());
|
||||
public static ClassOrInterface createClass(java.lang.Class jreClass){
|
||||
JavaClassName name = new JavaClassName(jreClass.getName());
|
||||
List<Method> methoden = new ArrayList<>();
|
||||
List<de.dhbwstuttgart.syntaxtree.Constructor> konstruktoren = new ArrayList<>();
|
||||
for(java.lang.reflect.Constructor constructor : jreClass.getConstructors()){
|
||||
@ -43,6 +37,9 @@ public class ASTFactory {
|
||||
methoden.add(createMethod(method, jreClass));
|
||||
}
|
||||
List<Field> felder = new ArrayList<>();
|
||||
for(java.lang.reflect.Field field : jreClass.getFields()){
|
||||
felder.add(createField(field, name));
|
||||
}
|
||||
int modifier = jreClass.getModifiers();
|
||||
boolean isInterface = jreClass.isInterface();
|
||||
java.lang.Class superjreClass = jreClass.getSuperclass();
|
||||
@ -63,13 +60,17 @@ public class ASTFactory {
|
||||
return new ClassOrInterface(modifier, name, felder, methoden, konstruktoren, genericDeclarationList, superClass,isInterface, implementedInterfaces, offset);
|
||||
}
|
||||
|
||||
private de.dhbwstuttgart.syntaxtree.Constructor createConstructor(Constructor constructor, Class inClass) {
|
||||
private static Field createField(java.lang.reflect.Field field, JavaClassName jreClass) {
|
||||
return new Field(field.getName(), createType(field.getType(), jreClass, null), field.getModifiers(), new NullToken());
|
||||
}
|
||||
|
||||
private static de.dhbwstuttgart.syntaxtree.Constructor createConstructor(Constructor constructor, Class inClass) {
|
||||
String name = constructor.getName();
|
||||
RefTypeOrTPHOrWildcardOrGeneric returnType = createType(inClass, names.getName(inClass.getName()), name);
|
||||
RefTypeOrTPHOrWildcardOrGeneric returnType = createType(inClass, new JavaClassName(inClass.getName()), name);
|
||||
Parameter[] jreParams = constructor.getParameters();
|
||||
List<FormalParameter> params = new ArrayList<>();
|
||||
for(Parameter jreParam : jreParams){
|
||||
RefTypeOrTPHOrWildcardOrGeneric paramType = createType(jreParam.getType(),names.getName(inClass.getName()), name);
|
||||
RefTypeOrTPHOrWildcardOrGeneric paramType = createType(jreParam.getType(),new JavaClassName(inClass.getName()), name);
|
||||
params.add(new FormalParameter(jreParam.getName(),paramType, new NullToken()));
|
||||
}
|
||||
ParameterList parameterList = new ParameterList(params, new NullToken());
|
||||
@ -78,17 +79,26 @@ public class ASTFactory {
|
||||
Token offset = new NullToken();
|
||||
int modifier = constructor.getModifiers();
|
||||
|
||||
return new de.dhbwstuttgart.syntaxtree.Constructor(name,returnType, modifier, parameterList, block, gtvDeclarations, offset);
|
||||
if(inClass.equals(java.lang.Object.class)){
|
||||
return null;
|
||||
}
|
||||
|
||||
return new de.dhbwstuttgart.syntaxtree.Constructor(name,returnType, modifier, parameterList, block, gtvDeclarations, offset, new ArrayList<>(),
|
||||
createType(inClass.getSuperclass()));
|
||||
}
|
||||
|
||||
public Method createMethod(java.lang.reflect.Method jreMethod, java.lang.Class inClass){
|
||||
private static RefType createType(Class classType) {
|
||||
return createClass(classType).getType();
|
||||
}
|
||||
|
||||
public static Method createMethod(java.lang.reflect.Method jreMethod, java.lang.Class inClass){
|
||||
String name = jreMethod.getName();
|
||||
RefTypeOrTPHOrWildcardOrGeneric returnType;
|
||||
returnType = createType(jreMethod.getReturnType(),names.getName(inClass.getName()), name);
|
||||
returnType = createType(jreMethod.getReturnType(),new JavaClassName(inClass.getName()), name);
|
||||
Parameter[] jreParams = jreMethod.getParameters();
|
||||
List<FormalParameter> params = new ArrayList<>();
|
||||
for(Parameter jreParam : jreParams){
|
||||
RefTypeOrTPHOrWildcardOrGeneric paramType = createType(jreParam.getType(),names.getName(inClass.getName()), name);
|
||||
RefTypeOrTPHOrWildcardOrGeneric paramType = createType(jreParam.getType(),new JavaClassName(inClass.getName()), name);
|
||||
params.add(new FormalParameter(jreParam.getName(),paramType, new NullToken()));
|
||||
}
|
||||
ParameterList parameterList = new ParameterList(params, new NullToken());
|
||||
@ -100,7 +110,7 @@ public class ASTFactory {
|
||||
return new Method(name,returnType, modifier, parameterList, block, gtvDeclarations, offset);
|
||||
}
|
||||
|
||||
public GenericDeclarationList createGenerics(TypeVariable[] typeParameters, Class context, String methodName){
|
||||
public static GenericDeclarationList createGenerics(TypeVariable[] typeParameters, Class context, String methodName){
|
||||
List<de.dhbwstuttgart.syntaxtree.GenericTypeVar> gtvs = new ArrayList<>();
|
||||
for(TypeVariable jreTV : typeParameters){
|
||||
de.dhbwstuttgart.syntaxtree.GenericTypeVar gtv = createGeneric(jreTV, jreTV.getName(), context, methodName);
|
||||
@ -120,23 +130,23 @@ public class ASTFactory {
|
||||
}
|
||||
*/
|
||||
|
||||
public RefTypeOrTPHOrWildcardOrGeneric createType(java.lang.reflect.Type type, JavaClassName parentClass, String parentMethod){
|
||||
public static RefTypeOrTPHOrWildcardOrGeneric createType(java.lang.reflect.Type type, JavaClassName parentClass, String parentMethod){
|
||||
if(type.getTypeName().equals("void")){
|
||||
return new Void(new NullToken());
|
||||
}else if(type.getTypeName().equals("int")){
|
||||
return new RefType(this.names.getName("java.lang.Integer"), new ArrayList<>(), new NullToken());
|
||||
return new RefType(new JavaClassName("java.lang.Integer"), new ArrayList<>(), new NullToken());
|
||||
}else if(type.getTypeName().equals("byte")){
|
||||
return new RefType(this.names.getName("java.lang.Byte"), new ArrayList<>(), new NullToken());
|
||||
return new RefType(new JavaClassName("java.lang.Byte"), new ArrayList<>(), new NullToken());
|
||||
}else if(type.getTypeName().equals("boolean")){
|
||||
return new RefType(this.names.getName("java.lang.Boolean"), new ArrayList<>(), new NullToken());
|
||||
return new RefType(new JavaClassName("java.lang.Boolean"), new ArrayList<>(), new NullToken());
|
||||
}else if(type.getTypeName().equals("char")){
|
||||
return new RefType(this.names.getName("java.lang.Char"), new ArrayList<>(), new NullToken());
|
||||
return new RefType(new JavaClassName("java.lang.Char"), new ArrayList<>(), new NullToken());
|
||||
}else if(type.getTypeName().equals("short")){
|
||||
return new RefType(this.names.getName("java.lang.Short"), new ArrayList<>(), new NullToken());
|
||||
return new RefType(new JavaClassName("java.lang.Short"), new ArrayList<>(), new NullToken());
|
||||
}else if(type.getTypeName().equals("double")){
|
||||
return new RefType(this.names.getName("java.lang.Double"), new ArrayList<>(), new NullToken());
|
||||
return new RefType(new JavaClassName("java.lang.Double"), new ArrayList<>(), new NullToken());
|
||||
}else if(type.getTypeName().equals("long")){
|
||||
return new RefType(this.names.getName("java.lang.Long"), new ArrayList<>(), new NullToken());
|
||||
return new RefType(new JavaClassName("java.lang.Long"), new ArrayList<>(), new NullToken());
|
||||
}else{
|
||||
if(type instanceof TypeVariable){
|
||||
//GTVDeclarationContext via "(TypeVariable) type).getGenericDeclaration()"
|
||||
@ -150,13 +160,13 @@ public class ASTFactory {
|
||||
params.add(createType(t, parentClass, parentMethod));
|
||||
}
|
||||
}
|
||||
RefType ret = new RefType(this.names.getName(type.getTypeName()), params, new NullToken());
|
||||
RefType ret = new RefType(new JavaClassName(type.getTypeName()), params, new NullToken());
|
||||
return ret;
|
||||
}
|
||||
}
|
||||
|
||||
public de.dhbwstuttgart.syntaxtree.GenericTypeVar createGeneric(TypeVariable jreTypeVar, String jreTVName, Class context, String parentMethod){
|
||||
JavaClassName parentClass = names.getName(context.getName());
|
||||
public static de.dhbwstuttgart.syntaxtree.GenericTypeVar createGeneric(TypeVariable jreTypeVar, String jreTVName, Class context, String parentMethod){
|
||||
JavaClassName parentClass = new JavaClassName(context.getName());
|
||||
List<RefType> genericBounds = new ArrayList<>();
|
||||
java.lang.reflect.Type[] bounds = jreTypeVar.getBounds();
|
||||
if(bounds.length > 0){
|
||||
@ -169,8 +179,8 @@ public class ASTFactory {
|
||||
, genericBounds, new NullToken(), new NullToken());
|
||||
}
|
||||
|
||||
public ClassOrInterface createObjectClass() {
|
||||
return this.createClass(Object.class);
|
||||
public static ClassOrInterface createObjectClass() {
|
||||
return createClass(Object.class);
|
||||
}
|
||||
|
||||
/*
|
||||
|
@ -11,6 +11,9 @@ import de.dhbwstuttgart.syntaxtree.type.Void;
|
||||
import de.dhbwstuttgart.typecheck.JavaClassName;
|
||||
import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
|
||||
import de.dhbwstuttgart.typeinference.constraints.Pair;
|
||||
import de.dhbwstuttgart.typeinference.result.PairTPHequalRefType;
|
||||
import de.dhbwstuttgart.typeinference.result.PairTPHsmallerTPH;
|
||||
import de.dhbwstuttgart.typeinference.result.ResultPair;
|
||||
import de.dhbwstuttgart.typeinference.unify.model.ExtendsType;
|
||||
import de.dhbwstuttgart.typeinference.unify.model.FiniteClosure;
|
||||
import de.dhbwstuttgart.typeinference.unify.model.FunNType;
|
||||
@ -133,18 +136,19 @@ public class UnifyTypeFactory {
|
||||
* Convert from
|
||||
* UnifyType -> ASTType
|
||||
*/
|
||||
public static Set<Set<Pair>> convert(Set<Set<UnifyPair>> unifyPairSet, Map<String,TypePlaceholder> tphs) {
|
||||
public static Set<ResultPair> convert(Set<UnifyPair> unifyPairSet, Map<String,TypePlaceholder> tphs) {
|
||||
return unifyPairSet.stream().map(
|
||||
set -> set.stream().map(
|
||||
unifyPair -> convert(unifyPair, tphs))
|
||||
.collect(Collectors.toSet()))
|
||||
.collect(Collectors.toSet());
|
||||
unifyPair -> convert(unifyPair, tphs))
|
||||
.collect(Collectors.toSet());
|
||||
}
|
||||
|
||||
public static Pair convert(UnifyPair mp, Map<String,TypePlaceholder> tphs) {
|
||||
public static ResultPair convert(UnifyPair mp, Map<String,TypePlaceholder> tphs) {
|
||||
RefTypeOrTPHOrWildcardOrGeneric tl = UnifyTypeFactory.convert(mp.getLhsType(), tphs);
|
||||
RefTypeOrTPHOrWildcardOrGeneric tr = UnifyTypeFactory.convert(mp.getRhsType(), tphs);
|
||||
return new Pair(tl, tr, mp.getPairOp());
|
||||
if(tl instanceof TypePlaceholder){
|
||||
if(tr instanceof TypePlaceholder) return new PairTPHsmallerTPH((TypePlaceholder)tl, (TypePlaceholder)tr);
|
||||
return new PairTPHequalRefType((TypePlaceholder)tl, tr);
|
||||
}else throw new NotImplementedException();
|
||||
}
|
||||
|
||||
public static RefTypeOrTPHOrWildcardOrGeneric convert(ReferenceType t, Map<String,TypePlaceholder> tphs) {
|
||||
@ -159,12 +163,12 @@ public class UnifyTypeFactory {
|
||||
}
|
||||
|
||||
public static RefTypeOrTPHOrWildcardOrGeneric convert(SuperType t, Map<String,TypePlaceholder> tphs) {
|
||||
RefType innerType = new RefType(new JavaClassName(t.getSuperedType().getName()), new NullToken());
|
||||
RefTypeOrTPHOrWildcardOrGeneric innerType = convert(t.getSuperedType(), tphs);
|
||||
return new SuperWildcardType(innerType, new NullToken());
|
||||
}
|
||||
|
||||
public static RefTypeOrTPHOrWildcardOrGeneric convert(ExtendsType t, Map<String,TypePlaceholder> tphs) {
|
||||
RefType innerType = new RefType(new JavaClassName(t.getExtendedType().getName()), new NullToken());
|
||||
RefTypeOrTPHOrWildcardOrGeneric innerType = convert(t.getExtendedType(), tphs);
|
||||
return new ExtendsWildcardType(innerType, new NullToken());
|
||||
}
|
||||
|
||||
|
24
src/de/dhbwstuttgart/syntaxtree/statement/AssertStmt.java
Normal file
24
src/de/dhbwstuttgart/syntaxtree/statement/AssertStmt.java
Normal file
@ -0,0 +1,24 @@
|
||||
package de.dhbwstuttgart.syntaxtree.statement;
|
||||
|
||||
import de.dhbwstuttgart.syntaxtree.StatementVisitor;
|
||||
import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
|
||||
import org.antlr.v4.runtime.Token;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
/**
|
||||
* Created by Felix_K on 21.09.2017.
|
||||
*/
|
||||
public class AssertStmt extends Statement
|
||||
{
|
||||
public final List<Expression> expr;
|
||||
public AssertStmt(RefTypeOrTPHOrWildcardOrGeneric type, List<Expression> expr, Token offset){
|
||||
super(type, offset);
|
||||
this.expr=expr;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void accept(StatementVisitor visitor) {
|
||||
|
||||
}
|
||||
}
|
@ -8,13 +8,16 @@ import de.dhbwstuttgart.typeinference.constraints.ConstraintsFactory;
|
||||
import de.dhbwstuttgart.typeinference.unify.model.PairOperator;
|
||||
import org.antlr.v4.runtime.Token;
|
||||
|
||||
|
||||
/*
|
||||
Aufbau:
|
||||
rightSide = leftSide
|
||||
*/
|
||||
public class Assign extends Statement
|
||||
{
|
||||
public final Expression rightSide;
|
||||
public final Expression lefSide;
|
||||
public final AssignLeftSide lefSide;
|
||||
|
||||
public Assign(Expression leftHandSide, Expression value, Token offset) {
|
||||
public Assign(AssignLeftSide leftHandSide, Expression value, Token offset) {
|
||||
super(leftHandSide.getType(), offset);
|
||||
this.rightSide = value;
|
||||
this.lefSide = leftHandSide;
|
||||
|
@ -0,0 +1,12 @@
|
||||
package de.dhbwstuttgart.syntaxtree.statement;
|
||||
|
||||
import de.dhbwstuttgart.syntaxtree.StatementVisitor;
|
||||
import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
|
||||
import org.antlr.v4.runtime.Token;
|
||||
|
||||
public abstract class AssignLeftSide extends TypableStatement{
|
||||
|
||||
public AssignLeftSide(RefTypeOrTPHOrWildcardOrGeneric type, Token offset) {
|
||||
super(type, offset);
|
||||
}
|
||||
}
|
16
src/de/dhbwstuttgart/syntaxtree/statement/AssignToField.java
Normal file
16
src/de/dhbwstuttgart/syntaxtree/statement/AssignToField.java
Normal file
@ -0,0 +1,16 @@
|
||||
package de.dhbwstuttgart.syntaxtree.statement;
|
||||
|
||||
import de.dhbwstuttgart.syntaxtree.StatementVisitor;
|
||||
|
||||
public class AssignToField extends AssignLeftSide{
|
||||
public final FieldVar field;
|
||||
public AssignToField(FieldVar fieldVar) {
|
||||
super(fieldVar.getType(), fieldVar.getOffset());
|
||||
field = fieldVar;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void accept(StatementVisitor visitor) {
|
||||
visitor.visit(this);
|
||||
}
|
||||
}
|
25
src/de/dhbwstuttgart/syntaxtree/statement/BreakStmt.java
Normal file
25
src/de/dhbwstuttgart/syntaxtree/statement/BreakStmt.java
Normal file
@ -0,0 +1,25 @@
|
||||
package de.dhbwstuttgart.syntaxtree.statement;
|
||||
|
||||
import com.sun.scenario.effect.Offset;
|
||||
import de.dhbwstuttgart.syntaxtree.StatementVisitor;
|
||||
import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
|
||||
import org.antlr.v4.runtime.Token;
|
||||
import org.antlr.v4.runtime.tree.TerminalNode;
|
||||
|
||||
/**
|
||||
* Created by Felix_K on 20.09.2017.
|
||||
*/
|
||||
public class BreakStmt extends Statement
|
||||
{
|
||||
public final String indentifier;
|
||||
|
||||
public BreakStmt(RefTypeOrTPHOrWildcardOrGeneric type, String Indentifier, Token offset)
|
||||
{
|
||||
super(type, offset);
|
||||
this.indentifier=Indentifier;
|
||||
}
|
||||
@Override
|
||||
public void accept(StatementVisitor visitor) {
|
||||
visitor.visit(this);
|
||||
}
|
||||
}
|
@ -0,0 +1,15 @@
|
||||
package de.dhbwstuttgart.syntaxtree.statement;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
/**
|
||||
* Created by Felix_K on 21.09.2017.
|
||||
*/
|
||||
public class CatchesStatement
|
||||
{
|
||||
final List<Statement> catchClauses;
|
||||
public CatchesStatement(List<Statement> catches)
|
||||
{
|
||||
catchClauses = catches;
|
||||
}
|
||||
}
|
14
src/de/dhbwstuttgart/syntaxtree/statement/ContinueStmt.java
Normal file
14
src/de/dhbwstuttgart/syntaxtree/statement/ContinueStmt.java
Normal file
@ -0,0 +1,14 @@
|
||||
package de.dhbwstuttgart.syntaxtree.statement;
|
||||
|
||||
import de.dhbwstuttgart.syntaxtree.type.RefType;
|
||||
import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
|
||||
import org.antlr.v4.runtime.Token;
|
||||
|
||||
/**
|
||||
* Created by Felix_K on 22.09.2017.
|
||||
*/
|
||||
public class ContinueStmt extends BreakStmt {
|
||||
public ContinueStmt(RefTypeOrTPHOrWildcardOrGeneric type, String indent, Token offset){
|
||||
super(type, indent, offset);
|
||||
}
|
||||
}
|
18
src/de/dhbwstuttgart/syntaxtree/statement/DoStmt.java
Normal file
18
src/de/dhbwstuttgart/syntaxtree/statement/DoStmt.java
Normal file
@ -0,0 +1,18 @@
|
||||
package de.dhbwstuttgart.syntaxtree.statement;
|
||||
|
||||
import de.dhbwstuttgart.syntaxtree.StatementVisitor;
|
||||
import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
|
||||
import org.antlr.v4.runtime.Token;
|
||||
|
||||
public class DoStmt extends WhileStmt
|
||||
{
|
||||
public DoStmt(Expression expr, Statement loopBlock, Token offset)
|
||||
{
|
||||
super(expr, loopBlock, offset);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void accept(StatementVisitor visitor) {
|
||||
visitor.visit(this);
|
||||
}
|
||||
}
|
@ -9,24 +9,9 @@ import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceBlockInformation;
|
||||
import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
|
||||
import org.antlr.v4.runtime.Token;
|
||||
|
||||
public abstract class Expression extends SyntaxTreeNode
|
||||
public abstract class Expression extends TypableStatement
|
||||
{
|
||||
private RefTypeOrTPHOrWildcardOrGeneric type;
|
||||
|
||||
public Expression(RefTypeOrTPHOrWildcardOrGeneric type, Token offset){
|
||||
super(offset);
|
||||
if(type == null)throw new NullPointerException();
|
||||
this.type = type;
|
||||
}
|
||||
|
||||
public RefTypeOrTPHOrWildcardOrGeneric getType(){
|
||||
return type;
|
||||
}
|
||||
|
||||
public abstract void accept(StatementVisitor visitor);
|
||||
|
||||
@Override
|
||||
public void accept(ASTVisitor visitor) {
|
||||
this.accept((StatementVisitor)visitor);
|
||||
super(type, offset);
|
||||
}
|
||||
}
|
||||
|
@ -1,22 +1,28 @@
|
||||
package de.dhbwstuttgart.syntaxtree.statement;
|
||||
|
||||
import de.dhbwstuttgart.syntaxtree.StatementVisitor;
|
||||
import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
|
||||
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 IfStmt extends Statement
|
||||
{
|
||||
public IfStmt(int offset, int variableLength)
|
||||
public final Expression expr;
|
||||
public final Statement then_block;
|
||||
public final Statement else_block;
|
||||
|
||||
public IfStmt(RefTypeOrTPHOrWildcardOrGeneric type,
|
||||
Expression expr, Statement thenBlock, Statement elseBlock, Token offset)
|
||||
{
|
||||
super(null,null);
|
||||
super(type,offset);
|
||||
this.expr = expr;
|
||||
this.then_block = thenBlock;
|
||||
this.else_block = elseBlock;
|
||||
}
|
||||
|
||||
public boolean hamaDebug = true; //hama: Debug Ausgaben von mir ein- bzw. ausschalten
|
||||
public Expression expr;
|
||||
public Block then_block;
|
||||
public Block else_block;
|
||||
|
||||
|
||||
@Override
|
||||
public void accept(StatementVisitor visitor) {
|
||||
|
@ -1,17 +0,0 @@
|
||||
package de.dhbwstuttgart.syntaxtree.statement;
|
||||
|
||||
import de.dhbwstuttgart.syntaxtree.FormalParameter;
|
||||
|
||||
/**
|
||||
* Der FormalParameter einer LambdaExpression hat gesonderte Eigenschaften.
|
||||
* @author janulrich
|
||||
*
|
||||
*/
|
||||
public class LambdaParameter extends FormalParameter {
|
||||
|
||||
public LambdaParameter(FormalParameter fp) {
|
||||
super(null,null,null);
|
||||
}
|
||||
|
||||
|
||||
}
|
@ -3,6 +3,7 @@ import java.util.Hashtable;
|
||||
import java.util.Iterator;
|
||||
|
||||
import de.dhbwstuttgart.parser.antlr.Java8Parser;
|
||||
import org.antlr.v4.runtime.Token;
|
||||
import org.apache.bcel.generic.ClassGen;
|
||||
import org.apache.bcel.generic.InstructionList;
|
||||
|
||||
|
@ -4,12 +4,15 @@ import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceBlockInformation;
|
||||
import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
|
||||
import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceInformation;
|
||||
import de.dhbwstuttgart.exceptions.NotImplementedException;
|
||||
import org.antlr.v4.runtime.Token;
|
||||
|
||||
|
||||
public class PostIncExpr extends UnaryExpr
|
||||
{
|
||||
final Expression expr;
|
||||
public PostIncExpr(Expression expr) {
|
||||
super(null);
|
||||
this.expr=expr;
|
||||
}
|
||||
|
||||
}
|
||||
|
@ -12,8 +12,10 @@ import org.apache.bcel.generic.InstructionList;
|
||||
|
||||
public class PreDecExpr extends UnaryExpr
|
||||
{
|
||||
public PreDecExpr(Token offset)
|
||||
Expression expr;
|
||||
public PreDecExpr(Expression expr, Token offset)
|
||||
{
|
||||
super(offset);
|
||||
this.expr=expr;
|
||||
}
|
||||
}
|
||||
|
@ -5,8 +5,10 @@ import org.antlr.v4.runtime.Token;
|
||||
|
||||
public class PreIncExpr extends UnaryExpr
|
||||
{
|
||||
public PreIncExpr(Token offset)
|
||||
final Expression expr;
|
||||
public PreIncExpr(Expression expr,Token offset)
|
||||
{
|
||||
super(offset);
|
||||
this.expr=expr;
|
||||
}
|
||||
}
|
||||
|
@ -1,5 +1,9 @@
|
||||
package de.dhbwstuttgart.syntaxtree.statement;
|
||||
|
||||
import de.dhbwstuttgart.syntaxtree.StatementVisitor;
|
||||
import de.dhbwstuttgart.syntaxtree.type.RefType;
|
||||
import de.dhbwstuttgart.syntaxtree.type.Void;
|
||||
import org.antlr.v4.runtime.Token;
|
||||
import org.apache.bcel.Constants;
|
||||
import org.apache.bcel.generic.InstructionFactory;
|
||||
import org.apache.bcel.generic.InstructionHandle;
|
||||
@ -7,18 +11,22 @@ import org.apache.bcel.generic.InstructionList;
|
||||
|
||||
import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode;
|
||||
|
||||
import java.util.ArrayList;
|
||||
|
||||
|
||||
public class SuperCall extends ThisCall
|
||||
public class SuperCall extends MethodCall
|
||||
{
|
||||
public SuperCall(int offset,int variableLength)
|
||||
{
|
||||
super(null,null,variableLength);
|
||||
public SuperCall(Token offset){
|
||||
this(new ArgumentList(new ArrayList<Expression>(), offset),offset);
|
||||
}
|
||||
|
||||
public SuperCall(SyntaxTreeNode parent){
|
||||
this(0,0);
|
||||
public SuperCall(ArgumentList argumentList, Token offset){
|
||||
super(new Void(offset), new Receiver(new This(offset)), "<init>", argumentList, offset);
|
||||
}
|
||||
|
||||
|
||||
|
||||
@Override
|
||||
public void accept(StatementVisitor visitor) {
|
||||
visitor.visit(this);
|
||||
}
|
||||
}
|
||||
|
24
src/de/dhbwstuttgart/syntaxtree/statement/SwitchStmt.java
Normal file
24
src/de/dhbwstuttgart/syntaxtree/statement/SwitchStmt.java
Normal file
@ -0,0 +1,24 @@
|
||||
package de.dhbwstuttgart.syntaxtree.statement;
|
||||
|
||||
import de.dhbwstuttgart.syntaxtree.StatementVisitor;
|
||||
import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
|
||||
import org.antlr.v4.runtime.Token;
|
||||
|
||||
/**
|
||||
* Created by Felix_K on 23.09.2017.
|
||||
*/
|
||||
public class SwitchStmt extends Statement
|
||||
{
|
||||
public final Expression expr;
|
||||
public final Block switchBlock;
|
||||
|
||||
public SwitchStmt(RefTypeOrTPHOrWildcardOrGeneric type,Expression expr, Block block, Token offset){
|
||||
super(type,offset);
|
||||
this.expr=expr;
|
||||
this.switchBlock=block;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void accept(StatementVisitor visitor) {
|
||||
}
|
||||
}
|
@ -0,0 +1,28 @@
|
||||
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;
|
||||
import org.antlr.v4.runtime.Token;
|
||||
|
||||
public abstract class TypableStatement extends SyntaxTreeNode{
|
||||
private RefTypeOrTPHOrWildcardOrGeneric type;
|
||||
|
||||
public TypableStatement(RefTypeOrTPHOrWildcardOrGeneric type, Token offset){
|
||||
super(offset);
|
||||
if(type == null)throw new NullPointerException();
|
||||
this.type = type;
|
||||
}
|
||||
|
||||
public RefTypeOrTPHOrWildcardOrGeneric getType(){
|
||||
return type;
|
||||
}
|
||||
|
||||
public abstract void accept(StatementVisitor visitor);
|
||||
|
||||
@Override
|
||||
public void accept(ASTVisitor visitor) {
|
||||
this.accept((StatementVisitor)visitor);
|
||||
}
|
||||
}
|
@ -2,28 +2,23 @@ package de.dhbwstuttgart.syntaxtree.statement;
|
||||
|
||||
|
||||
import de.dhbwstuttgart.syntaxtree.StatementVisitor;
|
||||
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 de.dhbwstuttgart.exceptions.NotImplementedException;
|
||||
import org.antlr.v4.runtime.Token;
|
||||
|
||||
public class WhileStmt extends Statement
|
||||
{
|
||||
public WhileStmt(int offset, int variableLength)
|
||||
{
|
||||
super(null,null);
|
||||
}
|
||||
public final Expression expr;
|
||||
public final Statement loopBlock;
|
||||
|
||||
public Expression expr;
|
||||
public Block loop_block;
|
||||
|
||||
/**
|
||||
* <br/>Author: Martin Pl�micke
|
||||
* @return
|
||||
*/
|
||||
public String toString()
|
||||
public WhileStmt(Expression expr, Statement loopBlock, Token offset)
|
||||
{
|
||||
return "WHILE " + loop_block.toString();
|
||||
super(TypePlaceholder.fresh(offset), offset);
|
||||
this.expr = expr;
|
||||
this.loopBlock = loopBlock;
|
||||
}
|
||||
|
||||
@Override
|
||||
|
@ -2,6 +2,7 @@ package de.dhbwstuttgart.syntaxtree.type;
|
||||
|
||||
|
||||
import de.dhbwstuttgart.syntaxtree.ASTVisitor;
|
||||
import de.dhbwstuttgart.typeinference.result.ResultSetVisitor;
|
||||
import org.antlr.v4.runtime.Token;
|
||||
|
||||
/**
|
||||
@ -18,7 +19,7 @@ public class ExtendsWildcardType extends WildcardType{
|
||||
* Author: Arne Lüdtke<br/>
|
||||
* Standard Konstruktor für eine ExtendsWildcard
|
||||
*/
|
||||
public ExtendsWildcardType (RefType extendsType, Token offset)
|
||||
public ExtendsWildcardType (RefTypeOrTPHOrWildcardOrGeneric extendsType, Token offset)
|
||||
{
|
||||
super(extendsType, offset);
|
||||
}
|
||||
@ -38,4 +39,9 @@ public class ExtendsWildcardType extends WildcardType{
|
||||
public void accept(ASTVisitor visitor) {
|
||||
visitor.visit(this);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void accept(ResultSetVisitor visitor) {
|
||||
visitor.visit(this);
|
||||
}
|
||||
}
|
||||
|
@ -3,6 +3,7 @@ package de.dhbwstuttgart.syntaxtree.type;
|
||||
import de.dhbwstuttgart.syntaxtree.ASTVisitor;
|
||||
import de.dhbwstuttgart.typecheck.GenericTypeName;
|
||||
import de.dhbwstuttgart.typecheck.JavaClassName;
|
||||
import de.dhbwstuttgart.typeinference.result.ResultSetVisitor;
|
||||
import org.antlr.v4.runtime.Token;
|
||||
|
||||
public class GenericRefType extends RefTypeOrTPHOrWildcardOrGeneric
|
||||
@ -26,5 +27,10 @@ public class GenericRefType extends RefTypeOrTPHOrWildcardOrGeneric
|
||||
public void accept(ASTVisitor visitor) {
|
||||
visitor.visit(this);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void accept(ResultSetVisitor visitor) {
|
||||
visitor.visit(this);
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -2,6 +2,7 @@ package de.dhbwstuttgart.syntaxtree.type;
|
||||
|
||||
import de.dhbwstuttgart.syntaxtree.ASTVisitor;
|
||||
import de.dhbwstuttgart.typecheck.JavaClassName;
|
||||
import de.dhbwstuttgart.typeinference.result.ResultSetVisitor;
|
||||
import org.antlr.v4.runtime.Token;
|
||||
|
||||
import java.util.ArrayList;
|
||||
@ -105,5 +106,10 @@ public class RefType extends RefTypeOrTPHOrWildcardOrGeneric
|
||||
public void accept(ASTVisitor visitor) {
|
||||
visitor.visit(this);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void accept(ResultSetVisitor visitor) {
|
||||
visitor.visit(this);
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -2,6 +2,7 @@ package de.dhbwstuttgart.syntaxtree.type;
|
||||
|
||||
import de.dhbwstuttgart.syntaxtree.ASTVisitor;
|
||||
import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode;
|
||||
import de.dhbwstuttgart.typeinference.result.ResultSetVisitor;
|
||||
import org.antlr.v4.runtime.Token;
|
||||
|
||||
public abstract class RefTypeOrTPHOrWildcardOrGeneric extends SyntaxTreeNode{
|
||||
@ -11,4 +12,6 @@ public abstract class RefTypeOrTPHOrWildcardOrGeneric extends SyntaxTreeNode{
|
||||
|
||||
@Override
|
||||
public abstract void accept(ASTVisitor visitor);
|
||||
|
||||
public abstract void accept(ResultSetVisitor visitor);
|
||||
}
|
||||
|
@ -2,6 +2,7 @@ package de.dhbwstuttgart.syntaxtree.type;
|
||||
|
||||
|
||||
import de.dhbwstuttgart.syntaxtree.ASTVisitor;
|
||||
import de.dhbwstuttgart.typeinference.result.ResultSetVisitor;
|
||||
import org.antlr.v4.runtime.Token;
|
||||
|
||||
/**
|
||||
@ -18,7 +19,7 @@ public class SuperWildcardType extends WildcardType{
|
||||
* Author: Arne Lüdtke<br/>
|
||||
* Standard Konstruktor für eine SuperWildcard
|
||||
*/
|
||||
public SuperWildcardType( RefType innerType, Token offset)
|
||||
public SuperWildcardType( RefTypeOrTPHOrWildcardOrGeneric innerType, Token offset)
|
||||
{
|
||||
super(innerType, offset);
|
||||
}
|
||||
@ -48,4 +49,9 @@ public class SuperWildcardType extends WildcardType{
|
||||
public void accept(ASTVisitor visitor) {
|
||||
visitor.visit(this);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void accept(ResultSetVisitor visitor) {
|
||||
visitor.visit(this);
|
||||
}
|
||||
}
|
||||
|
@ -4,6 +4,7 @@ import java.util.Hashtable;
|
||||
import de.dhbwstuttgart.syntaxtree.ASTVisitor;
|
||||
import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode;
|
||||
import de.dhbwstuttgart.syntaxtree.factory.NameGenerator;
|
||||
import de.dhbwstuttgart.typeinference.result.ResultSetVisitor;
|
||||
import org.antlr.v4.runtime.Token;
|
||||
|
||||
/**
|
||||
@ -71,4 +72,9 @@ public class TypePlaceholder extends RefTypeOrTPHOrWildcardOrGeneric
|
||||
public void accept(ASTVisitor visitor) {
|
||||
visitor.visit(this);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void accept(ResultSetVisitor visitor) {
|
||||
visitor.visit(this);
|
||||
}
|
||||
}
|
||||
|
@ -11,19 +11,19 @@ import org.antlr.v4.runtime.Token;
|
||||
|
||||
public abstract class WildcardType extends RefTypeOrTPHOrWildcardOrGeneric {
|
||||
|
||||
protected RefType innerType = null;
|
||||
protected RefTypeOrTPHOrWildcardOrGeneric innerType = null;
|
||||
|
||||
/**
|
||||
* Author: Arne Lüdtke<br/>
|
||||
* Standard Konstruktor für eine Wildcard
|
||||
*/
|
||||
public WildcardType(RefType innerType, Token offset)
|
||||
public WildcardType(RefTypeOrTPHOrWildcardOrGeneric innerType, Token offset)
|
||||
{
|
||||
super(offset);
|
||||
this.innerType = innerType;
|
||||
}
|
||||
|
||||
public RefType getInnerType(){
|
||||
public RefTypeOrTPHOrWildcardOrGeneric getInnerType(){
|
||||
return innerType;
|
||||
}
|
||||
|
||||
|
@ -1,5 +1,7 @@
|
||||
package de.dhbwstuttgart.syntaxtree.visual;
|
||||
|
||||
import de.dhbwstuttgart.exceptions.NotImplementedException;
|
||||
import de.dhbwstuttgart.parser.SyntaxTreeGenerator.AssignToLocal;
|
||||
import de.dhbwstuttgart.syntaxtree.*;
|
||||
import de.dhbwstuttgart.syntaxtree.statement.*;
|
||||
import de.dhbwstuttgart.syntaxtree.statement.literal.Literal;
|
||||
@ -82,6 +84,15 @@ public class OutputGenerator implements ASTVisitor {
|
||||
method.getType().accept(this);
|
||||
out.append(" " + method.getName());
|
||||
method.getParameterList().accept(this);
|
||||
if(method.block != null)
|
||||
method.block.accept(this);
|
||||
out.append("\n");
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(Constructor method) {
|
||||
out.append(method.getName());
|
||||
method.getParameterList().accept(this);
|
||||
method.block.accept(this);
|
||||
out.append("\n");
|
||||
}
|
||||
@ -120,6 +131,11 @@ public class OutputGenerator implements ASTVisitor {
|
||||
m.accept(this);
|
||||
out.append("\n");
|
||||
}
|
||||
for(Constructor m : classOrInterface.getConstructors()){
|
||||
out.append(tabs);
|
||||
m.accept(this);
|
||||
out.append("\n");
|
||||
}
|
||||
untab();
|
||||
out.append("}");
|
||||
}
|
||||
@ -193,6 +209,12 @@ public class OutputGenerator implements ASTVisitor {
|
||||
out.append("}");
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(BreakStmt breakStmt)
|
||||
{
|
||||
out.append("break"+ " " + breakStmt.indentifier);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(CastExpr castExpr) {
|
||||
|
||||
@ -216,7 +238,15 @@ public class OutputGenerator implements ASTVisitor {
|
||||
|
||||
@Override
|
||||
public void visit(IfStmt ifStmt) {
|
||||
out.append("if (");
|
||||
ifStmt.expr.accept(this);
|
||||
out.append(")");
|
||||
//TODO implement to set ; if then block is empty
|
||||
ifStmt.then_block.accept(this);
|
||||
out.append("else");
|
||||
ifStmt.else_block.accept(this);
|
||||
|
||||
//TODO Felix_K
|
||||
}
|
||||
|
||||
@Override
|
||||
@ -292,7 +322,19 @@ public class OutputGenerator implements ASTVisitor {
|
||||
|
||||
@Override
|
||||
public void visit(WhileStmt whileStmt) {
|
||||
out.append("while(");
|
||||
whileStmt.expr.accept(this);
|
||||
out.append(")");
|
||||
whileStmt.loopBlock.accept(this);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(DoStmt whileStmt) {
|
||||
out.append("do ");
|
||||
whileStmt.loopBlock.accept(this);
|
||||
out.append("while(");
|
||||
whileStmt.expr.accept(this);
|
||||
out.append(");");
|
||||
}
|
||||
|
||||
@Override
|
||||
@ -304,4 +346,21 @@ public class OutputGenerator implements ASTVisitor {
|
||||
public void visit(Literal literal) {
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(AssignToField assignLeftSide) {
|
||||
assignLeftSide.field.accept(this);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(AssignToLocal assignLeftSide) {
|
||||
assignLeftSide.localVar.accept(this);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(SuperCall superCall) {
|
||||
out.append("super(");
|
||||
superCall.arglist.accept(this);
|
||||
out.append(")");
|
||||
}
|
||||
}
|
@ -15,13 +15,9 @@ public class GenericTypeName extends JavaClassName {
|
||||
this.methodName = genericContext.parentMethod;
|
||||
}
|
||||
|
||||
public String toString(){
|
||||
public String getUniqueIdentifier() {
|
||||
return parentClass.toString()
|
||||
+ DELIMITER + methodName
|
||||
+ DELIMITER + super.toString();
|
||||
}
|
||||
|
||||
public String getShortName() {
|
||||
return super.toString();
|
||||
}
|
||||
}
|
||||
|
@ -34,6 +34,15 @@ public class JavaClassName {
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Gibt von einem Klassennamen nur den Namen der Klasse zur<75>ck
|
||||
* Beispiel:
|
||||
* java.lang.Object wird zu: Object
|
||||
*/
|
||||
public static String stripClassName(String className) {
|
||||
return new JavaClassName(className).name;
|
||||
}
|
||||
|
||||
@Override
|
||||
public int hashCode() {
|
||||
final int prime = 31;
|
||||
|
@ -1,13 +1,13 @@
|
||||
package de.dhbwstuttgart.typecheck;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
import java.util.*;
|
||||
|
||||
/**
|
||||
* Speichert die Klassen im aktuellen Projektscope
|
||||
*/
|
||||
public class JavaClassRegistry {
|
||||
public List<JavaClassName> existingClasses = new ArrayList<>();
|
||||
final List<JavaClassName> existingClasses = new ArrayList<>();
|
||||
final List<String> importedPackages = new ArrayList<>();
|
||||
|
||||
public JavaClassRegistry(List<String> initialNames){
|
||||
for(String name : initialNames){
|
||||
@ -15,6 +15,15 @@ public class JavaClassRegistry {
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* F<>gt ein gesamtes Package der ClassRegistry hinzu.
|
||||
* Dies geschieht beispielsweise, wenn der Benutzer ein "import package.*;" statement verwendet
|
||||
* @param packageName
|
||||
*/
|
||||
public void addPackage(String packageName) {
|
||||
importedPackages.add(packageName);
|
||||
}
|
||||
|
||||
public void add(String className){
|
||||
existingClasses.add(new JavaClassName(className));
|
||||
}
|
||||
@ -23,7 +32,13 @@ public class JavaClassRegistry {
|
||||
for(JavaClassName name : existingClasses){
|
||||
if(name.equals(new JavaClassName(className)))return name;
|
||||
}
|
||||
throw new TypeNotPresentException(className, new Throwable());
|
||||
//Jetzt noch alle importierten Packages durchsuchen:
|
||||
JavaClassName ret = getClassFromImportedPackages(className);
|
||||
if(ret == null){
|
||||
throw new TypeNotPresentException(className, new Throwable());
|
||||
}else{
|
||||
return ret;
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
@ -32,6 +47,34 @@ public class JavaClassRegistry {
|
||||
}
|
||||
|
||||
public boolean contains(String whole) {
|
||||
return existingClasses.contains(new JavaClassName(whole));
|
||||
boolean ret = existingClasses.contains(new JavaClassName(whole));
|
||||
if(ret == false){
|
||||
JavaClassName imported = getClassFromImportedPackages(whole);
|
||||
if(imported != null){
|
||||
existingClasses.add(imported);
|
||||
return true;
|
||||
}else {
|
||||
return false;
|
||||
}
|
||||
}else {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
private JavaClassName getClassFromImportedPackages(String className){
|
||||
ClassLoader loader = Thread.currentThread().getContextClassLoader();
|
||||
String shortName = JavaClassName.stripClassName(className);
|
||||
for(String packageName : importedPackages) {
|
||||
try {
|
||||
loader.loadClass(packageName+"."+shortName);
|
||||
//Keine Exception! Die Klasse existiert:
|
||||
JavaClassName ret = new JavaClassName(packageName+"."+shortName);
|
||||
if(ret.equals(new JavaClassName(className)))return ret;
|
||||
} catch (ClassNotFoundException e) {
|
||||
//Die Klasse wurde nicht gefunden!
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
}
|
||||
|
@ -8,24 +8,29 @@ import java.util.List;
|
||||
import java.util.Set;
|
||||
|
||||
public class TypeInsert {
|
||||
/**
|
||||
* point wird hauptsächlich zur Anzeige einer Annotation im Eclipse-plugin benutzt.
|
||||
*/
|
||||
public final TypeInsertPoint point;
|
||||
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 TypeInsert(TypeInsertPoint point, Set<TypeInsertPoint> additionalPoints){
|
||||
this.point = point;
|
||||
inserts = additionalPoints;
|
||||
}
|
||||
|
||||
public String insert(String intoSource){
|
||||
String ret = intoSource;
|
||||
List<TypeInsertPoint> offsets = new ArrayList<>();
|
||||
String ret = point.insert(intoSource, offsets);
|
||||
offsets.add(point);
|
||||
for(TypeInsertPoint insertPoint : inserts){
|
||||
ret = insertPoint.insert(ret, offsets);
|
||||
offsets.add(insertPoint);
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
public String getInsertString(){
|
||||
return point.getInsertString();
|
||||
}
|
||||
}
|
||||
|
@ -1,13 +1,10 @@
|
||||
package de.dhbwstuttgart.typedeployment;
|
||||
|
||||
import de.dhbwstuttgart.exceptions.NotImplementedException;
|
||||
import de.dhbwstuttgart.syntaxtree.*;
|
||||
import de.dhbwstuttgart.syntaxtree.type.*;
|
||||
import de.dhbwstuttgart.typeinference.ResultSet;
|
||||
import de.dhbwstuttgart.typeinference.constraints.Pair;
|
||||
import de.dhbwstuttgart.typeinference.result.*;
|
||||
import org.antlr.v4.runtime.Token;
|
||||
|
||||
import java.lang.reflect.Type;
|
||||
import java.util.*;
|
||||
|
||||
/**
|
||||
@ -16,114 +13,30 @@ import java.util.*;
|
||||
* 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
|
||||
*
|
||||
* Anmekung: Es wird nur ein RefType gleichzeitug eingesetzt.
|
||||
* Steht dieser mit anderen Typen in Verbindung, so müssen diese nicht eingesetzt werden
|
||||
* im Result set können nur TPHs mit <. Beziehung stehen
|
||||
* Steht ein Typ A über TPHs mit anderen Typen B in Verbindung, so lassen sich diese auch im nächsten Durchgang
|
||||
* inferieren, wenn A bereits eingesetzt wurde. Es werden dann eben zusätzliche Generics entstehen
|
||||
*/
|
||||
public class TypeInsertFactory {
|
||||
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){
|
||||
for(Set<Pair> pairs : withResults.results)
|
||||
ret.add(new TypeInsert(createInsertPoints(
|
||||
field.getType(), field.getType().getOffset(), cl, null, pairs)));
|
||||
}
|
||||
}
|
||||
|
||||
for(Method m : cl.getMethods()){
|
||||
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()){
|
||||
for(Set<Pair> pairs : withResults.results)
|
||||
ret.add(new TypeInsert(createInsertPoints(
|
||||
param.getType(), param.getType().getOffset(), cl, m, pairs)));
|
||||
}
|
||||
}
|
||||
}
|
||||
return ret;
|
||||
public static Set<TypeInsert> createTypeInsertPoints(SourceFile forSourcefile, ResultSet withResults){
|
||||
return new TypeInsertPlacer().getTypeInserts(forSourcefile, withResults);
|
||||
}
|
||||
|
||||
private static Set<TypeInsertPoint> createInsertPoints(RefTypeOrTPHOrWildcardOrGeneric type, Token offset, ClassOrInterface cl, Method m,
|
||||
Set<Pair> pairs) {
|
||||
public static TypeInsert createInsertPoints(RefTypeOrTPHOrWildcardOrGeneric type, Token offset, ClassOrInterface cl, Method m,
|
||||
ResultSet resultSet) {
|
||||
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;
|
||||
ResolvedType resolvedType = resultSet.resolveType(type);
|
||||
TypeInsertPoint insertPoint = new TypeInsertPoint(offset,
|
||||
new TypeToInsertString(resolvedType.resolvedType).insert);
|
||||
return new TypeInsert(insertPoint, new HashSet<>(Arrays.asList(createGenericInsert(resolvedType.additionalGenerics, cl, m))));
|
||||
}
|
||||
|
||||
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){
|
||||
private static TypeInsertPoint createGenericInsert(Set<GenericInsertPair> toInsert, ClassOrInterface cl, Method m){
|
||||
//Momentan wird Methode ignoriert. Parameter werden immer als Klassenparameter angefügt:
|
||||
//Offset zum Einstzen bestimmen:
|
||||
Token offset;
|
||||
@ -141,7 +54,7 @@ public class TypeInsertFactory {
|
||||
|
||||
//Alle einzusetzenden Generics und deren Bounds bestimmen:
|
||||
HashMap<TypePlaceholder, HashSet<TypePlaceholder>> genericsAndBounds = new HashMap<>();
|
||||
for(Pair p : toInsert){
|
||||
for(GenericInsertPair p : toInsert){
|
||||
if(!genericsAndBounds.containsKey(p.TA1)){
|
||||
genericsAndBounds.put((TypePlaceholder) p.TA1, new HashSet<>());
|
||||
}
|
||||
@ -173,4 +86,57 @@ public class TypeInsertFactory {
|
||||
}
|
||||
return new TypeInsertPoint(offset, insert + end);
|
||||
}
|
||||
}
|
||||
|
||||
class TypeToInsertString implements ResultSetVisitor{
|
||||
String insert = "";
|
||||
|
||||
TypeToInsertString(RefTypeOrTPHOrWildcardOrGeneric type){
|
||||
type.accept(this);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(PairTPHsmallerTPH p) {
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(PairTPHequalRefType p) {
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(RefType resolved) {
|
||||
insert = resolved.getName().toString();
|
||||
if(resolved.getParaList().size() > 0){
|
||||
insert += "<";
|
||||
Iterator<RefTypeOrTPHOrWildcardOrGeneric> iterator = resolved.getParaList().iterator();
|
||||
while(iterator.hasNext()){
|
||||
RefTypeOrTPHOrWildcardOrGeneric typeParam = iterator.next();
|
||||
insert += new TypeToInsertString(typeParam).insert;
|
||||
if(iterator.hasNext())insert += ", ";
|
||||
}
|
||||
insert += ">";
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(GenericRefType genericRefType) {
|
||||
insert += genericRefType.getName();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(SuperWildcardType superWildcardType) {
|
||||
insert += "? super " + new TypeToInsertString(superWildcardType.getInnerType()).insert;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(TypePlaceholder typePlaceholder) {
|
||||
insert += typePlaceholder.getName();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(ExtendsWildcardType extendsWildcardType) {
|
||||
insert += "? extends " + new TypeToInsertString(extendsWildcardType.getInnerType()).insert;
|
||||
}
|
||||
}
|
76
src/de/dhbwstuttgart/typedeployment/TypeInsertPlacer.java
Normal file
76
src/de/dhbwstuttgart/typedeployment/TypeInsertPlacer.java
Normal file
@ -0,0 +1,76 @@
|
||||
package de.dhbwstuttgart.typedeployment;
|
||||
|
||||
import de.dhbwstuttgart.exceptions.NotImplementedException;
|
||||
import de.dhbwstuttgart.syntaxtree.*;
|
||||
import de.dhbwstuttgart.syntaxtree.statement.BreakStmt;
|
||||
import de.dhbwstuttgart.syntaxtree.statement.LambdaExpression;
|
||||
import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
|
||||
import de.dhbwstuttgart.typeinference.result.ResultSet;
|
||||
|
||||
import java.util.HashSet;
|
||||
import java.util.Set;
|
||||
|
||||
public class TypeInsertPlacer extends AbstractASTWalker{
|
||||
Set<TypeInsert> inserts = new HashSet<>();
|
||||
private ResultSet withResults;
|
||||
|
||||
public Set<TypeInsert> getTypeInserts(SourceFile forSourceFile, ResultSet withResults){
|
||||
this.withResults = withResults;
|
||||
forSourceFile.accept(this);
|
||||
return inserts;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(ClassOrInterface classOrInterface) {
|
||||
TypeInsertPlacerClass cl = new TypeInsertPlacerClass(classOrInterface, withResults);
|
||||
this.inserts.addAll(cl.inserts);
|
||||
}
|
||||
}
|
||||
|
||||
class TypeInsertPlacerClass extends AbstractASTWalker{
|
||||
protected final ResultSet results;
|
||||
protected final ClassOrInterface cl;
|
||||
public final Set<TypeInsert> inserts = new HashSet<>();
|
||||
private Method method;
|
||||
|
||||
TypeInsertPlacerClass(ClassOrInterface forClass, ResultSet withResults){
|
||||
this.cl = forClass;
|
||||
this.method = null;
|
||||
this.results = withResults;
|
||||
forClass.accept(this);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(Method method) {
|
||||
this.method = method;
|
||||
if(method.getReturnType() instanceof TypePlaceholder)
|
||||
inserts.add(TypeInsertFactory.createInsertPoints(
|
||||
method.getReturnType(), method.getReturnType().getOffset(), cl, method, results));
|
||||
super.visit(method);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(Field field) {
|
||||
if(field.getType() instanceof TypePlaceholder){
|
||||
inserts.add(TypeInsertFactory.createInsertPoints(
|
||||
field.getType(), field.getType().getOffset(), cl, method, results));
|
||||
}
|
||||
super.visit(field);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(ParameterList params) {
|
||||
for(FormalParameter param : params){
|
||||
if(param.getType() instanceof TypePlaceholder)
|
||||
inserts.add(TypeInsertFactory.createInsertPoints(
|
||||
param.getType(), param.getType().getOffset(), cl, method, results));
|
||||
}
|
||||
super.visit(params);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(LambdaExpression lambdaExpression) {
|
||||
//Lambda-Ausdrücke brauchen keine Typeinsetzungen
|
||||
}
|
||||
|
||||
}
|
@ -6,12 +6,12 @@ import java.util.List;
|
||||
import java.util.stream.Collectors;
|
||||
|
||||
public class TypeInsertPoint {
|
||||
Token point;
|
||||
public final Token point;
|
||||
private String insertString;
|
||||
|
||||
public TypeInsertPoint(Token point, String toInsert){
|
||||
this.point = point;
|
||||
this.insertString = (toInsert.length()>1) ? toInsert + " " : toInsert;
|
||||
this.insertString = (toInsert.endsWith(" ")) ? toInsert : toInsert + " " ;
|
||||
}
|
||||
|
||||
public String insert(String intoSource, List<TypeInsertPoint> additionalOffset){
|
||||
@ -21,4 +21,8 @@ public class TypeInsertPoint {
|
||||
.mapToInt((typeInsertPoint -> typeInsertPoint.insertString.length())).sum();
|
||||
return new StringBuilder(intoSource).insert(point.getStartIndex()+offset, insertString).toString();
|
||||
}
|
||||
|
||||
public String getInsertString() {
|
||||
return insertString;
|
||||
}
|
||||
}
|
||||
|
@ -1,36 +0,0 @@
|
||||
package de.dhbwstuttgart.typeinference;
|
||||
|
||||
import de.dhbwstuttgart.exceptions.NotImplementedException;
|
||||
import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
|
||||
import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
|
||||
import de.dhbwstuttgart.typeinference.constraints.Pair;
|
||||
import de.dhbwstuttgart.typeinference.unify.model.PairOperator;
|
||||
import de.dhbwstuttgart.typeinference.unify.model.UnifyPair;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
import java.util.Set;
|
||||
|
||||
public class ResultSet {
|
||||
public final Set<Set<Pair>> results;
|
||||
public ResultSet(Set<Set<Pair>> results){
|
||||
this.results = results;
|
||||
}
|
||||
|
||||
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 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) || pair.TA2.equals(type)){
|
||||
ret.add(pair);
|
||||
}
|
||||
//}
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
}
|
@ -0,0 +1,26 @@
|
||||
package de.dhbwstuttgart.typeinference.result;
|
||||
|
||||
import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
|
||||
import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
|
||||
import de.dhbwstuttgart.typeinference.constraints.Pair;
|
||||
|
||||
public class GenericInsertPair {
|
||||
public TypePlaceholder TA1;
|
||||
public TypePlaceholder TA2;
|
||||
|
||||
public GenericInsertPair(TypePlaceholder additionalTPH, TypePlaceholder superType) {
|
||||
TA1 = additionalTPH;
|
||||
TA2 = superType;
|
||||
}
|
||||
|
||||
public GenericInsertPair(Pair pair) {
|
||||
TA1 = (TypePlaceholder) pair.TA1;
|
||||
TA2 = (TypePlaceholder) pair.TA2;
|
||||
}
|
||||
|
||||
public boolean contains(TypePlaceholder additionalTPH) {
|
||||
if(TA1.equals(additionalTPH))return true;
|
||||
if(TA2.equals(additionalTPH))return true;
|
||||
return false;
|
||||
}
|
||||
}
|
@ -0,0 +1,24 @@
|
||||
package de.dhbwstuttgart.typeinference.result;
|
||||
|
||||
import de.dhbwstuttgart.syntaxtree.type.RefType;
|
||||
import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
|
||||
import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
|
||||
|
||||
/**
|
||||
* Steht für A =. RefType
|
||||
*/
|
||||
public class PairTPHequalRefType extends ResultPair{
|
||||
public final TypePlaceholder left;
|
||||
public final RefTypeOrTPHOrWildcardOrGeneric right;
|
||||
|
||||
public PairTPHequalRefType(TypePlaceholder left, RefTypeOrTPHOrWildcardOrGeneric right){
|
||||
super(left, right);
|
||||
this.left = left;
|
||||
this.right = right;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void accept(ResultSetVisitor visitor) {
|
||||
visitor.visit(this);
|
||||
}
|
||||
}
|
@ -0,0 +1,23 @@
|
||||
package de.dhbwstuttgart.typeinference.result;
|
||||
|
||||
import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
|
||||
import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
|
||||
|
||||
/**
|
||||
* Steht für: A <. B
|
||||
*/
|
||||
public class PairTPHsmallerTPH extends ResultPair{
|
||||
public final TypePlaceholder left;
|
||||
public final TypePlaceholder right;
|
||||
|
||||
public PairTPHsmallerTPH(TypePlaceholder left, TypePlaceholder right){
|
||||
super(left, right);
|
||||
this.left = left;
|
||||
this.right = right;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void accept(ResultSetVisitor visitor) {
|
||||
visitor.visit(this);
|
||||
}
|
||||
}
|
17
src/de/dhbwstuttgart/typeinference/result/ResolvedType.java
Normal file
17
src/de/dhbwstuttgart/typeinference/result/ResolvedType.java
Normal file
@ -0,0 +1,17 @@
|
||||
package de.dhbwstuttgart.typeinference.result;
|
||||
|
||||
import de.dhbwstuttgart.syntaxtree.type.GenericRefType;
|
||||
import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
|
||||
import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
|
||||
|
||||
import java.util.Set;
|
||||
|
||||
public class ResolvedType{
|
||||
public final RefTypeOrTPHOrWildcardOrGeneric resolvedType;
|
||||
public final Set<GenericInsertPair> additionalGenerics;
|
||||
|
||||
public ResolvedType(RefTypeOrTPHOrWildcardOrGeneric resolvedType, Set<GenericInsertPair> additionalGenerics){
|
||||
this.resolvedType = resolvedType;
|
||||
this.additionalGenerics = additionalGenerics;
|
||||
}
|
||||
}
|
26
src/de/dhbwstuttgart/typeinference/result/ResultPair.java
Normal file
26
src/de/dhbwstuttgart/typeinference/result/ResultPair.java
Normal file
@ -0,0 +1,26 @@
|
||||
package de.dhbwstuttgart.typeinference.result;
|
||||
|
||||
import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
|
||||
|
||||
/**
|
||||
* Paare, welche das Unifikationsergebnis darstellen
|
||||
*/
|
||||
public abstract class ResultPair {
|
||||
private final RefTypeOrTPHOrWildcardOrGeneric left;
|
||||
private final RefTypeOrTPHOrWildcardOrGeneric right;
|
||||
|
||||
public abstract void accept(ResultSetVisitor visitor);
|
||||
|
||||
public ResultPair(RefTypeOrTPHOrWildcardOrGeneric left, RefTypeOrTPHOrWildcardOrGeneric right){
|
||||
this.left = left;
|
||||
this.right = right;
|
||||
}
|
||||
|
||||
public RefTypeOrTPHOrWildcardOrGeneric getLeft() {
|
||||
return left;
|
||||
}
|
||||
|
||||
public RefTypeOrTPHOrWildcardOrGeneric getRight() {
|
||||
return right;
|
||||
}
|
||||
}
|
229
src/de/dhbwstuttgart/typeinference/result/ResultSet.java
Normal file
229
src/de/dhbwstuttgart/typeinference/result/ResultSet.java
Normal file
@ -0,0 +1,229 @@
|
||||
package de.dhbwstuttgart.typeinference.result;
|
||||
|
||||
import de.dhbwstuttgart.syntaxtree.AbstractASTWalker;
|
||||
import de.dhbwstuttgart.syntaxtree.type.*;
|
||||
import de.dhbwstuttgart.typeinference.constraints.Pair;
|
||||
|
||||
import javax.xml.transform.Result;
|
||||
import java.util.ArrayList;
|
||||
import java.util.HashSet;
|
||||
import java.util.List;
|
||||
import java.util.Set;
|
||||
|
||||
public class ResultSet {
|
||||
public final Set<ResultPair> results;
|
||||
public ResultSet(Set<ResultPair> results){
|
||||
this.results = results;
|
||||
}
|
||||
|
||||
public ResolvedType resolveType(RefTypeOrTPHOrWildcardOrGeneric type) {
|
||||
if(type instanceof TypePlaceholder)
|
||||
return new Resolver(this).resolve((TypePlaceholder)type);
|
||||
if(type instanceof RefType){
|
||||
RelatedTypeWalker related = new RelatedTypeWalker(null, this);
|
||||
type.accept(related);
|
||||
return new ResolvedType(type, related.relatedTPHs);
|
||||
}else{
|
||||
return new ResolvedType(type,new HashSet<>());
|
||||
}
|
||||
}
|
||||
|
||||
//TODO Beim Einsetzen eines Generics, müssen die new und Methodenaufrufe verändert werden
|
||||
|
||||
|
||||
}
|
||||
|
||||
class Resolver implements ResultSetVisitor {
|
||||
private final ResultSet result;
|
||||
private TypePlaceholder toResolve;
|
||||
private RefTypeOrTPHOrWildcardOrGeneric resolved;
|
||||
private final Set<GenericInsertPair> additionalTPHs = new HashSet<>();
|
||||
|
||||
public Resolver(ResultSet resultPairs){
|
||||
this.result = resultPairs;
|
||||
}
|
||||
|
||||
public ResolvedType resolve(TypePlaceholder tph){
|
||||
toResolve = tph;
|
||||
resolved = null;
|
||||
for(ResultPair resultPair : result.results){
|
||||
resultPair.accept(this);
|
||||
}
|
||||
if(resolved==null){//TPH kommt nicht im Result vor:
|
||||
}
|
||||
|
||||
return new ResolvedType(resolved, additionalTPHs);//resolved;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(PairTPHsmallerTPH p) {
|
||||
if(p.left.equals(toResolve)){
|
||||
additionalTPHs.add(new GenericInsertPair(p.left, p.right));
|
||||
additionalTPHs.addAll(new RelatedTypeWalker(p.right, result).relatedTPHs);
|
||||
}
|
||||
if(p.right.equals(toResolve))
|
||||
additionalTPHs.addAll(new RelatedTypeWalker(p.left, result).relatedTPHs);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(PairTPHequalRefType p) {
|
||||
if(p.left.equals(toResolve)){
|
||||
resolved = p.right;
|
||||
RelatedTypeWalker related = new RelatedTypeWalker(null, result);
|
||||
p.right.accept(related);
|
||||
additionalTPHs.addAll(related.relatedTPHs);
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(RefType refType) {
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(GenericRefType genericRefType) {
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(SuperWildcardType superWildcardType) {
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(TypePlaceholder typePlaceholder) {
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(ExtendsWildcardType extendsWildcardType) {
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
* Sucht aus dem Result Set den Sub/supertyp für einen TPH
|
||||
*/
|
||||
class TPHResolver implements ResultSetVisitor {
|
||||
|
||||
private final TypePlaceholder tph;
|
||||
Set<GenericInsertPair> resolved = new HashSet<>();
|
||||
|
||||
TPHResolver(TypePlaceholder tph, ResultSet resultSet){
|
||||
this.tph = tph;
|
||||
for(ResultPair p : resultSet.results){
|
||||
p.accept(this);
|
||||
}
|
||||
if(resolved.size() == 0){
|
||||
resolved.add(new GenericInsertPair(tph, null));
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(PairTPHsmallerTPH p) {
|
||||
if(p.left.equals(tph) || p.right.equals(tph)){
|
||||
resolved.add(new GenericInsertPair(p.left, p.right));
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(PairTPHequalRefType p) {
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(RefType refType) {
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(GenericRefType genericRefType) {
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(SuperWildcardType superWildcardType) {
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(TypePlaceholder typePlaceholder) {
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(ExtendsWildcardType extendsWildcardType) {
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
class RelatedTypeWalker implements ResultSetVisitor {
|
||||
|
||||
final Set<GenericInsertPair> relatedTPHs = new HashSet<>();
|
||||
private final TypePlaceholder toResolve;
|
||||
private final ResultSet resultSet;
|
||||
|
||||
/**
|
||||
* Läuft über das resultSet und speichert alle TPHs, welche mit start in Verbindung stehen
|
||||
* @param start
|
||||
* @param resultSet
|
||||
*/
|
||||
RelatedTypeWalker(TypePlaceholder start, ResultSet resultSet){
|
||||
this.toResolve = start;
|
||||
this.resultSet = resultSet;
|
||||
for(ResultPair p : resultSet.results){
|
||||
p.accept(this);
|
||||
p.accept(this);
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(PairTPHsmallerTPH p) {
|
||||
if(p.getRight().equals(toResolve)){
|
||||
relatedTPHs.addAll(new TPHResolver(p.right, resultSet).resolved);
|
||||
relatedTPHs.addAll(new RelatedTypeWalker(p.right, resultSet).relatedTPHs);
|
||||
}
|
||||
if(p.getLeft().equals(toResolve)){
|
||||
relatedTPHs.addAll(new TPHResolver(p.left, resultSet).resolved);
|
||||
relatedTPHs.addAll(new RelatedTypeWalker(p.left, resultSet).relatedTPHs);
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(PairTPHequalRefType p) {
|
||||
if(p.getLeft().equals(toResolve)){
|
||||
p.getRight().accept(this);
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
Die folgenden Funktionen fügen alle TPHs an die relatedTPHs an, denen sie begegnen:
|
||||
*/
|
||||
|
||||
@Override
|
||||
public void visit(RefType refType) {
|
||||
for(RefTypeOrTPHOrWildcardOrGeneric param : refType.getParaList()){
|
||||
param.accept(this);
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(SuperWildcardType superWildcardType) {
|
||||
superWildcardType.getInnerType().accept(this);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(TypePlaceholder typePlaceholder) {
|
||||
relatedTPHs.addAll(new TPHResolver(typePlaceholder, resultSet).resolved);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(ExtendsWildcardType extendsWildcardType) {
|
||||
extendsWildcardType.getInnerType().accept(this);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(GenericRefType genericRefType) {
|
||||
}
|
||||
}
|
@ -0,0 +1,18 @@
|
||||
package de.dhbwstuttgart.typeinference.result;
|
||||
|
||||
import de.dhbwstuttgart.syntaxtree.type.*;
|
||||
|
||||
public interface ResultSetVisitor {
|
||||
void visit(PairTPHsmallerTPH p);
|
||||
void visit(PairTPHequalRefType p);
|
||||
|
||||
void visit(RefType refType);
|
||||
|
||||
void visit(GenericRefType genericRefType);
|
||||
|
||||
void visit(SuperWildcardType superWildcardType);
|
||||
|
||||
void visit(TypePlaceholder typePlaceholder);
|
||||
|
||||
void visit(ExtendsWildcardType extendsWildcardType);
|
||||
}
|
@ -1,302 +1,77 @@
|
||||
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.exceptions.DebugException;
|
||||
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.syntaxtree.factory.ASTFactory;
|
||||
import de.dhbwstuttgart.syntaxtree.statement.Statement;
|
||||
import de.dhbwstuttgart.typecheck.JavaClassName;
|
||||
import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceBlockInformation;
|
||||
import de.dhbwstuttgart.typeinference.constraints.Constraint;
|
||||
import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceInformation;
|
||||
import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
|
||||
import de.dhbwstuttgart.typeinference.constraints.ConstraintsFactory;
|
||||
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{
|
||||
public class TYPE {
|
||||
|
||||
private final TypeInferenceBlockInformation info;
|
||||
private final ConstraintSet constraintsSet = new ConstraintSet();
|
||||
private final List<SourceFile> sfs;
|
||||
|
||||
public TYPE(TypeInferenceBlockInformation info){
|
||||
this.info = info;
|
||||
public TYPE(List<SourceFile> sourceFiles){
|
||||
sfs = sourceFiles;
|
||||
}
|
||||
|
||||
|
||||
public ConstraintSet getConstraints() {
|
||||
return constraintsSet;
|
||||
}
|
||||
|
||||
@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());
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(Assign assign) {
|
||||
assign.lefSide.accept(this);
|
||||
assign.rightSide.accept(this);
|
||||
constraintsSet.addUndConstraint(ConstraintsFactory.createPair(
|
||||
assign.rightSide.getType(), assign.lefSide.getType(), PairOperator.SMALLERDOT, info));
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(Binary binary) {
|
||||
throw new NotImplementedException();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(Block block) {
|
||||
for(Statement stmt : block.getStatements()){
|
||||
stmt.accept(this);
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(CastExpr castExpr) {
|
||||
throw new NotImplementedException();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(EmptyStmt emptyStmt) {
|
||||
//Nothing :)
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(FieldVar fieldVar) {
|
||||
fieldVar.receiver.accept(this);
|
||||
Set<Constraint> oderConstraints = new HashSet<>();
|
||||
for(FieldAssumption fieldAssumption : info.getFields(fieldVar.fieldVarName)){
|
||||
Constraint constraint = new Constraint();
|
||||
constraint.add(ConstraintsFactory.createPair(
|
||||
fieldVar.receiver.getType(),fieldAssumption.getReceiverType(), info));
|
||||
constraint.add(ConstraintsFactory.createPair(
|
||||
fieldVar.getType(),fieldAssumption.getType(), info));
|
||||
oderConstraints.add(constraint);
|
||||
}
|
||||
if(oderConstraints.size() == 0)
|
||||
throw new TypeinferenceException("Kein Feld "+fieldVar.fieldVarName+ " gefunden", fieldVar.getOffset());
|
||||
constraintsSet.addOderConstraint(oderConstraints);
|
||||
}
|
||||
|
||||
@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(LocalVar localVar) {
|
||||
// Es werden nur bei Feldvariablen Constraints generiert. Lokale Variablen sind eindeutig
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(LocalVarDecl localVarDecl) {
|
||||
//Hier ist nichts zu tun. Allen lokalen Variablen bekommen beim parsen schon den korrekten Typ
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(MethodCall methodCall) {
|
||||
methodCall.receiver.accept(this);
|
||||
constraintsSet.addAll(this.getArgumentListConstraints(methodCall, info));
|
||||
//Overloading:
|
||||
Set<Constraint> methodConstraints = new HashSet<>();
|
||||
for(MethodAssumption m : this.getMethods(methodCall.name, methodCall.arglist, info)){
|
||||
methodConstraints.add(generateConstraint(methodCall, m, info));
|
||||
}
|
||||
if(methodConstraints.size()<1){
|
||||
throw new TypeinferenceException("Methode "+methodCall.name+" ist nicht vorhanden!",methodCall.getOffset());
|
||||
}
|
||||
constraintsSet.addOderConstraint(methodConstraints);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(NewClass methodCall) {
|
||||
constraintsSet.addAll(this.getArgumentListConstraints(methodCall, info));
|
||||
//Overloading:
|
||||
Set<Constraint> methodConstraints = new HashSet<>();
|
||||
for(MethodAssumption m : this.getConstructors(info, (RefType) methodCall.getType(), methodCall.getArgumentList())){
|
||||
methodConstraints.add(generateConstructorConstraint(methodCall, m, info));
|
||||
}
|
||||
if(methodConstraints.size()<1){
|
||||
throw new TypeinferenceException("Konstruktor in Klasse "+methodCall.getType().toString()+" ist nicht vorhanden!",methodCall.getOffset());
|
||||
}
|
||||
constraintsSet.addOderConstraint(methodConstraints);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(NewArray newArray) {
|
||||
throw new NotImplementedException();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(Receiver receiver) {
|
||||
receiver.expr.accept(this);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(Return returnExpr) {
|
||||
returnExpr.retexpr.accept(this);
|
||||
constraintsSet.addUndConstraint(ConstraintsFactory.createPair(
|
||||
returnExpr.getType(),info.getCurrentTypeScope().getReturnType(), PairOperator.EQUALSDOT, info));
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(ReturnVoid aReturn) {
|
||||
visit((Return) aReturn);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(StaticClassName staticClassName) {
|
||||
throw new NotImplementedException();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(Super aSuper) {
|
||||
throw new NotImplementedException();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(This aThis) {
|
||||
constraintsSet.addUndConstraint(ConstraintsFactory.createPair( aThis.getType(), info.getCurrentClass().getType(), PairOperator.EQUALSDOT, info));
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(UnaryPlus unaryPlus) {
|
||||
throw new NotImplementedException();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(WhileStmt whileStmt) {
|
||||
throw new NotImplementedException();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(Null aNull) {
|
||||
throw new NotImplementedException();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(Literal literal) {
|
||||
throw new NotImplementedException();
|
||||
}
|
||||
|
||||
/*
|
||||
METHOD CALL Section:
|
||||
*/
|
||||
|
||||
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.EQUALSDOT, info));
|
||||
methodConstraint.addAll(generateParameterConstraints(forMethod, assumption, info));
|
||||
return methodConstraint;
|
||||
}
|
||||
|
||||
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(foMethod.arglist.getArguments().get(i).getType(),
|
||||
assumption.getArgTypes().get(i), PairOperator.SMALLERDOT, info));
|
||||
ConstraintSet ret = new ConstraintSet();
|
||||
TypeInferenceInformation info = getTypeInferenceInformation();
|
||||
for(SourceFile sf : sfs)
|
||||
for (ClassOrInterface cl : sf.KlassenVektor) {
|
||||
ret.addAll(getConstraintsClass(cl ,info));
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
||||
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())));
|
||||
private ConstraintSet getConstraintsClass(ClassOrInterface cl, TypeInferenceInformation info) {
|
||||
ConstraintSet ret = new ConstraintSet();
|
||||
for(Method m : cl.getMethods()){
|
||||
ret.addAll(getConstraintsMethod(m,info, cl));
|
||||
}
|
||||
for(ClassOrInterface cl : info.getAvailableClasses()){
|
||||
for(Method m : cl.getMethods()){
|
||||
if(m.getName().equals(name) &&
|
||||
m.getParameterList().getFormalparalist().size() == numArgs){
|
||||
RefTypeOrTPHOrWildcardOrGeneric retType = info.checkGTV(m.getType());
|
||||
for(Constructor m : cl.getConstructors()){
|
||||
ret.addAll(getConstraintsConstructor(m,info, cl));
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
ret.add(new MethodAssumption(cl.getType(), retType, convertParams(m.getParameterList(),info)));
|
||||
private TypeInferenceInformation getTypeInferenceInformation() {
|
||||
ClassLoader classLoader = ClassLoader.getSystemClassLoader();
|
||||
Set<ClassOrInterface> classes = new HashSet<>();
|
||||
for(SourceFile sourceFile : sfs){
|
||||
for(JavaClassName importName : sourceFile.imports){
|
||||
System.out.println(importName);
|
||||
try {
|
||||
classes.add(ASTFactory.createClass(classLoader.loadClass(importName.toString())));
|
||||
} catch (ClassNotFoundException e) {
|
||||
throw new DebugException("Klasse " + importName + " konnte nicht geladen werden");
|
||||
}
|
||||
}
|
||||
classes.addAll(sourceFile.KlassenVektor);
|
||||
}
|
||||
|
||||
return new TypeInferenceInformation(classes);
|
||||
}
|
||||
|
||||
private ConstraintSet getConstraintsMethod(Method m, TypeInferenceInformation info, ClassOrInterface currentClass) {
|
||||
if(m.block == null)return new ConstraintSet(); //Abstrakte Methoden generieren keine Constraints
|
||||
TypeInferenceBlockInformation blockInfo = new TypeInferenceBlockInformation(info.getAvailableClasses(), currentClass, m);
|
||||
TYPEStmt methodScope = new TYPEStmt(blockInfo);
|
||||
m.block.accept(methodScope);
|
||||
return methodScope.getConstraints();
|
||||
}
|
||||
|
||||
private ConstraintSet getConstraintsConstructor(Constructor m, TypeInferenceInformation info, ClassOrInterface currentClass) {
|
||||
TypeInferenceBlockInformation blockInfo = new TypeInferenceBlockInformation(info.getAvailableClasses(), currentClass, null);
|
||||
TYPEStmt methodScope = new TYPEStmt(blockInfo);
|
||||
//for(Statement stmt : m.fieldInitializations)stmt.accept(methodScope);
|
||||
ConstraintSet ret = this.getConstraintsMethod(m, info, currentClass);
|
||||
ret.addAll(methodScope.getConstraints());
|
||||
return ret;
|
||||
}
|
||||
|
||||
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()));
|
||||
}
|
||||
return params;
|
||||
}
|
||||
|
||||
public ConstraintSet getArgumentListConstraints(MethodCall forMethod, TypeInferenceBlockInformation info) {
|
||||
TYPE ret = new TYPE(info);
|
||||
for(int i = 0;i<forMethod.arglist.getArguments().size();i++){
|
||||
forMethod.arglist.getArguments().get(i).accept(ret);
|
||||
}
|
||||
return ret.constraintsSet;
|
||||
}
|
||||
|
||||
public List<MethodAssumption> getConstructors(TypeInferenceBlockInformation info, RefType ofType, ArgumentList argList){
|
||||
List<MethodAssumption> ret = new ArrayList<>();
|
||||
for(ClassOrInterface cl : info.getAvailableClasses()){
|
||||
if(cl.getClassName().equals(ofType.getName())){
|
||||
for(Method m : cl.getConstructors()){
|
||||
if(m.getParameterList().getFormalparalist().size() == argList.getArguments().size()){
|
||||
ret.add(new MethodAssumption(ofType, ofType, convertParams(m.getParameterList(), info)));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
protected Constraint<Pair> generateConstructorConstraint(NewClass forConstructor, MethodAssumption assumption, TypeInferenceBlockInformation info){
|
||||
Constraint methodConstraint = new Constraint();
|
||||
methodConstraint.add(ConstraintsFactory.createPair(assumption.getReturnType(), forConstructor.getType(), PairOperator.SMALLERDOT, info));
|
||||
methodConstraint.addAll(generateParameterConstraints(forConstructor, assumption, info));
|
||||
return methodConstraint;
|
||||
}
|
||||
|
||||
}
|
||||
|
327
src/de/dhbwstuttgart/typeinference/typeAlgo/TYPEStmt.java
Normal file
327
src/de/dhbwstuttgart/typeinference/typeAlgo/TYPEStmt.java
Normal file
@ -0,0 +1,327 @@
|
||||
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.parser.SyntaxTreeGenerator.AssignToLocal;
|
||||
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;
|
||||
import de.dhbwstuttgart.typeinference.constraints.Constraint;
|
||||
import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
|
||||
import de.dhbwstuttgart.typeinference.constraints.ConstraintsFactory;
|
||||
import de.dhbwstuttgart.typeinference.constraints.Pair;
|
||||
import de.dhbwstuttgart.typeinference.unify.model.PairOperator;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.HashSet;
|
||||
import java.util.List;
|
||||
import java.util.Set;
|
||||
import java.util.stream.Collectors;
|
||||
|
||||
public class TYPEStmt implements StatementVisitor{
|
||||
|
||||
private final TypeInferenceBlockInformation info;
|
||||
private final ConstraintSet constraintsSet = new ConstraintSet();
|
||||
|
||||
public TYPEStmt(TypeInferenceBlockInformation info){
|
||||
this.info = info;
|
||||
}
|
||||
|
||||
public ConstraintSet getConstraints() {
|
||||
return constraintsSet;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(ArgumentList arglist) {
|
||||
for(int i = 0;i<arglist.getArguments().size();i++){
|
||||
arglist.getArguments().get(i).accept(this);
|
||||
}
|
||||
}
|
||||
|
||||
@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:
|
||||
TYPEStmt lambdaScope = new TYPEStmt(new TypeInferenceBlockInformation(info, lambdaExpression));
|
||||
lambdaExpression.methodBody.accept(lambdaScope);
|
||||
constraintsSet.addAll(lambdaScope.getConstraints());
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(Assign assign) {
|
||||
assign.lefSide.accept(this);
|
||||
assign.rightSide.accept(this);
|
||||
constraintsSet.addUndConstraint(ConstraintsFactory.createPair(
|
||||
assign.rightSide.getType(), assign.lefSide.getType(), PairOperator.SMALLERDOT, info));
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(Binary binary) {
|
||||
throw new NotImplementedException();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(Block block) {
|
||||
for(Statement stmt : block.getStatements()){
|
||||
stmt.accept(this);
|
||||
}
|
||||
}
|
||||
@Override
|
||||
public void visit(BreakStmt breakStmt){throw new NotImplementedException();}
|
||||
|
||||
@Override
|
||||
public void visit(CastExpr castExpr) {
|
||||
throw new NotImplementedException();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(EmptyStmt emptyStmt) {
|
||||
//Nothing :)
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(FieldVar fieldVar) {
|
||||
fieldVar.receiver.accept(this);
|
||||
Set<Constraint> oderConstraints = new HashSet<>();
|
||||
for(FieldAssumption fieldAssumption : info.getFields(fieldVar.fieldVarName)){
|
||||
Constraint constraint = new Constraint();
|
||||
constraint.add(ConstraintsFactory.createPair(
|
||||
fieldVar.receiver.getType(),fieldAssumption.getReceiverType(), info));
|
||||
constraint.add(ConstraintsFactory.createPair(
|
||||
fieldVar.getType(),fieldAssumption.getType(), info));
|
||||
oderConstraints.add(constraint);
|
||||
}
|
||||
if(oderConstraints.size() == 0)
|
||||
throw new TypeinferenceException("Kein Feld "+fieldVar.fieldVarName+ " gefunden", fieldVar.getOffset());
|
||||
constraintsSet.addOderConstraint(oderConstraints);
|
||||
}
|
||||
|
||||
@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(LocalVar localVar) {
|
||||
// Es werden nur bei Feldvariablen Constraints generiert. Lokale Variablen sind eindeutig
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(LocalVarDecl localVarDecl) {
|
||||
//Hier ist nichts zu tun. Allen lokalen Variablen bekommen beim parsen schon den korrekten Typ
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(MethodCall methodCall) {
|
||||
methodCall.receiver.accept(this);
|
||||
//Overloading:
|
||||
Set<Constraint> methodConstraints = new HashSet<>();
|
||||
for(MethodAssumption m : this.getMethods(methodCall.name, methodCall.arglist, info)){
|
||||
methodConstraints.add(generateConstraint(methodCall, m, info));
|
||||
}
|
||||
if(methodConstraints.size()<1){
|
||||
throw new TypeinferenceException("Methode "+methodCall.name+" ist nicht vorhanden!",methodCall.getOffset());
|
||||
}
|
||||
constraintsSet.addOderConstraint(methodConstraints);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(NewClass methodCall) {
|
||||
//Overloading:
|
||||
Set<Constraint> methodConstraints = new HashSet<>();
|
||||
for(MethodAssumption m : this.getConstructors(info, (RefType) methodCall.getType(), methodCall.getArgumentList())){
|
||||
methodConstraints.add(generateConstructorConstraint(methodCall, m, info));
|
||||
}
|
||||
if(methodConstraints.size()<1){
|
||||
throw new TypeinferenceException("Konstruktor in Klasse "+methodCall.getType().toString()+" ist nicht vorhanden!",methodCall.getOffset());
|
||||
}
|
||||
constraintsSet.addOderConstraint(methodConstraints);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(NewArray newArray) {
|
||||
throw new NotImplementedException();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(Receiver receiver) {
|
||||
receiver.expr.accept(this);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(Return returnExpr) {
|
||||
returnExpr.retexpr.accept(this);
|
||||
constraintsSet.addUndConstraint(ConstraintsFactory.createPair(
|
||||
returnExpr.getType(),info.getCurrentTypeScope().getReturnType(), PairOperator.EQUALSDOT, info));
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(ReturnVoid aReturn) {
|
||||
visit((Return) aReturn);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(StaticClassName staticClassName) {
|
||||
//Hier entstehen keine Constraints
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(Super aSuper) {
|
||||
throw new NotImplementedException();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(This aThis) {
|
||||
constraintsSet.addUndConstraint(ConstraintsFactory.createPair( aThis.getType(), info.getCurrentClass().getType(), PairOperator.EQUALSDOT, info));
|
||||
}
|
||||
|
||||
@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) {
|
||||
//Hier gibt es nichts zu tun
|
||||
//throw new NotImplementedException();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(AssignToField assignLeftSide) {
|
||||
//Hier ist kein Code nötig. Es werden keine extra Constraints generiert
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(AssignToLocal assignLeftSide) {
|
||||
//Hier ist kein Code nötig. Es werden keine extra Constraints generiert
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(SuperCall superCall) {
|
||||
//TODO: Für einen super-Call werden keine Constraints erzeugt bisher
|
||||
}
|
||||
|
||||
/*
|
||||
METHOD CALL Section:
|
||||
*/
|
||||
|
||||
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.EQUALSDOT, info));
|
||||
methodConstraint.addAll(generateParameterConstraints(forMethod, assumption, info));
|
||||
return methodConstraint;
|
||||
}
|
||||
|
||||
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(foMethod.arglist.getArguments().get(i).getType(),
|
||||
assumption.getArgTypes().get(i), PairOperator.SMALLERDOT, info));
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
||||
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() == numArgs){
|
||||
RefTypeOrTPHOrWildcardOrGeneric retType = info.checkGTV(m.getType());
|
||||
|
||||
ret.add(new MethodAssumption(cl.getType(), retType, convertParams(m.getParameterList(),info)));
|
||||
}
|
||||
}
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
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()));
|
||||
}
|
||||
return params;
|
||||
}
|
||||
|
||||
public List<MethodAssumption> getConstructors(TypeInferenceBlockInformation info, RefType ofType, ArgumentList argList){
|
||||
List<MethodAssumption> ret = new ArrayList<>();
|
||||
for(ClassOrInterface cl : info.getAvailableClasses()){
|
||||
if(cl.getClassName().equals(ofType.getName())){
|
||||
for(Method m : cl.getConstructors()){
|
||||
if(m.getParameterList().getFormalparalist().size() == argList.getArguments().size()){
|
||||
ret.add(new MethodAssumption(ofType, ofType, convertParams(m.getParameterList(), info)));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
protected Constraint<Pair> generateConstructorConstraint(NewClass forConstructor, MethodAssumption assumption, TypeInferenceBlockInformation info){
|
||||
Constraint methodConstraint = new Constraint();
|
||||
methodConstraint.add(ConstraintsFactory.createPair(assumption.getReturnType(), forConstructor.getType(), PairOperator.SMALLERDOT, info));
|
||||
methodConstraint.addAll(generateParameterConstraints(forConstructor, assumption, info));
|
||||
return methodConstraint;
|
||||
}
|
||||
|
||||
}
|
8
test/javFiles/Import.jav
Normal file
8
test/javFiles/Import.jav
Normal file
@ -0,0 +1,8 @@
|
||||
import java.util.Vector;
|
||||
|
||||
class Import {
|
||||
void methode(){
|
||||
Vector v;
|
||||
v.add(v);
|
||||
}
|
||||
}
|
@ -1,14 +1,13 @@
|
||||
class Matrix extends Menge<Menge<Integer>> {
|
||||
import java.util.Vector;
|
||||
|
||||
class Matrix extends Vector<Vector<Integer>> {
|
||||
|
||||
Matrix mul_rec(Matrix m) {
|
||||
v1;
|
||||
v1 = new Menge<Integer>();
|
||||
v2;
|
||||
v2 = new Menge<Integer>();
|
||||
i;
|
||||
i = 0;
|
||||
auto v1 = new Vector<Integer>();
|
||||
auto v2 = new Vector<Integer>();
|
||||
auto i = 0;
|
||||
while(i < m.size()) {
|
||||
v;
|
||||
auto v;
|
||||
v = m.elementAt(i);
|
||||
v2.addElement(v.remove(v.size()-1));
|
||||
i++;
|
||||
@ -21,14 +20,14 @@ class Matrix extends Menge<Menge<Integer>> {
|
||||
ret = new Matrix();
|
||||
i = 0;
|
||||
while (i < this.size()) {
|
||||
ret.addElement(new Menge<Integer>());
|
||||
ret.addElement(new Vector<Integer>());
|
||||
i++;
|
||||
}
|
||||
}
|
||||
i = 0;
|
||||
while (i < this.size()) {
|
||||
int erg = 0;
|
||||
j;
|
||||
auto j;
|
||||
j = 0;
|
||||
while (j < v2.size()) {
|
||||
erg = erg + this.elementAt(i).elementAt(j).intValue()
|
||||
|
@ -1,3 +1,4 @@
|
||||
|
||||
class mathStruc<A> {
|
||||
|
||||
mathStruc(A a) { }
|
||||
|
7
test/parser/AssertTest.jav
Normal file
7
test/parser/AssertTest.jav
Normal file
@ -0,0 +1,7 @@
|
||||
class AssertTest
|
||||
{
|
||||
void assertMethod()
|
||||
{
|
||||
assert true;
|
||||
}
|
||||
}
|
7
test/parser/BreakTest.jav
Normal file
7
test/parser/BreakTest.jav
Normal file
@ -0,0 +1,7 @@
|
||||
class BreakTest
|
||||
{
|
||||
void methode()
|
||||
{
|
||||
break BREAKTEST;
|
||||
}
|
||||
}
|
@ -1,6 +1,5 @@
|
||||
package parser;
|
||||
|
||||
import de.dhbwstuttgart.parser.ClassNotFoundException;
|
||||
import de.dhbwstuttgart.parser.JavaTXParser;
|
||||
import de.dhbwstuttgart.syntaxtree.ClassOrInterface;
|
||||
import de.dhbwstuttgart.syntaxtree.Field;
|
||||
|
@ -1,6 +1,5 @@
|
||||
package parser;
|
||||
|
||||
import de.dhbwstuttgart.parser.ClassNotFoundException;
|
||||
import de.dhbwstuttgart.parser.JavaTXParser;
|
||||
import de.dhbwstuttgart.syntaxtree.ClassOrInterface;
|
||||
import de.dhbwstuttgart.syntaxtree.Field;
|
||||
|
24
test/parser/IfTest.jav
Normal file
24
test/parser/IfTest.jav
Normal file
@ -0,0 +1,24 @@
|
||||
class IfTest
|
||||
{
|
||||
|
||||
public void IfStatementTest();
|
||||
|
||||
public void ifThenNoShortIfTest()
|
||||
{
|
||||
if(y)
|
||||
{
|
||||
}
|
||||
}
|
||||
|
||||
public void ifThenElseTest()
|
||||
{
|
||||
if(z)
|
||||
{
|
||||
|
||||
}
|
||||
else
|
||||
{
|
||||
|
||||
}
|
||||
}
|
||||
}
|
10
test/parser/PrePostOperationTest.jav
Normal file
10
test/parser/PrePostOperationTest.jav
Normal file
@ -0,0 +1,10 @@
|
||||
class TestClass
|
||||
{
|
||||
void testMethod()
|
||||
{
|
||||
//++i;
|
||||
//i++;
|
||||
//--i;
|
||||
//i--;
|
||||
}
|
||||
}
|
@ -1,6 +1,8 @@
|
||||
package parser;
|
||||
|
||||
import de.dhbwstuttgart.parser.JavaTXParser;
|
||||
import de.dhbwstuttgart.syntaxtree.SourceFile;
|
||||
import de.dhbwstuttgart.syntaxtree.visual.ASTPrinter;
|
||||
import org.junit.Test;
|
||||
|
||||
import java.io.File;
|
||||
@ -14,7 +16,8 @@ public class RunParserTest {
|
||||
@Test
|
||||
public void testMain() throws Exception {
|
||||
String[] args = new String[1];
|
||||
args[0] = rootDirectory+"ImportTest2.jav";
|
||||
new JavaTXParser().parse(new File(args[0]));
|
||||
args[0] = rootDirectory+"WhileTest.jav";
|
||||
SourceFile sf = new JavaTXParser().parse(new File(args[0]));
|
||||
System.out.println(ASTPrinter.print(sf));
|
||||
}
|
||||
}
|
11
test/parser/SwitchTest.jav
Normal file
11
test/parser/SwitchTest.jav
Normal file
@ -0,0 +1,11 @@
|
||||
public class SwitchTest
|
||||
{
|
||||
void testMethod()
|
||||
{
|
||||
switch(i)
|
||||
{
|
||||
case i:
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
14
test/parser/TryCatchTest.jav
Normal file
14
test/parser/TryCatchTest.jav
Normal file
@ -0,0 +1,14 @@
|
||||
class TryCatchTest
|
||||
{
|
||||
public void TryTest()
|
||||
{
|
||||
try
|
||||
{
|
||||
|
||||
}
|
||||
catch()
|
||||
{
|
||||
|
||||
}
|
||||
}
|
||||
}
|
16
test/parser/WhileTest.jav
Normal file
16
test/parser/WhileTest.jav
Normal file
@ -0,0 +1,16 @@
|
||||
class WhileTest
|
||||
{
|
||||
void methode()
|
||||
{
|
||||
Boolean boolVar=true;
|
||||
do
|
||||
{
|
||||
}while(boolVar);
|
||||
|
||||
|
||||
while(boolVar)
|
||||
{
|
||||
test = test;
|
||||
}
|
||||
}
|
||||
}
|
11
test/test.iml
Normal file
11
test/test.iml
Normal file
@ -0,0 +1,11 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<module type="JAVA_MODULE" version="4">
|
||||
<component name="NewModuleRootManager" inherit-compiler-output="true">
|
||||
<exclude-output />
|
||||
<content url="file://$MODULE_DIR$">
|
||||
<sourceFolder url="file://$MODULE_DIR$" isTestSource="true" />
|
||||
</content>
|
||||
<orderEntry type="inheritedJdk" />
|
||||
<orderEntry type="sourceFolder" forTests="false" />
|
||||
</component>
|
||||
</module>
|
@ -1,15 +1,13 @@
|
||||
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.SourceFile;
|
||||
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 de.dhbwstuttgart.typedeployment.TypeInsertFactory;
|
||||
import de.dhbwstuttgart.typeinference.result.ResultSet;
|
||||
import org.junit.Test;
|
||||
|
||||
import java.io.File;
|
||||
@ -20,18 +18,18 @@ import java.nio.file.Files;
|
||||
import java.nio.file.Paths;
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
|
||||
import static org.junit.Assert.*;
|
||||
import java.util.Set;
|
||||
|
||||
public class JavaTXCompilerTest extends JavaTXCompiler {
|
||||
|
||||
private static final String rootDirectory = System.getProperty("user.dir")+"/test/javFiles/";
|
||||
private static final String rootDirectory = System.getProperty("user.dir")+"/test/parser/";
|
||||
private static final List<File> filesToTest = new ArrayList<>();
|
||||
|
||||
@Test
|
||||
public void test() throws IOException, ClassNotFoundException {
|
||||
filesToTest.add(new File(rootDirectory+"Faculty.jav"));
|
||||
public void test() throws IOException, java.lang.ClassNotFoundException {
|
||||
//filesToTest.add(new File(rootDirectory+"Faculty.jav"));
|
||||
//filesToTest.add(new File(rootDirectory+"mathStruc.jav"));
|
||||
//filesToTest.add(new File(rootDirectory+"test.jav"));
|
||||
//filesToTest.add(new File(rootDirectory+"Lambda.jav"));
|
||||
//filesToTest.add(new File(rootDirectory+"Lambda2.jav"));
|
||||
//filesToTest.add(new File(rootDirectory+"Lambda3.jav"));
|
||||
@ -39,14 +37,29 @@ public class JavaTXCompilerTest extends JavaTXCompiler {
|
||||
//filesToTest.add(new File(rootDirectory+"Generics.jav"));
|
||||
//filesToTest.add(new File(rootDirectory+"MethodsEasy.jav"));
|
||||
//filesToTest.add(new File(rootDirectory+"Matrix.jav"));
|
||||
//filesToTest.add(new File(rootDirectory+"Import.jav"));
|
||||
|
||||
//filesToTest.add(new File(rootDirectory+"BreakTest.jav"));
|
||||
//filesToTest.add(new File(rootDirectory+"WhileTest.jav"));
|
||||
//filesToTest.add(new File(rootDirectory+"IfTest.jav"));
|
||||
filesToTest.add(new File(rootDirectory+"AssertTest.jav"));
|
||||
//filesToTest.add(new File(rootDirectory+"PrePostOperationTest.jav"));
|
||||
//filesToTest.add(new File(rootDirectory+"SwitchTest.jav"));
|
||||
//filesToTest.add(new File(rootDirectory+"WhileTest.jav"));
|
||||
for(File f : filesToTest){
|
||||
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(TypeInsert tip : result){
|
||||
System.out.println(tip.insert(content));
|
||||
SourceFile sf = this.parse(f);
|
||||
System.out.println("-------------------------------------|"+f.getName()+"|----------------------------------------------");
|
||||
System.out.println(ASTPrinter.print(this.sourceFiles.get(sourceFiles.size()-1)));
|
||||
|
||||
/*
|
||||
for(ResultSet resultSet : this.typeInference()){
|
||||
Set<TypeInsert> result = TypeInsertFactory.createTypeInsertPoints(sf, resultSet);
|
||||
String content = readFile(f.getPath(), StandardCharsets.UTF_8);
|
||||
for(TypeInsert tip : result){
|
||||
System.out.println(tip.insert(content));
|
||||
}
|
||||
}
|
||||
*/
|
||||
}
|
||||
|
||||
}
|
||||
|
9
tools/tools.iml
Normal file
9
tools/tools.iml
Normal file
@ -0,0 +1,9 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<module type="WEB_MODULE" version="4">
|
||||
<component name="NewModuleRootManager" inherit-compiler-output="true">
|
||||
<exclude-output />
|
||||
<content url="file://$MODULE_DIR$" />
|
||||
<orderEntry type="inheritedJdk" />
|
||||
<orderEntry type="sourceFolder" forTests="false" />
|
||||
</component>
|
||||
</module>
|
Reference in New Issue
Block a user