differentiate between call and construct

Author: bakkot

src/compiler/checker.ts

@@ -18442,7 +18442,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
         target: Signature,
         ignoreReturnTypes: boolean): boolean {
         return compareSignaturesRelated(source, target, ignoreReturnTypes ? SignatureCheckMode.IgnoreReturnTypes : 0, /*reportErrors*/ false,
-            /*errorReporter*/ undefined, /*errorReporter*/ undefined, compareTypesAssignable, /*reportUnreliableMarkers*/ undefined) !== Ternary.False;
+            /*errorReporter*/ undefined, /*incompatibleErrorReporter*/ undefined, /*signatureKindForErrors*/ undefined, compareTypesAssignable, /*reportUnreliableMarkers*/ undefined) !== Ternary.False;
     }
 
     type ErrorReporter = (message: DiagnosticMessage, arg0?: string, arg1?: string) => void;
@@ -18465,6 +18465,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
         reportErrors: boolean,
         errorReporter: ErrorReporter | undefined,
         incompatibleErrorReporter: ((source: Type, target: Type) => void) | undefined,
+        signatureKindForErrors: SignatureKind | undefined,
         compareTypes: TypeComparer,
         reportUnreliableMarkers: TypeMapper | undefined): Ternary {
         // TODO (drosen): De-duplicate code between related functions.
@@ -18481,7 +18482,8 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
             (checkMode & SignatureCheckMode.StrictArity ? hasEffectiveRestParameter(source) || getParameterCount(source) > targetCount : getMinArgumentCount(source) > targetCount);
         if (sourceHasMoreParameters) {
             if (reportErrors) {
-                errorReporter!(Diagnostics.Call_signature_0_expects_more_arguments_than_call_signature_1, signatureToString(source), signatureToString(target));
+                const diagnostic = signatureKindForErrors! === SignatureKind.Call ? Diagnostics.Call_signature_0_expects_more_arguments_than_call_signature_1 : Diagnostics.Construct_signature_0_expects_more_arguments_than_construct_signature_1;
+                errorReporter!(diagnostic, signatureToString(source), signatureToString(target));
             }
             return Ternary.False;
         }
@@ -18540,7 +18542,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
                 const callbacks = sourceSig && targetSig && !getTypePredicateOfSignature(sourceSig) && !getTypePredicateOfSignature(targetSig) &&
                     (getTypeFacts(sourceType) & TypeFacts.IsUndefinedOrNull) === (getTypeFacts(targetType) & TypeFacts.IsUndefinedOrNull);
                 let related = callbacks ?
-                    compareSignaturesRelated(targetSig, sourceSig, (checkMode & SignatureCheckMode.StrictArity) | (strictVariance ? SignatureCheckMode.StrictCallback : SignatureCheckMode.BivariantCallback), reportErrors, errorReporter, incompatibleErrorReporter, compareTypes, reportUnreliableMarkers) :
+                    compareSignaturesRelated(targetSig, sourceSig, (checkMode & SignatureCheckMode.StrictArity) | (strictVariance ? SignatureCheckMode.StrictCallback : SignatureCheckMode.BivariantCallback), reportErrors, errorReporter, incompatibleErrorReporter, signatureKindForErrors, compareTypes, reportUnreliableMarkers) :
                     !(checkMode & SignatureCheckMode.Callback) && !strictVariance && compareTypes(sourceType, targetType, /*reportErrors*/ false) || compareTypes(targetType, sourceType, reportErrors);
                 // With strict arity, (x: number | undefined) => void is a subtype of (x?: number | undefined) => void
                 if (related && checkMode & SignatureCheckMode.StrictArity && i >= getMinArgumentCount(source) && i < getMinArgumentCount(target) && compareTypes(sourceType, targetType, /*reportErrors*/ false)) {
@@ -20914,7 +20916,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
                 // of the much more expensive N * M comparison matrix we explore below. We erase type parameters
                 // as they are known to always be the same.
                 for (let i = 0; i < targetSignatures.length; i++) {
-                    const related = signatureRelatedTo(sourceSignatures[i], targetSignatures[i], /*erase*/ true, reportErrors, incompatibleReporter(sourceSignatures[i], targetSignatures[i]));
+                    const related = signatureRelatedTo(sourceSignatures[i], targetSignatures[i], /*erase*/ true, reportErrors, incompatibleReporter(sourceSignatures[i], targetSignatures[i]), kind);
                     if (!related) {
                         return Ternary.False;
                     }
@@ -20930,7 +20932,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
                 const eraseGenerics = relation === comparableRelation || !!compilerOptions.noStrictGenericChecks;
                 const sourceSignature = first(sourceSignatures);
                 const targetSignature = first(targetSignatures);
-                result = signatureRelatedTo(sourceSignature, targetSignature, eraseGenerics, reportErrors, incompatibleReporter(sourceSignature, targetSignature));
+                result = signatureRelatedTo(sourceSignature, targetSignature, eraseGenerics, reportErrors, incompatibleReporter(sourceSignature, targetSignature), kind);
                 if (!result && reportErrors && kind === SignatureKind.Construct && (sourceObjectFlags & targetObjectFlags) &&
                     (targetSignature.declaration?.kind === SyntaxKind.Constructor || sourceSignature.declaration?.kind === SyntaxKind.Constructor)) {
                     const constructSignatureToString = (signature: Signature) =>
@@ -20946,7 +20948,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
                     // Only elaborate errors from the first failure
                     let shouldElaborateErrors = reportErrors;
                     for (const s of sourceSignatures) {
-                        const related = signatureRelatedTo(s, t, /*erase*/ true, shouldElaborateErrors, incompatibleReporter(s, t));
+                        const related = signatureRelatedTo(s, t, /*erase*/ true, shouldElaborateErrors, incompatibleReporter(s, t), kind);
                         if (related) {
                             result &= related;
                             resetErrorInfo(saveErrorInfo);
@@ -20996,9 +20998,9 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
         /**
          * See signatureAssignableTo, compareSignaturesIdentical
          */
-        function signatureRelatedTo(source: Signature, target: Signature, erase: boolean, reportErrors: boolean, incompatibleReporter: (source: Type, target: Type) => void): Ternary {
+        function signatureRelatedTo(source: Signature, target: Signature, erase: boolean, reportErrors: boolean, incompatibleReporter: (source: Type, target: Type) => void, signatureKind: SignatureKind): Ternary {
             return compareSignaturesRelated(erase ? getErasedSignature(source) : source, erase ? getErasedSignature(target) : target,
-                relation === strictSubtypeRelation ? SignatureCheckMode.StrictArity : 0, reportErrors, reportError, incompatibleReporter, isRelatedToWorker, reportUnreliableMapper);
+                relation === strictSubtypeRelation ? SignatureCheckMode.StrictArity : 0, reportErrors, reportError, incompatibleReporter, signatureKind, isRelatedToWorker, reportUnreliableMapper);
         }
 
         function signaturesIdenticalTo(source: Type, target: Type, kind: SignatureKind): Ternary {

src/compiler/diagnosticMessages.json

@@ -3567,6 +3567,10 @@
         "category": "Error",
         "code": 2846
     },
+    "Construct signature '{0}' expects more arguments than construct signature '{1}'.": {
+        "category": "Error",
+        "code": 2847
+    },
 
     "Import declaration '{0}' is using private name '{1}'.": {
         "category": "Error",

tests/baselines/reference/signatureLengthMismatchConstruct.errors.txt

@@ -0,0 +1,22 @@
+tests/cases/compiler/signatureLengthMismatchConstruct.ts(9,15): error TS2345: Argument of type 'typeof OverlongCtor' is not assignable to parameter of type 'new (a: number) => void'.
+  Types of construct signatures are incompatible.
+    Type 'new (a: number, b: number) => OverlongCtor' is not assignable to type 'new (a: number) => void'.
+      Construct signature '(a: number, b: number): OverlongCtor' expects more arguments than construct signature '(a: number): void'.
+
+
+==== tests/cases/compiler/signatureLengthMismatchConstruct.ts (1 errors) ====
+    function takesCallback(fn: new (a: number) => void) {
+      // ...
+    }
+    
+    class OverlongCtor {
+      constructor(a: number, b: number) {}
+    }
+    
+    takesCallback(OverlongCtor);
+                  ~~~~~~~~~~~~
+!!! error TS2345: Argument of type 'typeof OverlongCtor' is not assignable to parameter of type 'new (a: number) => void'.
+!!! error TS2345:   Types of construct signatures are incompatible.
+!!! error TS2345:     Type 'new (a: number, b: number) => OverlongCtor' is not assignable to type 'new (a: number) => void'.
+!!! error TS2345:       Construct signature '(a: number, b: number): OverlongCtor' expects more arguments than construct signature '(a: number): void'.
+    

tests/baselines/reference/signatureLengthMismatchConstruct.js

@@ -0,0 +1,22 @@
+//// [signatureLengthMismatchConstruct.ts]
+function takesCallback(fn: new (a: number) => void) {
+  // ...
+}
+
+class OverlongCtor {
+  constructor(a: number, b: number) {}
+}
+
+takesCallback(OverlongCtor);
+
+
+//// [signatureLengthMismatchConstruct.js]
+function takesCallback(fn) {
+    // ...
+}
+var OverlongCtor = /** @class */ (function () {
+    function OverlongCtor(a, b) {
+    }
+    return OverlongCtor;
+}());
+takesCallback(OverlongCtor);

tests/baselines/reference/signatureLengthMismatchConstruct.symbols

@@ -0,0 +1,21 @@
+=== tests/cases/compiler/signatureLengthMismatchConstruct.ts ===
+function takesCallback(fn: new (a: number) => void) {
+>takesCallback : Symbol(takesCallback, Decl(signatureLengthMismatchConstruct.ts, 0, 0))
+>fn : Symbol(fn, Decl(signatureLengthMismatchConstruct.ts, 0, 23))
+>a : Symbol(a, Decl(signatureLengthMismatchConstruct.ts, 0, 32))
+
+  // ...
+}
+
+class OverlongCtor {
+>OverlongCtor : Symbol(OverlongCtor, Decl(signatureLengthMismatchConstruct.ts, 2, 1))
+
+  constructor(a: number, b: number) {}
+>a : Symbol(a, Decl(signatureLengthMismatchConstruct.ts, 5, 14))
+>b : Symbol(b, Decl(signatureLengthMismatchConstruct.ts, 5, 24))
+}
+
+takesCallback(OverlongCtor);
+>takesCallback : Symbol(takesCallback, Decl(signatureLengthMismatchConstruct.ts, 0, 0))
+>OverlongCtor : Symbol(OverlongCtor, Decl(signatureLengthMismatchConstruct.ts, 2, 1))
+

tests/baselines/reference/signatureLengthMismatchConstruct.types

@@ -0,0 +1,22 @@
+=== tests/cases/compiler/signatureLengthMismatchConstruct.ts ===
+function takesCallback(fn: new (a: number) => void) {
+>takesCallback : (fn: new (a: number) => void) => void
+>fn : new (a: number) => void
+>a : number
+
+  // ...
+}
+
+class OverlongCtor {
+>OverlongCtor : OverlongCtor
+
+  constructor(a: number, b: number) {}
+>a : number
+>b : number
+}
+
+takesCallback(OverlongCtor);
+>takesCallback(OverlongCtor) : void
+>takesCallback : (fn: new (a: number) => void) => void
+>OverlongCtor : typeof OverlongCtor
+

tests/cases/compiler/signatureLengthMismatchConstruct.ts

@@ -0,0 +1,9 @@
+function takesCallback(fn: new (a: number) => void) {
+  // ...
+}
+
+class OverlongCtor {
+  constructor(a: number, b: number) {}
+}
+
+takesCallback(OverlongCtor);