Add factory functions for rest of NodeEdgeTraversal

rbuckton · rbuckton · commit bd98bc97bdf6 · 2017-02-03T14:12:50.000-08:00
diff --git a/src/compiler/factory.ts b/src/compiler/factory.ts
@@ -187,6 +187,20 @@ namespace ts {
 
     // Names
 
+    export function createQualifiedName(left: EntityName, right: string | Identifier) {
+        const node = <QualifiedName>createSynthesizedNode(SyntaxKind.QualifiedName);
+        node.left = left;
+        node.right = asName(right);
+        return node;
+    }
+
+    export function updateQualifiedName(node: QualifiedName, left: EntityName, right: Identifier) {
+        return node.left !== left
+            || node.right !== right
+            ? updateNode(createQualifiedName(left, right), node)
+            : node;
+    }
+
     export function createComputedPropertyName(expression: Expression) {
         const node = <ComputedPropertyName>createSynthesizedNode(SyntaxKind.ComputedPropertyName);
         node.expression = expression;
@@ -502,6 +516,20 @@ namespace ts {
             : node;
     }
 
+    export function createTypeAssertion(type: TypeNode, expression: Expression) {
+        const node = <TypeAssertion>createSynthesizedNode(SyntaxKind.TypeAssertionExpression);
+        node.type = type;
+        node.expression = parenthesizePrefixOperand(expression);
+        return node;
+    }
+
+    export function updateTypeAssertion(node: TypeAssertion, type: TypeNode, expression: Expression) {
+        return node.type !== type
+            || node.expression !== expression
+            ? updateNode(createTypeAssertion(type, expression), node)
+            : node;
+    }
+
     export function createParen(expression: Expression) {
         const node = <ParenthesizedExpression>createSynthesizedNode(SyntaxKind.ParenthesizedExpression);
         node.expression = expression;
@@ -749,6 +777,32 @@ namespace ts {
             : node;
     }
 
+    export function createAsExpression(expression: Expression, type: TypeNode) {
+        const node = <AsExpression>createSynthesizedNode(SyntaxKind.AsExpression);
+        node.expression = expression;
+        node.type = type;
+        return node;
+    }
+
+    export function updateAsExpression(node: AsExpression, expression: Expression, type: TypeNode) {
+        return node.expression !== expression
+            || node.type !== type
+            ? updateNode(createAsExpression(expression, type), node)
+            : node;
+    }
+
+    export function createNonNullExpression(expression: Expression) {
+        const node = <NonNullExpression>createSynthesizedNode(SyntaxKind.NonNullExpression);
+        node.expression = parenthesizeForAccess(expression);
+        return node;
+    }
+
+    export function updateNonNullExpression(node: NonNullExpression, expression: Expression) {
+        return node.expression !== expression
+            ? updateNode(createNonNullExpression(expression), node)
+            : node;
+    }
+
     // Misc
 
     export function createTemplateSpan(expression: Expression, literal: TemplateMiddle | TemplateTail) {
@@ -1040,18 +1094,6 @@ namespace ts {
             : node;
     }
 
-    export function createCaseBlock(clauses: CaseOrDefaultClause[]): CaseBlock {
-        const node = <CaseBlock>createSynthesizedNode(SyntaxKind.CaseBlock);
-        node.clauses = createNodeArray(clauses);
-        return node;
-    }
-
-    export function updateCaseBlock(node: CaseBlock, clauses: CaseOrDefaultClause[]) {
-        return node.clauses !== clauses
-            ? updateNode(createCaseBlock(clauses), node)
-            : node;
-    }
-
     export function createFunctionDeclaration(decorators: Decorator[], modifiers: Modifier[], asteriskToken: AsteriskToken, name: string | Identifier, typeParameters: TypeParameterDeclaration[], parameters: ParameterDeclaration[], type: TypeNode, body: Block) {
         const node = <FunctionDeclaration>createSynthesizedNode(SyntaxKind.FunctionDeclaration);
         node.decorators = asNodeArray(decorators);
@@ -1099,6 +1141,85 @@ namespace ts {
             : node;
     }
 
+    export function createEnumDeclaration(decorators: Decorator[], modifiers: Modifier[], name: string | Identifier, members: EnumMember[]) {
+        const node = <EnumDeclaration>createSynthesizedNode(SyntaxKind.EnumDeclaration);
+        node.decorators = asNodeArray(decorators);
+        node.modifiers = asNodeArray(modifiers);
+        node.name = asName(name);
+        node.members = createNodeArray(members);
+        return node;
+    }
+
+    export function updateEnumDeclaration(node: EnumDeclaration, decorators: Decorator[], modifiers: Modifier[], name: Identifier, members: EnumMember[]) {
+        return node.decorators !== decorators
+            || node.modifiers !== modifiers
+            || node.name !== name
+            || node.members !== members
+            ? updateNode(createEnumDeclaration(decorators, modifiers, name, members), node)
+            : node;
+    }
+
+    export function createModuleDeclaration(decorators: Decorator[], modifiers: Modifier[], name: ModuleName, body: ModuleBody, flags?: NodeFlags) {
+        const node = <ModuleDeclaration>createSynthesizedNode(SyntaxKind.ModuleDeclaration);
+        node.flags |= flags;
+        node.decorators = asNodeArray(decorators);
+        node.modifiers = asNodeArray(modifiers);
+        node.name = name;
+        node.body = body;
+        return node;
+    }
+
+    export function updateModuleDeclaration(node: ModuleDeclaration, decorators: Decorator[], modifiers: Modifier[], name: ModuleName, body: ModuleBody) {
+        return node.decorators !== decorators
+            || node.modifiers !== modifiers
+            || node.name !== name
+            || node.body !== body
+            ? updateNode(createModuleDeclaration(decorators, modifiers, name, body, node.flags), node)
+            : node;
+    }
+
+    export function createModuleBlock(statements: Statement[]) {
+        const node = <ModuleBlock>createSynthesizedNode(SyntaxKind.CaseBlock);
+        node.statements = createNodeArray(statements);
+        return node;
+    }
+
+    export function updateModuleBlock(node: ModuleBlock, statements: Statement[]) {
+        return node.statements !== statements
+            ? updateNode(createModuleBlock(statements), node)
+            : node;
+    }
+
+    export function createCaseBlock(clauses: CaseOrDefaultClause[]): CaseBlock {
+        const node = <CaseBlock>createSynthesizedNode(SyntaxKind.CaseBlock);
+        node.clauses = createNodeArray(clauses);
+        return node;
+    }
+
+    export function updateCaseBlock(node: CaseBlock, clauses: CaseOrDefaultClause[]) {
+        return node.clauses !== clauses
+            ? updateNode(createCaseBlock(clauses), node)
+            : node;
+    }
+
+    export function createImportEqualsDeclaration(decorators: Decorator[], modifiers: Modifier[], name: string | Identifier, moduleReference: ModuleReference) {
+        const node = <ImportEqualsDeclaration>createSynthesizedNode(SyntaxKind.ImportEqualsDeclaration);
+        node.decorators = asNodeArray(decorators);
+        node.modifiers = asNodeArray(modifiers);
+        node.name = asName(name);
+        node.moduleReference = moduleReference;
+        return node;
+    }
+
+    export function updateImportEqualsDeclaration(node: ImportEqualsDeclaration, decorators: Decorator[], modifiers: Modifier[], name: Identifier, moduleReference: ModuleReference) {
+        return node.decorators !== decorators
+            || node.modifiers !== modifiers
+            || node.name !== name
+            || node.moduleReference !== moduleReference
+            ? updateNode(createImportEqualsDeclaration(decorators, modifiers, name, moduleReference), node)
+            : node;
+    }
+
     export function createImportDeclaration(decorators: Decorator[], modifiers: Modifier[], importClause: ImportClause, moduleSpecifier?: Expression): ImportDeclaration {
         const node = <ImportDeclaration>createSynthesizedNode(SyntaxKind.ImportDeclaration);
         node.decorators = asNodeArray(decorators);
@@ -1228,6 +1349,20 @@ namespace ts {
             : node;
     }
 
+    // Module references
+
+    export function createExternalModuleReference(expression: Expression) {
+        const node = <ExternalModuleReference>createSynthesizedNode(SyntaxKind.ExternalModuleReference);
+        node.expression = expression;
+        return node;
+    }
+
+    export function updateExternalModuleReference(node: ExternalModuleReference, expression: Expression) {
+        return node.expression !== expression
+            ? updateNode(createExternalModuleReference(expression), node)
+            : node;
+    }
+
     // JSX
 
     export function createJsxElement(openingElement: JsxOpeningElement, children: JsxChild[], closingElement: JsxClosingElement) {
@@ -1426,6 +1561,22 @@ namespace ts {
         return node;
     }
 
+    // Enum
+
+    export function createEnumMember(name: string | PropertyName, initializer?: Expression) {
+        const node = <EnumMember>createSynthesizedNode(SyntaxKind.EnumMember);
+        node.name = asName(name);
+        node.initializer = initializer && parenthesizeExpressionForList(initializer);
+        return node;
+    }
+
+    export function updateEnumMember(node: EnumMember, name: PropertyName, initializer: Expression | undefined) {
+        return node.name !== name
+            || node.initializer !== initializer
+            ? updateNode(createEnumMember(name, initializer), node)
+            : node;
+    }
+
     // Top-level nodes
 
     export function updateSourceFileNode(node: SourceFile, statements: Statement[]) {
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
@@ -1771,24 +1771,28 @@
         members: NodeArray<EnumMember>;
     }
 
-    export type ModuleBody = ModuleBlock | ModuleDeclaration;
-
     export type ModuleName = Identifier | StringLiteral;
 
+    export type ModuleBody = NamespaceBody | JSDocNamespaceBody;
+
     export interface ModuleDeclaration extends DeclarationStatement {
         kind: SyntaxKind.ModuleDeclaration;
         name: Identifier | StringLiteral;
-        body?: ModuleBlock | NamespaceDeclaration | JSDocNamespaceDeclaration | Identifier;
+        body?: ModuleBody | JSDocNamespaceDeclaration | Identifier;
     }
 
+    export type NamespaceBody = ModuleBlock | NamespaceDeclaration;
+
     export interface NamespaceDeclaration extends ModuleDeclaration {
         name: Identifier;
-        body: ModuleBlock | NamespaceDeclaration;
+        body: NamespaceBody;
     }
 
+    export type JSDocNamespaceBody = Identifier | JSDocNamespaceDeclaration;
+
     export interface JSDocNamespaceDeclaration extends ModuleDeclaration {
         name: Identifier;
-        body: JSDocNamespaceDeclaration | Identifier;
+        body: JSDocNamespaceBody;
     }
 
     export interface ModuleBlock extends Node, Statement {
diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts
@@ -3887,6 +3887,19 @@ namespace ts {
     export function isModuleBody(node: Node): node is ModuleBody {
         const kind = node.kind;
         return kind === SyntaxKind.ModuleBlock
+            || kind === SyntaxKind.ModuleDeclaration
+            || kind === SyntaxKind.Identifier;
+    }
+
+    export function isNamespaceBody(node: Node): node is NamespaceBody {
+        const kind = node.kind;
+        return kind === SyntaxKind.ModuleBlock
+            || kind === SyntaxKind.ModuleDeclaration;
+    }
+
+    export function isJSDocNamespaceBody(node: Node): node is JSDocNamespaceBody {
+        const kind = node.kind;
+        return kind === SyntaxKind.Identifier
             || kind === SyntaxKind.ModuleDeclaration;
     }
 
diff --git a/src/compiler/visitor.ts b/src/compiler/visitor.ts
