Example usage for org.eclipse.jdt.core.dom VariableDeclarationFragment setInitializer

List of usage examples for org.eclipse.jdt.core.dom VariableDeclarationFragment setInitializer

Introduction

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

Prototype

public void setInitializer(Expression initializer) 

Source Link

Document

Sets or clears the initializer of this variable declaration.

Usage

From source file:ch.acanda.eclipse.pmd.java.resolution.design.SingularFieldQuickFix.java

License:Open Source License

/**
 * Replaces the assignment with a variable declaration. If the assignment is the only one in the block for this
 * variable, the final modifier is added to the declaration.
 *//*  w  w w  .  j  a  v a  2s  .c om*/
@SuppressWarnings("unchecked")
private void replaceAssignment(final VariableDeclarationFragment node, final Assignment assignment,
        final boolean finalDeclaration) {
    final FieldDeclaration fieldDeclaration = (FieldDeclaration) node.getParent();
    final VariableDeclarationStatement declaration = (VariableDeclarationStatement) node.getAST()
            .createInstance(VariableDeclarationStatement.class);
    declaration.setType(ASTUtil.copy(fieldDeclaration.getType()));
    final VariableDeclarationFragment fragment = (VariableDeclarationFragment) node.getAST()
            .createInstance(VariableDeclarationFragment.class);
    fragment.setName(ASTUtil.copy(node.getName()));
    fragment.setInitializer(ASTUtil.copy(assignment.getRightHandSide()));
    declaration.fragments().add(fragment);
    if (finalDeclaration) {
        final Modifier modifier = (Modifier) node.getAST().createInstance(Modifier.class);
        modifier.setKeyword(ModifierKeyword.FINAL_KEYWORD);
        declaration.modifiers().add(modifier);
    }
    ASTUtil.replace(assignment.getParent(), declaration);
}

From source file:ch.acanda.eclipse.pmd.java.resolution.optimization.RedundantFieldInitializerQuickFix.java

License:Open Source License

/**
 * Removes the redundant field initializer.
 *///from   w w w.j  a  v  a 2 s .c  om
@Override
protected boolean apply(final VariableDeclarationFragment node) {
    node.setInitializer(null);
    return true;
}

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

License:Apache License

private static void merge(CompilationUnit unit, String pkgName, String typeName, String auth, String dbName,
        List<String> tableCreators) {
    unit.recordModifications();/*from  w  w w  .  ja  v a  2s.  c o m*/
    AST ast = unit.getAST();
    TypeDeclaration type = (TypeDeclaration) unit.types().get(0);
    ImportDeclaration id = ast.newImportDeclaration();
    id.setName(ast.newName("cn.ieclipse.aorm.Session"));
    unit.imports().add(id);

    id = ast.newImportDeclaration();
    id.setName(ast.newName("android.content.UriMatcher"));
    unit.imports().add(id);

    id = ast.newImportDeclaration();
    id.setName(ast.newName("android.database.sqlite.SQLiteDatabase"));
    unit.imports().add(id);

    id = ast.newImportDeclaration();
    id.setName(ast.newName("android.database.sqlite.SQLiteOpenHelper"));
    unit.imports().add(id);

    id = ast.newImportDeclaration();
    id.setName(ast.newName("java.net.Uri"));
    unit.imports().add(id);

    id = ast.newImportDeclaration();
    id.setName(ast.newName("android.content.ContentValue"));
    unit.imports().add(id);

    VariableDeclarationFragment vdf = ast.newVariableDeclarationFragment();
    vdf.setName(ast.newSimpleName("AUTH"));
    StringLiteral sl = ast.newStringLiteral();
    sl.setLiteralValue(auth);
    vdf.setInitializer(sl);

    FieldDeclaration fd = ast.newFieldDeclaration(vdf);
    fd.modifiers().addAll(ast.newModifiers((Modifier.PUBLIC | Modifier.STATIC | Modifier.FINAL)));
    fd.setType(ast.newSimpleType(ast.newSimpleName("String")));

    int i = 0;
    type.bodyDeclarations().add(i++, fd);

    // URI = Uri.parse("content://" + AUTH);
    vdf = ast.newVariableDeclarationFragment();
    vdf.setName(ast.newSimpleName("URI"));

    MethodInvocation mi = ast.newMethodInvocation();
    mi.setExpression(ast.newSimpleName("Uri"));
    mi.setName(ast.newSimpleName("parse"));

    InfixExpression fix = ast.newInfixExpression();
    fix.setOperator(InfixExpression.Operator.PLUS);
    sl = ast.newStringLiteral();
    sl.setLiteralValue("content://");
    fix.setLeftOperand(sl);
    fix.setRightOperand(ast.newSimpleName("AUTH"));

    mi.arguments().add(fix);

    vdf.setInitializer(mi);
    fd = ast.newFieldDeclaration(vdf);
    fd.modifiers().addAll(ast.newModifiers((Modifier.PUBLIC | Modifier.STATIC | Modifier.FINAL)));
    fd.setType(ast.newSimpleType(ast.newSimpleName("Uri")));

    type.bodyDeclarations().add(i++, fd);

    // private mOpenHelper;
    vdf = ast.newVariableDeclarationFragment();
    vdf.setName(ast.newSimpleName("mOpenHelper"));

    fd = ast.newFieldDeclaration(vdf);
    fd.modifiers().add(ast.newModifier(Modifier.ModifierKeyword.PRIVATE_KEYWORD));
    fd.setType(ast.newSimpleType(ast.newName("SQLiteOpenHelper")));
    type.bodyDeclarations().add(i++, fd);

    // private static session;
    vdf = ast.newVariableDeclarationFragment();
    vdf.setName(ast.newSimpleName("session"));

    fd = ast.newFieldDeclaration(vdf);
    fd.modifiers().addAll(ast.newModifiers((Modifier.PRIVATE | Modifier.STATIC)));
    fd.setType(ast.newSimpleType(ast.newName("Session")));
    type.bodyDeclarations().add(i++, fd);

    // public static Session getSession(){
    // return session;
    // }

    MethodDeclaration md = ast.newMethodDeclaration();
    md.modifiers().addAll(ast.newModifiers((Modifier.PUBLIC | Modifier.STATIC)));
    md.setReturnType2(ast.newSimpleType(ast.newName("Session")));
    md.setName(ast.newSimpleName("getSession"));

    Block methodBlock = ast.newBlock();
    ReturnStatement returnStmt = ast.newReturnStatement();
    returnStmt.setExpression(ast.newSimpleName("session"));
    methodBlock.statements().add(returnStmt);
    md.setBody(methodBlock);
    type.bodyDeclarations().add(i, md);

    // modify onCreate
    rewriteOnCreate(unit, dbName, tableCreators);
}

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

License:Apache License

private static void genInnerSQLiteOpenHelper(AnonymousClassDeclaration acd, AST ast,
        List<String> tableCreators) {
    MethodDeclaration md = ast.newMethodDeclaration();
    md.modifiers().addAll(ast.newModifiers((Modifier.PUBLIC)));
    md.setReturnType2(ast.newPrimitiveType(PrimitiveType.VOID));
    md.setName(ast.newSimpleName("onCreate"));
    SingleVariableDeclaration svd = ast.newSingleVariableDeclaration();
    svd.setName(ast.newSimpleName("db"));
    svd.setType(ast.newSimpleType(ast.newSimpleName("SQLiteDatabase")));
    md.parameters().add(svd);//from   ww  w . j  a v a  2 s  . c o  m
    Block innerBlock = ast.newBlock();
    md.setBody(innerBlock);
    VariableDeclarationFragment vdf = ast.newVariableDeclarationFragment();
    vdf.setName(ast.newSimpleName("sql"));
    StringLiteral sl = ast.newStringLiteral();
    sl.setLiteralValue("");
    vdf.setInitializer(sl);
    VariableDeclarationStatement vds = ast.newVariableDeclarationStatement(vdf);
    vds.setType(ast.newSimpleType(ast.newSimpleName("String")));
    innerBlock.statements().add(vds);
    for (String creator : tableCreators) {
        String[] lines = creator.split(SourceAnalysis.LF);
        for (String line : lines) {
            Assignment a = ast.newAssignment();
            a.setOperator(Assignment.Operator.PLUS_ASSIGN);
            a.setLeftHandSide(ast.newSimpleName("sql"));
            StringLiteral temp = ast.newStringLiteral();
            temp.setLiteralValue(line);
            a.setRightHandSide(temp);
            innerBlock.statements().add(ast.newExpressionStatement(a));
        }

        MethodInvocation mi = ast.newMethodInvocation();
        mi.setName(ast.newSimpleName("execSQL"));
        mi.setExpression(ast.newSimpleName("db"));
        mi.arguments().add(ast.newSimpleName("sql"));
        innerBlock.statements().add(ast.newExpressionStatement(mi));
    }

    acd.bodyDeclarations().add(md);
    // onUpgrade
    md = ast.newMethodDeclaration();
    md.modifiers().addAll(ast.newModifiers((Modifier.PUBLIC)));
    md.setReturnType2(ast.newPrimitiveType(PrimitiveType.VOID));
    md.setName(ast.newSimpleName("onUpgrade"));
    svd = ast.newSingleVariableDeclaration();
    svd.setName(ast.newSimpleName("db"));
    svd.setType(ast.newSimpleType(ast.newSimpleName("SQLiteDatabase")));
    md.parameters().add(svd);

    svd = ast.newSingleVariableDeclaration();
    svd.setName(ast.newSimpleName("oldVersion"));
    svd.setType(ast.newPrimitiveType(PrimitiveType.INT));
    md.parameters().add(svd);

    svd = ast.newSingleVariableDeclaration();
    svd.setName(ast.newSimpleName("newVersion"));
    svd.setType(ast.newPrimitiveType(PrimitiveType.INT));
    md.parameters().add(svd);

    innerBlock = ast.newBlock();
    md.setBody(innerBlock);
    acd.bodyDeclarations().add(md);
}

From source file:com.alex.example.fixlicense.actions.SampleAction.java

License:Open Source License

private FieldDeclaration createLiceseInLineField(AST ast) {
    VariableDeclarationFragment vdf = ast.newVariableDeclarationFragment();
    vdf.setName(ast.newSimpleName("COPYRIGHT"));
    StringLiteral sl = ast.newStringLiteral();
    sl.setLiteralValue(license_inline);// w w w. j  a v  a2  s . c  om
    vdf.setInitializer(sl);
    FieldDeclaration fd = ast.newFieldDeclaration(vdf);
    fd.modifiers().addAll(ast.newModifiers(Modifier.PUBLIC | Modifier.STATIC | Modifier.FINAL));
    fd.setType(ast.newSimpleType(ast.newSimpleName("String")));

    return fd;
}

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

License:Open Source License

@Override
public void endVisit(VariableDeclarationFragment node) {
    Expression initializer = node.getInitializer();
    if (initializer != null) {
        ITypeBinding nodeType = getBoxType(node);
        ITypeBinding initType = getBoxType(initializer);
        if (nodeType.isPrimitive() && !initType.isPrimitive()) {
            node.setInitializer(unbox(initializer));
        } else if (!nodeType.isPrimitive() && initType.isPrimitive()) {
            node.setInitializer(box(initializer));
        }//from ww w  .ja  v  a  2s. c  o m
    }
}

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

License:Open Source License

/**
 * Add an initializer expression to a field declaration fragment.
 *//*from w ww. java  2s  .co  m*/
private void addFieldInitializer(VariableDeclarationFragment var) {
    AST ast = var.getAST();
    ITypeBinding type = ((FieldDeclaration) var.getParent()).getType().resolveBinding();
    var.setInitializer(getDefaultValue(ast, type));
}

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

License:Open Source License

/**
 * Strip field initializers, convert them to assignment statements, and
 * add them to the appropriate list of initialization statements.
 *///  w  w w .j  a  va 2s . com
private void addFieldInitializer(BodyDeclaration member, List<Statement> initStatements,
        List<Statement> classInitStatements) {
    FieldDeclaration field = (FieldDeclaration) member;
    @SuppressWarnings("unchecked")
    List<VariableDeclarationFragment> fragments = field.fragments(); // safe by specification
    for (VariableDeclarationFragment frag : fragments) {
        if (frag.getInitializer() != null) {
            Statement assignStmt = makeAssignmentStatement(frag);
            if (Modifier.isStatic(field.getModifiers())) {
                IVariableBinding binding = Types.getVariableBinding(frag);
                if (binding.getConstantValue() == null) { // constants don't need initialization
                    classInitStatements.add(assignStmt);
                    frag.setInitializer(null);
                }
            } else {
                // always initialize instance variables, since they can't be constants
                initStatements.add(assignStmt);
                frag.setInitializer(null);
            }
        }
    }
}

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

License:Open Source License

@Override
public boolean visit(FieldDeclaration node) {
    int mods = node.getModifiers();
    if (Modifier.isStatic(mods)) {
        ASTNode parent = node.getParent();
        @SuppressWarnings("unchecked")
        List<BodyDeclaration> classMembers = parent instanceof AbstractTypeDeclaration
                ? ((AbstractTypeDeclaration) parent).bodyDeclarations()
                : ((AnonymousClassDeclaration) parent).bodyDeclarations(); // safe by specification
        int indexOfNewMember = classMembers.indexOf(node) + 1;

        @SuppressWarnings("unchecked")
        List<VariableDeclarationFragment> fragments = node.fragments(); // safe by specification
        for (VariableDeclarationFragment var : fragments) {
            IVariableBinding binding = Types.getVariableBinding(var);
            if (Types.isPrimitiveConstant(binding) && Modifier.isPrivate(binding.getModifiers())) {
                // Don't define accessors for private constants, since they can be
                // directly referenced.
                continue;
            }/*from   w  ww. j ava  2 s. c  o m*/

            // rename varName to varName_, per Obj-C style guide
            SimpleName oldName = var.getName();
            ITypeBinding type = ((AbstractTypeDeclaration) node.getParent()).resolveBinding();
            String varName = NameTable.getStaticVarQualifiedName(type, oldName.getIdentifier());
            NameTable.rename(binding, varName);
            ITypeBinding typeBinding = binding.getType();
            var.setExtraDimensions(0); // if array, type was corrected above

            // add accessor(s)
            if (needsReader(var, classMembers)) {
                classMembers.add(indexOfNewMember++, makeStaticReader(var, mods));
            }
            if (!Modifier.isFinal(node.getModifiers()) && needsWriter(var, classMembers)) {
                classMembers.add(indexOfNewMember++,
                        makeStaticWriter(var, oldName.getIdentifier(), node.getType(), mods));
            }

            // move non-constant initialization to init block
            Expression initializer = var.getInitializer();
            if (initializer != null && initializer.resolveConstantExpressionValue() == null) {
                var.setInitializer(null);

                AST ast = var.getAST();
                SimpleName newName = ast.newSimpleName(varName);
                Types.addBinding(newName, binding);
                Assignment assign = ast.newAssignment();
                assign.setLeftHandSide(newName);
                Expression newInit = NodeCopier.copySubtree(ast, initializer);
                assign.setRightHandSide(newInit);
                Types.addBinding(assign, typeBinding);

                Block initBlock = ast.newBlock();
                @SuppressWarnings("unchecked")
                List<Statement> stmts = initBlock.statements(); // safe by definition
                stmts.add(ast.newExpressionStatement(assign));
                Initializer staticInitializer = ast.newInitializer();
                staticInitializer.setBody(initBlock);
                @SuppressWarnings("unchecked")
                List<IExtendedModifier> initMods = staticInitializer.modifiers(); // safe by definition
                initMods.add(ast.newModifier(ModifierKeyword.STATIC_KEYWORD));
                classMembers.add(indexOfNewMember++, staticInitializer);
            }
        }
    }
    return true;
}

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

License:Open Source License

@Override
public boolean visit(Block node) {
    // split array declarations so that initializers are in separate statements.
    @SuppressWarnings("unchecked")
    List<Statement> stmts = node.statements(); // safe by definition
    int n = stmts.size();
    for (int i = 0; i < n; i++) {
        Statement s = stmts.get(i);
        if (s instanceof VariableDeclarationStatement) {
            VariableDeclarationStatement var = (VariableDeclarationStatement) s;
            Map<VariableDeclarationFragment, Expression> initializers = Maps.newLinkedHashMap();
            @SuppressWarnings("unchecked")
            List<VariableDeclarationFragment> fragments = var.fragments();
            for (VariableDeclarationFragment fragment : fragments) {
                ITypeBinding varType = Types.getTypeBinding(fragment);
                if (varType.isArray()) {
                    fragment.setExtraDimensions(0);
                    Expression initializer = fragment.getInitializer();
                    if (initializer != null) {
                        initializers.put(fragment, initializer);
                        if (initializer instanceof ArrayCreation) {
                            ArrayCreation creator = (ArrayCreation) initializer;
                            if (creator.getInitializer() != null) {
                                // replace this redundant array creation node with its
                                // rewritten initializer
                                initializer = creator.getInitializer();
                            } else {
                                continue;
                            }//from w  w  w  . j  a va  2s  .  c  o m
                        }
                        if (initializer instanceof ArrayInitializer) {
                            fragment.setInitializer(createIOSArrayInitializer(Types.getTypeBinding(fragment),
                                    (ArrayInitializer) initializer));
                        }
                    }
                }
            }
        } else if (s instanceof ExpressionStatement
                && ((ExpressionStatement) s).getExpression() instanceof Assignment) {
            Assignment assign = (Assignment) ((ExpressionStatement) s).getExpression();
            ITypeBinding assignType = Types.getTypeBinding(assign);
            if (assign.getRightHandSide() instanceof ArrayInitializer) {
                ArrayInitializer arrayInit = (ArrayInitializer) assign.getRightHandSide();
                assert assignType.isArray() : "array initializer assigned to non-array";
                assign.setRightHandSide(createIOSArrayInitializer(assignType, arrayInit));
            } else if (assign.getRightHandSide() instanceof ArrayCreation) {
                ArrayCreation arrayCreate = (ArrayCreation) assign.getRightHandSide();
                ArrayInitializer arrayInit = arrayCreate.getInitializer();
                if (arrayInit != null) {
                    // Replace ArrayCreation node with its initializer.
                    AST ast = node.getAST();
                    Assignment newAssign = ast.newAssignment();
                    Types.addBinding(newAssign, assignType);
                    newAssign.setLeftHandSide(NodeCopier.copySubtree(ast, assign.getLeftHandSide()));
                    newAssign.setRightHandSide(createIOSArrayInitializer(assignType, arrayInit));
                    ((ExpressionStatement) s).setExpression(newAssign);
                }
            }
        }
    }
    return true;
}