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

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

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

Introduction

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

Prototype

public TypeLiteral newTypeLiteral()

Source Link

Document

Creates and returns a new unparented type literal expression node owned by this AST.

Usage

From source file:com.android.icu4j.srcgen.RunWithAnnotator.java

License:Apache License

private boolean addRunWithAnnotation(CompilationUnit cu, ASTRewrite rewrite, TypeDeclaration type,
        String runnerClass, boolean imported) {

    AST ast = cu.getAST();

    QualifiedName qRunWith = (QualifiedName) ast.newName(RUN_WITH_CLASS_NAME);
    QualifiedName qRunner = (QualifiedName) ast.newName(runnerClass);
    if (!imported) {
        appendImport(cu, rewrite, qRunWith);
        appendImport(cu, rewrite, qRunner);
    }/*from w  ww  .j a v a  2 s  .  c  o m*/
    String runWithName = qRunWith.getName().getIdentifier();
    String runnerName = qRunner.getName().getIdentifier();

    SingleMemberAnnotation annotation = ast.newSingleMemberAnnotation();
    annotation.setTypeName(ast.newSimpleName(runWithName));

    TypeLiteral junit4Literal = ast.newTypeLiteral();
    junit4Literal.setType(ast.newSimpleType(ast.newSimpleName(runnerName)));
    annotation.setValue(junit4Literal);

    ListRewrite lrw = rewrite.getListRewrite(type, type.getModifiersProperty());
    lrw.insertFirst(annotation, null);

    return imported;
}

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

License:Open Source License

/**
 * Convert an array initializer into a init method on the equivalent
 * IOSArray. This init method takes a C array and count, like
 * NSArray.arrayWithObjects:count:. For example, "int[] a = { 1, 2, 3 };"
 * translates to "[IOSIntArray initWithInts:(int[]){ 1, 2, 3 } count:3];".
 *//*ww w . jav  a  2 s .c  o  m*/
private MethodInvocation createIOSArrayInitializer(ITypeBinding arrayType, ArrayInitializer arrayInit) {
    AST ast = arrayInit.getAST();

    int dimensions = arrayType.getDimensions();
    ITypeBinding componentType;
    IOSArrayTypeBinding iosArrayBinding;
    if (dimensions > 2) {
        // This gets resolved into IOSObjectArray, for an array of arrays.
        componentType = iosArrayBinding = Types.resolveArrayType(arrayType);
    } else if (dimensions == 2) {
        // Creates a single-dimension array type.
        componentType = Types.resolveArrayType(arrayType.getElementType());
        iosArrayBinding = Types.resolveArrayType(componentType);
    } else {
        componentType = Types.getTypeBinding(arrayInit).getComponentType();
        iosArrayBinding = Types.resolveArrayType(componentType);
    }

    // Create IOS message.
    MethodInvocation message = ast.newMethodInvocation();
    SimpleName receiver = ast.newSimpleName(iosArrayBinding.getName());
    Types.addBinding(receiver, iosArrayBinding);
    message.setExpression(receiver);
    String methodName = iosArrayBinding.getInitMethod();
    SimpleName messageName = ast.newSimpleName(methodName);
    GeneratedMethodBinding methodBinding = new GeneratedMethodBinding(methodName,
            Modifier.PUBLIC | Modifier.STATIC, iosArrayBinding, iosArrayBinding, false, false, true);
    Types.addBinding(messageName, methodBinding);
    message.setName(messageName);
    Types.addBinding(message, methodBinding);

    // Pass array initializer as C-style array to message.
    @SuppressWarnings("unchecked")
    List<Expression> args = message.arguments(); // safe by definition
    ArrayInitializer newArrayInit = NodeCopier.copySubtree(ast, arrayInit);
    @SuppressWarnings("unchecked")
    List<Expression> exprs = newArrayInit.expressions();
    for (int i = 0; i < exprs.size(); i++) {
        // Convert any elements that are also array initializers.
        Expression expr = exprs.get(i);
        if (expr instanceof ArrayInitializer) {
            exprs.set(i, createIOSArrayInitializer(componentType, (ArrayInitializer) expr));
        }
    }
    args.add(newArrayInit);
    GeneratedVariableBinding argBinding = new GeneratedVariableBinding(arrayType, false, true, null,
            methodBinding);
    methodBinding.addParameter(argBinding);
    NumberLiteral arraySize = ast.newNumberLiteral(Integer.toString(arrayInit.expressions().size()));
    Types.addBinding(arraySize, ast.resolveWellKnownType("int"));
    args.add(arraySize);
    argBinding = new GeneratedVariableBinding(ast.resolveWellKnownType("int"), false, true, null,
            methodBinding);
    methodBinding.addParameter(argBinding);

    // Specify type for object arrays.
    if (iosArrayBinding.getName().equals("IOSObjectArray")) {
        TypeLiteral typeLiteral = ast.newTypeLiteral();
        typeLiteral.setType(Types.makeType(componentType));
        Types.addBinding(typeLiteral, Types.getIOSClass());
        args.add(typeLiteral);
        argBinding = new GeneratedVariableBinding("type", 0, Types.getIOSClass(), false, true, null,
                methodBinding);
        methodBinding.addParameter(argBinding);
    }

    return message;
}

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

License:Apache License

public static TypeLiteral newTypeLiteral(AST ast, ITypeBinding type) {
    TypeLiteral literal = ast.newTypeLiteral();
    literal.setType(newType(ast, type));
    Types.addBinding(literal, type);
    return literal;
}

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

License:Open Source License

/**
 * Creates an (AST) {@link Literal} expression.
 * // ww w . ja  va  2 s .  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:com.idega.eclipse.ejbwizards.IBOEntityCreator.java

License:Open Source License

private void createHomeImplementation(IProgressMonitor monitor, ICompilationUnit iUnit, String typePackage,
        String name) throws JavaModelException, MalformedTreeException, BadLocationException {
    iUnit.getBuffer().setContents("");
    String source = iUnit.getBuffer().getContents();
    Document document = new Document(source);

    ASTParser parser = ASTParser.newParser(AST.JLS3);
    parser.setSource(iUnit);/* ww  w. j  a va  2  s .  c  o  m*/

    CompilationUnit unit = (CompilationUnit) parser.createAST(monitor);
    unit.recordModifications();

    AST ast = unit.getAST();

    // Package statement
    PackageDeclaration packageDeclaration = ast.newPackageDeclaration();
    unit.setPackage(packageDeclaration);
    packageDeclaration.setName(ast.newName(typePackage));

    // class declaration
    TypeDeclaration classType = getTypeDeclaration(ast, name + "HomeImpl", false, "IBOHomeImpl", null,
            getHomeImplImports());
    classType.superInterfaceTypes().add(ast.newSimpleType(ast.newSimpleName(name + "Home")));
    addHomeImplImport("com.idega.business.IBOHomeImpl");
    unit.types().add(classType);

    // create() method
    MethodDeclaration methodConstructor = ast.newMethodDeclaration();
    methodConstructor.setConstructor(false);
    if (this.isJDK1_5) {
        MarkerAnnotation annotation = ast.newMarkerAnnotation();
        annotation.setTypeName(ast.newSimpleName("Override"));
        methodConstructor.modifiers().add(annotation);
    }
    methodConstructor.modifiers().addAll(ast.newModifiers(Modifier.PUBLIC));
    if (this.isJDK1_5) {
        ParameterizedType returnType = ast.newParameterizedType(ast.newSimpleType(ast.newSimpleName("Class")));
        returnType.typeArguments().add(ast.newSimpleType(ast.newSimpleName(name)));
        methodConstructor.setReturnType2(returnType);
    } else {
        methodConstructor.setReturnType2(ast.newSimpleType(ast.newSimpleName("Class")));
    }
    methodConstructor.setName(ast.newSimpleName("getBeanInterfaceClass"));

    classType.bodyDeclarations().add(methodConstructor);

    Block constructorBlock = ast.newBlock();
    methodConstructor.setBody(constructorBlock);

    TypeLiteral typeLiteral = ast.newTypeLiteral();
    typeLiteral.setType(ast.newSimpleType(ast.newSimpleName(name)));

    ReturnStatement returnStatement = ast.newReturnStatement();
    returnStatement.setExpression(typeLiteral);
    constructorBlock.statements().add(returnStatement);

    // create() method
    methodConstructor = ast.newMethodDeclaration();
    methodConstructor.setConstructor(false);
    methodConstructor.modifiers().addAll(ast.newModifiers(Modifier.PUBLIC));
    methodConstructor.setReturnType2(ast.newSimpleType(ast.newSimpleName(name)));
    methodConstructor.setName(ast.newSimpleName("create"));
    methodConstructor.thrownExceptions().add(ast.newName("CreateException"));
    addHomeImplImport("javax.ejb.CreateException");
    classType.bodyDeclarations().add(methodConstructor);

    constructorBlock = ast.newBlock();
    methodConstructor.setBody(constructorBlock);

    SuperMethodInvocation superMethodInvocation = ast.newSuperMethodInvocation();
    superMethodInvocation.setName(ast.newSimpleName("createIBO"));

    CastExpression ce = ast.newCastExpression();
    ce.setType(ast.newSimpleType(ast.newSimpleName(name)));
    ce.setExpression(superMethodInvocation);

    returnStatement = ast.newReturnStatement();
    returnStatement.setExpression(ce);
    constructorBlock.statements().add(returnStatement);

    writeImports(ast, unit, getHomeImplImports());
    commitChanges(iUnit, unit, document);
}

From source file:com.idega.eclipse.ejbwizards.IDOEntityCreator.java

License:Open Source License

private void createHomeImplementation(IProgressMonitor monitor, ICompilationUnit iUnit, String typePackage,
        String name) throws JavaModelException, MalformedTreeException, BadLocationException {
    iUnit.getBuffer().setContents("");
    String source = iUnit.getBuffer().getContents();
    Document document = new Document(source);

    ASTParser parser = ASTParser.newParser(AST.JLS3);
    parser.setSource(iUnit);// ww w  .j  av  a2  s.com

    CompilationUnit unit = (CompilationUnit) parser.createAST(monitor);
    unit.recordModifications();

    AST ast = unit.getAST();

    // Package statement
    unit.setPackage(getPackageDeclaration(ast, typePackage));

    // class declaration
    TypeDeclaration classType = getTypeDeclaration(ast, name + "HomeImpl", false, "IDOFactory", null,
            getHomeImplImports());
    classType.superInterfaceTypes().add(ast.newSimpleType(ast.newSimpleName(name + "Home")));
    addHomeImplImport("com.idega.data.IDOFactory");
    unit.types().add(classType);

    // create() method
    MethodDeclaration methodConstructor = ast.newMethodDeclaration();
    methodConstructor.setConstructor(false);
    if (this.isJDK1_5) {
        MarkerAnnotation annotation = ast.newMarkerAnnotation();
        annotation.setTypeName(ast.newSimpleName("Override"));
        methodConstructor.modifiers().add(annotation);
    }
    methodConstructor.modifiers().addAll(ast.newModifiers(Modifier.PUBLIC));
    if (this.isJDK1_5) {
        ParameterizedType returnType = ast.newParameterizedType(ast.newSimpleType(ast.newSimpleName("Class")));
        returnType.typeArguments().add(ast.newSimpleType(ast.newSimpleName(name + "Home")));
        methodConstructor.setReturnType2(returnType);
    } else {
        methodConstructor.setReturnType2(ast.newSimpleType(ast.newSimpleName("Class")));
    }
    methodConstructor.setName(ast.newSimpleName("getEntityInterfaceClass"));

    classType.bodyDeclarations().add(methodConstructor);

    Block constructorBlock = ast.newBlock();
    methodConstructor.setBody(constructorBlock);

    TypeLiteral typeLiteral = ast.newTypeLiteral();
    typeLiteral.setType(ast.newSimpleType(ast.newSimpleName(name)));

    ReturnStatement returnStatement = ast.newReturnStatement();
    returnStatement.setExpression(typeLiteral);
    constructorBlock.statements().add(returnStatement);

    // create() method
    methodConstructor = ast.newMethodDeclaration();
    methodConstructor.setConstructor(false);
    methodConstructor.modifiers().addAll(ast.newModifiers(Modifier.PUBLIC));
    methodConstructor.setReturnType2(ast.newSimpleType(ast.newSimpleName(name)));
    methodConstructor.setName(ast.newSimpleName("create"));
    methodConstructor.thrownExceptions().add(ast.newName("CreateException"));
    addHomeImplImport("javax.ejb.CreateException");
    classType.bodyDeclarations().add(methodConstructor);

    constructorBlock = ast.newBlock();
    methodConstructor.setBody(constructorBlock);

    SuperMethodInvocation superMethodInvocation = ast.newSuperMethodInvocation();
    superMethodInvocation.setName(ast.newSimpleName("createIDO"));

    CastExpression ce = ast.newCastExpression();
    ce.setType(ast.newSimpleType(ast.newSimpleName(name)));
    ce.setExpression(superMethodInvocation);

    returnStatement = ast.newReturnStatement();
    returnStatement.setExpression(ce);
    constructorBlock.statements().add(returnStatement);

    // findByPrimarKey(Object) method
    methodConstructor = ast.newMethodDeclaration();
    methodConstructor.setConstructor(false);
    methodConstructor.modifiers().addAll(ast.newModifiers(Modifier.PUBLIC));
    methodConstructor.setReturnType2(ast.newSimpleType(ast.newSimpleName(name)));
    methodConstructor.setName(ast.newSimpleName("findByPrimaryKey"));
    methodConstructor.thrownExceptions().add(ast.newName("FinderException"));
    addHomeImplImport("javax.ejb.FinderException");
    classType.bodyDeclarations().add(methodConstructor);

    SingleVariableDeclaration variableDeclaration = ast.newSingleVariableDeclaration();
    variableDeclaration.modifiers().addAll(ast.newModifiers(Modifier.NONE));
    variableDeclaration.setType(ast.newSimpleType(ast.newSimpleName("Object")));
    variableDeclaration.setName(ast.newSimpleName("pk"));
    methodConstructor.parameters().add(variableDeclaration);

    constructorBlock = ast.newBlock();
    methodConstructor.setBody(constructorBlock);

    superMethodInvocation = ast.newSuperMethodInvocation();
    superMethodInvocation.setName(ast.newSimpleName("findByPrimaryKeyIDO"));
    superMethodInvocation.arguments().add(ast.newSimpleName("pk"));

    ce = ast.newCastExpression();
    ce.setType(ast.newSimpleType(ast.newSimpleName(name)));
    ce.setExpression(superMethodInvocation);

    returnStatement = ast.newReturnStatement();
    returnStatement.setExpression(ce);
    constructorBlock.statements().add(returnStatement);

    if (this.isLegacyEntity) {
        // createLegacy() method
        methodConstructor = ast.newMethodDeclaration();
        methodConstructor.setConstructor(false);
        methodConstructor.modifiers().addAll(ast.newModifiers(Modifier.PUBLIC));
        methodConstructor.setReturnType2(ast.newSimpleType(ast.newSimpleName(name)));
        methodConstructor.setName(ast.newSimpleName("createLegacy"));
        classType.bodyDeclarations().add(methodConstructor);

        constructorBlock = ast.newBlock();
        methodConstructor.setBody(constructorBlock);

        TryStatement tryStatement = ast.newTryStatement();
        constructorBlock.statements().add(tryStatement);
        Block tryBlock = ast.newBlock();
        tryStatement.setBody(tryBlock);

        MethodInvocation mi = ast.newMethodInvocation();
        mi.setName(ast.newSimpleName("create"));

        returnStatement = ast.newReturnStatement();
        returnStatement.setExpression(mi);
        tryBlock.statements().add(returnStatement);

        CatchClause catchClause = ast.newCatchClause();
        tryStatement.catchClauses().add(catchClause);
        variableDeclaration = ast.newSingleVariableDeclaration();
        variableDeclaration.modifiers().addAll(ast.newModifiers(Modifier.NONE));
        variableDeclaration.setType(ast.newSimpleType(ast.newSimpleName(("CreateException"))));
        variableDeclaration.setName(ast.newSimpleName("ce"));
        catchClause.setException(variableDeclaration);
        Block catchBlock = ast.newBlock();
        catchClause.setBody(catchBlock);

        ClassInstanceCreation cc = ast.newClassInstanceCreation();
        cc.setType(ast.newSimpleType(ast.newSimpleName("RuntimeException")));
        mi = ast.newMethodInvocation();
        mi.setExpression(ast.newSimpleName("ce"));
        mi.setName(ast.newSimpleName("getMessage"));
        cc.arguments().add(mi);

        ThrowStatement throwStatement = ast.newThrowStatement();
        throwStatement.setExpression(cc);
        catchBlock.statements().add(throwStatement);

        // findByPrimarKey(int) method
        methodConstructor = ast.newMethodDeclaration();
        methodConstructor.setConstructor(false);
        methodConstructor.modifiers().addAll(ast.newModifiers(Modifier.PUBLIC));
        methodConstructor.setReturnType2(ast.newSimpleType(ast.newSimpleName(name)));
        methodConstructor.setName(ast.newSimpleName("findByPrimaryKey"));
        methodConstructor.thrownExceptions().add(ast.newName("FinderException"));
        classType.bodyDeclarations().add(methodConstructor);

        variableDeclaration = ast.newSingleVariableDeclaration();
        variableDeclaration.modifiers().addAll(ast.newModifiers(Modifier.NONE));
        variableDeclaration.setType(ast.newPrimitiveType(PrimitiveType.INT));
        variableDeclaration.setName(ast.newSimpleName("id"));
        methodConstructor.parameters().add(variableDeclaration);

        constructorBlock = ast.newBlock();
        methodConstructor.setBody(constructorBlock);

        superMethodInvocation = ast.newSuperMethodInvocation();
        superMethodInvocation.setName(ast.newSimpleName("findByPrimaryKeyIDO"));
        superMethodInvocation.arguments().add(ast.newSimpleName("id"));

        ce = ast.newCastExpression();
        ce.setType(ast.newSimpleType(ast.newSimpleName(name)));
        ce.setExpression(superMethodInvocation);

        returnStatement = ast.newReturnStatement();
        returnStatement.setExpression(ce);
        constructorBlock.statements().add(returnStatement);

        // findByPrimarKeyLegacy(int) method
        methodConstructor = ast.newMethodDeclaration();
        methodConstructor.setConstructor(false);
        methodConstructor.modifiers().addAll(ast.newModifiers(Modifier.PUBLIC));
        methodConstructor.setReturnType2(ast.newSimpleType(ast.newSimpleName(name)));
        methodConstructor.setName(ast.newSimpleName("findByPrimaryKeyLegacy"));
        methodConstructor.thrownExceptions().add(ast.newName("SQLException"));
        addHomeImplImport("java.sql.SQLException");
        classType.bodyDeclarations().add(methodConstructor);

        variableDeclaration = ast.newSingleVariableDeclaration();
        variableDeclaration.modifiers().addAll(ast.newModifiers(Modifier.NONE));
        variableDeclaration.setType(ast.newPrimitiveType(PrimitiveType.INT));
        variableDeclaration.setName(ast.newSimpleName("id"));
        methodConstructor.parameters().add(variableDeclaration);

        constructorBlock = ast.newBlock();
        methodConstructor.setBody(constructorBlock);

        tryStatement = ast.newTryStatement();
        constructorBlock.statements().add(tryStatement);
        tryBlock = ast.newBlock();
        tryStatement.setBody(tryBlock);

        mi = ast.newMethodInvocation();
        mi.setName(ast.newSimpleName("findByPrimaryKey"));
        mi.arguments().add(ast.newSimpleName("id"));

        returnStatement = ast.newReturnStatement();
        returnStatement.setExpression(mi);
        tryBlock.statements().add(returnStatement);

        catchClause = ast.newCatchClause();
        tryStatement.catchClauses().add(catchClause);
        variableDeclaration = ast.newSingleVariableDeclaration();
        variableDeclaration.modifiers().addAll(ast.newModifiers(Modifier.NONE));
        variableDeclaration.setType(ast.newSimpleType(ast.newSimpleName(("FinderException"))));
        variableDeclaration.setName(ast.newSimpleName("fe"));
        catchClause.setException(variableDeclaration);
        catchBlock = ast.newBlock();
        catchClause.setBody(catchBlock);

        cc = ast.newClassInstanceCreation();
        cc.setType(ast.newSimpleType(ast.newSimpleName("SQLException")));
        mi = ast.newMethodInvocation();
        mi.setExpression(ast.newSimpleName("fe"));
        mi.setName(ast.newSimpleName("getMessage"));
        cc.arguments().add(mi);

        throwStatement = ast.newThrowStatement();
        throwStatement.setExpression(cc);
        catchBlock.statements().add(throwStatement);
    }

    MethodFilter[] validFilter = { new MethodFilter(WizardConstants.EJB_CREATE_START, MethodFilter.TYPE_PREFIX),
            new MethodFilter(WizardConstants.EJB_HOME_START, MethodFilter.TYPE_PREFIX),
            new MethodFilter(WizardConstants.EJB_FIND_START, MethodFilter.TYPE_PREFIX) };
    List methods = filterMethods(getType().getMethods(), validFilter, null);
    for (Iterator iter = methods.iterator(); iter.hasNext();) {
        IMethod method = (IMethod) iter.next();
        String fullMethodName = method.getElementName();
        String methodName = cutAwayEJBSuffix(fullMethodName);
        String[] parameterNames = method.getParameterNames();

        String returnType = method.getReturnType();
        if (fullMethodName.startsWith(WizardConstants.EJB_FIND_START)
                || fullMethodName.startsWith(WizardConstants.EJB_CREATE_START)) {
            if (!(Signature.getSimpleName(Signature.toString(method.getReturnType()))
                    .indexOf(Signature.getSimpleName("java.util.Collection")) != -1)
                    && !(Signature.getSimpleName(Signature.toString(method.getReturnType()))
                            .indexOf(Signature.getSimpleName("java.util.Set")) != -1)) {
                returnType = name;
            }
        }
        if (!returnType.equals(name)) {
            returnType = getReturnType(returnType);
        }

        methodConstructor = getMethodDeclaration(ast, method, methodName, returnType, getHomeImplImports(),
                false);
        classType.bodyDeclarations().add(methodConstructor);

        constructorBlock = ast.newBlock();
        methodConstructor.setBody(constructorBlock);

        constructorBlock.statements().add(getIDOCheckOutStatement(ast, getHomeImplImports()));

        if (fullMethodName.startsWith(WizardConstants.EJB_FIND_START)) {
            if (Signature.getSimpleName(Signature.toString(method.getReturnType()))
                    .indexOf(Signature.getSimpleName("java.util.Collection")) != -1) {
                constructorBlock.statements().add(
                        getDataCollectingStatement(ast, returnType, "ids", fullMethodName, parameterNames));
                constructorBlock.statements().add(getIDOCheckInStatement(ast));
                constructorBlock.statements()
                        .add(getObjectReturnStatement(ast, "getEntityCollectionForPrimaryKeys", "ids"));
            } else if (Signature.getSimpleName(Signature.toString(method.getReturnType()))
                    .indexOf(Signature.getSimpleName("java.util.Set")) != -1) {
                constructorBlock.statements().add(
                        getDataCollectingStatement(ast, returnType, "ids", fullMethodName, parameterNames));
                constructorBlock.statements().add(getIDOCheckInStatement(ast));
                constructorBlock.statements()
                        .add(getObjectReturnStatement(ast, "getEntitySetForPrimaryKeys", "ids"));
            } else {
                constructorBlock.statements()
                        .add(getDataCollectingStatement(ast, "Object", "pk", fullMethodName, parameterNames));
                constructorBlock.statements().add(getIDOCheckInStatement(ast));
                constructorBlock.statements().add(getObjectReturnStatement(ast, "findByPrimaryKey", "pk"));
            }
        } else if (fullMethodName.startsWith(WizardConstants.EJB_HOME_START)) {
            constructorBlock.statements().add(
                    getDataCollectingStatement(ast, returnType, "theReturn", fullMethodName, parameterNames));
            constructorBlock.statements().add(getIDOCheckInStatement(ast));
            constructorBlock.statements().add(getPrimitiveReturnStatement(ast, "theReturn"));
        } else if (fullMethodName.startsWith(WizardConstants.EJB_CREATE_START)) {
            constructorBlock.statements()
                    .add(getDataCollectingStatement(ast, "Object", "pk", fullMethodName, parameterNames));

            ce = ast.newCastExpression();
            ce.setType(ast.newSimpleType(ast.newSimpleName(getType().getTypeQualifiedName())));
            ce.setExpression(ast.newSimpleName("entity"));

            ParenthesizedExpression pe = ast.newParenthesizedExpression();
            pe.setExpression(ce);
            MethodInvocation mi = ast.newMethodInvocation();
            mi.setExpression(pe);
            mi.setName(ast.newSimpleName("ejbPostCreate"));
            constructorBlock.statements().add(ast.newExpressionStatement(mi));

            constructorBlock.statements().add(getIDOCheckInStatement(ast));

            TryStatement tryStatement = ast.newTryStatement();
            constructorBlock.statements().add(tryStatement);
            Block tryBlock = ast.newBlock();
            tryStatement.setBody(tryBlock);

            mi = ast.newMethodInvocation();
            mi.setName(ast.newSimpleName("findByPrimaryKey"));
            mi.arguments().add(ast.newSimpleName("pk"));

            returnStatement = ast.newReturnStatement();
            returnStatement.setExpression(mi);
            tryBlock.statements().add(returnStatement);

            CatchClause catchClause = ast.newCatchClause();
            tryStatement.catchClauses().add(catchClause);
            variableDeclaration = ast.newSingleVariableDeclaration();
            variableDeclaration.modifiers().addAll(ast.newModifiers(Modifier.NONE));
            variableDeclaration.setType(ast.newSimpleType(ast.newSimpleName(("FinderException"))));
            variableDeclaration.setName(ast.newSimpleName("fe"));
            catchClause.setException(variableDeclaration);
            Block catchBlock = ast.newBlock();
            catchClause.setBody(catchBlock);

            ClassInstanceCreation cc = ast.newClassInstanceCreation();
            cc.setType(ast.newSimpleType(ast.newSimpleName("IDOCreateException")));
            addHomeImplImport("com.idega.data.IDOCreateException");
            cc.arguments().add(ast.newSimpleName(("fe")));

            ThrowStatement throwStatement = ast.newThrowStatement();
            throwStatement.setExpression(cc);
            catchBlock.statements().add(throwStatement);

            catchClause = ast.newCatchClause();
            tryStatement.catchClauses().add(catchClause);
            variableDeclaration = ast.newSingleVariableDeclaration();
            variableDeclaration.modifiers().addAll(ast.newModifiers(Modifier.NONE));
            variableDeclaration.setType(ast.newSimpleType(ast.newSimpleName(("Exception"))));
            variableDeclaration.setName(ast.newSimpleName("e"));
            catchClause.setException(variableDeclaration);
            catchBlock = ast.newBlock();
            catchClause.setBody(catchBlock);

            cc = ast.newClassInstanceCreation();
            cc.setType(ast.newSimpleType(ast.newSimpleName("IDOCreateException")));
            cc.arguments().add(ast.newSimpleName(("e")));

            throwStatement = ast.newThrowStatement();
            throwStatement.setExpression(cc);
            catchBlock.statements().add(throwStatement);
        }
    }

    writeImports(ast, unit, getHomeImplImports());
    commitChanges(iUnit, unit, document);
}

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);/*from   w w w .  j a va  2 s  .  co  m*/
    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 createInterface(final AST ast, final CompilationUnit cu, final Interface iface,
        final String name) {

    final TypeDeclaration td = ast.newTypeDeclaration();
    cu.types().add(td);//  ww  w  .jav  a2  s  .co m
    td.setInterface(true);
    td.setName(ast.newSimpleName(name));

    make(td, PUBLIC_KEYWORD);

    final NormalAnnotation ann = JdtHelper.addAnnotation(td, "de.dentrassi.varlink.spi.Interface");

    {
        final MemberValuePair mvpName = ast.newMemberValuePair();
        ann.values().add(mvpName);
        mvpName.setName(ast.newSimpleName("name"));
        mvpName.setValue(JdtHelper.newStringLiteral(ast, iface.getName()));
    }

    {
        final MemberValuePair mvpFactory = ast.newMemberValuePair();
        ann.values().add(mvpFactory);
        mvpFactory.setName(ast.newSimpleName("factory"));

        final TypeLiteral fn = ast.newTypeLiteral();
        fn.setType(ast.newSimpleType(ast.newName(name + "Impl.Factory")));

        mvpFactory.setValue(fn);
    }

    // create types

    createTypes(td, iface);

    // create errors

    createErrors(td, iface);

    /*
     *
     * public interface Async { public CompletableFuture<List<Netdev>> list(); }
     *
     * public interface Sync { public List<Netdev> list(); }
     *
     * public Async async();
     *
     * public default Sync sync() { return new Sync() {
     *
     * @Override public List<Netdev> list() { return Syncer.await(async().list()); }
     * }; }
     */

    // create async

    {
        // public interface Async { ... }

        final TypeDeclaration async = ast.newTypeDeclaration();
        td.bodyDeclarations().add(async);
        async.setInterface(true);

        make(async, PUBLIC_KEYWORD);
        async.setName(ast.newSimpleName("Async"));

        forMethods(ast, iface, (m, md) -> {
            make(md, PUBLIC_KEYWORD);
            async.bodyDeclarations().add(md);
            makeAsync(md);
        });

        // public Async async();

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

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

        final Type rt = ast.newSimpleType(ast.newSimpleName("Async"));
        md.setReturnType2(rt);
    }

    // create sync

    {
        // public interface Sync { ... }

        final TypeDeclaration sync = ast.newTypeDeclaration();
        td.bodyDeclarations().add(sync);
        sync.setInterface(true);

        make(sync, PUBLIC_KEYWORD);
        sync.setName(ast.newSimpleName("Sync"));

        // methods

        forMethods(ast, iface, (m, md) -> {
            make(md, PUBLIC_KEYWORD);
            sync.bodyDeclarations().add(md);
        });

        {
            final MethodDeclaration smd = ast.newMethodDeclaration();
            smd.setName(ast.newSimpleName("sync"));
            make(smd, PUBLIC_KEYWORD, DEFAULT_KEYWORD);
            td.bodyDeclarations().add(smd);

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

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

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

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

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

                make(md, PUBLIC_KEYWORD);
                acc.bodyDeclarations().add(md);

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

                // return Syncer.await(async().list());

                final MethodInvocation await = ast.newMethodInvocation();

                await.setExpression(ast.newName("de.dentrassi.varlink.spi.Syncer"));
                await.setName(ast.newSimpleName("await"));

                final MethodInvocation asyncCall = ast.newMethodInvocation();
                asyncCall.setName(ast.newSimpleName("async"));

                final MethodInvocation mcall = ast.newMethodInvocation();
                mcall.setName(ast.newSimpleName(m.getName()));
                mcall.setExpression(asyncCall);

                await.arguments().add(mcall);

                // add arguments

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

                if (m.getReturnTypes().isEmpty()) {
                    mbody.statements().add(ast.newExpressionStatement(await));
                } else {
                    final ReturnStatement rs = ast.newReturnStatement();
                    rs.setExpression(await);
                    mbody.statements().add(rs);
                }

            });
        }

    }

}

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

License:Open Source License

/**
 * Decompile annotation default value (value or default value literal).
 *
 * @param defaultValue//from   w  ww  .  jav a 2 s.c om
 *            default value
 * @param context
 *            context
 * @return expression AST Node
 */
@Nullable
public static Expression decompileAnnotationDefaultValue(@Nullable final Object defaultValue,
        @Nonnull final Element context) {
    final AST ast = context.getCu().getAst();
    if (defaultValue == null) {
        return null;
    }
    if (defaultValue instanceof A) {
        return decompileAnnotation((A) defaultValue, context);
    }
    // could be primitive array - use slow reflection
    if (defaultValue.getClass().isArray()) {
        final int size = Array.getLength(defaultValue);
        if (size == 1) {
            // single entry autoboxing
            return decompileAnnotationDefaultValue(Array.get(defaultValue, 0), context);
        }
        final ArrayInitializer arrayInitializer = ast.newArrayInitializer();
        for (int i = 0; i < size; ++i) {
            final Expression expression = decompileAnnotationDefaultValue(Array.get(defaultValue, i), context);
            if (expression != null) {
                arrayInitializer.expressions().add(expression);
            }
        }
        return arrayInitializer;
    }
    if (defaultValue instanceof Boolean) {
        return ast.newBooleanLiteral((Boolean) defaultValue);
    }
    if (defaultValue instanceof Byte) {
        return ast.newNumberLiteral(defaultValue.toString());
    }
    if (defaultValue instanceof Character) {
        final CharacterLiteral characterLiteral = ast.newCharacterLiteral();
        characterLiteral.setCharValue((Character) defaultValue);
        return characterLiteral;
    }
    if (defaultValue instanceof T) {
        final TypeLiteral typeLiteral = ast.newTypeLiteral();
        typeLiteral.setType(newType((T) defaultValue, context));
        return typeLiteral;
    }
    if (defaultValue instanceof Double) {
        return ast.newNumberLiteral(defaultValue.toString() + 'D');
    }
    if (defaultValue instanceof F) {
        final F f = (F) defaultValue;
        if (!f.isEnum()) {
            log.warn("Default value field must be enum!");
        }
        return ast.newQualifiedName(newTypeName(f.getT(), context), newSimpleName(f.getName(), ast));
    }
    if (defaultValue instanceof Float) {
        return ast.newNumberLiteral(defaultValue.toString() + 'F');
    }
    if (defaultValue instanceof Integer) {
        return ast.newNumberLiteral(defaultValue.toString());
    }
    if (defaultValue instanceof Long) {
        return ast.newNumberLiteral(defaultValue.toString() + 'L');
    }
    if (defaultValue instanceof Short) {
        return ast.newNumberLiteral(defaultValue.toString());
    }
    if (defaultValue instanceof String) {
        final StringLiteral stringLiteral = ast.newStringLiteral();
        stringLiteral.setLiteralValue((String) defaultValue);
        return stringLiteral;
    }
    log.warn("Unknown member value type '" + defaultValue.getClass().getName() + "'!");
    final StringLiteral stringLiteral = ast.newStringLiteral();
    stringLiteral.setLiteralValue(defaultValue.toString());
    return stringLiteral;
}

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();
        }//from   w w w .j a  va  2s  .co m
        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;
}