Added cloneNode

scripts/processTypes.ts

@@ -537,6 +537,7 @@ function generateFactory(outputFile: string) {
     writer.writeLine();
     writer.increaseIndent();
     writeCreateAndUpdateFunctions();
+    writeCloneFunction();
     writer.decreaseIndent();
     writer.write(`}`);
     writer.writeLine();
@@ -726,6 +727,63 @@ function generateFactory(outputFile: string) {
         writer.writeLine();
     }
     
+    function writeCloneFunction() {
+        writer.write(`export function cloneNode<TNode extends Node>(node: TNode): TNode;`);
+        writer.writeLine();
+
+        writer.write(`export function cloneNode(node: Node): Node {`);
+        writer.writeLine();
+        writer.increaseIndent();
+        
+        writer.write(`if (!node) {`);
+        writer.writeLine();
+        writer.increaseIndent();
+        
+        writer.write(`return node;`);
+        writer.writeLine();
+        
+        writer.decreaseIndent();
+        writer.write(`}`);
+        writer.writeLine();
+        
+        writer.write(`switch (node.kind) {`);
+        writer.writeLine();
+        writer.increaseIndent();
+        
+        for (let syntaxNode of syntax) {
+            if (!syntaxNode.options.create) {
+                continue;
+            }
+            
+            writer.write(`case SyntaxKind.${syntaxNode.kindName}:`);
+            writer.writeLine();
+            writer.increaseIndent();
+            
+            writer.write(`return factory.create${syntaxNode.kindName}(`);
+            for (let i = 0; i < syntaxNode.members.length; ++i) {
+                if (i > 0) {
+                    writer.write(`, `);
+                }
+                
+                let member = syntaxNode.members[i];
+                writer.write(`(<${syntaxNode.typeName}>node).${member.propertyName}`);
+            }
+            
+            writer.write(`);`);
+            writer.writeLine();
+
+            writer.decreaseIndent();
+        }
+        
+        writer.decreaseIndent();
+        writer.write(`}`);
+        writer.writeLine();
+        
+        writer.decreaseIndent();
+        writer.write(`}`);
+        writer.writeLine();
+    }
+    
     function writeUpdateFunction(syntaxNode: SyntaxNode) {
         if (!syntaxNode.options.update || !hasChildNodes(syntaxNode)) {
             return;

src/compiler/declarationEmitter.ts

@@ -330,8 +330,6 @@ namespace ts {
                     return writeTextOfNode(currentSourceFile, type);
                 case SyntaxKind.ExpressionWithTypeArguments:
                     return emitExpressionWithTypeArguments(<ExpressionWithTypeArguments>type);
-                case SyntaxKind.TypePredicate:
-                    return emitTypePredicate(<TypePredicateNode>type);
                 case SyntaxKind.TypeReference:
                     return emitTypeReference(<TypeReferenceNode>type);
                 case SyntaxKind.TypeQuery:
@@ -393,12 +391,6 @@ namespace ts {
                 }
             }
             
-            function emitTypePredicate(type: TypePredicateNode) {
-                writeTextOfNode(currentSourceFile, type.parameterName);
-                write(" is ");
-                emitType(type.type);
-            }
-
             function emitTypeReference(type: TypeReferenceNode) {
                 emitEntityName(type.typeName);
                 if (type.typeArguments) {

src/compiler/emitter.ts

@@ -3045,31 +3045,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                     return expr;
                 }
 
-                function createDefaultValueCheck(value: Expression, defaultValue: Expression): Expression {
-                    // The value expression will be evaluated twice, so for anything but a simple identifier
-                    // we need to generate a temporary variable
-                    value = ensureIdentifier(value);
-                    // Return the expression 'value === void 0 ? defaultValue : value'
-                    return factory.createConditionalExpression2(
-                        factory.createBinaryExpression2(
-                            value,
-                            SyntaxKind.EqualsEqualsEqualsToken,
-                            factory.createVoidZeroExpression()
-                        ),
-                        defaultValue,
-                        value
-                    );
-                }
-
-                function createPropertyAccessForDestructuringProperty(object: Expression, propName: Identifier | LiteralExpression): Expression {
-                    // We create a synthetic copy of the identifier in order to avoid the rewriting that might
-                    // otherwise occur when the identifier is emitted.
-                    return factory.createPropertyOrElementAccessExpression(
-                        factory.parenthesizeForAccess(object),
-                        factory.cloneIdentifierOrLiteralExpression(propName)
-                    );
-                }
-
                 function emitObjectLiteralAssignment(target: ObjectLiteralExpression, value: Expression) {
                     let properties = target.properties;
                     if (properties.length !== 1) {
@@ -3108,7 +3083,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
 
                 function emitDestructuringAssignment(target: Expression, value: Expression) {
                     if (target.kind === SyntaxKind.BinaryExpression && (<BinaryExpression>target).operatorToken.kind === SyntaxKind.EqualsToken) {
-                        value = createDefaultValueCheck(value, (<BinaryExpression>target).right);
+                        value = factory.createDefaultValueCheck(value, (<BinaryExpression>target).right, ensureIdentifier);
                         target = (<BinaryExpression>target).left;
                     }
                     if (target.kind === SyntaxKind.ObjectLiteralExpression) {
@@ -3145,7 +3120,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 function emitBindingElement(target: BindingElement, value: Expression) {
                     if (target.initializer) {
                         // Combine value and initializer
-                        value = value ? createDefaultValueCheck(value, target.initializer) : target.initializer;
+                        value = value ? factory.createDefaultValueCheck(value, target.initializer, ensureIdentifier) : target.initializer;
                     }
                     else if (!value) {
                         // Use 'void 0' in absence of value and initializer
@@ -6601,4 +6576,4 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
             }
         }
     }
-}
+}

src/compiler/factory.generated.ts

@@ -2077,6 +2077,363 @@ namespace ts {
             }
             return node;
         }
+        export function cloneNode<TNode extends Node>(node: TNode): TNode;
+        export function cloneNode(node: Node): Node {
+            if (!node) {
+                return node;
+            }
+            switch (node.kind) {
+                case SyntaxKind.NumericLiteral:
+                    return factory.createNumericLiteral((<LiteralExpression>node).text);
+                case SyntaxKind.StringLiteral:
+                    return factory.createStringLiteral((<StringLiteral>node).text);
+                case SyntaxKind.RegularExpressionLiteral:
+                    return factory.createRegularExpressionLiteral((<LiteralExpression>node).text);
+                case SyntaxKind.NoSubstitutionTemplateLiteral:
+                    return factory.createNoSubstitutionTemplateLiteral((<LiteralExpression>node).text);
+                case SyntaxKind.TemplateHead:
+                    return factory.createTemplateHead((<LiteralExpression>node).text);
+                case SyntaxKind.TemplateMiddle:
+                    return factory.createTemplateMiddle((<LiteralExpression>node).text);
+                case SyntaxKind.TemplateTail:
+                    return factory.createTemplateTail((<LiteralExpression>node).text);
+                case SyntaxKind.Identifier:
+                    return factory.createIdentifier((<Identifier>node).text, (<Identifier>node).originalKeywordKind);
+                case SyntaxKind.QualifiedName:
+                    return factory.createQualifiedName((<QualifiedName>node).left, (<QualifiedName>node).right);
+                case SyntaxKind.ComputedPropertyName:
+                    return factory.createComputedPropertyName((<ComputedPropertyName>node).expression);
+                case SyntaxKind.TypeParameter:
+                    return factory.createTypeParameter((<TypeParameterDeclaration>node).name, (<TypeParameterDeclaration>node).constraint, 
+                        (<TypeParameterDeclaration>node).expression);
+                case SyntaxKind.Parameter:
+                    return factory.createParameter((<ParameterDeclaration>node).decorators, (<ParameterDeclaration>node).modifiers, 
+                        (<ParameterDeclaration>node).dotDotDotToken, (<ParameterDeclaration>node).name, (<ParameterDeclaration>node).questionToken, 
+                        (<ParameterDeclaration>node).type, (<ParameterDeclaration>node).initializer);
+                case SyntaxKind.Decorator:
+                    return factory.createDecorator((<Decorator>node).expression);
+                case SyntaxKind.PropertySignature:
+                    return factory.createPropertySignature((<PropertySignature>node).decorators, (<PropertySignature>node).modifiers, 
+                        (<PropertySignature>node).name, (<PropertySignature>node).questionToken, (<PropertySignature>node).type);
+                case SyntaxKind.PropertyDeclaration:
+                    return factory.createPropertyDeclaration((<PropertyDeclaration>node).decorators, (<PropertyDeclaration>node).modifiers, 
+                        (<PropertyDeclaration>node).name, (<PropertyDeclaration>node).questionToken, (<PropertyDeclaration>node).type, 
+                        (<PropertyDeclaration>node).initializer);
+                case SyntaxKind.MethodSignature:
+                    return factory.createMethodSignature((<MethodSignature>node).decorators, (<MethodSignature>node).modifiers, 
+                        (<MethodSignature>node).name, (<MethodSignature>node).questionToken, (<MethodSignature>node).typeParameters, 
+                        (<MethodSignature>node).parameters, (<MethodSignature>node).type);
+                case SyntaxKind.MethodDeclaration:
+                    return factory.createMethodDeclaration((<MethodDeclaration>node).decorators, (<MethodDeclaration>node).modifiers, 
+                        (<MethodDeclaration>node).name, (<MethodDeclaration>node).typeParameters, (<MethodDeclaration>node).parameters, 
+                        (<MethodDeclaration>node).type, (<MethodDeclaration>node).body);
+                case SyntaxKind.Constructor:
+                    return factory.createConstructor((<ConstructorDeclaration>node).decorators, (<ConstructorDeclaration>node).modifiers, 
+                        (<ConstructorDeclaration>node).parameters, (<ConstructorDeclaration>node).type, (<ConstructorDeclaration>node).body);
+                case SyntaxKind.GetAccessor:
+                    return factory.createGetAccessor((<GetAccessorDeclaration>node).decorators, (<GetAccessorDeclaration>node).modifiers, 
+                        (<GetAccessorDeclaration>node).name, (<GetAccessorDeclaration>node).parameters, (<GetAccessorDeclaration>node).type, 
+                        (<GetAccessorDeclaration>node).body);
+                case SyntaxKind.SetAccessor:
+                    return factory.createSetAccessor((<SetAccessorDeclaration>node).decorators, (<SetAccessorDeclaration>node).modifiers, 
+                        (<SetAccessorDeclaration>node).name, (<SetAccessorDeclaration>node).parameters, (<SetAccessorDeclaration>node).type, 
+                        (<SetAccessorDeclaration>node).body);
+                case SyntaxKind.CallSignature:
+                    return factory.createCallSignature((<CallSignatureDeclaration>node).typeParameters, (<CallSignatureDeclaration>node).parameters, 
+                        (<CallSignatureDeclaration>node).type);
+                case SyntaxKind.ConstructSignature:
+                    return factory.createConstructSignature((<ConstructSignatureDeclaration>node).typeParameters, 
+                        (<ConstructSignatureDeclaration>node).parameters, (<ConstructSignatureDeclaration>node).type);
+                case SyntaxKind.IndexSignature:
+                    return factory.createIndexSignature((<IndexSignatureDeclaration>node).decorators, (<IndexSignatureDeclaration>node).modifiers, 
+                        (<IndexSignatureDeclaration>node).parameters, (<IndexSignatureDeclaration>node).type);
+                case SyntaxKind.TypePredicate:
+                    return factory.createTypePredicate((<TypePredicateNode>node).parameterName, (<TypePredicateNode>node).type);
+                case SyntaxKind.TypeReference:
+                    return factory.createTypeReference((<TypeReferenceNode>node).typeName, (<TypeReferenceNode>node).typeArguments);
+                case SyntaxKind.FunctionType:
+                    return factory.createFunctionType((<FunctionTypeNode>node).typeParameters, (<FunctionTypeNode>node).parameters, 
+                        (<FunctionTypeNode>node).type);
+                case SyntaxKind.ConstructorType:
+                    return factory.createConstructorType((<ConstructorTypeNode>node).typeParameters, (<ConstructorTypeNode>node).parameters, 
+                        (<ConstructorTypeNode>node).type);
+                case SyntaxKind.TypeQuery:
+                    return factory.createTypeQuery((<TypeQueryNode>node).exprName);
+                case SyntaxKind.TypeLiteral:
+                    return factory.createTypeLiteral((<TypeLiteralNode>node).members);
+                case SyntaxKind.ArrayType:
+                    return factory.createArrayType((<ArrayTypeNode>node).elementType);
+                case SyntaxKind.TupleType:
+                    return factory.createTupleType((<TupleTypeNode>node).elementTypes);
+                case SyntaxKind.UnionType:
+                    return factory.createUnionType((<UnionTypeNode>node).types);
+                case SyntaxKind.IntersectionType:
+                    return factory.createIntersectionType((<IntersectionTypeNode>node).types);
+                case SyntaxKind.ParenthesizedType:
+                    return factory.createParenthesizedType((<ParenthesizedTypeNode>node).type);
+                case SyntaxKind.ObjectBindingPattern:
+                    return factory.createObjectBindingPattern((<ObjectBindingPattern>node).elements);
+                case SyntaxKind.ArrayBindingPattern:
+                    return factory.createArrayBindingPattern((<ArrayBindingPattern>node).elements);
+                case SyntaxKind.BindingElement:
+                    return factory.createBindingElement((<BindingElement>node).decorators, (<BindingElement>node).modifiers, 
+                        (<BindingElement>node).propertyName, (<BindingElement>node).dotDotDotToken, (<BindingElement>node).name, 
+                        (<BindingElement>node).initializer);
+                case SyntaxKind.ArrayLiteralExpression:
+                    return factory.createArrayLiteralExpression((<ArrayLiteralExpression>node).elements);
+                case SyntaxKind.ObjectLiteralExpression:
+                    return factory.createObjectLiteralExpression((<ObjectLiteralExpression>node).decorators, 
+                        (<ObjectLiteralExpression>node).modifiers, (<ObjectLiteralExpression>node).properties);
+                case SyntaxKind.PropertyAccessExpression:
+                    return factory.createPropertyAccessExpression((<PropertyAccessExpression>node).expression, 
+                        (<PropertyAccessExpression>node).dotToken, (<PropertyAccessExpression>node).name);
+                case SyntaxKind.ElementAccessExpression:
+                    return factory.createElementAccessExpression((<ElementAccessExpression>node).expression, 
+                        (<ElementAccessExpression>node).argumentExpression);
+                case SyntaxKind.CallExpression:
+                    return factory.createCallExpression((<CallExpression>node).expression, (<CallExpression>node).typeArguments, 
+                        (<CallExpression>node).arguments);
+                case SyntaxKind.NewExpression:
+                    return factory.createNewExpression((<NewExpression>node).expression, (<NewExpression>node).typeArguments, 
+                        (<NewExpression>node).arguments);
+                case SyntaxKind.TaggedTemplateExpression:
+                    return factory.createTaggedTemplateExpression((<TaggedTemplateExpression>node).tag, (<TaggedTemplateExpression>node).template);
+                case SyntaxKind.TypeAssertionExpression:
+                    return factory.createTypeAssertionExpression((<TypeAssertion>node).type, (<TypeAssertion>node).expression);
+                case SyntaxKind.ParenthesizedExpression:
+                    return factory.createParenthesizedExpression((<ParenthesizedExpression>node).expression);
+                case SyntaxKind.FunctionExpression:
+                    return factory.createFunctionExpression((<FunctionExpression>node).decorators, (<FunctionExpression>node).modifiers, 
+                        (<FunctionExpression>node).asteriskToken, (<FunctionExpression>node).name, (<FunctionExpression>node).typeParameters, 
+                        (<FunctionExpression>node).parameters, (<FunctionExpression>node).type, (<FunctionExpression>node).body);
+                case SyntaxKind.ArrowFunction:
+                    return factory.createArrowFunction((<ArrowFunction>node).decorators, (<ArrowFunction>node).modifiers, 
+                        (<ArrowFunction>node).typeParameters, (<ArrowFunction>node).parameters, (<ArrowFunction>node).type, 
+                        (<ArrowFunction>node).equalsGreaterThanToken, (<ArrowFunction>node).body);
+                case SyntaxKind.DeleteExpression:
+                    return factory.createDeleteExpression((<DeleteExpression>node).expression);
+                case SyntaxKind.TypeOfExpression:
+                    return factory.createTypeOfExpression((<TypeOfExpression>node).expression);
+                case SyntaxKind.VoidExpression:
+                    return factory.createVoidExpression((<VoidExpression>node).expression);
+                case SyntaxKind.AwaitExpression:
+                    return factory.createAwaitExpression((<AwaitExpression>node).expression);
+                case SyntaxKind.PrefixUnaryExpression:
+                    return factory.createPrefixUnaryExpression((<PrefixUnaryExpression>node).operator, (<PrefixUnaryExpression>node).operand);
+                case SyntaxKind.PostfixUnaryExpression:
+                    return factory.createPostfixUnaryExpression((<PostfixUnaryExpression>node).operand, (<PostfixUnaryExpression>node).operator);
+                case SyntaxKind.BinaryExpression:
+                    return factory.createBinaryExpression((<BinaryExpression>node).left, (<BinaryExpression>node).operatorToken, 
+                        (<BinaryExpression>node).right);
+                case SyntaxKind.ConditionalExpression:
+                    return factory.createConditionalExpression((<ConditionalExpression>node).condition, (<ConditionalExpression>node).questionToken, 
+                        (<ConditionalExpression>node).whenTrue, (<ConditionalExpression>node).colonToken, (<ConditionalExpression>node).whenFalse);
+                case SyntaxKind.TemplateExpression:
+                    return factory.createTemplateExpression((<TemplateExpression>node).head, (<TemplateExpression>node).templateSpans);
+                case SyntaxKind.YieldExpression:
+                    return factory.createYieldExpression((<YieldExpression>node).asteriskToken, (<YieldExpression>node).expression);
+                case SyntaxKind.SpreadElementExpression:
+                    return factory.createSpreadElementExpression((<SpreadElementExpression>node).expression);
+                case SyntaxKind.ClassExpression:
+                    return factory.createClassExpression((<ClassExpression>node).decorators, (<ClassExpression>node).modifiers, 
+                        (<ClassExpression>node).name, (<ClassExpression>node).typeParameters, (<ClassExpression>node).heritageClauses, 
+                        (<ClassExpression>node).members);
+                case SyntaxKind.OmittedExpression:
+                    return factory.createOmittedExpression();
+                case SyntaxKind.ExpressionWithTypeArguments:
+                    return factory.createExpressionWithTypeArguments((<ExpressionWithTypeArguments>node).expression, 
+                        (<ExpressionWithTypeArguments>node).typeArguments);
+                case SyntaxKind.AsExpression:
+                    return factory.createAsExpression((<AsExpression>node).expression, (<AsExpression>node).type);
+                case SyntaxKind.TemplateSpan:
+                    return factory.createTemplateSpan((<TemplateSpan>node).expression, (<TemplateSpan>node).literal);
+                case SyntaxKind.SemicolonClassElement:
+                    return factory.createSemicolonClassElement();
+                case SyntaxKind.Block:
+                    return factory.createBlock((<Block>node).statements);
+                case SyntaxKind.VariableStatement:
+                    return factory.createVariableStatement((<VariableStatement>node).declarationList);
+                case SyntaxKind.EmptyStatement:
+                    return factory.createEmptyStatement();
+                case SyntaxKind.ExpressionStatement:
+                    return factory.createExpressionStatement((<ExpressionStatement>node).expression);
+                case SyntaxKind.IfStatement:
+                    return factory.createIfStatement((<IfStatement>node).expression, (<IfStatement>node).thenStatement, 
+                        (<IfStatement>node).elseStatement);
+                case SyntaxKind.DoStatement:
+                    return factory.createDoStatement((<DoStatement>node).statement, (<DoStatement>node).expression);
+                case SyntaxKind.WhileStatement:
+                    return factory.createWhileStatement((<WhileStatement>node).expression, (<WhileStatement>node).statement);
+                case SyntaxKind.ForStatement:
+                    return factory.createForStatement((<ForStatement>node).initializer, (<ForStatement>node).condition, 
+                        (<ForStatement>node).incrementor, (<ForStatement>node).statement);
+                case SyntaxKind.ForInStatement:
+                    return factory.createForInStatement((<ForInStatement>node).initializer, (<ForInStatement>node).expression, 
+                        (<ForInStatement>node).statement);
+                case SyntaxKind.ForOfStatement:
+                    return factory.createForOfStatement((<ForOfStatement>node).initializer, (<ForOfStatement>node).expression, 
+                        (<ForOfStatement>node).statement);
+                case SyntaxKind.ContinueStatement:
+                    return factory.createContinueStatement((<ContinueStatement>node).label);
+                case SyntaxKind.BreakStatement:
+                    return factory.createBreakStatement((<BreakStatement>node).label);
+                case SyntaxKind.ReturnStatement:
+                    return factory.createReturnStatement((<ReturnStatement>node).expression);
+                case SyntaxKind.WithStatement:
+                    return factory.createWithStatement((<WithStatement>node).expression, (<WithStatement>node).statement);
+                case SyntaxKind.SwitchStatement:
+                    return factory.createSwitchStatement((<SwitchStatement>node).expression, (<SwitchStatement>node).caseBlock);
+                case SyntaxKind.LabeledStatement:
+                    return factory.createLabeledStatement((<LabeledStatement>node).label, (<LabeledStatement>node).statement);
+                case SyntaxKind.ThrowStatement:
+                    return factory.createThrowStatement((<ThrowStatement>node).expression);
+                case SyntaxKind.TryStatement:
+                    return factory.createTryStatement((<TryStatement>node).tryBlock, (<TryStatement>node).catchClause, 
+                        (<TryStatement>node).finallyBlock);
+                case SyntaxKind.DebuggerStatement:
+                    return factory.createDebuggerStatement();
+                case SyntaxKind.VariableDeclaration:
+                    return factory.createVariableDeclaration((<VariableDeclaration>node).decorators, (<VariableDeclaration>node).modifiers, 
+                        (<VariableDeclaration>node).name, (<VariableDeclaration>node).type, (<VariableDeclaration>node).initializer);
+                case SyntaxKind.VariableDeclarationList:
+                    return factory.createVariableDeclarationList((<VariableDeclarationList>node).declarations);
+                case SyntaxKind.FunctionDeclaration:
+                    return factory.createFunctionDeclaration((<FunctionDeclaration>node).decorators, (<FunctionDeclaration>node).modifiers, 
+                        (<FunctionDeclaration>node).asteriskToken, (<FunctionDeclaration>node).name, (<FunctionDeclaration>node).typeParameters, 
+                        (<FunctionDeclaration>node).parameters, (<FunctionDeclaration>node).type, (<FunctionDeclaration>node).body);
+                case SyntaxKind.ClassDeclaration:
+                    return factory.createClassDeclaration((<ClassDeclaration>node).decorators, (<ClassDeclaration>node).modifiers, 
+                        (<ClassDeclaration>node).name, (<ClassDeclaration>node).typeParameters, (<ClassDeclaration>node).heritageClauses, 
+                        (<ClassDeclaration>node).members);
+                case SyntaxKind.InterfaceDeclaration:
+                    return factory.createInterfaceDeclaration((<InterfaceDeclaration>node).decorators, (<InterfaceDeclaration>node).modifiers, 
+                        (<InterfaceDeclaration>node).name, (<InterfaceDeclaration>node).typeParameters, (<InterfaceDeclaration>node).heritageClauses, 
+                        (<InterfaceDeclaration>node).members);
+                case SyntaxKind.TypeAliasDeclaration:
+                    return factory.createTypeAliasDeclaration((<TypeAliasDeclaration>node).decorators, (<TypeAliasDeclaration>node).modifiers, 
+                        (<TypeAliasDeclaration>node).name, (<TypeAliasDeclaration>node).typeParameters, (<TypeAliasDeclaration>node).type);
+                case SyntaxKind.EnumDeclaration:
+                    return factory.createEnumDeclaration((<EnumDeclaration>node).decorators, (<EnumDeclaration>node).modifiers, 
+                        (<EnumDeclaration>node).name, (<EnumDeclaration>node).members);
+                case SyntaxKind.ModuleDeclaration:
+                    return factory.createModuleDeclaration((<ModuleDeclaration>node).decorators, (<ModuleDeclaration>node).modifiers, 
+                        (<ModuleDeclaration>node).name, (<ModuleDeclaration>node).body);
+                case SyntaxKind.ModuleBlock:
+                    return factory.createModuleBlock((<ModuleBlock>node).statements);
+                case SyntaxKind.CaseBlock:
+                    return factory.createCaseBlock((<CaseBlock>node).clauses);
+                case SyntaxKind.ImportEqualsDeclaration:
+                    return factory.createImportEqualsDeclaration((<ImportEqualsDeclaration>node).decorators, 
+                        (<ImportEqualsDeclaration>node).modifiers, (<ImportEqualsDeclaration>node).name, 
+                        (<ImportEqualsDeclaration>node).moduleReference);
+                case SyntaxKind.ImportDeclaration:
+                    return factory.createImportDeclaration((<ImportDeclaration>node).decorators, (<ImportDeclaration>node).modifiers, 
+                        (<ImportDeclaration>node).importClause, (<ImportDeclaration>node).moduleSpecifier);
+                case SyntaxKind.ImportClause:
+                    return factory.createImportClause((<ImportClause>node).name, (<ImportClause>node).namedBindings);
+                case SyntaxKind.NamespaceImport:
+                    return factory.createNamespaceImport((<NamespaceImport>node).name);
+                case SyntaxKind.NamedImports:
+                    return factory.createNamedImports((<NamedImports>node).elements);
+                case SyntaxKind.ImportSpecifier:
+                    return factory.createImportSpecifier((<ImportSpecifier>node).propertyName, (<ImportSpecifier>node).name);
+                case SyntaxKind.ExportAssignment:
+                    return factory.createExportAssignment((<ExportAssignment>node).decorators, (<ExportAssignment>node).modifiers, 
+                        (<ExportAssignment>node).expression);
+                case SyntaxKind.ExportDeclaration:
+                    return factory.createExportDeclaration((<ExportDeclaration>node).decorators, (<ExportDeclaration>node).modifiers, 
+                        (<ExportDeclaration>node).exportClause, (<ExportDeclaration>node).moduleSpecifier);
+                case SyntaxKind.NamedExports:
+                    return factory.createNamedExports((<NamedExports>node).elements);
+                case SyntaxKind.ExportSpecifier:
+                    return factory.createExportSpecifier((<ExportSpecifier>node).propertyName, (<ExportSpecifier>node).name);
+                case SyntaxKind.MissingDeclaration:
+                    return factory.createMissingDeclaration((<MissingDeclaration>node).decorators, (<MissingDeclaration>node).modifiers);
+                case SyntaxKind.ExternalModuleReference:
+                    return factory.createExternalModuleReference((<ExternalModuleReference>node).expression);
+                case SyntaxKind.JsxElement:
+                    return factory.createJsxElement((<JsxElement>node).openingElement, (<JsxElement>node).children, (<JsxElement>node).closingElement
+                        );
+                case SyntaxKind.JsxSelfClosingElement:
+                    return factory.createJsxSelfClosingElement((<JsxSelfClosingElement>node).tagName, (<JsxSelfClosingElement>node).attributes);
+                case SyntaxKind.JsxOpeningElement:
+                    return factory.createJsxOpeningElement((<JsxOpeningElement>node).tagName, (<JsxOpeningElement>node).attributes);
+                case SyntaxKind.JsxText:
+                    return factory.createJsxText();
+                case SyntaxKind.JsxClosingElement:
+                    return factory.createJsxClosingElement((<JsxClosingElement>node).tagName);
+                case SyntaxKind.JsxAttribute:
+                    return factory.createJsxAttribute((<JsxAttribute>node).name, (<JsxAttribute>node).initializer);
+                case SyntaxKind.JsxSpreadAttribute:
+                    return factory.createJsxSpreadAttribute((<JsxSpreadAttribute>node).expression);
+                case SyntaxKind.JsxExpression:
+                    return factory.createJsxExpression((<JsxExpression>node).expression);
+                case SyntaxKind.CaseClause:
+                    return factory.createCaseClause((<CaseClause>node).expression, (<CaseClause>node).statements);
+                case SyntaxKind.DefaultClause:
+                    return factory.createDefaultClause((<DefaultClause>node).statements);
+                case SyntaxKind.HeritageClause:
+                    return factory.createHeritageClause((<HeritageClause>node).types);
+                case SyntaxKind.CatchClause:
+                    return factory.createCatchClause((<CatchClause>node).variableDeclaration, (<CatchClause>node).block);
+                case SyntaxKind.PropertyAssignment:
+                    return factory.createPropertyAssignment((<PropertyAssignment>node).name, (<PropertyAssignment>node).questionToken, 
+                        (<PropertyAssignment>node).initializer);
+                case SyntaxKind.ShorthandPropertyAssignment:
+                    return factory.createShorthandPropertyAssignment((<ShorthandPropertyAssignment>node).name, 
+                        (<ShorthandPropertyAssignment>node).questionToken);
+                case SyntaxKind.EnumMember:
+                    return factory.createEnumMember((<EnumMember>node).name, (<EnumMember>node).initializer);
+                case SyntaxKind.JSDocTypeExpression:
+                    return factory.createJSDocTypeExpression((<JSDocTypeExpression>node).type);
+                case SyntaxKind.JSDocAllType:
+                    return factory.createJSDocAllType();
+                case SyntaxKind.JSDocUnknownType:
+                    return factory.createJSDocUnknownType();
+                case SyntaxKind.JSDocArrayType:
+                    return factory.createJSDocArrayType((<JSDocArrayType>node).elementType);
+                case SyntaxKind.JSDocUnionType:
+                    return factory.createJSDocUnionType((<JSDocUnionType>node).types);
+                case SyntaxKind.JSDocTupleType:
+                    return factory.createJSDocTupleType((<JSDocTupleType>node).types);
+                case SyntaxKind.JSDocNullableType:
+                    return factory.createJSDocNullableType((<JSDocNullableType>node).type);
+                case SyntaxKind.JSDocNonNullableType:
+                    return factory.createJSDocNonNullableType((<JSDocNonNullableType>node).type);
+                case SyntaxKind.JSDocRecordType:
+                    return factory.createJSDocRecordType((<JSDocRecordType>node).members);
+                case SyntaxKind.JSDocRecordMember:
+                    return factory.createJSDocRecordMember((<JSDocRecordMember>node).name, (<JSDocRecordMember>node).type);
+                case SyntaxKind.JSDocTypeReference:
+                    return factory.createJSDocTypeReference((<JSDocTypeReference>node).name, (<JSDocTypeReference>node).typeArguments);
+                case SyntaxKind.JSDocOptionalType:
+                    return factory.createJSDocOptionalType((<JSDocOptionalType>node).type);
+                case SyntaxKind.JSDocFunctionType:
+                    return factory.createJSDocFunctionType((<JSDocFunctionType>node).parameters, (<JSDocFunctionType>node).type);
+                case SyntaxKind.JSDocVariadicType:
+                    return factory.createJSDocVariadicType((<JSDocVariadicType>node).type);
+                case SyntaxKind.JSDocConstructorType:
+                    return factory.createJSDocConstructorType((<JSDocConstructorType>node).type);
+                case SyntaxKind.JSDocThisType:
+                    return factory.createJSDocThisType((<JSDocThisType>node).type);
+                case SyntaxKind.JSDocComment:
+                    return factory.createJSDocComment((<JSDocComment>node).tags);
+                case SyntaxKind.JSDocTag:
+                    return factory.createJSDocTag((<JSDocTag>node).atToken, (<JSDocTag>node).tagName);
+                case SyntaxKind.JSDocParameterTag:
+                    return factory.createJSDocParameterTag((<JSDocParameterTag>node).preParameterName, (<JSDocParameterTag>node).typeExpression, 
+                        (<JSDocParameterTag>node).postParameterName, (<JSDocParameterTag>node).atToken, (<JSDocParameterTag>node).tagName);
+                case SyntaxKind.JSDocReturnTag:
+                    return factory.createJSDocReturnTag((<JSDocReturnTag>node).typeExpression, (<JSDocReturnTag>node).atToken, 
+                        (<JSDocReturnTag>node).tagName);
+                case SyntaxKind.JSDocTypeTag:
+                    return factory.createJSDocTypeTag((<JSDocTypeTag>node).typeExpression, (<JSDocTypeTag>node).atToken, (<JSDocTypeTag>node).tagName
+                        );
+                case SyntaxKind.JSDocTemplateTag:
+                    return factory.createJSDocTemplateTag((<JSDocTemplateTag>node).typeParameters, (<JSDocTemplateTag>node).atToken, 
+                        (<JSDocTemplateTag>node).tagName);
+            }
+        }
     }
     export function isNumericLiteral(node: Node): node is LiteralExpression {
         return node && node.kind === SyntaxKind.NumericLiteral;

src/compiler/factory.ts

@@ -148,21 +148,10 @@ namespace ts {
         export function createVoidZeroExpression(): VoidExpression {
             return factory.createVoidExpression(factory.createNumericLiteral2(0));
         }
-
-        export function cloneIdentifier(node: Identifier) {
-            return factory.createIdentifier(
-                node.text);
-        }
-
-        export function cloneIdentifierOrLiteralExpression(node: Identifier | LiteralExpression) {
-            let newNode = factory.createNode<Identifier | LiteralExpression>(node.kind);
-            newNode.text = node.text;
-            return newNode;
-        }
-
+        
         export function createPropertyOrElementAccessExpression(expression: Expression, propName: Identifier | LiteralExpression): LeftHandSideExpression {
             if (!nodeIsSynthesized(propName)) {
-                propName = cloneIdentifierOrLiteralExpression(propName);
+                propName = cloneNode(propName);
             }
             
             if (propName.kind !== SyntaxKind.Identifier) {
@@ -197,5 +186,22 @@ namespace ts {
                 ]
             );
         }
+        
+        export function createDefaultValueCheck(value: Expression, defaultValue: Expression, ensureIdentifier: (value: Expression) => Expression): Expression {
+            // The value expression will be evaluated twice, so for anything but a simple identifier
+            // we need to generate a temporary variable
+            value = ensureIdentifier(value);
+            
+            // <value> === void 0 ? <defaultValue> : <value>
+            return factory.createConditionalExpression2(
+                factory.createBinaryExpression2(
+                    value,
+                    SyntaxKind.EqualsEqualsEqualsToken,
+                    factory.createVoidZeroExpression()
+                ),
+                defaultValue,
+                value
+            );
+        }
     }
 }