fix for Bugzilla Bug 41952

   XLint warning for call PCD's using subtype of defining type 

also added extraSourceLocations to IMessage+ for
message with multiple source lines

11 files changed, 157 insertions, 21 deletions

diff --git a/weaver/src/org/aspectj/weaver/Checker.java b/weaver/src/org/aspectj/weaver/Checker.java
index 0e30723b4..3baa45175 100644
--- a/weaver/src/org/aspectj/weaver/Checker.java
+++ b/weaver/src/org/aspectj/weaver/Checker.java
@@ -49,7 +49,9 @@ public class Checker extends ShadowMunger {
 				msg,
 				shadow.toString(),
 				isError ? IMessage.ERROR : IMessage.WARNING,
-				shadow.getSourceLocation());
+				shadow.getSourceLocation(),
+                null,
+                new ISourceLocation[]{this.getSourceLocation()});
 			world.getMessageHandler().handleMessage(message);
 			
 			AsmRelationshipProvider.checkerMunger(world.getModel(), shadow, this);
diff --git a/weaver/src/org/aspectj/weaver/Lint.java b/weaver/src/org/aspectj/weaver/Lint.java
index 3b3db4c60..5a2d1c566 100644
--- a/weaver/src/org/aspectj/weaver/Lint.java
+++ b/weaver/src/org/aspectj/weaver/Lint.java
@@ -46,7 +46,10 @@ public class Lint {
 		
 	public final Kind shadowNotInStructure = 
 		new Kind("shadowNotInStructure", "the shadow for this join point is not exposed in the structure model: {0}");
-		
+
+    public final Kind unmatchedSuperTypeInCall = 
+        new Kind("unmatchedSuperTypeInCall", "does not match because declaring type is {0}, if match desired use target({1})");
+            
 	public Lint(World world) {
 		this.world = world;
 	}
@@ -149,5 +152,14 @@ public class Lint {
 			text += " [Xlint:" + name + "]";
 			world.getMessageHandler().handleMessage(new Message(text, kind, null, location));
 		}
+
+		public void signal(String[] infos, ISourceLocation location, ISourceLocation[] extraLocations) {
+            if (kind == null) return;
+            
+            String text = MessageFormat.format(message, infos );
+            text += " [Xlint:" + name + "]";
+            world.getMessageHandler().handleMessage(
+                new Message(text, "", kind, location, null, extraLocations));
+		}
 	}
 }
diff --git a/weaver/src/org/aspectj/weaver/XlintDefault.properties b/weaver/src/org/aspectj/weaver/XlintDefault.properties
index 59d6d2f28..10da55a66 100644
--- a/weaver/src/org/aspectj/weaver/XlintDefault.properties
+++ b/weaver/src/org/aspectj/weaver/XlintDefault.properties
@@ -5,4 +5,6 @@ unresolvableMember = warning
 
 typeNotExposedToWeaver = warning
 
-shadowNotInStructure = ignore
\ No newline at end of file
+shadowNotInStructure = ignore
+
+unmatchedSuperTypeInCall = warning
diff --git a/weaver/src/org/aspectj/weaver/patterns/AndPointcut.java b/weaver/src/org/aspectj/weaver/patterns/AndPointcut.java
index 5dc127aaf..b3202774a 100644
--- a/weaver/src/org/aspectj/weaver/patterns/AndPointcut.java
+++ b/weaver/src/org/aspectj/weaver/patterns/AndPointcut.java
@@ -85,8 +85,8 @@ public class AndPointcut extends Pointcut {
 	}
 
 	public Pointcut concretize1(ResolvedTypeX inAspect, IntMap bindings) {
-		return new AndPointcut(left.concretize1(inAspect, bindings),
-								right.concretize1(inAspect, bindings));
+		return new AndPointcut(left.concretize(inAspect, bindings),
+								right.concretize(inAspect, bindings));
 	}
 
 	public Pointcut getLeft() {
diff --git a/weaver/src/org/aspectj/weaver/patterns/ExactTypePattern.java b/weaver/src/org/aspectj/weaver/patterns/ExactTypePattern.java
index ef5929888..1da25d363 100644
--- a/weaver/src/org/aspectj/weaver/patterns/ExactTypePattern.java
+++ b/weaver/src/org/aspectj/weaver/patterns/ExactTypePattern.java
@@ -73,7 +73,7 @@ public class ExactTypePattern extends TypePattern {
 
     public String toString() {
     	//Thread.currentThread().dumpStack();
-    	return "ExactTypePattern(" + type.toString() + (includeSubtypes ? "+" : "") + ")";
+    	return type.toString() + (includeSubtypes ? "+" : "");
     }
 	public TypePattern resolveBindings(IScope scope, Bindings bindings, 
     								boolean allowBinding, boolean requireExactType)
diff --git a/weaver/src/org/aspectj/weaver/patterns/KindedPointcut.java b/weaver/src/org/aspectj/weaver/patterns/KindedPointcut.java
index 8be3671f0..1dca9d036 100644
--- a/weaver/src/org/aspectj/weaver/patterns/KindedPointcut.java
+++ b/weaver/src/org/aspectj/weaver/patterns/KindedPointcut.java
@@ -13,23 +13,43 @@
 
 package org.aspectj.weaver.patterns;
 
-import java.io.*;
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.IOException;
 
+import org.aspectj.bridge.ISourceLocation;
 import org.aspectj.util.FuzzyBoolean;
-import org.aspectj.weaver.*;
+import org.aspectj.weaver.Checker;
+import org.aspectj.weaver.ISourceContext;
+import org.aspectj.weaver.IntMap;
+import org.aspectj.weaver.ResolvedTypeX;
+import org.aspectj.weaver.Shadow;
+import org.aspectj.weaver.ShadowMunger;
+import org.aspectj.weaver.TypeX;
+import org.aspectj.weaver.World;
 import org.aspectj.weaver.ast.Literal;
 import org.aspectj.weaver.ast.Test;
 
 public class KindedPointcut extends Pointcut {
 	Shadow.Kind kind;
 	SignaturePattern signature;
+    
+    private ShadowMunger munger = null; // only set after concretization
 
-	public KindedPointcut(
-		Shadow.Kind kind,
-		SignaturePattern signature) {
-		this.kind = kind;
-		this.signature = signature;
-	}
+    public KindedPointcut(
+        Shadow.Kind kind,
+        SignaturePattern signature) {
+        this.kind = kind;
+        this.signature = signature;
+    }
+    public KindedPointcut(
+        Shadow.Kind kind,
+        SignaturePattern signature,
+        ShadowMunger munger)
+    {
+        this(kind, signature);
+        this.munger = munger;
+    }
 	
     public FuzzyBoolean fastMatch(ResolvedTypeX type) {
 		return FuzzyBoolean.MAYBE;
@@ -37,11 +57,70 @@ public class KindedPointcut extends Pointcut {
 	public FuzzyBoolean match(Shadow shadow) {
 		if (shadow.getKind() != kind) return FuzzyBoolean.NO;
 		
-		if (!signature.matches(shadow.getSignature(), shadow.getIWorld())) return  FuzzyBoolean.NO;
+		if (!signature.matches(shadow.getSignature(), shadow.getIWorld())){
+            if(kind == Shadow.MethodCall) {
+                warnOnConfusingSig(shadow);
+            }
+            return  FuzzyBoolean.NO; 
+        }
 
 		return  FuzzyBoolean.YES;
 	}
 	
+	private void warnOnConfusingSig(Shadow shadow) {
+        // no warnings for declare error/warning
+        if (munger instanceof Checker) return;
+        
+        World world = shadow.getIWorld();
+        
+		// warning never needed if the declaring type is any
+		TypeX exactDeclaringType = signature.getDeclaringType().getExactType();
+        
+		ResolvedTypeX shadowDeclaringType =
+			shadow.getSignature().getDeclaringType().resolve(world);
+        
+		if (signature.getDeclaringType().isStar()
+			|| exactDeclaringType== ResolvedTypeX.MISSING)
+			return;
+
+        // warning not needed if match type couldn't ever be the declaring type
+		if (!shadowDeclaringType.isAssignableFrom(exactDeclaringType)) {
+            return;
+		}
+
+		// if the method in the declaring type is *not* visible to the
+		// exact declaring type then warning not needed.
+		int shadowModifiers = shadow.getSignature().getModifiers(world);
+		if (!ResolvedTypeX
+			.isVisible(
+				shadowModifiers,
+				shadowDeclaringType,
+				exactDeclaringType.resolve(world))) {
+			return;
+		}
+
+		SignaturePattern nonConfusingPattern =
+			new SignaturePattern(
+				signature.getKind(),
+				signature.getModifiers(),
+				signature.getReturnType(),
+				TypePattern.ANY,
+				signature.getName(), 
+				signature.getParameterTypes(),
+				signature.getThrowsPattern());
+
+		if (nonConfusingPattern
+			.matches(shadow.getSignature(), shadow.getIWorld())) {
+                shadow.getIWorld().getLint().unmatchedSuperTypeInCall.signal(
+                    new String[] {
+                        shadow.getSignature().getDeclaringType().toString(),
+                        signature.getDeclaringType().toString()
+                    },
+                    this.getSourceLocation(),
+                    new ISourceLocation[] {shadow.getSourceLocation()} );               
+		}
+	}
+
 	public boolean equals(Object other) {
 		if (!(other instanceof KindedPointcut)) return false;
 		KindedPointcut o = (KindedPointcut)other;
@@ -102,7 +181,9 @@ public class KindedPointcut extends Pointcut {
 	}
 	
 	public Pointcut concretize1(ResolvedTypeX inAspect, IntMap bindings) {
-		return new KindedPointcut(kind, signature);
+		Pointcut ret = new KindedPointcut(kind, signature, bindings.getEnclosingAdvice());
+        ret.copyLocationFrom(this);
+        return ret;
 	}
 
 	public Shadow.Kind getKind() {
diff --git a/weaver/src/org/aspectj/weaver/patterns/NotPointcut.java b/weaver/src/org/aspectj/weaver/patterns/NotPointcut.java
index d10eea34f..02884b22c 100644
--- a/weaver/src/org/aspectj/weaver/patterns/NotPointcut.java
+++ b/weaver/src/org/aspectj/weaver/patterns/NotPointcut.java
@@ -91,7 +91,7 @@ public class NotPointcut extends Pointcut {
 	}
 	
 	public Pointcut concretize1(ResolvedTypeX inAspect, IntMap bindings) {
-		return new NotPointcut(body.concretize1(inAspect, bindings));
+		return new NotPointcut(body.concretize(inAspect, bindings));
 	}
 
 }
diff --git a/weaver/src/org/aspectj/weaver/patterns/OrPointcut.java b/weaver/src/org/aspectj/weaver/patterns/OrPointcut.java
index 1e6c2b378..9e4eae4fb 100644
--- a/weaver/src/org/aspectj/weaver/patterns/OrPointcut.java
+++ b/weaver/src/org/aspectj/weaver/patterns/OrPointcut.java
@@ -88,8 +88,8 @@ public class OrPointcut extends Pointcut {
 	}
 	
 	public Pointcut concretize1(ResolvedTypeX inAspect, IntMap bindings) {
-		return new OrPointcut(left.concretize1(inAspect, bindings),
-								right.concretize1(inAspect, bindings));
+		return new OrPointcut(left.concretize(inAspect, bindings),
+								right.concretize(inAspect, bindings));
 	}
 	
 	public Pointcut getLeft() {
diff --git a/weaver/src/org/aspectj/weaver/patterns/Pointcut.java b/weaver/src/org/aspectj/weaver/patterns/Pointcut.java
index 0e1e2ba91..126a43b84 100644
--- a/weaver/src/org/aspectj/weaver/patterns/Pointcut.java
+++ b/weaver/src/org/aspectj/weaver/patterns/Pointcut.java
@@ -122,13 +122,19 @@ public abstract class Pointcut extends PatternNode {
 	
 	
 	public Pointcut concretize(ResolvedTypeX inAspect, IntMap bindings) {
-		assertState(RESOLVED);
+		//!!! add this test -- assertState(RESOLVED);
 		Pointcut ret = this.concretize1(inAspect, bindings);
+        if (shouldCopyLocationForConcretize()) ret.copyLocationFrom(this);
 		ret.state = CONCRETE;
 		return ret;
 	}
 	
 	
+	protected boolean shouldCopyLocationForConcretize() {
+		return true;
+	}
+
+
 	/**
 	 * Resolves and removes ReferencePointcuts, replacing with basic ones
 	 * 
diff --git a/weaver/src/org/aspectj/weaver/patterns/ReferencePointcut.java b/weaver/src/org/aspectj/weaver/patterns/ReferencePointcut.java
index 1b9848ccf..e73e24e82 100644
--- a/weaver/src/org/aspectj/weaver/patterns/ReferencePointcut.java
+++ b/weaver/src/org/aspectj/weaver/patterns/ReferencePointcut.java
@@ -271,7 +271,7 @@ public class ReferencePointcut extends Pointcut {
 			newBindings.copyContext(bindings);
 			newBindings.pushEnclosingDefinition(pointcutDec);
 			try {
-				return pointcutDec.getPointcut().concretize1(searchStart, newBindings);
+				return pointcutDec.getPointcut().concretize(searchStart, newBindings);
 			} finally {
 				newBindings.popEnclosingDefinitition();
 			}
@@ -280,6 +280,11 @@ public class ReferencePointcut extends Pointcut {
 			concretizing = false;
 		}
 	}
+    
+    // We want to keep the original source location, not the reference location
+    protected boolean shouldCopyLocationForConcretize() {
+        return false;
+    }
 
     public boolean equals(Object other) { 
         if (!(other instanceof ReferencePointcut)) return false;
diff --git a/weaver/src/org/aspectj/weaver/patterns/SignaturePattern.java b/weaver/src/org/aspectj/weaver/patterns/SignaturePattern.java
index d6db93f10..64a3f66b7 100644
--- a/weaver/src/org/aspectj/weaver/patterns/SignaturePattern.java
+++ b/weaver/src/org/aspectj/weaver/patterns/SignaturePattern.java
@@ -238,4 +238,32 @@ public class SignaturePattern extends PatternNode {
 		return ret;
 	}
 
+	/**
+	 * @return
+	 */
+	public ModifiersPattern getModifiers() {
+		return modifiers;
+	}
+
+	/**
+	 * @return
+	 */
+	public TypePatternList getParameterTypes() {
+		return parameterTypes;
+	}
+
+	/**
+	 * @return
+	 */
+	public TypePattern getReturnType() {
+		return returnType;
+	}
+
+	/**
+	 * @return
+	 */
+	public ThrowsPattern getThrowsPattern() {
+		return throwsPattern;
+	}
+
 }