Search in sources :

Example 6 with MethodBinding

use of org.eclipse.jdt.internal.compiler.lookup.MethodBinding in project lombok by rzwitserloot.

the class ExtensionMethodCompletionProposal method setMethodBinding.

public void setMethodBinding(final MethodBinding method, final ASTNode node) {
    MethodBinding original = method.original();
    TypeBinding[] parameters = Arrays.copyOf(method.parameters, method.parameters.length);
    method.parameters = Arrays.copyOfRange(method.parameters, 1, method.parameters.length);
    TypeBinding[] originalParameters = null;
    if (original != method) {
        originalParameters = Arrays.copyOf(method.original().parameters, method.original().parameters.length);
        method.original().parameters = Arrays.copyOfRange(method.original().parameters, 1, method.original().parameters.length);
    }
    int length = method.parameters == null ? 0 : method.parameters.length;
    char[][] parameterPackageNames = new char[length][];
    char[][] parameterTypeNames = new char[length][];
    for (int i = 0; i < length; i++) {
        TypeBinding type = method.original().parameters[i];
        parameterPackageNames[i] = type.qualifiedPackageName();
        parameterTypeNames[i] = type.qualifiedSourceName();
    }
    char[] completion = CharOperation.concat(method.selector, new char[] { '(', ')' });
    setDeclarationSignature(CompletionEngine.getSignature(method.declaringClass));
    setSignature(CompletionEngine.getSignature(method));
    if (original != method) {
        setOriginalSignature(CompletionEngine.getSignature(original));
    }
    setDeclarationPackageName(method.declaringClass.qualifiedPackageName());
    setDeclarationTypeName(method.declaringClass.qualifiedSourceName());
    setParameterPackageNames(parameterPackageNames);
    setParameterTypeNames(parameterTypeNames);
    setPackageName(method.returnType.qualifiedPackageName());
    setTypeName(method.returnType.qualifiedSourceName());
    setName(method.selector);
    setCompletion(completion);
    setFlags(method.modifiers & (~AccStatic));
    int index = node.sourceEnd + 1;
    if (node instanceof CompletionOnQualifiedNameReference) {
        index -= ((CompletionOnQualifiedNameReference) node).completionIdentifier.length;
    }
    if (node instanceof CompletionOnMemberAccess) {
        index -= ((CompletionOnMemberAccess) node).token.length;
    }
    if (node instanceof CompletionOnSingleNameReference) {
        index -= ((CompletionOnSingleNameReference) node).token.length;
    }
    setReplaceRange(index, index);
    setTokenRange(index, index);
    setRelevance(100);
    method.parameters = parameters;
    if (original != method) {
        method.original().parameters = originalParameters;
    }
}
Also used : CompletionOnMemberAccess(org.eclipse.jdt.internal.codeassist.complete.CompletionOnMemberAccess) TypeBinding(org.eclipse.jdt.internal.compiler.lookup.TypeBinding) MethodBinding(org.eclipse.jdt.internal.compiler.lookup.MethodBinding) CompletionOnSingleNameReference(org.eclipse.jdt.internal.codeassist.complete.CompletionOnSingleNameReference) CompletionOnQualifiedNameReference(org.eclipse.jdt.internal.codeassist.complete.CompletionOnQualifiedNameReference)

Example 7 with MethodBinding

use of org.eclipse.jdt.internal.compiler.lookup.MethodBinding in project lombok by rzwitserloot.

the class PatchDelegate method addAllMethodBindings0.

private static void addAllMethodBindings0(List<BindingTuple> list, TypeBinding binding, Set<String> banList, char[] fieldName, ASTNode responsible) throws DelegateRecursion {
    if (binding instanceof SourceTypeBinding) {
        ClassScope scope = ((SourceTypeBinding) binding).scope;
        if (scope != null)
            scope.environment().globalOptions.storeAnnotations = true;
    }
    if (binding == null)
        return;
    TypeBinding inner;
    if (binding instanceof ParameterizedTypeBinding) {
        inner = ((ParameterizedTypeBinding) binding).genericType();
    } else {
        inner = binding;
    }
    if (inner instanceof SourceTypeBinding) {
        ClassScope cs = ((SourceTypeBinding) inner).scope;
        if (cs != null) {
            try {
                Reflection.classScopeBuildFieldsAndMethodsMethod.invoke(cs);
            } catch (Exception e) {
            // See 'Reflection' class for why we ignore this exception.
            }
        }
    }
    if (!(binding instanceof ReferenceBinding)) {
        return;
    }
    ReferenceBinding rb = (ReferenceBinding) binding;
    MethodBinding[] availableMethods = rb.availableMethods();
    FieldBinding[] availableFields = rb.availableFields();
    failIfContainsAnnotation(binding, availableMethods);
    failIfContainsAnnotation(binding, availableFields);
    MethodBinding[] parameterizedSigs = availableMethods;
    MethodBinding[] baseSigs = parameterizedSigs;
    if (binding instanceof ParameterizedTypeBinding) {
        baseSigs = ((ParameterizedTypeBinding) binding).genericType().availableMethods();
        if (baseSigs.length != parameterizedSigs.length) {
            // The last known state of eclipse source says this can't happen, so we rely on it,
            // but if this invariant is broken, better to go with 'arg0' naming instead of crashing.
            baseSigs = parameterizedSigs;
        }
    }
    for (int i = 0; i < parameterizedSigs.length; i++) {
        MethodBinding mb = parameterizedSigs[i];
        String sig = printSig(mb);
        if (mb.isStatic())
            continue;
        if (mb.isBridge())
            continue;
        if (mb.isConstructor())
            continue;
        if (mb.isDefaultAbstract())
            continue;
        if (!mb.isPublic())
            continue;
        if (mb.isSynthetic())
            continue;
        // If add returns false, it was already in there.
        if (!banList.add(sig))
            continue;
        BindingTuple pair = new BindingTuple(mb, baseSigs[i], fieldName, responsible);
        list.add(pair);
    }
    addAllMethodBindings0(list, rb.superclass(), banList, fieldName, responsible);
    ReferenceBinding[] interfaces = rb.superInterfaces();
    if (interfaces != null) {
        for (ReferenceBinding iface : interfaces) addAllMethodBindings0(list, iface, banList, fieldName, responsible);
    }
}
Also used : ParameterizedTypeBinding(org.eclipse.jdt.internal.compiler.lookup.ParameterizedTypeBinding) ParameterizedTypeBinding(org.eclipse.jdt.internal.compiler.lookup.ParameterizedTypeBinding) TypeBinding(org.eclipse.jdt.internal.compiler.lookup.TypeBinding) SourceTypeBinding(org.eclipse.jdt.internal.compiler.lookup.SourceTypeBinding) BaseTypeBinding(org.eclipse.jdt.internal.compiler.lookup.BaseTypeBinding) UnresolvedReferenceBinding(org.eclipse.jdt.internal.compiler.lookup.UnresolvedReferenceBinding) ReferenceBinding(org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding) ClassScope(org.eclipse.jdt.internal.compiler.lookup.ClassScope) FieldBinding(org.eclipse.jdt.internal.compiler.lookup.FieldBinding) MethodBinding(org.eclipse.jdt.internal.compiler.lookup.MethodBinding) SourceTypeBinding(org.eclipse.jdt.internal.compiler.lookup.SourceTypeBinding)

Example 8 with MethodBinding

use of org.eclipse.jdt.internal.compiler.lookup.MethodBinding in project lombok by rzwitserloot.

the class PatchDelegate method createDelegateMethod.

private static MethodDeclaration createDelegateMethod(char[] name, EclipseNode typeNode, BindingTuple pair, CompilationResult compilationResult, EclipseNode annNode, DelegateReceiver delegateReceiver) {
    /* public <T, U, ...> ReturnType methodName(ParamType1 name1, ParamType2 name2, ...) throws T1, T2, ... {
		 *      (return) delegate.<T, U>methodName(name1, name2);
		 *  }
		 */
    boolean isVarargs = (pair.base.modifiers & ClassFileConstants.AccVarargs) != 0;
    try {
        checkConflictOfTypeVarNames(pair, typeNode);
    } catch (CantMakeDelegates e) {
        annNode.addError("There's a conflict in the names of type parameters. Fix it by renaming the following type parameters of your class: " + e.conflicted);
        return null;
    }
    ASTNode source = annNode.get();
    int pS = source.sourceStart, pE = source.sourceEnd;
    MethodBinding binding = pair.parameterized;
    MethodDeclaration method = new MethodDeclaration(compilationResult);
    setGeneratedBy(method, source);
    method.sourceStart = pS;
    method.sourceEnd = pE;
    method.modifiers = ClassFileConstants.AccPublic;
    method.returnType = makeType(binding.returnType, source, false);
    boolean isDeprecated = binding.isDeprecated();
    method.selector = binding.selector;
    if (binding.thrownExceptions != null && binding.thrownExceptions.length > 0) {
        method.thrownExceptions = new TypeReference[binding.thrownExceptions.length];
        for (int i = 0; i < method.thrownExceptions.length; i++) {
            method.thrownExceptions[i] = makeType(binding.thrownExceptions[i], source, false);
        }
    }
    MessageSend call = new MessageSend();
    call.sourceStart = pS;
    call.sourceEnd = pE;
    call.nameSourcePosition = pos(source);
    setGeneratedBy(call, source);
    call.receiver = delegateReceiver.get(source, name);
    call.selector = binding.selector;
    if (binding.typeVariables != null && binding.typeVariables.length > 0) {
        method.typeParameters = new TypeParameter[binding.typeVariables.length];
        call.typeArguments = new TypeReference[binding.typeVariables.length];
        for (int i = 0; i < method.typeParameters.length; i++) {
            method.typeParameters[i] = new TypeParameter();
            method.typeParameters[i].sourceStart = pS;
            method.typeParameters[i].sourceEnd = pE;
            setGeneratedBy(method.typeParameters[i], source);
            method.typeParameters[i].name = binding.typeVariables[i].sourceName;
            call.typeArguments[i] = new SingleTypeReference(binding.typeVariables[i].sourceName, pos(source));
            setGeneratedBy(call.typeArguments[i], source);
            ReferenceBinding super1 = binding.typeVariables[i].superclass;
            ReferenceBinding[] super2 = binding.typeVariables[i].superInterfaces;
            if (super2 == null)
                super2 = new ReferenceBinding[0];
            if (super1 != null || super2.length > 0) {
                int offset = super1 == null ? 0 : 1;
                method.typeParameters[i].bounds = new TypeReference[super2.length + offset - 1];
                if (super1 != null)
                    method.typeParameters[i].type = makeType(super1, source, false);
                else
                    method.typeParameters[i].type = makeType(super2[0], source, false);
                int ctr = 0;
                for (int j = (super1 == null) ? 1 : 0; j < super2.length; j++) {
                    method.typeParameters[i].bounds[ctr] = makeType(super2[j], source, false);
                    method.typeParameters[i].bounds[ctr++].bits |= ASTNode.IsSuperType;
                }
            }
        }
    }
    if (isDeprecated) {
        method.annotations = new Annotation[] { generateDeprecatedAnnotation(source) };
    }
    method.bits |= ECLIPSE_DO_NOT_TOUCH_FLAG;
    if (binding.parameters != null && binding.parameters.length > 0) {
        method.arguments = new Argument[binding.parameters.length];
        call.arguments = new Expression[method.arguments.length];
        for (int i = 0; i < method.arguments.length; i++) {
            AbstractMethodDeclaration sourceElem;
            try {
                sourceElem = pair.base.sourceMethod();
            } catch (Exception e) {
                sourceElem = null;
            }
            char[] argName;
            if (sourceElem == null)
                argName = ("arg" + i).toCharArray();
            else {
                argName = sourceElem.arguments[i].name;
            }
            method.arguments[i] = new Argument(argName, pos(source), makeType(binding.parameters[i], source, false), ClassFileConstants.AccFinal);
            setGeneratedBy(method.arguments[i], source);
            call.arguments[i] = new SingleNameReference(argName, pos(source));
            setGeneratedBy(call.arguments[i], source);
        }
        if (isVarargs) {
            method.arguments[method.arguments.length - 1].type.bits |= ASTNode.IsVarArgs;
        }
    }
    Statement body;
    if (method.returnType instanceof SingleTypeReference && ((SingleTypeReference) method.returnType).token == TypeConstants.VOID) {
        body = call;
    } else {
        body = new ReturnStatement(call, source.sourceStart, source.sourceEnd);
        setGeneratedBy(body, source);
    }
    method.statements = new Statement[] { body };
    return method;
}
Also used : TypeParameter(org.eclipse.jdt.internal.compiler.ast.TypeParameter) Argument(org.eclipse.jdt.internal.compiler.ast.Argument) MethodDeclaration(org.eclipse.jdt.internal.compiler.ast.MethodDeclaration) AbstractMethodDeclaration(org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration) Statement(org.eclipse.jdt.internal.compiler.ast.Statement) ReturnStatement(org.eclipse.jdt.internal.compiler.ast.ReturnStatement) UnresolvedReferenceBinding(org.eclipse.jdt.internal.compiler.lookup.UnresolvedReferenceBinding) ReferenceBinding(org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding) SingleNameReference(org.eclipse.jdt.internal.compiler.ast.SingleNameReference) MessageSend(org.eclipse.jdt.internal.compiler.ast.MessageSend) SingleTypeReference(org.eclipse.jdt.internal.compiler.ast.SingleTypeReference) ASTNode(org.eclipse.jdt.internal.compiler.ast.ASTNode) ReturnStatement(org.eclipse.jdt.internal.compiler.ast.ReturnStatement) MethodBinding(org.eclipse.jdt.internal.compiler.lookup.MethodBinding) AbstractMethodDeclaration(org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration)

Aggregations

MethodBinding (org.eclipse.jdt.internal.compiler.lookup.MethodBinding)8 ReferenceBinding (org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding)6 TypeBinding (org.eclipse.jdt.internal.compiler.lookup.TypeBinding)6 ArrayList (java.util.ArrayList)3 ASTNode (org.eclipse.jdt.internal.compiler.ast.ASTNode)3 IJavaElement (org.eclipse.jdt.core.IJavaElement)2 IMethod (org.eclipse.jdt.core.IMethod)2 IType (org.eclipse.jdt.core.IType)2 JavaModelException (org.eclipse.jdt.core.JavaModelException)2 AbstractMethodDeclaration (org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration)2 Argument (org.eclipse.jdt.internal.compiler.ast.Argument)2 MessageSend (org.eclipse.jdt.internal.compiler.ast.MessageSend)2 MethodDeclaration (org.eclipse.jdt.internal.compiler.ast.MethodDeclaration)2 SingleNameReference (org.eclipse.jdt.internal.compiler.ast.SingleNameReference)2 Binding (org.eclipse.jdt.internal.compiler.lookup.Binding)2 FieldBinding (org.eclipse.jdt.internal.compiler.lookup.FieldBinding)2 ProblemMethodBinding (org.eclipse.jdt.internal.compiler.lookup.ProblemMethodBinding)2 UnresolvedReferenceBinding (org.eclipse.jdt.internal.compiler.lookup.UnresolvedReferenceBinding)2 JavaElement (org.eclipse.jdt.internal.core.JavaElement)2 List (java.util.List)1