| /******************************************************************************* | |
| * Copyright (c) 2002 International Business Machines Corp. and others. | |
| * All rights reserved. This program and the accompanying materials | |
| * are made available under the terms of the Common Public License v0.5 | |
| * which accompanies this distribution, and is available at | |
| * http://www.eclipse.org/legal/cpl-v05.html | |
| * | |
| * Contributors: | |
| * IBM Corporation - initial API and implementation | |
| ******************************************************************************/ | |
| package org.eclipse.jdt.core.dom; | |
| import java.util.HashMap; | |
| import java.util.List; | |
| import java.util.Map; | |
| import org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration; | |
| import org.eclipse.jdt.internal.compiler.ast.AbstractVariableDeclaration; | |
| import org.eclipse.jdt.internal.compiler.ast.AllocationExpression; | |
| import org.eclipse.jdt.internal.compiler.ast.AnonymousLocalTypeDeclaration; | |
| import org.eclipse.jdt.internal.compiler.ast.ArrayAllocationExpression; | |
| import org.eclipse.jdt.internal.compiler.ast.ArrayReference; | |
| import org.eclipse.jdt.internal.compiler.ast.AstNode; | |
| import org.eclipse.jdt.internal.compiler.ast.BinaryExpression; | |
| import org.eclipse.jdt.internal.compiler.ast.CharLiteral; | |
| import org.eclipse.jdt.internal.compiler.ast.ClassLiteralAccess; | |
| import org.eclipse.jdt.internal.compiler.ast.CompilationUnitDeclaration; | |
| import org.eclipse.jdt.internal.compiler.ast.CompoundAssignment; | |
| import org.eclipse.jdt.internal.compiler.ast.ExplicitConstructorCall; | |
| import org.eclipse.jdt.internal.compiler.ast.FalseLiteral; | |
| import org.eclipse.jdt.internal.compiler.ast.FieldReference; | |
| import org.eclipse.jdt.internal.compiler.ast.ImportReference; | |
| import org.eclipse.jdt.internal.compiler.ast.Literal; | |
| import org.eclipse.jdt.internal.compiler.ast.LocalDeclaration; | |
| import org.eclipse.jdt.internal.compiler.ast.MessageSend; | |
| import org.eclipse.jdt.internal.compiler.ast.NameReference; | |
| import org.eclipse.jdt.internal.compiler.ast.OperatorExpression; | |
| import org.eclipse.jdt.internal.compiler.ast.QualifiedNameReference; | |
| import org.eclipse.jdt.internal.compiler.ast.QualifiedSuperReference; | |
| import org.eclipse.jdt.internal.compiler.ast.QualifiedTypeReference; | |
| import org.eclipse.jdt.internal.compiler.ast.SingleNameReference; | |
| import org.eclipse.jdt.internal.compiler.ast.SingleTypeReference; | |
| import org.eclipse.jdt.internal.compiler.ast.ThisReference; | |
| import org.eclipse.jdt.internal.compiler.ast.TrueLiteral; | |
| import org.eclipse.jdt.internal.compiler.ast.TypeReference; | |
| import org.eclipse.jdt.internal.compiler.lookup.ArrayBinding; | |
| import org.eclipse.jdt.internal.compiler.lookup.Binding; | |
| import org.eclipse.jdt.internal.compiler.lookup.BindingIds; | |
| import org.eclipse.jdt.internal.compiler.lookup.CompilationUnitScope; | |
| import org.eclipse.jdt.internal.compiler.lookup.FieldBinding; | |
| import org.eclipse.jdt.internal.compiler.lookup.LocalVariableBinding; | |
| import org.eclipse.jdt.internal.compiler.lookup.BlockScope; | |
| import org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding; | |
| import org.eclipse.jdt.internal.compiler.lookup.Scope; | |
| import org.eclipse.jdt.internal.compiler.util.CharOperation; | |
| /** | |
| * Internal class for resolving bindings using old ASTs. | |
| */ | |
| class DefaultBindingResolver extends BindingResolver { | |
| private static final char[][] JAVA_LANG_STRINGBUFFER = new char[][] {"java".toCharArray(), "lang".toCharArray(), "StringBuffer".toCharArray()}; //$NON-NLS-3$//$NON-NLS-2$//$NON-NLS-1$ | |
| private static final char[][] JAVA_LANG_EXCEPTION = new char[][] {"java".toCharArray(), "lang".toCharArray(), "Exception".toCharArray()};//$NON-NLS-3$//$NON-NLS-2$//$NON-NLS-1$ | |
| /** | |
| * This map is used to keep the correspondance between new bindings and the | |
| * compiler bindings. This is an identity map. We should only create one object | |
| * for one binding. | |
| */ | |
| Map compilerBindingsToASTBindings; | |
| /** | |
| * This map is used to retrieve an old ast node using the new ast node. This is not an | |
| * identity map. | |
| */ | |
| Map newAstToOldAst; | |
| /** | |
| * This map is used to get an ast node from its binding (new binding) | |
| */ | |
| Map bindingsToAstNodes; | |
| /** | |
| * This map is used to get a binding from its ast node | |
| */ | |
| Map astNodesToBindings; | |
| /** | |
| * Compilation unit scope | |
| */ | |
| private CompilationUnitScope scope; | |
| /** | |
| * Check if the binding resolver has to ensure the modification cound | |
| * didn't change | |
| */ | |
| private boolean checkModificationCount; | |
| /** | |
| * Constructor for DefaultBindingResolver. | |
| */ | |
| DefaultBindingResolver() { | |
| checkModificationCount = false; | |
| this.newAstToOldAst = new HashMap(); | |
| this.compilerBindingsToASTBindings = new HashMap(); | |
| this.bindingsToAstNodes = new HashMap(); | |
| this.astNodesToBindings = new HashMap(); | |
| } | |
| /** | |
| * Constructor for DefaultBindingResolver. | |
| */ | |
| DefaultBindingResolver(CompilationUnitScope scope) { | |
| this(); | |
| this.scope = scope; | |
| } | |
| /* | |
| * Method declared on BindingResolver. | |
| */ | |
| IBinding resolveName(Name name) { | |
| if (this.checkModificationCount && this.modificationCount != name.getAST().modificationCount()) { | |
| return null; | |
| } | |
| ASTNode parent = name.getParent(); | |
| if (parent instanceof MethodDeclaration && name.equals(((MethodDeclaration) parent).getName())) { | |
| return this.resolveMethod((MethodDeclaration)parent); | |
| } | |
| if (parent instanceof TypeDeclaration && name.equals(((TypeDeclaration) parent).getName())) { | |
| return this.resolveType((TypeDeclaration)parent); | |
| } | |
| if ((parent instanceof MethodInvocation && name.equals(((MethodInvocation) parent).getName())) | |
| || (parent instanceof SuperMethodInvocation && name.equals(((SuperMethodInvocation) parent).getName()))) { | |
| return this.internalResolveNameForMethodInvocation(name); | |
| } | |
| if ((parent instanceof FieldAccess && name.equals(((FieldAccess) parent).getName())) | |
| || (parent instanceof SuperFieldAccess && name.equals(((SuperFieldAccess) parent).getName()))) { | |
| return this.internalResolveNameForFieldAccess(name); | |
| } | |
| if (parent instanceof PackageDeclaration && name.equals(((PackageDeclaration) parent).getName())) { | |
| return this.internalResolveNameForPackageDeclaration(name); | |
| } | |
| if (parent instanceof SimpleType && name.equals(((SimpleType) parent).getName())) { | |
| return this.internalResolveNameForSimpleType(name); | |
| } | |
| if (parent instanceof ThisExpression) { | |
| return this.internalResolveNameForThisExpression(name); | |
| } | |
| if (name instanceof QualifiedName) { | |
| return this.internalResolveNameForQualifiedName(name); | |
| } | |
| if (name instanceof SimpleName) { | |
| return this.internalResolveNameForSimpleName(name); | |
| } | |
| return super.resolveName(name); | |
| } | |
| private IBinding internalResolveNameForPackageDeclaration(Name name) { | |
| PackageDeclaration packageDeclaration = (PackageDeclaration) name.getParent(); | |
| CompilationUnit unit = (CompilationUnit) packageDeclaration.getParent(); | |
| List types = unit.types(); | |
| if (types.size() == 0) { | |
| return super.resolveName(name); | |
| } | |
| TypeDeclaration type = (TypeDeclaration) types.get(0); | |
| ITypeBinding typeBinding = type.resolveBinding(); | |
| return typeBinding.getPackage(); | |
| } | |
| /* | |
| * Method declared on BindingResolver. | |
| */ | |
| ITypeBinding resolveType(Type type) { | |
| if (this.checkModificationCount && this.modificationCount != type.getAST().modificationCount()) { | |
| return null; | |
| } | |
| // retrieve the old ast node | |
| int index = 0; | |
| ASTNode parentType = type.getParent(); | |
| Type arrayType = null; | |
| AstNode node = (AstNode) this.newAstToOldAst.get(type); | |
| if (node == null) { | |
| if (parentType instanceof ArrayCreation) { | |
| node = (AstNode) this.newAstToOldAst.get(parentType); | |
| } else { | |
| // we try to retrieve the type as an element type of an array type | |
| while ((parentType instanceof Type) && ((Type) parentType).isArrayType()) { | |
| arrayType = (Type) parentType; | |
| parentType = parentType.getParent(); | |
| index++; | |
| } | |
| if (index != 0) { | |
| node = (AstNode) this.newAstToOldAst.get(arrayType); | |
| } | |
| } | |
| } | |
| if (node != null) { | |
| if (node instanceof TypeReference) { | |
| TypeReference typeReference = (TypeReference) node; | |
| ITypeBinding typeBinding = this.getTypeBinding(typeReference.binding); | |
| if (index != 0) { | |
| if (typeBinding.isArray()) { | |
| ArrayBinding arrayBinding = (ArrayBinding)typeReference.binding; | |
| if (index == arrayBinding.dimensions) { | |
| return this.getTypeBinding(arrayBinding.leafComponentType); | |
| } else { | |
| for (int i = 0; i < index; i++) { | |
| arrayBinding = (ArrayBinding) arrayBinding.elementsType(this.scope); | |
| } | |
| return this.getTypeBinding(arrayBinding); | |
| } | |
| } else { | |
| return null; | |
| } | |
| } else { | |
| return typeBinding; | |
| } | |
| } else if (node instanceof SingleNameReference) { | |
| SingleNameReference singleNameReference = (SingleNameReference) node; | |
| if (singleNameReference.isTypeReference()) { | |
| ITypeBinding typeBinding = this.getTypeBinding((ReferenceBinding)singleNameReference.binding); | |
| if (index != 0) { | |
| if (typeBinding.isArray()) { | |
| ArrayBinding arrayBinding = (ArrayBinding)singleNameReference.binding; | |
| if (index == arrayBinding.dimensions) { | |
| return this.getTypeBinding(arrayBinding.leafComponentType); | |
| } else { | |
| for (int i = 0; i < index; i++) { | |
| arrayBinding = (ArrayBinding) arrayBinding.elementsType(this.scope); | |
| } | |
| return this.getTypeBinding(arrayBinding); | |
| } | |
| } else { | |
| return null; | |
| } | |
| } else { | |
| return typeBinding; | |
| } | |
| } else { | |
| // it should be a type reference | |
| return null; | |
| } | |
| } else if (node instanceof QualifiedNameReference) { | |
| QualifiedNameReference qualifiedNameReference = (QualifiedNameReference) node; | |
| if (qualifiedNameReference.isTypeReference()) { | |
| ITypeBinding typeBinding = this.getTypeBinding((ReferenceBinding)qualifiedNameReference.binding); | |
| if (index != 0) { | |
| if (typeBinding.isArray()) { | |
| ArrayBinding arrayBinding = (ArrayBinding)qualifiedNameReference.binding; | |
| if (index == arrayBinding.dimensions) { | |
| return this.getTypeBinding(arrayBinding.leafComponentType); | |
| } else { | |
| for (int i = 0; i < index; i++) { | |
| arrayBinding = (ArrayBinding) arrayBinding.elementsType(this.scope); | |
| } | |
| } | |
| return this.getTypeBinding(arrayBinding); | |
| } else { | |
| return null; | |
| } | |
| } else { | |
| return typeBinding; | |
| } | |
| } else { | |
| // it should be a type reference | |
| return null; | |
| } | |
| } else if (node instanceof ArrayAllocationExpression) { | |
| ArrayAllocationExpression arrayAllocationExpression = (ArrayAllocationExpression) node; | |
| ArrayBinding arrayBinding = arrayAllocationExpression.arrayTb; | |
| if (index != 0) { | |
| return this.getTypeBinding(this.scope.createArray(arrayBinding.leafComponentType, arrayBinding.dimensions - index)); | |
| } | |
| return this.getTypeBinding(arrayBinding); | |
| } | |
| } | |
| return null; | |
| } | |
| /* | |
| * Method declared on BindingResolver. | |
| */ | |
| ITypeBinding resolveWellKnownType(String name) { | |
| if (("boolean".equals(name))//$NON-NLS-1$ | |
| || ("char".equals(name))//$NON-NLS-1$ | |
| || ("byte".equals(name))//$NON-NLS-1$ | |
| || ("short".equals(name))//$NON-NLS-1$ | |
| || ("int".equals(name))//$NON-NLS-1$ | |
| || ("long".equals(name))//$NON-NLS-1$ | |
| || ("float".equals(name))//$NON-NLS-1$ | |
| || ("double".equals(name))//$NON-NLS-1$ | |
| || ("void".equals(name))) {//$NON-NLS-1$ | |
| return this.getTypeBinding(this.scope.getBaseType(name.toCharArray())); | |
| } else if ("java.lang.Object".equals(name)) {//$NON-NLS-1$ | |
| return this.getTypeBinding(this.scope.getJavaLangObject()); | |
| } else if ("java.lang.String".equals(name)) {//$NON-NLS-1$ | |
| return this.getTypeBinding(this.scope.getJavaLangString()); | |
| } else if ("java.lang.StringBuffer".equals(name)) {//$NON-NLS-1$ | |
| return this.getTypeBinding(this.scope.getType(JAVA_LANG_STRINGBUFFER)); | |
| } else if ("java.lang.Throwable".equals(name)) {//$NON-NLS-1$ | |
| return this.getTypeBinding(this.scope.getJavaLangThrowable()); | |
| } else if ("java.lang.Exception".equals(name)) {//$NON-NLS-1$ | |
| return this.getTypeBinding(this.scope.getType(JAVA_LANG_EXCEPTION)); | |
| } else if ("java.lang.RuntimeException".equals(name)) {//$NON-NLS-1$ | |
| return this.getTypeBinding(this.scope.getJavaLangRuntimeException()); | |
| } else if ("java.lang.Error".equals(name)) {//$NON-NLS-1$ | |
| return this.getTypeBinding(this.scope.getJavaLangError()); | |
| } else if ("java.lang.Class".equals(name)) {//$NON-NLS-1$ | |
| return this.getTypeBinding(this.scope.getJavaLangClass()); | |
| } else { | |
| return super.resolveWellKnownType(name); | |
| } | |
| } | |
| /* | |
| * Method declared on BindingResolver. | |
| */ | |
| ITypeBinding resolveType(TypeDeclaration type) { | |
| if (this.checkModificationCount && this.modificationCount != type.getAST().modificationCount()) { | |
| return null; | |
| } | |
| org.eclipse.jdt.internal.compiler.ast.TypeDeclaration typeDeclaration = (org.eclipse.jdt.internal.compiler.ast.TypeDeclaration) this.newAstToOldAst.get(type); | |
| if (typeDeclaration != null) { | |
| ITypeBinding typeBinding = this.getTypeBinding(typeDeclaration.binding); | |
| this.bindingsToAstNodes.put(typeBinding, type); | |
| return typeBinding; | |
| } | |
| return super.resolveType(type); | |
| } | |
| /* | |
| * Method declared on BindingResolver. | |
| */ | |
| IMethodBinding resolveMethod(MethodDeclaration method) { | |
| if (this.checkModificationCount && this.modificationCount != method.getAST().modificationCount()) { | |
| return null; | |
| } | |
| AbstractMethodDeclaration methodDeclaration = (AbstractMethodDeclaration) this.newAstToOldAst.get(method); | |
| if (methodDeclaration != null) { | |
| IMethodBinding methodBinding = this.getMethodBinding(methodDeclaration.binding); | |
| this.bindingsToAstNodes.put(methodBinding, method); | |
| return methodBinding; | |
| } | |
| return super.resolveMethod(method); | |
| } | |
| /* | |
| * Method declared on BindingResolver. | |
| */ | |
| IVariableBinding resolveVariable(VariableDeclaration variable) { | |
| if (this.checkModificationCount && this.modificationCount != variable.getAST().modificationCount()) { | |
| return null; | |
| } | |
| AbstractVariableDeclaration abstractVariableDeclaration = (AbstractVariableDeclaration) this.newAstToOldAst.get(variable); | |
| if (abstractVariableDeclaration instanceof org.eclipse.jdt.internal.compiler.ast.FieldDeclaration) { | |
| org.eclipse.jdt.internal.compiler.ast.FieldDeclaration fieldDeclaration = (org.eclipse.jdt.internal.compiler.ast.FieldDeclaration) abstractVariableDeclaration; | |
| IVariableBinding variableBinding = this.getVariableBinding(fieldDeclaration.binding); | |
| this.bindingsToAstNodes.put(variableBinding, variable); | |
| return variableBinding; | |
| } | |
| IVariableBinding variableBinding = this.getVariableBinding(((LocalDeclaration) abstractVariableDeclaration).binding); | |
| this.bindingsToAstNodes.put(variableBinding, variable); | |
| return variableBinding; | |
| } | |
| /* | |
| * Method declared on BindingResolver. | |
| */ | |
| IVariableBinding resolveVariable(FieldDeclaration variable) { | |
| if (this.checkModificationCount && this.modificationCount != variable.getAST().modificationCount()) { | |
| return null; | |
| } | |
| org.eclipse.jdt.internal.compiler.ast.FieldDeclaration fieldDeclaration = (org.eclipse.jdt.internal.compiler.ast.FieldDeclaration) this.newAstToOldAst.get(variable); | |
| IVariableBinding variableBinding = this.getVariableBinding(fieldDeclaration.binding); | |
| this.bindingsToAstNodes.put(variableBinding, variable); | |
| return variableBinding; | |
| } | |
| /* | |
| * Method declared on BindingResolver. | |
| */ | |
| ITypeBinding resolveExpressionType(Expression expression) { | |
| if (this.checkModificationCount && this.modificationCount != expression.getAST().modificationCount()) { | |
| return null; | |
| } | |
| if (expression instanceof ClassInstanceCreation) { | |
| AstNode astNode = (AstNode) this.newAstToOldAst.get(expression); | |
| if (astNode instanceof org.eclipse.jdt.internal.compiler.ast.TypeDeclaration) { | |
| org.eclipse.jdt.internal.compiler.ast.TypeDeclaration typeDeclaration = (org.eclipse.jdt.internal.compiler.ast.TypeDeclaration) astNode; | |
| if (typeDeclaration != null) { | |
| ITypeBinding typeBinding = this.getTypeBinding(typeDeclaration.binding); | |
| this.bindingsToAstNodes.put(typeBinding, expression); | |
| return typeBinding; | |
| } | |
| } else { | |
| // should be an AllocationExpression | |
| AllocationExpression allocationExpression = (AllocationExpression) astNode; | |
| IMethodBinding methodBinding = this.getMethodBinding(allocationExpression.binding); | |
| if (methodBinding == null) { | |
| return null; | |
| } else { | |
| return methodBinding.getDeclaringClass(); | |
| } | |
| } | |
| } else if (expression instanceof Name) { | |
| IBinding binding = this.resolveName((Name) expression); | |
| if (binding == null) { | |
| return null; | |
| } | |
| switch(binding.getKind()) { | |
| case IBinding.TYPE : | |
| return (ITypeBinding) binding; | |
| case IBinding.VARIABLE : | |
| return ((IVariableBinding) binding).getType(); | |
| } | |
| } else if (expression instanceof ArrayInitializer) { | |
| org.eclipse.jdt.internal.compiler.ast.ArrayInitializer oldAst = (org.eclipse.jdt.internal.compiler.ast.ArrayInitializer) this.newAstToOldAst.get(expression); | |
| if (oldAst == null || oldAst.binding == null) { | |
| return super.resolveExpressionType(expression); | |
| } | |
| return this.getTypeBinding(oldAst.binding); | |
| } else if (expression instanceof ArrayCreation) { | |
| ArrayAllocationExpression arrayAllocationExpression = (ArrayAllocationExpression) this.newAstToOldAst.get(expression); | |
| return this.getTypeBinding(arrayAllocationExpression.arrayTb); | |
| } else if (expression instanceof Assignment) { | |
| Assignment assignment = (Assignment) expression; | |
| return this.resolveExpressionType(assignment.getLeftHandSide()); | |
| } else if (expression instanceof PostfixExpression) { | |
| PostfixExpression postFixExpression = (PostfixExpression) expression; | |
| return this.resolveExpressionType(postFixExpression.getOperand()); | |
| } else if (expression instanceof PrefixExpression) { | |
| PrefixExpression preFixExpression = (PrefixExpression) expression; | |
| return this.resolveExpressionType(preFixExpression.getOperand()); | |
| } else if (expression instanceof CastExpression) { | |
| org.eclipse.jdt.internal.compiler.ast.CastExpression castExpression = (org.eclipse.jdt.internal.compiler.ast.CastExpression) this.newAstToOldAst.get(expression); | |
| return this.getTypeBinding(castExpression.castTb); | |
| } else if (expression instanceof StringLiteral) { | |
| org.eclipse.jdt.internal.compiler.ast.StringLiteral stringLiteral = (org.eclipse.jdt.internal.compiler.ast.StringLiteral) this.newAstToOldAst.get(expression); | |
| BlockScope blockScope = this.retrieveEnclosingScope(expression); | |
| if (blockScope == null) { | |
| return this.getTypeBinding(this.scope.getJavaLangString()); | |
| } else { | |
| return this.getTypeBinding(stringLiteral.literalType(blockScope)); | |
| } | |
| } else if (expression instanceof TypeLiteral) { | |
| return this.getTypeBinding(this.scope.getJavaLangClass()); | |
| } else if (expression instanceof BooleanLiteral) { | |
| BooleanLiteral booleanLiteral = (BooleanLiteral) expression; | |
| if (booleanLiteral.booleanValue()) { | |
| TrueLiteral trueLiteral = (TrueLiteral) this.newAstToOldAst.get(booleanLiteral); | |
| return this.getTypeBinding(trueLiteral.literalType(null)); | |
| } else { | |
| FalseLiteral falseLiteral = (FalseLiteral) this.newAstToOldAst.get(booleanLiteral); | |
| return this.getTypeBinding(falseLiteral.literalType(null)); | |
| } | |
| } else if (expression instanceof NullLiteral) { | |
| org.eclipse.jdt.internal.compiler.ast.NullLiteral nullLiteral = (org.eclipse.jdt.internal.compiler.ast.NullLiteral) this.newAstToOldAst.get(expression); | |
| return this.getTypeBinding(nullLiteral.literalType(null)); | |
| } else if (expression instanceof CharacterLiteral) { | |
| CharLiteral charLiteral = (CharLiteral) this.newAstToOldAst.get(expression); | |
| return this.getTypeBinding(charLiteral.literalType(null)); | |
| } else if (expression instanceof NumberLiteral) { | |
| Literal literal = (Literal) this.newAstToOldAst.get(expression); | |
| return this.getTypeBinding(literal.literalType(null)); | |
| } else if (expression instanceof InfixExpression) { | |
| OperatorExpression operatorExpression = (OperatorExpression) this.newAstToOldAst.get(expression); | |
| return this.getTypeBinding(operatorExpression.typeBinding); | |
| } else if (expression instanceof InstanceofExpression) { | |
| org.eclipse.jdt.internal.compiler.ast.InstanceOfExpression instanceOfExpression = (org.eclipse.jdt.internal.compiler.ast.InstanceOfExpression) this.newAstToOldAst.get(expression); | |
| return this.getTypeBinding(instanceOfExpression.typeBinding); | |
| } else if (expression instanceof FieldAccess) { | |
| FieldReference fieldReference = (FieldReference) this.newAstToOldAst.get(expression); | |
| IVariableBinding variableBinding = this.getVariableBinding(fieldReference.binding); | |
| if (variableBinding == null) { | |
| return null; | |
| } else { | |
| return variableBinding.getType(); | |
| } | |
| } else if (expression instanceof SuperFieldAccess) { | |
| FieldReference fieldReference = (FieldReference) this.newAstToOldAst.get(expression); | |
| IVariableBinding variableBinding = this.getVariableBinding(fieldReference.binding); | |
| if (variableBinding == null) { | |
| return null; | |
| } else { | |
| return variableBinding.getType(); | |
| } | |
| } else if (expression instanceof ArrayAccess) { | |
| ArrayReference arrayReference = (ArrayReference) this.newAstToOldAst.get(expression); | |
| return this.getTypeBinding(arrayReference.arrayElementBinding); | |
| } else if (expression instanceof ThisExpression) { | |
| ThisReference thisReference = (ThisReference) this.newAstToOldAst.get(expression); | |
| BlockScope blockScope = this.retrieveEnclosingScope(expression); | |
| if (blockScope == null) { | |
| return null; | |
| } | |
| return this.getTypeBinding(thisReference.resolveType(blockScope)); | |
| } else if (expression instanceof MethodInvocation) { | |
| MessageSend messageSend = (MessageSend) this.newAstToOldAst.get(expression); | |
| IMethodBinding methodBinding = this.getMethodBinding(messageSend.binding); | |
| if (methodBinding == null) { | |
| return null; | |
| } else { | |
| return methodBinding.getReturnType(); | |
| } | |
| } else if (expression instanceof ParenthesizedExpression) { | |
| ParenthesizedExpression parenthesizedExpression = (ParenthesizedExpression) expression; | |
| return this.resolveExpressionType(parenthesizedExpression.getExpression()); | |
| } else if (expression instanceof ConditionalExpression) { | |
| org.eclipse.jdt.internal.compiler.ast.ConditionalExpression conditionalExpression = (org.eclipse.jdt.internal.compiler.ast.ConditionalExpression) this.newAstToOldAst.get(expression); | |
| return this.getTypeBinding(conditionalExpression.typeBinding); | |
| } | |
| return super.resolveExpressionType(expression); | |
| } | |
| /* | |
| * @see BindingResolver#resolveImport(ImportDeclaration) | |
| */ | |
| IBinding resolveImport(ImportDeclaration importDeclaration) { | |
| if (this.checkModificationCount && this.modificationCount != importDeclaration.getAST().modificationCount()) { | |
| return null; | |
| } | |
| AstNode node = (AstNode) this.newAstToOldAst.get(importDeclaration); | |
| if (node instanceof ImportReference) { | |
| ImportReference importReference = (ImportReference) node; | |
| if (importReference.onDemand) { | |
| Binding binding = this.scope.getTypeOrPackage(CharOperation.subarray(importReference.tokens, 0, importReference.tokens.length)); | |
| if ((binding != null) && (binding.isValidBinding())) { | |
| IPackageBinding packageBinding = this.getPackageBinding((org.eclipse.jdt.internal.compiler.lookup.PackageBinding) binding); | |
| this.bindingsToAstNodes.put(packageBinding, importDeclaration); | |
| return packageBinding; | |
| } | |
| } else { | |
| Binding binding = this.scope.getTypeOrPackage(importReference.tokens); | |
| if (binding != null && binding.isValidBinding()) { | |
| ITypeBinding typeBinding = this.getTypeBinding((org.eclipse.jdt.internal.compiler.lookup.TypeBinding) binding); | |
| this.bindingsToAstNodes.put(typeBinding, importDeclaration); | |
| return typeBinding; | |
| } | |
| } | |
| } | |
| return super.resolveImport(importDeclaration); | |
| } | |
| /* | |
| * @see BindingResolver#resolvePackage(PackageDeclaration) | |
| */ | |
| IPackageBinding resolvePackage(PackageDeclaration pkg) { | |
| if (this.checkModificationCount && this.modificationCount != pkg.getAST().modificationCount()) { | |
| return null; | |
| } | |
| AstNode node = (AstNode) this.newAstToOldAst.get(pkg); | |
| if (node instanceof ImportReference) { | |
| ImportReference importReference = (ImportReference) node; | |
| Binding binding = this.scope.getTypeOrPackage(CharOperation.subarray(importReference.tokens, 0, importReference.tokens.length)); | |
| if ((binding != null) && (binding.isValidBinding())) { | |
| IPackageBinding packageBinding = this.getPackageBinding((org.eclipse.jdt.internal.compiler.lookup.PackageBinding) binding); | |
| this.bindingsToAstNodes.put(packageBinding, pkg); | |
| return packageBinding; | |
| } | |
| } | |
| return super.resolvePackage(pkg); | |
| } | |
| /* | |
| * Method declared on BindingResolver. | |
| */ | |
| public ASTNode findDeclaringNode(IBinding binding) { | |
| if (binding == null) { | |
| return null; | |
| } | |
| return (ASTNode) this.bindingsToAstNodes.get(binding); | |
| } | |
| /* | |
| * Method declared on BindingResolver. | |
| */ | |
| void store(ASTNode node, AstNode oldASTNode) { | |
| this.newAstToOldAst.put(node, oldASTNode); | |
| } | |
| /* | |
| * Method declared on BindingResolver. | |
| */ | |
| protected ITypeBinding getTypeBinding(org.eclipse.jdt.internal.compiler.lookup.TypeBinding referenceBinding) { | |
| if (referenceBinding == null || !referenceBinding.isValidBinding()) { | |
| return null; | |
| } | |
| TypeBinding binding = (TypeBinding) this.compilerBindingsToASTBindings.get(referenceBinding); | |
| if (binding != null) { | |
| return binding; | |
| } | |
| binding = new TypeBinding(this, referenceBinding); | |
| this.compilerBindingsToASTBindings.put(referenceBinding, binding); | |
| return binding; | |
| } | |
| /* | |
| * Method declared on BindingResolver. | |
| */ | |
| protected IPackageBinding getPackageBinding(org.eclipse.jdt.internal.compiler.lookup.PackageBinding packageBinding) { | |
| if (packageBinding == null || !packageBinding.isValidBinding()) { | |
| return null; | |
| } | |
| IPackageBinding binding = (IPackageBinding) this.compilerBindingsToASTBindings.get(packageBinding); | |
| if (binding != null) { | |
| return binding; | |
| } | |
| binding = new PackageBinding(this, packageBinding); | |
| this.compilerBindingsToASTBindings.put(packageBinding, binding); | |
| return binding; | |
| } | |
| /* | |
| * Method declared on BindingResolver. | |
| */ | |
| protected IVariableBinding getVariableBinding(org.eclipse.jdt.internal.compiler.lookup.VariableBinding variableBinding) { | |
| if (variableBinding == null || !variableBinding.isValidBinding()) { | |
| return null; | |
| } | |
| IVariableBinding binding = (IVariableBinding) this.compilerBindingsToASTBindings.get(variableBinding); | |
| if (binding != null) { | |
| return binding; | |
| } | |
| binding = new VariableBinding(this, variableBinding); | |
| this.compilerBindingsToASTBindings.put(variableBinding, binding); | |
| return binding; | |
| } | |
| /* | |
| * Method declared on BindingResolver. | |
| */ | |
| protected IMethodBinding getMethodBinding(org.eclipse.jdt.internal.compiler.lookup.MethodBinding methodBinding) { | |
| if (methodBinding == null || !methodBinding.isValidBinding()) { | |
| return null; | |
| } | |
| IMethodBinding binding = (IMethodBinding) this.compilerBindingsToASTBindings.get(methodBinding); | |
| if (binding != null) { | |
| return binding; | |
| } | |
| binding = new MethodBinding(this, methodBinding); | |
| this.compilerBindingsToASTBindings.put(methodBinding, binding); | |
| return binding; | |
| } | |
| private BlockScope retrieveEnclosingScope(ASTNode node) { | |
| ASTNode currentNode = node; | |
| while(currentNode != null | |
| &&!(currentNode instanceof MethodDeclaration) | |
| && !(currentNode instanceof Initializer) | |
| && !(currentNode instanceof FieldDeclaration)) { | |
| currentNode = currentNode.getParent(); | |
| } | |
| if (currentNode == null) { | |
| return null; | |
| } | |
| if (currentNode instanceof Initializer) { | |
| Initializer initializer = (Initializer) currentNode; | |
| while(!(currentNode instanceof TypeDeclaration)) { | |
| currentNode = currentNode.getParent(); | |
| } | |
| org.eclipse.jdt.internal.compiler.ast.TypeDeclaration typeDecl = (org.eclipse.jdt.internal.compiler.ast.TypeDeclaration) this.newAstToOldAst.get(currentNode); | |
| if ((initializer.getModifiers() & Modifier.STATIC) != 0) { | |
| return typeDecl.staticInitializerScope; | |
| } else { | |
| return typeDecl.initializerScope; | |
| } | |
| } else if (currentNode instanceof FieldDeclaration) { | |
| FieldDeclaration fieldDeclaration = (FieldDeclaration) currentNode; | |
| while(!(currentNode instanceof TypeDeclaration)) { | |
| currentNode = currentNode.getParent(); | |
| } | |
| org.eclipse.jdt.internal.compiler.ast.TypeDeclaration typeDecl = (org.eclipse.jdt.internal.compiler.ast.TypeDeclaration) this.newAstToOldAst.get(currentNode); | |
| if ((fieldDeclaration.getModifiers() & Modifier.STATIC) != 0) { | |
| return typeDecl.staticInitializerScope; | |
| } else { | |
| return typeDecl.initializerScope; | |
| } | |
| } | |
| AbstractMethodDeclaration abstractMethodDeclaration = (AbstractMethodDeclaration) this.newAstToOldAst.get(currentNode); | |
| return abstractMethodDeclaration.scope; | |
| } | |
| private IBinding internalResolveNameForQualifiedName(Name name) { | |
| QualifiedName qualifiedName = (QualifiedName) name; | |
| ASTNode parent = qualifiedName.getParent(); | |
| int index = 0; | |
| while (parent instanceof QualifiedName) { | |
| qualifiedName = (QualifiedName) parent; | |
| parent = parent.getParent(); | |
| index++; | |
| } | |
| return returnBindingForQualifiedNamePart(qualifiedName, index); | |
| } | |
| private IBinding returnBindingForQualifiedNamePart(ASTNode parent, int index) { | |
| // now we can retrieve the compiler's node | |
| AstNode node = (AstNode) this.newAstToOldAst.get(parent); | |
| if (node instanceof QualifiedNameReference) { | |
| QualifiedNameReference qualifiedNameReference = (QualifiedNameReference) node; | |
| if (qualifiedNameReference.isTypeReference()) { | |
| return this.getTypeBinding((ReferenceBinding)qualifiedNameReference.binding); | |
| } else { | |
| int qualifiedNameLength = qualifiedNameReference.tokens.length; | |
| int indexInQualifiedName = qualifiedNameLength - index; // one-based | |
| int indexOfFirstFieldBinding = qualifiedNameReference.indexOfFirstFieldBinding; // one-based | |
| int otherBindingLength = qualifiedNameLength - indexOfFirstFieldBinding; | |
| if (indexInQualifiedName < indexOfFirstFieldBinding) { | |
| // a extra lookup is required | |
| BlockScope internalScope = retrieveEnclosingScope(parent); | |
| Binding binding = null; | |
| if (internalScope == null) { | |
| binding = this.scope.getTypeOrPackage(CharOperation.subarray(qualifiedNameReference.tokens, 0, indexInQualifiedName)); | |
| } else { | |
| binding = internalScope.getTypeOrPackage(CharOperation.subarray(qualifiedNameReference.tokens, 0, indexInQualifiedName)); | |
| } | |
| if (binding != null && binding.isValidBinding()) { | |
| if (binding instanceof org.eclipse.jdt.internal.compiler.lookup.PackageBinding) { | |
| return this.getPackageBinding((org.eclipse.jdt.internal.compiler.lookup.PackageBinding)binding); | |
| } else { | |
| // it is a type | |
| return this.getTypeBinding((org.eclipse.jdt.internal.compiler.lookup.TypeBinding)binding); | |
| } | |
| } | |
| return null; | |
| } else { | |
| if (indexInQualifiedName == indexOfFirstFieldBinding) { | |
| Binding binding = qualifiedNameReference.binding; | |
| if (binding != null && binding.isValidBinding()) { | |
| return this.getVariableBinding((org.eclipse.jdt.internal.compiler.lookup.VariableBinding) binding); | |
| } else { | |
| return null; | |
| } | |
| } else { | |
| /* This is the case for a name which is part of a qualified name that | |
| * cannot be resolved. See PR 13063. | |
| */ | |
| if (qualifiedNameReference.otherBindings == null) { | |
| return null; | |
| } else { | |
| return this.getVariableBinding(qualifiedNameReference.otherBindings[otherBindingLength - index - 1]); | |
| } | |
| } | |
| } | |
| } | |
| } else if (node instanceof QualifiedTypeReference) { | |
| QualifiedTypeReference qualifiedTypeReference = (QualifiedTypeReference) node; | |
| if (index == 0) { | |
| return this.getTypeBinding((ReferenceBinding)qualifiedTypeReference.binding); | |
| } else { | |
| int qualifiedTypeLength = qualifiedTypeReference.tokens.length; | |
| int indexInQualifiedName = qualifiedTypeLength - index; // one-based | |
| BlockScope internalScope = retrieveEnclosingScope(parent); | |
| Binding binding = null; | |
| if (internalScope == null) { | |
| binding = this.scope.getTypeOrPackage(CharOperation.subarray(qualifiedTypeReference.tokens, 0, indexInQualifiedName)); | |
| } else { | |
| binding = internalScope.getTypeOrPackage(CharOperation.subarray(qualifiedTypeReference.tokens, 0, indexInQualifiedName)); | |
| } | |
| if (binding != null && binding.isValidBinding()) { | |
| if (binding instanceof org.eclipse.jdt.internal.compiler.lookup.PackageBinding) { | |
| return this.getPackageBinding((org.eclipse.jdt.internal.compiler.lookup.PackageBinding)binding); | |
| } else { | |
| // it is a type | |
| return this.getTypeBinding((org.eclipse.jdt.internal.compiler.lookup.TypeBinding)binding); | |
| } | |
| } | |
| } | |
| } | |
| return null; | |
| } | |
| private IBinding internalResolveNameForSimpleName(Name name) { | |
| AstNode node = (AstNode) this.newAstToOldAst.get(name); | |
| if (node == null) { | |
| ASTNode parent = name.getParent(); | |
| if (parent instanceof QualifiedName) { | |
| // retrieve the qualified name and remember at which position is the simple name | |
| QualifiedName qualifiedName = (QualifiedName) parent; | |
| int index = -1; | |
| if (qualifiedName.getQualifier() == name) { | |
| index++; | |
| } | |
| while (parent instanceof QualifiedName) { | |
| qualifiedName = (QualifiedName) parent; | |
| parent = parent.getParent(); | |
| index++; | |
| } | |
| return returnBindingForQualifiedNamePart(qualifiedName, index); | |
| } | |
| } | |
| if (node instanceof SingleNameReference) { | |
| SingleNameReference singleNameReference = (SingleNameReference) node; | |
| if (singleNameReference.isTypeReference()) { | |
| return this.getTypeBinding((ReferenceBinding)singleNameReference.binding); | |
| } else { | |
| // this is a variable or a field | |
| Binding binding = singleNameReference.binding; | |
| if (binding != null && binding.isValidBinding()) { | |
| return this.getVariableBinding((org.eclipse.jdt.internal.compiler.lookup.VariableBinding) binding); | |
| } else { | |
| return null; | |
| } | |
| } | |
| } else if (node instanceof QualifiedSuperReference) { | |
| QualifiedSuperReference qualifiedSuperReference = (QualifiedSuperReference) node; | |
| return this.getTypeBinding(qualifiedSuperReference.qualification.binding); | |
| } else if (node instanceof LocalDeclaration) { | |
| return this.getVariableBinding(((LocalDeclaration)node).binding); | |
| } else if (node instanceof FieldReference) { | |
| return getVariableBinding(((FieldReference) node).binding); | |
| } else if (node instanceof SingleTypeReference) { | |
| SingleTypeReference singleTypeReference = (SingleTypeReference) node; | |
| return this.getTypeBinding(singleTypeReference.binding); | |
| } else if (node instanceof org.eclipse.jdt.internal.compiler.ast.FieldDeclaration) { | |
| org.eclipse.jdt.internal.compiler.ast.FieldDeclaration fieldDeclaration = (org.eclipse.jdt.internal.compiler.ast.FieldDeclaration) node; | |
| IVariableBinding variableBinding = this.getVariableBinding(fieldDeclaration.binding); | |
| return variableBinding; | |
| } | |
| return null; | |
| } | |
| private IBinding internalResolveNameForMethodInvocation(Name name) { | |
| ASTNode parent = name.getParent(); | |
| if (parent instanceof MethodInvocation) { | |
| MethodInvocation methodInvocation = (MethodInvocation) parent; | |
| if (name == methodInvocation.getExpression()) { | |
| if (name.isQualifiedName()) { | |
| return this.internalResolveNameForQualifiedName(name); | |
| } else { | |
| return this.internalResolveNameForSimpleName(name); | |
| } | |
| } else { | |
| AstNode node = (AstNode) this.newAstToOldAst.get(name); | |
| if (node instanceof MessageSend) { | |
| MessageSend messageSend = (MessageSend) node; | |
| return getMethodBinding(messageSend.binding); | |
| } else if (name.isQualifiedName()) { | |
| return this.internalResolveNameForQualifiedName(name); | |
| } else { | |
| return this.internalResolveNameForSimpleName(name); | |
| } | |
| } | |
| } else { | |
| SuperMethodInvocation superMethodInvocation = (SuperMethodInvocation) parent; | |
| if (name == superMethodInvocation.getQualifier()) { | |
| if (name.isQualifiedName()) { | |
| return this.internalResolveNameForQualifiedName(name); | |
| } else { | |
| return this.internalResolveNameForSimpleName(name); | |
| } | |
| } else { | |
| AstNode node = (AstNode) this.newAstToOldAst.get(name); | |
| if (node instanceof MessageSend) { | |
| MessageSend messageSend = (MessageSend) node; | |
| return getMethodBinding(messageSend.binding); | |
| } else if (name.isQualifiedName()) { | |
| return this.internalResolveNameForQualifiedName(name); | |
| } else { | |
| return this.internalResolveNameForSimpleName(name); | |
| } | |
| } | |
| } | |
| } | |
| private IBinding internalResolveNameForFieldAccess(Name name) { | |
| if (name.isQualifiedName()) { | |
| return this.internalResolveNameForQualifiedName(name); | |
| } else { | |
| return this.internalResolveNameForSimpleName(name); | |
| } | |
| } | |
| private IBinding internalResolveNameForSimpleType(Name name) { | |
| AstNode node = (AstNode) this.newAstToOldAst.get(name); | |
| if (node instanceof TypeReference) { | |
| return this.getTypeBinding(((TypeReference) node).binding); | |
| } else if (node instanceof NameReference) { | |
| NameReference nameReference = (NameReference) node; | |
| if (nameReference.isTypeReference()) { | |
| return this.getTypeBinding((org.eclipse.jdt.internal.compiler.lookup.TypeBinding) nameReference.binding); | |
| } | |
| } | |
| return null; | |
| } | |
| private IBinding internalResolveNameForThisExpression(Name name) { | |
| AstNode node = (AstNode) this.newAstToOldAst.get(name); | |
| if (node instanceof TypeReference) { | |
| return this.getTypeBinding(((TypeReference) node).binding); | |
| } | |
| return null; | |
| } | |
| /* | |
| * @see BindingResolver#resolveConstructor(ClassInstanceCreation) | |
| */ | |
| IMethodBinding resolveConstructor(ClassInstanceCreation expression) { | |
| if (this.checkModificationCount && this.modificationCount != expression.getAST().modificationCount()) { | |
| return null; | |
| } | |
| AstNode node = (AstNode) this.newAstToOldAst.get(expression); | |
| if (node instanceof AnonymousLocalTypeDeclaration) { | |
| AnonymousLocalTypeDeclaration anonymousLocalTypeDeclaration = (AnonymousLocalTypeDeclaration) node; | |
| return this.getMethodBinding(anonymousLocalTypeDeclaration.allocation.binding); | |
| } else if (node instanceof AllocationExpression) { | |
| return this.getMethodBinding(((AllocationExpression)node).binding); | |
| } | |
| return null; | |
| } | |
| /* | |
| * @see BindingResolver#resolveConstructor(ConstructorInvocation) | |
| */ | |
| IMethodBinding resolveConstructor(ConstructorInvocation expression) { | |
| if (this.checkModificationCount && this.modificationCount != expression.getAST().modificationCount()) { | |
| return null; | |
| } | |
| AstNode node = (AstNode) this.newAstToOldAst.get(expression); | |
| if (node instanceof ExplicitConstructorCall) { | |
| ExplicitConstructorCall explicitConstructorCall = (ExplicitConstructorCall) node; | |
| return this.getMethodBinding(explicitConstructorCall.binding); | |
| } | |
| return null; | |
| } | |
| /* | |
| * @see BindingResolver#resolveConstructor(SuperConstructorInvocation) | |
| */ | |
| IMethodBinding resolveConstructor(SuperConstructorInvocation expression) { | |
| if (this.checkModificationCount && this.modificationCount != expression.getAST().modificationCount()) { | |
| return null; | |
| } | |
| AstNode node = (AstNode) this.newAstToOldAst.get(expression); | |
| if (node instanceof ExplicitConstructorCall) { | |
| ExplicitConstructorCall explicitConstructorCall = (ExplicitConstructorCall) node; | |
| return this.getMethodBinding(explicitConstructorCall.binding); | |
| } | |
| return null; | |
| } | |
| /* | |
| * @see BindingResolver#resolveType(AnonymousClassDeclaration) | |
| */ | |
| ITypeBinding resolveType(AnonymousClassDeclaration type) { | |
| if (this.checkModificationCount && this.modificationCount != type.getAST().modificationCount()) { | |
| return null; | |
| } | |
| org.eclipse.jdt.internal.compiler.ast.AnonymousLocalTypeDeclaration anonymousLocalTypeDeclaration = (org.eclipse.jdt.internal.compiler.ast.AnonymousLocalTypeDeclaration) this.newAstToOldAst.get(type); | |
| if (anonymousLocalTypeDeclaration != null) { | |
| ITypeBinding typeBinding = this.getTypeBinding(anonymousLocalTypeDeclaration.binding); | |
| this.bindingsToAstNodes.put(typeBinding, type); | |
| return typeBinding; | |
| } | |
| return super.resolveType(type); | |
| } | |
| /** | |
| * Store the number of modifications done using the ast. This is used to validate | |
| * resolveBinding methods. If the number changed, all resolve bindings methods | |
| * simply return null. | |
| */ | |
| protected void storeModificationCount(long modificationCount) { | |
| super.storeModificationCount(modificationCount); | |
| this.checkModificationCount = true; | |
| } | |
| } |