From c6c22b6a6942ef6039a026fe871e72640374b160 Mon Sep 17 00:00:00 2001 From: aclement Date: Thu, 17 Jan 2008 00:26:42 +0000 Subject: [PATCH] AspectJ6: picking up compiler interface changes --- .../compiler/lookup/AjLookupEnvironment.java | 27 ++++++++ .../compiler/lookup/EclipseFactory.java | 61 ++++++++++++++----- .../lookup/EclipseSourceLocation.java | 5 +- .../compiler/lookup/EclipseTypeMunger.java | 31 ++++++++-- 4 files changed, 102 insertions(+), 22 deletions(-) diff --git a/org.aspectj.ajdt.core/src/org/aspectj/ajdt/internal/compiler/lookup/AjLookupEnvironment.java b/org.aspectj.ajdt.core/src/org/aspectj/ajdt/internal/compiler/lookup/AjLookupEnvironment.java index 310870454..7c26f68b6 100644 --- a/org.aspectj.ajdt.core/src/org/aspectj/ajdt/internal/compiler/lookup/AjLookupEnvironment.java +++ b/org.aspectj.ajdt.core/src/org/aspectj/ajdt/internal/compiler/lookup/AjLookupEnvironment.java @@ -808,6 +808,7 @@ public class AjLookupEnvironment extends LookupEnvironment implements AnonymousC TypeDeclaration typeDecl = ((SourceTypeBinding)mbs[0].declaringClass).scope.referenceContext; AbstractMethodDeclaration methodDecl = typeDecl.declarationOf(mbs[0]); toAdd = methodDecl.annotations; // this is what to add + toAdd[0] = createAnnotationCopy(toAdd[0]); if (toAdd[0].resolvedType!=null) // pr148536 abits = toAdd[0].resolvedType.getAnnotationTagBits(); } @@ -945,6 +946,32 @@ public class AjLookupEnvironment extends LookupEnvironment implements AnonymousC // ann.memberValuePairs = mvps; return ann; } + + /** Create a copy of an annotation, not deep but deep enough so we don't copy across fields that will get us into trouble like 'recipient' */ + private static Annotation createAnnotationCopy(Annotation ann) { + NormalAnnotation ann2 = new NormalAnnotation(ann.type,ann.sourceStart); + ann2.memberValuePairs = ann.memberValuePairs(); + ann2.resolvedType = ann.resolvedType; + ann2.bits = ann.bits; + return ann2; +// String name = annX.getTypeName(); +// TypeBinding tb = factory.makeTypeBinding(annX.getSignature()); +// String theName = annX.getSignature().getBaseName(); +// char[][] typeName = CharOperation.splitOn('.',name.replace('$','.').toCharArray()); //pr149293 - not bulletproof... +// long[] positions = new long[typeName.length]; +// for (int i = 0; i < positions.length; i++) positions[i]=pos; +// TypeReference annType = new QualifiedTypeReference(typeName,positions); +// NormalAnnotation ann = new NormalAnnotation(annType,pos); +// ann.resolvedType=tb; // yuck - is this OK in all cases? +// // We don't need membervalues... +//// Expression pcExpr = new StringLiteral(pointcutExpression.toCharArray(),pos,pos); +//// MemberValuePair[] mvps = new MemberValuePair[2]; +//// mvps[0] = new MemberValuePair("value".toCharArray(),pos,pos,pcExpr); +//// Expression argNamesExpr = new StringLiteral(argNames.toCharArray(),pos,pos); +//// mvps[1] = new MemberValuePair("argNames".toCharArray(),pos,pos,argNamesExpr); +//// ann.memberValuePairs = mvps; +// return ann; + } private boolean isAnnotationTargettingSomethingOtherThanAnnotationOrNormal(long abits) { return (abits & (TagBits.AnnotationForAnnotationType | TagBits.AnnotationForType))==0; diff --git a/org.aspectj.ajdt.core/src/org/aspectj/ajdt/internal/compiler/lookup/EclipseFactory.java b/org.aspectj.ajdt.core/src/org/aspectj/ajdt/internal/compiler/lookup/EclipseFactory.java index a856e5ec8..fdba92aa1 100644 --- a/org.aspectj.ajdt.core/src/org/aspectj/ajdt/internal/compiler/lookup/EclipseFactory.java +++ b/org.aspectj.ajdt.core/src/org/aspectj/ajdt/internal/compiler/lookup/EclipseFactory.java @@ -38,7 +38,6 @@ import org.aspectj.org.eclipse.jdt.internal.compiler.ast.Wildcard; import org.aspectj.org.eclipse.jdt.internal.compiler.impl.Constant; import org.aspectj.org.eclipse.jdt.internal.compiler.impl.ReferenceContext; import org.aspectj.org.eclipse.jdt.internal.compiler.lookup.ArrayBinding; -import org.aspectj.org.eclipse.jdt.internal.compiler.lookup.BaseTypes; import org.aspectj.org.eclipse.jdt.internal.compiler.lookup.Binding; import org.aspectj.org.eclipse.jdt.internal.compiler.lookup.FieldBinding; import org.aspectj.org.eclipse.jdt.internal.compiler.lookup.LocalTypeBinding; @@ -49,6 +48,7 @@ import org.aspectj.org.eclipse.jdt.internal.compiler.lookup.RawTypeBinding; import org.aspectj.org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding; import org.aspectj.org.eclipse.jdt.internal.compiler.lookup.Scope; import org.aspectj.org.eclipse.jdt.internal.compiler.lookup.SourceTypeBinding; +import org.aspectj.org.eclipse.jdt.internal.compiler.lookup.SyntheticFieldBinding; import org.aspectj.org.eclipse.jdt.internal.compiler.lookup.TypeBinding; import org.aspectj.org.eclipse.jdt.internal.compiler.lookup.TypeVariableBinding; import org.aspectj.org.eclipse.jdt.internal.compiler.lookup.WildcardBinding; @@ -72,6 +72,10 @@ import org.aspectj.weaver.UnresolvedType; import org.aspectj.weaver.UnresolvedTypeVariableReferenceType; import org.aspectj.weaver.World; import org.aspectj.weaver.UnresolvedType.TypeKind; + +import sun.reflect.generics.reflectiveObjects.NotImplementedException; + +import com.sun.org.apache.xml.internal.utils.UnImplNode; /** * @author Jim Hugunin @@ -612,15 +616,15 @@ public class EclipseFactory { private TypeBinding makeTypeBinding1(UnresolvedType typeX) { if (typeX.isPrimitiveType()) { - if (typeX == ResolvedType.BOOLEAN) return BaseTypes.BooleanBinding; - if (typeX == ResolvedType.BYTE) return BaseTypes.ByteBinding; - if (typeX == ResolvedType.CHAR) return BaseTypes.CharBinding; - if (typeX == ResolvedType.DOUBLE) return BaseTypes.DoubleBinding; - if (typeX == ResolvedType.FLOAT) return BaseTypes.FloatBinding; - if (typeX == ResolvedType.INT) return BaseTypes.IntBinding; - if (typeX == ResolvedType.LONG) return BaseTypes.LongBinding; - if (typeX == ResolvedType.SHORT) return BaseTypes.ShortBinding; - if (typeX == ResolvedType.VOID) return BaseTypes.VoidBinding; + if (typeX == ResolvedType.BOOLEAN) return TypeBinding.BOOLEAN; + if (typeX == ResolvedType.BYTE) return TypeBinding.BYTE; + if (typeX == ResolvedType.CHAR) return TypeBinding.CHAR; + if (typeX == ResolvedType.DOUBLE) return TypeBinding.DOUBLE; + if (typeX == ResolvedType.FLOAT) return TypeBinding.FLOAT; + if (typeX == ResolvedType.INT) return TypeBinding.INT; + if (typeX == ResolvedType.LONG) return TypeBinding.LONG; + if (typeX == ResolvedType.SHORT) return TypeBinding.SHORT; + if (typeX == ResolvedType.VOID) return TypeBinding.VOID; throw new RuntimeException("weird primitive type " + typeX); } else if (typeX.isArray()) { int dim = 0; @@ -721,6 +725,21 @@ public class EclipseFactory { return internalMakeFieldBinding(member,null); } + // OPTIMIZE tidy this up, must be able to optimize for the synthetic case, if we passed in the binding for the declaring type, that would make things easier + /** + * Build a new Eclipse SyntheticFieldBinding for an AspectJ ResolvedMember. + */ + public SyntheticFieldBinding createSyntheticFieldBinding(SourceTypeBinding owningType,ResolvedMember member) { + SyntheticFieldBinding sfb = new SyntheticFieldBinding(member.getName().toCharArray(), + makeTypeBinding(member.getReturnType()), + member.getModifiers() | Flags.AccSynthetic, + owningType, + Constant.NotAConstant, + -1); // index filled in later + owningType.addSyntheticField(sfb); + return sfb; + } + /** * Take a normal AJ member and convert it into an eclipse fieldBinding. * Taking into account any aliases that it may include due to being @@ -744,11 +763,21 @@ public class EclipseFactory { } currentType = declaringType; - FieldBinding fb = new FieldBinding(member.getName().toCharArray(), + + FieldBinding fb = null; + if (member.getName().startsWith(NameMangler.PREFIX)) { + fb = new SyntheticFieldBinding(member.getName().toCharArray(), + makeTypeBinding(member.getReturnType()), + member.getModifiers() | Flags.AccSynthetic, + currentType, + Constant.NotAConstant,-1); // index filled in later + } else { + fb = new FieldBinding(member.getName().toCharArray(), makeTypeBinding(member.getReturnType()), member.getModifiers(), currentType, Constant.NotAConstant); + } typeVariableToTypeBinding.clear(); currentType = null; @@ -806,7 +835,7 @@ public class EclipseFactory { if (member.getTypeVariables()!=null) { if (member.getTypeVariables().length==0) { - tvbs = MethodBinding.NoTypeVariables; + tvbs = Binding.NO_TYPE_VARIABLES; } else { tvbs = makeTypeVariableBindingsFromAJTypeVariables(member.getTypeVariables()); // QQQ do we need to bother fixing up the declaring element here? @@ -892,12 +921,14 @@ public class EclipseFactory { // } else { // declaringElement = makeTypeBinding((UnresolvedType)tVar.getDeclaringElement()); // } - tvBinding = new TypeVariableBinding(tv.getName().toCharArray(),declaringElement,tv.getRank()); + + tvBinding = new TypeVariableBinding(tv.getName().toCharArray(),null,tv.getRank()); + typeVariableToTypeBinding.put(tv.getName(),tvBinding); tvBinding.superclass=(ReferenceBinding)makeTypeBinding(tv.getUpperBound()); tvBinding.firstBound=(ReferenceBinding)makeTypeBinding(tv.getFirstBound()); if (tv.getAdditionalInterfaceBounds()==null) { - tvBinding.superInterfaces=TypeVariableBinding.NoSuperInterfaces; + tvBinding.superInterfaces=TypeVariableBinding.NO_SUPERINTERFACES; } else { TypeBinding tbs[] = makeTypeBindings(tv.getAdditionalInterfaceBounds()); ReferenceBinding[] rbs= new ReferenceBinding[tbs.length]; @@ -929,7 +960,7 @@ public class EclipseFactory { tvBinding.superclass=(ReferenceBinding)makeTypeBinding(tv.getUpperBound()); tvBinding.firstBound=(ReferenceBinding)makeTypeBinding(tv.getFirstBound()); if (tv.getAdditionalInterfaceBounds()==null) { - tvBinding.superInterfaces=TypeVariableBinding.NoSuperInterfaces; + tvBinding.superInterfaces=TypeVariableBinding.NO_SUPERINTERFACES; } else { TypeBinding tbs[] = makeTypeBindings(tv.getAdditionalInterfaceBounds()); ReferenceBinding[] rbs= new ReferenceBinding[tbs.length]; diff --git a/org.aspectj.ajdt.core/src/org/aspectj/ajdt/internal/compiler/lookup/EclipseSourceLocation.java b/org.aspectj.ajdt.core/src/org/aspectj/ajdt/internal/compiler/lookup/EclipseSourceLocation.java index 0f80b1380..42c84f664 100644 --- a/org.aspectj.ajdt.core/src/org/aspectj/ajdt/internal/compiler/lookup/EclipseSourceLocation.java +++ b/org.aspectj.ajdt.core/src/org/aspectj/ajdt/internal/compiler/lookup/EclipseSourceLocation.java @@ -21,6 +21,7 @@ import org.aspectj.org.eclipse.jdt.core.compiler.IProblem; import org.aspectj.org.eclipse.jdt.internal.compiler.CompilationResult; import org.aspectj.org.eclipse.jdt.internal.compiler.env.ICompilationUnit; import org.aspectj.org.eclipse.jdt.internal.compiler.problem.ProblemHandler; +import org.aspectj.org.eclipse.jdt.internal.compiler.util.Util; public class EclipseSourceLocation implements ISourceLocation { private static String NO_CONTEXT = "USE_NULL--NO_CONTEXT_AVAILABLE"; @@ -75,7 +76,7 @@ public class EclipseSourceLocation implements ISourceLocation { public int getLine() { if (-1 == startLine && result!=null) { - startLine = ProblemHandler.searchLineNumber(result.lineSeparatorPositions, startPos); + startLine = Util.getLineNumber(startPos,result.lineSeparatorPositions,0,result.lineSeparatorPositions.length-1); } return startLine; } @@ -101,7 +102,7 @@ public class EclipseSourceLocation implements ISourceLocation { public int getEndLine() { if (-1 == endLine) { - endLine = ProblemHandler.searchLineNumber(result.lineSeparatorPositions, endPos); + endLine = Util.getLineNumber(endPos,result.lineSeparatorPositions,0,result.lineSeparatorPositions.length-1); } return endLine; } diff --git a/org.aspectj.ajdt.core/src/org/aspectj/ajdt/internal/compiler/lookup/EclipseTypeMunger.java b/org.aspectj.ajdt.core/src/org/aspectj/ajdt/internal/compiler/lookup/EclipseTypeMunger.java index d94b8724e..78770ad98 100644 --- a/org.aspectj.ajdt.core/src/org/aspectj/ajdt/internal/compiler/lookup/EclipseTypeMunger.java +++ b/org.aspectj.ajdt.core/src/org/aspectj/ajdt/internal/compiler/lookup/EclipseTypeMunger.java @@ -14,13 +14,15 @@ package org.aspectj.ajdt.internal.compiler.lookup; import java.lang.reflect.Modifier; +import java.util.Map; import org.aspectj.bridge.ISourceLocation; import org.aspectj.org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration; -import org.aspectj.org.eclipse.jdt.internal.compiler.env.IConstants; +import org.aspectj.org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants; import org.aspectj.org.eclipse.jdt.internal.compiler.lookup.FieldBinding; import org.aspectj.org.eclipse.jdt.internal.compiler.lookup.MethodBinding; import org.aspectj.org.eclipse.jdt.internal.compiler.lookup.SourceTypeBinding; +import org.aspectj.org.eclipse.jdt.internal.compiler.lookup.TypeVariableBinding; import org.aspectj.weaver.ConcreteTypeMunger; import org.aspectj.weaver.NewConstructorTypeMunger; import org.aspectj.weaver.NewFieldTypeMunger; @@ -28,6 +30,7 @@ import org.aspectj.weaver.NewMethodTypeMunger; import org.aspectj.weaver.ResolvedMember; import org.aspectj.weaver.ResolvedType; import org.aspectj.weaver.ResolvedTypeMunger; +import org.aspectj.weaver.World; public class EclipseTypeMunger extends ConcreteTypeMunger { @@ -127,11 +130,11 @@ public class EclipseTypeMunger extends ConcreteTypeMunger { // retain *only* the visibility modifiers and abstract when putting methods on an interface... if (sourceType.isInterface()) { - boolean isAbstract = (binding.modifiers & IConstants.AccAbstract) != 0; - binding.modifiers = (binding.modifiers & (IConstants.AccPublic | IConstants.AccProtected | IConstants.AccPrivate)); - if (isAbstract) binding.modifiers |= IConstants.AccAbstract; + boolean isAbstract = (binding.modifiers & ClassFileConstants.AccAbstract) != 0; + binding.modifiers = (binding.modifiers & (ClassFileConstants.AccPublic | ClassFileConstants.AccProtected | ClassFileConstants.AccPrivate)); + if (isAbstract) binding.modifiers |= ClassFileConstants.AccAbstract; } - if (munger.getSignature().isVarargsMethod()) binding.modifiers |= IConstants.AccVarargs; + if (munger.getSignature().isVarargsMethod()) binding.modifiers |= ClassFileConstants.AccVarargs; findOrCreateInterTypeMemberFinder(sourceType).addInterTypeMethod(binding); return true; } @@ -141,6 +144,20 @@ public class EclipseTypeMunger extends ConcreteTypeMunger { if (shouldTreatAsPublic()) { MethodBinding binding = world.makeMethodBinding(munger.getSignature(),munger.getTypeVariableAliases()); findOrCreateInterTypeMemberFinder(sourceType).addInterTypeMethod(binding); + TypeVariableBinding[] typeVariables = binding.typeVariables; + for (int i = 0; i < typeVariables.length; i++) { + TypeVariableBinding tv = typeVariables[i]; + String name = new String(tv.sourceName); + TypeVariableBinding[] tv2 = sourceMethod.binding.typeVariables; + for (int j = 0; j < tv2.length; j++) { + TypeVariableBinding typeVariable = tv2[j]; + if (new String(tv2[j].sourceName).equals(name)) typeVariables[i].declaringElement = binding; + } + } + for (int i = 0; i < typeVariables.length; i++) { + if (typeVariables[i].declaringElement==null) throw new RuntimeException("Declaring element not set"); + + } //classScope.referenceContext.binding.addMethod(binding); } else { InterTypeMethodBinding binding = @@ -202,4 +219,8 @@ public class EclipseTypeMunger extends ConcreteTypeMunger { return new EclipseTypeMunger(world,munger.parameterizedFor(target),aspectType,sourceMethod); } + public ConcreteTypeMunger parameterizeWith(Map m,World w) { + return new EclipseTypeMunger(world,munger.parameterizeWith(m,w),aspectType,sourceMethod); + } + } -- 2.39.5