/**
* Get the shortest possible name of the a class. If there is no conflict, the class is first
* imported, and only the simple class is returned; otherwise, the its full name is returned.
*
* @param name The full class name. It must not be the name of an array type.
* @param state The state of the type analyzer.
* @param root The root of the AST. If there is no conflict and the class has not been imported
* yet, a new {@link ImportDeclaration} is added to it.
* @return The shortest possible class name.
*/
private static String _getNonarrayClassName(
String name, TypeAnalyzerState state, CompilationUnit root) {
LocalClassLoader loader = state.getClassLoader();
int lastDot = name.lastIndexOf('.');
String packageName = (lastDot == -1) ? "" : name.substring(0, lastDot);
String className = name.substring(lastDot + 1);
String simpleName;
int lastSeparator = lastIndexOf(name, new char[] {'.', '$'});
if (lastSeparator == -1) {
return name;
} else {
simpleName = name.substring(lastSeparator + 1);
}
String currentClassName = state.getCurrentClass().getName();
if (name.equals(currentClassName)) {
return simpleName;
} else {
int dollarPos = currentClassName.length();
while (dollarPos >= 0) {
String baseName = currentClassName.substring(0, dollarPos) + "$";
if (name.startsWith(baseName)) {
return name.substring(baseName.length());
}
dollarPos = currentClassName.lastIndexOf('$', dollarPos - 1);
}
}
Iterator importedClasses = loader.getImportedClasses().iterator();
while (importedClasses.hasNext()) {
ClassImport importedClass = (ClassImport) importedClasses.next();
if (importedClass.getPackageName().equals(packageName)
&& importedClass.getClassName().equals(className)) {
// Already imported.
return simpleName;
} else {
String importedName = importedClass.getClassName();
int lastDollar = importedName.lastIndexOf('$');
if ((lastDollar == -1) && importedName.equals(simpleName)) {
return name;
} else if ((lastDollar >= 0) && importedName.substring(lastDollar + 1).equals(simpleName)) {
return name;
}
}
}
Iterator importedPackages = loader.getImportedPackages().iterator();
while (importedPackages.hasNext()) {
String importedPackage = (String) importedPackages.next();
if (importedPackage.equals(packageName)) { // Already imported.
return simpleName;
} else {
try {
// Test if a class with the same name exists in the
// package.
loader.loadClass(importedPackage + "." + simpleName);
// If exists, conflict.
return name;
} catch (ClassNotFoundException e) {
}
}
}
AST ast = root.getAST();
ImportDeclaration declaration = ast.newImportDeclaration();
declaration.setName(createName(ast, name));
root.imports().add(declaration);
loader.importClass(name);
return simpleName;
}
@SuppressWarnings("unchecked")
@Before
public void setUp() {
manager = ModelManager.getInstance();
manager.clearModel();
AST ast2 = AST.newAST(AST.JLS3);
CompilationUnit cu2 = ast2.newCompilationUnit();
PackageDeclaration pack2 = ast2.newPackageDeclaration();
pack2.setName(ast2.newName("be.ac.ua.test.otherpack"));
cu2.setPackage(pack2);
TypeDeclaration type2 = ast2.newTypeDeclaration();
type2.setName(ast2.newSimpleName("Foo"));
cu2.types().add(type2); // created mock compilationunit containing package and class
PackageRecorder prec2 = new PackageRecorder(pack2);
prec2.storeChange(new Add()); // store the package addition
ClassRecorder crec2 = new ClassRecorder(type2);
declaredclassadd = new Add();
crec2.storeChange(declaredclassadd);
AST ast = AST.newAST(AST.JLS3);
CompilationUnit cu = ast.newCompilationUnit();
PackageDeclaration pack = ast.newPackageDeclaration();
pack.setName(ast.newName(packname));
cu.setPackage(pack);
TypeDeclaration type = ast.newTypeDeclaration();
type.setName(ast.newSimpleName(classname));
cu.types().add(type);
PackageRecorder prec = new PackageRecorder(pack);
prec.storeChange(new Add()); // store the package addition
ClassRecorder crec = new ClassRecorder(type);
classadd = new Add();
crec.storeChange(classadd);
// Class and package created and changes logged, now create the Field.
VariableDeclarationFragment frag1 = ast.newVariableDeclarationFragment();
frag1.setName(ast.newSimpleName(intfieldname));
FieldDeclaration field = ast.newFieldDeclaration(frag1);
field.setType(ast.newPrimitiveType(PrimitiveType.INT)); // field has type int
type.bodyDeclarations().add(field);
VariableDeclarationFragment frag2 = ast.newVariableDeclarationFragment();
frag2.setName(ast.newSimpleName(fieldname));
FieldDeclaration field2 = ast.newFieldDeclaration(frag2);
field2.setType(ast.newSimpleType(ast.newName(declaredTypeName))); // field has type Foo
type.bodyDeclarations().add(field2);
VariableDeclarationFragment frag3 = ast.newVariableDeclarationFragment();
frag3.setName(ast.newSimpleName(field3Name));
FieldDeclaration field3 = ast.newFieldDeclaration(frag3);
field3.setType(ast.newSimpleType(ast.newName("Foo"))); // field has type Foo
type.bodyDeclarations().add(field3);
ImportDeclaration imp = ast.newImportDeclaration();
imp.setName(ast.newName(declaredTypeName));
cu.imports().add(imp);
// created mock compilationunit containing package and class
recorder1 = new FieldRecorder(field);
recorder2 = new FieldRecorder(field2);
recorder3 = new FieldRecorder(field3);
}
