Example usage for org.eclipse.jdt.internal.compiler.ast MessageSend expectedType

Introduction

In this page you can find the example usage for org.eclipse.jdt.internal.compiler.ast MessageSend expectedType.

Prototype

TypeBinding expectedType

To view the source code for org.eclipse.jdt.internal.compiler.ast MessageSend expectedType.

Click Source Link

Usage

From source file:spoon.support.compiler.jdt.JDTTreeBuilder.java

License:Open Source License

@Override
public boolean visit(MessageSend messageSend, BlockScope scope) {
    if (messageSend.actualReceiverType == null || !messageSend.actualReceiverType.isAnnotationType()) {
        CtInvocation<Object> inv = factory.Core().createInvocation();
        if (messageSend.binding != null) {
            inv.setExecutable(references.getExecutableReference(messageSend.binding));
            if (messageSend.binding instanceof ProblemMethodBinding) {
                // We are in a static complex in noclasspath mode.
                if (inv.getExecutable() != null && inv.getExecutable().getDeclaringType() != null) {
                    final CtTypeAccess ta = factory.Core().createTypeAccess();
                    ta.setType(inv.getExecutable().getDeclaringType());
                    inv.setTarget(ta);//w w w . j a  va 2s . c o  m
                }
                if (messageSend.expectedType() != null) {
                    inv.getExecutable().setType(references.getTypeReference(messageSend.expectedType()));
                }
            }
        } else {
            CtExecutableReference<Object> ref = factory.Core().createExecutableReference();
            ref.setSimpleName(new String(messageSend.selector));
            ref.setType(references.getTypeReference(messageSend.expectedType()));
            if (messageSend.receiver.resolvedType == null) {
                // It is crisis dude! static context, we don't have much more information.
                if (messageSend.receiver instanceof SingleNameReference
                        || messageSend.receiver instanceof QualifiedNameReference) {
                    final CtTypeReference<Object> typeReference = factory.Core().createTypeReference();
                    typeReference.setSimpleName(messageSend.receiver.toString());
                    ref.setDeclaringType(typeReference);
                }
            } else {
                ref.setDeclaringType(references.getTypeReference(messageSend.receiver.resolvedType));
            }
            if (messageSend.arguments != null) {
                final List<CtTypeReference<?>> parameters = new ArrayList<CtTypeReference<?>>();
                for (Expression argument : messageSend.arguments) {
                    parameters.add(references.getTypeReference(argument.resolvedType));
                }
                ref.setParameters(parameters);
            }
            inv.setExecutable(ref);
        }
        // inv
        // .setType(references
        // .getTypeReference(messageSend.binding.returnType));
        context.enter(inv, messageSend);
        if (!(messageSend.receiver.getClass().equals(ThisReference.class))) {
            messageSend.receiver.traverse(this, scope);
        }
        context.pushArgument(inv);
        if (messageSend.arguments != null) {
            for (Expression e : messageSend.arguments) {
                e.traverse(this, scope);
            }
        }
        if (messageSend.genericTypeArguments() != null) {
            for (TypeBinding typeBinding : messageSend.genericTypeArguments()) {
                inv.getExecutable().addActualTypeArgument(references.getTypeReference(typeBinding));
            }
        }
        context.popArgument(inv);
        return false;

    } else {
        CtAnnotationFieldAccess<Object> acc = factory.Core().createAnnotationFieldAccess();
        acc.setVariable(references.getVariableReference(messageSend.binding));
        acc.setType(references.getTypeReference(messageSend.resolvedType));

        context.enter(acc, messageSend);

        context.target.push(acc);
        messageSend.receiver.traverse(this, scope);
        context.target.pop();

        return false;
    }
}

---

From source file:spoon.support.compiler.jdt.ReferenceBuilder.java

License:Open Source License

<T> CtExecutableReference<T> getExecutableReference(MessageSend messageSend) {
    if (messageSend.binding != null) {
        return getExecutableReference(messageSend.binding);
    }//from  www . jav  a  2s  .  c om
    CtExecutableReference<T> ref = jdtTreeBuilder.getFactory().Core().createExecutableReference();
    ref.setSimpleName(CharOperation.charToString(messageSend.selector));
    ref.setType(this.<T>getTypeReference(messageSend.expectedType(), true));
    if (messageSend.receiver.resolvedType == null) {
        // It is crisis dude! static context, we don't have much more information.
        ref.setStatic(true);
        if (messageSend.receiver instanceof SingleNameReference) {
            ref.setDeclaringType(jdtTreeBuilder.getHelper()
                    .createTypeAccessNoClasspath((SingleNameReference) messageSend.receiver).getAccessedType());
        } else if (messageSend.receiver instanceof QualifiedNameReference) {
            ref.setDeclaringType(jdtTreeBuilder.getHelper()
                    .createTypeAccessNoClasspath((QualifiedNameReference) messageSend.receiver)
                    .getAccessedType());
        }
    } else {
        ref.setDeclaringType(getTypeReference(messageSend.receiver.resolvedType));
    }
    if (messageSend.arguments != null) {
        final List<CtTypeReference<?>> parameters = new ArrayList<>();
        for (Expression expression : messageSend.arguments) {
            parameters.add(getTypeReference(expression.resolvedType, true));
        }
        ref.setParameters(parameters);
    }
    return ref;
}

---