Fix visitEachChild for signatures

rbuckton · rbuckton · commit 21714299d036 · 2017-04-25T11:02:54.000-07:00
diff --git a/src/compiler/factory.ts b/src/compiler/factory.ts
@@ -368,6 +368,18 @@ namespace ts {
             : node;
     }
 
+    export function createParenthesizedType(type: TypeNode) {
+        const node = <ParenthesizedTypeNode>createSynthesizedNode(SyntaxKind.ParenthesizedType);
+        node.type = type;
+        return node;
+    }
+
+    export function updateParenthesizedType(node: ParenthesizedTypeNode, type: TypeNode) {
+        return node.type !== type
+            ? updateNode(createParenthesizedType(type), node)
+            : node;
+    }
+
     export function createTypeLiteralNode(members: TypeElement[]) {
         const typeLiteralNode = createSynthesizedNode(SyntaxKind.TypeLiteral) as TypeLiteralNode;
         typeLiteralNode.members = createNodeArray(members);
diff --git a/src/compiler/visitor.ts b/src/compiler/visitor.ts
@@ -242,31 +242,31 @@ namespace ts {
             case SyntaxKind.FunctionType:
                 return updateFunctionTypeNode(<FunctionTypeNode>node,
                     nodesVisitor((<FunctionTypeNode>node).typeParameters, visitor, isTypeParameter),
-                    visitParameterList((<FunctionTypeNode>node).parameters, visitor, context, nodesVisitor),
+                    nodesVisitor((<FunctionTypeNode>node).parameters, visitor, isParameterDeclaration),
                     visitNode((<FunctionTypeNode>node).type, visitor, isTypeNode));
 
             case SyntaxKind.ConstructorType:
                 return updateConstructorTypeNode(<ConstructorTypeNode>node,
                     nodesVisitor((<ConstructorTypeNode>node).typeParameters, visitor, isTypeParameter),
-                    visitParameterList((<ConstructorTypeNode>node).parameters, visitor, context, nodesVisitor),
+                    nodesVisitor((<ConstructorTypeNode>node).parameters, visitor, isParameterDeclaration),
                     visitNode((<ConstructorTypeNode>node).type, visitor, isTypeNode));
 
             case SyntaxKind.CallSignature:
                 return updateCallSignatureDeclaration(<CallSignatureDeclaration>node,
                     nodesVisitor((<CallSignatureDeclaration>node).typeParameters, visitor, isTypeParameter),
-                    visitParameterList((<CallSignatureDeclaration>node).parameters, visitor, context, nodesVisitor),
+                    nodesVisitor((<CallSignatureDeclaration>node).parameters, visitor, isParameterDeclaration),
                     visitNode((<CallSignatureDeclaration>node).type, visitor, isTypeNode));
 
             case SyntaxKind.ConstructSignature:
                 return updateConstructSignatureDeclaration(<ConstructSignatureDeclaration>node,
                     nodesVisitor((<ConstructSignatureDeclaration>node).typeParameters, visitor, isTypeParameter),
-                    visitParameterList((<ConstructSignatureDeclaration>node).parameters, visitor, context, nodesVisitor),
+                    nodesVisitor((<ConstructSignatureDeclaration>node).parameters, visitor, isParameterDeclaration),
                     visitNode((<ConstructSignatureDeclaration>node).type, visitor, isTypeNode));
 
             case SyntaxKind.MethodSignature:
                 return updateMethodSignature(<MethodSignature>node,
                     nodesVisitor((<MethodSignature>node).typeParameters, visitor, isTypeParameter),
-                    visitParameterList((<MethodSignature>node).parameters, visitor, context, nodesVisitor),
+                    nodesVisitor((<MethodSignature>node).parameters, visitor, isParameterDeclaration),
                     visitNode((<MethodSignature>node).type, visitor, isTypeNode),
                     visitNode((<MethodSignature>node).name, visitor, isPropertyName),
                     visitNode((<MethodSignature>node).questionToken, tokenVisitor, isToken));
@@ -275,7 +275,7 @@ namespace ts {
                 return updateIndexSignatureDeclaration(<IndexSignatureDeclaration>node,
                     nodesVisitor((<IndexSignatureDeclaration>node).decorators, visitor, isDecorator),
                     nodesVisitor((<IndexSignatureDeclaration>node).modifiers, visitor, isModifier),
-                    visitParameterList((<IndexSignatureDeclaration>node).parameters, visitor, context, nodesVisitor),
+                    nodesVisitor((<IndexSignatureDeclaration>node).parameters, visitor, isParameterDeclaration),
                     visitNode((<IndexSignatureDeclaration>node).type, visitor, isTypeNode));
 
             case SyntaxKind.Parameter:
@@ -322,7 +322,8 @@ namespace ts {
                     nodesVisitor((<UnionOrIntersectionTypeNode>node).types, visitor, isTypeNode));
 
             case SyntaxKind.ParenthesizedType:
-                throw Debug.fail("not implemented.");
+                return updateParenthesizedType(<ParenthesizedTypeNode>node,
+                    visitNode((<ParenthesizedTypeNode>node).type, visitor, isTypeNode));
 
             case SyntaxKind.TypeOperator:
                 return updateTypeOperatorNode(<TypeOperatorNode>node, visitNode((<TypeOperatorNode>node).type, visitor, isTypeNode));
diff --git a/src/harness/unittests/transform.ts b/src/harness/unittests/transform.ts
@@ -39,5 +39,12 @@ namespace ts {
                 return file => file;
             }
         ]);
+
+        // https://github.com/Microsoft/TypeScript/issues/15192
+        transformsCorrectly("types", `let a: () => void`, [
+            context => file => visitNode(file, function visitor(node: Node): VisitResult<Node> {
+                return visitEachChild(node, visitor, context);
+            })
+        ]);
     });
 }
diff --git a/tests/baselines/reference/transformApi/transformsCorrectly.types.js b/tests/baselines/reference/transformApi/transformsCorrectly.types.js
@@ -0,0 +1 @@
+let a: () => void;

Original file line number	Diff line number	Diff line change
`@@ -39,5 +39,12 @@ namespace ts {`
`39`	`39`	`return file => file;`
`40`	`40`	`}`
`41`	`41`	`]);`
	`42`	`+`
	`43`	`+ // https://github.com/Microsoft/TypeScript/issues/15192`
	`44`	+ transformsCorrectly("types", `let a: () => void`, [
	`45`	`+ context => file => visitNode(file, function visitor(node: Node): VisitResult<Node> {`
	`46`	`+ return visitEachChild(node, visitor, context);`
	`47`	`+ })`
	`48`	`+ ]);`
`42`	`49`	`});`
`43`	`50`	`}`