Example usage for org.eclipse.jdt.internal.compiler.ast ASTNode FirstAssignmentToLocal

Introduction

In this page you can find the example usage for org.eclipse.jdt.internal.compiler.ast ASTNode FirstAssignmentToLocal.

Prototype

int FirstAssignmentToLocal

To view the source code for org.eclipse.jdt.internal.compiler.ast ASTNode FirstAssignmentToLocal.

Click Source Link

Usage

From source file:org.eclipse.objectteams.otdt.internal.core.compiler.lifting.Lowering.java

License:Open Source License

public Expression lowerExpression(final BlockScope scope, final Expression expression,
        TypeBinding unloweredType, TypeBinding requiredType, final Expression teamExpression,
        boolean needNullCheck, boolean deferredResolve) {
    // Note, unless deferredResolve, this method is responsible for 'resolving' all AST nodes it generates!

    int sourceStart = expression.sourceStart;
    int sourceEnd = expression.sourceEnd;
    AstGenerator gen = new AstGenerator(sourceStart, sourceEnd);

    unloweredType = TeamModel.strengthenRoleType(scope.enclosingSourceType(), unloweredType);
    Expression loweringExpr = null;

    TypeBinding expressionType = expression.resolvedType;
    // this assertion needed for pushing/casting using unchecked one-byte opcodes.
    assert expressionType == null || expressionType.leafComponentType() instanceof ReferenceBinding;

    LocalVariableBinding localVar = null;
    Expression unloweredExpression = expression;
    if (expression instanceof ThisReference || expression instanceof AllocationExpression)
        needNullCheck = false;//from www .java  2s .c  om
    if (needNullCheck) {
        localVar = makeNewLocal(scope, unloweredType, sourceStart, sourceEnd, deferredResolve);
        SingleNameReference varRef = gen.singleNameReference(localVar.name);
        if (!deferredResolve) {
            varRef.binding = localVar;
            varRef.bits = Binding.LOCAL;
            varRef.constant = Constant.NotAConstant;
            varRef.resolvedType = unloweredType;
        }
        unloweredExpression = varRef;
    }

    if (unloweredType.isArrayType()) {
        // (1) array translation:
        ArrayLowering trans = new ArrayLowering(teamExpression);
        loweringExpr = trans.lowerArray(scope, unloweredExpression, unloweredType, requiredType,
                deferredResolve);
    } else {
        RoleTypeBinding roleType = (RoleTypeBinding) unloweredType;
        boolean needMethod = roleType.isRegularInterface()
                || !roleType.isSiblingRole(scope.enclosingSourceType());
        if (needMethod) {
            // (3) translation using _OT$.getBase() method:
            MessageSend callLower = gen.messageSend(unloweredExpression, IOTConstants._OT_GETBASE,
                    new Expression[0]);

            // manual resolving:
            if (!deferredResolve) {
                callLower.constant = Constant.NotAConstant;
                callLower.actualReceiverType = unloweredType;
                if (unloweredExpression.constant == null)
                    unloweredExpression.resolveType(scope);
                callLower.resolvedType = roleType.baseclass();

                callLower.binding = StandardElementGenerator.getGetBaseMethod(scope, roleType.roleModel,
                        roleType.baseclass());
            }
            loweringExpr = callLower;
        } else {
            // (2) translation using field _OT$base:
            FieldReference invokeBaseOnRole = new FieldReference(IOTConstants._OT_BASE,
                    (((long) sourceStart) << 32) + sourceEnd);
            ReferenceBinding roleClass = roleType.roleModel.getClassPartBinding();
            TypeReference classRef = gen.typeReference(roleClass);
            if (classRef != null) {
                // field access needs cast to the role-class.
                // FIXME(SH): use synthetic role field accessor instead!
                classRef.constant = Constant.NotAConstant;
                classRef.resolvedType = roleClass;
                CastExpression unloweredExpr;
                unloweredExpr = new CastExpression(unloweredExpression, classRef, CastExpression.NEED_CLASS);
                unloweredExpr.constant = Constant.NotAConstant;
                unloweredExpr.resolvedType = roleClass;
                unloweredExpr.bits |= ASTNode.GenerateCheckcast;
                invokeBaseOnRole.receiver = unloweredExpr;
            } else {
                invokeBaseOnRole.receiver = unloweredExpression;
            }

            invokeBaseOnRole.actualReceiverType = roleClass;
            invokeBaseOnRole.resolvedType = roleClass.baseclass();
            invokeBaseOnRole.binding = scope.findField(roleClass, IOTConstants._OT_BASE, invokeBaseOnRole,
                    true);
            invokeBaseOnRole.constant = Constant.NotAConstant;
            loweringExpr = invokeBaseOnRole;
        }
    }
    if (needNullCheck) {
        // ((local = (expression)) == null) ? (RequiredType)local : lower(local));
        @SuppressWarnings("null") // needNullCheck => localVar != null
        SingleNameReference lhs = gen.singleNameReference(localVar.name);
        Assignment assignment = gen.assignment(lhs, expression);
        loweringExpr = new CheckedLoweringExpression(expression, gen.nullCheck(assignment), gen.nullLiteral(),
                loweringExpr, localVar, teamExpression);
        if (!deferredResolve) {
            lhs.binding = localVar;
            lhs.resolvedType = unloweredType;
            lhs.bits = Binding.LOCAL | ASTNode.FirstAssignmentToLocal;
            assignment.constant = Constant.NotAConstant;
            loweringExpr.constant = Constant.NotAConstant;
            loweringExpr.resolvedType = requiredType;
        }
    }
    return loweringExpr;
}

---