Example usage for org.eclipse.jdt.core.dom AST newNullLiteral

List of usage examples for org.eclipse.jdt.core.dom AST newNullLiteral

  1. HOME
  2. Java
  3. org.eclipse.jdt
  4. org.eclipse.jdt.core.dom.*
  5. AST
  6. newNullLiteral

Introduction

In this page you can find the example usage for org.eclipse.jdt.core.dom AST newNullLiteral.

Prototype

public NullLiteral newNullLiteral()

Source Link

Document

Creates and returns a new unparented null literal node.

Usage

From source file:cn.ieclipse.adt.ext.jdt.SourceGenerator.java

License:Apache License

private static void rewriteOnCreate(CompilationUnit unit, String dbName, List<String> tableCreators) {
    AST ast = unit.getAST();
    TypeDeclaration type = (TypeDeclaration) unit.types().get(0);
    MethodDeclaration onCreate = getMethod(type, ("onCreate"), null);
    if (onCreate != null) {
        Block methodBlock = ast.newBlock();

        // mOpenHelper = new
        // InlineOpenHelper(this.getContext(),"person.db",null,1);
        Assignment a = ast.newAssignment();
        a.setOperator(Assignment.Operator.ASSIGN);

        a.setLeftHandSide(ast.newSimpleName("mOpenHelper"));

        ClassInstanceCreation cc = ast.newClassInstanceCreation();
        cc.setType(ast.newSimpleType(ast.newSimpleName("SQLiteOpenHelper")));
        ThisExpression thisExp = ast.newThisExpression();
        MethodInvocation mi = ast.newMethodInvocation();
        mi.setName(ast.newSimpleName("getContext"));
        mi.setExpression(thisExp);/*from  w  w w.  j  a v a2 s .  c o m*/
        cc.arguments().add(mi);
        StringLiteral sl = ast.newStringLiteral();
        sl.setLiteralValue(dbName);

        cc.arguments().add(sl);
        cc.arguments().add(ast.newNullLiteral());
        cc.arguments().add(ast.newNumberLiteral("1"));
        a.setRightHandSide(cc);
        methodBlock.statements().add(ast.newExpressionStatement(a));

        AnonymousClassDeclaration acd = ast.newAnonymousClassDeclaration();
        cc.setAnonymousClassDeclaration(acd);
        genInnerSQLiteOpenHelper(acd, ast, tableCreators);

        a = ast.newAssignment();
        a.setOperator(Assignment.Operator.ASSIGN);

        a.setLeftHandSide(ast.newSimpleName("session"));

        ClassInstanceCreation cic = ast.newClassInstanceCreation();
        cic.setType(ast.newSimpleType(ast.newSimpleName("Session")));

        // SingleVariableDeclaration svd =
        // ast.newSingleVariableDeclaration();
        // svd.setName(ast.newSimpleName("mOpenHelper"));
        cic.arguments().add(ast.newSimpleName("mOpenHelper"));
        // vdf.setInitializer(cic);
        a.setRightHandSide(cic);
        // methodBlock.statements().add(vde);
        methodBlock.statements().add(ast.newExpressionStatement(a));

        ReturnStatement returnStmt = ast.newReturnStatement();
        returnStmt.setExpression(ast.newBooleanLiteral(true));
        methodBlock.statements().add(returnStmt);

        onCreate.setBody(methodBlock);
    }
}

From source file:com.ashigeru.eclipse.util.jdt.internal.ui.handlers.InsertAssertionHandler.java

License:Apache License

private AssertStatement createAssertion(AST factory, String paramName) {
    assert factory != null;
    assert paramName != null;
    AssertStatement assertion = factory.newAssertStatement();
    InfixExpression notNull = factory.newInfixExpression();
    notNull.setLeftOperand(factory.newSimpleName(paramName));
    notNull.setOperator(Operator.NOT_EQUALS);
    notNull.setRightOperand(factory.newNullLiteral());
    assertion.setExpression(notNull);// w  w w  . ja  va 2  s . co  m
    return assertion;
}

From source file:com.google.devtools.j2cpp.translate.DeadCodeEliminator.java

License:Open Source License

/**
 * Creates an Expression with a suitable zero-value for the specified type.
 * TODO(user): this doesn't take into account @NonNull annotations.
 *//*from ww w . ja v a 2s.c o m*/
private Expression getDefaultValue(AST ast, ITypeBinding type) {
    if (type.isPrimitive()) {
        if (type.getName().equals("boolean")) {
            return ast.newBooleanLiteral(false);
        }
        // All primitives types except boolean can be initialized as "0".
        return ast.newNumberLiteral("0");
    } else {
        return ast.newNullLiteral();
    }
}

From source file:com.google.devtools.j2objc.translate.ASTFactory.java

License:Apache License

public static NullLiteral newNullLiteral(AST ast) {
    NullLiteral node = ast.newNullLiteral();
    Types.addBinding(node, ast.resolveWellKnownType("java.lang.Object"));
    return node;/*w w  w  .  jav  a2 s . com*/
}

From source file:com.halware.nakedide.eclipse.ext.annot.utils.AstUtils.java

License:Open Source License

/**
 * Creates an (AST) {@link Literal} expression.
 * /*from   ww  w  .  j a v a 2s  .  com*/
 * @param ast
 * @param value
 * @return
 */
public static Expression createExpression(AST ast, Object value) {
    if (value instanceof String) {
        String stringValue = (String) value;
        StringLiteral newStringLiteral = ast.newStringLiteral();
        newStringLiteral.setLiteralValue(stringValue);
        return newStringLiteral;
    }
    if (value instanceof Boolean) {
        Boolean booleanValue = (Boolean) value;
        return ast.newBooleanLiteral(booleanValue);
    }
    if (value instanceof Number) {
        Number numberValue = (Number) value;
        return ast.newNumberLiteral(numberValue.toString());
    }
    if (value instanceof AstUtils.TypeLiteralValue) {
        AstUtils.TypeLiteralValue classHandle = (AstUtils.TypeLiteralValue) value;
        TypeLiteral newTypeLiteral = ast.newTypeLiteral();

        Name typeName = ast.newName(classHandle.getClassName());
        Type type = ast.newSimpleType(typeName);
        newTypeLiteral.setType(type);
        return newTypeLiteral;
    }
    if (value instanceof AstUtils.QualifiedNameValue) {
        AstUtils.QualifiedNameValue enumMember = (AstUtils.QualifiedNameValue) value;
        Name enumTypeName = ast.newName(enumMember.getName());
        SimpleName enumMemberName = ast.newSimpleName(enumMember.getIdentifier());
        return ast.newQualifiedName(enumTypeName, enumMemberName);
    }
    return ast.newNullLiteral();
}

From source file:de.dentrassi.varlink.generator.JdtGenerator.java

License:Open Source License

@SuppressWarnings("unchecked")
private void createImpl(final AST ast, final CompilationUnit cu, final Interface iface, final String name) {

    // create type

    final String implName = name + "Impl";

    final TypeDeclaration td = ast.newTypeDeclaration();
    cu.types().add(td);/* ww w .  ja va 2 s.com*/
    td.setName(ast.newSimpleName(implName));

    make(td, PUBLIC_KEYWORD);

    final Type parentType = ast.newSimpleType(ast.newName(name));
    td.superInterfaceTypes().add(parentType);

    // create factory

    createImplFactory(ast, td);

    // create fields

    createField(td, "de.dentrassi.varlink.spi.Connection", "connection", PRIVATE_KEYWORD, FINAL_KEYWORD);
    createField(td, "de.dentrassi.varlink.internal.VarlinkImpl", "varlink", PRIVATE_KEYWORD, FINAL_KEYWORD);

    // create constructor

    final MethodDeclaration ctor = ast.newMethodDeclaration();
    td.bodyDeclarations().add(ctor);

    ctor.setConstructor(true);
    ctor.setName(ast.newSimpleName(implName));
    make(ctor, PRIVATE_KEYWORD);

    createParameter(ctor, "de.dentrassi.varlink.spi.Connection", "connection", FINAL_KEYWORD);
    createParameter(ctor, "de.dentrassi.varlink.internal.VarlinkImpl", "varlink", FINAL_KEYWORD);

    // constructor body
    {
        final Block body = ast.newBlock();
        ctor.setBody(body);

        createThisAssignment(body, "connection");
        createThisAssignment(body, "varlink");
    }

    // error mapper

    {
        final MethodDeclaration md = ast.newMethodDeclaration();
        make(md, PUBLIC_KEYWORD);
        td.bodyDeclarations().add(md);

        md.setName(ast.newSimpleName("checkError"));
        createParameter(md, "de.dentrassi.varlink.spi.CallResponse", "response", FINAL_KEYWORD);

        final Block body = ast.newBlock();
        md.setBody(body);

        final MethodInvocation mi = ast.newMethodInvocation();
        mi.setExpression(ast.newName("de.dentrassi.varlink.spi.Errors"));
        mi.setName(ast.newSimpleName("checkErrors"));
        mi.arguments().add(ast.newSimpleName("response"));

        final ExpressionMethodReference ref = ast.newExpressionMethodReference();
        ref.setExpression(ast.newThisExpression());
        ref.setName(ast.newSimpleName("mapError"));
        mi.arguments().add(ref);

        body.statements().add(ast.newExpressionStatement(mi));
    }

    {
        final MethodDeclaration md = ast.newMethodDeclaration();
        make(md, PUBLIC_KEYWORD);
        td.bodyDeclarations().add(md);

        md.setName(ast.newSimpleName("mapError"));
        createParameter(md, "java.lang.String", "error", FINAL_KEYWORD);
        createParameter(md, "de.dentrassi.varlink.spi.CallResponse", "response", FINAL_KEYWORD);
        md.setReturnType2(ast.newSimpleType(ast.newName("java.lang.RuntimeException")));

        final Block body = ast.newBlock();
        md.setBody(body);

        final SwitchStatement sw = ast.newSwitchStatement();
        body.statements().add(sw);
        sw.setExpression(ast.newSimpleName("error"));

        errors(iface).forEach(error -> {
            final String errorName = errorTypeName(error);
            final String fullErrorName = iface.getName() + "." + errorName;

            final SwitchCase sc = ast.newSwitchCase();
            sc.setExpression(JdtHelper.newStringLiteral(ast, fullErrorName));
            sw.statements().add(sc);

            final FieldAccess fa = ast.newFieldAccess();
            fa.setExpression(ast.newThisExpression());
            fa.setName(ast.newSimpleName("varlink"));

            final MethodInvocation fromJson = ast.newMethodInvocation();
            fromJson.setExpression(fa);
            fromJson.setName(ast.newSimpleName("fromJson"));

            // type name

            final TypeLiteral typeLiteral = ast.newTypeLiteral();
            typeLiteral.setType(ast.newSimpleType(ast.newName(errorName + ".Parameters")));

            fromJson.arguments().add(typeLiteral);

            // parameters

            final MethodInvocation parameters = ast.newMethodInvocation();
            parameters.setExpression(ast.newSimpleName("response"));
            parameters.setName(ast.newSimpleName("getParameters"));
            fromJson.arguments().add(parameters);

            // new exception

            final ClassInstanceCreation cic = ast.newClassInstanceCreation();
            cic.setType(ast.newSimpleType(ast.newName(errorName)));
            cic.arguments().add(fromJson);

            // return

            final ReturnStatement ret = ast.newReturnStatement();
            ret.setExpression(cic);
            sw.statements().add(ret);
        });

        {
            final SwitchCase sc = ast.newSwitchCase();
            sc.setExpression(null);
            sw.statements().add(sc);
            final ReturnStatement ret = ast.newReturnStatement();
            ret.setExpression(ast.newNullLiteral());
            sw.statements().add(ret);
        }

    }

    // async creator

    /*
     * @Override public Async async() { return new Async() {
     *
     * @Override public CompletableFuture<List<Netdev>> list() { return
     * executeList(); } }; }
     */

    {
        final MethodDeclaration md = ast.newMethodDeclaration();
        td.bodyDeclarations().add(md);

        md.setName(ast.newSimpleName("async"));
        addSimpleAnnotation(md, "Override");
        make(md, PUBLIC_KEYWORD);

        md.setReturnType2(ast.newSimpleType(ast.newName("Async")));

        final Block body = ast.newBlock();
        md.setBody(body);

        // inner class

        final ReturnStatement ret = ast.newReturnStatement();
        body.statements().add(ret);

        final ClassInstanceCreation cic = ast.newClassInstanceCreation();
        cic.setType(ast.newSimpleType(ast.newName("Async")));
        ret.setExpression(cic);

        final AnonymousClassDeclaration acc = ast.newAnonymousClassDeclaration();
        cic.setAnonymousClassDeclaration(acc);

        forMethods(ast, iface, (m, amd) -> {

            acc.bodyDeclarations().add(amd);

            amd.setName(ast.newSimpleName(m.getName()));
            make(amd, PUBLIC_KEYWORD);
            makeAsync(amd);

            final Block asyncBody = ast.newBlock();
            amd.setBody(asyncBody);

            final ReturnStatement asyncRet = ast.newReturnStatement();
            asyncBody.statements().add(asyncRet);

            final MethodInvocation mi = ast.newMethodInvocation();
            mi.setName(ast.newSimpleName(internalMethodName(m.getName())));

            for (final String argName : m.getParameters().keySet()) {
                mi.arguments().add(ast.newSimpleName(argName));
            }

            asyncRet.setExpression(mi);
        });

    }

    // internal methods

    forMethods(ast, iface, (m, md) -> {
        make(md, PROTECTED_KEYWORD);
        td.bodyDeclarations().add(md);
        md.setName(ast.newSimpleName(internalMethodName(m.getName())));
        makeAsync(md);
        createInternalMethod(td, m, md);
    });

}

From source file:de.dentrassi.varlink.generator.JdtGenerator.java

License:Open Source License

@SuppressWarnings("unchecked")
private void createInternalMethod(final TypeDeclaration parentTypeDeclaration, final MethodInformation m,
        final MethodDeclaration md) {
    final AST ast = md.getAST();

    final Block body = ast.newBlock();
    md.setBody(body);//from  ww  w . j a v a  2  s. com

    /*
     * return this.connection.call(CallRequest.of("io.systemd.network.List"))
     * .thenApply(cr -> { check(cr);
     *
     * final Iterator<JsonElement> i = cr.getParameters().values().iterator();
     *
     * return asList( this.varlink .fromJson( Netdev[].class, i.next())); }); }
     */

    // add arguments

    if (!m.getParameters().isEmpty()) {

        // code: Map<String,Object> parameters = new HashMap<> ();

        final VariableDeclarationFragment parameters = ast.newVariableDeclarationFragment();
        parameters.setName(ast.newSimpleName("parameters"));

        final VariableDeclarationStatement decl = ast.newVariableDeclarationStatement(parameters);
        body.statements().add(decl);
        final ParameterizedType map = ast.newParameterizedType(ast.newSimpleType(ast.newName("java.util.Map")));
        map.typeArguments().add(ast.newSimpleType(ast.newName("java.lang.String")));
        map.typeArguments().add(ast.newSimpleType(ast.newName("java.lang.Object")));

        decl.setType(map);

        final ClassInstanceCreation init = ast.newClassInstanceCreation();
        init.setType(ast.newParameterizedType(ast.newSimpleType(ast.newName("java.util.HashMap"))));
        init.arguments().add(ast.newNumberLiteral(Integer.toString(m.getParameters().size())));
        parameters.setInitializer(init);

        for (final String argName : m.getParameters().keySet()) {
            final MethodInvocation mi = ast.newMethodInvocation();
            mi.setExpression(ast.newSimpleName("parameters"));
            mi.setName(ast.newSimpleName("put"));

            mi.arguments().add(JdtHelper.newStringLiteral(ast, argName));
            mi.arguments().add(ast.newSimpleName(argName));
        }

    }

    // return

    final ReturnStatement ret = ast.newReturnStatement();
    body.statements().add(ret);

    final MethodInvocation mi = ast.newMethodInvocation();
    mi.setName(ast.newSimpleName("call"));
    final FieldAccess fa = ast.newFieldAccess();
    fa.setExpression(ast.newThisExpression());
    fa.setName(ast.newSimpleName("connection"));
    mi.setExpression(fa);

    final MethodInvocation cr = ast.newMethodInvocation();
    cr.setExpression(ast.newName("de.dentrassi.varlink.spi.CallRequest"));
    cr.setName(ast.newSimpleName("of"));
    cr.arguments().add(newStringLiteral(ast, m.getInterface().getName() + "." + toUpperFirst(m.getName())));

    if (!m.getParameters().isEmpty()) {
        cr.arguments().add(ast.newSimpleName("parameters"));
    }

    mi.arguments().add(cr);

    final MethodInvocation thenApply = ast.newMethodInvocation();
    thenApply.setName(ast.newSimpleName("thenApply"));
    thenApply.setExpression(mi);

    // add transformation

    final LambdaExpression le = ast.newLambdaExpression();
    le.setParentheses(false);
    thenApply.arguments().add(le);
    final VariableDeclarationFragment p = ast.newVariableDeclarationFragment();
    p.setName(ast.newSimpleName("result"));
    le.parameters().add(p);
    final Block transform = ast.newBlock();
    le.setBody(transform);

    {
        // check result

        final MethodInvocation check = ast.newMethodInvocation();
        check.setName(ast.newSimpleName("checkError"));
        transform.statements().add(ast.newExpressionStatement(check));
        check.arguments().add(ast.newSimpleName("result"));
    }

    if (m.getReturnTypes().isEmpty()) {

        final ReturnStatement transformRet = ast.newReturnStatement();
        transformRet.setExpression(ast.newNullLiteral());
        transform.statements().add(transformRet);

    } else {

        final int returns = m.getReturnTypes().size();

        if (returns > 0) {

            // return this.varlink.fromJson(DriveCondition.class, result.getParameters());
            // return this.varlink.fromJson(DriveCondition.class,
            // result.getFirstParameter());

            final FieldAccess varlink = ast.newFieldAccess();
            varlink.setExpression(ast.newThisExpression());
            varlink.setName(ast.newSimpleName("varlink"));

            final MethodInvocation fromJson = ast.newMethodInvocation();
            fromJson.setExpression(varlink);
            fromJson.setName(ast.newSimpleName("fromJson"));

            // FIXME: add to parent
            {
                final ParameterizedType ttt = ast
                        .newParameterizedType(ast.newSimpleType(ast.newName(TYPE_TOKEN_TYPE_NAME)));

                ttt.typeArguments().add(m.createMainReturnType(ast));
                final ClassInstanceCreation tt = ast.newClassInstanceCreation();
                tt.setType(JdtHelper.copyNode(ast, ttt));

                final AnonymousClassDeclaration decl = ast.newAnonymousClassDeclaration();
                tt.setAnonymousClassDeclaration(decl);

                final MethodInvocation getType = ast.newMethodInvocation();
                getType.setExpression(tt);
                getType.setName(ast.newSimpleName("getType"));

                final VariableDeclarationFragment vdf = ast.newVariableDeclarationFragment();
                vdf.setName(ast.newSimpleName(m.getName() + "_returnTypeToken"));
                vdf.setInitializer(getType);
                final FieldDeclaration fd = ast.newFieldDeclaration(vdf);
                fd.setType(ast.newSimpleType(ast.newName("java.lang.reflect.Type")));
                make(fd, PRIVATE_KEYWORD, FINAL_KEYWORD, STATIC_KEYWORD);

                parentTypeDeclaration.bodyDeclarations().add(fd);
            }

            fromJson.arguments().add(ast.newSimpleName(m.getName() + "_returnTypeToken"));

            // json fragment

            final MethodInvocation fragment = ast.newMethodInvocation();
            if (returns == 1) {
                fragment.setName(ast.newSimpleName("getFirstParameter"));
            } else {
                fragment.setName(ast.newSimpleName("getParameters"));
            }
            fragment.setExpression(ast.newSimpleName("result"));

            fromJson.arguments().add(fragment);

            // return

            final ReturnStatement transformRet = ast.newReturnStatement();
            transformRet.setExpression(fromJson);
            transform.statements().add(transformRet);
        }

        // FIXME: handle return type

        // FIXME: handle n

    }

    // set return

    ret.setExpression(thenApply);
}

From source file:org.decojer.cavaj.utils.Expressions.java

License:Open Source License

@Nonnull
@SuppressWarnings("null")
private static Expression newLiteral2(@Nonnull final T t, @Nullable final Object value,
        @Nonnull final Element context) {
    final AST ast = context.getCu().getAst();
    if (t.isRef() /* incl. T.AREF */) {
        if (value == null) {
            return ast.newNullLiteral();
        }//  ww w.  j a  v a2s  .c  om
        if (value instanceof T && t.isAssignableFrom(Class.class)) {
            final TypeLiteral typeLiteral = ast.newTypeLiteral();
            typeLiteral.setType(newType((T) value, context));
            return typeLiteral;
        }
        if (value instanceof String && t.isAssignableFrom(String.class)) {
            final StringLiteral stringLiteral = ast.newStringLiteral();
            try {
                stringLiteral.setLiteralValue((String) value);
            } catch (final IllegalArgumentException e) {
                // TODO hmm, escaping doesn't always work?
                stringLiteral.setLiteralValue("<Invalid string literal>");
            }
            return stringLiteral;
        }
        log.warn(context + ": Unknown reference type '" + t + "'!");
        return ast.newNullLiteral();
    }
    if (t.is(T.BOOLEAN)) {
        // we prefer boolean, even if this is a multi-type
        if (value instanceof Boolean) {
            return ast.newBooleanLiteral(((Boolean) value).booleanValue());
        }
        if (value instanceof Number) {
            return ast.newBooleanLiteral(((Number) value).intValue() != 0);
        }
        if (value == null) {
            return ast.newBooleanLiteral(false);
        }
        log.warn("Boolean type with value '" + value + "' has type '" + value.getClass().getName() + "'!");
        return ast.newBooleanLiteral(
                value instanceof String ? Boolean.valueOf((String) value) : true /* value is not null here */);
    }
    if (t.is(T.BYTE)) {
        if (value instanceof Number) {
            final byte b = ((Number) value).byteValue();
            if (b == Byte.MAX_VALUE) {
                return ast.newQualifiedName(ast.newSimpleName("Byte"), ast.newSimpleName("MAX_VALUE"));
            }
            if (b == Byte.MIN_VALUE) {
                return ast.newQualifiedName(ast.newSimpleName("Byte"), ast.newSimpleName("MIN_VALUE"));
            }
            return ast.newNumberLiteral(Byte.toString(b));
        }
        if (value == null) {
            return ast.newNumberLiteral(Byte.toString((byte) 0));
        }
        log.warn("Byte type with value '" + value + "' has type '" + value.getClass().getName() + "'!");
        return ast.newNumberLiteral(value.toString());
    }
    if (t.is(T.SHORT)) {
        if (value instanceof Number) {
            final short s = ((Number) value).shortValue();
            if (s == Short.MAX_VALUE) {
                return ast.newQualifiedName(ast.newSimpleName("Short"), ast.newSimpleName("MAX_VALUE"));
            }
            if (s == Short.MIN_VALUE) {
                return ast.newQualifiedName(ast.newSimpleName("Short"), ast.newSimpleName("MIN_VALUE"));
            }
            return ast.newNumberLiteral(Short.toString(s));
        }
        if (value == null) {
            return ast.newNumberLiteral(Short.toString((short) 0));
        }
        log.warn("Short type with value '" + value + "' has type '" + value.getClass().getName() + "'!");
        return ast.newNumberLiteral(value.toString());
    }
    if (t.is(T.INT)) {
        if (value instanceof Number) {
            final int i = ((Number) value).intValue();
            if (i == Integer.MAX_VALUE) {
                return ast.newQualifiedName(ast.newSimpleName("Integer"), ast.newSimpleName("MAX_VALUE"));
            }
            if (i == Integer.MIN_VALUE) {
                return ast.newQualifiedName(ast.newSimpleName("Integer"), ast.newSimpleName("MIN_VALUE"));
            }
            return ast.newNumberLiteral(Integer.toString(i));
        }
        if (value == null) {
            return ast.newNumberLiteral(Integer.toString(0));
        }
        log.warn("Integer type with value '" + value + "' has type '" + value.getClass().getName() + "'!");
        return ast.newNumberLiteral(value.toString());
    }
    if (t.is(T.CHAR)) {
        // if this is a multi-type, we only use char if this is not already consumed;
        // we don't want to output strange characters if we are not very shure about this
        if (value instanceof Character || value instanceof Number
                || value instanceof String && ((String) value).length() == 1) {
            final char c = value instanceof Character ? (Character) value
                    : value instanceof Number ? (char) ((Number) value).intValue() : ((String) value).charAt(0);
            switch (c) {
            case Character.MAX_VALUE:
                return ast.newQualifiedName(ast.newSimpleName("Character"), ast.newSimpleName("MAX_VALUE"));
            case Character.MIN_VALUE:
                return ast.newQualifiedName(ast.newSimpleName("Character"), ast.newSimpleName("MIN_VALUE"));
            case Character.MAX_HIGH_SURROGATE:
                if (context.getT().isAtLeast(Version.JVM_5)) {
                    return ast.newQualifiedName(ast.newSimpleName("Character"),
                            ast.newSimpleName("MAX_HIGH_SURROGATE"));
                }
                break;
            case Character.MAX_LOW_SURROGATE:
                if (context.getT().isAtLeast(Version.JVM_5)) {
                    return ast.newQualifiedName(ast.newSimpleName("Character"),
                            ast.newSimpleName("MAX_LOW_SURROGATE"));
                }
                break;
            case Character.MIN_HIGH_SURROGATE:
                if (context.getT().isAtLeast(Version.JVM_5)) {
                    return ast.newQualifiedName(ast.newSimpleName("Character"),
                            ast.newSimpleName("MIN_HIGH_SURROGATE"));
                }
                break;
            case Character.MIN_LOW_SURROGATE:
                if (context.getT().isAtLeast(Version.JVM_5)) {
                    return ast.newQualifiedName(ast.newSimpleName("Character"),
                            ast.newSimpleName("MIN_LOW_SURROGATE"));
                }
                break;
            }
            final CharacterLiteral characterLiteral = ast.newCharacterLiteral();
            characterLiteral.setCharValue(c);
            return characterLiteral;
        }
        if (value == null) {
            final CharacterLiteral characterLiteral = ast.newCharacterLiteral();
            characterLiteral.setCharValue((char) 0);
            return characterLiteral;
        }
        log.warn("Character type with value '" + value + "' has type '" + value.getClass().getName() + "'!");
        // char is per default 'X'
        return ast.newCharacterLiteral();
    }
    if (t.is(T.FLOAT)) {
        if (value instanceof Float || value instanceof Integer) {
            final float f = value instanceof Float ? (Float) value : Float.intBitsToFloat((Integer) value);
            if (Float.isNaN(f)) {
                return ast.newQualifiedName(ast.newSimpleName("Float"), ast.newSimpleName("NaN"));
            }
            if (f == Float.POSITIVE_INFINITY) {
                return ast.newQualifiedName(ast.newSimpleName("Float"), ast.newSimpleName("POSITIVE_INFINITY"));
            }
            if (f == Float.NEGATIVE_INFINITY) {
                return ast.newQualifiedName(ast.newSimpleName("Float"), ast.newSimpleName("NEGATIVE_INFINITY"));
            }
            if (f == Float.MAX_VALUE) {
                return ast.newQualifiedName(ast.newSimpleName("Float"), ast.newSimpleName("MAX_VALUE"));
            }
            if (f == Float.MIN_VALUE) {
                return ast.newQualifiedName(ast.newSimpleName("Float"), ast.newSimpleName("MIN_VALUE"));
            }
            if (f == Float.MIN_NORMAL) {
                if (context.getT().isAtLeast(Version.JVM_6)) {
                    return ast.newQualifiedName(ast.newSimpleName("Float"), ast.newSimpleName("MIN_NORMAL"));
                }
            }
            return ast.newNumberLiteral(Float.toString(f) + 'F');
        }
        if (value == null) {
            return ast.newNumberLiteral(Float.toString(0F) + 'F');
        }
        log.warn("Float type with value '" + value + "' has type '" + value.getClass().getName() + "'!");
        return ast.newNumberLiteral(value.toString() + 'F');
    }
    if (t.is(T.LONG)) {
        if (value instanceof Long) {
            final long l = (Long) value;
            if (l == Long.MAX_VALUE) {
                return ast.newQualifiedName(ast.newSimpleName("Long"), ast.newSimpleName("MAX_VALUE"));
            }
            if (l == Long.MIN_VALUE) {
                return ast.newQualifiedName(ast.newSimpleName("Long"), ast.newSimpleName("MIN_VALUE"));
            }
            return ast.newNumberLiteral(Long.toString(l) + 'L');
        }
        if (value == null) {
            return ast.newNumberLiteral(Long.toString(0L) + 'L');
        }
        log.warn("Long type with value '" + value + "' has type '" + value.getClass().getName() + "'!");
        return ast.newNumberLiteral(value.toString() + 'L');
    }
    if (t.is(T.DOUBLE)) {
        if (value instanceof Double || value instanceof Long) {
            final double d = value instanceof Double ? (Double) value : Double.longBitsToDouble((Long) value);
            if (Double.isNaN(d)) {
                return ast.newQualifiedName(ast.newSimpleName("Double"), ast.newSimpleName("NaN"));
            }
            if (d == Double.POSITIVE_INFINITY) {
                return ast.newQualifiedName(ast.newSimpleName("Double"),
                        ast.newSimpleName("POSITIVE_INFINITY"));
            }
            if (d == Double.NEGATIVE_INFINITY) {
                return ast.newQualifiedName(ast.newSimpleName("Double"),
                        ast.newSimpleName("NEGATIVE_INFINITY"));
            }
            if (d == Double.MAX_VALUE) {
                return ast.newQualifiedName(ast.newSimpleName("Double"), ast.newSimpleName("MAX_VALUE"));
            }
            if (d == Double.MIN_VALUE) {
                return ast.newQualifiedName(ast.newSimpleName("Double"), ast.newSimpleName("MIN_VALUE"));
            }
            if (d == Double.MIN_NORMAL) {
                if (context.getT().isAtLeast(Version.JVM_6)) {
                    return ast.newQualifiedName(ast.newSimpleName("Double"), ast.newSimpleName("MIN_NORMAL"));
                }
            }
            return ast.newNumberLiteral(Double.toString(d) + 'D');
        }
        if (value == null) {
            return ast.newNumberLiteral(Double.toString(0D) + 'D');
        }
        log.warn("Double type with value '" + value + "' has type '" + value.getClass().getName() + "'!");
        return ast.newNumberLiteral(value.toString() + 'D');
    }
    log.warn("Unknown data type '" + t + "'!");
    final StringLiteral stringLiteral = ast.newStringLiteral();
    if (value != null) {
        stringLiteral.setLiteralValue(value.toString());
    }
    return stringLiteral;
}

From source file:org.evosuite.testcarver.codegen.CodeGenerator.java

License:Open Source License

@SuppressWarnings("unchecked")
private MethodInvocation createCallMethodOrNewInstanceCallStmt(final boolean isConstructorCall, final AST ast,
        final String varName, final String targetTypeName, final String methodName, final Object[] methodArgs,
        final org.objectweb.asm.Type[] paramTypes) {
    //-- construct getField() call
    final MethodInvocation callMethodCall = ast.newMethodInvocation();

    if (isConstructorCall) {
        callMethodCall.setName(ast.newSimpleName("newInstance"));
    } else {//from   w w  w . jav a 2 s.c o m
        callMethodCall.setName(ast.newSimpleName("callMethod"));
    }

    StringLiteral stringLiteral = ast.newStringLiteral();
    stringLiteral.setLiteralValue(targetTypeName);
    callMethodCall.arguments().add(stringLiteral); // class name

    if (!isConstructorCall) {
        stringLiteral = ast.newStringLiteral();
        stringLiteral.setLiteralValue(methodName);
        callMethodCall.arguments().add(stringLiteral); // method name

        if (varName == null) {
            callMethodCall.arguments().add(ast.newNullLiteral()); // static call -> no receiver
        } else {
            callMethodCall.arguments().add(ast.newSimpleName(varName)); // receiver
        }
    }

    // method arguments
    ArrayCreation arrCreation = ast.newArrayCreation();
    arrCreation.setType(ast.newArrayType(ast.newSimpleType(ast.newSimpleName("Object"))));
    ArrayInitializer arrInit = ast.newArrayInitializer();
    arrCreation.setInitializer(arrInit);
    callMethodCall.arguments().add(arrCreation);

    Integer arg; // is either an oid or null
    for (int i = 0; i < methodArgs.length; i++) {
        arg = (Integer) methodArgs[i];
        if (arg == null) {
            arrInit.expressions().add(ast.newNullLiteral());
        } else {
            arrInit.expressions().add(ast.newSimpleName(this.oidToVarMapping.get(arg)));
        }
    }

    // paramTypes
    arrCreation = ast.newArrayCreation();
    arrCreation.setType(ast.newArrayType(ast.newSimpleType(ast.newSimpleName("Class"))));
    arrInit = ast.newArrayInitializer();
    arrCreation.setInitializer(arrInit);
    callMethodCall.arguments().add(arrCreation);

    org.objectweb.asm.Type type;
    for (int i = 0; i < paramTypes.length; i++) {
        type = paramTypes[i];

        if (type.equals(org.objectweb.asm.Type.BOOLEAN_TYPE)) {
            FieldAccess facc = ast.newFieldAccess();
            facc.setName(ast.newSimpleName("TYPE"));
            facc.setExpression(ast.newSimpleName("Boolean"));
            arrInit.expressions().add(facc);
        } else if (type.equals(org.objectweb.asm.Type.BYTE_TYPE)) {
            FieldAccess facc = ast.newFieldAccess();
            facc.setName(ast.newSimpleName("TYPE"));
            facc.setExpression(ast.newSimpleName("Byte"));
            arrInit.expressions().add(facc);
        } else if (type.equals(org.objectweb.asm.Type.CHAR_TYPE)) {
            FieldAccess facc = ast.newFieldAccess();
            facc.setName(ast.newSimpleName("TYPE"));
            facc.setExpression(ast.newSimpleName("Character"));
            arrInit.expressions().add(facc);
        } else if (type.equals(org.objectweb.asm.Type.DOUBLE_TYPE)) {
            FieldAccess facc = ast.newFieldAccess();
            facc.setName(ast.newSimpleName("TYPE"));
            facc.setExpression(ast.newSimpleName("Double"));
            arrInit.expressions().add(facc);
        } else if (type.equals(org.objectweb.asm.Type.FLOAT_TYPE)) {
            FieldAccess facc = ast.newFieldAccess();
            facc.setName(ast.newSimpleName("TYPE"));
            facc.setExpression(ast.newSimpleName("Float"));
            arrInit.expressions().add(facc);
        } else if (type.equals(org.objectweb.asm.Type.INT_TYPE)) {
            FieldAccess facc = ast.newFieldAccess();
            facc.setName(ast.newSimpleName("TYPE"));
            facc.setExpression(ast.newSimpleName("Integer"));
            arrInit.expressions().add(facc);
        } else if (type.equals(org.objectweb.asm.Type.LONG_TYPE)) {
            FieldAccess facc = ast.newFieldAccess();
            facc.setName(ast.newSimpleName("TYPE"));
            facc.setExpression(ast.newSimpleName("Long"));
            arrInit.expressions().add(facc);
        } else if (type.equals(org.objectweb.asm.Type.SHORT_TYPE)) {
            FieldAccess facc = ast.newFieldAccess();
            facc.setName(ast.newSimpleName("TYPE"));
            facc.setExpression(ast.newSimpleName("Short"));
            arrInit.expressions().add(facc);
        } else {
            final TypeLiteral clazz = ast.newTypeLiteral();
            clazz.setType(ast.newSimpleType(ast.newName(type.getClassName())));

            arrInit.expressions().add(clazz);
        }
    }

    return callMethodCall;
}

From source file:org.evosuite.testcarver.codegen.CodeGenerator.java

License:Open Source License

@SuppressWarnings("unchecked")
private void createMethodCallStmt(final String packageName, final int logRecNo, final boolean postprocessing,
        final Block methodBlock, final AST ast) {
    // assumption: all necessary statements are created and there is one variable for reach referenced object
    final int oid = this.log.objectIds.get(logRecNo);
    final Object[] methodArgs = this.log.params.get(logRecNo);
    final String methodName = this.log.methodNames.get(logRecNo);

    final String methodDesc = this.log.descList.get(logRecNo);
    final org.objectweb.asm.Type[] methodParamTypes = org.objectweb.asm.Type.getArgumentTypes(methodDesc);

    final Class<?>[] methodParamTypeClasses = new Class[methodParamTypes.length];
    for (int i = 0; i < methodParamTypes.length; i++) {
        methodParamTypeClasses[i] = getClassForName(methodParamTypes[i].getClassName());
    }/*from   w  w  w.jav a 2  s  . com*/

    final String typeName = this.log.oidClassNames.get(this.log.oidRecMapping.get(oid));
    Class<?> type = getClassForName(typeName);

    //      Class<?> type;
    //      try {
    //         type = Class.forName(typeName);
    //      } catch (ClassNotFoundException e) {
    //         throw new RuntimeException(e);
    //      }

    final boolean haveSamePackage = type.getPackage().getName().equals(packageName); // TODO might be nicer...

    final Statement finalStmt;

    @SuppressWarnings("rawtypes")
    final List arguments;
    if (CaptureLog.OBSERVED_INIT.equals(methodName)) {
        /*
         * Person var0 = null;
         * {
         *    var0 = new Person();
         * }
         * catch(Throwable t)
         * {
         *    org.uni.saarland.sw.prototype.capture.PostProcessor.captureException(<logRecNo>);
         * }
         */

        // e.g. Person var0 = null;
        final String varName = this.createNewVarName(oid, typeName);
        VariableDeclarationFragment vd = ast.newVariableDeclarationFragment();
        vd.setName(ast.newSimpleName(varName));
        VariableDeclarationStatement stmt = ast.newVariableDeclarationStatement(vd);
        stmt.setType(this.createAstType(typeName, ast));
        vd.setInitializer(ast.newNullLiteral());
        methodBlock.statements().add(stmt);

        try {
            this.getConstructorModifiers(type, methodParamTypeClasses);
        } catch (Exception e) {
            e.printStackTrace();
        }

        final int constructorTypeModifiers = this.getConstructorModifiers(type, methodParamTypeClasses);
        final boolean isPublic = java.lang.reflect.Modifier.isPublic(constructorTypeModifiers);
        final boolean isReflectionAccessNeeded = !isPublic && !haveSamePackage;

        if (isReflectionAccessNeeded) {
            this.isNewInstanceMethodNeeded = true;
            final MethodInvocation mi = this.createCallMethodOrNewInstanceCallStmt(true, ast, varName, typeName,
                    methodName, methodArgs, methodParamTypes);
            arguments = null;

            final Assignment assignment = ast.newAssignment();
            assignment.setLeftHandSide(ast.newSimpleName(varName));
            assignment.setOperator(Operator.ASSIGN);

            final CastExpression cast = ast.newCastExpression();
            cast.setType(this.createAstType(typeName, ast));
            cast.setExpression(mi);
            assignment.setRightHandSide(cast);

            finalStmt = ast.newExpressionStatement(assignment);
        } else {
            // e.g. var0 = new Person();
            final ClassInstanceCreation ci = ast.newClassInstanceCreation();
            ci.setType(this.createAstType(typeName, ast));

            final Assignment assignment = ast.newAssignment();
            assignment.setLeftHandSide(ast.newSimpleName(varName));
            assignment.setOperator(Operator.ASSIGN);
            assignment.setRightHandSide(ci);

            finalStmt = ast.newExpressionStatement(assignment);
            arguments = ci.arguments();
        }
    } else //------------------ handling for ordinary method calls e.g. var1 = var0.doSth();
    {
        String returnVarName = null;

        final String desc = this.log.descList.get(logRecNo);
        final String returnType = org.objectweb.asm.Type.getReturnType(desc).getClassName();

        final Object returnValue = this.log.returnValues.get(logRecNo);
        if (!CaptureLog.RETURN_TYPE_VOID.equals(returnValue)) {
            Integer returnValueOID = (Integer) returnValue;

            // e.g. Person var0 = null;
            returnVarName = this.createNewVarName(returnValueOID, returnType);

            VariableDeclarationFragment vd = ast.newVariableDeclarationFragment();
            vd.setName(ast.newSimpleName(returnVarName));
            VariableDeclarationStatement stmt = ast.newVariableDeclarationStatement(vd);
            stmt.setType(this.createAstType(returnType, ast));
            vd.setInitializer(ast.newNullLiteral());
            methodBlock.statements().add(stmt);
        }

        final String varName = this.oidToVarMapping.get(oid);

        final int methodTypeModifiers = this.getMethodModifiers(type, methodName, methodParamTypeClasses);
        final boolean isPublic = java.lang.reflect.Modifier.isPublic(methodTypeModifiers);
        final boolean isReflectionAccessNeeded = !isPublic && !haveSamePackage;

        // e.g. Person var0 = var1.getPerson("Ben");

        final MethodInvocation mi;

        if (isReflectionAccessNeeded) {
            this.isCallMethodMethodNeeded = true;
            mi = this.createCallMethodOrNewInstanceCallStmt(false, ast, varName, typeName, methodName,
                    methodArgs, methodParamTypes);
            arguments = null;

            if (returnVarName != null) {
                final Assignment assignment = ast.newAssignment();
                assignment.setLeftHandSide(ast.newSimpleName(returnVarName));
                assignment.setOperator(Operator.ASSIGN);

                final CastExpression cast = ast.newCastExpression();
                cast.setType(this.createAstType(returnType, ast));
                cast.setExpression(mi);
                assignment.setRightHandSide(cast);

                finalStmt = ast.newExpressionStatement(assignment);
            } else {
                finalStmt = ast.newExpressionStatement(mi);
            }
        } else {
            mi = ast.newMethodInvocation();

            if (this.log.isStaticCallList.get(logRecNo)) {
                // can only happen, if this is a static method call (because constructor statement has been reported)
                final String tmpType = this.log.oidClassNames.get(this.log.oidRecMapping.get(oid));
                mi.setExpression(ast.newName(tmpType.split("\\.")));
            } else {
                mi.setExpression(ast.newSimpleName(varName));
            }

            mi.setName(ast.newSimpleName(methodName));

            arguments = mi.arguments();

            if (returnVarName != null) {
                final Assignment assignment = ast.newAssignment();
                assignment.setLeftHandSide(ast.newSimpleName(returnVarName));
                assignment.setOperator(Operator.ASSIGN);
                assignment.setRightHandSide(mi);

                finalStmt = ast.newExpressionStatement(assignment);
            } else {
                finalStmt = ast.newExpressionStatement(mi);
            }
        }
    }

    if (postprocessing) {
        final TryStatement tryStmt = this.createTryStatementForPostProcessing(ast, finalStmt, logRecNo);
        methodBlock.statements().add(tryStmt);
    } else {
        if (this.failedRecords.contains(logRecNo)) {
            // we just need an empty catch block to preserve program flow
            final TryStatement tryStmt = this.createTryStmtWithEmptyCatch(ast, finalStmt);
            methodBlock.statements().add(tryStmt);
        } else {
            methodBlock.statements().add(finalStmt);
        }
    }

    if (arguments != null) {
        //         final  String                   methodDesc       = this.log.descList.get(logRecNo);
        //         final  org.objectweb.asm.Type[] methodParamTypes = org.objectweb.asm.Type.getArgumentTypes(methodDesc);

        Class<?> methodParamType;
        Class<?> argType;

        Integer arg; // is either an oid or null
        for (int i = 0; i < methodArgs.length; i++) {
            arg = (Integer) methodArgs[i];
            if (arg == null) {
                arguments.add(ast.newNullLiteral());
            } else {
                methodParamType = CaptureUtil.getClassFromDesc(methodParamTypes[i].getDescriptor());
                argType = this.oidToTypeMapping.get(arg);

                if (methodParamType.isAssignableFrom(argType)) {
                    arguments.add(ast.newSimpleName(this.oidToVarMapping.get(arg)));
                } else {
                    // we need an up-cast
                    final CastExpression cast = ast.newCastExpression();
                    cast.setType(ast.newSimpleType(ast.newName(methodParamType.getName())));
                    cast.setExpression(ast.newSimpleName(this.oidToVarMapping.get(arg)));
                    arguments.add(cast);
                }
            }
        }
    }
}