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

Example 61 with JSType

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

the class GlobalTypeInfoCollector method getVarTypeFromAnnotation.

private JSType getVarTypeFromAnnotation(Node nameNode, NTIScope currentScope) {
    checkArgument(nameNode.getParent().isVar());
    Node varNode = nameNode.getParent();
    JSType varType = getDeclaredTypeOfNode(varNode.getJSDocInfo(), currentScope);
    if (varNode.hasMoreThanOneChild() && varType != null) {
        warnings.add(JSError.make(varNode, ONE_TYPE_FOR_MANY_VARS));
    }
    String varName = nameNode.getString();
    JSType nameNodeType = getDeclaredTypeOfNode(nameNode.getJSDocInfo(), currentScope);
    if (nameNodeType != null) {
        if (varType != null) {
            warnings.add(JSError.make(nameNode, DUPLICATE_JSDOC, varName));
        }
        return nameNodeType;
    } else {
        return varType;
    }
}

Example 62 with JSType

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

the class GlobalTypeInfo method createUnionType.

@Override
public TypeI createUnionType(List<? extends TypeI> members) {
    checkArgument(!members.isEmpty(), "Cannot create union type with no members");
    JSType result = commonTypes.BOTTOM;
    for (TypeI t : members) {
        result = JSType.join(result, (JSType) t);
    }
    return result;
}

Example 63 with JSType

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

the class GlobalTypeInfo method instantiateGenericType.

@Override
public JSType instantiateGenericType(ObjectTypeI genericType, ImmutableList<? extends TypeI> typeArgs) {
    JSType t = (JSType) genericType;
    int numTypeParams = t.getTypeParameters().size();
    int numTypeArgs = typeArgs.size();
    if (numTypeArgs == numTypeParams) {
        return t.instantiateGenerics(typeArgs);
    }
    ArrayList<JSType> newTypeArgs = new ArrayList<>(numTypeParams);
    for (int i = 0; i < numTypeParams; i++) {
        newTypeArgs.add(i < numTypeArgs ? (JSType) typeArgs.get(i) : this.commonTypes.UNKNOWN);
    }
    return t.instantiateGenerics(newTypeArgs);
}

Example 64 with JSType

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

the class NewTypeInference method createSummary.

private void createSummary(NTIScope fn) {
    Node fnRoot = fn.getRoot();
    checkArgument(!fnRoot.isFromExterns());
    FunctionTypeBuilder builder = new FunctionTypeBuilder(this.commonTypes);
    TypeEnv entryEnv = getEntryTypeEnv();
    TypeEnv exitEnv = getExitTypeEnv();
    DeclaredFunctionType declType = fn.getDeclaredFunctionType();
    int reqArity = declType.getRequiredArity();
    int optArity = declType.getOptionalArity();
    if (declType.isGeneric()) {
        builder.addTypeParameters(declType.getTypeParameters());
    }
    // Every trailing undeclared formal whose inferred type is ?
    // or contains undefined can be marked as optional.
    List<String> formals = fn.getFormals();
    for (int i = reqArity - 1; i >= 0; i--) {
        JSType formalType = declType.getFormalType(i);
        if (formalType != null) {
            break;
        }
        String formalName = formals.get(i);
        formalType = getTypeAfterFwd(formalName, entryEnv, exitEnv);
        if (formalType.isUnknown() || UNDEFINED.isSubtypeOf(formalType)) {
            reqArity--;
        } else {
            break;
        }
    }
    // Collect types of formals in the builder
    int i = 0;
    for (String formalName : formals) {
        JSType formalType = declType.getFormalType(i);
        if (formalType == null) {
            formalType = getTypeAfterFwd(formalName, entryEnv, exitEnv);
        }
        if (i < reqArity) {
            builder.addReqFormal(formalType);
        } else if (i < optArity) {
            builder.addOptFormal(formalType);
        }
        i++;
    }
    if (declType.hasRestFormals()) {
        builder.addRestFormals(declType.getFormalType(i));
    }
    for (String outer : fn.getOuterVars()) {
        println("Free var ", outer, " going in summary");
        builder.addOuterVarPrecondition(outer, envGetType(entryEnv, outer));
    }
    builder.addNominalType(declType.getNominalType());
    builder.addReceiverType(declType.getReceiverType());
    builder.addAbstract(declType.isAbstract());
    addRetTypeAndWarn(fn, exitEnv, declType, builder);
    JSType summary = commonTypes.fromFunctionType(builder.buildFunction());
    println("Function summary for ", fn.getReadableName());
    println("\t", summary);
    summary = changeTypeIfFunctionNamespace(fn, summary);
    summaries.put(fn, summary);
    maybeSetTypeI(fnRoot, summary);
    Node fnNameNode = NodeUtil.getNameNode(fnRoot);
    if (fnNameNode != null) {
        maybeSetTypeI(fnNameNode, summary);
    }
}

Example 65 with JSType

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

the class NewTypeInference method instantiateCalleeMaybeWithTTL.

/**
 * Instantiate the generic function using the appropriate type map.
 *
 * If the generic function uses TTL, we need to map the TTL variables to types.
 * In this method, we find the TTL expressions, call TypeTransformation#eval to evaluate them,
 * and update the type map.
 */
private FunctionType instantiateCalleeMaybeWithTTL(FunctionType calleeType, ImmutableMap<String, JSType> typeMap) {
    Map<String, Node> typeTransformations = calleeType.getTypeTransformations();
    if (typeTransformations.isEmpty()) {
        return calleeType.instantiateGenerics(typeMap);
    }
    ImmutableMap<String, TypeI> mapWithOriginalNames = getTypemapWithOriginalNames(typeMap);
    LinkedHashMap<String, JSType> newTypeMap = new LinkedHashMap<>();
    newTypeMap.putAll(typeMap);
    for (Map.Entry<String, Node> entry : typeTransformations.entrySet()) {
        String ttlVar = entry.getKey();
        Node transform = entry.getValue();
        @SuppressWarnings({ "unchecked", "rawtypes" }) JSType t = (JSType) this.ttlObj.eval(transform, mapWithOriginalNames);
        newTypeMap.put(ttlVar, t);
    }
    return calleeType.instantiateGenerics(ImmutableMap.copyOf(newTypeMap));
}