Transformation: `try...catch`

[RealyUniqueName]

Source

try {
	doSomething();
} catch(e:String) {
	catchString();
} catch(e:Int) {
	catchInt();
} catch(e:Dynamic) {
	catchDynamic();
}

Short legend for next snippet:

• __ctx__ is a context of state machine (holds current variable values and other data)
• ${id} is a unique id for current transformation

Preprocessed into:

//This line indicates that next state should be executed inside of a `try...catch` to handle exceptions; 
//and `@state @catchBegin ${id}` is a state which should be executed on exception
__ctx__.enterTry(@state @catchBegin ${id});
//this line finishes current state and advances state machine to specified state
@goto @tryBegin ${id};
//this line indicates that a new state starts here. In the end it will be replaced with `case ${id}:`
@label @tryBegin ${id}
//actual code of `try` block
doSomething();
//this line indicates that exception handling should be turned off now.
__ctx__.leaveTry();
//if we reached this line, it means there were no exceptions, and we should skip `catch` and go to the line after last `catch` block.
@goto @tryCatchEnd ${id}
//this line indicates a start of a state with `catch` blocks
@label @catchBegin ${id}
//each catch is transformed to a type checking of caught exception
//transforming `if`s is a topic for another transformation.
if(Std.is(__ctx__.exception, String)) {
	catchString();
} else if(Std.is(__ctx__.exception, Int)) {
	catchInt();
} else {
	catchDynamic();
	//if no `catch(e:Dynamic)` is defined in user code, then this block is replaced with
	//__ctx__.notCaught()
	//which rethrows exception if current context is not awaited or propagates exception to a caller context otherwise
}
//indicates a start of next state
@label @tryCatchEnd ${id}
//some cleanup if needed
__ctx__.leaveTryCatch();

[nadako]

It would be nice to look at what this generates in the end. For example, I think current Kotlin implementation would generate something like this:

// state-machine context
var __state = 0;
var __exceptionState = 2;
var __exception = null;

do {
	try {
		switch (__state) {
			case 0:
				__exceptionState = 1;
				doSomething();
				return;
			case 1:
				__exceptionState = 2;
				var e = __exception;
				if ((e is String)) {
					catchString();
				} else if ((e is Int)) {
					catchInt();
				} else {
					catchDynamic();
				}
				return;
			case 2: // default one: rethrow
				throw __exception;
		}
	} catch (e:Dynamic) {
		if (__exceptionState == 2)
			throw e; // rethrow
		__state = __exceptionState;
		__exception = e;
	}
} while (true);

[RealyUniqueName]

It's pretty much the same as your snippet, except try..catch is not getenerated, but state machine is executed inside of a try...catch instead when entering corresponding state.