Replace --ignoreUnchecked with --uncheckedBehavior

This new option allows users to use unchecked() as usual, ignore it
entirely, and *force unchecked contexts everywhere*. Ignoring unchecked
is useful for debugging, and, if you're certain you want to accept the
risk, forcing unchecked could be beneficial for performance.

Author: CountBleck

cli/index.js

@@ -295,14 +295,20 @@ export async function main(argv, options) {
   }
 
   // Set up options
-  let program, runtime;
+  let program, runtime, uncheckedBehavior;
   const compilerOptions = assemblyscript.newOptions();
   switch (opts.runtime) {
     case "stub": runtime = 0; break;
     case "minimal": runtime = 1; break;
     /* incremental */
     default: runtime = 2; break;
   }
+  switch (opts.uncheckedBehavior) {
+    /* default */
+    default: uncheckedBehavior = 0; break;
+    case "never": uncheckedBehavior = 1; break;
+    case "always": uncheckedBehavior = 2; break;
+  }
   assemblyscript.setTarget(compilerOptions, 0);
   assemblyscript.setDebugInfo(compilerOptions, !!opts.debug);
   assemblyscript.setRuntime(compilerOptions, runtime);
@@ -320,7 +326,7 @@ export async function main(argv, options) {
   assemblyscript.setMemoryBase(compilerOptions, opts.memoryBase >>> 0);
   assemblyscript.setTableBase(compilerOptions, opts.tableBase >>> 0);
   assemblyscript.setSourceMap(compilerOptions, opts.sourceMap != null);
-  assemblyscript.setIgnoreUnchecked(compilerOptions, opts.ignoreUnchecked);
+  assemblyscript.setUncheckedBehavior(compilerOptions, uncheckedBehavior);
   assemblyscript.setNoUnsafe(compilerOptions, opts.noUnsafe);
   assemblyscript.setPedantic(compilerOptions, opts.pedantic);
   assemblyscript.setLowMemoryLimit(compilerOptions, opts.lowMemoryLimit >>> 0);

cli/options.json

@@ -98,11 +98,20 @@
     ],
     "type": "s"
   },
-  "ignoreUnchecked": {
+  "uncheckedBehavior": {
     "category": "Debugging",
-    "description": "Ignores unchecked() expressions.",
-    "type": "b",
-    "default": false
+    "description": [
+      "Changes the behavior of unchecked() expressions.",
+      "",
+      "  default  The default behavior: unchecked operations are",
+      "           only used inside of unchecked().",
+      "  never    Unchecked operations are never used, even when",
+      "           inside of unchecked().",
+      "  always   Unchecked operations are always used if possible,",
+      "           whether or not unchecked() is used."
+    ],
+    "type": "s",
+    "default": "default"
   },
   "debug": {
     "category": "Debugging",

src/builtins.ts

@@ -26,7 +26,8 @@
 import {
   Compiler,
   Constraints,
-  RuntimeFeatures
+  RuntimeFeatures,
+  UncheckedBehavior
 } from "./compiler";
 
 import {
@@ -3587,8 +3588,9 @@ function builtin_unchecked(ctx: BuiltinContext): ExpressionRef {
     checkArgsRequired(ctx, 1)
   ) return module.unreachable();
   let flow = compiler.currentFlow;
-  let alreadyUnchecked = flow.is(FlowFlags.UncheckedContext);
-  if (!compiler.options.ignoreUnchecked) flow.set(FlowFlags.UncheckedContext);
+  let ignoreUnchecked = compiler.options.uncheckedBehavior === UncheckedBehavior.Never;
+  let alreadyUnchecked = !ignoreUnchecked && flow.is(FlowFlags.UncheckedContext);
+  if (!ignoreUnchecked) flow.set(FlowFlags.UncheckedContext);
   // eliminate unnecessary tees by preferring contextualType(=void)
   let expr = compiler.compileExpression(ctx.operands[0], ctx.contextualType);
   if (!alreadyUnchecked) flow.unset(FlowFlags.UncheckedContext);

src/compiler.ts

@@ -246,8 +246,8 @@ export class Options {
   exportTable: bool = false;
   /** If true, generates information necessary for source maps. */
   sourceMap: bool = false;
-  /** If true, unchecked() expressions are ignored. */
-  ignoreUnchecked: bool = false;
+  /** Unchecked behavior. Defaults to only using unchecked operations inside unchecked(). */
+  uncheckedBehavior: UncheckedBehavior = UncheckedBehavior.Default;
   /** If given, exports the start function instead of calling it implicitly. */
   exportStart: string | null = null;
   /** Static memory start offset. */
@@ -318,6 +318,16 @@ export class Options {
   }
 }
 
+/** Behaviors regarding unchecked operations. */
+export const enum UncheckedBehavior {
+  /** Only use unchecked operations inside unchecked(). */
+  Default = 0,
+  /** Never use unchecked operations. */
+  Never = 1,
+  /** Always use unchecked operations if possible. */
+  Always = 2
+}
+
 /** Various constraints in expression compilation. */
 export const enum Constraints {
   None = 0,

src/flow.ts

@@ -78,6 +78,10 @@ import {
   CommonFlags
 } from "./common";
 
+import {
+  UncheckedBehavior
+} from "./compiler";
+
 import {
   DiagnosticCode
 } from "./diagnostics";
@@ -203,6 +207,9 @@ export class Flow {
     if (targetFunction.is(CommonFlags.Constructor)) {
       flow.initThisFieldFlags();
     }
+    if (targetFunction.program.options.uncheckedBehavior === UncheckedBehavior.Always) {
+      flow.set(FlowFlags.UncheckedContext);
+    }
     return flow;
   }
 
@@ -215,6 +222,9 @@ export class Flow {
     if (inlineFunction.is(CommonFlags.Constructor)) {
       flow.initThisFieldFlags();
     }
+    if (targetFunction.program.options.uncheckedBehavior === UncheckedBehavior.Always) {
+      flow.set(FlowFlags.UncheckedContext);
+    }
     return flow;
   }
 

src/index-wasm.ts

@@ -22,7 +22,8 @@ import {
 
 import {
   Compiler,
-  Options
+  Options,
+  UncheckedBehavior
 } from "./compiler";
 
 import {
@@ -102,9 +103,9 @@ export function setSourceMap(options: Options, sourceMap: bool): void {
   options.sourceMap = sourceMap;
 }
 
-/** Sets the `ignoreUnchecked` option. */
-export function setIgnoreUnchecked(options: Options, ignoreUnchecked: bool): void {
-  options.ignoreUnchecked = ignoreUnchecked;
+/** Sets the `uncheckedBehavior` option. */
+export function setUncheckedBehavior(options: Options, uncheckedBehavior: UncheckedBehavior): void {
+  options.uncheckedBehavior = uncheckedBehavior;
 }
 
 /** Sets the `memoryBase` option. */