Merge pull request microsoft#10506 from Microsoft/ctorTag

DanielRosenwasser · web-flow · commit 0485bb6b56b3 · 2016-08-28T22:42:04.000-07:00
Issue error when tagging templates and decorating with only-constructable entities
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
@@ -11960,18 +11960,12 @@ namespace ts {
             // Function interface, since they have none by default. This is a bit of a leap of faith
             // that the user will not add any.
             const callSignatures = getSignaturesOfType(apparentType, SignatureKind.Call);
-
             const constructSignatures = getSignaturesOfType(apparentType, SignatureKind.Construct);
-            // TS 1.0 spec: 4.12
-            // If FuncExpr is of type Any, or of an object type that has no call or construct signatures
-            // but is a subtype of the Function interface, the call is an untyped function call. In an
-            // untyped function call no TypeArgs are permitted, Args can be any argument list, no contextual
+
+            // TS 1.0 Spec: 4.12
+            // In an untyped function call no TypeArgs are permitted, Args can be any argument list, no contextual
             // types are provided for the argument expressions, and the result is always of type Any.
-            // We exclude union types because we may have a union of function types that happen to have
-            // no common signatures.
-            if (isTypeAny(funcType) ||
-                (isTypeAny(apparentType) && funcType.flags & TypeFlags.TypeParameter) ||
-                (!callSignatures.length && !constructSignatures.length && !(funcType.flags & TypeFlags.Union) && isTypeAssignableTo(funcType, globalFunctionType))) {
+            if (isUntypedFunctionCall(funcType, apparentType, callSignatures.length, constructSignatures.length)) {
                 // The unknownType indicates that an error already occurred (and was reported).  No
                 // need to report another error in this case.
                 if (funcType !== unknownType && node.typeArguments) {
@@ -11994,6 +11988,29 @@ namespace ts {
             return resolveCall(node, callSignatures, candidatesOutArray);
         }
 
+        /**
+         * TS 1.0 spec: 4.12
+         * If FuncExpr is of type Any, or of an object type that has no call or construct signatures
+         * but is a subtype of the Function interface, the call is an untyped function call.
+         */
+        function isUntypedFunctionCall(funcType: Type, apparentFuncType: Type, numCallSignatures: number, numConstructSignatures: number) {
+            if (isTypeAny(funcType)) {
+                return true;
+            }
+            if (isTypeAny(apparentFuncType) && funcType.flags & TypeFlags.TypeParameter) {
+                return true;
+            }
+            if (!numCallSignatures && !numConstructSignatures) {
+                // We exclude union types because we may have a union of function types that happen to have
+                // no common signatures.
+                if (funcType.flags & TypeFlags.Union) {
+                    return false;
+                }
+                return isTypeAssignableTo(funcType, globalFunctionType);
+            }
+            return false;
+        }
+
         function resolveNewExpression(node: NewExpression, candidatesOutArray: Signature[]): Signature {
             if (node.arguments && languageVersion < ScriptTarget.ES5) {
                 const spreadIndex = getSpreadArgumentIndex(node.arguments);
@@ -12119,8 +12136,9 @@ namespace ts {
             }
 
             const callSignatures = getSignaturesOfType(apparentType, SignatureKind.Call);
+            const constructSignatures = getSignaturesOfType(apparentType, SignatureKind.Construct);
 
-            if (isTypeAny(tagType) || (!callSignatures.length && !(tagType.flags & TypeFlags.Union) && isTypeAssignableTo(tagType, globalFunctionType))) {
+            if (isUntypedFunctionCall(tagType, apparentType, callSignatures.length, constructSignatures.length)) {
                 return resolveUntypedCall(node);
             }
 
@@ -12165,7 +12183,8 @@ namespace ts {
             }
 
             const callSignatures = getSignaturesOfType(apparentType, SignatureKind.Call);
-            if (funcType === anyType || (!callSignatures.length && !(funcType.flags & TypeFlags.Union) && isTypeAssignableTo(funcType, globalFunctionType))) {
+            const constructSignatures = getSignaturesOfType(apparentType, SignatureKind.Construct);
+            if (isUntypedFunctionCall(funcType, apparentType, callSignatures.length, constructSignatures.length)) {
                 return resolveUntypedCall(node);
             }
 
diff --git a/tests/baselines/reference/constructableDecoratorOnClass01.errors.txt b/tests/baselines/reference/constructableDecoratorOnClass01.errors.txt
@@ -0,0 +1,16 @@
+tests/cases/conformance/decorators/class/constructableDecoratorOnClass01.ts(4,1): error TS1238: Unable to resolve signature of class decorator when called as an expression.
+  Cannot invoke an expression whose type lacks a call signature.
+
+
+==== tests/cases/conformance/decorators/class/constructableDecoratorOnClass01.ts (1 errors) ====
+    
+    class CtorDtor {}
+    
+    @CtorDtor
+    ~~~~~~~~~
+!!! error TS1238: Unable to resolve signature of class decorator when called as an expression.
+!!! error TS1238:   Cannot invoke an expression whose type lacks a call signature.
+    class C {
+    
+    }
+    
diff --git a/tests/baselines/reference/constructableDecoratorOnClass01.js b/tests/baselines/reference/constructableDecoratorOnClass01.js
@@ -0,0 +1,30 @@
+//// [constructableDecoratorOnClass01.ts]
+
+class CtorDtor {}
+
+@CtorDtor
+class C {
+
+}
+
+
+//// [constructableDecoratorOnClass01.js]
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var CtorDtor = (function () {
+    function CtorDtor() {
+    }
+    return CtorDtor;
+}());
+var C = (function () {
+    function C() {
+    }
+    C = __decorate([
+        CtorDtor
+    ], C);
+    return C;
+}());
diff --git a/tests/baselines/reference/constructableDecoratorOnClass01.symbols b/tests/baselines/reference/constructableDecoratorOnClass01.symbols
@@ -0,0 +1,13 @@
+=== tests/cases/conformance/decorators/class/constructableDecoratorOnClass01.ts ===
+
+class CtorDtor {}
+>CtorDtor : Symbol(CtorDtor, Decl(constructableDecoratorOnClass01.ts, 0, 0))
+
+@CtorDtor
+>CtorDtor : Symbol(CtorDtor, Decl(constructableDecoratorOnClass01.ts, 0, 0))
+
+class C {
+>C : Symbol(C, Decl(constructableDecoratorOnClass01.ts, 1, 17))
+
+}
+
diff --git a/tests/baselines/reference/constructableDecoratorOnClass01.types b/tests/baselines/reference/constructableDecoratorOnClass01.types
@@ -0,0 +1,13 @@
+=== tests/cases/conformance/decorators/class/constructableDecoratorOnClass01.ts ===
+
+class CtorDtor {}
+>CtorDtor : CtorDtor
+
+@CtorDtor
+>CtorDtor : typeof CtorDtor
+
+class C {
+>C : C
+
+}
+
diff --git a/tests/baselines/reference/taggedTemplateUntypedTagCall01.js b/tests/baselines/reference/taggedTemplateUntypedTagCall01.js
@@ -0,0 +1,8 @@
+//// [taggedTemplateUntypedTagCall01.ts]
+var tag: Function;
+tag `Hello world!`;
+
+//// [taggedTemplateUntypedTagCall01.js]
+var tag;
+(_a = ["Hello world!"], _a.raw = ["Hello world!"], tag(_a));
+var _a;
diff --git a/tests/baselines/reference/taggedTemplateUntypedTagCall01.symbols b/tests/baselines/reference/taggedTemplateUntypedTagCall01.symbols
@@ -0,0 +1,8 @@
+=== tests/cases/conformance/es6/templates/taggedTemplateUntypedTagCall01.ts ===
+var tag: Function;
+>tag : Symbol(tag, Decl(taggedTemplateUntypedTagCall01.ts, 0, 3))
+>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+
+tag `Hello world!`;
+>tag : Symbol(tag, Decl(taggedTemplateUntypedTagCall01.ts, 0, 3))
+
diff --git a/tests/baselines/reference/taggedTemplateUntypedTagCall01.types b/tests/baselines/reference/taggedTemplateUntypedTagCall01.types
@@ -0,0 +1,10 @@
+=== tests/cases/conformance/es6/templates/taggedTemplateUntypedTagCall01.ts ===
+var tag: Function;
+>tag : Function
+>Function : Function
+
+tag `Hello world!`;
+>tag `Hello world!` : any
+>tag : Function
+>`Hello world!` : string
+
diff --git a/tests/baselines/reference/taggedTemplateWithConstructableTag01.errors.txt b/tests/baselines/reference/taggedTemplateWithConstructableTag01.errors.txt
@@ -0,0 +1,9 @@
+tests/cases/conformance/es6/templates/taggedTemplateWithConstructableTag01.ts(3,1): error TS2349: Cannot invoke an expression whose type lacks a call signature.
+
+
+==== tests/cases/conformance/es6/templates/taggedTemplateWithConstructableTag01.ts (1 errors) ====
+    class CtorTag { }
+    
+    CtorTag `Hello world!`;
+    ~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS2349: Cannot invoke an expression whose type lacks a call signature.
diff --git a/tests/baselines/reference/taggedTemplateWithConstructableTag01.js b/tests/baselines/reference/taggedTemplateWithConstructableTag01.js
@@ -0,0 +1,13 @@
+//// [taggedTemplateWithConstructableTag01.ts]
+class CtorTag { }
+
+CtorTag `Hello world!`;
+
+//// [taggedTemplateWithConstructableTag01.js]
+var CtorTag = (function () {
+    function CtorTag() {
+    }
+    return CtorTag;
+}());
+(_a = ["Hello world!"], _a.raw = ["Hello world!"], CtorTag(_a));
+var _a;
diff --git a/tests/baselines/reference/taggedTemplateWithConstructableTag01.symbols b/tests/baselines/reference/taggedTemplateWithConstructableTag01.symbols
@@ -0,0 +1,7 @@
+=== tests/cases/conformance/es6/templates/taggedTemplateWithConstructableTag01.ts ===
+class CtorTag { }
+>CtorTag : Symbol(CtorTag, Decl(taggedTemplateWithConstructableTag01.ts, 0, 0))
+
+CtorTag `Hello world!`;
+>CtorTag : Symbol(CtorTag, Decl(taggedTemplateWithConstructableTag01.ts, 0, 0))
+
diff --git a/tests/baselines/reference/taggedTemplateWithConstructableTag01.types b/tests/baselines/reference/taggedTemplateWithConstructableTag01.types
@@ -0,0 +1,9 @@
+=== tests/cases/conformance/es6/templates/taggedTemplateWithConstructableTag01.ts ===
+class CtorTag { }
+>CtorTag : CtorTag
+
+CtorTag `Hello world!`;
+>CtorTag `Hello world!` : any
+>CtorTag : typeof CtorTag
+>`Hello world!` : string
+
diff --git a/tests/baselines/reference/taggedTemplateWithConstructableTag02.errors.txt b/tests/baselines/reference/taggedTemplateWithConstructableTag02.errors.txt
@@ -0,0 +1,12 @@
+tests/cases/conformance/es6/templates/taggedTemplateWithConstructableTag02.ts(6,1): error TS2349: Cannot invoke an expression whose type lacks a call signature.
+
+
+==== tests/cases/conformance/es6/templates/taggedTemplateWithConstructableTag02.ts (1 errors) ====
+    interface I {
+        new (...args: any[]): string;
+        new (): number;
+    }
+    var tag: I;
+    tag `Hello world!`;
+    ~~~~~~~~~~~~~~~~~~
+!!! error TS2349: Cannot invoke an expression whose type lacks a call signature.
diff --git a/tests/baselines/reference/taggedTemplateWithConstructableTag02.js b/tests/baselines/reference/taggedTemplateWithConstructableTag02.js
@@ -0,0 +1,12 @@
+//// [taggedTemplateWithConstructableTag02.ts]
+interface I {
+    new (...args: any[]): string;
+    new (): number;
+}
+var tag: I;
+tag `Hello world!`;
+
+//// [taggedTemplateWithConstructableTag02.js]
+var tag;
+(_a = ["Hello world!"], _a.raw = ["Hello world!"], tag(_a));
+var _a;
diff --git a/tests/baselines/reference/taggedTemplateWithConstructableTag02.symbols b/tests/baselines/reference/taggedTemplateWithConstructableTag02.symbols
@@ -0,0 +1,16 @@
+=== tests/cases/conformance/es6/templates/taggedTemplateWithConstructableTag02.ts ===
+interface I {
+>I : Symbol(I, Decl(taggedTemplateWithConstructableTag02.ts, 0, 0))
+
+    new (...args: any[]): string;
+>args : Symbol(args, Decl(taggedTemplateWithConstructableTag02.ts, 1, 9))
+
+    new (): number;
+}
+var tag: I;
+>tag : Symbol(tag, Decl(taggedTemplateWithConstructableTag02.ts, 4, 3))
+>I : Symbol(I, Decl(taggedTemplateWithConstructableTag02.ts, 0, 0))
+
+tag `Hello world!`;
+>tag : Symbol(tag, Decl(taggedTemplateWithConstructableTag02.ts, 4, 3))
+
diff --git a/tests/baselines/reference/taggedTemplateWithConstructableTag02.types b/tests/baselines/reference/taggedTemplateWithConstructableTag02.types
@@ -0,0 +1,18 @@
+=== tests/cases/conformance/es6/templates/taggedTemplateWithConstructableTag02.ts ===
+interface I {
+>I : I
+
+    new (...args: any[]): string;
+>args : any[]
+
+    new (): number;
+}
+var tag: I;
+>tag : I
+>I : I
+
+tag `Hello world!`;
+>tag `Hello world!` : any
+>tag : I
+>`Hello world!` : string
+
diff --git a/tests/cases/conformance/decorators/class/constructableDecoratorOnClass01.ts b/tests/cases/conformance/decorators/class/constructableDecoratorOnClass01.ts
@@ -0,0 +1,8 @@
+// @experimentalDecorators: true
+
+class CtorDtor {}
+
+@CtorDtor
+class C {
+
+}
diff --git a/tests/cases/conformance/es6/templates/taggedTemplateUntypedTagCall01.ts b/tests/cases/conformance/es6/templates/taggedTemplateUntypedTagCall01.ts
@@ -0,0 +1,2 @@
+var tag: Function;
+tag `Hello world!`;
diff --git a/tests/cases/conformance/es6/templates/taggedTemplateWithConstructableTag01.ts b/tests/cases/conformance/es6/templates/taggedTemplateWithConstructableTag01.ts
@@ -0,0 +1,3 @@
+class CtorTag { }
+
+CtorTag `Hello world!`;
diff --git a/tests/cases/conformance/es6/templates/taggedTemplateWithConstructableTag02.ts b/tests/cases/conformance/es6/templates/taggedTemplateWithConstructableTag02.ts
@@ -0,0 +1,6 @@
+interface I {
+    new (...args: any[]): string;
+    new (): number;
+}
+var tag: I;
+tag `Hello world!`;
