Search in sources :

Example 1 with CtParameter

use of spoon.reflect.declaration.CtParameter in project Ex2Amplifier by STAMP-project.

the class MainGenerator method initMainMethod.

private static CtMethod<?> initMainMethod(Factory factory) {
    final CtMethod<Void> mainMethod = factory.createMethod();
    mainMethod.setSimpleName("main");
    mainMethod.addModifier(ModifierKind.PUBLIC);
    mainMethod.addModifier(ModifierKind.STATIC);
    mainMethod.setType(factory.Type().VOID_PRIMITIVE);
    final CtParameter parameter = factory.createParameter();
    parameter.setSimpleName("args");
    parameter.setType(factory.Type().get(String[].class).getReference());
    mainMethod.addParameter(parameter);
    return mainMethod;
}
Also used : CtParameter(spoon.reflect.declaration.CtParameter)

Example 2 with CtParameter

use of spoon.reflect.declaration.CtParameter in project spoon by INRIA.

the class ReferenceBuilder method getLambdaExecutableReference.

/**
 * In noclasspath, lambda doesn't have always a binding for their variables accesses in their block/expression.
 * Here, we make the job of JDT and bind their variables accesses to their parameters.
 *
 * @param singleNameReference Name of the variable access.
 * @return executable reference which corresponds to the lambda.
 */
public CtExecutableReference<?> getLambdaExecutableReference(SingleNameReference singleNameReference) {
    ASTPair potentialLambda = null;
    for (ASTPair astPair : jdtTreeBuilder.getContextBuilder().stack) {
        if (astPair.node instanceof LambdaExpression) {
            potentialLambda = astPair;
            // stop at innermost lambda, fixes #1100
            break;
        }
    }
    if (potentialLambda == null) {
        return null;
    }
    LambdaExpression lambdaJDT = (LambdaExpression) potentialLambda.node;
    for (Argument argument : lambdaJDT.arguments()) {
        if (CharOperation.equals(argument.name, singleNameReference.token)) {
            CtTypeReference<?> declaringType = null;
            if (lambdaJDT.enclosingScope instanceof MethodScope) {
                declaringType = jdtTreeBuilder.getReferencesBuilder().getTypeReference(((MethodScope) lambdaJDT.enclosingScope).parent.enclosingSourceType());
            }
            CtLambda<?> ctLambda = (CtLambda<?>) potentialLambda.element;
            List<CtTypeReference<?>> parametersType = new ArrayList<>();
            List<CtParameter<?>> parameters = ctLambda.getParameters();
            for (CtParameter<?> parameter : parameters) {
                parametersType.add(parameter.getType() != null ? parameter.getType().clone() : // it's the best match :(
                jdtTreeBuilder.getFactory().Type().OBJECT.clone());
            }
            return jdtTreeBuilder.getFactory().Executable().createReference(declaringType, ctLambda.getType(), ctLambda.getSimpleName(), parametersType);
        }
    }
    return null;
}
Also used : CtLambda(spoon.reflect.code.CtLambda) Argument(org.eclipse.jdt.internal.compiler.ast.Argument) ArrayList(java.util.ArrayList) CtParameter(spoon.reflect.declaration.CtParameter) MethodScope(org.eclipse.jdt.internal.compiler.lookup.MethodScope) CtTypeReference(spoon.reflect.reference.CtTypeReference) LambdaExpression(org.eclipse.jdt.internal.compiler.ast.LambdaExpression)

Example 3 with CtParameter

use of spoon.reflect.declaration.CtParameter in project spoon by INRIA.

the class CommentTest method testBlockComment.

@Test
public void testBlockComment() {
    Factory f = getSpoonFactory();
    CtClass<?> type = (CtClass<?>) f.Type().get(BlockComment.class);
    String strType = type.toString();
    List<CtComment> comments = type.getElements(new TypeFilter<CtComment>(CtComment.class));
    // verify that the number of comment present in the AST is correct
    assertEquals(51, comments.size());
    // verify that all comments present in the AST is printed
    for (CtComment comment : comments) {
        if (comment.getCommentType() == CtComment.CommentType.FILE) {
            // the header of the file is not printed with the toString
            continue;
        }
        assertNotNull(comment.getParent());
        assertTrue(comment.toString() + ":" + comment.getParent() + " is not printed", strType.contains(comment.toString()));
    }
    assertEquals(4, type.getComments().size());
    assertEquals(createFakeBlockComment(f, "comment class"), type.getComments().get(1));
    CtField<?> field = type.getField("field");
    assertEquals(2, field.getComments().size());
    assertEquals(createFakeBlockComment(f, "Comment Field"), field.getComments().get(0));
    assertEquals("/* Comment Field */" + newLine + "/* comment in field */" + newLine + "private int field = 10;", field.toString());
    CtAnonymousExecutable ctAnonymousExecutable = type.getAnonymousExecutables().get(0);
    assertEquals(1, ctAnonymousExecutable.getComments().size());
    assertEquals(createFakeBlockComment(f, "comment static block"), ctAnonymousExecutable.getComments().get(0));
    assertEquals(createFakeBlockComment(f, "comment inside static"), ctAnonymousExecutable.getBody().getStatement(0));
    assertEquals("/* comment static block */" + newLine + "static {" + newLine + "    /* comment inside static */" + newLine + "}", ctAnonymousExecutable.toString());
    CtConstructor constructor = type.getConstructor();
    assertEquals(1, constructor.getComments().size());
    assertEquals(createFakeBlockComment(f, "comment constructor"), constructor.getComments().get(0));
    // index 0 is the implicit super call
    assertEquals(createFakeBlockComment(f, "Comment in constructor"), constructor.getBody().getStatement(1));
    assertEquals("/* comment constructor */" + newLine + "public BlockComment() {" + newLine + "    /* Comment in constructor */" + newLine + "}", constructor.toString());
    CtMethod<Object> m = type.getMethod("m");
    assertEquals(1, m.getComments().size());
    assertEquals(createFakeBlockComment(f, "comment method"), m.getComments().get(0));
    assertEquals(createFakeBlockComment(f, "comment empty method block"), m.getBody().getStatement(0));
    assertEquals("/* comment method */" + newLine + "public void m() {" + newLine + "    /* comment empty method block */" + newLine + "}", m.toString());
    CtMethod<Object> m1 = type.getMethod("m1");
    CtSwitch ctSwitch = m1.getBody().getStatement(0);
    assertEquals(createFakeBlockComment(f, "comment switch"), ctSwitch.getComments().get(0));
    assertEquals("/* comment switch */" + newLine + "switch (1) {" + newLine + "    /* before first case */" + newLine + "    case 0 :" + newLine + "        /* comment case 0: empty case */" + newLine + "    case 1 :" + newLine + "        /* comment case 1 */" + newLine + "        int i = 0;" + newLine + "    default :" + newLine + "        /* comment default */" + newLine + "}", ctSwitch.toString());
    CtFor ctFor = m1.getBody().getStatement(1);
    assertEquals(createFakeBlockComment(f, "comment for"), ctFor.getComments().get(0));
    assertEquals("/* comment for */" + newLine + "for (int i = 0; i < 10; i++) {" + newLine + "    /* comment for block */" + newLine + "}", ctFor.toString());
    CtIf ctIf = m1.getBody().getStatement(2);
    assertEquals(createFakeBlockComment(f, "comment if"), ctIf.getComments().get(0));
    assertEquals("/* comment if */" + newLine + "if ((1 % 2) == 0) {" + newLine + "    /* comment unary operator */" + newLine + "    (field)++;" + newLine + "}", ctIf.toString());
    CtConstructorCall ctConstructorCall = m1.getBody().getStatement(3);
    assertEquals(createFakeBlockComment(f, "comment constructor call"), ctConstructorCall.getComments().get(0));
    assertEquals("/* comment constructor call */" + newLine + "new spoon.test.comment.testclasses.BlockComment()", ctConstructorCall.toString());
    CtInvocation ctInvocation = m1.getBody().getStatement(4);
    assertEquals(createFakeBlockComment(f, "comment invocation"), ctInvocation.getComments().get(0));
    assertEquals("/* comment invocation */" + newLine + "this.m()", ctInvocation.toString());
    CtLocalVariable ctLocalVariable = m1.getBody().getStatement(5);
    assertEquals(createFakeBlockComment(f, "comment local variable"), ctLocalVariable.getComments().get(0));
    assertEquals("/* comment local variable */" + newLine + "int i = 0", ctLocalVariable.toString());
    CtLocalVariable ctLocalVariable2 = m1.getBody().getStatement(6);
    assertEquals(createFakeBlockComment(f, "comment multi assignments"), ctLocalVariable2.getComments().get(0));
    assertEquals("/* comment multi assignments */" + newLine + "int j = 2", ctLocalVariable2.toString());
    CtDo ctDo = m1.getBody().getStatement(7);
    assertEquals(createFakeBlockComment(f, "comment dowhile"), ctDo.getComments().get(0));
    assertEquals("/* comment dowhile */" + newLine + "do {" + newLine + "    /* comment in do while */" + newLine + "    i++;" + newLine + "    /* comment end do while */" + newLine + "} while (i < 10 )", ctDo.toString());
    CtTry ctTry = m1.getBody().getStatement(8);
    assertEquals(createFakeBlockComment(f, "comment try"), ctTry.getComments().get(0));
    assertEquals("/* comment try */" + newLine + "try {" + newLine + "    /* comment in try */" + newLine + "    i++;" + newLine + "} catch (java.lang.Exception e) {" + newLine + "    /* comment in catch */" + newLine + "}", ctTry.toString());
    CtSynchronized ctSynchronized = m1.getBody().getStatement(9);
    assertEquals(createFakeBlockComment(f, "comment synchronized"), ctSynchronized.getComments().get(0));
    assertEquals("/* comment synchronized */" + newLine + "synchronized(this) {" + newLine + "    /* comment in synchronized */" + newLine + "}", ctSynchronized.toString());
    CtReturn ctReturn = m1.getBody().getStatement(10);
    assertEquals(createFakeBlockComment(f, "comment return"), ctReturn.getComments().get(0));
    assertEquals("/* comment return */" + newLine + "return", ctReturn.toString());
    CtMethod m2 = type.getMethodsByName("m2").get(0);
    assertEquals(6, m2.getComments().size());
    CtParameter ctParameter = (CtParameter) m2.getParameters().get(0);
    assertEquals(4, ctParameter.getComments().size());
    assertEquals("/* comment before type */" + newLine + "/* comment after parameter */" + newLine + "/* comment before throws */" + newLine + "/* comment before exception 1 */" + newLine + "/* comment before exception 2 */" + newLine + "/* comment before block */" + newLine + "public void m2(/* comment before name */" + newLine + "/* comment before parameters */" + newLine + "/* comment before type parameter */" + newLine + "/* comment before name parameter */" + newLine + "int i) throws java.lang.Error, java.lang.Exception {" + newLine + "}", m2.toString());
}
Also used : CtComment(spoon.reflect.code.CtComment) CtSwitch(spoon.reflect.code.CtSwitch) DefaultCoreFactory(spoon.support.DefaultCoreFactory) Factory(spoon.reflect.factory.Factory) CtParameter(spoon.reflect.declaration.CtParameter) CtTry(spoon.reflect.code.CtTry) CtSynchronized(spoon.reflect.code.CtSynchronized) CtInvocation(spoon.reflect.code.CtInvocation) CtReturn(spoon.reflect.code.CtReturn) CtDo(spoon.reflect.code.CtDo) CtFor(spoon.reflect.code.CtFor) BlockComment(spoon.test.comment.testclasses.BlockComment) CtLocalVariable(spoon.reflect.code.CtLocalVariable) CtIf(spoon.reflect.code.CtIf) CtConstructor(spoon.reflect.declaration.CtConstructor) CtClass(spoon.reflect.declaration.CtClass) CtConstructorCall(spoon.reflect.code.CtConstructorCall) CtAnonymousExecutable(spoon.reflect.declaration.CtAnonymousExecutable) CtMethod(spoon.reflect.declaration.CtMethod) Test(org.junit.Test)

Example 4 with CtParameter

use of spoon.reflect.declaration.CtParameter in project spoon by INRIA.

the class GenericsTest method checkFakeTpl.

private void checkFakeTpl(CtInterface<?> fakeTplItf) {
    assertNotNull(fakeTplItf);
    CtMethod<?> applyMethod = fakeTplItf.getMethodsByName("apply").get(0);
    CtTypeReference<?> returnType = applyMethod.getType();
    assertEquals("T", returnType.getSimpleName());
    assertTrue(returnType instanceof CtTypeParameterReference);
    assertEquals("CtElement", returnType.getSuperclass().getSimpleName());
    CtParameter<?> targetType = applyMethod.getParameters().get(0);
    List<CtTypeReference<?>> targetTypeArgument = targetType.getType().getActualTypeArguments();
    assertEquals(1, targetTypeArgument.size());
    assertTrue(targetTypeArgument.get(0) instanceof CtWildcardReference);
    CtMethod<?> testMethod = fakeTplItf.getMethodsByName("test").get(0);
    List<CtParameter<?>> parameters = testMethod.getParameters();
    assertEquals(3, parameters.size());
    CtParameter thirdParam = parameters.get(2);
    assertTrue(thirdParam.getType() instanceof CtTypeParameterReference);
}
Also used : CtTypeParameterReference(spoon.reflect.reference.CtTypeParameterReference) CtWildcardReference(spoon.reflect.reference.CtWildcardReference) CtTypeReference(spoon.reflect.reference.CtTypeReference) CtParameter(spoon.reflect.declaration.CtParameter)

Example 5 with CtParameter

use of spoon.reflect.declaration.CtParameter in project spoon by INRIA.

the class CtParameterReferenceImpl method lookupDynamically.

private CtParameter<T> lookupDynamically() {
    CtElement element = this;
    CtParameter optional = null;
    String name = getSimpleName();
    try {
        do {
            CtExecutable executable = element.getParent(CtExecutable.class);
            if (executable == null) {
                return null;
            }
            for (CtParameter parameter : (List<CtParameter>) executable.getParameters()) {
                if (name.equals(parameter.getSimpleName())) {
                    optional = parameter;
                }
            }
            element = executable;
        } while (optional == null);
    } catch (ParentNotInitializedException e) {
        return null;
    }
    return optional;
}
Also used : ParentNotInitializedException(spoon.reflect.declaration.ParentNotInitializedException) CtElement(spoon.reflect.declaration.CtElement) CtParameter(spoon.reflect.declaration.CtParameter) List(java.util.List) CtExecutable(spoon.reflect.declaration.CtExecutable)

Aggregations

CtParameter (spoon.reflect.declaration.CtParameter)32 Test (org.junit.Test)18 CtMethod (spoon.reflect.declaration.CtMethod)13 Factory (spoon.reflect.factory.Factory)12 CtTypeReference (spoon.reflect.reference.CtTypeReference)10 ArrayList (java.util.ArrayList)8 Launcher (spoon.Launcher)8 CtElement (spoon.reflect.declaration.CtElement)7 List (java.util.List)6 CtIf (spoon.reflect.code.CtIf)6 CtLocalVariable (spoon.reflect.code.CtLocalVariable)6 TypeFilter (spoon.reflect.visitor.filter.TypeFilter)6 CtConstructor (spoon.reflect.declaration.CtConstructor)5 CtField (spoon.reflect.declaration.CtField)5 CtInvocation (spoon.reflect.code.CtInvocation)4 CtClass (spoon.reflect.declaration.CtClass)4 CtType (spoon.reflect.declaration.CtType)4 SpoonException (spoon.SpoonException)3 CtComment (spoon.reflect.code.CtComment)3 CtConstructorCall (spoon.reflect.code.CtConstructorCall)3