ranger-compiler 3.0.4 → 3.0.5

package/dist/rgrc.js

@@ -399,7 +399,7 @@ class RangerAppHashValue  {
 class RangerAppValue  {
   constructor() {
     this.double_value = 0.0;     /** note: unused */
-    this.string_value = "";     /** note: unused */
+    this.string_value = "";
     this.int_value = 0;     /** note: unused */
     this.boolean_value = false;     /** note: unused */
   }
@@ -862,6 +862,9 @@ class RangerAppClassDesc  extends RangerAppParamDesc {
     this.is_system_union = false;
     this.is_template = false;
     this.is_serialized = false;
+    this.is_process = false;
+    this.process_path = "";
+    this.is_singleton = false;
     this.is_trait = false;
     this.is_operator_class = false;
     this.is_generic_instance = false;
@@ -1034,10 +1037,70 @@ class RangerAppClassDesc  extends RangerAppParamDesc {
     };
     return res;
   };
+  isSingletonClass () {
+    if ( this.is_singleton ) {
+      return true;
+    }
+    if ( (typeof(this.nameNode) === "undefined") == false ) {
+      if ( this.nameNode.hasFlag("singleton") ) {
+        return true;
+      }
+    }
+    if ( (typeof(this.classNode) === "undefined") == false ) {
+      if ( this.classNode.hasBooleanProperty("singleton") ) {
+        return true;
+      }
+    }
+    return false;
+  };
+  buildSingletonAccessor () {
+    let res;
+    if ( this.isSingletonClass() == false ) {
+      return res;
+    }
+    let nodeForFactory;
+    if ( (typeof(this.classNode) === "undefined") == false ) {
+      nodeForFactory = this.classNode;
+    } else {
+      nodeForFactory = this.nameNode;
+    }
+    if ( typeof(nodeForFactory) === "undefined" ) {
+      return res;
+    }
+    const factoryNode = nodeForFactory;
+    const m = new RangerAppFunctionDesc();
+    m.name = "__singleton";
+    m.compiledName = "__singleton";
+    m.is_static = true;
+    m.container_class = this;
+    const methodNameNode = factoryNode.newVRefNode("__singleton");
+    methodNameNode.type_name = this.name;
+    methodNameNode.value_type = 11;
+    m.nameNode = methodNameNode;
+    if ( this.has_constructor ) {
+      const constr = this.constructor_fn;
+      for ( let i = 0; i < constr.params.length; i++) {
+        var arg = constr.params[i];
+        m.params.push(arg);
+      };
+    }
+    res = m;
+    return res;
+  };
   hasStaticMethod (m_name) {
+    if ( m_name == "__singleton" ) {
+      if ( this.isSingletonClass() ) {
+        return true;
+      }
+    }
     return ( typeof(this.defined_static_methods[m_name] ) != "undefined" && this.defined_static_methods.hasOwnProperty(m_name) );
   };
   findStaticMethod (f_name) {
+    if ( f_name == "__singleton" ) {
+      if ( this.isSingletonClass() ) {
+        return this.buildSingletonAccessor();
+      }
+    }
     let e;
     for ( let i = 0; i < this.static_methods.length; i++) {
       var m = this.static_methods[i];
@@ -2952,7 +3015,7 @@ class RangerAppWriterContext  {
     this.expr_restart = false;
     this.expr_restart_block = false;
     this.in_lhs_of_assignment = false;
-    this.in_method = false;     /** note: unused */
+    this.in_method = false;
     this.method_stack = [];
     this.typeNames = [];     /** note: unused */
     this.typeClasses = {};
@@ -5081,6 +5144,70 @@ class RangerLispParser  {
     };
     return 0;
   };
+  isComparisonOpPred (pred) {
+    if ( pred == 10 ) {
+      return true;
+    }
+    if ( pred == 11 ) {
+      return true;
+    }
+    return false;
+  };
+  isDotVRef (n) {
+    if ( n.parsed_type != 11 ) {
+      return false;
+    }
+    if ( (n.vref.indexOf(".")) >= 0 ) {
+      return true;
+    }
+    if ( (n.ns.length) >= 2 ) {
+      return true;
+    }
+    return false;
+  };
+  isDotCallPairOnNode (node) {
+    if ( (node.children.length) != 2 ) {
+      return false;
+    }
+    const ch0 = node.children[0];
+    return this.isDotVRef(ch0);
+  };
+  foldDotCallPairToGroup (node) {
+    if ( this.isDotCallPairOnNode(node) == false ) {
+      return;
+    }
+    const ch0 = node.children.splice(0, 1).pop();
+    const ch1 = node.children.splice(0, 1).pop();
+    const callGroup = new CodeNode(this.code, ch0.sp, ch1.ep);
+    callGroup.expression = true;
+    ch0.parent = callGroup;
+    ch1.parent = callGroup;
+    callGroup.children.push(ch0);
+    callGroup.children.push(ch1);
+    node.children.push(callGroup);
+  };
+  tryCloseCallArgParenBeforeInfix () {
+    const pr = this.curr_node.parent;
+    if ( typeof(pr) === "undefined" ) {
+      return false;
+    }
+    if ( (this.curr_node.children.length) < 1 ) {
+      return false;
+    }
+    const prCnt = pr.children.length;
+    if ( prCnt < 2 ) {
+      return false;
+    }
+    const prevCh = pr.children[(prCnt - 2)];
+    if ( this.isDotVRef(prevCh) == false ) {
+      return false;
+    }
+    this.paren_cnt = this.paren_cnt - 1;
+    this.parents.pop();
+    this.curr_node.ep = this.i;
+    this.curr_node = pr;
+    return true;
+  };
   insert_node (p_node) {
     let push_target = this.curr_node;
     if ( this.curr_node.infix_operator ) {
@@ -5805,6 +5932,15 @@ class RangerLispParser  {
               this.curr_node.infix_operator = false;
               continue;
             }
+            if ( this.isComparisonOpPred(op_pred) ) {
+              this.tryCloseCallArgParenBeforeInfix();
+            }
+            if ( this.isComparisonOpPred(op_pred) && (false == this.curr_node.infix_operator) ) {
+              const cn = this.curr_node;
+              if ( this.isDotCallPairOnNode(cn) ) {
+                this.foldDotCallPairToGroup(cn);
+              }
+            }
             let pTarget = this.curr_node;
             if ( this.curr_node.infix_operator ) {
               const iNode = this.curr_node.infix_node;
@@ -7332,6 +7468,369 @@ class RangerImmutableExtension  {
     wr.out("}", true);
   };
 }
+class RangerProcessLifecycle  {
+  constructor() {
+  }
+  emitInvokeMethods (cl, wr, regName) {
+    if ( cl.hasMethod("start") ) {
+      wr.out("fn __rangerInvokeStart:void () {", true);
+      wr.indent(1);
+      wr.out("this.start()", true);
+      wr.indent(-1);
+      wr.out("}", true);
+    }
+    if ( cl.hasMethod("stop") ) {
+      wr.out("fn __rangerInvokeStop:void () {", true);
+      wr.indent(1);
+      wr.out("this.stop()", true);
+      wr.indent(-1);
+      wr.out("}", true);
+    }
+    if ( cl.hasMethod("hibernate") ) {
+      wr.out("fn __rangerInvokeHibernate:string () {", true);
+      wr.indent(1);
+      wr.out("return this.hibernate()", true);
+      wr.indent(-1);
+      wr.out("}", true);
+    }
+    if ( cl.hasMethod("wakeup") ) {
+      wr.out("fn __rangerInvokeWakeup:void (state:string) {", true);
+      wr.indent(1);
+      wr.out("this.wakeup(state)", true);
+      wr.indent(-1);
+      wr.out("}", true);
+    }
+  };
+  emitStopSubtree (cl, wr, regName) {
+    wr.out("fn __rangerStopSubtree:void () {", true);
+    wr.indent(1);
+    wr.out("if (this.__rangerId == 0) {", true);
+    wr.indent(1);
+    wr.out("return", true);
+    wr.indent(-1);
+    wr.out("}", true);
+    wr.out("def __rgrIdx 0", true);
+    wr.out("while (__rgrIdx < (size this.__rangerChildren)) {", true);
+    wr.indent(1);
+    wr.out("def __rgrChild:RangerProcessBase (at this.__rangerChildren __rgrIdx)", true);
+    wr.out("__rgrChild.__rangerStopSubtree()", true);
+    wr.out("__rgrIdx = __rgrIdx + 1", true);
+    wr.indent(-1);
+    wr.out("}", true);
+    if ( cl.hasMethod("stop") ) {
+      wr.out("this.__rangerInvokeStop()", true);
+    }
+    wr.out(regName + ".__singleton().untrack(this)", true);
+    wr.out("this.__rangerUnregister()", true);
+    wr.out("this.__rangerClearChildren()", true);
+    wr.indent(-1);
+    wr.out("}", true);
+  };
+}
+class RangerProcessClass  {
+  constructor() {
+  }
+  emitAssignProcessId (wr) {
+    wr.out("def __rgrIdReg (ProcessIdRegistry.__singleton())", true);
+    wr.out("def __rgrNewId ( __rgrIdReg.allocate() )", true);
+    wr.out("this.__rangerId = __rgrNewId", true);
+  };
+  createProcessExtension (cl, ctx, wr, typeId) {
+    wr.out("Import \"RangerProcess.rgr\"", true);
+    const regName = cl.name + "__Registry";
+    const life = new RangerProcessLifecycle();
+    wr.out(("class " + regName) + " @singleton(true) {", true);
+    wr.indent(1);
+    wr.out(("def items:[" + cl.name) + "]", true);
+    wr.out(("fn track:void (inst:" + cl.name) + ") {", true);
+    wr.indent(1);
+    wr.out("push items inst", true);
+    wr.indent(-1);
+    wr.out("}", true);
+    wr.out(("fn untrack:void (inst:" + cl.name) + ") {", true);
+    wr.indent(1);
+    wr.out(("def kept:[" + cl.name) + "]", true);
+    wr.out(("for items x:" + cl.name) + " i {", true);
+    wr.indent(1);
+    wr.out("if (x.__rangerId != inst.__rangerId) {", true);
+    wr.indent(1);
+    wr.out("push kept x", true);
+    wr.indent(-1);
+    wr.out("}", true);
+    wr.indent(-1);
+    wr.out("}", true);
+    wr.out("items = kept", true);
+    wr.indent(-1);
+    wr.out("}", true);
+    wr.out(("fn all:[" + cl.name) + "] () {", true);
+    wr.indent(1);
+    wr.out("return items", true);
+    wr.indent(-1);
+    wr.out("}", true);
+    wr.out("fn stopAllInstances:void () {", true);
+    wr.indent(1);
+    wr.out("def n (size items)", true);
+    wr.out("def i (n - 1)", true);
+    wr.out("while (i >= 0) {", true);
+    wr.indent(1);
+    wr.out(("def inst:" + cl.name) + " (at items i)", true);
+    wr.out("if (inst.__rangerId != 0) {", true);
+    wr.indent(1);
+    wr.out("inst.__rangerStopSubtree()", true);
+    wr.indent(-1);
+    wr.out("}", true);
+    wr.out("i = i - 1", true);
+    wr.indent(-1);
+    wr.out("}", true);
+    wr.indent(-1);
+    wr.out("}", true);
+    wr.indent(-1);
+    wr.out("}", true);
+    wr.out(("extension " + cl.name) + " {", true);
+    wr.indent(1);
+    wr.out("fn __rangerRegisterRoot () {", true);
+    wr.indent(1);
+    wr.out(("this.__rangerClassName = \"" + cl.name) + "\"", true);
+    wr.out("this.__rangerTypeId = " + ("" + typeId), true);
+    this.emitAssignProcessId(wr);
+    wr.out(regName + ".__singleton().track(this)", true);
+    wr.indent(-1);
+    wr.out("}", true);
+    wr.out("fn __rangerRegisterChild (parent:RangerProcessBase) {", true);
+    wr.indent(1);
+    wr.out(("this.__rangerClassName = \"" + cl.name) + "\"", true);
+    wr.out("this.__rangerTypeId = " + ("" + typeId), true);
+    wr.out("this.__rangerParent = parent", true);
+    wr.out("this.__rangerParentId = parent.__rangerId", true);
+    this.emitAssignProcessId(wr);
+    wr.out("parent.__rangerTrackChild(this)", true);
+    wr.out(regName + ".__singleton().track(this)", true);
+    wr.indent(-1);
+    wr.out("}", true);
+    wr.out("fn __rangerUnregister:void () {", true);
+    wr.indent(1);
+    wr.out("this.__rangerId = 0", true);
+    wr.out("this.__rangerParentId = 0", true);
+    wr.indent(-1);
+    wr.out("}", true);
+    life.emitInvokeMethods(cl, wr, regName);
+    life.emitStopSubtree(cl, wr, regName);
+    this.emitStaticHelpers(cl, typeId, wr, regName);
+    if ( (cl.process_path.length) > 0 ) {
+      wr.out("sfn processPath:string () {", true);
+      wr.indent(1);
+      wr.out(("return \"" + cl.process_path) + "\"", true);
+      wr.indent(-1);
+      wr.out("}", true);
+    }
+    wr.out("sfn stopAllLive:void () {", true);
+    wr.indent(1);
+    wr.out(((("def __rgrReg:" + regName) + " (") + regName) + ".__singleton())", true);
+    wr.out("__rgrReg.stopAllInstances()", true);
+    wr.indent(-1);
+    wr.out("}", true);
+    wr.indent(-1);
+    wr.out("}", true);
+  };
+  emitStaticHelpers (cl, typeId, wr, regName) {
+    wr.out(("sfn allInstances:[" + cl.name) + "] () {", true);
+    wr.indent(1);
+    wr.out(((("def __rgrReg:" + regName) + " (") + regName) + ".__singleton())", true);
+    wr.out("return __rgrReg.items", true);
+    wr.indent(-1);
+    wr.out("}", true);
+    wr.out("sfn tryStopByProcessId:boolean (processId:int) {", true);
+    wr.indent(1);
+    wr.out(((("def __rgrReg:" + regName) + " (") + regName) + ".__singleton())", true);
+    wr.out(("for __rgrReg.items inst:" + cl.name) + " i {", true);
+    wr.indent(1);
+    wr.out("if (inst.__rangerId == processId) {", true);
+    wr.indent(1);
+    wr.out("if (inst.__rangerId != 0) {", true);
+    wr.indent(1);
+    wr.out("inst.__rangerStopSubtree()", true);
+    wr.out("return true", true);
+    wr.indent(-1);
+    wr.out("}", true);
+    wr.indent(-1);
+    wr.out("}", true);
+    wr.indent(-1);
+    wr.out("}", true);
+    wr.out("return false", true);
+    wr.indent(-1);
+    wr.out("}", true);
+    wr.out("sfn parentIdOf:int (child:RangerProcessBase) {", true);
+    wr.indent(1);
+    wr.out("def cur@(optional):RangerProcessBase (child.__rangerParent)", true);
+    wr.out("while ((null? cur) == false) {", true);
+    wr.indent(1);
+    wr.out("def node:RangerProcessBase (unwrap cur)", true);
+    wr.out("def __rgrExpectType:int " + ("" + typeId), true);
+    wr.out("if (node.__rangerTypeId != __rgrExpectType) {", true);
+    wr.indent(1);
+    wr.out("cur = node.__rangerParent", true);
+    wr.indent(-1);
+    wr.out("} {", true);
+    wr.indent(1);
+    wr.out("return node.__rangerId", true);
+    wr.indent(-1);
+    wr.out("}", true);
+    wr.indent(-1);
+    wr.out("}", true);
+    wr.out("return 0", true);
+    wr.indent(-1);
+    wr.out("}", true);
+  };
+  emitProcessNameRegistryExtension (processClasses, wr) {
+    wr.out("Import \"RangerProcess.rgr\"", true);
+    wr.out("extension ProcessNameRegistry {", true);
+    wr.indent(1);
+    wr.out("fn bindIfConfigured:void (proc:RangerProcessBase) {", true);
+    wr.indent(1);
+    wr.out("if (proc.__rangerId == 0) {", true);
+    wr.indent(1);
+    wr.out("return", true);
+    wr.indent(-1);
+    wr.out("}", true);
+    let hasNamed = false;
+    for ( let i = 0; i < processClasses.length; i++) {
+      var cl = processClasses[i];
+      if ( (cl.process_path.length) > 0 ) {
+        hasNamed = true;
+      }
+    };
+    if ( hasNamed ) {
+      for ( let i_1 = 0; i_1 < processClasses.length; i_1++) {
+        var cl_1 = processClasses[i_1];
+        if ( (cl_1.process_path.length) == 0 ) {
+          continue;
+        }
+        const typeId = i_1 + 1;
+        wr.out(("if (proc.__rangerTypeId == " + ("" + typeId)) + ") {", true);
+        wr.indent(1);
+        wr.out(("proc.__rangerPath = \"" + cl_1.process_path) + "\"", true);
+        wr.out(("this.register(\"" + cl_1.process_path) + "\" proc)", true);
+        wr.out("return", true);
+        wr.indent(-1);
+        wr.out("}", true);
+      };
+    }
+    wr.indent(-1);
+    wr.out("}", true);
+    wr.out("fn findProcess@(optional):RangerProcessBase (path:string) {", true);
+    wr.indent(1);
+    wr.out("if (this.hasLive(path)) {", true);
+    wr.indent(1);
+    wr.out("return (this.findByPath(path))", true);
+    wr.indent(-1);
+    wr.out("}", true);
+    wr.out("return (get byPath \"__rgr_no_such_process__\")", true);
+    wr.indent(-1);
+    wr.out("}", true);
+    wr.indent(-1);
+    wr.out("}", true);
+  };
+  emitProcessRuntimeExtension (processClasses, wr) {
+    wr.out("Import \"RangerProcess.rgr\"", true);
+    wr.out("extension ProcessRuntime {", true);
+    wr.indent(1);
+    wr.out("sfn collectAllLiveRoots:[RangerProcessBase] () {", true);
+    wr.indent(1);
+    wr.out("def roots:[RangerProcessBase]", true);
+    for ( let i = 0; i < processClasses.length; i++) {
+      var cl = processClasses[i];
+      wr.out(((("def __rgr_" + cl.name) + "_all ( ") + cl.name) + ".allInstances() )", true);
+      wr.out(((("for __rgr_" + cl.name) + "_all __rgrRoot:") + cl.name) + " i {", true);
+      wr.indent(1);
+      wr.out("if (__rgrRoot.__rangerId != 0 && __rgrRoot.__rangerParentId == 0) {", true);
+      wr.indent(1);
+      wr.out("push roots __rgrRoot", true);
+      wr.indent(-1);
+      wr.out("}", true);
+      wr.indent(-1);
+      wr.out("}", true);
+    };
+    wr.out("return roots", true);
+    wr.indent(-1);
+    wr.out("}", true);
+    wr.out("sfn printProcessTree:void () {", true);
+    wr.indent(1);
+    wr.out("def __rgrTreeView (new ProcessTreeView)", true);
+    wr.out("def __rgrRoots (ProcessRuntime.collectAllLiveRoots())", true);
+    wr.out("def __rgrTitle \"\"", true);
+    wr.out("__rgrTreeView.renderRoots(__rgrRoots __rgrTitle)", true);
+    wr.indent(-1);
+    wr.out("}", true);
+    wr.out("sfn printProcessTreeTitled:void (title:string) {", true);
+    wr.indent(1);
+    wr.out("def __rgrTreeView (new ProcessTreeView)", true);
+    wr.out("def __rgrRoots (ProcessRuntime.collectAllLiveRoots())", true);
+    wr.out("__rgrTreeView.renderRoots(__rgrRoots title)", true);
+    wr.indent(-1);
+    wr.out("}", true);
+    wr.out("sfn stopByProcessId:void (processId:int) {", true);
+    wr.indent(1);
+    for ( let i_1 = 0; i_1 < processClasses.length; i_1++) {
+      var cl_1 = processClasses[i_1];
+      wr.out(("if (" + cl_1.name) + ".tryStopByProcessId(processId)) {", true);
+      wr.indent(1);
+      wr.out("return", true);
+      wr.indent(-1);
+      wr.out("}", true);
+    };
+    wr.indent(-1);
+    wr.out("}", true);
+    wr.out("sfn stopByClassName:void (name:string) {", true);
+    wr.indent(1);
+    for ( let i_2 = 0; i_2 < processClasses.length; i_2++) {
+      var cl_2 = processClasses[i_2];
+      wr.out(("if (name == \"" + cl_2.name) + "\") {", true);
+      wr.indent(1);
+      wr.out(cl_2.name + ".stopAllLive()", true);
+      wr.out("return", true);
+      wr.indent(-1);
+      wr.out("}", true);
+    };
+    wr.indent(-1);
+    wr.out("}", true);
+    wr.indent(-1);
+    wr.out("}", true);
+  };
+  emitProcessTypeScriptHelpers (processClasses, wr) {
+    let namedPaths = [];
+    let namedClasses = [];
+    for ( let i = 0; i < processClasses.length; i++) {
+      var cl = processClasses[i];
+      if ( (cl.process_path.length) > 0 ) {
+        namedPaths.push(cl.process_path);
+        namedClasses.push(cl);
+      }
+    };
+    if ( (namedPaths.length) == 0 ) {
+      return;
+    }
+    wr.raw("", true);
+    wr.raw("// @process named-path helpers (generated)", true);
+    wr.raw("export type ProcessPath = ", false);
+    let pathIdx = 0;
+    for ( let i_1 = 0; i_1 < namedPaths.length; i_1++) {
+      var p = namedPaths[i_1];
+      if ( pathIdx > 0 ) {
+        wr.raw(" | ", false);
+      }
+      wr.raw(("\"" + p) + "\"", false);
+      pathIdx = pathIdx + 1;
+    };
+    wr.raw(";", true);
+    wr.raw("export interface ProcessNameRegistry {", true);
+    for ( let i_2 = 0; i_2 < namedClasses.length; i_2++) {
+      var cl_1 = namedClasses[i_2];
+      wr.raw(((("  findProcess(path: \"" + cl_1.process_path) + "\"): ") + cl_1.name) + " | undefined;", true);
+    };
+    wr.raw("  findProcess(path: string): RangerProcessBase | undefined;", true);
+    wr.raw("}", true);
+  };
+}
 class RangerServiceBuilder  {
   constructor() {
   }
@@ -7589,6 +8088,7 @@ class RangerFlowParser  {
     this.walkAlso = [];
     this.serializedClasses = [];
     this.immutableClasses = [];
+    this.processClasses = [];
     this.classesWithTraits = [];
     this.collectedIntefaces = [];
     this.definedInterfaces = {};     /** note: unused */
@@ -10505,16 +11005,82 @@ class RangerFlowParser  {
       await this.WalkCollectMethods(rn_1, cl_2.ctx, wr);
       this.walkAlso.push(rn_1);
     };
-    for ( let i_8 = 0; i_8 < ctx.definedClassList.length; i_8++) {
-      var cname = ctx.definedClassList[i_8];
+    if ( (this.processClasses.length) > 0 ) {
+      const baseDesc = ctx.findClass("RangerProcessBase");
+      if ( (typeof(baseDesc) === "undefined") == false ) {
+        const baseCl = baseDesc;
+        baseCl.is_extended_by_children = true;
+      }
+      this.validateProcessPaths(this.processClasses, ctx);
+      const procRtGen = new RangerProcessClass();
+      const rtWr = new CodeWriter();
+      const nameRegWr = new CodeWriter();
+      procRtGen.emitProcessNameRegistryExtension(this.processClasses, nameRegWr);
+      const nameRegCode = nameRegWr.getCode();
+      const nameRegSrc = new SourceCode(nameRegCode);
+      nameRegSrc.filename = "extension ProcessNameRegistry";
+      const nameRegParser = new RangerLispParser(nameRegSrc);
+      nameRegParser.parse(ctx.hasCompilerFlag("no-op-transform"));
+      const nameRegRn = nameRegParser.rootNode;
+      await this.WalkCollectMethods(nameRegRn, ctx, wr);
+      this.walkAlso.push(nameRegRn);
+      procRtGen.emitProcessRuntimeExtension(this.processClasses, rtWr);
+      const rtCode = rtWr.getCode();
+      const rtSrc = new SourceCode(rtCode);
+      rtSrc.filename = "extension ProcessRuntime";
+      const rtParser = new RangerLispParser(rtSrc);
+      rtParser.parse(ctx.hasCompilerFlag("no-op-transform"));
+      const rtRn = rtParser.rootNode;
+      await this.WalkCollectMethods(rtRn, ctx, wr);
+      this.walkAlso.push(rtRn);
+      if ( ctx.hasCompilerFlag("typescript") ) {
+        const tsWr = new CodeWriter();
+        procRtGen.emitProcessTypeScriptHelpers(this.processClasses, tsWr);
+        ctx.compilerSettings["processTsHelpers"] = tsWr.getCode();
+      }
+    }
+    for ( let i_8 = 0; i_8 < this.processClasses.length; i_8++) {
+      var cl_3 = this.processClasses[i_8];
+      cl_3.is_process = true;
+      let hasProcessBase = false;
+      for ( let i_9 = 0; i_9 < cl_3.extends_classes.length; i_9++) {
+        var extName = cl_3.extends_classes[i_9];
+        if ( extName == "RangerProcessBase" ) {
+          hasProcessBase = true;
+        }
+      };
+      if ( hasProcessBase == false ) {
+        cl_3.extends_classes.push("RangerProcessBase");
+        const parentDesc = ctx.findClass("RangerProcessBase");
+        if ( (typeof(parentDesc) === "undefined") == false ) {
+          const parentCl = parentDesc;
+          parentCl.is_extended_by_children = true;
+          parentCl.is_inherited = true;
+        }
+      }
+      const procGen = new RangerProcessClass();
+      const extWr_2 = new CodeWriter();
+      const processTypeId = i_8 + 1;
+      procGen.createProcessExtension(cl_3, cl_3.ctx, extWr_2, processTypeId);
+      const theCode_2 = extWr_2.getCode();
+      const code_2 = new SourceCode(theCode_2);
+      code_2.filename = "extension " + cl_3.name;
+      const parser_2 = new RangerLispParser(code_2);
+      parser_2.parse(ctx.hasCompilerFlag("no-op-transform"));
+      const rn_2 = parser_2.rootNode;
+      await this.WalkCollectMethods(rn_2, cl_3.ctx, wr);
+      this.walkAlso.push(rn_2);
+    };
+    for ( let i_10 = 0; i_10 < ctx.definedClassList.length; i_10++) {
+      var cname = ctx.definedClassList[i_10];
       allTypes.push(cname);
       const c = (( ctx.definedClasses.hasOwnProperty(cname) ? ctx.definedClasses[cname] : undefined ));
       if ( ((c.is_system || c.is_interface) || c.is_template) || c.is_trait ) {
         continue;
       }
       let varNames = {};
-      for ( let i_9 = 0; i_9 < c.variables.length; i_9++) {
-        var p = c.variables[i_9];
+      for ( let i_11 = 0; i_11 < c.variables.length; i_11++) {
+        var p = c.variables[i_11];
         ctx.hadValidType(p.nameNode);
         varNames[p.name] = true;
       };
@@ -10526,8 +11092,8 @@ class RangerFlowParser  {
         }));
       }));
     };
-    for ( let i_10 = 0; i_10 < ctx.definedClassList.length; i_10++) {
-      var cname_1 = ctx.definedClassList[i_10];
+    for ( let i_12 = 0; i_12 < ctx.definedClassList.length; i_12++) {
+      var cname_1 = ctx.definedClassList[i_12];
       allTypes.push(cname_1);
     };
     allTypes.push("int");
@@ -10542,8 +11108,8 @@ class RangerFlowParser  {
     rootCtx.addClass("Any", new_class);
     new_class.is_union = true;
     let did_push = {};
-    for ( let i_11 = 0; i_11 < allTypes.length; i_11++) {
-      var typeName_1 = allTypes[i_11];
+    for ( let i_13 = 0; i_13 < allTypes.length; i_13++) {
+      var typeName_1 = allTypes[i_13];
       if ( ( typeof(did_push[typeName_1] ) != "undefined" && did_push.hasOwnProperty(typeName_1) ) ) {
         continue;
       }
@@ -10999,6 +11565,10 @@ class RangerFlowParser  {
         this.immutableClasses.push(new_class_6);
         new_class_6.is_immutable = true;
       }
+      this.applyProcessClassMeta(new_class_6, classNameNode_1, node, ctx);
+      if ( node.hasBooleanProperty("singleton") ) {
+        new_class_6.is_singleton = true;
+      }
       const third = node.getThird();
       if ( third.vref == "extends" ) {
         if ( node.chlen() >= 4 ) {
@@ -11327,6 +11897,22 @@ class RangerFlowParser  {
     if ( node.hasBooleanProperty("serialize") ) {
       this.serializedClasses.push(ctx.currentClass);
     }
+    if ( node.hasBooleanProperty("process") ) {
+      const procCl = ctx.currentClass;
+      procCl.is_process = true;
+      const procNameNode = procCl.nameNode;
+      if ( (typeof(procNameNode) === "undefined") == false ) {
+        const pn = procNameNode;
+        const procPath = this.readProcessPathFromClassTree(node);
+        if ( (procPath.length) > 0 ) {
+          procCl.process_path = procPath;
+        }
+      }
+    }
+    if ( node.hasBooleanProperty("singleton") ) {
+      const singletonCl = ctx.currentClass;
+      singletonCl.is_singleton = true;
+    }
   };
   findFunctionDesc (obj, ctx, wr) {
     let varDesc;
@@ -11714,6 +12300,142 @@ class RangerFlowParser  {
       ctx.addError(n1, msg);
     }
   };
+  readProcessPathFromClassTree (root) {
+    const path = root.getStringProperty("name");
+    if ( (path.length) > 0 ) {
+      return path;
+    }
+    if ( root.hasExpressionProperty("name") ) {
+      const ann = root.getExpressionProperty("name");
+      if ( (typeof(ann) === "undefined") == false ) {
+        const an = ann;
+        if ( (an.children.length) > 0 ) {
+          const fc = an.children[0];
+          if ( fc.value_type == 4 ) {
+            return fc.string_value;
+          }
+        }
+        if ( an.value_type == 4 ) {
+          return an.string_value;
+        }
+      }
+    }
+    for ( let i = 0; i < root.children.length; i++) {
+      var ch = root.children[i];
+      const childPath = this.readProcessPathFromClassTree(ch);
+      if ( (childPath.length) > 0 ) {
+        return childPath;
+      }
+    };
+    return "";
+  };
+  applyProcessClassMeta (cl, classNameNode, node, ctx) {
+    let isProc = false;
+    if ( classNameNode.hasFlag("process") ) {
+      isProc = true;
+    }
+    if ( node.hasBooleanProperty("process") ) {
+      isProc = true;
+    }
+    const procPathOnly = this.readProcessPathFromClassTree(node);
+    if ( isProc == false ) {
+      if ( (procPathOnly.length) > 0 ) {
+        ctx.addError(classNameNode, "@name is only allowed on @process classes");
+      }
+      return;
+    }
+    this.processClasses.push(cl);
+    cl.is_process = true;
+    if ( (procPathOnly.length) > 0 ) {
+      cl.process_path = procPathOnly;
+    }
+  };
+  resolveProcessPathFromFields (cl) {
+    for ( let i = 0; i < cl.variables.length; i++) {
+      var v = cl.variables[i];
+      if ( v.name != "__rangerProcessName" ) {
+        continue;
+      }
+      if ( v.def_value.value_type == 4 ) {
+        cl.process_path = v.def_value.string_value;
+        return;
+      }
+      if ( (v.value.string_value.length) > 0 ) {
+        cl.process_path = v.value.string_value;
+        return;
+      }
+    };
+  };
+  validateProcessPaths (processClasses, ctx) {
+    for ( let i = 0; i < processClasses.length; i++) {
+      var cl = processClasses[i];
+      if ( (cl.process_path.length) == 0 ) {
+        const classNode = cl.node;
+        if ( (typeof(classNode) === "undefined") == false ) {
+          const cn = classNode;
+          const resolvedCn = this.readProcessPathFromClassTree(cn);
+          if ( (resolvedCn.length) > 0 ) {
+            cl.process_path = resolvedCn;
+          }
+        }
+        const nameNode = cl.nameNode;
+        if ( (cl.process_path.length) == 0 ) {
+          if ( (typeof(nameNode) === "undefined") == false ) {
+            const nn = nameNode;
+            const resolvedNn = this.readProcessPathFromClassTree(nn);
+            if ( (resolvedNn.length) > 0 ) {
+              cl.process_path = resolvedNn;
+            }
+          }
+        }
+        if ( (cl.process_path.length) == 0 ) {
+          this.resolveProcessPathFromFields(cl);
+        }
+      }
+    };
+    let seen = {};
+    for ( let i_1 = 0; i_1 < processClasses.length; i_1++) {
+      var cl_1 = processClasses[i_1];
+      if ( (cl_1.process_path.length) == 0 ) {
+        continue;
+      }
+      const path = cl_1.process_path;
+      const prev = ( seen.hasOwnProperty(path) ? seen[path] : undefined );
+      if ( (typeof(prev) === "undefined") == false ) {
+        const errNode = cl_1.nameNode;
+        if ( (typeof(errNode) === "undefined") == false ) {
+          const en = errNode;
+          ctx.addError(en, "Duplicate @process @name path: " + path);
+        }
+        continue;
+      }
+      seen[path] = "1";
+      if ( this.isValidProcessPath(path) == false ) {
+        const errNode2 = cl_1.nameNode;
+        if ( (typeof(errNode2) === "undefined") == false ) {
+          const en2 = errNode2;
+          ctx.addError(en2, "Invalid @name process path: " + path);
+        }
+      }
+    };
+  };
+  isValidProcessPath (pathStr) {
+    const n = pathStr.length;
+    if ( n == 0 ) {
+      return false;
+    }
+    if ( pathStr == "." ) {
+      return false;
+    }
+    const parts = pathStr.split(".");
+    for ( let i = 0; i < parts.length; i++) {
+      var seg = parts[i];
+      if ( (seg.length) == 0 ) {
+        return false;
+      }
+    };
+    return true;
+  };
   async findLanguageOper (details, ctx, opDef) {
     const langName = operatorsOf_21.getTargetLang_22(ctx);
     let rv;
@@ -12713,6 +13435,114 @@ class NodeEvalState  {
     this.ask_eval_end = 0;     /** note: unused */
   }
 }
+class RangerProcessCodegen  {
+  constructor() {
+  }
+  shouldWrapProcessNew (procNewNode, procNewCtx) {
+    if ( procNewNode.hasNewOper == false ) {
+      return false;
+    }
+    const cl = procNewNode.clDesc;
+    return cl.is_process;
+  };
+  hasParentRegister (procNewCtx) {
+    if ( procNewCtx.in_method && (procNewCtx.in_static_method == false) ) {
+      return true;
+    }
+    return false;
+  };
+  async writeNewArgs (node, ctx, wr, writer) {
+    const givenArgs = node.getThird();
+    const constr = node.clDesc.constructor_fn;
+    if ( (typeof(constr) === "undefined") == false ) {
+      const i = 0;
+      for ( let i_1 = 0; i_1 < constr.params.length; i_1++) {
+        var arg = constr.params[i_1];
+        const argNode = givenArgs.children[i_1];
+        if ( i_1 > 0 ) {
+          wr.out(", ", false);
+        }
+        await writer.walkNewArgForProcess(argNode, ctx, wr);
+        i_1 = i_1 + 1;
+      };
+    }
+  };
+  writeProcessInstanceRegisterCall (wr, lang) {
+    if ( lang == "kotlin" ) {
+      wr.out("if (this is RangerProcessBase && (this as RangerProcessBase).__rangerId != 0) { __rgr_proc.__rangerRegisterChild(this as RangerProcessBase) } else { __rgr_proc.__rangerRegisterRoot() }", false);
+      return;
+    }
+    if ( (lang == "swift6") || (lang == "swift3") ) {
+      wr.out("if let __rgr_parent = self as? RangerProcessBase, __rgr_parent.__rangerId != 0 { __rgr_proc.__rangerRegisterChild(parent: __rgr_parent) } else { __rgr_proc.__rangerRegisterRoot() }", false);
+      return;
+    }
+    wr.out("if (typeof this !== 'undefined' && this.__rangerId) { __rgr_proc.__rangerRegisterChild(this) } else { __rgr_proc.__rangerRegisterRoot() }", false);
+  };
+  shouldUseProcessInstanceRegister (procNewCtx, newCl) {
+    if ( newCl.is_process == false ) {
+      return false;
+    }
+    if ( procNewCtx.in_static_method ) {
+      return false;
+    }
+    const currCl = procNewCtx.getCurrentClass();
+    if ( typeof(currCl) === "undefined" ) {
+      return false;
+    }
+    const hostCl = currCl;
+    return hostCl.is_process;
+  };
+  writeRegisterCall (procNewCtx, wr, lang, newCl) {
+    if ( this.shouldUseProcessInstanceRegister(procNewCtx, newCl) ) {
+      this.writeProcessInstanceRegisterCall(wr, lang);
+    } else {
+      wr.out("__rgr_proc.__rangerRegisterRoot()", false);
+    }
+  };
+  async writeWrappedNewCallEs6 (node, ctx, wr, writer) {
+    const cl = node.clDesc;
+    wr.out("(() => { const __rgr_proc = new ", false);
+    wr.out(cl.name, false);
+    wr.out("(", false);
+    await this.writeNewArgs(node, ctx, wr, writer);
+    wr.out("); ", false);
+    this.writeRegisterCall(ctx, wr, "es6", cl);
+    wr.out("; return __rgr_proc; })()", false);
+  };
+  async writeWrappedNewCallKotlin (node, ctx, wr, writer) {
+    const cl = node.clDesc;
+    wr.out("run { val __rgr_proc = ", false);
+    wr.out(cl.name, false);
+    wr.out("(", false);
+    await this.writeNewArgs(node, ctx, wr, writer);
+    wr.out("); ", false);
+    this.writeRegisterCall(ctx, wr, "kotlin", cl);
+    wr.out("; __rgr_proc }", false);
+  };
+  async writeWrappedNewCallSwift6 (node, ctx, wr, writer) {
+    const cl = node.clDesc;
+    wr.out("({ () -> ", false);
+    wr.out(cl.name, false);
+    wr.out(" in let __rgr_proc = ", false);
+    wr.out(cl.name, false);
+    wr.out("(", false);
+    await this.writeNewArgs(node, ctx, wr, writer);
+    wr.out("); ", false);
+    this.writeRegisterCall(ctx, wr, "swift6", cl);
+    wr.out("; return __rgr_proc }())", false);
+  };
+  async writeWrappedNewCall (node, ctx, wr, lang, writer) {
+    if ( lang == "kotlin" ) {
+      await this.writeWrappedNewCallKotlin(node, ctx, wr, writer);
+      return;
+    }
+    if ( (lang == "swift6") || (lang == "swift3") ) {
+      await this.writeWrappedNewCallSwift6(node, ctx, wr, writer);
+      return;
+    }
+    await this.writeWrappedNewCallEs6(node, ctx, wr, writer);
+  };
+}
 class RangerGenericClassWriter  {
   constructor() {
     this.compFlags = {};
@@ -12902,6 +13732,27 @@ class RangerGenericClassWriter  {
   adjustType (tn) {
     return tn;
   };
+  defValueHasSideEffects (value) {
+    if ( value.has_call ) {
+      return true;
+    }
+    if ( value.hasFnCall ) {
+      return true;
+    }
+    if ( value.is_direct_method_call ) {
+      return true;
+    }
+    return false;
+  };
+  async writeSideEffectOnlyStmt (value, ctx, wr) {
+    ctx.setInExpr();
+    await this.WalkNode(value, ctx, wr);
+    ctx.unsetInExpr();
+    if ( ctx.expressionLevel() == 0 ) {
+      wr.out(";", true);
+    }
+    wr.newline();
+  };
   async WriteVRef (node, ctx, wr) {
     if ( node.eval_type == 13 ) {
       if ( (node.ns.length) > 1 ) {
@@ -13143,7 +13994,26 @@ class RangerGenericClassWriter  {
       }
     }
   };
+  async walkNewArgForProcess (n, ctx, wr) {
+    await this.WalkNode(n, ctx, wr);
+  };
+  async tryWriteProcessNewCall (procNewNode, procNewCtx, outWr) {
+    if ( procNewNode.hasNewOper == false ) {
+      return false;
+    }
+    const procCl = procNewNode.clDesc;
+    if ( procCl.is_process == false ) {
+      return false;
+    }
+    const pc = new RangerProcessCodegen();
+    const lang = operatorsOf_21.getTargetLang_22(procNewCtx);
+    await pc.writeWrappedNewCall(procNewNode, procNewCtx, outWr, lang, this);
+    return true;
+  };
   async writeNewCall (node, ctx, wr) {
+    if ( await this.tryWriteProcessNewCall(node, ctx, wr) ) {
+      return;
+    }
     if ( node.hasNewOper ) {
       const cl = node.clDesc;
       const fc = node.getSecond();
@@ -15357,6 +16227,13 @@ class RangerSwift6ClassWriter  extends RangerGenericClassWriter {
         }
       }
       if ( (p.ref_cnt == 0) && (p.is_class_variable == false) ) {
+        if ( (node.children.length) > 2 ) {
+          const value = node.getThird();
+          if ( this.defValueHasSideEffects(value) ) {
+            await this.writeSideEffectOnlyStmt(value, ctx, wr);
+            return;
+          }
+        }
         wr.out("/** unused:  ", false);
       }
       if ( p.is_static ) {
@@ -15371,8 +16248,8 @@ class RangerSwift6ClassWriter  extends RangerGenericClassWriter {
       if ( (node.children.length) > 2 ) {
         wr.out(" = ", false);
         ctx.setInExpr();
-        const value = node.getThird();
-        await this.WalkNode(value, ctx, wr);
+        const value_1 = node.getThird();
+        await this.WalkNode(value_1, ctx, wr);
         ctx.unsetInExpr();
       } else {
         if ( nn.value_type == 6 ) {
@@ -15440,29 +16317,78 @@ class RangerSwift6ClassWriter  extends RangerGenericClassWriter {
       await this.writeTypeDef(arg.nameNode, ctx, wr);
     };
   };
+  resolveCallReceiverClassName (obj, ctx) {
+    if ( (obj.vref.length) > 0 ) {
+      if ( ctx.isDefinedClass(obj.vref) ) {
+        return obj.vref;
+      }
+    }
+    if ( (obj.eval_type_name.length) > 0 ) {
+      if ( ctx.isDefinedClass(obj.eval_type_name) ) {
+        return obj.eval_type_name;
+      }
+    }
+    if ( (obj.ns.length) >= 1 ) {
+      const head = obj.ns[0];
+      if ( ctx.isDefinedClass(head) ) {
+        return head;
+      }
+    }
+    if ( (obj.children.length) == 1 ) {
+      const inner = obj.children[0];
+      const innerName = this.resolveCallReceiverClassName(inner, ctx);
+      if ( (innerName.length) > 0 ) {
+        return innerName;
+      }
+    }
+    return "";
+  };
+  isSimpleClassCallReceiver (obj, ctx) {
+    const className = this.resolveCallReceiverClassName(obj, ctx);
+    if ( (className.length) == 0 ) {
+      return false;
+    }
+    if ( obj.vref == className ) {
+      return true;
+    }
+    if ( (obj.children.length) == 1 ) {
+      const inner = obj.children[0];
+      if ( inner.vref == className ) {
+        return true;
+      }
+    }
+    return false;
+  };
   async CreateCallExpression (node, ctx, wr) {
     if ( node.has_call ) {
       const obj = node.getSecond();
       const method = node.getThird();
       const args = node.children[3];
-      wr.out("(", false);
+      const simpleReceiver = this.isSimpleClassCallReceiver(obj, ctx);
+      if ( simpleReceiver == false ) {
+        wr.out("(", false);
+      }
       ctx.setInExpr();
       await this.WalkNode(obj, ctx, wr);
       ctx.unsetInExpr();
-      wr.out(").", false);
+      if ( simpleReceiver == false ) {
+        wr.out(").", false);
+      } else {
+        wr.out(".", false);
+      }
       wr.out(method.vref, false);
       wr.out("(", false);
       ctx.setInExpr();
+      const fnDesc = this.resolveMethodFnDesc(node, ctx);
+      const hasFnDesc = (typeof(fnDesc) !== "undefined" && fnDesc != null ) ;
       for ( let i = 0; i < args.children.length; i++) {
         var arg = args.children[i];
         if ( i > 0 ) {
           wr.out(", ", false);
         }
-        if ( ctx.isDefinedClass(obj.eval_type_name) ) {
-          const clDef = ctx.findClass(obj.eval_type_name);
-          const clMethod = clDef.findMethod(method.vref);
-          if ( (typeof(clMethod) !== "undefined" && clMethod != null )  ) {
-            const mm = clMethod;
+        if ( hasFnDesc ) {
+          const mm = fnDesc;
+          if ( i < (mm.params.length) ) {
             const pDesc = mm.params[i];
             wr.out(pDesc.compiledName + " : ", false);
             if ( ((pDesc.nameNode)).hasFlag("mutates") ) {
@@ -15471,8 +16397,6 @@ class RangerSwift6ClassWriter  extends RangerGenericClassWriter {
             await this.WalkNode(arg, ctx, wr);
             continue;
           }
-        } else {
-          ctx.addError(arg, "Could not find evaluated class for the call");
         }
         await this.WalkNode(arg, ctx, wr);
       };
@@ -15596,7 +16520,10 @@ class RangerSwift6ClassWriter  extends RangerGenericClassWriter {
     if ( node.hasNewOper ) {
       const cl = node.clDesc;
       const givenArgs = node.getThird();
-      if ( cl.nameNode.hasFlag("singleton") ) {
+      if ( await this.tryWriteProcessNewCall(node, ctx, wr) ) {
+        return;
+      }
+      if ( cl.isSingletonClass() ) {
         wr.out(node.clDesc.name + ".__singleton", false);
         wr.out("(", false);
         if ( (typeof(cl.constructor_fn) !== "undefined" && cl.constructor_fn != null )  ) {
@@ -15849,7 +16776,7 @@ class RangerSwift6ClassWriter  extends RangerGenericClassWriter {
       wr.indent(-1);
       wr.out("}", true);
     };
-    if ( cl.nameNode.hasFlag("singleton") ) {
+    if ( cl.isSingletonClass() ) {
       wr.out(("private static var __singleton_instance : " + cl.compiledName) + "? = nil", true);
       wr.out("class func __singleton(", false);
       if ( cl.has_constructor ) {
@@ -15903,6 +16830,10 @@ class RangerSwift6ClassWriter  extends RangerGenericClassWriter {
         wr.newline();
         const subCtx_2 = variant_3.fnCtx;
         subCtx_2.is_function = true;
+        subCtx_2.in_method = true;
+        subCtx_2.in_static_method = false;
+        subCtx_2.currentMethod = variant_3;
+        subCtx_2.setCurrentClass(cl);
         await this.WalkNode(variant_3.fnBody, subCtx_2, wr);
         wr.newline();
         wr.indent(-1);
@@ -15924,6 +16855,9 @@ class RangerSwift6ClassWriter  extends RangerGenericClassWriter {
         theEnd.indent(1);
         const subCtx_3 = variant_4.fnCtx;
         subCtx_3.is_function = true;
+        subCtx_3.in_method = false;
+        subCtx_3.in_static_method = true;
+        subCtx_3.currentMethod = variant_4;
         await this.WalkNode(variant_4.fnBody, subCtx_3, theEnd);
         theEnd.newline();
         theEnd.indent(-1);
@@ -15933,6 +16867,85 @@ class RangerSwift6ClassWriter  extends RangerGenericClassWriter {
       }
     };
   };
+  resolveMethodFnDesc (methodNode, ctx) {
+    let res;
+    if ( methodNode.hasParamDesc ) {
+      const raw = (methodNode.paramDesc);
+      if ( (raw.params.length) > 0 ) {
+        res = raw;
+        return res;
+      }
+    }
+    if ( (methodNode.ns.length) >= 2 ) {
+      const className = methodNode.ns[0];
+      if ( ctx.isDefinedClass(className) ) {
+        const clDef = ctx.findClass(className);
+        const methodName = methodNode.ns[1];
+        let found = clDef.findStaticMethod(methodName);
+        if ( typeof(found) === "undefined" ) {
+          found = clDef.findMethod(methodName);
+        }
+        if ( (typeof(found) !== "undefined" && found != null )  ) {
+          res = found;
+          return res;
+        }
+      }
+    }
+    if ( methodNode.has_call ) {
+      const obj = methodNode.getSecond();
+      const method = methodNode.getThird();
+      const className_1 = this.resolveCallReceiverClassName(obj, ctx);
+      if ( (className_1.length) > 0 ) {
+        const clDef_1 = ctx.findClass(className_1);
+        let found_1 = clDef_1.findStaticMethod(method.vref);
+        if ( typeof(found_1) === "undefined" ) {
+          found_1 = clDef_1.findMethod(method.vref);
+        }
+        if ( (typeof(found_1) !== "undefined" && found_1 != null )  ) {
+          res = found_1;
+          return res;
+        }
+      }
+    }
+    return res;
+  };
+  async CreateMethodCall (node, ctx, wr) {
+    const methodNode = node.getFirst();
+    const args = node.getSecond();
+    ctx.setInExpr();
+    await this.WalkNode(methodNode, ctx, wr);
+    ctx.unsetInExpr();
+    wr.out("(", false);
+    ctx.setInExpr();
+    let hasFnDesc = false;
+    let fnDesc;
+    const resolved = this.resolveMethodFnDesc(methodNode, ctx);
+    if ( (typeof(resolved) !== "undefined" && resolved != null )  ) {
+      fnDesc = resolved;
+      hasFnDesc = true;
+    }
+    const pms = operatorsOf.filter_36(args.children, ((item, index) => { 
+      if ( item.hasFlag("keyword") ) {
+        return false;
+      }
+      return true;
+    }));
+    for ( let i = 0; i < pms.length; i++) {
+      var arg = pms[i];
+      if ( i > 0 ) {
+        wr.out(", ", false);
+      }
+      if ( hasFnDesc ) {
+        if ( i < (fnDesc.params.length) ) {
+          const pArg = fnDesc.params[i];
+          wr.out(pArg.compiledName + " : ", false);
+        }
+      }
+      await this.WalkNode(arg, ctx, wr);
+    };
+    ctx.unsetInExpr();
+    wr.out(")", false);
+  };
 }
 class RangerCppClassWriter  extends RangerGenericClassWriter {
   constructor() {
@@ -20141,6 +21154,13 @@ class RangerKotlinClassWriter  extends RangerGenericClassWriter {
       const nn = node.children[1];
       const p = nn.paramDesc;
       if ( (p.ref_cnt == 0) && (p.is_class_variable == false) ) {
+        if ( (node.children.length) > 2 ) {
+          const value = node.getThird();
+          if ( this.defValueHasSideEffects(value) ) {
+            await this.writeSideEffectOnlyStmt(value, ctx, wr);
+            return;
+          }
+        }
         wr.out("/** unused:  ", false);
       }
       if ( p.is_class_variable ) {
@@ -20158,8 +21178,8 @@ class RangerKotlinClassWriter  extends RangerGenericClassWriter {
       if ( (node.children.length) > 2 ) {
         wr.out(" = ", false);
         ctx.setInExpr();
-        const value = node.getThird();
-        await this.WalkNode(value, ctx, wr);
+        const value_1 = node.getThird();
+        await this.WalkNode(value_1, ctx, wr);
         ctx.unsetInExpr();
       } else {
         if ( nn.hasFlag("optional") ) {
@@ -20197,6 +21217,7 @@ class RangerKotlinClassWriter  extends RangerGenericClassWriter {
   };
   async writeFnCall (node, ctx, wr) {
     if ( node.hasFnCall ) {
+      ctx.setInExpr();
       const fc = node.getFirst();
       await this.WriteVRef(fc, ctx, wr);
       wr.out("(", false);
@@ -20220,6 +21241,7 @@ class RangerKotlinClassWriter  extends RangerGenericClassWriter {
         await this.WalkNode(n, ctx, wr);
       };
       wr.out(")", false);
+      ctx.unsetInExpr();
       if ( ctx.expressionLevel() == 0 ) {
         wr.out(";", true);
       }
@@ -20229,7 +21251,10 @@ class RangerKotlinClassWriter  extends RangerGenericClassWriter {
     if ( node.hasNewOper ) {
       const cl = node.clDesc;
       const givenArgs = node.getThird();
-      if ( cl.nameNode.hasFlag("singleton") ) {
+      if ( await this.tryWriteProcessNewCall(node, ctx, wr) ) {
+        return;
+      }
+      if ( cl.isSingletonClass() ) {
         wr.out(" ", false);
         wr.out(node.clDesc.name + ".__singleton", false);
         wr.out("(", false);
@@ -20272,7 +21297,7 @@ class RangerKotlinClassWriter  extends RangerGenericClassWriter {
     const wr = orig_wr;
     const importFork = wr.fork();
     wr.out("", true);
-    if ( cl.is_extended_by_children ) {
+    if ( cl.is_extended_by_children || (cl.name == "RangerProcessBase") ) {
       wr.out("open class " + cl.name, false);
     } else {
       wr.out("class " + cl.name, false);
@@ -20328,6 +21353,8 @@ class RangerKotlinClassWriter  extends RangerGenericClassWriter {
             };
           }
           wr.out(")", false);
+        } else {
+          wr.out("()", false);
         }
       };
     }
@@ -20345,7 +21372,7 @@ class RangerKotlinClassWriter  extends RangerGenericClassWriter {
     if ( ((cl.static_methods.length) > 0) || has_static_vars ) {
       wants_companion = true;
     }
-    if ( cl.nameNode.hasFlag("singleton") ) {
+    if ( cl.isSingletonClass() ) {
       wants_companion = true;
     }
     for ( let i_2 = 0; i_2 < cl.variables.length; i_2++) {
@@ -20379,7 +21406,7 @@ class RangerKotlinClassWriter  extends RangerGenericClassWriter {
       }
       await this.writeVarDef(pvar_2.node, ctx, wr);
     };
-    if ( cl.nameNode.hasFlag("singleton") ) {
+    if ( cl.isSingletonClass() ) {
       wr.out(("private var __singleton_instance : " + cl.compiledName) + "? = null", true);
       wr.out("fun __singleton(", false);
       if ( cl.has_constructor ) {
@@ -20431,6 +21458,10 @@ class RangerKotlinClassWriter  extends RangerGenericClassWriter {
       wr.newline();
       const subCtx_1 = variant_1.fnCtx;
       subCtx_1.is_function = true;
+      subCtx_1.in_method = true;
+      subCtx_1.in_static_method = false;
+      subCtx_1.currentMethod = variant_1;
+      subCtx_1.setCurrentClass(cl);
       await this.WalkNode(variant_1.fnBody, subCtx_1, wr);
       wr.newline();
       wr.indent(-1);
@@ -20474,6 +21505,10 @@ class RangerKotlinClassWriter  extends RangerGenericClassWriter {
         wr.newline();
         const subCtx_2 = variant_2.fnCtx;
         subCtx_2.is_function = true;
+        subCtx_2.in_method = true;
+        subCtx_2.in_static_method = false;
+        subCtx_2.currentMethod = variant_2;
+        subCtx_2.setCurrentClass(cl);
         await this.WalkNode(variant_2.fnBody, subCtx_2, wr);
         wr.newline();
         wr.indent(-1);
@@ -20491,6 +21526,9 @@ class RangerKotlinClassWriter  extends RangerGenericClassWriter {
         wr.newline();
         const subCtx_3 = variant_3.fnCtx;
         subCtx_3.is_function = true;
+        subCtx_3.in_method = false;
+        subCtx_3.in_static_method = true;
+        subCtx_3.currentMethod = variant_3;
         await this.WalkNode(variant_3.fnBody, subCtx_3, wr);
         wr.newline();
         wr.indent(-1);
@@ -24892,6 +25930,22 @@ class RangerJavaScriptClassWriter  extends RangerGenericClassWriter {
   lineEnding () {
     return ";";
   };
+  writeTsOptionalReturnSuffix (variant, wr) {
+    if ( this.target_typescript == false ) {
+      return;
+    }
+    if ( variant.nameNode.hasFlag("optional") ) {
+      wr.out(" | undefined", false);
+      return;
+    }
+    const rv = variant.return_value;
+    if ( typeof(rv) === "undefined" ) {
+      return;
+    }
+    if ( rv.is_optional ) {
+      wr.out(" | undefined", false);
+    }
+  };
   adjustType (tn) {
     if ( tn == "this" ) {
       return "this";
@@ -25479,6 +26533,14 @@ class RangerJavaScriptClassWriter  extends RangerGenericClassWriter {
   };
   async writeClassVarDef (p, ctx, wr) {
     if ( this.target_typescript ) {
+      const cl = ctx.currentClass;
+      let is_singleton = false;
+      if ( (typeof(cl) === "undefined") == false ) {
+        const clDesc = cl;
+        if ( clDesc.isSingletonClass() ) {
+          is_singleton = true;
+        }
+      }
       const pNode = p.node;
       let has_ctor_init = false;
       if ( (pNode.children.length) > 2 ) {
@@ -25493,11 +26555,17 @@ class RangerJavaScriptClassWriter  extends RangerGenericClassWriter {
         wr.out("static ", false);
       }
       wr.out(p.compiledName, false);
-      if ( (p.is_static == false) && p.is_optional ) {
-        if ( has_ctor_init ) {
-          wr.out("!", false);
+      if ( p.is_static == false ) {
+        if ( p.is_optional ) {
+          if ( has_ctor_init ) {
+            wr.out("!", false);
+          } else {
+            wr.out("?", false);
+          }
         } else {
-          wr.out("?", false);
+          if ( is_singleton || has_ctor_init ) {
+            wr.out("!", false);
+          }
         }
       }
       wr.out(": ", false);
@@ -25516,7 +26584,10 @@ class RangerJavaScriptClassWriter  extends RangerGenericClassWriter {
     if ( node.hasNewOper ) {
       const cl = node.clDesc;
       const givenArgs = node.getThird();
-      if ( cl.nameNode.hasFlag("singleton") ) {
+      if ( await this.tryWriteProcessNewCall(node, ctx, wr) ) {
+        return;
+      }
+      if ( cl.isSingletonClass() ) {
         wr.out(node.clDesc.name + ".__singleton", false);
         wr.out("(", false);
         for ( let i = 0; i < givenArgs.children.length; i++) {
@@ -25739,6 +26810,13 @@ class RangerJavaScriptClassWriter  extends RangerGenericClassWriter {
       }
       wr.out(") {", true);
       wr.indent(1);
+      if ( cl.isSingletonClass() ) {
+        wr.out(("if (" + cl.name) + ".__singleton_instance != null) {", true);
+        wr.indent(1);
+        wr.out(("return " + cl.name) + ".__singleton_instance;", true);
+        wr.indent(-1);
+        wr.out("}", true);
+      }
       if ( b_extd ) {
         if ( (typeof(parentClass) !== "undefined" && parentClass != null )  ) {
           const pc = parentClass;
@@ -25800,6 +26878,9 @@ class RangerJavaScriptClassWriter  extends RangerGenericClassWriter {
         subCtx.is_function = true;
         await this.WalkNode(constr_1.fnBody, subCtx, wr);
       }
+      if ( cl.isSingletonClass() ) {
+        wr.out(cl.name + ".__singleton_instance = this;", true);
+      }
       wr.newline();
       wr.indent(-1);
       wr.out("}", true);
@@ -25824,6 +26905,7 @@ class RangerJavaScriptClassWriter  extends RangerGenericClassWriter {
           if ( variant.nameNode.hasFlag("async") ) {
             wr.out(">", false);
           }
+          this.writeTsOptionalReturnSuffix(variant, wr);
           wr.out(" ", false);
         }
         wr.out(" {", true);
@@ -25871,6 +26953,7 @@ class RangerJavaScriptClassWriter  extends RangerGenericClassWriter {
         if ( variant_1.nameNode.hasFlag("async") ) {
           wr.out("> ", false);
         }
+        this.writeTsOptionalReturnSuffix(variant_1, wr);
         wr.out(" ", false);
         wr.out(" {", true);
         wr.indent(1);
@@ -25882,7 +26965,7 @@ class RangerJavaScriptClassWriter  extends RangerGenericClassWriter {
         wr.indent(-1);
         wr.out("};", true);
       };
-      if ( cl.nameNode.hasFlag("singleton") ) {
+      if ( cl.isSingletonClass() ) {
         wr.out(("static __singleton_instance : " + cl.name) + " | null = null;", true);
         wr.out("static __singleton(", false);
         if ( cl.has_constructor ) {
@@ -25946,7 +27029,7 @@ class RangerJavaScriptClassWriter  extends RangerGenericClassWriter {
         }
         wr.out(";", true);
       };
-      if ( cl.nameNode.hasFlag("singleton") ) {
+      if ( cl.isSingletonClass() ) {
         wr.out((cl.name + ".__singleton_instance") + " = null;", true);
         wr.out((cl.name + ".__singleton") + " = function(", false);
         if ( cl.has_constructor ) {
@@ -27613,7 +28696,7 @@ class CLIProgress  {
     this.inputFile = "";
     this.outputFile = "";
     this.targetLanguage = "";
-    this.compilerVersion = "3.0.4";
+    this.compilerVersion = "3.0.5";
     this.useColors = (process.stdout.isTTY || false);
     this.startTime = Date.now();
   }
@@ -29965,6 +31048,15 @@ class StaticAnalyzer  {
                 const contentFork = wr.fork();
                 wr.createTag("utilities");
                 const theEnd = wr.createTag("file_end");
+                if ( appCtx.hasCompilerFlag("typescript") ) {
+                  if ( ( typeof(appCtx.compilerSettings["processTsHelpers"] ) != "undefined" && appCtx.compilerSettings.hasOwnProperty("processTsHelpers") ) ) {
+                    const __rgrTs = (( appCtx.compilerSettings.hasOwnProperty("processTsHelpers") ? appCtx.compilerSettings["processTsHelpers"] : undefined ));
+                    if ( (__rgrTs.length) > 0 ) {
+                      theEnd.raw(__rgrTs, false);
+                      theEnd.newline();
+                    }
+                  }
+                }
                 wr = contentFork;
                 let handledClasses = {};
                 for ( let i_4 = 0; i_4 < appCtx.definedClassList.length; i_4++) {