JSType (Closure Compiler v20170218 API)

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

All Implemented Interfaces:

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

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

Field Summary

Fields
Modifier and Type Field and Description

static boolean mockToString

protected static int NON_SCALAR_MASK

protected static int NULL_MASK

protected static int TYPEVAR_MASK

Fields
Modifier and Type	Field and Description
`static boolean`	`mockToString`
`protected static int`	`NON_SCALAR_MASK`
`protected static int`	`NULL_MASK`
`protected static int`	`TYPEVAR_MASK`

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.
`StringBuilder`	`appendTo(StringBuilder builder)`
`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)`
`Collection<JSType>`	`getDirectImplementors()`
`String`	`getDisplayName()`
`JSType`	`getEnumeratedTypeOfEnumElement()`
`protected abstract com.google.common.collect.ImmutableSet<EnumType>`	`getEnums()`
`FunctionType`	`getFunType()`
`FunctionType`	`getFunTypeIfSingletonObj()`
`TypeI`	`getGreatestSubtypeWithProperty(String pname)`
`JSType`	`getIndexedType()`
`JSType`	`getIndexType()`
`ObjectTypeI`	`getInstanceType()`
`JSDocInfo`	`getJSDocInfo()`
`TypeI`	`getLegacyResolvedType()` Only called on instances of NamedType.
`protected abstract int`	`getMask()`
`NominalType`	`getNominalTypeIfSingletonObj()`
`FunctionTypeI`	`getOwnerFunction()`
`Node`	`getOwnPropertyDefSite(String propertyName)`
`JSDocInfo`	`getOwnPropertyJSDocInfo(String propertyName)`
`Iterable<String>`	`getOwnPropertyNames()` Returns the names of all the properties directly on this type.
`JSType`	`getProp(QualifiedName qname)`
`Node`	`getPropertyDefSite(String propertyName)`
`JSDocInfo`	`getPropertyJSDocInfo(String propertyName)`
`JSType`	`getPrototypeObject()` Returns the __proto__ object of this object type, NOT the ".prototype" property.
`ObjectTypeI`	`getPrototypeProperty()`
`ObjectTypeI`	`getRawType()`
`String`	`getReferenceName()`
`TypeI`	`getReturnType()`
`Node`	`getSource()` Gets the AST Node where this function was defined.
`List<? extends FunctionTypeI>`	`getSubTypes()` Returns a list of types that are subtypes of this type.
`FunctionTypeI`	`getSuperClassConstructor()`
`ObjectTypeI`	`getTopDefiningInterface(String propName)`
`TypeI`	`getTypeOfThis()` Gets the type of `this` in this function.
`protected abstract String`	`getTypeVar()`
`Iterable<TypeI>`	`getUnionMembers()` If this type is a union type, returns a list of its members.
`boolean`	`hasConstantProp(QualifiedName pname)`
`int`	`hashCode()`
`boolean`	`hasInstanceType()`
`boolean`	`hasNonScalar()`
`boolean`	`hasOwnProperty(String propertyName)`
`boolean`	`hasProp(QualifiedName qname)`
`boolean`	`hasProperties()`
`boolean`	`hasProperty(String propertyName)`
`boolean`	`hasTypeVariable()`
`static boolean`	`haveCommonSubtype(JSType lhs, JSType rhs)`
`boolean`	`isAnyFalsyType()`
`boolean`	`isAnyTruthyType()`
`boolean`	`isBoolean()`
`boolean`	`isBottom()`
`boolean`	`isBoxableScalar()`
`boolean`	`isConstructor()`
`boolean`	`isDict()`
`boolean`	`isEnumElement()`
`boolean`	`isEnumObject()`
`boolean`	`isEquivalentTo(TypeI type)`
`boolean`	`isFalseOrFalsy()`
`boolean`	`isFunctionType()`
`boolean`	`isFunctionWithProperties()`
`boolean`	`isGeneric()`
`boolean`	`isInstanceofObject()`
`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`	`isLoose()`
`boolean`	`isNamespace()`
`boolean`	`isNonClassyObject()`
`boolean`	`isNonLooseSubtypeOf(JSType other)`
`boolean`	`isNullable()`
`boolean`	`isNullOrUndef()`
`boolean`	`isNullType()`
`boolean`	`isNumber()`
`boolean`	`isObjectType()`
`boolean`	`isPropDefinedOnSubtype(QualifiedName pname)`
`boolean`	`isPrototypeObject()`
`boolean`	`isScalar()`
`boolean`	`isSingletonObj()`
`boolean`	`isSomeUnknownType()`
`boolean`	`isString()`
`boolean`	`isStruct()`
`boolean`	`isStructuralInterface()`
`boolean`	`isStructWithoutProp(QualifiedName pname)`
`boolean`	`isSubtypeOf(TypeI other)`
`boolean`	`isTop()`
`boolean`	`isTrueOrTruthy()`
`boolean`	`isTypeVariable()`
`boolean`	`isUndefined()`
`boolean`	`isUnion()`
`boolean`	`isUnionType()`
`boolean`	`isUnknown()`
`boolean`	`isUnknownObject()`
`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)`
`JSType`	`substituteGenericsWithUnknown()`
`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()`
`boolean`	`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 t1, JSType t2)`
`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
  - TYPEVAR_MASK
```
protected static final int TYPEVAR_MASK
```
    See Also:
    
    Constant Field Values
  - NON_SCALAR_MASK
```
protected static final int NON_SCALAR_MASK
```
    See Also:
    
    Constant Field Values
  - NULL_MASK
```
protected static final int NULL_MASK
```
    See Also:
    
    Constant Field Values
  - 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 boolean isTop()
```
    Specified by:
    
    isTop in interface TypeI
  - isBottom
```
public boolean isBottom()
```
    Specified by:
    
    isBottom in interface TypeI
  - isUndefined
```
public boolean isUndefined()
```
  - isUnknown
```
public boolean isUnknown()
```
  - isTrueOrTruthy
```
public boolean isTrueOrTruthy()
```
  - isFalseOrFalsy
```
public boolean isFalseOrFalsy()
```
  - isAnyTruthyType
```
public boolean isAnyTruthyType()
```
  - isAnyFalsyType
```
public boolean isAnyFalsyType()
```
  - isBoolean
```
public boolean isBoolean()
```
  - isString
```
public boolean isString()
```
  - isNumber
```
public boolean isNumber()
```
  - isNullOrUndef
```
public boolean isNullOrUndef()
```
  - isScalar
```
public boolean isScalar()
```
  - hasNonScalar
```
public boolean hasNonScalar()
```
  - isNullable
```
public boolean isNullable()
```
    Specified by:
    
    isNullable in interface TypeI
  - isTypeVariable
```
public boolean isTypeVariable()
```
    Specified by:
    
    isTypeVariable in interface TypeI
  - hasTypeVariable
```
public boolean hasTypeVariable()
```
  - isStruct
```
public boolean isStruct()
```
  - mayBeStruct
```
public boolean mayBeStruct()
```
  - isStructWithoutProp
```
public boolean isStructWithoutProp(QualifiedName pname)
```
  - isLoose
```
public boolean isLoose()
```
  - isDict
```
public boolean isDict()
```
  - getIndexType
```
public JSType getIndexType()
```
  - getIndexedType
```
public JSType getIndexedType()
```
  - mayBeDict
```
public boolean mayBeDict()
```
  - isEnumElement
```
public boolean isEnumElement()
```
    Specified by:
    
    isEnumElement in interface TypeI
  - isEnumObject
```
public boolean isEnumObject()
```
    Specified by:
    
    isEnumObject in interface TypeI
  - isUnion
```
public boolean isUnion()
```
  - isFunctionWithProperties
```
public boolean isFunctionWithProperties()
```
  - isNamespace
```
public boolean isNamespace()
```
  - getEnumeratedTypeOfEnumElement
```
public JSType getEnumeratedTypeOfEnumElement()
```
    Specified by:
    
    getEnumeratedTypeOfEnumElement in interface TypeI
  - autobox
```
public JSType autobox()
```
    Specified by:
    
    autobox in interface TypeI
  - join
```
public static JSType join(JSType lhs,
                          JSType rhs)
```
  - substituteGenerics
```
public JSType substituteGenerics(Map<String,JSType> concreteTypes)
```
  - substituteGenericsWithUnknown
```
public JSType substituteGenericsWithUnknown()
```
  - unifyWith
```
public boolean 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. Note that if this is a union type, some of the union members may be ignored if they are not present in other.
    
    Returns:
    
    Whether unification succeeded This method should only be called outside the newtypes package; classes inside the package should use unifyWithSubtype.
  - specialize
```
public 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 JSType negate()
```
  - toBoolean
```
public JSType toBoolean()
```
  - isNonLooseSubtypeOf
```
public boolean isNonLooseSubtypeOf(JSType other)
```
  - isSubtypeOf
```
public boolean isSubtypeOf(TypeI other)
```
    Specified by:
    
    isSubtypeOf in interface TypeI
  - whyNotSubtypeOf
```
public static MismatchInfo whyNotSubtypeOf(JSType t1,
                                           JSType t2)
```
  - removeType
```
public JSType removeType(JSType other)
```
  - withFunction
```
public JSType withFunction(FunctionType ft,
                           NominalType fnNominal)
```
  - createGetterPropName
```
public static String createGetterPropName(String originalPropName)
```
  - createSetterPropName
```
public static String createSetterPropName(String originalPropName)
```
  - isSingletonObj
```
public boolean isSingletonObj()
```
  - getFunTypeIfSingletonObj
```
public FunctionType getFunTypeIfSingletonObj()
```
  - getFunType
```
public FunctionType getFunType()
```
  - getNominalTypeIfSingletonObj
```
public NominalType getNominalTypeIfSingletonObj()
```
  - isInterfaceInstance
```
public boolean isInterfaceInstance()
```
  - isNonClassyObject
```
public boolean isNonClassyObject()
```
  - isIObject
```
public boolean isIObject()
```
  - isInterfaceDefinition
```
public boolean isInterfaceDefinition()
```
  - withLoose
```
public JSType withLoose()
```
    Turns the class-less object of this type (if any) into a loose object
  - getProp
```
public JSType getProp(QualifiedName qname)
```
  - getDeclaredProp
```
public JSType getDeclaredProp(QualifiedName qname)
```
  - mayHaveProp
```
public boolean mayHaveProp(QualifiedName qname)
```
  - hasProp
```
public boolean hasProp(QualifiedName qname)
```
  - hasConstantProp
```
public boolean hasConstantProp(QualifiedName pname)
```
  - containsArray
```
public boolean containsArray()
```
    Specified by:
    
    containsArray in interface TypeI
  - withoutProperty
```
public JSType withoutProperty(QualifiedName qname)
```
  - withProperty
```
public JSType withProperty(QualifiedName qname,
                           JSType type)
```
  - withDeclaredProperty
```
public JSType withDeclaredProperty(QualifiedName qname,
                                   JSType type,
                                   boolean isConstant)
```
  - withPropertyRequired
```
public JSType withPropertyRequired(String pname)
```
  - findSubtypeWithProp
```
public JSType findSubtypeWithProp(QualifiedName pname)
```
  - isPropDefinedOnSubtype
```
public boolean isPropDefinedOnSubtype(QualifiedName pname)
```
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - appendTo
```
public StringBuilder appendTo(StringBuilder builder)
```
  - isConstructor
```
public boolean isConstructor()
```
    Specified by:
    
    isConstructor in interface TypeI
  - isEquivalentTo
```
public boolean isEquivalentTo(TypeI type)
```
    Specified by:
    
    isEquivalentTo in interface TypeI
  - isFunctionType
```
public boolean isFunctionType()
```
    Specified by:
    
    isFunctionType in interface TypeI
  - isInterface
```
public boolean isInterface()
```
    Specified by:
    
    isInterface in interface TypeI
  - isUnknownType
```
public boolean isUnknownType()
```
    Specified by:
    
    isUnknownType in interface TypeI
  - isSomeUnknownType
```
public boolean isSomeUnknownType()
```
    Specified by:
    
    isSomeUnknownType in interface TypeI
  - isUnresolved
```
public boolean isUnresolved()
```
    Specified by:
    
    isUnresolved in interface TypeI
  - isUnresolvedOrResolvedUnknown
```
public boolean isUnresolvedOrResolvedUnknown()
```
    Specified by:
    
    isUnresolvedOrResolvedUnknown in interface TypeI
  - isUnionType
```
public boolean isUnionType()
```
    Specified by:
    
    isUnionType in interface TypeI
  - isVoidable
```
public boolean isVoidable()
```
    Specified by:
    
    isVoidable in interface TypeI
  - isNullType
```
public boolean isNullType()
```
    Specified by:
    
    isNullType in interface TypeI
  - isVoidType
```
public boolean isVoidType()
```
    Specified by:
    
    isVoidType in interface TypeI
  - restrictByNotNullOrUndefined
```
public 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 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 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 ObjectTypeI autoboxAndGetObject()
```
    Specified by:
    
    autoboxAndGetObject in interface TypeI
  - meetWith
```
public TypeI meetWith(TypeI other)
```
    Specified by:
    
    meetWith in interface TypeI
  - equals
```
public boolean equals(Object o)
```
    Overrides:
    
    equals in class Object
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class Object
  - getDisplayName
```
public String getDisplayName()
```
    Specified by:
    
    getDisplayName in interface TypeI
  - convertMethodToFunction
```
public 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 boolean hasInstanceType()
```
    Specified by:
    
    hasInstanceType in interface FunctionTypeI
  - getInstanceType
```
public ObjectTypeI getInstanceType()
```
    Specified by:
    
    getInstanceType in interface FunctionTypeI
  - getReferenceName
```
public String getReferenceName()
```
    Specified by:
    
    getReferenceName in interface FunctionTypeI
  - getSource
```
public Node getSource()
```
    Description copied from interface: FunctionTypeI
    
    Gets the AST Node where this function was defined.
    
    Specified by:
    
    getSource in interface FunctionTypeI
  - getSubTypes
```
public List<? extends FunctionTypeI> getSubTypes()
```
    Description copied from interface: FunctionTypeI
    
    Returns a list of types that are subtypes of this type. This is only valid for constructor functions, and may be null. This allows a downward traversal of the subtype graph.
    
    Specified by:
    
    getSubTypes in interface FunctionTypeI
  - getTypeOfThis
```
public TypeI getTypeOfThis()
```
    Description copied from interface: FunctionTypeI
    
    Gets the type of this in this function.
    
    Specified by:
    
    getTypeOfThis in interface FunctionTypeI
  - acceptsArguments
```
public 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
  - hasProperties
```
public boolean hasProperties()
```
    Specified by:
    
    hasProperties in interface FunctionTypeI
  - setSource
```
public void setSource(Node n)
```
    Specified by:
    
    setSource in interface FunctionTypeI
  - getReturnType
```
public TypeI getReturnType()
```
    Specified by:
    
    getReturnType in interface FunctionTypeI
  - getConstructor
```
public 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 FunctionTypeI getSuperClassConstructor()
```
    Specified by:
    
    getSuperClassConstructor in interface ObjectTypeI
  - getPrototypeObject
```
public 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 JSDocInfo getJSDocInfo()
```
    Specified by:
    
    getJSDocInfo in interface TypeI
  - getOwnPropertyJSDocInfo
```
public JSDocInfo getOwnPropertyJSDocInfo(String propertyName)
```
    Specified by:
    
    getOwnPropertyJSDocInfo in interface ObjectTypeI
  - getPropertyJSDocInfo
```
public JSDocInfo getPropertyJSDocInfo(String propertyName)
```
    Specified by:
    
    getPropertyJSDocInfo in interface ObjectTypeI
  - getOwnPropertyDefSite
```
public Node getOwnPropertyDefSite(String propertyName)
```
    Specified by:
    
    getOwnPropertyDefSite in interface ObjectTypeI
  - getPropertyDefSite
```
public Node getPropertyDefSite(String propertyName)
```
    Specified by:
    
    getPropertyDefSite in interface ObjectTypeI
  - getOwnPropertyNames
```
public Iterable<String> getOwnPropertyNames()
```
    Returns the names of all the properties directly on this type.
    
    Specified by:
    
    getOwnPropertyNames in interface ObjectTypeI
  - isPrototypeObject
```
public boolean isPrototypeObject()
```
    Specified by:
    
    isPrototypeObject in interface TypeI
  - isUnknownObject
```
public boolean isUnknownObject()
```
    Specified by:
    
    isUnknownObject in interface ObjectTypeI
  - isInstanceofObject
```
public boolean isInstanceofObject()
```
    Specified by:
    
    isInstanceofObject in interface TypeI
  - mayContainUnknownObject
```
public boolean mayContainUnknownObject()
```
  - isInstanceType
```
public 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 boolean hasProperty(String propertyName)
```
    Specified by:
    
    hasProperty in interface ObjectTypeI
  - getUnionMembers
```
public Iterable<TypeI> 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 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 boolean isBoxableScalar()
```
    Specified by:
    
    isBoxableScalar in interface TypeI
  - isObjectType
```
public final boolean isObjectType()
```
    Specified by:
    
    isObjectType in interface TypeI
  - isGeneric
```
public final boolean isGeneric()
```
    Specified by:
    
    isGeneric in interface ObjectTypeI
  - getAncestorInterfaces
```
public Collection<ObjectTypeI> getAncestorInterfaces()
```
    Specified by:
    
    getAncestorInterfaces in interface FunctionTypeI
  - isStructuralInterface
```
public boolean isStructuralInterface()
```
    Specified by:
    
    isStructuralInterface in interface TypeI
  - hasOwnProperty
```
public boolean hasOwnProperty(String propertyName)
```
    Specified by:
    
    hasOwnProperty in interface ObjectTypeI
  - getRawType
```
public ObjectTypeI getRawType()
```
    Specified by:
    
    getRawType 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 TypeI getLegacyResolvedType()
```
    Description copied from interface: ObjectTypeI
    
    Only called on instances of NamedType. See also isLegacyNamedType.
    
    Specified by:
    
    getLegacyResolvedType in interface ObjectTypeI
  - getGreatestSubtypeWithProperty
```
public TypeI getGreatestSubtypeWithProperty(String pname)
```
    Specified by:
    
    getGreatestSubtypeWithProperty in interface TypeI
  - getDirectImplementors
```
public Collection<JSType> getDirectImplementors()
```
    Specified by:
    
    getDirectImplementors in interface ObjectTypeI
  - getPrototypeProperty
```
public ObjectTypeI getPrototypeProperty()
```
    Specified by:
    
    getPrototypeProperty in interface FunctionTypeI
  - getTopDefiningInterface
```
public ObjectTypeI getTopDefiningInterface(String propName)
```
    Specified by:
    
    getTopDefiningInterface in interface ObjectTypeI
  - getOwnerFunction
```
public FunctionTypeI getOwnerFunction()
```
    Specified by:
    
    getOwnerFunction in interface ObjectTypeI

Class JSType

Field Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

TYPEVAR_MASK

NON_SCALAR_MASK

NULL_MASK

mockToString

Method Detail

getMask

getTypeVar

getEnums

fromObjectType

fromTypeVar

isTop

isBottom

isUndefined

isUnknown

isTrueOrTruthy

isFalseOrFalsy

isAnyTruthyType

isAnyFalsyType

isBoolean

isString

isNumber

isNullOrUndef

isScalar

hasNonScalar

isNullable

isTypeVariable

hasTypeVariable

isStruct

mayBeStruct

isStructWithoutProp

isLoose

isDict

getIndexType

getIndexedType

mayBeDict

isEnumElement

isEnumObject

isUnion

isFunctionWithProperties

isNamespace

getEnumeratedTypeOfEnumElement

autobox

join

substituteGenerics

substituteGenericsWithUnknown

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

containsArray

withoutProperty