ranger-compiler 3.2.0 → 3.5.0

package/dist/api.d.ts

@@ -1,4 +1,3 @@
-type union_Any = CmdParams | test_cmdparams | InputFSFolder | InputFSFile | InputEnv | test_input_filesystem | RangerAppTodo | RangerCompilerMessage | RangerParamEventHandler | RangerParamEventList | RangerParamEventMap | RangerAppArrayValue | RangerAppHashValue | RangerAppValue | RangerRefForce | RangerAppParamDesc | RangerAppFunctionDesc | RangerAppMethodVariants | RangerAppInterfaceImpl | RangerTraitParams | RangerAppClassDesc | RangerTypeClass | SourceCode | CodeNodeLiteral | CodeNode | TTypeRegistry | TypeCounts | RangerNodeValue | RangerBackReference | RangerAppEnum | OpFindResult | RangerOperatorList | RangerNodeList | ContextTransaction | ContextTransactionMutation | RangerRegisteredPlugin | RangerAppWriterContext | SourceMapEntry | SourceMapBuilder | CodeFile | CodeFileSystem | CodeSlice | CodeWriter | RangerLispParser | TTypes | RangerArgMatch | DictNode | RangerSerializeClass | RangerImmutableExtension | RangerProcessLifecycle | RangerProcessClass | RangerProcessProcSend | RangerProcessProcStartCheck | RangerProcessCodegen | RangerServiceBuilder | RangerAppOperatorDesc | TFiles | ClassJoinPoint | WalkLater | RangerFlowParser | TFactory | CallChain | NodeEvalState | RangerGenericClassWriter | AndroidPageWriter | RangerJava7ClassWriter | RangerSwift3ClassWriter | RangerSwift6ClassWriter | RangerCppClassWriter | MethodCallList | RangerRustClassWriter | RangerKotlinClassWriter | RangerCSharpClassWriter | RangerScalaClassWriter | RangerGolangClassWriter | RangerGolangHttpServerWriter | RangerPHPClassWriter | RangerPythonClassWriter | WebPageWriter | RangerJavaScriptClassWriter | RangerRangerClassWriter | LowIRUtil | LowIRParam | LowIRInstr | LowIRBlock | LowIRFunction | LowIRField | LowIRTypeFieldDesc | LowIRTypeDesc | LowIRStruct | LowIRStringGlobal | LowIRExternDecl | LowIRModule | LowIRSession | LowIRBuilder | LowIRRuntimeGen | LowIRTarget | LowIRLowerContext | LambdaCaptureInfo | LowIRBuilderPass | LLVMIRWriter | WATWriter | RangerLLVMPipeline | RangerLLVMClassWriter | OpList | RangerActiveOperators | LiveCompiler | ColorConsole | CLIProgress | RangerDocGenerator | StaticAnalyzer | viewbuilder_Android | viewbuilder_Web | CompilerResults | VirtualCompiler | CompilerInterface | number | string | boolean | number;
 export declare class CmdParams {
     flags: {
         [key: string]: boolean;
@@ -12,7 +11,7 @@ export declare class CmdParams {
     getParam(name: string): string | undefined;
     collect(): void;
     toDictionary(): Record<string, any>;
-    static fromDictionary(dict: Record<string, any>): Promise<CmdParams>;
+    static fromDictionary(dict: Record<string, any>): CmdParams;
 }
 export declare class test_cmdparams {
     constructor();
@@ -28,7 +27,7 @@ export declare class InputFSFolder {
     constructor();
     forTree(cb: (item: InputFSFolder) => void): void;
     toDictionary(): Record<string, any>;
-    static fromDictionary(dict: Record<string, any>): Promise<InputFSFolder>;
+    static fromDictionary(dict: Record<string, any>): InputFSFolder;
 }
 export declare class InputFSFile {
     name: string;
@@ -39,6 +38,23 @@ export declare class InputFSFile {
     toDictionary(): Record<string, any>;
     static fromDictionary(dict: Record<string, any>): InputFSFile;
 }
+export declare class InputFileResolver {
+    files: {
+        [key: string]: string;
+    };
+    hostDirs: Array<string>;
+    constructor();
+    putFile(name: string, data: string): void;
+    addHostDir(dir: string): void;
+    knownName(name: string): boolean;
+    baseName(path: string): string;
+    exists(path: string, name: string): boolean;
+    tryRead(path: string, name: string): Promise<string> | undefined;
+    hostHas(name: string): boolean;
+    hostRead(name: string): Promise<string> | undefined;
+    toDictionary(): Record<string, any>;
+    static fromDictionary(dict: Record<string, any>): InputFileResolver;
+}
 export declare class InputEnv {
     use_real: boolean;
     filesystem?: InputFSFolder;
@@ -46,10 +62,12 @@ export declare class InputEnv {
         [key: string]: string;
     };
     commandLine?: CmdParams;
+    resolver?: InputFileResolver;
     constructor();
     setEnv(name: string, value: string): void;
+    setResolver(r: InputFileResolver): void;
     toDictionary(): Record<string, any>;
-    static fromDictionary(dict: Record<string, any>): Promise<InputEnv>;
+    static fromDictionary(dict: Record<string, any>): InputEnv;
 }
 export declare class test_input_filesystem {
     constructor();
@@ -67,6 +85,218 @@ export declare class RangerCompilerMessage {
     node?: CodeNode;
     constructor();
 }
+export declare class RangerDocParam {
+    name: string;
+    text: string;
+    node?: CodeNode;
+    constructor();
+}
+export declare class RangerDocDeprecation {
+    since: string;
+    use: string;
+    description: string;
+    constructor();
+}
+export declare class RangerDocBlock {
+    is_public: boolean;
+    is_internal: boolean;
+    is_experimental: boolean;
+    description: string;
+    params: Array<RangerDocParam>;
+    returns: string;
+    throws: Array<string>;
+    since: string;
+    is_deprecated: boolean;
+    deprecation?: RangerDocDeprecation;
+    see: Array<string>;
+    examples: Array<string>;
+    exampleRefs: Array<string>;
+    category: string;
+    platform: string;
+    attrs: Array<string>;
+    targets: {
+        [key: string]: RangerDocBlock;
+    };
+    targetNames: Array<string>;
+    node?: CodeNode;
+    constructor();
+    hasParamDoc(n: string): boolean;
+    paramText(n: string): string;
+    hasTargetView(name: string): boolean;
+    viewFor(name: string): RangerDocBlock;
+}
+export declare class RangerDocReader {
+    constructor();
+    wordAt(node: CodeNode, idx: number): string;
+    textFrom(node: CodeNode, startIndex: number): string;
+    blockArgOf(node: CodeNode): CodeNode;
+    hasBlockArg(node: CodeNode): boolean;
+    readDeprecation(blockNode: CodeNode, ctx: RangerAppWriterContext): RangerDocDeprecation;
+    fill(doc: RangerDocBlock, blockNode: CodeNode, ctx: RangerAppWriterContext, allowTargets: boolean): void;
+    read(blockNode: CodeNode, ctx: RangerAppWriterContext): RangerDocBlock;
+}
+export declare class RangerApiParam {
+    name: string;
+    compiledName: string;
+    typeName: string;
+    description: string;
+    constructor();
+}
+export declare class RangerApiMethod {
+    name: string;
+    compiledName: string;
+    is_static: boolean;
+    is_constructor: boolean;
+    is_public: boolean;
+    returnType: string;
+    returnDoc: string;
+    params: Array<RangerApiParam>;
+    doc?: RangerDocBlock;
+    has_doc: boolean;
+    node?: CodeNode;
+    constructor();
+}
+export declare class RangerApiField {
+    name: string;
+    compiledName: string;
+    typeName: string;
+    is_public: boolean;
+    is_static: boolean;
+    doc?: RangerDocBlock;
+    has_doc: boolean;
+    constructor();
+}
+export declare class RangerApiClass {
+    name: string;
+    compiledName: string;
+    kind: string;
+    is_public: boolean;
+    extendsName: string;
+    fields: Array<RangerApiField>;
+    methods: Array<RangerApiMethod>;
+    doc?: RangerDocBlock;
+    has_doc: boolean;
+    node?: CodeNode;
+    constructor();
+    hasPublicMember(): boolean;
+}
+export declare class RangerApiModel {
+    moduleName: string;
+    version: string;
+    description: string;
+    classes: Array<RangerApiClass>;
+    warnings: Array<string>;
+    constructor();
+    publicClassCount(): number;
+}
+export declare class RangerApiBuilder {
+    strict: boolean;
+    publicClassNames: {
+        [key: string]: boolean;
+    };
+    internalClassNames: {
+        [key: string]: boolean;
+    };
+    exampleFns: Array<RangerAppFunctionDesc>;
+    constructor();
+    typeNameOf(node: CodeNode): string;
+    readDocOf(node: CodeNode, ctx: RangerAppWriterContext): RangerDocBlock;
+    warn(model: RangerApiModel, ctx: RangerAppWriterContext, node: CodeNode, msg: string): void;
+    validateMethod(model: RangerApiModel, m: RangerApiMethod, ctx: RangerAppWriterContext): void;
+    typeNamesOf(node: CodeNode): Array<string>;
+    checkNoLeak(ctx: RangerAppWriterContext, node: CodeNode, what: string, role: string, typeNode: CodeNode): void;
+    buildMethod(fd: RangerAppFunctionDesc, ctx: RangerAppWriterContext, isStatic: boolean): RangerApiMethod;
+    checkMethodLeaks(m: RangerApiMethod, fd: RangerAppFunctionDesc, ctx: RangerAppWriterContext): void;
+    build(ctx: RangerAppWriterContext): RangerApiModel;
+    findExampleFn(ctx: RangerAppWriterContext, name: string): RangerAppFunctionDesc;
+    markExamplesOf(doc: RangerDocBlock, owner: CodeNode, ctx: RangerAppWriterContext): void;
+    resolveExamples(model: RangerApiModel, ctx: RangerAppWriterContext): void;
+}
+export declare class RangerDocCommentWriter {
+    exampleTexts: Array<string>;
+    constructor();
+    clearExamples(): void;
+    loadExamples(doc: RangerDocBlock, ctx: RangerAppWriterContext): void;
+    allExamples(doc: RangerDocBlock): Array<string>;
+    jsTypeName(t: string): string;
+    jsTypeOf(node: CodeNode): string;
+    csTypeName(t: string): string;
+    xmlEscape(value: string): string;
+    linesOf(text: string): Array<string>;
+    writeJsDoc(doc: RangerDocBlock, retType: string, params: Array<RangerApiParam>, wr: CodeWriter): void;
+    writeJsDocTyped(doc: RangerDocBlock, retType: string, params: Array<RangerApiParam>, valueType: string, wr: CodeWriter): void;
+    writeXmlLines(tag: string, attrs: string, text: string, wr: CodeWriter): void;
+    writeCsDoc(doc: RangerDocBlock, retType: string, params: Array<RangerApiParam>, wr: CodeWriter): void;
+    writeCsAttrs(doc: RangerDocBlock, wr: CodeWriter): void;
+    swiftTypeName(t: string): string;
+    writeSwiftDoc(doc: RangerDocBlock, retType: string, params: Array<RangerApiParam>, wr: CodeWriter): void;
+    writeSwiftAttrs(doc: RangerDocBlock, wr: CodeWriter): void;
+    kotlinTypeName(t: string): string;
+    writeKotlinDoc(doc: RangerDocBlock, retType: string, params: Array<RangerApiParam>, wr: CodeWriter): void;
+    writeKotlinAttrs(doc: RangerDocBlock, replaceWith: string, wr: CodeWriter): void;
+    pyTypeName(t: string): string;
+    pyTypeOf(node: CodeNode): string;
+    writePyDoc(doc: RangerDocBlock, retType: string, params: Array<RangerApiParam>, wr: CodeWriter): void;
+    dartTypeName(t: string): string;
+    writeDartDoc(doc: RangerDocBlock, retType: string, params: Array<RangerApiParam>, wr: CodeWriter): void;
+    writeDartAttrs(doc: RangerDocBlock, wr: CodeWriter): void;
+    paramsOf(fd: RangerAppFunctionDesc, doc: RangerDocBlock, forJs: boolean): Array<RangerApiParam>;
+    writeJsDocForMethod(fd: RangerAppFunctionDesc, ctx: RangerAppWriterContext, wr: CodeWriter): void;
+    writeCsDocForMethod(fd: RangerAppFunctionDesc, ctx: RangerAppWriterContext, wr: CodeWriter): void;
+    writeJsDocForClass(cl: RangerAppClassDesc, ctx: RangerAppWriterContext, wr: CodeWriter): void;
+    writeCsDocForClass(cl: RangerAppClassDesc, ctx: RangerAppWriterContext, wr: CodeWriter): void;
+    writeSwiftDocForMethod(fd: RangerAppFunctionDesc, ctx: RangerAppWriterContext, wr: CodeWriter): void;
+    writeSwiftDocForClass(cl: RangerAppClassDesc, ctx: RangerAppWriterContext, wr: CodeWriter): void;
+    writeSwiftDocForField(p: RangerAppParamDesc, wr: CodeWriter): void;
+    kotlinReplaceWith(cl: RangerAppClassDesc, doc: RangerDocBlock): string;
+    writeKotlinDocForMethod(cl: RangerAppClassDesc, fd: RangerAppFunctionDesc, ctx: RangerAppWriterContext, wr: CodeWriter): void;
+    writeKotlinDocForClass(cl: RangerAppClassDesc, ctx: RangerAppWriterContext, wr: CodeWriter): void;
+    writeKotlinDocForField(p: RangerAppParamDesc, wr: CodeWriter): void;
+    writePyDocForMethod(fd: RangerAppFunctionDesc, ctx: RangerAppWriterContext, wr: CodeWriter): void;
+    writePyDocForClass(cl: RangerAppClassDesc, ctx: RangerAppWriterContext, wr: CodeWriter): void;
+    writeDartDocForMethod(fd: RangerAppFunctionDesc, ctx: RangerAppWriterContext, wr: CodeWriter): void;
+    writeDartDocForClass(cl: RangerAppClassDesc, ctx: RangerAppWriterContext, wr: CodeWriter): void;
+    writeDartDocForField(p: RangerAppParamDesc, wr: CodeWriter): void;
+    memberVisibility(cl: RangerAppClassDesc, member: RangerAppParamDesc, whenLegacy: string, whenPublic: string, whenInternal: string): string;
+    classVisibility(cl: RangerAppClassDesc, whenLegacy: string, whenPublic: string, whenInternal: string): string;
+    writeJsDocForField(p: RangerAppParamDesc, wr: CodeWriter): void;
+    writeCsDocForField(p: RangerAppParamDesc, wr: CodeWriter): void;
+    static lookupFn(ctx: RangerAppWriterContext, name: string): RangerAppFunctionDesc;
+}
+export declare class RangerApiArtifactWriter {
+    constructor();
+    jsonEscape(value: string): string;
+    jsonString(value: string): string;
+    jsonBool(value: boolean): string;
+    jsonStringList(items: Array<string>): string;
+    docFields(doc: RangerDocBlock, has: boolean): string;
+    writeJson(model: RangerApiModel, ctx: RangerAppWriterContext, wr: CodeWriter): void;
+    writeMarkdown(model: RangerApiModel, ctx: RangerAppWriterContext, wr: CodeWriter): void;
+    writeReport(model: RangerApiModel, wr: CodeWriter): void;
+    writeAll(model: RangerApiModel, ctx: RangerAppWriterContext, orig_wr: CodeWriter): void;
+}
+export declare class RangerApiPackageWriter {
+    constructor();
+    settingOr(ctx: RangerAppWriterContext, key: string, fallback: string): string;
+    jsonEscape(value: string): string;
+    writeNpmPackage(model: RangerApiModel, ctx: RangerAppWriterContext, orig_wr: CodeWriter): void;
+    xmlEscape(value: string): string;
+    writeCsProject(model: RangerApiModel, ctx: RangerAppWriterContext, orig_wr: CodeWriter): void;
+    writeDocFxConfig(model: RangerApiModel, ctx: RangerAppWriterContext, orig_wr: CodeWriter): void;
+    writeDocFxHome(model: RangerApiModel, ctx: RangerAppWriterContext, name: string, orig_wr: CodeWriter): void;
+    swiftModuleName(raw: string): string;
+    writeSwiftPackage(model: RangerApiModel, ctx: RangerAppWriterContext, orig_wr: CodeWriter): void;
+    writeDocCCatalog(model: RangerApiModel, ctx: RangerAppWriterContext, orig_wr: CodeWriter): void;
+    writeKotlinGradle(model: RangerApiModel, ctx: RangerAppWriterContext, orig_wr: CodeWriter): void;
+    writeDokkaModuleDoc(model: RangerApiModel, ctx: RangerAppWriterContext, orig_wr: CodeWriter): void;
+    writeDartBarrel(model: RangerApiModel, ctx: RangerAppWriterContext, orig_wr: CodeWriter, node: CodeNode): void;
+    pyModuleName(raw: string): string;
+    writePyProject(model: RangerApiModel, ctx: RangerAppWriterContext, orig_wr: CodeWriter): void;
+    writePyAll(model: RangerApiModel, ctx: RangerAppWriterContext, orig_wr: CodeWriter): void;
+    writeReadme(model: RangerApiModel, ctx: RangerAppWriterContext, orig_wr: CodeWriter): void;
+    writeDartPubspec(model: RangerApiModel, ctx: RangerAppWriterContext, orig_wr: CodeWriter): void;
+    writeAll(model: RangerApiModel, ctx: RangerAppWriterContext, orig_wr: CodeWriter, node: CodeNode): void;
+}
 export declare class RangerParamEventHandler {
     constructor();
     callback(param: RangerAppParamDesc): void;
@@ -130,6 +360,7 @@ export declare class RangerAppParamDesc {
     debugString: string;
     is_register: boolean;
     ref_cnt: number;
+    read_cnt: number;
     init_cnt: number;
     set_cnt: number;
     return_cnt: number;
@@ -162,14 +393,19 @@ export declare class RangerAppParamDesc {
     escapes_function: boolean;
     needs_cpp_reference: boolean;
     rust_borrow_type: number;
+    needs_swift_inout: boolean;
+    rust_static_str: boolean;
+    rust_interior_cell: boolean;
     rust_assigned_to_weak: boolean;
     rust_needs_rc_wrap: boolean;
     rust_assigned_to_field: boolean;
+    sharing_mutates: boolean;
     ownership_kind: number;
     ownership_resolved: boolean;
     escapes_via: string;
     escape_owners: Array<string>;
     escape_via_call: boolean;
+    escape_return_only: boolean;
     ownership_read_only: boolean;
     node?: CodeNode;
     nameNode?: CodeNode;
@@ -178,10 +414,15 @@ export declare class RangerAppParamDesc {
     return_value?: RangerAppParamDesc;
     description: string;
     git_doc: string;
+    has_doc: boolean;
+    docBlock?: RangerDocBlock;
+    is_doc_example: boolean;
+    docExampleText: string;
     has_events: boolean;
     eMap?: RangerParamEventMap;
     constructor();
     addEvent(name: string, e: RangerParamEventHandler): void;
+    changeStrengthSelf(newStrength: number, lifeTime: number): void;
     changeStrength(newStrength: number, lifeTime: number, changer: CodeNode): void;
     isFunction(): boolean;
     isProperty(): boolean;
@@ -231,6 +472,8 @@ export declare class RangerAppFunctionDesc extends RangerAppParamDesc {
     all_paths_return: boolean;
     mutates_self: boolean;
     static_analysis_done: boolean;
+    rust_needs_self_rc: boolean;
+    rust_mut_self: boolean;
     rust_uses_self: boolean;
     rust_passes_self_to_weak: boolean;
     rust_can_be_static: boolean;
@@ -241,13 +484,34 @@ export declare class RangerAppFunctionDesc extends RangerAppParamDesc {
     mutates_param_indices: Array<number>;
     constructor();
     addCallTo(m: RangerAppFunctionDesc): void;
-    addIndirectClassUsage(m: RangerAppClassDesc, ctx: RangerAppWriterContext): void;
-    addClassUsage(m: RangerAppClassDesc, ctx: RangerAppWriterContext): void;
+    addIndirectClassUsage(m: RangerAppClassDesc, ctx: RangerAppWriterContext): Promise<void>;
+    addClassUsage(m: RangerAppClassDesc, ctx: RangerAppWriterContext): Promise<void>;
     forOtherVersions(ctx: RangerAppWriterContext, cb: (item: RangerAppFunctionDesc) => void): Promise<void>;
     isFunction(): boolean;
     isClass(): boolean;
     isProperty(): boolean;
 }
+export declare class ShapeViewDesc {
+    shapeName: string;
+    viewKind: string;
+    viewName: string;
+    className: string;
+    allowedCases: Array<string>;
+    parentView: string;
+    methodNames: Array<string>;
+    requiredMethods: Array<string>;
+    constructor();
+}
+export declare class ShapeGroupMethodSlot {
+    declaringGroup: string;
+    methodName: string;
+    isRequired: boolean;
+    hasDefault: boolean;
+    defaultNode?: CodeNode;
+    implCaseNames: Array<string>;
+    implNodes: Array<CodeNode>;
+    constructor();
+}
 export declare class RangerAppMethodVariants {
     name: string;
     variants: Array<RangerAppFunctionDesc>;
@@ -326,10 +590,17 @@ export declare class RangerAppClassDesc extends RangerAppParamDesc {
     is_inherited: boolean;
     is_extended_by_children: boolean;
     child_classes: Array<string>;
+    rust_trait_mut: {
+        [key: string]: boolean;
+    };
+    rust_trait_mut_ready: boolean;
+    rust_needs_ref_semantics: boolean;
+    rust_ref_reason: string;
     constructor();
     isClass(): boolean;
     isProperty(): boolean;
     doesInherit(): boolean;
+    isDocExampleOnly(): boolean;
     isNormalClass(): boolean;
     getSystemclassType(): string;
     isSystemclassType(typeName: string): boolean;
@@ -362,7 +633,7 @@ export declare class RangerTypeClass {
     implements_interfaces: Array<RangerTypeClass>;
     extends_classes: Array<RangerTypeClass>;
     belongs_to_union: Array<RangerTypeClass>;
-    description?: union_Any;
+    description?: any;
     is_empty: boolean;
     is_primitive: boolean;
     is_mutable: boolean;
@@ -416,7 +687,7 @@ export declare class CodeNodeLiteral {
     attrs: Array<CodeNodeLiteral>;
     constructor();
     toDictionary(): Record<string, any>;
-    static fromDictionary(dict: Record<string, any>): Promise<CodeNodeLiteral>;
+    static fromDictionary(dict: Record<string, any>): CodeNodeLiteral;
 }
 export declare class CodeNode {
     code?: SourceCode;
@@ -441,9 +712,11 @@ export declare class CodeNode {
     has_lambda: boolean;
     has_lambda_call: boolean;
     has_call: boolean;
+    is_call_args: boolean;
     rust_needs_preevaluate: boolean;
     rust_preevaluated_args: Array<CodeNode>;
     rust_use_tmpvar: string;
+    rust_is_tail_return: boolean;
     operator_pred: number;
     to_the_right: boolean;
     right_node?: CodeNode;
@@ -498,6 +771,8 @@ export declare class CodeNode {
     fnDesc?: RangerAppFunctionDesc;
     lambdaFnDesc?: RangerAppFunctionDesc;
     hasParamDesc: boolean;
+    has_doc_tail: boolean;
+    docNode?: CodeNode;
     paramDesc?: RangerAppParamDesc;
     ownParamDesc?: RangerAppParamDesc;
     evalCtx?: RangerAppWriterContext;
@@ -561,6 +836,7 @@ export declare class CodeNode {
     isParsedAsPrimitive(): boolean;
     isPrimitiveType(): boolean;
     isAPrimitiveType(): boolean;
+    rangerDoubleLiteral(v: number): string;
     writeCode(wr: CodeWriter): void;
     createChainTarget(): void;
     inferDefExpressionTypeFromValue(node: CodeNode): void;
@@ -577,6 +853,7 @@ export declare class CodeNode {
     newExpressionNode(): CodeNode;
     getChildrenFrom(otherNode: CodeNode): void;
     finalizeAsCallChainRoot(): void;
+    chainDotName(item: CodeNode): string;
     tryDesugarNewMethodChain(): boolean;
     cloneWithType(match: RangerArgMatch, changeVref: boolean): CodeNode;
     rebuildWithType(match: RangerArgMatch, changeVref: boolean): CodeNode;
@@ -589,6 +866,7 @@ export declare class CodeNode {
     typeNameAsType(ctx: RangerAppWriterContext): number;
     copyEvalResFrom(node: CodeNode): void;
     defineNodeTypeTo(node: CodeNode, ctx: RangerAppWriterContext): void;
+    defineNodeTypeToSelf(ctx: RangerAppWriterContext): void;
     ifNoTypeSetToVoid(): void;
     ifNoTypeSetToEvalTypeOf(node: CodeNode): boolean;
     static vref1(name: string): CodeNode;
@@ -702,6 +980,10 @@ export declare class RangerAppWriterContext {
     targetLangName: string;
     parent?: RangerAppWriterContext;
     defined_imports: Array<string>;
+    active_macros: {
+        [key: string]: boolean;
+    };
+    macro_expansion_depth: number;
     already_imported: {
         [key: string]: boolean;
     };
@@ -839,6 +1121,10 @@ export declare class RangerAppWriterContext {
         [key: string]: number;
     };
     rust_temp_counter: number;
+    rust_path_field_names: {
+        [key: string]: boolean;
+    };
+    rust_path_names_ready: boolean;
     rootFile: string;
     constructor();
     rustMarkMoved(varName: string): void;
@@ -900,7 +1186,10 @@ export declare class RangerAppWriterContext {
     addCapturedVariable(name: string): void;
     getCapturedVariables(): Array<string>;
     transformOpNameWord(input_word: string): string;
+    transformMemberWord(input_word: string): string;
+    transformBindingWord(input_word: string): string;
     transformWord(input_word: string): string;
+    getTargetLangName(): string;
     initReservedWords(): boolean;
     initStdCommands(): boolean;
     transformTypeName(typeName: string): string;
@@ -917,6 +1206,7 @@ export declare class RangerAppWriterContext {
     canUseTypeInference(nameNode: CodeNode): boolean;
     createOpStaticClass(name: string): RangerAppClassDesc;
     createTraitInstanceClass(traitName: string, instanceName: string, initParams: CodeNode, flowParser: RangerFlowParser, wr: CodeWriter): Promise<RangerAppClassDesc> | undefined;
+    createGenericClassInstance(templateName: string, instanceName: string, typeArgs: CodeNode, flowParser: RangerFlowParser, wr: CodeWriter): Promise<RangerAppClassDesc> | undefined;
     createOperator(fromNode: CodeNode): void;
     findClassMethod(cname: string, fname: string): RangerAppFunctionDesc | undefined;
     getFileWriter(path: string, fileName: string): CodeWriter;
@@ -1025,6 +1315,28 @@ export declare class SourceMapBuilder {
     toJSON(fileName: string): string;
     hasMappings(): boolean;
 }
+export declare class RangerSourceFormat {
+    constructor();
+    static defaultWidthFor(ext: string): number;
+    static dotLeadsLine(ext: string): boolean;
+    static isSpaceCode(c: number): boolean;
+    static indentOf(line: string): string;
+    static isCommentOrEmpty(line: string): boolean;
+    static codeEndOf(line: string): number;
+    static chainSplits(line: string): Array<number>;
+    static breakChainLine(line: string, ext: string): string;
+    static isCallKeyword(word: string): boolean;
+    static isWordCode(c: number): boolean;
+    static wordBefore(line: string, i: number): string;
+    static argListOpen(line: string): number;
+    static topCommaCount(line: string, open: number, limit: number): number;
+    static topCommaAt(line: string, open: number, limit: number): Array<number>;
+    static codeTailChar(line: string): number;
+    static breakArgLine(line: string, ext: string): string;
+    static hasOpenString(line: string): boolean;
+    static breakRustBlockLine(line: string, ext: string): string;
+    static formatSource(text: string, ext: string, width: number): string;
+}
 export declare class CodeFile {
     path_name: string;
     name: string;
@@ -1036,7 +1348,7 @@ export declare class CodeFile {
     fileSystem?: CodeFileSystem;
     sourceMapBuilder?: SourceMapBuilder;
     constructor(filePath: string, fileName: string);
-    initSourceMapsIfNeeded(): void;
+    initSourceMapsIfNeeded(mapsEnabled: boolean): void;
     addImport(import_name: string): void;
     rewrite(newString: string): void;
     testCreateWriter(): CodeWriter;
@@ -1047,6 +1359,7 @@ export declare class CodeFile {
 export declare class CodeFileSystem {
     files: Array<CodeFile>;
     sourceMapsEnabled: boolean;
+    formatWidth: number;
     constructor();
     enableSourceMaps(): void;
     shouldWriteSourceMaps(): boolean;
@@ -1063,6 +1376,10 @@ export declare class CodeSlice {
 }
 export declare class CodeWriter {
     tagName: string;
+    suppress_expr_parens: boolean;
+    current_op_no_parens: boolean;
+    in_format_args: boolean;
+    parent_binding: number;
     codeStr: string;
     currentLine: string;
     tabStr: string;
@@ -1123,6 +1440,7 @@ export declare class CodeWriter {
 }
 export declare class RangerLispParser {
     code?: SourceCode;
+    source_text: string;
     buff?: string;
     __len: number;
     i: number;
@@ -1136,23 +1454,34 @@ export declare class RangerLispParser {
     curr_node?: CodeNode;
     had_error: boolean;
     disableOperators: boolean;
+    recv_tmp_count: number;
+    last_call_group?: CodeNode;
+    pending_comments: Array<CodeNode>;
     constructor(code_module: SourceCode);
     joo(cm: SourceCode): void;
     parse_raw_annotation(): CodeNode;
-    skip_space(is_block_parent: boolean): boolean;
+    skip_space(s: string, is_block_parent: boolean): boolean;
     end_expression(consumeCurrent: boolean): boolean;
-    getOperator(disabled: boolean): number;
-    isOperator(disabled: boolean): number;
+    getOperator(s: string, disabled: boolean): number;
+    isOperator(s: string, disabled: boolean): number;
     getOperatorPred(str: string, disabled: boolean): number;
     isComparisonOpPred(pred: number): boolean;
+    isFoldableInfixPred(pred: number): boolean;
     isDotVRef(n: CodeNode): boolean;
     isDotCallPairOnNode(node: CodeNode): boolean;
+    isCallChainOnNode(node: CodeNode): boolean;
+    foldCallChainToGroup(node: CodeNode): void;
     foldDotCallPairToGroup(node: CodeNode): void;
+    isPlainDotCallee(n: CodeNode, paren_pos: number): boolean;
+    isChainTailCallee(n: CodeNode, paren_pos: number): boolean;
+    insertCallOrNode(p_node: CodeNode): boolean;
     tryCloseCallArgParenBeforeInfix(): boolean;
     insert_node(p_node: CodeNode): void;
-    parse_attributes(): boolean;
-    parseXML(): void;
+    attachPendingComments(node: CodeNode): void;
+    parse_attributes(s: string): boolean;
+    parseXML(s: string): void;
     parse(disable_ops: boolean): void;
+    parseBuf(s: string, disable_ops: boolean): void;
     static normalizeLineEndings(src: string): string;
 }
 export declare class TTypes {
@@ -1176,6 +1505,7 @@ export declare class RangerArgMatch {
     matchedLambdas: {
         [key: string]: CodeNode;
     };
+    typeParamNames: Array<string>;
     constructor();
     matchArguments(args: CodeNode, callArgs: CodeNode, ctx: RangerAppWriterContext, firstArgIndex: number): boolean;
     force_add(tplKeyword: string, typeName: string, ctx: RangerAppWriterContext): void;
@@ -1186,6 +1516,9 @@ export declare class RangerArgMatch {
     doesMatch(arg: CodeNode, node: CodeNode, ctx: RangerAppWriterContext): boolean;
     areEqualTypes(type1o: string, type2o: string, ctx: RangerAppWriterContext): boolean;
     areEqualATypes(type1i: string, type2i: string, ctx: RangerAppWriterContext): boolean;
+    addTypeParam(tplKeyword: string, typeName: string): boolean;
+    isCollectionParam(n: string): boolean;
+    applyCollectionType(node: CodeNode, n: string): void;
     getTypeName(n: string): string;
     getType(n: string): number;
     setRvBasedOn(arg: CodeNode, node: CodeNode): boolean;
@@ -1322,6 +1655,53 @@ export declare class TFiles {
     static searchEnv(env: InputEnv, paths: Array<string>, fileName: string): string;
     static search(paths: Array<string>, fileName: string): string;
 }
+export declare class PkgHit {
+    ok: boolean;
+    err: string;
+    dir: string;
+    name: string;
+    packageId: string;
+    constructor();
+}
+export declare class PkgJVal {
+    kind: string;
+    str: string;
+    keys: Array<string>;
+    vals: Array<PkgJVal>;
+    constructor();
+}
+export declare class PkgJRead {
+    text: string;
+    i: number;
+    n: number;
+    ok: boolean;
+    constructor();
+    parse(src: string): PkgJVal;
+    skipWs(): void;
+    val(): PkgJVal;
+    obj(): PkgJVal;
+    quoted(): string;
+    static child(obj: PkgJVal, key: string): PkgJVal | undefined;
+    static strOf(obj: PkgJVal, key: string): string;
+}
+export declare class PkgImport {
+    constructor();
+    static isPkg(spec: string): boolean;
+    static stripDot(spec: string): string;
+    static cacheRoot(): string;
+    static joinPath(a: string, b: string): string;
+    static foldPath(path: string): string;
+    static splitName(path: string): Array<string>;
+    static parentDir(dir: string): string;
+    static findManifestDir(env: InputEnv, start: string, paths: Array<string>): string;
+    static walkUp(env: InputEnv, start: string): string;
+    static readText(env: InputEnv, dir: string, name: string): Promise<string>;
+    static findChar(s: string, code: number): number;
+    static manifestChain(env: InputEnv, startDir: string, libraryPaths: Array<string>): Array<string>;
+    static resolve(env: InputEnv, startDir: string, spec: string, libraryPaths: Array<string>): Promise<PkgHit>;
+    static resolveIn(env: InputEnv, manDir: string, spec: string): Promise<PkgHit>;
+    static lockRoot(env: InputEnv, lockText: string, pkgName: string, manDir: string): string;
+}
 export declare class ClassJoinPoint {
     class_def?: RangerAppClassDesc;
     node?: CodeNode;
@@ -1332,10 +1712,82 @@ export declare class WalkLater {
     callArg?: CodeNode;
     constructor();
 }
+export declare class RangerFnParts {
+    ok: boolean;
+    nameNode?: CodeNode;
+    fnArgs?: CodeNode;
+    fnBody?: CodeNode;
+    desc?: RangerAppClassDesc;
+    constructor();
+}
 export declare class RangerFlowParser {
     hasRootPath: boolean;
     rootPath: string;
     _debug: boolean;
+    treeChildCall: {
+        [key: string]: string;
+    };
+    treeTextField: {
+        [key: string]: string;
+    };
+    treeTags: {
+        [key: string]: string;
+    };
+    treeTagDefaults: {
+        [key: string]: CodeNode;
+    };
+    treeFactoryNames: {
+        [key: string]: boolean;
+    };
+    treeTmpCount: number;
+    shapeCases: {
+        [key: string]: Array<string>;
+    };
+    shapeGroupCases: {
+        [key: string]: Array<string>;
+    };
+    caseAlias: {
+        [key: string]: string;
+    };
+    groupAlias: {
+        [key: string]: string;
+    };
+    caseShape: {
+        [key: string]: string;
+    };
+    caseDisplay: {
+        [key: string]: string;
+    };
+    caseIsValue: {
+        [key: string]: boolean;
+    };
+    caseFieldNames: {
+        [key: string]: Array<string>;
+    };
+    shapeViews: {
+        [key: string]: ShapeViewDesc;
+    };
+    shapeGroupParent: {
+        [key: string]: string;
+    };
+    shapeGroupFields: {
+        [key: string]: Array<string>;
+    };
+    shapeGroupFieldTypeName: {
+        [key: string]: string;
+    };
+    shapeGroupFieldArrayType: {
+        [key: string]: string;
+    };
+    shapeGroupFieldKeyType: {
+        [key: string]: string;
+    };
+    shapeGroupAllValue: {
+        [key: string]: boolean;
+    };
+    shapeCaseCtorArgs: {
+        [key: string]: string;
+    };
     stdCommands?: CodeNode;
     lastProcessedNode?: CodeNode;
     collectWalkAtEnd: Array<CodeNode>;
@@ -1361,6 +1813,7 @@ export declare class RangerFlowParser {
         [key: string]: string;
     };
     allNewRNodes: Array<CodeNode>;
+    inline_static_depth: number;
     infinite_recursion: boolean;
     match_types: {
         [key: string]: string;
@@ -1375,7 +1828,7 @@ export declare class RangerFlowParser {
     getThisName(): string;
     GetProperty(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
     WriteVRef(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
-    EnterFn(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter, callback: (node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter, nameNode: CodeNode, fnArgs: CodeNode, fnBody: CodeNode, desc: RangerAppClassDesc) => void): Promise<void>;
+    EnterFnParts(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<RangerFnParts>;
     Constructor(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
     WriteScalarValue(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): void;
     normalizeNewArgList(node: CodeNode): void;
@@ -1384,6 +1837,10 @@ export declare class RangerFlowParser {
     transformParams2(list: Array<CodeNode>, fnArgs: Array<CodeNode>, ctx: RangerAppWriterContext): Array<CodeNode>;
     CreateCTTI(node: CodeNode, ctx: RangerAppWriterContext, orig_wr: CodeWriter): Promise<void>;
     CreateRTTI(node: CodeNode, ctx: RangerAppWriterContext, orig_wr: CodeWriter): Promise<void>;
+    walkXmlCreate(xmlNode: CodeNode, regName: string, in_currCnt: number, opBody: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<number>;
+    markAsyncFrom(f: RangerAppFunctionDesc, visited: Array<RangerAppFunctionDesc>): Promise<void>;
+    markAsyncFromVariant(f: RangerAppFunctionDesc, visited: Array<RangerAppFunctionDesc>, ctx: RangerAppWriterContext): Promise<void>;
+    markCalledFromMain(f: RangerAppFunctionDesc, ctx: RangerAppWriterContext): Promise<void>;
     SolveAsyncFuncs(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
     matchMethodCall(cl: RangerAppClassDesc, methodName: string, callArgs: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter, errNode: CodeNode): Promise<RangerAppFunctionDesc> | undefined;
     cmdCall(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<boolean>;
@@ -1407,9 +1864,15 @@ export declare class RangerFlowParser {
     testCompile(opFn: CodeNode, node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<{
         [key: string]: CodeNode;
     }>;
+    inlineStaticEligible(m: RangerAppFunctionDesc, fnNode: CodeNode, ctx: RangerAppWriterContext): Promise<boolean>;
+    tryInlineTrivialStatic(node: CodeNode, fnNode: CodeNode, m: RangerAppFunctionDesc, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<boolean>;
     TransformOpFn(opFnList: Array<CodeNode>, origNode: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
     cmdArray(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
     EnterLambdaMethod(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
+    annotationIsTypeArgs(tAnn: CodeNode, ctx: RangerAppWriterContext): boolean;
+    normalizeTypeArg(ch: CodeNode): void;
+    genericInstanceName(baseName: string, tAnn: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<string>;
+    typeArgKey(spelling: string): string;
     CheckVRefTypeAnnotationOf(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<boolean>;
     CheckTypeAnnotationOf(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<boolean>;
     matchNode(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<boolean>;
@@ -1422,7 +1885,75 @@ export declare class RangerFlowParser {
     finalizeRecordClasses(ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
     expandRecordCtorArgsIfNeeded(cl: RangerAppClassDesc, fnDescr: RangerAppFunctionDesc, params: CodeNode, node: CodeNode): void;
     buildRecordConstructor(cl: RangerAppClassDesc, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
+    prepareImport(ctx: RangerAppWriterContext, spec: string): Promise<PkgHit>;
     mergeImports(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
+    DesugarTrees(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): void;
+    reportStrayTrees(node: CodeNode, ctx: RangerAppWriterContext): void;
+    isTreeFactoryDeclaration(node: CodeNode): boolean;
+    collectTreeFactories(node: CodeNode, atTopLevel: boolean, ctx: RangerAppWriterContext): void;
+    registerTreeFactory(node: CodeNode, ctx: RangerAppWriterContext): void;
+    isTreeLiteral(node: CodeNode): boolean;
+    expandTreesIn(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): void;
+    expandTreesInBlock(block: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): void;
+    lowerTreesIn(node: CodeNode, prelude: Array<CodeNode>, ctx: RangerAppWriterContext, wr: CodeWriter): void;
+    rewriteAsVRef(node: CodeNode, name: string): void;
+    lowerTreeElement(el: CodeNode, fname: string, prelude: Array<CodeNode>, ctx: RangerAppWriterContext, wr: CodeWriter): string;
+    isTreeKeyword(node: CodeNode, word: string): boolean;
+    lowerComputedChildren(ch: CodeNode, reg: string, fname: string, prelude: Array<CodeNode>, ctx: RangerAppWriterContext, wr: CodeWriter): void;
+    treeCall(at_node: CodeNode, reg: string, method: string, arg: CodeNode): CodeNode;
+    lowerTreeProps(propsNode: CodeNode, reg: string, prelude: Array<CodeNode>, ctx: RangerAppWriterContext, wr: CodeWriter): void;
+    treeAssign(at_node: CodeNode, reg: string, field: string, value: CodeNode): CodeNode;
+    lowerTreeChild(ch: CodeNode, reg: string, fname: string, prelude: Array<CodeNode>, ctx: RangerAppWriterContext, wr: CodeWriter): void;
+    DesugarShapes(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): void;
+    isShapeDeclaration(node: CodeNode): boolean;
+    expandShapesIn(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter, renames: {
+        [key: string]: string;
+    }): void;
+    expandShapesInScope(node: CodeNode, atTopLevel: boolean, ctx: RangerAppWriterContext, wr: CodeWriter, renames: {
+        [key: string]: string;
+    }): void;
+    registerShapeAlias(target: {
+        [key: string]: string;
+    }, alias: string, clsName: string): void;
+    shapeFieldIsScalar(fieldNode: CodeNode): boolean;
+    shapeFieldName(fieldNode: CodeNode): string;
+    shapeMemberBlock(st: CodeNode): CodeNode;
+    shapeMemberIsField(st: CodeNode): boolean;
+    shapeMemberIsMethod(st: CodeNode): boolean;
+    shapeMethodHasBody(st: CodeNode): boolean;
+    shapeMethodSignatureKey(mNode: CodeNode): string;
+    rewriteMethodFieldRefs(node: CodeNode, fieldNames: Array<string>, selfName: string): void;
+    findOpsClassBlock(root: CodeNode): CodeNode | undefined;
+    attachOpsMethods(opsRoot: CodeNode, viewName: string, methodNodes: Array<CodeNode>, methodStatic: Array<boolean>, fieldNames: Array<string>, ctx: RangerAppWriterContext): void;
+    attachShapeMethods(eqRoot: CodeNode, shapeName: string, opsName: string, methodNodes: Array<CodeNode>, methodNames: Array<string>, methodStatic: Array<boolean>, ctx: RangerAppWriterContext): void;
+    parseOpsClassRoot(src: string, filename: string, shapeNode: CodeNode, ctx: RangerAppWriterContext): CodeNode | undefined;
+    registerShapeView(shapeName: string, viewKind: string, viewName: string, className: string, allowed: Array<string>, parentView: string): void;
+    shapeTypeSpelling(typeName: string, arrayType: string, keyType: string): string;
+    shapeGroupHasField(groupCls: string, fieldName: string): boolean;
+    buildGroupFieldAccessorSrc(shapeName: string, gn: string, gClsName: string, mems: Array<string>, fieldNames: Array<string>, allowSet: boolean): string;
+    rewriteToGroupFieldGet(node: CodeNode, receiver: CodeNode, fieldName: string, groupCls: string, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
+    rewriteToGroupWiden(node: CodeNode, targetGroupCls: string, sourceGroupCls: string, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
+    expandShape(shapeNode: CodeNode, parent: CodeNode, shapeIndex: number, ctx: RangerAppWriterContext, wr: CodeWriter, renames: {
+        [key: string]: string;
+    }): void;
+    isMatchStatement(node: CodeNode): boolean;
+    expandMatchesIn(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): void;
+    expandMatchesInFn(node: CodeNode, enclosing: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): void;
+    expandGroupKindTests(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): void;
+    buildCaseKindTest(proto: CodeNode, scrutinee: CodeNode, cls: string): CodeNode;
+    declaredTypeOf(fnNode: CodeNode, name: string): string;
+    declaredTypeInBody(node: CodeNode, name: string): string;
+    matchArmCases(armName: string, node: CodeNode, ctx: RangerAppWriterContext): Array<string>;
+    expandMatch(matchNode: CodeNode, parent: CodeNode, matchIndex: number, enclosing: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): void;
+    setShapeRef(node: CodeNode, replacement: string): void;
+    rewriteShapeRefs(node: CodeNode, renames: {
+        [key: string]: string;
+    }): void;
+    isClassMemberForm(node: CodeNode): boolean;
+    markParentClass(ee: CodeNode, childName: string, ctx: RangerAppWriterContext): void;
+    WalkCollectTemplates(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): void;
+    isDocumentableHead(name: string): boolean;
+    DetachDocBlocks(node: CodeNode, ctx: RangerAppWriterContext): void;
     CollectMethods(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
     defineFunctionParam(method: RangerAppFunctionDesc, arg: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
     spliceFunctionBody(startIndex: number, node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): CodeNode;
@@ -1442,6 +1973,7 @@ export declare class RangerFlowParser {
     resolveProcessPathFromFields(cl: RangerAppClassDesc): void;
     validateProcessPaths(processClasses: Array<RangerAppClassDesc>, ctx: RangerAppWriterContext): void;
     isValidProcessPath(pathStr: string): boolean;
+    isJustVref(a: CodeNode): boolean;
     findLanguageOper(details: CodeNode, ctx: RangerAppWriterContext, opDef: CodeNode): Promise<CodeNode> | undefined;
     buildMacro(langOper: CodeNode, args: CodeNode, ctx: RangerAppWriterContext): Promise<CodeNode>;
     operandIsNonOptionalForNullCheck(node: CodeNode): boolean;
@@ -1493,19 +2025,41 @@ export declare class RangerGenericClassWriter {
     compFlags: {
         [key: string]: boolean;
     };
+    fmtMode: number;
     constructor();
+    bindingPowerOf(opName: string): number;
+    operandNeedsParens(childBp: number, parentBp: number): boolean;
+    formatterEnabled(ctx: RangerAppWriterContext): boolean;
+    isIdentStartChar(c: number): boolean;
+    isPostfixTopChar(s: string, i: number, c: number, n: number): boolean;
+    isPostfixExpression(s: string): boolean;
+    isWrappedInParens(s: string): boolean;
+    receiverNeedsParens(s: string): boolean;
+    writeCallReceiver(obj: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
+    unionIsSealable(ucl: RangerAppClassDesc, ctx: RangerAppWriterContext): boolean;
+    unionInterfaceName(unionName: string): string;
+    sealableUnionNames(ctx: RangerAppWriterContext): Array<string>;
+    unionInterfacesOf(cl: RangerAppClassDesc, ctx: RangerAppWriterContext): Array<string>;
+    classInSealableUnion(cl: RangerAppClassDesc, ctx: RangerAppWriterContext): boolean;
+    sealableUnionTypeOr(unionName: string, topType: string, ctx: RangerAppWriterContext): string;
     lineEnding(): string;
+    opWritesOwnParens(opName: string, node: CodeNode, ctx: RangerAppWriterContext): boolean;
     addSystemImport(cl: RangerAppClassDesc, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
     EncodeString(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): string;
     CustomOperator(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
+    beforeOperatorStatement(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
     WriteSetterVRef(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
     writeArrayTypeDef(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): void;
     WriteEnum(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
+    doubleNeedsPointZero(dd_str: string): boolean;
     WriteScalarValue(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): void;
     getTypeString(type_string: string): string;
+    emptyBlockFiller(): string;
     import_lib(lib_name: string, ctx: RangerAppWriterContext, wr: CodeWriter): void;
     getObjectTypeString(type_string: string, ctx: RangerAppWriterContext): string;
     release_local_vars(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): void;
+    renderDocExample(fd: RangerAppFunctionDesc, ctx: RangerAppWriterContext, outer: CodeWriter): Promise<string>;
+    trimTrailingBlank(text: string): string;
     WalkNode(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
     writeTypeDef(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
     writeRawTypeDef(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
@@ -1572,7 +2126,13 @@ export declare class RangerJava7ClassWriter extends RangerGenericClassWriter {
 export declare class RangerSwift3ClassWriter extends RangerGenericClassWriter {
     compiler?: LiveCompiler;
     header_created: boolean;
+    swift_unions_written: boolean;
     constructor();
+    writeSwiftUnionEnums(ctx: RangerAppWriterContext, wr: CodeWriter): void;
+    swiftDeclaredClassOf(nVal: CodeNode): string;
+    swiftUnionHasMember(ucl: RangerAppClassDesc, memberName: string): boolean;
+    swiftWriteUnionValue(targetTypeName: string, nVal: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<boolean>;
+    swiftWriteUnionArg(arg: RangerAppParamDesc, nVal: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<boolean>;
     adjustType(tn: string): string;
     getObjectTypeString(type_string: string, ctx: RangerAppWriterContext): string;
     getTypeString(type_string: string): string;
@@ -1587,6 +2147,7 @@ export declare class RangerSwift3ClassWriter extends RangerGenericClassWriter {
     CreateLambdaCall(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
     CreateLambda(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
     writeNewCall(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
+    writeArrayLiteral(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
     haveSameSig(fn1: RangerAppFunctionDesc, fn2: RangerAppFunctionDesc, ctx: RangerAppWriterContext): boolean;
     CustomOperator(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
     writeClass(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
@@ -1594,8 +2155,20 @@ export declare class RangerSwift3ClassWriter extends RangerGenericClassWriter {
 export declare class RangerSwift6ClassWriter extends RangerGenericClassWriter {
     compiler?: LiveCompiler;
     header_created: boolean;
+    swift_unions_written: boolean;
     constructor();
     adjustType(tn: string): string;
+    isSwiftValueTypeOf(t: number): boolean;
+    isSwiftValueCollection(nn: CodeNode): boolean;
+    isSwiftValueType(nn: CodeNode): boolean;
+    paramNeedsLocalCopy(arg: RangerAppParamDesc): boolean;
+    swiftWriteMutableParamCopies(fnDesc: RangerAppFunctionDesc, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
+    paramNeedsInout(arg: RangerAppParamDesc): boolean;
+    writeSwiftUnionEnums(ctx: RangerAppWriterContext, wr: CodeWriter): void;
+    swiftDeclaredClassOf(nVal: CodeNode): string;
+    swiftUnionHasMember(ucl: RangerAppClassDesc, memberName: string): boolean;
+    swiftWriteUnionValue(targetTypeName: string, nVal: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<boolean>;
+    swiftWriteUnionArg(arg: RangerAppParamDesc, nVal: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<boolean>;
     getObjectTypeString(type_string: string, ctx: RangerAppWriterContext): string;
     collectionTypeStringToSwift(type_string: string, ctx: RangerAppWriterContext): string;
     getTypeString(type_string: string): string;
@@ -1607,11 +2180,15 @@ export declare class RangerSwift6ClassWriter extends RangerGenericClassWriter {
     writeArgsDefWithLocals(fnDesc: RangerAppFunctionDesc, localFnDesc: RangerAppFunctionDesc, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
     resolveCallReceiverClassName(obj: CodeNode, ctx: RangerAppWriterContext): string;
     isSimpleClassCallReceiver(obj: CodeNode, ctx: RangerAppWriterContext): boolean;
+    receiverIsNullable(obj: CodeNode): boolean;
+    callResultIsDiscarded(node: CodeNode, ctx: RangerAppWriterContext): boolean;
+    writeSideEffectOnlyStmt(value: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
     CreateCallExpression(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
     writeFnCall(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
     CreateLambdaCall(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
     CreateLambda(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
     writeNewCall(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
+    writeArrayLiteral(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
     haveSameSig(fn1: RangerAppFunctionDesc, fn2: RangerAppFunctionDesc, ctx: RangerAppWriterContext): boolean;
     CustomOperator(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
     writeClass(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
@@ -1623,12 +2200,21 @@ export declare class RangerCppClassWriter extends RangerGenericClassWriter {
     header_created: boolean;
     buf_ret_seen: boolean;
     buf_ret_all_safe: boolean;
+    cpp_single_thread: boolean;
     constructor();
+    cppPtr(inner: string): string;
+    cppPtrOpen(): string;
+    cppMakeOpen(): string;
+    cppEsft(inner: string): string;
+    readCppPtrFlag(ctx: RangerAppWriterContext): void;
+    writeCppSingleThreadPrelude(wr: CodeWriter): void;
     lineEnding(): string;
     adjustType(tn: string): string;
+    escapeCppTrigraphs(s: string): string;
     WriteScalarValue(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): void;
     getObjectTypeString(type_string: string, ctx: RangerAppWriterContext): string;
     collectionTypeStringToCpp(type_string: string, ctx: RangerAppWriterContext): string;
+    cppUnionValueCase(cl: RangerAppClassDesc, ctx: RangerAppWriterContext): boolean;
     getTypeString2(type_string: string, ctx: RangerAppWriterContext): string;
     writePtr(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): void;
     writeTypeDef(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
@@ -1637,21 +2223,33 @@ export declare class RangerCppClassWriter extends RangerGenericClassWriter {
     cppScanBufferReturns(node: CodeNode): void;
     cppBufferReturnByRef(variant: RangerAppFunctionDesc, ctx: RangerAppWriterContext): boolean;
     writeReturnTypeDef(variant: RangerAppFunctionDesc, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
+    cppSegmentIsValueCase(node: CodeNode, idx: number, ctx: RangerAppWriterContext): boolean;
     WriteVRef(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
     writeVarDef(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
     disabledVarDef(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
     CreateCallExpression(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
+    cppWriteCmpOperand(o: CodeNode, otherIsLiteral: boolean, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
     CustomOperator(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
     CreateMethodCall(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
     CreatePropertyGet(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
     CreateLambdaCall(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
     CreateLambda(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
+    cppIsWeakField(nn: CodeNode, ctx: RangerAppWriterContext): boolean;
+    cppProgramHasWeakField(ctx: RangerAppWriterContext): boolean;
+    writeCppWeakHelper(wr: CodeWriter): void;
     writeCppHeaderVar(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter, do_initialize: boolean): Promise<void>;
     cppReadonlyValueParam(arg: RangerAppParamDesc): boolean;
+    cppReadonlyUnionParam(arg: RangerAppParamDesc, ctx: RangerAppWriterContext): boolean;
+    cppBorrowedObjectParam(fnDesc: RangerAppFunctionDesc, arg: RangerAppParamDesc, ctx: RangerAppWriterContext): boolean;
+    cppNeedsCallTempCopy(fnDesc: RangerAppFunctionDesc, arg: RangerAppParamDesc, n: CodeNode, ctx: RangerAppWriterContext): boolean;
     writeArgsDef(fnDesc: RangerAppFunctionDesc, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
+    cppCaptureByReference(vD: RangerAppParamDesc, ctx: RangerAppWriterContext): boolean;
+    cppMutableRefParam(fnDesc: RangerAppFunctionDesc, arg: RangerAppParamDesc, ctx: RangerAppWriterContext): boolean;
     writeFnCall(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
     writeNewCall(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
     writeArrayLiteral(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
+    cppUsesThisValue(body: CodeNode): Promise<boolean>;
+    cppNeedsSharedFromThis(node: CodeNode): Promise<boolean>;
     writeClassHeader(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
     CreateUnions(parser: RangerFlowParser, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
     writeClass(node: CodeNode, ctx: RangerAppWriterContext, orig_wr: CodeWriter): Promise<void>;
@@ -1662,27 +2260,145 @@ export declare class MethodCallList {
     add(methodName: string): void;
 }
 export declare class RangerRustClassWriter extends RangerGenericClassWriter {
+    rust_writing_call_receiver: boolean;
+    rust_call_receiver_mut: boolean;
+    rust_receiver_written: boolean;
+    rust_in_trait_decl: boolean;
+    rust_in_weak_unwrap: boolean;
+    rust_lhs_is_receiver: boolean;
+    rust_writing_return_type: boolean;
+    rust_receiverless_method: boolean;
+    rust_receiver_mut_known: boolean;
+    rust_emit_class_name: string;
+    rust_receiver_shared_known: boolean;
+    rust_prop_base_state: number;
+    rust_recv_place_mut: boolean;
+    rust_writing_mut_arg: boolean;
+    rust_path_head_mut: boolean;
+    rust_field_call_mut_ready: boolean;
+    rust_writing_field_type: boolean;
     compiler?: LiveCompiler;
     thisName: string;
+    rustFnReturnsUnion: string;
+    rustFnReturnNameNode?: CodeNode;
     fileHeaderWritten: boolean;
+    rust_in_cell_assign: boolean;
+    rust_last_recv_tmp: string;
+    rust_computing_family_mut: boolean;
     constructor();
     lineEnding(): string;
     adjustType(tn: string): string;
     WriteScalarValue(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): void;
+    rustStaticStrRead(node: CodeNode): boolean;
+    rustWriteStaticStrValue(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
+    rustTryBareStrLitArg(nVal: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): boolean;
+    rustArgIsNameRead(nVal: CodeNode): boolean;
+    rustSliceRefRead(node: CodeNode): boolean;
+    rustStrRefRead(node: CodeNode): boolean;
+    rustLhsHoldsRc(left: CodeNode): boolean;
+    rustValueIsBorrowedHandle(node: CodeNode, ctx: RangerAppWriterContext): boolean;
+    CreateLambdaCall(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
+    CreateLambda(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
+    writeRustLambdaType(expression_value: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
+    rustTraitCoerceName(targetType: string, value: CodeNode, ctx: RangerAppWriterContext): string;
+    rustArgValueTypeName(nVal: CodeNode): string;
+    rustNodeCollectionElemType(coll: CodeNode): string;
+    rustSelfRcTraitName(ctx: RangerAppWriterContext): string;
+    rustTypeIsOwnHandle(type_name: string, ctx: RangerAppWriterContext): boolean;
+    rustSharedTypeString(type_name: string, ctx: RangerAppWriterContext): string;
+    rustSharedWeakTypeString(type_name: string, ctx: RangerAppWriterContext): string;
+    rustIsCollectionTypeString(type_string: string): boolean;
+    rustCollectionTypeString(type_string: string, ctx: RangerAppWriterContext): string;
+    rustElementTypeString(type_string: string, ctx: RangerAppWriterContext): string;
     getObjectTypeString(type_string: string, ctx: RangerAppWriterContext): string;
     getTypeString(type_string: string): string;
     writeTypeDef(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
+    writeRustWeakVRefTail(node: CodeNode, p: RangerAppParamDesc, ctx: RangerAppWriterContext, wr: CodeWriter): void;
+    rustMethodInTraitIface(cl: RangerAppClassDesc, name: string, ctx: RangerAppWriterContext): boolean;
+    rustClassMethodKnownShared(cls: RangerAppClassDesc, name: string, ctx: RangerAppWriterContext): boolean;
+    rustReceiverPathClass(fc: CodeNode, ctx: RangerAppWriterContext): RangerAppClassDesc | undefined;
+    rustReceiverKnownShared(fc: CodeNode, ctx: RangerAppWriterContext): boolean;
+    rustReceiverKnownMut(node: CodeNode, fc: CodeNode, ctx: RangerAppWriterContext): boolean;
+    rustReceiverMutFor(node: CodeNode, fc: CodeNode, ctx: RangerAppWriterContext): boolean;
+    rustThisPrefix(ctx: RangerAppWriterContext): string;
+    rustThisPathPrefix(ctx: RangerAppWriterContext): string;
     WriteVRef(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
+    writeRustFnClose(variant: RangerAppFunctionDesc, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
+    writeRustReturnType(variant: RangerAppFunctionDesc, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
+    rustExprReadsThrough(node: CodeNode, name: string): boolean;
+    rustRhsReadsSharedCell(node: CodeNode): boolean;
+    rustCollectInheritedVars(cl: RangerAppClassDesc, ctx: RangerAppWriterContext, seen: {
+        [key: string]: boolean;
+    }, into: Array<RangerAppParamDesc>): void;
+    rustAllStructVars(cl: RangerAppClassDesc, ctx: RangerAppWriterContext): Array<RangerAppParamDesc>;
+    writeStructFieldType(p: RangerAppParamDesc, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
+    writeStructFieldTypeInner(p: RangerAppParamDesc, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
+    rustSegThroughTrait(node: CodeNode, idx: number, ctx: RangerAppWriterContext): boolean;
     writeStructField(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
+    rustFieldAccessorName(p: RangerAppParamDesc): string;
+    rustFieldIsPlainString(p: RangerAppParamDesc, ctx: RangerAppWriterContext): boolean;
+    rustFieldIsCopyScalar(p: RangerAppParamDesc, ctx: RangerAppWriterContext): boolean;
+    writeTraitFieldAccessorDecls(cl: RangerAppClassDesc, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
+    writeTraitFieldAccessorImpls(cl: RangerAppClassDesc, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
     writeVarDef(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
+    rustNewIntoUnion(value: CodeNode, ctx: RangerAppWriterContext): boolean;
+    rustUnionHasMember(ucl: RangerAppClassDesc, memberName: string): boolean;
+    rustDeclaredClassOf(nVal: CodeNode): string;
+    rustWriteUnionValue(targetTypeName: string, nVal: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<boolean>;
+    rustUnionReturnOf(fnDesc: RangerAppFunctionDesc, ctx: RangerAppWriterContext): string;
+    rustUnionValueCase(cl: RangerAppClassDesc, ctx: RangerAppWriterContext): boolean;
+    rustArgNeedsUnionWrap(targetTypeName: string, nVal: CodeNode, ctx: RangerAppWriterContext): boolean;
+    rustWriteUnionArg(arg: RangerAppParamDesc, nVal: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<boolean>;
+    rustClassIsShared(typeName: string, ctx: RangerAppWriterContext): boolean;
+    rustNeedsSelfRc(fnDesc: RangerAppFunctionDesc, ctx: RangerAppWriterContext): boolean;
+    rustEnclosingMethod(fnDesc: RangerAppFunctionDesc): RangerAppFunctionDesc;
+    rustInitRcState(value: CodeNode, ctx: RangerAppWriterContext): number;
+    rustSelfRcParamType(fnDesc: RangerAppFunctionDesc, ctx: RangerAppWriterContext): string;
+    rustSelfRcCoerceTo(fc: CodeNode, fnDesc: RangerAppFunctionDesc, ctx: RangerAppWriterContext): string;
+    writeSelfRcReceiverArg(node: CodeNode, fc: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): boolean;
+    writeRustReceiver(mutSelf: boolean, wr: CodeWriter): void;
+    writeTraitForwardArgs(variant: RangerAppFunctionDesc, ctx: RangerAppWriterContext, wr: CodeWriter, lead: boolean): void;
     writeArgsDef(fnDesc: RangerAppFunctionDesc, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
+    rustNodeContainsCall(node: CodeNode): boolean;
     containsSelfReference(node: CodeNode): boolean;
+    rustThisSegIsMethod(segName: string, ctx: RangerAppWriterContext): boolean;
+    rustMethodNeedsReceiver(fnD: RangerAppFunctionDesc, body: CodeNode, useCtx: RangerAppWriterContext, ctx: RangerAppWriterContext): boolean;
+    rustBodyGetsOwnClassHandle(node: CodeNode, useCtx: RangerAppWriterContext, ctx: RangerAppWriterContext): boolean;
+    rustBodyGetsClassHandle(node: CodeNode, clsName: string, cl: RangerAppClassDesc): boolean;
+    fnBodyUsesThisStruct(node: CodeNode, ctx: RangerAppWriterContext): boolean;
     fnBodyUsesThis(node: CodeNode, ctx: RangerAppWriterContext): boolean;
     accessesFieldOf(node: CodeNode, varName: string): boolean;
     getArgRootVar(node: CodeNode): string;
     hasMutRefConflict(node: CodeNode, fnDesc: RangerAppFunctionDesc, argIdx: number, givenArgs: CodeNode): boolean;
     collectSelfMethodCalls(node: CodeNode, ctx: RangerAppWriterContext, calls: Array<string>): void;
+    rustFieldCallMutatesThis(node: CodeNode, ctx: RangerAppWriterContext): boolean;
+    rustFieldPathCallMutates(fcc: CodeNode, ctx: RangerAppWriterContext): boolean;
+    rustNodeIsOwnPath(nIn: CodeNode, ctx: RangerAppWriterContext): boolean;
+    rustArgBorrowsThisMutably(node: CodeNode, ctx: RangerAppWriterContext): boolean;
     fnBodyDirectlyMutatesThis(node: CodeNode, ctx: RangerAppWriterContext): boolean;
+    rustCallTargetIsCollection(callObj: CodeNode): boolean;
+    rustIsMutatingOpName(n: string): boolean;
+    buildInheritedMutationGraph(cl: RangerAppClassDesc, ctx: RangerAppWriterContext, directMutations: {
+        [key: string]: boolean;
+    }, callGraph: {
+        [key: string]: MethodCallList;
+    }): void;
+    alignTraitSelfRcNeeds(cl: RangerAppClassDesc, ctx: RangerAppWriterContext): void;
+    rustTraitRootOf(cl: RangerAppClassDesc, ctx: RangerAppWriterContext): RangerAppClassDesc | undefined;
+    rustCallThroughSharedField(callObj: CodeNode, ctx: RangerAppWriterContext): boolean;
+    rustCollectPathNames(node: CodeNode, ctx: RangerAppWriterContext): void;
+    rustFillPathFieldNames(ctx: RangerAppWriterContext): void;
+    rustFieldCanBeCell(p: RangerAppParamDesc, ctx: RangerAppWriterContext): boolean;
+    rustCellIsString(p: RangerAppParamDesc): boolean;
+    rustCellIsCollection(p: RangerAppParamDesc): boolean;
+    rustCellIsCopy(p: RangerAppParamDesc): boolean;
+    rustCellFieldDesc(node: CodeNode): RangerAppParamDesc | undefined;
+    rustNodeIsCellField(node: CodeNode): boolean;
+    rustMarkInteriorCells(cl: RangerAppClassDesc, ctx: RangerAppWriterContext): void;
+    rustFillTraitMutations(root: RangerAppClassDesc, ctx: RangerAppWriterContext): void;
+    markTraitIfaceMutations(cl: RangerAppClassDesc, ctx: RangerAppWriterContext, directMutations: {
+        [key: string]: boolean;
+    }): void;
     buildClassMutationGraph(cl: RangerAppClassDesc, ctx: RangerAppWriterContext, directMutations: {
         [key: string]: boolean;
     }, callGraph: {
@@ -1699,46 +2415,134 @@ export declare class RangerRustClassWriter extends RangerGenericClassWriter {
         [key: string]: MethodCallList;
     }): boolean;
     fnBodyMutatesThis(node: CodeNode, ctx: RangerAppWriterContext): boolean;
+    rustExprCallNeedsSelfRc(obj: CodeNode, methodName: string, recvIsThis: boolean, ctx: RangerAppWriterContext): boolean;
     CreateCallExpression(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
+    rustBareArgNeedsClone(arg: CodeNode, ctx: RangerAppWriterContext): boolean;
     CreateMethodCall(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
     isSelfMethodCall(node: CodeNode): boolean;
+    rustCollectNestedSelfCalls(node: CodeNode, into: Array<CodeNode>): void;
     findSelfCallInArgs(node: CodeNode): number;
     writeFnCall(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
     writeNewCall(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
     writeArrayLiteral(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
+    writeSingletonAccessor(cl: RangerAppClassDesc, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
     writeClass(node: CodeNode, ctx: RangerAppWriterContext, orig_wr: CodeWriter): Promise<void>;
+    rustProgramHasMainFlag(ctx: RangerAppWriterContext): boolean;
+    opWritesOwnParens(opName: string, node: CodeNode, ctx: RangerAppWriterContext): boolean;
+    rustWriteBitOperand(o: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
+    rustArgIsAlreadyRef(nVal: CodeNode): boolean;
+    rustArgIsBareThis(nValIn: CodeNode): boolean;
+    rustArgIsPlainMutPath(nValIn: CodeNode): boolean;
+    rustWriteMutArgPrefix(nVal: CodeNode, wr: CodeWriter): void;
+    rustArgIsAlreadyMutRef(nVal: CodeNode): boolean;
+    rustWriteCmpOperand(o: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
+    rustWriteCastOperandF64(o: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
+    rustExprIsOptional(inNode: CodeNode, ctx: RangerAppWriterContext): boolean;
+    rustNodeIsLambda(node: CodeNode): boolean;
+    CreatePropertyGet(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
+    rustUnwrapParens(node: CodeNode): CodeNode;
+    rustCollectConcatOperands(node: CodeNode, out: Array<CodeNode>): void;
+    rustFmtInline(o: CodeNode): boolean;
+    rustStripToString(o: CodeNode): CodeNode;
+    writeRustFormatOps(ops: Array<CodeNode>, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
+    rustHoistFieldReceiver(real: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): void;
+    rustExtractSelfCallConflicts(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
+    rustTailBorrowsLocal(node: CodeNode): boolean;
+    walkRustFnBody(fnB: CodeNode, sCtx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
+    rustPlainScalarPath(n: CodeNode): boolean;
+    rustTryCompoundAssign(left: CodeNode, right: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<boolean>;
+    rustArgNeedsCellWrap(arg: RangerAppParamDesc, nVal: CodeNode, ctx: RangerAppWriterContext): boolean;
+    rustTraitCoerceRoot(right: CodeNode, fieldTypeName: string, ctx: RangerAppWriterContext): string;
+    rustWalkOperand(n: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
+    rustClassBlocksClone(cl: RangerAppClassDesc, ctx: RangerAppWriterContext, depth: number): boolean;
+    rustIsIndexedWriteOp(n: string): boolean;
+    rustExprMentionsName(node: CodeNode, name: string): boolean;
+    rustArgIsOutParam(node: CodeNode, idx: number): boolean;
+    rustIsSelfCallNode(n: CodeNode): boolean;
+    beforeOperatorStatement(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
     CustomOperator(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
 }
 export declare class RangerKotlinClassWriter extends RangerGenericClassWriter {
     compiler?: LiveCompiler;
+    kotlin_unions_written: boolean;
+    kotlin_package_written: boolean;
     constructor();
+    writeKotlinUnionInterfaces(ctx: RangerAppWriterContext, wr: CodeWriter): void;
     WriteScalarValue(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): void;
+    writeArrayLiteral(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
     adjustType(tn: string): string;
     getObjectTypeString(type_string: string, ctx: RangerAppWriterContext): string;
     collectionTypeStringToKotlin(type_string: string, ctx: RangerAppWriterContext): string;
     getTypeString(type_string: string): string;
+    writeLambdaType(expression_value: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
     writeTypeDef(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
+    CreateLambda(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
     WriteVRef(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
+    EncodeString(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): string;
+    receiverIsNullable(obj: CodeNode): boolean;
+    CreateCallExpression(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
+    namesStaticMember(cl: RangerAppClassDesc, node: CodeNode): boolean;
     writeVarDef(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
     paramEmitName(arg: RangerAppParamDesc, ctx: RangerAppWriterContext): string;
+    paramIsMutated(arg: RangerAppParamDesc): boolean;
+    kotlinWriteMutableParamCopies(fnDesc: RangerAppFunctionDesc, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
     writeArgsDef(fnDesc: RangerAppFunctionDesc, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
     writeFnCall(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
     writeNewCall(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
     writeClass(node: CodeNode, ctx: RangerAppWriterContext, orig_wr: CodeWriter): Promise<void>;
 }
+export declare class RangerDartClassWriter extends RangerGenericClassWriter {
+    compiler?: LiveCompiler;
+    wrote_header: boolean;
+    dart_unions_written: boolean;
+    constructor();
+    writeDartUnionInterfaces(ctx: RangerAppWriterContext, wr: CodeWriter): void;
+    EncodeString(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): string;
+    WriteScalarValue(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): void;
+    adjustType(tn: string): string;
+    getObjectTypeString(type_string: string, ctx: RangerAppWriterContext): string;
+    collectionTypeStringToDart(type_string: string, ctx: RangerAppWriterContext): string;
+    getTypeString(type_string: string): string;
+    writeTypeDef(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
+    namesStaticMember(cl: RangerAppClassDesc, node: CodeNode): boolean;
+    WriteVRef(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
+    writeVarDef(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
+    paramEmitName(arg: RangerAppParamDesc, ctx: RangerAppWriterContext): string;
+    writeArgsDef(fnDesc: RangerAppFunctionDesc, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
+    receiverIsNullable(obj: CodeNode): boolean;
+    CreateCallExpression(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
+    CreateLambda(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
+    writeFnCall(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
+    writeNewCall(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
+    writePubspec(node: CodeNode, ctx: RangerAppWriterContext, orig_wr: CodeWriter): Promise<void>;
+    writeClass(node: CodeNode, ctx: RangerAppWriterContext, orig_wr: CodeWriter): Promise<void>;
+}
 export declare class RangerCSharpClassWriter extends RangerGenericClassWriter {
     compiler?: LiveCompiler;
+    csharp_unions_written: boolean;
+    csharp_namespace_written: boolean;
+    csLambdaArgCounter: number;
     constructor();
     adjustType(tn: string): string;
+    writeCSharpUnionInterfaces(ctx: RangerAppWriterContext, wr: CodeWriter): void;
     getObjectTypeString(type_string: string, ctx: RangerAppWriterContext): string;
+    collectionTypeStringToCS(type_string: string, ctx: RangerAppWriterContext): string;
     getTypeString(type_string: string): string;
     writeLambdaType(expression_value: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
+    writeNullableMark(node: CodeNode, wr: CodeWriter): void;
     writeTypeDef(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
     WriteVRef(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
+    csNodeContainsCall(node: CodeNode): boolean;
     writeVarDef(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
+    renameShadowedLambdaArg(arg: CodeNode, ctx: RangerAppWriterContext): void;
     CreateLambda(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
     writeArgsDef(fnDesc: RangerAppFunctionDesc, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
     writeArrayLiteral(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
+    csCollectInherited(cl: RangerAppClassDesc, ctx: RangerAppWriterContext, vars: {
+        [key: string]: boolean;
+    }, methods: {
+        [key: string]: number;
+    }): void;
     writeClass(node: CodeNode, ctx: RangerAppWriterContext, orig_wr: CodeWriter): Promise<void>;
 }
 export declare class RangerScalaClassWriter extends RangerGenericClassWriter {
@@ -1765,9 +2569,18 @@ export declare class RangerGolangClassWriter extends RangerGenericClassWriter {
     write_raw_type: boolean;
     did_write_nullable: boolean;
     did_write_sseclient: boolean;
+    go_unions_written: boolean;
     httpServerWriter: RangerGolangHttpServerWriter;
     constructor();
+    writeGoUnionStructs(ctx: RangerAppWriterContext, wr: CodeWriter): void;
+    goDeclaredClassOf(nVal: CodeNode): string;
+    goUnionHasMember(ucl: RangerAppClassDesc, memberName: string): boolean;
+    goWriteUnionValue(targetTypeName: string, nVal: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<boolean>;
+    goWriteUnionArg(arg: RangerAppParamDesc, nVal: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<boolean>;
     WriteScalarValue(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): void;
+    isCollectionTypeString(type_string: string): boolean;
+    collectionTypeStringToGo(type_string: string, ctx: RangerAppWriterContext): string;
+    goElementTypeString(type_string: string, ctx: RangerAppWriterContext): string;
     getObjectTypeString(type_string: string, ctx: RangerAppWriterContext): string;
     getTypeString2(type_string: string, ctx: RangerAppWriterContext): string;
     writeRawTypeDef(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
@@ -1777,16 +2590,19 @@ export declare class RangerGolangClassWriter extends RangerGenericClassWriter {
     WriteVRef(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
     WriteSetterVRef(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
     goExtractAssign(value: CodeNode, p: RangerAppParamDesc, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
+    goAncestors(cl: RangerAppClassDesc, ctx: RangerAppWriterContext): Array<string>;
     writeStructField(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
     CreateCallExpression(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
     writeVarDef(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
     writeArgsDef(fnDesc: RangerAppFunctionDesc, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
+    writeFnCall(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
     writeNewCall(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
     writeArrayLiteral(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
     CreateLambdaCall(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
     CreateLambda(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
     CustomOperator(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
     writeInterface(cl: RangerAppClassDesc, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
+    writeSingletonAccessor(cl: RangerAppClassDesc, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
     writeClass(node: CodeNode, ctx: RangerAppWriterContext, orig_wr: CodeWriter): Promise<void>;
 }
 export declare class RangerGolangHttpServerWriter {
@@ -1832,17 +2648,30 @@ export declare class RangerPythonClassWriter extends RangerGenericClassWriter {
     compiler?: LiveCompiler;
     thisName: string;
     wrote_header: boolean;
+    pyHoistWriters: Array<CodeWriter>;
+    pyLambdaCounter: number;
     constructor();
+    emptyBlockFiller(): string;
     adjustType(tn: string): string;
     EncodeString(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): string;
     WriteScalarValue(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): void;
     WriteVRef(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
+    pyNodeContainsCall(node: CodeNode): boolean;
+    pyWalkBody(body: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
     writeVarInitDef(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
     writeVarDef(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
     CreateMethodCall(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
     CreatePropertyGet(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
     CreateLambdaCall(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
+    pyEmittedName(n: CodeNode): string;
+    pyCollectAssigned(node: CodeNode, assigned: {
+        [key: string]: boolean;
+    }, declared: {
+        [key: string]: boolean;
+    }): void;
     CreateLambda(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
+    getPythonTypeName(node: CodeNode, ctx: RangerAppWriterContext): string;
+    writeTypeDef(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
     writeClassVarDef(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): void;
     writeArgsDef(fnDesc: RangerAppFunctionDesc, ctx: RangerAppWriterContext, wr: CodeWriter): void;
     writeArrayLiteral(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
@@ -1913,9 +2742,12 @@ export declare class LowIRUtil {
     constructor();
     static typeFromRanger(typeName: string): string;
     static isSupportedPrimitive(typeName: string): boolean;
+    static looksLikeUtf8Bytes(text: string): boolean;
+    static utf8Bytes(text: string): Array<number>;
     static isStringType(typeName: string): boolean;
     static isArrayTypeName(typeName: string): boolean;
     static isBufferTypeName(typeName: string): boolean;
+    static isJsonTypeName(typeName: string): boolean;
     static isSupportedParam(typeName: string): boolean;
     static fieldIrType(typeName: string): string;
     static mangleMethod(className: string, methodName: string): string;
@@ -1969,6 +2801,11 @@ export declare class LowIRField {
     name: string;
     irType: string;
     isPtrArray: boolean;
+    isStringMap: boolean;
+    isIntMap: boolean;
+    isIntMapStr: boolean;
+    isStringMapInt: boolean;
+    isStringMapStr: boolean;
     isBool: boolean;
     isString: boolean;
     isBuffer: boolean;
@@ -2021,6 +2858,8 @@ export declare class LowIRModule {
     singletonClasses: Array<string>;
     lambdaTableFuncs: Array<string>;
     lambdaSigs: Array<string>;
+    usesErrorMsg: boolean;
+    bigStackMain: boolean;
     constructor();
 }
 export declare class LowIRSession {
@@ -2037,33 +2876,40 @@ export declare class LowIRBuilder {
     blockCounter: number;
     blocks: Array<LowIRBlock>;
     currentBlock?: LowIRBlock;
+    destTypes: {
+        [key: string]: string;
+    };
     constructor(module: LowIRModule);
     freshTemp(prefix: string): string;
     freshLabel(prefix: string): string;
     reset(): void;
     startBlock(label: string): string;
     emit(instr: LowIRInstr): LowIRInstr;
+    emittedType(value: string): string;
     emitToEntry(instr: LowIRInstr): LowIRInstr;
     emitConst(irType: string, value: string): string;
     emitBin(kind: string, irType: string, lhs: string, rhs: string): string;
     emitIcmp(pred: string, lhs: string, rhs: string): string;
-    emitIcmpTyped(pred: string, operandType: string, lhs: string, rhs: string): string;
+    emitIcmpTyped(pred: string, operandType: string, lhsIn: string, rhsIn: string): string;
     emitPtrToInt(ptr: string): string;
     emitCall(fnName: string, retType: string, args: Array<string>, argTypes: Array<string>): string;
     emitComment(text: string): void;
-    emitCallWithSig(fnName: string, retType: string, callSig: string, args: Array<string>, argTypes: Array<string>): string;
+    coerceCallArgs(args: Array<string>, argTypes: Array<string>): Array<string>;
+    emitCallWithSig(fnName: string, retType: string, callSig: string, rawArgs: Array<string>, argTypes: Array<string>): string;
     emitAllocaStruct(className: string, slotName: string, fieldCount: number): string;
     emitGep(className: string, structPtr: string, fieldIndex: number): string;
     emitAlloca(irType: string, slotName: string): string;
     emitZeroInitToEntry(irType: string, slotName: string): void;
+    emitNullInitToEntry(irType: string, slotName: string): void;
     emitLoad(irType: string, slotName: string): string;
-    emitStore(irType: string, value: string, slotName: string): void;
+    emitStore(irType: string, valueIn: string, slotName: string): void;
     emitHeapAlloc(byteCount: string): string;
-    emitIntToI8Ptr(addr: string, addrType: string): string;
+    emitIntToI8Ptr(addr: string, addrTypeIn: string): string;
     emitIntToStructPtr(className: string, addr: string): string;
-    emitCast(castOp: string, destType: string, srcType: string, value: string): string;
+    emitCast(castOp: string, destType: string, srcTypeIn: string, value: string): string;
     emitZextI1ToI32(v: string): string;
     emitZextI32ToPtr(v: string): string;
+    addrWidthOf(ptr: string): string;
     emitPtrLoad(ptr: string): string;
     emitPtrLoadTyped(ptr: string, valueType: string): string;
     emitPtrStore(ptr: string, value: string): void;
@@ -2075,14 +2921,18 @@ export declare class LowIRBuilder {
     emitGlobalGet(name: string): string;
     emitGlobalSet(name: string, value: string): void;
     emitFuncRef(name: string): string;
-    emitCallIndirect(retType: string, callSig: string, args: Array<string>, argTypes: Array<string>, selector: string): string;
+    emitCallIndirect(retType: string, callSig: string, rawArgs: Array<string>, argTypes: Array<string>, selector: string): string;
     emitI32At(base: string, byteOff: number): string;
     emitStoreI32At(base: string, byteOff: number, value: string): void;
+    emitStoreTypedAt(base: string, byteOff: number, value: string, valueType: string): void;
+    emitLoadTypedAt(base: string, byteOff: number, valueType: string): string;
     emitLoadI32At(base: string, byteOff: number): string;
     emitStrPtr(globalName: string, byteLen: number): string;
     emitTypeDescPtr(className: string): string;
     terminateRet(retType: string, value: string): void;
     terminateBr(target: string): void;
+    coerceTo(v: string, want: string): string;
+    asI1(v: string): string;
     terminateBrIf(cond: string, ifTrue: string, ifFalse: string): void;
     terminateUnreachable(): void;
     finishFunction(name: string, retType: string, params: Array<LowIRParam>, exportFn: boolean, isMain: boolean): string;
@@ -2120,6 +2970,7 @@ export declare class LowIRRuntimeGen {
     static ptrBytes(module: LowIRModule): number;
     static descMetaOff(module: LowIRModule): number;
     static ensurePtrArrayRuntime(module: LowIRModule): void;
+    static buildRtPtrArrayReserve(module: LowIRModule): void;
     static buildRtPtrArrayNew(module: LowIRModule): void;
     static buildRtPtrArrayLen(module: LowIRModule): void;
     static buildRtPtrArrayGet(module: LowIRModule): void;
@@ -2151,6 +3002,17 @@ export declare class LowIRLowerContext {
     slots: {
         [key: string]: string;
     };
+    paramNames: Array<string>;
+    capturedNames: Array<string>;
+    shadowStack: Array<string>;
+    shadowCounter: number;
+    forceFreshSlots: Array<string>;
+    reslotNames: Array<string>;
+    reslotPrevSlots: Array<string>;
+    reslotPrevTypes: Array<string>;
+    reslotOwnedStr: Array<number>;
+    reslotOwnedObj: Array<number>;
+    reslotOwnedColl: Array<number>;
     slotTypes: {
         [key: string]: string;
     };
@@ -2163,6 +3025,12 @@ export declare class LowIRLowerContext {
     ptrArrayElemTypes: {
         [key: string]: string;
     };
+    smapValueTypes: {
+        [key: string]: string;
+    };
+    imapValueTypes: {
+        [key: string]: string;
+    };
     ownedObjectLocals: Array<string>;
     ownedCollectionLocals: Array<string>;
     ownedStringLocals: Array<string>;
@@ -2174,6 +3042,9 @@ export declare class LowIRLowerContext {
     boxedLocals: {
         [key: string]: number;
     };
+    boxedTypes: {
+        [key: string]: string;
+    };
     escapedLocals: {
         [key: string]: string;
     };
@@ -2181,6 +3052,12 @@ export declare class LowIRLowerContext {
     llvmRetType: string;
     className: string;
     selfPtr: string;
+    breakLabel: string;
+    continueLabel: string;
+    catchLabel: string;
+    loopOwnedMark: number;
+    loopOwnedStrMark: number;
+    loopOwnedCollMark: number;
     constructor();
 }
 export declare class LambdaCaptureInfo {
@@ -2188,10 +3065,17 @@ export declare class LambdaCaptureInfo {
     irTypes: Array<string>;
     kinds: Array<number>;
     objClasses: Array<string>;
+    boxTypes: Array<string>;
+    collKinds: Array<string>;
+    elemTypes: Array<string>;
+    smapValTypes: Array<string>;
     offsets: Array<number>;
     totalBytes: number;
     hasOwned: boolean;
     tdName: string;
+    capturesSelf: boolean;
+    selfOffset: number;
+    selfClass: string;
     constructor();
 }
 export declare class LowIRBuilderPass {
@@ -2200,6 +3084,7 @@ export declare class LowIRBuilderPass {
     usedArrayRuntime: boolean;
     usedPtrArrayRuntime: boolean;
     usedMemRuntime: boolean;
+    exprRecvPtr: string;
     lambdaSigMap: {
         [key: string]: string;
     };
@@ -2207,13 +3092,31 @@ export declare class LowIRBuilderPass {
         [key: string]: RangerAppFunctionDesc;
     };
     lambdaNames: Array<string>;
+    lambdaDepths: {
+        [key: string]: number;
+    };
     lambdaCounter: number;
     lambdaCaptures: {
         [key: string]: LambdaCaptureInfo;
     };
+    virtualKeys: Array<string>;
+    virtualIsKey: {
+        [key: string]: boolean;
+    };
+    virtualCases: {
+        [key: string]: Array<string>;
+    };
+    virtualImplOf: {
+        [key: string]: string;
+    };
+    virtualDescOf: {
+        [key: string]: RangerAppFunctionDesc;
+    };
+    appRoot?: RangerAppWriterContext;
     constructor();
     isLambdaTypeNode(node: CodeNode): boolean;
     canLowerFunction(fnDesc: RangerAppFunctionDesc, ctx: RangerAppWriterContext): boolean;
+    isKeywordMarkerParam(p: RangerAppParamDesc): boolean;
     canLowerMethod(fnDesc: RangerAppFunctionDesc): boolean;
     canLowerInstanceMethod(fnDesc: RangerAppFunctionDesc, ctx: RangerAppWriterContext): boolean;
     isMainEntry(fnDesc: RangerAppFunctionDesc, ctx: RangerAppWriterContext): boolean;
@@ -2225,11 +3128,14 @@ export declare class LowIRBuilderPass {
     ensureMemExtern(target: LowIRTarget): void;
     memEnabled(lctx: LowIRLowerContext): boolean;
     objRcEnabled(lctx: LowIRLowerContext): boolean;
+    strRcEnabled(lctx: LowIRLowerContext): boolean;
     wasmStrEnabled(lctx: LowIRLowerContext): boolean;
     isLowerableParamType(typeName: string): boolean;
+    isEnumTypeName(typeName: string): boolean;
     llvmTypeForRanger(typeName: string, ptrType: string): string;
     varTypeName(nameNode: CodeNode): string;
     exprIsObjectPtr(node: CodeNode, lctx: LowIRLowerContext): boolean;
+    isRefCountedObjectType(typeName: string): boolean;
     isObjectTypeName(typeName: string): boolean;
     exprIsString(node: CodeNode): boolean;
     exprMightBeString(node: CodeNode, lctx: LowIRLowerContext): boolean;
@@ -2260,10 +3166,15 @@ export declare class LowIRBuilderPass {
     lowerShellArgCnt(lctx: LowIRLowerContext): string;
     lowerShellArg(node: CodeNode, lctx: LowIRLowerContext): string;
     lowerReadFile(node: CodeNode, lctx: LowIRLowerContext): string;
+    lowerCreateDir(node: CodeNode, lctx: LowIRLowerContext): void;
+    lowerWriteFile(node: CodeNode, lctx: LowIRLowerContext): void;
+    lowerNullify(node: CodeNode, lctx: LowIRLowerContext): void;
     lowerBufferAlloc(node: CodeNode, lctx: LowIRLowerContext): string;
+    emitPtrArrayLenOrBufferLen(bufVal: string, lctx: LowIRLowerContext): string;
     lowerBufferLength(node: CodeNode, lctx: LowIRLowerContext): string;
     lowerBufferGet(node: CodeNode, lctx: LowIRLowerContext): string;
     lowerBufferSet(node: CodeNode, lctx: LowIRLowerContext): string;
+    lowerBufferFill(node: CodeNode, lctx: LowIRLowerContext): string;
     lowerBufferReadFile(node: CodeNode, lctx: LowIRLowerContext): string;
     lowerBufferWriteFile(node: CodeNode, lctx: LowIRLowerContext): string;
     lowerIntBufferAlloc(node: CodeNode, lctx: LowIRLowerContext): string;
@@ -2272,7 +3183,10 @@ export declare class LowIRBuilderPass {
     exprIsF64(node: CodeNode): boolean;
     promoteToF64(node: CodeNode, val: string, lctx: LowIRLowerContext): string;
     lowerToDouble(node: CodeNode, lctx: LowIRLowerContext): string;
+    emitDoubleToString(value: string, lctx: LowIRLowerContext): string;
+    emitLibmCall(fnName: string, value: string, lctx: LowIRLowerContext): string;
     lowerToInt(node: CodeNode, lctx: LowIRLowerContext): string;
+    lowerFloor(node: CodeNode, lctx: LowIRLowerContext): string;
     lowerStr2Double(node: CodeNode, lctx: LowIRLowerContext): string;
     lowerStr2Int(node: CodeNode, lctx: LowIRLowerContext): string;
     lowerIntBufferFill(node: CodeNode, lctx: LowIRLowerContext): string;
@@ -2284,19 +3198,89 @@ export declare class LowIRBuilderPass {
     lowerPtrIsNull(ptr: string, lctx: LowIRLowerContext): string;
     lowerPtrIsNotNull(ptr: string, lctx: LowIRLowerContext): string;
     loadArrayDescExpr(arrNode: CodeNode, lctx: LowIRLowerContext): string;
+    exprIsPtrSizedRead(rawNode: CodeNode, lctx: LowIRLowerContext): boolean;
+    pushValueNeedsWiden(itemNode: CodeNode, value: string, lctx: LowIRLowerContext): boolean;
     pushItemNeedsWiden(itemNode: CodeNode, lctx: LowIRLowerContext): boolean;
     arrayElemTypeName(arrNode: CodeNode, lctx: LowIRLowerContext): string;
+    nodeIsArrayExpr(node: CodeNode, lctx: LowIRLowerContext): boolean;
+    lowerArrayIndexOf(node: CodeNode, lctx: LowIRLowerContext): string;
+    isArrayLiteralValue(nameNode: CodeNode, val: CodeNode): boolean;
+    isArrayLiteralShape(val: CodeNode): boolean;
+    arrayElemTypeOfTypeName(typeName: string): string;
+    arrayLiteralElemType(nameNode: CodeNode, node: CodeNode, lctx: LowIRLowerContext): string;
+    lowerArrayLiteral(nameNode: CodeNode, node: CodeNode, lctx: LowIRLowerContext): string;
+    lowerArrayLiteralTyped(elemType: string, node: CodeNode, lctx: LowIRLowerContext): string;
     lowerPush(node: CodeNode, lctx: LowIRLowerContext): void;
+    lowerForMap(node: CodeNode, lctx: LowIRLowerContext): boolean;
     lowerFor(node: CodeNode, lctx: LowIRLowerContext): void;
     emitStrcmpEq(lhs: string, rhs: string, ctx: LowIRLowerContext): string;
+    propertyReadClass(node: CodeNode, lctx: LowIRLowerContext): string;
+    isPropertyReadNode(node: CodeNode): boolean;
+    lowerPropertyRead(node: CodeNode, lctx: LowIRLowerContext): string;
+    isLibmUnaryOp(op: string): boolean;
+    isLibmBinaryOp(op: string): boolean;
+    lowerLibmUnary(fnName: string, node: CodeNode, lctx: LowIRLowerContext): string;
+    lowerLibmBinary(fnName: string, node: CodeNode, lctx: LowIRLowerContext): string;
     lowerToString(node: CodeNode, lctx: LowIRLowerContext): string;
     lowerStrFromCode(node: CodeNode, fnName: string, lctx: LowIRLowerContext): string;
+    lowerStrlenOn(textNode: CodeNode, lctx: LowIRLowerContext): string;
+    unwrapUnwrapOper(node: CodeNode): CodeNode;
     lowerStrlen(node: CodeNode, lctx: LowIRLowerContext): string;
     isIntArrayTypeNode(node: CodeNode): boolean;
+    isIntKeyValueMapTypeNode(node: CodeNode): boolean;
+    ensureIMapExterns(): void;
+    widenToI64(val: string, keyNode: CodeNode, lctx: LowIRLowerContext): string;
+    emitIMapCall(fnName: string, retType: string, desc: string, rest: Array<string>, restTypes: Array<string>, lctx: LowIRLowerContext): string;
+    imapDescFromVref(vref: string, lctx: LowIRLowerContext): string;
+    imapValueKind(vref: string, lctx: LowIRLowerContext): string;
+    imapValueOwnKind(typeName: string): number;
     isIntIntMapTypeNode(node: CodeNode): boolean;
+    ensureSMapExterns(): void;
+    emitSMapNew(lctx: LowIRLowerContext): string;
+    emitSMapNewKind(valKind: number, lctx: LowIRLowerContext): string;
+    smapValueOwnKind(valueTypeName: string): number;
+    emitSMapCall(fnName: string, retType: string, descIn: string, rest: Array<string>, restTypes: Array<string>, lctx: LowIRLowerContext): string;
+    lowerSMapKeys(node: CodeNode, lctx: LowIRLowerContext): string;
+    lowerEnumRef(node: CodeNode, lctx: LowIRLowerContext): string;
+    jsonTypeNameOfNode(node: CodeNode, lctx: LowIRLowerContext): string;
+    nodeIsJson(node: CodeNode, lctx: LowIRLowerContext): boolean;
+    jsonValueKind(valNode: CodeNode, lctx: LowIRLowerContext): string;
+    ensureJsonExtern(fnName: string, retType: string, params: Array<string>): void;
+    emitAnsiConst(code: string, lctx: LowIRLowerContext): string;
+    tryLowerAnsi(opName: string, lctx: LowIRLowerContext): string;
+    emitJsonCall(fnName: string, retType: string, args: Array<string>, argTypes: Array<string>, cParams: Array<string>, lctx: LowIRLowerContext): string;
+    lowerJsonNew(fnName: string, lctx: LowIRLowerContext): string;
+    lowerJsonGet(node: CodeNode, fnName: string, retIr: string, cRet: string, lctx: LowIRLowerContext): string;
+    lowerJsonSet(node: CodeNode, lctx: LowIRLowerContext): void;
+    lowerJsonPush(node: CodeNode, lctx: LowIRLowerContext): void;
+    lowerJson1(node: CodeNode, fnName: string, cRet: string, lctx: LowIRLowerContext): string;
+    lowerJsonGetValue(node: CodeNode, lctx: LowIRLowerContext): string;
+    jsonCaseKindFor(typeName: string): number;
+    lowerJsonCase(node: CodeNode, lctx: LowIRLowerContext): boolean;
+    lowerArraySort(node: CodeNode, lctx: LowIRLowerContext): string;
+    lowerArrayInsert(node: CodeNode, lctx: LowIRLowerContext): void;
+    emitArrayRemoveCall(node: CodeNode, lctx: LowIRLowerContext): string;
+    lowerArrayRemove(node: CodeNode, lctx: LowIRLowerContext): void;
+    lowerArrayRemoveLast(node: CodeNode, lctx: LowIRLowerContext): void;
+    lowerArrayClear(node: CodeNode, lctx: LowIRLowerContext): void;
+    lowerArrayExtract(node: CodeNode, lctx: LowIRLowerContext): string;
+    lowerTernary(node: CodeNode, lctx: LowIRLowerContext): string;
+    lowerArrayReverse(node: CodeNode, lctx: LowIRLowerContext): string;
+    toI1(v: string, lctx: LowIRLowerContext): string;
+    lowerStr2Fn(node: CodeNode, fnName: string, retType: string, lctx: LowIRLowerContext): string;
+    lowerStr3Fn(node: CodeNode, fnName: string, lctx: LowIRLowerContext): string;
+    lowerStr2IntFn(node: CodeNode, fnName: string, retType: string, lctx: LowIRLowerContext): string;
+    lowerStr1IntFn(node: CodeNode, fnName: string, retType: string, lctx: LowIRLowerContext): string;
+    lowerStr0Fn(fnName: string, lctx: LowIRLowerContext): string;
+    lowerStr1Fn(node: CodeNode, fnName: string, lctx: LowIRLowerContext): string;
+    isStringKeyMapTypeNode(node: CodeNode): boolean;
     isObjectPtrArrayTypeNode(node: CodeNode): boolean;
+    isPlainValueArrayTypeNode(node: CodeNode): boolean;
+    isDoubleArrayTypeNode(node: CodeNode): boolean;
+    arrayElemIsDouble(arrNode: CodeNode, lctx: LowIRLowerContext): boolean;
     isStringArrayTypeNode(node: CodeNode): boolean;
     emitPtrArrayNewEmpty(lctx: LowIRLowerContext, elemKind: number): string;
+    isOwnedCollectionLocal(varName: string, lctx: LowIRLowerContext): boolean;
     bindPtrArraySlot(varName: string, desc: string, lctx: LowIRLowerContext, owned: boolean): void;
     wasmCollectionRcEnabled(lctx: LowIRLowerContext): boolean;
     collectionKind(varName: string, lctx: LowIRLowerContext): string;
@@ -2321,14 +3305,30 @@ export declare class LowIRBuilderPass {
     lowerCollectionLen(node: CodeNode, lctx: LowIRLowerContext): string;
     lowerCollectionHas(node: CodeNode, lctx: LowIRLowerContext): string;
     lowerCollectionSet(node: CodeNode, lctx: LowIRLowerContext): void;
+    collectStructVars(cl: RangerAppClassDesc, ctx: RangerAppWriterContext): Array<RangerAppParamDesc>;
+    collectStructVarsInto(cl: RangerAppClassDesc, ctx: RangerAppWriterContext, out: Array<RangerAppParamDesc>, seen: {
+        [key: string]: boolean;
+    }, depth: number): void;
     lowerStruct(cl: RangerAppClassDesc, ctx: RangerAppWriterContext): void;
     lowerTypeDesc(st: LowIRStruct, target: LowIRTarget): void;
     fieldByteOffset(className: string, fieldIndex: number, module: LowIRModule): number;
+    shadowBind(varName: string, irType: string, value: string, lctx: LowIRLowerContext): string;
+    restoreShadow(varName: string, prev: string, lctx: LowIRLowerContext): void;
+    takeForceFresh(varName: string, lctx: LowIRLowerContext): boolean;
     bindSlot(varName: string, irType: string, value: string, lctx: LowIRLowerContext): void;
     loadSlot(varName: string, irType: string, lctx: LowIRLowerContext): string;
+    loadSlotRaw(varName: string, irType: string, lctx: LowIRLowerContext): string;
+    isParamName(varName: string, lctx: LowIRLowerContext): boolean;
     fieldIrTypeFor(className: string, fieldName: string): string;
     fieldIsPtrArraySlot(className: string, fieldName: string): boolean;
     fieldIsObjectSlot(className: string, fieldName: string): boolean;
+    strKeyPtr(keyNode: CodeNode, key: string, lctx: LowIRLowerContext): string;
+    smapDescFromVref(vref: string, lctx: LowIRLowerContext): string;
+    isStringMapVref(vref: string, lctx: LowIRLowerContext): boolean;
+    smapValueKind(vref: string, lctx: LowIRLowerContext): string;
+    smapValueIsInt(vref: string, lctx: LowIRLowerContext): boolean;
+    fieldIsIntMapSlot(className: string, fieldName: string): boolean;
+    fieldIsStringMapSlot(className: string, fieldName: string): boolean;
     fieldIsStringSlot(className: string, fieldName: string): boolean;
     fieldIsBufferSlot(className: string, fieldName: string): boolean;
     fieldIsBoolSlot(className: string, fieldName: string): boolean;
@@ -2342,6 +3342,12 @@ export declare class LowIRBuilderPass {
     emitPtrArrayElemSet(desc: string, idx: string, val: string, arrNode: CodeNode, lctx: LowIRLowerContext): void;
     emitFieldLoadOn(className: string, structPtr: string, fieldName: string, lctx: LowIRLowerContext): string;
     emitReleaseFieldValue(className: string, fieldName: string, rawVal: string, lctx: LowIRLowerContext): void;
+    exprCarriesFreshRef(node: CodeNode, lctx: LowIRLowerContext): boolean;
+    exprIsBorrowedPtrArrayRef(node: CodeNode, lctx: LowIRLowerContext): boolean;
+    retainAliasedArray(valNode: CodeNode, desc: string, lctx: LowIRLowerContext): void;
+    isBorrowedArrayExpr(valNode: CodeNode): boolean;
+    emitSMapRetain(desc: string, lctx: LowIRLowerContext): void;
+    emitPtrArrayRetain(desc: string, lctx: LowIRLowerContext): void;
     emitFieldStoreOn(className: string, structPtr: string, fieldName: string, value: string, lctx: LowIRLowerContext): void;
     emitFieldStoreOnEx(className: string, structPtr: string, fieldName: string, value: string, srcIsFresh: boolean, lctx: LowIRLowerContext): void;
     emitObjRetainPtr(ptr: string, lctx: LowIRLowerContext): void;
@@ -2364,26 +3370,43 @@ export declare class LowIRBuilderPass {
     initArrayFieldsInConstructor(className: string, lctx: LowIRLowerContext): void;
     structByteSize(className: string, module: LowIRModule): number;
     classHasOwnedFields(className: string): boolean;
-    lowerNewObject(className: string, argsNode: CodeNode, lctx: LowIRLowerContext): string;
+    newArgListOf(argsNode: CodeNode): CodeNode;
+    lowerNewObject(className: string, argsNodeIn: CodeNode, lctx: LowIRLowerContext): string;
     findFieldIndex(className: string, fieldName: string, module: LowIRModule): number;
+    resolvesToField(fieldName: string, lctx: LowIRLowerContext): boolean;
+    isRealConstructor(fnDesc: RangerAppFunctionDesc, className: string, appCtx: RangerAppWriterContext): boolean;
     isClassField(fieldName: string, className: string, module: LowIRModule): boolean;
     structFieldCount(className: string, module: LowIRModule): number;
     lowerFunction(fnDesc: RangerAppFunctionDesc, className: string, appCtx: RangerAppWriterContext, exportFn: boolean, isMain: boolean, isInstance: boolean): void;
     lowerSingletonAccessor(cl: RangerAppClassDesc, appCtx: RangerAppWriterContext): void;
     collectLambdas(appCtx: RangerAppWriterContext): void;
     collectMethodLambdas(m: RangerAppFunctionDesc, pt: string): void;
+    collectMethodLambdasAt(m: RangerAppFunctionDesc, pt: string, depth: number): void;
     lambdaCallSig(lam: RangerAppFunctionDesc, pt: string): string;
     addLambdaSig(sig: string): void;
     lowerLambdaBodies(appCtx: RangerAppWriterContext): void;
     lowerLambdaFunction(lam: RangerAppFunctionDesc, fnName: string, appCtx: RangerAppWriterContext): void;
     lambdaTableIndex(name: string): number;
     nodeAssignsToName(node: CodeNode, name: string): boolean;
+    boxedCellType(varName: string, lctx: LowIRLowerContext): string;
+    emitBoxCell(lctx: LowIRLowerContext): string;
+    boxInitValue(irType: string, value: string, lctx: LowIRLowerContext): string;
+    bindBoxedLocal(varName: string, irType: string, value: string, lctx: LowIRLowerContext): void;
+    isBoxableIrType(irType: string): boolean;
+    boxedStorageType(logicalType: string): string;
+    widenForBoxCell(value: string, logicalType: string, lctx: LowIRLowerContext): string;
+    emitBoxCellSized(lctx: LowIRLowerContext, byteSize: number): string;
     computeBoxedCandidates(fnDesc: RangerAppFunctionDesc, lctx: LowIRLowerContext): void;
     collectBoxedCandidates(m: RangerAppFunctionDesc, lctx: LowIRLowerContext): void;
+    irTypeBytes(irType: string, lctx: LowIRLowerContext): number;
+    lambdaOwnerClass(lam: RangerAppFunctionDesc, depth: number): string;
+    lambdaCaptureNames(node: CodeNode, lam: RangerAppFunctionDesc): Array<string>;
+    nestedCaptureNames(lam: RangerAppFunctionDesc, depth: number): Array<string>;
     computeLambdaCaptures(node: CodeNode, lam: RangerAppFunctionDesc, lctx: LowIRLowerContext): LambdaCaptureInfo;
     lowerLambdaValue(node: CodeNode, lctx: LowIRLowerContext): string;
     lowerLambdaCall(node: CodeNode, lctx: LowIRLowerContext): string;
     isOwnedObjectLocal(varName: string, lctx: LowIRLowerContext): boolean;
+    slotHoldsObject(varName: string, lctx: LowIRLowerContext): boolean;
     releaseOwnedLocal(varName: string, lctx: LowIRLowerContext): void;
     isOwnedStringLocal(varName: string, lctx: LowIRLowerContext): boolean;
     registerFreshStringTemp(tmp: string, lctx: LowIRLowerContext): void;
@@ -2396,15 +3419,25 @@ export declare class LowIRBuilderPass {
     releaseOwnedString(varName: string, lctx: LowIRLowerContext): void;
     releaseOwnedCollectionLocal(varName: string, lctx: LowIRLowerContext): void;
     emitOwnedStringInit(varName: string, valNode: CodeNode, strPtr: string, lctx: LowIRLowerContext): string;
+    isCapturedName(varName: string, lctx: LowIRLowerContext): boolean;
     emitOwnedStringReassign(varName: string, valNode: CodeNode, strPtr: string, lctx: LowIRLowerContext): string;
     strictOwnershipEnabled(lctx: LowIRLowerContext): boolean;
     emitOwnershipSummary(lctx: LowIRLowerContext): void;
     emitReleaseOwnedLocals(lctx: LowIRLowerContext): void;
+    withoutName(names: Array<string>, varName: string): Array<string>;
+    popReslots(mark: number, lctx: LowIRLowerContext): void;
     lowerBlock(block: CodeNode, lctx: LowIRLowerContext): void;
+    blockClosed(lctx: LowIRLowerContext): boolean;
+    lowerStmtList(stmts: Array<CodeNode>, lctx: LowIRLowerContext): void;
+    lowerBlockBody(block: CodeNode, lctx: LowIRLowerContext): void;
     isAssignNode(node: CodeNode): boolean;
     lowerStmt(node: CodeNode, lctx: LowIRLowerContext): void;
     lowerStmtDispatch(node: CodeNode, lctx: LowIRLowerContext): void;
+    declaredIrTypeOf(nameNode: CodeNode, lctx: LowIRLowerContext): string;
+    noteRedeclaration(varName: string, nameNode: CodeNode, lctx: LowIRLowerContext): void;
     lowerVarDef(node: CodeNode, lctx: LowIRLowerContext): void;
+    lowerVarDefBody(node: CodeNode, lctx: LowIRLowerContext): void;
+    exprIsI64Operator(node: CodeNode): boolean;
     assignTargetFieldClass(varName: string, lctx: LowIRLowerContext): string;
     lowerAssign(node: CodeNode, lctx: LowIRLowerContext): void;
     lowerReturn(node: CodeNode, lctx: LowIRLowerContext): void;
@@ -2413,9 +3446,26 @@ export declare class LowIRBuilderPass {
     unwrapCondExpr(node: CodeNode): CodeNode;
     exprProducesI1(node: CodeNode, lctx: LowIRLowerContext): boolean;
     condVref(node: CodeNode): string;
+    lowerCondOperand(node: CodeNode, lctx: LowIRLowerContext): string;
     lowerCond(node: CodeNode, lctx: LowIRLowerContext): string;
+    emitSwitchCaseTest(subj: string, subjNode: CodeNode, caseNode: CodeNode, lctx: LowIRLowerContext): string;
+    emitStrOrDefault(value: string, fallback: string, lctx: LowIRLowerContext): string;
+    lowerThrow(node: CodeNode, lctx: LowIRLowerContext): void;
+    emptyStrList(): Array<string>;
+    lowerTry(node: CodeNode, lctx: LowIRLowerContext): void;
+    guardUnwrapInTry(value: string, lctx: LowIRLowerContext): void;
+    lowerSwitch(node: CodeNode, lctx: LowIRLowerContext): void;
+    shapeCaseClassName(itemNode: CodeNode): string;
+    moduleHasTypeDesc(className: string): boolean;
+    emitShapeKindTest(val: string, caseClass: string, lctx: LowIRLowerContext): string;
+    lowerShapeIs(node: CodeNode, lctx: LowIRLowerContext): string;
+    lowerShapeCase(node: CodeNode, lctx: LowIRLowerContext): void;
     lowerIf(node: CodeNode, lctx: LowIRLowerContext): void;
+    emitLoopBodyReleases(lctx: LowIRLowerContext): void;
+    lowerLoopJump(target: string, lctx: LowIRLowerContext): void;
     lowerWhile(node: CodeNode, lctx: LowIRLowerContext): void;
+    releaseAndClearOwnedLocal(varName: string, lctx: LowIRLowerContext): void;
+    releaseAndClearOwnedCollection(varName: string, lctx: LowIRLowerContext): void;
     releaseLoopBodyOwned(ownedBefore: number, ownedStrBefore: number, ownedCollBefore: number, lctx: LowIRLowerContext): void;
     lowerExpr(node: CodeNode, lctx: LowIRLowerContext): string;
     operatorReturnsString(op: string): boolean;
@@ -2425,20 +3475,40 @@ export declare class LowIRBuilderPass {
     lowerCompareI32(aNode: CodeNode, bNode: CodeNode, pred: string, lctx: LowIRLowerContext): string;
     lowerArithF64OrI32(intKind: string, fpKind: string, node: CodeNode, lctx: LowIRLowerContext): string;
     lowerBinaryOp(opName: string, node: CodeNode, lctx: LowIRLowerContext): string;
+    lowerShortCircuit(node: CodeNode, isAnd: boolean, lctx: LowIRLowerContext): string;
     tryLowerIntrinsic(fnName: string, argsNode: CodeNode, lctx: LowIRLowerContext): string;
     finishObjectCall(rv: string): string;
     lowerCall(node: CodeNode, lctx: LowIRLowerContext): string;
+    exprRecvClassName(node: CodeNode, lctx: LowIRLowerContext): string;
     tryLowerObjectCall(node: CodeNode, lctx: LowIRLowerContext): string;
     fieldReceiverClass(recvName: string, lctx: LowIRLowerContext): string;
     callArgsNode(node: CodeNode): CodeNode;
     resolveMethodName(node: CodeNode, defaultName: string): string;
     argIrType(arg: CodeNode, lctx: LowIRLowerContext): string;
+    lowerCallArgValue(arg: CodeNode, paramIndex: number, fnDesc: RangerAppFunctionDesc, lctx: LowIRLowerContext): string;
     paramIrTypeFromDesc(paramIndex: number, fnDesc: RangerAppFunctionDesc, lctx: LowIRLowerContext): string;
+    coerceArg(value: string, wantType: string, lctx: LowIRLowerContext): string;
+    methodOwnerClass(className: string, methodName: string, lctx: LowIRLowerContext): string;
+    methodOwnerClassIn(className: string, methodName: string, appCtx: RangerAppWriterContext, depth: number): string;
+    virtualKeyOf(className: string, methodName: string): string;
+    topmostDeclaringClass(className: string, methodName: string, appCtx: RangerAppWriterContext, depth: number): string;
+    classIsLowered(cl: RangerAppClassDesc): boolean;
+    collectVirtualMethods(appCtx: RangerAppWriterContext): void;
+    classInheritsFrom(className: string, baseName: string, appCtx: RangerAppWriterContext, depth: number): boolean;
+    virtualDispatcherName(className: string, methodName: string): string;
+    hasVirtualDispatcher(className: string, methodName: string): boolean;
+    emitVirtualDispatchers(appCtx: RangerAppWriterContext): void;
+    emitOneVirtualDispatcher(top: string, meth: string, fnDesc: RangerAppFunctionDesc, cases: Array<string>, appCtx: RangerAppWriterContext): void;
+    emitDispatchTailCall(builder: LowIRBuilder, cls: string, meth: string, retType: string, argNames: Array<string>, argTypes: Array<string>): void;
     lowerInstanceCallOn(node: CodeNode, receiverName: string, recvNode: CodeNode, methodName: string, lctx: LowIRLowerContext): string;
+    registerCallObjectTemp(node: CodeNode, tmp: string, lctx: LowIRLowerContext): void;
     lowerInstanceCall(node: CodeNode, lctx: LowIRLowerContext): string;
+    calleeReceiverIsUnknown(callee: CodeNode, lctx: LowIRLowerContext): boolean;
+    moduleHasFunction(fnName: string): boolean;
     resolveCalleeName(callee: CodeNode): string;
 }
 export declare class LLVMIRWriter {
+    instrLineLen: number;
     varargNames: Array<string>;
     varargSigs: Array<string>;
     constructor();
@@ -2450,11 +3520,14 @@ export declare class LLVMIRWriter {
     hexByte(b: number): string;
     llvmEscapeCString(text: string): string;
     writeModule(module: LowIRModule, wr: CodeWriter): void;
+    writeBigStackMain(wr: CodeWriter): void;
+    writeLambdaTable(module: LowIRModule, wr: CodeWriter): void;
     writeTypeDescs(module: LowIRModule, wr: CodeWriter): void;
     writeOneTypeDesc(td: LowIRTypeDesc, wr: CodeWriter): void;
     writeStruct(st: LowIRStruct, wr: CodeWriter): void;
     writeFunction(fn: LowIRFunction, wr: CodeWriter): void;
     writeInstr(ins: LowIRInstr, wr: CodeWriter): void;
+    writeInstrBody(ins: LowIRInstr, wr: CodeWriter): void;
     writeTerminator(bb: LowIRBlock, wr: CodeWriter): void;
 }
 export declare class WATWriter {
@@ -2570,7 +3643,9 @@ export declare class LiveCompiler {
     localCall(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<boolean>;
     finishWalkNode(wr: CodeWriter): void;
     WalkNode(node: CodeNode, in_ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
+    typeNameToIdentifier(ss: string): string;
     walkCommandList(cmd: CodeNode, node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
+    isMutatingOpName(n: string): boolean;
     walkCommand(cmd: CodeNode, node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
     compile(node: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): void;
     findParamDesc(obj: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): RangerAppParamDesc | undefined;
@@ -2631,6 +3706,396 @@ export declare class CLIProgress {
     printFlag(flag: string, description: string): void;
     printSection(title: string): void;
 }
+export declare class GitSha1 {
+    constructor();
+    static mask32(): number;
+    static add32(a: number, b: number): number;
+    static not32(x: number): number;
+    static rotl(x: number, n: number): number;
+    static copyRange(data: Uint8Array, start: number, count: number): Uint8Array;
+    static ascii(data: Uint8Array, start: number, count: number): string;
+    static u32be(data: Uint8Array, i: number): number;
+    static hexDigit(d: number): string;
+    static toHex(data: Uint8Array): string;
+    static fromHex(hex: string): Uint8Array;
+    static hash(data: Uint8Array): Uint8Array;
+    static writeU32be(out: Uint8Array, i: number, v: number): void;
+    static hashHex(data: Uint8Array): string;
+    static objectId(kind: string, payload: Uint8Array): string;
+    static hexEq(a: string, b: string): boolean;
+}
+export declare class GitPkt {
+    ok: boolean;
+    err: string;
+    lines: Array<string>;
+    raw: Array<Uint8Array>;
+    isFlush: Array<boolean>;
+    constructor();
+}
+export declare class GitRef {
+    name: string;
+    sha: string;
+    peeled: string;
+    constructor();
+}
+export declare class GitAdvertisement {
+    ok: boolean;
+    err: string;
+    service: string;
+    caps: string;
+    head: string;
+    refs: Array<GitRef>;
+    constructor();
+}
+export declare class GitWant {
+    ok: boolean;
+    err: string;
+    sha: string;
+    body: Uint8Array;
+    constructor();
+}
+export declare class GitSideband {
+    ok: boolean;
+    err: string;
+    pack: Uint8Array;
+    progress: string;
+    constructor();
+}
+export declare class GitPktIO {
+    constructor();
+    static hexVal(ch: string): number;
+    static parseHex4(data: Uint8Array, at: number): number;
+    static hex4(n: number): string;
+    static encodeLine(text: string): Uint8Array;
+    static encodeFlush(): Uint8Array;
+    static parse(data: Uint8Array): GitPkt;
+    static parseAdvertisement(data: Uint8Array): GitAdvertisement;
+    static findRef(adv: GitAdvertisement, spec: string): string;
+    static hasToken(caps: string, name: string): boolean;
+    static joinBuf(parts: Array<Uint8Array>): Uint8Array;
+    static encodeDelim(): Uint8Array;
+    static buildWant(adv: GitAdvertisement, spec: string): GitWant;
+    static buildWantFetch(sha: string, deepen: number, filter: string, extras: Array<string>): GitWant;
+    static buildWantTrees(adv: GitAdvertisement, spec: string): GitWant;
+    static buildWantSha(sha: string): GitWant;
+    static buildFetchV2(sha: string, deepen: number, filter: string): GitWant;
+    static demux(data: Uint8Array): GitSideband;
+    static indexOfPack(data: Uint8Array): number;
+    static indexOfChar(s: string, code: number): number;
+    static trimNl(s: string): string;
+}
+export declare class ZipBuffer {
+    data: Uint8Array;
+    pos: number;
+    length: number;
+    constructor();
+    initWithBuffer(buf: Uint8Array): void;
+    initWithSize(size: number): void;
+    getPosition(): number;
+    setPosition(newPos: number): void;
+    seek(offset: number): void;
+    skip(count: number): void;
+    remaining(): number;
+    isEOF(): boolean;
+    readUint8(): number;
+    readUint16LE(): number;
+    readUint32LE(): number;
+    readBytes(count: number): Uint8Array;
+    readString(count: number): string;
+    peekUint8(): number;
+    peekUint32LE(): number;
+    writeUint8(value: number): void;
+    writeUint16LE(value: number): void;
+    writeUint32LE(value: number): void;
+    writeBytes(src: Uint8Array, srcOffset: number, count: number): void;
+    writeBuffer(src: Uint8Array): void;
+    writeString(s: string): void;
+    getBuffer(): Uint8Array;
+    getLength(): number;
+    findSignatureBackward(sig: number, startPos: number): number;
+}
+export declare class GrowableZipBuffer {
+    chunks: Array<Uint8Array>;
+    chunkLens: Array<number>;
+    chunkSize: number;
+    currentChunk: Uint8Array;
+    currentPos: number;
+    totalSize: number;
+    constructor();
+    setChunkSize(size: number): void;
+    allocateNewChunk(): void;
+    writeUint8(value: number): void;
+    writeUint16LE(value: number): void;
+    writeUint32LE(value: number): void;
+    writeBytes(src: Uint8Array, srcOffset: number, count: number): void;
+    writeBuffer(src: Uint8Array): void;
+    writeString(s: string): void;
+    getSize(): number;
+    toBuffer(): Uint8Array;
+}
+export declare class InflateHuffmanTable {
+    counts: Array<number>;
+    symbols: Array<number>;
+    maxBits: number;
+    constructor();
+    build(lengths: Array<number>, numSymbols: number): void;
+    decode(reader: InflateBitReader): number;
+}
+export declare class InflateBitReader {
+    data: Uint8Array;
+    bytePos: number;
+    bitPos: number;
+    currentByte: number;
+    dataLength: number;
+    constructor();
+    init(buf: Uint8Array, offset: number, length: number): void;
+    readBit(): number;
+    readBits(count: number): number;
+    alignToByte(): void;
+    readByte(): number;
+    readUint16LE(): number;
+    getBytePosition(): number;
+    isEOF(): boolean;
+}
+export declare class Inflate {
+    input: Uint8Array;
+    reader: InflateBitReader;
+    outBuf: Uint8Array;
+    outLen: number;
+    outCap: number;
+    fixedLitLen: InflateHuffmanTable;
+    fixedDist: InflateHuffmanTable;
+    fixedTablesBuilt: boolean;
+    lengthBase: Array<number>;
+    lengthExtra: Array<number>;
+    distBase: Array<number>;
+    distExtra: Array<number>;
+    constructor();
+    resetOutput(hint: number): void;
+    ensureCapacity(extra: number): void;
+    pushByte(b: number): void;
+    finalOutput(): Uint8Array;
+    buildLengthDistTables(): void;
+    buildFixedTables(): void;
+    decompress(data: Uint8Array): Uint8Array;
+    decompressFrom(data: Uint8Array, offset: number): Uint8Array;
+    inputPos(): number;
+    decompressStored(): void;
+    decompressHuffman(litLenTable: InflateHuffmanTable, distTable: InflateHuffmanTable): void;
+    decompressDynamic(): void;
+    copyFromOutput(distance: number, length: number): void;
+}
+export declare class GitZlib {
+    ok: boolean;
+    err: string;
+    nextPos: number;
+    constructor();
+    inflateAt(data: Uint8Array, offset: number): Uint8Array;
+    inflate(data: Uint8Array): Uint8Array;
+}
+export declare class GitObj {
+    kind: number;
+    sha: string;
+    data: Uint8Array;
+    packOff: number;
+    resolved: boolean;
+    delta: boolean;
+    baseOff: number;
+    baseSha: string;
+    constructor();
+}
+export declare class GitPack {
+    ok: boolean;
+    err: string;
+    version: number;
+    count: number;
+    objects: Array<GitObj>;
+    bySha: {
+        [key: string]: GitObj;
+    };
+    byOff: {
+        [key: number]: GitObj;
+    };
+    constructor();
+}
+export declare class GitDelta {
+    constructor();
+    static varInt(data: Uint8Array, pos: Array<number>): number;
+    static apply(src: Uint8Array, delta: Uint8Array): Uint8Array;
+}
+export declare class GitPackIO {
+    constructor();
+    static kindName(kind: number): string;
+    static parse(data: Uint8Array): GitPack;
+    static resolveDeltas(pack: GitPack): void;
+    static lookup(pack: GitPack, sha: string): GitObj | undefined;
+    static merge(a: GitPack, b: GitPack): GitPack;
+}
+export declare class GitEntry {
+    name: string;
+    sha: string;
+    isTree: boolean;
+    mode: string;
+    constructor();
+}
+export declare class GitFile {
+    path: string;
+    data: Uint8Array;
+    constructor();
+}
+export declare class GitTree {
+    sha: string;
+    entries: Array<GitEntry>;
+    constructor();
+}
+export declare class GitMem {
+    files: Array<GitFile>;
+    paths: Array<string>;
+    byPath: {
+        [key: string]: GitFile;
+    };
+    constructor();
+}
+export declare class GitStore {
+    pack: GitPack;
+    ok: boolean;
+    err: string;
+    constructor(p: GitPack);
+    takeObj(sha: string): GitObj | undefined;
+    parseTree(payload: Uint8Array): GitTree;
+    commitTree(payload: Uint8Array): string;
+    checkout(sha: string, subdir: string): GitMem;
+    walk(mem: GitMem, treeSha: string, prefix: string, want: string): void;
+    mayEnter(path: string, want: string): boolean;
+    splitSegs(path: string): Array<string>;
+    asTreeSha(sha: string): string;
+    treeAt(sha: string, subdir: string): string;
+    underSubdir(path: string, want: string): boolean;
+    stripSubdir(path: string, want: string): string;
+    baseName(path: string): string;
+    writeDisk(mem: GitMem, root: string): void;
+    dirOf(path: string): string;
+    splitPath(path: string): Array<string>;
+    fileText(mem: GitMem, path: string): string;
+}
+export declare class PkgVal {
+    kind: string;
+    str: string;
+    num: number;
+    flag: boolean;
+    keys: Array<string>;
+    vals: Array<PkgVal>;
+    constructor();
+}
+export declare class PkgJson {
+    text: string;
+    i: number;
+    n: number;
+    ok: boolean;
+    err: string;
+    constructor();
+    parse(src: string): PkgVal;
+    skip(): void;
+    value(): PkgVal;
+    object(): PkgVal;
+    str(): string;
+    num(): number;
+    static child(obj: PkgVal, key: string): PkgVal | undefined;
+    static strOf(obj: PkgVal, key: string): string;
+    static intOf(obj: PkgVal, key: string): number;
+}
+export declare class PkgDep {
+    name: string;
+    path: string;
+    git: string;
+    rev: string;
+    tag: string;
+    subdir: string;
+    constructor();
+}
+export declare class PkgManifest {
+    name: string;
+    version: string;
+    entry: string;
+    license: string;
+    deps: Array<PkgDep>;
+    ok: boolean;
+    err: string;
+    constructor();
+}
+export declare class PkgLockEnt {
+    name: string;
+    path: string;
+    git: string;
+    rev: string;
+    subdir: string;
+    sha256: string;
+    constructor();
+}
+export declare class PkgLock {
+    lockVersion: number;
+    packages: Array<PkgLockEnt>;
+    ok: boolean;
+    err: string;
+    constructor();
+}
+export declare class PkgManifestIO {
+    constructor();
+    static load(src: string): PkgManifest;
+    static loadLock(src: string): PkgLock;
+    static escape(s: string): string;
+    static dumpLock(lock: PkgLock): string;
+    static dumpManifest(m: PkgManifest): string;
+}
+export declare class PkgCache {
+    constructor();
+    static lessStr(a: string, b: string): boolean;
+    static hashMem(mem: GitMem): string;
+    static put(mem: GitMem, cacheRoot: string): string;
+    static lockFor(name: string, git: string, rev: string, subdir: string, hash: string): PkgLockEnt;
+}
+export declare class PkgFetchWork {
+    dir: string;
+    man: PkgManifest;
+    git: string;
+    rev: string;
+    subdir: string;
+    fromGit: boolean;
+    constructor();
+}
+export declare class PkgFetch {
+    ok: boolean;
+    err: string;
+    cacheRoot: string;
+    cacheOverride: string;
+    rootDir: string;
+    tmpRoot: string;
+    httpTool: string;
+    vendor: boolean;
+    frozen: boolean;
+    force: boolean;
+    lock: PkgLock;
+    previous: PkgLock;
+    seen: {
+        [key: string]: boolean;
+    };
+    lastRev: string;
+    lastMem: GitMem;
+    constructor();
+    runHttp(args: Array<string>): boolean;
+    advertise(url: string, dest: string): boolean;
+    post(url: string, body: string, dest: string): boolean;
+    fetchInto(name: string, url: string, wantRev: string, subdir: string): string;
+    storeMem(mem: GitMem): string;
+    cachedFor(env: InputEnv, name: string, git: string, rev: string, subdir: string): string;
+    install(env: InputEnv, manDir: string): Promise<boolean>;
+    oneDep(env: InputEnv, pending: Array<PkgFetchWork>, w: PkgFetchWork, d: PkgDep): Promise<boolean>;
+    static findHttpTool(env: InputEnv): string;
+    static splitPath(path: string): Array<string>;
+    static readBytes(path: string): Uint8Array;
+    static writeBytes(path: string, data: Uint8Array): void;
+    static loadPack(path: string): GitPack;
+}
 export declare class RangerDocGenerator {
     constructor();
     writeTypeDef(item: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
@@ -2648,6 +4113,12 @@ export declare class StaticAnalyzer {
     mutatingOps: {
         [key: string]: boolean;
     };
+    own_call_params: Array<RangerAppParamDesc>;
+    own_call_callees: Array<RangerAppFunctionDesc>;
+    own_call_indexes: Array<number>;
+    rss_edge_src: Array<RangerAppParamDesc>;
+    rss_edge_dst: Array<RangerAppParamDesc>;
+    rss_in_place: Array<RangerAppParamDesc>;
     constructor();
     initMutatingOps(): void;
     isMutatingOperator(opName: string): boolean;
@@ -2655,6 +4126,8 @@ export declare class StaticAnalyzer {
     getRootVarName(node: CodeNode): string;
     isMemberAccess(node: CodeNode): boolean;
     getMemberPath(node: CodeNode): string;
+    isValuePassedType(t: number): boolean;
+    isValuePassedCollection(typeNode: CodeNode): boolean;
     markVarAsMutated(varName: string, fnCtx: RangerAppWriterContext): void;
     analyzeVarDef(node: CodeNode): void;
     walkForFieldAssignments(node: CodeNode, fnCtx: RangerAppWriterContext): void;
@@ -2678,6 +4151,7 @@ export declare class StaticAnalyzer {
     analyzeTransitiveMutBorrow(fn: RangerAppFunctionDesc, changedParams: Array<string>): void;
     analyzeClassTransitiveMutBorrow(cl: RangerAppClassDesc, changedParams: Array<string>): void;
     checkDirectSelfMutation(fn: RangerAppFunctionDesc): boolean;
+    writeTargetIsSelf(target: CodeNode): boolean;
     nodeDirectlyMutatesSelf(node: CodeNode): boolean;
     analyzeMethodMutation(fn: RangerAppFunctionDesc): boolean;
     checkTransitiveMutation(node: CodeNode, fn: RangerAppFunctionDesc): boolean;
@@ -2692,11 +4166,58 @@ export declare class StaticAnalyzer {
     isPrimitiveTypeName(name: string): boolean;
     isHeapOwnedParam(p: RangerAppParamDesc): boolean;
     recordEscape(valueName: string, ownerPath: string, via: string, fnCtx: RangerAppWriterContext): void;
-    walkForEscapes(node: CodeNode, fnCtx: RangerAppWriterContext): void;
+    escapeValueName(node: CodeNode): string;
+    aliasRootOf(name: string, aliasNames: Array<string>, aliasRoots: Array<string>): string;
+    recordEscapeAliased(valueName: string, ownerPath: string, via: string, fnCtx: RangerAppWriterContext, aliasNames: Array<string>, aliasRoots: Array<string>): void;
+    callArgParam(arg: CodeNode, fnCtx: RangerAppWriterContext, aliasNames: Array<string>, aliasRoots: Array<string>): RangerAppParamDesc;
+    markCallArgsResolved(argsNode: CodeNode, callee: RangerAppFunctionDesc, fnCtx: RangerAppWriterContext, aliasNames: Array<string>, aliasRoots: Array<string>): void;
+    markCallArgsUnresolved(argsNode: CodeNode, fnCtx: RangerAppWriterContext, aliasNames: Array<string>, aliasRoots: Array<string>): void;
+    collectCallArgEscapes(node: CodeNode, fnCtx: RangerAppWriterContext, aliasNames: Array<string>, aliasRoots: Array<string>): void;
+    walkForEscapes(node: CodeNode, fnCtx: RangerAppWriterContext, aliasNames: Array<string>, aliasRoots: Array<string>): void;
     ownerSuffix(param: RangerAppParamDesc): string;
-    finalizeOwnership(fn: RangerAppFunctionDesc, strict: boolean): void;
-    analyzeOwnership(fn: RangerAppFunctionDesc, strict: boolean): void;
-    analyzeOwnershipClass(cl: RangerAppClassDesc, strict: boolean): void;
+    fnIsPure(fn: RangerAppFunctionDesc): boolean;
+    classifyOwnership(fn: RangerAppFunctionDesc): void;
+    resolveCallEscapes(): void;
+    reportOwnership(fn: RangerAppFunctionDesc): void;
+    reportOwnershipClass(cl: RangerAppClassDesc): void;
+    analyzeOwnership(fn: RangerAppFunctionDesc): void;
+    analyzeOwnershipClass(cl: RangerAppClassDesc): void;
+    unionMemberIsScalarOnly(typeName: string): boolean;
+    markClassShared(typeName: string, reason: string): void;
+    classNameOfDesc(p: RangerAppParamDesc): string;
+    sharedClassNameOf(name: string, fnCtx: RangerAppWriterContext): string;
+    nodeClassNameOf(node: CodeNode, fnCtx: RangerAppWriterContext): string;
+    collectMutatedNames(node: CodeNode, names: Array<string>): void;
+    computeSharingMutations(): void;
+    markSharingMutations(fn: RangerAppFunctionDesc): boolean;
+    nameIn(name: string, names: Array<string>): boolean;
+    varIsMutated(name: string, fnCtx: RangerAppWriterContext, mutated: Array<string>): boolean;
+    readsStoredObject(node: CodeNode): boolean;
+    walkForSharing(node: CodeNode, fnCtx: RangerAppWriterContext, fnName: string, mutated: Array<string>): void;
+    markIdenticalOperandsShared(node: CodeNode, fnName: string): void;
+    analyzeClassSharingFn(fn: RangerAppFunctionDesc): void;
+    analyzeClassSharing(): void;
+    reportClassSharing(): void;
+    sharedClassOfDesc(p: RangerAppParamDesc): string;
+    markDescRcWrap(p: RangerAppParamDesc): void;
+    walkForSharedLocals(node: CodeNode): void;
+    fnUsesThisValue(fn: RangerAppFunctionDesc): Promise<boolean>;
+    fnSelfCallsNeedy(fn: RangerAppFunctionDesc): Promise<boolean>;
+    computeSelfRcNeeds(): Promise<void>;
+    markLambdaParamsRec(fn: RangerAppFunctionDesc): void;
+    applySharedClassRcWrap(): void;
+    rustParamHasRefSemantics(param: RangerAppParamDesc): boolean;
+    rustBorrowedObjectParam(cl: RangerAppClassDesc, param: RangerAppParamDesc): boolean;
+    rssPlainStringDesc(p: RangerAppParamDesc): boolean;
+    rssResolveDesc(node: CodeNode): RangerAppParamDesc;
+    rssSourceKind(value: CodeNode): number;
+    rssRecordAssign(target: RangerAppParamDesc, value: CodeNode): void;
+    rssLocalCandidate(p: RangerAppParamDesc): boolean;
+    rssWalkBody(node: CodeNode): void;
+    rssWalkFn(fn: RangerAppFunctionDesc): void;
+    analyzeRustStaticStrings(): void;
+    applyOwnershipToRustBorrowsFn(cl: RangerAppClassDesc, fn: RangerAppFunctionDesc): void;
+    applyOwnershipToRustBorrows(): void;
     analyzeOwnershipAll(strict: boolean): void;
     analyzeAll(): void;
 }
@@ -2734,6 +4255,7 @@ export declare class VirtualCompiler {
     fillStr(cnt: number): string;
     detectLanguageFromExtension(filename: string): string;
     isTypeScriptExtension(filename: string): boolean;
+    runInstall(env: InputEnv, params: CmdParams, cli: CLIProgress): Promise<boolean>;
     run(env: InputEnv): Promise<CompilerResults>;
     static create_env(): Promise<void>;
     static displayCompilerErrorsWithCLI(appCtx: RangerAppWriterContext, cli: CLIProgress): void;
@@ -2744,4 +4266,3 @@ export declare class CompilerInterface {
     constructor();
     static create_env(): InputEnv;
 }
-export {};