Example usage for org.eclipse.jdt.internal.core.search.matching PatternLocator qualifiedPattern

Introduction

In this page you can find the example usage for org.eclipse.jdt.internal.core.search.matching PatternLocator qualifiedPattern.

Prototype

public static char[] qualifiedPattern(char[] simpleNamePattern, char[] qualificationPattern) 

Source Link

Usage

From source file:org.eclipse.jdt.internal.core.search.matching.MatchLocator.java

License:Open Source License

public MethodBinding getMethodBinding(MethodPattern methodPattern) {
    if (this.unitScope == null)
        return null;
    // Try to get binding from cache
    Binding binding = (Binding) this.bindings.get(methodPattern);
    if (binding != null) {
        if (binding instanceof MethodBinding && binding.isValidBinding())
            return (MethodBinding) binding;
        return null;
    }//from   w  ww .j  ava  2  s  .c o  m
    //   Get binding from unit scope
    char[] typeName = PatternLocator.qualifiedPattern(methodPattern.declaringSimpleName,
            methodPattern.declaringQualification);
    if (typeName == null) {
        if (methodPattern.declaringType == null)
            return null;
        typeName = methodPattern.declaringType.getFullyQualifiedName().toCharArray();
    }
    TypeBinding declaringTypeBinding = getType(typeName, typeName);
    if (declaringTypeBinding != null) {
        if (declaringTypeBinding.isArrayType()) {
            declaringTypeBinding = declaringTypeBinding.leafComponentType();
        }
        if (!declaringTypeBinding.isBaseType()) {
            char[][] parameterTypes = methodPattern.parameterSimpleNames;
            if (parameterTypes == null)
                return null;
            int paramTypeslength = parameterTypes.length;
            ReferenceBinding referenceBinding = (ReferenceBinding) declaringTypeBinding;
            MethodBinding[] methods = referenceBinding.getMethods(methodPattern.selector);
            int methodsLength = methods.length;
            TypeVariableBinding[] refTypeVariables = referenceBinding.typeVariables();
            int typeVarLength = refTypeVariables == null ? 0 : refTypeVariables.length;
            for (int i = 0; i < methodsLength; i++) {
                TypeBinding[] methodParameters = methods[i].parameters;
                int paramLength = methodParameters == null ? 0 : methodParameters.length;
                TypeVariableBinding[] methodTypeVariables = methods[i].typeVariables;
                int methTypeVarLength = methodTypeVariables == null ? 0 : methodTypeVariables.length;
                boolean found = false;
                if (methodParameters != null && paramLength == paramTypeslength) {
                    for (int p = 0; p < paramLength; p++) {
                        if (CharOperation.equals(methodParameters[p].sourceName(), parameterTypes[p])) {
                            // param erasure match
                            found = true;
                        } else {
                            // type variable
                            found = false;
                            if (refTypeVariables != null) {
                                for (int v = 0; v < typeVarLength; v++) {
                                    if (!CharOperation.equals(refTypeVariables[v].sourceName,
                                            parameterTypes[p])) {
                                        found = false;
                                        break;
                                    }
                                    found = true;
                                }
                            }
                            if (!found && methodTypeVariables != null) {
                                for (int v = 0; v < methTypeVarLength; v++) {
                                    if (!CharOperation.equals(methodTypeVariables[v].sourceName,
                                            parameterTypes[p])) {
                                        found = false;
                                        break;
                                    }
                                    found = true;
                                }
                            }
                            if (!found)
                                break;
                        }
                    }
                }
                if (found) {
                    this.bindings.put(methodPattern, methods[i]);
                    return methods[i];
                }
            }
        }
    }
    this.bindings.put(methodPattern,
            new ProblemMethodBinding(methodPattern.selector, null, ProblemReasons.NotFound));
    return null;
}

---