Examples with AssignmentExpression org.eclipse.n4js.n4JS.AssignmentExpression used on opensource projects

Example 1 with AssignmentExpression

use of org.eclipse.n4js.n4JS.AssignmentExpression in project n4js by eclipse.

the class InternalTypeSystem method applyRuleExpectedTypeInAssignmentExpression.

protected Result<TypeRef> applyRuleExpectedTypeInAssignmentExpression(final RuleEnvironment G, final RuleApplicationTrace _trace_, final AssignmentExpression expr, final Expression operand) throws RuleFailedException {
    // output parameter
    TypeRef T = null;
    /* { ! jsVariantHelper.isTypeAware(expr) if (operand===expr.lhs) { T = G.bottomTypeRef } else { T = G.topTypeRef } } or { DestructureUtils.isTopOfDestructuringAssignment(expr) if (operand===expr.lhs) { T = G.bottomTypeRef } else { T = G.topTypeRef } } or { expr.op===AssignmentOperator.ASSIGN; if (operand===expr.lhs) { T = G.bottomTypeRef } else { G |- expr.lhs : T } } or { expr.op===AssignmentOperator.ADD_ASSIGN if (operand===expr.lhs) { T = TypeUtils.createNonSimplifiedIntersectionType(G.numberTypeRef, G.stringTypeRef); } else { G |- expr.lhs : var ParameterizedTypeRef lhsTypeRef if (lhsTypeRef.declaredType === G.stringType) { T = G.anyTypeRef } else if(G.isNumeric(lhsTypeRef.declaredType)) { T = G.numberTypeRef } else { T = G.anyTypeRef } } } or { T = G.numberTypeRef } */
    {
        RuleFailedException previousFailure = null;
        try {
            boolean _isTypeAware = this.jsVariantHelper.isTypeAware(expr);
            boolean _not = (!_isTypeAware);
            /* ! jsVariantHelper.isTypeAware(expr) */
            if (!_not) {
                sneakyThrowRuleFailedException("! jsVariantHelper.isTypeAware(expr)");
            }
            Expression _lhs = expr.getLhs();
            boolean _tripleEquals = (operand == _lhs);
            if (_tripleEquals) {
                T = RuleEnvironmentExtensions.bottomTypeRef(G);
            } else {
                T = RuleEnvironmentExtensions.topTypeRef(G);
            }
        } catch (Exception e) {
            previousFailure = extractRuleFailedException(e);
            /* { DestructureUtils.isTopOfDestructuringAssignment(expr) if (operand===expr.lhs) { T = G.bottomTypeRef } else { T = G.topTypeRef } } or { expr.op===AssignmentOperator.ASSIGN; if (operand===expr.lhs) { T = G.bottomTypeRef } else { G |- expr.lhs : T } } or { expr.op===AssignmentOperator.ADD_ASSIGN if (operand===expr.lhs) { T = TypeUtils.createNonSimplifiedIntersectionType(G.numberTypeRef, G.stringTypeRef); } else { G |- expr.lhs : var ParameterizedTypeRef lhsTypeRef if (lhsTypeRef.declaredType === G.stringType) { T = G.anyTypeRef } else if(G.isNumeric(lhsTypeRef.declaredType)) { T = G.numberTypeRef } else { T = G.anyTypeRef } } } or { T = G.numberTypeRef } */
            {
                try {
                    boolean _isTopOfDestructuringAssignment = DestructureUtils.isTopOfDestructuringAssignment(expr);
                    /* DestructureUtils.isTopOfDestructuringAssignment(expr) */
                    if (!_isTopOfDestructuringAssignment) {
                        sneakyThrowRuleFailedException("DestructureUtils.isTopOfDestructuringAssignment(expr)");
                    }
                    Expression _lhs_1 = expr.getLhs();
                    boolean _tripleEquals_1 = (operand == _lhs_1);
                    if (_tripleEquals_1) {
                        T = RuleEnvironmentExtensions.bottomTypeRef(G);
                    } else {
                        T = RuleEnvironmentExtensions.topTypeRef(G);
                    }
                } catch (Exception e_1) {
                    previousFailure = extractRuleFailedException(e_1);
                    /* { expr.op===AssignmentOperator.ASSIGN; if (operand===expr.lhs) { T = G.bottomTypeRef } else { G |- expr.lhs : T } } or { expr.op===AssignmentOperator.ADD_ASSIGN if (operand===expr.lhs) { T = TypeUtils.createNonSimplifiedIntersectionType(G.numberTypeRef, G.stringTypeRef); } else { G |- expr.lhs : var ParameterizedTypeRef lhsTypeRef if (lhsTypeRef.declaredType === G.stringType) { T = G.anyTypeRef } else if(G.isNumeric(lhsTypeRef.declaredType)) { T = G.numberTypeRef } else { T = G.anyTypeRef } } } or { T = G.numberTypeRef } */
                    {
                        try {
                            AssignmentOperator _op = expr.getOp();
                            boolean _tripleEquals_2 = (_op == AssignmentOperator.ASSIGN);
                            /* expr.op===AssignmentOperator.ASSIGN */
                            if (!_tripleEquals_2) {
                                sneakyThrowRuleFailedException("expr.op===AssignmentOperator.ASSIGN");
                            }
                            Expression _lhs_2 = expr.getLhs();
                            boolean _tripleEquals_3 = (operand == _lhs_2);
                            if (_tripleEquals_3) {
                                T = RuleEnvironmentExtensions.bottomTypeRef(G);
                            } else {
                                /* G |- expr.lhs : T */
                                Expression _lhs_3 = expr.getLhs();
                                Result<TypeRef> result = typeInternal(G, _trace_, _lhs_3);
                                checkAssignableTo(result.getFirst(), TypeRef.class);
                                T = (TypeRef) result.getFirst();
                            }
                        } catch (Exception e_2) {
                            previousFailure = extractRuleFailedException(e_2);
                            /* { expr.op===AssignmentOperator.ADD_ASSIGN if (operand===expr.lhs) { T = TypeUtils.createNonSimplifiedIntersectionType(G.numberTypeRef, G.stringTypeRef); } else { G |- expr.lhs : var ParameterizedTypeRef lhsTypeRef if (lhsTypeRef.declaredType === G.stringType) { T = G.anyTypeRef } else if(G.isNumeric(lhsTypeRef.declaredType)) { T = G.numberTypeRef } else { T = G.anyTypeRef } } } or { T = G.numberTypeRef } */
                            {
                                try {
                                    AssignmentOperator _op_1 = expr.getOp();
                                    boolean _tripleEquals_4 = (_op_1 == AssignmentOperator.ADD_ASSIGN);
                                    /* expr.op===AssignmentOperator.ADD_ASSIGN */
                                    if (!_tripleEquals_4) {
                                        sneakyThrowRuleFailedException("expr.op===AssignmentOperator.ADD_ASSIGN");
                                    }
                                    Expression _lhs_4 = expr.getLhs();
                                    boolean _tripleEquals_5 = (operand == _lhs_4);
                                    if (_tripleEquals_5) {
                                        T = TypeUtils.createNonSimplifiedIntersectionType(RuleEnvironmentExtensions.numberTypeRef(G), RuleEnvironmentExtensions.stringTypeRef(G));
                                    } else {
                                        /* G |- expr.lhs : var ParameterizedTypeRef lhsTypeRef */
                                        Expression _lhs_5 = expr.getLhs();
                                        ParameterizedTypeRef lhsTypeRef = null;
                                        Result<TypeRef> result_1 = typeInternal(G, _trace_, _lhs_5);
                                        checkAssignableTo(result_1.getFirst(), ParameterizedTypeRef.class);
                                        lhsTypeRef = (ParameterizedTypeRef) result_1.getFirst();
                                        Type _declaredType = lhsTypeRef.getDeclaredType();
                                        PrimitiveType _stringType = RuleEnvironmentExtensions.stringType(G);
                                        boolean _tripleEquals_6 = (_declaredType == _stringType);
                                        if (_tripleEquals_6) {
                                            T = RuleEnvironmentExtensions.anyTypeRef(G);
                                        } else {
                                            boolean _isNumeric = RuleEnvironmentExtensions.isNumeric(G, lhsTypeRef.getDeclaredType());
                                            if (_isNumeric) {
                                                T = RuleEnvironmentExtensions.numberTypeRef(G);
                                            } else {
                                                T = RuleEnvironmentExtensions.anyTypeRef(G);
                                            }
                                        }
                                    }
                                } catch (Exception e_3) {
                                    previousFailure = extractRuleFailedException(e_3);
                                    T = RuleEnvironmentExtensions.numberTypeRef(G);
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    return new Result<TypeRef>(T);
}

Example 2 with AssignmentExpression

use of org.eclipse.n4js.n4JS.AssignmentExpression in project n4js by eclipse.

the class InternalTypeSystem method applyRuleTypeAssignmentExpression.

protected Result<TypeRef> applyRuleTypeAssignmentExpression(final RuleEnvironment G, final RuleApplicationTrace _trace_, final AssignmentExpression expr) throws RuleFailedException {
    // output parameter
    TypeRef T = null;
    /* { expr.op===AssignmentOperator.ASSIGN; G |- expr.rhs: T } or { expr.op===AssignmentOperator.ADD_ASSIGN G |- expr.lhs: var ParameterizedTypeRef l G |- expr.rhs: var ParameterizedTypeRef r val lnum = l.declaredType == G.booleanType || G.isNumeric(l.declaredType); val rnum = r.declaredType == G.booleanType || G.isNumeric(r.declaredType); val undef = l.declaredType == G.undefinedType || l.declaredType == G.nullType || r.declaredType == G.undefinedType || r.declaredType == G.nullType; !(lnum && rnum); !(undef && (lnum || rnum)); T = G.stringTypeRef } or { T = G.numberTypeRef } */
    {
        RuleFailedException previousFailure = null;
        try {
            AssignmentOperator _op = expr.getOp();
            boolean _tripleEquals = (_op == AssignmentOperator.ASSIGN);
            /* expr.op===AssignmentOperator.ASSIGN */
            if (!_tripleEquals) {
                sneakyThrowRuleFailedException("expr.op===AssignmentOperator.ASSIGN");
            }
            /* G |- expr.rhs: T */
            Expression _rhs = expr.getRhs();
            Result<TypeRef> result = typeInternal(G, _trace_, _rhs);
            checkAssignableTo(result.getFirst(), TypeRef.class);
            T = (TypeRef) result.getFirst();
        } catch (Exception e) {
            previousFailure = extractRuleFailedException(e);
            /* { expr.op===AssignmentOperator.ADD_ASSIGN G |- expr.lhs: var ParameterizedTypeRef l G |- expr.rhs: var ParameterizedTypeRef r val lnum = l.declaredType == G.booleanType || G.isNumeric(l.declaredType); val rnum = r.declaredType == G.booleanType || G.isNumeric(r.declaredType); val undef = l.declaredType == G.undefinedType || l.declaredType == G.nullType || r.declaredType == G.undefinedType || r.declaredType == G.nullType; !(lnum && rnum); !(undef && (lnum || rnum)); T = G.stringTypeRef } or { T = G.numberTypeRef } */
            {
                try {
                    AssignmentOperator _op_1 = expr.getOp();
                    boolean _tripleEquals_1 = (_op_1 == AssignmentOperator.ADD_ASSIGN);
                    /* expr.op===AssignmentOperator.ADD_ASSIGN */
                    if (!_tripleEquals_1) {
                        sneakyThrowRuleFailedException("expr.op===AssignmentOperator.ADD_ASSIGN");
                    }
                    /* G |- expr.lhs: var ParameterizedTypeRef l */
                    Expression _lhs = expr.getLhs();
                    ParameterizedTypeRef l = null;
                    Result<TypeRef> result_1 = typeInternal(G, _trace_, _lhs);
                    checkAssignableTo(result_1.getFirst(), ParameterizedTypeRef.class);
                    l = (ParameterizedTypeRef) result_1.getFirst();
                    /* G |- expr.rhs: var ParameterizedTypeRef r */
                    Expression _rhs_1 = expr.getRhs();
                    ParameterizedTypeRef r = null;
                    Result<TypeRef> result_2 = typeInternal(G, _trace_, _rhs_1);
                    checkAssignableTo(result_2.getFirst(), ParameterizedTypeRef.class);
                    r = (ParameterizedTypeRef) result_2.getFirst();
                    final boolean lnum = (Objects.equal(l.getDeclaredType(), RuleEnvironmentExtensions.booleanType(G)) || RuleEnvironmentExtensions.isNumeric(G, l.getDeclaredType()));
                    final boolean rnum = (Objects.equal(r.getDeclaredType(), RuleEnvironmentExtensions.booleanType(G)) || RuleEnvironmentExtensions.isNumeric(G, r.getDeclaredType()));
                    final boolean undef = (((Objects.equal(l.getDeclaredType(), RuleEnvironmentExtensions.undefinedType(G)) || Objects.equal(l.getDeclaredType(), RuleEnvironmentExtensions.nullType(G))) || Objects.equal(r.getDeclaredType(), RuleEnvironmentExtensions.undefinedType(G))) || Objects.equal(r.getDeclaredType(), RuleEnvironmentExtensions.nullType(G)));
                    /* !(lnum && rnum) */
                    if (!(!(lnum && rnum))) {
                        sneakyThrowRuleFailedException("!(lnum && rnum)");
                    }
                    /* !(undef && (lnum || rnum)) */
                    if (!(!(undef && (lnum || rnum)))) {
                        sneakyThrowRuleFailedException("!(undef && (lnum || rnum))");
                    }
                    T = RuleEnvironmentExtensions.stringTypeRef(G);
                } catch (Exception e_1) {
                    previousFailure = extractRuleFailedException(e_1);
                    T = RuleEnvironmentExtensions.numberTypeRef(G);
                }
            }
        }
    }
    return new Result<TypeRef>(T);
}

Example 3 with AssignmentExpression

use of org.eclipse.n4js.n4JS.AssignmentExpression in project n4js by eclipse.

the class AssignmentRelationFactory method findInAssignmentExpression.

private void findInAssignmentExpression(Multimap<Symbol, Object> assgns, AssignmentExpression ae) {
    Expression lhs = ae.getLhs();
    Expression rhs = ae.getRhs();
    handleSubexpressions(assgns, lhs, rhs);
}

Example 4 with AssignmentExpression

use of org.eclipse.n4js.n4JS.AssignmentExpression in project n4js by eclipse.

the class AssignmentRelationFactory method handleSubexpressions.

private void handleSubexpressions(Multimap<Symbol, Object> assgns, ControlFlowElement lhs, Expression rhs) {
    rhs = ASTUtils.unwrapParentheses(rhs);
    if (rhs instanceof AssignmentExpression) {
        AssignmentExpression ae = (AssignmentExpression) rhs;
        Expression innerRhs = ae.getRhs();
        // The inner assignment is handled already.
        handleSubexpressions(assgns, lhs, innerRhs);
    } else if (rhs instanceof ConditionalExpression) {
        ConditionalExpression ce = (ConditionalExpression) rhs;
        Expression trueExpr = ce.getTrueExpression();
        Expression falseExpr = ce.getFalseExpression();
        handleSubexpressions(assgns, lhs, trueExpr);
        handleSubexpressions(assgns, lhs, falseExpr);
    } else if (rhs instanceof BinaryLogicalExpression) {
        BinaryLogicalExpression ble = (BinaryLogicalExpression) rhs;
        if (ble.getOp() == BinaryLogicalOperator.OR) {
            handleSubexpressions(assgns, lhs, ble.getLhs());
        }
        handleSubexpressions(assgns, lhs, ble.getRhs());
    } else {
        createRelation(assgns, lhs, rhs);
    }
}

Example 5 with AssignmentExpression

use of org.eclipse.n4js.n4JS.AssignmentExpression in project n4js by eclipse.

the class TaintedValueAnalyser method isUntaintedAssignee.

boolean isUntaintedAssignee(Symbol symbol, ControlFlowElement cfe) {
    if (cfe instanceof AssignmentExpression) {
        AssignmentExpression ae = (AssignmentExpression) cfe;
        Expression lhs = ae.getLhs();
        if (symbol.is(lhs)) {
            return assignedSymbolIsAnnotatedWith(symbol, "Untainted");
        }
    }
    return false;
}