forked from JavaTX/JavaCompilerCore
Compare commits
53 Commits
typeErasur
...
bigCleanup
Author | SHA1 | Date | |
---|---|---|---|
c8a31a6063 | |||
5c60918c47 | |||
a0367d5464 | |||
722d897d4b | |||
e2d76d314a | |||
cd5fbac987 | |||
67df9aa262 | |||
5b970f9359 | |||
1b5eacf921 | |||
a35e69f878 | |||
643f7c0220 | |||
24f1b507c4 | |||
a4cc4cc357 | |||
e80e2db26c | |||
4c0fb34c00 | |||
8e80cc2985 | |||
f03d3f5e64 | |||
dfd12422a6 | |||
eebb07ec8b | |||
c65102d89a | |||
ed00aeb056 | |||
7012010462 | |||
9444ee38d6 | |||
4ed30f11f7 | |||
fcedec60e7 | |||
d8bdcf854c | |||
0e363cfae3 | |||
fedf33a006 | |||
4522aeff36 | |||
bcf56e6bdd | |||
15c05e5cba | |||
dc9a54be3b | |||
21adeb7f26 | |||
6381d09174 | |||
918a2cc04d | |||
ac1e0340c3 | |||
0d84e8361f | |||
0207c7d1b0 | |||
f1f028f0b9 | |||
8b58259fe0 | |||
55a75b04a0 | |||
06b27dabd2 | |||
9baf89acc2 | |||
be307e95a6 | |||
df4faebd92 | |||
36ef1e124a | |||
2706c31beb | |||
c32a0cc222 | |||
eaec7f613a | |||
c681396061 | |||
3d19d8d729 | |||
f457e7e4d0 | |||
c22d12f6b0 |
pom.xml
src
main
antlr4
java
de
dhbwstuttgart
bytecode
core
parser
SyntaxTreeGenerator
syntaxtree
target
generate
tree
typeinference
test
java
bytecode
parser
targetast
resources
bytecode
javFiles
javFiles
parser
testBytecode
manually
16
pom.xml
16
pom.xml
@ -118,6 +118,15 @@ http://maven.apache.org/maven-v4_0_0.xsd">
|
||||
</descriptorRefs>
|
||||
</configuration>
|
||||
</plugin>
|
||||
<plugin>
|
||||
<groupId>org.apache.maven.plugins</groupId>
|
||||
<artifactId>maven-compiler-plugin</artifactId>
|
||||
<configuration>
|
||||
<source>17</source>
|
||||
<target>17</target>
|
||||
<compilerArgs>--enable-preview</compilerArgs>
|
||||
</configuration>
|
||||
</plugin>
|
||||
</plugins>
|
||||
</build>
|
||||
<repositories>
|
||||
@ -129,8 +138,11 @@ http://maven.apache.org/maven-v4_0_0.xsd">
|
||||
<properties>
|
||||
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
|
||||
<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
|
||||
<maven.compiler.source>1.8</maven.compiler.source>
|
||||
<maven.compiler.target>1.8</maven.compiler.target>
|
||||
<maven.compiler.source>17</maven.compiler.source>
|
||||
<maven.compiler.target>17</maven.compiler.target>
|
||||
<compilerArgs>
|
||||
--enable-preview
|
||||
</compilerArgs>
|
||||
<tycho.version>0.23.0</tycho.version>
|
||||
<mainClass>de.dhbwstuttgart.core.ConsoleInterface</mainClass>
|
||||
</properties>
|
||||
|
@ -1,37 +0,0 @@
|
||||
grammar UnifyResult;
|
||||
|
||||
answer : 'ANSWER' (resultSetRule '.')*;
|
||||
|
||||
resultSetRule :
|
||||
parameter
|
||||
| equals
|
||||
| smaller
|
||||
| typeVar
|
||||
| type
|
||||
| otherRule
|
||||
;
|
||||
|
||||
parameterList : '(' value (',' value)* ')';
|
||||
value : NAME
|
||||
| resultSetRule ;
|
||||
|
||||
parameter : PARAMLIST_NAME parameterList;
|
||||
equals : EQUALS_NAME parameterList;
|
||||
smaller : SMALLER_NAME parameterList;
|
||||
typeVar : TYPEVAR_NAME parameterList;
|
||||
type : TYPE_NAME parameterList;
|
||||
otherRule : NAME parameterList;
|
||||
|
||||
//TODO: Es sollte Regeln für das Result set geben, welche sich nicht mit den anderen überdecken, dann auch nur diese im Result ausgeben
|
||||
PARAMLIST_NAME : 'param';
|
||||
EQUALS_NAME : 'equals';
|
||||
SMALLER_NAME : 'smaller';
|
||||
TYPEVAR_NAME : 'typeVar';
|
||||
TYPE_NAME : 'type';
|
||||
NAME : [a-zA-Z0-9_]+;
|
||||
|
||||
WS : [ \t\r\n\u000C]+ -> skip
|
||||
;
|
||||
LINE_COMMENT
|
||||
: '%' ~[\r\n]* -> skip
|
||||
;
|
@ -1,23 +0,0 @@
|
||||
T__0=1
|
||||
T__1=2
|
||||
T__2=3
|
||||
T__3=4
|
||||
T__4=5
|
||||
PARAMLIST_NAME=6
|
||||
EQUALS_NAME=7
|
||||
SMALLER_NAME=8
|
||||
TYPEVAR_NAME=9
|
||||
TYPE_NAME=10
|
||||
NAME=11
|
||||
WS=12
|
||||
LINE_COMMENT=13
|
||||
'ANSWER'=1
|
||||
'.'=2
|
||||
'('=3
|
||||
','=4
|
||||
')'=5
|
||||
'param'=6
|
||||
'equals'=7
|
||||
'smaller'=8
|
||||
'typeVar'=9
|
||||
'type'=10
|
@ -1,23 +0,0 @@
|
||||
T__0=1
|
||||
T__1=2
|
||||
T__2=3
|
||||
T__3=4
|
||||
T__4=5
|
||||
PARAMLIST_NAME=6
|
||||
EQUALS_NAME=7
|
||||
SMALLER_NAME=8
|
||||
TYPEVAR_NAME=9
|
||||
TYPE_NAME=10
|
||||
NAME=11
|
||||
WS=12
|
||||
LINE_COMMENT=13
|
||||
'ANSWER'=1
|
||||
'.'=2
|
||||
'('=3
|
||||
','=4
|
||||
')'=5
|
||||
'param'=6
|
||||
'equals'=7
|
||||
'smaller'=8
|
||||
'typeVar'=9
|
||||
'type'=10
|
@ -13,7 +13,10 @@ import java.util.HashMap;
|
||||
import java.util.Iterator;
|
||||
import java.util.LinkedList;
|
||||
import java.util.List;
|
||||
import java.util.stream.Collectors;
|
||||
|
||||
import de.dhbwstuttgart.bytecode.funN.FunNGenerator;
|
||||
import de.dhbwstuttgart.bytecode.funN.FunNUtilities;
|
||||
import de.dhbwstuttgart.bytecode.utilities.*;
|
||||
import de.dhbwstuttgart.environment.DirectoryClassLoader;
|
||||
import de.dhbwstuttgart.exceptions.NotImplementedException;
|
||||
@ -584,16 +587,26 @@ public class BytecodeGenMethod implements StatementVisitor {
|
||||
}
|
||||
}
|
||||
|
||||
//ToDo Etienne: Für Type Erasure relevant?!
|
||||
@Override
|
||||
public void visit(LambdaExpression lambdaExpression) {
|
||||
this.lamCounter++;
|
||||
|
||||
String typeErasure = createDescriptorWithTypeErasure(lambdaExpression);
|
||||
//ToDo Etienne: Double Check
|
||||
RefTypeOrTPHOrWildcardOrGeneric returnType = resolver.resolve(lambdaExpression.getReturnType());
|
||||
List<RefTypeOrTPHOrWildcardOrGeneric> argumentTypes = lambdaExpression
|
||||
.params
|
||||
.getFormalparalist()
|
||||
.stream()
|
||||
.map(FormalParameter::getType)
|
||||
.map(resolver::resolve)
|
||||
.collect(Collectors.toList());
|
||||
FunNUtilities funNUtilities = FunNGenerator.getInstance();
|
||||
FunNUtilities.writeClassFile(funNUtilities.getSuperClassName(argumentTypes.size()),
|
||||
funNUtilities.generateSuperBytecode(argumentTypes.size()), path);
|
||||
FunNUtilities.writeClassFile(funNUtilities.getSpecializedClassName(argumentTypes, returnType),
|
||||
funNUtilities.generateSpecializedBytecode(argumentTypes, returnType), path);
|
||||
|
||||
ByteCodeForFunNGenerator.generateBCForFunN(lambdaExpression, typeErasure,path);
|
||||
|
||||
|
||||
Lambda lam = new Lambda(lambdaExpression);
|
||||
String lamDesc = lam.accept(new DescriptorToString(resultSet));
|
||||
// Call site, which, when invoked, returns an instance of the functional
|
||||
@ -654,7 +667,6 @@ public class BytecodeGenMethod implements StatementVisitor {
|
||||
// generateBCForFunN(lambdaExpression, typeErasure);
|
||||
}
|
||||
|
||||
//ToDo Etienne: Relevant?!
|
||||
private String addUsedVarsToDesugaredMethodDescriptor(String lamDesc) {
|
||||
String newDesc = "(";
|
||||
int pos = 0;
|
||||
@ -676,7 +688,6 @@ public class BytecodeGenMethod implements StatementVisitor {
|
||||
}
|
||||
}
|
||||
|
||||
//ToDo Etienne: Relevant?!
|
||||
private String createDescriptorWithTypeErasure(LambdaExpression lambdaExpression) {
|
||||
String typeErasure = "(";
|
||||
Iterator<FormalParameter> itr = lambdaExpression.params.iterator();
|
||||
@ -770,7 +781,6 @@ public class BytecodeGenMethod implements StatementVisitor {
|
||||
// This will be used if the class is not standard class (not in API)
|
||||
ClassLoader cLoader2;
|
||||
|
||||
//ToDo methodCallType wird nicht korrekt resolved, da kein Constraint vorhanden ist
|
||||
String methCallType = resultSet.resolveType(methodCall.getType()).resolvedType.acceptTV(new TypeToDescriptor());
|
||||
String[] typesOfParams = getTypes(methodCall.arglist.getArguments());
|
||||
try {
|
||||
@ -815,13 +825,23 @@ public class BytecodeGenMethod implements StatementVisitor {
|
||||
} catch (NotInCurrentPackageException | NotFoundException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
//ToDo Etienne: Für Type Erasure wichtig?!
|
||||
} else if(!helper.isInCurrPkg(clazz)){
|
||||
if(clazz.contains(CONSTANTS.$$)) {
|
||||
//ToDo Methoden Deskriptor neu setzen
|
||||
//ToDo Receiver neu setzen?!
|
||||
mDesc = helper.getDescriptorOfApplyMethod(methCallType);
|
||||
helper.generateBCForFunN(typesOfParams, methCallType);
|
||||
//ToDo Etienne: Double Check
|
||||
RefTypeOrTPHOrWildcardOrGeneric returnType = resolver.resolve(methodCall.getType());
|
||||
List<RefTypeOrTPHOrWildcardOrGeneric> argumentTypes = methodCall
|
||||
.arglist
|
||||
.getArguments()
|
||||
.stream()
|
||||
.map(TypableStatement::getType)
|
||||
.map(resolver::resolve)
|
||||
.collect(Collectors.toList());
|
||||
FunNUtilities funNUtilities = FunNGenerator.getInstance();
|
||||
FunNUtilities.writeClassFile(funNUtilities.getSuperClassName(argumentTypes.size()),
|
||||
funNUtilities.generateSuperBytecode(argumentTypes.size()), path);
|
||||
FunNUtilities.writeClassFile(funNUtilities.getSpecializedClassName(argumentTypes, returnType),
|
||||
funNUtilities.generateSpecializedBytecode(argumentTypes, returnType), path);
|
||||
}else {
|
||||
try {
|
||||
cLoader2 = new DirectoryClassLoader(path, classLoader);
|
||||
@ -878,7 +898,6 @@ public class BytecodeGenMethod implements StatementVisitor {
|
||||
if(parentBinary || isBinaryExp) {
|
||||
doUnboxing(resolver.getResolvedType(methodCall.getType()));
|
||||
}
|
||||
//ToDo Etienne: Für Type Erasure wichtig?!
|
||||
} else if(receiverName.contains(CONSTANTS.$$) && !methCallType.equals(Type.getInternalName(Object.class))) {
|
||||
helper.createCheckCast(methodCall,mv);
|
||||
}
|
||||
@ -906,7 +925,6 @@ public class BytecodeGenMethod implements StatementVisitor {
|
||||
}
|
||||
}
|
||||
|
||||
//ToDo Etienne: Für Type Erasure wichtig?!
|
||||
private void visitInvokeInsn(MethodCall methodCall, String receiverName, java.lang.reflect.Method methodRefl, String clazz, String mDesc, String receiverRefl) {
|
||||
// is methodCall.receiver functional Interface)?
|
||||
if (varsFunInterface.contains(methodCall.receiver.getType()) || (methodRefl!= null && receiverRefl.contains("interface")) ||
|
||||
|
@ -68,7 +68,6 @@ public class DescriptorToString implements DescriptorVisitor, CONSTANTS {
|
||||
}
|
||||
}
|
||||
}
|
||||
//ToDo Etienne: Für Type Erasure wichtig?!
|
||||
//TODO: generate a class java%% ... %%
|
||||
else if(resultSet.resolveType(fp.getType()).resolvedType.acceptTV(new TypeToDescriptor()).contains(CONSTANTS.ANGLEBRACKET)){
|
||||
desc += "L"+resultSet.resolveType(fp.getType()).resolvedType.toString().replace(".", "$$").replace(CONSTANTS.ANGLEBRACKET, "$$$").replace(">", "$$$")+ ";";
|
||||
@ -154,6 +153,7 @@ public class DescriptorToString implements DescriptorVisitor, CONSTANTS {
|
||||
return desc;
|
||||
}
|
||||
|
||||
//ToDo Etienne: ändern
|
||||
@Override
|
||||
public String visit(Lambda lambdaExpression) {
|
||||
String desc = "(";
|
||||
@ -208,7 +208,7 @@ public class DescriptorToString implements DescriptorVisitor, CONSTANTS {
|
||||
String desc = "(";
|
||||
for(Expression e : methodFromMethodCall.getArgList().getArguments()) {
|
||||
String d = resultSet.resolveType(e.getType()).resolvedType.acceptTV(new TypeToDescriptor());
|
||||
//ToDo Etienne: Ändern von $$ nötig für TypeErasure?
|
||||
|
||||
if(d.contains(CONSTANTS.TPH) ||d.contains(CONSTANTS.ANGLEBRACKET) || methodFromMethodCall.getReceiverName().contains("$$")) {
|
||||
desc += "L"+Type.getInternalName(Object.class)+ ";";
|
||||
}else {
|
||||
@ -226,7 +226,6 @@ public class DescriptorToString implements DescriptorVisitor, CONSTANTS {
|
||||
System.out.println("DescriptorToString retType = " + retType);
|
||||
if(retType.equals(CONSTANTS.VOID)) {
|
||||
desc += ")V";
|
||||
//ToDo Etienne: Ändern von $$ nötig für TypeErasure?
|
||||
}else if(retType.contains(CONSTANTS.TPH)|| retType.contains(CONSTANTS.ANGLEBRACKET) || methodFromMethodCall.getReceiverName().contains("$$")){
|
||||
desc += ")L"+Type.getInternalName(Object.class)+ ";";
|
||||
}else {
|
||||
@ -242,7 +241,6 @@ public class DescriptorToString implements DescriptorVisitor, CONSTANTS {
|
||||
return desc;
|
||||
}
|
||||
|
||||
//ToDo Etienne: Ändern für TypeErasure
|
||||
@Override
|
||||
public String createDescForFunN(ArgumentList argumentList, String returnType) {
|
||||
Iterator<Expression> itr1 = argumentList.getArguments().iterator();
|
||||
|
@ -11,9 +11,7 @@ public interface DescriptorVisitor {
|
||||
String visit(NormalMethod method);
|
||||
String visit(NormalConstructor constructor);
|
||||
String visit(Lambda lambdaExpression);
|
||||
//ToDo Etienne: Was ist SamMethod?
|
||||
String visit(SamMethod samMethod);
|
||||
//ToDo Etienne: Was ist MethodFromMethodCall?
|
||||
String visit(MethodFromMethodCall methodFromMethodCall);
|
||||
String createDescForFunN(ArgumentList argumentList, String returnType);
|
||||
}
|
||||
|
@ -1,17 +1,24 @@
|
||||
package de.dhbwstuttgart.bytecode.descriptor;
|
||||
|
||||
import de.dhbwstuttgart.exceptions.NotImplementedException;
|
||||
import de.dhbwstuttgart.syntaxtree.type.ExtendsWildcardType;
|
||||
import de.dhbwstuttgart.syntaxtree.type.GenericRefType;
|
||||
import de.dhbwstuttgart.syntaxtree.type.RefType;
|
||||
import de.dhbwstuttgart.syntaxtree.type.SuperWildcardType;
|
||||
import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
|
||||
import de.dhbwstuttgart.syntaxtree.type.TypeVisitor;
|
||||
import de.dhbwstuttgart.bytecode.funN.FunNGenerator;
|
||||
import de.dhbwstuttgart.bytecode.funN.FunNUtilities;
|
||||
import de.dhbwstuttgart.syntaxtree.type.*;
|
||||
|
||||
public class TypeToDescriptor implements TypeVisitor<String>{
|
||||
|
||||
private final boolean specializedFunN;
|
||||
|
||||
public TypeToDescriptor(){ this(true); }
|
||||
|
||||
public TypeToDescriptor(boolean specializedFunN) { this.specializedFunN = specializedFunN; }
|
||||
|
||||
@Override
|
||||
public String visit(RefType refType) {
|
||||
if (refType.getName().toString().matches("Fun\\d+\\$\\$") && specializedFunN) {
|
||||
FunNUtilities funNUtilities = FunNGenerator.getInstance();
|
||||
return funNUtilities.getSpecializedDescriptor(funNUtilities.getArguments(refType.getParaList()), funNUtilities.getReturnType(refType.getParaList()));
|
||||
}
|
||||
|
||||
return refType.getName().toString().replace(".", "/");
|
||||
// String t = refType.getName().toString().replace(".", "/");
|
||||
// return t.equals("Fun1")?(t+"$$"):t;
|
||||
@ -38,6 +45,8 @@ public class TypeToDescriptor implements TypeVisitor<String>{
|
||||
//throw new NotImplementedException();
|
||||
}
|
||||
|
||||
//ToDo Etienne: bin der Meinung hier müsste immer der Descriptor der extends-Schranke sein, z.b. <T> => Ljava/lang/Object; oder <T extends String> => Ljava/lang/String;
|
||||
//Tests sind aber damit grün?! => Fehler in Tests schon vorher aufgefallen und gut möglich!
|
||||
@Override
|
||||
public String visit(GenericRefType genericRefType) {
|
||||
return genericRefType.getParsedName().replace(".", "/");
|
||||
|
181
src/main/java/de/dhbwstuttgart/bytecode/funN/FunNGenerator.java
Normal file
181
src/main/java/de/dhbwstuttgart/bytecode/funN/FunNGenerator.java
Normal file
@ -0,0 +1,181 @@
|
||||
package de.dhbwstuttgart.bytecode.funN;
|
||||
|
||||
import de.dhbwstuttgart.bytecode.descriptor.TypeToDescriptor;
|
||||
import de.dhbwstuttgart.bytecode.signature.TypeToSignature;
|
||||
import de.dhbwstuttgart.bytecode.utilities.CONSTANTS;
|
||||
import de.dhbwstuttgart.parser.scope.JavaClassName;
|
||||
import de.dhbwstuttgart.syntaxtree.type.GenericRefType;
|
||||
import de.dhbwstuttgart.syntaxtree.type.RefType;
|
||||
import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
|
||||
import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
|
||||
import org.objectweb.asm.ClassWriter;
|
||||
import org.objectweb.asm.MethodVisitor;
|
||||
import org.objectweb.asm.Type;
|
||||
|
||||
import javax.annotation.Nonnull;
|
||||
import java.io.File;
|
||||
import java.io.FileOutputStream;
|
||||
import java.util.List;
|
||||
import java.util.Objects;
|
||||
import java.util.stream.Collectors;
|
||||
import java.util.stream.Stream;
|
||||
|
||||
import static org.objectweb.asm.Opcodes.*;
|
||||
|
||||
/**
|
||||
* Represents a Singleton-Service implementation for the {@link FunNUtilities} interface.
|
||||
*
|
||||
* @since Studienarbeit Type Erasure
|
||||
* @author etiennezink
|
||||
*/
|
||||
public final class FunNGenerator implements FunNUtilities{
|
||||
|
||||
private static final FunNGenerator funNGenerator = new FunNGenerator();
|
||||
|
||||
/**
|
||||
* @return the Singleton instance for {@link FunNGenerator}
|
||||
*/
|
||||
public static FunNUtilities getInstance(){ return funNGenerator; }
|
||||
|
||||
private final String argumentGenericBase = "T";
|
||||
private final String returnGeneric = "R";
|
||||
private final String methodName = "apply";
|
||||
private final int bytecodeVersion = V1_8;
|
||||
|
||||
private final String objectSuperType = Type.getInternalName(Object.class).replace('.','/');
|
||||
private final RefType objectRefType = new RefType(new JavaClassName(objectSuperType), null);
|
||||
private final String objectSignature = applySignature(objectRefType);
|
||||
|
||||
private FunNGenerator(){}
|
||||
|
||||
@Override
|
||||
public byte[] generateSuperBytecode(int numberArguments) {
|
||||
StringBuilder superFunNClassSignature = new StringBuilder("<");
|
||||
StringBuilder superFunNMethodSignature = new StringBuilder("(");
|
||||
StringBuilder superFunNMethodDescriptor = new StringBuilder("(");
|
||||
|
||||
for (int currentParameter = 1; currentParameter <= numberArguments; currentParameter++){
|
||||
superFunNClassSignature.append(String.format("%s%d:%s",argumentGenericBase, currentParameter, objectSignature));
|
||||
superFunNMethodSignature.append(applySignature( new GenericRefType(argumentGenericBase + currentParameter, null)));
|
||||
superFunNMethodDescriptor.append(objectSignature);
|
||||
}
|
||||
superFunNClassSignature.append(String.format("%s:%s>%s", returnGeneric, objectSignature, objectSignature));
|
||||
superFunNMethodSignature.append(String.format(")%s", applySignature(new GenericRefType(returnGeneric, null))));
|
||||
superFunNMethodDescriptor.append(String.format(")%s", objectSignature));
|
||||
|
||||
ClassWriter classWriter = new ClassWriter(0);
|
||||
MethodVisitor methodVisitor;
|
||||
classWriter.visit(bytecodeVersion, ACC_PUBLIC | ACC_ABSTRACT | ACC_INTERFACE, getSuperClassName(numberArguments), superFunNClassSignature.toString(), objectSuperType, null);
|
||||
methodVisitor = classWriter.visitMethod(ACC_PUBLIC | ACC_ABSTRACT, methodName, superFunNMethodDescriptor.toString(), superFunNMethodSignature.toString(), null);
|
||||
methodVisitor.visitEnd();
|
||||
classWriter.visitEnd();
|
||||
return classWriter.toByteArray();
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getSuperClassName(int numberArguments) {
|
||||
return String.format("Fun%d$$", numberArguments);
|
||||
}
|
||||
|
||||
@Override
|
||||
public byte[] generateSpecializedBytecode(List<RefTypeOrTPHOrWildcardOrGeneric> argumentTypes, RefTypeOrTPHOrWildcardOrGeneric returnType) {
|
||||
Objects.requireNonNull(argumentTypes);
|
||||
Objects.requireNonNull(returnType);
|
||||
//generates a list of all params and substitutes the TPH
|
||||
List<RefTypeOrTPHOrWildcardOrGeneric> parameters = Stream
|
||||
.concat(argumentTypes.stream(), Stream.of(returnType))
|
||||
.map(this::substituteTPH)
|
||||
.collect(Collectors.toList());
|
||||
RefType superFunN = new RefType(new JavaClassName(getSuperClassName(argumentTypes.size())), parameters , null);
|
||||
StringBuilder funNClassSignature = new StringBuilder(objectSignature + (superFunN.acceptTV(new TypeToSignature(false))));
|
||||
boolean containsGeneric = false;
|
||||
|
||||
String genericSignature = "<";
|
||||
for (RefTypeOrTPHOrWildcardOrGeneric typeArgument : parameters) {
|
||||
if (typeArgument instanceof GenericRefType){
|
||||
GenericRefType generic = (GenericRefType) typeArgument;
|
||||
String signatureOfArgument = generic.getParsedName();
|
||||
if(genericSignature.contains(signatureOfArgument)) continue;
|
||||
genericSignature += String.format("%s:%s", signatureOfArgument, objectSignature);
|
||||
containsGeneric = true;
|
||||
}
|
||||
}
|
||||
genericSignature += ">";
|
||||
if (containsGeneric) funNClassSignature.insert(0, genericSignature);
|
||||
|
||||
ClassWriter classWriter = new ClassWriter(0);
|
||||
classWriter.visit(bytecodeVersion, ACC_PUBLIC | ACC_ABSTRACT | ACC_INTERFACE, getSpecializedClassName(argumentTypes, returnType), funNClassSignature.toString(), objectSuperType, new String[]{getSuperClassName(argumentTypes.size())});
|
||||
classWriter.visitEnd();
|
||||
return classWriter.toByteArray();
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getSpecializedClassName(List<RefTypeOrTPHOrWildcardOrGeneric> argumentTypes, RefTypeOrTPHOrWildcardOrGeneric returnType) {
|
||||
Objects.requireNonNull(argumentTypes);
|
||||
Objects.requireNonNull(returnType);
|
||||
return String.format("Fun%d$$%s%s",
|
||||
argumentTypes.size(),
|
||||
argumentTypes
|
||||
.stream()
|
||||
.map(this::applyNameDescriptor)
|
||||
.collect(Collectors.joining()),
|
||||
applyNameDescriptor(returnType))
|
||||
.replace('/', '$')
|
||||
.replace(";", "$_$");
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getSpecializedDescriptor(List<RefTypeOrTPHOrWildcardOrGeneric> argumentTypes, RefTypeOrTPHOrWildcardOrGeneric returnType) {
|
||||
Objects.requireNonNull(argumentTypes);
|
||||
Objects.requireNonNull(returnType);
|
||||
return applyDescriptor(getSpecializedFunNRefType(argumentTypes, returnType));
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getSpecializedSignature(List<RefTypeOrTPHOrWildcardOrGeneric> argumentTypes, RefTypeOrTPHOrWildcardOrGeneric returnType) {
|
||||
Objects.requireNonNull(argumentTypes);
|
||||
Objects.requireNonNull(returnType);
|
||||
return applySignature(getSpecializedFunNRefType(argumentTypes, returnType));
|
||||
}
|
||||
|
||||
@Override
|
||||
public List<RefTypeOrTPHOrWildcardOrGeneric> getArguments(List<RefTypeOrTPHOrWildcardOrGeneric> list) {
|
||||
Objects.requireNonNull(list);
|
||||
return list
|
||||
.stream()
|
||||
.limit(Math.max(0, list.size() - 1))
|
||||
.collect(Collectors.toList());
|
||||
}
|
||||
|
||||
@Override
|
||||
public RefTypeOrTPHOrWildcardOrGeneric getReturnType(List<RefTypeOrTPHOrWildcardOrGeneric> list) {
|
||||
Objects.requireNonNull(list);
|
||||
if(list.size() == 0) return null;
|
||||
return list.get(list.size() - 1);
|
||||
}
|
||||
|
||||
private String applyDescriptor(RefTypeOrTPHOrWildcardOrGeneric a) { return a.acceptTV(new TypeToDescriptor(true)); }
|
||||
private String applySignature(RefTypeOrTPHOrWildcardOrGeneric a) { return a.acceptTV(new TypeToSignature(true)); }
|
||||
|
||||
/**
|
||||
* @param a
|
||||
* @return the name for the type {@code a} which should be used in the specialized name for FunN.
|
||||
*/
|
||||
private String applyNameDescriptor(RefTypeOrTPHOrWildcardOrGeneric a){ return a instanceof TypePlaceholder ? "LTPH;" : String.format("L%s;", applyDescriptor(a)); }
|
||||
|
||||
private RefTypeOrTPHOrWildcardOrGeneric substituteTPH(RefTypeOrTPHOrWildcardOrGeneric t) {
|
||||
if (t instanceof TypePlaceholder) {
|
||||
TypePlaceholder tph = (TypePlaceholder) t;
|
||||
return new GenericRefType(tph.getName()+"$", t.getOffset());
|
||||
}
|
||||
return t;
|
||||
}
|
||||
private RefType getSpecializedFunNRefType(List<RefTypeOrTPHOrWildcardOrGeneric> argumentTypes, RefTypeOrTPHOrWildcardOrGeneric returnType){
|
||||
return new RefType(new JavaClassName(getSpecializedClassName(argumentTypes, returnType)),
|
||||
Stream
|
||||
.concat(argumentTypes.stream(), Stream.of(returnType))
|
||||
.filter(t -> t instanceof GenericRefType ||
|
||||
t instanceof TypePlaceholder)
|
||||
.collect(Collectors.toList()),null);
|
||||
}
|
||||
}
|
@ -0,0 +1,90 @@
|
||||
package de.dhbwstuttgart.bytecode.funN;
|
||||
|
||||
import de.dhbwstuttgart.bytecode.utilities.CONSTANTS;
|
||||
import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
|
||||
|
||||
import javax.annotation.Nonnull;
|
||||
import java.io.File;
|
||||
import java.io.FileOutputStream;
|
||||
import java.util.List;
|
||||
|
||||
/**
|
||||
* Interface which represents the functionality for specifying and generating the specified functional types (FunN).
|
||||
*
|
||||
* @since Studienarbeit Type Erasure
|
||||
* @author etiennezink
|
||||
*/
|
||||
public interface FunNUtilities {
|
||||
|
||||
/**
|
||||
* @param numberArguments (excluding the return type!)
|
||||
* @return the bytecode for the super FunN-interface
|
||||
*/
|
||||
byte[] generateSuperBytecode(int numberArguments);
|
||||
|
||||
/**
|
||||
* @param numberArguments (excluding the return type!)
|
||||
* @return the name for the super FunN-interface
|
||||
*/
|
||||
String getSuperClassName(int numberArguments);
|
||||
|
||||
/**
|
||||
* @param argumentTypes (excluding the return type!)
|
||||
* @param returnType
|
||||
* @return the bytecode for the specialized FunN-interface
|
||||
*/
|
||||
byte[] generateSpecializedBytecode(List<RefTypeOrTPHOrWildcardOrGeneric> argumentTypes, RefTypeOrTPHOrWildcardOrGeneric returnType);
|
||||
|
||||
/**
|
||||
* @param argumentTypes (excluding the return type!)
|
||||
* @param returnType
|
||||
* @return the name for the specialized FunN-interface
|
||||
*/
|
||||
String getSpecializedClassName(List<RefTypeOrTPHOrWildcardOrGeneric> argumentTypes, RefTypeOrTPHOrWildcardOrGeneric returnType);
|
||||
|
||||
/**
|
||||
* @param argumentTypes (excluding the return type!)
|
||||
* @param returnType
|
||||
* @return the descriptor for a specialized FunN-interface.
|
||||
*/
|
||||
String getSpecializedDescriptor(List<RefTypeOrTPHOrWildcardOrGeneric> argumentTypes, RefTypeOrTPHOrWildcardOrGeneric returnType);
|
||||
|
||||
/**
|
||||
* @param argumentTypes (excluding the return type!)
|
||||
* @param returnType
|
||||
* @return the signature for a specialized FunN-interface.
|
||||
*/
|
||||
String getSpecializedSignature(List<RefTypeOrTPHOrWildcardOrGeneric> argumentTypes, RefTypeOrTPHOrWildcardOrGeneric returnType);
|
||||
|
||||
/**
|
||||
* @param list containing type arguments and the return type.
|
||||
* @return a {@link List} containing only the arguments of the specialized FunN-interface.
|
||||
*/
|
||||
List<RefTypeOrTPHOrWildcardOrGeneric> getArguments(List<RefTypeOrTPHOrWildcardOrGeneric> list);
|
||||
|
||||
/**
|
||||
* @param list containing type arguments and the return type.
|
||||
* @return the return type of the {@code list} (last member)
|
||||
*/
|
||||
RefTypeOrTPHOrWildcardOrGeneric getReturnType(List<RefTypeOrTPHOrWildcardOrGeneric> list);
|
||||
|
||||
/**
|
||||
* Should be refactored into a central API.
|
||||
*
|
||||
* @param className
|
||||
* @param bytecode
|
||||
* @param directory
|
||||
* @return {@code true} iff the file could be generated and {@code false} if not
|
||||
*/
|
||||
@Deprecated
|
||||
static boolean writeClassFile(String className, byte[] bytecode, File directory) {
|
||||
try (FileOutputStream output = new FileOutputStream(new File(directory , className + CONSTANTS.EXTENSIONCLASS))){
|
||||
output.write(bytecode);
|
||||
output.flush();
|
||||
return true;
|
||||
} catch (Exception e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
return false;
|
||||
}
|
||||
}
|
@ -136,7 +136,6 @@ public class Signature {
|
||||
defineGenericsFromConstraints(constraints,genericsAndBoundsMethod);
|
||||
}
|
||||
|
||||
//ToDo Etienne: für TypeErasure anschauen
|
||||
private void createSignatureForFunN(int numberOfParams, String to, String[] paramTypes) {
|
||||
defineTypeVariablesForParametersOfFunN(numberOfParams);
|
||||
|
||||
@ -148,7 +147,6 @@ public class Signature {
|
||||
|
||||
}
|
||||
|
||||
//ToDo Etienne: für TypeErasure anschauen
|
||||
private void createSignatureForFunN(int numberOfParams) {
|
||||
|
||||
defineTypeVariablesForParametersOfFunN(numberOfParams);
|
||||
@ -204,7 +202,6 @@ public class Signature {
|
||||
if (r instanceof GenericRefType) {
|
||||
sv.visitTypeVariable(sig2);
|
||||
} else if (!(r instanceof TypePlaceholder)) {
|
||||
//ToDo Etienne: Wichtig für Type Erasure?!
|
||||
if (sig2.contains(SPECIAL_CHAR_FOR_FUN)) {
|
||||
sv.visitInterface().visitClassType(sig2.substring(1));
|
||||
} else {
|
||||
@ -269,7 +266,6 @@ public class Signature {
|
||||
}
|
||||
|
||||
private void checkInnerSignatureOfWildCard(SignatureVisitor sv, String sigInner, int length, char superOrExtendsChar) {
|
||||
//ToDo Etienne: Wichtig für Type Erasure?!
|
||||
if (sigInner.contains(SPECIAL_CHAR_FOR_FUN)) {
|
||||
sv.visitTypeArgument(superOrExtendsChar).visitInterface().visitClassType(sigInner.substring(1, length));
|
||||
} else {
|
||||
|
@ -5,6 +5,8 @@ import java.util.Iterator;
|
||||
import java.util.List;
|
||||
import java.util.Optional;
|
||||
|
||||
import de.dhbwstuttgart.bytecode.funN.FunNGenerator;
|
||||
import de.dhbwstuttgart.bytecode.funN.FunNUtilities;
|
||||
import de.dhbwstuttgart.bytecode.genericsGeneratorTypes.GenericsGeneratorResult;
|
||||
import de.dhbwstuttgart.syntaxtree.type.ExtendsWildcardType;
|
||||
import de.dhbwstuttgart.syntaxtree.type.GenericRefType;
|
||||
@ -17,18 +19,29 @@ import de.dhbwstuttgart.syntaxtree.type.TypeVisitor;
|
||||
public class TypeToSignature implements TypeVisitor<String> {
|
||||
private List<GenericsGeneratorResult> constraints;
|
||||
|
||||
public TypeToSignature() {
|
||||
this.constraints = new ArrayList<>();
|
||||
}
|
||||
private final boolean specializedFunN;
|
||||
|
||||
public TypeToSignature() { this(new ArrayList<>(), true); }
|
||||
|
||||
public TypeToSignature(boolean specializedFunN) { this(new ArrayList<>(), specializedFunN); }
|
||||
|
||||
public TypeToSignature(List<GenericsGeneratorResult> constraints) {
|
||||
this(constraints, true);
|
||||
}
|
||||
|
||||
public TypeToSignature(List<GenericsGeneratorResult> constraints, boolean specializedFunN){
|
||||
this.constraints = constraints;
|
||||
this.specializedFunN = specializedFunN;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String visit(RefType refType) {
|
||||
if(refType.getName().toString().equals("void"))
|
||||
return "V";
|
||||
if (refType.getName().toString().matches("Fun\\d+\\$\\$") && specializedFunN){
|
||||
FunNUtilities funNUtilities = FunNGenerator.getInstance();
|
||||
return funNUtilities.getSpecializedSignature(funNUtilities.getArguments(refType.getParaList()), funNUtilities.getReturnType(refType.getParaList()));
|
||||
}
|
||||
// return refType.toString().replace(".", "/");
|
||||
String params = "";
|
||||
if(refType.getParaList().size()>0){
|
||||
@ -89,9 +102,20 @@ public class TypeToSignature implements TypeVisitor<String> {
|
||||
return sig;
|
||||
}
|
||||
|
||||
/**
|
||||
* Changed that the correct signature is returned:
|
||||
* returns now T...; expect of only ...
|
||||
* where ... is {@code genericRefType.getParsedName()}
|
||||
*
|
||||
* @since Studienarbeit Type Erasure
|
||||
* @author etiennezink
|
||||
*
|
||||
* @param genericRefType
|
||||
* @return
|
||||
*/
|
||||
@Override
|
||||
public String visit(GenericRefType genericRefType) {
|
||||
return genericRefType.getParsedName().replace(".", "/");
|
||||
return String.format("T%s;", genericRefType.getParsedName()).replace(".", "/");
|
||||
}
|
||||
|
||||
private Optional<GenericsGeneratorResult> getEqualTPHFromClassConstraints(List<GenericsGeneratorResult> listOfConstraints, String tph) {
|
||||
@ -99,34 +123,4 @@ public class TypeToSignature implements TypeVisitor<String> {
|
||||
.filter(c -> c.getConstraint().getLeft().equals(tph) || c.getEqualsTPHs().contains(tph))
|
||||
.findFirst();
|
||||
}
|
||||
|
||||
/**
|
||||
* //ToDo beschreiben
|
||||
*
|
||||
* @param type
|
||||
* @return
|
||||
*
|
||||
* @since Studienarbeit Type Erasure
|
||||
* @author Etienne Zink
|
||||
*/
|
||||
public String visit(RefTypeOrTPHOrWildcardOrGeneric type){
|
||||
String returnString = "";
|
||||
if (type instanceof GenericRefType){
|
||||
GenericRefType genericRefType = (GenericRefType) type;
|
||||
returnString += visit(genericRefType);
|
||||
} else if (type instanceof RefType){
|
||||
RefType refType = (RefType) type;
|
||||
returnString += visit(refType);
|
||||
} else if (type instanceof TypePlaceholder){
|
||||
TypePlaceholder typePlaceholder = (TypePlaceholder) type;
|
||||
returnString += visit(typePlaceholder);
|
||||
} else if (type instanceof SuperWildcardType){
|
||||
SuperWildcardType superWildcardType = (SuperWildcardType) type;
|
||||
returnString += visit(superWildcardType);
|
||||
} else if (type instanceof ExtendsWildcardType) {
|
||||
ExtendsWildcardType extendsWildcardType = (ExtendsWildcardType) type;
|
||||
returnString += visit(extendsWildcardType);
|
||||
}
|
||||
return returnString;
|
||||
}
|
||||
}
|
||||
|
@ -1,38 +1,25 @@
|
||||
package de.dhbwstuttgart.bytecode.utilities;
|
||||
|
||||
import de.dhbwstuttgart.bytecode.signature.Signature;
|
||||
import de.dhbwstuttgart.bytecode.signature.TypeToSignature;
|
||||
import de.dhbwstuttgart.syntaxtree.FormalParameter;
|
||||
import de.dhbwstuttgart.syntaxtree.statement.ArgumentList;
|
||||
import de.dhbwstuttgart.syntaxtree.statement.Expression;
|
||||
import de.dhbwstuttgart.syntaxtree.statement.LambdaExpression;
|
||||
import de.dhbwstuttgart.syntaxtree.type.*;
|
||||
import org.objectweb.asm.ClassWriter;
|
||||
import org.objectweb.asm.MethodVisitor;
|
||||
import org.objectweb.asm.Opcodes;
|
||||
import org.objectweb.asm.Type;
|
||||
import org.objectweb.asm.signature.SignatureVisitor;
|
||||
import org.objectweb.asm.signature.SignatureWriter;
|
||||
|
||||
import java.io.*;
|
||||
import java.sql.Ref;
|
||||
import java.util.HashSet;
|
||||
import java.io.File;
|
||||
import java.io.FileNotFoundException;
|
||||
import java.io.FileOutputStream;
|
||||
import java.io.IOException;
|
||||
import java.util.Iterator;
|
||||
import java.util.List;
|
||||
import java.util.stream.Collectors;
|
||||
|
||||
import static org.objectweb.asm.Opcodes.*;
|
||||
|
||||
public class ByteCodeForFunNGenerator {
|
||||
|
||||
/**
|
||||
* HashSet which contains the parameter number for which already a FunN$$ interface was generated.
|
||||
*
|
||||
* @since Studienarbeit Type Erasure
|
||||
* @author Etienne Zink
|
||||
*/
|
||||
private static HashSet<Integer> alreadyGeneratedFunN = new HashSet<>();
|
||||
|
||||
//ToDo Etienne: wird in Test OLFun nicht verwendet!
|
||||
public static void generateBCForFunN(LambdaExpression lambdaExpression, String methDesc, File path) {
|
||||
ClassWriter classWriter = new ClassWriter(ClassWriter.COMPUTE_FRAMES | ClassWriter.COMPUTE_MAXS);
|
||||
|
||||
@ -51,121 +38,57 @@ public class ByteCodeForFunNGenerator {
|
||||
// ")"+lam.getReturn.getBounds
|
||||
Signature sig = new Signature(numberOfParams);
|
||||
String name = CONSTANTS.FUN + numberOfParams + CONSTANTS.$$;
|
||||
classWriter.visit(V1_8, ACC_PUBLIC + ACC_INTERFACE + ACC_ABSTRACT, name, sig.toString(),
|
||||
classWriter.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC+Opcodes.ACC_INTERFACE + Opcodes.ACC_ABSTRACT, name, sig.toString(),
|
||||
Type.getInternalName(Object.class), null);
|
||||
MethodVisitor mvApply = classWriter.visitMethod(ACC_PUBLIC + ACC_ABSTRACT, "apply", methDesc,
|
||||
MethodVisitor mvApply = classWriter.visitMethod(Opcodes.ACC_PUBLIC + Opcodes.ACC_ABSTRACT, "apply", methDesc,
|
||||
methSig.toString(), null);
|
||||
mvApply.visitEnd();
|
||||
writeClassFile(name, classWriter.toByteArray(), path);
|
||||
writeClassFile(classWriter.toByteArray(), name, path);
|
||||
}
|
||||
|
||||
/**
|
||||
* //ToDo beschreiben
|
||||
*
|
||||
* @param typesOfFormalParameters
|
||||
* @param returnType
|
||||
* @param path
|
||||
*
|
||||
* @since Studienarbeit Type Erasure
|
||||
* @author Etienne Zink
|
||||
*/
|
||||
public static void generateBCForFunN(String[] typesOfFormalParameters, String returnType, File path) {
|
||||
public static void generateBCForFunN(ArgumentList argumentList, String methDesc, File path) {
|
||||
ClassWriter classWriter = new ClassWriter(ClassWriter.COMPUTE_FRAMES | ClassWriter.COMPUTE_MAXS);
|
||||
int numberOfParameters = typesOfFormalParameters.length;
|
||||
generateSuperFunNInterface(numberOfParameters, path);
|
||||
|
||||
String className = getBaseFunClassname(numberOfParameters);
|
||||
String classSignature = String.format("L%s;L%s<", Type.getInternalName(Object.class), className);
|
||||
SignatureWriter methSig = new SignatureWriter();
|
||||
|
||||
//ToDo testen ob der Klassenname und -signatur so passt
|
||||
for (String typeOfFormalParameter: typesOfFormalParameters) {
|
||||
className += String.format("%s$_$", typeOfFormalParameter);
|
||||
classSignature += String.format("L%s;", typeOfFormalParameter);
|
||||
int numberOfParams = 0;
|
||||
SignatureVisitor paramVisitor = methSig.visitParameterType();
|
||||
Iterator<Expression> itr1 = argumentList.getArguments().iterator();
|
||||
|
||||
while(itr1.hasNext()) {
|
||||
numberOfParams++;
|
||||
// getBounds
|
||||
paramVisitor.visitTypeVariable(CONSTANTS.T + numberOfParams);
|
||||
itr1.next();
|
||||
}
|
||||
className += returnType;
|
||||
className = className.replace('/', '$');
|
||||
classSignature += String.format("L%s>;", returnType);
|
||||
|
||||
System.out.println("Generated className: " + className);
|
||||
System.out.println("Generated signature: " + classSignature);
|
||||
|
||||
classWriter.visit(V1_8, ACC_PUBLIC | ACC_INTERFACE | ACC_ABSTRACT, className, classSignature,
|
||||
Type.getInternalName(Object.class), new String[]{getBaseFunClassname(numberOfParameters)});
|
||||
writeClassFile(className, classWriter.toByteArray(), path);
|
||||
methSig.visitReturnType().visitTypeVariable(CONSTANTS.R);
|
||||
// ")"+lam.getReturn.getBounds
|
||||
Signature sig = new Signature(numberOfParams);
|
||||
String name = CONSTANTS.FUN + numberOfParams + CONSTANTS.$$;
|
||||
classWriter.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC+Opcodes.ACC_INTERFACE + Opcodes.ACC_ABSTRACT, name, sig.toString(),
|
||||
Type.getInternalName(Object.class), null);
|
||||
MethodVisitor mvApply = classWriter.visitMethod(Opcodes.ACC_PUBLIC + Opcodes.ACC_ABSTRACT, "apply", methDesc,
|
||||
methSig.toString(), null);
|
||||
mvApply.visitEnd();
|
||||
writeClassFile(classWriter.toByteArray(), name, path);
|
||||
}
|
||||
|
||||
/**
|
||||
* Function which generates a {@code class-File} for the super interface
|
||||
* Fun<{@code numberOfParameters}>$$ if it doesn't exist already.
|
||||
*
|
||||
* @param numberOfParameters
|
||||
* @return {@code true}, iff the {@code class-File} exists after this method invocation
|
||||
* based on {@link #alreadyGeneratedFunN alreadyGeneratedFunN}.
|
||||
*
|
||||
* @since Studienarbeit Type Erase
|
||||
* @author Etienne Zink
|
||||
*/
|
||||
public static boolean generateSuperFunNInterface(int numberOfParameters, File path){
|
||||
if(alreadyGeneratedFunN.contains(numberOfParameters)) return true;
|
||||
//ToDo Etienne: Generierung der Signaturen/Deskriptoren vielleicht auslagern? Bzw. schauen ob nicht schon vorhanden und anpassen!
|
||||
String className = getBaseFunClassname(numberOfParameters);
|
||||
String classSignature = "<";
|
||||
String methodSignature = "(";
|
||||
String methodDescriptor = "(";
|
||||
for (int parameter = 1; parameter <= numberOfParameters; parameter++) {
|
||||
classSignature += String.format("T%d:L%s;", parameter, Type.getInternalName(Object.class));
|
||||
methodSignature += String.format("TT%d;", parameter);
|
||||
methodDescriptor += String.format("L%s;", Type.getInternalName(Object.class));
|
||||
}
|
||||
classSignature += String.format("R:L%s;>L%s;",Type.getInternalName(Object.class),Type.getInternalName(Object.class));
|
||||
methodSignature += ")TR;";
|
||||
methodDescriptor += String.format(")L%s;",Type.getInternalName(Object.class));
|
||||
|
||||
ClassWriter classWriter = new ClassWriter(0);
|
||||
classWriter.visit(V1_8, ACC_PUBLIC | ACC_ABSTRACT | ACC_INTERFACE, className, classSignature, Type.getInternalName(Object.class), null);
|
||||
|
||||
MethodVisitor methodVisitor = classWriter.visitMethod(ACC_PUBLIC | ACC_ABSTRACT, "apply", methodDescriptor, methodSignature, null);
|
||||
methodVisitor.visitEnd();
|
||||
classWriter.visitEnd();
|
||||
|
||||
byte[] bytecode = classWriter.toByteArray();
|
||||
if(writeClassFile(className, bytecode, path)) {
|
||||
alreadyGeneratedFunN.add(numberOfParameters);
|
||||
}
|
||||
return alreadyGeneratedFunN.contains(numberOfParameters);
|
||||
}
|
||||
|
||||
/**
|
||||
*
|
||||
* @param countParameters
|
||||
* @return the String of the super Fun$$ type
|
||||
*
|
||||
* @since Studienarbeit Type Erasure
|
||||
* @author Etienne Zink
|
||||
*/
|
||||
private static String getBaseFunClassname(int countParameters){
|
||||
return String.format("Fun%d$$", countParameters);
|
||||
}
|
||||
|
||||
/**
|
||||
* Generates a {@code class-File} for the class {@code className} with the {@code bytecode}.
|
||||
*
|
||||
* @param className of the class to generate
|
||||
* @param bytecode of the class
|
||||
* @param directory where the class should be saved to
|
||||
* @return {@code true}, iff the {@code class-File} could be generated.
|
||||
*
|
||||
* @since Studienarbeit Type Erasure
|
||||
* @author Etienne Zink
|
||||
*/
|
||||
private static boolean writeClassFile(String className, byte[] bytecode, File directory) {
|
||||
try (FileOutputStream output = new FileOutputStream(new File(directory , className + CONSTANTS.EXTENSIONCLASS))){
|
||||
public static void writeClassFile(byte[] bytecode, String name, File path) {
|
||||
FileOutputStream output;
|
||||
try {
|
||||
System.out.println("generating " + name + ".class file...");
|
||||
output = new FileOutputStream(
|
||||
new File(path , name + CONSTANTS.EXTENSIONCLASS));
|
||||
output.write(bytecode);
|
||||
output.flush();
|
||||
return true;
|
||||
} catch (Exception e) {
|
||||
output.close();
|
||||
System.out.println(name + ".class file generated");
|
||||
} catch (FileNotFoundException e) {
|
||||
e.printStackTrace();
|
||||
} catch (IOException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
return false;
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -220,13 +220,10 @@ public class MethodCallHelper {
|
||||
}
|
||||
}
|
||||
|
||||
//ToDo Etienne: Für Type Erasure wichtig?!
|
||||
public void generateBCForFunN(String[] typesOfFormalParams, String receiverType) {
|
||||
//ToDo return Descriptor auf apply Methode?
|
||||
ByteCodeForFunNGenerator.generateBCForFunN(typesOfFormalParams, receiverType,path);
|
||||
public void generateBCForFunN(String methodDescriptor) {
|
||||
ByteCodeForFunNGenerator.generateBCForFunN(methCall.arglist,methodDescriptor,path);
|
||||
}
|
||||
|
||||
//ToDo Etienne: Für Type Erasure wichtig
|
||||
public String getDescriptorOfApplyMethod(String methodCallType) {
|
||||
return new DescriptorToString().createDescForFunN(methCall.arglist, methodCallType);
|
||||
}
|
||||
|
@ -25,4 +25,8 @@ public class Resolver {
|
||||
public String getResolvedType(RefTypeOrTPHOrWildcardOrGeneric type) {
|
||||
return resultSet.resolveType(type).resolvedType.acceptTV(new TypeToDescriptor());
|
||||
}
|
||||
|
||||
public RefTypeOrTPHOrWildcardOrGeneric resolve(RefTypeOrTPHOrWildcardOrGeneric type) {
|
||||
return resultSet.resolveType(type).resolvedType;
|
||||
}
|
||||
}
|
||||
|
@ -884,7 +884,6 @@ public class JavaTXCompiler {
|
||||
return result;
|
||||
}
|
||||
|
||||
//ToDo Etienne: Für Type Erasure wichtig?! (alle generatedBytecode-Methoden?)
|
||||
public void generateBytecode() throws ClassNotFoundException, IOException, BytecodeGeneratorError {
|
||||
generateBytecode((File) null);
|
||||
}
|
||||
|
@ -185,7 +185,6 @@ public class TypeGenerator {
|
||||
}else{
|
||||
Pattern p = Pattern.compile("Fun(\\d+)[$][$]");
|
||||
Matcher m = p.matcher(name);
|
||||
//ToDo Etienne: Für Type Erasure wichtig?!
|
||||
if (m.matches()) {//es ist FunN$$-Type
|
||||
return new RefType(new JavaClassName(name), convert(typeArguments, reg, generics), offset);
|
||||
} else {
|
||||
|
@ -4,6 +4,8 @@ import de.dhbwstuttgart.syntaxtree.ASTVisitor;
|
||||
import de.dhbwstuttgart.typeinference.result.ResultSetVisitor;
|
||||
import org.antlr.v4.runtime.Token;
|
||||
|
||||
import java.util.Objects;
|
||||
|
||||
public class GenericRefType extends RefTypeOrTPHOrWildcardOrGeneric
|
||||
{
|
||||
private String name;
|
||||
@ -33,12 +35,20 @@ public class GenericRefType extends RefTypeOrTPHOrWildcardOrGeneric
|
||||
visitor.visit(this);
|
||||
}
|
||||
|
||||
/**
|
||||
* @since Studienarbeit Type Erasure
|
||||
* @author etiennezink
|
||||
*
|
||||
* @param o
|
||||
* @return
|
||||
*/
|
||||
@Override
|
||||
public boolean equals(Object o) {
|
||||
// TODO Auto-generated method stub
|
||||
return false;
|
||||
}
|
||||
|
||||
if((! (o instanceof GenericRefType))) return false;
|
||||
GenericRefType genericRefType = (GenericRefType) o;
|
||||
return getParsedName().equals(genericRefType.getParsedName()) &&
|
||||
Objects.equals(getOffset(), genericRefType.getOffset());
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toString()
|
||||
|
@ -9,7 +9,6 @@ import org.antlr.v4.runtime.Token;
|
||||
*
|
||||
*/
|
||||
|
||||
//ToDo Etienne: Wieso abstrakte Klasse? -> Dadurch keine Inferenz mit ? möglich!
|
||||
public abstract class WildcardType extends RefTypeOrTPHOrWildcardOrGeneric {
|
||||
|
||||
protected RefTypeOrTPHOrWildcardOrGeneric innerType = null;
|
||||
|
@ -0,0 +1,78 @@
|
||||
package de.dhbwstuttgart.target.generate;
|
||||
|
||||
import de.dhbwstuttgart.syntaxtree.ASTVisitor;
|
||||
import de.dhbwstuttgart.syntaxtree.ClassOrInterface;
|
||||
import de.dhbwstuttgart.syntaxtree.Field;
|
||||
import de.dhbwstuttgart.syntaxtree.Method;
|
||||
import de.dhbwstuttgart.syntaxtree.statement.Block;
|
||||
import de.dhbwstuttgart.syntaxtree.type.*;
|
||||
import de.dhbwstuttgart.target.tree.*;
|
||||
import de.dhbwstuttgart.target.tree.expression.TargetBlock;
|
||||
import de.dhbwstuttgart.target.tree.type.*;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import java.util.stream.Collectors;
|
||||
|
||||
public class ASTToTargetAST {
|
||||
|
||||
public TargetClass convert(ClassOrInterface input, Map<TypePlaceholder, TargetType> sigma){
|
||||
List<TargetConstructor> targetConstructors = new ArrayList<>();
|
||||
//TODO constructor conversion -> also reduce syntactic sugar
|
||||
return new TargetClass(input.getModifiers(),input.getClassName().toString(), null,
|
||||
sigma.get(input.getSuperClass()),
|
||||
input.getSuperInterfaces().stream().map(it -> sigma.get(it)).collect(Collectors.toList()),
|
||||
targetConstructors,
|
||||
input.getFieldDecl().stream().map(it -> convert(it, sigma)).collect(Collectors.toList()),
|
||||
input.getMethods().stream().map(it -> convert(it, sigma)).collect(Collectors.toList()));
|
||||
}
|
||||
|
||||
private TargetMethod convert(Method input, Map<TypePlaceholder, TargetType> sigma) {
|
||||
List<MethodParameter> params = input.getParameterList().getFormalparalist().stream()
|
||||
.map(param -> new MethodParameter(convert(param.getType(), sigma), param.getName())).collect(Collectors.toList());
|
||||
return new TargetMethod(input.name, params, convert(input.block));
|
||||
}
|
||||
|
||||
private TargetBlock convert(Block block) {
|
||||
return new TargetBlock(block.statements.stream().map(e -> {
|
||||
StatementToTargetExpression converter = new StatementToTargetExpression();
|
||||
e.accept(converter);
|
||||
return converter.result;
|
||||
}).collect(Collectors.toList()));
|
||||
}
|
||||
|
||||
private TargetField convert(Field input, Map<TypePlaceholder, TargetType> sigma) {
|
||||
return new TargetField(convert(input.getType(), sigma), input.getName());
|
||||
}
|
||||
|
||||
private TargetType convert(RefTypeOrTPHOrWildcardOrGeneric input, Map<TypePlaceholder, TargetType> sigma) {
|
||||
return input.acceptTV(new TypeVisitor<>() {
|
||||
@Override
|
||||
public TargetType visit(RefType refType) {
|
||||
return new TargetRefType(refType.getName().toString(),
|
||||
refType.getParaList().stream().map((it) -> convert(it, sigma)).collect(Collectors.toList()));
|
||||
}
|
||||
|
||||
@Override
|
||||
public TargetType visit(SuperWildcardType superWildcardType) {
|
||||
return new TargetSuperWildcard(convert(superWildcardType.getInnerType(), sigma));
|
||||
}
|
||||
|
||||
@Override
|
||||
public TargetType visit(TypePlaceholder typePlaceholder) {
|
||||
return sigma.get(typePlaceholder);
|
||||
}
|
||||
|
||||
@Override
|
||||
public TargetType visit(ExtendsWildcardType extendsWildcardType) {
|
||||
return new TargetExtendsWildcard(convert(extendsWildcardType.getInnerType(), sigma));
|
||||
}
|
||||
|
||||
@Override
|
||||
public TargetType visit(GenericRefType genericRefType) {
|
||||
return new TargetGenericType(genericRefType.getParsedName());
|
||||
}
|
||||
});
|
||||
}
|
||||
}
|
@ -0,0 +1,156 @@
|
||||
package de.dhbwstuttgart.target.generate;
|
||||
|
||||
import de.dhbwstuttgart.parser.SyntaxTreeGenerator.AssignToLocal;
|
||||
import de.dhbwstuttgart.syntaxtree.ASTVisitor;
|
||||
import de.dhbwstuttgart.syntaxtree.StatementVisitor;
|
||||
import de.dhbwstuttgart.syntaxtree.statement.*;
|
||||
import de.dhbwstuttgart.target.tree.expression.TargetExpression;
|
||||
|
||||
public class StatementToTargetExpression implements StatementVisitor {
|
||||
public TargetExpression result;
|
||||
|
||||
@Override
|
||||
public void visit(ArgumentList argumentList) {
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(LambdaExpression lambdaExpression) {
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(Assign assign) {
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(BinaryExpr binary) {
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(Block block) {
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(CastExpr castExpr) {
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(EmptyStmt emptyStmt) {
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(FieldVar fieldVar) {
|
||||
|
||||
}
|
||||
|
||||
@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) {
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(MethodCall methodCall) {
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(NewClass methodCall) {
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(NewArray newArray) {
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(Return aReturn) {
|
||||
|
||||
}
|
||||
|
||||
@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(WhileStmt whileStmt) {
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(DoStmt whileStmt) {
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(AssignToField assignLeftSide) {
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(AssignToLocal assignLeftSide) {
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(SuperCall superCall) {
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(ExpressionReceiver expressionReceiver) {
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(UnaryExpr unaryExpr) {
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visit(Literal literal) {
|
||||
|
||||
}
|
||||
}
|
@ -0,0 +1,7 @@
|
||||
package de.dhbwstuttgart.target.tree;
|
||||
|
||||
import de.dhbwstuttgart.syntaxtree.type.GenericRefType;
|
||||
import de.dhbwstuttgart.target.tree.type.TargetType;
|
||||
|
||||
public record GenericDeclaration(GenericRefType generic, TargetType bound) {
|
||||
}
|
@ -0,0 +1,6 @@
|
||||
package de.dhbwstuttgart.target.tree;
|
||||
|
||||
import de.dhbwstuttgart.target.tree.type.TargetType;
|
||||
|
||||
public record MethodParameter(TargetType type, String name) {
|
||||
}
|
11
src/main/java/de/dhbwstuttgart/target/tree/TargetClass.java
Normal file
11
src/main/java/de/dhbwstuttgart/target/tree/TargetClass.java
Normal file
@ -0,0 +1,11 @@
|
||||
package de.dhbwstuttgart.target.tree;
|
||||
|
||||
import de.dhbwstuttgart.target.tree.type.TargetRefType;
|
||||
import de.dhbwstuttgart.target.tree.type.TargetType;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
public record TargetClass(int modifiers, String qualifiedName, List<GenericDeclaration> generics, TargetType superType,
|
||||
List<TargetType> implementingInterfaces,
|
||||
List<TargetConstructor> constructors, List<TargetField> fields, List<TargetMethod> methods) {}
|
||||
|
@ -0,0 +1,9 @@
|
||||
package de.dhbwstuttgart.target.tree;
|
||||
|
||||
import de.dhbwstuttgart.target.tree.expression.TargetBlock;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
public record TargetConstructor(List<MethodParameter> parameterTypes, TargetBlock block) {
|
||||
}
|
||||
|
@ -0,0 +1,7 @@
|
||||
package de.dhbwstuttgart.target.tree;
|
||||
|
||||
import de.dhbwstuttgart.target.tree.type.TargetType;
|
||||
|
||||
public record TargetField(TargetType type, String name) {
|
||||
}
|
||||
|
@ -0,0 +1,9 @@
|
||||
package de.dhbwstuttgart.target.tree;
|
||||
|
||||
import de.dhbwstuttgart.target.tree.expression.TargetBlock;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
public record TargetMethod(String name, List<MethodParameter> parameterTypes, TargetBlock block) {
|
||||
}
|
||||
|
@ -0,0 +1,4 @@
|
||||
package de.dhbwstuttgart.target.tree.expression;
|
||||
|
||||
public record TargetAssign(TargetExpression leftSide, TargetExpression rightSide) implements TargetExpression {
|
||||
}
|
@ -0,0 +1,6 @@
|
||||
package de.dhbwstuttgart.target.tree.expression;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
public record TargetBlock(List<TargetExpression> statememts) implements TargetExpression {
|
||||
}
|
@ -0,0 +1,7 @@
|
||||
package de.dhbwstuttgart.target.tree.expression;
|
||||
|
||||
import de.dhbwstuttgart.target.tree.type.*;
|
||||
|
||||
public sealed interface TargetExpression
|
||||
permits TargetBlock, TargetLambdaExpression, TargetReturn, TargetThis, TargetSuper, TargetNew, TargetAssign {
|
||||
}
|
@ -0,0 +1,8 @@
|
||||
package de.dhbwstuttgart.target.tree.expression;
|
||||
|
||||
import de.dhbwstuttgart.target.tree.MethodParameter;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
public record TargetLambdaExpression(List<MethodParameter> params, TargetExpression block) implements TargetExpression {
|
||||
}
|
@ -0,0 +1,8 @@
|
||||
package de.dhbwstuttgart.target.tree.expression;
|
||||
|
||||
import de.dhbwstuttgart.target.tree.type.TargetType;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
public record TargetNew(TargetType instantiatedType, List<TargetExpression> params) implements TargetExpression {
|
||||
}
|
@ -0,0 +1,4 @@
|
||||
package de.dhbwstuttgart.target.tree.expression;
|
||||
|
||||
public record TargetReturn(TargetExpression expression) implements TargetExpression {
|
||||
}
|
@ -0,0 +1,4 @@
|
||||
package de.dhbwstuttgart.target.tree.expression;
|
||||
|
||||
public record TargetSuper() implements TargetExpression {
|
||||
}
|
@ -0,0 +1,4 @@
|
||||
package de.dhbwstuttgart.target.tree.expression;
|
||||
|
||||
public record TargetThis() implements TargetExpression {
|
||||
}
|
@ -0,0 +1,5 @@
|
||||
package de.dhbwstuttgart.target.tree.type;
|
||||
|
||||
public record TargetExtendsWildcard(TargetType innerType) implements TargetType{
|
||||
}
|
||||
|
@ -0,0 +1,6 @@
|
||||
package de.dhbwstuttgart.target.tree.type;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
public record TargetFunNType(int N, List<TargetRefType> params) implements TargetType {
|
||||
}
|
@ -0,0 +1,4 @@
|
||||
package de.dhbwstuttgart.target.tree.type;
|
||||
|
||||
public record TargetGenericType(String name) implements TargetType {
|
||||
}
|
@ -0,0 +1,8 @@
|
||||
package de.dhbwstuttgart.target.tree.type;
|
||||
|
||||
import de.dhbwstuttgart.target.tree.type.TargetType;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
public record TargetRefType(String name, List<TargetType> params) implements TargetType {
|
||||
}
|
@ -0,0 +1,4 @@
|
||||
package de.dhbwstuttgart.target.tree.type;
|
||||
|
||||
public record TargetSuperWildcard(TargetType innerType) implements TargetType {
|
||||
}
|
@ -0,0 +1,5 @@
|
||||
package de.dhbwstuttgart.target.tree.type;
|
||||
|
||||
public sealed interface TargetType
|
||||
permits TargetExtendsWildcard, TargetFunNType, TargetGenericType, TargetRefType, TargetSuperWildcard {
|
||||
}
|
@ -63,7 +63,6 @@ public class MethodAssumption extends Assumption{
|
||||
//Die Generics werden alle zu TPHs umgewandelt.
|
||||
params.add(resolver.resolve(new GenericRefType(gtv.getName(), new NullToken())));
|
||||
}
|
||||
//ToDo Etienne: Für Type Erasure wichtig?!
|
||||
RefTypeOrTPHOrWildcardOrGeneric receiverType;
|
||||
if(receiver instanceof FunNClass){
|
||||
receiverType = new RefType(new JavaClassName(receiver.getClassName().toString()+"$$"), params, new NullToken()); // new FunN(params);
|
||||
|
@ -68,7 +68,6 @@ public class TYPEStmt implements StatementVisitor{
|
||||
lambdaParams.add(tphRetType);
|
||||
//lambdaParams.add(0,tphRetType);
|
||||
constraintsSet.addUndConstraint(
|
||||
//ToDo Etienne: Für Type Erasure wichtig?!
|
||||
new Pair(lambdaExpression.getType(),
|
||||
new RefType(new JavaClassName("Fun"+(lambdaParams.size()-1)+"$$"), lambdaParams, new NullToken()),
|
||||
//new FunN(lambdaParams),
|
||||
|
@ -21,7 +21,6 @@ public class FunNType extends UnifyType {
|
||||
/**
|
||||
* Creates a FunN-Type with the specified TypeParameters.
|
||||
*/
|
||||
//ToDo Etienne: Für Type Erasure wichtig?!
|
||||
protected FunNType(TypeParams p) {
|
||||
super("Fun"+(p.size()-1)+"$$", p);
|
||||
}
|
||||
|
75
src/test/java/bytecode/OLFun2Test.java
Normal file
75
src/test/java/bytecode/OLFun2Test.java
Normal file
@ -0,0 +1,75 @@
|
||||
package bytecode;
|
||||
|
||||
import java.io.File;
|
||||
import java.lang.reflect.Method;
|
||||
import java.net.URL;
|
||||
import java.net.URLClassLoader;
|
||||
|
||||
import general.TestCleanUp;
|
||||
import org.junit.*;
|
||||
import de.dhbwstuttgart.core.JavaTXCompiler;
|
||||
import static org.junit.Assert.*;
|
||||
|
||||
/**
|
||||
* Test for the file {@code OLFun2.jav}.
|
||||
* Tests if the expected overloading for the method {@code m} exists.
|
||||
*
|
||||
* @since Studienarbeit Type Erasure
|
||||
* @author etiennezink
|
||||
*/
|
||||
public class OLFun2Test {
|
||||
private static String path;
|
||||
private static File fileToTest;
|
||||
private static JavaTXCompiler compiler;
|
||||
private static ClassLoader loader;
|
||||
private static Class<?> classToTest;
|
||||
private static Class<?> classFun1IntInt;
|
||||
private static Class<?> classFun1IntDouble;
|
||||
private static Class<?> classFun1DoubleDouble;
|
||||
private static Class<?> classFun1DoubleInt;
|
||||
|
||||
private static String generatedByteCodeDirectory = System.getProperty("user.dir") + "/src/test/resources/testBytecode/generatedBC/";
|
||||
|
||||
@BeforeClass
|
||||
public static void setUp() throws Exception {
|
||||
path = System.getProperty("user.dir")+"/src/test/resources/bytecode/javFiles/OLFun2.jav";
|
||||
fileToTest = new File(path);
|
||||
compiler = new JavaTXCompiler(fileToTest);
|
||||
compiler.generateBytecode(generatedByteCodeDirectory);
|
||||
loader = new URLClassLoader(new URL[] {new URL("file://"+generatedByteCodeDirectory)});
|
||||
classToTest = loader.loadClass("OLFun2");
|
||||
classFun1IntInt = loader.loadClass("Fun1$$Ljava$lang$Integer$_$Ljava$lang$Integer$_$");
|
||||
classFun1IntDouble = loader.loadClass("Fun1$$Ljava$lang$Integer$_$Ljava$lang$Double$_$");
|
||||
classFun1DoubleDouble = loader.loadClass("Fun1$$Ljava$lang$Double$_$Ljava$lang$Double$_$");
|
||||
classFun1DoubleInt = loader.loadClass("Fun1$$Ljava$lang$Double$_$Ljava$lang$Integer$_$");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void mExistsWithIntegerInteger() throws Exception{
|
||||
Method m = classToTest.getDeclaredMethod("m", classFun1IntInt);
|
||||
assertNotNull(m);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void mExistsWithIntegerDouble() throws Exception{
|
||||
Method m = classToTest.getDeclaredMethod("m", classFun1IntDouble);
|
||||
assertNotNull(m);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void mExistsWithDoubleInteger() throws Exception{
|
||||
Method m = classToTest.getDeclaredMethod("m", classFun1DoubleInt);
|
||||
assertNotNull(m);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void mExistsWithDoubleDouble() throws Exception{
|
||||
Method m = classToTest.getDeclaredMethod("m", classFun1DoubleDouble);
|
||||
assertNotNull(m);
|
||||
}
|
||||
|
||||
@AfterClass
|
||||
public static void cleanUp() {
|
||||
TestCleanUp.cleanUpDirectory(new File(generatedByteCodeDirectory), f -> f.getName().contains(".class"));
|
||||
}
|
||||
}
|
@ -11,11 +11,11 @@ import de.dhbwstuttgart.core.JavaTXCompiler;
|
||||
import static org.junit.Assert.*;
|
||||
|
||||
/**
|
||||
* Test which only checks if the class {@code OLFun} was correctly compiled.
|
||||
* This is achived by verifying the existence of the three implementations of {@code m}.
|
||||
* Test for the file {@code OLFun.jav}.
|
||||
* Tests if the expected overloading for the method {@code m} exists.
|
||||
*
|
||||
* @since Studienarbeit Type Erasure
|
||||
* @author Etienne Zink
|
||||
* @author etiennezink
|
||||
*/
|
||||
public class OLFunTest {
|
||||
private static String path;
|
||||
@ -23,11 +23,15 @@ public class OLFunTest {
|
||||
private static JavaTXCompiler compiler;
|
||||
private static ClassLoader loader;
|
||||
private static Class<?> classToTest;
|
||||
private static Class<?> classFun1;
|
||||
private static Object instanceOfClass;
|
||||
private static Class<?> classFun1IntInt;
|
||||
private static Class<?> classFun1IntDouble;
|
||||
private static Class<?> classFun1DoubleDouble;
|
||||
private static Class<?> classFun1DoubleInt;
|
||||
private static Class<?> classFun1StringInt;
|
||||
private static Class<?> classFun1StringDouble;
|
||||
|
||||
private static String generatedByteCodeDirectory = System.getProperty("user.dir") + "/src/test/resources/testBytecode/generatedBC/";
|
||||
|
||||
|
||||
@BeforeClass
|
||||
public static void setUp() throws Exception {
|
||||
path = System.getProperty("user.dir")+"/src/test/resources/bytecode/javFiles/OLFun.jav";
|
||||
@ -36,25 +40,47 @@ public class OLFunTest {
|
||||
compiler.generateBytecode(generatedByteCodeDirectory);
|
||||
loader = new URLClassLoader(new URL[] {new URL("file://"+generatedByteCodeDirectory)});
|
||||
classToTest = loader.loadClass("OLFun");
|
||||
classFun1 = loader.loadClass("Fun1$$");
|
||||
instanceOfClass = classToTest.getDeclaredConstructor().newInstance();
|
||||
classFun1IntInt = loader.loadClass("Fun1$$Ljava$lang$Integer$_$Ljava$lang$Integer$_$");
|
||||
classFun1IntDouble = loader.loadClass("Fun1$$Ljava$lang$Integer$_$Ljava$lang$Double$_$");
|
||||
classFun1DoubleDouble = loader.loadClass("Fun1$$Ljava$lang$Double$_$Ljava$lang$Double$_$");
|
||||
classFun1DoubleInt = loader.loadClass("Fun1$$Ljava$lang$Double$_$Ljava$lang$Integer$_$");
|
||||
classFun1StringInt = loader.loadClass("Fun1$$Ljava$lang$String$_$Ljava$lang$Integer$_$");
|
||||
classFun1StringDouble = loader.loadClass("Fun1$$Ljava$lang$String$_$Ljava$lang$Double$_$");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void mExistsWithInteger() throws Exception{
|
||||
Method m = classToTest.getDeclaredMethod("m", classFun1 ,Integer.class);
|
||||
public void mExistsWithIntegerInteger() throws Exception{
|
||||
Method m = classToTest.getDeclaredMethod("m", classFun1IntInt, Integer.class);
|
||||
assertNotNull(m);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void mExistsWithString() throws Exception{
|
||||
Method m = classToTest.getDeclaredMethod("m", classFun1 ,String.class);
|
||||
public void mExistsWithIntegerDouble() throws Exception{
|
||||
Method m = classToTest.getDeclaredMethod("m", classFun1IntDouble, Integer.class);
|
||||
assertNotNull(m);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void mExistsWithDouble() throws Exception{
|
||||
Method m = classToTest.getDeclaredMethod("m", classFun1 ,Double.class);
|
||||
public void mExistsWithDoubleInteger() throws Exception{
|
||||
Method m = classToTest.getDeclaredMethod("m", classFun1DoubleInt, Double.class);
|
||||
assertNotNull(m);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void mExistsWithDoubleDouble() throws Exception{
|
||||
Method m = classToTest.getDeclaredMethod("m", classFun1DoubleDouble, Double.class);
|
||||
assertNotNull(m);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void mExistsWithStringInteger() throws Exception{
|
||||
Method m = classToTest.getDeclaredMethod("m", classFun1StringInt, String.class);
|
||||
assertNotNull(m);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void mExistsWithStringDouble() throws Exception{
|
||||
Method m = classToTest.getDeclaredMethod("m", classFun1StringDouble, String.class);
|
||||
assertNotNull(m);
|
||||
}
|
||||
|
||||
|
248
src/test/java/bytecode/funN/FunNGeneratorTest.java
Normal file
248
src/test/java/bytecode/funN/FunNGeneratorTest.java
Normal file
@ -0,0 +1,248 @@
|
||||
package bytecode.funN;
|
||||
|
||||
import de.dhbwstuttgart.bytecode.funN.FunNGenerator;
|
||||
import de.dhbwstuttgart.bytecode.funN.FunNUtilities;
|
||||
import de.dhbwstuttgart.parser.scope.JavaClassName;
|
||||
import de.dhbwstuttgart.syntaxtree.type.GenericRefType;
|
||||
import de.dhbwstuttgart.syntaxtree.type.RefType;
|
||||
import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
|
||||
import org.junit.BeforeClass;
|
||||
import org.junit.Test;
|
||||
import org.objectweb.asm.ClassWriter;
|
||||
import org.objectweb.asm.Type;
|
||||
|
||||
import java.util.Arrays;
|
||||
|
||||
import static org.junit.Assert.*;
|
||||
import static org.objectweb.asm.Opcodes.*;
|
||||
|
||||
public class FunNGeneratorTest {
|
||||
|
||||
static FunNUtilities funNGenerator;
|
||||
static RefType voidType;
|
||||
static RefType integerType;
|
||||
static GenericRefType genericT;
|
||||
static TypePlaceholder tph;
|
||||
|
||||
@BeforeClass
|
||||
public static void setUp(){
|
||||
|
||||
funNGenerator = FunNGenerator.getInstance();
|
||||
voidType = new RefType(new JavaClassName(Type.getInternalName(Void.class)), null);
|
||||
integerType = new RefType(new JavaClassName(Type.getInternalName(Integer.class)), null);
|
||||
genericT = new GenericRefType("T", null);
|
||||
tph = TypePlaceholder.fresh(null);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void superClassName_0(){
|
||||
var superClassName = funNGenerator.getSuperClassName(0);
|
||||
assertEquals("Fun0$$", superClassName);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void superClassName_1(){
|
||||
var superClassName = funNGenerator.getSuperClassName(1);
|
||||
assertEquals("Fun1$$", superClassName);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void specializedClassName_VoidVoid(){
|
||||
var specializedClassName = funNGenerator.getSpecializedClassName(Arrays.asList(), voidType);
|
||||
assertEquals("Fun0$$Ljava$lang$Void$_$", specializedClassName);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void specializedClassName_VoidInt(){
|
||||
var specializedClassName = funNGenerator.getSpecializedClassName(Arrays.asList(), integerType);
|
||||
assertEquals("Fun0$$Ljava$lang$Integer$_$", specializedClassName);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void specializedClassName_IntInt(){
|
||||
var specializedClassName = funNGenerator.getSpecializedClassName(Arrays.asList(integerType), integerType);
|
||||
assertEquals("Fun1$$Ljava$lang$Integer$_$Ljava$lang$Integer$_$", specializedClassName);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void specializedClassName_IntT(){
|
||||
var specializedClassName = funNGenerator.getSpecializedClassName(Arrays.asList(integerType), genericT);
|
||||
assertEquals("Fun1$$Ljava$lang$Integer$_$LT$_$", specializedClassName);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void specializedClassName_IntTPH(){
|
||||
var specializedClassName = funNGenerator.getSpecializedClassName(Arrays.asList(integerType), TypePlaceholder.fresh(null));
|
||||
assertEquals("Fun1$$Ljava$lang$Integer$_$LTPH$_$", specializedClassName);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void signature_IntInt(){
|
||||
var classSignature = funNGenerator.getSpecializedSignature(Arrays.asList(integerType), integerType);
|
||||
assertEquals("LFun1$$Ljava$lang$Integer$_$Ljava$lang$Integer$_$;", classSignature);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void signature_IntT(){
|
||||
var classSignature = funNGenerator.getSpecializedSignature(Arrays.asList(integerType), genericT);
|
||||
assertEquals("LFun1$$Ljava$lang$Integer$_$LT$_$<TT;>;", classSignature);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void signature_TPHTPH(){
|
||||
var classSignature = funNGenerator.getSpecializedSignature(Arrays.asList(tph), tph);
|
||||
assertEquals(String.format("LFun1$$LTPH$_$LTPH$_$<T%s$;T%s$;>;",tph.getName(), tph.getName()), classSignature);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void descriptor_IntInt(){
|
||||
var classDescriptor = funNGenerator.getSpecializedDescriptor(Arrays.asList(integerType), integerType);
|
||||
//does not have to contain L and ; because TypeToDescriptor returns the descriptor without these characters as well
|
||||
assertEquals("Fun1$$Ljava$lang$Integer$_$Ljava$lang$Integer$_$", classDescriptor);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void descriptor_IntT(){
|
||||
var classDescriptor = funNGenerator.getSpecializedDescriptor(Arrays.asList(integerType), genericT);
|
||||
//does not have to contain L and ; because TypeToDescriptor returns the descriptor without these characters as well
|
||||
assertEquals("Fun1$$Ljava$lang$Integer$_$LT$_$", classDescriptor);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void descriptor_TPHTPH(){
|
||||
var classDescriptor = funNGenerator.getSpecializedDescriptor(Arrays.asList(tph), tph);
|
||||
//does not have to contain L and ; because TypeToDescriptor returns the descriptor without these characters as well
|
||||
assertEquals("Fun1$$LTPH$_$LTPH$_$", classDescriptor);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void getArguments_Empty(){
|
||||
var arguments = funNGenerator.getArguments(Arrays.asList());
|
||||
assertTrue(arguments.isEmpty());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void getArguments_Int(){
|
||||
var arguments = funNGenerator.getArguments(Arrays.asList(integerType));
|
||||
assertTrue(arguments.isEmpty());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void getArguments_IntT(){
|
||||
var arguments = funNGenerator.getArguments(Arrays.asList(integerType, genericT));
|
||||
assertTrue(arguments.size() == 1);
|
||||
assertTrue(arguments.contains(integerType));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void getArguments_IntTInt(){
|
||||
var arguments = funNGenerator.getArguments(Arrays.asList(integerType, genericT, integerType));
|
||||
assertTrue(arguments.size() == 2);
|
||||
assertTrue(arguments.contains(integerType));
|
||||
assertTrue(arguments.contains(genericT));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void getReturnType_Empty(){
|
||||
var returnType = funNGenerator.getReturnType(Arrays.asList());
|
||||
assertNull(returnType);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void getReturnType_Int(){
|
||||
var returnType = funNGenerator.getReturnType(Arrays.asList(integerType));
|
||||
assertEquals(integerType, returnType);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void getReturnType_IntT(){
|
||||
var returnType = funNGenerator.getReturnType(Arrays.asList(integerType, genericT));
|
||||
assertEquals(genericT, returnType);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void superBytecode_0(){
|
||||
var superBytecode = funNGenerator.generateSuperBytecode(0);
|
||||
assertArrayEquals(superBytecodeReference_0(), superBytecode);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void superBytecode_1(){
|
||||
var superBytecode = funNGenerator.generateSuperBytecode(1);
|
||||
assertArrayEquals(superBytecodeReference_1(), superBytecode);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void superBytecode_2(){
|
||||
var superBytecode = funNGenerator.generateSuperBytecode(2);
|
||||
assertArrayEquals(superBytecodeReference_2(), superBytecode);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void specializedBytecode_VoidInt(){
|
||||
var specializedBytecode = funNGenerator.generateSpecializedBytecode(Arrays.asList(), integerType);
|
||||
assertArrayEquals(specializedBytecodeReference_VoidInt(), specializedBytecode);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void specializedBytecode_IntInt(){
|
||||
var specializedBytecode = funNGenerator.generateSpecializedBytecode(Arrays.asList(integerType), integerType);
|
||||
assertArrayEquals(specializedBytecodeReference_IntInt(), specializedBytecode);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void specializedBytecode_TIntInt(){
|
||||
var specializedBytecode = funNGenerator.generateSpecializedBytecode(Arrays.asList(genericT, integerType), integerType);
|
||||
assertArrayEquals(specializedBytecodeReference_TIntInt(), specializedBytecode);
|
||||
}
|
||||
|
||||
//super bytecode reference methods
|
||||
private static byte[] superBytecodeReference_0() {
|
||||
var classWriter = new ClassWriter(0);
|
||||
classWriter.visit(V1_8, ACC_PUBLIC | ACC_ABSTRACT | ACC_INTERFACE, "Fun0$$", "<R:Ljava/lang/Object;>Ljava/lang/Object;", "java/lang/Object", null);
|
||||
var methodVisitor = classWriter.visitMethod(ACC_PUBLIC | ACC_ABSTRACT, "apply", "()Ljava/lang/Object;", "()TR;", null);
|
||||
methodVisitor.visitEnd();
|
||||
classWriter.visitEnd();
|
||||
return classWriter.toByteArray();
|
||||
}
|
||||
|
||||
private static byte[] superBytecodeReference_1() {
|
||||
var classWriter = new ClassWriter(0);
|
||||
classWriter.visit(V1_8, ACC_PUBLIC | ACC_ABSTRACT | ACC_INTERFACE, "Fun1$$", "<T1:Ljava/lang/Object;R:Ljava/lang/Object;>Ljava/lang/Object;", "java/lang/Object", null);
|
||||
var methodVisitor = classWriter.visitMethod(ACC_PUBLIC | ACC_ABSTRACT, "apply", "(Ljava/lang/Object;)Ljava/lang/Object;", "(TT1;)TR;", null);
|
||||
methodVisitor.visitEnd();
|
||||
classWriter.visitEnd();
|
||||
return classWriter.toByteArray();
|
||||
}
|
||||
|
||||
private static byte[] superBytecodeReference_2() {
|
||||
ClassWriter classWriter = new ClassWriter(0);
|
||||
classWriter.visit(V1_8, ACC_PUBLIC | ACC_ABSTRACT | ACC_INTERFACE, "Fun2$$", "<T1:Ljava/lang/Object;T2:Ljava/lang/Object;R:Ljava/lang/Object;>Ljava/lang/Object;", "java/lang/Object", null);
|
||||
var methodVisitor = classWriter.visitMethod(ACC_PUBLIC | ACC_ABSTRACT, "apply", "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;", "(TT1;TT2;)TR;", null);
|
||||
methodVisitor.visitEnd();
|
||||
classWriter.visitEnd();
|
||||
return classWriter.toByteArray();
|
||||
}
|
||||
|
||||
//specialized bytecode reference methods
|
||||
private static byte[] specializedBytecodeReference_VoidInt() {
|
||||
ClassWriter classWriter = new ClassWriter(0);
|
||||
classWriter.visit(V1_8, ACC_PUBLIC | ACC_ABSTRACT | ACC_INTERFACE, "Fun0$$Ljava$lang$Integer$_$", "Ljava/lang/Object;LFun0$$<Ljava/lang/Integer;>;", "java/lang/Object", new String[]{"Fun0$$"});
|
||||
classWriter.visitEnd();
|
||||
return classWriter.toByteArray();
|
||||
}
|
||||
|
||||
private static byte[] specializedBytecodeReference_IntInt() {
|
||||
ClassWriter classWriter = new ClassWriter(0);
|
||||
classWriter.visit(V1_8, ACC_PUBLIC | ACC_ABSTRACT | ACC_INTERFACE, "Fun1$$Ljava$lang$Integer$_$Ljava$lang$Integer$_$", "Ljava/lang/Object;LFun1$$<Ljava/lang/Integer;Ljava/lang/Integer;>;", "java/lang/Object", new String[]{"Fun1$$"});
|
||||
classWriter.visitEnd();
|
||||
return classWriter.toByteArray();
|
||||
}
|
||||
|
||||
private static byte[] specializedBytecodeReference_TIntInt() {
|
||||
ClassWriter classWriter = new ClassWriter(0);
|
||||
classWriter.visit(V1_8, ACC_PUBLIC | ACC_ABSTRACT | ACC_INTERFACE, "Fun2$$LT$_$Ljava$lang$Integer$_$Ljava$lang$Integer$_$", "<T:Ljava/lang/Object;>Ljava/lang/Object;LFun2$$<TT;Ljava/lang/Integer;Ljava/lang/Integer;>;", "java/lang/Object", new String[]{"Fun2$$"});
|
||||
classWriter.visitEnd();
|
||||
return classWriter.toByteArray();
|
||||
}
|
||||
}
|
@ -20,18 +20,17 @@ import org.junit.Test;
|
||||
*
|
||||
*/
|
||||
public class GeneralParserTest{
|
||||
private static final String rootDirectory = System.getProperty("user.dir")+"/test/parser/";
|
||||
|
||||
@Test
|
||||
public void run(){
|
||||
|
||||
|
||||
List<String> filenames = new ArrayList<String>();
|
||||
|
||||
filenames.add("javFiles/parser/NewTest.jav");
|
||||
//filenames.add("CastTest.jav");
|
||||
/*
|
||||
filenames.add("NewTest.jav");
|
||||
filenames.add("FieldInitializationTest.jav");
|
||||
filenames.add("ImportTest.jav");
|
||||
filenames.add("CastTest.jav");
|
||||
filenames.add("StatementsTest.jav");
|
||||
//filenames.add("Methods.jav");
|
||||
filenames.add("ImportTestGeneric.jav");
|
||||
@ -40,11 +39,14 @@ public class GeneralParserTest{
|
||||
//filenames.add("GenericFieldVarTest.jav");
|
||||
filenames.add("FieldVarTest.jav");
|
||||
filenames.add("StructuralTypes.jav");
|
||||
filenames.add("ExtendsTest.jav");
|
||||
*/
|
||||
// filenames.add("ExtendsTest.jav");
|
||||
filenames.add("PackageNameTest.jav");
|
||||
|
||||
//filenames.add("PackageNameTest.jav");
|
||||
try{
|
||||
new JavaTXCompiler(filenames.stream().map(s -> new File(rootDirectory + s)).collect(Collectors.toList()));
|
||||
for(String filename : filenames){
|
||||
new JavaTXCompiler(new File(Thread.currentThread().getContextClassLoader().getResource(filename).getPath()));
|
||||
}
|
||||
}catch(Exception exc){
|
||||
exc.printStackTrace();
|
||||
fail();
|
||||
|
5
src/test/java/targetast/ASTToTargetTest.java
Normal file
5
src/test/java/targetast/ASTToTargetTest.java
Normal file
@ -0,0 +1,5 @@
|
||||
package targetast;
|
||||
|
||||
public class ASTToTargetTest {
|
||||
|
||||
}
|
@ -4,13 +4,9 @@ import java.lang.Double;
|
||||
import java.util.Vector;
|
||||
import java.lang.Boolean;
|
||||
|
||||
|
||||
|
||||
|
||||
public class OLFun {
|
||||
|
||||
//f = x -> {return x + x;};
|
||||
m(f, x) {
|
||||
x = f.apply(x+x);
|
||||
var y = f.apply(x + x) + 1;
|
||||
}
|
||||
}
|
13
src/test/resources/bytecode/javFiles/OLFun2.jav
Normal file
13
src/test/resources/bytecode/javFiles/OLFun2.jav
Normal file
@ -0,0 +1,13 @@
|
||||
import java.lang.String;
|
||||
import java.lang.Integer;
|
||||
import java.lang.Double;
|
||||
import java.util.Vector;
|
||||
import java.lang.Boolean;
|
||||
|
||||
public class OLFun2 {
|
||||
|
||||
m(f){
|
||||
var x = 1;
|
||||
var y = f.apply(x + x) + 1;
|
||||
}
|
||||
}
|
@ -1,3 +1,4 @@
|
||||
|
||||
class Test{
|
||||
method(){
|
||||
if(true)i++;
|
0
src/test/java/parser/BoundedParameter.jav → src/test/resources/javFiles/parser/BoundedParameter.jav
0
src/test/java/parser/BoundedParameter.jav → src/test/resources/javFiles/parser/BoundedParameter.jav
9
src/test/resources/testBytecode/manually/OLFunTest.java
Normal file
9
src/test/resources/testBytecode/manually/OLFunTest.java
Normal file
@ -0,0 +1,9 @@
|
||||
public class OLFunTest{
|
||||
public static void main(String[] args){
|
||||
var olFun2 = new OLFun2();
|
||||
olFun2.m((Integer x) -> x);
|
||||
olFun2.m((Integer x) -> (Double) Double.valueOf(x));
|
||||
olFun2.m((Double x) -> x);
|
||||
olFun2.m((Double x) -> x.intValue());
|
||||
}
|
||||
}
|
Reference in New Issue
Block a user