Attachment #113229 for bug #38111




			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".
 */





import junit.framework.Test;

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


	super.tearDown();
}
private String toString(char[][] suggestions) {
	if(suggestions == null) {
		return ""; //$NON-NLS-1$
	}

	StringBuffer buffer = new StringBuffer();
	for (int i = 0; i < suggestions.length; i++) {
		if(i != 0) {
			buffer.append('\n');
		}
		buffer.append(suggestions[i]);
	}
	return buffer.toString();
}
public void testSuggestFieldName001() {
	String[] suggestions = NamingConventions.getVariableNames(
			NamingConventions.VK_INSTANCE_FIELD,
			NamingConventions.BK_SIMPLE_TYPE_NAME,
			"OneName", //$NON-NLS-1$
			this.project,
			0,
			new String[]{},
			true);

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

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

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

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

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

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

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

	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.getVariableNames(
			NamingConventions.VK_STATIC_FIELD,
			NamingConventions.BK_SIMPLE_TYPE_NAME,
			"OneName", //$NON-NLS-1$
			this.project,
			0,
			new String[]{},
			true);

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

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

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

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

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

	String[] suggestions = NamingConventions.getVariableNames(
			NamingConventions.VK_INSTANCE_FIELD,
			NamingConventions.BK_SIMPLE_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.getVariableNames(
			NamingConventions.VK_INSTANCE_FIELD,
			NamingConventions.BK_SIMPLE_TYPE_NAME,
			"OneName", //$NON-NLS-1$
			this.project,
			0,
			new String[]{"name"}, //$NON-NLS-1$
			true);

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

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

	String[] suggestions = NamingConventions.getVariableNames(
			NamingConventions.VK_INSTANCE_FIELD,
			NamingConventions.BK_SIMPLE_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$

	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.getVariableNames(
			NamingConventions.VK_INSTANCE_FIELD,
			NamingConventions.BK_SIMPLE_TYPE_NAME,
			"OneName", //$NON-NLS-1$
			this.project,
			1,
			new String[]{"preNamesuf"}, //$NON-NLS-1$
			true);

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

		toString(suggestions));
}
public void testSuggestFieldName011() {
	
	String[] suggestions = NamingConventions.getVariableNames(
			NamingConventions.VK_INSTANCE_FIELD,
			NamingConventions.BK_SIMPLE_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.getVariableNames(
			NamingConventions.VK_INSTANCE_FIELD,
			NamingConventions.BK_SIMPLE_TYPE_NAME,
			"FooBar", //$NON-NLS-1$
			this.project,
			0,
			new String[]{"bar"}, //$NON-NLS-1$
			true);

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

		toString(suggestions));
}
public void testSuggestFieldName013() {
	String[] suggestions = NamingConventions.getVariableNames(
			NamingConventions.VK_INSTANCE_FIELD,
			NamingConventions.BK_SIMPLE_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.getVariableNames(
			NamingConventions.VK_INSTANCE_FIELD,
			NamingConventions.BK_SIMPLE_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.getVariableNames(
			NamingConventions.VK_INSTANCE_FIELD,
			NamingConventions.BK_SIMPLE_TYPE_NAME,
			"#", //$NON-NLS-1$
			this.project,
			0,
			new String[]{},
			true);

	assumeEquals(
		"name",//$NON-NLS-1$
		toString(suggestions));
}
public void testSuggestFieldName016() {
	String[] suggestions = NamingConventions.getVariableNames(
			NamingConventions.VK_INSTANCE_FIELD,
			NamingConventions.BK_SIMPLE_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.getVariableNames(
			NamingConventions.VK_INSTANCE_FIELD,
			NamingConventions.BK_SIMPLE_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.getVariableNames(
			NamingConventions.VK_INSTANCE_FIELD,
			NamingConventions.BK_SIMPLE_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.getVariableNames(
			NamingConventions.VK_INSTANCE_FIELD,
			NamingConventions.BK_SIMPLE_TYPE_NAME,
			"MyClass", //$NON-NLS-1$
			this.project,
			0,
			new String[]{},
			true);

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

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

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

	assumeEquals(
		"TYPE\n" + //$NON-NLS-1$
		"MY_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.getVariableNames(
			NamingConventions.VK_CONSTANT_FIELD,
			NamingConventions.BK_SIMPLE_TYPE_NAME,
			"MyType", //$NON-NLS-1$
			this.project,
			0,
			new String[]{},
			true);

	assumeEquals(
		"preTYPEsuf\n" + //$NON-NLS-1$
		"preMY_TYPEsuf\n" + //$NON-NLS-1$
		"preTYPE\n" + //$NON-NLS-1$
		"preMY_TYPE\n" + //$NON-NLS-1$
		"TYPEsuf\n" + //$NON-NLS-1$
		"MY_TYPEsuf\n" + //$NON-NLS-1$
		"TYPE\n" + //$NON-NLS-1$
		"MY_TYPE", //$NON-NLS-1$
		toString(suggestions));
}
/*
 * bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=38111
 */
public void testSuggestFieldName023() {
	String[] suggestions = NamingConventions.getVariableNames(
			NamingConventions.VK_INSTANCE_FIELD,
			NamingConventions.BK_SIMPLE_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.getVariableNames(
			NamingConventions.VK_INSTANCE_FIELD,
			NamingConventions.BK_SIMPLE_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));
}
public void testRemovePrefixAndSuffixForFieldName001() {
	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 name = NamingConventions.removeVariablePrefixAndSuffix(NamingConventions.VK_INSTANCE_FIELD, this.project, "preOneNamesuf"); //$NON-NLS-1$
	assumeEquals(
		"oneName", //$NON-NLS-1$
		name);
}
public void testRemovePrefixAndSuffixForFieldName002() {
	Hashtable options = JavaCore.getOptions();

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

	String name = NamingConventions.removeVariablePrefixAndSuffix(NamingConventions.VK_STATIC_FIELD, this.project, "preOneNamesuf"); //$NON-NLS-1$
		this.project,
		"preOneNamesuf".toCharArray(), //$NON-NLS-1$
		Flags.AccStatic);

	assumeEquals(
		"preOneNamesuf", //$NON-NLS-1$
		name);
}
public void testRemovePrefixAndSuffixForFieldName003() {
	Hashtable options = JavaCore.getOptions();

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

	String name = NamingConventions.removeVariablePrefixAndSuffix(NamingConventions.VK_INSTANCE_FIELD, this.project, "preOneNamesuf"); //$NON-NLS-1$
		this.project,
		"preOneNamesuf".toCharArray(), //$NON-NLS-1$
		0);

	assumeEquals(
		"oneName", //$NON-NLS-1$
		name);
}
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=114086
public void testRemovePrefixAndSuffixForFieldName004() {

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

	String name = NamingConventions.removeVariablePrefixAndSuffix(NamingConventions.VK_INSTANCE_FIELD, this.project, "preOneName"); //$NON-NLS-1$
		this.project,
		"preOneName".toCharArray(), //$NON-NLS-1$
		0);

	assumeEquals(
		"oneName", //$NON-NLS-1$
		name);
}
public void testRemovePrefixAndSuffixForLocalName001() {
	Hashtable options = JavaCore.getOptions();

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

	String name = NamingConventions.removeVariablePrefixAndSuffix(NamingConventions.VK_LOCAL, this.project, "preOneNamesuf"); //$NON-NLS-1$
		this.project,
		"preOneNamesuf".toCharArray() //$NON-NLS-1$
		);

	assumeEquals(
		"oneName", //$NON-NLS-1$
		name);
}
public void testSuggestGetterName001() {
	char[] suggestion = NamingConventions.suggestGetterName(

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

		String[] suggestions = NamingConventions.getVariableNames(
			NamingConventions.VK_LOCAL,
			NamingConventions.BK_SIMPLE_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.getVariableNames(
			NamingConventions.VK_LOCAL,
			NamingConventions.BK_SIMPLE_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$





import java.util.Map;

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

				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){
		char[][] names = new char[5][];
		int nameCount = 0;
		boolean previousIsUpperCase = false;

					if(nameCount == names.length) {
						System.arraycopy(names, 0, names = new char[nameCount * 2][], 0, nameCount);
					}
					if (isConstantField) {
						name = convertToConstantName(name);
					} else {
						name[0] = ScannerHelper.toLowerCase(name[0]);
					}
					names[nameCount++] = name;
				}
			}

			previousIsLetter = isLetter;
		}
		if(nameCount == 0){
			if (isConstantField) {
				names[nameCount++] = convertToConstantName(sourceName);
			} else {
				names[nameCount++] = CharOperation.toLowerCase(sourceName);
			}
		}
		System.arraycopy(names, 0, names = new char[nameCount][], 0, nameCount);
		return names;
	}
	
	private static char[] convertToConstantName(char[] name) {
		int length = name.length;
		char[] constantName = new char[length * 2];
		int constantNamePtr = 0;
		boolean wasUnderscore = true;
		for (int i = 0; i < length; i++) {
			if (ScannerHelper.isUpperCase(name[i])) {
				if (!wasUnderscore) constantName[constantNamePtr++] = '_';
				constantName[constantNamePtr++] = name[i];
			} else {
				constantName[constantNamePtr++] = ScannerHelper.toUpperCase(name[i]);
				wasUnderscore = name[i] == '_';
			}
		}
		System.arraycopy(constantName, 0, constantName = new char[constantNamePtr], 0, constantNamePtr);
		return constantName;
	}

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

					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 = javaProject.getOptions(true);
		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 1799-1804 Link Here

(-)model/org/eclipse/jdt/core/JavaCore.java (+26 lines)
1799	*/	1799	*/
1800	public static final String CODEASSIST_STATIC_FIELD_PREFIXES = PLUGIN_ID + ".codeComplete.staticFieldPrefixes"; //$NON-NLS-1$	1800	public static final String CODEASSIST_STATIC_FIELD_PREFIXES = PLUGIN_ID + ".codeComplete.staticFieldPrefixes"; //$NON-NLS-1$
1801	/**	1801	/**
		1802	* Code assist option ID: Define the Prefixes for Static Final Field Name.
		1803	* <p>When the prefixes is non empty, completion for static final field name will begin with
		1804	* one of the proposed prefixes.
		1805	* <dl>
		1806	* <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.codeComplete.staticFinalFieldPrefixes"</code></dd>
		1807	* <dt>Possible values:</dt><dd><code>{ "<prefix>[,<prefix>]*" }</code> where <code><prefix></code> is a String without any wild-card</dd>
		1808	* <dt>Default:</dt><dd><code>""</code></dd>
		1809	* </dl>
		1810	* @since 3.5
		1811	* @category CodeAssistOptionID
		1812	*/
		1813	public static final String CODEASSIST_STATIC_FINAL_FIELD_PREFIXES = PLUGIN_ID + ".codeComplete.staticFinalFieldPrefixes"; //$NON-NLS-1$
		1814	/**
1802	* Code assist option ID: Define the Prefixes for Local Variable Name.	1815	* Code assist option ID: Define the Prefixes for Local Variable Name.
1803	* <p>When the prefixes is non empty, completion for local variable name will begin with	1816	* <p>When the prefixes is non empty, completion for local variable name will begin with
1804	* one of the proposed prefixes.	1817	* one of the proposed prefixes.
Lines 1851-1856 Link Here
1851	*/	1864	*/
1852	public static final String CODEASSIST_STATIC_FIELD_SUFFIXES = PLUGIN_ID + ".codeComplete.staticFieldSuffixes"; //$NON-NLS-1$	1865	public static final String CODEASSIST_STATIC_FIELD_SUFFIXES = PLUGIN_ID + ".codeComplete.staticFieldSuffixes"; //$NON-NLS-1$
1853	/**	1866	/**
		1867	* Code assist option ID: Define the Suffixes for Static Final Field Name.
		1868	* <p>When the suffixes is non empty, completion for static final field name will end with
		1869	* one of the proposed suffixes.
		1870	* <dl>
		1871	* <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.codeComplete.staticFinalFieldSuffixes"</code></dd>
		1872	* <dt>Possible values:</dt><dd><code>{ "<suffix>[,<suffix>]*" }</code>< where <code><suffix></code> is a String without any wild-card</dd>
		1873	* <dt>Default:</dt><dd><code>""</code></dd>
		1874	* </dl>
		1875	* @since 3.5
		1876	* @category CodeAssistOptionID
		1877	*/
		1878	public static final String CODEASSIST_STATIC_FINAL_FIELD_SUFFIXES = PLUGIN_ID + ".codeComplete.staticFinalFieldSuffixes"; //$NON-NLS-1$
		1879	/**
1854	* Code assist option ID: Define the Suffixes for Local Variable Name.	1880	* Code assist option ID: Define the Suffixes for Local Variable Name.
1855	* <p>When the suffixes is non empty, completion for local variable name will end with	1881	* <p>When the suffixes is non empty, completion for local variable name will end with
1856	* one of the proposed suffixes.	1882	* one of the proposed suffixes.




 * @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
	}

	public static final int VK_STATIC_FIELD = InternalNamingConventions.VK_STATIC_FIELD;
	public static final int VK_INSTANCE_FIELD = InternalNamingConventions.VK_INSTANCE_FIELD;
	public static final int VK_CONSTANT_FIELD = InternalNamingConventions.VK_CONSTANT_FIELD;
	public static final int VK_PARAMETER = InternalNamingConventions.VK_PARAMETER;
	public static final int VK_LOCAL = InternalNamingConventions.VK_LOCAL;
	
	public static final int BK_SIMPLE_NAME = InternalNamingConventions.BK_SIMPLE_NAME;
	public static final int BK_SIMPLE_TYPE_NAME = InternalNamingConventions.BK_SIMPLE_TYPE_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;
						}
					}
				}
			}
		}

	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;
	}

	/**
	 * Suggest names for a variable. The name is computed from a base name
	 * and possible prefixes or suffixes are added.
	 * <p>
	 * The variable can be a local variable, a parameter, an instance field, a static field or a constant field.
	 * Each type of variable is specified by a variable kind:
	 * <ul>
	 * <li>{@link #VK_PARAMETER} for parameter</li>
	 * <li>{@link #VK_LOCAL} for local variable</li>
	 * <li>{@link #VK_INSTANCE_FIELD} for instance field</li>
	 * <li>{@link #VK_STATIC_FIELD} for static field</li>
	 * <li>{@link #VK_CONSTANT_FIELD} for constant field</li>
	 * </ul>
	 * Some other kinds could be added in the future.
	 * </p>
	 * <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.
	 * The different kinds of base name are:
	 * <ul>
	 * <li>{@link #BK_SIMPLE_NAME}: If the prefix is <code>pre</code> and the suffix is <code>suf</code> then the proposed name is
	 * <code>preSimpleNamesuf</code>.</li>
	 * <li>{@link #BK_SIMPLE_TYPE_NAME}: If the type is <code>TypeName</code>, the prefix is <code>pre</code> and the suffix is <code>suf</code>
	 * then the proposed names are <code>preTypeNamesuf</code> and <code>preNamesuf</code>.</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>
	 *
	 * @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_SIMPLE_NAME} or {@link #BK_SIMPLE_TYPE_NAME}
	 * @param baseName name used to compute the suggested names.
	 * @param javaProject project which contains the variable.
	 * @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()
	 */
	public static String[] getVariableNames(
			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());
	}

	/**

	 * @return char[] the name without prefix and suffix.
	 * @see JavaCore#setOptions(java.util.Hashtable)
	 * @see JavaCore#getDefaultOptions()
	 * 
	 * @deprecated Use {@link #removeVariablePrefixAndSuffix(int, IJavaProject, String)} instead with {@link #VK_PARAMETER} as variable kind.
	 */
	public static char[] removePrefixAndSuffixForArgumentName(IJavaProject javaProject, char[] argumentName) {
		return 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 #removeVariablePrefixAndSuffix(int, IJavaProject, String)} 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 #removeVariablePrefixAndSuffix(int, IJavaProject, String)} 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 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 #removeVariablePrefixAndSuffix(int, IJavaProject, String)} 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 #removeVariablePrefixAndSuffix(int, IJavaProject, String)} instead with {@link #VK_LOCAL} as variable kind.
	 */
	public static char[] removePrefixAndSuffixForLocalVariableName(IJavaProject javaProject, char[] localName) {
		return 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 #removeVariablePrefixAndSuffix(int, IJavaProject, String)} instead with {@link #VK_LOCAL} as variable kind.
	 */
	public static String removePrefixAndSuffixForLocalVariableName(IJavaProject javaProject, String localName) {
		return String.valueOf(removePrefixAndSuffixForLocalVariableName(javaProject, localName.toCharArray()));
	}

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

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

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

	private static char[] removeVariablePrefixAndSuffix(
			int variableKind,
			IJavaProject javaProject,
			char[] name) {
		AssistOptions assistOptions = new AssistOptions(javaProject.getOptions(true));
		
		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 removeVariablePrefixAndSuffix(name,	prefixes, suffixes);
	}

	/**
	 * Remove prefix and suffix from a variable name.
	 * 
	 * <p>
	 * The variable can be a local variable, a parameter, an instance field, a static field or a constant field.
	 * Each type of variable is specified by a variable kind:
	 * <ul>
	 * <li>{@link #VK_PARAMETER}</li>
	 * <li>{@link #VK_LOCAL}</li>
	 * <li>{@link #VK_INSTANCE_FIELD}</li>
	 * <li>{@link #VK_STATIC_FIELD}</li>
	 * <li>{@link #VK_CONSTANT_FIELD}</li>
	 * </ul>
	 * </p>
	 * <p>
	 * If variable name prefix is <code>pre</code> and variable name suffix is <code>suf</code>
	 * then for a variable named <code>preVariablesuf</code> the result of this method is <code>variable</code>.
	 * If there is no prefix or suffix defined in JavaCore options the result is the unchanged
	 * name <code>preVariablesuf</code>.
	 * </p>
	 * <p>
	 * For each variable kind this method 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>
	 *
	 * @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 javaProject project which contains the variable.
	 * @param name variable name.
	 * @return String the name without prefix and suffix.
	 * @see JavaCore#setOptions(java.util.Hashtable)
	 * @see JavaCore#getDefaultOptions()
	 * 
	 * @since 3.5
	 */
	public static String removeVariablePrefixAndSuffix(
			int variableKind,
			IJavaProject javaProject,
			String name) {
		return String.valueOf(removeVariablePrefixAndSuffix(variableKind, javaProject, name.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
	 * and possible prefixes or suffixes are added.

	 * @return char[][] an array of names.
	 * @see JavaCore#setOptions(java.util.Hashtable)
	 * @see JavaCore#getDefaultOptions()
	 * 
	 * @deprecated Use {@link #getVariableNames(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_SIMPLE_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 #getVariableNames(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 #getVariableNames(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_SIMPLE_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 #getVariableNames(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 #getVariableNames(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_SIMPLE_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 #getVariableNames(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)));
	}
	
	private NamingConventions() {
		// Not instantiable
		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 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;
	}
}




}

/**
 * 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 = 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);
			}
		} else if (astNode instanceof CompletionOnFieldName) {
			if (!this.requestor.isIgnored(CompletionProposal.VARIABLE_DECLARATION)) {

				}

				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);
			}
		} else if (astNode instanceof CompletionOnLocalName || astNode instanceof CompletionOnArgumentName) {
			if (!this.requestor.isIgnored(CompletionProposal.VARIABLE_DECLARATION)) {

				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);
			}
		} else if (astNode instanceof CompletionOnKeyword) {
			if (!this.requestor.isIgnored(CompletionProposal.KEYWORD)) {

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

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

			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;
		}
	}
	
	private void findVariableNameForCollection(

			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);
					}
				}
			}

Return to bug 38111

Lines 5079-5084 Link Here

(-)src/org/eclipse/jdt/core/tests/model/CompletionTests.java (+115 lines)
5079	requestor.getResults());	5079	requestor.getResults());
5080	}	5080	}
5081		5081
		5082	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=38111
		5083	public void testCompletionFieldName3() throws JavaModelException {
		5084	this.workingCopies = new ICompilationUnit[1];
		5085	this.workingCopies[0] = getWorkingCopy(
		5086	"/Completion/src/test/TypeNameRequestor.java",
		5087	"package test;"+
		5088	"public class TypeNameRequestor {\n" +
		5089	" public static final TypeNameRequestor \n" +
		5090	"}\n");
		5091
		5092	CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true);
		5093	String str = this.workingCopies[0].getSource();
		5094	String completeBehind = "final TypeNameRequestor ";
		5095	int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
		5096	this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);
		5097
		5098	assertResults(
		5099	"NAME_REQUESTOR[VARIABLE_DECLARATION]{NAME_REQUESTOR, null, Ltest.TypeNameRequestor;, NAME_REQUESTOR, null, " + (R_DEFAULT + R_INTERESTING + R_CASE+ R_NON_RESTRICTED) + "}\n" +
		5100	"REQUESTOR[VARIABLE_DECLARATION]{REQUESTOR, null, Ltest.TypeNameRequestor;, REQUESTOR, null, " + (R_DEFAULT + R_INTERESTING + R_CASE+ R_NON_RESTRICTED) + "}\n" +
		5101	"TYPE_NAME_REQUESTOR[VARIABLE_DECLARATION]{TYPE_NAME_REQUESTOR, null, Ltest.TypeNameRequestor;, TYPE_NAME_REQUESTOR, null, " + (R_DEFAULT + R_INTERESTING + R_CASE+ R_NON_RESTRICTED) + "}",
		5102	requestor.getResults());
		5103	}
		5104
		5105	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=38111
		5106	public void testCompletionFieldName4() throws JavaModelException {
		5107	this.workingCopies = new ICompilationUnit[1];
		5108	this.workingCopies[0] = getWorkingCopy(
		5109	"/Completion/src/test/TypeNameRequestor.java",
		5110	"package test;"+
		5111	"public class TypeNameRequestor {\n" +
		5112	" public static final TypeNameRequestor nam\n" +
		5113	"}\n");
		5114
		5115	CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true);
		5116	String str = this.workingCopies[0].getSource();
		5117	String completeBehind = "final TypeNameRequestor nam";
		5118	int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
		5119	this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);
		5120
		5121	assertResults(
		5122	"NAM_REQUESTOR[VARIABLE_DECLARATION]{NAM_REQUESTOR, null, Ltest.TypeNameRequestor;, NAM_REQUESTOR, null, " + (R_DEFAULT + R_INTERESTING + R_NON_RESTRICTED) + "}\n" +
		5123	"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" +
		5124	"NAME_REQUESTOR[VARIABLE_DECLARATION]{NAME_REQUESTOR, null, Ltest.TypeNameRequestor;, NAME_REQUESTOR, null, " + (R_DEFAULT + R_INTERESTING + R_NAME_LESS_NEW_CHARACTERS+ R_NON_RESTRICTED) + "}",
		5125	requestor.getResults());
		5126	}
		5127
		5128	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=38111
		5129	public void testCompletionFieldName5() throws JavaModelException {
		5130	this.workingCopies = new ICompilationUnit[1];
		5131	this.workingCopies[0] = getWorkingCopy(
		5132	"/Completion/src/test/TypeNameRequestor.java",
		5133	"package test;"+
		5134	"public class TypeNameRequestor {\n" +
		5135	" public static final TypeNameRequestor ZZ\n" +
		5136	"}\n");
		5137
		5138	CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true);
		5139	String str = this.workingCopies[0].getSource();
		5140	String completeBehind = "final TypeNameRequestor ZZ";
		5141	int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
		5142	this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);
		5143
		5144	assertResults(
		5145	"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" +
5146	"ZZ_REQUESTOR[VARIABLE_DECLARATION]{ZZ_REQUESTOR, null, Ltest.TypeNameRequestor;, ZZ_REQUESTOR, null, " + (R_DEFAULT + R_INTERESTING + R_CASE + R_NON_RESTRICTED) + "}\n" +
5147	"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) + "}",
5148	requestor.getResults());
5149	}
5150
5151	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=38111
5152	public void testCompletionFieldName6() throws JavaModelException {
5153	this.workingCopies = new ICompilationUnit[1];
5154	this.workingCopies[0] = getWorkingCopy(
5155	"/Completion/src/test/TypeNameRequestor.java",
5156	"package test;"+
5157	"public class TypeNameRequestor {\n" +
5158	" public static final TypeNameRequestor ZZN\n" +
5159	"}\n");
5160
5161	CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true);
5162	String str = this.workingCopies[0].getSource();
5163	String completeBehind = "final TypeNameRequestor ZZN";
5164	int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
5165	this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);
5166
5167	assertResults(
5168	"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" +
5169	"ZZN_REQUESTOR[VARIABLE_DECLARATION]{ZZN_REQUESTOR, null, Ltest.TypeNameRequestor;, ZZN_REQUESTOR, null, " + (R_DEFAULT + R_INTERESTING + R_CASE + R_NON_RESTRICTED) + "}\n" +
5170	"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) + "}",
5171	requestor.getResults());
5172	}
5173
5174	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=38111
5175	public void testCompletionFieldName7() throws JavaModelException {
5176	this.workingCopies = new ICompilationUnit[1];
5177	this.workingCopies[0] = getWorkingCopy(
5178	"/Completion/src/test/TypeNameRequestor.java",
5179	"package test;"+
5180	"public class TypeNameRequestor {\n" +
5181	" public static final TypeNameRequestor ZZ_N\n" +
5182	"}\n");
5183
5184	CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true);
5185	String str = this.workingCopies[0].getSource();
5186	String completeBehind = "final TypeNameRequestor ZZ_N";
5187	int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
5188	this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);
5189
5190	assertResults(
5191	"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" +
5192	"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" +
5193	"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) + "}",
5194	requestor.getResults());
5195	}
5196
5082	/**	5197	/**
5083	* Complete the type "A" from "new A".	5198	* Complete the type "A" from "new A".
5084	*/	5199	*/

Lines 1979-1988 Link Here

(-)model/org/eclipse/jdt/internal/core/JavaModelManager.java (+2 lines)
1979	defaultOptionsMap.put(JavaCore.CODEASSIST_IMPLICIT_QUALIFICATION, JavaCore.DISABLED);	1979	defaultOptionsMap.put(JavaCore.CODEASSIST_IMPLICIT_QUALIFICATION, JavaCore.DISABLED);
1980	defaultOptionsMap.put(JavaCore.CODEASSIST_FIELD_PREFIXES, ""); //$NON-NLS-1$	1980	defaultOptionsMap.put(JavaCore.CODEASSIST_FIELD_PREFIXES, ""); //$NON-NLS-1$
1981	defaultOptionsMap.put(JavaCore.CODEASSIST_STATIC_FIELD_PREFIXES, ""); //$NON-NLS-1$	1981	defaultOptionsMap.put(JavaCore.CODEASSIST_STATIC_FIELD_PREFIXES, ""); //$NON-NLS-1$
		1982	defaultOptionsMap.put(JavaCore.CODEASSIST_STATIC_FINAL_FIELD_PREFIXES, ""); //$NON-NLS-1$
1982	defaultOptionsMap.put(JavaCore.CODEASSIST_LOCAL_PREFIXES, ""); //$NON-NLS-1$	1983	defaultOptionsMap.put(JavaCore.CODEASSIST_LOCAL_PREFIXES, ""); //$NON-NLS-1$
1983	defaultOptionsMap.put(JavaCore.CODEASSIST_ARGUMENT_PREFIXES, ""); //$NON-NLS-1$	1984	defaultOptionsMap.put(JavaCore.CODEASSIST_ARGUMENT_PREFIXES, ""); //$NON-NLS-1$
1984	defaultOptionsMap.put(JavaCore.CODEASSIST_FIELD_SUFFIXES, ""); //$NON-NLS-1$	1985	defaultOptionsMap.put(JavaCore.CODEASSIST_FIELD_SUFFIXES, ""); //$NON-NLS-1$
1985	defaultOptionsMap.put(JavaCore.CODEASSIST_STATIC_FIELD_SUFFIXES, ""); //$NON-NLS-1$	1986	defaultOptionsMap.put(JavaCore.CODEASSIST_STATIC_FIELD_SUFFIXES, ""); //$NON-NLS-1$
		1987	defaultOptionsMap.put(JavaCore.CODEASSIST_STATIC_FINAL_FIELD_SUFFIXES, ""); //$NON-NLS-1$
1986	defaultOptionsMap.put(JavaCore.CODEASSIST_LOCAL_SUFFIXES, ""); //$NON-NLS-1$	1988	defaultOptionsMap.put(JavaCore.CODEASSIST_LOCAL_SUFFIXES, ""); //$NON-NLS-1$
1987	defaultOptionsMap.put(JavaCore.CODEASSIST_ARGUMENT_SUFFIXES, ""); //$NON-NLS-1$	1989	defaultOptionsMap.put(JavaCore.CODEASSIST_ARGUMENT_SUFFIXES, ""); //$NON-NLS-1$
1988	defaultOptionsMap.put(JavaCore.CODEASSIST_FORBIDDEN_REFERENCE_CHECK, JavaCore.ENABLED);	1990	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 262-271 Link Here

(-)codeassist/org/eclipse/jdt/internal/codeassist/CompletionEngine.java (-59 / +39 lines)
262	private final static int SUPERTYPE = 1;	262	private final static int SUPERTYPE = 1;
263	private final static int SUBTYPE = 2;	263	private final static int SUBTYPE = 2;
264		264
265	private final static int FIELD = 0;
266	private final static int LOCAL = 1;
267	private final static int ARGUMENT = 2;
268
269	int expectedTypesPtr = -1;	265	int expectedTypesPtr = -1;
270	TypeBinding[] expectedTypes = new TypeBinding[1];	266	TypeBinding[] expectedTypes = new TypeBinding[1];
271	int expectedTypesFilter;	267	int expectedTypesFilter;
Lines 1585-1592 Link Here
1585	}	1581	}
1586		1582
1587	this.completionToken = method.selector;	1583	this.completionToken = method.selector;
1588		1584
1589	findVariableNames(this.completionToken, method.returnType, excludeNames, null, FIELD, method.modifiers);	1585	int kind =
		1586	(method.modifiers & ClassFileConstants.AccStatic) == 0 ?
		1587	InternalNamingConventions.VK_INSTANCE_FIELD :
		1588	(method.modifiers & ClassFileConstants.AccFinal) == 0 ?
		1589	InternalNamingConventions.VK_STATIC_FIELD :
		1590	InternalNamingConventions.VK_CONSTANT_FIELD;
		1591
		1592	findVariableNames(this.completionToken, method.returnType, excludeNames, null, kind);
1590	}	1593	}
1591	} else if (astNode instanceof CompletionOnFieldName) {	1594	} else if (astNode instanceof CompletionOnFieldName) {
1592	if (!this.requestor.isIgnored(CompletionProposal.VARIABLE_DECLARATION)) {	1595	if (!this.requestor.isIgnored(CompletionProposal.VARIABLE_DECLARATION)) {
Lines 1599-1606 Link Here
1599	}	1602	}
1600		1603
1601	this.completionToken = field.realName;	1604	this.completionToken = field.realName;
1602		1605
1603	findVariableNames(field.realName, field.type, excludeNames, null, FIELD, field.modifiers);	1606	int kind =
		1607	(field.modifiers & ClassFileConstants.AccStatic) == 0 ?
		1608	InternalNamingConventions.VK_INSTANCE_FIELD :
		1609	(field.modifiers & ClassFileConstants.AccFinal) == 0 ?
		1610	InternalNamingConventions.VK_STATIC_FIELD :
		1611	InternalNamingConventions.VK_CONSTANT_FIELD;
		1612
		1613	findVariableNames(field.realName, field.type, excludeNames, null, kind);
1604	}	1614	}
1605	} else if (astNode instanceof CompletionOnLocalName \|\| astNode instanceof CompletionOnArgumentName) {	1615	} else if (astNode instanceof CompletionOnLocalName \|\| astNode instanceof CompletionOnArgumentName) {
1606	if (!this.requestor.isIgnored(CompletionProposal.VARIABLE_DECLARATION)) {	1616	if (!this.requestor.isIgnored(CompletionProposal.VARIABLE_DECLARATION)) {
Lines 1609-1619 Link Here
1609	int kind;	1619	int kind;
1610	if (variable instanceof CompletionOnLocalName){	1620	if (variable instanceof CompletionOnLocalName){
1611	this.completionToken = ((CompletionOnLocalName) variable).realName;	1621	this.completionToken = ((CompletionOnLocalName) variable).realName;
1612	kind = LOCAL;	1622	kind = InternalNamingConventions.VK_LOCAL;
1613	} else {	1623	} else {
1614	CompletionOnArgumentName arg = (CompletionOnArgumentName) variable;	1624	CompletionOnArgumentName arg = (CompletionOnArgumentName) variable;
1615	this.completionToken = arg.realName;	1625	this.completionToken = arg.realName;
1616	kind = arg.isCatchArgument ? LOCAL : ARGUMENT;	1626	kind = arg.isCatchArgument ? InternalNamingConventions.VK_LOCAL : InternalNamingConventions.VK_PARAMETER;
1617	}	1627	}
1618		1628
1619	char[][] alreadyDefinedName = computeAlreadyDefinedName((BlockScope)scope, variable);	1629	char[][] alreadyDefinedName = computeAlreadyDefinedName((BlockScope)scope, variable);
Lines 1631-1637 Link Here
1631		1641
1632	System.arraycopy(discouragedNames, 0, discouragedNames = new char[localCount][], 0, localCount);	1642	System.arraycopy(discouragedNames, 0, discouragedNames = new char[localCount][], 0, localCount);
1633		1643
1634	findVariableNames(this.completionToken, variable.type, discouragedNames, forbiddenNames, kind, variable.modifiers);	1644	findVariableNames(this.completionToken, variable.type, discouragedNames, forbiddenNames, kind);
1635	}	1645	}
1636	} else if (astNode instanceof CompletionOnKeyword) {	1646	} else if (astNode instanceof CompletionOnKeyword) {
1637	if (!this.requestor.isIgnored(CompletionProposal.KEYWORD)) {	1647	if (!this.requestor.isIgnored(CompletionProposal.KEYWORD)) {
Lines 8898-8905 Link Here
8898	char[][] discouragedNames,	8908	char[][] discouragedNames,
8899	final char[][] forbiddenNames,	8909	final char[][] forbiddenNames,
8900	int dim,	8910	int dim,
8901	int kind,	8911	int kind){
8902	int modifiers){
8903	findVariableName(	8912	findVariableName(
8904	token,	8913	token,
8905	qualifiedPackageName,	8914	qualifiedPackageName,
Lines 8910-8917 Link Here
8910	forbiddenNames,	8919	forbiddenNames,
8911	false,	8920	false,
8912	dim,	8921	dim,
8913	kind,	8922	kind);
8914	modifiers);
8915	}	8923	}
8916	private void findVariableName(	8924	private void findVariableName(
8917	char[] token,	8925	char[] token,
Lines 8923-8930 Link Here
8923	final char[][] forbiddenNames,	8931	final char[][] forbiddenNames,
8924	boolean forCollection,	8932	boolean forCollection,
8925	int dim,	8933	int dim,
8926	int kind,	8934	int kind){
8927	int modifiers){
8928		8935
8929	if(sourceName == null \|\| sourceName.length == 0)	8936	if(sourceName == null \|\| sourceName.length == 0)
8930	return;	8937	return;
Lines 9004-9042 Link Here
9004	}	9011	}
9005	};	9012	};
9006		9013
9007	switch (kind) {	9014	InternalNamingConventions.suggestVariableNames(
9008	case FIELD :	9015	kind,
9009	InternalNamingConventions.suggestFieldNames(	9016	InternalNamingConventions.BK_SIMPLE_TYPE_NAME,
9010	this.javaProject,	9017	qualifiedSourceName,
9011	qualifiedPackageName,	9018	this.javaProject,
9012	qualifiedSourceName,	9019	dim,
9013	dim,	9020	token,
9014	modifiers,	9021	discouragedNames,
9015	token,	9022	true,
9016	discouragedNames,	9023	namingRequestor);
9017	namingRequestor);
9018	break;
9019	case LOCAL :
9020	InternalNamingConventions.suggestLocalVariableNames(
9021	this.javaProject,
9022	qualifiedPackageName,
9023	qualifiedSourceName,
9024	dim,
9025	token,
9026	discouragedNames,
9027	namingRequestor);
9028	break;
9029	case ARGUMENT :
9030	InternalNamingConventions.suggestArgumentNames(
9031	this.javaProject,
9032	qualifiedPackageName,
9033	qualifiedSourceName,
9034	dim,
9035	token,
9036	discouragedNames,
9037	namingRequestor);
9038	break;
9039	}
9040	}	9024	}
9041		9025
9042	private void findVariableNameForCollection(	9026	private void findVariableNameForCollection(
Lines 9047-9054 Link Here
9047	final TypeBinding typeBinding,	9031	final TypeBinding typeBinding,
9048	char[][] discouragedNames,	9032	char[][] discouragedNames,
9049	final char[][] forbiddenNames,	9033	final char[][] forbiddenNames,
9050	int kind,	9034	int kind){
9051	int modifiers){
9052		9035
9053	findVariableName(	9036	findVariableName(
9054	token,	9037	token,
Lines 9060-9070 Link Here
9060	forbiddenNames,	9043	forbiddenNames,
9061	false,	9044	false,
9062	1,	9045	1,
9063	kind,	9046	kind);
9064	modifiers);
9065	}	9047	}
9066		9048
9067	private void findVariableNames(char[] name, TypeReference type , char[][] discouragedNames, char[][] forbiddenNames, int kind, int modifiers){	9049	private void findVariableNames(char[] name, TypeReference type , char[][] discouragedNames, char[][] forbiddenNames, int kind){
9068	if(type != null &&	9050	if(type != null &&
9069	type.resolvedType != null) {	9051	type.resolvedType != null) {
9070	TypeBinding tb = type.resolvedType;	9052	TypeBinding tb = type.resolvedType;
Lines 9080-9087 Link Here
9080	discouragedNames,	9062	discouragedNames,
9081	forbiddenNames,	9063	forbiddenNames,
9082	type.dimensions(),	9064	type.dimensions(),
9083	kind,	9065	kind);
9084	modifiers);
9085		9066
9086	if (tb.isParameterizedType() &&	9067	if (tb.isParameterizedType() &&
9087	tb.findSuperTypeOriginatingFrom(TypeIds.T_JavaUtilCollection, false) != null) {	9068	tb.findSuperTypeOriginatingFrom(TypeIds.T_JavaUtilCollection, false) != null) {
Lines 9097-9104 Link Here
9097	tb,	9078	tb,
9098	discouragedNames,	9079	discouragedNames,
9099	forbiddenNames,	9080	forbiddenNames,
9100	kind,	9081	kind);
9101	modifiers);
9102	}	9082	}
9103	}	9083	}
9104	}	9084	}

Lines 12-18 Link Here

(-)model/org/eclipse/jdt/internal/core/InternalNamingConventions.java (-226 / +307 lines)
12		12
13	import java.util.Map;	13	import java.util.Map;
14		14
15	import org.eclipse.jdt.core.Flags;
16	import org.eclipse.jdt.core.IJavaProject;	15	import org.eclipse.jdt.core.IJavaProject;
17	import org.eclipse.jdt.core.compiler.CharOperation;	16	import org.eclipse.jdt.core.compiler.CharOperation;
18	import org.eclipse.jdt.core.compiler.InvalidInputException;	17	import org.eclipse.jdt.core.compiler.InvalidInputException;
Lines 37-263 Link Here
37	null/taskPriorities/,	36	null/taskPriorities/,
38	true/taskCaseSensitive/);	37	true/taskCaseSensitive/);
39	}	38	}
40	public static void suggestArgumentNames(IJavaProject javaProject, char[] packageName, char[] qualifiedTypeName, int dim, char[] internalPrefix, char[][] excludedNames, INamingRequestor requestor) {
41	Map options = javaProject.getOptions(true);
42	CompilerOptions compilerOptions = new CompilerOptions(options);
43	AssistOptions assistOptions = new AssistOptions(options);
44
45	suggestNames(
46	packageName,
47	qualifiedTypeName,
48	dim,
49	internalPrefix,
50	assistOptions.argumentPrefixes,
51	assistOptions.argumentSuffixes,
52	excludedNames,
53	getNameScanner(compilerOptions),
54	requestor);
55	}
56	public static void suggestFieldNames(IJavaProject javaProject, char[] packageName, char[] qualifiedTypeName, int dim, int modifiers, char[] internalPrefix, char[][] excludedNames, INamingRequestor requestor) {
57	boolean isStatic = Flags.isStatic(modifiers);
58
59	Map options = javaProject.getOptions(true);
60	CompilerOptions compilerOptions = new CompilerOptions(options);
61	AssistOptions assistOptions = new AssistOptions(options);
62
63	suggestNames(
64	packageName,
65	qualifiedTypeName,
66	dim,
67	internalPrefix,
68	isStatic ? assistOptions.staticFieldPrefixes : assistOptions.fieldPrefixes,
69	isStatic ? assistOptions.staticFieldSuffixes : assistOptions.fieldSuffixes,
70	excludedNames,
71	getNameScanner(compilerOptions),
72	requestor);
73	}
74	public static void suggestLocalVariableNames(IJavaProject javaProject, char[] packageName, char[] qualifiedTypeName, int dim, char[] internalPrefix, char[][] excludedNames, INamingRequestor requestor) {
75	Map options = javaProject.getOptions(true);
76	CompilerOptions compilerOptions = new CompilerOptions(options);
77	AssistOptions assistOptions = new AssistOptions(options);
78
79	suggestNames(
80	packageName,
81	qualifiedTypeName,
82	dim,
83	internalPrefix,
84	assistOptions.localPrefixes,
85	assistOptions.localSuffixes,
86	excludedNames,
87	getNameScanner(compilerOptions),
88	requestor);
89	}
90
91	private static void suggestNames(
92	char[] packageName,
93	char[] qualifiedTypeName,
94	int dim,
95	char[] internalPrefix,
96	char[][] prefixes,
97	char[][] suffixes,
98	char[][] excludedNames,
99	Scanner nameScanner,
100	INamingRequestor requestor){
101
102	if(qualifiedTypeName == null \|\| qualifiedTypeName.length == 0)
103	return;
104
105	if(internalPrefix == null) {
106	internalPrefix = CharOperation.NO_CHAR;
107	} else {
108	internalPrefix = removePrefix(internalPrefix, prefixes);
109	}
110
111	char[] typeName = CharOperation.lastSegment(qualifiedTypeName, '.');
112
113	if(prefixes == null \|\| prefixes.length == 0) {
114	prefixes = new char[1][0];
115	} else {
116	int length = prefixes.length;
117	System.arraycopy(prefixes, 0, prefixes = new char[length+1][], 0, length);
118	prefixes[length] = CharOperation.NO_CHAR;
119	}
120
121	if(suffixes == null \|\| suffixes.length == 0) {
122	suffixes = new char[1][0];
123	} else {
124	int length = suffixes.length;
125	System.arraycopy(suffixes, 0, suffixes = new char[length+1][], 0, length);
126	suffixes[length] = CharOperation.NO_CHAR;
127	}
128
129	char[][] tempNames = null;
130
131	// compute variable name for base type
132	try{
133	nameScanner.setSource(typeName);
134	switch (nameScanner.getNextToken()) {
135	case TerminalTokens.TokenNameint :
136	case TerminalTokens.TokenNamebyte :
137	case TerminalTokens.TokenNameshort :
138	case TerminalTokens.TokenNamechar :
139	case TerminalTokens.TokenNamelong :
140	case TerminalTokens.TokenNamefloat :
141	case TerminalTokens.TokenNamedouble :
142	case TerminalTokens.TokenNameboolean :
143
144	if (internalPrefix != null && internalPrefix.length > 0) return;
145
146	char[] name = computeBaseTypeNames(typeName[0], excludedNames);
147	if(name != null) {
148	tempNames = new char[][]{name};
149	}
150	break;
151	}
152	} catch(InvalidInputException e){
153	// ignore
154	}
155
156	// compute variable name for non base type
157	if(tempNames == null) {
158	tempNames = computeNames(typeName);
159	}
160
161	boolean acceptDefaultName = true;
162	SimpleSetOfCharArray foundNames = new SimpleSetOfCharArray();
163
164	next : for (int i = 0; i < tempNames.length; i++) {
165	char[] tempName = tempNames[i];
166	if(dim > 0) {
167	int length = tempName.length;
168	if (tempName[length-1] == 's'){
169	if(tempName.length > 1 && tempName[length-2] == 's') {
170	System.arraycopy(tempName, 0, tempName = new char[length + 2], 0, length);
171	tempName[length] = 'e';
172	tempName[length+1] = 's';
173	}
174	} else if(tempName[length-1] == 'y') {
175	System.arraycopy(tempName, 0, tempName = new char[length + 2], 0, length);
176	tempName[length-1] = 'i';
177	tempName[length] = 'e';
178	tempName[length+1] = 's';
179	} else {
180	System.arraycopy(tempName, 0, tempName = new char[length + 1], 0, length);
181	tempName[length] = 's';
182	}
183	}
184
185	char[] unprefixedName = tempName;
186	unprefixedName[0] = ScannerHelper.toUpperCase(unprefixedName[0]);
187	for (int j = 0; j <= internalPrefix.length; j++) {
188	if(j == internalPrefix.length \|\|
189	CharOperation.prefixEquals(CharOperation.subarray(internalPrefix, j, -1), unprefixedName, j != 0 /do not check case when there is no prefix/)) {
190	tempName = CharOperation.concat(CharOperation.subarray(internalPrefix, 0, j), unprefixedName);
191	if(j == 0) tempName[0] = ScannerHelper.toLowerCase(tempName[0]);
192	for (int k = 0; k < prefixes.length; k++) {
193	if(prefixes[k].length > 0
194	&& ScannerHelper.isLetterOrDigit(prefixes[k][prefixes[k].length - 1])) {
195	tempName[0] = ScannerHelper.toUpperCase(tempName[0]);
196	} else {
197	tempName[0] = ScannerHelper.toLowerCase(tempName[0]);
198	}
199	char[] prefixName = CharOperation.concat(prefixes[k], tempName);
200	for (int l = 0; l < suffixes.length; l++) {
201	char[] suffixName = CharOperation.concat(prefixName, suffixes[l]);
202	suffixName =
203	excludeNames(
204	suffixName,
205	prefixName,
206	suffixes[l],
207	excludedNames);
208	try{
209	nameScanner.setSource(suffixName);
210	switch (nameScanner.getNextToken()) {
211	case TerminalTokens.TokenNameIdentifier :
212	int token = nameScanner.getNextToken();
213	if (token == TerminalTokens.TokenNameEOF && nameScanner.startPosition == suffixName.length) {
214	if (!foundNames.includes(suffixName)) {
215	acceptName(suffixName, prefixes[k], suffixes[l], k == 0, l == 0, internalPrefix.length - j, requestor);
216	foundNames.add(suffixName);
217	acceptDefaultName = false;
218	}
219	}
220	break;
221	default:
222	suffixName = CharOperation.concat(
223	prefixName,
224	String.valueOf(1).toCharArray(),
225	suffixes[l]
226	);
227	suffixName =
228	excludeNames(
229	suffixName,
230	prefixName,
231	suffixes[l],
232	excludedNames);
233	nameScanner.setSource(suffixName);
234	switch (nameScanner.getNextToken()) {
235	case TerminalTokens.TokenNameIdentifier :
236	token = nameScanner.getNextToken();
237	if (token == TerminalTokens.TokenNameEOF && nameScanner.startPosition == suffixName.length) {
238	if (!foundNames.includes(suffixName)) {
239	acceptName(suffixName, prefixes[k], suffixes[l], k == 0, l == 0, internalPrefix.length - j, requestor);
240	foundNames.add(suffixName);
241	acceptDefaultName = false;
242	}
243	}
244	}
245	}
246	} catch(InvalidInputException e){
247	// ignore
248	}
249	}
250	}
251	continue next;
252	}
253	}
254	}
255	// if no names were found
256	if(acceptDefaultName) {
257	char[] name = excludeNames(DEFAULT_NAME, DEFAULT_NAME, CharOperation.NO_CHAR, excludedNames);
258	requestor.acceptNameWithoutPrefixAndSuffix(name, 0);
259	}
260	}
261		39
262	private static void acceptName(	40	private static void acceptName(
263	char[] name,	41	char[] name,
Lines 278-283 Link Here
278	}	56	}
279	}	57	}
280		58
		59	private static char[][] computeBaseTypeNames(char[] typeName, boolean isConstantField, char[][] excludedNames){
		60	char[] name = computeBaseTypeNames(typeName[0], excludedNames);
		61	if(name != null) {
		62	return new char[][]{name};
		63	} else {
		64	// compute variable name like from non base type
		65	return computeNonBaseTypeNames(typeName, isConstantField);
		66	}
		67	}
281	private static char[] computeBaseTypeNames(char firstName, char[][] excludedNames){	68	private static char[] computeBaseTypeNames(char firstName, char[][] excludedNames){
282	char[] name = new char[]{firstName};	69	char[] name = new char[]{firstName};
283		70
Lines 294-301 Link Here
294		81
295	return name;	82	return name;
296	}	83	}
297		84
298	private static char[][] computeNames(char[] sourceName){	85	private static char[][] computeNonBaseTypeNames(char[] sourceName, boolean isConstantField){
299	char[][] names = new char[5][];	86	char[][] names = new char[5][];
300	int nameCount = 0;	87	int nameCount = 0;
301	boolean previousIsUpperCase = false;	88	boolean previousIsUpperCase = false;
Lines 309-315 Link Here
309	if(nameCount == names.length) {	96	if(nameCount == names.length) {
310	System.arraycopy(names, 0, names = new char[nameCount * 2][], 0, nameCount);	97	System.arraycopy(names, 0, names = new char[nameCount * 2][], 0, nameCount);
311	}	98	}
312	name[0] = ScannerHelper.toLowerCase(name[0]);	99	if (isConstantField) {
		100	name = convertToConstantName(name);
		101	} else {
		102	name[0] = ScannerHelper.toLowerCase(name[0]);
		103	}
313	names[nameCount++] = name;	104	names[nameCount++] = name;
314	}	105	}
315	}	106	}
Lines 317-327 Link Here
317	previousIsLetter = isLetter;	108	previousIsLetter = isLetter;
318	}	109	}
319	if(nameCount == 0){	110	if(nameCount == 0){
320	names[nameCount++] = CharOperation.toLowerCase(sourceName);	111	if (isConstantField) {
		112	names[nameCount++] = convertToConstantName(sourceName);
		113	} else {
		114	names[nameCount++] = CharOperation.toLowerCase(sourceName);
		115	}
321	}	116	}
322	System.arraycopy(names, 0, names = new char[nameCount][], 0, nameCount);	117	System.arraycopy(names, 0, names = new char[nameCount][], 0, nameCount);
323	return names;	118	return names;
324	}	119	}
		120
		121	private static char[] convertToConstantName(char[] name) {
		122	int length = name.length;
		123	char[] constantName = new char[length * 2];
		124	int constantNamePtr = 0;
		125	boolean wasUnderscore = true;
		126	for (int i = 0; i < length; i++) {
		127	if (ScannerHelper.isUpperCase(name[i])) {
		128	if (!wasUnderscore) constantName[constantNamePtr++] = '_';
		129	constantName[constantNamePtr++] = name[i];
		130	} else {
		131	constantName[constantNamePtr++] = ScannerHelper.toUpperCase(name[i]);
		132	wasUnderscore = name[i] == '_';
		133	}
		134	}
		135	System.arraycopy(constantName, 0, constantName = new char[constantNamePtr], 0, constantNamePtr);
		136	return constantName;
		137	}
325		138
326	private static char[] excludeNames(	139	private static char[] excludeNames(
327	char[] suffixName,	140	char[] suffixName,
Lines 430-433 Link Here
430	return false;	243	return false;
431	return true;	244	return true;
432	}	245	}
		246
		247	public static final int VK_STATIC_FIELD = 1;
		248	public static final int VK_INSTANCE_FIELD = 2;
		249	public static final int VK_CONSTANT_FIELD = 3;
		250	public static final int VK_PARAMETER = 4;
		251	public static final int VK_LOCAL = 5;
		252
		253	public static final int BK_SIMPLE_NAME = 1;
		254	public static final int BK_SIMPLE_TYPE_NAME = 2;
		255
		256	public static void suggestVariableNames(
		257	int variableKind,
		258	int baseNameKind,
		259	char[] baseName,
		260	IJavaProject javaProject,
		261	int dim,
		262	char[] internalPrefix,
		263	char[][] excluded,
		264	boolean evaluateDefault,
		265	INamingRequestor requestor) {
		266
		267	if(baseName == null \|\| baseName.length == 0)
		268	return;
		269
		270	Map options = javaProject.getOptions(true);
		271	CompilerOptions compilerOptions = new CompilerOptions(options);
		272	AssistOptions assistOptions = new AssistOptions(options);
		273
		274	boolean isConstantField = false;
		275
		276	char[][] prefixes = null;
		277	char[][] suffixes = null;
		278	switch (variableKind) {
		279	case VK_INSTANCE_FIELD:
		280	prefixes = assistOptions.fieldPrefixes;
		281	suffixes = assistOptions.fieldSuffixes;
		282	break;
		283	case VK_STATIC_FIELD:
		284	prefixes = assistOptions.staticFieldPrefixes;
		285	suffixes = assistOptions.staticFieldSuffixes;
		286	break;
		287	case VK_CONSTANT_FIELD:
		288	isConstantField = true;
		289	prefixes = assistOptions.staticFinalFieldPrefixes;
		290	suffixes = assistOptions.staticFinalFieldSuffixes;
		291	break;
		292	case VK_LOCAL:
		293	prefixes = assistOptions.localPrefixes;
		294	suffixes = assistOptions.localSuffixes;
		295	break;
		296	case VK_PARAMETER:
		297	prefixes = assistOptions.argumentPrefixes;
		298	suffixes = assistOptions.argumentSuffixes;
		299	break;
		300	}
		301
		302	if(prefixes == null \|\| prefixes.length == 0) {
		303	prefixes = new char[1][0];
		304	} else {
		305	int length = prefixes.length;
		306	System.arraycopy(prefixes, 0, prefixes = new char[length+1][], 0, length);
		307	prefixes[length] = CharOperation.NO_CHAR;
		308	}
		309
310	if(suffixes == null \|\| suffixes.length == 0) {
311	suffixes = new char[1][0];
312	} else {
313	int length = suffixes.length;
314	System.arraycopy(suffixes, 0, suffixes = new char[length+1][], 0, length);
315	suffixes[length] = CharOperation.NO_CHAR;
316	}
317
318	if(internalPrefix == null) {
319	internalPrefix = CharOperation.NO_CHAR;
320	} else {
321	internalPrefix = removePrefix(internalPrefix, prefixes);
322	}
323
324	char[][] tempNames = null;
325
326	Scanner nameScanner = getNameScanner(compilerOptions);
327	if (baseNameKind == BK_SIMPLE_TYPE_NAME) {
328	boolean isBaseType = false;
329
330	try{
331	nameScanner.setSource(baseName);
332	switch (nameScanner.getNextToken()) {
333	case TerminalTokens.TokenNameint :
334	case TerminalTokens.TokenNamebyte :
335	case TerminalTokens.TokenNameshort :
336	case TerminalTokens.TokenNamechar :
337	case TerminalTokens.TokenNamelong :
338	case TerminalTokens.TokenNamefloat :
339	case TerminalTokens.TokenNamedouble :
340	case TerminalTokens.TokenNameboolean :
341	isBaseType = true;
342	break;
343	}
344	} catch(InvalidInputException e){
345	// ignore
346	}
347	if (isBaseType) {
348	// compute variable name from base type
349	if (internalPrefix.length > 0) return;
350
351	tempNames = computeBaseTypeNames(baseName, isConstantField, excluded);
352	} else {
353	// compute variable name for non base type
354	tempNames = computeNonBaseTypeNames(baseName, isConstantField);
355	}
356	} else {
357	tempNames = new char[][]{baseName};
358	}
359
360	boolean acceptDefaultName = true;
361	SimpleSetOfCharArray foundNames = new SimpleSetOfCharArray();
362
363	for (int i = 0; i < tempNames.length; i++) {
364	char[] tempName = tempNames[i];
365
366	// add English plural form is necessary
367	if(dim > 0) {
368	int length = tempName.length;
369
370	if (isConstantField) {
371	if (tempName[length-1] == 'S'){
372	if(tempName.length > 1 && tempName[length-2] == 'S') {
373	System.arraycopy(tempName, 0, tempName = new char[length + 2], 0, length);
374	tempName[length] = 'E';
375	tempName[length+1] = 'S';
376	}
377	} else if(tempName[length-1] == 'Y') {
378	System.arraycopy(tempName, 0, tempName = new char[length + 2], 0, length);
379	tempName[length-1] = 'I';
380	tempName[length] = 'E';
381	tempName[length+1] = 'S';
382	} else {
383	System.arraycopy(tempName, 0, tempName = new char[length + 1], 0, length);
384	tempName[length] = 'S';
385	}
386	} else {
387	if (tempName[length-1] == 's'){
388	if(tempName.length > 1 && tempName[length-2] == 's') {
389	System.arraycopy(tempName, 0, tempName = new char[length + 2], 0, length);
390	tempName[length] = 'e';
391	tempName[length+1] = 's';
392	}
393	} else if(tempName[length-1] == 'y') {
394	System.arraycopy(tempName, 0, tempName = new char[length + 2], 0, length);
395	tempName[length-1] = 'i';
396	tempName[length] = 'e';
397	tempName[length+1] = 's';
398	} else {
399	System.arraycopy(tempName, 0, tempName = new char[length + 1], 0, length);
400	tempName[length] = 's';
401	}
402	}
403	}
404
405	char[] unprefixedName = tempName;
406
407	int matchingIndex = -1;
408	if (!isConstantField) {
409	unprefixedName[0] = ScannerHelper.toUpperCase(unprefixedName[0]);
410
411	done : for (int j = 0; j <= internalPrefix.length; j++) {
412	if(j == internalPrefix.length \|\|
413	CharOperation.prefixEquals(CharOperation.subarray(internalPrefix, j, -1), unprefixedName, j != 0 /do not check case when there is no prefix/)) {
414	matchingIndex = j;
415	break done;
416	}
417	}
418	} else {
419	done : for (int j = 0; j <= internalPrefix.length; j++) {
420	if(j == internalPrefix.length) {
421	matchingIndex = j;
422	break done;
423	} else if(CharOperation.prefixEquals(CharOperation.subarray(internalPrefix, j, -1), unprefixedName, j != 0 /do not check case when there is no prefix/)) {
424	if (j == 0 \|\| internalPrefix[j - 1] == '_') {
425	matchingIndex = j;
426	break done;
427	}
428
429	}
430	}
431	}
432
433	if(matchingIndex > -1) {
434	if (!isConstantField) {
435	tempName = CharOperation.concat(CharOperation.subarray(internalPrefix, 0, matchingIndex), unprefixedName);
436	if(matchingIndex == 0) tempName[0] = ScannerHelper.toLowerCase(tempName[0]);
437	} else {
438	if(matchingIndex != 0 && tempName[0] != '_' && internalPrefix[matchingIndex - 1] != '_') {
439	tempName = CharOperation.concat(CharOperation.subarray(CharOperation.toUpperCase(internalPrefix), 0, matchingIndex), unprefixedName, '_');
440	} else {
441	tempName = CharOperation.concat(CharOperation.subarray(CharOperation.toUpperCase(internalPrefix), 0, matchingIndex), unprefixedName);
442	}
443	}
444
445	for (int k = 0; k < prefixes.length; k++) {
446	if (!isConstantField) {
447	if(prefixes[k].length > 0
448	&& ScannerHelper.isLetterOrDigit(prefixes[k][prefixes[k].length - 1])) {
449	tempName[0] = ScannerHelper.toUpperCase(tempName[0]);
450	} else {
451	tempName[0] = ScannerHelper.toLowerCase(tempName[0]);
452	}
453	}
454	char[] prefixName = CharOperation.concat(prefixes[k], tempName);
455	for (int l = 0; l < suffixes.length; l++) {
456	char[] suffixName = CharOperation.concat(prefixName, suffixes[l]);
457	suffixName =
458	excludeNames(
459	suffixName,
460	prefixName,
461	suffixes[l],
462	excluded);
463	try{
464	nameScanner.setSource(suffixName);
465	switch (nameScanner.getNextToken()) {
466	case TerminalTokens.TokenNameIdentifier :
467	int token = nameScanner.getNextToken();
468	if (token == TerminalTokens.TokenNameEOF && nameScanner.startPosition == suffixName.length) {
469	if (!foundNames.includes(suffixName)) {
470	acceptName(suffixName, prefixes[k], suffixes[l], k == 0, l == 0, internalPrefix.length - matchingIndex, requestor);
471	foundNames.add(suffixName);
472	acceptDefaultName = false;
473	}
474	}
475	break;
476	default:
477	suffixName = CharOperation.concat(
478	prefixName,
479	String.valueOf(1).toCharArray(),
480	suffixes[l]
481	);
482	suffixName =
483	excludeNames(
484	suffixName,
485	prefixName,
486	suffixes[l],
487	excluded);
488	nameScanner.setSource(suffixName);
489	switch (nameScanner.getNextToken()) {
490	case TerminalTokens.TokenNameIdentifier :
491	token = nameScanner.getNextToken();
492	if (token == TerminalTokens.TokenNameEOF && nameScanner.startPosition == suffixName.length) {
493	if (!foundNames.includes(suffixName)) {
494	acceptName(suffixName, prefixes[k], suffixes[l], k == 0, l == 0, internalPrefix.length - matchingIndex, requestor);
495	foundNames.add(suffixName);
496	acceptDefaultName = false;
497	}
498	}
499	}
500	}
501	} catch(InvalidInputException e){
502	// ignore
503	}
504	}
505	}
506	}
507	}
508	// if no names were found
509	if(evaluateDefault && acceptDefaultName) {
510	char[] name = excludeNames(DEFAULT_NAME, DEFAULT_NAME, CharOperation.NO_CHAR, excluded);
511	requestor.acceptNameWithoutPrefixAndSuffix(name, 0);
512	}
513	}
433	}	514	}