Attachment #39464 for bug #138167




	if (this.isConstructor()) {
		methodName = typeQualifiedName;
	}
	IBinaryMethod info = (IBinaryMethod) getElementInfo();
	char[] genericSignature = info.getGenericSignature();
	String anchor = null;
	if (genericSignature != null) {
		CharOperation.replace(genericSignature, '/', '.');
		anchor = Util.toAnchor(genericSignature, methodName, Flags.isVarargs(this.getFlags()));
		if (anchor == null) throw new JavaModelException(new JavaModelStatus(IJavaModelStatusConstants.UNKNOWN_JAVADOC_FORMAT, this));
	} else {
		anchor = Signature.toString(this.getSignature().replace('/', '.'), methodName, null, true, false, Flags.isVarargs(this.getFlags()));
	}
	if (declaringTypeIsMember) {

		int depth = 0;




		}
		return typeSignatures;
	}
	
	/*
	 * Can throw IllegalArgumentException or ArrayIndexOutOfBoundsException 
	 */
	public static String toAnchor(char[] methodSignature, String methodName, boolean isVarArgs) {
		try {
			return new String(toAnchor(methodSignature, methodName.toCharArray(), isVarArgs));
		} catch(RuntimeException exception) {
			return null;
		}
	}
	private static char[] toAnchor(char[] methodSignature, char[] methodName, boolean isVargArgs) {
		int firstParen = CharOperation.indexOf(Signature.C_PARAM_START, methodSignature);
		if (firstParen == -1) {
			throw new IllegalArgumentException();
		}
		
		StringBuffer buffer = new StringBuffer(methodSignature.length + 10);

		// selector
		if (methodName != null) {
			buffer.append(methodName);
		}
		
		// parameters
		buffer.append('(');
		char[][] pts = Signature.getParameterTypes(methodSignature);
		for (int i = 0, max = pts.length; i < max; i++) {
			if (i == max - 1) {
				appendTypeSignatureForAnchor(pts[i], 0 , buffer, isVargArgs);
			} else {
				appendTypeSignatureForAnchor(pts[i], 0 , buffer, false);
			}
			if (i != pts.length - 1) {
				buffer.append(',');
				buffer.append(' ');
			}
		}
		buffer.append(')');
		char[] result = new char[buffer.length()];
		buffer.getChars(0, buffer.length(), result, 0);
		return result;
	}

	private static int appendTypeSignatureForAnchor(char[] string, int start, StringBuffer buffer, boolean isVarArgs) {
		// need a minimum 1 char
		char c = string[start];
		if (isVarArgs) {
			switch (c) {
				case Signature.C_ARRAY :
					return appendArrayTypeSignatureForAnchor(string, start, buffer, true);
				case Signature.C_RESOLVED :
				case Signature.C_TYPE_VARIABLE :
				case Signature.C_BOOLEAN :
				case Signature.C_BYTE :
				case Signature.C_CHAR :
				case Signature.C_DOUBLE :
				case Signature.C_FLOAT :
				case Signature.C_INT :
				case Signature.C_LONG :
				case Signature.C_SHORT :
				case Signature.C_VOID :
				case Signature.C_STAR:
				case Signature.C_EXTENDS:
				case Signature.C_SUPER:
				case Signature.C_CAPTURE:
				default:
					throw new IllegalArgumentException(); // a var args is an array type
			}
		} else {
			switch (c) {
				case Signature.C_ARRAY :
					return appendArrayTypeSignatureForAnchor(string, start, buffer, false);
				case Signature.C_RESOLVED :
					return appendClassTypeSignatureForAnchor(string, start, buffer);
				case Signature.C_TYPE_VARIABLE :
					int e = Util.scanTypeVariableSignature(string, start);
					buffer.append(string, start + 1, e - start - 1);
					return e;
				case Signature.C_BOOLEAN :
					buffer.append(BOOLEAN);
					return start;
				case Signature.C_BYTE :
					buffer.append(BYTE);
					return start;
				case Signature.C_CHAR :
					buffer.append(CHAR);
					return start;
				case Signature.C_DOUBLE :
					buffer.append(DOUBLE);
					return start;
				case Signature.C_FLOAT :
					buffer.append(FLOAT);
					return start;
				case Signature.C_INT :
					buffer.append(INT);
					return start;
				case Signature.C_LONG :
					buffer.append(LONG);
					return start;
				case Signature.C_SHORT :
					buffer.append(SHORT);
					return start;
				case Signature.C_VOID :
					buffer.append(VOID);
					return start;
				case Signature.C_CAPTURE :
					return appendCaptureTypeSignatureForAnchor(string, start, buffer);
				case Signature.C_STAR:
				case Signature.C_EXTENDS:
				case Signature.C_SUPER:
					return appendTypeArgumentSignatureForAnchor(string, start, buffer);
				default :
					throw new IllegalArgumentException();
			}
		}
	}
	private static int appendTypeArgumentSignatureForAnchor(char[] string, int start, StringBuffer buffer) {
		char c = string[start];
		switch(c) {
			case Signature.C_STAR :
				return start;
			case Signature.C_EXTENDS :
				return appendTypeSignatureForAnchor(string, start + 1, buffer, false);
			case Signature.C_SUPER :
				return appendTypeSignatureForAnchor(string, start + 1, buffer, false);
			default :
				return appendTypeSignatureForAnchor(string, start, buffer, false);
		}
	}
	private static int appendCaptureTypeSignatureForAnchor(char[] string, int start, StringBuffer buffer) {
		char c = string[start];
		if (c != Signature.C_CAPTURE) {
			throw new IllegalArgumentException();
		}
		return appendTypeArgumentSignatureForAnchor(string, start + 1, buffer);
	}
	private static int appendArrayTypeSignatureForAnchor(char[] string, int start, StringBuffer buffer, boolean isVarArgs) {
		char c = string[start];
		if (c != Signature.C_ARRAY) {
			throw new IllegalArgumentException();
		}
		
		int index = start;
		c = string[++index];
		while(c == Signature.C_ARRAY) {
			c = string[++index];
		}
		
		int e = appendTypeSignatureForAnchor(string, index, buffer, false);
		
		for(int i = 1, dims = index - start; i < dims; i++) {
			buffer.append('[').append(']');
		}
		
		if (isVarArgs) {
			buffer.append('.').append('.').append('.');
		} else {
			buffer.append('[').append(']');
		}
		return e;
	}
	private static int appendClassTypeSignatureForAnchor(char[] string, int start, StringBuffer buffer) {
		// must start in "L" or "Q"
		char c = string[start];
		if (c != Signature.C_RESOLVED && c != Signature.C_UNRESOLVED) {
			throw new IllegalArgumentException();
		}
		int p = start + 1;
		while (true) {
			c = string[p];
			switch(c) {
				case Signature.C_SEMICOLON :
					// all done
					return p;
				case Signature.C_GENERIC_START :
					int e = scanGenericEnd(string, p + 1);
					// once we hit type arguments there are no more package prefixes
					p = e;
					break;
				case Signature.C_DOT :
					buffer.append('.');
					break;
				 case '/' :
					buffer.append('/');
					break;
				 case Signature.C_DOLLAR :
					// once we hit "$" there are no more package prefixes
					/**
					 * Convert '$' in resolved type signatures into '.'.
					 * NOTE: This assumes that the type signature is an inner type
					 * signature. This is true in most cases, but someone can define a
					 * non-inner type name containing a '$'.
					 */
					buffer.append('.');
				 	break;
				 default :
					buffer.append(c);
			}
			p++;
		}
	}
	private static int scanGenericEnd(char[] string, int start) {
		if (string[start] == Signature.C_GENERIC_END) {
			return start;
		}
		int length = string.length;
		int balance = 1;
		start++;
		while (start <= length) {
			switch(string[start]) {
				case Signature.C_GENERIC_END :
					balance--;
					if (balance == 0) {
						return start;
					}
					break;
				case Signature.C_GENERIC_START :
					balance++;
					break;
			}
			start++;
		}
		return start;
	}
}

Return to bug 138167

Lines 491-497 Link Here

(-)model/org/eclipse/jdt/internal/core/BinaryMethod.java (-1 / +10 lines)
491	if (this.isConstructor()) {	491	if (this.isConstructor()) {
492	methodName = typeQualifiedName;	492	methodName = typeQualifiedName;
493	}	493	}
494	String anchor = Signature.toString(this.getSignature().replace('/', '.'), methodName, null, true, false, Flags.isVarargs(this.getFlags()));	494	IBinaryMethod info = (IBinaryMethod) getElementInfo();
		495	char[] genericSignature = info.getGenericSignature();
		496	String anchor = null;
		497	if (genericSignature != null) {
		498	CharOperation.replace(genericSignature, '/', '.');
		499	anchor = Util.toAnchor(genericSignature, methodName, Flags.isVarargs(this.getFlags()));
		500	if (anchor == null) throw new JavaModelException(new JavaModelStatus(IJavaModelStatusConstants.UNKNOWN_JAVADOC_FORMAT, this));
		501	} else {
		502	anchor = Signature.toString(this.getSignature().replace('/', '.'), methodName, null, true, false, Flags.isVarargs(this.getFlags()));
		503	}
495	if (declaringTypeIsMember) {	504	if (declaringTypeIsMember) {
496		505
497	int depth = 0;	506	int depth = 0;

Lines 2879-2882 Link Here

(-)model/org/eclipse/jdt/internal/core/util/Util.java (+225 lines)
2879	}	2879	}
2880	return typeSignatures;	2880	return typeSignatures;
2881	}	2881	}
		2882
		2883	/*
		2884	* Can throw IllegalArgumentException or ArrayIndexOutOfBoundsException
		2885	*/
		2886	public static String toAnchor(char[] methodSignature, String methodName, boolean isVarArgs) {
		2887	try {
		2888	return new String(toAnchor(methodSignature, methodName.toCharArray(), isVarArgs));
		2889	} catch(RuntimeException exception) {
		2890	return null;
		2891	}
		2892	}
		2893	private static char[] toAnchor(char[] methodSignature, char[] methodName, boolean isVargArgs) {
		2894	int firstParen = CharOperation.indexOf(Signature.C_PARAM_START, methodSignature);
		2895	if (firstParen == -1) {
		2896	throw new IllegalArgumentException();
		2897	}
		2898
		2899	StringBuffer buffer = new StringBuffer(methodSignature.length + 10);
		2900
		2901	// selector
		2902	if (methodName != null) {
		2903	buffer.append(methodName);
		2904	}
		2905
		2906	// parameters
		2907	buffer.append('(');
		2908	char[][] pts = Signature.getParameterTypes(methodSignature);
		2909	for (int i = 0, max = pts.length; i < max; i++) {
		2910	if (i == max - 1) {
		2911	appendTypeSignatureForAnchor(pts[i], 0 , buffer, isVargArgs);
		2912	} else {
		2913	appendTypeSignatureForAnchor(pts[i], 0 , buffer, false);
		2914	}
		2915	if (i != pts.length - 1) {
		2916	buffer.append(',');
		2917	buffer.append(' ');
		2918	}
		2919	}
		2920	buffer.append(')');
		2921	char[] result = new char[buffer.length()];
		2922	buffer.getChars(0, buffer.length(), result, 0);
		2923	return result;
		2924	}
		2925
		2926	private static int appendTypeSignatureForAnchor(char[] string, int start, StringBuffer buffer, boolean isVarArgs) {
		2927	// need a minimum 1 char
		2928	char c = string[start];
		2929	if (isVarArgs) {
		2930	switch (c) {
		2931	case Signature.C_ARRAY :
		2932	return appendArrayTypeSignatureForAnchor(string, start, buffer, true);
		2933	case Signature.C_RESOLVED :
		2934	case Signature.C_TYPE_VARIABLE :
		2935	case Signature.C_BOOLEAN :
		2936	case Signature.C_BYTE :
		2937	case Signature.C_CHAR :
		2938	case Signature.C_DOUBLE :
		2939	case Signature.C_FLOAT :
		2940	case Signature.C_INT :
		2941	case Signature.C_LONG :
		2942	case Signature.C_SHORT :
		2943	case Signature.C_VOID :
		2944	case Signature.C_STAR:
		2945	case Signature.C_EXTENDS:
2946	case Signature.C_SUPER:
2947	case Signature.C_CAPTURE:
2948	default:
2949	throw new IllegalArgumentException(); // a var args is an array type
2950	}
2951	} else {
2952	switch (c) {
2953	case Signature.C_ARRAY :
2954	return appendArrayTypeSignatureForAnchor(string, start, buffer, false);
2955	case Signature.C_RESOLVED :
2956	return appendClassTypeSignatureForAnchor(string, start, buffer);
2957	case Signature.C_TYPE_VARIABLE :
2958	int e = Util.scanTypeVariableSignature(string, start);
2959	buffer.append(string, start + 1, e - start - 1);
2960	return e;
2961	case Signature.C_BOOLEAN :
2962	buffer.append(BOOLEAN);
2963	return start;
2964	case Signature.C_BYTE :
2965	buffer.append(BYTE);
2966	return start;
2967	case Signature.C_CHAR :
2968	buffer.append(CHAR);
2969	return start;
2970	case Signature.C_DOUBLE :
2971	buffer.append(DOUBLE);
2972	return start;
2973	case Signature.C_FLOAT :
2974	buffer.append(FLOAT);
2975	return start;
2976	case Signature.C_INT :
2977	buffer.append(INT);
2978	return start;
2979	case Signature.C_LONG :
2980	buffer.append(LONG);
2981	return start;
2982	case Signature.C_SHORT :
2983	buffer.append(SHORT);
2984	return start;
2985	case Signature.C_VOID :
2986	buffer.append(VOID);
2987	return start;
2988	case Signature.C_CAPTURE :
2989	return appendCaptureTypeSignatureForAnchor(string, start, buffer);
2990	case Signature.C_STAR:
2991	case Signature.C_EXTENDS:
2992	case Signature.C_SUPER:
2993	return appendTypeArgumentSignatureForAnchor(string, start, buffer);
2994	default :
2995	throw new IllegalArgumentException();
2996	}
2997	}
2998	}
2999	private static int appendTypeArgumentSignatureForAnchor(char[] string, int start, StringBuffer buffer) {
3000	char c = string[start];
3001	switch(c) {
3002	case Signature.C_STAR :
3003	return start;
3004	case Signature.C_EXTENDS :
3005	return appendTypeSignatureForAnchor(string, start + 1, buffer, false);
3006	case Signature.C_SUPER :
3007	return appendTypeSignatureForAnchor(string, start + 1, buffer, false);
3008	default :
3009	return appendTypeSignatureForAnchor(string, start, buffer, false);
3010	}
3011	}
3012	private static int appendCaptureTypeSignatureForAnchor(char[] string, int start, StringBuffer buffer) {
3013	char c = string[start];
3014	if (c != Signature.C_CAPTURE) {
3015	throw new IllegalArgumentException();
3016	}
3017	return appendTypeArgumentSignatureForAnchor(string, start + 1, buffer);
3018	}
3019	private static int appendArrayTypeSignatureForAnchor(char[] string, int start, StringBuffer buffer, boolean isVarArgs) {
3020	char c = string[start];
3021	if (c != Signature.C_ARRAY) {
3022	throw new IllegalArgumentException();
3023	}
3024
3025	int index = start;
3026	c = string[++index];
3027	while(c == Signature.C_ARRAY) {
3028	c = string[++index];
3029	}
3030
3031	int e = appendTypeSignatureForAnchor(string, index, buffer, false);
3032
3033	for(int i = 1, dims = index - start; i < dims; i++) {
3034	buffer.append('[').append(']');
3035	}
3036
3037	if (isVarArgs) {
3038	buffer.append('.').append('.').append('.');
3039	} else {
3040	buffer.append('[').append(']');
3041	}
3042	return e;
3043	}
3044	private static int appendClassTypeSignatureForAnchor(char[] string, int start, StringBuffer buffer) {
3045	// must start in "L" or "Q"
3046	char c = string[start];
3047	if (c != Signature.C_RESOLVED && c != Signature.C_UNRESOLVED) {
3048	throw new IllegalArgumentException();
3049	}
3050	int p = start + 1;
3051	while (true) {
3052	c = string[p];
3053	switch(c) {
3054	case Signature.C_SEMICOLON :
3055	// all done
3056	return p;
3057	case Signature.C_GENERIC_START :
3058	int e = scanGenericEnd(string, p + 1);
3059	// once we hit type arguments there are no more package prefixes
3060	p = e;
3061	break;
3062	case Signature.C_DOT :
3063	buffer.append('.');
3064	break;
3065	case '/' :
3066	buffer.append('/');
3067	break;
3068	case Signature.C_DOLLAR :
3069	// once we hit "$" there are no more package prefixes
3070	/**
3071	* Convert '$' in resolved type signatures into '.'.
3072	* NOTE: This assumes that the type signature is an inner type
3073	* signature. This is true in most cases, but someone can define a
3074	* non-inner type name containing a '$'.
3075	*/
3076	buffer.append('.');
3077	break;
3078	default :
3079	buffer.append(c);
3080	}
3081	p++;
3082	}
3083	}
3084	private static int scanGenericEnd(char[] string, int start) {
3085	if (string[start] == Signature.C_GENERIC_END) {
3086	return start;
3087	}
3088	int length = string.length;
3089	int balance = 1;
3090	start++;
3091	while (start <= length) {
3092	switch(string[start]) {
3093	case Signature.C_GENERIC_END :
3094	balance--;
3095	if (balance == 0) {
3096	return start;
3097	}
3098	break;
3099	case Signature.C_GENERIC_START :
3100	balance++;
3101	break;
3102	}
3103	start++;
3104	}
3105	return start;
3106	}
2882	}	3107	}