JSTypeRegistry (Closure Compiler v20180506 API)

java.lang.Object
- com.google.javascript.rhino.jstype.JSTypeRegistry

All Implemented Interfaces:

TypeIRegistry, java.io.Serializable
```
public class JSTypeRegistry
extends java.lang.Object
implements TypeIRegistry
```
The type registry is used to resolve named types.
This class is not thread-safe.

See Also:

Serialized Form

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class JSTypeRegistry.PropDefinitionKind
A tristate value returned from canPropertyBeDefined.

Nested Classes
Modifier and Type	Class and Description
`static class`	`JSTypeRegistry.PropDefinitionKind` A tristate value returned from canPropertyBeDefined.

Field Summary

Fields
Modifier and Type Field and Description

static java.lang.String OBJECT_ELEMENT_TEMPLATE
Deprecated.

Fields
Modifier and Type	Field and Description
`static java.lang.String`	`OBJECT_ELEMENT_TEMPLATE` Deprecated.

Constructor Summary

Constructors
Constructor and Description
`JSTypeRegistry(ErrorReporter reporter)`
`JSTypeRegistry(ErrorReporter reporter, java.util.Set<java.lang.String> forwardDeclaredTypes)` Constructs a new type registry populated with the built-in types.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`JSType`	`buildRecordTypeFromObject(ObjectTypeI obj)`
`JSTypeRegistry.PropDefinitionKind`	`canPropertyBeDefined(JSType type, java.lang.String propertyName)` Returns whether the given property can possibly be set on the given type.
`void`	`clearNamedTypes()` Flushes out the current resolved and unresolved Named Types from the type registry.
`void`	`clearTemplateTypeNames()` Clears the template type name.
`ObjectType`	`createAnonymousObjectType(JSDocInfo info)` Create an anonymous object type.
`FunctionType`	`createConstructorType(java.lang.String name, Node source, Node parameters, JSType returnType, com.google.common.collect.ImmutableList<TemplateType> templateKeys, boolean isAbstract)` Creates a constructor function type.
`JSType`	`createDefaultObjectUnion(JSType type)` Creates a type representing nullable values of the given type.
`EnumType`	`createEnumType(java.lang.String name, Node source, JSType elementsType)` Creates an enum type.
`FunctionType`	`createFunctionType(JSType returnType, JSType... parameterTypes)` Creates a function type.
`FunctionType`	`createFunctionType(JSType returnType, Node parameters)`
`JSType`	`createFunctionTypeWithInstanceType(ObjectType instanceType, JSType returnType, java.util.List<JSType> parameterTypes)` Creates a function type in which `this` refers to an object instance.
`FunctionType`	`createFunctionTypeWithNewReturnType(FunctionType existingFunctionType, JSType returnType)` Creates a new function type based on an existing function type but with a new return type.
`FunctionType`	`createFunctionTypeWithVarArgs(JSType returnType, JSType... parameterTypes)` Creates a function type.
`java.lang.String`	`createGetterPropName(java.lang.String originalPropName)` For NTI, this method returns an obfuscated name that represents the getter.
`FunctionType`	`createInterfaceType(java.lang.String name, Node source, com.google.common.collect.ImmutableList<TemplateType> templateKeys, boolean struct)` Creates an interface function type.
`NamedType`	`createNamedType(StaticTypedScope<JSType> scope, java.lang.String reference, java.lang.String sourceName, int lineno, int charno)` Creates a named type.
`JSType`	`createNullableType(JSType type)` Creates a type representing nullable values of the given type.
`ObjectType`	`createObjectType(java.lang.String name, ObjectType implicitPrototype)` Create an object type.
`JSType`	`createOptionalNullableType(JSType type)` Creates a nullable and undefine-able value of the given type.
`Node`	`createOptionalParameters(JSType... parameterTypes)` Creates a tree hierarchy representing a typed parameter list in which every parameter is optional.
`JSType`	`createOptionalType(JSType type)` Creates a type representing optional values of the given type.
`Node`	`createParameters(JSType... parameterTypes)` Creates a tree hierarchy representing a typed argument list.
`Node`	`createParametersWithVarArgs(JSType... parameterTypes)` Creates a tree hierarchy representing a typed argument list.
`JSType`	`createRecordType(java.util.Map<java.lang.String,? extends TypeI> props)` Creates an anonymous structural type with the given properties.
`java.lang.String`	`createSetterPropName(java.lang.String originalPropName)` For NTI, this method returns an obfuscated name that represents the setter.
`TemplateType`	`createTemplateType(java.lang.String name)`
`TemplateTypeMap`	`createTemplateTypeMap(com.google.common.collect.ImmutableList<TemplateType> templateKeys, com.google.common.collect.ImmutableList<JSType> templateValues)` Creates a template type map from the specified list of template keys and template value types.
`TemplateType`	`createTemplateTypeWithTransformation(java.lang.String name, Node expr)`
`TemplatizedType`	`createTemplatizedType(ObjectType baseType, com.google.common.collect.ImmutableList<JSType> templatizedTypes)` Creates a templatized instance of the specified type.
`TemplatizedType`	`createTemplatizedType(ObjectType baseType, JSType... templatizedTypes)` Creates a templatized instance of the specified type.
`TemplatizedType`	`createTemplatizedType(ObjectType baseType, java.util.Map<TemplateType,JSType> templatizedTypes)` Creates a templatized instance of the specified type.
`JSType`	`createTypeFromCommentNode(Node n)`
`JSType`	`createTypeFromCommentNode(Node n, java.lang.String sourceName, StaticTypedScope<? extends TypeI> scope)` Creates a JSType from the nodes representing a type.
`JSType`	`createUnionType(JSType... variants)` Creates a union type whose variants are the arguments.
`JSType`	`createUnionType(JSTypeNative... variants)` Creates a union type whose variants are the built-in types specified by the arguments.
`JSType`	`createUnionType(java.util.List<? extends TypeI> variants)`
`boolean`	`declareType(StaticScope scope, java.lang.String name, JSType type)` Records declared global type names.
`boolean`	`declareTypeForExactScope(StaticScope scope, java.lang.String name, JSType type)` Records declared global type names.
`JSType`	`evaluateTypeExpression(JSTypeExpression expr, TypeIEnv<TypeI> scope)`
`JSType`	`evaluateTypeExpressionInGlobalScope(JSTypeExpression expr)`
`java.util.Collection<FunctionTypeI>`	`getDirectImplementors(ObjectType interfaceInstance)` Returns a collection of types that directly implement `interfaceInstance`.
`java.lang.Iterable<ObjectType>`	`getEachReferenceTypeWithProperty(java.lang.String propertyName)` Returns each reference type that has a property `propertyName` defined on it.
`ErrorReporter`	`getErrorReporter()`
`JSType`	`getGlobalType(java.lang.String jsTypeName)` Returns the type represented by typeName or null if not found.
`JSType`	`getGreatestSubtypeWithProperty(JSType type, java.lang.String propertyName)` Gets the greatest subtype of the `type` that has a property `propertyName` defined on it.
`TemplateType`	`getIterableTemplate()`
`TemplateType`	`getIteratorTemplate()`
`FunctionType`	`getNativeFunctionType(JSTypeNative typeId)`
`ObjectType`	`getNativeObjectType(JSTypeNative typeId)`
`JSType`	`getNativeType(JSTypeNative typeId)`
`TemplateType`	`getObjectElementKey()`
`TemplateType`	`getObjectIndexKey()`
`java.lang.String`	`getReadableTypeName(Node n)` The nice API for this method is a single argument; dereference is a detail.
`java.lang.String`	`getReadableTypeNameNoDeref(Node n)`
`TemplateType`	`getThenableValueKey()`
`JSType`	`getType(StaticScope scope, java.lang.String jsTypeName)` Looks up a native type by name.
`JSType`	`getType(StaticTypedScope<JSType> scope, java.lang.String jsTypeName, java.lang.String sourceName, int lineno, int charno)` Looks up a type by name.
`JSType`	`getTypeForScope(StaticScope scope, java.lang.String jsTypeName)` Looks up a native type by name.
`void`	`identifyNonNullableName(java.lang.String name)` Identifies the name of a typedef or enum before we actually declare it.
`ObjectTypeI`	`instantiateGenericsWithUnknown(ObjectType obj)`
`TypeI`	`instantiateGenericType(ObjectTypeI genericType, com.google.common.collect.ImmutableList<? extends TypeI> typeArgs)` Instantiates genericType using typeArgs.
`boolean`	`isForwardDeclaredType(java.lang.String name)` Whether this is a forward-declared type name.
`com.google.common.collect.ImmutableList<TemplateType>`	`maybeGetTemplateTypesOfBuiltin(java.lang.String fnName)`
`void`	`overwriteDeclaredType(StaticScope scope, java.lang.String name, JSType type)` Overrides a declared global type name.
`void`	`overwriteDeclaredType(java.lang.String name, JSType type)` Overrides a declared global type name.
`void`	`registerPropertyOnType(java.lang.String propertyName, JSType type)` Tells the type system that `owner` may have a property named `propertyName`.
`void`	`removeType(StaticScope scope, java.lang.String name)` Removes a type by name.
`void`	`resetForTypeCheck()` Reset to run the TypeCheck pass.
`void`	`resetImplicitPrototype(JSType type, ObjectType newImplicitProto)` Set the implicit prototype if it's possible to do so.
`void`	`resolveTypesInScope(StaticTypedScope<JSType> scope)` Resolve all the unresolved types in the given scope.
`void`	`restoreContents(java.io.ObjectInputStream in)` Restores the derived state.
`void`	`saveContents(java.io.ObjectOutputStream out)` Saves the derived state.
`void`	`setTemplateTypeNames(java.util.List<TemplateType> keys)` Sets the template type name.
`void`	`unregisterPropertyOnType(java.lang.String propertyName, JSType type)` Removes the index's reference to a property on the given type (if it is currently registered).

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

- Field Detail
  - OBJECT_ELEMENT_TEMPLATE
```
@Deprecated
public static final java.lang.String OBJECT_ELEMENT_TEMPLATE
```
    Deprecated.
    
    See Also:
    
    Constant Field Values
- Constructor Detail
  - JSTypeRegistry
```
public JSTypeRegistry(ErrorReporter reporter)
```
  - JSTypeRegistry
```
public JSTypeRegistry(ErrorReporter reporter,
                      java.util.Set<java.lang.String> forwardDeclaredTypes)
```
    Constructs a new type registry populated with the built-in types.
- Method Detail
  - getObjectElementKey
```
public TemplateType getObjectElementKey()
```
    Returns:
    
    The template variable corresponding to the property value type for Javascript Objects and Arrays.
  - getObjectIndexKey
```
public TemplateType getObjectIndexKey()
```
    Returns:
    
    The template variable corresponding to the property key type of the built-in Javascript object.
  - getThenableValueKey
```
public TemplateType getThenableValueKey()
```
    Returns:
    
    The template variable corresponding to the property key type of the built-in Javascript object.
  - getIterableTemplate
```
public TemplateType getIterableTemplate()
```
    Returns:
    
    The template variable for the Iterable interface.
  - getIteratorTemplate
```
public TemplateType getIteratorTemplate()
```
    Returns:
    
    The template variable for the Iterator interface.
  - maybeGetTemplateTypesOfBuiltin
```
public com.google.common.collect.ImmutableList<TemplateType> maybeGetTemplateTypesOfBuiltin(java.lang.String fnName)
```
    Returns:
    
    return an immutable list of template types of the given builtin.
  - getErrorReporter
```
public ErrorReporter getErrorReporter()
```
  - resetForTypeCheck
```
public void resetForTypeCheck()
```
    Reset to run the TypeCheck pass.
  - removeType
```
public void removeType(StaticScope scope,
                       java.lang.String name)
```
    Removes a type by name.
    
    Parameters:
    
    name - The name string.
  - registerPropertyOnType
```
public void registerPropertyOnType(java.lang.String propertyName,
                                   JSType type)
```
    Tells the type system that owner may have a property named propertyName. This allows the registry to keep track of what types a property is defined upon. This is NOT the same as saying that owner must have a property named type. ObjectType#hasProperty attempts to minimize false positives ("if we're not sure, then don't type check this property"). The type registry, on the other hand, should attempt to minimize false negatives ("if this property is assigned anywhere in the program, it must show up in the type registry").
  - unregisterPropertyOnType
```
public void unregisterPropertyOnType(java.lang.String propertyName,
                                     JSType type)
```
    Removes the index's reference to a property on the given type (if it is currently registered). If the property is not registered on the type yet, this method will not change internal state.
    
    Parameters:
    
    propertyName - the name of the property to unregister
    
    type - the type to unregister the property on.
  - getGreatestSubtypeWithProperty
```
public JSType getGreatestSubtypeWithProperty(JSType type,
                                             java.lang.String propertyName)
```
    Gets the greatest subtype of the type that has a property propertyName defined on it.
  - canPropertyBeDefined
```
public JSTypeRegistry.PropDefinitionKind canPropertyBeDefined(JSType type,
                                                              java.lang.String propertyName)
```
    Returns whether the given property can possibly be set on the given type.
  - getEachReferenceTypeWithProperty
```
public java.lang.Iterable<ObjectType> getEachReferenceTypeWithProperty(java.lang.String propertyName)
```
    Returns each reference type that has a property propertyName defined on it. Unlike most types in our type system, the collection of types returned will not be collapsed. This means that if a type is defined on Object and on Array, this method must return [Object, Array]. It would not be correct to collapse them to [Object].
  - getDirectImplementors
```
public java.util.Collection<FunctionTypeI> getDirectImplementors(ObjectType interfaceInstance)
```
    Returns a collection of types that directly implement interfaceInstance. Subtypes of implementing types are not guaranteed to be returned. interfaceInstance must be an ObjectType for the instance of the interface.
  - declareType
```
public boolean declareType(StaticScope scope,
                           java.lang.String name,
                           JSType type)
```
    Records declared global type names. This makes resolution faster and more robust in the common case.
    
    Parameters:
    
    name - The name of the type to be recorded.
    
    type - The actual type being associated with the name.
    
    Returns:
    
    True if this name is not already defined, false otherwise.
  - declareTypeForExactScope
```
public boolean declareTypeForExactScope(StaticScope scope,
                                        java.lang.String name,
                                        JSType type)
```
    Records declared global type names. This makes resolution faster and more robust in the common case.
    
    Parameters:
    
    name - The name of the type to be recorded.
    
    type - The actual type being associated with the name.
    
    Returns:
    
    True if this name is not already defined, false otherwise.
  - overwriteDeclaredType
```
public void overwriteDeclaredType(java.lang.String name,
                                  JSType type)
```
    Overrides a declared global type name. Throws an exception if this type name hasn't been declared yet.
  - overwriteDeclaredType
```
public void overwriteDeclaredType(StaticScope scope,
                                  java.lang.String name,
                                  JSType type)
```
    Overrides a declared global type name. Throws an exception if this type name hasn't been declared yet.
  - isForwardDeclaredType
```
public boolean isForwardDeclaredType(java.lang.String name)
```
    Whether this is a forward-declared type name.
  - getReadableTypeName
```
public java.lang.String getReadableTypeName(Node n)
```
    The nice API for this method is a single argument; dereference is a detail. In the old type checker, most calls to getReadableJSTypeName are with true (do dereferencing). When we implement this method in the new type checker, we won't do dereferencing, but that's fine because we are stricter about null/undefined checking. (So, null and undefined wouldn't be in the type in the first place.)
    
    Specified by:
    
    getReadableTypeName in interface TypeIRegistry
  - getReadableTypeNameNoDeref
```
public java.lang.String getReadableTypeNameNoDeref(Node n)
```
  - createGetterPropName
```
public java.lang.String createGetterPropName(java.lang.String originalPropName)
```
    Description copied from interface: TypeIRegistry
    
    For NTI, this method returns an obfuscated name that represents the getter. For OTI, the property name is unchanged.
    
    Specified by:
    
    createGetterPropName in interface TypeIRegistry
  - createSetterPropName
```
public java.lang.String createSetterPropName(java.lang.String originalPropName)
```
    Description copied from interface: TypeIRegistry
    
    For NTI, this method returns an obfuscated name that represents the setter. For OTI, the property name is unchanged. This method is a bit of a hack. In the future, NTI can handle getters/setters more gracefully by having a field in the Property class. See also: https://github.com/google/closure-compiler/issues/2545.
    
    Specified by:
    
    createSetterPropName in interface TypeIRegistry
  - getTypeForScope
```
public JSType getTypeForScope(StaticScope scope,
                              java.lang.String jsTypeName)
```
    Looks up a native type by name.
    
    Parameters:
    
    jsTypeName - The name string.
    
    Returns:
    
    the corresponding JSType object or null it cannot be found
  - getGlobalType
```
public JSType getGlobalType(java.lang.String jsTypeName)
```
    Description copied from interface: TypeIRegistry
    
    Returns the type represented by typeName or null if not found. If you pass Foo to this method, and Foo can be an instance or a constructor, you get the Foo instance, in contrast to TypeIEnv#getNamespaceType, where you'd get the Foo constructor. If Foo is not a nominal type, returns the namespace type.
    
    Specified by:
    
    getGlobalType in interface TypeIRegistry
  - getType
```
public JSType getType(StaticScope scope,
                      java.lang.String jsTypeName)
```
    Looks up a native type by name.
    
    Specified by:
    
    getType in interface TypeIRegistry
    
    Parameters:
    
    jsTypeName - The name string.
    
    Returns:
    
    the corresponding JSType object or null it cannot be found
  - getType
```
public JSType getType(StaticTypedScope<JSType> scope,
                      java.lang.String jsTypeName,
                      java.lang.String sourceName,
                      int lineno,
                      int charno)
```
    Looks up a type by name. To allow for forward references to types, an unrecognized string has to be bound to a NamedType object that will be resolved later.
    
    Parameters:
    
    scope - A scope for doing type name resolution.
    
    jsTypeName - The name string.
    
    sourceName - The name of the source file where this reference appears.
    
    lineno - The line number of the reference.
    
    Returns:
    
    a NamedType if the string argument is not one of the known types, otherwise the corresponding JSType object.
  - getNativeType
```
public JSType getNativeType(JSTypeNative typeId)
```
    Specified by:
    
    getNativeType in interface TypeIRegistry
  - getNativeObjectType
```
public ObjectType getNativeObjectType(JSTypeNative typeId)
```
    Specified by:
    
    getNativeObjectType in interface TypeIRegistry
  - getNativeFunctionType
```
public FunctionType getNativeFunctionType(JSTypeNative typeId)
```
    Specified by:
    
    getNativeFunctionType in interface TypeIRegistry
  - clearNamedTypes
```
public void clearNamedTypes()
```
    Flushes out the current resolved and unresolved Named Types from the type registry. This is intended to be used ONLY before a compile is run.
  - resolveTypesInScope
```
public void resolveTypesInScope(StaticTypedScope<JSType> scope)
```
    Resolve all the unresolved types in the given scope.
  - evaluateTypeExpressionInGlobalScope
```
public JSType evaluateTypeExpressionInGlobalScope(JSTypeExpression expr)
```
    Specified by:
    
    evaluateTypeExpressionInGlobalScope in interface TypeIRegistry
  - createOptionalType
```
public JSType createOptionalType(JSType type)
```
    Creates a type representing optional values of the given type.
    
    Returns:
    
    the union of the type and the void type
  - createDefaultObjectUnion
```
public JSType createDefaultObjectUnion(JSType type)
```
    Creates a type representing nullable values of the given type.
    
    Returns:
    
    the union of the type and the Null type
  - createNullableType
```
public JSType createNullableType(JSType type)
```
    Creates a type representing nullable values of the given type.
    
    Returns:
    
    the union of the type and the Null type
  - createOptionalNullableType
```
public JSType createOptionalNullableType(JSType type)
```
    Creates a nullable and undefine-able value of the given type.
    
    Returns:
    
    The union of the type and null and undefined.
  - createUnionType
```
public JSType createUnionType(JSType... variants)
```
    Creates a union type whose variants are the arguments.
  - createUnionType
```
public JSType createUnionType(java.util.List<? extends TypeI> variants)
```
    Specified by:
    
    createUnionType in interface TypeIRegistry
  - createUnionType
```
public JSType createUnionType(JSTypeNative... variants)
```
    Creates a union type whose variants are the built-in types specified by the arguments.
  - createEnumType
```
public EnumType createEnumType(java.lang.String name,
                               Node source,
                               JSType elementsType)
```
    Creates an enum type.
  - createFunctionType
```
public FunctionType createFunctionType(JSType returnType,
                                       JSType... parameterTypes)
```
    Creates a function type.
    
    Parameters:
    
    returnType - the function's return type
    
    parameterTypes - the parameters' types
  - createFunctionType
```
public FunctionType createFunctionType(JSType returnType,
                                       Node parameters)
```
    Parameters:
    
    parameters - the function's parameters or null to indicate that the parameter types are unknown.
    
    returnType - the function's return type or null to indicate that the return type is unknown.
  - createFunctionTypeWithVarArgs
```
public FunctionType createFunctionTypeWithVarArgs(JSType returnType,
                                                  JSType... parameterTypes)
```
    Creates a function type. The last parameter type of the function is considered a variable length argument.
    
    Parameters:
    
    returnType - the function's return type
    
    parameterTypes - the parameters' types
  - createFunctionTypeWithInstanceType
```
public JSType createFunctionTypeWithInstanceType(ObjectType instanceType,
                                                 JSType returnType,
                                                 java.util.List<JSType> parameterTypes)
```
    Creates a function type in which this refers to an object instance.
    
    Parameters:
    
    instanceType - the type of this
    
    returnType - the function's return type
    
    parameterTypes - the parameters' types
  - createParameters
```
public Node createParameters(JSType... parameterTypes)
```
    Creates a tree hierarchy representing a typed argument list.
    
    Parameters:
    
    parameterTypes - the parameter types.
    
    Returns:
    
    a tree hierarchy representing a typed argument list.
  - createParametersWithVarArgs
```
public Node createParametersWithVarArgs(JSType... parameterTypes)
```
    Creates a tree hierarchy representing a typed argument list. The last parameter type is considered a variable length argument.
    
    Parameters:
    
    parameterTypes - the parameter types. The last element of this array is considered a variable length argument.
    
    Returns:
    
    a tree hierarchy representing a typed argument list.
  - createOptionalParameters
```
public Node createOptionalParameters(JSType... parameterTypes)
```
    Creates a tree hierarchy representing a typed parameter list in which every parameter is optional.
  - createFunctionTypeWithNewReturnType
```
public FunctionType createFunctionTypeWithNewReturnType(FunctionType existingFunctionType,
                                                        JSType returnType)
```
    Creates a new function type based on an existing function type but with a new return type.
    
    Parameters:
    
    existingFunctionType - the existing function type.
    
    returnType - the new return type.
  - buildRecordTypeFromObject
```
public JSType buildRecordTypeFromObject(ObjectTypeI obj)
```
    Specified by:
    
    buildRecordTypeFromObject in interface TypeIRegistry
  - createRecordType
```
public JSType createRecordType(java.util.Map<java.lang.String,? extends TypeI> props)
```
    Description copied from interface: TypeIRegistry
    
    Creates an anonymous structural type with the given properties.
    
    Specified by:
    
    createRecordType in interface TypeIRegistry
  - createObjectType
```
public ObjectType createObjectType(java.lang.String name,
                                   ObjectType implicitPrototype)
```
    Create an object type.
  - createAnonymousObjectType
```
public ObjectType createAnonymousObjectType(JSDocInfo info)
```
    Create an anonymous object type.
    
    Parameters:
    
    info - Used to mark object literals as structs; can be null
  - resetImplicitPrototype
```
public void resetImplicitPrototype(JSType type,
                                   ObjectType newImplicitProto)
```
    Set the implicit prototype if it's possible to do so. There are a few different reasons why this could be a no-op: for example, numbers can't be implicit prototypes, and we don't want to change the implicit prototype if other classes have already subclassed this one.
  - createConstructorType
```
public FunctionType createConstructorType(java.lang.String name,
                                          Node source,
                                          Node parameters,
                                          JSType returnType,
                                          com.google.common.collect.ImmutableList<TemplateType> templateKeys,
                                          boolean isAbstract)
```
    Creates a constructor function type.
    
    Parameters:
    
    name - the function's name or null to indicate that the function is anonymous.
    
    source - the node defining this function. Its type (Node.getToken() ()}) must be Token.FUNCTION.
    
    parameters - the function's parameters or null to indicate that the parameter types are unknown.
    
    returnType - the function's return type or null to indicate that the return type is unknown.
    
    templateKeys - the templatized types for the class.
    
    isAbstract - whether the function type represents an abstract class
  - createInterfaceType
```
public FunctionType createInterfaceType(java.lang.String name,
                                        Node source,
                                        com.google.common.collect.ImmutableList<TemplateType> templateKeys,
                                        boolean struct)
```
    Creates an interface function type.
    
    Parameters:
    
    name - the function's name
    
    source - the node defining this function. Its type (Node.getToken()) must be Token.FUNCTION.
    
    templateKeys - the templatized types for the interface.
  - createTemplateType
```
public TemplateType createTemplateType(java.lang.String name)
```
  - createTemplateTypeWithTransformation
```
public TemplateType createTemplateTypeWithTransformation(java.lang.String name,
                                                         Node expr)
```
  - createTemplateTypeMap
```
public TemplateTypeMap createTemplateTypeMap(com.google.common.collect.ImmutableList<TemplateType> templateKeys,
                                             com.google.common.collect.ImmutableList<JSType> templateValues)
```
    Creates a template type map from the specified list of template keys and template value types.
  - instantiateGenericsWithUnknown
```
public ObjectTypeI instantiateGenericsWithUnknown(ObjectType obj)
```
  - instantiateGenericType
```
public TypeI instantiateGenericType(ObjectTypeI genericType,
                                    com.google.common.collect.ImmutableList<? extends TypeI> typeArgs)
```
    Description copied from interface: TypeIRegistry
    
    Instantiates genericType using typeArgs. If genericType has fewer type variables than the number of typeArgs, we pad with unknown. If it has more, we drop the extra typeArgs. TODO(dimvar): fix the callers to pass the right number of typeArgs and throw here.
    
    Specified by:
    
    instantiateGenericType in interface TypeIRegistry
  - createTemplatizedType
```
public TemplatizedType createTemplatizedType(ObjectType baseType,
                                             com.google.common.collect.ImmutableList<JSType> templatizedTypes)
```
    Creates a templatized instance of the specified type. Only ObjectTypes can currently be templatized; extend the logic in this function when more types can be templatized.
    
    Parameters:
    
    baseType - the type to be templatized.
    
    templatizedTypes - a list of the template JSTypes. Will be matched by list order to the template keys on the base type.
  - createTemplatizedType
```
public TemplatizedType createTemplatizedType(ObjectType baseType,
                                             java.util.Map<TemplateType,JSType> templatizedTypes)
```
    Creates a templatized instance of the specified type. Only ObjectTypes can currently be templatized; extend the logic in this function when more types can be templatized.
    
    Parameters:
    
    baseType - the type to be templatized.
    
    templatizedTypes - a map from TemplateType to corresponding JSType value. Any unfilled TemplateTypes on the baseType that are *not* contained in this map will have UNKNOWN_TYPE used as their value.
  - createTemplatizedType
```
public TemplatizedType createTemplatizedType(ObjectType baseType,
                                             JSType... templatizedTypes)
```
    Creates a templatized instance of the specified type. Only ObjectTypes can currently be templatized; extend the logic in this function when more types can be templatized.
    
    Parameters:
    
    baseType - the type to be templatized.
    
    templatizedTypes - a list of the template JSTypes. Will be matched by list order to the template keys on the base type.
  - createNamedType
```
public NamedType createNamedType(StaticTypedScope<JSType> scope,
                                 java.lang.String reference,
                                 java.lang.String sourceName,
                                 int lineno,
                                 int charno)
```
    Creates a named type.
  - identifyNonNullableName
```
public void identifyNonNullableName(java.lang.String name)
```
    Identifies the name of a typedef or enum before we actually declare it.
  - evaluateTypeExpression
```
public JSType evaluateTypeExpression(JSTypeExpression expr,
                                     TypeIEnv<TypeI> scope)
```
    Specified by:
    
    evaluateTypeExpression in interface TypeIRegistry
  - createTypeFromCommentNode
```
public JSType createTypeFromCommentNode(Node n)
```
    Specified by:
    
    createTypeFromCommentNode in interface TypeIRegistry
  - createTypeFromCommentNode
```
public JSType createTypeFromCommentNode(Node n,
                                        java.lang.String sourceName,
                                        StaticTypedScope<? extends TypeI> scope)
```
    Creates a JSType from the nodes representing a type.
    
    Parameters:
    
    n - The node with type info.
    
    sourceName - The source file name.
    
    scope - A scope for doing type name lookups.
  - setTemplateTypeNames
```
public void setTemplateTypeNames(java.util.List<TemplateType> keys)
```
    Sets the template type name.
  - clearTemplateTypeNames
```
public void clearTemplateTypeNames()
```
    Clears the template type name.
  - saveContents
```
@GwtIncompatible(value="ObjectOutputStream")
public void saveContents(java.io.ObjectOutputStream out)
                                                               throws java.io.IOException
```
    Saves the derived state. Note: This should be only used when serializing the compiler state and needs to be done at the end, after serializing CompilerState.
    
    Throws:
    
    java.io.IOException
  - restoreContents
```
@GwtIncompatible(value="ObjectInputStream")
public void restoreContents(java.io.ObjectInputStream in)
                                                                 throws java.io.IOException,
                                                                        java.lang.ClassNotFoundException
```
    Restores the derived state. Note: This should be only used when deserializing the compiler state and needs to be done at the end, after deserializing CompilerState.
    
    Throws:
    
    java.io.IOException
    
    java.lang.ClassNotFoundException

Class JSTypeRegistry

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

OBJECT_ELEMENT_TEMPLATE

Constructor Detail

JSTypeRegistry

JSTypeRegistry

Method Detail

getObjectElementKey

getObjectIndexKey

getThenableValueKey

getIterableTemplate

getIteratorTemplate

maybeGetTemplateTypesOfBuiltin

getErrorReporter

resetForTypeCheck

removeType

registerPropertyOnType

unregisterPropertyOnType

getGreatestSubtypeWithProperty

canPropertyBeDefined

getEachReferenceTypeWithProperty

getDirectImplementors

declareType

declareTypeForExactScope

overwriteDeclaredType

overwriteDeclaredType

isForwardDeclaredType

getReadableTypeName

getReadableTypeNameNoDeref

createGetterPropName

createSetterPropName

getTypeForScope

getGlobalType

getType

getType

getNativeType

getNativeObjectType

getNativeFunctionType

clearNamedTypes

resolveTypesInScope

evaluateTypeExpressionInGlobalScope

createOptionalType

createDefaultObjectUnion

createNullableType

createOptionalNullableType

createUnionType

createUnionType

createUnionType

createEnumType

createFunctionType

createFunctionType

createFunctionTypeWithVarArgs

createFunctionTypeWithInstanceType

createParameters

createParametersWithVarArgs

createOptionalParameters

createFunctionTypeWithNewReturnType

buildRecordTypeFromObject

createRecordType

createObjectType

createAnonymousObjectType

resetImplicitPrototype

createConstructorType

createInterfaceType

createTemplateType

createTemplateTypeWithTransformation

createTemplateTypeMap

instantiateGenericsWithUnknown

instantiateGenericType

createTemplatizedType

createTemplatizedType

createTemplatizedType

createNamedType

identifyNonNullableName

evaluateTypeExpression