public final boolean isTypeVariable() { return isTemplateType(); }
/** * Creates a type representing nullable values of the given type. * @return the union of the type and the Null type */ public JSType createDefaultObjectUnion(JSType type) { if (type.isTemplateType()) { // Template types represent the substituted type exactly and should // not be wrapped. return type; } else { return createNullableType(type); } }
/** * Creates a type representing nullable values of the given type. * @return the union of the type and the Null type */ public JSType createDefaultObjectUnion(JSType type) { if (type.isTemplateType()) { // Template types represent the substituted type exactly and should // not be wrapped. return type; } else { return createNullableType(type); } }
protected boolean isTemplateType(Node n) { JSType type = n.getJSType().restrictByNotNullOrUndefined(); return type.isTemplateType(); }
private boolean allParametersUnknown(FunctionType ftype) { for (Node param : ftype.getParameters()) { JSType type = param.getJSType(); // Note: template types (e.g. the T in Array<T>) return true for isUnknownType, // so we check that first. if (type.isTemplateType() || !type.isUnknownType()) return false; } return true; }
public final String toNonNullAnnotationString() { return !isUnknownType() && !isTemplateType() && !isRecordType() && isObject() ? "!" + toAnnotationString() : toAnnotationString(); }
final StringBuilder appendAsNonNull(StringBuilder sb, boolean forAnnotations) { if (forAnnotations && isObject() && !isUnknownType() && !isTemplateType() && !isRecordType() && !isFunctionType() && !isUnionType() && !isLiteralObject()) { sb.append("!"); } return appendTo(sb, forAnnotations); }
/** * Emit a this parameter like `func(this: Foo)` in a function parameters. * * <p>TODO: emit for non-templatized this like `function(this: HTMLElement)` */ private void emitThisParameter(FunctionType ftype, Iterator<Node> parameters) { final JSType typeOfThis = ftype.getTypeOfThis(); // Don't emit for a constructor like `function(new: T)`. // A `this` parameter in a constructor is not allowed in TypeScript. if (typeOfThis == null || ftype.isConstructor()) { return; } final JSDocInfo jsDocInfo = ftype.getJSDocInfo(); // Emit for templatized this param like `function(this: T)` or JSDoc `@this` type. if (!typeOfThis.isTemplateType() && (jsDocInfo == null || jsDocInfo.getThisType() == null)) { return; } emitNoSpace("this :"); visitType(typeOfThis); if (parameters.hasNext()) { emit(", "); } }
type = thisType.getTemplateTypeMap().getTemplateTypeKeyByName(jsTypeName); if (type != null) { Preconditions.checkState(type.isTemplateType(), "expected:%s", type); return type;
/** * Returns whether the replacement type is a templatized type which contains the current type. * e.g. current type T is being replaced with Foo<T> */ private boolean isRecursive(TemplateType currentType, JSType replacementType) { TemplatizedType replacementTemplatizedType = replacementType.restrictByNotNullOrUndefined().toMaybeTemplatizedType(); if (replacementTemplatizedType == null) { return false; } Iterable<JSType> replacementTemplateTypes = replacementTemplatizedType.getTemplateTypes(); for (JSType replacementTemplateType : replacementTemplateTypes) { if (replacementTemplateType.isTemplateType() && isSameType(currentType, replacementTemplateType.toMaybeTemplateType())) { return true; } } return false; }
/** * Returns whether the replacement type is a templatized type which contains the current type. * e.g. current type T is being replaced with Foo<T> */ private boolean isRecursive(TemplateType currentType, JSType replacementType) { TemplatizedType replacementTemplatizedType = replacementType.restrictByNotNullOrUndefined().toMaybeTemplatizedType(); if (replacementTemplatizedType == null) { return false; } Iterable<JSType> replacementTemplateTypes = replacementTemplatizedType.getTemplateTypes(); for (JSType replacementTemplateType : replacementTemplateTypes) { if (replacementTemplateType.isTemplateType() && isSameType(currentType, replacementTemplateType.toMaybeTemplateType())) { return true; } } return false; }
/** * 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 void visitFunctionDeclaration(FunctionType ftype, List<String> skipTemplateParams) { visitFunctionParameters(ftype, true, skipTemplateParams); JSType type = ftype.getReturnType(); final JSType typeOfThis = ftype.getTypeOfThis(); if (type == null) return; emit(":"); // Closure conflates 'undefined' and 'void', and in general visitType always emits `undefined` // for that type. // In idiomatic TypeScript, `void` is used for function return types, and the "void", // "undefined" types are not the same. if (type.isVoidType()) { emit("void"); } else if (typeOfThis != null && typeOfThis.isTemplateType() && typeOfThis.equals(type)) { // Special case: prefer polymorphic `this` type to templatized `this` param emit("this"); } else { visitType(type); } }
@Override public boolean apply(JSType type) { ObjectType objectType = ObjectType.cast(type); if (objectType == null) { reportWarning(EXTENDS_NON_OBJECT, formatFnName(), type.toString()); return false; } if (objectType.isEmptyType()) { reportWarning(RESOLVED_TAG_EMPTY, "@extends", formatFnName()); return false; } if (objectType.isUnknownType()) { if (hasMoreTagsToResolve(objectType) || type.isTemplateType()) { return true; } else { reportWarning(RESOLVED_TAG_EMPTY, "@extends", fnName); return false; } } return true; } }
type = thisType.getTemplateTypeMap().getTemplateTypeKeyByName(jsTypeName); if (type != null) { Preconditions.checkState(type.isTemplateType(), "expected:%s", type); return type;
if (isTemplateType() && that.isTemplateType()) {
type = thisType.getTemplateTypeMap().getTemplateTypeKeyByName(name); if (type != null) { Preconditions.checkState(type.isTemplateType(), "Expected a template type, but found: %s", type); return type;
if (isTemplateType() && that.isTemplateType()) {
Map<TemplateType, JSType> resolvedTypes, Set<JSType> seenTypes) { if (paramType.isTemplateType()) {
JSType argType, Map<TemplateType, JSType> resolvedTypes, Set<JSType> seenTypes) { if (paramType.isTemplateType()) {