@Override public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory) throws IOException { String className = metadataReader.getClassMetadata().getClassName(); ResolvedType resolvedType = this.world.resolve(className); return this.typePattern.matchesStatically(resolvedType); }
public AspectJTypeFilter(String typePatternExpression, @Nullable ClassLoader classLoader) { this.world = new BcelWorld(classLoader, IMessageHandler.THROW, null); this.world.setBehaveInJava5Way(true); PatternParser patternParser = new PatternParser(typePatternExpression); TypePattern typePattern = patternParser.parseTypePattern(); typePattern.resolve(this.world); IScope scope = new SimpleScope(this.world, new FormalBinding[0]); this.typePattern = typePattern.resolveBindings(scope, Bindings.NONE, false, false); }
world.setXlazyTjp(weaverOption.lazyTjp); world.setXHasMemberSupportEnabled(weaverOption.hasMember); world.setTiming(weaverOption.timers, true); world.setOptionalJoinpoints(weaverOption.optionalJoinpoints); world.setPinpointMode(weaverOption.pinpoint); weaver.setReweavableMode(weaverOption.notReWeavable); if (weaverOption.loadersToSkip != null && weaverOption.loadersToSkip.length() > 0) { MessageUtil.info(world.getMessageHandler(),"no longer creating weavers for these classloaders: "+Aj.loadersToSkip); world.performExtraConfiguration(weaverOption.xSet); world.setXnoInline(weaverOption.noInline); world.setBehaveInJava5Way(LangUtil.is15VMOrGreater()); world.setAddSerialVerUID(weaverOption.addSerialVersionUID); Properties properties = new Properties(); properties.load(resource); world.getLint().setFromProperties(properties); } catch (IOException e) { failure = e;
/** * Attempt to resolve a type - the source location gives you some context in which resolution is taking place. In the case of an * error where we can't find the type - we can then at least report why (source location) we were trying to resolve it. */ public ResolvedType resolve(UnresolvedType ty, ISourceLocation isl) { ResolvedType ret = resolve(ty, true); if (ResolvedType.isMissing(ty)) { // IMessage msg = null; getLint().cantFindType.signal(WeaverMessages.format(WeaverMessages.CANT_FIND_TYPE, ty.getName()), isl); // if (isl!=null) { // msg = MessageUtil.error(WeaverMessages.format(WeaverMessages. // CANT_FIND_TYPE,ty.getName()),isl); // } else { // msg = MessageUtil.error(WeaverMessages.format(WeaverMessages. // CANT_FIND_TYPE,ty.getName())); // } // messageHandler.handleMessage(msg); } return ret; }
public void resolveBinding(World world) { if (resolved) { return; } resolved = true; formalType = world.resolve(formalType); annotationType = world.resolve(annotationType); ResolvedType annoType = (ResolvedType) annotationType; if (!annoType.isAnnotation()) { IMessage m = MessageUtil .error(WeaverMessages.format(WeaverMessages.REFERENCE_TO_NON_ANNOTATION_TYPE, annoType.getName()), getSourceLocation()); world.getMessageHandler().handleMessage(m); resolved = false; } }
rty = resolve(rty); ResolvedType something = getWildcard(); typeMap.put("?", something); return something; ResolvedType componentType = resolve(ty.getComponentType(), allowMissing); ret = new ArrayReferenceType(signature, "[" + componentType.getErasureSignature(), this, componentType); } else { ret = resolveToReferenceType(ty, allowMissing); if (!allowMissing && ret.isMissing()) { ret = handleRequiredMissingTypeDuringResolution(ty); completeBinaryType(ret); ret = ensureRawTypeIfNecessary(ret); typeMap.put(signature, ret); return ret;
if (world.isXmlConfigured() && world.isAspectIncluded(declaringType)) { TypePattern scoped = world.getAspectScope(declaringType); if (scoped != null) { Set<ResolvedType> excludedTypes = world.getExclusionMap().get(declaringType); ResolvedType type = shadow.getEnclosingType().resolve(world); if (excludedTypes != null && excludedTypes.contains(type)) { if (!world.getMessageHandler().isIgnoring(IMessage.INFO)) { world.getMessageHandler().handleMessage( MessageUtil.info("Type '" + type.getName() + "' not woven by aspect '" + declaringType.getName() + "' due to scope exclusion in XML definition")); excludedTypes = new HashSet<ResolvedType>(); excludedTypes.add(type); world.getExclusionMap().put(declaringType, excludedTypes); } else { excludedTypes.add(type); if (world.areInfoMessagesEnabled() && world.isTimingEnabled()) { long starttime = System.nanoTime(); FuzzyBoolean isMatch = pointcut.match(shadow); long endtime = System.nanoTime(); world.record(pointcut, endtime - starttime); return isMatch.maybeTrue(); } else {
private Collection<ResolvedType> collectCheckedExceptions(UnresolvedType[] excs) { if (excs == null || excs.length == 0) { return Collections.emptyList(); } Collection<ResolvedType> ret = new ArrayList<ResolvedType>(); World world = concreteAspect.getWorld(); ResolvedType runtimeException = world.getCoreType(UnresolvedType.RUNTIME_EXCEPTION); ResolvedType error = world.getCoreType(UnresolvedType.ERROR); for (int i = 0, len = excs.length; i < len; i++) { ResolvedType t = world.resolve(excs[i], true); if (t.isMissing()) { world.getLint().cantFindType .signal(WeaverMessages.format(WeaverMessages.CANT_FIND_TYPE_EXCEPTION_TYPE, excs[i].getName()), getSourceLocation()); // IMessage msg = new Message( // WeaverMessages.format(WeaverMessages.CANT_FIND_TYPE_EXCEPTION_TYPE,excs[i].getName()), // "",IMessage.ERROR,getSourceLocation(),null,null); // world.getMessageHandler().handleMessage(msg); } if (!(runtimeException.isAssignableFrom(t) || error.isAssignableFrom(t))) { ret.add(t); } } return ret; }
public List<ConcreteTypeMunger> getTypeMungers(ResolvedType onType) { World world = onType.getWorld(); List<ConcreteTypeMunger> ret = new ArrayList<ConcreteTypeMunger>(); for (Entry entry : typeMungers) { ResolvedType aspectType = world.resolve(entry.aspectType, true); if (aspectType.isMissing()) { world.showMessage(IMessage.ERROR, WeaverMessages.format(WeaverMessages.ASPECT_NEEDED, entry.aspectType, onType), onType.getSourceLocation(), null); continue; } ret.add(new TemporaryTypeMunger(entry.typeMunger, aspectType)); } return ret; }
/** * Go from an unresolved generic wildcard (represented by UnresolvedType) to a resolved version (BoundedReferenceType). */ private ReferenceType resolveGenericWildcardFor(WildcardedUnresolvedType aType) { BoundedReferenceType ret = null; // FIXME asc doesnt take account of additional interface bounds (e.g. ? super R & Serializable - can you do that?) if (aType.isExtends()) { ResolvedType resolvedUpperBound = resolve(aType.getUpperBound()); if (resolvedUpperBound.isMissing()) { return getWildcard(); } ret = new BoundedReferenceType((ReferenceType)resolvedUpperBound, true, this); } else if (aType.isSuper()) { ResolvedType resolvedLowerBound = resolve(aType.getLowerBound()); if (resolvedLowerBound.isMissing()) { return getWildcard(); } ret = new BoundedReferenceType((ReferenceType)resolvedLowerBound, false, this); } else { // must be ? on its own! ret = getWildcard(); } return ret; }
ResolvedType rawType = typeMap.get(rawSignature); if (rawType == null) { rawType = resolve(UnresolvedType.forSignature(rawSignature), allowMissing); typeMap.put(rawSignature, rawType); } else { ReferenceTypeDelegate delegate = resolveDelegate((ReferenceType) rawType); ReferenceType genericRefType = makeGenericTypeFrom(delegate, ((ReferenceType) rawType)); ((ReferenceType) rawType).setGenericType(genericRefType); genericRefType.setDelegate(delegate);
if (world.isJoinpointArrayConstructionEnabled() && this.isArray()) { if (member.getKind() == Member.CONSTRUCTOR) { ResolvedMemberImpl ret = new ResolvedMemberImpl(Member.CONSTRUCTOR, this, Modifier.PUBLIC, UnresolvedType.VOID, "<init>", world.resolve(member.getParameterTypes()));
public void addPrivilegedAccesses(Collection<ResolvedMember> accessedMembers) { int version = inAspect.getCompilerVersion(); for (ResolvedMember member : accessedMembers) { // Looking it up ensures we get the annotations - the accessedMembers are just retrieved from the attribute and // don't have that information ResolvedMember resolvedMember = world.resolve(member); // pr333469 // If the member is for an ITD (e.g. serialVersionUID) then during resolution we may resolve it on // a supertype because it doesn't yet exist on the target. // For example: MyList extends ArrayList<String> and the ITD is on MyList - after resolution it may be: // ArrayList<String>.serialVersionUID, we need to avoid that happening if (resolvedMember == null) { // can happen for ITDs - are there many privileged access ITDs?? resolvedMember = member; if (resolvedMember.hasBackingGenericMember()) { resolvedMember = resolvedMember.getBackingGenericMember(); } } else { UnresolvedType unresolvedDeclaringType = member.getDeclaringType().getRawType(); UnresolvedType resolvedDeclaringType = resolvedMember.getDeclaringType().getRawType(); if (!unresolvedDeclaringType.equals(resolvedDeclaringType)) { resolvedMember = member; } } PrivilegedAccessMunger privilegedAccessMunger = new PrivilegedAccessMunger(resolvedMember, version >= WeaverVersionInfo.WEAVER_VERSION_AJ169); ConcreteTypeMunger concreteTypeMunger = world.getWeavingSupport().concreteTypeMunger(privilegedAccessMunger, inAspect); addTypeMunger(concreteTypeMunger); } }
if (enclosingClass.getWorld().isJoinpointSynchronizationEnabled() && enclosingClass.getWorld().areSynchronizationPointcutsInUse()) { flags = getAccessFlagsWithoutSynchronized(); if (enclosingClass.getWorld().isInJava5Mode()) { gen.setModifiers(gen.getModifiers() | Constants.ACC_SYNTHETIC); if (this.enclosingClass.getWorld().shouldFastPackMethods()) { if (isAdviceMethod() || getName().equals("<clinit>")) { packBody(gen);
@Override public ShadowMunger concretize(ResolvedType fromType, World world, PerClause clause) { if (!world.areAllLintIgnored()) { suppressLintWarnings(world); } ShadowMunger ret = super.concretize(fromType, world, clause); if (!world.areAllLintIgnored()) { clearLintSuppressions(world, this.suppressedLintKinds); } IfFinder ifinder = new IfFinder(); ret.getPointcut().accept(ifinder, null); boolean hasGuardTest = ifinder.hasIf && getKind() != AdviceKind.Around; boolean isAround = getKind() == AdviceKind.Around; if ((getExtraParameterFlags() & ThisJoinPoint) != 0) { if (!isAround && !hasGuardTest && world.getLint().noGuardForLazyTjp.isEnabled()) { // can't build tjp lazily, no suitable test... // ... only want to record it once against the advice(bug 133117) world.getLint().noGuardForLazyTjp.signal("", getSourceLocation()); } } return ret; }
@Override public boolean match(Shadow shadow, World world) { if (world.areAllLintIgnored()) { return super.match(shadow, world); } else { suppressLintWarnings(world); boolean ret = super.match(shadow, world); clearLintSuppressions(world, this.suppressedLintKinds); return ret; } }
int ret = concreteAspect.getWorld().compareByPrecedence(concreteAspect, o.concreteAspect); if (ret != 0) { return ret;
UnresolvedType bound = fieldTypeSignature2TypeX(aTypeArgument.signature, typeParams, world, inProgressTypeVariableResolutions); ResolvedType resolvedBound = world.resolve(bound); if (resolvedBound.isMissing()) { world.getLint().cantFindType.signal("Unable to find type (for bound): " + resolvedBound.getName(), null); resolvedBound = world.resolve(UnresolvedType.OBJECT); UnresolvedType bound = fieldTypeSignature2TypeX(aTypeArgument.signature, typeParams, world, inProgressTypeVariableResolutions); ResolvedType resolvedBound = world.resolve(bound); if (resolvedBound.isMissing()) { world.getLint().cantFindType.signal("Unable to find type (for bound): " + resolvedBound.getName(), null); resolvedBound = world.resolve(UnresolvedType.OBJECT);
ResolvedType onTypeResolved = world.resolve(member.getDeclaringType()); ResolvedType onType = onTypeResolved.getGenericType(); if (onType == null) { getWorld().getMessageHandler().handleMessage( MessageUtil.error("The target type for the intertype declaration is not generic", munger.getSourceLocation()));
if (!world.areAllLintIgnored()) { suppressLintWarnings(world); if (!world.areAllLintIgnored()) { clearLintSuppressions(world, this.suppressedLintKinds); ((BcelShadow) shadow).requireThisJoinPoint(hasGuardTest, isAround); ((BcelShadow) shadow).getEnclosingClass().warnOnAddedStaticInitializer(shadow, getSourceLocation()); if (!hasGuardTest && world.getLint().multipleAdviceStoppingLazyTjp.isEnabled()) {