@Override public TemplateTypeMap getTemplateTypeMap() { return referencedType.getTemplateTypeMap(); } }
@Override public TemplateTypeMap getTemplateTypeMap() { return referencedType.getTemplateTypeMap(); } }
public final ImmutableSet<JSType> getTypeParameters() { ImmutableSet.Builder<JSType> params = ImmutableSet.builder(); for (TemplateType type : getTemplateTypeMap().getTemplateKeys()) { params.add(type); } return params.build(); }
/** * Returns the template type argument in this type's map corresponding to the supertype's template * parameter, or the UNKNOWN_TYPE if the supertype template key is not present. * * <p>Note: this only supports arguments that have a singleton list of template keys, and will * throw an exception for arguments with zero or multiple or template keys. */ public JSType getInstantiatedTypeArgument(JSType supertype) { TemplateType templateType = Iterables.getOnlyElement(supertype.getTemplateTypeMap().getTemplateKeys()); return getTemplateTypeMap().getResolvedTemplateType(templateType); } }
public boolean isPartiallyInstantiated() { return getTemplateTypeMap().isPartiallyFull(); }
public boolean isFullyInstantiated() { return getTemplateTypeMap().isFull(); }
/** Infer the template type from the doc info. */ FunctionTypeBuilder inferTemplateTypeName(@Nullable JSDocInfo info, @Nullable JSType ownerType) { // NOTE: these template type names may override a list // of inherited ones from an overridden function. if (info != null && !maybeUseNativeClassTemplateNames(info)) { ImmutableList<TemplateType> templates = buildTemplateTypesFromJSDocInfo(info, !(isConstructor || isInterface)); if (!templates.isEmpty()) { this.templateTypeNames = templates; } } ImmutableList<TemplateType> ownerTypeKeys = ownerType != null ? ownerType.getTemplateTypeMap().getTemplateKeys() : ImmutableList.of(); if (!templateTypeNames.isEmpty() || !ownerTypeKeys.isEmpty()) { // TODO(sdh): The order of these should be switched to avoid class templates shadowing // method templates, but this currently loosens type checking of arrays more than we'd like. // See http://github.com/google/closure-compiler/issues/2973 registerTemplates( Iterables.concat(templateTypeNames, ownerTypeKeys), contents.getSourceNode()); } return this; }
/** * Coerces this type to an Object type, then gets the type of the property whose name is given. * * <p>Unlike {@link ObjectType#getPropertyType}, returns null if the property is not found. * * @return The property's type. {@code null} if the current type cannot have properties, or if the * type is not found. */ @Nullable public final JSType findPropertyType(String propertyName) { @Nullable JSType propertyType = findPropertyTypeWithoutConsideringTemplateTypes(propertyName); if (propertyType == null) { return null; } // Do templatized type replacing logic here, and make this method final, to prevent a subclass // from forgetting to replace template types if (getTemplateTypeMap().isEmpty() || !propertyType.hasAnyTemplateTypes()) { return propertyType; } TemplateTypeMap typeMap = getTemplateTypeMap(); TemplateTypeMapReplacer replacer = new TemplateTypeMapReplacer(registry, typeMap); return propertyType.visit(replacer); }
if (ownerType != null) { ImmutableList<TemplateType> ownerTypeKeys = ownerType.getTemplateTypeMap().getTemplateKeys(); if (!ownerTypeKeys.isEmpty()) { ImmutableList.Builder<TemplateType> builder = ImmutableList.builder();
/** * Special handling for simple typing returning polymorphic this type in TypeScript. Prefer * `func(): this` instead of `func<T>(this: T): T` when any params are not templatized. */ private boolean shouldSkipEmittingThisTemplateAndParam(FunctionType ftype) { final JSType typeOfThis = ftype.getTypeOfThis(); if (typeOfThis == null || !typeOfThis.isTemplateType() || !typeOfThis.equals(ftype.getReturnType())) { return false; } Iterator<Node> parameters = ftype.getParameters().iterator(); while (parameters.hasNext()) { final JSType paramType = parameters.next().getJSType(); if (!paramType.isTemplatizedType()) { continue; } final TemplateTypeMap templateTypeMap = paramType.getTemplateTypeMap(); for (TemplateType key : templateTypeMap.getTemplateKeys()) { if (templateTypeMap.getResolvedTemplateType(key).equals(typeOfThis)) { return false; } } } return true; }
private JSType inferObjectPatternKeyType() { JSType patternType = patternTypeSupplier.get(); if (isRest) { return inferObjectRestType(patternType); } if (patternType == null || patternType.isUnknownType()) { return registry.getNativeType(JSTypeNative.UNKNOWN_TYPE); } switch (objectPatternKey.getToken()) { case STRING_KEY: JSType propertyType = patternType.findPropertyType(objectPatternKey.getString()); return propertyType != null ? propertyType : registry.getNativeType(JSTypeNative.UNKNOWN_TYPE); case COMPUTED_PROP: return patternType != null ? patternType .getTemplateTypeMap() .getResolvedTemplateType(registry.getObjectElementKey()) : registry.getNativeType(JSTypeNative.UNKNOWN_TYPE); default: throw new IllegalStateException("Unexpected key " + objectPatternKey); } }
private FlowScope traverseGetElem(Node n, FlowScope scope) { scope = traverseChildren(n, scope); JSType type = getJSType(n.getFirstChild()).restrictByNotNullOrUndefined(); TemplateTypeMap typeMap = type.getTemplateTypeMap(); if (typeMap.hasTemplateType(registry.getObjectElementKey())) { n.setJSType(typeMap.getResolvedTemplateType(registry.getObjectElementKey())); } return dereferencePointer(n.getFirstChild(), scope); }
Node createJSCompMakeIteratorCall(Node iterable, Scope scope) { String function = "makeIterator"; Node makeIteratorName = createQName(scope, "$jscomp." + function); // Since createCall (currently) doesn't handle templated functions, fill in the template types // of makeIteratorName manually. if (isAddingTypes() && !makeIteratorName.getJSType().isUnknownType()) { // if makeIteratorName has the unknown type, we must have not injected the required runtime // libraries - hopefully because this is in a test using NonInjectingCompiler. // e.g get `number` from `Iterable<number>` JSType iterableType = iterable .getJSType() .getInstantiatedTypeArgument(getNativeType(JSTypeNative.ITERABLE_TYPE)); JSType makeIteratorType = makeIteratorName.getJSType(); // e.g. replace // function(Iterable<T>): Iterator<T> // with // function(Iterable<number>): Iterator<number> TemplateTypeMap typeMap = registry.createTemplateTypeMap( makeIteratorType.getTemplateTypeMap().getTemplateKeys(), ImmutableList.of(iterableType)); TemplateTypeMapReplacer replacer = new TemplateTypeMapReplacer(registry, typeMap); makeIteratorName.setJSType(makeIteratorType.visit(replacer)); } return createCall(makeIteratorName, iterable); }
Node createJscompArrayFromIteratorCall(Node iterator, Scope scope) { String function = "arrayFromIterator"; Node makeIteratorName = createQName(scope, "$jscomp." + function); // Since createCall (currently) doesn't handle templated functions, fill in the template types // of makeIteratorName manually. if (isAddingTypes() && !makeIteratorName.getJSType().isUnknownType()) { // if makeIteratorName has the unknown type, we must have not injected the required runtime // libraries - hopefully because this is in a test using NonInjectingCompiler. // e.g get `number` from `Iterator<number>` JSType iterableType = iterator .getJSType() .getInstantiatedTypeArgument(getNativeType(JSTypeNative.ITERATOR_TYPE)); JSType makeIteratorType = makeIteratorName.getJSType(); // e.g. replace // function(Iterator<T>): Array<T> // with // function(Iterator<number>): Array<number> TemplateTypeMap typeMap = registry.createTemplateTypeMap( makeIteratorType.getTemplateTypeMap().getTemplateKeys(), ImmutableList.of(iterableType)); TemplateTypeMapReplacer replacer = new TemplateTypeMapReplacer(registry, typeMap); makeIteratorName.setJSType(makeIteratorType.visit(replacer)); } return createCall(makeIteratorName, iterator); }
.getTemplateTypeMap() .getResolvedTemplateType(typeRegistry.getIterableTemplate());
int numKeys = result.getTemplateTypeMap().numUnfilledTemplateKeys(); if (result.isObjectType() && (templateTypes != null && !templateTypes.isEmpty())
private FlowScope traverseGetElem(Node n, FlowScope scope) { scope = traverseChildren(n, scope); Node indexKey = n.getLastChild(); JSType indexType = getJSType(indexKey); if (indexType.isSymbolValueType()) { // For now, allow symbols definitions/access on any type. In the future only allow them // on the subtypes for which they are defined. // TODO(b/77474174): Type well known symbol accesses. n.setJSType(unknownType); } else { JSType type = getJSType(n.getFirstChild()).restrictByNotNullOrUndefined(); TemplateTypeMap typeMap = type.getTemplateTypeMap(); if (typeMap.hasTemplateType(registry.getObjectElementKey())) { n.setJSType(typeMap.getResolvedTemplateType(registry.getObjectElementKey())); } } return tightenTypeAfterDereference(n.getFirstChild(), scope); }
type = thisType.getTemplateTypeMap().getTemplateTypeKeyByName(name); if (type != null) { Preconditions.checkState(type.isTemplateType(),
/** * Returns the given `Iterable`s element type. * * <p>If the given type is not an `Iterator`, `Iterable`, `AsyncIterator`, or `AsyncIterable`, * returns the unknown type. */ static final JSType getElementType(JSType iterableOrIterator, JSTypeRegistry typeRegistry) { TemplateTypeMap templateTypeMap = iterableOrIterator // Remember that `string` will box to a `Iterable`. .autobox() .getTemplateTypeMap(); if (templateTypeMap.hasTemplateKey(typeRegistry.getIterableTemplate())) { // `Iterable<SomeElementType>` or `Generator<SomeElementType>` return templateTypeMap.getResolvedTemplateType(typeRegistry.getIterableTemplate()); } else if (templateTypeMap.hasTemplateKey(typeRegistry.getIteratorTemplate())) { // `Iterator<SomeElementType>` return templateTypeMap.getResolvedTemplateType(typeRegistry.getIteratorTemplate()); } else if (templateTypeMap.hasTemplateKey(typeRegistry.getAsyncIterableTemplate())) { // `AsyncIterable<SomeElementType>` or `AsyncGenerator<SomeElementType>` return templateTypeMap.getResolvedTemplateType(typeRegistry.getAsyncIterableTemplate()); } else if (templateTypeMap.hasTemplateKey(typeRegistry.getAsyncIteratorTemplate())) { // `AsyncIterator<SomeElementType>` return templateTypeMap.getResolvedTemplateType(typeRegistry.getAsyncIteratorTemplate()); } return typeRegistry.getNativeType(UNKNOWN_TYPE); }
TemplateTypeMap templates = type.getTemplateTypeMap(); if (templates.hasTemplateKey(registry.getIThenableTemplate())) {