function createTypeNode(type: Type) {

let encounteredError = false;

let checkAlias = true;

return createTypeNodeWorker(type);

function createTypeNodeWorker(type: Type): TypeNode {

if(!type) {

return undefined;

}

if (checkAlias && type.aliasSymbol) {

const name = getNameOfSymbol(type.aliasSymbol);

const typeArguments = mapToTypeNodeArray(type.aliasTypeArguments);

return createTypeReferenceNode(createIdentifier(name), typeArguments);

}

checkAlias = false;

if(type.flags & TypeFlags.Any) {

// TODO: add other case where type ends up being `any`.

return createKeywordTypeNode(SyntaxKind.StringKeyword);

}

if(type.flags & TypeFlags.String) {

return createKeywordTypeNode(SyntaxKind.StringKeyword);

}

if(type.flags & TypeFlags.Number) {

return createKeywordTypeNode(SyntaxKind.NumberKeyword);

}

if(type.flags & (TypeFlags.Boolean | TypeFlags.StringOrNumberLiteral)) {

// TODO: check if this actually works with boolean.

return createLiteralTypeNode((<LiteralType>type).text);

}

if(type.flags & TypeFlags.Void) {

return createKeywordTypeNode(SyntaxKind.VoidKeyword);

}

if(type.flags & TypeFlags.Undefined) {

return createKeywordTypeNode(SyntaxKind.UndefinedKeyword);

}

if(type.flags & TypeFlags.Null) {

return createKeywordTypeNode(SyntaxKind.NullKeyword);

}

if(type.flags & TypeFlags.Never) {

return createKeywordTypeNode(SyntaxKind.NeverKeyword);

}

if(type.flags & TypeFlags.Enum) {

throw new Error("not implemented");

}

if(type.flags & TypeFlags.ESSymbol) {

throw new Error("not implemented");

}

if(type.flags & TypeFlags.TypeParameter) {

const constraint = createTypeNodeWorker(getConstraintFromTypeParameter(<TypeParameter>type));

const defaultParameter = createTypeNodeWorker(getDefaultFromTypeParameter(<TypeParameter>type));

if(!type.symbol) {

encounteredError = true;

throw new Error("No symbol for type parameter so can't get name");

}

const name = getNameOfSymbol(type.symbol);

return createTypeParameterNode(name, constraint, defaultParameter);

}

if(type.flags & TypeFlags.Union) {

throw new Error("not implemented");

}

if(type.flags & TypeFlags.Intersection) {

throw new Error("not implemented");

}

if(type.flags & TypeFlags.Index) {

throw new Error("not implemented");

}

if(type.flags & TypeFlags.IndexedAccess) {

throw new Error("not implemented");

}

// if(type.flags & TypeFlags.Object) {

// throw new Error("not implemented");

// }

// TODO: should these be within the if above (check with asserts)

const objectFlags = getObjectFlags(type);

if (objectFlags & ObjectFlags.ClassOrInterface) {

Debug.assert(!!(type.flags & TypeFlags.Object));

// If type is a class or interface type that wasn't hit by the isSymbolAccessible check above,

// type must be an anonymous class or interface.

return false;

}

if (objectFlags & ObjectFlags.Reference) {

Debug.assert(!!(type.flags & TypeFlags.Object));

// and vice versa.

// this case includes tuple types

const typeArguments = (type as TypeReference).typeArguments || emptyArray;

return allTypesVisible(typeArguments);

}

// keyword types

// this type node

// function type node

// constructor type node

// type reference node

// type predicate node - is Foo (for return types)

// type query node -- typeof number

// type literal node (like object literal)

// array type

// tuple type

// union type

// might need parens

// intersection type

// Type operator node (eg (ie?): keyof T)

// IndexedAccess Type Node

// mapped type node

// literal type node

// if (inTypeAlias && type.aliasSymbol) {

// return isSymbolAccessible(type.aliasSymbol, enclosingDeclaration, SymbolFlags.Type, /*shouldComputeAliasesToMakeVisible*/false).accessibility === SymbolAccessibility.Accessible

// && (!type.aliasTypeArguments || allTypesVisible(type.aliasTypeArguments));

// }

// const typeSymbolAccessibility = type.symbol && isSymbolAccessible(type.symbol, enclosingDeclaration, SymbolFlags.Type, /*shouldComputeAliasesToMakeVisible*/ false).accessibility;

// if (type.flags & TypeFlags.TypeParameter) {

// if (inObjectLiteral && (type as TypeParameter).isThisType) {

// return false;

// }

// const constraint = getConstraintFromTypeParameter((<TypeParameter>type));

// return typeSymbolAccessibility === SymbolAccessibility.Accessible

// && (!constraint || isTypeAccessibleWorker(constraint, inObjectLiteral, /*inTypeAlias*/false));

// }

// if (typeSymbolAccessibility === SymbolAccessibility.Accessible) {

// return true;

// }

// if (type.flags & (TypeFlags.Intrinsic | TypeFlags.Literal)) {

// return true;

// }

// const objectFlags = getObjectFlags(type);

// if (objectFlags & ObjectFlags.ClassOrInterface) {

// // If type is a class or interface type that wasn't hit by the isSymbolAccessible check above,

// // type must be an anonymous class or interface.

// return false;

// }

// if (objectFlags & ObjectFlags.Reference) {

// // and vice versa.

// // this case includes tuple types

// const typeArguments = (type as TypeReference).typeArguments || emptyArray;

// return allTypesVisible(typeArguments);

// }

// if (type.flags & TypeFlags.UnionOrIntersection) {

// return allTypesVisible((type as UnionOrIntersectionType).types);

// }

if (objectFlags & ObjectFlags.Mapped) {

Debug.assert(!!(type.flags & TypeFlags.Object));

const typeParameter = getTypeParameterFromMappedType(<MappedType>type);

const constraintType = getConstraintTypeFromMappedType(<MappedType>type);

const templateType = getTemplateTypeFromMappedType(<MappedType>type);

}

if (objectFlags & ObjectFlags.Anonymous) {

Debug.assert(!!(type.flags & TypeFlags.Object));

// The type is an object literal type.

if (!type.symbol) {

// Anonymous types without symbols are literals.

return true;

}

// what case is this?

const members = type.symbol.members;

let allVisible = true;

members && members.forEach((member) => {

const memberType = getTypeOfSymbolAtLocation(member, enclosingDeclaration);

allVisible = allVisible && isTypeAccessibleWorker(memberType, /*inObjectLiteral*/ true, /*inTypeAlias*/false);

});

return allVisible;

}

Debug.fail("Should be unreachable here");

/** Note that mapToTypeNodeArray(undefined) === undefined. */

function mapToTypeNodeArray(types: Type[]): NodeArray<TypeNode> {

return asNodeArray(types && types.map(createTypeNodeWorker));

}

// function allTypesVisible(types: Type[]): boolean {

// return types.every(type => isTypeAccessibleWorker(type, inObjectLiteral, /*inTypeAlias*/false));

// }

}

}

const typeNode = createTypeNode(type, enclosingDeclaration);

// export function synthesizeTypeNode(type: Type, enclosingDeclaration: Node): TypeNode {

// throw new Error("Not implemented" + enclosingDeclaration);

// }

// Types

export function createLiteralTypeNode(value: string | number | boolean) {

const literal = createLiteral(value);

const literalTypeNode = createSynthesizedNode(SyntaxKind.LiteralType) as LiteralTypeNode;

literalTypeNode.literal = literal;

return literalTypeNode;

}

export function createTypeReferenceNode(typeName: string | EntityName, typeArguments?: NodeArray<TypeNode>) {

const typeReference = createSynthesizedNode(SyntaxKind.TypeReference) as TypeReferenceNode;

typeReference.typeName = asName(typeName);

typeReference.typeName.parent

typeReference.typeArguments = typeArguments;

return typeReference;

}

export function createTypeParameterNode(name: string | Identifier, constraint?: TypeNode, defaultParameter?: TypeNode) {

const typeParameter = createSynthesizedNode(SyntaxKind.TypeParameter) as TypeParameterDeclaration;

typeParameter.name = asName(name);

typeParameter.constraint = constraint;

typeParameter.default = defaultParameter;

return typeParameter;

}

export function createSignature(kind: SyntaxKind, parameters: NodeArray<ParameterDeclaration>, name?: PropertyName, typeParameters?: NodeArray<TypeParameterDeclaration>, returnType?: TypeNode): SignatureDeclaration {

const signature = createSynthesizedNode(kind) as SignatureDeclaration;

signature.parameters = parameters;

signature.name = name;

signature.typeParameters = typeParameters;

signature.type = returnType;

return signature;

}

export function asNodeArray<T extends Node>(array: T[] | undefined): NodeArray<T> | undefined {

export type KeywordKind = SyntaxKind.AnyKeyword

| SyntaxKind.NumberKeyword

| SyntaxKind.ObjectKeyword

| SyntaxKind.BooleanKeyword

| SyntaxKind.StringKeyword

| SyntaxKind.SymbolKeyword

| SyntaxKind.VoidKeyword

| SyntaxKind.UndefinedKeyword

| SyntaxKind.NullKeyword

| SyntaxKind.NeverKeyword;

kind: KeywordKind;

/** A TypeLiteral is the declaration node for an anonymous symbol. */