/** * Returns a java language string representation of this type. */ @Override public String toString() { return getName(); // + " - " + getKind(); }
static String[] makeBcelTypesAsClassNames(UnresolvedType[] types) { String[] ret = new String[types.length]; for (int i = 0, len = types.length; i < len; i++) { ret[i] = types[i].getName(); } return ret; }
protected String maybeGetSimpleName() { if (formalName != null) { return formalName; } String ret = annotationType.getName(); return (ret.indexOf('.') == -1) ? ret : null; }
public String getPackageNameAsIdentifier() { String name = getName(); int index = name.lastIndexOf('.'); if (index == -1) { return ""; } else { return name.substring(0, index).replace('.', '_'); } }
@Override public String toTraceString() { return getClass().getName() + "[" + getName() + "]"; }
public String[] maybeGetCleanNames() { String[] theParamNames = new String[typePatterns.length]; for (int i = 0; i < typePatterns.length; i++) { TypePattern string = typePatterns[i]; if (!(string instanceof ExactTypePattern)) { return null; } theParamNames[i] = ((ExactTypePattern) string).getExactType().getName(); } return theParamNames; } }
public String getBaseName() { String name = getName(); if (isParameterizedType() || isGenericType()) { if (typeParameters == null) { return name; } else { return name.substring(0, name.indexOf("<")); } } else { return name; } }
protected static String makeString(UnresolvedType t) { // this is the inverse of the odd behavior for Class.forName w/ arrays if (t.isArray()) { // this behavior matches the string used by the eclipse compiler for Foo.class literals return t.getSignature().replace('/', '.'); } else { return t.getName(); } }
@Override public AnnotationAJ getAnnotationOfType(UnresolvedType ofType) { ensureAnnotationTypesRetrieved(); for (AnnotationAJ annotation : annotations) { if (annotation.getTypeName().equals(ofType.getName())) { return annotation; } } return null; }
public String toString() { return "(BcelTypeMunger: CflowField " + cflowCounterField.getDeclaringType().getName() + " " + cflowCounterField.getName() + ")"; }
public String toString() { return "ExposeTypeMunger(" + getSignature().getDeclaringType().getName() + ")"; }
private static void setParentTypesOnDeclareParentsNode(DeclareParents decp, IProgramElement decpElement) { TypePatternList tpl = decp.getParents(); List<String> parents = new ArrayList<String>(); for (int i = 0; i < tpl.size(); i++) { parents.add(tpl.get(i).getExactType().getName().replaceAll("\\$", ".")); } decpElement.setParentTypes(parents); }
/** * Special resolution for "core" types like OBJECT. These are resolved just like any other type, but if they are not found it is * more serious and we issue an error message immediately. */ // OPTIMIZE streamline path for core types? They are just simple types, // could look straight in the typemap? public ResolvedType getCoreType(UnresolvedType tx) { ResolvedType coreTy = resolve(tx, true); if (coreTy.isMissing()) { MessageUtil.error(messageHandler, WeaverMessages.format(WeaverMessages.CANT_FIND_CORE_TYPE, tx.getName())); } return coreTy; }
public static Instruction createGet(InstructionFactory fact, Member signature) { short kind; if (Modifier.isStatic(signature.getModifiers())) { kind = Constants.GETSTATIC; } else { kind = Constants.GETFIELD; } return fact.createFieldAccess(signature.getDeclaringType().getName(), signature.getName(), BcelWorld.makeBcelType(signature.getReturnType()), kind); }
public static Instruction createSet(InstructionFactory fact, Member signature) { short kind; if (Modifier.isStatic(signature.getModifiers())) { kind = Constants.PUTSTATIC; } else { kind = Constants.PUTFIELD; } return fact.createFieldAccess(signature.getDeclaringType().getName(), signature.getName(), BcelWorld.makeBcelType(signature.getReturnType()), kind); }
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; } }
private void signalError(String msgid, BcelClassWeaver weaver, UnresolvedType onType) { IMessage msg = MessageUtil.error(WeaverMessages.format(msgid, onType.getName()), getSourceLocation()); weaver.getWorld().getMessageHandler().handleMessage(msg); }
private void generatePerCflowAjcClinitMethod(LazyClassGen classGen) { InstructionFactory factory = classGen.getFactory(); LazyMethodGen method = classGen.getAjcPreClinit(); // Creates a clinit if there isn't one InstructionList il = new InstructionList(); il.append(factory.createNew(AjcMemberMaker.CFLOW_STACK_TYPE.getName())); il.append(InstructionConstants.DUP); il.append(factory.createInvoke(AjcMemberMaker.CFLOW_STACK_TYPE.getName(), "<init>", Type.VOID, Type.NO_ARGS, Constants.INVOKESPECIAL)); il.append(Utility.createSet(factory, AjcMemberMaker.perCflowField(aspectType))); method.getBody().insert(il); }
/** * Create an invoke instruction * * @param fact * @param kind INVOKEINTERFACE, INVOKEVIRTUAL.. * @param member * @return */ public static Instruction createInvoke(InstructionFactory fact, short kind, Member member) { return fact.createInvoke(member.getDeclaringType().getName(), member.getName(), BcelWorld.makeBcelType(member.getReturnType()), BcelWorld.makeBcelTypes(member.getParameterTypes()), kind); }
protected FuzzyBoolean matchInternal(Shadow shadow) { ResolvedType enclosingType = shadow.getIWorld().resolve(shadow.getEnclosingType(), true); if (enclosingType.isMissing()) { shadow.getIWorld().getLint().cantFindType.signal(new String[] { WeaverMessages.format( WeaverMessages.CANT_FIND_TYPE_WITHINPCD, shadow.getEnclosingType().getName()) }, shadow.getSourceLocation(), new ISourceLocation[] { getSourceLocation() }); } typePattern.resolve(shadow.getIWorld()); return isWithinType(enclosingType); }