Control flow for constructor initialized properties (microsoft#37920)

* Use CFA to determine types of properties declared by this.xxx assignments

* Accept new baselines

* Also use CFA in constructor functions

* Accept new baselines

* Fix lint error

* Only widen fresh literal types in CFA of assignment to auto-typed

* Auto-typing for declared properties with no type annotation or initializer

* Add optionality if declaration includes '?' modifier

* Always use CFA for properties with no initializer in .js files

* Small fix

Author: ahejlsberg

src/compiler/binder.ts

@@ -649,7 +649,7 @@ namespace ts {
                 }
                 // We create a return control flow graph for IIFEs and constructors. For constructors
                 // we use the return control flow graph in strict property initialization checks.
-                currentReturnTarget = isIIFE || node.kind === SyntaxKind.Constructor ? createBranchLabel() : undefined;
+                currentReturnTarget = isIIFE || node.kind === SyntaxKind.Constructor || (isInJSFile && (node.kind === SyntaxKind.FunctionDeclaration || node.kind === SyntaxKind.FunctionExpression)) ? createBranchLabel() : undefined;
                 currentExceptionTarget = undefined;
                 currentBreakTarget = undefined;
                 currentContinueTarget = undefined;
@@ -670,8 +670,8 @@ namespace ts {
                 if (currentReturnTarget) {
                     addAntecedent(currentReturnTarget, currentFlow);
                     currentFlow = finishFlowLabel(currentReturnTarget);
-                    if (node.kind === SyntaxKind.Constructor) {
-                        (<ConstructorDeclaration>node).returnFlowNode = currentFlow;
+                    if (node.kind === SyntaxKind.Constructor || (isInJSFile && (node.kind === SyntaxKind.FunctionDeclaration || node.kind === SyntaxKind.FunctionExpression))) {
+                        (<FunctionLikeDeclaration>node).returnFlowNode = currentFlow;
                     }
                 }
                 if (!isIIFE) {

src/compiler/checker.ts

@@ -1107,6 +1107,7 @@ namespace ts {
         exclamationToken?: ExclamationToken;
         body?: Block | Expression;
         /* @internal */ endFlowNode?: FlowNode;
+        /* @internal */ returnFlowNode?: FlowNode;
     }
 
     export type FunctionLikeDeclaration =
@@ -1152,7 +1153,6 @@ namespace ts {
         kind: SyntaxKind.Constructor;
         parent: ClassLikeDeclaration;
         body?: FunctionBody;
-        /* @internal */ returnFlowNode?: FlowNode;
     }
 
     /** For when we encounter a semicolon in a class declaration. ES6 allows these as class elements. */
@@ -4157,6 +4157,7 @@ namespace ts {
         deferralParent?: Type;              // Source union/intersection of a deferred type
         cjsExportMerged?: Symbol;           // Version of the symbol with all non export= exports merged with the export= target
         typeOnlyDeclaration?: TypeOnlyCompatibleAliasDeclaration | false; // First resolved alias declaration that makes the symbol only usable in type constructs
+        isConstructorDeclaredProperty?: boolean;  // Property declared through 'this.x = ...' assignment in constructor
     }
 
     /* @internal */

src/compiler/types.ts

@@ -105,9 +105,9 @@ function Person(name) {
 
     this.name = name;
 >this.name = name : string
->this.name : string
+>this.name : any
 >this : this
->name : string
+>name : any
 >name : string
 }
 Person.prototype.describe = function () {

tests/baselines/reference/checkExportsObjectAssignPrototypeProperty.types

@@ -23,9 +23,9 @@ someFunction(function(BaseClass) {
 
             this.foo = "bar";
 >this.foo = "bar" : "bar"
->this.foo : string
+>this.foo : any
 >this : this
->foo : string
+>foo : any
 >"bar" : "bar"
         }
         _render(error) {

tests/baselines/reference/checkIndexConstraintOfJavascriptClassExpression.types

@@ -25,9 +25,9 @@ class B extends A {
 
     this.foo = () => 3;
 >this.foo = () => 3 : () => number
->this.foo : () => number
+>this.foo : any
 >this : this
->foo : () => number
+>foo : any
 >() => 3 : () => number
 >3 : 3
   }

tests/baselines/reference/checkJsFiles_noErrorLocation.types

@@ -12,9 +12,9 @@ class Derived {
 
         this.x = 10;
 >this.x = 10 : 10
->this.x : number
+>this.x : any
 >this : this
->x : number
+>x : any
 >10 : 10
 
         var that = this;

tests/baselines/reference/checkSuperCallBeforeThisAccessing9.types

@@ -9,9 +9,9 @@ function Wagon(numberOxen) {
 
     this.numberOxen = numberOxen
 >this.numberOxen = numberOxen : number
->this.numberOxen : number
+>this.numberOxen : any
 >this : this
->numberOxen : number
+>numberOxen : any
 >numberOxen : number
 }
 /** @param {Wagon[]=} wagons */
@@ -91,9 +91,9 @@ class Sql extends Wagon {
 
         this.foonly = 12
 >this.foonly = 12 : 12
->this.foonly : number
+>this.foonly : any
 >this : this
->foonly : number
+>foonly : any
 >12 : 12
     }
     /**

tests/baselines/reference/classCanExtendConstructorFunction.types

@@ -67,9 +67,9 @@ class B extends Err {
 
         this.wat = 12
 >this.wat = 12 : 12
->this.wat : number
+>this.wat : any
 >this : this
->wat : number
+>wat : any
 >12 : 12
     }
     f() {

tests/baselines/reference/classExtendingAny.types

@@ -143,9 +143,9 @@ function C6() {
 
   this.functions = [x => x, x => x + 1, x => x - 1]
 >this.functions = [x => x, x => x + 1, x => x - 1] : ((x: any) => any)[]
->this.functions : ((x: any) => any)[]
+>this.functions : any
 >this : this
->functions : ((x: any) => any)[]
+>functions : any
 >[x => x, x => x + 1, x => x - 1] : ((x: any) => any)[]
 >x => x : (x: any) => any
 >x : any