Attachment #39534 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(IllegalArgumentException e) {
			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
		if (start >= string.length) {
			throw new IllegalArgumentException();
		}
		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) {
		// need a minimum 1 char
		if (start >= string.length) {
			throw new IllegalArgumentException();
		}
		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) {
		// need a minimum 2 char
		if (start >= string.length - 1) {
			throw new IllegalArgumentException();
		}
		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) {
		int length = string.length;
		// need a minimum 2 char
		if (start >= length - 1) {
			throw new IllegalArgumentException();
		}
		char c = string[start];
		if (c != Signature.C_ARRAY) {
			throw new IllegalArgumentException();
		}
		
		int index = start;
		c = string[++index];
		while(c == Signature.C_ARRAY) {
			// need a minimum 2 char
			if (index >= length - 1) {
				throw new IllegalArgumentException();
			}
			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) {
		// need a minimum 3 chars "Lx;"
		if (start >= string.length - 2) { 
			throw new IllegalArgumentException();
		}
		// 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) {
			if (p >= string.length) {
				throw new IllegalArgumentException();
			}
			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 (+252 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(IllegalArgumentException e) {
		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	if (start >= string.length) {
		2929	throw new IllegalArgumentException();
		2930	}
		2931	char c = string[start];
		2932	if (isVarArgs) {
		2933	switch (c) {
		2934	case Signature.C_ARRAY :
		2935	return appendArrayTypeSignatureForAnchor(string, start, buffer, true);
		2936	case Signature.C_RESOLVED :
		2937	case Signature.C_TYPE_VARIABLE :
		2938	case Signature.C_BOOLEAN :
		2939	case Signature.C_BYTE :
		2940	case Signature.C_CHAR :
		2941	case Signature.C_DOUBLE :
		2942	case Signature.C_FLOAT :
		2943	case Signature.C_INT :
		2944	case Signature.C_LONG :
		2945	case Signature.C_SHORT :
2946	case Signature.C_VOID :
2947	case Signature.C_STAR:
2948	case Signature.C_EXTENDS:
2949	case Signature.C_SUPER:
2950	case Signature.C_CAPTURE:
2951	default:
2952	throw new IllegalArgumentException(); // a var args is an array type
2953	}
2954	} else {
2955	switch (c) {
2956	case Signature.C_ARRAY :
2957	return appendArrayTypeSignatureForAnchor(string, start, buffer, false);
2958	case Signature.C_RESOLVED :
2959	return appendClassTypeSignatureForAnchor(string, start, buffer);
2960	case Signature.C_TYPE_VARIABLE :
2961	int e = Util.scanTypeVariableSignature(string, start);
2962	buffer.append(string, start + 1, e - start - 1);
2963	return e;
2964	case Signature.C_BOOLEAN :
2965	buffer.append(BOOLEAN);
2966	return start;
2967	case Signature.C_BYTE :
2968	buffer.append(BYTE);
2969	return start;
2970	case Signature.C_CHAR :
2971	buffer.append(CHAR);
2972	return start;
2973	case Signature.C_DOUBLE :
2974	buffer.append(DOUBLE);
2975	return start;
2976	case Signature.C_FLOAT :
2977	buffer.append(FLOAT);
2978	return start;
2979	case Signature.C_INT :
2980	buffer.append(INT);
2981	return start;
2982	case Signature.C_LONG :
2983	buffer.append(LONG);
2984	return start;
2985	case Signature.C_SHORT :
2986	buffer.append(SHORT);
2987	return start;
2988	case Signature.C_VOID :
2989	buffer.append(VOID);
2990	return start;
2991	case Signature.C_CAPTURE :
2992	return appendCaptureTypeSignatureForAnchor(string, start, buffer);
2993	case Signature.C_STAR:
2994	case Signature.C_EXTENDS:
2995	case Signature.C_SUPER:
2996	return appendTypeArgumentSignatureForAnchor(string, start, buffer);
2997	default :
2998	throw new IllegalArgumentException();
2999	}
3000	}
3001	}
3002	private static int appendTypeArgumentSignatureForAnchor(char[] string, int start, StringBuffer buffer) {
3003	// need a minimum 1 char
3004	if (start >= string.length) {
3005	throw new IllegalArgumentException();
3006	}
3007	char c = string[start];
3008	switch(c) {
3009	case Signature.C_STAR :
3010	return start;
3011	case Signature.C_EXTENDS :
3012	return appendTypeSignatureForAnchor(string, start + 1, buffer, false);
3013	case Signature.C_SUPER :
3014	return appendTypeSignatureForAnchor(string, start + 1, buffer, false);
3015	default :
3016	return appendTypeSignatureForAnchor(string, start, buffer, false);
3017	}
3018	}
3019	private static int appendCaptureTypeSignatureForAnchor(char[] string, int start, StringBuffer buffer) {
3020	// need a minimum 2 char
3021	if (start >= string.length - 1) {
3022	throw new IllegalArgumentException();
3023	}
3024	char c = string[start];
3025	if (c != Signature.C_CAPTURE) {
3026	throw new IllegalArgumentException();
3027	}
3028	return appendTypeArgumentSignatureForAnchor(string, start + 1, buffer);
3029	}
3030	private static int appendArrayTypeSignatureForAnchor(char[] string, int start, StringBuffer buffer, boolean isVarArgs) {
3031	int length = string.length;
3032	// need a minimum 2 char
3033	if (start >= length - 1) {
3034	throw new IllegalArgumentException();
3035	}
3036	char c = string[start];
3037	if (c != Signature.C_ARRAY) {
3038	throw new IllegalArgumentException();
3039	}
3040
3041	int index = start;
3042	c = string[++index];
3043	while(c == Signature.C_ARRAY) {
3044	// need a minimum 2 char
3045	if (index >= length - 1) {
3046	throw new IllegalArgumentException();
3047	}
3048	c = string[++index];
3049	}
3050
3051	int e = appendTypeSignatureForAnchor(string, index, buffer, false);
3052
3053	for(int i = 1, dims = index - start; i < dims; i++) {
3054	buffer.append('[').append(']');
3055	}
3056
3057	if (isVarArgs) {
3058	buffer.append('.').append('.').append('.');
3059	} else {
3060	buffer.append('[').append(']');
3061	}
3062	return e;
3063	}
3064	private static int appendClassTypeSignatureForAnchor(char[] string, int start, StringBuffer buffer) {
3065	// need a minimum 3 chars "Lx;"
3066	if (start >= string.length - 2) {
3067	throw new IllegalArgumentException();
3068	}
3069	// must start in "L" or "Q"
3070	char c = string[start];
3071	if (c != Signature.C_RESOLVED && c != Signature.C_UNRESOLVED) {
3072	throw new IllegalArgumentException();
3073	}
3074	int p = start + 1;
3075	while (true) {
3076	if (p >= string.length) {
3077	throw new IllegalArgumentException();
3078	}
3079	c = string[p];
3080	switch(c) {
3081	case Signature.C_SEMICOLON :
3082	// all done
3083	return p;
3084	case Signature.C_GENERIC_START :
3085	int e = scanGenericEnd(string, p + 1);
3086	// once we hit type arguments there are no more package prefixes
3087	p = e;
3088	break;
3089	case Signature.C_DOT :
3090	buffer.append('.');
3091	break;
3092	case '/' :
3093	buffer.append('/');
3094	break;
3095	case Signature.C_DOLLAR :
3096	// once we hit "$" there are no more package prefixes
3097	/**
3098	* Convert '$' in resolved type signatures into '.'.
3099	* NOTE: This assumes that the type signature is an inner type
3100	* signature. This is true in most cases, but someone can define a
3101	* non-inner type name containing a '$'.
3102	*/
3103	buffer.append('.');
3104	break;
3105	default :
3106	buffer.append(c);
3107	}
3108	p++;
3109	}
3110	}
3111	private static int scanGenericEnd(char[] string, int start) {
3112	if (string[start] == Signature.C_GENERIC_END) {
3113	return start;
3114	}
3115	int length = string.length;
3116	int balance = 1;
3117	start++;
3118	while (start <= length) {
3119	switch(string[start]) {
3120	case Signature.C_GENERIC_END :
3121	balance--;
3122	if (balance == 0) {
3123	return start;
3124	}
3125	break;
3126	case Signature.C_GENERIC_START :
3127	balance++;
3128	break;
3129	}
3130	start++;
3131	}
3132	return start;
3133	}
2882	}	3134	}