public IMessageHandler getMessageHandler() { return world.getMessageHandler(); }
private IMessage.Kind getMessageKind(String v) { if (v.equals("ignore")) { return null; } else if (v.equals("warning")) { return IMessage.WARNING; } else if (v.equals("error")) { return IMessage.ERROR; } MessageUtil.error(world.getMessageHandler(), WeaverMessages.format(WeaverMessages.XLINT_VALUE_ERROR, v)); return null; }
@SuppressWarnings("rawtypes") public void setFromProperties(Properties properties) { for (Iterator i = properties.entrySet().iterator(); i.hasNext();) { Map.Entry entry = (Map.Entry) i.next(); Kind kind = kinds.get(entry.getKey()); if (kind == null) { MessageUtil.error(world.getMessageHandler(), WeaverMessages.format(WeaverMessages.XLINT_KEY_ERROR, entry.getKey())); } else { kind.setKind(getMessageKind((String) entry.getValue())); } } }
/** * Error reporting * * @param message */ private void reportError(String message) { world.getMessageHandler().handleMessage(new Message(message, IMessage.ERROR, null, null)); } }
public void setFromMap(Map<String,String> lintOptionsMap) { for (String key: lintOptionsMap.keySet()) { String value = lintOptionsMap.get(key); Kind kind = kinds.get(key); if (kind == null) { MessageUtil.error(world.getMessageHandler(), WeaverMessages.format(WeaverMessages.XLINT_KEY_ERROR, key)); } else { kind.setKind(getMessageKind(value)); } } }
public void signal(String info, ISourceLocation location) { if (kind == null) { return; } String text = MessageFormat.format(message, new Object[] { info }); text += " [Xlint:" + name + "]"; world.getMessageHandler().handleMessage(new LintMessage(text, kind, location, null, getLintKind(name))); }
public void signal(String[] infos, ISourceLocation location, ISourceLocation[] extraLocations) { if (kind == null) { return; } String text = MessageFormat.format(message, (Object[]) infos); text += " [Xlint:" + name + "]"; world.getMessageHandler().handleMessage(new LintMessage(text, kind, location, extraLocations, getLintKind(name))); }
public void report() { if (!memoryProfiling) { return; } checkq(); w.getMessageHandler().handleMessage( MessageUtil.info("MEMORY: world expendable type map reached maximum size of #" + maxExpendableMapSize + " entries")); w.getMessageHandler().handleMessage( MessageUtil.info("MEMORY: types collected through garbage collection #" + collectedTypes + " entries")); }
IMessageHandler setCustomMessageHandler(IMessageHandler aHandler) { IMessageHandler current = getWorld().getMessageHandler(); getWorld().setMessageHandler(aHandler); return current; }
IMessageHandler setCustomMessageHandler(IMessageHandler aHandler) { IMessageHandler current = getWorld().getMessageHandler(); getWorld().setMessageHandler(aHandler); return current; }
/** * @see org.aspectj.weaver.TypePattern#matchesInstanceof(IType) */ @Override public FuzzyBoolean matchesInstanceof(ResolvedType type) { // XXX hack to let unmatched types just silently remain so if (maybeGetSimpleName() != null) { return FuzzyBoolean.NO; } type.getWorld().getMessageHandler().handleMessage( new Message("can't do instanceof matching on patterns with wildcards", IMessage.ERROR, null, getSourceLocation())); return FuzzyBoolean.NO; }
private void verifyRuntimeRetention(World world, ResolvedType resolvedAnnotationType) { if (!resolvedAnnotationType.isAnnotationWithRuntimeRetention()) { // default is class visibility // default is class visibility IMessage m = MessageUtil.error(WeaverMessages.format(WeaverMessages.BINDING_NON_RUNTIME_RETENTION_ANNOTATION, annotationType.getName()), getSourceLocation()); world.getMessageHandler().handleMessage(m); resolved = false; } }
@Override public TypePattern resolveBindings(IScope scope, Bindings bindings, boolean allowBinding, boolean requireExactType) { if (requireExactType) { scope.getWorld().getMessageHandler().handleMessage( MessageUtil.error(WeaverMessages.format(WeaverMessages.WILDCARD_NOT_ALLOWED), getSourceLocation())); return NO; } return super.resolveBindings(scope, bindings, allowBinding, requireExactType); }
private void verifyRuntimeRetention(ResolvedType rAnnotationType) { if (!(rAnnotationType.isAnnotationWithRuntimeRetention())) { IMessage m = MessageUtil.error(WeaverMessages.format(WeaverMessages.BINDING_NON_RUNTIME_RETENTION_ANNOTATION, rAnnotationType.getName()), getSourceLocation()); rAnnotationType.getWorld().getMessageHandler().handleMessage(m); } }
protected void verifyIsAnnotationType(ResolvedType type, IScope scope) { if (!type.isAnnotation()) { IMessage m = MessageUtil.error(WeaverMessages.format(WeaverMessages.REFERENCE_TO_NON_ANNOTATION_TYPE, type.getName()), getSourceLocation()); scope.getWorld().getMessageHandler().handleMessage(m); resolved = false; } }
private void sortMungers() { List sorted = PartialOrder.sort(mungers); // Bunch of code to work out whether to report xlints for advice that isn't ordered at this Joinpoint possiblyReportUnorderedAdvice(sorted); if (sorted == null) { // this means that we have circular dependencies for (ShadowMunger m : mungers) { getIWorld().getMessageHandler().handleMessage( MessageUtil.error(WeaverMessages.format(WeaverMessages.CIRCULAR_DEPENDENCY, this), m.getSourceLocation())); } } mungers = sorted; }
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; } }
public PerClause concretize(ResolvedType inAspect) { PerClause p = lookupConcretePerClause(inAspect.getSuperclass()); if (p == null) { inAspect.getWorld().getMessageHandler().handleMessage( MessageUtil.error(WeaverMessages.format(WeaverMessages.MISSING_PER_CLAUSE, inAspect.getSuperclass()), getSourceLocation())); return new PerSingleton().concretize(inAspect);// AV: fallback on something else NPE in AJDT } else { if (p.getKind() != kind) { inAspect.getWorld().getMessageHandler().handleMessage( MessageUtil.error(WeaverMessages.format(WeaverMessages.WRONG_PER_CLAUSE, kind, p.getKind()), getSourceLocation())); } return p.concretize(inAspect); } }
public void resolveBinding(World world) { if (resolved) { return; } resolved = true; annotationType = annotationType.resolve(world); ResolvedType resolvedAnnotationType = (ResolvedType) annotationType; if (!resolvedAnnotationType.isAnnotation()) { IMessage m = MessageUtil.error(WeaverMessages.format(WeaverMessages.REFERENCE_TO_NON_ANNOTATION_TYPE, annotationType .getName()), getSourceLocation()); world.getMessageHandler().handleMessage(m); resolved = false; } if (annotationType.isTypeVariableReference()) { return; // we'll deal with this next check when the type var is actually bound... } verifyRuntimeRetention(world, resolvedAnnotationType); }
private void unpackAjAttributes(World world) { associatedShadowMunger = null; ResolvedType resolvedDeclaringType = getDeclaringType().resolve(world); WeaverVersionInfo wvinfo = bcelObjectType.getWeaverVersionAttribute(); List<AjAttribute> as = Utility.readAjAttributes(resolvedDeclaringType.getClassName(), method.getAttributes(), resolvedDeclaringType.getSourceContext(), world, wvinfo, new BcelConstantPoolReader(method.getConstantPool())); processAttributes(world, as); as = AtAjAttributes.readAj5MethodAttributes(method, this, resolvedDeclaringType, preResolvedPointcut, resolvedDeclaringType.getSourceContext(), world.getMessageHandler()); processAttributes(world, as); }