Examples with JSType com.google.javascript.jscomp.newtypes.JSType used on opensource projects

Example 36 with JSType

use of com.google.javascript.jscomp.newtypes.JSType in project closure-compiler by google.

the class NewTypeInference method analyzeIObjectElmLvalFwd.

private LValueResultFwd analyzeIObjectElmLvalFwd(Node prop, LValueResultFwd recvLvalue, JSType indexType) {
    EnvTypePair pair = analyzeExprFwd(prop, recvLvalue.env, firstNonBottom(indexType, UNKNOWN));
    if (mayWarnAboutBadIObjectIndex(prop, recvLvalue.type, pair.type, indexType)) {
        return new LValueResultFwd(pair.env, UNKNOWN, null, null);
    }
    JSType inferred = getIndexedTypeOrUnknown(recvLvalue.type);
    JSType declared = null;
    if (recvLvalue.declType != null) {
        JSType receiverAdjustedDeclType = recvLvalue.declType.removeType(NULL_OR_UNDEFINED);
        declared = receiverAdjustedDeclType.getIndexedType();
    }
    return new LValueResultFwd(pair.env, inferred, declared, null);
}

Example 37 with JSType

use of com.google.javascript.jscomp.newtypes.JSType in project closure-compiler by google.

the class NewTypeInference method instantiateGoogBind.

private void instantiateGoogBind(Node n, JSType recvType) {
    if (NodeUtil.isGoogBind(n)) {
        JSType t = (JSType) n.getTypeI();
        if (t.isFunctionType()) {
            FunctionType ft = t.getFunType();
            if (ft.isGeneric()) {
                FunctionType instantiatedFunction = ft.instantiateGenericsFromArgumentTypes(null, ImmutableList.of(UNKNOWN, recvType));
                n.setTypeI(this.commonTypes.fromFunctionType(instantiatedFunction));
            }
        }
    }
}

Example 38 with JSType

use of com.google.javascript.jscomp.newtypes.JSType in project closure-compiler by google.

the class NewTypeInference method analyzeAssignNumericOpFwd.

private EnvTypePair analyzeAssignNumericOpFwd(Node expr, TypeEnv inEnv) {
    mayWarnAboutConst(expr);
    Node lhs = expr.getFirstChild();
    Node rhs = expr.getLastChild();
    LValueResultFwd lvalue = analyzeLValueFwd(lhs, inEnv, NUMBER);
    JSType lhsType = lvalue.type;
    boolean lhsWarned = false;
    if (!commonTypes.isNumberScalarOrObj(lhsType)) {
        warnInvalidOperand(lhs, expr.getToken(), NUMBER, lhsType);
        lhsWarned = true;
    }
    EnvTypePair pair = analyzeExprFwd(rhs, lvalue.env, NUMBER);
    if (!commonTypes.isNumberScalarOrObj(pair.type)) {
        warnInvalidOperand(rhs, expr.getToken(), NUMBER, pair.type);
    }
    if (!lhsWarned) {
        pair.env = updateLvalueTypeInEnv(pair.env, lhs, lvalue.ptr, NUMBER);
    }
    pair.type = NUMBER;
    return pair;
}

Example 39 with JSType

use of com.google.javascript.jscomp.newtypes.JSType in project closure-compiler by google.

the class NewTypeInference method analyzeInFwd.

private EnvTypePair analyzeInFwd(Node expr, TypeEnv inEnv, JSType specializedType) {
    Node lhs = expr.getFirstChild();
    Node rhs = expr.getLastChild();
    JSType reqObjType = pickReqObjType(expr);
    EnvTypePair pair;
    pair = analyzeExprFwd(lhs, inEnv, NUMBER_OR_STRING);
    if (!pair.type.isSubtypeOf(NUMBER_OR_STRING)) {
        warnInvalidOperand(lhs, Token.IN, NUMBER_OR_STRING, pair.type);
    }
    pair = analyzeExprFwd(rhs, pair.env, reqObjType);
    if (!pair.type.isSubtypeOf(TOP_OBJECT)) {
        warnInvalidOperand(rhs, Token.IN, "Object", pair.type);
        pair.type = BOOLEAN;
        return pair;
    }
    if (pair.type.isStruct()) {
        warnings.add(JSError.make(rhs, IN_USED_WITH_STRUCT));
        pair.type = BOOLEAN;
        return pair;
    }
    JSType resultType = BOOLEAN;
    if (lhs.isString()) {
        QualifiedName pname = new QualifiedName(lhs.getString());
        if (specializedType.isTrueOrTruthy()) {
            pair = analyzeExprFwd(rhs, inEnv, reqObjType, reqObjType.withPropertyRequired(pname.getLeftmostName()));
            resultType = TRUE_TYPE;
        } else if (specializedType.isFalseOrFalsy()) {
            pair = analyzeExprFwd(rhs, inEnv, reqObjType);
            // If the rhs is a loose object, we won't warn about missing
            // properties, despite removing the type here.
            // The only way to have that warning would be to keep track of props
            // that a loose object *cannot* have; but the implementation cost
            // is probably not worth it.
            pair = analyzeExprFwd(rhs, inEnv, reqObjType, pair.type.withoutProperty(pname));
            resultType = FALSE_TYPE;
        }
    }
    pair.type = resultType;
    return pair;
}

Example 40 with JSType

use of com.google.javascript.jscomp.newtypes.JSType in project closure-compiler by google.

the class NewTypeInference method changeTypeIfFunctionNamespace.

private JSType changeTypeIfFunctionNamespace(NTIScope fnScope, JSType fnType) {
    NTIScope enclosingScope = fnScope.getParent();
    Node fnNameNode = NodeUtil.getNameNode(fnScope.getRoot());
    JSType namespaceType = null;
    if (fnNameNode == null) {
        return fnType;
    }
    if (fnNameNode.isName()) {
        String fnName = fnNameNode.getString();
        if (enclosingScope.isFunctionNamespace(fnName)) {
            namespaceType = enclosingScope.getDeclaredTypeOf(fnName);
        }
    } else if (fnNameNode.isQualifiedName()) {
        QualifiedName qname = QualifiedName.fromNode(fnNameNode);
        JSType rootNs = enclosingScope.getDeclaredTypeOf(qname.getLeftmostName());
        if (rootNs != null && rootNs.isSubtypeOf(TOP_OBJECT)) {
            namespaceType = rootNs.getProp(qname.getAllButLeftmost());
        }
    }
    if (namespaceType != null && namespaceType.isNamespace()) {
        // with the new function summary.
        return namespaceType.withFunction(fnType.getFunTypeIfSingletonObj(), commonTypes.getFunctionType());
    }
    return fnType;
}