UnresolvedType parameterizedReturnType = parameterize(getGenericReturnType(), m, true, w); UnresolvedType[] parameterizedParameterTypes = new UnresolvedType[getGenericParameterTypes().length]; UnresolvedType[] genericParameterTypes = getGenericParameterTypes(); for (int i = 0; i < parameterizedParameterTypes.length; i++) { parameterizedParameterTypes[i] = parameterize(genericParameterTypes[i], m, true, w); ResolvedMemberImpl ret = new ResolvedMemberImpl(getKind(), declaringType, getModifiers(), parameterizedReturnType, getName(), parameterizedParameterTypes, getExceptions(), this); ret.setTypeVariables(getTypeVariables()); ret.setSourceContext(getSourceContext()); ret.setPosition(getStart(), getEnd()); ret.setParameterNames(getParameterNames()); return ret;
private String getParameterSigWithBoundsRemoved() { if (myParameterSignatureWithBoundsRemoved != null) { return myParameterSignatureWithBoundsRemoved; } StringBuffer sig = new StringBuffer(); UnresolvedType[] myParameterTypes = getGenericParameterTypes(); for (int i = 0; i < myParameterTypes.length; i++) { appendSigWithTypeVarBoundsRemoved(myParameterTypes[i], sig, new HashSet<UnresolvedType>()); } myParameterSignatureWithBoundsRemoved = sig.toString(); return myParameterSignatureWithBoundsRemoved; }
public boolean isCompatibleWith(Member am) { if (kind != METHOD || am.getKind() != METHOD) { return true; } if (!name.equals(am.getName())) { return true; } if (!equalTypes(getParameterTypes(), am.getParameterTypes())) { return true; } return getReturnType().equals(am.getReturnType()); }
public void write(CompressingDataOutputStream s) throws IOException { getKind().write(s); s.writeCompressedSignature(getDeclaringType().getSignature()); } else { getDeclaringType().write(s); s.writeCompressedName(getName()); s.writeCompressedSignature(getSignature()); } else { s.writeUTF(getName()); s.writeUTF(getSignature()); UnresolvedType.writeArray(getExceptions(), s); s.writeInt(getStart()); s.writeInt(getEnd()); s.writeBoolean(isVarargsMethod()); String gsig = getGenericSignature(); if (getSignature().equals(gsig)) { s.writeByte(0xff); } else {
public static ResolvedMember perTypeWithinGetInstance(UnresolvedType declaringType) { // private static a.X ajc$getInstance(java.lang.Class) ResolvedMemberImpl rm = new ResolvedMemberImpl(Member.METHOD, declaringType, PRIVATE_STATIC, declaringType, // return value NameMangler.PERTYPEWITHIN_GETINSTANCE_METHOD, new UnresolvedType[] { UnresolvedType.JL_CLASS }); return rm; }
/** * This static method goes on the declaring aspect of the inter-type method. The implementation calls the interMethodBody() * method on the aspect. */ public static ResolvedMember interMethodDispatcher(ResolvedMember meth, UnresolvedType aspectType) { UnresolvedType[] paramTypes = meth.getParameterTypes(); if (!Modifier.isStatic(meth.getModifiers())) { paramTypes = UnresolvedType.insert(meth.getDeclaringType(), paramTypes); } ResolvedMemberImpl rmi = new ResolvedMemberImpl(Member.METHOD, aspectType, PUBLIC_STATIC, meth.getReturnType(), NameMangler.interMethodDispatcher(aspectType, meth.getDeclaringType(), meth.getName()), paramTypes, meth.getExceptions()); rmi.setParameterNames(meth.getParameterNames()); rmi.setTypeVariables(meth.getTypeVariables()); return rmi; }
ResolvedType firstDefiningType = firstDefiningMember.getDeclaringType().resolve(inAWorld); if (firstDefiningType != originalDeclaringType) { if (joinPointSignature.getKind() == Member.CONSTRUCTOR) { accumulateTypesInBetween(originalDeclaringType, firstDefiningType, declaringTypes); Set<ResolvedMember> memberSignatures = new HashSet<ResolvedMember>(); for (ResolvedType declaringType : declaringTypes) { if (shouldWalkUpHierarchyFor(firstDefiningMember)) { accumulateMembersMatching(firstDefiningMember, superTypeIterator, typesAlreadyVisited, memberSignatures, false);
ResolvedMemberImpl foundMember = (ResolvedMemberImpl) toLookIn.lookupResolvedMember(memberToMatch, true, ignoreGenerics); if (foundMember != null && isVisibleTo(memberToMatch, foundMember)) { List<ResolvedType> declaringTypes = new ArrayList<ResolvedType>(); ResolvedType resolvedDeclaringType = foundMember.getDeclaringType().resolve(toLookIn.getWorld()); accumulateTypesInBetween(toLookIn, resolvedDeclaringType, declaringTypes); for (ResolvedType declaringType : declaringTypes) { .resolve(toLookIn.getWorld()))); accumulateMembersMatching(foundMember, toLookIn.getDirectSupertypes(), typesAlreadyVisited, foundMembers, ignoreGenerics);
ResolvedMemberImpl ret = new ResolvedMemberImpl(Member.CONSTRUCTOR, this, Modifier.PUBLIC, UnresolvedType.VOID, "<init>", world.resolve(member.getParameterTypes())); int count = ret.getParameterTypes().length; String[] paramNames = new String[count]; for (int i = 0; i < count; i++) { paramNames[i] = new StringBuffer("dim").append(i).toString(); ret.setParameterNames(paramNames); return ret;
/** * Sometimes the intertyped method requires a bridge method alongside it. For example if the method 'N SomeI<N>.m()' is put onto * an interface 'interface I<N extends Number>' and then a concrete implementation is 'class C implements I<Float>' then the ITD * on the interface will be 'Number m()', whereas the ITD on the 'topmostimplementor' will be 'Float m()'. A bridge method needs * to be created in the topmostimplementor 'Number m()' that delegates to 'Float m()' */ public static ResolvedMember bridgerToInterMethod(ResolvedMember meth, UnresolvedType aspectType) { int modifiers = makePublicNonFinal(meth.getModifiers()); ResolvedMemberImpl rmi = new ResolvedMemberImpl(Member.METHOD, aspectType, modifiers, meth.getReturnType(), NameMangler.interMethod(meth.getModifiers(), aspectType, meth.getDeclaringType(), meth.getName()), meth.getParameterTypes(), meth.getExceptions()); rmi.setTypeVariables(meth.getTypeVariables()); return rmi; }
public boolean isVisible(ResolvedType fromType) { UnresolvedType declaringType = getDeclaringType(); ResolvedType type = null; if (fromType.equals(declaringType)) { type = fromType; } else { World world = fromType.getWorld(); type = declaringType.resolve(world); } return ResolvedType.isVisible(getModifiers(), type, fromType); }
public static ResolvedTypeMunger readMethod(VersionedDataInputStream s, ISourceContext context, boolean isEnhanced) throws IOException { ResolvedMemberImpl signature = ResolvedMemberImpl.readResolvedMember(s, context); UnresolvedType aspect = UnresolvedType.read(s); String implClassName = s.readUTF(); TypePattern tp = TypePattern.read(s, context); MethodDelegateTypeMunger typeMunger = new MethodDelegateTypeMunger(signature, aspect, implClassName, tp); UnresolvedType fieldType = null; if (isEnhanced) { fieldType = UnresolvedType.read(s); } else { // a guess... that will work in a lot of cases fieldType = signature.getDeclaringType(); } typeMunger.setFieldType(fieldType); if (isEnhanced) { typeMunger.factoryMethodName = s.readUTF(); typeMunger.factoryMethodSignature = s.readUTF(); typeMunger.bitflags = s.readInt(); } return typeMunger; }
aType = aType.resolve(w); } else { UnresolvedType dType = getDeclaringType(); aType = aType.resolve(((ResolvedType) dType).getWorld()); UnresolvedType parameterizedComponentSig = parameterize(componentSig, typeVariableMap, inParameterizedType, w); if (parameterizedComponentSig.isTypeVariableReference() && parameterizedComponentSig instanceof UnresolvedTypeVariableReferenceType
/** * A heavyweight BcelMethod object is only required for around advice that will be inlined. For other kinds of advice it is * possible to save some space. */ private static Member simplify(AdviceKind kind, Member adviceSignature) { if (adviceSignature != null) { UnresolvedType adviceDeclaringType = adviceSignature.getDeclaringType(); // if it isnt around advice or it is but inlining is turned off then shrink it to a ResolvedMemberImpl if (kind != AdviceKind.Around || ((adviceDeclaringType instanceof ResolvedType) && ((ResolvedType) adviceDeclaringType).getWorld() .isXnoInline())) { if (adviceSignature instanceof BcelMethod) { BcelMethod bm = (BcelMethod) adviceSignature; if (bm.getMethod() != null && bm.getMethod().getAnnotations() != null) { return adviceSignature; } ResolvedMemberImpl simplermember = new ResolvedMemberImpl(bm.getKind(), bm.getDeclaringType(), bm.getModifiers(), bm.getReturnType(), bm.getName(), bm.getParameterTypes());// ,bm.getExceptions(),bm.getBackingGenericMember() // ); simplermember.setParameterNames(bm.getParameterNames()); return simplermember; } } } return adviceSignature; }
String name = compressed ? s.readUtf8(s.readShort()) : s.readUTF(); String signature = compressed ? s.readUtf8(s.readShort()) : s.readUTF(); ResolvedMemberImpl m = new ResolvedMemberImpl(mk, declaringType, modifiers, name, signature); m.checkedExceptions = UnresolvedType.readArray(s); boolean isvarargs = s.readBoolean(); if (isvarargs) { m.setVarargsMethod();
public ISourceContext getSourceContext(World world) { return getDeclaringType().resolve(world).getSourceContext(); }
public boolean isEquivalentTo(Object other) { return this.equals(other); }
@Override public final UnresolvedType[] getExceptions(World world) { return getExceptions(); }
@Override public ResolvedType[] getAnnotationTypes() { unpackAnnotations(false); return super.getAnnotationTypes(); }
/** * Build a list containing every type between subtype and supertype, inclusively. */ private static void accumulateTypesInBetween(ResolvedType subType, ResolvedType superType, List<ResolvedType> types) { types.add(subType); if (subType == superType) { return; } else { for (Iterator<ResolvedType> iter = subType.getDirectSupertypes(); iter.hasNext();) { ResolvedType parent = iter.next(); if (superType.isAssignableFrom(parent)) { accumulateTypesInBetween(parent, superType, types); } } } }