Infer from usage by similarity to builtin types

src/compiler/checker.ts

@@ -522,6 +522,9 @@ namespace ts {
             },
             getApparentType,
             getUnionType,
+            isTypeAssignableTo: (source, target) => {
+                return isTypeAssignableTo(source, target);
+            },
             createAnonymousType,
             createSignature,
             createSymbol,

src/compiler/types.ts

@@ -3289,6 +3289,7 @@ namespace ts {
         /* @internal */ getElementTypeOfArrayType(arrayType: Type): Type | undefined;
         /* @internal */ createPromiseType(type: Type): Type;
 
+        /* @internal */ isTypeAssignableTo(source: Type, target: Type): boolean;
         /* @internal */ createAnonymousType(symbol: Symbol, members: SymbolTable, callSignatures: Signature[], constructSignatures: Signature[], stringIndexInfo: IndexInfo | undefined, numberIndexInfo: IndexInfo | undefined): Type;
         /* @internal */ createSignature(
             declaration: SignatureDeclaration,

tests/cases/fourslash/codeFixInferFromCallInAssignment.ts

@@ -0,0 +1,9 @@
+/// <reference path='fourslash.ts' />
+
+// @noImplicitAny: true
+//// function inferAny( [| app |] ) {
+////     const result = app.use('hi')
+////     return result
+//// }
+
+verify.rangeAfterCodeFix("app: { use: (arg0: string) => any; }");

tests/cases/fourslash/codeFixInferFromExpressionStatement.ts

@@ -0,0 +1,8 @@
+/// <reference path='fourslash.ts' />
+
+// @noImplicitAny: true
+//// function inferVoid( [| app |] ) {
+////     app.use('hi')
+//// }
+
+verify.rangeAfterCodeFix("app: { use: (arg0: string) => void; }");

tests/cases/fourslash/codeFixInferFromFunctionUsage.ts

@@ -2,8 +2,8 @@
 
 // @noImplicitAny: true
 ////function wrap( [| arr |] ) {
-////     arr.sort(function (a: number, b: number) { return a < b ? -1 : 1 })
+////     arr.other(function (a: number, b: number) { return a < b ? -1 : 1 })
 //// }
 
 // https://github.com/Microsoft/TypeScript/issues/29330
-verify.rangeAfterCodeFix("arr: { sort: (arg0: (a: number, b: number) => 1 | -1) => void; }");
+verify.rangeAfterCodeFix("arr: { other: (arg0: (a: number, b: number) => 1 | -1) => void; }");

tests/cases/fourslash/codeFixInferFromPrimitiveUsage.ts

@@ -0,0 +1,10 @@
+/// <reference path='fourslash.ts' />
+
+// @noImplicitAny: true
+//// function wrap( [| s |] ) {
+////     return s.length + s.indexOf('hi')
+//// }
+
+// https://github.com/Microsoft/TypeScript/issues/29330
+verify.rangeAfterCodeFix("s: string | string[]");
+

tests/cases/fourslash/codeFixInferFromUsageAddition.ts

@@ -0,0 +1,9 @@
+/// <reference path='fourslash.ts' />
+
+// @noImplicitAny: true
+//// function foo([|a, m |]) {
+////     return a + m
+//// }
+
+verify.rangeAfterCodeFix("a: any, m: any", /*includeWhiteSpace*/ undefined, /*errorCode*/ undefined, /*index*/0);
+

tests/cases/fourslash/codeFixInferFromUsageArray.ts

@@ -0,0 +1,14 @@
+/// <reference path='fourslash.ts' />
+
+// @noImplicitAny: true
+//// function foo([|p, a, b, c, d, e |]) {
+////     var x: string = a.pop()
+////     b.reverse()
+////     var rr: boolean[] = c.reverse()
+////     d.some(t => t > 1); // can't infer from callbacks right now
+////     var y = e.concat(12); // can't infer from overloaded functions right now
+////     return p.push(12)
+//// }
+
+verify.rangeAfterCodeFix("p: number[], a: string[], b: any[], c: boolean[], d: any[], e: any[]", /*includeWhiteSpace*/ undefined, /*errorCode*/ undefined, /*index*/0);
+

tests/cases/fourslash/codeFixInferFromUsageCallBodyBoth.ts

@@ -1,7 +1,7 @@
 /// <reference path='fourslash.ts' />
 
 ////class C {
-////
+////    p = 2
 ////}
 ////var c = new C()
 ////function f([|x, y |]) {

tests/cases/fourslash/codeFixInferFromUsageCommentAfterParameter.ts

@@ -16,7 +16,7 @@ verify.codeFix({
     index: 0,
     newFileContent:
 `/**
- * @param {(arg0: any) => void} callback
+ * @param {(arg0: any) => any} callback
  */
 function coll(callback /*, name1, name2, ... */) {
     return callback(this);

tests/cases/fourslash/codeFixInferFromUsageJSXElement.ts

@@ -30,4 +30,4 @@
 //// }
 
 
-verify.rangeAfterCodeFix("props: { isLoading: any; update: (arg0: any) => void; }",/*includeWhiteSpace*/ undefined, /*errorCode*/ undefined, 0);
+verify.rangeAfterCodeFix("props: { isLoading: any; update: (arg0: any) => any; }",/*includeWhiteSpace*/ undefined, /*errorCode*/ undefined, 0);

tests/cases/fourslash/codeFixInferFromUsageLiteralTypes.ts

@@ -0,0 +1,10 @@
+/// <reference path='fourslash.ts' />
+
+// @noImplicitAny: true
+//// function foo([|a, m |]) {
+////     a = 'hi'
+////     m = 1
+//// }
+
+verify.rangeAfterCodeFix("a: string, m: number", /*includeWhiteSpace*/ undefined, /*errorCode*/ undefined, /*index*/0);
+

tests/cases/fourslash/codeFixInferFromUsagePromise.ts

@@ -0,0 +1,9 @@
+/// <reference path='fourslash.ts' />
+
+// @noImplicitAny: true
+//// function foo([|p |]) {
+////     return p.then((x: string[]) => x[0])
+//// }
+
+verify.rangeAfterCodeFix("p: Promise<string[]>", /*includeWhiteSpace*/ undefined, /*errorCode*/ undefined, /*index*/0);
+

tests/cases/fourslash/codeFixInferFromUsagePropertyAccess.ts

@@ -12,4 +12,4 @@
 ////    return x.y.z
 ////}
 
-verify.rangeAfterCodeFix("a: { b: { c: any; }; }, m: { n: () => number; }, x: { y: { z: number[]; }; }", /*includeWhiteSpace*/ undefined, /*errorCode*/ undefined, /*index*/0);
+verify.rangeAfterCodeFix("a: { b: { c: void; }; }, m: { n: () => number; }, x: { y: { z: number[]; }; }", /*includeWhiteSpace*/ undefined, /*errorCode*/ undefined, /*index*/0);

tests/cases/fourslash/codeFixInferFromUsagePropertyAccessJS.ts

@@ -21,7 +21,7 @@ verify.codeFix({
     index: 0,
     newFileContent:
 `/**
- * @param {{ b: { c: any; }; }} a
+ * @param {{ b: { c: void; }; }} a
  * @param {{ n: () => number; }} m
  * @param {{ y: { z: number[]; }; }} x
  */

tests/cases/fourslash/codeFixInferFromUsageString.ts

@@ -0,0 +1,12 @@
+/// <reference path='fourslash.ts' />
+
+// @noImplicitAny: true
+//// function foo([|p, a, b |]) {
+////     var x
+////     p.charAt(x)
+////     a.charAt(0)
+////     b.concat('hi')
+//// }
+
+verify.rangeAfterCodeFix("p: string, a: string, b: string | any[]", /*includeWhiteSpace*/ undefined, /*errorCode*/ undefined, /*index*/0);
+