/**
* Ensures that creating a DOM AST and computing the bindings takes the owner's working copies
* into account.
*
* @deprecated using deprecated code
*/
public void testParseCompilationUnit3() throws CoreException {
try {
createJavaProject("P1", new String[] {"src"}, new String[] {"JCL_LIB", "lib"}, "bin");
// create X.class in lib folder
/* Evaluate the following in a scrapbook:
org.eclipse.jdt.core.tests.model.ModifyingResourceTests.generateClassFile(
"X",
"public class X {\n" +
"}")
*/
byte[] bytes =
new byte[] {
-54, -2, -70, -66, 0, 3, 0, 45, 0, 13, 1, 0, 1, 88, 7, 0, 1, 1, 0, 16, 106, 97, 118, 97,
47, 108, 97, 110, 103, 47, 79, 98, 106, 101, 99, 116, 7, 0, 3, 1, 0, 6, 60, 105,
110, 105, 116, 62, 1, 0, 3, 40, 41, 86, 1, 0, 4, 67, 111, 100, 101, 12, 0, 5, 0, 6,
10, 0, 4, 0, 8, 1, 0, 15, 76, 105, 110, 101, 78, 117,
109, 98, 101, 114, 84, 97, 98, 108, 101, 1, 0, 10, 83, 111, 117, 114, 99, 101, 70, 105,
108, 101, 1, 0, 6, 88, 46, 106, 97, 118, 97, 0, 33, 0, 2, 0, 4, 0, 0, 0, 0, 0, 1, 0,
1, 0, 5, 0, 6, 0, 1, 0, 7, 0, 0, 0, 29, 0, 1, 0, 1, 0, 0, 0, 5, 42, -73, 0, 9, -79,
0, 0, 0, 1, 0, 10, 0, 0, 0, 6,
0, 1, 0, 0, 0, 1, 0, 1, 0, 11, 0, 0, 0, 2, 0, 12,
};
this.createFile("P1/lib/X.class", bytes);
// create libsrc and attach source
createFolder("P1/libsrc");
createFile("P1/libsrc/X.java", "public class X extends Y {\n" + "}");
IPackageFragmentRoot lib = getPackageFragmentRoot("P1/lib");
lib.attachSource(new Path("/P1/libsrc"), null, null);
// create Y.java in src folder
createFile("P1/src/Y.java", "");
// create working copy on Y.java
TestWorkingCopyOwner owner = new TestWorkingCopyOwner();
this.workingCopy = getCompilationUnit("P1/src/Y.java").getWorkingCopy(owner, null);
this.workingCopy.getBuffer().setContents("public class Y {\n" + "}");
this.workingCopy.makeConsistent(null);
// parse and resolve class file
IClassFile classFile = getClassFile("P1/lib/X.class");
ASTParser parser = ASTParser.newParser(AST.JLS2);
parser.setSource(classFile);
parser.setResolveBindings(true);
parser.setWorkingCopyOwner(owner);
CompilationUnit cu = (CompilationUnit) parser.createAST(null);
List types = cu.types();
assertEquals("Unexpected number of types in AST", 1, types.size());
TypeDeclaration type = (TypeDeclaration) types.get(0);
ITypeBinding typeBinding = type.resolveBinding();
ITypeBinding superType = typeBinding.getSuperclass();
assertEquals(
"Unexpected super type",
"Y",
superType == null ? "<null>" : superType.getQualifiedName());
} finally {
deleteProject("P1");
}
}
public boolean visit(TypeDeclaration type) throws Exception {
if (type instanceof NamespaceDeclaration) {
NamespaceDeclaration namespaceDecl = (NamespaceDeclaration) type;
fLastNamespace = namespaceDecl;
fLastUseParts.clear();
if (namespaceDecl.isGlobal()) {
return true;
}
}
type.setModifiers(markAsDeprecated(type.getModifiers(), type));
// In case we are entering a nested element
if (!declarations.empty() && declarations.peek() instanceof MethodDeclaration) {
if (fLastNamespace == null) {
deferredDeclarations.add(type);
} else {
deferredNamespacedDeclarations.add(type);
}
return false;
}
declarations.push(type);
for (PHPSourceElementRequestorExtension visitor : extensions) {
visitor.visit(type);
}
return super.visit(type);
}
/**
* Ensures that creating a DOM AST and computing the bindings takes the owner's working copies
* into account. (regression test for bug 39533 Working copy with no corresponding file not
* considered by NameLookup)
*
* @deprecated using deprecated code
*/
public void testParseCompilationUnit1() throws CoreException {
ICompilationUnit workingCopy1 = null;
ICompilationUnit workingCopy2 = null;
try {
TestWorkingCopyOwner owner = new TestWorkingCopyOwner();
workingCopy1 = getCompilationUnit("P/X.java").getWorkingCopy(owner, null);
workingCopy1.getBuffer().setContents("public class X implements I {\n" + "}");
workingCopy1.makeConsistent(null);
workingCopy2 = getCompilationUnit("P/I.java").getWorkingCopy(owner, null);
workingCopy2.getBuffer().setContents("public interface I {\n" + "}");
workingCopy2.makeConsistent(null);
ASTParser parser = ASTParser.newParser(AST.JLS2);
parser.setSource(workingCopy1);
parser.setResolveBindings(true);
parser.setWorkingCopyOwner(owner);
CompilationUnit cu = (CompilationUnit) parser.createAST(null);
List types = cu.types();
assertEquals("Unexpected number of types in AST", 1, types.size());
TypeDeclaration type = (TypeDeclaration) types.get(0);
ITypeBinding typeBinding = type.resolveBinding();
assertTypeBindingsEqual("Unexpected interfaces", "I", typeBinding.getInterfaces());
} finally {
if (workingCopy1 != null) {
workingCopy1.discardWorkingCopy();
}
if (workingCopy2 != null) {
workingCopy2.discardWorkingCopy();
}
}
}
public void createPackageInfoType() {
TypeDeclaration declaration = new TypeDeclaration(this.compilationResult);
declaration.name = TypeConstants.PACKAGE_INFO_NAME;
declaration.modifiers = ClassFileConstants.AccDefault | ClassFileConstants.AccInterface;
declaration.javadoc = this.javadoc;
this.types[0] = declaration; // Assumes the first slot is meant for this type
}
public void resolve(int start, int end) {
try {
int startingTypeIndex = 0;
// resolve compilation unit javadoc package if any
if (this.javadoc != null
&& this.javadoc.sourceStart <= start
&& this.javadoc.sourceEnd >= end) {
this.javadoc.resolve(this.scope);
}
if (types != null) {
for (int i = startingTypeIndex, count = types.length; i < count; i++) {
TypeDeclaration typeDeclaration = types[i];
if (typeDeclaration.sourceStart <= start && typeDeclaration.sourceEnd >= end)
typeDeclaration.resolve(scope);
}
}
if (statements != null) {
for (int i = 0, count = statements.length; i < count; i++) {
ProgramElement programElement = statements[i];
if (programElement.sourceStart <= start && programElement.sourceEnd >= end)
programElement.resolve(scope);
}
}
reportNLSProblems();
} catch (AbortCompilationUnit e) {
this.ignoreFurtherInvestigation = true;
return;
}
}
public void process() {
for (TypeDeclaration typeDecl : env.getSpecifiedTypeDeclarations()) {
ExtractInterface annot = typeDecl.getAnnotation(ExtractInterface.class);
if (annot == null) break;
for (MethodDeclaration m : typeDecl.getMethods())
if (m.getModifiers().contains(Modifier.PUBLIC)
&& !(m.getModifiers().contains(Modifier.STATIC))) interfaceMethods.add(m);
if (interfaceMethods.size() > 0) {
try {
PrintWriter writer = env.getFiler().createSourceFile(annot.value());
writer.println("package " + typeDecl.getPackage().getQualifiedName() + ";");
writer.println("public interface " + annot.value() + " {");
for (MethodDeclaration m : interfaceMethods) {
writer.print(" public ");
writer.print(m.getReturnType() + " ");
writer.print(m.getSimpleName() + " (");
int i = 0;
for (ParameterDeclaration parm : m.getParameters()) {
writer.print(parm.getType() + " " + parm.getSimpleName());
if (++i < m.getParameters().size()) writer.print(", ");
}
writer.println(");");
}
writer.println("}");
writer.close();
} catch (IOException ioe) {
throw new RuntimeException(ioe);
}
}
}
}
/*
* Ensures that no bindings are created when reconciling a new working copy with no resource.
*/
public void testNewWorkingCopy07() throws CoreException {
this.workingCopy = newExternalWorkingCopy("X.java", "public class X {\n" + "}");
this.workingCopy.getBuffer().setContents("public class X {\n" + " int field;\n" + "}");
CompilationUnit ast =
this.workingCopy.reconcile(JLS3_INTERNAL, true /*force resolution*/, null, null);
TypeDeclaration type = (TypeDeclaration) ast.types().get(0);
assertNull("Unexpected binding", type.resolveBinding());
}
public void resolve() {
int startingTypeIndex = 0;
boolean isPackageInfo = false; // isPackageInfo();
if (this.types != null && isPackageInfo) {
// resolve synthetic type declaration
final TypeDeclaration syntheticTypeDeclaration = types[0];
// set empty javadoc to avoid missing warning (see bug
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=95286)
if (syntheticTypeDeclaration.javadoc == null) {
syntheticTypeDeclaration.javadoc =
new Javadoc(
syntheticTypeDeclaration.declarationSourceStart,
syntheticTypeDeclaration.declarationSourceStart);
}
syntheticTypeDeclaration.resolve(this.scope);
// resolve annotations if any
// if (this.currentPackage!= null && this.currentPackage.annotations != null) {
// resolveAnnotations(syntheticTypeDeclaration.staticInitializerScope,
// this.currentPackage.annotations, this.scope.getDefaultPackage());
// }
// resolve javadoc package if any
if (this.javadoc != null) {
this.javadoc.resolve(syntheticTypeDeclaration.staticInitializerScope);
}
startingTypeIndex = 1;
} else {
// resolve compilation unit javadoc package if any
if (this.javadoc != null) {
this.javadoc.resolve(this.scope);
}
}
try {
if (types != null) {
for (int i = startingTypeIndex, count = types.length; i < count; i++) {
types[i].resolve(scope);
}
}
if (statements != null) {
for (int i = 0, count = statements.length; i < count; i++) {
statements[i].resolve(scope);
}
}
reportNLSProblems();
} catch (AbortCompilationUnit e) {
this.ignoreFurtherInvestigation = true;
return;
}
}
public void resolve() {
int startingTypeIndex = 0;
boolean isPackageInfo = isPackageInfo();
if (this.types != null && isPackageInfo) {
// resolve synthetic type declaration
final TypeDeclaration syntheticTypeDeclaration = this.types[0];
// set empty javadoc to avoid missing warning (see bug
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=95286)
if (syntheticTypeDeclaration.javadoc == null) {
syntheticTypeDeclaration.javadoc =
new Javadoc(
syntheticTypeDeclaration.declarationSourceStart,
syntheticTypeDeclaration.declarationSourceStart);
}
syntheticTypeDeclaration.resolve(this.scope);
/*
* resolve javadoc package if any, skip this step if we don't have a valid scope due to an earlier error (bug 252555)
* we do it now as the javadoc in the fake type won't be resolved. The peculiar usage of MethodScope to resolve the
* package level javadoc is because the CU level resolve method is a NOP to mimic Javadoc's behavior and can't be used
* as such.
*/
if (this.javadoc != null && syntheticTypeDeclaration.staticInitializerScope != null) {
this.javadoc.resolve(syntheticTypeDeclaration.staticInitializerScope);
}
startingTypeIndex = 1;
} else {
// resolve compilation unit javadoc package if any
if (this.javadoc != null) {
this.javadoc.resolve(this.scope);
}
}
if (this.currentPackage != null && this.currentPackage.annotations != null && !isPackageInfo) {
this.scope
.problemReporter()
.invalidFileNameForPackageAnnotations(this.currentPackage.annotations[0]);
}
try {
if (this.types != null) {
for (int i = startingTypeIndex, count = this.types.length; i < count; i++) {
this.types[i].resolve(this.scope);
}
}
if (!this.compilationResult.hasMandatoryErrors()) checkUnusedImports();
reportNLSProblems();
} catch (AbortCompilationUnit e) {
this.ignoreFurtherInvestigation = true;
return;
}
}
/** Generates a dex file and returns its bytes. */
public byte[] generate() {
DexOptions options = new DexOptions();
options.targetApiLevel = DexFormat.API_NO_EXTENDED_OPCODES;
DexFile outputDex = new DexFile(options);
for (TypeDeclaration typeDeclaration : types.values()) {
outputDex.add(typeDeclaration.toClassDefItem());
}
try {
return outputDex.toDex(null, false);
} catch (IOException e) {
throw new RuntimeException(e);
}
}
@Override
public void process(CompilationUnitDeclaration cud, int i) {
super.process(cud, i);
ClassFile[] classFiles = cud.compilationResult().getClassFiles();
Map<ClassFile, CompiledClass> results = new LinkedHashMap<ClassFile, CompiledClass>();
for (ClassFile classFile : classFiles) {
createCompiledClass(classFile, results);
}
List<CompiledClass> compiledClasses = new ArrayList<CompiledClass>(results.values());
addBinaryTypes(compiledClasses);
ICompilationUnit icu = cud.compilationResult().compilationUnit;
Adapter adapter = (Adapter) icu;
CompilationUnitBuilder builder = adapter.getBuilder();
// TODO this code was added for the arquillian gwt extension
if (cud.types != null) {
for (TypeDeclaration type : cud.types) {
if (type.methods != null) {
if (isAnnotationPresent(RunWith.class.getSimpleName(), type.annotations)) {
Set<AbstractMethodDeclaration> filteredMethods =
new HashSet<AbstractMethodDeclaration>();
boolean match = false;
for (AbstractMethodDeclaration decl : type.methods) {
if (decl.annotations != null) {
// TODO make this configurable
if ((isAnnotationPresent(RunAsGwtClient.class.getSimpleName(), decl.annotations)
|| isAnnotationPresent(
RunAsGwtClient.class.getSimpleName(), type.annotations))
&& !isAnnotationPresent(Deployment.class.getSimpleName(), decl.annotations)) {
filteredMethods.add(decl);
} else {
match = true;
System.out.println("Ignoring non-translatable method:\n" + decl.toString());
}
}
}
if (match) {
type.methods =
filteredMethods.toArray(new AbstractMethodDeclaration[filteredMethods.size()]);
}
}
}
}
}
processor.process(builder, cud, compiledClasses);
}
protected void classInstanceCreation(boolean alwaysQualified) {
// ClassInstanceCreationExpression ::= 'new' ClassType '(' ArgumentListopt ')' ClassBodyopt
// ClassBodyopt produces a null item on the astStak if it produces NO class body
// An empty class body produces a 0 on the length stack.....
AllocationExpression alloc;
int length;
if (((length = this.astLengthStack[this.astLengthPtr--]) == 1)
&& (this.astStack[this.astPtr] == null)) {
// NO ClassBody
this.astPtr--;
if (alwaysQualified) {
alloc = new QualifiedAllocationExpression();
} else {
alloc = new CodeSnippetAllocationExpression(this.evaluationContext);
}
alloc.sourceEnd = this.endPosition; // the position has been stored explicitly
if ((length = this.expressionLengthStack[this.expressionLengthPtr--]) != 0) {
this.expressionPtr -= length;
System.arraycopy(
this.expressionStack,
this.expressionPtr + 1,
alloc.arguments = new Expression[length],
0,
length);
}
alloc.type = getTypeReference(0);
// the default constructor with the correct number of argument
// will be created and added by the TC (see createsInternalConstructorWithBinding)
alloc.sourceStart = this.intStack[this.intPtr--];
pushOnExpressionStack(alloc);
} else {
dispatchDeclarationInto(length);
TypeDeclaration anonymousTypeDeclaration = (TypeDeclaration) this.astStack[this.astPtr];
anonymousTypeDeclaration.declarationSourceEnd = this.endStatementPosition;
if (anonymousTypeDeclaration.allocation != null) {
anonymousTypeDeclaration.allocation.sourceEnd = this.endStatementPosition;
}
this.astPtr--;
this.astLengthPtr--;
// mark initializers with local type mark if needed
markInitializersWithLocalType(anonymousTypeDeclaration);
}
}
private static String loadPath(TypeDeclaration delegate) {
Path path = delegate.getAnnotation(Path.class);
if (path == null) {
throw new IllegalArgumentException(
"A JAX-RS root resource must be annotated with @javax.ws.rs.Path.");
}
return path.value();
}
private void resolveReferences(TypeDeclaration typeDeclaration)
throws UnresolvableReferenceException {
LOG.logDebug(
"Resolving references in type declaration '"
+ typeDeclaration.getName().getLocalName()
+ "'.");
if (typeDeclaration instanceof SimpleTypeDeclaration) {
LOG.logDebug("SimpleType.");
SimpleTypeDeclaration simpleType = (SimpleTypeDeclaration) typeDeclaration;
TypeReference typeReference = simpleType.getRestrictionBaseType();
if (typeReference != null) {
LOG.logDebug("restriction base='" + typeReference.getName() + "'");
try {
resolveType(typeReference);
} catch (XMLSchemaException e) {
throw new UndefinedXSDTypeException(
"Declaration of type '"
+ typeDeclaration.getName()
+ "' derives type '"
+ typeReference.getName()
+ "' which is not a defined simple type.");
}
}
} else {
LOG.logDebug("ComplexType.");
ComplexTypeDeclaration complexType = (ComplexTypeDeclaration) typeDeclaration;
TypeReference typeReference = complexType.getExtensionBaseType();
if (typeReference != null) {
LOG.logDebug("extension base='" + typeReference.getName() + "'");
try {
resolveType(typeReference);
} catch (XMLSchemaException e) {
throw new UndefinedXSDTypeException(
"Declaration of type '"
+ typeDeclaration.getName()
+ "' derives type '"
+ typeReference.getName()
+ "' which is not a defined complex type.");
}
}
ElementDeclaration[] elements = complexType.getExplicitElements();
for (int i = 0; i < elements.length; i++) {
resolveReferences(elements[i]);
}
}
}
@Override
public String toString() {
return "Import["
+ alias
+ "="
+ (typeDeclaration == null ? "" : typeDeclaration.getName())
+ declaration.getName()
+ "]";
}
public List<String> generateJavaCode() throws IOException {
List<String> generatedFiles = new ArrayList<String>();
String header = this.getHeaderCode("");
for (Iterator<TypeDeclaration> it = typeDeclarations.iterator(); it.hasNext(); ) {
TypeDeclaration td = it.next();
if (td instanceof BehaviorDeclaration) {
BehaviorDeclaration bd = (BehaviorDeclaration) td;
String refFileName = sourceDirName + File.separator + bd.getName() + ".java";
writeFile(refFileName, header + bd.toJavaRefCode(""));
String stateFileName = sourceDirName + File.separator + td.getName() + "State.java";
writeFile(stateFileName, header + bd.toJavaCode(""));
generatedFiles.add(refFileName);
generatedFiles.add(stateFileName);
} else if (td instanceof ClassDeclaration) {
String classFileName = sourceDirName + File.separator + td.getName() + ".java";
writeFile(classFileName, header + td.toJavaCode(""));
generatedFiles.add(classFileName);
}
}
return generatedFiles;
}
/**
* Visits a type declaration.
*
* @param d the declaration to visit
*/
public void visitTypeDeclaration(TypeDeclaration d) {
d.accept(pre);
SortedSet<Declaration> decls = new TreeSet<Declaration>(SourceOrderDeclScanner.comparator);
for (TypeParameterDeclaration tpDecl : d.getFormalTypeParameters()) {
decls.add(tpDecl);
}
for (FieldDeclaration fieldDecl : d.getFields()) {
decls.add(fieldDecl);
}
for (MethodDeclaration methodDecl : d.getMethods()) {
decls.add(methodDecl);
}
for (TypeDeclaration typeDecl : d.getNestedTypes()) {
decls.add(typeDecl);
}
for (Declaration decl : decls) decl.accept(this);
d.accept(post);
}
/**
* Ensures that creating a DOM AST and computing the bindings takes the owner's working copies
* into account.
*
* @deprecated using deprecated code
*/
public void testParseCompilationUnit2() throws CoreException {
TestWorkingCopyOwner owner = new TestWorkingCopyOwner();
this.workingCopy = getCompilationUnit("P/Y.java").getWorkingCopy(owner, null);
this.workingCopy.getBuffer().setContents("public class Y {\n" + "}");
this.workingCopy.makeConsistent(null);
char[] source = ("public class Z extends Y {\n" + "}").toCharArray();
ASTParser parser = ASTParser.newParser(AST.JLS2);
parser.setSource(source);
parser.setUnitName("Z.java");
parser.setProject(getJavaProject("P"));
parser.setWorkingCopyOwner(owner);
parser.setResolveBindings(true);
CompilationUnit cu = (CompilationUnit) parser.createAST(null);
List types = cu.types();
assertEquals("Unexpected number of types in AST", 1, types.size());
TypeDeclaration type = (TypeDeclaration) types.get(0);
ITypeBinding typeBinding = type.resolveBinding();
assertNotNull("No binding", typeBinding);
assertEquals("Unexpected super type", "Y", typeBinding.getSuperclass().getQualifiedName());
}
protected String[] processSuperClasses(TypeDeclaration type) {
ASTListNode superClasses = type.getSuperClasses();
if (superClasses == null) {
return new String[] {};
}
List<ASTNode> superClassNames = superClasses.getChilds();
List<String> result = new ArrayList<String>(superClassNames.size());
Iterator<ASTNode> iterator = superClassNames.iterator();
while (iterator.hasNext()) {
String name = processNameNode(iterator.next());
if (name != null) {
result.add(name);
}
}
return (String[]) result.toArray(new String[result.size()]);
}
/**
* Declares {@code type}.
*
* @param flags a bitwise combination of {@link Modifier#PUBLIC}, {@link Modifier#FINAL} and
* {@link Modifier#ABSTRACT}.
*/
public void declare(
TypeId<?> type, String sourceFile, int flags, TypeId<?> supertype, TypeId<?>... interfaces) {
TypeDeclaration declaration = getTypeDeclaration(type);
int supportedFlags = Modifier.PUBLIC | Modifier.FINAL | Modifier.ABSTRACT;
if ((flags & ~supportedFlags) != 0) {
throw new IllegalArgumentException("Unexpected flag: " + Integer.toHexString(flags));
}
if (declaration.declared) {
throw new IllegalStateException("already declared: " + type);
}
declaration.declared = true;
declaration.flags = flags;
declaration.supertype = supertype;
declaration.sourceFile = sourceFile;
declaration.interfaces = new TypeList(interfaces);
}
/*
* @see ASTVisitor#visit(TypeDeclaration)
*/
@Override
public boolean visit(TypeDeclaration node) {
if (node.getJavadoc() != null) {
node.getJavadoc().accept(this);
}
if (node.getAST().apiLevel() >= JLS3) {
printModifiers(node.modifiers());
}
this.fBuffer.append(node.isInterface() ? "interface " : "class "); // $NON-NLS-2$//$NON-NLS-1$
node.getName().accept(this);
if (node.getAST().apiLevel() >= JLS3) {
if (!node.typeParameters().isEmpty()) {
this.fBuffer.append("<"); // $NON-NLS-1$
for (Iterator<TypeParameter> it = node.typeParameters().iterator(); it.hasNext(); ) {
TypeParameter t = it.next();
t.accept(this);
if (it.hasNext()) {
this.fBuffer.append(","); // $NON-NLS-1$
}
}
this.fBuffer.append(">"); // $NON-NLS-1$
}
}
this.fBuffer.append(" "); // $NON-NLS-1$
if (node.getAST().apiLevel() >= JLS3) {
if (node.getSuperclassType() != null) {
this.fBuffer.append("extends "); // $NON-NLS-1$
node.getSuperclassType().accept(this);
this.fBuffer.append(" "); // $NON-NLS-1$
}
if (!node.superInterfaceTypes().isEmpty()) {
this.fBuffer.append(
node.isInterface() ? "extends " : "implements "); // $NON-NLS-2$//$NON-NLS-1$
for (Iterator<Type> it = node.superInterfaceTypes().iterator(); it.hasNext(); ) {
Type t = it.next();
t.accept(this);
if (it.hasNext()) {
this.fBuffer.append(", "); // $NON-NLS-1$
}
}
this.fBuffer.append(" "); // $NON-NLS-1$
}
}
this.fBuffer.append("{"); // $NON-NLS-1$
BodyDeclaration prev = null;
for (Iterator<BodyDeclaration> it = node.bodyDeclarations().iterator(); it.hasNext(); ) {
BodyDeclaration d = it.next();
if (prev instanceof EnumConstantDeclaration) {
// enum constant declarations do not include punctuation
if (d instanceof EnumConstantDeclaration) {
// enum constant declarations are separated by commas
this.fBuffer.append(", "); // $NON-NLS-1$
} else {
// semicolon separates last enum constant declaration from
// first class body declarations
this.fBuffer.append("; "); // $NON-NLS-1$
}
}
d.accept(this);
prev = d;
}
this.fBuffer.append("}"); // $NON-NLS-1$
return false;
}
/*
* Returns the handles of the super interfaces of the given type.
* Adds the simple name to the hierarchy missing types if an interface is not found (but don't put null in the returned array)
*/
private IType[] findSuperInterfaces(IGenericType type, ReferenceBinding typeBinding) {
char[][] superInterfaceNames;
char separator;
if (type instanceof IBinaryType) {
superInterfaceNames = ((IBinaryType) type).getInterfaceNames();
separator = '/';
} else if (type instanceof ISourceType) {
ISourceType sourceType = (ISourceType) type;
if (sourceType.isAnonymous()) { // if anonymous type
if (typeBinding.superInterfaces() != null && typeBinding.superInterfaces().length > 0) {
superInterfaceNames = new char[][] {sourceType.getSuperclassName()};
} else {
superInterfaceNames = sourceType.getInterfaceNames();
}
} else {
if (TypeDeclaration.kind(sourceType.getModifiers()) == TypeDeclaration.ANNOTATION_TYPE_DECL)
superInterfaceNames =
new char[][] {TypeConstants.CharArray_JAVA_LANG_ANNOTATION_ANNOTATION};
else superInterfaceNames = sourceType.getInterfaceNames();
}
separator = '.';
} else if (type instanceof HierarchyType) {
HierarchyType hierarchyType = (HierarchyType) type;
if (hierarchyType.isAnonymous()) { // if anonymous type
if (typeBinding.superInterfaces() != null && typeBinding.superInterfaces().length > 0) {
superInterfaceNames = new char[][] {hierarchyType.superclassName};
} else {
superInterfaceNames = hierarchyType.superInterfaceNames;
}
} else {
superInterfaceNames = hierarchyType.superInterfaceNames;
}
separator = '.';
} else {
return null;
}
ReferenceBinding[] interfaceBindings = typeBinding.superInterfaces();
int bindingIndex = 0;
int bindingLength = interfaceBindings == null ? 0 : interfaceBindings.length;
int length = superInterfaceNames == null ? 0 : superInterfaceNames.length;
IType[] superinterfaces = new IType[length];
int index = 0;
next:
for (int i = 0; i < length; i++) {
char[] superInterfaceName = superInterfaceNames[i];
int end = superInterfaceName.length;
// find the end of simple name
int genericStart = CharOperation.indexOf(Signature.C_GENERIC_START, superInterfaceName);
if (genericStart != -1) end = genericStart;
// find the start of simple name
int lastSeparator = CharOperation.lastIndexOf(separator, superInterfaceName, 0, end);
int start = lastSeparator + 1;
// case of binary inner type -> take the last part
int lastDollar = CharOperation.lastIndexOf('$', superInterfaceName, start);
if (lastDollar != -1) start = lastDollar + 1;
char[] simpleName = CharOperation.subarray(superInterfaceName, start, end);
if (bindingIndex < bindingLength) {
ReferenceBinding interfaceBinding =
(ReferenceBinding) interfaceBindings[bindingIndex].erasure();
// ensure that the binding corresponds to the interface defined by the user
if (CharOperation.equals(simpleName, interfaceBinding.sourceName)) {
bindingIndex++;
for (int t = this.typeIndex; t >= 0; t--) {
if (TypeBinding.equalsEquals(this.typeBindings[t], interfaceBinding)) {
IType handle = this.builder.getHandle(this.typeModels[t], interfaceBinding);
if (handle != null) {
superinterfaces[index++] = handle;
continue next;
}
}
}
}
}
this.builder.hierarchy.missingTypes.add(new String(simpleName));
}
if (index != length)
System.arraycopy(superinterfaces, 0, superinterfaces = new IType[index], 0, index);
return superinterfaces;
}
protected String[] processSuperClasses(TypeDeclaration type) {
ASTListNode superClasses = type.getSuperClasses();
if (superClasses == null) {
return new String[] {};
}
List<ASTNode> superClassNames = superClasses.getChilds();
List<String> result = new ArrayList<String>(superClassNames.size());
Iterator<ASTNode> iterator = superClassNames.iterator();
while (iterator.hasNext()) {
ASTNode nameNode = iterator.next();
String name;
if (nameNode instanceof FullyQualifiedReference) {
FullyQualifiedReference fullyQualifiedName = (FullyQualifiedReference) nameNode;
name = fullyQualifiedName.getFullyQualifiedName();
if (fullyQualifiedName.getNamespace() != null) {
String namespace = fullyQualifiedName.getNamespace().getName();
String subnamespace = ""; // $NON-NLS-1$
if (namespace.charAt(0) != NamespaceReference.NAMESPACE_SEPARATOR
&& namespace.indexOf(NamespaceReference.NAMESPACE_SEPARATOR) > 0) {
int firstNSLocation = namespace.indexOf(NamespaceReference.NAMESPACE_SEPARATOR);
subnamespace = namespace.substring(firstNSLocation);
namespace = namespace.substring(0, firstNSLocation);
}
if (name.charAt(0) == NamespaceReference.NAMESPACE_SEPARATOR) {
name = name.substring(1);
} else if (fLastUseParts.containsKey(namespace)) {
name =
new StringBuilder(
fLastUseParts.get(namespace).getNamespace().getFullyQualifiedName())
.append(subnamespace)
.append(NamespaceReference.NAMESPACE_SEPARATOR)
.append(fullyQualifiedName.getName())
.toString();
} else if (fCurrentNamespace != null) {
name =
new StringBuilder(fCurrentNamespace.getName())
.append(NamespaceReference.NAMESPACE_SEPARATOR)
.append(name)
.toString();
}
} else if (fLastUseParts.containsKey(name)) {
name = fLastUseParts.get(name).getNamespace().getFullyQualifiedName();
if (name.charAt(0) == NamespaceReference.NAMESPACE_SEPARATOR) {
name = name.substring(1);
}
} else {
if (fCurrentNamespace != null) {
name =
new StringBuilder(fCurrentNamespace.getName())
.append(NamespaceReference.NAMESPACE_SEPARATOR)
.append(name)
.toString();
}
}
result.add(name);
} else if (nameNode instanceof SimpleReference) {
result.add(((SimpleReference) nameNode).getName());
}
}
return (String[]) result.toArray(new String[result.size()]);
}
public boolean visit(TypeDeclaration type) throws Exception {
if (type instanceof NamespaceDeclaration) {
NamespaceDeclaration namespaceDecl = (NamespaceDeclaration) type;
fCurrentNamespace = namespaceDecl;
fLastUseParts.clear();
if (namespaceDecl.isGlobal()) {
return visitGeneral(type);
}
declarations.push(type);
int modifiers = type.getModifiers() | Modifiers.AccNameSpace;
fCurrentQualifier = type.getName();
Integer count = fCurrentQualifierCounts.get(fCurrentQualifier);
count = count != null ? count + 1 : 1;
fCurrentQualifierCounts.put(fCurrentQualifier, count);
modifiers = markAsDeprecated(modifiers, type);
StringBuilder metadata = new StringBuilder();
if (fCurrentQualifier != null) {
metadata.append(fCurrentQualifierCounts.get(fCurrentQualifier));
metadata.append(";"); // $NON-NLS-1$
}
modifyDeclaration(
type,
new DeclarationInfo(
IModelElement.PACKAGE_DECLARATION,
modifiers,
type.sourceStart(),
type.sourceEnd() - type.sourceStart(),
type.getNameStart(),
type.getNameEnd() - type.getNameStart(),
type.getName(),
metadata.length() == 0 ? null : metadata.toString(),
encodeDocInfo(type),
null,
null));
} else {
Declaration parentDeclaration = null;
if (!declarations.empty()) {
parentDeclaration = declarations.peek();
}
declarations.push(type);
if (!(parentDeclaration instanceof NamespaceDeclaration)) {
type.setModifier(Modifiers.AccGlobal);
}
// In case we are entering a nested element
if (parentDeclaration instanceof MethodDeclaration) {
if (fCurrentNamespace == null) {
deferredDeclarations.add(type);
} else {
deferredNamespacedDeclarations.add(type);
}
return visitGeneral(type);
}
int modifiers = type.getModifiers();
fCurrentParent = type.getName();
String[] superClasses = processSuperClasses(type);
StringBuilder metadata = new StringBuilder();
if (fCurrentQualifier != null) {
metadata.append(fCurrentQualifierCounts.get(fCurrentQualifier));
metadata.append(";"); // $NON-NLS-1$
}
for (int i = 0; i < superClasses.length; ++i) {
metadata.append(superClasses[i]);
if (i < superClasses.length - 1) {
metadata.append(","); // $NON-NLS-1$
}
}
modifiers = markAsDeprecated(modifiers, type);
modifyDeclaration(
type,
new DeclarationInfo(
IModelElement.TYPE,
modifiers,
type.sourceStart(),
type.sourceEnd() - type.sourceStart(),
type.getNameStart(),
type.getNameEnd() - type.getNameStart(),
type.getName(),
metadata.length() == 0 ? null : metadata.toString(),
encodeDocInfo(type),
fCurrentQualifier,
null));
}
for (PhpIndexingVisitorExtension visitor : extensions) {
visitor.visit(type);
}
return visitGeneral(type);
}
protected void consumeClassHeaderName1() {
// ClassHeaderName ::= Modifiersopt 'class' 'Identifier'
TypeDeclaration typeDecl;
if (this.nestedMethod[this.nestedType] == 0) {
if (this.nestedType != 0) {
typeDecl = new TypeDeclaration(this.compilationUnit.compilationResult);
typeDecl.bits |= ASTNode.IsMemberTypeMASK;
} else {
typeDecl = new CodeSnippetTypeDeclaration(this.compilationUnit.compilationResult);
}
} else {
// Record that the block has a declaration for local types
typeDecl = new TypeDeclaration(this.compilationUnit.compilationResult);
typeDecl.bits |= ASTNode.IsLocalTypeMASK;
markEnclosingMemberWithLocalType();
blockReal();
}
// highlight the name of the type
long pos = this.identifierPositionStack[this.identifierPtr];
typeDecl.sourceEnd = (int) pos;
typeDecl.sourceStart = (int) (pos >>> 32);
typeDecl.name = this.identifierStack[this.identifierPtr--];
this.identifierLengthPtr--;
// compute the declaration source too
typeDecl.declarationSourceStart = this.intStack[this.intPtr--];
this.intPtr--;
// 'class' and 'interface' push an int position
typeDecl.modifiersSourceStart = this.intStack[this.intPtr--];
typeDecl.modifiers = this.intStack[this.intPtr--];
if (typeDecl.modifiersSourceStart >= 0) {
typeDecl.declarationSourceStart = typeDecl.modifiersSourceStart;
}
typeDecl.bodyStart = typeDecl.sourceEnd + 1;
pushOnAstStack(typeDecl);
this.listLength = 0; // will be updated when reading super-interfaces
// recovery
if (this.currentElement != null) {
this.lastCheckPoint = typeDecl.bodyStart;
this.currentElement = this.currentElement.add(typeDecl, 0);
this.lastIgnoredToken = -1;
}
// javadoc
typeDecl.javadoc = this.javadoc;
this.javadoc = null;
}
/**
* Bytecode generation for a method
*
* @param classScope
* @param classFile
*/
public void generateCode(ClassScope classScope, ClassFile classFile) {
classFile.codeStream.wideMode = false; // reset wideMode to false
if (this.ignoreFurtherInvestigation) {
// method is known to have errors, dump a problem method
if (this.binding == null) return; // handle methods with invalid signature or duplicates
int problemsLength;
CategorizedProblem[] problems =
this.scope.referenceCompilationUnit().compilationResult.getProblems();
CategorizedProblem[] problemsCopy = new CategorizedProblem[problemsLength = problems.length];
System.arraycopy(problems, 0, problemsCopy, 0, problemsLength);
classFile.addProblemMethod(this, this.binding, problemsCopy);
return;
}
int problemResetPC = 0;
CompilationResult unitResult = null;
int problemCount = 0;
if (classScope != null) {
TypeDeclaration referenceContext = classScope.referenceContext;
if (referenceContext != null) {
unitResult = referenceContext.compilationResult();
problemCount = unitResult.problemCount;
}
}
boolean restart = false;
boolean abort = false;
// regular code generation
do {
try {
problemResetPC = classFile.contentsOffset;
this.generateCode(classFile);
restart = false;
} catch (AbortMethod e) {
// a fatal error was detected during code generation, need to restart code gen if possible
if (e.compilationResult == CodeStream.RESTART_IN_WIDE_MODE) {
// a branch target required a goto_w, restart code gen in wide mode.
classFile.contentsOffset = problemResetPC;
classFile.methodCount--;
classFile.codeStream.resetInWideMode(); // request wide mode
// reset the problem count to prevent reporting the same warning twice
if (unitResult != null) {
unitResult.problemCount = problemCount;
}
restart = true;
} else if (e.compilationResult == CodeStream.RESTART_CODE_GEN_FOR_UNUSED_LOCALS_MODE) {
classFile.contentsOffset = problemResetPC;
classFile.methodCount--;
classFile.codeStream.resetForCodeGenUnusedLocals();
// reset the problem count to prevent reporting the same warning twice
if (unitResult != null) {
unitResult.problemCount = problemCount;
}
restart = true;
} else {
restart = false;
abort = true;
}
}
} while (restart);
// produce a problem method accounting for this fatal error
if (abort) {
int problemsLength;
CategorizedProblem[] problems =
this.scope.referenceCompilationUnit().compilationResult.getAllProblems();
CategorizedProblem[] problemsCopy = new CategorizedProblem[problemsLength = problems.length];
System.arraycopy(problems, 0, problemsCopy, 0, problemsLength);
classFile.addProblemMethod(this, this.binding, problemsCopy, problemResetPC);
}
}
/*
* INTERNAL USE-ONLY
* Innerclasses get their name computed as they are generated, since some may not
* be actually outputed if sitting inside unreachable code.
*/
public char[] computeConstantPoolName(LocalTypeBinding localType) {
if (localType.constantPoolName != null) {
return localType.constantPoolName;
}
// delegates to the outermost enclosing classfile, since it is the only one with a global vision
// of its innertypes.
if (this.constantPoolNameUsage == null) this.constantPoolNameUsage = new HashtableOfType();
ReferenceBinding outerMostEnclosingType =
localType.scope.outerMostClassScope().enclosingSourceType();
// ensure there is not already such a local type name defined by the user
int index = 0;
char[] candidateName;
boolean isCompliant15 = compilerOptions().complianceLevel >= ClassFileConstants.JDK1_5;
while (true) {
if (localType.isMemberType()) {
if (index == 0) {
candidateName =
CharOperation.concat(
localType.enclosingType().constantPoolName(), localType.sourceName, '$');
} else {
// in case of collision, then member name gets extra $1 inserted
// e.g. class X { { class L{} new X(){ class L{} } } }
candidateName =
CharOperation.concat(
localType.enclosingType().constantPoolName(),
'$',
String.valueOf(index).toCharArray(),
'$',
localType.sourceName);
}
} else if (localType.isAnonymousType()) {
if (isCompliant15) {
// AspectJ Extension start
char[] extraInsert = null;
if (outerMostEnclosingType instanceof SourceTypeBinding) {
SourceTypeBinding sourceTypeBinding = (SourceTypeBinding) outerMostEnclosingType;
ClassScope classScope = sourceTypeBinding.scope;
if (classScope != null) {
TypeDeclaration typeDeclaration = classScope.referenceContext;
if (typeDeclaration != null) {
extraInsert = typeDeclaration.getLocalTypeNameSuffix();
}
}
}
if (extraInsert != null) { // AspectJ Extension end
candidateName =
CharOperation.concat(
localType.enclosingType.constantPoolName(),
'$',
extraInsert,
'$',
String.valueOf(index + 1).toCharArray());
} else {
// from 1.5 on, use immediately enclosing type name
candidateName =
CharOperation.concat(
localType.enclosingType.constantPoolName(),
String.valueOf(index + 1).toCharArray(),
'$');
} // AspectJ extension, closing }
} else {
candidateName =
CharOperation.concat(
outerMostEnclosingType.constantPoolName(),
String.valueOf(index + 1).toCharArray(),
'$');
}
} else {
// local type
if (isCompliant15) {
candidateName =
CharOperation.concat(
CharOperation.concat(
localType.enclosingType().constantPoolName(),
String.valueOf(index + 1).toCharArray(),
'$'),
localType.sourceName);
} else {
candidateName =
CharOperation.concat(
outerMostEnclosingType.constantPoolName(),
'$',
String.valueOf(index + 1).toCharArray(),
'$',
localType.sourceName);
}
}
if (this.constantPoolNameUsage.get(candidateName) != null) {
index++;
} else {
this.constantPoolNameUsage.put(candidateName, localType);
break;
}
}
return candidateName;
}
public QualifiedAllocationExpression(TypeDeclaration anonymousType) {
this.anonymousType = anonymousType;
anonymousType.allocation = this;
}
