JSTypeRegistry (Closure Compiler v20170910 API)

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

All Implemented Interfaces:

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

See Also:

Serialized Form

Field Summary

Fields
Modifier and Type Field and Description

static String OBJECT_ELEMENT_TEMPLATE
Deprecated.

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

Constructor Summary

Constructors
Constructor and Description
`JSTypeRegistry(ErrorReporter reporter)`
`JSTypeRegistry(ErrorReporter reporter, Set<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)`
`boolean`	`canPropertyBeDefined(JSType type, 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(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(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, 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.
`String`	`createGetterPropName(String originalPropName)` For NTI, this method returns an obfuscated name that represents the getter.
`FunctionType`	`createInterfaceType(String name, Node source, com.google.common.collect.ImmutableList<TemplateType> templateKeys, boolean struct)` Creates an interface function type.
`NamedType`	`createNamedType(String reference, 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(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(Map<String,? extends TypeI> props)` Creates an anonymous structural type with the given properties.
`String`	`createSetterPropName(String originalPropName)` For NTI, this method returns an obfuscated name that represents the setter.
`TemplateType`	`createTemplateType(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(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, Map<TemplateType,JSType> templatizedTypes)` Creates a templatized instance of the specified type.
`JSType`	`createTypeFromCommentNode(Node n)`
`JSType`	`createTypeFromCommentNode(Node n, 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(List<? extends TypeI> variants)`
`boolean`	`declareType(String name, JSType t)` Records declared global type names.
`JSType`	`evaluateTypeExpression(JSTypeExpression expr, TypeIEnv<TypeI> scope)`
`JSType`	`evaluateTypeExpressionInGlobalScope(JSTypeExpression expr)`
`Collection<FunctionTypeI>`	`getDirectImplementors(ObjectType interfaceInstance)` Returns a collection of types that directly implement `interfaceInstance`.
`Iterable<ObjectType>`	`getEachReferenceTypeWithProperty(String propertyName)` Returns each reference type that has a property `propertyName` defined on it.
`ErrorReporter`	`getErrorReporter()`
`JSType`	`getGreatestSubtypeWithProperty(JSType type, String propertyName)` Gets the greatest subtype of the `type` that has a property `propertyName` defined on it.
`FunctionType`	`getNativeFunctionType(JSTypeNative typeId)`
`ObjectType`	`getNativeObjectType(JSTypeNative typeId)`
`JSType`	`getNativeType(JSTypeNative typeId)`
`TemplateType`	`getObjectElementKey()`
`TemplateType`	`getObjectIndexKey()`
`String`	`getReadableTypeName(Node n)` The nice API for this method is a single argument; dereference is a detail.
`String`	`getReadableTypeNameNoDeref(Node n)`
`com.google.common.collect.ImmutableList<TemplateType>`	`getTemplateTypesOfBuiltin(String fnName)`
`JSType`	`getType(StaticTypedScope<JSType> scope, String jsTypeName, String sourceName, int lineno, int charno)` Looks up a type by name.
`JSType`	`getType(String jsTypeName)` Looks up a native type by name.
`void`	`identifyNonNullableName(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(String name)` Whether this is a forward-declared type name.
`boolean`	`isTemplatedBuiltin(String fnName, JSDocInfo info)` Check if a function declaration is one of the templated builitin contructor/interfaces, namely one of IObject, IArrayLike, or Array
`void`	`overwriteDeclaredType(String name, JSType t)` Overrides a declared global type name.
`void`	`registerPropertyOnType(String propertyName, JSType type)` Tells the type system that `owner` may have a property named `propertyName`.
`void`	`removeType(String jsTypeName)` Removes a type by name.
`void`	`resetForTypeCheck()` Reset to run the TypeCheck pass.
`boolean`	`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(ObjectInputStream in)` Restores the derived state.
`void`	`saveContents(ObjectOutputStream out)` Saves the derived state.
`void`	`setOptimizePropertyIndex_TRANSITIONAL_METHOD(boolean optimizePropIndex)`
`void`	`setTemplateTypeNames(List<TemplateType> keys)` Sets the template type name.
`void`	`unregisterPropertyOnType(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 String OBJECT_ELEMENT_TEMPLATE
```
    Deprecated.
    
    See Also:
    
    Constant Field Values
- Constructor Detail
  - JSTypeRegistry
```
public JSTypeRegistry(ErrorReporter reporter)
```
  - JSTypeRegistry
```
public JSTypeRegistry(ErrorReporter reporter,
                      Set<String> forwardDeclaredTypes)
```
    Constructs a new type registry populated with the built-in types.
- Method Detail
  - setOptimizePropertyIndex_TRANSITIONAL_METHOD
```
public void setOptimizePropertyIndex_TRANSITIONAL_METHOD(boolean optimizePropIndex)
```
  - 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.
  - isTemplatedBuiltin
```
public boolean isTemplatedBuiltin(String fnName,
                                  JSDocInfo info)
```
    Check if a function declaration is one of the templated builitin contructor/interfaces, namely one of IObject, IArrayLike, or Array
    
    Parameters:
    
    fnName - the function's name
    
    info - the JSDoc from the function declaration
  - getTemplateTypesOfBuiltin
```
public com.google.common.collect.ImmutableList<TemplateType> getTemplateTypesOfBuiltin(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.
  - registerPropertyOnType
```
public void registerPropertyOnType(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(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,
                                             String propertyName)
```
    Gets the greatest subtype of the type that has a property propertyName defined on it.
  - canPropertyBeDefined
```
public boolean canPropertyBeDefined(JSType type,
                                    String propertyName)
```
    Returns whether the given property can possibly be set on the given type.
  - getEachReferenceTypeWithProperty
```
public Iterable<ObjectType> getEachReferenceTypeWithProperty(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 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(String name,
                           JSType t)
```
    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.
    
    t - The actual type being associated with the name.
    
    Returns:
    
    True if this name is not already defined, false otherwise.
  - overwriteDeclaredType
```
public void overwriteDeclaredType(String name,
                                  JSType t)
```
    Overrides a declared global type name. Throws an exception if this type name hasn't been declared yet.
  - isForwardDeclaredType
```
public boolean isForwardDeclaredType(String name)
```
    Whether this is a forward-declared type name.
  - getReadableTypeName
```
public 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 String getReadableTypeNameNoDeref(Node n)
```
  - createGetterPropName
```
public String createGetterPropName(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 String createSetterPropName(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
  - removeType
```
public void removeType(String jsTypeName)
```
    Removes a type by name.
    
    Parameters:
    
    jsTypeName - The name string.
  - getType
```
public JSType getType(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
  - 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
  - getType
```
public JSType getType(StaticTypedScope<JSType> scope,
                      String jsTypeName,
                      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.
  - 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(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(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
  - 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,
                                                 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.
  - 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.
  - buildRecordTypeFromObject
```
public JSType buildRecordTypeFromObject(ObjectTypeI obj)
```
    Specified by:
    
    buildRecordTypeFromObject in interface TypeIRegistry
  - createRecordType
```
public JSType createRecordType(Map<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(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 boolean resetImplicitPrototype(JSType type,
                                      ObjectType newImplicitProto)
```
    Set the implicit prototype if it's possible to do so.
    
    Returns:
    
    True if we were able to set the implicit prototype successfully, false if it was not possible to do so for some reason. There are a few different reasons why this could fail: 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(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(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(String name)
```
  - createTemplateTypeWithTransformation
```
public TemplateType createTemplateTypeWithTransformation(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,
                                             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(String reference,
                                 String sourceName,
                                 int lineno,
                                 int charno)
```
    Creates a named type.
  - identifyNonNullableName
```
public void identifyNonNullableName(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,
                                        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(List<TemplateType> keys)
```
    Sets the template type name.
  - clearTemplateTypeNames
```
public void clearTemplateTypeNames()
```
    Clears the template type name.
  - saveContents
```
@GwtIncompatible(value="ObjectOutputStream")
public void saveContents(ObjectOutputStream out)
                                                               throws 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:
    
    IOException
  - restoreContents
```
@GwtIncompatible(value="ObjectInputStream")
public void restoreContents(ObjectInputStream in)
                                                                 throws IOException,
                                                                        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:
    
    IOException
    
    ClassNotFoundException

Class JSTypeRegistry

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

OBJECT_ELEMENT_TEMPLATE

Constructor Detail

JSTypeRegistry

JSTypeRegistry

Method Detail

setOptimizePropertyIndex_TRANSITIONAL_METHOD

getObjectElementKey

getObjectIndexKey

isTemplatedBuiltin

getTemplateTypesOfBuiltin

getErrorReporter

resetForTypeCheck

registerPropertyOnType

unregisterPropertyOnType

getGreatestSubtypeWithProperty

canPropertyBeDefined

getEachReferenceTypeWithProperty

getDirectImplementors

declareType

overwriteDeclaredType

isForwardDeclaredType

getReadableTypeName

getReadableTypeNameNoDeref

createGetterPropName

createSetterPropName

removeType

getType

getNativeType

getNativeObjectType

getNativeFunctionType

getType

clearNamedTypes

resolveTypesInScope

evaluateTypeExpressionInGlobalScope

createOptionalType

createDefaultObjectUnion

createNullableType

createOptionalNullableType

createUnionType

createUnionType

createUnionType

createEnumType

createFunctionType

createFunctionTypeWithVarArgs

createFunctionTypeWithInstanceType

createParameters

createParametersWithVarArgs

createOptionalParameters

createFunctionTypeWithNewReturnType

createFunctionType

buildRecordTypeFromObject

createRecordType

createObjectType

createAnonymousObjectType

resetImplicitPrototype

createConstructorType

createInterfaceType

createTemplateType

createTemplateTypeWithTransformation

createTemplateTypeMap

instantiateGenericsWithUnknown

instantiateGenericType

createTemplatizedType

createTemplatizedType

createTemplatizedType

createNamedType

identifyNonNullableName

evaluateTypeExpression

createTypeFromCommentNode

createTypeFromCommentNode

setTemplateTypeNames

clearTemplateTypeNames

saveContents

restoreContents