public static ReferenceType fromTypeX(UnresolvedType tx, World world) { ReferenceType rt = new ReferenceType(tx.getErasureSignature(), world); rt.typeKind = tx.typeKind; return rt; }
public UnresolvedType getRawType() { return UnresolvedType.forSignature(getErasureSignature()); }
/** * Return the erased form of the signature with bounds collapsed for type variables, etc. Does not include the return type, @see * getParam */ public String getParameterSignatureErased() { if (myParameterSignatureErasure == null) { StringBuilder sig = new StringBuilder(); for (UnresolvedType parameter : getParameterTypes()) { sig.append(parameter.getErasureSignature()); } myParameterSignatureErasure = sig.toString(); } return myParameterSignatureErasure; }
public String getErasureSignature() { return getFirstBound().getErasureSignature(); }
public static Type makeBcelType(UnresolvedType type) { return Type.getType(type.getErasureSignature()); }
public String getSignatureErased() { StringBuffer sb = new StringBuffer(); sb.append("("); sb.append(getParameterSignatureErased()); sb.append(")"); sb.append(getReturnType().getErasureSignature()); return sb.toString(); }
/** * Build a signature based on the return type and parameter types. For example: "(Ljava/util/Set<Ljava/lang/String;>;)V" or * "(Ljava/util/Set;)V". The latter form shows what happens when the generics are erased */ public static String typesToSignature(UnresolvedType returnType, UnresolvedType[] paramTypes, boolean eraseGenerics) { StringBuilder buf = new StringBuilder(); buf.append("("); for (UnresolvedType paramType : paramTypes) { if (eraseGenerics) { buf.append(paramType.getErasureSignature()); } else { buf.append(paramType.getSignature()); } } buf.append(")"); if (eraseGenerics) { buf.append(returnType.getErasureSignature()); } else { buf.append(returnType.getSignature()); } return buf.toString(); }
/** * Construct a MemberImpl using real type information for the parameters and return type (member method/ctor) or type (member * field) */ public MemberImpl(MemberKind kind, UnresolvedType declaringType, int modifiers, UnresolvedType returnType, String name, UnresolvedType[] parameterTypes) { this.kind = kind; this.declaringType = declaringType; this.modifiers = modifiers; this.returnType = returnType; this.name = name; this.parameterTypes = parameterTypes; if (kind == FIELD) { this.erasedSignature = returnType.getErasureSignature(); } else { this.erasedSignature = typesToSignature(returnType, parameterTypes, true); // Check parameter recovery by collapsing types to the string then rebuilding them from that // this will check we are capable of having WeakRefs to the parameter types // String nonErasedSignature = getParameterSignature()+getReturnType().getSignature(); // Object[] returnAndParams = signatureToTypes(nonErasedSignature); // UnresolvedType[] recoveredParams = (UnresolvedType[]) returnAndParams[1]; // for (int jj=0;jj<parameterTypes.length;jj++) { // if (!parameterTypes[jj].getSignature().equals(recoveredParams[jj].getSignature())) { // throw new // RuntimeException(parameterTypes[jj].getSignature()+" != "+recoveredParams[jj].getSignature()+" "+paramSignature); // } // } } }
public void setTypeVariable(TypeVariable aTypeVariable) { this.signature = "T" + aTypeVariable.getName() + ";"; // aTypeVariable.getUpperBound().getSignature(); this.signatureErasure = aTypeVariable.getFirstBound().getErasureSignature(); this.typeVariable = aTypeVariable; this.typeKind = TypeKind.TYPE_VARIABLE; }
public UnresolvedTypeVariableReferenceType(TypeVariable aTypeVariable) { super("T" + aTypeVariable.getName() + ";", aTypeVariable.getFirstBound().getErasureSignature());//aTypeVariable.getFirstBound().getSignature()); this.typeVariable = aTypeVariable; }
/** * Returns a UnresolvedType object representing the effective outermost enclosing type for a name type. For all other types, * this will return the type itself. * * The only guarantee is given in JLS 13.1 where code generated according to those rules will have type names that can be split * apart in this way. * * @return the outermost enclosing UnresolvedType object or this. */ public UnresolvedType getOutermostType() { if (isArray() || isPrimitiveType()) { return this; } String sig = getErasureSignature(); int dollar = sig.indexOf('$'); if (dollar != -1) { return UnresolvedType.forSignature(sig.substring(0, dollar) + ';'); } else { return this; } }
UnresolvedType[] candidateParams = candidate.getParameterTypes(); for (int p = 0; p < candidateParams.length; p++) { if (!candidateParams[p].getErasureSignature().equals(params[p].getErasureSignature())) { allOK = false; break;
private void createBridgeIfNecessary(BcelClassWeaver classWeaver, NewMethodTypeMunger munger, ResolvedMember unMangledInterMethod, LazyClassGen classGen) { if (munger.getDeclaredSignature() != null) { boolean needsbridging = false; ResolvedMember mungerSignature = munger.getSignature(); ResolvedMember toBridgeTo = munger.getDeclaredSignature().parameterizedWith(null, mungerSignature.getDeclaringType().resolve(getWorld()), false, munger.getTypeVariableAliases()); if (!toBridgeTo.getReturnType().getErasureSignature().equals(mungerSignature.getReturnType().getErasureSignature())) { needsbridging = true; } UnresolvedType[] originalParams = toBridgeTo.getParameterTypes(); UnresolvedType[] newParams = mungerSignature.getParameterTypes(); for (int ii = 0; ii < originalParams.length; ii++) { if (!originalParams[ii].getErasureSignature().equals(newParams[ii].getErasureSignature())) { needsbridging = true; } } if (needsbridging) { createBridge(classWeaver, unMangledInterMethod, classGen, toBridgeTo); } } }
String localReturnTypeESig = unMangledInterMethod.getReturnType().getErasureSignature(); if (!aMethod.getReturnType().getErasureSignature().equals(localReturnTypeESig) && !Modifier.isPrivate(aMethod.getModifiers())) {
public void exposeType(UnresolvedType typeToExpose) { if (ResolvedType.isMissing(typeToExpose)) { return; } if (typeToExpose.isParameterizedType() || typeToExpose.isRawType()) { if (typeToExpose instanceof ResolvedType) { typeToExpose = ((ResolvedType) typeToExpose).getGenericType(); } else { typeToExpose = UnresolvedType.forSignature(typeToExpose.getErasureSignature()); } } // Check we haven't already got a munger for this: String signatureToLookFor = typeToExpose.getSignature(); for (Iterator<ConcreteTypeMunger> iterator = typeMungers.iterator(); iterator.hasNext();) { ConcreteTypeMunger cTM = iterator.next(); ResolvedTypeMunger rTM = cTM.getMunger(); if (rTM != null && rTM instanceof ExposeTypeMunger) { String exposedType = ((ExposeTypeMunger) rTM).getExposedTypeSignature(); if (exposedType.equals(signatureToLookFor)) { return; // dont need to bother } } } addTypeMunger(world.getWeavingSupport().concreteTypeMunger(new ExposeTypeMunger(typeToExpose), inAspect)); // ResolvedMember member = new ResolvedMemberImpl( // Member.STATIC_INITIALIZATION, typeToExpose, 0, UnresolvedType.VOID, // "<clinit>", UnresolvedType.NONE); // addTypeMunger(world.concreteTypeMunger( // new PrivilegedAccessMunger(member), inAspect)); }
boolean b = !methodThatMightBeGettingOverridden.getParameterTypes()[p].getErasureSignature().equals( methodParamsArray[p].getErasureSignature()); if (typeToCheck.isParameterizedType()) { return methodThatMightBeGettingOverridden.getBackingGenericMember(); } else if (!methodThatMightBeGettingOverridden.getReturnType().getErasureSignature().equals(mrettype)) { UnresolvedType.forSignature(methodThatMightBeGettingOverridden.getReturnType().getErasureSignature())); ResolvedType subReturn = typeToCheck.getWorld().resolve(UnresolvedType.forSignature(mrettype)); if (superReturn.isAssignableFrom(subReturn)) {
private void createBridgeMethodForITDF(BcelClassWeaver weaver, LazyClassGen gen, ResolvedMember itdfieldSetter, ResolvedMember bridgingSetter) { InstructionFactory fact; LazyMethodGen bridgeMethod = makeMethodGen(gen, bridgingSetter); bridgeMethod.setAccessFlags(bridgeMethod.getAccessFlags() | 0x00000040); // BRIDGE = 0x00000040 Type[] paramTypes = BcelWorld.makeBcelTypes(bridgingSetter.getParameterTypes()); Type[] bridgingToParms = BcelWorld.makeBcelTypes(itdfieldSetter.getParameterTypes()); Type returnType = BcelWorld.makeBcelType(bridgingSetter.getReturnType()); InstructionList body = bridgeMethod.getBody(); fact = gen.getFactory(); int pos = 0; if (!Modifier.isStatic(bridgingSetter.getModifiers())) { body.append(InstructionFactory.createThis()); pos++; } for (int i = 0, len = paramTypes.length; i < len; i++) { Type paramType = paramTypes[i]; body.append(InstructionFactory.createLoad(paramType, pos)); if (!bridgingSetter.getParameterTypes()[i].getErasureSignature().equals( itdfieldSetter.getParameterTypes()[i].getErasureSignature())) { body.append(fact.createCast(paramType, bridgingToParms[i])); } pos += paramType.getSize(); } body.append(Utility.createInvoke(fact, weaver.getWorld(), itdfieldSetter)); body.append(InstructionFactory.createReturn(returnType)); gen.addMethodGen(bridgeMethod); }
Type paramType = paramTypes[i]; body.append(InstructionFactory.createLoad(paramType, pos)); if (!bridgingSetter.getParameterTypes()[i].getErasureSignature().equals( unMangledInterMethod.getParameterTypes()[i].getErasureSignature())) {
} else { String erasedSignature = ty.getErasureSignature(); ReferenceType simpleOrRawType = new ReferenceType(erasedSignature, this); if (ty.needsModifiableDelegate()) {
munger.getSignature().getDeclaringType().resolve(getWorld()), false, munger.getTypeVariableAliases()); boolean needsbridging = false; if (!toBridgeTo.getReturnType().getErasureSignature() .equals(munger.getSignature().getReturnType().getErasureSignature())) { needsbridging = true; munger.getSignature().getDeclaringType().resolve(getWorld()), false, munger.getTypeVariableAliases()); boolean needsbridging = false; if (!toBridgeTo.getReturnType().getErasureSignature() .equals(munger.getSignature().getReturnType().getErasureSignature())) { needsbridging = true;