Example usage for org.eclipse.jdt.internal.compiler.lookup MethodBinding isOverriding

Introduction

In this page you can find the example usage for org.eclipse.jdt.internal.compiler.lookup MethodBinding isOverriding.

Prototype

public final boolean isOverriding() 

Source Link

Usage

From source file:org.eclipse.jdt.internal.compiler.lookup.Scope.java

License:Open Source License

/**
 * Internal use only/*from  w  ww  .j av a2  s  .  co  m*/
 * Given a method, returns null if arguments cannot be converted to parameters.
 * Will answer a substituted method in case the method was generic and type inference got triggered;
 * in case the method was originally compatible, then simply answer it back.
 */
protected final MethodBinding computeCompatibleMethod(MethodBinding method, TypeBinding[] arguments,
        InvocationSite invocationSite) {
    TypeBinding[] genericTypeArguments = invocationSite.genericTypeArguments();
    TypeBinding[] parameters = method.parameters;
    TypeVariableBinding[] typeVariables = method.typeVariables;
    if (parameters == arguments && (method.returnType.tagBits & TagBits.HasTypeVariable) == 0
            && genericTypeArguments == null && typeVariables == Binding.NO_TYPE_VARIABLES)
        return method;

    int argLength = arguments.length;
    int paramLength = parameters.length;
    boolean isVarArgs = method.isVarargs();
    if (argLength != paramLength)
        if (!isVarArgs || argLength < paramLength - 1)
            return null; // incompatible

    // https://bugs.eclipse.org/bugs/show_bug.cgi?id=330435, inference should kick in only at source 1.5+
    if (typeVariables != Binding.NO_TYPE_VARIABLES
            && compilerOptions().sourceLevel >= ClassFileConstants.JDK1_5) { // generic method
        TypeBinding[] newArgs = null;
        for (int i = 0; i < argLength; i++) {
            TypeBinding param = i < paramLength ? parameters[i] : parameters[paramLength - 1];
            if (arguments[i].isBaseType() != param.isBaseType()) {
                if (newArgs == null) {
                    newArgs = new TypeBinding[argLength];
                    System.arraycopy(arguments, 0, newArgs, 0, argLength);
                }
                newArgs[i] = environment().computeBoxingType(arguments[i]);
            }
        }
        if (newArgs != null)
            arguments = newArgs;
        method = ParameterizedGenericMethodBinding.computeCompatibleMethod(method, arguments, this,
                invocationSite);
        if (method == null)
            return null; // incompatible
        if (!method.isValidBinding())
            return method; // bound check issue is taking precedence
    } else if (genericTypeArguments != null && compilerOptions().complianceLevel < ClassFileConstants.JDK1_7) {
        if (method instanceof ParameterizedGenericMethodBinding) {
            if (!((ParameterizedGenericMethodBinding) method).wasInferred)
                // attempt to invoke generic method of raw type with type hints <String>foo()
                return new ProblemMethodBinding(method, method.selector, genericTypeArguments,
                        ProblemReasons.TypeArgumentsForRawGenericMethod);
        } else if (!method.isOverriding() || !isOverriddenMethodGeneric(method)) {
            return new ProblemMethodBinding(method, method.selector, genericTypeArguments,
                    ProblemReasons.TypeParameterArityMismatch);
        }
    }

    if (parameterCompatibilityLevel(method, arguments) > NOT_COMPATIBLE) {
        if ((method.tagBits & TagBits.AnnotationPolymorphicSignature) != 0) {
            // generate polymorphic method
            return this.environment().createPolymorphicMethod(method, arguments);
        }
        return method;
    }
    // if method is generic and type arguments have been supplied, only then answer a problem 
    // of ParameterizedMethodTypeMismatch, else a non-generic method was invoked using type arguments
    // in which case this problem category will be bogus
    if (genericTypeArguments != null && typeVariables != Binding.NO_TYPE_VARIABLES)
        return new ProblemMethodBinding(method, method.selector, arguments,
                ProblemReasons.ParameterizedMethodTypeMismatch);
    return null; // incompatible
}

---

From source file:org.eclipse.objectteams.otdt.internal.core.compiler.model.MethodModel.java

License:Open Source License

public static boolean isOverriding(MethodBinding methodBinding, CompilationUnitScope scope) {
    if (!methodBinding.declaringClass.isBinaryBinding()) {
        Dependencies.ensureBindingState(methodBinding.declaringClass,
                ITranslationStates.STATE_METHODS_VERIFIED);
        return methodBinding.isOverriding();
    }/*from   w w w  .  j ava2s  .com*/
    ReferenceBinding currentClass = methodBinding.declaringClass.superclass();
    while (currentClass != null) {
        MethodBinding candidate = currentClass.getExactMethod(methodBinding.selector, methodBinding.parameters,
                scope);
        if (candidate != null && candidate.isValidBinding())
            return true;
        currentClass = currentClass.superclass();
    }
    return false;
}

---