Attachment 252324 Details for Bug 403917 – evolved patch

[patch] evolved patch

TYPE_USE_annotations_in_hover.patch (text/plain), 65.08 KB, created by Stephan Herrmann

on 2015-04-12 21:51:19 EDT

(hide)

Description:

Filename:

MIME Type:

Creator: Stephan Herrmann

Created: 2015-04-12 21:51:19 EDT

Size: 65.08 KB

patch

obsolete

>diff --git a/org.eclipse.jdt.ui.tests/ui/org/eclipse/jdt/ui/tests/core/BindingLabelsTest.java b/org.eclipse.jdt.ui.tests/ui/org/eclipse/jdt/ui/tests/core/BindingLabelsTest.java
>new file mode 100644
>index 0000000..98f91d5
>--- /dev/null
>+++ b/org.eclipse.jdt.ui.tests/ui/org/eclipse/jdt/ui/tests/core/BindingLabelsTest.java
>@@ -0,0 +1,828 @@
>+/*******************************************************************************
>+ * Copyright (c) 2000, 2014 IBM Corporation and others.
>+ * All rights reserved. This program and the accompanying materials
>+ * are made available under the terms of the Eclipse Public License v1.0
>+ * which accompanies this distribution, and is available at
>+ * http://www.eclipse.org/legal/epl-v10.html
>+ *
>+ * Contributors:
>+ *     IBM Corporation - initial API and implementation
>+ *******************************************************************************/
>+package org.eclipse.jdt.ui.tests.core;
>+
>+import java.util.regex.Matcher;
>+import java.util.regex.Pattern;
>+
>+import org.eclipse.jdt.testplugin.JavaProjectHelper;
>+
>+import org.eclipse.core.runtime.CoreException;
>+
>+import org.eclipse.jface.preference.IPreferenceStore;
>+
>+import org.eclipse.jdt.core.ICompilationUnit;
>+import org.eclipse.jdt.core.IJavaElement;
>+import org.eclipse.jdt.core.IJavaProject;
>+import org.eclipse.jdt.core.IMethod;
>+import org.eclipse.jdt.core.IPackageFragment;
>+import org.eclipse.jdt.core.IPackageFragmentRoot;
>+import org.eclipse.jdt.core.IType;
>+import org.eclipse.jdt.core.ITypeParameter;
>+import org.eclipse.jdt.core.JavaModelException;
>+import org.eclipse.jdt.core.dom.AST;
>+import org.eclipse.jdt.core.dom.ASTParser;
>+import org.eclipse.jdt.core.dom.IBinding;
>+import org.eclipse.jdt.core.dom.ITypeBinding;
>+
>+import org.eclipse.jdt.ui.JavaElementLabels;
>+import org.eclipse.jdt.ui.PreferenceConstants;
>+
>+import org.eclipse.jdt.internal.ui.viewsupport.JavaElementLinks;
>+
>+import junit.framework.Test;
>+import junit.framework.TestSuite;
>+
>+
>+public class BindingLabelsTest extends CoreTests {
>+
>+	private static final Class THIS= BindingLabelsTest.class;
>+
>+	private IJavaProject fJProject1;
>+
>+	public BindingLabelsTest(String name) {
>+		super(name);
>+	}
>+
>+	public static Test suite() {
>+		return setUpTest(new TestSuite(THIS));
>+	}
>+
>+	public static Test setUpTest(Test test) {
>+		return new ProjectTestSetup(test);
>+	}
>+
>+	protected void setUp() throws Exception {
>+		fJProject1= ProjectTestSetup.getProject();
>+
>+		IPreferenceStore store= PreferenceConstants.getPreferenceStore();
>+		store.setValue(PreferenceConstants.APPEARANCE_COMPRESS_PACKAGE_NAMES, false);
>+	}
>+
>+
>+	protected void tearDown() throws Exception {
>+		JavaProjectHelper.clear(fJProject1, ProjectTestSetup.getDefaultClasspath());
>+	}
>+
>+	protected String getBindingLabel(IJavaElement elem, long flags) {
>+		ASTParser parser= ASTParser.newParser(AST.JLS8);
>+		parser.setResolveBindings(true);
>+		parser.setProject(fJProject1);
>+		IBinding binding= parser.createBindings(new IJavaElement[]{elem}, null)[0];
>+		return JavaElementLinks.getBindingLabel(binding, elem, flags);
>+	}
>+
>+	private void assertLink(String lab, String display) {
>+		Pattern pattern= Pattern.compile("<a class='header' href='eclipse-javadoc:.*'>(.*)</a>");
>+		Matcher matcher= pattern.matcher(lab);
>+		assertEquals("number of match groups", 1, matcher.groupCount());
>+		assertTrue("Label doesn't match against expected pattern: "+lab, matcher.matches());
>+		assertEquals("display label", display, matcher.group(1));
>+	}
>+
>+	private void assertLink(String lab, String display, String title) {
>+		Pattern pattern= Pattern.compile("<a class='header' href='eclipse-javadoc:.*' title='(.*)'>(.*)</a>");
>+		Matcher matcher= pattern.matcher(lab);
>+		assertEquals("number of match groups", 2, matcher.groupCount());
>+		assertTrue("Label doesn't match against expected pattern: "+lab, matcher.matches());
>+		assertEquals("title", title, matcher.group(1));
>+		assertEquals("display label", display, matcher.group(2));
>+	}
>+
>+	/*
>+	 * expectedMarkup may contain any number of occurrences of "{{qualifier|name}}",
>+	 * which will be matched as a link with link text "name" and a link title "in qualifier".  
>+	 */
>+	protected void assertLinkMatch(String label, String expectedMarkup) {
>+		// to avoid matching the entire unreadable label in one step we co-parse expected and actual value:
>+		int patternPos= 0;
>+		int labelPos= 0;
>+		int fragmentCount= 0;
>+		while (patternPos < expectedMarkup.length()) {
>+			// analyse expected markup:
>+			int open= expectedMarkup.indexOf("{{", patternPos);
>+			if (open == -1)
>+				break;
>+			int pipe= expectedMarkup.indexOf('|', open);
>+			boolean hasTitle= pipe != -1;
>+			int close= expectedMarkup.indexOf("}}", hasTitle ? pipe : open);
>+
>+			if (open > patternPos) {
>+				// matching plain text:
>+				String expected= expectedMarkup.substring(patternPos, open);
>+				int end= label.indexOf("<a class", labelPos);
>+				assertTrue("next anchor not found", end != -1);
>+				assertEquals("plain text ("+(fragmentCount)+")", escape(expected), label.substring(labelPos, end));
>+				fragmentCount++;
>+
>+				labelPos= end;
>+			}
>+			
>+			if (close != -1) {
>+				// matching a link "<a class='header' href='eclipse-javadoc:IGNORE' title='LINK_TITLE'>LINK_TEXT</a>"
>+				assertTrue("link found", label.substring(labelPos).startsWith( "<a class='header' href='eclipse-javadoc:"));
>+				String linkText= expectedMarkup.substring(hasTitle ? pipe+1 : open+2, close);
>+				String linkTitle= hasTitle ? "in "+expectedMarkup.substring(open+2, pipe) : null;
>+				if (linkTitle != null) {
>+					// match linkTitle & linkText:
>+					int start= label.indexOf("' title='", labelPos) + "' title='".length();
>+					assertTrue("title start not found", start != -1);
>+					int end= label.indexOf('\'', start);
>+					assertTrue("title end not found", end != -1);
>+					assertEquals("title ("+fragmentCount+")", linkTitle, label.substring(start, end));
>+					fragmentCount++;
>+
>+					start= label.indexOf("'>", end) + 2;
>+					assertTrue("link text start not found", start != -1);
>+					end= label.indexOf("</a>", start);
>+					assertTrue("link text end not found", end != -1);
>+					assertEquals("link text ("+fragmentCount+")", escape(linkText), label.substring(start, end));
>+					fragmentCount++;
>+
>+					labelPos= end + "</a>".length();
>+				} else {
>+					// match only linkText
>+					int start= label.indexOf("'>", labelPos) + 2;
>+					assertTrue("link text start not found", start != -1);
>+					int end= label.indexOf("</a>", start+1);
>+					assertTrue("link text end not found", end != -1);
>+					assertEquals("link text ("+fragmentCount+")", escape(linkText), label.substring(start, end));
>+					fragmentCount++;
>+
>+					labelPos= end + "</a>".length();
>+				}
>+			}
>+			patternPos= close+2;
>+		}
>+		if (patternPos < expectedMarkup.length()) {
>+			// matching tailing plain text:
>+			String expected= expectedMarkup.substring(patternPos);
>+			assertEquals("plain text ("+(fragmentCount)+")", escape(expected), label.substring(labelPos));
>+		}
>+	}
>+
>+	protected String escape(String element) {
>+		return element.replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;");
>+	}
>+
>+	public void testTypeLabelOuter() throws Exception {
>+
>+		IPackageFragmentRoot sourceFolder= JavaProjectHelper.addSourceContainer(fJProject1, "src");
>+
>+		IPackageFragment pack1= sourceFolder.createPackageFragment("org.test", false, null);
>+		StringBuffer buf= new StringBuffer();
>+		buf.append("package org.test;\n");
>+		buf.append("public class Outer {\n");
>+		buf.append("}\n");
>+		String content= buf.toString();
>+		ICompilationUnit cu= pack1.createCompilationUnit("Outer.java", content, false, null);
>+
>+		IJavaElement elem= cu.getElementAt(content.indexOf("Outer"));
>+		String lab= getBindingLabel(elem, JavaElementLabels.T_FULLY_QUALIFIED);
>+		assertLink(lab, "org.test.Outer");
>+
>+		lab= getBindingLabel(elem, JavaElementLabels.T_CONTAINER_QUALIFIED);
>+		assertLink(lab, "Outer", "in org.test");
>+
>+/*
>+		lab= JavaElementLabels.getTextLabel(elem, JavaElementLabels.T_POST_QUALIFIED);
>+		assertEqualString(lab, "Outer - org.test");
>+
>+		lab= JavaElementLabels.getTextLabel(elem, JavaElementLabels.T_FULLY_QUALIFIED | JavaElementLabels.APPEND_ROOT_PATH);
>+		assertEqualString(lab, "org.test.Outer - TestSetupProject/src");
>+
>+		lab= JavaElementLabels.getTextLabel(elem, JavaElementLabels.T_FULLY_QUALIFIED | JavaElementLabels.PREPEND_ROOT_PATH);
>+		assertEqualString(lab, "TestSetupProject/src - org.test.Outer");
>+ */
>+	}
>+
>+	public void testTypeLabelInner() throws Exception {
>+
>+		IPackageFragmentRoot sourceFolder= JavaProjectHelper.addSourceContainer(fJProject1, "src");
>+
>+		IPackageFragment pack1= sourceFolder.createPackageFragment("org.test", false, null);
>+		StringBuffer buf= new StringBuffer();
>+		buf.append("package org.test;\n");
>+		buf.append("import java.util.Vector;\n");
>+		buf.append("public class Outer {\n");
>+		buf.append("    public void foo(Vector vec) {\n");
>+		buf.append("    }\n");
>+		buf.append("    public class Inner {\n");
>+		buf.append("        public int inner(Vector vec) {\n");
>+		buf.append("        }\n");
>+		buf.append("    }\n");
>+		buf.append("}\n");
>+		String content= buf.toString();
>+		ICompilationUnit cu= pack1.createCompilationUnit("Outer.java", content, false, null);
>+
>+		IJavaElement elem= cu.getElementAt(content.indexOf("Inner"));
>+		String lab= getBindingLabel(elem, JavaElementLabels.T_FULLY_QUALIFIED);
>+		assertLink(lab, "org.test.Outer.Inner");
>+
>+		lab= getBindingLabel(elem, JavaElementLabels.T_CONTAINER_QUALIFIED);
>+		assertLink(lab, "Outer.Inner", "in org.test");
>+
>+/*
>+		lab= JavaElementLabels.getTextLabel(elem, JavaElementLabels.T_POST_QUALIFIED);
>+		assertEqualString(lab, "Inner - org.test.Outer");
>+
>+		lab= JavaElementLabels.getTextLabel(elem, JavaElementLabels.T_FULLY_QUALIFIED | JavaElementLabels.APPEND_ROOT_PATH);
>+		assertEqualString(lab, "org.test.Outer.Inner - TestSetupProject/src");
>+
>+		lab= JavaElementLabels.getTextLabel(elem, JavaElementLabels.T_FULLY_QUALIFIED | JavaElementLabels.PREPEND_ROOT_PATH);
>+		assertEqualString(lab, "TestSetupProject/src - org.test.Outer.Inner");
>+ */
>+	}
>+
>+	public void testTypeLabelLocal() throws Exception {
>+
>+		IPackageFragmentRoot sourceFolder= JavaProjectHelper.addSourceContainer(fJProject1, "src");
>+
>+		IPackageFragment pack1= sourceFolder.createPackageFragment("org.test", false, null);
>+		StringBuffer buf= new StringBuffer();
>+		buf.append("package org.test;\n");
>+		buf.append("import java.util.Vector;\n");
>+		buf.append("public class Outer {\n");
>+		buf.append("    public void foo(Vector vec) {\n");
>+		buf.append("        public class Local {\n");
>+		buf.append("        }\n");
>+		buf.append("    }\n");
>+		buf.append("}\n");
>+		String content= buf.toString();
>+		ICompilationUnit cu= pack1.createCompilationUnit("Outer.java", content, false, null);
>+
>+		IJavaElement elem= cu.getElementAt(content.indexOf("Local"));
>+		String lab= getBindingLabel(elem, JavaElementLabels.T_FULLY_QUALIFIED);
>+		assertLink(lab, "org.test.Outer.foo(...).Local");
>+
>+		lab= getBindingLabel(elem, JavaElementLabels.T_CONTAINER_QUALIFIED);
>+		assertLink(lab, "Outer.foo(...).Local", "in org.test");
>+
>+/*
>+		lab= JavaElementLabels.getTextLabel(elem, JavaElementLabels.T_POST_QUALIFIED);
>+		assertEqualString(lab, "Local - org.test.Outer.foo(...)");
>+
>+		lab= JavaElementLabels.getTextLabel(elem, JavaElementLabels.T_FULLY_QUALIFIED | JavaElementLabels.APPEND_ROOT_PATH);
>+		assertEqualString(lab, "org.test.Outer.foo(...).Local - TestSetupProject/src");
>+
>+		lab= JavaElementLabels.getTextLabel(elem, JavaElementLabels.T_FULLY_QUALIFIED | JavaElementLabels.PREPEND_ROOT_PATH);
>+		assertEqualString(lab, "TestSetupProject/src - org.test.Outer.foo(...).Local");
>+ */
>+	}
>+
>+	public void testTypeParameterLabelType() throws Exception {
>+
>+		IPackageFragmentRoot sourceFolder= JavaProjectHelper.addSourceContainer(fJProject1, "src");
>+
>+		IPackageFragment pack1= sourceFolder.createPackageFragment("org.test", false, null);
>+		StringBuffer buf= new StringBuffer();
>+		buf.append("package org.test;\n");
>+		buf.append("import java.util.*;\n");
>+		buf.append("import java.io.Serializable;\n");
>+		buf.append("public class TypeParams<Q extends ArrayList<? extends Number>, Element extends Map<String, Integer> & Serializable, NoBound> {\n");
>+		buf.append("}\n");
>+		String content= buf.toString();
>+		ICompilationUnit cu= pack1.createCompilationUnit("TypeParams.java", content, false, null);
>+
>+		IType typeParams= (IType)cu.getElementAt(content.indexOf("TypeParams"));
>+		ITypeParameter[] typeParameters= typeParams.getTypeParameters();
>+		ITypeParameter q= typeParameters[0];
>+		ITypeParameter element= typeParameters[1];
>+		ITypeParameter nobound= typeParameters[2];
>+
>+		String lab= getBindingLabel(q, 0);
>+		assertLinkMatch(lab, "Q extends {{java.util|ArrayList}}<? extends {{java.lang|Number}}>");
>+/*
>+		lab= JavaElementLabels.getTextLabel(q, JavaElementLabels.ALL_POST_QUALIFIED);
>+		assertEqualString(lab, "Q extends ArrayList<? extends Number> - org.test.TypeParams");
>+ */
>+
>+		lab= getBindingLabel(element, 0);
>+		assertLinkMatch(lab, "Element extends {{java.util|Map}}<{{java.lang|String}}, {{java.lang|Integer}}> & {{java.io|Serializable}}");
>+/*
>+		lab= JavaElementLabels.getTextLabel(element, JavaElementLabels.DEFAULT_POST_QUALIFIED);
>+		assertEqualString(lab, "Element extends Map<String, Integer> & Serializable - org.test.TypeParams");
>+ */
>+
>+		lab= getBindingLabel(nobound, 0);
>+		assertEqualString(lab, "NoBound");
>+/*
>+		lab= JavaElementLabels.getTextLabel(nobound, JavaElementLabels.TP_POST_QUALIFIED);
>+		assertEqualString(lab, "NoBound - org.test.TypeParams");
>+ */
>+
>+
>+/* cannot select 'E' from cu.
>+		IType al= (IType)cu.codeSelect(content.indexOf("ArrayList"), 0)[0];
>+		ITypeParameter[] alTypeParameters= al.getTypeParameters();
>+		ITypeParameter e= alTypeParameters[0];
>+
>+		lab= JavaElementLabels.getTextLabel(e, 0);
>+		assertEqualString(lab, "E"); // no " extends java.lang.Object"!
>+ */
>+
>+/*
>+		lab= JavaElementLabels.getTextLabel(e, JavaElementLabels.ALL_POST_QUALIFIED);
>+		assertEqualString(lab, "E - java.util.ArrayList");
>+ */
>+		
>+		
>+		lab= getBindingLabel(typeParams, 0);
>+		assertLink(lab, "TypeParams", "in org.test");
>+		lab= getBindingLabel(typeParams, JavaElementLabels.ALL_DEFAULT);
>+		assertLinkMatch(lab, "{{org.test|TypeParams}}<Q extends {{java.util|ArrayList}}<? extends {{java.lang|Number}}>, Element extends {{java.util|Map}}<{{java.lang|String}}, {{java.lang|Integer}}> & {{java.io|Serializable}}, NoBound>");
>+/*
>+		lab= JavaElementLabels.getTextLabel(typeParams, JavaElementLabels.ALL_DEFAULT | JavaElementLabels.ALL_POST_QUALIFIED);
>+		assertEqualString(lab, "TypeParams<Q extends ArrayList<? extends Number>, Element extends Map<String, Integer> & Serializable, NoBound> - org.test");
>+ */
>+	}
>+
>+	public void testTypeParameterLabelMethod() throws Exception {
>+
>+		IPackageFragmentRoot sourceFolder= JavaProjectHelper.addSourceContainer(fJProject1, "src");
>+
>+		IPackageFragment pack1= sourceFolder.createPackageFragment("org.test", false, null);
>+		StringBuffer buf= new StringBuffer();
>+		buf.append("package org.test;\n");
>+		buf.append("import java.util.*;\n");
>+		buf.append("public class X {\n");
>+		buf.append("    <Q extends ArrayList<? extends Number>, Element extends Map<String, Integer>, NoBound> Q method(Element e, NoBound n) {\n");
>+		buf.append("        return null;\n");
>+		buf.append("    }\n");
>+		buf.append("}\n");
>+		String content= buf.toString();
>+		ICompilationUnit cu= pack1.createCompilationUnit("X.java", content, false, null);
>+
>+		IMethod method= (IMethod)cu.getElementAt(content.indexOf("method"));
>+		ITypeParameter[] typeParameters= method.getTypeParameters();
>+		ITypeParameter q= typeParameters[0];
>+		ITypeParameter element= typeParameters[1];
>+		ITypeParameter nobound= typeParameters[2];
>+
>+		String lab= getBindingLabel(q, 0);
>+		assertLinkMatch(lab, "Q extends {{java.util|ArrayList}}<? extends {{java.lang|Number}}>");
>+/*
>+		lab= JavaElementLabels.getTextLabel(q, JavaElementLabels.ALL_POST_QUALIFIED);
>+		assertEqualString(lab, "Q extends ArrayList<? extends Number> - org.test.X.method(Element, NoBound)");
>+ */
>+
>+		lab= getBindingLabel(element, 0);
>+		assertLinkMatch(lab, "Element extends {{java.util|Map}}<{{java.lang|String}}, {{java.lang|Integer}}>");
>+/*
>+		lab= JavaElementLabels.getTextLabel(element, JavaElementLabels.DEFAULT_POST_QUALIFIED);
>+		assertEqualString(lab, "Element extends Map<String, Integer> - org.test.X.method(Element, NoBound)");
>+ */
>+
>+		lab= getBindingLabel(nobound, 0);
>+		assertEqualString(lab, "NoBound");
>+/*
>+		lab= JavaElementLabels.getTextLabel(nobound, JavaElementLabels.TP_POST_QUALIFIED);
>+		assertEqualString(lab, "NoBound - org.test.X.method(Element, NoBound)");
>+ */
>+	}
>+
>+	public void testTypeLabelAnonymous() throws Exception {
>+
>+		IPackageFragmentRoot sourceFolder= JavaProjectHelper.addSourceContainer(fJProject1, "src");
>+
>+		IPackageFragment pack1= sourceFolder.createPackageFragment("org.test", false, null);
>+		StringBuffer buf= new StringBuffer();
>+		buf.append("package org.test;\n");
>+		buf.append("import java.util.Vector;\n");
>+		buf.append("public class Outer {\n");
>+		buf.append("    public void foo(Vector vec) {\n");
>+		buf.append("        new Object() {\n");
>+		buf.append("        };\n");
>+		buf.append("    }\n");
>+		buf.append("}\n");
>+		String content= buf.toString();
>+		ICompilationUnit cu= pack1.createCompilationUnit("Outer.java", content, false, null);
>+
>+		IJavaElement elem= cu.getElementAt(content.indexOf("Object"));
>+		String lab= getBindingLabel(elem, JavaElementLabels.T_FULLY_QUALIFIED);
>+		assertLink(lab, "org.test.Outer.foo(...).new Object() {...}");
>+
>+		lab= getBindingLabel(elem, JavaElementLabels.T_CONTAINER_QUALIFIED);
>+		assertLink(lab, "Outer.foo(...).new Object() {...}", "in org.test");
>+
>+/*
>+		lab= JavaElementLabels.getTextLabel(elem, JavaElementLabels.T_POST_QUALIFIED);
>+		assertEqualString(lab, "new Object() {...} - org.test.Outer.foo(...)");
>+
>+		lab= JavaElementLabels.getTextLabel(elem, JavaElementLabels.T_FULLY_QUALIFIED | JavaElementLabels.APPEND_ROOT_PATH);
>+		assertEqualString(lab, "org.test.Outer.foo(...).new Object() {...} - TestSetupProject/src");
>+
>+		lab= JavaElementLabels.getTextLabel(elem, JavaElementLabels.T_FULLY_QUALIFIED | JavaElementLabels.PREPEND_ROOT_PATH);
>+		assertEqualString(lab, "TestSetupProject/src - org.test.Outer.foo(...).new Object() {...}");
>+ */
>+	}
>+
>+	public void testTypeLabelAnonymousInAnonymous() throws Exception {
>+
>+		IPackageFragmentRoot sourceFolder= JavaProjectHelper.addSourceContainer(fJProject1, "src");
>+
>+		IPackageFragment pack1= sourceFolder.createPackageFragment("org.test", false, null);
>+		StringBuffer buf= new StringBuffer();
>+		buf.append("package org.test;\n");
>+		buf.append("import java.util.Vector;\n");
>+		buf.append("import java.io.Serializable;\n");
>+		buf.append("public class Outer {\n");
>+		buf.append("    public void foo(Vector vec) {\n");
>+		buf.append("        new Object() {\n");
>+		buf.append("            public void xoo() {\n");
>+		buf.append("                new Serializable() {\n");
>+		buf.append("                };\n");
>+		buf.append("            }\n");
>+		buf.append("        };\n");
>+		buf.append("    }\n");
>+		buf.append("}\n");
>+		String content= buf.toString();
>+		ICompilationUnit cu= pack1.createCompilationUnit("Outer.java", content, false, null);
>+
>+		IJavaElement elem= cu.getElementAt(content.indexOf("Serializable()"));
>+		String lab= getBindingLabel(elem, JavaElementLabels.T_FULLY_QUALIFIED);
>+		assertLink(lab, "org.test.Outer.foo(...).new Object() {...}.xoo().new Serializable() {...}");
>+
>+		lab= getBindingLabel(elem, JavaElementLabels.T_CONTAINER_QUALIFIED);
>+		assertLink(lab, "Outer.foo(...).new Object() {...}.xoo().new Serializable() {...}", "in org.test");
>+
>+/*
>+		lab= JavaElementLabels.getTextLabel(elem, JavaElementLabels.T_POST_QUALIFIED);
>+		assertEqualString(lab, "new Serializable() {...} - org.test.Outer.foo(...).new Object() {...}.xoo()");
>+
>+		lab= JavaElementLabels.getTextLabel(elem, JavaElementLabels.T_FULLY_QUALIFIED | JavaElementLabels.APPEND_ROOT_PATH);
>+		assertEqualString(lab, "org.test.Outer.foo(...).new Object() {...}.xoo().new Serializable() {...} - TestSetupProject/src");
>+
>+		lab= JavaElementLabels.getTextLabel(elem, JavaElementLabels.T_FULLY_QUALIFIED | JavaElementLabels.PREPEND_ROOT_PATH);
>+		assertEqualString(lab, "TestSetupProject/src - org.test.Outer.foo(...).new Object() {...}.xoo().new Serializable() {...}");
>+ */
>+	}
>+
>+	public void testTypeLabelAnonymousInFieldInitializer() throws Exception {
>+
>+		IPackageFragmentRoot sourceFolder= JavaProjectHelper.addSourceContainer(fJProject1, "src");
>+
>+		IPackageFragment pack1= sourceFolder.createPackageFragment("org.test", false, null);
>+		StringBuffer buf= new StringBuffer();
>+		buf.append("package org.test;\n");
>+		buf.append("import java.util.Vector;\n");
>+		buf.append("public class Outer {\n");
>+		buf.append("    Object o= new Thread() {\n");
>+		buf.append("    };\n");
>+		buf.append("}\n");
>+		String content= buf.toString();
>+		ICompilationUnit cu= pack1.createCompilationUnit("Outer.java", content, false, null);
>+
>+		IJavaElement elem= cu.getElementAt(content.indexOf("Thread"));
>+		String lab= getBindingLabel(elem, JavaElementLabels.T_FULLY_QUALIFIED);
>+		assertLink(lab, "org.test.Outer.o.new Thread() {...}");
>+
>+		lab= getBindingLabel(elem, JavaElementLabels.T_CONTAINER_QUALIFIED);
>+		assertLink(lab, "Outer.o.new Thread() {...}", "in org.test");
>+
>+/*
>+		lab= JavaElementLabels.getTextLabel(elem, JavaElementLabels.T_POST_QUALIFIED);
>+		assertEqualString(lab, "new Thread() {...} - org.test.Outer.o");
>+
>+		lab= JavaElementLabels.getTextLabel(elem, JavaElementLabels.T_FULLY_QUALIFIED | JavaElementLabels.APPEND_ROOT_PATH);
>+		assertEqualString(lab, "org.test.Outer.o.new Thread() {...} - TestSetupProject/src");
>+
>+		lab= JavaElementLabels.getTextLabel(elem, JavaElementLabels.T_FULLY_QUALIFIED | JavaElementLabels.PREPEND_ROOT_PATH);
>+		assertEqualString(lab, "TestSetupProject/src - org.test.Outer.o.new Thread() {...}");
>+ */
>+	}
>+
>+	public void testTypeLabelAnonymousInInitializer() throws Exception {
>+
>+		IPackageFragmentRoot sourceFolder= JavaProjectHelper.addSourceContainer(fJProject1, "src");
>+
>+		IPackageFragment pack1= sourceFolder.createPackageFragment("org.test", false, null);
>+		StringBuffer buf= new StringBuffer();
>+		buf.append("package org.test;\n");
>+		buf.append("import java.util.Vector;\n");
>+		buf.append("public class Outer {\n");
>+		buf.append("    static {\n");
>+		buf.append("        new Object() {\n");
>+		buf.append("        };\n");
>+		buf.append("    }\n");
>+		buf.append("}\n");
>+		String content= buf.toString();
>+		ICompilationUnit cu= pack1.createCompilationUnit("Outer.java", content, false, null);
>+
>+		IJavaElement elem= cu.getElementAt(content.indexOf("Object"));
>+		String lab= getBindingLabel(elem, JavaElementLabels.T_FULLY_QUALIFIED);
>+		assertLink(lab, "org.test.Outer.{...}.new Object() {...}");
>+
>+		lab= getBindingLabel(elem, JavaElementLabels.T_CONTAINER_QUALIFIED);
>+		assertLink(lab, "Outer.{...}.new Object() {...}", "in org.test");
>+
>+/*
>+		lab= JavaElementLabels.getTextLabel(elem, JavaElementLabels.T_POST_QUALIFIED);
>+		assertEqualString(lab, "new Object() {...} - org.test.Outer.{...}");
>+
>+		lab= JavaElementLabels.getTextLabel(elem, JavaElementLabels.T_FULLY_QUALIFIED | JavaElementLabels.APPEND_ROOT_PATH);
>+		assertEqualString(lab, "org.test.Outer.{...}.new Object() {...} - TestSetupProject/src");
>+
>+		lab= JavaElementLabels.getTextLabel(elem, JavaElementLabels.T_FULLY_QUALIFIED | JavaElementLabels.PREPEND_ROOT_PATH);
>+		assertEqualString(lab, "TestSetupProject/src - org.test.Outer.{...}.new Object() {...}");
>+ */
>+	}
>+
>+	public void testTypeLabelWildcards() throws Exception {
>+
>+			IPackageFragmentRoot sourceFolder= JavaProjectHelper.addSourceContainer(fJProject1, "src");
>+
>+			IPackageFragment pack1= sourceFolder.createPackageFragment("org.test", false, null);
>+			StringBuffer buf= new StringBuffer();
>+			buf.append("package org.test;\n");
>+			buf.append("public class Wildcards<T> {\n");
>+			buf.append("	Wildcards<? extends Number> upper;\n");
>+			buf.append("	Wildcards<? super Number> lower;\n");
>+			buf.append("	Wildcards<?> wild;\n");
>+			buf.append("}\n");
>+			String content= buf.toString();
>+			ICompilationUnit cu= pack1.createCompilationUnit("Wildcards.java", content, false, null);
>+
>+			IJavaElement elem= cu.getElementAt(content.indexOf("upper"));
>+			String lab= getBindingLabel(elem, JavaElementLabels.ALL_DEFAULT | JavaElementLabels.F_PRE_TYPE_SIGNATURE);
>+			assertLinkMatch(lab, "{{org.test|Wildcards}}<? extends {{java.lang|Number}}> upper");
>+
>+			elem= cu.getElementAt(content.indexOf("lower"));
>+			lab= getBindingLabel(elem, JavaElementLabels.ALL_DEFAULT | JavaElementLabels.F_PRE_TYPE_SIGNATURE);
>+			assertLinkMatch(lab, "{{org.test|Wildcards}}<? super {{java.lang|Number}}> lower");
>+
>+			elem= cu.getElementAt(content.indexOf("wild"));
>+			lab= getBindingLabel(elem, JavaElementLabels.ALL_DEFAULT | JavaElementLabels.F_PRE_TYPE_SIGNATURE);
>+			assertLinkMatch(lab, "{{org.test|Wildcards}}<?> wild");
>+
>+		}
>+
>+	public void testPackageLabels() throws Exception {
>+
>+		IPackageFragmentRoot sourceFolder= JavaProjectHelper.addSourceContainer(fJProject1, "src");
>+
>+		IPackageFragment packDefault= sourceFolder.getPackageFragment("");
>+		IPackageFragment packOrg= sourceFolder.createPackageFragment("org", false, null);
>+//		IPackageFragment packOrgTest= sourceFolder.createPackageFragment("org.test", false, null);
>+		IPackageFragment packOrgTestLongname= sourceFolder.createPackageFragment("org.test.longname", false, null);
>+		
>+		// to obtain an IPackageBinding go via imported types to their #package:
>+		packOrg.createCompilationUnit("T1.java", "package org;\npublic class T1 {}\n", false, null);
>+		packOrgTestLongname.createCompilationUnit("T2.java", "package org.test.longname;\npublic class T2 {}\n", false, null);
>+		
>+		StringBuffer buf= new StringBuffer();
>+		buf.append("import org.T1;\n");
>+		buf.append("import org.test.longname.T2;\n");
>+		buf.append("public class Main {\n");
>+		buf.append("}\n");
>+		String content= buf.toString();
>+		ICompilationUnit cu= packDefault.createCompilationUnit("Main.java", content, false, null);
>+
>+		IJavaElement main= cu.getElementAt(content.indexOf("Main"));
>+		IJavaElement t1= cu.getElementAt(content.indexOf("T1"));
>+		IJavaElement t2= cu.getElementAt(content.indexOf("T2"));
>+
>+		ASTParser parser= ASTParser.newParser(AST.JLS8);
>+		parser.setResolveBindings(true);
>+		parser.setProject(fJProject1);
>+		IBinding[] bindings= parser.createBindings(new IJavaElement[]{main, t1, t2}, null);
>+		
>+		String lab= JavaElementLinks.getBindingLabel(((ITypeBinding)bindings[0]).getPackage(), main.getAncestor(IJavaElement.PACKAGE_FRAGMENT), JavaElementLabels.ALL_DEFAULT);
>+		assertEqualString(lab, "(default package)");
>+		lab= JavaElementLinks.getBindingLabel(((ITypeBinding)bindings[1]).getPackage(), t1.getAncestor(IJavaElement.PACKAGE_FRAGMENT), JavaElementLabels.ALL_DEFAULT);
>+		assertEqualString(lab, "org");
>+		lab= JavaElementLinks.getBindingLabel(((ITypeBinding)bindings[2]).getPackage(), t2.getAncestor(IJavaElement.PACKAGE_FRAGMENT), JavaElementLabels.ALL_DEFAULT);
>+		assertEqualString(lab, "org.test.longname");
>+
>+/*
>+		assertExpectedLabel(packDefault, "(default package)", JavaElementLabels.P_COMPRESSED);
>+		assertExpectedLabel(packOrg, "org", JavaElementLabels.P_COMPRESSED);
>+		assertExpectedLabel(packOrgTestLongname, "org.test.longname", JavaElementLabels.P_COMPRESSED);
>+
>+		assertExpectedLabel(packDefault, "(default package) - TestSetupProject/src", JavaElementLabels.P_POST_QUALIFIED);
>+		assertExpectedLabel(packOrg, "org - TestSetupProject/src", JavaElementLabels.P_POST_QUALIFIED);
>+		assertExpectedLabel(packOrgTestLongname, "org.test.longname - TestSetupProject/src", JavaElementLabels.P_POST_QUALIFIED);
>+
>+		IPreferenceStore store= PreferenceConstants.getPreferenceStore();
>+		store.setValue(PreferenceConstants.APPEARANCE_COMPRESS_PACKAGE_NAMES, true);
>+
>+		try {
>+			store.setValue(PreferenceConstants.APPEARANCE_PKG_NAME_PATTERN_FOR_PKG_VIEW, "0");
>+
>+			assertExpectedLabel(packDefault, "(default package)", JavaElementLabels.P_COMPRESSED);
>+			assertExpectedLabel(packOrg, "org", JavaElementLabels.P_COMPRESSED);
>+			assertExpectedLabel(packOrgTest, "test", JavaElementLabels.P_COMPRESSED);
>+			assertExpectedLabel(packOrgTestLongname, "longname", JavaElementLabels.P_COMPRESSED);
>+
>+			store.setValue(PreferenceConstants.APPEARANCE_PKG_NAME_PATTERN_FOR_PKG_VIEW, ".");
>+
>+			assertExpectedLabel(packDefault, "(default package)", JavaElementLabels.P_COMPRESSED);
>+			assertExpectedLabel(packOrg, "org", JavaElementLabels.P_COMPRESSED);
>+			assertExpectedLabel(packOrgTest, ".test", JavaElementLabels.P_COMPRESSED);
>+			assertExpectedLabel(packOrgTestLongname, "..longname", JavaElementLabels.P_COMPRESSED);
>+
>+			store.setValue(PreferenceConstants.APPEARANCE_PKG_NAME_PATTERN_FOR_PKG_VIEW, "1~.");
>+
>+			assertExpectedLabel(packDefault, "(default package)", JavaElementLabels.P_COMPRESSED);
>+			assertExpectedLabel(packOrg, "org", JavaElementLabels.P_COMPRESSED);
>+			assertExpectedLabel(packOrgTest, "o~.test", JavaElementLabels.P_COMPRESSED);
>+			assertExpectedLabel(packOrgTestLongname, "o~.t~.longname", JavaElementLabels.P_COMPRESSED);
>+
>+			store.setValue(PreferenceConstants.APPEARANCE_PKG_NAME_PATTERN_FOR_PKG_VIEW, "2*.");
>+
>+			assertExpectedLabel(packDefault, "(default package)", JavaElementLabels.P_COMPRESSED);
>+			assertExpectedLabel(packOrg, "org", JavaElementLabels.P_COMPRESSED);
>+			assertExpectedLabel(packOrgTest, "org.test", JavaElementLabels.P_COMPRESSED);
>+			assertExpectedLabel(packOrgTestLongname, "org.te*.longname", JavaElementLabels.P_COMPRESSED);
>+
>+
>+			store.setValue(PreferenceConstants.APPEARANCE_ABBREVIATE_PACKAGE_NAMES, true);
>+			
>+			assertExpectedLabel(packOrgTestLongname, "org.te*.longname", JavaElementLabels.P_COMPRESSED);
>+			
>+			store.setValue(PreferenceConstants.APPEARANCE_PKG_NAME_ABBREVIATION_PATTERN_FOR_PKG_VIEW, "#com=@C\norg=@O");
>+			
>+			assertExpectedLabel(packDefault, "(default package)", JavaElementLabels.P_COMPRESSED);
>+			assertExpectedLabel(packOrg, "@O", JavaElementLabels.P_COMPRESSED);
>+			assertExpectedLabel(packOrgTest, "@O.test", JavaElementLabels.P_COMPRESSED);
>+			assertExpectedLabel(packOrgTestLongname, "@O.te*.longname", JavaElementLabels.P_COMPRESSED);
>+			
>+			store.setValue(PreferenceConstants.APPEARANCE_PKG_NAME_ABBREVIATION_PATTERN_FOR_PKG_VIEW, "org=@O\n\norg.test=@OT\n");
>+			
>+			assertExpectedLabel(packDefault, "(default package)", JavaElementLabels.P_COMPRESSED);
>+			assertExpectedLabel(packOrg, "@O", JavaElementLabels.P_COMPRESSED);
>+			assertExpectedLabel(packOrgTest, "@OT", JavaElementLabels.P_COMPRESSED);
>+			assertExpectedLabel(packOrgTestLongname, "@OT.longname", JavaElementLabels.P_COMPRESSED);
>+			
>+		} finally {
>+			store.setToDefault(PreferenceConstants.APPEARANCE_PKG_NAME_PATTERN_FOR_PKG_VIEW);
>+			store.setValue(PreferenceConstants.APPEARANCE_COMPRESS_PACKAGE_NAMES, false);
>+			store.setToDefault(PreferenceConstants.APPEARANCE_PKG_NAME_ABBREVIATION_PATTERN_FOR_PKG_VIEW);
>+			store.setValue(PreferenceConstants.APPEARANCE_ABBREVIATE_PACKAGE_NAMES, false);
>+		}
>+ */
>+	}
>+
>+	public void testMethodLabelVarargsDeclaration() throws Exception {
>+		
>+		IPackageFragmentRoot sourceFolder= JavaProjectHelper.addSourceContainer(fJProject1, "src");
>+		
>+		IPackageFragment pack1= sourceFolder.createPackageFragment("org.test", false, null);
>+		StringBuffer buf= new StringBuffer();
>+		buf.append("package org.test;\n");
>+		buf.append("public class Varargs {\n");
>+		buf.append("    public void foo(int i, String... varargs) {\n");
>+		buf.append("    }\n");
>+		buf.append("}\n");
>+		String content= buf.toString();
>+		ICompilationUnit cu= pack1.createCompilationUnit("Varargs.java", content, false, null);
>+
>+		IJavaElement elem= cu.getElementAt(content.indexOf("foo"));
>+		
>+		String lab= getBindingLabel(elem, JavaElementLabels.ALL_DEFAULT);
>+		assertLinkMatch(lab, "foo(int, {{java.lang|String}}...)");
>+
>+		lab= getBindingLabel(elem, JavaElementLabels.M_PARAMETER_NAMES);
>+		assertEqualString(lab, "foo(i, varargs)");
>+
>+		lab= getBindingLabel(elem, JavaElementLabels.M_PARAMETER_TYPES);
>+		assertLinkMatch(lab, "foo(int, {{java.lang|String}}...)");
>+		
>+		lab= getBindingLabel(elem, JavaElementLabels.M_PARAMETER_NAMES | JavaElementLabels.M_PARAMETER_TYPES);
>+		assertLinkMatch(lab, "foo(int i, {{java.lang|String}}... varargs)");
>+		
>+		lab= getBindingLabel(elem, JavaElementLabels.M_PARAMETER_TYPES | JavaElementLabels.USE_RESOLVED);
>+		assertLinkMatch(lab, "foo(int, {{java.lang|String}}...)");
>+	}
>+
>+	public void testMethodLabelVarargsReference0() throws Exception {
>+		IPackageFragmentRoot sourceFolder= JavaProjectHelper.addSourceContainer(fJProject1, "src");
>+		
>+		IPackageFragment pack1= sourceFolder.createPackageFragment("org.test", false, null);
>+		StringBuffer buf= new StringBuffer();
>+		buf.append("package org.test;\n");
>+		buf.append("import java.util.Arrays;\n");
>+		buf.append("public class Varargs {\n");
>+		buf.append("    void foo() {\n");
>+		buf.append("        Arrays.asList();\n");
>+		buf.append("    }\n");
>+		buf.append("}\n");
>+		String content= buf.toString();
>+		ICompilationUnit cu= pack1.createCompilationUnit("Varargs.java", content, false, null);
>+		
>+		IJavaElement elem= cu.codeSelect(content.indexOf("asList"), 0)[0];
>+		
>+		String lab= getBindingLabel(elem, JavaElementLabels.ALL_DEFAULT);
>+		assertEqualString(lab, "asList(T...) &lt;T&gt;");
>+		
>+		lab= getBindingLabel(elem, JavaElementLabels.M_PARAMETER_NAMES);
>+		assertEqualString(lab, "asList(arg0)");
>+		
>+		lab= getBindingLabel(elem, JavaElementLabels.M_PARAMETER_TYPES);
>+		assertEqualString(lab, "asList(T...)");
>+		
>+		lab= getBindingLabel(elem, JavaElementLabels.M_PARAMETER_NAMES | JavaElementLabels.M_PARAMETER_TYPES);
>+		assertEqualString(lab, "asList(T... arg0)");
>+		
>+		lab= getBindingLabel(elem, JavaElementLabels.ALL_DEFAULT | JavaElementLabels.USE_RESOLVED);
>+		assertLinkMatch(lab, "asList({{java.lang|Object}}...) <{{java.lang|Object}}>");
>+		
>+		lab= getBindingLabel(elem, JavaElementLabels.M_PARAMETER_TYPES | JavaElementLabels.USE_RESOLVED);
>+		assertLinkMatch(lab, "asList({{java.lang|Object}}...)");
>+	}
>+
>+	public void testMethodLabelVarargsReference1() throws Exception {
>+		assertMethodLabelVarargsReference("1");
>+	}
>+	
>+	public void testMethodLabelVarargsReference2() throws Exception {
>+		assertMethodLabelVarargsReference("1, 2");
>+	}
>+	
>+	public void testMethodLabelVarargsReference3() throws Exception {
>+		assertMethodLabelVarargsReference("1, 2, new Integer(3)");
>+	}
>+	
>+	private void assertMethodLabelVarargsReference(String args) throws CoreException, JavaModelException {
>+		IPackageFragmentRoot sourceFolder= JavaProjectHelper.addSourceContainer(fJProject1, "src");
>+
>+		IPackageFragment pack1= sourceFolder.createPackageFragment("org.test", false, null);
>+		StringBuffer buf= new StringBuffer();
>+		buf.append("package org.test;\n");
>+		buf.append("import java.util.Arrays;\n");
>+		buf.append("public class Varargs {\n");
>+		buf.append("    void foo() {\n");
>+		buf.append("        Arrays.asList(" + args + ");\n");
>+		buf.append("    }\n");
>+		buf.append("}\n");
>+		String content= buf.toString();
>+		ICompilationUnit cu= pack1.createCompilationUnit("Varargs.java", content, false, null);
>+
>+		IJavaElement elem= cu.codeSelect(content.indexOf("asList"), 0)[0];
>+		
>+		String lab= getBindingLabel(elem, JavaElementLabels.ALL_DEFAULT);
>+		assertEqualString(lab, "asList(T...) &lt;T&gt;");
>+
>+		lab= getBindingLabel(elem, JavaElementLabels.M_PARAMETER_NAMES);
>+		assertEqualString(lab, "asList(arg0)");
>+
>+		lab= getBindingLabel(elem, JavaElementLabels.M_PARAMETER_TYPES);
>+		assertEqualString(lab, "asList(T...)");
>+		
>+		lab= getBindingLabel(elem, JavaElementLabels.M_PARAMETER_NAMES | JavaElementLabels.M_PARAMETER_TYPES);
>+		assertEqualString(lab, "asList(T... arg0)");
>+		
>+		lab= getBindingLabel(elem, JavaElementLabels.ALL_DEFAULT | JavaElementLabels.USE_RESOLVED);
>+		assertLinkMatch(lab, "asList({{java.lang|Integer}}...) <{{java.lang|Integer}}>");
>+		
>+		lab= JavaElementLabels.getTextLabel(elem, JavaElementLabels.M_PARAMETER_TYPES | JavaElementLabels.USE_RESOLVED);
>+		assertEqualString(lab, "asList(Integer...)");
>+	}
>+	
>+	
>+	public void testMethodLabelAnnotatedParameters() throws Exception {
>+		IPackageFragmentRoot sourceFolder= JavaProjectHelper.addSourceContainer(fJProject1, "src");
>+		IPackageFragment pack1= sourceFolder.createPackageFragment("org.test", false, null);
>+		StringBuffer buf= new StringBuffer();
>+		buf.append("package org.test;\n");
>+		buf.append("\n");
>+		buf.append("import java.lang.annotation.Retention;\n");
>+		buf.append("import java.lang.annotation.RetentionPolicy;\n");
>+		buf.append("\n");
>+		buf.append("public class Annotations {\n");
>+		buf.append("    void foo(@Outer(a=@Ann(\"Hello world\\r\\n\\t\\\"<'#@%^&\")) String param) { }\n");
>+		buf.append("    \n");
>+		buf.append("    void foo2(@Ann(value=\"\", cl=Annotations.class, ints={1, 2, -19},\n");
>+		buf.append("            ch='\\0', sh= 0x7FFF, r= @Retention(RetentionPolicy.SOURCE)) String param) { }\n");
>+		buf.append("}\n");
>+		buf.append("@interface Ann {\n");
>+		buf.append("    String value();\n");
>+		buf.append("    Class<?> cl() default Ann.class;\n");
>+		buf.append("    int[] ints() default {1, 2};\n");
>+		buf.append("    char ch() default 'a';\n");
>+		buf.append("    short sh() default 1;\n");
>+		buf.append("    Retention r() default @Retention(RetentionPolicy.CLASS);\n");
>+		buf.append("}\n");
>+		buf.append("@interface Outer {\n");
>+		buf.append("    Ann a();\n");
>+		buf.append("}\n");
>+		String content= buf.toString();
>+		ICompilationUnit cu= pack1.createCompilationUnit("Annotations.java", content, false, null);
>+
>+		IJavaElement foo= cu.getElementAt(content.indexOf("foo"));
>+		String lab= getBindingLabel(foo, JavaElementLabels.ALL_DEFAULT | JavaElementLabels.ALL_FULLY_QUALIFIED | JavaElementLabels.M_PARAMETER_ANNOTATIONS);
>+		assertLinkMatch(lab, "{{org}}.{{test}}.{{Annotations}}.foo(@{{org.test.Outer}}({{a}}=@{{org.test.Ann}}({{value}}=\"Hello world\\r\\n\\t\\\"<'#@%^&\")) {{java.lang.String}})");
>+
>+		IJavaElement foo2= cu.getElementAt(content.indexOf("foo2"));
>+		lab= getBindingLabel(foo2, JavaElementLabels.ALL_DEFAULT | JavaElementLabels.ALL_FULLY_QUALIFIED | JavaElementLabels.M_PARAMETER_ANNOTATIONS);
>+		assertLinkMatch(lab, "{{org}}.{{test}}.{{Annotations}}.foo2(@{{org.test.Ann}}({{value}}=\"\", {{cl}}={{org.test.Annotations}}.class, {{ints}}={1, 2, -19}, {{ch}}='\\u0000', {{sh}}=32767, {{r}}=@{{java.lang.annotation.Retention}}({{value}}={{java}}.{{lang}}.{{annotation}}.{{RetentionPolicy}}.SOURCE)) {{java.lang.String}})");
>+	}
>+}
>diff --git a/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/infoviews/JavadocView.java b/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/infoviews/JavadocView.java
>index 6757de4..34c243d 100644
>--- a/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/infoviews/JavadocView.java
>+++ b/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/infoviews/JavadocView.java
>@@ -150,6 +150,7 @@ import org.eclipse.jdt.internal.ui.text.java.hover.JavadocHover;
> import org.eclipse.jdt.internal.ui.text.java.hover.JavadocHover.FallbackInformationPresenter;
> import org.eclipse.jdt.internal.ui.text.javadoc.JavadocContentAccess2;
> import org.eclipse.jdt.internal.ui.viewsupport.BasicElementLabels;
>+import org.eclipse.jdt.internal.ui.viewsupport.BindingLinkedLabelComposer;
> import org.eclipse.jdt.internal.ui.viewsupport.JavaElementLinks;
> 
> 
>@@ -1155,7 +1156,15 @@ public class JavadocView extends AbstractInfoView {
> 	 * @return a string containing the member's label
> 	 */
> 	private String getInfoText(IJavaElement member, String constantValue, boolean allowImage) {
>-		StringBuffer label= new StringBuffer(JavaElementLinks.getElementLabel(member, JavadocHover.getHeaderFlags(member)));
>+		long flags= JavadocHover.getHeaderFlags(member);
>+		IBinding binding= JavadocHover.getHoverBinding(member, null);
>+		StringBuffer label;
>+		if (binding != null) {
>+			label= new StringBuffer();
>+			new BindingLinkedLabelComposer(member, label).appendBindingLabel(binding, flags);
>+		} else {
>+			label= new StringBuffer(JavaElementLinks.getElementLabel(member, flags));
>+		}
> 		if (member.getElementType() == IJavaElement.FIELD && constantValue != null) {
> 			label.append(constantValue);
> 		}
>diff --git a/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/text/java/hover/JavadocHover.java b/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/text/java/hover/JavadocHover.java
>index 5288fe2..fe25f1e 100644
>--- a/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/text/java/hover/JavadocHover.java
>+++ b/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/text/java/hover/JavadocHover.java
>@@ -73,6 +73,7 @@ import org.eclipse.jdt.core.IMember;
> import org.eclipse.jdt.core.IPackageDeclaration;
> import org.eclipse.jdt.core.IPackageFragment;
> import org.eclipse.jdt.core.IPackageFragmentRoot;
>+import org.eclipse.jdt.core.ISourceReference;
> import org.eclipse.jdt.core.ITypeParameter;
> import org.eclipse.jdt.core.ITypeRoot;
> import org.eclipse.jdt.core.JavaCore;
>@@ -759,8 +760,17 @@ public class JavadocHover extends AbstractJavaEditorTextHover {
> 
> 	private static String getInfoText(IJavaElement element, ITypeRoot editorInputElement, IRegion hoverRegion, boolean allowImage) {
> 		long flags= getHeaderFlags(element);
>-		StringBuffer label= new StringBuffer(JavaElementLinks.getElementLabel(element, flags));
> 		
>+		ASTNode node= (editorInputElement instanceof ICompilationUnit) ? getHoveredASTNode(editorInputElement, hoverRegion) : null;
>+		IBinding binding= getHoverBinding(element, node);
>+
>+		StringBuffer label;
>+		if (binding != null) {
>+			label= new StringBuffer(JavaElementLinks.getBindingLabel(binding, element, flags));
>+		} else {
>+			label= new StringBuffer(JavaElementLinks.getElementLabel(element, flags));
>+		}
>+
> 		if (element.getElementType() == IJavaElement.FIELD) {
> 			String constantValue= getConstantValue((IField) element, editorInputElement, hoverRegion);
> 			if (constantValue != null) {
>@@ -778,6 +788,34 @@ public class JavadocHover extends AbstractJavaEditorTextHover {
> 
> 		return getImageAndLabel(element, allowImage, label.toString());
> 	}
>+
>+	/**
>+	 * Try to acquire a binding corresponding to the given element 
>+	 * for more precise information about (type) annotations.
>+	 * @param element the element being rendered
>+	 * @param node the AST node corresponding to the given element, or null, if no AST node is available.
>+	 * @return either a binding corresponding to the given element or null.
>+	 */
>+	public static IBinding getHoverBinding(IJavaElement element, ASTNode node) {
>+
>+		if (element.getJavaProject().getOption(JavaCore.COMPILER_ANNOTATION_NULL_ANALYSIS, true).equals(JavaCore.ENABLED)) {
>+			if (node == null) {
>+				if (element instanceof ISourceReference) {
>+					ASTParser p= ASTParser.newParser(ASTProvider.SHARED_AST_LEVEL);
>+					p.setProject(element.getJavaProject());
>+					p.setBindingsRecovery(true);
>+					try {
>+						return p.createBindings(new IJavaElement[] { element }, null)[0];
>+					} catch (OperationCanceledException e) {
>+						return null;
>+					}
>+				}
>+			} else {
>+				return resolveBinding(node);
>+			}
>+		}
>+		return null;
>+	}
> 	
> 	private static String getImageURL(IJavaElement element) {
> 		String imageName= null;
>diff --git a/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/viewsupport/BindingLinkedLabelComposer.java b/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/viewsupport/BindingLinkedLabelComposer.java
>new file mode 100644
>index 0000000..d52031c
>--- /dev/null
>+++ b/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/viewsupport/BindingLinkedLabelComposer.java
>@@ -0,0 +1,480 @@
>+package org.eclipse.jdt.internal.ui.viewsupport;
>+
>+import static org.eclipse.jdt.internal.ui.viewsupport.JavaElementLinks.JAVADOC_SCHEME;
>+import static org.eclipse.jdt.internal.ui.viewsupport.JavaElementLinks.createHeaderLink;
>+import static org.eclipse.jdt.internal.ui.viewsupport.JavaElementLinks.createURI;
>+
>+import java.net.URISyntaxException;
>+
>+import org.eclipse.jface.viewers.StyledString;
>+
>+import org.eclipse.jdt.core.Flags;
>+import org.eclipse.jdt.core.IField;
>+import org.eclipse.jdt.core.IInitializer;
>+import org.eclipse.jdt.core.IJavaElement;
>+import org.eclipse.jdt.core.IMethod;
>+import org.eclipse.jdt.core.IType;
>+import org.eclipse.jdt.core.JavaModelException;
>+import org.eclipse.jdt.core.dom.IAnnotationBinding;
>+import org.eclipse.jdt.core.dom.IBinding;
>+import org.eclipse.jdt.core.dom.IMemberValuePairBinding;
>+import org.eclipse.jdt.core.dom.IMethodBinding;
>+import org.eclipse.jdt.core.dom.IPackageBinding;
>+import org.eclipse.jdt.core.dom.ITypeBinding;
>+import org.eclipse.jdt.core.dom.IVariableBinding;
>+
>+import org.eclipse.jdt.internal.corext.dom.ASTNodes;
>+import org.eclipse.jdt.internal.corext.util.JavaModelUtil;
>+import org.eclipse.jdt.internal.corext.util.Messages;
>+
>+import org.eclipse.jdt.ui.JavaElementLabels;
>+
>+import org.eclipse.jdt.internal.ui.JavaPlugin;
>+import org.eclipse.jdt.internal.ui.JavaUIMessages;
>+import org.eclipse.jdt.internal.ui.viewsupport.JavaElementLinks.JavaElementLinkedLabelComposer;
>+
>+public class BindingLinkedLabelComposer extends JavaElementLinkedLabelComposer {
>+
>+	private IJavaElement fEnclosingElement;
>+
>+	public BindingLinkedLabelComposer(IJavaElement enclosingElement, StringBuffer buffer) {
>+		super(enclosingElement, buffer);
>+		fEnclosingElement= enclosingElement;
>+	}
>+
>+	/**
>+	 * <p>Supported flags:
>+	 * <ul>
>+	 * <li>{@link JavaElementLabels#ALL_FULLY_QUALIFIED} (set)</li>
>+	 * <li>{@link JavaElementLabels#M_PRE_RETURNTYPE}</li>
>+	 * <li>{@link JavaElementLabels#M_PARAMETER_ANNOTATIONS}</li>
>+ 	 * <li>{@link JavaElementLabels#M_PARAMETER_TYPES}</li>
>+	 * <li>{@link JavaElementLabels#M_PARAMETER_NAMES}</li>
>+	 * <li>{@link JavaElementLabels#M_EXCEPTIONS}</li>
>+	 * <li>{@link JavaElementLabels#F_PRE_TYPE_SIGNATURE}</li>
>+	 * <li>{@link JavaElementLabels#M_PRE_TYPE_PARAMETERS}</li>
>+	 * <li>{@link JavaElementLabels#T_TYPE_PARAMETERS}</li>
>+	 * <li>{@link JavaElementLabels#USE_RESOLVED}</li>
>+	 * <li>{@link JavaElementLabels#F_POST_QUALIFIED}</li>
>+	 * <li>{@link JavaElementLabels#TP_POST_QUALIFIED}</li>
>+	 * </ul>
>+	 * @param binding a binding to be rendered
>+	 * @param flags rendering flags, see above for supported values.
>+	 */
>+	public void appendBindingLabel(IBinding binding, long flags) {
>+		switch (binding.getKind()) {
>+			case IBinding.METHOD:
>+				appendMethodBindingLabel((IMethodBinding) binding, flags);
>+				return;
>+			case IBinding.TYPE:
>+				appendTypeBindingLabel((ITypeBinding) binding, flags); // TODO: compare w/ JavaElementLabelComposer.appendTypeLabel(IType, long)
>+				return;
>+			case IBinding.VARIABLE:
>+				appendVariableLabel((IVariableBinding) binding, flags);
>+				return;
>+			case IBinding.PACKAGE:
>+				appendPackageLabel((IPackageBinding) binding, flags);
>+				break;
>+			default:
>+				throw new IllegalArgumentException("Unsupported binding kind "+binding); // FIXME
>+		}
>+		
>+	}
>+
>+	private void appendMethodBindingLabel(IMethodBinding method, long flags) {
>+		if (method.isParameterizedMethod() && !getFlag(flags, JavaElementLabels.USE_RESOLVED))
>+			method= method.getMethodDeclaration();
>+		// type parameters
>+		if (getFlag(flags, JavaElementLabels.M_PRE_TYPE_PARAMETERS)) {
>+			appendTypeArgumentsBindingLabel(method.getTypeParameters(), null, flags);
>+			fBuffer.append(' ');
>+		}
>+		
>+		// return type
>+		if (getFlag(flags, JavaElementLabels.M_PRE_RETURNTYPE) && !method.isConstructor()) {
>+			appendTypeBindingLabel(method.getReturnType(), flags);
>+			fBuffer.append(' ');
>+		}
>+		
>+		// qualification
>+		if (getFlag(flags, JavaElementLabels.M_FULLY_QUALIFIED)) {
>+			// TODO: still Java-model-based:
>+			appendTypeLabel((IType) fEnclosingElement.getParent(), JavaElementLabels.T_FULLY_QUALIFIED | (flags & QUALIFIER_FLAGS));
>+			fBuffer.append('.');
>+		}
>+
>+		fBuffer.append(method.getName());
>+		
>+		// constructor type arguments
>+		if (getFlag(flags, JavaElementLabels.T_TYPE_PARAMETERS) && method.isConstructor()) {
>+			appendTypeArgumentsBindingLabel(method.getTypeArguments(), null, flags);
>+		}
>+		
>+		// parameters
>+		fBuffer.append('(');
>+		if (getFlag(flags, JavaElementLabels.M_PARAMETER_TYPES | JavaElementLabels.M_PARAMETER_NAMES)) {
>+			ITypeBinding[] types= null;
>+			int nParams= 0;
>+			boolean renderVarargs= false;
>+			boolean isPolymorphic= false;
>+			if (getFlag(flags, JavaElementLabels.M_PARAMETER_TYPES) || getFlag(flags, JavaElementLabels.M_PARAMETER_NAMES)) {
>+				if (getFlag(flags, JavaElementLabels.M_PARAMETER_TYPES)) {
>+					types= method.getParameterTypes();
>+					nParams= types.length;
>+					renderVarargs= method.isVarargs();
>+					if (fEnclosingElement instanceof IMethod) {
>+						// retrieval of flag isPolymorphic uses strategy from JavaElementLabelComposer:
>+						IMethod iMethod= (IMethod) fEnclosingElement;
>+						if (iMethod.getParameterTypes().length == 1
>+								&& JavaModelUtil.isPolymorphicSignature(iMethod)) {
>+							renderVarargs= false;
>+							isPolymorphic= true;
>+						}
>+					}
>+				}
>+				String[] names= null;
>+				if (getFlag(flags, JavaElementLabels.M_PARAMETER_NAMES) && fEnclosingElement instanceof IMethod) {
>+					// mostly from JavaElementLabelComposer:
>+					try {
>+						names= ((IMethod) fEnclosingElement).getParameterNames();
>+					} catch (JavaModelException e) {
>+						JavaPlugin.log(e);
>+					}
>+					if (isPolymorphic) {
>+						// handled specially below
>+					} else	if (types == null) {
>+						nParams= names.length;
>+					} else { // types != null
>+						if (nParams != names.length) {
>+							if (types.length > names.length) {
>+								// see https://bugs.eclipse.org/bugs/show_bug.cgi?id=99137
>+								nParams= names.length;
>+								ITypeBinding[] typesWithoutSyntheticParams= new ITypeBinding[nParams];
>+								System.arraycopy(types, types.length - nParams, typesWithoutSyntheticParams, 0, nParams);
>+								types= typesWithoutSyntheticParams;
>+							} else {
>+								// https://bugs.eclipse.org/bugs/show_bug.cgi?id=101029
>+								// JavaPlugin.logErrorMessage("JavaElementLabels: Number of param types(" + nParams + ") != number of names(" + names.length + "): " + method.getElementName());   //$NON-NLS-1$//$NON-NLS-2$//$NON-NLS-3$
>+								names= null; // no names rendered
>+							}
>+						}
>+					}
>+				}
>+				IAnnotationBinding[][] parameterAnnotations= null;
>+				if (nParams > 0 && getFlag(flags, JavaElementLabels.M_PARAMETER_ANNOTATIONS)) {
>+					parameterAnnotations= new IAnnotationBinding[nParams][];
>+					for (int i= 0; i < nParams; i++) {						
>+						parameterAnnotations[i]= method.getParameterAnnotations(i);
>+					}
>+				}
>+
>+				for (int i= 0; i < nParams; i++) {
>+					if (i > 0)
>+						fBuffer.append(JavaElementLabels.COMMA_STRING);
>+					if (parameterAnnotations != null && i < parameterAnnotations.length) {
>+						appendAnnotationLabels(parameterAnnotations[i], flags);
>+					}
>+
>+					if (types != null) {
>+						ITypeBinding paramSig= types[i];
>+						if (renderVarargs && (i == nParams - 1)) {
>+							int newDim= paramSig.getDimensions() - 1;
>+							appendTypeBindingLabel(paramSig.getElementType(), flags);
>+							for (int k= 0; k < newDim; k++) {
>+								fBuffer.append('[').append(']');
>+							}
>+							fBuffer.append(JavaElementLabels.ELLIPSIS_STRING);
>+						} else {
>+							appendTypeBindingLabel(paramSig, flags);
>+						}
>+					}
>+					if (names != null) {
>+						if (types != null) {
>+							fBuffer.append(' ');
>+						}
>+						if (isPolymorphic) {
>+							fBuffer.append(names[0] + i);
>+						} else {
>+							fBuffer.append(names[i]);
>+						}
>+					}
>+				}
>+			}
>+		} else {
>+			if (method.getParameterTypes().length > 0) {
>+				fBuffer.append(JavaElementLabels.ELLIPSIS_STRING);
>+			}
>+		}
>+		fBuffer.append(')');
>+
>+
>+		if (getFlag(flags, JavaElementLabels.M_EXCEPTIONS)) {
>+			ITypeBinding[] types= method.getExceptionTypes();
>+			if (types.length > 0) {
>+				fBuffer.append(" throws "); //$NON-NLS-1$
>+				for (int i= 0; i < types.length; i++) {
>+					if (i > 0)
>+						fBuffer.append(JavaElementLabels.COMMA_STRING);
>+					appendTypeBindingLabel(types[i], flags);
>+				}
>+			}
>+		}
>+
>+		if (getFlag(flags, JavaElementLabels.M_APP_TYPE_PARAMETERS)) {
>+			int offset= fBuffer.length();
>+			ITypeBinding[] typeParameters= method.isParameterizedMethod() ? method.getTypeArguments() : method.getTypeParameters();
>+			appendTypeArgumentsBindingLabel(typeParameters, String.valueOf(' '), flags);
>+			if (getFlag(flags, JavaElementLabels.COLORIZE) && offset != fBuffer.length()) {
>+				fBuffer.setStyle(offset, fBuffer.length() - offset, StyledString.DECORATIONS_STYLER);
>+			}
>+		}
>+	}
>+
>+	private void appendVariableLabel(IVariableBinding variable, long flags) {
>+		if (getFlag(flags, JavaElementLabels.F_PRE_TYPE_SIGNATURE) && !Flags.isEnum(variable.getModifiers())) {
>+			appendTypeBindingLabel(variable.getType(), flags);
>+			fBuffer.append(' ');
>+		}
>+
>+		// qualification
>+		if (variable.isField() && getFlag(flags, JavaElementLabels.F_FULLY_QUALIFIED)) {
>+			// Java-model-based:
>+			appendTypeLabel((IType) variable.getJavaElement().getParent(), JavaElementLabels.T_FULLY_QUALIFIED | (flags & QUALIFIER_FLAGS));
>+			fBuffer.append('.');
>+		}
>+		fBuffer.append(variable.getName());
>+	}
>+
>+	private void appendTypeArgumentsBindingLabel(ITypeBinding[] parameters, String separator, long flags) {
>+		if (parameters.length > 0) {
>+			if (separator != null)
>+				fBuffer.append(separator);
>+			fBuffer.append(getLT());
>+			for (int i = 0; i < parameters.length; i++) {
>+				if (i > 0)
>+					fBuffer.append(JavaElementLabels.COMMA_STRING);
>+				appendTypeBindingLabel(parameters[i], flags);
>+			}
>+			fBuffer.append(getGT());
>+		}
>+	}
>+
>+	private void appendTypeBindingLabel(ITypeBinding typeBinding, long flags) {
>+		if (!typeBinding.isArray()) { // different textual order for type annotations on array types
>+			appendAnnotationLabels(typeBinding.getTypeAnnotations(), flags);
>+		}
>+		if (typeBinding.isPrimitive()) {
>+			fBuffer.append(typeBinding.getName());
>+		} else if (typeBinding.isArray()) {
>+			appendTypeBindingLabel(typeBinding.getElementType(), flags);
>+			IAnnotationBinding[] typeAnnotations= typeBinding.getTypeAnnotations();
>+			if (typeAnnotations.length > 0) {
>+				fBuffer.append(' ');
>+				appendAnnotationLabels(typeAnnotations, flags);
>+			}
>+			for (int dim= typeBinding.getDimensions(); dim > 0; dim--) {
>+				fBuffer.append('[').append(']');
>+			}
>+		} else if (typeBinding.isClass() || typeBinding.isInterface() || typeBinding.isEnum()) {
>+			fBuffer.append(getTypeLink(typeBinding, flags));
>+			ITypeBinding[] typeArguments= typeBinding.getTypeArguments();
>+			if (typeArguments.length > 0) {
>+				appendTypeArgumentsBindingLabel(typeArguments, null, flags);
>+			} else if (getFlag(flags, JavaElementLabels.T_TYPE_PARAMETERS)) {
>+				ITypeBinding[] typeParameters= typeBinding.getTypeParameters();
>+				appendTypeArgumentsBindingLabel(typeParameters, null, flags);
>+			}
>+		} else if (typeBinding.isParameterizedType()) {
>+			fBuffer.append(getTypeLink(typeBinding.getTypeDeclaration(), flags));
>+			fBuffer.append(getLT());
>+			ITypeBinding[] typeArguments= typeBinding.getTypeArguments();
>+			for (int i= 0; i < typeArguments.length; i++) {
>+				if (i > 0)
>+					fBuffer.append(JavaElementLabels.COMMA_STRING);
>+				appendTypeBindingLabel(typeArguments[i], flags);
>+			}
>+			fBuffer.append(getGT());
>+		} else if (typeBinding.isTypeVariable()) {
>+			fBuffer.append(typeBinding.getName());
>+			ITypeBinding[] bounds= typeBinding.getTypeBounds();
>+			if (hasRelevantBound(bounds)) {
>+				fBuffer.append(" extends "); //$NON-NLS-1$
>+				for (int i= 0; i < bounds.length; i++) {
>+					if (i > 0)
>+						fBuffer.append(" &amp; "); //$NON-NLS-1$
>+					appendTypeBindingLabel(bounds[i], flags);
>+				}
>+			}
>+		} else if (typeBinding.isAnnotation()) {
>+			fBuffer.append(getTypeLink(typeBinding, flags));
>+		} else if (typeBinding.isWildcardType()) {
>+			ITypeBinding bound= typeBinding.getBound();
>+			if (bound == null || bound.getSuperclass() == null) { // no relevant bound / only j.l.Object
>+				fBuffer.append('?');
>+			} else {
>+				if (typeBinding.isUpperbound())
>+					fBuffer.append("? extends "); //$NON-NLS-1$
>+				else
>+					fBuffer.append("? super "); //$NON-NLS-1$
>+				appendTypeBindingLabel(bound, flags);
>+			}
>+		} else if (typeBinding.isCapture()) {
>+			appendTypeBindingLabel(typeBinding.getWildcard(), flags);
>+		}
>+		// TODO: intersection type
>+	}
>+	
>+	// only relevant bound / ignore j.l.Object
>+	private boolean hasRelevantBound(ITypeBinding[] bounds) {
>+		if (bounds != null) {
>+			for (int i= 0; i < bounds.length; i++)
>+				if (bounds[i].isInterface() || bounds[i].getSuperclass() != null)
>+					return true;
>+		}
>+		return false;
>+	}
>+
>+	private String getTypeLink(ITypeBinding typeBinding, long flags) {
>+		typeBinding= typeBinding.getTypeDeclaration();
>+		String typeName = getTypeName(typeBinding, flags);
>+		String qualifiedName = getTypeName(typeBinding, JavaElementLabels.T_FULLY_QUALIFIED);
>+		String title= ""; //$NON-NLS-1$
>+		int qualifierLength= qualifiedName.length() - typeName.length() - 1;
>+		if (qualifierLength > 0) {
>+			if (qualifiedName.endsWith(typeName)) {
>+				title= qualifiedName.substring(0, qualifierLength);
>+				title= Messages.format(JavaUIMessages.JavaElementLinks_title, title);
>+			} else {
>+				title= qualifiedName; // Not expected. Just show the whole qualifiedName.
>+			}
>+		}
>+		
>+		try {
>+			String uri= createURI(JAVADOC_SCHEME, fEnclosingElement, qualifiedName, null, null);
>+			return createHeaderLink(uri, typeName, title);
>+		} catch (URISyntaxException e) {
>+			JavaPlugin.log(e);
>+			return typeName;
>+		}
>+	}
>+
>+	private String getTypeName(ITypeBinding typeBinding, long flags) {
>+		if (typeBinding.isLocal()) {
>+			StringBuilder buf= new StringBuilder();
>+			IMethodBinding declaringMethod= typeBinding.getDeclaringMethod();
>+			if (getFlag(flags, JavaElementLabels.T_FULLY_QUALIFIED|JavaElementLabels.T_CONTAINER_QUALIFIED)) {
>+				if (declaringMethod != null) {
>+					buf.append(getTypeName(declaringMethod.getDeclaringClass(), flags));
>+					buf.append('.');
>+					buf.append(declaringMethod.getName());
>+					if (declaringMethod.getParameterTypes().length > 0) {
>+						buf.append("(...)."); //$NON-NLS-1$
>+					} else {
>+						buf.append("()."); //$NON-NLS-1$
>+					}
>+				} else {
>+					buf.append(getTypeName(typeBinding.getDeclaringClass(), flags));
>+					IJavaElement parent= fEnclosingElement.getParent();
>+					if (parent instanceof IField) {
>+						buf.append('.').append(parent.getElementName()).append('.');
>+					} else if (parent instanceof IInitializer){
>+						buf.append(".{...}."); //$NON-NLS-1$
>+					} else {
>+						throw new IllegalStateException("Unexpected parent of local class: "+parent);
>+					}
>+				}
>+			}
>+			if (typeBinding.isAnonymous()) {
>+				buf.append("new "); //$NON-NLS-1$
>+				ITypeBinding[] interfaces= typeBinding.getInterfaces();
>+				if (interfaces.length > 0) {
>+					buf.append(interfaces[0].getName());
>+				} else if (typeBinding.getSuperclass() != null){
>+					buf.append(typeBinding.getSuperclass().getName());
>+				} else {
>+					buf.append("MISSING"); //$NON-NLS-1$
>+				}
>+				buf.append("() {...}"); //$NON-NLS-1$
>+			} else {
>+				buf.append(typeBinding.getName());
>+			}
>+			return buf.toString();
>+		}
>+		if (getFlag(flags, JavaElementLabels.T_FULLY_QUALIFIED)) {
>+			return typeBinding.getQualifiedName();
>+		} else if (getFlag(flags, JavaElementLabels.T_CONTAINER_QUALIFIED)) {
>+			ITypeBinding declaringClass= typeBinding.getDeclaringClass();
>+			if (declaringClass != null) {
>+				StringBuilder buf= new StringBuilder(getTypeName(declaringClass, flags));
>+				buf.append('.');
>+				buf.append(typeBinding.getName());
>+				return buf.toString();
>+			}
>+		}
>+		return typeBinding.getName();
>+	}
>+
>+	private void appendAnnotationLabels(IAnnotationBinding[] annotationBindings, long flags) {
>+		for (int i= 0; i < annotationBindings.length; i++) {
>+			appendAnnotationLabel(annotationBindings[i], flags);
>+			fBuffer.append(' ');
>+		}
>+	}
>+
>+	private void appendAnnotationLabel(IAnnotationBinding annotation, long flags) {
>+		fBuffer.append('@');
>+		appendTypeBindingLabel(annotation.getAnnotationType(), flags);
>+		IMemberValuePairBinding[] memberValuePairs= annotation.getDeclaredMemberValuePairs();
>+		if (memberValuePairs.length == 0)
>+			return;
>+		fBuffer.append('(');
>+		for (int i= 0; i < memberValuePairs.length; i++) {
>+			if (i > 0)
>+				fBuffer.append(JavaElementLabels.COMMA_STRING);
>+			IMemberValuePairBinding memberValuePair= memberValuePairs[i];
>+			fBuffer.append(getMemberName(fEnclosingElement, annotation.getName(), memberValuePair.getName()));
>+			fBuffer.append('=');
>+			appendAnnotationValue(annotation, memberValuePair.getValue(), flags);
>+		}
>+		fBuffer.append(')');
>+	}
>+
>+	private void appendAnnotationValue(IAnnotationBinding annotation, Object value, long flags) {
>+		// Note: To be bug-compatible with Javadoc from Java 5/6/7, we currently don't escape HTML tags in String-valued annotations.
>+		if (value instanceof Object[]) {
>+			fBuffer.append('{');
>+			Object[] values= (Object[]) value;
>+			for (int j= 0; j < values.length; j++) {
>+				if (j > 0)
>+					fBuffer.append(JavaElementLabels.COMMA_STRING);
>+				value= values[j];
>+				appendAnnotationValue(annotation, value, flags);
>+			}
>+			fBuffer.append('}');
>+		} else {
>+			if (value instanceof ITypeBinding) {
>+				appendTypeBindingLabel((ITypeBinding) value, flags);
>+				fBuffer.append(".class"); //$NON-NLS-1$
>+			} else if (value instanceof String) {
>+				fBuffer.append(ASTNodes.getEscapedStringLiteral((String) value).replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;")); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$ //$NON-NLS-6$
>+			} else if (value instanceof IVariableBinding) {
>+				appendVariableLabel((IVariableBinding) value, flags);
>+			} else if (value instanceof IAnnotationBinding) {
>+				appendAnnotationLabel((IAnnotationBinding) value, flags);
>+			} else if (value instanceof Character) {
>+				fBuffer.append(ASTNodes.getEscapedCharacterLiteral(((Character) value).charValue()));
>+			} else { // other primitive literals
>+				fBuffer.append(String.valueOf(value));
>+			}
>+		}
>+	}
>+
>+	private void appendPackageLabel(IPackageBinding binding, long flags) {
>+		appendAnnotationLabels(binding.getAnnotations(), flags);
>+		String qualifiedName= binding.getName();
>+		if (qualifiedName.length() > 0)
>+			fBuffer.append(qualifiedName);
>+		else
>+			fBuffer.append("(default package)"); //$NON-NLS-1$
>+	}
>+}
>diff --git a/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/viewsupport/JavaElementLabelComposer.java b/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/viewsupport/JavaElementLabelComposer.java
>index 02b7554..d38cc44 100644
>--- a/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/viewsupport/JavaElementLabelComposer.java
>+++ b/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/viewsupport/JavaElementLabelComposer.java
>@@ -196,7 +196,7 @@ public class JavaElementLabelComposer {
> 	}
> 
> 
>-	private final static long QUALIFIER_FLAGS= JavaElementLabels.P_COMPRESSED | JavaElementLabels.USE_RESOLVED;
>+	final static long QUALIFIER_FLAGS= JavaElementLabels.P_COMPRESSED | JavaElementLabels.USE_RESOLVED;
> 
> 	private static final Styler QUALIFIER_STYLE= StyledString.QUALIFIER_STYLER;
> 	private static final Styler COUNTER_STYLE= StyledString.COUNTER_STYLER;
>@@ -219,7 +219,7 @@ public class JavaElementLabelComposer {
> 
> 	protected final FlexibleBuffer fBuffer;
> 
>-	private static final boolean getFlag(long flags, long flag) {
>+	protected static final boolean getFlag(long flags, long flag) {
> 		return (flags & flag) != 0;
> 	}
> 
>diff --git a/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/viewsupport/JavaElementLinks.java b/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/viewsupport/JavaElementLinks.java
>index 43add76..1f2be0e 100644
>--- a/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/viewsupport/JavaElementLinks.java
>+++ b/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/viewsupport/JavaElementLinks.java
>@@ -39,6 +39,7 @@ import org.eclipse.jdt.core.ITypeParameter;
> import org.eclipse.jdt.core.JavaCore;
> import org.eclipse.jdt.core.JavaModelException;
> import org.eclipse.jdt.core.Signature;
>+import org.eclipse.jdt.core.dom.IBinding;
> 
> import org.eclipse.jdt.internal.corext.util.JavaModelUtil;
> import org.eclipse.jdt.internal.corext.util.Messages;
>@@ -102,7 +103,7 @@ public class JavaElementLinks {
> 		void handleTextSet();
> 	}
> 
>-	private static final class JavaElementLinkedLabelComposer extends JavaElementLabelComposer {
>+	static class JavaElementLinkedLabelComposer extends JavaElementLabelComposer {
> 		private final IJavaElement fElement;
> 
> 		public JavaElementLinkedLabelComposer(IJavaElement member, StringBuffer buf) {
>@@ -665,7 +666,7 @@ public class JavaElementLinks {
> 	 * @return the HTML link
> 	 * @since 3.10
> 	 */
>-	private static String createHeaderLink(String uri, String label, String title) {
>+	public static String createHeaderLink(String uri, String label, String title) {
> 		if (title.length() > 0) {
> 			title= " title='" + title + "'";  //$NON-NLS-1$ //$NON-NLS-2$
> 		}
>@@ -708,4 +709,28 @@ public class JavaElementLinks {
> 			return label.replaceAll("<", "&lt;").replaceAll(">", "&gt;"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
> 		}
> 	}
>+
>+	/**
>+	 * Returns the label for a binding with the flags as defined by {@link JavaElementLabels}.
>+	 * Referenced element names in the label are rendered as header links.
>+	 *
>+	 * @param binding the binding to render
>+	 * @param element the corresponding Java element, used for javadoc hyperlinks
>+	 * @param flags the rendering flags
>+	 * @return the label of the binding
>+	 * @since 3.11
>+	 */
>+	public static String getBindingLabel(IBinding binding, IJavaElement element, long flags) {
>+		StringBuffer buf= new StringBuffer();
>+
>+		if (!Strings.USE_TEXT_PROCESSOR) {
>+			new BindingLinkedLabelComposer(element, buf).appendBindingLabel(binding, flags);
>+			return Strings.markJavaElementLabelLTR(buf.toString());
>+		} else {
>+			// TODO ?
>+			return "";
>+//			String label= JavaElementLabels.getElementLabel(element, flags);
>+//			return label.replaceAll("<", "&lt;").replaceAll(">", "&gt;"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
>+		}
>+	}
> }

Actions: View | Diff

Attachments on bug 403917: 251199 | 251569 | 252167 | 252324 | 252516 | 252659