Attachment #115780 for bug #38111




	this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);

	assertResults(
			"nameTypeNameRequestor[VARIABLE_DECLARATION]{nameTypeNameRequestor, null, Ltest.TypeNameRequestor;, nameTypeNameRequestor, null, " + (R_DEFAULT + R_INTERESTING + R_CASE+ R_NON_RESTRICTED) + "}\n" +
			"nameRequestor[VARIABLE_DECLARATION]{nameRequestor, null, Ltest.TypeNameRequestor;, nameRequestor, null, " + (R_DEFAULT + R_INTERESTING + R_CASE + R_NAME_LESS_NEW_CHARACTERS + R_NON_RESTRICTED) + "}",
			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());
}



	assertEquals(
		"element:class1    completion:class1    relevance:"+(R_DEFAULT + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"\n" +
		"element:fooMyClass    completion:fooMyClass    relevance:"+(R_DEFAULT + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"\n" +
		"element:myClass    completion:myClass    relevance:"+(R_DEFAULT + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"\n" +
		"element:testFooMyClass    completion:testFooMyClass    relevance:"+(R_DEFAULT + R_INTERESTING + R_CASE+ R_NON_RESTRICTED),
		requestor.getResults());
}
public void testCompletionVariableName10() throws JavaModelException {

	cu.codeComplete(cursorLocation, requestor);

	assertEquals(
		"element:barMyClass    completion:barMyClass    relevance:"+(R_DEFAULT  + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"\n" +
		"element:class1    completion:class1    relevance:"+(R_DEFAULT  + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"\n" +
		"element:myClass    completion:myClass    relevance:"+(R_DEFAULT  + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"\n" +
		"element:testBarMyClass    completion:testBarMyClass    relevance:"+(R_DEFAULT  + R_INTERESTING + R_CASE+ R_NON_RESTRICTED),
		requestor.getResults());
}
//https://bugs.eclipse.org/bugs/show_bug.cgi?id=150228




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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	assumeEquals(
		"MY_TYPE\n" + //$NON-NLS-1$
		"TYPE", //$NON-NLS-1$
		toString(suggestions));
}
/*
 * bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=38111
 */
public void testSuggestFieldName022() {
	Hashtable options = JavaCore.getOptions();
	options.put(JavaCore.CODEASSIST_STATIC_FINAL_FIELD_PREFIXES,"pre"); //$NON-NLS-1$
	options.put(JavaCore.CODEASSIST_STATIC_FINAL_FIELD_SUFFIXES,"suf"); //$NON-NLS-1$
	JavaCore.setOptions(options);
	
	String[] suggestions = NamingConventions.suggestVariableNames(
			NamingConventions.VK_CONSTANT_FIELD,
			NamingConventions.BK_TYPE_NAME,
			"MyType", //$NON-NLS-1$
			this.project,
			0,
			new String[]{},
			true);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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





import org.eclipse.jdt.core.Flags;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.core.compiler.CharOperation;
import org.eclipse.jdt.core.compiler.InvalidInputException;
import org.eclipse.jdt.internal.codeassist.impl.AssistOptions;

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


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


		System.arraycopy(names, 0, names = new char[nameCount][], 0, nameCount);
		return names;
	}
	
	
	private static char[][] computeNonBaseTypeNames(char[] sourceName, boolean isConstantField){
		int length = sourceName.length;
		
		if (length == 0) {
			return CharOperation.NO_CHAR_CHAR;
		}
		
		if (length == 1) {
			return new char[][]{CharOperation.toLowerCase(sourceName)};
		}
		
		char[][] nameParts = new char[length][];
		int namePartsPtr = -1;
		
		int endIndex = length;
		char c = sourceName[length - 1];
		
		final int IS_LOWER_CASE = 1;
		final int IS_UPPER_CASE = 2;
		final int IS_UNDERSCORE = 3;
		final int IS_OTHER = 4;
		
		int previousCharKind =
			ScannerHelper.isLowerCase(c) ? IS_LOWER_CASE :
				ScannerHelper.isUpperCase(c) ? IS_UPPER_CASE :
					c == '_' ? IS_UNDERSCORE : IS_OTHER;
		
		for(int i = length - 1 ; i >= 0 ; i--){
			c = sourceName[i];
			
			int charKind =
				ScannerHelper.isLowerCase(c) ? IS_LOWER_CASE :
					ScannerHelper.isUpperCase(c) ? IS_UPPER_CASE :
						c == '_' ? IS_UNDERSCORE : IS_OTHER;
			
			switch (charKind) {
				case IS_LOWER_CASE:
					if (previousCharKind == IS_UPPER_CASE) {
						nameParts[++namePartsPtr] = CharOperation.subarray(sourceName, i + 1, endIndex);
						endIndex = i + 1;
					}
					previousCharKind = IS_LOWER_CASE;
					break;
				case IS_UPPER_CASE:
					if (previousCharKind == IS_LOWER_CASE) {
						nameParts[++namePartsPtr] = CharOperation.subarray(sourceName, i, endIndex);
						if (i > 0) {
							char pc = sourceName[i - 1];
							previousCharKind =
								ScannerHelper.isLowerCase(pc) ? IS_LOWER_CASE :
									ScannerHelper.isUpperCase(pc) ? IS_UPPER_CASE :
										pc == '_' ? IS_UNDERSCORE : IS_OTHER;
						}
						endIndex = i;
					} else {
						previousCharKind = IS_UPPER_CASE;
					}
					break;
				case IS_UNDERSCORE:
					switch (previousCharKind) {
						case IS_UNDERSCORE:
							if (i > 0) {
								char pc = sourceName[i - 1];
								previousCharKind =
									ScannerHelper.isLowerCase(pc) ? IS_LOWER_CASE :
										ScannerHelper.isUpperCase(pc) ? IS_UPPER_CASE :
											pc == '_' ? IS_UNDERSCORE : IS_OTHER;
							}
							endIndex = i;
							break;
						case IS_LOWER_CASE:
						case IS_UPPER_CASE:
							nameParts[++namePartsPtr] = CharOperation.subarray(sourceName, i + 1, endIndex);
							if (i > 0) {
								char pc = sourceName[i - 1];
								previousCharKind =
									ScannerHelper.isLowerCase(pc) ? IS_LOWER_CASE :
										ScannerHelper.isUpperCase(pc) ? IS_UPPER_CASE :
											pc == '_' ? IS_UNDERSCORE : IS_OTHER;
							}
							endIndex = i;
							break;
						default:
							previousCharKind = IS_UNDERSCORE;
							break;
					}
					break;
				default:
					previousCharKind = IS_OTHER;
					break;
			}
		}
		if (endIndex > 0) {
			nameParts[++namePartsPtr] = CharOperation.subarray(sourceName, 0, endIndex);
		}
		
		if (isConstantField) {
			return generateConstantName(nameParts, namePartsPtr);
		} else {
			return generateNonConstantName(nameParts, namePartsPtr);
		}
	}
	
	

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

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

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

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

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

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

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

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

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

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

		char[][] tempNames = null;
		
		Scanner nameScanner = getNameScanner(compilerOptions);
		if (baseNameKind == BK_SIMPLE_TYPE_NAME) {
			boolean isBaseType = false;
			
			try{
				nameScanner.setSource(baseName);
				switch (nameScanner.getNextToken()) {
					case TerminalTokens.TokenNameint :
					case TerminalTokens.TokenNamebyte :
					case TerminalTokens.TokenNameshort :
					case TerminalTokens.TokenNamechar :
					case TerminalTokens.TokenNamelong :
					case TerminalTokens.TokenNamefloat :
					case TerminalTokens.TokenNamedouble :
					case TerminalTokens.TokenNameboolean :
						isBaseType = true;
						break;
				}
			} catch(InvalidInputException e){
				// ignore
			}
			if (isBaseType) {
				// compute variable name from base type
				if (internalPrefix.length > 0) return;
	
				tempNames = computeBaseTypeNames(baseName, isConstantField, excluded);
			} else {
				// compute variable name for non base type
				tempNames = computeNonBaseTypeNames(baseName, isConstantField);
			}
		} else {
			tempNames = new char[][]{baseName};
		}

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

		for (int i = 0; i < tempNames.length; i++) {
			char[] tempName = tempNames[i];
			
			// add English plural form is necessary
			if(dim > 0) {
				int length = tempName.length;
				
				if (isConstantField) {
					if (tempName[length-1] == 'S'){
						if(tempName.length > 1 && tempName[length-2] == 'S') {
							System.arraycopy(tempName, 0, tempName = new char[length + 2], 0, length);
							tempName[length] = 'E';
							tempName[length+1] = 'S';
						}
					} else if(tempName[length-1] == 'Y') {
						System.arraycopy(tempName, 0, tempName = new char[length + 2], 0, length);
						tempName[length-1] = 'I';
						tempName[length] = 'E';
						tempName[length+1] = 'S';
					} else {
						System.arraycopy(tempName, 0, tempName = new char[length + 1], 0, length);
						tempName[length] = 'S';
					}
				} else {
					if (tempName[length-1] == 's'){
						if(tempName.length > 1 && tempName[length-2] == 's') {
							System.arraycopy(tempName, 0, tempName = new char[length + 2], 0, length);
							tempName[length] = 'e';
							tempName[length+1] = 's';
						}
					} else if(tempName[length-1] == 'y') {
						System.arraycopy(tempName, 0, tempName = new char[length + 2], 0, length);
						tempName[length-1] = 'i';
						tempName[length] = 'e';
						tempName[length+1] = 's';
					} else {
						System.arraycopy(tempName, 0, tempName = new char[length + 1], 0, length);
						tempName[length] = 's';
					}
				}
			}
			
			char[] unprefixedName = tempName;
			
			int matchingIndex = -1;
			if (!isConstantField) {
				unprefixedName[0] = ScannerHelper.toUpperCase(unprefixedName[0]);
				
				done : for (int j = 0; j <= internalPrefix.length; j++) {
					if(j == internalPrefix.length ||
							CharOperation.prefixEquals(CharOperation.subarray(internalPrefix, j, -1), unprefixedName, j != 0 /*do not check case when there is no prefix*/)) {
						matchingIndex = j;
						break done;
					}
				}
			} else {
				done : for (int j = 0; j <= internalPrefix.length; j++) {
					if(j == internalPrefix.length) {
						matchingIndex = j;
						break done;
					} else if(CharOperation.prefixEquals(CharOperation.subarray(internalPrefix, j, -1), unprefixedName, j != 0 /*do not check case when there is no prefix*/)) {
						if (j == 0 || internalPrefix[j - 1] == '_') {
							matchingIndex = j;
							break done;
						}
						
					}
				}
			}

			if(matchingIndex > -1) {
				if (!isConstantField) {
					tempName = CharOperation.concat(CharOperation.subarray(internalPrefix, 0, matchingIndex), unprefixedName);
					if(matchingIndex == 0) tempName[0] = ScannerHelper.toLowerCase(tempName[0]);
				} else {
					if(matchingIndex != 0 && tempName[0] != '_' && internalPrefix[matchingIndex - 1] != '_') {
						tempName = CharOperation.concat(CharOperation.subarray(CharOperation.toUpperCase(internalPrefix), 0, matchingIndex), unprefixedName, '_');
					} else {
						tempName = CharOperation.concat(CharOperation.subarray(CharOperation.toUpperCase(internalPrefix), 0, matchingIndex), unprefixedName);
					}
				}
				
				for (int k = 0; k < prefixes.length; k++) {
					if (!isConstantField) {
						if(prefixes[k].length > 0
							&& ScannerHelper.isLetterOrDigit(prefixes[k][prefixes[k].length - 1])) {
							tempName[0] = ScannerHelper.toUpperCase(tempName[0]);
						} else {
							tempName[0] = ScannerHelper.toLowerCase(tempName[0]);
						}
					}
					char[] prefixName = CharOperation.concat(prefixes[k], tempName);
					for (int l = 0; l < suffixes.length; l++) {
						char[] suffixName = CharOperation.concat(prefixName, suffixes[l]);
						suffixName =
							excludeNames(
								suffixName,
								prefixName,
								suffixes[l],
								excluded);
						try{
							nameScanner.setSource(suffixName);
							switch (nameScanner.getNextToken()) {
								case TerminalTokens.TokenNameIdentifier :
									int token = nameScanner.getNextToken();
									if (token == TerminalTokens.TokenNameEOF && nameScanner.startPosition == suffixName.length) {
										if (!foundNames.includes(suffixName)) {
											acceptName(suffixName, prefixes[k], suffixes[l],  k == 0, l == 0, internalPrefix.length - matchingIndex, requestor);
											foundNames.add(suffixName);
											acceptDefaultName = false;
										}
									}
									break;
								default:
									suffixName = CharOperation.concat(
										prefixName,
										String.valueOf(1).toCharArray(),
										suffixes[l]
									);
									suffixName =
										excludeNames(
											suffixName,
											prefixName,
											suffixes[l],
											excluded);
									nameScanner.setSource(suffixName);
									switch (nameScanner.getNextToken()) {
										case TerminalTokens.TokenNameIdentifier :
											token = nameScanner.getNextToken();
											if (token == TerminalTokens.TokenNameEOF && nameScanner.startPosition == suffixName.length) {
												if (!foundNames.includes(suffixName)) {
													acceptName(suffixName, prefixes[k], suffixes[l], k == 0, l == 0, internalPrefix.length - matchingIndex, requestor);
													foundNames.add(suffixName);
													acceptDefaultName = false;
												}
											}
									}
							}
						} catch(InvalidInputException e){
							// ignore
						}
					}
				}
			}
		}
		// if no names were found
		if(evaluateDefault && acceptDefaultName) {
			char[] name = excludeNames(DEFAULT_NAME, DEFAULT_NAME, CharOperation.NO_CHAR, excluded);
			requestor.acceptNameWithoutPrefixAndSuffix(name, 0);
		}
	}
}




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




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

Lines 1812-1817 Link Here

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




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


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

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

	private static char[] removePrefixAndSuffix(char[] name, char[][] prefixes, char[][] suffixes) {

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

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

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

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

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

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

	 * @return char[] the name without prefix and suffix.
	 * @see JavaCore#setOptions(java.util.Hashtable)
	 * @see JavaCore#getDefaultOptions()
	 * 
	 * @deprecated Use {@link #getBaseName(int, String, IJavaProject)} instead with {@link #VK_LOCAL} as variable kind.
	 */
	public static char[] removePrefixAndSuffixForLocalVariableName(IJavaProject javaProject, char[] localName) {
		AssistOptions assistOptions = new AssistOptions(javaProject.getOptions(true));

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

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

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

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

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

				dim,
				convertStringToChars(excludedNames)));
	}

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

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

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

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

		return requestor.getResults();
	}

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

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

			);
		}
	}

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

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

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

			);
		}
	}

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

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

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

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

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

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




}

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

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

Lines 28-33 Link Here

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




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


			this.completionToken = field.realName;

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

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

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


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

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


			this.completionToken = method.selector;

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

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

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

			}
		};

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

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

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

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

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

		findVariableName(
				token,

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

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

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

Return to bug 38111

Lines 5160-5167 Link Here

(-)src/org/eclipse/jdt/core/tests/model/CompletionTests.java (-5 / +122 lines)
5160	this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);	5160	this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);
5161		5161
5162	assertResults(	5162	assertResults(
5163	"nameRequestor[VARIABLE_DECLARATION]{nameRequestor, null, Ltest.TypeNameRequestor;, nameRequestor, null, " + (R_DEFAULT + R_INTERESTING + R_CASE+ R_NON_RESTRICTED) + "}\n" +	5163	"nameTypeNameRequestor[VARIABLE_DECLARATION]{nameTypeNameRequestor, null, Ltest.TypeNameRequestor;, nameTypeNameRequestor, null, " + (R_DEFAULT + R_INTERESTING + R_CASE+ R_NON_RESTRICTED) + "}\n" +
5164	"nameTypeNameRequestor[VARIABLE_DECLARATION]{nameTypeNameRequestor, null, Ltest.TypeNameRequestor;, nameTypeNameRequestor, null, " + (R_DEFAULT + R_INTERESTING + R_CASE+ R_NON_RESTRICTED) + "}",	5164	"nameRequestor[VARIABLE_DECLARATION]{nameRequestor, null, Ltest.TypeNameRequestor;, nameRequestor, null, " + (R_DEFAULT + R_INTERESTING + R_CASE + R_NAME_LESS_NEW_CHARACTERS + R_NON_RESTRICTED) + "}",
		5165	requestor.getResults());
		5166	}
		5167
		5168	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=38111
		5169	public void testCompletionFieldName3() throws JavaModelException {
		5170	this.workingCopies = new ICompilationUnit[1];
		5171	this.workingCopies[0] = getWorkingCopy(
		5172	"/Completion/src/test/TypeNameRequestor.java",
		5173	"package test;"+
		5174	"public class TypeNameRequestor {\n" +
		5175	" public static final TypeNameRequestor \n" +
		5176	"}\n");
		5177
		5178	CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true);
		5179	String str = this.workingCopies[0].getSource();
		5180	String completeBehind = "final TypeNameRequestor ";
		5181	int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
		5182	this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);
		5183
		5184	assertResults(
		5185	"NAME_REQUESTOR[VARIABLE_DECLARATION]{NAME_REQUESTOR, null, Ltest.TypeNameRequestor;, NAME_REQUESTOR, null, " + (R_DEFAULT + R_INTERESTING + R_CASE+ R_NON_RESTRICTED) + "}\n" +
		5186	"REQUESTOR[VARIABLE_DECLARATION]{REQUESTOR, null, Ltest.TypeNameRequestor;, REQUESTOR, null, " + (R_DEFAULT + R_INTERESTING + R_CASE+ R_NON_RESTRICTED) + "}\n" +
		5187	"TYPE_NAME_REQUESTOR[VARIABLE_DECLARATION]{TYPE_NAME_REQUESTOR, null, Ltest.TypeNameRequestor;, TYPE_NAME_REQUESTOR, null, " + (R_DEFAULT + R_INTERESTING + R_CASE+ R_NON_RESTRICTED) + "}",
		5188	requestor.getResults());
		5189	}
		5190
		5191	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=38111
		5192	public void testCompletionFieldName4() throws JavaModelException {
		5193	this.workingCopies = new ICompilationUnit[1];
		5194	this.workingCopies[0] = getWorkingCopy(
		5195	"/Completion/src/test/TypeNameRequestor.java",
		5196	"package test;"+
		5197	"public class TypeNameRequestor {\n" +
		5198	" public static final TypeNameRequestor nam\n" +
		5199	"}\n");
		5200
		5201	CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true);
		5202	String str = this.workingCopies[0].getSource();
		5203	String completeBehind = "final TypeNameRequestor nam";
		5204	int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
		5205	this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);
		5206
		5207	assertResults(
		5208	"NAM_REQUESTOR[VARIABLE_DECLARATION]{NAM_REQUESTOR, null, Ltest.TypeNameRequestor;, NAM_REQUESTOR, null, " + (R_DEFAULT + R_INTERESTING + R_NON_RESTRICTED) + "}\n" +
		5209	"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" +
		5210	"NAME_REQUESTOR[VARIABLE_DECLARATION]{NAME_REQUESTOR, null, Ltest.TypeNameRequestor;, NAME_REQUESTOR, null, " + (R_DEFAULT + R_INTERESTING + R_NAME_LESS_NEW_CHARACTERS+ R_NON_RESTRICTED) + "}",
		5211	requestor.getResults());
		5212	}
		5213
		5214	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=38111
		5215	public void testCompletionFieldName5() throws JavaModelException {
		5216	this.workingCopies = new ICompilationUnit[1];
		5217	this.workingCopies[0] = getWorkingCopy(
		5218	"/Completion/src/test/TypeNameRequestor.java",
		5219	"package test;"+
		5220	"public class TypeNameRequestor {\n" +
		5221	" public static final TypeNameRequestor ZZ\n" +
		5222	"}\n");
		5223
		5224	CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true);
		5225	String str = this.workingCopies[0].getSource();
		5226	String completeBehind = "final TypeNameRequestor ZZ";
		5227	int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
		5228	this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);
5229
5230	assertResults(
5231	"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" +
5232	"ZZ_REQUESTOR[VARIABLE_DECLARATION]{ZZ_REQUESTOR, null, Ltest.TypeNameRequestor;, ZZ_REQUESTOR, null, " + (R_DEFAULT + R_INTERESTING + R_CASE + R_NON_RESTRICTED) + "}\n" +
5233	"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) + "}",
5234	requestor.getResults());
5235	}
5236
5237	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=38111
5238	public void testCompletionFieldName6() throws JavaModelException {
5239	this.workingCopies = new ICompilationUnit[1];
5240	this.workingCopies[0] = getWorkingCopy(
5241	"/Completion/src/test/TypeNameRequestor.java",
5242	"package test;"+
5243	"public class TypeNameRequestor {\n" +
5244	" public static final TypeNameRequestor ZZN\n" +
5245	"}\n");
5246
5247	CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true);
5248	String str = this.workingCopies[0].getSource();
5249	String completeBehind = "final TypeNameRequestor ZZN";
5250	int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
5251	this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);
5252
5253	assertResults(
5254	"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" +
5255	"ZZN_REQUESTOR[VARIABLE_DECLARATION]{ZZN_REQUESTOR, null, Ltest.TypeNameRequestor;, ZZN_REQUESTOR, null, " + (R_DEFAULT + R_INTERESTING + R_CASE + R_NON_RESTRICTED) + "}\n" +
5256	"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) + "}",
5257	requestor.getResults());
5258	}
5259
5260	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=38111
5261	public void testCompletionFieldName7() throws JavaModelException {
5262	this.workingCopies = new ICompilationUnit[1];
5263	this.workingCopies[0] = getWorkingCopy(
5264	"/Completion/src/test/TypeNameRequestor.java",
5265	"package test;"+
5266	"public class TypeNameRequestor {\n" +
5267	" public static final TypeNameRequestor ZZ_N\n" +
5268	"}\n");
5269
5270	CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true);
5271	String str = this.workingCopies[0].getSource();
5272	String completeBehind = "final TypeNameRequestor ZZ_N";
5273	int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
5274	this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);
5275
5276	assertResults(
5277	"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" +
5278	"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" +
5279	"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) + "}",
5165	requestor.getResults());	5280	requestor.getResults());
5166	}	5281	}
5167		5282
Lines 13906-13912 Link Here
13906		14021
13907	assertEquals(	14022	assertEquals(
13908	"element:class1 completion:class1 relevance:"+(R_DEFAULT + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"\n" +	14023	"element:class1 completion:class1 relevance:"+(R_DEFAULT + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"\n" +
13909	"element:myClass completion:myClass relevance:"+(R_DEFAULT + R_INTERESTING + R_CASE+ R_NON_RESTRICTED),	14024	"element:fooMyClass completion:fooMyClass relevance:"+(R_DEFAULT + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"\n" +
		14025	"element:myClass completion:myClass relevance:"+(R_DEFAULT + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"\n" +
		14026	"element:testFooMyClass completion:testFooMyClass relevance:"+(R_DEFAULT + R_INTERESTING + R_CASE+ R_NON_RESTRICTED),
13910	requestor.getResults());	14027	requestor.getResults());
13911	}	14028	}
13912	public void testCompletionVariableName10() throws JavaModelException {	14029	public void testCompletionVariableName10() throws JavaModelException {
Lines 14296-14305 Link Here
14296	cu.codeComplete(cursorLocation, requestor);	14413	cu.codeComplete(cursorLocation, requestor);
14297		14414
14298	assertEquals(	14415	assertEquals(
14299	"element:bar_MyClass completion:bar_MyClass relevance:"+(R_DEFAULT + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"\n" +	14416	"element:barMyClass completion:barMyClass relevance:"+(R_DEFAULT + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"\n" +
14300	"element:class1 completion:class1 relevance:"+(R_DEFAULT + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"\n" +	14417	"element:class1 completion:class1 relevance:"+(R_DEFAULT + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"\n" +
14301	"element:myClass completion:myClass relevance:"+(R_DEFAULT + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"\n" +	14418	"element:myClass completion:myClass relevance:"+(R_DEFAULT + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"\n" +
14302	"element:test_Bar_MyClass completion:test_Bar_MyClass relevance:"+(R_DEFAULT + R_INTERESTING + R_CASE+ R_NON_RESTRICTED),	14419	"element:testBarMyClass completion:testBarMyClass relevance:"+(R_DEFAULT + R_INTERESTING + R_CASE+ R_NON_RESTRICTED),
14303	requestor.getResults());	14420	requestor.getResults());
14304	}	14421	}
14305	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=150228	14422	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=150228

Lines 1965-1974 Link Here

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

Lines 3582-3587 Link Here

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

Lines 342-351 Link Here

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

Lines 14-19 Link Here

(-)model/org/eclipse/jdt/internal/core/InternalNamingConventions.java (+589 lines)
14		14
15	import org.eclipse.jdt.core.Flags;	15	import org.eclipse.jdt.core.Flags;
16	import org.eclipse.jdt.core.IJavaProject;	16	import org.eclipse.jdt.core.IJavaProject;
		17	import org.eclipse.jdt.core.JavaCore;
17	import org.eclipse.jdt.core.compiler.CharOperation;	18	import org.eclipse.jdt.core.compiler.CharOperation;
18	import org.eclipse.jdt.core.compiler.InvalidInputException;	19	import org.eclipse.jdt.core.compiler.InvalidInputException;
19	import org.eclipse.jdt.internal.codeassist.impl.AssistOptions;	20	import org.eclipse.jdt.internal.codeassist.impl.AssistOptions;
Lines 53-58 Link Here
53	getNameScanner(compilerOptions),	54	getNameScanner(compilerOptions),
54	requestor);	55	requestor);
55	}	56	}
		57
56	public static void suggestFieldNames(IJavaProject javaProject, char[] packageName, char[] qualifiedTypeName, int dim, int modifiers, char[] internalPrefix, char[][] excludedNames, INamingRequestor requestor) {	58	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);	59	boolean isStatic = Flags.isStatic(modifiers);
58		60
Lines 258-263 Link Here
258	requestor.acceptNameWithoutPrefixAndSuffix(name, 0);	260	requestor.acceptNameWithoutPrefixAndSuffix(name, 0);
259	}	261	}
260	}	262	}
		263
261		264
262	private static void acceptName(	265	private static void acceptName(
263	char[] name,	266	char[] name,
Lines 278-283 Link Here
278	}	281	}
279	}	282	}
280		283
		284	private static char[][] computeBaseTypeNames(char[] typeName, boolean isConstantField, char[][] excludedNames){
		285	char[] name = computeBaseTypeNames(typeName[0], excludedNames);
		286	if(name != null) {
		287	return new char[][]{name};
		288	} else {
		289	// compute variable name like from non base type
		290	return computeNonBaseTypeNames(typeName, isConstantField);
		291	}
		292	}
281	private static char[] computeBaseTypeNames(char firstName, char[][] excludedNames){	293	private static char[] computeBaseTypeNames(char firstName, char[][] excludedNames){
282	char[] name = new char[]{firstName};	294	char[] name = new char[]{firstName};
283		295
Lines 322-327 Link Here
322	System.arraycopy(names, 0, names = new char[nameCount][], 0, nameCount);	334	System.arraycopy(names, 0, names = new char[nameCount][], 0, nameCount);
323	return names;	335	return names;
324	}	336	}
		337
		338
		339	private static char[][] computeNonBaseTypeNames(char[] sourceName, boolean isConstantField){
		340	int length = sourceName.length;
		341
		342	if (length == 0) {
		343	return CharOperation.NO_CHAR_CHAR;
		344	}
		345
		346	if (length == 1) {
		347	return new char[][]{CharOperation.toLowerCase(sourceName)};
		348	}
		349
		350	char[][] nameParts = new char[length][];
		351	int namePartsPtr = -1;
		352
		353	int endIndex = length;
		354	char c = sourceName[length - 1];
		355
		356	final int IS_LOWER_CASE = 1;
		357	final int IS_UPPER_CASE = 2;
		358	final int IS_UNDERSCORE = 3;
		359	final int IS_OTHER = 4;
		360
		361	int previousCharKind =
		362	ScannerHelper.isLowerCase(c) ? IS_LOWER_CASE :
		363	ScannerHelper.isUpperCase(c) ? IS_UPPER_CASE :
		364	c == '_' ? IS_UNDERSCORE : IS_OTHER;
		365
		366	for(int i = length - 1 ; i >= 0 ; i--){
		367	c = sourceName[i];
		368
		369	int charKind =
		370	ScannerHelper.isLowerCase(c) ? IS_LOWER_CASE :
		371	ScannerHelper.isUpperCase(c) ? IS_UPPER_CASE :
		372	c == '_' ? IS_UNDERSCORE : IS_OTHER;
		373
		374	switch (charKind) {
		375	case IS_LOWER_CASE:
		376	if (previousCharKind == IS_UPPER_CASE) {
		377	nameParts[++namePartsPtr] = CharOperation.subarray(sourceName, i + 1, endIndex);
		378	endIndex = i + 1;
		379	}
		380	previousCharKind = IS_LOWER_CASE;
		381	break;
		382	case IS_UPPER_CASE:
		383	if (previousCharKind == IS_LOWER_CASE) {
		384	nameParts[++namePartsPtr] = CharOperation.subarray(sourceName, i, endIndex);
		385	if (i > 0) {
		386	char pc = sourceName[i - 1];
		387	previousCharKind =
		388	ScannerHelper.isLowerCase(pc) ? IS_LOWER_CASE :
		389	ScannerHelper.isUpperCase(pc) ? IS_UPPER_CASE :
		390	pc == '_' ? IS_UNDERSCORE : IS_OTHER;
		391	}
		392	endIndex = i;
		393	} else {
		394	previousCharKind = IS_UPPER_CASE;
		395	}
		396	break;
		397	case IS_UNDERSCORE:
		398	switch (previousCharKind) {
		399	case IS_UNDERSCORE:
		400	if (i > 0) {
401	char pc = sourceName[i - 1];
402	previousCharKind =
403	ScannerHelper.isLowerCase(pc) ? IS_LOWER_CASE :
404	ScannerHelper.isUpperCase(pc) ? IS_UPPER_CASE :
405	pc == '_' ? IS_UNDERSCORE : IS_OTHER;
406	}
407	endIndex = i;
408	break;
409	case IS_LOWER_CASE:
410	case IS_UPPER_CASE:
411	nameParts[++namePartsPtr] = CharOperation.subarray(sourceName, i + 1, endIndex);
412	if (i > 0) {
413	char pc = sourceName[i - 1];
414	previousCharKind =
415	ScannerHelper.isLowerCase(pc) ? IS_LOWER_CASE :
416	ScannerHelper.isUpperCase(pc) ? IS_UPPER_CASE :
417	pc == '_' ? IS_UNDERSCORE : IS_OTHER;
418	}
419	endIndex = i;
420	break;
421	default:
422	previousCharKind = IS_UNDERSCORE;
423	break;
424	}
425	break;
426	default:
427	previousCharKind = IS_OTHER;
428	break;
429	}
430	}
431	if (endIndex > 0) {
432	nameParts[++namePartsPtr] = CharOperation.subarray(sourceName, 0, endIndex);
433	}
434
435	if (isConstantField) {
436	return generateConstantName(nameParts, namePartsPtr);
437	} else {
438	return generateNonConstantName(nameParts, namePartsPtr);
439	}
440	}
441
442
325		443
326	private static char[] excludeNames(	444	private static char[] excludeNames(
327	char[] suffixName,	445	char[] suffixName,
Lines 344-349 Link Here
344	}	462	}
345	return suffixName;	463	return suffixName;
346	}	464	}
		465
		466	private static char[][] generateNonConstantName(char[][] nameParts, int namePartsPtr) {
		467	char[][] names = new char[namePartsPtr + 1][];
		468
		469	char[] namePart = CharOperation.toLowerCase(nameParts[0]);
		470	int namePartLength = namePart.length;
		471	System.arraycopy(namePart, 0, namePart, 0, namePartLength);
		472
		473	char[] name = namePart;
		474
		475	names[namePartsPtr] = name;
		476
		477	for (int i = 1; i <= namePartsPtr; i++) {
		478	namePart = CharOperation.toLowerCase(nameParts[i]);
		479	namePartLength = namePart.length;
		480	name = CharOperation.concat(namePart, name);
		481	name[namePartLength] = ScannerHelper.toUpperCase(name[namePartLength]);
		482
		483	names[namePartsPtr - i] = name;
		484	}
		485	return names;
		486	}
		487
		488	private static char[][] generateConstantName(char[][] nameParts, int namePartsPtr) {
		489	char[][] names = new char[namePartsPtr + 1][];
		490
		491	char[] namePart = CharOperation.toUpperCase(nameParts[0]);
		492	int namePartLength = namePart.length;
		493	System.arraycopy(namePart, 0, namePart, 0, namePartLength);
		494
		495	char[] name = namePart;
		496
		497	names[namePartsPtr] = name;
		498
		499	for (int i = 1; i <= namePartsPtr; i++) {
		500	namePart = CharOperation.toUpperCase(nameParts[i]);
		501	namePartLength = namePart.length;
		502	if (namePart[namePartLength - 1] != '_') {
		503	name = CharOperation.concat(namePart, name, '_');
		504	} else {
		505	name = CharOperation.concat(namePart, name);
		506	}
		507
		508	names[namePartsPtr - i] = name;
		509	}
		510	return names;
		511	}
		512
		513	public static char[] getBaseName(
		514	int variableKind,
		515	IJavaProject javaProject,
		516	char[] name) {
		517
		518	AssistOptions assistOptions;
		519	if (javaProject != null) {
		520	assistOptions = new AssistOptions(javaProject.getOptions(true));
		521	} else {
		522	assistOptions = new AssistOptions(JavaCore.getOptions());
		523	}
		524
		525	char[][] prefixes = null;
		526	char[][] suffixes = null;
		527	switch (variableKind) {
		528	case VK_INSTANCE_FIELD:
529	prefixes = assistOptions.fieldPrefixes;
530	suffixes = assistOptions.fieldSuffixes;
531	break;
532	case VK_STATIC_FIELD:
533	prefixes = assistOptions.staticFieldPrefixes;
534	suffixes = assistOptions.staticFieldSuffixes;
535	break;
536	case VK_CONSTANT_FIELD:
537	prefixes = assistOptions.staticFinalFieldPrefixes;
538	suffixes = assistOptions.staticFinalFieldSuffixes;
539	break;
540	case VK_LOCAL:
541	prefixes = assistOptions.localPrefixes;
542	suffixes = assistOptions.localSuffixes;
543	break;
544	case VK_PARAMETER:
545	prefixes = assistOptions.argumentPrefixes;
546	suffixes = assistOptions.argumentSuffixes;
547	break;
548	}
549
550
551	return getBaseName(name, prefixes, suffixes, variableKind == VK_CONSTANT_FIELD);
552	}
553
554	private static char[] getBaseName(char[] name, char[][] prefixes, char[][] suffixes, boolean isConstant) {
555	char[] nameWithoutPrefixAndSiffix = removeVariablePrefixAndSuffix(name, prefixes, suffixes, false);
556
557	char[] baseName;
558	if (isConstant) {
559	int length = nameWithoutPrefixAndSiffix.length;
560	baseName = new char[length];
561	int baseNamePtr = -1;
562
563	boolean previousIsUnderscore = false;
564	for (int i = 0; i < length; i++) {
565	char c = nameWithoutPrefixAndSiffix[i];
566	if (c != '_') {
567	if (previousIsUnderscore \|\| i == 0) {
568	baseName[++baseNamePtr] = ScannerHelper.toUpperCase(c);
569	previousIsUnderscore = false;
570	} else {
571	baseName[++baseNamePtr] = ScannerHelper.toLowerCase(c);
572	}
573	} else {
574	previousIsUnderscore = true;
575	}
576	}
577	System.arraycopy(baseName, 0, baseName = new char[baseNamePtr + 1], 0, baseNamePtr + 1);
578	} else {
579	baseName = nameWithoutPrefixAndSiffix;
580	}
581
582	return baseName;
583	}
584
585	public static char[] removeVariablePrefixAndSuffix(
586	int variableKind,
587	IJavaProject javaProject,
588	char[] name) {
589	AssistOptions assistOptions;
590	if (javaProject != null) {
591	assistOptions = new AssistOptions(javaProject.getOptions(true));
592	} else {
593	assistOptions = new AssistOptions(JavaCore.getOptions());
594	}
595
596	char[][] prefixes = null;
597	char[][] suffixes = null;
598	switch (variableKind) {
599	case VK_INSTANCE_FIELD:
600	prefixes = assistOptions.fieldPrefixes;
601	suffixes = assistOptions.fieldSuffixes;
602	break;
603	case VK_STATIC_FIELD:
604	prefixes = assistOptions.staticFieldPrefixes;
605	suffixes = assistOptions.staticFieldSuffixes;
606	break;
607	case VK_CONSTANT_FIELD:
608	prefixes = assistOptions.staticFinalFieldPrefixes;
609	suffixes = assistOptions.staticFinalFieldSuffixes;
610	break;
611	case VK_LOCAL:
612	prefixes = assistOptions.localPrefixes;
613	suffixes = assistOptions.localSuffixes;
614	break;
615	case VK_PARAMETER:
616	prefixes = assistOptions.argumentPrefixes;
617	suffixes = assistOptions.argumentSuffixes;
618	break;
619	}
620
621	return InternalNamingConventions.removeVariablePrefixAndSuffix(name, prefixes, suffixes, true);
622	}
623
624	private static char[] removeVariablePrefixAndSuffix(char[] name, char[][] prefixes, char[][] suffixes, boolean updateFirstCharacter) {
625	// remove longer prefix
626	char[] withoutPrefixName = name;
627	if (prefixes != null) {
628	int bestLength = 0;
629	for (int i= 0; i < prefixes.length; i++) {
630	char[] prefix = prefixes[i];
631	if (CharOperation.prefixEquals(prefix, name)) {
632	int currLen = prefix.length;
633	boolean lastCharIsLetter = ScannerHelper.isLetter(prefix[currLen - 1]);
634	if(!lastCharIsLetter \|\| (lastCharIsLetter && name.length > currLen && ScannerHelper.isUpperCase(name[currLen]))) {
635	if (bestLength < currLen && name.length != currLen) {
636	withoutPrefixName = CharOperation.subarray(name, currLen, name.length);
637	bestLength = currLen;
638	}
639	}
640	}
641	}
642	}
643
644	// remove longer suffix
645	char[] withoutSuffixName = withoutPrefixName;
646	if(suffixes != null) {
647	int bestLength = 0;
648	for (int i = 0; i < suffixes.length; i++) {
649	char[] suffix = suffixes[i];
650	if(CharOperation.endsWith(withoutPrefixName, suffix)) {
651	int currLen = suffix.length;
652	if(bestLength < currLen && withoutPrefixName.length != currLen) {
653	withoutSuffixName = CharOperation.subarray(withoutPrefixName, 0, withoutPrefixName.length - currLen);
654	bestLength = currLen;
655	}
656	}
657	}
658	}
659
660	if (updateFirstCharacter) withoutSuffixName[0] = ScannerHelper.toLowerCase(withoutSuffixName[0]);
661	return withoutSuffixName;
662	}
347		663
348	private static char[] removePrefix(char[] name, char[][] prefixes) {	664	private static char[] removePrefix(char[] name, char[][] prefixes) {
349	// remove longer prefix	665	// remove longer prefix
Lines 430-433 Link Here
430	return false;	746	return false;
431	return true;	747	return true;
432	}	748	}
		749
		750	public static final int VK_STATIC_FIELD = 1;
		751	public static final int VK_INSTANCE_FIELD = 2;
		752	public static final int VK_CONSTANT_FIELD = 3;
		753	public static final int VK_PARAMETER = 4;
		754	public static final int VK_LOCAL = 5;
		755
		756	public static final int BK_SIMPLE_NAME = 1;
		757	public static final int BK_SIMPLE_TYPE_NAME = 2;
		758
		759	public static void suggestVariableNames(
		760	int variableKind,
		761	int baseNameKind,
		762	char[] baseName,
		763	IJavaProject javaProject,
		764	int dim,
		765	char[] internalPrefix,
		766	char[][] excluded,
		767	boolean evaluateDefault,
		768	INamingRequestor requestor) {
		769
		770	if(baseName == null \|\| baseName.length == 0)
		771	return;
		772
		773	Map options;
		774	if (javaProject != null) {
		775	options = javaProject.getOptions(true);
		776	} else {
		777	options = JavaCore.getOptions();
		778	}
		779	CompilerOptions compilerOptions = new CompilerOptions(options);
		780	AssistOptions assistOptions = new AssistOptions(options);
		781
		782	boolean isConstantField = false;
		783
		784	char[][] prefixes = null;
		785	char[][] suffixes = null;
		786	switch (variableKind) {
		787	case VK_INSTANCE_FIELD:
		788	prefixes = assistOptions.fieldPrefixes;
		789	suffixes = assistOptions.fieldSuffixes;
		790	break;
		791	case VK_STATIC_FIELD:
		792	prefixes = assistOptions.staticFieldPrefixes;
		793	suffixes = assistOptions.staticFieldSuffixes;
		794	break;
		795	case VK_CONSTANT_FIELD:
		796	isConstantField = true;
		797	prefixes = assistOptions.staticFinalFieldPrefixes;
		798	suffixes = assistOptions.staticFinalFieldSuffixes;
		799	break;
		800	case VK_LOCAL:
		801	prefixes = assistOptions.localPrefixes;
		802	suffixes = assistOptions.localSuffixes;
		803	break;
		804	case VK_PARAMETER:
		805	prefixes = assistOptions.argumentPrefixes;
		806	suffixes = assistOptions.argumentSuffixes;
		807	break;
		808	}
		809
		810	if(prefixes == null \|\| prefixes.length == 0) {
		811	prefixes = new char[1][0];
		812	} else {
813	int length = prefixes.length;
814	System.arraycopy(prefixes, 0, prefixes = new char[length+1][], 0, length);
815	prefixes[length] = CharOperation.NO_CHAR;
816	}
817
818	if(suffixes == null \|\| suffixes.length == 0) {
819	suffixes = new char[1][0];
820	} else {
821	int length = suffixes.length;
822	System.arraycopy(suffixes, 0, suffixes = new char[length+1][], 0, length);
823	suffixes[length] = CharOperation.NO_CHAR;
824	}
825
826	if(internalPrefix == null) {
827	internalPrefix = CharOperation.NO_CHAR;
828	} else {
829	internalPrefix = removePrefix(internalPrefix, prefixes);
830	}
831
832	char[][] tempNames = null;
833
834	Scanner nameScanner = getNameScanner(compilerOptions);
835	if (baseNameKind == BK_SIMPLE_TYPE_NAME) {
836	boolean isBaseType = false;
837
838	try{
839	nameScanner.setSource(baseName);
840	switch (nameScanner.getNextToken()) {
841	case TerminalTokens.TokenNameint :
842	case TerminalTokens.TokenNamebyte :
843	case TerminalTokens.TokenNameshort :
844	case TerminalTokens.TokenNamechar :
845	case TerminalTokens.TokenNamelong :
846	case TerminalTokens.TokenNamefloat :
847	case TerminalTokens.TokenNamedouble :
848	case TerminalTokens.TokenNameboolean :
849	isBaseType = true;
850	break;
851	}
852	} catch(InvalidInputException e){
853	// ignore
854	}
855	if (isBaseType) {
856	// compute variable name from base type
857	if (internalPrefix.length > 0) return;
858
859	tempNames = computeBaseTypeNames(baseName, isConstantField, excluded);
860	} else {
861	// compute variable name for non base type
862	tempNames = computeNonBaseTypeNames(baseName, isConstantField);
863	}
864	} else {
865	tempNames = new char[][]{baseName};
866	}
867
868	boolean acceptDefaultName = true;
869	SimpleSetOfCharArray foundNames = new SimpleSetOfCharArray();
870
871	for (int i = 0; i < tempNames.length; i++) {
872	char[] tempName = tempNames[i];
873
874	// add English plural form is necessary
875	if(dim > 0) {
876	int length = tempName.length;
877
878	if (isConstantField) {
879	if (tempName[length-1] == 'S'){
880	if(tempName.length > 1 && tempName[length-2] == 'S') {
881	System.arraycopy(tempName, 0, tempName = new char[length + 2], 0, length);
882	tempName[length] = 'E';
883	tempName[length+1] = 'S';
884	}
885	} else if(tempName[length-1] == 'Y') {
886	System.arraycopy(tempName, 0, tempName = new char[length + 2], 0, length);
887	tempName[length-1] = 'I';
888	tempName[length] = 'E';
889	tempName[length+1] = 'S';
890	} else {
891	System.arraycopy(tempName, 0, tempName = new char[length + 1], 0, length);
892	tempName[length] = 'S';
893	}
894	} else {
895	if (tempName[length-1] == 's'){
896	if(tempName.length > 1 && tempName[length-2] == 's') {
897	System.arraycopy(tempName, 0, tempName = new char[length + 2], 0, length);
898	tempName[length] = 'e';
899	tempName[length+1] = 's';
900	}
901	} else if(tempName[length-1] == 'y') {
902	System.arraycopy(tempName, 0, tempName = new char[length + 2], 0, length);
903	tempName[length-1] = 'i';
904	tempName[length] = 'e';
905	tempName[length+1] = 's';
906	} else {
907	System.arraycopy(tempName, 0, tempName = new char[length + 1], 0, length);
908	tempName[length] = 's';
909	}
910	}
911	}
912
913	char[] unprefixedName = tempName;
914
915	int matchingIndex = -1;
916	if (!isConstantField) {
917	unprefixedName[0] = ScannerHelper.toUpperCase(unprefixedName[0]);
918
919	done : for (int j = 0; j <= internalPrefix.length; j++) {
920	if(j == internalPrefix.length \|\|
921	CharOperation.prefixEquals(CharOperation.subarray(internalPrefix, j, -1), unprefixedName, j != 0 /do not check case when there is no prefix/)) {
922	matchingIndex = j;
923	break done;
924	}
925	}
926	} else {
927	done : for (int j = 0; j <= internalPrefix.length; j++) {
928	if(j == internalPrefix.length) {
929	matchingIndex = j;
930	break done;
931	} else if(CharOperation.prefixEquals(CharOperation.subarray(internalPrefix, j, -1), unprefixedName, j != 0 /do not check case when there is no prefix/)) {
932	if (j == 0 \|\| internalPrefix[j - 1] == '_') {
933	matchingIndex = j;
934	break done;
935	}
936
937	}
938	}
939	}
940
941	if(matchingIndex > -1) {
942	if (!isConstantField) {
943	tempName = CharOperation.concat(CharOperation.subarray(internalPrefix, 0, matchingIndex), unprefixedName);
944	if(matchingIndex == 0) tempName[0] = ScannerHelper.toLowerCase(tempName[0]);
945	} else {
946	if(matchingIndex != 0 && tempName[0] != '_' && internalPrefix[matchingIndex - 1] != '_') {
947	tempName = CharOperation.concat(CharOperation.subarray(CharOperation.toUpperCase(internalPrefix), 0, matchingIndex), unprefixedName, '_');
948	} else {
949	tempName = CharOperation.concat(CharOperation.subarray(CharOperation.toUpperCase(internalPrefix), 0, matchingIndex), unprefixedName);
950	}
951	}
952
953	for (int k = 0; k < prefixes.length; k++) {
954	if (!isConstantField) {
955	if(prefixes[k].length > 0
956	&& ScannerHelper.isLetterOrDigit(prefixes[k][prefixes[k].length - 1])) {
957	tempName[0] = ScannerHelper.toUpperCase(tempName[0]);
958	} else {
959	tempName[0] = ScannerHelper.toLowerCase(tempName[0]);
960	}
961	}
962	char[] prefixName = CharOperation.concat(prefixes[k], tempName);
963	for (int l = 0; l < suffixes.length; l++) {
964	char[] suffixName = CharOperation.concat(prefixName, suffixes[l]);
965	suffixName =
966	excludeNames(
967	suffixName,
968	prefixName,
969	suffixes[l],
970	excluded);
971	try{
972	nameScanner.setSource(suffixName);
973	switch (nameScanner.getNextToken()) {
974	case TerminalTokens.TokenNameIdentifier :
975	int token = nameScanner.getNextToken();
976	if (token == TerminalTokens.TokenNameEOF && nameScanner.startPosition == suffixName.length) {
977	if (!foundNames.includes(suffixName)) {
978	acceptName(suffixName, prefixes[k], suffixes[l], k == 0, l == 0, internalPrefix.length - matchingIndex, requestor);
979	foundNames.add(suffixName);
980	acceptDefaultName = false;
981	}
982	}
983	break;
984	default:
985	suffixName = CharOperation.concat(
986	prefixName,
987	String.valueOf(1).toCharArray(),
988	suffixes[l]
989	);
990	suffixName =
991	excludeNames(
992	suffixName,
993	prefixName,
994	suffixes[l],
995	excluded);
996	nameScanner.setSource(suffixName);
997	switch (nameScanner.getNextToken()) {
998	case TerminalTokens.TokenNameIdentifier :
999	token = nameScanner.getNextToken();
1000	if (token == TerminalTokens.TokenNameEOF && nameScanner.startPosition == suffixName.length) {
1001	if (!foundNames.includes(suffixName)) {
1002	acceptName(suffixName, prefixes[k], suffixes[l], k == 0, l == 0, internalPrefix.length - matchingIndex, requestor);
1003	foundNames.add(suffixName);
1004	acceptDefaultName = false;
1005	}
1006	}
1007	}
1008	}
1009	} catch(InvalidInputException e){
1010	// ignore
1011	}
1012	}
1013	}
1014	}
1015	}
1016	// if no names were found
1017	if(evaluateDefault && acceptDefaultName) {
1018	char[] name = excludeNames(DEFAULT_NAME, DEFAULT_NAME, CharOperation.NO_CHAR, excluded);
1019	requestor.acceptNameWithoutPrefixAndSuffix(name, 0);
1020	}
1021	}
433	}	1022	}