Java tutorial
/******************************************************************************* * 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 * Guven Demir <guven.internet+eclipse@gmail.com> - [package explorer] Alternative package name shortening: abbreviation - https://bugs.eclipse.org/bugs/show_bug.cgi?id=299514 *******************************************************************************/ package com.microsoft.javapkgsrv; import java.util.ArrayList; import java.util.Collections; import java.util.Comparator; import java.util.jar.Attributes.Name; import org.eclipse.core.runtime.IPath; import org.eclipse.core.resources.IProject; import org.eclipse.core.resources.IResource; //import org.eclipse.jface.preference.IPreferenceStore; //import org.eclipse.jface.viewers.StyledString; //import org.eclipse.jface.viewers.StyledString.Styler; import org.eclipse.jdt.core.BindingKey; import org.eclipse.jdt.core.Flags; import org.eclipse.jdt.core.IAnnotation; import org.eclipse.jdt.core.IClassFile; import org.eclipse.jdt.core.IClasspathEntry; import org.eclipse.jdt.core.ICompilationUnit; import org.eclipse.jdt.core.IField; import org.eclipse.jdt.core.IInitializer; import org.eclipse.jdt.core.IJavaElement; import org.eclipse.jdt.core.ILocalVariable; import org.eclipse.jdt.core.IMember; import org.eclipse.jdt.core.IMemberValuePair; import org.eclipse.jdt.core.IMethod; import org.eclipse.jdt.core.IPackageFragment; import org.eclipse.jdt.core.IPackageFragmentRoot; import org.eclipse.jdt.core.ISourceRange; import org.eclipse.jdt.core.IType; import org.eclipse.jdt.core.ITypeParameter; import org.eclipse.jdt.core.JavaModelException; import org.eclipse.jdt.core.Signature; import org.eclipse.jdt.core.SourceRange; import org.eclipse.jdt.core.dom.AST; import org.eclipse.jdt.core.dom.CharacterLiteral; import org.eclipse.jdt.core.dom.StringLiteral; //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.ui.PreferenceConstants; //import org.eclipse.jdt.internal.ui.JavaPlugin; //import org.eclipse.jdt.internal.ui.JavaUIMessages; /** * Implementation of {@link JavaElementLabels}. * * @since 3.5 */ public class JavaElementLabelComposer { /** * An adapter for buffer supported by the label composer. */ public static abstract class FlexibleBuffer { /** * Appends the string representation of the given character to the buffer. * * @param ch the character to append * @return a reference to this object */ public abstract FlexibleBuffer append(char ch); /** * Appends the given string to the buffer. * * @param string the string to append * @return a reference to this object */ public abstract FlexibleBuffer append(String string); /** * Returns the length of the the buffer. * * @return the length of the current string */ public abstract int length(); } public static class FlexibleStringBuffer extends FlexibleBuffer { private final StringBuffer fStringBuffer; public FlexibleStringBuffer(StringBuffer stringBuffer) { fStringBuffer = stringBuffer; } @Override public FlexibleBuffer append(char ch) { fStringBuffer.append(ch); return this; } @Override public FlexibleBuffer append(String string) { fStringBuffer.append(string); return this; } @Override public int length() { return fStringBuffer.length(); } @Override public String toString() { return fStringBuffer.toString(); } } private static class PackageNameAbbreviation { private String fPackagePrefix; private String fAbbreviation; public PackageNameAbbreviation(String packagePrefix, String abbreviation) { fPackagePrefix = packagePrefix; fAbbreviation = abbreviation; } public String getPackagePrefix() { return fPackagePrefix; } public String getAbbreviation() { return fAbbreviation; } } /** * Method names contain parameter types. * e.g. <code>foo(int)</code> */ public final static long M_PARAMETER_TYPES = 1L << 0; /** * Method names contain parameter names. * e.g. <code>foo(index)</code> */ public final static long M_PARAMETER_NAMES = 1L << 1; /** * Method labels contain parameter annotations. * E.g. <code>foo(@NonNull int)</code>. * This flag is only valid if {@link #M_PARAMETER_NAMES} or {@link #M_PARAMETER_TYPES} is also set. * @since 3.8 */ public final static long M_PARAMETER_ANNOTATIONS = 1L << 52; /** * Method names contain type parameters prepended. * e.g. <code><A> foo(A index)</code> */ public final static long M_PRE_TYPE_PARAMETERS = 1L << 2; /** * Method names contain type parameters appended. * e.g. <code>foo(A index) <A></code> */ public final static long M_APP_TYPE_PARAMETERS = 1L << 3; /** * Method names contain thrown exceptions. * e.g. <code>foo throws IOException</code> */ public final static long M_EXCEPTIONS = 1L << 4; /** * Method names contain return type (appended) * e.g. <code>foo : int</code> */ public final static long M_APP_RETURNTYPE = 1L << 5; /** * Method names contain return type (appended) * e.g. <code>int foo</code> */ public final static long M_PRE_RETURNTYPE = 1L << 6; /** * Method names are fully qualified. * e.g. <code>java.util.Vector.size</code> */ public final static long M_FULLY_QUALIFIED = 1L << 7; /** * Method names are post qualified. * e.g. <code>size - java.util.Vector</code> */ public final static long M_POST_QUALIFIED = 1L << 8; /** * Initializer names are fully qualified. * e.g. <code>java.util.Vector.{ ... }</code> */ public final static long I_FULLY_QUALIFIED = 1L << 10; /** * Type names are post qualified. * e.g. <code>{ ... } - java.util.Map</code> */ public final static long I_POST_QUALIFIED = 1L << 11; /** * Field names contain the declared type (appended) * e.g. <code>fHello : int</code> */ public final static long F_APP_TYPE_SIGNATURE = 1L << 14; /** * Field names contain the declared type (prepended) * e.g. <code>int fHello</code> */ public final static long F_PRE_TYPE_SIGNATURE = 1L << 15; /** * Fields names are fully qualified. * e.g. <code>java.lang.System.out</code> */ public final static long F_FULLY_QUALIFIED = 1L << 16; /** * Fields names are post qualified. * e.g. <code>out - java.lang.System</code> */ public final static long F_POST_QUALIFIED = 1L << 17; /** * Type names are fully qualified. * e.g. <code>java.util.Map.Entry</code> */ public final static long T_FULLY_QUALIFIED = 1L << 18; /** * Type names are type container qualified. * e.g. <code>Map.Entry</code> */ public final static long T_CONTAINER_QUALIFIED = 1L << 19; /** * Type names are post qualified. * e.g. <code>Entry - java.util.Map</code> */ public final static long T_POST_QUALIFIED = 1L << 20; /** * Type names contain type parameters. * e.g. <code>Map<S, T></code> */ public final static long T_TYPE_PARAMETERS = 1L << 21; /** * Type parameters are post qualified. * e.g. <code>K - java.util.Map.Entry</code> * * @since 3.5 */ public final static long TP_POST_QUALIFIED = 1L << 22; /** * Declarations (import container / declaration, package declaration) are qualified. * e.g. <code>java.util.Vector.class/import container</code> */ public final static long D_QUALIFIED = 1L << 24; /** * Declarations (import container / declaration, package declaration) are post qualified. * e.g. <code>import container - java.util.Vector.class</code> */ public final static long D_POST_QUALIFIED = 1L << 25; /** * Class file names are fully qualified. * e.g. <code>java.util.Vector.class</code> */ public final static long CF_QUALIFIED = 1L << 27; /** * Class file names are post qualified. * e.g. <code>Vector.class - java.util</code> */ public final static long CF_POST_QUALIFIED = 1L << 28; /** * Compilation unit names are fully qualified. * e.g. <code>java.util.Vector.java</code> */ public final static long CU_QUALIFIED = 1L << 31; /** * Compilation unit names are post qualified. * e.g. <code>Vector.java - java.util</code> */ public final static long CU_POST_QUALIFIED = 1L << 32; /** * Package names are qualified. * e.g. <code>MyProject/src/java.util</code> */ public final static long P_QUALIFIED = 1L << 35; /** * Package names are post qualified. * e.g. <code>java.util - MyProject/src</code> */ public final static long P_POST_QUALIFIED = 1L << 36; /** * Package names are abbreviated if * {@link PreferenceConstants#APPEARANCE_ABBREVIATE_PACKAGE_NAMES} is <code>true</code> and/or * compressed if {@link PreferenceConstants#APPEARANCE_COMPRESS_PACKAGE_NAMES} is * <code>true</code>. */ public final static long P_COMPRESSED = 1L << 37; /** * Package Fragment Roots contain variable name if from a variable. * e.g. <code>JRE_LIB - c:\java\lib\rt.jar</code> */ public final static long ROOT_VARIABLE = 1L << 40; /** * Package Fragment Roots contain the project name if not an archive (prepended). * e.g. <code>MyProject/src</code> */ public final static long ROOT_QUALIFIED = 1L << 41; /** * Package Fragment Roots contain the project name if not an archive (appended). * e.g. <code>src - MyProject</code> */ public final static long ROOT_POST_QUALIFIED = 1L << 42; /** * Add root path to all elements except Package Fragment Roots and Java projects. * e.g. <code>java.lang.Vector - C:\java\lib\rt.jar</code> * Option only applies to getElementLabel */ public final static long APPEND_ROOT_PATH = 1L << 43; /** * Add root path to all elements except Package Fragment Roots and Java projects. * e.g. <code>C:\java\lib\rt.jar - java.lang.Vector</code> * Option only applies to getElementLabel */ public final static long PREPEND_ROOT_PATH = 1L << 44; /** * Post qualify referenced package fragment roots. For example * <code>jdt.jar - org.eclipse.jdt.ui</code> if the jar is referenced * from another project. */ public final static long REFERENCED_ROOT_POST_QUALIFIED = 1L << 45; /** * Specifies to use the resolved information of a IType, IMethod or IField. See {@link IType#isResolved()}. * If resolved information is available, types will be rendered with type parameters of the instantiated type. * Resolved methods render with the parameter types of the method instance. * <code>Vector<String>.get(String)</code> */ public final static long USE_RESOLVED = 1L << 48; /** * Specifies to apply color styles to labels. This flag only applies to methods taking or returning a {@link StyledString}. * * @since 3.4 */ public final static long COLORIZE = 1L << 55; /** * Prepend first category (if any) to field. * @since 3.2 */ public final static long F_CATEGORY = 1L << 49; /** * Prepend first category (if any) to method. * @since 3.2 */ public final static long M_CATEGORY = 1L << 50; /** * Prepend first category (if any) to type. * @since 3.2 */ public final static long T_CATEGORY = 1L << 51; /** * Show category for all elements. * @since 3.2 */ public final static long ALL_CATEGORY = new Long(F_CATEGORY | M_CATEGORY | T_CATEGORY).longValue(); /** * Qualify all elements */ public final static long ALL_FULLY_QUALIFIED = new Long( F_FULLY_QUALIFIED | M_FULLY_QUALIFIED | I_FULLY_QUALIFIED | T_FULLY_QUALIFIED | D_QUALIFIED | CF_QUALIFIED | CU_QUALIFIED | P_QUALIFIED | ROOT_QUALIFIED).longValue(); /** * Post qualify all elements */ public final static long ALL_POST_QUALIFIED = new Long(F_POST_QUALIFIED | M_POST_QUALIFIED | I_POST_QUALIFIED | T_POST_QUALIFIED | TP_POST_QUALIFIED | D_POST_QUALIFIED | CF_POST_QUALIFIED | CU_POST_QUALIFIED | P_POST_QUALIFIED | ROOT_POST_QUALIFIED).longValue(); /** * Default options (M_PARAMETER_TYPES, M_APP_TYPE_PARAMETERS & T_TYPE_PARAMETERS enabled) */ public final static long ALL_DEFAULT = new Long(M_PARAMETER_TYPES | M_APP_TYPE_PARAMETERS | T_TYPE_PARAMETERS) .longValue(); /** * Default qualify options (All except Root and Package) */ public final static long DEFAULT_QUALIFIED = new Long(F_FULLY_QUALIFIED | M_FULLY_QUALIFIED | I_FULLY_QUALIFIED | T_FULLY_QUALIFIED | D_QUALIFIED | CF_QUALIFIED | CU_QUALIFIED).longValue(); /** * Default post qualify options (All except Root and Package) */ public final static long DEFAULT_POST_QUALIFIED = new Long( F_POST_QUALIFIED | M_POST_QUALIFIED | I_POST_QUALIFIED | T_POST_QUALIFIED | TP_POST_QUALIFIED | D_POST_QUALIFIED | CF_POST_QUALIFIED | CU_POST_QUALIFIED).longValue(); /** * User-readable string for separating post qualified names (e.g. " - "). */ public final static String CONCAT_STRING = " - "; /** * User-readable string for separating list items (e.g. ", "). */ public final static String COMMA_STRING = ", "; /** * User-readable string for separating the return type (e.g. " : "). */ public final static String DECL_STRING = " : "; /** * User-readable string for concatenating categories (e.g. " "). * @since 3.5 */ public final static String CATEGORY_SEPARATOR_STRING = " "; /** * User-readable string for ellipsis ("..."). */ public final static String ELLIPSIS_STRING = "..."; //$NON-NLS-1$ /** * User-readable string for the default package name (e.g. "(default package)"). */ public final static String DEFAULT_PACKAGE = "(default package)"; private final static long QUALIFIER_FLAGS = P_COMPRESSED | USE_RESOLVED; /* * Package name compression */ private static String fgPkgNamePattern = ""; //$NON-NLS-1$ private static String fgPkgNamePrefix; private static String fgPkgNamePostfix; private static int fgPkgNameChars; private static int fgPkgNameLength = -1; /* * Package name abbreviation */ private static String fgPkgNameAbbreviationPattern = ""; //$NON-NLS-1$ private static PackageNameAbbreviation[] fgPkgNameAbbreviation; protected final FlexibleBuffer fBuffer; private static final boolean getFlag(long flags, long flag) { return (flags & flag) != 0; } /** * Creates a new java element composer based on the given buffer. * * @param buffer the buffer */ public JavaElementLabelComposer(FlexibleBuffer buffer) { fBuffer = buffer; } /** * Creates a new java element composer based on the given buffer. * * @param buffer the buffer */ public JavaElementLabelComposer(StringBuffer buffer) { this(new FlexibleStringBuffer(buffer)); } /** * Appends the label for a Java element with the flags as defined by this class. * * @param element the element to render * @param flags the rendering flags. */ public void appendElementLabel(IJavaElement element, long flags) { int type = element.getElementType(); IPackageFragmentRoot root = null; if (type != IJavaElement.JAVA_MODEL && type != IJavaElement.JAVA_PROJECT && type != IJavaElement.PACKAGE_FRAGMENT_ROOT) root = (IPackageFragmentRoot) element.getAncestor(IJavaElement.PACKAGE_FRAGMENT_ROOT); if (root != null && getFlag(flags, PREPEND_ROOT_PATH)) { appendPackageFragmentRootLabel(root, ROOT_QUALIFIED); fBuffer.append(CONCAT_STRING); } switch (type) { case IJavaElement.METHOD: appendMethodLabel((IMethod) element, flags); break; case IJavaElement.FIELD: appendFieldLabel((IField) element, flags); break; case IJavaElement.LOCAL_VARIABLE: appendLocalVariableLabel((ILocalVariable) element, flags); break; case IJavaElement.TYPE_PARAMETER: appendTypeParameterLabel((ITypeParameter) element, flags); break; case IJavaElement.INITIALIZER: appendInitializerLabel((IInitializer) element, flags); break; case IJavaElement.TYPE: appendTypeLabel((IType) element, flags); break; case IJavaElement.CLASS_FILE: appendClassFileLabel((IClassFile) element, flags); break; case IJavaElement.COMPILATION_UNIT: appendCompilationUnitLabel((ICompilationUnit) element, flags); break; case IJavaElement.PACKAGE_FRAGMENT: appendPackageFragmentLabel((IPackageFragment) element, flags); break; case IJavaElement.PACKAGE_FRAGMENT_ROOT: appendPackageFragmentRootLabel((IPackageFragmentRoot) element, flags); break; case IJavaElement.IMPORT_CONTAINER: case IJavaElement.IMPORT_DECLARATION: case IJavaElement.PACKAGE_DECLARATION: appendDeclarationLabel(element, flags); break; case IJavaElement.JAVA_PROJECT: case IJavaElement.JAVA_MODEL: fBuffer.append(element.getElementName()); break; default: fBuffer.append(element.getElementName()); } if (root != null && getFlag(flags, APPEND_ROOT_PATH)) { int offset = fBuffer.length(); fBuffer.append(CONCAT_STRING); appendPackageFragmentRootLabel(root, ROOT_QUALIFIED); } } /** * Appends the label for a method. Considers the M_* flags. * * @param method the element to render * @param flags the rendering flags. Flags with names starting with 'M_' are considered. */ public void appendMethodLabel(IMethod method, long flags) { try { BindingKey resolvedKey = getFlag(flags, USE_RESOLVED) && method.isResolved() ? new BindingKey(method.getKey()) : null; String resolvedSig = (resolvedKey != null) ? resolvedKey.toSignature() : null; // type parameters if (getFlag(flags, M_PRE_TYPE_PARAMETERS)) { if (resolvedKey != null) { if (resolvedKey.isParameterizedMethod()) { String[] typeArgRefs = resolvedKey.getTypeArguments(); if (typeArgRefs.length > 0) { appendTypeArgumentSignaturesLabel(method, typeArgRefs, flags); fBuffer.append(' '); } } else { String[] typeParameterSigs = Signature.getTypeParameters(resolvedSig); if (typeParameterSigs.length > 0) { appendTypeParameterSignaturesLabel(typeParameterSigs, flags); fBuffer.append(' '); } } } else if (method.exists()) { ITypeParameter[] typeParameters = method.getTypeParameters(); if (typeParameters.length > 0) { appendTypeParametersLabels(typeParameters, flags); fBuffer.append(' '); } } } // return type if (getFlag(flags, M_PRE_RETURNTYPE) && method.exists() && !method.isConstructor()) { String returnTypeSig = resolvedSig != null ? Signature.getReturnType(resolvedSig) : method.getReturnType(); appendTypeSignatureLabel(method, returnTypeSig, flags); fBuffer.append(' '); } // qualification if (getFlag(flags, M_FULLY_QUALIFIED)) { appendTypeLabel(method.getDeclaringType(), T_FULLY_QUALIFIED | (flags & QUALIFIER_FLAGS)); fBuffer.append('.'); } fBuffer.append(getElementName(method)); // constructor type arguments if (getFlag(flags, T_TYPE_PARAMETERS) && method.exists() && method.isConstructor()) { if (resolvedSig != null && resolvedKey.isParameterizedType()) { BindingKey declaringType = resolvedKey.getDeclaringType(); if (declaringType != null) { String[] declaringTypeArguments = declaringType.getTypeArguments(); appendTypeArgumentSignaturesLabel(method, declaringTypeArguments, flags); } } } // parameters fBuffer.append('('); String[] declaredParameterTypes = method.getParameterTypes(); if (getFlag(flags, M_PARAMETER_TYPES | M_PARAMETER_NAMES)) { String[] types = null; int nParams = 0; boolean renderVarargs = false; boolean isPolymorphic = false; if (getFlag(flags, M_PARAMETER_TYPES)) { if (resolvedSig != null) { types = Signature.getParameterTypes(resolvedSig); } else { types = declaredParameterTypes; } nParams = types.length; renderVarargs = method.exists() && Flags.isVarargs(method.getFlags()); if (renderVarargs && resolvedSig != null && declaredParameterTypes.length == 1 && method .getAnnotation("java.lang.invoke.MethodHandle$PolymorphicSignature").exists()) { renderVarargs = false; isPolymorphic = true; } } String[] names = null; if (getFlag(flags, M_PARAMETER_NAMES) && method.exists()) { names = method.getParameterNames(); if (isPolymorphic) { // handled specially below } else if (types == null) { nParams = names.length; } else { // types != null if (nParams != names.length) { if (resolvedSig != null && types.length > names.length) { // see https://bugs.eclipse.org/bugs/show_bug.cgi?id=99137 nParams = names.length; String[] typesWithoutSyntheticParams = new String[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 } } } } ILocalVariable[] annotatedParameters = null; if (nParams > 0 && getFlag(flags, M_PARAMETER_ANNOTATIONS)) { annotatedParameters = method.getParameters(); } for (int i = 0; i < nParams; i++) { if (i > 0) { fBuffer.append(COMMA_STRING); } if (annotatedParameters != null && i < annotatedParameters.length) { appendAnnotationLabels(annotatedParameters[i].getAnnotations(), flags); } if (types != null) { String paramSig = types[i]; if (renderVarargs && (i == nParams - 1)) { int newDim = Signature.getArrayCount(paramSig) - 1; appendTypeSignatureLabel(method, Signature.getElementType(paramSig), flags); for (int k = 0; k < newDim; k++) { fBuffer.append('[').append(']'); } fBuffer.append(ELLIPSIS_STRING); } else { appendTypeSignatureLabel(method, paramSig, flags); } } if (names != null) { if (types != null) { fBuffer.append(' '); } if (isPolymorphic) { fBuffer.append(names[0] + i); } else { fBuffer.append(names[i]); } } } } else { if (declaredParameterTypes.length > 0) { fBuffer.append(ELLIPSIS_STRING); } } fBuffer.append(')'); if (getFlag(flags, M_EXCEPTIONS)) { String[] types; if (resolvedKey != null) { types = resolvedKey.getThrownExceptions(); } else { types = method.exists() ? method.getExceptionTypes() : new String[0]; } if (types.length > 0) { fBuffer.append(" throws "); //$NON-NLS-1$ for (int i = 0; i < types.length; i++) { if (i > 0) { fBuffer.append(COMMA_STRING); } appendTypeSignatureLabel(method, types[i], flags); } } } if (getFlag(flags, M_APP_TYPE_PARAMETERS)) { int offset = fBuffer.length(); if (resolvedKey != null) { if (resolvedKey.isParameterizedMethod()) { String[] typeArgRefs = resolvedKey.getTypeArguments(); if (typeArgRefs.length > 0) { fBuffer.append(' '); appendTypeArgumentSignaturesLabel(method, typeArgRefs, flags); } } else { String[] typeParameterSigs = Signature.getTypeParameters(resolvedSig); if (typeParameterSigs.length > 0) { fBuffer.append(' '); appendTypeParameterSignaturesLabel(typeParameterSigs, flags); } } } else if (method.exists()) { ITypeParameter[] typeParameters = method.getTypeParameters(); if (typeParameters.length > 0) { fBuffer.append(' '); appendTypeParametersLabels(typeParameters, flags); } } } if (getFlag(flags, M_APP_RETURNTYPE) && method.exists() && !method.isConstructor()) { int offset = fBuffer.length(); fBuffer.append(DECL_STRING); String returnTypeSig = resolvedSig != null ? Signature.getReturnType(resolvedSig) : method.getReturnType(); appendTypeSignatureLabel(method, returnTypeSig, flags); } // category if (getFlag(flags, M_CATEGORY) && method.exists()) appendCategoryLabel(method, flags); // post qualification if (getFlag(flags, M_POST_QUALIFIED)) { int offset = fBuffer.length(); fBuffer.append(CONCAT_STRING); appendTypeLabel(method.getDeclaringType(), T_FULLY_QUALIFIED | (flags & QUALIFIER_FLAGS)); } } catch (JavaModelException e) { e.printStackTrace(); } } protected void appendAnnotationLabels(IAnnotation[] annotations, long flags) throws JavaModelException { for (int j = 0; j < annotations.length; j++) { IAnnotation annotation = annotations[j]; appendAnnotationLabel(annotation, flags); fBuffer.append(' '); } } public void appendAnnotationLabel(IAnnotation annotation, long flags) throws JavaModelException { fBuffer.append('@'); appendTypeSignatureLabel(annotation, Signature.createTypeSignature(annotation.getElementName(), false), flags); IMemberValuePair[] memberValuePairs = annotation.getMemberValuePairs(); if (memberValuePairs.length == 0) return; fBuffer.append('('); for (int i = 0; i < memberValuePairs.length; i++) { if (i > 0) fBuffer.append(COMMA_STRING); IMemberValuePair memberValuePair = memberValuePairs[i]; fBuffer.append(getMemberName(annotation, annotation.getElementName(), memberValuePair.getMemberName())); fBuffer.append('='); appendAnnotationValue(annotation, memberValuePair.getValue(), memberValuePair.getValueKind(), flags); } fBuffer.append(')'); } private void appendAnnotationValue(IAnnotation annotation, Object value, int valueKind, long flags) throws JavaModelException { // 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(COMMA_STRING); value = values[j]; appendAnnotationValue(annotation, value, valueKind, flags); } fBuffer.append('}'); } else { switch (valueKind) { case IMemberValuePair.K_CLASS: appendTypeSignatureLabel(annotation, Signature.createTypeSignature((String) value, false), flags); fBuffer.append(".class"); //$NON-NLS-1$ break; case IMemberValuePair.K_QUALIFIED_NAME: String name = (String) value; int lastDot = name.lastIndexOf('.'); if (lastDot != -1) { String type = name.substring(0, lastDot); String field = name.substring(lastDot + 1); appendTypeSignatureLabel(annotation, Signature.createTypeSignature(type, false), flags); fBuffer.append('.'); fBuffer.append(getMemberName(annotation, type, field)); break; } // case IMemberValuePair.K_SIMPLE_NAME: // can't implement, since parent type is not known //$FALL-THROUGH$ case IMemberValuePair.K_ANNOTATION: appendAnnotationLabel((IAnnotation) value, flags); break; case IMemberValuePair.K_STRING: fBuffer.append(getEscapedStringLiteral((String) value)); break; case IMemberValuePair.K_CHAR: fBuffer.append(getEscapedCharacterLiteral(((Character) value).charValue())); break; default: fBuffer.append(String.valueOf(value)); break; } } } private static String getEscapedStringLiteral(String stringValue) { StringLiteral stringLiteral = AST.newAST(AST.JLS8).newStringLiteral(); stringLiteral.setLiteralValue(stringValue); return stringLiteral.getEscapedValue(); } private static String getEscapedCharacterLiteral(char ch) { CharacterLiteral characterLiteral = AST.newAST(AST.JLS8).newCharacterLiteral(); characterLiteral.setCharValue(ch); return characterLiteral.getEscapedValue(); } private void appendCategoryLabel(IMember member, long flags) throws JavaModelException { String[] categories = member.getCategories(); if (categories.length > 0) { int offset = fBuffer.length(); StringBuffer categoriesBuf = new StringBuffer(); for (int i = 0; i < categories.length; i++) { if (i > 0) categoriesBuf.append(CATEGORY_SEPARATOR_STRING); categoriesBuf.append(categories[i]); } fBuffer.append(CONCAT_STRING); fBuffer.append('['); fBuffer.append(categoriesBuf.toString()); fBuffer.append(']'); } } /** * Appends labels for type parameters from type binding array. * * @param typeParameters the type parameters * @param flags flags with render options * @throws JavaModelException ... */ private void appendTypeParametersLabels(ITypeParameter[] typeParameters, long flags) throws JavaModelException { if (typeParameters.length > 0) { fBuffer.append(getLT()); for (int i = 0; i < typeParameters.length; i++) { if (i > 0) { fBuffer.append(COMMA_STRING); } appendTypeParameterWithBounds(typeParameters[i], flags); } fBuffer.append(getGT()); } } /** * Appends the style label for a field. Considers the F_* flags. * * @param field the element to render * @param flags the rendering flags. Flags with names starting with 'F_' are considered. */ public void appendFieldLabel(IField field, long flags) { try { if (getFlag(flags, F_PRE_TYPE_SIGNATURE) && field.exists() && !Flags.isEnum(field.getFlags())) { if (getFlag(flags, USE_RESOLVED) && field.isResolved()) { appendTypeSignatureLabel(field, new BindingKey(field.getKey()).toSignature(), flags); } else { appendTypeSignatureLabel(field, field.getTypeSignature(), flags); } fBuffer.append(' '); } // qualification if (getFlag(flags, F_FULLY_QUALIFIED)) { appendTypeLabel(field.getDeclaringType(), T_FULLY_QUALIFIED | (flags & QUALIFIER_FLAGS)); fBuffer.append('.'); } fBuffer.append(getElementName(field)); if (getFlag(flags, F_APP_TYPE_SIGNATURE) && field.exists() && !Flags.isEnum(field.getFlags())) { int offset = fBuffer.length(); fBuffer.append(DECL_STRING); if (getFlag(flags, USE_RESOLVED) && field.isResolved()) { appendTypeSignatureLabel(field, new BindingKey(field.getKey()).toSignature(), flags); } else { appendTypeSignatureLabel(field, field.getTypeSignature(), flags); } } // category if (getFlag(flags, F_CATEGORY) && field.exists()) appendCategoryLabel(field, flags); // post qualification if (getFlag(flags, F_POST_QUALIFIED)) { int offset = fBuffer.length(); fBuffer.append(CONCAT_STRING); appendTypeLabel(field.getDeclaringType(), T_FULLY_QUALIFIED | (flags & QUALIFIER_FLAGS)); } } catch (JavaModelException e) { e.printStackTrace(); } } /** * Appends the styled label for a local variable. * * @param localVariable the element to render * @param flags the rendering flags. Flags with names starting with 'F_' are considered. */ public void appendLocalVariableLabel(ILocalVariable localVariable, long flags) { if (getFlag(flags, F_PRE_TYPE_SIGNATURE)) { appendTypeSignatureLabel(localVariable, localVariable.getTypeSignature(), flags); fBuffer.append(' '); } if (getFlag(flags, F_FULLY_QUALIFIED)) { appendElementLabel(localVariable.getDeclaringMember(), M_PARAMETER_TYPES | M_FULLY_QUALIFIED | T_FULLY_QUALIFIED | (flags & QUALIFIER_FLAGS)); fBuffer.append('.'); } fBuffer.append(getElementName(localVariable)); if (getFlag(flags, F_APP_TYPE_SIGNATURE)) { int offset = fBuffer.length(); fBuffer.append(DECL_STRING); appendTypeSignatureLabel(localVariable, localVariable.getTypeSignature(), flags); } // post qualification if (getFlag(flags, F_POST_QUALIFIED)) { fBuffer.append(CONCAT_STRING); appendElementLabel(localVariable.getDeclaringMember(), M_PARAMETER_TYPES | M_FULLY_QUALIFIED | T_FULLY_QUALIFIED | (flags & QUALIFIER_FLAGS)); } } /** * Appends the styled label for a type parameter. * * @param typeParameter the element to render * @param flags the rendering flags. Flags with names starting with 'T_' are considered. */ public void appendTypeParameterLabel(ITypeParameter typeParameter, long flags) { try { appendTypeParameterWithBounds(typeParameter, flags); // post qualification if (getFlag(flags, TP_POST_QUALIFIED)) { fBuffer.append(CONCAT_STRING); IMember declaringMember = typeParameter.getDeclaringMember(); appendElementLabel(declaringMember, M_PARAMETER_TYPES | M_FULLY_QUALIFIED | T_FULLY_QUALIFIED | (flags & QUALIFIER_FLAGS)); } } catch (JavaModelException e) { e.printStackTrace(); } } private void appendTypeParameterWithBounds(ITypeParameter typeParameter, long flags) throws JavaModelException { fBuffer.append(getElementName(typeParameter)); if (typeParameter.exists()) { String[] bounds = typeParameter.getBoundsSignatures(); if (bounds.length > 0 && !(bounds.length == 1 && "Ljava.lang.Object;".equals(bounds[0]))) { //$NON-NLS-1$ fBuffer.append(" extends "); //$NON-NLS-1$ for (int j = 0; j < bounds.length; j++) { if (j > 0) { fBuffer.append(" & "); //$NON-NLS-1$ } appendTypeSignatureLabel(typeParameter, bounds[j], flags); } } } } /** * Appends the label for a initializer. Considers the I_* flags. * * @param initializer the element to render * @param flags the rendering flags. Flags with names starting with 'I_' are considered. */ public void appendInitializerLabel(IInitializer initializer, long flags) { // qualification if (getFlag(flags, I_FULLY_QUALIFIED)) { appendTypeLabel(initializer.getDeclaringType(), T_FULLY_QUALIFIED | (flags & QUALIFIER_FLAGS)); fBuffer.append('.'); } fBuffer.append("{...}"); // post qualification if (getFlag(flags, I_POST_QUALIFIED)) { int offset = fBuffer.length(); fBuffer.append(CONCAT_STRING); appendTypeLabel(initializer.getDeclaringType(), T_FULLY_QUALIFIED | (flags & QUALIFIER_FLAGS)); } } protected void appendTypeSignatureLabel(IJavaElement enclosingElement, String typeSig, long flags) { int sigKind = Signature.getTypeSignatureKind(typeSig); switch (sigKind) { case Signature.BASE_TYPE_SIGNATURE: fBuffer.append(Signature.toString(typeSig)); break; case Signature.ARRAY_TYPE_SIGNATURE: appendTypeSignatureLabel(enclosingElement, Signature.getElementType(typeSig), flags); for (int dim = Signature.getArrayCount(typeSig); dim > 0; dim--) { fBuffer.append('[').append(']'); } break; case Signature.CLASS_TYPE_SIGNATURE: String baseType = getSimpleTypeName(enclosingElement, typeSig); fBuffer.append(baseType); String[] typeArguments = Signature.getTypeArguments(typeSig); appendTypeArgumentSignaturesLabel(enclosingElement, typeArguments, flags); break; case Signature.TYPE_VARIABLE_SIGNATURE: fBuffer.append(getSimpleTypeName(enclosingElement, typeSig)); break; case Signature.WILDCARD_TYPE_SIGNATURE: char ch = typeSig.charAt(0); if (ch == Signature.C_STAR) { //workaround for bug 85713 fBuffer.append('?'); } else { if (ch == Signature.C_EXTENDS) { fBuffer.append("? extends "); //$NON-NLS-1$ appendTypeSignatureLabel(enclosingElement, typeSig.substring(1), flags); } else if (ch == Signature.C_SUPER) { fBuffer.append("? super "); //$NON-NLS-1$ appendTypeSignatureLabel(enclosingElement, typeSig.substring(1), flags); } } break; case Signature.CAPTURE_TYPE_SIGNATURE: appendTypeSignatureLabel(enclosingElement, typeSig.substring(1), flags); break; case Signature.INTERSECTION_TYPE_SIGNATURE: String[] typeBounds = Signature.getIntersectionTypeBounds(typeSig); appendTypeBoundsSignaturesLabel(enclosingElement, typeBounds, flags); break; default: // unknown } } /** * Returns the simple name of the given type signature. * * @param enclosingElement the enclosing element in which to resolve the signature * @param typeSig a {@link Signature#CLASS_TYPE_SIGNATURE} or {@link Signature#TYPE_VARIABLE_SIGNATURE} * @return the simple name of the given type signature */ protected String getSimpleTypeName(IJavaElement enclosingElement, String typeSig) { return Signature.getSimpleName(Signature.toString(Signature.getTypeErasure(typeSig))); } /** * Returns the simple name of the given member. * * @param enclosingElement the enclosing element * @param typeName the name of the member's declaring type * @param memberName the name of the member * @return the simple name of the member */ protected String getMemberName(IJavaElement enclosingElement, String typeName, String memberName) { return memberName; } private void appendTypeArgumentSignaturesLabel(IJavaElement enclosingElement, String[] typeArgsSig, long flags) { if (typeArgsSig.length > 0) { fBuffer.append(getLT()); for (int i = 0; i < typeArgsSig.length; i++) { if (i > 0) { fBuffer.append(COMMA_STRING); } appendTypeSignatureLabel(enclosingElement, typeArgsSig[i], flags); } fBuffer.append(getGT()); } } private void appendTypeBoundsSignaturesLabel(IJavaElement enclosingElement, String[] typeArgsSig, long flags) { for (int i = 0; i < typeArgsSig.length; i++) { if (i > 0) { fBuffer.append(" | "); //$NON-NLS-1$ } appendTypeSignatureLabel(enclosingElement, typeArgsSig[i], flags); } } /** * Appends labels for type parameters from a signature. * * @param typeParamSigs the type parameter signature * @param flags flags with render options */ private void appendTypeParameterSignaturesLabel(String[] typeParamSigs, long flags) { if (typeParamSigs.length > 0) { fBuffer.append(getLT()); for (int i = 0; i < typeParamSigs.length; i++) { if (i > 0) { fBuffer.append(COMMA_STRING); } fBuffer.append(Signature.getTypeVariable(typeParamSigs[i])); } fBuffer.append(getGT()); } } /** * Returns the string for rendering the '<code><</code>' character. * * @return the string for rendering '<code><</code>' */ protected String getLT() { return "<"; //$NON-NLS-1$ } /** * Returns the string for rendering the '<code>></code>' character. * * @return the string for rendering '<code>></code>' */ protected String getGT() { return ">"; //$NON-NLS-1$ } /** * Appends the label for a type. Considers the T_* flags. * * @param type the element to render * @param flags the rendering flags. Flags with names starting with 'T_' are considered. */ public void appendTypeLabel(IType type, long flags) { if (getFlag(flags, T_FULLY_QUALIFIED)) { IPackageFragment pack = type.getPackageFragment(); if (!pack.isDefaultPackage()) { appendPackageFragmentLabel(pack, (flags & QUALIFIER_FLAGS)); fBuffer.append('.'); } } IJavaElement parent = type.getParent(); if (getFlag(flags, T_FULLY_QUALIFIED | T_CONTAINER_QUALIFIED)) { IType declaringType = type.getDeclaringType(); if (declaringType != null) { appendTypeLabel(declaringType, T_CONTAINER_QUALIFIED | (flags & QUALIFIER_FLAGS)); fBuffer.append('.'); } int parentType = parent.getElementType(); if (parentType == IJavaElement.METHOD || parentType == IJavaElement.FIELD || parentType == IJavaElement.INITIALIZER) { // anonymous or local appendElementLabel(parent, 0); fBuffer.append('.'); } } String typeName; boolean isAnonymous = false; if (type.isLambda()) { typeName = "() -> {...}"; //$NON-NLS-1$ try { String[] superInterfaceSignatures = type.getSuperInterfaceTypeSignatures(); if (superInterfaceSignatures.length > 0) { typeName = typeName + ' ' + getSimpleTypeName(type, superInterfaceSignatures[0]); } } catch (JavaModelException e) { //ignore } } else { typeName = getElementName(type); try { isAnonymous = type.isAnonymous(); } catch (JavaModelException e1) { // should not happen, but let's play safe: isAnonymous = typeName.length() == 0; } if (isAnonymous) { try { if (parent instanceof IField && type.isEnum()) { typeName = '{' + ELLIPSIS_STRING + '}'; } else { String supertypeName; String[] superInterfaceSignatures = type.getSuperInterfaceTypeSignatures(); if (superInterfaceSignatures.length > 0) { supertypeName = getSimpleTypeName(type, superInterfaceSignatures[0]); } else { supertypeName = getSimpleTypeName(type, type.getSuperclassTypeSignature()); } typeName = "new " + supertypeName + "() {...}"; } } catch (JavaModelException e) { //ignore typeName = "new Anonymous"; } } } fBuffer.append(typeName); if (getFlag(flags, T_TYPE_PARAMETERS)) { if (getFlag(flags, USE_RESOLVED) && type.isResolved()) { BindingKey key = new BindingKey(type.getKey()); if (key.isParameterizedType()) { String[] typeArguments = key.getTypeArguments(); appendTypeArgumentSignaturesLabel(type, typeArguments, flags); } else { String[] typeParameters = Signature.getTypeParameters(key.toSignature()); appendTypeParameterSignaturesLabel(typeParameters, flags); } } else if (type.exists()) { try { appendTypeParametersLabels(type.getTypeParameters(), flags); } catch (JavaModelException e) { // ignore } } } // category if (getFlag(flags, T_CATEGORY) && type.exists()) { try { appendCategoryLabel(type, flags); } catch (JavaModelException e) { // ignore } } // post qualification if (getFlag(flags, T_POST_QUALIFIED)) { int offset = fBuffer.length(); fBuffer.append(CONCAT_STRING); IType declaringType = type.getDeclaringType(); if (declaringType == null && type.isBinary() && isAnonymous) { // workaround for Bug 87165: [model] IType#getDeclaringType() does not work for anonymous binary type String tqn = type.getTypeQualifiedName(); int lastDollar = tqn.lastIndexOf('$'); if (lastDollar != 1) { String declaringTypeCF = tqn.substring(0, lastDollar) + ".class"; //$NON-NLS-1$ declaringType = type.getPackageFragment().getClassFile(declaringTypeCF).getType(); try { ISourceRange typeSourceRange = type.getSourceRange(); if (declaringType.exists() && SourceRange.isAvailable(typeSourceRange)) { IJavaElement realParent = declaringType.getTypeRoot() .getElementAt(typeSourceRange.getOffset() - 1); if (realParent != null) { parent = realParent; } } } catch (JavaModelException e) { // ignore } } } if (declaringType != null) { appendTypeLabel(declaringType, T_FULLY_QUALIFIED | (flags & QUALIFIER_FLAGS)); int parentType = parent.getElementType(); if (parentType == IJavaElement.METHOD || parentType == IJavaElement.FIELD || parentType == IJavaElement.INITIALIZER) { // anonymous or local fBuffer.append('.'); appendElementLabel(parent, 0); } } else { appendPackageFragmentLabel(type.getPackageFragment(), flags & QUALIFIER_FLAGS); } } } /** * Returns the string for rendering the {@link IJavaElement#getElementName() element name} of * the given element. * <p> * <strong>Note:</strong> This class only calls this helper for those elements where ( * {@link JavaElementLinks}) has the need to render the name differently. * </p> * * @param element the element to render * @return the string for rendering the element name */ protected String getElementName(IJavaElement element) { return element.getElementName(); } /** * Appends the label for a import container, import or package declaration. Considers the D_* flags. * * @param declaration the element to render * @param flags the rendering flags. Flags with names starting with 'D_' are considered. */ public void appendDeclarationLabel(IJavaElement declaration, long flags) { if (getFlag(flags, D_QUALIFIED)) { IJavaElement openable = (IJavaElement) declaration.getOpenable(); if (openable != null) { appendElementLabel(openable, CF_QUALIFIED | CU_QUALIFIED | (flags & QUALIFIER_FLAGS)); fBuffer.append('/'); } } if (declaration.getElementType() == IJavaElement.IMPORT_CONTAINER) { fBuffer.append("import declarations"); } else { fBuffer.append(getElementName(declaration)); } // post qualification if (getFlag(flags, D_POST_QUALIFIED)) { int offset = fBuffer.length(); IJavaElement openable = (IJavaElement) declaration.getOpenable(); if (openable != null) { fBuffer.append(CONCAT_STRING); appendElementLabel(openable, CF_QUALIFIED | CU_QUALIFIED | (flags & QUALIFIER_FLAGS)); } } } /** * Appends the label for a class file. Considers the CF_* flags. * * @param classFile the element to render * @param flags the rendering flags. Flags with names starting with 'CF_' are considered. */ public void appendClassFileLabel(IClassFile classFile, long flags) { if (getFlag(flags, CF_QUALIFIED)) { IPackageFragment pack = (IPackageFragment) classFile.getParent(); if (!pack.isDefaultPackage()) { appendPackageFragmentLabel(pack, (flags & QUALIFIER_FLAGS)); fBuffer.append('.'); } } fBuffer.append(classFile.getElementName()); if (getFlag(flags, CF_POST_QUALIFIED)) { int offset = fBuffer.length(); fBuffer.append(CONCAT_STRING); appendPackageFragmentLabel((IPackageFragment) classFile.getParent(), flags & QUALIFIER_FLAGS); } } /** * Appends the label for a compilation unit. Considers the CU_* flags. * * @param cu the element to render * @param flags the rendering flags. Flags with names starting with 'CU_' are considered. */ public void appendCompilationUnitLabel(ICompilationUnit cu, long flags) { if (getFlag(flags, CU_QUALIFIED)) { IPackageFragment pack = (IPackageFragment) cu.getParent(); if (!pack.isDefaultPackage()) { appendPackageFragmentLabel(pack, (flags & QUALIFIER_FLAGS)); fBuffer.append('.'); } } fBuffer.append(cu.getElementName()); if (getFlag(flags, CU_POST_QUALIFIED)) { int offset = fBuffer.length(); fBuffer.append(CONCAT_STRING); appendPackageFragmentLabel((IPackageFragment) cu.getParent(), flags & QUALIFIER_FLAGS); } } /** * Appends the label for a package fragment. Considers the P_* flags. * * @param pack the element to render * @param flags the rendering flags. Flags with names starting with P_' are considered. */ public void appendPackageFragmentLabel(IPackageFragment pack, long flags) { if (getFlag(flags, P_QUALIFIED)) { appendPackageFragmentRootLabel((IPackageFragmentRoot) pack.getParent(), ROOT_QUALIFIED); fBuffer.append('/'); } if (pack.isDefaultPackage()) { fBuffer.append(DEFAULT_PACKAGE); } else if (getFlag(flags, P_COMPRESSED)) { if (isPackageNameAbbreviationEnabled()) appendAbbreviatedPackageFragment(pack); else appendCompressedPackageFragment(pack); } else { fBuffer.append(getElementName(pack)); } if (getFlag(flags, P_POST_QUALIFIED)) { int offset = fBuffer.length(); fBuffer.append(CONCAT_STRING); appendPackageFragmentRootLabel((IPackageFragmentRoot) pack.getParent(), ROOT_QUALIFIED); } } private void appendCompressedPackageFragment(IPackageFragment pack) { appendCompressedPackageFragment(pack.getElementName()); } private void appendCompressedPackageFragment(String elementName) { refreshPackageNamePattern(); if (fgPkgNameLength < 0) { fBuffer.append(elementName); return; } String name = elementName; int start = 0; int dot = name.indexOf('.', start); while (dot > 0) { if (dot - start > fgPkgNameLength - 1) { fBuffer.append(fgPkgNamePrefix); if (fgPkgNameChars > 0) fBuffer.append(name.substring(start, Math.min(start + fgPkgNameChars, dot))); fBuffer.append(fgPkgNamePostfix); } else fBuffer.append(name.substring(start, dot + 1)); start = dot + 1; dot = name.indexOf('.', start); } fBuffer.append(name.substring(start)); } private void appendAbbreviatedPackageFragment(IPackageFragment pack) { refreshPackageNameAbbreviation(); String pkgName = pack.getElementName(); if (fgPkgNameAbbreviation != null && fgPkgNameAbbreviation.length != 0) { for (int i = 0; i < fgPkgNameAbbreviation.length; i++) { PackageNameAbbreviation abbr = fgPkgNameAbbreviation[i]; String abbrPrefix = abbr.getPackagePrefix(); if (pkgName.startsWith(abbrPrefix)) { int abbrPrefixLength = abbrPrefix.length(); int pkgLength = pkgName.length(); if (!(pkgLength == abbrPrefixLength || pkgName.charAt(abbrPrefixLength) == '.')) continue; fBuffer.append(abbr.getAbbreviation()); if (pkgLength > abbrPrefixLength) { fBuffer.append('.'); String remaining = pkgName.substring(abbrPrefixLength + 1); if (isPackageNameCompressionEnabled()) appendCompressedPackageFragment(remaining); else fBuffer.append(remaining); } return; } } } if (isPackageNameCompressionEnabled()) { appendCompressedPackageFragment(pkgName); } else { fBuffer.append(pkgName); } } /** * Appends the label for a package fragment root. Considers the ROOT_* flags. * * @param root the element to render * @param flags the rendering flags. Flags with names starting with ROOT_' are considered. */ public void appendPackageFragmentRootLabel(IPackageFragmentRoot root, long flags) { // Handle variables different if (getFlag(flags, ROOT_VARIABLE) && appendVariableLabel(root, flags)) return; if (root.isArchive()) appendArchiveLabel(root, flags); else appendFolderLabel(root, flags); } private void appendArchiveLabel(IPackageFragmentRoot root, long flags) { boolean external = root.isExternal(); if (external) appendExternalArchiveLabel(root, flags); else appendInternalArchiveLabel(root, flags); } private static IClasspathEntry getClasspathEntry(IPackageFragmentRoot root) throws JavaModelException { IClasspathEntry rawEntry = root.getRawClasspathEntry(); int rawEntryKind = rawEntry.getEntryKind(); switch (rawEntryKind) { case IClasspathEntry.CPE_LIBRARY: case IClasspathEntry.CPE_VARIABLE: case IClasspathEntry.CPE_CONTAINER: // should not happen, see https://bugs.eclipse.org/bugs/show_bug.cgi?id=305037 if (root.isArchive() && root.getKind() == IPackageFragmentRoot.K_BINARY) { IClasspathEntry resolvedEntry = root.getResolvedClasspathEntry(); if (resolvedEntry.getReferencingEntry() != null) return resolvedEntry; else return rawEntry; } } return rawEntry; } private boolean appendVariableLabel(IPackageFragmentRoot root, long flags) { try { IClasspathEntry rawEntry = root.getRawClasspathEntry(); if (rawEntry.getEntryKind() == IClasspathEntry.CPE_VARIABLE) { IClasspathEntry entry = getClasspathEntry(root); if (entry.getReferencingEntry() != null) { return false; // not the variable entry itself, but a referenced entry } IPath path = rawEntry.getPath().makeRelative(); if (getFlag(flags, REFERENCED_ROOT_POST_QUALIFIED)) { int segements = path.segmentCount(); if (segements > 0) { fBuffer.append(path.segment(segements - 1)); if (segements > 1) { int offset = fBuffer.length(); fBuffer.append(CONCAT_STRING); fBuffer.append(path.removeLastSegments(1).toOSString()); } } else { fBuffer.append(path.toString()); } } else { fBuffer.append(path.toString()); } int offset = fBuffer.length(); fBuffer.append(CONCAT_STRING); if (root.isExternal()) fBuffer.append(root.getPath().toOSString()); else fBuffer.append(root.getPath().makeRelative().toString()); return true; } } catch (JavaModelException e) { // problems with class path, ignore (bug 202792) return false; } return false; } private void appendExternalArchiveLabel(IPackageFragmentRoot root, long flags) { IPath path; IClasspathEntry classpathEntry = null; try { classpathEntry = getClasspathEntry(root); IPath rawPath = classpathEntry.getPath(); if (classpathEntry.getEntryKind() != IClasspathEntry.CPE_CONTAINER && !rawPath.isAbsolute()) path = rawPath; else path = root.getPath(); } catch (JavaModelException e) { path = root.getPath(); } if (getFlag(flags, REFERENCED_ROOT_POST_QUALIFIED)) { int segements = path.segmentCount(); if (segements > 0) { fBuffer.append(path.segment(segements - 1)); int offset = fBuffer.length(); if (segements > 1 || path.getDevice() != null) { fBuffer.append(CONCAT_STRING); fBuffer.append(path.removeLastSegments(1).toOSString()); } if (classpathEntry != null) { IClasspathEntry referencingEntry = classpathEntry.getReferencingEntry(); if (referencingEntry != null) { fBuffer.append(" (from "); fBuffer.append(Name.CLASS_PATH.toString()); fBuffer.append(" of "); fBuffer.append(referencingEntry.getPath().lastSegment()); fBuffer.append(")"); } } } else { fBuffer.append(path.toOSString()); } } else { fBuffer.append(path.toOSString()); } } private void appendInternalArchiveLabel(IPackageFragmentRoot root, long flags) { IResource resource = root.getResource(); boolean rootQualified = getFlag(flags, ROOT_QUALIFIED); if (rootQualified) { fBuffer.append(root.getPath().makeRelative().toString()); } else { fBuffer.append(root.getElementName()); int offset = fBuffer.length(); boolean referencedPostQualified = getFlag(flags, REFERENCED_ROOT_POST_QUALIFIED); if (referencedPostQualified && isReferenced(root)) { fBuffer.append(CONCAT_STRING); fBuffer.append(resource.getParent().getFullPath().makeRelative().toString()); } else if (getFlag(flags, ROOT_POST_QUALIFIED)) { fBuffer.append(CONCAT_STRING); fBuffer.append(root.getParent().getPath().makeRelative().toString()); } if (referencedPostQualified) { try { IClasspathEntry referencingEntry = getClasspathEntry(root).getReferencingEntry(); if (referencingEntry != null) { fBuffer.append(" (from "); fBuffer.append(Name.CLASS_PATH.toString()); fBuffer.append(" of "); fBuffer.append(referencingEntry.getPath().lastSegment()); fBuffer.append(")"); } } catch (JavaModelException e) { // ignore } } } } private void appendFolderLabel(IPackageFragmentRoot root, long flags) { IResource resource = root.getResource(); if (resource == null) { appendExternalArchiveLabel(root, flags); return; } boolean rootQualified = getFlag(flags, ROOT_QUALIFIED); boolean referencedQualified = getFlag(flags, REFERENCED_ROOT_POST_QUALIFIED) && isReferenced(root); if (rootQualified) { fBuffer.append(root.getPath().makeRelative().toString()); } else { IPath projectRelativePath = resource.getProjectRelativePath(); if (projectRelativePath.segmentCount() == 0) { fBuffer.append(resource.getName()); referencedQualified = false; } else { fBuffer.append(projectRelativePath.toString()); } int offset = fBuffer.length(); if (referencedQualified) { fBuffer.append(CONCAT_STRING); fBuffer.append(resource.getProject().getName()); } else if (getFlag(flags, ROOT_POST_QUALIFIED)) { fBuffer.append(CONCAT_STRING); fBuffer.append(root.getParent().getElementName()); } else { return; } } } /** * Returns <code>true</code> if the given package fragment root is * referenced. This means it is a descendant of a different project but is referenced * by the root's parent. Returns <code>false</code> if the given root * doesn't have an underlying resource. * * @param root the package fragment root * @return returns <code>true</code> if the given package fragment root is referenced */ private boolean isReferenced(IPackageFragmentRoot root) { IResource resource = root.getResource(); if (resource != null) { IProject jarProject = resource.getProject(); IProject container = root.getJavaProject().getProject(); return !container.equals(jarProject); } return false; } private void refreshPackageNamePattern() { String pattern = getPkgNamePatternForPackagesView(); final String EMPTY_STRING = ""; //$NON-NLS-1$ if (pattern.equals(fgPkgNamePattern)) return; else if (pattern.length() == 0) { fgPkgNamePattern = EMPTY_STRING; fgPkgNameLength = -1; return; } fgPkgNamePattern = pattern; int i = 0; fgPkgNameChars = 0; fgPkgNamePrefix = EMPTY_STRING; fgPkgNamePostfix = EMPTY_STRING; while (i < pattern.length()) { char ch = pattern.charAt(i); if (Character.isDigit(ch)) { fgPkgNameChars = ch - 48; if (i > 0) fgPkgNamePrefix = pattern.substring(0, i); if (i >= 0) fgPkgNamePostfix = pattern.substring(i + 1); fgPkgNameLength = fgPkgNamePrefix.length() + fgPkgNameChars + fgPkgNamePostfix.length(); return; } i++; } fgPkgNamePrefix = pattern; fgPkgNameLength = pattern.length(); } private void refreshPackageNameAbbreviation() { String pattern = getPkgNameAbbreviationPatternForPackagesView(); if (fgPkgNameAbbreviationPattern.equals(pattern)) return; fgPkgNameAbbreviationPattern = pattern; if (pattern == null || pattern.length() == 0) { fgPkgNameAbbreviationPattern = ""; //$NON-NLS-1$ fgPkgNameAbbreviation = null; return; } PackageNameAbbreviation[] abbrs = parseAbbreviationPattern(pattern); if (abbrs == null) abbrs = new PackageNameAbbreviation[0]; fgPkgNameAbbreviation = abbrs; } public static PackageNameAbbreviation[] parseAbbreviationPattern(String pattern) { String[] parts = pattern.split("\\s*(?:\r\n?|\n)\\s*"); //$NON-NLS-1$ ArrayList<PackageNameAbbreviation> result = new ArrayList<PackageNameAbbreviation>(); for (int i = 0; i < parts.length; i++) { String part = parts[i].trim(); if (part.length() == 0) continue; String[] parts2 = part.split("\\s*=\\s*", 2); //$NON-NLS-1$ if (parts2.length != 2) return null; String prefix = parts2[0].trim(); String abbr = parts2[1].trim(); if (prefix.startsWith("#")) //$NON-NLS-1$ continue; PackageNameAbbreviation pkgAbbr = new PackageNameAbbreviation(prefix, abbr); result.add(pkgAbbr); } Collections.sort(result, new Comparator<PackageNameAbbreviation>() { public int compare(PackageNameAbbreviation a1, PackageNameAbbreviation a2) { return a2.getPackagePrefix().length() - a1.getPackagePrefix().length(); } }); return result.toArray(new PackageNameAbbreviation[0]); } private boolean isPackageNameCompressionEnabled() { //IPreferenceStore store= PreferenceConstants.getPreferenceStore(); //return store.getBoolean(PreferenceConstants.APPEARANCE_COMPRESS_PACKAGE_NAMES); return false; } private String getPkgNamePatternForPackagesView() { //IPreferenceStore store= PreferenceConstants.getPreferenceStore(); //if (!store.getBoolean(PreferenceConstants.APPEARANCE_COMPRESS_PACKAGE_NAMES)) return ""; //$NON-NLS-1$ //return store.getString(PreferenceConstants.APPEARANCE_PKG_NAME_PATTERN_FOR_PKG_VIEW); } private boolean isPackageNameAbbreviationEnabled() { //IPreferenceStore store= PreferenceConstants.getPreferenceStore(); //return store.getBoolean(PreferenceConstants.APPEARANCE_ABBREVIATE_PACKAGE_NAMES); return false; } private String getPkgNameAbbreviationPatternForPackagesView() { //IPreferenceStore store= PreferenceConstants.getPreferenceStore(); //if (!store.getBoolean(PreferenceConstants.APPEARANCE_ABBREVIATE_PACKAGE_NAMES)) return ""; //$NON-NLS-1$ //return store.getString(PreferenceConstants.APPEARANCE_PKG_NAME_ABBREVIATION_PATTERN_FOR_PKG_VIEW); } }