JSType (Closure Compiler v20170910 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

Nested Class Summary
- Nested classes/interfaces inherited from interface com.google.javascript.rhino.TypeI
  TypeI.Nullability, TypeI.TypeInference

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()`
`static JSType`	`buildRecordTypeFromObject(JSTypes commonTypes, JSType t)` Create an anonymous record using the "own" properties of the given type.
`boolean`	`containsArray()`
`TypeI`	`convertMethodToFunction()` Creates a new function type B based on the original function type A.
`boolean`	`equals(Object o)`
`JSType`	`findSubtypeWithProp(QualifiedName pname)`
`static JSType`	`fromObjectType(com.google.javascript.jscomp.newtypes.ObjectType obj)`
`static JSType`	`fromProperties(JSTypes commonTypes, Map<String,JSType> propTypes)` Create an anonymous record type with the given properties.
`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)`
`Collection<FunctionTypeI>`	`getDirectSubTypes()` Returns an iterable of direct types that are subtypes of this type.
`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`	`getInstantiatedTypeArgument(JSType supertype)` Given an generic supertype of this, returns the type argument as instantiated by this type.
`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)` TODO(dimvar): rename methods in this file that use the phrase OwnProp to NonInheritedProp, to avoid ambiguity with the built-in methods such as hasOwnProperty, which have different semantics.
`Iterable<String>`	`getOwnPropertyNames()` Return the names of all non-inherited properties of this type, including prototype properties.
`Iterable<TypeI>`	`getParameterTypes()`
`JSType`	`getProp(QualifiedName qname)`
`Node`	`getPropertyDefSite(String propertyName)`
`JSDocInfo`	`getPropertyJSDocInfo(String propertyName)`
`Set<String>`	`getPropertyNames()` Returns a set of properties defined or inferred on this type or any of its supertypes.
`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()` If this type is not generic, return as is.
`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.
`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<TypeI>`	`getTypeParameters()` If this type is a generic nominal type or function, return the type parameters as type variables.
`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()` Whether this function type has any properties (not counting "prototype").
`boolean`	`hasProperty(String propertyName)`
`boolean`	`hasTypeVariable()`
`static boolean`	`haveCommonSubtype(JSType lhs, JSType rhs)`
`JSType`	`instantiateGenerics(List<? extends TypeI> typeiArgs)` If this type represents an uninstantiated nominal type or function, instantiate it using the given type arguments.
`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`	`isAmbiguousObject()` Returns true if this object is an anonymous object or function type (i.e.
`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`	`isFullyInstantiated()` Returns true if this type is a generic object (non function) and all its type variables are instantiated.
`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`	`isPartiallyInstantiated()` Returns true if this type is a generic object (non function) and some of its type variables are instantiated.
`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`	`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(TypeI.Nullability nullability)` 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`	`toString()`
`String`	`toString(ToStringContext ctx)`
`TypeI.TypeInference`	`typeInference()` Returns the type inference of this object.
`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)`
`FunctionTypeI`	`withReturnType(TypeI returnType)` Returns a function type that is the same as functionType except for the return type, which is set to be returnType.

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()
```
  - getInstantiatedTypeArgument
```
public JSType getInstantiatedTypeArgument(JSType supertype)
```
    Given an generic supertype of this, returns the type argument as instantiated by this type. Parameter supertype has to be a type with a single type parameter. For example,
```
   
   (Iterable<Foo>).getInstantiatedTypeArgument(Iterable<?>) returns Foo,
   and
   /** {@literal @}template A * /
   class Foo {}
   /**
    * {@literal @}template B
    * {@literal @}extends {Foo<Array<B>>}
    * /
   class Bar {}
   (Bar<string>).getInstantiatedTypeArguments(Bar<?>) returns string
   (Bar<string>).getInstantiatedTypeArguments(Foo<?>) returns Array<string>
 
```
    This is used, for example, in type-checking for-of and yield.
  - 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)
```
  - 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
  - toString
```
public final String toString(ToStringContext ctx)
```
  - toAnnotationString
```
public final String toAnnotationString(TypeI.Nullability nullability)
```
    Description copied from interface: TypeI
    
    Returns a string representation of this type, suitable for printing in type annotations at code generation time.
    
    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
    
    Returns:
    
    True for both nominal and structural interfaces
  - 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
  - getDirectSubTypes
```
public final Collection<FunctionTypeI> getDirectSubTypes()
```
    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:
    
    getDirectSubTypes 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<TypeI> getTypeParameters()
```
    Description copied from interface: TypeI
    
    If this type is a generic nominal type or function, return the type parameters as type variables.
    
    Specified by:
    
    getTypeParameters in interface TypeI
  - hasProperties
```
public final boolean hasProperties()
```
    Description copied from interface: FunctionTypeI
    
    Whether this function type has any properties (not counting "prototype").
    
    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
  - withReturnType
```
public FunctionTypeI withReturnType(TypeI returnType)
```
    Description copied from interface: FunctionTypeI
    
    Returns a function type that is the same as functionType except for the return type, which is set to be returnType. This method is a bit of a hack to support preserving types during Generator transpilation, and is only implemented in NTI.
    
    Specified by:
    
    withReturnType 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)
```
    Description copied from interface: ObjectTypeI
    
    TODO(dimvar): rename methods in this file that use the phrase OwnProp to NonInheritedProp, to avoid ambiguity with the built-in methods such as hasOwnProperty, which have different semantics. The built-in methods also look at properties directly on the instance that have been copied from a super type, while we care only about non-inherited properties. The methods here have many uses, including in code outside the compiler codebase, which is why I'm deferring the renaming.
    
    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()
```
    Description copied from interface: ObjectTypeI
    
    Return the names of all non-inherited properties of this type, including prototype properties. If this type represents an object literal, do not include Object.prototype properties.
    
    Specified by:
    
    getOwnPropertyNames in interface ObjectTypeI
  - isPrototypeObject
```
public final boolean isPrototypeObject()
```
    Specified by:
    
    isPrototypeObject in interface TypeI
  - isAmbiguousObject
```
public final boolean isAmbiguousObject()
```
    Description copied from interface: ObjectTypeI
    
    Returns true if this object is an anonymous object or function type (i.e. the builtin Object or Function type, or a record or function literal). These types are ambiguous and should not participate in property renaming. Everything else has a named reference type and returns false.
    
    Specified by:
    
    isAmbiguousObject 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()
```
    Description copied from interface: ObjectTypeI
    
    If this type is not generic, return as is. If it is an instantiated generic type, drop the type arguments.
    
    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
  - instantiateGenerics
```
public final JSType instantiateGenerics(List<? extends TypeI> typeiArgs)
```
    If this type represents an uninstantiated nominal type or function, instantiate it using the given type arguments. Otherwise, return the type unchanged.
  - fromProperties
```
public static JSType fromProperties(JSTypes commonTypes,
                                    Map<String,JSType> propTypes)
```
    Create an anonymous record type with the given properties.
  - buildRecordTypeFromObject
```
public static JSType buildRecordTypeFromObject(JSTypes commonTypes,
                                               JSType t)
```
    Create an anonymous record using the "own" properties of the given type. Used by the TTL.
  - 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
  - isFullyInstantiated
```
public boolean isFullyInstantiated()
```
    Description copied from interface: TypeI
    
    Returns true if this type is a generic object (non function) and *all* its type variables are instantiated.
    
    Specified by:
    
    isFullyInstantiated in interface TypeI
  - isPartiallyInstantiated
```
public boolean isPartiallyInstantiated()
```
    Description copied from interface: TypeI
    
    Returns true if this type is a generic object (non function) and *some* of its type variables are instantiated. In NTI, this is the same as isFullyInstantiated. In OTI, generic types can be partially instantiated (bad implementation choice).
    
    Specified by:
    
    isPartiallyInstantiated 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.
  - getPropertyNames
```
public Set<String> getPropertyNames()
```
    Description copied from interface: ObjectTypeI
    
    Returns a set of properties defined or inferred on this type or any of its supertypes.
    
    Specified by:
    
    getPropertyNames in interface ObjectTypeI
  - typeInference
```
public TypeI.TypeInference typeInference()
```
    Description copied from interface: TypeI
    
    Returns the type inference of this object. Useful for debugging. Note: this should be deleted when OTI is no longer relevant.
    
    Specified by:
    
    typeInference in interface TypeI

Class JSType

Nested Class Summary

Nested classes/interfaces inherited from interface com.google.javascript.rhino.TypeI

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

getInstantiatedTypeArgument

unifyWith

specialize

meet

haveCommonSubtype

plus

negate

toBoolean

isNonLooseSubtypeOf

isSubtypeOf

whyNotSubtypeOf

removeType

withFunction

isSingletonObj

getFunTypeIfSingletonObj

getFunType

getNominalTypeIfSingletonObj

isInterfaceInstance

isNonClassyObject

isIObject

isInterfaceDefinition

withLoose

getProp

getDeclaredProp

mayHaveProp

hasProp

hasConstantProp