From: aclement Date: Fri, 12 Aug 2011 17:51:10 +0000 (+0000) Subject: 239649 and primitives no longer all resolved by default X-Git-Tag: V1_6_12M2~20 X-Git-Url: https://source.dussan.org/?a=commitdiff_plain;h=640fdf57df62873a2877be528c00a60001df067e;p=aspectj.git 239649 and primitives no longer all resolved by default --- diff --git a/org.aspectj.ajdt.core/src/org/aspectj/ajdt/internal/compiler/ast/AdviceDeclaration.java b/org.aspectj.ajdt.core/src/org/aspectj/ajdt/internal/compiler/ast/AdviceDeclaration.java index 3bbd8ddf0..cfbf9d8ef 100644 --- a/org.aspectj.ajdt.core/src/org/aspectj/ajdt/internal/compiler/ast/AdviceDeclaration.java +++ b/org.aspectj.ajdt.core/src/org/aspectj/ajdt/internal/compiler/ast/AdviceDeclaration.java @@ -27,6 +27,8 @@ import org.aspectj.org.eclipse.jdt.internal.compiler.ClassFile; import org.aspectj.org.eclipse.jdt.internal.compiler.CompilationResult; import org.aspectj.org.eclipse.jdt.internal.compiler.ast.Annotation; import org.aspectj.org.eclipse.jdt.internal.compiler.ast.Argument; +import org.aspectj.org.eclipse.jdt.internal.compiler.ast.QualifiedTypeReference; +import org.aspectj.org.eclipse.jdt.internal.compiler.ast.SingleTypeReference; import org.aspectj.org.eclipse.jdt.internal.compiler.ast.TypeDeclaration; import org.aspectj.org.eclipse.jdt.internal.compiler.ast.TypeReference; import org.aspectj.org.eclipse.jdt.internal.compiler.codegen.CodeStream; @@ -370,17 +372,27 @@ public class AdviceDeclaration extends AjMethodDeclaration { } // called by IfPseudoToken - public static Argument[] addTjpArguments(Argument[] arguments) { + public static Argument[] addTjpArguments(Argument[] arguments, TypeDeclaration containingTypeDec) { int index = arguments.length; - arguments = extendArgumentsLength(arguments, 3); + arguments = extendArgumentsLength(arguments, 4); arguments[index++] = makeFinalArgument("thisJoinPointStaticPart", AjTypeConstants.getJoinPointStaticPartType()); arguments[index++] = makeFinalArgument("thisJoinPoint", AjTypeConstants.getJoinPointType()); arguments[index++] = makeFinalArgument("thisEnclosingJoinPointStaticPart", AjTypeConstants.getJoinPointStaticPartType()); + arguments[index++] = makeFinalArgument("thisAspectInstance", toReference(containingTypeDec.name)); return arguments; } + private static TypeReference toReference(char[] typename) { + if (CharOperation.contains('.', typename)) { + char[][] compoundName = CharOperation.splitOn('.', typename); + return new QualifiedTypeReference(compoundName, new long[compoundName.length]); + } else { + return new SingleTypeReference(typename, 0); + } + } + private static Argument makeFinalArgument(String name, TypeReference typeRef) { long pos = 0; // XXX encode start and end location return new Argument(name.toCharArray(), pos, typeRef, Modifier.FINAL); @@ -415,13 +427,13 @@ public class AdviceDeclaration extends AjMethodDeclaration { // }; // }; // s += ")"; //$NON-NLS-1$ - // + // // if (extraArgument != null) { // s += "(" + extraArgument.toString(0) + ")"; // } - // - // - // + // + // + // // if (thrownExceptions != null) { // s += " throws "; //$NON-NLS-1$ // for (int i = 0; i < thrownExceptions.length; i++) { @@ -430,7 +442,7 @@ public class AdviceDeclaration extends AjMethodDeclaration { // s = s + ", "; //$NON-NLS-1$ // }; // }; - // + // // s += ": "; // if (pointcutDesignator != null) { // s += pointcutDesignator.toString(0); diff --git a/org.aspectj.ajdt.core/src/org/aspectj/ajdt/internal/compiler/ast/IfMethodDeclaration.java b/org.aspectj.ajdt.core/src/org/aspectj/ajdt/internal/compiler/ast/IfMethodDeclaration.java index 4f1473463..65115429c 100644 --- a/org.aspectj.ajdt.core/src/org/aspectj/ajdt/internal/compiler/ast/IfMethodDeclaration.java +++ b/org.aspectj.ajdt.core/src/org/aspectj/ajdt/internal/compiler/ast/IfMethodDeclaration.java @@ -17,11 +17,13 @@ import org.aspectj.org.eclipse.jdt.internal.compiler.ClassFile; import org.aspectj.org.eclipse.jdt.internal.compiler.CompilationResult; import org.aspectj.org.eclipse.jdt.internal.compiler.ast.CompilationUnitDeclaration; import org.aspectj.org.eclipse.jdt.internal.compiler.ast.ReturnStatement; +import org.aspectj.org.eclipse.jdt.internal.compiler.lookup.ClassScope; import org.aspectj.org.eclipse.jdt.internal.compiler.parser.Parser; import org.aspectj.weaver.Member; import org.aspectj.weaver.ResolvedMemberImpl; -import org.aspectj.weaver.ResolvedType; +import org.aspectj.weaver.UnresolvedType; import org.aspectj.weaver.patterns.IfPointcut; +import org.aspectj.weaver.patterns.PerClause; public class IfMethodDeclaration extends AjMethodDeclaration { IfPointcut ifPointcut; @@ -39,7 +41,6 @@ public class IfMethodDeclaration extends AjMethodDeclaration { return classFile.generateMethodInfoAttribute(binding, false, AstUtil.getAjSyntheticAttribute()); } - // private static class TrueFalseVisitor extends astvi public void resolveStatements() { super.resolveStatements(); if (binding != null) { @@ -61,7 +62,21 @@ public class IfMethodDeclaration extends AjMethodDeclaration { // XXX this is where we should remove unavailable args if we're in a cflow EclipseFactory factory = EclipseFactory.fromScopeLookupEnvironment(scope); ifPointcut.testMethod = new ResolvedMemberImpl(Member.METHOD, factory.fromBinding(binding.declaringClass), - this.modifiers, ResolvedType.BOOLEAN, new String(this.selector), factory.fromBindings(this.binding.parameters)); + this.modifiers, UnresolvedType.BOOLEAN, new String(this.selector), + factory.fromBindings(this.binding.parameters)); + if (tjp.needsThisAspectInstance && scope.parent instanceof ClassScope) { // really should be + ClassScope o = (ClassScope) scope.parent; + if (o.referenceContext instanceof AspectDeclaration) { // really should be + AspectDeclaration aspectDecl = (AspectDeclaration) o.referenceContext; + if (aspectDecl.perClause != null && aspectDecl.perClause.getKind() != PerClause.SINGLETON) { + scope.problemReporter() + .signalError(sourceStart, sourceEnd, + "thisAspectInstance can only be used inside an if() clause for singleton aspects (compiler limitation)"); + ignoreFurtherInvestigation = true; + return; + } + } + } } } } diff --git a/org.aspectj.ajdt.core/src/org/aspectj/ajdt/internal/compiler/ast/IfPseudoToken.java b/org.aspectj.ajdt.core/src/org/aspectj/ajdt/internal/compiler/ast/IfPseudoToken.java index 314884636..9bf2f3171 100644 --- a/org.aspectj.ajdt.core/src/org/aspectj/ajdt/internal/compiler/ast/IfPseudoToken.java +++ b/org.aspectj.ajdt.core/src/org/aspectj/ajdt/internal/compiler/ast/IfPseudoToken.java @@ -77,12 +77,13 @@ public class IfPseudoToken extends PseudoToken { if (pointcut == null) return; - testMethod = makeMethod(enclosingDec.compilationResult, enclosingDec); + testMethod = makeIfMethod(enclosingDec.compilationResult, enclosingDec, typeDec); AstUtil.addMethodDeclaration(typeDec, testMethod); } // XXX todo: make sure that errors in Arguments only get displayed once - private MethodDeclaration makeMethod(CompilationResult result, MethodDeclaration enclosingDec) { + private MethodDeclaration makeIfMethod(CompilationResult result, MethodDeclaration enclosingDec, + TypeDeclaration containingTypeDec) { MethodDeclaration ret = new IfMethodDeclaration(result, pointcut); ret.modifiers = ClassFileConstants.AccStatic | ClassFileConstants.AccFinal | ClassFileConstants.AccPublic; ret.returnType = AstUtil.makeTypeReference(TypeBinding.BOOLEAN); @@ -107,12 +108,12 @@ public class IfPseudoToken extends PseudoToken { // } // hashcode of expression ret.selector = ifSelector.toString().toCharArray(); - ret.arguments = makeArguments(enclosingDec); + ret.arguments = makeArguments(enclosingDec, containingTypeDec); ret.statements = new Statement[] { new ReturnStatement(expr, expr.sourceStart, expr.sourceEnd) }; return ret; } - private Argument[] makeArguments(MethodDeclaration enclosingDec) { + private Argument[] makeArguments(MethodDeclaration enclosingDec, TypeDeclaration containingTypeDec) { Argument[] baseArguments = enclosingDec.arguments; int len = baseArguments.length; if (enclosingDec instanceof AdviceDeclaration) { @@ -124,7 +125,7 @@ public class IfPseudoToken extends PseudoToken { Argument a = baseArguments[i]; ret[i] = new Argument(a.name, AstUtil.makeLongPos(a.sourceStart, a.sourceEnd), a.type, Modifier.FINAL); } - ret = AdviceDeclaration.addTjpArguments(ret); + ret = AdviceDeclaration.addTjpArguments(ret, containingTypeDec); return ret; } diff --git a/org.aspectj.ajdt.core/src/org/aspectj/ajdt/internal/compiler/ast/InterTypeConstructorDeclaration.java b/org.aspectj.ajdt.core/src/org/aspectj/ajdt/internal/compiler/ast/InterTypeConstructorDeclaration.java index cc569c1c4..fddcc3b90 100644 --- a/org.aspectj.ajdt.core/src/org/aspectj/ajdt/internal/compiler/ast/InterTypeConstructorDeclaration.java +++ b/org.aspectj.ajdt.core/src/org/aspectj/ajdt/internal/compiler/ast/InterTypeConstructorDeclaration.java @@ -324,7 +324,7 @@ public class InterTypeConstructorDeclaration extends InterTypeDeclaration { ((NewConstructorTypeMunger) munger).setExplicitConstructor(world.makeResolvedMember(explicitConstructor)); } else { ((NewConstructorTypeMunger) munger).setExplicitConstructor(new ResolvedMemberImpl(Member.CONSTRUCTOR, world - .fromBinding(onTypeBinding.superclass()), 0, ResolvedType.VOID, "", UnresolvedType.NONE)); + .fromBinding(onTypeBinding.superclass()), 0, UnresolvedType.VOID, "", UnresolvedType.NONE)); } return new AjAttribute.TypeMunger(munger); } diff --git a/org.aspectj.ajdt.core/src/org/aspectj/ajdt/internal/compiler/ast/InterTypeFieldDeclaration.java b/org.aspectj.ajdt.core/src/org/aspectj/ajdt/internal/compiler/ast/InterTypeFieldDeclaration.java index 9e87c5793..aa67fc2ef 100644 --- a/org.aspectj.ajdt.core/src/org/aspectj/ajdt/internal/compiler/ast/InterTypeFieldDeclaration.java +++ b/org.aspectj.ajdt.core/src/org/aspectj/ajdt/internal/compiler/ast/InterTypeFieldDeclaration.java @@ -109,8 +109,8 @@ public class InterTypeFieldDeclaration extends InterTypeDeclaration { ResolvedMember sig = munger.getSignature(); UnresolvedType aspectType = world.fromBinding(upperScope.referenceContext.binding); - if (sig.getReturnType() == ResolvedType.VOID - || (sig.getReturnType().isArray() && (sig.getReturnType().getComponentType() == ResolvedType.VOID))) { + if (sig.getReturnType().equals(UnresolvedType.VOID) + || (sig.getReturnType().isArray() && (sig.getReturnType().getComponentType().equals(UnresolvedType.VOID)))) { upperScope.problemReporter().signalError(sourceStart, sourceEnd, "field type can not be void"); } @@ -166,28 +166,29 @@ public class InterTypeFieldDeclaration extends InterTypeDeclaration { if (initialization == null) { this.statements = new Statement[] { new ReturnStatement(null, 0, 0), }; } else if (!onTypeBinding.isInterface()) { - MethodBinding writeMethod = world.makeMethodBinding(AjcMemberMaker.interFieldSetDispatcher(sig, aspectType), munger - .getTypeVariableAliases()); + MethodBinding writeMethod = world.makeMethodBinding(AjcMemberMaker.interFieldSetDispatcher(sig, aspectType), + munger.getTypeVariableAliases()); // For the body of an intertype field initalizer, generate a call to the inter field set dispatcher // method as that casts the shadow of a field set join point. if (Modifier.isStatic(declaredModifiers)) { - this.statements = new Statement[] { new KnownMessageSend(writeMethod, AstUtil - .makeNameReference(writeMethod.declaringClass), new Expression[] { initialization }), }; + this.statements = new Statement[] { new KnownMessageSend(writeMethod, + AstUtil.makeNameReference(writeMethod.declaringClass), new Expression[] { initialization }), }; } else { - this.statements = new Statement[] { new KnownMessageSend(writeMethod, AstUtil - .makeNameReference(writeMethod.declaringClass), new Expression[] { - AstUtil.makeLocalVariableReference(arguments[0].binding), initialization }), }; + this.statements = new Statement[] { new KnownMessageSend(writeMethod, + AstUtil.makeNameReference(writeMethod.declaringClass), new Expression[] { + AstUtil.makeLocalVariableReference(arguments[0].binding), initialization }), }; } } else { // XXX something is broken about this logic. Can we write to static interface fields? - MethodBinding writeMethod = world.makeMethodBinding(AjcMemberMaker.interFieldInterfaceSetter(sig, sig - .getDeclaringType().resolve(world.getWorld()), aspectType), munger.getTypeVariableAliases()); + MethodBinding writeMethod = world.makeMethodBinding( + AjcMemberMaker.interFieldInterfaceSetter(sig, sig.getDeclaringType().resolve(world.getWorld()), aspectType), + munger.getTypeVariableAliases()); if (Modifier.isStatic(declaredModifiers)) { - this.statements = new Statement[] { new KnownMessageSend(writeMethod, AstUtil - .makeNameReference(writeMethod.declaringClass), new Expression[] { initialization }), }; + this.statements = new Statement[] { new KnownMessageSend(writeMethod, + AstUtil.makeNameReference(writeMethod.declaringClass), new Expression[] { initialization }), }; } else { - this.statements = new Statement[] { new KnownMessageSend(writeMethod, AstUtil - .makeLocalVariableReference(arguments[0].binding), new Expression[] { initialization }), }; + this.statements = new Statement[] { new KnownMessageSend(writeMethod, + AstUtil.makeLocalVariableReference(arguments[0].binding), new Expression[] { initialization }), }; } } @@ -314,16 +315,16 @@ public class InterTypeFieldDeclaration extends InterTypeDeclaration { ClassFile classFile, boolean isGetter) { MethodBinding binding; if (isGetter) { - binding = world.makeMethodBinding(AjcMemberMaker.interFieldGetDispatcher(sig, aspectType), munger - .getTypeVariableAliases(), munger.getSignature().getDeclaringType()); + binding = world.makeMethodBinding(AjcMemberMaker.interFieldGetDispatcher(sig, aspectType), + munger.getTypeVariableAliases(), munger.getSignature().getDeclaringType()); } else { - binding = world.makeMethodBinding(AjcMemberMaker.interFieldSetDispatcher(sig, aspectType), munger - .getTypeVariableAliases(), munger.getSignature().getDeclaringType()); + binding = world.makeMethodBinding(AjcMemberMaker.interFieldSetDispatcher(sig, aspectType), + munger.getTypeVariableAliases(), munger.getSignature().getDeclaringType()); } classFile.generateMethodInfoHeader(binding); int methodAttributeOffset = classFile.contentsOffset; - int attributeNumber = classFile.generateMethodInfoAttribute(binding, false, makeEffectiveSignatureAttribute(sig, - isGetter ? Shadow.FieldGet : Shadow.FieldSet, false)); + int attributeNumber = classFile.generateMethodInfoAttribute(binding, false, + makeEffectiveSignatureAttribute(sig, isGetter ? Shadow.FieldGet : Shadow.FieldSet, false)); int codeAttributeOffset = classFile.contentsOffset; classFile.generateCodeAttributeHeader(); CodeStream codeStream = classFile.codeStream; @@ -331,7 +332,7 @@ public class InterTypeFieldDeclaration extends InterTypeDeclaration { NewFieldTypeMunger fieldMunger = (NewFieldTypeMunger) munger; - // Force use of version 1 if there is a field with that name on the type already + // Force use of version 1 if there is a field with that name on the type already if (world.getItdVersion() == 1) { fieldMunger.version = NewFieldTypeMunger.VersionOne; } else { @@ -346,24 +347,27 @@ public class InterTypeFieldDeclaration extends InterTypeDeclaration { } } - FieldBinding classField = world.makeFieldBinding(AjcMemberMaker.interFieldClassField(sig, aspectType, - fieldMunger.version == NewFieldTypeMunger.VersionTwo), munger.getTypeVariableAliases()); + FieldBinding classField = world.makeFieldBinding( + AjcMemberMaker.interFieldClassField(sig, aspectType, fieldMunger.version == NewFieldTypeMunger.VersionTwo), + munger.getTypeVariableAliases()); codeStream.initializeMaxLocals(binding); if (isGetter) { if (onTypeBinding.isInterface()) { UnresolvedType declaringTX = sig.getDeclaringType(); ResolvedType declaringRTX = world.getWorld().resolve(declaringTX, munger.getSourceLocation()); - MethodBinding readMethod = world.makeMethodBinding(AjcMemberMaker.interFieldInterfaceGetter(sig, declaringRTX, - aspectType), munger.getTypeVariableAliases()); + MethodBinding readMethod = world.makeMethodBinding( + AjcMemberMaker.interFieldInterfaceGetter(sig, declaringRTX, aspectType), munger.getTypeVariableAliases()); generateInterfaceReadBody(binding, readMethod, codeStream); } else { generateClassReadBody(binding, classField, codeStream); } } else { if (onTypeBinding.isInterface()) { - MethodBinding writeMethod = world.makeMethodBinding(AjcMemberMaker.interFieldInterfaceSetter(sig, world.getWorld() - .resolve(sig.getDeclaringType(), munger.getSourceLocation()), aspectType), munger.getTypeVariableAliases()); + MethodBinding writeMethod = world.makeMethodBinding( + AjcMemberMaker.interFieldInterfaceSetter(sig, + world.getWorld().resolve(sig.getDeclaringType(), munger.getSourceLocation()), aspectType), + munger.getTypeVariableAliases()); generateInterfaceWriteBody(binding, writeMethod, codeStream); } else { generateClassWriteBody(binding, classField, codeStream); diff --git a/org.aspectj.ajdt.core/src/org/aspectj/ajdt/internal/compiler/ast/ThisJoinPointVisitor.java b/org.aspectj.ajdt.core/src/org/aspectj/ajdt/internal/compiler/ast/ThisJoinPointVisitor.java index 0cdc91b09..9f4273fe3 100644 --- a/org.aspectj.ajdt.core/src/org/aspectj/ajdt/internal/compiler/ast/ThisJoinPointVisitor.java +++ b/org.aspectj.ajdt.core/src/org/aspectj/ajdt/internal/compiler/ast/ThisJoinPointVisitor.java @@ -40,6 +40,7 @@ public class ThisJoinPointVisitor extends ASTVisitor { boolean needsDynamic = false; boolean needsStatic = false; boolean needsStaticEnclosing = false; + boolean needsThisAspectInstance = false; boolean hasEffectivelyStaticRef = false; boolean hasConstantReference = false; boolean constantReferenceValue = false; // only has valid value when hasConstantReference is true @@ -47,18 +48,25 @@ public class ThisJoinPointVisitor extends ASTVisitor { LocalVariableBinding thisJoinPointDec; LocalVariableBinding thisJoinPointStaticPartDec; LocalVariableBinding thisEnclosingJoinPointStaticPartDec; + LocalVariableBinding thisAspectInstanceDec; LocalVariableBinding thisJoinPointDecLocal; LocalVariableBinding thisJoinPointStaticPartDecLocal; LocalVariableBinding thisEnclosingJoinPointStaticPartDecLocal; + LocalVariableBinding thisAspectInstanceDecLocal; boolean replaceEffectivelyStaticRefs = false; + boolean isIf = true; + AbstractMethodDeclaration method; ThisJoinPointVisitor(AbstractMethodDeclaration method) { this.method = method; - int index = method.arguments.length - 3; + if (method instanceof AdviceDeclaration) { + isIf = false; + } + int index = method.arguments.length - 3 - (isIf ? 1 : 0); thisJoinPointStaticPartDecLocal = method.scope.locals[index]; thisJoinPointStaticPartDec = method.arguments[index++].binding; @@ -66,6 +74,10 @@ public class ThisJoinPointVisitor extends ASTVisitor { thisJoinPointDec = method.arguments[index++].binding; thisEnclosingJoinPointStaticPartDecLocal = method.scope.locals[index]; thisEnclosingJoinPointStaticPartDec = method.arguments[index++].binding; + if (isIf) { + thisAspectInstanceDecLocal = method.scope.locals[index]; + thisAspectInstanceDec = method.arguments[index++].binding; + } } public void computeJoinPointParams() { @@ -100,6 +112,8 @@ public class ThisJoinPointVisitor extends ASTVisitor { needsStatic = true; } else if (isRef(ref, thisEnclosingJoinPointStaticPartDec)) { needsStaticEnclosing = true; + } else if (isIf && isRef(ref, thisAspectInstanceDec)) { + needsThisAspectInstance = true; } else if (ref.constant != null && ref.constant != Constant.NotAConstant) { if (ref.constant instanceof BooleanConstant) { hasConstantReference = true; @@ -196,7 +210,16 @@ public class ThisJoinPointVisitor extends ASTVisitor { this.computeJoinPointParams(); MethodBinding binding = method.binding; - int index = binding.parameters.length - 3; + int index = binding.parameters.length - 3 - (isIf ? 1 : 0); + + if (isIf) { + if (needsThisAspectInstance) { + extraArgumentFlags |= Advice.ThisAspectInstance; + } else { + removeParameter(index + 3); + } + } + if (needsStaticEnclosing) { extraArgumentFlags |= Advice.ThisEnclosingJoinPointStaticPart; } else { @@ -218,6 +241,10 @@ public class ThisJoinPointVisitor extends ASTVisitor { return extraArgumentFlags; } + public boolean usedThisAspectInstance() { + return needsThisAspectInstance; + } + private void removeParameter(int indexToRemove) { // TypeBinding[] parameters = method.binding.parameters; method.scope.locals = removeLocalBinding(indexToRemove, method.scope.locals); 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 e5bb25ce5..5afa9875c 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 @@ -639,31 +639,31 @@ public class EclipseFactory { private TypeBinding makeTypeBinding1(UnresolvedType typeX) { if (typeX.isPrimitiveType()) { - if (typeX == ResolvedType.BOOLEAN) { + if (typeX.equals(UnresolvedType.BOOLEAN)) { return TypeBinding.BOOLEAN; } - if (typeX == ResolvedType.BYTE) { + if (typeX.equals(UnresolvedType.BYTE)) { return TypeBinding.BYTE; } - if (typeX == ResolvedType.CHAR) { + if (typeX.equals(UnresolvedType.CHAR)) { return TypeBinding.CHAR; } - if (typeX == ResolvedType.DOUBLE) { + if (typeX.equals(UnresolvedType.DOUBLE)) { return TypeBinding.DOUBLE; } - if (typeX == ResolvedType.FLOAT) { + if (typeX.equals(UnresolvedType.FLOAT)) { return TypeBinding.FLOAT; } - if (typeX == ResolvedType.INT) { + if (typeX.equals(UnresolvedType.INT)) { return TypeBinding.INT; } - if (typeX == ResolvedType.LONG) { + if (typeX.equals(UnresolvedType.LONG)) { return TypeBinding.LONG; } - if (typeX == ResolvedType.SHORT) { + if (typeX.equals(UnresolvedType.SHORT)) { return TypeBinding.SHORT; } - if (typeX == ResolvedType.VOID) { + if (typeX.equals(UnresolvedType.VOID)) { return TypeBinding.VOID; } throw new RuntimeException("weird primitive type " + typeX); diff --git a/org.aspectj.ajdt.core/src/org/aspectj/ajdt/internal/compiler/lookup/EclipseShadow.java b/org.aspectj.ajdt.core/src/org/aspectj/ajdt/internal/compiler/lookup/EclipseShadow.java index 90a7a8061..e4de168e0 100644 --- a/org.aspectj.ajdt.core/src/org/aspectj/ajdt/internal/compiler/lookup/EclipseShadow.java +++ b/org.aspectj.ajdt.core/src/org/aspectj/ajdt/internal/compiler/lookup/EclipseShadow.java @@ -10,33 +10,46 @@ * PARC initial implementation * ******************************************************************/ - package org.aspectj.ajdt.internal.compiler.lookup; - -import org.aspectj.ajdt.internal.compiler.ast.*; +import org.aspectj.ajdt.internal.compiler.ast.AdviceDeclaration; +import org.aspectj.ajdt.internal.compiler.ast.InterTypeConstructorDeclaration; +import org.aspectj.ajdt.internal.compiler.ast.InterTypeDeclaration; +import org.aspectj.ajdt.internal.compiler.ast.InterTypeFieldDeclaration; +import org.aspectj.ajdt.internal.compiler.ast.InterTypeMethodDeclaration; import org.aspectj.bridge.ISourceLocation; -import org.aspectj.weaver.*; -import org.aspectj.weaver.ast.Var; -import org.aspectj.org.eclipse.jdt.internal.compiler.ast.*; +import org.aspectj.org.eclipse.jdt.internal.compiler.ast.ASTNode; +import org.aspectj.org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration; +import org.aspectj.org.eclipse.jdt.internal.compiler.ast.AllocationExpression; +import org.aspectj.org.eclipse.jdt.internal.compiler.ast.Clinit; +import org.aspectj.org.eclipse.jdt.internal.compiler.ast.ConstructorDeclaration; +import org.aspectj.org.eclipse.jdt.internal.compiler.ast.ExplicitConstructorCall; +import org.aspectj.org.eclipse.jdt.internal.compiler.ast.MessageSend; +import org.aspectj.org.eclipse.jdt.internal.compiler.ast.MethodDeclaration; +import org.aspectj.org.eclipse.jdt.internal.compiler.ast.TypeDeclaration; import org.aspectj.org.eclipse.jdt.internal.compiler.impl.ReferenceContext; +import org.aspectj.weaver.Member; +import org.aspectj.weaver.MemberImpl; +import org.aspectj.weaver.ResolvedType; +import org.aspectj.weaver.Shadow; +import org.aspectj.weaver.UnresolvedType; +import org.aspectj.weaver.World; +import org.aspectj.weaver.ast.Var; /** * This is only used for declare soft right now. * - * It might be used for other compile-time matching, but in all such cases - * this and target pcds can't be used. We might not behave correctly in - * such cases. + * It might be used for other compile-time matching, but in all such cases this and target pcds can't be used. We might not behave + * correctly in such cases. */ public class EclipseShadow extends Shadow { EclipseFactory world; ASTNode astNode; ReferenceContext context; - //AbstractMethodDeclaration enclosingMethod; - public EclipseShadow(EclipseFactory world, Kind kind, Member signature, ASTNode astNode, - ReferenceContext context) - { + // AbstractMethodDeclaration enclosingMethod; + + public EclipseShadow(EclipseFactory world, Kind kind, Member signature, ASTNode astNode, ReferenceContext context) { super(kind, signature, null); this.world = world; this.astNode = astNode; @@ -47,28 +60,27 @@ public class EclipseShadow extends Shadow { return world.getWorld(); } - public UnresolvedType getEnclosingType() { if (context instanceof TypeDeclaration) { - return world.fromBinding(((TypeDeclaration)context).binding); + return world.fromBinding(((TypeDeclaration) context).binding); } else if (context instanceof AbstractMethodDeclaration) { - return world.fromBinding(((AbstractMethodDeclaration)context).binding.declaringClass); + return world.fromBinding(((AbstractMethodDeclaration) context).binding.declaringClass); } else { return ResolvedType.MISSING; } } - + public ISourceLocation getSourceLocation() { - //XXX need to fill this in ASAP + // XXX need to fill this in ASAP return null; } public Member getEnclosingCodeSignature() { if (context instanceof TypeDeclaration) { - return new MemberImpl(Member.STATIC_INITIALIZATION, getEnclosingType(), 0, - ResolvedType.VOID, "", UnresolvedType.NONE); + return new MemberImpl(Member.STATIC_INITIALIZATION, getEnclosingType(), 0, UnresolvedType.VOID, "", + UnresolvedType.NONE); } else if (context instanceof AbstractMethodDeclaration) { - return world.makeResolvedMember(((AbstractMethodDeclaration)context).binding); + return world.makeResolvedMember(((AbstractMethodDeclaration) context).binding); } else { return null; } @@ -108,52 +120,52 @@ public class EclipseShadow extends Shadow { public Var getKindedAnnotationVar(UnresolvedType annotationType) { throw new RuntimeException("unimplemented"); } - + public Var getTargetAnnotationVar(UnresolvedType annotationType) { throw new RuntimeException("unimplemented"); } - + public Var getThisAnnotationVar(UnresolvedType annotationType) { throw new RuntimeException("unimplemented"); } - + + public Var getThisAspectInstanceVar(ResolvedType aspectType) { + throw new RuntimeException("unimplemented"); + } + public Var getWithinAnnotationVar(UnresolvedType annotationType) { throw new RuntimeException("unimplemented"); } - + public Var getWithinCodeAnnotationVar(UnresolvedType annotationType) { throw new RuntimeException("unimplemented"); } // --- factory methods - - public static EclipseShadow makeShadow(EclipseFactory world, ASTNode astNode, - ReferenceContext context) - { - //XXX make sure we're getting the correct declaring type at call-site + + public static EclipseShadow makeShadow(EclipseFactory world, ASTNode astNode, ReferenceContext context) { + // XXX make sure we're getting the correct declaring type at call-site if (astNode instanceof AllocationExpression) { - AllocationExpression e = (AllocationExpression)astNode; - return new EclipseShadow(world, Shadow.ConstructorCall, - world.makeResolvedMember(e.binding), astNode, context); + AllocationExpression e = (AllocationExpression) astNode; + return new EclipseShadow(world, Shadow.ConstructorCall, world.makeResolvedMember(e.binding), astNode, context); } else if (astNode instanceof MessageSend) { - MessageSend e = (MessageSend)astNode; - if (e.isSuperAccess()) return null; // super calls don't have shadows - return new EclipseShadow(world, Shadow.MethodCall, - world.makeResolvedMember(e.binding), astNode, context); + MessageSend e = (MessageSend) astNode; + if (e.isSuperAccess()) + return null; // super calls don't have shadows + return new EclipseShadow(world, Shadow.MethodCall, world.makeResolvedMember(e.binding), astNode, context); } else if (astNode instanceof ExplicitConstructorCall) { - //??? these should be ignored, they don't have shadows - return null; + // ??? these should be ignored, they don't have shadows + return null; } else if (astNode instanceof AbstractMethodDeclaration) { - AbstractMethodDeclaration e = (AbstractMethodDeclaration)astNode; + AbstractMethodDeclaration e = (AbstractMethodDeclaration) astNode; Shadow.Kind kind; if (e instanceof AdviceDeclaration) { kind = Shadow.AdviceExecution; } else if (e instanceof InterTypeMethodDeclaration) { - return new EclipseShadow(world, Shadow.MethodExecution, - ((InterTypeDeclaration)e).getSignature(), astNode, context); + return new EclipseShadow(world, Shadow.MethodExecution, ((InterTypeDeclaration) e).getSignature(), astNode, context); } else if (e instanceof InterTypeConstructorDeclaration) { - return new EclipseShadow(world, Shadow.ConstructorExecution, - ((InterTypeDeclaration)e).getSignature(), astNode, context); + return new EclipseShadow(world, Shadow.ConstructorExecution, ((InterTypeDeclaration) e).getSignature(), astNode, + context); } else if (e instanceof InterTypeFieldDeclaration) { return null; } else if (e instanceof MethodDeclaration) { @@ -161,25 +173,20 @@ public class EclipseShadow extends Shadow { } else if (e instanceof ConstructorDeclaration) { kind = Shadow.ConstructorExecution; } else if (e instanceof Clinit) { - kind = Shadow.StaticInitialization; + kind = Shadow.StaticInitialization; } else { return null; - //throw new RuntimeException("unimplemented: " + e); + // throw new RuntimeException("unimplemented: " + e); } - return - new EclipseShadow(world, kind, - world.makeResolvedMember(e.binding,kind), astNode, context); + return new EclipseShadow(world, kind, world.makeResolvedMember(e.binding, kind), astNode, context); } else if (astNode instanceof TypeDeclaration) { return new EclipseShadow(world, Shadow.StaticInitialization, - new MemberImpl(Member.STATIC_INITIALIZATION, - world.fromBinding(((TypeDeclaration)astNode).binding), 0, - ResolvedType.VOID, "", UnresolvedType.NONE), - astNode, context); + new MemberImpl(Member.STATIC_INITIALIZATION, world.fromBinding(((TypeDeclaration) astNode).binding), 0, + UnresolvedType.VOID, "", UnresolvedType.NONE), astNode, context); } else { return null; - //throw new RuntimeException("unimplemented: " + astNode); - } + // throw new RuntimeException("unimplemented: " + astNode); + } } - } diff --git a/org.aspectj.ajdt.core/src/org/aspectj/ajdt/internal/compiler/lookup/PrivilegedHandler.java b/org.aspectj.ajdt.core/src/org/aspectj/ajdt/internal/compiler/lookup/PrivilegedHandler.java index bf7aaed0f..9179e286d 100644 --- a/org.aspectj.ajdt.core/src/org/aspectj/ajdt/internal/compiler/lookup/PrivilegedHandler.java +++ b/org.aspectj.ajdt.core/src/org/aspectj/ajdt/internal/compiler/lookup/PrivilegedHandler.java @@ -115,7 +115,7 @@ public class PrivilegedHandler implements IPrivilegedHandler { public void notePrivilegedTypeAccess(ReferenceBinding type, ASTNode location) { ResolvedMember key = new ResolvedMemberImpl(Member.STATIC_INITIALIZATION, inAspect.factory.fromEclipse(type), 0, - ResolvedType.VOID, "", UnresolvedType.NONE); + UnresolvedType.VOID, "", UnresolvedType.NONE); checkWeaveAccess(key.getDeclaringType(), location); accessors.put(key, key);