## 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 memoCache (a new Map of Text to CExpr) and callGuard (a new Seq of Text).
## To peEnvB (st: PEState) -> Map of Text to CVal:
Inspect st:
When PEStateR (e, f, d, se, sr, os):
Return e.
## To peFuncsB (st: PEState) -> Map of Text to CFunc:
Inspect st:
When PEStateR (e, f, d, se, sr, os):
Return f.
## To peDepthB (st: PEState) -> Int:
Inspect st:
When PEStateR (e, f, d, se, sr, os):
Return d.
## To peStateWithDepthB (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 memoCache sr and callGuard os.
## To peMemoCache (st: PEState) -> Map of Text to CExpr:
Inspect st:
When PEStateR (e, f, d, se, sr, os):
Return sr.
## To peCallGuard (st: PEState) -> Seq of Text:
Inspect st:
When PEStateR (e, f, d, se, sr, os):
Return os.
## To peStateWithEnvDepthB (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 memoCache sr and callGuard (copy of os).
## To peStaticEnvB (st: PEState) -> Map of Text to CExpr:
Inspect st:
When PEStateR (e, f, d, se, sr, os):
Return se.
## To btiEnvBind (m: mutable Map of Text to CVal) and (k: Text) and (v: CVal):
Set item k of m to v.
## To btiEnvDrop (m: mutable Map of Text to CVal) and (k: Text):
Remove k from m.
## To btiSeBind (m: mutable Map of Text to CExpr) and (k: Text) and (v: CExpr):
Set item k of m to v.
## To btiSeDrop (m: mutable Map of Text to CExpr) and (k: Text):
Remove k from m.
## To btiCgPush (s: mutable Seq of Text) and (v: Text):
Push v to s.
## To peStateWithStaticBindingB (st: PEState) and (name: Text) and (val: CExpr) -> PEState:
Inspect st:
When PEStateR (e, f, d, se, sr, os):
btiSeBind(se, name, val).
Return a new PEStateR with env e and funcs f and depth d and staticEnv se and memoCache sr and callGuard os.
## To peStateRemoveStaticB (st: PEState) and (name: Text) -> PEState:
Inspect st:
When PEStateR (e, f, d, se, sr, os):
btiSeDrop(se, name).
Return a new PEStateR with env e and funcs f and depth d and staticEnv se and memoCache sr and callGuard os.
## To peStateWithEnvDepthStaticB (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 memoCache sr and callGuard (copy of os).
## To checkVNothing (v: CVal) -> Bool:
Inspect v:
When VNothing:
Return true.
Otherwise:
Return false.
## To checkLiteral (e: CExpr) -> Bool:
Inspect e:
When CInt (v):
Return true.
When CBool (v):
Return true.
When CText (v):
Return true.
Otherwise:
Return false.
## To exprToValB (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 exprToValB(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 exprToValB(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 exprToValB(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 exprToValB(elem) to vals.
Return a new VTuple with items vals.
When CCopy (target):
Return exprToValB(target).
Otherwise:
Return a new VNothing.
## To valToExprB (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 valToExprB(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 valToExprB(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 valToExprB(elem) to exprs.
Return a new CTuple with items exprs.
When VOption (inner, present):
If present:
Return a new COptionSome with inner (valToExprB(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 evalBinOpB (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 checkStatic (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 checkStatic(elem).
If not s:
Return false.
Return true.
When CNewVariant (tag, names, vals):
Repeat for v in vals:
Let s be checkStatic(v).
If not s:
Return false.
Return true.
When CTuple (items):
Repeat for elem in items:
Let s be checkStatic(elem).
If not s:
Return false.
Return true.
When COptionSome (inner):
Return checkStatic(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 checkStatic(fe).
If not s:
Return false.
Return true.
When CRange (start, end):
Let s1 be checkStatic(start).
Let s2 be checkStatic(end).
Return (s1 and s2).
When CCopy (target):
Return checkStatic(target).
When CClosure (clp, clb, clc):
Return true.
Otherwise:
Return false.
## To checkCopyPropSafe (e: CExpr) -> Bool:
Inspect e:
When CNewSeq:
Return false.
When CNewSet:
Return false.
Otherwise:
Return true.
## To isPeValueForCopyPropB (e: CExpr) -> Bool:
Let sv be checkStaticValue(e).
If sv:
Return true.
Inspect e:
When CList (cpvItems):
Return true.
When CTuple (cpvTup):
Return true.
When CNew (cpvTy, cpvNames, cpvVals):
Return true.
When CNewVariant (cpvTag, cpvNms, cpvVls):
Return true.
When COptionSome (cpvInner):
Return true.
When CRange (cpvS, cpvE):
Return true.
Otherwise:
Return false.
## To exprRefsAnyMutatedB (e: CExpr) and (muts: Seq of Text) -> Bool:
Inspect e:
When CVar (ravVn):
Repeat for ravM in muts:
If ravVn is equal to ravM:
Return true.
Return false.
When CBinOp (ravOp, ravL, ravR):
Let ravA be exprRefsAnyMutatedB(ravL, muts).
If ravA:
Return true.
Return exprRefsAnyMutatedB(ravR, muts).
When CNot (ravNi):
Return exprRefsAnyMutatedB(ravNi, muts).
When CIndex (ravIc, ravIi):
Let ravB be exprRefsAnyMutatedB(ravIc, muts).
If ravB:
Return true.
Return exprRefsAnyMutatedB(ravIi, muts).
When CLen (ravLt):
Return exprRefsAnyMutatedB(ravLt, muts).
When CFieldAccess (ravFt, ravFf):
Return exprRefsAnyMutatedB(ravFt, muts).
When CMapGet (ravMt, ravMk):
Let ravC be exprRefsAnyMutatedB(ravMt, muts).
If ravC:
Return true.
Return exprRefsAnyMutatedB(ravMk, muts).
When CContains (ravCc, ravCe):
Let ravD be exprRefsAnyMutatedB(ravCc, muts).
If ravD:
Return true.
Return exprRefsAnyMutatedB(ravCe, muts).
When CSlice (ravSc, ravSs, ravSe):
Let ravE be exprRefsAnyMutatedB(ravSc, muts).
If ravE:
Return true.
Let ravF be exprRefsAnyMutatedB(ravSs, muts).
If ravF:
Return true.
Return exprRefsAnyMutatedB(ravSe, muts).
When CUnion (ravUl, ravUr):
Let ravG be exprRefsAnyMutatedB(ravUl, muts).
If ravG:
Return true.
Return exprRefsAnyMutatedB(ravUr, muts).
When CIntersection (ravIl, ravIr):
Let ravH be exprRefsAnyMutatedB(ravIl, muts).
If ravH:
Return true.
Return exprRefsAnyMutatedB(ravIr, muts).
When CCopy (ravCt):
Return exprRefsAnyMutatedB(ravCt, muts).
When CInt (ravVi):
Return false.
When CBool (ravVb):
Return false.
When CText (ravVt):
Return false.
When CFloat (ravVf):
Return false.
Otherwise:
Return true.
## To shouldCopyPropB (e: CExpr) and (muts: Seq of Text) -> Bool:
Let scpSv be isPeValueForCopyPropB(e).
If scpSv:
Return true.
Let scpRm be exprRefsAnyMutatedB(e, muts).
If scpRm:
Return false.
Return true.
## To checkStaticValue (e: CExpr) -> Bool:
Inspect e:
When CNewSeq:
Return false.
When CNewSet:
Return false.
Otherwise:
Return checkStatic(e).
## To checkAllStatic (args: Seq of CExpr) -> Bool:
Repeat for a in args:
Let s be checkStatic(a).
If not s:
Return false.
Return true.
## To hasReturnB (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 exprToKeyPartB (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 exprToKeyPartB(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 exprToKeyPartB(fv).
Set parts to "{parts}_{vp}".
Return parts.
When CTuple (items):
Let mutable parts be "tp".
Repeat for elem in items:
Let ep be exprToKeyPartB(elem).
Set parts to "{parts}_{ep}".
Return parts.
When COptionSome (inner):
Let ip be exprToKeyPartB(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 exprToKeyPartB(left).
Let rp be exprToKeyPartB(right).
Return "op{op}_{lp}_{rp}".
When CNot (inner):
Let ip be exprToKeyPartB(inner).
Return "not_{ip}".
When CCall (fnName, args):
Let mutable parts be "call{fnName}".
Repeat for a in args:
Let ap be exprToKeyPartB(a).
Set parts to "{parts}_{ap}".
Return parts.
When CIndex (coll, idx):
Let cp be exprToKeyPartB(coll).
Let ip be exprToKeyPartB(idx).
Return "idx_{cp}_{ip}".
When CLen (target):
Let tp be exprToKeyPartB(target).
Return "len_{tp}".
When CMapGet (mapExpr, key):
Let mp be exprToKeyPartB(mapExpr).
Let kp be exprToKeyPartB(key).
Return "mg_{mp}_{kp}".
When CFieldAccess (target, field):
Let tp be exprToKeyPartB(target).
Return "fa{field}_{tp}".
When CNew (typeName, fieldNames, fieldExprs):
Let mutable parts be "new{typeName}".
Repeat for fv in fieldExprs:
Let vp be exprToKeyPartB(fv).
Set parts to "{parts}_{vp}".
Return parts.
When CRange (start, end):
Let sp be exprToKeyPartB(start).
Let ep be exprToKeyPartB(end).
Return "r_{sp}_{ep}".
When CSlice (coll, startIdx, endIdx):
Let cp be exprToKeyPartB(coll).
Let sp be exprToKeyPartB(startIdx).
Let ep be exprToKeyPartB(endIdx).
Return "sl_{cp}_{sp}_{ep}".
When CCopy (target):
Let tp be exprToKeyPartB(target).
Return "cp_{tp}".
When CContains (coll, elem):
Let cp be exprToKeyPartB(coll).
Let ep be exprToKeyPartB(elem).
Return "ct_{cp}_{ep}".
When CUnion (left, right):
Let lp be exprToKeyPartB(left).
Let rp be exprToKeyPartB(right).
Return "un_{lp}_{rp}".
When CIntersection (left, right):
Let lp be exprToKeyPartB(left).
Let rp be exprToKeyPartB(right).
Return "ix_{lp}_{rp}".
When CClosure (params, body, captured):
Return "cl".
When CCallExpr (target, args):
Let tp be exprToKeyPartB(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 exprToKeyPartB(epExpr).
Set ps to "{ps}_{pp}".
Return ps.
When CDuration (amount, unit):
Let ap be exprToKeyPartB(amount).
Return "dur_{ap}_{unit}".
When CTimeNow:
Return "tnow".
When CDateToday:
Return "today".
When CEscExpr (code):
Return "esc".
Otherwise:
Return "unk".
## To makeKeyB (fnName: Text) and (args: Seq of CExpr) -> Text:
Let key be fnName.
Repeat for a in args:
Let part be exprToKeyPartB(a).
Set key to "{key}_{part}".
Return key.
## To exprEmbedsB (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 (exprEmbedsB(l1, l2) and exprEmbedsB(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 exprEmbedsB(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 argsStrictlyEmbedB (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 exprEmbedsB(ea, la):
Set allEmbed to false.
If not exprEmbedsB(la, ea):
Set someStrict to true.
Set aidx to aidx + 1.
Return (allEmbed and someStrict).
## To makeCycleKeyB (fnName: Text) and (args: Seq of CExpr) -> Text:
Let key be fnName.
Repeat for a in args:
If checkStatic(a):
Let part be exprToKeyPartB(a).
Set key to "{key}_{part}".
Otherwise:
Set key to "{key}_d".
Return key.
## To peExprB (e: CExpr) and (state: PEState) -> CExpr:
Let env be peEnvB(state).
Let funcs be peFuncsB(state).
Let depth be peDepthB(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 peStaticEnvB(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 checkVNothing(val).
If dyn:
Return a new CVar with name varName.
Return valToExprB(val).
Return a new CVar with name varName.
When CBinOp (binOp, left, right):
Let peLeft be peExprB(left, state).
Let peRight be peExprB(right, state).
Let leftLit be checkLiteral(peLeft).
Let rightLit be checkLiteral(peRight).
If leftLit and rightLit:
Let lv be exprToValB(peLeft).
Let rv be exprToValB(peRight).
Let computed be evalBinOpB(binOp, lv, rv).
Return valToExprB(computed).
Return a new CBinOp with op binOp and left peLeft and right peRight.
When CNot (inner):
Let peInner be peExprB(inner, state).
Let innerLit be checkLiteral(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 equals 0:
Let residArgs be a new Seq of CExpr.
Repeat for a in argExprs:
Push peExprB(a, peStateWithDepthB(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 peExprB(a, state) to peArgs.
Let fnClKeyB be "{fnName}".
Let sEnvFCB be peStaticEnvB(state).
If sEnvFCB contains fnClKeyB:
Let fcValB be item fnClKeyB of sEnvFCB.
Inspect fcValB:
When CClosure (clParams, clBody, clCaptured):
Let clChildSeB be copy of sEnvFCB.
Let clCallEnvB be copy of env.
Let mutable cpiB be 1.
Repeat for clp in clParams:
Let clArgB be item cpiB of peArgs.
Let clpkB be "{clp}".
Let clArgCB be copy of clArgB.
Set item clpkB of clChildSeB to clArgCB.
Let clpk2B be "{clp}".
If checkStatic(clArgB):
Set item clpk2B of clCallEnvB to exprToValB(clArgB).
Otherwise:
Set item clpk2B of clCallEnvB to a new VNothing.
Set cpiB to cpiB + 1.
Let clStateB be peStateWithEnvDepthStaticB(state, clCallEnvB, depth - 1, clChildSeB).
Let clBodyResB be peBlockB(clBody, clStateB).
Let clRawB be extractReturnB(clBodyResB).
Let clResultB be validateExtractReturnB(clRawB, clBodyResB).
Inspect clResultB:
When CVar (clrnB):
If clrnB equals "__no_return__":
Let clResidArgsB be copy of peArgs.
Let clTargetExprB be a new CVar with name fnName.
Return a new CCallExpr with target clTargetExprB and args clResidArgsB.
Otherwise:
Let skipClRB be true.
Return clResultB.
Otherwise:
Let skipFCvB be true.
Let allStat be checkAllStatic(peArgs).
If allStat:
Let memoKey be makeKeyB(fn1, peArgs).
Let memoKeyStr be "{memoKey}".
Let specRes be peMemoCache(state).
Let mk0 be "{memoKeyStr}".
If specRes contains mk0:
Let cached be item mk0 of specRes.
Return cached.
Let memoCache be peCallGuard(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 argsStrictlyEmbedB(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}".
Let newSnapWrap be a new CList with items newSnapshots.
btiSeBind(specRes, embedKeyStr3, newSnapWrap).
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 exprToValB(argExpr).
Let pk1 be "{p}".
Set item pk1 of callEnv to argVal.
Let cpSafeArg be checkCopyPropSafe(argExpr).
If cpSafeArg:
Let pk2 be "{p}".
Set item pk2 of childSEnv to (copy of argExpr).
Set pidx to pidx + 1.
Let childState be peStateWithEnvDepthStaticB(state, callEnv, depth - 1, childSEnv).
Let mk2 be "{memoKeyStr}".
Let childStack be peCallGuard(childState).
btiCgPush(childStack, mk2).
Let peBody be peBlockB(body, childState).
Let rawResultB be extractReturnB(peBody).
Let bodyResult be validateExtractReturnB(rawResultB, 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.
btiSeBind(specRes, mk3, 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 checkStatic(pa):
Set hasSomeStatic to true.
Otherwise:
Set hasSomeDynamic to true.
If hasSomeStatic and hasSomeDynamic:
Let specKey be makeCycleKeyB(fn1, peArgs).
Let specKeyStr be "{specKey}".
Let specCache be peCallGuard(state).
Let sk1 be "{specKeyStr}".
If specCache contains sk1:
Let dynArgs be a new Seq of CExpr.
Repeat for pa in peArgs:
If not checkStatic(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 checkStatic(argExpr):
Let argVal be exprToValB(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}".
btiCgPush(specCache, sk3).
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 peStateWithEnvDepthStaticB(state, callEnv, depth - 1, childSEnv).
Let peBody be peBlockB(body, childState).
Let rawResultB2 be extractReturnB(peBody).
Let bodyResult be validateExtractReturnB(rawResultB2, 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 checkStatic(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.
Return a new CCall with name fn1 and args peArgs.
When CIndex (collExpr, idxExpr):
Let peColl be peExprB(collExpr, state).
Let peIdx be peExprB(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 peExprB(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 peExprB(mapTarget, state).
Let peKey be peExprB(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 fn2 in cnFieldNames:
If fn2 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 peExprB(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 peExprB(li, state) to peItems.
Return a new CList with items peItems.
When CRange (rangeStart, rangeEnd):
Let peStart be peExprB(rangeStart, state).
Let peEnd be peExprB(rangeEnd, state).
Return a new CRange with start peStart and end peEnd.
When CSlice (sliceColl, sliceStart, sliceEnd):
Let peColl be peExprB(sliceColl, state).
Let peStart be peExprB(sliceStart, state).
Let peEnd be peExprB(sliceEnd, state).
Return a new CSlice with coll peColl and startIdx peStart and endIdx peEnd.
When CCopy (copyTarget):
Let peTarget be peExprB(copyTarget, state).
Return a new CCopy with target peTarget.
When CNewSet:
Return a new CNewSet.
When CContains (containsColl, containsElem):
Let peColl be peExprB(containsColl, state).
Let peElem be peExprB(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 peExprB(unionLeft, state).
Let peRight be peExprB(unionRight, state).
Return a new CUnion with left peLeft and right peRight.
When CIntersection (interLeft, interRight):
Let peLeft be peExprB(interLeft, state).
Let peRight be peExprB(interRight, state).
Return a new CIntersection with left peLeft and right peRight.
When COptionSome (optInner):
Let peInner be peExprB(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 peExprB(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 peExprB(nfe, state) to peNewFields.
Return a new CNew with typeName newTypeName and fieldNames newFieldNames and fields peNewFields.
When CFieldAccess (faTarget, faField):
Let peFaTarget be peExprB(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 peBlockB(clBody, state).
Return a new CClosure with params clParams and body peClBody and captured clCaptured.
When CCallExpr (ceTarget, ceArgs):
Let peCeTarget be peExprB(ceTarget, state).
Let peCeArgs be a new Seq of CExpr.
Repeat for ceArg in ceArgs:
Push peExprB(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 peExprB(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 peExprB(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.
When CManifestOf (zn):
Let peZone be peExprB(zn, state).
Return a new CManifestOf with zn peZone.
When CChunkAt (idx, zn):
Let peIdx be peExprB(idx, state).
Let peZone be peExprB(zn, state).
Return a new CChunkAt with idx peIdx and zn peZone.
## To collectSetVarsB (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 collectSetVarsB(ifThen).
Repeat for tv in thenVars:
Push tv to result.
Let elseVars be collectSetVarsB(ifElse).
Repeat for ev in elseVars:
Push ev to result.
When CWhile (wCond, wBody):
Let wVars be collectSetVarsB(wBody).
Repeat for wv in wVars:
Push wv to result.
When CRepeat (rVar, rColl, rBody):
Let rVars be collectSetVarsB(rBody).
Repeat for rv in rVars:
Push rv to result.
When CRepeatRange (rrRVar, rrRStart, rrREnd, rrRBody):
Let rrRVars be collectSetVarsB(rrRBody).
Repeat for rrRv in rrRVars:
Push rrRv to result.
When CInspect (inspTarget, inspArms):
Repeat for cinsArm in inspArms:
Inspect cinsArm:
When CWhen (cwName, cwBindings, cwBody):
Let cwVars be collectSetVarsB(cwBody).
Repeat for cwv in cwVars:
Push cwv to result.
Otherwise:
Let skipCinsArm be true.
When CSelect (selBranches):
Repeat for cselBr in selBranches:
Inspect cselBr:
When CSelectRecv (csrChan, csrVar, csrBody):
Let csrVars be collectSetVarsB(csrBody).
Repeat for csrv in csrVars:
Push csrv to result.
When CSelectTimeout (cstDur, cstBody):
Let cstVars be collectSetVarsB(cstBody).
Repeat for cstv in cstVars:
Push cstv to result.
Otherwise:
Let skipCselBr be true.
When CZone (zoneName, zoneKind, zoneBody):
Let zVars be collectSetVarsB(zoneBody).
Repeat for zv in zVars:
Push zv to result.
When CConcurrent (concBranches):
Repeat for concBranch in concBranches:
Let concVars be collectSetVarsB(concBranch).
Repeat for ccv in concVars:
Push ccv to result.
When CParallel (parBranches):
Repeat for parBranch in parBranches:
Let parVars be collectSetVarsB(parBranch).
Repeat for pcv in parVars:
Push pcv to result.
When CLaunchTask (ltBody, ltHandle):
Let ltVars be collectSetVarsB(ltBody).
Repeat for ltv in ltVars:
Push ltv to result.
Otherwise:
Let skip be true.
Return result.
## To isDeadTargetB (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 checkVNothing(tv).
If tvn:
Return false.
Return true.
Return false.
## To peBlockB (stmts: Seq of CStmt) and (state: PEState) -> Seq of CStmt:
Let env be peEnvB(state).
Let funcs be peFuncsB(state).
Let depth be peDepthB(state).
Let mutable blockMutatedDone be false.
Let mutable blockMutated be a new Seq of Text.
Let blockResult be a new Seq of CStmt.
Repeat for s in stmts:
Let alreadyReturned be hasReturnB(blockResult).
If alreadyReturned:
Return blockResult.
Inspect s:
When CLet (letName, letExpr):
Let peVal be peExprB(letExpr, state).
Let valLit be checkStaticValue(peVal).
Let cpvL be isPeValueForCopyPropB(peVal).
Let mutable cpOk be cpvL.
If not cpvL:
If not blockMutatedDone:
Set blockMutated to collectSetVarsB(stmts).
Set blockMutatedDone to true.
Let rmmL be exprRefsAnyMutatedB(peVal, blockMutated).
If not rmmL:
Set cpOk to true.
If cpOk:
Let letNameS be "{letName}".
Let peValS be copy of peVal.
Let sEnvL be peStaticEnvB(state).
btiSeBind(sEnvL, letNameS, peValS).
Otherwise:
Let sEnvL2 be peStaticEnvB(state).
Let letNameR be "{letName}".
If sEnvL2 contains letNameR:
btiSeDrop(sEnvL2, letNameR).
If valLit:
btiEnvBind(env, letName, exprToValB(peVal)).
Otherwise:
Let letKey be "{letName}".
btiEnvBind(env, letKey, (a new VNothing)).
Push (a new CLet with name letName and expr peVal) to blockResult.
When CSet (setName, setExpr):
Let peVal be peExprB(setExpr, state).
Let valLit be checkStaticValue(peVal).
Let cpvSL be isPeValueForCopyPropB(peVal).
Let mutable cpOkS be cpvSL.
If not cpvSL:
If not blockMutatedDone:
Set blockMutated to collectSetVarsB(stmts).
Set blockMutatedDone to true.
Let rmmSL be exprRefsAnyMutatedB(peVal, blockMutated).
If not rmmSL:
Set cpOkS to true.
Let sEnvCS be peStaticEnvB(state).
Let setNameChk be "{setName}".
Let mutable priorWasStatic be false.
Let mutable priorStaticVal be (a new CInt with value 0).
If sEnvCS contains setNameChk:
Let setNameItm be "{setName}".
Let priorCV be item setNameItm of sEnvCS.
Let pcvStatic be checkStaticValue(priorCV).
If pcvStatic:
Set priorWasStatic to true.
Set priorStaticVal to copy of priorCV.
If cpOkS:
Let setNameS be "{setName}".
Let peValS be copy of peVal.
btiSeBind(sEnvCS, setNameS, peValS).
Otherwise:
Let setNameR be "{setName}".
If sEnvCS contains setNameR:
Let setNameD be "{setName}".
btiSeDrop(sEnvCS, setNameD).
If valLit:
btiEnvBind(env, setName, exprToValB(peVal)).
Otherwise:
If priorWasStatic:
Let setNameL be "{setName}".
Push (a new CLet with name setNameL and expr priorStaticVal) to blockResult.
Let setKey be "{setName}".
btiEnvBind(env, setKey, (a new VNothing)).
Push (a new CSet with name setName and expr peVal) to blockResult.
When CIf (ifCond, thenBlock, elseBlock):
Let peCond be peExprB(ifCond, state).
Let condLit be checkLiteral(peCond).
If condLit:
Inspect peCond:
When CBool (b):
If b:
Let thenRes be peBlockB(thenBlock, state).
Repeat for ts in thenRes:
Push ts to blockResult.
Otherwise:
Let elseRes be peBlockB(elseBlock, state).
Repeat for es in elseRes:
Push es to blockResult.
Otherwise:
Let thenRes2 be peBlockB(thenBlock, state).
Let elseRes2 be peBlockB(elseBlock, state).
Push (a new CIf with cond peCond and thenBlock thenRes2 and elseBlock elseRes2) to blockResult.
Otherwise:
Let thenModsIf be collectSetVarsB(thenBlock).
Let elseModsIf be collectSetVarsB(elseBlock).
Let allModsIf be a new Seq of Text.
Repeat for tmI in thenModsIf:
Push tmI to allModsIf.
Repeat for emI in elseModsIf:
Push emI to allModsIf.
Let sEnvIf be peStaticEnvB(state).
Repeat for pmI in allModsIf:
Let pmK1 be "{pmI}".
If sEnvIf contains pmK1:
Let pmK2 be "{pmI}".
Let pmV be item pmK2 of sEnvIf.
Let pmK3 be "{pmI}".
Push (a new CLet with name pmK3 and expr pmV) to blockResult.
Let pmK4 be "{pmI}".
btiSeDrop(sEnvIf, pmK4).
Let pmK5 be "{pmI}".
btiEnvBind(env, pmK5, (a new VNothing)).
Let thenRes3 be peBlockB(thenBlock, state).
Let thenFinal be a new Seq of CStmt.
Repeat for tstmt in thenRes3:
Push tstmt to thenFinal.
Let sEnvThenIf be peStaticEnvB(state).
Repeat for tmv in thenModsIf:
Let tmvK1 be "{tmv}".
If sEnvThenIf contains tmvK1:
Let tmvK2 be "{tmv}".
Let tmvV be item tmvK2 of sEnvThenIf.
Let tmvK3 be "{tmv}".
Push (a new CSet with name tmvK3 and expr tmvV) to thenFinal.
Repeat for rmv in allModsIf:
Let rmvK1 be "{rmv}".
If sEnvThenIf contains rmvK1:
Let rmvK2 be "{rmv}".
btiSeDrop(sEnvThenIf, rmvK2).
Let rmvK3 be "{rmv}".
btiEnvBind(env, rmvK3, (a new VNothing)).
Let elseRes3 be peBlockB(elseBlock, state).
Let elseFinal be a new Seq of CStmt.
Repeat for estmt in elseRes3:
Push estmt to elseFinal.
Let sEnvElseIf be peStaticEnvB(state).
Repeat for emv in elseModsIf:
Let emvK1 be "{emv}".
If sEnvElseIf contains emvK1:
Let emvK2 be "{emv}".
Let emvV be item emvK2 of sEnvElseIf.
Let emvK3 be "{emv}".
Push (a new CSet with name emvK3 and expr emvV) to elseFinal.
Repeat for dmv in allModsIf:
Let dmvK1 be "{dmv}".
If sEnvElseIf contains dmvK1:
Let dmvK2 be "{dmv}".
btiSeDrop(sEnvElseIf, dmvK2).
Let dmvK3 be "{dmv}".
btiEnvBind(env, dmvK3, (a new VNothing)).
Push (a new CIf with cond peCond and thenBlock thenFinal and elseBlock elseFinal) to blockResult.
When CWhile (whileCond, whileBody):
Let modVars be collectSetVarsB(whileBody).
Let sEnvW be peStaticEnvB(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}".
btiSeDrop(sEnvW, mvK4).
Let mvK5 be "{mv}".
btiEnvBind(env, mvK5, (a new VNothing)).
Let peCond be peExprB(whileCond, state).
Let condLit be checkLiteral(peCond).
If condLit:
Inspect peCond:
When CBool (b):
If not b:
Let skip be true.
Otherwise:
Let peBody be peBlockB(whileBody, state).
Let sEnvPost1 be peStaticEnvB(state).
Repeat for mv1 in modVars:
Let mv1K be "{mv1}".
If sEnvPost1 contains mv1K:
Let mv1K2 be "{mv1}".
btiSeDrop(sEnvPost1, mv1K2).
Let mv1K3 be "{mv1}".
btiEnvBind(env, mv1K3, (a new VNothing)).
Push (a new CWhile with cond peCond and body peBody) to blockResult.
Otherwise:
Let peBody2 be peBlockB(whileBody, state).
Let sEnvPost2 be peStaticEnvB(state).
Repeat for mv2 in modVars:
Let mv2K be "{mv2}".
If sEnvPost2 contains mv2K:
Let mv2K2 be "{mv2}".
btiSeDrop(sEnvPost2, mv2K2).
Let mv2K3 be "{mv2}".
btiEnvBind(env, mv2K3, (a new VNothing)).
Push (a new CWhile with cond peCond and body peBody2) to blockResult.
Otherwise:
Let peBody3 be peBlockB(whileBody, state).
Let sEnvPost3 be peStaticEnvB(state).
Repeat for mv3 in modVars:
Let mv3K be "{mv3}".
If sEnvPost3 contains mv3K:
Let mv3K2 be "{mv3}".
btiSeDrop(sEnvPost3, mv3K2).
Let mv3K3 be "{mv3}".
btiEnvBind(env, mv3K3, (a new VNothing)).
Push (a new CWhile with cond peCond and body peBody3) to blockResult.
When CReturn (retExpr):
Let peVal be peExprB(retExpr, state).
Push (a new CReturn with expr peVal) to blockResult.
When CShow (showExpr):
Let peVal be peExprB(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 peExprB(a, state) to peArgs.
Push (a new CCallS with name callName and args peArgs) to blockResult.
When CPush (pushExpr, pushTarget):
Let sEnvPush be peStaticEnvB(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}".
btiSeDrop(sEnvPush, ptk4).
Let ptk5 be "{pushTarget}".
btiEnvBind(env, ptk5, (a new VNothing)).
Let peVal be peExprB(pushExpr, state).
Push (a new CPush with expr peVal and target pushTarget) to blockResult.
When CSetIdx (siTarget, siIdx, siVal):
Let sEnvSI be peStaticEnvB(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}".
btiSeDrop(sEnvSI, sik4).
Let sik5 be "{siTarget}".
btiEnvBind(env, sik5, (a new VNothing)).
Let peIdx be peExprB(siIdx, state).
Let peVal be peExprB(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 peStaticEnvB(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}".
btiSeDrop(sEnvMS, msk4).
Let msk5 be "{msTarget}".
btiEnvBind(env, msk5, (a new VNothing)).
Let peKey be peExprB(msKey, state).
Let peVal be peExprB(msVal, state).
Push (a new CMapSet with target msTarget and key peKey and val peVal) to blockResult.
When CPop (popTarget):
Let sEnvPop be peStaticEnvB(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}".
btiSeDrop(sEnvPop, ppk4).
Let ppk5 be "{popTarget}".
btiEnvBind(env, ppk5, (a new VNothing)).
Push (a new CPop with target popTarget) to blockResult.
When CRepeat (repVar, repColl, repBody):
Let peColl be peExprB(repColl, state).
Let collStatic be checkStatic(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}".
btiEnvBind(env, rv, exprToValB(listItem)).
Let rv2 be "{repVar}".
Let sEnvR be peStaticEnvB(state).
btiSeBind(sEnvR, rv2, listItem).
Let unrolledBody be peBlockB(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 collectSetVarsB(repBody).
Let sEnvF be peStaticEnvB(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}".
btiSeDrop(sEnvF, rmvK4).
Let rmvK5 be "{rmv}".
btiEnvBind(env, rmvK5, (a new VNothing)).
If sEnvF contains repVar:
btiSeDrop(sEnvF, repVar).
Let repVarEnvKey be "{repVar}".
btiEnvBind(env, repVarEnvKey, (a new VNothing)).
Let peBody be peBlockB(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 peExprB(rrStart, state).
Let peEnd be peExprB(rrEnd, state).
Let startStatic be checkStatic(peStart).
Let endStatic be checkStatic(peEnd).
Let mutable didUnrollRR be false.
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}".
Let rrValV be a new VInt with value ri.
btiEnvBind(env, rrKey, rrValV).
Let rrValExpr be a new CInt with value ri.
Let rrKey2 be "{rrVar}".
Let sEnvRR be peStaticEnvB(state).
btiSeBind(sEnvRR, rrKey2, rrValExpr).
Let unrolledBody be peBlockB(rrBody, state).
Repeat for us in unrolledBody:
Push us to blockResult.
Set ri to ri + 1.
Set didUnrollRR to true.
Otherwise:
Let skip be true.
Otherwise:
Let skip be true.
If not didUnrollRR:
Let rrModVars be collectSetVarsB(rrBody).
Let sEnvRR2 be peStaticEnvB(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}".
btiSeDrop(sEnvRR2, rrmvK4).
Let rrmvK5 be "{rrmv}".
btiEnvBind(env, rrmvK5, (a new VNothing)).
Let peBody be peBlockB(rrBody, state).
Let sEnvRR3B be peStaticEnvB(state).
Repeat for rrmv2 in rrModVars:
Let rrmv2K be "{rrmv2}".
If sEnvRR3B contains rrmv2K:
btiSeDrop(sEnvRR3B, rrmv2K).
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 CForceDynamic (fdName):
Let sEnvFd be peStaticEnvB(state).
Let fdk be "{fdName}".
If sEnvFd contains fdk:
Let fdk2 be "{fdName}".
Let fdPrev be item fdk of sEnvFd.
Push (a new CLet with name fdName and expr fdPrev) to blockResult.
btiSeDrop(sEnvFd, fdk).
btiEnvBind(env, fdk2, (a new VNothing)).
When CAdd (addElem, addTarget):
Let sEnvAdd be peStaticEnvB(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}".
btiSeDrop(sEnvAdd, adk4).
Let adk5 be "{addTarget}".
btiEnvBind(env, adk5, (a new VNothing)).
Let peVal be peExprB(addElem, state).
Push (a new CAdd with elem peVal and target addTarget) to blockResult.
When CRemove (remElem, remTarget):
Let sEnvRem be peStaticEnvB(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}".
btiSeDrop(sEnvRem, rmk4).
Let rmk5 be "{remTarget}".
btiEnvBind(env, rmk5, (a new VNothing)).
Let peVal be peExprB(remElem, state).
Push (a new CRemove with elem peVal and target remTarget) to blockResult.
When CSetField (sfTarget, sfField, sfValExpr):
Let sEnvSF be peStaticEnvB(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}".
btiSeDrop(sEnvSF, sfk4).
Let sfk5 be "{sfTarget}".
btiEnvBind(env, sfk5, (a new VNothing)).
Let peVal be peExprB(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 peExprB(inspTarget, state).
Let targetStatic be checkStatic(peTarget).
If targetStatic:
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 b2 be "{b}".
Let bvalCopy be copy of bval.
Let sEnvI be peStaticEnvB(state).
btiSeBind(sEnvI, b2, bvalCopy).
btiEnvBind(env, b, exprToValB(bval)).
Set bidx to bidx + 1.
Let matchedBody be peBlockB(wBody, state).
Repeat for ms in matchedBody:
Push ms to blockResult.
Return blockResult.
Otherwise:
Let skip be true.
Repeat for arm in inspArms:
Inspect arm:
When COtherwise (oBody):
Let otherwiseBody be peBlockB(oBody, state).
Repeat for os in otherwiseBody:
Push os to blockResult.
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 b2 be "{b}".
Let bvalCopy be copy of bval.
Let sEnvI be peStaticEnvB(state).
btiSeBind(sEnvI, b2, bvalCopy).
btiEnvBind(env, b, exprToValB(bval)).
Set bidx to bidx + 1.
Let matchedBody be peBlockB(wBody, state).
Repeat for ms in matchedBody:
Push ms to blockResult.
Return blockResult.
Otherwise:
Let skip be true.
Repeat for arm in inspArms:
Inspect arm:
When COtherwise (oBody):
Let otherwiseBody be peBlockB(oBody, state).
Repeat for os in otherwiseBody:
Push os to blockResult.
Return blockResult.
Otherwise:
Let skip be true.
Otherwise:
Let skip be true.
Let peArms be a new Seq of CMatchArm.
Repeat for arm in inspArms:
Inspect arm:
When CWhen (wName, wBindings, wBody):
Let peBody be peBlockB(wBody, state).
Push (a new CWhen with variantName wName and bindings wBindings and body peBody) to peArms.
When COtherwise (oBody):
Let peBody be peBlockB(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 peExprB(raCond, state).
Let peRaMsg be peExprB(raMsg, state).
Push (a new CRuntimeAssert with cond peRaCond and msg peRaMsg) to blockResult.
When CHardAssert (raCond, raMsg):
Let peRaCond be peExprB(raCond, state).
Let peRaMsg be peExprB(raMsg, state).
Push (a new CHardAssert with cond peRaCond and msg peRaMsg) to blockResult.
When CGive (giveExpr, giveTarget):
Let peGiveExpr be peExprB(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 peExprB(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 peExprB(rfPath, state).
Push (a new CReadFile with path peRfPath and target rfTarget) to blockResult.
When CWriteFile (wfPath, wfContent):
Let peWfPath be peExprB(wfPath, state).
Let peWfContent be peExprB(wfContent, state).
Push (a new CWriteFile with path peWfPath and content peWfContent) to blockResult.
When CCheck (chkPred, chkMsg):
Let peChkPred be peExprB(chkPred, state).
Let peChkMsg be peExprB(chkMsg, state).
Push (a new CCheck with predicate peChkPred and msg peChkMsg) to blockResult.
When CAssert (assertProp):
Let peAssertProp be peExprB(assertProp, state).
Push (a new CAssert with proposition peAssertProp) to blockResult.
When CTrust (trustProp, trustJust):
Let peTrustProp be peExprB(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 peExprB(mergeOther, state).
Push (a new CMerge with target mergeTarget and other peMergeOther) to blockResult.
When CIncrease (incTarget, incAmount):
Let peIncAmount be peExprB(incAmount, state).
Push (a new CIncrease with target incTarget and amount peIncAmount) to blockResult.
When CDecrease (decTarget, decAmount):
Let peDecAmount be peExprB(decAmount, state).
Push (a new CDecrease with target decTarget and amount peDecAmount) to blockResult.
When CAppendToSeq (asTarget, asValue):
Let peAsValue be peExprB(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 peExprB(syncChannel, state).
Push (a new CSync with target syncTarget and channel peSyncChannel) to blockResult.
When CMount (mountTarget, mountPath):
Let peMountPath be peExprB(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 peBlockB(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 peBlockB(parBranch, state) to peParBranches.
Push (a new CParallel with branches peParBranches) to blockResult.
When CLaunchTask (ltBody, ltHandle):
Let peLtBody be peBlockB(ltBody, state).
Push (a new CLaunchTask with body peLtBody and handle ltHandle) to blockResult.
When CStopTask (stHandle):
Let peStHandle be peExprB(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 peBlockB(selBody, state).
Push (a new CSelectRecv with chan selChan and var selVar and body peSelBody) to peSelBranches.
When CSelectTimeout (selDur, selBody):
Let peSelDur be peExprB(selDur, state).
Let peSelBody be peBlockB(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 peExprB(cpCapacity, state).
Push (a new CCreatePipe with name cpName and capacity peCpCapacity) to blockResult.
When CSendPipe (spPipe, spValue):
Let peSpValue be peExprB(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 peExprB(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 peExprB(smTarget, state).
Let peSmMsg be peExprB(smMsg, state).
Push (a new CSendMessage with target peSmTarget and msg peSmMsg) to blockResult.
When CStreamMessage (stTarget, stVals):
Let peStTarget be peExprB(stTarget, state).
Let peStVals be peExprB(stVals, state).
Push (a new CStreamMessage with target peStTarget and values peStVals) to blockResult.
When CAwaitMessage (amTarget):
Push (a new CAwaitMessage with target amTarget) to blockResult.
When CListen (listenAddr, listenHandler):
Let peListenAddr be peExprB(listenAddr, state).
Push (a new CListen with addr peListenAddr and handler listenHandler) to blockResult.
When CConnectTo (connAddr, connTarget):
Let peConnAddr be peExprB(connAddr, state).
Push (a new CConnectTo with addr peConnAddr and target connTarget) to blockResult.
When CZone (zoneName, zoneKind, zoneBody):
Let peZoneBody be peBlockB(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 validateExtractReturnB (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 extractReturnB (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__".