## To makePeState (e: Map of Text to CVal) and (f: Map of Text to CFunc) and (d: Int) -> PEState:
Return a new PEStateR with env e and funcs f and depth d and staticEnv (a new Map of Text to CExpr) and specResults (a new Map of Text to CExpr) and onStack (a new Seq of Text).
## To peEnv (st: PEState) -> Map of Text to CVal:
Inspect st:
When PEStateR (e, f, d, se, sr, os):
Return e.
## To peFuncs (st: PEState) -> Map of Text to CFunc:
Inspect st:
When PEStateR (e, f, d, se, sr, os):
Return f.
## To peDepth (st: PEState) -> Int:
Inspect st:
When PEStateR (e, f, d, se, sr, os):
Return d.
## To peStateWithDepth (st: PEState) and (d: Int) -> PEState:
Inspect st:
When PEStateR (e, f, oldD, se, sr, os):
Return a new PEStateR with env e and funcs f and depth d and staticEnv se and specResults sr and onStack os.
## To peSpecResults (st: PEState) -> Map of Text to CExpr:
Inspect st:
When PEStateR (e, f, d, se, sr, os):
Return sr.
## To peOnStack (st: PEState) -> Seq of Text:
Inspect st:
When PEStateR (e, f, d, se, sr, os):
Return os.
## To peStateWithEnvDepth (st: PEState) and (newEnv: Map of Text to CVal) and (d: Int) -> PEState:
Inspect st:
When PEStateR (e, f, oldD, se, sr, os):
Return a new PEStateR with env newEnv and funcs f and depth d and staticEnv (a new Map of Text to CExpr) and specResults sr and onStack (copy of os).
## To peStaticEnv (st: PEState) -> Map of Text to CExpr:
Inspect st:
When PEStateR (e, f, d, se, sr, os):
Return se.
## To peStateWithStaticBinding (st: PEState) and (name: Text) and (val: CExpr) -> PEState:
Inspect st:
When PEStateR (e, f, d, se, sr, os):
Set item name of se to val.
Return a new PEStateR with env e and funcs f and depth d and staticEnv se and specResults sr and onStack os.
## To peStateRemoveStatic (st: PEState) and (name: Text) -> PEState:
Inspect st:
When PEStateR (e, f, d, se, sr, os):
Remove name from se.
Return a new PEStateR with env e and funcs f and depth d and staticEnv se and specResults sr and onStack os.
## To peStateWithEnvDepthStatic (st: PEState) and (newEnv: Map of Text to CVal) and (d: Int) and (newSe: Map of Text to CExpr) -> PEState:
Inspect st:
When PEStateR (e, f, oldD, se, sr, os):
Return a new PEStateR with env newEnv and funcs f and depth d and staticEnv newSe and specResults sr and onStack (copy of os).
## To isVNothing (v: CVal) -> Bool:
Inspect v:
When VNothing:
Return true.
Otherwise:
Return false.
## To isLiteral (e: CExpr) -> Bool:
Inspect e:
When CInt (v):
Return true.
When CBool (v):
Return true.
When CText (v):
Return true.
Otherwise:
Return false.
## To exprToVal (e: CExpr) -> CVal:
Inspect e:
When CInt (v):
Return a new VInt with value v.
When CBool (v):
Return a new VBool with value v.
When CText (v):
Return a new VText with value v.
When CFloat (v):
Return a new VFloat with value v.
When CList (items):
Let vals be a new Seq of CVal.
Repeat for elem in items:
Push exprToVal(elem) to vals.
Return a new VSeq with items vals.
When CNewVariant (tag, names, vals):
Let vvals be a new Seq of CVal.
Repeat for v in vals:
Push exprToVal(v) to vvals.
Return a new VVariant with typeName tag and variantName tag and fields vvals.
When CNew (typeName, fieldNames, fieldExprs):
If typeName equals "Map":
Return a new VMap with entries a new Map of Text to CVal.
Let vvals be a new Seq of CVal.
Repeat for fe in fieldExprs:
Push exprToVal(fe) to vvals.
Return a new VVariant with typeName typeName and variantName typeName and fields vvals.
When CTuple (items):
Let vals be a new Seq of CVal.
Repeat for elem in items:
Push exprToVal(elem) to vals.
Return a new VTuple with items vals.
When CCopy (target):
Return exprToVal(target).
Otherwise:
Return a new VNothing.
## To valToExpr (v: CVal) -> CExpr:
Inspect v:
When VInt (n):
Return a new CInt with value n.
When VBool (b):
Return a new CBool with value b.
When VText (s):
Return a new CText with value s.
When VFloat (f):
Return a new CFloat with value f.
When VSeq (items):
Let exprs be a new Seq of CExpr.
Repeat for elem in items:
Push valToExpr(elem) to exprs.
Return a new CList with items exprs.
When VVariant (vTypeName, vVarName, vFields):
Let exprs be a new Seq of CExpr.
Repeat for v in vFields:
Push valToExpr(v) to exprs.
Return a new CNewVariant with tag vVarName and fnames (a new Seq of Text) and fvals exprs.
When VTuple (items):
Let exprs be a new Seq of CExpr.
Repeat for elem in items:
Push valToExpr(elem) to exprs.
Return a new CTuple with items exprs.
When VOption (inner, present):
If present:
Return a new COptionSome with inner (valToExpr(inner)).
Return a new COptionNone.
When VMap (entries):
Return a new CNew with typeName "Map" and fieldNames (a new Seq of Text) and fields (a new Seq of CExpr).
Otherwise:
Return a new CVar with name "__unresolvable".
## To evalBinOp (binOp: Text) and (lv: CVal) and (rv: CVal) -> CVal:
Inspect lv:
When VInt (a):
Inspect rv:
When VInt (b):
If binOp equals "+":
Return a new VInt with value (a + b).
If binOp equals "-":
Return a new VInt with value (a - b).
If binOp equals "*":
Return a new VInt with value (a * b).
If binOp equals "/":
If b equals 0:
Return a new VNothing.
Return a new VInt with value (a / b).
If binOp equals "%":
If b equals 0:
Return a new VNothing.
Return a new VInt with value (a % b).
If binOp equals "<":
Return a new VBool with value (a is less than b).
If binOp equals ">":
Return a new VBool with value (a is greater than b).
If binOp equals "<=":
Return a new VBool with value (a is at most b).
If binOp equals ">=":
Return a new VBool with value (a is at least b).
If binOp equals "==":
Return a new VBool with value (a equals b).
If binOp equals "!=":
Return a new VBool with value (a is not b).
Return a new VNothing.
Otherwise:
Return a new VNothing.
When VBool (a):
Inspect rv:
When VBool (b):
If binOp equals "&&":
Return a new VBool with value (a and b).
If binOp equals "||":
Return a new VBool with value (a or b).
If binOp equals "==":
Return a new VBool with value (a equals b).
If binOp equals "!=":
Return a new VBool with value (a is not b).
Return a new VNothing.
Otherwise:
Return a new VNothing.
When VText (a):
Inspect rv:
When VText (b):
If binOp equals "+":
Let joined be "{a}{b}".
Return a new VText with value joined.
If binOp equals "==":
Return a new VBool with value (a equals b).
If binOp equals "!=":
Return a new VBool with value (a is not b).
Return a new VNothing.
Otherwise:
Return a new VNothing.
Otherwise:
Return a new VNothing.
## To isStatic (e: CExpr) -> Bool:
Inspect e:
When CInt (v):
Return true.
When CBool (v):
Return true.
When CText (v):
Return true.
When CFloat (v):
Return true.
When CList (items):
Repeat for elem in items:
Let s be isStatic(elem).
If not s:
Return false.
Return true.
When CNewVariant (tag, names, vals):
Repeat for v in vals:
Let s be isStatic(v).
If not s:
Return false.
Return true.
When CTuple (items):
Repeat for elem in items:
Let s be isStatic(elem).
If not s:
Return false.
Return true.
When COptionSome (inner):
Return isStatic(inner).
When COptionNone:
Return true.
When CNewSeq:
Return true.
When CNewSet:
Return true.
When CNew (typeName, fieldNames, fieldExprs):
Repeat for fe in fieldExprs:
Let s be isStatic(fe).
If not s:
Return false.
Return true.
When CRange (start, end):
Let s1 be isStatic(start).
Let s2 be isStatic(end).
Return (s1 and s2).
When CCopy (target):
Return isStatic(target).
Otherwise:
Return false.
## To isStaticValue (e: CExpr) -> Bool:
Inspect e:
When CNewSeq:
Return false.
When CNewSet:
Return false.
Otherwise:
Return isStatic(e).
## To isCopyPropSafe (e: CExpr) -> Bool:
Inspect e:
When CNewSeq:
Return false.
When CNewSet:
Return false.
Otherwise:
Return true.
## To hasKnownTag (e: CExpr) -> Bool:
Inspect e:
When CNewVariant (tag, names, vals):
Return true.
When CNew (typeName, fieldNames, fieldExprs):
Return true.
Otherwise:
Return false.
## To allStatic (args: Seq of CExpr) -> Bool:
Repeat for a in args:
Let s be isStatic(a).
If not s:
Return false.
Return true.
## To allLiteral (args: Seq of CExpr) -> Bool:
Repeat for a in args:
Let lit be isLiteral(a).
If not lit:
Return false.
Return true.
## To dynamicOnly (args: Seq of CExpr) -> Bool:
Repeat for a in args:
Let lit be isLiteral(a).
If lit:
Return false.
Return true.
## To dynamicArgs (args: Seq of CExpr) -> Seq of CExpr:
Let filtered be a new Seq of CExpr.
Repeat for a in args:
Let lit be isLiteral(a).
If not lit:
Push a to filtered.
Return filtered.
## To hasReturn (stmts: Seq of CStmt) -> Bool:
Repeat for s in stmts:
Inspect s:
When CReturn (retExpr):
Return true.
Otherwise:
Let skip be true.
Return false.
## To exprToKeyPart (e: CExpr) -> Text:
Inspect e:
When CInt (v):
Return "i{v}".
When CBool (v):
If v:
Return "btrue".
Return "bfalse".
When CText (v):
Return "t{v}".
When CFloat (v):
Return "f{v}".
When CList (items):
Let mutable parts be "l".
Repeat for elem in items:
Let ep be exprToKeyPart(elem).
Set parts to "{parts}_{ep}".
Return parts.
When CNewVariant (tag, names, vals):
Let mutable parts be "v{tag}".
Repeat for fv in vals:
Let vp be exprToKeyPart(fv).
Set parts to "{parts}_{vp}".
Return parts.
When CTuple (items):
Let mutable parts be "tp".
Repeat for elem in items:
Let ep be exprToKeyPart(elem).
Set parts to "{parts}_{ep}".
Return parts.
When COptionSome (inner):
Let ip be exprToKeyPart(inner).
Return "s{ip}".
When COptionNone:
Return "none".
When CNewSeq:
Return "seq".
When CNewSet:
Return "set".
When CVar (varName):
Return "var{varName}".
When CBinOp (op, left, right):
Let lp be exprToKeyPart(left).
Let rp be exprToKeyPart(right).
Return "op{op}_{lp}_{rp}".
When CNot (inner):
Let ip be exprToKeyPart(inner).
Return "not_{ip}".
When CCall (fnName, args):
Let mutable parts be "call{fnName}".
Repeat for a in args:
Let ap be exprToKeyPart(a).
Set parts to "{parts}_{ap}".
Return parts.
When CIndex (coll, idx):
Let cp be exprToKeyPart(coll).
Let ip be exprToKeyPart(idx).
Return "idx_{cp}_{ip}".
When CLen (target):
Let tp be exprToKeyPart(target).
Return "len_{tp}".
When CMapGet (mapExpr, key):
Let mp be exprToKeyPart(mapExpr).
Let kp be exprToKeyPart(key).
Return "mg_{mp}_{kp}".
When CFieldAccess (target, field):
Let tp be exprToKeyPart(target).
Return "fa{field}_{tp}".
When CNew (typeName, fieldNames, fieldExprs):
Let mutable parts be "new{typeName}".
Repeat for fv in fieldExprs:
Let vp be exprToKeyPart(fv).
Set parts to "{parts}_{vp}".
Return parts.
When CRange (start, end):
Let sp be exprToKeyPart(start).
Let ep be exprToKeyPart(end).
Return "r_{sp}_{ep}".
When CSlice (coll, startIdx, endIdx):
Let cp be exprToKeyPart(coll).
Let sp be exprToKeyPart(startIdx).
Let ep be exprToKeyPart(endIdx).
Return "sl_{cp}_{sp}_{ep}".
When CCopy (target):
Let tp be exprToKeyPart(target).
Return "cp_{tp}".
When CContains (coll, elem):
Let cp be exprToKeyPart(coll).
Let ep be exprToKeyPart(elem).
Return "ct_{cp}_{ep}".
When CUnion (left, right):
Let lp be exprToKeyPart(left).
Let rp be exprToKeyPart(right).
Return "un_{lp}_{rp}".
When CIntersection (left, right):
Let lp be exprToKeyPart(left).
Let rp be exprToKeyPart(right).
Return "ix_{lp}_{rp}".
When CClosure (params, body, captured):
Return "cl".
When CCallExpr (target, args):
Let tp be exprToKeyPart(target).
Return "ce_{tp}".
When CInterpolatedString (parts):
Let mutable ps be "is".
Repeat for p in parts:
Inspect p:
When CLiteralPart (litVal):
Set ps to "{ps}_lt{litVal}".
When CExprPart (epExpr):
Let pp be exprToKeyPart(epExpr).
Set ps to "{ps}_{pp}".
Return ps.
When CDuration (amount, unit):
Let ap be exprToKeyPart(amount).
Return "dur_{ap}_{unit}".
When CTimeNow:
Return "tnow".
When CDateToday:
Return "today".
When CEscExpr (code):
Return "esc".
Otherwise:
Return "unk".
## To makeKey (fnName: Text) and (args: Seq of CExpr) -> Text:
Let key be fnName.
Repeat for a in args:
Let part be exprToKeyPart(a).
Set key to "{key}_{part}".
Return key.
## To exprEmbeds (prevExpr: CExpr) and (nextExpr: CExpr) -> Bool:
Inspect prevExpr:
When CInt (a):
Inspect nextExpr:
When CInt (b):
Let mutable absA be a.
If a is less than 0:
Set absA to 0 - a.
Let mutable absB be b.
If b is less than 0:
Set absB to 0 - b.
Return (absA is at most absB).
Otherwise:
Return false.
When CBool (a):
Inspect nextExpr:
When CBool (b):
Return true.
Otherwise:
Return false.
When CText (a):
Inspect nextExpr:
When CText (b):
Return (length of a is at most length of b).
Otherwise:
Return false.
When CFloat (a):
Inspect nextExpr:
When CFloat (b):
Return true.
Otherwise:
Return false.
When CVar (a):
Inspect nextExpr:
When CVar (b):
Return true.
Otherwise:
Return false.
When CBinOp (op1, l1, r1):
Inspect nextExpr:
When CBinOp (op2, l2, r2):
If op1 equals op2:
Return (exprEmbeds(l1, l2) and exprEmbeds(r1, r2)).
Return false.
Otherwise:
Return false.
When CCall (fn1, args1):
Inspect nextExpr:
When CCall (fn2, args2):
If fn1 equals fn2:
Let len1 be length of args1.
Let len2 be length of args2.
If len1 equals len2:
Let mutable allEmbed be true.
Let mutable eidx be 1.
Repeat for a1 in args1:
If eidx is at most len2:
Let a2 be item eidx of args2.
If not exprEmbeds(a1, a2):
Set allEmbed to false.
Set eidx to eidx + 1.
Return allEmbed.
Return false.
Otherwise:
Return false.
When CList (items1):
Inspect nextExpr:
When CList (items2):
Let li1 be length of items1.
Let li2 be length of items2.
If li1 is at most li2:
Return true.
Return false.
Otherwise:
Return false.
Otherwise:
Return false.
## To argsStrictlyEmbed (prevExpr: Seq of CExpr) and (nextExpr: Seq of CExpr) -> Bool:
Let lenE be length of prevExpr.
Let lenL be length of nextExpr.
If not (lenE equals lenL):
Return false.
Let mutable allEmbed be true.
Let mutable someStrict be false.
Let mutable aidx be 1.
Repeat for ea in prevExpr:
If aidx is at most lenL:
Let la be item aidx of nextExpr.
If not exprEmbeds(ea, la):
Set allEmbed to false.
If not exprEmbeds(la, ea):
Set someStrict to true.
Set aidx to aidx + 1.
Return (allEmbed and someStrict).
## To makeCycleKey (fnName: Text) and (args: Seq of CExpr) -> Text:
Let key be fnName.
Repeat for a in args:
If isStatic(a):
Let part be exprToKeyPart(a).
Set key to "{key}_{part}".
Otherwise:
Set key to "{key}_d".
Return key.
## To peExpr (e: CExpr) and (state: PEState) -> CExpr:
Let env be peEnv(state).
Let funcs be peFuncs(state).
Let depth be peDepth(state).
Inspect e:
When CInt (v):
Return a new CInt with value v.
When CBool (v):
Return a new CBool with value v.
When CText (v):
Return a new CText with value v.
When CVar (varName):
Let sEnv be peStaticEnv(state).
Let svn be "{varName}".
If sEnv contains svn:
Let staticVal be item svn of sEnv.
Return staticVal.
Let vn be "{varName}".
If env contains vn:
Let val be item vn of env.
Let dyn be isVNothing(val).
If dyn:
Return a new CVar with name varName.
Return valToExpr(val).
Return a new CVar with name varName.
When CBinOp (binOp, left, right):
Let peLeft be peExpr(left, state).
Let peRight be peExpr(right, state).
Let leftLit be isLiteral(peLeft).
Let rightLit be isLiteral(peRight).
If leftLit and rightLit:
Let lv be exprToVal(peLeft).
Let rv be exprToVal(peRight).
Let computed be evalBinOp(binOp, lv, rv).
Return valToExpr(computed).
Return a new CBinOp with op binOp and left peLeft and right peRight.
When CNot (inner):
Let peInner be peExpr(inner, state).
Let innerLit be isLiteral(peInner).
If innerLit:
Inspect peInner:
When CBool (b):
Return a new CBool with value (not b).
Otherwise:
Return a new CNot with inner peInner.
Return a new CNot with inner peInner.
When CCall (fnName, argExprs):
If depth is at most 0:
Let residArgs be a new Seq of CExpr.
Repeat for a in argExprs:
Push peExpr(a, peStateWithDepth(state, 0)) to residArgs.
Return a new CCall with name fnName and args residArgs.
Let fn1 be "{fnName}".
Let peArgs be a new Seq of CExpr.
Repeat for a in argExprs:
Push peExpr(a, state) to peArgs.
Let allStat be allStatic(peArgs).
If allStat:
Let memoKey be makeKey(fn1, peArgs).
Let memoKeyStr be "{memoKey}".
Let specRes be peSpecResults(state).
Let mk0 be "{memoKeyStr}".
If specRes contains mk0:
Let cached be item mk0 of specRes.
Return cached.
Let memoCache be peOnStack(state).
Let mk1 be "{memoKeyStr}".
If memoCache contains mk1:
Return a new CCall with name fn1 and args peArgs.
Let embedKey be "__embed_{fn1}".
Let embedKeyStr be "{embedKey}".
If specRes contains embedKeyStr:
Let prevArgsList be item embedKeyStr of specRes.
Inspect prevArgsList:
When CList (prevSnapshots):
Repeat for prevSnapshot in prevSnapshots:
Inspect prevSnapshot:
When CList (prevArgs):
If argsStrictlyEmbed(prevArgs, peArgs):
Return a new CCall with name fn1 and args peArgs.
Otherwise:
Let skipSnap be true.
Otherwise:
Let skipPrev be true.
Let embedKeyStr2 be "{embedKey}".
Let mutable newSnapshots be a new Seq of CExpr.
If specRes contains embedKeyStr2:
Let existingList be item embedKeyStr2 of specRes.
Inspect existingList:
When CList (existingSnaps):
Repeat for es in existingSnaps:
Push es to newSnapshots.
Otherwise:
Let skipExist be true.
Let peArgsCopy be copy of peArgs.
Push (a new CList with items peArgsCopy) to newSnapshots.
Let embedKeyStr3 be "{embedKey}".
Set item embedKeyStr3 of specRes to (a new CList with items newSnapshots).
Let fn2 be "{fn1}".
Let func be item fn2 of funcs.
Inspect func:
When CFuncDef (fname, params, fnParamTypes, fnReturnType, body):
Let callEnv be a new Map of Text to CVal.
Let childSEnv be a new Map of Text to CExpr.
Let mutable pidx be 1.
Repeat for p in params:
Let argExpr be item pidx of peArgs.
Let argVal be exprToVal(argExpr).
Let pk1 be "{p}".
Set item pk1 of callEnv to argVal.
Let cpSafeArg be isCopyPropSafe(argExpr).
If cpSafeArg:
Let pk2 be "{p}".
Set item pk2 of childSEnv to (copy of argExpr).
Set pidx to pidx + 1.
Let childState be peStateWithEnvDepthStatic(state, callEnv, depth - 1, childSEnv).
Let mk2 be "{memoKeyStr}".
Let childStack be peOnStack(childState).
Push mk2 to childStack.
Let peBody be peBlock(body, childState).
Let rawResult be extractReturn(peBody).
Let bodyResult be validateExtractReturn(rawResult, peBody).
Inspect bodyResult:
When CVar (brName2):
If brName2 equals "__no_return__":
Return a new CCall with name fn1 and args peArgs.
Otherwise:
Let skip be true.
Let mk3 be "{memoKeyStr}".
Let bodyResultCopy be copy of bodyResult.
Set item mk3 of specRes to bodyResultCopy.
Return bodyResult.
Otherwise:
Let fn3 be "{fn1}".
Return a new CCall with name fn3 and args peArgs.
Let mutable hasSomeStatic be false.
Let mutable hasSomeDynamic be false.
Repeat for pa in peArgs:
If isStatic(pa):
Set hasSomeStatic to true.
Otherwise:
Set hasSomeDynamic to true.
If hasSomeStatic and hasSomeDynamic:
Let specKey be makeCycleKey(fn1, peArgs).
Let specKeyStr be "{specKey}".
Let specCache be peOnStack(state).
Let sk1 be "{specKeyStr}".
If specCache contains sk1:
Let dynArgs be a new Seq of CExpr.
Repeat for pa in peArgs:
If not isStatic(pa):
Push pa to dynArgs.
Let sk2 be "{specKeyStr}".
Return a new CCall with name sk2 and args dynArgs.
Let fn4 be "{fn1}".
Let func2 be item fn4 of funcs.
Inspect func2:
When CFuncDef (fname, params, fnParamTypes, fnReturnType, body):
Let callEnv be a new Map of Text to CVal.
Let childSEnv be a new Map of Text to CExpr.
Let dynParams be a new Seq of Text.
Let mutable pidx be 1.
Repeat for p in params:
Let argExpr be item pidx of peArgs.
If isStatic(argExpr):
Let argVal be exprToVal(argExpr).
Let pk1 be "{p}".
Set item pk1 of callEnv to argVal.
Let pk2 be "{p}".
Let argExprCopy be copy of argExpr.
Set item pk2 of childSEnv to argExprCopy.
Otherwise:
Let pk3 be "{p}".
Push pk3 to dynParams.
Let pk4 be "{p}".
Set item pk4 of callEnv to a new VNothing.
Set pidx to pidx + 1.
Let sk3 be "{specKeyStr}".
Push sk3 to specCache.
Let placeholderBody be a new Seq of CStmt.
Let sk4 be "{specKeyStr}".
Let phDynParams be a new Seq of Text.
Repeat for dp in dynParams:
Let dpCopy be "{dp}".
Push dpCopy to phDynParams.
Let phPT be a new Seq of Text.
Let placeholderFunc be a new CFuncDef with name sk4 and params phDynParams and paramTypes phPT and returnType "Any" and body placeholderBody.
Let sk5 be "{specKeyStr}".
Set item sk5 of funcs to placeholderFunc.
Let childState be peStateWithEnvDepthStatic(state, callEnv, depth - 1, childSEnv).
Let peBody be peBlock(body, childState).
Let rawResult2 be extractReturn(peBody).
Let bodyResult be validateExtractReturn(rawResult2, peBody).
Let sk6 be "{specKeyStr}".
Let spDynParams be a new Seq of Text.
Repeat for dp in dynParams:
Let dpCopy be "{dp}".
Push dpCopy to spDynParams.
Let spPT be a new Seq of Text.
Let specFunc be a new CFuncDef with name sk6 and params spDynParams and paramTypes spPT and returnType "Any" and body peBody.
Let sk7 be "{specKeyStr}".
Set item sk7 of funcs to specFunc.
Inspect bodyResult:
When CVar (brName):
If brName equals "__no_return__":
Let fallbackDynArgs be a new Seq of CExpr.
Repeat for pa in peArgs:
If not isStatic(pa):
Push pa to fallbackDynArgs.
Let sk8 be "{specKeyStr}".
Return a new CCall with name sk8 and args fallbackDynArgs.
Otherwise:
Let skip be true.
Return bodyResult.
Otherwise:
Let fn5 be "{fn1}".
Return a new CCall with name fn5 and args peArgs.
Let mutable hasStructArg be false.
Repeat for pa in peArgs:
If hasKnownTag(pa):
Set hasStructArg to true.
If hasStructArg:
Let structKey be "struct_{fn1}".
Let osCheck be peOnStack(state).
Let mutable structSeen be false.
Repeat for osK in osCheck:
If osK equals structKey:
Set structSeen to true.
If not structSeen:
Let fn6 be "{fn1}".
If funcs contains fn6:
Let func3 be item fn6 of funcs.
Inspect func3:
When CFuncDef (fname3, params3, fnPT3, fnRT3, body3):
Let callEnv3 be a new Map of Text to CVal.
Let childSEnv3 be a new Map of Text to CExpr.
Let mutable pidx3 be 1.
Repeat for p3 in params3:
Let argExpr3 be item pidx3 of peArgs.
Let pk31 be "{p3}".
Set item pk31 of callEnv3 to a new VNothing.
Let cpSafe3 be isCopyPropSafe(argExpr3).
If cpSafe3:
Let pk32 be "{p3}".
Set item pk32 of childSEnv3 to (copy of argExpr3).
Set pidx3 to pidx3 + 1.
Let childOs3 be copy of osCheck.
Let structKeyCopy be "{structKey}".
Push structKeyCopy to childOs3.
Let childState3 be peStateWithEnvDepthStatic(state, callEnv3, depth - 1, childSEnv3).
Inspect childState3:
When PEStateR (ce, cf, cd, cse, csr, cos):
Set childState3 to a new PEStateR with env ce and funcs cf and depth cd and staticEnv cse and specResults csr and onStack childOs3.
Let peBody3 be peBlock(body3, childState3).
Let rawResult3 be extractReturn(peBody3).
Let bodyResult3 be validateExtractReturn(rawResult3, peBody3).
Inspect bodyResult3:
When CVar (brName3):
If brName3 equals "__no_return__":
Return a new CCall with name fnName and args peArgs.
Otherwise:
Let skip3 be true.
Return bodyResult3.
Otherwise:
Let fn7 be "{fn1}".
Return a new CCall with name fn7 and args peArgs.
Return a new CCall with name fn1 and args peArgs.
When CIndex (collExpr, idxExpr):
Let peColl be peExpr(collExpr, state).
Let peIdx be peExpr(idxExpr, state).
Inspect peColl:
When CList (listItems):
Inspect peIdx:
When CInt (idxVal):
If idxVal is greater than 0:
If idxVal is at most length of listItems:
Return item idxVal of listItems.
Otherwise:
Let skip be true.
Otherwise:
Let skip be true.
Return a new CIndex with coll peColl and idx peIdx.
When CLen (lenTarget):
Let peTarget be peExpr(lenTarget, state).
Inspect peTarget:
When CList (listItems):
Return a new CInt with value (length of listItems).
When CTuple (tupleItems):
Return a new CInt with value (length of tupleItems).
Otherwise:
Let skip be true.
Return a new CLen with target peTarget.
When CMapGet (mapTarget, mapKey):
Let peTarget be peExpr(mapTarget, state).
Let peKey be peExpr(mapKey, state).
Inspect peTarget:
When CNewVariant (nvTag, nvNames, nvVals):
Inspect peKey:
When CText (keyStr):
If keyStr equals "__tag":
Return a new CText with value nvTag.
Let mutable fidx be 1.
Repeat for fname in nvNames:
If fname equals keyStr:
Return item fidx of nvVals.
Set fidx to fidx + 1.
Otherwise:
Let skip be true.
When CNew (cnTypeName, cnFieldNames, cnFieldVals):
Inspect peKey:
When CText (keyStr):
If keyStr equals "__tag":
Return a new CText with value cnTypeName.
Let mutable fidx2 be 1.
Repeat for fname2 in cnFieldNames:
If fname2 equals keyStr:
Return item fidx2 of cnFieldVals.
Set fidx2 to fidx2 + 1.
Otherwise:
Let skip be true.
Otherwise:
Let skip be true.
Return a new CMapGet with target peTarget and key peKey.
When CNewSeq:
Return a new CNewSeq.
When CNewVariant (nvTag, nvNames, nvVals):
Let peVals be a new Seq of CExpr.
Repeat for v in nvVals:
Push peExpr(v, state) to peVals.
Return a new CNewVariant with tag nvTag and fnames nvNames and fvals peVals.
When CFloat (fv):
Return a new CFloat with value fv.
When CList (listItems):
Let peItems be a new Seq of CExpr.
Repeat for li in listItems:
Push peExpr(li, state) to peItems.
Return a new CList with items peItems.
When CRange (rangeStart, rangeEnd):
Let peStart be peExpr(rangeStart, state).
Let peEnd be peExpr(rangeEnd, state).
Return a new CRange with start peStart and end peEnd.
When CSlice (sliceColl, sliceStart, sliceEnd):
Let peColl be peExpr(sliceColl, state).
Let peStart be peExpr(sliceStart, state).
Let peEnd be peExpr(sliceEnd, state).
Return a new CSlice with coll peColl and startIdx peStart and endIdx peEnd.
When CCopy (copyTarget):
Let peTarget be peExpr(copyTarget, state).
Return a new CCopy with target peTarget.
When CNewSet:
Return a new CNewSet.
When CContains (containsColl, containsElem):
Let peColl be peExpr(containsColl, state).
Let peElem be peExpr(containsElem, state).
Inspect peColl:
When CNew (cnTypeName, cnFieldNames, cnFields):
If length of cnFields equals 0:
Return a new CBool with value false.
When CNewSeq:
Return a new CBool with value false.
When CNewSet:
Return a new CBool with value false.
When CList (litems):
If length of litems equals 0:
Return a new CBool with value false.
Otherwise:
Let skipContains be true.
Return a new CContains with coll peColl and elem peElem.
When CUnion (unionLeft, unionRight):
Let peLeft be peExpr(unionLeft, state).
Let peRight be peExpr(unionRight, state).
Return a new CUnion with left peLeft and right peRight.
When CIntersection (interLeft, interRight):
Let peLeft be peExpr(interLeft, state).
Let peRight be peExpr(interRight, state).
Return a new CIntersection with left peLeft and right peRight.
When COptionSome (optInner):
Let peInner be peExpr(optInner, state).
Return a new COptionSome with inner peInner.
When COptionNone:
Return a new COptionNone.
When CTuple (tupleItems):
Let peItems be a new Seq of CExpr.
Repeat for ti in tupleItems:
Push peExpr(ti, state) to peItems.
Return a new CTuple with items peItems.
When CNew (newTypeName, newFieldNames, newFieldExprs):
Let peNewFields be a new Seq of CExpr.
Repeat for nfe in newFieldExprs:
Push peExpr(nfe, state) to peNewFields.
Return a new CNew with typeName newTypeName and fieldNames newFieldNames and fields peNewFields.
When CFieldAccess (faTarget, faField):
Let peFaTarget be peExpr(faTarget, state).
Inspect peFaTarget:
When CNewVariant (nvTag, nvNames, nvVals):
Let mutable fidx be 1.
Repeat for fname in nvNames:
If fname equals faField:
Return item fidx of nvVals.
Set fidx to fidx + 1.
When CNew (nType, nNames, nVals):
Let mutable fidx be 1.
Repeat for fname in nNames:
If fname equals faField:
Return item fidx of nVals.
Set fidx to fidx + 1.
Otherwise:
Let skip be true.
Return a new CFieldAccess with target peFaTarget and field faField.
When CClosure (clParams, clBody, clCaptured):
Let peClBody be peBlock(clBody, state).
Return a new CClosure with params clParams and body peClBody and captured clCaptured.
When CCallExpr (ceTarget, ceArgs):
Let peCeTarget be peExpr(ceTarget, state).
Let peCeArgs be a new Seq of CExpr.
Repeat for ceArg in ceArgs:
Push peExpr(ceArg, state) to peCeArgs.
Return a new CCallExpr with target peCeTarget and args peCeArgs.
When CInterpolatedString (isParts):
Let peIsParts be a new Seq of CStringPart.
Repeat for isPart in isParts:
Inspect isPart:
When CLiteralPart (litVal):
Push a new CLiteralPart with value litVal to peIsParts.
When CExprPart (epExpr):
Let peEpExpr be peExpr(epExpr, state).
Push a new CExprPart with expr peEpExpr to peIsParts.
Return a new CInterpolatedString with parts peIsParts.
When CDuration (durAmount, durUnit):
Let peDurAmount be peExpr(durAmount, state).
Return a new CDuration with amount peDurAmount and unit durUnit.
When CTimeNow:
Return a new CTimeNow.
When CDateToday:
Return a new CDateToday.
When CEscExpr (escCode):
Return a new CEscExpr with code escCode.
## To collectSetVars (stmts: Seq of CStmt) -> Seq of Text:
Let result be a new Seq of Text.
Repeat for s in stmts:
Inspect s:
When CSet (setName, setExpr):
Push setName to result.
When CIf (ifCond, ifThen, ifElse):
Let thenVars be collectSetVars(ifThen).
Repeat for tv in thenVars:
Push tv to result.
Let elseVars be collectSetVars(ifElse).
Repeat for ev in elseVars:
Push ev to result.
When CWhile (wCond, wBody):
Let wVars be collectSetVars(wBody).
Repeat for wv in wVars:
Push wv to result.
When CRepeat (rVar, rColl, rBody):
Let rVars be collectSetVars(rBody).
Repeat for rv in rVars:
Push rv to result.
Otherwise:
Let skip be true.
Return result.
## To isDeadTarget (targetName: Text) and (env: Map of Text to CVal) -> Bool:
Let tk be "{targetName}".
If env contains tk:
Let tv be item tk of env.
Let tvn be isVNothing(tv).
If tvn:
Return false.
Return true.
Return false.
## To peBlock (stmts: Seq of CStmt) and (state: PEState) -> Seq of CStmt:
Let env be peEnv(state).
Let funcs be peFuncs(state).
Let depth be peDepth(state).
Let blockResult be a new Seq of CStmt.
Repeat for s in stmts:
Let alreadyReturned be hasReturn(blockResult).
If alreadyReturned:
Return blockResult.
Inspect s:
When CLet (letName, letExpr):
Let peVal be peExpr(letExpr, state).
Let valSV be isStaticValue(peVal).
Let cpSafe be isCopyPropSafe(peVal).
If cpSafe:
Let letNameS be "{letName}".
Let peValS be copy of peVal.
Let sEnvL be peStaticEnv(state).
Set item letNameS of sEnvL to peValS.
Otherwise:
Let sEnvL2 be peStaticEnv(state).
Let letNameR be "{letName}".
If sEnvL2 contains letNameR:
Remove letNameR from sEnvL2.
If valSV:
Set item letName of env to exprToVal(peVal).
Otherwise:
Let letKey be "{letName}".
Set item letKey of env to a new VNothing.
Push (a new CLet with name letName and expr peVal) to blockResult.
When CSet (setName, setExpr):
Let peVal be peExpr(setExpr, state).
Let valSV2 be isStaticValue(peVal).
Let cpSafeS be isCopyPropSafe(peVal).
If cpSafeS:
Let setNameS be "{setName}".
Let peValS be copy of peVal.
Let sEnvS be peStaticEnv(state).
Set item setNameS of sEnvS to peValS.
Otherwise:
Let sEnvS2 be peStaticEnv(state).
Let setNameR be "{setName}".
If sEnvS2 contains setNameR:
Remove setNameR from sEnvS2.
If valSV2:
Set item setName of env to exprToVal(peVal).
Otherwise:
Let setKey be "{setName}".
Set item setKey of env to a new VNothing.
Push (a new CSet with name setName and expr peVal) to blockResult.
When CIf (ifCond, thenBlock, elseBlock):
Let peCond be peExpr(ifCond, state).
Let condLit be isLiteral(peCond).
If condLit:
Inspect peCond:
When CBool (b):
If b:
Let thenRes be peBlock(thenBlock, state).
Repeat for ts in thenRes:
Push ts to blockResult.
Otherwise:
Let elseRes be peBlock(elseBlock, state).
Repeat for es in elseRes:
Push es to blockResult.
Otherwise:
Let thenRes2 be peBlock(thenBlock, state).
Let elseRes2 be peBlock(elseBlock, state).
Push (a new CIf with cond peCond and thenBlock thenRes2 and elseBlock elseRes2) to blockResult.
Otherwise:
Let thenRes3 be peBlock(thenBlock, state).
Let elseRes3 be peBlock(elseBlock, state).
Push (a new CIf with cond peCond and thenBlock thenRes3 and elseBlock elseRes3) to blockResult.
When CWhile (whileCond, whileBody):
Let modVars be collectSetVars(whileBody).
Let sEnvW be peStaticEnv(state).
Repeat for mv in modVars:
Let mvK1 be "{mv}".
If sEnvW contains mvK1:
Let mvK2 be "{mv}".
Let prevVal be item mvK2 of sEnvW.
Let mvK3 be "{mv}".
Push (a new CLet with name mvK3 and expr prevVal) to blockResult.
Let mvK4 be "{mv}".
Remove mvK4 from sEnvW.
Let mvK5 be "{mv}".
Set item mvK5 of env to a new VNothing.
Let peCond be peExpr(whileCond, state).
Let condLit be isLiteral(peCond).
If condLit:
Inspect peCond:
When CBool (b):
If not b:
Let skip be true.
Otherwise:
Let peBody be peBlock(whileBody, state).
Let sEnvPost1 be peStaticEnv(state).
Repeat for mv1 in modVars:
Let mv1K be "{mv1}".
If sEnvPost1 contains mv1K:
Let mv1K2 be "{mv1}".
Remove mv1K2 from sEnvPost1.
Let mv1K3 be "{mv1}".
Set item mv1K3 of env to a new VNothing.
Push (a new CWhile with cond peCond and body peBody) to blockResult.
Otherwise:
Let peBody2 be peBlock(whileBody, state).
Let sEnvPost2 be peStaticEnv(state).
Repeat for mv2 in modVars:
Let mv2K be "{mv2}".
If sEnvPost2 contains mv2K:
Let mv2K2 be "{mv2}".
Remove mv2K2 from sEnvPost2.
Let mv2K3 be "{mv2}".
Set item mv2K3 of env to a new VNothing.
Push (a new CWhile with cond peCond and body peBody2) to blockResult.
Otherwise:
Let peBody3 be peBlock(whileBody, state).
Let sEnvPost3 be peStaticEnv(state).
Repeat for mv3 in modVars:
Let mv3K be "{mv3}".
If sEnvPost3 contains mv3K:
Let mv3K2 be "{mv3}".
Remove mv3K2 from sEnvPost3.
Let mv3K3 be "{mv3}".
Set item mv3K3 of env to a new VNothing.
Push (a new CWhile with cond peCond and body peBody3) to blockResult.
When CReturn (retExpr):
Let peVal be peExpr(retExpr, state).
Push (a new CReturn with expr peVal) to blockResult.
When CShow (showExpr):
Let peVal be peExpr(showExpr, state).
Push (a new CShow with expr peVal) to blockResult.
When CCallS (callName, callArgs):
Let peArgs be a new Seq of CExpr.
Repeat for a in callArgs:
Push peExpr(a, state) to peArgs.
Push (a new CCallS with name callName and args peArgs) to blockResult.
When CPush (pushExpr, pushTarget):
Let sEnvPush be peStaticEnv(state).
Let ptk1 be "{pushTarget}".
If sEnvPush contains ptk1:
Let ptk2 be "{pushTarget}".
Let ptPrev be item ptk2 of sEnvPush.
Let ptk3 be "{pushTarget}".
Push (a new CLet with name ptk3 and expr ptPrev) to blockResult.
Let ptk4 be "{pushTarget}".
Remove ptk4 from sEnvPush.
Let ptk5 be "{pushTarget}".
Set item ptk5 of env to a new VNothing.
Let peVal be peExpr(pushExpr, state).
Push (a new CPush with expr peVal and target pushTarget) to blockResult.
When CSetIdx (siTarget, siIdx, siVal):
Let sEnvSI be peStaticEnv(state).
Let sik1 be "{siTarget}".
If sEnvSI contains sik1:
Let sik2 be "{siTarget}".
Let siPrev be item sik2 of sEnvSI.
Let sik3 be "{siTarget}".
Push (a new CLet with name sik3 and expr siPrev) to blockResult.
Let sik4 be "{siTarget}".
Remove sik4 from sEnvSI.
Let sik5 be "{siTarget}".
Set item sik5 of env to a new VNothing.
Let peIdx be peExpr(siIdx, state).
Let peVal be peExpr(siVal, state).
Push (a new CSetIdx with target siTarget and idx peIdx and val peVal) to blockResult.
When CMapSet (msTarget, msKey, msVal):
Let sEnvMS be peStaticEnv(state).
Let msk1 be "{msTarget}".
If sEnvMS contains msk1:
Let msk2 be "{msTarget}".
Let msPrev be item msk2 of sEnvMS.
Let msk3 be "{msTarget}".
Push (a new CLet with name msk3 and expr msPrev) to blockResult.
Let msk4 be "{msTarget}".
Remove msk4 from sEnvMS.
Let msk5 be "{msTarget}".
Set item msk5 of env to a new VNothing.
Let peKey be peExpr(msKey, state).
Let peVal be peExpr(msVal, state).
Push (a new CMapSet with target msTarget and key peKey and val peVal) to blockResult.
When CPop (popTarget):
Let sEnvPop be peStaticEnv(state).
Let ppk1 be "{popTarget}".
If sEnvPop contains ppk1:
Let ppk2 be "{popTarget}".
Let ppPrev be item ppk2 of sEnvPop.
Let ppk3 be "{popTarget}".
Push (a new CLet with name ppk3 and expr ppPrev) to blockResult.
Let ppk4 be "{popTarget}".
Remove ppk4 from sEnvPop.
Let ppk5 be "{popTarget}".
Set item ppk5 of env to a new VNothing.
Push (a new CPop with target popTarget) to blockResult.
When CRepeat (repVar, repColl, repBody):
Let peColl be peExpr(repColl, state).
Let collStatic be isStatic(peColl).
Let mutable didUnroll be false.
If collStatic:
Inspect peColl:
When CList (listItems):
Set didUnroll to true.
Repeat for listItem in listItems:
Let rv be "{repVar}".
Set item rv of env to exprToVal(listItem).
Let rv2 be "{repVar}".
Let sEnvR be peStaticEnv(state).
Set item rv2 of sEnvR to listItem.
Let unrolledBody be peBlock(repBody, state).
Let mutable hasBreakOrReturn be false.
Repeat for us in unrolledBody:
Inspect us:
When CBreak:
Set hasBreakOrReturn to true.
When CReturn (retExpr):
Set hasBreakOrReturn to true.
Otherwise:
Let skip be true.
Repeat for us in unrolledBody:
Push us to blockResult.
If hasBreakOrReturn:
Return blockResult.
Otherwise:
Let skip be true.
If not didUnroll:
Let repModVars be collectSetVars(repBody).
Let sEnvF be peStaticEnv(state).
Repeat for rmv in repModVars:
Let rmvK1 be "{rmv}".
If sEnvF contains rmvK1:
Let rmvK2 be "{rmv}".
Let rmvPrev be item rmvK2 of sEnvF.
Let rmvK3 be "{rmv}".
Push (a new CLet with name rmvK3 and expr rmvPrev) to blockResult.
Let rmvK4 be "{rmv}".
Remove rmvK4 from sEnvF.
Let rmvK5 be "{rmv}".
Set item rmvK5 of env to a new VNothing.
If sEnvF contains repVar:
Remove repVar from sEnvF.
Let repVarEnvKey be "{repVar}".
Set item repVarEnvKey of env to a new VNothing.
Let peBody be peBlock(repBody, state).
Push (a new CRepeat with var repVar and coll peColl and body peBody) to blockResult.
When CRepeatRange (rrVar, rrStart, rrEnd, rrBody):
Let peStart be peExpr(rrStart, state).
Let peEnd be peExpr(rrEnd, state).
Let startStatic be isStatic(peStart).
Let endStatic be isStatic(peEnd).
If startStatic and endStatic:
Inspect peStart:
When CInt (startVal):
Inspect peEnd:
When CInt (endVal):
Let rangeSize be endVal - startVal.
If rangeSize is less than 64:
Let mutable ri be startVal.
While ri is at most endVal:
Let rrKey be "{rrVar}".
Set item rrKey of env to a new VInt with value ri.
Let rrValExpr be a new CInt with value ri.
Let rrKey2 be "{rrVar}".
Let sEnvRR be peStaticEnv(state).
Set item rrKey2 of sEnvRR to rrValExpr.
Let unrolledBody be peBlock(rrBody, state).
Repeat for us in unrolledBody:
Push us to blockResult.
Set ri to ri + 1.
Return blockResult.
Otherwise:
Let skip be true.
Otherwise:
Let skip be true.
Let rrModVars be collectSetVars(rrBody).
Let sEnvRR2 be peStaticEnv(state).
Repeat for rrmv in rrModVars:
Let rrmvK1 be "{rrmv}".
If sEnvRR2 contains rrmvK1:
Let rrmvK2 be "{rrmv}".
Let rrmvPrev be item rrmvK2 of sEnvRR2.
Let rrmvK3 be "{rrmv}".
Push (a new CLet with name rrmvK3 and expr rrmvPrev) to blockResult.
Let rrmvK4 be "{rrmv}".
Remove rrmvK4 from sEnvRR2.
Let rrmvK5 be "{rrmv}".
Set item rrmvK5 of env to a new VNothing.
Let peBody be peBlock(rrBody, state).
Push (a new CRepeatRange with var rrVar and start peStart and end peEnd and body peBody) to blockResult.
When CBreak:
Push a new CBreak to blockResult.
When CAdd (addElem, addTarget):
Let sEnvAdd be peStaticEnv(state).
Let adk1 be "{addTarget}".
If sEnvAdd contains adk1:
Let adk2 be "{addTarget}".
Let adPrev be item adk2 of sEnvAdd.
Let adk3 be "{addTarget}".
Push (a new CLet with name adk3 and expr adPrev) to blockResult.
Let adk4 be "{addTarget}".
Remove adk4 from sEnvAdd.
Let adk5 be "{addTarget}".
Set item adk5 of env to a new VNothing.
Let peVal be peExpr(addElem, state).
Push (a new CAdd with elem peVal and target addTarget) to blockResult.
When CRemove (remElem, remTarget):
Let sEnvRem be peStaticEnv(state).
Let rmk1 be "{remTarget}".
If sEnvRem contains rmk1:
Let rmk2 be "{remTarget}".
Let rmPrev be item rmk2 of sEnvRem.
Let rmk3 be "{remTarget}".
Push (a new CLet with name rmk3 and expr rmPrev) to blockResult.
Let rmk4 be "{remTarget}".
Remove rmk4 from sEnvRem.
Let rmk5 be "{remTarget}".
Set item rmk5 of env to a new VNothing.
Let peVal be peExpr(remElem, state).
Push (a new CRemove with elem peVal and target remTarget) to blockResult.
When CSetField (sfTarget, sfField, sfValExpr):
Let sEnvSF be peStaticEnv(state).
Let sfk1 be "{sfTarget}".
If sEnvSF contains sfk1:
Let sfk2 be "{sfTarget}".
Let sfPrev be item sfk2 of sEnvSF.
Let sfk3 be "{sfTarget}".
Push (a new CLet with name sfk3 and expr sfPrev) to blockResult.
Let sfk4 be "{sfTarget}".
Remove sfk4 from sEnvSF.
Let sfk5 be "{sfTarget}".
Set item sfk5 of env to a new VNothing.
Let peVal be peExpr(sfValExpr, state).
Push (a new CSetField with target sfTarget and field sfField and val peVal) to blockResult.
When CStructDef (sdName, sdFieldNames):
Push (a new CStructDef with name sdName and fieldNames sdFieldNames) to blockResult.
When CEnumDef (edName, edVariants):
Push (a new CEnumDef with name edName and variants edVariants) to blockResult.
When CInspect (inspTarget, inspArms):
Let peTarget be peExpr(inspTarget, state).
Let mutable inspDispatched be false.
Inspect peTarget:
When CNewVariant (nvTag, nvNames, nvVals):
Repeat for arm in inspArms:
Inspect arm:
When CWhen (wName, wBindings, wBody):
If wName equals nvTag:
Let mutable bidx be 1.
Repeat for b in wBindings:
Let bval be item bidx of nvVals.
Let bvalStatic be isStatic(bval).
If bvalStatic:
Let b2 be "{b}".
Let bvalCopy be copy of bval.
Let sEnvI be peStaticEnv(state).
Set item b2 of sEnvI to bvalCopy.
Set item b of env to exprToVal(bval).
Otherwise:
Let b3 be "{b}".
Set item b3 of env to a new VNothing.
Let b4 be "{b}".
Let bvalCopy2 be copy of bval.
Let sEnvI2 be peStaticEnv(state).
Set item b4 of sEnvI2 to bvalCopy2.
Push (a new CLet with name b and expr bval) to blockResult.
Set bidx to bidx + 1.
Let matchedBody be peBlock(wBody, state).
Repeat for ms in matchedBody:
Push ms to blockResult.
Set inspDispatched to true.
Return blockResult.
Otherwise:
Let skip be true.
If not inspDispatched:
Repeat for arm in inspArms:
Inspect arm:
When COtherwise (oBody):
Let otherwiseBody be peBlock(oBody, state).
Repeat for os in otherwiseBody:
Push os to blockResult.
Set inspDispatched to true.
Return blockResult.
Otherwise:
Let skip be true.
When CNew (cnTypeName, cnFieldNames, cnFieldVals):
Repeat for arm in inspArms:
Inspect arm:
When CWhen (wName, wBindings, wBody):
If wName equals cnTypeName:
Let mutable bidx be 1.
Repeat for b in wBindings:
Let bval be item bidx of cnFieldVals.
Let bvalStatic be isStatic(bval).
If bvalStatic:
Let b2 be "{b}".
Let bvalCopy be copy of bval.
Let sEnvI be peStaticEnv(state).
Set item b2 of sEnvI to bvalCopy.
Set item b of env to exprToVal(bval).
Otherwise:
Let b3 be "{b}".
Set item b3 of env to a new VNothing.
Let b4 be "{b}".
Let bvalCopy2 be copy of bval.
Let sEnvI2 be peStaticEnv(state).
Set item b4 of sEnvI2 to bvalCopy2.
Push (a new CLet with name b and expr bval) to blockResult.
Set bidx to bidx + 1.
Let matchedBody be peBlock(wBody, state).
Repeat for ms in matchedBody:
Push ms to blockResult.
Set inspDispatched to true.
Return blockResult.
Otherwise:
Let skip be true.
If not inspDispatched:
Repeat for arm in inspArms:
Inspect arm:
When COtherwise (oBody):
Let otherwiseBody be peBlock(oBody, state).
Repeat for os in otherwiseBody:
Push os to blockResult.
Set inspDispatched to true.
Return blockResult.
Otherwise:
Let skip be true.
Otherwise:
Let skip be true.
If not inspDispatched:
Let peArms be a new Seq of CMatchArm.
Repeat for arm in inspArms:
Inspect arm:
When CWhen (wName, wBindings, wBody):
Let peBody be peBlock(wBody, state).
Push (a new CWhen with variantName wName and bindings wBindings and body peBody) to peArms.
When COtherwise (oBody):
Let peBody be peBlock(oBody, state).
Push (a new COtherwise with body peBody) to peArms.
Push (a new CInspect with target peTarget and arms peArms) to blockResult.
When CRuntimeAssert (raCond, raMsg):
Let peRaCond be peExpr(raCond, state).
Let peRaMsg be peExpr(raMsg, state).
Push (a new CRuntimeAssert with cond peRaCond and msg peRaMsg) to blockResult.
When CGive (giveExpr, giveTarget):
Let peGiveExpr be peExpr(giveExpr, state).
Push (a new CGive with expr peGiveExpr and target giveTarget) to blockResult.
When CEscStmt (escCode):
Push (a new CEscStmt with code escCode) to blockResult.
When CSleep (sleepDur):
Let peSleepDur be peExpr(sleepDur, state).
Push (a new CSleep with duration peSleepDur) to blockResult.
When CReadConsole (rcTarget):
Push (a new CReadConsole with target rcTarget) to blockResult.
When CReadFile (rfPath, rfTarget):
Let peRfPath be peExpr(rfPath, state).
Push (a new CReadFile with path peRfPath and target rfTarget) to blockResult.
When CWriteFile (wfPath, wfContent):
Let peWfPath be peExpr(wfPath, state).
Let peWfContent be peExpr(wfContent, state).
Push (a new CWriteFile with path peWfPath and content peWfContent) to blockResult.
When CCheck (chkPred, chkMsg):
Let peChkPred be peExpr(chkPred, state).
Let peChkMsg be peExpr(chkMsg, state).
Push (a new CCheck with predicate peChkPred and msg peChkMsg) to blockResult.
When CAssert (assertProp):
Let peAssertProp be peExpr(assertProp, state).
Push (a new CAssert with proposition peAssertProp) to blockResult.
When CTrust (trustProp, trustJust):
Let peTrustProp be peExpr(trustProp, state).
Push (a new CTrust with proposition peTrustProp and justification trustJust) to blockResult.
When CRequire (reqDep):
Push (a new CRequire with dependency reqDep) to blockResult.
When CMerge (mergeTarget, mergeOther):
Let peMergeOther be peExpr(mergeOther, state).
Push (a new CMerge with target mergeTarget and other peMergeOther) to blockResult.
When CIncrease (incTarget, incAmount):
Let peIncAmount be peExpr(incAmount, state).
Push (a new CIncrease with target incTarget and amount peIncAmount) to blockResult.
When CDecrease (decTarget, decAmount):
Let peDecAmount be peExpr(decAmount, state).
Push (a new CDecrease with target decTarget and amount peDecAmount) to blockResult.
When CAppendToSeq (asTarget, asValue):
Let peAsValue be peExpr(asValue, state).
Push (a new CAppendToSeq with target asTarget and value peAsValue) to blockResult.
When CResolve (resTarget):
Push (a new CResolve with target resTarget) to blockResult.
When CSync (syncTarget, syncChannel):
Let peSyncChannel be peExpr(syncChannel, state).
Push (a new CSync with target syncTarget and channel peSyncChannel) to blockResult.
When CMount (mountTarget, mountPath):
Let peMountPath be peExpr(mountPath, state).
Push (a new CMount with target mountTarget and path peMountPath) to blockResult.
When CConcurrent (concBranches):
Let peConcBranches be a new Seq of Seq of CStmt.
Repeat for concBranch in concBranches:
Push peBlock(concBranch, state) to peConcBranches.
Push (a new CConcurrent with branches peConcBranches) to blockResult.
When CParallel (parBranches):
Let peParBranches be a new Seq of Seq of CStmt.
Repeat for parBranch in parBranches:
Push peBlock(parBranch, state) to peParBranches.
Push (a new CParallel with branches peParBranches) to blockResult.
When CLaunchTask (ltBody, ltHandle):
Let peLtBody be peBlock(ltBody, state).
Push (a new CLaunchTask with body peLtBody and handle ltHandle) to blockResult.
When CStopTask (stHandle):
Let peStHandle be peExpr(stHandle, state).
Push (a new CStopTask with handle peStHandle) to blockResult.
When CSelect (selBranches):
Let peSelBranches be a new Seq of CSelectBranch.
Repeat for selBr in selBranches:
Inspect selBr:
When CSelectRecv (selChan, selVar, selBody):
Let peSelBody be peBlock(selBody, state).
Push (a new CSelectRecv with chan selChan and var selVar and body peSelBody) to peSelBranches.
When CSelectTimeout (selDur, selBody):
Let peSelDur be peExpr(selDur, state).
Let peSelBody be peBlock(selBody, state).
Push (a new CSelectTimeout with duration peSelDur and body peSelBody) to peSelBranches.
Push (a new CSelect with branches peSelBranches) to blockResult.
When CCreatePipe (cpName, cpCapacity):
Let peCpCapacity be peExpr(cpCapacity, state).
Push (a new CCreatePipe with name cpName and capacity peCpCapacity) to blockResult.
When CSendPipe (spPipe, spValue):
Let peSpValue be peExpr(spValue, state).
Push (a new CSendPipe with chan spPipe and value peSpValue) to blockResult.
When CReceivePipe (rpPipe, rpTarget):
Push (a new CReceivePipe with chan rpPipe and target rpTarget) to blockResult.
When CTrySendPipe (tspPipe, tspValue):
Let peTspValue be peExpr(tspValue, state).
Push (a new CTrySendPipe with chan tspPipe and value peTspValue) to blockResult.
When CTryReceivePipe (trpPipe, trpTarget):
Push (a new CTryReceivePipe with chan trpPipe and target trpTarget) to blockResult.
When CSpawn (spawnType, spawnTarget):
Push (a new CSpawn with agentType spawnType and target spawnTarget) to blockResult.
When CSendMessage (smTarget, smMsg):
Let peSmTarget be peExpr(smTarget, state).
Let peSmMsg be peExpr(smMsg, state).
Push (a new CSendMessage with target peSmTarget and msg peSmMsg) to blockResult.
When CAwaitMessage (amTarget):
Push (a new CAwaitMessage with target amTarget) to blockResult.
When CListen (listenAddr, listenHandler):
Let peListenAddr be peExpr(listenAddr, state).
Push (a new CListen with addr peListenAddr and handler listenHandler) to blockResult.
When CConnectTo (connAddr, connTarget):
Let peConnAddr be peExpr(connAddr, state).
Push (a new CConnectTo with addr peConnAddr and target connTarget) to blockResult.
When CZone (zoneName, zoneKind, zoneBody):
Let peZoneBody be peBlock(zoneBody, state).
Push (a new CZone with name zoneName and kind zoneKind and body peZoneBody) to blockResult.
Otherwise:
Let skip be true.
Return blockResult.
## To validateExtractReturn (result: CExpr) and (bodyStmts: Seq of CStmt) -> CExpr:
Inspect result:
When CVar (retName):
If retName equals "__no_return__":
Return result.
If retName equals "__unresolvable":
Return result.
Repeat for s in bodyStmts:
Inspect s:
When CLet (letName, letExpr):
If letName equals retName:
Return a new CVar with name "__no_return__".
Otherwise:
Let skip be true.
Return result.
Otherwise:
Return result.
## To extractReturn (stmts: Seq of CStmt) -> CExpr:
Let mutable idx be length of stmts.
While idx is at least 1:
Let s be item idx of stmts.
Inspect s:
When CReturn (retExpr):
Return retExpr.
Otherwise:
Set idx to idx - 1.
Return a new CVar with name "__no_return__".