Infer instance type arguments as constraint

Signed-off-by: Michael Molisani <[email protected]>

Author: molisani

src/compiler/checker.ts

@@ -383,6 +383,7 @@ m2: ${(this.mapper2 as unknown as DebugTypeMapper).__debugToString().split("\n")
         const noImplicitAny = getStrictOptionValue(compilerOptions, "noImplicitAny");
         const noImplicitThis = getStrictOptionValue(compilerOptions, "noImplicitThis");
         const useUnknownInCatchVariables = getStrictOptionValue(compilerOptions, "useUnknownInCatchVariables");
+        const inferInstanceTypeArgumentsAsConstraint = getStrictOptionValue(compilerOptions, "inferInstanceTypeArgumentsAsConstraint");
         const keyofStringsOnly = !!compilerOptions.keyofStringsOnly;
         const freshObjectLiteralFlag = compilerOptions.suppressExcessPropertyErrors ? 0 : ObjectFlags.FreshLiteral;
         const exactOptionalPropertyTypes = compilerOptions.exactOptionalPropertyTypes;
@@ -8700,13 +8701,25 @@ m2: ${(this.mapper2 as unknown as DebugTypeMapper).__debugToString().split("\n")
             })!.parent;
         }
 
+        function getInstanceTypeOfClassSymbol(classSymbol: Symbol): Type {
+            const classType = getDeclaredTypeOfSymbol(classSymbol) as InterfaceType;
+            if (!classType.typeParameters) {
+                return classType;
+            }
+            const typeArguments = map(classType.typeParameters, typeParameter => {
+                return (inferInstanceTypeArgumentsAsConstraint) ? getBaseConstraintOfType(typeParameter) || unknownType : anyType;
+            });
+            return createTypeReference(classType as GenericType, typeArguments);
+        }
+
         function getTypeOfPrototypeProperty(prototype: Symbol): Type {
             // TypeScript 1.0 spec (April 2014): 8.4
             // Every class automatically contains a static property member named 'prototype',
             // the type of which is an instantiation of the class type with type Any supplied as a type argument for each type parameter.
+            // FIXME: this needs to be updated to address new behavior with inferInstanceTypeArgumentsAsConstraint
             // It is an error to explicitly declare a static property member with the name 'prototype'.
-            const classType = getDeclaredTypeOfSymbol(getParentOfSymbol(prototype)!) as InterfaceType;
-            return classType.typeParameters ? createTypeReference(classType as GenericType, map(classType.typeParameters, _ => anyType)) : classType;
+            const classSymbol = getParentOfSymbol(prototype)!;
+            return getInstanceTypeOfClassSymbol(classSymbol);
         }
 
         // Return the type of the given property in the given type, or undefined if no such property exists
@@ -25135,10 +25148,10 @@ m2: ${(this.mapper2 as unknown as DebugTypeMapper).__debugToString().split("\n")
                 if (symbol === undefined) {
                     return type;
                 }
-                const classSymbol = symbol.parent!;
+                const classSymbol = getParentOfSymbol(symbol)!;
                 const targetType = hasStaticModifier(Debug.checkDefined(symbol.valueDeclaration, "should always have a declaration"))
                     ? getTypeOfSymbol(classSymbol) as InterfaceType
-                    : getDeclaredTypeOfSymbol(classSymbol);
+                    : getInstanceTypeOfClassSymbol(classSymbol);
                 return getNarrowedType(type, targetType, assumeTrue, /*checkDerived*/ true);
             }
 

src/compiler/commandLineParser.ts

@@ -739,6 +739,16 @@ namespace ts {
             description: Diagnostics.Default_catch_clause_variables_as_unknown_instead_of_any,
             defaultValueDescription: false,
         },
+        {
+            name: "inferInstanceTypeArgumentsAsConstraint",
+            type: "boolean",
+            affectsSemanticDiagnostics: true,
+            affectsMultiFileEmitBuildInfo: true,
+            strictFlag: true,
+            category: Diagnostics.Type_Checking,
+            description: Diagnostics.Default_type_arguments_to_parameter_constraint_or_unknown_instead_of_any,
+            defaultValueDescription: false,
+        },
         {
             name: "alwaysStrict",
             type: "boolean",

src/compiler/diagnosticMessages.json

@@ -5843,6 +5843,10 @@
         "category": "Message",
         "code": 6803
     },
+    "Default type arguments to parameter constraint or 'unknown' instead of 'any'.": {
+        "category": "Message",
+        "code": 6804
+    },
 
     "one of:": {
         "category": "Message",

src/compiler/types.ts

@@ -6342,6 +6342,7 @@ namespace ts {
         /*@internal*/help?: boolean;
         importHelpers?: boolean;
         importsNotUsedAsValues?: ImportsNotUsedAsValues;
+        inferInstanceTypeArgumentsAsConstraint?: boolean;
         /*@internal*/init?: boolean;
         inlineSourceMap?: boolean;
         inlineSources?: boolean;

src/compiler/utilities.ts

@@ -6459,6 +6459,7 @@ namespace ts {
         | "strictPropertyInitialization"
         | "alwaysStrict"
         | "useUnknownInCatchVariables"
+        | "inferInstanceTypeArgumentsAsConstraint"
         ;
 
     export function getStrictOptionValue(compilerOptions: CompilerOptions, flag: StrictOptionName): boolean {

tests/baselines/reference/accessorsOverrideProperty9.types

@@ -68,7 +68,7 @@ function ApiItemContainerMixin<TBaseClass extends IApiItemConstructor>(
   }
 
   return MixedClass;
->MixedClass : ((abstract new (...args: any[]) => MixedClass) & { prototype: ApiItemContainerMixin<any>.MixedClass; }) & TBaseClass
+>MixedClass : ((abstract new (...args: any[]) => MixedClass) & { prototype: ApiItemContainerMixin<IApiItemConstructor>.MixedClass; }) & TBaseClass
 }
 
 // Subclass inheriting from mixin

tests/baselines/reference/api/tsserverlibrary.d.ts

@@ -3002,6 +3002,7 @@ declare namespace ts {
         forceConsistentCasingInFileNames?: boolean;
         importHelpers?: boolean;
         importsNotUsedAsValues?: ImportsNotUsedAsValues;
+        inferInstanceTypeArgumentsAsConstraint?: boolean;
         inlineSourceMap?: boolean;
         inlineSources?: boolean;
         isolatedModules?: boolean;

tests/baselines/reference/api/typescript.d.ts

@@ -3002,6 +3002,7 @@ declare namespace ts {
         forceConsistentCasingInFileNames?: boolean;
         importHelpers?: boolean;
         importsNotUsedAsValues?: ImportsNotUsedAsValues;
+        inferInstanceTypeArgumentsAsConstraint?: boolean;
         inlineSourceMap?: boolean;
         inlineSources?: boolean;
         isolatedModules?: boolean;

tests/baselines/reference/inferInstanceTypeArgumentsAsConstraint.errors.txt

@@ -0,0 +1,43 @@
+tests/cases/compiler/inferInstanceTypeArgumentsAsConstraint.ts(8,13): error TS2339: Property 'toUpperCase' does not exist on type 'unknown'.
+tests/cases/compiler/inferInstanceTypeArgumentsAsConstraint.ts(9,5): error TS2356: An arithmetic operand must be of type 'any', 'number', 'bigint' or an enum type.
+tests/cases/compiler/inferInstanceTypeArgumentsAsConstraint.ts(10,7): error TS2349: This expression is not callable.
+  Type '{}' has no call signatures.
+
+
+==== tests/cases/compiler/inferInstanceTypeArgumentsAsConstraint.ts (3 errors) ====
+    class Unconstrained<T> {
+        value: T;
+    }
+    
+    declare const x: unknown;
+    
+    if (x instanceof Unconstrained) {
+        x.value.toUpperCase();
+                ~~~~~~~~~~~
+!!! error TS2339: Property 'toUpperCase' does not exist on type 'unknown'.
+        x.value++;
+        ~~~~~~~
+!!! error TS2356: An arithmetic operand must be of type 'any', 'number', 'bigint' or an enum type.
+        x.value();
+          ~~~~~
+!!! error TS2349: This expression is not callable.
+!!! error TS2349:   Type '{}' has no call signatures.
+    
+        if (typeof x.value === "string") {
+            x.value.toUpperCase();
+        }
+        if (typeof x.value === "number") {
+            x.value++;
+        }
+    }
+    
+    class Constrained<T extends number> {
+        value: T;
+    }
+    
+    declare const y: unknown;
+    
+    if (y instanceof Constrained) {
+        y.value++;
+    }
+    

tests/baselines/reference/inferInstanceTypeArgumentsAsConstraint.js

@@ -0,0 +1,56 @@
+//// [inferInstanceTypeArgumentsAsConstraint.ts]
+class Unconstrained<T> {
+    value: T;
+}
+
+declare const x: unknown;
+
+if (x instanceof Unconstrained) {
+    x.value.toUpperCase();
+    x.value++;
+    x.value();
+
+    if (typeof x.value === "string") {
+        x.value.toUpperCase();
+    }
+    if (typeof x.value === "number") {
+        x.value++;
+    }
+}
+
+class Constrained<T extends number> {
+    value: T;
+}
+
+declare const y: unknown;
+
+if (y instanceof Constrained) {
+    y.value++;
+}
+
+
+//// [inferInstanceTypeArgumentsAsConstraint.js]
+var Unconstrained = /** @class */ (function () {
+    function Unconstrained() {
+    }
+    return Unconstrained;
+}());
+if (x instanceof Unconstrained) {
+    x.value.toUpperCase();
+    x.value++;
+    x.value();
+    if (typeof x.value === "string") {
+        x.value.toUpperCase();
+    }
+    if (typeof x.value === "number") {
+        x.value++;
+    }
+}
+var Constrained = /** @class */ (function () {
+    function Constrained() {
+    }
+    return Constrained;
+}());
+if (y instanceof Constrained) {
+    y.value++;
+}