Merge branch 'experimental-try-catch-finally' into v0.29

Author: BlobMaster41

src/compiler.ts

@@ -52,6 +52,7 @@
   "Initializer, definitive assignment or nullable type expected.": 238,
   "Definitive assignment has no effect on local variables.": 239,
   "Ambiguous operator overload '{0}' (conflicting overloads '{1}' and '{2}').": 240,
+  "Only Error or its subclasses can be thrown, but found type '{0}'.": 241,
 
   "Importing the table disables some indirect call optimizations.": 901,
   "Exporting the table disables some indirect call optimizations.": 902,

src/diagnosticMessages.json

@@ -265,12 +265,35 @@ export class Flow {
   trueFlows: Map<ExpressionRef,Flow> | null = null;
   /** Alternative flows if a compound expression is false-ish. */
   falseFlows: Map<ExpressionRef,Flow> | null = null;
+  /** Try-finally context: local index for pending action (0=none, 1=return, 2=break, 3=continue). */
+  tryFinallyPendingActionLocal: i32 = -1;
+  /** Try-finally context: local index for pending return value. */
+  tryFinallyPendingValueLocal: i32 = -1;
+  /** Try-finally context: label to branch to for finally dispatch. */
+  tryFinallyDispatchLabel: string | null = null;
+  /** Try-finally context: return type for the pending value. */
+  tryFinallyReturnType: Type | null = null;
 
   /** Tests if this is an inline flow. */
   get isInline(): bool {
     return this.inlineFunction != null;
   }
 
+  /** Tests if this flow or any parent is in a try-finally context. */
+  get isInTryFinally(): bool {
+    return this.tryFinallyPendingActionLocal >= 0;
+  }
+
+  /** Gets the try-finally context from this flow or a parent flow. */
+  getTryFinallyContext(): Flow | null {
+    let flow: Flow | null = this;
+    while (flow) {
+      if (flow.tryFinallyPendingActionLocal >= 0) return flow;
+      flow = flow.parent;
+    }
+    return null;
+  }
+
   /** Gets the source function being compiled. Differs from target when inlining. */
   get sourceFunction(): Function {
     // Obtaining the source function is useful when resolving elements relative

src/flow.ts

@@ -636,6 +636,14 @@ export class Program extends DiagnosticEmitter {
   }
   private _stringInstance: Class | null = null;
 
+  /** Gets the standard `Error` instance. */
+  get errorInstance(): Class {
+    let cached = this._errorInstance;
+    if (!cached) this._errorInstance = cached = this.requireClass(CommonNames.Error);
+    return cached;
+  }
+  private _errorInstance: Class | null = null;
+
   /** Gets the standard `RegExp` instance. */
   get regexpInstance(): Class {
     let cached = this._regexpInstance;

src/program.ts

@@ -2603,13 +2603,32 @@ export abstract class i31 { // FIXME: usage of 'new' requires a class :(
 // @ts-ignore: decorator
 @external("env", "abort")
 @external.js("throw Error(`${message} in ${fileName}:${lineNumber}:${columnNumber}`);")
-declare function abort(
+declare function __abort_impl(
   message?: string | null,
   fileName?: string | null,
   lineNumber?: u32,
   columnNumber?: u32
 ): void;
 
+// When exception-handling is enabled, abort throws an Error that can be caught.
+// When disabled, it calls the external abort function (host implementation).
+function abort(
+  message: string | null = null,
+  fileName: string | null = null,
+  lineNumber: u32 = 0,
+  columnNumber: u32 = 0
+): void {
+  if (isDefined(ASC_FEATURE_EXCEPTION_HANDLING)) {
+    let fullMessage = message ? message : "abort";
+    if (fileName) {
+      fullMessage += " in " + fileName + ":" + lineNumber.toString() + ":" + columnNumber.toString();
+    }
+    throw new Error(fullMessage);
+  } else {
+    __abort_impl(message, fileName, lineNumber, columnNumber);
+  }
+}
+
 // @ts-ignore: decorator
 @external("env", "trace")
 @external.js("console.log(message, ...[a0, a1, a2, a3, a4].slice(0, n));")

std/assembly/builtins.ts

@@ -254,10 +254,10 @@ async function runTest(basename) {
 
   if (config.features) {
     config.features.forEach(feature => {
-      if (!features.includes(feature) && !features.includes("*")) {
+      let featureConfig = featuresConfig[feature];
+      if (!features.includes(feature) && !features.includes("*") && !featureConfig.enabled) {
         missing_features.push(feature);
       }
-      let featureConfig = featuresConfig[feature];
       if (featureConfig.asc_flags) {
         featureConfig.asc_flags.forEach(flag => {
           Array.prototype.push.apply(asc_flags, flag.split(" "));

tests/compiler.js

@@ -0,0 +1,3 @@
+{
+  "features": ["exception-handling"]
+}