ranger-compiler 3.5.0 → 3.5.2

package/dist/lib/JSON.rgr

@@ -21,7 +21,10 @@
 ; it, both spelled in full so that no `use` line is needed.
 systemclass JSONDataObject {
     es6 Object
-    java7 JSONObject ( (imp "org.json.JSONObject") )
+    ; no (imp): org.json is not on the classpath, and the Java writer emits
+    ; JSONObject.java / JSONArray.java / RgJson.java itself when the program
+    ; uses JSON -- the same reason Kotlin carries a polyfill below
+    java7 JSONObject
     kotlin JSONObject
     go "map[string]interface{}"
     swift3 '[String:Any]'
@@ -35,7 +38,7 @@ systemclass JSONDataObject {
 
 systemclass JSONArrayObject {
     es6 JSONArrayObject2
-    java7 JSONArray ( (imp "org.json.JSONArray") )
+    java7 JSONArray
     kotlin JSONArray
     go "[]interface{}"
     swift3 '[Any]'
@@ -385,7 +388,7 @@ inline std::string rg_json_arr_to_string(const rg_json_arr& a) { std::string out
             es6 ( 
                 "console.log(JSON.stringify(" (e 1) "));" nl
             )
-            java7 @macro(true) ("print (to_string " (e 1) " )" (imp "org.json.JSONObject"))
+            java7 @macro(true) ("print (to_string " (e 1) " )")
             python ( "print(json.dumps(" (e 1) "))" (imp "json") )
             rust @macro(true) ("print (to_string " (e 1) " )")
         }
@@ -654,6 +657,7 @@ inline rg_json_arr rg_json_as_arr(const rg_json_val& v) {
     return rg_json_arr();
 }
 ")
+             (imp "<optional>")
              (create_polyfill "
 inline const rg_json_val* rg_json_find(const rg_json_obj& o, const std::string& k) {
     if (!o) { return nullptr; }
@@ -662,10 +666,14 @@ inline const rg_json_val* rg_json_find(const rg_json_obj& o, const std::string&
     }
     return nullptr;
 }
-inline std::string rg_json_get_str(const rg_json_obj& o, const std::string& k) {
+// getStr is declared optional, and every other target answers null for a key
+// that is absent or not a string. Returning a bare std::string made that the
+// empty string, which is a value.
+inline std::optional<std::string> rg_json_get_str(const rg_json_obj& o, const std::string& k) {
+    std::optional<std::string> res;
     const rg_json_val* v = rg_json_find(o, k);
-    if (v && std::holds_alternative<std::string>(*v)) { return std::get<std::string>(*v); }
-    return std::string();
+    if (v && std::holds_alternative<std::string>(*v)) { res = std::get<std::string>(*v); }
+    return res;
 }
 inline bool rg_json_get_bool(const rg_json_obj& o, const std::string& k) {
     const rg_json_val* v = rg_json_find(o, k);
@@ -1176,6 +1184,7 @@ inline rg_json_arr rg_json_as_arr(const rg_json_val& v) {
     return rg_json_arr();
 }
 ")
+             (imp "<optional>")
              (create_polyfill "
 inline const rg_json_val* rg_json_find(const rg_json_obj& o, const std::string& k) {
     if (!o) { return nullptr; }
@@ -1184,10 +1193,14 @@ inline const rg_json_val* rg_json_find(const rg_json_obj& o, const std::string&
     }
     return nullptr;
 }
-inline std::string rg_json_get_str(const rg_json_obj& o, const std::string& k) {
+// getStr is declared optional, and every other target answers null for a key
+// that is absent or not a string. Returning a bare std::string made that the
+// empty string, which is a value.
+inline std::optional<std::string> rg_json_get_str(const rg_json_obj& o, const std::string& k) {
+    std::optional<std::string> res;
     const rg_json_val* v = rg_json_find(o, k);
-    if (v && std::holds_alternative<std::string>(*v)) { return std::get<std::string>(*v); }
-    return std::string();
+    if (v && std::holds_alternative<std::string>(*v)) { res = std::get<std::string>(*v); }
+    return res;
 }
 inline bool rg_json_get_bool(const rg_json_obj& o, const std::string& k) {
     const rg_json_val* v = rg_json_find(o, k);
@@ -1205,43 +1218,23 @@ inline rg_json_arr rg_json_get_arr(const rg_json_obj& o, const std::string& k) {
     return rg_json_arr();
 }
 ")
+             (imp "<optional>")
              (create_polyfill "
-template <class T>
-class r_optional_primitive {
-  public:
-    // has_value has to start false: cpp_str_to_int and its siblings leave the
-    // field untouched when the conversion throws, and an indeterminate bool
-    // made a failed str2int read back as a value on the C++ target.
-    bool has_value = false;
-    T value = T();
-    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;
-    }
-};
-")
-             (create_polyfill "
-inline r_optional_primitive<int> rg_json_get_int(const rg_json_obj& o, const std::string& k) {
-    r_optional_primitive<int> res;
+inline std::optional<int> rg_json_get_int(const rg_json_obj& o, const std::string& k) {
+    std::optional<int> res;
     const rg_json_val* v = rg_json_find(o, k);
     if (v) {
-        if (std::holds_alternative<int>(*v)) { res.has_value = true; res.value = std::get<int>(*v); }
-        else if (std::holds_alternative<double>(*v)) { res.has_value = true; res.value = (int)std::get<double>(*v); }
+        if (std::holds_alternative<int>(*v)) { res = std::get<int>(*v); }
+        else if (std::holds_alternative<double>(*v)) { res = (int)std::get<double>(*v); }
     }
     return res;
 }
-inline r_optional_primitive<double> rg_json_get_double(const rg_json_obj& o, const std::string& k) {
-    r_optional_primitive<double> res;
+inline std::optional<double> rg_json_get_double(const rg_json_obj& o, const std::string& k) {
+    std::optional<double> res;
     const rg_json_val* v = rg_json_find(o, k);
     if (v) {
-        if (std::holds_alternative<double>(*v)) { res.has_value = true; res.value = std::get<double>(*v); }
-        else if (std::holds_alternative<int>(*v)) { res.has_value = true; res.value = (double)std::get<int>(*v); }
+        if (std::holds_alternative<double>(*v)) { res = std::get<double>(*v); }
+        else if (std::holds_alternative<int>(*v)) { res = (double)std::get<int>(*v); }
     }
     return res;
 }
@@ -1567,6 +1560,7 @@ inline rg_json_arr rg_json_as_arr(const rg_json_val& v) {
     return rg_json_arr();
 }
 ")
+             (imp "<optional>")
              (create_polyfill "
 inline const rg_json_val* rg_json_find(const rg_json_obj& o, const std::string& k) {
     if (!o) { return nullptr; }
@@ -1575,10 +1569,14 @@ inline const rg_json_val* rg_json_find(const rg_json_obj& o, const std::string&
     }
     return nullptr;
 }
-inline std::string rg_json_get_str(const rg_json_obj& o, const std::string& k) {
+// getStr is declared optional, and every other target answers null for a key
+// that is absent or not a string. Returning a bare std::string made that the
+// empty string, which is a value.
+inline std::optional<std::string> rg_json_get_str(const rg_json_obj& o, const std::string& k) {
+    std::optional<std::string> res;
     const rg_json_val* v = rg_json_find(o, k);
-    if (v && std::holds_alternative<std::string>(*v)) { return std::get<std::string>(*v); }
-    return std::string();
+    if (v && std::holds_alternative<std::string>(*v)) { res = std::get<std::string>(*v); }
+    return res;
 }
 inline bool rg_json_get_bool(const rg_json_obj& o, const std::string& k) {
     const rg_json_val* v = rg_json_find(o, k);
@@ -1596,43 +1594,23 @@ inline rg_json_arr rg_json_get_arr(const rg_json_obj& o, const std::string& k) {
     return rg_json_arr();
 }
 ")
+             (imp "<optional>")
              (create_polyfill "
-template <class T>
-class r_optional_primitive {
-  public:
-    // has_value has to start false: cpp_str_to_int and its siblings leave the
-    // field untouched when the conversion throws, and an indeterminate bool
-    // made a failed str2int read back as a value on the C++ target.
-    bool has_value = false;
-    T value = T();
-    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;
-    }
-};
-")
-             (create_polyfill "
-inline r_optional_primitive<int> rg_json_get_int(const rg_json_obj& o, const std::string& k) {
-    r_optional_primitive<int> res;
+inline std::optional<int> rg_json_get_int(const rg_json_obj& o, const std::string& k) {
+    std::optional<int> res;
     const rg_json_val* v = rg_json_find(o, k);
     if (v) {
-        if (std::holds_alternative<int>(*v)) { res.has_value = true; res.value = std::get<int>(*v); }
-        else if (std::holds_alternative<double>(*v)) { res.has_value = true; res.value = (int)std::get<double>(*v); }
+        if (std::holds_alternative<int>(*v)) { res = std::get<int>(*v); }
+        else if (std::holds_alternative<double>(*v)) { res = (int)std::get<double>(*v); }
     }
     return res;
 }
-inline r_optional_primitive<double> rg_json_get_double(const rg_json_obj& o, const std::string& k) {
-    r_optional_primitive<double> res;
+inline std::optional<double> rg_json_get_double(const rg_json_obj& o, const std::string& k) {
+    std::optional<double> res;
     const rg_json_val* v = rg_json_find(o, k);
     if (v) {
-        if (std::holds_alternative<double>(*v)) { res.has_value = true; res.value = std::get<double>(*v); }
-        else if (std::holds_alternative<int>(*v)) { res.has_value = true; res.value = (double)std::get<int>(*v); }
+        if (std::holds_alternative<double>(*v)) { res = std::get<double>(*v); }
+        else if (std::holds_alternative<int>(*v)) { res = (double)std::get<int>(*v); }
     }
     return res;
 }
@@ -1954,6 +1932,7 @@ inline rg_json_arr rg_json_as_arr(const rg_json_val& v) {
     return rg_json_arr();
 }
 ")
+             (imp "<optional>")
              (create_polyfill "
 inline const rg_json_val* rg_json_find(const rg_json_obj& o, const std::string& k) {
     if (!o) { return nullptr; }
@@ -1962,10 +1941,14 @@ inline const rg_json_val* rg_json_find(const rg_json_obj& o, const std::string&
     }
     return nullptr;
 }
-inline std::string rg_json_get_str(const rg_json_obj& o, const std::string& k) {
+// getStr is declared optional, and every other target answers null for a key
+// that is absent or not a string. Returning a bare std::string made that the
+// empty string, which is a value.
+inline std::optional<std::string> rg_json_get_str(const rg_json_obj& o, const std::string& k) {
+    std::optional<std::string> res;
     const rg_json_val* v = rg_json_find(o, k);
-    if (v && std::holds_alternative<std::string>(*v)) { return std::get<std::string>(*v); }
-    return std::string();
+    if (v && std::holds_alternative<std::string>(*v)) { res = std::get<std::string>(*v); }
+    return res;
 }
 inline bool rg_json_get_bool(const rg_json_obj& o, const std::string& k) {
     const rg_json_val* v = rg_json_find(o, k);
@@ -2252,7 +2235,14 @@ List<dynamic>? rg_json_as_arr(dynamic v) {
 }
 ")
              )
-             cpp ( "rg_json_get_obj(" (e 1) ", " (e 2) ")"
+             cpp ( "rg_json_opt(rg_json_get_obj(" (e 1) ", " (e 2) ")" ")" (imp "<optional>") (create_polyfill "
+// an absent JSON object or array is the empty pointer; as an optional it is
+// std::nullopt, so has_value() tells a missing key from a present one
+template <class P> std::optional<P> rg_json_opt(const P & p) {
+    if (p) { return p; }
+    return std::nullopt;
+}
+")
              (create_polyfill "
 #include <memory>
 #include <string>
@@ -2289,6 +2279,7 @@ inline rg_json_arr rg_json_as_arr(const rg_json_val& v) {
     return rg_json_arr();
 }
 ")
+             (imp "<optional>")
              (create_polyfill "
 inline const rg_json_val* rg_json_find(const rg_json_obj& o, const std::string& k) {
     if (!o) { return nullptr; }
@@ -2297,10 +2288,14 @@ inline const rg_json_val* rg_json_find(const rg_json_obj& o, const std::string&
     }
     return nullptr;
 }
-inline std::string rg_json_get_str(const rg_json_obj& o, const std::string& k) {
+// getStr is declared optional, and every other target answers null for a key
+// that is absent or not a string. Returning a bare std::string made that the
+// empty string, which is a value.
+inline std::optional<std::string> rg_json_get_str(const rg_json_obj& o, const std::string& k) {
+    std::optional<std::string> res;
     const rg_json_val* v = rg_json_find(o, k);
-    if (v && std::holds_alternative<std::string>(*v)) { return std::get<std::string>(*v); }
-    return std::string();
+    if (v && std::holds_alternative<std::string>(*v)) { res = std::get<std::string>(*v); }
+    return res;
 }
 inline bool rg_json_get_bool(const rg_json_obj& o, const std::string& k) {
     const rg_json_val* v = rg_json_find(o, k);
@@ -2326,7 +2321,7 @@ inline rg_json_arr rg_json_get_arr(const rg_json_obj& o, const std::string& k) {
             swift3 (  (e 1) '[' (e 2) '] as? [String:Any] ')
             swift6 (  (e 1) '[' (e 2) '] as? [String:Any] ')
             ranger ( '(getObject ' (e 1) ' ' (e 2) ')')
-            java7 ( "__getJSONObj(" (e 1) ", " (e 2) " )" (imp 'org.json.JSONException')
+            java7 ( "__getJSONObj(" (e 1) ", " (e 2) " )"
 
 (create_polyfill '
 static JSONObject __getJSONObj(JSONObject o, String item) 
@@ -2605,7 +2600,14 @@ List<dynamic>? rg_json_as_arr(dynamic v) {
 }
 ")
              )
-             cpp ( "rg_json_get_arr(" (e 1) ", " (e 2) ")"
+             cpp ( "rg_json_opt(rg_json_get_arr(" (e 1) ", " (e 2) ")" ")" (imp "<optional>") (create_polyfill "
+// an absent JSON object or array is the empty pointer; as an optional it is
+// std::nullopt, so has_value() tells a missing key from a present one
+template <class P> std::optional<P> rg_json_opt(const P & p) {
+    if (p) { return p; }
+    return std::nullopt;
+}
+")
              (create_polyfill "
 #include <memory>
 #include <string>
@@ -2642,6 +2644,7 @@ inline rg_json_arr rg_json_as_arr(const rg_json_val& v) {
     return rg_json_arr();
 }
 ")
+             (imp "<optional>")
              (create_polyfill "
 inline const rg_json_val* rg_json_find(const rg_json_obj& o, const std::string& k) {
     if (!o) { return nullptr; }
@@ -2650,10 +2653,14 @@ inline const rg_json_val* rg_json_find(const rg_json_obj& o, const std::string&
     }
     return nullptr;
 }
-inline std::string rg_json_get_str(const rg_json_obj& o, const std::string& k) {
+// getStr is declared optional, and every other target answers null for a key
+// that is absent or not a string. Returning a bare std::string made that the
+// empty string, which is a value.
+inline std::optional<std::string> rg_json_get_str(const rg_json_obj& o, const std::string& k) {
+    std::optional<std::string> res;
     const rg_json_val* v = rg_json_find(o, k);
-    if (v && std::holds_alternative<std::string>(*v)) { return std::get<std::string>(*v); }
-    return std::string();
+    if (v && std::holds_alternative<std::string>(*v)) { res = std::get<std::string>(*v); }
+    return res;
 }
 inline bool rg_json_get_bool(const rg_json_obj& o, const std::string& k) {
     const rg_json_val* v = rg_json_find(o, k);
@@ -2798,9 +2805,6 @@ static ArrayList<String> __getJSONKeys(JSONObject obj)
     return list;
 }    
     ")                               
-            (imp "org.json.JSONObject")    
-            (imp "org.json.JSONArray")    
-            
             )
             go ("(func() []string {" nl I
                     "keys := reflect.ValueOf(" (e 1) ").MapKeys()" nl
@@ -3113,7 +3117,14 @@ List<dynamic>? rg_json_as_arr(dynamic v) {
 }
 ")
             )
-            cpp ( "rg_json_as_arr(" (e 1) ")"
+            cpp ( "rg_json_opt(rg_json_as_arr(" (e 1) ")" ")" (imp "<optional>") (create_polyfill "
+// an absent JSON object or array is the empty pointer; as an optional it is
+// std::nullopt, so has_value() tells a missing key from a present one
+template <class P> std::optional<P> rg_json_opt(const P & p) {
+    if (p) { return p; }
+    return std::nullopt;
+}
+")
             (create_polyfill "
 #include <memory>
 #include <string>
@@ -3397,7 +3408,7 @@ inline rg_json_arr rg_json_as_arr(const rg_json_val& v) {
             )
             es6 ( (e 1) "[" (e 2) "]")
             ranger( "(getValue " (e 1) " " (e 2) " )")
-            java7(  '__getJSONValue(' (e 1) ', ' (e 2) ')' (imp 'org.json.JSONObject') (imp 'org.json.JSONArray') (imp 'org.json.JSONException')
+            java7(  '__getJSONValue(' (e 1) ', ' (e 2) ')'
 
 (create_polyfill '
 static Object __getJSONValue(JSONArray o, Integer item) 
@@ -4405,7 +4416,7 @@ inline rg_json_obj rg_json_parse_obj(const std::string& s) {
             )
             swift3 ( 'try JSONSerialization.jsonObject(with: ' (e 1) ', options:[]) as! [String:Any]' (imp 'Foundation') )
             swift6 ( 'try JSONSerialization.jsonObject(with: ' (e 1) ', options:[]) as! [String:Any]' (imp 'Foundation') )
-            java7 ("new JSONObject(" (e 1) ")"  (imp "org.json.JSONObject") (plugin 'maven' (  (dep 'org.json' 'json' '20171018'  ) ) ))
+            java7 ("new JSONObject(" (e 1) ")")
             kotlin ("JSONObject(" (e 1) ")")
             go ( "__r_json_to_interface(" (e 1) ")" (imp "encoding/json")
 
@@ -5425,7 +5436,7 @@ inline rg_json_arr rg_json_as_arr(const rg_json_val& v) {
             swift3 ( '[Any]()' )
             swift6 ( '[Any]()' )
             ranger ("(json_array )")
-            java7 ("new JSONArray()" (imp "org.json.JSONArray") (plugin 'maven' (  (dep 'org.json' 'json' '20171018'  ) ) ))
+            java7 ("new JSONArray()")
             kotlin ("JSONArray()")
             go ( "make([]interface{},0)" )
             php ( "array()" )
@@ -5485,7 +5496,7 @@ inline rg_json_arr rg_json_as_arr(const rg_json_val& v) {
             swift3 ( '[String:Any]()' )
             swift6 ( '[String:Any]()' )
             ranger ("(json_object )")
-            java7 ("new JSONObject()" (imp "org.json.JSONObject") (plugin 'maven' (  (dep 'org.json' 'json' '20171018'  ) ) ))
+            java7 ("new JSONObject()")
             kotlin ("JSONObject()")
             go ( "make(map[string]interface{})" )
             php ( "array()")
@@ -5504,7 +5515,7 @@ enum RJson { Null, Bool(bool), Int(i64), Double(f64), Str(String), Arr(Vec<RJson
             swift3 ("[" ( repeat_from 1 (  (block 1) ) ) "]")
             swift6 ("[" ( repeat_from 1 (  (block 1) ) ) "]")
             ranger ("(json_array " ( repeat 1 (  (block 1) ) ) ")")
-            java7 ("new JSONArray" (imp "org.json.JSONArray") (plugin 'maven' (  (dep 'org.json' 'json' '20171018'  ) ) ))
+            java7 ("new JSONArray")
             go ( "make([]interface{},0)" )
             php ( "array()" )
             python ("[" ( repeat_from 1 (  (block 1) ) ) "]")

package/dist/lib/Shell.rgr

@@ -35,10 +35,10 @@
 ;         print (r.outText())
 ;     }
 ;
-; Build the argument vector rather than writing it as an inline literal: an
-; array literal handed straight to a call is lost when the call result is
-; immediately dereferenced, and a one-element one is flattened on Rust
-; (ISSUES.md #84, #85).
+; Build the argument vector rather than writing it as an inline literal: a
+; one-element literal is flattened to its element on Rust (ISSUES.md #84). The
+; same shape used to lose the whole array whenever the call result was
+; immediately dereferenced, on every target (#85, fixed).
 ;
 ; =============================================================================
 

package/dist/lib/apple/AppleToolchain.rgr

@@ -47,10 +47,10 @@ class AppleToolchain {
     fn developerDir:string () {
         ; Every argument vector in this file is BUILT rather than written as
         ; an inline literal: a one-element literal is flattened to its element
-        ; on Rust (ISSUES.md #84), and any literal is lost when the call
-        ; taking it is immediately dereferenced (#85). A build driver that only
-        ; compiled on Node would be a poor advertisement for a cross-language
-        ; compiler; this one is checked on seven targets.
+        ; on Rust (ISSUES.md #84). Any literal used to be lost when the call
+        ; taking it was immediately dereferenced (#85, fixed). A build driver
+        ; that only compiled on Node would be a poor advertisement for a
+        ; cross-language compiler; this one is checked on seven targets.
         def argv:[string]
         push argv "-p"
         return (sh.text("xcode-select" argv))

package/dist/lib/apple/README.md

@@ -287,10 +287,11 @@ if ((!null? idOpt) && (!null? profOpt)) {
 }
 ```
 
-Every intermediate is bound rather than chained, and that is not style: a call
-result that is immediately dereferenced loses an argument (ISSUES.md #85) and a
-`(expr).field` read as a call argument does not resolve (#81). Both examples
-above compile and run — they are checked, not written from memory.
+Every intermediate is bound rather than chained, and that is not style: a
+`(expr).field` read as a call argument does not resolve (ISSUES.md #81), and a
+call result that was immediately dereferenced used to lose an array literal in
+its arguments (#85, fixed). Both examples above compile and run — they are
+checked, not written from memory.
 
 A worked example, end to end, is
 [`gallery/ui/ios`](../../gallery/ui/ios/README.md): the dashboard demo as an

package/dist/lib/apple/apple_test.rgr

@@ -10,7 +10,7 @@
 ; records instead of executing, so the whole plan is a list of strings, and the
 ; simulator parser is a pure function over the text simctl prints.
 ;
-;     node bin/output.js -es6 lib/apple/apple_test.rgr -nodecli -d=tmp -o=apple_test.js
+;     node dist/rgrc.js -es6 lib/apple/apple_test.rgr -nodecli -d=tmp -o=apple_test.js
 ;     node tmp/apple_test.js
 ; =============================================================================
 

package/dist/lib/core/README.md

@@ -10,7 +10,7 @@ templates, no per-target branches.
 **Status: first slice, wired into the JS engine.** `RgNum`, `RgU32`, `RgText`
 and `RgBase` are landed and gated, and `ComponentEngine.rgr` now delegates 16 of
 its own functions here instead of carrying copies (268 lines deleted). The rest
-is planned in [PLAN_JS_STDLIB.md](../../PLAN_JS_STDLIB.md).
+is planned in [PLAN_JS_STDLIB.md](../../docs/plans/PLAN_JS_STDLIB.md).
 
 | File | What | State |
 | --- | --- | --- |

package/dist/lib/evg/EVG.rgr

@@ -0,0 +1,12 @@
+; SPDX-License-Identifier: MIT
+
+; Package entry for `Import "pkg:evg"`. Individual files stay importable as
+; `Import "pkg:evg/EVGColor.rgr"`. Relative imports inside this tree are
+; unchanged (`Import "EVGElement.rgr"`).
+
+Import "EVGElement.rgr"
+Import "EVGUnit.rgr"
+Import "EVGLayout.rgr"
+Import "EVGDisplayList.rgr"
+Import "EVGStyleSheet.rgr"
+Import "EVGTransition.rgr"