Attachment #39421 for bug #138167




 */

/* package */ class BinaryMethod extends BinaryMember implements IMethod {

	/**
	 * The parameter type signatures of the method - stored locally
	 * to perform equality test. <code>null</code> indicates no

	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()));
	} else {
		anchor = Signature.toString(this.getSignature().replace('/', '.'), methodName, null, true, false, Flags.isVarargs(this.getFlags()));
	}
	if (declaringTypeIsMember) {

		int depth = 0;




		}
		return typeSignatures;
	}
	
	public static String toAnchor(char[] methodSignature, String methodName, boolean isVarArgs) {
		return new String(toAnchor(methodSignature, methodName.toCharArray(), isVarArgs));
	}
	public 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 = searchGenericEnd(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 searchGenericEnd(char[] string, int start) {
		if (start >= string.length) {
			throw new IllegalArgumentException();
		}
		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 25-31 Link Here

(-)model/org/eclipse/jdt/internal/core/BinaryMethod.java (-2 / +9 lines)
25	*/	25	*/
26		26
27	/* package */ class BinaryMethod extends BinaryMember implements IMethod {	27	/* package */ class BinaryMethod extends BinaryMember implements IMethod {
28
29	/**	28	/**
30	* The parameter type signatures of the method - stored locally	29	* The parameter type signatures of the method - stored locally
31	* to perform equality test. <code>null</code> indicates no	30	* to perform equality test. <code>null</code> indicates no
Lines 491-497 Link Here
491	if (this.isConstructor()) {	490	if (this.isConstructor()) {
492	methodName = typeQualifiedName;	491	methodName = typeQualifiedName;
493	}	492	}
494	String anchor = Signature.toString(this.getSignature().replace('/', '.'), methodName, null, true, false, Flags.isVarargs(this.getFlags()));	493	IBinaryMethod info = (IBinaryMethod) getElementInfo();
		494	char[] genericSignature = info.getGenericSignature();
		495	String anchor = null;
		496	if (genericSignature != null) {
		497	CharOperation.replace(genericSignature, '/', '.');
		498	anchor = Util.toAnchor(genericSignature, methodName, Flags.isVarargs(this.getFlags()));
		499	} else {
		500	anchor = Signature.toString(this.getSignature().replace('/', '.'), methodName, null, true, false, Flags.isVarargs(this.getFlags()));
		501	}
495	if (declaringTypeIsMember) {	502	if (declaringTypeIsMember) {
496		503
497	int depth = 0;	504	int depth = 0;

Lines 2879-2882 Link Here

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