Attachment #118352 for bug #251693

View | Details | Raw Unified | Return to bug 251693
Collapse All | Expand All





import java.util.Map;

import org.eclipse.jdt.core.Flags;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.core.compiler.CharOperation;

				null/*taskPriorities*/,
				true/*taskCaseSensitive*/);
	}
	public static void suggestArgumentNames(IJavaProject javaProject, char[] packageName, char[] qualifiedTypeName, int dim, char[] internalPrefix, char[][] excludedNames, INamingRequestor requestor) {
		Map options = javaProject.getOptions(true);
		CompilerOptions compilerOptions = new CompilerOptions(options);
		AssistOptions assistOptions = new AssistOptions(options);

		suggestNames(
			packageName,
			qualifiedTypeName,
			dim,
			internalPrefix,
			assistOptions.argumentPrefixes,
			assistOptions.argumentSuffixes,
			excludedNames,
			getNameScanner(compilerOptions),
			requestor);
	}
	
	public static void suggestFieldNames(IJavaProject javaProject, char[] packageName, char[] qualifiedTypeName, int dim, int modifiers, char[] internalPrefix, char[][] excludedNames, INamingRequestor requestor) {
		boolean isStatic = Flags.isStatic(modifiers);

		Map options = javaProject.getOptions(true);
		CompilerOptions compilerOptions = new CompilerOptions(options);
		AssistOptions assistOptions = new AssistOptions(options);

		suggestNames(
			packageName,
			qualifiedTypeName,
			dim,
			internalPrefix,
			isStatic ? assistOptions.staticFieldPrefixes : assistOptions.fieldPrefixes,
			isStatic ? assistOptions.staticFieldSuffixes : assistOptions.fieldSuffixes,
			excludedNames,
			getNameScanner(compilerOptions),
			requestor);
	}
	public static void suggestLocalVariableNames(IJavaProject javaProject, char[] packageName, char[] qualifiedTypeName, int dim, char[] internalPrefix, char[][] excludedNames, INamingRequestor requestor) {
		Map options = javaProject.getOptions(true);
		CompilerOptions compilerOptions = new CompilerOptions(options);
		AssistOptions assistOptions = new AssistOptions(options);

		suggestNames(
			packageName,
			qualifiedTypeName,
			dim,
			internalPrefix,
			assistOptions.localPrefixes,
			assistOptions.localSuffixes,
			excludedNames,
			getNameScanner(compilerOptions),
			requestor);
	}

	private static void suggestNames(
		char[] packageName,
		char[] qualifiedTypeName,
		int dim,
		char[] internalPrefix,
		char[][] prefixes,
		char[][] suffixes,
		char[][] excludedNames,
		Scanner nameScanner,
		INamingRequestor requestor){

		if(qualifiedTypeName == null || qualifiedTypeName.length == 0)
			return;

		if(internalPrefix == null) {
			internalPrefix = CharOperation.NO_CHAR;
		} else {
			internalPrefix = removePrefix(internalPrefix, prefixes);
		}

		char[] typeName = CharOperation.lastSegment(qualifiedTypeName, '.');

		if(prefixes == null || prefixes.length == 0) {
			prefixes = new char[1][0];
		} else {
			int length = prefixes.length;
			System.arraycopy(prefixes, 0, prefixes = new char[length+1][], 0, length);
			prefixes[length] = CharOperation.NO_CHAR;
		}

		if(suffixes == null || suffixes.length == 0) {
			suffixes = new char[1][0];
		} else {
			int length = suffixes.length;
			System.arraycopy(suffixes, 0, suffixes = new char[length+1][], 0, length);
			suffixes[length] = CharOperation.NO_CHAR;
		}

		char[][] tempNames = null;

		// compute variable name for base type
		try{
			nameScanner.setSource(typeName);
			switch (nameScanner.getNextToken()) {
				case TerminalTokens.TokenNameint :
				case TerminalTokens.TokenNamebyte :
				case TerminalTokens.TokenNameshort :
				case TerminalTokens.TokenNamechar :
				case TerminalTokens.TokenNamelong :
				case TerminalTokens.TokenNamefloat :
				case TerminalTokens.TokenNamedouble :
				case TerminalTokens.TokenNameboolean :

					if (internalPrefix != null && internalPrefix.length > 0) return;

					char[] name = computeBaseTypeNames(typeName[0], excludedNames);
					if(name != null) {
						tempNames =  new char[][]{name};
					}
					break;
			}
		} catch(InvalidInputException e){
			// ignore
		}

		// compute variable name for non base type
		if(tempNames == null) {
			tempNames = computeNames(typeName);
		}

		boolean acceptDefaultName = true;
		SimpleSetOfCharArray foundNames = new SimpleSetOfCharArray();

		next : for (int i = 0; i < tempNames.length; i++) {
			char[] tempName = tempNames[i];
			if(dim > 0) {
				int length = tempName.length;
				if (tempName[length-1] == 's'){
					if(tempName.length > 1 && tempName[length-2] == 's') {
						System.arraycopy(tempName, 0, tempName = new char[length + 2], 0, length);
						tempName[length] = 'e';
						tempName[length+1] = 's';
					}
				} else if(tempName[length-1] == 'y') {
					System.arraycopy(tempName, 0, tempName = new char[length + 2], 0, length);
					tempName[length-1] = 'i';
					tempName[length] = 'e';
					tempName[length+1] = 's';
				} else {
					System.arraycopy(tempName, 0, tempName = new char[length + 1], 0, length);
					tempName[length] = 's';
				}
			}

			char[] unprefixedName = tempName;
			unprefixedName[0] = ScannerHelper.toUpperCase(unprefixedName[0]);
			for (int j = 0; j <= internalPrefix.length; j++) {
				if(j == internalPrefix.length ||
						CharOperation.prefixEquals(CharOperation.subarray(internalPrefix, j, -1), unprefixedName, j != 0 /*do not check case when there is no prefix*/)) {
					tempName = CharOperation.concat(CharOperation.subarray(internalPrefix, 0, j), unprefixedName);
					if(j == 0) tempName[0] = ScannerHelper.toLowerCase(tempName[0]);
					for (int k = 0; k < prefixes.length; k++) {
						if(prefixes[k].length > 0
							&& ScannerHelper.isLetterOrDigit(prefixes[k][prefixes[k].length - 1])) {
							tempName[0] = ScannerHelper.toUpperCase(tempName[0]);
						} else {
							tempName[0] = ScannerHelper.toLowerCase(tempName[0]);
						}
						char[] prefixName = CharOperation.concat(prefixes[k], tempName);
						for (int l = 0; l < suffixes.length; l++) {
							char[] suffixName = CharOperation.concat(prefixName, suffixes[l]);
							suffixName =
								excludeNames(
									suffixName,
									prefixName,
									suffixes[l],
									excludedNames);
							try{
								nameScanner.setSource(suffixName);
								switch (nameScanner.getNextToken()) {
									case TerminalTokens.TokenNameIdentifier :
										int token = nameScanner.getNextToken();
										if (token == TerminalTokens.TokenNameEOF && nameScanner.startPosition == suffixName.length) {
											if (!foundNames.includes(suffixName)) {
												acceptName(suffixName, prefixes[k], suffixes[l],  k == 0, l == 0, internalPrefix.length - j, requestor);
												foundNames.add(suffixName);
												acceptDefaultName = false;
											}
										}
										break;
									default:
										suffixName = CharOperation.concat(
											prefixName,
											String.valueOf(1).toCharArray(),
											suffixes[l]
										);
										suffixName =
											excludeNames(
												suffixName,
												prefixName,
												suffixes[l],
												excludedNames);
										nameScanner.setSource(suffixName);
										switch (nameScanner.getNextToken()) {
											case TerminalTokens.TokenNameIdentifier :
												token = nameScanner.getNextToken();
												if (token == TerminalTokens.TokenNameEOF && nameScanner.startPosition == suffixName.length) {
													if (!foundNames.includes(suffixName)) {
														acceptName(suffixName, prefixes[k], suffixes[l], k == 0, l == 0, internalPrefix.length - j, requestor);
														foundNames.add(suffixName);
														acceptDefaultName = false;
													}
												}
										}
								}
							} catch(InvalidInputException e){
								// ignore
							}
						}
					}
					continue next;
				}
			}
		}
		// if no names were found
		if(acceptDefaultName) {
			char[] name = excludeNames(DEFAULT_NAME, DEFAULT_NAME, CharOperation.NO_CHAR, excludedNames);
			requestor.acceptNameWithoutPrefixAndSuffix(name, 0);
		}
	}
	

	private static void acceptName(
		char[] name,

		return name;
	}

	private static char[][] computeNames(char[] sourceName){
		char[][] names = new char[5][];
		int nameCount = 0;
		boolean previousIsUpperCase = false;
		boolean previousIsLetter = true;
		for(int i = sourceName.length - 1 ; i >= 0 ; i--){
			boolean isUpperCase = ScannerHelper.isUpperCase(sourceName[i]);
			boolean isLetter = ScannerHelper.isLetter(sourceName[i]);
			if(isUpperCase && !previousIsUpperCase && previousIsLetter){
				char[] name = CharOperation.subarray(sourceName,i,sourceName.length);
				if(name.length > 1){
					if(nameCount == names.length) {
						System.arraycopy(names, 0, names = new char[nameCount * 2][], 0, nameCount);
					}
					name[0] = ScannerHelper.toLowerCase(name[0]);
					names[nameCount++] = name;
				}
			}
			previousIsUpperCase = isUpperCase;
			previousIsLetter = isLetter;
		}
		if(nameCount == 0){
			names[nameCount++] = CharOperation.toLowerCase(sourceName);
		}
		System.arraycopy(names, 0, names = new char[nameCount][], 0, nameCount);
		return names;
	}
	
	
	private static char[][] computeNonBaseTypeNames(char[] sourceName, boolean isConstantField){
		int length = sourceName.length;
		

				break;
		}
		
		return InternalNamingConventions.removeVariablePrefixAndSuffix(name, prefixes, suffixes, true);
	}
	
	private static char[] removeVariablePrefixAndSuffix(char[] name, char[][] prefixes, char[][] suffixes, boolean updateFirstCharacter) {


		return withoutPrefixName;
	}

	public static final boolean prefixEquals(char[] prefix, char[] name) {

		int max = prefix.length;
		if (name.length < max)
			return false;
		for (int i = max;
			--i >= 0;
			) // assumes the prefix is not larger than the name
				if (prefix[i] != name[i])
					return false;
			return true;
	}
	
	public static final int VK_STATIC_FIELD = 1;
	public static final int VK_INSTANCE_FIELD = 2;





import org.eclipse.jdt.core.compiler.CharOperation;

import org.eclipse.jdt.internal.codeassist.impl.AssistOptions;
import org.eclipse.jdt.internal.compiler.parser.ScannerHelper;
import org.eclipse.jdt.internal.core.INamingRequestor;
import org.eclipse.jdt.internal.core.InternalNamingConventions;

		return c;
	}

	private static char[] removePrefixAndSuffix(char[] name, char[][] prefixes, char[][] suffixes) {
		// remove longer prefix
		char[] withoutPrefixName = name;
		if (prefixes != null) {
			int bestLength = 0;
			for (int i= 0; i < prefixes.length; i++) {
				char[] prefix = prefixes[i];
				if (CharOperation.prefixEquals(prefix, name)) {
					int currLen = prefix.length;
					boolean lastCharIsLetter = ScannerHelper.isLetter(prefix[currLen - 1]);
					if(!lastCharIsLetter || (lastCharIsLetter && name.length > currLen && ScannerHelper.isUpperCase(name[currLen]))) {
						if (bestLength < currLen && name.length != currLen) {
							withoutPrefixName = CharOperation.subarray(name, currLen, name.length);
							bestLength = currLen;
						}
					}
				}
			}
		}

		// remove longer suffix
		char[] withoutSuffixName = withoutPrefixName;
		if(suffixes != null) {
			int bestLength = 0;
			for (int i = 0; i < suffixes.length; i++) {
				char[] suffix = suffixes[i];
				if(CharOperation.endsWith(withoutPrefixName, suffix)) {
					int currLen = suffix.length;
					if(bestLength < currLen && withoutPrefixName.length != currLen) {
						withoutSuffixName = CharOperation.subarray(withoutPrefixName, 0, withoutPrefixName.length - currLen);
						bestLength = currLen;
					}
				}
			}
		}

		withoutSuffixName[0] = ScannerHelper.toLowerCase(withoutSuffixName[0]);
		return withoutSuffixName;
	}

	/**
	 * Remove prefix and suffix from an argument name.
	 * <p>

	 * @deprecated Use {@link #getBaseName(int, String, IJavaProject)} instead with {@link #VK_PARAMETER} as variable kind.
	 */
	public static char[] removePrefixAndSuffixForArgumentName(IJavaProject javaProject, char[] argumentName) {
		return InternalNamingConventions.removeVariablePrefixAndSuffix(VK_PARAMETER, javaProject, argumentName);
		return	removePrefixAndSuffix(
			argumentName,
			assistOptions.argumentPrefixes,
			assistOptions.argumentSuffixes);
	}

	/**

	 * with {@link #VK_INSTANCE_FIELD} or {@link #VK_STATIC_FIELD} as variable kind.
	 */
	public static char[] removePrefixAndSuffixForFieldName(IJavaProject javaProject, char[] fieldName, int modifiers) {
		return InternalNamingConventions.removeVariablePrefixAndSuffix(
				Flags.isStatic(modifiers) ? VK_STATIC_FIELD : VK_INSTANCE_FIELD,
				javaProject,
				fieldName);
			isStatic ? assistOptions.staticFieldPrefixes : assistOptions.fieldPrefixes,
			isStatic ? assistOptions.staticFieldSuffixes : assistOptions.fieldSuffixes);
	}

	/**

	 * @deprecated Use {@link #getBaseName(int, String, IJavaProject)} instead with {@link #VK_LOCAL} as variable kind.
	 */
	public static char[] removePrefixAndSuffixForLocalVariableName(IJavaProject javaProject, char[] localName) {
		return InternalNamingConventions.removeVariablePrefixAndSuffix(VK_LOCAL, javaProject, localName);
		return	removePrefixAndSuffix(
			localName,
			assistOptions.localPrefixes,
			assistOptions.localSuffixes);
	}

	/**

			IJavaProject javaProject) {
		return String.valueOf(InternalNamingConventions.getBaseName(variableKind, javaProject, variableName.toCharArray()));
	}
	
	private static int getFieldVariableKind(int modifiers) {
		if (Flags.isStatic(modifiers)) {
			if (Flags.isFinal(modifiers)) {
				return VK_STATIC_FINAL_FIELD;
			}
			return VK_STATIC_FIELD;
		}
		return VK_INSTANCE_FIELD;
	}

	private static char[] suggestAccessorName(IJavaProject project, char[] fieldName, int modifiers) {
		char[] name = InternalNamingConventions.getBaseName(getFieldVariableKind(modifiers), project, fieldName);
		if (name.length > 0 && ScannerHelper.isLowerCase(name[0])) {
			name[0] = ScannerHelper.toUpperCase(name[0]);
		}

	 * @deprecated Use {@link #suggestVariableNames(int, int, String, IJavaProject, int, String[], boolean)} instead with {@link #VK_PARAMETER} as variable kind.
	 */
	public static char[][] suggestArgumentNames(IJavaProject javaProject, char[] packageName, char[] qualifiedTypeName, int dim, char[][] excludedNames) {
		if(qualifiedTypeName == null || qualifiedTypeName.length == 0)
			return CharOperation.NO_CHAR_CHAR;
		
		char[] typeName = CharOperation.lastSegment(qualifiedTypeName, '.');
		
 		NamingRequestor requestor = new NamingRequestor();
		InternalNamingConventions.suggestVariableNames(
				VK_PARAMETER,
				BK_TYPE_NAME,
				typeName,
				javaProject,
				dim,
				null,
				excludedNames,
				true,
				requestor);
 
 		return requestor.getResults();
	}

	/**

	 * with {@link #VK_INSTANCE_FIELD} or  {@link #VK_STATIC_FIELD} as variable kind.
	 */
	public static char[][] suggestFieldNames(IJavaProject javaProject, char[] packageName, char[] qualifiedTypeName, int dim, int modifiers, char[][] excludedNames) {
		if(qualifiedTypeName == null || qualifiedTypeName.length == 0)
			return CharOperation.NO_CHAR_CHAR;
		
		char[] typeName = CharOperation.lastSegment(qualifiedTypeName, '.');
		
 		NamingRequestor requestor = new NamingRequestor();
		InternalNamingConventions.suggestVariableNames(
				Flags.isStatic(modifiers) ? VK_STATIC_FIELD : VK_INSTANCE_FIELD,
				BK_TYPE_NAME,
				typeName,
				javaProject,
				dim,
				null,
				excludedNames,
				true,
				requestor);
 
 		return requestor.getResults();
	}

	/**

	 */
	public static char[] suggestGetterName(IJavaProject project, char[] fieldName, int modifiers, boolean isBoolean, char[][] excludedNames) {
		if (isBoolean) {
			char[] name = InternalNamingConventions.getBaseName(getFieldVariableKind(modifiers), project, fieldName);
			int prefixLen =  GETTER_BOOL_NAME.length;
			if (CharOperation.prefixEquals(GETTER_BOOL_NAME, name)
				&& name.length > prefixLen && ScannerHelper.isUpperCase(name[prefixLen])) {

	 * @deprecated Use {@link #suggestVariableNames(int, int, String, IJavaProject, int, String[], boolean)} instead with {@link #VK_LOCAL} as variable kind.
	 */
	public static char[][] suggestLocalVariableNames(IJavaProject javaProject, char[] packageName, char[] qualifiedTypeName, int dim, char[][] excludedNames) {
		if(qualifiedTypeName == null || qualifiedTypeName.length == 0)
			return CharOperation.NO_CHAR_CHAR;
		
		char[] typeName = CharOperation.lastSegment(qualifiedTypeName, '.');
		
		NamingRequestor requestor = new NamingRequestor();
		InternalNamingConventions.suggestVariableNames(
				VK_LOCAL,
				BK_TYPE_NAME,
				typeName,
				javaProject,
				dim,
				null,
				excludedNames,
				true,
				requestor);
 
		return requestor.getResults();

	}
	/**
	 * Suggest names for a local variable. The name is computed from variable's type

	public static char[] suggestSetterName(IJavaProject project, char[] fieldName, int modifiers, boolean isBoolean, char[][] excludedNames) {

		if (isBoolean) {
			char[] name = InternalNamingConventions.getBaseName(getFieldVariableKind(modifiers), project, fieldName);
			int prefixLen =  GETTER_BOOL_NAME.length;
			if (CharOperation.prefixEquals(GETTER_BOOL_NAME, name)
				&& name.length > prefixLen && ScannerHelper.isUpperCase(name[prefixLen])) {




		"getÉfield", //$NON-NLS-1$
		new String(suggestion));
}
public void testSuggestGetterName009() {
	Hashtable options = JavaCore.getOptions();
	options.put(JavaCore.CODEASSIST_STATIC_FINAL_FIELD_PREFIXES,"PRE_"); //$NON-NLS-1$
	options.put(JavaCore.CODEASSIST_STATIC_FINAL_FIELD_SUFFIXES,"_SUF"); //$NON-NLS-1$
	JavaCore.setOptions(options);

	char[] suggestion = NamingConventions.suggestGetterName(
		this.project,
		"PRE_FIELD_NAME_SUF".toCharArray(), //$NON-NLS-1$
		Flags.AccStatic | Flags.AccFinal,
		false,
		CharOperation.NO_CHAR_CHAR);

	assumeEquals(
		"getFieldName", //$NON-NLS-1$
		new String(suggestion));
}
public void testSuggestSetterName001() {
	char[] suggestion = NamingConventions.suggestSetterName(
		this.project,

		"setIsSomething", //$NON-NLS-1$
		new String(suggestion));
}
public void testSuggestSetterName003() {
	Hashtable options = JavaCore.getOptions();
	options.put(JavaCore.CODEASSIST_STATIC_FINAL_FIELD_PREFIXES,"PRE_"); //$NON-NLS-1$
	options.put(JavaCore.CODEASSIST_STATIC_FINAL_FIELD_SUFFIXES,"_SUF"); //$NON-NLS-1$
	JavaCore.setOptions(options);

	char[] suggestion = NamingConventions.suggestSetterName(
		this.project,
		"PRE_FIELD_NAME_SUF".toCharArray(), //$NON-NLS-1$
		Flags.AccStatic | Flags.AccFinal,
		false,
		CharOperation.NO_CHAR_CHAR);

	assumeEquals(
		"setFieldName", //$NON-NLS-1$
		new String(suggestion));
}
/*
 * bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=133562
 */

Return to bug 251693

Lines 1052-1057 Link Here

(-)src/org/eclipse/jdt/core/tests/model/NamingConventionTests.java (+34 lines)
1052	"getÉfield", //$NON-NLS-1$	1052	"getÉfield", //$NON-NLS-1$
1053	new String(suggestion));	1053	new String(suggestion));
1054	}	1054	}
		1055	public void testSuggestGetterName009() {
		1056	Hashtable options = JavaCore.getOptions();
		1057	options.put(JavaCore.CODEASSIST_STATIC_FINAL_FIELD_PREFIXES,"PRE_"); //$NON-NLS-1$
		1058	options.put(JavaCore.CODEASSIST_STATIC_FINAL_FIELD_SUFFIXES,"_SUF"); //$NON-NLS-1$
		1059	JavaCore.setOptions(options);
		1060
		1061	char[] suggestion = NamingConventions.suggestGetterName(
		1062	this.project,
		1063	"PRE_FIELD_NAME_SUF".toCharArray(), //$NON-NLS-1$
		1064	Flags.AccStatic \| Flags.AccFinal,
		1065	false,
		1066	CharOperation.NO_CHAR_CHAR);
		1067
		1068	assumeEquals(
		1069	"getFieldName", //$NON-NLS-1$
		1070	new String(suggestion));
		1071	}
1055	public void testSuggestSetterName001() {	1072	public void testSuggestSetterName001() {
1056	char[] suggestion = NamingConventions.suggestSetterName(	1073	char[] suggestion = NamingConventions.suggestSetterName(
1057	this.project,	1074	this.project,
Lines 1076-1081 Link Here
1076	"setIsSomething", //$NON-NLS-1$	1093	"setIsSomething", //$NON-NLS-1$
1077	new String(suggestion));	1094	new String(suggestion));
1078	}	1095	}
		1096	public void testSuggestSetterName003() {
		1097	Hashtable options = JavaCore.getOptions();
		1098	options.put(JavaCore.CODEASSIST_STATIC_FINAL_FIELD_PREFIXES,"PRE_"); //$NON-NLS-1$
		1099	options.put(JavaCore.CODEASSIST_STATIC_FINAL_FIELD_SUFFIXES,"_SUF"); //$NON-NLS-1$
		1100	JavaCore.setOptions(options);
		1101
		1102	char[] suggestion = NamingConventions.suggestSetterName(
		1103	this.project,
		1104	"PRE_FIELD_NAME_SUF".toCharArray(), //$NON-NLS-1$
		1105	Flags.AccStatic \| Flags.AccFinal,
		1106	false,
		1107	CharOperation.NO_CHAR_CHAR);
		1108
		1109	assumeEquals(
		1110	"setFieldName", //$NON-NLS-1$
		1111	new String(suggestion));
		1112	}
1079	/*	1113	/*
1080	* bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=133562	1114	* bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=133562
1081	*/	1115	*/

Lines 12-18 Link Here

(-)model/org/eclipse/jdt/internal/core/InternalNamingConventions.java (-267 / +1 lines)
12		12
13	import java.util.Map;	13	import java.util.Map;
14		14
15	import org.eclipse.jdt.core.Flags;
16	import org.eclipse.jdt.core.IJavaProject;	15	import org.eclipse.jdt.core.IJavaProject;
17	import org.eclipse.jdt.core.JavaCore;	16	import org.eclipse.jdt.core.JavaCore;
18	import org.eclipse.jdt.core.compiler.CharOperation;	17	import org.eclipse.jdt.core.compiler.CharOperation;
Lines 38-266 Link Here
38	null/taskPriorities/,	37	null/taskPriorities/,
39	true/taskCaseSensitive/);	38	true/taskCaseSensitive/);
40	}	39	}
41	public static void suggestArgumentNames(IJavaProject javaProject, char[] packageName, char[] qualifiedTypeName, int dim, char[] internalPrefix, char[][] excludedNames, INamingRequestor requestor) {
42	Map options = javaProject.getOptions(true);
43	CompilerOptions compilerOptions = new CompilerOptions(options);
44	AssistOptions assistOptions = new AssistOptions(options);
45
46	suggestNames(
47	packageName,
48	qualifiedTypeName,
49	dim,
50	internalPrefix,
51	assistOptions.argumentPrefixes,
52	assistOptions.argumentSuffixes,
53	excludedNames,
54	getNameScanner(compilerOptions),
55	requestor);
56	}
57
58	public static void suggestFieldNames(IJavaProject javaProject, char[] packageName, char[] qualifiedTypeName, int dim, int modifiers, char[] internalPrefix, char[][] excludedNames, INamingRequestor requestor) {
59	boolean isStatic = Flags.isStatic(modifiers);
60
61	Map options = javaProject.getOptions(true);
62	CompilerOptions compilerOptions = new CompilerOptions(options);
63	AssistOptions assistOptions = new AssistOptions(options);
64
65	suggestNames(
66	packageName,
67	qualifiedTypeName,
68	dim,
69	internalPrefix,
70	isStatic ? assistOptions.staticFieldPrefixes : assistOptions.fieldPrefixes,
71	isStatic ? assistOptions.staticFieldSuffixes : assistOptions.fieldSuffixes,
72	excludedNames,
73	getNameScanner(compilerOptions),
74	requestor);
75	}
76	public static void suggestLocalVariableNames(IJavaProject javaProject, char[] packageName, char[] qualifiedTypeName, int dim, char[] internalPrefix, char[][] excludedNames, INamingRequestor requestor) {
77	Map options = javaProject.getOptions(true);
78	CompilerOptions compilerOptions = new CompilerOptions(options);
79	AssistOptions assistOptions = new AssistOptions(options);
80
81	suggestNames(
82	packageName,
83	qualifiedTypeName,
84	dim,
85	internalPrefix,
86	assistOptions.localPrefixes,
87	assistOptions.localSuffixes,
88	excludedNames,
89	getNameScanner(compilerOptions),
90	requestor);
91	}
92
93	private static void suggestNames(
94	char[] packageName,
95	char[] qualifiedTypeName,
96	int dim,
97	char[] internalPrefix,
98	char[][] prefixes,
99	char[][] suffixes,
100	char[][] excludedNames,
101	Scanner nameScanner,
102	INamingRequestor requestor){
103
104	if(qualifiedTypeName == null \|\| qualifiedTypeName.length == 0)
105	return;
106
107	if(internalPrefix == null) {
108	internalPrefix = CharOperation.NO_CHAR;
109	} else {
110	internalPrefix = removePrefix(internalPrefix, prefixes);
111	}
112
113	char[] typeName = CharOperation.lastSegment(qualifiedTypeName, '.');
114
115	if(prefixes == null \|\| prefixes.length == 0) {
116	prefixes = new char[1][0];
117	} else {
118	int length = prefixes.length;
119	System.arraycopy(prefixes, 0, prefixes = new char[length+1][], 0, length);
120	prefixes[length] = CharOperation.NO_CHAR;
121	}
122
123	if(suffixes == null \|\| suffixes.length == 0) {
124	suffixes = new char[1][0];
125	} else {
126	int length = suffixes.length;
127	System.arraycopy(suffixes, 0, suffixes = new char[length+1][], 0, length);
128	suffixes[length] = CharOperation.NO_CHAR;
129	}
130
131	char[][] tempNames = null;
132
133	// compute variable name for base type
134	try{
135	nameScanner.setSource(typeName);
136	switch (nameScanner.getNextToken()) {
137	case TerminalTokens.TokenNameint :
138	case TerminalTokens.TokenNamebyte :
139	case TerminalTokens.TokenNameshort :
140	case TerminalTokens.TokenNamechar :
141	case TerminalTokens.TokenNamelong :
142	case TerminalTokens.TokenNamefloat :
143	case TerminalTokens.TokenNamedouble :
144	case TerminalTokens.TokenNameboolean :
145
146	if (internalPrefix != null && internalPrefix.length > 0) return;
147
148	char[] name = computeBaseTypeNames(typeName[0], excludedNames);
149	if(name != null) {
150	tempNames = new char[][]{name};
151	}
152	break;
153	}
154	} catch(InvalidInputException e){
155	// ignore
156	}
157
158	// compute variable name for non base type
159	if(tempNames == null) {
160	tempNames = computeNames(typeName);
161	}
162
163	boolean acceptDefaultName = true;
164	SimpleSetOfCharArray foundNames = new SimpleSetOfCharArray();
165
166	next : for (int i = 0; i < tempNames.length; i++) {
167	char[] tempName = tempNames[i];
168	if(dim > 0) {
169	int length = tempName.length;
170	if (tempName[length-1] == 's'){
171	if(tempName.length > 1 && tempName[length-2] == 's') {
172	System.arraycopy(tempName, 0, tempName = new char[length + 2], 0, length);
173	tempName[length] = 'e';
174	tempName[length+1] = 's';
175	}
176	} else if(tempName[length-1] == 'y') {
177	System.arraycopy(tempName, 0, tempName = new char[length + 2], 0, length);
178	tempName[length-1] = 'i';
179	tempName[length] = 'e';
180	tempName[length+1] = 's';
181	} else {
182	System.arraycopy(tempName, 0, tempName = new char[length + 1], 0, length);
183	tempName[length] = 's';
184	}
185	}
186
187	char[] unprefixedName = tempName;
188	unprefixedName[0] = ScannerHelper.toUpperCase(unprefixedName[0]);
189	for (int j = 0; j <= internalPrefix.length; j++) {
190	if(j == internalPrefix.length \|\|
191	CharOperation.prefixEquals(CharOperation.subarray(internalPrefix, j, -1), unprefixedName, j != 0 /do not check case when there is no prefix/)) {
192	tempName = CharOperation.concat(CharOperation.subarray(internalPrefix, 0, j), unprefixedName);
193	if(j == 0) tempName[0] = ScannerHelper.toLowerCase(tempName[0]);
194	for (int k = 0; k < prefixes.length; k++) {
195	if(prefixes[k].length > 0
196	&& ScannerHelper.isLetterOrDigit(prefixes[k][prefixes[k].length - 1])) {
197	tempName[0] = ScannerHelper.toUpperCase(tempName[0]);
198	} else {
199	tempName[0] = ScannerHelper.toLowerCase(tempName[0]);
200	}
201	char[] prefixName = CharOperation.concat(prefixes[k], tempName);
202	for (int l = 0; l < suffixes.length; l++) {
203	char[] suffixName = CharOperation.concat(prefixName, suffixes[l]);
204	suffixName =
205	excludeNames(
206	suffixName,
207	prefixName,
208	suffixes[l],
209	excludedNames);
210	try{
211	nameScanner.setSource(suffixName);
212	switch (nameScanner.getNextToken()) {
213	case TerminalTokens.TokenNameIdentifier :
214	int token = nameScanner.getNextToken();
215	if (token == TerminalTokens.TokenNameEOF && nameScanner.startPosition == suffixName.length) {
216	if (!foundNames.includes(suffixName)) {
217	acceptName(suffixName, prefixes[k], suffixes[l], k == 0, l == 0, internalPrefix.length - j, requestor);
218	foundNames.add(suffixName);
219	acceptDefaultName = false;
220	}
221	}
222	break;
223	default:
224	suffixName = CharOperation.concat(
225	prefixName,
226	String.valueOf(1).toCharArray(),
227	suffixes[l]
228	);
229	suffixName =
230	excludeNames(
231	suffixName,
232	prefixName,
233	suffixes[l],
234	excludedNames);
235	nameScanner.setSource(suffixName);
236	switch (nameScanner.getNextToken()) {
237	case TerminalTokens.TokenNameIdentifier :
238	token = nameScanner.getNextToken();
239	if (token == TerminalTokens.TokenNameEOF && nameScanner.startPosition == suffixName.length) {
240	if (!foundNames.includes(suffixName)) {
241	acceptName(suffixName, prefixes[k], suffixes[l], k == 0, l == 0, internalPrefix.length - j, requestor);
242	foundNames.add(suffixName);
243	acceptDefaultName = false;
244	}
245	}
246	}
247	}
248	} catch(InvalidInputException e){
249	// ignore
250	}
251	}
252	}
253	continue next;
254	}
255	}
256	}
257	// if no names were found
258	if(acceptDefaultName) {
259	char[] name = excludeNames(DEFAULT_NAME, DEFAULT_NAME, CharOperation.NO_CHAR, excludedNames);
260	requestor.acceptNameWithoutPrefixAndSuffix(name, 0);
261	}
262	}
263
264		40
265	private static void acceptName(	41	private static void acceptName(
266	char[] name,	42	char[] name,
Lines 311-345 Link Here
311	return name;	87	return name;
312	}	88	}
313		89
314	private static char[][] computeNames(char[] sourceName){
315	char[][] names = new char[5][];
316	int nameCount = 0;
317	boolean previousIsUpperCase = false;
318	boolean previousIsLetter = true;
319	for(int i = sourceName.length - 1 ; i >= 0 ; i--){
320	boolean isUpperCase = ScannerHelper.isUpperCase(sourceName[i]);
321	boolean isLetter = ScannerHelper.isLetter(sourceName[i]);
322	if(isUpperCase && !previousIsUpperCase && previousIsLetter){
323	char[] name = CharOperation.subarray(sourceName,i,sourceName.length);
324	if(name.length > 1){
325	if(nameCount == names.length) {
326	System.arraycopy(names, 0, names = new char[nameCount * 2][], 0, nameCount);
327	}
328	name[0] = ScannerHelper.toLowerCase(name[0]);
329	names[nameCount++] = name;
330	}
331	}
332	previousIsUpperCase = isUpperCase;
333	previousIsLetter = isLetter;
334	}
335	if(nameCount == 0){
336	names[nameCount++] = CharOperation.toLowerCase(sourceName);
337	}
338	System.arraycopy(names, 0, names = new char[nameCount][], 0, nameCount);
339	return names;
340	}
341
342
343	private static char[][] computeNonBaseTypeNames(char[] sourceName, boolean isConstantField){	90	private static char[][] computeNonBaseTypeNames(char[] sourceName, boolean isConstantField){
344	int length = sourceName.length;	91	int length = sourceName.length;
345		92
Lines 626-632 Link Here
626	break;	373	break;
627	}	374	}
628		375
629	return InternalNamingConventions.removeVariablePrefixAndSuffix(name, prefixes, suffixes, true);	376	return InternalNamingConventions.removeVariablePrefixAndSuffix(name, prefixes, suffixes, true);
630	}	377	}
631		378
632	private static char[] removeVariablePrefixAndSuffix(char[] name, char[][] prefixes, char[][] suffixes, boolean updateFirstCharacter) {	379	private static char[] removeVariablePrefixAndSuffix(char[] name, char[][] prefixes, char[][] suffixes, boolean updateFirstCharacter) {
Lines 741-759 Link Here
741		488
742	return withoutPrefixName;	489	return withoutPrefixName;
743	}	490	}
744
745	public static final boolean prefixEquals(char[] prefix, char[] name) {
746
747	int max = prefix.length;
748	if (name.length < max)
749	return false;
750	for (int i = max;
751	--i >= 0;
752	) // assumes the prefix is not larger than the name
753	if (prefix[i] != name[i])
754	return false;
755	return true;
756	}
757		491
758	public static final int VK_STATIC_FIELD = 1;	492	public static final int VK_STATIC_FIELD = 1;
759	public static final int VK_INSTANCE_FIELD = 2;	493	public static final int VK_INSTANCE_FIELD = 2;

Lines 12-18 Link Here

(-)model/org/eclipse/jdt/core/NamingConventions.java (-92 / +72 lines)
12		12
13	import org.eclipse.jdt.core.compiler.CharOperation;	13	import org.eclipse.jdt.core.compiler.CharOperation;
14		14
15	import org.eclipse.jdt.internal.codeassist.impl.AssistOptions;
16	import org.eclipse.jdt.internal.compiler.parser.ScannerHelper;	15	import org.eclipse.jdt.internal.compiler.parser.ScannerHelper;
17	import org.eclipse.jdt.internal.core.INamingRequestor;	16	import org.eclipse.jdt.internal.core.INamingRequestor;
18	import org.eclipse.jdt.internal.core.InternalNamingConventions;	17	import org.eclipse.jdt.internal.core.InternalNamingConventions;
Lines 316-361 Link Here
316	return c;	315	return c;
317	}	316	}
318		317
319	private static char[] removePrefixAndSuffix(char[] name, char[][] prefixes, char[][] suffixes) {
320	// remove longer prefix
321	char[] withoutPrefixName = name;
322	if (prefixes != null) {
323	int bestLength = 0;
324	for (int i= 0; i < prefixes.length; i++) {
325	char[] prefix = prefixes[i];
326	if (CharOperation.prefixEquals(prefix, name)) {
327	int currLen = prefix.length;
328	boolean lastCharIsLetter = ScannerHelper.isLetter(prefix[currLen - 1]);
329	if(!lastCharIsLetter \|\| (lastCharIsLetter && name.length > currLen && ScannerHelper.isUpperCase(name[currLen]))) {
330	if (bestLength < currLen && name.length != currLen) {
331	withoutPrefixName = CharOperation.subarray(name, currLen, name.length);
332	bestLength = currLen;
333	}
334	}
335	}
336	}
337	}
338
339	// remove longer suffix
340	char[] withoutSuffixName = withoutPrefixName;
341	if(suffixes != null) {
342	int bestLength = 0;
343	for (int i = 0; i < suffixes.length; i++) {
344	char[] suffix = suffixes[i];
345	if(CharOperation.endsWith(withoutPrefixName, suffix)) {
346	int currLen = suffix.length;
347	if(bestLength < currLen && withoutPrefixName.length != currLen) {
348	withoutSuffixName = CharOperation.subarray(withoutPrefixName, 0, withoutPrefixName.length - currLen);
349	bestLength = currLen;
350	}
351	}
352	}
353	}
354
355	withoutSuffixName[0] = ScannerHelper.toLowerCase(withoutSuffixName[0]);
356	return withoutSuffixName;
357	}
358
359	/**	318	/**
360	* Remove prefix and suffix from an argument name.	319	* Remove prefix and suffix from an argument name.
361	* <p>	320	* <p>
Lines 382-392 Link Here
382	* @deprecated Use {@link #getBaseName(int, String, IJavaProject)} instead with {@link #VK_PARAMETER} as variable kind.	341	* @deprecated Use {@link #getBaseName(int, String, IJavaProject)} instead with {@link #VK_PARAMETER} as variable kind.
383	*/	342	*/
384	public static char[] removePrefixAndSuffixForArgumentName(IJavaProject javaProject, char[] argumentName) {	343	public static char[] removePrefixAndSuffixForArgumentName(IJavaProject javaProject, char[] argumentName) {
385	AssistOptions assistOptions = new AssistOptions(javaProject.getOptions(true));	344	return InternalNamingConventions.removeVariablePrefixAndSuffix(VK_PARAMETER, javaProject, argumentName);
386	return removePrefixAndSuffix(
387	argumentName,
388	assistOptions.argumentPrefixes,
389	assistOptions.argumentSuffixes);
390	}	345	}
391		346
392	/**	347	/**
Lines 448-459 Link Here
448	* with {@link #VK_INSTANCE_FIELD} or {@link #VK_STATIC_FIELD} as variable kind.	403	* with {@link #VK_INSTANCE_FIELD} or {@link #VK_STATIC_FIELD} as variable kind.
449	*/	404	*/
450	public static char[] removePrefixAndSuffixForFieldName(IJavaProject javaProject, char[] fieldName, int modifiers) {	405	public static char[] removePrefixAndSuffixForFieldName(IJavaProject javaProject, char[] fieldName, int modifiers) {
451	boolean isStatic = Flags.isStatic(modifiers);	406	return InternalNamingConventions.removeVariablePrefixAndSuffix(
452	AssistOptions assistOptions = new AssistOptions(javaProject.getOptions(true));	407	Flags.isStatic(modifiers) ? VK_STATIC_FIELD : VK_INSTANCE_FIELD,
453	return removePrefixAndSuffix(	408	javaProject,
454	fieldName,	409	fieldName);
455	isStatic ? assistOptions.staticFieldPrefixes : assistOptions.fieldPrefixes,
456	isStatic ? assistOptions.staticFieldSuffixes : assistOptions.fieldSuffixes);
457	}	410	}
458		411
459	/**	412	/**
Lines 516-526 Link Here
516	* @deprecated Use {@link #getBaseName(int, String, IJavaProject)} instead with {@link #VK_LOCAL} as variable kind.	469	* @deprecated Use {@link #getBaseName(int, String, IJavaProject)} instead with {@link #VK_LOCAL} as variable kind.
517	*/	470	*/
518	public static char[] removePrefixAndSuffixForLocalVariableName(IJavaProject javaProject, char[] localName) {	471	public static char[] removePrefixAndSuffixForLocalVariableName(IJavaProject javaProject, char[] localName) {
519	AssistOptions assistOptions = new AssistOptions(javaProject.getOptions(true));	472	return InternalNamingConventions.removeVariablePrefixAndSuffix(VK_LOCAL, javaProject, localName);
520	return removePrefixAndSuffix(
521	localName,
522	assistOptions.localPrefixes,
523	assistOptions.localSuffixes);
524	}	473	}
525		474
526	/**	475	/**
Lines 590-598 Link Here
590	IJavaProject javaProject) {	539	IJavaProject javaProject) {
591	return String.valueOf(InternalNamingConventions.getBaseName(variableKind, javaProject, variableName.toCharArray()));	540	return String.valueOf(InternalNamingConventions.getBaseName(variableKind, javaProject, variableName.toCharArray()));
592	}	541	}
		542
		543	private static int getFieldVariableKind(int modifiers) {
		544	if (Flags.isStatic(modifiers)) {
		545	if (Flags.isFinal(modifiers)) {
		546	return VK_STATIC_FINAL_FIELD;
		547	}
		548	return VK_STATIC_FIELD;
		549	}
		550	return VK_INSTANCE_FIELD;
		551	}
593		552
594	private static char[] suggestAccessorName(IJavaProject project, char[] fieldName, int modifiers) {	553	private static char[] suggestAccessorName(IJavaProject project, char[] fieldName, int modifiers) {
595	char[] name = removePrefixAndSuffixForFieldName(project, fieldName, modifiers);	554	char[] name = InternalNamingConventions.getBaseName(getFieldVariableKind(modifiers), project, fieldName);
596	if (name.length > 0 && ScannerHelper.isLowerCase(name[0])) {	555	if (name.length > 0 && ScannerHelper.isLowerCase(name[0])) {
597	name[0] = ScannerHelper.toUpperCase(name[0]);	556	name[0] = ScannerHelper.toUpperCase(name[0]);
598	}	557	}
Lines 630-646 Link Here
630	* @deprecated Use {@link #suggestVariableNames(int, int, String, IJavaProject, int, String[], boolean)} instead with {@link #VK_PARAMETER} as variable kind.	589	* @deprecated Use {@link #suggestVariableNames(int, int, String, IJavaProject, int, String[], boolean)} instead with {@link #VK_PARAMETER} as variable kind.
631	*/	590	*/
632	public static char[][] suggestArgumentNames(IJavaProject javaProject, char[] packageName, char[] qualifiedTypeName, int dim, char[][] excludedNames) {	591	public static char[][] suggestArgumentNames(IJavaProject javaProject, char[] packageName, char[] qualifiedTypeName, int dim, char[][] excludedNames) {
633	NamingRequestor requestor = new NamingRequestor();	592	if(qualifiedTypeName == null \|\| qualifiedTypeName.length == 0)
634	InternalNamingConventions.suggestArgumentNames(	593	return CharOperation.NO_CHAR_CHAR;
635	javaProject,	594
636	packageName,	595	char[] typeName = CharOperation.lastSegment(qualifiedTypeName, '.');
637	qualifiedTypeName,	596
638	dim,	597	NamingRequestor requestor = new NamingRequestor();
639	null,	598	InternalNamingConventions.suggestVariableNames(
640	excludedNames,	599	VK_PARAMETER,
641	requestor);	600	BK_TYPE_NAME,
642		601	typeName,
643	return requestor.getResults();	602	javaProject,
		603	dim,
		604	null,
		605	excludedNames,
		606	true,
		607	requestor);
		608
		609	return requestor.getResults();
644	}	610	}
645		611
646	/**	612	/**
Lines 719-736 Link Here
719	* with {@link #VK_INSTANCE_FIELD} or {@link #VK_STATIC_FIELD} as variable kind.	685	* with {@link #VK_INSTANCE_FIELD} or {@link #VK_STATIC_FIELD} as variable kind.
720	*/	686	*/
721	public static char[][] suggestFieldNames(IJavaProject javaProject, char[] packageName, char[] qualifiedTypeName, int dim, int modifiers, char[][] excludedNames) {	687	public static char[][] suggestFieldNames(IJavaProject javaProject, char[] packageName, char[] qualifiedTypeName, int dim, int modifiers, char[][] excludedNames) {
722	NamingRequestor requestor = new NamingRequestor();	688	if(qualifiedTypeName == null \|\| qualifiedTypeName.length == 0)
723	InternalNamingConventions.suggestFieldNames(	689	return CharOperation.NO_CHAR_CHAR;
724	javaProject,	690
725	packageName,	691	char[] typeName = CharOperation.lastSegment(qualifiedTypeName, '.');
726	qualifiedTypeName,	692
727	dim,	693	NamingRequestor requestor = new NamingRequestor();
728	modifiers,	694	InternalNamingConventions.suggestVariableNames(
729	null,	695	Flags.isStatic(modifiers) ? VK_STATIC_FIELD : VK_INSTANCE_FIELD,
730	excludedNames,	696	BK_TYPE_NAME,
731	requestor);	697	typeName,
732		698	javaProject,
733	return requestor.getResults();	699	dim,
		700	null,
		701	excludedNames,
		702	true,
		703	requestor);
		704
		705	return requestor.getResults();
734	}	706	}
735		707
736	/**	708	/**
Lines 812-818 Link Here
812	*/	784	*/
813	public static char[] suggestGetterName(IJavaProject project, char[] fieldName, int modifiers, boolean isBoolean, char[][] excludedNames) {	785	public static char[] suggestGetterName(IJavaProject project, char[] fieldName, int modifiers, boolean isBoolean, char[][] excludedNames) {
814	if (isBoolean) {	786	if (isBoolean) {
815	char[] name = removePrefixAndSuffixForFieldName(project, fieldName, modifiers);	787	char[] name = InternalNamingConventions.getBaseName(getFieldVariableKind(modifiers), project, fieldName);
816	int prefixLen = GETTER_BOOL_NAME.length;	788	int prefixLen = GETTER_BOOL_NAME.length;
817	if (CharOperation.prefixEquals(GETTER_BOOL_NAME, name)	789	if (CharOperation.prefixEquals(GETTER_BOOL_NAME, name)
818	&& name.length > prefixLen && ScannerHelper.isUpperCase(name[prefixLen])) {	790	&& name.length > prefixLen && ScannerHelper.isUpperCase(name[prefixLen])) {
Lines 901-917 Link Here
901	* @deprecated Use {@link #suggestVariableNames(int, int, String, IJavaProject, int, String[], boolean)} instead with {@link #VK_LOCAL} as variable kind.	873	* @deprecated Use {@link #suggestVariableNames(int, int, String, IJavaProject, int, String[], boolean)} instead with {@link #VK_LOCAL} as variable kind.
902	*/	874	*/
903	public static char[][] suggestLocalVariableNames(IJavaProject javaProject, char[] packageName, char[] qualifiedTypeName, int dim, char[][] excludedNames) {	875	public static char[][] suggestLocalVariableNames(IJavaProject javaProject, char[] packageName, char[] qualifiedTypeName, int dim, char[][] excludedNames) {
		876	if(qualifiedTypeName == null \|\| qualifiedTypeName.length == 0)
		877	return CharOperation.NO_CHAR_CHAR;
		878
		879	char[] typeName = CharOperation.lastSegment(qualifiedTypeName, '.');
		880
904	NamingRequestor requestor = new NamingRequestor();	881	NamingRequestor requestor = new NamingRequestor();
905	InternalNamingConventions.suggestLocalVariableNames(	882	InternalNamingConventions.suggestVariableNames(
906	javaProject,	883	VK_LOCAL,
907	packageName,	884	BK_TYPE_NAME,
908	qualifiedTypeName,	885	typeName,
909	dim,	886	javaProject,
910	null,	887	dim,
911	excludedNames,	888	null,
912	requestor);	889	excludedNames,
913		890	true,
		891	requestor);
		892
914	return requestor.getResults();	893	return requestor.getResults();
		894
915	}	895	}
916	/**	896	/**
917	* Suggest names for a local variable. The name is computed from variable's type	897	* Suggest names for a local variable. The name is computed from variable's type
Lines 1004-1010 Link Here
1004	public static char[] suggestSetterName(IJavaProject project, char[] fieldName, int modifiers, boolean isBoolean, char[][] excludedNames) {	984	public static char[] suggestSetterName(IJavaProject project, char[] fieldName, int modifiers, boolean isBoolean, char[][] excludedNames) {
1005		985
1006	if (isBoolean) {	986	if (isBoolean) {
1007	char[] name = removePrefixAndSuffixForFieldName(project, fieldName, modifiers);	987	char[] name = InternalNamingConventions.getBaseName(getFieldVariableKind(modifiers), project, fieldName);
1008	int prefixLen = GETTER_BOOL_NAME.length;	988	int prefixLen = GETTER_BOOL_NAME.length;
1009	if (CharOperation.prefixEquals(GETTER_BOOL_NAME, name)	989	if (CharOperation.prefixEquals(GETTER_BOOL_NAME, name)
1010	&& name.length > prefixLen && ScannerHelper.isUpperCase(name[prefixLen])) {	990	&& name.length > prefixLen && ScannerHelper.isUpperCase(name[prefixLen])) {