Fill out remaining factory functions

Author: rbuckton

src/compiler/checker.ts

@@ -2389,7 +2389,7 @@ namespace ts {
                     const formattedUnionTypes = formatUnionTypes((<UnionType>type).types);
                     const unionTypeNodes = formattedUnionTypes && mapToTypeNodeArray(formattedUnionTypes);
                     if (unionTypeNodes && unionTypeNodes.length > 0) {
-                        return createUnionOrIntersectionTypeNode(SyntaxKind.UnionType, unionTypeNodes);
+                        return createUnionTypeNode(unionTypeNodes);
                     }
                     else {
                         if (!context.encounteredError && !(context.flags & NodeBuilderFlags.allowEmptyUnionOrIntersection)) {
@@ -2400,7 +2400,7 @@ namespace ts {
                 }
 
                 if (type.flags & TypeFlags.Intersection) {
-                    return createUnionOrIntersectionTypeNode(SyntaxKind.IntersectionType, mapToTypeNodeArray((type as UnionType).types));
+                    return createIntersectionTypeNode(mapToTypeNodeArray((type as IntersectionType).types));
                 }
 
                 if (objectFlags & (ObjectFlags.Anonymous | ObjectFlags.Mapped)) {
@@ -2660,7 +2660,7 @@ namespace ts {
                     indexerTypeNode,
                     /*initializer*/ undefined);
                 const typeNode = typeToTypeNodeHelper(indexInfo.type);
-                return createIndexSignatureDeclaration(
+                return createIndexSignature(
                     /*decorators*/ undefined,
                     indexInfo.isReadonly ? [createToken(SyntaxKind.ReadonlyKeyword)] : undefined,
                     [indexingParameter],

src/compiler/factory.ts

@@ -1506,7 +1506,7 @@ namespace ts {
     //       for the same reasons we treat NewExpression as a PrimaryExpression.
     export interface MetaProperty extends PrimaryExpression {
         kind: SyntaxKind.MetaProperty;
-        keywordToken: SyntaxKind;
+        keywordToken: SyntaxKind.NewKeyword;
         name: Identifier;
     }
 

src/compiler/types.ts

@@ -3649,7 +3649,18 @@ namespace ts {
             || kind === SyntaxKind.GetAccessor
             || kind === SyntaxKind.SetAccessor
             || kind === SyntaxKind.IndexSignature
-            || kind === SyntaxKind.SemicolonClassElement;
+            || kind === SyntaxKind.SemicolonClassElement
+            || kind === SyntaxKind.MissingDeclaration;
+    }
+
+    export function isTypeElement(node: Node): node is TypeElement {
+        const kind = node.kind;
+        return kind === SyntaxKind.ConstructSignature
+            || kind === SyntaxKind.CallSignature
+            || kind === SyntaxKind.PropertySignature
+            || kind === SyntaxKind.MethodSignature
+            || kind === SyntaxKind.IndexSignature
+            || kind === SyntaxKind.MissingDeclaration;
     }
 
     export function isObjectLiteralElementLike(node: Node): node is ObjectLiteralElementLike {

src/compiler/utilities.ts

@@ -68,6 +68,9 @@ namespace ts {
                 transformers: {
                     before: [replaceUndefinedWithVoid0],
                     after: [replaceIdentifiersNamedOldNameWithNewName]
+                },
+                compilerOptions: {
+                    newLine: NewLineKind.LineFeed
                 }
             }).outputText;
         });

src/compiler/visitor.ts

@@ -110,16 +110,16 @@ namespace ts.codefix {
             if (!isStatic) {
                 const stringTypeNode = createKeywordTypeNode(SyntaxKind.StringKeyword);
                 const indexingParameter = createParameter(
-                /*decorators*/ undefined,
-                /*modifiers*/ undefined,
-                /*dotDotDotToken*/ undefined,
+                    /*decorators*/ undefined,
+                    /*modifiers*/ undefined,
+                    /*dotDotDotToken*/ undefined,
                     "x",
-                /*questionToken*/ undefined,
+                    /*questionToken*/ undefined,
                     stringTypeNode,
-                /*initializer*/ undefined);
-                const indexSignature = createIndexSignatureDeclaration(
-                /*decorators*/ undefined,
-                /*modifiers*/ undefined,
+                    /*initializer*/ undefined);
+                const indexSignature = createIndexSignature(
+                    /*decorators*/ undefined,
+                    /*modifiers*/ undefined,
                     [indexingParameter],
                     typeNode);
 

src/harness/unittests/transform.ts

@@ -200,7 +200,7 @@ namespace ts.codefix {
     }
 
     export function createStubbedMethod(modifiers: Modifier[], name: PropertyName, optional: boolean, typeParameters: TypeParameterDeclaration[] | undefined, parameters: ParameterDeclaration[], returnType: TypeNode | undefined) {
-        return createMethodDeclaration(
+        return createMethod(
             /*decorators*/ undefined,
             modifiers,
             /*asteriskToken*/ undefined,