From b56f18c16ecfa685142483690079451c2af87dae Mon Sep 17 00:00:00 2001 From: Fayez Abu Alia Date: Thu, 4 Oct 2018 12:54:03 +0200 Subject: [PATCH] Unboxing fuer methodcall wird nicht gemacht wenn es sich in Returnstatement befindet. SimplifyPairs fuer Paramtrisierte Typen wird einmal vor die Signatureerzeugung ausgefuehrt und nicht separat. getAllPairs in Signature gefixt. --- .../bytecode/BytecodeGenMethod.java | 9 +- .../bytecode/signature/Signature.java | 176 ++++++++++++------ 2 files changed, 129 insertions(+), 56 deletions(-) diff --git a/src/de/dhbwstuttgart/bytecode/BytecodeGenMethod.java b/src/de/dhbwstuttgart/bytecode/BytecodeGenMethod.java index 6bd1829d..c421ddc9 100644 --- a/src/de/dhbwstuttgart/bytecode/BytecodeGenMethod.java +++ b/src/de/dhbwstuttgart/bytecode/BytecodeGenMethod.java @@ -70,6 +70,7 @@ public class BytecodeGenMethod implements StatementVisitor { private String path; private SourceFile sf; private IStatement statement = null; + private boolean isReturnStmt = false; private boolean needDUP = false; @@ -780,8 +781,8 @@ public class BytecodeGenMethod implements StatementVisitor { if(isBinaryExp) doUnboxing(getResolvedType(methodCall.getType())); } - - if(methodRefl == null) { + + if(methodRefl == null && !isReturnStmt) { if(isBinaryExp) doUnboxing(getResolvedType(methodCall.getType())); } @@ -958,6 +959,7 @@ public class BytecodeGenMethod implements StatementVisitor { @Override public void visit(Return aReturn) { statement = new ReturnStmt(aReturn.retexpr); + isReturnStmt = true; isBinaryExp = statement.isExprBinary(); boolean isBinary = isBinaryExp; if(aReturn.retexpr instanceof UnaryExpr) @@ -970,8 +972,9 @@ public class BytecodeGenMethod implements StatementVisitor { doBoxing(getResolvedType(binary.getType())); // isBinaryExp = false; } - + mv.visitInsn(Opcodes.ARETURN); + isReturnStmt = false; statement = null; } diff --git a/src/de/dhbwstuttgart/bytecode/signature/Signature.java b/src/de/dhbwstuttgart/bytecode/signature/Signature.java index ffcf5409..6f387f17 100644 --- a/src/de/dhbwstuttgart/bytecode/signature/Signature.java +++ b/src/de/dhbwstuttgart/bytecode/signature/Signature.java @@ -117,6 +117,21 @@ public class Signature { // z.B: Type = TPH K => wird eine Formal Type Parameter K$ erzeugt und Bound = Object if(!isConstructor) { String ret = resultSet.resolveType(method.getReturnType()).resolvedType.acceptTV(new TypeToSignature()); + ArrayList allPairs = new ArrayList<>(); + if(ret.contains("<")) { + allPairs = getAllPairs((RefType) resultSet.resolveType(method.getReturnType()).resolvedType); + } + + for(String paramName : methodParamsAndTypes.keySet()) { + RefTypeOrTPHOrWildcardOrGeneric t = methodParamsAndTypes.get(paramName); + String pT = t.acceptTV(new TypeToSignature()); + + if(pT.contains("<")) + allPairs.addAll(getAllPairs((RefType) t)); + } + + createTypeVars(allPairs); + if(!ret.equals("V")) { // TODO TypeToSignature nochmal kontrollieren und schauen ob man dort wirklich // T... braucht und L ... @@ -131,15 +146,15 @@ public class Signature { } } - if(ret.contains("<")) { - RefType ref = (RefType) resultSet.resolveType(method.getReturnType()).resolvedType; - if(hasTPHs(ref)) { - createSignatureForParameterizedType(ref); - } - System.out.println("HAS WC = " + hasWC(ref)); - if(hasWC(ref)) - createSigForParamTypeWithWC(ref); - } +// if(ret.contains("<")) { +// RefType ref = (RefType) resultSet.resolveType(method.getReturnType()).resolvedType; +// if(hasTPHs(ref)) { +// createSignatureForParameterizedType(ref); +// } +// System.out.println("HAS WC = " + hasWC(ref)); +// if(hasWC(ref)) +// createSigForParamTypeWithWC(ref); +// } } } @@ -173,14 +188,14 @@ public class Signature { } } - if(pT.contains("<")) { - RefType ref = (RefType) methodParamsAndTypes.get(paramName); - if(hasTPHs(ref)) - createSignatureForParameterizedType(ref); - - if(hasWC(ref)) - createSigForParamTypeWithWC(ref); - } +// if(pT.contains("<")) { +// RefType ref = (RefType) methodParamsAndTypes.get(paramName); +// if(hasTPHs(ref)) +// createSignatureForParameterizedType(ref); +// +// if(hasWC(ref)) +// createSigForParamTypeWithWC(ref); +// } for(GenericInsertPair p:methodPairs) { String name = p.TA1.getName()+"$"; @@ -228,6 +243,41 @@ public class Signature { // sw.visitEnd(); } + private void createTypeVars(ArrayList allPairs) { + allPairs.addAll(methodPairs); + ArrayList simplifiedPairs = simplifyPairs(allPairs); + + HashMap names = new HashMap<>(); + + for(GenericInsertPair pair : simplifiedPairs) { +// if(ref.getParaList().contains(pair.TA1)) { + String sub = pair.TA1.getName()+"$"; + String superT = pair.TA2.getName()+"$"; + names.put(sub, superT); +// } + } + + for(String sub : names.keySet()) { + if(!genericsAndBoundsMethod.containsKey(sub) && !genericsAndBounds.containsKey(sub)) { + sw.visitFormalTypeParameter(sub); + String bound = names.get(sub); + sw.visitClassBound().visitTypeVariable(bound); + genericsAndBoundsMethod.put(sub, bound); + } + } + + for(String superT : names.values()) { + if(!names.containsKey(superT)) { + if(!genericsAndBoundsMethod.containsKey(superT) && !genericsAndBounds.containsKey(superT)) { + sw.visitFormalTypeParameter(superT); + sw.visitClassBound().visitClassType(Type.getInternalName(Object.class)); + sw.visitClassBound().visitEnd(); + genericsAndBoundsMethod.put(superT, Type.getInternalName(Object.class)); + } + } + } + } + private void createSigForParamTypeWithWC(RefType ref) { for(RefTypeOrTPHOrWildcardOrGeneric p : ref.getParaList()) { if(p instanceof WildcardType) { @@ -264,39 +314,39 @@ public class Signature { } private void createSignatureForParameterizedType(RefType ref) { - ArrayList allPairs = getAllPairs(ref); - allPairs.addAll(methodPairs); - ArrayList simplifiedPairs = simplifyPairs(allPairs); - - HashMap names = new HashMap<>(); - - for(GenericInsertPair pair : simplifiedPairs) { - if(ref.getParaList().contains(pair.TA1)) { - String sub = pair.TA1.getName()+"$"; - String superT = pair.TA2.getName()+"$"; - names.put(sub, superT); - } - } - - for(String sub : names.keySet()) { - if(!genericsAndBoundsMethod.containsKey(sub) && !genericsAndBounds.containsKey(sub)) { - sw.visitFormalTypeParameter(sub); - String bound = names.get(sub); - sw.visitClassBound().visitTypeVariable(bound); - genericsAndBoundsMethod.put(sub, bound); - } - } - - for(String superT : names.values()) { - if(!names.containsKey(superT)) { - if(!genericsAndBoundsMethod.containsKey(superT) && !genericsAndBounds.containsKey(superT)) { - sw.visitFormalTypeParameter(superT); - sw.visitClassBound().visitClassType(Type.getInternalName(Object.class)); - sw.visitClassBound().visitEnd(); - genericsAndBoundsMethod.put(superT, Type.getInternalName(Object.class)); - } - } - } +// ArrayList allPairs = getAllPairs(ref); +// allPairs.addAll(methodPairs); +// ArrayList simplifiedPairs = simplifyPairs(allPairs); +// +// HashMap names = new HashMap<>(); +// +// for(GenericInsertPair pair : simplifiedPairs) { +// if(ref.getParaList().contains(pair.TA1)) { +// String sub = pair.TA1.getName()+"$"; +// String superT = pair.TA2.getName()+"$"; +// names.put(sub, superT); +// } +// } +// +// for(String sub : names.keySet()) { +// if(!genericsAndBoundsMethod.containsKey(sub) && !genericsAndBounds.containsKey(sub)) { +// sw.visitFormalTypeParameter(sub); +// String bound = names.get(sub); +// sw.visitClassBound().visitTypeVariable(bound); +// genericsAndBoundsMethod.put(sub, bound); +// } +// } +// +// for(String superT : names.values()) { +// if(!names.containsKey(superT)) { +// if(!genericsAndBoundsMethod.containsKey(superT) && !genericsAndBounds.containsKey(superT)) { +// sw.visitFormalTypeParameter(superT); +// sw.visitClassBound().visitClassType(Type.getInternalName(Object.class)); +// sw.visitClassBound().visitEnd(); +// genericsAndBoundsMethod.put(superT, Type.getInternalName(Object.class)); +// } +// } +// } for(RefTypeOrTPHOrWildcardOrGeneric p: ref.getParaList()) { if(p instanceof TypePlaceholder) { @@ -314,16 +364,35 @@ public class Signature { private ArrayList getAllPairs(RefType ref) { final ArrayList res = new ArrayList<>(); for(RefTypeOrTPHOrWildcardOrGeneric p : ref.getParaList()) { - RefTypeOrTPHOrWildcardOrGeneric resolved = resultSet.resolveType(p).resolvedType; + ResolvedType resType; + if(p instanceof WildcardType) { + resType = resultSet.resolveType(((WildcardType) p).getInnerType()); + }else { + resType = resultSet.resolveType(p); + } + + RefTypeOrTPHOrWildcardOrGeneric resolved = resType.resolvedType; if(resolved instanceof TypePlaceholder) { - resultSet.resolveType(p).additionalGenerics.forEach(ag ->{ + resType.additionalGenerics.forEach(ag ->{ if(!contains(res,ag)) { res.add(ag); } }); } + if(resolved instanceof WildcardType) { + WildcardType resWC = (WildcardType) resolved; + ResolvedType resType2 = resultSet.resolveType(resWC.getInnerType()); + if(resType2.resolvedType instanceof TypePlaceholder) { + resType2.additionalGenerics.forEach(ag ->{ + if(!contains(res,ag)) { + res.add(ag); + } + }); + } + } } + System.out.println("RES GIP === " + res.size()); return res; } @@ -341,7 +410,8 @@ public class Signature { HashMap subAndSuperTph = new HashMap<>(); for(GenericInsertPair p : allPairs) { - subAndSuperTph.put(p.TA1, p.TA2); + if(!p.TA1.equals(p.TA2)) + subAndSuperTph.put(p.TA1, p.TA2); } subAndSuperTph.forEach((k,v)->System.out.println(k.getName() + " || " + v.getName()));