Migrate std.join to a native implementation. (#581)

* Move std.join to a native implementation.

Author: dmuir

core/desugarer.cpp

@@ -34,7 +34,7 @@ struct BuiltinDecl {
     std::vector<UString> params;
 };
 
-static unsigned long max_builtin = 33;
+static unsigned long max_builtin = 34;
 BuiltinDecl jsonnet_builtin_decl(unsigned long builtin)
 {
     switch (builtin) {
@@ -72,6 +72,7 @@ BuiltinDecl jsonnet_builtin_decl(unsigned long builtin)
         case 31: return {U"strReplace", {U"str", U"from", U"to"}};
         case 32: return {U"asciiLower", {U"str"}};
         case 33: return {U"asciiUpper", {U"str"}};
+        case 34: return {U"join", {U"sep", U"arr"}};
         default:
             std::cerr << "INTERNAL ERROR: Unrecognized builtin function: " << builtin << std::endl;
             std::abort();

core/vm.cpp

@@ -68,6 +68,8 @@ enum FrameKind {
     FRAME_STRING_CONCAT,        // Stores intermediate state while co-ercing objects
     FRAME_SUPER_INDEX,          // e in super[e]
     FRAME_UNARY,                // e in -e
+    FRAME_BUILTIN_JOIN_STRINGS, // When executing std.join over strings, used to hold intermediate state.
+    FRAME_BUILTIN_JOIN_ARRAYS,  // When executing std.join over arrays, used to hold intermediate state.
 };
 
 /** A frame on the stack.
@@ -126,6 +128,9 @@ struct Frame {
     /** Used for a variety of purposes. */
     std::vector<HeapThunk *> thunks;
 
+    /** Used for accumulating a joined string. */
+    UString str;
+
     /** The context is used in error messages to attempt to find a reasonable name for the
      * object, function, or thunk value being executed.  If it is a thunk, it is filled
      * with the value when the frame terminates.
@@ -864,6 +869,7 @@ class Interpreter {
         builtins["strReplace"] = &Interpreter::builtinStrReplace;
         builtins["asciiLower"] = &Interpreter::builtinAsciiLower;
         builtins["asciiUpper"] = &Interpreter::builtinAsciiUpper;
+        builtins["join"] = &Interpreter::builtinJoin;
     }
 
     /** Clean up the heap, stack, stash, and builtin function ASTs. */
@@ -1429,6 +1435,114 @@ class Interpreter {
         return nullptr;
     }
 
+    void joinString(UString &running, const Value &sep, unsigned idx, const Value &elt)
+    {
+        if (elt.t == Value::NULL_TYPE) {
+            return;
+        }
+        if (elt.t != Value::STRING) {
+            std::stringstream ss;
+            ss << "expected string but arr[" << idx << "] was " << type_str(elt);
+            throw makeError(stack.top().location, ss.str());
+        }
+        if (!running.empty()) {
+            running.append(static_cast<HeapString *>(sep.v.h)->value);
+        }
+        running.append(static_cast<HeapString *>(elt.v.h)->value);
+    }
+
+    const AST *joinStrings(const Value &sep, const Value &arr, unsigned idx, UString running)
+    {
+        const auto& elements = static_cast<HeapArray*>(arr.v.h)->elements;
+        if (idx >= elements.size()) {
+            scratch = makeString(running);
+        } else {
+            for (int i = idx; i < elements.size(); ++i) {
+                auto *th = elements[i];
+                if (th->filled) {
+                    joinString(running, sep, i, th->content);
+                } else {
+                    Frame &f = stack.top();
+                    f.kind = FRAME_BUILTIN_JOIN_STRINGS;
+                    f.val = sep;
+                    f.val2 = arr;
+                    f.str = running;
+                    f.elementId = i;
+                    stack.newCall(f.location, th, th->self, th->offset, th->upValues);
+                    return th->body;
+                }
+            }
+            scratch = makeString(running);
+        }
+        return nullptr;
+    }
+
+    void joinArray(std::vector<HeapThunk*> &running, const Value &sep, unsigned idx, const Value &elt)
+    {
+        if (elt.t == Value::NULL_TYPE) {
+            return;
+        }
+        if (elt.t != Value::ARRAY) {
+            std::stringstream ss;
+            ss << "expected array but arr[" << idx << "] was " << type_str(elt);
+            throw makeError(stack.top().location, ss.str());
+        }
+        if (!running.empty()) {
+            auto& elts = static_cast<HeapArray *>(sep.v.h)->elements;
+            running.insert(running.end(), elts.begin(), elts.end());
+        }
+        auto& elts = static_cast<HeapArray *>(elt.v.h)->elements;
+        running.insert(running.end(), elts.begin(), elts.end());
+    }
+
+    const AST *joinArrays(const Value &sep, const Value &arr, unsigned idx, std::vector<HeapThunk*> &running)
+    {
+        const auto& elements = static_cast<HeapArray*>(arr.v.h)->elements;
+        if (idx >= elements.size()) {
+          scratch = makeArray(running);
+        } else {
+            for (int i = idx; i < elements.size(); ++i) {
+                auto *th = elements[i];
+                if (th->filled) {
+                    joinArray(running, sep, i, th->content);
+                } else {
+                    Frame &f = stack.top();
+                    f.kind = FRAME_BUILTIN_JOIN_ARRAYS;
+                    f.val = sep;
+                    f.val2 = arr;
+                    f.thunks = running;
+                    f.elementId = i;
+                    stack.newCall(f.location, th, th->self, th->offset, th->upValues);
+                    return th->body;
+                }
+            }
+            scratch = makeArray(running);
+        }
+        return nullptr;
+    }
+
+    const AST *builtinJoin(const LocationRange &loc, const std::vector<Value> &args)
+    {
+        if (args[0].t != Value::ARRAY && args[0].t != Value::STRING) {
+            std::stringstream ss;
+            ss << "join first parameter should be string or array, got " << type_str(args[0]);
+            throw makeError(loc, ss.str());
+        }
+        if (args[1].t != Value::ARRAY) {
+            std::stringstream ss;
+            ss << "join second parameter should be array, got " << type_str(args[1]);
+            throw makeError(loc, ss.str());
+        }
+        Frame &f = stack.top();
+        if (args[0].t == Value::STRING) {
+            f.str.clear();
+            return joinStrings(args[0], args[1], 0, f.str);
+        } else {
+            f.thunks.clear();
+            return joinArrays(args[0], args[1], 0, f.thunks);
+        }
+    }
+
     void jsonToHeap(const std::unique_ptr<JsonnetJsonValue> &v, bool &filled, Value &attach)
     {
         // In order to not anger the garbage collector, assign to attach immediately after
@@ -2643,6 +2757,26 @@ class Interpreter {
                     }
                 } break;
 
+                case FRAME_BUILTIN_JOIN_STRINGS: {
+                    joinString(f.str, f.val, f.elementId, scratch);
+                    f.elementId++;
+                    auto *ast = joinStrings(f.val, f.val2, f.elementId, f.str);
+                    if (ast != nullptr) {
+                        ast_ = ast;
+                        goto recurse;
+                    }
+                } break;
+
+                case FRAME_BUILTIN_JOIN_ARRAYS: {
+                    joinArray(f.thunks, f.val, f.elementId, scratch);
+                    f.elementId++;
+                    auto *ast = joinArrays(f.val, f.val2, f.elementId, f.thunks);
+                    if (ast != nullptr) {
+                        ast_ = ast;
+                        goto recurse;
+                    }
+                } break;
+
                 default:
                     std::cerr << "INTERNAL ERROR: Unknown FrameKind:  " << f.kind << std::endl;
                     std::abort();

test_suite/error.std_join_types1.jsonnet.golden

@@ -1,5 +1,2 @@
-RUNTIME ERROR: expected string but arr[1] was array 
-	std.jsonnet:262:9-87	function <aux>
-	std.jsonnet:264:9-49	function <aux>
-	std.jsonnet:270:7-28	function <anonymous>
+RUNTIME ERROR: expected string but arr[1] was array
 	error.std_join_types1.jsonnet:17:1-26	

test_suite/error.std_join_types2.jsonnet.golden

@@ -1,4 +1,2 @@
-RUNTIME ERROR: expected array but arr[0] was string 
-	std.jsonnet:262:9-87	function <aux>
-	std.jsonnet:272:7-28	function <anonymous>
+RUNTIME ERROR: expected array but arr[0] was string
 	error.std_join_types2.jsonnet:17:1-31