Move field initialization tracking at the flow level

This commit add field initialization at the flow level. It also refactors the error reporting for uninitialized properties.

Author: saulecabrera

src/common.ts

@@ -76,7 +76,7 @@ export enum CommonFlags {
   // Other
 
   /** Is quoted. */
-  QUOTED = 1 << 28,
+  QUOTED = 1 << 28
 }
 
 /** Path delimiter inserted between file system levels. */

src/compiler.ts

@@ -90,6 +90,7 @@ import {
 
 import {
   FlowFlags,
+  FieldFlags,
   Flow,
   LocalFlags,
   ConditionKind,
@@ -1509,6 +1510,7 @@ export class Compiler extends DiagnosticEmitter {
       }
     }
     this.ensureConstructor(instance, instance.identifierNode);
+    this.checkFieldInitialization(instance);
     var instanceMembers = instance.members;
     if (instanceMembers) {
       // TODO: for (let element of instanceMembers.values()) {
@@ -1536,18 +1538,30 @@ export class Compiler extends DiagnosticEmitter {
     return true;
   }
 
+  checkFieldInitialization(instance: Class): void {
+    const flow = instance.constructorInstance!.flow;
+    const instanceMembers = instance.members;
+    if (instanceMembers) {
+      for (let _values = Map_values(instanceMembers), i = 0, k = _values.length; i < k; ++i) {
+        const element = unchecked(_values[i]);
+        if (element.kind == ElementKind.FIELD) {
+          const field = <Field>element;
+          if (!flow.isFieldFlag(field.internalName, FieldFlags.INITIALIZED)) {
+            this.error(
+              DiagnosticCode.Property_0_has_no_initializer_and_is_not_definitely_assigned_in_constructor,
+              field.declaration.name.range,
+              field.declaration.name.text
+            );
+          }
+        }
+      }
+    }
+  }
+
   /** Compiles an instance field to a getter and a setter. */
   compileField(instance: Field): bool {
     this.compileFieldGetter(instance);
     this.compileFieldSetter(instance);
-    if (!instance.is(CommonFlags.INITIALIZED)) {
-      this.error(
-        DiagnosticCode.Property_0_has_no_initializer_and_is_not_definitely_assigned_in_constructor,
-        instance.declaration.name.range,
-        instance.declaration.name.text
-      );
-    }
-
     return instance.is(CommonFlags.COMPILED);
   }
 
@@ -5945,8 +5959,8 @@ export class Compiler extends DiagnosticEmitter {
           return module.unreachable();
         }
 
-        if (flow.actualFunction.is(CommonFlags.CONSTRUCTOR) && !fieldInstance.is(CommonFlags.INITIALIZED)) {
-          fieldInstance.set(CommonFlags.INITIALIZED);
+        if (flow.actualFunction.is(CommonFlags.CONSTRUCTOR)) {
+          flow.setFieldFlag(fieldInstance.internalName, FieldFlags.INITIALIZED);
         }
 
         return this.makeFieldAssignment(fieldInstance,
@@ -8838,6 +8852,7 @@ export class Compiler extends DiagnosticEmitter {
     reportNode: Node
   ): ExpressionRef {
     var ctor = this.ensureConstructor(classInstance, reportNode);
+    this.checkFieldInitialization(classInstance);
     if (ctor.hasDecorator(DecoratorFlags.UNSAFE)) this.checkUnsafe(reportNode);
     var expr = this.compileCallDirect( // no need for another autoreleased local
       ctor,
@@ -8850,23 +8865,6 @@ export class Compiler extends DiagnosticEmitter {
       this.currentType = classInstance.type; // important because a super ctor could be called
     }
 
-    let members = classInstance.members;
-    if (members) {
-      for (let _values = Map_values(members), i = 0, k = _values.length; i < k; ++i) {
-        const field = <Field>unchecked(_values[i]);
-        if (
-          field.kind === ElementKind.FIELD &&
-          !field.is(CommonFlags.INITIALIZED)
-        ) {
-          this.error(
-            DiagnosticCode.Property_0_has_no_initializer_and_is_not_definitely_assigned_in_constructor,
-            field.declaration.name.range,
-            field.declaration.name.text
-          );
-        }
-      }
-    }
-
     return expr;
   }
 
@@ -10075,7 +10073,9 @@ export class Compiler extends DiagnosticEmitter {
             field.memoryOffset
           )
         );
-        field.set(CommonFlags.INITIALIZED);
+        flow.setFieldFlag(field.internalName, FieldFlags.INITIALIZED)
+      } else {
+        flow.setFieldFlag(field.internalName, FieldFlags.NONE);
       }
     }
     return stmts;

src/flow.ts

@@ -169,6 +169,12 @@ export enum LocalFlags {
                | CONDITIONALLY_RETAINED
 }
 
+/** Flags indicating the current state of an instance field. */
+export enum FieldFlags {
+  NONE = 0,
+  INITIALIZED = 1 << 0,
+}
+
 /** Condition kinds. */
 export const enum ConditionKind {
   /** Outcome of the condition is unknown */
@@ -200,6 +206,8 @@ export class Flow {
   scopedLocals: Map<string,Local> | null = null;
   /** Local flags. */
   localFlags: LocalFlags[];
+  /** Field flags. */
+  fieldFlags: Map<string, FieldFlags>;
   /** Function being inlined, when inlining. */
   inlineFunction: Function | null;
   /** The label we break to when encountering a return statement, when inlining. */
@@ -216,6 +224,7 @@ export class Flow {
     flow.returnType = parentFunction.signature.returnType;
     flow.contextualTypeArguments = parentFunction.contextualTypeArguments;
     flow.localFlags = [];
+    flow.fieldFlags = new Map();
     flow.inlineFunction = null;
     flow.inlineReturnLabel = null;
     return flow;
@@ -276,6 +285,7 @@ export class Flow {
     branch.localFlags = this.localFlags.slice();
     branch.inlineFunction = this.inlineFunction;
     branch.inlineReturnLabel = this.inlineReturnLabel;
+    branch.fieldFlags = new Map(this.fieldFlags);
     return branch;
   }
 
@@ -519,6 +529,20 @@ export class Flow {
     localFlags[index] = flags & ~flag;
   }
 
+  setFieldFlag(name: string, flag: FieldFlags): void {
+    let fieldFlags = this.fieldFlags;
+    const flags = fieldFlags.get(name) || 0;
+    fieldFlags.set(name, flags | flag);
+  }
+
+  isFieldFlag(name: string, flag: FieldFlags): bool {
+    const flags = this.fieldFlags.get(name);
+    if (flags) {
+      return (flags & flag) == flag;
+    }
+    return false;
+  }
+
   /** Pushes a new break label to the stack, for example when entering a loop that one can `break` from. */
   pushBreakLabel(): string {
     var parentFunction = this.parentFunction;
@@ -806,6 +830,20 @@ export class Flow {
         thisLocalFlags[i] = newFlags;
       }
     }
+
+    // Only the most right flow will have an effect
+    // on the resulting flow.
+    const rightFieldFlags = right.fieldFlags;
+    const rightKeys = Map_keys(rightFieldFlags);
+
+    for (let _values = Map_values(rightFieldFlags), i = 0, k = _values.length; i < k; ++i) {
+      const rightValue = unchecked(_values[i]);
+      const currentKey = unchecked(rightKeys[i]);
+
+      if (rightValue & FieldFlags.INITIALIZED) {
+        this.setFieldFlag(currentKey, FieldFlags.INITIALIZED);
+      }
+    }
   }
 
   /** Tests if the specified flows have differing local states. */

tests/compiler/strict-init.json

@@ -3,6 +3,8 @@
     "--runtime none"
   ],
   "stderr": [
-    "TS2564: Property b has no initializer and is not definitely assigned in constructor"
+    "TS2564: Property inlinedProp has no initializer and is not definitely assigned in constructor",
+    "TS2564: Property b has no initializer and is not definitely assigned in constructor",
+    "TS2564: Property p has no initializer and is not definitely assigned in constructor"
   ]
 }

tests/compiler/strict-init.ts

@@ -1,7 +1,6 @@
 // OK - Field with explicit initializer
 export class WithInitializer {
   public a: i32 = 1;
-  constructor() {}
 }
 
 // ERR - Field b not initialized
@@ -24,8 +23,37 @@ export class ExplicitConstructorInit {
   }
 }
 
-export class SupressExplicitInit {
-  p!: f64;
+export class NonDefiniteIf {
+  p: f64;
+  constructor(a: i32) {
+    if ((a % 2) == 0) {
+      this.p = 1.0;
+    } else if ((a * 2) == 10) {
+      this.p = 0.0;
+    }
+  }
+}
+
+export class DefiniteIf {
+  definite: i32;
+
+  constructor(a: i32) {
+    if ((a % 2) == 0) {
+      this.definite = 1;
+    } else if ((a * 2) == 10) {
+      this.definite = 0;
+    } else if ((a / 2) == 1) {
+      this.definite = 8;
+    } else {
+      this.definite = 0;
+    }
+  }
+}
+
+
+class Inlined {
+  inlinedProp: i32;
   constructor() {}
 }
 
+new Inlined();