| /******************************************************************************* |
| * Copyright (c) 2000, 2009 IBM Corporation and others. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * IBM Corporation - initial API and implementation |
| *******************************************************************************/ |
| package org.eclipse.jdt.internal.core.search.matching; |
| |
| import org.eclipse.core.runtime.CoreException; |
| |
| import org.eclipse.jdt.core.IJavaElement; |
| import org.eclipse.jdt.core.IPackageFragment; |
| import org.eclipse.jdt.core.IPackageFragmentRoot; |
| import org.eclipse.jdt.core.JavaModelException; |
| import org.eclipse.jdt.core.search.PackageReferenceMatch; |
| import org.eclipse.jdt.core.search.SearchPattern; |
| import org.eclipse.jdt.core.compiler.CharOperation; |
| import org.eclipse.jdt.internal.compiler.ast.*; |
| import org.eclipse.jdt.internal.compiler.lookup.*; |
| import org.eclipse.jdt.internal.compiler.util.Util; |
| |
| public class PackageReferenceLocator extends PatternLocator { |
| |
| protected PackageReferencePattern pattern; |
| |
| // check that referenced type is actually defined in this package fragment |
| public static boolean isDeclaringPackageFragment(IPackageFragment packageFragment, ReferenceBinding typeBinding) { |
| char[] fileName = typeBinding.getFileName(); |
| if (fileName != null) { |
| // retrieve the actual file name from the full path (sources are generally only containing it already) |
| fileName = CharOperation.replaceOnCopy(fileName, '/', '\\'); // ensure to not do any side effect on file name (see https://bugs.eclipse.org/bugs/show_bug.cgi?id=136016) |
| fileName = CharOperation.lastSegment(fileName, '\\'); |
| |
| try { |
| switch (packageFragment.getKind()) { |
| case IPackageFragmentRoot.K_SOURCE : |
| if (!org.eclipse.jdt.internal.core.util.Util.isJavaLikeFileName(fileName) || !packageFragment.getCompilationUnit(new String(fileName)).exists()) { |
| return false; // unit doesn't live in selected package |
| } |
| break; |
| case IPackageFragmentRoot.K_BINARY : |
| // if (Util.isJavaFileName(fileName)) { // binary with attached source |
| // int length = fileName.length; |
| // System.arraycopy(fileName, 0, fileName = new char[length], 0, length - 4); // copy all but extension |
| // System.arraycopy(SuffixConstants.SUFFIX_class, 0, fileName, length - 4, 4); |
| // } |
| if (!Util.isClassFileName(fileName) || !packageFragment.getClassFile(new String(fileName)).exists()) { |
| return false; // classfile doesn't live in selected package |
| } |
| break; |
| } |
| } catch(JavaModelException e) { |
| // unable to determine kind; tolerate this match |
| } |
| } |
| return true; // by default, do not eliminate |
| } |
| |
| public PackageReferenceLocator(PackageReferencePattern pattern) { |
| super(pattern); |
| |
| this.pattern = pattern; |
| } |
| public int match(Annotation node, MatchingNodeSet nodeSet) { |
| return match(node.type, nodeSet); |
| } |
| public int match(ASTNode node, MatchingNodeSet nodeSet) { // interested in ImportReference |
| if (!(node instanceof ImportReference)) return IMPOSSIBLE_MATCH; |
| |
| return nodeSet.addMatch(node, matchLevel((ImportReference) node)); |
| } |
| //public int match(ConstructorDeclaration node, MatchingNodeSet nodeSet) - SKIP IT |
| //public int match(Expression node, MatchingNodeSet nodeSet) - SKIP IT |
| //public int match(FieldDeclaration node, MatchingNodeSet nodeSet) - SKIP IT |
| //public int match(MethodDeclaration node, MatchingNodeSet nodeSet) - SKIP IT |
| //public int match(MessageSend node, MatchingNodeSet nodeSet) - SKIP IT |
| public int match(Reference node, MatchingNodeSet nodeSet) { // interested in QualifiedNameReference |
| if (!(node instanceof QualifiedNameReference)) return IMPOSSIBLE_MATCH; |
| |
| return nodeSet.addMatch(node, matchLevelForTokens(((QualifiedNameReference) node).tokens)); |
| } |
| //public int match(TypeDeclaration node, MatchingNodeSet nodeSet) - SKIP IT |
| public int match(TypeReference node, MatchingNodeSet nodeSet) { // interested in QualifiedTypeReference only |
| if (node instanceof JavadocSingleTypeReference) { |
| char[][] tokens = new char[][] { ((JavadocSingleTypeReference) node).token }; |
| return nodeSet.addMatch(node, matchLevelForTokens(tokens)); |
| } |
| if (!(node instanceof QualifiedTypeReference)) return IMPOSSIBLE_MATCH; |
| return nodeSet.addMatch(node, matchLevelForTokens(((QualifiedTypeReference) node).tokens)); |
| } |
| |
| protected int matchLevel(ImportReference importRef) { |
| return matchLevelForTokens(importRef.tokens); |
| } |
| protected int matchLevelForTokens(char[][] tokens) { |
| if (this.pattern.pkgName == null) return ACCURATE_MATCH; |
| |
| switch (this.matchMode) { |
| case SearchPattern.R_EXACT_MATCH: |
| case SearchPattern.R_PREFIX_MATCH: |
| if (CharOperation.prefixEquals(this.pattern.pkgName, CharOperation.concatWith(tokens, '.'), this.isCaseSensitive)) { |
| return POSSIBLE_MATCH; |
| } |
| break; |
| |
| case SearchPattern.R_PATTERN_MATCH: |
| char[] patternName = this.pattern.pkgName[this.pattern.pkgName.length - 1] == '*' |
| ? this.pattern.pkgName |
| : CharOperation.concat(this.pattern.pkgName, ".*".toCharArray()); //$NON-NLS-1$ |
| if (CharOperation.match(patternName, CharOperation.concatWith(tokens, '.'), this.isCaseSensitive)) { |
| return POSSIBLE_MATCH; |
| } |
| break; |
| |
| case SearchPattern.R_REGEXP_MATCH : |
| // TODO (frederic) implement regular expression match |
| break; |
| |
| case SearchPattern.R_CAMELCASE_MATCH: |
| char[] packageName = CharOperation.concatWith(tokens, '.'); |
| if (CharOperation.camelCaseMatch(this.pattern.pkgName, packageName, false)) { |
| return POSSIBLE_MATCH; |
| } |
| // only test case insensitive as CamelCase already verified prefix case sensitive |
| if (!this.isCaseSensitive && CharOperation.prefixEquals(this.pattern.pkgName, packageName, false)) { |
| return POSSIBLE_MATCH; |
| } |
| break; |
| |
| case SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH: |
| packageName = CharOperation.concatWith(tokens, '.'); |
| if (CharOperation.camelCaseMatch(this.pattern.pkgName, CharOperation.concatWith(tokens, '.'), true)) { |
| return POSSIBLE_MATCH; |
| } |
| break; |
| } |
| return IMPOSSIBLE_MATCH; |
| } |
| /* (non-Javadoc) |
| * @see org.eclipse.jdt.internal.core.search.matching.PatternLocator#matchLevelAndReportImportRef(org.eclipse.jdt.internal.compiler.ast.ImportReference, org.eclipse.jdt.internal.compiler.lookup.Binding, org.eclipse.jdt.internal.core.search.matching.MatchLocator) |
| */ |
| protected void matchLevelAndReportImportRef(ImportReference importRef, Binding binding, MatchLocator locator) throws CoreException { |
| Binding refBinding = binding; |
| if (importRef.isStatic()) { |
| // for static import, binding can be a field binding or a member type binding |
| // verify that in this case binding is static and use declaring class for fields |
| if (binding instanceof FieldBinding) { |
| FieldBinding fieldBinding = (FieldBinding) binding; |
| if (!fieldBinding.isStatic()) return; |
| refBinding = fieldBinding.declaringClass; |
| } else if (binding instanceof MethodBinding) { |
| MethodBinding methodBinding = (MethodBinding) binding; |
| if (!methodBinding.isStatic()) return; |
| refBinding = methodBinding.declaringClass; |
| } else if (binding instanceof MemberTypeBinding) { |
| MemberTypeBinding memberBinding = (MemberTypeBinding) binding; |
| if (!memberBinding.isStatic()) return; |
| } |
| } |
| super.matchLevelAndReportImportRef(importRef, refBinding, locator); |
| } |
| protected void matchReportImportRef(ImportReference importRef, Binding binding, IJavaElement element, int accuracy, MatchLocator locator) throws CoreException { |
| if (binding == null) { |
| this.matchReportReference(importRef, element, null/*no binding*/, accuracy, locator); |
| } else { |
| if (locator.encloses(element)) { |
| long[] positions = importRef.sourcePositions; |
| int last = positions.length - 1; |
| if (binding instanceof ProblemReferenceBinding) |
| binding = ((ProblemReferenceBinding) binding).closestMatch(); |
| if (binding instanceof ReferenceBinding) { |
| PackageBinding pkgBinding = ((ReferenceBinding) binding).fPackage; |
| if (pkgBinding != null) |
| last = pkgBinding.compoundName.length; |
| } |
| if (binding instanceof PackageBinding) |
| last = ((PackageBinding) binding).compoundName.length; |
| int start = (int) (positions[0] >>> 32); |
| int end = (int) positions[last - 1]; |
| this.match = locator.newPackageReferenceMatch(element, accuracy, start, end-start+1, importRef); |
| locator.report(this.match); |
| } |
| } |
| } |
| protected void matchReportReference(ASTNode reference, IJavaElement element, Binding elementBinding, int accuracy, MatchLocator locator) throws CoreException { |
| matchReportReference(reference, element, null, null, elementBinding, accuracy, locator); |
| } |
| protected void matchReportReference(ASTNode reference, IJavaElement element, IJavaElement localElement, IJavaElement[] otherElements, Binding elementBinding, int accuracy, MatchLocator locator) throws CoreException { |
| long[] positions = null; |
| int last = -1; |
| if (reference instanceof ImportReference) { |
| ImportReference importRef = (ImportReference) reference; |
| positions = importRef.sourcePositions; |
| last = (importRef.bits & ASTNode.OnDemand) != 0 ? positions.length : positions.length - 1; |
| } else { |
| TypeBinding typeBinding = null; |
| if (reference instanceof QualifiedNameReference) { |
| QualifiedNameReference qNameRef = (QualifiedNameReference) reference; |
| positions = qNameRef.sourcePositions; |
| switch (qNameRef.bits & ASTNode.RestrictiveFlagMASK) { |
| case Binding.FIELD : // reading a field |
| typeBinding = qNameRef.actualReceiverType; |
| break; |
| case Binding.TYPE : //=============only type ============== |
| if (qNameRef.binding instanceof TypeBinding) |
| typeBinding = (TypeBinding) qNameRef.binding; |
| break; |
| case Binding.VARIABLE : //============unbound cases=========== |
| case Binding.TYPE | Binding.VARIABLE : |
| Binding binding = qNameRef.binding; |
| if (binding instanceof TypeBinding) { |
| typeBinding = (TypeBinding) binding; |
| } else if (binding instanceof ProblemFieldBinding) { |
| typeBinding = qNameRef.actualReceiverType; |
| last = qNameRef.tokens.length - (qNameRef.otherBindings == null ? 2 : qNameRef.otherBindings.length + 2); |
| } else if (binding instanceof ProblemBinding) { |
| ProblemBinding pbBinding = (ProblemBinding) binding; |
| typeBinding = pbBinding.searchType; |
| last = CharOperation.occurencesOf('.', pbBinding.name); |
| } |
| break; |
| } |
| } else if (reference instanceof QualifiedTypeReference) { |
| QualifiedTypeReference qTypeRef = (QualifiedTypeReference) reference; |
| positions = qTypeRef.sourcePositions; |
| typeBinding = qTypeRef.resolvedType; |
| } else if (reference instanceof JavadocSingleTypeReference) { |
| JavadocSingleTypeReference jsTypeRef = (JavadocSingleTypeReference) reference; |
| positions = new long[1]; |
| positions[0] = (((long)jsTypeRef.sourceStart) << 32) + jsTypeRef.sourceEnd; |
| typeBinding = jsTypeRef.resolvedType; |
| } |
| if (positions == null) return; |
| if (typeBinding instanceof ArrayBinding) |
| typeBinding = ((ArrayBinding) typeBinding).leafComponentType; |
| if (typeBinding instanceof ProblemReferenceBinding) |
| typeBinding = ((ProblemReferenceBinding) typeBinding).closestMatch(); |
| if (typeBinding instanceof ReferenceBinding) { |
| PackageBinding pkgBinding = ((ReferenceBinding) typeBinding).fPackage; |
| if (pkgBinding != null) |
| last = pkgBinding.compoundName.length; |
| } |
| // Do not report qualified references which are only enclosing type |
| // (see bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=91078) |
| ReferenceBinding enclosingType = typeBinding == null ? null: typeBinding.enclosingType(); |
| if (enclosingType != null) { |
| int length = positions.length; |
| while (enclosingType != null && length > 0) { |
| length--; |
| enclosingType = enclosingType.enclosingType(); |
| } |
| if (length <= 1) return; |
| } |
| } |
| if (last == -1) { |
| last = this.pattern.segments.length; |
| } |
| if (last == 0) return; |
| if (last > positions.length) last = positions.length; |
| int sourceStart = (int) (positions[0] >>> 32); |
| int sourceEnd = ((int) positions[last - 1]); |
| PackageReferenceMatch packageReferenceMatch = locator.newPackageReferenceMatch(element, accuracy, sourceStart, sourceEnd-sourceStart+1, reference); |
| packageReferenceMatch.setLocalElement(localElement); |
| this.match = packageReferenceMatch; |
| locator.report(this.match); |
| } |
| protected int referenceType() { |
| return IJavaElement.PACKAGE_FRAGMENT; |
| } |
| public int resolveLevel(ASTNode node) { |
| if (node instanceof JavadocQualifiedTypeReference) { |
| JavadocQualifiedTypeReference qualifRef = (JavadocQualifiedTypeReference) node; |
| if (qualifRef.packageBinding != null) |
| return resolveLevel(qualifRef.packageBinding); |
| return resolveLevel(qualifRef.resolvedType); |
| } |
| if (node instanceof JavadocSingleTypeReference) { |
| JavadocSingleTypeReference singleRef = (JavadocSingleTypeReference) node; |
| if (singleRef.packageBinding != null) |
| return resolveLevel(singleRef.packageBinding); |
| return IMPOSSIBLE_MATCH; |
| } |
| if (node instanceof QualifiedTypeReference) |
| return resolveLevel(((QualifiedTypeReference) node).resolvedType); |
| if (node instanceof QualifiedNameReference) |
| return this.resolveLevel((QualifiedNameReference) node); |
| // if (node instanceof ImportReference) - Not called when resolve is true, see MatchingNodeSet.reportMatching(unit) |
| return IMPOSSIBLE_MATCH; |
| } |
| public int resolveLevel(Binding binding) { |
| if (binding == null) return INACCURATE_MATCH; |
| |
| char[][] compoundName = null; |
| if (binding instanceof ImportBinding) { |
| compoundName = ((ImportBinding) binding).compoundName; |
| } else if (binding instanceof PackageBinding) { |
| compoundName = ((PackageBinding) binding).compoundName; |
| } else { |
| if (binding instanceof ArrayBinding) |
| binding = ((ArrayBinding) binding).leafComponentType; |
| if (binding instanceof ProblemReferenceBinding) |
| binding = ((ProblemReferenceBinding) binding).closestMatch(); |
| if (binding == null) return INACCURATE_MATCH; |
| |
| if (binding instanceof ReferenceBinding) { |
| PackageBinding pkgBinding = ((ReferenceBinding) binding).fPackage; |
| if (pkgBinding == null) return INACCURATE_MATCH; |
| compoundName = pkgBinding.compoundName; |
| } |
| } |
| if (compoundName != null && matchesName(this.pattern.pkgName, CharOperation.concatWith(compoundName, '.'))) { |
| if (this.pattern.focus instanceof IPackageFragment && binding instanceof ReferenceBinding) { |
| // check that type is located inside this instance of a package fragment |
| if (!isDeclaringPackageFragment((IPackageFragment) this.pattern.focus, (ReferenceBinding)binding)) |
| return IMPOSSIBLE_MATCH; |
| } |
| return ACCURATE_MATCH; |
| } |
| return IMPOSSIBLE_MATCH; |
| } |
| protected int resolveLevel(QualifiedNameReference qNameRef) { |
| TypeBinding typeBinding = null; |
| switch (qNameRef.bits & ASTNode.RestrictiveFlagMASK) { |
| case Binding.FIELD : // reading a field |
| if (qNameRef.tokens.length < (qNameRef.otherBindings == null ? 3 : qNameRef.otherBindings.length + 3)) |
| return IMPOSSIBLE_MATCH; // must be at least p1.A.x |
| typeBinding = qNameRef.actualReceiverType; |
| break; |
| case Binding.LOCAL : // reading a local variable |
| return IMPOSSIBLE_MATCH; // no package match in it |
| case Binding.TYPE : //=============only type ============== |
| if (qNameRef.binding instanceof TypeBinding) |
| typeBinding = (TypeBinding) qNameRef.binding; |
| break; |
| /* |
| * Handling of unbound qualified name references. The match may reside in the resolved fragment, |
| * which is recorded inside the problem binding, along with the portion of the name until it became a problem. |
| */ |
| case Binding.VARIABLE : //============unbound cases=========== |
| case Binding.TYPE | Binding.VARIABLE : |
| Binding binding = qNameRef.binding; |
| if (binding instanceof ProblemReferenceBinding) { |
| typeBinding = (TypeBinding) binding; |
| } else if (binding instanceof ProblemFieldBinding) { |
| if (qNameRef.tokens.length < (qNameRef.otherBindings == null ? 3 : qNameRef.otherBindings.length + 3)) |
| return IMPOSSIBLE_MATCH; // must be at least p1.A.x |
| typeBinding = qNameRef.actualReceiverType; |
| } else if (binding instanceof ProblemBinding) { |
| ProblemBinding pbBinding = (ProblemBinding) binding; |
| if (CharOperation.occurencesOf('.', pbBinding.name) <= 0) // index of last bound token is one before the pb token |
| return INACCURATE_MATCH; |
| typeBinding = pbBinding.searchType; |
| } |
| break; |
| } |
| return resolveLevel(typeBinding); |
| } |
| public String toString() { |
| return "Locator for " + this.pattern.toString(); //$NON-NLS-1$ |
| } |
| } |
