Handle switch statement

Author: saulecabrera

src/compiler.ts

@@ -2673,13 +2673,17 @@ export class Compiler extends DiagnosticEmitter {
       // stmts.push(module.createUnreachable());
       return module.flatten(stmts);
     }
-
     // Otherwise emit a normal return
     if (!stmts.length) return module.return(expr);
     stmts.push(module.return(expr));
     return module.flatten(stmts);
   }
 
+  // For strict field init:
+  // Need to sequentially check for each of the branches
+  // if no default assume not init
+  // if default try and check all statements
+
   private compileSwitchStatement(
     statement: SwitchStatement
   ): ExpressionRef {
@@ -2742,6 +2746,9 @@ export class Compiler extends DiagnosticEmitter {
     var currentBlock = module.block("case0|" + context, breaks, NativeType.None);
     var commonCategorical = FlowFlags.ANY_CATEGORICAL;
     var commonConditional = 0;
+    // Track qualifying flows for field flag analysis
+    // A qualifying flow is a breaking flow or the last flow
+    var flows: Flow[] = [];
     for (let i = 0; i < numCases; ++i) {
       let case_ = cases[i];
       let statements = case_.statements;
@@ -2775,6 +2782,10 @@ export class Compiler extends DiagnosticEmitter {
       }
       commonConditional |= innerFlow.flags & FlowFlags.ANY_CONDITIONAL;
 
+      if (innerFlow.isAny(FlowFlags.BREAKS | FlowFlags.RETURNS) || isLast) {
+        flows.push(innerFlow);
+      }
+
       // Switch back to the parent flow
       if (!terminates) this.performAutoreleases(innerFlow, stmts);
       innerFlow.unset(
@@ -2788,7 +2799,28 @@ export class Compiler extends DiagnosticEmitter {
     outerFlow.popBreakLabel();
 
     // If the switch has a default (guaranteed to handle any value), propagate common flags
-    if (defaultIndex >= 0) outerFlow.flags |= commonCategorical & ~FlowFlags.BREAKS;
+    if (defaultIndex >= 0){
+      outerFlow.flags |= commonCategorical & ~FlowFlags.BREAKS;
+
+      // If the switch:
+      // - has a default label
+      // - is located in the constructor
+      // - and has one or more qualifying flows
+      // analyze field flags
+      if (flows.length > 0 && this.currentFlow.actualFunction.is(CommonFlags.CONSTRUCTOR)) {
+        if (flows.length == 1) {
+          this.currentFlow.inheritFieldFlags(flows[0]);
+        } else {
+          for(let i = 0; i < flows.length; ++i) {
+            if (i < (flows.length - 1)) {
+              const left = flows[i];
+              const right = flows[i + 1];
+              this.currentFlow.mergeFieldFlags(left, right);
+            }
+          }
+        }
+      }
+    }
     outerFlow.flags |= commonConditional & ~FlowFlags.CONDITIONALLY_BREAKS;
     // TODO: what about local states?
     return currentBlock;

src/flow.ts

@@ -842,9 +842,12 @@ export class Flow {
       }
     }
 
+    this.mergeFieldFlags(left, right);
+  }
 
-    if ((left.fieldFlags !== null) &&
-      (right.fieldFlags !== null) &&
+  mergeFieldFlags(left: Flow, right: Flow): void {
+    if (left.fieldFlags !== null &&
+      right.fieldFlags !== null &&
       right.fieldFlags.size > 0
     ) {
       const rightFieldFlags = right.fieldFlags;
@@ -867,6 +870,26 @@ export class Flow {
     }
   }
 
+  inheritFieldFlags(other: Flow): void {
+    if (
+      this.fieldFlags !== null &&
+      other.fieldFlags !== null
+    ) {
+      const otherFieldFlags = other.fieldFlags;
+      const otherKeys = Map_keys(otherFieldFlags!);
+      const otherValues = Map_values(otherFieldFlags!);
+      const currentFieldFlags = this.fieldFlags;
+
+      for (let i = 0, k = otherValues.length; i < k; ++i) {
+        const key = otherKeys[i];
+        const otherValue = otherValues[i];
+        if (otherValue & FieldFlags.INITIALIZED) {
+          currentFieldFlags.set(key, FieldFlags.INITIALIZED)
+        }
+      }
+    }
+  }
+
   /** Tests if the specified flows have differing local states. */
   static hasIncompatibleLocalStates(before: Flow, after: Flow): bool {
     var numThisLocalFlags = before.localFlags.length;

tests/compiler/strict-init.json

@@ -7,6 +7,8 @@
     "TS2564: Property b has no initializer and is not definitely assigned in constructor",
     "TS2564: Property fieldLeft has no initializer and is not definitely assigned in constructor",
     "TS2564: Property fieldRight has no initializer and is not definitely assigned in constructor",
-    "TS2564: Property p has no initializer and is not definitely assigned in constructor"
+    "TS2564: Property p has no initializer and is not definitely assigned in constructor",
+    "TS2564: Property switchNotInitInDefault has no initializer and is not definitely assigned in constructor",
+    "TS2564: Property switchNoDefault has no initializer and is not definitely assigned in constructor"
   ]
 }

tests/compiler/strict-init.ts

@@ -104,3 +104,80 @@ export abstract class X extends Y {
     }
   }
 }
+
+// OK
+export class SwitchFallback {
+  switchFallback: i32;
+  constructor(some: i32) {
+    switch (some) {
+      case 1:
+      case 2:
+      case 3:
+      default:
+        this.switchFallback = 6;
+        break;
+    }
+  }
+}
+
+// ERR
+export class SwitchWithNonInitInDefault {
+  switchNotInitInDefault: i32;
+
+  constructor(some: i32) {
+    switch (some) {
+      case 0:
+      case 1:
+        this.switchNotInitInDefault = 1;
+        break;
+      case 3:
+        this.switchNotInitInDefault = 5;
+      default:
+        const x = 6;
+        break;
+    }
+  }
+}
+
+// OK
+export class SwitchDefinitelyInit {
+  switchDefinitelyInit: i32;
+  constructor(some: i32) {
+    switch(some) {
+      case 0:
+        this.switchDefinitelyInit = 0;
+        break;
+      case 1:
+        this.switchDefinitelyInit = 1;
+        break;
+      case 3:
+        this.switchDefinitelyInit = 5;
+      default:
+        this.switchDefinitelyInit = 10;
+        break;
+    }
+  }
+}
+
+// ERR
+export class SwitchNoDefault {
+  switchNoDefault: i32;
+
+  constructor(some: i32) {
+    switch(some) {
+      case 1:
+        this.switchNoDefault = 4;
+    }
+  }
+}
+
+export class SwitchOnlyDefault {
+  switchOnlyDefault: i32;
+
+  constructor(some: i32) {
+    switch (some) {
+      default:
+        this.switchOnlyDefault = 0;
+    }
+  }
+}