ranger-compiler 3.5.0 → 3.5.2

package/dist/lib/shell_test.rgr

@@ -26,10 +26,10 @@ class ShellTest {
     ; Argument vectors, built rather than written inline.
     ;
     ; A one-element typed array literal handed straight to a call is flattened
-    ; to the bare string on the Rust target (ISSUES.md #84), and ANY array
-    ; literal is lost when the call taking it is immediately dereferenced on
-    ; every target (#85). Every vector in this file goes through one of these
-    ; instead. They also read better than the literal does.
+    ; to the bare string on the Rust target (ISSUES.md #84). ANY array literal
+    ; used to be lost when the call taking it was immediately dereferenced, on
+    ; every target (#85, fixed). Every vector in this file goes through one of
+    ; these instead. They also read better than the literal does.
     sfn one:[string] (a:string) {
         def v:[string]
         push v a
@@ -116,9 +116,9 @@ class ShellTest {
         def inLib:Shell (new Shell)
         inLib.cwd = "lib"
         ; Bound rather than chained: a call result that is immediately
-        ; dereferenced loses the array literal in its arguments (ISSUES.md
-        ; #85), and on JavaScript the failure is a runtime type error rather
-        ; than a compile one.
+        ; dereferenced used to lose the array literal in its arguments
+        ; (ISSUES.md #85, fixed), and on JavaScript the failure was a runtime
+        ; type error rather than a compile one.
         def hereArgs:[string] (ShellTest.one("Shell.rgr"))
         def here:ShellResult (inLib.capture("ls" hereArgs))
         this.check("cwd is where the command runs" (here.ok()))

package/dist/lib/stdlib.rgr

@@ -305,6 +305,7 @@ operators {
             swift6 (
                 (forkctx _ ) (def 2) "if type(of: " (e 1) ") == " (typeof 2) ".self  {" nl I
                         "let " (e 2) " = " (e 1) " as! " (typeof 2)";" nl
+                        "_ = " (e 2) nl
                         (block 3)
                         
                         nl i "}"
@@ -414,6 +415,7 @@ operators {
             swift6 (
                 (forkctx _ ) (def 2) "if type(of: " (e 1) ") == " (typeof 2) ".self  {" nl I
                         "let " (e 2) " = " (e 1) " as! " (typeof 2)";" nl
+                        "_ = " (e 2) nl
                         (block 3)
                         
                         nl i "}"
@@ -468,6 +470,12 @@ operators {
     }
     case             _@(newcontext):void           ( arg@(union):T item@(define):T code:block )  {
         templates {
+            ; LLVM is a code generator, not a source writer: this template only
+            ; has to exist so the operator matches for the target and the front
+            ; end binds `item`. lowerShapeCase reads the call node itself and
+            ; emits a type-descriptor compare against the case's @X_typeDesc.
+            llvm ( "case " (e 1) " " (e 2) ":" (typeof 2) " {" nl
+                        I (block 3) i nl "}" nl )
             ranger ( "case " (e 1) " " (e 2) ":" (typeof 2) " {" nl
                         I (block 3) i nl "}" nl
             )
@@ -503,13 +511,18 @@ operators {
                         (block 3)
                         nl i "}"
             ) 
+            ; `_ = name` right after the binding: an arm that does not read
+            ; its payload — a `match` that covers every case has many — would
+            ; otherwise draw a "never used" warning per arm from swiftc.
             swift3 (
                 (forkctx _ ) (def 2) "if case let ." (rawtype 2) "(" (e 2) ") = " (e 1) " { /* union case */" nl I
+                        "_ = " (e 2) nl
                         (block 3)
                         nl i "}"
             ) 
             swift6 (
                 (forkctx _ ) (def 2) "if case let ." (rawtype 2) "(" (e 2) ") = " (e 1) " { /* union case */" nl I
+                        "_ = " (e 2) nl
                         (block 3)
                         nl i "}"
             ) 
@@ -555,11 +568,11 @@ operators {
                         (block 3)
                         nl i "}"
             ) 
-            rust (
-                (forkctx _ ) (def 2) "if let " (typeof 1) "::" (typeof 2) "(" (e 2) ") = &" (e 1) " { /* union case */" nl I
-                        (block 3)
-                        nl i "}"
-            )
+            ; PLAN_RUST_SEMANTIC_IDIOMS E: the writer decides between the `if
+            ; let` this used to be and an arm of a real `match`, because only it
+            ; can see whether FlowShape marked this narrowing as part of a
+            ; complete match. See RustUnion.rustWriteUnionCase.
+            rust ( (forkctx _ ) (def 2) (custom _) )
 
         }
     }
@@ -576,6 +589,9 @@ operators {
     ; target evaluates (e 1) more than once.
     is _:boolean ( arg@(union):T item@(noeval):T ) {
         templates {
+            ; as for `case` above -- a marker so the operator matches for LLVM;
+            ; lowerShapeIs emits the descriptor compare
+            llvm ( "(is " (e 1) " " (typeof 2) ")" )
             ranger ( "(is " (e 1) " " (typeof 2) ")" )
             ; S5 FlatTaggedObject: the stable kind tag, no `var x = …` after it
             es6    ( "(" (e 1) " != null && " (e 1) ".__rg_kind === \"" (typeof 2) "\")" )

package/dist/lib/zip/ranger.json

@@ -0,0 +1,6 @@
+{
+  "name": "zip",
+  "version": "0.1.0",
+  "entry": "Inflate.rgr",
+  "license": "MIT"
+}