ranger-compiler 3.1.1 → 3.2.0

package/CHANGELOG.md

@@ -7,6 +7,51 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [3.2.0] - 2026-08-01
+
+### Fixed
+
+- **`@serialize(true)` array / hash / property types without the annotation** — the generator assumed every referenced class had `toDictionary` / `fromDictionary` and emitted the call regardless, so the compile failed inside `extension <Class>` with `Could not match argument types for push` / `for case` and never named the real cause. Hash-valued fields were worse: the field was silently dropped from the serialized output. A `@serialize(true)` class that references a class which is neither `@serialize(true)` nor implements the pair by hand now fails at the declaration:
+
+  ```text
+  [FAIL] Parent.kids: [Child] can not be serialized - class Child is not @serialize(true).
+         Add @serialize(true) to Child, or implement toDictionary / fromDictionary in it.
+      9 │     def kids:[Child]
+                  ^── here
+  ```
+
+- **`@serialize(true)` with mutually referencing classes** — serializer extensions were generated one class at a time and `is_serialized` was set as each was reached, so whichever class came first in the dependency sort saw its peer as non-serializable and emitted primitive element code. All `@serialize(true)` classes are now marked before any extension is generated, which mutual references could not satisfy by sorting.
+
+- **`@serialize(true)` element types with hand-written `toDictionary` / `fromDictionary`** — accepted as serializable; the generator now routes them through the object path instead of treating them as primitives.
+
+- **Duplicate serializer extension when one file is reached by two import spellings** — a file imported as both `Child.rgr` and `domain/Child.rgr` was expanded twice, and with `@serialize(true)` the second expansion produced `method with the same name and parameter signature declared earlier` pointing at generated code. Fixed since 3.1.1 was published, released here; covered by a regression test.
+
+- **`SourceCode` constructed with three arguments in `ng_CodeNode.rgr`** — `SourceCode` takes a single `code_str`, but `vref1`, `vref2`, `newStr`, `newBool` and nine sibling factories passed `(name 0 (strlen name))` or `("" 0 0)`, copying the shape of the adjacent `new CodeNode(code 0 ...)`. JavaScript discards the extra arguments, so this was invisible until the TypeScript API bundle was type checked, where it produced all 13 of the `TS2554: Expected 1 arguments, but got 3` errors that `build:dist:module` reported. Dropping the dead arguments makes `tsc` clean, so the step is `&&`-chained again and a real type error blocks the build instead of scrolling past
+
+- **`file_mtime` C++ backend** — added missing `cpp` template in `Lang.rgr` (`stat()` + ms, matching es6 `mtimeMs`); fixes `game_runtime.rgr` hot-reload compile for `game_sdl` native binary
+
+- **`TSLexer` UTF-8 / native C++ tokenization** — code-unit length vs byte `charAt` mismatch after multi-byte characters (e.g. em dash in comments) no longer desyncs the lexer; fixes native SDL parse failures on [`invaders.game.tsx`](./gallery/game_engine/scripting/invaders.game.tsx) and similar scripts
+
+### Added
+
+- **LPC spritesheet compositor (standalone MVP)** — Ranger-native `gallery/game_engine/lpc/` (`png_decoder.rgr`, layer blit, male walk demo); embedded `pack/demo-male-walk` (~28 KB); `npm run engine:lpc:build` / `engine:lpc:run`; design doc [`LPC_HEADLESS_SPRITESHEET.md`](./gallery/game_engine/LPC_HEADLESS_SPRITESHEET.md)
+
+- **JPEG background loading for scripted games** — `GameImageLoader` + `GameRunner` asset queue (`resources()`, `backgroundImage()`, `onLoading()`); `splash_demo.game.tsx` smoke test; `game.d.ts` `ResourceDef` / `LoadingProps` types
+
+- **In-process TS hot reload (Path A)** — `TSAstPatcher` (`ts_ast_patch.rgr`), `ComponentEngine.patchScript()`, `GameRunner` runtime options (`setHotReload`, `trackScriptFile`, `maybeHotReload`); `game_sdl --hot-reload` / `--no-hot-reload`; default on for interactive SDL, off for `maxFrames` smoke runs
+
+- **SDL + native compiled games (Path B)** — `game_sdl_native_host.rgr`, `invaders_native_sdl_runner.rgr`, `build-game-sdl-native.sh`; `npm run engine:game-sdl-native:run:invaders` runs emitter output in an SDL window without `ComponentEngine`
+
+- **`@serialize(true)` regression suite** — `tests/compiler-serialize.test.ts` and `tests/fixtures/serialize/`: round trip over primitives, nested objects, object arrays and object hashes; mutual references; hand-written `toDictionary` / `fromDictionary`; duplicate import spellings; and the three diagnostics above
+
+### Changed
+
+- **`prepublishOnly` no longer runs the whole repository suite** — publishing the compiler ran all 56 test files, including the gallery, game-engine and native-toolchain suites. Those need SDL2, `g++`, Cannon and game fixtures that ship with neither the repo nor the package, so `npm publish` failed on the publisher's machine for reasons unrelated to the compiler (missing `SDL2/SDL.h`, `gallery/game_engine/games/ylos/index.tsx` and `physics_race/index.tsx` are absent from the repository entirely). `prepublishOnly` and `.github/workflows/publish.yml` now run `npm run test:publish` — 44 files, 355 tests, ~90s — covering parsing, type checking and code generation for every target backend. `npm test` still runs everything, and `ci.yml` is unchanged.
+
+- **`build:dist` now includes `build:dist:module`** — `dist/api.js` was not rebuilt by the release build, which is how it drifted behind `bin/output.js`
+
+- **`dist/api.js` rebuilt from current sources** — the committed programmatic-API bundle predated several compiler fixes, so `require("ranger-compiler")` shipped older behaviour than the `rgrc` CLI. `scripts/patch-chain-desugar.js` now patches `dist/api.js` as well as `bin/output.js`, and `build:dist:module` runs it after `tsc`
+
 ## [3.1.1] - 2026-06-23
 
 ### Changed

package/README.md

@@ -69,6 +69,7 @@ host.notifyPath = (path) => { /* sync view model + re-render */ };
 - `gallery/js_parser` - substantial parser example with benchmarks and README
 - `gallery/pdf_writer` - EVG / TSX document tooling and preview server
 - `gallery/invaders` - cross-target demo game
+- `gallery/game_engine` - retained-mode game runner, SDL launcher, and TSX games (Pong, Breakout, Invaders, Pac-Man); see `gallery/game_engine/scripting/GAME_SCRIPTING.md`
 - `gallery/invaders/llvm/invaders.ll` - checked-in LLVM IR sample from the experimental `-l=llvm` backend
 
 ## Compatibility Snapshot
@@ -84,6 +85,23 @@ The project can target `JavaScript`, `Java`, `Go`, `Swift`, `PHP`, `C++`, `C#`,
 | **LLVM / WASM** (`-l=llvm`) | **Experimental.** Lowers to LLVM IR; optional WAT export for freestanding WASM. Native libc builds work for demos like Space Invaders; browser WASM is still rough. See `npm run test:llvm`, `npm run game:build:llvm`. |
 | Gallery examples | Good for understanding direction and capability, but some require manual setup or platform-specific tooling |
 
+### Conformance suite (Track 1)
+
+Cross-target semantic fixtures live in `tests/conformance/`. Run `npx vitest run tests/compiler-conformance.test.ts`.
+Regenerate the fixture list with `node scripts/generate-conformance-table.mjs`.
+
+<!-- BEGIN CONFORMANCE_TABLE -->
+| Fixture | Topic | Targets |
+| --- | --- | --- |
+| `array_param_mutate` | array parameters use reference semantics (Issue #58; Go known gap) | ES6, Go, Kotlin (when toolchain present) |
+| `clear_then_push` | clear resets slice without nil, push refills (Issue #59) | ES6, Go, Kotlin (when toolchain present) |
+| `int_division_to_double` | Conformance: integer division promoted to double (Issue #4) | ES6, Go, Kotlin (when toolchain present) |
+| `lf_line_endings` | LF-only source (Issue #12 class must not break operator spacing) | ES6, Go, Kotlin (when toolchain present) |
+| `math_ops` | Conformance: arithmetic and comparisons | ES6, Go, Kotlin (when toolchain present) |
+| `string_codepoint_index` | Conformance: Unicode code-point string indexing (Issue #57) | ES6, Go, Kotlin (when toolchain present) |
+| `while_loop` | Conformance: while loop control flow | ES6, Go, Kotlin (when toolchain present) |
+<!-- END CONFORMANCE_TABLE -->
+
 ## What's New in Version 3.0
 
 - **New File Extension** - Transitioning from `.clj` to `.rgr` for Ranger identity
@@ -434,7 +452,7 @@ npm run demo:wasm            # smaller freestanding WASM demo (tests/fixtures/ll
 
 **Checked-in sample:** [`gallery/invaders/llvm/invaders.ll`](gallery/invaders/llvm/invaders.ll) is LLVM IR kept in the repo so you can inspect codegen without building. Regenerate with `cp tmp/invaders-native/invaders.ll gallery/invaders/llvm/invaders.ll` after `game:build:llvm` (see [`gallery/invaders/llvm/README.md`](gallery/invaders/llvm/README.md)).
 
-Status: experimental — libc-linked native builds are the most reliable path; freestanding WAT/WASM for the full game is still incomplete (terminal imports, control-flow lowering). Smaller WASM demos under `npm run demo:wasm` are closer to working in the browser.
+Status: experimental — libc-linked native builds are the most reliable path. The freestanding WAT/WASM path (`-wasmrc`) now has a reference-counting runtime (free-list heap with `memory.grow`, typedesc-driven recursive object destruction), classes with reference-counted fields, singletons, strings, `[T]`/`[K:V]` collections, and lambdas/closures (function table + `call_indirect`, with value/object capture and mutation); the `gallery/game_engine/games/ranger_autopeli` guest is authored in Ranger and compiles to WASM this way. Terminal-import lowering for the full Space Invaders game is still incomplete. Smaller freestanding demos run under `npm run demo:wasm`.
 
 #### Cross-Compiling the Game
 
@@ -1329,6 +1347,8 @@ this.foo({
 })
 ```
 
+Lambdas compile on every backend, including the freestanding WASM/WAT path (`-wasmrc`): each body is hoisted to a function-table entry and calls go through `call_indirect`, with the value a reference-counted closure record. Captured variables are copied (values/strings) or retained (objects); a captured object can be mutated through the closure, and a captured value can be shared by boxing it in a heap cell.
+
 # Automatically infixed math support
 
 It is easy to define new mathematical operations in the Lang.clj file or in modules. However, some mathematical operations are automatically infixed

package/dist/Lang.rgr

@@ -60,7 +60,7 @@ language {
         llvm        LLVM IR         ll
     }
 
-    toplevel_keywords (class systemclass Constructor fn sfn Import Extend Enum def let operators)
+    toplevel_keywords (class record systemclass Constructor fn sfn Import Extend Enum def let operators)
     annotation_keywors (weak strong lives temp)
     
     ; transformations for the reserved words for function names or other keywords
@@ -80,12 +80,34 @@ language {
             class _class
             new _new
             delete _delete
+            and _and
+            or _or
+            not _not
+            xor _xor
+            compl _compl
+            bitand _bitand
+            bitor _bitor
+            and_eq _and_eq
+            or_eq _or_eq
+            xor_eq _xor_eq
+            not_eq _not_eq
             template _template
             namespace _namespace
             virtual _virtual
             public _public
             private _private
             protected _protected
+            signed _signed
+            unsigned _unsigned
+            register _register
+            volatile _volatile
+            mutable _mutable
+            friend _friend
+            typename _typename
+            typedef _typedef
+            extern _extern
+            explicit _explicit
+            goto _goto
         }
         go {
             type _type
@@ -222,6 +244,19 @@ language {
             templates {
                 es6 ('Math.random()')
                 kotlin ('Math.random()' (imp "java.lang.Math"))
+                cpp ( "rg_random_double()" (imp "<random>")
+(create_polyfill "
+double rg_random_double() {
+    static thread_local std::mt19937 _rg{std::random_device{}()};
+    static thread_local std::uniform_real_distribution<double> _rd(0.0, 1.0);
+    return _rd(_rg);
+}
+")
+                )
+                go ( 'rand.Float64()' (imp "math/rand") )
+                ; std-only (rustc, no crates): each RandomState::new() draws a fresh
+                ; OS-seeded key, so hashing a constant yields a varying 53-bit value.
+                rust ( '{ use std::hash::{BuildHasher, Hasher}; let mut h = std::collections::hash_map::RandomState::new().build_hasher(); h.write_u64(0); ((h.finish() >> 11) as f64) / ((1u64 << 53) as f64) }' )
             }
         }
 
@@ -413,11 +448,27 @@ func _r_md5(value string) string {
         tan tan:double ( v:double ) {
             templates {
                 es6 ("Math.tan(" (e 1) ")")
-                go ( "math.Tan(" (e 1) ")" (imp "math"))                                
-                swift3 ( "tan(" (e 1) ")" (imp "Foundation"))   
-                java7 ( "Math.tan(" (e 1) ")" (imp "java.lang.Math"))     
-                php ( "tan(" (e 1) ")")     
-                cpp ("tan(" (e 1) ")" (imp "<math.h>"))                          
+                go ( "math.Tan(" (e 1) ")" (imp "math"))
+                swift3 ( "tan(" (e 1) ")" (imp "Foundation"))
+                java7 ( "Math.tan(" (e 1) ")" (imp "java.lang.Math"))
+                php ( "tan(" (e 1) ")")
+                cpp ("tan(" (e 1) ")" (imp "<math.h>"))
+            }
+        }
+
+        atan2 atan2:double ( y:double x:double ) {
+            templates {
+                ranger ( "(atan2 " (e 1) " " (e 2) ")" )
+                es6 ( "Math.atan2(" (e 1) ", " (e 2) ")" )
+                go ( "math.Atan2(" (e 1) ", " (e 2) ")" (imp "math"))
+                swift3 ( "atan2(" (e 1) ", " (e 2) ")" (imp "Foundation"))
+                java7 ( "Math.atan2(" (e 1) ", " (e 2) ")" (imp "java.lang.Math"))
+                php ( "atan2(" (e 1) ", " (e 2) ")" )
+                csharp ( "Math.Atan2(" (e 1) ", " (e 2) ")" (imp "System"))
+                rust ( "" (e 1) ".atan2(" (e 2) ")" )
+                scala ( "math.atan2(" (e 1) ", " (e 2) ")" (imp "scala.math"))
+                cpp ( "atan2(" (e 1) ", " (e 2) ")" (imp "<math.h>"))
+                * ( "Math.atan2(" (e 1) ", " (e 2) ")" )
             }
         }
 
@@ -713,7 +764,7 @@ func r_dir_exists(pathName string) bool {
            }
         }
 
-        ; Returns the file modification time as Unix timestamp (seconds since epoch)
+        ; Returns the file modification time (ms on es6/cpp; seconds on go)
         file_mtime          cmdFileMTime:int (path:string filename:string) {
             templates {
                 go ( "r_file_mtime(" (e 1) ", " (e 2) ")"
@@ -730,6 +781,18 @@ func r_file_mtime(pathName string, fileName string) int64 {
 )                    
                 )
                 es6 ( "require('fs').statSync(" (e 1) " + '/' + " (e 2) ").mtimeMs" )
+                cpp ( "r_file_mtime(" (e 1) ", " (e 2) ")" (imp "<sys/stat.h>") (imp "<string>")
+(create_polyfill "
+int64_t r_file_mtime(const std::string& path, const std::string& filename) {
+    struct stat st;
+    std::string full = path + \"/\" + filename;
+    if (stat(full.c_str(), &st) != 0) {
+        return 0;
+    }
+    return (int64_t)st.st_mtime * 1000;
+}
+")
+                )
                 ranger ( "(file_mtime " (e 1) " " (e 2) ")" )
            }
         }
@@ -1310,6 +1373,24 @@ fn r_read_file(path: &str, filename: &str) -> Option<String> {
             }
         }
 
+        ; Integer division (truncates toward zero). Use instead of / when both
+        ; operands are int — plain / returns double for int/int in Ranger.
+        idiv  _:int (left:int right:int) {
+            templates {
+                ranger @macro(true) ( "(/ " (e 1) " " (e 2) ")" )
+                cpp ( "((" (e 1) ") / (" (e 2) "))" )
+                llvm ( "(idiv " (e 1) " " (e 2) ")" )
+                es6 ( "((" (e 1) " / " (e 2) ") | 0)" )
+                go ( (e 1) " / " (e 2) )
+                rust ( "((" (e 1) ") / (" (e 2) "))" )
+                kotlin ( (e 1) " / " (e 2) )
+                python ( "((" (e 1) ") // (" (e 2) "))" )
+                java7 ( "((" (e 1) ") / (" (e 2) "))" )
+                php ( "intdiv(" (e 1) ", " (e 2) ")" )
+                * ( (e 1) " / " (e 2) )
+            }
+        }
+
         ; ============================================================================
         ; Bitwise operators for integer manipulation
         ; ============================================================================
@@ -1449,12 +1530,16 @@ fn r_read_file(path: &str, filename: &str) -> Option<String> {
         *               cmdMulOp:double         ( left:double right:double ) { templates { * ( (e 1) " * " (e 2) ) } }
         *               cmdMulOp:int            ( left:int right:int ) { templates { * ( (e 1) " * " (e 2) ) } }
 
-        /               cmdDivOp:double         ( left:double right:double ) { templates { * ( (e 1) " / " (e 2) ) } }
-        /               cmdDivOp:double         ( left:int right:int ) { templates { 
+        /               cmdDivOp:double         ( left:double right:double ) { templates {
+            cpp ( "((double)(" (e 1) ") / (double)(" (e 2) "))" )
+            * ( (e 1) " / " (e 2) )
+        } }
+        /               cmdDivOp:double         ( left:int right:int ) { templates {
             go ( "float64(" (e 1) ") / float64(" (e 2) ")" )
             rust ( "(" (e 1) " as f64) / (" (e 2) " as f64)" )
             kotlin ( (e 1) ".toDouble() / " (e 2) ".toDouble()" )
-            * ( (e 1) " / " (e 2) ) 
+            cpp ( "((double)(" (e 1) ") / (double)(" (e 2) "))" )
+            * ( (e 1) " / " (e 2) )
         } }
 
         ; optional string operator...
@@ -1687,7 +1772,22 @@ fn r_read_file(path: &str, filename: &str) -> Option<String> {
             templates {
                 cpp ( "if ( " (e 1) ".has_value ) {" nl I (block 2) i nl "}" nl )
             }
-        }        
+        }
+
+        ; typed optional int/double with an else branch: r_optional_primitive is
+        ; a value type (has_value field), not a pointer, so the generic :T
+        ; `!= NULL` form below does not compile under clang. Emit `.has_value`.
+        if              cmdIf:void              ( condition@(optional):int then_block:block else_block )  {
+            templates {
+                cpp ( "if ( " (e 1) ".has_value ) {" I nl (block 2) i nl "} else {" nl I (block 3) i "}" nl )
+            }
+        }
+
+        if              cmdIf:void              ( condition@(optional):double then_block:block else_block )  {
+            templates {
+                cpp ( "if ( " (e 1) ".has_value ) {" I nl (block 2) i nl "} else {" nl I (block 3) i "}" nl )
+            }
+        }
 
         if              cmdIf:void              ( condition@(optional):T then_block:block )  {
             templates {
@@ -1930,9 +2030,18 @@ std::vector<T> r_make_vector_from_array( const T (&data)[N] )
         }               
         null?       cmdIsNotNull:boolean        ( arg@(optional):string ) {
             templates {
-                cpp ((e 1) ".empty()")     
+                cpp ((e 1) ".empty()")
             }
-        }               
+        }
+
+        ; buffer is a value type (std::vector<uint8_t>) in C++, so the generic
+        ; `!= NULL` path below does not compile. Treat empty/absent as null,
+        ; mirroring the string overload above.
+        null?       cmdIsNotNull:boolean        ( arg@(optional):buffer ) {
+            templates {
+                cpp ((e 1) ".empty()")
+            }
+        }
 
         null?       cmdIsNull:boolean        ( arg@(optional):T ) {
             templates {
@@ -1964,9 +2073,18 @@ std::vector<T> r_make_vector_from_array( const T (&data)[N] )
         }               
         !null?       cmdIsNotNull:boolean        ( arg@(optional):string ) {
             templates {
-                cpp ((e 1) ".empty() == false ")     
+                cpp ((e 1) ".empty() == false ")
             }
-        }               
+        }
+
+        ; buffer is a value type (std::vector<uint8_t>) in C++; the generic
+        ; `!= NULL` path below does not compile. Present == non-empty, matching
+        ; the string overload above.
+        !null?       cmdIsNotNull:boolean        ( arg@(optional):buffer ) {
+            templates {
+                cpp ((e 1) ".empty() == false ")
+            }
+        }
 
         !null?       cmdIsNotNull:boolean        ( arg@(optional):T ) {
             templates {
@@ -2123,7 +2241,7 @@ case class customException(smth:String)  extends Exception
                 php ( "trim(" (e 1 ) ")")
                 cpp ( "r_cpp_trim( " (e 1) ")" (imp "<cctype>") (imp "<string>") (imp "<algorithm>")
 (create_polyfill "
-inline std::string  r_cpp_trim(std::string &s) 
+inline std::string  r_cpp_trim(const std::string &s) 
 {
    auto wsfront=std::find_if_not(s.begin(),s.end(),[](int c){return std::isspace(c);});
    auto wsback=std::find_if_not(s.rbegin(),s.rend(),[](int c){return std::isspace(c);}).base();
@@ -3016,10 +3134,10 @@ std::vector<std::string> r_get_keys_of_map(  std::map<std::string, T> orig_map )
 (create_polyfill '
 std::string r_utf8_substr(const std::string& str, int start_i, int leng_i)
 {
-    unsigned int start ((unsigned int)start_i);
-    unsigned int leng ((unsigned int)leng_i);
+    size_t start = (size_t)start_i;
+    size_t leng = (size_t)leng_i;
     if (leng==0) { return ""; }
-    unsigned int c, i, ix, q, min= (unsigned int) std::string::npos, max=(unsigned int)std::string::npos;
+    size_t c, i, ix, q, min= std::string::npos, max= std::string::npos;
     for (q=0, i=0, ix=str.length(); i < ix; i++, q++)
     {
         if (q==start){ min=i; }
@@ -3538,6 +3656,49 @@ r_optional_primitive<int> cpp_get_map_int_value( std::map<" (r_ktype 1) ", int>
                 )
             }
         }
+
+        get             cmdGet@(optional weak):double          ( map:[K:double] key:K ) {
+            templates {
+                cpp( "cpp_get_map_string_double_value(" (e 1) ", " (e 2) ")"
+(create_polyfill
+"
+template <class T>
+class r_optional_primitive {
+  public:
+    bool has_value;
+    T value;
+    r_optional_primitive<T> & operator=(const r_optional_primitive<T> & rhs) {
+        has_value = rhs.has_value;
+        value = rhs.value;
+        return *this;
+    }
+    r_optional_primitive<T> & operator=(const T a_value) {
+        has_value = true;
+        value = a_value;
+        return *this;
+    }
+};
+"
+)
+(macro
+("
+r_optional_primitive<double> cpp_get_map_string_double_value( std::map<std::string, double> m , std::string key) {
+    r_optional_primitive<double> result;
+    auto it = m.find(key);
+    if (it != m.end()) {
+        result.value = it->second;
+        result.has_value = true;
+    }
+    return result;
+}")
+)
+                )
+                ranger ( "(get " (e 1) " " (e 2) ")")
+                llvm ( "(get " (e 1) " " (e 2) ")")
+                es6 ( "( " (e 1) ".hasOwnProperty(" (e 2) ") ? " (e 1) "[" (e 2) "] : undefined )" )
+                * ( (e 1) "[" (e 2) "]" )
+            }
+        }
          
         get             cmdGet@(optional weak):T          ( map:[K:T] key:K ) { 
             templates {
@@ -3545,6 +3706,21 @@ r_optional_primitive<int> cpp_get_map_int_value( std::map<" (r_ktype 1) ", int>
                 llvm ( "(get " (e 1) " " (e 2) ")")
                 java7 ( (e 1) ".get(" (e 2) ")" )
                 rust ( (e 1) ".get(" (e 2) ")" )
+                cpp ( "r_map_get_val(" (e 1) ", " (e 2) ")"
+(create_polyfill
+"
+// Map read that never inserts on miss (unlike std::map::operator[]) and does a
+// single lookup. Returns a default-constructed value (e.g. null shared_ptr)
+// when the key is absent.
+template<typename M, typename K>
+typename M::mapped_type r_map_get_val( const M & m , const K & key) {
+    auto it = m.find(key);
+    if ( it != m.end() ) { return it->second; }
+    return typename M::mapped_type();
+}
+"
+)
+                )
 
                 scala ( (e 1) ".get(" (e 2) ")" )
 
@@ -5007,6 +5183,20 @@ fun r_read_key(): String {
                 swift6 ((e 1) ".lowercased()")
                 scala ((e 1) ".toLowerCase()")
                 python ((e 1) ".lower()")
+                cpp (
+                    "r_cpp_str_to_lowercase(" (e 1) ")"
+                        (imp "<algorithm>")
+                        (imp "<string>")
+(create_polyfill "
+std::string r_cpp_str_to_lowercase(std::string original)
+{
+    std::string str = original;
+    std::transform(str.begin(), str.end(), str.begin(), ::tolower);
+    return str;
+}
+    ")
+
+                    )
             }
         }
         to_uppercase _:string (s:string) {