diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index f29204f7ca1..d3e1eeb08e2 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -2190,20 +2190,34 @@ namespace ts {
         }
 
         function createTypeNode(type: Type) {
-            // let encounteredError = false;
+            let undefinedArgumentIsError = true;
+            let encounteredError = false;
             let checkAlias = true;
 
             return createTypeNodeWorker(type);
 
             // function createTypeDeclaration(type: Type): Declaration {
             //     if (!type) {
+            //         if (undefinedArgumentIsError) { encounteredError = true; }
             //         return undefined;
             //     }
-            //     throw new Error("not implemented.");
+            //     if (type.flags & TypeFlags.TypeParameter) {
+            //         const constraint = createTypeNodeWorker(getConstraintFromTypeParameter(<TypeParameter>type)) as TypeNode;
+            //         const defaultParameter = createTypeNodeWorker(getDefaultFromTypeParameter(<TypeParameter>type)) as TypeNode;
+            //         if (!type.symbol) {
+            //             encounteredError = true;
+            //             throw new Error("No symbol for type parameter so can't get name");
+            //         }
+            //         const name = getNameOfSymbol(type.symbol);
+            //         return createTypeParameterDeclaration(name, constraint, defaultParameter);
+            //     }
+
+            //     throw new Error("type declarations not implemented.");
             // }
 
             function createTypeNodeWorker(type: Type): TypeNode {
                 if (!type) {
+                    if (undefinedArgumentIsError) { encounteredError = true; }
                     return undefined;
                 }
 
@@ -2229,11 +2243,9 @@ namespace ts {
                     return createKeywordTypeNode(SyntaxKind.BooleanKeyword);
                 }
                 if (type.flags & (TypeFlags.StringLiteral)) {
-                    // TODO: check if this actually works with boolean.
                     return createLiteralTypeNode((createLiteral((<LiteralType>type).text)));
                 }
                 if (type.flags & (TypeFlags.NumberLiteral)) {
-                    // TODO: check if this actually works with boolean.
                     return createLiteralTypeNode((createNumericLiteral((<LiteralType>type).text)));
                 }
                 if (type.flags & TypeFlags.Void) {
@@ -2249,40 +2261,27 @@ namespace ts {
                     return createKeywordTypeNode(SyntaxKind.NeverKeyword);
                 }
                 if (type.flags & TypeFlags.Enum) {
-                    throw new Error("not implemented");
+                    throw new Error("enum not implemented");
                 }
                 if (type.flags & TypeFlags.ESSymbol) {
-                    throw new Error("not implemented");
+                    throw new Error("ESSymbol not implemented");
                 }
                 if (type.flags & TypeFlags.TypeParameter) {
                     throw new Error("Type Parameter declarations only handled in other worker.");
-                    // const constraint = createTypeNodeWorker(getConstraintFromTypeParameter(<TypeParameter>type)) as TypeNode;
-                    // const defaultParameter = createTypeNodeWorker(getDefaultFromTypeParameter(<TypeParameter>type)) as TypeNode;
-                    // 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");
+                    return createUnionOrIntersectionTypeNode(SyntaxKind.UnionType, mapToTypeNodeArray((type as UnionType).types));
                 }
                 if (type.flags & TypeFlags.Intersection) {
-                    throw new Error("not implemented");
+                    return createUnionOrIntersectionTypeNode(SyntaxKind.IntersectionType, mapToTypeNodeArray((type as UnionType).types));
                 }
                 if (type.flags & TypeFlags.Index) {
-                    throw new Error("not implemented");
+                    throw new Error("index not implemented");
                 }
                 if (type.flags & TypeFlags.IndexedAccess) {
-                    throw new Error("not implemented");
+                    throw new Error("indexed access 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) {
@@ -2390,10 +2389,6 @@ namespace ts {
                 function mapToTypeNodeArray(types: Type[]): NodeArray<TypeNode> {
                     return asNodeArray(types && types.map(createTypeNodeWorker) as TypeNode[]);
                 }
-
-                // function mapToTypeDeclarationsArray(types: Type[]): NodeArray<Declaration> {
-                //     return asNodeArray(types && types.map(createTypeDeclaration));
-                // }
             }
         }
 
diff --git a/src/compiler/factory.ts b/src/compiler/factory.ts
index 901f3a4bd17..6e10d8bb22b 100644
--- a/src/compiler/factory.ts
+++ b/src/compiler/factory.ts
@@ -273,10 +273,9 @@ namespace ts {
         return unionTypeNode;
     }
 
-    export function updateUnionOrIntersectionTypeNode(node: UnionOrIntersectionTypeNode, kind: SyntaxKind.UnionType | SyntaxKind.IntersectionType, types: NodeArray<TypeNode>) {
+    export function updateUnionOrIntersectionTypeNode(node: UnionOrIntersectionTypeNode, types: NodeArray<TypeNode>) {
         return node.types !== types
-            || node.kind !== kind
-            ? updateNode(createUnionOrIntersectionTypeNode(kind, types), node)
+            ? updateNode(createUnionOrIntersectionTypeNode(node.kind, types), node)
             : node;
     }
 
diff --git a/src/compiler/visitor.ts b/src/compiler/visitor.ts
index 91110accbb0..bd2d26b7753 100644
--- a/src/compiler/visitor.ts
+++ b/src/compiler/visitor.ts
@@ -275,39 +275,40 @@ namespace ts {
             // Types
 
             case SyntaxKind.TypePredicate:
-                throw new Error("reached unsupported type.");
+                throw new Error("reached unsupported type in visitor.");
             case SyntaxKind.TypeReference:
                 return updateTypeReferenceNode(<TypeReferenceNode>node
                      , visitNode((<TypeReferenceNode>node).typeName as Identifier, visitor)
                      , nodesVisitor((<TypeReferenceNode>node).typeArguments, visitor)
                 );
             case SyntaxKind.FunctionType:
-                throw new Error("reached unsupported type.");
+                throw new Error("reached unsupported type in visitor.");
             case SyntaxKind.ConstructorType:
-                throw new Error("reached unsupported type.");
+                throw new Error("reached unsupported type in visitor.");
             case SyntaxKind.TypeQuery:
-                throw new Error("reached unsupported type.");
+                throw new Error("reached unsupported type in visitor.");
             case SyntaxKind.TypeLiteral:
-                throw new Error("reached unsupported type.");
+                throw new Error("reached unsupported type in visitor.");
             case SyntaxKind.ArrayType:
-                throw new Error("reached unsupported type.");
+                throw new Error("reached unsupported type in visitor.");
             case SyntaxKind.TupleType:
-                throw new Error("reached unsupported type.");
+                throw new Error("reached unsupported type in visitor.");
             case SyntaxKind.UnionType:
             case SyntaxKind.IntersectionType:
-                throw new Error("reached unsupported type.");
+                return updateUnionOrIntersectionTypeNode(<UnionOrIntersectionTypeNode>node
+                , nodesVisitor((<UnionOrIntersectionTypeNode>node).types, visitor, isTypeNode));
             case SyntaxKind.ParenthesizedType:
-                throw new Error("reached unsupported type.");
+                throw new Error("reached unsupported type in visitor.");
             case SyntaxKind.ThisType:
-                throw new Error("reached unsupported type.");
+                throw new Error("reached unsupported type in visitor.");
             case SyntaxKind.TypeOperator:
-                throw new Error("reached unsupported type.");
+                throw new Error("reached unsupported type in visitor.");
             case SyntaxKind.IndexedAccessType:
-                throw new Error("reached unsupported type.");
+                throw new Error("reached unsupported type in visitor.");
             case SyntaxKind.MappedType:
-                throw new Error("reached unsupported type.");
+                throw new Error("reached unsupported type in visitor.");
             case SyntaxKind.LiteralType:
-                throw new Error("reached unsupported type.");
+                throw new Error("reached unsupported type in visitor.");
 
             // Type Declarations