gelang 0.1.0

package/python/pyeffic/emitters/cpp.py

@@ -0,0 +1,266 @@
+"""C++ backend spec + program assembly."""
+from __future__ import annotations
+
+import ast
+
+from .base import Emitter, Spec
+from ..analyzer import FuncUnit
+
+SPEC = Spec(
+    name="cpp",
+    types={"int": "int64_t", "float": "double", "bool": "bool", "str": "std::string", "None": "void"},
+    list_type="std::vector<{T}>",
+    list_param_type="std::vector<int64_t>&",
+    list_elem_type="int64_t",
+    borrow_list_arg=False,
+    range_call="for_range({lo}, {hi})",
+    range_step_call="for_range({lo}, {hi}, {step})",
+    len_call="static_cast<int64_t>({x}.size())",
+    list_len="static_cast<int64_t>({x}.size())",
+    print_int='std::cout << ({v}) << std::endl',
+    print_float='std::cout << ({v}) << std::endl',
+    print_str='std::cout << ({v}) << std::endl',
+    print_bool='std::cout << ({v}) << std::endl',
+    print_generic='std::cout << ({v}) << std::endl',
+    int_cast="static_cast<int64_t>({x})",
+    float_cast="static_cast<double>({x})",
+    float_div="(static_cast<double>({l}) / static_cast<double>({r}))",
+    floor_div="({l} / {r})",
+    sum_call="std::accumulate({it}.begin(), {it}.end(), 0LL)",
+    abs_int="std::abs({x})",
+    abs_float="std::fabs({x})",
+    min_call="*std::min_element({it}.begin(), {it}.end())",
+    max_call="*std::max_element({it}.begin(), {it}.end())",
+    pow_call="std::pow({l}, {r})",
+    append_call="{x}.push_back({v})",
+    index_call="{x}[{i}]",
+    comment="//",
+    fn_template="{sig} {{\n{body}\n}}",
+    main_template="",
+    ffi_prefix='extern "C" ',
+    str_concat="{l} + {r}",
+    str_len="static_cast<int64_t>({x}.length())",
+    str_index="static_cast<int64_t>({x}[{i}])",
+    str_slice="{x}.substr({start}, {len})",
+    str_slice_start="{x}.substr({start})",
+    str_slice_end="{x}.substr(0, {end})",
+    list_concat="[&]() {{ auto t = {l}; auto s = {r}; t.insert(t.end(), s.begin(), s.end()); return t; }}()",
+    foreach_template="for (auto {var} : {iter})",
+    try_template="try {{\n{body}\n}} catch (...) {{\n{handler}\n}}",
+    struct_template="struct {name} {{\n{fields}\n}};",
+    struct_field_template="    {type} {name};",
+    struct_new_template="{name} {name}_new({params}) {{\n{body}\n}}",
+    dict_type="std::map<std::string, {V}>",
+    dict_get="{d}.at({k})",
+    dict_set="{d}[{k}] = {v}",
+    dict_contains="({d}.find({k}) != {d}.end())",
+    tuple_type="std::tuple<{T}, {T}>",
+    tuple_get="std::get<{i}>({t})",
+)
+
+
+class CppEmitter(Emitter):
+    def for_loop(self, node, ind):  # type: ignore[override]
+        var = node.target.id if isinstance(node.target, ast.Name) else "_"
+        it = node.iter
+        if isinstance(it, ast.Call) and getattr(it.func, "id", None) == "range":
+            args = it.args
+            if len(args) == 1:
+                lo, hi, step = "0", self.expr(args[0]), "1"
+            elif len(args) == 2:
+                lo, hi, step = self.expr(args[0]), self.expr(args[1]), "1"
+            else:
+                lo, hi, step = self.expr(args[0]), self.expr(args[1]), self.expr(args[2])
+            self.var_types[var] = "int"
+            if step == "1":
+                self.lines.append(f"{ind}for (int64_t {var} = {lo}; {var} < {hi}; ++{var}) {{")
+            else:
+                self.lines.append(
+                    f"{ind}for (int64_t {var} = {lo}; {var} < {hi}; {var} += {step}) {{"
+                )
+        else:
+            iter_s = self.expr(it)
+            self.var_types[var] = "int"
+            self.lines.append(f"{ind}for (auto& {var} : {iter_s}) {{")
+        self.indent_lvl += 1
+        for s in node.body:
+            self.stmt(s)
+        self.indent_lvl -= 1
+        self.lines.append(f"{ind}}}")
+
+
+def _entry_unit(units: list[FuncUnit], entry: str | None) -> FuncUnit:
+    if entry:
+        for u in units:
+            if u.name == entry:
+                return u
+    for u in units:
+        if u.name == "main":
+            return u
+    return units[0]
+
+
+def _emit_structs_cpp(classes: list) -> str:
+    """Emit C++ struct definitions and constructors for ClassUnits."""
+    out: list[str] = []
+    for cls in classes:
+        fields_str = ""
+        for fname, ftype in cls.fields:
+            nt = SPEC.types.get(ftype, SPEC.types.get("float"))
+            if ftype == "list":
+                nt = "std::vector<int64_t>"
+            elif ftype not in SPEC.types:
+                nt = "double"
+            fields_str += f"    {nt} {fname};\n"
+        out.append(f"struct {cls.name} {{\n{fields_str}}};\n")
+        # constructor
+        if cls.constructor_params:
+            params_str = ", ".join(
+                f"{SPEC.types.get(ptype, 'double')} {pname}"
+                for pname, ptype in cls.constructor_params
+            )
+            init_list = ", ".join(fname for fname, _ in cls.constructor_params)
+            out.append(f"{cls.name} {cls.name}_new({params_str}) {{\n"
+                        f"    return {cls.name}{{{init_list}}};\n}}\n")
+        else:
+            out.append(f"{cls.name} {cls.name}_new() {{\n"
+                        f"    return {cls.name}{{}};\n}}\n")
+    return "\n".join(out)
+
+
+def emit_cpp(units: list[FuncUnit], entry: str | None,
+             library_mode: bool = False,
+             extern_fns: list[FuncUnit] | None = None,
+             classes: list | None = None,
+             constants: dict | None = None,
+             preamble: dict | None = None) -> tuple[str, dict[str, str]]:
+    emitter = CppEmitter(SPEC)
+    emitter.library_mode = library_mode
+    emitter.constants = constants or {}
+    # in multi-backend mode, force extern "C" on all functions so Rust can link
+    emitter.force_extern_c = extern_fns is not None
+    emitted: dict[str, str] = {}
+    fns: list[str] = []
+
+    # register class names
+    if classes:
+        for cls in classes:
+            emitter.class_names.add(cls.name)
+            emitter.class_fields[cls.name] = cls.fields
+            emitter.class_bases[cls.name] = cls.bases
+            emitter.class_properties[cls.name] = cls.properties
+            emitter.class_static_methods[cls.name] = cls.static_methods
+
+    prelude = (
+        "#include <cstdint>\n"
+        "#include <iostream>\n"
+        "#include <vector>\n"
+        "#include <map>\n"
+        "#include <tuple>\n"
+        "#include <cmath>\n"
+        "#include <numeric>\n"
+        "#include <algorithm>\n"
+        "#include <string>\n\n"
+        "using std::cout;\n"
+        "using std::endl;\n\n"
+    )
+
+    # emit extern "C" declarations for cross-backend calls (Rust functions)
+    if extern_fns:
+        decls = []
+        for u in extern_fns:
+            if not u.supported:
+                continue
+            params = ", ".join(
+                f"{'const std::vector<int64_t>&' if ptype == 'list' else SPEC.types.get(ptype, 'double')} {pname}"
+                for pname, ptype in u.params)
+            ret = SPEC.types.get(u.ret_type, "void") if u.ret_type != "None" else "void"
+            decls.append(f'extern "C" {ret} {u.name}({params});')
+        prelude += "\n// cross-backend declarations (Rust functions called from C++)\n" + "\n".join(decls) + "\n\n"
+
+    # emit struct definitions
+    if classes:
+        struct_code = _emit_structs_cpp(classes)
+        if struct_code:
+            prelude += struct_code + "\n"
+
+    # build function return type lookup for type inference
+    for u in units:
+        if u.supported:
+            emitter.func_return_types[u.name] = u.ret_type
+
+    # emit forward declarations so functions can call each other regardless of order
+    # (also needed before preamble so preamble code can call GE-compiled functions)
+    forward_decls: list[str] = []
+    for u in units:
+        if not u.supported or (u.is_method and u.name.endswith(".__init__")):
+            continue
+        params = ", ".join(
+            f"{'std::vector<int64_t>' if ptype == 'list' else SPEC.types.get(ptype, 'double')} {pname}"
+            for pname, ptype in u.params
+        ) or ""
+        # main always returns int in C++; list returns std::vector<int64_t>
+        if u.name == "main":
+            ret = "int"
+        elif u.ret_type == "None":
+            ret = "void"
+        elif u.ret_type == "list":
+            ret = "std::vector<int64_t>"
+        else:
+            ret = SPEC.types.get(u.ret_type, "void")
+        if emitter.force_extern_c:
+            forward_decls.append(f'extern "C" {ret} {u.name}({params});')
+        else:
+            forward_decls.append(f'{ret} {u.name}({params});')
+    if forward_decls:
+        prelude += "\n// forward declarations\n" + "\n".join(forward_decls) + "\n\n"
+
+    # inject user preamble (file-scope code from ge_preamble("cpp", "..."))
+    # (after forward declarations so preamble can call GE-compiled functions)
+    if preamble and "cpp" in preamble:
+        prelude += "\n// === user preamble (ge_preamble) ===\n" + preamble["cpp"] + "\n\n"
+
+    if library_mode:
+        for u in units:
+            if not u.supported:
+                continue
+            if u.is_method and u.name.endswith(".__init__"):
+                continue
+            code = emitter.emit(u)
+            if emitter.unsupported_emissions:
+                u.supported = False
+                u.unsupported_reasons.extend(emitter.unsupported_emissions)
+                continue
+            emitted[u.name] = code
+            fns.append(code)
+        return prelude + "\n".join(fns) + "\n", emitted
+
+    entry_u = _entry_unit(units, entry)
+    for u in units:
+        if u.is_method and u.name.endswith(".__init__"):
+            continue
+        if u is entry_u and u.name == "main":
+            code = emitter.emit(u, sig_override="int main()", body_suffix="return 0;")
+        else:
+            code = emitter.emit(u)
+        if emitter.unsupported_emissions:
+            u.supported = False
+            u.unsupported_reasons.extend(emitter.unsupported_emissions)
+            continue
+        emitted[u.name] = code
+        fns.append(code)
+
+    if entry_u.name != "main":
+        if entry_u.ret_type == "None":
+            wrapper = "int main() {\n    " + entry_u.name + "();\n    return 0;\n}\n"
+        else:
+            wrapper = "int main() {\n    auto _r = " + entry_u.name + "();\n    (void)_r;\n    return 0;\n}\n"
+        fns.append(wrapper)
+
+    program = prelude + "\n".join(fns) + "\n"
+    # inject stdlib runtime after the prelude so #include <cmath> is in scope
+    from ..stdlib import get_runtime
+    runtime = get_runtime("cpp")
+    if runtime:
+        program = prelude + runtime + "\n" + "\n".join(fns) + "\n"
+    return program, emitted

package/python/pyeffic/emitters/csharp.py

@@ -0,0 +1,342 @@
+"""C# backend spec + program assembly.
+
+Compiles via .NET NativeAOT to a native shared library that exports C ABI
+functions via [UnmanagedCallersOnly]. Interops with Rust/C++/Zig/Go through
+the C ABI boundary.
+"""
+from __future__ import annotations
+
+import ast
+
+from .base import Emitter, Spec
+from ..analyzer import FuncUnit
+
+SPEC = Spec(
+    name="csharp",
+    types={"int": "long", "float": "double", "bool": "bool", "str": "string", "None": "void"},
+    list_type="List<long>",
+    list_param_type="List<long>",
+    list_elem_type="long",
+    borrow_list_arg=False,
+    range_call="({lo}..{hi})",
+    range_step_call="({lo}..{hi}).Step({step})",
+    len_call="{x}.Length",
+    list_len="{x}.Count",
+    print_int='Console.WriteLine({v})',
+    print_float='Console.WriteLine({v})',
+    print_str='Console.WriteLine({v})',
+    print_bool='Console.WriteLine({v})',
+    print_generic='Console.WriteLine({v})',
+    int_cast="(long)({x})",
+    float_cast="(double)({x})",
+    float_div="((double)({l}) / (double)({r}))",
+    floor_div="({l} / {r})",
+    sum_call="{it}.Sum()",
+    abs_int="Math.Abs({x})",
+    abs_float="Math.Abs({x})",
+    min_call="{it}.Min()",
+    max_call="{it}.Max()",
+    pow_call="Math.Pow({l}, {r})",
+    append_call="{x}.Add({v})",
+    index_call="{x}[(int)({i})]",
+    comment="//",
+    fn_template="{sig}\n{{\n{body}\n}}",
+    main_template="",
+    ffi_prefix="[UnmanagedCallersOnly]\npublic static ",
+    indent="    ",
+    str_concat="{l} + {r}",
+    str_len="{x}.Length",
+    str_index="(long)({x}[{i}])",
+    str_slice="{x}.Substring({start}, {len})",
+    str_slice_start="{x}.Substring({start})",
+    str_slice_end="{x}.Substring(0, {end})",
+    list_concat="new List<long>({l}).Concat({r}).ToList()",
+    foreach_template="foreach (var {var} in {iter})",
+    try_template="try {{\n{body}\n}} catch {{\n{handler}\n}}",
+    struct_template="struct {name} {{\n{fields}\n}}",
+    struct_field_template="    public {type} {name};",
+    struct_new_template="static {name} {name}_New({params}) {{\n{body}\n}}",
+    dict_type="Dictionary<string, {V}>",
+    dict_get="{d}[{k}]",
+    dict_set="{d}[{k}] = {v}",
+    dict_contains="{d}.ContainsKey({k})",
+    tuple_type="({T}, {T})",
+    tuple_get="{t}.Item{i1}",
+)
+
+
+class CSharpEmitter(Emitter):
+    # C# reserved keywords that need @ prefix when used as identifiers
+    _KEYWORDS = {"abstract", "as", "base", "bool", "break", "byte", "case",
+                 "catch", "char", "checked", "class", "const", "continue",
+                 "decimal", "default", "delegate", "do", "double", "else",
+                 "enum", "event", "explicit", "extern", "false", "finally",
+                 "fixed", "float", "for", "foreach", "goto", "if", "implicit",
+                 "in", "int", "interface", "internal", "is", "lock", "long",
+                 "namespace", "new", "null", "object", "operator", "out",
+                 "override", "params", "private", "protected", "public",
+                 "readonly", "ref", "return", "sbyte", "sealed", "short",
+                 "sizeof", "stackalloc", "static", "string", "struct",
+                 "switch", "this", "throw", "true", "try", "typeof", "uint",
+                 "ulong", "unchecked", "unsafe", "ushort", "using",
+                 "virtual", "void", "volatile", "while"}
+
+    def _esc(self, name: str) -> str:
+        if name in self._KEYWORDS:
+            return "@" + name
+        return name
+
+    def _ident(self, name: str) -> str:
+        """Escape C# reserved words (e.g. a GE parameter named `base`)."""
+        return self._esc(name)
+
+    # note: function names are renamed in the shared IR (pyeffic.idents) so
+    # cross-backend symbols agree; _ident only covers locals and parameters.
+
+    def for_loop(self, node, ind):  # type: ignore[override]
+        var = node.target.id if isinstance(node.target, ast.Name) else "_"
+        it = node.iter
+        if isinstance(it, ast.Call) and getattr(it.func, "id", None) == "range":
+            args = it.args
+            if len(args) == 1:
+                lo, hi, step = "0", self.expr(args[0]), "1"
+            elif len(args) == 2:
+                lo, hi, step = self.expr(args[0]), self.expr(args[1]), "1"
+            else:
+                lo, hi, step = self.expr(args[0]), self.expr(args[1]), self.expr(args[2])
+            self.var_types[var] = "int"
+            self.lines.append(f"{ind}for (long {var} = {lo}; {var} < {hi}; {var}++) {{")
+        else:
+            iter_s = self.expr(it)
+            self.var_types[var] = "long"
+            self.lines.append(f"{ind}foreach (var {var} in {iter_s}) {{")
+        self.indent_lvl += 1
+        for s in node.body:
+            self.stmt(s)
+        self.indent_lvl -= 1
+        self.lines.append(f"{ind}}}")
+
+    def signature(self, unit: FuncUnit) -> str:
+        emit_name = unit.name.replace(".", "_")
+        params = []
+        for pname, ptype in unit.params:
+            nt = self.param_native_type(ptype)
+            params.append(f"{nt} {self._ident(pname)}")
+        ret = self.py_to_native(unit.ret_type) if unit.ret_type != "None" else "void"
+        param_str = ", ".join(params)
+        base_sig = f"static {ret} {emit_name}({param_str})"
+        # add C ABI export prefix in library mode for FFI-exported functions
+        if self.library_mode and getattr(unit, "ffi_export", False) and self.spec.ffi_prefix:
+            return self.spec.ffi_prefix + base_sig
+        return base_sig
+
+    def stmt(self, node):  # type: ignore[override]
+        # escape C# keywords in variable declarations
+        if isinstance(node, ast.AnnAssign) and isinstance(node.target, ast.Name):
+            name = self._esc(node.target.id)
+            ann_type = self._ann_type(node.annotation)
+            nt = self.py_to_native(ann_type)
+            if node.value is not None:
+                val = self.expr(node.value)
+                self.lines.append(f"{self.spec.indent * self.indent_lvl}{nt} {name} = {val};")
+                self.var_types[node.target.id] = ann_type
+                self.declared.add(node.target.id)
+            else:
+                self.lines.append(f"{self.spec.indent * self.indent_lvl}{nt} {name};")
+                self.var_types[node.target.id] = ann_type
+                self.declared.add(node.target.id)
+            return
+        super().stmt(node)
+
+    def _try_stmt(self, node, ind):
+        """C# try/catch syntax."""
+        self.lines.append(f"{ind}try {{")
+        self.indent_lvl += 1
+        for s in node.body:
+            self.stmt(s)
+        self.indent_lvl -= 1
+        if node.handlers:
+            self.lines.append(f"{ind}}} catch {{")
+            self.indent_lvl += 1
+            for s in node.handlers[0].body:
+                self.stmt(s)
+            self.indent_lvl -= 1
+            self.lines.append(f"{ind}}}")
+        else:
+            self.lines.append(f"{ind}}} catch {{")
+            self.lines.append(f"{ind}}}")
+        if node.finalbody:
+            self.lines.append(f"{ind}finally {{")
+            self.indent_lvl += 1
+            for s in node.finalbody:
+                self.stmt(s)
+            self.indent_lvl -= 1
+            self.lines.append(f"{ind}}}")
+        if isinstance(node, ast.Name) and node.id in self._KEYWORDS:
+            return "@" + node.id
+        return super().expr(node)
+
+
+def _entry_unit(units: list[FuncUnit], entry: str | None) -> FuncUnit:
+    if entry:
+        for u in units:
+            if u.name == entry:
+                return u
+    for u in units:
+        if u.name == "main":
+            return u
+    return units[0]
+
+
+def _emit_structs_csharp(classes: list) -> str:
+    """Emit C# struct definitions and constructors for ClassUnits."""
+    out: list[str] = []
+    for cls in classes:
+        fields_str = ""
+        for fname, ftype in cls.fields:
+            nt = SPEC.types.get(ftype, SPEC.types.get("float"))
+            if ftype == "list":
+                nt = "long[]"
+            fields_str += f"    public {nt} {fname};\n"
+        out.append(f"struct {cls.name} {{\n{fields_str}}}\n")
+        if cls.constructor_params:
+            params_str = ", ".join(
+                f"{SPEC.types.get(ptype, 'double')} {pname}"
+                for pname, ptype in cls.constructor_params
+            )
+            init_lines = "\n".join(
+                f"            {fname} = {fname}," for fname, _ in cls.constructor_params
+            )
+            out.append(f"static {cls.name} {cls.name}_new({params_str}) {{\n"
+                        f"    return new {cls.name} {{\n{init_lines}\n    }};\n}}\n")
+        else:
+            out.append(f"static {cls.name} {cls.name}_new() {{\n"
+                        f"    return new {cls.name}();\n}}\n")
+    return "\n".join(out)
+
+
+def emit_csharp(units: list[FuncUnit], entry: str | None,
+                library_mode: bool = False,
+                extern_fns: list[FuncUnit] | None = None,
+                classes: list | None = None,
+                constants: dict | None = None,
+                preamble: dict | None = None) -> tuple[str, dict[str, str]]:
+    """Return (full_program_source, {func_name: emitted_source}).
+
+    In library_mode: emit [UnmanagedCallersOnly] exports for C ABI FFI.
+    extern_fns: functions from other backends that this C# code calls.
+    """
+    emitter = CSharpEmitter(SPEC)
+    emitter.library_mode = library_mode
+    emitter.constants = constants or {}
+    emitted: dict[str, str] = {}
+    fns: list[str] = []
+
+    # register class names
+    if classes:
+        for cls in classes:
+            emitter.class_names.add(cls.name)
+            emitter.class_fields[cls.name] = cls.fields
+            emitter.class_bases[cls.name] = cls.bases
+            emitter.class_properties[cls.name] = cls.properties
+            emitter.class_static_methods[cls.name] = cls.static_methods
+
+    prelude = (
+        "using System;\n"
+        "using System.Collections.Generic;\n"
+        "using System.Linq;\n\n"
+    )
+
+    # emit DllImport declarations for cross-backend calls
+    if extern_fns:
+        decls = []
+        for u in extern_fns:
+            if not u.supported:
+                continue
+            params = ", ".join(
+                f"{'long[]' if ptype == 'list' else SPEC.types.get(ptype, 'double')} {pname}"
+                for pname, ptype in u.params)
+            ret = SPEC.types.get(u.ret_type, "void") if u.ret_type != "None" else "void"
+            decls.append(
+                f'[DllImport("ge_logic", CallingConvention = CallingConvention.Cdecl)]\n'
+                f"static extern {ret} {u.name}({params});"
+            )
+        prelude += "\n// cross-backend declarations (functions from other backends)\n" + "\n".join(decls) + "\n\n"
+
+    # emit struct definitions (inside the class Program block)
+    struct_code = ""
+    if classes:
+        struct_code = _emit_structs_csharp(classes)
+        if struct_code:
+            struct_code += "\n"
+
+    # build function return type lookup for type inference
+    for u in units:
+        if u.supported:
+            emitter.func_return_types[u.name] = u.ret_type
+
+    if library_mode:
+        for u in units:
+            if not u.supported:
+                continue
+            if u.is_method and u.name.endswith(".__init__"):
+                continue
+            code = emitter.emit(u)
+            if emitter.unsupported_emissions:
+                u.supported = False
+                u.unsupported_reasons.extend(emitter.unsupported_emissions)
+                continue
+            emitted[u.name] = code
+            fns.append(code)
+        return prelude + "\n".join(fns) + "\n", emitted
+
+    entry_u = _entry_unit(units, entry)
+    for u in units:
+        if u.is_method and u.name.endswith(".__init__"):
+            continue
+        code = emitter.emit(u)
+        if emitter.unsupported_emissions:
+            u.supported = False
+            u.unsupported_reasons.extend(emitter.unsupported_emissions)
+            continue
+        emitted[u.name] = code
+        fns.append(code)
+
+    # C# requires all methods inside a class; wrap in a Program class
+    # add struct definitions at the beginning of the class block
+    if struct_code:
+        fns.insert(0, struct_code)
+
+    if entry_u.name != "main":
+        if entry_u.ret_type == "None":
+            wrapper = "    static void Main() {\n        " + entry_u.name + "();\n    }\n"
+        else:
+            wrapper = "    static int Main() {\n        return (int)" + entry_u.name + "();\n    }\n"
+        indented_fns = []
+        for fn in fns:
+            for line in fn.split("\n"):
+                indented_fns.append("    " + line)
+        indented_fns.append(wrapper.rstrip())
+    else:
+        # rename main to Main for C# entry point
+        # C# Main must return void or int (32-bit), not long
+        if entry_u.ret_type == "None":
+            fns[-1] = fns[-1].replace(f"static void {entry_u.name}(", "static void Main(")
+        else:
+            # Replace the return type and add a cast at the return
+            fns[-1] = fns[-1].replace(f"static long {entry_u.name}(", "static int Main(")
+            fns[-1] = fns[-1].replace(f"static int {entry_u.name}(", "static int Main(")
+        indented_fns = []
+        for fn in fns:
+            for line in fn.split("\n"):
+                indented_fns.append("    " + line)
+
+    program = prelude + "class Program {\n" + "\n".join(indented_fns) + "\n}\n"
+    # inject stdlib runtime (inside the Program class)
+    from ..stdlib import get_runtime
+    runtime = get_runtime("csharp")
+    if runtime:
+        # indent runtime code to be inside the class
+        indented_runtime = "\n".join("    " + line if line else line for line in runtime.splitlines())
+        program = prelude + "class Program {\n" + indented_runtime + "\n" + "\n".join(indented_fns) + "\n}\n"
+    return program, emitted