more temp

Author: Arthur Ozga

src/compiler/checker.ts

@@ -255,25 +255,8 @@ namespace ts {
             : node;
     }
 
-    export function createSignatureDeclaration<T extends SignatureDeclaration>(kind: SyntaxKind, name: string | PropertyName | undefined, typeParameters: NodeArray<TypeParameterDeclaration> | undefined, parameters: NodeArray<ParameterDeclaration>, type: TypeNode | undefined): T {
-        const signatureDeclaration = createSynthesizedNode(kind) as T;
-        signatureDeclaration.name = asName(name);
-        signatureDeclaration.typeParameters = asNodeArray(typeParameters);
-        signatureDeclaration.type = type;
-        return signatureDeclaration;
-    }
-
-    export function updateSignatureDeclaration<T extends SignatureDeclaration>(node: T, name: string | PropertyName | undefined, typeParameters: NodeArray<TypeParameterDeclaration> | undefined, parameters: NodeArray<ParameterDeclaration>, type: TypeNode | undefined): T {
-        return node.name !== name
-            || node.typeParameters !== typeParameters
-            || node.type !== type
-            ? <T>updateNode(createSignatureDeclaration(node.kind, name, typeParameters, parameters, type), node)
-            : node;
-    }
-    
     export function createTypeReferenceNode(typeName: string | EntityName, typeArguments: NodeArray<TypeNode> | undefined) {
         const typeReference = createSynthesizedNode(SyntaxKind.TypeReference) as TypeReferenceNode;
-
         typeReference.typeName = isQualifiedName(<EntityName>typeName) ? <QualifiedName>typeName : asName(<string | Identifier>typeName);
         typeReference.typeArguments = typeArguments;
         return typeReference;
@@ -286,6 +269,16 @@ namespace ts {
             : node;
     }
 
+    export function createTypeQueryNode(exprName: EntityName) {
+        const typeQueryNode = createSynthesizedNode(SyntaxKind.TypeQuery) as TypeQueryNode;
+        typeQueryNode.exprName = exprName;
+        return typeQueryNode;
+    }
+
+    export function updateTypeQueryNode(node: TypeQueryNode, exprName: EntityName) {
+        return node.exprName !== exprName ? updateNode(createTypeQueryNode(exprName) , node) : node;
+    }
+
     export function createArrayTypeNode(elementType: TypeNode): ArrayTypeNode {
         const arrayTypeNode = createSynthesizedNode(SyntaxKind.ArrayType) as ArrayTypeNode;
         arrayTypeNode.elementType = elementType;
@@ -355,6 +348,33 @@ namespace ts {
             : node;
     }
 
+    export function createTypeOperatorNode(type: TypeNode) {
+        const typeOperatorNode = createSynthesizedNode(SyntaxKind.TypeOperator) as TypeOperatorNode;
+        typeOperatorNode.operator = SyntaxKind.KeyOfKeyword;
+        typeOperatorNode.type = type
+        return typeOperatorNode;
+    }
+
+    export function updateTypeOperatorNode(node: TypeOperatorNode, type: TypeNode) {
+        return node.type !== type ? updateNode(createTypeOperatorNode(type), node) : node;
+    }
+
+    export function createIndexedAccessTypeNode(objectType: TypeNode, indexType: TypeNode) {
+        const indexedAccessTypeNode = createSynthesizedNode(SyntaxKind.IndexedAccessType) as IndexedAccessTypeNode;
+        indexedAccessTypeNode.objectType = objectType;
+        indexedAccessTypeNode.indexType = indexType;
+        return indexedAccessTypeNode;
+    }
+
+
+    export function updateIndexedAccessTypeNode(node: IndexedAccessTypeNode, objectType: TypeNode, indexType: TypeNode) {
+        return node.objectType !== objectType
+            || node.indexType !== indexType
+            ? updateNode(createIndexedAccessTypeNode(objectType, indexType), node)
+            : node;
+    }
+
+
     // Type Declarations
 
     export function createTypeParameterDeclaration(name: string | Identifier, constraint: TypeNode | undefined, defaultParameter: TypeNode | undefined) {
@@ -374,6 +394,24 @@ namespace ts {
             : node;
     }
 
+    export function createSignatureDeclaration<T extends SignatureDeclaration>(kind: SyntaxKind, name: string | PropertyName | undefined, typeParameters: NodeArray<TypeParameterDeclaration> | undefined, parameters: NodeArray<ParameterDeclaration>, type: TypeNode | undefined): T {
+        const signatureDeclaration = createSynthesizedNode(kind) as T;
+        signatureDeclaration.name = asName(name);
+        signatureDeclaration.typeParameters = asNodeArray(typeParameters);
+        signatureDeclaration.parameters = asNodeArray(parameters);
+        signatureDeclaration.type = type;
+        return signatureDeclaration;
+    }
+
+    export function updateSignatureDeclaration<T extends SignatureDeclaration>(node: T, name: string | PropertyName | undefined, typeParameters: NodeArray<TypeParameterDeclaration> | undefined, parameters: NodeArray<ParameterDeclaration>, type: TypeNode | undefined): T {
+        return node.name !== name
+            || node.typeParameters !== typeParameters
+            || node.parameters !== parameters
+            || node.type !== type
+            ? <T>updateNode(createSignatureDeclaration(node.kind, name, typeParameters, parameters, type), node)
+            : node;
+    }
+
     // Signature elements
 
     export function createPropertySignature(name: PropertyName, questionToken: QuestionToken | undefined, type: TypeNode | undefined, initializer: Expression | undefined): PropertySignature {

src/compiler/factory.ts

@@ -320,13 +320,13 @@ namespace ts {
             case SyntaxKind.ConstructorType:
                 throw new Error("reached unsupported type in visitor.");
             case SyntaxKind.TypeQuery:
-                throw new Error("reached unsupported type in visitor.");
+                return updateTypeQueryNode((<TypeQueryNode>node), visitNode((<TypeQueryNode>node).exprName, visitor, isEntityName));
             case SyntaxKind.TypeLiteral:
                 return updateTypeLiteralNode((<TypeLiteralNode>node), nodesVisitor((<TypeLiteralNode>node).members, visitor));
             case SyntaxKind.ArrayType:
                 return updateArrayTypeNode(<ArrayTypeNode>node, visitNode((<ArrayTypeNode>node).elementType, visitor, isTypeNode));
             case SyntaxKind.TupleType:
-                throw new Error("reached unsupported type in visitor.");
+                return updateTypleTypeNode((<TupleTypeNode>node), nodesVisitor((<TupleTypeNode>node).elementTypes, visitor, isTypeNode));
             case SyntaxKind.UnionType:
             case SyntaxKind.IntersectionType:
                 return updateUnionOrIntersectionTypeNode(<UnionOrIntersectionTypeNode>node
@@ -336,9 +336,11 @@ namespace ts {
             case SyntaxKind.ThisType:
                 throw new Error("reached unsupported type in visitor.");
             case SyntaxKind.TypeOperator:
-                throw new Error("reached unsupported type in visitor.");
+                return updateTypeOperatorNode(<TypeOperatorNode>node, visitNode((<TypeOperatorNode>node).type, visitor, isTypeNode));
             case SyntaxKind.IndexedAccessType:
-                throw new Error("reached unsupported type in visitor.");
+                return updateIndexedAccessTypeNode((<IndexedAccessTypeNode>node)
+                , visitNode((<IndexedAccessTypeNode>node).objectType, visitor, isTypeNode)
+                , visitNode((<IndexedAccessTypeNode>node).indexType, visitor, isTypeNode));
             case SyntaxKind.MappedType:
                 throw new Error("reached unsupported type in visitor.");
             case SyntaxKind.LiteralType:

src/compiler/visitor.ts

@@ -0,0 +1,10 @@
+/// <reference path='fourslash.ts' />
+
+//// interface I {
+////     (x: number, b: string): number;
+//// }
+//// class C implements I {[| |]}
+
+verify.not.codeFixAvailable();
+
+

tests/cases/fourslash/codeFixClassImplementInterfaceCallSignature.ts

@@ -0,0 +1,10 @@
+/// <reference path='fourslash.ts' />
+
+//// interface I {
+////     new (x: number, b: string);
+//// }
+//// class C implements I {[| |]}
+
+verify.not.codeFixAvailable();
+
+

tests/cases/fourslash/codeFixClassImplementInterfaceConstructSignature.ts

@@ -0,0 +1,13 @@
+/// <reference path='fourslash.ts' />
+
+//// interface I {
+////     a1: { (b1: number, c1: string): number; };
+////     a2: (b2: number, c2: string) => number;
+//// }
+//// class C implements I {[| |]}
+
+verify.rangeAfterCodeFix(`
+    a1: (b1: number, c1: string) => number;
+    a2: (b2: number, c2: string) => number;
+`);
+

tests/cases/fourslash/codeFixClassImplementInterfacePropertyCallSignature.ts

@@ -0,0 +1,12 @@
+/// <reference path='fourslash.ts' />
+
+//// interface I {
+////     a1: { new (b1: number, c1: string): number; };
+////     a2: new (b2: number, c2: string) => number;
+//// }
+//// class C implements I {[| |]}
+
+verify.rangeAfterCodeFix(`
+    a1: new (b1: number, c1: string) => number;
+    a2: new (b2: number, c2: string) => number;
+`);

tests/cases/fourslash/codeFixClassImplementInterfacePropertyConstructSignature.1.ts

@@ -0,0 +1,11 @@
+/// <reference path='fourslash.ts' />
+
+//// interface I {
+////     x: { a(b: number, c: string): number };
+//// }
+//// class C implements I {[| |]}
+
+verify.rangeAfterCodeFix(`
+    a: { (b: number, c: string): number; };
+`);
+