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

Introduction

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

Prototype

int GenerateCheckcast

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

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;//ww w . ja  v  a2s. com
    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;
}

---