TypeDeclarationsIRFactory (Closure Compiler v20150505 API)

java.lang.Object
- com.google.javascript.jscomp.parsing.TypeDeclarationsIRFactory

```
public final class TypeDeclarationsIRFactory
extends Object
```
Produces ASTs which represent JavaScript type declarations, both those created from closure-style type declarations in a JSDoc node (via a conversion from the rhino AST produced in IRFactory) as well as those created from TypeScript-style inline type declarations.
This is an alternative to the AST found in the root property of JSTypeExpression, which is a crufty AST that reuses language tokens.

Author:

alexeagle@google.com (Alex Eagle)

Constructor Summary

Constructors
Constructor and Description

TypeDeclarationsIRFactory()

Constructors
Constructor and Description
`TypeDeclarationsIRFactory()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static Node.TypeDeclarationNode`	`anyType()` Equivalent to the UNKNOWN type in Closure, expressed with `{?}`
`static Node.TypeDeclarationNode`	`arrayType(Node elementType)` Represents an array type.
`static Node.TypeDeclarationNode`	`booleanType()`
`static Node.TypeDeclarationNode`	`convert(JSTypeExpression typeExpr)`
`static Node.TypeDeclarationNode`	`convertTypeNodeAST(Node n)` The root of a JSTypeExpression is very different from an AST node, even though we use the same Java class to represent them.
`static Node.TypeDeclarationNode`	`functionType(Node returnType, LinkedHashMap<String,Node.TypeDeclarationNode> parameters, String restName, Node.TypeDeclarationNode restType)` Represents a function type.
`static Node.TypeDeclarationNode`	`namedType(Iterable<String> segments)` Produces a tree structure similar to the Rhino AST of a qualified name expression, under a top-level NAMED_TYPE node.
`static Node.TypeDeclarationNode`	`namedType(String typeName)` Splits a '.' separated qualified name into a tree of type segments.
`static Node.TypeDeclarationNode`	`nullable(Node.TypeDeclarationNode type)` We assume that types are non-nullable by default.
`static Node.TypeDeclarationNode`	`numberType()`
`static Node.TypeDeclarationNode`	`optionalParameter(Node.TypeDeclarationNode parameterType)` Represents a function parameter that is optional.
`static Node.TypeDeclarationNode`	`parameterizedType(Node.TypeDeclarationNode baseType, Iterable<Node.TypeDeclarationNode> typeParameters)` Represents a parameterized, or generic, type.
`static Node.TypeDeclarationNode`	`recordType(LinkedHashMap<String,Node.TypeDeclarationNode> properties)` Represents a structural type.
`static Node.TypeDeclarationNode`	`restParams(Node type)` Represents a function parameter type which may be repeated.
`static Node.TypeDeclarationNode`	`stringType()`
`static Node.TypeDeclarationNode`	`undefinedType()`
`static Node.TypeDeclarationNode`	`unionType(Iterable<Node.TypeDeclarationNode> options)` Represents a union type, which can be one of the given types.
`static Node.TypeDeclarationNode`	`unionType(Node.TypeDeclarationNode... options)`
`static Node.TypeDeclarationNode`	`voidType()`

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

- Constructor Detail
  - TypeDeclarationsIRFactory
```
public TypeDeclarationsIRFactory()
```
- Method Detail
  - stringType
```
public static Node.TypeDeclarationNode stringType()
```
    Returns:
    
    a new node representing the string built-in type.
  - numberType
```
public static Node.TypeDeclarationNode numberType()
```
    Returns:
    
    a new node representing the number built-in type.
  - booleanType
```
public static Node.TypeDeclarationNode booleanType()
```
    Returns:
    
    a new node representing the boolean built-in type.
  - nullable
```
public static Node.TypeDeclarationNode nullable(Node.TypeDeclarationNode type)
```
    We assume that types are non-nullable by default. Wrap a type in nullable to indicate that it should be allowed to take a null value. NB: this is not currently supported in TypeScript so it is not printed in the CodeGenerator for ES6_TYPED.
    
    Returns:
    
    a new node indicating that the nested type is nullable
  - anyType
```
public static Node.TypeDeclarationNode anyType()
```
    Equivalent to the UNKNOWN type in Closure, expressed with {?}
    
    Returns:
    
    a new node representing any type, without type checking.
  - voidType
```
public static Node.TypeDeclarationNode voidType()
```
    Returns:
    
    a new node representing the Void type as defined by TypeScript.
  - undefinedType
```
public static Node.TypeDeclarationNode undefinedType()
```
    Returns:
    
    a new node representing the Undefined type as defined by TypeScript.
  - namedType
```
public static Node.TypeDeclarationNode namedType(String typeName)
```
    Splits a '.' separated qualified name into a tree of type segments.
    
    Parameters:
    
    typeName - a qualified name such as "goog.ui.Window"
    
    Returns:
    
    a new node representing the type
    
    See Also:
    
    namedType(Iterable)
  - namedType
```
public static Node.TypeDeclarationNode namedType(Iterable<String> segments)
```
    Produces a tree structure similar to the Rhino AST of a qualified name expression, under a top-level NAMED_TYPE node.
    Example:
```
 NAMED_TYPE
   NAME goog
     STRING ui
       STRING Window
 
```
  - recordType
```
public static Node.TypeDeclarationNode recordType(LinkedHashMap<String,Node.TypeDeclarationNode> properties)
```
    Represents a structural type. Closure calls this a Record Type and accepts the syntax {myNum: number, myObject}
    Example:
```
 RECORD_TYPE
   STRING_KEY myNum
     NUMBER_TYPE
   STRING_KEY myObject
 
```
    Parameters:
    
    properties - a map from property name to property type
    
    Returns:
    
    a new node representing the record type
  - functionType
```
public static Node.TypeDeclarationNode functionType(Node returnType,
                                                    LinkedHashMap<String,Node.TypeDeclarationNode> parameters,
                                                    String restName,
                                                    Node.TypeDeclarationNode restType)
```
    Represents a function type. Closure has syntax like {function(string, boolean):number} Closure doesn't include parameter names. If the parameter types are unnamed, arbitrary names can be substituted, eg. p1, p2, etc.
    Example:
```
 FUNCTION_TYPE
   NUMBER_TYPE
   STRING_KEY p1
     STRING_TYPE
   STRING_KEY p2
     BOOLEAN_TYPE
 
```
    Parameters:
    
    returnType - the type returned by the function, possibly UNKNOWN_TYPE
    
    parameters - the types of the parameters.
  - parameterizedType
```
public static Node.TypeDeclarationNode parameterizedType(Node.TypeDeclarationNode baseType,
                                                         Iterable<Node.TypeDeclarationNode> typeParameters)
```
    Represents a parameterized, or generic, type. Closure calls this a Type Application and accepts syntax like {Object.<string, number>}
    Example:
```
 PARAMETERIZED_TYPE
   NAMED_TYPE
     NAME Object
   STRING_TYPE
   NUMBER_TYPE
 
```
    Parameters:
    
    baseType -
    
    typeParameters -
  - arrayType
```
public static Node.TypeDeclarationNode arrayType(Node elementType)
```
    Represents an array type. In Closure, this is represented by a parameterized type of Array with elementType as the sole type parameter.
    Example
```
 ARRAY_TYPE
   elementType
 
```
  - unionType
```
public static Node.TypeDeclarationNode unionType(Iterable<Node.TypeDeclarationNode> options)
```
    Represents a union type, which can be one of the given types. Closure accepts syntax like {(number|boolean)}
    Example:
```
 UNION_TYPE
   NUMBER_TYPE
   BOOLEAN_TYPE
 
```
    Parameters:
    
    options - the types which are accepted
    
    Returns:
    
    a new node representing the union type
  - unionType
```
public static Node.TypeDeclarationNode unionType(Node.TypeDeclarationNode... options)
```
  - restParams
```
public static Node.TypeDeclarationNode restParams(Node type)
```
    Represents a function parameter type which may be repeated. Closure calls this Variable Parameters and accepts a syntax like {function(string, ...number): number}
```
 FUNCTION_TYPE
   NUMBER_TYPE
   STRING_KEY p1
     STRING_TYPE
   REST_PARAMETER_TYPE
     STRING_KEY p2
       NUMBER_TYPE
 
```
    Parameters:
    
    type - an array type that is seen inside the function body
    
    Returns:
    
    a new node representing the function parameter type
  - optionalParameter
```
public static Node.TypeDeclarationNode optionalParameter(Node.TypeDeclarationNode parameterType)
```
    Represents a function parameter that is optional. In closure syntax, this is function(?string=, number=) In TypeScript syntax, it is (firstName: string, lastName?: string)=>string
    
    Parameters:
    
    parameterType - the type of the parameter
    
    Returns:
    
    a new node representing the function parameter type
  - convert
```
@Nullable
public static Node.TypeDeclarationNode convert(@Nullable
                                                         JSTypeExpression typeExpr)
```
  - convertTypeNodeAST
```
@Nullable
public static Node.TypeDeclarationNode convertTypeNodeAST(Node n)
```
    The root of a JSTypeExpression is very different from an AST node, even though we use the same Java class to represent them. This function converts root nodes of JSTypeExpressions into TypeDeclaration ASTs, to make them more similar to ordinary AST nodes.
    
    Returns:
    
    the root node of a TypeDeclaration AST, or null if no type is available for the node.

Class TypeDeclarationsIRFactory

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

TypeDeclarationsIRFactory

Method Detail

stringType

numberType

booleanType

nullable

anyType

voidType

undefinedType

namedType

namedType

recordType

functionType

parameterizedType

arrayType

unionType

unionType

restParams

optionalParameter

convert

convertTypeNodeAST