Attachment #115175 for bug #38111





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;
import org.eclipse.jdt.core.compiler.InvalidInputException;
import org.eclipse.jdt.internal.codeassist.impl.AssistOptions;

				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,

		}
	}

	private static char[][] computeBaseTypeNames(char[] typeName, boolean isConstantField, char[][] excludedNames){
		char[] name = computeBaseTypeNames(typeName[0], excludedNames);
		if(name != null) {
			return new char[][]{name};
		} else {
			// compute variable name like from non base type
			return  computeNonBaseTypeNames(typeName, isConstantField);
		}
	}
	private static char[] computeBaseTypeNames(char firstName, char[][] excludedNames){
		char[] name = new char[]{firstName};



		return name;
	}
	
	private static char[][] computeNonBaseTypeNames(char[] sourceName, boolean isConstantField){
		int length = sourceName.length;
		
		if (length == 0) {
			return CharOperation.NO_CHAR_CHAR;
		}
		
		if (length == 1) {
			return new char[][]{CharOperation.toLowerCase(sourceName)};
		}
		
		char[][] nameParts = new char[length][];
		int namePartsPtr = -1;
		
		int endIndex = length;
		boolean previousIsLowerCase = ScannerHelper.isLowerCase(sourceName[length - 1]);
		boolean previousIsUpperCase = ScannerHelper.isUpperCase(sourceName[length - 1]);
		
		for(int i = length - 1 ; i >= 0 ; i--){
			boolean isLowerCase = ScannerHelper.isLowerCase(sourceName[i]);
			boolean isUpperCase = ScannerHelper.isUpperCase(sourceName[i]);
			// if a character is not upper case and not lower case then it is not a letter
			
			if (isUpperCase) {
				if (previousIsLowerCase) {
					nameParts[++namePartsPtr] = CharOperation.subarray(sourceName, i, endIndex);
					if (i > 0) {
						previousIsLowerCase = ScannerHelper.isLowerCase(sourceName[i - 1]);
						previousIsUpperCase = ScannerHelper.isUpperCase(sourceName[i - 1]);
					}
					endIndex = i;
				}
			} else if (isLowerCase) {
				if (previousIsUpperCase) {
					nameParts[++namePartsPtr] = CharOperation.subarray(sourceName, i + 1, endIndex);
					endIndex = i + 1;
				}
				previousIsLowerCase = isLowerCase;
				previousIsUpperCase = isUpperCase;
			}
			previousIsUpperCase = isUpperCase;
			previousIsLetter = isLetter;
		}
		if (endIndex > 0) {
			nameParts[++namePartsPtr] = CharOperation.subarray(sourceName, 0, endIndex);
		}
		
		if (isConstantField) {
			return generateConstantName(nameParts, namePartsPtr);
		} else {
			return generateNonConstantName(nameParts, namePartsPtr);
		}
		System.arraycopy(names, 0, names = new char[nameCount][], 0, nameCount);
		return names;
	}
	
	

	private static char[] excludeNames(
		char[] suffixName,

		}
		return suffixName;
	}
	
	private static char[][] generateNonConstantName(char[][] nameParts, int namePartsPtr) {
		char[][] names = new char[namePartsPtr + 1][];
		
		char[] namePart = CharOperation.toLowerCase(nameParts[0]);
		int namePartLength = namePart.length;
		System.arraycopy(namePart, 0, namePart, 0, namePartLength);
		
		char[] name = namePart;
		
		names[namePartsPtr] = name;
		
		for (int i = 1; i <= namePartsPtr; i++) {
			namePart = CharOperation.toLowerCase(nameParts[i]);
			namePartLength = namePart.length;
			name = CharOperation.concat(namePart, name);
			name[namePartLength] = ScannerHelper.toUpperCase(name[namePartLength]);
			
			names[namePartsPtr - i] = name;
		}
		return names;
	}

	private static char[][] generateConstantName(char[][] nameParts, int namePartsPtr) {
		char[][] names = new char[namePartsPtr + 1][];
		
		char[] namePart = CharOperation.toUpperCase(nameParts[0]);
		int namePartLength = namePart.length;
		System.arraycopy(namePart, 0, namePart, 0, namePartLength);
		
		char[] name = namePart;
		
		names[namePartsPtr] = name;
		
		for (int i = 1; i <= namePartsPtr; i++) {
			namePart = CharOperation.toUpperCase(nameParts[i]);
			namePartLength = namePart.length;
			if (namePart[namePartLength - 1] != '_') {
				name = CharOperation.concat(namePart, name, '_');
			} else {
				name = CharOperation.concat(namePart, name);
			}
			
			names[namePartsPtr - i] = name;
		}
		return names;
	}
	
	public static char[] getBaseName(
			int variableKind,
			IJavaProject javaProject,
			char[] name) {
		
		AssistOptions assistOptions;
		if (javaProject != null) {
			assistOptions = new AssistOptions(javaProject.getOptions(true));
		} else {
			assistOptions = new AssistOptions(JavaCore.getOptions());
		}
		
		char[][] prefixes = null;
		char[][] suffixes = null;
		switch (variableKind) {
			case VK_INSTANCE_FIELD:
				prefixes = assistOptions.fieldPrefixes;
				suffixes = assistOptions.fieldSuffixes;
				break;
			case VK_STATIC_FIELD:
				prefixes = assistOptions.staticFieldPrefixes;
				suffixes = assistOptions.staticFieldSuffixes;
				break;
			case VK_CONSTANT_FIELD:
				prefixes = assistOptions.staticFinalFieldPrefixes;
				suffixes = assistOptions.staticFinalFieldSuffixes;
				break;
			case VK_LOCAL:
				prefixes = assistOptions.localPrefixes;
				suffixes = assistOptions.localSuffixes;
				break;
			case VK_PARAMETER:
				prefixes = assistOptions.argumentPrefixes;
				suffixes = assistOptions.argumentSuffixes;
				break;
		}
		
		
		return getBaseName(name, prefixes, suffixes, variableKind == VK_CONSTANT_FIELD);
	}

	private static char[] getBaseName(char[] name, char[][] prefixes, char[][] suffixes, boolean isConstant) {
		char[] nameWithoutPrefixAndSiffix = removeVariablePrefixAndSuffix(name, prefixes, suffixes, false);
		
		char[] baseName;
		if (isConstant) {
			int length = nameWithoutPrefixAndSiffix.length;
			baseName = new char[length];
			int baseNamePtr = -1;
			
			boolean previousIsUnderscore = false;
			for (int i = 0; i < length; i++) {
				char c = nameWithoutPrefixAndSiffix[i];
				if (c != '_') {
					if (previousIsUnderscore || i == 0) {
						baseName[++baseNamePtr] = ScannerHelper.toUpperCase(c);
						previousIsUnderscore = false;
					} else {
						baseName[++baseNamePtr] = ScannerHelper.toLowerCase(c);
					}
				} else {
					previousIsUnderscore = true;
				}
			}
			System.arraycopy(baseName, 0, baseName = new char[baseNamePtr + 1], 0, baseNamePtr + 1);
		} else {
			baseName = nameWithoutPrefixAndSiffix;
		}
		
		return baseName;
	}
	
	public static char[] removeVariablePrefixAndSuffix(
			int variableKind,
			IJavaProject javaProject,
			char[] name) {
		AssistOptions assistOptions;
		if (javaProject != null) {
			assistOptions = new AssistOptions(javaProject.getOptions(true));
		} else {
			assistOptions = new AssistOptions(JavaCore.getOptions());
		}
		
		char[][] prefixes = null;
		char[][] suffixes = null;
		switch (variableKind) {
			case VK_INSTANCE_FIELD:
				prefixes = assistOptions.fieldPrefixes;
				suffixes = assistOptions.fieldSuffixes;
				break;
			case VK_STATIC_FIELD:
				prefixes = assistOptions.staticFieldPrefixes;
				suffixes = assistOptions.staticFieldSuffixes;
				break;
			case VK_CONSTANT_FIELD:
				prefixes = assistOptions.staticFinalFieldPrefixes;
				suffixes = assistOptions.staticFinalFieldSuffixes;
				break;
			case VK_LOCAL:
				prefixes = assistOptions.localPrefixes;
				suffixes = assistOptions.localSuffixes;
				break;
			case VK_PARAMETER:
				prefixes = assistOptions.argumentPrefixes;
				suffixes = assistOptions.argumentSuffixes;
				break;
		}
		
		return InternalNamingConventions.removeVariablePrefixAndSuffix(name,	prefixes, suffixes, true);
	}
	
	private static char[] removeVariablePrefixAndSuffix(char[] name, char[][] prefixes, char[][] suffixes, boolean updateFirstCharacter) {
		// 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;
					}
				}
			}
		}

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

	private static char[] removePrefix(char[] name, char[][] prefixes) {
		// remove longer prefix

					return false;
			return true;
	}
	
	public static final int VK_STATIC_FIELD = 1;
	public static final int VK_INSTANCE_FIELD = 2;
	public static final int VK_CONSTANT_FIELD = 3;
	public static final int VK_PARAMETER = 4;
	public static final int VK_LOCAL = 5;
	
	public static final int BK_SIMPLE_NAME = 1;
	public static final int BK_SIMPLE_TYPE_NAME = 2;

	public static void suggestVariableNames(
			int variableKind,
			int baseNameKind,
			char[] baseName,
			IJavaProject javaProject,
			int dim,
			char[] internalPrefix,
			char[][] excluded,
			boolean evaluateDefault,
			INamingRequestor requestor) {
		
		if(baseName == null || baseName.length == 0)
			return;
		
		Map options;
		if (javaProject != null) {
			options = javaProject.getOptions(true);
		} else {
			options = JavaCore.getOptions();
		}
		CompilerOptions compilerOptions = new CompilerOptions(options);
		AssistOptions assistOptions = new AssistOptions(options);
		
		boolean isConstantField = false;
		
		char[][] prefixes = null;
		char[][] suffixes = null;
		switch (variableKind) {
			case VK_INSTANCE_FIELD:
				prefixes = assistOptions.fieldPrefixes;
				suffixes = assistOptions.fieldSuffixes;
				break;
			case VK_STATIC_FIELD:
				prefixes = assistOptions.staticFieldPrefixes;
				suffixes = assistOptions.staticFieldSuffixes;
				break;
			case VK_CONSTANT_FIELD:
				isConstantField = true;
				prefixes = assistOptions.staticFinalFieldPrefixes;
				suffixes = assistOptions.staticFinalFieldSuffixes;
				break;
			case VK_LOCAL:
				prefixes = assistOptions.localPrefixes;
				suffixes = assistOptions.localSuffixes;
				break;
			case VK_PARAMETER:
				prefixes = assistOptions.argumentPrefixes;
				suffixes = assistOptions.argumentSuffixes;
				break;
		}
		
		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;
		}
		
		if(internalPrefix == null) {
			internalPrefix = CharOperation.NO_CHAR;
		} else {
			internalPrefix = removePrefix(internalPrefix, prefixes);
		}

		char[][] tempNames = null;
		
		Scanner nameScanner = getNameScanner(compilerOptions);
		if (baseNameKind == BK_SIMPLE_TYPE_NAME) {
			boolean isBaseType = false;
			
			try{
				nameScanner.setSource(baseName);
				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 :
						isBaseType = true;
						break;
				}
			} catch(InvalidInputException e){
				// ignore
			}
			if (isBaseType) {
				// compute variable name from base type
				if (internalPrefix.length > 0) return;
	
				tempNames = computeBaseTypeNames(baseName, isConstantField, excluded);
			} else {
				// compute variable name for non base type
				tempNames = computeNonBaseTypeNames(baseName, isConstantField);
			}
		} else {
			tempNames = new char[][]{baseName};
		}

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

		for (int i = 0; i < tempNames.length; i++) {
			char[] tempName = tempNames[i];
			
			// add English plural form is necessary
			if(dim > 0) {
				int length = tempName.length;
				
				if (isConstantField) {
					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';
					}
				} else {
					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;
			
			int matchingIndex = -1;
			if (!isConstantField) {
				unprefixedName[0] = ScannerHelper.toUpperCase(unprefixedName[0]);
				
				done : 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*/)) {
						matchingIndex = j;
						break done;
					}
				}
			} else {
				done : for (int j = 0; j <= internalPrefix.length; j++) {
					if(j == internalPrefix.length) {
						matchingIndex = j;
						break done;
					} else if(CharOperation.prefixEquals(CharOperation.subarray(internalPrefix, j, -1), unprefixedName, j != 0 /*do not check case when there is no prefix*/)) {
						if (j == 0 || internalPrefix[j - 1] == '_') {
							matchingIndex = j;
							break done;
						}
						
					}
				}
			}

			if(matchingIndex > -1) {
				if (!isConstantField) {
					tempName = CharOperation.concat(CharOperation.subarray(internalPrefix, 0, matchingIndex), unprefixedName);
					if(matchingIndex == 0) tempName[0] = ScannerHelper.toLowerCase(tempName[0]);
				} else {
					if(matchingIndex != 0 && tempName[0] != '_' && internalPrefix[matchingIndex - 1] != '_') {
						tempName = CharOperation.concat(CharOperation.subarray(CharOperation.toUpperCase(internalPrefix), 0, matchingIndex), unprefixedName, '_');
					} else {
						tempName = CharOperation.concat(CharOperation.subarray(CharOperation.toUpperCase(internalPrefix), 0, matchingIndex), unprefixedName);
					}
				}
				
				for (int k = 0; k < prefixes.length; k++) {
					if (!isConstantField) {
						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],
								excluded);
						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 - matchingIndex, requestor);
											foundNames.add(suffixName);
											acceptDefaultName = false;
										}
									}
									break;
								default:
									suffixName = CharOperation.concat(
										prefixName,
										String.valueOf(1).toCharArray(),
										suffixes[l]
									);
									suffixName =
										excludeNames(
											suffixName,
											prefixName,
											suffixes[l],
											excluded);
									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 - matchingIndex, requestor);
													foundNames.add(suffixName);
													acceptDefaultName = false;
												}
											}
									}
							}
						} catch(InvalidInputException e){
							// ignore
						}
					}
				}
			}
		}
		// if no names were found
		if(evaluateDefault && acceptDefaultName) {
			char[] name = excludeNames(DEFAULT_NAME, DEFAULT_NAME, CharOperation.NO_CHAR, excluded);
			requestor.acceptNameWithoutPrefixAndSuffix(name, 0);
		}
	}
}




		defaultOptionsMap.put(JavaCore.CODEASSIST_IMPLICIT_QUALIFICATION, JavaCore.DISABLED);
		defaultOptionsMap.put(JavaCore.CODEASSIST_FIELD_PREFIXES, ""); //$NON-NLS-1$
		defaultOptionsMap.put(JavaCore.CODEASSIST_STATIC_FIELD_PREFIXES, ""); //$NON-NLS-1$
		defaultOptionsMap.put(JavaCore.CODEASSIST_STATIC_FINAL_FIELD_PREFIXES, ""); //$NON-NLS-1$
		defaultOptionsMap.put(JavaCore.CODEASSIST_LOCAL_PREFIXES, ""); //$NON-NLS-1$
		defaultOptionsMap.put(JavaCore.CODEASSIST_ARGUMENT_PREFIXES, ""); //$NON-NLS-1$
		defaultOptionsMap.put(JavaCore.CODEASSIST_FIELD_SUFFIXES, ""); //$NON-NLS-1$
		defaultOptionsMap.put(JavaCore.CODEASSIST_STATIC_FIELD_SUFFIXES, ""); //$NON-NLS-1$
		defaultOptionsMap.put(JavaCore.CODEASSIST_STATIC_FINAL_FIELD_SUFFIXES, ""); //$NON-NLS-1$
		defaultOptionsMap.put(JavaCore.CODEASSIST_LOCAL_SUFFIXES, ""); //$NON-NLS-1$
		defaultOptionsMap.put(JavaCore.CODEASSIST_ARGUMENT_SUFFIXES, ""); //$NON-NLS-1$
		defaultOptionsMap.put(JavaCore.CODEASSIST_FORBIDDEN_REFERENCE_CHECK, JavaCore.ENABLED);




		defaultOptionsMap.put(JavaCore.CODEASSIST_IMPLICIT_QUALIFICATION, JavaCore.DISABLED);
		defaultOptionsMap.put(JavaCore.CODEASSIST_FIELD_PREFIXES, ""); //$NON-NLS-1$
		defaultOptionsMap.put(JavaCore.CODEASSIST_STATIC_FIELD_PREFIXES, ""); //$NON-NLS-1$
		defaultOptionsMap.put(JavaCore.CODEASSIST_STATIC_FINAL_FIELD_PREFIXES, ""); //$NON-NLS-1$
		defaultOptionsMap.put(JavaCore.CODEASSIST_LOCAL_PREFIXES, ""); //$NON-NLS-1$
		defaultOptionsMap.put(JavaCore.CODEASSIST_ARGUMENT_PREFIXES, ""); //$NON-NLS-1$
		defaultOptionsMap.put(JavaCore.CODEASSIST_FIELD_SUFFIXES, ""); //$NON-NLS-1$
		defaultOptionsMap.put(JavaCore.CODEASSIST_STATIC_FIELD_SUFFIXES, ""); //$NON-NLS-1$
		defaultOptionsMap.put(JavaCore.CODEASSIST_STATIC_FINAL_FIELD_SUFFIXES, ""); //$NON-NLS-1$
		defaultOptionsMap.put(JavaCore.CODEASSIST_LOCAL_SUFFIXES, ""); //$NON-NLS-1$
		defaultOptionsMap.put(JavaCore.CODEASSIST_ARGUMENT_SUFFIXES, ""); //$NON-NLS-1$
		defaultOptionsMap.put(JavaCore.CODEASSIST_FORBIDDEN_REFERENCE_CHECK, JavaCore.ENABLED);

Lines 1812-1817 Link Here

(-)model/org/eclipse/jdt/core/JavaCore.java (+26 lines)
1812	*/	1812	*/
1813	public static final String CODEASSIST_STATIC_FIELD_PREFIXES = PLUGIN_ID + ".codeComplete.staticFieldPrefixes"; //$NON-NLS-1$	1813	public static final String CODEASSIST_STATIC_FIELD_PREFIXES = PLUGIN_ID + ".codeComplete.staticFieldPrefixes"; //$NON-NLS-1$
1814	/**	1814	/**
		1815	* Code assist option ID: Define the Prefixes for Static Final Field Name.
		1816	* <p>When the prefixes is non empty, completion for static final field name will begin with
		1817	* one of the proposed prefixes.
		1818	* <dl>
		1819	* <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.codeComplete.staticFinalFieldPrefixes"</code></dd>
		1820	* <dt>Possible values:</dt><dd><code>{ "<prefix>[,<prefix>]*" }</code> where <code><prefix></code> is a String without any wild-card</dd>
		1821	* <dt>Default:</dt><dd><code>""</code></dd>
		1822	* </dl>
		1823	* @since 3.5
		1824	* @category CodeAssistOptionID
		1825	*/
		1826	public static final String CODEASSIST_STATIC_FINAL_FIELD_PREFIXES = PLUGIN_ID + ".codeComplete.staticFinalFieldPrefixes"; //$NON-NLS-1$
		1827	/**
1815	* Code assist option ID: Define the Prefixes for Local Variable Name.	1828	* Code assist option ID: Define the Prefixes for Local Variable Name.
1816	* <p>When the prefixes is non empty, completion for local variable name will begin with	1829	* <p>When the prefixes is non empty, completion for local variable name will begin with
1817	* one of the proposed prefixes.	1830	* one of the proposed prefixes.
Lines 1864-1869 Link Here
1864	*/	1877	*/
1865	public static final String CODEASSIST_STATIC_FIELD_SUFFIXES = PLUGIN_ID + ".codeComplete.staticFieldSuffixes"; //$NON-NLS-1$	1878	public static final String CODEASSIST_STATIC_FIELD_SUFFIXES = PLUGIN_ID + ".codeComplete.staticFieldSuffixes"; //$NON-NLS-1$
1866	/**	1879	/**
		1880	* Code assist option ID: Define the Suffixes for Static Final Field Name.
		1881	* <p>When the suffixes is non empty, completion for static final field name will end with
		1882	* one of the proposed suffixes.
		1883	* <dl>
		1884	* <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.codeComplete.staticFinalFieldSuffixes"</code></dd>
		1885	* <dt>Possible values:</dt><dd><code>{ "<suffix>[,<suffix>]*" }</code>< where <code><suffix></code> is a String without any wild-card</dd>
		1886	* <dt>Default:</dt><dd><code>""</code></dd>
		1887	* </dl>
		1888	* @since 3.5
		1889	* @category CodeAssistOptionID
		1890	*/
		1891	public static final String CODEASSIST_STATIC_FINAL_FIELD_SUFFIXES = PLUGIN_ID + ".codeComplete.staticFinalFieldSuffixes"; //$NON-NLS-1$
		1892	/**
1867	* Code assist option ID: Define the Suffixes for Local Variable Name.	1893	* Code assist option ID: Define the Suffixes for Local Variable Name.
1868	* <p>When the suffixes is non empty, completion for local variable name will end with	1894	* <p>When the suffixes is non empty, completion for local variable name will end with
1869	* one of the proposed suffixes.	1895	* one of the proposed suffixes.




package org.eclipse.jdt.core;

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;

 * @noinstantiate This class is not intended to be instantiated by clients.
 */
public final class NamingConventions {
	private static final char[] GETTER_BOOL_NAME = "is".toCharArray(); //$NON-NLS-1$
	private static final char[] GETTER_NAME = "get".toCharArray(); //$NON-NLS-1$
	private static final char[] SETTER_NAME = "set".toCharArray(); //$NON-NLS-1$

	static class NamingRequestor implements INamingRequestor {
		private final static int SIZE = 10;


		// for acceptNameWithoutPrefixAndSuffix
		private char[][] otherResults = new char[SIZE][];
		private int otherResultsCount = 0;
		public void acceptNameWithoutPrefixAndSuffix(char[] name, int reusedCharacters) {
			int length = this.otherResults.length;
			if(length == this.otherResultsCount) {
				System.arraycopy(
					this.otherResults,
					0,
					this.otherResults = new char[length * 2][],
					0,
					length);
			}
			this.otherResults[this.otherResultsCount++] = name;
		}

		public void acceptNameWithPrefix(char[] name, boolean isFirstPrefix, int reusedCharacters) {
			if(isFirstPrefix) {
				int length = this.firstPrefixResults.length;
				if(length == this.firstPrefixResultsCount) {
					System.arraycopy(
						this.firstPrefixResults,
						0,
						this.firstPrefixResults = new char[length * 2][],
						0,
						length);
				}
				this.firstPrefixResults[this.firstPrefixResultsCount++] = name;
			} else{
				int length = this.prefixResults.length;
				if(length == this.prefixResultsCount) {
					System.arraycopy(
						this.prefixResults,
						0,
						this.prefixResults = new char[length * 2][],
						0,
						length);
				}
				this.prefixResults[this.prefixResultsCount++] = name;
			}
		}

		public void acceptNameWithPrefixAndSuffix(char[] name, boolean isFirstPrefix, boolean isFirstSuffix, int reusedCharacters) {
			if(isFirstPrefix && isFirstSuffix) {
				int length = this.firstPrefixAndFirstSuffixResults.length;

			}
		}

		public void acceptNameWithPrefix(char[] name, boolean isFirstPrefix, int reusedCharacters) {
			if(isFirstPrefix) {
				int length = this.firstPrefixResults.length;
				if(length == this.firstPrefixResultsCount) {
					System.arraycopy(
						this.firstPrefixResults,
						0,
						this.firstPrefixResults = new char[length * 2][],
						0,
						length);
				}
				this.firstPrefixResults[this.firstPrefixResultsCount++] = name;
			} else{
				int length = this.prefixResults.length;
				if(length == this.prefixResultsCount) {
					System.arraycopy(
						this.prefixResults,
						0,
						this.prefixResults = new char[length * 2][],
						0,
						length);
				}
				this.prefixResults[this.prefixResultsCount++] = name;
			}
		}

		public void acceptNameWithSuffix(char[] name, boolean isFirstSuffix, int reusedCharacters) {
			if(isFirstSuffix) {
				int length = this.firstSuffixResults.length;

				this.suffixResults[this.suffixResultsCount++] = name;
			}
		}

		public void acceptNameWithoutPrefixAndSuffix(char[] name, int reusedCharacters) {
			int length = this.otherResults.length;
			if(length == this.otherResultsCount) {
				System.arraycopy(
					this.otherResults,
					0,
					this.otherResults = new char[length * 2][],
					0,
					length);
			}
			this.otherResults[this.otherResultsCount++] = name;
		}
		public char[][] getResults(){
			int count =
				this.firstPrefixAndFirstSuffixResultsCount

			return results;
		}
	}
	private static final char[] GETTER_BOOL_NAME = "is".toCharArray(); //$NON-NLS-1$
	private static final char[] GETTER_NAME = "get".toCharArray(); //$NON-NLS-1$

	private static final char[] SETTER_NAME = "set".toCharArray(); //$NON-NLS-1$

	private NamingConventions() {
		// Not instantiable
	}

	/**
	 * Variable kind which represents a static field.
	 * 
	 * @since 3.5
	 */
	public static final int VK_STATIC_FIELD = InternalNamingConventions.VK_STATIC_FIELD;
	/**
	 * Variable kind which represents an instance field.
	 * 
	 * @since 3.5
	 */
	public static final int VK_INSTANCE_FIELD = InternalNamingConventions.VK_INSTANCE_FIELD;
	/**
	 * Variable kind which represents a constant field (static final).
	 * 
	 * @since 3.5
	 */
	public static final int VK_CONSTANT_FIELD = InternalNamingConventions.VK_CONSTANT_FIELD;
	/**
	 * Variable kind which represents an argument.
	 * 
	 * @since 3.5
	 */
	public static final int VK_PARAMETER = InternalNamingConventions.VK_PARAMETER;
	/**
	 * Variable kind which represents a local variable.
	 * 
	 * @since 3.5
	 */
	public static final int VK_LOCAL = InternalNamingConventions.VK_LOCAL;
	
	/**
	 * The base name associated to this base name kind is a simple name.
	 * When this base name is used the whole name is considered.
	 * 
	 * @see #suggestVariableNames(int, int, String, IJavaProject, int, String[], boolean)
	 * 
	 * @since 3.5
	 */
	public static final int BK_NAME = InternalNamingConventions.BK_SIMPLE_NAME;
	
	/**
	 * The base name associated to this base name kind is a simple type name.
	 * When this base name is used to all the words of the name are considered.
	 * 
	 * @see #suggestVariableNames(int, int, String, IJavaProject, int, String[], boolean)
	 * 
	 * @since 3.5
	 */
	public static final int BK_TYPE_NAME = InternalNamingConventions.BK_SIMPLE_TYPE_NAME;

	private static String[] convertCharsToString(char[][] c) {
		int length = c == null ? 0 : c.length;
		String[] s = new String[length];
		for (int i = 0; i < length; i++) {
			s[i] = String.valueOf(c[i]);
		}
		return s;
	}
	private static char[][] convertStringToChars(String[] s) {
		int length = s == null ? 0 : s.length;
		char[][] c = new char[length][];
		for (int i = 0; i < length; i++) {
			if(s[i] == null) {
				c[i] = CharOperation.NO_CHAR;
			} else {
				c[i] = s[i].toCharArray();
			}
		}
		return c;
		withoutSuffixName[0] = ScannerHelper.toLowerCase(withoutSuffixName[0]);
		return withoutSuffixName;
	}

	/**

	 * @return char[] the name without prefix and suffix.
	 * @see JavaCore#setOptions(java.util.Hashtable)
	 * @see JavaCore#getDefaultOptions()
	 * 
	 * @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);
	}

	/**

	 * @return char[] the name without prefix and suffix.
	 * @see JavaCore#setOptions(java.util.Hashtable)
	 * @see JavaCore#getDefaultOptions()
	 * 
	 * @deprecated Use {@link #getBaseName(int, String, IJavaProject)} instead with {@link #VK_PARAMETER} as variable kind.
	 */
	public static String removePrefixAndSuffixForArgumentName(IJavaProject javaProject, String argumentName) {
		return String.valueOf(removePrefixAndSuffixForArgumentName(javaProject, argumentName.toCharArray()));
	}

	/**
	 * Remove prefix and suffix from a field name.
	 * <p>

	 * @see Flags
	 * @see JavaCore#setOptions(java.util.Hashtable)
	 * @see JavaCore#getDefaultOptions()
	 * 
	 * @deprecated Use {@link #getBaseName(int, String, IJavaProject)} instead
	 * with {@link #VK_INSTANCE_FIELD} or {@link #VK_STATIC_FIELD} as variable kind.
	 */
	public static char[] removePrefixAndSuffixForFieldName(IJavaProject javaProject, char[] fieldName, int modifiers) {
		boolean isStatic = Flags.isStatic(modifiers);
		return InternalNamingConventions.removeVariablePrefixAndSuffix(isStatic ? VK_STATIC_FIELD : VK_INSTANCE_FIELD, javaProject, fieldName);
		return	removePrefixAndSuffix(
			fieldName,
			isStatic ? assistOptions.staticFieldPrefixes : assistOptions.fieldPrefixes,
			isStatic ? assistOptions.staticFieldSuffixes : assistOptions.fieldSuffixes);
	}

	/**

	 * @see Flags
	 * @see JavaCore#setOptions(java.util.Hashtable)
	 * @see JavaCore#getDefaultOptions()
	 * 
	 * @deprecated Use {@link #getBaseName(int, String, IJavaProject)} instead
	 * with {@link #VK_INSTANCE_FIELD} or {@link #VK_STATIC_FIELD} as variable kind.
	 */
	public static String removePrefixAndSuffixForFieldName(IJavaProject javaProject, String fieldName, int modifiers) {
		return String.valueOf(removePrefixAndSuffixForFieldName(javaProject, fieldName.toCharArray(), modifiers));
	}

	/**
	 * Remove prefix and suffix from a local variable name.
	 * <p>

	 * @return char[] the name without prefix and suffix.
	 * @see JavaCore#setOptions(java.util.Hashtable)
	 * @see JavaCore#getDefaultOptions()
	 * 
	 * @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);
	}

	/**

	 * @return char[] the name without prefix and suffix.
	 * @see JavaCore#setOptions(java.util.Hashtable)
	 * @see JavaCore#getDefaultOptions()
	 * 
	 * @deprecated Use {@link #getBaseName(int, String, IJavaProject)} instead with {@link #VK_LOCAL} as variable kind.
	 */
	public static String removePrefixAndSuffixForLocalVariableName(IJavaProject javaProject, String localName) {
		return String.valueOf(removePrefixAndSuffixForLocalVariableName(javaProject, localName.toCharArray()));
	}
	
	/**
	 * Returns a base name which could be used to generate this variable with {@link #suggestVariableNames(int, int, String, IJavaProject, int, String[], boolean)}.
	 * <p>
	 * e.g.<br>
	 * If the variable is a {@link #VK_LOCAL} and the variable name is <code>variableName</code> then the base name will be <code>VariableName</code>.<br>
	 * If the variable is a {@link #VK_CONSTANT_FIELD} and the variable name is <code>VARIABLE_NAME</code> then the base name will be <code>VariableName</code>.<br>
	 * </p>
	 * 
	 * @param variableKind specifies what type the variable is: {@link #VK_LOCAL}, {@link #VK_PARAMETER}, {@link #VK_STATIC_FIELD},
	 * {@link #VK_INSTANCE_FIELD} or {@link #VK_CONSTANT_FIELD}.
	 * @param variableName a variable name
	 * @param javaProject project which contains the variable or <code>null</code> to take into account only workspace settings.
	 * 
	 * @see #suggestVariableNames(int, int, String, IJavaProject, int, String[], boolean)
	 * @since 3.5
	 */
	public static String getBaseName(
			int variableKind,
			String variableName,
			IJavaProject javaProject) {
		return String.valueOf(InternalNamingConventions.getBaseName(variableKind, javaProject, variableName.toCharArray()));
	}

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

	/**
	 * Suggest names for an argument. The name is computed from argument's type

	 * @return char[][] an array of names.
	 * @see JavaCore#setOptions(java.util.Hashtable)
	 * @see JavaCore#getDefaultOptions()
	 * 
	 * @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) {
		NamingRequestor requestor = new NamingRequestor();
		InternalNamingConventions.suggestVariableNames(
				VK_PARAMETER,
				BK_TYPE_NAME,
				qualifiedTypeName,
				javaProject,
				dim,
				null,
				excludedNames,
				true,
				requestor);

		return requestor.getResults();
	}

	 * @return char[][] an array of names.
	 * @see JavaCore#setOptions(java.util.Hashtable)
	 * @see JavaCore#getDefaultOptions()
	 * 
	 * @deprecated Use {@link #suggestVariableNames(int, int, String, IJavaProject, int, String[], boolean)} instead with {@link #VK_PARAMETER} as variable kind.
	 */
	public static String[] suggestArgumentNames(IJavaProject javaProject, String packageName, String qualifiedTypeName, int dim, String[] excludedNames) {
		return convertCharsToString(

				dim,
				convertStringToChars(excludedNames)));
	}

	/**
	 * Suggest names for a field. The name is computed from field's type
	 * and possible prefixes or suffixes are added.

	 * @see Flags
	 * @see JavaCore#setOptions(java.util.Hashtable)
	 * @see JavaCore#getDefaultOptions()
	 * 
	 * @deprecated Use {@link #suggestVariableNames(int, int, String, IJavaProject, int, String[], boolean)} instead 
	 * 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) {
		NamingRequestor requestor = new NamingRequestor();
		InternalNamingConventions.suggestVariableNames(
				Flags.isStatic(modifiers) ? VK_STATIC_FIELD : VK_INSTANCE_FIELD,
				BK_TYPE_NAME,
				qualifiedTypeName,
				javaProject,
				dim,
				null,
				excludedNames,
				true,
				requestor);

		return requestor.getResults();
	}

	 * @see Flags
	 * @see JavaCore#setOptions(java.util.Hashtable)
	 * @see JavaCore#getDefaultOptions()
	 * 
	 * @deprecated Use {@link #suggestVariableNames(int, int, String, IJavaProject, int, String[], boolean)} instead 
	 * with {@link #VK_INSTANCE_FIELD} or  {@link #VK_STATIC_FIELD} as variable kind.
	 */
	public static String[] suggestFieldNames(IJavaProject javaProject, String packageName, String qualifiedTypeName, int dim, int modifiers, String[] excludedNames) {
		return convertCharsToString(

				modifiers,
				convertStringToChars(excludedNames)));
	}
	
	/**
	 * Suggest names for a local variable. The name is computed from variable's type
	 * and possible prefixes or suffixes are added.
	 * <p>
	 * If the type of the local variable is <code>TypeName</code>, the prefix for local variable is <code>pre</code>
	 * and the suffix for local variable is <code>suf</code> then the proposed names are <code>preTypeNamesuf</code>
	 * and <code>preNamesuf</code>. If there is no prefix or suffix the proposals are <code>typeName</code>
	 * and <code>name</code>.
	 * </p>
	 * <p>
	 * This method is affected by the following JavaCore options :  {@link JavaCore#CODEASSIST_LOCAL_PREFIXES} and
	 *  {@link JavaCore#CODEASSIST_LOCAL_SUFFIXES}.
	 * </p>
	 * <p>
	 * For a complete description of these configurable options, see <code>getDefaultOptions</code>.
	 * For programmaticaly change these options, see <code>JavaCore#setOptions()</code>.
	 * </p>
	 *
	 * @param javaProject project which contains the variable.
	 * @param packageName package of the variable's type.
	 * @param qualifiedTypeName variable's type.
	 * @param dim variable's dimension (0 if the variable is not an array).
	 * @param excludedNames a list of names which cannot be suggested (already used names).
	 *         Can be <code>null</code> if there is no excluded names.
	 * @return char[][] an array of names.
	 * @see JavaCore#setOptions(java.util.Hashtable)
	 * @see JavaCore#getDefaultOptions()
	 */
	public static char[][] suggestLocalVariableNames(IJavaProject javaProject, char[] packageName, char[] qualifiedTypeName, int dim, char[][] excludedNames) {
		NamingRequestor requestor = new NamingRequestor();
		InternalNamingConventions.suggestLocalVariableNames(
			javaProject,
			packageName,
			qualifiedTypeName,
			dim,
			null,
			excludedNames,
			requestor);

		return requestor.getResults();
	}

	/**
	 * Suggest names for a local variable. The name is computed from variable's type
	 * and possible prefixes or suffixes are added.
	 * <p>
	 * If the type of the local variable is <code>TypeName</code>, the prefix for local variable is <code>pre</code>
	 * and the suffix for local variable is <code>suf</code> then the proposed names are <code>preTypeNamesuf</code>
	 * and <code>preNamesuf</code>. If there is no prefix or suffix the proposals are <code>typeName</code>
	 * and <code>name</code>.
	 * </p>
	 * <p>
	 * This method is affected by the following JavaCore options :  {@link JavaCore#CODEASSIST_LOCAL_PREFIXES} and
	 *  {@link JavaCore#CODEASSIST_LOCAL_SUFFIXES}.
	 * </p>
	 * <p>
	 * For a complete description of these configurable options, see <code>getDefaultOptions</code>.
	 * For programmaticaly change these options, see <code>JavaCore#setOptions()</code>.
	 * </p>
	 *
	 * @param javaProject project which contains the variable.
	 * @param packageName package of the variable's type.
	 * @param qualifiedTypeName variable's type.
	 * @param dim variable's dimension (0 if the variable is not an array).
	 * @param excludedNames a list of names which cannot be suggested (already used names).
	 *         Can be <code>null</code> if there is no excluded names.
	 * @return char[][] an array of names.
	 * @see JavaCore#setOptions(java.util.Hashtable)
	 * @see JavaCore#getDefaultOptions()
	 */
	public static String[] suggestLocalVariableNames(IJavaProject javaProject, String packageName, String qualifiedTypeName, int dim, String[] excludedNames) {
		return convertCharsToString(
			suggestLocalVariableNames(
				javaProject,
				packageName.toCharArray(),
				qualifiedTypeName.toCharArray(),
				dim,
				convertStringToChars(excludedNames)));
	}

	/**
	 * Suggest name for a getter method. The name is computed from field's name
	 * and possible prefixes or suffixes are removed.

			);
		}
	}

	/**
	 * Suggest name for a getter method. The name is computed from field's name
	 * and possible prefixes or suffixes are removed.

				isBoolean,
				convertStringToChars(excludedNames)));
	}
	/**
	 * Suggest names for a local variable. The name is computed from variable's type
	 * and possible prefixes or suffixes are added.
	 * <p>
	 * If the type of the local variable is <code>TypeName</code>, the prefix for local variable is <code>pre</code>
	 * and the suffix for local variable is <code>suf</code> then the proposed names are <code>preTypeNamesuf</code>
	 * and <code>preNamesuf</code>. If there is no prefix or suffix the proposals are <code>typeName</code>
	 * and <code>name</code>.
	 * </p>
	 * <p>
	 * This method is affected by the following JavaCore options :  {@link JavaCore#CODEASSIST_LOCAL_PREFIXES} and
	 *  {@link JavaCore#CODEASSIST_LOCAL_SUFFIXES}.
	 * </p>
	 * <p>
	 * For a complete description of these configurable options, see <code>getDefaultOptions</code>.
	 * For programmaticaly change these options, see <code>JavaCore#setOptions()</code>.
	 * </p>
	 *
	 * @param javaProject project which contains the variable.
	 * @param packageName package of the variable's type.
	 * @param qualifiedTypeName variable's type.
	 * @param dim variable's dimension (0 if the variable is not an array).
	 * @param excludedNames a list of names which cannot be suggested (already used names).
	 *         Can be <code>null</code> if there is no excluded names.
	 * @return char[][] an array of names.
	 * @see JavaCore#setOptions(java.util.Hashtable)
	 * @see JavaCore#getDefaultOptions()
	 * 
	 * @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) {
		NamingRequestor requestor = new NamingRequestor();
		InternalNamingConventions.suggestVariableNames(
				VK_LOCAL,
				BK_TYPE_NAME,
				qualifiedTypeName,
				javaProject,
				dim,
				null,
				excludedNames,
				true,
				requestor);

		return requestor.getResults();
	}
	/**
	 * Suggest names for a local variable. The name is computed from variable's type
	 * and possible prefixes or suffixes are added.
	 * <p>
	 * If the type of the local variable is <code>TypeName</code>, the prefix for local variable is <code>pre</code>
	 * and the suffix for local variable is <code>suf</code> then the proposed names are <code>preTypeNamesuf</code>
	 * and <code>preNamesuf</code>. If there is no prefix or suffix the proposals are <code>typeName</code>
	 * and <code>name</code>.
	 * </p>
	 * <p>
	 * This method is affected by the following JavaCore options :  {@link JavaCore#CODEASSIST_LOCAL_PREFIXES} and
	 *  {@link JavaCore#CODEASSIST_LOCAL_SUFFIXES}.
	 * </p>
	 * <p>
	 * For a complete description of these configurable options, see <code>getDefaultOptions</code>.
	 * For programmaticaly change these options, see <code>JavaCore#setOptions()</code>.
	 * </p>
	 *
	 * @param javaProject project which contains the variable.
	 * @param packageName package of the variable's type.
	 * @param qualifiedTypeName variable's type.
	 * @param dim variable's dimension (0 if the variable is not an array).
	 * @param excludedNames a list of names which cannot be suggested (already used names).
	 *         Can be <code>null</code> if there is no excluded names.
	 * @return char[][] an array of names.
	 * @see JavaCore#setOptions(java.util.Hashtable)
	 * @see JavaCore#getDefaultOptions()
	 * 
	 * @deprecated Use {@link #suggestVariableNames(int, int, String, IJavaProject, int, String[], boolean)} instead with {@link #VK_LOCAL} as variable kind.
	 */
	public static String[] suggestLocalVariableNames(IJavaProject javaProject, String packageName, String qualifiedTypeName, int dim, String[] excludedNames) {
		return convertCharsToString(
			suggestLocalVariableNames(
				javaProject,
				packageName.toCharArray(),
				qualifiedTypeName.toCharArray(),
				dim,
				convertStringToChars(excludedNames)));
	}
	private static char[] suggestNewName(char[] name, char[][] excludedNames){
		if(excludedNames == null) {
			return name;
		}

		char[] newName = name;
		int count = 2;
		int i = 0;
		while (i < excludedNames.length) {
			if(CharOperation.equals(newName, excludedNames[i], false)) {
				newName = CharOperation.concat(name, String.valueOf(count++).toCharArray());
				i = 0;
			} else {
				i++;
			}
		}
		return newName;
	}
	
	/**
	 * Suggest name for a setter method. The name is computed from field's name
	 * and possible prefixes or suffixes are removed.

			);
		}
	}

	/**
	 * Suggest name for a setter method. The name is computed from field's name
	 * and possible prefixes or suffixes are removed.

				isBoolean,
				convertStringToChars(excludedNames)));
	}
	
	/**
	 * Suggests names for a variable. The name is computed from a base name and possible prefixes or suffixes are added.
	 *
	 * <p>
	 * The base name is used to compute the variable name.
	 * Some different kinds of base name are possible and each kind is associated to a different heuristic to compute variable names.<br>
	 * The heuristic depends also of the kind of the variable. Each kind of variable is identified by a constant starting with <code>VK_</code>.<br>
	 * When a prefix and a suffix can be added then all combinations of prefix and suffix are suggested.
	 * If the name is <code>name</code>, the prefix is <code>pre</code> and the suffix is <code>suf</code> then the suggested names will be
	 * <code>prenamesuf</code>, <code>prename</code>, <code>namesuf</code> and <code>name</code>.<br>
	 * <br>
	 * The different kinds of base name are:
	 * <ul>
	 * <li>{@link #BK_NAME}: the whole base name is considered to compute the variable names. A prefix and a suffix can be added.<br>
	 * There is an heuristic by variable kind.
	 * <ul>
	 * <li>{@link #VK_PARAMETER}, {@link #VK_LOCAL}, {@link #VK_INSTANCE_FIELD} and {@link #VK_STATIC_FIELD}:<br>
	 * In this case the first character will be converted to lower case and the other characters won't be changed.<br>
	 * If the base name is <code>SimpleName</code> then the suggested name will be <code>simpleName</code>.<br></li>
	 * <li>{@link #VK_CONSTANT_FIELD} :<br>
	 * In this case all letters of the name will be converted to upper case and words will be separated by an underscore (<code>"_"</code>).<br>
	 * If the base name is <code>SimpleName</code> then the suggested name will be <code>SIMPLE_NAME</code>.</li>
	 * </ul></li>
	 * <li>{@link #BK_TYPE_NAME}: all the words of the base name are considered to compute the variable names. A prefix and a suffix can be added to these names.<br>
	 * There is an heuristic by variable kind.
	 * <ul>
	 * <li>{@link #VK_PARAMETER}, {@link #VK_LOCAL}, {@link #VK_INSTANCE_FIELD} and {@link #VK_STATIC_FIELD}:<br>
	 * In this case a variable name will contain some words of the base name and the first character will be converted to lower case.<br>
	 * If the type is <code>TypeName</code> then the suggested names will be <code>typeName</code> and <code>name</code>.</li>
	 * <li>{@link #VK_CONSTANT_FIELD} :<br>
	 * In this case a variable name will contain some words of the base name, all letters of the name will be converted to upper case and segments will be separated by a underscore (<code>"_"</code>).<br>
	 * If the base name is <code>TypeName</code> then the suggested name will be <code>TYPE_NAME</code> and <code>NAME</code>.</li>
	 * </ul></li>
	 * </ul>
	 * Some other kinds could be added in the future.
	 * </p>
	 * <p>
	 * Each variable kind is affected by the following JavaCore options:
	 * <ul>
	 * <li>{@link #VK_PARAMETER}: {@link JavaCore#CODEASSIST_ARGUMENT_PREFIXES} and {@link JavaCore#CODEASSIST_ARGUMENT_SUFFIXES}</li>
	 * <li>{@link #VK_LOCAL}: {@link JavaCore#CODEASSIST_LOCAL_PREFIXES} and {@link JavaCore#CODEASSIST_LOCAL_SUFFIXES}</li>
	 * <li>{@link #VK_INSTANCE_FIELD}: {@link JavaCore#CODEASSIST_FIELD_PREFIXES} and {@link JavaCore#CODEASSIST_FIELD_SUFFIXES}</li>
	 * <li>{@link #VK_STATIC_FIELD}: {@link JavaCore#CODEASSIST_STATIC_FIELD_PREFIXES} and {@link JavaCore#CODEASSIST_STATIC_FIELD_SUFFIXES}</li>
	 * <li>{@link #VK_CONSTANT_FIELD}: {@link JavaCore#CODEASSIST_STATIC_FINAL_FIELD_PREFIXES} and {@link JavaCore#CODEASSIST_STATIC_FINAL_FIELD_SUFFIXES}</li>
	 * </ul>
	 * </p>
	 * <p>
	 * For a complete description of these configurable options, see <code>getDefaultOptions</code>.
	 * For programmaticaly change these options, see <code>JavaCore#setOptions()</code>.
	 * </p>
	 * <p>
	 * Proposed names are sorted by relevance (best proposal first).<br>
	 * The names are proposed in the following order:
	 * <ol>
	 * <li>Names with prefix and suffix. Longest name are proposed first</li>
	 * <li>Names with prefix. Longest name are proposed first</li>
	 * <li>Names with suffix. Longest name are proposed first</li>
	 * <li>Names without prefix and suffix. Longest name are proposed first</li>
	 * </ol>
	 * </p>
	 *
	 * @param variableKind specifies what type the variable is: {@link #VK_LOCAL}, {@link #VK_PARAMETER}, {@link #VK_STATIC_FIELD},
	 * {@link #VK_INSTANCE_FIELD} or {@link #VK_CONSTANT_FIELD}.
	 * @param baseNameKind specifies what type the base name is: {@link #BK_NAME} or {@link #BK_TYPE_NAME}
	 * @param baseName name used to compute the suggested names.
	 * @param javaProject project which contains the variable or <code>null</code> to take into account only workspace settings.
	 * @param dim variable dimension (0 if the field is not an array).
	 * @param excluded a list of names which cannot be suggested (already used names).
	 *         Can be <code>null</code> if there is no excluded names.
	 * @param evaluateDefault if set, the result is guaranteed to contain at least one result. If not, the result can be an empty array. 
	 * @return String[] an array of names.
	 * @see JavaCore#setOptions(java.util.Hashtable)
	 * @see JavaCore#getDefaultOptions()
	 * 
	 * @since 3.5
	 */
	public static String[] suggestVariableNames(
			int variableKind,
			int baseNameKind,
			String baseName,
			IJavaProject javaProject,
			int dim,
			String[] excluded,
			boolean evaluateDefault) {
		
		NamingRequestor requestor = new NamingRequestor();
		InternalNamingConventions.suggestVariableNames(
			variableKind,
			baseNameKind,
			baseName.toCharArray(),
			javaProject,
			dim,
			null,
			convertStringToChars(excluded),
			evaluateDefault,
			requestor);

		return convertCharsToString(requestor.getResults());
		char[] name = removePrefixAndSuffixForFieldName(project, fieldName, modifiers);
		if (name.length > 0 && ScannerHelper.isLowerCase(name[0])) {
			name[0] = ScannerHelper.toUpperCase(name[0]);
		}
		return name;
	}

	private static char[] suggestNewName(char[] name, char[][] excludedNames){
		if(excludedNames == null) {
			return name;
		}

		char[] newName = name;
		int count = 2;
		int i = 0;
		while (i < excludedNames.length) {
			if(CharOperation.equals(newName, excludedNames[i], false)) {
				newName = CharOperation.concat(name, String.valueOf(count++).toCharArray());
				i = 0;
			} else {
				i++;
			}
		}
		return newName;
	}

	private static String[] convertCharsToString(char[][] c) {
		int length = c == null ? 0 : c.length;
		String[] s = new String[length];
		for (int i = 0; i < length; i++) {
			s[i] = String.valueOf(c[i]);
		}
		return s;
	}
	
	private NamingConventions() {
		// Not instantiable
		char[][] c = new char[length][];
		for (int i = 0; i < length; i++) {
			if(s[i] == null) {
				c[i] = CharOperation.NO_CHAR;
			} else {
				c[i] = s[i].toCharArray();
			}
		}
		return c;
	}
}




}

/**
 * Answers the result of a char[] conversion to uppercase. Answers null if the given chars array is null.
 * <br>
 * NOTE: If no conversion was necessary, then answers back the argument one.
 * <br>
 * <br>
 * For example:
 * <ol>
 * <li><pre>
 *    chars = { 'A' , 'B' }
 *    result => { 'A' , 'B' }
 * </pre>
 * </li>
 * <li><pre>
 *    array = { 'a', 'B' }
 *    result => { 'A' , 'B' }
 * </pre>
 * </li>
 * </ol>
 *
 * @param chars the chars to convert
 * @return the result of a char[] conversion to uppercase
 * 
 * @since 3.5
 */
final static public char[] toUpperCase(char[] chars) {
	if (chars == null)
		return null;
	int length = chars.length;
	char[] upperChars = null;
	for (int i = 0; i < length; i++) {
		char c = chars[i];
		char lc = ScannerHelper.toUpperCase(c);
		if ((c != lc) || (upperChars != null)) {
			if (upperChars == null) {
				System.arraycopy(
					chars,
					0,
					upperChars = new char[length],
					0,
					i);
			}
			upperChars[i] = lc;
		}
	}
	return upperChars == null ? chars : upperChars;
}

/**
 * Answers a new array removing leading and trailing spaces (' '). Answers the given array if there is no
 * space characters to remove.
 * <br>

Lines 28-33 Link Here

(-)codeassist/org/eclipse/jdt/internal/codeassist/impl/AssistOptions.java (+26 lines)
28	"org.eclipse.jdt.core.codeComplete.fieldPrefixes"; //$NON-NLS-1$	28	"org.eclipse.jdt.core.codeComplete.fieldPrefixes"; //$NON-NLS-1$
29	public static final String OPTION_StaticFieldPrefixes =	29	public static final String OPTION_StaticFieldPrefixes =
30	"org.eclipse.jdt.core.codeComplete.staticFieldPrefixes"; //$NON-NLS-1$	30	"org.eclipse.jdt.core.codeComplete.staticFieldPrefixes"; //$NON-NLS-1$
		31	public static final String OPTION_StaticFinalFieldPrefixes =
		32	"org.eclipse.jdt.core.codeComplete.staticFinalFieldPrefixes"; //$NON-NLS-1$
31	public static final String OPTION_LocalPrefixes =	33	public static final String OPTION_LocalPrefixes =
32	"org.eclipse.jdt.core.codeComplete.localPrefixes"; //$NON-NLS-1$	34	"org.eclipse.jdt.core.codeComplete.localPrefixes"; //$NON-NLS-1$
33	public static final String OPTION_ArgumentPrefixes =	35	public static final String OPTION_ArgumentPrefixes =
Lines 36-41 Link Here
36	"org.eclipse.jdt.core.codeComplete.fieldSuffixes"; //$NON-NLS-1$	38	"org.eclipse.jdt.core.codeComplete.fieldSuffixes"; //$NON-NLS-1$
37	public static final String OPTION_StaticFieldSuffixes =	39	public static final String OPTION_StaticFieldSuffixes =
38	"org.eclipse.jdt.core.codeComplete.staticFieldSuffixes"; //$NON-NLS-1$	40	"org.eclipse.jdt.core.codeComplete.staticFieldSuffixes"; //$NON-NLS-1$
		41	public static final String OPTION_StaticFinalFieldSuffixes =
		42	"org.eclipse.jdt.core.codeComplete.staticFinalFieldSuffixes"; //$NON-NLS-1$
39	public static final String OPTION_LocalSuffixes =	43	public static final String OPTION_LocalSuffixes =
40	"org.eclipse.jdt.core.codeComplete.localSuffixes"; //$NON-NLS-1$	44	"org.eclipse.jdt.core.codeComplete.localSuffixes"; //$NON-NLS-1$
41	public static final String OPTION_ArgumentSuffixes =	45	public static final String OPTION_ArgumentSuffixes =
Lines 61-70 Link Here
61	public boolean suggestStaticImport = true;	65	public boolean suggestStaticImport = true;
62	public char[][] fieldPrefixes = null;	66	public char[][] fieldPrefixes = null;
63	public char[][] staticFieldPrefixes = null;	67	public char[][] staticFieldPrefixes = null;
		68	public char[][] staticFinalFieldPrefixes = null;
64	public char[][] localPrefixes = null;	69	public char[][] localPrefixes = null;
65	public char[][] argumentPrefixes = null;	70	public char[][] argumentPrefixes = null;
66	public char[][] fieldSuffixes = null;	71	public char[][] fieldSuffixes = null;
67	public char[][] staticFieldSuffixes = null;	72	public char[][] staticFieldSuffixes = null;
		73	public char[][] staticFinalFieldSuffixes = null;
68	public char[][] localSuffixes = null;	74	public char[][] localSuffixes = null;
69	public char[][] argumentSuffixes = null;	75	public char[][] argumentSuffixes = null;
70		76
Lines 121-126 Link Here
121	}	127	}
122	}	128	}
123	}	129	}
		130	if ((optionValue = optionsMap.get(OPTION_StaticFinalFieldPrefixes)) != null) {
		131	if (optionValue instanceof String) {
		132	String stringValue = (String) optionValue;
		133	if (stringValue.length() > 0){
		134	this.staticFinalFieldPrefixes = splitAndTrimOn(',', stringValue.toCharArray());
		135	} else {
		136	this.staticFinalFieldPrefixes = null;
		137	}
		138	}
		139	}
124	if ((optionValue = optionsMap.get(OPTION_LocalPrefixes)) != null) {	140	if ((optionValue = optionsMap.get(OPTION_LocalPrefixes)) != null) {
125	if (optionValue instanceof String) {	141	if (optionValue instanceof String) {
126	String stringValue = (String) optionValue;	142	String stringValue = (String) optionValue;
Lines 161-166 Link Here
161	}	177	}
162	}	178	}
163	}	179	}
		180	if ((optionValue = optionsMap.get(OPTION_StaticFinalFieldSuffixes)) != null) {
		181	if (optionValue instanceof String) {
		182	String stringValue = (String) optionValue;
		183	if (stringValue.length() > 0){
		184	this.staticFinalFieldSuffixes = splitAndTrimOn(',', stringValue.toCharArray());
		185	} else {
		186	this.staticFinalFieldSuffixes = null;
		187	}
		188	}
		189	}
164	if ((optionValue = optionsMap.get(OPTION_LocalSuffixes)) != null) {	190	if ((optionValue = optionsMap.get(OPTION_LocalSuffixes)) != null) {
165	if (optionValue instanceof String) {	191	if (optionValue instanceof String) {
166	String stringValue = (String) optionValue;	192	String stringValue = (String) optionValue;




	private final static int SUPERTYPE = 1;
	private final static int SUBTYPE = 2;
	
	private final static int FIELD = 0;
	private final static int LOCAL = 1;
	private final static int ARGUMENT = 2;
	
	int expectedTypesPtr = -1;
	TypeBinding[] expectedTypes = new TypeBinding[1];
	int expectedTypesFilter;


			this.completionToken = field.realName;

			
			int kind =
				 (field.modifiers & ClassFileConstants.AccStatic) == 0 ? 
						InternalNamingConventions.VK_INSTANCE_FIELD :
							(field.modifiers & ClassFileConstants.AccFinal) == 0 ? 
									InternalNamingConventions.VK_STATIC_FIELD :
										InternalNamingConventions.VK_CONSTANT_FIELD;
			
			findVariableNames(field.realName, field.type, excludeNames, null, kind);
		}
	}
	

			int kind;
			if (variable instanceof CompletionOnLocalName){
				this.completionToken = ((CompletionOnLocalName) variable).realName;
				kind = InternalNamingConventions.VK_LOCAL;
			} else {
				CompletionOnArgumentName arg = (CompletionOnArgumentName) variable;
				this.completionToken = arg.realName;
				kind = arg.isCatchArgument ? InternalNamingConventions.VK_LOCAL : InternalNamingConventions.VK_PARAMETER;
			}

			char[][] alreadyDefinedName = computeAlreadyDefinedName((BlockScope)scope, variable);


			System.arraycopy(discouragedNames, 0, discouragedNames = new char[localCount][], 0, localCount);

			findVariableNames(this.completionToken, variable.type, discouragedNames, forbiddenNames, kind);
		}
	}
	


			this.completionToken = method.selector;

			
			int kind =
				 (method.modifiers & ClassFileConstants.AccStatic) == 0 ? 
						InternalNamingConventions.VK_INSTANCE_FIELD :
							(method.modifiers & ClassFileConstants.AccFinal) == 0 ? 
									InternalNamingConventions.VK_STATIC_FIELD :
										InternalNamingConventions.VK_CONSTANT_FIELD;
						
			findVariableNames(this.completionToken, method.returnType, excludeNames, null, kind);
		}
	}
	

			final char[][] forbiddenNames,
			boolean forCollection,
			int dim,
			int kind){
			int modifiers){

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

			}
		};

		InternalNamingConventions.suggestVariableNames(
				kind,
				InternalNamingConventions.BK_SIMPLE_TYPE_NAME,
				qualifiedSourceName,
				this.javaProject,
				dim,
				token,
				discouragedNames,
				true,
				namingRequestor);
					namingRequestor);
				break;
			case LOCAL :
				InternalNamingConventions.suggestLocalVariableNames(
					this.javaProject,
					qualifiedPackageName,
					qualifiedSourceName,
					dim,
					token,
					discouragedNames,
					namingRequestor);
				break;
			case ARGUMENT :
				InternalNamingConventions.suggestArgumentNames(
					this.javaProject,
					qualifiedPackageName,
					qualifiedSourceName,
					dim,
					token,
					discouragedNames,
					namingRequestor);
				break;
		}
	}

	// Helper method for private void findVariableNames(char[] name, TypeReference type )

			char[][] discouragedNames,
			final char[][] forbiddenNames,
			int dim,
			int kind){
			int modifiers){
		findVariableName(
				token,
				qualifiedPackageName,

				forbiddenNames,
				false,
				dim,
				kind);
				modifiers);
	}
	private void findVariableNameForCollection(
			char[] token,

			final TypeBinding typeBinding,
			char[][] discouragedNames,
			final char[][] forbiddenNames,
			int kind){
			int modifiers){

		findVariableName(
				token,

				forbiddenNames,
				false,
				1,
				kind);
				modifiers);
	}
	private void findVariableNames(char[] name, TypeReference type , char[][] discouragedNames, char[][] forbiddenNames, int kind){
		if(type != null &&
			type.resolvedType != null) {
			TypeBinding tb = type.resolvedType;

					discouragedNames,
					forbiddenNames,
					type.dimensions(),
					kind);
					modifiers);
				
				if (tb.isParameterizedType() &&
						tb.findSuperTypeOriginatingFrom(TypeIds.T_JavaUtilCollection, false) != null) {

							tb,
							discouragedNames,
							forbiddenNames,
							kind);
							modifiers);
					}
				}
			}




			requestor.getResults());
}

//https://bugs.eclipse.org/bugs/show_bug.cgi?id=38111
public void testCompletionFieldName3() throws JavaModelException { 
	this.workingCopies = new ICompilationUnit[1];
	this.workingCopies[0] = getWorkingCopy(
		"/Completion/src/test/TypeNameRequestor.java",
		"package test;"+
		"public class TypeNameRequestor {\n" +
		"  public static final TypeNameRequestor \n" +
		"}\n");

	CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true);
	String str = this.workingCopies[0].getSource();
	String completeBehind = "final TypeNameRequestor ";
	int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
	this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);

	assertResults(
			"NAME_REQUESTOR[VARIABLE_DECLARATION]{NAME_REQUESTOR, null, Ltest.TypeNameRequestor;, NAME_REQUESTOR, null, " + (R_DEFAULT + R_INTERESTING + R_CASE+ R_NON_RESTRICTED) + "}\n" +
			"REQUESTOR[VARIABLE_DECLARATION]{REQUESTOR, null, Ltest.TypeNameRequestor;, REQUESTOR, null, " + (R_DEFAULT + R_INTERESTING + R_CASE+ R_NON_RESTRICTED) + "}\n" +
			"TYPE_NAME_REQUESTOR[VARIABLE_DECLARATION]{TYPE_NAME_REQUESTOR, null, Ltest.TypeNameRequestor;, TYPE_NAME_REQUESTOR, null, " + (R_DEFAULT + R_INTERESTING + R_CASE+ R_NON_RESTRICTED) + "}",
			requestor.getResults());
}

//https://bugs.eclipse.org/bugs/show_bug.cgi?id=38111
public void testCompletionFieldName4() throws JavaModelException { 
	this.workingCopies = new ICompilationUnit[1];
	this.workingCopies[0] = getWorkingCopy(
		"/Completion/src/test/TypeNameRequestor.java",
		"package test;"+
		"public class TypeNameRequestor {\n" +
		"  public static final TypeNameRequestor nam\n" +
		"}\n");

	CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true);
	String str = this.workingCopies[0].getSource();
	String completeBehind = "final TypeNameRequestor nam";
	int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
	this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);

	assertResults(
			"NAM_REQUESTOR[VARIABLE_DECLARATION]{NAM_REQUESTOR, null, Ltest.TypeNameRequestor;, NAM_REQUESTOR, null, " + (R_DEFAULT + R_INTERESTING + R_NON_RESTRICTED) + "}\n" +
			"NAM_TYPE_NAME_REQUESTOR[VARIABLE_DECLARATION]{NAM_TYPE_NAME_REQUESTOR, null, Ltest.TypeNameRequestor;, NAM_TYPE_NAME_REQUESTOR, null, " + (R_DEFAULT + R_INTERESTING + R_NON_RESTRICTED) + "}\n" +
			"NAME_REQUESTOR[VARIABLE_DECLARATION]{NAME_REQUESTOR, null, Ltest.TypeNameRequestor;, NAME_REQUESTOR, null, " + (R_DEFAULT + R_INTERESTING + R_NAME_LESS_NEW_CHARACTERS+ R_NON_RESTRICTED) + "}",
			requestor.getResults());
}

//https://bugs.eclipse.org/bugs/show_bug.cgi?id=38111
public void testCompletionFieldName5() throws JavaModelException { 
	this.workingCopies = new ICompilationUnit[1];
	this.workingCopies[0] = getWorkingCopy(
		"/Completion/src/test/TypeNameRequestor.java",
		"package test;"+
		"public class TypeNameRequestor {\n" +
		"  public static final TypeNameRequestor ZZ\n" +
		"}\n");

	CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true);
	String str = this.workingCopies[0].getSource();
	String completeBehind = "final TypeNameRequestor ZZ";
	int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
	this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);

	assertResults(
			"ZZ_NAME_REQUESTOR[VARIABLE_DECLARATION]{ZZ_NAME_REQUESTOR, null, Ltest.TypeNameRequestor;, ZZ_NAME_REQUESTOR, null, " + (R_DEFAULT + R_INTERESTING + R_CASE + R_NON_RESTRICTED) + "}\n" +
			"ZZ_REQUESTOR[VARIABLE_DECLARATION]{ZZ_REQUESTOR, null, Ltest.TypeNameRequestor;, ZZ_REQUESTOR, null, " + (R_DEFAULT + R_INTERESTING + R_CASE + R_NON_RESTRICTED) + "}\n" +
			"ZZ_TYPE_NAME_REQUESTOR[VARIABLE_DECLARATION]{ZZ_TYPE_NAME_REQUESTOR, null, Ltest.TypeNameRequestor;, ZZ_TYPE_NAME_REQUESTOR, null, " + (R_DEFAULT + R_INTERESTING + R_CASE+ R_NON_RESTRICTED) + "}",
			requestor.getResults());
}

//https://bugs.eclipse.org/bugs/show_bug.cgi?id=38111
public void testCompletionFieldName6() throws JavaModelException { 
	this.workingCopies = new ICompilationUnit[1];
	this.workingCopies[0] = getWorkingCopy(
		"/Completion/src/test/TypeNameRequestor.java",
		"package test;"+
		"public class TypeNameRequestor {\n" +
		"  public static final TypeNameRequestor ZZN\n" +
		"}\n");

	CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true);
	String str = this.workingCopies[0].getSource();
	String completeBehind = "final TypeNameRequestor ZZN";
	int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
	this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);

	assertResults(
			"ZZN_NAME_REQUESTOR[VARIABLE_DECLARATION]{ZZN_NAME_REQUESTOR, null, Ltest.TypeNameRequestor;, ZZN_NAME_REQUESTOR, null, " + (R_DEFAULT + R_INTERESTING + R_CASE + R_NON_RESTRICTED) + "}\n" +
			"ZZN_REQUESTOR[VARIABLE_DECLARATION]{ZZN_REQUESTOR, null, Ltest.TypeNameRequestor;, ZZN_REQUESTOR, null, " + (R_DEFAULT + R_INTERESTING + R_CASE + R_NON_RESTRICTED) + "}\n" +
			"ZZN_TYPE_NAME_REQUESTOR[VARIABLE_DECLARATION]{ZZN_TYPE_NAME_REQUESTOR, null, Ltest.TypeNameRequestor;, ZZN_TYPE_NAME_REQUESTOR, null, " + (R_DEFAULT + R_INTERESTING + R_CASE+ R_NON_RESTRICTED) + "}",
			requestor.getResults());
}

//https://bugs.eclipse.org/bugs/show_bug.cgi?id=38111
public void testCompletionFieldName7() throws JavaModelException { 
	this.workingCopies = new ICompilationUnit[1];
	this.workingCopies[0] = getWorkingCopy(
		"/Completion/src/test/TypeNameRequestor.java",
		"package test;"+
		"public class TypeNameRequestor {\n" +
		"  public static final TypeNameRequestor ZZ_N\n" +
		"}\n");

	CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true);
	String str = this.workingCopies[0].getSource();
	String completeBehind = "final TypeNameRequestor ZZ_N";
	int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
	this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);

	assertResults(
			"ZZ_N_REQUESTOR[VARIABLE_DECLARATION]{ZZ_N_REQUESTOR, null, Ltest.TypeNameRequestor;, ZZ_N_REQUESTOR, null, " + (R_DEFAULT + R_INTERESTING + R_CASE + R_NON_RESTRICTED) + "}\n" +
			"ZZ_N_TYPE_NAME_REQUESTOR[VARIABLE_DECLARATION]{ZZ_N_TYPE_NAME_REQUESTOR, null, Ltest.TypeNameRequestor;, ZZ_N_TYPE_NAME_REQUESTOR, null, " + (R_DEFAULT + R_INTERESTING + R_CASE + R_NON_RESTRICTED) + "}\n" +
			"ZZ_NAME_REQUESTOR[VARIABLE_DECLARATION]{ZZ_NAME_REQUESTOR, null, Ltest.TypeNameRequestor;, ZZ_NAME_REQUESTOR, null, " + (R_DEFAULT + R_INTERESTING + R_CASE + R_NAME_LESS_NEW_CHARACTERS + R_NON_RESTRICTED) + "}",
			requestor.getResults());
}

/**
 * Complete the type "A" from "new A".
 */




	super.setUp();
	this.project = createJavaProject("P", new String[]{"src"}, "bin"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
	this.oldOptions = JavaCore.getOptions();
//	this.abortOnFailure = false; // some tests have failing one time on macos boxes => do not abort on failures
}
/**
 * Cleanup after the previous test.


	super.tearDown();
}
/*
 * bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=38111
 */
public void testGetBaseName001() {
	String baseName = NamingConventions.getBaseName(
			NamingConventions.VK_INSTANCE_FIELD,
			"OneName", //$NON-NLS-1$
			this.project);
	
	assertEquals(
			"OneName", //$NON-NLS-1$
			baseName);
}
/*
 * bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=38111
 */
public void testGetBaseName002() {
	String baseName = NamingConventions.getBaseName(
			NamingConventions.VK_CONSTANT_FIELD,
			"ONE_NAME", //$NON-NLS-1$
			this.project);
	
	assertEquals(
			"OneName", //$NON-NLS-1$
			baseName);
}
/*
 * bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=38111
 */
public void testGetBaseName003() {
	Hashtable options = JavaCore.getOptions();
	options.put(JavaCore.CODEASSIST_FIELD_PREFIXES,"pre"); //$NON-NLS-1$
	options.put(JavaCore.CODEASSIST_FIELD_SUFFIXES,"suf"); //$NON-NLS-1$
	JavaCore.setOptions(options);
	
	String baseName = NamingConventions.getBaseName(
			NamingConventions.VK_INSTANCE_FIELD,
			"preOneNamesuf", //$NON-NLS-1$
			this.project);
	
	assertEquals(
			"OneName", //$NON-NLS-1$
			baseName);
}
/*
 * bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=38111
 */
public void testGetBaseName004() {
	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);
	
	String baseName = NamingConventions.getBaseName(
			NamingConventions.VK_CONSTANT_FIELD,
			"preONE_NAMEsuf", //$NON-NLS-1$
			this.project);
	
	assertEquals(
			"OneName", //$NON-NLS-1$
			baseName);
}
public void testSuggestFieldName001() {
	String[] suggestions = NamingConventions.suggestVariableNames(
			NamingConventions.VK_INSTANCE_FIELD,
			NamingConventions.BK_TYPE_NAME,
			"OneName", //$NON-NLS-1$
			this.project,
			0,
			new String[]{},
			true);

	assumeEquals(
		"oneName\n" + //$NON-NLS-1$
		"name", //$NON-NLS-1$
		toString(suggestions));
}
public void testSuggestFieldName002() {
	String[] suggestions = NamingConventions.suggestVariableNames(
			NamingConventions.VK_INSTANCE_FIELD,
			NamingConventions.BK_TYPE_NAME,
			"OneClass", //$NON-NLS-1$
			this.project,
			0,
			new String[]{},
			true);
	
	assumeEquals(
		"oneClass\n" + //$NON-NLS-1$
		"class1", //$NON-NLS-1$
		toString(suggestions));
}
public void testSuggestFieldName003() {

	options.put(JavaCore.CODEASSIST_FIELD_PREFIXES,"f"); //$NON-NLS-1$
	JavaCore.setOptions(options);

	String[] suggestions = NamingConventions.suggestVariableNames(
			NamingConventions.VK_INSTANCE_FIELD,
			NamingConventions.BK_TYPE_NAME,
			"OneName", //$NON-NLS-1$
			this.project,
			0,
			new String[]{},
			true);

	assumeEquals(
		"fName\n" + //$NON-NLS-1$
		"fOneName\n" + //$NON-NLS-1$
		"fName\n" + //$NON-NLS-1$
		"oneName\n" + //$NON-NLS-1$
		"name", //$NON-NLS-1$
		toString(suggestions));
}
public void testSuggestFieldName004() {

	options.put(JavaCore.CODEASSIST_FIELD_PREFIXES,"_"); //$NON-NLS-1$
	JavaCore.setOptions(options);

	String[] suggestions = NamingConventions.suggestVariableNames(
			NamingConventions.VK_INSTANCE_FIELD,
			NamingConventions.BK_TYPE_NAME,
			"OneName", //$NON-NLS-1$
			this.project,
			0,
			new String[]{},
			true);

	assumeEquals(
		"_name\n" + //$NON-NLS-1$
		"_oneName\n" + //$NON-NLS-1$
		"_name\n" + //$NON-NLS-1$
		"oneName\n" + //$NON-NLS-1$
		"name", //$NON-NLS-1$
		toString(suggestions));
}
public void testSuggestFieldName005() {

	options.put(JavaCore.CODEASSIST_FIELD_PREFIXES,"f"); //$NON-NLS-1$
	options.put(JavaCore.CODEASSIST_STATIC_FIELD_PREFIXES,"fg"); //$NON-NLS-1$
	JavaCore.setOptions(options);
	
	String[] suggestions = NamingConventions.suggestVariableNames(
			NamingConventions.VK_STATIC_FIELD,
			NamingConventions.BK_TYPE_NAME,
			"OneName", //$NON-NLS-1$
			this.project,
			0,
			new String[]{},
			true);

	assumeEquals(
		"fgName\n" + //$NON-NLS-1$
		"fgOneName\n" + //$NON-NLS-1$
		"fgName\n" + //$NON-NLS-1$
		"oneName\n" + //$NON-NLS-1$
		"name", //$NON-NLS-1$
		toString(suggestions));
}
public void testSuggestFieldName006() {

	options.put(JavaCore.CODEASSIST_FIELD_SUFFIXES,"suf"); //$NON-NLS-1$
	JavaCore.setOptions(options);

	String[] suggestions = NamingConventions.suggestVariableNames(
			NamingConventions.VK_INSTANCE_FIELD,
			NamingConventions.BK_TYPE_NAME,
			"OneName", //$NON-NLS-1$
			this.project,
			0,
			new String[]{},
			true);

	assumeEquals(
		"preNamesuf\n" + //$NON-NLS-1$
		"preOneNamesuf\n" + //$NON-NLS-1$
		"preNamesuf\n" + //$NON-NLS-1$
		"preOneName\n" + //$NON-NLS-1$
		"preName\n" + //$NON-NLS-1$
		"oneNamesuf\n" + //$NON-NLS-1$
		"namesuf\n" + //$NON-NLS-1$
		"oneName\n" + //$NON-NLS-1$
		"name", //$NON-NLS-1$
		toString(suggestions));
}
public void testSuggestFieldName007() {

	options.put(JavaCore.CODEASSIST_FIELD_SUFFIXES,"suf"); //$NON-NLS-1$
	JavaCore.setOptions(options);

	String[] suggestions = NamingConventions.suggestVariableNames(
			NamingConventions.VK_INSTANCE_FIELD,
			NamingConventions.BK_TYPE_NAME,
			"int", //$NON-NLS-1$
			this.project,
			0,
			new String[]{},
			true);

	assumeEquals(
		"preIsuf\n" + //$NON-NLS-1$

		toString(suggestions));
}
public void testSuggestFieldName008() {
	String[] suggestions = NamingConventions.suggestVariableNames(
			NamingConventions.VK_INSTANCE_FIELD,
			NamingConventions.BK_TYPE_NAME,
			"OneName", //$NON-NLS-1$
			this.project,
			0,
			new String[]{"name"}, //$NON-NLS-1$
			true);

	assumeEquals(
		"oneName\n" + //$NON-NLS-1$
		"name2", //$NON-NLS-1$
		toString(suggestions));
}
public void testSuggestFieldName009() {

	options.put(JavaCore.CODEASSIST_FIELD_SUFFIXES,"suf"); //$NON-NLS-1$
	JavaCore.setOptions(options);

	String[] suggestions = NamingConventions.suggestVariableNames(
			NamingConventions.VK_INSTANCE_FIELD,
			NamingConventions.BK_TYPE_NAME,
			"OneName", //$NON-NLS-1$
			this.project,
			0,
			new String[]{"preNamesuf"}, //$NON-NLS-1$
			true);
	
	assumeEquals(
		"preName2suf\n" + //$NON-NLS-1$
		"preOneNamesuf\n" + //$NON-NLS-1$
		"preName2suf\n" + //$NON-NLS-1$
		"preOneName\n" + //$NON-NLS-1$
		"preName\n" + //$NON-NLS-1$
		"oneNamesuf\n" + //$NON-NLS-1$
		"namesuf\n" + //$NON-NLS-1$
		"oneName\n" + //$NON-NLS-1$
		"name", //$NON-NLS-1$
		toString(suggestions));
}
public void testSuggestFieldName010() {

	options.put(JavaCore.CODEASSIST_FIELD_PREFIXES,"pre"); //$NON-NLS-1$
	options.put(JavaCore.CODEASSIST_FIELD_SUFFIXES,"suf"); //$NON-NLS-1$
	JavaCore.setOptions(options);
	
	String[] suggestions = NamingConventions.suggestVariableNames(
			NamingConventions.VK_INSTANCE_FIELD,
			NamingConventions.BK_TYPE_NAME,
			"OneName", //$NON-NLS-1$
			this.project,
			1,
			new String[]{"preNamesuf"}, //$NON-NLS-1$
			true);

	assumeEquals(
		"preNamessuf\n" + //$NON-NLS-1$
		"preOneNamessuf\n" + //$NON-NLS-1$
		"preNamessuf\n" + //$NON-NLS-1$
		"preOneNames\n" + //$NON-NLS-1$
		"preNames\n" + //$NON-NLS-1$
		"oneNamessuf\n" + //$NON-NLS-1$
		"namessuf\n" + //$NON-NLS-1$
		"oneNames\n" + //$NON-NLS-1$
		"names", //$NON-NLS-1$
		toString(suggestions));
}
public void testSuggestFieldName011() {
	
	String[] suggestions = NamingConventions.suggestVariableNames(
			NamingConventions.VK_INSTANCE_FIELD,
			NamingConventions.BK_TYPE_NAME,
			"Factory", //$NON-NLS-1$
			this.project,
			1,
			new String[]{},
			true);

	assumeEquals(
		"factories", //$NON-NLS-1$
		toString(suggestions));
}
public void testSuggestFieldName012() {
	String[] suggestions = NamingConventions.suggestVariableNames(
			NamingConventions.VK_INSTANCE_FIELD,
			NamingConventions.BK_TYPE_NAME,
			"FooBar", //$NON-NLS-1$
			this.project,
			0,
			new String[]{"bar"}, //$NON-NLS-1$
			true);

	assumeEquals(
		"fooBar\n" + //$NON-NLS-1$
		"bar2", //$NON-NLS-1$
		toString(suggestions));
}
public void testSuggestFieldName013() {
	String[] suggestions = NamingConventions.suggestVariableNames(
			NamingConventions.VK_INSTANCE_FIELD,
			NamingConventions.BK_TYPE_NAME,
			"Class", //$NON-NLS-1$
			this.project,
			0,
			new String[]{},
			true);

	assumeEquals(
		"class1",//$NON-NLS-1$
		toString(suggestions));
}
public void testSuggestFieldName014() {
	String[] suggestions = NamingConventions.suggestVariableNames(
			NamingConventions.VK_INSTANCE_FIELD,
			NamingConventions.BK_TYPE_NAME,
			"Class", //$NON-NLS-1$
			this.project,
			0,
			new String[]{"class1"}, //$NON-NLS-1$
			true);

	assumeEquals(
		"class2",//$NON-NLS-1$
		toString(suggestions));
}
public void testSuggestFieldName015() {
	String[] suggestions = NamingConventions.suggestVariableNames(
			NamingConventions.VK_INSTANCE_FIELD,
			NamingConventions.BK_TYPE_NAME,
			"#", //$NON-NLS-1$
			this.project,
			0,
			new String[]{},
			true);

	assumeEquals(
		"name",//$NON-NLS-1$
		toString(suggestions));
}
public void testSuggestFieldName016() {
	String[] suggestions = NamingConventions.suggestVariableNames(
			NamingConventions.VK_INSTANCE_FIELD,
			NamingConventions.BK_TYPE_NAME,
			"#", //$NON-NLS-1$
			this.project,
			0,
			new String[]{"name"}, //$NON-NLS-1$
			true);

	assumeEquals(
		"name2",//$NON-NLS-1$

 * bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=35356
 */
public void testSuggestFieldName017() {
	String[] suggestions = NamingConventions.suggestVariableNames(
			NamingConventions.VK_INSTANCE_FIELD,
			NamingConventions.BK_TYPE_NAME,
			"names", //$NON-NLS-1$
			this.project,
			0,
			new String[]{},
			true);

	assumeEquals(
		"names",//$NON-NLS-1$

 * bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=35356
 */
public void testSuggestFieldName018() {
	String[] suggestions = NamingConventions.suggestVariableNames(
			NamingConventions.VK_INSTANCE_FIELD,
			NamingConventions.BK_TYPE_NAME,
			"names", //$NON-NLS-1$
			this.project,
			1,
			new String[]{},
			true);

	assumeEquals(
		"names",//$NON-NLS-1$

 * bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=35356
 */
public void testSuggestFieldName019() {
	String[] suggestions = NamingConventions.suggestVariableNames(
			NamingConventions.VK_INSTANCE_FIELD,
			NamingConventions.BK_TYPE_NAME,
			"MyClass", //$NON-NLS-1$
			this.project,
			0,
			new String[]{},
			true);

	assumeEquals(
		"myClass\n" + //$NON-NLS-1$
		"class1", //$NON-NLS-1$
		toString(suggestions));
}
/*
 * bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=35356
 */
public void testSuggestFieldName020() {
	String[] suggestions = NamingConventions.suggestVariableNames(
			NamingConventions.VK_INSTANCE_FIELD,
			NamingConventions.BK_TYPE_NAME,
			"MyClass", //$NON-NLS-1$
			this.project,
			1,
			new String[]{},
			true);

	assumeEquals(
		"myClasses\n" + //$NON-NLS-1$
		"classes", //$NON-NLS-1$
		toString(suggestions));
}
/*
 * bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=38111
 */
public void testSuggestFieldName021() {
	String[] suggestions = NamingConventions.suggestVariableNames(
			NamingConventions.VK_CONSTANT_FIELD,
			NamingConventions.BK_TYPE_NAME,
			"MyType", //$NON-NLS-1$
			this.project,
			0,
			new String[]{},
			true);

	assumeEquals(
		"MY_TYPE\n" + //$NON-NLS-1$
		"TYPE", //$NON-NLS-1$
		toString(suggestions));
}
/*
 * bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=38111
 */
public void testSuggestFieldName022() {
	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);
	
	String[] suggestions = NamingConventions.suggestVariableNames(
			NamingConventions.VK_CONSTANT_FIELD,
			NamingConventions.BK_TYPE_NAME,
			"MyType", //$NON-NLS-1$
			this.project,
			0,
			new String[]{},
			true);

	assumeEquals(
		"preMY_TYPEsuf\n" + //$NON-NLS-1$
		"preTYPEsuf\n" + //$NON-NLS-1$
		"preMY_TYPE\n" + //$NON-NLS-1$
		"preTYPE\n" + //$NON-NLS-1$
		"MY_TYPEsuf\n" + //$NON-NLS-1$
		"TYPEsuf\n" + //$NON-NLS-1$
		"MY_TYPE\n" + //$NON-NLS-1$
		"TYPE", //$NON-NLS-1$
		toString(suggestions));
}
/*
 * bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=38111
 */
public void testSuggestFieldName023() {
	String[] suggestions = NamingConventions.suggestVariableNames(
			NamingConventions.VK_INSTANCE_FIELD,
			NamingConventions.BK_NAME,
			"oneName", //$NON-NLS-1$
			this.project,
			0,
			new String[]{},
			true);

	assumeEquals(
		"oneName", //$NON-NLS-1$
		toString(suggestions));
}
/*
 * bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=38111
 */
public void testSuggestFieldName024() {
	Hashtable options = JavaCore.getOptions();
	options.put(JavaCore.CODEASSIST_FIELD_PREFIXES,"pre"); //$NON-NLS-1$
	options.put(JavaCore.CODEASSIST_FIELD_SUFFIXES,"suf"); //$NON-NLS-1$
	JavaCore.setOptions(options);
	
	String[] suggestions = NamingConventions.suggestVariableNames(
			NamingConventions.VK_INSTANCE_FIELD,
			NamingConventions.BK_NAME,
			"oneName", //$NON-NLS-1$
			this.project,
			0,
			new String[]{},
			true);

	assumeEquals(
		"preOneNamesuf\n" + //$NON-NLS-1$
		"preOneName\n" + //$NON-NLS-1$
		"oneNamesuf\n" + //$NON-NLS-1$
		"oneName", //$NON-NLS-1$
		toString(suggestions));
}
/*
 * bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=38111
 */
public void testSuggestFieldName025() {
	String[] suggestions = NamingConventions.suggestVariableNames(
			NamingConventions.VK_CONSTANT_FIELD,
			NamingConventions.BK_TYPE_NAME,
			"My_Type", //$NON-NLS-1$
			this.project,
			0,
			new String[]{},
			true);

	assumeEquals(
		"MY_TYPE\n" + //$NON-NLS-1$
		"TYPE", //$NON-NLS-1$
		toString(suggestions));
}
/*
 * bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=38111
 */
public void testSuggestFieldName026() {
	String[] suggestions = NamingConventions.suggestVariableNames(
			NamingConventions.VK_CONSTANT_FIELD,
			NamingConventions.BK_TYPE_NAME,
			"_MyType", //$NON-NLS-1$
			this.project,
			0,
			new String[]{},
			true);

	assumeEquals(
		"_MY_TYPE\n" + //$NON-NLS-1$
		"MY_TYPE\n" + //$NON-NLS-1$
		"TYPE", //$NON-NLS-1$
		toString(suggestions));
}
/*
 * bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=38111
 */
public void testSuggestFieldName027() {
	String[] suggestions = NamingConventions.suggestVariableNames(
			NamingConventions.VK_CONSTANT_FIELD,
			NamingConventions.BK_TYPE_NAME,
			"MyType_", //$NON-NLS-1$
			this.project,
			0,
			new String[]{},
			true);

	assumeEquals(
		"MY_TYPE_\n" + //$NON-NLS-1$
		"TYPE_", //$NON-NLS-1$
		toString(suggestions));
}
/*
 * bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=38111
 */
public void testSuggestFieldName028() {
	String[] suggestions = NamingConventions.suggestVariableNames(
			NamingConventions.VK_CONSTANT_FIELD,
			NamingConventions.BK_TYPE_NAME,
			"MyTyp_e", //$NON-NLS-1$
			this.project,
			0,
			new String[]{},
			true);

	assumeEquals(
		"MY_TYP_E\n" + //$NON-NLS-1$
		"TYP_E", //$NON-NLS-1$
		toString(suggestions));
}
/*
 * bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=38111
 */
public void testSuggestFieldName029() {
	String[] suggestions = NamingConventions.suggestVariableNames(
			NamingConventions.VK_INSTANCE_FIELD,
			NamingConventions.BK_TYPE_NAME,
			"My1Type", //$NON-NLS-1$
			this.project,
			0,
			new String[]{},
			true);

	assumeEquals(
		"my1Type\n" + //$NON-NLS-1$
		"type", //$NON-NLS-1$
		toString(suggestions));
}
/*
 * bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=38111
 */
public void testSuggestFieldName030() {
	String[] suggestions = NamingConventions.suggestVariableNames(
			NamingConventions.VK_INSTANCE_FIELD,
			NamingConventions.BK_TYPE_NAME,
			"M1yType", //$NON-NLS-1$
			this.project,
			0,
			new String[]{},
			true);

	assumeEquals(
		"m1yType\n" + //$NON-NLS-1$
		"type", //$NON-NLS-1$
		toString(suggestions));
}
/*
 * bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=38111
 */
public void testSuggestFieldName031() {
	String[] suggestions = NamingConventions.suggestVariableNames(
			NamingConventions.VK_INSTANCE_FIELD,
			NamingConventions.BK_TYPE_NAME,
			"MY1Type", //$NON-NLS-1$
			this.project,
			0,
			new String[]{},
			true);

	assumeEquals(
		"my1Type\n" + //$NON-NLS-1$
		"type", //$NON-NLS-1$
		toString(suggestions));
}
/*
 * bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=38111
 */
public void testSuggestFieldName032() {
	String[] suggestions = NamingConventions.suggestVariableNames(
			NamingConventions.VK_INSTANCE_FIELD,
			NamingConventions.BK_TYPE_NAME,
			"M1YType", //$NON-NLS-1$
			this.project,
			0,
			new String[]{},
			true);

	assumeEquals(
		"m1yType\n" + //$NON-NLS-1$
		"type", //$NON-NLS-1$
		toString(suggestions));
}
/** @deprecated */
public void testRemovePrefixAndSuffixForFieldName001() {
	Hashtable options = JavaCore.getOptions();
	options.put(JavaCore.CODEASSIST_FIELD_PREFIXES,"pre"); //$NON-NLS-1$

		"oneName", //$NON-NLS-1$
		new String(name));
}
/** @deprecated */
public void testRemovePrefixAndSuffixForFieldName002() {
	Hashtable options = JavaCore.getOptions();
	options.put(JavaCore.CODEASSIST_FIELD_PREFIXES,"pr, pre"); //$NON-NLS-1$

		"preOneNamesuf", //$NON-NLS-1$
		new String(name));
}
/** @deprecated */
public void testRemovePrefixAndSuffixForFieldName003() {
	Hashtable options = JavaCore.getOptions();
	options.put(JavaCore.CODEASSIST_FIELD_PREFIXES,"pr, pre"); //$NON-NLS-1$

		new String(name));
}
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=114086
/** @deprecated */
public void testRemovePrefixAndSuffixForFieldName004() {
	Hashtable options = JavaCore.getOptions();
	options.put(JavaCore.CODEASSIST_FIELD_PREFIXES,"pre,"); //$NON-NLS-1$

		"oneName", //$NON-NLS-1$
		new String(name));
}
/** @deprecated */
public void testRemovePrefixAndSuffixForLocalName001() {
	Hashtable options = JavaCore.getOptions();
	options.put(JavaCore.CODEASSIST_LOCAL_PREFIXES,"pr, pre"); //$NON-NLS-1$

		newOptions.put(JavaCore.COMPILER_COMPLIANCE, JavaCore.VERSION_1_5);
		this.project.setOptions(newOptions);

		String[] suggestions = NamingConventions.suggestVariableNames(
			NamingConventions.VK_LOCAL,
			NamingConventions.BK_TYPE_NAME,
			"Enum",
			this.project,
			"",//$NON-NLS-1$
			"Enum",//$NON-NLS-1$
			0,
			new String[]{"o"}, //$NON-NLS-1$
			true);

		assumeEquals(
			"enum1", //$NON-NLS-1$

		newOptions.put(JavaCore.COMPILER_COMPLIANCE, JavaCore.VERSION_1_5);
		this.project.setOptions(newOptions);

		String[] suggestions = NamingConventions.suggestVariableNames(
			NamingConventions.VK_LOCAL,
			NamingConventions.BK_TYPE_NAME,
			"Enums",
			this.project,
			"",//$NON-NLS-1$
			"Enums",//$NON-NLS-1$
			0,
			new String[]{"o"}, //$NON-NLS-1$
			true);

		assumeEquals(
			"enums", //$NON-NLS-1$

Return to bug 38111

Lines 1965-1974 Link Here

(-)model/org/eclipse/jdt/internal/core/JavaModelManager.java (+2 lines)
1965	defaultOptionsMap.put(JavaCore.CODEASSIST_IMPLICIT_QUALIFICATION, JavaCore.DISABLED);	1965	defaultOptionsMap.put(JavaCore.CODEASSIST_IMPLICIT_QUALIFICATION, JavaCore.DISABLED);
1966	defaultOptionsMap.put(JavaCore.CODEASSIST_FIELD_PREFIXES, ""); //$NON-NLS-1$	1966	defaultOptionsMap.put(JavaCore.CODEASSIST_FIELD_PREFIXES, ""); //$NON-NLS-1$
1967	defaultOptionsMap.put(JavaCore.CODEASSIST_STATIC_FIELD_PREFIXES, ""); //$NON-NLS-1$	1967	defaultOptionsMap.put(JavaCore.CODEASSIST_STATIC_FIELD_PREFIXES, ""); //$NON-NLS-1$
		1968	defaultOptionsMap.put(JavaCore.CODEASSIST_STATIC_FINAL_FIELD_PREFIXES, ""); //$NON-NLS-1$
1968	defaultOptionsMap.put(JavaCore.CODEASSIST_LOCAL_PREFIXES, ""); //$NON-NLS-1$	1969	defaultOptionsMap.put(JavaCore.CODEASSIST_LOCAL_PREFIXES, ""); //$NON-NLS-1$
1969	defaultOptionsMap.put(JavaCore.CODEASSIST_ARGUMENT_PREFIXES, ""); //$NON-NLS-1$	1970	defaultOptionsMap.put(JavaCore.CODEASSIST_ARGUMENT_PREFIXES, ""); //$NON-NLS-1$
1970	defaultOptionsMap.put(JavaCore.CODEASSIST_FIELD_SUFFIXES, ""); //$NON-NLS-1$	1971	defaultOptionsMap.put(JavaCore.CODEASSIST_FIELD_SUFFIXES, ""); //$NON-NLS-1$
1971	defaultOptionsMap.put(JavaCore.CODEASSIST_STATIC_FIELD_SUFFIXES, ""); //$NON-NLS-1$	1972	defaultOptionsMap.put(JavaCore.CODEASSIST_STATIC_FIELD_SUFFIXES, ""); //$NON-NLS-1$
		1973	defaultOptionsMap.put(JavaCore.CODEASSIST_STATIC_FINAL_FIELD_SUFFIXES, ""); //$NON-NLS-1$
1972	defaultOptionsMap.put(JavaCore.CODEASSIST_LOCAL_SUFFIXES, ""); //$NON-NLS-1$	1974	defaultOptionsMap.put(JavaCore.CODEASSIST_LOCAL_SUFFIXES, ""); //$NON-NLS-1$
1973	defaultOptionsMap.put(JavaCore.CODEASSIST_ARGUMENT_SUFFIXES, ""); //$NON-NLS-1$	1975	defaultOptionsMap.put(JavaCore.CODEASSIST_ARGUMENT_SUFFIXES, ""); //$NON-NLS-1$
1974	defaultOptionsMap.put(JavaCore.CODEASSIST_FORBIDDEN_REFERENCE_CHECK, JavaCore.ENABLED);	1976	defaultOptionsMap.put(JavaCore.CODEASSIST_FORBIDDEN_REFERENCE_CHECK, JavaCore.ENABLED);

Lines 3582-3587 Link Here

(-)compiler/org/eclipse/jdt/core/compiler/CharOperation.java (+48 lines)
3582	}	3582	}
3583		3583
3584	/**	3584	/**
		3585	* Answers the result of a char[] conversion to uppercase. Answers null if the given chars array is null.
		3586	* <br>
		3587	* NOTE: If no conversion was necessary, then answers back the argument one.
		3588	* <br>
		3589	* <br>
		3590	* For example:
		3591	* <ol>
		3592	* <li><pre>
		3593	* chars = { 'A' , 'B' }
		3594	* result => { 'A' , 'B' }
		3595	* </pre>
		3596	* </li>
		3597	* <li><pre>
		3598	* array = { 'a', 'B' }
		3599	* result => { 'A' , 'B' }
		3600	* </pre>
		3601	* </li>
		3602	* </ol>
		3603	*
		3604	* @param chars the chars to convert
		3605	* @return the result of a char[] conversion to uppercase
		3606	*
		3607	* @since 3.5
		3608	*/
		3609	final static public char[] toUpperCase(char[] chars) {
		3610	if (chars == null)
		3611	return null;
		3612	int length = chars.length;
		3613	char[] upperChars = null;
		3614	for (int i = 0; i < length; i++) {
		3615	char c = chars[i];
		3616	char lc = ScannerHelper.toUpperCase(c);
		3617	if ((c != lc) \|\| (upperChars != null)) {
		3618	if (upperChars == null) {
		3619	System.arraycopy(
		3620	chars,
		3621	0,
		3622	upperChars = new char[length],
		3623	0,
		3624	i);
		3625	}
		3626	upperChars[i] = lc;
		3627	}
		3628	}
		3629	return upperChars == null ? chars : upperChars;
		3630	}
		3631
		3632	/**
3585	* Answers a new array removing leading and trailing spaces (' '). Answers the given array if there is no	3633	* Answers a new array removing leading and trailing spaces (' '). Answers the given array if there is no
3586	* space characters to remove.	3634	* space characters to remove.
3587	* <br>	3635	* <br>

Lines 342-351 Link Here

(-)codeassist/org/eclipse/jdt/internal/codeassist/CompletionEngine.java (-57 / +39 lines)
342	private final static int SUPERTYPE = 1;	342	private final static int SUPERTYPE = 1;
343	private final static int SUBTYPE = 2;	343	private final static int SUBTYPE = 2;
344		344
345	private final static int FIELD = 0;
346	private final static int LOCAL = 1;
347	private final static int ARGUMENT = 2;
348
349	int expectedTypesPtr = -1;	345	int expectedTypesPtr = -1;
350	TypeBinding[] expectedTypes = new TypeBinding[1];	346	TypeBinding[] expectedTypes = new TypeBinding[1];
351	int expectedTypesFilter;	347	int expectedTypesFilter;
Lines 1559-1565 Link Here
1559		1555
1560	this.completionToken = field.realName;	1556	this.completionToken = field.realName;
1561		1557
1562	findVariableNames(field.realName, field.type, excludeNames, null, FIELD, field.modifiers);	1558
		1559	int kind =
		1560	(field.modifiers & ClassFileConstants.AccStatic) == 0 ?
		1561	InternalNamingConventions.VK_INSTANCE_FIELD :
		1562	(field.modifiers & ClassFileConstants.AccFinal) == 0 ?
		1563	InternalNamingConventions.VK_STATIC_FIELD :
		1564	InternalNamingConventions.VK_CONSTANT_FIELD;
		1565
		1566	findVariableNames(field.realName, field.type, excludeNames, null, kind);
1563	}	1567	}
1564	}	1568	}
1565		1569
Lines 1826-1836 Link Here
1826	int kind;	1830	int kind;
1827	if (variable instanceof CompletionOnLocalName){	1831	if (variable instanceof CompletionOnLocalName){
1828	this.completionToken = ((CompletionOnLocalName) variable).realName;	1832	this.completionToken = ((CompletionOnLocalName) variable).realName;
1829	kind = LOCAL;	1833	kind = InternalNamingConventions.VK_LOCAL;
1830	} else {	1834	} else {
1831	CompletionOnArgumentName arg = (CompletionOnArgumentName) variable;	1835	CompletionOnArgumentName arg = (CompletionOnArgumentName) variable;
1832	this.completionToken = arg.realName;	1836	this.completionToken = arg.realName;
1833	kind = arg.isCatchArgument ? LOCAL : ARGUMENT;	1837	kind = arg.isCatchArgument ? InternalNamingConventions.VK_LOCAL : InternalNamingConventions.VK_PARAMETER;
1834	}	1838	}
1835		1839
1836	char[][] alreadyDefinedName = computeAlreadyDefinedName((BlockScope)scope, variable);	1840	char[][] alreadyDefinedName = computeAlreadyDefinedName((BlockScope)scope, variable);
Lines 1848-1854 Link Here
1848		1852
1849	System.arraycopy(discouragedNames, 0, discouragedNames = new char[localCount][], 0, localCount);	1853	System.arraycopy(discouragedNames, 0, discouragedNames = new char[localCount][], 0, localCount);
1850		1854
1851	findVariableNames(this.completionToken, variable.type, discouragedNames, forbiddenNames, kind, variable.modifiers);	1855	findVariableNames(this.completionToken, variable.type, discouragedNames, forbiddenNames, kind);
1852	}	1856	}
1853	}	1857	}
1854		1858
Lines 2166-2172 Link Here
2166		2170
2167	this.completionToken = method.selector;	2171	this.completionToken = method.selector;
2168		2172
2169	findVariableNames(this.completionToken, method.returnType, excludeNames, null, FIELD, method.modifiers);	2173
		2174	int kind =
		2175	(method.modifiers & ClassFileConstants.AccStatic) == 0 ?
		2176	InternalNamingConventions.VK_INSTANCE_FIELD :
		2177	(method.modifiers & ClassFileConstants.AccFinal) == 0 ?
		2178	InternalNamingConventions.VK_STATIC_FIELD :
		2179	InternalNamingConventions.VK_CONSTANT_FIELD;
		2180
		2181	findVariableNames(this.completionToken, method.returnType, excludeNames, null, kind);
2170	}	2182	}
2171	}	2183	}
2172		2184
Lines 9674-9681 Link Here
9674	final char[][] forbiddenNames,	9686	final char[][] forbiddenNames,
9675	boolean forCollection,	9687	boolean forCollection,
9676	int dim,	9688	int dim,
9677	int kind,	9689	int kind){
9678	int modifiers){
9679		9690
9680	if(sourceName == null \|\| sourceName.length == 0)	9691	if(sourceName == null \|\| sourceName.length == 0)
9681	return;	9692	return;
Lines 9755-9793 Link Here
9755	}	9766	}
9756	};	9767	};
9757		9768
9758	switch (kind) {	9769	InternalNamingConventions.suggestVariableNames(
9759	case FIELD :	9770	kind,
9760	InternalNamingConventions.suggestFieldNames(	9771	InternalNamingConventions.BK_SIMPLE_TYPE_NAME,
9761	this.javaProject,	9772	qualifiedSourceName,
9762	qualifiedPackageName,	9773	this.javaProject,
9763	qualifiedSourceName,	9774	dim,
9764	dim,	9775	token,
9765	modifiers,	9776	discouragedNames,
9766	token,	9777	true,
9767	discouragedNames,	9778	namingRequestor);
9768	namingRequestor);
9769	break;
9770	case LOCAL :
9771	InternalNamingConventions.suggestLocalVariableNames(
9772	this.javaProject,
9773	qualifiedPackageName,
9774	qualifiedSourceName,
9775	dim,
9776	token,
9777	discouragedNames,
9778	namingRequestor);
9779	break;
9780	case ARGUMENT :
9781	InternalNamingConventions.suggestArgumentNames(
9782	this.javaProject,
9783	qualifiedPackageName,
9784	qualifiedSourceName,
9785	dim,
9786	token,
9787	discouragedNames,
9788	namingRequestor);
9789	break;
9790	}
9791	}	9779	}
9792		9780
9793	// Helper method for private void findVariableNames(char[] name, TypeReference type )	9781	// Helper method for private void findVariableNames(char[] name, TypeReference type )
Lines 9800-9807 Link Here
9800	char[][] discouragedNames,	9788	char[][] discouragedNames,
9801	final char[][] forbiddenNames,	9789	final char[][] forbiddenNames,
9802	int dim,	9790	int dim,
9803	int kind,	9791	int kind){
9804	int modifiers){
9805	findVariableName(	9792	findVariableName(
9806	token,	9793	token,
9807	qualifiedPackageName,	9794	qualifiedPackageName,
Lines 9812-9819 Link Here
9812	forbiddenNames,	9799	forbiddenNames,
9813	false,	9800	false,
9814	dim,	9801	dim,
9815	kind,	9802	kind);
9816	modifiers);
9817	}	9803	}
9818	private void findVariableNameForCollection(	9804	private void findVariableNameForCollection(
9819	char[] token,	9805	char[] token,
Lines 9823-9830 Link Here
9823	final TypeBinding typeBinding,	9809	final TypeBinding typeBinding,
9824	char[][] discouragedNames,	9810	char[][] discouragedNames,
9825	final char[][] forbiddenNames,	9811	final char[][] forbiddenNames,
9826	int kind,	9812	int kind){
9827	int modifiers){
9828		9813
9829	findVariableName(	9814	findVariableName(
9830	token,	9815	token,
Lines 9836-9845 Link Here
9836	forbiddenNames,	9821	forbiddenNames,
9837	false,	9822	false,
9838	1,	9823	1,
9839	kind,	9824	kind);
9840	modifiers);
9841	}	9825	}
9842	private void findVariableNames(char[] name, TypeReference type , char[][] discouragedNames, char[][] forbiddenNames, int kind, int modifiers){	9826	private void findVariableNames(char[] name, TypeReference type , char[][] discouragedNames, char[][] forbiddenNames, int kind){
9843	if(type != null &&	9827	if(type != null &&
9844	type.resolvedType != null) {	9828	type.resolvedType != null) {
9845	TypeBinding tb = type.resolvedType;	9829	TypeBinding tb = type.resolvedType;
Lines 9855-9862 Link Here
9855	discouragedNames,	9839	discouragedNames,
9856	forbiddenNames,	9840	forbiddenNames,
9857	type.dimensions(),	9841	type.dimensions(),
9858	kind,	9842	kind);
9859	modifiers);
9860		9843
9861	if (tb.isParameterizedType() &&	9844	if (tb.isParameterizedType() &&
9862	tb.findSuperTypeOriginatingFrom(TypeIds.T_JavaUtilCollection, false) != null) {	9845	tb.findSuperTypeOriginatingFrom(TypeIds.T_JavaUtilCollection, false) != null) {
Lines 9872-9879 Link Here
9872	tb,	9855	tb,
9873	discouragedNames,	9856	discouragedNames,
9874	forbiddenNames,	9857	forbiddenNames,
9875	kind,	9858	kind);
9876	modifiers);
9877	}	9859	}
9878	}	9860	}
9879	}	9861	}

Lines 5139-5144 Link Here

(-)src/org/eclipse/jdt/core/tests/model/CompletionTests.java (+115 lines)
5139	requestor.getResults());	5139	requestor.getResults());
5140	}	5140	}
5141		5141
		5142	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=38111
		5143	public void testCompletionFieldName3() throws JavaModelException {
		5144	this.workingCopies = new ICompilationUnit[1];
		5145	this.workingCopies[0] = getWorkingCopy(
		5146	"/Completion/src/test/TypeNameRequestor.java",
		5147	"package test;"+
		5148	"public class TypeNameRequestor {\n" +
		5149	" public static final TypeNameRequestor \n" +
		5150	"}\n");
		5151
		5152	CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true);
		5153	String str = this.workingCopies[0].getSource();
		5154	String completeBehind = "final TypeNameRequestor ";
		5155	int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
		5156	this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);
		5157
		5158	assertResults(
		5159	"NAME_REQUESTOR[VARIABLE_DECLARATION]{NAME_REQUESTOR, null, Ltest.TypeNameRequestor;, NAME_REQUESTOR, null, " + (R_DEFAULT + R_INTERESTING + R_CASE+ R_NON_RESTRICTED) + "}\n" +
		5160	"REQUESTOR[VARIABLE_DECLARATION]{REQUESTOR, null, Ltest.TypeNameRequestor;, REQUESTOR, null, " + (R_DEFAULT + R_INTERESTING + R_CASE+ R_NON_RESTRICTED) + "}\n" +
		5161	"TYPE_NAME_REQUESTOR[VARIABLE_DECLARATION]{TYPE_NAME_REQUESTOR, null, Ltest.TypeNameRequestor;, TYPE_NAME_REQUESTOR, null, " + (R_DEFAULT + R_INTERESTING + R_CASE+ R_NON_RESTRICTED) + "}",
		5162	requestor.getResults());
		5163	}
		5164
		5165	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=38111
		5166	public void testCompletionFieldName4() throws JavaModelException {
		5167	this.workingCopies = new ICompilationUnit[1];
		5168	this.workingCopies[0] = getWorkingCopy(
		5169	"/Completion/src/test/TypeNameRequestor.java",
		5170	"package test;"+
		5171	"public class TypeNameRequestor {\n" +
		5172	" public static final TypeNameRequestor nam\n" +
		5173	"}\n");
		5174
		5175	CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true);
		5176	String str = this.workingCopies[0].getSource();
		5177	String completeBehind = "final TypeNameRequestor nam";
		5178	int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
		5179	this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);
		5180
		5181	assertResults(
		5182	"NAM_REQUESTOR[VARIABLE_DECLARATION]{NAM_REQUESTOR, null, Ltest.TypeNameRequestor;, NAM_REQUESTOR, null, " + (R_DEFAULT + R_INTERESTING + R_NON_RESTRICTED) + "}\n" +
		5183	"NAM_TYPE_NAME_REQUESTOR[VARIABLE_DECLARATION]{NAM_TYPE_NAME_REQUESTOR, null, Ltest.TypeNameRequestor;, NAM_TYPE_NAME_REQUESTOR, null, " + (R_DEFAULT + R_INTERESTING + R_NON_RESTRICTED) + "}\n" +
		5184	"NAME_REQUESTOR[VARIABLE_DECLARATION]{NAME_REQUESTOR, null, Ltest.TypeNameRequestor;, NAME_REQUESTOR, null, " + (R_DEFAULT + R_INTERESTING + R_NAME_LESS_NEW_CHARACTERS+ R_NON_RESTRICTED) + "}",
		5185	requestor.getResults());
		5186	}
		5187
		5188	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=38111
		5189	public void testCompletionFieldName5() throws JavaModelException {
		5190	this.workingCopies = new ICompilationUnit[1];
		5191	this.workingCopies[0] = getWorkingCopy(
		5192	"/Completion/src/test/TypeNameRequestor.java",
		5193	"package test;"+
		5194	"public class TypeNameRequestor {\n" +
		5195	" public static final TypeNameRequestor ZZ\n" +
		5196	"}\n");
		5197
		5198	CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true);
		5199	String str = this.workingCopies[0].getSource();
		5200	String completeBehind = "final TypeNameRequestor ZZ";
		5201	int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
		5202	this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);
		5203
		5204	assertResults(
		5205	"ZZ_NAME_REQUESTOR[VARIABLE_DECLARATION]{ZZ_NAME_REQUESTOR, null, Ltest.TypeNameRequestor;, ZZ_NAME_REQUESTOR, null, " + (R_DEFAULT + R_INTERESTING + R_CASE + R_NON_RESTRICTED) + "}\n" +
5206	"ZZ_REQUESTOR[VARIABLE_DECLARATION]{ZZ_REQUESTOR, null, Ltest.TypeNameRequestor;, ZZ_REQUESTOR, null, " + (R_DEFAULT + R_INTERESTING + R_CASE + R_NON_RESTRICTED) + "}\n" +
5207	"ZZ_TYPE_NAME_REQUESTOR[VARIABLE_DECLARATION]{ZZ_TYPE_NAME_REQUESTOR, null, Ltest.TypeNameRequestor;, ZZ_TYPE_NAME_REQUESTOR, null, " + (R_DEFAULT + R_INTERESTING + R_CASE+ R_NON_RESTRICTED) + "}",
5208	requestor.getResults());
5209	}
5210
5211	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=38111
5212	public void testCompletionFieldName6() throws JavaModelException {
5213	this.workingCopies = new ICompilationUnit[1];
5214	this.workingCopies[0] = getWorkingCopy(
5215	"/Completion/src/test/TypeNameRequestor.java",
5216	"package test;"+
5217	"public class TypeNameRequestor {\n" +
5218	" public static final TypeNameRequestor ZZN\n" +
5219	"}\n");
5220
5221	CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true);
5222	String str = this.workingCopies[0].getSource();
5223	String completeBehind = "final TypeNameRequestor ZZN";
5224	int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
5225	this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);
5226
5227	assertResults(
5228	"ZZN_NAME_REQUESTOR[VARIABLE_DECLARATION]{ZZN_NAME_REQUESTOR, null, Ltest.TypeNameRequestor;, ZZN_NAME_REQUESTOR, null, " + (R_DEFAULT + R_INTERESTING + R_CASE + R_NON_RESTRICTED) + "}\n" +
5229	"ZZN_REQUESTOR[VARIABLE_DECLARATION]{ZZN_REQUESTOR, null, Ltest.TypeNameRequestor;, ZZN_REQUESTOR, null, " + (R_DEFAULT + R_INTERESTING + R_CASE + R_NON_RESTRICTED) + "}\n" +
5230	"ZZN_TYPE_NAME_REQUESTOR[VARIABLE_DECLARATION]{ZZN_TYPE_NAME_REQUESTOR, null, Ltest.TypeNameRequestor;, ZZN_TYPE_NAME_REQUESTOR, null, " + (R_DEFAULT + R_INTERESTING + R_CASE+ R_NON_RESTRICTED) + "}",
5231	requestor.getResults());
5232	}
5233
5234	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=38111
5235	public void testCompletionFieldName7() throws JavaModelException {
5236	this.workingCopies = new ICompilationUnit[1];
5237	this.workingCopies[0] = getWorkingCopy(
5238	"/Completion/src/test/TypeNameRequestor.java",
5239	"package test;"+
5240	"public class TypeNameRequestor {\n" +
5241	" public static final TypeNameRequestor ZZ_N\n" +
5242	"}\n");
5243
5244	CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true);
5245	String str = this.workingCopies[0].getSource();
5246	String completeBehind = "final TypeNameRequestor ZZ_N";
5247	int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
5248	this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);
5249
5250	assertResults(
5251	"ZZ_N_REQUESTOR[VARIABLE_DECLARATION]{ZZ_N_REQUESTOR, null, Ltest.TypeNameRequestor;, ZZ_N_REQUESTOR, null, " + (R_DEFAULT + R_INTERESTING + R_CASE + R_NON_RESTRICTED) + "}\n" +
5252	"ZZ_N_TYPE_NAME_REQUESTOR[VARIABLE_DECLARATION]{ZZ_N_TYPE_NAME_REQUESTOR, null, Ltest.TypeNameRequestor;, ZZ_N_TYPE_NAME_REQUESTOR, null, " + (R_DEFAULT + R_INTERESTING + R_CASE + R_NON_RESTRICTED) + "}\n" +
5253	"ZZ_NAME_REQUESTOR[VARIABLE_DECLARATION]{ZZ_NAME_REQUESTOR, null, Ltest.TypeNameRequestor;, ZZ_NAME_REQUESTOR, null, " + (R_DEFAULT + R_INTERESTING + R_CASE + R_NAME_LESS_NEW_CHARACTERS + R_NON_RESTRICTED) + "}",
5254	requestor.getResults());
5255	}
5256
5142	/**	5257	/**
5143	* Complete the type "A" from "new A".	5258	* Complete the type "A" from "new A".
5144	*/	5259	*/