import org.aspectj.weaver.AjAttribute;
import org.aspectj.weaver.AjcMemberMaker;
import org.aspectj.weaver.NameMangler;
+import org.aspectj.weaver.ReferenceType;
import org.aspectj.weaver.ResolvedMember;
import org.aspectj.weaver.ResolvedTypeX;
import org.aspectj.weaver.Shadow;
public EclipseSourceType concreteName;
- public ResolvedTypeX.Name typeX;
+ public ReferenceType typeX;
public EclipseFactory factory; //??? should use this consistently
import org.aspectj.org.eclipse.jdt.internal.compiler.problem.ProblemReporter;
import org.aspectj.weaver.AsmRelationshipProvider;
import org.aspectj.weaver.ConcreteTypeMunger;
+import org.aspectj.weaver.ReferenceType;
import org.aspectj.weaver.ResolvedTypeMunger;
import org.aspectj.weaver.ResolvedTypeX;
import org.aspectj.weaver.TypeX;
}
if (hasPointcuts || dec instanceof AspectDeclaration) {
- ResolvedTypeX.Name name = (ResolvedTypeX.Name)factory.fromEclipse(sourceType);
+ ReferenceType name = (ReferenceType)factory.fromEclipse(sourceType);
EclipseSourceType eclipseSourceType = (EclipseSourceType)name.getDelegate();
eclipseSourceType.checkPointcutDeclarations();
}
import org.aspectj.weaver.ConcreteTypeMunger;
import org.aspectj.weaver.IHasPosition;
import org.aspectj.weaver.Member;
+import org.aspectj.weaver.ReferenceType;
import org.aspectj.weaver.ResolvedMember;
import org.aspectj.weaver.ResolvedTypeX;
import org.aspectj.weaver.Shadow;
public void addSourceTypeBinding(SourceTypeBinding binding) {
TypeDeclaration decl = binding.scope.referenceContext;
- ResolvedTypeX.Name name = getWorld().lookupOrCreateName(TypeX.forName(getName(binding)));
+ ReferenceType name = getWorld().lookupOrCreateName(TypeX.forName(getName(binding)));
EclipseSourceType t = new EclipseSourceType(name, this, binding, decl);
name.setDelegate(t);
if (decl instanceof AspectDeclaration) {
*
* @author Jim Hugunin
*/
-public class EclipseSourceType extends ResolvedTypeX.ConcreteName {
+public class EclipseSourceType extends AbstractReferenceTypeDelegate {
private static final char[] pointcutSig = "Lorg/aspectj/lang/annotation/Pointcut;".toCharArray();
private static final char[] aspectSig = "Lorg/aspectj/lang/annotation/Aspect;".toCharArray();
protected ResolvedPointcutDefinition[] declaredPointcuts = null;
return factory;
}
- public EclipseSourceType(ResolvedTypeX.Name resolvedTypeX, EclipseFactory factory,
+ public EclipseSourceType(ReferenceType resolvedTypeX, EclipseFactory factory,
SourceTypeBinding binding, TypeDeclaration declaration)
{
super(resolvedTypeX, true);
}
- protected Collection getDeclares() {
+ public Collection getDeclares() {
return declares;
}
- protected Collection getPrivilegedAccesses() {
+ public Collection getPrivilegedAccesses() {
return Collections.EMPTY_LIST;
}
- protected Collection getTypeMungers() {
+ public Collection getTypeMungers() {
return typeMungers;
}
--- /dev/null
+/* *******************************************************************
+ * Copyright (c) 2002 Contributors
+ * All rights reserved.
+ * This program and the accompanying materials are made available
+ * under the terms of the Common Public License v1.0
+ * which accompanies this distribution and is available at
+ * http://www.eclipse.org/legal/cpl-v10.html
+ *
+ * Contributors:
+ * PARC initial implementation
+ * Andy Clement - June 2005 - separated out from ResolvedTypeX
+ * ******************************************************************/
+package org.aspectj.weaver;
+
+public abstract class AbstractReferenceTypeDelegate implements ReferenceTypeDelegate {
+ protected boolean exposedToWeaver;
+ protected ReferenceType resolvedTypeX;
+
+ public AbstractReferenceTypeDelegate(ReferenceType resolvedTypeX, boolean exposedToWeaver) {
+ this.resolvedTypeX = resolvedTypeX;
+ this.exposedToWeaver = exposedToWeaver;
+ }
+
+ public final boolean isClass() {
+ return !isAspect() && !isInterface();
+ }
+
+ /**
+ * Designed to be overriden by EclipseType to disable collection of shadow mungers
+ * during pre-weave compilation phase
+ */
+ public boolean doesNotExposeShadowMungers() {
+ return false;
+ }
+
+ public boolean isExposedToWeaver() {
+ return exposedToWeaver;
+ }
+
+ public ReferenceType getResolvedTypeX() {
+ return resolvedTypeX;
+ }
+
+}
\ No newline at end of file
--- /dev/null
+/* *******************************************************************
+ * Copyright (c) 2002 Contributors
+ * All rights reserved.
+ * This program and the accompanying materials are made available
+ * under the terms of the Common Public License v1.0
+ * which accompanies this distribution and is available at
+ * http://www.eclipse.org/legal/cpl-v10.html
+ *
+ * Contributors:
+ * PARC initial implementation
+ * Andy Clement - June 2005 - separated out from ResolvedTypeX
+ * ******************************************************************/
+package org.aspectj.weaver;
+
+import java.util.Collection;
+import java.util.Iterator;
+
+import org.aspectj.bridge.ISourceLocation;
+import org.aspectj.weaver.patterns.PerClause;
+
+public class ReferenceType extends ResolvedTypeX {
+ ReferenceTypeDelegate delegate = null;
+ ISourceContext sourceContext = null;
+ int startPos = 0;
+ int endPos = 0;
+
+ //??? should set delegate before any use
+ public ReferenceType(String signature, World world) {
+ super(signature, world);
+ }
+
+ public final boolean isClass() {
+ return delegate.isClass();
+ }
+
+ public AnnotationX[] getAnnotations() {
+ return delegate.getAnnotations();
+ }
+
+ public void addAnnotation(AnnotationX annotationX) {
+ delegate.addAnnotation(annotationX);
+ }
+ public boolean hasAnnotation(TypeX ofType) {
+ return delegate.hasAnnotation(ofType);
+ }
+
+ public ResolvedTypeX[] getAnnotationTypes() {
+ return delegate.getAnnotationTypes();
+ }
+
+ public boolean isAspect() {
+ return delegate.isAspect();
+ }
+
+ public boolean isAnnotationStyleAspect() {
+ return delegate.isAnnotationStyleAspect();
+ }
+
+ public boolean isEnum() {
+ return delegate.isEnum();
+ }
+
+ public boolean isAnnotation() {
+ return delegate.isAnnotation();
+ }
+
+ public boolean isAnnotationWithRuntimeRetention() {
+ return delegate.isAnnotationWithRuntimeRetention();
+ }
+
+ public final boolean needsNoConversionFrom(TypeX o) {
+ return isAssignableFrom(o);
+ }
+
+ public final boolean isAssignableFrom(TypeX o) {
+ if (o.isPrimitive()) {
+ if (!world.behaveInJava5Way) return false;
+ if (ResolvedTypeX.validBoxing.contains(this.getSignature()+o.getSignature())) return true;
+ }
+ ResolvedTypeX other = o.resolve(world);
+
+ return isAssignableFrom(other);
+ }
+
+ public final boolean isCoerceableFrom(TypeX o) {
+ ResolvedTypeX other = o.resolve(world);
+
+ if (this.isAssignableFrom(other) || other.isAssignableFrom(this)) {
+ return true;
+ }
+ if (!this.isInterface() && !other.isInterface()) {
+ return false;
+ }
+ if (this.isFinal() || other.isFinal()) {
+ return false;
+ }
+ // ??? needs to be Methods, not just declared methods? JLS 5.5 unclear
+ ResolvedMember[] a = getDeclaredMethods();
+ ResolvedMember[] b = other.getDeclaredMethods(); //??? is this cast always safe
+ for (int ai = 0, alen = a.length; ai < alen; ai++) {
+ for (int bi = 0, blen = b.length; bi < blen; bi++) {
+ if (! b[bi].isCompatibleWith(a[ai])) return false;
+ }
+ }
+ return true;
+ }
+
+ private boolean isAssignableFrom(ResolvedTypeX other) {
+ if (this == other) return true;
+ for(Iterator i = other.getDirectSupertypes(); i.hasNext(); ) {
+ if (this.isAssignableFrom((ResolvedTypeX) i.next())) return true;
+ }
+ return false;
+ }
+
+ public ISourceContext getSourceContext() {
+ return sourceContext;
+ }
+
+ public ISourceLocation getSourceLocation() {
+ if (sourceContext == null) return null;
+ return sourceContext.makeSourceLocation(new Position(startPos, endPos));
+ }
+
+ public boolean isExposedToWeaver() {
+ return (delegate == null) || delegate.isExposedToWeaver(); //??? where does this belong
+ }
+
+ public WeaverStateInfo getWeaverState() {
+ return delegate.getWeaverState();
+ }
+
+ public ResolvedMember[] getDeclaredFields() {
+ return delegate.getDeclaredFields();
+ }
+
+ public ResolvedTypeX[] getDeclaredInterfaces() {
+ return delegate.getDeclaredInterfaces();
+ }
+
+ public ResolvedMember[] getDeclaredMethods() {
+ return delegate.getDeclaredMethods();
+ }
+
+ public ResolvedMember[] getDeclaredPointcuts() {
+ return delegate.getDeclaredPointcuts();
+ }
+
+ public PerClause getPerClause() { return delegate.getPerClause(); }
+ protected Collection getDeclares() { return delegate.getDeclares(); }
+ protected Collection getTypeMungers() { return delegate.getTypeMungers(); }
+
+ protected Collection getPrivilegedAccesses() { return delegate.getPrivilegedAccesses(); }
+
+
+ public int getModifiers() {
+ return delegate.getModifiers();
+ }
+
+ public ResolvedTypeX getSuperclass() {
+ return delegate.getSuperclass();
+ }
+
+
+ public ReferenceTypeDelegate getDelegate() {
+ return delegate;
+ }
+
+ public void setDelegate(ReferenceTypeDelegate delegate) {
+ this.delegate = delegate;
+ }
+
+ public int getEndPos() {
+ return endPos;
+ }
+
+ public int getStartPos() {
+ return startPos;
+ }
+
+ public void setEndPos(int endPos) {
+ this.endPos = endPos;
+ }
+
+ public void setSourceContext(ISourceContext sourceContext) {
+ this.sourceContext = sourceContext;
+ }
+
+ public void setStartPos(int startPos) {
+ this.startPos = startPos;
+ }
+
+ public boolean doesNotExposeShadowMungers() {
+ return delegate.doesNotExposeShadowMungers();
+ }
+
+}
\ No newline at end of file
--- /dev/null
+/* *******************************************************************
+ * Copyright (c) 2002 Contributors
+ * All rights reserved.
+ * This program and the accompanying materials are made available
+ * under the terms of the Common Public License v1.0
+ * which accompanies this distribution and is available at
+ * http://www.eclipse.org/legal/cpl-v10.html
+ *
+ * Contributors:
+ * PARC initial implementation
+ * Andy Clement - June 2005 - separated out from ResolvedTypeX
+ * ******************************************************************/
+package org.aspectj.weaver;
+
+import java.util.Collection;
+
+import org.aspectj.weaver.patterns.PerClause;
+
+/**
+ * Abstraction over a type. Abstract implementation provided by
+ * AbstractReferenceTypeDelegate.
+ */
+public interface ReferenceTypeDelegate {
+
+ // TODO asc move to proxy
+ public void addAnnotation(AnnotationX annotationX);
+
+ public boolean isAspect();
+ public boolean isAnnotationStyleAspect();
+ public boolean isInterface();
+ public boolean isEnum();
+ public boolean isAnnotation();
+ public boolean isAnnotationWithRuntimeRetention();
+ public boolean isClass();
+ public boolean isExposedToWeaver();
+
+ public boolean hasAnnotation(TypeX ofType);
+
+ public AnnotationX[] getAnnotations();
+ public ResolvedTypeX[] getAnnotationTypes();
+ public ResolvedMember[] getDeclaredFields();
+ public ResolvedTypeX[] getDeclaredInterfaces();
+ public ResolvedMember[] getDeclaredMethods();
+ public ResolvedMember[] getDeclaredPointcuts();
+
+ public PerClause getPerClause();
+ public Collection getDeclares() ;
+ public Collection getTypeMungers();
+ public Collection getPrivilegedAccesses();
+ public int getModifiers();
+ public ResolvedTypeX getSuperclass();
+ public WeaverStateInfo getWeaverState();
+ public ReferenceType getResolvedTypeX();
+ public boolean doesNotExposeShadowMungers();
+}
\ No newline at end of file
// This set contains pairs of types whose signatures are concatenated
// together, this means with a fast lookup we can tell if two types
// are equivalent.
- private static Set validBoxing = new HashSet();
+ static Set validBoxing = new HashSet();
static {
validBoxing.add("Ljava/lang/Byte;B");
// ---- types
- public static class Name extends ResolvedTypeX {
- private ConcreteName delegate = null;
- private ISourceContext sourceContext = null;
- private int startPos = 0;
- private int endPos = 0;
-
- //??? should set delegate before any use
- public Name(String signature, World world) {
- super(signature, world);
- }
-
- public final boolean isClass() {
- return delegate.isClass();
- }
-
- public AnnotationX[] getAnnotations() {
- return delegate.getAnnotations();
- }
-
- public void addAnnotation(AnnotationX annotationX) {
- delegate.addAnnotation(annotationX);
- }
- public boolean hasAnnotation(TypeX ofType) {
- return delegate.hasAnnotation(ofType);
- }
-
- public ResolvedTypeX[] getAnnotationTypes() {
- return delegate.getAnnotationTypes();
- }
-
- public boolean isAspect() {
- return delegate.isAspect();
- }
-
- public boolean isAnnotationStyleAspect() {
- return delegate.isAnnotationStyleAspect();
- }
-
- public boolean isEnum() {
- return delegate.isEnum();
- }
-
- public boolean isAnnotation() {
- return delegate.isAnnotation();
- }
-
- public boolean isAnnotationWithRuntimeRetention() {
- return delegate.isAnnotationWithRuntimeRetention();
- }
-
- public final boolean needsNoConversionFrom(TypeX o) {
- return isAssignableFrom(o);
- }
-
- public final boolean isAssignableFrom(TypeX o) {
- if (o.isPrimitive()) {
- if (!world.behaveInJava5Way) return false;
- if (validBoxing.contains(this.getSignature()+o.getSignature())) return true;
- }
- ResolvedTypeX other = o.resolve(world);
-
- return isAssignableFrom(other);
- }
-
- public final boolean isCoerceableFrom(TypeX o) {
- ResolvedTypeX other = o.resolve(world);
-
- if (this.isAssignableFrom(other) || other.isAssignableFrom(this)) {
- return true;
- }
- if (!this.isInterface() && !other.isInterface()) {
- return false;
- }
- if (this.isFinal() || other.isFinal()) {
- return false;
- }
- // ??? needs to be Methods, not just declared methods? JLS 5.5 unclear
- ResolvedMember[] a = getDeclaredMethods();
- ResolvedMember[] b = other.getDeclaredMethods(); //??? is this cast always safe
- for (int ai = 0, alen = a.length; ai < alen; ai++) {
- for (int bi = 0, blen = b.length; bi < blen; bi++) {
- if (! b[bi].isCompatibleWith(a[ai])) return false;
- }
- }
- return true;
- }
-
- private boolean isAssignableFrom(ResolvedTypeX other) {
- if (this == other) return true;
- for(Iterator i = other.getDirectSupertypes(); i.hasNext(); ) {
- if (this.isAssignableFrom((ResolvedTypeX) i.next())) return true;
- }
- return false;
- }
-
- public ISourceContext getSourceContext() {
- return sourceContext;
- }
-
- public ISourceLocation getSourceLocation() {
- if (sourceContext == null) return null;
- return sourceContext.makeSourceLocation(new Position(startPos, endPos));
- }
-
- public boolean isExposedToWeaver() {
- return (delegate == null) || delegate.isExposedToWeaver(); //??? where does this belong
- }
-
- public WeaverStateInfo getWeaverState() {
- return delegate.getWeaverState();
- }
-
- public ResolvedMember[] getDeclaredFields() {
- return delegate.getDeclaredFields();
- }
-
- public ResolvedTypeX[] getDeclaredInterfaces() {
- return delegate.getDeclaredInterfaces();
- }
-
- public ResolvedMember[] getDeclaredMethods() {
- return delegate.getDeclaredMethods();
- }
-
- public ResolvedMember[] getDeclaredPointcuts() {
- return delegate.getDeclaredPointcuts();
- }
-
- public PerClause getPerClause() { return delegate.getPerClause(); }
- protected Collection getDeclares() { return delegate.getDeclares(); }
- protected Collection getTypeMungers() { return delegate.getTypeMungers(); }
-
- protected Collection getPrivilegedAccesses() { return delegate.getPrivilegedAccesses(); }
-
-
- public int getModifiers() {
- return delegate.getModifiers();
- }
-
- public ResolvedTypeX getSuperclass() {
- return delegate.getSuperclass();
- }
-
-
- public ConcreteName getDelegate() {
- return delegate;
- }
-
- public void setDelegate(ConcreteName delegate) {
- this.delegate = delegate;
- }
-
- public int getEndPos() {
- return endPos;
- }
-
- public int getStartPos() {
- return startPos;
- }
-
- public void setEndPos(int endPos) {
- this.endPos = endPos;
- }
-
- public void setSourceContext(ISourceContext sourceContext) {
- this.sourceContext = sourceContext;
- }
-
- public void setStartPos(int startPos) {
- this.startPos = startPos;
- }
-
- public boolean doesNotExposeShadowMungers() {
- return delegate.doesNotExposeShadowMungers();
- }
-
- }
-
- public static abstract class ConcreteName {
- //protected ISourceContext sourceContext;
- protected boolean exposedToWeaver;
- protected ResolvedTypeX.Name resolvedTypeX;
-
-
- public ConcreteName(ResolvedTypeX.Name resolvedTypeX, boolean exposedToWeaver) {
- //???super(signature, world);
- this.resolvedTypeX = resolvedTypeX;
- this.exposedToWeaver = exposedToWeaver;
- }
-
-
- public final boolean isClass() {
- return !isAspect() && !isInterface();
- }
-
- public abstract boolean isAspect();
- public abstract boolean isAnnotationStyleAspect();
- public abstract boolean isInterface();
- public abstract boolean isEnum();
- public abstract boolean isAnnotation();
- public abstract boolean isAnnotationWithRuntimeRetention();
-
- public abstract AnnotationX[] getAnnotations();
- public abstract void addAnnotation(AnnotationX annotationX);
- public abstract boolean hasAnnotation(TypeX ofType);
- public abstract ResolvedTypeX[] getAnnotationTypes();
-
- public abstract ResolvedMember[] getDeclaredFields();
-
- public abstract ResolvedTypeX[] getDeclaredInterfaces();
-
- public abstract ResolvedMember[] getDeclaredMethods();
-
- public abstract ResolvedMember[] getDeclaredPointcuts();
-
- public abstract PerClause getPerClause();
- protected abstract Collection getDeclares() ;
- protected abstract Collection getTypeMungers();
-
- protected abstract Collection getPrivilegedAccesses();
-
-
- public abstract int getModifiers();
-
- public abstract ResolvedTypeX getSuperclass();
-
-// public abstract ISourceLocation getSourceLocation();
-
- public abstract WeaverStateInfo getWeaverState();
-
-// public ISourceContext getSourceContext() {
-// return sourceContext;
-// }
-
- /**
- * Designed to be overriden by EclipseType to disable collection of shadow mungers
- * during pre-weave compilation phase
- */
- public boolean doesNotExposeShadowMungers() {
- return false;
- }
-
- public boolean isExposedToWeaver() {
- return exposedToWeaver;
- }
-
- public ResolvedTypeX.Name getResolvedTypeX() {
- return resolvedTypeX;
- }
-
- }
-
static class Array extends ResolvedTypeX {
ResolvedTypeX componentType;
Array(String s, World world, ResolvedTypeX componentType) {
// an inner type of a parameterized type that specifies no type parameters of its own.
protected TypeX[] typeParameters;
private boolean isParameterized = false;
- private boolean isRawtype = false;
+ private boolean isRawtype = false; // TODO asc - change to isGeneric?
/**
protected final ResolvedTypeX resolveObjectType(TypeX ty) {
String signature = ty.getRawTypeSignature();
- ResolvedTypeX.Name name = new ResolvedTypeX.Name(signature, this);
- ResolvedTypeX.ConcreteName concreteName = resolveObjectType(name);
+ ReferenceType name = new ReferenceType(signature, this);
+ ReferenceTypeDelegate concreteName = resolveObjectType(name);
if (concreteName == null) return ResolvedTypeX.MISSING;
name.setDelegate(concreteName);
return name;
}
- protected abstract ResolvedTypeX.ConcreteName resolveObjectType(ResolvedTypeX.Name ty);
+ protected abstract ReferenceTypeDelegate resolveObjectType(ReferenceType ty);
protected final boolean isCoerceableFrom(TypeX type, TypeX other) {
XlazyTjp = b;
}
- public ResolvedTypeX.Name lookupOrCreateName(TypeX ty) {
+ public ReferenceType lookupOrCreateName(TypeX ty) {
String signature = ty.getRawTypeSignature();
- ResolvedTypeX.Name ret = (ResolvedTypeX.Name)typeMap.get(signature);
+ ReferenceType ret = (ReferenceType)typeMap.get(signature);
if (ret == null) {
- ret = new ResolvedTypeX.Name(signature, this);
+ ret = new ReferenceType(signature, this);
typeMap.put(signature, ret);
}
import org.aspectj.apache.bcel.classfile.annotation.ElementNameValuePair;
import org.aspectj.apache.bcel.classfile.annotation.ElementValue;
import org.aspectj.bridge.ISourceLocation;
+import org.aspectj.weaver.AbstractReferenceTypeDelegate;
import org.aspectj.weaver.AjAttribute;
import org.aspectj.weaver.AnnotationX;
import org.aspectj.weaver.BCException;
+import org.aspectj.weaver.ReferenceType;
import org.aspectj.weaver.ResolvedMember;
import org.aspectj.weaver.ResolvedPointcutDefinition;
import org.aspectj.weaver.ResolvedTypeX;
// ??? exposed for testing
-public class BcelObjectType extends ResolvedTypeX.ConcreteName {
+public class BcelObjectType extends AbstractReferenceTypeDelegate {
private JavaClass javaClass;
private boolean isObject = false; // set upon construction
private LazyClassGen lazyClassGen = null; // set lazily if it's an aspect
// IMPORTANT! THIS DOESN'T do real work on the java class, just stores it away.
- BcelObjectType(ResolvedTypeX.Name resolvedTypeX, JavaClass javaClass, boolean exposedToWeaver) {
+ BcelObjectType(ReferenceType resolvedTypeX, JavaClass javaClass, boolean exposedToWeaver) {
super(resolvedTypeX, exposedToWeaver);
this.javaClass = javaClass;
import org.aspectj.weaver.ConcreteTypeMunger;
import org.aspectj.weaver.ICrossReferenceHandler;
import org.aspectj.weaver.Member;
+import org.aspectj.weaver.ReferenceType;
+import org.aspectj.weaver.ReferenceTypeDelegate;
import org.aspectj.weaver.ResolvedMember;
import org.aspectj.weaver.ResolvedTypeMunger;
import org.aspectj.weaver.ResolvedTypeX;
}
- protected ResolvedTypeX.ConcreteName resolveObjectType(ResolvedTypeX.Name ty) {
+ protected ReferenceTypeDelegate resolveObjectType(ReferenceType ty) {
String name = ty.getName();
JavaClass jc = null;
//UnwovenClassFile classFile = (UnwovenClassFile)sourceJavaClasses.get(name);
}
}
- protected BcelObjectType makeBcelObjectType(ResolvedTypeX.Name resolvedTypeX, JavaClass jc, boolean exposedToWeaver) {
+ protected BcelObjectType makeBcelObjectType(ReferenceType resolvedTypeX, JavaClass jc, boolean exposedToWeaver) {
BcelObjectType ret = new BcelObjectType(resolvedTypeX, jc, exposedToWeaver);
return ret;
}
public BcelObjectType addSourceObjectType(JavaClass jc) {
String signature = TypeX.forName(jc.getClassName()).getSignature();
- ResolvedTypeX.Name nameTypeX = (ResolvedTypeX.Name)typeMap.get(signature);
+ ReferenceType nameTypeX = (ReferenceType)typeMap.get(signature);
if (nameTypeX == null) {
- nameTypeX = new ResolvedTypeX.Name(signature, this);
+ nameTypeX = new ReferenceType(signature, this);
}
BcelObjectType ret = makeBcelObjectType(nameTypeX, jc, true);
typeMap.put(signature, nameTypeX);
public static BcelObjectType getBcelObjectType(ResolvedTypeX concreteAspect) {
//XXX need error checking
- return (BcelObjectType) ((ResolvedTypeX.Name)concreteAspect).getDelegate();
+ return (BcelObjectType) ((ReferenceType)concreteAspect).getDelegate();
}
public void tidyUp() {
projects / aspectj.git / commitdiff