Examples with ASTNode org.eclipse.jdt.internal.compiler.ast.ASTNode used on opensource projects

Example 11 with ASTNode

use of org.eclipse.jdt.internal.compiler.ast.ASTNode in project lombok by rzwitserloot.

the class PatchExtensionMethodCompletionProposal method getAssistNode.

private static ASTNode getAssistNode(CompletionProposalCollector completionProposalCollector) {
    try {
        InternalCompletionContext context = (InternalCompletionContext) Reflection.contextField.get(completionProposalCollector);
        InternalExtendedCompletionContext extendedContext = (InternalExtendedCompletionContext) Reflection.extendedContextField.get(context);
        if (extendedContext == null)
            return null;
        return (ASTNode) Reflection.assistNodeField.get(extendedContext);
    } catch (Exception ignore) {
        return null;
    }
}

Example 12 with ASTNode

use of org.eclipse.jdt.internal.compiler.ast.ASTNode in project lombok by rzwitserloot.

the class PatchValEclipse method copyInitializationOfForEachIterable.

public static void copyInitializationOfForEachIterable(Parser parser) {
    ASTNode[] astStack;
    int astPtr;
    try {
        astStack = (ASTNode[]) Reflection.astStackField.get(parser);
        astPtr = (Integer) Reflection.astPtrField.get(parser);
    } catch (Exception e) {
        // Most likely we're in ecj or some other plugin usage of the eclipse compiler. No need for this.
        return;
    }
    ForeachStatement foreachDecl = (ForeachStatement) astStack[astPtr];
    ASTNode init = foreachDecl.collection;
    if (init == null)
        return;
    boolean val = couldBeVal(foreachDecl.elementVariable.type);
    boolean var = couldBeVar(foreachDecl.elementVariable.type);
    if (foreachDecl.elementVariable == null || !(val || var))
        return;
    try {
        if (Reflection.iterableCopyField != null)
            Reflection.iterableCopyField.set(foreachDecl.elementVariable, init);
    } catch (Exception e) {
    // In ecj mode this field isn't there and we don't need the copy anyway, so, we ignore the exception.
    }
}

Example 13 with ASTNode

use of org.eclipse.jdt.internal.compiler.ast.ASTNode in project lombok by rzwitserloot.

the class PatchValEclipse method copyInitializationOfLocalDeclaration.

public static void copyInitializationOfLocalDeclaration(Parser parser) {
    ASTNode[] astStack;
    int astPtr;
    try {
        astStack = (ASTNode[]) Reflection.astStackField.get(parser);
        astPtr = (Integer) Reflection.astPtrField.get(parser);
    } catch (Exception e) {
        // Most likely we're in ecj or some other plugin usage of the eclipse compiler. No need for this.
        return;
    }
    AbstractVariableDeclaration variableDecl = (AbstractVariableDeclaration) astStack[astPtr];
    if (!(variableDecl instanceof LocalDeclaration))
        return;
    ASTNode init = variableDecl.initialization;
    if (init == null)
        return;
    boolean val = couldBeVal(variableDecl.type);
    boolean var = couldBeVar(variableDecl.type);
    if (!(val || var))
        return;
    try {
        if (Reflection.initCopyField != null)
            Reflection.initCopyField.set(variableDecl, init);
    } catch (Exception e) {
    // In ecj mode this field isn't there and we don't need the copy anyway, so, we ignore the exception.
    }
}

Example 14 with ASTNode

use of org.eclipse.jdt.internal.compiler.ast.ASTNode 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;
}

Example 15 with ASTNode

use of org.eclipse.jdt.internal.compiler.ast.ASTNode in project lombok by rzwitserloot.

the class PatchExtensionMethodCompletionProposal method getFirstParameterType.

static TypeBinding getFirstParameterType(TypeDeclaration decl, CompletionProposalCollector completionProposalCollector) {
    TypeBinding firstParameterType = null;
    ASTNode node = getAssistNode(completionProposalCollector);
    if (node == null)
        return null;
    if (!(node instanceof CompletionOnQualifiedNameReference) && !(node instanceof CompletionOnSingleNameReference) && !(node instanceof CompletionOnMemberAccess))
        return null;
    // Never offer on 'super.<autocomplete>'.
    if (node instanceof FieldReference && ((FieldReference) node).receiver instanceof SuperReference)
        return null;
    if (node instanceof NameReference) {
        Binding binding = ((NameReference) node).binding;
        /*			if ((node instanceof SingleNameReference) && (((SingleNameReference) node).token.length == 0)) {
				firstParameterType = decl.binding;
			} else */
        if (binding instanceof VariableBinding) {
            firstParameterType = ((VariableBinding) binding).type;
        }
    } else if (node instanceof FieldReference) {
        firstParameterType = ((FieldReference) node).actualReceiverType;
    }
    return firstParameterType;
}