From 0e363cfae345524a290d8fafccc6554436c00b6e Mon Sep 17 00:00:00 2001 From: Etienne Zink Date: Mon, 28 Mar 2022 22:34:07 +0200 Subject: [PATCH] =?UTF-8?q?L=C3=B6chen=20des=20Intermediate-Packages=20und?= =?UTF-8?q?=20Erstellung=20einer=20Utility-Klasse=20zur=20FunN=20Bytecodeg?= =?UTF-8?q?enerierung.=20=C3=9Cbertragung=20der=20Funktionalit=C3=A4t=20zu?= =?UTF-8?q?r=20Generierung=20von=20FunN=20auf=20FunNGenerator.?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../bytecode/BytecodeGenMethod.java | 46 ++++-- .../bytecode/descriptor/TypeToDescriptor.java | 17 +- .../bytecode/funN/FunNGenerator.java | 136 ++++++++++++++++ .../bytecode/funN/FunNUtilities.java | 34 ++++ .../bytecode/signature/TypeToSignature.java | 10 +- .../convert/ASTToIntermediate.java | 73 --------- .../intermediate/generation/FunN.java | 152 ------------------ .../types/IntermediateExtendsWildcard.java | 57 ------- .../types/IntermediateGenericType.java | 85 ---------- .../types/IntermediateInnerType.java | 8 - .../types/IntermediateRefType.java | 115 ------------- .../types/IntermediateSuperWildcard.java | 56 ------- .../intermediate/types/IntermediateType.java | 23 --- .../types/IntermediateWildcard.java | 33 ---- .../intermediate/generation/FunNTest.java | 117 -------------- .../types/IntermediateExtensWildcardTest.java | 62 ------- .../types/IntermediateGenericTypeTest.java | 80 --------- .../types/IntermediateRefTypeTest.java | 107 ------------ .../types/IntermediateSuperWildcardTest.java | 62 ------- .../types/IntermediateWildcardTest.java | 57 ------- 20 files changed, 219 insertions(+), 1111 deletions(-) create mode 100644 src/main/java/de/dhbwstuttgart/bytecode/funN/FunNGenerator.java create mode 100644 src/main/java/de/dhbwstuttgart/bytecode/funN/FunNUtilities.java delete mode 100644 src/main/java/de/dhbwstuttgart/intermediate/convert/ASTToIntermediate.java delete mode 100644 src/main/java/de/dhbwstuttgart/intermediate/generation/FunN.java delete mode 100644 src/main/java/de/dhbwstuttgart/intermediate/types/IntermediateExtendsWildcard.java delete mode 100644 src/main/java/de/dhbwstuttgart/intermediate/types/IntermediateGenericType.java delete mode 100644 src/main/java/de/dhbwstuttgart/intermediate/types/IntermediateInnerType.java delete mode 100644 src/main/java/de/dhbwstuttgart/intermediate/types/IntermediateRefType.java delete mode 100644 src/main/java/de/dhbwstuttgart/intermediate/types/IntermediateSuperWildcard.java delete mode 100644 src/main/java/de/dhbwstuttgart/intermediate/types/IntermediateType.java delete mode 100644 src/main/java/de/dhbwstuttgart/intermediate/types/IntermediateWildcard.java delete mode 100644 src/test/java/intermediate/generation/FunNTest.java delete mode 100644 src/test/java/intermediate/types/IntermediateExtensWildcardTest.java delete mode 100644 src/test/java/intermediate/types/IntermediateGenericTypeTest.java delete mode 100644 src/test/java/intermediate/types/IntermediateRefTypeTest.java delete mode 100644 src/test/java/intermediate/types/IntermediateSuperWildcardTest.java delete mode 100644 src/test/java/intermediate/types/IntermediateWildcardTest.java diff --git a/src/main/java/de/dhbwstuttgart/bytecode/BytecodeGenMethod.java b/src/main/java/de/dhbwstuttgart/bytecode/BytecodeGenMethod.java index 208c93bef..526eaa7ad 100644 --- a/src/main/java/de/dhbwstuttgart/bytecode/BytecodeGenMethod.java +++ b/src/main/java/de/dhbwstuttgart/bytecode/BytecodeGenMethod.java @@ -15,12 +15,11 @@ 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; -import de.dhbwstuttgart.intermediate.convert.ASTToIntermediate; -import de.dhbwstuttgart.intermediate.generation.FunN; -import de.dhbwstuttgart.intermediate.types.IntermediateInnerType; import de.dhbwstuttgart.parser.scope.JavaClassName; import de.dhbwstuttgart.syntaxtree.statement.*; import de.dhbwstuttgart.syntaxtree.statement.BinaryExpr.Operator; @@ -595,8 +594,9 @@ public class BytecodeGenMethod implements StatementVisitor { String typeErasure = createDescriptorWithTypeErasure(lambdaExpression); //ByteCodeForFunNGenerator.generateBCForFunN(lambdaExpression, typeErasure,path); //old //ToDo Etienne: umbauen + //ToDo Refactor + /* FunN f; - //ToDo refactor with code for FunN underneath ASTToIntermediate converter = new ASTToIntermediate(); //Fehler in return Typ IntermediateInnerType returnType = (IntermediateInnerType) converter.convert(resolver.resolve(lambdaExpression.getReturnType())); @@ -612,6 +612,22 @@ public class BytecodeGenMethod implements StatementVisitor { f = new FunN(arguments, returnType); FunN.writeClassFile(f.getSuperClassName(), f.getSuperBytecode(), path); FunN.writeClassFile(f.getClassName(), f.getBytecode(), path); + */ + ///* + RefTypeOrTPHOrWildcardOrGeneric returnType = resolver.resolve(lambdaExpression.getReturnType()); + List argumentTypes = lambdaExpression + .params + .getFormalparalist() + .stream() + .map(FormalParameter::getType) + .map(resolver::resolve) + .collect(Collectors.toList()); + FunNUtilities funNUtilities = FunNGenerator.getInstance(); + byte[] superBytecode = funNUtilities.generateSuperBytecode(argumentTypes.size()); + byte[] specializedBytecode = funNUtilities.generateSpecializedBytecode(argumentTypes, returnType); + FunNUtilities.writeClassFile(funNUtilities.getSuperClassName(argumentTypes.size()), superBytecode, path); + FunNUtilities.writeClassFile(funNUtilities.getSpecializedClassName(argumentTypes, returnType), specializedBytecode, path); + //*/ //ToDo Etienne: umbauen end Lambda lam = new Lambda(lambdaExpression); String lamDesc = lam.accept(new DescriptorToString(resultSet)); @@ -835,16 +851,14 @@ public class BytecodeGenMethod implements StatementVisitor { if(clazz.contains(CONSTANTS.$$)) { mDesc = helper.getDescriptorOfApplyMethod(methCallType); //helper.generateBCForFunN(mDesc); //old - //ToDo Etienne: check if it works + //ToDo Etienne: Refactor + /* FunN f; ASTToIntermediate converter = new ASTToIntermediate(); - //Fehler IntermediateInnerType returnType = (IntermediateInnerType) converter.convert(resolver.resolve(methodCall.getType())); List arguments = methodCall - .arglist - .getArguments() + .argTypes .stream() - .map(TypableStatement::getType) .map(resolver::resolve) .map(converter::convert) .filter(t -> t instanceof IntermediateInnerType) @@ -854,6 +868,20 @@ public class BytecodeGenMethod implements StatementVisitor { FunN.writeClassFile(f.getSuperClassName(), f.getSuperBytecode(), path); FunN.writeClassFile(f.getClassName(), f.getBytecode(), path); + */ + ///* + RefTypeOrTPHOrWildcardOrGeneric returnType = resolver.resolve(methodCall.getType()); + List argumentTypes = methodCall + .argTypes + .stream() + .map(resolver::resolve) + .collect(Collectors.toList()); + FunNUtilities funNUtilities = FunNGenerator.getInstance(); + byte[] superBytecode = funNUtilities.generateSuperBytecode(argumentTypes.size()); + byte[] specializedBytecode = funNUtilities.generateSpecializedBytecode(argumentTypes, returnType); + FunNUtilities.writeClassFile(funNUtilities.getSuperClassName(argumentTypes.size()), superBytecode, path); + FunNUtilities.writeClassFile(funNUtilities.getSpecializedClassName(argumentTypes, returnType), specializedBytecode, path); + //*/ //ToDo Etienne End // mDesc = helper.generateBCForFunN(methCallType,typesOfParams); }else { diff --git a/src/main/java/de/dhbwstuttgart/bytecode/descriptor/TypeToDescriptor.java b/src/main/java/de/dhbwstuttgart/bytecode/descriptor/TypeToDescriptor.java index c54f6fc99..dd4f62a28 100644 --- a/src/main/java/de/dhbwstuttgart/bytecode/descriptor/TypeToDescriptor.java +++ b/src/main/java/de/dhbwstuttgart/bytecode/descriptor/TypeToDescriptor.java @@ -1,22 +1,17 @@ package de.dhbwstuttgart.bytecode.descriptor; -import de.dhbwstuttgart.exceptions.NotImplementedException; -import de.dhbwstuttgart.intermediate.convert.ASTToIntermediate; -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{ @Override public String visit(RefType refType) { //ToDo Etienne: check if it works - if (refType.getName().toString().matches("Fun\\d+\\$\\$")) { - String descriptor = new ASTToIntermediate().convert(refType).getDescriptor(); - return descriptor.substring(1, descriptor.length() - 1); + if (refType.getName().toString().matches("Fun\\d+\\$\\$") && refType.getParaList().size() > 0) { + FunNUtilities funNUtilities = FunNGenerator.getInstance(); + return funNUtilities.getSpecializedDescriptor(funNUtilities.getArguments(refType.getParaList()), funNUtilities.getReturnType(refType.getParaList())); } return refType.getName().toString().replace(".", "/"); diff --git a/src/main/java/de/dhbwstuttgart/bytecode/funN/FunNGenerator.java b/src/main/java/de/dhbwstuttgart/bytecode/funN/FunNGenerator.java new file mode 100644 index 000000000..c9eae6b0a --- /dev/null +++ b/src/main/java/de/dhbwstuttgart/bytecode/funN/FunNGenerator.java @@ -0,0 +1,136 @@ +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 java.io.File; +import java.io.FileOutputStream; +import java.util.List; +import java.util.stream.Collectors; + +import static org.objectweb.asm.Opcodes.*; + +//ToDo Kommentieren +public class FunNGenerator implements FunNUtilities{ + + private static FunNGenerator funNGenerator = new FunNGenerator(); + + public static FunNGenerator 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 static String applyDescriptor(RefTypeOrTPHOrWildcardOrGeneric a) { return a.acceptTV(new TypeToDescriptor()); } + private static String applySignature(RefTypeOrTPHOrWildcardOrGeneric a) { return a.acceptTV(new TypeToSignature()); } + + @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 argumentTypes, RefTypeOrTPHOrWildcardOrGeneric returnType) { + StringBuilder funNClassSignature = new StringBuilder(objectSignature + applySignature(new RefType(new JavaClassName(getSuperClassName(argumentTypes.size())), null))); + boolean containsGeneric = false; + + String genericSignature = "<"; + for (int currentTypArgumentIndex = 0; currentTypArgumentIndex < argumentTypes.size(); currentTypArgumentIndex++) { + RefTypeOrTPHOrWildcardOrGeneric typArgument = argumentTypes.get(currentTypArgumentIndex); + if (typArgument == null) continue; + if (typArgument instanceof GenericRefType){ + GenericRefType generic = (GenericRefType) typArgument; + genericSignature += String.format("%s:%s", generic.getParsedName(), applyDescriptor(generic)); + 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 argumentTypes, RefTypeOrTPHOrWildcardOrGeneric returnType) { + if (returnType instanceof TypePlaceholder) returnType = objectRefType; + return String.format("Fun%d$$%s%s", + argumentTypes.size(), + argumentTypes + .stream() + .map(r -> r instanceof TypePlaceholder ? objectRefType : r) + .map(FunNGenerator::applyDescriptor) + .map(d -> String.format("L%s;", d)) + .collect(Collectors.joining()), + applyDescriptor(returnType)) + .replace('/', '$') + .replace(";", "$_$"); + } + + @Override + public String getSpecializedDescriptor(List argumentTypes, RefTypeOrTPHOrWildcardOrGeneric returnType) { + return applyDescriptor(new RefType(new JavaClassName(getSpecializedClassName(argumentTypes, returnType)), null)); + } + + @Override + public String getSpecializedSignature(List argumentTypes, RefTypeOrTPHOrWildcardOrGeneric returnType) { + return applySignature(new RefType(new JavaClassName(getSpecializedClassName(argumentTypes, returnType)), null)); + } + + @Override + public List getArguments(List list) { + return list + .stream() + .limit(Math.max(0, list.size() - 1)) + .collect(Collectors.toList()); + } + + @Override + public RefTypeOrTPHOrWildcardOrGeneric getReturnType(List list) { + if(list.size() == 0) + throw new IndexOutOfBoundsException(); + return list.get(list.size() - 1); + } +} diff --git a/src/main/java/de/dhbwstuttgart/bytecode/funN/FunNUtilities.java b/src/main/java/de/dhbwstuttgart/bytecode/funN/FunNUtilities.java new file mode 100644 index 000000000..d545723b8 --- /dev/null +++ b/src/main/java/de/dhbwstuttgart/bytecode/funN/FunNUtilities.java @@ -0,0 +1,34 @@ +package de.dhbwstuttgart.bytecode.funN; + +import de.dhbwstuttgart.bytecode.utilities.CONSTANTS; +import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric; + +import java.io.File; +import java.io.FileOutputStream; +import java.util.List; + +public interface FunNUtilities { + + byte[] generateSuperBytecode(int numberArguments); + String getSuperClassName(int numberArguments); + + byte[] generateSpecializedBytecode(List argumentTypes, RefTypeOrTPHOrWildcardOrGeneric returnType); + String getSpecializedClassName(List argumentTypes, RefTypeOrTPHOrWildcardOrGeneric returnType); + String getSpecializedDescriptor(List argumentTypes, RefTypeOrTPHOrWildcardOrGeneric returnType); + String getSpecializedSignature(List argumentTypes, RefTypeOrTPHOrWildcardOrGeneric returnType); + + List getArguments(List list); + RefTypeOrTPHOrWildcardOrGeneric getReturnType(List list); + + @Deprecated + public 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; + } +} diff --git a/src/main/java/de/dhbwstuttgart/bytecode/signature/TypeToSignature.java b/src/main/java/de/dhbwstuttgart/bytecode/signature/TypeToSignature.java index e9fc63f98..53b39b3a3 100644 --- a/src/main/java/de/dhbwstuttgart/bytecode/signature/TypeToSignature.java +++ b/src/main/java/de/dhbwstuttgart/bytecode/signature/TypeToSignature.java @@ -5,8 +5,9 @@ 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.intermediate.convert.ASTToIntermediate; import de.dhbwstuttgart.syntaxtree.type.ExtendsWildcardType; import de.dhbwstuttgart.syntaxtree.type.GenericRefType; import de.dhbwstuttgart.syntaxtree.type.RefType; @@ -31,9 +32,10 @@ public class TypeToSignature implements TypeVisitor { if(refType.getName().toString().equals("void")) return "V"; //ToDo Etienne: check if it works - if (refType.getName().toString().matches("Fun\\d+\\$\\$")) - return new ASTToIntermediate().convert(refType).getSignature(); - + if (refType.getName().toString().matches("Fun\\d+\\$\\$") && refType.getParaList().size() > 0){ + 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){ diff --git a/src/main/java/de/dhbwstuttgart/intermediate/convert/ASTToIntermediate.java b/src/main/java/de/dhbwstuttgart/intermediate/convert/ASTToIntermediate.java deleted file mode 100644 index 20ea14ccf..000000000 --- a/src/main/java/de/dhbwstuttgart/intermediate/convert/ASTToIntermediate.java +++ /dev/null @@ -1,73 +0,0 @@ -package de.dhbwstuttgart.intermediate.convert; - -import de.dhbwstuttgart.exceptions.NotImplementedException; -import de.dhbwstuttgart.intermediate.generation.FunN; -import de.dhbwstuttgart.intermediate.types.*; -import de.dhbwstuttgart.syntaxtree.type.*; - -import java.util.List; -import java.util.stream.Collectors; - -public class ASTToIntermediate { - - public IntermediateRefType convert(RefType originalType){ - //ToDo Etienne: check if it works - System.out.println(originalType.getName()); - System.out.println(originalType.getParaList().size()); - - if (originalType.getName().toString().matches("Fun\\d+\\$\\$")){ - if(originalType.getParaList().size() == 0) - throw new RuntimeException("Incorrect FunN Type: No params are defined!"); - List parameters = originalType.getParaList(); - IntermediateInnerType returnType = (IntermediateInnerType) convert(parameters.get(parameters.size() - 1)); - return new FunN(parameters - .stream() - .limit((parameters.size() - 1) > 0 ? (parameters.size() - 1) : 0) - .map(this::convert) - .filter(t -> t instanceof IntermediateInnerType) - .map(t -> (IntermediateInnerType) t) - .collect(Collectors.toList()), returnType); - } - - return new IntermediateRefType(originalType.getName(), - originalType - .getParaList() - .stream() - .map(this::convert) - .collect(Collectors.toList())); - } - - public IntermediateGenericType convert(GenericRefType originalType){ - //no typ argument for e.g. is present in the definition of GenericRefType - return new IntermediateGenericType(originalType.getParsedName()); - } - - public IntermediateSuperWildcard convert(SuperWildcardType originalType){ - IntermediateType innerType = convert(originalType.getInnerType()); - //throws RuntimeException, because only IntermediateInnerType (no wildcards) are allowed as inner types of wildcards - if (!(innerType instanceof IntermediateInnerType)) throw new RuntimeException("False inner type!"); - return new IntermediateSuperWildcard((IntermediateInnerType) innerType); - } - - public IntermediateExtendsWildcard convert(ExtendsWildcardType originalType){ - IntermediateType innerType = convert(originalType.getInnerType()); - //throws RuntimeException because only IntermediateInnerType (no wildcards) are allowed as inner types of wildcards - if (!(innerType instanceof IntermediateInnerType)) throw new RuntimeException("False inner type!"); - return new IntermediateExtendsWildcard((IntermediateInnerType) innerType); - } - - //ToDo Etienne: check if it works - public IntermediateGenericType convert(TypePlaceholder originalType){ - //ToDo muss zu einem Generic werden - return new IntermediateGenericType(originalType.getName()); - } - - public IntermediateType convert(RefTypeOrTPHOrWildcardOrGeneric originalType){ - if (originalType instanceof RefType) return convert((RefType) originalType); - if (originalType instanceof GenericRefType) return convert((GenericRefType) originalType); - if (originalType instanceof SuperWildcardType) return convert((SuperWildcardType) originalType); - if (originalType instanceof ExtendsWildcardType) return convert((ExtendsWildcardType) originalType); - if (originalType instanceof TypePlaceholder) return convert((TypePlaceholder) originalType); - throw new NotImplementedException("There is no conversion defined for this type." + originalType.getClass().getName()); - } -} diff --git a/src/main/java/de/dhbwstuttgart/intermediate/generation/FunN.java b/src/main/java/de/dhbwstuttgart/intermediate/generation/FunN.java deleted file mode 100644 index 11b1ccc8b..000000000 --- a/src/main/java/de/dhbwstuttgart/intermediate/generation/FunN.java +++ /dev/null @@ -1,152 +0,0 @@ -package de.dhbwstuttgart.intermediate.generation; - -import de.dhbwstuttgart.bytecode.utilities.CONSTANTS; -import de.dhbwstuttgart.intermediate.types.IntermediateGenericType; -import de.dhbwstuttgart.intermediate.types.IntermediateInnerType; -import de.dhbwstuttgart.intermediate.types.IntermediateRefType; -import de.dhbwstuttgart.intermediate.types.IntermediateType; -import de.dhbwstuttgart.parser.scope.JavaClassName; -import org.objectweb.asm.ClassWriter; -import org.objectweb.asm.MethodVisitor; -import org.objectweb.asm.Type; - -import java.io.File; -import java.io.FileOutputStream; -import java.util.Collections; -import java.util.List; -import java.util.stream.Collectors; -import java.util.stream.Stream; - -import static org.objectweb.asm.Opcodes.*; - -/** - * Class which represents a function type. - * Offers different methods to generate or interact with this real function type. - * - * @since Studienarbeit Type Erasure - * @author etiennezink - */ -public final class FunN extends IntermediateRefType { - - 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 String objectSignature = new IntermediateRefType(new JavaClassName(Type.getInternalName(Object.class))).getSignature(); - - /** - * Represents the super interface of this specialized function. - */ - private final IntermediateRefType superFunN; - - /** - * Caches the superBytecode after first computation. - */ - private byte[] superBytecode; - - /** - * Caches the bytecode after first computation. - */ - private byte[] bytecode; - - public FunN(IntermediateInnerType returnType){ this(Collections.emptyList(), returnType); } - - public FunN(List typArguments, IntermediateInnerType returnType) { - //using stream-API for single line processing of relevant data in the super()-call - super(new JavaClassName( - String.format("Fun%d$$%s%s", - typArguments.size(), - typArguments - .stream() - .map(IntermediateInnerType::getDescriptor) - .collect(Collectors.joining()), - returnType.getDescriptor()) - .replace('/', '$') - .replace(";", "$_$")), - Stream.concat(typArguments.stream(), Stream.of(returnType)).collect(Collectors.toList())); - superFunN = new IntermediateRefType(new JavaClassName(String.format("Fun%d$$", typArguments.size())), - Stream.concat(typArguments.stream(), Stream.of(returnType)).collect(Collectors.toList())); - } - - public String getSuperClassName() { return superFunN.getClassName(); } - - /** - * @return the bytecode for the super FunN type - */ - public byte[] getSuperBytecode(){ - byte[] superBytecode = this.superBytecode; - if (superBytecode == null){ - String superFunNClassSignature = "<"; - String superFunNMethodSignature = "("; - String superFunNMethodDescriptor = "("; - - //currentParameter < getTypArgumentSize() because the return type is stored in the typArguments as well - for (int currentParameter = 1; currentParameter < getTypArgumentSize(); currentParameter++){ - superFunNClassSignature += String.format("%s%d:%s",argumentGenericBase, currentParameter, objectSignature); - superFunNMethodSignature += new IntermediateGenericType(argumentGenericBase + currentParameter).getSignature(); - superFunNMethodDescriptor += objectSignature; - } - superFunNClassSignature += String.format("%s:%s>%s", returnGeneric, objectSignature, objectSignature); - superFunNMethodSignature += String.format(")%s", new IntermediateGenericType(returnGeneric).getSignature()); - superFunNMethodDescriptor += String.format(")%s", objectSignature); - - ClassWriter classWriter = new ClassWriter(0); - MethodVisitor methodVisitor; - classWriter.visit(bytecodeVersion, ACC_PUBLIC | ACC_ABSTRACT | ACC_INTERFACE, superFunN.getClassName(), superFunNClassSignature, objectSuperType, null); - methodVisitor = classWriter.visitMethod(ACC_PUBLIC | ACC_ABSTRACT, methodName, superFunNMethodDescriptor, superFunNMethodSignature , null); - methodVisitor.visitEnd(); - classWriter.visitEnd(); - superBytecode = classWriter.toByteArray(); - this.superBytecode = superBytecode; - } - return superBytecode; - } - - /** - * Generates the bytecode for this FunN type. - * Make sure to generate the bytecode for the super FunN as well. - * @return the bytecode for this explicit FunN type - */ - public byte[] getBytecode(){ - byte[] bytecode = this.bytecode; - if (bytecode == null){ - String funNClassSignature = objectSignature + superFunN.getSignature(); - boolean containsGeneric = false; - - String genericSignature = "<"; - for (int currentTypArgumentIndex = 0; currentTypArgumentIndex < getTypArgumentSize(); currentTypArgumentIndex++) { - IntermediateType typArgument = getTypArgument(currentTypArgumentIndex); - if (typArgument == null) continue; - if (typArgument instanceof IntermediateGenericType){ - IntermediateGenericType generic = (IntermediateGenericType) typArgument; - genericSignature += String.format("%s:%s", generic.getGenericName(), generic.getDescriptor()); - containsGeneric = true; - } - } - genericSignature += ">"; - if (containsGeneric) funNClassSignature = genericSignature + funNClassSignature; - - ClassWriter classWriter = new ClassWriter(0); - classWriter.visit(bytecodeVersion, ACC_PUBLIC | ACC_ABSTRACT | ACC_INTERFACE, getClassName(), funNClassSignature, objectSuperType, new String[]{superFunN.getClassName()}); - classWriter.visitEnd(); - bytecode = classWriter.toByteArray(); - this.bytecode = bytecode; - } - return bytecode; - } - - //ToDo Etienne: Auslagern in andere Klasse; - @Deprecated - public 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; - } -} diff --git a/src/main/java/de/dhbwstuttgart/intermediate/types/IntermediateExtendsWildcard.java b/src/main/java/de/dhbwstuttgart/intermediate/types/IntermediateExtendsWildcard.java deleted file mode 100644 index 0bfde0ece..000000000 --- a/src/main/java/de/dhbwstuttgart/intermediate/types/IntermediateExtendsWildcard.java +++ /dev/null @@ -1,57 +0,0 @@ -package de.dhbwstuttgart.intermediate.types; - -/** - * Represents a Java Wildcard with a extends-operator. - * E.g. {@code <? extends String>} - * - * @since Studienarbeit Type Erasure - * @author etiennezink - */ -public final class IntermediateExtendsWildcard extends IntermediateType { - - private final IntermediateInnerType innerType; - - /** - * Caches the hashCode after first computation. - */ - private int hashCode; - - /** - * Caches the signature after first computation. - */ - private String signature = ""; - - public IntermediateExtendsWildcard(IntermediateInnerType innerType) { - this.innerType = innerType; - } - - @Override - public boolean equals(Object o) { - if (!(o instanceof IntermediateExtendsWildcard)) return false; - - IntermediateExtendsWildcard intermediateExtendsWildcard = (IntermediateExtendsWildcard) o; - if(!innerType.equals(intermediateExtendsWildcard.innerType)) return false; - return true; - } - - @Override - public int hashCode() { - int prime = 31; - int hashCode = this.hashCode; - if (hashCode == 0){ - hashCode += innerType.hashCode(); - hashCode = prime * hashCode + "extends".hashCode(); - this.hashCode = hashCode; - } - return hashCode; - } - - @Override - public String getSignature() { - String signature = this.signature; - if (!signature.equals("")) return this.signature; - signature = String.format("+%s", innerType.getSignature()); - this.signature = signature; - return signature; - } -} diff --git a/src/main/java/de/dhbwstuttgart/intermediate/types/IntermediateGenericType.java b/src/main/java/de/dhbwstuttgart/intermediate/types/IntermediateGenericType.java deleted file mode 100644 index a222dc2c9..000000000 --- a/src/main/java/de/dhbwstuttgart/intermediate/types/IntermediateGenericType.java +++ /dev/null @@ -1,85 +0,0 @@ -package de.dhbwstuttgart.intermediate.types; - -import de.dhbwstuttgart.parser.scope.JavaClassName; -import org.objectweb.asm.Type; - -/** - * Represents a Java typ variable. - * E.g. {@code <T>} or {@code <T extends String>}. - * - * @since Studienarbeit Type Erasure - * @author etiennezink - */ -public final class IntermediateGenericType extends IntermediateInnerType { - - private final String genericName; - private final IntermediateInnerType innerType; - - /** - * Caches the hashCode after first computation. - */ - private int hashCode; - - /** - * Caches the signature after first computation. - */ - private String signature = ""; - - /** - * Caches the descriptor after first computation. - */ - private String descriptor = ""; - - public IntermediateGenericType(String genericName){ - this(genericName, new IntermediateRefType(new JavaClassName(Type.getInternalName(Object.class)))); - } - - public IntermediateGenericType(String genericName, IntermediateInnerType innerType) { - this.innerType = innerType; - this.genericName = genericName; - } - - @Override - public boolean equals(Object o) { - if (!(o instanceof IntermediateGenericType)) return false; - - IntermediateGenericType intermediateGenericType = (IntermediateGenericType) o; - if(!innerType.equals(intermediateGenericType.innerType)) return false; - if(!genericName.equals(intermediateGenericType.genericName)) return false; - return true; - } - - @Override - public int hashCode() { - int prime = 31; - int hashCode = this.hashCode; - if (hashCode == 0){ - hashCode += innerType.hashCode(); - hashCode = prime * hashCode + genericName.hashCode(); - this.hashCode = hashCode; - } - return hashCode; - } - - @Override - public String getSignature() { - String signature = this.signature; - if (!signature.equals("")) return this.signature; - signature += String.format("T%s;", genericName); - this.signature = signature; - return signature; - } - - @Override - public String getDescriptor() { - String descriptor = this.descriptor; - if (!descriptor.equals("")) return this.descriptor; - descriptor = innerType.getDescriptor(); - this.descriptor = descriptor; - return descriptor; - } - - public String getGenericName() { - return genericName; - } -} diff --git a/src/main/java/de/dhbwstuttgart/intermediate/types/IntermediateInnerType.java b/src/main/java/de/dhbwstuttgart/intermediate/types/IntermediateInnerType.java deleted file mode 100644 index f10fe157f..000000000 --- a/src/main/java/de/dhbwstuttgart/intermediate/types/IntermediateInnerType.java +++ /dev/null @@ -1,8 +0,0 @@ -package de.dhbwstuttgart.intermediate.types; - -/** - * Only Java types which can be used as an inner type, have a descriptor definition. - */ -public abstract class IntermediateInnerType extends IntermediateType { - public abstract String getDescriptor(); -} diff --git a/src/main/java/de/dhbwstuttgart/intermediate/types/IntermediateRefType.java b/src/main/java/de/dhbwstuttgart/intermediate/types/IntermediateRefType.java deleted file mode 100644 index 91be08c06..000000000 --- a/src/main/java/de/dhbwstuttgart/intermediate/types/IntermediateRefType.java +++ /dev/null @@ -1,115 +0,0 @@ -package de.dhbwstuttgart.intermediate.types; - -import de.dhbwstuttgart.parser.scope.JavaClassName; -import java.util.ArrayList; -import java.util.Collections; -import java.util.List; - -/** - * Represents a Java reference type. - * - * @since Studienarbeit Type Erasure - * @author etiennezink - */ -public class IntermediateRefType extends IntermediateInnerType{ - - private final List typArguments; - private final JavaClassName className; - - /** - * Caches the hashCode after first computation. - */ - private int hashCode; - - /** - * Caches the signature after first computation. - */ - private String signature = ""; - - /** - * Caches the descriptor after first computation. - */ - private String descriptor = ""; - - public IntermediateRefType(JavaClassName className) { this(className, Collections.emptyList()); } - - public IntermediateRefType(JavaClassName className, List typArguments){ - this.className = className; - this.typArguments = Collections.unmodifiableList(typArguments); - } - - @Override - public boolean equals(Object o) { - if (!(o instanceof IntermediateRefType)) return false; - - IntermediateRefType intermediateRefType = (IntermediateRefType) o; - if(!getFullyQualifiedName().equals(intermediateRefType.getFullyQualifiedName())) return false; - - for(int index = 0; index < typArguments.size(); index++){ - if(!typArguments.get(index).equals(intermediateRefType.typArguments.get(index))) return false; - } - return true; - } - - @Override - public int hashCode() { - int prime = 31; - int hashCode = this.hashCode; - if (hashCode == 0){ - hashCode += getFullyQualifiedName().hashCode(); - for (IntermediateType typeArgument: typArguments) { - hashCode = prime * hashCode + typeArgument.hashCode(); - } - this.hashCode = hashCode; - } - return hashCode; - } - - @Override - public String getSignature() { - String signature = this.signature; - if (!signature.equals("")) return this.signature; - - if (className.getClassName().equals("void")) signature = "V"; - else { - signature += String.format("L%s", getFullyQualifiedName()); - if (typArguments.size() != 0){ - signature += "<"; - for (IntermediateType typArgument: typArguments) { - signature += typArgument.getSignature(); - } - signature += ">"; - } - signature += ";"; - } - signature = signature.replace('.','/'); - this.signature = signature; - return signature; - } - - @Override - public String getDescriptor() { - String descriptor = this.descriptor; - if (!descriptor.equals("")) return this.descriptor; - descriptor = getSignature().replaceAll("<.+>", ""); - this.descriptor = descriptor; - return descriptor; - } - - public boolean isParametrized() { return typArguments.size() > 0; } - - public int getTypArgumentSize(){ return typArguments.size(); } - - /** - * @param index - * @return the typ parameter at {@code index} or {@code null}, iff {@code |typ parameters| < index} - */ - public IntermediateType getTypArgument(int index) { - if(typArguments.size() < index) return null; - return typArguments.get(index); - } - - public String getClassName(){ return className.getClassName(); } - public String getPackageName(){ return className.getPackageName(); } - public String getFullyQualifiedName(){ return className.toString(); } -} diff --git a/src/main/java/de/dhbwstuttgart/intermediate/types/IntermediateSuperWildcard.java b/src/main/java/de/dhbwstuttgart/intermediate/types/IntermediateSuperWildcard.java deleted file mode 100644 index 33b8cf803..000000000 --- a/src/main/java/de/dhbwstuttgart/intermediate/types/IntermediateSuperWildcard.java +++ /dev/null @@ -1,56 +0,0 @@ -package de.dhbwstuttgart.intermediate.types; - -/** - * Represents a Java Wildcard with a super-operator. - * E.g. {@code <? super String>} - * - * @since Studienarbeit Type Erasure - * @author etiennezink - */ -public final class IntermediateSuperWildcard extends IntermediateType { - private final IntermediateInnerType innerType; - - /** - * Caches the hashCode after first computation. - */ - private int hashCode; - - /** - * Caches the signature after first computation. - */ - private String signature = ""; - - public IntermediateSuperWildcard(IntermediateInnerType innerType) { - this.innerType = innerType; - } - - @Override - public boolean equals(Object o) { - if (!(o instanceof IntermediateSuperWildcard)) return false; - - IntermediateSuperWildcard intermediateSuperWildcard = (IntermediateSuperWildcard) o; - if(!innerType.equals(intermediateSuperWildcard.innerType)) return false; - return true; - } - - @Override - public int hashCode() { - int prime = 31; - int hashCode = this.hashCode; - if (hashCode == 0){ - hashCode += innerType.hashCode(); - hashCode = prime * hashCode + "super".hashCode(); - this.hashCode = hashCode; - } - return hashCode; - } - - @Override - public String getSignature() { - String signature = this.signature; - if (!signature.equals("")) return this.signature; - signature = String.format("-%s", innerType.getSignature()); - this.signature = signature; - return signature; - } -} diff --git a/src/main/java/de/dhbwstuttgart/intermediate/types/IntermediateType.java b/src/main/java/de/dhbwstuttgart/intermediate/types/IntermediateType.java deleted file mode 100644 index 3edaf9b0a..000000000 --- a/src/main/java/de/dhbwstuttgart/intermediate/types/IntermediateType.java +++ /dev/null @@ -1,23 +0,0 @@ -package de.dhbwstuttgart.intermediate.types; - -/** - * Base class for Java data types which is used as an intermediate representation after type resolution. - * This class and it's subtypes have to be immutable (e.g. no mutators) to ensure side effect freedom. - * Immutability and final subtypes are essential for future parallel processing. - * - * @since Studienarbeit Type Erasure - * @author etiennezink - */ -public abstract class IntermediateType { - - @Override - public abstract boolean equals(Object o); - - @Override - public abstract int hashCode(); - - public abstract String getSignature(); - - @Override - public String toString() { return getSignature(); } -} diff --git a/src/main/java/de/dhbwstuttgart/intermediate/types/IntermediateWildcard.java b/src/main/java/de/dhbwstuttgart/intermediate/types/IntermediateWildcard.java deleted file mode 100644 index 92020d101..000000000 --- a/src/main/java/de/dhbwstuttgart/intermediate/types/IntermediateWildcard.java +++ /dev/null @@ -1,33 +0,0 @@ -package de.dhbwstuttgart.intermediate.types; - -/** - * Represents a Java wildcard {@code <?>}. - * - * @since Studienarbeit Type Erasure - * @author etiennezink - */ -public final class IntermediateWildcard extends IntermediateType{ - - /** - * Caches the hashCode after first computation. - */ - private int hashCode; - - @Override - public boolean equals(Object o) { return o instanceof IntermediateWildcard; } - - @Override - public int hashCode() { - int prime = 31; - int hashCode = this.hashCode; - if (hashCode == 0){ - hashCode += "wildcard".hashCode(); - hashCode = prime * hashCode + "*".hashCode(); - this.hashCode = hashCode; - } - return hashCode; - } - - @Override - public String getSignature() { return "*"; } -} diff --git a/src/test/java/intermediate/generation/FunNTest.java b/src/test/java/intermediate/generation/FunNTest.java deleted file mode 100644 index d94595cd5..000000000 --- a/src/test/java/intermediate/generation/FunNTest.java +++ /dev/null @@ -1,117 +0,0 @@ -package intermediate.generation; - -import de.dhbwstuttgart.intermediate.generation.FunN; -import de.dhbwstuttgart.intermediate.types.IntermediateGenericType; -import de.dhbwstuttgart.intermediate.types.IntermediateRefType; -import de.dhbwstuttgart.parser.scope.JavaClassName; -import org.junit.BeforeClass; -import org.junit.Test; -import org.objectweb.asm.ClassWriter; -import org.objectweb.asm.MethodVisitor; -import org.objectweb.asm.Type; - -import java.util.Arrays; - -import static org.junit.Assert.assertArrayEquals; -import static org.junit.Assert.assertEquals; -import static org.objectweb.asm.Opcodes.*; - -public class FunNTest { - - private static FunN fun0T; - - private static String fun1IntIntSignature; - private static String fun1IntIntDescriptor; - private static FunN fun1IntInt; - - private static FunN fun2IntIntString; - - @BeforeClass - public static void SetUp(){ - IntermediateRefType integer = new IntermediateRefType(new JavaClassName(Type.getInternalName(Integer.class))); - IntermediateRefType string = new IntermediateRefType(new JavaClassName(Type.getInternalName(String.class))); - - fun0T = new FunN(new IntermediateGenericType("T")); - - fun1IntIntSignature = "LFun1$$Ljava$lang$Integer$_$Ljava$lang$Integer$_$;"; - fun1IntIntDescriptor = "LFun1$$Ljava$lang$Integer$_$Ljava$lang$Integer$_$;"; - fun1IntInt = new FunN(Arrays.asList(integer), integer); - - fun2IntIntString = new FunN(Arrays.asList(integer, integer), string); - } - - @Test - public void SignatureTest_Fun1IntegerInteger(){ assertEquals(fun1IntIntSignature, fun1IntInt.getSignature()); } - - @Test - public void DescriptorTest_Fun1IntegerInteger(){ assertEquals(fun1IntIntDescriptor, fun1IntInt.getDescriptor()); } - - @Test - public void BytecodeTest_Super0(){ assertArrayEquals(generatedASMFun0(), fun0T.getSuperBytecode()) ;} - - @Test - public void BytecodeTest_Fun0T(){ assertArrayEquals(generatedASMFun0T(), fun0T.getBytecode()) ;} - - @Test - public void BytecodeTest_Super1(){ assertArrayEquals(generatedASMFun1(), fun1IntInt.getSuperBytecode()) ;} - - @Test - public void BytecodeTest_Fun1IntInt(){ assertArrayEquals(generatedASMFun1IntInt(), fun1IntInt.getBytecode()) ;} - - @Test - public void BytecodeTest_Super2(){ assertArrayEquals(generatedASMFun2(), fun2IntIntString.getSuperBytecode()) ;} - - @Test - public void BytecodeTest_Fun2IntIntString(){ assertArrayEquals(generatedASMFun2IntIntString(), fun2IntIntString.getBytecode()) ;} - - private byte[] generatedASMFun0() { - ClassWriter classWriter = new ClassWriter(0); - MethodVisitor methodVisitor; - classWriter.visit(V1_8, ACC_PUBLIC | ACC_ABSTRACT | ACC_INTERFACE, "Fun0$$", "Ljava/lang/Object;", "java/lang/Object", null); - methodVisitor = classWriter.visitMethod(ACC_PUBLIC | ACC_ABSTRACT, "apply", "()Ljava/lang/Object;", "()TR;", null); - methodVisitor.visitEnd(); - classWriter.visitEnd(); - return classWriter.toByteArray(); - } - - private byte[] generatedASMFun0T() { - ClassWriter classWriter = new ClassWriter(0); - classWriter.visit(V1_8, ACC_PUBLIC | ACC_ABSTRACT | ACC_INTERFACE, "Fun0$$TT$_$", "Ljava/lang/Object;LFun0$$;", "java/lang/Object", new String[]{"Fun0$$"}); - classWriter.visitEnd(); - return classWriter.toByteArray(); - } - - private byte[] generatedASMFun1() { - ClassWriter classWriter = new ClassWriter(0); - MethodVisitor methodVisitor; - classWriter.visit(V1_8, ACC_PUBLIC | ACC_ABSTRACT | ACC_INTERFACE, "Fun1$$", "Ljava/lang/Object;", "java/lang/Object", null); - 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 byte[] generatedASMFun1IntInt() { - 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$$;", "java/lang/Object", new String[]{"Fun1$$"}); - classWriter.visitEnd(); - return classWriter.toByteArray(); - } - - private byte[] generatedASMFun2() { - ClassWriter classWriter = new ClassWriter(0); - MethodVisitor methodVisitor; - classWriter.visit(V1_8, ACC_PUBLIC | ACC_ABSTRACT | ACC_INTERFACE, "Fun2$$", "Ljava/lang/Object;", "java/lang/Object", null); - 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(); - } - - private byte[] generatedASMFun2IntIntString() { - ClassWriter classWriter = new ClassWriter(0); - classWriter.visit(V1_8, ACC_PUBLIC | ACC_ABSTRACT | ACC_INTERFACE, "Fun2$$Ljava$lang$Integer$_$Ljava$lang$Integer$_$Ljava$lang$String$_$", "Ljava/lang/Object;LFun2$$;", "java/lang/Object", new String[]{"Fun2$$"}); - classWriter.visitEnd(); - return classWriter.toByteArray(); - } -} diff --git a/src/test/java/intermediate/types/IntermediateExtensWildcardTest.java b/src/test/java/intermediate/types/IntermediateExtensWildcardTest.java deleted file mode 100644 index f097310a2..000000000 --- a/src/test/java/intermediate/types/IntermediateExtensWildcardTest.java +++ /dev/null @@ -1,62 +0,0 @@ -package intermediate.types; - -import de.dhbwstuttgart.intermediate.types.IntermediateExtendsWildcard; -import de.dhbwstuttgart.intermediate.types.IntermediateGenericType; -import de.dhbwstuttgart.intermediate.types.IntermediateRefType; -import de.dhbwstuttgart.parser.scope.JavaClassName; -import org.junit.BeforeClass; -import org.junit.Test; -import org.objectweb.asm.Type; - -import java.util.Arrays; -import java.util.List; - -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNotEquals; - -public class IntermediateExtensWildcardTest { - - private static String integerWildcardSignature; - private static IntermediateRefType integerWildcard; - - private static String tWildcardSignature; - private static IntermediateRefType tWildcard; - - private static IntermediateRefType tWildcardSame; - - @BeforeClass - public static void StartUp(){ - - integerWildcardSignature = "Ljava/util/List<+Ljava/lang/Integer;>;"; - integerWildcard = new IntermediateRefType( - new JavaClassName(Type.getInternalName(List.class)), - Arrays.asList(new IntermediateExtendsWildcard(new IntermediateRefType(new JavaClassName(Type.getInternalName(Integer.class)))))); - - tWildcardSignature = "Ljava/util/List<+TT;>;"; - tWildcard = new IntermediateRefType( - new JavaClassName(Type.getInternalName(List.class)), - Arrays.asList(new IntermediateExtendsWildcard(new IntermediateGenericType("T")))); - - tWildcardSame = new IntermediateRefType( - new JavaClassName(Type.getInternalName(List.class)), - Arrays.asList(new IntermediateExtendsWildcard(new IntermediateGenericType("T")))); - } - - @Test - public void SignatureTest_Integer(){ assertEquals(integerWildcardSignature, integerWildcard.getSignature()); } - - @Test - public void SignatureTest_T(){ assertEquals(tWildcardSignature, tWildcard.getSignature()); } - - @Test - public void HashCodeTest_Succeed() { assertEquals(tWildcardSame.hashCode(), tWildcard.hashCode());} - - @Test - public void HashCodeTest_Fail() { assertNotEquals(tWildcardSame.hashCode(), integerWildcard.hashCode()); } - - @Test - public void EqualsTest_Succeed() { assertEquals(tWildcardSame, tWildcard); } - - @Test - public void EqualsTest_Fail() { assertNotEquals(tWildcardSame, integerWildcard); } -} diff --git a/src/test/java/intermediate/types/IntermediateGenericTypeTest.java b/src/test/java/intermediate/types/IntermediateGenericTypeTest.java deleted file mode 100644 index f680e5c3e..000000000 --- a/src/test/java/intermediate/types/IntermediateGenericTypeTest.java +++ /dev/null @@ -1,80 +0,0 @@ -package intermediate.types; - -import de.dhbwstuttgart.intermediate.types.IntermediateGenericType; -import de.dhbwstuttgart.intermediate.types.IntermediateRefType; -import de.dhbwstuttgart.parser.scope.JavaClassName; -import org.junit.BeforeClass; -import org.junit.Test; -import org.objectweb.asm.Type; - -import java.util.Arrays; -import java.util.List; - -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNotEquals; - -public class IntermediateGenericTypeTest { - - private static String tSignature; - private static String tDescriptor; - private static IntermediateGenericType t; - - private static String sExtendsStringSignature; - private static String sExtendsStringDescriptor; - private static IntermediateGenericType sExtendsString; - - private static String rExtendsSSignature; - private static String rExtendsSDescriptor; - private static IntermediateGenericType rExtendsS; - - private static IntermediateGenericType rSame; - - @BeforeClass - public static void StartUp(){ - tSignature = "TT;"; - tDescriptor = "Ljava/lang/Object;"; - t = new IntermediateGenericType("T"); - - sExtendsStringSignature = "TS;"; - sExtendsStringDescriptor = "Ljava/util/List;"; - sExtendsString = new IntermediateGenericType("S", - new IntermediateRefType(new JavaClassName(Type.getInternalName(List.class)), - Arrays.asList(new IntermediateRefType(new JavaClassName(Type.getInternalName(Integer.class)))))); - - rExtendsSSignature = "TR;"; - rExtendsSDescriptor = sExtendsStringDescriptor; - rExtendsS = new IntermediateGenericType("R", sExtendsString); - - rSame = new IntermediateGenericType("R", sExtendsString); - } - - @Test - public void SignatureTest_T(){ assertEquals(tSignature, t.getSignature()); } - - @Test - public void DescriptorTest_T(){ assertEquals(tDescriptor, t.getDescriptor()); } - - @Test - public void SignatureTest_TExtendsString(){ assertEquals(sExtendsStringSignature, sExtendsString.getSignature()); } - - @Test - public void DescriptorTest_TExtendsString(){ assertEquals(sExtendsStringDescriptor, sExtendsString.getDescriptor()); } - - @Test - public void SignatureTest_TExtendsS(){ assertEquals(rExtendsSSignature, rExtendsS.getSignature()); } - - @Test - public void DescriptorTest_TExtendsS(){ assertEquals(rExtendsSDescriptor, rExtendsS.getDescriptor()); } - - @Test - public void HashCodeTest_Succeed() { assertEquals(rSame.hashCode(), rExtendsS.hashCode());} - - @Test - public void HashCodeTest_Fail() { assertNotEquals(rSame.hashCode(), t.hashCode()); } - - @Test - public void EqualsTest_Succeed() { assertEquals(rSame, rExtendsS); } - - @Test - public void EqualsTest_Fail() { assertNotEquals(rSame, t); } -} diff --git a/src/test/java/intermediate/types/IntermediateRefTypeTest.java b/src/test/java/intermediate/types/IntermediateRefTypeTest.java deleted file mode 100644 index fdcca7e24..000000000 --- a/src/test/java/intermediate/types/IntermediateRefTypeTest.java +++ /dev/null @@ -1,107 +0,0 @@ -package intermediate.types; - -import de.dhbwstuttgart.intermediate.types.IntermediateGenericType; -import de.dhbwstuttgart.intermediate.types.IntermediateRefType; -import de.dhbwstuttgart.parser.scope.JavaClassName; - -import org.junit.BeforeClass; -import org.junit.Test; -import org.objectweb.asm.Type; - -import java.util.Arrays; -import java.util.List; - -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNotEquals; - -public class IntermediateRefTypeTest { - - private static String integerSignature; - private static String integerDescriptor; - private static IntermediateRefType typeToTest_Integer; - - private static String listOfIntegerSignature; - private static String listOfIntegerDescriptor; - private static IntermediateRefType typeToTest_ListOfInteger; - - private static String listOfTSignature; - private static String listOfTDescriptor; - private static IntermediateRefType typeToTest_ListOfT; - - private static String voidSignature; - private static String voidDescriptor; - private static IntermediateRefType typeToTest_void; - - private static IntermediateRefType typeToTest_ListOfIntegerSame; - - @BeforeClass - public static void StartUp(){ - integerSignature = "Ljava/lang/Integer;"; - integerDescriptor = "Ljava/lang/Integer;"; - typeToTest_Integer = new IntermediateRefType(new JavaClassName(Type.getInternalName(Integer.class))); - - listOfIntegerSignature = "Ljava/util/List;"; - listOfIntegerDescriptor = "Ljava/util/List;"; - typeToTest_ListOfInteger = new IntermediateRefType( - new JavaClassName(Type.getInternalName(List.class)), - Arrays.asList(typeToTest_Integer)); - - listOfTSignature = "Ljava/util/List;"; - listOfTDescriptor = "Ljava/util/List;"; - typeToTest_ListOfT = new IntermediateRefType( - new JavaClassName(Type.getInternalName(List.class)), - Arrays.asList(new IntermediateGenericType("T"))); - - voidSignature = "V"; - voidDescriptor = "V"; - typeToTest_void = new IntermediateRefType(new JavaClassName("void")); - - typeToTest_ListOfIntegerSame = new IntermediateRefType( - new JavaClassName(Type.getInternalName(List.class)), - Arrays.asList(typeToTest_Integer)); - } - - @Test - public void SignatureTest_Integer(){ - assertEquals(integerSignature, typeToTest_Integer.getSignature()); - } - - @Test - public void DescriptorTest_Integer(){ - assertEquals(integerDescriptor, typeToTest_Integer.getDescriptor()); - } - - @Test - public void SignatureTest_List(){ assertEquals(listOfIntegerSignature, typeToTest_ListOfInteger.getSignature()); } - - @Test - public void DescriptorTest_List(){ assertEquals(listOfIntegerDescriptor, typeToTest_ListOfInteger.getDescriptor()); } - - @Test - public void SignatureTest_ListT(){ assertEquals(listOfTSignature, typeToTest_ListOfT.getSignature()); } - - @Test - public void DescriptorTest_ListT(){ assertEquals(listOfTDescriptor, typeToTest_ListOfT.getDescriptor()); } - - @Test - public void SignatureTest_Void(){ - assertEquals(voidSignature, typeToTest_void.getSignature()); - } - - @Test - public void DescriptorTest_Void(){ - assertEquals(voidDescriptor, typeToTest_void.getDescriptor()); - } - - @Test - public void HashCodeTest_Succeed() { assertEquals(typeToTest_ListOfIntegerSame.hashCode(), typeToTest_ListOfInteger.hashCode());} - - @Test - public void HashCodeTest_Fail() { assertNotEquals(typeToTest_ListOfIntegerSame.hashCode(), typeToTest_Integer.hashCode()); } - - @Test - public void EqualsTest_Succeed() { assertEquals(typeToTest_ListOfIntegerSame, typeToTest_ListOfInteger); } - - @Test - public void EqualsTest_Fail() { assertNotEquals(typeToTest_ListOfIntegerSame, typeToTest_Integer); } -} diff --git a/src/test/java/intermediate/types/IntermediateSuperWildcardTest.java b/src/test/java/intermediate/types/IntermediateSuperWildcardTest.java deleted file mode 100644 index 4571ddf5a..000000000 --- a/src/test/java/intermediate/types/IntermediateSuperWildcardTest.java +++ /dev/null @@ -1,62 +0,0 @@ -package intermediate.types; - -import de.dhbwstuttgart.intermediate.types.IntermediateGenericType; -import de.dhbwstuttgart.intermediate.types.IntermediateRefType; -import de.dhbwstuttgart.intermediate.types.IntermediateSuperWildcard; -import de.dhbwstuttgart.parser.scope.JavaClassName; -import org.junit.BeforeClass; -import org.junit.Test; -import org.objectweb.asm.Type; - -import java.util.Arrays; -import java.util.List; - -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNotEquals; - -public class IntermediateSuperWildcardTest { - - private static String integerWildcardSignature; - private static IntermediateRefType integerWildcard; - - private static String tWildcardSignature; - private static IntermediateRefType tWildcard; - - private static IntermediateRefType tWildcardSame; - - @BeforeClass - public static void StartUp(){ - - integerWildcardSignature = "Ljava/util/List<-Ljava/lang/Integer;>;"; - integerWildcard = new IntermediateRefType( - new JavaClassName(Type.getInternalName(List.class)), - Arrays.asList(new IntermediateSuperWildcard(new IntermediateRefType(new JavaClassName(Type.getInternalName(Integer.class)))))); - - tWildcardSignature = "Ljava/util/List<-TT;>;"; - tWildcard = new IntermediateRefType( - new JavaClassName(Type.getInternalName(List.class)), - Arrays.asList(new IntermediateSuperWildcard(new IntermediateGenericType("T")))); - - tWildcardSame = new IntermediateRefType( - new JavaClassName(Type.getInternalName(List.class)), - Arrays.asList(new IntermediateSuperWildcard(new IntermediateGenericType("T")))); - } - - @Test - public void SignatureTest_Integer(){ assertEquals(integerWildcardSignature, integerWildcard.getSignature()); } - - @Test - public void SignatureTest_T(){ assertEquals(tWildcardSignature, tWildcard.getSignature()); } - - @Test - public void HashCodeTest_Succeed() { assertEquals(tWildcardSame.hashCode(), tWildcard.hashCode());} - - @Test - public void HashCodeTest_Fail() { assertNotEquals(tWildcardSame.hashCode(), integerWildcard.hashCode()); } - - @Test - public void EqualsTest_Succeed() { assertEquals(tWildcardSame, tWildcard); } - - @Test - public void EqualsTest_Fail() { assertNotEquals(tWildcardSame, integerWildcard); } -} diff --git a/src/test/java/intermediate/types/IntermediateWildcardTest.java b/src/test/java/intermediate/types/IntermediateWildcardTest.java deleted file mode 100644 index b804d9e9c..000000000 --- a/src/test/java/intermediate/types/IntermediateWildcardTest.java +++ /dev/null @@ -1,57 +0,0 @@ -package intermediate.types; - -import de.dhbwstuttgart.intermediate.types.IntermediateExtendsWildcard; -import de.dhbwstuttgart.intermediate.types.IntermediateGenericType; -import de.dhbwstuttgart.intermediate.types.IntermediateRefType; -import de.dhbwstuttgart.intermediate.types.IntermediateWildcard; -import de.dhbwstuttgart.parser.scope.JavaClassName; -import org.junit.BeforeClass; -import org.junit.Test; -import org.objectweb.asm.Type; - -import java.util.Arrays; -import java.util.List; - -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNotEquals; - -public class IntermediateWildcardTest { - - private static String wildcardSignature; - private static IntermediateRefType wildcard; - - private static IntermediateRefType wildcardSame; - private static IntermediateRefType tWildcard; - - @BeforeClass - public static void StartUp(){ - - wildcardSignature = "Ljava/util/List<*>;"; - wildcard = new IntermediateRefType( - new JavaClassName(Type.getInternalName(List.class)), - Arrays.asList(new IntermediateWildcard())); - - wildcardSame = new IntermediateRefType( - new JavaClassName(Type.getInternalName(List.class)), - Arrays.asList(new IntermediateWildcard())); - - tWildcard = new IntermediateRefType( - new JavaClassName(Type.getInternalName(List.class)), - Arrays.asList(new IntermediateExtendsWildcard(new IntermediateGenericType("T")))); - } - - @Test - public void SignatureTest_Wildcard(){ assertEquals(wildcardSignature, wildcard.getSignature()); } - - @Test - public void HashCodeTest_Succeed() { assertEquals(wildcardSame.hashCode(), wildcard.hashCode());} - - @Test - public void HashCodeTest_Fail() { assertNotEquals(wildcardSame.hashCode(), tWildcard.hashCode()); } - - @Test - public void EqualsTest_Succeed() { assertEquals(wildcardSame, wildcard); } - - @Test - public void EqualsTest_Fail() { assertNotEquals(wildcardSame, tWildcard); } -}