TypeValidator(AbstractCompiler compiler) { this.compiler = compiler; this.typeRegistry = compiler.getTypeRegistry(); this.allBitwisableValueTypes = typeRegistry.createUnionType(STRING_TYPE, NUMBER_TYPE, BOOLEAN_TYPE, NULL_TYPE, VOID_TYPE); this.nullOrUndefined = typeRegistry.getNativeType(JSTypeNative.NULL_VOID); this.promiseOfUnknownType = typeRegistry.createTemplatizedType( typeRegistry.getNativeObjectType(JSTypeNative.PROMISE_TYPE), typeRegistry.getNativeType(JSTypeNative.UNKNOWN_TYPE)); this.iterableOrAsyncIterable = typeRegistry.createUnionType( typeRegistry.getNativeObjectType(JSTypeNative.ITERATOR_TYPE), typeRegistry.getNativeObjectType(JSTypeNative.ASYNC_ITERATOR_TYPE)); }
@Override public JSTypeRegistry getTypeRegistry() { if (typeRegistry == null) { typeRegistry = new JSTypeRegistry(oldErrorReporter, forwardDeclaredTypes); } return typeRegistry; }
private JSType getSentinelObjectLiteral() { if (sentinelObjectLiteral == null) { sentinelObjectLiteral = createAnonymousObjectType(null); } return sentinelObjectLiteral; }
/** * Returns an `Iterable` type templated on {@code elementType}. * * <p>Example: `number' => `Iterable<number>`. */ static final JSType createIterableTypeOf(JSType elementType, JSTypeRegistry typeRegistry) { return typeRegistry.createTemplatizedType( typeRegistry.getNativeObjectType(JSTypeNative.ITERABLE_TYPE), elementType); }
/** * Creates a type representing nullable values of the given type. * @return the union of the type and the Null type */ public JSType createNullableType(JSType type) { return createUnionType(type, getNativeType(JSTypeNative.NULL_TYPE)); }
registerNativeType(JSTypeNative.BOOLEAN_TYPE, booleanType); registerNativeType(JSTypeNative.NULL_TYPE, nullType); registerNativeType(JSTypeNative.NUMBER_TYPE, numberType); registerNativeType(JSTypeNative.STRING_TYPE, stringType); registerNativeType(JSTypeNative.SYMBOL_TYPE, symbolType); registerNativeType(JSTypeNative.UNKNOWN_TYPE, unknownType); UnknownType checkedUnknownType = new UnknownType(this, true); registerNativeType(JSTypeNative.CHECKED_UNKNOWN_TYPE, checkedUnknownType); registerNativeType(JSTypeNative.VOID_TYPE, voidType); registerNativeType(JSTypeNative.ALL_TYPE, allType); registerNativeType(JSTypeNative.TOP_LEVEL_PROTOTYPE, topLevelPrototype); nativeInterface("IObject", iObjectIndexTemplateKey, iObjectElementTemplateKey); registerNativeType(JSTypeNative.I_OBJECT_FUNCTION_TYPE, iObjectFunctionType); registerNativeType(JSTypeNative.I_OBJECT_TYPE, iObjectFunctionType.getInstanceType()); nativeConstructorBuilder("Object") .withParamsNode(createOptionalParameters(allType)) .withReturnsOwnInstanceType() .withTemplateKeys(iObjectIndexTemplateKey, iObjectElementTemplateKey) .build();
switch (n.getType()) { case Token.LC: // Record type. return createRecordTypeFromNodes( n.getFirstChild(), sourceName, scope); return createFromTypeNodesInternal( n.getFirstChild(), sourceName, scope) .restrictByNotNullOrUndefined(); Node firstChild = n.getFirstChild(); if (firstChild == null) { return getNativeType(UNKNOWN_TYPE); return createNullableType( createFromTypeNodesInternal( firstChild, sourceName, scope)); return createOptionalType( createFromTypeNodesInternal( n.getFirstChild(), sourceName, scope)); return createOptionalType( createFromTypeNodesInternal( n.getFirstChild(), sourceName, scope)); return getNativeType(ALL_TYPE); child = child.getNext()) { builder.addAlternate(
registerNativeType(JSTypeNative.BOOLEAN_TYPE, BOOLEAN_TYPE); registerNativeType(JSTypeNative.NULL_TYPE, NULL_TYPE); registerNativeType(JSTypeNative.NUMBER_TYPE, NUMBER_TYPE); registerNativeType(JSTypeNative.STRING_TYPE, STRING_TYPE); registerNativeType(JSTypeNative.UNKNOWN_TYPE, UNKNOWN_TYPE); UnknownType checkedUnknownType = new UnknownType(this, true); registerNativeType( JSTypeNative.CHECKED_UNKNOWN_TYPE, checkedUnknownType); registerNativeType(JSTypeNative.VOID_TYPE, VOID_TYPE); registerNativeType(JSTypeNative.ALL_TYPE, ALL_TYPE); registerNativeType(JSTypeNative.TOP_LEVEL_PROTOTYPE, TOP_LEVEL_PROTOTYPE); createArrowType(createOptionalParameters(ALL_TYPE), null), null, createTemplateTypeMap(ImmutableList.of( iObjectIndexTemplateKey, iObjectElementTemplateKey), null), true, true); registerNativeType(JSTypeNative.OBJECT_FUNCTION_TYPE, OBJECT_FUNCTION_TYPE); registerNativeType(JSTypeNative.OBJECT_TYPE, OBJECT_TYPE);
/** * Returns the JSType as specified by the typeName. * Returns null if shouldCreate is false. */ static JSType createType(boolean shouldCreate, JSTypeRegistry registry, JSTypeNative typeName) { if (!shouldCreate) { return null; } return registry.getNativeType(typeName); }
DelegateRelationship delegateRelationship) { ObjectType delegatorObject = ObjectType.cast( typeRegistry.getType(delegateRelationship.delegator)); ObjectType delegateBaseObject = ObjectType.cast( typeRegistry.getType(delegateRelationship.delegateBase)); ObjectType delegateSuperObject = ObjectType.cast( typeRegistry.getType(codingConvention.getDelegateSuperclassName())); if (delegatorObject != null && delegateBaseObject != null && new FunctionParamBuilder(typeRegistry); functionParamBuilder.addRequiredParams( getNativeType(U2U_CONSTRUCTOR_TYPE)); FunctionType findDelegate = typeRegistry.createFunctionType( typeRegistry.createDefaultObjectUnion(delegateBaseObject), functionParamBuilder.build()); FunctionType delegateProxy = typeRegistry.createConstructorType( delegateBaseObject.getReferenceName() + DELEGATE_PROXY_SUFFIX, null, null, null, null);
/** * Creates a templatized instance of the specified type. Only ObjectTypes * can currently be templatized; extend the logic in this function when * more types can be templatized. * @param baseType the type to be templatized. * @param templatizedTypes a map from TemplateType to corresponding JSType * value. Any unfilled TemplateTypes on the baseType that are *not* * contained in this map will have UNKNOWN_TYPE used as their value. */ public TemplatizedType createTemplatizedType( ObjectType baseType, Map<TemplateType, JSType> templatizedTypes) { ImmutableList.Builder<JSType> builder = ImmutableList.builder(); TemplateTypeMap baseTemplateTypeMap = baseType.getTemplateTypeMap(); for (TemplateType key : baseTemplateTypeMap.getUnfilledTemplateKeys()) { JSType templatizedType = templatizedTypes.containsKey(key) ? templatizedTypes.get(key) : getNativeType(UNKNOWN_TYPE); builder.add(templatizedType); } return createTemplatizedType(baseType, builder.build()); }
private JSType inferArrayPatternTargetType() { JSType patternType = patternTypeSupplier.get(); // e.g. get `number` from `!Iterable<number>` JSType templateTypeOfIterable = patternType.getInstantiatedTypeArgument(registry.getNativeType(JSTypeNative.ITERABLE_TYPE)); if (isRest) { // return `!Array<number>` return registry.createTemplatizedType( registry.getNativeObjectType(JSTypeNative.ARRAY_TYPE), templateTypeOfIterable); } else { return templateTypeOfIterable; } } }
private JSType inferObjectRestType(JSType patternType) { ObjectType objectType = registry.getNativeObjectType(JSTypeNative.OBJECT_TYPE); if (patternType == null) { return objectType; if (templates.hasTemplateKey(registry.getObjectIndexKey())) { return registry.createTemplatizedType( objectType, templates.getResolvedTemplateType(registry.getObjectIndexKey()), templates.getResolvedTemplateType(registry.getObjectElementKey()));
ErrorFunctionType(JSTypeRegistry registry, String name) { super( registry, name, null, registry.createArrowType( registry.createOptionalParameters( registry.getNativeType(ALL_TYPE), registry.getNativeType(ALL_TYPE), registry.getNativeType(ALL_TYPE)), null), null, null, true, true); // NOTE(nicksantos): Errors have the weird behavior in that they can // be called as functions, and they will return instances of themselves. // Error('x') instanceof Error => true // // In user-defined types, we would deal with this case by creating // a NamedType with the name "Error" and then resolve it later. // // For native types, we don't really want the native types to // depend on type-resolution. So we just set the return type manually // at the end of construction. // // There's similar logic in JSTypeRegistry for Array and RegExp. getInternalArrowType().returnType = getInstanceType(); } }
public JSType instantiateGenericType( ObjectType genericType, ImmutableList<JSType> typeArgs) { return createTemplatizedType(genericType, typeArgs); }
FunctionType fnType = typeRegistry.createConstructorType( fnName, contents.getSourceNode(), parametersNode, returnType, classTemplateTypeNames); JSType existingType = typeRegistry.getType(fnName); isInstanceObject ? existingType.toObjectType().getConstructor() : typeRegistry.getNativeFunctionType(FUNCTION_FUNCTION_TYPE); typeRegistry.declareType(fnName, fnType.getInstanceType());
SingleGeneratorFunctionTranspiler(Node genFunc, int genaratorNestingLevel) { this.generatorNestingLevel = genaratorNestingLevel; this.originalGeneratorBody = genFunc.getLastChild(); ObjectType contextType = null; if (shouldAddTypes) { // Find the yield type of the generator. // e.g. given @return {!Generator<number>}, we want this.yieldType to be number. yieldType = unknownType; if (genFunc.getJSType() != null && genFunc.getJSType().isFunctionType()) { FunctionType fnType = genFunc.getJSType().toMaybeFunctionType(); this.originalGenReturnType = fnType.getReturnType(); yieldType = JsIterables.getElementType(originalGenReturnType, registry); } JSType globalContextType = registry.getGlobalType("$jscomp.generator.Context"); if (globalContextType == null) { // We don't have the es6/generator polyfill, which can happen in tests using a // NonInjectingCompiler or if someone sets --inject_libraries=false. Don't crash, just // back off on giving some type information. contextType = registry.getNativeObjectType(JSTypeNative.OBJECT_TYPE); } else { contextType = registry.createTemplatizedType(globalContextType.toMaybeObjectType(), yieldType); } } this.context = new TranspilationContext(contextType); }
registry.createTemplatizedType(registry.getNativeObjectType(ARRAY_TYPE), inferredType); registry.createUnionType( inferredType.restrictByNotUndefined(), getJSType(defaultValue));
type = unknownType; if (!type.isSubtype(typeRegistry.getNativeType(OBJECT_TYPE))) { report(JSError.make( objectLit, LENDS_ON_NON_OBJECT, lendsName, type.toString())); type = typeRegistry.createAnonymousObjectType(info);
public Es6RewriteClass(AbstractCompiler compiler) { this.compiler = compiler; this.registry = compiler.getTypeRegistry(); this.astFactory = compiler.createAstFactory(); // Finds the type for `ObjectPropertyDescriptor`. Fallback to the unknown type if it's not // present, which may happen if typechecking hasn't run or this is a unit test w/o externs. JSType actualObjectPropertyDescriptorType = registry.getGlobalType("ObjectPropertyDescriptor"); this.objectPropertyDescriptorType = actualObjectPropertyDescriptorType != null ? actualObjectPropertyDescriptorType : registry.getNativeType(JSTypeNative.UNKNOWN_TYPE); }