### Eclipse Workspace Patch 1.0
#P org.eclipse.jdt.core.tests.model
Index: src/org/eclipse/jdt/core/tests/model/JavaSearchBugsTests.java
===================================================================
RCS file: /cvsroot/eclipse/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/model/JavaSearchBugsTests.java,v
retrieving revision 1.53
diff -u -r1.53 JavaSearchBugsTests.java
--- src/org/eclipse/jdt/core/tests/model/JavaSearchBugsTests.java	4 Nov 2005 15:21:02 -0000	1.53
+++ src/org/eclipse/jdt/core/tests/model/JavaSearchBugsTests.java	23 Nov 2005 17:11:38 -0000
@@ -44,17 +44,45 @@
 static {
 //	org.eclipse.jdt.internal.core.search.BasicSearchEngine.VERBOSE = true;
 //	org.eclipse.jdt.internal.codeassist.SelectionEngine.DEBUG = true;
-//	TESTS_PREFIX =  "testBug110060";
-//	TESTS_NAMES = new String[] { "testBug113671" };
-//	TESTS_NUMBERS = new int[] { 114539 };
+//	TESTS_PREFIX =  "testBug110336";
+//	TESTS_NAMES = new String[] { "testBug110336e" };
+//	TESTS_NUMBERS = new int[] { 79267 };
 //	TESTS_RANGE = new int[] { 83304, -1 };
 	}
 
 class TestCollector extends JavaSearchResultCollector {
 	public List matches = new ArrayList();
-	public void acceptSearchMatch(SearchMatch match) throws CoreException {
-		super.acceptSearchMatch(match);
-		matches.add(match);
+	public void acceptSearchMatch(SearchMatch searchMatch) throws CoreException {
+		super.acceptSearchMatch(searchMatch);
+		matches.add(searchMatch);
+	}
+}
+class TypeReferencesCollector extends JavaSearchResultCollector {
+
+	protected IJavaElement getElement(SearchMatch searchMatch) {
+		IJavaElement element = super.getElement(searchMatch);
+		IJavaElement localElement = null;
+		TypeReferenceMatch typeRefMatch = (TypeReferenceMatch) match;
+		localElement = typeRefMatch.getLocalElement();
+		if (localElement != null) {
+			return localElement;
+		}
+		return element;
+	}
+	protected void writeLine() throws CoreException {
+		super.writeLine();
+		TypeReferenceMatch typeRefMatch = (TypeReferenceMatch) this.match;
+		IJavaElement[] others = typeRefMatch.getOtherElements();
+		int length = others==null ? 0 : others.length;
+		if (length > 0) {
+			line.append("+[");
+			for (int i=0; i<length; i++) {
+				IJavaElement other = others[i];
+				if (i>0) line.append(',');
+				line.append(other.getElementName());
+			}
+			line.append(']');
+		}
 	}
 }
 
@@ -5268,7 +5296,6 @@
  * @test Bug 114539: [search] Internal error when refactoring code with errors
  * @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=114539"
  */
-// Types search
 public void testBug114539() throws CoreException {
 	workingCopies = new ICompilationUnit[2];
 	workingCopies[0] = getWorkingCopy("/JavaSearchBugs/src/b114539/Foo.java",
@@ -5285,9 +5312,163 @@
 	);
 	IField field = this.workingCopies[1].getType("Bar").getField("FOO");
 	search(field, REFERENCES);
-	this.discard = false;
 	assertSearchResults(
 		"src/b114539/Foo.java b114539.Foo.bar [FOO] POTENTIAL_MATCH"
 	);
 }
+
+/**
+ * @test Bug 110336: [plan][search] Should optionaly return the local variable for type reference
+ * @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=110336"
+ */
+public void testBug110336a() throws CoreException {
+	workingCopies = new ICompilationUnit[1];
+	workingCopies[0] = getWorkingCopy("/JavaSearchBugs/src/b110336/Test.java",
+		"package b110336;\n" + 
+		"public class Test {\n" + 
+		"	<TP extends Test> void method(Class<Test> clazz) {\n" + 
+		"		Test localVar1 = new Test();\n" + 
+		"		Class<Test> localVar2 = new Class<Test>();\n" + 
+		"		localVar1.method(localVar2);\n" + 
+		"	}\n" + 
+		"}\n"
+	);
+	IType type = this.workingCopies[0].getType("Test");
+	TypeReferencesCollector collector = new TypeReferencesCollector();
+	search(type, REFERENCES, EXACT_RULE, getJavaSearchScopeBugs(), collector);
+	assertSearchResults(
+		"src/b110336/Test.java void b110336.Test.method(Class<Test>).TP [Test]\n" + 
+		"src/b110336/Test.java void b110336.Test.method(Class<Test>).clazz [Test]\n" + 
+		"src/b110336/Test.java void b110336.Test.method(Class<Test>).localVar1 [Test]\n" + 
+		"src/b110336/Test.java void b110336.Test.method(Class<Test>).localVar1 [Test]\n" + 
+		"src/b110336/Test.java void b110336.Test.method(Class<Test>).localVar2 [Test]\n" + 
+		"src/b110336/Test.java void b110336.Test.method(Class<Test>).localVar2 [Test]",
+		collector
+	);
+}
+public void testBug110336b() throws CoreException {
+	workingCopies = new ICompilationUnit[1];
+	workingCopies[0] = getWorkingCopy("/JavaSearchBugs/src/b110336/Test.java",
+		"package b110336;\n" + 
+		"public class Test {\n" + 
+		"	void method1(Test methodParam) {\n" + 
+		"		Test localVar1 = new Test(){\n" + 
+		"			Class c = Test.class;\n" + 
+		"			<TP extends Test> void foo(){\n" + 
+		"				Test o = (Test) null;\n" + 
+		"			}\n" + 
+		"		};\n" + 
+		"	}	\n" + 
+		"}\n"
+	);
+	IType type = this.workingCopies[0].getType("Test");
+	TypeReferencesCollector collector = new TypeReferencesCollector();
+	search(type, REFERENCES, EXACT_RULE, getJavaSearchScopeBugs(), collector);
+	assertSearchResults(
+		"src/b110336/Test.java void b110336.Test.method1(Test):<anonymous>#1 [Test]\n" + 
+		"src/b110336/Test.java void b110336.Test.method1(Test):<anonymous>#1.c [Test]\n" + 
+		"src/b110336/Test.java void void b110336.Test.method1(Test):<anonymous>#1.foo().TP [Test]\n" + 
+		"src/b110336/Test.java void void b110336.Test.method1(Test):<anonymous>#1.foo().o [Test]\n" + 
+		"src/b110336/Test.java void void b110336.Test.method1(Test):<anonymous>#1.foo().o [Test]\n" + 
+		"src/b110336/Test.java void b110336.Test.method1(Test).methodParam [Test]\n" + 
+		"src/b110336/Test.java void b110336.Test.method1(Test).localVar1 [Test]",
+		collector
+	);
+}
+public void testBug110336c() throws CoreException {
+	workingCopies = new ICompilationUnit[1];
+	workingCopies[0] = getWorkingCopy("/JavaSearchBugs/src/b110336/Test.java",
+		"package b110336;\n" + 
+		"public class Test<TP extends X> {\n" + 
+		"	X x;\n" + 
+		"\n" + 
+		"}\n" + 
+		"class X {}\n"
+	);
+	IType type = this.workingCopies[0].getType("X");
+	TypeReferencesCollector collector = new TypeReferencesCollector();
+	search(type, REFERENCES, EXACT_RULE, getJavaSearchScopeBugs(), collector);
+	assertSearchResults(
+		"src/b110336/Test.java b110336.Test.TP [X]\n" + 
+		"src/b110336/Test.java b110336.Test.x [X]",
+		collector
+	);
+}
+public void testBug110336d() throws CoreException {
+	workingCopies = new ICompilationUnit[1];
+	workingCopies[0] = getWorkingCopy("/JavaSearchBugs/src/b110336/Test.java",
+		"package b110336;\n" + 
+		"public class Test {\n" + 
+		"	Test a1Test = null, b1Test = new Test(), c1Test;\n" + 
+		"	Test a2Test = new Test(), b2Test, c2Test = null;\n" + 
+		"	Test a3Test, b3Test = null, c3Test = new Test();\n" + 
+		"}\n"
+	);
+	IType type = this.workingCopies[0].getType("Test");
+	TypeReferencesCollector collector = new TypeReferencesCollector();
+	search(type, REFERENCES, EXACT_RULE, getJavaSearchScopeBugs(), collector);
+	assertSearchResults(
+		"src/b110336/Test.java b110336.Test.a1Test [Test]+[b1Test,c1Test]\n" + 
+		"src/b110336/Test.java b110336.Test.b1Test [Test]\n" + 
+		"src/b110336/Test.java b110336.Test.a2Test [Test]+[b2Test,c2Test]\n" + 
+		"src/b110336/Test.java b110336.Test.a2Test [Test]\n" + 
+		"src/b110336/Test.java b110336.Test.a3Test [Test]+[b3Test,c3Test]\n" + 
+		"src/b110336/Test.java b110336.Test.c3Test [Test]",
+		collector
+	);
+}
+public void testBug110336e() throws CoreException {
+	workingCopies = new ICompilationUnit[1];
+	workingCopies[0] = getWorkingCopy("/JavaSearchBugs/src/b110336/Test.java",
+		"package b110336;\n" + 
+		"public class Test {\n" + 
+		"	void foo() {\n" + 
+		"		Test lv1 = null, lv2 = new Test(), lv3;\n" + 
+		"		Test lv4 = new Test(), lv5, lv6 = null;\n" + 
+		"		Test lv7, lv8 = null, lv9 = new Test();\n" + 
+		"	}\n" + 
+		"}\n"
+	);
+	IType type = this.workingCopies[0].getType("Test");
+	TypeReferencesCollector collector = new TypeReferencesCollector();
+	search(type, REFERENCES, EXACT_RULE, getJavaSearchScopeBugs(), collector);
+	assertSearchResults(
+		"src/b110336/Test.java void b110336.Test.foo().lv1 [Test]+[lv2,lv3]\n" + 
+		"src/b110336/Test.java void b110336.Test.foo().lv2 [Test]\n" + 
+		"src/b110336/Test.java void b110336.Test.foo().lv4 [Test]+[lv5,lv6]\n" + 
+		"src/b110336/Test.java void b110336.Test.foo().lv4 [Test]\n" + 
+		"src/b110336/Test.java void b110336.Test.foo().lv7 [Test]+[lv8,lv9]\n" + 
+		"src/b110336/Test.java void b110336.Test.foo().lv9 [Test]",
+		collector
+	);
+}
+public void testBug110336f() throws CoreException {
+	workingCopies = new ICompilationUnit[1];
+	workingCopies[0] = getWorkingCopy("/JavaSearchBugs/src/b110336/Test.java",
+		"package b110336;\n" + 
+		"public class Test extends Exception {\n" + 
+		"        void foo(Test test1) { // <- no local element\n" + 
+		"                Test test2; // <- local element\n" + 
+		"                try {\n" + 
+		"                        throw new Test();\n" + 
+		"                }\n" + 
+		"                catch (Test test4) { // <- no local element\n" + 
+		"                }\n" + 
+		"                for(Test test3;;) {} // <- local element\n" + 
+		"        }\n" + 
+		"\n" + 
+		"}\n"
+	);
+	IType type = this.workingCopies[0].getType("Test");
+	TypeReferencesCollector collector = new TypeReferencesCollector();
+	search(type, REFERENCES, EXACT_RULE, getJavaSearchScopeBugs(), collector);
+	assertSearchResults(
+		"src/b110336/Test.java void b110336.Test.foo(Test).test1 [Test]\n" + 
+		"src/b110336/Test.java void b110336.Test.foo(Test).test2 [Test]\n" + 
+		"src/b110336/Test.java void b110336.Test.foo(Test) [Test]\n" + 
+		"src/b110336/Test.java void b110336.Test.foo(Test).test4 [Test]\n" + 
+		"src/b110336/Test.java void b110336.Test.foo(Test).test3 [Test]",
+		collector
+	);
+}
 }
Index: src/org/eclipse/jdt/core/tests/model/JavaSearchTests.java
===================================================================
RCS file: /cvsroot/eclipse/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/model/JavaSearchTests.java,v
retrieving revision 1.143
diff -u -r1.143 JavaSearchTests.java
--- src/org/eclipse/jdt/core/tests/model/JavaSearchTests.java	26 Oct 2005 18:01:00 -0000	1.143
+++ src/org/eclipse/jdt/core/tests/model/JavaSearchTests.java	23 Nov 2005 17:11:40 -0000
@@ -40,7 +40,7 @@
 static {
 //	org.eclipse.jdt.internal.core.search.BasicSearchEngine.VERBOSE = true;
 //	TESTS_PREFIX =  "testCamelCase";
-//	TESTS_NAMES = new String[] { "testMethodDeclaration11" };
+	TESTS_NAMES = new String[] { "testTypeReference11" };
 //	TESTS_NUMBERS = new int[] { 113671 };
 //	TESTS_RANGE = new int[] { 16, -1 };
 }
Index: src/org/eclipse/jdt/core/tests/model/AbstractJavaSearchTests.java
===================================================================
RCS file: /cvsroot/eclipse/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/model/AbstractJavaSearchTests.java,v
retrieving revision 1.14
diff -u -r1.14 AbstractJavaSearchTests.java
--- src/org/eclipse/jdt/core/tests/model/AbstractJavaSearchTests.java	26 Oct 2005 18:00:59 -0000	1.14
+++ src/org/eclipse/jdt/core/tests/model/AbstractJavaSearchTests.java	23 Nov 2005 17:11:34 -0000
@@ -45,6 +45,7 @@
 	 * Collects results as a string.
 	 */
 	public static class JavaSearchResultCollector extends SearchRequestor {
+		protected SearchMatch match;
 		public StringBuffer results = new StringBuffer(), line;
 		public boolean showAccuracy;
 		public boolean showContext;
@@ -54,11 +55,22 @@
 		public boolean showProject;
 		public boolean showSynthetic;
 		public int count = 0;
-		public void acceptSearchMatch(SearchMatch match) throws CoreException {
+		public void acceptSearchMatch(SearchMatch searchMatch) throws CoreException {
 			count++;
+			this.match = searchMatch;
+			writeLine();
+			writeLineToResult();
+		}
+		protected void writeLineToResult() {
+			if (match.getAccuracy() == SearchMatch.A_ACCURATE || showPotential) {
+				if (results.length() > 0) results.append("\n");
+				results.append(line);
+			}
+		}
+		protected void writeLine() throws CoreException {
 			try {
 				IResource resource = match.getResource();
-				IJavaElement element = (IJavaElement) match.getElement();
+				IJavaElement element = getElement(match);
 				line = new StringBuffer(getPathString(resource, element));
 				if (this.showProject) {
 					IProject project = element.getJavaProject().getProject();
@@ -104,6 +116,24 @@
 					line.append(".");
 					line.append(localVar.getElementName());
 					unit = (ICompilationUnit)localVar.getAncestor(IJavaElement.COMPILATION_UNIT);
+				} else if (element instanceof ITypeParameter) {
+					line.append(" ");
+					ITypeParameter typeParam = (ITypeParameter)element;
+					IJavaElement parent = typeParam.getParent();
+					if (parent instanceof IType) {
+						IType type = (IType)parent;
+						append(type);
+						unit = type.getCompilationUnit();
+					} else if (parent instanceof IMethod) {
+						IMethod method = (IMethod)parent;
+						append(method);
+						unit = method.getCompilationUnit();
+					} else {
+						line.append("<Unexpected kind of parent for type parameter>");
+						unit = (ICompilationUnit)typeParam.getAncestor(IJavaElement.COMPILATION_UNIT);
+					}
+					line.append(".");
+					line.append(typeParam.getElementName());
 				} else if (element instanceof IImportDeclaration) {
 					IImportDeclaration importDeclaration = (IImportDeclaration)element;
 					unit = (ICompilationUnit)importDeclaration.getAncestor(IJavaElement.COMPILATION_UNIT);
@@ -180,16 +210,12 @@
 						}
 					}
 				}
-				if (match.getAccuracy() == SearchMatch.A_ACCURATE || showPotential) {
-					if (results.length() > 0) results.append("\n");
-					results.append(line);
-				}
 			} catch (JavaModelException e) {
 				results.append("\n");
 				results.append(e.toString());
 			}
 		}
-		private void append(IField field) throws JavaModelException {
+		protected void append(IField field) throws JavaModelException {
 			append(field.getDeclaringType());
 			line.append(".");
 			line.append(field.getElementName());
@@ -288,6 +314,9 @@
 				line.append(((SourceRefElement)type).occurrenceCount);
 			}
 		}
+		protected IJavaElement getElement(SearchMatch searchMatch) {
+			return (IJavaElement) searchMatch.getElement();
+		}
 		protected String getPathString(IResource resource, IJavaElement element) {
 			String pathString;
 			if (resource != null) {
#P org.eclipse.jdt.core
Index: search/org/eclipse/jdt/internal/core/search/matching/MatchLocator.java
===================================================================
RCS file: /cvsroot/eclipse/org.eclipse.jdt.core/search/org/eclipse/jdt/internal/core/search/matching/MatchLocator.java,v
retrieving revision 1.255
diff -u -r1.255 MatchLocator.java
--- search/org/eclipse/jdt/internal/core/search/matching/MatchLocator.java	17 Nov 2005 11:08:57 -0000	1.255
+++ search/org/eclipse/jdt/internal/core/search/matching/MatchLocator.java	23 Nov 2005 17:11:45 -0000
@@ -61,6 +61,7 @@
 import org.eclipse.jdt.internal.core.JavaElement;
 import org.eclipse.jdt.internal.core.JavaModelManager;
 import org.eclipse.jdt.internal.core.JavaProject;
+import org.eclipse.jdt.internal.core.LocalVariable;
 import org.eclipse.jdt.internal.core.NameLookup;
 import org.eclipse.jdt.internal.core.Openable;
 import org.eclipse.jdt.internal.core.PackageFragment;
@@ -165,7 +166,6 @@
 	}
 }
 
-
 public static class WorkingCopyDocument extends JavaSearchDocument {
 	public org.eclipse.jdt.core.ICompilationUnit workingCopy;
 	WorkingCopyDocument(org.eclipse.jdt.core.ICompilationUnit workingCopy, SearchParticipant participant) {
@@ -562,6 +562,34 @@
 	}
 	return ((IType) parent).getInitializer(occurrenceCount);
 }
+/**
+ * Create an handle for a local variable declartion (may be a local variable or type parameter).
+ */
+protected IJavaElement createHandle(AbstractVariableDeclaration variableDeclaration, IJavaElement parent) {
+	switch (variableDeclaration.getKind()) {
+		case AbstractVariableDeclaration.LOCAL_VARIABLE:
+			return new LocalVariable((JavaElement)parent,
+				new String(variableDeclaration.name),
+				variableDeclaration.declarationSourceStart,
+				variableDeclaration.declarationSourceEnd,
+				variableDeclaration.sourceStart,
+				variableDeclaration.sourceEnd,
+				new String(variableDeclaration.type.resolvedType.signature())
+			);
+		case AbstractVariableDeclaration.PARAMETER:
+			return new LocalVariable((JavaElement)parent,
+				new String(variableDeclaration.name),
+				variableDeclaration.declarationSourceStart,
+				variableDeclaration.declarationSourceEnd,
+				variableDeclaration.sourceStart,
+				variableDeclaration.sourceEnd,
+				new String(variableDeclaration.type.resolvedType.signature())
+			);
+		case AbstractVariableDeclaration.TYPE_PARAMETER:
+			return new org.eclipse.jdt.internal.core.TypeParameter((JavaElement)parent, new String(variableDeclaration.name));
+	}
+	return null;
+}
 /*
  * Creates hierarchy resolver if needed. 
  * Returns whether focus is visible.
@@ -1364,7 +1392,7 @@
 	return new TypeParameterReferenceMatch(enclosingElement, accuracy, offset, length, insideDocComment, participant, resource);
 }
 
-public SearchMatch newTypeReferenceMatch(
+public TypeReferenceMatch newTypeReferenceMatch(
 		IJavaElement enclosingElement,
 		Binding enclosingBinding,
 		int accuracy,
@@ -1379,7 +1407,7 @@
 	return new TypeReferenceMatch(enclosingElement, accuracy, offset, length, insideDocComment, participant, resource);
 }
 
-public SearchMatch newTypeReferenceMatch(
+public TypeReferenceMatch newTypeReferenceMatch(
 		IJavaElement enclosingElement,
 		Binding enclosingBinding,
 		int accuracy,
@@ -1541,6 +1569,26 @@
 		} catch (Exception e) {
 			// it's just for debug purposes... ignore all exceptions in this area
 		}
+		if (match instanceof TypeReferenceMatch) {
+			try {
+				TypeReferenceMatch typeRefMatch = (TypeReferenceMatch) match;
+				JavaElement local = (JavaElement) typeRefMatch.getLocalElement();
+				if (local != null) {
+					System.out.println("\tLocal element: "+ local.toStringWithAncestors()); //$NON-NLS-1$
+				}
+				IJavaElement[] others = typeRefMatch.getOtherElements();
+				int length = others==null ? 0 : others.length;
+				if (length > 0) {
+					System.out.println("\tOther elements:"); //$NON-NLS-1$
+					for (int i=0; i<length; i++) {
+						JavaElement other = (JavaElement) others[i];
+						System.out.println("\t\t- "+ other.toStringWithAncestors()); //$NON-NLS-1$
+					}
+				}
+			} catch (Exception e) {
+				// it's just for debug purposes... ignore all exceptions in this area
+			}
+		}
 		System.out.println(match.getAccuracy() == SearchMatch.A_ACCURATE
 			? "\tAccuracy: EXACT_MATCH" //$NON-NLS-1$
 			: "\tAccuracy: POTENTIAL_MATCH"); //$NON-NLS-1$
@@ -1848,6 +1896,15 @@
 		}
 	}
 
+	// report the type parameters
+	TypeParameter[] typeParameters = method.typeParameters();
+	if (typeParameters != null) {
+		if (enclosingElement == null) {
+			enclosingElement = createHandle(method, parent);
+		}
+		reportMatching(typeParameters, enclosingElement, parent, method.binding, nodeSet);
+	}
+
 	// report annotations
 	if (method.annotations != null) {
 		if (enclosingElement == null) {
@@ -1867,7 +1924,7 @@
 					for (int i = 0, l = nodes.length; i < l; i++) {
 						ASTNode node = nodes[i];
 						Integer level = (Integer) nodeSet.matchingNodes.removeKey(node);
-						this.patternLocator.matchReportReference(node, enclosingElement, method.binding, level.intValue(), this);
+						this.patternLocator.matchReportReference(node, enclosingElement, method.binding, method.scope, level.intValue(), this);
 					}
 					return;
 				}
@@ -2033,7 +2090,7 @@
  * Visit the given field declaration and report the nodes that match exactly the
  * search pattern (ie. the ones in the matching nodes set)
  */
-protected void reportMatching(FieldDeclaration field, TypeDeclaration type, IJavaElement parent, int accuracy, boolean typeInHierarchy, MatchingNodeSet nodeSet) throws CoreException {
+protected void reportMatching(FieldDeclaration field, TypeDeclaration type, IJavaElement parent, IJavaElement[] otherElements, int accuracy, boolean typeInHierarchy, MatchingNodeSet nodeSet) throws CoreException {
 	IJavaElement enclosingElement = null;
 	if (accuracy > -1) {
 		enclosingElement = createHandle(field, type, parent);
@@ -2065,17 +2122,39 @@
 	}
 
 	if (typeInHierarchy) {
-		// limit scan to end part position for multiple fields declaration (see bug 73112)
-		int end = field.endPart2Position==0 ? field.declarationSourceEnd : field.endPart2Position;
-		ASTNode[] nodes = nodeSet.matchingNodes(field.declarationSourceStart, end);
+		// Look at field declaration
+		if (field.endPart1Position != 0) { // not an initializer
+			ASTNode[] nodes = nodeSet.matchingNodes(field.declarationSourceStart, field.endPart1Position);
+			if (nodes != null) {
+				if ((this.matchContainer & PatternLocator.FIELD_CONTAINER) == 0) {
+					for (int i = 0, l = nodes.length; i < l; i++)
+						nodeSet.matchingNodes.removeKey(nodes[i]);
+				} else {
+					if (enclosingElement == null)
+						enclosingElement = createHandle(field, type, parent);
+					if (encloses(enclosingElement)) {
+						for (int i = 0, l = nodes.length; i < l; i++) {
+							ASTNode node = nodes[i];
+							Integer level = (Integer) nodeSet.matchingNodes.removeKey(node);
+							this.patternLocator.matchReportReference(node, enclosingElement, null, otherElements, field.binding, level.intValue(), this);
+						}
+					}
+				}
+			}
+		}
+
+		// Look in initializers
+		int fieldEnd = field.endPart2Position == 0 ? field.declarationSourceEnd : field.endPart2Position;
+		ASTNode[] nodes = nodeSet.matchingNodes(field.sourceStart, fieldEnd);
 		if (nodes != null) {
 			if ((this.matchContainer & PatternLocator.FIELD_CONTAINER) == 0) {
 				for (int i = 0, l = nodes.length; i < l; i++)
 					nodeSet.matchingNodes.removeKey(nodes[i]);
 			} else {
-				if (enclosingElement == null)
+				if (enclosingElement == null) {
 					enclosingElement = createHandle(field, type, parent);
-				if (encloses(enclosingElement))
+				}
+				if (encloses(enclosingElement)) {
 					for (int i = 0, l = nodes.length; i < l; i++) {
 						ASTNode node = nodes[i];
 						Integer level = (Integer) nodeSet.matchingNodes.removeKey(node);
@@ -2088,6 +2167,7 @@
 						}
 						this.patternLocator.matchReportReference(node, enclosingElement, field.binding, level.intValue(), this);
 					}
+				}
 			}
 		}
 	}
@@ -2121,36 +2201,10 @@
 	}
 
 	boolean matchedClassContainer = (this.matchContainer & PatternLocator.CLASS_CONTAINER) != 0;
-	
+
 	// report the type parameters
 	if (type.typeParameters != null) {
-		for (int i=0, l=type.typeParameters.length; i<l; i++) {
-			TypeParameter typeParameter = type.typeParameters[i];
-			if (typeParameter != null) {
-				Integer level = (Integer) nodeSet.matchingNodes.removeKey(typeParameter);
-				if (level != null && matchedClassContainer) {
-					if (level.intValue() > -1 && enclosesElement) {
-						int offset = typeParameter.sourceStart;
-						SearchMatch match = this.patternLocator.newDeclarationMatch(typeParameter, enclosingElement, type.binding, level.intValue(), typeParameter.sourceEnd-offset+1, this);
-						report(match);
-					}
-				}
-				if (typeParameter.type != null) {
-					level = (Integer) nodeSet.matchingNodes.removeKey(typeParameter.type);
-					if (level != null && matchedClassContainer) {
-						this.patternLocator.matchReportReference(typeParameter.type, enclosingElement, type.binding, level.intValue(), this);
-					}
-				}
-				if (typeParameter.bounds != null) {
-					for (int j=0, b=typeParameter.bounds.length; j<b; j++) {
-						level = (Integer) nodeSet.matchingNodes.removeKey(typeParameter.bounds[j]);
-						if (level != null && matchedClassContainer) {
-							this.patternLocator.matchReportReference(typeParameter.bounds[j], enclosingElement, type.binding, level.intValue(), this);
-						}
-					}
-				}
-			}
-		}
+		reportMatching(type.typeParameters, enclosingElement, parent, type.binding, nodeSet);
 	}
 
 	// report annotations
@@ -2202,20 +2256,56 @@
 	boolean typeInHierarchy = type.binding == null || typeInHierarchy(type.binding);
 	matchedClassContainer = matchedClassContainer && typeInHierarchy; 
 
+	// Visit fields
 	FieldDeclaration[] fields = type.fields;
 	if (fields != null) {
-		if (nodeSet.matchingNodes.elementSize == 0) return; // reported all the matching nodes
+		if (nodeSet.matchingNodes.elementSize == 0) return;	// end as all matching nodes were reported
+		IJavaElement[] otherElements = null;
+		int first = -1;
 		for (int i = 0, l = fields.length; i < l; i++) {
 			FieldDeclaration field = fields[i];
-			Integer level = (Integer) nodeSet.matchingNodes.removeKey(field);
-			int value = (level != null && matchedClassContainer) ? level.intValue() : -1;
-			reportMatching(field, type, enclosingElement, value, typeInHierarchy, nodeSet);
+			boolean last = field.endPart2Position == 0 || field.declarationEnd == field.endPart2Position;
+			// Store first index of multiple field declaration
+			if (!last) {
+				if (first == -1) {
+					first = i;
+				}
+			}
+			// Mutliple declaration fields
+			if (first >= 0) {
+				// Create handle for all multiple fields except first one as it would be returned through the match
+				if (i > first) {
+					if (otherElements == null) {
+						otherElements = new IJavaElement[] { createHandle(field, type, enclosingElement) };
+					} else {
+						int length = otherElements.length;
+						System.arraycopy(otherElements, 0, otherElements = new IJavaElement[length+1], 0, length);
+						otherElements[length] = createHandle(field, type, enclosingElement);
+					}
+				}
+				// On last field, report match with all other elements
+				if (last) {
+					for (int j=first; j<=i; j++) {
+						Integer level = (Integer) nodeSet.matchingNodes.removeKey(fields[j]);
+						int value = (level != null && matchedClassContainer) ? level.intValue() : -1;
+						reportMatching(fields[j], type, enclosingElement, otherElements, value, typeInHierarchy, nodeSet);
+					}
+					first = -1;
+					otherElements = null;
+				}
+			} else {
+				// Single field, report normally
+				Integer level = (Integer) nodeSet.matchingNodes.removeKey(field);
+				int value = (level != null && matchedClassContainer) ? level.intValue() : -1;
+				reportMatching(field, type, enclosingElement, null, value, typeInHierarchy, nodeSet);
+			}
 		}
 	}
 
+	// Visit methods
 	AbstractMethodDeclaration[] methods = type.methods;
 	if (methods != null) {
-		if (nodeSet.matchingNodes.elementSize == 0) return; // reported all the matching nodes
+		if (nodeSet.matchingNodes.elementSize == 0) return;	// end as all matching nodes were reported
 		for (int i = 0, l = methods.length; i < l; i++) {
 			AbstractMethodDeclaration method = methods[i];
 			Integer level = (Integer) nodeSet.matchingNodes.removeKey(method);
@@ -2224,10 +2314,11 @@
 		}
 	}
 
+	// Visit types
 	TypeDeclaration[] memberTypes = type.memberTypes;
 	if (memberTypes != null) {
 		for (int i = 0, l = memberTypes.length; i < l; i++) {
-			if (nodeSet.matchingNodes.elementSize == 0) return; // reported all the matching nodes
+			if (nodeSet.matchingNodes.elementSize == 0) return;	// end as all matching nodes were reported
 			TypeDeclaration memberType = memberTypes[i];
 			Integer level = (Integer) nodeSet.matchingNodes.removeKey(memberType);
 			int value = (level != null && matchedClassContainer) ? level.intValue() : -1;
@@ -2235,6 +2326,41 @@
 		}
 	}
 }
+/**
+ * Report matches in type parameters.
+ */
+protected void reportMatching(TypeParameter[] typeParameters, IJavaElement enclosingElement, IJavaElement parent, Binding binding, MatchingNodeSet nodeSet) throws CoreException {
+	if (typeParameters == null) return;
+	for (int i=0, l=typeParameters.length; i<l; i++) {
+		TypeParameter typeParameter = typeParameters[i];
+		if (typeParameter != null) {
+			Integer level = (Integer) nodeSet.matchingNodes.removeKey(typeParameter);
+			if (level != null) {
+				if (level.intValue() > -1 && encloses(enclosingElement)) {
+					int offset = typeParameter.sourceStart;
+					SearchMatch match = this.patternLocator.newDeclarationMatch(typeParameter, enclosingElement, binding, level.intValue(), typeParameter.sourceEnd-offset+1, this);
+					report(match);
+				}
+			}
+			if (typeParameter.type != null) {
+				level = (Integer) nodeSet.matchingNodes.removeKey(typeParameter.type);
+				if (level != null) {
+					IJavaElement localElement = createHandle(typeParameter, enclosingElement);
+					this.patternLocator.matchReportReference(typeParameter.type, enclosingElement, localElement, null, binding, level.intValue(), this);
+				}
+			}
+			if (typeParameter.bounds != null) {
+				for (int j=0, b=typeParameter.bounds.length; j<b; j++) {
+					level = (Integer) nodeSet.matchingNodes.removeKey(typeParameter.bounds[j]);
+					if (level != null) {
+						IJavaElement localElement = createHandle(typeParameter, enclosingElement);
+						this.patternLocator.matchReportReference(typeParameter.bounds[j], enclosingElement, localElement, null, binding, level.intValue(), this);
+					}
+				}
+			}
+		}
+	}
+}
 protected void reportMatchingSuper(TypeReference superReference, IJavaElement enclosingElement, Binding elementBinding, MatchingNodeSet nodeSet, boolean matchedClassContainer) throws CoreException {
 	ASTNode[] nodes = null;
 	if (superReference instanceof ParameterizedSingleTypeReference || superReference instanceof ParameterizedQualifiedTypeReference) {
Index: search/org/eclipse/jdt/internal/core/search/matching/PatternLocator.java
===================================================================
RCS file: /cvsroot/eclipse/org.eclipse.jdt.core/search/org/eclipse/jdt/internal/core/search/matching/PatternLocator.java,v
retrieving revision 1.51
diff -u -r1.51 PatternLocator.java
--- search/org/eclipse/jdt/internal/core/search/matching/PatternLocator.java	26 Oct 2005 18:00:43 -0000	1.51
+++ search/org/eclipse/jdt/internal/core/search/matching/PatternLocator.java	23 Nov 2005 17:11:46 -0000
@@ -391,6 +391,18 @@
 		locator.report(match);
 	}
 }
+/**
+ * Reports the match of the given reference. Also provide a local element to eventually report in match.
+ */
+protected void matchReportReference(ASTNode reference, IJavaElement element, IJavaElement localElement, IJavaElement[] otherElements, Binding elementBinding, int accuracy, MatchLocator locator) throws CoreException {
+	matchReportReference(reference, element, elementBinding, accuracy, locator);
+}
+/**
+ * Reports the match of the given reference. Also provide a scope to look for potential other elements.
+ */
+protected void matchReportReference(ASTNode reference, IJavaElement element, Binding elementBinding, Scope scope, int accuracy, MatchLocator locator) throws CoreException {
+	matchReportReference(reference, element, elementBinding, accuracy, locator);
+}
 public SearchMatch newDeclarationMatch(ASTNode reference, IJavaElement element, Binding elementBinding, int accuracy, int length, MatchLocator locator) {
     return locator.newDeclarationMatch(element, elementBinding, accuracy, reference.sourceStart, length);
 }
Index: search/org/eclipse/jdt/internal/core/search/matching/TypeReferenceLocator.java
===================================================================
RCS file: /cvsroot/eclipse/org.eclipse.jdt.core/search/org/eclipse/jdt/internal/core/search/matching/TypeReferenceLocator.java,v
retrieving revision 1.46
diff -u -r1.46 TypeReferenceLocator.java
--- search/org/eclipse/jdt/internal/core/search/matching/TypeReferenceLocator.java	18 Oct 2005 17:12:32 -0000	1.46
+++ search/org/eclipse/jdt/internal/core/search/matching/TypeReferenceLocator.java	23 Nov 2005 17:11:46 -0000
@@ -255,7 +255,13 @@
 		// TODO (frederic) need to add a test for this case while searching generic types...
 		if (locator.encloses(element)) {
 			int offset = arrayRef.sourceStart;
-			match = locator.newTypeReferenceMatch(element, elementBinding, accuracy, offset, arrayRef.sourceEnd-offset+1, arrayRef);
+			int length = arrayRef.sourceEnd-offset+1;
+			if (this.match == null) {
+				this.match = locator.newTypeReferenceMatch(element, elementBinding, accuracy, offset, length, arrayRef);
+			} else {
+				this.match.setOffset(offset);
+				this.match.setLength(length);
+			}
 			locator.report(match);
 			return;
 		}
@@ -268,6 +274,12 @@
 	locator.reportAccurateTypeReference(match, arrayRef, this.pattern.simpleName);
 }
 protected void matchReportReference(ASTNode reference, IJavaElement element, Binding elementBinding, int accuracy, MatchLocator locator) throws CoreException {
+	matchReportReference(reference, element, null, null, elementBinding, accuracy, locator);
+}
+/**
+ * Reports the match of the given reference. Also provide a local element to eventually report in match.
+ */
+protected void matchReportReference(ASTNode reference, IJavaElement element, IJavaElement localElement, IJavaElement[] otherElements, Binding elementBinding, int accuracy, MatchLocator locator) throws CoreException {
 	if (this.isDeclarationOfReferencedTypesPattern) {
 		if ((element = findElement(element, accuracy)) != null)
 			reportDeclaration(reference, element, locator, ((DeclarationOfReferencedTypesPattern) this.pattern).knownTypes);
@@ -275,7 +287,10 @@
 	}
 	
 	// Create search match
-	match = locator.newTypeReferenceMatch(element, elementBinding, accuracy, reference);
+	TypeReferenceMatch refMatch = locator.newTypeReferenceMatch(element, elementBinding, accuracy, reference);
+	refMatch.setLocalElement(localElement);
+	refMatch.setOtherElements(otherElements);
+	this.match = refMatch;
 
 	// Report match depending on reference type
 	if (reference instanceof QualifiedNameReference)
@@ -293,6 +308,54 @@
 		locator.report(match);
 	}
 }
+/**
+ * Reports the match of the given reference. Also provide a scope to look for potential other elements.
+ */
+protected void matchReportReference(ASTNode reference, IJavaElement element, Binding elementBinding, Scope scope, int accuracy, MatchLocator locator) throws CoreException {
+	if (scope == null || (scope.kind != Scope.BLOCK_SCOPE && scope.kind != Scope.METHOD_SCOPE)) {
+		matchReportReference(reference, element, elementBinding, accuracy, locator);
+		return;
+	}
+	BlockScope blockScope = (BlockScope) scope;
+	LocalDeclaration[] localDeclarations = blockScope.findLocalVariableDeclarations(reference.sourceStart);
+	int length = localDeclarations == null ? 0 : localDeclarations.length;
+	IJavaElement localElement = null;
+	IJavaElement[] otherElements = null;
+	if (length > 0) {
+		// Set other elements to  as it's different from enclosing one
+		int idx = 0;
+		for (; idx<length; idx++) {
+			if (localDeclarations[idx] == null) break;
+			if (reference.sourceStart == localDeclarations[idx].declarationSourceStart) {
+				localElement = locator.createHandle(localDeclarations[idx], element);
+				break;
+			}
+			if (idx>0 && localDeclarations[idx].sourceStart > reference.sourceStart) {
+				localElement = locator.createHandle(localDeclarations[idx-1], element);
+				break;
+			}
+		}
+		if (localElement == null && idx > 0) {
+			if (reference.sourceEnd < localDeclarations[idx-1].declarationEnd) {
+				localElement = locator.createHandle(localDeclarations[idx-1], element);
+			}
+		}
+		int size = 0;
+		for (int j=1; j<length; j++) {
+			if (localDeclarations[j] == null) break;
+			if (reference.sourceStart == localDeclarations[j].declarationSourceStart) {
+				if (otherElements == null) {
+					otherElements = new IJavaElement[length-j];
+				}
+				otherElements[size++] = locator.createHandle(localDeclarations[j], element);
+			}
+		}
+		if (size > 0 && size != (length-1)) {
+			System.arraycopy(otherElements, 0, otherElements = new IJavaElement[size], 0, size);
+		}
+	}
+	matchReportReference(reference, element, localElement, otherElements, elementBinding, accuracy, locator);
+}
 protected void matchReportReference(QualifiedNameReference qNameRef, IJavaElement element, Binding elementBinding, int accuracy, MatchLocator locator) throws CoreException {
 	Binding binding = qNameRef.binding;
 	TypeBinding typeBinding = null;
@@ -325,7 +388,9 @@
 	}
 
 	// Create search match to report
-	match = locator.newTypeReferenceMatch(element, elementBinding, accuracy, qNameRef);
+	if (this.match == null) {
+		this.match = locator.newTypeReferenceMatch(element, elementBinding, accuracy, qNameRef);
+	}
 
 	// try to match all enclosing types for which the token matches as well.
 	if (typeBinding instanceof ReferenceBinding) {
@@ -368,7 +433,9 @@
 	}
 
 	// Create search match to report
-	match = locator.newTypeReferenceMatch(element, elementBinding, accuracy, qTypeRef);
+	if (this.match == null) {
+		this.match = locator.newTypeReferenceMatch(element, elementBinding, accuracy, qTypeRef);
+	}
 
 	// try to match all enclosing types for which the token matches as well
 	if (typeBinding instanceof ReferenceBinding) {
Index: search/org/eclipse/jdt/core/search/TypeReferenceMatch.java
===================================================================
RCS file: /cvsroot/eclipse/org.eclipse.jdt.core/search/org/eclipse/jdt/core/search/TypeReferenceMatch.java,v
retrieving revision 1.14
diff -u -r1.14 TypeReferenceMatch.java
--- search/org/eclipse/jdt/core/search/TypeReferenceMatch.java	23 Feb 2005 02:47:30 -0000	1.14
+++ search/org/eclipse/jdt/core/search/TypeReferenceMatch.java	23 Nov 2005 17:11:43 -0000
@@ -24,6 +24,9 @@
  */
 public class TypeReferenceMatch extends SearchMatch {
 
+	private IJavaElement[] otherElements;
+	private IJavaElement localElement;
+
 	/**
 	 * Creates a new type reference match.
 	 * 
@@ -40,4 +43,45 @@
 		super(enclosingElement, accuracy, offset, length, participant, resource);
 		setInsideDocComment(insideDocComment);
 	}
+
+	/**
+	 * Returns the local element of this search match.
+	 * This may be a local variable or a type parameter.
+	 * 
+	 * @return the element of the search match, or <code>null</code> if none or there's
+	 * 	no more inner-most enclosing than the element itself ({@link SearchMatch#getElement()}).
+	 */
+	public final IJavaElement getLocalElement() {
+		return this.localElement;
+	}
+
+	/**
+	 * Returns other elements of this search match.
+	 * These may be other fields of a multiple fields declaration.
+	 * 
+	 * @return the other elements of the search match, or <code>null</code> if none.
+	 */
+	public final IJavaElement[] getOtherElements() {
+		return this.otherElements;
+	}
+
+	/**
+	 * Sets the local element of this search match.
+	 * 
+	 * @param element the local element that encloses or corresponds to the match,
+	 * or <code>null</code> if none
+	 */
+	public final void setLocalElement(IJavaElement element) {
+		this.localElement = element;
+	}
+
+	/**
+	 * Sets the other elements of this search match.
+	 * 
+	 * @param elements the other elements of the match,
+	 * 	or <code>null</code> if none
+	 */
+	public final void setOtherElements(IJavaElement[] elements) {
+		this.otherElements = elements;
+	}
 }
Index: compiler/org/eclipse/jdt/internal/compiler/lookup/BlockScope.java
===================================================================
RCS file: /cvsroot/eclipse/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/BlockScope.java,v
retrieving revision 1.94
diff -u -r1.94 BlockScope.java
--- compiler/org/eclipse/jdt/internal/compiler/lookup/BlockScope.java	18 Nov 2005 16:46:23 -0000	1.94
+++ compiler/org/eclipse/jdt/internal/compiler/lookup/BlockScope.java	23 Nov 2005 17:11:43 -0000
@@ -299,6 +299,63 @@
 		}
 	}
 
+	/**
+	 * Returns all declarations of most specific locals containing a given position in their source range.
+	 * This code does not recurse in nested types.
+	 * Returned array may have null values at trailing indexes.
+	 */
+	public LocalDeclaration[] findLocalVariableDeclarations(int position) {
+
+		// local variable init
+		int ilocal = 0, maxLocals = this.localIndex;
+		boolean hasMoreVariables = maxLocals > 0;
+		LocalDeclaration[] localDeclarations = null;
+		int declPtr = 0;
+
+		// scope init
+		int iscope = 0, maxScopes = this.subscopeCount;
+		boolean hasMoreScopes = maxScopes > 0;
+
+		// iterate scopes and variables in parallel
+		while (hasMoreVariables || hasMoreScopes) {
+			if (hasMoreScopes
+				&& (!hasMoreVariables || (subscopes[iscope].startIndex() <= ilocal))) {
+				// consider subscope first
+				Scope subscope = subscopes[iscope];
+				if (subscope.kind == Scope.BLOCK_SCOPE) { // do not dive in nested types
+					localDeclarations = ((BlockScope)subscope).findLocalVariableDeclarations(position);
+					if (localDeclarations != null) {
+						return localDeclarations;
+					}
+				}
+				hasMoreScopes = ++iscope < maxScopes;
+			} else {
+				// consider variable first
+				LocalVariableBinding local = locals[ilocal]; // if no local at all, will be locals[ilocal]==null
+				if (local != null) {
+					LocalDeclaration localDecl = local.declaration;
+					if (localDecl != null) {
+						if (localDecl.declarationSourceStart <= position) {
+							if (position <= localDecl.declarationSourceEnd) {
+								if (localDeclarations == null) {
+									localDeclarations = new LocalDeclaration[maxLocals];
+								}
+								localDeclarations[declPtr++] = localDecl;
+							}
+						} else {
+							return localDeclarations;
+						}
+					}
+				}
+				hasMoreVariables = ++ilocal < maxLocals;
+				if (!hasMoreVariables && localDeclarations != null) {
+					return localDeclarations;
+				}
+			}
+		}
+		return null;
+	}
+
 	/* Note that it must never produce a direct access to the targetEnclosingType,
 	 * but instead a field sequence (this$2.this$1.this$0) so as to handle such a test case:
 	 *