JSType (Closure Compiler Unshaded v20170626 API)

java.lang.Object
- com.google.javascript.jscomp.newtypes.JSType

All Implemented Interfaces:

FunctionTypeI, ObjectTypeI, TypeI, Serializable
```
public abstract class JSType
extends Object
implements TypeI, FunctionTypeI, ObjectTypeI
```
Author:

blickly@google.com (Ben Lickly), dimvar@google.com (Dimitris Vardoulakis)

See Also:

Serialized Form

Field Summary

Fields
Modifier and Type Field and Description

static boolean mockToString

Fields
Modifier and Type	Field and Description
`static boolean`	`mockToString`

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`boolean`	`acceptsArguments(List<? extends TypeI> argumentTypes)` Checks if a call to this function with the given list of arguments is valid.
`JSType`	`autobox()`
`ObjectTypeI`	`autoboxAndGetObject()`
`boolean`	`containsArray()`
`TypeI`	`convertMethodToFunction()` Creates a new function type B based on the original function type A.
`static String`	`createGetterPropName(String originalPropName)`
`static String`	`createSetterPropName(String originalPropName)`
`boolean`	`equals(Object o)`
`JSType`	`findSubtypeWithProp(QualifiedName pname)`
`static JSType`	`fromObjectType(com.google.javascript.jscomp.newtypes.ObjectType obj)`
`static JSType`	`fromTypeVar(JSTypes commonTypes, String typevarName)`
`Collection<ObjectTypeI>`	`getAncestorInterfaces()`
`FunctionTypeI`	`getConstructor()` Gets this object's constructor, or null if it is a native object (constructed natively vs.
`JSType`	`getDeclaredProp(QualifiedName qname)`
`String`	`getDisplayName()`
`JSType`	`getEnumeratedTypeOfEnumElement()`
`TypeI`	`getEnumeratedTypeOfEnumObject()` If this type is an enum object, returns the declared type of the elements.
`protected abstract com.google.common.collect.ImmutableSet<EnumType>`	`getEnums()`
`FunctionType`	`getFunType()`
`FunctionType`	`getFunTypeIfSingletonObj()`
`TypeI`	`getGreatestSubtypeWithProperty(String pname)`
`JSType`	`getIndexedType()`
`JSType`	`getIndexType()`
`ObjectTypeI`	`getInstanceType()` Returns a type representing an instance of `this` constructor, or null if `this` is not a constructor.
`JSType`	`getInstantiatedTypeOfIterable()` Given a type that is a subtype of Iterable, returns what that Iterable is instantiated with.
`JSDocInfo`	`getJSDocInfo()`
`TypeI`	`getLegacyResolvedType()` Only called on instances of NamedType.
`protected abstract int`	`getMask()`
`int`	`getMaxArity()` Returns the maximum number of allowed arguments, or Integer.MAX_VALUE if variadic.
`int`	`getMinArity()` Returns the number of required arguments.
`NominalType`	`getNominalTypeIfSingletonObj()`
`FunctionTypeI`	`getOwnerFunction()` If this type represents the object in a function's prototype property, return that function.
`Node`	`getOwnPropertyDefSite(String propertyName)`
`JSDocInfo`	`getOwnPropertyJSDocInfo(String propertyName)`
`Iterable<String>`	`getOwnPropertyNames()` Returns the names of all the properties directly on this type.
`Iterable<TypeI>`	`getParameterTypes()`
`JSType`	`getProp(QualifiedName qname)`
`Node`	`getPropertyDefSite(String propertyName)`
`JSDocInfo`	`getPropertyJSDocInfo(String propertyName)`
`TypeI`	`getPropertyType(String propName)` Returns the type of property propName on this object, or null if the property doesn't exist.
`JSType`	`getPrototypeObject()` Returns the __proto__ object of this object type, NOT the ".prototype" property.
`ObjectTypeI`	`getPrototypeProperty()`
`ObjectTypeI`	`getRawType()`
`String`	`getReferenceName()` For a constructor function, returns the name of the instances.
`TypeI`	`getReturnType()`
`Node`	`getSource()` Gets the AST Node where this function was defined.
`Collection<FunctionTypeI>`	`getSubTypes()` Returns an iterable of direct types that are subtypes of this type.
`FunctionTypeI`	`getSuperClassConstructor()`
`com.google.common.collect.ImmutableList<? extends TypeI>`	`getTemplateTypes()` For an instantiated generic type, return the types that the type variables are mapped to.
`JSType`	`getTopDefiningInterface(String pname)` Given an interface and a property, finds a top-most super interface that has the property defined (including this interface).
`TypeI`	`getTypeOfThis()` Gets the type of `this` in this function.
`List<String>`	`getTypeParameters()` Returns the names of all type parameters.
`protected abstract String`	`getTypeVar()`
`Iterable<JSType>`	`getUnionMembers()` If this type is a union type, returns a list of its members.
`boolean`	`hasConstantProp(QualifiedName pname)`
`int`	`hashCode()`
`boolean`	`hasInstanceType()` Returns whether `this` type represents a constructor.
`boolean`	`hasNonScalar()`
`boolean`	`hasOwnProperty(String propertyName)`
`boolean`	`hasProp(QualifiedName qname)`
`boolean`	`hasProperties()`
`boolean`	`hasProperty(String propertyName)`
`boolean`	`hasTypeVariable()`
`boolean`	`hasUninstantiatedTypeVariables()` Returns true if this type is a generic object (non function) and some (or all) of its type variables are not instantiated.
`static boolean`	`haveCommonSubtype(JSType lhs, JSType rhs)`
`ObjectTypeI`	`instantiateGenericsWithUnknown()` When this type represents an instance of a generic class/interface Foo, return an instance of Foo with type parameters mapped to the unknown type.
`boolean`	`isAnyFalsyType()`
`boolean`	`isAnyTruthyType()`
`boolean`	`isBoolean()`
`boolean`	`isBooleanValueType()` Whether the type is a scalar boolean.
`boolean`	`isBottom()`
`boolean`	`isBoxableScalar()`
`boolean`	`isConstructor()`
`boolean`	`isDict()`
`boolean`	`isEnumElement()`
`boolean`	`isEnumObject()`
`boolean`	`isEquivalentTo(TypeI type)`
`boolean`	`isFalseOrFalsy()`
`boolean`	`isFunctionType()`
`boolean`	`isFunctionWithProperties()`
`boolean`	`isGenericObjectType()` True if this type represents a generic object (non function) type, instantiated or not.
`boolean`	`isInstanceofObject()` True when the nominal type of this type is Object.
`boolean`	`isInstanceType()` Whether this type is an instance object of some constructor.
`boolean`	`isInterface()`
`boolean`	`isInterfaceDefinition()`
`boolean`	`isInterfaceInstance()`
`boolean`	`isIObject()`
`boolean`	`isLegacyNamedType()` The old type checker uses NamedType to wrap types (e.g., defined by typedefs), and to represent unresolved forward declares.
`boolean`	`isLiteralObject()`
`boolean`	`isLoose()`
`boolean`	`isNamespace()`
`boolean`	`isNonClassyObject()`
`boolean`	`isNonLooseSubtypeOf(JSType other)`
`boolean`	`isNullable()`
`boolean`	`isNullOrUndef()`
`boolean`	`isNullType()`
`boolean`	`isNumber()`
`boolean`	`isNumberValueType()` Whether the type is a scalar number.
`boolean`	`isObjectType()`
`boolean`	`isPropDefinedOnSubtype(QualifiedName pname)`
`boolean`	`isPrototypeObject()`
`boolean`	`isRecordType()` Whether this type represents an anonymous structural type, e.g., { a: number, b: string }.
`boolean`	`isScalar()`
`boolean`	`isSingletonObj()`
`boolean`	`isSomeUnknownType()`
`boolean`	`isString()`
`boolean`	`isStringValueType()` Whether the type is a scalar string.
`boolean`	`isStruct()`
`boolean`	`isStructuralInterface()`
`boolean`	`isStructWithoutProp(QualifiedName pname)`
`boolean`	`isSubtypeOf(TypeI other)`
`boolean`	`isSubtypeWithoutStructuralTyping(TypeI other)`
`boolean`	`isTop()`
`boolean`	`isTrueOrTruthy()`
`boolean`	`isTypeVariable()`
`boolean`	`isUndefined()`
`boolean`	`isUnion()`
`boolean`	`isUnionType()`
`boolean`	`isUnknown()`
`boolean`	`isUnknownObject()` Returns true if this object is an anonymous object type (i.e.
`boolean`	`isUnknownType()`
`boolean`	`isUnresolved()`
`boolean`	`isUnresolvedOrResolvedUnknown()`
`boolean`	`isVoidable()`
`boolean`	`isVoidType()`
`static JSType`	`join(JSType lhs, JSType rhs)`
`boolean`	`mayBeDict()`
`boolean`	`mayBeStruct()`
`boolean`	`mayContainUnknownObject()`
`boolean`	`mayHaveProp(QualifiedName qname)`
`static JSType`	`meet(JSType lhs, JSType rhs)`
`TypeI`	`meetWith(TypeI other)`
`JSType`	`negate()`
`ObjectTypeI`	`normalizeObjectForCheckAccessControls()` Works around the OTI distinction between prototype-object types and other objects.
`static JSType`	`plus(JSType lhs, JSType rhs)`
`JSType`	`removeType(JSType other)`
`TypeI`	`restrictByNotNullOrUndefined()` If this is a union type, returns a union type that does not include the null or undefined type.
`void`	`setSource(Node n)`
`JSType`	`specialize(JSType other)`
`JSType`	`substituteGenerics(Map<String,JSType> concreteTypes)` Creates a new JSType by deeply substituting the free type variables in this type with concrete replacements from the given map.
`JSType`	`substituteGenericsWithUnknown()`
`String`	`toAnnotationString()` Returns a string representation of this type, suitable for printing in type annotations at code generation time.
`JSType`	`toBoolean()`
`FunctionTypeI`	`toMaybeFunctionType()` Downcasts this to a FunctionTypeI, or returns null if this is not a function.
`ObjectTypeI`	`toMaybeObjectType()` If this type is a single object, downcast it to ObjectTypeI.
`String`	`toNonNullAnnotationString()` Returns a string representation of this type, suitable for printing in type annotations at code generation time.
`String`	`toString()`
`void`	`unifyWith(JSType other, List<String> typeParameters, com.google.common.collect.Multimap<String,JSType> typeMultimap)` Unify `this`, which may contain free type variables, with `other`, a concrete subtype, modifying the supplied `typeMultimap` to add any new template variable type bindings.
`static MismatchInfo`	`whyNotSubtypeOf(JSType found, JSType expected)`
`JSType`	`withDeclaredProperty(QualifiedName qname, JSType type, boolean isConstant)`
`JSType`	`withFunction(FunctionType ft, NominalType fnNominal)`
`JSType`	`withLoose()` Turns the class-less object of this type (if any) into a loose object
`JSType`	`withoutProperty(QualifiedName qname)`
`JSType`	`withProperty(QualifiedName qname, JSType type)`
`JSType`	`withPropertyRequired(String pname)`

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

- Field Detail
  - mockToString
```
public static boolean mockToString
```
- Method Detail
  - getMask
```
protected abstract int getMask()
```
  - getTypeVar
```
protected abstract String getTypeVar()
```
  - getEnums
```
protected abstract com.google.common.collect.ImmutableSet<EnumType> getEnums()
```
  - fromObjectType
```
public static JSType fromObjectType(com.google.javascript.jscomp.newtypes.ObjectType obj)
```
  - fromTypeVar
```
public static JSType fromTypeVar(JSTypes commonTypes,
                                 String typevarName)
```
  - isTop
```
public final boolean isTop()
```
    Specified by:
    
    isTop in interface TypeI
  - isBottom
```
public final boolean isBottom()
```
    Specified by:
    
    isBottom in interface TypeI
  - isUndefined
```
public final boolean isUndefined()
```
  - isUnknown
```
public final boolean isUnknown()
```
  - isTrueOrTruthy
```
public final boolean isTrueOrTruthy()
```
  - isFalseOrFalsy
```
public final boolean isFalseOrFalsy()
```
  - isAnyTruthyType
```
public final boolean isAnyTruthyType()
```
  - isAnyFalsyType
```
public final boolean isAnyFalsyType()
```
  - isBoolean
```
public final boolean isBoolean()
```
  - isBooleanValueType
```
public final boolean isBooleanValueType()
```
    Description copied from interface: TypeI
    
    Whether the type is a scalar boolean. In OTI, the isBoolean method returns true for Boolean objects as well.
    
    Specified by:
    
    isBooleanValueType in interface TypeI
  - isString
```
public final boolean isString()
```
  - isStringValueType
```
public final boolean isStringValueType()
```
    Description copied from interface: TypeI
    
    Whether the type is a scalar string. In OTI, the isString method returns true for String objects as well.
    
    Specified by:
    
    isStringValueType in interface TypeI
  - isNumber
```
public final boolean isNumber()
```
  - isNumberValueType
```
public final boolean isNumberValueType()
```
    Description copied from interface: TypeI
    
    Whether the type is a scalar number. In OTI, the isNumber method returns true for Number objects as well.
    
    Specified by:
    
    isNumberValueType in interface TypeI
  - isNullOrUndef
```
public final boolean isNullOrUndef()
```
  - isScalar
```
public final boolean isScalar()
```
  - hasNonScalar
```
public final boolean hasNonScalar()
```
  - isNullable
```
public final boolean isNullable()
```
    Specified by:
    
    isNullable in interface TypeI
  - isTypeVariable
```
public final boolean isTypeVariable()
```
    Specified by:
    
    isTypeVariable in interface TypeI
  - hasTypeVariable
```
public final boolean hasTypeVariable()
```
  - isStruct
```
public final boolean isStruct()
```
  - mayBeStruct
```
public final boolean mayBeStruct()
```
  - isStructWithoutProp
```
public final boolean isStructWithoutProp(QualifiedName pname)
```
  - isLoose
```
public final boolean isLoose()
```
  - isDict
```
public final boolean isDict()
```
  - getIndexType
```
public final JSType getIndexType()
```
  - getIndexedType
```
public final JSType getIndexedType()
```
  - mayBeDict
```
public final boolean mayBeDict()
```
  - isEnumElement
```
public final boolean isEnumElement()
```
    Specified by:
    
    isEnumElement in interface TypeI
  - isEnumObject
```
public final boolean isEnumObject()
```
    Specified by:
    
    isEnumObject in interface TypeI
  - getEnumeratedTypeOfEnumObject
```
public final TypeI getEnumeratedTypeOfEnumObject()
```
    Description copied from interface: ObjectTypeI
    
    If this type is an enum object, returns the declared type of the elements. Otherwise returns null.
    
    Specified by:
    
    getEnumeratedTypeOfEnumObject in interface ObjectTypeI
  - isUnion
```
public final boolean isUnion()
```
  - isFunctionWithProperties
```
public final boolean isFunctionWithProperties()
```
  - isNamespace
```
public final boolean isNamespace()
```
  - getEnumeratedTypeOfEnumElement
```
public final JSType getEnumeratedTypeOfEnumElement()
```
    Specified by:
    
    getEnumeratedTypeOfEnumElement in interface TypeI
  - autobox
```
public final JSType autobox()
```
    Specified by:
    
    autobox in interface TypeI
  - join
```
public static JSType join(JSType lhs,
                          JSType rhs)
```
  - substituteGenerics
```
public final JSType substituteGenerics(Map<String,JSType> concreteTypes)
```
    Creates a new JSType by deeply substituting the *free* type variables in this type with concrete replacements from the given map. This is also what all other substituteGenerics methods in this package do. Do not confuse with the instantiateGenerics methods, which take an *uninstantiated* generic type (a nominal type or a generic function), and substitute the *bound* type variables with the concrete types from the map. For example, when you define a class Foo with T, an uninstantiated Foo object has type: ForAll T.Foo<T>. When you define a generic function f with U, that takes a Foo<U> as an argument and returns a U, f's type is ForAll U.Foo<U> => U. When you call f with some argument, say Foo of string, you instantiate U in f's type. The part of f's type without the ForAll contains U as a free type variable. So you call substituteGenerics in order to convert the Foo<U> to a Foo<string>
  - substituteGenericsWithUnknown
```
public final JSType substituteGenericsWithUnknown()
```
  - getInstantiatedTypeOfIterable
```
public JSType getInstantiatedTypeOfIterable()
```
    Given a type that is a subtype of Iterable, returns what that Iterable is instantiated with. Needed for typechecking for/of.
  - unifyWith
```
public final void unifyWith(JSType other,
                            List<String> typeParameters,
                            com.google.common.collect.Multimap<String,JSType> typeMultimap)
```
    Unify this, which may contain free type variables, with other, a concrete subtype, modifying the supplied typeMultimap to add any new template variable type bindings. This method should only be called outside the newtypes package; classes inside the package should use unifyWithSubtype. Unification algorithm. Say that this is a potentially generic type G and other is a concrete type C. 1. If C is not a union: (A) If C is a subtype of G, then unification succeeds and we don't update the type map. E.g., (T|string) unifies with string and we learn nothing about T. (B) If some member of G unifies with C, unification succeeds and we update the type map. (C) If 2+ members of G unify with C, we use each of them to update the type map. This is simpler than depending on the iteration order of the members of G to decide which one to unify with C. E.g., if Foo extends Bar and implements Baz, (Bar(T)|Baz(T)) unifies with Foo(number) and T is number. (Bar(number, T)|Baz(T, string)) doesn't unify with Foo(number,string), but each member unifies with C, and we get a "not unique instantiation" warning. 2. If C is a union: We throw away C's members that are subtypes of G, and for each remaining member we try to individually unify G with it. A single member of G may unify with 2+ members of C. Let SubC be a type that contains all members of C that are left over: they are not subtypes of G and G doesn't unify with them. If G is of the form (T|...), then T is mapped to SubC. E.g., (T|Foo|Bar(U)) unifies with (number|string|Foo|Bar(Baz)) SubC is (number|string), T is mapped to (number|string), and U is mapped to Baz.
  - specialize
```
public final JSType specialize(JSType other)
```
  - meet
```
public static JSType meet(JSType lhs,
                          JSType rhs)
```
  - haveCommonSubtype
```
public static boolean haveCommonSubtype(JSType lhs,
                                        JSType rhs)
```
  - plus
```
public static JSType plus(JSType lhs,
                          JSType rhs)
```
  - negate
```
public final JSType negate()
```
  - toBoolean
```
public final JSType toBoolean()
```
  - isNonLooseSubtypeOf
```
public final boolean isNonLooseSubtypeOf(JSType other)
```
  - isSubtypeOf
```
public final boolean isSubtypeOf(TypeI other)
```
    Specified by:
    
    isSubtypeOf in interface TypeI
  - whyNotSubtypeOf
```
public static MismatchInfo whyNotSubtypeOf(JSType found,
                                           JSType expected)
```
  - removeType
```
public final JSType removeType(JSType other)
```
  - withFunction
```
public final JSType withFunction(FunctionType ft,
                                 NominalType fnNominal)
```
  - createGetterPropName
```
public static String createGetterPropName(String originalPropName)
```
  - createSetterPropName
```
public static String createSetterPropName(String originalPropName)
```
  - isSingletonObj
```
public final boolean isSingletonObj()
```
  - getFunTypeIfSingletonObj
```
public final FunctionType getFunTypeIfSingletonObj()
```
  - getFunType
```
public final FunctionType getFunType()
```
  - getNominalTypeIfSingletonObj
```
public final NominalType getNominalTypeIfSingletonObj()
```
  - isInterfaceInstance
```
public final boolean isInterfaceInstance()
```
  - isNonClassyObject
```
public final boolean isNonClassyObject()
```
  - isIObject
```
public final boolean isIObject()
```
  - isInterfaceDefinition
```
public final boolean isInterfaceDefinition()
```
  - withLoose
```
public final JSType withLoose()
```
    Turns the class-less object of this type (if any) into a loose object
  - getProp
```
public final JSType getProp(QualifiedName qname)
```
  - getDeclaredProp
```
public final JSType getDeclaredProp(QualifiedName qname)
```
  - mayHaveProp
```
public final boolean mayHaveProp(QualifiedName qname)
```
  - hasProp
```
public final boolean hasProp(QualifiedName qname)
```
  - hasConstantProp
```
public final boolean hasConstantProp(QualifiedName pname)
```
  - containsArray
```
public final boolean containsArray()
```
    Specified by:
    
    containsArray in interface TypeI
  - withoutProperty
```
public final JSType withoutProperty(QualifiedName qname)
```
  - withProperty
```
public final JSType withProperty(QualifiedName qname,
                                 JSType type)
```
  - withDeclaredProperty
```
public final JSType withDeclaredProperty(QualifiedName qname,
                                         JSType type,
                                         boolean isConstant)
```
  - withPropertyRequired
```
public final JSType withPropertyRequired(String pname)
```
  - findSubtypeWithProp
```
public final JSType findSubtypeWithProp(QualifiedName pname)
```
  - isPropDefinedOnSubtype
```
public final boolean isPropDefinedOnSubtype(QualifiedName pname)
```
  - toString
```
public final String toString()
```
    Overrides:
    
    toString in class Object
  - toNonNullAnnotationString
```
public final String toNonNullAnnotationString()
```
    Description copied from interface: TypeI
    
    Returns a string representation of this type, suitable for printing in type annotations at code generation time. In particular, explicit non-null modifiers will be added to implicitly nullable types.
    
    Specified by:
    
    toNonNullAnnotationString in interface TypeI
  - toAnnotationString
```
public final String toAnnotationString()
```
    Description copied from interface: TypeI
    
    Returns a string representation of this type, suitable for printing in type annotations at code generation time. In particular, explicit non-null modifiers will be added to implicitly nullable types (except the outermost type, which is expected to be a reference type).
    
    Specified by:
    
    toAnnotationString in interface TypeI
  - isConstructor
```
public final boolean isConstructor()
```
    Specified by:
    
    isConstructor in interface TypeI
  - isEquivalentTo
```
public final boolean isEquivalentTo(TypeI type)
```
    Specified by:
    
    isEquivalentTo in interface TypeI
  - isFunctionType
```
public final boolean isFunctionType()
```
    Specified by:
    
    isFunctionType in interface TypeI
  - isInterface
```
public final boolean isInterface()
```
    Specified by:
    
    isInterface in interface TypeI
  - isUnknownType
```
public final boolean isUnknownType()
```
    Specified by:
    
    isUnknownType in interface TypeI
  - isSomeUnknownType
```
public final boolean isSomeUnknownType()
```
    Specified by:
    
    isSomeUnknownType in interface TypeI
  - isUnresolved
```
public final boolean isUnresolved()
```
    Specified by:
    
    isUnresolved in interface TypeI
  - isUnresolvedOrResolvedUnknown
```
public final boolean isUnresolvedOrResolvedUnknown()
```
    Specified by:
    
    isUnresolvedOrResolvedUnknown in interface TypeI
  - isUnionType
```
public final boolean isUnionType()
```
    Specified by:
    
    isUnionType in interface TypeI
  - isVoidable
```
public final boolean isVoidable()
```
    Specified by:
    
    isVoidable in interface TypeI
  - isNullType
```
public final boolean isNullType()
```
    Specified by:
    
    isNullType in interface TypeI
  - isVoidType
```
public final boolean isVoidType()
```
    Specified by:
    
    isVoidType in interface TypeI
  - restrictByNotNullOrUndefined
```
public final TypeI restrictByNotNullOrUndefined()
```
    Description copied from interface: TypeI
    
    If this is a union type, returns a union type that does not include the null or undefined type.
    
    Specified by:
    
    restrictByNotNullOrUndefined in interface TypeI
  - toMaybeFunctionType
```
public final FunctionTypeI toMaybeFunctionType()
```
    Description copied from interface: TypeI
    
    Downcasts this to a FunctionTypeI, or returns null if this is not a function.
    
    Specified by:
    
    toMaybeFunctionType in interface TypeI
  - toMaybeObjectType
```
public final ObjectTypeI toMaybeObjectType()
```
    Description copied from interface: TypeI
    
    If this type is a single object, downcast it to ObjectTypeI. If it is a non-object or a union of objects, return null.
    
    Specified by:
    
    toMaybeObjectType in interface TypeI
  - autoboxAndGetObject
```
public final ObjectTypeI autoboxAndGetObject()
```
    Specified by:
    
    autoboxAndGetObject in interface TypeI
  - meetWith
```
public final TypeI meetWith(TypeI other)
```
    Specified by:
    
    meetWith in interface TypeI
  - equals
```
public final boolean equals(Object o)
```
    Overrides:
    
    equals in class Object
  - hashCode
```
public final int hashCode()
```
    Overrides:
    
    hashCode in class Object
  - getDisplayName
```
public final String getDisplayName()
```
    Specified by:
    
    getDisplayName in interface TypeI
  - convertMethodToFunction
```
public final TypeI convertMethodToFunction()
```
    Description copied from interface: FunctionTypeI
    
    Creates a new function type B based on the original function type A. Takes the receiver type (this type) of A and makes it the first argument of B; B has no receiver type. Used by the DevirtualizePrototypeMethods pass.
    
    Specified by:
    
    convertMethodToFunction in interface FunctionTypeI
  - hasInstanceType
```
public final boolean hasInstanceType()
```
    Description copied from interface: FunctionTypeI
    
    Returns whether this type represents a constructor.
    
    Specified by:
    
    hasInstanceType in interface FunctionTypeI
  - getInstanceType
```
public final ObjectTypeI getInstanceType()
```
    Description copied from interface: FunctionTypeI
    
    Returns a type representing an instance of this constructor, or null if this is not a constructor.
    
    Specified by:
    
    getInstanceType in interface FunctionTypeI
  - getReferenceName
```
public final String getReferenceName()
```
    Description copied from interface: FunctionTypeI
    
    For a constructor function, returns the name of the instances. For other functions, returns null.
    
    Specified by:
    
    getReferenceName in interface FunctionTypeI
  - getSource
```
public final Node getSource()
```
    Description copied from interface: FunctionTypeI
    
    Gets the AST Node where this function was defined.
    
    Specified by:
    
    getSource in interface FunctionTypeI
  - getSubTypes
```
public final Collection<FunctionTypeI> getSubTypes()
```
    Description copied from interface: FunctionTypeI
    
    Returns an iterable of direct types that are subtypes of this type. This is only valid for constructors and interfaces, and will not be null. This allows a downward traversal of the subtype graph.
    
    Specified by:
    
    getSubTypes in interface FunctionTypeI
  - getTypeOfThis
```
public final TypeI getTypeOfThis()
```
    Description copied from interface: FunctionTypeI
    
    Gets the type of this in this function.
    
    Specified by:
    
    getTypeOfThis in interface FunctionTypeI
  - acceptsArguments
```
public final boolean acceptsArguments(List<? extends TypeI> argumentTypes)
```
    Description copied from interface: FunctionTypeI
    
    Checks if a call to this function with the given list of arguments is valid.
    
    Specified by:
    
    acceptsArguments in interface FunctionTypeI
  - getMinArity
```
public final int getMinArity()
```
    Description copied from interface: FunctionTypeI
    
    Returns the number of required arguments.
    
    Specified by:
    
    getMinArity in interface FunctionTypeI
  - getMaxArity
```
public final int getMaxArity()
```
    Description copied from interface: FunctionTypeI
    
    Returns the maximum number of allowed arguments, or Integer.MAX_VALUE if variadic.
    
    Specified by:
    
    getMaxArity in interface FunctionTypeI
  - getTypeParameters
```
public final List<String> getTypeParameters()
```
    Description copied from interface: FunctionTypeI
    
    Returns the names of all type parameters.
    
    Specified by:
    
    getTypeParameters in interface FunctionTypeI
  - hasProperties
```
public final boolean hasProperties()
```
    Specified by:
    
    hasProperties in interface FunctionTypeI
  - setSource
```
public final void setSource(Node n)
```
    Specified by:
    
    setSource in interface FunctionTypeI
  - getReturnType
```
public final TypeI getReturnType()
```
    Specified by:
    
    getReturnType in interface FunctionTypeI
  - getConstructor
```
public final FunctionTypeI getConstructor()
```
    Description copied from interface: ObjectTypeI
    
    Gets this object's constructor, or null if it is a native object (constructed natively vs. by instantiation of a function).
    
    Specified by:
    
    getConstructor in interface ObjectTypeI
  - getSuperClassConstructor
```
public final FunctionTypeI getSuperClassConstructor()
```
    Specified by:
    
    getSuperClassConstructor in interface ObjectTypeI
  - getPrototypeObject
```
public final JSType getPrototypeObject()
```
    Description copied from interface: ObjectTypeI
    
    Returns the __proto__ object of this object type, NOT the ".prototype" property.
    
    Specified by:
    
    getPrototypeObject in interface ObjectTypeI
  - getJSDocInfo
```
public final JSDocInfo getJSDocInfo()
```
    Specified by:
    
    getJSDocInfo in interface TypeI
  - getOwnPropertyJSDocInfo
```
public final JSDocInfo getOwnPropertyJSDocInfo(String propertyName)
```
    Specified by:
    
    getOwnPropertyJSDocInfo in interface ObjectTypeI
  - getPropertyJSDocInfo
```
public final JSDocInfo getPropertyJSDocInfo(String propertyName)
```
    Specified by:
    
    getPropertyJSDocInfo in interface ObjectTypeI
  - getOwnPropertyDefSite
```
public final Node getOwnPropertyDefSite(String propertyName)
```
    Specified by:
    
    getOwnPropertyDefSite in interface ObjectTypeI
  - getPropertyDefSite
```
public final Node getPropertyDefSite(String propertyName)
```
    Specified by:
    
    getPropertyDefSite in interface ObjectTypeI
  - getOwnPropertyNames
```
public final Iterable<String> getOwnPropertyNames()
```
    Returns the names of all the properties directly on this type.
    
    Specified by:
    
    getOwnPropertyNames in interface ObjectTypeI
  - isPrototypeObject
```
public final boolean isPrototypeObject()
```
    Specified by:
    
    isPrototypeObject in interface TypeI
  - isUnknownObject
```
public final boolean isUnknownObject()
```
    Description copied from interface: ObjectTypeI
    
    Returns true if this object is an anonymous object type (i.e. the builtin Object type, or an object literal). Everything else has a named reference type and returns false.
    
    Specified by:
    
    isUnknownObject in interface ObjectTypeI
  - isLiteralObject
```
public final boolean isLiteralObject()
```
    Specified by:
    
    isLiteralObject in interface TypeI
  - isInstanceofObject
```
public final boolean isInstanceofObject()
```
    Description copied from interface: TypeI
    
    True when the nominal type of this type is Object. The name is not great, because objects with a different nominal type can flow to places that treat them as Object. But I'm not sure what a better name would be.
    
    Specified by:
    
    isInstanceofObject in interface TypeI
  - mayContainUnknownObject
```
public final boolean mayContainUnknownObject()
```
  - isInstanceType
```
public final boolean isInstanceType()
```
    Description copied from interface: ObjectTypeI
    
    Whether this type is an instance object of some constructor.
    
    Specified by:
    
    isInstanceType in interface ObjectTypeI
  - hasProperty
```
public final boolean hasProperty(String propertyName)
```
    Specified by:
    
    hasProperty in interface ObjectTypeI
  - getUnionMembers
```
public final Iterable<JSType> getUnionMembers()
```
    Description copied from interface: TypeI
    
    If this type is a union type, returns a list of its members. Otherwise returns null.
    
    Specified by:
    
    getUnionMembers in interface TypeI
  - normalizeObjectForCheckAccessControls
```
public final ObjectTypeI normalizeObjectForCheckAccessControls()
```
    Description copied from interface: ObjectTypeI
    
    Works around the OTI distinction between prototype-object types and other objects. This method is a hack and can be deleted, either - when NTI treats objects in .prototype properties specially, or - when OTI is deleted. Currently, if Foo extends Bar, for the Bar instance pointed to by Foo.prototype, this method returns a Foo in OTI and a Bar in NTI.
    
    Specified by:
    
    normalizeObjectForCheckAccessControls in interface ObjectTypeI
  - isBoxableScalar
```
public final boolean isBoxableScalar()
```
    Specified by:
    
    isBoxableScalar in interface TypeI
  - isObjectType
```
public final boolean isObjectType()
```
    Specified by:
    
    isObjectType in interface TypeI
  - isGenericObjectType
```
public final boolean isGenericObjectType()
```
    Description copied from interface: TypeI
    
    True if this type represents a generic object (non function) type, instantiated or not.
    
    Specified by:
    
    isGenericObjectType in interface TypeI
  - getAncestorInterfaces
```
public final Collection<ObjectTypeI> getAncestorInterfaces()
```
    Specified by:
    
    getAncestorInterfaces in interface FunctionTypeI
  - isStructuralInterface
```
public final boolean isStructuralInterface()
```
    Specified by:
    
    isStructuralInterface in interface TypeI
  - hasOwnProperty
```
public final boolean hasOwnProperty(String propertyName)
```
    Specified by:
    
    hasOwnProperty in interface ObjectTypeI
  - getRawType
```
public final ObjectTypeI getRawType()
```
    Specified by:
    
    getRawType in interface ObjectTypeI
  - instantiateGenericsWithUnknown
```
public final ObjectTypeI instantiateGenericsWithUnknown()
```
    Description copied from interface: ObjectTypeI
    
    When this type represents an instance of a generic class/interface Foo, return an instance of Foo with type parameters mapped to the unknown type.
    
    Specified by:
    
    instantiateGenericsWithUnknown in interface ObjectTypeI
  - isLegacyNamedType
```
public final boolean isLegacyNamedType()
```
    Description copied from interface: ObjectTypeI
    
    The old type checker uses NamedType to wrap types (e.g., defined by typedefs), and to represent unresolved forward declares. NTI does not do that; unresolved types just become unknown. This method always returns false for NTI types.
    
    Specified by:
    
    isLegacyNamedType in interface ObjectTypeI
  - getLegacyResolvedType
```
public final TypeI getLegacyResolvedType()
```
    Description copied from interface: ObjectTypeI
    
    Only called on instances of NamedType. See also isLegacyNamedType.
    
    Specified by:
    
    getLegacyResolvedType in interface ObjectTypeI
  - getGreatestSubtypeWithProperty
```
public final TypeI getGreatestSubtypeWithProperty(String pname)
```
    Specified by:
    
    getGreatestSubtypeWithProperty in interface TypeI
  - getPrototypeProperty
```
public final ObjectTypeI getPrototypeProperty()
```
    Specified by:
    
    getPrototypeProperty in interface FunctionTypeI
  - getTopDefiningInterface
```
public final JSType getTopDefiningInterface(String pname)
```
    Description copied from interface: ObjectTypeI
    
    Given an interface and a property, finds a top-most super interface that has the property defined (including this interface). If more than one interfaces have the property, the result is order-specific. Returns a type representing an instance of the interface, not the constructor.
    
    Specified by:
    
    getTopDefiningInterface in interface ObjectTypeI
  - getOwnerFunction
```
public final FunctionTypeI getOwnerFunction()
```
    Description copied from interface: ObjectTypeI
    
    If this type represents the object in a function's prototype property, return that function.
    
    Specified by:
    
    getOwnerFunction in interface ObjectTypeI
  - isSubtypeWithoutStructuralTyping
```
public final boolean isSubtypeWithoutStructuralTyping(TypeI other)
```
    Specified by:
    
    isSubtypeWithoutStructuralTyping in interface TypeI
  - getParameterTypes
```
public final Iterable<TypeI> getParameterTypes()
```
    Specified by:
    
    getParameterTypes in interface FunctionTypeI
  - getPropertyType
```
public TypeI getPropertyType(String propName)
```
    Description copied from interface: ObjectTypeI
    
    Returns the type of property propName on this object, or null if the property doesn't exist.
    
    Specified by:
    
    getPropertyType in interface ObjectTypeI
  - isRecordType
```
public boolean isRecordType()
```
    Description copied from interface: TypeI
    
    Whether this type represents an anonymous structural type, e.g., { a: number, b: string }. Returns false for named structural types (i.e., types defined using @record).
    
    Specified by:
    
    isRecordType in interface TypeI
  - hasUninstantiatedTypeVariables
```
public boolean hasUninstantiatedTypeVariables()
```
    Description copied from interface: TypeI
    
    Returns true if this type is a generic object (non function) and some (or all) of its type variables are not instantiated. Note that in OTI it is possible to instantiate only some of the type variables of a generic type (bad implementation choice). In NTI, a generic type can only be uninstantiated or fully instantiated.
    
    Specified by:
    
    hasUninstantiatedTypeVariables in interface TypeI
  - getTemplateTypes
```
public com.google.common.collect.ImmutableList<? extends TypeI> getTemplateTypes()
```
    Description copied from interface: ObjectTypeI
    
    For an instantiated generic type, return the types that the type variables are mapped to.
    
    Specified by:
    
    getTemplateTypes in interface ObjectTypeI
    
    Returns:
    
    Returns null if this type is not generic. TODO(dimvar): this could have a better name, but it's used by non-compiler code. Rename in a follow-up CL. TODO(dimvar): After deleting the old type checker, change the signature of this and other methods in TypeI to stop using wildcards.

Class JSType

Field Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

mockToString

Method Detail

getMask

getTypeVar

getEnums

fromObjectType

fromTypeVar

isTop

isBottom

isUndefined

isUnknown

isTrueOrTruthy

isFalseOrFalsy

isAnyTruthyType

isAnyFalsyType

isBoolean

isBooleanValueType

isString

isStringValueType

isNumber

isNumberValueType

isNullOrUndef

isScalar

hasNonScalar

isNullable

isTypeVariable

hasTypeVariable

isStruct

mayBeStruct

isStructWithoutProp

isLoose

isDict

getIndexType

getIndexedType

mayBeDict

isEnumElement

isEnumObject

getEnumeratedTypeOfEnumObject

isUnion

isFunctionWithProperties

isNamespace

getEnumeratedTypeOfEnumElement

autobox

join

substituteGenerics

substituteGenericsWithUnknown

getInstantiatedTypeOfIterable

unifyWith

specialize

meet

haveCommonSubtype

plus

negate

toBoolean

isNonLooseSubtypeOf

isSubtypeOf

whyNotSubtypeOf

removeType

withFunction

createGetterPropName

createSetterPropName

isSingletonObj

getFunTypeIfSingletonObj

getFunType

getNominalTypeIfSingletonObj

isInterfaceInstance

isNonClassyObject

isIObject

isInterfaceDefinition

withLoose

getProp

getDeclaredProp

mayHaveProp

hasProp

hasConstantProp