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

Introduction

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

Prototype

public ArrayCreation newArrayCreation() 

Source Link

Document

Creates and returns a new unparented array creation expression node owned by this AST.

Usage

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

License:Open Source License

private ExpressionStatement makeAssignmentStatement(VariableDeclarationFragment fragment) {
    AST ast = fragment.getAST();
    IVariableBinding varBinding = Types.getVariableBinding(fragment);
    Assignment assignment = ast.newAssignment();
    Types.addBinding(assignment, varBinding.getType());
    Expression lhs = ast.newSimpleName(fragment.getName().getIdentifier());
    Types.addBinding(lhs, varBinding);
    assignment.setLeftHandSide(lhs);//from ww  w . j  a  v a2 s.c  o  m

    Expression initializer = fragment.getInitializer();
    if (initializer instanceof ArrayInitializer) {
        // An array initializer cannot be directly assigned, since by itself
        // it's just shorthand for an array creation node.  This therefore
        // builds an array creation node with the existing initializer.
        ArrayCreation arrayCreation = ast.newArrayCreation();
        ITypeBinding arrayType = varBinding.getType();
        Types.addBinding(arrayCreation, arrayType);
        Type newType = Types.makeIOSType(arrayType);
        assert newType != null;
        ArrayType newArrayType = ast.newArrayType(newType);
        Types.addBinding(newArrayType, arrayType);
        arrayCreation.setType(newArrayType);
        arrayCreation.setInitializer((ArrayInitializer) NodeCopier.copySubtree(ast, initializer));
        assignment.setRightHandSide(arrayCreation);
    } else {
        assignment.setRightHandSide(NodeCopier.copySubtree(ast, initializer));
    }
    return ast.newExpressionStatement(assignment);
}

---

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

License:Apache License

public static ArrayCreation newArrayCreation(AST ast, ArrayInitializer initializer) {
    ITypeBinding type = Types.getTypeBinding(initializer);
    ArrayCreation arrayCreation = ast.newArrayCreation();
    arrayCreation.setType((ArrayType) newType(ast, type));
    arrayCreation.setInitializer(initializer);
    Types.addBinding(arrayCreation, type);
    return arrayCreation;
}

---

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 ww w .j  av  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.jboss.forge.roaster.model.impl.expressions.ArrayImpl.java

License:Open Source License

@Override
public ArrayCreation materialize(AST ast) {
    if (isMaterialized()) {
        return array;
    }//from  w ww.  ja  v a2 s  .co m
    array = ast.newArrayCreation();
    array.setType((ArrayType) JDTHelper.getType(type + new String(new char[getDimension()]).replace("\0", "[]"),
            ast));
    for (ExpressionSource<O, ArrayConstructorExpression<O, P>, ?> dim : dims) {
        array.dimensions().add(wireAndGetExpression(dim, this, ast));
    }
    if (init != null) {
        array.setInitializer((ArrayInitializer) wireAndGetExpression(init, this, ast));
    }
    return array;
}

---

From source file:ptolemy.backtrack.eclipse.ast.transform.AssignmentTransformer.java

License:Open Source License

/** Create the body of an assignment method, which backs up the field
 *  before a new value is assigned to it.
 *
 *  @param ast The {@link AST} object./*from  w  ww.  ja v a  2s . com*/
 *  @param state The current state of the type analyzer.
 *  @param fieldName The name of the field.
 *  @param fieldType The type of the left-hand side (with <tt>indices</tt>
 *   dimensions less than the original field type).
 *  @param indices The number of indices.
 *  @param special Whether to handle special assign operators.
 *  @return The body of the assignment method.
 */
private Block _createAssignmentBlock(AST ast, TypeAnalyzerState state, String fieldName, Type fieldType,
        int indices, boolean special) {
    Block block = ast.newBlock();

    // Test if the checkpoint object is not null.
    IfStatement ifStatement = ast.newIfStatement();
    InfixExpression testExpression = ast.newInfixExpression();

    InfixExpression condition1 = ast.newInfixExpression();
    condition1.setLeftOperand(ast.newSimpleName(CHECKPOINT_NAME));
    condition1.setOperator(InfixExpression.Operator.NOT_EQUALS);
    condition1.setRightOperand(ast.newNullLiteral());

    InfixExpression condition2 = ast.newInfixExpression();
    MethodInvocation getTimestamp = ast.newMethodInvocation();
    getTimestamp.setExpression(ast.newSimpleName(CHECKPOINT_NAME));
    getTimestamp.setName(ast.newSimpleName("getTimestamp"));
    condition2.setLeftOperand(getTimestamp);
    condition2.setOperator(InfixExpression.Operator.GREATER);
    condition2.setRightOperand(ast.newNumberLiteral("0"));

    testExpression.setLeftOperand(condition1);
    testExpression.setOperator(InfixExpression.Operator.CONDITIONAL_AND);
    testExpression.setRightOperand(condition2);
    ifStatement.setExpression(testExpression);

    // The "then" branch.
    Block thenBranch = ast.newBlock();

    // Method call to store old value.
    MethodInvocation recordInvocation = ast.newMethodInvocation();
    recordInvocation.setExpression(ast.newSimpleName(_getRecordName(fieldName)));
    recordInvocation.setName(ast.newSimpleName("add"));

    // If there are indices, create an integer array of those indices,
    // and add it as an argument.
    if (indices == 0) {
        recordInvocation.arguments().add(ast.newNullLiteral());
    } else {
        ArrayCreation arrayCreation = ast.newArrayCreation();
        ArrayType arrayType = ast.newArrayType(ast.newPrimitiveType(PrimitiveType.INT));
        ArrayInitializer initializer = ast.newArrayInitializer();

        for (int i = 0; i < indices; i++) {
            initializer.expressions().add(ast.newSimpleName("index" + i));
        }

        arrayCreation.setType(arrayType);
        arrayCreation.setInitializer(initializer);
        recordInvocation.arguments().add(arrayCreation);
    }

    // If there are indices, add them ("index0", "index1", ...) after the
    // field.
    Expression field = ast.newSimpleName(fieldName);

    if (indices > 0) {
        for (int i = 0; i < indices; i++) {
            ArrayAccess arrayAccess = ast.newArrayAccess();
            arrayAccess.setArray(field);
            arrayAccess.setIndex(ast.newSimpleName("index" + i));
            field = arrayAccess;
        }
    }

    // Set the field as the next argument.
    recordInvocation.arguments().add(field);

    // Get current timestamp from the checkpoint object.
    MethodInvocation timestampGetter = ast.newMethodInvocation();
    timestampGetter.setExpression(ast.newSimpleName(CHECKPOINT_NAME));
    timestampGetter.setName(ast.newSimpleName("getTimestamp"));

    // Set the timestamp as the next argument.
    recordInvocation.arguments().add(timestampGetter);

    // The statement of the method call.
    ExpressionStatement recordStatement = ast.newExpressionStatement(recordInvocation);
    thenBranch.statements().add(recordStatement);

    ifStatement.setThenStatement(thenBranch);
    block.statements().add(ifStatement);

    // Finally, assign the new value to the field.
    Assignment assignment = ast.newAssignment();
    assignment.setLeftHandSide((Expression) ASTNode.copySubtree(ast, field));
    assignment.setRightHandSide(ast.newSimpleName("newValue"));
    assignment.setOperator(Assignment.Operator.ASSIGN);

    // Set the checkpoint object of the new value, if necessary.
    Class c;

    try {
        c = fieldType.toClass(state.getClassLoader());
    } catch (ClassNotFoundException e) {
        throw new ASTClassNotFoundException(fieldType.getName());
    }

    if (hasMethod(c, _getSetCheckpointMethodName(false), new Class[] { Checkpoint.class })
            || state.getCrossAnalyzedTypes().contains(c.getName())) {
        block.statements().add(_createSetCheckpointInvocation(ast));
    } else {
        addToLists(_fixSetCheckpoint, c.getName(), block);
    }

    // Return the result of the assignment.
    if (special && _assignOperators.containsKey(fieldType.getName())) {
        String[] operators = _assignOperators.get(fieldType.getName());

        SwitchStatement switchStatement = ast.newSwitchStatement();
        switchStatement.setExpression(ast.newSimpleName("operator"));

        boolean isPostfix = true;

        for (int i = 0; i < operators.length; i++) {
            String operator = operators[i];

            SwitchCase switchCase = ast.newSwitchCase();
            switchCase.setExpression(ast.newNumberLiteral(Integer.toString(i)));
            switchStatement.statements().add(switchCase);

            ReturnStatement returnStatement = ast.newReturnStatement();

            if (operator.equals("=")) {
                Assignment newAssignment = (Assignment) ASTNode.copySubtree(ast, assignment);
                returnStatement.setExpression(newAssignment);
            } else if (operator.equals("++") || operator.equals("--")) {
                Expression expression;

                if (isPostfix) {
                    PostfixExpression postfix = ast.newPostfixExpression();
                    postfix.setOperand((Expression) ASTNode.copySubtree(ast, assignment.getLeftHandSide()));
                    postfix.setOperator(PostfixExpression.Operator.toOperator(operator));
                    expression = postfix;

                    // Produce prefix operators next time.
                    if (operator.equals("--")) {
                        isPostfix = false;
                    }
                } else {
                    PrefixExpression prefix = ast.newPrefixExpression();
                    prefix.setOperand((Expression) ASTNode.copySubtree(ast, assignment.getLeftHandSide()));
                    prefix.setOperator(PrefixExpression.Operator.toOperator(operator));
                    expression = prefix;
                }

                returnStatement.setExpression(expression);
            } else {
                Assignment newAssignment = (Assignment) ASTNode.copySubtree(ast, assignment);
                newAssignment.setOperator(Assignment.Operator.toOperator(operator));
                returnStatement.setExpression(newAssignment);
            }

            switchStatement.statements().add(returnStatement);
        }

        // The default statement: just return the old value.
        // This case should not be reached.
        SwitchCase defaultCase = ast.newSwitchCase();
        defaultCase.setExpression(null);
        switchStatement.statements().add(defaultCase);

        ReturnStatement defaultReturn = ast.newReturnStatement();
        defaultReturn.setExpression((Expression) ASTNode.copySubtree(ast, assignment.getLeftHandSide()));
        switchStatement.statements().add(defaultReturn);

        block.statements().add(switchStatement);
    } else {
        ReturnStatement returnStatement = ast.newReturnStatement();
        returnStatement.setExpression(assignment);
        block.statements().add(returnStatement);
    }

    return block;
}

---

From source file:ptolemy.backtrack.eclipse.ast.transform.AssignmentTransformer.java

License:Open Source License

/** Create a backup method that backs up an array (possibly with some given
 *  indices) in memory, and return the same array to be aliased.
 *
 *  @param ast The {@link AST} object./*from   w ww  .j  a  v a  2  s. c om*/
 *  @param root The root of the AST.
 *  @param state The current state of the type analyzer.
 *  @param fieldName The name of the field to be backed up.
 *  @param fieldType The type of the field.
 *  @param indices The number of indices.
 *  @param isStatic Whether the field is static.
 *  @return The declaration of the backup method.
 */
private MethodDeclaration _createBackupMethod(AST ast, CompilationUnit root, TypeAnalyzerState state,
        String fieldName, Type fieldType, int indices, boolean isStatic) {
    Class currentClass = state.getCurrentClass();
    ClassLoader loader = state.getClassLoader();
    String methodName = _getBackupMethodName(fieldName);

    // Check if the method is duplicated (possibly because the source
    // program is refactored twice).
    if (_isMethodDuplicated(currentClass, methodName, fieldType, indices, isStatic, loader, false)) {
        throw new ASTDuplicatedMethodException(currentClass.getName(), methodName);
    }

    // Get the type of the new value. The return value has the same
    // type.
    for (int i = 0; i < indices; i++) {
        try {
            fieldType = fieldType.removeOneDimension();
        } catch (ClassNotFoundException e) {
            throw new ASTClassNotFoundException(fieldType);
        }
    }

    String fieldTypeName = fieldType.getName();

    MethodDeclaration method = ast.newMethodDeclaration();
    method.setName(ast.newSimpleName(methodName));
    method.setReturnType2(createType(ast, getClassName(fieldTypeName, state, root)));

    // If the field is static, add a checkpoint object argument.
    if (isStatic) {
        // Add a "$CHECKPOINT" argument.
        SingleVariableDeclaration checkpoint = ast.newSingleVariableDeclaration();
        String checkpointType = getClassName(Checkpoint.class, state, root);
        checkpoint.setType(ast.newSimpleType(createName(ast, checkpointType)));
        checkpoint.setName(ast.newSimpleName(CHECKPOINT_NAME));
        method.parameters().add(checkpoint);
    }

    // Add all the indices.
    for (int i = 0; i < indices; i++) {
        SingleVariableDeclaration index = ast.newSingleVariableDeclaration();
        index.setType(ast.newPrimitiveType(PrimitiveType.INT));
        index.setName(ast.newSimpleName("index" + i));
        method.parameters().add(index);
    }

    Block body = ast.newBlock();
    method.setBody(body);

    // The first statement: backup the whole array.
    MethodInvocation backup = ast.newMethodInvocation();
    backup.setExpression(ast.newSimpleName(_getRecordName(fieldName)));
    backup.setName(ast.newSimpleName("backup"));

    if (indices == 0) {
        backup.arguments().add(ast.newNullLiteral());
    } else {
        ArrayCreation arrayCreation = ast.newArrayCreation();
        ArrayType arrayType = ast.newArrayType(ast.newPrimitiveType(PrimitiveType.INT));
        ArrayInitializer initializer = ast.newArrayInitializer();

        for (int i = 0; i < indices; i++) {
            initializer.expressions().add(ast.newSimpleName("index" + i));
        }

        arrayCreation.setType(arrayType);
        arrayCreation.setInitializer(initializer);
        backup.arguments().add(arrayCreation);
    }

    //If there are indices, add them ("index0", "index1", ...) after the
    // field.
    Expression field = ast.newSimpleName(fieldName);

    if (indices > 0) {
        for (int i = 0; i < indices; i++) {
            ArrayAccess arrayAccess = ast.newArrayAccess();
            arrayAccess.setArray(field);
            arrayAccess.setIndex(ast.newSimpleName("index" + i));
            field = arrayAccess;
        }
    }

    // Set the field as the next argument.
    backup.arguments().add(field);

    // Get current timestamp from the checkpoint object.
    MethodInvocation timestampGetter = ast.newMethodInvocation();
    timestampGetter.setExpression(ast.newSimpleName(CHECKPOINT_NAME));
    timestampGetter.setName(ast.newSimpleName("getTimestamp"));

    // Set the timestamp as the next argument.
    backup.arguments().add(timestampGetter);

    body.statements().add(ast.newExpressionStatement(backup));

    // The second statement: return the array.
    ReturnStatement returnStatement = ast.newReturnStatement();
    returnStatement.setExpression((Expression) ASTNode.copySubtree(ast, field));
    body.statements().add(returnStatement);

    // If the field is static, the method is also static; the method
    // is also private.
    List modifiers = method.modifiers();
    modifiers.add(ast.newModifier(Modifier.ModifierKeyword.PRIVATE_KEYWORD));
    modifiers.add(ast.newModifier(Modifier.ModifierKeyword.FINAL_KEYWORD));
    if (isStatic) {
        modifiers.add(ast.newModifier(Modifier.ModifierKeyword.STATIC_KEYWORD));
    }

    return method;
}

---

From source file:ptolemy.backtrack.eclipse.ast.transform.AssignmentTransformer.java

License:Open Source License

/** Create a field that stores all the records as an array.
 *
 *  @param ast The {@link AST} object./*from   w w w  .  ja v a  2  s.  c o m*/
 *  @param root The root of the AST.
 *  @param state The current state of the type analyzer.
 *  @param fieldNames The names of all the fields.
 *  @return The field declaration of the record array.
 */
private FieldDeclaration _createRecordArray(AST ast, CompilationUnit root, TypeAnalyzerState state,
        List fieldNames) {
    VariableDeclarationFragment fragment = ast.newVariableDeclarationFragment();
    fragment.setName(ast.newSimpleName(RECORDS_NAME));

    ArrayCreation initializer = ast.newArrayCreation();
    String typeName = getClassName(FieldRecord.class, state, root);
    initializer.setType(ast.newArrayType(createType(ast, typeName)));

    Iterator fields = fieldNames.iterator();
    ArrayInitializer arrayInitializer = ast.newArrayInitializer();
    initializer.setInitializer(arrayInitializer);

    List expressions = arrayInitializer.expressions();

    while (fields.hasNext()) {
        String fieldName = (String) fields.next();

        String recordName = _getRecordName(fieldName);
        expressions.add(ast.newSimpleName(recordName));
    }

    fragment.setInitializer(initializer);

    FieldDeclaration array = ast.newFieldDeclaration(fragment);
    array.setType(ast.newArrayType(createType(ast, typeName)));

    array.modifiers().add(ast.newModifier(Modifier.ModifierKeyword.PRIVATE_KEYWORD));
    array.modifiers().add(ast.newModifier(Modifier.ModifierKeyword.TRANSIENT_KEYWORD));
    return array;
}

---