diff --git a/src/compiler/factory.ts b/src/compiler/factory.ts
index 0ae42459709..0d2dee8cfdc 100644
--- a/src/compiler/factory.ts
+++ b/src/compiler/factory.ts
@@ -378,28 +378,65 @@ namespace ts {
     }
 
     // TODO: Split according to AST nodes.
-    export function createSignatureDeclaration<T extends SignatureDeclaration>(kind: SyntaxKind, typeParameters: TypeParameterDeclaration[] | undefined, parameters: ParameterDeclaration[], type: TypeNode | undefined): T;
-    export function createSignatureDeclaration<T extends SignatureDeclaration & TypeElement>(kind: SyntaxKind, typeParameters: TypeParameterDeclaration[] | undefined, parameters: ParameterDeclaration[], type: TypeNode | undefined, name: string | PropertyName, questionToken: QuestionToken | undefined): T;
-    export function createSignatureDeclaration<T extends SignatureDeclaration & TypeElement>(kind: SyntaxKind, typeParameters: TypeParameterDeclaration[] | undefined, parameters: ParameterDeclaration[], type: TypeNode | undefined, name?: string | PropertyName, questionToken?: QuestionToken): T {
-        const signatureDeclaration = createSynthesizedNode(kind) as T;
+    export function createSignatureDeclaration(kind: SyntaxKind, typeParameters: TypeParameterDeclaration[] | undefined, parameters: ParameterDeclaration[], type: TypeNode | undefined) {
+        const signatureDeclaration = createSynthesizedNode(kind) as SignatureDeclaration;
         signatureDeclaration.typeParameters = asNodeArray(typeParameters);
         signatureDeclaration.parameters = asNodeArray(parameters);
         signatureDeclaration.type = type;
-        signatureDeclaration.name = asName(name);
-        signatureDeclaration.questionToken = questionToken;
         return signatureDeclaration;
     }
 
-    // TODO: figure out right type annotation for this function.
-    export function updateSignatureDeclaration<T extends SignatureDeclaration>(node: T, typeParameters: NodeArray<TypeParameterDeclaration> | undefined, parameters: NodeArray<ParameterDeclaration>, type: TypeNode | undefined): T;
-    export function updateSignatureDeclaration<T extends SignatureDeclaration & TypeElement>(node: T, typeParameters: NodeArray<TypeParameterDeclaration> | undefined, parameters: NodeArray<ParameterDeclaration>, type: TypeNode | undefined, name: PropertyName, questionToken: QuestionToken | undefined): T;
-    export function updateSignatureDeclaration<T extends SignatureDeclaration & TypeElement>(node: T, typeParameters: NodeArray<TypeParameterDeclaration> | undefined, parameters: NodeArray<ParameterDeclaration>, type: TypeNode | undefined, name?: PropertyName, questionToken?: QuestionToken): T {
+    export function updateSignatureDeclaration(node: SignatureDeclaration, typeParameters: NodeArray<TypeParameterDeclaration> | undefined, parameters: NodeArray<ParameterDeclaration>, type: TypeNode | undefined) {
+        return node.typeParameters !== typeParameters
+            || node.parameters !== parameters
+            || node.type !== type
+            ? updateNode(createSignatureDeclaration(node.kind, typeParameters, parameters, type), node)
+            : node;
+    }
+
+    export function createFunctionTypeNode(typeParameters: TypeParameterDeclaration[] | undefined, parameters: ParameterDeclaration[], type: TypeNode | undefined): FunctionTypeNode {
+        return createSignatureDeclaration(SyntaxKind.FunctionType, typeParameters, parameters, type) as FunctionTypeNode;
+    }
+
+    export function updateFunctionTypeNode(node: FunctionTypeNode, typeParameters: NodeArray<TypeParameterDeclaration> | undefined, parameters: NodeArray<ParameterDeclaration>, type: TypeNode | undefined): FunctionTypeNode {
+        return <FunctionTypeNode>updateSignatureDeclaration(node, typeParameters, parameters, type);
+    }
+
+    export function createConstructorTypeNode(typeParameters: TypeParameterDeclaration[] | undefined, parameters: ParameterDeclaration[], type: TypeNode | undefined): ConstructorTypeNode {
+        return createSignatureDeclaration(SyntaxKind.ConstructorType, typeParameters, parameters, type) as ConstructorTypeNode;
+    }
+    export function updateConstructorTypeNode(node: ConstructorTypeNode, typeParameters: NodeArray<TypeParameterDeclaration> | undefined, parameters: NodeArray<ParameterDeclaration>, type: TypeNode | undefined): ConstructorTypeNode {
+        return <ConstructorTypeNode>updateSignatureDeclaration(node, typeParameters, parameters, type);
+    }
+
+    export function createCallSignatureDeclaration(typeParameters: TypeParameterDeclaration[] | undefined, parameters: ParameterDeclaration[], type: TypeNode | undefined): CallSignatureDeclaration {
+        return createSignatureDeclaration(SyntaxKind.CallSignature, typeParameters, parameters, type) as CallSignatureDeclaration;
+    }
+    export function updateCallSignatureDeclaration(node: CallSignatureDeclaration, typeParameters: NodeArray<TypeParameterDeclaration> | undefined, parameters: NodeArray<ParameterDeclaration>, type: TypeNode | undefined): CallSignatureDeclaration {
+        return <CallSignatureDeclaration>updateSignatureDeclaration(node, typeParameters, parameters, type);
+    }
+
+    export function createConstructSignatureDeclaration(typeParameters: TypeParameterDeclaration[] | undefined, parameters: ParameterDeclaration[], type: TypeNode | undefined): ConstructSignatureDeclaration {
+        return createSignatureDeclaration(SyntaxKind.ConstructSignature, typeParameters, parameters, type) as ConstructSignatureDeclaration;
+    }
+    export function updateConstructSignatureDeclaration(node: ConstructSignatureDeclaration, typeParameters: NodeArray<TypeParameterDeclaration> | undefined, parameters: NodeArray<ParameterDeclaration>, type: TypeNode | undefined): ConstructSignatureDeclaration {
+        return <ConstructSignatureDeclaration>updateSignatureDeclaration(node, typeParameters, parameters, type);
+    }
+
+    export function createMethodSignature(typeParameters: TypeParameterDeclaration[] | undefined, parameters: ParameterDeclaration[], type: TypeNode | undefined, name: string | PropertyName, questionToken: QuestionToken | undefined): MethodSignature{
+        const methodSignature = createSignatureDeclaration(SyntaxKind.MethodSignature, typeParameters, parameters, type) as MethodSignature;
+        methodSignature.name = asName(name);
+        methodSignature.questionToken = questionToken;
+        return methodSignature;
+    }
+
+    export function updateMethodSignature(node: MethodSignature, typeParameters: NodeArray<TypeParameterDeclaration> | undefined, parameters: NodeArray<ParameterDeclaration>, type: TypeNode | undefined, name?: PropertyName, questionToken?: QuestionToken): MethodSignature {
         return node.typeParameters !== typeParameters
             || node.parameters !== parameters
             || node.type !== type
             || node.name !== name
             || node.questionToken !== questionToken
-            ? updateNode(createSignatureDeclaration<T>(node.kind, typeParameters, parameters, type, name, questionToken), node)
+            ? updateNode(createMethodSignature(typeParameters, parameters, type, name, questionToken), node)
             : node;
     }
 
@@ -502,7 +539,7 @@ namespace ts {
             : node;
     }
 
-    export function createMethod(decorators: Decorator[] | undefined, modifiers: Modifier[] | undefined, asteriskToken: AsteriskToken | undefined, name: string | PropertyName, questionToken: QuestionToken | undefined, typeParameters: TypeParameterDeclaration[] | undefined, parameters: ParameterDeclaration[], type: TypeNode | undefined, body: Block | undefined) {
+    export function createMethodDeclaration(decorators: Decorator[] | undefined, modifiers: Modifier[] | undefined, asteriskToken: AsteriskToken | undefined, name: string | PropertyName, questionToken: QuestionToken | undefined, typeParameters: TypeParameterDeclaration[] | undefined, parameters: ParameterDeclaration[], type: TypeNode | undefined, body: Block | undefined) {
         const node = <MethodDeclaration>createSynthesizedNode(SyntaxKind.MethodDeclaration);
         node.decorators = asNodeArray(decorators);
         node.modifiers = asNodeArray(modifiers);
@@ -525,7 +562,7 @@ namespace ts {
             || node.parameters !== parameters
             || node.type !== type
             || node.body !== body
-            ? updateNode(createMethod(decorators, modifiers, asteriskToken, name, questionToken, typeParameters, parameters, type, body), node)
+            ? updateNode(createMethodDeclaration(decorators, modifiers, asteriskToken, name, questionToken, typeParameters, parameters, type, body), node)
             : node;
     }
 
diff --git a/src/compiler/visitor.ts b/src/compiler/visitor.ts
index 57de104b0ca..e6df9c211e7 100644
--- a/src/compiler/visitor.ts
+++ b/src/compiler/visitor.ts
@@ -260,21 +260,36 @@ namespace ts {
 
             // Signatures and Signature Elements
             case SyntaxKind.FunctionType:
+                return updateFunctionTypeNode(<FunctionTypeNode>node,
+                    nodesVisitor((<FunctionTypeNode>node).typeParameters, visitor, isTypeParameter),
+                    visitParameterList((<FunctionTypeNode>node).parameters, visitor, context, nodesVisitor),
+                    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),
+                    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),
+                    visitNode((<CallSignatureDeclaration>node).type, visitor, isTypeNode));
+
             case SyntaxKind.ConstructSignature:
-                return updateSignatureDeclaration(<SignatureDeclaration>node,
-                    nodesVisitor((<SignatureDeclaration>node).typeParameters, visitor, isTypeParameter),
-                    visitParameterList((<SignatureDeclaration>node).parameters, visitor, context, nodesVisitor),
-                    visitNode((<SignatureDeclaration>node).type, visitor, isTypeNode));
+                return updateConstructSignatureDeclaration(<ConstructSignatureDeclaration>node,
+                    nodesVisitor((<ConstructSignatureDeclaration>node).typeParameters, visitor, isTypeParameter),
+                    visitParameterList((<ConstructSignatureDeclaration>node).parameters, visitor, context, nodesVisitor),
+                    visitNode((<ConstructSignatureDeclaration>node).type, visitor, isTypeNode));
 
             case SyntaxKind.MethodSignature:
-                return updateSignatureDeclaration(<SignatureDeclaration & TypeElement>node,
-                    nodesVisitor((<SignatureDeclaration & TypeElement>node).typeParameters, visitor, isTypeParameter),
-                    visitParameterList((<SignatureDeclaration & TypeElement>node).parameters, visitor, context, nodesVisitor),
-                    visitNode((<SignatureDeclaration & TypeElement>node).type, visitor, isTypeNode),
-                    visitNode((<SignatureDeclaration & TypeElement>node).name, visitor, isPropertyName),
-                    visitNode((<SignatureDeclaration & TypeElement>node).questionToken, tokenVisitor, isToken));
+                return updateMethodSignature(<MethodSignature>node,
+                    nodesVisitor((<MethodSignature>node).typeParameters, visitor, isTypeParameter),
+                    visitParameterList((<MethodSignature>node).parameters, visitor, context, nodesVisitor),
+                    visitNode((<MethodSignature>node).type, visitor, isTypeNode),
+                    visitNode((<MethodSignature>node).name, visitor, isPropertyName),
+                    visitNode((<MethodSignature>node).questionToken, tokenVisitor, isToken));
 
             case SyntaxKind.IndexSignature:
                 return updateIndexSignatureDeclaration(<IndexSignatureDeclaration>node,
diff --git a/src/services/codefixes/helpers.ts b/src/services/codefixes/helpers.ts
index da729215087..0000bd97c56 100644
--- a/src/services/codefixes/helpers.ts
+++ b/src/services/codefixes/helpers.ts
@@ -100,7 +100,7 @@ namespace ts.codefix {
                 if (declarations.length === 1) {
                     Debug.assert(signatures.length === 1);
                     const signature = signatures[0];
-                    const signatureDeclaration = checker.signatureToSignatureDeclaration(signature, SyntaxKind.MethodDeclaration, enclosingDeclaration) as MethodDeclaration;
+                    const signatureDeclaration = <MethodDeclaration>checker.signatureToSignatureDeclaration(signature, SyntaxKind.MethodDeclaration, enclosingDeclaration);
                     signatureDeclaration.modifiers = modifiers;
                     signatureDeclaration.name = name;
                     signatureDeclaration.questionToken = optional ? createToken(SyntaxKind.QuestionToken) : undefined;
@@ -111,7 +111,7 @@ namespace ts.codefix {
                 let signatureDeclarations = [];
                 for (let i = 0; i < signatures.length; i++) {
                     const signature = signatures[i];
-                    const signatureDeclaration = checker.signatureToSignatureDeclaration(signature, SyntaxKind.MethodDeclaration, enclosingDeclaration) as MethodDeclaration;
+                    const signatureDeclaration = <MethodDeclaration>checker.signatureToSignatureDeclaration(signature, SyntaxKind.MethodDeclaration, enclosingDeclaration);
                     signatureDeclaration.modifiers = modifiers;
                     signatureDeclaration.name = name;
                     signatureDeclaration.questionToken = optional ? createToken(SyntaxKind.QuestionToken) : undefined;
@@ -120,7 +120,7 @@ namespace ts.codefix {
 
                 if (declarations.length > signatures.length) {
                     let signature = checker.getSignatureFromDeclaration(declarations[declarations.length - 1] as SignatureDeclaration);
-                    const signatureDeclaration = checker.signatureToSignatureDeclaration(signature, SyntaxKind.MethodDeclaration, enclosingDeclaration) as MethodDeclaration;
+                    const signatureDeclaration = <MethodDeclaration>checker.signatureToSignatureDeclaration(signature, SyntaxKind.MethodDeclaration, enclosingDeclaration);
                     signatureDeclaration.modifiers = modifiers;
                     signatureDeclaration.name = name;
                     signatureDeclaration.questionToken = optional ? createToken(SyntaxKind.QuestionToken) : undefined;
@@ -197,7 +197,7 @@ namespace ts.codefix {
     }
 
     export function createStubbedMethod(modifiers: Modifier[], name: PropertyName, optional: boolean, typeParameters: TypeParameterDeclaration[] | undefined, parameters: ParameterDeclaration[], returnType: TypeNode | undefined) {
-        return createMethod(
+        return createMethodDeclaration(
             /*decorators*/ undefined,
             modifiers,
             /*asteriskToken*/ undefined,