diff --git a/jsonnet.c b/jsonnet.c
index fa23be0..83c50d4 100644
--- a/jsonnet.c
+++ b/jsonnet.c
@@ -27,7 +27,6 @@
 #include "ext/json/php_json.h"
 #include "Zend/zend_exceptions.h"
 #include "php_jsonnet.h"
-#include <stdlib.h>
 
 #include "libjsonnet.h"
 
@@ -50,8 +49,10 @@ const zend_function_entry jsonnet_methods[] =
     PHP_ME(JSONNET_RES_NAME, __construct,   NULL, ZEND_ACC_PUBLIC | ZEND_ACC_CTOR)
     PHP_ME(JSONNET_RES_NAME, __destruct,    NULL, ZEND_ACC_PUBLIC | ZEND_ACC_DTOR)
 
-    PHP_ME(JSONNET_RES_NAME, evaluateFile,      NULL, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC)
-    PHP_ME(JSONNET_RES_NAME, evaluateSnippet,   NULL, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC)
+    PHP_ME(JSONNET_RES_NAME, evaluateFile,          NULL, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC)
+    PHP_ME(JSONNET_RES_NAME, evaluateSnippet,       NULL, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC)
+    PHP_ME(JSONNET_RES_NAME, fmtFile,               NULL, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC)
+    PHP_ME(JSONNET_RES_NAME, fmtSnippet,            NULL, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC)
 
     {
         NULL, NULL, NULL
@@ -204,7 +205,7 @@ PHP_METHOD(JSONNET_RES_NAME, evaluateFile)
         {
             zval_ptr_dtor(&result);
             zval_ptr_dtor(&resultZval);
-            zend_throw_exception(php_com_exception_class_entry, "JsonNet #error", CODE_ERROR TSRMLS_CC);
+            zend_throw_exception(php_com_exception_class_entry, "JsonNet::evaluateFile #error", CODE_ERROR TSRMLS_CC);
             return;
         }
 
@@ -259,7 +260,7 @@ PHP_METHOD(JSONNET_RES_NAME, evaluateSnippet)
         {
             zval_ptr_dtor(&result);
             zval_ptr_dtor(&resultZval);
-            zend_throw_exception(php_com_exception_class_entry, "JsonNet #error", CODE_ERROR TSRMLS_CC);
+            zend_throw_exception(php_com_exception_class_entry, "JsonNet::evaluateSnippet #error", CODE_ERROR TSRMLS_CC);
             return;
         }
 
@@ -270,11 +271,104 @@ PHP_METHOD(JSONNET_RES_NAME, evaluateSnippet)
     zend_throw_exception(php_com_exception_class_entry, "JsonNet::evaluateSnippet('string'), string is null", CODE_ERROR TSRMLS_CC);
 }
 
-/*
- * Local variables:
- * tab-width: 4
- * c-basic-offset: 4
- * End:
- * vim600: noet sw=4 ts=4 fdm=marker
- * vim<600: noet sw=4 ts=4
- */
+PHP_METHOD(JSONNET_RES_NAME, fmtFile)
+{
+    int argc = ZEND_NUM_ARGS();
+    int _file_path_len, error;
+
+    char *output, *_file_path = NULL;
+    struct JsonnetVm *vm;
+
+    zval *err, *result;
+
+    if (zend_parse_parameters(argc TSRMLS_CC, "s", &_file_path, &_file_path_len) == FAILURE)
+        return;
+
+    if (argc > 0 && _file_path_len > 0)
+    {
+
+        vm = jsonnet_make();
+        output = jsonnet_fmt_file(vm, _file_path, &error);
+
+        if (error)
+        {
+            MAKE_STD_ZVAL(err);
+            ZVAL_STRING(err,output,1);
+
+            jsonnet_realloc(vm, output, 0);
+            jsonnet_destroy(vm);
+
+            zend_throw_exception(php_com_exception_class_entry, Z_STRVAL_P(err), CODE_ERROR TSRMLS_CC);
+            zval_ptr_dtor(&err);
+            RETURN_FALSE;
+        }
+
+        MAKE_STD_ZVAL(result);
+        ZVAL_STRING(result,output,1);
+
+        jsonnet_realloc(vm, output, 0);
+        jsonnet_destroy(vm);
+
+        if(Z_TYPE_P(result) == IS_NULL)
+        {
+            zval_ptr_dtor(&result);
+            zend_throw_exception(php_com_exception_class_entry, "JsonNet::fmtFile #error", CODE_ERROR TSRMLS_CC);
+            return;
+        }
+
+        RETURN_ZVAL(result,1,1);
+    }
+
+    zend_throw_exception(php_com_exception_class_entry, "JsonNet::fmtFile('filePath'), filePath is null", CODE_ERROR TSRMLS_CC);
+}
+
+PHP_METHOD(JSONNET_RES_NAME, fmtSnippet)
+{
+    int argc = ZEND_NUM_ARGS();
+    int _snippet_string_len, error;
+
+    char *output, *_snippet_string = NULL;
+    struct JsonnetVm *vm;
+
+    zval *err, *result;
+
+    if (zend_parse_parameters(argc TSRMLS_CC, "s", &_snippet_string, &_snippet_string_len) == FAILURE)
+        return;
+
+    if (argc > 0 && _snippet_string_len > 0)
+    {
+
+        vm = jsonnet_make();
+        output = jsonnet_fmt_snippet(vm, "snippet", _snippet_string, &error);
+
+        if (error)
+        {
+            MAKE_STD_ZVAL(err);
+            ZVAL_STRING(err,output,1);
+
+            jsonnet_realloc(vm, output, 0);
+            jsonnet_destroy(vm);
+
+            zend_throw_exception(php_com_exception_class_entry, Z_STRVAL_P(err), CODE_ERROR TSRMLS_CC);
+            zval_ptr_dtor(&err);
+            RETURN_FALSE;
+        }
+
+        MAKE_STD_ZVAL(result);
+        ZVAL_STRING(result,output,1);
+
+        jsonnet_realloc(vm, output, 0);
+        jsonnet_destroy(vm);
+
+        if(Z_TYPE_P(result) == IS_NULL)
+        {
+            zval_ptr_dtor(&result);
+            zend_throw_exception(php_com_exception_class_entry, "JsonNet::fmtSnippet #error", CODE_ERROR TSRMLS_CC);
+            return;
+        }
+
+        RETURN_ZVAL(result,1,1);
+    }
+
+    zend_throw_exception(php_com_exception_class_entry, "JsonNet::fmtSnippet('string'), string is null", CODE_ERROR TSRMLS_CC);
+}
diff --git a/libjsonnet/Makefile b/libjsonnet/Makefile
index aaecd9b..cfad23a 100644
--- a/libjsonnet/Makefile
+++ b/libjsonnet/Makefile
@@ -16,7 +16,7 @@
 # User-servicable parts:
 ################################################################################
 
-# C/C++ compiler -- clang also works
+# C/C++ compiler; to use Clang, build with `make CC=clang CXX=clang++`
 CXX ?= g++
 CC ?= gcc
 
@@ -29,9 +29,10 @@ OD ?= od
 
 OPT ?= -O3
 
-CXXFLAGS ?= -g $(OPT) -Wall -Wextra -Woverloaded-virtual -pedantic -std=c++0x -fPIC -Iinclude
+CXXFLAGS ?= -g $(OPT) -Wall -Wextra -Woverloaded-virtual -pedantic -std=c++0x -fPIC -Iinclude -Ithird_party/md5
 CFLAGS ?= -g $(OPT) -Wall -Wextra -pedantic -std=c99 -fPIC -Iinclude
-EMCXXFLAGS = $(CXXFLAGS) --memory-init-file 0 -s DISABLE_EXCEPTION_CATCHING=0
+MAKEDEPENDFLAGS ?= -Iinclude -Ithird_party/md5
+EMCXXFLAGS = $(CXXFLAGS) -Os --memory-init-file 0 -s DISABLE_EXCEPTION_CATCHING=0 -s OUTLINING_LIMIT=10000
 EMCFLAGS = $(CFLAGS) --memory-init-file 0 -s DISABLE_EXCEPTION_CATCHING=0
 LDFLAGS ?=
 
@@ -47,9 +48,11 @@ LIB_SRC = \
 	core/lexer.cpp \
 	core/libjsonnet.cpp \
 	core/parser.cpp \
+	core/pass.cpp \
 	core/static_analysis.cpp \
 	core/string_utils.cpp \
-	core/vm.cpp
+	core/vm.cpp \
+	third_party/md5/md5.cpp
 
 LIB_OBJ = $(LIB_SRC:.cpp=.o)
 
@@ -81,7 +84,8 @@ ALL_HEADERS = \
 	core/vm.h \
 	core/std.jsonnet.h \
 	include/libjsonnet.h \
-	include/libjsonnet++.h
+	include/libjsonnet++.h \
+	third_party/md5/md5.h
 
 LIB_JSONNET_PATH = /usr/local/lib
 
@@ -89,15 +93,14 @@ default: jsonnet
 
 all: $(ALL)
 
-TEST_SNIPPET = "std.assertEqual(({ x: 1, y: self.x } { x: 2 }).y, 2)"
 test: jsonnet libjsonnet.so libjsonnet_test_snippet libjsonnet_test_file
-	./jsonnet -e $(TEST_SNIPPET)
-	LD_LIBRARY_PATH=. ./libjsonnet_test_snippet $(TEST_SNIPPET)
-	LD_LIBRARY_PATH=. ./libjsonnet_test_file "test_suite/object.jsonnet"
-	cd examples ; ./check.sh
-	cd examples/terraform ; ./check.sh
-	cd test_suite ; ./run_tests.sh
-	cd test_suite ; ./run_fmt_tests.sh
+	./tests.sh
+
+reformat:
+	clang-format -i -style=file **/*.cpp **/*.h
+
+test-formatting:
+	test "`clang-format -style=file -output-replacements-xml **/*.cpp **/*.h | grep -c "<replacement "`" == 0
 
 MAKEDEPEND_SRCS = \
 	cmd/jsonnet.cpp \
@@ -105,7 +108,8 @@ MAKEDEPEND_SRCS = \
 	core/libjsonnet_test_file.c
 
 depend:
-	makedepend -f- $(LIB_SRC) $(MAKEDEPEND_SRCS) > Makefile.depend
+	rm -f Makefile.depend
+	for FILE in $(LIB_SRC) $(MAKEDEPEND_SRCS) ; do $(CXX) -MM $(CXXFLAGS) $$FILE -MT $$(dirname $$FILE)/$$(basename $$FILE .cpp).o >> Makefile.depend ; done
 
 core/desugarer.cpp: core/std.jsonnet.h
 
@@ -124,10 +128,11 @@ libjsonnet.so: $(LIB_OBJ)
 	cp -rf include/libjsonnet.h  $(LIB_JSONNET_PATH)
 	cp -rf libjsonnet.so $(LIB_JSONNET_PATH)
 
+
 libjsonnet++.so: $(LIB_CPP_OBJ)
 	$(CXX) $(LDFLAGS) $(LIB_CPP_OBJ) $(SHARED_LDFLAGS) -o $@
 
-# Javascript build of C binding
+# JavaScript build of C binding
 JS_EXPORTED_FUNCTIONS = 'EXPORTED_FUNCTIONS=["_jsonnet_make", "_jsonnet_evaluate_snippet", "_jsonnet_realloc", "_jsonnet_destroy"]'
 
 libjsonnet.js: $(LIB_SRC) $(ALL_HEADERS)
@@ -163,6 +168,8 @@ core/%.jsonnet.h: stdlib/%.jsonnet
 	echo >> $@
 
 clean:
-	rm -vf */*~ *~ .*~ */.*.swp .*.swp $(ALL) *.o core/*.jsonnet.h Make.depend
+	rm -vf */*~ *~ .*~ */.*.swp .*.swp $(ALL) *.o core/*.jsonnet.h Makefile.depend
 
 -include Makefile.depend
+
+.PHONY: default all depend clean reformat test test-formatting
diff --git a/libjsonnet/cmd/jsonnet.cpp b/libjsonnet/cmd/jsonnet.cpp
index 3449d40..9fc22ef 100644
--- a/libjsonnet/cmd/jsonnet.cpp
+++ b/libjsonnet/cmd/jsonnet.cpp
@@ -14,9 +14,9 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
+#include <cassert>
 #include <cstdlib>
 #include <cstring>
-#include <cassert>
 
 #include <exception>
 #include <fstream>
@@ -26,7 +26,7 @@ limitations under the License.
 #include <vector>
 
 extern "C" {
-    #include <libjsonnet.h>
+#include <libjsonnet.h>
 }
 
 std::string next_arg(unsigned &i, const std::vector<std::string> &args)
@@ -43,7 +43,7 @@ std::string next_arg(unsigned &i, const std::vector<std::string> &args)
 std::vector<std::string> simplify_args(int argc, const char **argv)
 {
     std::vector<std::string> r;
-    for (int i=1 ; i<argc ; ++i) {
+    for (int i = 1; i < argc; ++i) {
         std::string arg = argv[i];
         if (arg == "--") {
             // Add this arg and all remaining ones without simplification.
@@ -54,8 +54,8 @@ std::vector<std::string> simplify_args(int argc, const char **argv)
         }
         // Check if it is of the form -abc and convert to -a -b -c
         if (arg.length() > 2 && arg[0] == '-' && arg[1] != '-') {
-            for (unsigned j=1 ; j<arg.length() ; ++j) {
-                r.push_back("-" + arg.substr(j,1));
+            for (unsigned j = 1; j < arg.length(); ++j) {
+                r.push_back("-" + arg.substr(j, 1));
             }
         } else {
             r.push_back(arg);
@@ -72,9 +72,15 @@ void version(std::ostream &o)
 void usage(std::ostream &o)
 {
     version(o);
-    o << "Typical Usage:\n";
-    o << "jsonnet [<cmd>] {<option>} <filename>\n";
-    o << "Where <cmd> is one of {eval, fmt} and defaults to eval.\n";
+    o << "\n";
+    o << "General commandline:\n";
+    o << "jsonnet [<cmd>] {<option>} { <filename> }\n";
+    o << "Note: <cmd> defaults to \"eval\"\n";
+    o << "\n";
+    o << "The eval command:\n";
+    o << "jsonnet eval {<option>} <filename>\n";
+    o << "Note: Only one filename is supported\n";
+    o << "\n";
     o << "Available eval options:\n";
     o << "  -h / --help             This message\n";
     o << "  -e / --exec             Treat filename as code\n";
@@ -95,7 +101,6 @@ void usage(std::ostream &o)
     o << "Provide a value as Jsonnet code:\n";
     o << "  --ext-code <var>[=<code>]    If <code> is omitted, get from environment var <var>\n";
     o << "  --ext-code-file <var>=<file> Read the code from the file\n";
-    o << "\n";
     o << "Available options for specifying values of 'top-level arguments':\n";
     o << "Provide the value as a string:\n";
     o << "  -A / --tla-str <var>[=<val>]     If <val> is omitted, get from environment var <var>\n";
@@ -104,14 +109,16 @@ void usage(std::ostream &o)
     o << "  --tla-code <var>[=<code>]    If <code> is omitted, get from environment var <var>\n";
     o << "  --tla-code-file <var>=<file> Read the code from the file\n";
     o << "\n";
+    o << "The fmt command:\n";
+    o << "jsonnet fmt {<option>} { <filename> }\n";
+    o << "Note: Some options do not support multiple filenames\n";
+    o << "\n";
     o << "Available fmt options:\n";
-    o << "jsonnet fmt {<option>} <filename>\n";
-    o << "and <option> can be:\n";
     o << "  -h / --help             This message\n";
     o << "  -e / --exec             Treat filename as code\n";
     o << "  -o / --output-file <file> Write to the output file rather than stdout\n";
-    o << "  -i / --in-place         Update the Jsonnet file in place.  Same as -o <filename>\n";
-    o << "  --test                  Exit with failure if reformatting changed the file.\n";
+    o << "  -i / --in-place         Update the Jsonnet file(s) in place.\n";
+    o << "  --test                  Exit with failure if reformatting changed the file(s).\n";
     o << "  -n / --indent <n>       Number of spaces to indent by (default 0, means no change)\n";
     o << "  --max-blank-lines <n>   Max vertical spacing, 0 means no change (default 2)\n";
     o << "  --string-style <d|s|l>  Enforce double, single quotes or 'leave' (the default)\n";
@@ -119,6 +126,7 @@ void usage(std::ostream &o)
     o << "  --[no-]pretty-field-names Use syntax sugar for fields and indexing (on by default)\n";
     o << "  --[no-]pad-arrays       [ 1, 2, 3 ] instead of [1, 2, 3]\n";
     o << "  --[no-]pad-objects      { x: 1, x: 2 } instead of {x: 1, y: 2} (on by default)\n";
+    o << "  --[no-]sort-imports     Sorting of imports (off by default)\n";
     o << "  --debug-desugaring      Unparse the desugared AST without executing it\n";
     o << "  --version               Print version\n";
     o << "\n";
@@ -138,7 +146,6 @@ long strtol_check(const std::string &str)
     long r = std::strtol(arg, &ep, 10);
     if (*ep != '\0' || *arg == '\0') {
         std::cerr << "ERROR: Invalid integer \"" << arg << "\"\n" << std::endl;
-        usage(std::cerr);
         exit(EXIT_FAILURE);
     }
     return r;
@@ -152,7 +159,7 @@ enum Command {
 /** Class for representing configuration read from command line flags.  */
 struct JsonnetConfig {
     Command cmd;
-    std::string inputFile;
+    std::vector<std::string> inputFiles;
     std::string outputFile;
     bool filenameIsCode;
 
@@ -166,12 +173,14 @@ struct JsonnetConfig {
     bool fmtTest;
 
     JsonnetConfig()
-      : cmd(EVAL), filenameIsCode(false),
-        evalMulti(false),
-        evalStream(false),
-        fmtInPlace(false),
-        fmtTest(false)
-    { }
+        : cmd(EVAL),
+          filenameIsCode(false),
+          evalMulti(false),
+          evalStream(false),
+          fmtInPlace(false),
+          fmtTest(false)
+    {
+    }
 };
 
 bool get_var_val(const std::string &var_val, std::string &var, std::string &val)
@@ -181,8 +190,7 @@ bool get_var_val(const std::string &var_val, std::string &var, std::string &val)
         var = var_val;
         const char *val_cstr = ::getenv(var.c_str());
         if (val_cstr == nullptr) {
-            std::cerr << "ERROR: Environment variable " << var
-                      << " was undefined." << std::endl;
+            std::cerr << "ERROR: Environment variable " << var << " was undefined." << std::endl;
             return false;
         }
         val = val_cstr;
@@ -197,8 +205,8 @@ bool get_var_file(const std::string &var_file, std::string &var, std::string &va
 {
     size_t eq_pos = var_file.find_first_of('=', 0);
     if (eq_pos == std::string::npos) {
-        std::cerr << "ERROR: argument not in form <var>=<file> \""
-                  << var_file << "\"." << std::endl;
+        std::cerr << "ERROR: argument not in form <var>=<file> \"" << var_file << "\"."
+                  << std::endl;
         return false;
     }
     var = var_file.substr(0, eq_pos);
@@ -209,13 +217,17 @@ bool get_var_file(const std::string &var_file, std::string &var, std::string &va
     return true;
 }
 
+enum ArgStatus {
+    ARG_CONTINUE,
+    ARG_SUCCESS,
+    ARG_FAILURE,
+};
+
 /** Parse the command line arguments, configuring the Jsonnet VM context and
  * populating the JsonnetConfig.
  */
-static bool process_args(int argc,
-                         const char **argv,
-                         JsonnetConfig *config,
-                         JsonnetVm *vm) {
+static ArgStatus process_args(int argc, const char **argv, JsonnetConfig *config, JsonnetVm *vm)
+{
     auto args = simplify_args(argc, argv);
     std::vector<std::string> remaining_args;
 
@@ -228,21 +240,21 @@ static bool process_args(int argc,
         i++;
     }
 
-    for (; i<args.size() ; ++i) {
+    for (; i < args.size(); ++i) {
         const std::string &arg = args[i];
         if (arg == "-h" || arg == "--help") {
             usage(std::cout);
-            return false;
+            return ARG_SUCCESS;
         } else if (arg == "-v" || arg == "--version") {
             version(std::cout);
-            return false;
+            return ARG_SUCCESS;
         } else if (arg == "-e" || arg == "--exec") {
             config->filenameIsCode = true;
         } else if (arg == "-o" || arg == "--output-file") {
             std::string output_file = next_arg(i, args);
             if (output_file.length() == 0) {
                 std::cerr << "ERROR: -o argument was empty string" << std::endl;
-                return EXIT_FAILURE;
+                return ARG_FAILURE;
             }
             config->outputFile = output_file;
         } else if (arg == "--") {
@@ -254,101 +266,87 @@ static bool process_args(int argc,
             if (arg == "-s" || arg == "--max-stack") {
                 long l = strtol_check(next_arg(i, args));
                 if (l < 1) {
-                    std::cerr << "ERROR: Invalid --max-stack value: " << l << "\n"
-                              << std::endl;
-                    usage(std::cerr);
-                    return false;
+                    std::cerr << "ERROR: Invalid --max-stack value: " << l << std::endl;
+                    return ARG_FAILURE;
                 }
                 jsonnet_max_stack(vm, l);
             } else if (arg == "-J" || arg == "--jpath") {
                 std::string dir = next_arg(i, args);
                 if (dir.length() == 0) {
                     std::cerr << "ERROR: -J argument was empty string" << std::endl;
-                    return false;
+                    return ARG_FAILURE;
                 }
                 if (dir[dir.length() - 1] != '/') {
                     dir += '/';
                 }
                 jsonnet_jpath_add(vm, dir.c_str());
-            // TODO(dcunnin): Remove deprecated --var, --env and -E
-            } else if (arg == "-V" || arg == "--ext-str"
-                       || arg == "--var" || arg == "--env" || arg == "-E") {
+            } else if (arg == "-V" || arg == "--ext-str") {
                 std::string var, val;
                 if (!get_var_val(next_arg(i, args), var, val))
-                    return EXIT_FAILURE;
+                    return ARG_FAILURE;
                 jsonnet_ext_var(vm, var.c_str(), val.c_str());
-            // TODO(dcunnin): Remove deprecated --file and -F
-            } else if (arg == "--ext-str-file" || arg == "--file" || arg == "-F") {
+            } else if (arg == "--ext-str-file") {
                 std::string var, val;
                 if (!get_var_file(next_arg(i, args), var, val))
-                    return EXIT_FAILURE;
+                    return ARG_FAILURE;
                 jsonnet_ext_var(vm, var.c_str(), val.c_str());
-            // TODO(dcunnin): Remove deprecated --code-var, --code-env
-            } else if (arg == "--ext-code" || arg == "--code-var" || arg == "--code-env") {
+            } else if (arg == "--ext-code") {
                 std::string var, val;
                 if (!get_var_val(next_arg(i, args), var, val))
-                    return EXIT_FAILURE;
+                    return ARG_FAILURE;
                 jsonnet_ext_code(vm, var.c_str(), val.c_str());
-            // TODO(dcunnin): Remove deprecated --code-file
-            } else if (arg == "--ext-code-file" || arg == "--code-file") {
+            } else if (arg == "--ext-code-file") {
                 std::string var, val;
                 if (!get_var_file(next_arg(i, args), var, val))
-                    return EXIT_FAILURE;
+                    return ARG_FAILURE;
                 jsonnet_ext_code(vm, var.c_str(), val.c_str());
             } else if (arg == "-A" || arg == "--tla-str") {
                 std::string var, val;
                 if (!get_var_val(next_arg(i, args), var, val))
-                    return EXIT_FAILURE;
+                    return ARG_FAILURE;
                 jsonnet_tla_var(vm, var.c_str(), val.c_str());
             } else if (arg == "--tla-str-file") {
                 std::string var, val;
                 if (!get_var_file(next_arg(i, args), var, val))
-                    return EXIT_FAILURE;
+                    return ARG_FAILURE;
                 jsonnet_tla_var(vm, var.c_str(), val.c_str());
             } else if (arg == "--tla-code") {
                 std::string var, val;
                 if (!get_var_val(next_arg(i, args), var, val))
-                    return EXIT_FAILURE;
+                    return ARG_FAILURE;
                 jsonnet_tla_code(vm, var.c_str(), val.c_str());
             } else if (arg == "--tla-code-file") {
                 std::string var, val;
                 if (!get_var_file(next_arg(i, args), var, val))
-                    return EXIT_FAILURE;
+                    return ARG_FAILURE;
                 jsonnet_tla_code(vm, var.c_str(), val.c_str());
 
             } else if (arg == "--gc-min-objects") {
                 long l = strtol_check(next_arg(i, args));
                 if (l < 0) {
-                    std::cerr << "ERROR: Invalid --gc-min-objects value: " << l
-                              << std::endl;
-                    usage(std::cerr);
-                    return EXIT_FAILURE;
+                    std::cerr << "ERROR: Invalid --gc-min-objects value: " << l << std::endl;
+                    return ARG_FAILURE;
                 }
                 jsonnet_gc_min_objects(vm, l);
             } else if (arg == "-t" || arg == "--max-trace") {
                 long l = strtol_check(next_arg(i, args));
                 if (l < 0) {
-                    std::cerr << "ERROR: Invalid --max-trace value: " << l
-                              << std::endl;
-                    usage(std::cerr);
-                    return EXIT_FAILURE;
+                    std::cerr << "ERROR: Invalid --max-trace value: " << l << std::endl;
+                    return ARG_FAILURE;
                 }
                 jsonnet_max_trace(vm, l);
             } else if (arg == "--gc-growth-trigger") {
-                const char *arg = next_arg(i,args).c_str();
+                const char *arg = next_arg(i, args).c_str();
                 char *ep;
                 double v = std::strtod(arg, &ep);
                 if (*ep != '\0' || *arg == '\0') {
-                    std::cerr << "ERROR: Invalid number \"" << arg << "\""
-                              << std::endl;
-                    usage(std::cerr);
-                    return EXIT_FAILURE;
+                    std::cerr << "ERROR: Invalid number \"" << arg << "\"" << std::endl;
+                    return ARG_FAILURE;
                 }
                 if (v < 0) {
-                    std::cerr << "ERROR: Invalid --gc-growth-trigger \""
-                              << arg << "\"\n" << std::endl;
-                    usage(std::cerr);
-                    return EXIT_FAILURE;
+                    std::cerr << "ERROR: Invalid --gc-growth-trigger \"" << arg << "\""
+                              << std::endl;
+                    return ARG_FAILURE;
                 }
                 jsonnet_gc_growth_trigger(vm, v);
             } else if (arg == "-m" || arg == "--multi") {
@@ -356,7 +354,7 @@ static bool process_args(int argc,
                 std::string output_dir = next_arg(i, args);
                 if (output_dir.length() == 0) {
                     std::cerr << "ERROR: -m argument was empty string" << std::endl;
-                    return EXIT_FAILURE;
+                    return ARG_FAILURE;
                 }
                 if (output_dir[output_dir.length() - 1] != '/') {
                     output_dir += '/';
@@ -368,7 +366,7 @@ static bool process_args(int argc,
                 jsonnet_string_output(vm, 1);
             } else if (arg.length() > 1 && arg[0] == '-') {
                 std::cerr << "ERROR: Unrecognized argument: " << arg << std::endl;
-                return EXIT_FAILURE;
+                return ARG_FAILURE;
             } else {
                 remaining_args.push_back(args[i]);
             }
@@ -382,19 +380,16 @@ static bool process_args(int argc,
             } else if (arg == "-n" || arg == "--indent") {
                 long l = strtol_check(next_arg(i, args));
                 if (l < 0) {
-                    std::cerr << "ERROR: Invalid --indent value: " << l << "\n"
-                              << std::endl;
-                    usage(std::cerr);
-                    return false;
+                    std::cerr << "ERROR: Invalid --indent value: " << l << std::endl;
+                    return ARG_FAILURE;
                 }
                 jsonnet_fmt_indent(vm, l);
             } else if (arg == "--max-blank-lines") {
                 long l = strtol_check(next_arg(i, args));
                 if (l < 0) {
-                    std::cerr << "ERROR: Invalid --max-blank-lines value: " << l << "\n"
+                    std::cerr << "ERROR: Invalid --max-blank-lines value: " << l << ""
                               << std::endl;
-                    usage(std::cerr);
-                    return false;
+                    return ARG_FAILURE;
                 }
                 jsonnet_fmt_max_blank_lines(vm, l);
             } else if (arg == "--comment-style") {
@@ -406,10 +401,9 @@ static bool process_args(int argc,
                 } else if (val == "l") {
                     jsonnet_fmt_comment(vm, 'l');
                 } else {
-                    std::cerr << "ERROR: Invalid --comment-style value: " << val << "\n"
+                    std::cerr << "ERROR: Invalid --comment-style value: " << val
                               << std::endl;
-                    usage(std::cerr);
-                    return false;
+                    return ARG_FAILURE;
                 }
             } else if (arg == "--string-style") {
                 const std::string val = next_arg(i, args);
@@ -420,10 +414,9 @@ static bool process_args(int argc,
                 } else if (val == "l") {
                     jsonnet_fmt_string(vm, 'l');
                 } else {
-                    std::cerr << "ERROR: Invalid --string-style value: " << val << "\n"
+                    std::cerr << "ERROR: Invalid --string-style value: " << val
                               << std::endl;
-                    usage(std::cerr);
-                    return false;
+                    return ARG_FAILURE;
                 }
             } else if (arg == "--pad-arrays") {
                 jsonnet_fmt_pad_arrays(vm, true);
@@ -437,11 +430,15 @@ static bool process_args(int argc,
                 jsonnet_fmt_pretty_field_names(vm, true);
             } else if (arg == "--no-pretty-field-names") {
                 jsonnet_fmt_pretty_field_names(vm, false);
+            } else if (arg == "--sort-imports") {
+                jsonnet_fmt_sort_imports(vm, true);
+            } else if (arg == "--no-sort-imports") {
+                jsonnet_fmt_sort_imports(vm, false);
             } else if (arg == "--debug-desugaring") {
                 jsonnet_fmt_debug_desugaring(vm, true);
             } else if (arg.length() > 1 && arg[0] == '-') {
                 std::cerr << "ERROR: Unrecognized argument: " << arg << std::endl;
-                return EXIT_FAILURE;
+                return ARG_FAILURE;
             } else {
                 remaining_args.push_back(args[i]);
             }
@@ -452,75 +449,113 @@ static bool process_args(int argc,
     if (remaining_args.size() == 0) {
         std::cerr << "ERROR: Must give " << want << "\n" << std::endl;
         usage(std::cerr);
-        return false;
+        return ARG_FAILURE;
     }
 
-    std::string filename = remaining_args[0];
-    if (remaining_args.size() > 1) {
-        std::cerr << "ERROR: Already specified " << want
-                  << " as \"" << filename << "\"\n"
-                  << std::endl;
-        usage(std::cerr);
-        return false;
+    bool multiple_files_allowed = config->cmd == FMT && (config->fmtTest || config->fmtInPlace);
+    if (!multiple_files_allowed) {
+        if (remaining_args.size() > 1) {
+            std::string filename = remaining_args[0];
+            std::cerr << "ERROR: Only one " << want << " is allowed\n" << std::endl;
+            return ARG_FAILURE;
+        }
     }
-    config->inputFile = filename;
-    return true;
+    config->inputFiles = remaining_args;
+    return ARG_CONTINUE;
 }
 
-/** Reads Jsonnet code from the input file or stdin into the input buffer. */
-static bool read_input(JsonnetConfig* config, std::string* input) {
-    if (config->filenameIsCode) {
-        *input = config->inputFile;
-        config->inputFile = "<cmdline>";
+/** Reads from the input file or stdin into the input buffer. */
+static bool read_input_content(std::string filename, std::string *input)
+{
+    // Input file "-" tells Jsonnet to read stdin.
+    if (filename == "-") {
+        input->assign(std::istreambuf_iterator<char>(std::cin), std::istreambuf_iterator<char>());
     } else {
-        if (config->inputFile == "-") {
-            config->inputFile = "<stdin>";
-            input->assign(std::istreambuf_iterator<char>(std::cin),
-                          std::istreambuf_iterator<char>());
-        } else {
-            std::ifstream f;
-            f.open(config->inputFile.c_str());
-            if (!f.good()) {
-                std::string msg = "Opening input file: " + config->inputFile;
-                perror(msg.c_str());
-                return false;
-            }
-            input->assign(std::istreambuf_iterator<char>(f),
-                          std::istreambuf_iterator<char>());
-            if (!f.good()) {
-                std::string msg = "Reading input file: " + config->inputFile;
-                perror(msg.c_str());
-                return false;
-            }
+        std::ifstream f;
+        f.open(filename);
+        if (!f.good()) {
+            std::string msg = "Opening input file: " + filename;
+            perror(msg.c_str());
+            return false;
+        }
+        input->assign(std::istreambuf_iterator<char>(f), std::istreambuf_iterator<char>());
+        if (!f.good()) {
+            std::string msg = "Reading input file: " + filename;
+            perror(msg.c_str());
+            return false;
         }
     }
     return true;
 }
 
+void change_special_filename(JsonnetConfig *config, std::string *filename)
+{
+    if (config->filenameIsCode) {
+        *filename = "<cmdline>";
+    } else if (*filename == "-") {
+        *filename = "<stdin>";
+    }
+}
+
+/** Gets Jsonnet code from any source into the input buffer and changes
+ * the filename if it's not an actual filename (e.g. "-"). */
+static bool read_input(JsonnetConfig *config, std::string *filename, std::string *input)
+{
+    bool ok;
+    if (config->filenameIsCode) {
+        *input = *filename;
+        ok = true;
+    } else {
+        ok = read_input_content(*filename, input);
+    }
+    // Let's change the filename to something we can show the user
+    // if it is not a real filename.
+    change_special_filename(config, filename);
+    return ok;
+}
+
 /** Writes output files for multiple file output */
-static bool write_multi_output_files(JsonnetVm* vm, char* output,
-                                     const std::string& output_dir)
+static bool write_multi_output_files(JsonnetVm *vm, char *output, const std::string &output_dir,
+                                     const std::string &output_file)
 {
     // If multiple file output is used, then iterate over each string from
     // the sequence of strings returned by jsonnet_evaluate_snippet_multi,
     // construct pairs of filename and content, and write each output file.
     std::map<std::string, std::string> r;
-    for (const char *c=output ; *c!='\0' ; ) {
+    for (const char *c = output; *c != '\0';) {
         const char *filename = c;
         const char *c2 = c;
-        while (*c2 != '\0') ++c2;
+        while (*c2 != '\0')
+            ++c2;
         ++c2;
         const char *json = c2;
-        while (*c2 != '\0') ++c2;
+        while (*c2 != '\0')
+            ++c2;
         ++c2;
         c = c2;
         r[filename] = json;
     }
     jsonnet_realloc(vm, output, 0);
+
+    std::ostream *o;
+    std::ofstream f;
+
+    if (output_file.empty()) {
+        o = &std::cout;
+    } else {
+        f.open(output_file.c_str());
+        if (!f.good()) {
+            std::string msg = "Writing to output file: " + output_file;
+            perror(msg.c_str());
+            return false;
+        }
+        o = &f;
+    }
+
     for (const auto &pair : r) {
         const std::string &new_content = pair.second;
         const std::string &filename = output_dir + pair.first;
-        std::cout << filename << std::endl;
+        (*o) << filename << std::endl;
         {
             std::ifstream exists(filename.c_str());
             if (exists.good()) {
@@ -540,7 +575,6 @@ static bool write_multi_output_files(JsonnetVm* vm, char* output,
         if (!f.good()) {
             std::string msg = "Opening output file: " + filename;
             perror(msg.c_str());
-            jsonnet_destroy(vm);
             return false;
         }
         f << new_content;
@@ -548,61 +582,106 @@ static bool write_multi_output_files(JsonnetVm* vm, char* output,
         if (!f.good()) {
             std::string msg = "Writing to output file: " + filename;
             perror(msg.c_str());
-            jsonnet_destroy(vm);
             return false;
         }
     }
-    std::cout.flush();
+
+    if (output_file.empty()) {
+        std::cout.flush();
+    } else {
+        f.close();
+        if (!f.good()) {
+            std::string msg = "Writing to output file: " + output_file;
+            perror(msg.c_str());
+            return false;
+        }
+    }
     return true;
 }
 
 /** Writes output files for YAML stream output */
-static bool write_output_stream(JsonnetVm* vm, char* output)
+static bool write_output_stream(JsonnetVm *vm, char *output, const std::string &output_file)
 {
+    std::ostream *o;
+    std::ofstream f;
+
+    if (output_file.empty()) {
+        o = &std::cout;
+    } else {
+        f.open(output_file.c_str());
+        if (!f.good()) {
+            std::string msg = "Writing to output file: " + output_file;
+            perror(msg.c_str());
+            return false;
+        }
+        o = &f;
+    }
+
     // If YAML stream output is used, then iterate over each string from
     // the sequence of strings returned by jsonnet_evaluate_snippet_stream,
     // and add the --- and ... as defined by the YAML spec.
     std::vector<std::string> r;
-    for (const char *c=output ; *c!='\0' ; ) {
+    for (const char *c = output; *c != '\0';) {
         const char *json = c;
-        while (*c != '\0') ++c;
+        while (*c != '\0')
+            ++c;
         ++c;
         r.emplace_back(json);
     }
     jsonnet_realloc(vm, output, 0);
     for (const auto &str : r) {
-        std::cout << "---\n";
-        std::cout << str;
+        (*o) << "---\n";
+        (*o) << str;
     }
     if (r.size() > 0)
-        std::cout << "...\n";
-    std::cout.flush();
+        (*o) << "...\n";
+    o->flush();
+
+    if (output_file.empty()) {
+        std::cout.flush();
+    } else {
+        f.close();
+        if (!f.good()) {
+            std::string msg = "Writing to output file: " + output_file;
+            perror(msg.c_str());
+            return false;
+        }
+    }
+
     return true;
 }
 
 /** Writes the output JSON to the specified output file for single-file
  * output
  */
-static bool write_output_file(const char* output,
-                              const std::string &output_file) {
-    if (output_file.empty()) {
-        std::cout << output;
-        std::cout.flush();
-        return true;
-    }
+static bool write_output_file(const char *output, const std::string &output_file)
+{
+    std::ostream *o;
     std::ofstream f;
-    f.open(output_file.c_str());
-    if (!f.good()) {
-        std::string msg = "Writing to output file: " + output_file;
-        perror(msg.c_str());
-        return false;
+
+    if (output_file.empty()) {
+        o = &std::cout;
+    } else {
+        f.open(output_file.c_str());
+        if (!f.good()) {
+            std::string msg = "Writing to output file: " + output_file;
+            perror(msg.c_str());
+            return false;
+        }
+        o = &f;
     }
-    f << output;
-    f.close();
-    if (!f.good()) {
-        std::string msg = "Writing to output file: " + output_file;
-        perror(msg.c_str());
-        return false;
+
+    (*o) << output;
+
+    if (output_file.empty()) {
+        std::cout.flush();
+    } else {
+        f.close();
+        if (!f.good()) {
+            std::string msg = "Writing to output file: " + output_file;
+            perror(msg.c_str());
+            return false;
+        }
     }
     return true;
 }
@@ -612,14 +691,10 @@ int main(int argc, const char **argv)
     try {
         JsonnetVm *vm = jsonnet_make();
         JsonnetConfig config;
-        if (!process_args(argc, argv, &config, vm)) {
-            return EXIT_FAILURE;
-        }
-
-        // Read input files.
-        std::string input;
-        if (!read_input(&config, &input)) {
-            return EXIT_FAILURE;
+        ArgStatus arg_status = process_args(argc, argv, &config, vm);
+        if (arg_status != ARG_CONTINUE) {
+            jsonnet_destroy(vm);
+            return arg_status == ARG_SUCCESS ? EXIT_SUCCESS : EXIT_FAILURE;
         }
 
         // Evaluate input Jsonnet and handle any errors from Jsonnet VM.
@@ -627,20 +702,28 @@ int main(int argc, const char **argv)
         char *output;
         switch (config.cmd) {
             case EVAL: {
+                assert(config.inputFiles.size() == 1);
+
+                // Read input file.
+                std::string input;
+                if (!read_input(&config, &config.inputFiles[0], &input)) {
+                    jsonnet_destroy(vm);
+                    return EXIT_FAILURE;
+                }
+
                 if (config.evalMulti) {
                     output = jsonnet_evaluate_snippet_multi(
-                        vm, config.inputFile.c_str(), input.c_str(), &error);
+                        vm, config.inputFiles[0].c_str(), input.c_str(), &error);
                 } else if (config.evalStream) {
                     output = jsonnet_evaluate_snippet_stream(
-                        vm, config.inputFile.c_str(), input.c_str(), &error);
+                        vm, config.inputFiles[0].c_str(), input.c_str(), &error);
                 } else {
                     output = jsonnet_evaluate_snippet(
-                        vm, config.inputFile.c_str(), input.c_str(), &error);
+                        vm, config.inputFiles[0].c_str(), input.c_str(), &error);
                 }
 
                 if (error) {
                     std::cerr << output;
-                    std::cerr.flush();
                     jsonnet_realloc(vm, output, 0);
                     jsonnet_destroy(vm);
                     return EXIT_FAILURE;
@@ -648,11 +731,14 @@ int main(int argc, const char **argv)
 
                 // Write output JSON.
                 if (config.evalMulti) {
-                    if (!write_multi_output_files(vm, output, config.evalMultiOutputDir)) {
+                    if (!write_multi_output_files(
+                            vm, output, config.evalMultiOutputDir, config.outputFile)) {
+                        jsonnet_destroy(vm);
                         return EXIT_FAILURE;
                     }
                 } else if (config.evalStream) {
-                    if (!write_output_stream(vm, output)) {
+                    if (!write_output_stream(vm, output, config.outputFile)) {
+                        jsonnet_destroy(vm);
                         return EXIT_FAILURE;
                     }
                 } else {
@@ -663,43 +749,82 @@ int main(int argc, const char **argv)
                         return EXIT_FAILURE;
                     }
                 }
-            }
-            break;
+            } break;
 
             case FMT: {
                 std::string output_file = config.outputFile;
-                if (config.fmtInPlace) {
-                    if (config.inputFile == "-") {
-                        std::cerr << "ERROR: Cannot use --in-place with stdin" << std::endl;
-                        jsonnet_destroy(vm);
-                        return EXIT_FAILURE;
+
+                if (config.fmtInPlace || config.fmtTest) {
+                    assert(config.inputFiles.size() >= 1);
+                    for (std::string &inputFile : config.inputFiles) {
+                        if (config.fmtInPlace) {
+                            output_file = inputFile;
+
+                            if (inputFile == "-") {
+                                std::cerr << "ERROR: Cannot use --in-place with stdin" << std::endl;
+                                jsonnet_destroy(vm);
+                                return EXIT_FAILURE;
+                            }
+                            if (config.filenameIsCode) {
+                                std::cerr << "ERROR: Cannot use --in-place with --exec"
+                                          << std::endl;
+                                jsonnet_destroy(vm);
+                                return EXIT_FAILURE;
+                            }
+                        }
+
+                        std::string input;
+                        if (!read_input(&config, &inputFile, &input)) {
+                            jsonnet_destroy(vm);
+                            return EXIT_FAILURE;
+                        }
+
+                        output = jsonnet_fmt_snippet(vm, inputFile.c_str(), input.c_str(), &error);
+
+                        if (error) {
+                            std::cerr << output;
+                            jsonnet_realloc(vm, output, 0);
+                            jsonnet_destroy(vm);
+                            return EXIT_FAILURE;
+                        }
+
+                        if (config.fmtTest) {
+                            // Check the output matches the input.
+                            bool ok = output == input;
+                            jsonnet_realloc(vm, output, 0);
+                            if (!ok) {
+                                jsonnet_destroy(vm);
+                                return 2;
+                            }
+                        } else {
+                            // Write output Jsonnet.
+                            bool successful = write_output_file(output, output_file);
+                            jsonnet_realloc(vm, output, 0);
+                            if (!successful) {
+                                jsonnet_destroy(vm);
+                                return EXIT_FAILURE;
+                            }
+                        }
                     }
-                    if (config.filenameIsCode) {
-                        std::cerr << "ERROR: Cannot use --in-place with --exec" << std::endl;
+                } else {
+                    assert(config.inputFiles.size() == 1);
+                    // Read input file.
+                    std::string input;
+                    if (!read_input(&config, &config.inputFiles[0], &input)) {
                         jsonnet_destroy(vm);
                         return EXIT_FAILURE;
                     }
-                    output_file = config.inputFile;
-                }
 
-                output = jsonnet_fmt_snippet(vm, config.inputFile.c_str(), input.c_str(), &error);
-
-                if (error) {
-                    std::cerr << output;
-                    std::cerr.flush();
-                    jsonnet_realloc(vm, output, 0);
-                    jsonnet_destroy(vm);
-                    return EXIT_FAILURE;
-                }
+                    output = jsonnet_fmt_snippet(
+                        vm, config.inputFiles[0].c_str(), input.c_str(), &error);
 
-                if (config.fmtTest) {
-                    // Check the output matches the input.
-                    bool ok = output == input;
-                    jsonnet_realloc(vm, output, 0);
-                    jsonnet_destroy(vm);
-                    return ok ? EXIT_SUCCESS : 2;
+                    if (error) {
+                        std::cerr << output;
+                        jsonnet_realloc(vm, output, 0);
+                        jsonnet_destroy(vm);
+                        return EXIT_FAILURE;
+                    }
 
-                } else {
                     // Write output Jsonnet.
                     bool successful = write_output_file(output, output_file);
                     jsonnet_realloc(vm, output, 0);
@@ -708,8 +833,7 @@ int main(int argc, const char **argv)
                         return EXIT_FAILURE;
                     }
                 }
-            }
-            break;
+            } break;
         }
 
         jsonnet_destroy(vm);
@@ -719,12 +843,9 @@ int main(int argc, const char **argv)
         // Avoid further allocation attempts
         fputs("Internal out-of-memory error (please report this)\n", stderr);
     } catch (const std::exception &e) {
-        std::cerr << "Internal error (please report this): "
-                  << e.what() << std::endl;
+        std::cerr << "Internal error (please report this): " << e.what() << std::endl;
     } catch (...) {
-        std::cerr << "An unknown exception occurred (please report this)."
-                  << std::endl;
+        std::cerr << "An unknown exception occurred (please report this)." << std::endl;
     }
     return EXIT_FAILURE;
 }
-
diff --git a/libjsonnet/core/BUILD b/libjsonnet/core/BUILD
index addbd39..07e3c27 100644
--- a/libjsonnet/core/BUILD
+++ b/libjsonnet/core/BUILD
@@ -8,6 +8,7 @@ cc_library(
         "lexer.cpp",
         "libjsonnet.cpp",
         "parser.cpp",
+        "pass.cpp",
         "static_analysis.cpp",
         "string_utils.cpp",
         "vm.cpp",
@@ -19,6 +20,7 @@ cc_library(
         "json.h",
         "lexer.h",
         "parser.h",
+        "pass.h",
         "state.h",
         "static_analysis.h",
         "static_error.h",
@@ -29,6 +31,7 @@ cc_library(
     deps = [
         "//include:libjsonnet",
         "//stdlib:std",
+        "//third_party/md5:libmd5",
     ],
     linkopts = ["-lm"],
     includes = ["."],
@@ -40,7 +43,7 @@ cc_test(
     deps = [
         ":libjsonnet",
         # Note: On Ubuntu, apt-get install libgtest-dev google-mock
-        "//external:gtest_main",
+        "//external:googletest_main",
     ],
 )
 
@@ -49,7 +52,7 @@ cc_test(
     srcs = ["parser_test.cpp"],
     deps = [
         ":libjsonnet",
-        "//external:gtest_main",
+        "//external:googletest_main",
     ],
 )
 
@@ -58,6 +61,6 @@ cc_test(
     srcs = ["libjsonnet_test.cpp"],
     deps = [
         ":libjsonnet",
-        "//external:gtest_main",
+        "//external:googletest_main",
     ],
 )
diff --git a/libjsonnet/core/ast.h b/libjsonnet/core/ast.h
index 42124e6..6ed56a8 100644
--- a/libjsonnet/core/ast.h
+++ b/libjsonnet/core/ast.h
@@ -17,12 +17,12 @@ limitations under the License.
 #ifndef JSONNET_AST_H
 #define JSONNET_AST_H
 
-#include <cstdlib>
 #include <cassert>
+#include <cstdlib>
 
 #include <iostream>
-#include <string>
 #include <map>
+#include <string>
 #include <vector>
 
 #include "lexer.h"
@@ -44,11 +44,12 @@ enum ASTType {
     AST_IMPORT,
     AST_IMPORTSTR,
     AST_INDEX,
-    AST_LOCAL,
+    AST_IN_SUPER,
     AST_LITERAL_BOOLEAN,
     AST_LITERAL_NULL,
     AST_LITERAL_NUMBER,
     AST_LITERAL_STRING,
+    AST_LOCAL,
     AST_OBJECT,
     AST_OBJECT_COMPREHENSION,
     AST_OBJECT_COMPREHENSION_SIMPLE,
@@ -59,12 +60,48 @@ enum ASTType {
     AST_VAR
 };
 
+static inline std::string ASTTypeToString(ASTType type)
+{
+    switch (type) {
+        case AST_APPLY: return "AST_APPLY";
+        case AST_ARRAY: return "AST_ARRAY";
+        case AST_ARRAY_COMPREHENSION: return "AST_ARRAY_COMPREHENSION";
+        case AST_ARRAY_COMPREHENSION_SIMPLE: return "AST_ARRAY_COMPREHENSION_SIMPLE";
+        case AST_ASSERT: return "AST_ASSERT";
+        case AST_BINARY: return "AST_BINARY";
+        case AST_BUILTIN_FUNCTION: return "AST_BUILTIN_FUNCTION";
+        case AST_CONDITIONAL: return "AST_CONDITIONAL";
+        case AST_DESUGARED_OBJECT: return "AST_DESUGARED_OBJECT";
+        case AST_DOLLAR: return "AST_DOLLAR";
+        case AST_ERROR: return "AST_ERROR";
+        case AST_FUNCTION: return "AST_FUNCTION";
+        case AST_IMPORT: return "AST_IMPORT";
+        case AST_IMPORTSTR: return "AST_IMPORTSTR";
+        case AST_INDEX: return "AST_INDEX";
+        case AST_IN_SUPER: return "AST_IN_SUPER";
+        case AST_LITERAL_BOOLEAN: return "AST_LITERAL_BOOLEAN";
+        case AST_LITERAL_NULL: return "AST_LITERAL_NULL";
+        case AST_LITERAL_NUMBER: return "AST_LITERAL_NUMBER";
+        case AST_LITERAL_STRING: return "AST_LITERAL_STRING";
+        case AST_LOCAL: return "AST_LOCAL";
+        case AST_OBJECT: return "AST_OBJECT";
+        case AST_OBJECT_COMPREHENSION: return "AST_OBJECT_COMPREHENSION";
+        case AST_OBJECT_COMPREHENSION_SIMPLE: return "AST_OBJECT_COMPREHENSION_SIMPLE";
+        case AST_PARENS: return "AST_PARENS";
+        case AST_SELF: return "AST_SELF";
+        case AST_SUPER_INDEX: return "AST_SUPER_INDEX";
+        case AST_UNARY: return "AST_UNARY";
+        case AST_VAR: return "AST_VAR";
+    }
+    std::cerr << "Invalid AST type"
+              << "\n";
+    abort();
+}
+
 /** Represents a variable / parameter / field name. */
 struct Identifier {
-    String name;
-    Identifier(const String &name)
-      : name(name)
-    { }
+    UString name;
+    Identifier(const UString &name) : name(name) {}
 };
 
 static inline std::ostream &operator<<(std::ostream &o, const Identifier *id)
@@ -75,7 +112,6 @@ static inline std::ostream &operator<<(std::ostream &o, const Identifier *id)
 
 typedef std::vector<const Identifier *> Identifiers;
 
-
 /** All AST nodes are subtypes of this class.
  */
 struct AST {
@@ -84,15 +120,13 @@ struct AST {
     Fodder openFodder;
     Identifiers freeVariables;
     AST(const LocationRange &location, ASTType type, const Fodder &open_fodder)
-      : location(location), type(type), openFodder(open_fodder)
-    {
-    }
-    virtual ~AST(void)
+        : location(location), type(type), openFodder(open_fodder)
     {
     }
+    virtual ~AST(void) {}
 };
 
-typedef std::vector<AST*> ASTs;
+typedef std::vector<AST *> ASTs;
 
 /** Either an arg in a function apply, or a param in a closure / other function definition.
  *
@@ -105,48 +139,52 @@ typedef std::vector<AST*> ASTs;
  * used when no argument is bound to the param.
  */
 struct ArgParam {
-    Fodder idFodder;  // Empty if no id.
+    Fodder idFodder;       // Empty if no id.
     const Identifier *id;  // nullptr if there isn't one
-    Fodder eqFodder; // Empty if no id or no expr.
-    AST *expr;  // nullptr if there wasn't one.
-    Fodder commaFodder;  // Before the comma (if there is a comma).
+    Fodder eqFodder;       // Empty if no id or no expr.
+    AST *expr;             // nullptr if there wasn't one.
+    Fodder commaFodder;    // Before the comma (if there is a comma).
     // Only has id
-    ArgParam (const Fodder &id_fodder, const Identifier *id, const Fodder &comma_fodder)
-      : idFodder(id_fodder), id(id), expr(nullptr), commaFodder(comma_fodder)
-    { }
+    ArgParam(const Fodder &id_fodder, const Identifier *id, const Fodder &comma_fodder)
+        : idFodder(id_fodder), id(id), expr(nullptr), commaFodder(comma_fodder)
+    {
+    }
     // Only has expr
-    ArgParam (AST *expr, const Fodder &comma_fodder)
-      : id(nullptr), expr(expr), commaFodder(comma_fodder)
-    { }
+    ArgParam(AST *expr, const Fodder &comma_fodder)
+        : id(nullptr), expr(expr), commaFodder(comma_fodder)
+    {
+    }
     // Has both id and expr
-    ArgParam (const Fodder &id_fodder, const Identifier *id, const Fodder &eq_fodder,
-              AST *expr, const Fodder &comma_fodder)
-      : idFodder(id_fodder), id(id), eqFodder(eq_fodder), expr(expr), commaFodder(comma_fodder)
-    { }
+    ArgParam(const Fodder &id_fodder, const Identifier *id, const Fodder &eq_fodder, AST *expr,
+             const Fodder &comma_fodder)
+        : idFodder(id_fodder), id(id), eqFodder(eq_fodder), expr(expr), commaFodder(comma_fodder)
+    {
+    }
 };
 
 typedef std::vector<ArgParam> ArgParams;
 
 /** Used in Object & Array Comprehensions. */
 struct ComprehensionSpec {
-    enum Kind {
-        FOR,
-        IF
-    };
+    enum Kind { FOR, IF };
     Kind kind;
     Fodder openFodder;
-    Fodder varFodder; // {} when kind != SPEC_FOR.
+    Fodder varFodder;       // {} when kind != SPEC_FOR.
     const Identifier *var;  // Null when kind != SPEC_FOR.
-    Fodder inFodder; // {} when kind != SPEC_FOR.
+    Fodder inFodder;        // {} when kind != SPEC_FOR.
     AST *expr;
     ComprehensionSpec(Kind kind, const Fodder &open_fodder, const Fodder &var_fodder,
                       const Identifier *var, const Fodder &in_fodder, AST *expr)
-      : kind(kind), openFodder(open_fodder), varFodder(var_fodder), var(var), inFodder(in_fodder),
-        expr(expr)
-    { }
+        : kind(kind),
+          openFodder(open_fodder),
+          varFodder(var_fodder),
+          var(var),
+          inFodder(in_fodder),
+          expr(expr)
+    {
+    }
 };
 
-
 /** Represents function calls. */
 struct Apply : public AST {
     AST *target;
@@ -159,10 +197,16 @@ struct Apply : public AST {
     Apply(const LocationRange &lr, const Fodder &open_fodder, AST *target, const Fodder &fodder_l,
           const ArgParams &args, bool trailing_comma, const Fodder &fodder_r,
           const Fodder &tailstrict_fodder, bool tailstrict)
-      : AST(lr, AST_APPLY, open_fodder), target(target), fodderL(fodder_l), args(args),
-        trailingComma(trailing_comma), fodderR(fodder_r), tailstrictFodder(tailstrict_fodder),
-        tailstrict(tailstrict)
-    { }
+        : AST(lr, AST_APPLY, open_fodder),
+          target(target),
+          fodderL(fodder_l),
+          args(args),
+          trailingComma(trailing_comma),
+          fodderR(fodder_r),
+          tailstrictFodder(tailstrict_fodder),
+          tailstrict(tailstrict)
+    {
+    }
 };
 
 /** Represents e { }.  Desugared to e + { }. */
@@ -170,8 +214,9 @@ struct ApplyBrace : public AST {
     AST *left;
     AST *right;  // This is always an object or object comprehension.
     ApplyBrace(const LocationRange &lr, const Fodder &open_fodder, AST *left, AST *right)
-      : AST(lr, AST_BINARY, open_fodder), left(left), right(right)
-    { }
+        : AST(lr, AST_BINARY, open_fodder), left(left), right(right)
+    {
+    }
 };
 
 /** Represents array constructors [1, 2, 3]. */
@@ -179,9 +224,7 @@ struct Array : public AST {
     struct Element {
         AST *expr;
         Fodder commaFodder;
-        Element(AST *expr, const Fodder &comma_fodder)
-          : expr(expr), commaFodder(comma_fodder)
-        { }
+        Element(AST *expr, const Fodder &comma_fodder) : expr(expr), commaFodder(comma_fodder) {}
     };
     typedef std::vector<Element> Elements;
     Elements elements;
@@ -189,14 +232,17 @@ struct Array : public AST {
     Fodder closeFodder;
     Array(const LocationRange &lr, const Fodder &open_fodder, const Elements &elements,
           bool trailing_comma, const Fodder &close_fodder)
-      : AST(lr, AST_ARRAY, open_fodder), elements(elements), trailingComma(trailing_comma),
-        closeFodder(close_fodder)
-    { }
+        : AST(lr, AST_ARRAY, open_fodder),
+          elements(elements),
+          trailingComma(trailing_comma),
+          closeFodder(close_fodder)
+    {
+    }
 };
 
 /** Represents array comprehensions (which are like Python list comprehensions). */
 struct ArrayComprehension : public AST {
-    AST* body;
+    AST *body;
     Fodder commaFodder;
     bool trailingComma;
     std::vector<ComprehensionSpec> specs;
@@ -204,15 +250,19 @@ struct ArrayComprehension : public AST {
     ArrayComprehension(const LocationRange &lr, const Fodder &open_fodder, AST *body,
                        const Fodder &comma_fodder, bool trailing_comma,
                        const std::vector<ComprehensionSpec> &specs, const Fodder &close_fodder)
-      : AST(lr, AST_ARRAY_COMPREHENSION, open_fodder), body(body), commaFodder(comma_fodder),
-        trailingComma(trailing_comma), specs(specs), closeFodder(close_fodder)
+        : AST(lr, AST_ARRAY_COMPREHENSION, open_fodder),
+          body(body),
+          commaFodder(comma_fodder),
+          trailingComma(trailing_comma),
+          specs(specs),
+          closeFodder(close_fodder)
     {
         assert(specs.size() > 0);
     }
 };
 
 /** Represents an assert expression (not an object-level assert).
- * 
+ *
  * After parsing, message can be nullptr indicating that no message was specified. This AST is
  * elimiated by desugaring.
  */
@@ -224,9 +274,14 @@ struct Assert : public AST {
     AST *rest;
     Assert(const LocationRange &lr, const Fodder &open_fodder, AST *cond,
            const Fodder &colon_fodder, AST *message, const Fodder &semicolon_fodder, AST *rest)
-      : AST(lr, AST_ASSERT, open_fodder), cond(cond), colonFodder(colon_fodder),
-        message(message), semicolonFodder(semicolon_fodder), rest(rest)
-    { }
+        : AST(lr, AST_ASSERT, open_fodder),
+          cond(cond),
+          colonFodder(colon_fodder),
+          message(message),
+          semicolonFodder(semicolon_fodder),
+          rest(rest)
+    {
+    }
 };
 
 enum BinaryOp {
@@ -244,6 +299,7 @@ enum BinaryOp {
     BOP_GREATER_EQ,
     BOP_LESS,
     BOP_LESS_EQ,
+    BOP_IN,
 
     BOP_MANIFEST_EQUAL,
     BOP_MANIFEST_UNEQUAL,
@@ -256,7 +312,7 @@ enum BinaryOp {
     BOP_OR
 };
 
-static inline std::string bop_string (BinaryOp bop)
+static inline std::string bop_string(BinaryOp bop)
 {
     switch (bop) {
         case BOP_MULT: return "*";
@@ -273,6 +329,7 @@ static inline std::string bop_string (BinaryOp bop)
         case BOP_GREATER_EQ: return ">=";
         case BOP_LESS: return "<";
         case BOP_LESS_EQ: return "<=";
+        case BOP_IN: return "in";
 
         case BOP_MANIFEST_EQUAL: return "==";
         case BOP_MANIFEST_UNEQUAL: return "!=";
@@ -285,8 +342,8 @@ static inline std::string bop_string (BinaryOp bop)
         case BOP_OR: return "||";
 
         default:
-        std::cerr << "INTERNAL ERROR: Unrecognised binary operator: " << bop << std::endl;
-        std::abort();
+            std::cerr << "INTERNAL ERROR: Unrecognised binary operator: " << bop << std::endl;
+            std::abort();
     }
 }
 
@@ -298,8 +355,9 @@ struct Binary : public AST {
     AST *right;
     Binary(const LocationRange &lr, const Fodder &open_fodder, AST *left, const Fodder &op_fodder,
            BinaryOp op, AST *right)
-      : AST(lr, AST_BINARY, open_fodder), left(left), opFodder(op_fodder), op(op), right(right)
-    { }
+        : AST(lr, AST_BINARY, open_fodder), left(left), opFodder(op_fodder), op(op), right(right)
+    {
+    }
 };
 
 /** Represents built-in functions.
@@ -310,44 +368,48 @@ struct Binary : public AST {
 struct BuiltinFunction : public AST {
     std::string name;
     Identifiers params;
-    BuiltinFunction(const LocationRange &lr, const std::string &name,
-                    const Identifiers &params)
-      : AST(lr, AST_BUILTIN_FUNCTION, Fodder{}), name(name), params(params)
-    { }
+    BuiltinFunction(const LocationRange &lr, const std::string &name, const Identifiers &params)
+        : AST(lr, AST_BUILTIN_FUNCTION, Fodder{}), name(name), params(params)
+    {
+    }
 };
 
 /** Represents if then else.
- * 
+ *
  * After parsing, branchFalse can be nullptr indicating that no else branch was specified.  The
  * desugarer fills this in with a LiteralNull.
  */
 struct Conditional : public AST {
     AST *cond;
-	Fodder thenFodder;
+    Fodder thenFodder;
     AST *branchTrue;
-	Fodder elseFodder;
+    Fodder elseFodder;
     AST *branchFalse;
     Conditional(const LocationRange &lr, const Fodder &open_fodder, AST *cond,
                 const Fodder &then_fodder, AST *branch_true, const Fodder &else_fodder,
                 AST *branch_false)
-      : AST(lr, AST_CONDITIONAL, open_fodder), cond(cond), thenFodder(then_fodder),
-        branchTrue(branch_true), elseFodder(else_fodder), branchFalse(branch_false)
-    { }
+        : AST(lr, AST_CONDITIONAL, open_fodder),
+          cond(cond),
+          thenFodder(then_fodder),
+          branchTrue(branch_true),
+          elseFodder(else_fodder),
+          branchFalse(branch_false)
+    {
+    }
 };
 
 /** Represents the $ keyword. */
 struct Dollar : public AST {
-    Dollar(const LocationRange &lr, const Fodder &open_fodder)
-      : AST(lr, AST_DOLLAR, open_fodder)
-    { }
+    Dollar(const LocationRange &lr, const Fodder &open_fodder) : AST(lr, AST_DOLLAR, open_fodder) {}
 };
 
 /** Represents error e. */
 struct Error : public AST {
     AST *expr;
     Error(const LocationRange &lr, const Fodder &open_fodder, AST *expr)
-      : AST(lr, AST_ERROR, open_fodder), expr(expr)
-    { }
+        : AST(lr, AST_ERROR, open_fodder), expr(expr)
+    {
+    }
 };
 
 /** Represents closures. */
@@ -360,10 +422,14 @@ struct Function : public AST {
     Function(const LocationRange &lr, const Fodder &open_fodder, const Fodder &paren_left_fodder,
              const ArgParams &params, bool trailing_comma, const Fodder &paren_right_fodder,
              AST *body)
-      : AST(lr, AST_FUNCTION, open_fodder), parenLeftFodder(paren_left_fodder),
-        params(params), trailingComma(trailing_comma), parenRightFodder(paren_right_fodder),
-        body(body)
-    { }
+        : AST(lr, AST_FUNCTION, open_fodder),
+          parenLeftFodder(paren_left_fodder),
+          params(params),
+          trailingComma(trailing_comma),
+          parenRightFodder(paren_right_fodder),
+          body(body)
+    {
+    }
 };
 
 struct LiteralString;
@@ -372,16 +438,18 @@ struct LiteralString;
 struct Import : public AST {
     LiteralString *file;
     Import(const LocationRange &lr, const Fodder &open_fodder, LiteralString *file)
-      : AST(lr, AST_IMPORT, open_fodder), file(file)
-    { }
+        : AST(lr, AST_IMPORT, open_fodder), file(file)
+    {
+    }
 };
 
 /** Represents importstr "file". */
 struct Importstr : public AST {
     LiteralString *file;
     Importstr(const LocationRange &lr, const Fodder &open_fodder, LiteralString *file)
-      : AST(lr, AST_IMPORTSTR, open_fodder), file(file)
-    { }
+        : AST(lr, AST_IMPORTSTR, open_fodder), file(file)
+    {
+    }
 };
 
 /** Represents both e[e] and the syntax sugar e.f.
@@ -402,17 +470,34 @@ struct Index : public AST {
     // Use this constructor for e.f
     Index(const LocationRange &lr, const Fodder &open_fodder, AST *target, const Fodder &dot_fodder,
           const Fodder &id_fodder, const Identifier *id)
-      : AST(lr, AST_INDEX, open_fodder), target(target), dotFodder(dot_fodder), isSlice(false),
-        index(nullptr), end(nullptr), step(nullptr), idFodder(id_fodder), id(id)
-    { }
-    // Use this constructor for e[x:y:z] with nullptr for end or step if not present. 
+        : AST(lr, AST_INDEX, open_fodder),
+          target(target),
+          dotFodder(dot_fodder),
+          isSlice(false),
+          index(nullptr),
+          end(nullptr),
+          step(nullptr),
+          idFodder(id_fodder),
+          id(id)
+    {
+    }
+    // Use this constructor for e[x:y:z] with nullptr for index, end or step if not present.
     Index(const LocationRange &lr, const Fodder &open_fodder, AST *target, const Fodder &dot_fodder,
           bool is_slice, AST *index, const Fodder &end_colon_fodder, AST *end,
           const Fodder &step_colon_fodder, AST *step, const Fodder &id_fodder)
-      : AST(lr, AST_INDEX, open_fodder), target(target), dotFodder(dot_fodder), isSlice(is_slice),
-        index(index), endColonFodder(end_colon_fodder), end(end),
-        stepColonFodder(step_colon_fodder), step(step), idFodder(id_fodder), id(nullptr)
-    { }
+        : AST(lr, AST_INDEX, open_fodder),
+          target(target),
+          dotFodder(dot_fodder),
+          isSlice(is_slice),
+          index(index),
+          endColonFodder(end_colon_fodder),
+          end(end),
+          stepColonFodder(step_colon_fodder),
+          step(step),
+          idFodder(id_fodder),
+          id(nullptr)
+    {
+    }
 };
 
 /** Represents local x = e; e.  After desugaring, functionSugar is false. */
@@ -431,33 +516,43 @@ struct Local : public AST {
         Bind(const Fodder &var_fodder, const Identifier *var, const Fodder &op_fodder, AST *body,
              bool function_sugar, const Fodder &paren_left_fodder, const ArgParams &params,
              bool trailing_comma, const Fodder &paren_right_fodder, const Fodder &close_fodder)
-          : varFodder(var_fodder), var(var), opFodder(op_fodder), body(body),
-            functionSugar(function_sugar), parenLeftFodder(paren_left_fodder), params(params),
-            trailingComma(trailing_comma), parenRightFodder(paren_right_fodder),
-            closeFodder(close_fodder)
-        { }
+            : varFodder(var_fodder),
+              var(var),
+              opFodder(op_fodder),
+              body(body),
+              functionSugar(function_sugar),
+              parenLeftFodder(paren_left_fodder),
+              params(params),
+              trailingComma(trailing_comma),
+              parenRightFodder(paren_right_fodder),
+              closeFodder(close_fodder)
+        {
+        }
     };
     typedef std::vector<Bind> Binds;
     Binds binds;
     AST *body;
     Local(const LocationRange &lr, const Fodder &open_fodder, const Binds &binds, AST *body)
-      : AST(lr, AST_LOCAL, open_fodder), binds(binds), body(body)
-    { }
+        : AST(lr, AST_LOCAL, open_fodder), binds(binds), body(body)
+    {
+    }
 };
 
 /** Represents true and false. */
 struct LiteralBoolean : public AST {
     bool value;
     LiteralBoolean(const LocationRange &lr, const Fodder &open_fodder, bool value)
-      : AST(lr, AST_LITERAL_BOOLEAN, open_fodder), value(value)
-    { }
+        : AST(lr, AST_LITERAL_BOOLEAN, open_fodder), value(value)
+    {
+    }
 };
 
 /** Represents the null keyword. */
 struct LiteralNull : public AST {
     LiteralNull(const LocationRange &lr, const Fodder &open_fodder)
-      : AST(lr, AST_LITERAL_NULL, open_fodder)
-    { }
+        : AST(lr, AST_LITERAL_NULL, open_fodder)
+    {
+    }
 };
 
 /** Represents JSON numbers. */
@@ -465,27 +560,32 @@ struct LiteralNumber : public AST {
     double value;
     std::string originalString;
     LiteralNumber(const LocationRange &lr, const Fodder &open_fodder, const std::string &str)
-      : AST(lr, AST_LITERAL_NUMBER, open_fodder), value(strtod(str.c_str(), nullptr)),
-        originalString(str)
-    { }
+        : AST(lr, AST_LITERAL_NUMBER, open_fodder),
+          value(strtod(str.c_str(), nullptr)),
+          originalString(str)
+    {
+    }
 };
 
 /** Represents JSON strings. */
 struct LiteralString : public AST {
-    String value;
-    enum TokenKind { SINGLE, DOUBLE, BLOCK };
+    UString value;
+    enum TokenKind { SINGLE, DOUBLE, BLOCK, VERBATIM_SINGLE, VERBATIM_DOUBLE };
     TokenKind tokenKind;
-    std::string blockIndent;  // Only contains ' ' and '\t'.
+    std::string blockIndent;      // Only contains ' ' and '\t'.
     std::string blockTermIndent;  // Only contains ' ' and '\t'.
-    LiteralString(const LocationRange &lr, const Fodder &open_fodder, const String &value,
+    LiteralString(const LocationRange &lr, const Fodder &open_fodder, const UString &value,
                   TokenKind token_kind, const std::string &block_indent,
                   const std::string &block_term_indent)
-      : AST(lr, AST_LITERAL_STRING, open_fodder), value(value), tokenKind(token_kind),
-        blockIndent(block_indent), blockTermIndent(block_term_indent)
-    { }
+        : AST(lr, AST_LITERAL_STRING, open_fodder),
+          value(value),
+          tokenKind(token_kind),
+          blockIndent(block_indent),
+          blockTermIndent(block_term_indent)
+    {
+    }
 };
 
-
 struct ObjectField {
     // Depending on the kind of Jsonnet field, the fields of this C++ class are used for storing
     // different parts of the AST.
@@ -494,7 +594,7 @@ struct ObjectField {
         // <fodder1> 'assert' <expr2>
         // [ <opFodder> : <expr3> ]
         // <commaFodder>
-        ASSERT, 
+        ASSERT,
 
         // <fodder1> id
         // [ <fodderL> '(' <params> <fodderR> ')' ]
@@ -524,32 +624,44 @@ struct ObjectField {
     // NOTE TO SELF: sort out fodder1-4, then modify desugarer (maybe) parser and unparser.
 
     enum Hide {
-        HIDDEN,  // f:: e
+        HIDDEN,   // f:: e
         INHERIT,  // f: e
         VISIBLE,  // f::: e
     };
     enum Kind kind;
     Fodder fodder1, fodder2, fodderL, fodderR;
-    enum Hide hide;  // (ignore if kind != FIELD_something
-    bool superSugar;  // +:  (ignore if kind != FIELD_something)
+    enum Hide hide;    // (ignore if kind != FIELD_something
+    bool superSugar;   // +:  (ignore if kind != FIELD_something)
     bool methodSugar;  // f(x, y, z): ...  (ignore if kind  == ASSERT)
-    AST *expr1;  // Not in scope of the object
+    AST *expr1;        // Not in scope of the object
     const Identifier *id;
-    ArgParams params;  // If methodSugar == true then holds the params.
+    ArgParams params;    // If methodSugar == true then holds the params.
     bool trailingComma;  // If methodSugar == true then remembers the trailing comma.
-    Fodder opFodder;  // Before the : or =
+    Fodder opFodder;     // Before the : or =
     AST *expr2, *expr3;  // In scope of the object (can see self).
     Fodder commaFodder;  // If this field is followed by a comma, this is its fodder.
 
-    ObjectField(
-        enum Kind kind, const Fodder &fodder1, const Fodder &fodder2, const Fodder &fodder_l,
-        const Fodder &fodder_r, enum Hide hide, bool super_sugar, bool method_sugar, AST *expr1,
-        const Identifier *id, const ArgParams &params, bool trailing_comma, const Fodder &op_fodder,
-        AST *expr2, AST *expr3, const Fodder &comma_fodder)
-        : kind(kind), fodder1(fodder1), fodder2(fodder2), fodderL(fodder_l), fodderR(fodder_r),
-          hide(hide), superSugar(super_sugar), methodSugar(method_sugar), expr1(expr1), id(id),
-          params(params), trailingComma(trailing_comma), opFodder(op_fodder), expr2(expr2),
-          expr3(expr3), commaFodder(comma_fodder)
+    ObjectField(enum Kind kind, const Fodder &fodder1, const Fodder &fodder2,
+                const Fodder &fodder_l, const Fodder &fodder_r, enum Hide hide, bool super_sugar,
+                bool method_sugar, AST *expr1, const Identifier *id, const ArgParams &params,
+                bool trailing_comma, const Fodder &op_fodder, AST *expr2, AST *expr3,
+                const Fodder &comma_fodder)
+        : kind(kind),
+          fodder1(fodder1),
+          fodder2(fodder2),
+          fodderL(fodder_l),
+          fodderR(fodder_r),
+          hide(hide),
+          superSugar(super_sugar),
+          methodSugar(method_sugar),
+          expr1(expr1),
+          id(id),
+          params(params),
+          trailingComma(trailing_comma),
+          opFodder(op_fodder),
+          expr2(expr2),
+          expr3(expr3),
+          commaFodder(comma_fodder)
     {
         // Enforce what is written in comments above.
         assert(kind != ASSERT || (hide == VISIBLE && !superSugar && !methodSugar));
@@ -560,38 +672,90 @@ struct ObjectField {
         assert(kind == ASSERT || expr3 == nullptr);
     }
     // For when we don't know if it's a function or not.
-    static ObjectField Local(
-        const Fodder &fodder1, const Fodder &fodder2, const Fodder &fodder_l,
-        const Fodder &fodder_r, bool method_sugar, const Identifier *id, const ArgParams &params,
-        bool trailing_comma, const Fodder &op_fodder, AST *body, const Fodder &comma_fodder)
+    static ObjectField Local(const Fodder &fodder1, const Fodder &fodder2, const Fodder &fodder_l,
+                             const Fodder &fodder_r, bool method_sugar, const Identifier *id,
+                             const ArgParams &params, bool trailing_comma, const Fodder &op_fodder,
+                             AST *body, const Fodder &comma_fodder)
     {
-        return ObjectField(
-            LOCAL, fodder1, fodder2, fodder_l, fodder_r, VISIBLE, false, method_sugar, nullptr, id,
-            params, trailing_comma, op_fodder, body, nullptr, comma_fodder);
+        return ObjectField(LOCAL,
+                           fodder1,
+                           fodder2,
+                           fodder_l,
+                           fodder_r,
+                           VISIBLE,
+                           false,
+                           method_sugar,
+                           nullptr,
+                           id,
+                           params,
+                           trailing_comma,
+                           op_fodder,
+                           body,
+                           nullptr,
+                           comma_fodder);
     }
-    static ObjectField Local(
-        const Fodder &fodder1, const Fodder &fodder2, const Identifier *id,
-        const Fodder &op_fodder, AST *body, const Fodder &comma_fodder)
+    static ObjectField Local(const Fodder &fodder1, const Fodder &fodder2, const Identifier *id,
+                             const Fodder &op_fodder, AST *body, const Fodder &comma_fodder)
     {
-        return ObjectField(
-            LOCAL, fodder1, fodder2, Fodder{}, Fodder{}, VISIBLE, false, false, nullptr, id,
-            ArgParams{}, false, op_fodder, body, nullptr, comma_fodder);
+        return ObjectField(LOCAL,
+                           fodder1,
+                           fodder2,
+                           Fodder{},
+                           Fodder{},
+                           VISIBLE,
+                           false,
+                           false,
+                           nullptr,
+                           id,
+                           ArgParams{},
+                           false,
+                           op_fodder,
+                           body,
+                           nullptr,
+                           comma_fodder);
     }
-    static ObjectField LocalMethod(
-        const Fodder &fodder1, const Fodder &fodder2, const Fodder &fodder_l,
-        const Fodder &fodder_r, const Identifier *id, const ArgParams &params, bool trailing_comma,
-        const Fodder &op_fodder, AST *body, const Fodder &comma_fodder)
+    static ObjectField LocalMethod(const Fodder &fodder1, const Fodder &fodder2,
+                                   const Fodder &fodder_l, const Fodder &fodder_r,
+                                   const Identifier *id, const ArgParams &params,
+                                   bool trailing_comma, const Fodder &op_fodder, AST *body,
+                                   const Fodder &comma_fodder)
     {
-        return ObjectField(
-            LOCAL, fodder1, fodder2, fodder_l, fodder_r, VISIBLE, false, true, nullptr, id, params,
-            trailing_comma, op_fodder, body, nullptr, comma_fodder);
+        return ObjectField(LOCAL,
+                           fodder1,
+                           fodder2,
+                           fodder_l,
+                           fodder_r,
+                           VISIBLE,
+                           false,
+                           true,
+                           nullptr,
+                           id,
+                           params,
+                           trailing_comma,
+                           op_fodder,
+                           body,
+                           nullptr,
+                           comma_fodder);
     }
     static ObjectField Assert(const Fodder &fodder1, AST *body, const Fodder &op_fodder, AST *msg,
                               const Fodder &comma_fodder)
     {
-        return ObjectField(
-            ASSERT, fodder1, Fodder{}, Fodder{}, Fodder{}, VISIBLE, false, false, nullptr, nullptr,
-            ArgParams{}, false, op_fodder, body, msg, comma_fodder);
+        return ObjectField(ASSERT,
+                           fodder1,
+                           Fodder{},
+                           Fodder{},
+                           Fodder{},
+                           VISIBLE,
+                           false,
+                           false,
+                           nullptr,
+                           nullptr,
+                           ArgParams{},
+                           false,
+                           op_fodder,
+                           body,
+                           msg,
+                           comma_fodder);
     }
 };
 typedef std::vector<ObjectField> ObjectFields;
@@ -607,8 +771,10 @@ struct Object : public AST {
     Fodder closeFodder;
     Object(const LocationRange &lr, const Fodder &open_fodder, const ObjectFields &fields,
            bool trailing_comma, const Fodder &close_fodder)
-      : AST(lr, AST_OBJECT, open_fodder), fields(fields), trailingComma(trailing_comma),
-        closeFodder(close_fodder)
+        : AST(lr, AST_OBJECT, open_fodder),
+          fields(fields),
+          trailingComma(trailing_comma),
+          closeFodder(close_fodder)
     {
         assert(fields.size() > 0 || !trailing_comma);
         if (fields.size() > 0)
@@ -626,18 +792,19 @@ struct DesugaredObject : public AST {
         AST *name;
         AST *body;
         Field(enum ObjectField::Hide hide, AST *name, AST *body)
-          : hide(hide), name(name), body(body)
-        { }
+            : hide(hide), name(name), body(body)
+        {
+        }
     };
     typedef std::vector<Field> Fields;
     ASTs asserts;
     Fields fields;
     DesugaredObject(const LocationRange &lr, const ASTs &asserts, const Fields &fields)
-      : AST(lr, AST_DESUGARED_OBJECT, Fodder{}), asserts(asserts), fields(fields)
-    { }
+        : AST(lr, AST_DESUGARED_OBJECT, Fodder{}), asserts(asserts), fields(fields)
+    {
+    }
 };
 
-
 /** Represents object comprehension { [e]: e for x in e for.. if... }. */
 struct ObjectComprehension : public AST {
     ObjectFields fields;
@@ -647,10 +814,14 @@ struct ObjectComprehension : public AST {
     ObjectComprehension(const LocationRange &lr, const Fodder &open_fodder,
                         const ObjectFields &fields, bool trailing_comma,
                         const std::vector<ComprehensionSpec> &specs, const Fodder &close_fodder)
-                        
-      : AST(lr, AST_OBJECT_COMPREHENSION, open_fodder), fields(fields),
-        trailingComma(trailing_comma), specs(specs), closeFodder(close_fodder)
-    { }
+
+        : AST(lr, AST_OBJECT_COMPREHENSION, open_fodder),
+          fields(fields),
+          trailingComma(trailing_comma),
+          specs(specs),
+          closeFodder(close_fodder)
+    {
+    }
 };
 
 /** Represents post-desugaring object comprehension { [e]: e for x in e }. */
@@ -659,10 +830,15 @@ struct ObjectComprehensionSimple : public AST {
     AST *value;
     const Identifier *id;
     AST *array;
-    ObjectComprehensionSimple(const LocationRange &lr, AST *field, AST *value,
-                              const Identifier *id, AST *array)
-      : AST(lr, AST_OBJECT_COMPREHENSION_SIMPLE, Fodder{}), field(field), value(value), id(id), array(array)
-    { }
+    ObjectComprehensionSimple(const LocationRange &lr, AST *field, AST *value, const Identifier *id,
+                              AST *array)
+        : AST(lr, AST_OBJECT_COMPREHENSION_SIMPLE, Fodder{}),
+          field(field),
+          value(value),
+          id(id),
+          array(array)
+    {
+    }
 };
 
 /** Represents (e), which is desugared. */
@@ -671,15 +847,14 @@ struct Parens : public AST {
     Fodder closeFodder;
     Parens(const LocationRange &lr, const Fodder &open_fodder, AST *expr,
            const Fodder &close_fodder)
-      : AST(lr, AST_PARENS, open_fodder), expr(expr), closeFodder(close_fodder)
-    { }
+        : AST(lr, AST_PARENS, open_fodder), expr(expr), closeFodder(close_fodder)
+    {
+    }
 };
 
 /** Represents the self keyword. */
 struct Self : public AST {
-    Self(const LocationRange &lr, const Fodder &open_fodder)
-      : AST(lr, AST_SELF, open_fodder)
-    { }
+    Self(const LocationRange &lr, const Fodder &open_fodder) : AST(lr, AST_SELF, open_fodder) {}
 };
 
 /** Represents the super[e] and super.f constructs.
@@ -694,19 +869,34 @@ struct SuperIndex : public AST {
     const Identifier *id;
     SuperIndex(const LocationRange &lr, const Fodder &open_fodder, const Fodder &dot_fodder,
                AST *index, const Fodder &id_fodder, const Identifier *id)
-      : AST(lr, AST_SUPER_INDEX, open_fodder), dotFodder(dot_fodder), index(index),
-        idFodder(id_fodder), id(id)
-    { }
+        : AST(lr, AST_SUPER_INDEX, open_fodder),
+          dotFodder(dot_fodder),
+          index(index),
+          idFodder(id_fodder),
+          id(id)
+    {
+    }
 };
 
-enum UnaryOp {
-    UOP_NOT,
-    UOP_BITWISE_NOT,
-    UOP_PLUS,
-    UOP_MINUS
+/** Represents the e in super construct.
+ */
+struct InSuper : public AST {
+    AST *element;
+    Fodder inFodder;
+    Fodder superFodder;
+    InSuper(const LocationRange &lr, const Fodder &open_fodder, AST *element,
+            const Fodder &in_fodder, const Fodder &super_fodder)
+        : AST(lr, AST_IN_SUPER, open_fodder),
+          element(element),
+          inFodder(in_fodder),
+          superFodder(super_fodder)
+    {
+    }
 };
 
-static inline std::string uop_string (UnaryOp uop)
+enum UnaryOp { UOP_NOT, UOP_BITWISE_NOT, UOP_PLUS, UOP_MINUS };
+
+static inline std::string uop_string(UnaryOp uop)
 {
     switch (uop) {
         case UOP_PLUS: return "+";
@@ -715,46 +905,57 @@ static inline std::string uop_string (UnaryOp uop)
         case UOP_NOT: return "!";
 
         default:
-        std::cerr << "INTERNAL ERROR: Unrecognised unary operator: " << uop << std::endl;
-        std::abort();
+            std::cerr << "INTERNAL ERROR: Unrecognised unary operator: " << uop << std::endl;
+            std::abort();
     }
 }
 
 /** Represents unary operators. */
 struct Unary : public AST {
-   UnaryOp op;
+    UnaryOp op;
     AST *expr;
     Unary(const LocationRange &lr, const Fodder &open_fodder, UnaryOp op, AST *expr)
-      : AST(lr, AST_UNARY, open_fodder), op(op), expr(expr)
-    { }
+        : AST(lr, AST_UNARY, open_fodder), op(op), expr(expr)
+    {
+    }
 };
 
 /** Represents variables. */
 struct Var : public AST {
     const Identifier *id;
     Var(const LocationRange &lr, const Fodder &open_fodder, const Identifier *id)
-      : AST(lr, AST_VAR, open_fodder), id(id)
-    { }
+        : AST(lr, AST_VAR, open_fodder), id(id)
+    {
+    }
 };
 
-
 /** Allocates ASTs on demand, frees them in its destructor.
  */
 class Allocator {
-    std::map<String, const Identifier*> internedIdentifiers;
+    std::map<UString, const Identifier *> internedIdentifiers;
     ASTs allocated;
-    public:
-    template <class T, class... Args> T* make(Args&&... args)
+
+   public:
+    template <class T, class... Args>
+    T *make(Args &&... args)
     {
         auto r = new T(std::forward<Args>(args)...);
         allocated.push_back(r);
         return r;
     }
+
+    template <class T>
+    T *clone(T *ast)
+    {
+        auto r = new T(*ast);
+        allocated.push_back(r);
+        return r;
+    }
     /** Returns interned identifiers.
      *
      * The location used in the Identifier AST is that of the first one parsed.
      */
-    const Identifier *makeIdentifier(const String &name)
+    const Identifier *makeIdentifier(const UString &name)
     {
         auto it = internedIdentifiers.find(name);
         if (it != internedIdentifiers.end()) {
@@ -780,10 +981,10 @@ class Allocator {
 namespace {
 
 // Precedences used by various compilation units are defined here.
-const int APPLY_PRECEDENCE = 2;  // Function calls and indexing.
-const int UNARY_PRECEDENCE = 4;  // Logical and bitwise negation, unary + -
-const int BEFORE_ELSE_PRECEDENCE = 15; // True branch of an if.
-const int MAX_PRECEDENCE = 16; // Local, If, Import, Function, Error
+const int APPLY_PRECEDENCE = 2;         // Function calls and indexing.
+const int UNARY_PRECEDENCE = 4;         // Logical and bitwise negation, unary + -
+const int BEFORE_ELSE_PRECEDENCE = 15;  // True branch of an if.
+const int MAX_PRECEDENCE = 16;          // Local, If, Import, Function, Error
 
 /** These are the binary operator precedences, unary precedence is given by
  * UNARY_PRECEDENCE.
@@ -806,6 +1007,7 @@ std::map<BinaryOp, int> build_precedence_map(void)
     r[BOP_GREATER_EQ] = 8;
     r[BOP_LESS] = 8;
     r[BOP_LESS_EQ] = 8;
+    r[BOP_IN] = 8;
 
     r[BOP_MANIFEST_EQUAL] = 9;
     r[BOP_MANIFEST_UNEQUAL] = 9;
@@ -851,6 +1053,7 @@ std::map<std::string, BinaryOp> build_binary_map(void)
     r[">="] = BOP_GREATER_EQ;
     r["<"] = BOP_LESS;
     r["<="] = BOP_LESS_EQ;
+    r["in"] = BOP_IN;
 
     r["=="] = BOP_MANIFEST_EQUAL;
     r["!="] = BOP_MANIFEST_UNEQUAL;
diff --git a/libjsonnet/core/desugarer.cpp b/libjsonnet/core/desugarer.cpp
index 2353212..5d0564f 100644
--- a/libjsonnet/core/desugarer.cpp
+++ b/libjsonnet/core/desugarer.cpp
@@ -20,6 +20,7 @@ limitations under the License.
 #include "desugarer.h"
 #include "lexer.h"
 #include "parser.h"
+#include "pass.h"
 #include "string_utils.h"
 
 static const Fodder EF;  // Empty fodder.
@@ -27,11 +28,11 @@ static const Fodder EF;  // Empty fodder.
 static const LocationRange E;  // Empty.
 
 struct BuiltinDecl {
-    String name;
-    std::vector<String> params;
+    UString name;
+    std::vector<UString> params;
 };
 
-static unsigned long max_builtin = 25;
+static unsigned long max_builtin = 26;
 BuiltinDecl jsonnet_builtin_decl(unsigned long builtin)
 {
     switch (builtin) {
@@ -61,16 +62,17 @@ BuiltinDecl jsonnet_builtin_decl(unsigned long builtin)
         case 23: return {U"extVar", {U"x"}};
         case 24: return {U"primitiveEquals", {U"a", U"b"}};
         case 25: return {U"native", {U"name"}};
+        case 26: return {U"md5", {U"str"}};
         default:
-        std::cerr << "INTERNAL ERROR: Unrecognized builtin function: " << builtin << std::endl;
-        std::abort();
+            std::cerr << "INTERNAL ERROR: Unrecognized builtin function: " << builtin << std::endl;
+            std::abort();
     }
     // Quiet, compiler.
     return BuiltinDecl();
 }
 
 static constexpr char STD_CODE[] = {
-    #include "std.jsonnet.h"
+#include "std.jsonnet.h"
 };
 
 /** Desugar Jsonnet expressions to reduce the number of constructs the rest of the implementation
@@ -81,32 +83,48 @@ static constexpr char STD_CODE[] = {
  * variables used in user code.
  */
 class Desugarer {
-
     Allocator *alloc;
 
-    template <class T, class... Args> T* make(Args&&... args)
+    template <class T, class... Args>
+    T *make(Args &&... args)
     {
         return alloc->make<T>(std::forward<Args>(args)...);
     }
 
-    const Identifier *id(const String &s)
-    { return alloc->makeIdentifier(s); }
+    AST *clone(AST *ast)
+    {
+        return clone_ast(*alloc, ast);
+    }
 
-    LiteralString *str(const String &s)
-    { return make<LiteralString>(E, EF, s, LiteralString::DOUBLE, "", ""); }
+    const Identifier *id(const UString &s)
+    {
+        return alloc->makeIdentifier(s);
+    }
+
+    LiteralString *str(const UString &s)
+    {
+        return make<LiteralString>(E, EF, s, LiteralString::DOUBLE, "", "");
+    }
 
-    LiteralString *str(const LocationRange &loc, const String &s)
-    { return make<LiteralString>(loc, EF, s, LiteralString::DOUBLE, "", ""); }
+    LiteralString *str(const LocationRange &loc, const UString &s)
+    {
+        return make<LiteralString>(loc, EF, s, LiteralString::DOUBLE, "", "");
+    }
 
     LiteralNull *null(void)
-    { return make<LiteralNull>(E, EF); }
+    {
+        return make<LiteralNull>(E, EF);
+    }
 
     Var *var(const Identifier *ident)
-    { return make<Var>(E, EF, ident); }
+    {
+        return make<Var>(E, EF, ident);
+    }
 
     Var *std(void)
-    { return var(id(U"std")); }
-
+    {
+        return var(id(U"std"));
+    }
 
     Local::Bind bind(const Identifier *id, AST *body)
     {
@@ -120,11 +138,11 @@ class Desugarer {
 
     Array *singleton(AST *body)
     {
-        return make<Array>(body->location, EF, Array::Elements{Array::Element(body, EF)},
-                           false, EF);
+        return make<Array>(
+            body->location, EF, Array::Elements{Array::Element(body, EF)}, false, EF);
     }
 
-    Apply *stdFunc(const String &name, AST *v)
+    Apply *stdFunc(const UString &name, AST *v)
     {
         return make<Apply>(
             v->location,
@@ -139,7 +157,7 @@ class Desugarer {
         );
     }
 
-    Apply *stdFunc(const LocationRange &loc, const String &name, AST *a, AST *b)
+    Apply *stdFunc(const LocationRange &loc, const UString &name, AST *a, AST *b)
     {
         return make<Apply>(
             loc,
@@ -179,15 +197,13 @@ class Desugarer {
         return make<Error>(msg->location, EF, msg);
     }
 
-    Error *error(const LocationRange &loc, const String &msg)
+    Error *error(const LocationRange &loc, const UString &msg)
     {
         return error(str(loc, msg));
     }
 
-    public:
-    Desugarer(Allocator *alloc)
-      : alloc(alloc)
-    { }
+   public:
+    Desugarer(Allocator *alloc) : alloc(alloc) {}
 
     void desugarParams(ArgParams &params, unsigned obj_level)
     {
@@ -199,19 +215,26 @@ class Desugarer {
         }
     }
 
-    void desugarFields(AST *ast, ObjectFields &fields, unsigned obj_level)
+    // For all occurrences, records the identifier that will replace super[e]
+    // If self occurs, also map the self identifier to nullptr.
+    typedef std::vector<std::pair<const Identifier *, AST *>> SuperVars;
+
+    SuperVars desugarFields(AST *ast, ObjectFields &fields, unsigned obj_level)
     {
         // Desugar children
         for (auto &field : fields) {
-            if (field.expr1 != nullptr) desugar(field.expr1, obj_level);
+            if (field.expr1 != nullptr)
+                desugar(field.expr1, obj_level);
             desugar(field.expr2, obj_level + 1);
-            if (field.expr3 != nullptr) desugar(field.expr3, obj_level + 1);
+            if (field.expr3 != nullptr)
+                desugar(field.expr3, obj_level + 1);
             desugarParams(field.params, obj_level + 1);
         }
 
         // Simplify asserts
         for (auto &field : fields) {
-            if (field.kind != ObjectField::ASSERT) continue;
+            if (field.kind != ObjectField::ASSERT)
+                continue;
             AST *msg = field.expr3;
             field.expr3 = nullptr;
             if (msg == nullptr) {
@@ -220,37 +243,42 @@ class Desugarer {
             }
 
             // if expr2 then true else error msg
-            field.expr2 = make<Conditional>(
-                field.expr2->location,
-                EF,
-                field.expr2,
-                EF,
-                make<LiteralBoolean>(E, EF, true),
-                EF,
-                error(msg));
+            field.expr2 = make<Conditional>(field.expr2->location,
+                                            EF,
+                                            field.expr2,
+                                            EF,
+                                            make<LiteralBoolean>(E, EF, true),
+                                            EF,
+                                            error(msg));
         }
 
         // Remove methods
         for (auto &field : fields) {
-            if (!field.methodSugar) continue;
-            field.expr2 = make<Function>(
-                field.expr2->location, EF, field.fodderL, field.params, field.trailingComma,
-                field.fodderR, field.expr2);
+            if (!field.methodSugar)
+                continue;
+            field.expr2 = make<Function>(field.expr2->location,
+                                         EF,
+                                         field.fodderL,
+                                         field.params,
+                                         field.trailingComma,
+                                         field.fodderR,
+                                         field.expr2);
             field.methodSugar = false;
             field.params.clear();
         }
 
-
         // Remove object-level locals
         auto copy = fields;
         fields.clear();
         Local::Binds binds;
         for (auto &local : copy) {
-            if (local.kind != ObjectField::LOCAL) continue;
+            if (local.kind != ObjectField::LOCAL)
+                continue;
             binds.push_back(bind(local.id, local.expr2));
         }
         for (auto &field : copy) {
-            if (field.kind == ObjectField::LOCAL) continue;
+            if (field.kind == ObjectField::LOCAL)
+                continue;
             if (!binds.empty())
                 field.expr2 = make<Local>(field.expr2->location, EF, binds, field.expr2);
             fields.push_back(field);
@@ -260,58 +288,128 @@ class Desugarer {
         for (auto &field : fields) {
             switch (field.kind) {
                 case ObjectField::ASSERT:
-                // Nothing to do.
-                break;
+                    // Nothing to do.
+                    break;
 
                 case ObjectField::FIELD_ID:
-                field.expr1 = str(field.id->name);
-                field.kind = ObjectField::FIELD_EXPR;
-                break;
+                    field.expr1 = str(field.id->name);
+                    field.kind = ObjectField::FIELD_EXPR;
+                    break;
 
                 case ObjectField::FIELD_EXPR:
-                // Nothing to do.
-                break;
+                    // Nothing to do.
+                    break;
 
                 case ObjectField::FIELD_STR:
-                // Just set the flag.
-                field.kind = ObjectField::FIELD_EXPR;
-                break;
+                    // Just set the flag.
+                    field.kind = ObjectField::FIELD_EXPR;
+                    break;
 
                 case ObjectField::LOCAL:
-                std::cerr << "Locals should be removed by now." << std::endl;
-                abort();
+                    std::cerr << "Locals should be removed by now." << std::endl;
+                    abort();
             }
         }
 
+        /** Replaces all occurrences of self, super[f] and e in super with variables.
+         *
+         * Returns all variables and original expressions via super_vars.
+         */
+        class SubstituteSelfSuper : public CompilerPass {
+            Desugarer *desugarer;
+            SuperVars &superVars;
+            unsigned &counter;
+            const Identifier *newSelf;
+
+           public:
+            SubstituteSelfSuper(Desugarer *desugarer, SuperVars &super_vars, unsigned &counter)
+                : CompilerPass(*desugarer->alloc),
+                  desugarer(desugarer),
+                  superVars(super_vars),
+                  counter(counter),
+                  newSelf(nullptr)
+            {
+            }
+            void visitExpr(AST *&expr)
+            {
+                if (dynamic_cast<Self *>(expr)) {
+                    if (newSelf == nullptr) {
+                        newSelf = desugarer->id(U"$outer_self");
+                        superVars.emplace_back(newSelf, nullptr);
+                    }
+                    expr = alloc.make<Var>(expr->location, expr->openFodder, newSelf);
+                } else if (auto *super_index = dynamic_cast<SuperIndex *>(expr)) {
+                    UStringStream ss;
+                    ss << U"$outer_super_index" << (counter++);
+                    const Identifier *super_var = desugarer->id(ss.str());
+                    AST *index = super_index->index;
+                    // Desugaring of expr should already have occurred.
+                    assert(index != nullptr);
+                    // Re-use super_index since we're replacing it here.
+                    superVars.emplace_back(super_var, super_index);
+                    expr = alloc.make<Var>(expr->location, expr->openFodder, super_var);
+                } else if (auto *in_super = dynamic_cast<InSuper *>(expr)) {
+                    UStringStream ss;
+                    ss << U"$outer_in_super" << (counter++);
+                    const Identifier *in_super_var = desugarer->id(ss.str());
+                    // Re-use in_super since we're replacing it here.
+                    superVars.emplace_back(in_super_var, in_super);
+                    expr = alloc.make<Var>(expr->location, expr->openFodder, in_super_var);
+                }
+                CompilerPass::visitExpr(expr);
+            }
+        };
+
+        SuperVars super_vars;
+        unsigned counter = 0;
+
         // Remove +:
         for (auto &field : fields) {
-            if (!field.superSugar) continue;
-            AST *super_f = make<SuperIndex>(field.expr1->location, EF, EF, field.expr1, EF,
-                                                   nullptr);
-            field.expr2 = make<Binary>(ast->location, EF, super_f, EF, BOP_PLUS,
-                                              field.expr2);
+            if (!field.superSugar)
+                continue;
+            // We have to bind self/super from expr1 outside the class, as we copy the expression
+            // into the field body.
+            // Clone it so that we maintain the AST as a tree.
+            AST *index = clone(field.expr1);
+            // This will remove self/super.
+            SubstituteSelfSuper(this, super_vars, counter).expr(index);
+            field.expr2 = make<Conditional>(
+                ast->location,
+                EF,
+                make<InSuper>(ast->location, EF, index, EF, EF),
+                EF,
+                make<Binary>(ast->location,
+                             EF,
+                             make<SuperIndex>(ast->location, EF, EF, clone(index), EF, nullptr),
+                             EF,
+                             BOP_PLUS,
+                             field.expr2),
+                EF,
+                clone(field.expr2));
             field.superSugar = false;
         }
+
+        return super_vars;
     }
 
     void desugar(AST *&ast_, unsigned obj_level)
     {
-        if (auto *ast = dynamic_cast<Apply*>(ast_)) {
+        if (auto *ast = dynamic_cast<Apply *>(ast_)) {
             desugar(ast->target, obj_level);
             for (ArgParam &arg : ast->args)
                 desugar(arg.expr, obj_level);
 
-        } else if (auto *ast = dynamic_cast<ApplyBrace*>(ast_)) {
+        } else if (auto *ast = dynamic_cast<ApplyBrace *>(ast_)) {
             desugar(ast->left, obj_level);
             desugar(ast->right, obj_level);
-            ast_ = make<Binary>(ast->location, ast->openFodder,
-                                       ast->left, EF, BOP_PLUS, ast->right);
+            ast_ =
+                make<Binary>(ast->location, ast->openFodder, ast->left, EF, BOP_PLUS, ast->right);
 
-        } else if (auto *ast = dynamic_cast<Array*>(ast_)) {
+        } else if (auto *ast = dynamic_cast<Array *>(ast_)) {
             for (auto &el : ast->elements)
                 desugar(el.expr, obj_level);
 
-        } else if (auto *ast = dynamic_cast<ArrayComprehension*>(ast_)) {
+        } else if (auto *ast = dynamic_cast<ArrayComprehension *>(ast_)) {
             for (ComprehensionSpec &spec : ast->specs)
                 desugar(spec.expr, obj_level);
             desugar(ast->body, obj_level + 1);
@@ -321,15 +419,15 @@ class Desugarer {
             AST *one = make<LiteralNumber>(E, EF, "1.0");
             auto *_r = id(U"$r");
             auto *_l = id(U"$l");
-            std::vector<const Identifier*> _i(n);
-            for (int i = 0; i < n ; ++i) {
-                StringStream ss;
+            std::vector<const Identifier *> _i(n);
+            for (int i = 0; i < n; ++i) {
+                UStringStream ss;
                 ss << U"$i_" << i;
                 _i[i] = id(ss.str());
             }
-            std::vector<const Identifier*> _aux(n);
-            for (int i = 0; i < n ; ++i) {
-                StringStream ss;
+            std::vector<const Identifier *> _aux(n);
+            for (int i = 0; i < n; ++i) {
+                UStringStream ss;
                 ss << U"$aux_" << i;
                 _aux[i] = id(ss.str());
             }
@@ -346,16 +444,14 @@ class Desugarer {
                 EF,
                 var(_aux[last_for]),
                 EF,
-                ArgParams {
-                    { make<Binary>(E, EF, var(_i[last_for]), EF, BOP_PLUS, one), EF},
-                    { make<Binary>(E, EF, var(_r), EF, BOP_PLUS, singleton(ast->body)), EF}
-                },
+                ArgParams{{make<Binary>(E, EF, var(_i[last_for]), EF, BOP_PLUS, one), EF},
+                          {make<Binary>(E, EF, var(_r), EF, BOP_PLUS, singleton(ast->body)), EF}},
                 false,  // trailingComma
                 EF,
                 EF,
                 true  // tailstrict
             );
-            for (int i = n - 1; i >= 0 ; --i) {
+            for (int i = n - 1; i >= 0; --i) {
                 const ComprehensionSpec &spec = ast->specs[i];
                 AST *out;
                 if (i > 0) {
@@ -369,11 +465,15 @@ class Desugarer {
                         EF,
                         var(_aux[prev_for]),
                         EF,
-                        ArgParams {
-                            { make<Binary>(E, EF, var(_i[prev_for]), EF, BOP_PLUS, one), EF, },
-                            { var(_r), EF, }
-                        },
-                        false, // trailingComma
+                        ArgParams{{
+                                      make<Binary>(E, EF, var(_i[prev_for]), EF, BOP_PLUS, one),
+                                      EF,
+                                  },
+                                  {
+                                      var(_r),
+                                      EF,
+                                  }},
+                        false,  // trailingComma
                         EF,
                         EF,
                         true  // tailstrict
@@ -389,14 +489,13 @@ class Desugarer {
                             else
                                 [[[...out...]]]
                         */
-                        in = make<Conditional>(
-                            ast->location,
-                            EF,
-                            spec.expr,
-                            EF,
-                            in,  // True branch.
-                            EF,
-                            out);  // False branch.
+                        in = make<Conditional>(ast->location,
+                                               EF,
+                                               spec.expr,
+                                               EF,
+                                               in,  // True branch.
+                                               EF,
+                                               out);  // False branch.
                     } break;
                     case ComprehensionSpec::FOR: {
                         /*
@@ -406,43 +505,52 @@ class Desugarer {
                                     [[[...out...]]]
                                 else
                                     local [[[...var...]]] = $l[i_{i}];
-                                    [[[...in...]]];`
-                            if std.type($l) != "array" then
-                                error "In comprehension, can only iterate over array.."
+                                    [[[...in...]]];
+                            if std.type($l) == "array" then
+                                aux_{i}(0, $r) tailstrict
                             else
-                                aux_{i}(0, r) tailstrict;
+                                error "In comprehension, can only iterate over array..";
                         */
                         in = make<Local>(
                             ast->location,
                             EF,
-                            Local::Binds {
+                            Local::Binds{
                                 bind(_l, spec.expr),  // Need to check expr is an array
-                                bind(_aux[i], make<Function>(
-                                    ast->location,
-                                    EF,
-                                    EF,
-                                    ArgParams{{EF, _i[i], EF}, {EF, _r, EF}},
-                                    false,  // trailingComma
-                                    EF,
-                                    make<Conditional>(
-                                        ast->location,
-                                        EF,
-                                        make<Binary>(
-                                            E, EF, var(_i[i]), EF, BOP_GREATER_EQ, length(var(_l))),
-                                        EF,
-                                        out,
-                                        EF,
-                                        make<Local>(
-                                            ast->location,
-                                            EF,
-                                            singleBind(
-                                                spec.var,
-                                                make<Index>(E, EF, var(_l), EF, false, var(_i[i]),
-                                                            EF, nullptr, EF, nullptr, EF)
-                                            ),
-                                            in)
-                                    )
-                                ))},
+                                bind(_aux[i],
+                                     make<Function>(
+                                         ast->location,
+                                         EF,
+                                         EF,
+                                         ArgParams{{EF, _i[i], EF}, {EF, _r, EF}},
+                                         false,  // trailingComma
+                                         EF,
+                                         make<Conditional>(ast->location,
+                                                           EF,
+                                                           make<Binary>(E,
+                                                                        EF,
+                                                                        var(_i[i]),
+                                                                        EF,
+                                                                        BOP_GREATER_EQ,
+                                                                        length(var(_l))),
+                                                           EF,
+                                                           out,
+                                                           EF,
+                                                           make<Local>(
+                                                               ast->location,
+                                                               EF,
+                                                               singleBind(spec.var,
+                                                                          make<Index>(E,
+                                                                                      EF,
+                                                                                      var(_l),
+                                                                                      EF,
+                                                                                      false,
+                                                                                      var(_i[i]),
+                                                                                      EF,
+                                                                                      nullptr,
+                                                                                      EF,
+                                                                                      nullptr,
+                                                                                      EF)),
+                                                               in))))},
                             make<Conditional>(
                                 ast->location,
                                 EF,
@@ -453,15 +561,13 @@ class Desugarer {
                                     EF,
                                     var(_aux[i]),
                                     EF,
-                                    ArgParams {
-                                        {zero, EF},
-                                        {
-                                            i == 0
-                                            ? make<Array>(E, EF, Array::Elements{}, false, EF)
-                                            : static_cast<AST*>(var(_r)),
-                                            EF,
-                                        }
-                                    },
+                                    ArgParams{{zero, EF},
+                                              {
+                                                  i == 0 ? make<Array>(
+                                                               E, EF, Array::Elements{}, false, EF)
+                                                         : static_cast<AST *>(var(_r)),
+                                                  EF,
+                                              }},
                                     false,  // trailingComma
                                     EF,
                                     EF,
@@ -475,7 +581,7 @@ class Desugarer {
 
             ast_ = in;
 
-        } else if (auto *ast = dynamic_cast<Assert*>(ast_)) {
+        } else if (auto *ast = dynamic_cast<Assert *>(ast_)) {
             desugar(ast->cond, obj_level);
             if (ast->message == nullptr) {
                 ast->message = str(U"Assertion failed.");
@@ -485,10 +591,10 @@ class Desugarer {
 
             // if cond then rest else error msg
             AST *branch_false = make<Error>(ast->location, EF, ast->message);
-            ast_ = make<Conditional>(ast->location, ast->openFodder,
-                                            ast->cond, EF, ast->rest, EF, branch_false);
+            ast_ = make<Conditional>(
+                ast->location, ast->openFodder, ast->cond, EF, ast->rest, EF, branch_false);
 
-        } else if (auto *ast = dynamic_cast<Binary*>(ast_)) {
+        } else if (auto *ast = dynamic_cast<Binary *>(ast_)) {
             desugar(ast->left, obj_level);
             desugar(ast->right, obj_level);
 
@@ -496,56 +602,63 @@ class Desugarer {
 
             switch (ast->op) {
                 case BOP_PERCENT: {
-                    AST *f_mod = make<Index>(E, EF, std(), EF, false, str(U"mod"), EF,
-                                                    nullptr, EF, nullptr, EF);
+                    AST *f_mod = make<Index>(
+                        E, EF, std(), EF, false, str(U"mod"), EF, nullptr, EF, nullptr, EF);
                     ArgParams args = {{ast->left, EF}, {ast->right, EF}};
-                    ast_ = make<Apply>(ast->location, ast->openFodder, f_mod, EF, args,
-                                              false, EF, EF, false);
+                    ast_ = make<Apply>(
+                        ast->location, ast->openFodder, f_mod, EF, args, false, EF, EF, false);
                 } break;
 
-                case BOP_MANIFEST_UNEQUAL:
-                invert = true;
+                case BOP_MANIFEST_UNEQUAL: invert = true;
                 case BOP_MANIFEST_EQUAL: {
                     ast_ = equals(ast->location, ast->left, ast->right);
                     if (invert)
                         ast_ = make<Unary>(ast->location, ast->openFodder, UOP_NOT, ast_);
-                }
-                break;
+                } break;
 
                 default:;
-                // Otherwise don't change it.
+                    // Otherwise don't change it.
             }
 
-        } else if (dynamic_cast<const BuiltinFunction*>(ast_)) {
+        } else if (dynamic_cast<const BuiltinFunction *>(ast_)) {
             // Nothing to do.
 
-        } else if (auto *ast = dynamic_cast<Conditional*>(ast_)) {
+        } else if (auto *ast = dynamic_cast<Conditional *>(ast_)) {
             desugar(ast->cond, obj_level);
             desugar(ast->branchTrue, obj_level);
             if (ast->branchFalse == nullptr)
                 ast->branchFalse = null();
             desugar(ast->branchFalse, obj_level);
 
-        } else if (auto *ast = dynamic_cast<Dollar*>(ast_)) {
+        } else if (auto *ast = dynamic_cast<Dollar *>(ast_)) {
             if (obj_level == 0) {
                 throw StaticError(ast->location, "No top-level object found.");
             }
             ast_ = var(id(U"$"));
 
-        } else if (auto *ast = dynamic_cast<Error*>(ast_)) {
+        } else if (auto *ast = dynamic_cast<Error *>(ast_)) {
             desugar(ast->expr, obj_level);
 
-        } else if (auto *ast = dynamic_cast<Function*>(ast_)) {
+        } else if (auto *ast = dynamic_cast<Function *>(ast_)) {
             desugar(ast->body, obj_level);
             desugarParams(ast->params, obj_level);
 
-        } else if (dynamic_cast<const Import*>(ast_)) {
-            // Nothing to do.
+        } else if (auto *ast = dynamic_cast<Import *>(ast_)) {
+            // TODO(dcunnin): Abstract this into a template function if it becomes more common.
+            AST *file = ast->file;
+            desugar(file, obj_level);
+            ast->file = dynamic_cast<LiteralString *>(file);
 
-        } else if (dynamic_cast<const Importstr*>(ast_)) {
-            // Nothing to do.
+        } else if (auto *ast = dynamic_cast<Importstr *>(ast_)) {
+            // TODO(dcunnin): Abstract this into a template function if it becomes more common.
+            AST *file = ast->file;
+            desugar(file, obj_level);
+            ast->file = dynamic_cast<LiteralString *>(file);
 
-        } else if (auto *ast = dynamic_cast<Index*>(ast_)) {
+        } else if (auto *ast = dynamic_cast<InSuper *>(ast_)) {
+            desugar(ast->element, obj_level);
+
+        } else if (auto *ast = dynamic_cast<Index *>(ast_)) {
             desugar(ast->target, obj_level);
             if (ast->isSlice) {
                 if (ast->index == nullptr)
@@ -586,39 +699,45 @@ class Desugarer {
                 desugar(ast->index, obj_level);
             }
 
-        } else if (auto *ast = dynamic_cast<Local*>(ast_)) {
-            for (auto &bind: ast->binds)
+        } else if (auto *ast = dynamic_cast<Local *>(ast_)) {
+            for (auto &bind : ast->binds)
                 desugar(bind.body, obj_level);
             desugar(ast->body, obj_level);
 
-            for (auto &bind: ast->binds) {
+            for (auto &bind : ast->binds) {
                 if (bind.functionSugar) {
                     desugarParams(bind.params, obj_level);
-                    bind.body = make<Function>(
-                        ast->location, ast->openFodder, bind.parenLeftFodder, bind.params, false,
-                        bind.parenRightFodder, bind.body);
+                    bind.body = make<Function>(ast->location,
+                                               ast->openFodder,
+                                               bind.parenLeftFodder,
+                                               bind.params,
+                                               false,
+                                               bind.parenRightFodder,
+                                               bind.body);
                     bind.functionSugar = false;
                     bind.params.clear();
                 }
             }
 
-        } else if (dynamic_cast<const LiteralBoolean*>(ast_)) {
+        } else if (dynamic_cast<const LiteralBoolean *>(ast_)) {
             // Nothing to do.
 
-        } else if (dynamic_cast<const LiteralNumber*>(ast_)) {
+        } else if (dynamic_cast<const LiteralNumber *>(ast_)) {
             // Nothing to do.
 
-        } else if (auto *ast = dynamic_cast<LiteralString*>(ast_)) {
-            if (ast->tokenKind != LiteralString::BLOCK) {
+        } else if (auto *ast = dynamic_cast<LiteralString *>(ast_)) {
+            if ((ast->tokenKind != LiteralString::BLOCK) &&
+                (ast->tokenKind != LiteralString::VERBATIM_DOUBLE) &&
+                (ast->tokenKind != LiteralString::VERBATIM_SINGLE)) {
                 ast->value = jsonnet_string_unescape(ast->location, ast->value);
             }
             ast->tokenKind = LiteralString::DOUBLE;
             ast->blockIndent.clear();
 
-        } else if (dynamic_cast<const LiteralNull*>(ast_)) {
+        } else if (dynamic_cast<const LiteralNull *>(ast_)) {
             // Nothing to do.
 
-        } else if (auto *ast = dynamic_cast<DesugaredObject*>(ast_)) {
+        } else if (auto *ast = dynamic_cast<DesugaredObject *>(ast_)) {
             for (auto &field : ast->fields) {
                 desugar(field.name, obj_level);
                 desugar(field.body, obj_level + 1);
@@ -627,7 +746,7 @@ class Desugarer {
                 desugar(assert, obj_level + 1);
             }
 
-        } else if (auto *ast = dynamic_cast<Object*>(ast_)) {
+        } else if (auto *ast = dynamic_cast<Object *>(ast_)) {
             // Hidden variable to allow outer/top binding.
             if (obj_level == 0) {
                 const Identifier *hidden_var = id(U"$");
@@ -635,7 +754,7 @@ class Desugarer {
                 ast->fields.push_back(ObjectField::Local(EF, EF, hidden_var, EF, body, EF));
             }
 
-            desugarFields(ast, ast->fields, obj_level);
+            SuperVars svs = desugarFields(ast, ast->fields, obj_level);
 
             DesugaredObject::Fields new_fields;
             ASTs new_asserts;
@@ -645,13 +764,26 @@ class Desugarer {
                 } else if (field.kind == ObjectField::FIELD_EXPR) {
                     new_fields.emplace_back(field.hide, field.expr1, field.expr2);
                 } else {
-                    std::cerr << "INTERNAL ERROR: field should have been desugared: "
-                              << field.kind << std::endl;
+                    std::cerr << "INTERNAL ERROR: field should have been desugared: " << field.kind
+                              << std::endl;
                 }
             }
             ast_ = make<DesugaredObject>(ast->location, new_asserts, new_fields);
+            if (svs.size() > 0) {
+                Local::Binds binds;
+                for (const auto &pair : svs) {
+                    if (pair.second == nullptr) {
+                        // Self binding
+                        binds.push_back(bind(pair.first, make<Self>(E, EF)));
+                    } else {
+                        // Super binding
+                        binds.push_back(bind(pair.first, pair.second));
+                    }
+                }
+                ast_ = make<Local>(ast->location, EF, binds, ast_);
+            }
 
-        } else if (auto *ast = dynamic_cast<ObjectComprehension*>(ast_)) {
+        } else if (auto *ast = dynamic_cast<ObjectComprehension *>(ast_)) {
             // Hidden variable to allow outer/top binding.
             if (obj_level == 0) {
                 const Identifier *hidden_var = id(U"$");
@@ -659,7 +791,7 @@ class Desugarer {
                 ast->fields.push_back(ObjectField::Local(EF, EF, hidden_var, EF, body, EF));
             }
 
-            desugarFields(ast, ast->fields, obj_level);
+            SuperVars svs = desugarFields(ast, ast->fields, obj_level);
 
             for (ComprehensionSpec &spec : ast->specs)
                 desugar(spec.expr, obj_level);
@@ -676,53 +808,55 @@ class Desugarer {
             AST *zero = make<LiteralNumber>(E, EF, "0.0");
             int counter = 1;
             Local::Binds binds;
-            Array::Elements arr_e {Array::Element(field, EF)};
+            Array::Elements arr_e{Array::Element(field, EF)};
             for (ComprehensionSpec &spec : ast->specs) {
                 if (spec.kind == ComprehensionSpec::FOR) {
                     std::stringstream num;
                     num << counter++;
-                    binds.push_back(bind(
-                        spec.var,
-                        make<Index>(E, EF, var(_arr), EF, false,
-                                    make<LiteralNumber>(E, EF, num.str()), EF, nullptr, EF, nullptr,
-                                    EF)));
+                    binds.push_back(bind(spec.var,
+                                         make<Index>(E,
+                                                     EF,
+                                                     var(_arr),
+                                                     EF,
+                                                     false,
+                                                     make<LiteralNumber>(E, EF, num.str()),
+                                                     EF,
+                                                     nullptr,
+                                                     EF,
+                                                     nullptr,
+                                                     EF)));
                     arr_e.emplace_back(var(spec.var), EF);
                 }
             }
-            AST *arr = make<ArrayComprehension>(
-                ast->location,
-                EF,
-                make<Array>(ast->location, EF, arr_e, false, EF),
-                EF,
-                false,
-                ast->specs,
-                EF);
+            AST *arr = make<ArrayComprehension>(ast->location,
+                                                EF,
+                                                make<Array>(ast->location, EF, arr_e, false, EF),
+                                                EF,
+                                                false,
+                                                ast->specs,
+                                                EF);
             desugar(arr, obj_level);
             ast_ = make<ObjectComprehensionSimple>(
                 ast->location,
                 make<Index>(E, EF, var(_arr), EF, false, zero, EF, nullptr, EF, nullptr, EF),
-                make<Local>(
-                    ast->location,
-                    EF,
-                    binds,
-                    value),
+                make<Local>(ast->location, EF, binds, value),
                 _arr,
                 arr);
 
-        } else if (auto *ast = dynamic_cast<ObjectComprehensionSimple*>(ast_)) {
+        } else if (auto *ast = dynamic_cast<ObjectComprehensionSimple *>(ast_)) {
             desugar(ast->field, obj_level);
             desugar(ast->value, obj_level + 1);
             desugar(ast->array, obj_level);
 
-        } else if (auto *ast = dynamic_cast<Parens*>(ast_)) {
+        } else if (auto *ast = dynamic_cast<Parens *>(ast_)) {
             // Strip parens.
             desugar(ast->expr, obj_level);
             ast_ = ast->expr;
 
-        } else if (dynamic_cast<const Self*>(ast_)) {
+        } else if (dynamic_cast<const Self *>(ast_)) {
             // Nothing to do.
 
-        } else if (auto * ast = dynamic_cast<SuperIndex*>(ast_)) {
+        } else if (auto *ast = dynamic_cast<SuperIndex *>(ast_)) {
             if (ast->id != nullptr) {
                 assert(ast->index == nullptr);
                 ast->index = str(ast->id->name);
@@ -730,16 +864,15 @@ class Desugarer {
             }
             desugar(ast->index, obj_level);
 
-        } else if (auto *ast = dynamic_cast<Unary*>(ast_)) {
+        } else if (auto *ast = dynamic_cast<Unary *>(ast_)) {
             desugar(ast->expr, obj_level);
 
-        } else if (dynamic_cast<const Var*>(ast_)) {
+        } else if (dynamic_cast<const Var *>(ast_)) {
             // Nothing to do.
 
         } else {
             std::cerr << "INTERNAL ERROR: Unknown AST: " << ast_ << std::endl;
             std::abort();
-
         }
     }
 
@@ -751,7 +884,7 @@ class Desugarer {
         Tokens tokens = jsonnet_lex("std.jsonnet", STD_CODE);
         AST *std_ast = jsonnet_parse(alloc, tokens);
         desugar(std_ast, 0);
-        auto *std_obj = dynamic_cast<DesugaredObject*>(std_ast);
+        auto *std_obj = dynamic_cast<DesugaredObject *>(std_ast);
         if (std_obj == nullptr) {
             std::cerr << "INTERNAL ERROR: std.jsonnet not an object." << std::endl;
             std::abort();
@@ -759,20 +892,17 @@ class Desugarer {
 
         // Bind 'std' builtins that are implemented natively.
         DesugaredObject::Fields &fields = std_obj->fields;
-        for (unsigned long c=0 ; c <= max_builtin ; ++c) {
+        for (unsigned long c = 0; c <= max_builtin; ++c) {
             const auto &decl = jsonnet_builtin_decl(c);
             Identifiers params;
             for (const auto &p : decl.params)
                 params.push_back(id(p));
-            fields.emplace_back(
-                ObjectField::HIDDEN,
-                str(decl.name),
-                make<BuiltinFunction>(E, encode_utf8(decl.name), params));
+            fields.emplace_back(ObjectField::HIDDEN,
+                                str(decl.name),
+                                make<BuiltinFunction>(E, encode_utf8(decl.name), params));
         }
         fields.emplace_back(
-            ObjectField::HIDDEN,
-            str(U"thisFile"),
-            str(decode_utf8(ast->location.file)));
+            ObjectField::HIDDEN, str(U"thisFile"), str(decode_utf8(ast->location.file)));
 
         std::vector<std::string> empty;
         auto line_end_blank = Fodder{{FodderElement::LINE_END, 1, 0, empty}};
@@ -786,8 +916,7 @@ class Desugarer {
         if (tlas != nullptr) {
             LocationRange tla_loc("Top-level function");
             ArgParams args;
-            for (const auto &pair : *tlas)
-            {
+            for (const auto &pair : *tlas) {
                 AST *expr;
                 if (pair.second.isCode) {
                     // Now, implement the std library by wrapping in a local construct.
@@ -801,36 +930,30 @@ class Desugarer {
                 args.emplace_back(EF, id(decode_utf8(pair.first)), EF, expr, EF);
             }
             const Identifier *body = id(U"top_level");
-            ast = make<Local>(
-                ast->location,
-                line_end_blank,
-                singleBind(body, ast),
-                make<Conditional>(
-                    E,
-                    line_end,
-                    primitiveEquals(E, type(var(body)), str(U"function")),
-                    EF,
-                    make<Apply>(
-                        tla_loc,
-                        EF,
-                        make<Var>(E, line_end, body),
-                        EF,
-                        args,
-                        false,  // trailing comma
-                        EF,
-                        EF,
-                        false  // tailstrict
-                    ),
-                    line_end,
-                    make<Var>(E, line_end, body)));
+            ast =
+                make<Local>(ast->location,
+                            line_end_blank,
+                            singleBind(body, ast),
+                            make<Conditional>(E,
+                                              line_end,
+                                              primitiveEquals(E, type(var(body)), str(U"function")),
+                                              EF,
+                                              make<Apply>(tla_loc,
+                                                          EF,
+                                                          make<Var>(E, line_end, body),
+                                                          EF,
+                                                          args,
+                                                          false,  // trailing comma
+                                                          EF,
+                                                          EF,
+                                                          false  // tailstrict
+                                                          ),
+                                              line_end,
+                                              make<Var>(E, line_end, body)));
         }
 
         // local std = (std.jsonnet stuff); ast
-        ast = make<Local>(
-            ast->location,
-            EF,
-            singleBind(id(U"std"), std_obj),
-            ast);
+        ast = make<Local>(ast->location, EF, singleBind(id(U"std"), std_obj), ast);
     }
 };
 
diff --git a/libjsonnet/core/formatter.cpp b/libjsonnet/core/formatter.cpp
index 064d77e..3f38f7d 100644
--- a/libjsonnet/core/formatter.cpp
+++ b/libjsonnet/core/formatter.cpp
@@ -14,10 +14,13 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
+#include <algorithm>
+#include <set>
 #include <typeinfo>
 
-#include "lexer.h"
 #include "formatter.h"
+#include "lexer.h"
+#include "pass.h"
 #include "string_utils.h"
 #include "unicode.h"
 
@@ -29,26 +32,41 @@ static std::string unparse_id(const Identifier *id)
 /** If left recursive, return the left hand side, else return nullptr. */
 static AST *left_recursive(AST *ast_)
 {
-    if (auto *ast = dynamic_cast<Apply*>(ast_))
+    if (auto *ast = dynamic_cast<Apply *>(ast_))
         return ast->target;
-    if (auto *ast = dynamic_cast<ApplyBrace*>(ast_))
+    if (auto *ast = dynamic_cast<ApplyBrace *>(ast_))
         return ast->left;
-    if (auto *ast = dynamic_cast<Binary*>(ast_))
+    if (auto *ast = dynamic_cast<Binary *>(ast_))
         return ast->left;
-    if (auto *ast = dynamic_cast<Index*>(ast_))
+    if (auto *ast = dynamic_cast<Index *>(ast_))
         return ast->target;
+    if (auto *ast = dynamic_cast<InSuper *>(ast_))
+        return ast->element;
     return nullptr;
 }
 static const AST *left_recursive(const AST *ast_)
 {
-    return left_recursive(const_cast<AST*>(ast_));
+    return left_recursive(const_cast<AST *>(ast_));
+}
+
+/** The transitive closure of left_recursive). */
+static AST *left_recursive_deep(AST *ast_)
+{
+    AST *last = ast_;
+    AST *left = left_recursive(ast_);
+
+    while (left != nullptr) {
+        last = left;
+        left = left_recursive(last);
+    }
+    return last;
 }
 
 /** Pretty-print fodder.
  *
  * \param fodder The fodder to print
  * \param space_before Whether a space should be printed before any other output.
- * \param separate_token If a space should separate the token from any interstitials.
+ * \param separate_token If the last fodder was an interstitial, whether a space should follow it.
  */
 void fodder_fill(std::ostream &o, const Fodder &fodder, bool space_before, bool separate_token)
 {
@@ -56,21 +74,21 @@ void fodder_fill(std::ostream &o, const Fodder &fodder, bool space_before, bool
     for (const auto &fod : fodder) {
         switch (fod.kind) {
             case FodderElement::LINE_END:
-            if (fod.comment.size() > 0)
-                o << "  " << fod.comment[0];
-            o << '\n';
-            o << std::string(fod.blanks, '\n');
-            o << std::string(fod.indent, ' ');
-            last_indent = fod.indent;
-            space_before = false;
-            break;
+                if (fod.comment.size() > 0)
+                    o << "  " << fod.comment[0];
+                o << '\n';
+                o << std::string(fod.blanks, '\n');
+                o << std::string(fod.indent, ' ');
+                last_indent = fod.indent;
+                space_before = false;
+                break;
 
             case FodderElement::INTERSTITIAL:
-            if (space_before)
-                o << ' ';
-            o << fod.comment[0];
-            space_before = true;
-            break;
+                if (space_before)
+                    o << ' ';
+                o << fod.comment[0];
+                space_before = true;
+                break;
 
             case FodderElement::PARAGRAPH: {
                 bool first = true;
@@ -97,22 +115,23 @@ void fodder_fill(std::ostream &o, const Fodder &fodder, bool space_before, bool
 }
 
 /** A model of fodder_fill that just keeps track of the column counter. */
-static void fodder_count(unsigned &column, const Fodder &fodder, bool space_before, bool separate_token)
+static void fodder_count(unsigned &column, const Fodder &fodder, bool space_before,
+                         bool separate_token)
 {
     for (const auto &fod : fodder) {
         switch (fod.kind) {
             case FodderElement::PARAGRAPH:
             case FodderElement::LINE_END:
-            column = fod.indent;
-            space_before = false;
-            break;
+                column = fod.indent;
+                space_before = false;
+                break;
 
             case FodderElement::INTERSTITIAL:
-            if (space_before)
-                column++;
-            column += fod.comment[0].length();
-            space_before = true;
-            break;
+                if (space_before)
+                    column++;
+                column += fod.comment[0].length();
+                space_before = true;
+                break;
         }
     }
     if (separate_token && space_before)
@@ -120,16 +139,13 @@ static void fodder_count(unsigned &column, const Fodder &fodder, bool space_befo
 }
 
 class Unparser {
-    public:
-
-    private:
+   public:
+   private:
     std::ostream &o;
     FmtOpts opts;
 
-    public:
-    Unparser(std::ostream &o, const FmtOpts &opts)
-      : o(o), opts(opts)
-    { }
+   public:
+    Unparser(std::ostream &o, const FmtOpts &opts) : o(o), opts(opts) {}
 
     void unparseSpecs(const std::vector<ComprehensionSpec> &specs)
     {
@@ -137,17 +153,17 @@ class Unparser {
             fill(spec.openFodder, true, true);
             switch (spec.kind) {
                 case ComprehensionSpec::FOR:
-                o << "for";
-                fill(spec.varFodder, true, true);
-                o << unparse_id(spec.var);
-                fill(spec.inFodder, true, true);
-                o << "in";
-                unparse(spec.expr, true);
-                break;
+                    o << "for";
+                    fill(spec.varFodder, true, true);
+                    o << unparse_id(spec.var);
+                    fill(spec.inFodder, true, true);
+                    o << "in";
+                    unparse(spec.expr, true);
+                    break;
                 case ComprehensionSpec::IF:
-                o << "if";
-                unparse(spec.expr, true);
-                break;
+                    o << "if";
+                    unparse(spec.expr, true);
+                    break;
             }
         }
     }
@@ -164,7 +180,8 @@ class Unparser {
         o << "(";
         bool first = true;
         for (const auto &param : params) {
-            if (!first) o << ",";
+            if (!first)
+                o << ",";
             fill(param.idFodder, !first, true);
             o << unparse_id(param.id);
             if (param.expr != nullptr) {
@@ -193,8 +210,8 @@ class Unparser {
     {
         bool first = true;
         for (const auto &field : fields) {
-
-            if (!first) o << ',';
+            if (!first)
+                o << ',';
 
             switch (field.kind) {
                 case ObjectField::LOCAL: {
@@ -211,8 +228,6 @@ class Unparser {
                 case ObjectField::FIELD_ID:
                 case ObjectField::FIELD_STR:
                 case ObjectField::FIELD_EXPR: {
-
-
                     if (field.kind == ObjectField::FIELD_ID) {
                         fill(field.fodder1, !first || space_before, true);
                         o << unparse_id(field.id);
@@ -231,7 +246,8 @@ class Unparser {
 
                     fill(field.opFodder, false, false);
 
-                    if (field.superSugar) o << "+";
+                    if (field.superSugar)
+                        o << "+";
                     switch (field.hide) {
                         case ObjectField::INHERIT: o << ":"; break;
                         case ObjectField::HIDDEN: o << "::"; break;
@@ -271,13 +287,14 @@ class Unparser {
 
         fill(ast_->openFodder, space_before, separate_token);
 
-        if (auto *ast = dynamic_cast<const Apply*>(ast_)) {
+        if (auto *ast = dynamic_cast<const Apply *>(ast_)) {
             unparse(ast->target, space_before);
             fill(ast->fodderL, false, false);
             o << "(";
             bool first = true;
             for (const auto &arg : ast->args) {
-                if (!first) o << ',';
+                if (!first)
+                    o << ',';
                 bool space = !first;
                 if (arg.id != nullptr) {
                     fill(arg.idFodder, space, true);
@@ -289,7 +306,8 @@ class Unparser {
                 fill(arg.commaFodder, false, false);
                 first = false;
             }
-            if (ast->trailingComma) o << ",";
+            if (ast->trailingComma)
+                o << ",";
             fill(ast->fodderR, false, false);
             o << ")";
             if (ast->tailstrict) {
@@ -297,33 +315,36 @@ class Unparser {
                 o << "tailstrict";
             }
 
-        } else if (auto *ast = dynamic_cast<const ApplyBrace*>(ast_)) {
+        } else if (auto *ast = dynamic_cast<const ApplyBrace *>(ast_)) {
             unparse(ast->left, space_before);
             unparse(ast->right, true);
 
-        } else if (auto *ast = dynamic_cast<const Array*>(ast_)) {
+        } else if (auto *ast = dynamic_cast<const Array *>(ast_)) {
             o << "[";
             bool first = true;
             for (const auto &element : ast->elements) {
-                if (!first) o << ',';
+                if (!first)
+                    o << ',';
                 unparse(element.expr, !first || opts.padArrays);
                 fill(element.commaFodder, false, false);
                 first = false;
             }
-            if (ast->trailingComma) o << ",";
+            if (ast->trailingComma)
+                o << ",";
             fill(ast->closeFodder, ast->elements.size() > 0, opts.padArrays);
             o << "]";
 
-        } else if (auto *ast = dynamic_cast<const ArrayComprehension*>(ast_)) {
+        } else if (auto *ast = dynamic_cast<const ArrayComprehension *>(ast_)) {
             o << "[";
             unparse(ast->body, opts.padArrays);
             fill(ast->commaFodder, false, false);
-            if (ast->trailingComma) o << ",";
+            if (ast->trailingComma)
+                o << ",";
             unparseSpecs(ast->specs);
             fill(ast->closeFodder, true, opts.padArrays);
             o << "]";
 
-        } else if (auto *ast = dynamic_cast<const Assert*>(ast_)) {
+        } else if (auto *ast = dynamic_cast<const Assert *>(ast_)) {
             o << "assert";
             unparse(ast->cond, true);
             if (ast->message != nullptr) {
@@ -335,17 +356,17 @@ class Unparser {
             o << ";";
             unparse(ast->rest, true);
 
-        } else if (auto *ast = dynamic_cast<const Binary*>(ast_)) {
+        } else if (auto *ast = dynamic_cast<const Binary *>(ast_)) {
             unparse(ast->left, space_before);
             fill(ast->opFodder, true, true);
             o << bop_string(ast->op);
             // The - 1 is for left associativity.
             unparse(ast->right, true);
 
-        } else if (auto *ast = dynamic_cast<const BuiltinFunction*>(ast_)) {
+        } else if (auto *ast = dynamic_cast<const BuiltinFunction *>(ast_)) {
             o << "/* builtin " << ast->name << " */ null";
 
-        } else if (auto *ast = dynamic_cast<const Conditional*>(ast_)) {
+        } else if (auto *ast = dynamic_cast<const Conditional *>(ast_)) {
             o << "if";
             unparse(ast->cond, true);
             fill(ast->thenFodder, true, true);
@@ -359,28 +380,35 @@ class Unparser {
                 unparse(ast->branchTrue, true);
             }
 
-        } else if (dynamic_cast<const Dollar*>(ast_)) {
+        } else if (dynamic_cast<const Dollar *>(ast_)) {
             o << "$";
 
-        } else if (auto *ast = dynamic_cast<const Error*>(ast_)) {
+        } else if (auto *ast = dynamic_cast<const Error *>(ast_)) {
             o << "error";
             unparse(ast->expr, true);
 
-        } else if (auto *ast = dynamic_cast<const Function*>(ast_)) {
+        } else if (auto *ast = dynamic_cast<const Function *>(ast_)) {
             o << "function";
-            unparseParams(ast->parenLeftFodder, ast->params, ast->trailingComma,
-                          ast->parenRightFodder);
+            unparseParams(
+                ast->parenLeftFodder, ast->params, ast->trailingComma, ast->parenRightFodder);
             unparse(ast->body, true);
 
-        } else if (auto *ast = dynamic_cast<const Import*>(ast_)) {
+        } else if (auto *ast = dynamic_cast<const Import *>(ast_)) {
             o << "import";
             unparse(ast->file, true);
 
-        } else if (auto *ast = dynamic_cast<const Importstr*>(ast_)) {
+        } else if (auto *ast = dynamic_cast<const Importstr *>(ast_)) {
             o << "importstr";
             unparse(ast->file, true);
 
-        } else if (auto *ast = dynamic_cast<const Index*>(ast_)) {
+        } else if (auto *ast = dynamic_cast<const InSuper *>(ast_)) {
+            unparse(ast->element, true);
+            fill(ast->inFodder, true, true);
+            o << "in";
+            fill(ast->superFodder, true, true);
+            o << "super";
+
+        } else if (auto *ast = dynamic_cast<const Index *>(ast_)) {
             unparse(ast->target, space_before);
             fill(ast->dotFodder, false, false);
             if (ast->id != nullptr) {
@@ -412,7 +440,7 @@ class Unparser {
                 o << "]";
             }
 
-        } else if (auto *ast = dynamic_cast<const Local*>(ast_)) {
+        } else if (auto *ast = dynamic_cast<const Local *>(ast_)) {
             o << "local";
             assert(ast->binds.size() > 0);
             bool first = true;
@@ -423,9 +451,11 @@ class Unparser {
                 fill(bind.varFodder, true, true);
                 o << unparse_id(bind.var);
                 if (bind.functionSugar) {
-                    unparseParams(bind.parenLeftFodder, bind.params, bind.trailingComma,
+                    unparseParams(bind.parenLeftFodder,
+                                  bind.params,
+                                  bind.trailingComma,
                                   bind.parenRightFodder);
-                } 
+                }
                 fill(bind.opFodder, true, true);
                 o << "=";
                 unparse(bind.body, true);
@@ -434,13 +464,13 @@ class Unparser {
             o << ";";
             unparse(ast->body, true);
 
-        } else if (auto *ast = dynamic_cast<const LiteralBoolean*>(ast_)) {
+        } else if (auto *ast = dynamic_cast<const LiteralBoolean *>(ast_)) {
             o << (ast->value ? "true" : "false");
 
-        } else if (auto *ast = dynamic_cast<const LiteralNumber*>(ast_)) {
+        } else if (auto *ast = dynamic_cast<const LiteralNumber *>(ast_)) {
             o << ast->originalString;
 
-        } else if (auto *ast = dynamic_cast<const LiteralString*>(ast_)) {
+        } else if (auto *ast = dynamic_cast<const LiteralString *>(ast_)) {
             if (ast->tokenKind == LiteralString::DOUBLE) {
                 o << "\"";
                 o << encode_utf8(ast->value);
@@ -453,7 +483,7 @@ class Unparser {
                 o << "|||\n";
                 if (ast->value.c_str()[0] != U'\n')
                     o << ast->blockIndent;
-                for (const char32_t *cp = ast->value.c_str() ; *cp != U'\0' ; ++cp) {
+                for (const char32_t *cp = ast->value.c_str(); *cp != U'\0'; ++cp) {
                     std::string utf8;
                     encode_utf8(*cp, utf8);
                     o << utf8;
@@ -462,19 +492,44 @@ class Unparser {
                     }
                 }
                 o << ast->blockTermIndent << "|||";
+            } else if (ast->tokenKind == LiteralString::VERBATIM_DOUBLE) {
+                o << "@\"";
+                for (const char32_t *cp = ast->value.c_str(); *cp != U'\0'; ++cp) {
+                    if (*cp == U'"') {
+                        o << "\"\"";
+                    } else {
+                        std::string utf8;
+                        encode_utf8(*cp, utf8);
+                        o << utf8;
+                    }
+                }
+                o << "\"";
+            } else if (ast->tokenKind == LiteralString::VERBATIM_SINGLE) {
+                o << "@'";
+                for (const char32_t *cp = ast->value.c_str(); *cp != U'\0'; ++cp) {
+                    if (*cp == U'\'') {
+                        o << "''";
+                    } else {
+                        std::string utf8;
+                        encode_utf8(*cp, utf8);
+                        o << utf8;
+                    }
+                }
+                o << "'";
             }
 
-        } else if (dynamic_cast<const LiteralNull*>(ast_)) {
+        } else if (dynamic_cast<const LiteralNull *>(ast_)) {
             o << "null";
 
-        } else if (auto *ast = dynamic_cast<const Object*>(ast_)) {
+        } else if (auto *ast = dynamic_cast<const Object *>(ast_)) {
             o << "{";
             unparseFields(ast->fields, opts.padObjects);
-            if (ast->trailingComma) o << ",";
+            if (ast->trailingComma)
+                o << ",";
             fill(ast->closeFodder, ast->fields.size() > 0, opts.padObjects);
             o << "}";
 
-        } else if (auto *ast = dynamic_cast<const DesugaredObject*>(ast_)) {
+        } else if (auto *ast = dynamic_cast<const DesugaredObject *>(ast_)) {
             o << "{";
             for (AST *assert : ast->asserts) {
                 o << "assert";
@@ -495,15 +550,16 @@ class Unparser {
             }
             o << "}";
 
-        } else if (auto *ast = dynamic_cast<const ObjectComprehension*>(ast_)) {
+        } else if (auto *ast = dynamic_cast<const ObjectComprehension *>(ast_)) {
             o << "{";
             unparseFields(ast->fields, opts.padObjects);
-            if (ast->trailingComma) o << ",";
+            if (ast->trailingComma)
+                o << ",";
             unparseSpecs(ast->specs);
             fill(ast->closeFodder, true, opts.padObjects);
             o << "}";
 
-        } else if (auto *ast = dynamic_cast<const ObjectComprehensionSimple*>(ast_)) {
+        } else if (auto *ast = dynamic_cast<const ObjectComprehensionSimple *>(ast_)) {
             o << "{[";
             unparse(ast->field, false);
             o << "]:";
@@ -512,16 +568,16 @@ class Unparser {
             unparse(ast->array, true);
             o << "}";
 
-        } else if (auto *ast = dynamic_cast<const Parens*>(ast_)) {
+        } else if (auto *ast = dynamic_cast<const Parens *>(ast_)) {
             o << "(";
             unparse(ast->expr, false);
             fill(ast->closeFodder, false, false);
             o << ")";
 
-        } else if (dynamic_cast<const Self*>(ast_)) {
+        } else if (dynamic_cast<const Self *>(ast_)) {
             o << "self";
 
-        } else if (auto *ast = dynamic_cast<const SuperIndex*>(ast_)) {
+        } else if (auto *ast = dynamic_cast<const SuperIndex *>(ast_)) {
             o << "super";
             fill(ast->dotFodder, false, false);
             if (ast->id != nullptr) {
@@ -535,462 +591,61 @@ class Unparser {
                 o << "]";
             }
 
-        } else if (auto *ast = dynamic_cast<const Unary*>(ast_)) {
+        } else if (auto *ast = dynamic_cast<const Unary *>(ast_)) {
             o << uop_string(ast->op);
-            unparse(ast->expr, false);
+            if (dynamic_cast<const Dollar *>(left_recursive_deep(ast->expr))) {
+                unparse(ast->expr, true);
+            } else {
+                unparse(ast->expr, false);
+            }
 
-        } else if (auto *ast = dynamic_cast<const Var*>(ast_)) {
+        } else if (auto *ast = dynamic_cast<const Var *>(ast_)) {
             o << encode_utf8(ast->id->name);
 
         } else {
             std::cerr << "INTERNAL ERROR: Unknown AST: " << ast_ << std::endl;
             std::abort();
-
         }
     }
 };
 
-
 /********************************************************************************
  * The rest of this file contains transformations on the ASTs before unparsing. *
  ********************************************************************************/
 
-/** As a + b but preserves constraints.
- *
- * Namely, a LINE_END is not allowed to follow a PARAGRAPH or a LINE_END.
- */
-static Fodder concat_fodder(const Fodder &a, const Fodder &b)
-{
-    if (a.size() == 0) return b;
-    if (b.size() == 0) return a;
-    Fodder r = a;
-    // Add the first element of b somehow.
-    if (r[a.size() - 1].kind != FodderElement::INTERSTITIAL &&
-        b[0].kind == FodderElement::LINE_END) {
-        if (b[0].comment.size() > 0) {
-            // The line end had a comment, so create a single line paragraph for it.
-            r.emplace_back(FodderElement::PARAGRAPH, b[0].blanks, b[0].indent, b[0].comment);
-        } else {
-            // Merge it into the previous line end.
-            r[r.size() - 1].indent = b[0].indent;
-            r[r.size() - 1].blanks += b[0].blanks;
-        }
-    } else {
-        r.push_back(b[0]);
-    }
-    // Add the rest of b.
-    for (unsigned i = 1; i < b.size() ; ++i) {
-        r.push_back(b[i]);
-    }
-    return r;
-}
-
-/** Move b to the front of a. */
-static void fodder_move_front(Fodder &a, Fodder &b)
-{
-    a = concat_fodder(b, a);
-    b.clear();
-}
-
-/** Move b to the back of a. */
-static void fodder_move_back(Fodder &a, Fodder &b)
-{
-    a = concat_fodder(a, b);
-    b.clear();
-}
-
-
 /** A generic Pass that does nothing but can be extended to easily define real passes.
  */
-class Pass {
-    public:
-
-    protected:
-    Allocator &alloc;
+class FmtPass : public CompilerPass {
+   protected:
     FmtOpts opts;
 
-    public:
-    Pass(Allocator &alloc, const FmtOpts &opts)
-     : alloc(alloc), opts(opts) { }
-
-    virtual void fodderElement(FodderElement &f)
-    {
-        (void) f;
-    }
-
-    virtual void fodder(Fodder &fodder)
-    {
-        for (auto &f : fodder)
-            fodderElement(f);
-    }
-
-    virtual void specs(std::vector<ComprehensionSpec> &specs)
-    {
-        for (auto &spec : specs) {
-            fodder(spec.openFodder);
-            switch (spec.kind) {
-                case ComprehensionSpec::FOR:
-                fodder(spec.varFodder);
-                fodder(spec.inFodder);
-                expr(spec.expr);
-                break;
-                case ComprehensionSpec::IF:
-                expr(spec.expr);
-                break;
-            }
-        }
-    }
-
-    virtual void params(Fodder &fodder_l, ArgParams &params, Fodder &fodder_r)
-    {
-        fodder(fodder_l);
-        for (auto &param : params) {
-            fodder(param.idFodder);
-            if (param.expr) {
-                fodder(param.eqFodder);
-                expr(param.expr);
-            }
-            fodder(param.commaFodder);
-        }
-        fodder(fodder_r);
-    }
-
-    virtual void fieldParams(ObjectField &field)
-    {
-        if (field.methodSugar) {
-            params(field.fodderL, field.params, field.fodderR);
-        }
-    }
-
-    virtual void fields(ObjectFields &fields)
-    {
-        for (auto &field : fields) {
-
-            switch (field.kind) {
-                case ObjectField::LOCAL: {
-                    fodder(field.fodder1);
-                    fodder(field.fodder2);
-                    fieldParams(field);
-                    fodder(field.opFodder);
-                    expr(field.expr2);
-                } break;
-
-                case ObjectField::FIELD_ID:
-                case ObjectField::FIELD_STR:
-                case ObjectField::FIELD_EXPR: {
-                    if (field.kind == ObjectField::FIELD_ID) {
-                        fodder(field.fodder1);
-
-                    } else if (field.kind == ObjectField::FIELD_STR) {
-                        expr(field.expr1);
-
-                    } else if (field.kind == ObjectField::FIELD_EXPR) {
-                        fodder(field.fodder1);
-                        expr(field.expr1);
-                        fodder(field.fodder2);
-                    }
-                    fieldParams(field);
-                    fodder(field.opFodder);
-                    expr(field.expr2);
-
-                } break;
-
-                case ObjectField::ASSERT: {
-                    fodder(field.fodder1);
-                    expr(field.expr2);
-                    if (field.expr3 != nullptr) {
-                        fodder(field.opFodder);
-                        expr(field.expr3);
-                    }
-                } break;
-            }
-
-            fodder(field.commaFodder);
-        }
-    }
-
-    virtual void expr(AST *&ast_)
-    {
-        fodder(ast_->openFodder);
-        visitExpr(ast_);
-    }
-
-    virtual void visit(Apply *ast)
-    {
-        expr(ast->target);
-        fodder(ast->fodderL);
-        for (auto &arg : ast->args) {
-            expr(arg.expr);
-            fodder(arg.commaFodder);
-        }
-        fodder(ast->fodderR);
-        if (ast->tailstrict) {
-            fodder(ast->tailstrictFodder);
-        }
-    }
-
-    virtual void visit(ApplyBrace *ast)
-    {
-        expr(ast->left);
-        expr(ast->right);
-    }
-
-    virtual void visit(Array *ast)
-    {
-        for (auto &element : ast->elements) {
-            expr(element.expr);
-            fodder(element.commaFodder);
-        }
-        fodder(ast->closeFodder);
-    }
-
-    virtual void visit(ArrayComprehension *ast)
-    {
-        expr(ast->body);
-        fodder(ast->commaFodder);
-        specs(ast->specs);
-        fodder(ast->closeFodder);
-    }
-
-    virtual void visit(Assert *ast)
-    {
-        expr(ast->cond);
-        if (ast->message != nullptr) {
-            fodder(ast->colonFodder);
-            expr(ast->message);
-        }
-        fodder(ast->semicolonFodder);
-        expr(ast->rest);
-    }
-
-    virtual void visit(Binary *ast)
-    {
-        expr(ast->left);
-        fodder(ast->opFodder);
-        expr(ast->right);
-    }
-
-    virtual void visit(BuiltinFunction *) { }
-
-    virtual void visit(Conditional *ast)
-    {
-        expr(ast->cond);
-        fodder(ast->thenFodder);
-        if (ast->branchFalse != nullptr) {
-            expr(ast->branchTrue);
-            fodder(ast->elseFodder);
-            expr(ast->branchFalse);
-        } else {
-            expr(ast->branchTrue);
-        }
-    }
-
-    virtual void visit(Dollar *) { }
-
-    virtual void visit(Error *ast)
-    {
-        expr(ast->expr);
-    }
-
-    virtual void visit(Function *ast)
-    {
-        params(ast->parenLeftFodder, ast->params, ast->parenRightFodder);
-        expr(ast->body);
-    }
-
-    virtual void visit(Import *ast)
-    {
-        visit(ast->file);
-    }
-
-    virtual void visit(Importstr *ast)
-    {
-        visit(ast->file);
-    }
-
-    virtual void visit(Index *ast)
-    {
-        expr(ast->target);
-        if (ast->id != nullptr) {
-        } else {
-            if (ast->isSlice) {
-                if (ast->index != nullptr)
-                    expr(ast->index);
-                if (ast->end != nullptr)
-                    expr(ast->end);
-                if (ast->step != nullptr)
-                    expr(ast->step);
-            } else {
-                expr(ast->index);
-            }
-        }
-    }
-
-    virtual void visit(Local *ast)
-    {
-        assert(ast->binds.size() > 0);
-        for (auto &bind : ast->binds) {
-            fodder(bind.varFodder);
-            if (bind.functionSugar) {
-                params(bind.parenLeftFodder, bind.params, bind.parenRightFodder);
-            } 
-            fodder(bind.opFodder);
-            expr(bind.body);
-            fodder(bind.closeFodder);
-        }
-        expr(ast->body);
-    }
-
-    virtual void visit(LiteralBoolean *) { }
-
-    virtual void visit(LiteralNumber *) { }
-
-    virtual void visit(LiteralString *) { }
-
-    virtual void visit(LiteralNull *) { }
-
-    virtual void visit(Object *ast)
-    {
-        fields(ast->fields);
-        fodder(ast->closeFodder);
-    }
-
-    virtual void visit(DesugaredObject *ast)
-    {
-        for (AST *assert : ast->asserts) {
-            expr(assert);
-        }
-        for (auto &field : ast->fields) {
-            expr(field.name);
-            expr(field.body);
-        }
-    }
-
-    virtual void visit(ObjectComprehension *ast)
-    {
-        fields(ast->fields);
-        specs(ast->specs);
-        fodder(ast->closeFodder);
-    }
-
-    virtual void visit(ObjectComprehensionSimple *ast)
-    {
-        expr(ast->field);
-        expr(ast->value);
-        expr(ast->array);
-    }
-
-    virtual void visit(Parens *ast)
-    {
-        expr(ast->expr);
-        fodder(ast->closeFodder);
-    }
-
-    virtual void visit(Self *) { }
-
-    virtual void visit(SuperIndex *ast)
-    {
-        if (ast->id != nullptr) {
-        } else {
-            expr(ast->index);
-        }
-    }
-
-    virtual void visit(Unary *ast)
-    {
-        expr(ast->expr);
-    }
-
-    virtual void visit(Var *) { }
-
-    virtual void visitExpr(AST *&ast_)
-    {
-        if (auto *ast = dynamic_cast<Apply*>(ast_)) {
-            visit(ast);
-        } else if (auto *ast = dynamic_cast<ApplyBrace*>(ast_)) {
-            visit(ast);
-        } else if (auto *ast = dynamic_cast<Array*>(ast_)) {
-            visit(ast);
-        } else if (auto *ast = dynamic_cast<ArrayComprehension*>(ast_)) {
-            visit(ast);
-        } else if (auto *ast = dynamic_cast<Assert*>(ast_)) {
-            visit(ast);
-        } else if (auto *ast = dynamic_cast<Binary*>(ast_)) {
-            visit(ast);
-        } else if (auto *ast = dynamic_cast<BuiltinFunction*>(ast_)) {
-            visit(ast);
-        } else if (auto *ast = dynamic_cast<Conditional*>(ast_)) {
-            visit(ast);
-        } else if (auto *ast = dynamic_cast<Dollar*>(ast_)) {
-            visit(ast);
-        } else if (auto *ast = dynamic_cast<Error*>(ast_)) {
-            visit(ast);
-        } else if (auto *ast = dynamic_cast<Function*>(ast_)) {
-            visit(ast);
-        } else if (auto *ast = dynamic_cast<Import*>(ast_)) {
-            visit(ast);
-        } else if (auto *ast = dynamic_cast<Importstr*>(ast_)) {
-            visit(ast);
-        } else if (auto *ast = dynamic_cast<Index*>(ast_)) {
-            visit(ast);
-        } else if (auto *ast = dynamic_cast<Local*>(ast_)) {
-            visit(ast);
-        } else if (auto *ast = dynamic_cast<LiteralBoolean*>(ast_)) {
-            visit(ast);
-        } else if (auto *ast = dynamic_cast<LiteralNumber*>(ast_)) {
-            visit(ast);
-        } else if (auto *ast = dynamic_cast<LiteralString*>(ast_)) {
-            visit(ast);
-        } else if (auto *ast = dynamic_cast<LiteralNull*>(ast_)) {
-            visit(ast);
-        } else if (auto *ast = dynamic_cast<Object*>(ast_)) {
-            visit(ast);
-        } else if (auto *ast = dynamic_cast<DesugaredObject*>(ast_)) {
-            visit(ast);
-        } else if (auto *ast = dynamic_cast<ObjectComprehension*>(ast_)) {
-            visit(ast);
-        } else if (auto *ast = dynamic_cast<ObjectComprehensionSimple*>(ast_)) {
-            visit(ast);
-        } else if (auto *ast = dynamic_cast<Parens*>(ast_)) {
-            visit(ast);
-        } else if (auto *ast = dynamic_cast<Self*>(ast_)) {
-            visit(ast);
-        } else if (auto *ast = dynamic_cast<SuperIndex*>(ast_)) {
-            visit(ast);
-        } else if (auto *ast = dynamic_cast<Unary*>(ast_)) {
-            visit(ast);
-        } else if (auto *ast = dynamic_cast<Var*>(ast_)) {
-            visit(ast);
-
-        } else {
-            std::cerr << "INTERNAL ERROR: Unknown AST: " << ast_ << std::endl;
-            std::abort();
-
-        }
-    }
-
-    virtual void file(AST *&body, Fodder &final_fodder)
-    {
-        expr(body);
-        fodder(final_fodder);
-    }
+   public:
+    FmtPass(Allocator &alloc, const FmtOpts &opts) : CompilerPass(alloc), opts(opts) {}
 };
 
+class EnforceStringStyle : public FmtPass {
+    using FmtPass::visit;
 
-class EnforceStringStyle : public Pass {
-    using Pass::visit;
-    public:
-    EnforceStringStyle(Allocator &alloc, const FmtOpts &opts) : Pass(alloc, opts) { }
+   public:
+    EnforceStringStyle(Allocator &alloc, const FmtOpts &opts) : FmtPass(alloc, opts) {}
     void visit(LiteralString *lit)
     {
-        if (lit->tokenKind == LiteralString::BLOCK) return;
-        String canonical = jsonnet_string_unescape(lit->location, lit->value);
+        if (lit->tokenKind == LiteralString::BLOCK)
+            return;
+        if (lit->tokenKind == LiteralString::VERBATIM_DOUBLE)
+            return;
+        if (lit->tokenKind == LiteralString::VERBATIM_SINGLE)
+            return;
+        UString canonical = jsonnet_string_unescape(lit->location, lit->value);
         unsigned num_single = 0, num_double = 0;
         for (char32_t c : canonical) {
-            if (c == '\'') num_single++;
-            if (c == '"') num_double++;
+            if (c == '\'')
+                num_single++;
+            if (c == '"')
+                num_double++;
         }
-        if (num_single > 0 && num_double > 0) return;  // Don't change it.
+        if (num_single > 0 && num_double > 0)
+            return;  // Don't change it.
         bool use_single = opts.stringStyle == 's';
         if (num_single > 0)
             use_single = false;
@@ -1003,12 +658,13 @@ class EnforceStringStyle : public Pass {
     }
 };
 
-class EnforceCommentStyle : public Pass {
-    public:
+class EnforceCommentStyle : public FmtPass {
+   public:
     bool firstFodder;
     EnforceCommentStyle(Allocator &alloc, const FmtOpts &opts)
-      : Pass(alloc, opts), firstFodder(true)
-    { }
+        : FmtPass(alloc, opts), firstFodder(true)
+    {
+    }
     /** Change the comment to match the given style, but don't break she-bang.
      *
      * If preserve_hash is true, do not touch a comment that starts with #!.
@@ -1019,7 +675,8 @@ class EnforceCommentStyle : public Pass {
             s = "#" + s.substr(2);
         }
         if (opts.commentStyle == 's' && s[0] == '#') {
-            if (preserve_hash && s[1] == '!') return;
+            if (preserve_hash && s[1] == '!')
+                return;
             s = "//" + s.substr(1);
         }
     }
@@ -1029,32 +686,32 @@ class EnforceCommentStyle : public Pass {
             switch (f.kind) {
                 case FodderElement::LINE_END:
                 case FodderElement::PARAGRAPH:
-                if (f.comment.size() == 1) {
-                    fixComment(f.comment[0], firstFodder);
-                }
-                break;
+                    if (f.comment.size() == 1) {
+                        fixComment(f.comment[0], firstFodder);
+                    }
+                    break;
 
-                case FodderElement::INTERSTITIAL:
-                break;
+                case FodderElement::INTERSTITIAL: break;
             }
             firstFodder = false;
         }
     }
 };
 
-class EnforceMaximumBlankLines : public Pass {
-    public:
-    EnforceMaximumBlankLines(Allocator &alloc, const FmtOpts &opts) : Pass(alloc, opts) { }
+class EnforceMaximumBlankLines : public FmtPass {
+   public:
+    EnforceMaximumBlankLines(Allocator &alloc, const FmtOpts &opts) : FmtPass(alloc, opts) {}
     void fodderElement(FodderElement &f)
     {
         if (f.kind != FodderElement::INTERSTITIAL)
-            if (f.blanks > 2) f.blanks = 2;
+            if (f.blanks > opts.maxBlankLines)
+                f.blanks = opts.maxBlankLines;
     }
 };
 
-class StripComments : public Pass {
-    public:
-    StripComments(Allocator &alloc, const FmtOpts &opts) : Pass(alloc, opts) { }
+class StripComments : public FmtPass {
+   public:
+    StripComments(Allocator &alloc, const FmtOpts &opts) : FmtPass(alloc, opts) {}
     void fodder(Fodder &fodder)
     {
         Fodder copy = fodder;
@@ -1066,15 +723,18 @@ class StripComments : public Pass {
     }
 };
 
-class StripEverything : public Pass {
-    public:
-    StripEverything(Allocator &alloc, const FmtOpts &opts) : Pass(alloc, opts) { }
-    void fodder(Fodder &fodder) { fodder.clear(); }
+class StripEverything : public FmtPass {
+   public:
+    StripEverything(Allocator &alloc, const FmtOpts &opts) : FmtPass(alloc, opts) {}
+    void fodder(Fodder &fodder)
+    {
+        fodder.clear();
+    }
 };
 
-class StripAllButComments : public Pass {
-    public:
-    StripAllButComments(Allocator &alloc, const FmtOpts &opts) : Pass(alloc, opts) { }
+class StripAllButComments : public FmtPass {
+   public:
+    StripAllButComments(Allocator &alloc, const FmtOpts &opts) : FmtPass(alloc, opts) {}
     Fodder comments;
     void fodder(Fodder &fodder)
     {
@@ -1100,12 +760,7 @@ class StripAllButComments : public Pass {
 /** These cases are infix so we descend on the left to find the fodder. */
 static Fodder &open_fodder(AST *ast_)
 {
-    AST *left = left_recursive(ast_);
-    return left != nullptr ? open_fodder(left) : ast_->openFodder;
-}
-static const Fodder &open_fodder(const AST *ast_)
-{
-    return open_fodder(const_cast<AST*>(ast_));
+    return left_recursive_deep(ast_)->openFodder;
 }
 
 /** Strip blank lines from the top of the file. */
@@ -1126,10 +781,11 @@ bool contains_newline(const Fodder &fodder)
 }
 
 /* Commas should appear at the end of an object/array only if the closing token is on a new line. */
-class FixTrailingCommas : public Pass {
-    using Pass::visit;
-    public:
-    FixTrailingCommas(Allocator &alloc, const FmtOpts &opts) : Pass(alloc, opts) { }
+class FixTrailingCommas : public FmtPass {
+    using FmtPass::visit;
+
+   public:
+    FixTrailingCommas(Allocator &alloc, const FmtOpts &opts) : FmtPass(alloc, opts) {}
     Fodder comments;
 
     // Generalized fix that works across a range of ASTs.
@@ -1140,10 +796,10 @@ class FixTrailingCommas : public Pass {
             if (!need_comma) {
                 // Remove it but keep fodder.
                 trailing_comma = false;
-                fodder_move_back(close_fodder, last_comma_fodder);
+                fodder_move_front(close_fodder, last_comma_fodder);
             } else if (contains_newline(last_comma_fodder)) {
                 // The comma is needed but currently is separated by a newline.
-                fodder_move_back(close_fodder, last_comma_fodder);
+                fodder_move_front(close_fodder, last_comma_fodder);
             }
         } else {
             if (need_comma) {
@@ -1171,13 +827,13 @@ class FixTrailingCommas : public Pass {
         }
 
         fix_comma(expr->elements.back().commaFodder, expr->trailingComma, expr->closeFodder);
-        Pass::visit(expr);
+        FmtPass::visit(expr);
     }
 
     void visit(ArrayComprehension *expr)
     {
         remove_comma(expr->commaFodder, expr->trailingComma, expr->specs[0].openFodder);
-        Pass::visit(expr);
+        FmtPass::visit(expr);
     }
 
     void visit(Object *expr)
@@ -1188,68 +844,64 @@ class FixTrailingCommas : public Pass {
         }
 
         fix_comma(expr->fields.back().commaFodder, expr->trailingComma, expr->closeFodder);
-        Pass::visit(expr);
+        FmtPass::visit(expr);
     }
 
     void visit(ObjectComprehension *expr)
     {
         remove_comma(expr->fields.back().commaFodder, expr->trailingComma, expr->closeFodder);
-        Pass::visit(expr);
+        FmtPass::visit(expr);
     }
-
 };
 
-
 /* Remove nested parens. */
-class FixParens : public Pass {
-    using Pass::visit;
-    public:
-    FixParens(Allocator &alloc, const FmtOpts &opts) : Pass(alloc, opts) { }
+class FixParens : public FmtPass {
+    using FmtPass::visit;
+
+   public:
+    FixParens(Allocator &alloc, const FmtOpts &opts) : FmtPass(alloc, opts) {}
     void visit(Parens *expr)
     {
-        if (auto *body = dynamic_cast<Parens*>(expr->expr)) {
+        if (auto *body = dynamic_cast<Parens *>(expr->expr)) {
             // Deal with fodder.
             expr->expr = body->expr;
             fodder_move_front(open_fodder(body->expr), body->openFodder);
             fodder_move_front(expr->closeFodder, body->closeFodder);
         }
-        Pass::visit(expr);
+        FmtPass::visit(expr);
     }
 };
 
-
-
 /* Ensure ApplyBrace syntax sugar is used in the case of A + { }. */
-class FixPlusObject : public Pass {
-    using Pass::visit;
-    public:
-    FixPlusObject(Allocator &alloc, const FmtOpts &opts) : Pass(alloc, opts) { }
+class FixPlusObject : public FmtPass {
+    using FmtPass::visit;
+
+   public:
+    FixPlusObject(Allocator &alloc, const FmtOpts &opts) : FmtPass(alloc, opts) {}
     void visitExpr(AST *&expr)
     {
-        if (auto *bin_op = dynamic_cast<Binary*>(expr)) {
+        if (auto *bin_op = dynamic_cast<Binary *>(expr)) {
             // Could relax this to allow more ASTs on the LHS but this seems OK for now.
-            if (dynamic_cast<Var*>(bin_op->left)
-                || dynamic_cast<Index*>(bin_op->left)) {
-                if (AST *rhs = dynamic_cast<Object*>(bin_op->right)) {
+            if (dynamic_cast<Var *>(bin_op->left) || dynamic_cast<Index *>(bin_op->left)) {
+                if (AST *rhs = dynamic_cast<Object *>(bin_op->right)) {
                     if (bin_op->op == BOP_PLUS) {
                         fodder_move_front(rhs->openFodder, bin_op->opFodder);
-                        expr = alloc.make<ApplyBrace>(bin_op->location, bin_op->openFodder,
-                                                      bin_op->left, rhs);
+                        expr = alloc.make<ApplyBrace>(
+                            bin_op->location, bin_op->openFodder, bin_op->left, rhs);
                     }
                 }
             }
         }
-        Pass::visitExpr(expr);
+        FmtPass::visitExpr(expr);
     }
 };
 
-
-
 /* Remove final colon in slices. */
-class NoRedundantSliceColon : public Pass {
-    using Pass::visit;
-    public:
-    NoRedundantSliceColon(Allocator &alloc, const FmtOpts &opts) : Pass(alloc, opts) { }
+class NoRedundantSliceColon : public FmtPass {
+    using FmtPass::visit;
+
+   public:
+    NoRedundantSliceColon(Allocator &alloc, const FmtOpts &opts) : FmtPass(alloc, opts) {}
 
     void visit(Index *expr)
     {
@@ -1260,25 +912,25 @@ class NoRedundantSliceColon : public Pass {
                 }
             }
         }
-        Pass::visit(expr);
+        FmtPass::visit(expr);
     }
 };
 
 /* Ensure syntax sugar is used where possible. */
-class PrettyFieldNames : public Pass {
-    using Pass::visit;
-    public:
-    PrettyFieldNames(Allocator &alloc, const FmtOpts &opts) : Pass(alloc, opts) { }
+class PrettyFieldNames : public FmtPass {
+    using FmtPass::visit;
+
+   public:
+    PrettyFieldNames(Allocator &alloc, const FmtOpts &opts) : FmtPass(alloc, opts) {}
 
-    bool isIdentifier(const String &str) {
+    bool isIdentifier(const UString &str)
+    {
         bool first = true;
         for (char32_t c : str) {
             if (!first && c >= '0' && c <= '9')
                 continue;
             first = false;
-            if ((c >= 'A' && c <= 'Z')
-                || (c >= 'a' && c <= 'z')
-                || (c == '_'))
+            if ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || (c == '_'))
                 continue;
             return false;
         }
@@ -1292,7 +944,7 @@ class PrettyFieldNames : public Pass {
     {
         if (!expr->isSlice && expr->index != nullptr) {
             // Maybe we can use an id instead.
-            if (auto *lit = dynamic_cast<LiteralString*>(expr->index)) {
+            if (auto *lit = dynamic_cast<LiteralString *>(expr->index)) {
                 if (isIdentifier(lit->value)) {
                     expr->id = alloc.makeIdentifier(lit->value);
                     expr->idFodder = lit->openFodder;
@@ -1300,7 +952,7 @@ class PrettyFieldNames : public Pass {
                 }
             }
         }
-        Pass::visit(expr);
+        FmtPass::visit(expr);
     }
 
     void visit(Object *expr)
@@ -1308,7 +960,7 @@ class PrettyFieldNames : public Pass {
         for (auto &field : expr->fields) {
             // First try ["foo"] -> "foo".
             if (field.kind == ObjectField::FIELD_EXPR) {
-                if (auto *field_expr = dynamic_cast<LiteralString*>(field.expr1)) {
+                if (auto *field_expr = dynamic_cast<LiteralString *>(field.expr1)) {
                     field.kind = ObjectField::FIELD_STR;
                     fodder_move_front(field_expr->openFodder, field.fodder1);
                     if (field.methodSugar) {
@@ -1320,7 +972,7 @@ class PrettyFieldNames : public Pass {
             }
             // Then try "foo" -> foo.
             if (field.kind == ObjectField::FIELD_STR) {
-                if (auto *lit = dynamic_cast<LiteralString*>(field.expr1)) {
+                if (auto *lit = dynamic_cast<LiteralString *>(field.expr1)) {
                     if (isIdentifier(lit->value)) {
                         field.kind = ObjectField::FIELD_ID;
                         field.id = alloc.makeIdentifier(lit->value);
@@ -1330,21 +982,303 @@ class PrettyFieldNames : public Pass {
                 }
             }
         }
-        Pass::visit(expr);
+        FmtPass::visit(expr);
     }
 };
 
-class FixIndentation {
-
-    Allocator &alloc;
-    FmtOpts opts;
-    unsigned column;
-
-    public:
-    FixIndentation(Allocator &alloc, const FmtOpts &opts) : alloc(alloc), opts(opts) { }
+/// Add newlines inside complex structures (arrays, objects etc.).
+///
+/// The main principle is that a structure can either be:
+/// * expanded and contain newlines in all the designated places
+/// * unexpanded and contain newlines in none of the designated places
+///
+/// It only looks shallowly at the AST nodes, so there may be some newlines deeper that
+/// don't affect expanding. For example:
+/// [{
+///     'a': 'b',
+///     'c': 'd',
+/// }]
+/// The outer array can stay unexpanded, because there are no newlines between
+/// the square brackets and the braces.
+class FixNewlines : public FmtPass {
+    using FmtPass::visit;
+
+    bool shouldExpand(const Array *array)
+    {
+        for (const auto &elem : array->elements) {
+            if (countNewlines(open_fodder(elem.expr)) > 0) {
+                return true;
+            }
+        }
+        if (countNewlines(array->closeFodder) > 0) {
+            return true;
+        }
+        return false;
+    }
 
-    void fill(Fodder &fodder, bool space_before, bool separate_token,
-              unsigned all_but_last_indent, unsigned last_indent)
+    void expand(Array *array)
+    {
+        for (auto &elem : array->elements) {
+            ensureCleanNewline(open_fodder(elem.expr));
+        }
+        ensureCleanNewline(array->closeFodder);
+    }
+
+    Fodder &objectFieldOpenFodder(ObjectField &field)
+    {
+        if (field.kind == ObjectField::Kind::FIELD_STR) {
+            return field.expr1->openFodder;
+        }
+        return field.fodder1;
+    }
+
+    bool shouldExpand(Object *object)
+    {
+        for (auto &field : object->fields) {
+            if (countNewlines(objectFieldOpenFodder(field)) > 0) {
+                return true;
+            }
+        }
+        if (countNewlines(object->closeFodder) > 0) {
+            return true;
+        }
+        return false;
+    }
+
+    void expand(Object *object)
+    {
+        for (auto &field : object->fields) {
+            ensureCleanNewline(objectFieldOpenFodder(field));
+        }
+        ensureCleanNewline(object->closeFodder);
+    }
+
+    bool shouldExpand(Local *local)
+    {
+        for (auto &bind : local->binds) {
+            if (countNewlines(bind.varFodder) > 0) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    void expand(Local *local)
+    {
+        bool first = true;
+        for (auto &bind : local->binds) {
+            if (!first) {
+                ensureCleanNewline(bind.varFodder);
+            }
+            first = false;
+        }
+    }
+
+    bool shouldExpand(ArrayComprehension *comp)
+    {
+        if (countNewlines(open_fodder(comp->body)) > 0) {
+            return true;
+        }
+        for (auto &spec : comp->specs) {
+            if (countNewlines(spec.openFodder) > 0) {
+                return true;
+            }
+        }
+        if (countNewlines(comp->closeFodder) > 0) {
+            return true;
+        }
+        return false;
+    }
+
+    void expand(ArrayComprehension *comp)
+    {
+        ensureCleanNewline(open_fodder(comp->body));
+        for (auto &spec : comp->specs) {
+            ensureCleanNewline(spec.openFodder);
+        }
+        ensureCleanNewline(comp->closeFodder);
+    }
+
+    bool shouldExpand(ObjectComprehension *comp)
+    {
+        for (auto &field : comp->fields) {
+            if (countNewlines(objectFieldOpenFodder(field)) > 0) {
+                return true;
+            }
+        }
+        for (auto &spec : comp->specs) {
+            if (countNewlines(spec.openFodder) > 0) {
+                return true;
+            }
+        }
+        if (countNewlines(comp->closeFodder) > 0) {
+            return true;
+        }
+        return false;
+    }
+
+    void expand(ObjectComprehension *comp)
+    {
+        for (auto &field : comp->fields) {
+            ensureCleanNewline(objectFieldOpenFodder(field));
+        }
+        for (auto &spec : comp->specs) {
+            ensureCleanNewline(spec.openFodder);
+        }
+        ensureCleanNewline(comp->closeFodder);
+    }
+
+    bool shouldExpand(Parens *parens)
+    {
+        return countNewlines(open_fodder(parens->expr)) > 0 ||
+               countNewlines(parens->closeFodder) > 0;
+    }
+
+    void expand(Parens *parens)
+    {
+        ensureCleanNewline(open_fodder(parens->expr));
+        ensureCleanNewline(parens->closeFodder);
+    }
+
+    Fodder &argParamOpenFodder(ArgParam &param)
+    {
+        if (param.id != nullptr) {
+            return param.idFodder;
+        } else if (param.expr != nullptr) {
+            return open_fodder(param.expr);
+        } else {
+            std::cerr << "Invalid ArgParam" << std::endl;
+            abort();
+        }
+    }
+
+    // Example:
+    // f(1, 2,
+    //   3)
+    // Should be expanded to:
+    // f(1,
+    //   2,
+    //   3)
+    bool shouldExpandBetween(ArgParams &params)
+    {
+        bool first = true;
+        for (auto &param : params) {
+            if (!first && countNewlines(argParamOpenFodder(param)) > 0) {
+                return true;
+            }
+            first = false;
+        }
+        return false;
+    }
+
+    void expandBetween(ArgParams &params)
+    {
+        bool first = true;
+        for (auto &param : params) {
+            if (!first) {
+                ensureCleanNewline(argParamOpenFodder(param));
+            }
+            first = false;
+        }
+    }
+
+    // Example:
+    // foo(
+    //     1, 2, 3)
+    // Should be expanded to:
+    // foo(
+    //     1, 2, 3
+    // )
+    bool shouldExpandNearParens(ArgParams &params, Fodder &fodder_r)
+    {
+        if (params.empty()) {
+            return false;
+        }
+        auto &argFodder = argParamOpenFodder(params.front());
+        return countNewlines(fodder_r) > 0 || countNewlines(argFodder) > 0;
+    }
+
+    void expandNearParens(ArgParams &params, Fodder &fodder_r)
+    {
+        if (!params.empty()) {
+            ensureCleanNewline(argParamOpenFodder(params.front()));
+        }
+        ensureCleanNewline(fodder_r);
+    }
+
+   public:
+    FixNewlines(Allocator &alloc, const FmtOpts &opts) : FmtPass(alloc, opts) {}
+
+    template <class T>
+    void simpleExpandingVisit(T *expr)
+    {
+        if (shouldExpand(expr)) {
+            expand(expr);
+        }
+        FmtPass::visit(expr);
+    }
+
+    void visit(Array *array)
+    {
+        simpleExpandingVisit(array);
+    }
+
+    void visit(Object *object)
+    {
+        simpleExpandingVisit(object);
+    }
+
+    void visit(Local *local)
+    {
+        simpleExpandingVisit(local);
+    }
+
+    void visit(ArrayComprehension *comp)
+    {
+        simpleExpandingVisit(comp);
+    }
+
+    void visit(ObjectComprehension *comp)
+    {
+        simpleExpandingVisit(comp);
+    }
+
+    void visit(Parens *parens)
+    {
+        simpleExpandingVisit(parens);
+    }
+
+    void params(Fodder &fodder_l, ArgParams &params, Fodder &fodder_r)
+    {
+        if (shouldExpandBetween(params)) {
+            expandBetween(params);
+        }
+
+        if (shouldExpandNearParens(params, fodder_r)) {
+            expandNearParens(params, fodder_r);
+        }
+
+        FmtPass::params(fodder_l, params, fodder_r);
+    }
+};
+
+class FixIndentation {
+    FmtOpts opts;
+    unsigned column;
+
+   public:
+    FixIndentation(const FmtOpts &opts) : opts(opts), column(0) {}
+
+    /* Set the indentation on the fodder elements, adjust column counter as if it was printed.
+     * \param fodder The fodder to pretend to print.
+     * \param space_before Whether a space should be printed before any other output.
+     * \param separate_token If the last fodder was an interstitial, whether a space should follow
+     * it.
+     * \param all_but_last_indent New indentation value for all but final fodder element.
+     * \param last_indent New indentation value for the final fodder element.
+     */
+    void fill(Fodder &fodder, bool space_before, bool separate_token, unsigned all_but_last_indent,
+              unsigned last_indent)
     {
         setIndents(fodder, all_but_last_indent, last_indent);
         fodder_count(column, fodder, space_before, separate_token);
@@ -1355,10 +1289,20 @@ class FixIndentation {
         fill(fodder, space_before, separate_token, indent, indent);
     }
 
+    /* This struct is the representation of the indentation level.  The field lineUp is what is
+     * generally used to indent after a new line.  The field base is used to help derive a new
+     * Indent struct when the indentation level increases.  lineUp is generally > base.
+     *
+     * In the following case (where spaces are replaced with underscores):
+     * ____foobar(1,
+     * ___________2)
+     *
+     * At the AST representing the 2, the indent has base == 4 and lineUp == 11.
+     */
     struct Indent {
         unsigned base;
         unsigned lineUp;
-        Indent(unsigned base, unsigned line_up) : base(base), lineUp(line_up) { }
+        Indent(unsigned base, unsigned line_up) : base(base), lineUp(line_up) {}
     };
 
     /** Calculate the indentation of sub-expressions.
@@ -1382,7 +1326,6 @@ class FixIndentation {
      * If the first sub-expression is on the same line as the current node, then subsequent
      * ones will be lined up and further indentations in their subexpressions will be based from
      * this column.
-     * by 'indent'.
      */
     Indent newIndentStrong(const Fodder &first_fodder, const Indent &old, unsigned line_up)
     {
@@ -1394,6 +1337,12 @@ class FixIndentation {
         }
     }
 
+    /** Calculate the indentation of sub-expressions.
+     *
+     * If the first sub-expression is on the same line as the current node, then subsequent
+     * ones will be lined up, otherwise subseqeuent ones will be on the next line with no
+     * additional indent.
+     */
     Indent align(const Fodder &first_fodder, const Indent &old, unsigned line_up)
     {
         if (first_fodder.size() == 0 || first_fodder[0].kind == FodderElement::INTERSTITIAL) {
@@ -1404,6 +1353,27 @@ class FixIndentation {
         }
     }
 
+    /** Calculate the indentation of sub-expressions.
+     *
+     * If the first sub-expression is on the same line as the current node, then subsequent
+     * ones will be lined up and further indentations in their subexpresssions will be based from
+     * this column.  Otherwise, subseqeuent ones will be on the next line with no
+     * additional indent.
+     */
+    Indent alignStrong(const Fodder &first_fodder, const Indent &old, unsigned line_up)
+    {
+        if (first_fodder.size() == 0 || first_fodder[0].kind == FodderElement::INTERSTITIAL) {
+            return Indent(line_up, line_up);
+        } else {
+            // Reset
+            return old;
+        }
+    }
+
+    /* Set indentation values within the fodder elements.
+     *
+     * The last one gets a special indentation value, all the others are set to the same thing.
+     */
     void setIndents(Fodder &fodder, unsigned all_but_last_indent, unsigned last_indent)
     {
         // First count how many there are.
@@ -1412,7 +1382,7 @@ class FixIndentation {
             if (f.kind != FodderElement::INTERSTITIAL)
                 count++;
         }
-        // Now set the indent on the right ones.
+        // Now set the indents.
         unsigned i = 0;
         for (auto &f : fodder) {
             if (f.kind != FodderElement::INTERSTITIAL) {
@@ -1443,15 +1413,13 @@ class FixIndentation {
                     column += 2;  // in
                     Indent new_indent = newIndent(open_fodder(spec.expr), indent, column);
                     expr(spec.expr, new_indent, true);
-                }
-                break;
+                } break;
 
                 case ComprehensionSpec::IF: {
                     column += 2;  // if
                     Indent new_indent = newIndent(open_fodder(spec.expr), indent, column);
                     expr(spec.expr, new_indent, true);
-                }
-                break;
+                } break;
             }
         }
     }
@@ -1466,7 +1434,8 @@ class FixIndentation {
         Indent new_indent = newIndent(first_inside, indent, column);
         bool first = true;
         for (auto &param : params) {
-            if (!first) column++;  // ','
+            if (!first)
+                column++;  // ','
             fill(param.idFodder, !first, true, new_indent.lineUp);
             column += param.id->name.length();
             if (param.expr != nullptr) {
@@ -1502,11 +1471,11 @@ class FixIndentation {
         unsigned new_indent = indent.lineUp;
         bool first = true;
         for (auto &field : fields) {
-            if (!first) column++;  // ','
+            if (!first)
+                column++;  // ','
 
             switch (field.kind) {
                 case ObjectField::LOCAL: {
-
                     fill(field.fodder1, !first || space_before, true, indent.lineUp);
                     column += 5;  // local
                     fill(field.fodder2, true, true, indent.lineUp);
@@ -1521,7 +1490,6 @@ class FixIndentation {
                 case ObjectField::FIELD_ID:
                 case ObjectField::FIELD_STR:
                 case ObjectField::FIELD_EXPR: {
-
                     if (field.kind == ObjectField::FIELD_ID) {
                         fill(field.fodder1, !first || space_before, true, new_indent);
                         column += field.id->name.length();
@@ -1541,11 +1509,12 @@ class FixIndentation {
 
                     fill(field.opFodder, false, false, new_indent);
 
-                    if (field.superSugar) column++;
+                    if (field.superSugar)
+                        column++;
                     switch (field.hide) {
-                        case ObjectField::INHERIT: column+=1; break;
-                        case ObjectField::HIDDEN: column+=2; break;
-                        case ObjectField::VISIBLE: column+=3; break;
+                        case ObjectField::INHERIT: column += 1; break;
+                        case ObjectField::HIDDEN: column += 2; break;
+                        case ObjectField::VISIBLE: column += 3; break;
                     }
                     Indent new_indent2 = newIndent(open_fodder(field.expr2), indent, column);
                     expr(field.expr2, new_indent2, true);
@@ -1553,14 +1522,15 @@ class FixIndentation {
                 } break;
 
                 case ObjectField::ASSERT: {
-
                     fill(field.fodder1, !first || space_before, true, new_indent);
                     column += 6;  // assert
+                    // + 1 for the space after the assert
+                    Indent new_indent2 = newIndent(open_fodder(field.expr2), indent, column + 1);
                     expr(field.expr2, indent, true);
                     if (field.expr3 != nullptr) {
-                        fill(field.opFodder, true, true, new_indent);
+                        fill(field.opFodder, true, true, new_indent2.lineUp);
                         column++;  // ":"
-                        expr(field.expr3, indent, true);
+                        expr(field.expr3, new_indent2, true);
                     }
                 } break;
             }
@@ -1570,6 +1540,7 @@ class FixIndentation {
         }
     }
 
+    /** Does the given fodder contain at least one new line? */
     bool hasNewLines(const Fodder &fodder)
     {
         for (const auto &f : fodder) {
@@ -1579,49 +1550,54 @@ class FixIndentation {
         return false;
     }
 
-    bool hasNewLines(const AST *expr)
+    /** Get the first fodder from an ArgParam. */
+    const Fodder &argParamFirstFodder(const ArgParam &ap)
     {
-        return hasNewLines(open_fodder(expr));
+        if (ap.id != nullptr)
+            return ap.idFodder;
+        return open_fodder(ap.expr);
     }
 
     /** Reindent an expression.
      *
      * \param ast_ The ast to reindent.
      * \param indent Beginning of the line.
-     * \param line_up Line up to here.
      * \param space_before As defined in the pretty-printer.
      */
     void expr(AST *ast_, const Indent &indent, bool space_before)
     {
-        fill(ast_->openFodder, space_before, !left_recursive(ast_), indent.lineUp);
+        bool separate_token = !left_recursive(ast_);
 
-        if (auto *ast = dynamic_cast<Apply*>(ast_)) {
+        fill(ast_->openFodder, space_before, separate_token, indent.lineUp);
+
+        if (auto *ast = dynamic_cast<Apply *>(ast_)) {
             const Fodder &init_fodder = open_fodder(ast->target);
-            Indent new_indent = align(init_fodder, indent,
-                                      column + (space_before ? 1 : 0));
+            Indent new_indent = align(init_fodder, indent, column + (space_before ? 1 : 0));
             expr(ast->target, new_indent, space_before);
             fill(ast->fodderL, false, false, new_indent.lineUp);
             column++;  // (
-            const Fodder &first_fodder = ast->args.size() == 0
-                                         ? ast->fodderR
-                                         : open_fodder(ast->args[0].expr);
+            const Fodder &first_fodder =
+                ast->args.size() == 0 ? ast->fodderR : argParamFirstFodder(ast->args[0]);
             bool strong_indent = false;
-            // Need to use strong indent if there are not newlines before any of the sub-expressions
+            // Need to use strong indent if any of the
+            // arguments (except the first) are preceded by newlines.
             bool first = true;
             for (auto &arg : ast->args) {
                 if (first) {
+                    // Skip first element.
                     first = false;
                     continue;
                 }
-                if (hasNewLines(arg.expr)) strong_indent = true;
+                if (hasNewLines(argParamFirstFodder(arg)))
+                    strong_indent = true;
             }
 
-            Indent arg_indent = strong_indent
-                                ? newIndentStrong(first_fodder, indent, column)
-                                : newIndent(first_fodder, indent, column);
+            Indent arg_indent = strong_indent ? newIndentStrong(first_fodder, indent, column)
+                                              : newIndent(first_fodder, indent, column);
             first = true;
             for (auto &arg : ast->args) {
-                if (!first) column++;  // ","
+                if (!first)
+                    column++;  // ","
 
                 bool space = !first;
                 if (arg.id != nullptr) {
@@ -1634,7 +1610,8 @@ class FixIndentation {
                 fill(arg.commaFodder, false, false, arg_indent.lineUp);
                 first = false;
             }
-            if (ast->trailingComma) column++;  // ","
+            if (ast->trailingComma)
+                column++;  // ","
             fill(ast->fodderR, false, false, arg_indent.lineUp, indent.base);
             column++;  // )
             if (ast->tailstrict) {
@@ -1642,19 +1619,17 @@ class FixIndentation {
                 column += 10;  // tailstrict
             }
 
-        } else if (auto *ast = dynamic_cast<ApplyBrace*>(ast_)) {
+        } else if (auto *ast = dynamic_cast<ApplyBrace *>(ast_)) {
             const Fodder &init_fodder = open_fodder(ast->left);
-            Indent new_indent = align(init_fodder, indent,
-                                      column + (space_before ? 1 : 0));
+            Indent new_indent = align(init_fodder, indent, column + (space_before ? 1 : 0));
             expr(ast->left, new_indent, space_before);
             expr(ast->right, new_indent, true);
 
-        } else if (auto *ast = dynamic_cast<Array*>(ast_)) {
+        } else if (auto *ast = dynamic_cast<Array *>(ast_)) {
             column++;  // '['
             // First fodder element exists and is a newline
-            const Fodder &first_fodder = ast->elements.size() > 0
-                                         ? open_fodder(ast->elements[0].expr)
-                                         : ast->closeFodder;
+            const Fodder &first_fodder =
+                ast->elements.size() > 0 ? open_fodder(ast->elements[0].expr) : ast->closeFodder;
             unsigned new_column = column + (opts.padArrays ? 1 : 0);
             bool strong_indent = false;
             // Need to use strong indent if there are not newlines before any of the sub-expressions
@@ -1664,39 +1639,45 @@ class FixIndentation {
                     first = false;
                     continue;
                 }
-                if (hasNewLines(el.expr)) strong_indent = true;
+                if (hasNewLines(open_fodder(el.expr)))
+                    strong_indent = true;
             }
 
-            Indent new_indent = strong_indent
-                                ? newIndentStrong(first_fodder, indent, new_column)
-                                : newIndent(first_fodder, indent, new_column);
-                
+            Indent new_indent = strong_indent ? newIndentStrong(first_fodder, indent, new_column)
+                                              : newIndent(first_fodder, indent, new_column);
+
             first = true;
             for (auto &element : ast->elements) {
-                if (!first) column++;
+                if (!first)
+                    column++;
                 expr(element.expr, new_indent, !first || opts.padArrays);
                 fill(element.commaFodder, false, false, new_indent.lineUp, new_indent.lineUp);
                 first = false;
             }
-            if (ast->trailingComma) column++;
+            if (ast->trailingComma)
+                column++;
 
             // Handle penultimate newlines from expr.close_fodder if there are any.
-            fill(ast->closeFodder, ast->elements.size() > 0, opts.padArrays, new_indent.lineUp,
+            fill(ast->closeFodder,
+                 ast->elements.size() > 0,
+                 opts.padArrays,
+                 new_indent.lineUp,
                  indent.base);
             column++;  // ']'
 
-        } else if (auto *ast = dynamic_cast<ArrayComprehension*>(ast_)) {
+        } else if (auto *ast = dynamic_cast<ArrayComprehension *>(ast_)) {
             column++;  // [
-            Indent new_indent = newIndent(open_fodder(ast->body), indent,
-                                          column + (opts.padArrays ? 1 : 0));
+            Indent new_indent =
+                newIndent(open_fodder(ast->body), indent, column + (opts.padArrays ? 1 : 0));
             expr(ast->body, new_indent, opts.padArrays);
             fill(ast->commaFodder, false, false, new_indent.lineUp);
-            if (ast->trailingComma) column++;  // ','
+            if (ast->trailingComma)
+                column++;  // ','
             specs(ast->specs, new_indent);
             fill(ast->closeFodder, true, opts.padArrays, new_indent.lineUp, indent.base);
             column++;  // ]
 
-        } else if (auto *ast = dynamic_cast<Assert*>(ast_)) {
+        } else if (auto *ast = dynamic_cast<Assert *>(ast_)) {
             column += 6;  // assert
             // + 1 for the space after the assert
             Indent new_indent = newIndent(open_fodder(ast->cond), indent, column + 1);
@@ -1704,16 +1685,28 @@ class FixIndentation {
             if (ast->message != nullptr) {
                 fill(ast->colonFodder, true, true, new_indent.lineUp);
                 column++;  // ":"
-                expr(ast->message, indent, true);
+                expr(ast->message, new_indent, true);
             }
             fill(ast->semicolonFodder, false, false, new_indent.lineUp);
             column++;  // ";"
             expr(ast->rest, indent, true);
 
-        } else if (auto *ast = dynamic_cast<Binary*>(ast_)) {
+        } else if (auto *ast = dynamic_cast<Binary *>(ast_)) {
             const Fodder &first_fodder = open_fodder(ast->left);
-            Indent new_indent = align(first_fodder, indent,
-                                      column + (space_before ? 1 : 0));
+
+            // Need to use strong indent in the case of
+            /*
+            A
+            + B
+            or
+            A +
+            B
+            */
+            bool strong_indent = hasNewLines(ast->opFodder) || hasNewLines(open_fodder(ast->right));
+
+            unsigned inner_column = column + (space_before ? 1 : 0);
+            Indent new_indent = strong_indent ? alignStrong(first_fodder, indent, inner_column)
+                                              : align(first_fodder, indent, inner_column);
             expr(ast->left, new_indent, space_before);
             fill(ast->opFodder, true, true, new_indent.lineUp);
             column += bop_string(ast->op).length();
@@ -1723,12 +1716,12 @@ class FixIndentation {
             // true
             expr(ast->right, new_indent, true);
 
-        } else if (auto *ast = dynamic_cast<BuiltinFunction*>(ast_)) {
+        } else if (auto *ast = dynamic_cast<BuiltinFunction *>(ast_)) {
             column += 11;  // "/* builtin "
             column += ast->name.length();
             column += 8;  // " */ null"
 
-        } else if (auto *ast = dynamic_cast<Conditional*>(ast_)) {
+        } else if (auto *ast = dynamic_cast<Conditional *>(ast_)) {
             column += 2;  // if
             Indent cond_indent = newIndent(open_fodder(ast->cond), indent, column + 1);
             expr(ast->cond, cond_indent, true);
@@ -1743,48 +1736,87 @@ class FixIndentation {
                 expr(ast->branchFalse, false_indent, true);
             }
 
-        } else if (dynamic_cast<Dollar*>(ast_)) {
+        } else if (dynamic_cast<Dollar *>(ast_)) {
             column++;  // $
 
-        } else if (auto *ast = dynamic_cast<Error*>(ast_)) {
+        } else if (auto *ast = dynamic_cast<Error *>(ast_)) {
             column += 5;  // error
             Indent new_indent = newIndent(open_fodder(ast->expr), indent, column + 1);
             expr(ast->expr, new_indent, true);
 
-        } else if (auto *ast = dynamic_cast<Function*>(ast_)) {
+        } else if (auto *ast = dynamic_cast<Function *>(ast_)) {
             column += 8;  // function
-            params(ast->parenLeftFodder, ast->params, ast->trailingComma,
-                   ast->parenRightFodder, indent);
+            params(ast->parenLeftFodder,
+                   ast->params,
+                   ast->trailingComma,
+                   ast->parenRightFodder,
+                   indent);
             Indent new_indent = newIndent(open_fodder(ast->body), indent, column + 1);
             expr(ast->body, new_indent, true);
 
-        } else if (auto *ast = dynamic_cast<Import*>(ast_)) {
+        } else if (auto *ast = dynamic_cast<Import *>(ast_)) {
             column += 6;  // import
             Indent new_indent = newIndent(open_fodder(ast->file), indent, column + 1);
             expr(ast->file, new_indent, true);
 
-        } else if (auto *ast = dynamic_cast<Importstr*>(ast_)) {
+        } else if (auto *ast = dynamic_cast<Importstr *>(ast_)) {
             column += 9;  // importstr
             Indent new_indent = newIndent(open_fodder(ast->file), indent, column + 1);
             expr(ast->file, new_indent, true);
 
-        } else if (auto *ast = dynamic_cast<Index*>(ast_)) {
+        } else if (auto *ast = dynamic_cast<InSuper *>(ast_)) {
+            expr(ast->element, indent, space_before);
+            fill(ast->inFodder, true, true, indent.lineUp);
+            column += 2;  // in
+            fill(ast->superFodder, true, true, indent.lineUp);
+            column += 5;  // super
+
+        } else if (auto *ast = dynamic_cast<Index *>(ast_)) {
             expr(ast->target, indent, space_before);
             fill(ast->dotFodder, false, false, indent.lineUp);
             if (ast->id != nullptr) {
                 Indent new_indent = newIndent(ast->idFodder, indent, column);
-                column++;  // ".";
+                column++;  // "."
                 fill(ast->idFodder, false, false, new_indent.lineUp);
                 column += ast->id->name.length();
             } else {
-                column++;  // "[";
-                Indent new_indent = newIndent(open_fodder(ast->index), indent, column);
-                expr(ast->index, new_indent, false);
-                fill(ast->idFodder, false, false, new_indent.lineUp, indent.base);
-                column++;  // "]";
+                column++;  // "["
+                if (ast->isSlice) {
+                    Indent new_indent(0, 0);
+                    if (ast->index != nullptr) {
+                        new_indent = newIndent(open_fodder(ast->index), indent, column);
+                        expr(ast->index, new_indent, false);
+                    }
+                    if (ast->end != nullptr) {
+                        new_indent = newIndent(ast->endColonFodder, indent, column);
+                        fill(ast->endColonFodder, false, false, new_indent.lineUp);
+                        column++;  // ":"
+                        expr(ast->end, new_indent, false);
+                    }
+                    if (ast->step != nullptr) {
+                        if (ast->end == nullptr) {
+                            new_indent = newIndent(ast->endColonFodder, indent, column);
+                            fill(ast->endColonFodder, false, false, new_indent.lineUp);
+                            column++;  // ":"
+                        }
+                        fill(ast->stepColonFodder, false, false, new_indent.lineUp);
+                        column++;  // ":"
+                        expr(ast->step, new_indent, false);
+                    }
+                    if (ast->index == nullptr && ast->end == nullptr && ast->step == nullptr) {
+                        new_indent = newIndent(ast->endColonFodder, indent, column);
+                        fill(ast->endColonFodder, false, false, new_indent.lineUp);
+                        column++;  // ":"
+                    }
+                } else {
+                    Indent new_indent = newIndent(open_fodder(ast->index), indent, column);
+                    expr(ast->index, new_indent, false);
+                    fill(ast->idFodder, false, false, new_indent.lineUp, indent.base);
+                }
+                column++;  // "]"
             }
 
-        } else if (auto *ast = dynamic_cast<Local*>(ast_)) {
+        } else if (auto *ast = dynamic_cast<Local *>(ast_)) {
             column += 5;  // local
             assert(ast->binds.size() > 0);
             bool first = true;
@@ -1796,9 +1828,12 @@ class FixIndentation {
                 fill(bind.varFodder, true, true, new_indent.lineUp);
                 column += bind.var->name.length();
                 if (bind.functionSugar) {
-                    params(bind.parenLeftFodder, bind.params, bind.trailingComma,
-                           bind.parenRightFodder, new_indent);
-                } 
+                    params(bind.parenLeftFodder,
+                           bind.params,
+                           bind.trailingComma,
+                           bind.parenRightFodder,
+                           new_indent);
+                }
                 fill(bind.opFodder, true, true, new_indent.lineUp);
                 column++;  // '='
                 Indent new_indent2 = newIndent(open_fodder(bind.body), new_indent, column + 1);
@@ -1808,13 +1843,13 @@ class FixIndentation {
             column++;  // ';'
             expr(ast->body, indent, true);
 
-        } else if (auto *ast = dynamic_cast<LiteralBoolean*>(ast_)) {
+        } else if (auto *ast = dynamic_cast<LiteralBoolean *>(ast_)) {
             column += (ast->value ? 4 : 5);
 
-        } else if (auto *ast = dynamic_cast<LiteralNumber*>(ast_)) {
+        } else if (auto *ast = dynamic_cast<LiteralNumber *>(ast_)) {
             column += ast->originalString.length();
 
-        } else if (auto *ast = dynamic_cast<LiteralString*>(ast_)) {
+        } else if (auto *ast = dynamic_cast<LiteralString *>(ast_)) {
             if (ast->tokenKind == LiteralString::DOUBLE) {
                 column += 2 + ast->value.length();  // Include quotes
             } else if (ast->tokenKind == LiteralString::SINGLE) {
@@ -1823,29 +1858,50 @@ class FixIndentation {
                 ast->blockIndent = std::string(indent.base + opts.indent, ' ');
                 ast->blockTermIndent = std::string(indent.base, ' ');
                 column = indent.base;  // blockTermIndent
-                column += 3;  // "|||"
+                column += 3;           // "|||"
+            } else if (ast->tokenKind == LiteralString::VERBATIM_SINGLE) {
+                column += 3;  // Include @, start and end quotes
+                for (const char32_t *cp = ast->value.c_str(); *cp != U'\0'; ++cp) {
+                    if (*cp == U'\'') {
+                        column += 2;
+                    } else {
+                        column += 1;
+                    }
+                }
+            } else if (ast->tokenKind == LiteralString::VERBATIM_DOUBLE) {
+                column += 3;  // Include @, start and end quotes
+                for (const char32_t *cp = ast->value.c_str(); *cp != U'\0'; ++cp) {
+                    if (*cp == U'"') {
+                        column += 2;
+                    } else {
+                        column += 1;
+                    }
+                }
             }
 
-        } else if (dynamic_cast<LiteralNull*>(ast_)) {
+        } else if (dynamic_cast<LiteralNull *>(ast_)) {
             column += 4;  // null
 
-        } else if (auto *ast = dynamic_cast<Object*>(ast_)) {
+        } else if (auto *ast = dynamic_cast<Object *>(ast_)) {
             column++;  // '{'
             const Fodder &first_fodder = ast->fields.size() == 0
-                                         ? ast->closeFodder
-                                         : ast->fields[0].kind == ObjectField::FIELD_STR
-                                           ? open_fodder(ast->fields[0].expr1)
-                                           : ast->fields[0].fodder1;
-            Indent new_indent = newIndent(first_fodder, indent,
-                                          column + (opts.padObjects ? 1 : 0));
+                                             ? ast->closeFodder
+                                             : ast->fields[0].kind == ObjectField::FIELD_STR
+                                                   ? open_fodder(ast->fields[0].expr1)
+                                                   : ast->fields[0].fodder1;
+            Indent new_indent = newIndent(first_fodder, indent, column + (opts.padObjects ? 1 : 0));
 
             fields(ast->fields, new_indent, opts.padObjects);
-            if (ast->trailingComma) column++;
-            fill(ast->closeFodder, ast->fields.size() > 0, opts.padObjects,
-                 new_indent.lineUp, indent.base);
+            if (ast->trailingComma)
+                column++;
+            fill(ast->closeFodder,
+                 ast->fields.size() > 0,
+                 opts.padObjects,
+                 new_indent.lineUp,
+                 indent.base);
             column++;  // '}'
 
-        } else if (auto *ast = dynamic_cast<DesugaredObject*>(ast_)) {
+        } else if (auto *ast = dynamic_cast<DesugaredObject *>(ast_)) {
             // No fodder but need to recurse and maintain column counter.
             column++;  // '{'
             for (AST *assert : ast->asserts) {
@@ -1866,24 +1922,25 @@ class FixIndentation {
             }
             column++;  // '}'
 
-        } else if (auto *ast = dynamic_cast<ObjectComprehension*>(ast_)) {
+        } else if (auto *ast = dynamic_cast<ObjectComprehension *>(ast_)) {
             column++;  // '{'
             unsigned start_column = column;
             const Fodder &first_fodder = ast->fields.size() == 0
-                                         ? ast->closeFodder
-                                         : ast->fields[0].kind == ObjectField::FIELD_STR
-                                           ? open_fodder(ast->fields[0].expr1)
-                                           : ast->fields[0].fodder1;
-            Indent new_indent = newIndent(first_fodder, indent,
-                                          start_column + (opts.padObjects ? 1 : 0));
+                                             ? ast->closeFodder
+                                             : ast->fields[0].kind == ObjectField::FIELD_STR
+                                                   ? open_fodder(ast->fields[0].expr1)
+                                                   : ast->fields[0].fodder1;
+            Indent new_indent =
+                newIndent(first_fodder, indent, start_column + (opts.padObjects ? 1 : 0));
 
             fields(ast->fields, new_indent, opts.padObjects);
-            if (ast->trailingComma) column++;  // ','
+            if (ast->trailingComma)
+                column++;  // ','
             specs(ast->specs, new_indent);
             fill(ast->closeFodder, true, opts.padObjects, new_indent.lineUp, indent.base);
             column++;  // '}'
 
-        } else if (auto *ast = dynamic_cast<ObjectComprehensionSimple*>(ast_)) {
+        } else if (auto *ast = dynamic_cast<ObjectComprehensionSimple *>(ast_)) {
             column++;  // '{'
             column++;  // '['
             expr(ast->field, indent, false);
@@ -1896,17 +1953,17 @@ class FixIndentation {
             expr(ast->array, indent, true);
             column++;  // '}'
 
-        } else if (auto *ast = dynamic_cast<Parens*>(ast_)) {
+        } else if (auto *ast = dynamic_cast<Parens *>(ast_)) {
             column++;  // (
-            Indent new_indent = newIndent(open_fodder(ast->expr), indent, column);
+            Indent new_indent = newIndentStrong(open_fodder(ast->expr), indent, column);
             expr(ast->expr, new_indent, false);
             fill(ast->closeFodder, false, false, new_indent.lineUp, indent.base);
             column++;  // )
 
-        } else if (dynamic_cast<const Self*>(ast_)) {
+        } else if (dynamic_cast<const Self *>(ast_)) {
             column += 4;  // self
 
-        } else if (auto *ast = dynamic_cast<SuperIndex*>(ast_)) {
+        } else if (auto *ast = dynamic_cast<SuperIndex *>(ast_)) {
             column += 5;  // super
             fill(ast->dotFodder, false, false, indent.lineUp);
             if (ast->id != nullptr) {
@@ -1922,18 +1979,21 @@ class FixIndentation {
                 column++;  // "]";
             }
 
-        } else if (auto *ast = dynamic_cast<Unary*>(ast_)) {
+        } else if (auto *ast = dynamic_cast<Unary *>(ast_)) {
             column += uop_string(ast->op).length();
             Indent new_indent = newIndent(open_fodder(ast->expr), indent, column);
-            expr(ast->expr, new_indent, false);
+            if (dynamic_cast<const Dollar *>(left_recursive_deep(ast->expr))) {
+                expr(ast->expr, new_indent, true);
+            } else {
+                expr(ast->expr, new_indent, false);
+            }
 
-        } else if (auto *ast = dynamic_cast<Var*>(ast_)) {
+        } else if (auto *ast = dynamic_cast<Var *>(ast_)) {
             column += ast->id->name.length();
 
         } else {
             std::cerr << "INTERNAL ERROR: Unknown AST: " << ast_ << std::endl;
             std::abort();
-
         }
     }
     virtual void file(AST *body, Fodder &final_fodder)
@@ -1943,19 +2003,263 @@ class FixIndentation {
     }
 };
 
+/** Sort top-level imports.
+ *
+ * Top-level imports are `local x = import 'xxx.jsonnet` expressions
+ * that go before anything else in the file (more precisely all such imports
+ * that are either the root of AST or a direct child (body) of a top-level
+ * import.
+ *
+ * Grouping of imports is preserved. Groups of imports are separated by blank
+ * lines or lines containing comments.
+ */
+class SortImports {
+    /// Internal representation of an import
+    struct ImportElem {
+        ImportElem(UString key, Fodder adjacentFodder, Local::Bind bind)
+            : key(key), adjacentFodder(adjacentFodder), bind(bind)
+        {
+        }
+
+        // A key by which the imports should be sorted.
+        // It's a file path that is imported, represented as UTF-32 codepoints without case folding.
+        // In particular "Z" < "a", because 'Z' == 90 and 'a' == 97.
+        UString key;
+
+        // Comments adjacent to the import that go after it and that should stay attached
+        // when imports are reordered.
+        Fodder adjacentFodder;
+
+        // The bind that contains the import
+        // Satisfies: bind.functionSugar == false && bind.body->type == AST_IMPORT
+        Local::Bind bind;
+        bool operator<(const ImportElem &elem) const
+        {
+            return key < elem.key;
+        }
+    };
+
+    typedef std::vector<ImportElem> ImportElems;
+
+    Allocator &alloc;
+
+   public:
+    SortImports(Allocator &alloc) : alloc(alloc) {}
 
+    /// Get the value by which the imports should be sorted.
+    UString sortingKey(Import *import)
+    {
+        return import->file->value;
+    }
+
+    /// Check if `local` expression is used for importing,
+    bool isGoodLocal(Local *local)
+    {
+        for (const auto &bind : local->binds) {
+            if (bind.body->type != AST_IMPORT || bind.functionSugar) {
+                return false;
+            }
+        }
+        return true;
+    }
 
-// TODO(dcunnin): Add pass to alphabeticize top level imports.
+    Local *goodLocalOrNull(AST *expr)
+    {
+        if (auto *local = dynamic_cast<Local *>(expr)) {
+            return isGoodLocal(local) ? local : nullptr;
+        } else {
+            return nullptr;
+        }
+    }
 
+    /** Split fodder after the first new line / paragraph fodder,
+     * leaving blank lines after the newline in the second half.
+     *
+     * The two returned fodders can be concatenated using concat_fodder to get the original fodder.
+     *
+     * It's a heuristic that given two consecutive tokens `prev_token`, `next_token`
+     * with some fodder between them, decides which part of the fodder logically belongs
+     * to `prev_token` and which part belongs to the `next_token`.
+     *
+     * Example:
+     * prev_token // prev_token is awesome!
+     *
+     * // blah blah
+     * next_token
+     *
+     * In such case "// prev_token is awesome!\n" part of the fodder belongs
+     * to the `prev_token` and "\n//blah blah\n" to the `next_token`.
+     */
+    std::pair<Fodder, Fodder> splitFodder(const Fodder &fodder)
+    {
+        Fodder afterPrev, beforeNext;
+        bool inSecondPart = false;
+        for (const auto &fodderElem : fodder) {
+            if (inSecondPart) {
+                fodder_push_back(beforeNext, fodderElem);
+            } else {
+                afterPrev.push_back(fodderElem);
+            }
+            if (fodderElem.kind != FodderElement::Kind::INTERSTITIAL && !inSecondPart) {
+                inSecondPart = true;
+                if (fodderElem.blanks > 0) {
+                    // If there are any blank lines at the end of afterPrev, move them
+                    // to beforeNext.
+                    afterPrev.back().blanks = 0;
+                    assert(beforeNext.empty());
+                    beforeNext.emplace_back(FodderElement::Kind::LINE_END,
+                                            fodderElem.blanks,
+                                            fodderElem.indent,
+                                            std::vector<std::string>());
+                }
+            }
+        }
+        return {afterPrev, beforeNext};
+    }
+
+    void sortGroup(ImportElems &imports)
+    {
+        // We don't want to change behaviour in such case:
+        // local foo = "b.jsonnet";
+        // local foo = "a.jsonnet";
+        // So we don't change the order when there are shadowed variables.
+        if (!duplicatedVariables(imports)) {
+            std::sort(imports.begin(), imports.end());
+        }
+    }
+
+    ImportElems extractImportElems(const Local::Binds &binds, Fodder after)
+    {
+        ImportElems result;
+        Fodder before = binds.front().varFodder;
+        for (int i = 0; i < int(binds.size()); ++i) {
+            const auto &bind = binds[i];
+            bool last = i == int(binds.size() - 1);
+            Fodder adjacent, beforeNext;
+            if (!last) {
+                auto &next = binds[i + 1];
+                std::tie(adjacent, beforeNext) = splitFodder(next.varFodder);
+            } else {
+                adjacent = after;
+            }
+            ensureCleanNewline(adjacent);
+            Local::Bind newBind = bind;
+            newBind.varFodder = before;
+            Import *import = dynamic_cast<Import *>(bind.body);
+            assert(import != nullptr);
+            result.emplace_back(sortingKey(import), adjacent, newBind);
+            before = beforeNext;
+        }
+        return result;
+    }
+
+    AST *buildGroupAST(ImportElems &imports, AST *body, const Fodder &groupOpenFodder)
+    {
+        for (int i = imports.size() - 1; i >= 0; --i) {
+            auto &import = imports[i];
+            Fodder fodder;
+            if (i == 0) {
+                fodder = groupOpenFodder;
+            } else {
+                fodder = imports[i - 1].adjacentFodder;
+            }
+            auto *local =
+                alloc.make<Local>(LocationRange(), fodder, Local::Binds({import.bind}), body);
+            body = local;
+        }
+
+        return body;
+    }
+
+    bool duplicatedVariables(const ImportElems &elems)
+    {
+        std::set<UString> idents;
+        for (const auto &elem : elems) {
+            idents.insert(elem.bind.var->name);
+        }
+        return idents.size() < elems.size();
+    }
+
+    /// Check if the import group ends after this local
+    bool groupEndsAfter(Local *local)
+    {
+        Local *next = goodLocalOrNull(local->body);
+        if (!next) {
+            return true;
+        }
+
+        bool newlineReached = false;
+        for (const auto &fodderElem : open_fodder(next)) {
+            if (newlineReached || fodderElem.blanks > 0) {
+                return true;
+            }
+            if (fodderElem.kind != FodderElement::Kind::INTERSTITIAL) {
+                newlineReached = true;
+            }
+        }
+        return false;
+    }
+
+    AST *toplevelImport(Local *local, ImportElems &imports, const Fodder &groupOpenFodder)
+    {
+        assert(isGoodLocal(local));
+
+        Fodder adjacentCommentFodder, beforeNextFodder;
+        std::tie(adjacentCommentFodder, beforeNextFodder) = splitFodder(open_fodder(local->body));
+
+        ensureCleanNewline(adjacentCommentFodder);
+
+        ImportElems newImports = extractImportElems(local->binds, adjacentCommentFodder);
+        imports.insert(imports.end(), newImports.begin(), newImports.end());
+
+        if (groupEndsAfter(local)) {
+            sortGroup(imports);
+
+            Fodder afterGroup = imports.back().adjacentFodder;
+            ensureCleanNewline(beforeNextFodder);
+            auto nextOpenFodder = concat_fodder(afterGroup, beforeNextFodder);
+
+            // Process the code after the current group:
+            AST *bodyAfterGroup;
+            Local *next = goodLocalOrNull(local->body);
+            if (next) {
+                // Another group of imports
+                ImportElems nextImports;
+                bodyAfterGroup = toplevelImport(next, nextImports, nextOpenFodder);
+            } else {
+                // Something else
+                bodyAfterGroup = local->body;
+                open_fodder(bodyAfterGroup) = nextOpenFodder;
+            }
+
+            return buildGroupAST(imports, bodyAfterGroup, groupOpenFodder);
+        } else {
+            assert(beforeNextFodder.empty());
+            return toplevelImport(dynamic_cast<Local *>(local->body), imports, groupOpenFodder);
+        }
+    }
+
+    void file(AST *&body)
+    {
+        ImportElems imports;
+        Local *local = goodLocalOrNull(body);
+        if (local) {
+            body = toplevelImport(local, imports, open_fodder(local));
+        }
+    }
+};
 
 std::string jsonnet_fmt(AST *ast, Fodder &final_fodder, const FmtOpts &opts)
 {
     Allocator alloc;
 
     // Passes to enforce style on the AST.
+    if (opts.sortImports)
+        SortImports(alloc).file(ast);
     remove_initial_newlines(ast);
     if (opts.maxBlankLines > 0)
         EnforceMaximumBlankLines(alloc, opts).file(ast, final_fodder);
+    FixNewlines(alloc, opts).file(ast, final_fodder);
     FixTrailingCommas(alloc, opts).file(ast, final_fodder);
     FixParens(alloc, opts).file(ast, final_fodder);
     FixPlusObject(alloc, opts).file(ast, final_fodder);
@@ -1973,7 +2277,7 @@ std::string jsonnet_fmt(AST *ast, Fodder &final_fodder, const FmtOpts &opts)
     if (opts.commentStyle != 'l')
         EnforceCommentStyle(alloc, opts).file(ast, final_fodder);
     if (opts.indent > 0)
-        FixIndentation(alloc, opts).file(ast, final_fodder);
+        FixIndentation(opts).file(ast, final_fodder);
 
     std::stringstream ss;
     Unparser unparser(ss, opts);
diff --git a/libjsonnet/core/formatter.h b/libjsonnet/core/formatter.h
index a3a610b..3fa4aff 100644
--- a/libjsonnet/core/formatter.h
+++ b/libjsonnet/core/formatter.h
@@ -30,18 +30,21 @@ struct FmtOpts {
     bool stripAllButComments;
     bool stripEverything;
     bool prettyFieldNames;
+    bool sortImports;
     FmtOpts(void)
-      : stringStyle('l'),
-        commentStyle('l'),
-        indent(0),
-        maxBlankLines(2),
-        padArrays(false),
-        padObjects(true),
-        stripComments(false),
-        stripAllButComments(false),
-        stripEverything(false),
-        prettyFieldNames(true)
-    { }
+        : stringStyle('l'),
+          commentStyle('l'),
+          indent(0),
+          maxBlankLines(2),
+          padArrays(false),
+          padObjects(true),
+          stripComments(false),
+          stripAllButComments(false),
+          stripEverything(false),
+          prettyFieldNames(true),
+          sortImports(false)
+    {
+    }
 };
 
 /** The inverse of jsonnet_parse.
diff --git a/libjsonnet/core/json.h b/libjsonnet/core/json.h
index d1c5463..d178b8a 100644
--- a/libjsonnet/core/json.h
+++ b/libjsonnet/core/json.h
@@ -17,9 +17,9 @@ limitations under the License.
 #ifndef JSONNET_JSON_H
 #define JSONNET_JSON_H
 
-#include <vector>
 #include <memory>
 #include <string>
+#include <vector>
 
 #include <libjsonnet.h>
 
@@ -32,6 +32,16 @@ struct JsonnetJsonValue {
         OBJECT,
         STRING,
     };
+
+    JsonnetJsonValue() = default;
+    JsonnetJsonValue(JsonnetJsonValue&) = delete;
+    JsonnetJsonValue(JsonnetJsonValue&&) = default;
+
+    JsonnetJsonValue(Kind kind, std::string string, double number)
+        : kind(kind), string(string), number(number)
+    {
+    }
+
     Kind kind;
     std::string string;
     double number;  // Also used for bool (0.0 and 1.0)
diff --git a/libjsonnet/core/lexer.cpp b/libjsonnet/core/lexer.cpp
index e5f6fd9..f119913 100644
--- a/libjsonnet/core/lexer.cpp
+++ b/libjsonnet/core/lexer.cpp
@@ -17,8 +17,8 @@ limitations under the License.
 #include <cassert>
 
 #include <map>
-#include <string>
 #include <sstream>
+#include <string>
 
 #include "lexer.h"
 #include "static_error.h"
@@ -29,7 +29,8 @@ static const std::vector<std::string> EMPTY;
 /** Strip whitespace from both ends of a string, but only up to margin on the left hand side. */
 static std::string strip_ws(const std::string &s, unsigned margin)
 {
-    if (s.size() == 0) return s;  // Avoid underflow below.
+    if (s.size() == 0)
+        return s;  // Avoid underflow below.
     size_t i = 0;
     while (i < s.length() && (s[i] == ' ' || s[i] == '\t' || s[i] == '\r') && i < margin)
         i++;
@@ -45,7 +46,7 @@ static std::vector<std::string> line_split(const std::string &s, unsigned margin
 {
     std::vector<std::string> ret;
     std::stringstream ss;
-    for (size_t i=0 ; i<s.length() ; ++i) {
+    for (size_t i = 0; i < s.length(); ++i) {
         if (s[i] == '\n') {
             ret.emplace_back(strip_ws(ss.str(), margin));
             ss.str("");
@@ -57,8 +58,6 @@ static std::vector<std::string> line_split(const std::string &s, unsigned margin
     return ret;
 }
 
-
-
 /** Consume whitespace.
  *
  * Return number of \n and number of spaces after last \n.  Convert \t to spaces.
@@ -71,33 +70,28 @@ static void lex_ws(const char *&c, unsigned &new_lines, unsigned &indent, const
     for (; *c != '\0' && (*c == ' ' || *c == '\n' || *c == '\t' || *c == '\r'); c++) {
         switch (*c) {
             case '\r':
-            // Ignore.
-            break;
+                // Ignore.
+                break;
 
             case '\n':
-            indent = 0;
-            new_lines++;
-            line_number++;
-            line_start = c + 1;
-            break;
+                indent = 0;
+                new_lines++;
+                line_number++;
+                line_start = c + 1;
+                break;
 
-            case ' ':
-            indent += 1;
-            break;
+            case ' ': indent += 1; break;
 
             // This only works for \t at the beginning of lines, but we strip it everywhere else
             // anyway.  The only case where this will cause a problem is spaces followed by \t
             // at the beginning of a line.  However that is rare, ill-advised, and if re-indentation
             // is enabled it will be fixed later.
-            case '\t':
-            indent += 8;
-            break;
+            case '\t': indent += 8; break;
         }
     }
 }
 
-
-/** 
+/**
 # Consume all text until the end of the line, return number of newlines after that and indent
 */
 static void lex_until_newline(const char *&c, std::string &text, unsigned &blanks, unsigned &indent,
@@ -144,12 +138,21 @@ static bool is_identifier(char c)
 static bool is_symbol(char c)
 {
     switch (c) {
-        case '!': case '$': case ':':
-        case '~': case '+': case '-':
-        case '&': case '|': case '^':
-        case '=': case '<': case '>':
-        case '*': case '/': case '%':
-        return true;
+        case '!':
+        case '$':
+        case ':':
+        case '~':
+        case '+':
+        case '-':
+        case '&':
+        case '|':
+        case '^':
+        case '=':
+        case '<':
+        case '>':
+        case '*':
+        case '/':
+        case '%': return true;
     }
     return false;
 }
@@ -177,7 +180,8 @@ static const std::map<std::string, Token::Kind> keywords = {
 Token::Kind lex_get_keyword_kind(const std::string &identifier)
 {
     auto it = keywords.find(identifier);
-    if (it == keywords.end()) return Token::IDENTIFIER;
+    if (it == keywords.end())
+        return Token::IDENTIFIER;
     return it->second;
 }
 
@@ -208,137 +212,163 @@ std::string lex_number(const char *&c, const std::string &filename, const Locati
     while (true) {
         switch (state) {
             case BEGIN:
-            switch (*c) {
-                case '0':
-                state = AFTER_ZERO;
-                break;
-
-                case '1': case '2': case '3': case '4':
-                case '5': case '6': case '7': case '8': case '9':
-                state = AFTER_ONE_TO_NINE;
+                switch (*c) {
+                    case '0': state = AFTER_ZERO; break;
+
+                    case '1':
+                    case '2':
+                    case '3':
+                    case '4':
+                    case '5':
+                    case '6':
+                    case '7':
+                    case '8':
+                    case '9': state = AFTER_ONE_TO_NINE; break;
+
+                    default: throw StaticError(filename, begin, "Couldn't lex number");
+                }
                 break;
 
-                default:
-                throw StaticError(filename, begin, "Couldn't lex number");
-            }
-            break;
-
             case AFTER_ZERO:
-            switch (*c) {
-                case '.':
-                state = AFTER_DOT;
-                break;
-
-                case 'e': case 'E':
-                state = AFTER_E;
-                break;
-
-                default:
-                goto end;
-            }
-            break;
+                switch (*c) {
+                    case '.': state = AFTER_DOT; break;
 
-            case AFTER_ONE_TO_NINE:
-            switch (*c) {
-                case '.':
-                state = AFTER_DOT;
-                break;
+                    case 'e':
+                    case 'E': state = AFTER_E; break;
 
-                case 'e': case 'E':
-                state = AFTER_E;
+                    default: goto end;
+                }
                 break;
 
-                case '0': case '1': case '2': case '3': case '4':
-                case '5': case '6': case '7': case '8': case '9':
-                state = AFTER_ONE_TO_NINE;
+            case AFTER_ONE_TO_NINE:
+                switch (*c) {
+                    case '.': state = AFTER_DOT; break;
+
+                    case 'e':
+                    case 'E': state = AFTER_E; break;
+
+                    case '0':
+                    case '1':
+                    case '2':
+                    case '3':
+                    case '4':
+                    case '5':
+                    case '6':
+                    case '7':
+                    case '8':
+                    case '9': state = AFTER_ONE_TO_NINE; break;
+
+                    default: goto end;
+                }
                 break;
 
-                default:
-                goto end;
-            }
-            break;
-
             case AFTER_DOT:
-            switch (*c) {
-                case '0': case '1': case '2': case '3': case '4':
-                case '5': case '6': case '7': case '8': case '9':
-                state = AFTER_DIGIT;
-                break;
-
-                default: {
-                    std::stringstream ss;
-                    ss << "Couldn't lex number, junk after decimal point: " << *c;
-                    throw StaticError(filename, begin, ss.str());
+                switch (*c) {
+                    case '0':
+                    case '1':
+                    case '2':
+                    case '3':
+                    case '4':
+                    case '5':
+                    case '6':
+                    case '7':
+                    case '8':
+                    case '9': state = AFTER_DIGIT; break;
+
+                    default: {
+                        std::stringstream ss;
+                        ss << "Couldn't lex number, junk after decimal point: " << *c;
+                        throw StaticError(filename, begin, ss.str());
+                    }
                 }
-            }
-            break;
-
-            case AFTER_DIGIT:
-            switch (*c) {
-                case 'e': case 'E':
-                state = AFTER_E;
                 break;
 
-                case '0': case '1': case '2': case '3': case '4':
-                case '5': case '6': case '7': case '8': case '9':
-                state = AFTER_DIGIT;
+            case AFTER_DIGIT:
+                switch (*c) {
+                    case 'e':
+                    case 'E': state = AFTER_E; break;
+
+                    case '0':
+                    case '1':
+                    case '2':
+                    case '3':
+                    case '4':
+                    case '5':
+                    case '6':
+                    case '7':
+                    case '8':
+                    case '9': state = AFTER_DIGIT; break;
+
+                    default: goto end;
+                }
                 break;
 
-                default:
-                goto end;
-            }
-            break;
-
             case AFTER_E:
-            switch (*c) {
-                case '+': case '-':
-                state = AFTER_EXP_SIGN;
-                break;
-
-                case '0': case '1': case '2': case '3': case '4':
-                case '5': case '6': case '7': case '8': case '9':
-                state = AFTER_EXP_DIGIT;
-                break;
-
-                default: {
-                    std::stringstream ss;
-                    ss << "Couldn't lex number, junk after 'E': " << *c;
-                    throw StaticError(filename, begin, ss.str());
+                switch (*c) {
+                    case '+':
+                    case '-': state = AFTER_EXP_SIGN; break;
+
+                    case '0':
+                    case '1':
+                    case '2':
+                    case '3':
+                    case '4':
+                    case '5':
+                    case '6':
+                    case '7':
+                    case '8':
+                    case '9': state = AFTER_EXP_DIGIT; break;
+
+                    default: {
+                        std::stringstream ss;
+                        ss << "Couldn't lex number, junk after 'E': " << *c;
+                        throw StaticError(filename, begin, ss.str());
+                    }
                 }
-            }
-            break;
-
-            case AFTER_EXP_SIGN:
-            switch (*c) {
-                case '0': case '1': case '2': case '3': case '4':
-                case '5': case '6': case '7': case '8': case '9':
-                state = AFTER_EXP_DIGIT;
                 break;
 
-                default: {
-                    std::stringstream ss;
-                    ss << "Couldn't lex number, junk after exponent sign: " << *c;
-                    throw StaticError(filename, begin, ss.str());
+            case AFTER_EXP_SIGN:
+                switch (*c) {
+                    case '0':
+                    case '1':
+                    case '2':
+                    case '3':
+                    case '4':
+                    case '5':
+                    case '6':
+                    case '7':
+                    case '8':
+                    case '9': state = AFTER_EXP_DIGIT; break;
+
+                    default: {
+                        std::stringstream ss;
+                        ss << "Couldn't lex number, junk after exponent sign: " << *c;
+                        throw StaticError(filename, begin, ss.str());
+                    }
                 }
-            }
-            break;
+                break;
 
             case AFTER_EXP_DIGIT:
-            switch (*c) {
-                case '0': case '1': case '2': case '3': case '4':
-                case '5': case '6': case '7': case '8': case '9':
-                state = AFTER_EXP_DIGIT;
+                switch (*c) {
+                    case '0':
+                    case '1':
+                    case '2':
+                    case '3':
+                    case '4':
+                    case '5':
+                    case '6':
+                    case '7':
+                    case '8':
+                    case '9': state = AFTER_EXP_DIGIT; break;
+
+                    default: goto end;
+                }
                 break;
-
-                default:
-                goto end;
-            }
-            break;
         }
         r += *c;
         c++;
     }
-    end:
+end:
     return r;
 }
 
@@ -348,7 +378,8 @@ static int whitespace_check(const char *a, const char *b)
 {
     int i = 0;
     while (a[i] == ' ' || a[i] == '\t') {
-        if (b[i] != a[i]) return 0;
+        if (b[i] != a[i])
+            return 0;
         i++;
     }
     return i;
@@ -378,7 +409,10 @@ Tokens jsonnet_lex(const std::string &filename, const char *input)
     Fodder fodder;
     bool fresh_line = true;  // Are we tokenizing from the beginning of a new line?
 
-    while (*c!='\0') {
+    while (*c != '\0') {
+        // Used to ensure we have actually advanced the pointer by the end of the iteration.
+        const char *original_c = c;
+
         Token::Kind kind;
         std::string data;
         std::string string_block_indent;
@@ -401,306 +435,367 @@ Tokens jsonnet_lex(const std::string &filename, const char *input)
         Location begin(line_number, c - line_start + 1);
 
         switch (*c) {
-
             // The following operators should never be combined with subsequent symbols.
             case '{':
-            kind = Token::BRACE_L;
-            c++;
-            break;
+                kind = Token::BRACE_L;
+                c++;
+                break;
 
             case '}':
-            kind = Token::BRACE_R;
-            c++;
-            break;
+                kind = Token::BRACE_R;
+                c++;
+                break;
 
             case '[':
-            kind = Token::BRACKET_L;
-            c++;
-            break;
+                kind = Token::BRACKET_L;
+                c++;
+                break;
 
             case ']':
-            kind = Token::BRACKET_R;
-            c++;
-            break;
+                kind = Token::BRACKET_R;
+                c++;
+                break;
 
             case ',':
-            kind = Token::COMMA;
-            c++;
-            break;
+                kind = Token::COMMA;
+                c++;
+                break;
 
             case '.':
-            kind = Token::DOT;
-            c++;
-            break;
+                kind = Token::DOT;
+                c++;
+                break;
 
             case '(':
-            kind = Token::PAREN_L;
-            c++;
-            break;
+                kind = Token::PAREN_L;
+                c++;
+                break;
 
             case ')':
-            kind = Token::PAREN_R;
-            c++;
-            break;
+                kind = Token::PAREN_R;
+                c++;
+                break;
 
             case ';':
-            kind = Token::SEMICOLON;
-            c++;
-            break;
+                kind = Token::SEMICOLON;
+                c++;
+                break;
 
             // Numeric literals.
-            case '0': case '1': case '2': case '3': case '4':
-            case '5': case '6': case '7': case '8': case '9':
-            kind = Token::NUMBER;
-            data = lex_number(c, filename, begin);
-            break;
+            case '0':
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9':
+                kind = Token::NUMBER;
+                data = lex_number(c, filename, begin);
+                break;
 
-            // String literals.
+            // UString literals.
             case '"': {
                 c++;
-                for (; ; ++c) {
+                for (;; ++c) {
                     if (*c == '\0') {
                         throw StaticError(filename, begin, "Unterminated string");
                     }
                     if (*c == '"') {
                         break;
                     }
-                    if (*c == '\\' && *(c+1) != '\0') {
+                    if (*c == '\\' && *(c + 1) != '\0') {
                         data += *c;
                         ++c;
                     }
                     if (*c == '\n') {
                         // Maintain line/column counters.
                         line_number++;
-                        line_start = c+1;
+                        line_start = c + 1;
                     }
                     data += *c;
                 }
                 c++;  // Advance beyond the ".
                 kind = Token::STRING_DOUBLE;
-            }
-            break;
+            } break;
 
-            // String literals.
+            // UString literals.
             case '\'': {
                 c++;
-                for (; ; ++c) {
+                for (;; ++c) {
                     if (*c == '\0') {
                         throw StaticError(filename, begin, "Unterminated string");
                     }
                     if (*c == '\'') {
                         break;
                     }
-                    if (*c == '\\' && *(c+1) != '\0') {
+                    if (*c == '\\' && *(c + 1) != '\0') {
                         data += *c;
                         ++c;
                     }
                     if (*c == '\n') {
                         // Maintain line/column counters.
                         line_number++;
-                        line_start = c+1;
+                        line_start = c + 1;
                     }
                     data += *c;
                 }
                 c++;  // Advance beyond the '.
                 kind = Token::STRING_SINGLE;
-            }
-            break;
+            } break;
+
+            // Verbatim string literals.
+            // ' and " quoting is interpreted here, unlike non-verbatim strings
+            // where it is done later by jsonnet_string_unescape.  This is OK
+            // in this case because no information is lost by resoving the
+            // repeated quote into a single quote, so we can go back to the
+            // original form in the formatter.
+            case '@': {
+                c++;
+                if (*c != '"' && *c != '\'') {
+                    std::stringstream ss;
+                    ss << "Couldn't lex verbatim string, junk after '@': " << *c;
+                    throw StaticError(filename, begin, ss.str());
+                }
+                const char quot = *c;
+                c++;  // Advance beyond the opening quote.
+                for (;; ++c) {
+                    if (*c == '\0') {
+                        throw StaticError(filename, begin, "Unterminated verbatim string");
+                    }
+                    if (*c == quot) {
+                        if (*(c + 1) == quot) {
+                            c++;
+                        } else {
+                            break;
+                        }
+                    }
+                    data += *c;
+                }
+                c++;  // Advance beyond the closing quote.
+                if (quot == '"') {
+                    kind = Token::VERBATIM_STRING_DOUBLE;
+                } else {
+                    kind = Token::VERBATIM_STRING_SINGLE;
+                }
+            } break;
 
             // Keywords
             default:
-            if (is_identifier_first(*c)) {
-                std::string id;
-                for (; is_identifier(*c); ++c)
-                    id += *c;
-                kind = lex_get_keyword_kind(id);
-                data = id;
-
-            } else if (is_symbol(*c) || *c == '#') {
-
-                // Single line C++ and Python style comments.
-                if (*c == '#' || (*c == '/' && *(c+1) == '/')) {
-                    std::vector<std::string> comment(1);
-                    unsigned blanks;
-                    unsigned indent;
-                    lex_until_newline(c, comment[0], blanks, indent, line_start, line_number);
-                    auto kind = fresh_line ? FodderElement::PARAGRAPH : FodderElement::LINE_END;
-                    fodder.emplace_back(kind, blanks, indent, comment);
-                    fresh_line = true;
-                    continue;  // We've not got a token, just fodder, so keep scanning.
-                }
+                if (is_identifier_first(*c)) {
+                    std::string id;
+                    for (; is_identifier(*c); ++c)
+                        id += *c;
+                    kind = lex_get_keyword_kind(id);
+                    data = id;
+
+                } else if (is_symbol(*c) || *c == '#') {
+                    // Single line C++ and Python style comments.
+                    if (*c == '#' || (*c == '/' && *(c + 1) == '/')) {
+                        std::vector<std::string> comment(1);
+                        unsigned blanks;
+                        unsigned indent;
+                        lex_until_newline(c, comment[0], blanks, indent, line_start, line_number);
+                        auto kind = fresh_line ? FodderElement::PARAGRAPH : FodderElement::LINE_END;
+                        fodder.emplace_back(kind, blanks, indent, comment);
+                        fresh_line = true;
+                        continue;  // We've not got a token, just fodder, so keep scanning.
+                    }
 
-                // Multi-line C style comment.
-                if (*c == '/' && *(c+1) == '*') {
+                    // Multi-line C style comment.
+                    if (*c == '/' && *(c + 1) == '*') {
+                        unsigned margin = c - line_start;
 
-                    unsigned margin = c - line_start;
- 
-                    const char *initial_c = c;
-                    c += 2;  // Avoid matching /*/: skip the /* before starting the search for */.
+                        const char *initial_c = c;
+                        c += 2;  // Avoid matching /*/: skip the /* before starting the search for
+                                 // */.
 
-                    while (!(*c == '*' && *(c+1) == '/')) {
-                        if (*c == '\0') {
-                            auto msg = "Multi-line comment has no terminating */.";
-                            throw StaticError(filename, begin, msg);
-                        }
-                        if (*c == '\n') {
-                            // Just keep track of the line / column counters.
-                            line_number++;
-                            line_start = c+1;
-                        }
-                        ++c;
-                    }
-                    c += 2;  // Move the pointer to the char after the closing '/'.
-
-                    std::string comment(initial_c, c - initial_c);  // Includes the "/*" and "*/".
-
-                    // Lex whitespace after comment
-                    unsigned new_lines_after, indent_after;
-                    lex_ws(c, new_lines_after, indent_after, line_start, line_number);
-                    std::vector<std::string> lines;
-                    if (comment.find('\n') >= comment.length()) {
-                        // Comment looks like /* foo */
-                        lines.push_back(comment);
-                        fodder.emplace_back(FodderElement::INTERSTITIAL, 0, 0, lines);
-                        if (new_lines_after > 0) {
-                            fodder.emplace_back(FodderElement::LINE_END, new_lines_after - 1,
-                                                indent_after, EMPTY);
-                            fresh_line = true;
-                        }
-                    } else {
-                        lines = line_split(comment, margin);
-                        assert(lines[0][0] == '/');
-                        // Little hack to support PARAGRAPHs with * down the LHS:
-                        // Add a space to lines that start with a '*'
-                        bool all_star = true;
-                        for (auto &l : lines) {
-                            if (l[0] != '*')
-                                all_star = false;
+                        while (!(*c == '*' && *(c + 1) == '/')) {
+                            if (*c == '\0') {
+                                auto msg = "Multi-line comment has no terminating */.";
+                                throw StaticError(filename, begin, msg);
+                            }
+                            if (*c == '\n') {
+                                // Just keep track of the line / column counters.
+                                line_number++;
+                                line_start = c + 1;
+                            }
+                            ++c;
                         }
-                        if (all_star) {
+                        c += 2;  // Move the pointer to the char after the closing '/'.
+
+                        std::string comment(initial_c,
+                                            c - initial_c);  // Includes the "/*" and "*/".
+
+                        // Lex whitespace after comment
+                        unsigned new_lines_after, indent_after;
+                        lex_ws(c, new_lines_after, indent_after, line_start, line_number);
+                        std::vector<std::string> lines;
+                        if (comment.find('\n') >= comment.length()) {
+                            // Comment looks like /* foo */
+                            lines.push_back(comment);
+                            fodder.emplace_back(FodderElement::INTERSTITIAL, 0, 0, lines);
+                            if (new_lines_after > 0) {
+                                fodder.emplace_back(FodderElement::LINE_END,
+                                                    new_lines_after - 1,
+                                                    indent_after,
+                                                    EMPTY);
+                                fresh_line = true;
+                            }
+                        } else {
+                            lines = line_split(comment, margin);
+                            assert(lines[0][0] == '/');
+                            // Little hack to support PARAGRAPHs with * down the LHS:
+                            // Add a space to lines that start with a '*'
+                            bool all_star = true;
                             for (auto &l : lines) {
-                                if (l[0] == '*') l = " " + l;
+                                if (l[0] != '*')
+                                    all_star = false;
                             }
+                            if (all_star) {
+                                for (auto &l : lines) {
+                                    if (l[0] == '*')
+                                        l = " " + l;
+                                }
+                            }
+                            if (new_lines_after == 0) {
+                                // Ensure a line end after the paragraph.
+                                new_lines_after = 1;
+                                indent_after = 0;
+                            }
+                            fodder_push_back(fodder,
+                                             FodderElement(FodderElement::PARAGRAPH,
+                                                           new_lines_after - 1,
+                                                           indent_after,
+                                                           lines));
+                            fresh_line = true;
                         }
-                        if (new_lines_after == 0) {
-                            // Ensure a line end after the paragraph.
-                            new_lines_after = 1;
-                            indent_after = 0;
-                        }
-                        if (!fresh_line)
-                            // Ensure a line end before the comment.
-                            fodder.emplace_back(FodderElement::LINE_END, 0, 0, EMPTY);
-                        fodder.emplace_back(FodderElement::PARAGRAPH, new_lines_after - 1,
-                                            indent_after, lines);
-                        fresh_line = true;
+                        continue;  // We've not got a token, just fodder, so keep scanning.
                     }
-                    continue;  // We've not got a token, just fodder, so keep scanning.
-                }
 
-                // Text block
-                if (*c == '|' && *(c+1) == '|' && *(c+2) == '|' && *(c+3) == '\n') {
-                    std::stringstream block;
-                    c += 4; // Skip the "|||\n"
-                    line_number++;
-                    // Skip any blank lines at the beginning of the block.
-                    while (*c == '\n') {
-                        line_number++;
-                        ++c;
-                        block << '\n';
-                    }
-                    line_start = c;
-                    const char *first_line = c;
-                    int ws_chars = whitespace_check(first_line, c);
-                    string_block_indent = std::string(first_line, ws_chars);
-                    if (ws_chars == 0) {
-                        auto msg = "Text block's first line must start with whitespace.";
-                        throw StaticError(filename, begin, msg);
-                    }
-                    while (true) {
-                        assert(ws_chars > 0);
-                        // Read up to the \n
-                        for (c = &c[ws_chars]; *c != '\n' ; ++c) {
-                            if (*c == '\0')
-                                throw StaticError(filename, begin, "Unexpected EOF");
-                            block << *c;
+                    // Text block
+                    if (*c == '|' && *(c + 1) == '|' && *(c + 2) == '|') {
+                        if (*(c + 3) != '\n') {
+                            auto msg = "Text block syntax requires new line after |||.";
+                            throw StaticError(filename, begin, msg);
                         }
-                        // Add the \n
-                        block << '\n';
-                        ++c;
+                        std::stringstream block;
+                        c += 4;  // Skip the "|||\n"
                         line_number++;
-                        line_start = c;
-                        // Skip any blank lines
+                        // Skip any blank lines at the beginning of the block.
                         while (*c == '\n') {
                             line_number++;
                             ++c;
                             block << '\n';
                         }
-                        // Examine next line
-                        ws_chars = whitespace_check(first_line, c);
+                        line_start = c;
+                        const char *first_line = c;
+                        int ws_chars = whitespace_check(first_line, c);
+                        string_block_indent = std::string(first_line, ws_chars);
                         if (ws_chars == 0) {
-                            // End of text block
-                            // Skip over any whitespace
-                            while (*c == ' ' || *c == '\t') {
-                                string_block_term_indent += *c;
+                            auto msg = "Text block's first line must start with whitespace.";
+                            throw StaticError(filename, begin, msg);
+                        }
+                        while (true) {
+                            assert(ws_chars > 0);
+                            // Read up to the \n
+                            for (c = &c[ws_chars]; *c != '\n'; ++c) {
+                                if (*c == '\0')
+                                    throw StaticError(filename, begin, "Unexpected EOF");
+                                block << *c;
+                            }
+                            // Add the \n
+                            block << '\n';
+                            ++c;
+                            line_number++;
+                            line_start = c;
+                            // Skip any blank lines
+                            while (*c == '\n') {
+                                line_number++;
                                 ++c;
+                                block << '\n';
                             }
-                            // Expect |||
-                            if (!(*c == '|' && *(c+1) == '|' && *(c+2) == '|')) {
-                                auto msg = "Text block not terminated with |||";
-                                throw StaticError(filename, begin, msg);
+                            // Examine next line
+                            ws_chars = whitespace_check(first_line, c);
+                            if (ws_chars == 0) {
+                                // End of text block
+                                // Skip over any whitespace
+                                while (*c == ' ' || *c == '\t') {
+                                    string_block_term_indent += *c;
+                                    ++c;
+                                }
+                                // Expect |||
+                                if (!(*c == '|' && *(c + 1) == '|' && *(c + 2) == '|')) {
+                                    auto msg = "Text block not terminated with |||";
+                                    throw StaticError(filename, begin, msg);
+                                }
+                                c += 3;  // Leave after the last |
+                                data = block.str();
+                                kind = Token::STRING_BLOCK;
+                                break;  // Out of the while loop.
                             }
-                            c += 3;  // Leave after the last |
-                            data = block.str();
-                            kind = Token::STRING_BLOCK;
-                            break;  // Out of the while loop.
                         }
-                    }
 
-                    break;  // Out of the switch.
-                }
+                        break;  // Out of the switch.
+                    }
 
-                const char *operator_begin = c;
-                for (; is_symbol(*c) ; ++c) {
-                    // Not allowed // in operators
-                    if (*c == '/' && *(c+1) == '/') break;
-                    // Not allowed /* in operators
-                    if (*c == '/' && *(c+1) == '*') break;
-                    // Not allowed ||| in operators
-                    if (*c == '|' && *(c+1) == '|' && *(c+2) == '|') break;
-                }
-                // Not allowed to end with a + - ~ ! unless a single char.
-                // So, wind it back if we need to (but not too far).
-                while (c > operator_begin + 1
-                       && (*(c-1) == '+' || *(c-1) == '-' || *(c-1) == '~' || *(c-1) == '!')) {
-                    c--;
-                }
-                data += std::string(operator_begin, c);
-                if (data == "$") {
-                    kind = Token::DOLLAR;
-                    data = "";
+                    const char *operator_begin = c;
+                    for (; is_symbol(*c); ++c) {
+                        // Not allowed // in operators
+                        if (*c == '/' && *(c + 1) == '/')
+                            break;
+                        // Not allowed /* in operators
+                        if (*c == '/' && *(c + 1) == '*')
+                            break;
+                        // Not allowed ||| in operators
+                        if (*c == '|' && *(c + 1) == '|' && *(c + 2) == '|')
+                            break;
+                    }
+                    // Not allowed to end with a + - ~ ! unless a single char.
+                    // So, wind it back if we need to (but not too far).
+                    while (c > operator_begin + 1 && (*(c - 1) == '+' || *(c - 1) == '-' ||
+                                                      *(c - 1) == '~' || *(c - 1) == '!')) {
+                        c--;
+                    }
+                    data += std::string(operator_begin, c);
+                    if (data == "$") {
+                        kind = Token::DOLLAR;
+                        data = "";
+                    } else {
+                        kind = Token::OPERATOR;
+                    }
                 } else {
-                    kind = Token::OPERATOR;
+                    std::stringstream ss;
+                    ss << "Could not lex the character ";
+                    auto uc = (unsigned char)(*c);
+                    if (*c < 32)
+                        ss << "code " << unsigned(uc);
+                    else
+                        ss << "'" << *c << "'";
+                    throw StaticError(filename, begin, ss.str());
                 }
-            } else {
-                std::stringstream ss;
-                ss << "Could not lex the character ";
-                auto uc = (unsigned char)(*c);
-                if (*c < 32)
-                    ss << "code " << unsigned(uc);
-                else
-                    ss << "'" << *c << "'";
-                throw StaticError(filename, begin, ss.str());
-            }
         }
 
-        Location end(line_number, c - line_start);
-        r.emplace_back(kind, fodder, data, string_block_indent, string_block_term_indent,
+        // Ensure that a bug in the above code does not cause an infinite memory consuming loop due
+        // to pushing empty tokens.
+        if (c == original_c) {
+            throw StaticError(filename, begin, "Internal lexing error:  Pointer did not advance");
+        }
+
+        Location end(line_number, (c + 1) - line_start);
+        r.emplace_back(kind,
+                       fodder,
+                       data,
+                       string_block_indent,
+                       string_block_term_indent,
                        LocationRange(filename, begin, end));
         fodder.clear();
         fresh_line = false;
     }
 
-    Location end(line_number, c - line_start + 1);
+    Location end(line_number, (c + 1) - line_start + 1);
     r.emplace_back(Token::END_OF_FILE, fodder, "", "", "", LocationRange(filename, end, end));
     return r;
 }
@@ -713,8 +808,8 @@ std::string jsonnet_unlex(const Tokens &tokens)
             switch (f.kind) {
                 case FodderElement::LINE_END: {
                     if (f.comment.size() > 0) {
-                        ss << "LineEnd(" << f.blanks << ", " << f.indent << ", "
-                           << f.comment[0] << ")\n";
+                        ss << "LineEnd(" << f.blanks << ", " << f.indent << ", " << f.comment[0]
+                           << ")\n";
                     } else {
                         ss << "LineEnd(" << f.blanks << ", " << f.indent << ")\n";
                     }
@@ -744,7 +839,7 @@ std::string jsonnet_unlex(const Tokens &tokens)
         } else if (t.kind == Token::STRING_BLOCK) {
             ss << "|||\n";
             ss << t.stringBlockIndent;
-            for (const char *cp = t.data.c_str() ; *cp != '\0' ; ++cp) {
+            for (const char *cp = t.data.c_str(); *cp != '\0'; ++cp) {
                 ss << *cp;
                 if (*cp == '\n' && *(cp + 1) != '\n' && *(cp + 1) != '\0') {
                     ss << t.stringBlockIndent;
diff --git a/libjsonnet/core/lexer.h b/libjsonnet/core/lexer.h
index 9a7b5c3..839199e 100644
--- a/libjsonnet/core/lexer.h
+++ b/libjsonnet/core/lexer.h
@@ -17,17 +17,17 @@ limitations under the License.
 #ifndef JSONNET_LEXER_H
 #define JSONNET_LEXER_H
 
-#include <cstdlib>
 #include <cassert>
+#include <cstdlib>
 
 #include <iostream>
-#include <string>
 #include <list>
 #include <sstream>
+#include <string>
 #include <vector>
 
-#include "unicode.h"
 #include "static_error.h"
+#include "unicode.h"
 
 /** Whitespace and comments.
  *
@@ -35,40 +35,188 @@ limitations under the License.
  */
 struct FodderElement {
     enum Kind {
+        /** The next token, paragraph, or interstitial should be on a new line.
+         *
+         * A single comment string is allowed, which flows before the new line.
+         *
+         * The LINE_END fodder specifies the indentation level and vertical spacing before whatever
+         * comes next.
+         */
         LINE_END,
+
+        /** A C-style comment that begins and ends on the same line.
+         *
+         * If it follows a token (i.e., it is the first fodder element) then it appears after the
+         * token on the same line.  If it follows another interstitial, it will also flow after it
+         * on the same line.  If it follows a new line or a paragraph, it is the first thing on the
+         * following line, after the blank lines and indentation specified by the previous fodder.
+         *
+         * There is exactly one comment string.
+         */
         INTERSTITIAL,
+
+        /** A comment consisting of at least one line.
+         *
+         * // and # style commes have exactly one line.  C-style comments can have more than one
+         * line.
+         *
+         * All lines of the comment are indented according to the indentation level of the previous
+         * new line / paragraph fodder.
+         *
+         * The PARAGRAPH fodder specifies the indentation level and vertical spacing before whatever
+         * comes next.
+         */
         PARAGRAPH,
     };
     Kind kind;
+
+    /** How many blank lines (vertical space) before the next fodder / token. */
     unsigned blanks;
+
+    /** How far the next fodder / token should be indented. */
     unsigned indent;
+
+    /** Whatever comments are part of this fodder.
+     *
+     * Constraints apply.  See Kind, above.
+     *
+     * The strings include any delimiting characters, e.g. // # and C-style comment delimiters but
+     * not newline characters or indentation.
+     */
     std::vector<std::string> comment;
+
     FodderElement(Kind kind, unsigned blanks, unsigned indent,
                   const std::vector<std::string> &comment)
-      : kind(kind), blanks(blanks), indent(indent), comment(comment)
+        : kind(kind), blanks(blanks), indent(indent), comment(comment)
     {
         assert(kind != LINE_END || comment.size() <= 1);
         assert(kind != INTERSTITIAL || (blanks == 0 && indent == 0 && comment.size() == 1));
         assert(kind != PARAGRAPH || comment.size() >= 1);
     }
 };
+
 static inline std::ostream &operator<<(std::ostream &o, const FodderElement &f)
 {
     switch (f.kind) {
         case FodderElement::LINE_END:
-        o << "END(" << f.blanks << ", " << f.indent << ", " << f.comment[0] << ")";
-        break;
+            o << "END(" << f.blanks << ", " << f.indent;
+            if (!f.comment.empty()) {
+                o << ", " << f.comment[0];
+            }
+            o << ")";
+            break;
         case FodderElement::INTERSTITIAL:
-        o << "INT(" << f.blanks << ", " << f.indent << ", " << f.comment[0] << ")";
-        break;
+            o << "INT(" << f.blanks << ", " << f.indent << ", " << f.comment[0] << ")";
+            break;
         case FodderElement::PARAGRAPH:
-        o << "PAR(" << f.blanks << ", " << f.indent << ", " << f.comment[0] << "...)";
-        break;
+            o << "PAR(" << f.blanks << ", " << f.indent << ", " << f.comment[0] << "...)";
+            break;
     }
     return o;
 }
+
+/** A sequence of fodder elements, typically between two tokens.
+ *
+ * A LINE_END is not allowed to follow a PARAGRAPH or a LINE_END. This can be represented by
+ * replacing the indent of the prior fodder and increasing the number of blank lines if necessary.
+ * If there was a comment, it can be represented by changing the LINE_END to a paragraph containing
+ * the same single comment string.
+ *
+ * There must be a LINE_END or a PARAGRAPH before a PARAGRAPH.
+ *
+ * TODO(sbarzowski) Make it a proper class
+ */
 typedef std::vector<FodderElement> Fodder;
 
+static inline bool fodder_has_clean_endline(const Fodder &fodder)
+{
+    return !fodder.empty() && fodder.back().kind != FodderElement::INTERSTITIAL;
+}
+
+/** As a.push_back(elem) but preserves constraints.
+ *
+ * See concat_fodder below.
+ */
+static inline void fodder_push_back(Fodder &a, const FodderElement &elem)
+{
+    if (fodder_has_clean_endline(a) && elem.kind == FodderElement::LINE_END) {
+        if (elem.comment.size() > 0) {
+            // The line end had a comment, so create a single line paragraph for it.
+            a.emplace_back(FodderElement::PARAGRAPH, elem.blanks, elem.indent, elem.comment);
+        } else {
+            // Merge it into the previous line end.
+            a.back().indent = elem.indent;
+            a.back().blanks += elem.blanks;
+        }
+    } else {
+        if (!fodder_has_clean_endline(a) && elem.kind == FodderElement::PARAGRAPH) {
+            a.emplace_back(FodderElement::LINE_END, 0, elem.indent, std::vector<std::string>());
+        }
+        a.push_back(elem);
+    }
+}
+
+/** As a + b but preserves constraints.
+ *
+ * Namely, a LINE_END is not allowed to follow a PARAGRAPH or a LINE_END.
+ */
+static inline Fodder concat_fodder(const Fodder &a, const Fodder &b)
+{
+    if (a.size() == 0)
+        return b;
+    if (b.size() == 0)
+        return a;
+    Fodder r = a;
+    // Carefully add the first element of b.
+    fodder_push_back(r, b[0]);
+    // Add the rest of b.
+    for (unsigned i = 1; i < b.size(); ++i) {
+        r.push_back(b[i]);
+    }
+    return r;
+}
+
+/** Move b to the front of a. */
+static inline void fodder_move_front(Fodder &a, Fodder &b)
+{
+    a = concat_fodder(b, a);
+    b.clear();
+}
+
+static inline Fodder make_fodder(const FodderElement &elem)
+{
+    Fodder fodder;
+    fodder_push_back(fodder, elem);
+    return fodder;
+}
+
+static inline void ensureCleanNewline(Fodder &fodder)
+{
+    if (!fodder_has_clean_endline(fodder)) {
+        fodder_push_back(fodder, FodderElement(FodderElement::Kind::LINE_END, 0, 0, {}));
+    }
+}
+
+static inline int countNewlines(const FodderElement &elem)
+{
+    switch (elem.kind) {
+        case FodderElement::INTERSTITIAL: return 0;
+        case FodderElement::LINE_END: return 1;
+        case FodderElement::PARAGRAPH: return elem.comment.size() + elem.blanks;
+    }
+    std::cerr << "Unknown FodderElement kind" << std::endl;
+    abort();
+}
+
+static inline int countNewlines(const Fodder &fodder)
+{
+    int sum = 0;
+    for (const auto &elem : fodder) {
+        sum += countNewlines(elem);
+    }
+    return sum;
+}
+
 static inline std::ostream &operator<<(std::ostream &o, const Fodder &fodder)
 {
     bool first = true;
@@ -102,6 +250,8 @@ struct Token {
         STRING_DOUBLE,
         STRING_SINGLE,
         STRING_BLOCK,
+        VERBATIM_STRING_SINGLE,
+        VERBATIM_STRING_DOUBLE,
 
         // Keywords
         ASSERT,
@@ -142,19 +292,26 @@ struct Token {
      */
     std::string stringBlockTermIndent;
 
-    String data32(void) { return decode_utf8(data); }
+    UString data32(void)
+    {
+        return decode_utf8(data);
+    }
 
     LocationRange location;
 
     Token(Kind kind, const Fodder &fodder, const std::string &data,
           const std::string &string_block_indent, const std::string &string_block_term_indent,
           const LocationRange &location)
-      : kind(kind), fodder(fodder), data(data), stringBlockIndent(string_block_indent),
-        stringBlockTermIndent(string_block_term_indent), location(location)
-    { }
+        : kind(kind),
+          fodder(fodder),
+          data(data),
+          stringBlockIndent(string_block_indent),
+          stringBlockTermIndent(string_block_term_indent),
+          location(location)
+    {
+    }
 
-    Token(Kind kind, const std::string &data="")
-        : kind(kind), data(data) { }
+    Token(Kind kind, const std::string &data = "") : kind(kind), data(data) {}
 
     static const char *toString(Kind v)
     {
@@ -176,6 +333,8 @@ struct Token {
             case OPERATOR: return "OPERATOR";
             case STRING_SINGLE: return "STRING_SINGLE";
             case STRING_DOUBLE: return "STRING_DOUBLE";
+            case VERBATIM_STRING_SINGLE: return "VERBATIM_STRING_SINGLE";
+            case VERBATIM_STRING_DOUBLE: return "VERBATIM_STRING_DOUBLE";
             case STRING_BLOCK: return "STRING_BLOCK";
 
             case ASSERT: return "assert";
@@ -198,8 +357,8 @@ struct Token {
 
             case END_OF_FILE: return "end of file";
             default:
-            std::cerr << "INTERNAL ERROR: Unknown token kind: " << v << std::endl;
-            std::abort();
+                std::cerr << "INTERNAL ERROR: Unknown token kind: " << v << std::endl;
+                std::abort();
         }
     }
 };
@@ -213,8 +372,10 @@ typedef std::list<Token> Tokens;
 
 static inline bool operator==(const Token &a, const Token &b)
 {
-    if (a.kind != b.kind) return false;
-    if (a.data != b.data) return false;
+    if (a.kind != b.kind)
+        return false;
+    if (a.data != b.data)
+        return false;
     return true;
 }
 
@@ -229,7 +390,7 @@ static inline std::ostream &operator<<(std::ostream &o, const Token &v)
     if (v.data == "") {
         o << Token::toString(v.kind);
     } else if (v.kind == Token::OPERATOR) {
-            o << "\"" << v.data << "\"";
+        o << "\"" << v.data << "\"";
     } else {
         o << "(" << Token::toString(v.kind) << ", \"" << v.data << "\")";
     }
diff --git a/libjsonnet/core/lexer_test.cpp b/libjsonnet/core/lexer_test.cpp
index 271e2e4..2d454ce 100644
--- a/libjsonnet/core/lexer_test.cpp
+++ b/libjsonnet/core/lexer_test.cpp
@@ -21,9 +21,7 @@ limitations under the License.
 
 namespace {
 
-void testLex(const char* name,
-             const char* input,
-             const std::list<Token>& tokens,
+void testLex(const char* name, const char* input, const std::list<Token>& tokens,
              const std::string& error)
 {
     std::list<Token> test_tokens(tokens);
@@ -31,8 +29,7 @@ void testLex(const char* name,
 
     try {
         std::list<Token> lexed_tokens = jsonnet_lex(name, input);
-        ASSERT_EQ(test_tokens, lexed_tokens)
-            << "Test failed: " << name << std::endl;
+        ASSERT_EQ(test_tokens, lexed_tokens) << "Test failed: " << name << std::endl;
     } catch (StaticError& e) {
         ASSERT_EQ(error, e.toString());
     }
@@ -54,9 +51,10 @@ TEST(Lexer, TestOperators)
     testLex("colon 2", "::", {Token(Token::Kind::OPERATOR, "::")}, "");
     testLex("colon 2", ":::", {Token(Token::Kind::OPERATOR, ":::")}, "");
     testLex("arrow right", "->", {Token(Token::Kind::OPERATOR, "->")}, "");
-    testLex("less than minus", "<-",
-            {Token(Token::Kind::OPERATOR, "<"),
-             Token(Token::Kind::OPERATOR, "-")}, "");
+    testLex("less than minus",
+            "<-",
+            {Token(Token::Kind::OPERATOR, "<"), Token(Token::Kind::OPERATOR, "-")},
+            "");
     testLex("comma", ",", {Token(Token::Kind::COMMA, "")}, "");
     testLex("dollar", "$", {Token(Token::Kind::DOLLAR, "")}, "");
     testLex("dot", ".", {Token(Token::Kind::DOT, "")}, "");
@@ -97,47 +95,106 @@ TEST(Lexer, TestNumbers)
     testLex("number 1.1e100", "1.1e100", {Token(Token::Kind::NUMBER, "1.1e100")}, "");
     testLex("number 1.1e-100", "1.1e-100", {Token(Token::Kind::NUMBER, "1.1e-100")}, "");
     testLex("number 1.1e+100", "1.1e+100", {Token(Token::Kind::NUMBER, "1.1e+100")}, "");
-    testLex("number 0100", "0100",
+    testLex("number 0100",
+            "0100",
             {Token(Token::Kind::NUMBER, "0"), Token(Token::Kind::NUMBER, "100")},
             "");
-    testLex("number 10+10", "10+10",
+    testLex("number 10+10",
+            "10+10",
             {Token(Token::Kind::NUMBER, "10"),
              Token(Token::Kind::OPERATOR, "+"),
-             Token(Token::Kind::NUMBER, "10")}, "");
-    testLex("number 1.+3", "1.+3", {},
+             Token(Token::Kind::NUMBER, "10")},
+            "");
+    testLex("number 1.+3",
+            "1.+3",
+            {},
             "number 1.+3:1:1: Couldn't lex number, junk after decimal point: +");
-    testLex("number 1e!", "1e!", {},
-            "number 1e!:1:1: Couldn't lex number, junk after 'E': !");
-    testLex("number 1e+!", "1e+!", {},
+    testLex("number 1e!", "1e!", {}, "number 1e!:1:1: Couldn't lex number, junk after 'E': !");
+    testLex("number 1e+!",
+            "1e+!",
+            {},
             "number 1e+!:1:1: Couldn't lex number, junk after exponent sign: !");
 }
 
 TEST(Lexer, TestDoubleStrings)
 {
-    testLex("double string \"hi\"",
-            "\"hi\"", {Token(Token::Kind::STRING_DOUBLE, "hi")}, "");
-    testLex("double string \"hi nl\"",
-            "\"hi\n\"", {Token(Token::Kind::STRING_DOUBLE, "hi\n")}, "");
+    testLex("double string \"hi\"", "\"hi\"", {Token(Token::Kind::STRING_DOUBLE, "hi")}, "");
+    testLex("double string \"hi nl\"", "\"hi\n\"", {Token(Token::Kind::STRING_DOUBLE, "hi\n")}, "");
     testLex("double string \"hi\\\"\"",
-            "\"hi\\\"\"", {Token(Token::Kind::STRING_DOUBLE, "hi\\\"")}, "");
+            "\"hi\\\"\"",
+            {Token(Token::Kind::STRING_DOUBLE, "hi\\\"")},
+            "");
     testLex("double string \"hi\\nl\"",
-            "\"hi\\\n\"", {Token(Token::Kind::STRING_DOUBLE, "hi\\\n")}, "");
-    testLex("double string \"hi",
-            "\"hi", {}, "double string \"hi:1:1: Unterminated string");
+            "\"hi\\\n\"",
+            {Token(Token::Kind::STRING_DOUBLE, "hi\\\n")},
+            "");
+    testLex("double string \"hi", "\"hi", {}, "double string \"hi:1:1: Unterminated string");
 }
 
 TEST(Lexer, TestSingleStrings)
 {
-    testLex("single string 'hi'",
-            "'hi'", {Token(Token::Kind::STRING_SINGLE, "hi")}, "");
-    testLex("single string 'hi nl'",
-            "'hi\n'", {Token(Token::Kind::STRING_SINGLE, "hi\n")}, "");
-    testLex("single string 'hi\\''",
-            "'hi\\''", {Token(Token::Kind::STRING_SINGLE, "hi\\'")}, "");
-    testLex("single string 'hi\\nl'",
-            "'hi\\\n'", {Token(Token::Kind::STRING_SINGLE, "hi\\\n")}, "");
-    testLex("single string 'hi",
-            "'hi", {}, "single string 'hi:1:1: Unterminated string");
+    testLex("single string 'hi'", "'hi'", {Token(Token::Kind::STRING_SINGLE, "hi")}, "");
+    testLex("single string 'hi nl'", "'hi\n'", {Token(Token::Kind::STRING_SINGLE, "hi\n")}, "");
+    testLex("single string 'hi\\''", "'hi\\''", {Token(Token::Kind::STRING_SINGLE, "hi\\'")}, "");
+    testLex(
+        "single string 'hi\\nl'", "'hi\\\n'", {Token(Token::Kind::STRING_SINGLE, "hi\\\n")}, "");
+    testLex("single string 'hi", "'hi", {}, "single string 'hi:1:1: Unterminated string");
+}
+
+TEST(Lexer, TestVerbatimDoubleStrings)
+{
+    testLex("verbatim double string @\"hi\"",
+            "@\"hi\"",
+            {Token(Token::Kind::VERBATIM_STRING_DOUBLE, "hi")},
+            "");
+    testLex("verbatim double string @\"hi nl\"",
+            "@\"hi\n\"",
+            {Token(Token::Kind::VERBATIM_STRING_DOUBLE, "hi\n")},
+            "");
+    testLex("verbatim double string @\"hi\\\"",
+            "@\"hi\\\"",
+            {Token(Token::Kind::VERBATIM_STRING_DOUBLE, "hi\\")},
+            "");
+    testLex("verbatim double string @\"hi\\\\\"",
+            "@\"hi\\\\\"",
+            {Token(Token::Kind::VERBATIM_STRING_DOUBLE, "hi\\\\")},
+            "");
+    testLex("verbatim double string @\"hi\"\"\"",
+            "@\"hi\"\"\"",
+            {Token(Token::Kind::VERBATIM_STRING_DOUBLE, "hi\"")},
+            "");
+    testLex("verbatim double string @\"\"\"hi\"",
+            "@\"\"\"hi\"",
+            {Token(Token::Kind::VERBATIM_STRING_DOUBLE, "\"hi")},
+            "");
+}
+
+TEST(Lexer, TestVerbatimSingleStrings)
+{
+    testLex("verbatim single string @'hi'",
+            "@'hi'",
+            {Token(Token::Kind::VERBATIM_STRING_SINGLE, "hi")},
+            "");
+    testLex("verbatim single string @'hi nl'",
+            "@'hi\n'",
+            {Token(Token::Kind::VERBATIM_STRING_SINGLE, "hi\n")},
+            "");
+    testLex("verbatim single string @'hi\\'",
+            "@'hi\\'",
+            {Token(Token::Kind::VERBATIM_STRING_SINGLE, "hi\\")},
+            "");
+    testLex("verbatim single string @'hi\\\\'",
+            "@'hi\\\\'",
+            {Token(Token::Kind::VERBATIM_STRING_SINGLE, "hi\\\\")},
+            "");
+    testLex("verbatim single string @'hi'''",
+            "@'hi'''",
+            {Token(Token::Kind::VERBATIM_STRING_SINGLE, "hi'")},
+            "");
+    testLex("verbatim single string @'''hi'",
+            "@'''hi'",
+            {Token(Token::Kind::VERBATIM_STRING_SINGLE, "'hi")},
+            "");
 }
 
 TEST(Lexer, TestBlockStringSpaces)
@@ -149,13 +206,8 @@ TEST(Lexer, TestBlockStringSpaces)
         "  |||\n"
         "    foo\n"
         "|||";
-    const Token token = Token(
-        Token::Kind::STRING_BLOCK,
-        {},
-        "test\n  more\n|||\n  foo\n",
-        "  ",
-        "",
-        {});
+    const Token token =
+        Token(Token::Kind::STRING_BLOCK, {}, "test\n  more\n|||\n  foo\n", "  ", "", {});
     testLex("block string spaces", str, {token}, "");
 }
 
@@ -168,13 +220,8 @@ TEST(Lexer, TestBlockStringTabs)
         "\t|||\n"
         "\t  foo\n"
         "|||";
-    const Token token = Token(
-        Token::Kind::STRING_BLOCK,
-        {},
-        "test\n  more\n|||\n  foo\n",
-        "\t",
-        "",
-        {});
+    const Token token =
+        Token(Token::Kind::STRING_BLOCK, {}, "test\n  more\n|||\n  foo\n", "\t", "", {});
     testLex("block string tabs", str, {token}, "");
 }
 
@@ -187,13 +234,8 @@ TEST(Lexer, TestBlockStringsMixed)
         "\t  \t|||\n"
         "\t  \t  foo\n"
         "|||";
-    const Token token = Token(
-        Token::Kind::STRING_BLOCK,
-        {},
-        "test\n  more\n|||\n  foo\n",
-        "\t  \t",
-        "",
-        {});
+    const Token token =
+        Token(Token::Kind::STRING_BLOCK, {}, "test\n  more\n|||\n  foo\n", "\t  \t", "", {});
     testLex("block string mixed", str, {token}, "");
 }
 
@@ -206,13 +248,8 @@ TEST(Lexer, TestBlockStringBlanks)
         "  |||\n"
         "    foo\n"
         "|||";
-    const Token token = Token(
-        Token::Kind::STRING_BLOCK,
-        {},
-        "\ntest\n\n\n  more\n|||\n  foo\n",
-        "  ",
-        "",
-        {});
+    const Token token =
+        Token(Token::Kind::STRING_BLOCK, {}, "\ntest\n\n\n  more\n|||\n  foo\n", "  ", "", {});
     testLex("block string blanks", str, {token}, "");
 }
 
@@ -223,7 +260,9 @@ TEST(Lexer, TestBlockStringBadIndent)
         "  test\n"
         " foo\n"
         "|||";
-    testLex("block string bad indent", str, {},
+    testLex("block string bad indent",
+            str,
+            {},
             "block string bad indent:1:1: Text block not terminated with |||");
 }
 
@@ -240,7 +279,9 @@ TEST(Lexer, TestBlockStringNotTerm)
     const char str[] =
         "|||\n"
         "  test\n";
-    testLex("block string not term", str, {},
+    testLex("block string not term",
+            str,
+            {},
             "block string not term:1:1: Text block not terminated with |||");
 }
 
@@ -250,7 +291,9 @@ TEST(Lexer, TestBlockStringNoWs)
         "|||\n"
         "test\n"
         "|||";
-    testLex("block string no ws", str, {},
+    testLex("block string no ws",
+            str,
+            {},
             "block string no ws:1:1: Text block's first line must start with"
             " whitespace.");
 }
@@ -279,9 +322,10 @@ TEST(Lexer, TestKeywords)
 TEST(Lexer, TestIdentifier)
 {
     testLex("identifier", "foobar123", {Token(Token::Kind::IDENTIFIER, "foobar123")}, "");
-    testLex("identifier", "foo bar123",
-            {Token(Token::Kind::IDENTIFIER, "foo"),
-             Token(Token::Kind::IDENTIFIER, "bar123")}, "");
+    testLex("identifier",
+            "foo bar123",
+            {Token(Token::Kind::IDENTIFIER, "foo"), Token(Token::Kind::IDENTIFIER, "bar123")},
+            "");
 }
 
 TEST(Lexer, TestComments)
@@ -290,7 +334,9 @@ TEST(Lexer, TestComments)
     testLex("c++ comment", "// hi", {}, "");
     testLex("hash comment", "# hi", {}, "");
     testLex("c comment", "/* hi */", {}, "");
-    testLex("c comment no term", "/* hi", {},
+    testLex("c comment no term",
+            "/* hi",
+            {},
             "c comment no term:1:1: Multi-line comment has no terminating */.");
 }
 
diff --git a/libjsonnet/core/libjsonnet.cpp b/libjsonnet/core/libjsonnet.cpp
index ec759ed..5899f2b 100644
--- a/libjsonnet/core/libjsonnet.cpp
+++ b/libjsonnet/core/libjsonnet.cpp
@@ -14,9 +14,9 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
+#include <cerrno>
 #include <cstdlib>
 #include <cstring>
-#include <cerrno>
 
 #include <exception>
 #include <fstream>
@@ -41,7 +41,7 @@ static void memory_panic(void)
     abort();
 }
 
-static char *from_string(JsonnetVm* vm, const std::string &v)
+static char *from_string(JsonnetVm *vm, const std::string &v)
 {
     char *r = jsonnet_realloc(vm, nullptr, v.length() + 1);
     std::strcpy(r, v.c_str());
@@ -53,7 +53,7 @@ static char *default_import_callback(void *ctx, const char *dir, const char *fil
 
 const char *jsonnet_json_extract_string(JsonnetVm *vm, const struct JsonnetJsonValue *v)
 {
-    (void) vm;
+    (void)vm;
     if (v->kind != JsonnetJsonValue::STRING)
         return nullptr;
     return v->string.c_str();
@@ -61,7 +61,7 @@ const char *jsonnet_json_extract_string(JsonnetVm *vm, const struct JsonnetJsonV
 
 int jsonnet_json_extract_number(struct JsonnetVm *vm, const struct JsonnetJsonValue *v, double *out)
 {
-    (void) vm;
+    (void)vm;
     if (v->kind != JsonnetJsonValue::NUMBER)
         return 0;
     *out = v->number;
@@ -70,20 +70,21 @@ int jsonnet_json_extract_number(struct JsonnetVm *vm, const struct JsonnetJsonVa
 
 int jsonnet_json_extract_bool(struct JsonnetVm *vm, const struct JsonnetJsonValue *v)
 {
-    (void) vm;
-    if (v->kind != JsonnetJsonValue::BOOL) return 2;
+    (void)vm;
+    if (v->kind != JsonnetJsonValue::BOOL)
+        return 2;
     return v->number != 0;
 }
 
 int jsonnet_json_extract_null(struct JsonnetVm *vm, const struct JsonnetJsonValue *v)
 {
-    (void) vm;
+    (void)vm;
     return v->kind == JsonnetJsonValue::NULL_KIND;
 }
 
 JsonnetJsonValue *jsonnet_json_make_string(JsonnetVm *vm, const char *v)
 {
-    (void) vm;
+    (void)vm;
     JsonnetJsonValue *r = new JsonnetJsonValue();
     r->kind = JsonnetJsonValue::STRING;
     r->string = v;
@@ -92,7 +93,7 @@ JsonnetJsonValue *jsonnet_json_make_string(JsonnetVm *vm, const char *v)
 
 JsonnetJsonValue *jsonnet_json_make_number(struct JsonnetVm *vm, double v)
 {
-    (void) vm;
+    (void)vm;
     JsonnetJsonValue *r = new JsonnetJsonValue();
     r->kind = JsonnetJsonValue::NUMBER;
     r->number = v;
@@ -101,7 +102,7 @@ JsonnetJsonValue *jsonnet_json_make_number(struct JsonnetVm *vm, double v)
 
 JsonnetJsonValue *jsonnet_json_make_bool(struct JsonnetVm *vm, int v)
 {
-    (void) vm;
+    (void)vm;
     JsonnetJsonValue *r = new JsonnetJsonValue();
     r->kind = JsonnetJsonValue::BOOL;
     r->number = v != 0;
@@ -110,7 +111,7 @@ JsonnetJsonValue *jsonnet_json_make_bool(struct JsonnetVm *vm, int v)
 
 JsonnetJsonValue *jsonnet_json_make_null(struct JsonnetVm *vm)
 {
-    (void) vm;
+    (void)vm;
     JsonnetJsonValue *r = new JsonnetJsonValue();
     r->kind = JsonnetJsonValue::NULL_KIND;
     return r;
@@ -118,7 +119,7 @@ JsonnetJsonValue *jsonnet_json_make_null(struct JsonnetVm *vm)
 
 JsonnetJsonValue *jsonnet_json_make_array(JsonnetVm *vm)
 {
-    (void) vm;
+    (void)vm;
     JsonnetJsonValue *r = new JsonnetJsonValue();
     r->kind = JsonnetJsonValue::ARRAY;
     return r;
@@ -126,30 +127,30 @@ JsonnetJsonValue *jsonnet_json_make_array(JsonnetVm *vm)
 
 void jsonnet_json_array_append(JsonnetVm *vm, JsonnetJsonValue *arr, JsonnetJsonValue *v)
 {
-    (void) vm;
+    (void)vm;
     assert(arr->kind == JsonnetJsonValue::ARRAY);
     arr->elements.emplace_back(v);
 }
 
 JsonnetJsonValue *jsonnet_json_make_object(JsonnetVm *vm)
 {
-    (void) vm;
+    (void)vm;
     JsonnetJsonValue *r = new JsonnetJsonValue();
     r->kind = JsonnetJsonValue::OBJECT;
     return r;
 }
 
-void jsonnet_json_object_append(JsonnetVm *vm, JsonnetJsonValue *obj,
-                                const char *f, JsonnetJsonValue *v)
+void jsonnet_json_object_append(JsonnetVm *vm, JsonnetJsonValue *obj, const char *f,
+                                JsonnetJsonValue *v)
 {
-    (void) vm;
+    (void)vm;
     assert(obj->kind == JsonnetJsonValue::OBJECT);
     obj->fields[std::string(f)] = std::unique_ptr<JsonnetJsonValue>(v);
 }
 
 void jsonnet_json_destroy(JsonnetVm *vm, JsonnetJsonValue *v)
 {
-    (void) vm;
+    (void)vm;
     delete v;
 }
 
@@ -170,20 +171,21 @@ struct JsonnetVm {
     bool fmtDebugDesugaring;
 
     JsonnetVm(void)
-      : gcGrowthTrigger(2.0), maxStack(500), gcMinObjects(1000), maxTrace(20),
-        importCallback(default_import_callback), importCallbackContext(this), stringOutput(false),
-        fmtDebugDesugaring(false)
+        : gcGrowthTrigger(2.0),
+          maxStack(500),
+          gcMinObjects(1000),
+          maxTrace(20),
+          importCallback(default_import_callback),
+          importCallbackContext(this),
+          stringOutput(false),
+          fmtDebugDesugaring(false)
     {
-        jpaths.emplace_back("/usr/share/" + std::string(jsonnet_version()) + "/");
-        jpaths.emplace_back("/usr/local/share/" + std::string(jsonnet_version()) + "/");
+        jpaths.emplace_back("/usr/share/jsonnet-" + std::string(jsonnet_version()) + "/");
+        jpaths.emplace_back("/usr/local/share/jsonnet-" + std::string(jsonnet_version()) + "/");
     }
 };
 
-enum ImportStatus {
-    IMPORT_STATUS_OK,
-    IMPORT_STATUS_FILE_NOT_FOUND,
-    IMPORT_STATUS_IO_ERROR
-};
+enum ImportStatus { IMPORT_STATUS_OK, IMPORT_STATUS_FILE_NOT_FOUND, IMPORT_STATUS_IO_ERROR };
 
 static enum ImportStatus try_path(const std::string &dir, const std::string &rel,
                                   std::string &content, std::string &found_here,
@@ -208,7 +210,8 @@ static enum ImportStatus try_path(const std::string &dir, const std::string &rel
 
     std::ifstream f;
     f.open(abs_path.c_str());
-    if (!f.good()) return IMPORT_STATUS_FILE_NOT_FOUND;
+    if (!f.good())
+        return IMPORT_STATUS_FILE_NOT_FOUND;
     try {
         content.assign(std::istreambuf_iterator<char>(f), std::istreambuf_iterator<char>());
     } catch (const std::ios_base::failure &io_err) {
@@ -228,7 +231,7 @@ static enum ImportStatus try_path(const std::string &dir, const std::string &rel
 static char *default_import_callback(void *ctx, const char *dir, const char *file,
                                      char **found_here_cptr, int *success)
 {
-    auto *vm = static_cast<JsonnetVm*>(ctx);
+    auto *vm = static_cast<JsonnetVm *>(ctx);
 
     std::string input, found_here, err_msg;
 
@@ -261,13 +264,17 @@ static char *default_import_callback(void *ctx, const char *dir, const char *fil
 }
 
 #define TRY try {
-#define CATCH(func) \
-    } catch (const std::bad_alloc &) {\
-        memory_panic(); \
-    } catch (const std::exception &e) {\
-        std::cerr << "Something went wrong during " func ", please report this: " \
-                  << e.what() << std::endl; \
-        abort(); \
+#define CATCH(func)                                                                           \
+    }                                                                                         \
+    catch (const std::bad_alloc &)                                                            \
+    {                                                                                         \
+        memory_panic();                                                                       \
+    }                                                                                         \
+    catch (const std::exception &e)                                                           \
+    {                                                                                         \
+        std::cerr << "Something went wrong during " func ", please report this: " << e.what() \
+                  << std::endl;                                                               \
+        abort();                                                                              \
     }
 
 const char *jsonnet_version(void)
@@ -278,7 +285,7 @@ const char *jsonnet_version(void)
 JsonnetVm *jsonnet_make(void)
 {
     TRY
-    return new JsonnetVm();
+        return new JsonnetVm();
     CATCH("jsonnet_make")
     return nullptr;
 }
@@ -286,7 +293,7 @@ JsonnetVm *jsonnet_make(void)
 void jsonnet_destroy(JsonnetVm *vm)
 {
     TRY
-    delete vm;
+        delete vm;
     CATCH("jsonnet_destroy")
 }
 
@@ -317,15 +324,14 @@ void jsonnet_import_callback(struct JsonnetVm *vm, JsonnetImportCallback *cb, vo
 }
 
 void jsonnet_native_callback(struct JsonnetVm *vm, const char *name, JsonnetNativeCallback *cb,
-                             void *ctx, const char * const *params)
+                             void *ctx, const char *const *params)
 {
     std::vector<std::string> params2;
     for (; *params != nullptr; params++)
         params2.push_back(*params);
-    vm->nativeCallbacks[name] = VmNativeCallback {cb, ctx, params2};
+    vm->nativeCallbacks[name] = VmNativeCallback{cb, ctx, params2};
 }
 
-
 void jsonnet_ext_var(JsonnetVm *vm, const char *key, const char *val)
 {
     vm->ext[key] = VmExt(val, false);
@@ -390,6 +396,11 @@ void jsonnet_fmt_pretty_field_names(JsonnetVm *vm, int v)
     vm->fmtOpts.prettyFieldNames = v;
 }
 
+void jsonnet_fmt_sort_imports(JsonnetVm *vm, int v)
+{
+    vm->fmtOpts.sortImports = v;
+}
+
 void jsonnet_max_trace(JsonnetVm *vm, unsigned v)
 {
     vm->maxTrace = v;
@@ -397,9 +408,11 @@ void jsonnet_max_trace(JsonnetVm *vm, unsigned v)
 
 void jsonnet_jpath_add(JsonnetVm *vm, const char *path_)
 {
-    if (std::strlen(path_) == 0) return;
+    if (std::strlen(path_) == 0)
+        return;
     std::string path = path_;
-    if (path[path.length() - 1] != '/') path += '/';
+    if (path[path.length() - 1] != '/')
+        path += '/';
     vm->jpaths.emplace_back(path);
 }
 
@@ -434,7 +447,6 @@ static char *jsonnet_fmt_snippet_aux(JsonnetVm *vm, const char *filename, const
         *error = true;
         return from_string(vm, ss.str());
     }
-
 }
 
 char *jsonnet_fmt_file(JsonnetVm *vm, const char *filename, int *error)
@@ -449,8 +461,7 @@ char *jsonnet_fmt_file(JsonnetVm *vm, const char *filename, int *error)
             return from_string(vm, ss.str());
         }
         std::string input;
-        input.assign(std::istreambuf_iterator<char>(f),
-                     std::istreambuf_iterator<char>());
+        input.assign(std::istreambuf_iterator<char>(f), std::istreambuf_iterator<char>());
 
         return jsonnet_fmt_snippet_aux(vm, filename, input.c_str(), error);
     CATCH("jsonnet_fmt_file")
@@ -465,13 +476,12 @@ char *jsonnet_fmt_snippet(JsonnetVm *vm, const char *filename, const char *snipp
     return nullptr;  // Never happens.
 }
 
-
 namespace {
 enum EvalKind { REGULAR, MULTI, STREAM };
 }  // namespace
 
-static char *jsonnet_evaluate_snippet_aux(JsonnetVm *vm, const char *filename,
-                                          const char *snippet, int *error, EvalKind kind)
+static char *jsonnet_evaluate_snippet_aux(JsonnetVm *vm, const char *filename, const char *snippet,
+                                          int *error, EvalKind kind)
 {
     try {
         Allocator alloc;
@@ -482,31 +492,52 @@ static char *jsonnet_evaluate_snippet_aux(JsonnetVm *vm, const char *filename,
 
         jsonnet_desugar(&alloc, expr, &vm->tla);
 
+        unsigned max_stack = vm->maxStack;
+
+        // For the stdlib desugaring.
+        max_stack++;
+
+        // For the TLA desugaring.
+        max_stack++;
+
         jsonnet_static_analysis(expr);
         switch (kind) {
             case REGULAR: {
-                std::string json_str = jsonnet_vm_execute(
-                    &alloc, expr, vm->ext, vm->maxStack, vm->gcMinObjects,
-                    vm->gcGrowthTrigger, vm->nativeCallbacks, vm->importCallback,
-                    vm->importCallbackContext, vm->stringOutput);
+                std::string json_str = jsonnet_vm_execute(&alloc,
+                                                          expr,
+                                                          vm->ext,
+                                                          max_stack,
+                                                          vm->gcMinObjects,
+                                                          vm->gcGrowthTrigger,
+                                                          vm->nativeCallbacks,
+                                                          vm->importCallback,
+                                                          vm->importCallbackContext,
+                                                          vm->stringOutput);
                 json_str += "\n";
                 *error = false;
                 return from_string(vm, json_str);
-            }
-            break;
+            } break;
 
             case MULTI: {
-                std::map<std::string, std::string> files = jsonnet_vm_execute_multi(
-                    &alloc, expr, vm->ext, vm->maxStack, vm->gcMinObjects,
-                    vm->gcGrowthTrigger, vm->nativeCallbacks, vm->importCallback,
-                    vm->importCallbackContext, vm->stringOutput);
-                size_t sz = 1; // final sentinel
+                std::map<std::string, std::string> files =
+                    jsonnet_vm_execute_multi(&alloc,
+                                             expr,
+                                             vm->ext,
+                                             max_stack,
+                                             vm->gcMinObjects,
+                                             vm->gcGrowthTrigger,
+                                             vm->nativeCallbacks,
+                                             vm->importCallback,
+                                             vm->importCallbackContext,
+                                             vm->stringOutput);
+                size_t sz = 1;  // final sentinel
                 for (const auto &pair : files) {
-                    sz += pair.first.length() + 1; // include sentinel
-                    sz += pair.second.length() + 2; // Add a '\n' as well as sentinel
+                    sz += pair.first.length() + 1;   // include sentinel
+                    sz += pair.second.length() + 2;  // Add a '\n' as well as sentinel
                 }
-                char *buf = (char*)::malloc(sz);
-                if (buf == nullptr) memory_panic();
+                char *buf = (char *)::malloc(sz);
+                if (buf == nullptr)
+                    memory_panic();
                 std::ptrdiff_t i = 0;
                 for (const auto &pair : files) {
                     memcpy(&buf[i], pair.first.c_str(), pair.first.length() + 1);
@@ -518,23 +549,29 @@ static char *jsonnet_evaluate_snippet_aux(JsonnetVm *vm, const char *filename,
                     buf[i] = '\0';
                     i++;
                 }
-                buf[i] = '\0'; // final sentinel
+                buf[i] = '\0';  // final sentinel
                 *error = false;
                 return buf;
-            }
-            break;
+            } break;
 
             case STREAM: {
-                std::vector<std::string> documents = jsonnet_vm_execute_stream(
-                    &alloc, expr, vm->ext, vm->maxStack, vm->gcMinObjects,
-                    vm->gcGrowthTrigger, vm->nativeCallbacks, vm->importCallback,
-                    vm->importCallbackContext);
-                size_t sz = 1; // final sentinel
+                std::vector<std::string> documents =
+                    jsonnet_vm_execute_stream(&alloc,
+                                              expr,
+                                              vm->ext,
+                                              max_stack,
+                                              vm->gcMinObjects,
+                                              vm->gcGrowthTrigger,
+                                              vm->nativeCallbacks,
+                                              vm->importCallback,
+                                              vm->importCallbackContext);
+                size_t sz = 1;  // final sentinel
                 for (const auto &doc : documents) {
-                    sz += doc.length() + 2; // Add a '\n' as well as sentinel
+                    sz += doc.length() + 2;  // Add a '\n' as well as sentinel
                 }
-                char *buf = (char*)::malloc(sz);
-                if (buf == nullptr) memory_panic();
+                char *buf = (char *)::malloc(sz);
+                if (buf == nullptr)
+                    memory_panic();
                 std::ptrdiff_t i = 0;
                 for (const auto &doc : documents) {
                     memcpy(&buf[i], doc.c_str(), doc.length());
@@ -544,15 +581,14 @@ static char *jsonnet_evaluate_snippet_aux(JsonnetVm *vm, const char *filename,
                     buf[i] = '\0';
                     i++;
                 }
-                buf[i] = '\0'; // final sentinel
+                buf[i] = '\0';  // final sentinel
                 *error = false;
                 return buf;
-            }
-            break;
+            } break;
 
             default:
-            fputs("INTERNAL ERROR: bad value of 'kind', probably memory corruption.\n", stderr);
-            abort();
+                fputs("INTERNAL ERROR: bad value of 'kind', probably memory corruption.\n", stderr);
+                abort();
         }
 
     } catch (StaticError &e) {
@@ -567,7 +603,7 @@ static char *jsonnet_evaluate_snippet_aux(JsonnetVm *vm, const char *filename,
         const long max_above = vm->maxTrace / 2;
         const long max_below = vm->maxTrace - max_above;
         const long sz = e.stackTrace.size();
-        for (long i = 0 ; i < sz ; ++i) {
+        for (long i = 0; i < sz; ++i) {
             const auto &f = e.stackTrace[i];
             if (vm->maxTrace > 0 && i >= max_above && i < sz - max_below) {
                 if (i == max_above)
@@ -583,7 +619,8 @@ static char *jsonnet_evaluate_snippet_aux(JsonnetVm *vm, const char *filename,
     return nullptr;  // Quiet, compiler.
 }
 
-static char *jsonnet_evaluate_file_aux(JsonnetVm *vm, const char *filename, int *error, EvalKind kind)
+static char *jsonnet_evaluate_file_aux(JsonnetVm *vm, const char *filename, int *error,
+                                       EvalKind kind)
 {
     std::ifstream f;
     f.open(filename);
@@ -594,8 +631,7 @@ static char *jsonnet_evaluate_file_aux(JsonnetVm *vm, const char *filename, int
         return from_string(vm, ss.str());
     }
     std::string input;
-    input.assign(std::istreambuf_iterator<char>(f),
-                 std::istreambuf_iterator<char>());
+    input.assign(std::istreambuf_iterator<char>(f), std::istreambuf_iterator<char>());
 
     return jsonnet_evaluate_snippet_aux(vm, filename, input.c_str(), error, kind);
 }
@@ -603,7 +639,7 @@ static char *jsonnet_evaluate_file_aux(JsonnetVm *vm, const char *filename, int
 char *jsonnet_evaluate_file(JsonnetVm *vm, const char *filename, int *error)
 {
     TRY
-    return jsonnet_evaluate_file_aux(vm, filename, error, REGULAR);
+        return jsonnet_evaluate_file_aux(vm, filename, error, REGULAR);
     CATCH("jsonnet_evaluate_file")
     return nullptr;  // Never happens.
 }
@@ -611,7 +647,7 @@ char *jsonnet_evaluate_file(JsonnetVm *vm, const char *filename, int *error)
 char *jsonnet_evaluate_file_multi(JsonnetVm *vm, const char *filename, int *error)
 {
     TRY
-    return jsonnet_evaluate_file_aux(vm, filename, error, MULTI);
+        return jsonnet_evaluate_file_aux(vm, filename, error, MULTI);
     CATCH("jsonnet_evaluate_file_multi")
     return nullptr;  // Never happens.
 }
@@ -619,7 +655,7 @@ char *jsonnet_evaluate_file_multi(JsonnetVm *vm, const char *filename, int *erro
 char *jsonnet_evaluate_file_stream(JsonnetVm *vm, const char *filename, int *error)
 {
     TRY
-    return jsonnet_evaluate_file_aux(vm, filename, error, STREAM);
+        return jsonnet_evaluate_file_aux(vm, filename, error, STREAM);
     CATCH("jsonnet_evaluate_file_stream")
     return nullptr;  // Never happens.
 }
@@ -627,46 +663,48 @@ char *jsonnet_evaluate_file_stream(JsonnetVm *vm, const char *filename, int *err
 char *jsonnet_evaluate_snippet(JsonnetVm *vm, const char *filename, const char *snippet, int *error)
 {
     TRY
-    return jsonnet_evaluate_snippet_aux(vm, filename, snippet, error, REGULAR);
+        return jsonnet_evaluate_snippet_aux(vm, filename, snippet, error, REGULAR);
     CATCH("jsonnet_evaluate_snippet")
     return nullptr;  // Never happens.
 }
 
-char *jsonnet_evaluate_snippet_multi(JsonnetVm *vm, const char *filename,
-                                     const char *snippet, int *error)
+char *jsonnet_evaluate_snippet_multi(JsonnetVm *vm, const char *filename, const char *snippet,
+                                     int *error)
 {
     TRY
-    return jsonnet_evaluate_snippet_aux(vm, filename, snippet, error, MULTI);
+        return jsonnet_evaluate_snippet_aux(vm, filename, snippet, error, MULTI);
     CATCH("jsonnet_evaluate_snippet_multi")
     return nullptr;  // Never happens.
 }
 
-char *jsonnet_evaluate_snippet_stream(JsonnetVm *vm, const char *filename,
-                                     const char *snippet, int *error)
+char *jsonnet_evaluate_snippet_stream(JsonnetVm *vm, const char *filename, const char *snippet,
+                                      int *error)
 {
     TRY
-    return jsonnet_evaluate_snippet_aux(vm, filename, snippet, error, STREAM);
+        return jsonnet_evaluate_snippet_aux(vm, filename, snippet, error, STREAM);
     CATCH("jsonnet_evaluate_snippet_stream")
     return nullptr;  // Never happens.
 }
 
 char *jsonnet_realloc(JsonnetVm *vm, char *str, size_t sz)
 {
-    (void) vm;
+    (void)vm;
     if (str == nullptr) {
-        if (sz == 0) return nullptr;
-        auto *r = static_cast<char*>(::malloc(sz));
-        if (r == nullptr) memory_panic();
+        if (sz == 0)
+            return nullptr;
+        auto *r = static_cast<char *>(::malloc(sz));
+        if (r == nullptr)
+            memory_panic();
         return r;
     } else {
         if (sz == 0) {
             ::free(str);
             return nullptr;
         } else {
-            auto *r = static_cast<char*>(::realloc(str, sz));
-            if (r == nullptr) memory_panic();
+            auto *r = static_cast<char *>(::realloc(str, sz));
+            if (r == nullptr)
+                memory_panic();
             return r;
         }
     }
 }
-
diff --git a/libjsonnet/core/libjsonnet_test.cpp b/libjsonnet/core/libjsonnet_test.cpp
index 051ffd8..1ad9146 100644
--- a/libjsonnet/core/libjsonnet_test.cpp
+++ b/libjsonnet/core/libjsonnet_test.cpp
@@ -15,7 +15,7 @@ limitations under the License.
 */
 
 extern "C" {
-    #include "libjsonnet.h"
+#include "libjsonnet.h"
 }
 
 #include "gtest/gtest.h"
diff --git a/libjsonnet/core/parser.cpp b/libjsonnet/core/parser.cpp
index 0dd7692..0909e44 100644
--- a/libjsonnet/core/parser.cpp
+++ b/libjsonnet/core/parser.cpp
@@ -14,16 +14,15 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-#include <cstdlib>
 #include <cassert>
 #include <cmath>
+#include <cstdlib>
 
+#include <iomanip>
 #include <list>
 #include <set>
 #include <sstream>
 #include <string>
-#include <iomanip>
-
 
 #include "ast.h"
 #include "desugarer.h"
@@ -31,7 +30,6 @@ limitations under the License.
 #include "parser.h"
 #include "static_error.h"
 
-
 std::string jsonnet_unparse_number(double v)
 {
     std::stringstream ss;
@@ -47,13 +45,13 @@ std::string jsonnet_unparse_number(double v)
     return ss.str();
 }
 
-
 namespace {
 
 static bool op_is_unary(const std::string &op, UnaryOp &uop)
 {
     auto it = unary_map.find(op);
-    if (it == unary_map.end()) return false;
+    if (it == unary_map.end())
+        return false;
     uop = it->second;
     return true;
 }
@@ -61,7 +59,8 @@ static bool op_is_unary(const std::string &op, UnaryOp &uop)
 static bool op_is_binary(const std::string &op, BinaryOp &bop)
 {
     auto it = binary_map.find(op);
-    if (it == binary_map.end()) return false;
+    if (it == binary_map.end())
+        return false;
     bop = it->second;
     return true;
 }
@@ -84,7 +83,6 @@ LocationRange span(const Token &begin, AST *end)
 /** Holds state while parsing a given token list.
  */
 class Parser {
-
     // The private member functions are utilities for dealing with the token stream.
 
     StaticError unexpected(const Token &tok, const std::string &while_)
@@ -101,7 +99,8 @@ class Parser {
         return tok;
     }
 
-    void push(Token tok) {
+    void push(Token tok)
+    {
         tokens.push_front(tok);
     }
 
@@ -115,11 +114,11 @@ class Parser {
     Token doublePeek(void)
     {
         Tokens::iterator it = tokens.begin();  // First one.
-        it++; // Now pointing at the second one.
+        it++;                                  // Now pointing at the second one.
         return *(it);
     }
 
-    Token popExpect(Token::Kind k, const char *data=nullptr)
+    Token popExpect(Token::Kind k, const char *data = nullptr)
     {
         Token tok = pop();
         if (tok.kind != k) {
@@ -138,11 +137,8 @@ class Parser {
     std::list<Token> &tokens;
     Allocator *alloc;
 
-    public:
-
-    Parser(Tokens &tokens, Allocator *alloc)
-      : tokens(tokens), alloc(alloc)
-    { }
+   public:
+    Parser(Tokens &tokens, Allocator *alloc) : tokens(tokens), alloc(alloc) {}
 
     /** Parse a comma-separated list of expressions.
      *
@@ -152,8 +148,8 @@ class Parser {
      * \param element_kind Used in error messages when a comma was not found.
      * \returns The last token (the one that matched parameter end).
      */
-    Token parseArgs(ArgParams &args, Token::Kind end,
-                    const std::string &element_kind, bool &got_comma)
+    Token parseArgs(ArgParams &args, Token::Kind end, const std::string &element_kind,
+                    bool &got_comma)
     {
         got_comma = false;
         bool first = true;
@@ -165,7 +161,7 @@ class Parser {
             }
             if (!first && !got_comma) {
                 std::stringstream ss;
-                ss << "Expected a comma before next " << element_kind <<  ".";
+                ss << "Expected a comma before next " << element_kind << ".";
                 throw StaticError(next.location, ss.str());
             }
             // Either id=expr or id or expr, but note that expr could be id==1 so this needs
@@ -205,11 +201,9 @@ class Parser {
         // parseArgs returns f(x) with x as an expression.  Convert it here.
         for (auto &p : params) {
             if (p.id == nullptr) {
-                auto *pv = dynamic_cast<Var*>(p.expr);
+                auto *pv = dynamic_cast<Var *>(p.expr);
                 if (pv == nullptr) {
-                    throw StaticError(p.expr->location,
-                                      "Could not parse parameter here.");
-
+                    throw StaticError(p.expr->location, "Could not parse parameter here.");
                 }
                 p.id = pv->id;
                 p.idFodder = pv->openFodder;
@@ -243,24 +237,30 @@ class Parser {
         Token eq = popExpect(Token::OPERATOR, "=");
         AST *body = parse(MAX_PRECEDENCE);
         Token delim = pop();
-        binds.emplace_back(var_id.fodder, id, eq.fodder, body, is_function, fodder_l, params,
-                           trailing_comma, fodder_r, delim.fodder);
+        binds.emplace_back(var_id.fodder,
+                           id,
+                           eq.fodder,
+                           body,
+                           is_function,
+                           fodder_l,
+                           params,
+                           trailing_comma,
+                           fodder_r,
+                           delim.fodder);
         return delim;
     }
 
-
     Token parseObjectRemainder(AST *&obj, const Token &tok)
     {
         ObjectFields fields;
         std::set<std::string> literal_fields;  // For duplicate fields detection.
-        std::set<const Identifier *> binds;  // For duplicate locals detection.
+        std::set<const Identifier *> binds;    // For duplicate locals detection.
 
         bool got_comma = false;
         bool first = true;
         Token next = pop();
 
         do {
-
             if (next.kind == Token::BRACE_R) {
                 obj = alloc->make<Object>(
                     span(tok, next), tok.fodder, fields, got_comma, next.fodder);
@@ -272,7 +272,8 @@ class Parser {
                 unsigned num_asserts = 0;
                 const ObjectField *field_ptr = nullptr;
                 for (const auto &field : fields) {
-                    if (field.kind == ObjectField::LOCAL) continue;
+                    if (field.kind == ObjectField::LOCAL)
+                        continue;
                     if (field.kind == ObjectField::ASSERT) {
                         num_asserts++;
                         continue;
@@ -315,8 +316,13 @@ class Parser {
             got_comma = false;
 
             switch (next.kind) {
-                case Token::BRACKET_L: case Token::IDENTIFIER: case Token::STRING_DOUBLE:
-                case Token::STRING_SINGLE: case Token::STRING_BLOCK: {
+                case Token::BRACKET_L:
+                case Token::IDENTIFIER:
+                case Token::STRING_DOUBLE:
+                case Token::STRING_SINGLE:
+                case Token::STRING_BLOCK:
+                case Token::VERBATIM_STRING_DOUBLE:
+                case Token::VERBATIM_STRING_SINGLE: {
                     ObjectField::Kind kind;
                     AST *expr1 = nullptr;
                     const Identifier *id = nullptr;
@@ -327,19 +333,44 @@ class Parser {
                         id = alloc->makeIdentifier(next.data32());
                     } else if (next.kind == Token::STRING_DOUBLE) {
                         kind = ObjectField::FIELD_STR;
-                        expr1 = alloc->make<LiteralString>(
-                            next.location, next.fodder, next.data32(), LiteralString::DOUBLE,
-                            "", "");
+                        expr1 = alloc->make<LiteralString>(next.location,
+                                                           next.fodder,
+                                                           next.data32(),
+                                                           LiteralString::DOUBLE,
+                                                           "",
+                                                           "");
                     } else if (next.kind == Token::STRING_SINGLE) {
                         kind = ObjectField::FIELD_STR;
-                        expr1 = alloc->make<LiteralString>(
-                            next.location, next.fodder, next.data32(), LiteralString::SINGLE,
-                            "", "");
+                        expr1 = alloc->make<LiteralString>(next.location,
+                                                           next.fodder,
+                                                           next.data32(),
+                                                           LiteralString::SINGLE,
+                                                           "",
+                                                           "");
                     } else if (next.kind == Token::STRING_BLOCK) {
                         kind = ObjectField::FIELD_STR;
-                        expr1 = alloc->make<LiteralString>(
-                            next.location, next.fodder, next.data32(), LiteralString::BLOCK,
-                            next.stringBlockIndent, next.stringBlockTermIndent);
+                        expr1 = alloc->make<LiteralString>(next.location,
+                                                           next.fodder,
+                                                           next.data32(),
+                                                           LiteralString::BLOCK,
+                                                           next.stringBlockIndent,
+                                                           next.stringBlockTermIndent);
+                    } else if (next.kind == Token::VERBATIM_STRING_SINGLE) {
+                        kind = ObjectField::FIELD_STR;
+                        expr1 = alloc->make<LiteralString>(next.location,
+                                                           next.fodder,
+                                                           next.data32(),
+                                                           LiteralString::VERBATIM_SINGLE,
+                                                           "",
+                                                           "");
+                    } else if (next.kind == Token::VERBATIM_STRING_DOUBLE) {
+                        kind = ObjectField::FIELD_STR;
+                        expr1 = alloc->make<LiteralString>(next.location,
+                                                           next.fodder,
+                                                           next.data32(),
+                                                           LiteralString::VERBATIM_DOUBLE,
+                                                           "",
+                                                           "");
                     } else {
                         kind = ObjectField::FIELD_EXPR;
                         fodder1 = next.fodder;
@@ -369,7 +400,7 @@ class Parser {
                         od++;
                     }
                     unsigned colons = 0;
-                    for (; *od != '\0' ; ++od) {
+                    for (; *od != '\0'; ++od) {
                         if (*od != ':') {
                             throw StaticError(
                                 next.location,
@@ -379,17 +410,11 @@ class Parser {
                     }
                     ObjectField::Hide field_hide;
                     switch (colons) {
-                        case 1:
-                        field_hide = ObjectField::INHERIT;
-                        break;
+                        case 1: field_hide = ObjectField::INHERIT; break;
 
-                        case 2:
-                        field_hide = ObjectField::HIDDEN;
-                        break;
+                        case 2: field_hide = ObjectField::HIDDEN; break;
 
-                        case 3:
-                        field_hide = ObjectField::VISIBLE;
-                        break;
+                        case 3: field_hide = ObjectField::VISIBLE; break;
 
                         default:
                             throw StaticError(
@@ -399,12 +424,12 @@ class Parser {
 
                     // Basic checks for invalid Jsonnet code.
                     if (is_method && plus_sugar) {
-                        throw StaticError(
-                            next.location, "Cannot use +: syntax sugar in a method: " + next.data);
+                        throw StaticError(next.location,
+                                          "Cannot use +: syntax sugar in a method: " + next.data);
                     }
                     if (kind != ObjectField::FIELD_EXPR) {
                         if (!literal_fields.insert(next.data).second) {
-                            throw StaticError(next.location, "Duplicate field: "+next.data);
+                            throw StaticError(next.location, "Duplicate field: " + next.data);
                         }
                     }
 
@@ -417,12 +442,23 @@ class Parser {
                         next = pop();
                         got_comma = true;
                     }
-                    fields.emplace_back(
-                        kind, fodder1, fodder2, fodder_l, fodder_r, field_hide, plus_sugar,
-                        is_method, expr1, id, params, meth_comma, op.fodder, body, nullptr,
-                        comma_fodder);
-                }
-                break;
+                    fields.emplace_back(kind,
+                                        fodder1,
+                                        fodder2,
+                                        fodder_l,
+                                        fodder_r,
+                                        field_hide,
+                                        plus_sugar,
+                                        is_method,
+                                        expr1,
+                                        id,
+                                        params,
+                                        meth_comma,
+                                        op.fodder,
+                                        body,
+                                        nullptr,
+                                        comma_fodder);
+                } break;
 
                 case Token::LOCAL: {
                     Fodder local_fodder = next.fodder;
@@ -454,13 +490,19 @@ class Parser {
                         next = pop();
                         got_comma = true;
                     }
-                    fields.push_back(
-                        ObjectField::Local(
-                            local_fodder, var_id.fodder, paren_l_fodder, paren_r_fodder,
-                            is_method, id, params, func_comma, eq.fodder, body, comma_fodder));
-
-                }
-                break;
+                    fields.push_back(ObjectField::Local(local_fodder,
+                                                        var_id.fodder,
+                                                        paren_l_fodder,
+                                                        paren_r_fodder,
+                                                        is_method,
+                                                        id,
+                                                        params,
+                                                        func_comma,
+                                                        eq.fodder,
+                                                        body,
+                                                        comma_fodder));
+
+                } break;
 
                 case Token::ASSERT: {
                     Fodder assert_fodder = next.fodder;
@@ -480,16 +522,13 @@ class Parser {
                         next = pop();
                         got_comma = true;
                     }
-                    fields.push_back(ObjectField::Assert(assert_fodder, cond, colon_fodder, msg,
-                                     comma_fodder));
-                }
-                break;
+                    fields.push_back(
+                        ObjectField::Assert(assert_fodder, cond, colon_fodder, msg, comma_fodder));
+                } break;
 
-                default:
-                throw unexpected(next, "parsing field definition");
+                default: throw unexpected(next, "parsing field definition");
             }
 
-
         } while (true);
     }
 
@@ -503,14 +542,14 @@ class Parser {
             const Identifier *id = alloc->makeIdentifier(id_token.data32());
             Token in_token = popExpect(Token::IN);
             AST *arr = parse(MAX_PRECEDENCE);
-            specs.emplace_back(ComprehensionSpec::FOR, for_fodder, id_token.fodder, id,
-                               in_token.fodder, arr);
+            specs.emplace_back(
+                ComprehensionSpec::FOR, for_fodder, id_token.fodder, id, in_token.fodder, arr);
 
             Token maybe_if = pop();
             for (; maybe_if.kind == Token::IF; maybe_if = pop()) {
                 AST *cond = parse(MAX_PRECEDENCE);
-                specs.emplace_back(ComprehensionSpec::IF, maybe_if.fodder, Fodder{}, nullptr,
-                                   Fodder{}, cond);
+                specs.emplace_back(
+                    ComprehensionSpec::IF, maybe_if.fodder, Fodder{}, nullptr, Fodder{}, cond);
             }
             if (maybe_if.kind == end) {
                 return maybe_if;
@@ -546,11 +585,9 @@ class Parser {
             case Token::PAREN_R:
             case Token::SEMICOLON:
             case Token::TAILSTRICT:
-            case Token::THEN:
-            throw unexpected(tok, "parsing terminal");
+            case Token::THEN: throw unexpected(tok, "parsing terminal");
 
-            case Token::END_OF_FILE:
-            throw StaticError(tok.location, "Unexpected end of file.");
+            case Token::END_OF_FILE: throw StaticError(tok.location, "Unexpected end of file.");
 
             case Token::BRACE_L: {
                 AST *obj;
@@ -562,8 +599,8 @@ class Parser {
                 Token next = peek();
                 if (next.kind == Token::BRACKET_R) {
                     Token bracket_r = pop();
-                    return alloc->make<Array>(span(tok, next), tok.fodder, Array::Elements{},
-                                              false, bracket_r.fodder);
+                    return alloc->make<Array>(
+                        span(tok, next), tok.fodder, Array::Elements{}, false, bracket_r.fodder);
                 }
                 AST *first = parse(MAX_PRECEDENCE);
                 bool got_comma = false;
@@ -581,9 +618,13 @@ class Parser {
                     Token for_token = pop();
                     std::vector<ComprehensionSpec> specs;
                     Token last = parseComprehensionSpecs(Token::BRACKET_R, for_token.fodder, specs);
-                    return alloc->make<ArrayComprehension>(
-                        span(tok, last), tok.fodder, first, comma_fodder, got_comma, specs,
-                        last.fodder);
+                    return alloc->make<ArrayComprehension>(span(tok, last),
+                                                           tok.fodder,
+                                                           first,
+                                                           comma_fodder,
+                                                           got_comma,
+                                                           specs,
+                                                           last.fodder);
                 }
 
                 // Not a comprehension: It can have more elements.
@@ -621,38 +662,41 @@ class Parser {
             }
 
             // Literals
-            case Token::NUMBER:
-            return alloc->make<LiteralNumber>(span(tok), tok.fodder, tok.data);
+            case Token::NUMBER: return alloc->make<LiteralNumber>(span(tok), tok.fodder, tok.data);
 
             case Token::STRING_SINGLE:
-            return alloc->make<LiteralString>(
-                span(tok), tok.fodder, tok.data32(), LiteralString::SINGLE, "", "");
+                return alloc->make<LiteralString>(
+                    span(tok), tok.fodder, tok.data32(), LiteralString::SINGLE, "", "");
             case Token::STRING_DOUBLE:
-            return alloc->make<LiteralString>(
-                span(tok), tok.fodder, tok.data32(), LiteralString::DOUBLE, "", "");
+                return alloc->make<LiteralString>(
+                    span(tok), tok.fodder, tok.data32(), LiteralString::DOUBLE, "", "");
             case Token::STRING_BLOCK:
-            return alloc->make<LiteralString>(
-                span(tok), tok.fodder, tok.data32(), LiteralString::BLOCK,
-                tok.stringBlockIndent, tok.stringBlockTermIndent);
+                return alloc->make<LiteralString>(span(tok),
+                                                  tok.fodder,
+                                                  tok.data32(),
+                                                  LiteralString::BLOCK,
+                                                  tok.stringBlockIndent,
+                                                  tok.stringBlockTermIndent);
+            case Token::VERBATIM_STRING_SINGLE:
+                return alloc->make<LiteralString>(
+                    span(tok), tok.fodder, tok.data32(), LiteralString::VERBATIM_SINGLE, "", "");
+            case Token::VERBATIM_STRING_DOUBLE:
+                return alloc->make<LiteralString>(
+                    span(tok), tok.fodder, tok.data32(), LiteralString::VERBATIM_DOUBLE, "", "");
 
-            case Token::FALSE:
-            return alloc->make<LiteralBoolean>(span(tok), tok.fodder, false);
+            case Token::FALSE: return alloc->make<LiteralBoolean>(span(tok), tok.fodder, false);
 
-            case Token::TRUE:
-            return alloc->make<LiteralBoolean>(span(tok), tok.fodder, true);
+            case Token::TRUE: return alloc->make<LiteralBoolean>(span(tok), tok.fodder, true);
 
-            case Token::NULL_LIT:
-            return alloc->make<LiteralNull>(span(tok), tok.fodder);
+            case Token::NULL_LIT: return alloc->make<LiteralNull>(span(tok), tok.fodder);
 
             // Variables
-            case Token::DOLLAR:
-            return alloc->make<Dollar>(span(tok), tok.fodder);
+            case Token::DOLLAR: return alloc->make<Dollar>(span(tok), tok.fodder);
 
             case Token::IDENTIFIER:
-            return alloc->make<Var>(span(tok), tok.fodder, alloc->makeIdentifier(tok.data32()));
+                return alloc->make<Var>(span(tok), tok.fodder, alloc->makeIdentifier(tok.data32()));
 
-            case Token::SELF:
-            return alloc->make<Self>(span(tok), tok.fodder);
+            case Token::SELF: return alloc->make<Self>(span(tok), tok.fodder);
 
             case Token::SUPER: {
                 Token next = pop();
@@ -670,11 +714,10 @@ class Parser {
                         Token bracket_r = popExpect(Token::BRACKET_R);
                         id_fodder = bracket_r.fodder;  // Not id_fodder, but use the same var.
                     } break;
-                    default:
-                    throw StaticError(tok.location, "Expected . or [ after super.");
+                    default: throw StaticError(tok.location, "Expected . or [ after super.");
                 }
-                return alloc->make<SuperIndex>(span(tok), tok.fodder, next.fodder, index,
-                                               id_fodder, id);
+                return alloc->make<SuperIndex>(
+                    span(tok), tok.fodder, next.fodder, index, id_fodder, id);
             }
         }
 
@@ -688,7 +731,6 @@ class Parser {
         Token begin = peek();
 
         switch (begin.kind) {
-
             // These cases have effectively MAX_PRECEDENCE as the first
             // call to parse will parse them.
             case Token::ASSERT: {
@@ -703,8 +745,13 @@ class Parser {
                 }
                 Token semicolon = popExpect(Token::SEMICOLON);
                 AST *rest = parse(MAX_PRECEDENCE);
-                return alloc->make<Assert>(span(begin, rest), begin.fodder, cond, colonFodder,
-                                           msg, semicolon.fodder, rest);
+                return alloc->make<Assert>(span(begin, rest),
+                                           begin.fodder,
+                                           cond,
+                                           colonFodder,
+                                           msg,
+                                           semicolon.fodder,
+                                           rest);
             }
 
             case Token::ERROR: {
@@ -721,27 +768,39 @@ class Parser {
                 if (peek().kind == Token::ELSE) {
                     Token else_ = pop();
                     AST *branch_false = parse(MAX_PRECEDENCE);
-                    return alloc->make<Conditional>(
-                        span(begin, branch_false), begin.fodder, cond, then.fodder, branch_true,
-                        else_.fodder, branch_false);
+                    return alloc->make<Conditional>(span(begin, branch_false),
+                                                    begin.fodder,
+                                                    cond,
+                                                    then.fodder,
+                                                    branch_true,
+                                                    else_.fodder,
+                                                    branch_false);
                 }
-                return alloc->make<Conditional>(span(begin, branch_true), begin.fodder, cond,
-                                                then.fodder, branch_true, Fodder{}, nullptr);
+                return alloc->make<Conditional>(span(begin, branch_true),
+                                                begin.fodder,
+                                                cond,
+                                                then.fodder,
+                                                branch_true,
+                                                Fodder{},
+                                                nullptr);
             }
 
             case Token::FUNCTION: {
                 pop();  // Still available in 'begin'.
                 Token paren_l = pop();
                 if (paren_l.kind == Token::PAREN_L) {
-                    std::vector<AST*> params_asts;
+                    std::vector<AST *> params_asts;
                     bool got_comma;
                     Fodder paren_r_fodder;
-                    ArgParams params = parseParams(
-                        "function parameter", got_comma, paren_r_fodder);
+                    ArgParams params = parseParams("function parameter", got_comma, paren_r_fodder);
                     AST *body = parse(MAX_PRECEDENCE);
-                    return alloc->make<Function>(
-                        span(begin, body), begin.fodder, paren_l.fodder, params, got_comma,
-                        paren_r_fodder, body);
+                    return alloc->make<Function>(span(begin, body),
+                                                 begin.fodder,
+                                                 paren_l.fodder,
+                                                 params,
+                                                 got_comma,
+                                                 paren_r_fodder,
+                                                 body);
                 } else {
                     std::stringstream ss;
                     ss << "Expected ( but got " << paren_l;
@@ -752,7 +811,7 @@ class Parser {
             case Token::IMPORT: {
                 pop();
                 AST *body = parse(MAX_PRECEDENCE);
-                if (auto *lit = dynamic_cast<LiteralString*>(body)) {
+                if (auto *lit = dynamic_cast<LiteralString *>(body)) {
                     if (lit->tokenKind == LiteralString::BLOCK) {
                         throw StaticError(lit->location,
                                           "Cannot use text blocks in import statements.");
@@ -768,7 +827,7 @@ class Parser {
             case Token::IMPORTSTR: {
                 pop();
                 AST *body = parse(MAX_PRECEDENCE);
-                if (auto *lit = dynamic_cast<LiteralString*>(body)) {
+                if (auto *lit = dynamic_cast<LiteralString *>(body)) {
                     if (lit->tokenKind == LiteralString::BLOCK) {
                         throw StaticError(lit->location,
                                           "Cannot use text blocks in import statements.");
@@ -791,7 +850,8 @@ class Parser {
                         ss << "Expected , or ; but got " << delim;
                         throw StaticError(delim.location, ss.str());
                     }
-                    if (delim.kind == Token::SEMICOLON) break;
+                    if (delim.kind == Token::SEMICOLON)
+                        break;
                 } while (true);
                 AST *body = parse(MAX_PRECEDENCE);
                 return alloc->make<Local>(span(begin, body), begin.fodder, binds, body);
@@ -799,165 +859,198 @@ class Parser {
 
             default:
 
-            // Unary operator.
-            if (begin.kind == Token::OPERATOR) {
-                UnaryOp uop;
-                if (!op_is_unary(begin.data, uop)) {
-                    std::stringstream ss;
-                    ss << "Not a unary operator: " << begin.data;
-                    throw StaticError(begin.location, ss.str());
-                }
-                if (UNARY_PRECEDENCE == precedence) {
-                    Token op = pop();
-                    AST *expr = parse(precedence);
-                    return alloc->make<Unary>(span(op, expr), op.fodder, uop, expr);
-                }
-            }
-
-            // Base case
-            if (precedence == 0) return parseTerminal();
-
-            AST *lhs = parse(precedence - 1);
-
-            Fodder begin_fodder;
-
-            while (true) {
-
-                // Then next token must be a binary operator.
-
-                // The compiler can't figure out that this is never used uninitialized.
-                BinaryOp bop = BOP_PLUS;
-
-                // Check precedence is correct for this level.  If we're
-                // parsing operators with higher precedence, then return
-                // lhs and let lower levels deal with the operator.
-                switch (peek().kind) {
-                    // Logical / arithmetic binary operator.
-                    case Token::OPERATOR:
-                    if (peek().data == ":") {
-                        // Special case for the colons in assert.
-                        // Since COLON is no-longer a special token, we have to make sure it
-                        // does not trip the op_is_binary test below.  It should
-                        // terminate parsing of the expression here, returning control
-                        // to the parsing of the actual assert AST.
-                        return lhs;
-                    }
-                    if (!op_is_binary(peek().data, bop)) {
+                // Unary operator.
+                if (begin.kind == Token::OPERATOR) {
+                    UnaryOp uop;
+                    if (!op_is_unary(begin.data, uop)) {
                         std::stringstream ss;
-                        ss << "Not a binary operator: " << peek().data;
-                        throw StaticError(peek().location, ss.str());
+                        ss << "Not a unary operator: " << begin.data;
+                        throw StaticError(begin.location, ss.str());
                     }
-                    if (precedence_map[bop] != precedence) return lhs;
-                    break;
-
-                    // Index, Apply
-                    case Token::DOT: case Token::BRACKET_L:
-                    case Token::PAREN_L: case Token::BRACE_L:
-                    if (APPLY_PRECEDENCE != precedence) return lhs;
-                    break;
-
-                    default:
-                    return lhs;
-                }
-
-                Token op = pop();
-                if (op.kind == Token::BRACKET_L) {
-                    bool is_slice;
-                    AST *first = nullptr;
-                    Fodder second_fodder;
-                    AST *second = nullptr;
-                    Fodder third_fodder;
-                    AST *third = nullptr;
-
-                    if (peek().kind == Token::BRACKET_R)
-                        throw unexpected(pop(), "parsing index");
-
-                    // break up "::" into ":", ":" before we start parsing.
-                    if (peek().kind == Token::OPERATOR && peek().data == "::") {
-                        Token joined = pop();
-                        push(Token(Token::OPERATOR, joined.fodder, ":", "", "", joined.location));
-                        push(Token(Token::OPERATOR, Fodder{}, ":", "", "", joined.location));
+                    if (UNARY_PRECEDENCE == precedence) {
+                        Token op = pop();
+                        AST *expr = parse(precedence);
+                        return alloc->make<Unary>(span(op, expr), op.fodder, uop, expr);
                     }
+                }
 
-                    Token first_token = pop();
-                    if (peek().kind == Token::OPERATOR && peek().data == "::") {
-                        Token joined = pop();
-                        push(Token(Token::OPERATOR, joined.fodder, ":", "", "", joined.location));
-                        push(Token(Token::OPERATOR, Fodder{}, ":", "", "", joined.location));
+                // Base case
+                if (precedence == 0)
+                    return parseTerminal();
+
+                AST *lhs = parse(precedence - 1);
+
+                Fodder begin_fodder;
+
+                while (true) {
+                    // Then next token must be a binary operator.
+
+                    // The compiler can't figure out that this is never used uninitialized.
+                    BinaryOp bop = BOP_PLUS;
+
+                    // Check precedence is correct for this level.  If we're
+                    // parsing operators with higher precedence, then return
+                    // lhs and let lower levels deal with the operator.
+                    switch (peek().kind) {
+                        // Logical / arithmetic binary operator.
+                        case Token::IN:
+                        case Token::OPERATOR:
+                            if (peek().data == ":") {
+                                // Special case for the colons in assert.
+                                // Since COLON is no-longer a special token, we have to make sure it
+                                // does not trip the op_is_binary test below.  It should
+                                // terminate parsing of the expression here, returning control
+                                // to the parsing of the actual assert AST.
+                                return lhs;
+                            }
+                            if (peek().data == "::") {
+                                // Special case for [e::]
+                                // We need to stop parsing e when we see the :: and
+                                // avoid tripping the op_is_binary test below.
+                                return lhs;
+                            }
+                            if (!op_is_binary(peek().data, bop)) {
+                                std::stringstream ss;
+                                ss << "Not a binary operator: " << peek().data;
+                                throw StaticError(peek().location, ss.str());
+                            }
+                            if (precedence_map[bop] != precedence)
+                                return lhs;
+                            break;
+
+                        // Index, Apply
+                        case Token::DOT:
+                        case Token::BRACKET_L:
+                        case Token::PAREN_L:
+                        case Token::BRACE_L:
+                            if (APPLY_PRECEDENCE != precedence)
+                                return lhs;
+                            break;
+
+                        default: return lhs;
                     }
-                    push(first_token);
-
-                    if (peek().data != ":")
-                        first = parse(MAX_PRECEDENCE);
 
-                    if (peek().kind != Token::BRACKET_R) {
-                        is_slice = true;
-                        Token delim = pop();
-                        if (delim.data != ":")
-                            throw unexpected(delim, "parsing slice");
+                    Token op = pop();
+                    if (op.kind == Token::BRACKET_L) {
+                        bool is_slice;
+                        AST *first = nullptr;
+                        Fodder second_fodder;
+                        AST *second = nullptr;
+                        Fodder third_fodder;
+                        AST *third = nullptr;
+
+                        if (peek().kind == Token::BRACKET_R)
+                            throw unexpected(pop(), "parsing index");
+
+                        if (peek().data != ":" && peek().data != "::") {
+                            first = parse(MAX_PRECEDENCE);
+                        }
 
-                        second_fodder = delim.fodder;
+                        if (peek().kind == Token::OPERATOR && peek().data == "::") {
+                            // Handle ::
+                            is_slice = true;
+                            Token joined = pop();
+                            second_fodder = joined.fodder;
 
-                        if (peek().data != ":" && peek().kind != Token::BRACKET_R)
-                            second = parse(MAX_PRECEDENCE);
+                            if (peek().kind != Token::BRACKET_R)
+                                third = parse(MAX_PRECEDENCE);
 
-                        if (peek().kind != Token::BRACKET_R) {
+                        } else if (peek().kind != Token::BRACKET_R) {
+                            is_slice = true;
                             Token delim = pop();
                             if (delim.data != ":")
                                 throw unexpected(delim, "parsing slice");
 
-                            third_fodder = delim.fodder;
+                            second_fodder = delim.fodder;
 
-                            if (peek().kind != Token::BRACKET_R)
-                                third= parse(MAX_PRECEDENCE);
+                            if (peek().data != ":" && peek().kind != Token::BRACKET_R)
+                                second = parse(MAX_PRECEDENCE);
+
+                            if (peek().kind != Token::BRACKET_R) {
+                                Token delim = pop();
+                                if (delim.data != ":")
+                                    throw unexpected(delim, "parsing slice");
+
+                                third_fodder = delim.fodder;
+
+                                if (peek().kind != Token::BRACKET_R)
+                                    third = parse(MAX_PRECEDENCE);
+                            }
+                        } else {
+                            is_slice = false;
+                        }
+                        Token end = popExpect(Token::BRACKET_R);
+                        lhs = alloc->make<Index>(span(begin, end),
+                                                 begin_fodder,
+                                                 lhs,
+                                                 op.fodder,
+                                                 is_slice,
+                                                 first,
+                                                 second_fodder,
+                                                 second,
+                                                 third_fodder,
+                                                 third,
+                                                 end.fodder);
+
+                    } else if (op.kind == Token::DOT) {
+                        Token field_id = popExpect(Token::IDENTIFIER);
+                        const Identifier *id = alloc->makeIdentifier(field_id.data32());
+                        lhs = alloc->make<Index>(span(begin, field_id),
+                                                 begin_fodder,
+                                                 lhs,
+                                                 op.fodder,
+                                                 field_id.fodder,
+                                                 id);
+
+                    } else if (op.kind == Token::PAREN_L) {
+                        ArgParams args;
+                        bool got_comma;
+                        Token end = parseArgs(args, Token::PAREN_R, "function argument", got_comma);
+                        bool tailstrict = false;
+                        Fodder tailstrict_fodder;
+                        if (peek().kind == Token::TAILSTRICT) {
+                            Token tailstrict_token = pop();
+                            tailstrict_fodder = tailstrict_token.fodder;
+                            tailstrict = true;
+                        }
+                        lhs = alloc->make<Apply>(span(begin, end),
+                                                 begin_fodder,
+                                                 lhs,
+                                                 op.fodder,
+                                                 args,
+                                                 got_comma,
+                                                 end.fodder,
+                                                 tailstrict_fodder,
+                                                 tailstrict);
+
+                    } else if (op.kind == Token::BRACE_L) {
+                        AST *obj;
+                        Token end = parseObjectRemainder(obj, op);
+                        lhs = alloc->make<ApplyBrace>(span(begin, end), begin_fodder, lhs, obj);
+
+                    } else if (op.kind == Token::IN) {
+                        if (peek().kind == Token::SUPER) {
+                            Token super = pop();
+                            lhs = alloc->make<InSuper>(
+                                span(begin, super), begin_fodder, lhs, op.fodder, super.fodder);
+                        } else {
+                            AST *rhs = parse(precedence - 1);
+                            lhs = alloc->make<Binary>(
+                                span(begin, rhs), begin_fodder, lhs, op.fodder, bop, rhs);
                         }
+
                     } else {
-                        is_slice = false;
-                    }
-                    Token end = popExpect(Token::BRACKET_R);
-                    lhs = alloc->make<Index>(span(begin, end), begin_fodder, lhs, op.fodder,
-                                             is_slice, first, second_fodder, second,
-                                             third_fodder, third, end.fodder);
-
-                } else if (op.kind == Token::DOT) {
-                    Token field_id = popExpect(Token::IDENTIFIER);
-                    const Identifier *id = alloc->makeIdentifier(field_id.data32());
-                    lhs = alloc->make<Index>(span(begin, field_id), begin_fodder, lhs,
-                                             op.fodder, field_id.fodder, id);
-
-                } else if (op.kind == Token::PAREN_L) {
-                    ArgParams args;
-                    bool got_comma;
-                    Token end = parseArgs(args, Token::PAREN_R, "function argument", got_comma);
-                    bool tailstrict = false;
-                    Fodder tailstrict_fodder;
-                    if (peek().kind == Token::TAILSTRICT) {
-                        Token tailstrict_token = pop();
-                        tailstrict_fodder = tailstrict_token.fodder;
-                        tailstrict = true;
+                        // Logical / arithmetic binary operator.
+                        assert(op.kind == Token::OPERATOR);
+                        AST *rhs = parse(precedence - 1);
+                        lhs = alloc->make<Binary>(
+                            span(begin, rhs), begin_fodder, lhs, op.fodder, bop, rhs);
                     }
-                    lhs = alloc->make<Apply>(span(begin, end), begin_fodder, lhs, op.fodder,
-                                             args, got_comma, end.fodder, tailstrict_fodder,
-                                             tailstrict);
-
-                } else if (op.kind == Token::BRACE_L) {
-                    AST *obj;
-                    Token end = parseObjectRemainder(obj, op);
-                    lhs = alloc->make<ApplyBrace>(span(begin, end), begin_fodder, lhs, obj);
 
-                } else {
-                    // Logical / arithmetic binary operator.
-                    assert(op.kind == Token::OPERATOR);
-                    AST *rhs = parse(precedence - 1);
-                    lhs = alloc->make<Binary>(span(begin, rhs), begin_fodder, lhs, op.fodder,
-                                              bop, rhs);
+                    begin_fodder.clear();
                 }
-
-                begin_fodder.clear();
-            }
         }
     }
-
 };
 
 }  // namespace
diff --git a/libjsonnet/core/parser_test.cpp b/libjsonnet/core/parser_test.cpp
index 9d8a6cc..da51585 100644
--- a/libjsonnet/core/parser_test.cpp
+++ b/libjsonnet/core/parser_test.cpp
@@ -18,8 +18,8 @@ limitations under the License.
 
 #include <list>
 #include "ast.h"
-#include "lexer.h"
 #include "gtest/gtest.h"
+#include "lexer.h"
 
 namespace {
 
@@ -33,10 +33,9 @@ void testParse(const char* snippet)
         AST* ast = jsonnet_parse(&allocator, tokens);
         (void)ast;
     } catch (StaticError& e) {
-        ASSERT_TRUE(false)
-            << "Static error: " << e.toString() << std::endl
-            << "Snippet:" << std::endl
-            << snippet << std::endl;
+        ASSERT_TRUE(false) << "Static error: " << e.toString() << std::endl
+                           << "Snippet:" << std::endl
+                           << snippet << std::endl;
     }
 }
 
@@ -132,99 +131,67 @@ void testParseError(const char* snippet, const std::string& expectedError)
         AST* ast = jsonnet_parse(&allocator, tokens);
         (void)ast;
     } catch (StaticError& e) {
-        ASSERT_EQ(expectedError, e.toString())
-            << "Snippet:" << std::endl
-            << snippet << std::endl;
-      }
+        ASSERT_EQ(expectedError, e.toString()) << "Snippet:" << std::endl << snippet << std::endl;
+    }
 }
 
 TEST(Parser, TestInvalidFunctionCall)
 {
-    testParseError(
-        "function(a, b c)",
-        "test:1:15: Expected a comma before next function parameter.");
-    testParseError(
-        "function(a, 1)",
-        "test:1:13: Expected an identifier but got a complex expression.");
+    testParseError("function(a, b c)",
+                   "test:1:15: Expected a comma before next function parameter.");
+    testParseError("function(a, 1)", "test:1:13: Could not parse parameter here.");
     testParseError("a b", R"(test:1:3: Did not expect: (IDENTIFIER, "b"))");
-    testParseError(
-        "foo(a, bar(a b))",
-        "test:1:14: Expected a comma before next function argument.");
+    testParseError("foo(a, bar(a b))",
+                   "test:1:14: Expected a comma before next function argument.");
 }
 
 TEST(Parser, TestInvalidLocal)
 {
     testParseError("local", "test:1:6: Expected token IDENTIFIER but got end of file");
-    testParseError(
-        "local foo = 1, foo = 2; true",
-        "test:1:16-18: Duplicate local var: foo");
-    testParseError(
-        "local foo(a b) = a; true",
-        "test:1:13: Expected a comma before next function parameter.");
-    testParseError(
-        "local foo(a): a; true",
-        "test:1:13: Expected operator = but got :");
-    testParseError(
-        "local foo(a) = bar(a b); true",
-        "test:1:22: Expected a comma before next function argument.");
-    testParseError(
-        "local foo: 1; true",
-        "test:1:10: Expected operator = but got :");
-    testParseError(
-        "local foo = bar(a b); true",
-        "test:1:19: Expected a comma before next function argument.");
-
-    testParseError(
-        "local a = b ()",
-        "test:1:15: Expected , or ; but got end of file");
-    testParseError(
-        "local a = b; (a b)",
-        R"_(test:1:17: Expected token ")" but got (IDENTIFIER, "b"))_");
+    testParseError("local foo = 1, foo = 2; true", "test:1:16-18: Duplicate local var: foo");
+    testParseError("local foo(a b) = a; true",
+                   "test:1:13: Expected a comma before next function parameter.");
+    testParseError("local foo(a): a; true", "test:1:13: Expected operator = but got :");
+    testParseError("local foo(a) = bar(a b); true",
+                   "test:1:22: Expected a comma before next function argument.");
+    testParseError("local foo: 1; true", "test:1:10: Expected operator = but got :");
+    testParseError("local foo = bar(a b); true",
+                   "test:1:19: Expected a comma before next function argument.");
+
+    testParseError("local a = b ()", "test:1:15: Expected , or ; but got end of file");
+    testParseError("local a = b; (a b)",
+                   R"_(test:1:17: Expected token ")" but got (IDENTIFIER, "b"))_");
 }
 
 TEST(Parser, TestInvalidTuple)
 {
-    testParseError(
-        "{a b}",
-        R"(test:1:4: Expected token OPERATOR but got (IDENTIFIER, "b"))");
-    testParseError(
-        "{a = b}",
-        "test:1:2: Expected one of :, ::, :::, +:, +::, +:::, got: =");
-    testParseError(
-        "{a :::: b}",
-        "test:1:2: Expected one of :, ::, :::, +:, +::, +:::, got: ::::");
+    testParseError("{a b}",
+                   R"(test:1:4: Expected token OPERATOR but got (IDENTIFIER, "b"))");
+    testParseError("{a = b}", "test:1:2: Expected one of :, ::, :::, +:, +::, +:::, got: =");
+    testParseError("{a :::: b}", "test:1:2: Expected one of :, ::, :::, +:, +::, +:::, got: ::::");
 }
 
 TEST(Parser, TestInvalidComprehension)
 {
-    testParseError(
-        "{assert x for x in [1, 2, 3]}",
-        "test:1:11-13: Object comprehension cannot have asserts.");
-    testParseError(
-        "{['foo' + x]: true, [x]: x for x in [1, 2, 3]}",
-        "test:1:28-30: Object comprehension can only have one field.");
-    testParseError(
-        "{foo: x for x in [1, 2, 3]}",
-        "test:1:9-11: Object comprehensions can only have [e] fields.");
-    testParseError(
-        "{[x]:: true for x in [1, 2, 3]}",
-        "test:1:13-15: Object comprehensions cannot have hidden fields.");
-    testParseError(
-        "{[x]: true for 1 in [1, 2, 3]}",
-        R"(test:1:16: Expected token IDENTIFIER but got (NUMBER, "1"))");
-    testParseError(
-        "{[x]: true for x at [1, 2, 3]}",
-        R"(test:1:18-19: Expected token in but got (IDENTIFIER, "at"))");
-    testParseError(
-        "{[x]: true for x in [1, 2 3]}",
-        "test:1:27: Expected a comma before next array element.");
-    testParseError(
-        "{[x]: true for x in [1, 2, 3] if (a b)}",
-        R"_(test:1:37: Expected token ")" but got (IDENTIFIER, "b"))_");
-    testParseError(
-        "{[x]: true for x in [1, 2, 3] if a b}",
-        R"(test:1:36: Expected for, if or "}" after for clause,)"
-        R"( got: (IDENTIFIER, "b"))");
+    testParseError("{assert x for x in [1, 2, 3]}",
+                   "test:1:11-13: Object comprehension cannot have asserts.");
+    testParseError("{['foo' + x]: true, [x]: x for x in [1, 2, 3]}",
+                   "test:1:28-30: Object comprehension can only have one field.");
+    testParseError("{foo: x for x in [1, 2, 3]}",
+                   "test:1:9-11: Object comprehensions can only have [e] fields.");
+    testParseError("{[x]:: true for x in [1, 2, 3]}",
+                   "test:1:13-15: Object comprehensions cannot have hidden fields.");
+    testParseError("{[x]: true for 1 in [1, 2, 3]}",
+                   R"(test:1:16: Expected token IDENTIFIER but got (NUMBER, "1"))");
+    testParseError("{[x]: true for x at [1, 2, 3]}",
+                   R"(test:1:18-19: Expected token in but got (IDENTIFIER, "at"))");
+    testParseError("{[x]: true for x in [1, 2 3]}",
+                   "test:1:27: Expected a comma before next array element.");
+    testParseError("{[x]: true for x in [1, 2, 3] if (a b)}",
+                   R"_(test:1:37: Expected token ")" but got (IDENTIFIER, "b"))_");
+    testParseError("{[x]: true for x in [1, 2, 3] if a b}",
+                   R"(test:1:36: Expected for, if or "}" after for clause,)"
+                   R"( got: (IDENTIFIER, "b"))");
 }
 
 TEST(Parser, TestInvalidNoComma)
@@ -248,31 +215,23 @@ TEST(Parser, TestInvalidFields)
 
 TEST(Parser, TestInvalidLocalInTuple)
 {
-    testParseError(
-        "{local 1 = 3, true}",
-        R"(test:1:8: Expected token IDENTIFIER but got (NUMBER, "1"))");
-    testParseError(
-        "{local foo = 1, local foo = 2, true}",
-        "test:1:23-25: Duplicate local var: foo");
-    testParseError(
-        "{local foo(a b) = 1, a: true}",
-        "test:1:14: Expected a comma before next function parameter.");
-    testParseError(
-        "{local foo(a): 1, a: true}",
-        "test:1:14: Expected operator = but got :");
-    testParseError(
-        "{local foo(a) = (a b), a: true}",
-        R"_(test:1:20: Expected token ")" but got (IDENTIFIER, "b"))_");
+    testParseError("{local 1 = 3, true}",
+                   R"(test:1:8: Expected token IDENTIFIER but got (NUMBER, "1"))");
+    testParseError("{local foo = 1, local foo = 2, true}",
+                   "test:1:23-25: Duplicate local var: foo");
+    testParseError("{local foo(a b) = 1, a: true}",
+                   "test:1:14: Expected a comma before next function parameter.");
+    testParseError("{local foo(a): 1, a: true}", "test:1:14: Expected operator = but got :");
+    testParseError("{local foo(a) = (a b), a: true}",
+                   R"_(test:1:20: Expected token ")" but got (IDENTIFIER, "b"))_");
 }
 
 TEST(Parser, TestInvalidAssertInTuple)
 {
-    testParseError(
-        "{assert (a b), a: true}",
-        R"_(test:1:12: Expected token ")" but got (IDENTIFIER, "b"))_");
-    testParseError(
-        "{assert a: (a b), a: true}",
-        R"_(test:1:15: Expected token ")" but got (IDENTIFIER, "b"))_");
+    testParseError("{assert (a b), a: true}",
+                   R"_(test:1:12: Expected token ")" but got (IDENTIFIER, "b"))_");
+    testParseError("{assert a: (a b), a: true}",
+                   R"_(test:1:15: Expected token ")" but got (IDENTIFIER, "b"))_");
 }
 
 TEST(Parser, TestInvalidUnexpectedFunction)
@@ -281,22 +240,18 @@ TEST(Parser, TestInvalidUnexpectedFunction)
     // implementation, which is:
     // test:1:2-10 Unexpected: (function, "function") while parsing field
     // definition.
-    testParseError(
-        "{function(a, b) a+b: true}",
-        "test:1:2-9: Unexpected: function while parsing field definition");
+    testParseError("{function(a, b) a+b: true}",
+                   "test:1:2-9: Unexpected: function while parsing field definition");
 }
 
 TEST(Parser, TestInvalidArray)
 {
-    testParseError(
-        "[(a b), 2, 3]",
-        R"_(test:1:5: Expected token ")" but got (IDENTIFIER, "b"))_");
-    testParseError(
-        "[1, (a b), 2, 3]",
-        R"_(test:1:8: Expected token ")" but got (IDENTIFIER, "b"))_");
-    testParseError(
-        "[a for b in [1 2 3]]",
-        "test:1:16: Expected a comma before next array element.");
+    testParseError("[(a b), 2, 3]",
+                   R"_(test:1:5: Expected token ")" but got (IDENTIFIER, "b"))_");
+    testParseError("[1, (a b), 2, 3]",
+                   R"_(test:1:8: Expected token ")" but got (IDENTIFIER, "b"))_");
+    testParseError("[a for b in [1 2 3]]",
+                   "test:1:16: Expected a comma before next array element.");
 }
 
 TEST(Parser, TestInvalidExpression)
@@ -316,21 +271,17 @@ TEST(Parser, TestInvalidExpression)
 
 TEST(Parser, TestInvalidAssert)
 {
-    testParseError(
-        "assert (a b); true",
-        R"_(test:1:11: Expected token ")" but got (IDENTIFIER, "b"))_");
-    testParseError(
-        "assert a: (a b); true",
-        R"_(test:1:14: Expected token ")" but got (IDENTIFIER, "b"))_");
+    testParseError("assert (a b); true",
+                   R"_(test:1:11: Expected token ")" but got (IDENTIFIER, "b"))_");
+    testParseError("assert a: (a b); true",
+                   R"_(test:1:14: Expected token ")" but got (IDENTIFIER, "b"))_");
     // TODO(jsonnet-team): The error output of this differs from the Go
     // implementation, which is:
     // test:1:16: Expected token ";" but got (",", ",")
-    testParseError(
-        "assert a: 'foo', true",
-        R"(test:1:16: Expected token ";" but got ",")");
-    testParseError(
-        "assert a: 'foo'; (a b)",
-        R"_(test:1:21: Expected token ")" but got (IDENTIFIER, "b"))_");
+    testParseError("assert a: 'foo', true",
+                   R"(test:1:16: Expected token ";" but got ",")");
+    testParseError("assert a: 'foo'; (a b)",
+                   R"_(test:1:21: Expected token ")" but got (IDENTIFIER, "b"))_");
 }
 
 TEST(Parser, TestInvalidError)
@@ -340,25 +291,20 @@ TEST(Parser, TestInvalidError)
 
 TEST(Parser, TestInvalidIf)
 {
-    testParseError(
-        "if (a b) then c",
-        R"_(test:1:7: Expected token ")" but got (IDENTIFIER, "b"))_");
-    testParseError(
-        "if a b c",
-        R"(test:1:6: Expected token then but got (IDENTIFIER, "b"))");
-    testParseError(
-        "if a then (b c)",
-        R"_(test:1:14: Expected token ")" but got (IDENTIFIER, "c"))_");
-    testParseError(
-        "if a then b else (c d)",
-        R"_(test:1:21: Expected token ")" but got (IDENTIFIER, "d"))_");
+    testParseError("if (a b) then c",
+                   R"_(test:1:7: Expected token ")" but got (IDENTIFIER, "b"))_");
+    testParseError("if a b c",
+                   R"(test:1:6: Expected token then but got (IDENTIFIER, "b"))");
+    testParseError("if a then (b c)",
+                   R"_(test:1:14: Expected token ")" but got (IDENTIFIER, "c"))_");
+    testParseError("if a then b else (c d)",
+                   R"_(test:1:21: Expected token ")" but got (IDENTIFIER, "d"))_");
 }
 
 TEST(Parser, TestInvalidFunction)
 {
-    testParseError(
-        "function(a) (a b)",
-        R"_(test:1:16: Expected token ")" but got (IDENTIFIER, "b"))_");
+    testParseError("function(a) (a b)",
+                   R"_(test:1:16: Expected token ")" but got (IDENTIFIER, "b"))_");
     testParseError("function a a", R"(test:1:10: Expected ( but got (IDENTIFIER, "a"))");
 }
 
@@ -366,12 +312,9 @@ TEST(Parser, TestInvalidImport)
 {
     testParseError("import (a b)", R"_(test:1:11: Expected token ")" but got (IDENTIFIER, "b"))_");
     testParseError("import (a+b)", "test:1:8-12: Computed imports are not allowed.");
-    testParseError(
-        "importstr (a b)",
-        R"_(test:1:14: Expected token ")" but got (IDENTIFIER, "b"))_");
-    testParseError(
-        "importstr (a+b)",
-        "test:1:11-15: Computed imports are not allowed.");
+    testParseError("importstr (a b)",
+                   R"_(test:1:14: Expected token ")" but got (IDENTIFIER, "b"))_");
+    testParseError("importstr (a+b)", "test:1:11-15: Computed imports are not allowed.");
 }
 
 TEST(Parser, TestInvalidOperator)
@@ -392,7 +335,7 @@ TEST(Parser, TestInvalidArrayAccess)
 
 TEST(Parser, TestInvalidOverride)
 {
-    testParseError( "a{b c}", R"(test:1:5: Expected token OPERATOR but got (IDENTIFIER, "c"))");
+    testParseError("a{b c}", R"(test:1:5: Expected token OPERATOR but got (IDENTIFIER, "c"))");
 }
 
 }  // namespace
diff --git a/libjsonnet/core/pass.cpp b/libjsonnet/core/pass.cpp
new file mode 100644
index 0000000..656f7e5
--- /dev/null
+++ b/libjsonnet/core/pass.cpp
@@ -0,0 +1,439 @@
+/*
+Copyright 2015 Google Inc. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+#include "pass.h"
+
+void CompilerPass::fodder(Fodder &fodder)
+{
+    for (auto &f : fodder)
+        fodderElement(f);
+}
+
+void CompilerPass::specs(std::vector<ComprehensionSpec> &specs)
+{
+    for (auto &spec : specs) {
+        fodder(spec.openFodder);
+        switch (spec.kind) {
+            case ComprehensionSpec::FOR:
+                fodder(spec.varFodder);
+                fodder(spec.inFodder);
+                expr(spec.expr);
+                break;
+            case ComprehensionSpec::IF: expr(spec.expr); break;
+        }
+    }
+}
+
+void CompilerPass::params(Fodder &fodder_l, ArgParams &params, Fodder &fodder_r)
+{
+    fodder(fodder_l);
+    for (auto &param : params) {
+        fodder(param.idFodder);
+        if (param.expr) {
+            fodder(param.eqFodder);
+            expr(param.expr);
+        }
+        fodder(param.commaFodder);
+    }
+    fodder(fodder_r);
+}
+
+void CompilerPass::fieldParams(ObjectField &field)
+{
+    if (field.methodSugar) {
+        params(field.fodderL, field.params, field.fodderR);
+    }
+}
+
+void CompilerPass::fields(ObjectFields &fields)
+{
+    for (auto &field : fields) {
+        switch (field.kind) {
+            case ObjectField::LOCAL: {
+                fodder(field.fodder1);
+                fodder(field.fodder2);
+                fieldParams(field);
+                fodder(field.opFodder);
+                expr(field.expr2);
+            } break;
+
+            case ObjectField::FIELD_ID:
+            case ObjectField::FIELD_STR:
+            case ObjectField::FIELD_EXPR: {
+                if (field.kind == ObjectField::FIELD_ID) {
+                    fodder(field.fodder1);
+
+                } else if (field.kind == ObjectField::FIELD_STR) {
+                    expr(field.expr1);
+
+                } else if (field.kind == ObjectField::FIELD_EXPR) {
+                    fodder(field.fodder1);
+                    expr(field.expr1);
+                    fodder(field.fodder2);
+                }
+                fieldParams(field);
+                fodder(field.opFodder);
+                expr(field.expr2);
+
+            } break;
+
+            case ObjectField::ASSERT: {
+                fodder(field.fodder1);
+                expr(field.expr2);
+                if (field.expr3 != nullptr) {
+                    fodder(field.opFodder);
+                    expr(field.expr3);
+                }
+            } break;
+        }
+
+        fodder(field.commaFodder);
+    }
+}
+
+void CompilerPass::expr(AST *&ast_)
+{
+    fodder(ast_->openFodder);
+    visitExpr(ast_);
+}
+
+void CompilerPass::visit(Apply *ast)
+{
+    expr(ast->target);
+    params(ast->fodderL, ast->args, ast->fodderR);
+    if (ast->tailstrict) {
+        fodder(ast->tailstrictFodder);
+    }
+}
+
+void CompilerPass::visit(ApplyBrace *ast)
+{
+    expr(ast->left);
+    expr(ast->right);
+}
+
+void CompilerPass::visit(Array *ast)
+{
+    for (auto &element : ast->elements) {
+        expr(element.expr);
+        fodder(element.commaFodder);
+    }
+    fodder(ast->closeFodder);
+}
+
+void CompilerPass::visit(ArrayComprehension *ast)
+{
+    expr(ast->body);
+    fodder(ast->commaFodder);
+    specs(ast->specs);
+    fodder(ast->closeFodder);
+}
+
+void CompilerPass::visit(Assert *ast)
+{
+    expr(ast->cond);
+    if (ast->message != nullptr) {
+        fodder(ast->colonFodder);
+        expr(ast->message);
+    }
+    fodder(ast->semicolonFodder);
+    expr(ast->rest);
+}
+
+void CompilerPass::visit(Binary *ast)
+{
+    expr(ast->left);
+    fodder(ast->opFodder);
+    expr(ast->right);
+}
+
+void CompilerPass::visit(Conditional *ast)
+{
+    expr(ast->cond);
+    fodder(ast->thenFodder);
+    if (ast->branchFalse != nullptr) {
+        expr(ast->branchTrue);
+        fodder(ast->elseFodder);
+        expr(ast->branchFalse);
+    } else {
+        expr(ast->branchTrue);
+    }
+}
+
+void CompilerPass::visit(Error *ast)
+{
+    expr(ast->expr);
+}
+
+void CompilerPass::visit(Function *ast)
+{
+    params(ast->parenLeftFodder, ast->params, ast->parenRightFodder);
+    expr(ast->body);
+}
+
+void CompilerPass::visit(Import *ast)
+{
+    visit(ast->file);
+}
+
+void CompilerPass::visit(Importstr *ast)
+{
+    visit(ast->file);
+}
+
+void CompilerPass::visit(InSuper *ast)
+{
+    expr(ast->element);
+}
+
+void CompilerPass::visit(Index *ast)
+{
+    expr(ast->target);
+    if (ast->id != nullptr) {
+    } else {
+        if (ast->isSlice) {
+            if (ast->index != nullptr)
+                expr(ast->index);
+            if (ast->end != nullptr)
+                expr(ast->end);
+            if (ast->step != nullptr)
+                expr(ast->step);
+        } else {
+            expr(ast->index);
+        }
+    }
+}
+
+void CompilerPass::visit(Local *ast)
+{
+    assert(ast->binds.size() > 0);
+    for (auto &bind : ast->binds) {
+        fodder(bind.varFodder);
+        if (bind.functionSugar) {
+            params(bind.parenLeftFodder, bind.params, bind.parenRightFodder);
+        }
+        fodder(bind.opFodder);
+        expr(bind.body);
+        fodder(bind.closeFodder);
+    }
+    expr(ast->body);
+}
+
+void CompilerPass::visit(Object *ast)
+{
+    fields(ast->fields);
+    fodder(ast->closeFodder);
+}
+
+void CompilerPass::visit(DesugaredObject *ast)
+{
+    for (AST *assert : ast->asserts) {
+        expr(assert);
+    }
+    for (auto &field : ast->fields) {
+        expr(field.name);
+        expr(field.body);
+    }
+}
+
+void CompilerPass::visit(ObjectComprehension *ast)
+{
+    fields(ast->fields);
+    specs(ast->specs);
+    fodder(ast->closeFodder);
+}
+
+void CompilerPass::visit(ObjectComprehensionSimple *ast)
+{
+    expr(ast->field);
+    expr(ast->value);
+    expr(ast->array);
+}
+
+void CompilerPass::visit(Parens *ast)
+{
+    expr(ast->expr);
+    fodder(ast->closeFodder);
+}
+
+void CompilerPass::visit(SuperIndex *ast)
+{
+    if (ast->id != nullptr) {
+    } else {
+        expr(ast->index);
+    }
+}
+
+void CompilerPass::visit(Unary *ast)
+{
+    expr(ast->expr);
+}
+
+void CompilerPass::visitExpr(AST *&ast_)
+{
+    if (auto *ast = dynamic_cast<Apply *>(ast_)) {
+        visit(ast);
+    } else if (auto *ast = dynamic_cast<ApplyBrace *>(ast_)) {
+        visit(ast);
+    } else if (auto *ast = dynamic_cast<Array *>(ast_)) {
+        visit(ast);
+    } else if (auto *ast = dynamic_cast<ArrayComprehension *>(ast_)) {
+        visit(ast);
+    } else if (auto *ast = dynamic_cast<Assert *>(ast_)) {
+        visit(ast);
+    } else if (auto *ast = dynamic_cast<Binary *>(ast_)) {
+        visit(ast);
+    } else if (auto *ast = dynamic_cast<BuiltinFunction *>(ast_)) {
+        visit(ast);
+    } else if (auto *ast = dynamic_cast<Conditional *>(ast_)) {
+        visit(ast);
+    } else if (auto *ast = dynamic_cast<Dollar *>(ast_)) {
+        visit(ast);
+    } else if (auto *ast = dynamic_cast<Error *>(ast_)) {
+        visit(ast);
+    } else if (auto *ast = dynamic_cast<Function *>(ast_)) {
+        visit(ast);
+    } else if (auto *ast = dynamic_cast<Import *>(ast_)) {
+        visit(ast);
+    } else if (auto *ast = dynamic_cast<Importstr *>(ast_)) {
+        visit(ast);
+    } else if (auto *ast = dynamic_cast<InSuper *>(ast_)) {
+        visit(ast);
+    } else if (auto *ast = dynamic_cast<Index *>(ast_)) {
+        visit(ast);
+    } else if (auto *ast = dynamic_cast<Local *>(ast_)) {
+        visit(ast);
+    } else if (auto *ast = dynamic_cast<LiteralBoolean *>(ast_)) {
+        visit(ast);
+    } else if (auto *ast = dynamic_cast<LiteralNumber *>(ast_)) {
+        visit(ast);
+    } else if (auto *ast = dynamic_cast<LiteralString *>(ast_)) {
+        visit(ast);
+    } else if (auto *ast = dynamic_cast<LiteralNull *>(ast_)) {
+        visit(ast);
+    } else if (auto *ast = dynamic_cast<Object *>(ast_)) {
+        visit(ast);
+    } else if (auto *ast = dynamic_cast<DesugaredObject *>(ast_)) {
+        visit(ast);
+    } else if (auto *ast = dynamic_cast<ObjectComprehension *>(ast_)) {
+        visit(ast);
+    } else if (auto *ast = dynamic_cast<ObjectComprehensionSimple *>(ast_)) {
+        visit(ast);
+    } else if (auto *ast = dynamic_cast<Parens *>(ast_)) {
+        visit(ast);
+    } else if (auto *ast = dynamic_cast<Self *>(ast_)) {
+        visit(ast);
+    } else if (auto *ast = dynamic_cast<SuperIndex *>(ast_)) {
+        visit(ast);
+    } else if (auto *ast = dynamic_cast<Unary *>(ast_)) {
+        visit(ast);
+    } else if (auto *ast = dynamic_cast<Var *>(ast_)) {
+        visit(ast);
+
+    } else {
+        std::cerr << "INTERNAL ERROR: Unknown AST: " << ast_ << std::endl;
+        std::abort();
+    }
+}
+
+void CompilerPass::file(AST *&body, Fodder &final_fodder)
+{
+    expr(body);
+    fodder(final_fodder);
+}
+
+/** A pass that clones the AST it is given. */
+class ClonePass : public CompilerPass {
+   public:
+    ClonePass(Allocator &alloc) : CompilerPass(alloc) {}
+    virtual void expr(AST *&ast);
+};
+
+void ClonePass::expr(AST *&ast_)
+{
+    if (auto *ast = dynamic_cast<Apply *>(ast_)) {
+        ast_ = alloc.clone(ast);
+    } else if (auto *ast = dynamic_cast<ApplyBrace *>(ast_)) {
+        ast_ = alloc.clone(ast);
+    } else if (auto *ast = dynamic_cast<Array *>(ast_)) {
+        ast_ = alloc.clone(ast);
+    } else if (auto *ast = dynamic_cast<ArrayComprehension *>(ast_)) {
+        ast_ = alloc.clone(ast);
+    } else if (auto *ast = dynamic_cast<Assert *>(ast_)) {
+        ast_ = alloc.clone(ast);
+    } else if (auto *ast = dynamic_cast<Binary *>(ast_)) {
+        ast_ = alloc.clone(ast);
+    } else if (auto *ast = dynamic_cast<BuiltinFunction *>(ast_)) {
+        ast_ = alloc.clone(ast);
+    } else if (auto *ast = dynamic_cast<Conditional *>(ast_)) {
+        ast_ = alloc.clone(ast);
+    } else if (auto *ast = dynamic_cast<Dollar *>(ast_)) {
+        ast_ = alloc.clone(ast);
+    } else if (auto *ast = dynamic_cast<Error *>(ast_)) {
+        ast_ = alloc.clone(ast);
+    } else if (auto *ast = dynamic_cast<Function *>(ast_)) {
+        ast_ = alloc.clone(ast);
+    } else if (auto *ast = dynamic_cast<Import *>(ast_)) {
+        ast_ = alloc.clone(ast);
+    } else if (auto *ast = dynamic_cast<Importstr *>(ast_)) {
+        ast_ = alloc.clone(ast);
+    } else if (auto *ast = dynamic_cast<InSuper *>(ast_)) {
+        ast_ = alloc.clone(ast);
+    } else if (auto *ast = dynamic_cast<Index *>(ast_)) {
+        ast_ = alloc.clone(ast);
+    } else if (auto *ast = dynamic_cast<Local *>(ast_)) {
+        ast_ = alloc.clone(ast);
+    } else if (auto *ast = dynamic_cast<LiteralBoolean *>(ast_)) {
+        ast_ = alloc.clone(ast);
+    } else if (auto *ast = dynamic_cast<LiteralNumber *>(ast_)) {
+        ast_ = alloc.clone(ast);
+    } else if (auto *ast = dynamic_cast<LiteralString *>(ast_)) {
+        ast_ = alloc.clone(ast);
+    } else if (auto *ast = dynamic_cast<LiteralNull *>(ast_)) {
+        ast_ = alloc.clone(ast);
+    } else if (auto *ast = dynamic_cast<Object *>(ast_)) {
+        ast_ = alloc.clone(ast);
+    } else if (auto *ast = dynamic_cast<DesugaredObject *>(ast_)) {
+        ast_ = alloc.clone(ast);
+    } else if (auto *ast = dynamic_cast<ObjectComprehension *>(ast_)) {
+        ast_ = alloc.clone(ast);
+    } else if (auto *ast = dynamic_cast<ObjectComprehensionSimple *>(ast_)) {
+        ast_ = alloc.clone(ast);
+    } else if (auto *ast = dynamic_cast<Parens *>(ast_)) {
+        ast_ = alloc.clone(ast);
+    } else if (auto *ast = dynamic_cast<Self *>(ast_)) {
+        ast_ = alloc.clone(ast);
+    } else if (auto *ast = dynamic_cast<SuperIndex *>(ast_)) {
+        ast_ = alloc.clone(ast);
+    } else if (auto *ast = dynamic_cast<Unary *>(ast_)) {
+        ast_ = alloc.clone(ast);
+    } else if (auto *ast = dynamic_cast<Var *>(ast_)) {
+        ast_ = alloc.clone(ast);
+
+    } else {
+        std::cerr << "INTERNAL ERROR: Unknown AST: " << ast_ << std::endl;
+        std::abort();
+    }
+
+    CompilerPass::expr(ast_);
+}
+
+AST *clone_ast(Allocator &alloc, AST *ast)
+{
+    AST *r = ast;
+    ClonePass(alloc).expr(r);
+    return r;
+}
diff --git a/libjsonnet/core/pass.h b/libjsonnet/core/pass.h
new file mode 100644
index 0000000..230294e
--- /dev/null
+++ b/libjsonnet/core/pass.h
@@ -0,0 +1,115 @@
+/*
+Copyright 2015 Google Inc. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+#ifndef JSONNET_PASS_H
+#define JSONNET_PASS_H
+
+#include "ast.h"
+
+/** A generic Pass that does nothing but can be extended to easily define real passes.
+ */
+class CompilerPass {
+   public:
+   protected:
+    Allocator &alloc;
+
+   public:
+    CompilerPass(Allocator &alloc) : alloc(alloc) {}
+
+    virtual void fodderElement(FodderElement &) {}
+
+    virtual void fodder(Fodder &fodder);
+
+    virtual void specs(std::vector<ComprehensionSpec> &specs);
+
+    virtual void params(Fodder &fodder_l, ArgParams &params, Fodder &fodder_r);
+
+    virtual void fieldParams(ObjectField &field);
+
+    virtual void fields(ObjectFields &fields);
+
+    virtual void expr(AST *&ast_);
+
+    virtual void visit(Apply *ast);
+
+    virtual void visit(ApplyBrace *ast);
+
+    virtual void visit(Array *ast);
+
+    virtual void visit(ArrayComprehension *ast);
+
+    virtual void visit(Assert *ast);
+
+    virtual void visit(Binary *ast);
+
+    virtual void visit(BuiltinFunction *) {}
+
+    virtual void visit(Conditional *ast);
+
+    virtual void visit(Dollar *) {}
+
+    virtual void visit(Error *ast);
+
+    virtual void visit(Function *ast);
+
+    virtual void visit(Import *ast);
+
+    virtual void visit(Importstr *ast);
+
+    virtual void visit(InSuper *ast);
+
+    virtual void visit(Index *ast);
+
+    virtual void visit(Local *ast);
+
+    virtual void visit(LiteralBoolean *) {}
+
+    virtual void visit(LiteralNumber *) {}
+
+    virtual void visit(LiteralString *) {}
+
+    virtual void visit(LiteralNull *) {}
+
+    virtual void visit(Object *ast);
+
+    virtual void visit(DesugaredObject *ast);
+
+    virtual void visit(ObjectComprehension *ast);
+
+    virtual void visit(ObjectComprehensionSimple *ast);
+
+    virtual void visit(Parens *ast);
+
+    virtual void visit(Self *) {}
+
+    virtual void visit(SuperIndex *ast);
+
+    virtual void visit(Unary *ast);
+
+    virtual void visit(Var *) {}
+
+    virtual void visitExpr(AST *&ast_);
+
+    virtual void file(AST *&body, Fodder &final_fodder);
+};
+
+/** Return an equivalent AST that can be modified without affecting the original.
+ *
+ * This is a deep copy.
+ */
+AST *clone_ast(Allocator &alloc, AST *ast);
+
+#endif
diff --git a/libjsonnet/core/state.h b/libjsonnet/core/state.h
index e053512..e927dae 100644
--- a/libjsonnet/core/state.h
+++ b/libjsonnet/core/state.h
@@ -27,7 +27,7 @@ typedef unsigned char GarbageCollectionMark;
  */
 struct HeapEntity {
     GarbageCollectionMark mark;
-    virtual ~HeapEntity() { }
+    virtual ~HeapEntity() {}
 };
 
 /** Tagged union of all values.
@@ -38,7 +38,7 @@ struct Value {
     enum Type {
         NULL_TYPE = 0x0,  // Unfortunately NULL is a macro in C.
         BOOLEAN = 0x1,
-        DOUBLE = 0x2,
+        NUMBER = 0x2,
 
         ARRAY = 0x10,
         FUNCTION = 0x11,
@@ -63,15 +63,15 @@ std::string type_str(Value::Type t)
     switch (t) {
         case Value::NULL_TYPE: return "null";
         case Value::BOOLEAN: return "boolean";
-        case Value::DOUBLE: return "double";
+        case Value::NUMBER: return "number";
         case Value::ARRAY: return "array";
         case Value::FUNCTION: return "function";
         case Value::OBJECT: return "object";
         case Value::STRING: return "string";
         default:
-        std::cerr << "INTERNAL ERROR: Unknown type: " << t << std::endl;
-        std::abort();
-        return "";  // Quiet, compiler.
+            std::cerr << "INTERNAL ERROR: Unknown type: " << t << std::endl;
+            std::abort();
+            return "";  // Quiet, compiler.
     }
 }
 
@@ -88,7 +88,7 @@ struct HeapThunk;
  * Each nested local statement, function call, and field access has its own binding frame to
  * give the values for the local variable, function parameters, or upValues.
  */
-typedef std::map<const Identifier*, HeapThunk*> BindingFrame;
+typedef std::map<const Identifier *, HeapThunk *> BindingFrame;
 
 /** Supertype of all objects.  Types of Value::OBJECT will point at these.  */
 struct HeapObject : public HeapEntity {
@@ -122,8 +122,9 @@ struct HeapThunk : public HeapEntity {
     const AST *body;
 
     HeapThunk(const Identifier *name, HeapObject *self, unsigned offset, const AST *body)
-      : filled(false), name(name), self(self), offset(offset), body(body)
-    { }
+        : filled(false), name(name), self(self), offset(offset), body(body)
+    {
+    }
 
     void fill(const Value &v)
     {
@@ -138,10 +139,8 @@ struct HeapArray : public HeapEntity {
     // It is convenient for this to not be const, so that we can add elements to it one at a
     // time after creation.  Thus, elements are not GCed as the array is being
     // created.
-    std::vector<HeapThunk*> elements;
-    HeapArray(const std::vector<HeapThunk*> &elements)
-      : elements(elements)
-    { }
+    std::vector<HeapThunk *> elements;
+    HeapArray(const std::vector<HeapThunk *> &elements) : elements(elements) {}
 };
 
 /** Supertype of all objects that are not super objects or extended objects.  */
@@ -165,21 +164,22 @@ struct HeapSimpleObject : public HeapLeafObject {
      * These are evaluated in the captured environment and with self and super bound
      * dynamically.
      */
-    const std::map<const Identifier*, Field> fields;
+    const std::map<const Identifier *, Field> fields;
 
     /** The object's invariants.
      *
      * These are evaluated in the captured environment with self and super bound.
      */
-    std::vector<AST*> asserts;
+    std::vector<AST *> asserts;
 
     HeapSimpleObject(const BindingFrame &up_values,
-                     const std::map<const Identifier*, Field> fields, std::vector<AST*> asserts)
-      : upValues(up_values), fields(fields), asserts(asserts)
-    { }
+                     const std::map<const Identifier *, Field> fields, std::vector<AST *> asserts)
+        : upValues(up_values), fields(fields), asserts(asserts)
+    {
+    }
 };
 
-/** Objects created by the extendby construct. */
+/** Objects created by the + construct. */
 struct HeapExtendedObject : public HeapObject {
     /** The left hand side of the construct. */
     HeapObject *left;
@@ -187,22 +187,19 @@ struct HeapExtendedObject : public HeapObject {
     /** The right hand side of the construct. */
     HeapObject *right;
 
-    HeapExtendedObject(HeapObject *left, HeapObject *right)
-      : left(left), right(right)
-    { }
+    HeapExtendedObject(HeapObject *left, HeapObject *right) : left(left), right(right) {}
 };
 
 /** Objects created by the ObjectComprehensionSimple construct. */
 struct HeapComprehensionObject : public HeapLeafObject {
-
     /** The captured environment. */
     const BindingFrame upValues;
 
     /** The expression used to compute the field values.  */
-    const AST* value;
+    const AST *value;
 
     /** The identifier of bound variable in that construct.  */
-    const Identifier * const id;
+    const Identifier *const id;
 
     /** Binding for id.
      *
@@ -213,13 +210,13 @@ struct HeapComprehensionObject : public HeapLeafObject {
      * It is convenient to make this non-const to allow building up the values one by one, so that
      * the garbage collector can see them at each intermediate point.
      */
-    std::map<const Identifier*, HeapThunk*> compValues;
+    std::map<const Identifier *, HeapThunk *> compValues;
 
-    HeapComprehensionObject(const BindingFrame &up_values, const AST *value,
-                            const Identifier *id,
-                            const std::map<const Identifier*, HeapThunk*> &comp_values)
-      : upValues(up_values), value(value), id(id), compValues(comp_values)
-    { }
+    HeapComprehensionObject(const BindingFrame &up_values, const AST *value, const Identifier *id,
+                            const std::map<const Identifier *, HeapThunk *> &comp_values)
+        : upValues(up_values), value(value), id(id), compValues(comp_values)
+    {
+    }
 };
 
 /** Stores the function itself and also the captured environment.
@@ -239,35 +236,32 @@ struct HeapClosure : public HeapEntity {
     struct Param {
         const Identifier *id;
         const AST *def;
-        Param(const Identifier *id, const AST *def)
-          : id(id), def(def)
-        { }
+        Param(const Identifier *id, const AST *def) : id(id), def(def) {}
     };
     typedef std::vector<Param> Params;
     const Params params;
     const AST *body;
     std::string builtinName;
-    HeapClosure(const BindingFrame &up_values,
-                HeapObject *self,
-                unsigned offset,
-                const Params &params,
-                const AST *body, const std::string &builtin_name)
-      : upValues(up_values), self(self), offset(offset),
-        params(params), body(body), builtinName(builtin_name)
-    { }
+    HeapClosure(const BindingFrame &up_values, HeapObject *self, unsigned offset,
+                const Params &params, const AST *body, const std::string &builtin_name)
+        : upValues(up_values),
+          self(self),
+          offset(offset),
+          params(params),
+          body(body),
+          builtinName(builtin_name)
+    {
+    }
 };
 
 /** Stores a simple string on the heap. */
 struct HeapString : public HeapEntity {
-    const String value;
-    HeapString(const String &value)
-      : value(value)
-    { }
+    const UString value;
+    HeapString(const UString &value) : value(value) {}
 };
 
 /** The heap does memory management, i.e. garbage collection. */
 class Heap {
-
     /** How many objects must exist in the heap before we bother doing garbage collection?
      */
     unsigned gcTuneMinObjects;
@@ -285,7 +279,7 @@ class Heap {
      * removed from the heap via O(1) swap with last element, so the ordering of entities is
      * arbitrary and changes every garbage collection cycle.
      */
-    std::vector<HeapEntity*> entities;
+    std::vector<HeapEntity *> entities;
 
     /** The number of heap entities at the last garbage collection cycle. */
     unsigned long lastNumEntities;
@@ -293,25 +287,28 @@ class Heap {
     /** The number of heap entities now. */
     unsigned long numEntities;
 
-    /** Add the HeapEntity inside v to vec, if the value exists on the heap.   
+    /** Add the HeapEntity inside v to vec, if the value exists on the heap.
      */
-    void addIfHeapEntity(Value v, std::vector<HeapEntity*> &vec)
+    void addIfHeapEntity(Value v, std::vector<HeapEntity *> &vec)
     {
-        if (v.isHeap()) vec.push_back(v.v.h);
+        if (v.isHeap())
+            vec.push_back(v.v.h);
     }
 
-    /** Add the HeapEntity inside v to vec, if the value exists on the heap.   
+    /** Add the HeapEntity inside v to vec, if the value exists on the heap.
      */
-    void addIfHeapEntity(HeapEntity *v, std::vector<HeapEntity*> &vec)
+    void addIfHeapEntity(HeapEntity *v, std::vector<HeapEntity *> &vec)
     {
         vec.push_back(v);
     }
 
-    public:
-
+   public:
     Heap(unsigned gc_tune_min_objects, double gc_tune_growth_trigger)
-      : gcTuneMinObjects(gc_tune_min_objects), gcTuneGrowthTrigger(gc_tune_growth_trigger),
-        lastMark(0), lastNumEntities(0), numEntities(0)
+        : gcTuneMinObjects(gc_tune_min_objects),
+          gcTuneGrowthTrigger(gc_tune_growth_trigger),
+          lastMark(0),
+          lastNumEntities(0),
+          numEntities(0)
     {
     }
 
@@ -324,7 +321,8 @@ class Heap {
     /** Garbage collection: Mark v, and entities reachable from v. */
     void markFrom(Value v)
     {
-        if (v.isHeap()) markFrom(v.v.h);
+        if (v.isHeap())
+            markFrom(v.v.h);
     }
 
     /** Garbage collection: Mark heap entities reachable from the given heap entity. */
@@ -334,8 +332,8 @@ class Heap {
         const GarbageCollectionMark thisMark = lastMark + 1;
         struct State {
             HeapEntity *ent;
-            std::vector<HeapEntity*> children;
-            State(HeapEntity *ent) : ent(ent) { }
+            std::vector<HeapEntity *> children;
+            State(HeapEntity *ent) : ent(ent) {}
         };
 
         std::vector<State> stack;
@@ -348,32 +346,31 @@ class Heap {
             if (curr->mark != thisMark) {
                 curr->mark = thisMark;
 
-                if (auto *obj = dynamic_cast<HeapSimpleObject*>(curr)) {
+                if (auto *obj = dynamic_cast<HeapSimpleObject *>(curr)) {
                     for (auto upv : obj->upValues)
                         addIfHeapEntity(upv.second, s.children);
 
-                } else if (auto *obj = dynamic_cast<HeapExtendedObject*>(curr)) {
+                } else if (auto *obj = dynamic_cast<HeapExtendedObject *>(curr)) {
                     addIfHeapEntity(obj->left, s.children);
                     addIfHeapEntity(obj->right, s.children);
 
-                } else if (auto *obj = dynamic_cast<HeapComprehensionObject*>(curr)) {
+                } else if (auto *obj = dynamic_cast<HeapComprehensionObject *>(curr)) {
                     for (auto upv : obj->upValues)
                         addIfHeapEntity(upv.second, s.children);
                     for (auto upv : obj->compValues)
                         addIfHeapEntity(upv.second, s.children);
 
-
-                } else if (auto *arr = dynamic_cast<HeapArray*>(curr)) {
+                } else if (auto *arr = dynamic_cast<HeapArray *>(curr)) {
                     for (auto el : arr->elements)
                         addIfHeapEntity(el, s.children);
 
-                } else if (auto *func = dynamic_cast<HeapClosure*>(curr)) {
+                } else if (auto *func = dynamic_cast<HeapClosure *>(curr)) {
                     for (auto upv : func->upValues)
                         addIfHeapEntity(upv.second, s.children);
                     if (func->self)
                         addIfHeapEntity(func->self, s.children);
 
-                } else if (auto *thunk = dynamic_cast<HeapThunk*>(curr)) {
+                } else if (auto *thunk = dynamic_cast<HeapThunk *>(curr)) {
                     if (thunk->filled) {
                         if (thunk->content.isHeap())
                             addIfHeapEntity(thunk->content.v.h, s.children);
@@ -401,13 +398,13 @@ class Heap {
     {
         lastMark++;
         // Heap shrinks during this loop.  Do not cache entities.size().
-        for (unsigned long i=0 ; i<entities.size() ; ++i) {
+        for (unsigned long i = 0; i < entities.size(); ++i) {
             HeapEntity *x = entities[i];
             if (x->mark != lastMark) {
                 delete x;
                 if (i != entities.size() - 1) {
                     // Swap it with the back.
-                    entities[i] = entities[entities.size()-1];
+                    entities[i] = entities[entities.size() - 1];
                 }
                 entities.pop_back();
                 --i;
@@ -419,16 +416,17 @@ class Heap {
     /** Is it time to initiate a GC cycle? */
     bool checkHeap(void)
     {
-        return numEntities > gcTuneMinObjects
-            && numEntities > gcTuneGrowthTrigger * lastNumEntities;
+        return numEntities > gcTuneMinObjects &&
+               numEntities > gcTuneGrowthTrigger * lastNumEntities;
     }
 
     /** Allocate a heap entity.
      *
      * If the heap is large enough (\see gcTuneMinObjects) and has grown by enough since the
      * last collection cycle (\see gcTuneGrowthTrigger), a collection cycle is performed.
-    */
-    template <class T, class... Args> T* makeEntity(Args&&... args)
+     */
+    template <class T, class... Args>
+    T *makeEntity(Args &&... args)
     {
         T *r = new T(std::forward<Args>(args)...);
         entities.push_back(r);
@@ -436,7 +434,6 @@ class Heap {
         numEntities = entities.size();
         return r;
     }
-
 };
 
 }  // namespace
diff --git a/libjsonnet/core/static_analysis.cpp b/libjsonnet/core/static_analysis.cpp
index 868017c..4656788 100644
--- a/libjsonnet/core/static_analysis.cpp
+++ b/libjsonnet/core/static_analysis.cpp
@@ -16,9 +16,9 @@ limitations under the License.
 
 #include <set>
 
+#include "ast.h"
 #include "static_analysis.h"
 #include "static_error.h"
-#include "ast.h"
 
 typedef std::set<const Identifier *> IdSet;
 
@@ -39,31 +39,31 @@ static IdSet static_analysis(AST *ast_, bool in_object, const IdSet &vars)
 {
     IdSet r;
 
-    if (auto *ast = dynamic_cast<const Apply*>(ast_)) {
+    if (auto *ast = dynamic_cast<const Apply *>(ast_)) {
         append(r, static_analysis(ast->target, in_object, vars));
         for (const auto &arg : ast->args)
             append(r, static_analysis(arg.expr, in_object, vars));
 
-    } else if (auto *ast = dynamic_cast<const Array*>(ast_)) {
-        for (auto & el : ast->elements)
+    } else if (auto *ast = dynamic_cast<const Array *>(ast_)) {
+        for (auto &el : ast->elements)
             append(r, static_analysis(el.expr, in_object, vars));
 
-    } else if (auto *ast = dynamic_cast<const Binary*>(ast_)) {
+    } else if (auto *ast = dynamic_cast<const Binary *>(ast_)) {
         append(r, static_analysis(ast->left, in_object, vars));
         append(r, static_analysis(ast->right, in_object, vars));
 
-    } else if (dynamic_cast<const BuiltinFunction*>(ast_)) {
+    } else if (dynamic_cast<const BuiltinFunction *>(ast_)) {
         // Nothing to do.
 
-    } else if (auto *ast = dynamic_cast<const Conditional*>(ast_)) {
+    } else if (auto *ast = dynamic_cast<const Conditional *>(ast_)) {
         append(r, static_analysis(ast->cond, in_object, vars));
         append(r, static_analysis(ast->branchTrue, in_object, vars));
         append(r, static_analysis(ast->branchFalse, in_object, vars));
 
-    } else if (auto *ast = dynamic_cast<const Error*>(ast_)) {
+    } else if (auto *ast = dynamic_cast<const Error *>(ast_)) {
         append(r, static_analysis(ast->expr, in_object, vars));
 
-    } else if (auto *ast = dynamic_cast<const Function*>(ast_)) {
+    } else if (auto *ast = dynamic_cast<const Function *>(ast_)) {
         auto new_vars = vars;
         IdSet params;
         for (const auto &p : ast->params) {
@@ -84,48 +84,53 @@ static IdSet static_analysis(AST *ast_, bool in_object, const IdSet &vars)
             fv.erase(p.id);
         append(r, fv);
 
-    } else if (dynamic_cast<const Import*>(ast_)) {
+    } else if (dynamic_cast<const Import *>(ast_)) {
         // Nothing to do.
 
-    } else if (dynamic_cast<const Importstr*>(ast_)) {
+    } else if (dynamic_cast<const Importstr *>(ast_)) {
         // Nothing to do.
 
-    } else if (auto *ast = dynamic_cast<const Index*>(ast_)) {
+    } else if (auto *ast = dynamic_cast<const InSuper *>(ast_)) {
+        if (!in_object)
+            throw StaticError(ast_->location, "Can't use super outside of an object.");
+        append(r, static_analysis(ast->element, in_object, vars));
+
+    } else if (auto *ast = dynamic_cast<const Index *>(ast_)) {
         append(r, static_analysis(ast->target, in_object, vars));
         append(r, static_analysis(ast->index, in_object, vars));
 
-    } else if (auto *ast = dynamic_cast<const Local*>(ast_)) {
+    } else if (auto *ast = dynamic_cast<const Local *>(ast_)) {
         IdSet ast_vars;
-        for (const auto &bind: ast->binds) {
+        for (const auto &bind : ast->binds) {
             ast_vars.insert(bind.var);
         }
         auto new_vars = vars;
         append(new_vars, ast_vars);
         IdSet fvs;
-        for (const auto &bind: ast->binds) {
+        for (const auto &bind : ast->binds) {
             append(fvs, static_analysis(bind.body, in_object, new_vars));
         }
 
         append(fvs, static_analysis(ast->body, in_object, new_vars));
 
-        for (const auto &bind: ast->binds)
+        for (const auto &bind : ast->binds)
             fvs.erase(bind.var);
 
         append(r, fvs);
 
-    } else if (dynamic_cast<const LiteralBoolean*>(ast_)) {
+    } else if (dynamic_cast<const LiteralBoolean *>(ast_)) {
         // Nothing to do.
 
-    } else if (dynamic_cast<const LiteralNumber*>(ast_)) {
+    } else if (dynamic_cast<const LiteralNumber *>(ast_)) {
         // Nothing to do.
 
-    } else if (dynamic_cast<const LiteralString*>(ast_)) {
+    } else if (dynamic_cast<const LiteralString *>(ast_)) {
         // Nothing to do.
 
-    } else if (dynamic_cast<const LiteralNull*>(ast_)) {
+    } else if (dynamic_cast<const LiteralNull *>(ast_)) {
         // Nothing to do.
 
-    } else if (auto *ast = dynamic_cast<DesugaredObject*>(ast_)) {
+    } else if (auto *ast = dynamic_cast<DesugaredObject *>(ast_)) {
         for (auto &field : ast->fields) {
             append(r, static_analysis(field.name, in_object, vars));
             append(r, static_analysis(field.body, true, vars));
@@ -134,7 +139,7 @@ static IdSet static_analysis(AST *ast_, bool in_object, const IdSet &vars)
             append(r, static_analysis(assert, true, vars));
         }
 
-    } else if (auto *ast = dynamic_cast<ObjectComprehensionSimple*>(ast_)) {
+    } else if (auto *ast = dynamic_cast<ObjectComprehensionSimple *>(ast_)) {
         auto new_vars = vars;
         new_vars.insert(ast->id);
         append(r, static_analysis(ast->field, false, new_vars));
@@ -142,28 +147,27 @@ static IdSet static_analysis(AST *ast_, bool in_object, const IdSet &vars)
         r.erase(ast->id);
         append(r, static_analysis(ast->array, in_object, vars));
 
-    } else if (dynamic_cast<const Self*>(ast_)) {
+    } else if (dynamic_cast<const Self *>(ast_)) {
         if (!in_object)
             throw StaticError(ast_->location, "Can't use self outside of an object.");
 
-    } else if (auto *ast = dynamic_cast<const SuperIndex*>(ast_)) {
+    } else if (auto *ast = dynamic_cast<const SuperIndex *>(ast_)) {
         if (!in_object)
             throw StaticError(ast_->location, "Can't use super outside of an object.");
         append(r, static_analysis(ast->index, in_object, vars));
 
-    } else if (auto *ast = dynamic_cast<const Unary*>(ast_)) {
+    } else if (auto *ast = dynamic_cast<const Unary *>(ast_)) {
         append(r, static_analysis(ast->expr, in_object, vars));
 
-    } else if (auto *ast = dynamic_cast<const Var*>(ast_)) {
+    } else if (auto *ast = dynamic_cast<const Var *>(ast_)) {
         if (vars.find(ast->id) == vars.end()) {
-            throw StaticError(ast->location, "Unknown variable: "+encode_utf8(ast->id->name));
+            throw StaticError(ast->location, "Unknown variable: " + encode_utf8(ast->id->name));
         }
         r.insert(ast->id);
 
     } else {
         std::cerr << "INTERNAL ERROR: Unknown AST: " << ast_ << std::endl;
         std::abort();
-
     }
 
     for (auto *id : r)
diff --git a/libjsonnet/core/static_error.h b/libjsonnet/core/static_error.h
index 1b8b7e8..7182ce8 100644
--- a/libjsonnet/core/static_error.h
+++ b/libjsonnet/core/static_error.h
@@ -23,16 +23,16 @@ limitations under the License.
 struct Location {
     unsigned long line;
     unsigned long column;
-    Location(void)
-      : line(0), column(0)
-    { }
-    Location(unsigned long line_number, unsigned long column)
-      : line(line_number), column(column)
-    { }
+    Location(void) : line(0), column(0) {}
+    Location(unsigned long line, unsigned long column) : line(line), column(column) {}
     bool isSet(void) const
     {
         return line != 0;
     }
+    Location successor(void) const
+    {
+        return Location(this->line, this->column + 1);
+    }
 };
 
 static inline std::ostream &operator<<(std::ostream &o, const Location &loc)
@@ -43,16 +43,15 @@ static inline std::ostream &operator<<(std::ostream &o, const Location &loc)
 
 struct LocationRange {
     std::string file;
+    // [begin, end)
     Location begin, end;
-    LocationRange(void)
-    { }
+    LocationRange(void) {}
     /** This is useful for special locations, e.g. manifestation entry point. */
-    LocationRange(const std::string &msg)
-      : file(msg)
-    { }
+    LocationRange(const std::string &msg) : file(msg) {}
     LocationRange(const std::string &file, const Location &begin, const Location &end)
-      : file(file), begin(begin), end(end)
-    { }
+        : file(file), begin(begin), end(end)
+    {
+    }
     bool isSet(void) const
     {
         return begin.isSet();
@@ -67,7 +66,7 @@ static inline std::ostream &operator<<(std::ostream &o, const LocationRange &loc
         if (loc.file.length() > 0)
             o << ":";
         if (loc.begin.line == loc.end.line) {
-            if (loc.begin.column == loc.end.column) {
+            if (loc.begin.column == loc.end.column - 1) {
                 o << loc.begin;
             } else {
                 o << loc.begin << "-" << loc.end.column;
@@ -82,16 +81,13 @@ static inline std::ostream &operator<<(std::ostream &o, const LocationRange &loc
 struct StaticError {
     LocationRange location;
     std::string msg;
-    StaticError(const std::string &msg)
-      : msg(msg)
-    {
-    }
+    StaticError(const std::string &msg) : msg(msg) {}
     StaticError(const std::string &filename, const Location &location, const std::string &msg)
-      : location(filename, location, location), msg(msg)
+        : location(filename, location, location.successor()), msg(msg)
     {
     }
     StaticError(const LocationRange &location, const std::string &msg)
-      : location(location), msg(msg)
+        : location(location), msg(msg)
     {
     }
 
diff --git a/libjsonnet/core/string_utils.cpp b/libjsonnet/core/string_utils.cpp
index 84992bc..280b384 100644
--- a/libjsonnet/core/string_utils.cpp
+++ b/libjsonnet/core/string_utils.cpp
@@ -16,22 +16,22 @@ limitations under the License.
 
 #include <iomanip>
 
-#include "string_utils.h"
 #include "static_error.h"
+#include "string_utils.h"
 
-String jsonnet_string_unparse(const String &str, bool single)
+UString jsonnet_string_unparse(const UString &str, bool single)
 {
-    StringStream ss;
+    UStringStream ss;
     ss << (single ? U'\'' : U'\"');
-	ss << jsonnet_string_escape(str, single);
+    ss << jsonnet_string_escape(str, single);
     ss << (single ? U'\'' : U'\"');
-	return ss.str();
+    return ss.str();
 }
 
-String jsonnet_string_escape(const String &str, bool single)
+UString jsonnet_string_escape(const UString &str, bool single)
 {
-    StringStream ss;
-    for (std::size_t i=0 ; i<str.length() ; ++i) {
+    UStringStream ss;
+    for (std::size_t i = 0; i < str.length(); ++i) {
         char32_t c = str[i];
         switch (c) {
             case U'\"': ss << (single ? U"\"" : U"\\\""); break;
@@ -45,10 +45,10 @@ String jsonnet_string_escape(const String &str, bool single)
             case U'\0': ss << U"\\u0000"; break;
             default: {
                 if (c < 0x20 || (c >= 0x7f && c <= 0x9f)) {
-                    //Unprintable, use \u
+                    // Unprintable, use \u
                     std::stringstream ss8;
                     ss8 << "\\u" << std::hex << std::setfill('0') << std::setw(4)
-                       << (unsigned long)(c);
+                        << (unsigned long)(c);
                     ss << decode_utf8(ss8.str());
                 } else {
                     // Printable, write verbatim
@@ -60,103 +60,83 @@ String jsonnet_string_escape(const String &str, bool single)
     return ss.str();
 }
 
-
-String jsonnet_string_unescape(const LocationRange &loc, const String &s)
+UString jsonnet_string_unescape(const LocationRange &loc, const UString &s)
 {
-    String r;
+    UString r;
     const char32_t *s_ptr = s.c_str();
-    for (const char32_t *c = s_ptr; *c != U'\0' ; ++c) {
+    for (const char32_t *c = s_ptr; *c != U'\0'; ++c) {
         switch (*c) {
             case '\\':
-            switch (*(++c)) {
-                case '"':
-                case '\'':
-                r += *c;
-                break;
-
-                case '\\':
-                r += *c;
-                break;
-
-                case '/':
-                r += *c;
-                break;
-
-                case 'b':
-                r += '\b';
-                break;
-
-                case 'f':
-                r += '\f';
-                break;
-
-                case 'n':
-                r += '\n';
-                break;
+                switch (*(++c)) {
+                    case '"':
+                    case '\'': r += *c; break;
+
+                    case '\\': r += *c; break;
+
+                    case '/': r += *c; break;
+
+                    case 'b': r += '\b'; break;
+
+                    case 'f': r += '\f'; break;
+
+                    case 'n': r += '\n'; break;
+
+                    case 'r': r += '\r'; break;
+
+                    case 't': r += '\t'; break;
+
+                    case 'u': {
+                        ++c;  // Consume the 'u'.
+                        unsigned long codepoint = 0;
+                        // Expect 4 hex digits.
+                        for (unsigned i = 0; i < 4; ++i) {
+                            auto x = (unsigned char)(c[i]);
+                            unsigned digit;
+                            if (x == '\0') {
+                                auto msg = "Truncated unicode escape sequence in string literal.";
+                                throw StaticError(loc, msg);
+                            } else if (x >= '0' && x <= '9') {
+                                digit = x - '0';
+                            } else if (x >= 'a' && x <= 'f') {
+                                digit = x - 'a' + 10;
+                            } else if (x >= 'A' && x <= 'F') {
+                                digit = x - 'A' + 10;
+                            } else {
+                                std::stringstream ss;
+                                ss << "Malformed unicode escape character, "
+                                   << "should be hex: '" << x << "'";
+                                throw StaticError(loc, ss.str());
+                            }
+                            codepoint *= 16;
+                            codepoint += digit;
+                        }
 
-                case 'r':
-                r += '\r';
-                break;
+                        r += codepoint;
 
-                case 't':
-                r += '\t';
-                break;
+                        // Leave us on the last char, ready for the ++c at
+                        // the outer for loop.
+                        c += 3;
+                    } break;
 
-                case 'u': {
-                    ++c;  // Consume the 'u'.
-                    unsigned long codepoint = 0;
-                    // Expect 4 hex digits.
-                    for (unsigned i=0 ; i<4 ; ++i) {
-                        auto x = (unsigned char)(c[i]);
-                        unsigned digit;
-                        if (x == '\0') {
-                            auto msg = "Truncated unicode escape sequence in string literal.";
-                            throw StaticError(loc, msg);
-                        } else if (x >= '0' && x <= '9') {
-                            digit = x - '0';
-                        } else if (x >= 'a' && x <= 'f') {
-                            digit = x - 'a' + 10;
-                        } else if (x >= 'A' && x <= 'F') {
-                            digit = x - 'A' + 10;
-                        } else {
-                            std::stringstream ss;
-                            ss << "Malformed unicode escape character, "
-                               << "should be hex: '" << x << "'";
-                            throw StaticError(loc, ss.str());
-                        }
-                        codepoint *= 16;
-                        codepoint += digit;
+                    case '\0': {
+                        auto msg = "Truncated escape sequence in string literal.";
+                        throw StaticError(loc, msg);
                     }
 
-                    r += codepoint;
-
-                    // Leave us on the last char, ready for the ++c at
-                    // the outer for loop.
-                    c += 3;
+                    default: {
+                        std::stringstream ss;
+                        std::string utf8;
+                        encode_utf8(*c, utf8);
+                        ss << "Unknown escape sequence in string literal: '" << utf8 << "'";
+                        throw StaticError(loc, ss.str());
+                    }
                 }
                 break;
 
-                case '\0': {
-                    auto msg = "Truncated escape sequence in string literal.";
-                    throw StaticError(loc, msg);
-                }
-
-                default: {
-                    std::stringstream ss;
-                    std::string utf8;
-                    encode_utf8(*c, utf8);
-                    ss << "Unknown escape sequence in string literal: '" << utf8 << "'";
-                    throw StaticError(loc, ss.str());
-                }
-            }
-            break;
-
             default:
-            // Just a regular letter.
-            r += *c;
+                // Just a regular letter.
+                r += *c;
         }
     }
     return r;
 }
-
-
diff --git a/libjsonnet/core/string_utils.h b/libjsonnet/core/string_utils.h
index 8916d5a..fc26929 100644
--- a/libjsonnet/core/string_utils.h
+++ b/libjsonnet/core/string_utils.h
@@ -20,12 +20,16 @@ limitations under the License.
 #include "lexer.h"
 
 /** Unparse the string. */
-String jsonnet_string_unparse(const String &str, bool single);
+UString jsonnet_string_unparse(const UString &str, bool single);
+
+// Note that the following two functions do not handle the quoting of ' and "
+// inside verbatim strings because that quoting is reversible.  Thus, that
+// quoting is done at lexing time and undone again at pretty-printing time.
 
 /** Escape special characters. */
-String jsonnet_string_escape(const String &str, bool single);
+UString jsonnet_string_escape(const UString &str, bool single);
 
 /** Resolve escape chracters in the string. */
-String jsonnet_string_unescape(const LocationRange &loc, const String &s);
+UString jsonnet_string_unescape(const LocationRange &loc, const UString &s);
 
 #endif
diff --git a/libjsonnet/core/unicode.h b/libjsonnet/core/unicode.h
index ec9596f..5742c4f 100644
--- a/libjsonnet/core/unicode.h
+++ b/libjsonnet/core/unicode.h
@@ -38,23 +38,23 @@ static inline int encode_utf8(char32_t x, std::string &s)
     if (x < 0x80) {
         s.push_back((char)x);
         return 1;
-    } else if (x < 0x800) { // note that capital 'Y' bits must be 0
+    } else if (x < 0x800) {  // note that capital 'Y' bits must be 0
         bytes |= 0xC080;
         s.push_back((bytes >> 8) & 0xFF);
         s.push_back((bytes >> 0) & 0xFF);
         return 2;
-    } else if (x < 0x10000) { // note that 'z' bits must be 0
+    } else if (x < 0x10000) {  // note that 'z' bits must be 0
         bytes |= 0xE08080;
         s.push_back((bytes >> 16) & 0xFF);
-        s.push_back((bytes >>  8) & 0xFF);
-        s.push_back((bytes >>  0) & 0xFF);
+        s.push_back((bytes >> 8) & 0xFF);
+        s.push_back((bytes >> 0) & 0xFF);
         return 3;
-    } else if (x < 0x110000) { // note that capital 'Z' bits must be 0
+    } else if (x < 0x110000) {  // note that capital 'Z' bits must be 0
         bytes |= 0xF0808080;
         s.push_back((bytes >> 24) & 0xFF);
         s.push_back((bytes >> 16) & 0xFF);
-        s.push_back((bytes >>  8) & 0xFF);
-        s.push_back((bytes >>  0) & 0xFF);
+        s.push_back((bytes >> 8) & 0xFF);
+        s.push_back((bytes >> 0) & 0xFF);
         return 4;
     } else {
         std::cerr << "Should never get here." << std::endl;
@@ -64,18 +64,18 @@ static inline int encode_utf8(char32_t x, std::string &s)
 
 /** Convert the UTF8 byte sequence in the given string to a unicode code point.
  *
- * \param str The string. 
+ * \param str The string.
  * \param i The index of the string from which to start decoding and returns the index of the last
- *          byte of the encoded codepoint. 
+ *          byte of the encoded codepoint.
  * \returns The decoded unicode codepoint.
  */
 static inline char32_t decode_utf8(const std::string &str, size_t &i)
 {
     char c0 = str[i];
-    if ((c0 & 0x80) == 0) { //0xxxxxxx
+    if ((c0 & 0x80) == 0) {  // 0xxxxxxx
         return c0;
-    } else if ((c0 & 0xE0) == 0xC0) { //110yyyxx 10xxxxxx
-        if (i+1 >= str.length()) {
+    } else if ((c0 & 0xE0) == 0xC0) {  // 110yyyxx 10xxxxxx
+        if (i + 1 >= str.length()) {
             return JSONNET_CODEPOINT_ERROR;
         }
         char c1 = str[++i];
@@ -83,8 +83,8 @@ static inline char32_t decode_utf8(const std::string &str, size_t &i)
             return JSONNET_CODEPOINT_ERROR;
         }
         return ((c0 & 0x1F) << 6ul) | (c1 & 0x3F);
-    } else if ((c0 & 0xF0) == 0xE0) { //1110yyyy 10yyyyxx 10xxxxxx
-        if (i+2 >= str.length()) {
+    } else if ((c0 & 0xF0) == 0xE0) {  // 1110yyyy 10yyyyxx 10xxxxxx
+        if (i + 2 >= str.length()) {
             return JSONNET_CODEPOINT_ERROR;
         }
         char c1 = str[++i];
@@ -96,8 +96,8 @@ static inline char32_t decode_utf8(const std::string &str, size_t &i)
             return JSONNET_CODEPOINT_ERROR;
         }
         return ((c0 & 0xF) << 12ul) | ((c1 & 0x3F) << 6) | (c2 & 0x3F);
-    } else if ((c0 & 0xF8) == 0xF0) { //11110zzz 10zzyyyy 10yyyyxx 10xxxxxx
-        if (i+3 >= str.length()) {
+    } else if ((c0 & 0xF8) == 0xF0) {  // 11110zzz 10zzyyyy 10yyyyxx 10xxxxxx
+        if (i + 3 >= str.length()) {
             return JSONNET_CODEPOINT_ERROR;
         }
         char c1 = str[++i];
@@ -119,40 +119,53 @@ static inline char32_t decode_utf8(const std::string &str, size_t &i)
 }
 
 /** A string class capable of holding unicode codepoints. */
-typedef std::basic_string<char32_t> String;
+typedef std::basic_string<char32_t> UString;
 
-  
-static inline void encode_utf8(const String &s, std::string &r)
+static inline void encode_utf8(const UString &s, std::string &r)
 {
     for (char32_t cp : s)
         encode_utf8(cp, r);
 }
 
-static inline std::string encode_utf8(const String &s)
+static inline std::string encode_utf8(const UString &s)
 {
     std::string r;
     encode_utf8(s, r);
     return r;
 }
 
-static inline String decode_utf8(const std::string &s)
+static inline UString decode_utf8(const std::string &s)
 {
-    String r;
-    for (size_t i = 0; i < s.length(); ++i) 
+    UString r;
+    for (size_t i = 0; i < s.length(); ++i)
         r.push_back(decode_utf8(s, i));
     return r;
 }
 
-/** A stringstream-like class capable of holding unicode codepoints. 
+/** A stringstream-like class capable of holding unicode codepoints.
  * The C++ standard does not support std::basic_stringstream<char32_t.
  */
-class StringStream {
-    String buf;
-    public:
-    StringStream &operator << (const String &s) { buf.append(s); return *this; }
-    StringStream &operator << (const char32_t *s) { buf.append(s); return *this; }
-    StringStream &operator << (char32_t c) { buf.push_back(c); return *this; }
-    template<class T> StringStream &operator << (T c)
+class UStringStream {
+    UString buf;
+
+   public:
+    UStringStream &operator<<(const UString &s)
+    {
+        buf.append(s);
+        return *this;
+    }
+    UStringStream &operator<<(const char32_t *s)
+    {
+        buf.append(s);
+        return *this;
+    }
+    UStringStream &operator<<(char32_t c)
+    {
+        buf.push_back(c);
+        return *this;
+    }
+    template <class T>
+    UStringStream &operator<<(T c)
     {
         std::stringstream ss;
         ss << c;
@@ -160,7 +173,10 @@ class StringStream {
             buf.push_back(char32_t(c));
         return *this;
     }
-    String str() { return buf; }
+    UString str()
+    {
+        return buf;
+    }
 };
 
 #endif  // JSONNET_UNICODE_H
diff --git a/libjsonnet/core/vm.cpp b/libjsonnet/core/vm.cpp
index b9d86ea..d4ffc2a 100644
--- a/libjsonnet/core/vm.cpp
+++ b/libjsonnet/core/vm.cpp
@@ -21,9 +21,9 @@ limitations under the License.
 #include <set>
 #include <string>
 
-
 #include "desugarer.h"
 #include "json.h"
+#include "md5.h"
 #include "parser.h"
 #include "state.h"
 #include "static_analysis.h"
@@ -38,7 +38,7 @@ std::string dir_name(const std::string &path)
 {
     size_t last_slash = path.rfind('/');
     if (last_slash != std::string::npos) {
-        return path.substr(0, last_slash+1);
+        return path.substr(0, last_slash + 1);
     }
     return "";
 }
@@ -49,24 +49,25 @@ std::string dir_name(const std::string &path)
  * trace (for errors) displays.
  */
 enum FrameKind {
-    FRAME_APPLY_TARGET,  // e in e(...)
-    FRAME_BINARY_LEFT,  // a in a + b
-    FRAME_BINARY_RIGHT,  // b in a + b
-    FRAME_BUILTIN_FILTER,  // When executing std.filter, used to hold intermediate state.
+    FRAME_APPLY_TARGET,          // e in e(...)
+    FRAME_BINARY_LEFT,           // a in a + b
+    FRAME_BINARY_RIGHT,          // b in a + b
+    FRAME_BUILTIN_FILTER,        // When executing std.filter, used to hold intermediate state.
     FRAME_BUILTIN_FORCE_THUNKS,  // When forcing builtin args, holds intermediate state.
-    FRAME_CALL,  // Used any time we have switched location in user code.
-    FRAME_ERROR,  // e in error e
-    FRAME_IF,  // e in if e then a else b
-    FRAME_INDEX_TARGET,  // e in e[x]
-    FRAME_INDEX_INDEX,  // e in x[e]
-    FRAME_INVARIANTS,  // Caches the thunks that need to be executed one at a time.
-    FRAME_LOCAL,  // Stores thunk bindings as we execute e in local ...; e
+    FRAME_CALL,                  // Used any time we have switched location in user code.
+    FRAME_ERROR,                 // e in error e
+    FRAME_IF,                    // e in if e then a else b
+    FRAME_IN_SUPER_ELEMENT,      // e in 'e in super'
+    FRAME_INDEX_TARGET,          // e in e[x]
+    FRAME_INDEX_INDEX,           // e in x[e]
+    FRAME_INVARIANTS,            // Caches the thunks that need to be executed one at a time.
+    FRAME_LOCAL,                 // Stores thunk bindings as we execute e in local ...; e
     FRAME_OBJECT,  // Stores intermediate state as we execute es in { [e]: ..., [e]: ... }
-    FRAME_OBJECT_COMP_ARRAY,  // e in {f:a for x in e]
+    FRAME_OBJECT_COMP_ARRAY,    // e in {f:a for x in e]
     FRAME_OBJECT_COMP_ELEMENT,  // Stores intermediate state when building object
-    FRAME_STRING_CONCAT,  // Stores intermediate state while co-ercing objects
-    FRAME_SUPER_INDEX,  // e in super[e]
-    FRAME_UNARY,  // e in -e
+    FRAME_STRING_CONCAT,        // Stores intermediate state while co-ercing objects
+    FRAME_SUPER_INDEX,          // e in super[e]
+    FRAME_UNARY,                // e in -e
 };
 
 /** A frame on the stack.
@@ -89,7 +90,6 @@ enum FrameKind {
  * prematurely collected.
  */
 struct Frame {
-
     /** Tag (tagged union). */
     FrameKind kind;
 
@@ -121,13 +121,14 @@ struct Frame {
     unsigned elementId;
 
     /** Used for a variety of purposes. */
-    std::map<const Identifier *, HeapThunk*> elements;
+    std::map<const Identifier *, HeapThunk *> elements;
 
     /** Used for a variety of purposes. */
-    std::vector<HeapThunk*> thunks;
+    std::vector<HeapThunk *> thunks;
 
     /** The context is used in error messages to attempt to find a reasonable name for the
-     * object, function, or thunk value being executed.
+     * object, function, or thunk value being executed.  If it is a thunk, it is filled
+     * with the value when the frame terminates.
      */
     HeapEntity *context;
 
@@ -152,16 +153,28 @@ struct Frame {
     BindingFrame bindings;
 
     Frame(const FrameKind &kind, const AST *ast)
-      : kind(kind), ast(ast), location(ast->location), tailCall(false), elementId(0),
-        context(NULL), self(NULL), offset(0)
+        : kind(kind),
+          ast(ast),
+          location(ast->location),
+          tailCall(false),
+          elementId(0),
+          context(NULL),
+          self(NULL),
+          offset(0)
     {
         val.t = Value::NULL_TYPE;
         val2.t = Value::NULL_TYPE;
     }
 
     Frame(const FrameKind &kind, const LocationRange &location)
-      : kind(kind), ast(nullptr), location(location), tailCall(false), elementId(0),
-        context(NULL), self(NULL), offset(0)
+        : kind(kind),
+          ast(nullptr),
+          location(location),
+          tailCall(false),
+          elementId(0),
+          context(NULL),
+          self(NULL),
+          offset(0)
     {
         val.t = Value::NULL_TYPE;
         val2.t = Value::NULL_TYPE;
@@ -172,8 +185,10 @@ struct Frame {
     {
         heap.markFrom(val);
         heap.markFrom(val2);
-        if (context) heap.markFrom(context);
-        if (self) heap.markFrom(self);
+        if (context)
+            heap.markFrom(context);
+        if (self)
+            heap.markFrom(self);
         for (const auto &bind : bindings)
             heap.markFrom(bind.second);
         for (const auto &el : elements)
@@ -186,12 +201,10 @@ struct Frame {
     {
         return kind == FRAME_CALL;
     }
-
 };
 
 /** The stack holds all the stack frames and manages the stack frame limit. */
 class Stack {
-
     /** How many call frames are on the stack. */
     unsigned calls;
 
@@ -201,14 +214,10 @@ class Stack {
     /** The stack frames. */
     std::vector<Frame> stack;
 
-    public:
-
-    Stack(unsigned limit)
-      : calls(0), limit(limit)
-    {
-    }
+   public:
+    Stack(unsigned limit) : calls(0), limit(limit) {}
 
-    ~Stack(void) { }
+    ~Stack(void) {}
 
     unsigned size(void)
     {
@@ -218,13 +227,14 @@ class Stack {
     /** Search for the closest variable in scope that matches the given name. */
     HeapThunk *lookUpVar(const Identifier *id)
     {
-        for (int i=stack.size()-1 ; i>=0 ; --i) {
+        for (int i = stack.size() - 1; i >= 0; --i) {
             const auto &binds = stack[i].bindings;
             auto it = binds.find(id);
             if (it != binds.end()) {
                 return it->second;
             }
-            if (stack[i].isCall()) break;
+            if (stack[i].isCall())
+                break;
         }
         return nullptr;
     }
@@ -249,7 +259,8 @@ class Stack {
 
     void pop(void)
     {
-        if (top().isCall()) calls--;
+        if (top().isCall())
+            calls--;
         stack.pop_back();
     }
 
@@ -261,23 +272,28 @@ class Stack {
     std::string getName(unsigned from_here, const HeapEntity *e)
     {
         std::string name;
-        for (int i=from_here-1 ; i>=0; --i) {
+        for (int i = from_here - 1; i >= 0; --i) {
             const auto &f = stack[i];
             for (const auto &pair : f.bindings) {
                 HeapThunk *thunk = pair.second;
-                if (!thunk->filled) continue;
-                if (!thunk->content.isHeap()) continue;
-                if (e != thunk->content.v.h) continue;
+                if (!thunk->filled)
+                    continue;
+                if (!thunk->content.isHeap())
+                    continue;
+                if (e != thunk->content.v.h)
+                    continue;
                 name = encode_utf8(pair.first->name);
             }
             // Do not go into the next call frame, keep local reasoning.
-            if (f.isCall()) break;
+            if (f.isCall())
+                break;
         }
 
-        if (name == "") name = "anonymous";
-        if (dynamic_cast<const HeapObject*>(e)) {
+        if (name == "")
+            name = "anonymous";
+        if (dynamic_cast<const HeapObject *>(e)) {
             return "object <" + name + ">";
-        } else if (auto *thunk = dynamic_cast<const HeapThunk*>(e)) {
+        } else if (auto *thunk = dynamic_cast<const HeapThunk *>(e)) {
             if (thunk->name == nullptr) {
                 return "";  // Argument of builtin, or root (since top level functions).
             } else {
@@ -299,10 +315,9 @@ class Stack {
      */
     virtual void dump(void)
     {
-        for (unsigned i=0 ; i<stack.size() ; ++i) {
-            std::cout << "stack[" << i << "] = " << stack[i].location
-                      << " (" << stack[i].kind << ")"
-                      << std::endl;
+        for (unsigned i = 0; i < stack.size(); ++i) {
+            std::cout << "stack[" << i << "] = " << stack[i].location << " (" << stack[i].kind
+                      << ")" << std::endl;
         }
         std::cout << std::endl;
     }
@@ -313,12 +328,12 @@ class Stack {
     {
         std::vector<TraceFrame> stack_trace;
         stack_trace.push_back(TraceFrame(loc));
-        for (int i=stack.size()-1 ; i>=0 ; --i) {
+        for (int i = stack.size() - 1; i >= 0; --i) {
             const auto &f = stack[i];
             if (f.isCall()) {
                 if (f.context != nullptr) {
                     // Give the last line a name.
-                    stack_trace[stack_trace.size()-1].name = getName(i, f.context);
+                    stack_trace[stack_trace.size() - 1].name = getName(i, f.context);
                 }
                 if (f.location.isSet() || f.location.file.length() > 0)
                     stack_trace.push_back(TraceFrame(f.location));
@@ -328,22 +343,24 @@ class Stack {
     }
 
     /** New (non-call) frame. */
-    template <class... Args> void newFrame(Args... args)
+    template <class... Args>
+    void newFrame(Args... args)
     {
         stack.emplace_back(args...);
     }
 
     /** If there is a tailstrict annotated frame followed by some locals, pop them all. */
-    void tailCallTrimStack (void)
+    void tailCallTrimStack(void)
     {
-        for (int i=stack.size()-1 ; i>=0 ; --i) {
+        for (int i = stack.size() - 1; i >= 0; --i) {
             switch (stack[i].kind) {
                 case FRAME_CALL: {
                     if (!stack[i].tailCall || stack[i].thunks.size() > 0) {
                         return;
                     }
                     // Remove all stack frames including this one.
-                    while (stack.size() > unsigned(i)) stack.pop_back();
+                    while (stack.size() > unsigned(i))
+                        stack.pop_back();
                     calls--;
                     return;
                 } break;
@@ -356,8 +373,8 @@ class Stack {
     }
 
     /** New call frame. */
-    void newCall(const LocationRange &loc, HeapEntity *context, HeapObject *self,
-                 unsigned offset, const BindingFrame &up_values)
+    void newCall(const LocationRange &loc, HeapEntity *context, HeapObject *self, unsigned offset,
+                 const BindingFrame &up_values)
     {
         tailCallTrimStack();
         if (calls >= limit) {
@@ -371,7 +388,7 @@ class Stack {
         top().bindings = up_values;
         top().tailCall = false;
 
-        #ifndef NDEBUG
+#ifndef NDEBUG
         for (const auto &bind : up_values) {
             if (bind.second == nullptr) {
                 std::cerr << "INTERNAL ERROR: No binding for variable "
@@ -379,7 +396,7 @@ class Stack {
                 std::abort();
             }
         }
-        #endif
+#endif
     }
 
     /** Look up the stack to find the self binding. */
@@ -387,7 +404,7 @@ class Stack {
     {
         self = nullptr;
         offset = 0;
-        for (int i=stack.size() - 1 ; i>=0 ; --i) {
+        for (int i = stack.size() - 1; i >= 0; --i) {
             if (stack[i].isCall()) {
                 self = stack[i].self;
                 offset = stack[i].offset;
@@ -399,9 +416,10 @@ class Stack {
     /** Look up the stack to see if we're running assertions for this object. */
     bool alreadyExecutingInvariants(HeapObject *self)
     {
-        for (int i=stack.size() - 1 ; i>=0 ; --i) {
+        for (int i = stack.size() - 1; i >= 0; --i) {
             if (stack[i].kind == FRAME_INVARIANTS) {
-                if (stack[i].self == self) return true;
+                if (stack[i].self == self)
+                    return true;
             }
         }
         return false;
@@ -414,7 +432,6 @@ typedef std::map<std::string, VmExt> ExtMap;
 /** Typedef to save some typing. */
 typedef std::map<std::string, std::string> StrMap;
 
-
 class Interpreter;
 
 typedef const AST *(Interpreter::*BuiltinFunc)(const LocationRange &loc,
@@ -429,7 +446,6 @@ typedef const AST *(Interpreter::*BuiltinFunc)(const LocationRange &loc,
  * mark are removed from the heap.
  */
 class Interpreter {
-
     /** The heap. */
     Heap heap;
 
@@ -445,6 +461,9 @@ class Interpreter {
      */
     Allocator *alloc;
 
+    /** Used to "name" thunks created to cache imports. */
+    const Identifier *idImport;
+
     /** Used to "name" thunks created on the inside of an array. */
     const Identifier *idArrayElement;
 
@@ -460,11 +479,15 @@ class Interpreter {
     struct ImportCacheValue {
         std::string foundHere;
         std::string content;
+        /** Thunk to store cached result of execution.
+         *
+         * Null if this file was only ever successfully imported with importstr.
+         */
+        HeapThunk *thunk;
     };
 
     /** Cache for imported Jsonnet files. */
-    std::map<std::pair<std::string, String>,
-             const ImportCacheValue *> cachedImports;
+    std::map<std::pair<std::string, UString>, ImportCacheValue *> cachedImports;
 
     /** External variables for std.extVar. */
     ExtMap externalVars;
@@ -491,7 +514,8 @@ class Interpreter {
      * \param T Something under HeapEntity
      * \returns The new object
      */
-    template <class T, class... Args> T* makeHeap(Args&&... args)
+    template <class T, class... Args>
+    T *makeHeap(Args &&... args)
     {
         T *r = heap.makeEntity<T, Args...>(std::forward<Args>(args)...);
         if (heap.checkHeap()) {  // Do a GC cycle?
@@ -504,6 +528,13 @@ class Interpreter {
             // Mark from the scratch register
             heap.markFrom(scratch);
 
+            // Mark from cached imports
+            for (const auto &pair : cachedImports) {
+                HeapThunk *thunk = pair.second->thunk;
+                if (thunk != nullptr)
+                    heap.markFrom(thunk);
+            }
+
             // Delete unreachable objects.
             heap.sweep();
         }
@@ -518,15 +549,15 @@ class Interpreter {
         return r;
     }
 
-    Value makeDouble(double v)
+    Value makeNumber(double v)
     {
         Value r;
-        r.t = Value::DOUBLE;
+        r.t = Value::NUMBER;
         r.v.d = v;
         return r;
     }
 
-    Value makeDoubleCheck(const LocationRange &loc, double v)
+    Value makeNumberCheck(const LocationRange &loc, double v)
     {
         if (std::isnan(v)) {
             throw makeError(loc, "Not a number");
@@ -534,7 +565,7 @@ class Interpreter {
         if (std::isinf(v)) {
             throw makeError(loc, "Overflow");
         }
-        return makeDouble(v);
+        return makeNumber(v);
     }
 
     Value makeNull(void)
@@ -544,7 +575,7 @@ class Interpreter {
         return r;
     }
 
-    Value makeArray(const std::vector<HeapThunk*> &v)
+    Value makeArray(const std::vector<HeapThunk *> &v)
     {
         Value r;
         r.t = Value::ARRAY;
@@ -552,11 +583,8 @@ class Interpreter {
         return r;
     }
 
-    Value makeClosure(const BindingFrame &env,
-                       HeapObject *self,
-                       unsigned offset,
-                       const HeapClosure::Params &params,
-                       AST *body)
+    Value makeClosure(const BindingFrame &env, HeapObject *self, unsigned offset,
+                      const HeapClosure::Params &params, AST *body)
     {
         Value r;
         r.t = Value::FUNCTION;
@@ -582,7 +610,8 @@ class Interpreter {
         return r;
     }
 
-    template <class T, class... Args> Value makeObject(Args... args)
+    template <class T, class... Args>
+    Value makeObject(Args... args)
     {
         Value r;
         r.t = Value::OBJECT;
@@ -590,7 +619,7 @@ class Interpreter {
         return r;
     }
 
-    Value makeString(const String &v)
+    Value makeString(const UString &v)
     {
         Value r;
         r.t = Value::STRING;
@@ -608,22 +637,24 @@ class Interpreter {
      * \param counter Return the level of "super" that contained the field.
      * \returns The first object with the field, or nullptr if it could not be found.
      */
-    HeapLeafObject *findObject(const Identifier *f, HeapObject *curr,
-                               unsigned start_from, unsigned &counter)
+    HeapLeafObject *findObject(const Identifier *f, HeapObject *curr, unsigned start_from,
+                               unsigned &counter)
     {
-        if (auto *ext = dynamic_cast<HeapExtendedObject*>(curr)) {
+        if (auto *ext = dynamic_cast<HeapExtendedObject *>(curr)) {
             auto *r = findObject(f, ext->right, start_from, counter);
-            if (r) return r;
+            if (r)
+                return r;
             auto *l = findObject(f, ext->left, start_from, counter);
-            if (l) return l;
+            if (l)
+                return l;
         } else {
             if (counter >= start_from) {
-                if (auto *simp = dynamic_cast<HeapSimpleObject*>(curr)) {
+                if (auto *simp = dynamic_cast<HeapSimpleObject *>(curr)) {
                     auto it = simp->fields.find(f);
                     if (it != simp->fields.end()) {
                         return simp;
                     }
-                } else if (auto *comp = dynamic_cast<HeapComprehensionObject*>(curr)) {
+                } else if (auto *comp = dynamic_cast<HeapComprehensionObject *>(curr)) {
                     auto it = comp->compValues.find(f);
                     if (it != comp->compValues.end()) {
                         return comp;
@@ -635,19 +666,19 @@ class Interpreter {
         return nullptr;
     }
 
-    typedef std::map<const Identifier*, ObjectField::Hide> IdHideMap;
+    typedef std::map<const Identifier *, ObjectField::Hide> IdHideMap;
 
     /** Auxiliary function.
      */
     IdHideMap objectFieldsAux(const HeapObject *obj_)
     {
         IdHideMap r;
-        if (auto *obj = dynamic_cast<const HeapSimpleObject*>(obj_)) {
+        if (auto *obj = dynamic_cast<const HeapSimpleObject *>(obj_)) {
             for (const auto &f : obj->fields) {
                 r[f.first] = f.second.hide;
             }
 
-        } else if (auto *obj = dynamic_cast<const HeapExtendedObject*>(obj_)) {
+        } else if (auto *obj = dynamic_cast<const HeapExtendedObject *>(obj_)) {
             r = objectFieldsAux(obj->right);
             for (const auto &pair : objectFieldsAux(obj->left)) {
                 auto it = r.find(pair.first);
@@ -660,7 +691,7 @@ class Interpreter {
                 }
             }
 
-        } else if (auto *obj = dynamic_cast<const HeapComprehensionObject*>(obj_)) {
+        } else if (auto *obj = dynamic_cast<const HeapComprehensionObject *>(obj_)) {
             for (const auto &f : obj->compValues)
                 r[f.first] = ObjectField::VISIBLE;
         }
@@ -669,11 +700,12 @@ class Interpreter {
 
     /** Auxiliary function.
      */
-    std::set<const Identifier*> objectFields(const HeapObject *obj_, bool manifesting)
+    std::set<const Identifier *> objectFields(const HeapObject *obj_, bool manifesting)
     {
-        std::set<const Identifier*> r;
+        std::set<const Identifier *> r;
         for (const auto &pair : objectFieldsAux(obj_)) {
-            if (!manifesting || pair.second != ObjectField::HIDDEN) r.insert(pair.first);
+            if (!manifesting || pair.second != ObjectField::HIDDEN)
+                r.insert(pair.first);
         }
         return r;
     }
@@ -681,19 +713,25 @@ class Interpreter {
     /** Import another Jsonnet file.
      *
      * If the file has already been imported, then use that version.  This maintains
-     * referential transparency in the case of writes to disk during execution.
+     * referential transparency in the case of writes to disk during execution.  The
+     * cache holds a thunk in order to cache the resulting value of execution.
      *
      * \param loc Location of the import statement.
      * \param file Path to the filename.
      */
-    AST *import(const LocationRange &loc, const LiteralString *file)
+    HeapThunk *import(const LocationRange &loc, const LiteralString *file)
     {
-        const ImportCacheValue *input = importString(loc, file);
-        Tokens tokens = jsonnet_lex(input->foundHere, input->content.c_str());
-        AST *expr = jsonnet_parse(alloc, tokens);
-        jsonnet_desugar(alloc, expr, nullptr);
-        jsonnet_static_analysis(expr);
-        return expr;
+        ImportCacheValue *input = importString(loc, file);
+        if (input->thunk == nullptr) {
+            Tokens tokens = jsonnet_lex(input->foundHere, input->content.c_str());
+            AST *expr = jsonnet_parse(alloc, tokens);
+            jsonnet_desugar(alloc, expr, nullptr);
+            jsonnet_static_analysis(expr);
+            // If no errors then populate cache.
+            auto *thunk = makeHeap<HeapThunk>(idImport, nullptr, 0, expr);
+            input->thunk = thunk;
+        }
+        return input->thunk;
     }
 
     /** Import a file as a string.
@@ -705,22 +743,24 @@ class Interpreter {
      * \param file Path to the filename.
      * \param found_here If non-null, used to store the actual path of the file
      */
-    const ImportCacheValue *importString(const LocationRange &loc, const LiteralString *file)
+    ImportCacheValue *importString(const LocationRange &loc, const LiteralString *file)
     {
         std::string dir = dir_name(loc.file);
 
-        const String &path = file->value;
+        const UString &path = file->value;
 
-        std::pair<std::string, String> key(dir, path);
-        const ImportCacheValue *cached_value = cachedImports[key];
+        std::pair<std::string, UString> key(dir, path);
+        ImportCacheValue *cached_value = cachedImports[key];
         if (cached_value != nullptr)
             return cached_value;
 
         int success = 0;
         char *found_here_cptr;
-        char *content =
-            importCallback(importCallbackContext, dir.c_str(), encode_utf8(path).c_str(),
-                           &found_here_cptr, &success);
+        char *content = importCallback(importCallbackContext,
+                                       dir.c_str(),
+                                       encode_utf8(path).c_str(),
+                                       &found_here_cptr,
+                                       &success);
 
         std::string input(content);
         ::free(content);
@@ -734,13 +774,14 @@ class Interpreter {
         auto *input_ptr = new ImportCacheValue();
         input_ptr->foundHere = found_here_cptr;
         input_ptr->content = input;
+        input_ptr->thunk = nullptr;  // May be filled in later by import().
         ::free(found_here_cptr);
         cachedImports[key] = input_ptr;
         return input_ptr;
     }
 
     /** Capture the required variables from the environment. */
-    BindingFrame capture(const std::vector<const Identifier*> &free_vars)
+    BindingFrame capture(const std::vector<const Identifier *> &free_vars)
     {
         BindingFrame env;
         for (auto fv : free_vars) {
@@ -753,44 +794,39 @@ class Interpreter {
     /** Count the number of leaves in the tree.
      *
      * \param obj The root of the tree.
-     * \param counter Initialize to 0, returns the number of leaves.
+     * \returns The number of leaves.
      */
     unsigned countLeaves(HeapObject *obj)
     {
-        if (auto *ext = dynamic_cast<HeapExtendedObject*>(obj)) {
+        if (auto *ext = dynamic_cast<HeapExtendedObject *>(obj)) {
             return countLeaves(ext->left) + countLeaves(ext->right);
         } else {
+            // Must be a HeapLeafObject.
             return 1;
         }
     }
 
-    public:
-
+   public:
     /** Create a new interpreter.
      *
      * \param loc The location range of the file to be executed.
      */
-    Interpreter(
-        Allocator *alloc,
-        const ExtMap &ext_vars,
-        unsigned max_stack,
-        double gc_min_objects,
-        double gc_growth_trigger,
-        const VmNativeCallbackMap &native_callbacks,
-        JsonnetImportCallback *import_callback,
-        void *import_callback_context)
-
-      : heap(gc_min_objects, gc_growth_trigger),
-        stack(max_stack),
-        alloc(alloc),
-        idArrayElement(alloc->makeIdentifier(U"array_element")),
-        idInvariant(alloc->makeIdentifier(U"object_assert")),
-        idJsonObjVar(alloc->makeIdentifier(U"_")),
-        jsonObjVar(alloc->make<Var>(LocationRange(), Fodder{}, idJsonObjVar)),
-        externalVars(ext_vars),
-        nativeCallbacks(native_callbacks),
-        importCallback(import_callback),
-        importCallbackContext(import_callback_context)
+    Interpreter(Allocator *alloc, const ExtMap &ext_vars, unsigned max_stack, double gc_min_objects,
+                double gc_growth_trigger, const VmNativeCallbackMap &native_callbacks,
+                JsonnetImportCallback *import_callback, void *import_callback_context)
+
+        : heap(gc_min_objects, gc_growth_trigger),
+          stack(max_stack),
+          alloc(alloc),
+          idImport(alloc->makeIdentifier(U"import")),
+          idArrayElement(alloc->makeIdentifier(U"array_element")),
+          idInvariant(alloc->makeIdentifier(U"object_assert")),
+          idJsonObjVar(alloc->makeIdentifier(U"_")),
+          jsonObjVar(alloc->make<Var>(LocationRange(), Fodder{}, idJsonObjVar)),
+          externalVars(ext_vars),
+          nativeCallbacks(native_callbacks),
+          importCallback(import_callback),
+          importCallbackContext(import_callback_context)
     {
         scratch = makeNull();
         builtins["makeArray"] = &Interpreter::builtinMakeArray;
@@ -819,6 +855,7 @@ class Interpreter {
         builtins["extVar"] = &Interpreter::builtinExtVar;
         builtins["primitiveEquals"] = &Interpreter::builtinPrimitiveEquals;
         builtins["native"] = &Interpreter::builtinNative;
+        builtins["md5"] = &Interpreter::builtinMd5;
     }
 
     /** Clean up the heap, stack, stash, and builtin function ASTs. */
@@ -839,20 +876,18 @@ class Interpreter {
         scratch = v;
     }
 
-
     /** Raise an error if the arguments aren't the expected types. */
-    void validateBuiltinArgs(const LocationRange &loc,
-                             const std::string &name,
-                             const std::vector<Value> &args,
-                             const std::vector<Value::Type> params)
+    void validateBuiltinArgs(const LocationRange &loc, const std::string &name,
+                             const std::vector<Value> &args, const std::vector<Value::Type> params)
     {
         if (args.size() == params.size()) {
-            for (unsigned i=0 ; i<args.size() ; ++i) {
-                if (args[i].t != params[i]) goto bad;
+            for (unsigned i = 0; i < args.size(); ++i) {
+                if (args[i].t != params[i])
+                    goto bad;
             }
             return;
         }
-        bad:;
+    bad:;
         std::stringstream ss;
         ss << "Builtin function " + name + " expected (";
         const char *prefix = "";
@@ -873,30 +908,29 @@ class Interpreter {
     const AST *builtinMakeArray(const LocationRange &loc, const std::vector<Value> &args)
     {
         Frame &f = stack.top();
-        validateBuiltinArgs(loc, "makeArray", args,
-                            {Value::DOUBLE, Value::FUNCTION});
+        validateBuiltinArgs(loc, "makeArray", args, {Value::NUMBER, Value::FUNCTION});
         long sz = long(args[0].v.d);
         if (sz < 0) {
             std::stringstream ss;
             ss << "makeArray requires size >= 0, got " << sz;
             throw makeError(loc, ss.str());
         }
-        auto *func = static_cast<const HeapClosure*>(args[1].v.h);
-        std::vector<HeapThunk*> elements;
+        auto *func = static_cast<const HeapClosure *>(args[1].v.h);
+        std::vector<HeapThunk *> elements;
         if (func->params.size() != 1) {
             std::stringstream ss;
             ss << "makeArray function must take 1 param, got: " << func->params.size();
             throw makeError(loc, ss.str());
         }
         elements.resize(sz);
-        for (long i=0 ; i<sz ; ++i) {
+        for (long i = 0; i < sz; ++i) {
             auto *th = makeHeap<HeapThunk>(idArrayElement, func->self, func->offset, func->body);
             // The next line stops the new thunks from being GCed.
             f.thunks.push_back(th);
             th->upValues = func->upValues;
 
             auto *el = makeHeap<HeapThunk>(func->params[0].id, nullptr, 0, nullptr);
-            el->fill(makeDouble(i));  // i guaranteed not to be inf/NaN
+            el->fill(makeNumber(i));  // i guaranteed not to be inf/NaN
             th->upValues[func->params[0].id] = el;
             elements[i] = th;
         }
@@ -906,104 +940,90 @@ class Interpreter {
 
     const AST *builtinPow(const LocationRange &loc, const std::vector<Value> &args)
     {
-        validateBuiltinArgs(loc, "pow", args, {Value::DOUBLE, Value::DOUBLE});
-        scratch = makeDoubleCheck(loc, std::pow(args[0].v.d, args[1].v.d));
+        validateBuiltinArgs(loc, "pow", args, {Value::NUMBER, Value::NUMBER});
+        scratch = makeNumberCheck(loc, std::pow(args[0].v.d, args[1].v.d));
         return nullptr;
     }
 
     const AST *builtinFloor(const LocationRange &loc, const std::vector<Value> &args)
     {
-        validateBuiltinArgs(loc, "floor", args, {Value::DOUBLE});
-        scratch = makeDoubleCheck(loc, std::floor(args[0].v.d));
+        validateBuiltinArgs(loc, "floor", args, {Value::NUMBER});
+        scratch = makeNumberCheck(loc, std::floor(args[0].v.d));
         return nullptr;
     }
 
     const AST *builtinCeil(const LocationRange &loc, const std::vector<Value> &args)
     {
-        validateBuiltinArgs(loc, "ceil", args, {Value::DOUBLE});
-        scratch = makeDoubleCheck(loc, std::ceil(args[0].v.d));
+        validateBuiltinArgs(loc, "ceil", args, {Value::NUMBER});
+        scratch = makeNumberCheck(loc, std::ceil(args[0].v.d));
         return nullptr;
     }
 
     const AST *builtinSqrt(const LocationRange &loc, const std::vector<Value> &args)
     {
-        validateBuiltinArgs(loc, "sqrt", args, {Value::DOUBLE});
-        scratch = makeDoubleCheck(loc, std::sqrt(args[0].v.d));
+        validateBuiltinArgs(loc, "sqrt", args, {Value::NUMBER});
+        scratch = makeNumberCheck(loc, std::sqrt(args[0].v.d));
         return nullptr;
     }
 
     const AST *builtinSin(const LocationRange &loc, const std::vector<Value> &args)
     {
-        validateBuiltinArgs(loc, "sin", args, {Value::DOUBLE});
-        scratch = makeDoubleCheck(loc, std::sin(args[0].v.d));
+        validateBuiltinArgs(loc, "sin", args, {Value::NUMBER});
+        scratch = makeNumberCheck(loc, std::sin(args[0].v.d));
         return nullptr;
     }
 
     const AST *builtinCos(const LocationRange &loc, const std::vector<Value> &args)
     {
-        validateBuiltinArgs(loc, "cos", args, {Value::DOUBLE});
-        scratch = makeDoubleCheck(loc, std::cos(args[0].v.d));
+        validateBuiltinArgs(loc, "cos", args, {Value::NUMBER});
+        scratch = makeNumberCheck(loc, std::cos(args[0].v.d));
         return nullptr;
     }
 
     const AST *builtinTan(const LocationRange &loc, const std::vector<Value> &args)
     {
-        validateBuiltinArgs(loc, "tan", args, {Value::DOUBLE});
-        scratch = makeDoubleCheck(loc, std::tan(args[0].v.d));
+        validateBuiltinArgs(loc, "tan", args, {Value::NUMBER});
+        scratch = makeNumberCheck(loc, std::tan(args[0].v.d));
         return nullptr;
     }
 
     const AST *builtinAsin(const LocationRange &loc, const std::vector<Value> &args)
     {
-        validateBuiltinArgs(loc, "asin", args, {Value::DOUBLE});
-        scratch = makeDoubleCheck(loc, std::asin(args[0].v.d));
+        validateBuiltinArgs(loc, "asin", args, {Value::NUMBER});
+        scratch = makeNumberCheck(loc, std::asin(args[0].v.d));
         return nullptr;
     }
 
     const AST *builtinAcos(const LocationRange &loc, const std::vector<Value> &args)
     {
-        validateBuiltinArgs(loc, "acos", args, {Value::DOUBLE});
-        scratch = makeDoubleCheck(loc, std::acos(args[0].v.d));
+        validateBuiltinArgs(loc, "acos", args, {Value::NUMBER});
+        scratch = makeNumberCheck(loc, std::acos(args[0].v.d));
         return nullptr;
     }
 
     const AST *builtinAtan(const LocationRange &loc, const std::vector<Value> &args)
     {
-        validateBuiltinArgs(loc, "atan", args, {Value::DOUBLE});
-        scratch = makeDoubleCheck(loc, std::atan(args[0].v.d));
+        validateBuiltinArgs(loc, "atan", args, {Value::NUMBER});
+        scratch = makeNumberCheck(loc, std::atan(args[0].v.d));
         return nullptr;
     }
 
     const AST *builtinType(const LocationRange &, const std::vector<Value> &args)
     {
         switch (args[0].t) {
-            case Value::NULL_TYPE:
-            scratch = makeString(U"null");
-            return nullptr;
+            case Value::NULL_TYPE: scratch = makeString(U"null"); return nullptr;
 
-            case Value::BOOLEAN:
-            scratch = makeString(U"boolean");
-            return nullptr;
+            case Value::BOOLEAN: scratch = makeString(U"boolean"); return nullptr;
 
-            case Value::DOUBLE:
-            scratch = makeString(U"number");
-            return nullptr;
+            case Value::NUMBER: scratch = makeString(U"number"); return nullptr;
 
-            case Value::ARRAY:
-            scratch = makeString(U"array");
-            return nullptr;
+            case Value::ARRAY: scratch = makeString(U"array"); return nullptr;
 
-            case Value::FUNCTION:
-            scratch = makeString(U"function");
-            return nullptr;
+            case Value::FUNCTION: scratch = makeString(U"function"); return nullptr;
 
-            case Value::OBJECT:
-            scratch = makeString(U"object");
-            return nullptr;
+            case Value::OBJECT: scratch = makeString(U"object"); return nullptr;
 
-            case Value::STRING:
-            scratch = makeString(U"string");
-            return nullptr;
+            case Value::STRING: scratch = makeString(U"string"); return nullptr;
         }
         return nullptr;  // Quiet, compiler.
     }
@@ -1012,8 +1032,8 @@ class Interpreter {
     {
         Frame &f = stack.top();
         validateBuiltinArgs(loc, "filter", args, {Value::FUNCTION, Value::ARRAY});
-        auto *func = static_cast<HeapClosure*>(args[0].v.h);
-        auto *arr = static_cast<HeapArray*>(args[1].v.h);
+        auto *func = static_cast<HeapClosure *>(args[0].v.h);
+        auto *arr = static_cast<HeapArray *>(args[1].v.h);
         if (func->params.size() != 1) {
             throw makeError(loc, "filter function takes 1 parameter.");
         }
@@ -1037,11 +1057,10 @@ class Interpreter {
 
     const AST *builtinObjectHasEx(const LocationRange &loc, const std::vector<Value> &args)
     {
-        validateBuiltinArgs(loc, "objectHasEx", args,
-                            {Value::OBJECT, Value::STRING,
-                             Value::BOOLEAN});
-        const auto *obj = static_cast<const HeapObject*>(args[0].v.h);
-        const auto *str = static_cast<const HeapString*>(args[1].v.h);
+        validateBuiltinArgs(
+            loc, "objectHasEx", args, {Value::OBJECT, Value::STRING, Value::BOOLEAN});
+        const auto *obj = static_cast<const HeapObject *>(args[0].v.h);
+        const auto *str = static_cast<const HeapString *>(args[1].v.h);
         bool include_hidden = args[2].v.b;
         bool found = false;
         for (const auto &field : objectFields(obj, !include_hidden)) {
@@ -1052,7 +1071,7 @@ class Interpreter {
         }
         scratch = makeBoolean(found);
         return nullptr;
-    } 
+    }
 
     const AST *builtinLength(const LocationRange &loc, const std::vector<Value> &args)
     {
@@ -1062,70 +1081,68 @@ class Interpreter {
         HeapEntity *e = args[0].v.h;
         switch (args[0].t) {
             case Value::OBJECT: {
-                auto fields = objectFields(static_cast<HeapObject*>(e), true);
-                scratch = makeDouble(fields.size());
+                auto fields = objectFields(static_cast<HeapObject *>(e), true);
+                scratch = makeNumber(fields.size());
             } break;
 
             case Value::ARRAY:
-            scratch = makeDouble(static_cast<HeapArray*>(e)->elements.size());
-            break;
+                scratch = makeNumber(static_cast<HeapArray *>(e)->elements.size());
+                break;
 
             case Value::STRING:
-            scratch = makeDouble(static_cast<HeapString*>(e)->value.length());
-            break;
+                scratch = makeNumber(static_cast<HeapString *>(e)->value.length());
+                break;
 
             case Value::FUNCTION:
-            scratch = makeDouble(static_cast<HeapClosure*>(e)->params.size());
-            break;
+                scratch = makeNumber(static_cast<HeapClosure *>(e)->params.size());
+                break;
 
             default:
-            throw makeError(loc,
-                            "length operates on strings, objects, "
-                            "and arrays, got " + type_str(args[0]));
+                throw makeError(loc,
+                                "length operates on strings, objects, "
+                                "and arrays, got " +
+                                    type_str(args[0]));
         }
         return nullptr;
-    } 
+    }
 
     const AST *builtinObjectFieldsEx(const LocationRange &loc, const std::vector<Value> &args)
     {
-        validateBuiltinArgs(loc, "objectFieldsEx", args,
-                            {Value::OBJECT, Value::BOOLEAN});
-        const auto *obj = static_cast<HeapObject*>(args[0].v.h);
+        validateBuiltinArgs(loc, "objectFieldsEx", args, {Value::OBJECT, Value::BOOLEAN});
+        const auto *obj = static_cast<HeapObject *>(args[0].v.h);
         bool include_hidden = args[1].v.b;
         // Stash in a set first to sort them.
-        std::set<String> fields;
+        std::set<UString> fields;
         for (const auto &field : objectFields(obj, !include_hidden)) {
             fields.insert(field->name);
         }
         scratch = makeArray({});
-        auto &elements = static_cast<HeapArray*>(scratch.v.h)->elements;
+        auto &elements = static_cast<HeapArray *>(scratch.v.h)->elements;
         for (const auto &field : fields) {
             auto *th = makeHeap<HeapThunk>(idArrayElement, nullptr, 0, nullptr);
             elements.push_back(th);
             th->fill(makeString(field));
         }
         return nullptr;
-    } 
+    }
 
     const AST *builtinCodepoint(const LocationRange &loc, const std::vector<Value> &args)
     {
         validateBuiltinArgs(loc, "codepoint", args, {Value::STRING});
-        const String &str =
-            static_cast<HeapString*>(args[0].v.h)->value;
+        const UString &str = static_cast<HeapString *>(args[0].v.h)->value;
         if (str.length() != 1) {
             std::stringstream ss;
-            ss << "codepoint takes a string of length 1, got length "
-               << str.length();
+            ss << "codepoint takes a string of length 1, got length " << str.length();
             throw makeError(loc, ss.str());
         }
-        char32_t c = static_cast<HeapString*>(args[0].v.h)->value[0];
-        scratch = makeDouble((unsigned long)(c));
+        char32_t c = static_cast<HeapString *>(args[0].v.h)->value[0];
+        scratch = makeNumber((unsigned long)(c));
         return nullptr;
-    } 
+    }
 
     const AST *builtinChar(const LocationRange &loc, const std::vector<Value> &args)
     {
-        validateBuiltinArgs(loc, "char", args, {Value::DOUBLE});
+        validateBuiltinArgs(loc, "char", args, {Value::NUMBER});
         long l = long(args[0].v.d);
         if (l < 0) {
             std::stringstream ss;
@@ -1138,58 +1155,57 @@ class Interpreter {
             throw makeError(loc, ss.str());
         }
         char32_t c = l;
-        scratch = makeString(String(&c, 1));
+        scratch = makeString(UString(&c, 1));
         return nullptr;
-    } 
+    }
 
     const AST *builtinLog(const LocationRange &loc, const std::vector<Value> &args)
     {
-        validateBuiltinArgs(loc, "log", args, {Value::DOUBLE});
-        scratch = makeDoubleCheck(loc, std::log(args[0].v.d));
+        validateBuiltinArgs(loc, "log", args, {Value::NUMBER});
+        scratch = makeNumberCheck(loc, std::log(args[0].v.d));
         return nullptr;
-    } 
+    }
 
     const AST *builtinExp(const LocationRange &loc, const std::vector<Value> &args)
     {
-        validateBuiltinArgs(loc, "exp", args, {Value::DOUBLE});
-        scratch = makeDoubleCheck(loc, std::exp(args[0].v.d));
+        validateBuiltinArgs(loc, "exp", args, {Value::NUMBER});
+        scratch = makeNumberCheck(loc, std::exp(args[0].v.d));
         return nullptr;
-    } 
+    }
 
     const AST *builtinMantissa(const LocationRange &loc, const std::vector<Value> &args)
     {
-        validateBuiltinArgs(loc, "mantissa", args, {Value::DOUBLE});
+        validateBuiltinArgs(loc, "mantissa", args, {Value::NUMBER});
         int exp;
         double m = std::frexp(args[0].v.d, &exp);
-        scratch = makeDoubleCheck(loc, m);
+        scratch = makeNumberCheck(loc, m);
         return nullptr;
-    } 
+    }
 
     const AST *builtinExponent(const LocationRange &loc, const std::vector<Value> &args)
     {
-        validateBuiltinArgs(loc, "exponent", args, {Value::DOUBLE});
+        validateBuiltinArgs(loc, "exponent", args, {Value::NUMBER});
         int exp;
         std::frexp(args[0].v.d, &exp);
-        scratch = makeDoubleCheck(loc, exp);
+        scratch = makeNumberCheck(loc, exp);
         return nullptr;
-    } 
+    }
 
     const AST *builtinModulo(const LocationRange &loc, const std::vector<Value> &args)
     {
-        validateBuiltinArgs(loc, "modulo", args, {Value::DOUBLE, Value::DOUBLE});
+        validateBuiltinArgs(loc, "modulo", args, {Value::NUMBER, Value::NUMBER});
         double a = args[0].v.d;
         double b = args[1].v.d;
         if (b == 0)
             throw makeError(loc, "Division by zero.");
-        scratch = makeDoubleCheck(loc, std::fmod(a, b));
+        scratch = makeNumberCheck(loc, std::fmod(a, b));
         return nullptr;
-    } 
+    }
 
     const AST *builtinExtVar(const LocationRange &loc, const std::vector<Value> &args)
     {
         validateBuiltinArgs(loc, "extVar", args, {Value::STRING});
-        const String &var =
-            static_cast<HeapString*>(args[0].v.h)->value;
+        const UString &var = static_cast<HeapString *>(args[0].v.h)->value;
         std::string var8 = encode_utf8(var);
         auto it = externalVars.find(var8);
         if (it == externalVars.end()) {
@@ -1209,7 +1225,7 @@ class Interpreter {
             scratch = makeString(decode_utf8(ext.data));
             return nullptr;
         }
-    } 
+    }
 
     const AST *builtinPrimitiveEquals(const LocationRange &loc, const std::vector<Value> &args)
     {
@@ -1224,41 +1240,34 @@ class Interpreter {
         }
         bool r;
         switch (args[0].t) {
-            case Value::BOOLEAN:
-            r = args[0].v.b == args[1].v.b;
-            break;
+            case Value::BOOLEAN: r = args[0].v.b == args[1].v.b; break;
 
-            case Value::DOUBLE:
-            r = args[0].v.d == args[1].v.d;
-            break;
+            case Value::NUMBER: r = args[0].v.d == args[1].v.d; break;
 
             case Value::STRING:
-            r = static_cast<HeapString*>(args[0].v.h)->value
-              == static_cast<HeapString*>(args[1].v.h)->value;
-            break;
+                r = static_cast<HeapString *>(args[0].v.h)->value ==
+                    static_cast<HeapString *>(args[1].v.h)->value;
+                break;
 
-            case Value::NULL_TYPE:
-            r = true;
-            break;
+            case Value::NULL_TYPE: r = true; break;
 
-            case Value::FUNCTION:
-            throw makeError(loc, "Cannot test equality of functions");
-            break;
+            case Value::FUNCTION: throw makeError(loc, "Cannot test equality of functions"); break;
 
             default:
-            throw makeError(loc,
-                            "primitiveEquals operates on primitive "
-                            "types, got " + type_str(args[0]));
+                throw makeError(loc,
+                                "primitiveEquals operates on primitive "
+                                "types, got " +
+                                    type_str(args[0]));
         }
         scratch = makeBoolean(r);
         return nullptr;
-    } 
+    }
 
     const AST *builtinNative(const LocationRange &loc, const std::vector<Value> &args)
     {
         validateBuiltinArgs(loc, "native", args, {Value::STRING});
 
-        std::string builtin_name = encode_utf8(static_cast<HeapString*>(args[0].v.h)->value);
+        std::string builtin_name = encode_utf8(static_cast<HeapString *>(args[0].v.h)->value);
 
         VmNativeCallbackMap::const_iterator nit = nativeCallbacks.find(builtin_name);
         if (nit == nativeCallbacks.end()) {
@@ -1268,62 +1277,73 @@ class Interpreter {
         const VmNativeCallback &cb = nit->second;
         scratch = makeNativeBuiltin(builtin_name, cb.params);
         return nullptr;
-    } 
+    }
+
+    const AST *builtinMd5(const LocationRange &loc, const std::vector<Value> &args)
+    {
+        validateBuiltinArgs(loc, "md5", args, {Value::STRING});
+
+        std::string value = encode_utf8(static_cast<HeapString *>(args[0].v.h)->value);
+
+        scratch = makeString(decode_utf8(md5(value)));
+        return nullptr;
+    }
 
-    void jsonToHeap(const std::unique_ptr<JsonnetJsonValue> &v, Value &attach)
+    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
         // making the heap object.
         switch (v->kind) {
             case JsonnetJsonValue::STRING:
-            attach = makeString(decode_utf8(v->string));
-            break;
+                attach = makeString(decode_utf8(v->string));
+                filled = true;
+                break;
 
             case JsonnetJsonValue::BOOL:
-            attach = makeBoolean(v->number != 0.0);
-            break;
+                attach = makeBoolean(v->number != 0.0);
+                filled = true;
+                break;
 
             case JsonnetJsonValue::NUMBER:
-            attach = makeDouble(v->number);
-            break;
+                attach = makeNumber(v->number);
+                filled = true;
+                break;
 
             case JsonnetJsonValue::NULL_KIND:
-            attach = makeNull();
-            break;
+                attach = makeNull();
+                filled = true;
+                break;
 
             case JsonnetJsonValue::ARRAY: {
-                attach = makeArray(std::vector<HeapThunk*>{});
-                auto *arr = static_cast<HeapArray*>(attach.v.h);
-                for (size_t i = 0; i < v->elements.size() ; ++i) {
+                attach = makeArray(std::vector<HeapThunk *>{});
+                filled = true;
+                auto *arr = static_cast<HeapArray *>(attach.v.h);
+                for (size_t i = 0; i < v->elements.size(); ++i) {
                     arr->elements.push_back(
                         makeHeap<HeapThunk>(idArrayElement, nullptr, 0, nullptr));
-                    arr->elements[i]->filled = true;
-                    jsonToHeap(v->elements[i], arr->elements[i]->content);
+                    jsonToHeap(v->elements[i], arr->elements[i]->filled, arr->elements[i]->content);
                 }
             } break;
 
             case JsonnetJsonValue::OBJECT: {
                 attach = makeObject<HeapComprehensionObject>(
                     BindingFrame{}, jsonObjVar, idJsonObjVar, BindingFrame{});
-                auto *obj = static_cast<HeapComprehensionObject*>(attach.v.h);
+                filled = true;
+                auto *obj = static_cast<HeapComprehensionObject *>(attach.v.h);
                 for (const auto &pair : v->fields) {
                     auto *thunk = makeHeap<HeapThunk>(idJsonObjVar, nullptr, 0, nullptr);
                     obj->compValues[alloc->makeIdentifier(decode_utf8(pair.first))] = thunk;
-                    thunk->filled = true;
-                    jsonToHeap(pair.second, thunk->content);
+                    jsonToHeap(pair.second, thunk->filled, thunk->content);
                 }
             } break;
         }
     }
 
-
-    String toString(const LocationRange &loc)
+    UString toString(const LocationRange &loc)
     {
         return manifestJson(loc, false, U"");
     }
 
-
-
     /** Recursively collect an object's invariants.
      *
      * \param curr
@@ -1331,14 +1351,14 @@ class Interpreter {
      * \param offset
      * \param thunks
      */
-    void objectInvariants(HeapObject *curr, HeapObject *self,
-                          unsigned &counter, std::vector<HeapThunk*> &thunks)
+    void objectInvariants(HeapObject *curr, HeapObject *self, unsigned &counter,
+                          std::vector<HeapThunk *> &thunks)
     {
-        if (auto *ext = dynamic_cast<HeapExtendedObject*>(curr)) {
+        if (auto *ext = dynamic_cast<HeapExtendedObject *>(curr)) {
             objectInvariants(ext->right, self, counter, thunks);
             objectInvariants(ext->left, self, counter, thunks);
         } else {
-            if (auto *simp = dynamic_cast<HeapSimpleObject*>(curr)) {
+            if (auto *simp = dynamic_cast<HeapSimpleObject *>(curr)) {
                 for (AST *assert : simp->asserts) {
                     auto *el_th = makeHeap<HeapThunk>(idInvariant, self, counter, assert);
                     el_th->upValues = simp->upValues;
@@ -1355,8 +1375,8 @@ class Interpreter {
      * \param obj The target
      * \param f The field
      */
-    const AST *objectIndex(const LocationRange &loc, HeapObject *obj,
-                           const Identifier *f, unsigned offset)
+    const AST *objectIndex(const LocationRange &loc, HeapObject *obj, const Identifier *f,
+                           unsigned offset)
     {
         unsigned found_at = 0;
         HeapObject *self = obj;
@@ -1364,7 +1384,7 @@ class Interpreter {
         if (found == nullptr) {
             throw makeError(loc, "Field does not exist: " + encode_utf8(f->name));
         }
-        if (auto *simp = dynamic_cast<HeapSimpleObject*>(found)) {
+        if (auto *simp = dynamic_cast<HeapSimpleObject *>(found)) {
             auto it = simp->fields.find(f);
             const AST *body = it->second.body;
 
@@ -1372,7 +1392,7 @@ class Interpreter {
             return body;
         } else {
             // If a HeapLeafObject is not HeapSimpleObject, it must be HeapComprehensionObject.
-            auto *comp = static_cast<HeapComprehensionObject*>(found);
+            auto *comp = static_cast<HeapComprehensionObject *>(found);
             auto it = comp->compValues.find(f);
             auto *th = it->second;
             BindingFrame binds = comp->upValues;
@@ -1384,12 +1404,13 @@ class Interpreter {
 
     void runInvariants(const LocationRange &loc, HeapObject *self)
     {
-        if (stack.alreadyExecutingInvariants(self)) return;
+        if (stack.alreadyExecutingInvariants(self))
+            return;
 
         unsigned counter = 0;
         unsigned initial_stack_size = stack.size();
         stack.newFrame(FRAME_INVARIANTS, loc);
-        std::vector<HeapThunk*> &thunks = stack.top().thunks;
+        std::vector<HeapThunk *> &thunks = stack.top().thunks;
         objectInvariants(self, self, counter, thunks);
         if (thunks.size() == 0) {
             stack.pop();
@@ -1416,39 +1437,39 @@ class Interpreter {
      */
     void evaluate(const AST *ast_, unsigned initial_stack_size)
     {
-        recurse:
+    recurse:
 
         switch (ast_->type) {
             case AST_APPLY: {
-                const auto &ast = *static_cast<const Apply*>(ast_);
+                const auto &ast = *static_cast<const Apply *>(ast_);
                 stack.newFrame(FRAME_APPLY_TARGET, ast_);
                 ast_ = ast.target;
                 goto recurse;
             } break;
 
             case AST_ARRAY: {
-                const auto &ast = *static_cast<const Array*>(ast_);
+                const auto &ast = *static_cast<const Array *>(ast_);
                 HeapObject *self;
                 unsigned offset;
                 stack.getSelfBinding(self, offset);
                 scratch = makeArray({});
-                auto &elements = static_cast<HeapArray*>(scratch.v.h)->elements;
+                auto &elements = static_cast<HeapArray *>(scratch.v.h)->elements;
                 for (const auto &el : ast.elements) {
                     auto *el_th = makeHeap<HeapThunk>(idArrayElement, self, offset, el.expr);
-                    el_th->upValues =  capture(el.expr->freeVariables);
+                    el_th->upValues = capture(el.expr->freeVariables);
                     elements.push_back(el_th);
                 }
             } break;
 
             case AST_BINARY: {
-                const auto &ast = *static_cast<const Binary*>(ast_);
+                const auto &ast = *static_cast<const Binary *>(ast_);
                 stack.newFrame(FRAME_BINARY_LEFT, ast_);
                 ast_ = ast.left;
                 goto recurse;
             } break;
 
             case AST_BUILTIN_FUNCTION: {
-                const auto &ast = *static_cast<const BuiltinFunction*>(ast_);
+                const auto &ast = *static_cast<const BuiltinFunction *>(ast_);
                 HeapClosure::Params params;
                 params.reserve(ast.params.size());
                 for (const auto &p : ast.params) {
@@ -1459,21 +1480,21 @@ class Interpreter {
             } break;
 
             case AST_CONDITIONAL: {
-                const auto &ast = *static_cast<const Conditional*>(ast_);
+                const auto &ast = *static_cast<const Conditional *>(ast_);
                 stack.newFrame(FRAME_IF, ast_);
                 ast_ = ast.cond;
                 goto recurse;
             } break;
 
             case AST_ERROR: {
-                const auto &ast = *static_cast<const Error*>(ast_);
+                const auto &ast = *static_cast<const Error *>(ast_);
                 stack.newFrame(FRAME_ERROR, ast_);
                 ast_ = ast.expr;
                 goto recurse;
             } break;
 
             case AST_FUNCTION: {
-                const auto &ast = *static_cast<const Function*>(ast_);
+                const auto &ast = *static_cast<const Function *>(ast_);
                 auto env = capture(ast.freeVariables);
                 HeapObject *self;
                 unsigned offset;
@@ -1487,28 +1508,39 @@ class Interpreter {
             } break;
 
             case AST_IMPORT: {
-                const auto &ast = *static_cast<const Import*>(ast_);
-                AST *expr = import(ast.location, ast.file);
-                ast_ = expr;
-                stack.newCall(ast.location, nullptr, nullptr, 0, BindingFrame());
-                goto recurse;
+                const auto &ast = *static_cast<const Import *>(ast_);
+                HeapThunk *thunk = import(ast.location, ast.file);
+                if (thunk->filled) {
+                    scratch = thunk->content;
+                } else {
+                    stack.newCall(ast.location, thunk, thunk->self, thunk->offset, thunk->upValues);
+                    ast_ = thunk->body;
+                    goto recurse;
+                }
             } break;
 
             case AST_IMPORTSTR: {
-                const auto &ast = *static_cast<const Importstr*>(ast_);
+                const auto &ast = *static_cast<const Importstr *>(ast_);
                 const ImportCacheValue *value = importString(ast.location, ast.file);
                 scratch = makeString(decode_utf8(value->content));
             } break;
 
+            case AST_IN_SUPER: {
+                const auto &ast = *static_cast<const InSuper *>(ast_);
+                stack.newFrame(FRAME_IN_SUPER_ELEMENT, ast_);
+                ast_ = ast.element;
+                goto recurse;
+            } break;
+
             case AST_INDEX: {
-                const auto &ast = *static_cast<const Index*>(ast_);
+                const auto &ast = *static_cast<const Index *>(ast_);
                 stack.newFrame(FRAME_INDEX_TARGET, ast_);
                 ast_ = ast.target;
                 goto recurse;
             } break;
 
             case AST_LOCAL: {
-                const auto &ast = *static_cast<const Local*>(ast_);
+                const auto &ast = *static_cast<const Local *>(ast_);
                 stack.newFrame(FRAME_LOCAL, ast_);
                 Frame &f = stack.top();
                 // First build all the thunks and bind them.
@@ -1531,17 +1563,17 @@ class Interpreter {
             } break;
 
             case AST_LITERAL_BOOLEAN: {
-                const auto &ast = *static_cast<const LiteralBoolean*>(ast_);
+                const auto &ast = *static_cast<const LiteralBoolean *>(ast_);
                 scratch = makeBoolean(ast.value);
             } break;
 
             case AST_LITERAL_NUMBER: {
-                const auto &ast = *static_cast<const LiteralNumber*>(ast_);
-                scratch = makeDoubleCheck(ast_->location, ast.value);
+                const auto &ast = *static_cast<const LiteralNumber *>(ast_);
+                scratch = makeNumberCheck(ast_->location, ast.value);
             } break;
 
             case AST_LITERAL_STRING: {
-                const auto &ast = *static_cast<const LiteralString*>(ast_);
+                const auto &ast = *static_cast<const LiteralString *>(ast_);
                 scratch = makeString(ast.value);
             } break;
 
@@ -1550,7 +1582,7 @@ class Interpreter {
             } break;
 
             case AST_DESUGARED_OBJECT: {
-                const auto &ast = *static_cast<const DesugaredObject*>(ast_);
+                const auto &ast = *static_cast<const DesugaredObject *>(ast_);
                 if (ast.fields.empty()) {
                     auto env = capture(ast.freeVariables);
                     std::map<const Identifier *, HeapSimpleObject::Field> fields;
@@ -1566,7 +1598,7 @@ class Interpreter {
             } break;
 
             case AST_OBJECT_COMPREHENSION_SIMPLE: {
-                const auto &ast = *static_cast<const ObjectComprehensionSimple*>(ast_);
+                const auto &ast = *static_cast<const ObjectComprehensionSimple *>(ast_);
                 stack.newFrame(FRAME_OBJECT_COMP_ARRAY, ast_);
                 ast_ = ast.array;
                 goto recurse;
@@ -1581,21 +1613,21 @@ class Interpreter {
             } break;
 
             case AST_SUPER_INDEX: {
-                const auto &ast = *static_cast<const SuperIndex*>(ast_);
+                const auto &ast = *static_cast<const SuperIndex *>(ast_);
                 stack.newFrame(FRAME_SUPER_INDEX, ast_);
                 ast_ = ast.index;
                 goto recurse;
             } break;
 
             case AST_UNARY: {
-                const auto &ast = *static_cast<const Unary*>(ast_);
+                const auto &ast = *static_cast<const Unary *>(ast_);
                 stack.newFrame(FRAME_UNARY, ast_);
                 ast_ = ast.expr;
                 goto recurse;
             } break;
 
             case AST_VAR: {
-                const auto &ast = *static_cast<const Var*>(ast_);
+                const auto &ast = *static_cast<const Var *>(ast_);
                 auto *thunk = stack.lookUpVar(ast.id);
                 if (thunk == nullptr) {
                     std::cerr << "INTERNAL ERROR: Could not bind variable: "
@@ -1612,8 +1644,8 @@ class Interpreter {
             } break;
 
             default:
-            std::cerr << "INTERNAL ERROR: Unknown AST: " << ast_->type << std::endl;
-            std::abort();
+                std::cerr << "INTERNAL ERROR: Unknown AST: " << ast_->type << std::endl;
+                std::abort();
         }
 
         // To evaluate another AST, set ast to it, then goto recurse.
@@ -1623,13 +1655,12 @@ class Interpreter {
             Frame &f = stack.top();
             switch (f.kind) {
                 case FRAME_APPLY_TARGET: {
-                    const auto &ast = *static_cast<const Apply*>(f.ast);
+                    const auto &ast = *static_cast<const Apply *>(f.ast);
                     if (scratch.t != Value::FUNCTION) {
                         throw makeError(ast.location,
-                                        "Only functions can be called, got "
-                                        + type_str(scratch));
+                                        "Only functions can be called, got " + type_str(scratch));
                     }
-                    auto *func = static_cast<HeapClosure*>(scratch.v.h);
+                    auto *func = static_cast<HeapClosure *>(scratch.v.h);
 
                     std::set<const Identifier *> params_needed;
                     for (const auto &param : func->params) {
@@ -1637,10 +1668,10 @@ class Interpreter {
                     }
 
                     // Create thunks for arguments.
-                    std::vector<HeapThunk*> positional_args;
+                    std::vector<HeapThunk *> positional_args;
                     BindingFrame args;
                     bool got_named = false;
-                    for (unsigned i=0 ; i<ast.args.size() ; ++i) {
+                    for (unsigned i = 0; i < ast.args.size(); ++i) {
                         const auto &arg = ast.args[i];
 
                         const Identifier *name;
@@ -1692,21 +1723,22 @@ class Interpreter {
 
                     // Raise errors for unbound params, create thunks (but don't fill in upvalues).
                     // This is a subset of f.thunks, so will not get garbage collected.
-                    std::vector<HeapThunk*> def_arg_thunks;
+                    std::vector<HeapThunk *> def_arg_thunks;
                     for (const auto &param : func->params) {
-                        if (args.find(param.id) != args.end()) continue;
+                        if (args.find(param.id) != args.end())
+                            continue;
                         if (param.def == nullptr) {
                             std::stringstream ss;
-                            ss << "Function parameter " << encode_utf8(param.id->name) <<
-                                  " not bound in call.";
+                            ss << "Function parameter " << encode_utf8(param.id->name)
+                               << " not bound in call.";
                             throw makeError(ast.location, ss.str());
                         }
 
                         // Special case for builtin functions -- leave identifier blank for
                         // them in the thunk.  This removes the thunk frame from the stacktrace.
                         const Identifier *name_ = func->body == nullptr ? nullptr : param.id;
-                        auto *thunk = makeHeap<HeapThunk>(name_, func->self, func->offset,
-                                                          param.def);
+                        auto *thunk =
+                            makeHeap<HeapThunk>(name_, func->self, func->offset, param.def);
                         f.thunks.push_back(thunk);
                         def_arg_thunks.push_back(thunk);
                         args[param.id] = thunk;
@@ -1721,7 +1753,7 @@ class Interpreter {
                     }
 
                     // Cache these, because pop will invalidate them.
-                    std::vector<HeapThunk*> thunks_copy = f.thunks;
+                    std::vector<HeapThunk *> thunks_copy = f.thunks;
 
                     stack.pop();
 
@@ -1756,7 +1788,7 @@ class Interpreter {
                 } break;
 
                 case FRAME_BINARY_LEFT: {
-                    const auto &ast = *static_cast<const Binary*>(f.ast);
+                    const auto &ast = *static_cast<const Binary *>(f.ast);
                     const Value &lhs = scratch;
                     if (lhs.t == Value::BOOLEAN) {
                         // Handle short-cut semantics
@@ -1785,9 +1817,11 @@ class Interpreter {
                 } break;
 
                 case FRAME_BINARY_RIGHT: {
-                    const auto &ast = *static_cast<const Binary*>(f.ast);
+                    const auto &ast = *static_cast<const Binary *>(f.ast);
                     const Value &lhs = stack.top().val;
                     const Value &rhs = scratch;
+
+                    // Handle cases where the LHS and RHS are not the same type.
                     if (lhs.t == Value::STRING || rhs.t == Value::STRING) {
                         if (ast.op == BOP_PLUS) {
                             // Handle co-ercions for string processing.
@@ -1796,201 +1830,212 @@ class Interpreter {
                             goto replaceframe;
                         }
                     }
-                    // Equality can be used when the types don't match.
                     switch (ast.op) {
+                        // Equality can be used when the types don't match.
                         case BOP_MANIFEST_EQUAL:
-                        std::cerr << "INTERNAL ERROR: Equals not desugared" << std::endl;
-                        abort();
+                            std::cerr << "INTERNAL ERROR: Equals not desugared" << std::endl;
+                            abort();
 
+                        // Equality can be used when the types don't match.
                         case BOP_MANIFEST_UNEQUAL:
-                        std::cerr << "INTERNAL ERROR: Notequals not desugared" << std::endl;
-                        abort();
+                            std::cerr << "INTERNAL ERROR: Notequals not desugared" << std::endl;
+                            abort();
+
+                        // e in e
+                        case BOP_IN: {
+                            if (lhs.t != Value::STRING) {
+                                throw makeError(ast.location,
+                                                "The left hand side of the 'in' operator should be "
+                                                "a string,  got " +
+                                                    type_str(lhs));
+                            }
+                            auto *field = static_cast<HeapString *>(lhs.v.h);
+                            switch (rhs.t) {
+                                case Value::OBJECT: {
+                                    auto *obj = static_cast<HeapObject *>(rhs.v.h);
+                                    auto *fid = alloc->makeIdentifier(field->value);
+                                    unsigned unused_found_at = 0;
+                                    bool in = findObject(fid, obj, 0, unused_found_at);
+                                    scratch = makeBoolean(in);
+                                } break;
+
+                                default:
+                                    throw makeError(
+                                        ast.location,
+                                        "The right hand side of the 'in' operator should be"
+                                        " an object, got " +
+                                            type_str(rhs));
+                            }
+                            goto popframe;
+                        }
 
                         default:;
                     }
                     // Everything else requires matching types.
                     if (lhs.t != rhs.t) {
                         throw makeError(ast.location,
-                                        "Binary operator " + bop_string(ast.op) + " requires "
-                                        "matching types, got " + type_str(lhs) + " and " +
-                                        type_str(rhs) + ".");
+                                        "Binary operator " + bop_string(ast.op) +
+                                            " requires "
+                                            "matching types, got " +
+                                            type_str(lhs) + " and " + type_str(rhs) + ".");
                     }
                     switch (lhs.t) {
                         case Value::ARRAY:
-                        if (ast.op == BOP_PLUS) {
-                            auto *arr_l = static_cast<HeapArray*>(lhs.v.h);
-                            auto *arr_r = static_cast<HeapArray*>(rhs.v.h);
-                            std::vector<HeapThunk*> elements;
-                            for (auto *el : arr_l->elements)
-                                elements.push_back(el);
-                            for (auto *el : arr_r->elements)
-                                elements.push_back(el);
-                            scratch = makeArray(elements);
-                        } else {
-                            throw makeError(ast.location,
-                                            "Binary operator " + bop_string(ast.op)
-                                            + " does not operate on arrays.");
-                        }
-                        break;
-
-                        case Value::BOOLEAN:
-                        switch (ast.op) {
-                            case BOP_AND:
-                            scratch = makeBoolean(lhs.v.b && rhs.v.b);
-                            break;
-
-                            case BOP_OR:
-                            scratch = makeBoolean(lhs.v.b || rhs.v.b);
-                            break;
-
-                            default:
-                            throw makeError(ast.location,
-                                            "Binary operator " + bop_string(ast.op)
-                                            + " does not operate on booleans.");
-                        }
-                        break;
-
-                        case Value::DOUBLE:
-                        switch (ast.op) {
-                            case BOP_PLUS:
-                            scratch = makeDoubleCheck(ast.location, lhs.v.d + rhs.v.d);
+                            if (ast.op == BOP_PLUS) {
+                                auto *arr_l = static_cast<HeapArray *>(lhs.v.h);
+                                auto *arr_r = static_cast<HeapArray *>(rhs.v.h);
+                                std::vector<HeapThunk *> elements;
+                                for (auto *el : arr_l->elements)
+                                    elements.push_back(el);
+                                for (auto *el : arr_r->elements)
+                                    elements.push_back(el);
+                                scratch = makeArray(elements);
+                            } else {
+                                throw makeError(ast.location,
+                                                "Binary operator " + bop_string(ast.op) +
+                                                    " does not operate on arrays.");
+                            }
                             break;
 
-                            case BOP_MINUS:
-                            scratch = makeDoubleCheck(ast.location, lhs.v.d - rhs.v.d);
-                            break;
+                        case Value::BOOLEAN:
+                            switch (ast.op) {
+                                case BOP_AND: scratch = makeBoolean(lhs.v.b && rhs.v.b); break;
 
-                            case BOP_MULT:
-                            scratch = makeDoubleCheck(ast.location, lhs.v.d * rhs.v.d);
-                            break;
+                                case BOP_OR: scratch = makeBoolean(lhs.v.b || rhs.v.b); break;
 
-                            case BOP_DIV:
-                            if (rhs.v.d == 0)
-                                throw makeError(ast.location, "Division by zero.");
-                            scratch = makeDoubleCheck(ast.location, lhs.v.d / rhs.v.d);
+                                default:
+                                    throw makeError(ast.location,
+                                                    "Binary operator " + bop_string(ast.op) +
+                                                        " does not operate on booleans.");
+                            }
                             break;
 
-                            // No need to check doubles made from longs
-
-                            case BOP_SHIFT_L: {
-                                long long_l = lhs.v.d;
-                                long long_r = rhs.v.d;
-                                scratch = makeDouble(long_l << long_r);
-                            } break;
-
-                            case BOP_SHIFT_R: {
-                                long long_l = lhs.v.d;
-                                long long_r = rhs.v.d;
-                                scratch = makeDouble(long_l >> long_r);
-                            } break;
-
-                            case BOP_BITWISE_AND: {
-                                long long_l = lhs.v.d;
-                                long long_r = rhs.v.d;
-                                scratch = makeDouble(long_l & long_r);
-                            } break;
-
-                            case BOP_BITWISE_XOR: {
-                                long long_l = lhs.v.d;
-                                long long_r = rhs.v.d;
-                                scratch = makeDouble(long_l ^ long_r);
-                            } break;
-
-                            case BOP_BITWISE_OR: {
-                                long long_l = lhs.v.d;
-                                long long_r = rhs.v.d;
-                                scratch = makeDouble(long_l | long_r);
-                            } break;
+                        case Value::NUMBER:
+                            switch (ast.op) {
+                                case BOP_PLUS:
+                                    scratch = makeNumberCheck(ast.location, lhs.v.d + rhs.v.d);
+                                    break;
+
+                                case BOP_MINUS:
+                                    scratch = makeNumberCheck(ast.location, lhs.v.d - rhs.v.d);
+                                    break;
+
+                                case BOP_MULT:
+                                    scratch = makeNumberCheck(ast.location, lhs.v.d * rhs.v.d);
+                                    break;
+
+                                case BOP_DIV:
+                                    if (rhs.v.d == 0)
+                                        throw makeError(ast.location, "Division by zero.");
+                                    scratch = makeNumberCheck(ast.location, lhs.v.d / rhs.v.d);
+                                    break;
+
+                                    // No need to check doubles made from longs
+
+                                case BOP_SHIFT_L: {
+                                    long long_l = lhs.v.d;
+                                    long long_r = rhs.v.d;
+                                    scratch = makeNumber(long_l << long_r);
+                                } break;
+
+                                case BOP_SHIFT_R: {
+                                    long long_l = lhs.v.d;
+                                    long long_r = rhs.v.d;
+                                    scratch = makeNumber(long_l >> long_r);
+                                } break;
+
+                                case BOP_BITWISE_AND: {
+                                    long long_l = lhs.v.d;
+                                    long long_r = rhs.v.d;
+                                    scratch = makeNumber(long_l & long_r);
+                                } break;
+
+                                case BOP_BITWISE_XOR: {
+                                    long long_l = lhs.v.d;
+                                    long long_r = rhs.v.d;
+                                    scratch = makeNumber(long_l ^ long_r);
+                                } break;
+
+                                case BOP_BITWISE_OR: {
+                                    long long_l = lhs.v.d;
+                                    long long_r = rhs.v.d;
+                                    scratch = makeNumber(long_l | long_r);
+                                } break;
+
+                                case BOP_LESS_EQ: scratch = makeBoolean(lhs.v.d <= rhs.v.d); break;
 
-                            case BOP_LESS_EQ:
-                            scratch = makeBoolean(lhs.v.d <= rhs.v.d);
-                            break;
+                                case BOP_GREATER_EQ:
+                                    scratch = makeBoolean(lhs.v.d >= rhs.v.d);
+                                    break;
 
-                            case BOP_GREATER_EQ:
-                            scratch = makeBoolean(lhs.v.d >= rhs.v.d);
-                            break;
+                                case BOP_LESS: scratch = makeBoolean(lhs.v.d < rhs.v.d); break;
 
-                            case BOP_LESS:
-                            scratch = makeBoolean(lhs.v.d < rhs.v.d);
-                            break;
+                                case BOP_GREATER: scratch = makeBoolean(lhs.v.d > rhs.v.d); break;
 
-                            case BOP_GREATER:
-                            scratch = makeBoolean(lhs.v.d > rhs.v.d);
+                                default:
+                                    throw makeError(ast.location,
+                                                    "Binary operator " + bop_string(ast.op) +
+                                                        " does not operate on numbers.");
+                            }
                             break;
 
-                            default:
-                            throw makeError(ast.location,
-                                            "Binary operator " + bop_string(ast.op)
-                                            + " does not operate on numbers.");
-                        }
-                        break;
-
                         case Value::FUNCTION:
-                        throw makeError(ast.location, "Binary operator " + bop_string(ast.op) +
-                                                      " does not operate on functions.");
+                            throw makeError(ast.location,
+                                            "Binary operator " + bop_string(ast.op) +
+                                                " does not operate on functions.");
 
                         case Value::NULL_TYPE:
-                        throw makeError(ast.location, "Binary operator " + bop_string(ast.op) +
-                                                      " does not operate on null.");
+                            throw makeError(ast.location,
+                                            "Binary operator " + bop_string(ast.op) +
+                                                " does not operate on null.");
 
                         case Value::OBJECT: {
                             if (ast.op != BOP_PLUS) {
                                 throw makeError(ast.location,
                                                 "Binary operator " + bop_string(ast.op) +
-                                                " does not operate on objects.");
+                                                    " does not operate on objects.");
                             }
-                            auto *lhs_obj = static_cast<HeapObject*>(lhs.v.h);
-                            auto *rhs_obj = static_cast<HeapObject*>(rhs.v.h);
+                            auto *lhs_obj = static_cast<HeapObject *>(lhs.v.h);
+                            auto *rhs_obj = static_cast<HeapObject *>(rhs.v.h);
                             scratch = makeObject<HeapExtendedObject>(lhs_obj, rhs_obj);
-                        }
-                        break;
+                        } break;
 
                         case Value::STRING: {
-                            const String &lhs_str =
-                                static_cast<HeapString*>(lhs.v.h)->value;
-                            const String &rhs_str =
-                                static_cast<HeapString*>(rhs.v.h)->value;
+                            const UString &lhs_str = static_cast<HeapString *>(lhs.v.h)->value;
+                            const UString &rhs_str = static_cast<HeapString *>(rhs.v.h)->value;
                             switch (ast.op) {
-                                case BOP_PLUS:
-                                scratch = makeString(lhs_str + rhs_str);
-                                break;
+                                case BOP_PLUS: scratch = makeString(lhs_str + rhs_str); break;
 
-                                case BOP_LESS_EQ:
-                                scratch = makeBoolean(lhs_str <= rhs_str);
-                                break;
+                                case BOP_LESS_EQ: scratch = makeBoolean(lhs_str <= rhs_str); break;
 
                                 case BOP_GREATER_EQ:
-                                scratch = makeBoolean(lhs_str >= rhs_str);
-                                break;
+                                    scratch = makeBoolean(lhs_str >= rhs_str);
+                                    break;
 
-                                case BOP_LESS:
-                                scratch = makeBoolean(lhs_str < rhs_str);
-                                break;
+                                case BOP_LESS: scratch = makeBoolean(lhs_str < rhs_str); break;
 
-                                case BOP_GREATER:
-                                scratch = makeBoolean(lhs_str > rhs_str);
-                                break;
+                                case BOP_GREATER: scratch = makeBoolean(lhs_str > rhs_str); break;
 
                                 default:
-                                throw makeError(ast.location,
-                                                "Binary operator " + bop_string(ast.op)
-                                                + " does not operate on strings.");
+                                    throw makeError(ast.location,
+                                                    "Binary operator " + bop_string(ast.op) +
+                                                        " does not operate on strings.");
                             }
-                        }
-                        break;
+                        } break;
                     }
                 } break;
 
                 case FRAME_BUILTIN_FILTER: {
-                    const auto &ast = *static_cast<const Apply*>(f.ast);
-                    auto *func = static_cast<HeapClosure*>(f.val.v.h);
-                    auto *arr = static_cast<HeapArray*>(f.val2.v.h);
+                    const auto &ast = *static_cast<const Apply *>(f.ast);
+                    auto *func = static_cast<HeapClosure *>(f.val.v.h);
+                    auto *arr = static_cast<HeapArray *>(f.val2.v.h);
                     if (scratch.t != Value::BOOLEAN) {
-                        throw makeError(ast.location,
-                                        "filter function must return boolean, got: "
-                                        + type_str(scratch));
+                        throw makeError(
+                            ast.location,
+                            "filter function must return boolean, got: " + type_str(scratch));
                     }
-                    if (scratch.v.b) f.thunks.push_back(arr->elements[f.elementId]);
+                    if (scratch.v.b)
+                        f.thunks.push_back(arr->elements[f.elementId]);
                     f.elementId++;
                     // Iterate through arr, calling the function on each.
                     if (f.elementId == arr->elements.size()) {
@@ -2006,8 +2051,8 @@ class Interpreter {
                 } break;
 
                 case FRAME_BUILTIN_FORCE_THUNKS: {
-                    const auto &ast = *static_cast<const Apply*>(f.ast);
-                    auto *func = static_cast<HeapClosure*>(f.val.v.h);
+                    const auto &ast = *static_cast<const Apply *>(f.ast);
+                    auto *func = static_cast<HeapClosure *>(f.val.v.h);
                     if (f.elementId == f.thunks.size()) {
                         // All thunks forced, now the builtin implementations.
                         const LocationRange &loc = ast.location;
@@ -2033,53 +2078,32 @@ class Interpreter {
                         for (const Value &arg : args) {
                             switch (arg.t) {
                                 case Value::STRING:
-                                args2.push_back(JsonnetJsonValue{
-                                    JsonnetJsonValue::STRING,
-                                    encode_utf8(static_cast<HeapString*>(arg.v.h)->value),
-                                    0,
-                                    std::vector<std::unique_ptr<JsonnetJsonValue>>{},
-                                    std::map<std::string, std::unique_ptr<JsonnetJsonValue>>{},
-                                });
-                                break;
+                                    args2.emplace_back(
+                                        JsonnetJsonValue::STRING,
+                                        encode_utf8(static_cast<HeapString *>(arg.v.h)->value),
+                                        0);
+                                    break;
 
                                 case Value::BOOLEAN:
-                                args2.push_back(JsonnetJsonValue{
-                                    JsonnetJsonValue::BOOL,
-                                    "",
-                                    arg.v.b ? 1.0 : 0.0,
-                                    std::vector<std::unique_ptr<JsonnetJsonValue>>{},
-                                    std::map<std::string, std::unique_ptr<JsonnetJsonValue>>{},
-                                });
-                                break;
-
-                                case Value::DOUBLE:
-                                args2.push_back(JsonnetJsonValue{
-                                    JsonnetJsonValue::NUMBER,
-                                    "",
-                                    arg.v.d,
-                                    std::vector<std::unique_ptr<JsonnetJsonValue>>{},
-                                    std::map<std::string, std::unique_ptr<JsonnetJsonValue>>{},
-                                });
-                                break;
+                                    args2.emplace_back(
+                                        JsonnetJsonValue::BOOL, "", arg.v.b ? 1.0 : 0.0);
+                                    break;
+
+                                case Value::NUMBER:
+                                    args2.emplace_back(JsonnetJsonValue::NUMBER, "", arg.v.d);
+                                    break;
 
                                 case Value::NULL_TYPE:
-                                args2.push_back(JsonnetJsonValue{
-                                    JsonnetJsonValue::NULL_KIND,
-                                    "",
-                                    0,
-                                    std::vector<std::unique_ptr<JsonnetJsonValue>>{},
-                                    std::map<std::string, std::unique_ptr<JsonnetJsonValue>>{},
-                                });
-                                break;
+                                    args2.emplace_back(JsonnetJsonValue::NULL_KIND, "", 0);
+                                    break;
 
                                 default:
-                                throw makeError(ast.location,
-                                                "Native extensions can only take primitives.");
+                                    throw makeError(ast.location,
+                                                    "Native extensions can only take primitives.");
                             }
-
                         }
-                        std::vector<const JsonnetJsonValue*> args3;
-                        for (size_t i = 0; i < args2.size() ; ++i) {
+                        std::vector<const JsonnetJsonValue *> args3;
+                        for (size_t i = 0; i < args2.size(); ++i) {
                             args3.push_back(&args2[i]);
                         }
                         if (nit == nativeCallbacks.end()) {
@@ -2089,10 +2113,11 @@ class Interpreter {
                         const VmNativeCallback &cb = nit->second;
 
                         int succ;
-                        std::unique_ptr<JsonnetJsonValue> r(cb.cb(cb.ctx, &args3[0], &succ));
+                        std::unique_ptr<JsonnetJsonValue> r(cb.cb(cb.ctx, args3.data(), &succ));
 
                         if (succ) {
-                            jsonToHeap(r, scratch);
+                            bool unused;
+                            jsonToHeap(r, unused, scratch);
                         } else {
                             if (r->kind != JsonnetJsonValue::STRING) {
                                 throw makeError(
@@ -2115,16 +2140,15 @@ class Interpreter {
                 } break;
 
                 case FRAME_CALL: {
-                    if (auto *thunk = dynamic_cast<HeapThunk*>(f.context)) {
+                    if (auto *thunk = dynamic_cast<HeapThunk *>(f.context)) {
                         // If we called a thunk, cache result.
                         thunk->fill(scratch);
-                    } else if (auto *closure = dynamic_cast<HeapClosure*>(f.context)) {
+                    } else if (auto *closure = dynamic_cast<HeapClosure *>(f.context)) {
                         if (f.elementId < f.thunks.size()) {
                             // If tailstrict, force thunks
                             HeapThunk *th = f.thunks[f.elementId++];
                             if (!th->filled) {
-                                stack.newCall(f.location, th,
-                                              th->self, th->offset, th->upValues);
+                                stack.newCall(f.location, th, th->self, th->offset, th->upValues);
                                 ast_ = th->body;
                                 goto recurse;
                             }
@@ -2142,19 +2166,22 @@ class Interpreter {
                 } break;
 
                 case FRAME_ERROR: {
-                    const auto &ast = *static_cast<const Error*>(f.ast);
-                    if (scratch.t != Value::STRING)
-                        throw makeError(ast.location, "Error message must be string, got " +
-                                                      type_str(scratch) + ".");
-                    std::string msg = encode_utf8(static_cast<HeapString*>(scratch.v.h)->value);
-                    throw makeError(ast.location, msg);
+                    const auto &ast = *static_cast<const Error *>(f.ast);
+                    UString msg;
+                    if (scratch.t == Value::STRING) {
+                        msg = static_cast<HeapString *>(scratch.v.h)->value;
+                    } else {
+                        msg = toString(ast.location);
+                    }
+                    throw makeError(ast.location, encode_utf8(msg));
                 } break;
 
                 case FRAME_IF: {
-                    const auto &ast = *static_cast<const Conditional*>(f.ast);
+                    const auto &ast = *static_cast<const Conditional *>(f.ast);
                     if (scratch.t != Value::BOOLEAN) {
-                        throw makeError(ast.location, "Condition must be boolean, got " +
-                                                      type_str(scratch) + ".");
+                        throw makeError(
+                            ast.location,
+                            "Condition must be boolean, got " + type_str(scratch) + ".");
                     }
                     ast_ = scratch.v.b ? ast.branchTrue : ast.branchFalse;
                     stack.pop();
@@ -2162,7 +2189,7 @@ class Interpreter {
                 } break;
 
                 case FRAME_SUPER_INDEX: {
-                    const auto &ast = *static_cast<const SuperIndex*>(f.ast);
+                    const auto &ast = *static_cast<const SuperIndex *>(f.ast);
                     HeapObject *self;
                     unsigned offset;
                     stack.getSelfBinding(self, offset);
@@ -2172,74 +2199,101 @@ class Interpreter {
                                         "Attempt to use super when there is no super class.");
                     }
                     if (scratch.t != Value::STRING) {
-                        throw makeError(ast.location,
-                                        "Super index must be string, got "
-                                        + type_str(scratch) + ".");
+                        throw makeError(
+                            ast.location,
+                            "Super index must be string, got " + type_str(scratch) + ".");
                     }
 
-                    const String &index_name =
-                        static_cast<HeapString*>(scratch.v.h)->value;
+                    const UString &index_name = static_cast<HeapString *>(scratch.v.h)->value;
                     auto *fid = alloc->makeIdentifier(index_name);
                     stack.pop();
                     ast_ = objectIndex(ast.location, self, fid, offset);
                     goto recurse;
                 } break;
 
+                case FRAME_IN_SUPER_ELEMENT: {
+                    const auto &ast = *static_cast<const InSuper *>(f.ast);
+                    HeapObject *self;
+                    unsigned offset;
+                    stack.getSelfBinding(self, offset);
+                    offset++;
+                    if (scratch.t != Value::STRING) {
+                        throw makeError(ast.location,
+                                        "Left hand side of e in super must be string, got " +
+                                            type_str(scratch) + ".");
+                    }
+                    if (offset >= countLeaves(self)) {
+                        // There is no super object.
+                        scratch = makeBoolean(false);
+                    } else {
+                        const UString &element_name = static_cast<HeapString *>(scratch.v.h)->value;
+                        auto *fid = alloc->makeIdentifier(element_name);
+                        unsigned unused_found_at = 0;
+                        bool in = findObject(fid, self, offset, unused_found_at);
+                        scratch = makeBoolean(in);
+                    }
+                } break;
+
                 case FRAME_INDEX_INDEX: {
-                    const auto &ast = *static_cast<const Index*>(f.ast);
+                    const auto &ast = *static_cast<const Index *>(f.ast);
                     const Value &target = f.val;
                     if (target.t == Value::ARRAY) {
-                        const auto *array = static_cast<HeapArray*>(target.v.h);
-                        if (scratch.t != Value::DOUBLE) {
-                            throw makeError(ast.location, "Array index must be number, got "
-                                                          + type_str(scratch) + ".");
+                        const auto *array = static_cast<HeapArray *>(target.v.h);
+                        if (scratch.t != Value::NUMBER) {
+                            throw makeError(
+                                ast.location,
+                                "Array index must be number, got " + type_str(scratch) + ".");
                         }
-                        long i = long(scratch.v.d);
+                        double index = ::floor(scratch.v.d);
                         long sz = array->elements.size();
-                        if (i < 0 || i >= sz) {
+                        if (index < 0 || index >= sz) {
+                            std::stringstream ss;
+                            ss << "Array bounds error: " << index << " not within [0, " << sz
+                               << ")";
+                            throw makeError(ast.location, ss.str());
+                        }
+                        if (scratch.v.d != index) {
                             std::stringstream ss;
-                            ss << "Array bounds error: " << i
-                               << " not within [0, " << sz << ")";
+                            ss << "Array index was not integer: " << scratch.v.d;
                             throw makeError(ast.location, ss.str());
                         }
-                        auto *thunk = array->elements[i];
+                        // index < sz <= SIZE_T_MAX
+                        auto *thunk = array->elements[size_t(index)];
                         if (thunk->filled) {
                             scratch = thunk->content;
                         } else {
                             stack.pop();
-                            stack.newCall(ast.location, thunk,
-                                          thunk->self, thunk->offset, thunk->upValues);
+                            stack.newCall(
+                                ast.location, thunk, thunk->self, thunk->offset, thunk->upValues);
                             ast_ = thunk->body;
                             goto recurse;
                         }
                     } else if (target.t == Value::OBJECT) {
-                        auto *obj = static_cast<HeapObject*>(target.v.h);
+                        auto *obj = static_cast<HeapObject *>(target.v.h);
                         assert(obj != nullptr);
                         if (scratch.t != Value::STRING) {
-                            throw makeError(ast.location,
-                                            "Object index must be string, got "
-                                            + type_str(scratch) + ".");
+                            throw makeError(
+                                ast.location,
+                                "Object index must be string, got " + type_str(scratch) + ".");
                         }
-                        const String &index_name =
-                            static_cast<HeapString*>(scratch.v.h)->value;
+                        const UString &index_name = static_cast<HeapString *>(scratch.v.h)->value;
                         auto *fid = alloc->makeIdentifier(index_name);
                         stack.pop();
                         ast_ = objectIndex(ast.location, obj, fid, 0);
                         goto recurse;
                     } else if (target.t == Value::STRING) {
-                        auto *obj = static_cast<HeapString*>(target.v.h);
+                        auto *obj = static_cast<HeapString *>(target.v.h);
                         assert(obj != nullptr);
-                        if (scratch.t != Value::DOUBLE) {
-                            throw makeError(ast.location,
-                                            "String index must be a number, got "
-                                            + type_str(scratch) + ".");
+                        if (scratch.t != Value::NUMBER) {
+                            throw makeError(
+                                ast.location,
+                                "UString index must be a number, got " + type_str(scratch) + ".");
                         }
                         long sz = obj->value.length();
                         long i = (long)scratch.v.d;
                         if (i < 0 || i >= sz) {
                             std::stringstream ss;
-                            ss << "String bounds error: " << i
-                               << " not within [0, " << sz << ")";
+                            ss << "UString bounds error: " << i << " not within [0, " << sz << ")";
                             throw makeError(ast.location, ss.str());
                         }
                         char32_t ch[] = {obj->value[i], U'\0'};
@@ -2251,18 +2305,17 @@ class Interpreter {
                 } break;
 
                 case FRAME_INDEX_TARGET: {
-                    const auto &ast = *static_cast<const Index*>(f.ast);
-                    if (scratch.t != Value::ARRAY
-                        && scratch.t != Value::OBJECT
-                        && scratch.t != Value::STRING) {
+                    const auto &ast = *static_cast<const Index *>(f.ast);
+                    if (scratch.t != Value::ARRAY && scratch.t != Value::OBJECT &&
+                        scratch.t != Value::STRING) {
                         throw makeError(ast.location,
-                                        "Can only index objects, strings, and arrays, got "
-                                        + type_str(scratch) + ".");
+                                        "Can only index objects, strings, and arrays, got " +
+                                            type_str(scratch) + ".");
                     }
                     f.val = scratch;
                     f.kind = FRAME_INDEX_INDEX;
                     if (scratch.t == Value::OBJECT) {
-                        auto *self = static_cast<HeapObject*>(scratch.v.h);
+                        auto *self = static_cast<HeapObject *>(scratch.v.h);
                         if (!stack.alreadyExecutingInvariants(self)) {
                             stack.newFrame(FRAME_INVARIANTS, ast.location);
                             Frame &f2 = stack.top();
@@ -2272,8 +2325,11 @@ class Interpreter {
                             if (f2.thunks.size() > 0) {
                                 auto *thunk = f2.thunks[0];
                                 f2.elementId = 1;
-                                stack.newCall(ast.location, thunk,
-                                              thunk->self, thunk->offset, thunk->upValues);
+                                stack.newCall(ast.location,
+                                              thunk,
+                                              thunk->self,
+                                              thunk->offset,
+                                              thunk->upValues);
                                 ast_ = thunk->body;
                                 goto recurse;
                             }
@@ -2291,13 +2347,12 @@ class Interpreter {
                         }
                         stack.pop();
                         Frame &f2 = stack.top();
-                        const auto &ast = *static_cast<const Index*>(f2.ast);
+                        const auto &ast = *static_cast<const Index *>(f2.ast);
                         ast_ = ast.index;
                         goto recurse;
                     }
                     auto *thunk = f.thunks[f.elementId++];
-                    stack.newCall(f.location, thunk,
-                                  thunk->self, thunk->offset, thunk->upValues);
+                    stack.newCall(f.location, thunk, thunk->self, thunk->offset, thunk->upValues);
                     ast_ = thunk->body;
                     goto recurse;
                 } break;
@@ -2307,16 +2362,16 @@ class Interpreter {
                 } break;
 
                 case FRAME_OBJECT: {
-                    const auto &ast = *static_cast<const DesugaredObject*>(f.ast);
+                    const auto &ast = *static_cast<const DesugaredObject *>(f.ast);
                     if (scratch.t != Value::NULL_TYPE) {
                         if (scratch.t != Value::STRING) {
                             throw makeError(ast.location, "Field name was not a string.");
                         }
-                        const auto &fname = static_cast<const HeapString*>(scratch.v.h)->value;
+                        const auto &fname = static_cast<const HeapString *>(scratch.v.h)->value;
                         const Identifier *fid = alloc->makeIdentifier(fname);
                         if (f.objectFields.find(fid) != f.objectFields.end()) {
-                            std::string msg = "Duplicate field name: \""
-                                              + encode_utf8(fname) + "\"";
+                            std::string msg =
+                                "Duplicate field name: \"" + encode_utf8(fname) + "\"";
                             throw makeError(ast.location, msg);
                         }
                         f.objectFields[fid].hide = f.fit->hide;
@@ -2333,18 +2388,17 @@ class Interpreter {
                 } break;
 
                 case FRAME_OBJECT_COMP_ARRAY: {
-                    const auto &ast = *static_cast<const ObjectComprehensionSimple*>(f.ast);
+                    const auto &ast = *static_cast<const ObjectComprehensionSimple *>(f.ast);
                     const Value &arr_v = scratch;
                     if (scratch.t != Value::ARRAY) {
                         throw makeError(ast.location,
-                                        "Object comprehension needs array, got "
-                                        + type_str(arr_v));
+                                        "Object comprehension needs array, got " + type_str(arr_v));
                     }
-                    const auto *arr = static_cast<const HeapArray*>(arr_v.v.h);
+                    const auto *arr = static_cast<const HeapArray *>(arr_v.v.h);
                     if (arr->elements.size() == 0) {
                         // Degenerate case.  Just create the object now.
-                        scratch = makeObject<HeapComprehensionObject>(BindingFrame{}, ast.value,
-                                                                      ast.id, BindingFrame{});
+                        scratch = makeObject<HeapComprehensionObject>(
+                            BindingFrame{}, ast.value, ast.id, BindingFrame{});
                     } else {
                         f.kind = FRAME_OBJECT_COMP_ELEMENT;
                         f.val = scratch;
@@ -2356,14 +2410,14 @@ class Interpreter {
                 } break;
 
                 case FRAME_OBJECT_COMP_ELEMENT: {
-                    const auto &ast = *static_cast<const ObjectComprehensionSimple*>(f.ast);
-                    const auto *arr = static_cast<const HeapArray*>(f.val.v.h);
+                    const auto &ast = *static_cast<const ObjectComprehensionSimple *>(f.ast);
+                    const auto *arr = static_cast<const HeapArray *>(f.val.v.h);
                     if (scratch.t != Value::STRING) {
                         std::stringstream ss;
                         ss << "field must be string, got: " << type_str(scratch);
                         throw makeError(ast.location, ss.str());
                     }
-                    const auto &fname = static_cast<const HeapString*>(scratch.v.h)->value;
+                    const auto &fname = static_cast<const HeapString *>(scratch.v.h)->value;
                     const Identifier *fid = alloc->makeIdentifier(fname);
                     if (f.elements.find(fid) != f.elements.end()) {
                         throw makeError(ast.location,
@@ -2374,8 +2428,8 @@ class Interpreter {
 
                     if (f.elementId == arr->elements.size()) {
                         auto env = capture(ast.freeVariables);
-                        scratch = makeObject<HeapComprehensionObject>(env, ast.value,
-                                                                      ast.id, f.elements);
+                        scratch =
+                            makeObject<HeapComprehensionObject>(env, ast.value, ast.id, f.elements);
                     } else {
                         f.bindings[ast.id] = arr->elements[f.elementId];
                         ast_ = ast.field;
@@ -2384,18 +2438,18 @@ class Interpreter {
                 } break;
 
                 case FRAME_STRING_CONCAT: {
-                    const auto &ast = *static_cast<const Binary*>(f.ast);
+                    const auto &ast = *static_cast<const Binary *>(f.ast);
                     const Value &lhs = stack.top().val;
                     const Value &rhs = stack.top().val2;
-                    String output;
+                    UString output;
                     if (lhs.t == Value::STRING) {
-                        output.append(static_cast<const HeapString*>(lhs.v.h)->value);
+                        output.append(static_cast<const HeapString *>(lhs.v.h)->value);
                     } else {
                         scratch = lhs;
                         output.append(toString(ast.left->location));
                     }
                     if (rhs.t == Value::STRING) {
-                        output.append(static_cast<const HeapString*>(rhs.v.h)->value);
+                        output.append(static_cast<const HeapString *>(rhs.v.h)->value);
                     } else {
                         scratch = rhs;
                         output.append(toString(ast.right->location));
@@ -2404,56 +2458,52 @@ class Interpreter {
                 } break;
 
                 case FRAME_UNARY: {
-                    const auto &ast = *static_cast<const Unary*>(f.ast);
+                    const auto &ast = *static_cast<const Unary *>(f.ast);
                     switch (scratch.t) {
-
                         case Value::BOOLEAN:
-                        if (ast.op == UOP_NOT) {
-                            scratch = makeBoolean(!scratch.v.b);
-                        } else {
-                            throw makeError(ast.location,
-                                            "Unary operator " + uop_string(ast.op)
-                                            + " does not operate on booleans.");
-                        }
-                        break;
-
-                        case Value::DOUBLE:
-                        switch (ast.op) {
-                            case UOP_PLUS:
+                            if (ast.op == UOP_NOT) {
+                                scratch = makeBoolean(!scratch.v.b);
+                            } else {
+                                throw makeError(ast.location,
+                                                "Unary operator " + uop_string(ast.op) +
+                                                    " does not operate on booleans.");
+                            }
                             break;
 
-                            case UOP_MINUS:
-                            scratch = makeDouble(-scratch.v.d);
-                            break;
+                        case Value::NUMBER:
+                            switch (ast.op) {
+                                case UOP_PLUS: break;
 
-                            case UOP_BITWISE_NOT:
-                            scratch = makeDouble(~(long)(scratch.v.d));
-                            break;
+                                case UOP_MINUS: scratch = makeNumber(-scratch.v.d); break;
 
-                            default:
-                            throw makeError(ast.location,
-                                            "Unary operator " + uop_string(ast.op)
-                                            + " does not operate on numbers.");
-                        }
-                        break;
+                                case UOP_BITWISE_NOT:
+                                    scratch = makeNumber(~(long)(scratch.v.d));
+                                    break;
+
+                                default:
+                                    throw makeError(ast.location,
+                                                    "Unary operator " + uop_string(ast.op) +
+                                                        " does not operate on numbers.");
+                            }
+                            break;
 
                         default:
                             throw makeError(ast.location,
                                             "Unary operator " + uop_string(ast.op) +
-                                            " does not operate on type " + type_str(scratch));
+                                                " does not operate on type " + type_str(scratch));
                     }
                 } break;
 
                 default:
-                std::cerr << "INTERNAL ERROR: Unknown FrameKind:  " << f.kind << std::endl;
-                std::abort();
+                    std::cerr << "INTERNAL ERROR: Unknown FrameKind:  " << f.kind << std::endl;
+                    std::abort();
             }
 
-            popframe:;
+        popframe:;
 
             stack.pop();
 
-            replaceframe:;
+        replaceframe:;
         }
     }
 
@@ -2464,24 +2514,22 @@ class Interpreter {
      *
      * \param multiline If true, will print objects and arrays in an indented fashion.
      */
-    String manifestJson(const LocationRange &loc, bool multiline, const String &indent)
+    UString manifestJson(const LocationRange &loc, bool multiline, const UString &indent)
     {
         // Printing fields means evaluating and binding them, which can trigger
         // garbage collection.
 
-        StringStream ss;
+        UStringStream ss;
         switch (scratch.t) {
             case Value::ARRAY: {
-                HeapArray *arr = static_cast<HeapArray*>(scratch.v.h);
+                HeapArray *arr = static_cast<HeapArray *>(scratch.v.h);
                 if (arr->elements.size() == 0) {
                     ss << U"[ ]";
                 } else {
                     const char32_t *prefix = multiline ? U"[\n" : U"[";
-                    String indent2 = multiline ? indent + U"   " : indent;
+                    UString indent2 = multiline ? indent + U"   " : indent;
                     for (auto *thunk : arr->elements) {
-                        LocationRange tloc = thunk->body == nullptr
-                                           ? loc
-                                           : thunk->body->location;
+                        LocationRange tloc = thunk->body == nullptr ? loc : thunk->body->location;
                         if (thunk->filled) {
                             stack.newCall(loc, thunk, nullptr, 0, BindingFrame{});
                             // Keep arr alive when scratch is overwritten
@@ -2502,37 +2550,30 @@ class Interpreter {
                     }
                     ss << (multiline ? U"\n" : U"") << indent << U"]";
                 }
-            }
-            break;
+            } break;
 
-            case Value::BOOLEAN:
-            ss << (scratch.v.b ? U"true" : U"false");
-            break;
+            case Value::BOOLEAN: ss << (scratch.v.b ? U"true" : U"false"); break;
 
-            case Value::DOUBLE:
-            ss << decode_utf8(jsonnet_unparse_number(scratch.v.d));
-            break;
+            case Value::NUMBER: ss << decode_utf8(jsonnet_unparse_number(scratch.v.d)); break;
 
             case Value::FUNCTION:
-            throw makeError(loc, "Couldn't manifest function in JSON output.");
+                throw makeError(loc, "Couldn't manifest function in JSON output.");
 
-            case Value::NULL_TYPE:
-            ss << U"null";
-            break;
+            case Value::NULL_TYPE: ss << U"null"; break;
 
             case Value::OBJECT: {
-                auto *obj = static_cast<HeapObject*>(scratch.v.h);
+                auto *obj = static_cast<HeapObject *>(scratch.v.h);
                 runInvariants(loc, obj);
                 // Using std::map has the useful side-effect of ordering the fields
                 // alphabetically.
-                std::map<String, const Identifier*> fields;
+                std::map<UString, const Identifier *> fields;
                 for (const auto &f : objectFields(obj, true)) {
                     fields[f->name] = f;
                 }
                 if (fields.size() == 0) {
                     ss << U"{ }";
                 } else {
-                    String indent2 = multiline ? indent + U"   " : indent;
+                    UString indent2 = multiline ? indent + U"   " : indent;
                     const char32_t *prefix = multiline ? U"{\n" : U"{";
                     for (const auto &f : fields) {
                         // pushes FRAME_CALL
@@ -2544,31 +2585,30 @@ class Interpreter {
                         // get GC'd.
                         scratch = stack.top().val;
                         stack.pop();
-                        ss << prefix << indent2 << U"\"" << f.first << U"\": " << vstr;
+                        ss << prefix << indent2 << jsonnet_string_unparse(f.first, false) << U": "
+                           << vstr;
                         prefix = multiline ? U",\n" : U", ";
                     }
                     ss << (multiline ? U"\n" : U"") << indent << U"}";
                 }
-            }
-            break;
+            } break;
 
             case Value::STRING: {
-                const String &str = static_cast<HeapString*>(scratch.v.h)->value;
+                const UString &str = static_cast<HeapString *>(scratch.v.h)->value;
                 ss << jsonnet_string_unparse(str, false);
-            }
-            break;
+            } break;
         }
         return ss.str();
     }
 
-    String manifestString(const LocationRange &loc)
+    UString manifestString(const LocationRange &loc)
     {
         if (scratch.t != Value::STRING) {
             std::stringstream ss;
             ss << "Expected string result, got: " << type_str(scratch.t);
             throw makeError(loc, ss.str());
         }
-        return static_cast<HeapString*>(scratch.v.h)->value;
+        return static_cast<HeapString *>(scratch.v.h)->value;
     }
 
     StrMap manifestMulti(bool string)
@@ -2582,9 +2622,9 @@ class Interpreter {
                << "the JSON for that file.";
             throw makeError(loc, ss.str());
         }
-        auto *obj = static_cast<HeapObject*>(scratch.v.h);
+        auto *obj = static_cast<HeapObject *>(scratch.v.h);
         runInvariants(loc, obj);
-        std::map<String, const Identifier*> fields;
+        std::map<UString, const Identifier *> fields;
         for (const auto &f : objectFields(obj, true)) {
             fields[f->name] = f;
         }
@@ -2593,8 +2633,8 @@ class Interpreter {
             const AST *body = objectIndex(loc, obj, f.second, 0);
             stack.top().val = scratch;
             evaluate(body, stack.size());
-            auto vstr = string ? manifestString(body->location)
-                               : manifestJson(body->location, true, U"");
+            auto vstr =
+                string ? manifestString(body->location) : manifestJson(body->location, true, U"");
             // Reset scratch so that the object we're manifesting doesn't
             // get GC'd.
             scratch = stack.top().val;
@@ -2615,11 +2655,9 @@ class Interpreter {
                << "the JSON for each document in the stream.";
             throw makeError(loc, ss.str());
         }
-        auto *arr = static_cast<HeapArray*>(scratch.v.h);
+        auto *arr = static_cast<HeapArray *>(scratch.v.h);
         for (auto *thunk : arr->elements) {
-            LocationRange tloc = thunk->body == nullptr
-                               ? loc
-                               : thunk->body->location;
+            LocationRange tloc = thunk->body == nullptr ? loc : thunk->body->location;
             if (thunk->filled) {
                 stack.newCall(loc, thunk, nullptr, 0, BindingFrame{});
                 // Keep arr alive when scratch is overwritten
@@ -2631,32 +2669,31 @@ class Interpreter {
                 stack.top().val = scratch;
                 evaluate(thunk->body, stack.size());
             }
-            String element = manifestJson(tloc, true, U"");
+            UString element = manifestJson(tloc, true, U"");
             scratch = stack.top().val;
             stack.pop();
             r.push_back(encode_utf8(element));
         }
         return r;
     }
-
 };
 
 }  // namespace
 
-std::string jsonnet_vm_execute(
-    Allocator *alloc,
-    const AST *ast,
-    const ExtMap &ext_vars,
-    unsigned max_stack,
-    double gc_min_objects,
-    double gc_growth_trigger,
-    const VmNativeCallbackMap &natives,
-    JsonnetImportCallback *import_callback,
-    void *ctx,
-    bool string_output)
+std::string jsonnet_vm_execute(Allocator *alloc, const AST *ast, const ExtMap &ext_vars,
+                               unsigned max_stack, double gc_min_objects, double gc_growth_trigger,
+                               const VmNativeCallbackMap &natives,
+                               JsonnetImportCallback *import_callback, void *ctx,
+                               bool string_output)
 {
-    Interpreter vm(alloc, ext_vars, max_stack, gc_min_objects, gc_growth_trigger,
-                   natives, import_callback, ctx);
+    Interpreter vm(alloc,
+                   ext_vars,
+                   max_stack,
+                   gc_min_objects,
+                   gc_growth_trigger,
+                   natives,
+                   import_callback,
+                   ctx);
     vm.evaluate(ast, 0);
     if (string_output) {
         return encode_utf8(vm.manifestString(LocationRange("During manifestation")));
@@ -2665,39 +2702,39 @@ std::string jsonnet_vm_execute(
     }
 }
 
-StrMap jsonnet_vm_execute_multi(
-    Allocator *alloc,
-    const AST *ast,
-    const ExtMap &ext_vars,
-    unsigned max_stack,
-    double gc_min_objects,
-    double gc_growth_trigger,
-    const VmNativeCallbackMap &natives,
-    JsonnetImportCallback *import_callback,
-    void *ctx,
-    bool string_output)
+StrMap jsonnet_vm_execute_multi(Allocator *alloc, const AST *ast, const ExtMap &ext_vars,
+                                unsigned max_stack, double gc_min_objects, double gc_growth_trigger,
+                                const VmNativeCallbackMap &natives,
+                                JsonnetImportCallback *import_callback, void *ctx,
+                                bool string_output)
 {
-    Interpreter vm(alloc, ext_vars, max_stack, gc_min_objects, gc_growth_trigger,
-                   natives, import_callback, ctx);
+    Interpreter vm(alloc,
+                   ext_vars,
+                   max_stack,
+                   gc_min_objects,
+                   gc_growth_trigger,
+                   natives,
+                   import_callback,
+                   ctx);
     vm.evaluate(ast, 0);
     return vm.manifestMulti(string_output);
 }
 
-std::vector<std::string> jsonnet_vm_execute_stream(
-    Allocator *alloc,
-    const AST *ast,
-    const ExtMap &ext_vars,
-    unsigned max_stack,
-    double gc_min_objects,
-    double gc_growth_trigger,
-    const VmNativeCallbackMap &natives,
-    JsonnetImportCallback *import_callback,
-    void *ctx)
+std::vector<std::string> jsonnet_vm_execute_stream(Allocator *alloc, const AST *ast,
+                                                   const ExtMap &ext_vars, unsigned max_stack,
+                                                   double gc_min_objects, double gc_growth_trigger,
+                                                   const VmNativeCallbackMap &natives,
+                                                   JsonnetImportCallback *import_callback,
+                                                   void *ctx)
 {
-    Interpreter vm(alloc, ext_vars, max_stack, gc_min_objects, gc_growth_trigger,
-                   natives, import_callback, ctx);
+    Interpreter vm(alloc,
+                   ext_vars,
+                   max_stack,
+                   gc_min_objects,
+                   gc_growth_trigger,
+                   natives,
+                   import_callback,
+                   ctx);
     vm.evaluate(ast, 0);
     return vm.manifestStream();
 }
-
-
diff --git a/libjsonnet/core/vm.h b/libjsonnet/core/vm.h
index 2f6f7bd..cc67b67 100644
--- a/libjsonnet/core/vm.h
+++ b/libjsonnet/core/vm.h
@@ -26,9 +26,10 @@ limitations under the License.
 struct TraceFrame {
     LocationRange location;
     std::string name;
-    TraceFrame(const LocationRange &location, const std::string &name="")
-      : location(location), name(name)
-    { }
+    TraceFrame(const LocationRange &location, const std::string &name = "")
+        : location(location), name(name)
+    {
+    }
 };
 
 /** Exception that is thrown by the interpreter when it reaches an error construct, or divide by
@@ -38,8 +39,9 @@ struct RuntimeError {
     std::vector<TraceFrame> stackTrace;
     std::string msg;
     RuntimeError(const std::vector<TraceFrame> stack_trace, const std::string &msg)
-      : stackTrace(stack_trace), msg(msg)
-    { }
+        : stackTrace(stack_trace), msg(msg)
+    {
+    }
 };
 
 /** Holds native callback and context. */
@@ -55,13 +57,10 @@ typedef std::map<std::string, VmNativeCallback> VmNativeCallbackMap;
 struct VmExt {
     std::string data;
     bool isCode;
-    VmExt() : isCode(false) { }
-    VmExt(const std::string &data, bool is_code)
-      : data(data), isCode(is_code)
-    { }
+    VmExt() : isCode(false) {}
+    VmExt(const std::string &data, bool is_code) : data(data), isCode(is_code) {}
 };
 
-
 /** Execute the program and return the value as a JSON string.
  *
  * \param alloc The allocator used to create the ast.
@@ -76,16 +75,12 @@ struct VmExt {
  * \throws RuntimeError reports runtime errors in the program.
  * \returns The JSON result in string form.
  */
-std::string jsonnet_vm_execute(
-    Allocator *alloc, const AST *ast,
-    const std::map<std::string, VmExt> &ext,
-    unsigned max_stack,
-    double gc_min_objects,
-    double gc_growth_trigger,
-    const VmNativeCallbackMap &natives,
-    JsonnetImportCallback *import_callback,
-    void *import_callback_ctx,
-    bool string_output);
+std::string jsonnet_vm_execute(Allocator *alloc, const AST *ast,
+                               const std::map<std::string, VmExt> &ext, unsigned max_stack,
+                               double gc_min_objects, double gc_growth_trigger,
+                               const VmNativeCallbackMap &natives,
+                               JsonnetImportCallback *import_callback, void *import_callback_ctx,
+                               bool string_output);
 
 /** Execute the program and return the value as a number of named JSON files.
  *
@@ -105,16 +100,9 @@ std::string jsonnet_vm_execute(
  * \returns A mapping from filename to the JSON strings for that file.
  */
 std::map<std::string, std::string> jsonnet_vm_execute_multi(
-    Allocator *alloc,
-    const AST *ast,
-    const std::map<std::string, VmExt> &ext,
-    unsigned max_stack,
-    double gc_min_objects,
-    double gc_growth_trigger,
-    const VmNativeCallbackMap &natives,
-    JsonnetImportCallback *import_callback,
-    void *import_callback_ctx,
-    bool string_output);
+    Allocator *alloc, const AST *ast, const std::map<std::string, VmExt> &ext, unsigned max_stack,
+    double gc_min_objects, double gc_growth_trigger, const VmNativeCallbackMap &natives,
+    JsonnetImportCallback *import_callback, void *import_callback_ctx, bool string_output);
 
 /** Execute the program and return the value as a stream of JSON files.
  *
@@ -135,14 +123,8 @@ std::map<std::string, std::string> jsonnet_vm_execute_multi(
  * \returns A mapping from filename to the JSON strings for that file.
  */
 std::vector<std::string> jsonnet_vm_execute_stream(
-    Allocator *alloc,
-    const AST *ast,
-    const std::map<std::string, VmExt> &ext,
-    unsigned max_stack,
-    double gc_min_objects,
-    double gc_growth_trigger,
-    const VmNativeCallbackMap &natives,
-    JsonnetImportCallback *import_callback,
-    void *import_callback_ctx);
+    Allocator *alloc, const AST *ast, const std::map<std::string, VmExt> &ext, unsigned max_stack,
+    double gc_min_objects, double gc_growth_trigger, const VmNativeCallbackMap &natives,
+    JsonnetImportCallback *import_callback, void *import_callback_ctx);
 
 #endif
diff --git a/libjsonnet/cpp/libjsonnet++.cpp b/libjsonnet/cpp/libjsonnet++.cpp
index ed7d80d..819f869 100644
--- a/libjsonnet/cpp/libjsonnet++.cpp
+++ b/libjsonnet/cpp/libjsonnet++.cpp
@@ -17,9 +17,7 @@ limitations under the License.
 #include "libjsonnet++.h"
 
 namespace jsonnet {
-
-Jsonnet::Jsonnet()
-{}
+Jsonnet::Jsonnet() {}
 
 Jsonnet::~Jsonnet()
 {
@@ -34,7 +32,8 @@ std::string Jsonnet::version()
     return ::jsonnet_version();
 }
 
-bool Jsonnet::init() {
+bool Jsonnet::init()
+{
     vm_ = static_cast<struct JsonnetVm*>(::jsonnet_make());
     return vm_ != nullptr;
 }
@@ -94,16 +93,15 @@ bool Jsonnet::evaluateFile(const std::string& filename, std::string* output)
     return true;
 }
 
-bool Jsonnet::evaluateSnippet(const std::string& filename,
-                              const std::string& snippet,
+bool Jsonnet::evaluateSnippet(const std::string& filename, const std::string& snippet,
                               std::string* output)
 {
     if (output == nullptr) {
         return false;
     }
     int error = 0;
-    const char* jsonnet_output = ::jsonnet_evaluate_snippet(
-        vm_, filename.c_str(), snippet.c_str(), &error);
+    const char* jsonnet_output =
+        ::jsonnet_evaluate_snippet(vm_, filename.c_str(), snippet.c_str(), &error);
     if (error != 0) {
         last_error_.assign(jsonnet_output);
         return false;
@@ -113,16 +111,17 @@ bool Jsonnet::evaluateSnippet(const std::string& filename,
 }
 
 namespace {
-void parseMultiOutput(const char* jsonnet_output,
-                      std::map<std::string, std::string>* outputs)
+void parseMultiOutput(const char* jsonnet_output, std::map<std::string, std::string>* outputs)
 {
-    for (const char* c = jsonnet_output; *c != '\0'; ) {
-        const char *filename = c;
-        const char *c2 = c;
-        while (*c2 != '\0') ++c2;
+    for (const char* c = jsonnet_output; *c != '\0';) {
+        const char* filename = c;
+        const char* c2 = c;
+        while (*c2 != '\0')
+            ++c2;
         ++c2;
-        const char *json = c2;
-        while (*c2 != '\0') ++c2;
+        const char* json = c2;
+        while (*c2 != '\0')
+            ++c2;
         ++c2;
         c = c2;
         outputs->insert(std::make_pair(filename, json));
@@ -137,8 +136,7 @@ bool Jsonnet::evaluateFileMulti(const std::string& filename,
         return false;
     }
     int error = 0;
-    const char* jsonnet_output =
-        ::jsonnet_evaluate_file_multi(vm_, filename.c_str(), &error);
+    const char* jsonnet_output = ::jsonnet_evaluate_file_multi(vm_, filename.c_str(), &error);
     if (error != 0) {
         last_error_.assign(jsonnet_output);
         return false;
@@ -147,16 +145,15 @@ bool Jsonnet::evaluateFileMulti(const std::string& filename,
     return true;
 }
 
-bool Jsonnet::evaluateSnippetMulti(const std::string& filename,
-                                   const std::string& snippet,
+bool Jsonnet::evaluateSnippetMulti(const std::string& filename, const std::string& snippet,
                                    std::map<std::string, std::string>* outputs)
 {
     if (outputs == nullptr) {
         return false;
     }
     int error = 0;
-    const char* jsonnet_output = ::jsonnet_evaluate_snippet_multi(
-        vm_, filename.c_str(), snippet.c_str(), &error);
+    const char* jsonnet_output =
+        ::jsonnet_evaluate_snippet_multi(vm_, filename.c_str(), snippet.c_str(), &error);
     if (error != 0) {
         last_error_.assign(jsonnet_output);
         return false;
diff --git a/libjsonnet/include/libjsonnet++.h b/libjsonnet/include/libjsonnet++.h
index 4cd6da1..7b4b857 100644
--- a/libjsonnet/include/libjsonnet++.h
+++ b/libjsonnet/include/libjsonnet++.h
@@ -17,17 +17,16 @@ limitations under the License.
 #ifndef CPP_JSONNET_H_
 #define CPP_JSONNET_H_
 
-#include <functional>
 #include <cstring>
-#include <string>
+#include <functional>
 #include <map>
+#include <string>
 
 extern "C" {
-    #include "libjsonnet.h"
+#include "libjsonnet.h"
 }
 
 namespace jsonnet {
-
 class Jsonnet {
    public:
     Jsonnet();
@@ -99,8 +98,7 @@ class Jsonnet {
     /// @param output Pointer to string to contain the output.
     /// @return true if the Jsonnet code was successfully evaluated, false
     ///         otherwise.
-    bool evaluateSnippet(const std::string& filename,
-                         const std::string& snippet,
+    bool evaluateSnippet(const std::string& filename, const std::string& snippet,
                          std::string* output);
 
     /// Evaluate a file containing Jsonnet code, return a number of JSON files.
@@ -127,14 +125,13 @@ class Jsonnet {
     ///        to JSON string.
     /// @return true if the Jsonnet code was successfully evaluated, false
     ///         otherwise.
-    bool evaluateSnippetMulti(const std::string& filename,
-                              const std::string& snippet,
+    bool evaluateSnippetMulti(const std::string& filename, const std::string& snippet,
                               std::map<std::string, std::string>* outputs);
 
     /// Returns the last error raised by Jsonnet.
     std::string lastError() const;
 
-  private:
+   private:
     struct JsonnetVm* vm_;
     std::string last_error_;
 };
diff --git a/libjsonnet/include/libjsonnet.h b/libjsonnet/include/libjsonnet.h
index 9453718..9f10e39 100644
--- a/libjsonnet/include/libjsonnet.h
+++ b/libjsonnet/include/libjsonnet.h
@@ -24,9 +24,7 @@ limitations under the License.
  * of using the library.
  */
 
-
-#define LIB_JSONNET_VERSION "v0.8.9"
-
+#define LIB_JSONNET_VERSION "v0.9.5"
 
 /** Return the version string of the Jsonnet interpreter.  Conforms to semantic versioning
  * http://semver.org/ If this does not match LIB_JSONNET_VERSION then there is a mismatch between
@@ -66,7 +64,8 @@ void jsonnet_string_output(struct JsonnetVm *vm, int v);
  * \param success Set this byref param to 1 to indicate success and 0 for failure.
  * \returns The content of the imported file, or an error message.
  */
-typedef char *JsonnetImportCallback(void *ctx, const char *base, const char *rel, char **found_here, int *success);
+typedef char *JsonnetImportCallback(void *ctx, const char *base, const char *rel, char **found_here,
+                                    int *success);
 
 /** An opaque type which can only be utilized via the jsonnet_json_* family of functions.
  */
@@ -78,7 +77,8 @@ const char *jsonnet_json_extract_string(struct JsonnetVm *vm, const struct Jsonn
 
 /** If the value is a number, return 1 and store the number in out, otherwise return 0.
  */
-int jsonnet_json_extract_number(struct JsonnetVm *vm, const struct JsonnetJsonValue *v, double *out);
+int jsonnet_json_extract_number(struct JsonnetVm *vm, const struct JsonnetJsonValue *v,
+                                double *out);
 
 /** Return 0 if the value is false, 1 if it is true, and 2 if it is not a bool.
  */
@@ -112,8 +112,7 @@ struct JsonnetJsonValue *jsonnet_json_make_array(struct JsonnetVm *vm);
 
 /** Add v to the end of the array.
  */
-void jsonnet_json_array_append(struct JsonnetVm *vm,
-                               struct JsonnetJsonValue *arr,
+void jsonnet_json_array_append(struct JsonnetVm *vm, struct JsonnetJsonValue *arr,
                                struct JsonnetJsonValue *v);
 
 /** Make a JsonnetJsonValue representing an object with the given number of fields.
@@ -126,9 +125,7 @@ struct JsonnetJsonValue *jsonnet_json_make_object(struct JsonnetVm *vm);
  *
  * This replaces any previous binding of the field.
  */
-void jsonnet_json_object_append(struct JsonnetVm *vm,
-                                struct JsonnetJsonValue *obj,
-                                const char *f,
+void jsonnet_json_object_append(struct JsonnetVm *vm, struct JsonnetJsonValue *obj, const char *f,
                                 struct JsonnetJsonValue *v);
 
 /** Clean up a JSON subtree.
@@ -141,16 +138,16 @@ void jsonnet_json_destroy(struct JsonnetVm *vm, struct JsonnetJsonValue *v);
  *
  * The returned JsonnetJsonValue* should be allocated with jsonnet_realloc.  It will be cleaned up
  * along with the objects rooted at argv by libjsonnet when no-longer needed.  Return a string upon
- * failure, which will appear in Jsonnet as an error.
+ * failure, which will appear in Jsonnet as an error.  The argv pointer is an array whose size
+ * matches the array of parameters supplied when the native callback was originally registered.
  *
  * \param ctx User pointer, given in jsonnet_native_callback.
- * \param argc The number of arguments from Jsonnet code.
  * \param argv Array of arguments from Jsonnet code.
  * \param success Set this byref param to 1 to indicate success and 0 for failure.
  * \returns The content of the imported file, or an error message.
  */
 typedef struct JsonnetJsonValue *JsonnetNativeCallback(void *ctx,
-                                                       const struct JsonnetJsonValue * const *argv,
+                                                       const struct JsonnetJsonValue *const *argv,
                                                        int *success);
 
 /** Allocate, resize, or free a buffer.  This will abort if the memory cannot be allocated.  It will
@@ -177,10 +174,10 @@ void jsonnet_import_callback(struct JsonnetVm *vm, JsonnetImportCallback *cb, vo
  * \param name The name of the function as visible to Jsonnet code, e.g. "foo".
  * \param cb The PURE function that implements the behavior you want.
  * \param ctx User pointer, stash non-global state you need here.
- * \param params The names of the params.  Must be valid Jsonnet identifiers.
+ * \param params NULL-terminated array of the names of the params.  Must be valid identifiers.
  */
 void jsonnet_native_callback(struct JsonnetVm *vm, const char *name, JsonnetNativeCallback *cb,
-                             void *ctx, const char * const *params);
+                             void *ctx, const char *const *params);
 
 /** Bind a Jsonnet external var to the given string.
  *
@@ -242,6 +239,10 @@ void jsonnet_fmt_pad_objects(struct JsonnetVm *vm, int v);
  */
 void jsonnet_fmt_pretty_field_names(struct JsonnetVm *vm, int v);
 
+/** Sort top-level imports in alphabetical order
+ */
+void jsonnet_fmt_sort_imports(struct JsonnetVm *vm, int v);
+
 /** If set to 1, will reformat the Jsonnet input after desugaring. */
 void jsonnet_fmt_debug_desugaring(struct JsonnetVm *vm, int v);
 
@@ -253,22 +254,18 @@ void jsonnet_fmt_debug_desugaring(struct JsonnetVm *vm, int v);
  * \param error Return by reference whether or not there was an error.
  * \returns Either Jsonnet code or the error message.
  */
-char *jsonnet_fmt_file(struct JsonnetVm *vm,
-                       const char *filename,
-                       int *error);
+char *jsonnet_fmt_file(struct JsonnetVm *vm, const char *filename, int *error);
 
-/** Evaluate a string containing Jsonnet code, return a Jsonnet string.
+/** Reformat a string containing Jsonnet code, return a Jsonnet string.
  *
  * The returned string should be cleaned up with jsonnet_realloc.
  *
  * \param filename Path to a file (used in error messages).
  * \param snippet Jsonnet code to execute.
  * \param error Return by reference whether or not there was an error.
- * \returns Either JSON or the error message.
+ * \returns Either Jsonnet code or the error message.
  */
-char *jsonnet_fmt_snippet(struct JsonnetVm *vm,
-                          const char *filename,
-                          const char *snippet,
+char *jsonnet_fmt_snippet(struct JsonnetVm *vm, const char *filename, const char *snippet,
                           int *error);
 
 /** Set the number of lines of stack trace to display (0 for all of them). */
@@ -285,9 +282,7 @@ void jsonnet_jpath_add(struct JsonnetVm *vm, const char *v);
  * \param error Return by reference whether or not there was an error.
  * \returns Either JSON or the error message.
  */
-char *jsonnet_evaluate_file(struct JsonnetVm *vm,
-                            const char *filename,
-                            int *error);
+char *jsonnet_evaluate_file(struct JsonnetVm *vm, const char *filename, int *error);
 
 /** Evaluate a string containing Jsonnet code, return a JSON string.
  *
@@ -298,9 +293,7 @@ char *jsonnet_evaluate_file(struct JsonnetVm *vm,
  * \param error Return by reference whether or not there was an error.
  * \returns Either JSON or the error message.
  */
-char *jsonnet_evaluate_snippet(struct JsonnetVm *vm,
-                               const char *filename,
-                               const char *snippet,
+char *jsonnet_evaluate_snippet(struct JsonnetVm *vm, const char *filename, const char *snippet,
                                int *error);
 
 /** Evaluate a file containing Jsonnet code, return a number of named JSON files.
@@ -312,9 +305,7 @@ char *jsonnet_evaluate_snippet(struct JsonnetVm *vm,
  * \param error Return by reference whether or not there was an error.
  * \returns Either the error, or a sequence of strings separated by \0, terminated with \0\0.
  */
-char *jsonnet_evaluate_file_multi(struct JsonnetVm *vm,
-                                  const char *filename,
-                                  int *error);
+char *jsonnet_evaluate_file_multi(struct JsonnetVm *vm, const char *filename, int *error);
 
 /** Evaluate a string containing Jsonnet code, return a number of named JSON files.
  *
@@ -326,10 +317,8 @@ char *jsonnet_evaluate_file_multi(struct JsonnetVm *vm,
  * \param error Return by reference whether or not there was an error.
  * \returns Either the error, or a sequence of strings separated by \0, terminated with \0\0.
  */
-char *jsonnet_evaluate_snippet_multi(struct JsonnetVm *vm,
-                                     const char *filename,
-                                     const char *snippet,
-                                     int *error);
+char *jsonnet_evaluate_snippet_multi(struct JsonnetVm *vm, const char *filename,
+                                     const char *snippet, int *error);
 
 /** Evaluate a file containing Jsonnet code, return a number of JSON files.
  *
@@ -340,9 +329,7 @@ char *jsonnet_evaluate_snippet_multi(struct JsonnetVm *vm,
  * \param error Return by reference whether or not there was an error.
  * \returns Either the error, or a sequence of strings separated by \0, terminated with \0\0.
  */
-char *jsonnet_evaluate_file_stream(struct JsonnetVm *vm,
-                                   const char *filename,
-                                   int *error);
+char *jsonnet_evaluate_file_stream(struct JsonnetVm *vm, const char *filename, int *error);
 
 /** Evaluate a string containing Jsonnet code, return a number of JSON files.
  *
@@ -354,10 +341,8 @@ char *jsonnet_evaluate_file_stream(struct JsonnetVm *vm,
  * \param error Return by reference whether or not there was an error.
  * \returns Either the error, or a sequence of strings separated by \0, terminated with \0\0.
  */
-char *jsonnet_evaluate_snippet_stream(struct JsonnetVm *vm,
-                                      const char *filename,
-                                      const char *snippet,
-                                      int *error);
+char *jsonnet_evaluate_snippet_stream(struct JsonnetVm *vm, const char *filename,
+                                      const char *snippet, int *error);
 
 /** Complement of \see jsonnet_vm_make. */
 void jsonnet_destroy(struct JsonnetVm *vm);
diff --git a/libjsonnet/stdlib/std.jsonnet b/libjsonnet/stdlib/std.jsonnet
index b0362c1..3fb0fb5 100644
--- a/libjsonnet/stdlib/std.jsonnet
+++ b/libjsonnet/stdlib/std.jsonnet
@@ -39,13 +39,13 @@ limitations under the License.
         else
             std.join("", std.makeArray(len, function(i) str[i + from])),
 
-    startsWith(a, b):
+    startsWith(a, b)::
         if std.length(a) < std.length(b) then
             false
         else
             std.substr(a, 0, std.length(b)) == b,
 
-    endsWith(a, b):
+    endsWith(a, b)::
         if std.length(a) < std.length(b) then
             false
         else
@@ -53,11 +53,11 @@ limitations under the License.
 
     stringChars(str)::
         std.makeArray(std.length(str), function(i) str[i]),
-    
+
     parseInt(str)::
         local addDigit(aggregate, digit) =
             if digit < 0 || digit > 9 then
-                error("parseInt got string which does not match regex [0-9]+")
+                error ("parseInt got string which does not match regex [0-9]+")
             else
                 10 * aggregate + digit;
         local toDigits(str) =
@@ -102,29 +102,30 @@ limitations under the License.
         std.makeArray(to - from + 1, function(i) i + from),
 
     slice(indexable, index, end, step)::
-        if (index != null && index < 0) || (end != null && end < 0) || (step != null && step < 0) then
-            error("got [%s:%s:%s] but negative index, end, and steps are not supported" % [index, end, step])
+        local invar =
+            // loop invariant with defaults applied
+            {
+                indexable: indexable,
+                index:
+                    if index == null then 0
+                    else index,
+                end:
+                    if end == null then std.length(indexable)
+                    else end,
+                step:
+                    if step == null then 1
+                    else step,
+                length: std.length(indexable),
+                type: std.type(indexable),
+            };
+        if invar.index < 0 || invar.end < 0 || invar.step < 0 then
+            error ("got [%s:%s:%s] but negative index, end, and steps are not supported"
+                   % [invar.index, invar.end, invar.step])
         else if step == 0 then
-            error("got %s but step must be greater than 0" % step)
+            error ("got %s but step must be greater than 0" % step)
         else if std.type(indexable) != "string" && std.type(indexable) != "array" then
-            error("std.slice accepts a string or an array, but got: %s" % std.type(indexable))
+            error ("std.slice accepts a string or an array, but got: %s" % std.type(indexable))
         else
-            local invar =
-                // loop invariant with defaults applied
-                {
-                    indexable: indexable,
-                    index:
-                        if index == null then 0
-                        else index,
-                    end:
-                        if end == null then std.length(indexable)
-                        else end,
-                    step:
-                        if step == null then 1
-                        else step,
-                    length: std.length(indexable),
-                    type: std.type(indexable)
-                };
             local build(slice, cur) =
                 if cur >= invar.end || cur >= invar.length then
                     slice
@@ -133,12 +134,12 @@ limitations under the License.
                         if invar.type == "string" then
                             slice + invar.indexable[cur]
                         else
-                            slice + [ invar.indexable[cur] ],
+                            slice + [invar.indexable[cur]],
                         cur + invar.step
                     ) tailstrict;
             build(if invar.type == "string" then "" else [], invar.index),
 
-    count(arr, x):: std.length(std.filter(function(v) v==x, arr)),
+    count(arr, x):: std.length(std.filter(function(v) v == x, arr)),
 
     mod(a, b)::
         if std.type(a) == "number" && std.type(b) == "number" then
@@ -150,9 +151,9 @@ limitations under the License.
 
     map(func, arr)::
         if std.type(func) != "function" then
-            error("std.map first param must be function, got " + std.type(func))
+            error ("std.map first param must be function, got " + std.type(func))
         else if std.type(arr) != "array" && std.type(arr) != "string" then
-            error("std.map second param must be array / string, got " + std.type(arr))
+            error ("std.map second param must be array / string, got " + std.type(arr))
         else
             std.makeArray(std.length(arr), function(i) func(arr[i])),
 
@@ -210,22 +211,22 @@ limitations under the License.
                 else
                     local c = str[j];
                     if c == "#" then
-                        consume(str, j + 1, v + { alt: true })
+                        consume(str, j + 1, v { alt: true })
                     else if c == "0" then
-                        consume(str, j + 1, v + { zero: true })
+                        consume(str, j + 1, v { zero: true })
                     else if c == "-" then
-                        consume(str, j + 1, v + { left: true })
+                        consume(str, j + 1, v { left: true })
                     else if c == " " then
-                        consume(str, j + 1, v + { blank: true })
+                        consume(str, j + 1, v { blank: true })
                     else if c == "+" then
-                        consume(str, j + 1, v + { sign: true })
+                        consume(str, j + 1, v { sign: true })
                     else
                         { i: j, v: v };
-            consume(str, i, { alt: false, zero: false, left: false, blank: false, sign: false});
+            consume(str, i, { alt: false, zero: false, left: false, blank: false, sign: false });
 
         local try_parse_field_width(str, i) =
             if i < std.length(str) && str[i] == "*" then
-                { i: i+1, v: "*" }
+                { i: i + 1, v: "*" }
             else
                 local consume(str, j, v) =
                     if j >= std.length(str) then
@@ -332,7 +333,7 @@ limitations under the License.
                         prec: prec.v,
                         ctype: ctype.v,
                         caps: ctype.caps,
-                    }
+                    },
                 };
 
         // Parse a format string (containing none or more % format tags).
@@ -390,7 +391,7 @@ limitations under the License.
         local render_hex(n__, min_chars, min_digits, blank, sign, add_zerox, capitals) =
             local numerals = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
                              + if capitals then ["A", "B", "C", "D", "E", "F"]
-                                           else ["a", "b", "c", "d", "e", "f"];
+                             else ["a", "b", "c", "d", "e", "f"];
             local n_ = std.abs(n__);
             local aux(n) =
                 if n == 0 then
@@ -400,7 +401,7 @@ limitations under the License.
             local hex = if std.floor(n_) == 0 then "0" else aux(std.floor(n_));
             local neg = n__ < 0;
             local zp = min_chars - (if neg || blank || sign then 1 else 0)
-                                 - (if add_zerox then 2 else 0);
+                       - (if add_zerox then 2 else 0);
             local zp2 = std.max(zp, min_digits);
             local hex2 = (if add_zerox then (if capitals then "0X" else "0x") else "")
                          + pad_left(hex, zp2, "0");
@@ -490,12 +491,12 @@ limitations under the License.
                     error "Format required number at "
                           + i + ", got " + std.type(val)
                 else
-                    local exponent = std.floor(std.log(std.abs(val))/std.log(10));
+                    local exponent = std.floor(std.log(std.abs(val)) / std.log(10));
                     if exponent < -4 || exponent >= fpprec then
                         render_float_sci(val, zp, cflags.blank, cflags.sign, cflags.alt,
                                          cflags.alt, code.caps, fpprec - 1)
                     else
-                        local digits_before_pt = std.max(1, exponent+1);
+                        local digits_before_pt = std.max(1, exponent + 1);
                         render_float_dec(val, zp, cflags.blank, cflags.sign, cflags.alt,
                                          cflags.alt, fpprec - digits_before_pt)
             else if code.ctype == "c" then
@@ -515,7 +516,7 @@ limitations under the License.
         local format_codes_arr(codes, arr, i, j, v) =
             if i >= std.length(codes) then
                 if j < std.length(arr) then
-                    error("Too many values to format: " + std.length(arr) + ", expected " + j)
+                    error ("Too many values to format: " + std.length(arr) + ", expected " + j)
                 else
                     v
             else
@@ -526,9 +527,9 @@ limitations under the License.
                     local tmp = if code.fw == "*" then {
                         j: j + 1,
                         fw: if j >= std.length(arr) then
-                                error "Not enough values to format: " + std.length(arr)
-                            else
-                                arr[j]
+                            error "Not enough values to format: " + std.length(arr)
+                        else
+                            arr[j],
                     } else {
                         j: j,
                         fw: code.fw,
@@ -536,9 +537,9 @@ limitations under the License.
                     local tmp2 = if code.prec == "*" then {
                         j: tmp.j + 1,
                         prec: if tmp.j >= std.length(arr) then
-                                error "Not enough values to format: " + std.length(arr)
-                            else
-                                arr[tmp.j]
+                            error "Not enough values to format: " + std.length(arr)
+                        else
+                            arr[tmp.j],
                     } else {
                         j: tmp.j,
                         prec: code.prec,
@@ -547,7 +548,7 @@ limitations under the License.
                     local val =
                         if j2 < std.length(arr) then
                             arr[j2]
-                        else 
+                        else
                             error "Not enough values to format, got " + std.length(arr);
                     local s =
                         if code.ctype == "%" then
@@ -590,7 +591,7 @@ limitations under the License.
                             error "Cannot use * precision with object."
                         else
                             code.prec;
-                    local val = 
+                    local val =
                         if std.objectHasAll(obj, f) then
                             obj[f]
                         else
@@ -633,11 +634,11 @@ limitations under the License.
 
     filterMap(filter_func, map_func, arr)::
         if std.type(filter_func) != "function" then
-            error("std.filterMap first param must be function, got " + std.type(filter_func))
+            error ("std.filterMap first param must be function, got " + std.type(filter_func))
         else if std.type(map_func) != "function" then
-            error("std.filterMap second param must be function, got " + std.type(map_func))
+            error ("std.filterMap second param must be function, got " + std.type(map_func))
         else if std.type(arr) != "array" then
-            error("std.filterMap third param must be array, got " + std.type(arr))
+            error ("std.filterMap third param must be array, got " + std.type(arr))
         else
             std.map(map_func, std.filter(filter_func, arr)),
 
@@ -670,11 +671,21 @@ limitations under the License.
             if a < b then a else b,
 
     flattenArrays(arrs)::
-        std.foldl(function(a,b) a + b, arrs, []),
+        std.foldl(function(a, b) a + b, arrs, []),
 
     manifestIni(ini)::
-        local body_lines(body) = [ "%s = %s" % [k, body[k]] for k in std.objectFields(body) ],
-              section_lines(sname, sbody) = [ "[%s]" % [sname] ] + body_lines(sbody),
+        local body_lines(body) =
+            std.join([], [
+                local value_or_values = body[k];
+                if std.type(value_or_values) == "array" then
+                    ["%s = %s" % [k, value] for value in value_or_values]
+                else
+                    ["%s = %s" % [k, value_or_values]]
+
+                for k in std.objectFields(body)
+            ]);
+
+        local section_lines(sname, sbody) = ["[%s]" % [sname]] + body_lines(sbody),
               main_body = if std.objectHas(ini, "main") then body_lines(ini.main) else [],
               all_sections = [section_lines(k, ini.sections[k])
                               for k in std.objectFields(ini.sections)];
@@ -728,7 +739,7 @@ limitations under the License.
 
     manifestJson(value):: std.manifestJsonEx(value, "    "),
 
-    manifestJsonEx(value, indent):: 
+    manifestJsonEx(value, indent)::
         local aux(v, path, cindent) =
             if v == true then
                 "true"
@@ -744,10 +755,11 @@ limitations under the License.
                 error "Tried to manifest function at " + path
             else if std.type(v) == "array" then
                 local range = std.range(0, std.length(v) - 1);
+                local new_indent = cindent + indent;
                 local lines = ["[\n"]
                               + std.join([",\n"],
-                                         [[cindent + indent + aux(v[i], path + [i], cindent + indent)] for i
-in range])                
+                                         [[new_indent + aux(v[i], path + [i], new_indent)]
+                                          for i in range])
                               + ["\n" + cindent + "]"];
                 std.join("", lines)
             else if std.type(v) == "object" then
@@ -793,7 +805,7 @@ in range])
 
 
     local base64_table = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",
-    local base64_inv = {[base64_table[i]]: i for i in std.range(0, 63)},
+    local base64_inv = { [base64_table[i]]: i for i in std.range(0, 63) },
 
     base64(input)::
         local bytes =
@@ -814,25 +826,25 @@ in range])
                     "==";
                 aux(arr, i + 3, r + str) tailstrict
             else if i + 2 >= std.length(arr) then
-                local str = 
-                    // 6 MSB of i 
+                local str =
+                    // 6 MSB of i
                     base64_table[(arr[i] & 252) >> 2] +
                     // 2 LSB of i, 4 MSB of i+1
-                    base64_table[(arr[i] & 3) << 4 | (arr[i+1] & 240) >> 4] +
-                    // 4 LSB of i+1 
-                    base64_table[(arr[i+1] & 15) << 2] +
-                    "="; 
+                    base64_table[(arr[i] & 3) << 4 | (arr[i + 1] & 240) >> 4] +
+                    // 4 LSB of i+1
+                    base64_table[(arr[i + 1] & 15) << 2] +
+                    "=";
                 aux(arr, i + 3, r + str) tailstrict
             else
-                local str = 
-                    // 6 MSB of i 
+                local str =
+                    // 6 MSB of i
                     base64_table[(arr[i] & 252) >> 2] +
                     // 2 LSB of i, 4 MSB of i+1
-                    base64_table[(arr[i] & 3) << 4 | (arr[i+1] & 240) >> 4] +
+                    base64_table[(arr[i] & 3) << 4 | (arr[i + 1] & 240) >> 4] +
                     // 4 LSB of i+1, 2 MSB of i+2
-                    base64_table[(arr[i+1] & 15) << 2 | (arr[i+2] & 192) >> 6] +
-                    // 6 LSB of i+2 
-                    base64_table[(arr[i+2] & 63)];
+                    base64_table[(arr[i + 1] & 15) << 2 | (arr[i + 2] & 192) >> 6] +
+                    // 6 LSB of i+2
+                    base64_table[(arr[i + 2] & 63)];
                 aux(arr, i + 3, r + str) tailstrict;
 
         local sanity = std.foldl(function(r, a) r && (a < 256), bytes, true);
@@ -849,18 +861,18 @@ in range])
             local aux(str, i, r) =
                 if i >= std.length(str) then
                     r
-                else 
-                    // all 6 bits of i, 2 MSB of i+1 
-                    local n1 = [base64_inv[str[i]] << 2 | (base64_inv[str[i+1]] >> 4)];
+                else
+                    // all 6 bits of i, 2 MSB of i+1
+                    local n1 = [base64_inv[str[i]] << 2 | (base64_inv[str[i + 1]] >> 4)];
                     // 4 LSB of i+1, 4MSB of i+2
                     local n2 =
-                        if str[i+2] == "=" then [] 
-                        else [(base64_inv[str[i+1]] & 15) << 4 | (base64_inv[str[i+2]] >> 2)];
+                        if str[i + 2] == "=" then []
+                        else [(base64_inv[str[i + 1]] & 15) << 4 | (base64_inv[str[i + 2]] >> 2)];
                     // 2 LSB of i+2, all 6 bits of i+3
                     local n3 =
-                        if str[i+3] == "=" then []
-                        else [(base64_inv[str[i+2]] & 3) << 6 | base64_inv[str[i+3]]];
-                    aux(str, i+4, r + n1 + n2 + n3) tailstrict;
+                        if str[i + 3] == "=" then []
+                        else [(base64_inv[str[i + 2]] & 3) << 6 | base64_inv[str[i + 3]]];
+                    aux(str, i + 4, r + n1 + n2 + n3) tailstrict;
             aux(str, 0, []),
 
     base64Decode(str)::
@@ -887,7 +899,7 @@ in range])
                 a
             else
                 a + [b];
-        std.foldl(f , arr, []),
+        std.foldl(f, arr, []),
 
     set(arr)::
         std.uniq(std.sort(arr)),
@@ -1002,6 +1014,25 @@ in range])
 
     resolvePath(f, r)::
         local arr = std.split(f, "/");
-        std.join("/", std.makeArray(std.length(arr)-1, function(i)arr[i]) + [r]),
-
+        std.join("/", std.makeArray(std.length(arr) - 1, function(i) arr[i]) + [r]),
+
+    prune(a)::
+        local isContent(b) =
+            local t = std.type(b);
+            if b == null then
+                false
+            else if t == "array" then
+                std.length(b) > 0
+            else if t == "object" then
+                std.length(b) > 0
+            else
+                true;
+        local t = std.type(a);
+        if t== "array" then
+            [ std.prune(x) for x in a if isContent($.prune(x)) ]
+        else if t == "object" then {
+            [x]: $.prune(a[x])
+            for x in std.objectFields(a) if isContent(std.prune(a[x]))
+        } else
+            a,
 }
diff --git a/libjsonnet/third_party/md5/BUILD b/libjsonnet/third_party/md5/BUILD
new file mode 100644
index 0000000..5610367
--- /dev/null
+++ b/libjsonnet/third_party/md5/BUILD
@@ -0,0 +1,15 @@
+licenses(["permissive"])
+package(default_visibility = ["//visibility:public"])
+
+cc_library(
+    name = "libmd5",
+    srcs = [
+        "md5.cpp",
+    ],
+    hdrs = [
+        "md5.h",
+    ],
+    linkopts = ["-lm"],
+    includes = ["."],
+)
+
diff --git a/libjsonnet/third_party/md5/LICENSE b/libjsonnet/third_party/md5/LICENSE
new file mode 100644
index 0000000..e1ec4b8
--- /dev/null
+++ b/libjsonnet/third_party/md5/LICENSE
@@ -0,0 +1,29 @@
+MD5
+Converted to C++ class by Frank Thilo (thilo@unix-ag.org)
+for bzflag (http://www.bzflag.org)
+ 
+based on:
+
+md5.h and md5.c
+reference implementation of RFC 1321
+ 
+Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All
+rights reserved.
+ 
+License to copy and use this software is granted provided that it
+is identified as the "RSA Data Security, Inc. MD5 Message-Digest
+Algorithm" in all material mentioning or referencing this software
+or this function.
+ 
+License is also granted to make and use derivative works provided
+that such works are identified as "derived from the RSA Data
+Security, Inc. MD5 Message-Digest Algorithm" in all material
+mentioning or referencing the derived work.
+ 
+RSA Data Security, Inc. makes no representations concerning either
+the merchantability of this software or the suitability of this
+software for any particular purpose. It is provided "as is"
+without express or implied warranty of any kind.
+ 
+These notices must be retained in any copies of any part of this
+documentation and/or software.
diff --git a/libjsonnet/third_party/md5/md5.cpp b/libjsonnet/third_party/md5/md5.cpp
new file mode 100644
index 0000000..b51d2e9
--- /dev/null
+++ b/libjsonnet/third_party/md5/md5.cpp
@@ -0,0 +1,363 @@
+/* MD5
+ converted to C++ class by Frank Thilo (thilo@unix-ag.org)
+ for bzflag (http://www.bzflag.org)
+ 
+   based on:
+ 
+   md5.h and md5.c
+   reference implemantion of RFC 1321
+ 
+   Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All
+rights reserved.
+ 
+License to copy and use this software is granted provided that it
+is identified as the "RSA Data Security, Inc. MD5 Message-Digest
+Algorithm" in all material mentioning or referencing this software
+or this function.
+ 
+License is also granted to make and use derivative works provided
+that such works are identified as "derived from the RSA Data
+Security, Inc. MD5 Message-Digest Algorithm" in all material
+mentioning or referencing the derived work.
+ 
+RSA Data Security, Inc. makes no representations concerning either
+the merchantability of this software or the suitability of this
+software for any particular purpose. It is provided "as is"
+without express or implied warranty of any kind.
+ 
+These notices must be retained in any copies of any part of this
+documentation and/or software.
+ 
+*/
+ 
+/* interface header */
+#include "md5.h"
+ 
+/* system implementation headers */
+#include <cstdio>
+ 
+ 
+// Constants for MD5Transform routine.
+#define S11 7
+#define S12 12
+#define S13 17
+#define S14 22
+#define S21 5
+#define S22 9
+#define S23 14
+#define S24 20
+#define S31 4
+#define S32 11
+#define S33 16
+#define S34 23
+#define S41 6
+#define S42 10
+#define S43 15
+#define S44 21
+ 
+///////////////////////////////////////////////
+ 
+// F, G, H and I are basic MD5 functions.
+inline MD5::uint4 MD5::F(uint4 x, uint4 y, uint4 z) {
+  return (x&y) | (~x&z);
+}
+ 
+inline MD5::uint4 MD5::G(uint4 x, uint4 y, uint4 z) {
+  return (x&z) | (y&~z);
+}
+ 
+inline MD5::uint4 MD5::H(uint4 x, uint4 y, uint4 z) {
+  return x^y^z;
+}
+ 
+inline MD5::uint4 MD5::I(uint4 x, uint4 y, uint4 z) {
+  return y ^ (x | ~z);
+}
+ 
+// rotate_left rotates x left n bits.
+inline MD5::uint4 MD5::rotate_left(uint4 x, int n) {
+  return (x << n) | (x >> (32-n));
+}
+ 
+// FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4.
+// Rotation is separate from addition to prevent recomputation.
+inline void MD5::FF(uint4 &a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac) {
+  a = rotate_left(a+ F(b,c,d) + x + ac, s) + b;
+}
+ 
+inline void MD5::GG(uint4 &a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac) {
+  a = rotate_left(a + G(b,c,d) + x + ac, s) + b;
+}
+ 
+inline void MD5::HH(uint4 &a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac) {
+  a = rotate_left(a + H(b,c,d) + x + ac, s) + b;
+}
+ 
+inline void MD5::II(uint4 &a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac) {
+  a = rotate_left(a + I(b,c,d) + x + ac, s) + b;
+}
+ 
+//////////////////////////////////////////////
+ 
+// default ctor, just initailize
+MD5::MD5()
+{
+  init();
+}
+ 
+//////////////////////////////////////////////
+ 
+// nifty shortcut ctor, compute MD5 for string and finalize it right away
+MD5::MD5(const std::string &text)
+{
+  init();
+  update(text.c_str(), text.length());
+  finalize();
+}
+ 
+//////////////////////////////
+ 
+void MD5::init()
+{
+  finalized=false;
+ 
+  count[0] = 0;
+  count[1] = 0;
+ 
+  // load magic initialization constants.
+  state[0] = 0x67452301;
+  state[1] = 0xefcdab89;
+  state[2] = 0x98badcfe;
+  state[3] = 0x10325476;
+}
+ 
+//////////////////////////////
+ 
+// decodes input (unsigned char) into output (uint4). Assumes len is a multiple of 4.
+void MD5::decode(uint4 output[], const uint1 input[], size_type len)
+{
+  for (unsigned int i = 0, j = 0; j < len; i++, j += 4)
+    output[i] = ((uint4)input[j]) | (((uint4)input[j+1]) << 8) |
+      (((uint4)input[j+2]) << 16) | (((uint4)input[j+3]) << 24);
+}
+ 
+//////////////////////////////
+ 
+// encodes input (uint4) into output (unsigned char). Assumes len is
+// a multiple of 4.
+void MD5::encode(uint1 output[], const uint4 input[], size_type len)
+{
+  for (size_type i = 0, j = 0; j < len; i++, j += 4) {
+    output[j] = input[i] & 0xff;
+    output[j+1] = (input[i] >> 8) & 0xff;
+    output[j+2] = (input[i] >> 16) & 0xff;
+    output[j+3] = (input[i] >> 24) & 0xff;
+  }
+}
+ 
+//////////////////////////////
+ 
+// apply MD5 algo on a block
+void MD5::transform(const uint1 block[blocksize])
+{
+  uint4 a = state[0], b = state[1], c = state[2], d = state[3], x[16];
+  decode (x, block, blocksize);
+ 
+  /* Round 1 */
+  FF (a, b, c, d, x[ 0], S11, 0xd76aa478); /* 1 */
+  FF (d, a, b, c, x[ 1], S12, 0xe8c7b756); /* 2 */
+  FF (c, d, a, b, x[ 2], S13, 0x242070db); /* 3 */
+  FF (b, c, d, a, x[ 3], S14, 0xc1bdceee); /* 4 */
+  FF (a, b, c, d, x[ 4], S11, 0xf57c0faf); /* 5 */
+  FF (d, a, b, c, x[ 5], S12, 0x4787c62a); /* 6 */
+  FF (c, d, a, b, x[ 6], S13, 0xa8304613); /* 7 */
+  FF (b, c, d, a, x[ 7], S14, 0xfd469501); /* 8 */
+  FF (a, b, c, d, x[ 8], S11, 0x698098d8); /* 9 */
+  FF (d, a, b, c, x[ 9], S12, 0x8b44f7af); /* 10 */
+  FF (c, d, a, b, x[10], S13, 0xffff5bb1); /* 11 */
+  FF (b, c, d, a, x[11], S14, 0x895cd7be); /* 12 */
+  FF (a, b, c, d, x[12], S11, 0x6b901122); /* 13 */
+  FF (d, a, b, c, x[13], S12, 0xfd987193); /* 14 */
+  FF (c, d, a, b, x[14], S13, 0xa679438e); /* 15 */
+  FF (b, c, d, a, x[15], S14, 0x49b40821); /* 16 */
+ 
+  /* Round 2 */
+  GG (a, b, c, d, x[ 1], S21, 0xf61e2562); /* 17 */
+  GG (d, a, b, c, x[ 6], S22, 0xc040b340); /* 18 */
+  GG (c, d, a, b, x[11], S23, 0x265e5a51); /* 19 */
+  GG (b, c, d, a, x[ 0], S24, 0xe9b6c7aa); /* 20 */
+  GG (a, b, c, d, x[ 5], S21, 0xd62f105d); /* 21 */
+  GG (d, a, b, c, x[10], S22,  0x2441453); /* 22 */
+  GG (c, d, a, b, x[15], S23, 0xd8a1e681); /* 23 */
+  GG (b, c, d, a, x[ 4], S24, 0xe7d3fbc8); /* 24 */
+  GG (a, b, c, d, x[ 9], S21, 0x21e1cde6); /* 25 */
+  GG (d, a, b, c, x[14], S22, 0xc33707d6); /* 26 */
+  GG (c, d, a, b, x[ 3], S23, 0xf4d50d87); /* 27 */
+  GG (b, c, d, a, x[ 8], S24, 0x455a14ed); /* 28 */
+  GG (a, b, c, d, x[13], S21, 0xa9e3e905); /* 29 */
+  GG (d, a, b, c, x[ 2], S22, 0xfcefa3f8); /* 30 */
+  GG (c, d, a, b, x[ 7], S23, 0x676f02d9); /* 31 */
+  GG (b, c, d, a, x[12], S24, 0x8d2a4c8a); /* 32 */
+ 
+  /* Round 3 */
+  HH (a, b, c, d, x[ 5], S31, 0xfffa3942); /* 33 */
+  HH (d, a, b, c, x[ 8], S32, 0x8771f681); /* 34 */
+  HH (c, d, a, b, x[11], S33, 0x6d9d6122); /* 35 */
+  HH (b, c, d, a, x[14], S34, 0xfde5380c); /* 36 */
+  HH (a, b, c, d, x[ 1], S31, 0xa4beea44); /* 37 */
+  HH (d, a, b, c, x[ 4], S32, 0x4bdecfa9); /* 38 */
+  HH (c, d, a, b, x[ 7], S33, 0xf6bb4b60); /* 39 */
+  HH (b, c, d, a, x[10], S34, 0xbebfbc70); /* 40 */
+  HH (a, b, c, d, x[13], S31, 0x289b7ec6); /* 41 */
+  HH (d, a, b, c, x[ 0], S32, 0xeaa127fa); /* 42 */
+  HH (c, d, a, b, x[ 3], S33, 0xd4ef3085); /* 43 */
+  HH (b, c, d, a, x[ 6], S34,  0x4881d05); /* 44 */
+  HH (a, b, c, d, x[ 9], S31, 0xd9d4d039); /* 45 */
+  HH (d, a, b, c, x[12], S32, 0xe6db99e5); /* 46 */
+  HH (c, d, a, b, x[15], S33, 0x1fa27cf8); /* 47 */
+  HH (b, c, d, a, x[ 2], S34, 0xc4ac5665); /* 48 */
+ 
+  /* Round 4 */
+  II (a, b, c, d, x[ 0], S41, 0xf4292244); /* 49 */
+  II (d, a, b, c, x[ 7], S42, 0x432aff97); /* 50 */
+  II (c, d, a, b, x[14], S43, 0xab9423a7); /* 51 */
+  II (b, c, d, a, x[ 5], S44, 0xfc93a039); /* 52 */
+  II (a, b, c, d, x[12], S41, 0x655b59c3); /* 53 */
+  II (d, a, b, c, x[ 3], S42, 0x8f0ccc92); /* 54 */
+  II (c, d, a, b, x[10], S43, 0xffeff47d); /* 55 */
+  II (b, c, d, a, x[ 1], S44, 0x85845dd1); /* 56 */
+  II (a, b, c, d, x[ 8], S41, 0x6fa87e4f); /* 57 */
+  II (d, a, b, c, x[15], S42, 0xfe2ce6e0); /* 58 */
+  II (c, d, a, b, x[ 6], S43, 0xa3014314); /* 59 */
+  II (b, c, d, a, x[13], S44, 0x4e0811a1); /* 60 */
+  II (a, b, c, d, x[ 4], S41, 0xf7537e82); /* 61 */
+  II (d, a, b, c, x[11], S42, 0xbd3af235); /* 62 */
+  II (c, d, a, b, x[ 2], S43, 0x2ad7d2bb); /* 63 */
+  II (b, c, d, a, x[ 9], S44, 0xeb86d391); /* 64 */
+ 
+  state[0] += a;
+  state[1] += b;
+  state[2] += c;
+  state[3] += d;
+ 
+  // Zeroize sensitive information.
+  memset(x, 0, sizeof x);
+}
+ 
+//////////////////////////////
+ 
+// MD5 block update operation. Continues an MD5 message-digest
+// operation, processing another message block
+void MD5::update(const unsigned char input[], size_type length)
+{
+  // compute number of bytes mod 64
+  size_type index = count[0] / 8 % blocksize;
+ 
+  // Update number of bits
+  if ((count[0] += (length << 3)) < (length << 3))
+    count[1]++;
+  count[1] += (length >> 29);
+ 
+  // number of bytes we need to fill in buffer
+  size_type firstpart = 64 - index;
+ 
+  size_type i;
+ 
+  // transform as many times as possible.
+  if (length >= firstpart)
+  {
+    // fill buffer first, transform
+    memcpy(&buffer[index], input, firstpart);
+    transform(buffer);
+ 
+    // transform chunks of blocksize (64 bytes)
+    for (i = firstpart; i + blocksize <= length; i += blocksize)
+      transform(&input[i]);
+ 
+    index = 0;
+  }
+  else
+    i = 0;
+ 
+  // buffer remaining input
+  memcpy(&buffer[index], &input[i], length-i);
+}
+ 
+//////////////////////////////
+ 
+// for convenience provide a verson with signed char
+void MD5::update(const char input[], size_type length)
+{
+  update((const unsigned char*)input, length);
+}
+ 
+//////////////////////////////
+ 
+// MD5 finalization. Ends an MD5 message-digest operation, writing the
+// the message digest and zeroizing the context.
+MD5& MD5::finalize()
+{
+  static unsigned char padding[64] = {
+    0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
+  };
+ 
+  if (!finalized) {
+    // Save number of bits
+    unsigned char bits[8];
+    encode(bits, count, 8);
+ 
+    // pad out to 56 mod 64.
+    size_type index = count[0] / 8 % 64;
+    size_type padLen = (index < 56) ? (56 - index) : (120 - index);
+    update(padding, padLen);
+ 
+    // Append length (before padding)
+    update(bits, 8);
+ 
+    // Store state in digest
+    encode(digest, state, 16);
+ 
+    // Zeroize sensitive information.
+    memset(buffer, 0, sizeof buffer);
+    memset(count, 0, sizeof count);
+ 
+    finalized=true;
+  }
+ 
+  return *this;
+}
+ 
+//////////////////////////////
+ 
+// return hex representation of digest as string
+std::string MD5::hexdigest() const
+{
+  if (!finalized)
+    return "";
+ 
+  char buf[33];
+  for (int i=0; i<16; i++)
+    sprintf(buf+i*2, "%02x", digest[i]);
+  buf[32]=0;
+ 
+  return std::string(buf);
+}
+ 
+//////////////////////////////
+ 
+std::ostream& operator<<(std::ostream& out, MD5 md5)
+{
+  return out << md5.hexdigest();
+}
+ 
+//////////////////////////////
+ 
+std::string md5(const std::string str)
+{
+    MD5 md5 = MD5(str);
+ 
+    return md5.hexdigest();
+}
+
diff --git a/libjsonnet/third_party/md5/md5.h b/libjsonnet/third_party/md5/md5.h
new file mode 100644
index 0000000..d57b2c6
--- /dev/null
+++ b/libjsonnet/third_party/md5/md5.h
@@ -0,0 +1,93 @@
+/* MD5
+ converted to C++ class by Frank Thilo (thilo@unix-ag.org)
+ for bzflag (http://www.bzflag.org)
+ 
+   based on:
+ 
+   md5.h and md5.c
+   reference implementation of RFC 1321
+ 
+   Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All
+rights reserved.
+ 
+License to copy and use this software is granted provided that it
+is identified as the "RSA Data Security, Inc. MD5 Message-Digest
+Algorithm" in all material mentioning or referencing this software
+or this function.
+ 
+License is also granted to make and use derivative works provided
+that such works are identified as "derived from the RSA Data
+Security, Inc. MD5 Message-Digest Algorithm" in all material
+mentioning or referencing the derived work.
+ 
+RSA Data Security, Inc. makes no representations concerning either
+the merchantability of this software or the suitability of this
+software for any particular purpose. It is provided "as is"
+without express or implied warranty of any kind.
+ 
+These notices must be retained in any copies of any part of this
+documentation and/or software.
+ 
+*/
+ 
+#ifndef BZF_MD5_H
+#define BZF_MD5_H
+ 
+#include <cstring>
+#include <iostream>
+ 
+ 
+// a small class for calculating MD5 hashes of strings or byte arrays
+// it is not meant to be fast or secure
+//
+// usage: 1) feed it blocks of uchars with update()
+//      2) finalize()
+//      3) get hexdigest() string
+//      or
+//      MD5(std::string).hexdigest()
+//
+// assumes that char is 8 bit and int is 32 bit
+class MD5
+{
+public:
+  typedef unsigned int size_type; // must be 32bit
+ 
+  MD5();
+  MD5(const std::string& text);
+  void update(const unsigned char *buf, size_type length);
+  void update(const char *buf, size_type length);
+  MD5& finalize();
+  std::string hexdigest() const;
+  friend std::ostream& operator<<(std::ostream&, MD5 md5);
+ 
+private:
+  void init();
+  typedef unsigned char uint1; //  8bit
+  typedef unsigned int uint4;  // 32bit
+  enum {blocksize = 64}; // VC6 won't eat a const static int here
+ 
+  void transform(const uint1 block[blocksize]);
+  static void decode(uint4 output[], const uint1 input[], size_type len);
+  static void encode(uint1 output[], const uint4 input[], size_type len);
+ 
+  bool finalized;
+  uint1 buffer[blocksize]; // bytes that didn't fit in last 64 byte chunk
+  uint4 count[2];   // 64bit counter for number of bits (lo, hi)
+  uint4 state[4];   // digest so far
+  uint1 digest[16]; // the result
+ 
+  // low level logic operations
+  static inline uint4 F(uint4 x, uint4 y, uint4 z);
+  static inline uint4 G(uint4 x, uint4 y, uint4 z);
+  static inline uint4 H(uint4 x, uint4 y, uint4 z);
+  static inline uint4 I(uint4 x, uint4 y, uint4 z);
+  static inline uint4 rotate_left(uint4 x, int n);
+  static inline void FF(uint4 &a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac);
+  static inline void GG(uint4 &a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac);
+  static inline void HH(uint4 &a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac);
+  static inline void II(uint4 &a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac);
+};
+ 
+std::string md5(const std::string str);
+ 
+#endif
diff --git a/package.xml b/package.xml
index 0f35c60..b3e888e 100644
--- a/package.xml
+++ b/package.xml
@@ -1,14 +1,24 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<package packagerversion="1.9.4" version="2.0" xmlns="http://pear.php.net/dtd/package-2.0" xmlns:tasks="http://pear.php.net/dtd/tasks-1.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://pear.php.net/dtd/tasks-1.0 http://pear.php.net/dtd/tasks-1.0.xsd http://pear.php.net/dtd/package-2.0 http://pear.php.net/dtd/package-2.0.xsd">
+<package packagerversion="1.9.4" version="2.0" xmlns="http://pear.php.net/dtd/package-2.0"
+         xmlns:tasks="http://pear.php.net/dtd/tasks-1.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://pear.php.net/dtd/tasks-1.0 http://pear.php.net/dtd/tasks-1.0.xsd http://pear.php.net/dtd/package-2.0 http://pear.php.net/dtd/package-2.0.xsd">
     <name>JsonNet</name>
     <channel>pecl.php.net</channel>
     <summary>The Google JsonNet for PHP.</summary>
     <description>
         The Google JsonNet for PHP.
 
-        Jsonnet language, from its most basic features to its powerful object model, punctuated with examples drawn from the world of cocktails. These examples are meant to be fun, and although a little contrived, do not restrict our thinking to any one particular application of Jsonnet.
+        Jsonnet language, from its most basic features to its powerful object model, punctuated with examples drawn from
+        the world of cocktails. These examples are meant to be fun, and although a little contrived, do not restrict our
+        thinking to any one particular application of Jsonnet.
 
-        Caveat: Note that Jsonnet unparses JSON in a simple way. In particular, it alphabetically reorders object fields in its output. This is natural and compatible with JSON, since if order is meaningful, an array of pairs should be used instead of an object. Also, unparsing JSON using a canonical ordering of field names makes it possible to use diff to compare outputs. However, the example output on this page has been manually re-ordered in order to allow easier visual comparison to the given input. The whitespace of the output has also been tweaked to make it fit more neatly on the page. So, if you run these examples yourself, the output might be different (but equivalent).
+        Caveat: Note that Jsonnet unparses JSON in a simple way. In particular, it alphabetically reorders object fields
+        in its output. This is natural and compatible with JSON, since if order is meaningful, an array of pairs should
+        be used instead of an object. Also, unparsing JSON using a canonical ordering of field names makes it possible
+        to use diff to compare outputs. However, the example output on this page has been manually re-ordered in order
+        to allow easier visual comparison to the given input. The whitespace of the output has also been tweaked to make
+        it fit more neatly on the page. So, if you run these examples yourself, the output might be different (but
+        equivalent).
     </description>
     <lead>
         <name>Chitao Gao</name>
@@ -16,11 +26,11 @@
         <email>neeke@php.net</email>
         <active>yes</active>
     </lead>
-    <date>2016-08-07</date>
-    <time>15:15:00</time>
+    <date>2017-11-28</date>
+    <time>21:45:00</time>
     <version>
-        <release>1.1.1</release>
-        <api>1.1.0</api>
+        <release>1.2.0</release>
+        <api>1.2.0</api>
     </version>
     <stability>
         <release>stable</release>
@@ -28,28 +38,30 @@
     </stability>
     <license uri="http://www.apache.org/licenses/LICENSE-2.0.html">Apache2.0</license>
     <notes>
-        - Fixed issue #4, pecl install failed.
+        - Update Lib JsonNet use v0.9.5.
+        - Add function JsonNet::fmtFile.
+        - Add function JsonNet::fmtSnippet.
     </notes>
     <contents>
         <dir name="/">
-            <file role="doc" name="CREDITS" />
-            <file role="doc" name="README.md" />
-            <file role="doc" name="LICENSE" />
-            <file role="src" name="config.m4" />
-            <file role="src" name="config.w32" />
-            <file role="src" name="CREDITS" />
-            <file role="src" name="EXPERIMENTAL" />
-            <file role="src" name="php_jsonnet.h" />
-            <file role="src" name="jsonnet.c" />
+            <file role="doc" name="CREDITS"/>
+            <file role="doc" name="README.md"/>
+            <file role="doc" name="LICENSE"/>
+            <file role="src" name="config.m4"/>
+            <file role="src" name="config.w32"/>
+            <file role="src" name="CREDITS"/>
+            <file role="src" name="EXPERIMENTAL"/>
+            <file role="src" name="php_jsonnet.h"/>
+            <file role="src" name="jsonnet.c"/>
             <dir name="test">
-                <file role="src" name="bar_menu.1.jsonnet" />
-                <file role="src" name="bar_menu.2.jsonnet" />
-                <file role="src" name="bar_menu.3.jsonnet" />
-                <file role="src" name="bar_menu.5.jsonnet" />
-                <file role="src" name="bar_menu.6.jsonnet" />
-                <file role="src" name="martinis.jsonnet" />
-                <file role="src" name="utf8.jsonnet" />
-                <file role="src" name="test.jsonnet.php" />
+                <file role="src" name="bar_menu.1.jsonnet"/>
+                <file role="src" name="bar_menu.2.jsonnet"/>
+                <file role="src" name="bar_menu.3.jsonnet"/>
+                <file role="src" name="bar_menu.5.jsonnet"/>
+                <file role="src" name="bar_menu.6.jsonnet"/>
+                <file role="src" name="martinis.jsonnet"/>
+                <file role="src" name="utf8.jsonnet"/>
+                <file role="src" name="test.jsonnet.php"/>
             </dir>
             <dir name="libjsonnet">
                 <file role="src" name="LICENSE"/>
@@ -87,6 +99,8 @@
                     <file role="src" name="parser.cpp"/>
                     <file role="src" name="parser.h"/>
                     <file role="src" name="parser_test.cpp"/>
+                    <file role="src" name="pass.cpp"/>
+                    <file role="src" name="pass.h"/>
                     <file role="src" name="state.h"/>
                     <file role="src" name="static_analysis.cpp"/>
                     <file role="src" name="static_analysis.h"/>
@@ -101,6 +115,14 @@
                     <file role="src" name="BUILD"/>
                     <file role="src" name="jsonnet.cpp"/>
                 </dir>
+                <dir name="third_party">
+                    <dir name="md5">
+                        <file role="src" name="BUILD"/>
+                        <file role="src" name="LICENSE"/>
+                        <file role="src" name="md5.cpp"/>
+                        <file role="src" name="md5.h"/>
+                    </dir>
+                </dir>
             </dir>
         </dir>
     </contents>
@@ -115,7 +137,7 @@
         </required>
     </dependencies>
     <providesextension>jsonnet</providesextension>
-    <extsrcrelease />
+    <extsrcrelease/>
     <changelog>
         <release>
             <date>2015-05-31</date>
@@ -150,5 +172,21 @@
                 - Fixed issue #1 #2, install error and .so load failed.
             </notes>
         </release>
+        <release>
+            <date>2016-08-07</date>
+            <time>15:15:00</time>
+            <version>
+                <release>1.1.1</release>
+                <api>1.1.0</api>
+            </version>
+            <stability>
+                <release>stable</release>
+                <api>stable</api>
+            </stability>
+            <license uri="http://www.apache.org/licenses/LICENSE-2.0.html">Apache2.0</license>
+            <notes>
+                - Fixed issue #4, pecl install failed.
+            </notes>
+        </release>
     </changelog>
 </package>
\ No newline at end of file
diff --git a/php_jsonnet.h b/php_jsonnet.h
index 584d241..be00ac1 100755
--- a/php_jsonnet.h
+++ b/php_jsonnet.h
@@ -17,14 +17,14 @@ extern zend_module_entry jsonnet_module_entry;
 #include "TSRM.h"
 #endif
 
-#define JSONNET_RES_NAME                    "JsonNet"
-#define JSONNET_PHP_VERSION                 "v1.1.1"
-#define JSONNET_PHP_AUTHOR                  "Chitao.Gao  [ neeke@php.net ]"
+#define JSONNET_RES_NAME        "JsonNet"
+#define JSONNET_PHP_VERSION     "v1.2.0"
+#define JSONNET_PHP_AUTHOR      "Chitao.Gao  [ neeke@php.net ]"
 
-#define SL_S(s)                             s, sizeof(s) - 1
+#define SL_S(s)                 s, sizeof(s) - 1
 
-#define CODE_SUCCESS      1000
-#define CODE_ERROR        900
+#define CODE_SUCCESS            1000
+#define CODE_ERROR              900
 
 PHP_MINIT_FUNCTION(jsonnet);
 PHP_MSHUTDOWN_FUNCTION(jsonnet);
@@ -41,6 +41,8 @@ PHP_METHOD(JSONNET_RES_NAME, __construct);
 PHP_METHOD(JSONNET_RES_NAME, __destruct);
 PHP_METHOD(JSONNET_RES_NAME, evaluateFile);
 PHP_METHOD(JSONNET_RES_NAME, evaluateSnippet);
+PHP_METHOD(JSONNET_RES_NAME, fmtFile);
+PHP_METHOD(JSONNET_RES_NAME, fmtSnippet);
 
 ZEND_BEGIN_MODULE_GLOBALS(jsonnet)
 
diff --git a/test/test.jsonnet.php b/test/test.jsonnet.php
index c94fc69..2767689 100644
--- a/test/test.jsonnet.php
+++ b/test/test.jsonnet.php
@@ -10,6 +10,7 @@
 
 
     var_dump(JsonNet::evaluateFile('bar_menu.1.jsonnet'));
+    var_dump(JsonNet::fmtFile('bar_menu.1.jsonnet'));
     var_dump(JsonNet::evaluateFile('bar_menu.2.jsonnet'));
     var_dump(JsonNet::evaluateFile('bar_menu.3.jsonnet'));
     var_dump(JsonNet::evaluateFile('bar_menu.5.jsonnet'));
@@ -46,6 +47,7 @@
 
     ';
 
+    var_dump(JsonNet::fmtSnippet($Snippet));
     var_dump(JsonNet::evaluateSnippet($Snippet));
 } catch (Exception $e) {