diff --git a/src/compiler/factory.ts b/src/compiler/factory.ts
index 5c7486debe3..80e2fea7668 100644
--- 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
index 7850155ed25..54cea3168e1 100644
--- 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
index ae2caf4f23b..7c9d60f7bc4 100644
--- 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
new file mode 100644
index 00000000000..1f7b2f53ec1
--- /dev/null
+++ b/tests/baselines/reference/transformApi/transformsCorrectly.types.js
@@ -0,0 +1 @@
+let a: () => void;