From 16d8faa31adcd5cba6aac76dfc73e72251e85c92 Mon Sep 17 00:00:00 2001
From: Ramon Asuncion <asuncionbatista@gmail.com>
Date: Wed, 10 Dec 2025 19:39:41 -0500
Subject: [PATCH 01/56] Update header to <csignal> and use `const`.

---
 compiler/parachute.cpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/compiler/parachute.cpp b/compiler/parachute.cpp
index 308312cb..6bb047c2 100644
--- a/compiler/parachute.cpp
+++ b/compiler/parachute.cpp
@@ -55,13 +55,13 @@ namespace clay {
 
 // Signal parachute
 
-#include <signal.h>
+#include <csignal>
 
 namespace clay {
     static volatile int threatLevel = 0;
 
-    static void emergencyCompileContext(int sig) {
-        int oldThreatLevel = __sync_fetch_and_add(&threatLevel, 1);
+    static void emergencyCompileContext(const int sig) {
+        const int oldThreatLevel = __sync_fetch_and_add(&threatLevel, 1);
         if (oldThreatLevel == 0) {
             fprintf(stderr, "signal %d!\n", sig);
             displayCompileContext();

From 2f3625cb691d608ee9afa584a2fac5d83aec62ad Mon Sep 17 00:00:00 2001
From: Ramon Asuncion <asuncionbatista@gmail.com>
Date: Wed, 10 Dec 2025 21:45:52 -0500
Subject: [PATCH 02/56] Remove deprecated Path from RemoveFileOnSignal

---
 compiler/clay.cpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/compiler/clay.cpp b/compiler/clay.cpp
index 6a034da0..3b1b4efe 100644
--- a/compiler/clay.cpp
+++ b/compiler/clay.cpp
@@ -311,7 +311,7 @@ namespace clay {
             llvm::errs() << "error creating temporary object file: " << ec.message() << '\n';
             return false;
         }
-        llvm::sys::RemoveFileOnSignal(llvm::sys::Path(tempObj));
+        llvm::sys::RemoveFileOnSignal(tempObj);
 
         {
             llvm::raw_fd_ostream objOut(fd, /*shouldClose=*/ true);
@@ -1024,7 +1024,7 @@ namespace clay {
                 llvm::errs() << "error: output file '" << outputFile << "' is a directory\n";
                 return 1;
             }
-            llvm::sys::RemoveFileOnSignal(llvm::sys::Path(outputFile));
+            llvm::sys::RemoveFileOnSignal(outputFile);
         }
 
         if (generateDeps) {
@@ -1044,7 +1044,7 @@ namespace clay {
                 llvm::errs() << "error: dependencies output file '" << dependenciesOutputFile << "' is a directory\n";
                 return 1;
             }
-            llvm::sys::RemoveFileOnSignal(llvm::sys::Path(dependenciesOutputFile));
+            llvm::sys::RemoveFileOnSignal(dependenciesOutputFile);
         }
 
         HiResTimer loadTimer, compileTimer, optTimer, outputTimer;

From d4ad0f3aba06d129b68e78de6c0520d8658a3be3 Mon Sep 17 00:00:00 2001
From: Ramon Asuncion <asuncionbatista@gmail.com>
Date: Wed, 10 Dec 2025 21:47:37 -0500
Subject: [PATCH 03/56] Update generateBinary and helper to modern LLVM

---
 compiler/clay.cpp | 54 +++++++++++++++++++++++------------------------
 1 file changed, 27 insertions(+), 27 deletions(-)

diff --git a/compiler/clay.cpp b/compiler/clay.cpp
index 3b1b4efe..ffa5cfb7 100644
--- a/compiler/clay.cpp
+++ b/compiler/clay.cpp
@@ -28,8 +28,8 @@ namespace clay {
 
     using namespace std;
 
-    static void addOptimizationPasses(llvm::legacy::PassManager &passes,
-                                      llvm::legacy::FunctionPassManager &fpasses,
+    static void addOptimizationPasses(llvm::PassManager &passes,
+                                      llvm::FunctionPassManager &fpasses,
                                       unsigned optLevel,
                                       bool internalize) {
         llvm::Pass *inliningPass = 0;
@@ -280,18 +280,14 @@ namespace clay {
         fpasses.doFinalization();
     }
 
-    static string joinCmdArgs(llvm::ArrayRef<const char *> args) {
+    static string joinCmdArgs(llvm::ArrayRef<llvm::StringRef> args) {
         string s;
         llvm::raw_string_ostream ss(s);
-        for (char const *const *arg = args.begin();
-             arg != args.end(); ++arg) {
-            if (arg != args.begin()) {
+        for (const llvm::StringRef &arg : args) {
+            if (&arg != args.begin()) {
                 ss << " ";
             }
-            if (*arg == 0 && arg + 1 == args.end()) {
-                continue;
-            }
-            ss << *arg;
+            ss << arg;
         }
         return s;
     }
@@ -299,7 +295,7 @@ namespace clay {
     static bool generateBinary(llvm::Module *module,
                                llvm::TargetMachine *targetMachine,
                                llvm::Twine const &outputFilePath,
-                               llvm::sys::Path const &clangPath,
+                               llvm::StringRef const &clangPath,
                                bool /*exceptions*/,
                                bool sharedLib,
                                bool debug,
@@ -307,7 +303,7 @@ namespace clay {
                                bool verbose) {
         int fd;
         PathString tempObj;
-        if (llvm::error_code ec = llvm::sys::fs::unique_file("clayobj-%%%%%%%%.obj", fd, tempObj)) {
+        if (std::error_code ec = llvm::sys::fs::createUniqueFile("clayobj-%%%%%%%%.obj", fd, tempObj)) {
             llvm::errs() << "error creating temporary object file: " << ec.message() << '\n';
             return false;
         }
@@ -321,8 +317,8 @@ namespace clay {
 
         string outputFilePathStr = outputFilePath.str();
 
-        vector<const char *> clangArgs;
-        clangArgs.push_back(clangPath.c_str());
+        std::vector<llvm::StringRef> clangArgs;
+        clangArgs.push_back(clangPath.data());
 
         switch (llvmDataLayout->getPointerSizeInBits()) {
             case 32:
@@ -340,8 +336,7 @@ namespace clay {
         if (sharedLib) {
             clangArgs.push_back("-shared");
 
-            if (triple.getOS() == llvm::Triple::MinGW32
-                || triple.getOS() == llvm::Triple::Cygwin) {
+            if (triple.isOSWindows()) {
                 PathString defPath;
                 outputFilePath.toVector(defPath);
                 llvm::sys::path::replace_extension(defPath, "def");
@@ -356,39 +351,44 @@ namespace clay {
                 clangArgs.push_back("-Wl,/debug");
         }
         clangArgs.push_back("-o");
-        clangArgs.push_back(outputFilePathStr.c_str());
-        clangArgs.push_back(tempObj.c_str());
+        clangArgs.push_back(outputFilePathStr);
+        clangArgs.push_back(tempObj);
         for (unsigned i = 0; i < arguments.size(); ++i)
             clangArgs.push_back(arguments[i].c_str());
-        clangArgs.push_back(nullptr);
 
         if (verbose) {
             llvm::errs() << "executing clang to generate binary:\n";
             llvm::errs() << "    " << joinCmdArgs(clangArgs) << "\n";
         }
 
-        int result = llvm::sys::Program::ExecuteAndWait(clangPath, &clangArgs[0]);
+        int result = llvm::sys::ExecuteAndWait(clangPath, clangArgs);
+
+        if (debug && triple.isOSDarwin()) {
+            llvm::ErrorOr<std::string> DsymutilPathOrErr = llvm::sys::findProgramByName("dsymutil");
+            if (std::error_code EC = DsymutilPathOrErr.getError())
+                llvm::errs() << "error creating dsymutil: " << EC.message() << '\n';
 
         if (debug && triple.getOS() == llvm::Triple::Darwin) {
             llvm::sys::Path dsymutilPath = llvm::sys::Program::FindProgramByName("dsymutil");
             if (dsymutilPath.isValid()) {
+            std::string dsymutilPath = DsymutilPathOrErr ? *DsymutilPathOrErr : "";
+
+            if (!dsymutilPath.empty()) {
                 string outputDSYMPath = outputFilePathStr;
                 outputDSYMPath.append(".dSYM");
 
-                vector<const char *> dsymutilArgs;
-                dsymutilArgs.push_back(dsymutilPath.c_str());
+                std::vector<llvm::StringRef> dsymutilArgs;
+                dsymutilArgs.push_back(dsymutilPath);
                 dsymutilArgs.push_back("-o");
-                dsymutilArgs.push_back(outputDSYMPath.c_str());
-                dsymutilArgs.push_back(outputFilePathStr.c_str());
-                dsymutilArgs.push_back(nullptr);
+                dsymutilArgs.push_back(outputDSYMPath);
+                dsymutilArgs.push_back(outputFilePathStr);
 
                 if (verbose) {
                     llvm::errs() << "executing dsymutil:";
                     llvm::errs() << "    " << joinCmdArgs(dsymutilArgs) << "\n";
                 }
 
-                int dsymResult = llvm::sys::Program::ExecuteAndWait(dsymutilPath,
-                                                                    &dsymutilArgs[0]);
+                int dsymResult = llvm::sys::ExecuteAndWait(dsymutilPath, dsymutilArgs);
 
                 if (dsymResult != 0)
                     llvm::errs() << "warning: dsymutil exited with error code " << dsymResult << "\n";

From fc70c2e39848082fd5564cdf2ed5c5b693e50fe5 Mon Sep 17 00:00:00 2001
From: Ramon Asuncion <asuncionbatista@gmail.com>
Date: Wed, 10 Dec 2025 21:47:49 -0500
Subject: [PATCH 04/56] Add header files

---
 compiler/clay.cpp | 19 ++++++++++++++++---
 1 file changed, 16 insertions(+), 3 deletions(-)

diff --git a/compiler/clay.cpp b/compiler/clay.cpp
index ffa5cfb7..1705aa54 100644
--- a/compiler/clay.cpp
+++ b/compiler/clay.cpp
@@ -1,3 +1,19 @@
+#include <llvm/Support/FileSystem.h>
+#include <llvm/Support/raw_os_ostream.h>
+#include <llvm/Support/Path.h>
+#include <llvm/Support/Process.h>
+#include <llvm/Support/Program.h>
+#include "llvm/Support/DynamicLibrary.h"
+#include <llvm/Support/ErrorOr.h>
+#include <llvm/Support/MemoryBuffer.h>
+#include <llvm/Support/Signals.h>
+#include <llvm/TargetParser/Host.h>
+#include <llvm/TargetParser/Triple.h>
+#include <llvm/Linker/Linker.h>
+
+#include <system_error>
+#include <string>
+
 #include "clay.hpp"
 #include "hirestimer.hpp"
 #include "error.hpp"
@@ -368,9 +384,6 @@ namespace clay {
             if (std::error_code EC = DsymutilPathOrErr.getError())
                 llvm::errs() << "error creating dsymutil: " << EC.message() << '\n';
 
-        if (debug && triple.getOS() == llvm::Triple::Darwin) {
-            llvm::sys::Path dsymutilPath = llvm::sys::Program::FindProgramByName("dsymutil");
-            if (dsymutilPath.isValid()) {
             std::string dsymutilPath = DsymutilPathOrErr ? *DsymutilPathOrErr : "";
 
             if (!dsymutilPath.empty()) {

From bb45fb6a8743e8fd6ffd43d2c528581cc9b9b0c3 Mon Sep 17 00:00:00 2001
From: Ramon Asuncion <asuncionbatista@gmail.com>
Date: Wed, 10 Dec 2025 21:48:18 -0500
Subject: [PATCH 05/56] Use modern versions to find OS type

---
 compiler/clay.cpp | 22 ++++++++--------------
 1 file changed, 8 insertions(+), 14 deletions(-)

diff --git a/compiler/clay.cpp b/compiler/clay.cpp
index 1705aa54..1757834b 100644
--- a/compiler/clay.cpp
+++ b/compiler/clay.cpp
@@ -479,33 +479,27 @@ namespace clay {
     }
 
     static string sharedExtensionForTarget(llvm::Triple const &triple) {
-        if (triple.getOS() == llvm::Triple::Win32
-            || triple.getOS() == llvm::Triple::MinGW32
-            || triple.getOS() == llvm::Triple::Cygwin) {
+        if (triple.isOSWindows()) {
             return ".dll";
-        } else if (triple.getOS() == llvm::Triple::Darwin) {
+        }
+        if (triple.isOSDarwin()) {
             return ".dylib";
-        } else {
-            return ".so";
         }
+        return ".so";
     }
 
     static string objExtensionForTarget(llvm::Triple const &triple) {
-        if (triple.getOS() == llvm::Triple::Win32) {
+        if (triple.isOSWindows()) {
             return ".obj";
-        } else {
-            return ".o";
         }
+        return ".o";
     }
 
     static string exeExtensionForTarget(llvm::Triple const &triple) {
-        if (triple.getOS() == llvm::Triple::Win32
-            || triple.getOS() == llvm::Triple::MinGW32
-            || triple.getOS() == llvm::Triple::Cygwin) {
+        if (triple.isOSWindows()) {
             return ".exe";
-        } else {
-            return "";
         }
+        return "";
     }
 
     static void printVersion() {

From 85052ef3c781155d8bb5e84df6a90b03d3d56585 Mon Sep 17 00:00:00 2001
From: Ramon Asuncion <asuncionbatista@gmail.com>
Date: Wed, 10 Dec 2025 21:51:21 -0500
Subject: [PATCH 06/56] Use getMainExecutable from filesystem

---
 compiler/clay.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/compiler/clay.cpp b/compiler/clay.cpp
index 1757834b..4d2519b1 100644
--- a/compiler/clay.cpp
+++ b/compiler/clay.cpp
@@ -983,7 +983,7 @@ namespace clay {
             } while (*end);
         }
         // Add the relative path from the executable
-        PathString clayExe(llvm::sys::Path::GetMainExecutable(argv[0], (void *) (uintptr_t) &usage).c_str());
+        PathString clayExe(llvm::sys::fs::getMainExecutable(argv[0], (void *) (uintptr_t) &usage));
         llvm::StringRef clayDir = llvm::sys::path::parent_path(clayExe);
 
         PathString libDirDevelopment(clayDir);

From 0e6d332e892bb3decf46a5ecb22e011fc5272830 Mon Sep 17 00:00:00 2001
From: Ramon Asuncion <asuncionbatista@gmail.com>
Date: Wed, 10 Dec 2025 22:05:17 -0500
Subject: [PATCH 07/56] Remove the temporary object from generateBinary

---
 compiler/clay.cpp | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/compiler/clay.cpp b/compiler/clay.cpp
index 4d2519b1..cdb51c84 100644
--- a/compiler/clay.cpp
+++ b/compiler/clay.cpp
@@ -10,6 +10,7 @@
 #include <llvm/TargetParser/Host.h>
 #include <llvm/TargetParser/Triple.h>
 #include <llvm/Linker/Linker.h>
+#include <llvm/Support/FileUtilities.h>
 
 #include <system_error>
 #include <string>
@@ -323,7 +324,7 @@ namespace clay {
             llvm::errs() << "error creating temporary object file: " << ec.message() << '\n';
             return false;
         }
-        llvm::sys::RemoveFileOnSignal(tempObj);
+        llvm::FileRemover removeTempObj(tempObj);
 
         {
             llvm::raw_fd_ostream objOut(fd, /*shouldClose=*/ true);
@@ -410,9 +411,6 @@ namespace clay {
                         "warning: unable to find dsymutil on the path; debug info for executable will not be generated\n";
         }
 
-        bool dontcare;
-        llvm::sys::fs::remove(llvm::StringRef(tempObj), dontcare);
-
         return (result == 0);
     }
 

From 32fe90b53fc05cfca6f360d10d0bc4c4ca54a92e Mon Sep 17 00:00:00 2001
From: Ramon Asuncion <asuncionbatista@gmail.com>
Date: Wed, 10 Dec 2025 22:28:59 -0500
Subject: [PATCH 08/56] Use modern features of C++

---
 compiler/clay.cpp | 103 ++++++++++++++++++++++------------------------
 1 file changed, 49 insertions(+), 54 deletions(-)

diff --git a/compiler/clay.cpp b/compiler/clay.cpp
index cdb51c84..7f562c7b 100644
--- a/compiler/clay.cpp
+++ b/compiler/clay.cpp
@@ -49,7 +49,7 @@ namespace clay {
                                       llvm::FunctionPassManager &fpasses,
                                       unsigned optLevel,
                                       bool internalize) {
-        llvm::Pass *inliningPass = 0;
+        llvm::Pass *inliningPass = nullptr;
         if (optLevel > 1) {
             int threshold = 225;
             if (optLevel > 2)
@@ -160,11 +160,11 @@ namespace clay {
                               llvm::ArrayRef<string> libs) {
         if (libs.empty())
             return true;
+
         llvm::Linker linker("clay", llvmModule, llvm::Linker::Verbose);
         linker.addSystemPaths();
         linker.addPaths(libSearchPaths);
-        for (size_t i = 0; i < libs.size(); ++i) {
-            string lib = libs[i];
+        for (auto lib : libs) {
             llvmModule->addLibrary(lib);
             //as in cling/lib/Interpreter/Interpreter.cpp
             bool isNative = true;
@@ -202,11 +202,9 @@ namespace clay {
                 bool hasError = llvm::sys::DynamicLibrary
                         ::LoadLibraryPermanently(SoFile.str().c_str(), &errMsg);
                 if (hasError) {
-                    if (hasError) {
-                        llvm::errs() << "Couldn't load shared library " << lib << "\n" << errMsg.c_str();
-                        linker.releaseModule();
-                        return false;
-                    }
+                    llvm::errs() << "Couldn't load shared library " << lib << "\n" << errMsg.c_str();
+                    linker.releaseModule();
+                    return false;
                 }
             }
         }
@@ -242,7 +240,7 @@ namespace clay {
         llvm::PassManager passes;
 
         string moduleDataLayout = module->getDataLayout();
-        llvm::DataLayout *dl = new llvm::DataLayout(moduleDataLayout);
+        auto *dl = new llvm::DataLayout(moduleDataLayout);
         passes.add(dl);
 
         llvm::FunctionPassManager fpasses(module);
@@ -252,9 +250,8 @@ namespace clay {
         addOptimizationPasses(passes, fpasses, optLevel, internalize);
 
         fpasses.doInitialization();
-        for (llvm::Module::iterator i = module->begin(), e = module->end();
-             i != e; ++i) {
-            fpasses.run(*i);
+        for (auto & i : *module) {
+            fpasses.run(i);
         }
 
         passes.add(llvm::createVerifierPass());
@@ -290,15 +287,15 @@ namespace clay {
         assert(!result);
 
         fpasses.doInitialization();
-        for (llvm::Module::iterator i = module->begin(), e = module->end();
-             i != e; ++i) {
-            fpasses.run(*i);
+        for (auto & i : *module) {
+            fpasses.run(i);
         }
         fpasses.doFinalization();
     }
 
-    static string joinCmdArgs(llvm::ArrayRef<llvm::StringRef> args) {
-        string s;
+    [[maybe_unused]] static std::string joinCmdArgs(llvm::ArrayRef<llvm::StringRef> args)
+    {
+        std::string s;
         llvm::raw_string_ostream ss(s);
         for (const llvm::StringRef &arg : args) {
             if (&arg != args.begin()) {
@@ -335,43 +332,43 @@ namespace clay {
         string outputFilePathStr = outputFilePath.str();
 
         std::vector<llvm::StringRef> clangArgs;
-        clangArgs.push_back(clangPath.data());
+        clangArgs.emplace_back(clangPath.data());
 
         switch (llvmDataLayout->getPointerSizeInBits()) {
             case 32:
-                clangArgs.push_back("-m32");
+                clangArgs.emplace_back("-m32");
                 break;
             case 64:
-                clangArgs.push_back("-m64");
+                clangArgs.emplace_back("-m64");
                 break;
             default:
                 assert(false);
         }
 
         llvm::Triple triple(llvmModule->getTargetTriple());
-        string linkerFlags;
         if (sharedLib) {
-            clangArgs.push_back("-shared");
+            clangArgs.emplace_back("-shared");
 
             if (triple.isOSWindows()) {
+                string linkerFlags;
                 PathString defPath;
                 outputFilePath.toVector(defPath);
                 llvm::sys::path::replace_extension(defPath, "def");
 
                 linkerFlags = "-Wl,--output-def," + string(defPath.begin(), defPath.end());
 
-                clangArgs.push_back(linkerFlags.c_str());
+                clangArgs.emplace_back(linkerFlags);
             }
         }
         if (debug) {
             if (triple.getOS() == llvm::Triple::Win32)
-                clangArgs.push_back("-Wl,/debug");
+                clangArgs.emplace_back("-Wl,/debug");
         }
-        clangArgs.push_back("-o");
-        clangArgs.push_back(outputFilePathStr);
+        clangArgs.emplace_back("-o");
+        clangArgs.emplace_back(outputFilePathStr);
         clangArgs.push_back(tempObj);
-        for (unsigned i = 0; i < arguments.size(); ++i)
-            clangArgs.push_back(arguments[i].c_str());
+        for (const auto & argument : arguments)
+            clangArgs.emplace_back(argument);
 
         if (verbose) {
             llvm::errs() << "executing clang to generate binary:\n";
@@ -392,10 +389,10 @@ namespace clay {
                 outputDSYMPath.append(".dSYM");
 
                 std::vector<llvm::StringRef> dsymutilArgs;
-                dsymutilArgs.push_back(dsymutilPath);
-                dsymutilArgs.push_back("-o");
-                dsymutilArgs.push_back(outputDSYMPath);
-                dsymutilArgs.push_back(outputFilePathStr);
+                dsymutilArgs.emplace_back(dsymutilPath);
+                dsymutilArgs.emplace_back("-o");
+                dsymutilArgs.emplace_back(outputDSYMPath);
+                dsymutilArgs.emplace_back(outputFilePathStr);
 
                 if (verbose) {
                     llvm::errs() << "executing dsymutil:";
@@ -414,7 +411,7 @@ namespace clay {
         return (result == 0);
     }
 
-    static void usage(char *argv0) {
+    static void usage(const char *argv0) {
         llvm::errs() << "usage: " << argv0 << " <options> <clay file>\n";
         llvm::errs() << "       " << argv0 << " <options> -e <clay code>\n";
         llvm::errs() << "options:\n";
@@ -630,7 +627,7 @@ namespace clay {
                 if (dot == nullptr) {
                     logMatchSymbols.insert(make_pair(string("*"), argv[i]));
                 } else {
-                    logMatchSymbols.insert(make_pair(string((char const *) argv[i], dot), string(dot + 1)));
+                    logMatchSymbols.insert(make_pair(string(static_cast<char const *>(argv[i]), dot), string(dot + 1)));
                 }
             } else if (strcmp(argv[i], "-e") == 0) {
                 if (i + 1 == argc) {
@@ -832,7 +829,7 @@ namespace clay {
                         return 1;
                     }
                 }
-                searchPath.push_back(PathString(path));
+                searchPath.emplace_back(path);
             } else if (strstr(argv[i], "-version") == argv[i]
                        || strcmp(argv[i], "--version") == 0) {
                 printVersion();
@@ -964,24 +961,23 @@ namespace clay {
         initExternalTarget(targetTriple);
 
         // Try environment variables first
-        char *libclayPath = getenv("CLAY_PATH");
-        if (libclayPath) {
+        if (char *libclayPath = getenv("CLAY_PATH")) {
             // Parse the environment variable
-            // Format expected is standard PATH form, i.e
-            // CLAY_PATH=path1:path2:path3  (on unix)
-            // CLAY_PATH=path1;path2;path3  (on windows)
+            // Format expected is standard PATH form, i.e.
+            // CLAY_PATH=path1:path2:path3  (on Unix)
+            // CLAY_PATH=path1;path2;path3  (on Windows)
             char *begin = libclayPath;
             char *end;
             do {
                 end = begin;
                 while (*end && (*end != ENV_SEPARATOR))
                     ++end;
-                searchPath.push_back(llvm::StringRef(begin, (size_t) (end - begin)));
+                searchPath.emplace_back(llvm::StringRef(begin, static_cast<size_t>(end - begin)));
                 begin = end + 1;
             } while (*end);
         }
         // Add the relative path from the executable
-        PathString clayExe(llvm::sys::fs::getMainExecutable(argv[0], (void *) (uintptr_t) &usage));
+        PathString clayExe(llvm::sys::fs::getMainExecutable(argv[0], reinterpret_cast<void *>(&usage)));
         llvm::StringRef clayDir = llvm::sys::path::parent_path(clayExe);
 
         PathString libDirDevelopment(clayDir);
@@ -995,14 +991,13 @@ namespace clay {
         searchPath.push_back(libDirDevelopment);
         searchPath.push_back(libDirProduction1);
         searchPath.push_back(libDirProduction2);
-        searchPath.push_back(PathString("."));
+        searchPath.emplace_back(".");
 
         if (verbose) {
             llvm::errs() << "using search path:\n";
 
-            for (std::vector<PathString>::const_iterator it = searchPath.begin();
-                 it != searchPath.end(); ++it) {
-                llvm::errs() << "    " << *it << "\n";
+            for (const auto & it : searchPath) {
+                llvm::errs() << "    " << it << "\n";
             }
         }
 
@@ -1061,9 +1056,9 @@ namespace clay {
             initLoader();
 
             ModulePtr m;
-            string clayScriptSource;
             vector<string> sourceFiles;
             if (!clayScript.empty()) {
+                string clayScriptSource;
                 clayScriptSource = clayScriptImports + "main() {\n" + clayScript + "}";
                 m = loadProgramSource("-e", clayScriptSource, verbose, repl);
             } else if (generateDeps)
@@ -1111,9 +1106,9 @@ namespace clay {
             optTimer.stop();
 
             if (run) {
-                vector<string> argv;
-                argv.push_back(clayFile);
-                runModule(llvmModule, argv, envp, libSearchPath, libraries);
+                vector<string> runArgs;
+                runArgs.push_back(clayFile);
+                runModule(llvmModule, runArgs, envp, libSearchPath, libraries);
             } else if (repl) {
                 linkLibraries(llvmModule, libSearchPath, libraries);
                 runInteractive(llvmModule, m);
@@ -1175,10 +1170,10 @@ namespace clay {
             return 1;
         }
         if (showTiming) {
-            llvm::errs() << "load time = " << (size_t) loadTimer.elapsedMillis() << " ms\n";
-            llvm::errs() << "compile time = " << (size_t) compileTimer.elapsedMillis() << " ms\n";
-            llvm::errs() << "optimization time = " << (size_t) optTimer.elapsedMillis() << " ms\n";
-            llvm::errs() << "codegen time = " << (size_t) outputTimer.elapsedMillis() << " ms\n";
+            llvm::errs() << "load time = " << static_cast<size_t>(loadTimer.elapsedMillis()) << " ms\n";
+            llvm::errs() << "compile time = " << static_cast<size_t>(compileTimer.elapsedMillis()) << " ms\n";
+            llvm::errs() << "optimization time = " << static_cast<size_t>(optTimer.elapsedMillis()) << " ms\n";
+            llvm::errs() << "codegen time = " << static_cast<size_t>(outputTimer.elapsedMillis()) << " ms\n";
             llvm::errs().flush();
         }
 

From 9016c7198360f050f3ca58335c18f861519ab188 Mon Sep 17 00:00:00 2001
From: Ramon Asuncion <asuncionbatista@gmail.com>
Date: Wed, 10 Dec 2025 22:31:24 -0500
Subject: [PATCH 09/56] Remove namespace to std and use C++ iostream

---
 compiler/ut_main.cpp | 15 +++++++--------
 1 file changed, 7 insertions(+), 8 deletions(-)

diff --git a/compiler/ut_main.cpp b/compiler/ut_main.cpp
index 6ba1cfb8..f91ae7aa 100644
--- a/compiler/ut_main.cpp
+++ b/compiler/ut_main.cpp
@@ -1,36 +1,35 @@
+#include <iostream>
 #include <vector>
 
 #include "ut.hpp"
 #include "parachute.hpp"
 
-using namespace std;
-
 namespace clay {
     struct Test {
         const char *name;
         TestFunc func;
     };
 
-    static vector<Test> *tests;
+    static std::vector<Test> *tests;
 
     void register_test(const char *name, const TestFunc func) {
         if (tests == nullptr) {
-            tests = new vector<Test>;
+            tests = new std::vector<Test>;
         }
-        tests->push_back(Test());
+        tests->emplace_back();
         tests->back().name = name;
         tests->back().func = func;
     }
 
     int real_main(int argc, char **argv, char const *const *envp) {
         for (const auto test : *tests) {
-            printf("%s...\n", test.name);
+            std::cout << test.name << "...\n";
             try {
                 test.func();
 
-                printf("%s OK\n", test.name);
+                std::cout << test.name << " OK\n";
             } catch (const AssertionError &) {
-                printf("%s FAILED\n", test.name);
+                std::cout << test.name << " FAILED\n";
             }
         }
         return 0;

From fae00b5a23285cf47143ee6d2cee863f86a3e1d7 Mon Sep 17 00:00:00 2001
From: Ramon Asuncion <asuncionbatista@gmail.com>
Date: Wed, 10 Dec 2025 22:31:52 -0500
Subject: [PATCH 10/56] Remove unused header files. Define them in each
 transition unit.

---
 compiler/clay.hpp | 23 +----------------------
 1 file changed, 1 insertion(+), 22 deletions(-)

diff --git a/compiler/clay.hpp b/compiler/clay.hpp
index cd467c93..778ed0eb 100644
--- a/compiler/clay.hpp
+++ b/compiler/clay.hpp
@@ -23,38 +23,17 @@
 #include <llvm/ADT/StringMap.h>
 #include <llvm/ADT/StringRef.h>
 #include <llvm/AsmParser/Parser.h>
-#include <llvm/Analysis/Passes.h>
 #include <llvm/Bitcode/BitcodeWriter.h>
-#include <llvm/CodeGen/LinkAllAsmWriterComponents.h>
-#include <llvm/CodeGen/LinkAllCodegenComponents.h>
 #include <llvm/CodeGen/ValueTypes.h>
-#include <llvm/IR/Attributes.h>
 #include <llvm/IR/DataLayout.h>
 #include <llvm/IR/DIBuilder.h>
 #include <llvm/IR/DebugInfoMetadata.h>
 #include <llvm/IR/Function.h>
-#include <llvm/IR/IRBuilder.h>
 #include <llvm/IR/Type.h>
-#include <llvm/ExecutionEngine/ExecutionEngine.h>
-#include <llvm/ExecutionEngine/GenericValue.h>
-#include <llvm/MC/TargetRegistry.h>
 #include <llvm/Support/Allocator.h>
-#include <llvm/Support/FileSystem.h>
-#include <llvm/Support/FormattedStream.h>
 #include <llvm/Support/MemoryBuffer.h>
-#include <llvm/Support/Path.h>
-#include <llvm/Support/SourceMgr.h>
-#include <llvm/Support/TargetSelect.h>
-#include <llvm/Support/raw_ostream.h>
-#include <llvm/Support/Error.h>
-#include <llvm/Target/TargetOptions.h>
-#include <llvm/Transforms/IPO.h>
-#include <llvm/Transforms/Scalar.h>
 #include <llvm/Transforms/Scalar/GVN.h>
-#include <llvm/IR/LegacyPassManager.h>
-#include <llvm/Support/Program.h>
-#include <llvm/TargetParser/Host.h>
-#include <llvm/Linker/Linker.h>
+#include <llvm/IR/GlobalVariable.h>
 
 #include <complex>
 

From f690e770c9e3e908ceb7c664eca735b1b21d0e92 Mon Sep 17 00:00:00 2001
From: Ramon Asuncion <asuncionbatista@gmail.com>
Date: Wed, 10 Dec 2025 22:36:31 -0500
Subject: [PATCH 11/56] Specify a minimum version (a guess?)

---
 CMakeLists.txt | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 8388526f..1422db4b 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -35,6 +35,9 @@ if(UNIX)
     if (NOT ${LLVM_CONFIG_VERSION_RESULT} EQUAL 0)
         message(FATAL_ERROR "${LLVM_CONFIG} failed")
     endif()
+    if(LLVM_VERSION VERSION_LESS 18.0)
+        message(FATAL_ERROR "LLVM 18 or newer is required. Found ${LLVM_VERSION}")
+    endif()
 
     execute_process(
         COMMAND ${LLVM_CONFIG} --cxxflags

From 26c0d39bf0c898f93a464911589442b7e591d290 Mon Sep 17 00:00:00 2001
From: Ramon Asuncion <asuncionbatista@gmail.com>
Date: Wed, 10 Dec 2025 22:41:48 -0500
Subject: [PATCH 12/56] Don't create unnecessary object

---
 compiler/profiler.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/compiler/profiler.cpp b/compiler/profiler.cpp
index d473fdb5..b91f8aa5 100644
--- a/compiler/profiler.cpp
+++ b/compiler/profiler.cpp
@@ -22,7 +22,7 @@ namespace clay {
         vector<pair<int, string> > counts;
         llvm::StringMap<int>::iterator cmi = countsMap.begin();
         while (cmi != countsMap.end()) {
-            counts.push_back(vector<pair<int, string>>::value_type(make_pair(cmi->getValue(), cmi->getKey())));
+            counts.emplace_back(cmi->getValue(), cmi->getKey());
             ++cmi;
         }
         sort(counts.begin(), counts.end());

From e9b63a68510ad12c1dc28ea274db7804014f604f Mon Sep 17 00:00:00 2001
From: Ramon Asuncion <asuncionbatista@gmail.com>
Date: Thu, 11 Dec 2025 00:59:04 -0500
Subject: [PATCH 13/56] Use standard error_code to fix F_Binary

---
 compiler/clay.cpp | 15 ++++++++++-----
 1 file changed, 10 insertions(+), 5 deletions(-)

diff --git a/compiler/clay.cpp b/compiler/clay.cpp
index 7f562c7b..5cdc7fdc 100644
--- a/compiler/clay.cpp
+++ b/compiler/clay.cpp
@@ -1113,12 +1113,13 @@ namespace clay {
                 linkLibraries(llvmModule, libSearchPath, libraries);
                 runInteractive(llvmModule, m);
             } else if (emitLLVM || emitAsm || emitObject) {
-                string errorInfo;
+                std::error_code ec;
+
                 llvm::raw_fd_ostream out(outputFile.c_str(),
-                                         errorInfo,
-                                         llvm::raw_fd_ostream::F_Binary);
-                if (!errorInfo.empty()) {
-                    llvm::errs() << "error: " << errorInfo << '\n';
+                                         ec,
+                                         llvm::sys::fs::OF_None);
+                if (ec) {
+                    llvm::errs() << "error creating output file: " << ec.message() << '\n';
                     return 1;
                 }
                 outputTimer.start();
@@ -1132,8 +1133,12 @@ namespace clay {
                 llvm::sys::Path clangPath = llvm::sys::Program::FindProgramByName("clang");
                 if (!clangPath.isValid()) {
                     llvm::errs() << "error: unable to find clang on the path\n";
+                llvm::ErrorOr<std::string> clangPathOrErr = llvm::sys::findProgramByName("clang");
+                if (std::error_code ec = clangPathOrErr.getError()) {
+                    llvm::errs() << "error: unable to find clang on the path: " << ec.message() << "\n";
                     return 1;
                 }
+                std::string clangPath = clangPathOrErr.get();
 
                 vector<string> arguments;
 #ifdef __APPLE__

From 22cc213a0eaf283d4a43004d5491c1acf4e38bb1 Mon Sep 17 00:00:00 2001
From: Ramon Asuncion <asuncionbatista@gmail.com>
Date: Thu, 11 Dec 2025 01:00:12 -0500
Subject: [PATCH 14/56] Add all missing LLVM related header files from clay.cpp

---
 compiler/clay.cpp | 26 ++++++++++++++++++++------
 1 file changed, 20 insertions(+), 6 deletions(-)

diff --git a/compiler/clay.cpp b/compiler/clay.cpp
index 5cdc7fdc..a088af33 100644
--- a/compiler/clay.cpp
+++ b/compiler/clay.cpp
@@ -1,16 +1,33 @@
 #include <llvm/Support/FileSystem.h>
-#include <llvm/Support/raw_os_ostream.h>
 #include <llvm/Support/Path.h>
 #include <llvm/Support/Process.h>
 #include <llvm/Support/Program.h>
-#include "llvm/Support/DynamicLibrary.h"
 #include <llvm/Support/ErrorOr.h>
 #include <llvm/Support/MemoryBuffer.h>
 #include <llvm/Support/Signals.h>
 #include <llvm/TargetParser/Host.h>
 #include <llvm/TargetParser/Triple.h>
-#include <llvm/Linker/Linker.h>
 #include <llvm/Support/FileUtilities.h>
+#include <llvm/Target/TargetMachine.h>
+#include <llvm/IR/Verifier.h>
+#include <llvm/IR/Module.h>
+#include <llvm/IR/PassManager.h>
+#include <llvm/Passes/PassBuilder.h>
+#include <llvm/Passes/OptimizationLevel.h>
+#include <llvm/Support/FormattedStream.h>
+#include <llvm/Support/raw_ostream.h>
+#include <llvm/Support/Error.h>
+#include <llvm/ExecutionEngine/Orc/LLJIT.h>
+#include <llvm/ExecutionEngine/Orc/ThreadSafeModule.h>
+#include <llvm/Transforms/IPO/Internalize.h>
+#include <llvm/Bitcode/BitcodeWriterPass.h>
+#include <llvm/IR/LegacyPassManager.h>
+#include <llvm/ExecutionEngine/Orc/ExecutionUtils.h>
+#include <llvm/ADT/ArrayRef.h>
+#include <llvm/ExecutionEngine/Orc/Core.h>
+#include <llvm/IR/Function.h>
+#include <llvm/Transforms/InstCombine/InstCombine.h>
+#include <llvm/IRPrinter/IRPrintingPasses.h>
 
 #include <system_error>
 #include <string>
@@ -1130,9 +1147,6 @@ namespace clay {
                 outputTimer.stop();
             } else {
                 bool result;
-                llvm::sys::Path clangPath = llvm::sys::Program::FindProgramByName("clang");
-                if (!clangPath.isValid()) {
-                    llvm::errs() << "error: unable to find clang on the path\n";
                 llvm::ErrorOr<std::string> clangPathOrErr = llvm::sys::findProgramByName("clang");
                 if (std::error_code ec = clangPathOrErr.getError()) {
                     llvm::errs() << "error: unable to find clang on the path: " << ec.message() << "\n";

From cd1ca33d30ae2a69639e84dcf354c9d29d80f054 Mon Sep 17 00:00:00 2001
From: Ramon Asuncion <asuncionbatista@gmail.com>
Date: Thu, 11 Dec 2025 01:00:57 -0500
Subject: [PATCH 15/56] Rename the dsymutilPath to camelCase

---
 compiler/clay.cpp | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/compiler/clay.cpp b/compiler/clay.cpp
index a088af33..fe021009 100644
--- a/compiler/clay.cpp
+++ b/compiler/clay.cpp
@@ -395,11 +395,11 @@ namespace clay {
         int result = llvm::sys::ExecuteAndWait(clangPath, clangArgs);
 
         if (debug && triple.isOSDarwin()) {
-            llvm::ErrorOr<std::string> DsymutilPathOrErr = llvm::sys::findProgramByName("dsymutil");
-            if (std::error_code EC = DsymutilPathOrErr.getError())
-                llvm::errs() << "error creating dsymutil: " << EC.message() << '\n';
+            llvm::ErrorOr<std::string> dsymutilPathOrErr = llvm::sys::findProgramByName("dsymutil");
+            if (std::error_code ec = dsymutilPathOrErr.getError())
+                llvm::errs() << "error creating dsymutil: " << ec.message() << '\n';
 
-            std::string dsymutilPath = DsymutilPathOrErr ? *DsymutilPathOrErr : "";
+            std::string dsymutilPath = dsymutilPathOrErr ? *dsymutilPathOrErr : "";
 
             if (!dsymutilPath.empty()) {
                 string outputDSYMPath = outputFilePathStr;

From cddbd9d35dd2e14ee22b40b76dd45dda1bf15305 Mon Sep 17 00:00:00 2001
From: Ramon Asuncion <asuncionbatista@gmail.com>
Date: Thu, 11 Dec 2025 01:01:35 -0500
Subject: [PATCH 16/56] Use standard error_code to fix F_Binary

---
 compiler/clay.cpp | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/compiler/clay.cpp b/compiler/clay.cpp
index fe021009..a1ad6607 100644
--- a/compiler/clay.cpp
+++ b/compiler/clay.cpp
@@ -1089,17 +1089,17 @@ namespace clay {
             compileTimer.stop();
 
             if (generateDeps) {
-                string errorInfo;
+                std::error_code ec;
 
                 if (verbose) {
                     llvm::errs() << "generating dependencies into " << dependenciesOutputFile << "\n";
                 }
 
                 llvm::raw_fd_ostream dependenciesOut(dependenciesOutputFile.c_str(),
-                                                     errorInfo,
-                                                     llvm::raw_fd_ostream::F_Binary);
-                if (!errorInfo.empty()) {
-                    llvm::errs() << "error: " << errorInfo << '\n';
+                                                     ec,
+                                                     llvm::sys::fs::OF_None);
+                if (ec) {
+                    llvm::errs() << "error creating dependencies file: " << ec.message() << '\n';
                     return 1;
                 }
                 dependenciesOut << outputFile << ": \\\n";

From 23e2eee784e0f54f6fafd17c8b2e184834386fc9 Mon Sep 17 00:00:00 2001
From: Ramon Asuncion <asuncionbatista@gmail.com>
Date: Thu, 11 Dec 2025 01:09:11 -0500
Subject: [PATCH 17/56] Update clay.cpp: modern llvm migration

- moved to orc jit for dynamic execution
- moved to new pass manager (npm) for optimization
- updated ir and assembly generation pass manager objects
---
 compiler/clay.cpp | 306 ++++++++++++++--------------------------------
 1 file changed, 93 insertions(+), 213 deletions(-)

diff --git a/compiler/clay.cpp b/compiler/clay.cpp
index a1ad6607..61197b88 100644
--- a/compiler/clay.cpp
+++ b/compiler/clay.cpp
@@ -30,7 +30,10 @@
 #include <llvm/IRPrinter/IRPrintingPasses.h>
 
 #include <system_error>
+#include <vector>
 #include <string>
+#include <memory>
+#include <utility>
 
 #include "clay.hpp"
 #include "hirestimer.hpp"
@@ -40,6 +43,9 @@
 #include "invoketables.hpp"
 #include "parachute.hpp"
 
+using std::string;
+using std::vector;
+
 // for _exit
 #ifdef _WIN32
 # include <process.h>
@@ -60,254 +66,128 @@ namespace clay {
 #define ENV_SEPARATOR ':'
 #endif
 
-    using namespace std;
-
-    static void addOptimizationPasses(llvm::PassManager &passes,
-                                      llvm::FunctionPassManager &fpasses,
-                                      unsigned optLevel,
-                                      bool internalize) {
-        llvm::Pass *inliningPass = nullptr;
-        if (optLevel > 1) {
-            int threshold = 225;
-            if (optLevel > 2)
-                threshold = 275;
-            inliningPass = llvm::createFunctionInliningPass(threshold);
-        } else {
-            inliningPass = llvm::createAlwaysInlinerPass();
+    static bool runModule(llvm::Module *module,
+                      const std::vector<std::string> &argv,
+                      char const *const*envp,
+                      llvm::ArrayRef<std::string> libSearchPaths,
+                      llvm::ArrayRef<std::string> libs) {
+        auto JIT_expected = llvm::orc::LLJITBuilder().create();
+        if (!JIT_expected) {
+            llvm::errs() << "error creating JIT: " << llvm::toString(JIT_expected.takeError()) << "\n";
+            return false;
         }
+        auto JIT = std::move(JIT_expected.get());
+        llvm::orc::LLJIT &jit = *JIT;
 
-        llvm::PassManagerBuilder builder;
-        builder.OptLevel = optLevel;
-        builder.Inliner = inliningPass;
-
-        builder.populateFunctionPassManager(fpasses);
-
-        // If all optimizations are disabled, just run the always-inline pass.
-        if (optLevel == 0) {
-            if (builder.Inliner) {
-                passes.add(builder.Inliner);
-                builder.Inliner = 0;
-            }
-        } else {
-            passes.add(llvm::createTypeBasedAliasAnalysisPass());
-            passes.add(llvm::createBasicAliasAnalysisPass());
+        llvm::orc::JITDylib& mainDylib = jit.getMainJITDylib();
 
-            passes.add(llvm::createGlobalOptimizerPass()); // Optimize out global vars
+        auto Generator_expected = llvm::orc::DynamicLibrarySearchGenerator::GetForCurrentProcess(
+            jit.getDataLayout().getGlobalPrefix()
+        );
 
-            passes.add(llvm::createIPSCCPPass()); // IP SCCP
-            passes.add(llvm::createDeadArgEliminationPass()); // Dead argument elimination
+        if (!Generator_expected) {
+            llvm::errs() << "error creating generator: " << llvm::toString(Generator_expected.takeError()) << "\n";
+            return false;
+        }
 
-            passes.add(llvm::createInstructionCombiningPass()); // Clean up after IPCP & DAE
-            passes.add(llvm::createCFGSimplificationPass()); // Clean up after IPCP & DAE
+        std::unique_ptr<llvm::orc::DynamicLibrarySearchGenerator> Generator =
+            std::move(*Generator_expected);
 
-            // Start of CallGraph SCC passes.
-            if (builder.Inliner) {
-                passes.add(builder.Inliner);
-                builder.Inliner = 0;
-            }
-            if (optLevel > 2)
-                passes.add(llvm::createArgumentPromotionPass()); // Scalarize uninlined fn args
-
-            // Start of function pass.
-            // Break up aggregate allocas, using SSAUpdater.
-            passes.add(llvm::createScalarReplAggregatesPass(-1, false));
-            passes.add(llvm::createEarlyCSEPass()); // Catch trivial redundancies
-
-            passes.add(llvm::createJumpThreadingPass()); // Thread jumps.
-            // Disable Value Propagation pass until fixed LLVM bug #12503
-            // passes.add(llvm::createCorrelatedValuePropagationPass()); // Propagate conditionals
-            passes.add(llvm::createCFGSimplificationPass()); // Merge & remove BBs
-            passes.add(llvm::createInstructionCombiningPass()); // Combine silly seq's
-
-            passes.add(llvm::createTailCallEliminationPass()); // Eliminate tail calls
-            passes.add(llvm::createCFGSimplificationPass()); // Merge & remove BBs
-            passes.add(llvm::createReassociatePass()); // Reassociate expressions
-            passes.add(llvm::createLoopRotatePass()); // Rotate Loop
-            passes.add(llvm::createLICMPass()); // Hoist loop invariants
-            passes.add(llvm::createLoopUnswitchPass(builder.SizeLevel || optLevel < 3));
-            passes.add(llvm::createInstructionCombiningPass());
-            passes.add(llvm::createIndVarSimplifyPass()); // Canonicalize indvars
-            passes.add(llvm::createLoopIdiomPass()); // Recognize idioms like memset.
-            passes.add(llvm::createLoopDeletionPass()); // Delete dead loops
-
-            if (optLevel > 1)
-                passes.add(llvm::createGVNPass()); // Remove redundancies
-            passes.add(llvm::createMemCpyOptPass()); // Remove memcpy / form memset
-            passes.add(llvm::createSCCPPass()); // Constant prop with SCCP
-
-            // Run instcombine after redundancy elimination to exploit opportunities
-            // opened up by them.
-            passes.add(llvm::createInstructionCombiningPass());
-            passes.add(llvm::createJumpThreadingPass()); // Thread jumps
-            // Disable Value Propagation pass until fixed LLVM bug #12503
-            // passes.add(llvm::createCorrelatedValuePropagationPass());
-            passes.add(llvm::createDeadStoreEliminationPass()); // Delete dead stores
-
-            if (builder.Vectorize) {
-                passes.add(llvm::createBBVectorizePass());
-                passes.add(llvm::createInstructionCombiningPass());
-                if (optLevel > 1)
-                    passes.add(llvm::createGVNPass()); // Remove redundancies
-            }
+        mainDylib.addGenerator(std::move(Generator));
 
-            passes.add(llvm::createAggressiveDCEPass()); // Delete dead instructions
-            passes.add(llvm::createCFGSimplificationPass()); // Merge & remove BBs
-            passes.add(llvm::createInstructionCombiningPass()); // Clean up after everything.
+        module->setDataLayout(jit.getDataLayout());
 
-            // GlobalOpt already deletes dead functions and globals, at -O3 try a
-            // late pass of GlobalDCE.  It is capable of deleting dead cycles.
-            if (optLevel > 2)
-                passes.add(llvm::createGlobalDCEPass()); // Remove dead fns and globals.
+        auto TSM = llvm::orc::ThreadSafeModule(std::unique_ptr<llvm::Module>(module),
+                                               std::make_unique<llvm::LLVMContext>());
 
-            if (optLevel > 1)
-                passes.add(llvm::createConstantMergePass()); // Merge dup global constants
+        if (llvm::Error AddIRErr = jit.addIRModule(std::move(TSM))) {
+            llvm::errs() << "error adding module to JIT: " << llvm::toString(std::move(AddIRErr)) << "\n";
+            return false;
         }
 
-        if (optLevel > 2) {
-            if (internalize) {
-                vector<const char *> do_not_internalize;
-                do_not_internalize.push_back("main");
-                passes.add(llvm::createInternalizePass(do_not_internalize));
-            }
-            builder.populateLTOPassManager(passes, false, true);
+        auto mainAddr_expected = jit.lookup("main");
+        if (!mainAddr_expected) {
+            llvm::errs() << "error resolving main: " << llvm::toString(mainAddr_expected.takeError()) << "\n";
+            return false;
         }
-    }
 
-    static bool linkLibraries(llvm::Module *module, llvm::ArrayRef<string> libSearchPaths,
-                              llvm::ArrayRef<string> libs) {
-        if (libs.empty())
-            return true;
-
-        llvm::Linker linker("clay", llvmModule, llvm::Linker::Verbose);
-        linker.addSystemPaths();
-        linker.addPaths(libSearchPaths);
-        for (auto lib : libs) {
-            llvmModule->addLibrary(lib);
-            //as in cling/lib/Interpreter/Interpreter.cpp
-            bool isNative = true;
-            if (linker.LinkInLibrary(lib, isNative)) {
-                // that didn't work, try bitcode:
-                llvm::sys::Path FilePath(lib);
-                std::string Magic;
-                if (!FilePath.getMagicNumber(Magic, 64)) {
-                    // filename doesn't exist...
-                    linker.releaseModule();
-                    return false;
-                }
-                if (llvm::sys::IdentifyFileType(Magic.c_str(), 64)
-                    == llvm::sys::Bitcode_FileType) {
-                    // We are promised a bitcode file, complain if it fails
-                    linker.setFlags(0);
-                    if (linker.LinkInFile(llvm::sys::Path(lib), isNative)) {
-                        linker.releaseModule();
-                        return false;
-                    }
-                } else {
-                    // Nothing the linker can handle
-                    linker.releaseModule();
-                    return false;
-                }
-            } else if (isNative) {
-                // native shared library, load it!
-                llvm::sys::Path SoFile = linker.FindLib(lib);
-                if (SoFile.isEmpty()) {
-                    llvm::errs() << "Couldn't find shared library " << lib << "\n";
-                    linker.releaseModule();
-                    return false;
-                }
-                std::string errMsg;
-                bool hasError = llvm::sys::DynamicLibrary
-                        ::LoadLibraryPermanently(SoFile.str().c_str(), &errMsg);
-                if (hasError) {
-                    llvm::errs() << "Couldn't load shared library " << lib << "\n" << errMsg.c_str();
-                    linker.releaseModule();
-                    return false;
-                }
-            }
-        }
-        linker.releaseModule();
-        return true;
-    }
+        using MainPtr = int (*)(int, char *[], char *[]);
 
-    static bool runModule(llvm::Module *module,
-                          vector<string> &argv,
-                          char const *const*envp,
-                          llvm::ArrayRef<string> libSearchPaths,
-                          llvm::ArrayRef<string> libs) {
-        if (!linkLibraries(module, libSearchPaths, libs)) {
-            return false;
-        }
-        llvm::EngineBuilder eb(llvmModule);
-        llvm::ExecutionEngine *engine = eb.create();
-        llvm::Function *mainFunc = module->getFunction("main");
-        if (!mainFunc) {
-            llvm::errs() << "no main function to -run\n";
-            delete engine;
-            return false;
+        llvm::orc::ExecutorAddr mainAddr = mainAddr_expected.get();
+        MainPtr mainFunc = reinterpret_cast<MainPtr>(mainAddr.getValue());
+
+        std::vector<const char*> c_argv;
+        for (const auto& arg : argv) {
+            c_argv.push_back(arg.c_str());
         }
-        engine->runStaticConstructorsDestructors(false);
-        engine->runFunctionAsMain(mainFunc, argv, envp);
-        engine->runStaticConstructorsDestructors(true);
+        c_argv.push_back(nullptr);
+
+        mainFunc(c_argv.size() - 1, const_cast<char **>(c_argv.data()), const_cast<char **>(envp));
 
-        delete engine;
         return true;
     }
 
     static void optimizeLLVM(llvm::Module *module, unsigned optLevel, bool internalize) {
-        llvm::PassManager passes;
-
-        string moduleDataLayout = module->getDataLayout();
-        auto *dl = new llvm::DataLayout(moduleDataLayout);
-        passes.add(dl);
-
-        llvm::FunctionPassManager fpasses(module);
-
-        fpasses.add(new llvm::DataLayout(*dl));
-
-        addOptimizationPasses(passes, fpasses, optLevel, internalize);
-
-        fpasses.doInitialization();
-        for (auto & i : *module) {
-            fpasses.run(i);
+        llvm::LoopAnalysisManager LAM;
+        llvm::FunctionAnalysisManager FAM;
+        llvm::CGSCCAnalysisManager CGAM;
+        llvm::ModuleAnalysisManager MAM;
+        llvm::PassBuilder PB;
+
+        PB.registerModuleAnalyses(MAM);
+        PB.registerCGSCCAnalyses(CGAM);
+        PB.registerFunctionAnalyses(FAM);
+        PB.registerLoopAnalyses(LAM);
+        PB.crossRegisterProxies(LAM, FAM, CGAM, MAM);
+
+        llvm::OptimizationLevel O = llvm::OptimizationLevel::O0;
+        if (optLevel == 1) O = llvm::OptimizationLevel::O1;
+        else if (optLevel == 2) O = llvm::OptimizationLevel::O2;
+        else if (optLevel >= 3) O = llvm::OptimizationLevel::O3;
+
+        llvm::ModulePassManager MPM = PB.buildPerModuleDefaultPipeline(O);
+
+        if (optLevel > 2 && internalize) {
+            MPM.addPass(llvm::InternalizePass([=](const llvm::GlobalValue &GV) {
+                return GV.getName() == "main";
+            }));
         }
 
-        passes.add(llvm::createVerifierPass());
-        passes.run(*module);
+        MPM.addPass(llvm::VerifierPass());
+
+        MPM.run(*module, MAM);
     }
 
     static void generateLLVM(llvm::Module *module, bool emitAsm, llvm::raw_ostream *out) {
-        llvm::PassManager passes;
+        llvm::ModuleAnalysisManager MAM;
+        llvm::ModulePassManager passes;
+
         if (emitAsm)
-            passes.add(llvm::createPrintModulePass(out));
+            passes.addPass(llvm::PrintModulePass(*out));
         else
-            passes.add(llvm::createBitcodeWriterPass(*out));
-        passes.run(*module);
+            passes.addPass(llvm::BitcodeWriterPass(*out));
+
+        passes.run(*module, MAM);
     }
 
     static void generateAssembly(llvm::Module *module,
                                  llvm::TargetMachine *targetMachine,
-                                 llvm::raw_ostream *out,
+                                 llvm::raw_pwrite_stream *out,
                                  bool emitObject) {
-        llvm::FunctionPassManager fpasses(module);
-
-        fpasses.add(new llvm::DataLayout(module));
-        fpasses.add(llvm::createVerifierPass());
-
-        targetMachine->setAsmVerbosityDefault(true);
+        llvm::legacy::PassManager passes;
 
-        llvm::formatted_raw_ostream fout(*out);
-        llvm::TargetMachine::CodeGenFileType fileType = emitObject
-                                                            ? llvm::TargetMachine::CGFT_ObjectFile
-                                                            : llvm::TargetMachine::CGFT_AssemblyFile;
+        passes.add(llvm::createVerifierPass());
 
-        bool result = targetMachine->addPassesToEmitFile(fpasses, fout, fileType);
-        assert(!result);
+        llvm::CodeGenFileType fileType = emitObject
+                                            ? llvm::CodeGenFileType::ObjectFile
+                                            : llvm::CodeGenFileType::AssemblyFile;
 
-        fpasses.doInitialization();
-        for (auto & i : *module) {
-            fpasses.run(i);
+        if (targetMachine->addPassesToEmitFile(passes, *out, nullptr, fileType)) {
+            llvm::errs() << "error: adding codegen passes failed\n";
+            return;
         }
-        fpasses.doFinalization();
+
+        passes.run(*module);
     }
 
     [[maybe_unused]] static std::string joinCmdArgs(llvm::ArrayRef<llvm::StringRef> args)
@@ -1127,7 +1007,7 @@ namespace clay {
                 runArgs.push_back(clayFile);
                 runModule(llvmModule, runArgs, envp, libSearchPath, libraries);
             } else if (repl) {
-                linkLibraries(llvmModule, libSearchPath, libraries);
+                // TODO: future me task
                 runInteractive(llvmModule, m);
             } else if (emitLLVM || emitAsm || emitObject) {
                 std::error_code ec;

From aa6c3665b5b2865ab5bb97b9031fd5dfe3cad78b Mon Sep 17 00:00:00 2001
From: Ramon Asuncion <asuncionbatista@gmail.com>
Date: Thu, 11 Dec 2025 05:55:12 -0500
Subject: [PATCH 18/56] Remove quotes and export compile commands

---
 CMakeLists.txt | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 1422db4b..eb6cecba 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -5,6 +5,7 @@ set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(CMAKE_CXX_EXTENSIONS OFF)
 
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 set(CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake")
 
 find_package(Git)
@@ -44,11 +45,11 @@ if(UNIX)
         OUTPUT_VARIABLE LLVM_CXXFLAGS
         OUTPUT_STRIP_TRAILING_WHITESPACE
     )
-    set(LLVM_CXXFLAGS "${LLVM_CXXFLAGS}")
+    set(LLVM_CXXFLAGS ${LLVM_CXXFLAGS})
     separate_arguments(LLVM_CXXFLAGS)
 
     if(CMAKE_BUILD_TYPE STREQUAL "Debug")
-        set(LLVM_CXXFLAGS "${LLVM_CXXFLAGS} -O0")
+        list(APPEND LLVM_CXXFLAGS -O0)
     endif()
 
     execute_process(
@@ -82,7 +83,7 @@ if(UNIX)
         OUTPUT_VARIABLE LLVM_INCLUDEDIR
         OUTPUT_STRIP_TRAILING_WHITESPACE
     )
-    set(LLVM_INCLUDEDIR "${LLVM_INCLUDEDIR}")
+    set(LLVM_INCLUDEDIR ${LLVM_INCLUDEDIR})
 
     message("-- Using LLVM: ${LLVM_DIR}")
     message("-- LLVM include dir: ${LLVM_INCLUDEDIR}")

From be072f4be7bd4f5bed85524970d0c3236781c073 Mon Sep 17 00:00:00 2001
From: Ramon Asuncion <asuncionbatista@gmail.com>
Date: Thu, 11 Dec 2025 05:56:13 -0500
Subject: [PATCH 19/56] Pass through with clang-tidy on clay.cpp

---
 compiler/clay.cpp | 18 ++++++++----------
 1 file changed, 8 insertions(+), 10 deletions(-)

diff --git a/compiler/clay.cpp b/compiler/clay.cpp
index 61197b88..8761286f 100644
--- a/compiler/clay.cpp
+++ b/compiler/clay.cpp
@@ -1,9 +1,7 @@
 #include <llvm/Support/FileSystem.h>
 #include <llvm/Support/Path.h>
-#include <llvm/Support/Process.h>
 #include <llvm/Support/Program.h>
 #include <llvm/Support/ErrorOr.h>
-#include <llvm/Support/MemoryBuffer.h>
 #include <llvm/Support/Signals.h>
 #include <llvm/TargetParser/Host.h>
 #include <llvm/TargetParser/Triple.h>
@@ -114,7 +112,7 @@ namespace clay {
         using MainPtr = int (*)(int, char *[], char *[]);
 
         llvm::orc::ExecutorAddr mainAddr = mainAddr_expected.get();
-        MainPtr mainFunc = reinterpret_cast<MainPtr>(mainAddr.getValue());
+        auto mainFunc = reinterpret_cast<MainPtr>(mainAddr.getValue());
 
         std::vector<const char*> c_argv;
         for (const auto& arg : argv) {
@@ -122,7 +120,7 @@ namespace clay {
         }
         c_argv.push_back(nullptr);
 
-        mainFunc(c_argv.size() - 1, const_cast<char **>(c_argv.data()), const_cast<char **>(envp));
+        mainFunc(static_cast<int>(c_argv.size() - 1), const_cast<char **>(c_argv.data()), const_cast<char **>(envp));
 
         return true;
     }
@@ -242,7 +240,7 @@ namespace clay {
                 assert(false);
         }
 
-        llvm::Triple triple(llvmModule->getTargetTriple());
+        const llvm::Triple& triple(llvmModule->getTargetTriple());
         if (sharedLib) {
             clangArgs.emplace_back("-shared");
 
@@ -583,7 +581,7 @@ namespace clay {
                     llvm::errs() << "error: framework name missing after -framework\n";
                     return 1;
                 }
-                frameworks.push_back("-framework");
+                frameworks.emplace_back("-framework");
                 frameworks.push_back(framework);
             } else if (strcmp(argv[i], "-arch") == 0) {
                 if (i + 1 == argc) {
@@ -975,7 +973,7 @@ namespace clay {
                     llvm::errs() << "generating dependencies into " << dependenciesOutputFile << "\n";
                 }
 
-                llvm::raw_fd_ostream dependenciesOut(dependenciesOutputFile.c_str(),
+                llvm::raw_fd_ostream dependenciesOut(dependenciesOutputFile,
                                                      ec,
                                                      llvm::sys::fs::OF_None);
                 if (ec) {
@@ -1012,7 +1010,7 @@ namespace clay {
             } else if (emitLLVM || emitAsm || emitObject) {
                 std::error_code ec;
 
-                llvm::raw_fd_ostream out(outputFile.c_str(),
+                llvm::raw_fd_ostream out(outputFile,
                                          ec,
                                          llvm::sys::fs::OF_None);
                 if (ec) {
@@ -1032,12 +1030,12 @@ namespace clay {
                     llvm::errs() << "error: unable to find clang on the path: " << ec.message() << "\n";
                     return 1;
                 }
-                std::string clangPath = clangPathOrErr.get();
+                const std::string& clangPath = clangPathOrErr.get();
 
                 vector<string> arguments;
 #ifdef __APPLE__
                 if (!arch.empty()) {
-                    arguments.push_back("-arch");
+                    arguments.emplace_back("-arch");
                     arguments.push_back(arch);
                 }
 #endif

From 7ea75094608202a4238b29a95a15bf207f87c387 Mon Sep 17 00:00:00 2001
From: Ramon Asuncion <asuncionbatista@gmail.com>
Date: Thu, 11 Dec 2025 05:56:29 -0500
Subject: [PATCH 20/56] Remove CLAY_CXXFLAGS

---
 compiler/CMakeLists.txt | 63 +++++++++++++++++++++++++----------------
 1 file changed, 39 insertions(+), 24 deletions(-)

diff --git a/compiler/CMakeLists.txt b/compiler/CMakeLists.txt
index 2868281a..2b750204 100644
--- a/compiler/CMakeLists.txt
+++ b/compiler/CMakeLists.txt
@@ -54,41 +54,56 @@ if(GIT_FOUND AND EXISTS "${PROJECT_SOURCE_DIR}/.git")
         COMPILE_DEFINITIONS "GIT_ID=\"${GIT_WC_ID}\"")
 endif()
 
-# Compiler flags
+# Targets
+add_library(compiler STATIC ${COMPILER_SOURCES})
+add_executable(clay ${CLAY_SOURCES})
+add_executable(claydoc ${CLAYDOC_SOURCES})
+add_executable(ut ${UT_SOURCES})
+
+# compiler flags
+target_compile_options(compiler PRIVATE ${LLVM_CXXFLAGS})
+target_compile_options(clay     PRIVATE ${LLVM_CXXFLAGS})
+target_compile_options(claydoc  PRIVATE ${LLVM_CXXFLAGS})
+target_compile_options(ut       PRIVATE ${LLVM_CXXFLAGS})
+
+# include directories
+target_include_directories(compiler PRIVATE ${LLVM_INCLUDEDIR})
+target_include_directories(clay     PRIVATE ${LLVM_INCLUDEDIR})
+target_include_directories(claydoc  PRIVATE ${LLVM_INCLUDEDIR})
+target_include_directories(ut       PRIVATE ${LLVM_INCLUDEDIR})
+
 if(CMAKE_BUILD_TYPE STREQUAL "Debug" OR CMAKE_BUILD_TYPE STREQUAL "RelWithDebInfo")
-    set(CLAY_CXXFLAGS "${LLVM_CXXFLAGS} -UNDEBUG")
+    target_compile_definitions(compiler PRIVATE UNDEBUG)
+    target_compile_definitions(clay     PRIVATE UNDEBUG)
+    target_compile_definitions(claydoc  PRIVATE UNDEBUG)
+    target_compile_definitions(ut       PRIVATE UNDEBUG)
 else()
-    set(CLAY_CXXFLAGS "${LLVM_CXXFLAGS} -DNDEBUG")
+    target_compile_definitions(compiler PRIVATE NDEBUG)
+    target_compile_definitions(clay     PRIVATE NDEBUG)
+    target_compile_definitions(claydoc  PRIVATE NDEBUG)
+    target_compile_definitions(ut       PRIVATE NDEBUG)
 endif()
-if (NOT MSVC)
-    set(CLAY_CXXFLAGS "${CLAY_CXXFLAGS} -fexceptions")
+
+if(NOT MSVC)
+    target_compile_options(compiler PRIVATE -fexceptions)
+    target_compile_options(clay     PRIVATE -fexceptions)
+    target_compile_options(claydoc  PRIVATE -fexceptions)
+    target_compile_options(ut       PRIVATE -fexceptions)
 endif()
 
 set(ENABLE_PCH False CACHE BOOL
-    "Use precompiled headers when building the compiler. (experimental)")
+        "Use precompiled headers when building the compiler. (experimental)")
 
 if(ENABLE_PCH)
-    precompile_header(clay.hpp SOURCES pch.cpp "${CLAY_CXXFLAGS}")
+    precompile_header(clay.hpp SOURCES pch.cpp ${LLVM_CXXFLAGS})
 endif(ENABLE_PCH)
 
-# Targets
-add_library(compiler STATIC ${COMPILER_SOURCES})
-add_executable(clay ${CLAY_SOURCES})
-add_executable(claydoc ${CLAYDOC_SOURCES})
-add_executable(ut ${UT_SOURCES})
-
-# compiler flags
-target_compile_options(compiler PRIVATE "${CLAY_CXXFLAGS}")
-target_compile_options(clay     PRIVATE "${CLAY_CXXFLAGS}")
-target_compile_options(claydoc  PRIVATE "${CLAY_CXXFLAGS}")
-target_compile_options(ut       PRIVATE "${CLAY_CXXFLAGS}")
-
 if (UNIX)
-    target_link_options(compiler PRIVATE "${LLVM_LDFLAGS}")
-    target_link_options(clay     PRIVATE "${LLVM_LDFLAGS}")
-    target_link_options(claydoc  PRIVATE "${LLVM_LDFLAGS}")
-    target_link_options(ut       PRIVATE "${LLVM_LDFLAGS}")
-endif(UNIX)
+    target_link_options(compiler PRIVATE ${LLVM_LDFLAGS})
+    target_link_options(clay     PRIVATE ${LLVM_LDFLAGS})
+    target_link_options(claydoc  PRIVATE ${LLVM_LDFLAGS})
+    target_link_options(ut       PRIVATE ${LLVM_LDFLAGS})
+endif()
 
 # Libraries
 target_link_libraries(clay     PRIVATE compiler ${LLVM_LIBS})

From a2e97abb275c589703b20c01930be4969f697ec2 Mon Sep 17 00:00:00 2001
From: Ramon Asuncion <asuncionbatista@gmail.com>
Date: Thu, 11 Dec 2025 09:30:32 -0500
Subject: [PATCH 21/56] Fix the issues with error.cpp (getDebugLineCol still
 needs work)

---
 compiler/clay.hpp  |  14 +++---
 compiler/error.cpp | 118 +++++++++++++++++++++++----------------------
 compiler/error.hpp |  44 ++++++++---------
 3 files changed, 90 insertions(+), 86 deletions(-)

diff --git a/compiler/clay.hpp b/compiler/clay.hpp
index 778ed0eb..83433e3c 100644
--- a/compiler/clay.hpp
+++ b/compiler/clay.hpp
@@ -549,14 +549,16 @@ namespace clay {
         Source(llvm::StringRef lineOfCode, int dummy);
 
         Source(llvm::StringRef fileName, llvm::MemoryBuffer *buffer)
-            : Object(SOURCE), fileName(fileName), buffer(buffer), debugInfo(nullptr) {
+                : Object(SOURCE), fileName(fileName), buffer(buffer) {
         }
 
-        const char *data() const { return buffer->getBufferStart(); }
-        const char *endData() const { return buffer->getBufferEnd(); }
-        size_t size() const { return buffer->getBufferSize(); }
+        [[nodiscard]] const char *data() const { return buffer->getBufferStart(); }
+        [[nodiscard]] const char *endData() const { return buffer->getBufferEnd(); }
+        [[nodiscard]] size_t size() const { return buffer->getBufferSize(); }
 
-        llvm::DIFile getDebugInfo() const { return llvm::DIFile(debugInfo); }
+        [[nodiscard]] llvm::DIFile *getDebugInfo() const {
+            // TODO: implement this...
+        }
     };
 
     struct Location {
@@ -670,7 +672,7 @@ namespace clay {
                     unsigned &column,
                     unsigned &tabColumn);
 
-    llvm::DIFile getDebugLineCol(Location const &location, unsigned &line, unsigned &column);
+    llvm::DIFile *getDebugLineCol(Location const &location, unsigned &line, unsigned &column);
 
     void printFileLineCol(llvm::raw_ostream &out, Location const &location);
 
diff --git a/compiler/error.cpp b/compiler/error.cpp
index ddb0ae0f..d0f8cc2d 100644
--- a/compiler/error.cpp
+++ b/compiler/error.cpp
@@ -4,6 +4,7 @@
 #include "matchinvoke.hpp"
 #include "invoketables.hpp"
 #include "error.hpp"
+#include "printer.hpp"
 
 namespace clay {
     bool shouldPrintFullMatchErrors;
@@ -17,28 +18,28 @@ namespace clay {
 
     static constexpr unsigned RECURSION_WARNING_LEVEL = 1000;
 
-    void pushCompileContext(ObjectPtr obj) {
+    void pushCompileContext(const ObjectPtr &obj) {
         if (contextStack.size() >= RECURSION_WARNING_LEVEL)
             warning("potential runaway recursion");
         if (!contextStack.empty())
             contextStack.back().location = topLocation();
-        contextStack.push_back(CompileContextEntry(obj));
+        contextStack.emplace_back(obj);
     }
 
-    void pushCompileContext(ObjectPtr obj, llvm::ArrayRef<ObjectPtr> params) {
+    void pushCompileContext(const ObjectPtr &obj, const llvm::ArrayRef<ObjectPtr> params) {
         if (contextStack.size() >= RECURSION_WARNING_LEVEL)
             warning("potential runaway recursion");
         if (!contextStack.empty())
             contextStack.back().location = topLocation();
-        contextStack.push_back(CompileContextEntry(obj, params));
+        contextStack.emplace_back(obj, params);
     }
 
-    void pushCompileContext(ObjectPtr obj, llvm::ArrayRef<ObjectPtr> params, llvm::ArrayRef<unsigned> dispatchIndices) {
+    void pushCompileContext(const ObjectPtr &obj, llvm::ArrayRef<ObjectPtr> params, llvm::ArrayRef<unsigned> dispatchIndices) {
         if (contextStack.size() >= RECURSION_WARNING_LEVEL)
             warning("potential runaway recursion");
         if (!contextStack.empty())
             contextStack.back().location = topLocation();
-        contextStack.push_back(CompileContextEntry(obj, params, dispatchIndices));
+        contextStack.emplace_back(obj, params, dispatchIndices);
     }
 
     void popCompileContext() {
@@ -53,11 +54,11 @@ namespace clay {
         contextStack = x;
     }
 
-    CompileContextPusher::CompileContextPusher(ObjectPtr obj, llvm::ArrayRef<PVData> params,
+    CompileContextPusher::CompileContextPusher(const ObjectPtr &obj, llvm::ArrayRef<PVData> params,
                                                llvm::ArrayRef<unsigned> dispatchIndices) {
         vector<ObjectPtr> params2;
-        for (unsigned i = 0; i < params.size(); ++i) {
-            params2.push_back(params[i].type.ptr());
+        for (const auto & param : params) {
+            params2.emplace_back(param.type.ptr());
         }
         pushCompileContext(obj, params2, dispatchIndices);
     }
@@ -77,14 +78,13 @@ namespace clay {
     }
 
     Location topLocation() {
-        vector<Location>::iterator i, begin;
-        i = errorLocations.end();
-        begin = errorLocations.begin();
+        auto i = errorLocations.end();
+        auto begin = errorLocations.begin();
         while (i != begin) {
             --i;
             if (i->ok()) return *i;
         }
-        return Location();
+        return {};
     }
 
     //
@@ -95,7 +95,7 @@ namespace clay {
 
     int DebugPrinter::indent = 0;
 
-    DebugPrinter::DebugPrinter(ObjectPtr obj)
+    DebugPrinter::DebugPrinter(const ObjectPtr &obj)
         : obj(obj) {
         for (int i = 0; i < indent; ++i)
             llvm::outs() << ' ';
@@ -133,11 +133,11 @@ namespace clay {
         }
     }
 
-    llvm::DIFile getDebugLineCol(Location const &location, unsigned &line, unsigned &column) {
+    llvm::DIFile *getDebugLineCol(Location const &location, unsigned &line, unsigned &column) {
         if (!location.ok()) {
             line = 0;
             column = 0;
-            return llvm::DIFile();
+            return nullptr;
         }
 
         unsigned tabColumn;
@@ -158,14 +158,18 @@ namespace clay {
         computeLineCol(location, line, column, tabColumn);
     }
 
-    static void splitLines(SourcePtr source, vector<string> &lines) {
-        lines.push_back(string());
-        const char *p = source->data();
-        const char *end = source->endData();
-        for (; p != end; ++p) {
-            lines.back().push_back(*p);
-            if (*p == '\n')
-                lines.push_back(string());
+    static void splitLines(const SourcePtr &source, vector<string> &lines) {
+        lines.clear();
+        if (!source || source->data() == source->endData()) {
+            return;
+        }
+        const std::string_view sourceView(source->data(), source->endData() - source->data());
+        lines.emplace_back();
+
+        for (const char c : sourceView) {
+            lines.back().push_back(c);
+            if (c == '\n')
+                lines.emplace_back();
         }
     }
 
@@ -242,7 +246,7 @@ namespace clay {
             return;
         llvm::errs() << "\ndebug stack:\n";
         for (size_t i = debugStack.size(); i > 0; --i) {
-            llvm::errs() << "  " << debugStack[i - 1] << "\n";
+            llvm::errs() << "  " << debugStack[i - 1]->toString() << "\n";
         }
     }
 
@@ -321,22 +325,22 @@ namespace clay {
         error(sout.str());
     }
 
-    void ensureArity(MultiStaticPtr args, size_t size) {
+    void ensureArity(const MultiStaticPtr &args, size_t size) {
         if (args->size() != size)
             arityError(size, args->size());
     }
 
-    void ensureArity(MultiEValuePtr args, size_t size) {
+    void ensureArity(const MultiEValuePtr &args, size_t size) {
         if (args->size() != size)
             arityError(size, args->size());
     }
 
-    void ensureArity(MultiPValuePtr args, size_t size) {
+    void ensureArity(const MultiPValuePtr &args, size_t size) {
         if (args->size() != size)
             arityError(size, args->size());
     }
 
-    void ensureArity(MultiCValuePtr args, size_t size) {
+    void ensureArity(const MultiCValuePtr &args, size_t size) {
         if (args->size() != size)
             arityError(size, args->size());
     }
@@ -354,45 +358,45 @@ namespace clay {
     }
 
     static string typeErrorMessage(llvm::StringRef expected,
-                                   TypePtr receivedType) {
+                                   const TypePtr &receivedType) {
         string buf;
         llvm::raw_string_ostream sout(buf);
         sout << "expected " << expected << ", "
-                << "but received " << receivedType << " type";
+                << "but received " << receivedType->toString() << " type";
         return sout.str();
     }
 
-    static string typeErrorMessage(TypePtr expectedType,
-                                   TypePtr receivedType) {
+    static string typeErrorMessage(const TypePtr &expectedType,
+                                   const TypePtr &receivedType) {
         string buf;
         llvm::raw_string_ostream sout(buf);
-        sout << expectedType << " type";
+        sout << expectedType->toString() << " type";
         return typeErrorMessage(sout.str(), receivedType);
     }
 
-    void typeError(llvm::StringRef expected, TypePtr receivedType) {
+    void typeError(const llvm::StringRef expected, const TypePtr &receivedType) {
         error(typeErrorMessage(expected, receivedType));
     }
 
-    void typeError(TypePtr expectedType, TypePtr receivedType) {
+    void typeError(const TypePtr &expectedType, const TypePtr &receivedType) {
         error(typeErrorMessage(expectedType, receivedType));
     }
 
-    void argumentTypeError(unsigned index,
-                           llvm::StringRef expected,
-                           TypePtr receivedType) {
+    void argumentTypeError(const unsigned index,
+                           const llvm::StringRef expected,
+                           const TypePtr &receivedType) {
         argumentError(index, typeErrorMessage(expected, receivedType));
     }
 
-    void argumentTypeError(unsigned index,
-                           TypePtr expectedType,
-                           TypePtr receivedType) {
+    void argumentTypeError(const unsigned index,
+                           const TypePtr &expectedType,
+                           const TypePtr &receivedType) {
         argumentError(index, typeErrorMessage(expectedType, receivedType));
     }
 
-    void indexRangeError(llvm::StringRef kind,
-                         size_t value,
-                         size_t maxValue) {
+    void indexRangeError(const llvm::StringRef kind,
+                         const size_t value,
+                         const size_t maxValue) {
         string buf;
         llvm::raw_string_ostream sout(buf);
         sout << kind << " " << value << " is out of range. ";
@@ -400,10 +404,10 @@ namespace clay {
         error(sout.str());
     }
 
-    void argumentIndexRangeError(unsigned index,
-                                 llvm::StringRef kind,
-                                 size_t value,
-                                 size_t maxValue) {
+    void argumentIndexRangeError(const unsigned index,
+                                 const llvm::StringRef kind,
+                                 const size_t value,
+                                 const size_t maxValue) {
         string buf;
         llvm::raw_string_ostream sout(buf);
         sout << kind << " " << value << " is out of range. ";
@@ -411,17 +415,17 @@ namespace clay {
         argumentError(index, sout.str());
     }
 
-    void invalidStaticObjectError(ObjectPtr obj) {
+    void invalidStaticObjectError(const ObjectPtr &obj) {
         string buf;
         llvm::raw_string_ostream sout(buf);
-        sout << "invalid static object: " << obj;
+        sout << "invalid static object: " << obj->toString();
         error(sout.str());
     }
 
-    void argumentInvalidStaticObjectError(unsigned index, ObjectPtr obj) {
+    void argumentInvalidStaticObjectError(const unsigned index, const ObjectPtr &obj) {
         string buf;
         llvm::raw_string_ostream sout(buf);
-        sout << "invalid static object: " << obj;
+        sout << "invalid static object: " << obj->toString();
         argumentError(index, sout.str());
     }
 
@@ -436,10 +440,8 @@ namespace clay {
         llvm::raw_string_ostream sout(outBuf);
         int hiddenPatternOverloads = 0;
 
-        for (MatchFailureVector::const_iterator i = err.failures.begin();
-             i != err.failures.end();
-             ++i) {
-            OverloadPtr overload = i->first;
+        for (const auto & failure : err.failures) {
+            OverloadPtr overload = failure.first;
             if (!shouldPrintFullMatchErrors && overload->nameIsPattern) {
                 ++hiddenPatternOverloads;
                 continue;
@@ -451,7 +453,7 @@ namespace clay {
             sout << location.source->fileName.c_str()
                     << "(" << line + 1 << "," << column << ")"
                     << "\n        ";
-            printMatchError(sout, i->second);
+            printMatchError(sout, failure.second);
         }
         if (hiddenPatternOverloads > 0)
             sout << "\n    " << hiddenPatternOverloads <<
diff --git a/compiler/error.hpp b/compiler/error.hpp
index ef3d882e..247d53dd 100644
--- a/compiler/error.hpp
+++ b/compiler/error.hpp
@@ -1,8 +1,8 @@
 #pragma once
 
 #include "clay.hpp"
-#include "invoketables.hpp"
-#include "printer.hpp"
+// #include "invoketables.hpp"
+// #include "printer.hpp"
 
 #if defined(__GNUC__) || defined(__clang__)
 #define CLAY_NORETURN __attribute__((noreturn))
@@ -21,20 +21,20 @@ namespace clay {
     void fmtError(const char *fmt, ...) CLAY_NORETURN;
 
     template<class T>
-    inline void error(Pointer<T> context, llvm::Twine const &msg) CLAY_NORETURN;
+    void error(Pointer<T> context, llvm::Twine const &msg) CLAY_NORETURN;
 
     template<class T>
-    inline void error(Pointer<T> context, llvm::Twine const &msg) {
+    void error(Pointer<T> context, llvm::Twine const &msg) {
         if (context->location.ok())
             pushLocation(context->location);
         error(msg);
     }
 
     template<class T>
-    inline void error(T const *context, llvm::Twine const &msg) CLAY_NORETURN;
+    void error(T const *context, llvm::Twine const &msg) CLAY_NORETURN;
 
     template<class T>
-    inline void error(T const *context, llvm::Twine const &msg) {
+    void error(T const *context, llvm::Twine const &msg) {
         error(context->location, msg);
     }
 
@@ -44,7 +44,7 @@ namespace clay {
     void argumentError(size_t index, llvm::StringRef msg, const T &argument) CLAY_NORETURN;
 
     template<typename T>
-    void argumentError(size_t index, llvm::StringRef msg, const T &argument) {
+    void argumentError(const size_t index, const llvm::StringRef msg, const T &argument) {
         string buf;
         llvm::raw_string_ostream sout(buf);
         sout << "argument " << (index + 1) << ": " << msg << ", actual " << argument;
@@ -55,38 +55,38 @@ namespace clay {
     void arityError2(size_t minExpected, size_t received) CLAY_NORETURN;
 
     template<class T>
-    inline void arityError(Pointer<T> context, size_t expected, size_t received) CLAY_NORETURN;
+    void arityError(Pointer<T> context, size_t expected, size_t received) CLAY_NORETURN;
 
     template<class T>
-    inline void arityError(Pointer<T> context, size_t expected, size_t received) {
+    void arityError(Pointer<T> context, size_t expected, size_t received) {
         if (context->location.ok())
             pushLocation(context->location);
         arityError(expected, received);
     }
 
     template<class T>
-    inline void arityError2(Pointer<T> context, size_t minExpected, size_t received) CLAY_NORETURN;
+    void arityError2(Pointer<T> context, size_t minExpected, size_t received) CLAY_NORETURN;
 
     template<class T>
-    inline void arityError2(Pointer<T> context, size_t minExpected, size_t received) {
+    void arityError2(Pointer<T> context, size_t minExpected, size_t received) {
         if (context->location.ok())
             pushLocation(context->location);
         arityError2(minExpected, received);
     }
 
-    void ensureArity(MultiStaticPtr args, size_t size);
-    void ensureArity(MultiEValuePtr args, size_t size);
-    void ensureArity(MultiPValuePtr args, size_t size);
-    void ensureArity(MultiCValuePtr args, size_t size);
+    void ensureArity(const MultiStaticPtr &args, size_t size);
+    void ensureArity(const MultiEValuePtr &args, size_t size);
+    void ensureArity(const MultiPValuePtr &args, size_t size);
+    void ensureArity(const MultiCValuePtr &args, size_t size);
 
     template<class T>
-    inline void ensureArity(T const &args, size_t size) {
+    void ensureArity(T const &args, size_t size) {
         if (args.size() != size)
             arityError(size, args.size());
     }
 
     template<class T>
-    inline void ensureArity2(T const &args, size_t size, bool hasVarArgs) {
+    void ensureArity2(T const &args, size_t size, bool hasVarArgs) {
         if (!hasVarArgs)
             ensureArity(args, size);
         else if (args.size() < size)
@@ -95,16 +95,16 @@ namespace clay {
 
     void arityMismatchError(size_t leftArity, size_t rightArity, bool hasVarArg) CLAY_NORETURN;
 
-    void typeError(llvm::StringRef expected, TypePtr receivedType) CLAY_NORETURN;
-    void typeError(TypePtr expectedType, TypePtr receivedType) CLAY_NORETURN;
+    void typeError(llvm::StringRef expected, const TypePtr &receivedType) CLAY_NORETURN;
+    void typeError(const TypePtr &expectedType, const TypePtr &receivedType) CLAY_NORETURN;
 
     void argumentTypeError(unsigned index,
                            llvm::StringRef expected,
-                           TypePtr receivedType) CLAY_NORETURN;
+                           const TypePtr &receivedType) CLAY_NORETURN;
 
     void argumentTypeError(unsigned index,
-                           TypePtr expectedType,
-                           TypePtr receivedType) CLAY_NORETURN;
+                           const TypePtr &expectedType,
+                           const TypePtr &receivedType) CLAY_NORETURN;
 
     void indexRangeError(llvm::StringRef kind,
                          size_t value,

From a8c074712b49df4c9df18aaf6c791e0405642e98 Mon Sep 17 00:00:00 2001
From: Ramon Asuncion <asuncionbatista@gmail.com>
Date: Thu, 11 Dec 2025 09:31:00 -0500
Subject: [PATCH 22/56] Fix formatting

---
 compiler/lambdas.hpp | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/compiler/lambdas.hpp b/compiler/lambdas.hpp
index f2386831..faf80384 100644
--- a/compiler/lambdas.hpp
+++ b/compiler/lambdas.hpp
@@ -3,7 +3,5 @@
 #include "clay.hpp"
 
 namespace clay {
-
-void initializeLambda(LambdaPtr x, EnvPtr env);
-
+    void initializeLambda(LambdaPtr x, EnvPtr env);
 }

From 3c3392ba8da8d9ec526ede0e7e4f8287134259d9 Mon Sep 17 00:00:00 2001
From: Ramon Asuncion <asuncionbatista@gmail.com>
Date: Thu, 11 Dec 2025 19:30:10 -0500
Subject: [PATCH 23/56] Remove const ref from llvm::Tripe in clay.cpp

---
 compiler/clay.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/compiler/clay.cpp b/compiler/clay.cpp
index 8761286f..2561a6ab 100644
--- a/compiler/clay.cpp
+++ b/compiler/clay.cpp
@@ -240,7 +240,7 @@ namespace clay {
                 assert(false);
         }
 
-        const llvm::Triple& triple(llvmModule->getTargetTriple());
+        llvm::Triple triple(llvmModule->getTargetTriple());
         if (sharedLib) {
             clangArgs.emplace_back("-shared");
 

From ebcf8844558fa42f83d3ee866916b008fe15da5a Mon Sep 17 00:00:00 2001
From: Ramon Asuncion <asuncionbatista@gmail.com>
Date: Thu, 11 Dec 2025 20:33:11 -0500
Subject: [PATCH 24/56] Refactor REPL JIT from ExecutionEngine to LLJit
 framework

---
 compiler/interactive.cpp | 110 ++++++++++++++++++++++++++++-----------
 1 file changed, 79 insertions(+), 31 deletions(-)

diff --git a/compiler/interactive.cpp b/compiler/interactive.cpp
index d3f25926..fd055101 100644
--- a/compiler/interactive.cpp
+++ b/compiler/interactive.cpp
@@ -1,3 +1,6 @@
+#include <llvm/Support/Error.h>
+#include <llvm/ExecutionEngine/Orc/LLJIT.h>
+
 #include "clay.hpp"
 #include "lexer.hpp"
 #include "parser.hpp"
@@ -7,9 +10,9 @@
 #include "invoketables.hpp"
 #include "env.hpp"
 
-#include <setjmp.h>
-#include <signal.h>
-#include <stdio.h>
+#include <csetjmp>
+#include <csignal>
+#include <cstdio>
 
 namespace clay {
     typedef llvm::SmallString<16U> Str;
@@ -17,13 +20,13 @@ namespace clay {
     const char *replAnonymousFunctionName = "__replAnonymousFunction__";
 
     static ModulePtr module;
-    static llvm::ExecutionEngine *engine;
+    static std::unique_ptr<llvm::orc::LLJIT> jit;
 
     jmp_buf recovery;
 
     static bool printAST = false;
 
-    static void eval(llvm::StringRef code);
+    static void eval(llvm::StringRef line);
 
     string newFunctionName() {
         static int funNum = 0;
@@ -105,7 +108,7 @@ namespace clay {
                 for (size_t k = 0; k < sets.size(); ++k) {
                     llvm::errs() << "        ";
                     for (size_t l = 0; l < sets[k]->argsKey.size(); ++l) {
-                        llvm::errs() << sets[k]->argsKey[l] << " : ";
+                        llvm::errs() << sets[k]->argsKey[l]->toString() << " : ";
                     }
                     llvm::errs() << "\n";
                 }
@@ -122,7 +125,7 @@ namespace clay {
                     llvm::errs() << "Can't find identifier " << identifier.c_str();
                 } else {
                     for (size_t i = 0; i < iter->second.size(); ++i) {
-                        llvm::errs() << iter->second[i] << "\n";
+                        llvm::errs() << iter->second[i]->toString() << "\n";
                     }
                 }
             }
@@ -156,15 +159,15 @@ namespace clay {
         }
     }
 
-    static void loadImports(llvm::ArrayRef<ImportPtr> imports) {
-        for (size_t i = 0; i < imports.size(); ++i) {
-            module->imports.push_back(imports[i]);
+    static void loadImports(const llvm::ArrayRef<ImportPtr> imports) {
+        for (const auto & import : imports) {
+            module->imports.push_back(import);
         }
-        for (size_t i = 0; i < imports.size(); ++i) {
-            loadDependent(module, nullptr, imports[i], false);
+        for (const auto & import : imports) {
+            loadDependent(module, nullptr, import, false);
         }
-        for (size_t i = 0; i < imports.size(); ++i) {
-            initModule(imports[i]->module);
+        for (const auto & import : imports) {
+            initModule(import->module);
         }
     }
 
@@ -174,7 +177,7 @@ namespace clay {
         }
         if (printAST) {
             for (size_t i = 0; i < toplevels.size(); ++i) {
-                llvm::errs() << i << ": " << toplevels[i] << "\n";
+                llvm::errs() << i << ": " << toplevels[i]->toString() << "\n";
             }
         }
         addGlobals(module, toplevels);
@@ -186,8 +189,8 @@ namespace clay {
         }
 
         if (printAST) {
-            for (size_t i = 0; i < statements.size(); ++i) {
-                llvm::errs() << statements[i] << "\n";
+            for (const auto & statement : statements) {
+                llvm::errs() << statement->toString() << "\n";
             }
         }
 
@@ -217,12 +220,34 @@ namespace clay {
         llvm::Function *dtor;
         codegenAfterRepl(ctor, dtor);
 
-        engine->runFunction(ctor, std::vector<llvm::GenericValue>());
+        // hacky voodoo raw memory address returned by LLJIT symbol lookup
+        // https://llvm.org/docs/ORCv2.html
+        using CtorPtr = void (*)();
+        using PFN = void (*)();
+
+        auto ctorAddExpected = jit->lookup(ctor->getName());
+        if (!ctorAddExpected) {
+            llvm::errs() << "error: cannot look up constructor: " << llvm::toString(ctorAddExpected.takeError()) << "\n";
+            return;
+        }
+        CtorPtr ctorFunc = reinterpret_cast<CtorPtr>(ctorAddExpected->getValue());
+        ctorFunc();
 
-        void *dtorLlvmFun = engine->getPointerToFunction(dtor);
-        typedef void (*PFN)();
+        auto dtorAddExpected = jit->lookup(dtor->getName());
+        if (!dtorAddExpected) {
+            llvm::errs() << "error: cannot look up destructor: " << llvm::toString(dtorAddExpected.takeError()) << "\n";
+            return;
+        }
+        void *dtorLlvmFun = reinterpret_cast<void *>(dtorAddExpected->getValue());
         atexit((PFN) (uintptr_t) dtorLlvmFun);
-        engine->runFunction(entryProc->llvmFunc, std::vector<llvm::GenericValue>());
+
+        auto entryAddrExpected = jit->lookup(entryProc->llvmFunc->getName());
+        if (!entryAddrExpected) {
+            llvm::errs() << "error: cannot look up entry function: " << llvm::toString(entryAddrExpected.takeError()) << "\n";
+            return;
+        }
+        PFN entryFunc = reinterpret_cast<PFN>(entryAddrExpected->getValue());
+        entryFunc();
     }
 
     static void jitAndPrintExpr(ExprPtr expr) {
@@ -249,14 +274,13 @@ namespace clay {
         }
     }
 
-    static void interactiveLoop() {
+    [[noreturn]] static void interactiveLoop() {
         setjmp(recovery);
-        string line;
         while (true) {
             llvm::errs().flush();
             llvm::errs() << "clay>";
             char buf[255];
-            line = fgets(buf, 255, stdin);
+            string line = fgets(buf, 255, stdin);
             line = stripSpaces(line);
             if (line[0] == ':') {
                 replCommand(line.substr(1, line.size() - 1));
@@ -264,7 +288,6 @@ namespace clay {
                 eval(line);
             }
         }
-        engine->runStaticConstructorsDestructors(true);
     }
 
     static void exceptionHandler(int i) {
@@ -284,12 +307,37 @@ namespace clay {
         llvm::errs() << ":globals to list globals\n";
         llvm::errs() << "In multi-line mode empty line to exit\n";
 
-        llvm::EngineBuilder eb(llvmModule);
-        llvm::TargetOptions targetOptions;
-        targetOptions.JITExceptionHandling = true;
-        eb.setTargetOptions(targetOptions);
-        engine = eb.create();
-        engine->runStaticConstructorsDestructors(false);
+        auto expectedJIT = llvm::orc::LLJITBuilder().create();
+        if (!expectedJIT) {
+            llvm::errs() << "error: could not create JIT: " << llvm::toString(expectedJIT.takeError()) << "\n";
+            return;
+        }
+        jit = std::move(*expectedJIT);
+
+        llvm::orc::JITDylib& mainDylib = jit->getMainJITDylib();
+
+        auto generatorExpected = llvm::orc::DynamicLibrarySearchGenerator::GetForCurrentProcess(
+            jit->getDataLayout().getGlobalPrefix()
+        );
+
+        if (!generatorExpected) {
+            llvm::errs() << "error: setting up symbol" << llvm::toString(generatorExpected.takeError()) << "\n";
+        } else {
+            std::unique_ptr<llvm::orc::DynamicLibrarySearchGenerator> generator =
+                std::move(*generatorExpected);
+            mainDylib.addGenerator(std::move(generator));
+        }
+
+        llvmModule->setDataLayout(jit->getDataLayout());
+
+        auto tsm = llvm::orc::ThreadSafeModule(
+            std::unique_ptr<llvm::Module>(llvmModule),
+            std::make_unique<llvm::LLVMContext>());
+
+        if (llvm::Error addIRErr = jit->addIRModule(std::move(tsm))) {
+            llvm::errs() << "error: " << addIRErr << "\n";
+            return;
+        }
 
         setAddTokens(&addTokens);
 

From 060cf372d06d8aad1489e42b96681c7e663c4056 Mon Sep 17 00:00:00 2001
From: Ramon Asuncion <asuncionbatista@gmail.com>
Date: Sat, 13 Dec 2025 06:01:53 -0500
Subject: [PATCH 25/56] Complete AssertionError

---
 compiler/ut.hpp | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/compiler/ut.hpp b/compiler/ut.hpp
index 51e01da7..bbb6cb11 100644
--- a/compiler/ut.hpp
+++ b/compiler/ut.hpp
@@ -1,5 +1,7 @@
 #pragma once
 
+#include <stdexcept>
+
 namespace clay {
     typedef void (*TestFunc)();
 
@@ -15,7 +17,8 @@ namespace clay {
     static TestRegistrator_ ## NAME testRegistrator_ ## NAME; \
     void NAME ## _testImpl()
 
-    struct AssertionError {
+    struct AssertionError  : std::runtime_error {
+        AssertionError() : std::runtime_error("AssertionError") {}
     };
 
 #define UT_FAIL() do { \

From 7fc94082c62202cb20376acef1abfde5af0985f4 Mon Sep 17 00:00:00 2001
From: Ramon Asuncion <asuncionbatista@gmail.com>
Date: Sat, 13 Dec 2025 06:06:38 -0500
Subject: [PATCH 26/56] Fix warnings with refcounted_ut.cpp

---
 compiler/refcounted_ut.cpp | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/compiler/refcounted_ut.cpp b/compiler/refcounted_ut.cpp
index 05582979..0d61a641 100644
--- a/compiler/refcounted_ut.cpp
+++ b/compiler/refcounted_ut.cpp
@@ -1,13 +1,14 @@
-#include "refcounted.hpp"
+#include <cstdio>
 
+#include "refcounted.hpp"
 #include "ut.hpp"
 
 namespace clay {
     CLAY_UNITTEST(RefCounted_copy_constructor) {
-        Pointer<RefCounted> p(new RefCounted);
+        Pointer p(new RefCounted);
         UT_ASSERT(p->getRefCount() == 1);
 
-        Pointer<RefCounted> p2(new RefCounted(*p));
+        Pointer p2(new RefCounted(*p));
         UT_ASSERT(p->getRefCount() == 1);
         UT_ASSERT(p2->getRefCount() == 1);
     }

From 4d1531be6f416b091aaa248e9725704942703f75 Mon Sep 17 00:00:00 2001
From: Ramon Asuncion <asuncionbatista@gmail.com>
Date: Sat, 13 Dec 2025 06:08:57 -0500
Subject: [PATCH 27/56] Mark getRefCount() with [[nodiscard]]

---
 compiler/refcounted.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/compiler/refcounted.hpp b/compiler/refcounted.hpp
index 3ec490b4..286310a2 100644
--- a/compiler/refcounted.hpp
+++ b/compiler/refcounted.hpp
@@ -73,7 +73,7 @@ namespace clay {
             }
         }
 
-        int getRefCount() const { return refCount; }
+        [[nodiscard]] int getRefCount() const { return refCount; }
 
         virtual ~RefCounted() = default;
     };

From 3b5e594ee573df07d7fa62da585cc4478ad689ca Mon Sep 17 00:00:00 2001
From: Ramon Asuncion <asuncionbatista@gmail.com>
Date: Sat, 13 Dec 2025 07:26:23 -0500
Subject: [PATCH 28/56] Add missing header for analyzer_op.cpp

---
 compiler/analyzer_op.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/compiler/analyzer_op.cpp b/compiler/analyzer_op.cpp
index 792e28b5..0448f604 100644
--- a/compiler/analyzer_op.cpp
+++ b/compiler/analyzer_op.cpp
@@ -6,8 +6,9 @@
 #include "env.hpp"
 
 #include "analyzer.hpp"
-
 #include "analyzer_op.hpp"
+#include "invoketables.hpp"
+#include "printer.hpp"
 
 namespace clay {
     static size_t staticToSizeTOrIntValue(MultiPValue *args, size_t index) {

From c26ef44f3a5f239ab6202b42854d2cb1d4ae19b9 Mon Sep 17 00:00:00 2001
From: Ramon Asuncion <asuncionbatista@gmail.com>
Date: Sat, 13 Dec 2025 08:07:08 -0500
Subject: [PATCH 29/56] Fix errors in claydoc.cpp

---
 compiler/claydoc.cpp | 56 +++++++++++++++++++++++++++-----------------
 1 file changed, 34 insertions(+), 22 deletions(-)

diff --git a/compiler/claydoc.cpp b/compiler/claydoc.cpp
index b9603319..a18fbba0 100644
--- a/compiler/claydoc.cpp
+++ b/compiler/claydoc.cpp
@@ -1,37 +1,40 @@
+#include <llvm/Support/Path.h>
+#include <llvm/Support/FileSystem.h>
+
 #include "claydoc.hpp"
 #include "parser.hpp"
+
 #include <sstream>
 #include <string>
 
 using namespace std;
 using namespace clay;
 
-static void usage(char *argv0) {
+static void usage(const char *argv0) {
     llvm::errs() << "usage: " << argv0 << " <sourceDir> <htmlOutputDir>\n";
 }
 
-DocModule *docParseModule(string fileName, DocState *state, std::string fqn) {
+DocModule *docParseModule(const string &fileName, DocState *state, const std::string& fqn) {
     SourcePtr src = new Source(fileName);
     ModulePtr m = parse(fileName, src, ParserKeepDocumentation);
 
-    DocModule *docMod = new DocModule;
+    auto *docMod = new DocModule;
     docMod->fileName = fileName;
     docMod->fqn = fqn;
 
-    DocSection *section = new DocSection;
+    auto *section = new DocSection;
     docMod->sections.push_back(section);
 
     DocumentationPtr lastAttachment;
 
-    for (vector<TopLevelItemPtr>::iterator i = m->topLevelItems.begin(); i != m->topLevelItems.end(); i++) {
-        TopLevelItemPtr item = *i;
+    for (const auto& item : m->topLevelItems) {
         if (!item)
             continue;
         std::string name = identifierString(item->name);
 
         switch (item->objKind) {
             case DOCUMENTATION: {
-                DocumentationPtr doc = ((Documentation *) item.ptr());
+                DocumentationPtr doc = dynamic_cast<Documentation *>(item.ptr());
                 if (doc->annotation.count(ModuleAnnotation)) {
                     docMod->name = doc->annotation.find(ModuleAnnotation)->second;
                     docMod->description = doc->text;
@@ -46,16 +49,16 @@ DocModule *docParseModule(string fileName, DocState *state, std::string fqn) {
                 break;
             }
             case OVERLOAD:
-                if (!!((clay::Overload *) item.ptr())->target)
-                    name = ((clay::Overload *) item.ptr())->target->asString();
+                if (!!dynamic_cast<Overload *>(item.ptr())->target)
+                    name = dynamic_cast<Overload *>(item.ptr())->target->asString();
             case RECORD_DECL:
             case PROCEDURE: {
-                DocObject *obj = new DocObject;
+                auto *obj = new DocObject;
                 obj->item = item;
                 obj->name = name;
                 if (!!lastAttachment) {
                     obj->description = lastAttachment->text;
-                    lastAttachment = 0;
+                    lastAttachment = nullptr;
                 }
                 section->objects.push_back(obj);
 
@@ -109,28 +112,37 @@ int main(int argc, char **argv) {
         return 1;
     }
 
-    bool whatever;
-    if (llvm::sys::fs::create_directories(outputDir, whatever) != 0) {
+    bool whatever = false;
+    std::error_code ec;
+
+    ec = llvm::sys::fs::create_directories(outputDir, whatever);
+    if (ec) {
         llvm::errs() << "cannot create output directory " << outputDir << "\n";
         return 4;
     }
 
-    DocState *state = new DocState;
+    std::error_code ec2;
+    auto *state = new DocState;
     state->name = llvm::sys::path::filename(inputDir).str();
 
-    llvm::error_code ec;
-    for (llvm::sys::fs::recursive_directory_iterator it(inputDir, ec), ite; it != ite; it.increment(ec)) {
+    for (llvm::sys::fs::recursive_directory_iterator it(inputDir, ec2), ite; it != ite; it.increment(ec)) {
         llvm::sys::fs::file_status status;
-        if (!it->status(status) && is_regular_file(status) && endsWith(it->path(), ".clay")) {
+        if (!it->status() && is_regular_file(status) && endsWith(it->path(), ".clay")) {
             std::string fqn;
 
             llvm::sys::path::const_iterator word = llvm::sys::path::begin(it->path());
-            ++word;
+            llvm::sys::path::const_iterator path_end = llvm::sys::path::end(it->path());
+
+            if (word != path_end)
+                ++word;
+
+            for (; word != path_end; ++word) {
+                llvm::sys::path::const_iterator next_word = word;
+                ++next_word;
 
-            llvm::sys::path::const_iterator worde = llvm::sys::path::end(it->path());
-            --worde;
+                if (next_word == path_end)
+                    break;
 
-            for (; word != worde; ++word) {
                 fqn.append(*word);
                 fqn.append(".");
             }
@@ -148,7 +160,7 @@ int main(int argc, char **argv) {
     emitHtmlIndex(outputDir, state);
 }
 
-std::string identifierString(clay::IdentifierPtr id) {
+std::string identifierString(const IdentifierPtr& id) {
     if (!id)
         return {"<anonymous>"};
     return {id->str.str().begin(), id->str.str().end()};

From 8cd3c1586a20189761dc6a5b05ebbfbf66ecbff8 Mon Sep 17 00:00:00 2001
From: Ramon Asuncion <asuncionbatista@gmail.com>
Date: Sat, 13 Dec 2025 08:07:32 -0500
Subject: [PATCH 30/56] Small edit in claydoc.hpp with `const`

---
 compiler/claydoc.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/compiler/claydoc.hpp b/compiler/claydoc.hpp
index e0b82d36..48ba7d8a 100644
--- a/compiler/claydoc.hpp
+++ b/compiler/claydoc.hpp
@@ -32,7 +32,7 @@ struct DocState {
     std::map<std::string, DocModule *> modules;
 };
 
-std::string identifierString(clay::IdentifierPtr id);
+std::string identifierString(const clay::IdentifierPtr& id);
 
 void emitHtmlModule(std::string outpath, DocModule *mod, std::string fqn);
 void emitHtmlIndex(std::string outpath, DocState *);

From 57428116bc73472ce7dfbdabbe946ef6e1074608 Mon Sep 17 00:00:00 2001
From: Ramon Asuncion <asuncionbatista@gmail.com>
Date: Sat, 13 Dec 2025 09:08:04 -0500
Subject: [PATCH 31/56] Fix errors with strings in lambdas.cpp

---
 compiler/lambdas.cpp | 198 ++++++++++++++++++++-----------------------
 1 file changed, 94 insertions(+), 104 deletions(-)

diff --git a/compiler/lambdas.cpp b/compiler/lambdas.cpp
index 95b8ed8b..f2f97e6b 100644
--- a/compiler/lambdas.cpp
+++ b/compiler/lambdas.cpp
@@ -7,6 +7,7 @@
 #include "loader.hpp"
 #include "env.hpp"
 #include "error.hpp"
+#include "printer.hpp"
 
 namespace clay {
     struct LambdaContext {
@@ -16,7 +17,7 @@ namespace clay {
         vector<string> &freeVars;
 
         LambdaContext(LambdaCapture captureBy,
-                      EnvPtr nonLocalEnv,
+                      const EnvPtr& nonLocalEnv,
                       llvm::StringRef closureDataName,
                       vector<string> &freeVars)
             : captureBy(captureBy), nonLocalEnv(nonLocalEnv),
@@ -24,40 +25,39 @@ namespace clay {
         }
     };
 
-    void convertFreeVars(LambdaPtr x, EnvPtr env,
+    void convertFreeVars(const LambdaPtr &x, const EnvPtr &env,
                          llvm::StringRef closureDataName,
                          vector<string> &freeVars);
 
-    void convertFreeVars(StatementPtr x, EnvPtr env, LambdaContext &ctx);
+    void convertFreeVars(const StatementPtr &x, EnvPtr env, LambdaContext &ctx);
 
-    void convertFreeVars(ExprPtr &x, EnvPtr env, LambdaContext &ctx);
+    void convertFreeVars(ExprPtr &x, const EnvPtr &env, LambdaContext &ctx);
 
-    void convertFreeVars(ExprList *x, EnvPtr env, LambdaContext &ctx);
+    void convertFreeVars(ExprList *x, const EnvPtr &env, LambdaContext &ctx);
     
     //
     // initializeLambda
     //
 
-    static TypePtr typeOfValue(ObjectPtr obj) {
+    static TypePtr typeOfValue(const ObjectPtr& obj) {
         switch (obj->objKind) {
-            case PVALUE: return ((PValue *) obj.ptr())->data.type;
-            case CVALUE: return ((CValue *) obj.ptr())->type;
+            case PVALUE: return dynamic_cast<PValue *>(obj.ptr())->data.type;
+            case CVALUE: return dynamic_cast<CValue *>(obj.ptr())->type;
             default: assert(false);
-                return nullptr;
         }
     }
 
-    static vector<TypePtr> typesOfValues(ObjectPtr obj) {
+    static vector<TypePtr> typesOfValues(const ObjectPtr &obj) {
         vector<TypePtr> types;
         switch (obj->objKind) {
             case MULTI_PVALUE: {
-                MultiPValue *mpv = (MultiPValue *) obj.ptr();
+                auto mpv = dynamic_cast<MultiPValue *>(obj.ptr());
                 for (unsigned i = 0; i < mpv->size(); ++i)
                     types.push_back(mpv->values[i].type);
                 break;
             }
             case MULTI_CVALUE: {
-                MultiCValue *mcv = (MultiCValue *) obj.ptr();
+                auto mcv = dynamic_cast<MultiCValue *>(obj.ptr());
                 for (unsigned i = 0; i < mcv->size(); ++i)
                     types.push_back(mcv->values[i]->type);
                 break;
@@ -68,13 +68,13 @@ namespace clay {
         return types;
     }
 
-    static void initializeLambdaWithFreeVars(LambdaPtr x, EnvPtr env,
+    static void initializeLambdaWithFreeVars(const LambdaPtr &x, const EnvPtr &env,
                                              llvm::StringRef closureDataName, llvm::StringRef lname);
 
-    static void initializeLambdaWithoutFreeVars(LambdaPtr x, EnvPtr env,
+    static void initializeLambdaWithoutFreeVars(const LambdaPtr &x, const EnvPtr &env,
                                                 llvm::StringRef lname);
 
-    static string lambdaName(LambdaPtr x) {
+    static string lambdaName(const LambdaPtr &x) {
         string fullName = shortString(x->asString());
 
         if (fullName.size() <= 80)
@@ -86,11 +86,11 @@ namespace clay {
             printFileLineCol(shortName, x->location);
             shortName << ">";
 
-            return shortName.str();
+            return shortName.str().str(); // what is this abomination
         }
     }
 
-    void initializeLambda(LambdaPtr x, EnvPtr env) {
+    void initializeLambda(const LambdaPtr& x, const EnvPtr &env) {
         assert(!x->initialized);
         x->initialized = true;
 
@@ -99,7 +99,7 @@ namespace clay {
         llvm::SmallString<128> buf;
         llvm::raw_svector_ostream ostr(buf);
         ostr << "%closureData:" << lname;
-        string closureDataName = ostr.str();
+        string closureDataName = ostr.str().str(); // again
 
         convertFreeVars(x, env, closureDataName, x->freeVars);
         getProcedureMonoTypes(x->mono, env, x->formalArgs, x->hasVarArg);
@@ -124,15 +124,15 @@ namespace clay {
         }
     }
 
-    static void checkForeignExpr(ObjectPtr &obj, EnvPtr env) {
+    static void checkForeignExpr(ObjectPtr &obj, const EnvPtr &env) {
         if (obj->objKind == EXPRESSION) {
-            ExprPtr expr = (Expr *) obj.ptr();
+            ExprPtr expr = dynamic_cast<Expr *>(obj.ptr());
             if (expr->exprKind == FOREIGN_EXPR) {
                 MultiPValuePtr mpv = safeAnalyzeMulti(new ExprList(expr), env, 0);
                 obj = mpv.ptr();
             }
         } else if (obj->objKind == EXPR_LIST) {
-            ExprListPtr expr = (ExprList *) obj.ptr();
+            ExprListPtr expr = dynamic_cast<ExprList *>(obj.ptr());
             switch (expr->exprs[0]->exprKind) {
                 case FOREIGN_EXPR:
                 case UNPACK: {
@@ -146,7 +146,7 @@ namespace clay {
         }
     }
 
-    static void initializeLambdaWithFreeVars(LambdaPtr x, EnvPtr env,
+    static void initializeLambdaWithFreeVars(const LambdaPtr &x, const EnvPtr &env,
                                              llvm::StringRef closureDataName, llvm::StringRef lname) {
         RecordDeclPtr r = new RecordDecl(nullptr, PRIVATE);
         r->location = x->location;
@@ -181,8 +181,7 @@ namespace clay {
                 case MULTI_CVALUE: {
                     vector<TypePtr> types = typesOfValues(obj);
                     vector<TypePtr> elementTypes;
-                    for (size_t j = 0; j < types.size(); ++j) {
-                        TypePtr t = types[j];
+                    for (auto t : types) {
                         if (x->captureBy == REF_CAPTURE)
                             t = pointerType(t);
                         elementTypes.push_back(t);
@@ -221,9 +220,9 @@ namespace clay {
         code->location = x->location;
         IdentifierPtr closureDataIdent = Identifier::get(closureDataName);
         FormalArgPtr closureDataArg = new FormalArg(closureDataIdent, typeExpr);
-        code->formalArgs.push_back(closureDataArg.ptr());
-        for (size_t i = 0; i < x->formalArgs.size(); ++i) {
-            code->formalArgs.push_back(x->formalArgs[i]);
+        code->formalArgs.emplace_back(closureDataArg.ptr());
+        for (const auto & formalArg : x->formalArgs) {
+            code->formalArgs.push_back(formalArg);
         }
         code->hasVarArg = x->hasVarArg;
         code->body = x->body;
@@ -236,11 +235,11 @@ namespace clay {
         ObjectPtr obj = operator_call();
         if (obj->objKind != PROCEDURE)
             error("'call' operator not found!");
-        Procedure *callObj = (Procedure *) obj.ptr();
+        auto *callObj = dynamic_cast<Procedure *>(obj.ptr());
         addOverload(callObj->overloads, overload);
     }
 
-    static void initializeLambdaWithoutFreeVars(LambdaPtr x, EnvPtr env,
+    static void initializeLambdaWithoutFreeVars(const LambdaPtr &x, const EnvPtr &env,
                                                 llvm::StringRef lname) {
         IdentifierPtr name = Identifier::get(lname, x->location);
         x->lambdaProc = new Procedure(nullptr, name, PRIVATE, false);
@@ -248,8 +247,8 @@ namespace clay {
 
         CodePtr code = new Code();
         code->location = x->location;
-        for (size_t i = 0; i < x->formalArgs.size(); ++i) {
-            code->formalArgs.push_back(x->formalArgs[i]);
+        for (const auto & formalArg : x->formalArgs) {
+            code->formalArgs.push_back(formalArg);
         }
         code->hasVarArg = x->hasVarArg;
         code->body = x->body;
@@ -268,11 +267,10 @@ namespace clay {
     // addFreeVar, typeOfValue, typesOfValues
     //
 
-    static void addFreeVar(LambdaContext &ctx, llvm::StringRef str) {
-        vector<string>::iterator i;
-        i = std::find(ctx.freeVars.begin(), ctx.freeVars.end(), str);
+    static void addFreeVar(const LambdaContext &ctx, llvm::StringRef str) {
+        auto i = std::find(ctx.freeVars.begin(), ctx.freeVars.end(), str);
         if (i == ctx.freeVars.end()) {
-            ctx.freeVars.push_back(str);
+            ctx.freeVars.push_back(str.str());
         }
     }
 
@@ -280,62 +278,57 @@ namespace clay {
     // convertFreeVars
     //
 
-    void convertFreeVars(LambdaPtr x, EnvPtr env,
+    void convertFreeVars(const LambdaPtr &x, const EnvPtr &env,
                          llvm::StringRef closureDataName,
                          vector<string> &freeVars) {
         EnvPtr env2 = new Env(env);
-        for (size_t i = 0; i < x->formalArgs.size(); ++i) {
-            FormalArgPtr arg = x->formalArgs[i];
+        for (const auto& arg : x->formalArgs) {
             addLocal(env2, arg->name, arg->name.ptr());
         }
         LambdaContext ctx(x->captureBy, env, closureDataName, freeVars);
         convertFreeVars(x->body, env2, ctx);
     }
 
-    static EnvPtr convertFreeVarsFromBinding(BindingPtr binding, EnvPtr env, LambdaContext &ctx) {
+    static EnvPtr convertFreeVarsFromBinding(const BindingPtr &binding, const EnvPtr &env, LambdaContext &ctx) {
         convertFreeVars(binding->values.ptr(), env, ctx);
         EnvPtr env2 = new Env(env);
-        for (size_t j = 0; j < binding->args.size(); ++j)
-            addLocal(env2, binding->args[j]->name, binding->args[j]->name.ptr());
+        for (const auto & arg : binding->args)
+            addLocal(env2, arg->name, arg->name.ptr());
         return env2;
     }
 
     static EnvPtr convertFreeVarsFromStatementExpressionStatements(
         llvm::ArrayRef<StatementPtr> stmts,
-        EnvPtr env,
+        const EnvPtr &env,
         LambdaContext &ctx) {
         EnvPtr env2 = env;
-        for (StatementPtr const *i = stmts.begin(), *end = stmts.end();
-             i != end;
-             ++i) {
-            switch ((*i)->stmtKind) {
+        for (const auto & stmt : stmts) {
+            switch (stmt->stmtKind) {
                 case BINDING:
-                    env2 = convertFreeVarsFromBinding((Binding *) i->ptr(), env2, ctx);
+                    env2 = convertFreeVarsFromBinding(dynamic_cast<Binding *>(stmt.ptr()), env2, ctx);
                     break;
 
                 case ASSIGNMENT:
                 case VARIADIC_ASSIGNMENT:
                 case INIT_ASSIGNMENT:
                 case EXPR_STATEMENT:
-                    convertFreeVars(*i, env2, ctx);
+                    convertFreeVars(stmt, env2, ctx);
                     break;
 
                 default:
                     assert(false);
-                    return nullptr;
             }
         }
         return env2;
     }
 
-    void convertFreeVars(StatementPtr x, EnvPtr env, LambdaContext &ctx) {
+    void convertFreeVars(const StatementPtr &x, EnvPtr env, LambdaContext &ctx) {
         switch (x->stmtKind) {
             case BLOCK: {
-                Block *y = (Block *) x.ptr();
-                for (size_t i = 0; i < y->statements.size(); ++i) {
-                    StatementPtr z = y->statements[i];
+                auto y = dynamic_cast<Block *>(x.ptr());
+                for (const auto& z : y->statements) {
                     if (z->stmtKind == BINDING)
-                        env = convertFreeVarsFromBinding((Binding *) z.ptr(), env, ctx);
+                        env = convertFreeVarsFromBinding(dynamic_cast<Binding *>(z.ptr()), env, ctx);
                     else
                         convertFreeVars(z, env, ctx);
                 }
@@ -348,21 +341,21 @@ namespace clay {
             }
 
             case ASSIGNMENT: {
-                Assignment *y = (Assignment *) x.ptr();
+                auto *y = dynamic_cast<Assignment *>(x.ptr());
                 convertFreeVars(y->left.ptr(), env, ctx);
                 convertFreeVars(y->right.ptr(), env, ctx);
                 break;
             }
 
             case INIT_ASSIGNMENT: {
-                InitAssignment *y = (InitAssignment *) x.ptr();
+                auto y = dynamic_cast<InitAssignment *>(x.ptr());
                 convertFreeVars(y->left.ptr(), env, ctx);
                 convertFreeVars(y->right.ptr(), env, ctx);
                 break;
             }
 
             case VARIADIC_ASSIGNMENT: {
-                VariadicAssignment *y = (VariadicAssignment *) x.ptr();
+                auto *y = dynamic_cast<VariadicAssignment *>(x.ptr());
                 convertFreeVars(y->exprs.ptr(), env, ctx);
                 break;
             }
@@ -372,13 +365,13 @@ namespace clay {
             }
 
             case RETURN: {
-                Return *y = (Return *) x.ptr();
+                auto *y = dynamic_cast<Return *>(x.ptr());
                 convertFreeVars(y->values.ptr(), env, ctx);
                 break;
             }
 
             case IF: {
-                If *y = (If *) x.ptr();
+                If *y = dynamic_cast<If *>(x.ptr());
                 env = convertFreeVarsFromStatementExpressionStatements(y->conditionStatements, env, ctx);
                 convertFreeVars(y->condition, env, ctx);
                 convertFreeVars(y->thenPart, env, ctx);
@@ -388,11 +381,10 @@ namespace clay {
             }
 
             case SWITCH: {
-                Switch *y = (Switch *) x.ptr();
+                auto y = dynamic_cast<Switch *>(x.ptr());
                 env = convertFreeVarsFromStatementExpressionStatements(y->exprStatements, env, ctx);
                 convertFreeVars(y->expr, env, ctx);
-                for (size_t i = 0; i < y->caseBlocks.size(); ++i) {
-                    CaseBlockPtr z = y->caseBlocks[i];
+                for (const auto& z : y->caseBlocks) {
                     convertFreeVars(z->caseLabels.ptr(), env, ctx);
                     convertFreeVars(z->body, env, ctx);
                 }
@@ -402,19 +394,19 @@ namespace clay {
             }
 
             case EVAL_STATEMENT: {
-                EvalStatement *eval = (EvalStatement *) x.ptr();
+                auto eval = dynamic_cast<EvalStatement *>(x.ptr());
                 convertFreeVars(eval->args.ptr(), env, ctx);
                 break;
             }
 
             case EXPR_STATEMENT: {
-                ExprStatement *y = (ExprStatement *) x.ptr();
+                auto y = dynamic_cast<ExprStatement *>(x.ptr());
                 convertFreeVars(y->expr, env, ctx);
                 break;
             }
 
             case WHILE: {
-                While *y = (While *) x.ptr();
+                auto y = dynamic_cast<While *>(x.ptr());
                 env = convertFreeVarsFromStatementExpressionStatements(y->conditionStatements, env, ctx);
                 convertFreeVars(y->condition, env, ctx);
                 convertFreeVars(y->body, env, ctx);
@@ -427,11 +419,11 @@ namespace clay {
             }
 
             case FOR: {
-                For *y = (For *) x.ptr();
+                For *y = dynamic_cast<For *>(x.ptr());
                 convertFreeVars(y->expr, env, ctx);
                 EnvPtr env2 = new Env(env);
-                for (size_t j = 0; j < y->variables.size(); ++j)
-                    addLocal(env2, y->variables[j], y->variables[j].ptr());
+                for (const auto & variable : y->variables)
+                    addLocal(env2, variable, variable.ptr());
                 convertFreeVars(y->body, env2, ctx);
                 break;
             }
@@ -441,24 +433,24 @@ namespace clay {
             }
 
             case TRY: {
-                Try *y = (Try *) x.ptr();
+                Try *y = dynamic_cast<Try *>(x.ptr());
                 convertFreeVars(y->tryBlock, env, ctx);
-                for (size_t i = 0; i < y->catchBlocks.size(); ++i) {
+                for (const auto & catchBlock : y->catchBlocks) {
                     EnvPtr env2 = new Env(env);
                     addLocal(env2,
-                             y->catchBlocks[i]->exceptionVar,
-                             y->catchBlocks[i]->exceptionVar.ptr()
+                             catchBlock->exceptionVar,
+                             catchBlock->exceptionVar.ptr()
                     );
-                    if (y->catchBlocks[i]->exceptionType.ptr())
-                        convertFreeVars(y->catchBlocks[i]->exceptionType, env, ctx);
-                    convertFreeVars(y->catchBlocks[i]->body, env2, ctx);
+                    if (catchBlock->exceptionType.ptr())
+                        convertFreeVars(catchBlock->exceptionType, env, ctx);
+                    convertFreeVars(catchBlock->body, env2, ctx);
                 }
 
                 break;
             }
 
             case THROW: {
-                Throw *y = (Throw *) x.ptr();
+                auto y = dynamic_cast<Throw *>(x.ptr());
                 desugarThrow(y);
                 convertFreeVars(y->desugaredExpr, env, ctx);
                 if (y->desugaredContext != nullptr)
@@ -467,7 +459,7 @@ namespace clay {
             }
 
             case STATIC_FOR: {
-                StaticFor *y = (StaticFor *) x.ptr();
+                auto y = dynamic_cast<StaticFor *>(x.ptr());
                 convertFreeVars(y->values.ptr(), env, ctx);
                 EnvPtr env2 = new Env(env);
                 addLocal(env2, y->variable, y->variable.ptr());
@@ -476,20 +468,18 @@ namespace clay {
             }
 
             case FINALLY: {
-                Finally *y = (Finally *) x.ptr();
+                auto y = dynamic_cast<Finally *>(x.ptr());
                 convertFreeVars(y->body, env, ctx);
                 break;
             }
 
             case ONERROR: {
-                OnError *y = (OnError *) x.ptr();
+                auto y = dynamic_cast<OnError *>(x.ptr());
                 convertFreeVars(y->body, env, ctx);
                 break;
             }
 
             case UNREACHABLE:
-                break;
-
             case STATIC_ASSERT_STATEMENT:
                 break;
 
@@ -498,7 +488,7 @@ namespace clay {
         }
     }
 
-    void convertFreeVars(ExprPtr &x, EnvPtr env, LambdaContext &ctx) {
+    void convertFreeVars(ExprPtr &x, const EnvPtr &env, LambdaContext &ctx) {
         switch (x->exprKind) {
             case BOOL_LITERAL:
             case INT_LITERAL:
@@ -508,7 +498,7 @@ namespace clay {
                 break;
 
             case NAME_REF: {
-                NameRef *y = (NameRef *) x.ptr();
+                auto y = dynamic_cast<NameRef *>(x.ptr());
                 bool isNonLocal = false;
                 bool isGlobal = false;
                 ObjectPtr z = lookupEnvEx(env, y->name, ctx.nonLocalEnv,
@@ -551,16 +541,16 @@ namespace clay {
                     } else if ((z->objKind == MULTI_PVALUE) || (z->objKind == MULTI_CVALUE)) {
                         vector<TypePtr> types = typesOfValues(z);
                         bool allStatic = true;
-                        for (size_t i = 0; i < types.size(); ++i) {
-                            if (!isStaticOrTupleOfStatics(types[i])) {
+                        for (const auto & type : types) {
+                            if (!isStaticOrTupleOfStatics(type)) {
                                 allStatic = false;
                                 break;
                             }
                         }
                         if (allStatic) {
                             ExprListPtr args = new ExprList();
-                            for (size_t i = 0; i < types.size(); ++i)
-                                args->add(new ObjectExpr(types[i].ptr()));
+                            for (const auto & type : types)
+                                args->add(new ObjectExpr(type.ptr()));
                             CallPtr call = new Call(operator_expr_typesToRValues(), args);
                             call->location = y->location;
                             x = call.ptr();
@@ -600,33 +590,33 @@ namespace clay {
             }
 
             case TUPLE: {
-                Tuple *y = (Tuple *) x.ptr();
+                auto y = dynamic_cast<Tuple *>(x.ptr());
                 convertFreeVars(y->args.ptr(), env, ctx);
                 break;
             }
 
             case PAREN: {
-                Paren *y = (Paren *) x.ptr();
+                auto y = dynamic_cast<Paren *>(x.ptr());
                 convertFreeVars(y->args.ptr(), env, ctx);
                 break;
             }
 
             case INDEXING: {
-                Indexing *y = (Indexing *) x.ptr();
+                auto y = dynamic_cast<Indexing *>(x.ptr());
                 convertFreeVars(y->expr, env, ctx);
                 convertFreeVars(y->args.ptr(), env, ctx);
                 break;
             }
 
             case CALL: {
-                Call *y = (Call *) x.ptr();
+                Call *y = dynamic_cast<Call *>(x.ptr());
                 convertFreeVars(y->expr, env, ctx);
                 convertFreeVars(y->parenArgs.ptr(), env, ctx);
                 break;
             }
 
             case FIELD_REF: {
-                FieldRef *y = (FieldRef *) x.ptr();
+                auto y = dynamic_cast<FieldRef *>(x.ptr());
                 if (y->desugared == nullptr)
                     desugarFieldRef(y, safeLookupModule(env));
                 if (!y->isDottedModuleName)
@@ -635,60 +625,60 @@ namespace clay {
             }
 
             case STATIC_INDEXING: {
-                StaticIndexing *y = (StaticIndexing *) x.ptr();
+                auto y = dynamic_cast<StaticIndexing *>(x.ptr());
                 convertFreeVars(y->expr, env, ctx);
                 break;
             }
 
             case VARIADIC_OP: {
-                VariadicOp *y = (VariadicOp *) x.ptr();
+                auto y = dynamic_cast<VariadicOp *>(x.ptr());
                 convertFreeVars(y->exprs.ptr(), env, ctx);
                 break;
             }
 
             case AND: {
-                And *y = (And *) x.ptr();
+                And *y = dynamic_cast<And *>(x.ptr());
                 convertFreeVars(y->expr1, env, ctx);
                 convertFreeVars(y->expr2, env, ctx);
                 break;
             }
 
             case OR: {
-                Or *y = (Or *) x.ptr();
+                Or *y = dynamic_cast<Or *>(x.ptr());
                 convertFreeVars(y->expr1, env, ctx);
                 convertFreeVars(y->expr2, env, ctx);
                 break;
             }
 
             case LAMBDA: {
-                Lambda *y = (Lambda *) x.ptr();
+                auto y = dynamic_cast<Lambda *>(x.ptr());
                 EnvPtr env2 = new Env(env);
-                for (size_t i = 0; i < y->formalArgs.size(); ++i)
-                    addLocal(env2, y->formalArgs[i]->name, y->formalArgs[i]->name.ptr());
+                for (const auto & formalArg : y->formalArgs)
+                    addLocal(env2, formalArg->name, formalArg->name.ptr());
                 convertFreeVars(y->body, env2, ctx);
                 break;
             }
 
             case UNPACK: {
-                Unpack *y = (Unpack *) x.ptr();
+                auto y = dynamic_cast<Unpack *>(x.ptr());
                 convertFreeVars(y->expr, env, ctx);
                 break;
             }
 
             case STATIC_EXPR: {
-                StaticExpr *y = (StaticExpr *) x.ptr();
+                auto y = dynamic_cast<StaticExpr *>(x.ptr());
                 convertFreeVars(y->expr, env, ctx);
                 break;
             }
 
             case DISPATCH_EXPR: {
-                DispatchExpr *y = (DispatchExpr *) x.ptr();
+                auto y = dynamic_cast<DispatchExpr *>(x.ptr());
                 convertFreeVars(y->expr, env, ctx);
                 break;
             }
 
             case EVAL_EXPR: {
-                EvalExpr *eval = (EvalExpr *) x.ptr();
+                auto eval = dynamic_cast<EvalExpr *>(x.ptr());
                 convertFreeVars(eval->args, env, ctx);
                 break;
             }
@@ -703,7 +693,7 @@ namespace clay {
         }
     }
 
-    void convertFreeVars(ExprList *x, EnvPtr env, LambdaContext &ctx) {
+    void convertFreeVars(ExprList *x, const EnvPtr &env, LambdaContext &ctx) {
         for (unsigned i = 0; i < x->size(); ++i)
             convertFreeVars(x->exprs[i], env, ctx);
     }

From 56d5f3b3f813fa61f627fafd7f05352fdfe4bae2 Mon Sep 17 00:00:00 2001
From: Ramon Asuncion <asuncionbatista@gmail.com>
Date: Sat, 13 Dec 2025 09:08:33 -0500
Subject: [PATCH 32/56] Update const ref to lambdas.hpp

---
 compiler/lambdas.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/compiler/lambdas.hpp b/compiler/lambdas.hpp
index faf80384..a9310232 100644
--- a/compiler/lambdas.hpp
+++ b/compiler/lambdas.hpp
@@ -3,5 +3,5 @@
 #include "clay.hpp"
 
 namespace clay {
-    void initializeLambda(LambdaPtr x, EnvPtr env);
+    void initializeLambda(const LambdaPtr& x, EnvPtr env);
 }

From 7c04e76bf4f3c5d4a35c91741740fdeedb361380 Mon Sep 17 00:00:00 2001
From: Ramon Asuncion <asuncionbatista@gmail.com>
Date: Sat, 13 Dec 2025 09:19:22 -0500
Subject: [PATCH 33/56] Add printer.hpp header file to analyzer.cpp

---
 compiler/analyzer.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/compiler/analyzer.cpp b/compiler/analyzer.cpp
index a64b5d81..31c42724 100644
--- a/compiler/analyzer.cpp
+++ b/compiler/analyzer.cpp
@@ -17,6 +17,7 @@
 #include "clone.hpp"
 #include "objects.hpp"
 #include "analyzer_op.hpp"
+#include "printer.hpp"
 
 #pragma clang diagnostic ignored "-Wcovered-switch-default"
 

From 160c4a3cceb48b97c9aaaad34d0299b038c4fb06 Mon Sep 17 00:00:00 2001
From: Ramon Asuncion <asuncionbatista@gmail.com>
Date: Sat, 13 Dec 2025 09:41:10 -0500
Subject: [PATCH 34/56] Update the use of `auto` in lambdas.cpp

---
 compiler/lambdas.cpp | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/compiler/lambdas.cpp b/compiler/lambdas.cpp
index f2f97e6b..c6ae9c0b 100644
--- a/compiler/lambdas.cpp
+++ b/compiler/lambdas.cpp
@@ -341,7 +341,7 @@ namespace clay {
             }
 
             case ASSIGNMENT: {
-                auto *y = dynamic_cast<Assignment *>(x.ptr());
+                auto y = dynamic_cast<Assignment *>(x.ptr());
                 convertFreeVars(y->left.ptr(), env, ctx);
                 convertFreeVars(y->right.ptr(), env, ctx);
                 break;
@@ -355,7 +355,7 @@ namespace clay {
             }
 
             case VARIADIC_ASSIGNMENT: {
-                auto *y = dynamic_cast<VariadicAssignment *>(x.ptr());
+                auto y = dynamic_cast<VariadicAssignment *>(x.ptr());
                 convertFreeVars(y->exprs.ptr(), env, ctx);
                 break;
             }
@@ -365,13 +365,13 @@ namespace clay {
             }
 
             case RETURN: {
-                auto *y = dynamic_cast<Return *>(x.ptr());
+                auto y = dynamic_cast<Return *>(x.ptr());
                 convertFreeVars(y->values.ptr(), env, ctx);
                 break;
             }
 
             case IF: {
-                If *y = dynamic_cast<If *>(x.ptr());
+                auto y = dynamic_cast<If *>(x.ptr());
                 env = convertFreeVarsFromStatementExpressionStatements(y->conditionStatements, env, ctx);
                 convertFreeVars(y->condition, env, ctx);
                 convertFreeVars(y->thenPart, env, ctx);
@@ -419,7 +419,7 @@ namespace clay {
             }
 
             case FOR: {
-                For *y = dynamic_cast<For *>(x.ptr());
+                auto y = dynamic_cast<For *>(x.ptr());
                 convertFreeVars(y->expr, env, ctx);
                 EnvPtr env2 = new Env(env);
                 for (const auto & variable : y->variables)
@@ -433,7 +433,7 @@ namespace clay {
             }
 
             case TRY: {
-                Try *y = dynamic_cast<Try *>(x.ptr());
+                auto y = dynamic_cast<Try *>(x.ptr());
                 convertFreeVars(y->tryBlock, env, ctx);
                 for (const auto & catchBlock : y->catchBlocks) {
                     EnvPtr env2 = new Env(env);
@@ -609,7 +609,7 @@ namespace clay {
             }
 
             case CALL: {
-                Call *y = dynamic_cast<Call *>(x.ptr());
+                auto y = dynamic_cast<Call *>(x.ptr());
                 convertFreeVars(y->expr, env, ctx);
                 convertFreeVars(y->parenArgs.ptr(), env, ctx);
                 break;
@@ -637,14 +637,14 @@ namespace clay {
             }
 
             case AND: {
-                And *y = dynamic_cast<And *>(x.ptr());
+                auto y = dynamic_cast<And *>(x.ptr());
                 convertFreeVars(y->expr1, env, ctx);
                 convertFreeVars(y->expr2, env, ctx);
                 break;
             }
 
             case OR: {
-                Or *y = dynamic_cast<Or *>(x.ptr());
+                auto y = dynamic_cast<Or *>(x.ptr());
                 convertFreeVars(y->expr1, env, ctx);
                 convertFreeVars(y->expr2, env, ctx);
                 break;

From f91cb78e032e1fdec5f3c9450c54429ed22968bb Mon Sep 17 00:00:00 2001
From: Ramon Asuncion <asuncionbatista@gmail.com>
Date: Sat, 13 Dec 2025 09:49:46 -0500
Subject: [PATCH 35/56] Remove `const` from `setSearchPath` in loader.hpp

---
 compiler/loader.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/compiler/loader.hpp b/compiler/loader.hpp
index 20a860df..8eaa5759 100644
--- a/compiler/loader.hpp
+++ b/compiler/loader.hpp
@@ -14,7 +14,7 @@ namespace clay {
                                llvm::ArrayRef<FormalArgPtr> formalArgs, bool hasVarArg);
 
     void initLoader();
-    void setSearchPath(const llvm::ArrayRef<PathString> path);
+    void setSearchPath(llvm::ArrayRef<PathString> path);
     ModulePtr loadProgram(llvm::StringRef fileName, vector<string> *sourceFiles, bool verbose, bool repl);
     ModulePtr loadProgramSource(llvm::StringRef name, llvm::StringRef source, bool verbose, bool repl);
     ModulePtr loadedModule(llvm::StringRef module);

From 924f194b6521c08ab160ff6a86941b6c5c8c44e9 Mon Sep 17 00:00:00 2001
From: Ramon Asuncion <asuncionbatista@gmail.com>
Date: Sat, 13 Dec 2025 09:53:03 -0500
Subject: [PATCH 36/56] Update `staticPValue` and remove unused header in
 analyzer.hpp

---
 compiler/analyzer.hpp | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/compiler/analyzer.hpp b/compiler/analyzer.hpp
index f2ee6e91..ee73296b 100644
--- a/compiler/analyzer.hpp
+++ b/compiler/analyzer.hpp
@@ -2,7 +2,6 @@
 
 #include "clay.hpp"
 
-// #include "invoketables.hpp"
 #include "types.hpp"
 
 namespace clay {
@@ -24,9 +23,9 @@ namespace clay {
     bool staticToCallingConv(ObjectPtr x, CallingConv &out);
     CallingConv staticToCallingConv(MultiStaticPtr x, unsigned index);
 
-    static inline PVData staticPValue(ObjectPtr x) {
+    static PVData staticPValue(const ObjectPtr& x) {
         const TypePtr t = staticType(x);
-        return PVData(t, true);
+        return {t, true};
     }
 
     enum BoolKind {

From 1fb70fd8273214c3f7a936b44031e50bdbc47c79 Mon Sep 17 00:00:00 2001
From: Ramon Asuncion <asuncionbatista@gmail.com>
Date: Sat, 13 Dec 2025 10:15:29 -0500
Subject: [PATCH 37/56] Fix warnings found in parser.cpp

---
 compiler/parser.cpp | 91 ++++++++++++++++++++++-----------------------
 1 file changed, 45 insertions(+), 46 deletions(-)

diff --git a/compiler/parser.cpp b/compiler/parser.cpp
index 13698281..2d79761b 100644
--- a/compiler/parser.cpp
+++ b/compiler/parser.cpp
@@ -24,7 +24,7 @@ namespace clay {
             if (inRepl) {
                 assert(addTokens != nullptr);
                 vector<Token> toks = addTokens();
-                if (toks.size() == 0) {
+                if (toks.empty()) {
                     inRepl = false;
                     return false;
                 }
@@ -50,7 +50,7 @@ namespace clay {
 
     static Location currentLocation() {
         if (position == tokens->size())
-            return Location();
+            return {};
         return (*tokens)[position].location;
     }
 
@@ -278,10 +278,9 @@ namespace clay {
     }
 
     static bool expressionList(ExprListPtr &x, bool = false) {
-        ExprListPtr a;
         ExprPtr b;
         if (!expression(b)) return false;
-        a = new ExprList(b);
+        ExprListPtr a = new ExprList(b);
         while (true) {
             unsigned p = save();
             if (!symbol(",")) {
@@ -481,30 +480,30 @@ namespace clay {
         return false;
     }
 
-    static void setSuffixBase(Expr *a, ExprPtr base) {
+    static void setSuffixBase(Expr *a, const ExprPtr &base) {
         switch (a->exprKind) {
             case INDEXING: {
-                Indexing *b = (Indexing *) a;
+                auto b = dynamic_cast<Indexing *>(a);
                 b->expr = base;
                 break;
             }
             case CALL: {
-                Call *b = (Call *) a;
+                Call *b = dynamic_cast<Call *>(a);
                 b->expr = base;
                 break;
             }
             case FIELD_REF: {
-                FieldRef *b = (FieldRef *) a;
+                auto b = dynamic_cast<FieldRef *>(a);
                 b->expr = base;
                 break;
             }
             case STATIC_INDEXING: {
-                StaticIndexing *b = (StaticIndexing *) a;
+                auto b = dynamic_cast<StaticIndexing *>(a);
                 b->expr = base;
                 break;
             }
             case VARIADIC_OP: {
-                VariadicOp *b = (VariadicOp *) a;
+                auto *b = dynamic_cast<VariadicOp *>(a);
                 assert(b->op == DEREFERENCE);
                 b->exprs->add(base);
                 break;
@@ -1033,7 +1032,7 @@ namespace clay {
 
     static bool optPatternVarsWithCond(vector<PatternVar> &x, ExprPtr &y);
 
-    static bool bindingsBody(vector<FormalArgPtr> &args, bool &hasVarArg);
+    static bool bindingsBody(vector<FormalArgPtr> &x, bool &hasVarArg);
 
     static bool localBinding(StatementPtr &x) {
         Location location = currentLocation();
@@ -1146,7 +1145,7 @@ namespace clay {
         if (!symbol(";")) return false;
         ExprListPtr exprs = new ExprList(new NameRef(Identifier::get(op, true)));
         if (z->exprKind == VARIADIC_OP) {
-            VariadicOp *y = (VariadicOp *) z.ptr();
+            auto y = dynamic_cast<VariadicOp *>(z.ptr());
             exprs->add(y->exprs);
         } else {
             exprs->add(z);
@@ -1167,8 +1166,8 @@ namespace clay {
         ExprListPtr exprs = new ExprList(new NameRef(Identifier::get(op, true)));
         exprs->add(y);
         if (z->exprKind == VARIADIC_OP) {
-            VariadicOp *y = (VariadicOp *) z.ptr();
-            exprs->add(y->exprs);
+            auto variadic_op = dynamic_cast<VariadicOp *>(z.ptr());
+            exprs->add(variadic_op->exprs);
         } else {
             exprs->add(z);
         }
@@ -1694,7 +1693,7 @@ namespace clay {
         return true;
     }
 
-    static FormalArgPtr makeStaticFormalArg(size_t index, ExprPtr expr, Location const &location) {
+    static FormalArgPtr makeStaticFormalArg(size_t index, const ExprPtr &expr, Location const &location) {
         // desugar static args
         llvm::SmallString<128> buf;
         llvm::raw_svector_ostream sout(buf);
@@ -1889,12 +1888,12 @@ namespace clay {
         } else {
             int bracket = 1;
             while (bracket) {
-                unsigned p = save();
+                unsigned i = save();
                 if (symbol("[")) {
                     ++bracket;
                     continue;
                 }
-                restore(p);
+                restore(i);
                 if (symbol("]"))
                     --bracket;
             }
@@ -2285,7 +2284,7 @@ namespace clay {
         if (symbol(":")) {
             if (!optReturnTypeList(returnSpecs)) return false;
             if (!optVarReturnType(varReturnSpec)) return false;
-            if (returnSpecs.size() > 0 || varReturnSpec != nullptr)
+            if (!returnSpecs.empty() || varReturnSpec != nullptr)
                 exprRetSpecs = true;
             return true;
         } else {
@@ -2312,7 +2311,7 @@ namespace clay {
     //
 
     static bool isOverload(bool &isDefault) {
-        int p = save();
+        int p = static_cast<int>(save());
         if (keyword("overload"))
             isDefault = false;
         else if (restore(p), keyword("default"))
@@ -2394,7 +2393,7 @@ namespace clay {
 
         ProcedurePtr u = new Procedure(module, z, vis, true);
         u->location = location;
-        x.push_back(u.ptr());
+        x.emplace_back(u.ptr());
 
         ExprPtr target = new NameRef(z);
         target->location = location;
@@ -2402,7 +2401,7 @@ namespace clay {
         target->endLocation = targetEndLocation;
         OverloadPtr v = new Overload(module, target, y, false, isInline, hasAsConversion);
         v->location = location;
-        x.push_back(v.ptr());
+        x.emplace_back(v.ptr());
 
         u->singleOverload = v;
 
@@ -2444,7 +2443,7 @@ namespace clay {
 
         ProcedurePtr proc = new Procedure(module, name, vis, privateOverload, interface);
         proc->location = location;
-        x.push_back(proc.ptr());
+        x.emplace_back(proc.ptr());
 
         return true;
     }
@@ -2475,14 +2474,14 @@ namespace clay {
         if (!body(code->body)) return false;
         code->location = location;
         if (exprRetSpecs && code->body->stmtKind == RETURN) {
-            Return *x = (Return *) code->body.ptr();
-            if (x->isExprReturn)
-                x->isReturnSpecs = true;
+            auto return_ = dynamic_cast<Return *>(code->body.ptr());
+            if (return_->isExprReturn)
+                return_->isReturnSpecs = true;
         }
 
         ProcedurePtr proc = new Procedure(module, name, vis, true);
         proc->location = location;
-        x.push_back(proc.ptr());
+        x.emplace_back(proc.ptr());
 
         ExprPtr target = new NameRef(name);
         target->location = location;
@@ -2490,7 +2489,7 @@ namespace clay {
         target->endLocation = targetEndLocation;
         OverloadPtr oload = new Overload(module, target, code, callByName, isInline, hasAsConversion);
         oload->location = location;
-        x.push_back(oload.ptr());
+        x.emplace_back(oload.ptr());
 
         proc->singleOverload = oload;
 
@@ -2542,9 +2541,9 @@ namespace clay {
             if (!llvmCode(code->llvmBody)) return false;
         }
         if (exprRetSpecs && code->body->stmtKind == RETURN) {
-            Return *x = (Return *) code->body.ptr();
-            if (x->isExprReturn)
-                x->isReturnSpecs = true;
+            auto return_ = dynamic_cast<Return *>(code->body.ptr());
+            if (return_->isExprReturn)
+                return_->isReturnSpecs = true;
         }
         target->location = location;
         target->startLocation = targetStartLocation;
@@ -2975,7 +2974,7 @@ namespace clay {
         Location location = currentLocation();
         Token *t;
         if (!next(t) || t->tokenKind != T_DOC_PROPERTY) return false;
-        llvm::StringRef key = llvm::StringRef(t->str);
+        auto key = llvm::StringRef(t->str);
 
         DocumentationAnnotation ano;
         if (key == "section") {
@@ -2993,7 +2992,7 @@ namespace clay {
         }
 
         if (!next(t) || t->tokenKind != T_DOC_TEXT) return false;
-        llvm::StringRef value = llvm::StringRef(t->str);
+        auto value = llvm::StringRef(t->str);
 
         an.insert(std::pair<DocumentationAnnotation, string>(ano, value.str()));
         return true;
@@ -3173,22 +3172,22 @@ namespace clay {
                 break;
             }
 
-            unsigned p = save();
+            unsigned i = save();
 
             if (!topLevelItem(x.toplevels, nullptr)) {
-                restore(p);
+                restore(i);
             } else {
                 continue;
             }
 
             if (!import(x.imports)) {
-                restore(p);
+                restore(i);
             } else {
                 continue;
             }
 
             if (!blockItem(stmtItem)) {
-                restore(p);
+                restore(i);
                 break;
             } else {
                 x.stmts.push_back(stmtItem);
@@ -3205,7 +3204,7 @@ namespace clay {
     //
 
     template<typename Parser, typename ParserParam, typename Node>
-    void applyParser(SourcePtr source, unsigned offset, size_t length, Parser parser, ParserParam parserParam,
+    void applyParser(const SourcePtr& source, unsigned offset, size_t length, Parser parser, ParserParam parserParam,
                      Node &node) {
         vector<Token> t;
         tokenize(source, offset, length, t);
@@ -3216,7 +3215,7 @@ namespace clay {
         if (!parser(node, parserParam) || (position < t.size())) {
             Location location;
             if (maxPosition == t.size())
-                location = Location(source.ptr(), unsigned(source->size()));
+                location = Location(source.ptr(), static_cast<unsigned>(source->size()));
             else
                 location = t[maxPosition].location;
             pushLocation(location);
@@ -3229,11 +3228,11 @@ namespace clay {
 
     struct ModuleParser {
         llvm::StringRef moduleName;
-        bool operator()(ModulePtr &m, Module *) { return module(moduleName, m); }
+        bool operator()(ModulePtr &m, Module *) const { return module(moduleName, m); }
     };
 
-    ModulePtr parse(llvm::StringRef moduleName, SourcePtr source, ParserFlags flags) {
-        if (flags && ParserKeepDocumentation)
+    ModulePtr parse(llvm::StringRef moduleName, const SourcePtr &source, ParserFlags flags) {
+        if (flags)
             parserOptionKeepDocumentation = true;
         ModulePtr m;
         ModuleParser p = {moduleName};
@@ -3246,7 +3245,7 @@ namespace clay {
     // parseExpr
     //
 
-    ExprPtr parseExpr(SourcePtr source, unsigned offset, size_t length) {
+    ExprPtr parseExpr(const SourcePtr &source, unsigned offset, size_t length) {
         ExprPtr expr;
         applyParser(source, offset, length, expression, false, expr);
         return expr;
@@ -3256,7 +3255,7 @@ namespace clay {
     // parseExprList
     //
 
-    ExprListPtr parseExprList(SourcePtr source, unsigned offset, size_t length) {
+    ExprListPtr parseExprList(const SourcePtr &source, unsigned offset, size_t length) {
         ExprListPtr exprList;
         applyParser(source, offset, length, expressionList, false, exprList);
         return exprList;
@@ -3266,7 +3265,7 @@ namespace clay {
     // parseStatements
     //
 
-    void parseStatements(SourcePtr source, unsigned offset, size_t length,
+    void parseStatements(const SourcePtr &source, unsigned offset, size_t length,
                          vector<StatementPtr> &stmts) {
         applyParser(source, offset, length, blockItems, false, stmts);
     }
@@ -3275,7 +3274,7 @@ namespace clay {
     // parseTopLevelItems
     //
 
-    void parseTopLevelItems(SourcePtr source, unsigned offset, size_t length,
+    void parseTopLevelItems(const SourcePtr &source, unsigned offset, size_t length,
                             vector<TopLevelItemPtr> &topLevels, Module *module) {
         applyParser(source, offset, length, topLevelItems, module, topLevels);
     }
@@ -3284,7 +3283,7 @@ namespace clay {
     // parseInteractive
     //
 
-    ReplItem parseInteractive(SourcePtr source, unsigned offset, size_t length) {
+    ReplItem parseInteractive(const SourcePtr &source, unsigned offset, size_t length) {
         ReplItem x;
         applyParser(source, offset, length, replItems, false, x);
         return x;

From 624e35920314568c0db7ec841bd9a68eacdcd513 Mon Sep 17 00:00:00 2001
From: Ramon Asuncion <asuncionbatista@gmail.com>
Date: Sat, 13 Dec 2025 10:23:04 -0500
Subject: [PATCH 38/56] Add missing printer.hpp header file for
 invoketables.cpp

---
 compiler/invoketables.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/compiler/invoketables.cpp b/compiler/invoketables.cpp
index b8c6789b..d80935b2 100644
--- a/compiler/invoketables.cpp
+++ b/compiler/invoketables.cpp
@@ -5,6 +5,7 @@
 #include "constructors.hpp"
 #include "clone.hpp"
 #include "objects.hpp"
+#include "printer.hpp"
 
 #pragma clang diagnostic ignored "-Wcovered-switch-default"
 

From 7d19e8d7b159c0b0c497d8ab623163772c138c64 Mon Sep 17 00:00:00 2001
From: Ramon Asuncion <asuncionbatista@gmail.com>
Date: Sat, 13 Dec 2025 10:35:39 -0500
Subject: [PATCH 39/56] Add const ref to header to match definitions

---
 compiler/parser.hpp | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/compiler/parser.hpp b/compiler/parser.hpp
index 3af1a3a9..a8243843 100644
--- a/compiler/parser.hpp
+++ b/compiler/parser.hpp
@@ -17,19 +17,19 @@ namespace clay {
         vector<StatementPtr> stmts;
     };
 
-    ModulePtr parse(llvm::StringRef moduleName, SourcePtr source, ParserFlags flags = NoParserFlags);
+    ModulePtr parse(llvm::StringRef moduleName, const SourcePtr &source, ParserFlags flags = NoParserFlags);
 
-    ExprPtr parseExpr(SourcePtr source, unsigned offset, size_t length);
+    ExprPtr parseExpr(const SourcePtr &source, unsigned offset, size_t length);
 
-    ExprListPtr parseExprList(SourcePtr source, unsigned offset, size_t length);
+    ExprListPtr parseExprList(const SourcePtr &source, unsigned offset, size_t length);
 
-    void parseStatements(SourcePtr source, unsigned offset, size_t length,
+    void parseStatements(const SourcePtr &source, unsigned offset, size_t length,
                          vector<StatementPtr> &statements);
 
-    void parseTopLevelItems(SourcePtr source, unsigned offset, size_t length,
+    void parseTopLevelItems(const SourcePtr &source, unsigned offset, size_t length,
                             vector<TopLevelItemPtr> &topLevels, Module *);
 
-    ReplItem parseInteractive(SourcePtr source, unsigned offset, size_t length);
+    ReplItem parseInteractive(const SourcePtr &source, unsigned offset, size_t length);
 
     typedef vector<Token> (*AddTokensCallback)();
 

From 7597805413866e803a2b6971214f009756664d11 Mon Sep 17 00:00:00 2001
From: Ramon Asuncion <asuncionbatista@gmail.com>
Date: Sat, 13 Dec 2025 10:58:09 -0500
Subject: [PATCH 40/56] Change out the deprecated isX86_MMXTy call

---
 compiler/analyzer.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/compiler/analyzer.cpp b/compiler/analyzer.cpp
index 31c42724..edf9018b 100644
--- a/compiler/analyzer.cpp
+++ b/compiler/analyzer.cpp
@@ -1443,7 +1443,7 @@ namespace clay {
                     }
                     return;
                 case IITDescriptor::MMX:
-                    if (!Ty->isX86_MMXTy()) {
+                    if (!Ty->isX86_AMXTy()) {
                         errors << "intrinsic argument " << (ai + 1)
                                 << " must match LLVM MMX type, but got ";
                         Ty->print(errors);

From b9e892cfac8d5181b09e774363e8c4e0ba01b41d Mon Sep 17 00:00:00 2001
From: Ramon Asuncion <asuncionbatista@gmail.com>
Date: Sat, 13 Dec 2025 10:59:10 -0500
Subject: [PATCH 41/56] Update the IITDescriptor::Vector case in analyzer.cpp

---
 compiler/analyzer.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/compiler/analyzer.cpp b/compiler/analyzer.cpp
index edf9018b..d471bd9c 100644
--- a/compiler/analyzer.cpp
+++ b/compiler/analyzer.cpp
@@ -1480,11 +1480,11 @@ namespace clay {
                     return;
                 case IITDescriptor::Vector: {
                     llvm::VectorType *VT = dyn_cast<llvm::VectorType>(Ty);
-                    if (VT == 0) {
+                    if (VT == nullptr) {
                         errors << "intrinsic argument " << (ai + 1)
                                 << " must be of an LLVM vector type, but got ";
                         Ty->print(errors);
-                    } else if (VT->getNumElements() != D.Vector_Width) {
+                    } else if (VT->getElementCount() != D.Vector_Width) {
                         errors << "intrinsic argument " << (ai + 1)
                                 << " must be of an LLVM vector type with "
                                 << D.Vector_Width

From ff31c4c4c09efdc72518868ab8214dd2a16c5822 Mon Sep 17 00:00:00 2001
From: Ramon Asuncion <asuncionbatista@gmail.com>
Date: Sat, 13 Dec 2025 11:01:20 -0500
Subject: [PATCH 42/56] Fix some ambiguous function calls using const ref in
 types.cpp

---
 compiler/analyzer.cpp |  6 ++----
 compiler/types.cpp    | 38 +++++++++++++++++++-------------------
 2 files changed, 21 insertions(+), 23 deletions(-)

diff --git a/compiler/analyzer.cpp b/compiler/analyzer.cpp
index d471bd9c..8cb92b27 100644
--- a/compiler/analyzer.cpp
+++ b/compiler/analyzer.cpp
@@ -56,8 +56,7 @@ namespace clay {
           params(params), varParam(varParam), expr(expr) {
     }
 
-    GlobalVariable::~GlobalVariable() {
-    }
+    GlobalVariable::~GlobalVariable() = default;
 
     static StatementAnalysis analyzeStatement(StatementPtr stmt, EnvPtr env, AnalysisContext *ctx);
 
@@ -220,8 +219,7 @@ namespace clay {
     static vector<CompileContextEntry> analysisErrorCompileContext;
 
     struct ClearAnalysisError {
-        ClearAnalysisError() {
-        }
+        ClearAnalysisError() = default;
 
         ~ClearAnalysisError() {
             analysisErrorLocation = Location();
diff --git a/compiler/types.cpp b/compiler/types.cpp
index 055c45e9..8e5635af 100644
--- a/compiler/types.cpp
+++ b/compiler/types.cpp
@@ -250,7 +250,7 @@ namespace clay {
     TypePtr cCodePointerType(CallingConv callingConv,
                              llvm::ArrayRef<TypePtr> argTypes,
                              bool hasVarArgs,
-                             TypePtr returnType) {
+                             const TypePtr& returnType) {
         unsigned h = unsigned(callingConv) * 100;
         for (unsigned i = 0; i < argTypes.size(); ++i) {
             h += pointerHash(argTypes[i].ptr());
@@ -277,7 +277,7 @@ namespace clay {
         return t.ptr();
     }
 
-    TypePtr arrayType(TypePtr elementType, unsigned size) {
+    TypePtr arrayType(const TypePtr& elementType, const unsigned size) {
         unsigned h = pointerHash(elementType.ptr()) + size;
         h &= unsigned(arrayTypes.size() - 1);
         vector<ArrayTypePtr>::iterator i, end;
@@ -292,7 +292,7 @@ namespace clay {
         return t.ptr();
     }
 
-    TypePtr vecType(TypePtr elementType, unsigned size) {
+    TypePtr vecType(const TypePtr& elementType, const unsigned size) {
         if (elementType->typeKind != INTEGER_TYPE && elementType->typeKind != FLOAT_TYPE)
             error("Vec element type must be an integer or float type");
         unsigned h = pointerHash(elementType.ptr()) + size;
@@ -329,7 +329,7 @@ namespace clay {
         return t.ptr();
     }
 
-    TypePtr unionType(llvm::ArrayRef<TypePtr> memberTypes) {
+    TypePtr unionType(const llvm::ArrayRef<TypePtr> memberTypes) {
         unsigned h = 0;
         TypePtr const *mi, *mend;
         for (mi = memberTypes.begin(), mend = memberTypes.end();
@@ -349,7 +349,7 @@ namespace clay {
         return t.ptr();
     }
 
-    TypePtr recordType(RecordDeclPtr record, llvm::ArrayRef<ObjectPtr> params) {
+    TypePtr recordType(const RecordDeclPtr& record, llvm::ArrayRef<ObjectPtr> params) {
         unsigned h = pointerHash(record.ptr());
         ObjectPtr const *pi, *pend;
         for (pi = params.begin(), pend = params.end(); pi != pend; ++pi)
@@ -370,7 +370,7 @@ namespace clay {
         return t.ptr();
     }
 
-    TypePtr variantType(VariantDeclPtr variant, llvm::ArrayRef<ObjectPtr> params) {
+    TypePtr variantType(const VariantDeclPtr& variant, llvm::ArrayRef<ObjectPtr> params) {
         unsigned h = pointerHash(variant.ptr());
         for (unsigned i = 0; i < params.size(); ++i)
             h += objectHash(params[i]);
@@ -388,7 +388,7 @@ namespace clay {
         return t.ptr();
     }
 
-    TypePtr staticType(ObjectPtr obj) {
+    TypePtr staticType(const ObjectPtr& obj) {
         unsigned h = objectHash(obj);
         h &= unsigned(staticTypes.size() - 1);
         vector<StaticTypePtr> &bucket = staticTypes[h];
@@ -412,13 +412,13 @@ namespace clay {
         t->initialized = true;
     }
 
-    TypePtr enumType(EnumDeclPtr enumeration) {
+    TypePtr enumType(const EnumDeclPtr& enumeration) {
         if (!enumeration->type)
             enumeration->type = new EnumType(enumeration);
         return enumeration->type;
     }
 
-    void initializeNewType(NewTypePtr t) {
+    void initializeNewType(const NewTypePtr& t) {
         if (t->newtype->initialized)
             return;
         CompileContextPusher pusher(t.ptr());
@@ -426,13 +426,13 @@ namespace clay {
         t->newtype->initialized = true;
     }
 
-    TypePtr newType(NewTypeDeclPtr newtype) {
+    TypePtr newType(const NewTypeDeclPtr& newtype) {
         if (!newtype->type)
             newtype->type = new NewType(newtype);
         return newtype->type.ptr();
     }
 
-    TypePtr newtypeReprType(NewTypePtr t) {
+    TypePtr newtypeReprType(const NewTypePtr& t) {
         if (!t->newtype->initialized)
             initializeNewType(t);
         return t->newtype->baseType;
@@ -640,7 +640,7 @@ namespace clay {
             setProperty(type, props[i]);
     }
 
-    void initializeRecordFields(RecordTypePtr t) {
+    void initializeRecordFields(const RecordTypePtr& t) {
         CompileContextPusher pusher(t.ptr());
 
         assert(!t->fieldsInitialized);
@@ -727,7 +727,7 @@ namespace clay {
         return t->fieldNames;
     }
 
-    llvm::ArrayRef<TypePtr> recordFieldTypes(RecordTypePtr t) {
+    llvm::ArrayRef<TypePtr> recordFieldTypes(const RecordTypePtr& t) {
         if (!t->fieldsInitialized)
             initializeRecordFields(t);
         return t->fieldTypes;
@@ -743,14 +743,14 @@ namespace clay {
     // variantMemberTypes, variantReprType, dispatchTagCount
     //
 
-    static TypePtr getVariantReprType(VariantTypePtr t) {
+    static TypePtr getVariantReprType(const VariantTypePtr& t) {
         ExprPtr variantReprType = operator_expr_variantReprType();
         ExprPtr reprExpr = new Call(variantReprType, new ExprList(new ObjectExpr(t.ptr())));
 
         return evaluateType(reprExpr, new Env());
     }
 
-    static void initializeVariantType(VariantTypePtr t) {
+    static void initializeVariantType(const VariantTypePtr& t) {
         assert(!t->initialized);
 
         CompileContextPusher pusher(t.ptr());
@@ -987,7 +987,7 @@ namespace clay {
 
     static void defineLLVMType(TypePtr t);
 
-    static void makeLLVMType(TypePtr t);
+    static void makeLLVMType(const TypePtr& t);
 
     llvm::PointerType *llvmPointerType(TypePtr t) {
         if (!t->llType)
@@ -1024,7 +1024,7 @@ namespace clay {
     // llvmType
     //
 
-    static void makeLLVMType(TypePtr t) {
+    static void makeLLVMType(const TypePtr& t) {
         if (t->llType == nullptr) {
             verifyRecursionCorrectness(t);
             declareLLVMType(t);
@@ -1034,7 +1034,7 @@ namespace clay {
         }
     }
 
-    llvm::Type *llvmType(TypePtr t) {
+    llvm::Type *llvmType(const TypePtr& t) {
         makeLLVMType(t);
 
         return t->llType;
@@ -1050,7 +1050,7 @@ namespace clay {
         return theType;
     }
 
-    llvm::DIType llvmTypeDebugInfo(TypePtr t) {
+    llvm::DIType llvmTypeDebugInfo(const TypePtr& t) {
         if (t->llType == nullptr)
             declareLLVMType(t);
 

From 52f7b750c92ac31b8d2c80d08af819813633239c Mon Sep 17 00:00:00 2001
From: Ramon Asuncion <asuncionbatista@gmail.com>
Date: Sat, 13 Dec 2025 11:20:10 -0500
Subject: [PATCH 43/56] Use TrackingMDNodeRef for DISubprogram debug info and
 fix warnings

---
 compiler/invoketables.hpp | 26 ++++++++++++++++----------
 1 file changed, 16 insertions(+), 10 deletions(-)

diff --git a/compiler/invoketables.hpp b/compiler/invoketables.hpp
index 764885b4..19815b6e 100644
--- a/compiler/invoketables.hpp
+++ b/compiler/invoketables.hpp
@@ -7,12 +7,14 @@ namespace clay {
     struct InvokeSet;
     struct InvokeEntry;
 
-    static llvm::SpecificBumpPtrAllocator<InvokeEntry> *invokeEntryAllocator
+    static auto invokeEntryAllocator
             = new llvm::SpecificBumpPtrAllocator<InvokeEntry>();
-    static llvm::SpecificBumpPtrAllocator<InvokeSet> *invokeSetAllocator
+    static auto invokeSetAllocator
             = new llvm::SpecificBumpPtrAllocator<InvokeSet>();
 
     struct InvokeEntry {
+        virtual ~InvokeEntry() = default;
+
         InvokeSet *parent;
         ObjectPtr callable;
         vector<TypePtr> argsKey;
@@ -36,9 +38,9 @@ namespace clay {
         vector<TypePtr> returnTypes;
 
         llvm::Function *llvmFunc;
-        llvm::Function *llvmCWrappers[CC_Count];
+        llvm::Function *llvmCWrappers[CC_Count]{};
 
-        llvm::TrackingVH<llvm::MDNode> debugInfo;
+        llvm::TrackingMDNodeRef debugInfo;
 
         bool analyzed: 1;
         bool analyzing: 1;
@@ -46,7 +48,7 @@ namespace clay {
         bool runtimeNop: 1;
 
         InvokeEntry(InvokeSet *parent,
-                    ObjectPtr callable,
+                    const ObjectPtr &callable,
                     llvm::ArrayRef<TypePtr> argsKey)
             : parent(parent), callable(callable),
               argsKey(argsKey),
@@ -58,8 +60,8 @@ namespace clay {
               analyzing(false),
               callByName(false),
               runtimeNop(false) {
-            for (size_t i = 0; i < CC_Count; ++i)
-                llvmCWrappers[i] = nullptr;
+            for (auto & llvmCWrapper : llvmCWrappers)
+                llvmCWrapper = nullptr;
         }
 
         void *operator new(size_t num_bytes) {
@@ -67,12 +69,16 @@ namespace clay {
         }
 
         virtual void dealloc() { ANodeAllocator->Deallocate(this); }
-        llvm::DISubprogram getDebugInfo() { return llvm::DISubprogram(debugInfo); }
+        llvm::DISubprogram *getDebugInfo() const {
+            return llvm::dyn_cast_or_null<llvm::DISubprogram>(debugInfo.get());
+        }
     };
 
     extern vector<OverloadPtr> patternOverloads;
 
     struct InvokeSet {
+        virtual ~InvokeSet() = default;
+
         ObjectPtr callable;
         vector<TypePtr> argsKey;
         OverloadPtr interface;
@@ -87,9 +93,9 @@ namespace clay {
         bool shouldLog: 1;
         bool evaluatingPredicate: 1;
 
-        InvokeSet(ObjectPtr callable,
+        InvokeSet(const ObjectPtr &callable,
                   llvm::ArrayRef<TypePtr> argsKey,
-                  OverloadPtr symbolInterface,
+                  const OverloadPtr &symbolInterface,
                   llvm::ArrayRef<OverloadPtr> symbolOverloads)
             : callable(callable), argsKey(argsKey),
               interface(symbolInterface),

From f561ea25c7f20a0b78440e2a6250d3bd473fabe3 Mon Sep 17 00:00:00 2001
From: Ramon Asuncion <asuncionbatista@gmail.com>
Date: Sat, 13 Dec 2025 11:28:29 -0500
Subject: [PATCH 44/56] Apply .get() on buffer in desugar.cpp

---
 compiler/desugar.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/compiler/desugar.cpp b/compiler/desugar.cpp
index 15c852f1..73cabcbb 100644
--- a/compiler/desugar.cpp
+++ b/compiler/desugar.cpp
@@ -7,6 +7,7 @@
 #include "clone.hpp"
 #include "objects.hpp"
 #include "error.hpp"
+#include "printer.hpp"
 
 namespace clay {
     ExprPtr desugarCharLiteral(char c) {
@@ -402,7 +403,7 @@ namespace clay {
         sourceNameOut << ">";
 
         return new Source(sourceNameOut.str(),
-                          llvm::MemoryBuffer::getMemBufferCopy(sourceTextBuf));
+                          llvm::MemoryBuffer::getMemBufferCopy(sourceTextBuf).get());
     }
 
     ExprListPtr desugarEvalExpr(EvalExprPtr eval, EnvPtr env) {

From e3a3f9614f3c5b97748155296efca0166786f8a3 Mon Sep 17 00:00:00 2001
From: Ramon Asuncion <asuncionbatista@gmail.com>
Date: Sat, 13 Dec 2025 12:35:43 -0500
Subject: [PATCH 45/56] Define modern AttributeList and include FoldingSet

---
 compiler/externals.hpp | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/compiler/externals.hpp b/compiler/externals.hpp
index dbdb107f..b5f6f284 100644
--- a/compiler/externals.hpp
+++ b/compiler/externals.hpp
@@ -1,5 +1,7 @@
 #pragma once
 
+#include <llvm/ADT/FoldingSet.h>
+
 #include "clay.hpp"
 #include "codegen.hpp"
 
@@ -41,7 +43,7 @@ namespace clay {
         llvm::CallingConv::ID llConv;
         ArgInfo retInfo;
         vector<ArgInfo> argInfos;
-        vector<pair<unsigned, llvm::Attributes>> attrs;
+        llvm::AttributeList attrs;
 
         ExternalFunction(CallingConv conv, TypePtr ret,
                          vector<TypePtr> &args, size_t numReqArg,

From 0ccd673b7bf90a97a6b05ecc3221ec23fa23f711 Mon Sep 17 00:00:00 2001
From: Ramon Asuncion <asuncionbatista@gmail.com>
Date: Sun, 14 Dec 2025 04:59:18 -0500
Subject: [PATCH 46/56] Add .gitattributes

---
 .gitattributes | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 .gitattributes

diff --git a/.gitattributes b/.gitattributes
new file mode 100644
index 00000000..bc8bc344
--- /dev/null
+++ b/.gitattributes
@@ -0,0 +1 @@
+*.clay linguist-language=C

From 70ccdef7774c3b8760b81ec50e396e1203c7013f Mon Sep 17 00:00:00 2001
From: Ramon Asuncion <asuncionbatista@gmail.com>
Date: Sun, 14 Dec 2025 08:29:07 -0500
Subject: [PATCH 47/56] Fix the header situation with llvm in clay.hpp

---
 compiler/analyzer.cpp     |  2 --
 compiler/analyzer_op.cpp  |  2 --
 compiler/clay.cpp         | 29 -----------------------------
 compiler/clay.hpp         | 35 ++++++++++++++++++++++++++++++++++-
 compiler/claydoc.cpp      |  6 +++---
 compiler/codegen_op.cpp   |  2 +-
 compiler/desugar.cpp      |  3 +--
 compiler/error.cpp        |  2 ++
 compiler/error.hpp        |  3 +--
 compiler/interactive.cpp  |  3 ---
 compiler/invoketables.cpp |  1 -
 compiler/lambdas.cpp      |  1 -
 compiler/loader.cpp       |  2 ++
 compiler/loader.hpp       |  1 -
 compiler/profiler.cpp     |  1 -
 15 files changed, 44 insertions(+), 49 deletions(-)

diff --git a/compiler/analyzer.cpp b/compiler/analyzer.cpp
index 8cb92b27..631f9bbf 100644
--- a/compiler/analyzer.cpp
+++ b/compiler/analyzer.cpp
@@ -1,4 +1,3 @@
-
 #include "clay.hpp"
 #include "evaluator.hpp"
 #include "codegen.hpp"
@@ -17,7 +16,6 @@
 #include "clone.hpp"
 #include "objects.hpp"
 #include "analyzer_op.hpp"
-#include "printer.hpp"
 
 #pragma clang diagnostic ignored "-Wcovered-switch-default"
 
diff --git a/compiler/analyzer_op.cpp b/compiler/analyzer_op.cpp
index 0448f604..b1ace831 100644
--- a/compiler/analyzer_op.cpp
+++ b/compiler/analyzer_op.cpp
@@ -4,11 +4,9 @@
 #include "constructors.hpp"
 #include "loader.hpp"
 #include "env.hpp"
-
 #include "analyzer.hpp"
 #include "analyzer_op.hpp"
 #include "invoketables.hpp"
-#include "printer.hpp"
 
 namespace clay {
     static size_t staticToSizeTOrIntValue(MultiPValue *args, size_t index) {
diff --git a/compiler/clay.cpp b/compiler/clay.cpp
index 2561a6ab..2b1b76db 100644
--- a/compiler/clay.cpp
+++ b/compiler/clay.cpp
@@ -1,32 +1,3 @@
-#include <llvm/Support/FileSystem.h>
-#include <llvm/Support/Path.h>
-#include <llvm/Support/Program.h>
-#include <llvm/Support/ErrorOr.h>
-#include <llvm/Support/Signals.h>
-#include <llvm/TargetParser/Host.h>
-#include <llvm/TargetParser/Triple.h>
-#include <llvm/Support/FileUtilities.h>
-#include <llvm/Target/TargetMachine.h>
-#include <llvm/IR/Verifier.h>
-#include <llvm/IR/Module.h>
-#include <llvm/IR/PassManager.h>
-#include <llvm/Passes/PassBuilder.h>
-#include <llvm/Passes/OptimizationLevel.h>
-#include <llvm/Support/FormattedStream.h>
-#include <llvm/Support/raw_ostream.h>
-#include <llvm/Support/Error.h>
-#include <llvm/ExecutionEngine/Orc/LLJIT.h>
-#include <llvm/ExecutionEngine/Orc/ThreadSafeModule.h>
-#include <llvm/Transforms/IPO/Internalize.h>
-#include <llvm/Bitcode/BitcodeWriterPass.h>
-#include <llvm/IR/LegacyPassManager.h>
-#include <llvm/ExecutionEngine/Orc/ExecutionUtils.h>
-#include <llvm/ADT/ArrayRef.h>
-#include <llvm/ExecutionEngine/Orc/Core.h>
-#include <llvm/IR/Function.h>
-#include <llvm/Transforms/InstCombine/InstCombine.h>
-#include <llvm/IRPrinter/IRPrintingPasses.h>
-
 #include <system_error>
 #include <vector>
 #include <string>
diff --git a/compiler/clay.hpp b/compiler/clay.hpp
index 83433e3c..5013752c 100644
--- a/compiler/clay.hpp
+++ b/compiler/clay.hpp
@@ -17,7 +17,6 @@
 #pragma warning(disable: 4146 4244 4267 4355 4146 4800 4996)
 #endif
 
-#include <llvm/ADT/FoldingSet.h>
 #include <llvm/ADT/SmallString.h>
 #include <llvm/ADT/SmallVector.h>
 #include <llvm/ADT/StringMap.h>
@@ -34,6 +33,40 @@
 #include <llvm/Support/MemoryBuffer.h>
 #include <llvm/Transforms/Scalar/GVN.h>
 #include <llvm/IR/GlobalVariable.h>
+#include <llvm/IR/Metadata.h>
+#include <llvm/Support/FileSystem.h>
+#include <llvm/Support/Path.h>
+#include <llvm/Support/Program.h>
+#include <llvm/Support/ErrorOr.h>
+#include <llvm/Support/Signals.h>
+#include <llvm/TargetParser/Host.h>
+#include <llvm/TargetParser/Triple.h>
+#include <llvm/Support/FileUtilities.h>
+#include <llvm/Target/TargetMachine.h>
+#include <llvm/IR/Verifier.h>
+#include <llvm/IR/Module.h>
+#include <llvm/IR/PassManager.h>
+#include <llvm/Passes/PassBuilder.h>
+#include <llvm/Passes/OptimizationLevel.h>
+#include <llvm/Support/FormattedStream.h>
+#include <llvm/Support/raw_ostream.h>
+#include <llvm/Support/Error.h>
+#include <llvm/ExecutionEngine/Orc/LLJIT.h>
+#include <llvm/ExecutionEngine/Orc/ThreadSafeModule.h>
+#include <llvm/Transforms/IPO/Internalize.h>
+#include <llvm/Bitcode/BitcodeWriterPass.h>
+#include <llvm/IR/LegacyPassManager.h>
+#include <llvm/ExecutionEngine/Orc/ExecutionUtils.h>
+#include <llvm/ADT/ArrayRef.h>
+#include <llvm/ExecutionEngine/Orc/Core.h>
+#include <llvm/Transforms/InstCombine/InstCombine.h>
+#include <llvm/IRPrinter/IRPrintingPasses.h>
+#include <llvm/Support/AtomicOrdering.h>
+#include <llvm/MC/TargetRegistry.h>
+#include <llvm/Support/TargetSelect.h>
+#include <llvm/ExecutionEngine/ExecutionEngine.h>
+#include <llvm/Support/AtomicOrdering.h>
+#include <llvm/IR/Attributes.h>
 
 #include <complex>
 
diff --git a/compiler/claydoc.cpp b/compiler/claydoc.cpp
index a18fbba0..f691e46c 100644
--- a/compiler/claydoc.cpp
+++ b/compiler/claydoc.cpp
@@ -1,12 +1,12 @@
 #include <llvm/Support/Path.h>
 #include <llvm/Support/FileSystem.h>
 
-#include "claydoc.hpp"
-#include "parser.hpp"
-
 #include <sstream>
 #include <string>
 
+#include "claydoc.hpp"
+#include "parser.hpp"
+
 using namespace std;
 using namespace clay;
 
diff --git a/compiler/codegen_op.cpp b/compiler/codegen_op.cpp
index 990d60dc..595ce87f 100644
--- a/compiler/codegen_op.cpp
+++ b/compiler/codegen_op.cpp
@@ -9,8 +9,8 @@
 #include "constructors.hpp"
 #include "externals.hpp"
 #include "env.hpp"
-
 #include "codegen_op.hpp"
+#include "invoketables.hpp"
 
 namespace clay {
     static llvm::StringMap<llvm::Constant *> stringTableConstants;
diff --git a/compiler/desugar.cpp b/compiler/desugar.cpp
index 73cabcbb..1b713e1f 100644
--- a/compiler/desugar.cpp
+++ b/compiler/desugar.cpp
@@ -1,13 +1,12 @@
 #include "clay.hpp"
 #include "operators.hpp"
 #include "evaluator.hpp"
-// #include "analyzer.hpp"
+#include "analyzer.hpp"
 #include "desugar.hpp"
 #include "parser.hpp"
 #include "clone.hpp"
 #include "objects.hpp"
 #include "error.hpp"
-#include "printer.hpp"
 
 namespace clay {
     ExprPtr desugarCharLiteral(char c) {
diff --git a/compiler/error.cpp b/compiler/error.cpp
index d0f8cc2d..7a7bffb7 100644
--- a/compiler/error.cpp
+++ b/compiler/error.cpp
@@ -6,6 +6,8 @@
 #include "error.hpp"
 #include "printer.hpp"
 
+#include <cstdarg>
+
 namespace clay {
     bool shouldPrintFullMatchErrors;
     set<pair<string, string> > logMatchSymbols;
diff --git a/compiler/error.hpp b/compiler/error.hpp
index 247d53dd..a08ed56f 100644
--- a/compiler/error.hpp
+++ b/compiler/error.hpp
@@ -1,8 +1,7 @@
 #pragma once
 
 #include "clay.hpp"
-// #include "invoketables.hpp"
-// #include "printer.hpp"
+#include "printer.hpp"
 
 #if defined(__GNUC__) || defined(__clang__)
 #define CLAY_NORETURN __attribute__((noreturn))
diff --git a/compiler/interactive.cpp b/compiler/interactive.cpp
index fd055101..9896819b 100644
--- a/compiler/interactive.cpp
+++ b/compiler/interactive.cpp
@@ -1,6 +1,3 @@
-#include <llvm/Support/Error.h>
-#include <llvm/ExecutionEngine/Orc/LLJIT.h>
-
 #include "clay.hpp"
 #include "lexer.hpp"
 #include "parser.hpp"
diff --git a/compiler/invoketables.cpp b/compiler/invoketables.cpp
index d80935b2..b8c6789b 100644
--- a/compiler/invoketables.cpp
+++ b/compiler/invoketables.cpp
@@ -5,7 +5,6 @@
 #include "constructors.hpp"
 #include "clone.hpp"
 #include "objects.hpp"
-#include "printer.hpp"
 
 #pragma clang diagnostic ignored "-Wcovered-switch-default"
 
diff --git a/compiler/lambdas.cpp b/compiler/lambdas.cpp
index c6ae9c0b..c96abf15 100644
--- a/compiler/lambdas.cpp
+++ b/compiler/lambdas.cpp
@@ -7,7 +7,6 @@
 #include "loader.hpp"
 #include "env.hpp"
 #include "error.hpp"
-#include "printer.hpp"
 
 namespace clay {
     struct LambdaContext {
diff --git a/compiler/loader.cpp b/compiler/loader.cpp
index 071d8338..d2bbc060 100644
--- a/compiler/loader.cpp
+++ b/compiler/loader.cpp
@@ -1,3 +1,5 @@
+#include <system_error>
+
 #include "clay.hpp"
 #include "loader.hpp"
 #include "patterns.hpp"
diff --git a/compiler/loader.hpp b/compiler/loader.hpp
index 8eaa5759..0f0cada9 100644
--- a/compiler/loader.hpp
+++ b/compiler/loader.hpp
@@ -1,6 +1,5 @@
 #pragma once
 
-
 #include "clay.hpp"
 
 namespace clay {
diff --git a/compiler/profiler.cpp b/compiler/profiler.cpp
index b91f8aa5..2262977d 100644
--- a/compiler/profiler.cpp
+++ b/compiler/profiler.cpp
@@ -1,6 +1,5 @@
 #include "clay.hpp"
 #include "profiler.hpp"
-#include "printer.hpp"
 
 namespace clay {
     static llvm::StringMap<int> countsMap;

From 92bc0837a5a09e24a311b3b0ae1f01ae2e4b8bd6 Mon Sep 17 00:00:00 2001
From: Ramon Asuncion <asuncionbatista@gmail.com>
Date: Sun, 14 Dec 2025 08:32:31 -0500
Subject: [PATCH 48/56] Undo mistake of replaceall nullptr

---
 compiler/codegen.cpp    | 4 ++--
 compiler/codegen_op.cpp | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/compiler/codegen.cpp b/compiler/codegen.cpp
index 9f22d4a1..c6ec722c 100644
--- a/compiler/codegen.cpp
+++ b/compiler/codegen.cpp
@@ -42,7 +42,7 @@ namespace clay {
     }
 
     llvm::Value *noExceptionReturnValue() {
-        return llvm::ConstantPointernullptr::get(exceptionReturnType());
+        return llvm::ConstantPointerNull::get(exceptionReturnType());
     }
 
     void codegenValueInit(CValuePtr dest, CodegenContext *ctx);
@@ -1360,7 +1360,7 @@ namespace clay {
         assert(mpv->size() == 1);
         PVData const &y = mpv->values[0];
         llvm::Constant *initializer =
-                llvm::Constant::getnullptrValue(llvmType(y.type));
+                llvm::Constant::getNullValue(llvmType(y.type));
 
         llvm::SmallString<128> nameBuf;
         llvm::raw_svector_ostream nameStr(nameBuf);
diff --git a/compiler/codegen_op.cpp b/compiler/codegen_op.cpp
index 595ce87f..f572b7a8 100644
--- a/compiler/codegen_op.cpp
+++ b/compiler/codegen_op.cpp
@@ -1335,7 +1335,7 @@ namespace clay {
                 break;
             }
 
-            case PRIM_nullptrPointer: {
+            case PRIM_nullPointer: {
                 ensureArity(args, 1);
                 TypePtr dest = valueToPointerLikeType(args, 0);
                 assert(out->size() == 1);
@@ -1343,7 +1343,7 @@ namespace clay {
                 assert(out0->type == dest);
                 llvm::PointerType *llType = llvm::dyn_cast<llvm::PointerType>(llvmType(dest));
                 assert(llType != nullptr);
-                llvm::Value *result = llvm::ConstantPointernullptr::get(llType);
+                llvm::Value *result = llvm::ConstantPointerNull::get(llType);
                 ctx->builder->CreateStore(result, out0->llValue);
                 break;
             }

From d4eff9e96f1518a4c6870b979e40ea94c77b0821 Mon Sep 17 00:00:00 2001
From: Ramon Asuncion <asuncionbatista@gmail.com>
Date: Sun, 14 Dec 2025 08:32:52 -0500
Subject: [PATCH 49/56] Update .gitattributes to JS

---
 .gitattributes | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.gitattributes b/.gitattributes
index bc8bc344..623cd141 100644
--- a/.gitattributes
+++ b/.gitattributes
@@ -1 +1 @@
-*.clay linguist-language=C
+*.clay linguist-language=JavaScript

From 097dbc07e1f32bd89da38bbd15295cc572e5355b Mon Sep 17 00:00:00 2001
From: Ramon Asuncion <asuncionbatista@gmail.com>
Date: Sun, 14 Dec 2025 08:34:24 -0500
Subject: [PATCH 50/56] Remove const reference on recordType

---
 compiler/clay.hpp  | 2 +-
 compiler/types.cpp | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/compiler/clay.hpp b/compiler/clay.hpp
index 5013752c..bde527a9 100644
--- a/compiler/clay.hpp
+++ b/compiler/clay.hpp
@@ -2725,7 +2725,7 @@ namespace clay {
         bool fieldsInitialized: 1;
         bool hasVarField: 1;
 
-        RecordType(const RecordDeclPtr &record, llvm::ArrayRef<ObjectPtr> params);
+        RecordType(RecordDeclPtr record, llvm::ArrayRef<ObjectPtr> params);
 
         size_t varFieldSize() const {
             return fieldTypes.size() - fieldNames.size() + 1;
diff --git a/compiler/types.cpp b/compiler/types.cpp
index 8e5635af..ba7e4f06 100644
--- a/compiler/types.cpp
+++ b/compiler/types.cpp
@@ -349,7 +349,7 @@ namespace clay {
         return t.ptr();
     }
 
-    TypePtr recordType(const RecordDeclPtr& record, llvm::ArrayRef<ObjectPtr> params) {
+    TypePtr recordType(RecordDeclPtr record, llvm::ArrayRef<ObjectPtr> params) {
         unsigned h = pointerHash(record.ptr());
         ObjectPtr const *pi, *pend;
         for (pi = params.begin(), pend = params.end(); pi != pend; ++pi)

From 92d35829a257a114eb30fc8265399224ea2fca3b Mon Sep 17 00:00:00 2001
From: Ramon Asuncion <asuncionbatista@gmail.com>
Date: Sun, 14 Dec 2025 08:34:48 -0500
Subject: [PATCH 51/56] Add toString to profiler.cpp

---
 compiler/profiler.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/compiler/profiler.cpp b/compiler/profiler.cpp
index 2262977d..56940757 100644
--- a/compiler/profiler.cpp
+++ b/compiler/profiler.cpp
@@ -7,7 +7,7 @@ namespace clay {
     void incrementCount(const ObjectPtr &obj) {
         string buf;
         llvm::raw_string_ostream sout(buf);
-        sout << obj;
+        sout << obj->toString();
         string s = sout.str();
         llvm::StringMap<int>::iterator i = countsMap.find(s);
         if (i == countsMap.end()) {

From 6076eb7ebe103214b62617fc91f8d30dbb9f9363 Mon Sep 17 00:00:00 2001
From: Ramon Asuncion <asuncionbatista@gmail.com>
Date: Sun, 14 Dec 2025 08:35:19 -0500
Subject: [PATCH 52/56] Remove const reference from error.cpp

---
 compiler/error.cpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/compiler/error.cpp b/compiler/error.cpp
index 7a7bffb7..35e4e592 100644
--- a/compiler/error.cpp
+++ b/compiler/error.cpp
@@ -36,7 +36,7 @@ namespace clay {
         contextStack.emplace_back(obj, params);
     }
 
-    void pushCompileContext(const ObjectPtr &obj, llvm::ArrayRef<ObjectPtr> params, llvm::ArrayRef<unsigned> dispatchIndices) {
+    void pushCompileContext(ObjectPtr obj, llvm::ArrayRef<ObjectPtr> params, llvm::ArrayRef<unsigned> dispatchIndices) {
         if (contextStack.size() >= RECURSION_WARNING_LEVEL)
             warning("potential runaway recursion");
         if (!contextStack.empty())
@@ -56,7 +56,7 @@ namespace clay {
         contextStack = x;
     }
 
-    CompileContextPusher::CompileContextPusher(const ObjectPtr &obj, llvm::ArrayRef<PVData> params,
+    CompileContextPusher::CompileContextPusher(ObjectPtr obj, llvm::ArrayRef<PVData> params,
                                                llvm::ArrayRef<unsigned> dispatchIndices) {
         vector<ObjectPtr> params2;
         for (const auto & param : params) {
@@ -97,7 +97,7 @@ namespace clay {
 
     int DebugPrinter::indent = 0;
 
-    DebugPrinter::DebugPrinter(const ObjectPtr &obj)
+    DebugPrinter::DebugPrinter(ObjectPtr obj)
         : obj(obj) {
         for (int i = 0; i < indent; ++i)
             llvm::outs() << ' ';

From 47ae5ae5c81eeaf9dedb2c5652067b747ed45e42 Mon Sep 17 00:00:00 2001
From: Ramon Asuncion <asuncionbatista@gmail.com>
Date: Sun, 14 Dec 2025 08:36:41 -0500
Subject: [PATCH 53/56] Add type to CreateLoad in codegen_op.cpp

---
 compiler/codegen_op.cpp | 21 ++++++++++++++-------
 1 file changed, 14 insertions(+), 7 deletions(-)

diff --git a/compiler/codegen_op.cpp b/compiler/codegen_op.cpp
index f572b7a8..ebbdbaec 100644
--- a/compiler/codegen_op.cpp
+++ b/compiler/codegen_op.cpp
@@ -155,7 +155,8 @@ namespace clay {
             }
             type = cv->type;
         }
-        return ctx->builder->CreateLoad(cv->llValue);
+        llvm::Type *llTy = llvmType(cv->type);
+        return ctx->builder->CreateLoad(llTy, cv->llValue);
     }
 
     static llvm::Value *floatValue(MultiCValuePtr args,
@@ -175,7 +176,8 @@ namespace clay {
             }
             type = (FloatType *) cv->type.ptr();
         }
-        return ctx->builder->CreateLoad(cv->llValue);
+        llvm::Type *llTy = llvmType(cv->type);
+        return ctx->builder->CreateLoad(llTy, cv->llValue);
     }
 
     static llvm::Value *integerOrPointerLikeValue(MultiCValuePtr args,
@@ -198,7 +200,8 @@ namespace clay {
             }
             type = cv->type;
         }
-        return ctx->builder->CreateLoad(cv->llValue);
+        llvm::Type *llTy = llvmType(cv->type);
+        return ctx->builder->CreateLoad(llTy, cv->llValue);
     }
 
     static void checkIntegerValue(MultiCValuePtr args,
@@ -222,7 +225,8 @@ namespace clay {
                                      CodegenContext *ctx) {
         checkIntegerValue(args, index, type, ctx);
         CValuePtr cv = args->values[index];
-        return ctx->builder->CreateLoad(cv->llValue);
+        llvm::Type *llTy = llvmType(cv->type);
+        return ctx->builder->CreateLoad(llTy, cv->llValue);
     }
 
     static llvm::Value *pointerValue(MultiCValuePtr args,
@@ -239,7 +243,8 @@ namespace clay {
             type = (PointerType *) cv->type.ptr();
             llvmType(type->pointeeType); // force the pointee type to be refined
         }
-        return ctx->builder->CreateLoad(cv->llValue);
+        llvm::Type *llTy = llvmType(cv->type);
+        return ctx->builder->CreateLoad(llTy, cv->llValue);
     }
 
     static llvm::Value *pointerLikeValue(MultiCValuePtr args,
@@ -257,7 +262,8 @@ namespace clay {
                                   cv->type);
             type = cv->type;
         }
-        return ctx->builder->CreateLoad(cv->llValue);
+        llvm::Type *llTy = llvmType(cv->type);
+        return ctx->builder->CreateLoad(llTy, cv->llValue);
     }
 
     static llvm::Value *cCodePointerValue(MultiCValuePtr args,
@@ -333,7 +339,8 @@ namespace clay {
                 argumentTypeError(index, "enum type", cv->type);
             type = (EnumType *) cv->type.ptr();
         }
-        return ctx->builder->CreateLoad(cv->llValue);
+        llvm::Type *llTy = llvmType(cv->type);
+        return ctx->builder->CreateLoad(llTy, cv->llValue);
     }
 
     llvm::AtomicOrdering atomicOrderValue(MultiCValuePtr args, unsigned index) {

From fe660143a3ce8a107b6dbfb1b361b11c61dfbcbd Mon Sep 17 00:00:00 2001
From: Ramon Asuncion <asuncionbatista@gmail.com>
Date: Sun, 14 Dec 2025 08:41:14 -0500
Subject: [PATCH 54/56] Use new AtomicOrdering states

---
 compiler/codegen_op.cpp | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/compiler/codegen_op.cpp b/compiler/codegen_op.cpp
index ebbdbaec..dbd5a8c3 100644
--- a/compiler/codegen_op.cpp
+++ b/compiler/codegen_op.cpp
@@ -350,21 +350,21 @@ namespace clay {
             PrimOp *prim = (PrimOp *) obj.ptr();
             switch (prim->primOpCode) {
                 case PRIM_OrderUnordered:
-                    return llvm::Unordered;
+                    return llvm::AtomicOrdering::Unordered;
                 case PRIM_OrderMonotonic:
-                    return llvm::Monotonic;
+                    return llvm::AtomicOrdering::Monotonic;
                 case PRIM_OrderAcquire:
-                    return llvm::Acquire;
+                    return llvm::AtomicOrdering::Acquire;
                 case PRIM_OrderRelease:
-                    return llvm::Release;
+                    return llvm::AtomicOrdering::Release;
                 case PRIM_OrderAcqRel:
-                    return llvm::AcquireRelease;
+                    return llvm::AtomicOrdering::AcquireRelease;
                 case PRIM_OrderSeqCst:
-                    return llvm::SequentiallyConsistent;
+                    return llvm::AtomicOrdering::SequentiallyConsistent;
             }
         }
         argumentTypeError(index, "atomic ordering", cv->type);
-        return llvm::Unordered;
+        return llvm::AtomicOrdering::Unordered;
     }
 
     llvm::AtomicRMWInst::BinOp atomicRMWOpValue(MultiCValuePtr args, unsigned index) {

From cc2e8978858881e9060165812012ef1151742a24 Mon Sep 17 00:00:00 2001
From: Ramon Asuncion <asuncionbatista@gmail.com>
Date: Sun, 14 Dec 2025 08:42:56 -0500
Subject: [PATCH 55/56] Use DW_TAG_variable tag instead of old
 DW_TAG_arg_variable and DW_TAG_auto_variable

---
 compiler/codegen.cpp | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/compiler/codegen.cpp b/compiler/codegen.cpp
index c6ec722c..1cb89164 100644
--- a/compiler/codegen.cpp
+++ b/compiler/codegen.cpp
@@ -1603,7 +1603,7 @@ namespace clay {
                 Location argLocation = arg->location;
                 llvm::DIFile file = getDebugLineCol(argLocation, line, column);
                 llvm::DIVariable debugVar = llvmDIBuilder->createLocalVariable(
-                    llvm::dwarf::DW_TAG_arg_variable, // tag
+                    llvm::dwarf::DW_TAG_variable, // tag
                     x->getDebugInfo(), // scope
                     arg->name->str, // name
                     file, // file
@@ -2893,7 +2893,7 @@ namespace clay {
                 llvm::DIFile file = getDebugLineCol(argLocation, line, column);
                 llvm::DebugLoc debugLoc = llvm::DebugLoc::get(line, column, entry->getDebugInfo());
                 llvm::DIVariable debugVar = llvmDIBuilder->createLocalVariable(
-                    llvm::dwarf::DW_TAG_arg_variable, // tag
+                    llvm::dwarf::DW_TAG_variable, // tag
                     entry->getDebugInfo(), // scope
                     entry->fixedArgNames[i]->str, // name
                     file, // file
@@ -2935,7 +2935,7 @@ namespace clay {
                 if (llvmDIBuilder != nullptr) {
                     llvm::DebugLoc debugLoc = llvm::DebugLoc::get(line, column, entry->getDebugInfo());
                     llvm::DIVariable debugVar = llvmDIBuilder->createLocalVariable(
-                        llvm::dwarf::DW_TAG_arg_variable, // tag
+                        llvm::dwarf::DW_TAG_variable, // tag
                         entry->getDebugInfo(), // scope
                         sout.str(), // name
                         file, // file
@@ -2969,7 +2969,7 @@ namespace clay {
                     llvm::DIFile file = getDebugLineCol(argLocation, line, column);
                     llvm::DebugLoc debugLoc = llvm::DebugLoc::get(line, column, entry->getDebugInfo());
                     llvm::DIVariable debugVar = llvmDIBuilder->createLocalVariable(
-                        llvm::dwarf::DW_TAG_arg_variable, // tag
+                        llvm::dwarf::DW_TAG_variable, // tag
                         entry->getDebugInfo(), // scope
                         entry->fixedArgNames[i]->str, // name
                         file, // file
@@ -3995,7 +3995,7 @@ namespace clay {
                     if (llvmDIBuilder != nullptr) {
                         llvm::DILexicalBlock debugBlock = ctx->getDebugScope();
                         llvm::DIVariable debugVar = llvmDIBuilder->createLocalVariable(
-                            llvm::dwarf::DW_TAG_auto_variable, // tag
+                            llvm::dwarf::DW_TAG_variable, // tag
                             debugBlock, // scope
                             getBindingVariableName(x, i), // name
                             file, // file
@@ -4062,7 +4062,7 @@ namespace clay {
                     if (llvmDIBuilder != nullptr) {
                         llvm::DILexicalBlock debugBlock = ctx->getDebugScope();
                         llvm::DIVariable debugVar = llvmDIBuilder->createLocalVariable(
-                            llvm::dwarf::DW_TAG_auto_variable, // tag
+                            llvm::dwarf::DW_TAG_variable, // tag
                             debugBlock, // scope
                             getBindingVariableName(x, i), // name
                             file, // file
@@ -4133,7 +4133,7 @@ namespace clay {
                         llvm::DILexicalBlock debugBlock = ctx->getDebugScope();
                         llvm::DIType debugType = llvmTypeDebugInfo(pv.type);
                         llvm::DIVariable debugVar = llvmDIBuilder->createLocalVariable(
-                            llvm::dwarf::DW_TAG_auto_variable, // tag
+                            llvm::dwarf::DW_TAG_variable, // tag
                             debugBlock, // scope
                             getBindingVariableName(x, i), // name
                             file, // file

From 69ae16ce62b7fe7122e5b330afa143fd51b59c8c Mon Sep 17 00:00:00 2001
From: Ramon Asuncion <asuncionbatista@gmail.com>
Date: Fri, 8 May 2026 21:23:58 -0400
Subject: [PATCH 56/56] Fix DI type API, BumpPtrAllocator, and reformat
 codebase

---
 .clang-format              |    3 +
 .gitignore                 |    4 +-
 CMakeLists.txt             |    7 +-
 compiler/analyzer.cpp      | 4562 ++++++++++-----------
 compiler/analyzer.hpp      |  232 +-
 compiler/analyzer_op.cpp   | 1881 +++++----
 compiler/analyzer_op.hpp   |    2 +-
 compiler/checkedcast.hpp   |   11 +-
 compiler/clay.cpp          | 1766 ++++----
 compiler/clay.hpp          | 4620 ++++++++++-----------
 compiler/claydoc.cpp       |   96 +-
 compiler/claydoc.hpp       |    4 +-
 compiler/clone.cpp         |  916 +++--
 compiler/clone.hpp         |   36 +-
 compiler/codegen.cpp       | 7828 +++++++++++++++++-------------------
 compiler/codegen.hpp       |  432 +-
 compiler/codegen_op.cpp    | 4199 ++++++++++---------
 compiler/codegen_op.hpp    |    6 +-
 compiler/constructors.cpp  |  228 +-
 compiler/constructors.hpp  |   10 +-
 compiler/desugar.cpp       |  894 ++--
 compiler/desugar.hpp       |   32 +-
 compiler/env.cpp           |  823 ++--
 compiler/env.hpp           |   35 +-
 compiler/error.cpp         |  806 ++--
 compiler/error.hpp         |  221 +-
 compiler/evaluator.cpp     | 4128 ++++++++++---------
 compiler/evaluator.hpp     |  183 +-
 compiler/evaluator_op.cpp  | 4314 ++++++++++----------
 compiler/evaluator_op.hpp  |    2 +-
 compiler/externals.cpp     | 2071 +++++-----
 compiler/externals.hpp     |  214 +-
 compiler/hirestimer.cpp    |  123 +-
 compiler/hirestimer.hpp    |   22 +-
 compiler/html.cpp          |  119 +-
 compiler/int128.hpp        |  252 +-
 compiler/interactive.cpp   |  541 +--
 compiler/invoketables.cpp  |  705 ++--
 compiler/invoketables.hpp  |  254 +-
 compiler/lambdas.cpp       | 1236 +++---
 compiler/lambdas.hpp       |    2 +-
 compiler/lexer.cpp         | 1644 ++++----
 compiler/lexer.hpp         |   96 +-
 compiler/literals.cpp      |  658 +--
 compiler/literals.hpp      |    6 +-
 compiler/loader.cpp        | 2631 ++++++------
 compiler/loader.hpp        |  475 +--
 compiler/matchinvoke.cpp   |  418 +-
 compiler/matchinvoke.hpp   |  255 +-
 compiler/objects.cpp       |  230 +-
 compiler/objects.hpp       |   97 +-
 compiler/operators.hpp     |  298 +-
 compiler/parachute.cpp     |  106 +-
 compiler/parachute.hpp     |    4 +-
 compiler/parser.cpp        | 6100 +++++++++++++++-------------
 compiler/parser.hpp        |   44 +-
 compiler/patterns.cpp      | 1291 +++---
 compiler/patterns.hpp      |   42 +-
 compiler/printer.cpp       | 2434 +++++------
 compiler/printer.hpp       |   81 +-
 compiler/profiler.cpp      |   48 +-
 compiler/profiler.hpp      |    6 +-
 compiler/refcounted.hpp    |  108 +-
 compiler/refcounted_ut.cpp |   14 +-
 compiler/types.cpp         | 3026 +++++++-------
 compiler/types.hpp         |  179 +-
 compiler/ut.hpp            |   49 +-
 compiler/ut_main.cpp       |   46 +-
 68 files changed, 32157 insertions(+), 32049 deletions(-)
 create mode 100644 .clang-format

diff --git a/.clang-format b/.clang-format
new file mode 100644
index 00000000..e6e2c5bf
--- /dev/null
+++ b/.clang-format
@@ -0,0 +1,3 @@
+BasedOnStyle: LLVM
+IndentWidth: 4
+TabWidth: 4
diff --git a/.gitignore b/.gitignore
index a9316691..89e59f99 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,7 +1,9 @@
 .DS_Store
 Thumbs.db
 *.pdb
-.vscode/
+.vscode/*.code-workspace
+.cache/
+compile_commands.json
 *.swp
 *.swo
 *.idea/
diff --git a/CMakeLists.txt b/CMakeLists.txt
index eb6cecba..e94311b8 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -45,7 +45,6 @@ if(UNIX)
         OUTPUT_VARIABLE LLVM_CXXFLAGS
         OUTPUT_STRIP_TRAILING_WHITESPACE
     )
-    set(LLVM_CXXFLAGS ${LLVM_CXXFLAGS})
     separate_arguments(LLVM_CXXFLAGS)
 
     if(CMAKE_BUILD_TYPE STREQUAL "Debug")
@@ -83,7 +82,6 @@ if(UNIX)
         OUTPUT_VARIABLE LLVM_INCLUDEDIR
         OUTPUT_STRIP_TRAILING_WHITESPACE
     )
-    set(LLVM_INCLUDEDIR ${LLVM_INCLUDEDIR})
 
     message("-- Using LLVM: ${LLVM_DIR}")
     message("-- LLVM include dir: ${LLVM_INCLUDEDIR}")
@@ -94,6 +92,7 @@ if(UNIX)
 
 elseif(WIN32)
 
+    # TODO: unverified, port to find_package(LLVM CONFIG) + llvm_map_components_to_libnames.
     set(LLVM_DIR "$ENV{ProgramFiles}/LLVM" CACHE PATH "llvm install path")
 
     if(IS_DIRECTORY ${LLVM_DIR})
@@ -119,10 +118,6 @@ elseif(WIN32)
 
 endif()
 
-set(BUILD_BINDGEN True CACHE BOOL
-    "Build the clay-bindgen tool for generating Clay bindings from C header files."
-)
-
 install(DIRECTORY doc/        DESTINATION share/doc/clay)
 install(DIRECTORY examples/   DESTINATION share/doc/clay/examples)
 install(DIRECTORY lib-clay    DESTINATION lib)
diff --git a/compiler/analyzer.cpp b/compiler/analyzer.cpp
index 631f9bbf..1c5087c2 100644
--- a/compiler/analyzer.cpp
+++ b/compiler/analyzer.cpp
@@ -1,2630 +1,2656 @@
+#include "analyzer.hpp"
+#include "analyzer_op.hpp"
 #include "clay.hpp"
-#include "evaluator.hpp"
+#include "clone.hpp"
 #include "codegen.hpp"
-#include "loader.hpp"
-#include "operators.hpp"
-#include "patterns.hpp"
-#include "lambdas.hpp"
-#include "analyzer.hpp"
-#include "invoketables.hpp"
-#include "matchinvoke.hpp"
-#include "error.hpp"
-#include "literals.hpp"
-#include "desugar.hpp"
 #include "constructors.hpp"
+#include "desugar.hpp"
 #include "env.hpp"
-#include "clone.hpp"
+#include "error.hpp"
+#include "evaluator.hpp"
+#include "invoketables.hpp"
+#include "lambdas.hpp"
+#include "literals.hpp"
+#include "loader.hpp"
+#include "matchinvoke.hpp"
 #include "objects.hpp"
-#include "analyzer_op.hpp"
+#include "operators.hpp"
+#include "patterns.hpp"
 
 #pragma clang diagnostic ignored "-Wcovered-switch-default"
 
 namespace clay {
-    GVarInstance::GVarInstance(const GlobalVariablePtr &gvar,
-                               llvm::ArrayRef<ObjectPtr> params)
-        : gvar(gvar), params(params),
-          llGlobal(nullptr), debugInfo(nullptr), analyzing(false) {
-    }
-
-    GVarInstance::~GVarInstance() = default;
+GVarInstance::GVarInstance(const GlobalVariablePtr &gvar,
+                           llvm::ArrayRef<ObjectPtr> params)
+    : gvar(gvar), params(params), llGlobal(nullptr), debugInfo(nullptr),
+      analyzing(false) {}
 
-    Procedure::Procedure(Module *module, IdentifierPtr name, Visibility visibility, bool privateOverload)
-        : TopLevelItem(PROCEDURE, module, name, visibility),
-          privateOverload(privateOverload) {
-    }
-
-    Procedure::Procedure(Module *module, IdentifierPtr name, Visibility visibility, bool privateOverload,
-                         OverloadPtr interface)
-        : TopLevelItem(PROCEDURE, module, name, visibility),
-          interface(interface), privateOverload(privateOverload) {
-    }
+GVarInstance::~GVarInstance() = default;
 
-    Procedure::~Procedure() {
-    }
+Procedure::Procedure(Module *module, IdentifierPtr name, Visibility visibility,
+                     bool privateOverload)
+    : TopLevelItem(PROCEDURE, module, name, visibility),
+      privateOverload(privateOverload) {}
 
-    GlobalVariable::GlobalVariable(Module *module, IdentifierPtr name,
-                                   Visibility visibility,
-                                   llvm::ArrayRef<PatternVar> patternVars,
-                                   ExprPtr predicate,
-                                   llvm::ArrayRef<IdentifierPtr> params,
-                                   IdentifierPtr varParam,
-                                   ExprPtr expr)
-        : TopLevelItem(GLOBAL_VARIABLE, module, name, visibility),
-          patternVars(patternVars), predicate(predicate),
-          params(params), varParam(varParam), expr(expr) {
-    }
+Procedure::Procedure(Module *module, IdentifierPtr name, Visibility visibility,
+                     bool privateOverload, OverloadPtr interface)
+    : TopLevelItem(PROCEDURE, module, name, visibility), interface(interface),
+      privateOverload(privateOverload) {}
 
-    GlobalVariable::~GlobalVariable() = default;
+Procedure::~Procedure() {}
 
-    static StatementAnalysis analyzeStatement(StatementPtr stmt, EnvPtr env, AnalysisContext *ctx);
+GlobalVariable::GlobalVariable(Module *module, IdentifierPtr name,
+                               Visibility visibility,
+                               llvm::ArrayRef<PatternVar> patternVars,
+                               ExprPtr predicate,
+                               llvm::ArrayRef<IdentifierPtr> params,
+                               IdentifierPtr varParam, ExprPtr expr)
+    : TopLevelItem(GLOBAL_VARIABLE, module, name, visibility),
+      patternVars(patternVars), predicate(predicate), params(params),
+      varParam(varParam), expr(expr) {}
 
-    static EnvPtr analyzeBinding(BindingPtr x, EnvPtr env);
+GlobalVariable::~GlobalVariable() = default;
 
-    static int analysisCachingDisabled = 0;
-    void disableAnalysisCaching() { analysisCachingDisabled += 1; }
-    void enableAnalysisCaching() { analysisCachingDisabled -= 1; }
+static StatementAnalysis analyzeStatement(StatementPtr stmt, EnvPtr env,
+                                          AnalysisContext *ctx);
 
-    static TypePtr objectType(ObjectPtr x);
+static EnvPtr analyzeBinding(BindingPtr x, EnvPtr env);
 
-    static bool staticToTypeTuple(ObjectPtr x, vector<TypePtr> &out);
+static int analysisCachingDisabled = 0;
+void disableAnalysisCaching() { analysisCachingDisabled += 1; }
+void enableAnalysisCaching() { analysisCachingDisabled -= 1; }
 
-    static void staticToTypeTuple(MultiStaticPtr x, unsigned index,
-                                  vector<TypePtr> &out);
+static TypePtr objectType(ObjectPtr x);
 
-    static int staticToInt(MultiStaticPtr x, unsigned index);
+static bool staticToTypeTuple(ObjectPtr x, vector<TypePtr> &out);
 
-    //
-    // utility procs
-    //
+static void staticToTypeTuple(MultiStaticPtr x, unsigned index,
+                              vector<TypePtr> &out);
 
-    static TypePtr objectType(ObjectPtr x) {
-        switch (x->objKind) {
-            case VALUE_HOLDER: {
-                ValueHolder *y = (ValueHolder *) x.ptr();
-                return y->type;
-            }
+static int staticToInt(MultiStaticPtr x, unsigned index);
 
-            case TYPE:
-            case PRIM_OP:
-            case PROCEDURE:
-            case INTRINSIC:
-            case GLOBAL_ALIAS:
-            case RECORD_DECL:
-            case VARIANT_DECL:
-            case MODULE:
-            case IDENTIFIER:
-                return staticType(x);
+//
+// utility procs
+//
 
-            default:
-                error("untypeable object");
-                return nullptr;
-        }
+static TypePtr objectType(ObjectPtr x) {
+    switch (x->objKind) {
+    case VALUE_HOLDER: {
+        ValueHolder *y = (ValueHolder *)x.ptr();
+        return y->type;
     }
 
-    ObjectPtr unwrapStaticType(TypePtr t) {
-        if (t->typeKind != STATIC_TYPE)
-            return nullptr;
-        StaticType *st = (StaticType *) t.ptr();
-        return st->obj;
-    }
+    case TYPE:
+    case PRIM_OP:
+    case PROCEDURE:
+    case INTRINSIC:
+    case GLOBAL_ALIAS:
+    case RECORD_DECL:
+    case VARIANT_DECL:
+    case MODULE:
+    case IDENTIFIER:
+        return staticType(x);
 
-    static bool staticToTypeTuple(ObjectPtr x, vector<TypePtr> &out) {
-        TypePtr t;
-        if (staticToType(x, t)) {
-            out.push_back(t);
-            return true;
-        }
-        if (x->objKind != VALUE_HOLDER)
-            return false;
-        ValueHolderPtr y = (ValueHolder *) x.ptr();
-        assert(y->type->typeKind != STATIC_TYPE);
-        if (y->type->typeKind != TUPLE_TYPE)
-            return false;
-        TupleTypePtr z = static_cast<TupleType *>(y->type.ptr());
-        for (const auto &elementType: z->elementTypes) {
-            ObjectPtr obj = unwrapStaticType(elementType);
-            if ((!obj) || (obj->objKind != TYPE))
-                return false;
-            out.push_back(static_cast<Type *>(obj.ptr()));
-        }
-        return true;
+    default:
+        error("untypeable object");
+        return nullptr;
     }
+}
 
-    static void staticToTypeTuple(MultiStaticPtr x, const unsigned index,
-                                  vector<TypePtr> &out) {
-        if (!staticToTypeTuple(x->values[index], out))
-            argumentError(index, "expecting zero-or-more types");
-    }
+ObjectPtr unwrapStaticType(TypePtr t) {
+    if (t->typeKind != STATIC_TYPE)
+        return nullptr;
+    StaticType *st = (StaticType *)t.ptr();
+    return st->obj;
+}
 
-    static bool staticToInt(ObjectPtr x, int &out, TypePtr &type) {
-        if (x->objKind != VALUE_HOLDER)
-            return false;
-        ValueHolderPtr vh = static_cast<ValueHolder *>(x.ptr());
-        if (vh->type != cIntType) {
-            type = vh->type;
-            return false;
-        }
-        out = vh->as<int>();
+static bool staticToTypeTuple(ObjectPtr x, vector<TypePtr> &out) {
+    TypePtr t;
+    if (staticToType(x, t)) {
+        out.push_back(t);
         return true;
     }
-
-    static int staticToInt(MultiStaticPtr x, unsigned index) {
-        int out = -1;
-        TypePtr type;
-        if (!staticToInt(x->values[index], out, type)) {
-            argumentTypeError(index, "Int", type);
-        }
-        return out;
-    }
-
-    bool staticToBool(ObjectPtr x, bool &out, TypePtr &type) {
-        if (x->objKind != VALUE_HOLDER)
-            return false;
-        ValueHolderPtr vh = (ValueHolder *) x.ptr();
-        if (vh->type != boolType) {
-            type = vh->type;
+    if (x->objKind != VALUE_HOLDER)
+        return false;
+    ValueHolderPtr y = (ValueHolder *)x.ptr();
+    assert(y->type->typeKind != STATIC_TYPE);
+    if (y->type->typeKind != TUPLE_TYPE)
+        return false;
+    TupleTypePtr z = static_cast<TupleType *>(y->type.ptr());
+    for (const auto &elementType : z->elementTypes) {
+        ObjectPtr obj = unwrapStaticType(elementType);
+        if ((!obj) || (obj->objKind != TYPE))
             return false;
-        }
-        out = vh->as<bool>();
-        return true;
+        out.push_back(static_cast<Type *>(obj.ptr()));
     }
+    return true;
+}
 
-    bool staticToBool(MultiStaticPtr x, unsigned index) {
-        bool out = false;
-        TypePtr type;
-        if (!staticToBool(x->values[index], out, type))
-            argumentTypeError(index, "Bool", type);
-        return out;
-    }
+static void staticToTypeTuple(MultiStaticPtr x, const unsigned index,
+                              vector<TypePtr> &out) {
+    if (!staticToTypeTuple(x->values[index], out))
+        argumentError(index, "expecting zero-or-more types");
+}
 
-    bool staticToCallingConv(ObjectPtr x, CallingConv &out) {
-        if (x->objKind != PRIM_OP)
-            return false;
-        PrimOp *ccPrim = (PrimOp *) x.ptr();
-        switch (ccPrim->primOpCode) {
-            case PRIM_AttributeCCall:
-                out = CC_DEFAULT;
-                return true;
-            case PRIM_AttributeStdCall:
-                out = CC_STDCALL;
-                return true;
-            case PRIM_AttributeFastCall:
-                out = CC_FASTCALL;
-                return true;
-            case PRIM_AttributeThisCall:
-                out = CC_THISCALL;
-                return true;
-            case PRIM_AttributeLLVMCall:
-                out = CC_LLVM;
-                return true;
-            default:
-                return false;
-        }
+static bool staticToInt(ObjectPtr x, int &out, TypePtr &type) {
+    if (x->objKind != VALUE_HOLDER)
+        return false;
+    ValueHolderPtr vh = static_cast<ValueHolder *>(x.ptr());
+    if (vh->type != cIntType) {
+        type = vh->type;
+        return false;
     }
+    out = vh->as<int>();
+    return true;
+}
 
-    CallingConv staticToCallingConv(MultiStaticPtr x, unsigned index) {
-        CallingConv out;
-        if (!staticToCallingConv(x->values[index], out))
-            argumentError(index, "expecting calling convention attribute");
-        return out;
+static int staticToInt(MultiStaticPtr x, unsigned index) {
+    int out = -1;
+    TypePtr type;
+    if (!staticToInt(x->values[index], out, type)) {
+        argumentTypeError(index, "Int", type);
     }
+    return out;
+}
 
-    //
-    // safe analysis
-    //
+bool staticToBool(ObjectPtr x, bool &out, TypePtr &type) {
+    if (x->objKind != VALUE_HOLDER)
+        return false;
+    ValueHolderPtr vh = (ValueHolder *)x.ptr();
+    if (vh->type != boolType) {
+        type = vh->type;
+        return false;
+    }
+    out = vh->as<bool>();
+    return true;
+}
 
-    static Location analysisErrorLocation;
-    static vector<CompileContextEntry> analysisErrorCompileContext;
+bool staticToBool(MultiStaticPtr x, unsigned index) {
+    bool out = false;
+    TypePtr type;
+    if (!staticToBool(x->values[index], out, type))
+        argumentTypeError(index, "Bool", type);
+    return out;
+}
 
-    struct ClearAnalysisError {
-        ClearAnalysisError() = default;
+bool staticToCallingConv(ObjectPtr x, CallingConv &out) {
+    if (x->objKind != PRIM_OP)
+        return false;
+    PrimOp *ccPrim = (PrimOp *)x.ptr();
+    switch (ccPrim->primOpCode) {
+    case PRIM_AttributeCCall:
+        out = CC_DEFAULT;
+        return true;
+    case PRIM_AttributeStdCall:
+        out = CC_STDCALL;
+        return true;
+    case PRIM_AttributeFastCall:
+        out = CC_FASTCALL;
+        return true;
+    case PRIM_AttributeThisCall:
+        out = CC_THISCALL;
+        return true;
+    case PRIM_AttributeLLVMCall:
+        out = CC_LLVM;
+        return true;
+    default:
+        return false;
+    }
+}
 
-        ~ClearAnalysisError() {
-            analysisErrorLocation = Location();
-            analysisErrorCompileContext.clear();
-        }
-    };
+CallingConv staticToCallingConv(MultiStaticPtr x, unsigned index) {
+    CallingConv out;
+    if (!staticToCallingConv(x->values[index], out))
+        argumentError(index, "expecting calling convention attribute");
+    return out;
+}
 
-    static void updateAnalysisErrorLocation() {
-        analysisErrorLocation = topLocation();
-        analysisErrorCompileContext = getCompileContext();
-    }
+//
+// safe analysis
+//
 
-    static void analysisError() {
-        setCompileContext(analysisErrorCompileContext);
-        LocationContext loc(analysisErrorLocation);
-        error("type propagation failed due to recursion without base case");
-    }
+static Location analysisErrorLocation;
+static vector<CompileContextEntry> analysisErrorCompileContext;
 
-    PVData safeAnalyzeOne(ExprPtr expr, EnvPtr env) {
-        ClearAnalysisError clear;
-        PVData result = analyzeOne(expr, env);
-        if (!result.ok())
-            analysisError();
-        return result;
-    }
+struct ClearAnalysisError {
+    ClearAnalysisError() = default;
 
-    MultiPValuePtr safeAnalyzeMulti(ExprListPtr exprs, EnvPtr env, size_t wantCount) {
-        ClearAnalysisError clear;
-        MultiPValuePtr result = analyzeMulti(exprs, env, wantCount);
-        if (!result)
-            analysisError();
-        return result;
+    ~ClearAnalysisError() {
+        analysisErrorLocation = Location();
+        analysisErrorCompileContext.clear();
     }
+};
 
-    MultiPValuePtr safeAnalyzeExpr(ExprPtr expr, EnvPtr env) {
-        ClearAnalysisError clear;
-        MultiPValuePtr result = analyzeExpr(expr, env);
-        if (!result)
-            analysisError();
-        return result;
-    }
+static void updateAnalysisErrorLocation() {
+    analysisErrorLocation = topLocation();
+    analysisErrorCompileContext = getCompileContext();
+}
 
-    MultiPValuePtr safeAnalyzeIndexingExpr(ExprPtr indexable,
-                                           ExprListPtr args,
-                                           EnvPtr env) {
-        ClearAnalysisError clear;
-        MultiPValuePtr result = analyzeIndexingExpr(indexable, args, env);
-        if (!result)
-            analysisError();
-        return result;
-    }
+static void analysisError() {
+    setCompileContext(analysisErrorCompileContext);
+    LocationContext loc(analysisErrorLocation);
+    error("type propagation failed due to recursion without base case");
+}
 
-    MultiPValuePtr safeAnalyzeMultiArgs(ExprListPtr exprs,
-                                        EnvPtr env,
-                                        vector<unsigned> &dispatchIndices) {
-        ClearAnalysisError clear;
-        MultiPValuePtr result = analyzeMultiArgs(exprs, env, dispatchIndices);
-        if (!result)
-            analysisError();
-        return result;
-    }
-
-    InvokeEntry *safeAnalyzeCallable(ObjectPtr x,
-                                     llvm::ArrayRef<PVData> args) {
-        ClearAnalysisError clear;
-        InvokeEntry *entry = analyzeCallable(x, args);
-        if (!entry->callByName && !entry->analyzed)
-            analysisError();
-        return entry;
-    }
+PVData safeAnalyzeOne(ExprPtr expr, EnvPtr env) {
+    ClearAnalysisError clear;
+    PVData result = analyzeOne(expr, env);
+    if (!result.ok())
+        analysisError();
+    return result;
+}
 
-    MultiPValuePtr safeAnalyzeCallByName(InvokeEntry *entry,
-                                         ExprPtr callable,
-                                         ExprListPtr args,
-                                         EnvPtr env) {
-        ClearAnalysisError clear;
-        MultiPValuePtr result = analyzeCallByName(entry, callable, args, env);
-        if (!entry)
-            analysisError();
-        return result;
-    }
+MultiPValuePtr safeAnalyzeMulti(ExprListPtr exprs, EnvPtr env,
+                                size_t wantCount) {
+    ClearAnalysisError clear;
+    MultiPValuePtr result = analyzeMulti(exprs, env, wantCount);
+    if (!result)
+        analysisError();
+    return result;
+}
 
-    MultiPValuePtr safeAnalyzeGVarInstance(GVarInstancePtr x) {
-        ClearAnalysisError clear;
-        MultiPValuePtr result = analyzeGVarInstance(x);
-        if (!result)
-            analysisError();
-        return result;
-    }
+MultiPValuePtr safeAnalyzeExpr(ExprPtr expr, EnvPtr env) {
+    ClearAnalysisError clear;
+    MultiPValuePtr result = analyzeExpr(expr, env);
+    if (!result)
+        analysisError();
+    return result;
+}
 
-    //
-    // analyzeMulti
-    //
+MultiPValuePtr safeAnalyzeIndexingExpr(ExprPtr indexable, ExprListPtr args,
+                                       EnvPtr env) {
+    ClearAnalysisError clear;
+    MultiPValuePtr result = analyzeIndexingExpr(indexable, args, env);
+    if (!result)
+        analysisError();
+    return result;
+}
 
-    static MultiPValuePtr analyzeMulti2(ExprListPtr exprs, EnvPtr env, size_t wantCount);
+MultiPValuePtr safeAnalyzeMultiArgs(ExprListPtr exprs, EnvPtr env,
+                                    vector<unsigned> &dispatchIndices) {
+    ClearAnalysisError clear;
+    MultiPValuePtr result = analyzeMultiArgs(exprs, env, dispatchIndices);
+    if (!result)
+        analysisError();
+    return result;
+}
 
-    MultiPValuePtr analyzeMulti(ExprListPtr exprs, EnvPtr env, size_t wantCount) {
-        if (analysisCachingDisabled > 0)
-            return analyzeMulti2(exprs, env, wantCount);
-        if (!exprs->cachedAnalysis)
-            exprs->cachedAnalysis = analyzeMulti2(exprs, env, wantCount);
-        return exprs->cachedAnalysis;
-    }
+InvokeEntry *safeAnalyzeCallable(ObjectPtr x, llvm::ArrayRef<PVData> args) {
+    ClearAnalysisError clear;
+    InvokeEntry *entry = analyzeCallable(x, args);
+    if (!entry->callByName && !entry->analyzed)
+        analysisError();
+    return entry;
+}
 
-    static MultiPValuePtr analyzeMulti2(ExprListPtr exprs, EnvPtr env, size_t wantCount) {
-        MultiPValuePtr out = new MultiPValue();
-        ExprPtr unpackExpr = implicitUnpackExpr(wantCount, exprs);
-        if (unpackExpr != nullptr) {
-            MultiPValuePtr z = analyzeExpr(unpackExpr, env);
-            if (!z)
-                return nullptr;
-            out->add(z);
-        } else
-            for (unsigned i = 0; i < exprs->size(); ++i) {
-                ExprPtr x = exprs->exprs[i];
-                if (x->exprKind == UNPACK) {
-                    Unpack *y = (Unpack *) x.ptr();
-                    MultiPValuePtr z = analyzeExpr(y->expr, env);
-                    if (!z)
-                        return nullptr;
-                    out->add(z);
-                } else if (x->exprKind == PAREN) {
-                    MultiPValuePtr y = analyzeExpr(x, env);
-                    if (!y)
-                        return nullptr;
-                    out->add(y);
-                } else {
-                    PVData y = analyzeOne(x, env);
-                    if (!y.ok())
-                        return nullptr;
-                    out->add(y);
-                }
-            }
-        return out;
-    }
+MultiPValuePtr safeAnalyzeCallByName(InvokeEntry *entry, ExprPtr callable,
+                                     ExprListPtr args, EnvPtr env) {
+    ClearAnalysisError clear;
+    MultiPValuePtr result = analyzeCallByName(entry, callable, args, env);
+    if (!entry)
+        analysisError();
+    return result;
+}
 
-    //
-    // analyzeOne
-    //
+MultiPValuePtr safeAnalyzeGVarInstance(GVarInstancePtr x) {
+    ClearAnalysisError clear;
+    MultiPValuePtr result = analyzeGVarInstance(x);
+    if (!result)
+        analysisError();
+    return result;
+}
 
-    PVData analyzeOne(ExprPtr expr, EnvPtr env) {
-        MultiPValuePtr x = analyzeExpr(expr, env);
-        if (!x)
-            return PVData();
-        LocationContext loc(expr->location);
-        ensureArity(x, 1);
-        return x->values[0];
-    }
+//
+// analyzeMulti
+//
 
-    //
-    // analyzeMultiArgs, analyzeOneArg, analyzeArgExpr
-    //
+static MultiPValuePtr analyzeMulti2(ExprListPtr exprs, EnvPtr env,
+                                    size_t wantCount);
 
-    static MultiPValuePtr analyzeMultiArgs2(ExprListPtr exprs,
-                                            EnvPtr env,
-                                            unsigned startIndex,
-                                            vector<unsigned> &dispatchIndices);
+MultiPValuePtr analyzeMulti(ExprListPtr exprs, EnvPtr env, size_t wantCount) {
+    if (analysisCachingDisabled > 0)
+        return analyzeMulti2(exprs, env, wantCount);
+    if (!exprs->cachedAnalysis)
+        exprs->cachedAnalysis = analyzeMulti2(exprs, env, wantCount);
+    return exprs->cachedAnalysis;
+}
 
-    MultiPValuePtr analyzeMultiArgs(ExprListPtr exprs,
-                                    EnvPtr env,
-                                    vector<unsigned> &dispatchIndices) {
-        if (analysisCachingDisabled > 0)
-            return analyzeMultiArgs2(exprs, env, 0, dispatchIndices);
-        if (!exprs->cachedAnalysis) {
-            MultiPValuePtr mpv = analyzeMultiArgs2(exprs, env, 0, dispatchIndices);
-            if (mpv.ptr() && dispatchIndices.empty())
-                exprs->cachedAnalysis = mpv;
-            return mpv;
-        }
-        return exprs->cachedAnalysis;
-    }
-
-    static MultiPValuePtr analyzeMultiArgs2(ExprListPtr exprs,
-                                            EnvPtr env,
-                                            unsigned startIndex,
-                                            vector<unsigned> &dispatchIndices) {
-        MultiPValuePtr out = new MultiPValue();
-        unsigned index = startIndex;
+static MultiPValuePtr analyzeMulti2(ExprListPtr exprs, EnvPtr env,
+                                    size_t wantCount) {
+    MultiPValuePtr out = new MultiPValue();
+    ExprPtr unpackExpr = implicitUnpackExpr(wantCount, exprs);
+    if (unpackExpr != nullptr) {
+        MultiPValuePtr z = analyzeExpr(unpackExpr, env);
+        if (!z)
+            return nullptr;
+        out->add(z);
+    } else
         for (unsigned i = 0; i < exprs->size(); ++i) {
             ExprPtr x = exprs->exprs[i];
             if (x->exprKind == UNPACK) {
-                Unpack *y = (Unpack *) x.ptr();
-                MultiPValuePtr z = analyzeArgExpr(y->expr, env, index, dispatchIndices);
+                Unpack *y = (Unpack *)x.ptr();
+                MultiPValuePtr z = analyzeExpr(y->expr, env);
                 if (!z)
                     return nullptr;
-                index += unsigned(z->size());
                 out->add(z);
             } else if (x->exprKind == PAREN) {
-                MultiPValuePtr z = analyzeArgExpr(x, env, index, dispatchIndices);
-                if (!z)
+                MultiPValuePtr y = analyzeExpr(x, env);
+                if (!y)
                     return nullptr;
-                index += unsigned(z->size());
-                out->add(z);
+                out->add(y);
             } else {
-                PVData y = analyzeOneArg(x, env, index, dispatchIndices);
+                PVData y = analyzeOne(x, env);
                 if (!y.ok())
                     return nullptr;
                 out->add(y);
-                index += 1;
             }
         }
-        return out;
-    }
-
-    PVData analyzeOneArg(ExprPtr x,
-                         EnvPtr env,
-                         unsigned startIndex,
-                         vector<unsigned> &dispatchIndices) {
-        MultiPValuePtr mpv = analyzeArgExpr(x, env, startIndex, dispatchIndices);
-        if (!mpv)
-            return PVData();
-        LocationContext loc(x->location);
-        ensureArity(mpv, 1);
-        return mpv->values[0];
-    }
-
-    MultiPValuePtr analyzeArgExpr(ExprPtr x,
-                                  EnvPtr env,
-                                  unsigned startIndex,
-                                  vector<unsigned> &dispatchIndices) {
-        if (x->exprKind == DISPATCH_EXPR) {
-            DispatchExpr *y = (DispatchExpr *) x.ptr();
-            MultiPValuePtr mpv = analyzeExpr(y->expr, env);
-            if (!mpv)
-                return nullptr;
-            for (unsigned i = 0; i < mpv->size(); ++i)
-                dispatchIndices.push_back(i + startIndex);
-            return mpv;
-        }
-        return analyzeExpr(x, env);
-    }
-
-    //
-    // analyzeExpr
-    //
-
-    static MultiPValuePtr analyzeExpr2(ExprPtr expr, EnvPtr env);
-
-    void appendArgString(Expr *expr, string *outString) {
-        ForeignExpr *fexpr;
-        if (expr->exprKind == FOREIGN_EXPR)
-            fexpr = (ForeignExpr *) expr;
-        else if (expr->exprKind == UNPACK) {
-            Unpack *uexpr = (Unpack *) expr;
-            if (uexpr->expr->exprKind != FOREIGN_EXPR)
-                goto notAlias;
-            fexpr = (ForeignExpr *) uexpr->expr.ptr();
-            *outString += "..";
-        } else
-            goto notAlias;
+    return out;
+}
 
-        *outString += fexpr->expr->asString();
-        return;
+//
+// analyzeOne
+//
+
+PVData analyzeOne(ExprPtr expr, EnvPtr env) {
+    MultiPValuePtr x = analyzeExpr(expr, env);
+    if (!x)
+        return PVData();
+    LocationContext loc(expr->location);
+    ensureArity(x, 1);
+    return x->values[0];
+}
 
-    notAlias:
-        error("__ARG__ may only be applied to an alias value or alias function argument");
-    }
+//
+// analyzeMultiArgs, analyzeOneArg, analyzeArgExpr
+//
+
+static MultiPValuePtr analyzeMultiArgs2(ExprListPtr exprs, EnvPtr env,
+                                        unsigned startIndex,
+                                        vector<unsigned> &dispatchIndices);
+
+MultiPValuePtr analyzeMultiArgs(ExprListPtr exprs, EnvPtr env,
+                                vector<unsigned> &dispatchIndices) {
+    if (analysisCachingDisabled > 0)
+        return analyzeMultiArgs2(exprs, env, 0, dispatchIndices);
+    if (!exprs->cachedAnalysis) {
+        MultiPValuePtr mpv = analyzeMultiArgs2(exprs, env, 0, dispatchIndices);
+        if (mpv.ptr() && dispatchIndices.empty())
+            exprs->cachedAnalysis = mpv;
+        return mpv;
+    }
+    return exprs->cachedAnalysis;
+}
 
-    MultiPValuePtr analyzeExpr(ExprPtr expr, EnvPtr env) {
-        if (analysisCachingDisabled > 0)
-            return analyzeExpr2(expr, env);
-        if (!expr->cachedAnalysis)
-            expr->cachedAnalysis = analyzeExpr2(expr, env);
-        return expr->cachedAnalysis;
+static MultiPValuePtr analyzeMultiArgs2(ExprListPtr exprs, EnvPtr env,
+                                        unsigned startIndex,
+                                        vector<unsigned> &dispatchIndices) {
+    MultiPValuePtr out = new MultiPValue();
+    unsigned index = startIndex;
+    for (unsigned i = 0; i < exprs->size(); ++i) {
+        ExprPtr x = exprs->exprs[i];
+        if (x->exprKind == UNPACK) {
+            Unpack *y = (Unpack *)x.ptr();
+            MultiPValuePtr z =
+                analyzeArgExpr(y->expr, env, index, dispatchIndices);
+            if (!z)
+                return nullptr;
+            index += unsigned(z->size());
+            out->add(z);
+        } else if (x->exprKind == PAREN) {
+            MultiPValuePtr z = analyzeArgExpr(x, env, index, dispatchIndices);
+            if (!z)
+                return nullptr;
+            index += unsigned(z->size());
+            out->add(z);
+        } else {
+            PVData y = analyzeOneArg(x, env, index, dispatchIndices);
+            if (!y.ok())
+                return nullptr;
+            out->add(y);
+            index += 1;
+        }
     }
+    return out;
+}
 
-    static MultiPValuePtr analyzeExpr2(ExprPtr expr, EnvPtr env) {
-        LocationContext loc(expr->location);
-        switch (expr->exprKind) {
-            case BOOL_LITERAL: {
-                return new MultiPValue(PVData(boolType, true));
-            }
-
-            case INT_LITERAL: {
-                IntLiteral *x = (IntLiteral *) expr.ptr();
-                ValueHolderPtr v = parseIntLiteral(safeLookupModule(env), x);
-                return new MultiPValue(PVData(v->type, true));
-            }
+PVData analyzeOneArg(ExprPtr x, EnvPtr env, unsigned startIndex,
+                     vector<unsigned> &dispatchIndices) {
+    MultiPValuePtr mpv = analyzeArgExpr(x, env, startIndex, dispatchIndices);
+    if (!mpv)
+        return PVData();
+    LocationContext loc(x->location);
+    ensureArity(mpv, 1);
+    return mpv->values[0];
+}
 
-            case FLOAT_LITERAL: {
-                FloatLiteral *x = (FloatLiteral *) expr.ptr();
-                ValueHolderPtr v = parseFloatLiteral(safeLookupModule(env), x);
-                return new MultiPValue(PVData(v->type, true));
-            }
+MultiPValuePtr analyzeArgExpr(ExprPtr x, EnvPtr env, unsigned startIndex,
+                              vector<unsigned> &dispatchIndices) {
+    if (x->exprKind == DISPATCH_EXPR) {
+        DispatchExpr *y = (DispatchExpr *)x.ptr();
+        MultiPValuePtr mpv = analyzeExpr(y->expr, env);
+        if (!mpv)
+            return nullptr;
+        for (unsigned i = 0; i < mpv->size(); ++i)
+            dispatchIndices.push_back(i + startIndex);
+        return mpv;
+    }
+    return analyzeExpr(x, env);
+}
 
-            case CHAR_LITERAL: {
-                CharLiteral *x = (CharLiteral *) expr.ptr();
-                if (!x->desugared)
-                    x->desugared = desugarCharLiteral(x->value);
-                return analyzeExpr(x->desugared, env);
-            }
+//
+// analyzeExpr
+//
 
-            case STRING_LITERAL: {
-                StringLiteral *x = (StringLiteral *) expr.ptr();
-                return new MultiPValue(staticPValue(x->value.ptr()));
-            }
+static MultiPValuePtr analyzeExpr2(ExprPtr expr, EnvPtr env);
 
-            case NAME_REF: {
-                NameRef *x = (NameRef *) expr.ptr();
-                ObjectPtr y = safeLookupEnv(env, x->name);
-                if (y->objKind == EXPRESSION) {
-                    ExprPtr z = (Expr *) y.ptr();
-                    return analyzeExpr(z, env);
-                } else if (y->objKind == EXPR_LIST) {
-                    ExprListPtr z = (ExprList *) y.ptr();
-                    return analyzeMulti(z, env, 0);
-                }
-                return analyzeStaticObject(y);
-            }
+void appendArgString(Expr *expr, string *outString) {
+    ForeignExpr *fexpr;
+    if (expr->exprKind == FOREIGN_EXPR)
+        fexpr = (ForeignExpr *)expr;
+    else if (expr->exprKind == UNPACK) {
+        Unpack *uexpr = (Unpack *)expr;
+        if (uexpr->expr->exprKind != FOREIGN_EXPR)
+            goto notAlias;
+        fexpr = (ForeignExpr *)uexpr->expr.ptr();
+        *outString += "..";
+    } else
+        goto notAlias;
 
-            case FILE_EXPR: {
-                Location location = safeLookupCallByNameLocation(env);
-                string filename = location.source->fileName;
-                return analyzeStaticObject(Identifier::get(filename));
-            }
+    *outString += fexpr->expr->asString();
+    return;
 
-            case LINE_EXPR: {
-                return new MultiPValue(PVData(cSizeTType, true));
-            }
+notAlias:
+    error("__ARG__ may only be applied to an alias value or alias function "
+          "argument");
+}
 
-            case COLUMN_EXPR: {
-                return new MultiPValue(PVData(cSizeTType, true));
-            }
+MultiPValuePtr analyzeExpr(ExprPtr expr, EnvPtr env) {
+    if (analysisCachingDisabled > 0)
+        return analyzeExpr2(expr, env);
+    if (!expr->cachedAnalysis)
+        expr->cachedAnalysis = analyzeExpr2(expr, env);
+    return expr->cachedAnalysis;
+}
 
-            case ARG_EXPR: {
-                ARGExpr *arg = (ARGExpr *) expr.ptr();
-                ObjectPtr obj = safeLookupEnv(env, arg->name);
-                string argString;
-                if (obj->objKind == EXPRESSION) {
-                    Expr *expr = (Expr *) obj.ptr();
-                    appendArgString(expr, &argString);
-                } else if (obj->objKind == EXPR_LIST) {
-                    ExprList *elist = (ExprList *) obj.ptr();
-                    for (vector<ExprPtr>::const_iterator i = elist->exprs.begin(),
-                                 end = elist->exprs.end();
-                         i != end;
-                         ++i) {
-                        if (!argString.empty())
-                            argString += ", ";
-
-                        Expr *expr = i->ptr();
-                        appendArgString(expr, &argString);
-                    }
-                }
-                return analyzeStaticObject(Identifier::get(argString));
-            }
+static MultiPValuePtr analyzeExpr2(ExprPtr expr, EnvPtr env) {
+    LocationContext loc(expr->location);
+    switch (expr->exprKind) {
+    case BOOL_LITERAL: {
+        return new MultiPValue(PVData(boolType, true));
+    }
 
-            case TUPLE: {
-                Tuple *x = (Tuple *) expr.ptr();
-                return analyzeCallExpr(operator_expr_tupleLiteral(),
-                                       x->args,
-                                       env);
-            }
+    case INT_LITERAL: {
+        IntLiteral *x = (IntLiteral *)expr.ptr();
+        ValueHolderPtr v = parseIntLiteral(safeLookupModule(env), x);
+        return new MultiPValue(PVData(v->type, true));
+    }
 
-            case PAREN: {
-                Paren *x = (Paren *) expr.ptr();
-                return analyzeMulti(x->args, env, 0);
-            }
+    case FLOAT_LITERAL: {
+        FloatLiteral *x = (FloatLiteral *)expr.ptr();
+        ValueHolderPtr v = parseFloatLiteral(safeLookupModule(env), x);
+        return new MultiPValue(PVData(v->type, true));
+    }
 
-            case INDEXING: {
-                Indexing *x = (Indexing *) expr.ptr();
-                return analyzeIndexingExpr(x->expr, x->args, env);
-            }
+    case CHAR_LITERAL: {
+        CharLiteral *x = (CharLiteral *)expr.ptr();
+        if (!x->desugared)
+            x->desugared = desugarCharLiteral(x->value);
+        return analyzeExpr(x->desugared, env);
+    }
 
-            case CALL: {
-                Call *x = (Call *) expr.ptr();
-                return analyzeCallExpr(x->expr, x->allArgs(), env);
-            }
+    case STRING_LITERAL: {
+        StringLiteral *x = (StringLiteral *)expr.ptr();
+        return new MultiPValue(staticPValue(x->value.ptr()));
+    }
 
-            case FIELD_REF: {
-                FieldRef *x = (FieldRef *) expr.ptr();
-                if (!x->desugared)
-                    desugarFieldRef(x, safeLookupModule(env));
-                if (x->isDottedModuleName)
-                    return analyzeExpr(x->desugared, env);
+    case NAME_REF: {
+        NameRef *x = (NameRef *)expr.ptr();
+        ObjectPtr y = safeLookupEnv(env, x->name);
+        if (y->objKind == EXPRESSION) {
+            ExprPtr z = (Expr *)y.ptr();
+            return analyzeExpr(z, env);
+        } else if (y->objKind == EXPR_LIST) {
+            ExprListPtr z = (ExprList *)y.ptr();
+            return analyzeMulti(z, env, 0);
+        }
+        return analyzeStaticObject(y);
+    }
 
-                PVData pv = analyzeOne(x->expr, env);
-                if (!pv.ok())
-                    return nullptr;
-                if (pv.type->typeKind == STATIC_TYPE) {
-                    StaticType *st = (StaticType *) pv.type.ptr();
-                    if (st->obj->objKind == MODULE) {
-                        Module *m = (Module *) st->obj.ptr();
-                        ObjectPtr obj = safeLookupPublic(m, x->name);
-                        return analyzeStaticObject(obj);
-                    }
-                }
+    case FILE_EXPR: {
+        Location location = safeLookupCallByNameLocation(env);
+        string filename = location.source->fileName;
+        return analyzeStaticObject(Identifier::get(filename));
+    }
 
-                return analyzeExpr(x->desugared, env);
-            }
+    case LINE_EXPR: {
+        return new MultiPValue(PVData(cSizeTType, true));
+    }
 
-            case STATIC_INDEXING: {
-                StaticIndexing *x = (StaticIndexing *) expr.ptr();
-                if (!x->desugared)
-                    x->desugared = desugarStaticIndexing(x);
-                return analyzeExpr(x->desugared, env);
-            }
+    case COLUMN_EXPR: {
+        return new MultiPValue(PVData(cSizeTType, true));
+    }
 
-            case VARIADIC_OP: {
-                VariadicOp *x = (VariadicOp *) expr.ptr();
-                if (x->op == ADDRESS_OF) {
-                    PVData pv = analyzeOne(x->exprs->exprs.front(), env);
-                    if (!pv.ok())
-                        return nullptr;
-                    if (pv.isRValue)
-                        error("can't take address of a temporary");
-                }
-                if (!x->desugared)
-                    x->desugared = desugarVariadicOp(x);
-                return analyzeExpr(x->desugared, env);
-            }
+    case ARG_EXPR: {
+        ARGExpr *arg = (ARGExpr *)expr.ptr();
+        ObjectPtr obj = safeLookupEnv(env, arg->name);
+        string argString;
+        if (obj->objKind == EXPRESSION) {
+            Expr *expr = (Expr *)obj.ptr();
+            appendArgString(expr, &argString);
+        } else if (obj->objKind == EXPR_LIST) {
+            ExprList *elist = (ExprList *)obj.ptr();
+            for (vector<ExprPtr>::const_iterator i = elist->exprs.begin(),
+                                                 end = elist->exprs.end();
+                 i != end; ++i) {
+                if (!argString.empty())
+                    argString += ", ";
 
-            case EVAL_EXPR: {
-                EvalExpr *eval = (EvalExpr *) expr.ptr();
-                // XXX compilation context
-                ExprListPtr evaled = desugarEvalExpr(eval, env);
-                return analyzeMulti(evaled, env, 0);
+                Expr *expr = i->ptr();
+                appendArgString(expr, &argString);
             }
+        }
+        return analyzeStaticObject(Identifier::get(argString));
+    }
 
-            case AND: {
-                return new MultiPValue(PVData(boolType, true));
-            }
+    case TUPLE: {
+        Tuple *x = (Tuple *)expr.ptr();
+        return analyzeCallExpr(operator_expr_tupleLiteral(), x->args, env);
+    }
 
-            case OR: {
-                return new MultiPValue(PVData(boolType, true));
-            }
+    case PAREN: {
+        Paren *x = (Paren *)expr.ptr();
+        return analyzeMulti(x->args, env, 0);
+    }
 
-            case LAMBDA: {
-                Lambda *x = (Lambda *) expr.ptr();
-                if (!x->initialized)
-                    initializeLambda(x, env);
-                return analyzeExpr(x->converted, env);
-            }
+    case INDEXING: {
+        Indexing *x = (Indexing *)expr.ptr();
+        return analyzeIndexingExpr(x->expr, x->args, env);
+    }
 
-            case UNPACK: {
-                Unpack *unpack = (Unpack *) expr.ptr();
-                if (unpack->expr->exprKind != FOREIGN_EXPR)
-                    error("incorrect usage of unpack operator");
-                return analyzeExpr(unpack->expr, env);
-            }
+    case CALL: {
+        Call *x = (Call *)expr.ptr();
+        return analyzeCallExpr(x->expr, x->allArgs(), env);
+    }
 
-            case STATIC_EXPR: {
-                StaticExpr *x = (StaticExpr *) expr.ptr();
-                ObjectPtr obj = evaluateOneStatic(x->expr, env);
-                TypePtr t = staticType(obj);
-                return new MultiPValue(PVData(t, true));
-            }
+    case FIELD_REF: {
+        FieldRef *x = (FieldRef *)expr.ptr();
+        if (!x->desugared)
+            desugarFieldRef(x, safeLookupModule(env));
+        if (x->isDottedModuleName)
+            return analyzeExpr(x->desugared, env);
 
-            case DISPATCH_EXPR: {
-                error("incorrect usage of dispatch operator");
-                return nullptr;
+        PVData pv = analyzeOne(x->expr, env);
+        if (!pv.ok())
+            return nullptr;
+        if (pv.type->typeKind == STATIC_TYPE) {
+            StaticType *st = (StaticType *)pv.type.ptr();
+            if (st->obj->objKind == MODULE) {
+                Module *m = (Module *)st->obj.ptr();
+                ObjectPtr obj = safeLookupPublic(m, x->name);
+                return analyzeStaticObject(obj);
             }
+        }
 
-            case FOREIGN_EXPR: {
-                ForeignExpr *x = (ForeignExpr *) expr.ptr();
-                return analyzeExpr(x->expr, x->getEnv());
-            }
+        return analyzeExpr(x->desugared, env);
+    }
 
-            case OBJECT_EXPR: {
-                ObjectExpr *x = (ObjectExpr *) expr.ptr();
-                return analyzeStaticObject(x->obj);
-            }
+    case STATIC_INDEXING: {
+        StaticIndexing *x = (StaticIndexing *)expr.ptr();
+        if (!x->desugared)
+            x->desugared = desugarStaticIndexing(x);
+        return analyzeExpr(x->desugared, env);
+    }
 
-            default:
-                assert(false);
+    case VARIADIC_OP: {
+        VariadicOp *x = (VariadicOp *)expr.ptr();
+        if (x->op == ADDRESS_OF) {
+            PVData pv = analyzeOne(x->exprs->exprs.front(), env);
+            if (!pv.ok())
                 return nullptr;
+            if (pv.isRValue)
+                error("can't take address of a temporary");
         }
+        if (!x->desugared)
+            x->desugared = desugarVariadicOp(x);
+        return analyzeExpr(x->desugared, env);
     }
 
-    //
-    // analyzeStaticObject
-    //
-
-    MultiPValuePtr analyzeStaticObject(ObjectPtr x) {
-        switch (x->objKind) {
-            case NEW_TYPE_DECL: {
-                NewTypeDecl *y = (NewTypeDecl *) x.ptr();
-                assert(y->type->typeKind == NEW_TYPE);
-                initializeNewType(y->type);
-
-                return new MultiPValue(PVData(y->type.ptr(), true));
-            }
-
-            case ENUM_MEMBER: {
-                EnumMember *y = (EnumMember *) x.ptr();
-                assert(y->type->typeKind == ENUM_TYPE);
-                initializeEnumType((EnumType *) y->type.ptr());
+    case EVAL_EXPR: {
+        EvalExpr *eval = (EvalExpr *)expr.ptr();
+        // XXX compilation context
+        ExprListPtr evaled = desugarEvalExpr(eval, env);
+        return analyzeMulti(evaled, env, 0);
+    }
 
-                return new MultiPValue(PVData(y->type, true));
-            }
+    case AND: {
+        return new MultiPValue(PVData(boolType, true));
+    }
 
-            case GLOBAL_VARIABLE: {
-                GlobalVariable *y = (GlobalVariable *) x.ptr();
-                if (y->hasParams()) {
-                    TypePtr t = staticType(x);
-                    return new MultiPValue(PVData(t, true));
-                }
-                GVarInstancePtr inst = defaultGVarInstance(y);
-                return analyzeGVarInstance(inst);
-            }
+    case OR: {
+        return new MultiPValue(PVData(boolType, true));
+    }
 
-            case EXTERNAL_VARIABLE: {
-                ExternalVariable *y = (ExternalVariable *) x.ptr();
-                return new MultiPValue(analyzeExternalVariable(y));
-            }
+    case LAMBDA: {
+        Lambda *x = (Lambda *)expr.ptr();
+        if (!x->initialized)
+            initializeLambda(x, env);
+        return analyzeExpr(x->converted, env);
+    }
 
-            case EXTERNAL_PROCEDURE: {
-                ExternalProcedure *y = (ExternalProcedure *) x.ptr();
-                analyzeExternalProcedure(y);
-                return new MultiPValue(PVData(y->ptrType, true));
-            }
+    case UNPACK: {
+        Unpack *unpack = (Unpack *)expr.ptr();
+        if (unpack->expr->exprKind != FOREIGN_EXPR)
+            error("incorrect usage of unpack operator");
+        return analyzeExpr(unpack->expr, env);
+    }
 
-            case GLOBAL_ALIAS: {
-                GlobalAlias *y = (GlobalAlias *) x.ptr();
-                if (y->hasParams()) {
-                    TypePtr t = staticType(x);
-                    return new MultiPValue(PVData(t, true));
-                }
-                evaluatePredicate(y->patternVars, y->predicate, y->env);
-                return analyzeExpr(y->expr, y->env);
-            }
+    case STATIC_EXPR: {
+        StaticExpr *x = (StaticExpr *)expr.ptr();
+        ObjectPtr obj = evaluateOneStatic(x->expr, env);
+        TypePtr t = staticType(obj);
+        return new MultiPValue(PVData(t, true));
+    }
 
-            case VALUE_HOLDER: {
-                ValueHolder *y = (ValueHolder *) x.ptr();
-                return new MultiPValue(PVData(y->type, true));
-            }
+    case DISPATCH_EXPR: {
+        error("incorrect usage of dispatch operator");
+        return nullptr;
+    }
 
-            case MULTI_STATIC: {
-                MultiStatic *y = (MultiStatic *) x.ptr();
-                MultiPValuePtr mpv = new MultiPValue();
-                for (size_t i = 0; i < y->size(); ++i) {
-                    TypePtr t = objectType(y->values[i]);
-                    mpv->values.push_back(PVData(t, true));
-                }
-                return mpv;
-            }
+    case FOREIGN_EXPR: {
+        ForeignExpr *x = (ForeignExpr *)expr.ptr();
+        return analyzeExpr(x->expr, x->getEnv());
+    }
 
-            case RECORD_DECL: {
-                RecordDecl *y = (RecordDecl *) x.ptr();
-                ObjectPtr z;
-                if (y->params.empty() && !y->varParam)
-                    z = recordType(y, vector<ObjectPtr>()).ptr();
-                else
-                    z = y;
-                return new MultiPValue(PVData(staticType(z), true));
-            }
+    case OBJECT_EXPR: {
+        ObjectExpr *x = (ObjectExpr *)expr.ptr();
+        return analyzeStaticObject(x->obj);
+    }
 
-            case VARIANT_DECL: {
-                VariantDecl *y = (VariantDecl *) x.ptr();
-                ObjectPtr z;
-                if (y->params.empty() && !y->varParam)
-                    z = variantType(y, vector<ObjectPtr>()).ptr();
-                else
-                    z = y;
-                return new MultiPValue(PVData(staticType(z), true));
-            }
+    default:
+        assert(false);
+        return nullptr;
+    }
+}
 
-            case TYPE:
-            case PRIM_OP:
-            case PROCEDURE:
-            case MODULE:
-            case INTRINSIC:
-            case IDENTIFIER: {
-                TypePtr t = staticType(x);
-                return new MultiPValue(PVData(t, true));
-            }
+//
+// analyzeStaticObject
+//
 
-            case EVALUE: {
-                EValue *y = (EValue *) x.ptr();
-                return new MultiPValue(PVData(y->type, y->forwardedRValue));
-            }
+MultiPValuePtr analyzeStaticObject(ObjectPtr x) {
+    switch (x->objKind) {
+    case NEW_TYPE_DECL: {
+        NewTypeDecl *y = (NewTypeDecl *)x.ptr();
+        assert(y->type->typeKind == NEW_TYPE);
+        initializeNewType(y->type);
 
-            case MULTI_EVALUE: {
-                MultiEValue *y = (MultiEValue *) x.ptr();
-                MultiPValuePtr z = new MultiPValue();
-                for (size_t i = 0; i < y->values.size(); ++i) {
-                    EValue *ev = y->values[i].ptr();
-                    z->values.push_back(PVData(ev->type, ev->forwardedRValue));
-                }
-                return z;
-            }
+        return new MultiPValue(PVData(y->type.ptr(), true));
+    }
 
-            case CVALUE: {
-                CValue *y = (CValue *) x.ptr();
-                return new MultiPValue(PVData(y->type, y->forwardedRValue));
-            }
+    case ENUM_MEMBER: {
+        EnumMember *y = (EnumMember *)x.ptr();
+        assert(y->type->typeKind == ENUM_TYPE);
+        initializeEnumType((EnumType *)y->type.ptr());
 
-            case MULTI_CVALUE: {
-                MultiCValue *y = (MultiCValue *) x.ptr();
-                MultiPValuePtr z = new MultiPValue();
-                for (size_t i = 0; i < y->values.size(); ++i) {
-                    CValue *cv = y->values[i].ptr();
-                    z->add(PVData(cv->type, cv->forwardedRValue));
-                }
-                return z;
-            }
+        return new MultiPValue(PVData(y->type, true));
+    }
 
-            case PVALUE: {
-                PValue *y = (PValue *) x.ptr();
-                return new MultiPValue(y->data);
-            }
+    case GLOBAL_VARIABLE: {
+        GlobalVariable *y = (GlobalVariable *)x.ptr();
+        if (y->hasParams()) {
+            TypePtr t = staticType(x);
+            return new MultiPValue(PVData(t, true));
+        }
+        GVarInstancePtr inst = defaultGVarInstance(y);
+        return analyzeGVarInstance(inst);
+    }
 
-            case MULTI_PVALUE: {
-                MultiPValue *y = (MultiPValue *) x.ptr();
-                return y;
-            }
+    case EXTERNAL_VARIABLE: {
+        ExternalVariable *y = (ExternalVariable *)x.ptr();
+        return new MultiPValue(analyzeExternalVariable(y));
+    }
 
-            case PATTERN:
-            case MULTI_PATTERN:
-                error("pattern variable cannot be used as value");
-                return nullptr;
+    case EXTERNAL_PROCEDURE: {
+        ExternalProcedure *y = (ExternalProcedure *)x.ptr();
+        analyzeExternalProcedure(y);
+        return new MultiPValue(PVData(y->ptrType, true));
+    }
 
-            default:
-                invalidStaticObjectError(x);
-                return nullptr;
+    case GLOBAL_ALIAS: {
+        GlobalAlias *y = (GlobalAlias *)x.ptr();
+        if (y->hasParams()) {
+            TypePtr t = staticType(x);
+            return new MultiPValue(PVData(t, true));
         }
+        evaluatePredicate(y->patternVars, y->predicate, y->env);
+        return analyzeExpr(y->expr, y->env);
     }
 
-    //
-    // lookupGVarInstance, defaultGVarInstance
-    // analyzeGVarIndexing, analyzeGVarInstance
-    //
+    case VALUE_HOLDER: {
+        ValueHolder *y = (ValueHolder *)x.ptr();
+        return new MultiPValue(PVData(y->type, true));
+    }
 
-    GVarInstancePtr lookupGVarInstance(GlobalVariablePtr x,
-                                       llvm::ArrayRef<ObjectPtr> params) {
-        if (!x->instances)
-            x->instances = new ObjectTable();
-        Pointer<RefCounted> &y = x->instances->lookup(params);
-        if (!y) {
-            y = new GVarInstance(x, params);
+    case MULTI_STATIC: {
+        MultiStatic *y = (MultiStatic *)x.ptr();
+        MultiPValuePtr mpv = new MultiPValue();
+        for (size_t i = 0; i < y->size(); ++i) {
+            TypePtr t = objectType(y->values[i]);
+            mpv->values.push_back(PVData(t, true));
         }
-        return (GVarInstance *) y.ptr();
+        return mpv;
     }
 
-    GVarInstancePtr defaultGVarInstance(GlobalVariablePtr x) {
-        return lookupGVarInstance(x, vector<ObjectPtr>());
+    case RECORD_DECL: {
+        RecordDecl *y = (RecordDecl *)x.ptr();
+        ObjectPtr z;
+        if (y->params.empty() && !y->varParam)
+            z = recordType(y, vector<ObjectPtr>()).ptr();
+        else
+            z = y;
+        return new MultiPValue(PVData(staticType(z), true));
     }
 
-    GVarInstancePtr analyzeGVarIndexing(GlobalVariablePtr x,
-                                        ExprListPtr args,
-                                        EnvPtr env) {
-        assert(x->hasParams());
-        MultiStaticPtr params = evaluateMultiStatic(args, env);
-        if (x->varParam.ptr()) {
-            if (params->size() < x->params.size())
-                arityError2(x->params.size(), params->size());
-        } else {
-            ensureArity(params, x->params.size());
-        }
-        return lookupGVarInstance(x, params->values);
+    case VARIANT_DECL: {
+        VariantDecl *y = (VariantDecl *)x.ptr();
+        ObjectPtr z;
+        if (y->params.empty() && !y->varParam)
+            z = variantType(y, vector<ObjectPtr>()).ptr();
+        else
+            z = y;
+        return new MultiPValue(PVData(staticType(z), true));
     }
 
-    MultiPValuePtr analyzeGVarInstance(GVarInstancePtr x) {
-        if (x->analysis.ptr())
-            return x->analysis;
-        CompileContextPusher pusher(x->gvar.ptr(), x->params);
-        if (x->analyzing) {
-            updateAnalysisErrorLocation();
-            return nullptr;
+    case TYPE:
+    case PRIM_OP:
+    case PROCEDURE:
+    case MODULE:
+    case INTRINSIC:
+    case IDENTIFIER: {
+        TypePtr t = staticType(x);
+        return new MultiPValue(PVData(t, true));
+    }
+
+    case EVALUE: {
+        EValue *y = (EValue *)x.ptr();
+        return new MultiPValue(PVData(y->type, y->forwardedRValue));
+    }
+
+    case MULTI_EVALUE: {
+        MultiEValue *y = (MultiEValue *)x.ptr();
+        MultiPValuePtr z = new MultiPValue();
+        for (size_t i = 0; i < y->values.size(); ++i) {
+            EValue *ev = y->values[i].ptr();
+            z->values.push_back(PVData(ev->type, ev->forwardedRValue));
         }
-        GlobalVariablePtr gvar = x->gvar;
-        if (!x->expr)
-            x->expr = clone(gvar->expr);
-        if (!x->env) {
-            x->env = new Env(gvar->env);
-            for (size_t i = 0; i < gvar->params.size(); ++i) {
-                addLocal(x->env, gvar->params[i], x->params[i]);
-            }
-            if (gvar->varParam.ptr()) {
-                MultiStaticPtr varParams = new MultiStatic();
-                for (size_t i = gvar->params.size(); i < x->params.size(); ++i)
-                    varParams->add(x->params[i]);
-                addLocal(x->env, gvar->varParam, varParams.ptr());
-            }
+        return z;
+    }
+
+    case CVALUE: {
+        CValue *y = (CValue *)x.ptr();
+        return new MultiPValue(PVData(y->type, y->forwardedRValue));
+    }
+
+    case MULTI_CVALUE: {
+        MultiCValue *y = (MultiCValue *)x.ptr();
+        MultiPValuePtr z = new MultiPValue();
+        for (size_t i = 0; i < y->values.size(); ++i) {
+            CValue *cv = y->values[i].ptr();
+            z->add(PVData(cv->type, cv->forwardedRValue));
         }
-        x->analyzing = true;
-        evaluatePredicate(x->gvar->patternVars, x->gvar->predicate, x->env);
-        PVData pv = analyzeOne(x->expr, x->env);
-        x->analyzing = false;
-        if (!pv.ok())
-            return nullptr;
-        x->analysis = new MultiPValue(PVData(pv.type, false));
-        x->type = pv.type;
-        return x->analysis;
+        return z;
     }
 
-    //
-    // analyzeExternalVariable
-    //
+    case PVALUE: {
+        PValue *y = (PValue *)x.ptr();
+        return new MultiPValue(y->data);
+    }
 
-    PVData analyzeExternalVariable(ExternalVariablePtr x) {
-        if (!x->type2)
-            x->type2 = evaluateType(x->type, x->env);
-        return PVData(x->type2, false);
+    case MULTI_PVALUE: {
+        MultiPValue *y = (MultiPValue *)x.ptr();
+        return y;
     }
 
-    //
-    // analyzeExternalProcedure
-    //
+    case PATTERN:
+    case MULTI_PATTERN:
+        error("pattern variable cannot be used as value");
+        return nullptr;
 
-    void analyzeExternalProcedure(ExternalProcedurePtr x) {
-        if (x->analyzed)
-            return;
-        if (!x->attributesVerified)
-            verifyAttributes(x);
-        vector<TypePtr> argTypes;
-        for (size_t i = 0; i < x->args.size(); ++i) {
-            ExternalArgPtr y = x->args[i];
-            y->type2 = evaluateType(y->type, x->env);
-            argTypes.push_back(y->type2);
-        }
-        if (!x->returnType)
-            x->returnType2 = nullptr;
-        else
-            x->returnType2 = evaluateType(x->returnType, x->env);
-        x->ptrType = cCodePointerType(x->callingConv, argTypes,
-                                      x->hasVarArgs, x->returnType2);
-        x->analyzed = true;
+    default:
+        invalidStaticObjectError(x);
+        return nullptr;
     }
+}
 
-    //
-    // verifyAttributes
-    //
+//
+// lookupGVarInstance, defaultGVarInstance
+// analyzeGVarIndexing, analyzeGVarInstance
+//
 
-    void verifyAttributes(ExternalProcedurePtr x) {
-        assert(!x->attributesVerified);
-        x->attributesVerified = true;
-        x->attrDLLImport = false;
-        x->attrDLLExport = false;
-        int callingConv = -1;
-        x->attrAsmLabel = "";
+GVarInstancePtr lookupGVarInstance(GlobalVariablePtr x,
+                                   llvm::ArrayRef<ObjectPtr> params) {
+    if (!x->instances)
+        x->instances = new ObjectTable();
+    Pointer<RefCounted> &y = x->instances->lookup(params);
+    if (!y) {
+        y = new GVarInstance(x, params);
+    }
+    return (GVarInstance *)y.ptr();
+}
 
-        MultiStaticPtr attrs = evaluateMultiStatic(x->attributes, x->env);
+GVarInstancePtr defaultGVarInstance(GlobalVariablePtr x) {
+    return lookupGVarInstance(x, vector<ObjectPtr>());
+}
 
-        for (size_t i = 0; i < attrs->size(); ++i) {
-            ObjectPtr obj = attrs->values[i];
+GVarInstancePtr analyzeGVarIndexing(GlobalVariablePtr x, ExprListPtr args,
+                                    EnvPtr env) {
+    assert(x->hasParams());
+    MultiStaticPtr params = evaluateMultiStatic(args, env);
+    if (x->varParam.ptr()) {
+        if (params->size() < x->params.size())
+            arityError2(x->params.size(), params->size());
+    } else {
+        ensureArity(params, x->params.size());
+    }
+    return lookupGVarInstance(x, params->values);
+}
 
-            switch (obj->objKind) {
-                case PRIM_OP: {
-                    PrimOp *y = (PrimOp *) obj.ptr();
-                    switch (y->primOpCode) {
-                        case PRIM_AttributeStdCall: {
-                            if (callingConv != -1)
-                                error(x, "cannot specify more than one calling convention in external attributes");
-                            callingConv = CC_STDCALL;
-                            break;
-                        }
-                        case PRIM_AttributeFastCall: {
-                            if (callingConv != -1)
-                                error(x, "cannot specify more than one calling convention in external attributes");
-                            callingConv = CC_FASTCALL;
-                            break;
-                        }
-                        case PRIM_AttributeThisCall: {
-                            if (callingConv != -1)
-                                error(x, "cannot specify more than one calling convention in external attributes");
-                            callingConv = CC_THISCALL;
-                            break;
-                        }
-                        case PRIM_AttributeCCall: {
-                            if (callingConv != -1)
-                                error(x, "cannot specify more than one calling convention in external attributes");
-                            callingConv = CC_DEFAULT;
-                            break;
-                        }
-                        case PRIM_AttributeLLVMCall: {
-                            if (callingConv != -1)
-                                error(x, "cannot specify more than one calling convention in external attributes");
-                            callingConv = CC_LLVM;
-                            break;
-                        }
-                        case PRIM_AttributeDLLImport: {
-                            if (x->attrDLLExport)
-                                error(x, "dllimport specified after dllexport in external attributes");
-                            x->attrDLLImport = true;
-                            break;
-                        }
-                        case PRIM_AttributeDLLExport: {
-                            if (x->attrDLLImport)
-                                error(x, "dllexport specified after dllimport in external attributes");
-                            x->attrDLLExport = true;
-                            break;
-                        }
-                        default: {
-                            string buf;
-                            llvm::raw_string_ostream os(buf);
-                            os << "invalid external function attribute: ";
-                            printStaticName(os, obj);
-                            error(x, os.str());
-                        }
-                    }
-                    break;
-                }
-                case IDENTIFIER: {
-                    Identifier *y = (Identifier *) obj.ptr();
-                    x->attrAsmLabel = y->str;
-                    break;
-                }
-                default: {
-                    string buf;
-                    llvm::raw_string_ostream os(buf);
-                    os << "invalid external function attribute: ";
-                    printStaticName(os, obj);
-                    error(x, os.str());
-                }
-            }
+MultiPValuePtr analyzeGVarInstance(GVarInstancePtr x) {
+    if (x->analysis.ptr())
+        return x->analysis;
+    CompileContextPusher pusher(x->gvar.ptr(), x->params);
+    if (x->analyzing) {
+        updateAnalysisErrorLocation();
+        return nullptr;
+    }
+    GlobalVariablePtr gvar = x->gvar;
+    if (!x->expr)
+        x->expr = clone(gvar->expr);
+    if (!x->env) {
+        x->env = new Env(gvar->env);
+        for (size_t i = 0; i < gvar->params.size(); ++i) {
+            addLocal(x->env, gvar->params[i], x->params[i]);
+        }
+        if (gvar->varParam.ptr()) {
+            MultiStaticPtr varParams = new MultiStatic();
+            for (size_t i = gvar->params.size(); i < x->params.size(); ++i)
+                varParams->add(x->params[i]);
+            addLocal(x->env, gvar->varParam, varParams.ptr());
         }
-        if (callingConv == -1)
-            callingConv = CC_DEFAULT;
-        x->callingConv = (CallingConv) callingConv;
     }
+    x->analyzing = true;
+    evaluatePredicate(x->gvar->patternVars, x->gvar->predicate, x->env);
+    PVData pv = analyzeOne(x->expr, x->env);
+    x->analyzing = false;
+    if (!pv.ok())
+        return nullptr;
+    x->analysis = new MultiPValue(PVData(pv.type, false));
+    x->type = pv.type;
+    return x->analysis;
+}
 
-    void verifyAttributes(ExternalVariablePtr var) {
-        assert(!var->attributesVerified);
-        var->attributesVerified = true;
-        var->attrDLLImport = false;
-        var->attrDLLExport = false;
+//
+// analyzeExternalVariable
+//
 
-        MultiStaticPtr attrs = evaluateMultiStatic(var->attributes, var->env);
+PVData analyzeExternalVariable(ExternalVariablePtr x) {
+    if (!x->type2)
+        x->type2 = evaluateType(x->type, x->env);
+    return PVData(x->type2, false);
+}
 
-        for (size_t i = 0; i < attrs->size(); ++i) {
-            ObjectPtr obj = attrs->values[i];
+//
+// analyzeExternalProcedure
+//
+
+void analyzeExternalProcedure(ExternalProcedurePtr x) {
+    if (x->analyzed)
+        return;
+    if (!x->attributesVerified)
+        verifyAttributes(x);
+    vector<TypePtr> argTypes;
+    for (size_t i = 0; i < x->args.size(); ++i) {
+        ExternalArgPtr y = x->args[i];
+        y->type2 = evaluateType(y->type, x->env);
+        argTypes.push_back(y->type2);
+    }
+    if (!x->returnType)
+        x->returnType2 = nullptr;
+    else
+        x->returnType2 = evaluateType(x->returnType, x->env);
+    x->ptrType = cCodePointerType(x->callingConv, argTypes, x->hasVarArgs,
+                                  x->returnType2);
+    x->analyzed = true;
+}
+
+//
+// verifyAttributes
+//
+
+void verifyAttributes(ExternalProcedurePtr x) {
+    assert(!x->attributesVerified);
+    x->attributesVerified = true;
+    x->attrDLLImport = false;
+    x->attrDLLExport = false;
+    int callingConv = -1;
+    x->attrAsmLabel = "";
+
+    MultiStaticPtr attrs = evaluateMultiStatic(x->attributes, x->env);
 
-            if (obj->objKind != PRIM_OP) {
+    for (size_t i = 0; i < attrs->size(); ++i) {
+        ObjectPtr obj = attrs->values[i];
+
+        switch (obj->objKind) {
+        case PRIM_OP: {
+            PrimOp *y = (PrimOp *)obj.ptr();
+            switch (y->primOpCode) {
+            case PRIM_AttributeStdCall: {
+                if (callingConv != -1)
+                    error(x, "cannot specify more than one calling convention "
+                             "in external attributes");
+                callingConv = CC_STDCALL;
+                break;
+            }
+            case PRIM_AttributeFastCall: {
+                if (callingConv != -1)
+                    error(x, "cannot specify more than one calling convention "
+                             "in external attributes");
+                callingConv = CC_FASTCALL;
+                break;
+            }
+            case PRIM_AttributeThisCall: {
+                if (callingConv != -1)
+                    error(x, "cannot specify more than one calling convention "
+                             "in external attributes");
+                callingConv = CC_THISCALL;
+                break;
+            }
+            case PRIM_AttributeCCall: {
+                if (callingConv != -1)
+                    error(x, "cannot specify more than one calling convention "
+                             "in external attributes");
+                callingConv = CC_DEFAULT;
+                break;
+            }
+            case PRIM_AttributeLLVMCall: {
+                if (callingConv != -1)
+                    error(x, "cannot specify more than one calling convention "
+                             "in external attributes");
+                callingConv = CC_LLVM;
+                break;
+            }
+            case PRIM_AttributeDLLImport: {
+                if (x->attrDLLExport)
+                    error(x, "dllimport specified after dllexport in external "
+                             "attributes");
+                x->attrDLLImport = true;
+                break;
+            }
+            case PRIM_AttributeDLLExport: {
+                if (x->attrDLLImport)
+                    error(x, "dllexport specified after dllimport in external "
+                             "attributes");
+                x->attrDLLExport = true;
+                break;
+            }
+            default: {
                 string buf;
                 llvm::raw_string_ostream os(buf);
-                os << "invalid external variable attribute: ";
+                os << "invalid external function attribute: ";
                 printStaticName(os, obj);
-                error(var, os.str());
+                error(x, os.str());
             }
-
-            PrimOp *y = (PrimOp *) obj.ptr();
-            switch (y->primOpCode) {
-                case PRIM_AttributeDLLImport: {
-                    if (var->attrDLLExport)
-                        error(var, "dllimport specified after dllexport in external attributes");
-                    var->attrDLLImport = true;
-                    break;
-                }
-                case PRIM_AttributeDLLExport: {
-                    if (var->attrDLLImport)
-                        error(var, "dllexport specified after dllimport in external attributes");
-                    var->attrDLLExport = true;
-                    break;
-                }
-                default: {
-                    string buf;
-                    llvm::raw_string_ostream os(buf);
-                    os << "invalid external variable attribute: ";
-                    printStaticName(os, obj);
-                    error(var, os.str());
-                }
             }
+            break;
+        }
+        case IDENTIFIER: {
+            Identifier *y = (Identifier *)obj.ptr();
+            x->attrAsmLabel = y->str;
+            break;
+        }
+        default: {
+            string buf;
+            llvm::raw_string_ostream os(buf);
+            os << "invalid external function attribute: ";
+            printStaticName(os, obj);
+            error(x, os.str());
+        }
         }
     }
+    if (callingConv == -1)
+        callingConv = CC_DEFAULT;
+    x->callingConv = (CallingConv)callingConv;
+}
 
-    void verifyAttributes(ModulePtr mod) {
-        assert(!mod->attributesVerified);
-        mod->attributesVerified = true;
+void verifyAttributes(ExternalVariablePtr var) {
+    assert(!var->attributesVerified);
+    var->attributesVerified = true;
+    var->attrDLLImport = false;
+    var->attrDLLExport = false;
 
-        if (mod->declaration != nullptr && mod->declaration->attributes != nullptr) {
-            MultiStaticPtr attrs = evaluateMultiStatic(mod->declaration->attributes, mod->env);
+    MultiStaticPtr attrs = evaluateMultiStatic(var->attributes, var->env);
 
-            for (size_t i = 0; i < attrs->size(); ++i) {
-                ObjectPtr obj = attrs->values[i];
+    for (size_t i = 0; i < attrs->size(); ++i) {
+        ObjectPtr obj = attrs->values[i];
 
-                switch (obj->objKind) {
-                    case TYPE: {
-                        if (obj->objKind == TYPE) {
-                            Type *ty = (Type *) obj.ptr();
-                            if (ty->typeKind == FLOAT_TYPE) {
-                                mod->attrDefaultFloatType = (FloatType *) ty;
-                            } else if (ty->typeKind == INTEGER_TYPE) {
-                                mod->attrDefaultIntegerType = (IntegerType *) ty;
-                            }
-                        }
-                        break;
-                    }
-                    case IDENTIFIER: {
-                        Identifier *y = (Identifier *) obj.ptr();
-                        mod->attrBuildFlags.push_back(y->str);
-                        break;
+        if (obj->objKind != PRIM_OP) {
+            string buf;
+            llvm::raw_string_ostream os(buf);
+            os << "invalid external variable attribute: ";
+            printStaticName(os, obj);
+            error(var, os.str());
+        }
+
+        PrimOp *y = (PrimOp *)obj.ptr();
+        switch (y->primOpCode) {
+        case PRIM_AttributeDLLImport: {
+            if (var->attrDLLExport)
+                error(var, "dllimport specified after dllexport in external "
+                           "attributes");
+            var->attrDLLImport = true;
+            break;
+        }
+        case PRIM_AttributeDLLExport: {
+            if (var->attrDLLImport)
+                error(var, "dllexport specified after dllimport in external "
+                           "attributes");
+            var->attrDLLExport = true;
+            break;
+        }
+        default: {
+            string buf;
+            llvm::raw_string_ostream os(buf);
+            os << "invalid external variable attribute: ";
+            printStaticName(os, obj);
+            error(var, os.str());
+        }
+        }
+    }
+}
+
+void verifyAttributes(ModulePtr mod) {
+    assert(!mod->attributesVerified);
+    mod->attributesVerified = true;
+
+    if (mod->declaration != nullptr &&
+        mod->declaration->attributes != nullptr) {
+        MultiStaticPtr attrs =
+            evaluateMultiStatic(mod->declaration->attributes, mod->env);
+
+        for (size_t i = 0; i < attrs->size(); ++i) {
+            ObjectPtr obj = attrs->values[i];
+
+            switch (obj->objKind) {
+            case TYPE: {
+                if (obj->objKind == TYPE) {
+                    Type *ty = (Type *)obj.ptr();
+                    if (ty->typeKind == FLOAT_TYPE) {
+                        mod->attrDefaultFloatType = (FloatType *)ty;
+                    } else if (ty->typeKind == INTEGER_TYPE) {
+                        mod->attrDefaultIntegerType = (IntegerType *)ty;
                     }
-                    default:
-                        string buf;
-                        llvm::raw_string_ostream os(buf);
-                        os << "invalid module attribute: ";
-                        printStaticName(os, obj);
-                        error(mod->declaration, os.str());
                 }
+                break;
+            }
+            case IDENTIFIER: {
+                Identifier *y = (Identifier *)obj.ptr();
+                mod->attrBuildFlags.push_back(y->str);
+                break;
+            }
+            default:
+                string buf;
+                llvm::raw_string_ostream os(buf);
+                os << "invalid module attribute: ";
+                printStaticName(os, obj);
+                error(mod->declaration, os.str());
             }
         }
     }
+}
 
-    //
-    // analyzeIndexingExpr
-    //
-
-    static bool isTypeConstructor(ObjectPtr x) {
-        if (x->objKind == PRIM_OP) {
-            PrimOpPtr y = (PrimOp *) x.ptr();
-            switch (y->primOpCode) {
-                case PRIM_Pointer:
-                case PRIM_CodePointer:
-                case PRIM_ExternalCodePointer:
-                case PRIM_Array:
-                case PRIM_Vec:
-                case PRIM_Tuple:
-                case PRIM_Union:
-                case PRIM_Static:
-                    return true;
-                default:
-                    return false;
-            }
-        } else if (x->objKind == RECORD_DECL) {
+//
+// analyzeIndexingExpr
+//
+
+static bool isTypeConstructor(ObjectPtr x) {
+    if (x->objKind == PRIM_OP) {
+        PrimOpPtr y = (PrimOp *)x.ptr();
+        switch (y->primOpCode) {
+        case PRIM_Pointer:
+        case PRIM_CodePointer:
+        case PRIM_ExternalCodePointer:
+        case PRIM_Array:
+        case PRIM_Vec:
+        case PRIM_Tuple:
+        case PRIM_Union:
+        case PRIM_Static:
             return true;
-        } else if (x->objKind == VARIANT_DECL) {
-            return true;
-        } else {
+        default:
             return false;
         }
+    } else if (x->objKind == RECORD_DECL) {
+        return true;
+    } else if (x->objKind == VARIANT_DECL) {
+        return true;
+    } else {
+        return false;
     }
+}
 
-    MultiPValuePtr analyzeIndexingExpr(ExprPtr indexable,
-                                       ExprListPtr args,
-                                       EnvPtr env) {
-        PVData pv = analyzeOne(indexable, env);
-        if (!pv.ok())
-            return nullptr;
-        ObjectPtr obj = unwrapStaticType(pv.type);
-        if (obj.ptr()) {
-            if (isTypeConstructor(obj)) {
-                MultiStaticPtr params = evaluateMultiStatic(args, env);
-                PVData out = analyzeTypeConstructor(obj, params);
-                return new MultiPValue(out);
-            }
-            if (obj->objKind == GLOBAL_ALIAS) {
-                GlobalAlias *x = (GlobalAlias *) obj.ptr();
-                return analyzeAliasIndexing(x, args, env);
-            }
-            if (obj->objKind == GLOBAL_VARIABLE) {
-                GlobalVariable *x = (GlobalVariable *) obj.ptr();
-                GVarInstancePtr y = analyzeGVarIndexing(x, args, env);
-                return analyzeGVarInstance(y);
-            }
-            if (obj->objKind != VALUE_HOLDER && obj->objKind != IDENTIFIER)
-                error("invalid indexing operation");
+MultiPValuePtr analyzeIndexingExpr(ExprPtr indexable, ExprListPtr args,
+                                   EnvPtr env) {
+    PVData pv = analyzeOne(indexable, env);
+    if (!pv.ok())
+        return nullptr;
+    ObjectPtr obj = unwrapStaticType(pv.type);
+    if (obj.ptr()) {
+        if (isTypeConstructor(obj)) {
+            MultiStaticPtr params = evaluateMultiStatic(args, env);
+            PVData out = analyzeTypeConstructor(obj, params);
+            return new MultiPValue(out);
         }
-        ExprListPtr args2 = new ExprList(indexable);
-        args2->add(args);
-        return analyzeCallExpr(operator_expr_index(), args2, env);
-    }
-
-    //
-    // unwrapByRef
-    //
-
-    bool unwrapByRef(TypePtr &t) {
-        if (t->typeKind == RECORD_TYPE) {
-            RecordType *rt = (RecordType *) t.ptr();
-            if (rt->record.ptr() == primitive_ByRef().ptr()) {
-                assert(rt->params.size() == 1);
-                ObjectPtr obj = rt->params[0];
-                if (obj->objKind != TYPE) {
-                    string buf;
-                    llvm::raw_string_ostream ostr(buf);
-                    ostr << "invalid return type: " << t;
-                    error(ostr.str());
-                }
-                t = (Type *) obj.ptr();
-                return true;
+        if (obj->objKind == GLOBAL_ALIAS) {
+            GlobalAlias *x = (GlobalAlias *)obj.ptr();
+            return analyzeAliasIndexing(x, args, env);
+        }
+        if (obj->objKind == GLOBAL_VARIABLE) {
+            GlobalVariable *x = (GlobalVariable *)obj.ptr();
+            GVarInstancePtr y = analyzeGVarIndexing(x, args, env);
+            return analyzeGVarInstance(y);
+        }
+        if (obj->objKind != VALUE_HOLDER && obj->objKind != IDENTIFIER)
+            error("invalid indexing operation");
+    }
+    ExprListPtr args2 = new ExprList(indexable);
+    args2->add(args);
+    return analyzeCallExpr(operator_expr_index(), args2, env);
+}
+
+//
+// unwrapByRef
+//
+
+bool unwrapByRef(TypePtr &t) {
+    if (t->typeKind == RECORD_TYPE) {
+        RecordType *rt = (RecordType *)t.ptr();
+        if (rt->record.ptr() == primitive_ByRef().ptr()) {
+            assert(rt->params.size() == 1);
+            ObjectPtr obj = rt->params[0];
+            if (obj->objKind != TYPE) {
+                string buf;
+                llvm::raw_string_ostream ostr(buf);
+                ostr << "invalid return type: " << t;
+                error(ostr.str());
             }
+            t = (Type *)obj.ptr();
+            return true;
         }
-        return false;
     }
+    return false;
+}
 
-    //
-    // constructType
-    //
+//
+// constructType
+//
 
-    TypePtr constructType(ObjectPtr constructor, MultiStaticPtr args) {
-        if (constructor->objKind == PRIM_OP) {
-            PrimOpPtr x = (PrimOp *) constructor.ptr();
+TypePtr constructType(ObjectPtr constructor, MultiStaticPtr args) {
+    if (constructor->objKind == PRIM_OP) {
+        PrimOpPtr x = (PrimOp *)constructor.ptr();
 
-            switch (x->primOpCode) {
-                case PRIM_Pointer: {
-                    ensureArity(args, 1);
-                    TypePtr pointeeType = staticToType(args, 0);
-                    return pointerType(pointeeType);
-                }
+        switch (x->primOpCode) {
+        case PRIM_Pointer: {
+            ensureArity(args, 1);
+            TypePtr pointeeType = staticToType(args, 0);
+            return pointerType(pointeeType);
+        }
 
-                case PRIM_CodePointer: {
-                    ensureArity(args, 2);
-                    vector<TypePtr> argTypes;
-                    staticToTypeTuple(args, 0, argTypes);
-                    vector<TypePtr> returnTypes;
-                    staticToTypeTuple(args, 1, returnTypes);
-                    vector<uint8_t> returnIsRef(returnTypes.size(), false);
-                    for (size_t i = 0; i < returnTypes.size(); ++i)
-                        returnIsRef[i] = unwrapByRef(returnTypes[i]);
-                    return codePointerType(argTypes, returnIsRef, returnTypes);
-                }
+        case PRIM_CodePointer: {
+            ensureArity(args, 2);
+            vector<TypePtr> argTypes;
+            staticToTypeTuple(args, 0, argTypes);
+            vector<TypePtr> returnTypes;
+            staticToTypeTuple(args, 1, returnTypes);
+            vector<uint8_t> returnIsRef(returnTypes.size(), false);
+            for (size_t i = 0; i < returnTypes.size(); ++i)
+                returnIsRef[i] = unwrapByRef(returnTypes[i]);
+            return codePointerType(argTypes, returnIsRef, returnTypes);
+        }
 
-                case PRIM_ExternalCodePointer: {
-                    ensureArity(args, 4);
-
-                    CallingConv cc = staticToCallingConv(args, 0);
-                    bool hasVarArgs = staticToBool(args, 1);
-                    vector<TypePtr> argTypes;
-                    staticToTypeTuple(args, 2, argTypes);
-                    vector<TypePtr> returnTypes;
-                    staticToTypeTuple(args, 3, returnTypes);
-                    if (returnTypes.size() > 1)
-                        argumentError(1, "C code cannot return more than one value");
-                    TypePtr returnType;
-                    if (returnTypes.size() == 1)
-                        returnType = returnTypes[0];
-                    return cCodePointerType(cc, argTypes, hasVarArgs, returnType);
-                }
+        case PRIM_ExternalCodePointer: {
+            ensureArity(args, 4);
 
-                case PRIM_Array: {
-                    ensureArity(args, 2);
-                    TypePtr t = staticToType(args, 0);
-                    return arrayType(t, unsigned(staticToInt(args, 1)));
-                }
+            CallingConv cc = staticToCallingConv(args, 0);
+            bool hasVarArgs = staticToBool(args, 1);
+            vector<TypePtr> argTypes;
+            staticToTypeTuple(args, 2, argTypes);
+            vector<TypePtr> returnTypes;
+            staticToTypeTuple(args, 3, returnTypes);
+            if (returnTypes.size() > 1)
+                argumentError(1, "C code cannot return more than one value");
+            TypePtr returnType;
+            if (returnTypes.size() == 1)
+                returnType = returnTypes[0];
+            return cCodePointerType(cc, argTypes, hasVarArgs, returnType);
+        }
 
-                case PRIM_Vec: {
-                    ensureArity(args, 2);
-                    TypePtr t = staticToType(args, 0);
-                    return vecType(t, unsigned(staticToInt(args, 1)));
-                }
+        case PRIM_Array: {
+            ensureArity(args, 2);
+            TypePtr t = staticToType(args, 0);
+            return arrayType(t, unsigned(staticToInt(args, 1)));
+        }
 
-                case PRIM_Tuple: {
-                    vector<TypePtr> types;
-                    for (size_t i = 0; i < args->size(); ++i)
-                        types.push_back(staticToType(args, i));
-                    return tupleType(types);
-                }
+        case PRIM_Vec: {
+            ensureArity(args, 2);
+            TypePtr t = staticToType(args, 0);
+            return vecType(t, unsigned(staticToInt(args, 1)));
+        }
 
-                case PRIM_Union: {
-                    vector<TypePtr> types;
-                    for (size_t i = 0; i < args->size(); ++i)
-                        types.push_back(staticToType(args, i));
-                    return unionType(types);
-                }
+        case PRIM_Tuple: {
+            vector<TypePtr> types;
+            for (size_t i = 0; i < args->size(); ++i)
+                types.push_back(staticToType(args, i));
+            return tupleType(types);
+        }
 
-                case PRIM_Static: {
-                    ensureArity(args, 1);
-                    return staticType(args->values[0]);
-                }
+        case PRIM_Union: {
+            vector<TypePtr> types;
+            for (size_t i = 0; i < args->size(); ++i)
+                types.push_back(staticToType(args, i));
+            return unionType(types);
+        }
 
-                default:
-                    assert(false);
-                    return nullptr;
-            }
-        } else if (constructor->objKind == RECORD_DECL) {
-            RecordDeclPtr x = (RecordDecl *) constructor.ptr();
-            if (x->varParam.ptr()) {
-                if (args->size() < x->params.size())
-                    arityError2(x->params.size(), args->size());
-            } else {
-                ensureArity(args, x->params.size());
-            }
-            return recordType(x, args->values);
-        } else if (constructor->objKind == VARIANT_DECL) {
-            VariantDeclPtr x = (VariantDecl *) constructor.ptr();
-            if (x->varParam.ptr()) {
-                if (args->size() < x->params.size())
-                    arityError2(x->params.size(), args->size());
-            } else {
-                ensureArity(args, x->params.size());
-            }
-            return variantType(x, args->values);
-        } else {
+        case PRIM_Static: {
+            ensureArity(args, 1);
+            return staticType(args->values[0]);
+        }
+
+        default:
             assert(false);
             return nullptr;
         }
+    } else if (constructor->objKind == RECORD_DECL) {
+        RecordDeclPtr x = (RecordDecl *)constructor.ptr();
+        if (x->varParam.ptr()) {
+            if (args->size() < x->params.size())
+                arityError2(x->params.size(), args->size());
+        } else {
+            ensureArity(args, x->params.size());
+        }
+        return recordType(x, args->values);
+    } else if (constructor->objKind == VARIANT_DECL) {
+        VariantDeclPtr x = (VariantDecl *)constructor.ptr();
+        if (x->varParam.ptr()) {
+            if (args->size() < x->params.size())
+                arityError2(x->params.size(), args->size());
+        } else {
+            ensureArity(args, x->params.size());
+        }
+        return variantType(x, args->values);
+    } else {
+        assert(false);
+        return nullptr;
     }
+}
 
-    //
-    // analyzeTypeConstructor
-    //
+//
+// analyzeTypeConstructor
+//
 
-    PVData analyzeTypeConstructor(ObjectPtr obj, MultiStaticPtr args) {
-        TypePtr t = constructType(obj, args);
-        return staticPValue(t.ptr());
-    }
+PVData analyzeTypeConstructor(ObjectPtr obj, MultiStaticPtr args) {
+    TypePtr t = constructType(obj, args);
+    return staticPValue(t.ptr());
+}
 
-    //
-    // analyzeAliasIndexing
-    //
+//
+// analyzeAliasIndexing
+//
+
+MultiPValuePtr analyzeAliasIndexing(GlobalAliasPtr x, ExprListPtr args,
+                                    EnvPtr env) {
+    assert(x->hasParams());
+    MultiStaticPtr params = evaluateMultiStatic(args, env);
+    if (x->varParam.ptr()) {
+        if (params->size() < x->params.size())
+            arityError2(x->params.size(), params->size());
+    } else {
+        ensureArity(params, x->params.size());
+    }
+    EnvPtr bodyEnv = new Env(x->env);
+    for (size_t i = 0; i < x->params.size(); ++i) {
+        addLocal(bodyEnv, x->params[i], params->values[i]);
+    }
+    if (x->varParam.ptr()) {
+        MultiStaticPtr varParams = new MultiStatic();
+        for (size_t i = x->params.size(); i < params->size(); ++i)
+            varParams->add(params->values[i]);
+        addLocal(bodyEnv, x->varParam, varParams.ptr());
+    }
+    evaluatePredicate(x->patternVars, x->predicate, bodyEnv);
+    AnalysisCachingDisabler disabler;
+    return analyzeExpr(x->expr, bodyEnv);
+}
 
-    MultiPValuePtr analyzeAliasIndexing(GlobalAliasPtr x,
-                                        ExprListPtr args,
-                                        EnvPtr env) {
-        assert(x->hasParams());
-        MultiStaticPtr params = evaluateMultiStatic(args, env);
-        if (x->varParam.ptr()) {
-            if (params->size() < x->params.size())
-                arityError2(x->params.size(), params->size());
-        } else {
-            ensureArity(params, x->params.size());
+//
+// analyzeReturn
+//
+
+MultiPValuePtr analyzeReturn(llvm::ArrayRef<uint8_t> returnIsRef,
+                             llvm::ArrayRef<TypePtr> returnTypes) {
+    MultiPValuePtr x = new MultiPValue();
+    for (size_t i = 0; i < returnTypes.size(); ++i) {
+        PVData pv = PVData(returnTypes[i], !returnIsRef[i]);
+        x->values.push_back(pv);
+    }
+    return x.ptr();
+}
+
+//
+// analyzeIntrinsic
+//
+
+// this class is designed to pervert the intrinsic verification code
+// in llvm/Intrinsics.gen, selected by #define GET_INTRINSIC_VERIFIER,
+// into doing type checking and output type propagation for an intrinsic.
+// GET_INTRINSIC_VERIFIER contains a function body that expects to have
+// the following in scope:
+//  - namespace llvm
+//  - int-sized bit mask constants `ExtendedElementVectorType` and
+//  `TruncatedElementVectorType`
+//  - an `llvm::Intrinsic::ID ID`
+//  - an `llvm::FunctionType *IF`. This is unused by our code, so we provide
+//    a dummy IF variable instead
+//  - a function that can be called as
+//    `VerifyIntrinsicPrototype(ID, IF, numReturns, numArgs, ...)`
+//    where the varargs are either values from the llvm::MVT::SimpleValueType
+//    enum signifying the expected return or argument type, or negative values
+//    equal to `~index`, indicating that that argument must be the same type as
+//    the `index`th vararg.
+struct IntrinsicAnalyzer {
+    llvm::Intrinsic::ID ID;
+    llvm::ArrayRef<llvm::Type *> inputTypes;
+
+    string outError;
+    llvm::SmallVector<llvm::Type *, 4> ArgTys;
+
+    IntrinsicAnalyzer(llvm::Intrinsic::ID ID,
+                      llvm::ArrayRef<llvm::Type *> inputTypes)
+        : ID(ID), inputTypes(inputTypes) {}
+
+    static void
+    skipReturnType(llvm::ArrayRef<llvm::Intrinsic::IITDescriptor> &Infos) {
+        using namespace llvm;
+        using namespace Intrinsic;
+        IITDescriptor D = Infos.front();
+        Infos = Infos.slice(1);
+
+        switch (D.Kind) {
+        case IITDescriptor::Void:
+            return;
+        case IITDescriptor::MMX:
+            return;
+        case IITDescriptor::Metadata:
+            return;
+        case IITDescriptor::Float:
+            return;
+        case IITDescriptor::Double:
+            return;
+        case IITDescriptor::Integer:
+            return;
+        case IITDescriptor::Vector:
+            skipReturnType(Infos);
+            return;
+        case IITDescriptor::Pointer:
+            skipReturnType(Infos);
+            return;
+        case IITDescriptor::Struct: {
+            for (unsigned i = 0, e = D.Struct_NumElements; i != e; ++i)
+                skipReturnType(Infos);
+            return;
+        }
+        case IITDescriptor::Argument:
+            return;
+        case IITDescriptor::ExtendArgument:
+            return;
+        case IITDescriptor::TruncArgument:
+            return;
+        default:
+            return;
         }
-        EnvPtr bodyEnv = new Env(x->env);
-        for (size_t i = 0; i < x->params.size(); ++i) {
-            addLocal(bodyEnv, x->params[i], params->values[i]);
+        llvm_unreachable("unhandled");
+    }
+
+    void
+    VerifyIntrinsicType(llvm::Type *Ty,
+                        llvm::ArrayRef<llvm::Intrinsic::IITDescriptor> &Infos,
+                        llvm::raw_string_ostream &errors, size_t ai) {
+        using namespace llvm;
+        using namespace Intrinsic;
+
+        // If we ran out of descriptors, there are too many arguments.
+        if (Infos.empty()) {
+            errors << "intrinsic has too many arguments";
+            return;
         }
-        if (x->varParam.ptr()) {
-            MultiStaticPtr varParams = new MultiStatic();
-            for (size_t i = x->params.size(); i < params->size(); ++i)
-                varParams->add(params->values[i]);
-            addLocal(bodyEnv, x->varParam, varParams.ptr());
-        }
-        evaluatePredicate(x->patternVars, x->predicate, bodyEnv);
-        AnalysisCachingDisabler disabler;
-        return analyzeExpr(x->expr, bodyEnv);
-    }
-
-    //
-    // analyzeReturn
-    //
-
-    MultiPValuePtr analyzeReturn(llvm::ArrayRef<uint8_t> returnIsRef,
-                                 llvm::ArrayRef<TypePtr> returnTypes) {
-        MultiPValuePtr x = new MultiPValue();
-        for (size_t i = 0; i < returnTypes.size(); ++i) {
-            PVData pv = PVData(returnTypes[i], !returnIsRef[i]);
-            x->values.push_back(pv);
-        }
-        return x.ptr();
-    }
-
-    //
-    // analyzeIntrinsic
-    //
-
-    // this class is designed to pervert the intrinsic verification code
-    // in llvm/Intrinsics.gen, selected by #define GET_INTRINSIC_VERIFIER,
-    // into doing type checking and output type propagation for an intrinsic.
-    // GET_INTRINSIC_VERIFIER contains a function body that expects to have
-    // the following in scope:
-    //  - namespace llvm
-    //  - int-sized bit mask constants `ExtendedElementVectorType` and `TruncatedElementVectorType`
-    //  - an `llvm::Intrinsic::ID ID`
-    //  - an `llvm::FunctionType *IF`. This is unused by our code, so we provide
-    //    a dummy IF variable instead
-    //  - a function that can be called as
-    //    `VerifyIntrinsicPrototype(ID, IF, numReturns, numArgs, ...)`
-    //    where the varargs are either values from the llvm::MVT::SimpleValueType enum
-    //    signifying the expected return or argument type, or negative values
-    //    equal to `~index`, indicating that that argument must be the same type as
-    //    the `index`th vararg.
-    struct IntrinsicAnalyzer {
-        llvm::Intrinsic::ID ID;
-        llvm::ArrayRef<llvm::Type *> inputTypes;
-
-        string outError;
-        llvm::SmallVector<llvm::Type *, 4> ArgTys;
-
-        IntrinsicAnalyzer(llvm::Intrinsic::ID ID,
-                          llvm::ArrayRef<llvm::Type *> inputTypes)
-            : ID(ID), inputTypes(inputTypes) {
-        }
-
-        static void skipReturnType(
-            llvm::ArrayRef<llvm::Intrinsic::IITDescriptor> &Infos) {
-            using namespace llvm;
-            using namespace Intrinsic;
-            IITDescriptor D = Infos.front();
-            Infos = Infos.slice(1);
-
-            switch (D.Kind) {
-                case IITDescriptor::Void: return;
-                case IITDescriptor::MMX: return;
-                case IITDescriptor::Metadata: return;
-                case IITDescriptor::Float: return;
-                case IITDescriptor::Double: return;
-                case IITDescriptor::Integer: return;
-                case IITDescriptor::Vector:
-                    skipReturnType(Infos);
-                    return;
-                case IITDescriptor::Pointer:
-                    skipReturnType(Infos);
-                    return;
-                case IITDescriptor::Struct: {
-                    for (unsigned i = 0, e = D.Struct_NumElements; i != e; ++i)
-                        skipReturnType(Infos);
-                    return;
-                }
-                case IITDescriptor::Argument: return;
-                case IITDescriptor::ExtendArgument: return;
-                case IITDescriptor::TruncArgument: return;
-                default: return;
+        IITDescriptor D = Infos.front();
+        Infos = Infos.slice(1);
+
+        switch (D.Kind) {
+        case IITDescriptor::Void:
+            if (!Ty->isVoidTy()) {
+                errors << "intrinsic argument " << (ai + 1)
+                       << " must match LLVM void type, but got ";
+                Ty->print(errors);
+            }
+            return;
+        case IITDescriptor::MMX:
+            if (!Ty->isX86_AMXTy()) {
+                errors << "intrinsic argument " << (ai + 1)
+                       << " must match LLVM MMX type, but got ";
+                Ty->print(errors);
+            }
+            return;
+        case IITDescriptor::Metadata:
+            if (!Ty->isMetadataTy()) {
+                errors << "intrinsic argument " << (ai + 1)
+                       << " must match LLVM metadata type, but got ";
+                Ty->print(errors);
+            }
+            return;
+        case IITDescriptor::Float:
+            if (!Ty->isFloatTy()) {
+                errors << "intrinsic argument " << (ai + 1)
+                       << " must match LLVM float type, but got ";
+                Ty->print(errors);
+            }
+            return;
+        case IITDescriptor::Double:
+            if (!Ty->isDoubleTy()) {
+                errors << "intrinsic argument " << (ai + 1)
+                       << " must match LLVM double type, but got ";
+                Ty->print(errors);
             }
-            llvm_unreachable("unhandled");
+            return;
+        case IITDescriptor::Integer:
+            if (!Ty->isIntegerTy(D.Integer_Width)) {
+                errors << "intrinsic argument " << (ai + 1)
+                       << " must match LLVM i" << D.Integer_Width
+                       << " type, but got ";
+                Ty->print(errors);
+            }
+            return;
+        case IITDescriptor::Vector: {
+            llvm::VectorType *VT = dyn_cast<llvm::VectorType>(Ty);
+            if (VT == nullptr) {
+                errors << "intrinsic argument " << (ai + 1)
+                       << " must be of an LLVM vector type, but got ";
+                Ty->print(errors);
+            } else if (VT->getElementCount() != D.Vector_Width) {
+                errors << "intrinsic argument " << (ai + 1)
+                       << " must be of an LLVM vector type with "
+                       << D.Vector_Width << " elements, but got ";
+                Ty->print(errors);
+            }
+            VerifyIntrinsicType(VT->getElementType(), Infos, errors, ai);
+            return;
+        }
+        case IITDescriptor::Pointer: {
+            llvm::PointerType *PT = dyn_cast<llvm::PointerType>(Ty);
+            if (PT == 0) {
+                errors << "intrinsic argument " << (ai + 1)
+                       << " must be of an LLVM pointer type, but got ";
+                Ty->print(errors);
+            } else if (PT->getAddressSpace() != D.Pointer_AddressSpace) {
+                errors << "intrinsic argument " << (ai + 1)
+                       << " must be of an LLVM pointer type with"
+                       << D.Pointer_AddressSpace << " address space, but got ";
+                Ty->print(errors);
+            }
+            VerifyIntrinsicType(PT->getElementType(), Infos, errors, ai);
+            return;
         }
 
-        void VerifyIntrinsicType(
-            llvm::Type *Ty,
-            llvm::ArrayRef<llvm::Intrinsic::IITDescriptor> &Infos,
-            llvm::raw_string_ostream &errors, size_t ai) {
-            using namespace llvm;
-            using namespace Intrinsic;
+        case IITDescriptor::Struct: {
+            llvm::StructType *ST = dyn_cast<llvm::StructType>(Ty);
+            if (ST == 0) {
+                errors << "intrinsic argument " << (ai + 1)
+                       << " must be of an LLVM struct type, but got ";
+                Ty->print(errors);
+            } else if (ST->getNumElements() != D.Struct_NumElements) {
+                errors << "intrinsic argument " << (ai + 1)
+                       << " must be of an LLVM struct type with "
+                       << D.Struct_NumElements << " elements, but got ";
+                Ty->print(errors);
+            }
+            for (unsigned i = 0, e = D.Struct_NumElements; i != e; ++i)
+                VerifyIntrinsicType(ST->getElementType(i), Infos, errors, ai);
+            return;
+        }
 
-            // If we ran out of descriptors, there are too many arguments.
-            if (Infos.empty()) {
-                errors << "intrinsic has too many arguments";
+        case IITDescriptor::Argument:
+            // Two cases here - If this is the second occurrence of an argument,
+            // verify that the later instance matches the previous instance.
+            if (D.getArgumentNumber() < ArgTys.size()) {
+                if (Ty != ArgTys[D.getArgumentNumber()]) {
+                    errors << "intrinsic argument " << (ai + 1)
+                           << " must match LLVM type of argument "
+                           << D.getArgumentNumber() << ", which is ";
+                    ArgTys[D.getArgumentNumber()]->print(errors);
+                    errors << ", but got ";
+                    Ty->print(errors);
+                }
                 return;
             }
-            IITDescriptor D = Infos.front();
-            Infos = Infos.slice(1);
-
-            switch (D.Kind) {
-                case IITDescriptor::Void:
-                    if (!Ty->isVoidTy()) {
-                        errors << "intrinsic argument " << (ai + 1)
-                                << " must match LLVM void type, but got ";
-                        Ty->print(errors);
-                    }
-                    return;
-                case IITDescriptor::MMX:
-                    if (!Ty->isX86_AMXTy()) {
-                        errors << "intrinsic argument " << (ai + 1)
-                                << " must match LLVM MMX type, but got ";
-                        Ty->print(errors);
-                    }
-                    return;
-                case IITDescriptor::Metadata:
-                    if (!Ty->isMetadataTy()) {
-                        errors << "intrinsic argument " << (ai + 1)
-                                << " must match LLVM metadata type, but got ";
-                        Ty->print(errors);
-                    }
-                    return;
-                case IITDescriptor::Float:
-                    if (!Ty->isFloatTy()) {
-                        errors << "intrinsic argument " << (ai + 1)
-                                << " must match LLVM float type, but got ";
-                        Ty->print(errors);
-                    }
-                    return;
-                case IITDescriptor::Double:
-                    if (!Ty->isDoubleTy()) {
-                        errors << "intrinsic argument " << (ai + 1)
-                                << " must match LLVM double type, but got ";
-                        Ty->print(errors);
-                    }
-                    return;
-                case IITDescriptor::Integer:
-                    if (!Ty->isIntegerTy(D.Integer_Width)) {
-                        errors << "intrinsic argument " << (ai + 1)
-                                << " must match LLVM i" << D.Integer_Width
-                                << " type, but got ";
-                        Ty->print(errors);
-                    }
-                    return;
-                case IITDescriptor::Vector: {
-                    llvm::VectorType *VT = dyn_cast<llvm::VectorType>(Ty);
-                    if (VT == nullptr) {
-                        errors << "intrinsic argument " << (ai + 1)
-                                << " must be of an LLVM vector type, but got ";
-                        Ty->print(errors);
-                    } else if (VT->getElementCount() != D.Vector_Width) {
-                        errors << "intrinsic argument " << (ai + 1)
-                                << " must be of an LLVM vector type with "
-                                << D.Vector_Width
-                                << " elements, but got ";
-                        Ty->print(errors);
-                    }
-                    VerifyIntrinsicType(VT->getElementType(), Infos, errors, ai);
-                    return;
+
+            // Otherwise, if this is the first instance of an argument, record
+            // it and verify the "Any" kind.
+            assert(D.getArgumentNumber() == ArgTys.size() &&
+                   "Table consistency error");
+            ArgTys.push_back(Ty);
+
+            switch (D.getArgumentKind()) {
+            case IITDescriptor::AK_AnyInteger:
+                if (!Ty->isIntOrIntVectorTy()) {
+                    errors << "intrinsic argument " << (ai + 1)
+                           << " must be of an LLVM integer type, but got ";
+                    Ty->print(errors);
                 }
-                case IITDescriptor::Pointer: {
-                    llvm::PointerType *PT = dyn_cast<llvm::PointerType>(Ty);
-                    if (PT == 0) {
-                        errors << "intrinsic argument " << (ai + 1)
-                                << " must be of an LLVM pointer type, but got ";
-                        Ty->print(errors);
-                    } else if (PT->getAddressSpace() != D.Pointer_AddressSpace) {
-                        errors << "intrinsic argument " << (ai + 1)
-                                << " must be of an LLVM pointer type with"
-                                << D.Pointer_AddressSpace
-                                << " address space, but got ";
-                        Ty->print(errors);
-                    }
-                    VerifyIntrinsicType(PT->getElementType(), Infos, errors, ai);
-                    return;
+                return;
+            case IITDescriptor::AK_AnyFloat:
+                if (!Ty->isFPOrFPVectorTy()) {
+                    errors
+                        << "intrinsic argument " << (ai + 1)
+                        << " must be of an LLVM floating point type, but got ";
+                    Ty->print(errors);
                 }
-
-                case IITDescriptor::Struct: {
-                    llvm::StructType *ST = dyn_cast<llvm::StructType>(Ty);
-                    if (ST == 0) {
-                        errors << "intrinsic argument " << (ai + 1)
-                                << " must be of an LLVM struct type, but got ";
-                        Ty->print(errors);
-                    } else if (ST->getNumElements() != D.Struct_NumElements) {
-                        errors << "intrinsic argument " << (ai + 1)
-                                << " must be of an LLVM struct type with "
-                                << D.Struct_NumElements
-                                << " elements, but got ";
-                        Ty->print(errors);
-                    }
-                    for (unsigned i = 0, e = D.Struct_NumElements; i != e; ++i)
-                        VerifyIntrinsicType(ST->getElementType(i), Infos, errors, ai);
-                    return;
+                return;
+            case IITDescriptor::AK_AnyVector:
+                if (!isa<llvm::VectorType>(Ty)) {
+                    errors << "intrinsic argument " << (ai + 1)
+                           << " must be of an LLVM vector type, but got ";
+                    Ty->print(errors);
                 }
+                return;
+            case IITDescriptor::AK_AnyPointer:
+                if (!isa<llvm::PointerType>(Ty)) {
+                    errors << "intrinsic argument " << (ai + 1)
+                           << " must be of an LLVM pointer type, but got ";
+                    Ty->print(errors);
+                }
+                return;
+            default:
+                return;
+            }
+            llvm_unreachable("all argument kinds not covered");
 
-                case IITDescriptor::Argument:
-                    // Two cases here - If this is the second occurrence of an argument, verify
-                    // that the later instance matches the previous instance.
-                    if (D.getArgumentNumber() < ArgTys.size()) {
-                        if (Ty != ArgTys[D.getArgumentNumber()]) {
-                            errors << "intrinsic argument " << (ai + 1)
-                                    << " must match LLVM type of argument "
-                                    << D.getArgumentNumber()
-                                    << ", which is ";
-                            ArgTys[D.getArgumentNumber()]->print(errors);
-                            errors << ", but got ";
-                            Ty->print(errors);
-                        }
-                        return;
-                    }
+        case IITDescriptor::ExtendArgument:
+            // This may only be used when referring to a previous vector
+            // argument.
+            if (D.getArgumentNumber() >= ArgTys.size() ||
+                !isa<llvm::VectorType>(ArgTys[D.getArgumentNumber()]) ||
+                llvm::VectorType::getExtendedElementVectorType(
+                    cast<llvm::VectorType>(ArgTys[D.getArgumentNumber()])) !=
+                    Ty) {
+                errors << "intrinsic argument " << (ai + 1)
+                       << " must be of an LLVM vector type, but got ";
+                Ty->print(errors);
+            }
+            return;
 
-                    // Otherwise, if this is the first instance of an argument, record it and
-                    // verify the "Any" kind.
-                    assert(D.getArgumentNumber() == ArgTys.size() && "Table consistency error");
-                    ArgTys.push_back(Ty);
-
-                    switch (D.getArgumentKind()) {
-                        case IITDescriptor::AK_AnyInteger:
-                            if (!Ty->isIntOrIntVectorTy()) {
-                                errors << "intrinsic argument " << (ai + 1)
-                                        << " must be of an LLVM integer type, but got ";
-                                Ty->print(errors);
-                            }
-                            return;
-                        case IITDescriptor::AK_AnyFloat:
-                            if (!Ty->isFPOrFPVectorTy()) {
-                                errors << "intrinsic argument " << (ai + 1)
-                                        << " must be of an LLVM floating point type, but got ";
-                                Ty->print(errors);
-                            }
-                            return;
-                        case IITDescriptor::AK_AnyVector:
-                            if (!isa<llvm::VectorType>(Ty)) {
-                                errors << "intrinsic argument " << (ai + 1)
-                                        << " must be of an LLVM vector type, but got ";
-                                Ty->print(errors);
-                            }
-                            return;
-                        case IITDescriptor::AK_AnyPointer:
-                            if (!isa<llvm::PointerType>(Ty)) {
-                                errors << "intrinsic argument " << (ai + 1)
-                                        << " must be of an LLVM pointer type, but got ";
-                                Ty->print(errors);
-                            }
-                            return;
-                        default: return;
-                    }
-                    llvm_unreachable("all argument kinds not covered");
-
-                case IITDescriptor::ExtendArgument:
-                    // This may only be used when referring to a previous vector argument.
-                    if (D.getArgumentNumber() >= ArgTys.size() ||
-                        !isa<llvm::VectorType>(ArgTys[D.getArgumentNumber()]) ||
-                        llvm::VectorType::getExtendedElementVectorType(
-                            cast<llvm::VectorType>(
-                                ArgTys[D.getArgumentNumber()])) != Ty) {
-                        errors << "intrinsic argument " << (ai + 1)
-                                << " must be of an LLVM vector type, but got ";
-                        Ty->print(errors);
-                    }
-                    return;
-
-                case IITDescriptor::TruncArgument:
-                    // This may only be used when referring to a previous vector argument.
-                    if (D.getArgumentNumber() >= ArgTys.size() ||
-                        !isa<llvm::VectorType>(ArgTys[D.getArgumentNumber()]) ||
-                        llvm::VectorType::getTruncatedElementVectorType(
-                            cast<llvm::VectorType>(
-                                ArgTys[D.getArgumentNumber()])) != Ty) {
-                        errors << "intrinsic argument " << (ai + 1)
-                                << " must be of an LLVM vector type, but got ";
-                        Ty->print(errors);
-                    }
-                    return;
-                default: return;
+        case IITDescriptor::TruncArgument:
+            // This may only be used when referring to a previous vector
+            // argument.
+            if (D.getArgumentNumber() >= ArgTys.size() ||
+                !isa<llvm::VectorType>(ArgTys[D.getArgumentNumber()]) ||
+                llvm::VectorType::getTruncatedElementVectorType(
+                    cast<llvm::VectorType>(ArgTys[D.getArgumentNumber()])) !=
+                    Ty) {
+                errors << "intrinsic argument " << (ai + 1)
+                       << " must be of an LLVM vector type, but got ";
+                Ty->print(errors);
             }
-            llvm_unreachable("unhandled");
+            return;
+        default:
+            return;
         }
+        llvm_unreachable("unhandled");
+    }
 
-        void run() {
-            using namespace llvm;
+    void run() {
+        using namespace llvm;
 
-            llvm::raw_string_ostream errors(outError);
+        llvm::raw_string_ostream errors(outError);
 
-            SmallVector<Intrinsic::IITDescriptor, 8> Table;
-            getIntrinsicInfoTableEntries(ID, Table);
-            ArrayRef<Intrinsic::IITDescriptor> TableRef = Table;
+        SmallVector<Intrinsic::IITDescriptor, 8> Table;
+        getIntrinsicInfoTableEntries(ID, Table);
+        ArrayRef<Intrinsic::IITDescriptor> TableRef = Table;
 
-            skipReturnType(TableRef);
+        skipReturnType(TableRef);
 
-            for (unsigned i = 0, e = inputTypes.size(); i != e; ++i) {
-                VerifyIntrinsicType(inputTypes[i], TableRef, errors, i);
-            }
-            if (!TableRef.empty()) {
-                errors << "intrinsic has too few arguments";
-            }
+        for (unsigned i = 0, e = inputTypes.size(); i != e; ++i) {
+            VerifyIntrinsicType(inputTypes[i], TableRef, errors, i);
+        }
+        if (!TableRef.empty()) {
+            errors << "intrinsic has too few arguments";
         }
-
-        bool ok() const { return outError.empty(); }
-    };
-
-    static TypePtr intrinsicOutputType(llvm::Type *ty) {
-        if (llvm::IntegerType *intTy = llvm::dyn_cast<llvm::IntegerType>(ty)) {
-            switch (intTy->getBitWidth()) {
-                case 8:
-                    return uint8Type;
-                case 16:
-                    return uint16Type;
-                case 32:
-                    return uint32Type;
-                case 64:
-                    return uint64Type;
-                case 128:
-                    return uint128Type;
-                default:
-                    return nullptr;
-            }
-        } else if (ty == llvm::Type::getFloatTy(ty->getContext()))
-            return float32Type;
-        else if (ty == llvm::Type::getDoubleTy(ty->getContext()))
-            return float64Type;
-        else if (auto *pointerTy = llvm::dyn_cast<llvm::PointerType>(ty)) {
-            TypePtr baseType = intrinsicOutputType(pointerTy->getPointerElementType());
-            if (baseType != nullptr)
-                return pointerType(baseType);
-            else
-                return nullptr;
-        } else if (auto *vectorTy = llvm::dyn_cast<llvm::VectorType>(ty)) {
-            TypePtr baseType = intrinsicOutputType(vectorTy->getElementType());
-            if (baseType != nullptr)
-                return vecType(baseType, vectorTy->getNumElements());
-            else
-                return nullptr;
-        } else
-            return nullptr;
     }
 
-    static MultiPValuePtr intrinsicOutputTypes(llvm::Function *instance) {
-        MultiPValuePtr ret = new MultiPValue();
-        llvm::Type *ty = instance->getFunctionType()->getReturnType();
-
-        if (ty->isVoidTy())
-            return ret;
-
-        TypePtr outType = intrinsicOutputType(ty);
-        if (outType == nullptr) {
-            std::string errorBuf;
-            llvm::raw_string_ostream errors(errorBuf);
-            errors << "intrinsic returning LLVM type ";
-            ty->print(errors);
-            errors << " not yet supported";
-            error(errors.str());
+    bool ok() const { return outError.empty(); }
+};
+
+static TypePtr intrinsicOutputType(llvm::Type *ty) {
+    if (llvm::IntegerType *intTy = llvm::dyn_cast<llvm::IntegerType>(ty)) {
+        switch (intTy->getBitWidth()) {
+        case 8:
+            return uint8Type;
+        case 16:
+            return uint16Type;
+        case 32:
+            return uint32Type;
+        case 64:
+            return uint64Type;
+        case 128:
+            return uint128Type;
+        default:
+            return nullptr;
         }
+    } else if (ty == llvm::Type::getFloatTy(ty->getContext()))
+        return float32Type;
+    else if (ty == llvm::Type::getDoubleTy(ty->getContext()))
+        return float64Type;
+    else if (auto *pointerTy = llvm::dyn_cast<llvm::PointerType>(ty)) {
+        TypePtr baseType =
+            intrinsicOutputType(pointerTy->getPointerElementType());
+        if (baseType != nullptr)
+            return pointerType(baseType);
+        else
+            return nullptr;
+    } else if (auto *vectorTy = llvm::dyn_cast<llvm::VectorType>(ty)) {
+        TypePtr baseType = intrinsicOutputType(vectorTy->getElementType());
+        if (baseType != nullptr)
+            return vecType(baseType, vectorTy->getNumElements());
+        else
+            return nullptr;
+    } else
+        return nullptr;
+}
 
-        ret->add(PVData(outType, true));
-        return ret;
-    }
+static MultiPValuePtr intrinsicOutputTypes(llvm::Function *instance) {
+    MultiPValuePtr ret = new MultiPValue();
+    llvm::Type *ty = instance->getFunctionType()->getReturnType();
 
-    static MultiPValuePtr analyzeIntrinsic(IntrinsicSymbol *intrin, MultiPValue *args) {
-        vector<TypePtr> argsKey;
-        args->toArgsKey(&argsKey);
+    if (ty->isVoidTy())
+        return ret;
 
-        map<vector<TypePtr>, IntrinsicInstance>::const_iterator instancePair
-                = intrin->instances.find(argsKey);
-        if (instancePair != intrin->instances.end()) {
-            IntrinsicInstance const &instance = instancePair->second;
-            if (!instance.error.empty()) {
-                error(instance.error);
-                return nullptr;
-            } else {
-                assert(instance.function != nullptr);
-                return instance.outputTypes;
-            }
-        } else {
-            vector<llvm::Type *> inputTypes;
-            for (vector<TypePtr>::const_iterator i = argsKey.begin(), end = argsKey.end();
-                 i != end;
-                 ++i) {
-                Type *type = i->ptr();
-                if (type->typeKind == STATIC_TYPE) {
-                    StaticType *staticType = (StaticType *) type;
-                    if (staticType->obj->objKind != VALUE_HOLDER)
-                        // XXX defer error for analyzeCallDefined
-                        error("intrinsic static arguments must be boolean or integer statics");
-                    ValueHolder *vh = (ValueHolder *) staticType->obj.ptr();
-                    type = vh->type.ptr();
-                }
-                inputTypes.push_back(llvmType(type));
-            }
-            IntrinsicAnalyzer ia(intrin->id, inputTypes);
-            ia.run();
-            IntrinsicInstance &instance = intrin->instances[argsKey];
-            if (ia.outError.empty()) {
-                instance.function = llvm::Intrinsic::getOrInsertDeclaration(llvmModule,
-                                                                            intrin->id,
-                                                                            ia.ArgTys);
-                instance.outputTypes = intrinsicOutputTypes(instance.function);
-                return instance.outputTypes;
-            } else {
-                instance.function = nullptr;
-                instance.outputTypes = nullptr;
-                instance.error.swap(ia.outError);
-                error(instance.error); // XXX factor this out and use in analyzeCallDefined
-                return nullptr;
-            }
-        }
+    TypePtr outType = intrinsicOutputType(ty);
+    if (outType == nullptr) {
+        std::string errorBuf;
+        llvm::raw_string_ostream errors(errorBuf);
+        errors << "intrinsic returning LLVM type ";
+        ty->print(errors);
+        errors << " not yet supported";
+        error(errors.str());
     }
 
-    //
-    // analyzeCallExpr
-    //
+    ret->add(PVData(outType, true));
+    return ret;
+}
 
-    MultiPValuePtr analyzeCallExpr(ExprPtr callable,
-                                   ExprListPtr args,
-                                   EnvPtr env) {
-        PVData pv = analyzeOne(callable, env);
-        if (!pv.ok())
+static MultiPValuePtr analyzeIntrinsic(IntrinsicSymbol *intrin,
+                                       MultiPValue *args) {
+    vector<TypePtr> argsKey;
+    args->toArgsKey(&argsKey);
+
+    map<vector<TypePtr>, IntrinsicInstance>::const_iterator instancePair =
+        intrin->instances.find(argsKey);
+    if (instancePair != intrin->instances.end()) {
+        IntrinsicInstance const &instance = instancePair->second;
+        if (!instance.error.empty()) {
+            error(instance.error);
             return nullptr;
-        switch (pv.type->typeKind) {
-            case CODE_POINTER_TYPE: {
-                MultiPValuePtr mpv = analyzeMulti(args, env, 0);
-                if (!mpv)
-                    return nullptr;
-                return analyzeCallPointer(pv, mpv);
-            }
-            default:
-                break;
+        } else {
+            assert(instance.function != nullptr);
+            return instance.outputTypes;
         }
-        ObjectPtr obj = unwrapStaticType(pv.type);
-        if (!obj) {
-            ExprListPtr args2 = new ExprList(callable);
-            args2->add(args);
-            return analyzeCallExpr(operator_expr_call(), args2, env);
+    } else {
+        vector<llvm::Type *> inputTypes;
+        for (vector<TypePtr>::const_iterator i = argsKey.begin(),
+                                             end = argsKey.end();
+             i != end; ++i) {
+            Type *type = i->ptr();
+            if (type->typeKind == STATIC_TYPE) {
+                StaticType *staticType = (StaticType *)type;
+                if (staticType->obj->objKind != VALUE_HOLDER)
+                    // XXX defer error for analyzeCallDefined
+                    error("intrinsic static arguments must be boolean or "
+                          "integer statics");
+                ValueHolder *vh = (ValueHolder *)staticType->obj.ptr();
+                type = vh->type.ptr();
+            }
+            inputTypes.push_back(llvmType(type));
         }
+        IntrinsicAnalyzer ia(intrin->id, inputTypes);
+        ia.run();
+        IntrinsicInstance &instance = intrin->instances[argsKey];
+        if (ia.outError.empty()) {
+            instance.function = llvm::Intrinsic::getOrInsertDeclaration(
+                llvmModule, intrin->id, ia.ArgTys);
+            instance.outputTypes = intrinsicOutputTypes(instance.function);
+            return instance.outputTypes;
+        } else {
+            instance.function = nullptr;
+            instance.outputTypes = nullptr;
+            instance.error.swap(ia.outError);
+            error(instance.error); // XXX factor this out and use in
+                                   // analyzeCallDefined
+            return nullptr;
+        }
+    }
+}
 
-        switch (obj->objKind) {
-            case TYPE:
-            case RECORD_DECL:
-            case VARIANT_DECL:
-            case PROCEDURE:
-            case GLOBAL_ALIAS:
-            case PRIM_OP: {
-                if ((obj->objKind == PRIM_OP) && !isOverloadablePrimOp(obj)) {
-                    PrimOpPtr x = (PrimOp *) obj.ptr();
-                    MultiPValuePtr mpv = analyzeMulti(args, env, 0);
-                    if (!mpv)
-                        return nullptr;
-                    return analyzePrimOp(x, mpv);
-                }
-                vector<unsigned> dispatchIndices;
-                MultiPValuePtr mpv = analyzeMultiArgs(args, env, dispatchIndices);
-                if (!mpv)
-                    return nullptr;
-                if (dispatchIndices.size() > 0) {
-                    return analyzeDispatch(obj, mpv, dispatchIndices);
-                }
-                CompileContextPusher pusher(obj, mpv->values);
-                InvokeEntry *entry =
-                        analyzeCallable(obj, mpv->values);
-                if (entry->callByName)
-                    return analyzeCallByName(entry, callable, args, env);
-                if (!entry->analyzed)
-                    return nullptr;
-                return analyzeReturn(entry->returnIsRef, entry->returnTypes);
-            }
-
-            case INTRINSIC: {
-                IntrinsicSymbol *intrin = (IntrinsicSymbol *) obj.ptr();
-                MultiPValuePtr mpv = analyzeMulti(args, env, 0);
-                if (!mpv)
-                    return nullptr;
-                return analyzeIntrinsic(intrin, mpv.ptr());
-            }
-
-            default:
-                error("invalid call expression");
+//
+// analyzeCallExpr
+//
+
+MultiPValuePtr analyzeCallExpr(ExprPtr callable, ExprListPtr args, EnvPtr env) {
+    PVData pv = analyzeOne(callable, env);
+    if (!pv.ok())
+        return nullptr;
+    switch (pv.type->typeKind) {
+    case CODE_POINTER_TYPE: {
+        MultiPValuePtr mpv = analyzeMulti(args, env, 0);
+        if (!mpv)
+            return nullptr;
+        return analyzeCallPointer(pv, mpv);
+    }
+    default:
+        break;
+    }
+    ObjectPtr obj = unwrapStaticType(pv.type);
+    if (!obj) {
+        ExprListPtr args2 = new ExprList(callable);
+        args2->add(args);
+        return analyzeCallExpr(operator_expr_call(), args2, env);
+    }
+
+    switch (obj->objKind) {
+    case TYPE:
+    case RECORD_DECL:
+    case VARIANT_DECL:
+    case PROCEDURE:
+    case GLOBAL_ALIAS:
+    case PRIM_OP: {
+        if ((obj->objKind == PRIM_OP) && !isOverloadablePrimOp(obj)) {
+            PrimOpPtr x = (PrimOp *)obj.ptr();
+            MultiPValuePtr mpv = analyzeMulti(args, env, 0);
+            if (!mpv)
                 return nullptr;
+            return analyzePrimOp(x, mpv);
+        }
+        vector<unsigned> dispatchIndices;
+        MultiPValuePtr mpv = analyzeMultiArgs(args, env, dispatchIndices);
+        if (!mpv)
+            return nullptr;
+        if (dispatchIndices.size() > 0) {
+            return analyzeDispatch(obj, mpv, dispatchIndices);
         }
+        CompileContextPusher pusher(obj, mpv->values);
+        InvokeEntry *entry = analyzeCallable(obj, mpv->values);
+        if (entry->callByName)
+            return analyzeCallByName(entry, callable, args, env);
+        if (!entry->analyzed)
+            return nullptr;
+        return analyzeReturn(entry->returnIsRef, entry->returnTypes);
     }
-    
-    //
-    // analyzeDispatch
-    //
-
-    PVData analyzeDispatchIndex(PVData const &pv, unsigned tag) {
-        MultiPValuePtr args = new MultiPValue();
-        args->add(pv);
-        ValueHolderPtr vh = intToValueHolder((int) tag);
-        args->add(staticPValue(vh.ptr()));
-
-        MultiPValuePtr out =
-                analyzeCallValue(staticPValue(operator_dispatchIndex()), args);
-        ensureArity(out, 1);
-        return out->values[0];
-    }
-
-    MultiPValuePtr analyzeDispatch(ObjectPtr obj,
-                                   MultiPValuePtr args,
-                                   llvm::ArrayRef<unsigned> dispatchIndices) {
-        if (dispatchIndices.empty())
-            return analyzeCallValue(staticPValue(obj), args);
-
-        CompileContextPusher pusher(obj, args->values, dispatchIndices);
-
-        unsigned index = dispatchIndices[0];
-        vector<unsigned> dispatchIndices2(dispatchIndices.begin() + 1,
-                                          dispatchIndices.end());
-        MultiPValuePtr prefix = new MultiPValue();
-        for (unsigned i = 0; i < index; ++i)
-            prefix->add(args->values[i]);
-        MultiPValuePtr suffix = new MultiPValue();
-        for (unsigned i = index + 1; i < args->size(); ++i)
-            suffix->add(args->values[i]);
-        PVData const &pvDispatch = args->values[index];
-        unsigned memberCount = dispatchTagCount(pvDispatch.type);
-
-        MultiPValuePtr result;
-        vector<TypePtr> dispatchedTypes;
-        for (unsigned i = 0; i < memberCount; ++i) {
-            MultiPValuePtr args2 = new MultiPValue();
-            args2->add(prefix);
-            PVData pvDispatch2 = analyzeDispatchIndex(pvDispatch, i);
-            args2->add(pvDispatch2);
-            args2->add(suffix);
-            MultiPValuePtr result2 = analyzeDispatch(obj, args2, dispatchIndices2);
-            if (!result2)
-                return nullptr;
-            if (!result) {
-                result = result2;
+
+    case INTRINSIC: {
+        IntrinsicSymbol *intrin = (IntrinsicSymbol *)obj.ptr();
+        MultiPValuePtr mpv = analyzeMulti(args, env, 0);
+        if (!mpv)
+            return nullptr;
+        return analyzeIntrinsic(intrin, mpv.ptr());
+    }
+
+    default:
+        error("invalid call expression");
+        return nullptr;
+    }
+}
+
+//
+// analyzeDispatch
+//
+
+PVData analyzeDispatchIndex(PVData const &pv, unsigned tag) {
+    MultiPValuePtr args = new MultiPValue();
+    args->add(pv);
+    ValueHolderPtr vh = intToValueHolder((int)tag);
+    args->add(staticPValue(vh.ptr()));
+
+    MultiPValuePtr out =
+        analyzeCallValue(staticPValue(operator_dispatchIndex()), args);
+    ensureArity(out, 1);
+    return out->values[0];
+}
+
+MultiPValuePtr analyzeDispatch(ObjectPtr obj, MultiPValuePtr args,
+                               llvm::ArrayRef<unsigned> dispatchIndices) {
+    if (dispatchIndices.empty())
+        return analyzeCallValue(staticPValue(obj), args);
+
+    CompileContextPusher pusher(obj, args->values, dispatchIndices);
+
+    unsigned index = dispatchIndices[0];
+    vector<unsigned> dispatchIndices2(dispatchIndices.begin() + 1,
+                                      dispatchIndices.end());
+    MultiPValuePtr prefix = new MultiPValue();
+    for (unsigned i = 0; i < index; ++i)
+        prefix->add(args->values[i]);
+    MultiPValuePtr suffix = new MultiPValue();
+    for (unsigned i = index + 1; i < args->size(); ++i)
+        suffix->add(args->values[i]);
+    PVData const &pvDispatch = args->values[index];
+    unsigned memberCount = dispatchTagCount(pvDispatch.type);
+
+    MultiPValuePtr result;
+    vector<TypePtr> dispatchedTypes;
+    for (unsigned i = 0; i < memberCount; ++i) {
+        MultiPValuePtr args2 = new MultiPValue();
+        args2->add(prefix);
+        PVData pvDispatch2 = analyzeDispatchIndex(pvDispatch, i);
+        args2->add(pvDispatch2);
+        args2->add(suffix);
+        MultiPValuePtr result2 = analyzeDispatch(obj, args2, dispatchIndices2);
+        if (!result2)
+            return nullptr;
+        if (!result) {
+            result = result2;
+        } else {
+            bool ok = true;
+            if (result->size() != result2->size()) {
+                ok = false;
             } else {
-                bool ok = true;
-                if (result->size() != result2->size()) {
-                    ok = false;
-                } else {
-                    for (unsigned j = 0; j < result2->size(); ++j) {
-                        PVData const &pv = result->values[j];
-                        PVData const &pv2 = result2->values[j];
-                        if (pv.type != pv2.type) {
-                            ok = false;
-                            break;
-                        }
-                        if (pv.isRValue != pv2.isRValue) {
-                            ok = false;
-                            break;
-                        }
-                    }
-                }
-                if (!ok) {
-                    string buf;
-                    llvm::raw_string_ostream ostr(buf);
-                    ostr << "mismatching result types with dispatch";
-                    ostr << "\n    expected ";
-                    unsigned j = 0;
-                    for (; j < result->size(); ++j) {
-                        if (j != 0) ostr << ", ";
-                        ostr << result->values[j].type;
-                    }
-                    ostr << "\n        from dispatching to ";
-                    for (j = 0; j < dispatchedTypes.size(); ++j) {
-                        if (j != 0) ostr << ", ";
-                        ostr << dispatchedTypes[j];
+                for (unsigned j = 0; j < result2->size(); ++j) {
+                    PVData const &pv = result->values[j];
+                    PVData const &pv2 = result2->values[j];
+                    if (pv.type != pv2.type) {
+                        ok = false;
+                        break;
                     }
-                    ostr << "\n     but got ";
-                    for (j = 0; j < result->size(); ++j) {
-                        if (j != 0) ostr << ", ";
-                        ostr << result2->values[j].type;
+                    if (pv.isRValue != pv2.isRValue) {
+                        ok = false;
+                        break;
                     }
-                    ostr << "\n        when dispatching to " << pvDispatch2.type;
-                    argumentError(index, ostr.str());
                 }
             }
-            dispatchedTypes.push_back(pvDispatch2.type);
-        }
-        assert(result.ptr());
-        return result;
-    }
-
-    //
-    // analyzeCallValue
-    //
-
-    MultiPValuePtr analyzeCallValue(PVData const &callable,
-                                    MultiPValuePtr args) {
-        switch (callable.type->typeKind) {
-            case CODE_POINTER_TYPE:
-                return analyzeCallPointer(callable, args);
-            default:
-                break;
-        }
-        ObjectPtr obj = unwrapStaticType(callable.type);
-        if (!obj) {
-            MultiPValuePtr args2 = new MultiPValue(callable);
-            args2->add(args);
-            return analyzeCallValue(staticPValue(operator_call()), args2);
-        }
-
-        switch (obj->objKind) {
-            case TYPE:
-            case RECORD_DECL:
-            case VARIANT_DECL:
-            case PROCEDURE:
-            case GLOBAL_ALIAS:
-            case PRIM_OP: {
-                if ((obj->objKind == PRIM_OP) && !isOverloadablePrimOp(obj)) {
-                    PrimOpPtr x = (PrimOp *) obj.ptr();
-                    return analyzePrimOp(x, args);
+            if (!ok) {
+                string buf;
+                llvm::raw_string_ostream ostr(buf);
+                ostr << "mismatching result types with dispatch";
+                ostr << "\n    expected ";
+                unsigned j = 0;
+                for (; j < result->size(); ++j) {
+                    if (j != 0)
+                        ostr << ", ";
+                    ostr << result->values[j].type;
                 }
-                CompileContextPusher pusher(obj, args->values);
-                InvokeEntry *entry =
-                        analyzeCallable(obj, args->values);
-                if (entry->callByName) {
-                    ExprListPtr objectExprs = new ExprList();
-                    for (PVData const *i = args->values.begin(), *end = args->values.end();
-                         i < end;
-                         ++i) {
-                        objectExprs->add(new ObjectExpr(new PValue(*i)));
-                    }
-                    ExprPtr callableObject = new ObjectExpr(new PValue(callable));
-                    callableObject->location = topLocation();
-                    return analyzeCallByName(entry, callableObject, objectExprs, new Env());
-                } else if (!entry->analyzed)
-                    return nullptr;
-                else
-                    return analyzeReturn(entry->returnIsRef, entry->returnTypes);
+                ostr << "\n        from dispatching to ";
+                for (j = 0; j < dispatchedTypes.size(); ++j) {
+                    if (j != 0)
+                        ostr << ", ";
+                    ostr << dispatchedTypes[j];
+                }
+                ostr << "\n     but got ";
+                for (j = 0; j < result->size(); ++j) {
+                    if (j != 0)
+                        ostr << ", ";
+                    ostr << result2->values[j].type;
+                }
+                ostr << "\n        when dispatching to " << pvDispatch2.type;
+                argumentError(index, ostr.str());
             }
+        }
+        dispatchedTypes.push_back(pvDispatch2.type);
+    }
+    assert(result.ptr());
+    return result;
+}
 
-            case INTRINSIC: {
-                IntrinsicSymbol *intrin = (IntrinsicSymbol *) obj.ptr();
-                return analyzeIntrinsic(intrin, args.ptr());
-            }
+//
+// analyzeCallValue
+//
 
-            default:
-                error("invalid call expression");
-                return nullptr;
+MultiPValuePtr analyzeCallValue(PVData const &callable, MultiPValuePtr args) {
+    switch (callable.type->typeKind) {
+    case CODE_POINTER_TYPE:
+        return analyzeCallPointer(callable, args);
+    default:
+        break;
+    }
+    ObjectPtr obj = unwrapStaticType(callable.type);
+    if (!obj) {
+        MultiPValuePtr args2 = new MultiPValue(callable);
+        args2->add(args);
+        return analyzeCallValue(staticPValue(operator_call()), args2);
+    }
+
+    switch (obj->objKind) {
+    case TYPE:
+    case RECORD_DECL:
+    case VARIANT_DECL:
+    case PROCEDURE:
+    case GLOBAL_ALIAS:
+    case PRIM_OP: {
+        if ((obj->objKind == PRIM_OP) && !isOverloadablePrimOp(obj)) {
+            PrimOpPtr x = (PrimOp *)obj.ptr();
+            return analyzePrimOp(x, args);
         }
+        CompileContextPusher pusher(obj, args->values);
+        InvokeEntry *entry = analyzeCallable(obj, args->values);
+        if (entry->callByName) {
+            ExprListPtr objectExprs = new ExprList();
+            for (PVData const *i = args->values.begin(),
+                              *end = args->values.end();
+                 i < end; ++i) {
+                objectExprs->add(new ObjectExpr(new PValue(*i)));
+            }
+            ExprPtr callableObject = new ObjectExpr(new PValue(callable));
+            callableObject->location = topLocation();
+            return analyzeCallByName(entry, callableObject, objectExprs,
+                                     new Env());
+        } else if (!entry->analyzed)
+            return nullptr;
+        else
+            return analyzeReturn(entry->returnIsRef, entry->returnTypes);
     }
-    
-    //
-    // analyzeCallPointer
-    //
 
-    MultiPValuePtr analyzeCallPointer(PVData const &x,
-                                      MultiPValuePtr /*args*/) {
-        switch (x.type->typeKind) {
-            case CODE_POINTER_TYPE: {
-                CodePointerType *y = (CodePointerType *) x.type.ptr();
-                return analyzeReturn(y->returnIsRef, y->returnTypes);
-            }
+    case INTRINSIC: {
+        IntrinsicSymbol *intrin = (IntrinsicSymbol *)obj.ptr();
+        return analyzeIntrinsic(intrin, args.ptr());
+    }
 
-            default:
-                assert(false);
-                return nullptr;
-        }
+    default:
+        error("invalid call expression");
+        return nullptr;
     }
+}
 
-    //
-    // analyzeIsDefined, analyzeCallable
-    //
+//
+// analyzeCallPointer
+//
 
-    bool analyzeIsDefined(ObjectPtr x,
-                          llvm::ArrayRef<PVData> args) {
-        MatchFailureError failures;
-        InvokeEntry *entry = lookupInvokeEntry(x, args, failures);
+MultiPValuePtr analyzeCallPointer(PVData const &x, MultiPValuePtr /*args*/) {
+    switch (x.type->typeKind) {
+    case CODE_POINTER_TYPE: {
+        CodePointerType *y = (CodePointerType *)x.type.ptr();
+        return analyzeReturn(y->returnIsRef, y->returnTypes);
+    }
 
-        if (!entry || !entry->code->hasBody())
-            return false;
-        return true;
+    default:
+        assert(false);
+        return nullptr;
     }
+}
 
-    InvokeEntry *analyzeCallable(ObjectPtr x,
-                                 llvm::ArrayRef<PVData> args) {
-        MatchFailureError failures;
-        InvokeEntry *entry = lookupInvokeEntry(x, args, failures);
+//
+// analyzeIsDefined, analyzeCallable
+//
 
-        if (!entry || !entry->code->hasBody()) {
-            matchFailureError(failures);
-        }
+bool analyzeIsDefined(ObjectPtr x, llvm::ArrayRef<PVData> args) {
+    MatchFailureError failures;
+    InvokeEntry *entry = lookupInvokeEntry(x, args, failures);
 
-        if (entry->parent->shouldLog)
-            matchFailureLog(failures);
+    if (!entry || !entry->code->hasBody())
+        return false;
+    return true;
+}
 
-        if (entry->analyzed)
-            return entry;
-        if (entry->analyzing) {
-            updateAnalysisErrorLocation();
-            return entry;
-        }
-        if (entry->callByName) {
-            entry->code = clone(entry->origCode);
-            return entry;
-        }
+InvokeEntry *analyzeCallable(ObjectPtr x, llvm::ArrayRef<PVData> args) {
+    MatchFailureError failures;
+    InvokeEntry *entry = lookupInvokeEntry(x, args, failures);
+
+    if (!entry || !entry->code->hasBody()) {
+        matchFailureError(failures);
+    }
 
-        entry->analyzing = true;
-        analyzeCodeBody(entry);
-        entry->analyzing = false;
+    if (entry->parent->shouldLog)
+        matchFailureLog(failures);
 
+    if (entry->analyzed)
+        return entry;
+    if (entry->analyzing) {
+        updateAnalysisErrorLocation();
+        return entry;
+    }
+    if (entry->callByName) {
+        entry->code = clone(entry->origCode);
         return entry;
     }
 
-    //
-    // analyzeCallByName
-    //
-
-    MultiPValuePtr analyzeCallByName(InvokeEntry *entry,
-                                     ExprPtr callable,
-                                     ExprListPtr args,
-                                     EnvPtr env) {
-        assert(entry->callByName);
+    entry->analyzing = true;
+    analyzeCodeBody(entry);
+    entry->analyzing = false;
 
-        CodePtr code = entry->code;
-        assert(code->body.ptr());
+    return entry;
+}
 
-        if (code->hasReturnSpecs()) {
-            vector<uint8_t> returnIsRef;
-            vector<TypePtr> returnTypes;
-            evaluateReturnSpecs(code->returnSpecs, code->varReturnSpec,
-                                entry->env, returnIsRef, returnTypes);
-            return analyzeReturn(returnIsRef, returnTypes);
+//
+// analyzeCallByName
+//
+
+MultiPValuePtr analyzeCallByName(InvokeEntry *entry, ExprPtr callable,
+                                 ExprListPtr args, EnvPtr env) {
+    assert(entry->callByName);
+
+    CodePtr code = entry->code;
+    assert(code->body.ptr());
+
+    if (code->hasReturnSpecs()) {
+        vector<uint8_t> returnIsRef;
+        vector<TypePtr> returnTypes;
+        evaluateReturnSpecs(code->returnSpecs, code->varReturnSpec, entry->env,
+                            returnIsRef, returnTypes);
+        return analyzeReturn(returnIsRef, returnTypes);
+    }
+
+    if (entry->varArgName.ptr())
+        assert(args->size() >= entry->fixedArgNames.size());
+    else
+        assert(args->size() == entry->fixedArgNames.size());
+
+    EnvPtr bodyEnv = new Env(entry->env);
+    bodyEnv->callByNameExprHead = callable;
+    unsigned i = 0;
+    for (; i < entry->varArgPosition; ++i) {
+        ExprPtr expr = foreignExpr(env, args->exprs[i]);
+        addLocal(bodyEnv, entry->fixedArgNames[i], expr.ptr());
+    }
+    if (entry->varArgName.ptr()) {
+        unsigned j = 0;
+        const ExprListPtr varArgs = new ExprList();
+        for (; j < args->size() - entry->fixedArgNames.size(); ++j) {
+            ExprPtr expr = foreignExpr(env, args->exprs[i + j]);
+            varArgs->add(expr);
+        }
+        addLocal(bodyEnv, entry->varArgName, varArgs.ptr());
+        for (; i < entry->fixedArgNames.size(); ++i) {
+            ExprPtr expr = foreignExpr(env, args->exprs[i + j]);
+            addLocal(bodyEnv, entry->fixedArgNames[i], expr.ptr());
         }
+    }
 
-        if (entry->varArgName.ptr())
-            assert(args->size() >= entry->fixedArgNames.size());
-        else
-            assert(args->size() == entry->fixedArgNames.size());
+    AnalysisContext ctx;
+    StatementAnalysis sa = analyzeStatement(code->body, bodyEnv, &ctx);
+    if ((sa == SA_RECURSIVE) && (!ctx.returnInitialized))
+        return nullptr;
+    if (ctx.returnInitialized) {
+        return analyzeReturn(ctx.returnIsRef, ctx.returnTypes);
+    } else if ((sa == SA_TERMINATED) && ctx.hasRecursivePropagation) {
+        analysisError();
+        return nullptr;
+    } else {
+        // assume void return (zero return values)
+        return new MultiPValue();
+    }
+}
 
-        EnvPtr bodyEnv = new Env(entry->env);
-        bodyEnv->callByNameExprHead = callable;
-        unsigned i = 0;
-        for (; i < entry->varArgPosition; ++i) {
-            ExprPtr expr = foreignExpr(env, args->exprs[i]);
-            addLocal(bodyEnv, entry->fixedArgNames[i], expr.ptr());
+//
+// analyzeCodeBody
+//
+
+static void unifyInterfaceReturns(InvokeEntry *entry) {
+    if (entry->parent->callable->objKind == TYPE) {
+        string buf;
+        llvm::raw_string_ostream out(buf);
+        if (entry->returnTypes.size() != 1) {
+            out << "constructor overload for type " << entry->parent->callable
+                << " must return a single value of that type";
+            error(entry->code, out.str());
         }
-        if (entry->varArgName.ptr()) {
-            unsigned j = 0;
-            const ExprListPtr varArgs = new ExprList();
-            for (; j < args->size() - entry->fixedArgNames.size(); ++j) {
-                ExprPtr expr = foreignExpr(env, args->exprs[i + j]);
-                varArgs->add(expr);
-            }
-            addLocal(bodyEnv, entry->varArgName, varArgs.ptr());
-            for (; i < entry->fixedArgNames.size(); ++i) {
-                ExprPtr expr = foreignExpr(env, args->exprs[i + j]);
-                addLocal(bodyEnv, entry->fixedArgNames[i], expr.ptr());
-            }
+        if (entry->returnIsRef[0]) {
+            out << "constructor overload for type " << entry->parent->callable
+                << " must return by value";
+            error(entry->code, out.str());
         }
-
-        AnalysisContext ctx;
-        StatementAnalysis sa = analyzeStatement(code->body, bodyEnv, &ctx);
-        if ((sa == SA_RECURSIVE) && (!ctx.returnInitialized))
-            return nullptr;
-        if (ctx.returnInitialized) {
-            return analyzeReturn(ctx.returnIsRef, ctx.returnTypes);
-        } else if ((sa == SA_TERMINATED) && ctx.hasRecursivePropagation) {
-            analysisError();
-            return nullptr;
-        } else {
-            // assume void return (zero return values)
-            return new MultiPValue();
+        if (entry->returnTypes[0].ptr() != entry->parent->callable.ptr()) {
+            out << "constructor overload for type " << entry->parent->callable
+                << " returns type " << entry->returnTypes[0];
+            error(entry->code, out.str());
         }
+        return;
     }
 
-    //
-    // analyzeCodeBody
-    //
+    if (entry->parent->interface == nullptr)
+        return;
+
+    CodePtr interfaceCode = entry->parent->interface->code;
+    if (!interfaceCode->returnSpecsDeclared)
+        return;
 
-    static void unifyInterfaceReturns(InvokeEntry *entry) {
-        if (entry->parent->callable->objKind == TYPE) {
+    vector<uint8_t> interfaceReturnIsRef;
+    vector<TypePtr> interfaceReturnTypes;
+
+    evaluateReturnSpecs(interfaceCode->returnSpecs,
+                        interfaceCode->varReturnSpec, entry->interfaceEnv,
+                        interfaceReturnIsRef, interfaceReturnTypes);
+    if (entry->returnTypes.size() != interfaceReturnTypes.size()) {
+        string buf;
+        llvm::raw_string_ostream out(buf);
+        out << "interface declares " << interfaceReturnTypes.size()
+            << " arguments, but got " << entry->returnTypes.size() << "\n"
+            << "    interface at ";
+        printFileLineCol(out, entry->parent->interface->location);
+        error(entry->code, out.str());
+    }
+    for (size_t i = 0; i < interfaceReturnTypes.size(); ++i) {
+        if (interfaceReturnTypes[i] != entry->returnTypes[i]) {
             string buf;
             llvm::raw_string_ostream out(buf);
-            if (entry->returnTypes.size() != 1) {
-                out << "constructor overload for type " << entry->parent->callable
-                        << " must return a single value of that type";
-                error(entry->code, out.str());
-            }
-            if (entry->returnIsRef[0]) {
-                out << "constructor overload for type " << entry->parent->callable
-                        << " must return by value";
-                error(entry->code, out.str());
-            }
-            if (entry->returnTypes[0].ptr() != entry->parent->callable.ptr()) {
-                out << "constructor overload for type " << entry->parent->callable
-                        << " returns type " << entry->returnTypes[0];
-                error(entry->code, out.str());
-            }
-            return;
+            out << "return value " << i + 1 << ": "
+                << "interface declares return type " << interfaceReturnTypes[i]
+                << ", but overload returns type " << entry->returnTypes[i]
+                << "\n"
+                << "    interface at ";
+            printFileLineCol(out, entry->parent->interface->location);
+            error(entry->code, out.str());
         }
-
-        if (entry->parent->interface == nullptr)
-            return;
-
-        CodePtr interfaceCode = entry->parent->interface->code;
-        if (!interfaceCode->returnSpecsDeclared)
-            return;
-
-        vector<uint8_t> interfaceReturnIsRef;
-        vector<TypePtr> interfaceReturnTypes;
-
-        evaluateReturnSpecs(interfaceCode->returnSpecs,
-                            interfaceCode->varReturnSpec,
-                            entry->interfaceEnv,
-                            interfaceReturnIsRef, interfaceReturnTypes);
-        if (entry->returnTypes.size() != interfaceReturnTypes.size()) {
+        if (interfaceReturnIsRef[i] && !entry->returnIsRef[i]) {
             string buf;
             llvm::raw_string_ostream out(buf);
-            out << "interface declares " << interfaceReturnTypes.size()
-                    << " arguments, but got " << entry->returnTypes.size() << "\n"
-                    << "    interface at ";
+            out << "return value " << i + 1 << ": "
+                << "interface declares return by reference, but overload "
+                   "returns by value\n"
+                << "    interface at ";
             printFileLineCol(out, entry->parent->interface->location);
             error(entry->code, out.str());
         }
-        for (size_t i = 0; i < interfaceReturnTypes.size(); ++i) {
-            if (interfaceReturnTypes[i] != entry->returnTypes[i]) {
-                string buf;
-                llvm::raw_string_ostream out(buf);
-                out << "return value " << i + 1 << ": "
-                        << "interface declares return type " << interfaceReturnTypes[i]
-                        << ", but overload returns type " << entry->returnTypes[i] << "\n"
-                        << "    interface at ";
-                printFileLineCol(out, entry->parent->interface->location);
-                error(entry->code, out.str());
-            }
-            if (interfaceReturnIsRef[i] && !entry->returnIsRef[i]) {
-                string buf;
-                llvm::raw_string_ostream out(buf);
-                out << "return value " << i + 1 << ": "
-                        << "interface declares return by reference, but overload returns by value\n"
-                        << "    interface at ";
-                printFileLineCol(out, entry->parent->interface->location);
-                error(entry->code, out.str());
-            }
-        }
     }
+}
 
-    void analyzeCodeBody(InvokeEntry *entry) {
-        assert(!entry->analyzed);
+void analyzeCodeBody(InvokeEntry *entry) {
+    assert(!entry->analyzed);
 
-        CodePtr code = entry->code;
-        assert(code->hasBody());
+    CodePtr code = entry->code;
+    assert(code->hasBody());
 
-        if (code->isLLVMBody() || code->hasReturnSpecs()) {
-            evaluateReturnSpecs(code->returnSpecs, code->varReturnSpec,
-                                entry->env,
-                                entry->returnIsRef, entry->returnTypes);
-            entry->analyzed = true;
-            return;
-        }
+    if (code->isLLVMBody() || code->hasReturnSpecs()) {
+        evaluateReturnSpecs(code->returnSpecs, code->varReturnSpec, entry->env,
+                            entry->returnIsRef, entry->returnTypes);
+        entry->analyzed = true;
+        return;
+    }
 
-        EnvPtr bodyEnv = new Env(entry->env);
+    EnvPtr bodyEnv = new Env(entry->env);
 
-        size_t i = 0;
-        for (; i < entry->varArgPosition; ++i) {
-            bool flag = entry->forwardedRValueFlags[i];
-            addLocal(bodyEnv, entry->fixedArgNames[i], new PValue(entry->fixedArgTypes[i], flag));
+    size_t i = 0;
+    for (; i < entry->varArgPosition; ++i) {
+        bool flag = entry->forwardedRValueFlags[i];
+        addLocal(bodyEnv, entry->fixedArgNames[i],
+                 new PValue(entry->fixedArgTypes[i], flag));
+    }
+    if (entry->varArgName.ptr()) {
+        MultiPValuePtr varArgs = new MultiPValue();
+        size_t j = 0;
+        for (; j < entry->varArgTypes.size(); ++j) {
+            bool flag = entry->forwardedRValueFlags[i + j];
+            PVData parg(entry->varArgTypes[j], flag);
+            varArgs->values.push_back(parg);
         }
-        if (entry->varArgName.ptr()) {
-            MultiPValuePtr varArgs = new MultiPValue();
-            size_t j = 0;
-            for (; j < entry->varArgTypes.size(); ++j) {
-                bool flag = entry->forwardedRValueFlags[i + j];
-                PVData parg(entry->varArgTypes[j], flag);
-                varArgs->values.push_back(parg);
-            }
-            addLocal(bodyEnv, entry->varArgName, varArgs.ptr());
-            for (; i < entry->fixedArgNames.size(); ++i) {
-                bool flag = entry->forwardedRValueFlags[i + j];
-                addLocal(bodyEnv, entry->fixedArgNames[i], new PValue(entry->fixedArgTypes[i], flag));
-            }
+        addLocal(bodyEnv, entry->varArgName, varArgs.ptr());
+        for (; i < entry->fixedArgNames.size(); ++i) {
+            bool flag = entry->forwardedRValueFlags[i + j];
+            addLocal(bodyEnv, entry->fixedArgNames[i],
+                     new PValue(entry->fixedArgTypes[i], flag));
         }
+    }
 
-        AnalysisContext ctx;
-        StatementAnalysis sa = analyzeStatement(code->body, bodyEnv, &ctx);
-        if ((sa == SA_RECURSIVE) && (!ctx.returnInitialized))
-            return;
-        if (ctx.returnInitialized) {
-            entry->returnIsRef = ctx.returnIsRef;
-            entry->returnTypes = ctx.returnTypes;
-        } else if ((sa == SA_TERMINATED) && ctx.hasRecursivePropagation) {
-            analysisError();
-        }
+    AnalysisContext ctx;
+    StatementAnalysis sa = analyzeStatement(code->body, bodyEnv, &ctx);
+    if ((sa == SA_RECURSIVE) && (!ctx.returnInitialized))
+        return;
+    if (ctx.returnInitialized) {
+        entry->returnIsRef = ctx.returnIsRef;
+        entry->returnTypes = ctx.returnTypes;
+    } else if ((sa == SA_TERMINATED) && ctx.hasRecursivePropagation) {
+        analysisError();
+    }
 
-        unifyInterfaceReturns(entry);
+    unifyInterfaceReturns(entry);
 
-        entry->analyzed = true;
-    }
+    entry->analyzed = true;
+}
 
-    //
-    // analyzeStatement
-    //
+//
+// analyzeStatement
+//
+
+static StatementAnalysis combineStatementAnalysis(StatementAnalysis a,
+                                                  StatementAnalysis b) {
+    if ((a == SA_FALLTHROUGH) || (b == SA_FALLTHROUGH))
+        return SA_FALLTHROUGH;
+    if ((a == SA_RECURSIVE) && (b == SA_RECURSIVE))
+        return SA_RECURSIVE;
+    if ((a == SA_TERMINATED) && (b == SA_TERMINATED))
+        return SA_TERMINATED;
+    if ((a == SA_RECURSIVE) && (b == SA_TERMINATED))
+        return SA_TERMINATED;
+    assert((a == SA_TERMINATED) && (b == SA_RECURSIVE));
+    return SA_TERMINATED;
+}
 
-    static StatementAnalysis combineStatementAnalysis(StatementAnalysis a,
-                                                      StatementAnalysis b) {
-        if ((a == SA_FALLTHROUGH) || (b == SA_FALLTHROUGH))
-            return SA_FALLTHROUGH;
-        if ((a == SA_RECURSIVE) && (b == SA_RECURSIVE))
+static StatementAnalysis analyzeBlockStatement(const StatementPtr &stmt,
+                                               EnvPtr &env,
+                                               AnalysisContext *ctx) {
+    if (stmt->stmtKind == BINDING) {
+        env = analyzeBinding(static_cast<Binding *>(stmt.ptr()), env);
+        if (!env) {
+            ctx->hasRecursivePropagation = true;
             return SA_RECURSIVE;
-        if ((a == SA_TERMINATED) && (b == SA_TERMINATED))
-            return SA_TERMINATED;
-        if ((a == SA_RECURSIVE) && (b == SA_TERMINATED))
-            return SA_TERMINATED;
-        assert((a == SA_TERMINATED) && (b == SA_RECURSIVE));
-        return SA_TERMINATED;
-    }
+        }
+        return SA_FALLTHROUGH;
+    } else if (stmt->stmtKind == EVAL_STATEMENT) {
+        EvalStatement *eval = (EvalStatement *)stmt.ptr();
+        llvm::ArrayRef<StatementPtr> evaled = desugarEvalStatement(eval, env);
+        for (size_t i = 0; i < evaled.size(); ++i) {
+            StatementAnalysis sa = analyzeBlockStatement(evaled[i], env, ctx);
+            if (sa != SA_FALLTHROUGH)
+                return sa;
+        }
+        return SA_FALLTHROUGH;
+    } else
+        return analyzeStatement(stmt, env, ctx);
+}
 
-    static StatementAnalysis analyzeBlockStatement(const StatementPtr &stmt, EnvPtr &env, AnalysisContext *ctx) {
-        if (stmt->stmtKind == BINDING) {
-            env = analyzeBinding(static_cast<Binding *>(stmt.ptr()), env);
-            if (!env) {
-                ctx->hasRecursivePropagation = true;
-                return SA_RECURSIVE;
-            }
-            return SA_FALLTHROUGH;
-        } else if (stmt->stmtKind == EVAL_STATEMENT) {
-            EvalStatement *eval = (EvalStatement *) stmt.ptr();
-            llvm::ArrayRef<StatementPtr> evaled = desugarEvalStatement(eval, env);
-            for (size_t i = 0; i < evaled.size(); ++i) {
-                StatementAnalysis sa = analyzeBlockStatement(evaled[i], env, ctx);
-                if (sa != SA_FALLTHROUGH)
-                    return sa;
-            }
-            return SA_FALLTHROUGH;
-        } else
-            return analyzeStatement(stmt, env, ctx);
-    }
-
-    static EnvPtr analyzeStatementExpressionStatements(llvm::ArrayRef<StatementPtr> stmts, EnvPtr env) {
-        EnvPtr env2 = env;
-        for (StatementPtr const *i = stmts.begin(), *end = stmts.end();
-             i != end;
-             ++i) {
-            switch ((*i)->stmtKind) {
-                case BINDING:
-                    env2 = analyzeBinding(static_cast<Binding *>(i->ptr()), env2);
-                    if (env2 == nullptr)
-                        return nullptr;
-                    break;
-
-                case ASSIGNMENT:
-                case VARIADIC_ASSIGNMENT:
-                case INIT_ASSIGNMENT:
-                case EXPR_STATEMENT:
-                    break;
-
-                default:
-                    assert(false);
-                    return nullptr;
-            }
+static EnvPtr
+analyzeStatementExpressionStatements(llvm::ArrayRef<StatementPtr> stmts,
+                                     EnvPtr env) {
+    EnvPtr env2 = env;
+    for (StatementPtr const *i = stmts.begin(), *end = stmts.end(); i != end;
+         ++i) {
+        switch ((*i)->stmtKind) {
+        case BINDING:
+            env2 = analyzeBinding(static_cast<Binding *>(i->ptr()), env2);
+            if (env2 == nullptr)
+                return nullptr;
+            break;
+
+        case ASSIGNMENT:
+        case VARIADIC_ASSIGNMENT:
+        case INIT_ASSIGNMENT:
+        case EXPR_STATEMENT:
+            break;
+
+        default:
+            assert(false);
+            return nullptr;
         }
-        return env2;
     }
+    return env2;
+}
 
-    static StatementAnalysis analyzeStatement(StatementPtr stmt, EnvPtr env, AnalysisContext *ctx) {
-        LocationContext loc(stmt->location);
-
-        switch (stmt->stmtKind) {
-            case BLOCK: {
-                Block *block = (Block *) stmt.ptr();
-                for (size_t i = 0; i < block->statements.size(); ++i) {
-                    StatementAnalysis sa = analyzeBlockStatement(block->statements[i], env, ctx);
-                    if (sa != SA_FALLTHROUGH)
-                        return sa;
-                }
-                return SA_FALLTHROUGH;
-            }
+static StatementAnalysis analyzeStatement(StatementPtr stmt, EnvPtr env,
+                                          AnalysisContext *ctx) {
+    LocationContext loc(stmt->location);
+
+    switch (stmt->stmtKind) {
+    case BLOCK: {
+        Block *block = (Block *)stmt.ptr();
+        for (size_t i = 0; i < block->statements.size(); ++i) {
+            StatementAnalysis sa =
+                analyzeBlockStatement(block->statements[i], env, ctx);
+            if (sa != SA_FALLTHROUGH)
+                return sa;
+        }
+        return SA_FALLTHROUGH;
+    }
 
-            case LABEL:
-            case BINDING:
-            case ASSIGNMENT:
-            case INIT_ASSIGNMENT:
-            case VARIADIC_ASSIGNMENT:
-                return SA_FALLTHROUGH;
+    case LABEL:
+    case BINDING:
+    case ASSIGNMENT:
+    case INIT_ASSIGNMENT:
+    case VARIADIC_ASSIGNMENT:
+        return SA_FALLTHROUGH;
 
-            case GOTO:
-                return SA_TERMINATED;
+    case GOTO:
+        return SA_TERMINATED;
 
-            case RETURN: {
-                Return *x = (Return *) stmt.ptr();
-                unsigned wantCount = x->isReturnSpecs ? 1 : 0;
-                MultiPValuePtr mpv = analyzeMulti(x->values, env, wantCount);
+    case RETURN: {
+        Return *x = (Return *)stmt.ptr();
+        unsigned wantCount = x->isReturnSpecs ? 1 : 0;
+        MultiPValuePtr mpv = analyzeMulti(x->values, env, wantCount);
 
-                if (!mpv) {
-                    ctx->hasRecursivePropagation = true;
-                    return SA_RECURSIVE;
-                }
-                if (ctx->returnInitialized) {
-                    ensureArity(mpv, ctx->returnTypes.size());
-                    for (unsigned i = 0; i < mpv->size(); ++i) {
-                        PVData const &pv = mpv->values[i];
-                        bool byRef = returnKindToByRef(x->returnKind, pv);
-                        if (ctx->returnTypes[i] != pv.type)
-                            argumentTypeError(i, ctx->returnTypes[i], pv.type);
-                        if (byRef != ctx->returnIsRef[i])
-                            argumentError(i, "mismatching by-ref and "
-                                          "by-value returns");
-                        if (byRef && pv.isRValue)
-                            argumentError(i, "cannot return a temporary by reference");
-                    }
-                } else {
-                    ctx->returnIsRef.clear();
-                    ctx->returnTypes.clear();
-                    for (unsigned i = 0; i < mpv->size(); ++i) {
-                        PVData const &pv = mpv->values[i];
-                        bool byRef = returnKindToByRef(x->returnKind, pv);
-                        ctx->returnIsRef.push_back(byRef);
-                        if (byRef && pv.isRValue)
-                            argumentError(i, "cannot return a temporary by reference");
-                        ctx->returnTypes.push_back(pv.type);
-                    }
-                    ctx->returnInitialized = true;
-                }
-                return SA_TERMINATED;
+        if (!mpv) {
+            ctx->hasRecursivePropagation = true;
+            return SA_RECURSIVE;
+        }
+        if (ctx->returnInitialized) {
+            ensureArity(mpv, ctx->returnTypes.size());
+            for (unsigned i = 0; i < mpv->size(); ++i) {
+                PVData const &pv = mpv->values[i];
+                bool byRef = returnKindToByRef(x->returnKind, pv);
+                if (ctx->returnTypes[i] != pv.type)
+                    argumentTypeError(i, ctx->returnTypes[i], pv.type);
+                if (byRef != ctx->returnIsRef[i])
+                    argumentError(i, "mismatching by-ref and "
+                                     "by-value returns");
+                if (byRef && pv.isRValue)
+                    argumentError(i, "cannot return a temporary by reference");
             }
+        } else {
+            ctx->returnIsRef.clear();
+            ctx->returnTypes.clear();
+            for (unsigned i = 0; i < mpv->size(); ++i) {
+                PVData const &pv = mpv->values[i];
+                bool byRef = returnKindToByRef(x->returnKind, pv);
+                ctx->returnIsRef.push_back(byRef);
+                if (byRef && pv.isRValue)
+                    argumentError(i, "cannot return a temporary by reference");
+                ctx->returnTypes.push_back(pv.type);
+            }
+            ctx->returnInitialized = true;
+        }
+        return SA_TERMINATED;
+    }
 
-            case IF: {
-                auto x = static_cast<If *>(stmt.ptr());
+    case IF: {
+        auto x = static_cast<If *>(stmt.ptr());
 
-                EnvPtr env2 = analyzeStatementExpressionStatements(x->conditionStatements, env);
-                if (env2 == nullptr) {
-                    ctx->hasRecursivePropagation = true;
-                    return SA_RECURSIVE;
-                }
+        EnvPtr env2 =
+            analyzeStatementExpressionStatements(x->conditionStatements, env);
+        if (env2 == nullptr) {
+            ctx->hasRecursivePropagation = true;
+            return SA_RECURSIVE;
+        }
 
-                MultiPValuePtr cond = analyzeExpr(x->condition, env2);
+        MultiPValuePtr cond = analyzeExpr(x->condition, env2);
 
-                if (cond->values.size() != 1) {
-                    arityError(1, cond->values.size());
-                }
+        if (cond->values.size() != 1) {
+            arityError(1, cond->values.size());
+        }
 
-                PVData &condPvData = cond->values[0];
+        PVData &condPvData = cond->values[0];
 
-                BoolKind condKind = typeBoolKind(condPvData.type);
+        BoolKind condKind = typeBoolKind(condPvData.type);
 
-                StatementAnalysis thenResult = SA_FALLTHROUGH;
-                StatementAnalysis elseResult = SA_FALLTHROUGH;
-                if (condKind == BOOL_EXPR || condKind == BOOL_STATIC_TRUE)
-                    thenResult = analyzeStatement(x->thenPart, env2, ctx);
-                if ((condKind == BOOL_EXPR || condKind == BOOL_STATIC_FALSE) && x->elsePart.ptr())
-                    elseResult = analyzeStatement(x->elsePart, env2, ctx);
-                return combineStatementAnalysis(thenResult, elseResult);
-            }
+        StatementAnalysis thenResult = SA_FALLTHROUGH;
+        StatementAnalysis elseResult = SA_FALLTHROUGH;
+        if (condKind == BOOL_EXPR || condKind == BOOL_STATIC_TRUE)
+            thenResult = analyzeStatement(x->thenPart, env2, ctx);
+        if ((condKind == BOOL_EXPR || condKind == BOOL_STATIC_FALSE) &&
+            x->elsePart.ptr())
+            elseResult = analyzeStatement(x->elsePart, env2, ctx);
+        return combineStatementAnalysis(thenResult, elseResult);
+    }
 
-            case SWITCH: {
-                auto *x = static_cast<Switch *>(stmt.ptr());
-                if (!x->desugared)
-                    x->desugared = desugarSwitchStatement(x);
-                return analyzeStatement(x->desugared, env, ctx);
-            }
+    case SWITCH: {
+        auto *x = static_cast<Switch *>(stmt.ptr());
+        if (!x->desugared)
+            x->desugared = desugarSwitchStatement(x);
+        return analyzeStatement(x->desugared, env, ctx);
+    }
 
-            case EVAL_STATEMENT: {
-                EvalStatement *eval = (EvalStatement *) stmt.ptr();
-                llvm::ArrayRef<StatementPtr> evaled = desugarEvalStatement(eval, env);
-                for (size_t i = 0; i < evaled.size(); ++i) {
-                    StatementAnalysis sa = analyzeStatement(evaled[i], env, ctx);
-                    if (sa != SA_FALLTHROUGH)
-                        return sa;
-                }
-                return SA_FALLTHROUGH;
-            }
+    case EVAL_STATEMENT: {
+        EvalStatement *eval = (EvalStatement *)stmt.ptr();
+        llvm::ArrayRef<StatementPtr> evaled = desugarEvalStatement(eval, env);
+        for (size_t i = 0; i < evaled.size(); ++i) {
+            StatementAnalysis sa = analyzeStatement(evaled[i], env, ctx);
+            if (sa != SA_FALLTHROUGH)
+                return sa;
+        }
+        return SA_FALLTHROUGH;
+    }
 
-            case EXPR_STATEMENT:
-                return SA_FALLTHROUGH;
+    case EXPR_STATEMENT:
+        return SA_FALLTHROUGH;
 
-            case WHILE: {
-                While *x = (While *) stmt.ptr();
+    case WHILE: {
+        While *x = (While *)stmt.ptr();
 
-                EnvPtr env2 = analyzeStatementExpressionStatements(x->conditionStatements, env);
-                if (env2 == nullptr) {
-                    ctx->hasRecursivePropagation = true;
-                    return SA_RECURSIVE;
-                }
+        EnvPtr env2 =
+            analyzeStatementExpressionStatements(x->conditionStatements, env);
+        if (env2 == nullptr) {
+            ctx->hasRecursivePropagation = true;
+            return SA_RECURSIVE;
+        }
 
-                analyzeStatement(x->body, env2, ctx);
-                return SA_FALLTHROUGH;
-            }
+        analyzeStatement(x->body, env2, ctx);
+        return SA_FALLTHROUGH;
+    }
 
-            case BREAK:
-            case CONTINUE:
-                return SA_TERMINATED;
+    case BREAK:
+    case CONTINUE:
+        return SA_TERMINATED;
 
-            case FOR: {
-                For *x = (For *) stmt.ptr();
-                if (!x->desugared)
-                    x->desugared = desugarForStatement(x);
-                return analyzeStatement(x->desugared, env, ctx);
-            }
+    case FOR: {
+        For *x = (For *)stmt.ptr();
+        if (!x->desugared)
+            x->desugared = desugarForStatement(x);
+        return analyzeStatement(x->desugared, env, ctx);
+    }
 
-            case FOREIGN_STATEMENT: {
-                ForeignStatement *x = (ForeignStatement *) stmt.ptr();
-                return analyzeStatement(x->statement, x->getEnv(), ctx);
-            }
+    case FOREIGN_STATEMENT: {
+        ForeignStatement *x = (ForeignStatement *)stmt.ptr();
+        return analyzeStatement(x->statement, x->getEnv(), ctx);
+    }
 
-            case TRY: {
-                Try *x = (Try *) stmt.ptr();
-                if (!exceptionsEnabled())
-                    return analyzeStatement(x->tryBlock, env, ctx);
-                if (!x->desugaredCatchBlock)
-                    x->desugaredCatchBlock = desugarCatchBlocks(x->catchBlocks);
-                StatementAnalysis result1, result2;
-                result1 = analyzeStatement(x->tryBlock, env, ctx);
+    case TRY: {
+        Try *x = (Try *)stmt.ptr();
+        if (!exceptionsEnabled())
+            return analyzeStatement(x->tryBlock, env, ctx);
+        if (!x->desugaredCatchBlock)
+            x->desugaredCatchBlock = desugarCatchBlocks(x->catchBlocks);
+        StatementAnalysis result1, result2;
+        result1 = analyzeStatement(x->tryBlock, env, ctx);
 
-                EnvPtr catchEnv = new Env(env, true);
+        EnvPtr catchEnv = new Env(env, true);
 
-                result2 = analyzeStatement(x->desugaredCatchBlock, catchEnv, ctx);
-                return combineStatementAnalysis(result1, result2);
-            }
+        result2 = analyzeStatement(x->desugaredCatchBlock, catchEnv, ctx);
+        return combineStatementAnalysis(result1, result2);
+    }
 
-            case THROW:
-                return SA_TERMINATED;
+    case THROW:
+        return SA_TERMINATED;
 
-            case STATIC_FOR: {
-                StaticFor *x = (StaticFor *) stmt.ptr();
-                MultiPValuePtr mpv = analyzeMulti(x->values, env, 2);
-                if (!mpv) {
-                    ctx->hasRecursivePropagation = true;
-                    return SA_RECURSIVE;
-                }
-                initializeStaticForClones(x, mpv->size());
-                for (unsigned i = 0; i < mpv->size(); ++i) {
-                    EnvPtr env2 = new Env(env);
-                    addLocal(env2, x->variable, new PValue(mpv->values[i]));
-                    StatementAnalysis sa = analyzeStatement(x->clonedBodies[i], env2, ctx);
-                    if (sa != SA_FALLTHROUGH)
-                        return sa;
-                }
-                return SA_FALLTHROUGH;
-            }
+    case STATIC_FOR: {
+        StaticFor *x = (StaticFor *)stmt.ptr();
+        MultiPValuePtr mpv = analyzeMulti(x->values, env, 2);
+        if (!mpv) {
+            ctx->hasRecursivePropagation = true;
+            return SA_RECURSIVE;
+        }
+        initializeStaticForClones(x, mpv->size());
+        for (unsigned i = 0; i < mpv->size(); ++i) {
+            EnvPtr env2 = new Env(env);
+            addLocal(env2, x->variable, new PValue(mpv->values[i]));
+            StatementAnalysis sa =
+                analyzeStatement(x->clonedBodies[i], env2, ctx);
+            if (sa != SA_FALLTHROUGH)
+                return sa;
+        }
+        return SA_FALLTHROUGH;
+    }
 
-            case FINALLY:
-            case ONERROR:
-                return SA_FALLTHROUGH;
+    case FINALLY:
+    case ONERROR:
+        return SA_FALLTHROUGH;
 
-            case UNREACHABLE:
-                return SA_TERMINATED;
+    case UNREACHABLE:
+        return SA_TERMINATED;
 
-            case STATIC_ASSERT_STATEMENT:
-                return SA_FALLTHROUGH;
+    case STATIC_ASSERT_STATEMENT:
+        return SA_FALLTHROUGH;
 
-            default:
-                assert(false);
-                return SA_FALLTHROUGH;
-        }
+    default:
+        assert(false);
+        return SA_FALLTHROUGH;
     }
+}
 
-    void initializeStaticForClones(StaticForPtr x, size_t count) {
-        if (x->clonesInitialized) {
-            assert(count == x->clonedBodies.size());
-        } else {
-            if (analysisCachingDisabled == 0)
-                x->clonesInitialized = true;
-            x->clonedBodies.clear();
-            for (unsigned i = 0; i < count; ++i)
-                x->clonedBodies.push_back(clone(x->body));
-        }
+void initializeStaticForClones(StaticForPtr x, size_t count) {
+    if (x->clonesInitialized) {
+        assert(count == x->clonedBodies.size());
+    } else {
+        if (analysisCachingDisabled == 0)
+            x->clonesInitialized = true;
+        x->clonedBodies.clear();
+        for (unsigned i = 0; i < count; ++i)
+            x->clonedBodies.push_back(clone(x->body));
     }
+}
 
-    static EnvPtr analyzeBinding(BindingPtr x, EnvPtr env) {
-        LocationContext loc(x->location);
-
-        switch (x->bindingKind) {
-            case VAR:
-            case REF:
-            case FORWARD: {
-                MultiPValuePtr mpv = analyzeMulti(x->values, env, x->args.size());
-                if (!mpv)
-                    return nullptr;
-
-                if (x->hasVarArg) {
-                    if (mpv->values.size() < x->args.size() - 1)
-                        arityMismatchError(x->args.size() - 1, mpv->values.size(), /*hasVarArg=*/ true);
-                } else if (mpv->values.size() != x->args.size())
-                    arityMismatchError(x->args.size(), mpv->values.size(), /*hasVarArg=*/ false);
+static EnvPtr analyzeBinding(BindingPtr x, EnvPtr env) {
+    LocationContext loc(x->location);
 
-                vector<TypePtr> key;
-                for (unsigned i = 0; i < mpv->size(); ++i) {
-                    PVData const &pv = mpv->values[i];
-                    key.push_back(pv.type);
-                }
+    switch (x->bindingKind) {
+    case VAR:
+    case REF:
+    case FORWARD: {
+        MultiPValuePtr mpv = analyzeMulti(x->values, env, x->args.size());
+        if (!mpv)
+            return nullptr;
 
-                llvm::ArrayRef<PatternVar> pvars = x->patternVars;
-                EnvPtr patternEnv = new Env(env);
-                vector<PatternCellPtr> cells;
-                vector<MultiPatternCellPtr> multiCells;
-                initializePatternEnv(patternEnv, pvars, cells, multiCells);
-
-                llvm::ArrayRef<FormalArgPtr> formalArgs = x->args;
-                size_t varArgSize = key.size() - formalArgs.size() + 1;
-                for (size_t i = 0, j = 0; i < formalArgs.size(); ++i) {
-                    FormalArgPtr y = formalArgs[i];
-                    if (y->varArg) {
-                        if (y->type.ptr()) {
-                            ExprPtr unpack = new Unpack(y->type.ptr());
-                            unpack->location = y->type->location;
-                            MultiStaticPtr types = new MultiStatic();
-                            for (; j < varArgSize; ++j) {
-                                types->add(key[i + j].ptr());
-                            }
-                            --j;
-                            if (!unifyMulti(evaluateMultiPattern(new ExprList(unpack), patternEnv), types))
-                                matchBindingError(new MatchMultiBindingError(unsigned(formalArgs.size()), types, y));
-                        } else {
-                            j = varArgSize - 1;
-                        }
-                    } else {
-                        if (y->type.ptr()) {
-                            if (!unifyPatternObj(evaluateOnePattern(y->type, patternEnv), key[i + j].ptr()))
-                                matchBindingError(new MatchBindingError(unsigned(i + j), key[i + j], y));
-                        }
-                    }
-                }
+        if (x->hasVarArg) {
+            if (mpv->values.size() < x->args.size() - 1)
+                arityMismatchError(x->args.size() - 1, mpv->values.size(),
+                                   /*hasVarArg=*/true);
+        } else if (mpv->values.size() != x->args.size())
+            arityMismatchError(x->args.size(), mpv->values.size(),
+                               /*hasVarArg=*/false);
+
+        vector<TypePtr> key;
+        for (unsigned i = 0; i < mpv->size(); ++i) {
+            PVData const &pv = mpv->values[i];
+            key.push_back(pv.type);
+        }
 
-                EnvPtr staticEnv = new Env(env);
-                for (size_t i = 0; i < pvars.size(); ++i) {
-                    if (pvars[i].isMulti) {
-                        MultiStaticPtr ms = derefDeep(multiCells[i].ptr());
-                        if (!ms)
-                            error(pvars[i].name, "unbound pattern variable");
-                        addLocal(staticEnv, pvars[i].name, ms.ptr());
-                        x->patternTypes.push_back(ms.ptr());
-                    } else {
-                        ObjectPtr v = derefDeep(cells[i].ptr());
-                        if (!v)
-                            error(pvars[i].name, "unbound pattern variable");
-                        addLocal(staticEnv, pvars[i].name, v.ptr());
-                        x->patternTypes.push_back(v.ptr());
+        llvm::ArrayRef<PatternVar> pvars = x->patternVars;
+        EnvPtr patternEnv = new Env(env);
+        vector<PatternCellPtr> cells;
+        vector<MultiPatternCellPtr> multiCells;
+        initializePatternEnv(patternEnv, pvars, cells, multiCells);
+
+        llvm::ArrayRef<FormalArgPtr> formalArgs = x->args;
+        size_t varArgSize = key.size() - formalArgs.size() + 1;
+        for (size_t i = 0, j = 0; i < formalArgs.size(); ++i) {
+            FormalArgPtr y = formalArgs[i];
+            if (y->varArg) {
+                if (y->type.ptr()) {
+                    ExprPtr unpack = new Unpack(y->type.ptr());
+                    unpack->location = y->type->location;
+                    MultiStaticPtr types = new MultiStatic();
+                    for (; j < varArgSize; ++j) {
+                        types->add(key[i + j].ptr());
                     }
+                    --j;
+                    if (!unifyMulti(evaluateMultiPattern(new ExprList(unpack),
+                                                         patternEnv),
+                                    types))
+                        matchBindingError(new MatchMultiBindingError(
+                            unsigned(formalArgs.size()), types, y));
+                } else {
+                    j = varArgSize - 1;
                 }
-
-                evaluatePredicate(x->patternVars, x->predicate, staticEnv);
-
-                EnvPtr env2 = new Env(staticEnv);
-                for (size_t i = 0, j = 0; i < formalArgs.size(); ++i) {
-                    FormalArgPtr y = formalArgs[i];
-                    if (y->varArg) {
-                        MultiPValuePtr varArgs = new MultiPValue();
-                        for (; j < varArgSize; ++j) {
-                            PVData parg(key[i + j], false);
-                            varArgs->values.push_back(parg);
-                        }
-                        --j;
-                        addLocal(env2, y->name, varArgs.ptr());
-                    } else {
-                        addLocal(env2, y->name, new PValue(key[i + j], false));
-                    }
+            } else {
+                if (y->type.ptr()) {
+                    if (!unifyPatternObj(
+                            evaluateOnePattern(y->type, patternEnv),
+                            key[i + j].ptr()))
+                        matchBindingError(new MatchBindingError(unsigned(i + j),
+                                                                key[i + j], y));
                 }
-                return env2;
             }
+        }
 
-            case ALIAS: {
-                ensureArity(x->args, 1);
-                ensureArity(x->values->exprs, 1);
-                EnvPtr env2 = new Env(env);
-                ExprPtr y = foreignExpr(env, x->values->exprs[0]);
-                addLocal(env2, x->args[0]->name, y.ptr());
-                return env2;
+        EnvPtr staticEnv = new Env(env);
+        for (size_t i = 0; i < pvars.size(); ++i) {
+            if (pvars[i].isMulti) {
+                MultiStaticPtr ms = derefDeep(multiCells[i].ptr());
+                if (!ms)
+                    error(pvars[i].name, "unbound pattern variable");
+                addLocal(staticEnv, pvars[i].name, ms.ptr());
+                x->patternTypes.push_back(ms.ptr());
+            } else {
+                ObjectPtr v = derefDeep(cells[i].ptr());
+                if (!v)
+                    error(pvars[i].name, "unbound pattern variable");
+                addLocal(staticEnv, pvars[i].name, v.ptr());
+                x->patternTypes.push_back(v.ptr());
             }
+        }
 
-            default:
-                assert(false);
-                return nullptr;
+        evaluatePredicate(x->patternVars, x->predicate, staticEnv);
+
+        EnvPtr env2 = new Env(staticEnv);
+        for (size_t i = 0, j = 0; i < formalArgs.size(); ++i) {
+            FormalArgPtr y = formalArgs[i];
+            if (y->varArg) {
+                MultiPValuePtr varArgs = new MultiPValue();
+                for (; j < varArgSize; ++j) {
+                    PVData parg(key[i + j], false);
+                    varArgs->values.push_back(parg);
+                }
+                --j;
+                addLocal(env2, y->name, varArgs.ptr());
+            } else {
+                addLocal(env2, y->name, new PValue(key[i + j], false));
+            }
         }
+        return env2;
     }
 
-    bool returnKindToByRef(ReturnKind returnKind, PVData const &pv) {
-        switch (returnKind) {
-            case RETURN_VALUE: return false;
-            case RETURN_REF: return true;
-            case RETURN_FORWARD: return !pv.isRValue;
-            default: assert(false);
-                return false;
-        }
+    case ALIAS: {
+        ensureArity(x->args, 1);
+        ensureArity(x->values->exprs, 1);
+        EnvPtr env2 = new Env(env);
+        ExprPtr y = foreignExpr(env, x->values->exprs[0]);
+        addLocal(env2, x->args[0]->name, y.ptr());
+        return env2;
     }
 
-    BoolKind typeBoolKind(TypePtr type) {
-        if (type == boolType) {
-            return BOOL_EXPR;
-        } else if (type->typeKind == STATIC_TYPE) {
-            StaticType *staticType = (StaticType *) type.ptr();
-            if (staticType->obj->objKind != VALUE_HOLDER) {
-                error("expecting value holder");
-            }
-            ValueHolder *valueHolder = (ValueHolder *) staticType->obj.ptr();
-            if (valueHolder->type != boolType) {
-                typeError(boolType, valueHolder->type);
-            }
-            bool staticValue = valueHolder->as<bool>();
-            return staticValue ? BOOL_STATIC_TRUE : BOOL_STATIC_FALSE;
-        } else {
-            typeError("Bool or static Bool", type);
-            return BOOL_STATIC_TRUE;
-        }
+    default:
+        assert(false);
+        return nullptr;
     }
+}
 
-    ExprPtr implicitUnpackExpr(size_t wantCount, const ExprListPtr &exprs) {
-        if (wantCount >= 1 && exprs->size() == 1 && exprs->exprs[0]->exprKind != UNPACK)
-            return exprs->exprs[0];
-        else
-            return nullptr;
+bool returnKindToByRef(ReturnKind returnKind, PVData const &pv) {
+    switch (returnKind) {
+    case RETURN_VALUE:
+        return false;
+    case RETURN_REF:
+        return true;
+    case RETURN_FORWARD:
+        return !pv.isRValue;
+    default:
+        assert(false);
+        return false;
+    }
+}
+
+BoolKind typeBoolKind(TypePtr type) {
+    if (type == boolType) {
+        return BOOL_EXPR;
+    } else if (type->typeKind == STATIC_TYPE) {
+        StaticType *staticType = (StaticType *)type.ptr();
+        if (staticType->obj->objKind != VALUE_HOLDER) {
+            error("expecting value holder");
+        }
+        ValueHolder *valueHolder = (ValueHolder *)staticType->obj.ptr();
+        if (valueHolder->type != boolType) {
+            typeError(boolType, valueHolder->type);
+        }
+        bool staticValue = valueHolder->as<bool>();
+        return staticValue ? BOOL_STATIC_TRUE : BOOL_STATIC_FALSE;
+    } else {
+        typeError("Bool or static Bool", type);
+        return BOOL_STATIC_TRUE;
     }
 }
+
+ExprPtr implicitUnpackExpr(size_t wantCount, const ExprListPtr &exprs) {
+    if (wantCount >= 1 && exprs->size() == 1 &&
+        exprs->exprs[0]->exprKind != UNPACK)
+        return exprs->exprs[0];
+    else
+        return nullptr;
+}
+} // namespace clay
diff --git a/compiler/analyzer.hpp b/compiler/analyzer.hpp
index ee73296b..81940127 100644
--- a/compiler/analyzer.hpp
+++ b/compiler/analyzer.hpp
@@ -2,139 +2,109 @@
 
 #include "clay.hpp"
 
+#include "invoketables.hpp"
 #include "types.hpp"
 
 namespace clay {
-    void disableAnalysisCaching();
-    void enableAnalysisCaching();
-
-    struct AnalysisCachingDisabler {
-        AnalysisCachingDisabler() { disableAnalysisCaching(); }
-        ~AnalysisCachingDisabler() { enableAnalysisCaching(); }
-    };
-
-    void initializeStaticForClones(StaticForPtr x, size_t count);
-    bool returnKindToByRef(ReturnKind returnKind, PVData const &pv);
-
-    ObjectPtr unwrapStaticType(TypePtr t);
-
-    bool staticToBool(ObjectPtr x, bool &out, TypePtr &type);
-    bool staticToBool(MultiStaticPtr x, unsigned index);
-    bool staticToCallingConv(ObjectPtr x, CallingConv &out);
-    CallingConv staticToCallingConv(MultiStaticPtr x, unsigned index);
-
-    static PVData staticPValue(const ObjectPtr& x) {
-        const TypePtr t = staticType(x);
-        return {t, true};
-    }
-
-    enum BoolKind {
-        BOOL_EXPR,
-        BOOL_STATIC_TRUE,
-        BOOL_STATIC_FALSE
-    };
-
-    BoolKind typeBoolKind(TypePtr type);
-
-    PVData safeAnalyzeOne(ExprPtr expr, EnvPtr env);
-    MultiPValuePtr safeAnalyzeMulti(ExprListPtr exprs, EnvPtr env, size_t wantCount);
-    MultiPValuePtr safeAnalyzeExpr(ExprPtr expr, EnvPtr env);
-    MultiPValuePtr safeAnalyzeIndexingExpr(ExprPtr indexable,
-                                           ExprListPtr args,
-                                           EnvPtr env);
-    MultiPValuePtr safeAnalyzeMultiArgs(ExprListPtr exprs,
-                                        EnvPtr env,
-                                        vector<unsigned> &dispatchIndices);
-    InvokeEntry *safeAnalyzeCallable(ObjectPtr x,
-                                     llvm::ArrayRef<PVData> args);
-    MultiPValuePtr safeAnalyzeCallByName(InvokeEntry *entry,
-                                         ExprPtr callable,
-                                         ExprListPtr args,
-                                         EnvPtr env);
-    MultiPValuePtr safeAnalyzeGVarInstance(GVarInstancePtr x);
-
-    MultiPValuePtr analyzeMulti(ExprListPtr exprs, EnvPtr env, size_t wantCount);
-    PVData analyzeOne(ExprPtr expr, EnvPtr env);
-
-    MultiPValuePtr analyzeMultiArgs(ExprListPtr exprs,
-                                    EnvPtr env,
-                                    vector<unsigned> &dispatchIndices);
-    PVData analyzeOneArg(ExprPtr x,
-                         EnvPtr env,
-                         unsigned startIndex,
-                         vector<unsigned> &dispatchIndices);
-    MultiPValuePtr analyzeArgExpr(ExprPtr x,
-                                  EnvPtr env,
-                                  unsigned startIndex,
-                                  vector<unsigned> &dispatchIndices);
-
-    MultiPValuePtr analyzeExpr(ExprPtr expr, EnvPtr env);
-    MultiPValuePtr analyzeStaticObject(ObjectPtr x);
-
-    GVarInstancePtr lookupGVarInstance(GlobalVariablePtr x,
-                                       llvm::ArrayRef<ObjectPtr> params);
-    GVarInstancePtr defaultGVarInstance(GlobalVariablePtr x);
-    GVarInstancePtr analyzeGVarIndexing(GlobalVariablePtr x,
-                                        ExprListPtr args,
-                                        EnvPtr env);
-    MultiPValuePtr analyzeGVarInstance(GVarInstancePtr x);
-
-    PVData analyzeExternalVariable(ExternalVariablePtr x);
-    void analyzeExternalProcedure(ExternalProcedurePtr x);
-    void verifyAttributes(ExternalProcedurePtr x);
-    void verifyAttributes(ExternalVariablePtr x);
-    void verifyAttributes(ModulePtr x);
-    MultiPValuePtr analyzeIndexingExpr(ExprPtr indexable,
-                                       ExprListPtr args,
+void disableAnalysisCaching();
+void enableAnalysisCaching();
+
+struct AnalysisCachingDisabler {
+    AnalysisCachingDisabler() { disableAnalysisCaching(); }
+    ~AnalysisCachingDisabler() { enableAnalysisCaching(); }
+};
+
+void initializeStaticForClones(StaticForPtr x, size_t count);
+bool returnKindToByRef(ReturnKind returnKind, PVData const &pv);
+
+ObjectPtr unwrapStaticType(TypePtr t);
+
+bool staticToBool(ObjectPtr x, bool &out, TypePtr &type);
+bool staticToBool(MultiStaticPtr x, unsigned index);
+bool staticToCallingConv(ObjectPtr x, CallingConv &out);
+CallingConv staticToCallingConv(MultiStaticPtr x, unsigned index);
+
+static PVData staticPValue(const ObjectPtr &x) {
+    const TypePtr t = staticType(x);
+    return {t, true};
+}
+
+enum BoolKind { BOOL_EXPR, BOOL_STATIC_TRUE, BOOL_STATIC_FALSE };
+
+BoolKind typeBoolKind(TypePtr type);
+
+PVData safeAnalyzeOne(ExprPtr expr, EnvPtr env);
+MultiPValuePtr safeAnalyzeMulti(ExprListPtr exprs, EnvPtr env,
+                                size_t wantCount);
+MultiPValuePtr safeAnalyzeExpr(ExprPtr expr, EnvPtr env);
+MultiPValuePtr safeAnalyzeIndexingExpr(ExprPtr indexable, ExprListPtr args,
                                        EnvPtr env);
-    bool unwrapByRef(TypePtr &t);
-    TypePtr constructType(ObjectPtr constructor, MultiStaticPtr args);
-    PVData analyzeTypeConstructor(ObjectPtr obj, MultiStaticPtr args);
-    MultiPValuePtr analyzeAliasIndexing(GlobalAliasPtr x,
-                                        ExprListPtr args,
-                                        EnvPtr env);
-    MultiPValuePtr analyzeReturn(llvm::ArrayRef<uint8_t> returnIsRef,
-                                 llvm::ArrayRef<TypePtr> returnTypes);
-    MultiPValuePtr analyzeCallExpr(ExprPtr callable,
-                                   ExprListPtr args,
+MultiPValuePtr safeAnalyzeMultiArgs(ExprListPtr exprs, EnvPtr env,
+                                    vector<unsigned> &dispatchIndices);
+InvokeEntry *safeAnalyzeCallable(ObjectPtr x, llvm::ArrayRef<PVData> args);
+MultiPValuePtr safeAnalyzeCallByName(InvokeEntry *entry, ExprPtr callable,
+                                     ExprListPtr args, EnvPtr env);
+MultiPValuePtr safeAnalyzeGVarInstance(GVarInstancePtr x);
+
+MultiPValuePtr analyzeMulti(ExprListPtr exprs, EnvPtr env, size_t wantCount);
+PVData analyzeOne(ExprPtr expr, EnvPtr env);
+
+MultiPValuePtr analyzeMultiArgs(ExprListPtr exprs, EnvPtr env,
+                                vector<unsigned> &dispatchIndices);
+PVData analyzeOneArg(ExprPtr x, EnvPtr env, unsigned startIndex,
+                     vector<unsigned> &dispatchIndices);
+MultiPValuePtr analyzeArgExpr(ExprPtr x, EnvPtr env, unsigned startIndex,
+                              vector<unsigned> &dispatchIndices);
+
+MultiPValuePtr analyzeExpr(ExprPtr expr, EnvPtr env);
+MultiPValuePtr analyzeStaticObject(ObjectPtr x);
+
+GVarInstancePtr lookupGVarInstance(GlobalVariablePtr x,
+                                   llvm::ArrayRef<ObjectPtr> params);
+GVarInstancePtr defaultGVarInstance(GlobalVariablePtr x);
+GVarInstancePtr analyzeGVarIndexing(GlobalVariablePtr x, ExprListPtr args,
+                                    EnvPtr env);
+MultiPValuePtr analyzeGVarInstance(GVarInstancePtr x);
+
+PVData analyzeExternalVariable(ExternalVariablePtr x);
+void analyzeExternalProcedure(ExternalProcedurePtr x);
+void verifyAttributes(ExternalProcedurePtr x);
+void verifyAttributes(ExternalVariablePtr x);
+void verifyAttributes(ModulePtr x);
+MultiPValuePtr analyzeIndexingExpr(ExprPtr indexable, ExprListPtr args,
                                    EnvPtr env);
-    PVData analyzeDispatchIndex(PVData const &pv, unsigned tag);
-    MultiPValuePtr analyzeDispatch(ObjectPtr obj,
-                                   MultiPValuePtr args,
-                                   llvm::ArrayRef<unsigned> dispatchIndices);
-    MultiPValuePtr analyzeCallValue(PVData const &callable,
-                                    MultiPValuePtr args);
-    MultiPValuePtr analyzeCallPointer(PVData const &x,
-                                      MultiPValuePtr args);
-    bool analyzeIsDefined(ObjectPtr x,
-                          llvm::ArrayRef<PVData> args);
-    InvokeEntry *analyzeCallable(ObjectPtr x,
-                                 llvm::ArrayRef<PVData> args);
-
-    MultiPValuePtr analyzeCallByName(InvokeEntry *entry,
-                                     ExprPtr callable,
-                                     ExprListPtr args,
-                                     EnvPtr env);
-
-    void analyzeCodeBody(InvokeEntry *entry);
-
-    struct AnalysisContext {
-        vector<uint8_t> returnIsRef;
-        vector<TypePtr> returnTypes;
-        bool hasRecursivePropagation: 1;
-        bool returnInitialized: 1;
-
-        AnalysisContext()
-            : hasRecursivePropagation(false),
-              returnInitialized(false) {
-        }
-    };
-
-    enum StatementAnalysis {
-        SA_FALLTHROUGH,
-        SA_RECURSIVE,
-        SA_TERMINATED
-    };
-
-    ExprPtr implicitUnpackExpr(size_t wantCount, const ExprListPtr &exprs);
-}
+bool unwrapByRef(TypePtr &t);
+TypePtr constructType(ObjectPtr constructor, MultiStaticPtr args);
+PVData analyzeTypeConstructor(ObjectPtr obj, MultiStaticPtr args);
+MultiPValuePtr analyzeAliasIndexing(GlobalAliasPtr x, ExprListPtr args,
+                                    EnvPtr env);
+MultiPValuePtr analyzeReturn(llvm::ArrayRef<uint8_t> returnIsRef,
+                             llvm::ArrayRef<TypePtr> returnTypes);
+MultiPValuePtr analyzeCallExpr(ExprPtr callable, ExprListPtr args, EnvPtr env);
+PVData analyzeDispatchIndex(PVData const &pv, unsigned tag);
+MultiPValuePtr analyzeDispatch(ObjectPtr obj, MultiPValuePtr args,
+                               llvm::ArrayRef<unsigned> dispatchIndices);
+MultiPValuePtr analyzeCallValue(PVData const &callable, MultiPValuePtr args);
+MultiPValuePtr analyzeCallPointer(PVData const &x, MultiPValuePtr args);
+bool analyzeIsDefined(ObjectPtr x, llvm::ArrayRef<PVData> args);
+InvokeEntry *analyzeCallable(ObjectPtr x, llvm::ArrayRef<PVData> args);
+
+MultiPValuePtr analyzeCallByName(InvokeEntry *entry, ExprPtr callable,
+                                 ExprListPtr args, EnvPtr env);
+
+void analyzeCodeBody(InvokeEntry *entry);
+
+struct AnalysisContext {
+    vector<uint8_t> returnIsRef;
+    vector<TypePtr> returnTypes;
+    bool hasRecursivePropagation : 1;
+    bool returnInitialized : 1;
+
+    AnalysisContext()
+        : hasRecursivePropagation(false), returnInitialized(false) {}
+};
+
+enum StatementAnalysis { SA_FALLTHROUGH, SA_RECURSIVE, SA_TERMINATED };
+
+ExprPtr implicitUnpackExpr(size_t wantCount, const ExprListPtr &exprs);
+} // namespace clay
diff --git a/compiler/analyzer_op.cpp b/compiler/analyzer_op.cpp
index b1ace831..c93a66a1 100644
--- a/compiler/analyzer_op.cpp
+++ b/compiler/analyzer_op.cpp
@@ -1,1060 +1,1053 @@
-#include "error.hpp"
-#include "objects.hpp"
-#include "evaluator.hpp"
+#include "analyzer_op.hpp"
+#include "analyzer.hpp"
 #include "constructors.hpp"
-#include "loader.hpp"
 #include "env.hpp"
-#include "analyzer.hpp"
-#include "analyzer_op.hpp"
+#include "error.hpp"
+#include "evaluator.hpp"
 #include "invoketables.hpp"
+#include "loader.hpp"
+#include "objects.hpp"
 
 namespace clay {
-    static size_t staticToSizeTOrIntValue(MultiPValue *args, size_t index) {
-        ObjectPtr obj = unwrapStaticType(args->values[index].type);
-        if (obj->objKind == VALUE_HOLDER) {
-            ValueHolderPtr vh = (ValueHolder *) obj.ptr();
-            if (vh->type == cSizeTType) {
-                return *((size_t *) vh->buf);
-            } else if (vh->type == cIntType) {
-                return (size_t) *((int *) vh->buf);
-            }
-        }
-        argumentError(index, "expecting static SizeT or Int value", args->values[index]);
-    }
-
-    static TypePtr numericTypeOfValue(MultiPValuePtr x, unsigned index) {
-        TypePtr t = x->values[index].type;
-        switch (t->typeKind) {
-            case INTEGER_TYPE:
-            case FLOAT_TYPE:
-                return t;
-            default:
-                argumentTypeError(index, "numeric type", t);
-                return nullptr;
+static size_t staticToSizeTOrIntValue(MultiPValue *args, size_t index) {
+    ObjectPtr obj = unwrapStaticType(args->values[index].type);
+    if (obj->objKind == VALUE_HOLDER) {
+        ValueHolderPtr vh = (ValueHolder *)obj.ptr();
+        if (vh->type == cSizeTType) {
+            return *((size_t *)vh->buf);
+        } else if (vh->type == cIntType) {
+            return (size_t)*((int *)vh->buf);
         }
     }
+    argumentError(index, "expecting static SizeT or Int value",
+                  args->values[index]);
+}
 
-    static IntegerTypePtr integerTypeOfValue(MultiPValuePtr x, unsigned index) {
-        TypePtr t = x->values[index].type;
-        if (t->typeKind != INTEGER_TYPE)
-            argumentTypeError(index, "integer type", t);
-        return (IntegerType *) t.ptr();
+static TypePtr numericTypeOfValue(MultiPValuePtr x, unsigned index) {
+    TypePtr t = x->values[index].type;
+    switch (t->typeKind) {
+    case INTEGER_TYPE:
+    case FLOAT_TYPE:
+        return t;
+    default:
+        argumentTypeError(index, "numeric type", t);
+        return nullptr;
     }
+}
 
-    static PointerTypePtr pointerTypeOfValue(MultiPValuePtr x, unsigned index) {
-        TypePtr t = x->values[index].type;
-        if (t->typeKind != POINTER_TYPE)
-            argumentTypeError(index, "pointer type", t);
-        return (PointerType *) t.ptr();
-    }
+static IntegerTypePtr integerTypeOfValue(MultiPValuePtr x, unsigned index) {
+    TypePtr t = x->values[index].type;
+    if (t->typeKind != INTEGER_TYPE)
+        argumentTypeError(index, "integer type", t);
+    return (IntegerType *)t.ptr();
+}
 
-    static CCodePointerTypePtr cCodePointerTypeOfValue(MultiPValuePtr x,
-                                                       unsigned index) {
-        TypePtr t = x->values[index].type;
-        if (t->typeKind != CCODE_POINTER_TYPE)
-            argumentTypeError(index, "external code pointer type", t);
-        return (CCodePointerType *) t.ptr();
-    }
+static PointerTypePtr pointerTypeOfValue(MultiPValuePtr x, unsigned index) {
+    TypePtr t = x->values[index].type;
+    if (t->typeKind != POINTER_TYPE)
+        argumentTypeError(index, "pointer type", t);
+    return (PointerType *)t.ptr();
+}
 
-    static ArrayTypePtr arrayTypeOfValue(MultiPValuePtr x, unsigned index) {
-        TypePtr t = x->values[index].type;
-        if (t->typeKind != ARRAY_TYPE)
-            argumentTypeError(index, "array type", t);
-        return (ArrayType *) t.ptr();
-    }
+static CCodePointerTypePtr cCodePointerTypeOfValue(MultiPValuePtr x,
+                                                   unsigned index) {
+    TypePtr t = x->values[index].type;
+    if (t->typeKind != CCODE_POINTER_TYPE)
+        argumentTypeError(index, "external code pointer type", t);
+    return (CCodePointerType *)t.ptr();
+}
 
-    static TupleTypePtr tupleTypeOfValue(MultiPValuePtr x, unsigned index) {
-        TypePtr t = x->values[index].type;
-        if (t->typeKind != TUPLE_TYPE)
-            argumentTypeError(index, "tuple type", t);
-        return (TupleType *) t.ptr();
-    }
+static ArrayTypePtr arrayTypeOfValue(MultiPValuePtr x, unsigned index) {
+    TypePtr t = x->values[index].type;
+    if (t->typeKind != ARRAY_TYPE)
+        argumentTypeError(index, "array type", t);
+    return (ArrayType *)t.ptr();
+}
 
-    static RecordTypePtr recordTypeOfValue(MultiPValuePtr x, unsigned index) {
-        TypePtr t = x->values[index].type;
-        if (t->typeKind != RECORD_TYPE)
-            argumentTypeError(index, "record type", t);
-        return (RecordType *) t.ptr();
-    }
+static TupleTypePtr tupleTypeOfValue(MultiPValuePtr x, unsigned index) {
+    TypePtr t = x->values[index].type;
+    if (t->typeKind != TUPLE_TYPE)
+        argumentTypeError(index, "tuple type", t);
+    return (TupleType *)t.ptr();
+}
 
-    static TypePtr valueToType(MultiPValuePtr x, unsigned index) {
-        ObjectPtr obj = unwrapStaticType(x->values[index].type);
-        if (!obj)
-            argumentError(index, "expecting a type");
-        TypePtr t;
-        if (!staticToType(obj, t))
-            argumentError(index, "expecting a type");
+static RecordTypePtr recordTypeOfValue(MultiPValuePtr x, unsigned index) {
+    TypePtr t = x->values[index].type;
+    if (t->typeKind != RECORD_TYPE)
+        argumentTypeError(index, "record type", t);
+    return (RecordType *)t.ptr();
+}
+
+static TypePtr valueToType(MultiPValuePtr x, unsigned index) {
+    ObjectPtr obj = unwrapStaticType(x->values[index].type);
+    if (!obj)
+        argumentError(index, "expecting a type");
+    TypePtr t;
+    if (!staticToType(obj, t))
+        argumentError(index, "expecting a type");
+    return t;
+}
+
+static TypePtr valueToNumericType(MultiPValuePtr x, unsigned index) {
+    TypePtr t = valueToType(x, index);
+    switch (t->typeKind) {
+    case INTEGER_TYPE:
+    case FLOAT_TYPE:
         return t;
+    default:
+        argumentTypeError(index, "numeric type", t);
+        return nullptr;
     }
+}
 
-    static TypePtr valueToNumericType(MultiPValuePtr x, unsigned index) {
-        TypePtr t = valueToType(x, index);
-        switch (t->typeKind) {
-            case INTEGER_TYPE:
-            case FLOAT_TYPE:
-                return t;
-            default:
-                argumentTypeError(index, "numeric type", t);
-                return nullptr;
-        }
-    }
+static IntegerTypePtr valueToIntegerType(MultiPValuePtr x, unsigned index) {
+    TypePtr t = valueToType(x, index);
+    if (t->typeKind != INTEGER_TYPE)
+        argumentTypeError(index, "integer type", t);
+    return (IntegerType *)t.ptr();
+}
+
+static TypePtr valueToPointerLikeType(MultiPValuePtr x, unsigned index) {
+    TypePtr t = valueToType(x, index);
+    if (!isPointerOrCodePointerType(t))
+        argumentTypeError(index, "pointer or code-pointer type", t);
+    return t;
+}
 
-    static IntegerTypePtr valueToIntegerType(MultiPValuePtr x, unsigned index) {
-        TypePtr t = valueToType(x, index);
-        if (t->typeKind != INTEGER_TYPE)
-            argumentTypeError(index, "integer type", t);
-        return (IntegerType *) t.ptr();
+static EnumTypePtr valueToEnumType(MultiPValuePtr x, unsigned index) {
+    TypePtr t = valueToType(x, index);
+    if (t->typeKind != ENUM_TYPE)
+        argumentTypeError(index, "enum type", t);
+    return (EnumType *)t.ptr();
+}
+
+static std::pair<vector<TypePtr>, InvokeEntry *>
+invokeEntryForCallableArguments(MultiPValuePtr args, unsigned callableIndex,
+                                unsigned firstArgTypeIndex) {
+    if (args->size() < firstArgTypeIndex)
+        arityError2(firstArgTypeIndex, args->size());
+    ObjectPtr callable = unwrapStaticType(args->values[callableIndex].type);
+    if (!callable)
+        argumentError(callableIndex, "static callable expected");
+    switch (callable->objKind) {
+    case TYPE:
+    case RECORD_DECL:
+    case VARIANT_DECL:
+    case PROCEDURE:
+    case GLOBAL_ALIAS:
+        break;
+    case PRIM_OP:
+        if (!isOverloadablePrimOp(callable))
+            argumentError(callableIndex, "invalid callable");
+        break;
+    default:
+        argumentError(callableIndex, "invalid callable");
+    }
+    vector<TypePtr> argTypes;
+    vector<PVData> argsPVData;
+    for (unsigned i = firstArgTypeIndex; i < args->size(); ++i) {
+        TypePtr t = valueToType(args, i);
+        argTypes.push_back(t);
+        argsPVData.push_back(PVData(t, false));
     }
 
-    static TypePtr valueToPointerLikeType(MultiPValuePtr x, unsigned index) {
-        TypePtr t = valueToType(x, index);
-        if (!isPointerOrCodePointerType(t))
-            argumentTypeError(index, "pointer or code-pointer type", t);
-        return t;
+    CompileContextPusher pusher(callable, argsPVData);
+
+    return std::make_pair(argTypes, analyzeCallable(callable, argsPVData));
+}
+
+MultiPValuePtr analyzePrimOp(PrimOpPtr x, MultiPValuePtr args) {
+    switch (x->primOpCode) {
+    case PRIM_TypeP:
+        return new MultiPValue(PVData(boolType, true));
+
+    case PRIM_TypeSize:
+        return new MultiPValue(PVData(cSizeTType, true));
+
+    case PRIM_TypeAlignment:
+        return new MultiPValue(PVData(cSizeTType, true));
+
+    case PRIM_OperatorP:
+    case PRIM_SymbolP:
+    case PRIM_StaticCallDefinedP:
+        return new MultiPValue(PVData(boolType, true));
+
+    case PRIM_StaticCallOutputTypes: {
+        std::pair<vector<TypePtr>, InvokeEntry *> entry =
+            invokeEntryForCallableArguments(args, 0, 1);
+        MultiPValuePtr values = new MultiPValue();
+        for (size_t i = 0; i < entry.second->returnTypes.size(); ++i)
+            values->add(staticPValue(entry.second->returnTypes[i].ptr()));
+        return values;
     }
 
-    static EnumTypePtr valueToEnumType(MultiPValuePtr x, unsigned index) {
-        TypePtr t = valueToType(x, index);
-        if (t->typeKind != ENUM_TYPE)
-            argumentTypeError(index, "enum type", t);
-        return (EnumType *) t.ptr();
+    case PRIM_StaticMonoP: {
+        return new MultiPValue(PVData(boolType, true));
     }
 
-    static std::pair<vector<TypePtr>, InvokeEntry *>
-    invokeEntryForCallableArguments(MultiPValuePtr args, unsigned callableIndex, unsigned firstArgTypeIndex) {
-        if (args->size() < firstArgTypeIndex)
-            arityError2(firstArgTypeIndex, args->size());
-        ObjectPtr callable = unwrapStaticType(args->values[callableIndex].type);
+    case PRIM_StaticMonoInputTypes: {
+        ensureArity(args, 1);
+        ObjectPtr callable = unwrapStaticType(args->values[0].type);
         if (!callable)
-            argumentError(callableIndex, "static callable expected");
+            argumentError(0, "static callable expected");
+
         switch (callable->objKind) {
-            case TYPE:
-            case RECORD_DECL:
-            case VARIANT_DECL:
-            case PROCEDURE:
-            case GLOBAL_ALIAS:
-                break;
-            case PRIM_OP:
-                if (!isOverloadablePrimOp(callable))
-                    argumentError(callableIndex, "invalid callable");
-                break;
-            default:
-                argumentError(callableIndex, "invalid callable");
+        case PROCEDURE: {
+            Procedure *proc = (Procedure *)callable.ptr();
+            if (proc->mono.monoState != Procedure_MonoOverload) {
+                argumentError(0, "not a static monomorphic callable");
+            }
+
+            MultiPValuePtr values = new MultiPValue();
+            for (size_t i = 0; i < proc->mono.monoTypes.size(); ++i)
+                values->add(staticPValue(proc->mono.monoTypes[i].ptr()));
+
+            return values;
         }
-        vector<TypePtr> argTypes;
-        vector<PVData> argsPVData;
-        for (unsigned i = firstArgTypeIndex; i < args->size(); ++i) {
-            TypePtr t = valueToType(args, i);
-            argTypes.push_back(t);
-            argsPVData.push_back(PVData(t, false));
+
+        default:
+            argumentError(0, "not a static monomorphic callable");
         }
+    }
 
-        CompileContextPusher pusher(callable, argsPVData);
+    case PRIM_bitcopy:
+        return new MultiPValue();
+
+    case PRIM_boolNot:
+        return new MultiPValue(PVData(boolType, true));
+
+    case PRIM_integerEqualsP:
+    case PRIM_integerLesserP:
+    case PRIM_floatOrderedEqualsP:
+    case PRIM_floatOrderedLesserP:
+    case PRIM_floatOrderedLesserEqualsP:
+    case PRIM_floatOrderedGreaterP:
+    case PRIM_floatOrderedGreaterEqualsP:
+    case PRIM_floatOrderedNotEqualsP:
+    case PRIM_floatOrderedP:
+    case PRIM_floatUnorderedEqualsP:
+    case PRIM_floatUnorderedLesserP:
+    case PRIM_floatUnorderedLesserEqualsP:
+    case PRIM_floatUnorderedGreaterP:
+    case PRIM_floatUnorderedGreaterEqualsP:
+    case PRIM_floatUnorderedNotEqualsP:
+    case PRIM_floatUnorderedP:
+        ensureArity(args, 2);
+        return new MultiPValue(PVData(boolType, true));
+
+    case PRIM_numericAdd:
+    case PRIM_numericSubtract:
+    case PRIM_numericMultiply:
+    case PRIM_floatDivide: {
+        ensureArity(args, 2);
+        TypePtr t = numericTypeOfValue(args, 0);
+        return new MultiPValue(PVData(t, true));
+    }
 
-        return std::make_pair(
-            argTypes,
-            analyzeCallable(callable, argsPVData));
+    case PRIM_numericNegate: {
+        ensureArity(args, 1);
+        TypePtr t = numericTypeOfValue(args, 0);
+        return new MultiPValue(PVData(t, true));
     }
 
-    MultiPValuePtr analyzePrimOp(PrimOpPtr x, MultiPValuePtr args) {
-        switch (x->primOpCode) {
-            case PRIM_TypeP:
-                return new MultiPValue(PVData(boolType, true));
+    case PRIM_integerQuotient:
+    case PRIM_integerRemainder:
+    case PRIM_integerShiftLeft:
+    case PRIM_integerShiftRight:
+    case PRIM_integerBitwiseAnd:
+    case PRIM_integerBitwiseOr:
+    case PRIM_integerBitwiseXor:
+    case PRIM_integerAddChecked:
+    case PRIM_integerSubtractChecked:
+    case PRIM_integerMultiplyChecked:
+    case PRIM_integerQuotientChecked:
+    case PRIM_integerRemainderChecked:
+    case PRIM_integerShiftLeftChecked: {
+        ensureArity(args, 2);
+        IntegerTypePtr t = integerTypeOfValue(args, 0);
+        return new MultiPValue(PVData(t.ptr(), true));
+    }
 
-            case PRIM_TypeSize:
-                return new MultiPValue(PVData(cSizeTType, true));
+    case PRIM_integerBitwiseNot:
+    case PRIM_integerNegateChecked: {
+        ensureArity(args, 1);
+        IntegerTypePtr t = integerTypeOfValue(args, 0);
+        return new MultiPValue(PVData(t.ptr(), true));
+    }
 
-            case PRIM_TypeAlignment:
-                return new MultiPValue(PVData(cSizeTType, true));
+    case PRIM_numericConvert: {
+        ensureArity(args, 2);
+        TypePtr t = valueToNumericType(args, 0);
+        return new MultiPValue(PVData(t, true));
+    }
 
-            case PRIM_OperatorP:
-            case PRIM_SymbolP:
-            case PRIM_StaticCallDefinedP:
-                return new MultiPValue(PVData(boolType, true));
+    case PRIM_integerConvertChecked: {
+        ensureArity(args, 2);
+        IntegerTypePtr t = valueToIntegerType(args, 0);
+        return new MultiPValue(PVData(t.ptr(), true));
+    }
 
-            case PRIM_StaticCallOutputTypes: {
-                std::pair<vector<TypePtr>, InvokeEntry *> entry =
-                        invokeEntryForCallableArguments(args, 0, 1);
-                MultiPValuePtr values = new MultiPValue();
-                for (size_t i = 0; i < entry.second->returnTypes.size(); ++i)
-                    values->add(staticPValue(entry.second->returnTypes[i].ptr()));
-                return values;
-            }
+    case PRIM_Pointer:
+        error("no Pointer type constructor overload found");
 
-            case PRIM_StaticMonoP: {
-                return new MultiPValue(PVData(boolType, true));
-            }
+    case PRIM_addressOf: {
+        ensureArity(args, 1);
+        TypePtr t = pointerType(args->values[0].type);
+        return new MultiPValue(PVData(t, true));
+    }
 
-            case PRIM_StaticMonoInputTypes: {
-                ensureArity(args, 1);
-                ObjectPtr callable = unwrapStaticType(args->values[0].type);
-                if (!callable)
-                    argumentError(0, "static callable expected");
-
-                switch (callable->objKind) {
-                    case PROCEDURE: {
-                        Procedure *proc = (Procedure *) callable.ptr();
-                        if (proc->mono.monoState != Procedure_MonoOverload) {
-                            argumentError(0, "not a static monomorphic callable");
-                        }
-
-                        MultiPValuePtr values = new MultiPValue();
-                        for (size_t i = 0; i < proc->mono.monoTypes.size(); ++i)
-                            values->add(staticPValue(proc->mono.monoTypes[i].ptr()));
-
-                        return values;
-                    }
-
-                    default:
-                        argumentError(0, "not a static monomorphic callable");
-                }
-            }
+    case PRIM_pointerDereference: {
+        ensureArity(args, 1);
+        PointerTypePtr pt = pointerTypeOfValue(args, 0);
+        return new MultiPValue(PVData(pt->pointeeType, false));
+    }
 
-            case PRIM_bitcopy:
-                return new MultiPValue();
-
-            case PRIM_boolNot:
-                return new MultiPValue(PVData(boolType, true));
-
-            case PRIM_integerEqualsP:
-            case PRIM_integerLesserP:
-            case PRIM_floatOrderedEqualsP:
-            case PRIM_floatOrderedLesserP:
-            case PRIM_floatOrderedLesserEqualsP:
-            case PRIM_floatOrderedGreaterP:
-            case PRIM_floatOrderedGreaterEqualsP:
-            case PRIM_floatOrderedNotEqualsP:
-            case PRIM_floatOrderedP:
-            case PRIM_floatUnorderedEqualsP:
-            case PRIM_floatUnorderedLesserP:
-            case PRIM_floatUnorderedLesserEqualsP:
-            case PRIM_floatUnorderedGreaterP:
-            case PRIM_floatUnorderedGreaterEqualsP:
-            case PRIM_floatUnorderedNotEqualsP:
-            case PRIM_floatUnorderedP:
-                ensureArity(args, 2);
-                return new MultiPValue(PVData(boolType, true));
-
-            case PRIM_numericAdd:
-            case PRIM_numericSubtract:
-            case PRIM_numericMultiply:
-            case PRIM_floatDivide: {
-                ensureArity(args, 2);
-                TypePtr t = numericTypeOfValue(args, 0);
-                return new MultiPValue(PVData(t, true));
-            }
+    case PRIM_pointerOffset: {
+        ensureArity(args, 2);
+        PointerTypePtr pt = pointerTypeOfValue(args, 0);
+        return new MultiPValue(PVData(pt.ptr(), true));
+    }
 
-            case PRIM_numericNegate: {
-                ensureArity(args, 1);
-                TypePtr t = numericTypeOfValue(args, 0);
-                return new MultiPValue(PVData(t, true));
-            }
+    case PRIM_pointerToInt: {
+        ensureArity(args, 2);
+        IntegerTypePtr t = valueToIntegerType(args, 0);
+        return new MultiPValue(PVData(t.ptr(), true));
+    }
 
-            case PRIM_integerQuotient:
-            case PRIM_integerRemainder:
-            case PRIM_integerShiftLeft:
-            case PRIM_integerShiftRight:
-            case PRIM_integerBitwiseAnd:
-            case PRIM_integerBitwiseOr:
-            case PRIM_integerBitwiseXor:
-            case PRIM_integerAddChecked:
-            case PRIM_integerSubtractChecked:
-            case PRIM_integerMultiplyChecked:
-            case PRIM_integerQuotientChecked:
-            case PRIM_integerRemainderChecked:
-            case PRIM_integerShiftLeftChecked: {
-                ensureArity(args, 2);
-                IntegerTypePtr t = integerTypeOfValue(args, 0);
-                return new MultiPValue(PVData(t.ptr(), true));
-            }
+    case PRIM_intToPointer: {
+        ensureArity(args, 2);
+        TypePtr t = valueToPointerLikeType(args, 0);
+        return new MultiPValue(PVData(t, true));
+    }
 
-            case PRIM_integerBitwiseNot:
-            case PRIM_integerNegateChecked: {
-                ensureArity(args, 1);
-                IntegerTypePtr t = integerTypeOfValue(args, 0);
-                return new MultiPValue(PVData(t.ptr(), true));
-            }
+    case PRIM_nullPointer: {
+        ensureArity(args, 1);
+        TypePtr t = valueToPointerLikeType(args, 0);
+        return new MultiPValue(PVData(t, true));
+    }
 
-            case PRIM_numericConvert: {
-                ensureArity(args, 2);
-                TypePtr t = valueToNumericType(args, 0);
-                return new MultiPValue(PVData(t, true));
-            }
+    case PRIM_CodePointer:
+        error("no CodePointer type constructor overload found");
+
+    case PRIM_makeCodePointer: {
+        std::pair<vector<TypePtr>, InvokeEntry *> entry =
+            invokeEntryForCallableArguments(args, 0, 1);
+        if (entry.second->callByName)
+            argumentError(0, "cannot create pointer to call-by-name code");
+        if (!entry.second->analyzed)
+            return nullptr;
+        TypePtr cpType = codePointerType(entry.first, entry.second->returnIsRef,
+                                         entry.second->returnTypes);
+        return new MultiPValue(PVData(cpType, true));
+    }
 
-            case PRIM_integerConvertChecked: {
-                ensureArity(args, 2);
-                IntegerTypePtr t = valueToIntegerType(args, 0);
-                return new MultiPValue(PVData(t.ptr(), true));
-            }
+    case PRIM_ExternalCodePointer:
+        error("no ExternalCodePointer type constructor overload found");
+
+    case PRIM_makeExternalCodePointer: {
+        std::pair<vector<TypePtr>, InvokeEntry *> entry =
+            invokeEntryForCallableArguments(args, 0, 3);
+        if (entry.second->callByName)
+            argumentError(0, "cannot create pointer to call-by-name code");
+        if (!entry.second->analyzed)
+            return nullptr;
+
+        ObjectPtr ccObj = unwrapStaticType(args->values[1].type);
+        CallingConv cc;
+        if (!staticToCallingConv(ccObj, cc))
+            argumentError(1, "expecting a calling convention attribute");
+
+        ObjectPtr isVarArgObj = unwrapStaticType(args->values[2].type);
+        bool isVarArg;
+        TypePtr type;
+        if (!staticToBool(isVarArgObj, isVarArg, type))
+            argumentTypeError(2, "static Bool", type);
+
+        if (isVarArg)
+            argumentError(2, "implementation of external variadic functions is "
+                             "not yet supported");
+
+        TypePtr returnType;
+        if (entry.second->returnTypes.empty()) {
+            returnType = nullptr;
+        } else if (entry.second->returnTypes.size() == 1) {
+            if (entry.second->returnIsRef[0]) {
+                argumentError(0, "cannot create external code pointer to "
+                                 " return-by-reference code");
+            }
+            returnType = entry.second->returnTypes[0];
+        } else {
+            argumentError(0, "cannot create external code pointer to "
+                             "multi-return code");
+        }
+        TypePtr ccpType =
+            cCodePointerType(cc, entry.first, isVarArg, returnType);
+        return new MultiPValue(PVData(ccpType, true));
+    }
 
-            case PRIM_Pointer:
-                error("no Pointer type constructor overload found");
+    case PRIM_callExternalCodePointer: {
+        if (args->size() < 1)
+            arityError2(1, args->size());
+        CCodePointerTypePtr y = cCodePointerTypeOfValue(args, 0);
+        if (!y->returnType)
+            return new MultiPValue();
+        return new MultiPValue(PVData(y->returnType, true));
+    }
 
-            case PRIM_addressOf: {
-                ensureArity(args, 1);
-                TypePtr t = pointerType(args->values[0].type);
-                return new MultiPValue(PVData(t, true));
-            }
+    case PRIM_bitcast: {
+        ensureArity(args, 2);
+        TypePtr t = valueToType(args, 0);
+        return new MultiPValue(PVData(t, false));
+    }
 
-            case PRIM_pointerDereference: {
-                ensureArity(args, 1);
-                PointerTypePtr pt = pointerTypeOfValue(args, 0);
-                return new MultiPValue(PVData(pt->pointeeType, false));
-            }
+    case PRIM_Array:
+        error("no Array type constructor overload found");
 
-            case PRIM_pointerOffset: {
-                ensureArity(args, 2);
-                PointerTypePtr pt = pointerTypeOfValue(args, 0);
-                return new MultiPValue(PVData(pt.ptr(), true));
-            }
+    case PRIM_arrayRef: {
+        ensureArity(args, 2);
+        ArrayTypePtr t = arrayTypeOfValue(args, 0);
+        return new MultiPValue(PVData(t->elementType, false));
+    }
 
-            case PRIM_pointerToInt: {
-                ensureArity(args, 2);
-                IntegerTypePtr t = valueToIntegerType(args, 0);
-                return new MultiPValue(PVData(t.ptr(), true));
-            }
+    case PRIM_arrayElements: {
+        ensureArity(args, 1);
+        ArrayTypePtr t = arrayTypeOfValue(args, 0);
+        MultiPValuePtr mpv = new MultiPValue();
+        for (size_t i = 0; i < t->size; ++i)
+            mpv->add(PVData(t->elementType, false));
+        return mpv;
+    }
 
-            case PRIM_intToPointer: {
-                ensureArity(args, 2);
-                TypePtr t = valueToPointerLikeType(args, 0);
-                return new MultiPValue(PVData(t, true));
-            }
+    case PRIM_Vec:
+        error("no Vec type constructor overload found");
 
-            case PRIM_nullPointer: {
-                ensureArity(args, 1);
-                TypePtr t = valueToPointerLikeType(args, 0);
-                return new MultiPValue(PVData(t, true));
-            }
+    case PRIM_Tuple:
+        error("no Tuple type constructor overload found");
 
-            case PRIM_CodePointer:
-                error("no CodePointer type constructor overload found");
-
-            case PRIM_makeCodePointer: {
-                std::pair<vector<TypePtr>, InvokeEntry *> entry =
-                        invokeEntryForCallableArguments(args, 0, 1);
-                if (entry.second->callByName)
-                    argumentError(0, "cannot create pointer to call-by-name code");
-                if (!entry.second->analyzed)
-                    return nullptr;
-                TypePtr cpType = codePointerType(entry.first,
-                                                 entry.second->returnIsRef,
-                                                 entry.second->returnTypes);
-                return new MultiPValue(PVData(cpType, true));
-            }
+    case PRIM_TupleElementCount:
+        return new MultiPValue(PVData(cSizeTType, true));
 
-            case PRIM_ExternalCodePointer:
-                error("no ExternalCodePointer type constructor overload found");
-
-            case PRIM_makeExternalCodePointer: {
-                std::pair<vector<TypePtr>, InvokeEntry *> entry =
-                        invokeEntryForCallableArguments(args, 0, 3);
-                if (entry.second->callByName)
-                    argumentError(0, "cannot create pointer to call-by-name code");
-                if (!entry.second->analyzed)
-                    return nullptr;
-
-                ObjectPtr ccObj = unwrapStaticType(args->values[1].type);
-                CallingConv cc;
-                if (!staticToCallingConv(ccObj, cc))
-                    argumentError(1, "expecting a calling convention attribute");
-
-                ObjectPtr isVarArgObj = unwrapStaticType(args->values[2].type);
-                bool isVarArg;
-                TypePtr type;
-                if (!staticToBool(isVarArgObj, isVarArg, type))
-                    argumentTypeError(2, "static Bool", type);
-
-                if (isVarArg)
-                    argumentError(2, "implementation of external variadic functions is not yet supported");
-
-                TypePtr returnType;
-                if (entry.second->returnTypes.empty()) {
-                    returnType = nullptr;
-                } else if (entry.second->returnTypes.size() == 1) {
-                    if (entry.second->returnIsRef[0]) {
-                        argumentError(0, "cannot create external code pointer to "
-                                      " return-by-reference code");
-                    }
-                    returnType = entry.second->returnTypes[0];
-                } else {
-                    argumentError(0, "cannot create external code pointer to "
-                                  "multi-return code");
-                }
-                TypePtr ccpType = cCodePointerType(cc,
-                                                   entry.first,
-                                                   isVarArg,
-                                                   returnType);
-                return new MultiPValue(PVData(ccpType, true));
-            }
+    case PRIM_tupleRef: {
+        ensureArity(args, 2);
+        TupleTypePtr t = tupleTypeOfValue(args, 0);
+        size_t i = staticToSizeTOrIntValue(args.ptr(), 1);
+        if (i >= t->elementTypes.size())
+            argumentIndexRangeError(1, "tuple element index", i,
+                                    t->elementTypes.size());
+        return new MultiPValue(PVData(t->elementTypes[i], false));
+    }
 
-            case PRIM_callExternalCodePointer: {
-                if (args->size() < 1)
-                    arityError2(1, args->size());
-                CCodePointerTypePtr y = cCodePointerTypeOfValue(args, 0);
-                if (!y->returnType)
-                    return new MultiPValue();
-                return new MultiPValue(PVData(y->returnType, true));
-            }
+    case PRIM_tupleElements: {
+        ensureArity(args, 1);
+        TupleTypePtr t = tupleTypeOfValue(args, 0);
+        MultiPValuePtr mpv = new MultiPValue();
+        for (size_t i = 0; i < t->elementTypes.size(); ++i)
+            mpv->add(PVData(t->elementTypes[i], false));
+        return mpv;
+    }
 
-            case PRIM_bitcast: {
-                ensureArity(args, 2);
-                TypePtr t = valueToType(args, 0);
-                return new MultiPValue(PVData(t, false));
-            }
+    case PRIM_Union:
+        error("no Union type constructor overload found");
 
-            case PRIM_Array:
-                error("no Array type constructor overload found");
+    case PRIM_UnionMemberCount:
+        return new MultiPValue(PVData(cSizeTType, true));
 
-            case PRIM_arrayRef: {
-                ensureArity(args, 2);
-                ArrayTypePtr t = arrayTypeOfValue(args, 0);
-                return new MultiPValue(PVData(t->elementType, false));
-            }
+    case PRIM_RecordP:
+        return new MultiPValue(PVData(boolType, true));
 
-            case PRIM_arrayElements: {
-                ensureArity(args, 1);
-                ArrayTypePtr t = arrayTypeOfValue(args, 0);
-                MultiPValuePtr mpv = new MultiPValue();
-                for (size_t i = 0; i < t->size; ++i)
-                    mpv->add(PVData(t->elementType, false));
-                return mpv;
-            }
+    case PRIM_RecordFieldCount:
+        return new MultiPValue(PVData(cSizeTType, true));
 
-            case PRIM_Vec:
-                error("no Vec type constructor overload found");
+    case PRIM_RecordFieldName: {
+        ensureArity(args, 2);
+        ObjectPtr first = unwrapStaticType(args->values[0].type);
+        if (!first)
+            argumentError(0, "expecting a record type");
+        TypePtr t;
+        if (!staticToType(first, t))
+            argumentError(0, "expecting a record type");
+        if (t->typeKind != RECORD_TYPE)
+            argumentError(0, "expecting a record type");
+        RecordType *rt = (RecordType *)t.ptr();
+        size_t i = staticToSizeTOrIntValue(args.ptr(), 1);
+        const vector<IdentifierPtr> fieldNames = recordFieldNames(rt);
+        if (i >= fieldNames.size())
+            argumentIndexRangeError(1, "record field index", i,
+                                    fieldNames.size());
+        return new MultiPValue(staticPValue(fieldNames[i].ptr()));
+    }
 
-            case PRIM_Tuple:
-                error("no Tuple type constructor overload found");
+    case PRIM_RecordWithFieldP:
+        return new MultiPValue(PVData(boolType, true));
+
+    case PRIM_recordFieldRef: {
+        ensureArity(args, 2);
+        RecordTypePtr t = recordTypeOfValue(args, 0);
+        size_t i = staticToSizeTOrIntValue(args.ptr(), 1);
+        llvm::ArrayRef<TypePtr> fieldTypes = recordFieldTypes(t);
+        if (i >= t->fieldCount())
+            argumentIndexRangeError(1, "record field index", i,
+                                    t->fieldCount());
+
+        MultiPValuePtr mpv = new MultiPValue();
+        if (t->hasVarField && i >= t->varFieldPosition)
+            if (i == t->varFieldPosition)
+                for (size_t j = 0; j < t->varFieldSize(); ++j)
+                    mpv->add(PVData(fieldTypes[i + j], false));
+            else
+                mpv->add(PVData(fieldTypes[i + t->varFieldSize() - 1], false));
+        else
+            mpv->add(PVData(fieldTypes[i], false));
+        return mpv;
+    }
 
-            case PRIM_TupleElementCount:
-                return new MultiPValue(PVData(cSizeTType, true));
+    case PRIM_recordFieldRefByName: {
+        ensureArity(args, 2);
+        RecordTypePtr t = recordTypeOfValue(args, 0);
+        ObjectPtr obj = unwrapStaticType(args->values[1].type);
+        if (!obj || (obj->objKind != IDENTIFIER))
+            argumentError(1, "expecting field name identifier");
+        IdentifierPtr fname = (Identifier *)obj.ptr();
+        const llvm::StringMap<size_t> &fieldIndexMap = recordFieldIndexMap(t);
+        llvm::StringMap<size_t>::const_iterator fi =
+            fieldIndexMap.find(fname->str);
+        if (fi == fieldIndexMap.end()) {
+            string buf;
+            llvm::raw_string_ostream sout(buf);
+            sout << "field not found: " << fname->str;
+            argumentError(1, sout.str());
+        }
+        llvm::ArrayRef<TypePtr> fieldTypes = recordFieldTypes(t);
+        MultiPValuePtr mpv = new MultiPValue();
+        size_t i = fi->second;
+        if (t->hasVarField && i >= t->varFieldPosition)
+            if (i == t->varFieldPosition)
+                for (size_t j = 0; j < t->varFieldSize(); ++j)
+                    mpv->add(PVData(fieldTypes[i + j], false));
+            else
+                mpv->add(PVData(fieldTypes[i + t->varFieldSize() - 1], false));
+        else
+            mpv->add(PVData(fieldTypes[i], false));
+        return mpv;
+    }
 
-            case PRIM_tupleRef: {
-                ensureArity(args, 2);
-                TupleTypePtr t = tupleTypeOfValue(args, 0);
-                size_t i = staticToSizeTOrIntValue(args.ptr(), 1);
-                if (i >= t->elementTypes.size())
-                    argumentIndexRangeError(1, "tuple element index",
-                                            i, t->elementTypes.size());
-                return new MultiPValue(PVData(t->elementTypes[i], false));
-            }
+    case PRIM_recordFields: {
+        ensureArity(args, 1);
+        RecordTypePtr t = recordTypeOfValue(args, 0);
+        llvm::ArrayRef<TypePtr> fieldTypes = recordFieldTypes(t);
+        MultiPValuePtr mpv = new MultiPValue();
+        for (size_t i = 0; i < fieldTypes.size(); ++i)
+            mpv->add(PVData(fieldTypes[i], false));
+        return mpv;
+    }
 
-            case PRIM_tupleElements: {
-                ensureArity(args, 1);
-                TupleTypePtr t = tupleTypeOfValue(args, 0);
-                MultiPValuePtr mpv = new MultiPValue();
-                for (size_t i = 0; i < t->elementTypes.size(); ++i)
-                    mpv->add(PVData(t->elementTypes[i], false));
-                return mpv;
-            }
+    case PRIM_recordVariadicField: {
+        ensureArity(args, 1);
+        RecordTypePtr t = recordTypeOfValue(args, 0);
+        if (!t->hasVarField)
+            argumentError(0, "expecting a record with a variadic field");
+        llvm::ArrayRef<TypePtr> fieldTypes = recordFieldTypes(t);
+        MultiPValuePtr mpv = new MultiPValue();
+        size_t varEnd = t->varFieldPosition + t->varFieldSize();
+        for (size_t i = t->varFieldPosition; i < varEnd; ++i)
+            mpv->add(PVData(fieldTypes[i], false));
+        return mpv;
+    }
 
-            case PRIM_Union:
-                error("no Union type constructor overload found");
-
-            case PRIM_UnionMemberCount:
-                return new MultiPValue(PVData(cSizeTType, true));
-
-            case PRIM_RecordP:
-                return new MultiPValue(PVData(boolType, true));
-
-            case PRIM_RecordFieldCount:
-                return new MultiPValue(PVData(cSizeTType, true));
-
-            case PRIM_RecordFieldName: {
-                ensureArity(args, 2);
-                ObjectPtr first = unwrapStaticType(args->values[0].type);
-                if (!first)
-                    argumentError(0, "expecting a record type");
-                TypePtr t;
-                if (!staticToType(first, t))
-                    argumentError(0, "expecting a record type");
-                if (t->typeKind != RECORD_TYPE)
-                    argumentError(0, "expecting a record type");
-                RecordType *rt = (RecordType *) t.ptr();
-                size_t i = staticToSizeTOrIntValue(args.ptr(), 1);
-                const vector<IdentifierPtr> fieldNames = recordFieldNames(rt);
-                if (i >= fieldNames.size())
-                    argumentIndexRangeError(1, "record field index",
-                                            i, fieldNames.size());
-                return new MultiPValue(staticPValue(fieldNames[i].ptr()));
-            }
+    case PRIM_VariantP:
+        return new MultiPValue(PVData(boolType, true));
 
-            case PRIM_RecordWithFieldP:
-                return new MultiPValue(PVData(boolType, true));
-
-            case PRIM_recordFieldRef: {
-                ensureArity(args, 2);
-                RecordTypePtr t = recordTypeOfValue(args, 0);
-                size_t i = staticToSizeTOrIntValue(args.ptr(), 1);
-                llvm::ArrayRef<TypePtr> fieldTypes = recordFieldTypes(t);
-                if (i >= t->fieldCount())
-                    argumentIndexRangeError(1, "record field index",
-                                            i, t->fieldCount());
-
-                MultiPValuePtr mpv = new MultiPValue();
-                if (t->hasVarField && i >= t->varFieldPosition)
-                    if (i == t->varFieldPosition)
-                        for (size_t j = 0; j < t->varFieldSize(); ++j)
-                            mpv->add(PVData(fieldTypes[i + j], false));
-                    else
-                        mpv->add(PVData(fieldTypes[i + t->varFieldSize() - 1], false));
-                else
-                    mpv->add(PVData(fieldTypes[i], false));
-                return mpv;
-            }
+    case PRIM_VariantMemberIndex:
+        return new MultiPValue(PVData(cSizeTType, true));
 
-            case PRIM_recordFieldRefByName: {
-                ensureArity(args, 2);
-                RecordTypePtr t = recordTypeOfValue(args, 0);
-                ObjectPtr obj = unwrapStaticType(args->values[1].type);
-                if (!obj || (obj->objKind != IDENTIFIER))
-                    argumentError(1, "expecting field name identifier");
-                IdentifierPtr fname = (Identifier *) obj.ptr();
-                const llvm::StringMap<size_t> &fieldIndexMap = recordFieldIndexMap(t);
-                llvm::StringMap<size_t>::const_iterator fi =
-                        fieldIndexMap.find(fname->str);
-                if (fi == fieldIndexMap.end()) {
-                    string buf;
-                    llvm::raw_string_ostream sout(buf);
-                    sout << "field not found: " << fname->str;
-                    argumentError(1, sout.str());
-                }
-                llvm::ArrayRef<TypePtr> fieldTypes = recordFieldTypes(t);
-                MultiPValuePtr mpv = new MultiPValue();
-                size_t i = fi->second;
-                if (t->hasVarField && i >= t->varFieldPosition)
-                    if (i == t->varFieldPosition)
-                        for (size_t j = 0; j < t->varFieldSize(); ++j)
-                            mpv->add(PVData(fieldTypes[i + j], false));
-                    else
-                        mpv->add(PVData(fieldTypes[i + t->varFieldSize() - 1], false));
-                else
-                    mpv->add(PVData(fieldTypes[i], false));
-                return mpv;
-            }
+    case PRIM_VariantMemberCount:
+        return new MultiPValue(PVData(cSizeTType, true));
 
-            case PRIM_recordFields: {
-                ensureArity(args, 1);
-                RecordTypePtr t = recordTypeOfValue(args, 0);
-                llvm::ArrayRef<TypePtr> fieldTypes = recordFieldTypes(t);
-                MultiPValuePtr mpv = new MultiPValue();
-                for (size_t i = 0; i < fieldTypes.size(); ++i)
-                    mpv->add(PVData(fieldTypes[i], false));
-                return mpv;
-            }
+    case PRIM_VariantMembers: {
+        ensureArity(args, 1);
+        ObjectPtr typeObj = unwrapStaticType(args->values[0].type);
+        if (!typeObj)
+            argumentError(0, "expecting a variant type");
+        TypePtr t;
+        if (!staticToType(typeObj, t))
+            argumentError(0, "expecting a variant type");
+        if (t->typeKind != VARIANT_TYPE)
+            argumentError(0, "expecting a variant type");
+        VariantType *vt = (VariantType *)t.ptr();
+        llvm::ArrayRef<TypePtr> members = variantMemberTypes(vt);
+
+        MultiPValuePtr mpv = new MultiPValue();
+        for (TypePtr const *i = members.begin(), *end = members.end(); i != end;
+             ++i) {
+            mpv->add(staticPValue(i->ptr()));
+        }
+        return mpv;
+    }
 
-            case PRIM_recordVariadicField: {
-                ensureArity(args, 1);
-                RecordTypePtr t = recordTypeOfValue(args, 0);
-                if (!t->hasVarField)
-                    argumentError(0, "expecting a record with a variadic field");
-                llvm::ArrayRef<TypePtr> fieldTypes = recordFieldTypes(t);
-                MultiPValuePtr mpv = new MultiPValue();
-                size_t varEnd = t->varFieldPosition + t->varFieldSize();
-                for (size_t i = t->varFieldPosition; i < varEnd; ++i)
-                    mpv->add(PVData(fieldTypes[i], false));
-                return mpv;
-            }
+    case PRIM_BaseType: {
+        ensureArity(args, 1);
+        ObjectPtr obj = unwrapStaticType(args->values[0].type);
+        if (!obj && obj->objKind != TYPE)
+            argumentError(0, "static type expected");
+        Type *type = (Type *)obj.ptr();
+        MultiPValuePtr mpv = new MultiPValue();
+        if (type->typeKind == NEW_TYPE) {
+            NewType *nt = (NewType *)type;
+            mpv->add(staticPValue(newtypeReprType(nt).ptr()));
+        } else {
+            mpv->add(staticPValue(type));
+        }
+        return mpv;
+    }
 
-            case PRIM_VariantP:
-                return new MultiPValue(PVData(boolType, true));
-
-            case PRIM_VariantMemberIndex:
-                return new MultiPValue(PVData(cSizeTType, true));
-
-            case PRIM_VariantMemberCount:
-                return new MultiPValue(PVData(cSizeTType, true));
-
-            case PRIM_VariantMembers: {
-                ensureArity(args, 1);
-                ObjectPtr typeObj = unwrapStaticType(args->values[0].type);
-                if (!typeObj)
-                    argumentError(0, "expecting a variant type");
-                TypePtr t;
-                if (!staticToType(typeObj, t))
-                    argumentError(0, "expecting a variant type");
-                if (t->typeKind != VARIANT_TYPE)
-                    argumentError(0, "expecting a variant type");
-                VariantType *vt = (VariantType *) t.ptr();
-                llvm::ArrayRef<TypePtr> members = variantMemberTypes(vt);
-
-                MultiPValuePtr mpv = new MultiPValue();
-                for (TypePtr const *i = members.begin(), *end = members.end();
-                     i != end;
-                     ++i) {
-                    mpv->add(staticPValue(i->ptr()));
-                }
-                return mpv;
-            }
+    case PRIM_Static:
+        error("no Static type constructor overload found");
+
+    case PRIM_staticIntegers: {
+        ensureArity(args, 1);
+        ObjectPtr obj = unwrapStaticType(args->values[0].type);
+        if (!obj || (obj->objKind != VALUE_HOLDER))
+            argumentError(0, "expecting a static SizeT or Int value");
+        MultiPValuePtr mpv = new MultiPValue();
+        ValueHolder *vh = (ValueHolder *)obj.ptr();
+        if (vh->type == cIntType) {
+            int count = *((int *)vh->buf);
+            if (count < 0)
+                argumentError(0, "negative values are not allowed");
+            for (int i = 0; i < count; ++i) {
+                ValueHolderPtr vhi = intToValueHolder(i);
+                mpv->add(PVData(staticType(vhi.ptr()), true));
+            }
+        } else if (vh->type == cSizeTType) {
+            size_t count = *((size_t *)vh->buf);
+            for (size_t i = 0; i < count; ++i) {
+                ValueHolderPtr vhi = sizeTToValueHolder(i);
+                mpv->add(PVData(staticType(vhi.ptr()), true));
+            }
+        } else {
+            argumentError(0, "expecting a static SizeT or Int value");
+        }
+        return mpv;
+    }
 
-            case PRIM_BaseType: {
-                ensureArity(args, 1);
-                ObjectPtr obj = unwrapStaticType(args->values[0].type);
-                if (!obj && obj->objKind != TYPE)
-                    argumentError(0, "static type expected");
-                Type *type = (Type *) obj.ptr();
-                MultiPValuePtr mpv = new MultiPValue();
-                if (type->typeKind == NEW_TYPE) {
-                    NewType *nt = (NewType *) type;
-                    mpv->add(staticPValue(newtypeReprType(nt).ptr()));
-                } else {
-                    mpv->add(staticPValue(type));
-                }
-                return mpv;
-            }
+    case PRIM_integers: {
+        ensureArity(args, 1);
+        ObjectPtr obj = unwrapStaticType(args->values[0].type);
+        if (!obj || (obj->objKind != VALUE_HOLDER))
+            argumentError(0, "expecting a static SizeT or Int value");
+        MultiPValuePtr mpv = new MultiPValue();
+        ValueHolder *vh = (ValueHolder *)obj.ptr();
+        if (vh->type == cIntType) {
+            int count = *((int *)vh->buf);
+            if (count < 0)
+                argumentError(0, "negative values are not allowed");
+            for (int i = 0; i < count; ++i)
+                mpv->add(PVData(cIntType, true));
+        } else if (vh->type == cSizeTType) {
+            size_t count = *((size_t *)vh->buf);
+            for (size_t i = 0; i < count; ++i)
+                mpv->add(PVData(cSizeTType, true));
+        } else {
+            argumentError(0, "expecting a static SizeT or Int value");
+        }
+        return mpv;
+    }
 
-            case PRIM_Static:
-                error("no Static type constructor overload found");
-
-            case PRIM_staticIntegers: {
-                ensureArity(args, 1);
-                ObjectPtr obj = unwrapStaticType(args->values[0].type);
-                if (!obj || (obj->objKind != VALUE_HOLDER))
-                    argumentError(0, "expecting a static SizeT or Int value");
-                MultiPValuePtr mpv = new MultiPValue();
-                ValueHolder *vh = (ValueHolder *) obj.ptr();
-                if (vh->type == cIntType) {
-                    int count = *((int *) vh->buf);
-                    if (count < 0)
-                        argumentError(0, "negative values are not allowed");
-                    for (int i = 0; i < count; ++i) {
-                        ValueHolderPtr vhi = intToValueHolder(i);
-                        mpv->add(PVData(staticType(vhi.ptr()), true));
-                    }
-                } else if (vh->type == cSizeTType) {
-                    size_t count = *((size_t *) vh->buf);
-                    for (size_t i = 0; i < count; ++i) {
-                        ValueHolderPtr vhi = sizeTToValueHolder(i);
-                        mpv->add(PVData(staticType(vhi.ptr()), true));
-                    }
-                } else {
-                    argumentError(0, "expecting a static SizeT or Int value");
-                }
-                return mpv;
-            }
+    case PRIM_staticFieldRef: {
+        ensureArity(args, 2);
+        ObjectPtr moduleObj = unwrapStaticType(args->values[0].type);
+        if (!moduleObj || (moduleObj->objKind != MODULE))
+            argumentError(0, "expecting a module");
+        ObjectPtr identObj = unwrapStaticType(args->values[1].type);
+        if (!identObj || (identObj->objKind != IDENTIFIER))
+            argumentError(1, "expecting a string literal value");
+        Module *module = (Module *)moduleObj.ptr();
+        Identifier *ident = (Identifier *)identObj.ptr();
+        ObjectPtr obj = safeLookupPublic(module, ident);
+        return analyzeStaticObject(obj);
+    }
 
-            case PRIM_integers: {
-                ensureArity(args, 1);
-                ObjectPtr obj = unwrapStaticType(args->values[0].type);
-                if (!obj || (obj->objKind != VALUE_HOLDER))
-                    argumentError(0, "expecting a static SizeT or Int value");
-                MultiPValuePtr mpv = new MultiPValue();
-                ValueHolder *vh = (ValueHolder *) obj.ptr();
-                if (vh->type == cIntType) {
-                    int count = *((int *) vh->buf);
-                    if (count < 0)
-                        argumentError(0, "negative values are not allowed");
-                    for (int i = 0; i < count; ++i)
-                        mpv->add(PVData(cIntType, true));
-                } else if (vh->type == cSizeTType) {
-                    size_t count = *((size_t *) vh->buf);
-                    for (size_t i = 0; i < count; ++i)
-                        mpv->add(PVData(cSizeTType, true));
-                } else {
-                    argumentError(0, "expecting a static SizeT or Int value");
-                }
-                return mpv;
-            }
+    case PRIM_EnumP:
+        return new MultiPValue(PVData(boolType, true));
 
-            case PRIM_staticFieldRef: {
-                ensureArity(args, 2);
-                ObjectPtr moduleObj = unwrapStaticType(args->values[0].type);
-                if (!moduleObj || (moduleObj->objKind != MODULE))
-                    argumentError(0, "expecting a module");
-                ObjectPtr identObj = unwrapStaticType(args->values[1].type);
-                if (!identObj || (identObj->objKind != IDENTIFIER))
-                    argumentError(1, "expecting a string literal value");
-                Module *module = (Module *) moduleObj.ptr();
-                Identifier *ident = (Identifier *) identObj.ptr();
-                ObjectPtr obj = safeLookupPublic(module, ident);
-                return analyzeStaticObject(obj);
-            }
+    case PRIM_EnumMemberCount:
+        return new MultiPValue(PVData(cSizeTType, true));
 
-            case PRIM_EnumP:
-                return new MultiPValue(PVData(boolType, true));
+    case PRIM_EnumMemberName: {
+        ensureArity(args, 2);
+        EnumTypePtr et = valueToEnumType(args, 0);
+        size_t i = staticToSizeTOrIntValue(args.ptr(), 1);
 
-            case PRIM_EnumMemberCount:
-                return new MultiPValue(PVData(cSizeTType, true));
+        EnumDeclPtr e = et->enumeration;
+        if (i >= e->members.size())
+            argumentIndexRangeError(1, "enum member index", i,
+                                    e->members.size());
 
-            case PRIM_EnumMemberName: {
-                ensureArity(args, 2);
-                EnumTypePtr et = valueToEnumType(args, 0);
-                size_t i = staticToSizeTOrIntValue(args.ptr(), 1);
+        return analyzeStaticObject(e->members[i]->name.ptr());
+    }
 
-                EnumDeclPtr e = et->enumeration;
-                if (i >= e->members.size())
-                    argumentIndexRangeError(1, "enum member index",
-                                            i, e->members.size());
+    case PRIM_enumToInt:
+        return new MultiPValue(PVData(cIntType, true));
 
-                return analyzeStaticObject(e->members[i]->name.ptr());
-            }
+    case PRIM_intToEnum: {
+        ensureArity(args, 2);
+        EnumTypePtr t = valueToEnumType(args, 0);
+        initializeEnumType(t);
+        return new MultiPValue(PVData(t.ptr(), true));
+    }
 
-            case PRIM_enumToInt:
-                return new MultiPValue(PVData(cIntType, true));
+    case PRIM_StringLiteralP:
+        return new MultiPValue(PVData(boolType, true));
+
+    case PRIM_stringLiteralByteIndex:
+        return new MultiPValue(PVData(cIntType, true));
+
+    case PRIM_stringLiteralBytes: {
+        ensureArity(args, 1);
+        ObjectPtr obj = unwrapStaticType(args->values[0].type);
+        if (!obj || (obj->objKind != IDENTIFIER))
+            argumentError(0, "expecting a string literal value");
+        Identifier *ident = (Identifier *)obj.ptr();
+        MultiPValuePtr result = new MultiPValue();
+        for (size_t i = 0, sz = ident->str.size(); i < sz; ++i)
+            result->add(PVData(cIntType, true));
+        return result;
+    }
 
-            case PRIM_intToEnum: {
-                ensureArity(args, 2);
-                EnumTypePtr t = valueToEnumType(args, 0);
-                initializeEnumType(t);
-                return new MultiPValue(PVData(t.ptr(), true));
-            }
+    case PRIM_stringLiteralByteSize:
+        return new MultiPValue(PVData(cSizeTType, true));
+
+    case PRIM_stringLiteralByteSlice: {
+        ensureArity(args, 3);
+        ObjectPtr identObj = unwrapStaticType(args->values[0].type);
+        if (!identObj || (identObj->objKind != IDENTIFIER))
+            argumentError(0, "expecting a string literal value");
+        Identifier *ident = (Identifier *)identObj.ptr();
+        ObjectPtr beginObj = unwrapStaticType(args->values[1].type);
+        ObjectPtr endObj = unwrapStaticType(args->values[2].type);
+        size_t begin = staticToSizeTOrIntValue(args.ptr(), 1);
+        size_t end = staticToSizeTOrIntValue(args.ptr(), 2);
+        if (end > ident->str.size()) {
+            argumentIndexRangeError(2, "ending index", end, ident->str.size());
+        }
+        if (begin > end)
+            argumentIndexRangeError(1, "starting index", begin, end);
+        llvm::StringRef result(&ident->str[unsigned(begin)], end - begin);
+        return analyzeStaticObject(Identifier::get(result));
+    }
 
-            case PRIM_StringLiteralP:
-                return new MultiPValue(PVData(boolType, true));
-
-            case PRIM_stringLiteralByteIndex:
-                return new MultiPValue(PVData(cIntType, true));
-
-            case PRIM_stringLiteralBytes: {
-                ensureArity(args, 1);
-                ObjectPtr obj = unwrapStaticType(args->values[0].type);
-                if (!obj || (obj->objKind != IDENTIFIER))
-                    argumentError(0, "expecting a string literal value");
-                Identifier *ident = (Identifier *) obj.ptr();
-                MultiPValuePtr result = new MultiPValue();
-                for (size_t i = 0, sz = ident->str.size(); i < sz; ++i)
-                    result->add(PVData(cIntType, true));
-                return result;
-            }
+    case PRIM_stringLiteralConcat: {
+        llvm::SmallString<32> result;
+        for (size_t i = 0, sz = args->size(); i < sz; ++i) {
+            ObjectPtr obj = unwrapStaticType(args->values[unsigned(i)].type);
+            if (!obj || (obj->objKind != IDENTIFIER))
+                argumentError(i, "expecting a string literal value");
+            Identifier *ident = (Identifier *)obj.ptr();
+            result.append(ident->str.begin(), ident->str.end());
+        }
+        return analyzeStaticObject(Identifier::get(result));
+    }
 
-            case PRIM_stringLiteralByteSize:
-                return new MultiPValue(PVData(cSizeTType, true));
-
-            case PRIM_stringLiteralByteSlice: {
-                ensureArity(args, 3);
-                ObjectPtr identObj = unwrapStaticType(args->values[0].type);
-                if (!identObj || (identObj->objKind != IDENTIFIER))
-                    argumentError(0, "expecting a string literal value");
-                Identifier *ident = (Identifier *) identObj.ptr();
-                ObjectPtr beginObj = unwrapStaticType(args->values[1].type);
-                ObjectPtr endObj = unwrapStaticType(args->values[2].type);
-                size_t begin = staticToSizeTOrIntValue(args.ptr(), 1);
-                size_t end = staticToSizeTOrIntValue(args.ptr(), 2);
-                if (end > ident->str.size()) {
-                    argumentIndexRangeError(2, "ending index",
-                                            end, ident->str.size());
-                }
-                if (begin > end)
-                    argumentIndexRangeError(1, "starting index",
-                                            begin, end);
-                llvm::StringRef result(&ident->str[unsigned(begin)], end - begin);
-                return analyzeStaticObject(Identifier::get(result));
-            }
+    case PRIM_stringLiteralFromBytes: {
+        std::string result;
+        for (size_t i = 0, sz = args->size(); i < sz; ++i) {
+            size_t byte = staticToSizeTOrIntValue(args.ptr(), i);
+            if (byte > 255) {
+                string buf;
+                llvm::raw_string_ostream os(buf);
+                os << byte << " is too large for a string literal byte";
+                argumentError(i, os.str());
+            }
+            result.push_back((char)byte);
+        }
+        return analyzeStaticObject(Identifier::get(result));
+    }
 
-            case PRIM_stringLiteralConcat: {
-                llvm::SmallString<32> result;
-                for (size_t i = 0, sz = args->size(); i < sz; ++i) {
-                    ObjectPtr obj = unwrapStaticType(args->values[unsigned(i)].type);
-                    if (!obj || (obj->objKind != IDENTIFIER))
-                        argumentError(i, "expecting a string literal value");
-                    Identifier *ident = (Identifier *) obj.ptr();
-                    result.append(ident->str.begin(), ident->str.end());
-                }
-                return analyzeStaticObject(Identifier::get(result));
-            }
+    case PRIM_stringTableConstant:
+        return new MultiPValue(PVData(pointerType(cSizeTType), true));
 
-            case PRIM_stringLiteralFromBytes: {
-                std::string result;
-                for (size_t i = 0, sz = args->size(); i < sz; ++i) {
-                    size_t byte = staticToSizeTOrIntValue(args.ptr(), i);
-                    if (byte > 255) {
-                        string buf;
-                        llvm::raw_string_ostream os(buf);
-                        os << byte << " is too large for a string literal byte";
-                        argumentError(i, os.str());
-                    }
-                    result.push_back((char) byte);
-                }
-                return analyzeStaticObject(Identifier::get(result));
-            }
+    case PRIM_StaticName: {
+        ensureArity(args, 1);
+        ObjectPtr obj = unwrapStaticType(args->values[0].type);
+        if (!obj)
+            argumentError(0, "expecting static object");
+        llvm::SmallString<128> buf;
+        llvm::raw_svector_ostream sout(buf);
+        printStaticName(sout, obj);
+        return analyzeStaticObject(Identifier::get(sout.str()));
+    }
 
-            case PRIM_stringTableConstant:
-                return new MultiPValue(PVData(pointerType(cSizeTType), true));
-
-            case PRIM_StaticName: {
-                ensureArity(args, 1);
-                ObjectPtr obj = unwrapStaticType(args->values[0].type);
-                if (!obj)
-                    argumentError(0, "expecting static object");
-                llvm::SmallString<128> buf;
-                llvm::raw_svector_ostream sout(buf);
-                printStaticName(sout, obj);
-                return analyzeStaticObject(Identifier::get(sout.str()));
-            }
+    case PRIM_MainModule: {
+        ensureArity(args, 0);
+        assert(globalMainModule != nullptr);
+        return analyzeStaticObject(globalMainModule.ptr());
+    }
 
-            case PRIM_MainModule: {
-                ensureArity(args, 0);
-                assert(globalMainModule != nullptr);
-                return analyzeStaticObject(globalMainModule.ptr());
-            }
+    case PRIM_StaticModule: {
+        ensureArity(args, 1);
+        ObjectPtr obj = unwrapStaticType(args->values[0].type);
+        if (!obj)
+            argumentError(0, "expecting static object");
+        ModulePtr m = staticModule(obj);
+        if (!m)
+            argumentError(0, "value has no associated module");
+        return analyzeStaticObject(m.ptr());
+    }
 
-            case PRIM_StaticModule: {
-                ensureArity(args, 1);
-                ObjectPtr obj = unwrapStaticType(args->values[0].type);
-                if (!obj)
-                    argumentError(0, "expecting static object");
-                ModulePtr m = staticModule(obj);
-                if (!m)
-                    argumentError(0, "value has no associated module");
-                return analyzeStaticObject(m.ptr());
-            }
+    case PRIM_ModuleName: {
+        ensureArity(args, 1);
+        ObjectPtr obj = unwrapStaticType(args->values[0].type);
+        if (!obj)
+            argumentError(0, "expecting static object");
+        ModulePtr m = staticModule(obj);
+        if (!m)
+            argumentError(0, "value has no associated module");
+        return analyzeStaticObject(Identifier::get(m->moduleName));
+    }
 
-            case PRIM_ModuleName: {
-                ensureArity(args, 1);
-                ObjectPtr obj = unwrapStaticType(args->values[0].type);
-                if (!obj)
-                    argumentError(0, "expecting static object");
-                ModulePtr m = staticModule(obj);
-                if (!m)
-                    argumentError(0, "value has no associated module");
-                return analyzeStaticObject(Identifier::get(m->moduleName));
-            }
+    case PRIM_ModuleMemberNames: {
+        ensureArity(args, 1);
+        ObjectPtr moduleObj = unwrapStaticType(args->values[0].type);
+        if (!moduleObj || (moduleObj->objKind != MODULE))
+            argumentError(0, "expecting a module");
+        ModulePtr m = staticModule(moduleObj);
+        assert(m != nullptr);
+
+        MultiPValuePtr result = new MultiPValue();
+
+        for (llvm::StringMap<ObjectPtr>::const_iterator
+                 i = m->publicGlobals.begin(),
+                 end = m->publicGlobals.end();
+             i != end; ++i) {
+            result->add(staticPValue(Identifier::get(i->getKey())));
+        }
+        return result;
+    }
 
-            case PRIM_ModuleMemberNames: {
-                ensureArity(args, 1);
-                ObjectPtr moduleObj = unwrapStaticType(args->values[0].type);
-                if (!moduleObj || (moduleObj->objKind != MODULE))
-                    argumentError(0, "expecting a module");
-                ModulePtr m = staticModule(moduleObj);
-                assert(m != nullptr);
-
-                MultiPValuePtr result = new MultiPValue();
-
-                for (llvm::StringMap<ObjectPtr>::const_iterator i = m->publicGlobals.begin(),
-                             end = m->publicGlobals.end();
-                     i != end;
-                     ++i) {
-                    result->add(staticPValue(Identifier::get(i->getKey())));
-                }
-                return result;
-            }
+    case PRIM_FlagP: {
+        return new MultiPValue(PVData(boolType, true));
+    }
 
-            case PRIM_FlagP: {
-                return new MultiPValue(PVData(boolType, true));
-            }
+    case PRIM_Flag: {
+        ensureArity(args, 1);
+        ObjectPtr obj = unwrapStaticType(args->values[0].type);
+        if (obj != nullptr && obj->objKind == IDENTIFIER) {
+            Identifier *ident = (Identifier *)obj.ptr();
+
+            llvm::StringMap<string>::const_iterator flag =
+                globalFlags.find(ident->str);
+            string value;
+            if (flag != globalFlags.end())
+                value = flag->second;
+
+            return analyzeStaticObject(Identifier::get(value));
+        } else
+            argumentTypeError(0, "identifier", args->values[0].type);
+        return nullptr;
+    }
 
-            case PRIM_Flag: {
-                ensureArity(args, 1);
-                ObjectPtr obj = unwrapStaticType(args->values[0].type);
-                if (obj != nullptr && obj->objKind == IDENTIFIER) {
-                    Identifier *ident = (Identifier *) obj.ptr();
-
-                    llvm::StringMap<string>::const_iterator flag = globalFlags.find(ident->str);
-                    string value;
-                    if (flag != globalFlags.end())
-                        value = flag->second;
-
-                    return analyzeStaticObject(Identifier::get(value));
-                } else
-                    argumentTypeError(0, "identifier", args->values[0].type);
-                return nullptr;
-            }
+    case PRIM_atomicFence: {
+        ensureArity(args, 1);
+        return new MultiPValue();
+    }
 
-            case PRIM_atomicFence: {
-                ensureArity(args, 1);
-                return new MultiPValue();
-            }
+    case PRIM_atomicRMW: {
+        // order op ptr val
+        ensureArity(args, 4);
+        pointerTypeOfValue(args, 2);
+        return new MultiPValue(PVData(args->values[3].type, true));
+    }
 
-            case PRIM_atomicRMW: {
-                // order op ptr val
-                ensureArity(args, 4);
-                pointerTypeOfValue(args, 2);
-                return new MultiPValue(PVData(args->values[3].type, true));
-            }
+    case PRIM_atomicLoad: {
+        // order ptr
+        ensureArity(args, 2);
+        PointerTypePtr pt = pointerTypeOfValue(args, 1);
+        return new MultiPValue(PVData(pt->pointeeType, true));
+    }
 
-            case PRIM_atomicLoad: {
-                // order ptr
-                ensureArity(args, 2);
-                PointerTypePtr pt = pointerTypeOfValue(args, 1);
-                return new MultiPValue(PVData(pt->pointeeType, true));
-            }
+    case PRIM_atomicStore: {
+        // order ptr val
+        ensureArity(args, 3);
+        pointerTypeOfValue(args, 1);
+        return new MultiPValue();
+    }
 
-            case PRIM_atomicStore: {
-                // order ptr val
-                ensureArity(args, 3);
-                pointerTypeOfValue(args, 1);
-                return new MultiPValue();
-            }
+    case PRIM_atomicCompareExchange: {
+        // order ptr old new
+        ensureArity(args, 4);
+        PointerTypePtr pt = pointerTypeOfValue(args, 1);
 
-            case PRIM_atomicCompareExchange: {
-                // order ptr old new
-                ensureArity(args, 4);
-                PointerTypePtr pt = pointerTypeOfValue(args, 1);
+        return new MultiPValue(PVData(args->values[2].type, true));
+    }
 
-                return new MultiPValue(PVData(args->values[2].type, true));
-            }
+    case PRIM_activeException: {
+        ensureArity(args, 0);
+        return new MultiPValue(PVData(pointerType(uint8Type), true));
+    }
 
-            case PRIM_activeException: {
-                ensureArity(args, 0);
-                return new MultiPValue(PVData(pointerType(uint8Type), true));
-            }
+    case PRIM_memcpy:
+    case PRIM_memmove: {
+        ensureArity(args, 3);
+        PointerTypePtr toPt = pointerTypeOfValue(args, 0);
+        PointerTypePtr fromPt = pointerTypeOfValue(args, 1);
+        integerTypeOfValue(args, 2);
+        return new MultiPValue();
+    }
 
-            case PRIM_memcpy:
-            case PRIM_memmove: {
-                ensureArity(args, 3);
-                PointerTypePtr toPt = pointerTypeOfValue(args, 0);
-                PointerTypePtr fromPt = pointerTypeOfValue(args, 1);
-                integerTypeOfValue(args, 2);
-                return new MultiPValue();
-            }
+    case PRIM_countValues: {
+        return new MultiPValue(PVData(cIntType, true));
+    }
 
-            case PRIM_countValues: {
-                return new MultiPValue(PVData(cIntType, true));
-            }
+    case PRIM_nthValue: {
+        if (args->size() < 1)
+            arityError2(1, args->size());
+        ObjectPtr obj = unwrapStaticType(args->values[0].type);
+        size_t i = staticToSizeTOrIntValue(args.ptr(), 0);
+        if (i + 1 >= args->size())
+            argumentError(0, "nthValue argument out of bounds");
+        return new MultiPValue(args->values[unsigned(i) + 1]);
+    }
 
-            case PRIM_nthValue: {
-                if (args->size() < 1)
-                    arityError2(1, args->size());
-                ObjectPtr obj = unwrapStaticType(args->values[0].type);
-                size_t i = staticToSizeTOrIntValue(args.ptr(), 0);
-                if (i + 1 >= args->size())
-                    argumentError(0, "nthValue argument out of bounds");
-                return new MultiPValue(args->values[unsigned(i) + 1]);
-            }
+    case PRIM_withoutNthValue: {
+        if (args->size() < 1)
+            arityError2(1, args->size());
+        size_t i = staticToSizeTOrIntValue(args.ptr(), 0);
+        if (i + 1 >= args->size())
+            argumentError(0, "withoutNthValue argument out of bounds");
+        MultiPValuePtr mpv = new MultiPValue();
+        for (unsigned n = 1; n < args->size(); ++n) {
+            if (n == i + 1)
+                continue;
+            mpv->add(args->values[n]);
+        }
+        return mpv;
+    }
 
-            case PRIM_withoutNthValue: {
-                if (args->size() < 1)
-                    arityError2(1, args->size());
-                size_t i = staticToSizeTOrIntValue(args.ptr(), 0);
-                if (i + 1 >= args->size())
-                    argumentError(0, "withoutNthValue argument out of bounds");
-                MultiPValuePtr mpv = new MultiPValue();
-                for (unsigned n = 1; n < args->size(); ++n) {
-                    if (n == i + 1)
-                        continue;
-                    mpv->add(args->values[n]);
-                }
-                return mpv;
-            }
+    case PRIM_takeValues: {
+        if (args->size() < 1)
+            arityError2(1, args->size());
+        size_t i = staticToSizeTOrIntValue(args.ptr(), 0);
+        if (i + 1 >= args->size())
+            i = args->size() - 1;
+        MultiPValuePtr mpv = new MultiPValue();
+        for (unsigned n = 1; n < i + 1; ++n)
+            mpv->add(args->values[n]);
+        return mpv;
+    }
 
-            case PRIM_takeValues: {
-                if (args->size() < 1)
-                    arityError2(1, args->size());
-                size_t i = staticToSizeTOrIntValue(args.ptr(), 0);
-                if (i + 1 >= args->size())
-                    i = args->size() - 1;
-                MultiPValuePtr mpv = new MultiPValue();
-                for (unsigned n = 1; n < i + 1; ++n)
-                    mpv->add(args->values[n]);
-                return mpv;
-            }
+    case PRIM_dropValues: {
+        if (args->size() < 1)
+            arityError2(1, args->size());
+        size_t i = staticToSizeTOrIntValue(args.ptr(), 0);
+        if (i + 1 >= args->size())
+            i = args->size() - 1;
+        MultiPValuePtr mpv = new MultiPValue();
+        for (size_t n = i + 1; n < args->size(); ++n)
+            mpv->add(args->values[unsigned(n)]);
+        return mpv;
+    }
 
-            case PRIM_dropValues: {
-                if (args->size() < 1)
-                    arityError2(1, args->size());
-                size_t i = staticToSizeTOrIntValue(args.ptr(), 0);
-                if (i + 1 >= args->size())
-                    i = args->size() - 1;
-                MultiPValuePtr mpv = new MultiPValue();
-                for (size_t n = i + 1; n < args->size(); ++n)
-                    mpv->add(args->values[unsigned(n)]);
-                return mpv;
-            }
+    case PRIM_LambdaRecordP: {
+        ensureArity(args, 1);
+        return new MultiPValue(PVData(boolType, true));
+    }
 
-            case PRIM_LambdaRecordP: {
-                ensureArity(args, 1);
-                return new MultiPValue(PVData(boolType, true));
-            }
+    case PRIM_LambdaSymbolP: {
+        ensureArity(args, 1);
+        return new MultiPValue(PVData(boolType, true));
+    }
 
-            case PRIM_LambdaSymbolP: {
-                ensureArity(args, 1);
-                return new MultiPValue(PVData(boolType, true));
-            }
+    case PRIM_LambdaMonoP: {
+        ensureArity(args, 1);
+        return new MultiPValue(PVData(boolType, true));
+    }
 
-            case PRIM_LambdaMonoP: {
-                ensureArity(args, 1);
-                return new MultiPValue(PVData(boolType, true));
-            }
+    case PRIM_LambdaMonoInputTypes: {
+        ensureArity(args, 1);
+        ObjectPtr callable = unwrapStaticType(args->values[0].type);
+        if (!callable)
+            argumentError(0, "lambda record type expected");
+
+        if (callable != nullptr && callable->objKind == TYPE) {
+            Type *t = (Type *)callable.ptr();
+            if (t->typeKind == RECORD_TYPE) {
+                RecordType *r = (RecordType *)t;
+                if (r->record->lambda->mono.monoState != Procedure_MonoOverload)
+                    argumentError(0, "not a monomorphic lambda record type");
+                llvm::ArrayRef<TypePtr> monoTypes =
+                    r->record->lambda->mono.monoTypes;
+                MultiPValuePtr values = new MultiPValue();
+                for (size_t i = 0; i < monoTypes.size(); ++i)
+                    values->add(staticPValue(monoTypes[i].ptr()));
 
-            case PRIM_LambdaMonoInputTypes: {
-                ensureArity(args, 1);
-                ObjectPtr callable = unwrapStaticType(args->values[0].type);
-                if (!callable)
-                    argumentError(0, "lambda record type expected");
-
-                if (callable != nullptr && callable->objKind == TYPE) {
-                    Type *t = (Type *) callable.ptr();
-                    if (t->typeKind == RECORD_TYPE) {
-                        RecordType *r = (RecordType *) t;
-                        if (r->record->lambda->mono.monoState != Procedure_MonoOverload)
-                            argumentError(0, "not a monomorphic lambda record type");
-                        llvm::ArrayRef<TypePtr> monoTypes = r->record->lambda->mono.monoTypes;
-                        MultiPValuePtr values = new MultiPValue();
-                        for (size_t i = 0; i < monoTypes.size(); ++i)
-                            values->add(staticPValue(monoTypes[i].ptr()));
-
-                        return values;
-                    }
-                }
-
-                argumentError(0, "not a monomorphic lambda record type");
-                return new MultiPValue();
+                return values;
             }
+        }
 
-            case PRIM_GetOverload: {
-                std::pair<vector<TypePtr>, InvokeEntry *> entry =
-                        invokeEntryForCallableArguments(args, 0, 1);
-
-                llvm::SmallString<128> buf;
-                llvm::raw_svector_ostream nameout(buf);
-                nameout << "GetOverload(";
-                printStaticName(nameout, entry.second->callable);
-                nameout << ", ";
-                nameout << ")";
-
-                ProcedurePtr proc = new Procedure(
-                    nullptr, Identifier::get(nameout.str()),
-                    PRIVATE, false);
-
-                proc->env = entry.second->env;
-
-                CodePtr code = new Code(), origCode = entry.second->origCode;
-                for (vector<FormalArgPtr>::const_iterator arg = origCode->formalArgs.begin(),
-                             end = origCode->formalArgs.end();
-                     arg != end;
-                     ++arg) {
-                    code->formalArgs.push_back(new FormalArg((*arg)->name, nullptr));
-                }
-
-                code->hasVarArg = origCode->hasVarArg;
-
-                if (origCode->hasNamedReturns()) {
-                    code->returnSpecsDeclared = true;
-                    code->returnSpecs = origCode->returnSpecs;
-                    code->varReturnSpec = origCode->varReturnSpec;
-                }
-
-                code->body = origCode->body;
-                code->llvmBody = origCode->llvmBody;
-
-                OverloadPtr overload = new Overload(
-                    nullptr,
-                    new ObjectExpr(proc.ptr()),
-                    code,
-                    entry.second->callByName,
-                    entry.second->isInline);
-                overload->env = entry.second->env;
-                addProcedureOverload(proc, entry.second->env, overload);
-
-                return new MultiPValue(staticPValue(proc.ptr()));
-            }
+        argumentError(0, "not a monomorphic lambda record type");
+        return new MultiPValue();
+    }
 
-            case PRIM_usuallyEquals: {
-                ensureArity(args, 2);
-                if (!isPrimitiveType(args->values[0].type))
-                    argumentTypeError(0, "primitive type", args->values[0].type);
-                ObjectPtr expectedValue = unwrapStaticType(args->values[1].type);
-                if (expectedValue == nullptr
-                    || expectedValue->objKind != VALUE_HOLDER
-                    || ((ValueHolder *) expectedValue.ptr())->type != args->values[0].type)
-                    error(
-                        "second argument to usuallyEquals must be a static value of the same type as the first argument");
-                return new MultiPValue(PVData(args->values[0].type, true));
-            }
+    case PRIM_GetOverload: {
+        std::pair<vector<TypePtr>, InvokeEntry *> entry =
+            invokeEntryForCallableArguments(args, 0, 1);
 
-            default:
-                assert(false);
-                return nullptr;
+        llvm::SmallString<128> buf;
+        llvm::raw_svector_ostream nameout(buf);
+        nameout << "GetOverload(";
+        printStaticName(nameout, entry.second->callable);
+        nameout << ", ";
+        nameout << ")";
+
+        ProcedurePtr proc = new Procedure(
+            nullptr, Identifier::get(nameout.str()), PRIVATE, false);
+
+        proc->env = entry.second->env;
+
+        CodePtr code = new Code(), origCode = entry.second->origCode;
+        for (vector<FormalArgPtr>::const_iterator
+                 arg = origCode->formalArgs.begin(),
+                 end = origCode->formalArgs.end();
+             arg != end; ++arg) {
+            code->formalArgs.push_back(new FormalArg((*arg)->name, nullptr));
         }
+
+        code->hasVarArg = origCode->hasVarArg;
+
+        if (origCode->hasNamedReturns()) {
+            code->returnSpecsDeclared = true;
+            code->returnSpecs = origCode->returnSpecs;
+            code->varReturnSpec = origCode->varReturnSpec;
+        }
+
+        code->body = origCode->body;
+        code->llvmBody = origCode->llvmBody;
+
+        OverloadPtr overload =
+            new Overload(nullptr, new ObjectExpr(proc.ptr()), code,
+                         entry.second->callByName, entry.second->isInline);
+        overload->env = entry.second->env;
+        addProcedureOverload(proc, entry.second->env, overload);
+
+        return new MultiPValue(staticPValue(proc.ptr()));
+    }
+
+    case PRIM_usuallyEquals: {
+        ensureArity(args, 2);
+        if (!isPrimitiveType(args->values[0].type))
+            argumentTypeError(0, "primitive type", args->values[0].type);
+        ObjectPtr expectedValue = unwrapStaticType(args->values[1].type);
+        if (expectedValue == nullptr ||
+            expectedValue->objKind != VALUE_HOLDER ||
+            ((ValueHolder *)expectedValue.ptr())->type != args->values[0].type)
+            error("second argument to usuallyEquals must be a static value of "
+                  "the same type as the first argument");
+        return new MultiPValue(PVData(args->values[0].type, true));
+    }
+
+    default:
+        assert(false);
+        return nullptr;
     }
 }
+} // namespace clay
diff --git a/compiler/analyzer_op.hpp b/compiler/analyzer_op.hpp
index af8a2c32..60bdf3e4 100644
--- a/compiler/analyzer_op.hpp
+++ b/compiler/analyzer_op.hpp
@@ -3,5 +3,5 @@
 #include "clay.hpp"
 
 namespace clay {
-    MultiPValuePtr analyzePrimOp(PrimOpPtr x, MultiPValuePtr args);
+MultiPValuePtr analyzePrimOp(PrimOpPtr x, MultiPValuePtr args);
 }
diff --git a/compiler/checkedcast.hpp b/compiler/checkedcast.hpp
index a38b06b5..be7e9917 100644
--- a/compiler/checkedcast.hpp
+++ b/compiler/checkedcast.hpp
@@ -3,10 +3,9 @@
 #include "assert.h"
 
 namespace clay {
-    template<class To, class From>
-    To checked_cast(From *from) {
-        // TODO: for unknown reason this code cause SEGV in runtime
-        //assert(!from || dynamic_cast<To>(from));
-        return static_cast<To>(from);
-    }
+template <class To, class From> To checked_cast(From *from) {
+    // TODO: for unknown reason this code cause SEGV in runtime
+    // assert(!from || dynamic_cast<To>(from));
+    return static_cast<To>(from);
 }
+} // namespace clay
diff --git a/compiler/clay.cpp b/compiler/clay.cpp
index 2b1b76db..94fb8a26 100644
--- a/compiler/clay.cpp
+++ b/compiler/clay.cpp
@@ -1,15 +1,15 @@
-#include <system_error>
-#include <vector>
-#include <string>
 #include <memory>
+#include <string>
+#include <system_error>
 #include <utility>
+#include <vector>
 
 #include "clay.hpp"
-#include "hirestimer.hpp"
-#include "error.hpp"
 #include "codegen.hpp"
-#include "loader.hpp"
+#include "error.hpp"
+#include "hirestimer.hpp"
 #include "invoketables.hpp"
+#include "loader.hpp"
 #include "parachute.hpp"
 
 using std::string;
@@ -17,9 +17,9 @@ using std::vector;
 
 // for _exit
 #ifdef _WIN32
-# include <process.h>
+#include <process.h>
 #else
-# include <unistd.h>
+#include <unistd.h>
 #endif
 
 namespace clay {
@@ -35,1020 +35,1090 @@ namespace clay {
 #define ENV_SEPARATOR ':'
 #endif
 
-    static bool runModule(llvm::Module *module,
+static bool runModule(llvm::Module *module,
                       const std::vector<std::string> &argv,
-                      char const *const*envp,
+                      char const *const *envp,
                       llvm::ArrayRef<std::string> libSearchPaths,
                       llvm::ArrayRef<std::string> libs) {
-        auto JIT_expected = llvm::orc::LLJITBuilder().create();
-        if (!JIT_expected) {
-            llvm::errs() << "error creating JIT: " << llvm::toString(JIT_expected.takeError()) << "\n";
-            return false;
-        }
-        auto JIT = std::move(JIT_expected.get());
-        llvm::orc::LLJIT &jit = *JIT;
-
-        llvm::orc::JITDylib& mainDylib = jit.getMainJITDylib();
+    auto JIT_expected = llvm::orc::LLJITBuilder().create();
+    if (!JIT_expected) {
+        llvm::errs() << "error creating JIT: "
+                     << llvm::toString(JIT_expected.takeError()) << "\n";
+        return false;
+    }
+    auto JIT = std::move(JIT_expected.get());
+    llvm::orc::LLJIT &jit = *JIT;
 
-        auto Generator_expected = llvm::orc::DynamicLibrarySearchGenerator::GetForCurrentProcess(
-            jit.getDataLayout().getGlobalPrefix()
-        );
+    llvm::orc::JITDylib &mainDylib = jit.getMainJITDylib();
 
-        if (!Generator_expected) {
-            llvm::errs() << "error creating generator: " << llvm::toString(Generator_expected.takeError()) << "\n";
-            return false;
-        }
+    auto Generator_expected =
+        llvm::orc::DynamicLibrarySearchGenerator::GetForCurrentProcess(
+            jit.getDataLayout().getGlobalPrefix());
 
-        std::unique_ptr<llvm::orc::DynamicLibrarySearchGenerator> Generator =
-            std::move(*Generator_expected);
-
-        mainDylib.addGenerator(std::move(Generator));
+    if (!Generator_expected) {
+        llvm::errs() << "error creating generator: "
+                     << llvm::toString(Generator_expected.takeError()) << "\n";
+        return false;
+    }
 
-        module->setDataLayout(jit.getDataLayout());
+    std::unique_ptr<llvm::orc::DynamicLibrarySearchGenerator> Generator =
+        std::move(*Generator_expected);
 
-        auto TSM = llvm::orc::ThreadSafeModule(std::unique_ptr<llvm::Module>(module),
-                                               std::make_unique<llvm::LLVMContext>());
+    mainDylib.addGenerator(std::move(Generator));
 
-        if (llvm::Error AddIRErr = jit.addIRModule(std::move(TSM))) {
-            llvm::errs() << "error adding module to JIT: " << llvm::toString(std::move(AddIRErr)) << "\n";
-            return false;
-        }
+    module->setDataLayout(jit.getDataLayout());
 
-        auto mainAddr_expected = jit.lookup("main");
-        if (!mainAddr_expected) {
-            llvm::errs() << "error resolving main: " << llvm::toString(mainAddr_expected.takeError()) << "\n";
-            return false;
-        }
+    auto TSM =
+        llvm::orc::ThreadSafeModule(std::unique_ptr<llvm::Module>(module),
+                                    std::make_unique<llvm::LLVMContext>());
 
-        using MainPtr = int (*)(int, char *[], char *[]);
+    if (llvm::Error AddIRErr = jit.addIRModule(std::move(TSM))) {
+        llvm::errs() << "error adding module to JIT: "
+                     << llvm::toString(std::move(AddIRErr)) << "\n";
+        return false;
+    }
 
-        llvm::orc::ExecutorAddr mainAddr = mainAddr_expected.get();
-        auto mainFunc = reinterpret_cast<MainPtr>(mainAddr.getValue());
+    auto mainAddr_expected = jit.lookup("main");
+    if (!mainAddr_expected) {
+        llvm::errs() << "error resolving main: "
+                     << llvm::toString(mainAddr_expected.takeError()) << "\n";
+        return false;
+    }
 
-        std::vector<const char*> c_argv;
-        for (const auto& arg : argv) {
-            c_argv.push_back(arg.c_str());
-        }
-        c_argv.push_back(nullptr);
+    using MainPtr = int (*)(int, char *[], char *[]);
 
-        mainFunc(static_cast<int>(c_argv.size() - 1), const_cast<char **>(c_argv.data()), const_cast<char **>(envp));
+    llvm::orc::ExecutorAddr mainAddr = mainAddr_expected.get();
+    auto mainFunc = reinterpret_cast<MainPtr>(mainAddr.getValue());
 
-        return true;
+    std::vector<const char *> c_argv;
+    for (const auto &arg : argv) {
+        c_argv.push_back(arg.c_str());
     }
+    c_argv.push_back(nullptr);
 
-    static void optimizeLLVM(llvm::Module *module, unsigned optLevel, bool internalize) {
-        llvm::LoopAnalysisManager LAM;
-        llvm::FunctionAnalysisManager FAM;
-        llvm::CGSCCAnalysisManager CGAM;
-        llvm::ModuleAnalysisManager MAM;
-        llvm::PassBuilder PB;
-
-        PB.registerModuleAnalyses(MAM);
-        PB.registerCGSCCAnalyses(CGAM);
-        PB.registerFunctionAnalyses(FAM);
-        PB.registerLoopAnalyses(LAM);
-        PB.crossRegisterProxies(LAM, FAM, CGAM, MAM);
-
-        llvm::OptimizationLevel O = llvm::OptimizationLevel::O0;
-        if (optLevel == 1) O = llvm::OptimizationLevel::O1;
-        else if (optLevel == 2) O = llvm::OptimizationLevel::O2;
-        else if (optLevel >= 3) O = llvm::OptimizationLevel::O3;
-
-        llvm::ModulePassManager MPM = PB.buildPerModuleDefaultPipeline(O);
-
-        if (optLevel > 2 && internalize) {
-            MPM.addPass(llvm::InternalizePass([=](const llvm::GlobalValue &GV) {
-                return GV.getName() == "main";
-            }));
-        }
+    mainFunc(static_cast<int>(c_argv.size() - 1),
+             const_cast<char **>(c_argv.data()), const_cast<char **>(envp));
 
-        MPM.addPass(llvm::VerifierPass());
+    return true;
+}
 
-        MPM.run(*module, MAM);
+static void optimizeLLVM(llvm::Module *module, unsigned optLevel,
+                         bool internalize) {
+    llvm::LoopAnalysisManager LAM;
+    llvm::FunctionAnalysisManager FAM;
+    llvm::CGSCCAnalysisManager CGAM;
+    llvm::ModuleAnalysisManager MAM;
+    llvm::PassBuilder PB;
+
+    PB.registerModuleAnalyses(MAM);
+    PB.registerCGSCCAnalyses(CGAM);
+    PB.registerFunctionAnalyses(FAM);
+    PB.registerLoopAnalyses(LAM);
+    PB.crossRegisterProxies(LAM, FAM, CGAM, MAM);
+
+    llvm::OptimizationLevel O = llvm::OptimizationLevel::O0;
+    if (optLevel == 1)
+        O = llvm::OptimizationLevel::O1;
+    else if (optLevel == 2)
+        O = llvm::OptimizationLevel::O2;
+    else if (optLevel >= 3)
+        O = llvm::OptimizationLevel::O3;
+
+    llvm::ModulePassManager MPM = PB.buildPerModuleDefaultPipeline(O);
+
+    if (optLevel > 2 && internalize) {
+        MPM.addPass(llvm::InternalizePass([=](const llvm::GlobalValue &GV) {
+            return GV.getName() == "main";
+        }));
     }
 
-    static void generateLLVM(llvm::Module *module, bool emitAsm, llvm::raw_ostream *out) {
-        llvm::ModuleAnalysisManager MAM;
-        llvm::ModulePassManager passes;
+    MPM.addPass(llvm::VerifierPass());
 
-        if (emitAsm)
-            passes.addPass(llvm::PrintModulePass(*out));
-        else
-            passes.addPass(llvm::BitcodeWriterPass(*out));
+    MPM.run(*module, MAM);
+}
 
-        passes.run(*module, MAM);
-    }
+static void generateLLVM(llvm::Module *module, bool emitAsm,
+                         llvm::raw_ostream *out) {
+    llvm::ModuleAnalysisManager MAM;
+    llvm::ModulePassManager passes;
 
-    static void generateAssembly(llvm::Module *module,
-                                 llvm::TargetMachine *targetMachine,
-                                 llvm::raw_pwrite_stream *out,
-                                 bool emitObject) {
-        llvm::legacy::PassManager passes;
+    if (emitAsm)
+        passes.addPass(llvm::PrintModulePass(*out));
+    else
+        passes.addPass(llvm::BitcodeWriterPass(*out));
 
-        passes.add(llvm::createVerifierPass());
+    passes.run(*module, MAM);
+}
 
-        llvm::CodeGenFileType fileType = emitObject
-                                            ? llvm::CodeGenFileType::ObjectFile
-                                            : llvm::CodeGenFileType::AssemblyFile;
+static void generateAssembly(llvm::Module *module,
+                             llvm::TargetMachine *targetMachine,
+                             llvm::raw_pwrite_stream *out, bool emitObject) {
+    llvm::legacy::PassManager passes;
 
-        if (targetMachine->addPassesToEmitFile(passes, *out, nullptr, fileType)) {
-            llvm::errs() << "error: adding codegen passes failed\n";
-            return;
-        }
+    passes.add(llvm::createVerifierPass());
+
+    llvm::CodeGenFileType fileType = emitObject
+                                         ? llvm::CodeGenFileType::ObjectFile
+                                         : llvm::CodeGenFileType::AssemblyFile;
 
-        passes.run(*module);
+    if (targetMachine->addPassesToEmitFile(passes, *out, nullptr, fileType)) {
+        llvm::errs() << "error: adding codegen passes failed\n";
+        return;
     }
 
-    [[maybe_unused]] static std::string joinCmdArgs(llvm::ArrayRef<llvm::StringRef> args)
-    {
-        std::string s;
-        llvm::raw_string_ostream ss(s);
-        for (const llvm::StringRef &arg : args) {
-            if (&arg != args.begin()) {
-                ss << " ";
-            }
-            ss << arg;
+    passes.run(*module);
+}
+
+[[maybe_unused]] static std::string
+joinCmdArgs(llvm::ArrayRef<llvm::StringRef> args) {
+    std::string s;
+    llvm::raw_string_ostream ss(s);
+    for (const llvm::StringRef &arg : args) {
+        if (&arg != args.begin()) {
+            ss << " ";
         }
-        return s;
+        ss << arg;
     }
+    return s;
+}
 
-    static bool generateBinary(llvm::Module *module,
-                               llvm::TargetMachine *targetMachine,
-                               llvm::Twine const &outputFilePath,
-                               llvm::StringRef const &clangPath,
-                               bool /*exceptions*/,
-                               bool sharedLib,
-                               bool debug,
-                               llvm::ArrayRef<string> arguments,
-                               bool verbose) {
-        int fd;
-        PathString tempObj;
-        if (std::error_code ec = llvm::sys::fs::createUniqueFile("clayobj-%%%%%%%%.obj", fd, tempObj)) {
-            llvm::errs() << "error creating temporary object file: " << ec.message() << '\n';
-            return false;
-        }
-        llvm::FileRemover removeTempObj(tempObj);
+static bool generateBinary(llvm::Module *module,
+                           llvm::TargetMachine *targetMachine,
+                           llvm::Twine const &outputFilePath,
+                           llvm::StringRef const &clangPath,
+                           bool /*exceptions*/, bool sharedLib, bool debug,
+                           llvm::ArrayRef<string> arguments, bool verbose) {
+    int fd;
+    PathString tempObj;
+    if (std::error_code ec = llvm::sys::fs::createUniqueFile(
+            "clayobj-%%%%%%%%.obj", fd, tempObj)) {
+        llvm::errs() << "error creating temporary object file: " << ec.message()
+                     << '\n';
+        return false;
+    }
+    llvm::FileRemover removeTempObj(tempObj);
 
-        {
-            llvm::raw_fd_ostream objOut(fd, /*shouldClose=*/ true);
+    {
+        llvm::raw_fd_ostream objOut(fd, /*shouldClose=*/true);
 
-            generateAssembly(module, targetMachine, &objOut, true);
-        }
+        generateAssembly(module, targetMachine, &objOut, true);
+    }
 
-        string outputFilePathStr = outputFilePath.str();
+    string outputFilePathStr = outputFilePath.str();
 
-        std::vector<llvm::StringRef> clangArgs;
-        clangArgs.emplace_back(clangPath.data());
+    std::vector<llvm::StringRef> clangArgs;
+    clangArgs.emplace_back(clangPath.data());
 
-        switch (llvmDataLayout->getPointerSizeInBits()) {
-            case 32:
-                clangArgs.emplace_back("-m32");
-                break;
-            case 64:
-                clangArgs.emplace_back("-m64");
-                break;
-            default:
-                assert(false);
-        }
+    switch (llvmDataLayout->getPointerSizeInBits()) {
+    case 32:
+        clangArgs.emplace_back("-m32");
+        break;
+    case 64:
+        clangArgs.emplace_back("-m64");
+        break;
+    default:
+        assert(false);
+    }
 
-        llvm::Triple triple(llvmModule->getTargetTriple());
-        if (sharedLib) {
-            clangArgs.emplace_back("-shared");
+    llvm::Triple triple(llvmModule->getTargetTriple());
+    if (sharedLib) {
+        clangArgs.emplace_back("-shared");
 
-            if (triple.isOSWindows()) {
-                string linkerFlags;
-                PathString defPath;
-                outputFilePath.toVector(defPath);
-                llvm::sys::path::replace_extension(defPath, "def");
+        if (triple.isOSWindows()) {
+            string linkerFlags;
+            PathString defPath;
+            outputFilePath.toVector(defPath);
+            llvm::sys::path::replace_extension(defPath, "def");
 
-                linkerFlags = "-Wl,--output-def," + string(defPath.begin(), defPath.end());
+            linkerFlags =
+                "-Wl,--output-def," + string(defPath.begin(), defPath.end());
 
-                clangArgs.emplace_back(linkerFlags);
-            }
-        }
-        if (debug) {
-            if (triple.getOS() == llvm::Triple::Win32)
-                clangArgs.emplace_back("-Wl,/debug");
-        }
-        clangArgs.emplace_back("-o");
-        clangArgs.emplace_back(outputFilePathStr);
-        clangArgs.push_back(tempObj);
-        for (const auto & argument : arguments)
-            clangArgs.emplace_back(argument);
-
-        if (verbose) {
-            llvm::errs() << "executing clang to generate binary:\n";
-            llvm::errs() << "    " << joinCmdArgs(clangArgs) << "\n";
+            clangArgs.emplace_back(linkerFlags);
         }
+    }
+    if (debug) {
+        if (triple.getOS() == llvm::Triple::Win32)
+            clangArgs.emplace_back("-Wl,/debug");
+    }
+    clangArgs.emplace_back("-o");
+    clangArgs.emplace_back(outputFilePathStr);
+    clangArgs.push_back(tempObj);
+    for (const auto &argument : arguments)
+        clangArgs.emplace_back(argument);
+
+    if (verbose) {
+        llvm::errs() << "executing clang to generate binary:\n";
+        llvm::errs() << "    " << joinCmdArgs(clangArgs) << "\n";
+    }
 
-        int result = llvm::sys::ExecuteAndWait(clangPath, clangArgs);
-
-        if (debug && triple.isOSDarwin()) {
-            llvm::ErrorOr<std::string> dsymutilPathOrErr = llvm::sys::findProgramByName("dsymutil");
-            if (std::error_code ec = dsymutilPathOrErr.getError())
-                llvm::errs() << "error creating dsymutil: " << ec.message() << '\n';
+    int result = llvm::sys::ExecuteAndWait(clangPath, clangArgs);
 
-            std::string dsymutilPath = dsymutilPathOrErr ? *dsymutilPathOrErr : "";
+    if (debug && triple.isOSDarwin()) {
+        llvm::ErrorOr<std::string> dsymutilPathOrErr =
+            llvm::sys::findProgramByName("dsymutil");
+        if (std::error_code ec = dsymutilPathOrErr.getError())
+            llvm::errs() << "error creating dsymutil: " << ec.message() << '\n';
 
-            if (!dsymutilPath.empty()) {
-                string outputDSYMPath = outputFilePathStr;
-                outputDSYMPath.append(".dSYM");
+        std::string dsymutilPath = dsymutilPathOrErr ? *dsymutilPathOrErr : "";
 
-                std::vector<llvm::StringRef> dsymutilArgs;
-                dsymutilArgs.emplace_back(dsymutilPath);
-                dsymutilArgs.emplace_back("-o");
-                dsymutilArgs.emplace_back(outputDSYMPath);
-                dsymutilArgs.emplace_back(outputFilePathStr);
+        if (!dsymutilPath.empty()) {
+            string outputDSYMPath = outputFilePathStr;
+            outputDSYMPath.append(".dSYM");
 
-                if (verbose) {
-                    llvm::errs() << "executing dsymutil:";
-                    llvm::errs() << "    " << joinCmdArgs(dsymutilArgs) << "\n";
-                }
+            std::vector<llvm::StringRef> dsymutilArgs;
+            dsymutilArgs.emplace_back(dsymutilPath);
+            dsymutilArgs.emplace_back("-o");
+            dsymutilArgs.emplace_back(outputDSYMPath);
+            dsymutilArgs.emplace_back(outputFilePathStr);
 
-                int dsymResult = llvm::sys::ExecuteAndWait(dsymutilPath, dsymutilArgs);
+            if (verbose) {
+                llvm::errs() << "executing dsymutil:";
+                llvm::errs() << "    " << joinCmdArgs(dsymutilArgs) << "\n";
+            }
 
-                if (dsymResult != 0)
-                    llvm::errs() << "warning: dsymutil exited with error code " << dsymResult << "\n";
-            } else
-                llvm::errs() <<
-                        "warning: unable to find dsymutil on the path; debug info for executable will not be generated\n";
-        }
+            int dsymResult =
+                llvm::sys::ExecuteAndWait(dsymutilPath, dsymutilArgs);
 
-        return (result == 0);
+            if (dsymResult != 0)
+                llvm::errs() << "warning: dsymutil exited with error code "
+                             << dsymResult << "\n";
+        } else
+            llvm::errs() << "warning: unable to find dsymutil on the path; "
+                            "debug info for executable will not be generated\n";
     }
 
-    static void usage(const char *argv0) {
-        llvm::errs() << "usage: " << argv0 << " <options> <clay file>\n";
-        llvm::errs() << "       " << argv0 << " <options> -e <clay code>\n";
-        llvm::errs() << "options:\n";
-        llvm::errs() << "  -o <file>             specify output file\n";
-        llvm::errs() << "  -target <target>      set target platform for code generation\n";
-        llvm::errs() << "  -mcpu <CPU>           set target CPU for code generation\n";
-        llvm::errs() << "  -mattr <features>     set target features for code generation\n"
-                << "                        use +feature to enable a feature\n"
-                << "                        or -feature to disable it\n"
-                << "                        for example, -mattr +feature1,-feature2\n";
-        llvm::errs() << "  -soft-float           generate software floating point library calls\n";
-        llvm::errs() << "  -shared               create a dynamically linkable library\n";
-        llvm::errs() << "  -emit-llvm            emit llvm code\n";
-        llvm::errs() << "  -S                    emit assembler code\n";
-        llvm::errs() << "  -c                    emit object code\n";
-        llvm::errs() << "  -DFLAG[=value]        set flag value\n"
-                << "                        (queryable with Flag?() and Flag())\n";
-        llvm::errs() << "  -O0 -O1 -O2 -O3       set optimization level\n";
-        llvm::errs() << "                        (default -O2, or -O0 with -g)\n";
-        llvm::errs() << "  -g                    keep debug symbol information\n";
-        llvm::errs() << "  -exceptions           enable exception handling\n";
-        llvm::errs() << "  -no-exceptions        disable exception handling\n";
-        llvm::errs() << "  -inline               inline procedures marked 'forceinline'\n";
-        llvm::errs() << "                        and enable 'inline' hints (default)\n";
-        llvm::errs() << "  -no-inline            ignore 'inline' and 'forceinline' keyword\n";
-        llvm::errs() << "  -import-externals     include externals from imported modules\n"
-                << "                        in compilation unit\n"
-                << "                        (default when building standalone or -shared)\n";
-        llvm::errs() << "  -no-import-externals  don't include externals from imported modules\n"
-                << "                        in compilation unit\n"
-                << "                        (default when building -c or -S)\n";
-        llvm::errs() << "  -pic                  generate position independent code\n";
-        llvm::errs() << "  -run                  execute the program without writing to disk\n";
-        llvm::errs() << "  -timing               show timing information\n";
-        llvm::errs() << "  -verbose              be verbose\n";
-        llvm::errs() << "  -full-match-errors    show universal patterns in match failure errors\n";
-        llvm::errs() << "  -log-match <module.symbol>\n"
-                << "                        log overload matching behavior for calls to <symbol>\n"
-                << "                        in module <module>\n";
+    return (result == 0);
+}
+
+static void usage(const char *argv0) {
+    llvm::errs() << "usage: " << argv0 << " <options> <clay file>\n";
+    llvm::errs() << "       " << argv0 << " <options> -e <clay code>\n";
+    llvm::errs() << "options:\n";
+    llvm::errs() << "  -o <file>             specify output file\n";
+    llvm::errs()
+        << "  -target <target>      set target platform for code generation\n";
+    llvm::errs()
+        << "  -mcpu <CPU>           set target CPU for code generation\n";
+    llvm::errs()
+        << "  -mattr <features>     set target features for code generation\n"
+        << "                        use +feature to enable a feature\n"
+        << "                        or -feature to disable it\n"
+        << "                        for example, -mattr +feature1,-feature2\n";
+    llvm::errs() << "  -soft-float           generate software floating point "
+                    "library calls\n";
+    llvm::errs()
+        << "  -shared               create a dynamically linkable library\n";
+    llvm::errs() << "  -emit-llvm            emit llvm code\n";
+    llvm::errs() << "  -S                    emit assembler code\n";
+    llvm::errs() << "  -c                    emit object code\n";
+    llvm::errs()
+        << "  -DFLAG[=value]        set flag value\n"
+        << "                        (queryable with Flag?() and Flag())\n";
+    llvm::errs() << "  -O0 -O1 -O2 -O3       set optimization level\n";
+    llvm::errs() << "                        (default -O2, or -O0 with -g)\n";
+    llvm::errs() << "  -g                    keep debug symbol information\n";
+    llvm::errs() << "  -exceptions           enable exception handling\n";
+    llvm::errs() << "  -no-exceptions        disable exception handling\n";
+    llvm::errs()
+        << "  -inline               inline procedures marked 'forceinline'\n";
+    llvm::errs()
+        << "                        and enable 'inline' hints (default)\n";
+    llvm::errs() << "  -no-inline            ignore 'inline' and 'forceinline' "
+                    "keyword\n";
+    llvm::errs()
+        << "  -import-externals     include externals from imported modules\n"
+        << "                        in compilation unit\n"
+        << "                        (default when building standalone or "
+           "-shared)\n";
+    llvm::errs()
+        << "  -no-import-externals  don't include externals from imported "
+           "modules\n"
+        << "                        in compilation unit\n"
+        << "                        (default when building -c or -S)\n";
+    llvm::errs()
+        << "  -pic                  generate position independent code\n";
+    llvm::errs() << "  -run                  execute the program without "
+                    "writing to disk\n";
+    llvm::errs() << "  -timing               show timing information\n";
+    llvm::errs() << "  -verbose              be verbose\n";
+    llvm::errs() << "  -full-match-errors    show universal patterns in match "
+                    "failure errors\n";
+    llvm::errs() << "  -log-match <module.symbol>\n"
+                 << "                        log overload matching behavior "
+                    "for calls to <symbol>\n"
+                 << "                        in module <module>\n";
 #ifdef __APPLE__
-        llvm::errs() << "  -arch <arch>          build for Darwin architecture <arch>\n";
-        llvm::errs() << "  -F<dir>               add <dir> to framework search path\n";
-        llvm::errs() << "  -framework <name>     link with framework <name>\n";
+    llvm::errs()
+        << "  -arch <arch>          build for Darwin architecture <arch>\n";
+    llvm::errs()
+        << "  -F<dir>               add <dir> to framework search path\n";
+    llvm::errs() << "  -framework <name>     link with framework <name>\n";
 #endif
-        llvm::errs() << "  -L<dir>               add <dir> to library search path\n";
-        llvm::errs() << "  -Wl,<opts>            pass flags to linker\n";
-        llvm::errs() << "  -l<lib>               link with library <lib>\n";
-        llvm::errs() << "  -I<path>              add <path> to clay module search path\n";
-        llvm::errs() << "  -deps                 keep track of the dependencies of the currently\n";
-        llvm::errs() << "                        compiling file and write them to the file\n";
-        llvm::errs() << "                        specified by -o-deps\n";
-        llvm::errs() << "  -no-deps              don't generate dependencies file\n";
-        llvm::errs() << "  -o-deps <file>        write the dependencies to this file\n";
-        llvm::errs() << "                        (defaults to <compilation output file>.d)\n";
-        llvm::errs() << "  -e <source>           compile and run <source> (implies -run)\n";
-        llvm::errs() << "  -M<module>            \"import <module>.*;\" for -e\n";
-        llvm::errs() << "  -version              display version info\n";
-
-        llvm::errs() << "  -final-overloads      enable final overloads (temporary option)\n";
-    }
+    llvm::errs()
+        << "  -L<dir>               add <dir> to library search path\n";
+    llvm::errs() << "  -Wl,<opts>            pass flags to linker\n";
+    llvm::errs() << "  -l<lib>               link with library <lib>\n";
+    llvm::errs()
+        << "  -I<path>              add <path> to clay module search path\n";
+    llvm::errs() << "  -deps                 keep track of the dependencies of "
+                    "the currently\n";
+    llvm::errs() << "                        compiling file and write them to "
+                    "the file\n";
+    llvm::errs() << "                        specified by -o-deps\n";
+    llvm::errs()
+        << "  -no-deps              don't generate dependencies file\n";
+    llvm::errs()
+        << "  -o-deps <file>        write the dependencies to this file\n";
+    llvm::errs() << "                        (defaults to <compilation output "
+                    "file>.d)\n";
+    llvm::errs()
+        << "  -e <source>           compile and run <source> (implies -run)\n";
+    llvm::errs() << "  -M<module>            \"import <module>.*;\" for -e\n";
+    llvm::errs() << "  -version              display version info\n";
+
+    llvm::errs() << "  -final-overloads      enable final overloads (temporary "
+                    "option)\n";
+}
 
-    static string sharedExtensionForTarget(llvm::Triple const &triple) {
-        if (triple.isOSWindows()) {
-            return ".dll";
-        }
-        if (triple.isOSDarwin()) {
-            return ".dylib";
-        }
-        return ".so";
+static string sharedExtensionForTarget(llvm::Triple const &triple) {
+    if (triple.isOSWindows()) {
+        return ".dll";
+    }
+    if (triple.isOSDarwin()) {
+        return ".dylib";
     }
+    return ".so";
+}
 
-    static string objExtensionForTarget(llvm::Triple const &triple) {
-        if (triple.isOSWindows()) {
-            return ".obj";
-        }
-        return ".o";
+static string objExtensionForTarget(llvm::Triple const &triple) {
+    if (triple.isOSWindows()) {
+        return ".obj";
     }
+    return ".o";
+}
 
-    static string exeExtensionForTarget(llvm::Triple const &triple) {
-        if (triple.isOSWindows()) {
-            return ".exe";
-        }
-        return "";
+static string exeExtensionForTarget(llvm::Triple const &triple) {
+    if (triple.isOSWindows()) {
+        return ".exe";
     }
+    return "";
+}
 
-    static void printVersion() {
-        llvm::errs() << "clay compiler version " CLAY_COMPILER_VERSION
-                ", language version " CLAY_LANGUAGE_VERSION " ("
+static void printVersion() {
+    llvm::errs() << "clay compiler version " CLAY_COMPILER_VERSION
+                    ", language version " CLAY_LANGUAGE_VERSION " ("
 #ifdef GIT_ID
-         << "git id " << GIT_ID << ", "
+                 << "git id " << GIT_ID << ", "
 #endif
 #ifdef HG_ID
-         << "hg id " << HG_ID << ", "
+                 << "hg id " << HG_ID << ", "
 #endif
 #ifdef SVN_REVISION
-         << "llvm r" << SVN_REVISION << ", "
+                 << "llvm r" << SVN_REVISION << ", "
 #endif
-                << __DATE__ << ")\n";
-    }
+                 << __DATE__ << ")\n";
+}
 
-    int main2(int argc, char **argv, char const *const*envp) {
-        if (argc == 1) {
-            usage(argv[0]);
-            return 2;
-        }
+int main2(int argc, char **argv, char const *const *envp) {
+    if (argc == 1) {
+        usage(argv[0]);
+        return 2;
+    }
 
-        bool emitLLVM = false;
-        bool emitAsm = false;
-        bool emitObject = false;
-        bool sharedLib = false;
-        bool genPIC = false;
-        bool inlineEnabled = true;
-        bool exceptions = true;
-        bool run = false;
-        bool repl = false;
-        bool verbose = false;
-        bool crossCompiling = false;
-        bool showTiming = false;
-        bool codegenExternals = false;
-        bool codegenExternalsSet = false;
-
-        bool generateDeps = false;
-
-        unsigned optLevel = 2;
-        bool optLevelSet = false;
-
-        bool finalOverloadsEnabled = false;
-        bool softFloat = false;
+    bool emitLLVM = false;
+    bool emitAsm = false;
+    bool emitObject = false;
+    bool sharedLib = false;
+    bool genPIC = false;
+    bool inlineEnabled = true;
+    bool exceptions = true;
+    bool run = false;
+    bool repl = false;
+    bool verbose = false;
+    bool crossCompiling = false;
+    bool showTiming = false;
+    bool codegenExternals = false;
+    bool codegenExternalsSet = false;
+
+    bool generateDeps = false;
+
+    unsigned optLevel = 2;
+    bool optLevelSet = false;
+
+    bool finalOverloadsEnabled = false;
+    bool softFloat = false;
 
 #ifdef __APPLE__
-        genPIC = true;
+    genPIC = true;
 
-        string arch;
+    string arch;
 #endif
 
-        string clayFile;
-        string outputFile;
-        string targetTriple = llvm::sys::getDefaultTargetTriple();
+    string clayFile;
+    string outputFile;
+    string targetTriple = llvm::sys::getDefaultTargetTriple();
 
-        string targetCPU;
-        string targetFeatures;
+    string targetCPU;
+    string targetFeatures;
 
-        string clayScriptImports;
-        string clayScript;
+    string clayScriptImports;
+    string clayScript;
 
-        vector<string> libSearchPathArgs;
-        vector<string> libSearchPath;
-        string linkerFlags;
-        vector<string> librariesArgs;
-        vector<string> libraries;
-        vector<PathString> searchPath;
+    vector<string> libSearchPathArgs;
+    vector<string> libSearchPath;
+    string linkerFlags;
+    vector<string> librariesArgs;
+    vector<string> libraries;
+    vector<PathString> searchPath;
 
-        string dependenciesOutputFile;
+    string dependenciesOutputFile;
 #ifdef __APPLE__
-        vector<string> frameworkSearchPath;
-        vector<string> frameworks;
+    vector<string> frameworkSearchPath;
+    vector<string> frameworks;
 #endif
 
-        bool debug = false;
-
-        for (int i = 1; i < argc; ++i) {
-            if ((strcmp(argv[i], "-shared") == 0)) {
-                sharedLib = true;
-            } else if (strcmp(argv[i], "-emit-llvm") == 0) {
-                emitLLVM = true;
-            } else if (strcmp(argv[i], "-S") == 0) {
-                emitAsm = true;
-            } else if (strcmp(argv[i], "-c") == 0) {
-                emitObject = true;
-            } else if (strcmp(argv[i], "-g") == 0) {
-                debug = true;
-                if (!optLevelSet)
-                    optLevel = 0;
-            } else if (strcmp(argv[i], "-O0") == 0) {
+    bool debug = false;
+
+    for (int i = 1; i < argc; ++i) {
+        if ((strcmp(argv[i], "-shared") == 0)) {
+            sharedLib = true;
+        } else if (strcmp(argv[i], "-emit-llvm") == 0) {
+            emitLLVM = true;
+        } else if (strcmp(argv[i], "-S") == 0) {
+            emitAsm = true;
+        } else if (strcmp(argv[i], "-c") == 0) {
+            emitObject = true;
+        } else if (strcmp(argv[i], "-g") == 0) {
+            debug = true;
+            if (!optLevelSet)
                 optLevel = 0;
-                optLevelSet = true;
-            } else if (strcmp(argv[i], "-O1") == 0) {
-                optLevel = 1;
-                optLevelSet = true;
-            } else if (strcmp(argv[i], "-O2") == 0) {
-                optLevel = 2;
-                optLevelSet = true;
-            } else if (strcmp(argv[i], "-O3") == 0) {
-                optLevel = 3;
-                optLevelSet = true;
-            } else if (strcmp(argv[i], "-inline") == 0) {
-                inlineEnabled = true;
-            } else if (strcmp(argv[i], "-no-inline") == 0) {
-                inlineEnabled = false;
-            } else if (strcmp(argv[i], "-exceptions") == 0) {
-                exceptions = true;
-            } else if (strcmp(argv[i], "-no-exceptions") == 0) {
-                exceptions = false;
-            } else if (strcmp(argv[i], "-pic") == 0) {
-                genPIC = true;
-            } else if (strcmp(argv[i], "-verbose") == 0 || strcmp(argv[i], "-v") == 0) {
-                verbose = true;
-            } else if (strcmp(argv[i], "-run") == 0) {
-                run = true;
-            } else if (strcmp(argv[i], "-repl") == 0) {
-                repl = true;
-            } else if (strcmp(argv[i], "-timing") == 0) {
-                showTiming = true;
-            } else if (strcmp(argv[i], "-full-match-errors") == 0) {
-                shouldPrintFullMatchErrors = true;
-            } else if (strcmp(argv[i], "-log-match") == 0) {
-                if (i + 1 == argc) {
-                    llvm::errs() << "error: symbol name missing after -log-match\n";
-                    return 1;
-                }
-                ++i;
-                char const *dot = strrchr(argv[i], '.');
-                if (dot == nullptr) {
-                    logMatchSymbols.insert(make_pair(string("*"), argv[i]));
-                } else {
-                    logMatchSymbols.insert(make_pair(string(static_cast<char const *>(argv[i]), dot), string(dot + 1)));
-                }
-            } else if (strcmp(argv[i], "-e") == 0) {
-                if (i + 1 == argc) {
-                    llvm::errs() << "error: source string missing after -e\n";
-                    return 1;
-                }
-                ++i;
-                run = true;
-                clayScript += argv[i];
-                clayScript += "\n";
-            } else if (strncmp(argv[i], "-M", 2) == 0) {
-                string modulespec = argv[i] + 2;
-                if (modulespec.empty()) {
-                    llvm::errs() << "error: module missing after -M\n";
-                    return 1;
-                }
-                clayScriptImports += "import " + modulespec + ".*; ";
-            } else if (strcmp(argv[i], "-o") == 0) {
-                ++i;
-                if (i == argc) {
-                    llvm::errs() << "error: filename missing after -o\n";
-                    return 1;
-                }
-                if (!outputFile.empty()) {
-                    llvm::errs() << "error: output file already specified: "
-                            << outputFile
-                            << ", specified again as " << argv[i] << '\n';
-                    return 1;
-                }
-                outputFile = argv[i];
+        } else if (strcmp(argv[i], "-O0") == 0) {
+            optLevel = 0;
+            optLevelSet = true;
+        } else if (strcmp(argv[i], "-O1") == 0) {
+            optLevel = 1;
+            optLevelSet = true;
+        } else if (strcmp(argv[i], "-O2") == 0) {
+            optLevel = 2;
+            optLevelSet = true;
+        } else if (strcmp(argv[i], "-O3") == 0) {
+            optLevel = 3;
+            optLevelSet = true;
+        } else if (strcmp(argv[i], "-inline") == 0) {
+            inlineEnabled = true;
+        } else if (strcmp(argv[i], "-no-inline") == 0) {
+            inlineEnabled = false;
+        } else if (strcmp(argv[i], "-exceptions") == 0) {
+            exceptions = true;
+        } else if (strcmp(argv[i], "-no-exceptions") == 0) {
+            exceptions = false;
+        } else if (strcmp(argv[i], "-pic") == 0) {
+            genPIC = true;
+        } else if (strcmp(argv[i], "-verbose") == 0 ||
+                   strcmp(argv[i], "-v") == 0) {
+            verbose = true;
+        } else if (strcmp(argv[i], "-run") == 0) {
+            run = true;
+        } else if (strcmp(argv[i], "-repl") == 0) {
+            repl = true;
+        } else if (strcmp(argv[i], "-timing") == 0) {
+            showTiming = true;
+        } else if (strcmp(argv[i], "-full-match-errors") == 0) {
+            shouldPrintFullMatchErrors = true;
+        } else if (strcmp(argv[i], "-log-match") == 0) {
+            if (i + 1 == argc) {
+                llvm::errs() << "error: symbol name missing after -log-match\n";
+                return 1;
             }
+            ++i;
+            char const *dot = strrchr(argv[i], '.');
+            if (dot == nullptr) {
+                logMatchSymbols.insert(make_pair(string("*"), argv[i]));
+            } else {
+                logMatchSymbols.insert(
+                    make_pair(string(static_cast<char const *>(argv[i]), dot),
+                              string(dot + 1)));
+            }
+        } else if (strcmp(argv[i], "-e") == 0) {
+            if (i + 1 == argc) {
+                llvm::errs() << "error: source string missing after -e\n";
+                return 1;
+            }
+            ++i;
+            run = true;
+            clayScript += argv[i];
+            clayScript += "\n";
+        } else if (strncmp(argv[i], "-M", 2) == 0) {
+            string modulespec = argv[i] + 2;
+            if (modulespec.empty()) {
+                llvm::errs() << "error: module missing after -M\n";
+                return 1;
+            }
+            clayScriptImports += "import " + modulespec + ".*; ";
+        } else if (strcmp(argv[i], "-o") == 0) {
+            ++i;
+            if (i == argc) {
+                llvm::errs() << "error: filename missing after -o\n";
+                return 1;
+            }
+            if (!outputFile.empty()) {
+                llvm::errs()
+                    << "error: output file already specified: " << outputFile
+                    << ", specified again as " << argv[i] << '\n';
+                return 1;
+            }
+            outputFile = argv[i];
+        }
 #ifdef __APPLE__
-            else if (strstr(argv[i], "-F") == argv[i]) {
-                string frameworkDir = argv[i] + strlen("-F");
-                if (frameworkDir.empty()) {
-                    if (i + 1 == argc) {
-                        llvm::errs() << "error: directory missing after -F\n";
-                        return 1;
-                    }
-                    ++i;
-                    frameworkDir = argv[i];
-                    if (frameworkDir.empty() || (frameworkDir[0] == '-')) {
-                        llvm::errs() << "error: directory missing after -F\n";
-                        return 1;
-                    }
-                }
-                frameworkSearchPath.push_back("-F" + frameworkDir);
-            } else if (strcmp(argv[i], "-framework") == 0) {
-                if (i + 1 == argc) {
-                    llvm::errs() << "error: framework name missing after -framework\n";
-                    return 1;
-                }
-                ++i;
-                string framework = argv[i];
-                if (framework.empty() || (framework[0] == '-')) {
-                    llvm::errs() << "error: framework name missing after -framework\n";
-                    return 1;
-                }
-                frameworks.emplace_back("-framework");
-                frameworks.push_back(framework);
-            } else if (strcmp(argv[i], "-arch") == 0) {
+        else if (strstr(argv[i], "-F") == argv[i]) {
+            string frameworkDir = argv[i] + strlen("-F");
+            if (frameworkDir.empty()) {
                 if (i + 1 == argc) {
-                    llvm::errs() << "error: architecture name missing after -arch\n";
+                    llvm::errs() << "error: directory missing after -F\n";
                     return 1;
                 }
                 ++i;
-                if (!arch.empty()) {
-                    llvm::errs() << "error: multiple -arch flags currently unsupported\n";
-                    return 1;
-                }
-                arch = argv[i];
-                if (arch.empty() || (arch[0] == '-')) {
-                    llvm::errs() << "error: architecture name missing after -arch\n";
+                frameworkDir = argv[i];
+                if (frameworkDir.empty() || (frameworkDir[0] == '-')) {
+                    llvm::errs() << "error: directory missing after -F\n";
                     return 1;
                 }
+            }
+            frameworkSearchPath.push_back("-F" + frameworkDir);
+        } else if (strcmp(argv[i], "-framework") == 0) {
+            if (i + 1 == argc) {
+                llvm::errs()
+                    << "error: framework name missing after -framework\n";
+                return 1;
+            }
+            ++i;
+            string framework = argv[i];
+            if (framework.empty() || (framework[0] == '-')) {
+                llvm::errs()
+                    << "error: framework name missing after -framework\n";
+                return 1;
+            }
+            frameworks.emplace_back("-framework");
+            frameworks.push_back(framework);
+        } else if (strcmp(argv[i], "-arch") == 0) {
+            if (i + 1 == argc) {
+                llvm::errs()
+                    << "error: architecture name missing after -arch\n";
+                return 1;
+            }
+            ++i;
+            if (!arch.empty()) {
+                llvm::errs()
+                    << "error: multiple -arch flags currently unsupported\n";
+                return 1;
+            }
+            arch = argv[i];
+            if (arch.empty() || (arch[0] == '-')) {
+                llvm::errs()
+                    << "error: architecture name missing after -arch\n";
+                return 1;
+            }
 
-                if (arch == "i386") {
-                    targetTriple = "i386-apple-darwin10";
-                } else if (arch == "x86_64") {
-                    targetTriple = "x86_64-apple-darwin10";
-                } else if (arch == "ppc") {
-                    targetTriple = "powerpc-apple-darwin10";
-                } else if (arch == "ppc64") {
-                    targetTriple = "powerpc64-apple-darwin10";
-                } else if (arch == "armv6") {
-                    targetTriple = "armv6-apple-darwin4.1-iphoneos";
-                } else if (arch == "armv7") {
-                    targetTriple = "thumbv7-apple-darwin4.1-iphoneos";
-                } else {
-                    llvm::errs() << "error: unrecognized -arch value " << arch << "\n";
-                    return 1;
-                }
+            if (arch == "i386") {
+                targetTriple = "i386-apple-darwin10";
+            } else if (arch == "x86_64") {
+                targetTriple = "x86_64-apple-darwin10";
+            } else if (arch == "ppc") {
+                targetTriple = "powerpc-apple-darwin10";
+            } else if (arch == "ppc64") {
+                targetTriple = "powerpc64-apple-darwin10";
+            } else if (arch == "armv6") {
+                targetTriple = "armv6-apple-darwin4.1-iphoneos";
+            } else if (arch == "armv7") {
+                targetTriple = "thumbv7-apple-darwin4.1-iphoneos";
+            } else {
+                llvm::errs()
+                    << "error: unrecognized -arch value " << arch << "\n";
+                return 1;
             }
+        }
 #endif
-            else if (strcmp(argv[i], "-target") == 0) {
+        else if (strcmp(argv[i], "-target") == 0) {
+            if (i + 1 == argc) {
+                llvm::errs() << "error: target name missing after -target\n";
+                return 1;
+            }
+            ++i;
+            targetTriple = argv[i];
+            if (targetTriple.empty() || (targetTriple[0] == '-')) {
+                llvm::errs() << "error: target name missing after -target\n";
+                return 1;
+            }
+            crossCompiling =
+                targetTriple != llvm::sys::getDefaultTargetTriple();
+        } else if (strcmp(argv[i], "-mcpu") == 0) {
+            if (i + 1 == argc) {
+                llvm::errs() << "error: CPU name missing after -mcpu\n";
+                return 1;
+            }
+            ++i;
+            targetCPU = argv[i];
+            if (targetCPU.empty() || (targetCPU[0] == '-')) {
+                llvm::errs() << "error: CPU name missing after -mcpu\n";
+                return 1;
+            }
+        } else if (strcmp(argv[i], "-mattr") == 0) {
+            if (i + 1 == argc) {
+                llvm::errs() << "error: features missing after -mattr\n";
+                return 1;
+            }
+            ++i;
+            targetFeatures = argv[i];
+            if (targetFeatures.empty() || (targetFeatures[0] == '-')) {
+                llvm::errs() << "error: features missing after -mattr\n";
+                return 1;
+            }
+        } else if (strcmp(argv[i], "-soft-float") == 0) {
+            softFloat = true;
+        } else if (strstr(argv[i], "-Wl") == argv[i]) {
+            linkerFlags += argv[i] + strlen("-Wl");
+        } else if (strstr(argv[i], "-L") == argv[i]) {
+            string libDir = argv[i] + strlen("-L");
+            if (libDir.empty()) {
                 if (i + 1 == argc) {
-                    llvm::errs() << "error: target name missing after -target\n";
+                    llvm::errs() << "error: directory missing after -L\n";
                     return 1;
                 }
                 ++i;
-                targetTriple = argv[i];
-                if (targetTriple.empty() || (targetTriple[0] == '-')) {
-                    llvm::errs() << "error: target name missing after -target\n";
+                libDir = argv[i];
+                if (libDir.empty() || (libDir[0] == '-')) {
+                    llvm::errs() << "error: directory missing after -L\n";
                     return 1;
                 }
-                crossCompiling = targetTriple != llvm::sys::getDefaultTargetTriple();
-            } else if (strcmp(argv[i], "-mcpu") == 0) {
+            }
+            libSearchPath.push_back(libDir);
+            libSearchPathArgs.push_back("-L" + libDir);
+        } else if (strstr(argv[i], "-l") == argv[i]) {
+            string lib = argv[i] + strlen("-l");
+            if (lib.empty()) {
                 if (i + 1 == argc) {
-                    llvm::errs() << "error: CPU name missing after -mcpu\n";
+                    llvm::errs() << "error: library missing after -l\n";
                     return 1;
                 }
                 ++i;
-                targetCPU = argv[i];
-                if (targetCPU.empty() || (targetCPU[0] == '-')) {
-                    llvm::errs() << "error: CPU name missing after -mcpu\n";
+                lib = argv[i];
+                if (lib.empty() || (lib[0] == '-')) {
+                    llvm::errs() << "error: library missing after -l\n";
                     return 1;
                 }
-            } else if (strcmp(argv[i], "-mattr") == 0) {
+            }
+            libraries.push_back(lib);
+            librariesArgs.push_back("-l" + lib);
+        } else if (strstr(argv[i], "-D") == argv[i]) {
+            char *namep = argv[i] + strlen("-D");
+            if (namep[0] == '\0') {
                 if (i + 1 == argc) {
-                    llvm::errs() << "error: features missing after -mattr\n";
+                    llvm::errs() << "error: definition missing after -D\n";
                     return 1;
                 }
                 ++i;
-                targetFeatures = argv[i];
-                if (targetFeatures.empty() || (targetFeatures[0] == '-')) {
-                    llvm::errs() << "error: features missing after -mattr\n";
+                namep = argv[i];
+                if (namep[0] == '\0' || namep[0] == '-') {
+                    llvm::errs() << "error: definition missing after -D\n";
                     return 1;
                 }
-            } else if (strcmp(argv[i], "-soft-float") == 0) {
-                softFloat = true;
-            } else if (strstr(argv[i], "-Wl") == argv[i]) {
-                linkerFlags += argv[i] + strlen("-Wl");
-            } else if (strstr(argv[i], "-L") == argv[i]) {
-                string libDir = argv[i] + strlen("-L");
-                if (libDir.empty()) {
-                    if (i + 1 == argc) {
-                        llvm::errs() << "error: directory missing after -L\n";
-                        return 1;
-                    }
-                    ++i;
-                    libDir = argv[i];
-                    if (libDir.empty() || (libDir[0] == '-')) {
-                        llvm::errs() << "error: directory missing after -L\n";
-                        return 1;
-                    }
-                }
-                libSearchPath.push_back(libDir);
-                libSearchPathArgs.push_back("-L" + libDir);
-            } else if (strstr(argv[i], "-l") == argv[i]) {
-                string lib = argv[i] + strlen("-l");
-                if (lib.empty()) {
-                    if (i + 1 == argc) {
-                        llvm::errs() << "error: library missing after -l\n";
-                        return 1;
-                    }
-                    ++i;
-                    lib = argv[i];
-                    if (lib.empty() || (lib[0] == '-')) {
-                        llvm::errs() << "error: library missing after -l\n";
-                        return 1;
-                    }
-                }
-                libraries.push_back(lib);
-                librariesArgs.push_back("-l" + lib);
-            } else if (strstr(argv[i], "-D") == argv[i]) {
-                char *namep = argv[i] + strlen("-D");
-                if (namep[0] == '\0') {
-                    if (i + 1 == argc) {
-                        llvm::errs() << "error: definition missing after -D\n";
-                        return 1;
-                    }
-                    ++i;
-                    namep = argv[i];
-                    if (namep[0] == '\0' || namep[0] == '-') {
-                        llvm::errs() << "error: definition missing after -D\n";
-                        return 1;
-                    }
-                }
-                char *equalSignp = strchr(namep, '=');
-                string name = equalSignp == nullptr
-                                  ? string(namep)
-                                  : string(namep, equalSignp);
-                string value = equalSignp == nullptr
-                                   ? string()
-                                   : string(equalSignp + 1);
-
-                globalFlags[name] = value;
-            } else if (strstr(argv[i], "-I") == argv[i]) {
-                string path = argv[i] + strlen("-I");
-                if (path.empty()) {
-                    if (i + 1 == argc) {
-                        llvm::errs() << "error: path missing after -I\n";
-                        return 1;
-                    }
-                    ++i;
-                    path = argv[i];
-                    if (path.empty() || (path[0] == '-')) {
-                        llvm::errs() << "error: path missing after -I\n";
-                        return 1;
-                    }
-                }
-                searchPath.emplace_back(path);
-            } else if (strstr(argv[i], "-version") == argv[i]
-                       || strcmp(argv[i], "--version") == 0) {
-                printVersion();
-                return 0;
-            } else if (strcmp(argv[i], "-import-externals") == 0) {
-                codegenExternals = true;
-                codegenExternalsSet = true;
-            } else if (strcmp(argv[i], "-no-import-externals") == 0) {
-                codegenExternals = false;
-                codegenExternalsSet = true;
-            } else if (strcmp(argv[i], "-deps") == 0) {
-                generateDeps = true;
-            } else if (strcmp(argv[i], "-no-deps") == 0) {
-                generateDeps = false;
-            } else if (strcmp(argv[i], "-o-deps") == 0) {
-                ++i;
-                if (i == argc) {
-                    llvm::errs() << "error: filename missing after -o-deps\n";
-                    return 1;
-                }
-                if (!dependenciesOutputFile.empty()) {
-                    llvm::errs() << "error: dependencies output file already specified: "
-                            << dependenciesOutputFile
-                            << ", specified again as " << argv[i] << '\n';
+            }
+            char *equalSignp = strchr(namep, '=');
+            string name = equalSignp == nullptr ? string(namep)
+                                                : string(namep, equalSignp);
+            string value =
+                equalSignp == nullptr ? string() : string(equalSignp + 1);
+
+            globalFlags[name] = value;
+        } else if (strstr(argv[i], "-I") == argv[i]) {
+            string path = argv[i] + strlen("-I");
+            if (path.empty()) {
+                if (i + 1 == argc) {
+                    llvm::errs() << "error: path missing after -I\n";
                     return 1;
                 }
-                dependenciesOutputFile = argv[i];
-            } else if (strcmp(argv[i], "--") == 0) {
                 ++i;
-                if (clayFile.empty()) {
-                    if (i != argc - 1) {
-                        llvm::errs() << "error: clay file already specified: " << argv[i]
-                                << ", unrecognized parameter: " << argv[i + 1] << '\n';
-                        return 1;
-                    }
-                    clayFile = argv[i];
-                } else {
-                    if (i != argc) {
-                        llvm::errs() << "error: clay file already specified: " << clayFile
-                                << ", unrecognized parameter: " << argv[i] << '\n';
-                        return 1;
-                    }
-                }
-            } else if (strcmp(argv[i], "-help") == 0
-                       || strcmp(argv[i], "--help") == 0
-                       || strcmp(argv[i], "/?") == 0) {
-                usage(argv[0]);
-                return 2;
-            } else if (strstr(argv[i], "-") != argv[i]) {
-                if (!clayFile.empty()) {
-                    llvm::errs() << "error: clay file already specified: " << clayFile
-                            << ", unrecognized parameter: " << argv[i] << '\n';
+                path = argv[i];
+                if (path.empty() || (path[0] == '-')) {
+                    llvm::errs() << "error: path missing after -I\n";
                     return 1;
                 }
-                clayFile = argv[i];
-            } else if (strcmp(argv[i], "-final-overloads") == 0) {
-                finalOverloadsEnabled = true;
-            } else {
-                llvm::errs() << "error: unrecognized option " << argv[i] << '\n';
-                return 1;
             }
-        }
-
-        if (verbose) {
+            searchPath.emplace_back(path);
+        } else if (strstr(argv[i], "-version") == argv[i] ||
+                   strcmp(argv[i], "--version") == 0) {
             printVersion();
-        }
-
-        if (repl && clayScript.empty() && clayFile.empty()) {
-            clayScript = "/*empty module if file not specified*/";
-        } else {
-            if (clayScript.empty() && clayFile.empty()) {
-                llvm::errs() << "error: clay file not specified\n";
+            return 0;
+        } else if (strcmp(argv[i], "-import-externals") == 0) {
+            codegenExternals = true;
+            codegenExternalsSet = true;
+        } else if (strcmp(argv[i], "-no-import-externals") == 0) {
+            codegenExternals = false;
+            codegenExternalsSet = true;
+        } else if (strcmp(argv[i], "-deps") == 0) {
+            generateDeps = true;
+        } else if (strcmp(argv[i], "-no-deps") == 0) {
+            generateDeps = false;
+        } else if (strcmp(argv[i], "-o-deps") == 0) {
+            ++i;
+            if (i == argc) {
+                llvm::errs() << "error: filename missing after -o-deps\n";
+                return 1;
+            }
+            if (!dependenciesOutputFile.empty()) {
+                llvm::errs()
+                    << "error: dependencies output file already specified: "
+                    << dependenciesOutputFile << ", specified again as "
+                    << argv[i] << '\n';
                 return 1;
             }
-            if (!clayScript.empty() && !clayFile.empty()) {
-                llvm::errs() << "error: -e cannot be specified with input file\n";
+            dependenciesOutputFile = argv[i];
+        } else if (strcmp(argv[i], "--") == 0) {
+            ++i;
+            if (clayFile.empty()) {
+                if (i != argc - 1) {
+                    llvm::errs()
+                        << "error: clay file already specified: " << argv[i]
+                        << ", unrecognized parameter: " << argv[i + 1] << '\n';
+                    return 1;
+                }
+                clayFile = argv[i];
+            } else {
+                if (i != argc) {
+                    llvm::errs()
+                        << "error: clay file already specified: " << clayFile
+                        << ", unrecognized parameter: " << argv[i] << '\n';
+                    return 1;
+                }
+            }
+        } else if (strcmp(argv[i], "-help") == 0 ||
+                   strcmp(argv[i], "--help") == 0 ||
+                   strcmp(argv[i], "/?") == 0) {
+            usage(argv[0]);
+            return 2;
+        } else if (strstr(argv[i], "-") != argv[i]) {
+            if (!clayFile.empty()) {
+                llvm::errs()
+                    << "error: clay file already specified: " << clayFile
+                    << ", unrecognized parameter: " << argv[i] << '\n';
                 return 1;
             }
+            clayFile = argv[i];
+        } else if (strcmp(argv[i], "-final-overloads") == 0) {
+            finalOverloadsEnabled = true;
+        } else {
+            llvm::errs() << "error: unrecognized option " << argv[i] << '\n';
+            return 1;
         }
+    }
 
-        if (!clayScriptImports.empty() && clayScript.empty()) {
-            llvm::errs() << "error: -M specified without -e\n";
-        }
+    if (verbose) {
+        printVersion();
+    }
 
-        if (emitAsm && emitObject) {
-            llvm::errs() << "error: -S or -c cannot be used together\n";
+    if (repl && clayScript.empty() && clayFile.empty()) {
+        clayScript = "/*empty module if file not specified*/";
+    } else {
+        if (clayScript.empty() && clayFile.empty()) {
+            llvm::errs() << "error: clay file not specified\n";
             return 1;
         }
-
-        if (crossCompiling && run) {
-            llvm::errs() << "error: cannot use -run when cross compiling\n";
+        if (!clayScript.empty() && !clayFile.empty()) {
+            llvm::errs() << "error: -e cannot be specified with input file\n";
             return 1;
         }
+    }
+
+    if (!clayScriptImports.empty() && clayScript.empty()) {
+        llvm::errs() << "error: -M specified without -e\n";
+    }
+
+    if (emitAsm && emitObject) {
+        llvm::errs() << "error: -S or -c cannot be used together\n";
+        return 1;
+    }
+
+    if (crossCompiling && run) {
+        llvm::errs() << "error: cannot use -run when cross compiling\n";
+        return 1;
+    }
 
-        if (crossCompiling && !(emitLLVM || emitAsm || emitObject)
+    if (crossCompiling && !(emitLLVM || emitAsm || emitObject)
 #ifdef __APPLE__
-            && arch.empty()
+        && arch.empty()
 #endif
-        ) {
-            llvm::errs() << "error: must use -emit-llvm, -S, or -c when cross compiling\n";
-            return 1;
-        }
+    ) {
+        llvm::errs()
+            << "error: must use -emit-llvm, -S, or -c when cross compiling\n";
+        return 1;
+    }
 
-        if (!codegenExternalsSet)
-            codegenExternals = !(emitLLVM || emitAsm || emitObject);
+    if (!codegenExternalsSet)
+        codegenExternals = !(emitLLVM || emitAsm || emitObject);
 
-        if ((emitLLVM || emitAsm || emitObject) && run)
-            run = false;
+    if ((emitLLVM || emitAsm || emitObject) && run)
+        run = false;
 
-        setInlineEnabled(inlineEnabled);
-        setExceptionsEnabled(exceptions);
+    setInlineEnabled(inlineEnabled);
+    setExceptionsEnabled(exceptions);
 
-        setFinalOverloadsEnabled(finalOverloadsEnabled);
+    setFinalOverloadsEnabled(finalOverloadsEnabled);
 
-        llvm::Triple llvmTriple(targetTriple);
-        targetTriple = llvmTriple.str();
+    llvm::Triple llvmTriple(targetTriple);
+    targetTriple = llvmTriple.str();
 
-        std::string moduleName = clayScript.empty() ? clayFile : "-e";
+    std::string moduleName = clayScript.empty() ? clayFile : "-e";
 
-        llvm::TargetMachine *targetMachine = initLLVM(targetTriple,
-                                                      targetCPU, targetFeatures, softFloat, moduleName, "",
-                                                      (sharedLib || genPIC), debug, optLevel);
-        if (targetMachine == nullptr) {
-            llvm::errs() << "error: unable to initialize LLVM for target " << targetTriple << "\n";
-            return 1;
-        }
+    llvm::TargetMachine *targetMachine =
+        initLLVM(targetTriple, targetCPU, targetFeatures, softFloat, moduleName,
+                 "", (sharedLib || genPIC), debug, optLevel);
+    if (targetMachine == nullptr) {
+        llvm::errs() << "error: unable to initialize LLVM for target "
+                     << targetTriple << "\n";
+        return 1;
+    }
 
-        initTypes();
-        initExternalTarget(targetTriple);
-
-        // Try environment variables first
-        if (char *libclayPath = getenv("CLAY_PATH")) {
-            // Parse the environment variable
-            // Format expected is standard PATH form, i.e.
-            // CLAY_PATH=path1:path2:path3  (on Unix)
-            // CLAY_PATH=path1;path2;path3  (on Windows)
-            char *begin = libclayPath;
-            char *end;
-            do {
-                end = begin;
-                while (*end && (*end != ENV_SEPARATOR))
-                    ++end;
-                searchPath.emplace_back(llvm::StringRef(begin, static_cast<size_t>(end - begin)));
-                begin = end + 1;
-            } while (*end);
-        }
-        // Add the relative path from the executable
-        PathString clayExe(llvm::sys::fs::getMainExecutable(argv[0], reinterpret_cast<void *>(&usage)));
-        llvm::StringRef clayDir = llvm::sys::path::parent_path(clayExe);
+    initTypes();
+    initExternalTarget(targetTriple);
+
+    // Try environment variables first
+    if (char *libclayPath = getenv("CLAY_PATH")) {
+        // Parse the environment variable
+        // Format expected is standard PATH form, i.e.
+        // CLAY_PATH=path1:path2:path3  (on Unix)
+        // CLAY_PATH=path1;path2;path3  (on Windows)
+        char *begin = libclayPath;
+        char *end;
+        do {
+            end = begin;
+            while (*end && (*end != ENV_SEPARATOR))
+                ++end;
+            searchPath.emplace_back(
+                llvm::StringRef(begin, static_cast<size_t>(end - begin)));
+            begin = end + 1;
+        } while (*end);
+    }
+    // Add the relative path from the executable
+    PathString clayExe(llvm::sys::fs::getMainExecutable(
+        argv[0], reinterpret_cast<void *>(&usage)));
+    llvm::StringRef clayDir = llvm::sys::path::parent_path(clayExe);
 
-        PathString libDirDevelopment(clayDir);
-        PathString libDirProduction1(clayDir);
-        PathString libDirProduction2(clayDir);
+    PathString libDirDevelopment(clayDir);
+    PathString libDirProduction1(clayDir);
+    PathString libDirProduction2(clayDir);
 
-        llvm::sys::path::append(libDirDevelopment, "../../lib-clay");
-        llvm::sys::path::append(libDirProduction1, "../lib/lib-clay");
-        llvm::sys::path::append(libDirProduction2, "lib-clay");
+    llvm::sys::path::append(libDirDevelopment, "../../lib-clay");
+    llvm::sys::path::append(libDirProduction1, "../lib/lib-clay");
+    llvm::sys::path::append(libDirProduction2, "lib-clay");
 
-        searchPath.push_back(libDirDevelopment);
-        searchPath.push_back(libDirProduction1);
-        searchPath.push_back(libDirProduction2);
-        searchPath.emplace_back(".");
+    searchPath.push_back(libDirDevelopment);
+    searchPath.push_back(libDirProduction1);
+    searchPath.push_back(libDirProduction2);
+    searchPath.emplace_back(".");
 
-        if (verbose) {
-            llvm::errs() << "using search path:\n";
+    if (verbose) {
+        llvm::errs() << "using search path:\n";
 
-            for (const auto & it : searchPath) {
-                llvm::errs() << "    " << it << "\n";
-            }
+        for (const auto &it : searchPath) {
+            llvm::errs() << "    " << it << "\n";
         }
+    }
 
-        setSearchPath(searchPath);
-
-        if (outputFile.empty()) {
-            llvm::StringRef clayFileBasename = llvm::sys::path::stem(clayFile);
-            outputFile = string(clayFileBasename.begin(), clayFileBasename.end());
-
-            if (emitLLVM && emitAsm)
-                outputFile += ".ll";
-            else if (emitAsm)
-                outputFile += ".s";
-            else if (emitObject || emitLLVM)
-                outputFile += objExtensionForTarget(llvmTriple);
-            else if (sharedLib)
-                outputFile += sharedExtensionForTarget(llvmTriple);
-            else
-                outputFile += exeExtensionForTarget(llvmTriple);
-        }
-        if (!run) {
-            bool isDir;
-            if (!llvm::sys::fs::is_directory(outputFile, isDir) && isDir) {
-                llvm::errs() << "error: output file '" << outputFile << "' is a directory\n";
-                return 1;
-            }
-            llvm::sys::RemoveFileOnSignal(outputFile);
+    setSearchPath(searchPath);
+
+    if (outputFile.empty()) {
+        llvm::StringRef clayFileBasename = llvm::sys::path::stem(clayFile);
+        outputFile = string(clayFileBasename.begin(), clayFileBasename.end());
+
+        if (emitLLVM && emitAsm)
+            outputFile += ".ll";
+        else if (emitAsm)
+            outputFile += ".s";
+        else if (emitObject || emitLLVM)
+            outputFile += objExtensionForTarget(llvmTriple);
+        else if (sharedLib)
+            outputFile += sharedExtensionForTarget(llvmTriple);
+        else
+            outputFile += exeExtensionForTarget(llvmTriple);
+    }
+    if (!run) {
+        bool isDir;
+        if (!llvm::sys::fs::is_directory(outputFile, isDir) && isDir) {
+            llvm::errs() << "error: output file '" << outputFile
+                         << "' is a directory\n";
+            return 1;
         }
+        llvm::sys::RemoveFileOnSignal(outputFile);
+    }
 
-        if (generateDeps) {
-            if (run) {
-                llvm::errs() << "error: '-deps' can not be used together with '-e' or '-run'\n";
-                return 1;
-            }
-            if (dependenciesOutputFile.empty()) {
-                dependenciesOutputFile = outputFile;
-                dependenciesOutputFile += ".d";
-            }
+    if (generateDeps) {
+        if (run) {
+            llvm::errs() << "error: '-deps' can not be used together with '-e' "
+                            "or '-run'\n";
+            return 1;
         }
+        if (dependenciesOutputFile.empty()) {
+            dependenciesOutputFile = outputFile;
+            dependenciesOutputFile += ".d";
+        }
+    }
 
-        if (generateDeps) {
-            bool isDir;
-            if (!llvm::sys::fs::is_directory(dependenciesOutputFile, isDir) && isDir) {
-                llvm::errs() << "error: dependencies output file '" << dependenciesOutputFile << "' is a directory\n";
-                return 1;
-            }
-            llvm::sys::RemoveFileOnSignal(dependenciesOutputFile);
+    if (generateDeps) {
+        bool isDir;
+        if (!llvm::sys::fs::is_directory(dependenciesOutputFile, isDir) &&
+            isDir) {
+            llvm::errs() << "error: dependencies output file '"
+                         << dependenciesOutputFile << "' is a directory\n";
+            return 1;
         }
+        llvm::sys::RemoveFileOnSignal(dependenciesOutputFile);
+    }
 
-        HiResTimer loadTimer, compileTimer, optTimer, outputTimer;
+    HiResTimer loadTimer, compileTimer, optTimer, outputTimer;
 
-        //compiler
+    // compiler
 
-        loadTimer.start();
-        try {
-            initLoader();
+    loadTimer.start();
+    try {
+        initLoader();
 
-            ModulePtr m;
-            vector<string> sourceFiles;
-            if (!clayScript.empty()) {
-                string clayScriptSource;
-                clayScriptSource = clayScriptImports + "main() {\n" + clayScript + "}";
-                m = loadProgramSource("-e", clayScriptSource, verbose, repl);
-            } else if (generateDeps)
-                m = loadProgram(clayFile, &sourceFiles, verbose, repl);
-            else
-                m = loadProgram(clayFile, nullptr, verbose, repl);
+        ModulePtr m;
+        vector<string> sourceFiles;
+        if (!clayScript.empty()) {
+            string clayScriptSource;
+            clayScriptSource =
+                clayScriptImports + "main() {\n" + clayScript + "}";
+            m = loadProgramSource("-e", clayScriptSource, verbose, repl);
+        } else if (generateDeps)
+            m = loadProgram(clayFile, &sourceFiles, verbose, repl);
+        else
+            m = loadProgram(clayFile, nullptr, verbose, repl);
 
-            loadTimer.stop();
-            compileTimer.start();
-            codegenEntryPoints(m, codegenExternals);
-            compileTimer.stop();
+        loadTimer.stop();
+        compileTimer.start();
+        codegenEntryPoints(m, codegenExternals);
+        compileTimer.stop();
 
-            if (generateDeps) {
-                std::error_code ec;
+        if (generateDeps) {
+            std::error_code ec;
 
-                if (verbose) {
-                    llvm::errs() << "generating dependencies into " << dependenciesOutputFile << "\n";
-                }
+            if (verbose) {
+                llvm::errs() << "generating dependencies into "
+                             << dependenciesOutputFile << "\n";
+            }
 
-                llvm::raw_fd_ostream dependenciesOut(dependenciesOutputFile,
-                                                     ec,
-                                                     llvm::sys::fs::OF_None);
-                if (ec) {
-                    llvm::errs() << "error creating dependencies file: " << ec.message() << '\n';
-                    return 1;
-                }
-                dependenciesOut << outputFile << ": \\\n";
-                for (size_t i = 0; i < sourceFiles.size(); ++i) {
-                    dependenciesOut << "  " << sourceFiles[i];
-                    if (i < sourceFiles.size() - 1)
-                        dependenciesOut << " \\\n";
-                }
+            llvm::raw_fd_ostream dependenciesOut(dependenciesOutputFile, ec,
+                                                 llvm::sys::fs::OF_None);
+            if (ec) {
+                llvm::errs()
+                    << "error creating dependencies file: " << ec.message()
+                    << '\n';
+                return 1;
             }
+            dependenciesOut << outputFile << ": \\\n";
+            for (size_t i = 0; i < sourceFiles.size(); ++i) {
+                dependenciesOut << "  " << sourceFiles[i];
+                if (i < sourceFiles.size() - 1)
+                    dependenciesOut << " \\\n";
+            }
+        }
 
-            bool internalize = true;
-            if (debug || sharedLib || run || !codegenExternals)
-                internalize = false;
+        bool internalize = true;
+        if (debug || sharedLib || run || !codegenExternals)
+            internalize = false;
 
-            optTimer.start();
+        optTimer.start();
 
-            if (!repl) {
-                if (optLevel > 0)
-                    optimizeLLVM(llvmModule, optLevel, internalize);
+        if (!repl) {
+            if (optLevel > 0)
+                optimizeLLVM(llvmModule, optLevel, internalize);
+        }
+        optTimer.stop();
+
+        if (run) {
+            vector<string> runArgs;
+            runArgs.push_back(clayFile);
+            runModule(llvmModule, runArgs, envp, libSearchPath, libraries);
+        } else if (repl) {
+            // TODO: future me task
+            runInteractive(llvmModule, m);
+        } else if (emitLLVM || emitAsm || emitObject) {
+            std::error_code ec;
+
+            llvm::raw_fd_ostream out(outputFile, ec, llvm::sys::fs::OF_None);
+            if (ec) {
+                llvm::errs()
+                    << "error creating output file: " << ec.message() << '\n';
+                return 1;
             }
-            optTimer.stop();
-
-            if (run) {
-                vector<string> runArgs;
-                runArgs.push_back(clayFile);
-                runModule(llvmModule, runArgs, envp, libSearchPath, libraries);
-            } else if (repl) {
-                // TODO: future me task
-                runInteractive(llvmModule, m);
-            } else if (emitLLVM || emitAsm || emitObject) {
-                std::error_code ec;
-
-                llvm::raw_fd_ostream out(outputFile,
-                                         ec,
-                                         llvm::sys::fs::OF_None);
-                if (ec) {
-                    llvm::errs() << "error creating output file: " << ec.message() << '\n';
-                    return 1;
-                }
-                outputTimer.start();
-                if (emitLLVM)
-                    generateLLVM(llvmModule, emitAsm, &out);
-                else if (emitAsm || emitObject)
-                    generateAssembly(llvmModule, targetMachine, &out, emitObject);
-                outputTimer.stop();
-            } else {
-                bool result;
-                llvm::ErrorOr<std::string> clangPathOrErr = llvm::sys::findProgramByName("clang");
-                if (std::error_code ec = clangPathOrErr.getError()) {
-                    llvm::errs() << "error: unable to find clang on the path: " << ec.message() << "\n";
-                    return 1;
-                }
-                const std::string& clangPath = clangPathOrErr.get();
+            outputTimer.start();
+            if (emitLLVM)
+                generateLLVM(llvmModule, emitAsm, &out);
+            else if (emitAsm || emitObject)
+                generateAssembly(llvmModule, targetMachine, &out, emitObject);
+            outputTimer.stop();
+        } else {
+            bool result;
+            llvm::ErrorOr<std::string> clangPathOrErr =
+                llvm::sys::findProgramByName("clang");
+            if (std::error_code ec = clangPathOrErr.getError()) {
+                llvm::errs() << "error: unable to find clang on the path: "
+                             << ec.message() << "\n";
+                return 1;
+            }
+            const std::string &clangPath = clangPathOrErr.get();
 
-                vector<string> arguments;
+            vector<string> arguments;
 #ifdef __APPLE__
-                if (!arch.empty()) {
-                    arguments.emplace_back("-arch");
-                    arguments.push_back(arch);
-                }
+            if (!arch.empty()) {
+                arguments.emplace_back("-arch");
+                arguments.push_back(arch);
+            }
 #endif
-                if (!linkerFlags.empty())
-                    arguments.push_back("-Wl" + linkerFlags);
+            if (!linkerFlags.empty())
+                arguments.push_back("-Wl" + linkerFlags);
 #ifdef __APPLE__
-                copy(
-                    frameworkSearchPath.begin(),
-                    frameworkSearchPath.end(),
-                    back_inserter(arguments)
-                );
-                copy(frameworks.begin(), frameworks.end(), back_inserter(arguments));
+            copy(frameworkSearchPath.begin(), frameworkSearchPath.end(),
+                 back_inserter(arguments));
+            copy(frameworks.begin(), frameworks.end(),
+                 back_inserter(arguments));
 #endif
-                copy(
-                    libSearchPathArgs.begin(),
-                    libSearchPathArgs.end(),
-                    back_inserter(arguments)
-                );
-                copy(librariesArgs.begin(), librariesArgs.end(), back_inserter(arguments));
-
-                outputTimer.start();
-                result = generateBinary(llvmModule, targetMachine, outputFile, clangPath,
-                                        exceptions, sharedLib, debug, arguments, verbose);
-                outputTimer.stop();
-                if (!result)
-                    return 1;
-            }
-        } catch (const CompilerError &) {
-            return 1;
-        }
-        if (showTiming) {
-            llvm::errs() << "load time = " << static_cast<size_t>(loadTimer.elapsedMillis()) << " ms\n";
-            llvm::errs() << "compile time = " << static_cast<size_t>(compileTimer.elapsedMillis()) << " ms\n";
-            llvm::errs() << "optimization time = " << static_cast<size_t>(optTimer.elapsedMillis()) << " ms\n";
-            llvm::errs() << "codegen time = " << static_cast<size_t>(outputTimer.elapsedMillis()) << " ms\n";
-            llvm::errs().flush();
+            copy(libSearchPathArgs.begin(), libSearchPathArgs.end(),
+                 back_inserter(arguments));
+            copy(librariesArgs.begin(), librariesArgs.end(),
+                 back_inserter(arguments));
+
+            outputTimer.start();
+            result = generateBinary(llvmModule, targetMachine, outputFile,
+                                    clangPath, exceptions, sharedLib, debug,
+                                    arguments, verbose);
+            outputTimer.stop();
+            if (!result)
+                return 1;
         }
-
-        _exit(0);
+    } catch (const CompilerError &) {
+        return 1;
+    }
+    if (showTiming) {
+        llvm::errs() << "load time = "
+                     << static_cast<size_t>(loadTimer.elapsedMillis())
+                     << " ms\n";
+        llvm::errs() << "compile time = "
+                     << static_cast<size_t>(compileTimer.elapsedMillis())
+                     << " ms\n";
+        llvm::errs() << "optimization time = "
+                     << static_cast<size_t>(optTimer.elapsedMillis())
+                     << " ms\n";
+        llvm::errs() << "codegen time = "
+                     << static_cast<size_t>(outputTimer.elapsedMillis())
+                     << " ms\n";
+        llvm::errs().flush();
     }
+
+    _exit(0);
 }
+} // namespace clay
 
-int main(int argc, char **argv, char const *const*envp) {
+int main(int argc, char **argv, char const *const *envp) {
     return clay::parachute(clay::main2, argc, argv, envp);
 }
diff --git a/compiler/clay.hpp b/compiler/clay.hpp
index bde527a9..6c8147f4 100644
--- a/compiler/clay.hpp
+++ b/compiler/clay.hpp
@@ -5,68 +5,68 @@
 #define _SCL_SECURE_NO_WARNINGS
 #endif
 
-#include <string>
-#include <vector>
+#include <cassert>
 #include <map>
 #include <set>
-#include <cassert>
+#include <string>
+#include <vector>
 
 #ifdef _MSC_VER
 // LLVM headers spew warnings on MSVC
 #pragma warning(push)
-#pragma warning(disable: 4146 4244 4267 4355 4146 4800 4996)
+#pragma warning(disable : 4146 4244 4267 4355 4146 4800 4996)
 #endif
 
+#include <llvm/ADT/ArrayRef.h>
 #include <llvm/ADT/SmallString.h>
 #include <llvm/ADT/SmallVector.h>
 #include <llvm/ADT/StringMap.h>
 #include <llvm/ADT/StringRef.h>
 #include <llvm/AsmParser/Parser.h>
 #include <llvm/Bitcode/BitcodeWriter.h>
+#include <llvm/Bitcode/BitcodeWriterPass.h>
 #include <llvm/CodeGen/ValueTypes.h>
-#include <llvm/IR/DataLayout.h>
+#include <llvm/ExecutionEngine/ExecutionEngine.h>
+#include <llvm/ExecutionEngine/GenericValue.h>
+#include <llvm/ExecutionEngine/Orc/Core.h>
+#include <llvm/ExecutionEngine/Orc/ExecutionUtils.h>
+#include <llvm/ExecutionEngine/Orc/LLJIT.h>
+#include <llvm/ExecutionEngine/Orc/ThreadSafeModule.h>
+#include <llvm/IR/Attributes.h>
 #include <llvm/IR/DIBuilder.h>
+#include <llvm/IR/DataLayout.h>
 #include <llvm/IR/DebugInfoMetadata.h>
 #include <llvm/IR/Function.h>
-#include <llvm/IR/Type.h>
-#include <llvm/Support/Allocator.h>
-#include <llvm/Support/MemoryBuffer.h>
-#include <llvm/Transforms/Scalar/GVN.h>
 #include <llvm/IR/GlobalVariable.h>
+#include <llvm/IR/LegacyPassManager.h>
 #include <llvm/IR/Metadata.h>
+#include <llvm/IR/Module.h>
+#include <llvm/IR/PassManager.h>
+#include <llvm/IR/Type.h>
+#include <llvm/IR/Verifier.h>
+#include <llvm/IRPrinter/IRPrintingPasses.h>
+#include <llvm/MC/TargetRegistry.h>
+#include <llvm/Passes/OptimizationLevel.h>
+#include <llvm/Passes/PassBuilder.h>
+#include <llvm/Support/Allocator.h>
+#include <llvm/Support/AtomicOrdering.h>
+#include <llvm/Support/Error.h>
+#include <llvm/Support/ErrorOr.h>
 #include <llvm/Support/FileSystem.h>
+#include <llvm/Support/FileUtilities.h>
+#include <llvm/Support/FormattedStream.h>
+#include <llvm/Support/MemoryBuffer.h>
 #include <llvm/Support/Path.h>
 #include <llvm/Support/Program.h>
-#include <llvm/Support/ErrorOr.h>
 #include <llvm/Support/Signals.h>
+#include <llvm/Support/TargetSelect.h>
+#include <llvm/Support/raw_ostream.h>
+#include <llvm/Target/TargetMachine.h>
 #include <llvm/TargetParser/Host.h>
 #include <llvm/TargetParser/Triple.h>
-#include <llvm/Support/FileUtilities.h>
-#include <llvm/Target/TargetMachine.h>
-#include <llvm/IR/Verifier.h>
-#include <llvm/IR/Module.h>
-#include <llvm/IR/PassManager.h>
-#include <llvm/Passes/PassBuilder.h>
-#include <llvm/Passes/OptimizationLevel.h>
-#include <llvm/Support/FormattedStream.h>
-#include <llvm/Support/raw_ostream.h>
-#include <llvm/Support/Error.h>
-#include <llvm/ExecutionEngine/Orc/LLJIT.h>
-#include <llvm/ExecutionEngine/Orc/ThreadSafeModule.h>
 #include <llvm/Transforms/IPO/Internalize.h>
-#include <llvm/Bitcode/BitcodeWriterPass.h>
-#include <llvm/IR/LegacyPassManager.h>
-#include <llvm/ExecutionEngine/Orc/ExecutionUtils.h>
-#include <llvm/ADT/ArrayRef.h>
-#include <llvm/ExecutionEngine/Orc/Core.h>
 #include <llvm/Transforms/InstCombine/InstCombine.h>
-#include <llvm/IRPrinter/IRPrintingPasses.h>
-#include <llvm/Support/AtomicOrdering.h>
-#include <llvm/MC/TargetRegistry.h>
-#include <llvm/Support/TargetSelect.h>
-#include <llvm/ExecutionEngine/ExecutionEngine.h>
-#include <llvm/Support/AtomicOrdering.h>
-#include <llvm/IR/Attributes.h>
+#include <llvm/Transforms/Scalar/GVN.h>
 
 #include <complex>
 
@@ -77,31 +77,28 @@
 #include "refcounted.hpp"
 
 namespace clay {
-    template<bool Cond>
-    struct StaticAssertChecker;
-
-    template<>
-    struct StaticAssertChecker<true> {
-        typedef int type;
-    };
-
-    template<>
-    struct StaticAssertChecker<false> {
-    };
-
-#define _CLAY_CAT(a,b) a##b
-#define CLAY_CAT(a,b) _CLAY_CAT(a,b)
-
-#define CLAY_STATIC_ASSERT(cond) \
-    static const ::clay::StaticAssertChecker<(cond)>::type CLAY_CAT(static_assert_, __LINE__);
-
-    using std::string;
-    using std::vector;
-    using std::pair;
-    using std::make_pair;
-    using std::map;
-    using std::set;
-}
+template <bool Cond> struct StaticAssertChecker;
+
+template <> struct StaticAssertChecker<true> {
+    typedef int type;
+};
+
+template <> struct StaticAssertChecker<false> {};
+
+#define _CLAY_CAT(a, b) a##b
+#define CLAY_CAT(a, b) _CLAY_CAT(a, b)
+
+#define CLAY_STATIC_ASSERT(cond)                                               \
+    static const ::clay::StaticAssertChecker<(cond)>::type CLAY_CAT(           \
+        static_assert_, __LINE__);
+
+using std::make_pair;
+using std::map;
+using std::pair;
+using std::set;
+using std::string;
+using std::vector;
+} // namespace clay
 
 #ifdef _MSC_VER
 
@@ -114,34 +111,36 @@ namespace clay {
 #include <complex>
 
 namespace clay {
-    typedef std::complex<float> clay_cfloat;
-    typedef std::complex<double> clay_cdouble;
-    typedef std::complex<long double> clay_cldouble;
+typedef std::complex<float> clay_cfloat;
+typedef std::complex<double> clay_cdouble;
+typedef std::complex<long double> clay_cldouble;
 
-    template<typename T>
-    inline T clay_creal(std::complex<T> const &c) { return std::real(c); }
+template <typename T> inline T clay_creal(std::complex<T> const &c) {
+    return std::real(c);
+}
 
-    template<typename T>
-    inline T clay_cimag(std::complex<T> const &c) { return std::imag(c); }
+template <typename T> inline T clay_cimag(std::complex<T> const &c) {
+    return std::imag(c);
 }
+} // namespace clay
 
 #else
 
 #define CLAY_ALIGN(n) __attribute__((aligned(n)))
 
 namespace clay {
-    typedef std::complex<float> clay_cfloat;
-    typedef std::complex<double> clay_cdouble;
-    typedef std::complex<long double> clay_cldouble;
+typedef std::complex<float> clay_cfloat;
+typedef std::complex<double> clay_cdouble;
+typedef std::complex<long double> clay_cldouble;
 
-    inline float clay_creal(const clay_cfloat &c) { return c.real(); }
-    inline double clay_creal(const clay_cdouble &c) { return c.real(); }
-    inline long double clay_creal(const clay_cldouble &c) { return c.real(); }
+inline float clay_creal(const clay_cfloat &c) { return c.real(); }
+inline double clay_creal(const clay_cdouble &c) { return c.real(); }
+inline long double clay_creal(const clay_cldouble &c) { return c.real(); }
 
-    inline float clay_cimag(const clay_cfloat &c) { return c.imag(); }
-    inline double clay_cimag(const clay_cdouble &c) { return c.imag(); }
-    inline long double clay_cimag(const clay_cldouble &c) { return c.imag(); }
-}
+inline float clay_cimag(const clay_cfloat &c) { return c.imag(); }
+inline double clay_cimag(const clay_cdouble &c) { return c.imag(); }
+inline long double clay_cimag(const clay_cldouble &c) { return c.imag(); }
+} // namespace clay
 
 #endif
 
@@ -149,2741 +148,2394 @@ namespace clay {
 #define CLAY_COMPILER_VERSION "0.2git"
 
 namespace clay {
-    //
-    // container typedefs
-    //
-
-    typedef llvm::SmallString<260> PathString;
-
-    //
-    // Target-specific types
-    //
-    typedef int ptrdiff32_t;
-    typedef long long ptrdiff64_t;
-
-    typedef unsigned size32_t;
-    typedef unsigned long long size64_t;
-
-    //
-    // ObjectKind
-    //
-
-#define OBJECT_KIND_MAP(XX) \
-    XX(SOURCE) \
-    XX(LOCATION) \
-\
-    XX(IDENTIFIER) \
-    XX(DOTTED_NAME) \
-\
-    XX(EXPRESSION) \
-    XX(EXPR_LIST) \
-    XX(STATEMENT) \
-    XX(CASE_BLOCK) \
-    XX(CATCH) \
-\
-    XX(FORMAL_ARG) \
-    XX(RETURN_SPEC) \
-    XX(LLVM_CODE) \
-    XX(CODE) \
-\
-    XX(RECORD_DECL) \
-    XX(RECORD_BODY) \
-    XX(RECORD_FIELD) \
-    XX(VARIANT_DECL) \
-    XX(INSTANCE_DECL) \
-    XX(NEW_TYPE_DECL) \
-    XX(OVERLOAD) \
-    XX(PROCEDURE) \
-    XX(INTRINSIC) \
-    XX(ENUM_DECL) \
-    XX(ENUM_MEMBER) \
-    XX(GLOBAL_VARIABLE) \
-    XX(EXTERNAL_PROCEDURE) \
-    XX(EXTERNAL_ARG) \
-    XX(EXTERNAL_VARIABLE) \
-    XX(EVAL_TOPLEVEL) \
-\
-    XX(GLOBAL_ALIAS) \
-\
-    XX(IMPORT) \
-    XX(MODULE_DECLARATION) \
-    XX(MODULE) \
-\
-    XX(ENV) \
-\
-    XX(PRIM_OP) \
-\
-    XX(TYPE) \
-\
-    XX(PATTERN) \
-    XX(MULTI_PATTERN) \
-\
-    XX(VALUE_HOLDER) \
-    XX(MULTI_STATIC) \
-\
-    XX(PVALUE) \
-    XX(MULTI_PVALUE) \
-\
-    XX(EVALUE) \
-    XX(MULTI_EVALUE) \
-\
-    XX(CVALUE) \
-    XX(MULTI_CVALUE) \
-\
-    XX(DOCUMENTATION) \
-\
+//
+// container typedefs
+//
+
+typedef llvm::SmallString<260> PathString;
+
+//
+// Target-specific types
+//
+typedef int ptrdiff32_t;
+typedef long long ptrdiff64_t;
+
+typedef unsigned size32_t;
+typedef unsigned long long size64_t;
+
+//
+// ObjectKind
+//
+
+#define OBJECT_KIND_MAP(XX)                                                    \
+    XX(SOURCE)                                                                 \
+    XX(LOCATION)                                                               \
+                                                                               \
+    XX(IDENTIFIER)                                                             \
+    XX(DOTTED_NAME)                                                            \
+                                                                               \
+    XX(EXPRESSION)                                                             \
+    XX(EXPR_LIST)                                                              \
+    XX(STATEMENT)                                                              \
+    XX(CASE_BLOCK)                                                             \
+    XX(CATCH)                                                                  \
+                                                                               \
+    XX(FORMAL_ARG)                                                             \
+    XX(RETURN_SPEC)                                                            \
+    XX(LLVM_CODE)                                                              \
+    XX(CODE)                                                                   \
+                                                                               \
+    XX(RECORD_DECL)                                                            \
+    XX(RECORD_BODY)                                                            \
+    XX(RECORD_FIELD)                                                           \
+    XX(VARIANT_DECL)                                                           \
+    XX(INSTANCE_DECL)                                                          \
+    XX(NEW_TYPE_DECL)                                                          \
+    XX(OVERLOAD)                                                               \
+    XX(PROCEDURE)                                                              \
+    XX(INTRINSIC)                                                              \
+    XX(ENUM_DECL)                                                              \
+    XX(ENUM_MEMBER)                                                            \
+    XX(GLOBAL_VARIABLE)                                                        \
+    XX(EXTERNAL_PROCEDURE)                                                     \
+    XX(EXTERNAL_ARG)                                                           \
+    XX(EXTERNAL_VARIABLE)                                                      \
+    XX(EVAL_TOPLEVEL)                                                          \
+                                                                               \
+    XX(GLOBAL_ALIAS)                                                           \
+                                                                               \
+    XX(IMPORT)                                                                 \
+    XX(MODULE_DECLARATION)                                                     \
+    XX(MODULE)                                                                 \
+                                                                               \
+    XX(ENV)                                                                    \
+                                                                               \
+    XX(PRIM_OP)                                                                \
+                                                                               \
+    XX(TYPE)                                                                   \
+                                                                               \
+    XX(PATTERN)                                                                \
+    XX(MULTI_PATTERN)                                                          \
+                                                                               \
+    XX(VALUE_HOLDER)                                                           \
+    XX(MULTI_STATIC)                                                           \
+                                                                               \
+    XX(PVALUE)                                                                 \
+    XX(MULTI_PVALUE)                                                           \
+                                                                               \
+    XX(EVALUE)                                                                 \
+    XX(MULTI_EVALUE)                                                           \
+                                                                               \
+    XX(CVALUE)                                                                 \
+    XX(MULTI_CVALUE)                                                           \
+                                                                               \
+    XX(DOCUMENTATION)                                                          \
+                                                                               \
     XX(STATIC_ASSERT_TOP_LEVEL)
 
 #define OBJECT_KIND_GEN(e) e,
 
-    enum ObjectKind {
-        OBJECT_KIND_MAP(OBJECT_KIND_GEN)
-    };
+enum ObjectKind { OBJECT_KIND_MAP(OBJECT_KIND_GEN) };
 #undef OBJECT_KIND_GEN
 
-    llvm::raw_ostream &operator<<(llvm::raw_ostream &os, ObjectKind);
+llvm::raw_ostream &operator<<(llvm::raw_ostream &os, ObjectKind);
+
+//
+// Object
+//
+
+struct Object : public RefCounted {
+    const ObjectKind objKind;
+
+    Object(ObjectKind objKind) : objKind(objKind) {}
+
+    virtual ~Object() {}
+
+    // print to stderr, for debugging
+    void print() const;
+
+    // use only in debugger
+    std::string toString() const;
+};
+
+typedef Pointer<Object> ObjectPtr;
+
+//
+// forwards
+//
+
+struct Source;
+
+struct ANode;
+struct Identifier;
+struct DottedName;
+
+struct Expr;
+struct BoolLiteral;
+struct IntLiteral;
+struct FloatLiteral;
+struct CharLiteral;
+struct StringLiteral;
+struct NameRef;
+struct FILEExpr;
+struct LINEExpr;
+struct COLUMNExpr;
+struct ARGExpr;
+struct Tuple;
+struct Paren;
+struct Indexing;
+struct Call;
+struct FieldRef;
+struct StaticIndexing;
+struct VariadicOp;
+struct And;
+struct Or;
+struct Lambda;
+struct Unpack;
+struct StaticExpr;
+struct DispatchExpr;
+struct ForeignExpr;
+struct ObjectExpr;
+struct EvalExpr;
+
+struct ExprList;
+
+struct Statement;
+struct Block;
+struct Label;
+struct Binding;
+struct Assignment;
+struct InitAssignment;
+struct VariadicAssignment;
+struct Goto;
+struct Switch;
+struct CaseBlock;
+struct Return;
+struct If;
+struct ExprStatement;
+struct While;
+struct Break;
+struct Continue;
+struct For;
+struct ForeignStatement;
+struct Try;
+struct Catch;
+struct Throw;
+struct StaticFor;
+struct Finally;
+struct OnError;
+struct Unreachable;
+struct EvalStatement;
+struct StaticAssertStatement;
+
+struct FormalArg;
+struct ReturnSpec;
+struct LLVMCode;
+struct Code;
+
+struct TopLevelItem;
+struct RecordDecl;
+struct RecordBody;
+struct RecordField;
+struct VariantDecl;
+struct InstanceDecl;
+struct NewTypeDecl;
+struct Overload;
+struct Procedure;
+struct IntrinsicSymbol;
+struct EnumDecl;
+struct EnumMember;
+struct GlobalVariable;
+struct GVarInstance;
+struct ExternalProcedure;
+struct ExternalArg;
+struct ExternalVariable;
+struct EvalTopLevel;
+struct StaticAssertTopLevel;
+struct Documentation;
+
+struct GlobalAlias;
+
+struct Import;
+struct ImportModule;
+struct ImportStar;
+struct ImportMembers;
+struct Module;
+struct ModuleDeclaration;
+
+struct Env;
+
+struct PrimOp;
+
+struct Type;
+struct BoolType;
+struct IntegerType;
+struct FloatType;
+struct ComplexType;
+struct ArrayType;
+struct VecType;
+struct TupleType;
+struct UnionType;
+struct PointerType;
+struct CodePointerType;
+struct CCodePointerType;
+struct RecordType;
+struct VariantType;
+struct StaticType;
+struct EnumType;
+struct NewType;
+
+struct Pattern;
+struct PatternCell;
+struct PatternStruct;
+
+struct MultiPattern;
+struct MultiPatternCell;
+struct MultiPatternList;
+
+struct ValueHolder;
+struct MultiStatic;
+
+struct PValue;
+struct MultiPValue;
+
+struct EValue;
+struct MultiEValue;
+
+struct CValue;
+struct MultiCValue;
+
+struct ObjectTable;
+
+struct ValueStackEntry;
+
+struct MatchResult;
+struct MatchFailureError;
+
+//
+// Pointer typedefs
+//
+
+typedef Pointer<Source> SourcePtr;
+
+typedef Pointer<ANode> ANodePtr;
+typedef Pointer<Identifier> IdentifierPtr;
+typedef Pointer<DottedName> DottedNamePtr;
+
+typedef Pointer<Expr> ExprPtr;
+typedef Pointer<BoolLiteral> BoolLiteralPtr;
+typedef Pointer<IntLiteral> IntLiteralPtr;
+typedef Pointer<FloatLiteral> FloatLiteralPtr;
+typedef Pointer<CharLiteral> CharLiteralPtr;
+typedef Pointer<StringLiteral> StringLiteralPtr;
+typedef Pointer<NameRef> NameRefPtr;
+typedef Pointer<FILEExpr> FILEExprPtr;
+typedef Pointer<LINEExpr> LINEExprPtr;
+typedef Pointer<COLUMNExpr> COLUMNExprPtr;
+typedef Pointer<ARGExpr> ARGExprPtr;
+typedef Pointer<Tuple> TuplePtr;
+typedef Pointer<Paren> ParenPtr;
+typedef Pointer<Indexing> IndexingPtr;
+typedef Pointer<Call> CallPtr;
+typedef Pointer<FieldRef> FieldRefPtr;
+typedef Pointer<StaticIndexing> StaticIndexingPtr;
+typedef Pointer<VariadicOp> VariadicOpPtr;
+typedef Pointer<And> AndPtr;
+typedef Pointer<Or> OrPtr;
+typedef Pointer<Lambda> LambdaPtr;
+typedef Pointer<Unpack> UnpackPtr;
+typedef Pointer<StaticExpr> StaticExprPtr;
+typedef Pointer<DispatchExpr> DispatchExprPtr;
+typedef Pointer<ForeignExpr> ForeignExprPtr;
+typedef Pointer<ObjectExpr> ObjectExprPtr;
+typedef Pointer<EvalExpr> EvalExprPtr;
+
+typedef Pointer<ExprList> ExprListPtr;
+
+typedef Pointer<Statement> StatementPtr;
+typedef Pointer<Block> BlockPtr;
+typedef Pointer<Label> LabelPtr;
+typedef Pointer<Binding> BindingPtr;
+typedef Pointer<Assignment> AssignmentPtr;
+typedef Pointer<InitAssignment> InitAssignmentPtr;
+typedef Pointer<VariadicAssignment> VariadicAssignmentPtr;
+typedef Pointer<Goto> GotoPtr;
+typedef Pointer<Switch> SwitchPtr;
+typedef Pointer<CaseBlock> CaseBlockPtr;
+typedef Pointer<Return> ReturnPtr;
+typedef Pointer<If> IfPtr;
+typedef Pointer<ExprStatement> ExprStatementPtr;
+typedef Pointer<While> WhilePtr;
+typedef Pointer<Break> BreakPtr;
+typedef Pointer<Continue> ContinuePtr;
+typedef Pointer<For> ForPtr;
+typedef Pointer<ForeignStatement> ForeignStatementPtr;
+typedef Pointer<Try> TryPtr;
+typedef Pointer<Catch> CatchPtr;
+typedef Pointer<Throw> ThrowPtr;
+typedef Pointer<StaticFor> StaticForPtr;
+typedef Pointer<Finally> FinallyPtr;
+typedef Pointer<OnError> OnErrorPtr;
+typedef Pointer<Unreachable> UnreachablePtr;
+typedef Pointer<EvalStatement> EvalStatementPtr;
+typedef Pointer<StaticAssertStatement> StaticAssertStatementPtr;
+
+typedef Pointer<FormalArg> FormalArgPtr;
+typedef Pointer<ReturnSpec> ReturnSpecPtr;
+typedef Pointer<LLVMCode> LLVMCodePtr;
+typedef Pointer<Code> CodePtr;
+
+typedef Pointer<TopLevelItem> TopLevelItemPtr;
+typedef Pointer<RecordDecl> RecordDeclPtr;
+typedef Pointer<RecordBody> RecordBodyPtr;
+typedef Pointer<RecordField> RecordFieldPtr;
+typedef Pointer<VariantDecl> VariantDeclPtr;
+typedef Pointer<InstanceDecl> InstanceDeclPtr;
+typedef Pointer<NewTypeDecl> NewTypeDeclPtr;
+typedef Pointer<Overload> OverloadPtr;
+typedef Pointer<Procedure> ProcedurePtr;
+typedef Pointer<IntrinsicSymbol> IntrinsicPtr;
+typedef Pointer<EnumDecl> EnumDeclPtr;
+typedef Pointer<EnumMember> EnumMemberPtr;
+typedef Pointer<GlobalVariable> GlobalVariablePtr;
+typedef Pointer<GVarInstance> GVarInstancePtr;
+typedef Pointer<ExternalProcedure> ExternalProcedurePtr;
+typedef Pointer<ExternalArg> ExternalArgPtr;
+typedef Pointer<ExternalVariable> ExternalVariablePtr;
+typedef Pointer<EvalTopLevel> EvalTopLevelPtr;
+typedef Pointer<StaticAssertTopLevel> StaticAssertTopLevelPtr;
+typedef Pointer<Documentation> DocumentationPtr;
+
+typedef Pointer<GlobalAlias> GlobalAliasPtr;
+
+typedef Pointer<Import> ImportPtr;
+typedef Pointer<ImportModule> ImportModulePtr;
+typedef Pointer<ImportStar> ImportStarPtr;
+typedef Pointer<ImportMembers> ImportMembersPtr;
+typedef Pointer<Module> ModulePtr;
+typedef Pointer<ModuleDeclaration> ModuleDeclarationPtr;
+
+typedef Pointer<Env> EnvPtr;
+
+typedef Pointer<PrimOp> PrimOpPtr;
+
+typedef Pointer<Type> TypePtr;
+typedef Pointer<BoolType> BoolTypePtr;
+typedef Pointer<IntegerType> IntegerTypePtr;
+typedef Pointer<FloatType> FloatTypePtr;
+typedef Pointer<ComplexType> ComplexTypePtr;
+typedef Pointer<ArrayType> ArrayTypePtr;
+typedef Pointer<VecType> VecTypePtr;
+typedef Pointer<TupleType> TupleTypePtr;
+typedef Pointer<UnionType> UnionTypePtr;
+typedef Pointer<PointerType> PointerTypePtr;
+typedef Pointer<CodePointerType> CodePointerTypePtr;
+typedef Pointer<CCodePointerType> CCodePointerTypePtr;
+typedef Pointer<RecordType> RecordTypePtr;
+typedef Pointer<VariantType> VariantTypePtr;
+typedef Pointer<StaticType> StaticTypePtr;
+typedef Pointer<EnumType> EnumTypePtr;
+typedef Pointer<NewType> NewTypePtr;
+
+typedef Pointer<Pattern> PatternPtr;
+typedef Pointer<PatternCell> PatternCellPtr;
+typedef Pointer<PatternStruct> PatternStructPtr;
+typedef Pointer<MultiPattern> MultiPatternPtr;
+typedef Pointer<MultiPatternCell> MultiPatternCellPtr;
+typedef Pointer<MultiPatternList> MultiPatternListPtr;
+
+typedef Pointer<ValueHolder> ValueHolderPtr;
+typedef Pointer<MultiStatic> MultiStaticPtr;
+
+typedef Pointer<PValue> PValuePtr;
+typedef Pointer<MultiPValue> MultiPValuePtr;
+
+typedef Pointer<EValue> EValuePtr;
+typedef Pointer<MultiEValue> MultiEValuePtr;
+
+typedef Pointer<CValue> CValuePtr;
+typedef Pointer<MultiCValue> MultiCValuePtr;
+
+typedef Pointer<ObjectTable> ObjectTablePtr;
+
+typedef Pointer<MatchResult> MatchResultPtr;
+
+//
+// Source, Location
+//
+
+struct Location;
+
+struct Source : public Object {
+    string fileName;
+    std::unique_ptr<llvm::MemoryBuffer> buffer;
+    llvm::TrackingVH<llvm::MDNode> debugInfo;
 
-    //
-    // Object
-    //
+    Source(llvm::StringRef fileName);
 
-    struct Object : public RefCounted {
-        const ObjectKind objKind;
+    Source(llvm::StringRef lineOfCode, int dummy);
 
-        Object(ObjectKind objKind)
-            : objKind(objKind) {
-        }
+    Source(llvm::StringRef fileName, llvm::MemoryBuffer *buffer)
+        : Object(SOURCE), fileName(fileName), buffer(buffer) {}
 
-        virtual ~Object() {
-        }
+    [[nodiscard]] const char *data() const { return buffer->getBufferStart(); }
+    [[nodiscard]] const char *endData() const { return buffer->getBufferEnd(); }
+    [[nodiscard]] size_t size() const { return buffer->getBufferSize(); }
 
-        // print to stderr, for debugging
-        void print() const;
-
-        // use only in debugger
-        std::string toString() const;
-    };
-
-    typedef Pointer<Object> ObjectPtr;
-
-    //
-    // forwards
-    //
-
-    struct Source;
-
-    struct ANode;
-    struct Identifier;
-    struct DottedName;
-
-    struct Expr;
-    struct BoolLiteral;
-    struct IntLiteral;
-    struct FloatLiteral;
-    struct CharLiteral;
-    struct StringLiteral;
-    struct NameRef;
-    struct FILEExpr;
-    struct LINEExpr;
-    struct COLUMNExpr;
-    struct ARGExpr;
-    struct Tuple;
-    struct Paren;
-    struct Indexing;
-    struct Call;
-    struct FieldRef;
-    struct StaticIndexing;
-    struct VariadicOp;
-    struct And;
-    struct Or;
-    struct Lambda;
-    struct Unpack;
-    struct StaticExpr;
-    struct DispatchExpr;
-    struct ForeignExpr;
-    struct ObjectExpr;
-    struct EvalExpr;
-
-    struct ExprList;
-
-    struct Statement;
-    struct Block;
-    struct Label;
-    struct Binding;
-    struct Assignment;
-    struct InitAssignment;
-    struct VariadicAssignment;
-    struct Goto;
-    struct Switch;
-    struct CaseBlock;
-    struct Return;
-    struct If;
-    struct ExprStatement;
-    struct While;
-    struct Break;
-    struct Continue;
-    struct For;
-    struct ForeignStatement;
-    struct Try;
-    struct Catch;
-    struct Throw;
-    struct StaticFor;
-    struct Finally;
-    struct OnError;
-    struct Unreachable;
-    struct EvalStatement;
-    struct StaticAssertStatement;
-
-    struct FormalArg;
-    struct ReturnSpec;
-    struct LLVMCode;
-    struct Code;
-
-    struct TopLevelItem;
-    struct RecordDecl;
-    struct RecordBody;
-    struct RecordField;
-    struct VariantDecl;
-    struct InstanceDecl;
-    struct NewTypeDecl;
-    struct Overload;
-    struct Procedure;
-    struct IntrinsicSymbol;
-    struct EnumDecl;
-    struct EnumMember;
-    struct GlobalVariable;
-    struct GVarInstance;
-    struct ExternalProcedure;
-    struct ExternalArg;
-    struct ExternalVariable;
-    struct EvalTopLevel;
-    struct StaticAssertTopLevel;
-    struct Documentation;
-
-    struct GlobalAlias;
-
-    struct Import;
-    struct ImportModule;
-    struct ImportStar;
-    struct ImportMembers;
-    struct Module;
-    struct ModuleDeclaration;
-
-    struct Env;
-
-    struct PrimOp;
-
-    struct Type;
-    struct BoolType;
-    struct IntegerType;
-    struct FloatType;
-    struct ComplexType;
-    struct ArrayType;
-    struct VecType;
-    struct TupleType;
-    struct UnionType;
-    struct PointerType;
-    struct CodePointerType;
-    struct CCodePointerType;
-    struct RecordType;
-    struct VariantType;
-    struct StaticType;
-    struct EnumType;
-    struct NewType;
-
-    struct Pattern;
-    struct PatternCell;
-    struct PatternStruct;
-
-    struct MultiPattern;
-    struct MultiPatternCell;
-    struct MultiPatternList;
-
-    struct ValueHolder;
-    struct MultiStatic;
-
-    struct PValue;
-    struct MultiPValue;
-
-    struct EValue;
-    struct MultiEValue;
-
-    struct CValue;
-    struct MultiCValue;
-
-    struct ObjectTable;
-
-    struct ValueStackEntry;
-
-    struct MatchResult;
-    struct MatchFailureError;
-
-    //
-    // Pointer typedefs
-    //
-
-    typedef Pointer<Source> SourcePtr;
-
-    typedef Pointer<ANode> ANodePtr;
-    typedef Pointer<Identifier> IdentifierPtr;
-    typedef Pointer<DottedName> DottedNamePtr;
-
-    typedef Pointer<Expr> ExprPtr;
-    typedef Pointer<BoolLiteral> BoolLiteralPtr;
-    typedef Pointer<IntLiteral> IntLiteralPtr;
-    typedef Pointer<FloatLiteral> FloatLiteralPtr;
-    typedef Pointer<CharLiteral> CharLiteralPtr;
-    typedef Pointer<StringLiteral> StringLiteralPtr;
-    typedef Pointer<NameRef> NameRefPtr;
-    typedef Pointer<FILEExpr> FILEExprPtr;
-    typedef Pointer<LINEExpr> LINEExprPtr;
-    typedef Pointer<COLUMNExpr> COLUMNExprPtr;
-    typedef Pointer<ARGExpr> ARGExprPtr;
-    typedef Pointer<Tuple> TuplePtr;
-    typedef Pointer<Paren> ParenPtr;
-    typedef Pointer<Indexing> IndexingPtr;
-    typedef Pointer<Call> CallPtr;
-    typedef Pointer<FieldRef> FieldRefPtr;
-    typedef Pointer<StaticIndexing> StaticIndexingPtr;
-    typedef Pointer<VariadicOp> VariadicOpPtr;
-    typedef Pointer<And> AndPtr;
-    typedef Pointer<Or> OrPtr;
-    typedef Pointer<Lambda> LambdaPtr;
-    typedef Pointer<Unpack> UnpackPtr;
-    typedef Pointer<StaticExpr> StaticExprPtr;
-    typedef Pointer<DispatchExpr> DispatchExprPtr;
-    typedef Pointer<ForeignExpr> ForeignExprPtr;
-    typedef Pointer<ObjectExpr> ObjectExprPtr;
-    typedef Pointer<EvalExpr> EvalExprPtr;
-
-    typedef Pointer<ExprList> ExprListPtr;
-
-    typedef Pointer<Statement> StatementPtr;
-    typedef Pointer<Block> BlockPtr;
-    typedef Pointer<Label> LabelPtr;
-    typedef Pointer<Binding> BindingPtr;
-    typedef Pointer<Assignment> AssignmentPtr;
-    typedef Pointer<InitAssignment> InitAssignmentPtr;
-    typedef Pointer<VariadicAssignment> VariadicAssignmentPtr;
-    typedef Pointer<Goto> GotoPtr;
-    typedef Pointer<Switch> SwitchPtr;
-    typedef Pointer<CaseBlock> CaseBlockPtr;
-    typedef Pointer<Return> ReturnPtr;
-    typedef Pointer<If> IfPtr;
-    typedef Pointer<ExprStatement> ExprStatementPtr;
-    typedef Pointer<While> WhilePtr;
-    typedef Pointer<Break> BreakPtr;
-    typedef Pointer<Continue> ContinuePtr;
-    typedef Pointer<For> ForPtr;
-    typedef Pointer<ForeignStatement> ForeignStatementPtr;
-    typedef Pointer<Try> TryPtr;
-    typedef Pointer<Catch> CatchPtr;
-    typedef Pointer<Throw> ThrowPtr;
-    typedef Pointer<StaticFor> StaticForPtr;
-    typedef Pointer<Finally> FinallyPtr;
-    typedef Pointer<OnError> OnErrorPtr;
-    typedef Pointer<Unreachable> UnreachablePtr;
-    typedef Pointer<EvalStatement> EvalStatementPtr;
-    typedef Pointer<StaticAssertStatement> StaticAssertStatementPtr;
-
-    typedef Pointer<FormalArg> FormalArgPtr;
-    typedef Pointer<ReturnSpec> ReturnSpecPtr;
-    typedef Pointer<LLVMCode> LLVMCodePtr;
-    typedef Pointer<Code> CodePtr;
-
-    typedef Pointer<TopLevelItem> TopLevelItemPtr;
-    typedef Pointer<RecordDecl> RecordDeclPtr;
-    typedef Pointer<RecordBody> RecordBodyPtr;
-    typedef Pointer<RecordField> RecordFieldPtr;
-    typedef Pointer<VariantDecl> VariantDeclPtr;
-    typedef Pointer<InstanceDecl> InstanceDeclPtr;
-    typedef Pointer<NewTypeDecl> NewTypeDeclPtr;
-    typedef Pointer<Overload> OverloadPtr;
-    typedef Pointer<Procedure> ProcedurePtr;
-    typedef Pointer<IntrinsicSymbol> IntrinsicPtr;
-    typedef Pointer<EnumDecl> EnumDeclPtr;
-    typedef Pointer<EnumMember> EnumMemberPtr;
-    typedef Pointer<GlobalVariable> GlobalVariablePtr;
-    typedef Pointer<GVarInstance> GVarInstancePtr;
-    typedef Pointer<ExternalProcedure> ExternalProcedurePtr;
-    typedef Pointer<ExternalArg> ExternalArgPtr;
-    typedef Pointer<ExternalVariable> ExternalVariablePtr;
-    typedef Pointer<EvalTopLevel> EvalTopLevelPtr;
-    typedef Pointer<StaticAssertTopLevel> StaticAssertTopLevelPtr;
-    typedef Pointer<Documentation> DocumentationPtr;
-
-    typedef Pointer<GlobalAlias> GlobalAliasPtr;
-
-    typedef Pointer<Import> ImportPtr;
-    typedef Pointer<ImportModule> ImportModulePtr;
-    typedef Pointer<ImportStar> ImportStarPtr;
-    typedef Pointer<ImportMembers> ImportMembersPtr;
-    typedef Pointer<Module> ModulePtr;
-    typedef Pointer<ModuleDeclaration> ModuleDeclarationPtr;
-
-    typedef Pointer<Env> EnvPtr;
-
-    typedef Pointer<PrimOp> PrimOpPtr;
-
-    typedef Pointer<Type> TypePtr;
-    typedef Pointer<BoolType> BoolTypePtr;
-    typedef Pointer<IntegerType> IntegerTypePtr;
-    typedef Pointer<FloatType> FloatTypePtr;
-    typedef Pointer<ComplexType> ComplexTypePtr;
-    typedef Pointer<ArrayType> ArrayTypePtr;
-    typedef Pointer<VecType> VecTypePtr;
-    typedef Pointer<TupleType> TupleTypePtr;
-    typedef Pointer<UnionType> UnionTypePtr;
-    typedef Pointer<PointerType> PointerTypePtr;
-    typedef Pointer<CodePointerType> CodePointerTypePtr;
-    typedef Pointer<CCodePointerType> CCodePointerTypePtr;
-    typedef Pointer<RecordType> RecordTypePtr;
-    typedef Pointer<VariantType> VariantTypePtr;
-    typedef Pointer<StaticType> StaticTypePtr;
-    typedef Pointer<EnumType> EnumTypePtr;
-    typedef Pointer<NewType> NewTypePtr;
-
-    typedef Pointer<Pattern> PatternPtr;
-    typedef Pointer<PatternCell> PatternCellPtr;
-    typedef Pointer<PatternStruct> PatternStructPtr;
-    typedef Pointer<MultiPattern> MultiPatternPtr;
-    typedef Pointer<MultiPatternCell> MultiPatternCellPtr;
-    typedef Pointer<MultiPatternList> MultiPatternListPtr;
-
-    typedef Pointer<ValueHolder> ValueHolderPtr;
-    typedef Pointer<MultiStatic> MultiStaticPtr;
-
-    typedef Pointer<PValue> PValuePtr;
-    typedef Pointer<MultiPValue> MultiPValuePtr;
-
-    typedef Pointer<EValue> EValuePtr;
-    typedef Pointer<MultiEValue> MultiEValuePtr;
-
-    typedef Pointer<CValue> CValuePtr;
-    typedef Pointer<MultiCValue> MultiCValuePtr;
-
-    typedef Pointer<ObjectTable> ObjectTablePtr;
-
-    typedef Pointer<MatchResult> MatchResultPtr;
-
-    //
-    // Source, Location
-    //
-
-    struct Location;
-
-    struct Source : public Object {
-        string fileName;
-        std::unique_ptr<llvm::MemoryBuffer> buffer;
-        llvm::TrackingVH<llvm::MDNode> debugInfo;
-
-        Source(llvm::StringRef fileName);
-
-        Source(llvm::StringRef lineOfCode, int dummy);
-
-        Source(llvm::StringRef fileName, llvm::MemoryBuffer *buffer)
-                : Object(SOURCE), fileName(fileName), buffer(buffer) {
-        }
-
-        [[nodiscard]] const char *data() const { return buffer->getBufferStart(); }
-        [[nodiscard]] const char *endData() const { return buffer->getBufferEnd(); }
-        [[nodiscard]] size_t size() const { return buffer->getBufferSize(); }
-
-        [[nodiscard]] llvm::DIFile *getDebugInfo() const {
-            // TODO: implement this...
-        }
-    };
-
-    struct Location {
-        SourcePtr source;
-        unsigned offset;
+    [[nodiscard]] llvm::DIFile *getDebugInfo() const { return nullptr; }
+};
 
-        Location()
-            : source(nullptr), offset(0) {
-        }
+struct Location {
+    SourcePtr source;
+    unsigned offset;
 
-        Location(const SourcePtr &source, unsigned offset)
-            : source(source), offset(offset) {
-        }
+    Location() : source(nullptr), offset(0) {}
 
-        bool ok() const { return source != nullptr; }
-    };
+    Location(const SourcePtr &source, unsigned offset)
+        : source(source), offset(offset) {}
 
-    //
-    // error module
-    //
+    bool ok() const { return source != nullptr; }
+};
 
-    struct CompileContextEntry {
-        vector<ObjectPtr> params;
-        vector<unsigned> dispatchIndices;
+//
+// error module
+//
 
-        Location location;
+struct CompileContextEntry {
+    vector<ObjectPtr> params;
+    vector<unsigned> dispatchIndices;
 
-        ObjectPtr callable;
+    Location location;
 
-        bool hasParams: 1;
+    ObjectPtr callable;
 
-        CompileContextEntry(ObjectPtr callable)
-            : callable(callable), hasParams(false) {
-        }
+    bool hasParams : 1;
 
-        CompileContextEntry(ObjectPtr callable, llvm::ArrayRef<ObjectPtr> params)
-            : params(params), callable(callable), hasParams(true) {
-        }
+    CompileContextEntry(ObjectPtr callable)
+        : callable(callable), hasParams(false) {}
 
-        CompileContextEntry(ObjectPtr callable,
-                            llvm::ArrayRef<ObjectPtr> params,
-                            llvm::ArrayRef<unsigned> dispatchIndices)
-            : params(params), dispatchIndices(dispatchIndices), callable(callable), hasParams(true) {
-        }
-    };
+    CompileContextEntry(ObjectPtr callable, llvm::ArrayRef<ObjectPtr> params)
+        : params(params), callable(callable), hasParams(true) {}
 
-    void pushCompileContext(ObjectPtr obj);
+    CompileContextEntry(ObjectPtr callable, llvm::ArrayRef<ObjectPtr> params,
+                        llvm::ArrayRef<unsigned> dispatchIndices)
+        : params(params), dispatchIndices(dispatchIndices), callable(callable),
+          hasParams(true) {}
+};
 
-    void pushCompileContext(ObjectPtr obj, llvm::ArrayRef<ObjectPtr> params);
+void pushCompileContext(ObjectPtr obj);
 
-    void pushCompileContext(ObjectPtr obj,
-                            llvm::ArrayRef<ObjectPtr> params,
-                            llvm::ArrayRef<unsigned> dispatchIndices);
+void pushCompileContext(ObjectPtr obj, llvm::ArrayRef<ObjectPtr> params);
 
-    void popCompileContext();
+void pushCompileContext(ObjectPtr obj, llvm::ArrayRef<ObjectPtr> params,
+                        llvm::ArrayRef<unsigned> dispatchIndices);
 
-    vector<CompileContextEntry> getCompileContext();
+void popCompileContext();
 
-    void setCompileContext(llvm::ArrayRef<CompileContextEntry> x);
+vector<CompileContextEntry> getCompileContext();
 
-    struct PVData;
+void setCompileContext(llvm::ArrayRef<CompileContextEntry> x);
 
-    struct CompileContextPusher {
-        CompileContextPusher(const ObjectPtr &obj) {
-            pushCompileContext(obj);
-        }
+struct PVData;
 
-        CompileContextPusher(const ObjectPtr &obj, llvm::ArrayRef<ObjectPtr> params) {
-            pushCompileContext(obj, params);
-        }
+struct CompileContextPusher {
+    CompileContextPusher(const ObjectPtr &obj) { pushCompileContext(obj); }
 
-        CompileContextPusher(
-            ObjectPtr obj,
-            llvm::ArrayRef<PVData> params,
-            llvm::ArrayRef<unsigned> dispatchIndices = llvm::ArrayRef<unsigned>());
+    CompileContextPusher(const ObjectPtr &obj,
+                         llvm::ArrayRef<ObjectPtr> params) {
+        pushCompileContext(obj, params);
+    }
 
-        ~CompileContextPusher() {
-            popCompileContext();
-        }
-    };
+    CompileContextPusher(
+        ObjectPtr obj, llvm::ArrayRef<PVData> params,
+        llvm::ArrayRef<unsigned> dispatchIndices = llvm::ArrayRef<unsigned>());
 
-    void pushLocation(Location const &location);
+    ~CompileContextPusher() { popCompileContext(); }
+};
 
-    void popLocation();
+void pushLocation(Location const &location);
 
-    Location topLocation();
+void popLocation();
 
-    struct LocationContext {
-        Location loc;
+Location topLocation();
 
-        LocationContext(Location const &loc)
-            : loc(loc) {
-            if (loc.ok()) pushLocation(loc);
-        }
+struct LocationContext {
+    Location loc;
 
-        ~LocationContext() {
-            if (loc.ok())
-                popLocation();
-        }
+    LocationContext(Location const &loc) : loc(loc) {
+        if (loc.ok())
+            pushLocation(loc);
+    }
 
-    private :
-        LocationContext(const LocationContext &) {
-        }
+    ~LocationContext() {
+        if (loc.ok())
+            popLocation();
+    }
 
-        void operator=(const LocationContext &) {
-        }
-    };
+  private:
+    LocationContext(const LocationContext &) {}
 
-    void getLineCol(Location const &location,
-                    unsigned &line,
-                    unsigned &column,
-                    unsigned &tabColumn);
+    void operator=(const LocationContext &) {}
+};
 
-    llvm::DIFile *getDebugLineCol(Location const &location, unsigned &line, unsigned &column);
+void getLineCol(Location const &location, unsigned &line, unsigned &column,
+                unsigned &tabColumn);
 
-    void printFileLineCol(llvm::raw_ostream &out, Location const &location);
+llvm::DIFile *getDebugLineCol(Location const &location, unsigned &line,
+                              unsigned &column);
 
-    void invalidStaticObjectError(ObjectPtr obj);
+void printFileLineCol(llvm::raw_ostream &out, Location const &location);
 
-    void argumentInvalidStaticObjectError(unsigned index, ObjectPtr obj);
+void invalidStaticObjectError(ObjectPtr obj);
 
-    struct DebugPrinter {
-        static int indent;
-        const ObjectPtr obj;
+void argumentInvalidStaticObjectError(unsigned index, ObjectPtr obj);
 
-        DebugPrinter(ObjectPtr obj);
+struct DebugPrinter {
+    static int indent;
+    const ObjectPtr obj;
 
-        ~DebugPrinter();
-    };
+    DebugPrinter(ObjectPtr obj);
 
-    extern "C" void displayCompileContext();
+    ~DebugPrinter();
+};
 
-    //
-    // AST
-    //
+extern "C" void displayCompileContext();
 
-    static llvm::BumpPtrAllocator *ANodeAllocator = new llvm::BumpPtrAllocator();
+//
+// AST
+//
 
-    struct ANode : public Object {
-        Location location;
+static llvm::BumpPtrAllocator *ANodeAllocator = new llvm::BumpPtrAllocator();
 
-        ANode(ObjectKind objKind)
-            : Object(objKind) {
-        }
+struct ANode : public Object {
+    Location location;
 
-        void *operator new(size_t num_bytes) {
-            return ANodeAllocator->Allocate(num_bytes, alignof(ANode));
-        }
+    ANode(ObjectKind objKind) : Object(objKind) {}
 
-        void operator delete(void *anode) {
-            ANodeAllocator->Deallocate(anode);
-        }
-    };
+    void *operator new(size_t num_bytes) {
+        return ANodeAllocator->Allocate(num_bytes, alignof(ANode));
+    }
 
-    struct Identifier : public ANode {
-        const llvm::SmallString<16> str;
-        bool isOperator: 1;
+    void operator delete(void *anode) {
+        ANodeAllocator->Deallocate(anode, sizeof(ANode), alignof(ANode));
+    }
+};
 
-        Identifier(llvm::StringRef str)
-            : ANode(IDENTIFIER), str(str), isOperator(false) {
-        }
+struct Identifier : public ANode {
+    const llvm::SmallString<16> str;
+    bool isOperator : 1;
 
-        Identifier(llvm::StringRef str, bool isOperator)
-            : ANode(IDENTIFIER), str(str), isOperator(isOperator) {
-        }
+    Identifier(llvm::StringRef str)
+        : ANode(IDENTIFIER), str(str), isOperator(false) {}
 
-        static map<llvm::StringRef, IdentifierPtr> freeIdentifiers; // in parser.cpp
+    Identifier(llvm::StringRef str, bool isOperator)
+        : ANode(IDENTIFIER), str(str), isOperator(isOperator) {}
 
-        static Identifier *get(llvm::StringRef str, bool isOperator = false) {
-            map<llvm::StringRef, IdentifierPtr>::const_iterator iter = freeIdentifiers.find(str);
-            if (iter == freeIdentifiers.end()) {
-                Identifier *ident = new Identifier(str, isOperator);
-                freeIdentifiers[ident->str] = ident;
-                return ident;
-            } else
-                return iter->second.ptr();
-        }
+    static map<llvm::StringRef, IdentifierPtr> freeIdentifiers; // in parser.cpp
 
-        static Identifier *get(llvm::StringRef str, Location const &location, bool isOperator = false) {
+    static Identifier *get(llvm::StringRef str, bool isOperator = false) {
+        map<llvm::StringRef, IdentifierPtr>::const_iterator iter =
+            freeIdentifiers.find(str);
+        if (iter == freeIdentifiers.end()) {
             Identifier *ident = new Identifier(str, isOperator);
-            ident->location = location;
+            freeIdentifiers[ident->str] = ident;
             return ident;
-        }
-    };
-
-    struct DottedName : public ANode {
-        llvm::SmallVector<IdentifierPtr, 2> parts;
-
-        DottedName()
-            : ANode(DOTTED_NAME) {
-        }
-
-        DottedName(llvm::ArrayRef<IdentifierPtr> parts)
-            : ANode(DOTTED_NAME), parts(parts.begin(), parts.end()) {
-        }
+        } else
+            return iter->second.ptr();
+    }
 
-        string join() const;
-    };
-
-    //
-    // Expr
-    //
-
-#define EXPR_KIND_MAP(XX) \
-    XX(BOOL_LITERAL) \
-    XX(INT_LITERAL) \
-    XX(FLOAT_LITERAL) \
-    XX(CHAR_LITERAL) \
-    XX(STRING_LITERAL) \
-\
-    XX(FILE_EXPR) \
-    XX(LINE_EXPR) \
-    XX(COLUMN_EXPR) \
-    XX(ARG_EXPR) \
-\
-    XX(NAME_REF) \
-    XX(TUPLE) \
-    XX(PAREN) \
-    XX(INDEXING) \
-    XX(CALL) \
-    XX(FIELD_REF) \
-    XX(STATIC_INDEXING) \
-    XX(VARIADIC_OP) \
-    XX(AND) \
-    XX(OR) \
-\
-    XX(LAMBDA) \
-    XX(UNPACK) \
-    XX(STATIC_EXPR) \
-    XX(DISPATCH_EXPR) \
-\
-    XX(FOREIGN_EXPR) \
-    XX(OBJECT_EXPR) \
-\
+    static Identifier *get(llvm::StringRef str, Location const &location,
+                           bool isOperator = false) {
+        Identifier *ident = new Identifier(str, isOperator);
+        ident->location = location;
+        return ident;
+    }
+};
+
+struct DottedName : public ANode {
+    llvm::SmallVector<IdentifierPtr, 2> parts;
+
+    DottedName() : ANode(DOTTED_NAME) {}
+
+    DottedName(llvm::ArrayRef<IdentifierPtr> parts)
+        : ANode(DOTTED_NAME), parts(parts.begin(), parts.end()) {}
+
+    string join() const;
+};
+
+//
+// Expr
+//
+
+#define EXPR_KIND_MAP(XX)                                                      \
+    XX(BOOL_LITERAL)                                                           \
+    XX(INT_LITERAL)                                                            \
+    XX(FLOAT_LITERAL)                                                          \
+    XX(CHAR_LITERAL)                                                           \
+    XX(STRING_LITERAL)                                                         \
+                                                                               \
+    XX(FILE_EXPR)                                                              \
+    XX(LINE_EXPR)                                                              \
+    XX(COLUMN_EXPR)                                                            \
+    XX(ARG_EXPR)                                                               \
+                                                                               \
+    XX(NAME_REF)                                                               \
+    XX(TUPLE)                                                                  \
+    XX(PAREN)                                                                  \
+    XX(INDEXING)                                                               \
+    XX(CALL)                                                                   \
+    XX(FIELD_REF)                                                              \
+    XX(STATIC_INDEXING)                                                        \
+    XX(VARIADIC_OP)                                                            \
+    XX(AND)                                                                    \
+    XX(OR)                                                                     \
+                                                                               \
+    XX(LAMBDA)                                                                 \
+    XX(UNPACK)                                                                 \
+    XX(STATIC_EXPR)                                                            \
+    XX(DISPATCH_EXPR)                                                          \
+                                                                               \
+    XX(FOREIGN_EXPR)                                                           \
+    XX(OBJECT_EXPR)                                                            \
+                                                                               \
     XX(EVAL_EXPR)
 #define EXPR_KIND_GEN(e) e,
 
-    enum ExprKind {
-        EXPR_KIND_MAP(EXPR_KIND_GEN)
-    };
+enum ExprKind { EXPR_KIND_MAP(EXPR_KIND_GEN) };
 #undef EXPR_KIND_GEN
 
-    llvm::raw_ostream &operator<<(llvm::raw_ostream &os, ExprKind);
+llvm::raw_ostream &operator<<(llvm::raw_ostream &os, ExprKind);
 
-    struct Expr : public ANode {
-        const ExprKind exprKind;
-        Location startLocation;
-        Location endLocation;
+struct Expr : public ANode {
+    const ExprKind exprKind;
+    Location startLocation;
+    Location endLocation;
 
-        MultiPValuePtr cachedAnalysis;
+    MultiPValuePtr cachedAnalysis;
 
-        Expr(ExprKind exprKind)
-            : ANode(EXPRESSION), exprKind(exprKind) {
-        }
+    Expr(ExprKind exprKind) : ANode(EXPRESSION), exprKind(exprKind) {}
 
-        string asString() {
-            if (!startLocation.ok() || !endLocation.ok())
-                return "<generated expression>";
-            assert(startLocation.source == endLocation.source);
-            const char *data = startLocation.source->data();
-            return string(data + startLocation.offset, data + endLocation.offset);
-        }
-    };
+    string asString() {
+        if (!startLocation.ok() || !endLocation.ok())
+            return "<generated expression>";
+        assert(startLocation.source == endLocation.source);
+        const char *data = startLocation.source->data();
+        return string(data + startLocation.offset, data + endLocation.offset);
+    }
+};
 
-    struct BoolLiteral : public Expr {
-        const bool value;
+struct BoolLiteral : public Expr {
+    const bool value;
 
-        BoolLiteral(bool value)
-            : Expr(BOOL_LITERAL), value(value) {
-        }
-    };
+    BoolLiteral(bool value) : Expr(BOOL_LITERAL), value(value) {}
+};
 
-    struct IntLiteral : public Expr {
-        const string value;
-        const string suffix;
+struct IntLiteral : public Expr {
+    const string value;
+    const string suffix;
 
-        IntLiteral(llvm::StringRef value)
-            : Expr(INT_LITERAL), value(value) {
-        }
+    IntLiteral(llvm::StringRef value) : Expr(INT_LITERAL), value(value) {}
 
-        IntLiteral(llvm::StringRef value, llvm::StringRef suffix)
-            : Expr(INT_LITERAL), value(value), suffix(suffix) {
-        }
-    };
+    IntLiteral(llvm::StringRef value, llvm::StringRef suffix)
+        : Expr(INT_LITERAL), value(value), suffix(suffix) {}
+};
 
-    struct FloatLiteral : public Expr {
-        const string value;
-        const string suffix;
+struct FloatLiteral : public Expr {
+    const string value;
+    const string suffix;
 
-        FloatLiteral(llvm::StringRef value)
-            : Expr(FLOAT_LITERAL), value(value) {
-        }
+    FloatLiteral(llvm::StringRef value) : Expr(FLOAT_LITERAL), value(value) {}
 
-        FloatLiteral(llvm::StringRef value, llvm::StringRef suffix)
-            : Expr(FLOAT_LITERAL), value(value), suffix(suffix) {
-        }
-    };
+    FloatLiteral(llvm::StringRef value, llvm::StringRef suffix)
+        : Expr(FLOAT_LITERAL), value(value), suffix(suffix) {}
+};
 
-    struct CharLiteral : public Expr {
-        ExprPtr desugared;
-        const char value;
+struct CharLiteral : public Expr {
+    ExprPtr desugared;
+    const char value;
 
-        CharLiteral(char value)
-            : Expr(CHAR_LITERAL), value(value) {
-        }
-    };
+    CharLiteral(char value) : Expr(CHAR_LITERAL), value(value) {}
+};
 
-    struct StringLiteral : public Expr {
-        const IdentifierPtr value;
+struct StringLiteral : public Expr {
+    const IdentifierPtr value;
 
-        StringLiteral(const IdentifierPtr &value)
-            : Expr(STRING_LITERAL), value(value) {
-        }
-    };
+    StringLiteral(const IdentifierPtr &value)
+        : Expr(STRING_LITERAL), value(value) {}
+};
 
-    struct NameRef : public Expr {
-        const IdentifierPtr name;
+struct NameRef : public Expr {
+    const IdentifierPtr name;
 
-        NameRef(const IdentifierPtr &name)
-            : Expr(NAME_REF), name(name) {
-        }
-    };
+    NameRef(const IdentifierPtr &name) : Expr(NAME_REF), name(name) {}
+};
 
-    // `__FILE__`
-    struct FILEExpr : public Expr {
-        FILEExpr()
-            : Expr(FILE_EXPR) {
-        }
-    };
+// `__FILE__`
+struct FILEExpr : public Expr {
+    FILEExpr() : Expr(FILE_EXPR) {}
+};
 
-    // `__LINE__`
-    struct LINEExpr : public Expr {
-        LINEExpr()
-            : Expr(LINE_EXPR) {
-        }
-    };
+// `__LINE__`
+struct LINEExpr : public Expr {
+    LINEExpr() : Expr(LINE_EXPR) {}
+};
 
-    // `__COLUMN__`
-    struct COLUMNExpr : public Expr {
-        COLUMNExpr()
-            : Expr(COLUMN_EXPR) {
-        }
-    };
+// `__COLUMN__`
+struct COLUMNExpr : public Expr {
+    COLUMNExpr() : Expr(COLUMN_EXPR) {}
+};
 
-    // `__ARG__`
-    struct ARGExpr : public Expr {
-        IdentifierPtr name;
+// `__ARG__`
+struct ARGExpr : public Expr {
+    IdentifierPtr name;
 
-        ARGExpr(IdentifierPtr name)
-            : Expr(ARG_EXPR), name(name) {
-        }
-    };
+    ARGExpr(IdentifierPtr name) : Expr(ARG_EXPR), name(name) {}
+};
 
-    // expression like `[foo, bar]`
-    struct Tuple : public Expr {
-        // `foo, bar`
-        ExprListPtr args;
+// expression like `[foo, bar]`
+struct Tuple : public Expr {
+    // `foo, bar`
+    ExprListPtr args;
 
-        Tuple(ExprListPtr args)
-            : Expr(TUPLE), args(args) {
-        }
-    };
+    Tuple(ExprListPtr args) : Expr(TUPLE), args(args) {}
+};
 
-    // parenthesized expression, like `(foo)`
-    struct Paren : public Expr {
-        // `foo`
-        const ExprListPtr args;
+// parenthesized expression, like `(foo)`
+struct Paren : public Expr {
+    // `foo`
+    const ExprListPtr args;
 
-        Paren(ExprListPtr args)
-            : Expr(PAREN), args(args) {
-        }
-    };
+    Paren(ExprListPtr args) : Expr(PAREN), args(args) {}
+};
 
-    // indexing is expression like `foo[bar, baz]`
-    struct Indexing : public Expr {
-        // `foo`
-        ExprPtr expr;
-        // `bar, baz`
-        const ExprListPtr args;
+// indexing is expression like `foo[bar, baz]`
+struct Indexing : public Expr {
+    // `foo`
+    ExprPtr expr;
+    // `bar, baz`
+    const ExprListPtr args;
 
-        Indexing(const ExprPtr &expr, const ExprListPtr &args)
-            : Expr(INDEXING), expr(expr), args(args) {
-        }
-    };
+    Indexing(const ExprPtr &expr, const ExprListPtr &args)
+        : Expr(INDEXING), expr(expr), args(args) {}
+};
 
-    struct Call : public Expr {
-        ExprPtr expr;
-        const ExprListPtr parenArgs;
+struct Call : public Expr {
+    ExprPtr expr;
+    const ExprListPtr parenArgs;
 
-        ExprListPtr _allArgs;
+    ExprListPtr _allArgs;
 
-        ExprListPtr allArgs();
+    ExprListPtr allArgs();
 
-        Call(const ExprPtr &expr, const ExprListPtr &parenArgs)
-            : Expr(CALL), expr(expr), parenArgs(parenArgs),
-              _allArgs(nullptr) {
-        }
-    };
-
-    struct FieldRef : public Expr {
-        ExprPtr expr;
-        const IdentifierPtr name;
-        ExprPtr desugared;
-        bool isDottedModuleName;
-
-        FieldRef(ExprPtr expr, IdentifierPtr name)
-            : Expr(FIELD_REF), expr(expr), name(name), isDottedModuleName(false) {
-        }
-    };
-
-    // static indexing, like `foo.12`
-    struct StaticIndexing : public Expr {
-        // `foo`
-        ExprPtr expr;
-        // `12`
-        const size_t index;
-        ExprPtr desugared;
-
-        StaticIndexing(ExprPtr expr, size_t index)
-            : Expr(STATIC_INDEXING), expr(expr), index(index) {
-        }
-    };
-
-#define VARIADIC_OP_KIND_MAP(XX) \
-    XX(DEREFERENCE) \
-    XX(ADDRESS_OF) \
-    XX(NOT) \
-    XX(PREFIX_OP) \
-    XX(INFIX_OP) \
+    Call(const ExprPtr &expr, const ExprListPtr &parenArgs)
+        : Expr(CALL), expr(expr), parenArgs(parenArgs), _allArgs(nullptr) {}
+};
+
+struct FieldRef : public Expr {
+    ExprPtr expr;
+    const IdentifierPtr name;
+    ExprPtr desugared;
+    bool isDottedModuleName;
+
+    FieldRef(ExprPtr expr, IdentifierPtr name)
+        : Expr(FIELD_REF), expr(expr), name(name), isDottedModuleName(false) {}
+};
+
+// static indexing, like `foo.12`
+struct StaticIndexing : public Expr {
+    // `foo`
+    ExprPtr expr;
+    // `12`
+    const size_t index;
+    ExprPtr desugared;
+
+    StaticIndexing(ExprPtr expr, size_t index)
+        : Expr(STATIC_INDEXING), expr(expr), index(index) {}
+};
+
+#define VARIADIC_OP_KIND_MAP(XX)                                               \
+    XX(DEREFERENCE)                                                            \
+    XX(ADDRESS_OF)                                                             \
+    XX(NOT)                                                                    \
+    XX(PREFIX_OP)                                                              \
+    XX(INFIX_OP)                                                               \
     XX(IF_EXPR)
 #define VARIADIC_OP_KIND_GEN(e) e,
 
-    enum VariadicOpKind {
-        VARIADIC_OP_KIND_MAP(VARIADIC_OP_KIND_GEN)
-    };
+enum VariadicOpKind { VARIADIC_OP_KIND_MAP(VARIADIC_OP_KIND_GEN) };
 #undef VARIADIC_OP_KIND_GEN
 
-    llvm::raw_ostream &operator<<(llvm::raw_ostream &os, VariadicOpKind);
+llvm::raw_ostream &operator<<(llvm::raw_ostream &os, VariadicOpKind);
 
-    struct VariadicOp : public Expr {
-        const VariadicOpKind op;
-        const ExprListPtr exprs;
-        ExprPtr desugared;
+struct VariadicOp : public Expr {
+    const VariadicOpKind op;
+    const ExprListPtr exprs;
+    ExprPtr desugared;
 
-        VariadicOp(VariadicOpKind op, ExprListPtr exprs)
-            : Expr(VARIADIC_OP), op(op), exprs(exprs) {
-        }
-    };
+    VariadicOp(VariadicOpKind op, ExprListPtr exprs)
+        : Expr(VARIADIC_OP), op(op), exprs(exprs) {}
+};
 
-    struct And : public Expr {
-        ExprPtr expr1, expr2;
+struct And : public Expr {
+    ExprPtr expr1, expr2;
 
-        And(ExprPtr expr1, ExprPtr expr2)
-            : Expr(AND), expr1(expr1), expr2(expr2) {
-        }
-    };
+    And(ExprPtr expr1, ExprPtr expr2) : Expr(AND), expr1(expr1), expr2(expr2) {}
+};
 
-    struct Or : public Expr {
-        ExprPtr expr1, expr2;
+struct Or : public Expr {
+    ExprPtr expr1, expr2;
 
-        Or(ExprPtr expr1, ExprPtr expr2)
-            : Expr(OR), expr1(expr1), expr2(expr2) {
-        }
-    };
+    Or(ExprPtr expr1, ExprPtr expr2) : Expr(OR), expr1(expr1), expr2(expr2) {}
+};
 
-    enum ProcedureMonoState {
-        Procedure_NoOverloads,
-        Procedure_MonoOverload,
-        Procedure_PolyOverload
-    };
+enum ProcedureMonoState {
+    Procedure_NoOverloads,
+    Procedure_MonoOverload,
+    Procedure_PolyOverload
+};
 
-    struct ProcedureMono {
-        ProcedureMonoState monoState;
-        vector<TypePtr> monoTypes;
+struct ProcedureMono {
+    ProcedureMonoState monoState;
+    vector<TypePtr> monoTypes;
 
-        ProcedureMono() : monoState(Procedure_NoOverloads) {
-        }
-    };
+    ProcedureMono() : monoState(Procedure_NoOverloads) {}
+};
 
-    enum LambdaCapture {
-        REF_CAPTURE,
-        VALUE_CAPTURE,
-        STATELESS
-    };
+enum LambdaCapture { REF_CAPTURE, VALUE_CAPTURE, STATELESS };
 
-    struct Lambda : public Expr {
-        const LambdaCapture captureBy;
-        const vector<FormalArgPtr> formalArgs;
+struct Lambda : public Expr {
+    const LambdaCapture captureBy;
+    const vector<FormalArgPtr> formalArgs;
 
-        const StatementPtr body;
+    const StatementPtr body;
 
-        ExprPtr converted;
+    ExprPtr converted;
 
-        vector<string> freeVars;
+    vector<string> freeVars;
 
-        ProcedureMono mono;
+    ProcedureMono mono;
 
-        // if freevars are present
-        RecordDeclPtr lambdaRecord;
-        TypePtr lambdaType;
+    // if freevars are present
+    RecordDeclPtr lambdaRecord;
+    TypePtr lambdaType;
 
-        // if freevars are absent
-        ProcedurePtr lambdaProc;
+    // if freevars are absent
+    ProcedurePtr lambdaProc;
 
-        const bool hasVarArg: 1;
-        const bool hasAsConversion: 1;
-        bool initialized: 1;
+    const bool hasVarArg : 1;
+    const bool hasAsConversion : 1;
+    bool initialized : 1;
 
-        Lambda(LambdaCapture captureBy,
-               llvm::ArrayRef<FormalArgPtr> formalArgs,
-               bool hasVarArg, bool hasAsConversion, StatementPtr body)
-            : Expr(LAMBDA), captureBy(captureBy),
-              formalArgs(formalArgs), body(body),
-              hasVarArg(hasVarArg), hasAsConversion(hasAsConversion),
-              initialized(false) {
-        }
-    };
+    Lambda(LambdaCapture captureBy, llvm::ArrayRef<FormalArgPtr> formalArgs,
+           bool hasVarArg, bool hasAsConversion, StatementPtr body)
+        : Expr(LAMBDA), captureBy(captureBy), formalArgs(formalArgs),
+          body(body), hasVarArg(hasVarArg), hasAsConversion(hasAsConversion),
+          initialized(false) {}
+};
 
-    // unpack, like `..foo()`
-    struct Unpack : public Expr {
-        ExprPtr expr;
+// unpack, like `..foo()`
+struct Unpack : public Expr {
+    ExprPtr expr;
 
-        Unpack(ExprPtr expr) : Expr(UNPACK), expr(expr) {
-        }
-    };
+    Unpack(ExprPtr expr) : Expr(UNPACK), expr(expr) {}
+};
 
-    // static, like `#foo`
-    struct StaticExpr : public Expr {
-        // `foo`
-        ExprPtr expr;
+// static, like `#foo`
+struct StaticExpr : public Expr {
+    // `foo`
+    ExprPtr expr;
 
-        StaticExpr(ExprPtr expr) : Expr(STATIC_EXPR), expr(expr) {
-        }
-    };
+    StaticExpr(ExprPtr expr) : Expr(STATIC_EXPR), expr(expr) {}
+};
 
-    // variant dispatch, as `*foo` in `bar(*foo)`
-    struct DispatchExpr : public Expr {
-        // `foo`
-        ExprPtr expr;
+// variant dispatch, as `*foo` in `bar(*foo)`
+struct DispatchExpr : public Expr {
+    // `foo`
+    ExprPtr expr;
 
-        DispatchExpr(ExprPtr expr) : Expr(DISPATCH_EXPR), expr(expr) {
-        }
-    };
+    DispatchExpr(ExprPtr expr) : Expr(DISPATCH_EXPR), expr(expr) {}
+};
 
-    // synthetic expression that is evaluated in specified env or module
-    struct ForeignExpr : public Expr {
-        const string moduleName;
-        EnvPtr foreignEnv;
-        const ExprPtr expr;
+// synthetic expression that is evaluated in specified env or module
+struct ForeignExpr : public Expr {
+    const string moduleName;
+    EnvPtr foreignEnv;
+    const ExprPtr expr;
 
-        ForeignExpr(llvm::StringRef moduleName, ExprPtr expr)
-            : Expr(FOREIGN_EXPR), moduleName(moduleName), expr(expr) {
-        }
+    ForeignExpr(llvm::StringRef moduleName, ExprPtr expr)
+        : Expr(FOREIGN_EXPR), moduleName(moduleName), expr(expr) {}
 
-        ForeignExpr(EnvPtr foreignEnv, ExprPtr expr)
-            : Expr(FOREIGN_EXPR), foreignEnv(foreignEnv), expr(expr) {
-        }
+    ForeignExpr(EnvPtr foreignEnv, ExprPtr expr)
+        : Expr(FOREIGN_EXPR), foreignEnv(foreignEnv), expr(expr) {}
 
-        EnvPtr getEnv();
-    };
+    EnvPtr getEnv();
+};
 
-    // synthetic expression that evaluates to specified object
-    struct ObjectExpr : public Expr {
-        const ObjectPtr obj;
+// synthetic expression that evaluates to specified object
+struct ObjectExpr : public Expr {
+    const ObjectPtr obj;
 
-        ObjectExpr(ObjectPtr obj)
-            : Expr(OBJECT_EXPR), obj(obj) {
-        }
-    };
+    ObjectExpr(ObjectPtr obj) : Expr(OBJECT_EXPR), obj(obj) {}
+};
 
-    struct EvalExpr : public Expr {
-        // expression that must evaluate to string
-        ExprPtr args;
-        // result of evaluation, lazy
-        ExprListPtr value;
+struct EvalExpr : public Expr {
+    // expression that must evaluate to string
+    ExprPtr args;
+    // result of evaluation, lazy
+    ExprListPtr value;
 
-        EvalExpr(ExprPtr args)
-            : Expr(EVAL_EXPR), args(args) {
-        }
-    };
+    EvalExpr(ExprPtr args) : Expr(EVAL_EXPR), args(args) {}
+};
 
-    //
-    // ExprList
-    //
+//
+// ExprList
+//
 
-    struct ExprList : public Object {
-        vector<ExprPtr> exprs;
+struct ExprList : public Object {
+    vector<ExprPtr> exprs;
 
-        MultiPValuePtr cachedAnalysis;
+    MultiPValuePtr cachedAnalysis;
 
-        ExprList()
-            : Object(EXPR_LIST) {
-        }
+    ExprList() : Object(EXPR_LIST) {}
 
-        ExprList(ExprPtr x)
-            : Object(EXPR_LIST) {
-            exprs.push_back(x);
-        }
+    ExprList(ExprPtr x) : Object(EXPR_LIST) { exprs.push_back(x); }
 
-        ExprList(llvm::ArrayRef<ExprPtr> exprs)
-            : Object(EXPR_LIST), exprs(exprs) {
-        }
+    ExprList(llvm::ArrayRef<ExprPtr> exprs) : Object(EXPR_LIST), exprs(exprs) {}
 
-        size_t size() const { return exprs.size(); }
-        void add(ExprPtr x) { exprs.push_back(x); }
+    size_t size() const { return exprs.size(); }
+    void add(ExprPtr x) { exprs.push_back(x); }
 
-        void add(ExprListPtr x) {
-            exprs.insert(exprs.end(), x->exprs.begin(), x->exprs.end());
-        }
+    void add(ExprListPtr x) {
+        exprs.insert(exprs.end(), x->exprs.begin(), x->exprs.end());
+    }
 
-        void insert(ExprPtr x) {
-            exprs.insert(exprs.begin(), x);
-        }
-    };
+    void insert(ExprPtr x) { exprs.insert(exprs.begin(), x); }
+};
 
-    inline ExprListPtr Call::allArgs() {
-        if (_allArgs == nullptr) {
-            _allArgs = new ExprList();
-            _allArgs->add(parenArgs);
-        }
-        return _allArgs;
+inline ExprListPtr Call::allArgs() {
+    if (_allArgs == nullptr) {
+        _allArgs = new ExprList();
+        _allArgs->add(parenArgs);
     }
+    return _allArgs;
+}
 
-    //
-    // Stmt
-    //
-
-#define STATEMENT_KIND_MAP(XX) \
-    XX(BLOCK) \
-    XX(LABEL) \
-    XX(BINDING) \
-    XX(ASSIGNMENT) \
-    XX(INIT_ASSIGNMENT) \
-    XX(VARIADIC_ASSIGNMENT) \
-    XX(GOTO) \
-    XX(RETURN) \
-    XX(IF) \
-    XX(SWITCH) \
-    XX(EXPR_STATEMENT) \
-    XX(WHILE) \
-    XX(BREAK) \
-    XX(CONTINUE) \
-    XX(FOR) \
-    XX(FOREIGN_STATEMENT) \
-    XX(TRY) \
-    XX(THROW) \
-    XX(STATIC_FOR) \
-    XX(FINALLY) \
-    XX(ONERROR) \
-    XX(UNREACHABLE) \
-    XX(EVAL_STATEMENT) \
+//
+// Stmt
+//
+
+#define STATEMENT_KIND_MAP(XX)                                                 \
+    XX(BLOCK)                                                                  \
+    XX(LABEL)                                                                  \
+    XX(BINDING)                                                                \
+    XX(ASSIGNMENT)                                                             \
+    XX(INIT_ASSIGNMENT)                                                        \
+    XX(VARIADIC_ASSIGNMENT)                                                    \
+    XX(GOTO)                                                                   \
+    XX(RETURN)                                                                 \
+    XX(IF)                                                                     \
+    XX(SWITCH)                                                                 \
+    XX(EXPR_STATEMENT)                                                         \
+    XX(WHILE)                                                                  \
+    XX(BREAK)                                                                  \
+    XX(CONTINUE)                                                               \
+    XX(FOR)                                                                    \
+    XX(FOREIGN_STATEMENT)                                                      \
+    XX(TRY)                                                                    \
+    XX(THROW)                                                                  \
+    XX(STATIC_FOR)                                                             \
+    XX(FINALLY)                                                                \
+    XX(ONERROR)                                                                \
+    XX(UNREACHABLE)                                                            \
+    XX(EVAL_STATEMENT)                                                         \
     XX(STATIC_ASSERT_STATEMENT)
 #define STATEMENT_KIND_GEN(e) e,
 
-    enum StatementKind {
-        STATEMENT_KIND_MAP(STATEMENT_KIND_GEN)
-    };
+enum StatementKind { STATEMENT_KIND_MAP(STATEMENT_KIND_GEN) };
 #undef STATEMENT_KIND_GEN
 
-    llvm::raw_ostream &operator<<(llvm::raw_ostream &os, StatementKind);
+llvm::raw_ostream &operator<<(llvm::raw_ostream &os, StatementKind);
 
-    struct Statement : public ANode {
-        const StatementKind stmtKind;
+struct Statement : public ANode {
+    const StatementKind stmtKind;
 
-        Statement(StatementKind stmtKind)
-            : ANode(STATEMENT), stmtKind(stmtKind) {
-        }
-    };
+    Statement(StatementKind stmtKind) : ANode(STATEMENT), stmtKind(stmtKind) {}
+};
 
-    struct Block : public Statement {
-        vector<StatementPtr> statements;
+struct Block : public Statement {
+    vector<StatementPtr> statements;
 
-        Block()
-            : Statement(BLOCK) {
-        }
+    Block() : Statement(BLOCK) {}
 
-        Block(llvm::ArrayRef<StatementPtr> statements)
-            : Statement(BLOCK), statements(statements) {
-        }
-    };
+    Block(llvm::ArrayRef<StatementPtr> statements)
+        : Statement(BLOCK), statements(statements) {}
+};
 
-    struct Label : public Statement {
-        const IdentifierPtr name;
+struct Label : public Statement {
+    const IdentifierPtr name;
 
-        Label(IdentifierPtr name)
-            : Statement(LABEL), name(name) {
-        }
-    };
+    Label(IdentifierPtr name) : Statement(LABEL), name(name) {}
+};
 
-#define BINDING_KIND_MAP(XX) \
-    XX(VAR) \
-    XX(REF) \
-    XX(ALIAS) \
+#define BINDING_KIND_MAP(XX)                                                   \
+    XX(VAR)                                                                    \
+    XX(REF)                                                                    \
+    XX(ALIAS)                                                                  \
     XX(FORWARD)
 #define BINDING_KIND_GEN(e) e,
 
-    enum BindingKind {
-        BINDING_KIND_MAP(BINDING_KIND_GEN)
-    };
+enum BindingKind { BINDING_KIND_MAP(BINDING_KIND_GEN) };
 #undef BINDING_KIND_GEN
 
-    llvm::raw_ostream &operator<<(llvm::raw_ostream &os, BindingKind);
-
-    struct PatternVar;
+llvm::raw_ostream &operator<<(llvm::raw_ostream &os, BindingKind);
 
-    struct Binding : public Statement {
-        const BindingKind bindingKind;
-        vector<PatternVar> patternVars;
-        vector<ObjectPtr> patternTypes;
-        const ExprPtr predicate;
-        vector<FormalArgPtr> args;
-        const ExprListPtr values;
-        const bool hasVarArg;
+struct PatternVar;
+
+struct Binding : public Statement {
+    const BindingKind bindingKind;
+    vector<PatternVar> patternVars;
+    vector<ObjectPtr> patternTypes;
+    const ExprPtr predicate;
+    vector<FormalArgPtr> args;
+    const ExprListPtr values;
+    const bool hasVarArg;
+
+    Binding(BindingKind bindingKind, llvm::ArrayRef<FormalArgPtr> args,
+            ExprListPtr values)
+        : Statement(BINDING), bindingKind(bindingKind), args(args),
+          values(values), hasVarArg(false) {}
+
+    Binding(BindingKind bindingKind, llvm::ArrayRef<PatternVar> patternVars,
+            llvm::ArrayRef<ObjectPtr> patternTypes, ExprPtr predicate,
+            llvm::ArrayRef<FormalArgPtr> args, ExprListPtr values,
+            bool hasVarArg)
+        : Statement(BINDING), bindingKind(bindingKind),
+          patternVars(patternVars), predicate(predicate), args(args),
+          values(values), hasVarArg(hasVarArg) {}
+};
+
+struct Assignment : public Statement {
+    const ExprListPtr left, right;
+
+    Assignment(ExprListPtr left, ExprListPtr right)
+        : Statement(ASSIGNMENT), left(left), right(right) {}
+};
 
-        Binding(BindingKind bindingKind,
-                llvm::ArrayRef<FormalArgPtr> args,
-                ExprListPtr values)
-            : Statement(BINDING), bindingKind(bindingKind),
-              args(args), values(values), hasVarArg(false) {
-        }
+struct InitAssignment : public Statement {
+    const ExprListPtr left, right;
+
+    InitAssignment(ExprListPtr left, ExprListPtr right)
+        : Statement(INIT_ASSIGNMENT), left(left), right(right) {}
 
-        Binding(BindingKind bindingKind,
-                llvm::ArrayRef<PatternVar> patternVars,
-                llvm::ArrayRef<ObjectPtr> patternTypes,
-                ExprPtr predicate,
-                llvm::ArrayRef<FormalArgPtr> args,
-                ExprListPtr values, bool hasVarArg)
-            : Statement(BINDING), bindingKind(bindingKind),
-              patternVars(patternVars),
-              predicate(predicate),
-              args(args), values(values), hasVarArg(hasVarArg) {
-        }
-    };
+    InitAssignment(ExprPtr leftExpr, ExprPtr rightExpr)
+        : Statement(INIT_ASSIGNMENT), left(new ExprList(leftExpr)),
+          right(new ExprList(rightExpr)) {}
+};
 
-    struct Assignment : public Statement {
-        const ExprListPtr left, right;
+struct VariadicAssignment : public Statement {
+    const ExprListPtr exprs;
+    ExprPtr desugared;
+    VariadicOpKind op;
 
-        Assignment(ExprListPtr left,
-                   ExprListPtr right)
-            : Statement(ASSIGNMENT), left(left), right(right) {
-        }
-    };
+    VariadicAssignment(VariadicOpKind op, ExprListPtr exprs)
+        : Statement(VARIADIC_ASSIGNMENT), exprs(exprs), op(op) {}
+};
 
-    struct InitAssignment : public Statement {
-        const ExprListPtr left, right;
+struct Goto : public Statement {
+    const IdentifierPtr labelName;
 
-        InitAssignment(ExprListPtr left,
-                       ExprListPtr right)
-            : Statement(INIT_ASSIGNMENT), left(left), right(right) {
-        }
-
-        InitAssignment(ExprPtr leftExpr, ExprPtr rightExpr)
-            : Statement(INIT_ASSIGNMENT),
-              left(new ExprList(leftExpr)),
-              right(new ExprList(rightExpr)) {
-        }
-    };
-
-    struct VariadicAssignment : public Statement {
-        const ExprListPtr exprs;
-        ExprPtr desugared;
-        VariadicOpKind op;
-
-        VariadicAssignment(VariadicOpKind op, ExprListPtr exprs)
-            : Statement(VARIADIC_ASSIGNMENT), exprs(exprs), op(op) {
-        }
-    };
-
-    struct Goto : public Statement {
-        const IdentifierPtr labelName;
-
-        Goto(IdentifierPtr labelName)
-            : Statement(GOTO), labelName(labelName) {
-        }
-    };
-
-    enum ReturnKind {
-        RETURN_VALUE,
-        RETURN_REF,
-        RETURN_FORWARD
-    };
-
-    struct Return : public Statement {
-        const ExprListPtr values;
-        const ReturnKind returnKind: 3;
-        bool isExprReturn: 1;
-        bool isReturnSpecs: 1;
-
-        Return(ReturnKind returnKind, ExprListPtr values)
-            : Statement(RETURN), values(values),
-              returnKind(returnKind), isExprReturn(false), isReturnSpecs(false) {
-        }
-
-        Return(ReturnKind returnKind, ExprListPtr values, bool exprRet)
-            : Statement(RETURN), values(values),
-              returnKind(returnKind), isExprReturn(exprRet), isReturnSpecs(false) {
-        }
-    };
-
-    struct If : public Statement {
-        vector<StatementPtr> conditionStatements;
-        ExprPtr condition;
-
-        StatementPtr thenPart, elsePart;
-
-        If(const ExprPtr &condition, StatementPtr thenPart)
-            : Statement(IF), condition(condition), thenPart(thenPart) {
-        }
-
-        If(ExprPtr condition, StatementPtr thenPart, StatementPtr elsePart)
-            : Statement(IF), condition(condition), thenPart(thenPart),
-              elsePart(elsePart) {
-        }
-
-        If(llvm::ArrayRef<StatementPtr> conditionStatements,
-           ExprPtr condition, StatementPtr thenPart)
-            : Statement(IF), conditionStatements(conditionStatements),
-              condition(condition), thenPart(thenPart) {
-        }
-
-        If(llvm::ArrayRef<StatementPtr> conditionStatements,
-           ExprPtr condition, StatementPtr thenPart, StatementPtr elsePart)
-            : Statement(IF), conditionStatements(conditionStatements),
-              condition(condition), thenPart(thenPart),
-              elsePart(elsePart) {
-        }
-    };
-
-    struct Switch : public Statement {
-        vector<StatementPtr> exprStatements;
-        ExprPtr expr;
-        vector<CaseBlockPtr> caseBlocks;
-        StatementPtr defaultCase;
-
-        StatementPtr desugared;
-
-        Switch(llvm::ArrayRef<StatementPtr> exprStatements,
-               ExprPtr expr,
-               llvm::ArrayRef<CaseBlockPtr> caseBlocks,
-               StatementPtr defaultCase)
-            : Statement(SWITCH), exprStatements(exprStatements),
-              expr(expr), caseBlocks(caseBlocks),
-              defaultCase(defaultCase) {
-        }
-
-        Switch(ExprPtr expr,
-               llvm::ArrayRef<CaseBlockPtr> caseBlocks,
-               StatementPtr defaultCase)
-            : Statement(SWITCH), expr(expr), caseBlocks(caseBlocks),
-              defaultCase(defaultCase) {
-        }
-    };
-
-    struct CaseBlock : public ANode {
-        const ExprListPtr caseLabels;
-        const StatementPtr body;
-
-        CaseBlock(ExprListPtr caseLabels, StatementPtr body)
-            : ANode(CASE_BLOCK), caseLabels(caseLabels), body(body) {
-        }
-    };
-
-    struct ExprStatement : public Statement {
-        ExprPtr expr;
-
-        ExprStatement(ExprPtr expr)
-            : Statement(EXPR_STATEMENT), expr(expr) {
-        }
-    };
-
-    struct While : public Statement {
-        const vector<StatementPtr> conditionStatements;
-        ExprPtr condition;
-
-        const StatementPtr body;
-
-        While(ExprPtr condition, StatementPtr body)
-            : Statement(WHILE), condition(condition), body(body) {
-        }
-
-        While(llvm::ArrayRef<StatementPtr> conditionStatements,
-              ExprPtr condition, StatementPtr body)
-            : Statement(WHILE), conditionStatements(conditionStatements),
-              condition(condition), body(body) {
-        }
-    };
-
-    struct Break : public Statement {
-        Break()
-            : Statement(BREAK) {
-        }
-    };
-
-    struct Continue : public Statement {
-        Continue()
-            : Statement(CONTINUE) {
-        }
-    };
-
-    struct For : public Statement {
-        const vector<IdentifierPtr> variables;
-        ExprPtr expr;
-        const StatementPtr body;
-        StatementPtr desugared;
-
-        For(llvm::ArrayRef<IdentifierPtr> variables,
-            ExprPtr expr,
-            StatementPtr body)
-            : Statement(FOR), variables(variables), expr(expr), body(body) {
-        }
-    };
-
-    struct ForeignStatement : public Statement {
-        const string moduleName;
-        EnvPtr foreignEnv;
-        const StatementPtr statement;
-
-        ForeignStatement(llvm::StringRef moduleName, StatementPtr statement)
-            : Statement(FOREIGN_STATEMENT), moduleName(moduleName),
-              statement(statement) {
-        }
-
-        ForeignStatement(EnvPtr foreignEnv, StatementPtr statement)
-            : Statement(FOREIGN_STATEMENT), foreignEnv(foreignEnv),
-              statement(statement) {
-        }
-
-        ForeignStatement(llvm::StringRef moduleName, EnvPtr foreignEnv,
-                         StatementPtr statement)
-            : Statement(FOREIGN_STATEMENT), moduleName(moduleName),
-              foreignEnv(foreignEnv), statement(statement) {
-        }
-
-        EnvPtr getEnv();
-    };
-
-    struct Try : public Statement {
-        const StatementPtr tryBlock;
-        const vector<CatchPtr> catchBlocks;
-        StatementPtr desugaredCatchBlock;
-
-        Try(StatementPtr tryBlock,
-            vector<CatchPtr> catchBlocks)
-            : Statement(TRY), tryBlock(tryBlock),
-              catchBlocks(catchBlocks) {
-        }
-    };
-
-    struct Catch : public ANode {
-        const IdentifierPtr exceptionVar;
-        ExprPtr exceptionType; // optional
-        const IdentifierPtr contextVar;
-        const StatementPtr body;
-
-        Catch(IdentifierPtr exceptionVar,
-              ExprPtr exceptionType,
-              IdentifierPtr contextVar,
-              StatementPtr body)
-            : ANode(CATCH), exceptionVar(exceptionVar),
-              exceptionType(exceptionType), contextVar(contextVar), body(body) {
-        }
-    };
-
-    struct Throw : public Statement {
-        const ExprPtr expr;
-        const ExprPtr context;
-        ExprPtr desugaredExpr;
-        ExprPtr desugaredContext;
-
-        Throw(ExprPtr expr, ExprPtr context)
-            : Statement(THROW), expr(expr), context(context) {
-        }
-    };
-
-    struct StaticFor : public Statement {
-        const IdentifierPtr variable;
-        const ExprListPtr values;
-        const StatementPtr body;
-
-        bool clonesInitialized;
-        vector<StatementPtr> clonedBodies;
-
-        StaticFor(IdentifierPtr variable,
-                  ExprListPtr values,
-                  StatementPtr body)
-            : Statement(STATIC_FOR), variable(variable), values(values),
-              body(body), clonesInitialized(false) {
-        }
-    };
-
-    struct Finally : public Statement {
-        const StatementPtr body;
-
-        explicit Finally(StatementPtr body) : Statement(FINALLY), body(body) {
-        }
-    };
-
-    struct OnError : public Statement {
-        const StatementPtr body;
-
-        explicit OnError(StatementPtr body) : Statement(ONERROR), body(body) {
-        }
-    };
-
-    struct Unreachable : public Statement {
-        Unreachable()
-            : Statement(UNREACHABLE) {
-        }
-    };
-
-    struct EvalStatement : public Statement {
-        ExprListPtr args;
-        vector<StatementPtr> value;
-        bool evaled: 1;
-
-        EvalStatement(ExprListPtr args)
-            : Statement(EVAL_STATEMENT), args(args), evaled(false) {
-        }
-    };
-
-    struct StaticAssertStatement : public Statement {
-        const ExprPtr cond;
-        const ExprListPtr message;
-
-        StaticAssertStatement(ExprPtr cond, ExprListPtr message)
-            : Statement(STATIC_ASSERT_STATEMENT), cond(cond), message(message) {
-        }
-    };
-
-    //
-    // Code
-    //
-
-    enum ValueTempness {
-        TEMPNESS_DONTCARE,
-        TEMPNESS_LVALUE,
-        TEMPNESS_RVALUE,
-        TEMPNESS_FORWARD
-    };
-
-    struct FormalArg : public ANode {
-        const IdentifierPtr name;
-        ExprPtr type;
-        ValueTempness tempness;
-        ExprPtr asType;
-        bool varArg: 1;
-
-        FormalArg(IdentifierPtr name, ExprPtr type)
-            : ANode(FORMAL_ARG), name(name), type(type),
-              tempness(TEMPNESS_DONTCARE), varArg(false) {
-        }
-
-        FormalArg(IdentifierPtr name, ExprPtr type, ValueTempness tempness)
-            : ANode(FORMAL_ARG), name(name), type(type),
-              tempness(tempness), varArg(false) {
-        }
-
-        FormalArg(IdentifierPtr name, ExprPtr type, ValueTempness tempness, bool varArg)
-            : ANode(FORMAL_ARG), name(name), type(type),
-              tempness(tempness), varArg(varArg) {
-        }
-
-        FormalArg(IdentifierPtr name, ExprPtr type, ValueTempness tempness, ExprPtr asType)
-            : ANode(FORMAL_ARG), name(name), type(type),
-              tempness(tempness), asType(asType), varArg(false) {
-        }
-
-        FormalArg(IdentifierPtr name, ExprPtr type, ValueTempness tempness, ExprPtr asType, bool varArg)
-            : ANode(FORMAL_ARG), name(name), type(type),
-              tempness(tempness), asType(asType), varArg(varArg) {
-        }
-    };
-
-    struct ReturnSpec : public ANode {
-        const ExprPtr type;
-        const IdentifierPtr name;
-
-        ReturnSpec(ExprPtr type)
-            : ANode(RETURN_SPEC), type(type) {
-        }
-
-        ReturnSpec(ExprPtr type, IdentifierPtr name)
-            : ANode(RETURN_SPEC), type(type), name(name) {
-        }
-    };
-
-    struct PatternVar {
-        IdentifierPtr name;
-        bool isMulti: 1;
-
-        PatternVar(bool isMulti, IdentifierPtr name)
-            : name(name), isMulti(isMulti) {
-        }
-
-        PatternVar()
-            : isMulti(false) {
-        }
-    };
+    Goto(IdentifierPtr labelName) : Statement(GOTO), labelName(labelName) {}
+};
+
+enum ReturnKind { RETURN_VALUE, RETURN_REF, RETURN_FORWARD };
+
+struct Return : public Statement {
+    const ExprListPtr values;
+    const ReturnKind returnKind : 3;
+    bool isExprReturn : 1;
+    bool isReturnSpecs : 1;
+
+    Return(ReturnKind returnKind, ExprListPtr values)
+        : Statement(RETURN), values(values), returnKind(returnKind),
+          isExprReturn(false), isReturnSpecs(false) {}
+
+    Return(ReturnKind returnKind, ExprListPtr values, bool exprRet)
+        : Statement(RETURN), values(values), returnKind(returnKind),
+          isExprReturn(exprRet), isReturnSpecs(false) {}
+};
+
+struct If : public Statement {
+    vector<StatementPtr> conditionStatements;
+    ExprPtr condition;
+
+    StatementPtr thenPart, elsePart;
+
+    If(const ExprPtr &condition, StatementPtr thenPart)
+        : Statement(IF), condition(condition), thenPart(thenPart) {}
+
+    If(ExprPtr condition, StatementPtr thenPart, StatementPtr elsePart)
+        : Statement(IF), condition(condition), thenPart(thenPart),
+          elsePart(elsePart) {}
+
+    If(llvm::ArrayRef<StatementPtr> conditionStatements, ExprPtr condition,
+       StatementPtr thenPart)
+        : Statement(IF), conditionStatements(conditionStatements),
+          condition(condition), thenPart(thenPart) {}
+
+    If(llvm::ArrayRef<StatementPtr> conditionStatements, ExprPtr condition,
+       StatementPtr thenPart, StatementPtr elsePart)
+        : Statement(IF), conditionStatements(conditionStatements),
+          condition(condition), thenPart(thenPart), elsePart(elsePart) {}
+};
+
+struct Switch : public Statement {
+    vector<StatementPtr> exprStatements;
+    ExprPtr expr;
+    vector<CaseBlockPtr> caseBlocks;
+    StatementPtr defaultCase;
+
+    StatementPtr desugared;
+
+    Switch(llvm::ArrayRef<StatementPtr> exprStatements, ExprPtr expr,
+           llvm::ArrayRef<CaseBlockPtr> caseBlocks, StatementPtr defaultCase)
+        : Statement(SWITCH), exprStatements(exprStatements), expr(expr),
+          caseBlocks(caseBlocks), defaultCase(defaultCase) {}
+
+    Switch(ExprPtr expr, llvm::ArrayRef<CaseBlockPtr> caseBlocks,
+           StatementPtr defaultCase)
+        : Statement(SWITCH), expr(expr), caseBlocks(caseBlocks),
+          defaultCase(defaultCase) {}
+};
+
+struct CaseBlock : public ANode {
+    const ExprListPtr caseLabels;
+    const StatementPtr body;
+
+    CaseBlock(ExprListPtr caseLabels, StatementPtr body)
+        : ANode(CASE_BLOCK), caseLabels(caseLabels), body(body) {}
+};
+
+struct ExprStatement : public Statement {
+    ExprPtr expr;
+
+    ExprStatement(ExprPtr expr) : Statement(EXPR_STATEMENT), expr(expr) {}
+};
+
+struct While : public Statement {
+    const vector<StatementPtr> conditionStatements;
+    ExprPtr condition;
+
+    const StatementPtr body;
+
+    While(ExprPtr condition, StatementPtr body)
+        : Statement(WHILE), condition(condition), body(body) {}
+
+    While(llvm::ArrayRef<StatementPtr> conditionStatements, ExprPtr condition,
+          StatementPtr body)
+        : Statement(WHILE), conditionStatements(conditionStatements),
+          condition(condition), body(body) {}
+};
+
+struct Break : public Statement {
+    Break() : Statement(BREAK) {}
+};
+
+struct Continue : public Statement {
+    Continue() : Statement(CONTINUE) {}
+};
+
+struct For : public Statement {
+    const vector<IdentifierPtr> variables;
+    ExprPtr expr;
+    const StatementPtr body;
+    StatementPtr desugared;
+
+    For(llvm::ArrayRef<IdentifierPtr> variables, ExprPtr expr,
+        StatementPtr body)
+        : Statement(FOR), variables(variables), expr(expr), body(body) {}
+};
+
+struct ForeignStatement : public Statement {
+    const string moduleName;
+    EnvPtr foreignEnv;
+    const StatementPtr statement;
+
+    ForeignStatement(llvm::StringRef moduleName, StatementPtr statement)
+        : Statement(FOREIGN_STATEMENT), moduleName(moduleName),
+          statement(statement) {}
+
+    ForeignStatement(EnvPtr foreignEnv, StatementPtr statement)
+        : Statement(FOREIGN_STATEMENT), foreignEnv(foreignEnv),
+          statement(statement) {}
+
+    ForeignStatement(llvm::StringRef moduleName, EnvPtr foreignEnv,
+                     StatementPtr statement)
+        : Statement(FOREIGN_STATEMENT), moduleName(moduleName),
+          foreignEnv(foreignEnv), statement(statement) {}
+
+    EnvPtr getEnv();
+};
+
+struct Try : public Statement {
+    const StatementPtr tryBlock;
+    const vector<CatchPtr> catchBlocks;
+    StatementPtr desugaredCatchBlock;
+
+    Try(StatementPtr tryBlock, vector<CatchPtr> catchBlocks)
+        : Statement(TRY), tryBlock(tryBlock), catchBlocks(catchBlocks) {}
+};
+
+struct Catch : public ANode {
+    const IdentifierPtr exceptionVar;
+    ExprPtr exceptionType; // optional
+    const IdentifierPtr contextVar;
+    const StatementPtr body;
+
+    Catch(IdentifierPtr exceptionVar, ExprPtr exceptionType,
+          IdentifierPtr contextVar, StatementPtr body)
+        : ANode(CATCH), exceptionVar(exceptionVar),
+          exceptionType(exceptionType), contextVar(contextVar), body(body) {}
+};
+
+struct Throw : public Statement {
+    const ExprPtr expr;
+    const ExprPtr context;
+    ExprPtr desugaredExpr;
+    ExprPtr desugaredContext;
+
+    Throw(ExprPtr expr, ExprPtr context)
+        : Statement(THROW), expr(expr), context(context) {}
+};
+
+struct StaticFor : public Statement {
+    const IdentifierPtr variable;
+    const ExprListPtr values;
+    const StatementPtr body;
+
+    bool clonesInitialized;
+    vector<StatementPtr> clonedBodies;
+
+    StaticFor(IdentifierPtr variable, ExprListPtr values, StatementPtr body)
+        : Statement(STATIC_FOR), variable(variable), values(values), body(body),
+          clonesInitialized(false) {}
+};
+
+struct Finally : public Statement {
+    const StatementPtr body;
+
+    explicit Finally(StatementPtr body) : Statement(FINALLY), body(body) {}
+};
+
+struct OnError : public Statement {
+    const StatementPtr body;
+
+    explicit OnError(StatementPtr body) : Statement(ONERROR), body(body) {}
+};
+
+struct Unreachable : public Statement {
+    Unreachable() : Statement(UNREACHABLE) {}
+};
+
+struct EvalStatement : public Statement {
+    ExprListPtr args;
+    vector<StatementPtr> value;
+    bool evaled : 1;
+
+    EvalStatement(ExprListPtr args)
+        : Statement(EVAL_STATEMENT), args(args), evaled(false) {}
+};
+
+struct StaticAssertStatement : public Statement {
+    const ExprPtr cond;
+    const ExprListPtr message;
+
+    StaticAssertStatement(ExprPtr cond, ExprListPtr message)
+        : Statement(STATIC_ASSERT_STATEMENT), cond(cond), message(message) {}
+};
+
+//
+// Code
+//
+
+enum ValueTempness {
+    TEMPNESS_DONTCARE,
+    TEMPNESS_LVALUE,
+    TEMPNESS_RVALUE,
+    TEMPNESS_FORWARD
+};
+
+struct FormalArg : public ANode {
+    const IdentifierPtr name;
+    ExprPtr type;
+    ValueTempness tempness;
+    ExprPtr asType;
+    bool varArg : 1;
+
+    FormalArg(IdentifierPtr name, ExprPtr type)
+        : ANode(FORMAL_ARG), name(name), type(type),
+          tempness(TEMPNESS_DONTCARE), varArg(false) {}
+
+    FormalArg(IdentifierPtr name, ExprPtr type, ValueTempness tempness)
+        : ANode(FORMAL_ARG), name(name), type(type), tempness(tempness),
+          varArg(false) {}
+
+    FormalArg(IdentifierPtr name, ExprPtr type, ValueTempness tempness,
+              bool varArg)
+        : ANode(FORMAL_ARG), name(name), type(type), tempness(tempness),
+          varArg(varArg) {}
+
+    FormalArg(IdentifierPtr name, ExprPtr type, ValueTempness tempness,
+              ExprPtr asType)
+        : ANode(FORMAL_ARG), name(name), type(type), tempness(tempness),
+          asType(asType), varArg(false) {}
+
+    FormalArg(IdentifierPtr name, ExprPtr type, ValueTempness tempness,
+              ExprPtr asType, bool varArg)
+        : ANode(FORMAL_ARG), name(name), type(type), tempness(tempness),
+          asType(asType), varArg(varArg) {}
+};
+
+struct ReturnSpec : public ANode {
+    const ExprPtr type;
+    const IdentifierPtr name;
+
+    ReturnSpec(ExprPtr type) : ANode(RETURN_SPEC), type(type) {}
+
+    ReturnSpec(ExprPtr type, IdentifierPtr name)
+        : ANode(RETURN_SPEC), type(type), name(name) {}
+};
+
+struct PatternVar {
+    IdentifierPtr name;
+    bool isMulti : 1;
+
+    PatternVar(bool isMulti, IdentifierPtr name)
+        : name(name), isMulti(isMulti) {}
+
+    PatternVar() : isMulti(false) {}
+};
+
+struct LLVMCode : ANode {
+    const string body;
+
+    LLVMCode(llvm::StringRef body) : ANode(LLVM_CODE), body(body) {}
+};
+
+struct Code : public ANode {
+    vector<PatternVar> patternVars;
+    ExprPtr predicate;
+    vector<FormalArgPtr> formalArgs;
+    vector<ReturnSpecPtr> returnSpecs;
+    ReturnSpecPtr varReturnSpec;
+    StatementPtr body;
+    LLVMCodePtr llvmBody;
+    bool hasVarArg : 1;
+    bool returnSpecsDeclared : 1;
+
+    Code() : ANode(CODE), hasVarArg(false), returnSpecsDeclared(false) {}
+
+    Code(llvm::ArrayRef<PatternVar> patternVars, ExprPtr predicate,
+         llvm::ArrayRef<FormalArgPtr> formalArgs,
+         llvm::ArrayRef<ReturnSpecPtr> returnSpecs, ReturnSpecPtr varReturnSpec,
+         StatementPtr body)
+        : ANode(CODE), patternVars(patternVars), predicate(predicate),
+          formalArgs(formalArgs), returnSpecs(returnSpecs),
+          varReturnSpec(varReturnSpec), body(body), hasVarArg(false),
+          returnSpecsDeclared(false) {}
+
+    bool hasReturnSpecs() { return returnSpecsDeclared; }
+
+    bool hasNamedReturns() {
+        return hasReturnSpecs() &&
+               ((!returnSpecs.empty() && returnSpecs[0]->name != nullptr) ||
+                (varReturnSpec != nullptr && varReturnSpec->name != nullptr));
+    }
 
-    struct LLVMCode : ANode {
-        const string body;
+    bool isLLVMBody() { return llvmBody.ptr() != nullptr; }
 
-        LLVMCode(llvm::StringRef body)
-            : ANode(LLVM_CODE), body(body) {
-        }
-    };
-
-    struct Code : public ANode {
-        vector<PatternVar> patternVars;
-        ExprPtr predicate;
-        vector<FormalArgPtr> formalArgs;
-        vector<ReturnSpecPtr> returnSpecs;
-        ReturnSpecPtr varReturnSpec;
-        StatementPtr body;
-        LLVMCodePtr llvmBody;
-        bool hasVarArg: 1;
-        bool returnSpecsDeclared: 1;
-
-        Code()
-            : ANode(CODE), hasVarArg(false), returnSpecsDeclared(false) {
-        }
+    bool hasBody() { return body.ptr() || isLLVMBody(); }
+};
 
-        Code(llvm::ArrayRef<PatternVar> patternVars,
-             ExprPtr predicate,
-             llvm::ArrayRef<FormalArgPtr> formalArgs,
-             llvm::ArrayRef<ReturnSpecPtr> returnSpecs,
-             ReturnSpecPtr varReturnSpec,
-             StatementPtr body)
-            : ANode(CODE), patternVars(patternVars), predicate(predicate),
-              formalArgs(formalArgs),
-              returnSpecs(returnSpecs), varReturnSpec(varReturnSpec),
-              body(body),
-              hasVarArg(false), returnSpecsDeclared(false) {
-        }
+//
+// Visibility
+//
 
-        bool hasReturnSpecs() {
-            return returnSpecsDeclared;
-        }
+enum Visibility { VISIBILITY_UNDEFINED, PUBLIC, PRIVATE };
 
-        bool hasNamedReturns() {
-            return hasReturnSpecs() && (
-                       (!returnSpecs.empty() && returnSpecs[0]->name != nullptr)
-                       || (varReturnSpec != nullptr && varReturnSpec->name != nullptr));
-        }
+//
+// TopLevelItem
+//
 
-        bool isLLVMBody() {
-            return llvmBody.ptr() != nullptr;
-        }
+struct TopLevelItem : public ANode {
+    Module *const module;
+    IdentifierPtr name;          // for named top level items
+    const Visibility visibility; // valid only if name != nullptr
 
-        bool hasBody() {
-            return body.ptr() || isLLVMBody();
-        }
-    };
-
-    //
-    // Visibility
-    //
-
-    enum Visibility {
-        VISIBILITY_UNDEFINED,
-        PUBLIC,
-        PRIVATE
-    };
+    EnvPtr env;
 
-    //
-    // TopLevelItem
-    //
+    TopLevelItem(ObjectKind objKind, Module *module,
+                 Visibility visibility = VISIBILITY_UNDEFINED)
+        : ANode(objKind), module(module), visibility(visibility) {}
 
-    struct TopLevelItem : public ANode {
-        Module *const module;
-        IdentifierPtr name; // for named top level items
-        const Visibility visibility; // valid only if name != nullptr
+    TopLevelItem(ObjectKind objKind, Module *module, IdentifierPtr name,
+                 Visibility visibility)
+        : ANode(objKind), module(module), name(name), visibility(visibility) {}
+};
 
-        EnvPtr env;
+struct RecordDecl : public TopLevelItem {
+    const vector<PatternVar> patternVars;
+    const ExprPtr predicate;
 
-        TopLevelItem(ObjectKind objKind, Module *module, Visibility visibility = VISIBILITY_UNDEFINED)
-            : ANode(objKind), module(module), visibility(visibility) {
-        }
-
-        TopLevelItem(ObjectKind objKind, Module *module, IdentifierPtr name, Visibility visibility)
-            : ANode(objKind), module(module), name(name), visibility(visibility) {
-        }
-    };
+    const vector<IdentifierPtr> params;
 
-    struct RecordDecl : public TopLevelItem {
-        const vector<PatternVar> patternVars;
-        const ExprPtr predicate;
+    const IdentifierPtr varParam;
 
-        const vector<IdentifierPtr> params;
+    RecordBodyPtr body;
 
-        const IdentifierPtr varParam;
+    vector<OverloadPtr> overloads;
 
-        RecordBodyPtr body;
+    LambdaPtr lambda;
 
-        vector<OverloadPtr> overloads;
+    bool builtinOverloadInitialized : 1;
 
-        LambdaPtr lambda;
+    RecordDecl(Module *module, Visibility visibility)
+        : TopLevelItem(RECORD_DECL, module, visibility),
+          builtinOverloadInitialized(false) {}
 
-        bool builtinOverloadInitialized: 1;
-
-        RecordDecl(Module *module, Visibility visibility)
-            : TopLevelItem(RECORD_DECL, module, visibility),
-              builtinOverloadInitialized(false) {
-        }
-
-        RecordDecl(Module *module, Visibility visibility,
+    RecordDecl(Module *module, Visibility visibility,
+               llvm::ArrayRef<PatternVar> patternVars, ExprPtr predicate,
+               llvm::ArrayRef<IdentifierPtr> params, IdentifierPtr varParam,
+               RecordBodyPtr body)
+        : TopLevelItem(RECORD_DECL, module, visibility),
+          patternVars(patternVars), predicate(predicate), params(params),
+          varParam(varParam), body(body), builtinOverloadInitialized(false) {}
+
+    RecordDecl(Module *module, IdentifierPtr name, Visibility visibility,
+               llvm::ArrayRef<PatternVar> patternVars, ExprPtr predicate,
+               llvm::ArrayRef<IdentifierPtr> params, IdentifierPtr varParam,
+               RecordBodyPtr body)
+        : TopLevelItem(RECORD_DECL, module, name, visibility),
+          patternVars(patternVars), predicate(predicate), params(params),
+          varParam(varParam), body(body), builtinOverloadInitialized(false) {}
+};
+
+struct RecordBody : public ANode {
+    ExprListPtr computed;                // valid if isComputed == true
+    const vector<RecordFieldPtr> fields; // valid if isComputed == false
+    bool isComputed : 1;
+    const bool hasVarField : 1;
+
+    RecordBody(ExprListPtr computed)
+        : ANode(RECORD_BODY), computed(computed), isComputed(true),
+          hasVarField(false) {}
+
+    RecordBody(llvm::ArrayRef<RecordFieldPtr> fields)
+        : ANode(RECORD_BODY), fields(fields), isComputed(false),
+          hasVarField(false) {}
+
+    RecordBody(llvm::ArrayRef<RecordFieldPtr> fields, bool hasVarField)
+        : ANode(RECORD_BODY), fields(fields), isComputed(false),
+          hasVarField(hasVarField) {}
+};
+
+struct RecordField : public ANode {
+    const IdentifierPtr name;
+    const ExprPtr type;
+    bool varField : 1;
+
+    RecordField(IdentifierPtr name, ExprPtr type)
+        : ANode(RECORD_FIELD), name(name), type(type), varField(false) {}
+};
+
+struct VariantDecl : public TopLevelItem {
+    const vector<PatternVar> patternVars;
+    const ExprPtr predicate;
+
+    const vector<IdentifierPtr> params;
+    const IdentifierPtr varParam;
+
+    const ExprListPtr defaultInstances;
+
+    vector<InstanceDeclPtr> instances;
+
+    vector<OverloadPtr> overloads;
+
+    const bool open : 1;
+
+    VariantDecl(Module *module, IdentifierPtr name, Visibility visibility,
+                llvm::ArrayRef<PatternVar> patternVars, ExprPtr predicate,
+                llvm::ArrayRef<IdentifierPtr> params, IdentifierPtr varParam,
+                bool open, ExprListPtr defaultInstances)
+        : TopLevelItem(VARIANT_DECL, module, name, visibility),
+          patternVars(patternVars), predicate(predicate), params(params),
+          varParam(varParam), defaultInstances(defaultInstances), open(open) {}
+};
+
+struct InstanceDecl : public TopLevelItem {
+    const vector<PatternVar> patternVars;
+    const ExprPtr predicate;
+    const ExprPtr target;
+    const ExprListPtr members;
+
+    InstanceDecl(Module *module, llvm::ArrayRef<PatternVar> patternVars,
+                 ExprPtr predicate, ExprPtr target, ExprListPtr members)
+        : TopLevelItem(INSTANCE_DECL, module), patternVars(patternVars),
+          predicate(predicate), target(target), members(members) {}
+};
+
+enum InlineAttribute { IGNORE, INLINE, FORCE_INLINE, NEVER_INLINE };
+
+struct Overload : public TopLevelItem {
+    const ExprPtr target;
+    const CodePtr code;
+
+    // pre-computed patterns for matchInvoke
+    vector<PatternCellPtr> cells;
+    vector<MultiPatternCellPtr> multiCells;
+    PatternPtr callablePattern;
+    vector<PatternPtr> argPatterns;
+    MultiPatternPtr varArgPattern;
+    InlineAttribute isInline : 3;
+    int patternsInitializedState : 2; // 0:notinit, -1:initing, +1:inited
+    bool callByName : 1;
+    bool nameIsPattern : 1;
+    bool hasAsConversion : 1;
+    bool isDefault : 1;
+
+    Overload(Module *module, ExprPtr target, CodePtr code, bool callByName,
+             InlineAttribute isInline)
+        : TopLevelItem(OVERLOAD, module), target(target), code(code),
+          isInline(isInline), patternsInitializedState(0),
+          callByName(callByName), nameIsPattern(false), hasAsConversion(false),
+          isDefault(false) {}
+
+    Overload(Module *module, ExprPtr target, CodePtr code, bool callByName,
+             InlineAttribute isInline, bool hasAsConversion)
+        : TopLevelItem(OVERLOAD, module), target(target), code(code),
+          isInline(isInline), patternsInitializedState(0),
+          callByName(callByName), nameIsPattern(false),
+          hasAsConversion(hasAsConversion), isDefault(false) {}
+};
+
+struct Procedure : public TopLevelItem {
+    const OverloadPtr interface;
+
+    OverloadPtr singleOverload;
+    vector<OverloadPtr> overloads;
+    ObjectTablePtr evaluatorCache; // HACK: used only for predicates
+    ProcedureMono mono;
+    LambdaPtr lambda;
+
+    const bool privateOverload : 1;
+
+    Procedure(Module *module, IdentifierPtr name, Visibility visibility,
+              bool privateOverload);
+
+    Procedure(Module *module, IdentifierPtr name, Visibility visibility,
+              bool privateOverload, OverloadPtr interface);
+
+    ~Procedure();
+};
+
+struct IntrinsicInstance {
+    llvm::Function *function;
+    MultiPValuePtr outputTypes;
+    std::string error;
+};
+
+struct IntrinsicSymbol : public TopLevelItem {
+    llvm::Intrinsic::ID id;
+    map<vector<TypePtr>, IntrinsicInstance> instances;
+
+    IntrinsicSymbol(Module *module, IdentifierPtr name, llvm::Intrinsic::ID id)
+        : TopLevelItem(INTRINSIC, module, name, PUBLIC), id(id) {}
+};
+
+struct NewTypeDecl : public TopLevelItem {
+    const ExprPtr expr;
+    NewTypePtr type;
+    TypePtr baseType;
+    bool initialized : 1;
+
+    NewTypeDecl(Module *module, IdentifierPtr name, Visibility visibility,
+                ExprPtr expr)
+        : TopLevelItem(NEW_TYPE_DECL, module, name, visibility), expr(expr),
+          initialized(false) {}
+};
+
+struct EnumDecl : public TopLevelItem {
+    const vector<PatternVar> patternVars;
+    const ExprPtr predicate;
+
+    vector<EnumMemberPtr> members;
+    TypePtr type;
+
+    EnumDecl(Module *module, IdentifierPtr name, Visibility visibility,
+             llvm::ArrayRef<PatternVar> patternVars, ExprPtr predicate)
+        : TopLevelItem(ENUM_DECL, module, name, visibility),
+          patternVars(patternVars), predicate(predicate) {}
+
+    EnumDecl(Module *module, IdentifierPtr name, Visibility visibility,
+             llvm::ArrayRef<PatternVar> patternVars, ExprPtr predicate,
+             llvm::ArrayRef<EnumMemberPtr> members)
+        : TopLevelItem(ENUM_DECL, module, name, visibility),
+          patternVars(patternVars), predicate(predicate), members(members) {}
+};
+
+struct EnumMember : public ANode {
+    const IdentifierPtr name;
+    TypePtr type;
+    int index;
+
+    EnumMember(IdentifierPtr name)
+        : ANode(ENUM_MEMBER), name(name), index(-1) {}
+};
+
+struct GlobalVariable : public TopLevelItem {
+    const vector<PatternVar> patternVars;
+    const ExprPtr predicate;
+
+    const vector<IdentifierPtr> params;
+    const IdentifierPtr varParam;
+    const ExprPtr expr;
+
+    ObjectTablePtr instances;
+
+    GlobalVariable(Module *module, IdentifierPtr name, Visibility visibility,
                    llvm::ArrayRef<PatternVar> patternVars, ExprPtr predicate,
                    llvm::ArrayRef<IdentifierPtr> params, IdentifierPtr varParam,
-                   RecordBodyPtr body)
-            : TopLevelItem(RECORD_DECL, module, visibility),
-              patternVars(patternVars),
-              predicate(predicate),
-              params(params),
-              varParam(varParam),
-              body(body),
-              builtinOverloadInitialized(false) {
-        }
-
-        RecordDecl(Module *module, IdentifierPtr name,
-                   Visibility visibility,
-                   llvm::ArrayRef<PatternVar> patternVars,
-                   ExprPtr predicate,
-                   llvm::ArrayRef<IdentifierPtr> params,
-                   IdentifierPtr varParam,
-                   RecordBodyPtr body)
-            : TopLevelItem(RECORD_DECL, module, name, visibility),
-              patternVars(patternVars), predicate(predicate),
-              params(params), varParam(varParam), body(body),
-              builtinOverloadInitialized(false) {
-        }
-    };
-
-    struct RecordBody : public ANode {
-        ExprListPtr computed; // valid if isComputed == true
-        const vector<RecordFieldPtr> fields; // valid if isComputed == false
-        bool isComputed: 1;
-        const bool hasVarField: 1;
-
-        RecordBody(ExprListPtr computed)
-            : ANode(RECORD_BODY), computed(computed), isComputed(true),
-              hasVarField(false) {
-        }
-
-        RecordBody(llvm::ArrayRef<RecordFieldPtr> fields)
-            : ANode(RECORD_BODY), fields(fields), isComputed(false),
-              hasVarField(false) {
-        }
-
-        RecordBody(llvm::ArrayRef<RecordFieldPtr> fields, bool hasVarField)
-            : ANode(RECORD_BODY), fields(fields), isComputed(false),
-              hasVarField(hasVarField) {
-        }
-    };
-
-    struct RecordField : public ANode {
-        const IdentifierPtr name;
-        const ExprPtr type;
-        bool varField: 1;
-
-        RecordField(IdentifierPtr name, ExprPtr type)
-            : ANode(RECORD_FIELD), name(name), type(type), varField(false) {
-        }
-    };
-
-    struct VariantDecl : public TopLevelItem {
-        const vector<PatternVar> patternVars;
-        const ExprPtr predicate;
-
-        const vector<IdentifierPtr> params;
-        const IdentifierPtr varParam;
-
-        const ExprListPtr defaultInstances;
-
-        vector<InstanceDeclPtr> instances;
-
-        vector<OverloadPtr> overloads;
-
-        const bool open: 1;
-
-        VariantDecl(Module *module, IdentifierPtr name,
-                    Visibility visibility,
-                    llvm::ArrayRef<PatternVar> patternVars,
-                    ExprPtr predicate,
-                    llvm::ArrayRef<IdentifierPtr> params,
-                    IdentifierPtr varParam,
-                    bool open,
-                    ExprListPtr defaultInstances)
-            : TopLevelItem(VARIANT_DECL, module, name, visibility),
-              patternVars(patternVars), predicate(predicate),
-              params(params), varParam(varParam),
-              defaultInstances(defaultInstances),
-              open(open) {
-        }
-    };
-
-    struct InstanceDecl : public TopLevelItem {
-        const vector<PatternVar> patternVars;
-        const ExprPtr predicate;
-        const ExprPtr target;
-        const ExprListPtr members;
-
-        InstanceDecl(Module *module, llvm::ArrayRef<PatternVar> patternVars,
-                     ExprPtr predicate,
-                     ExprPtr target,
-                     ExprListPtr members)
-            : TopLevelItem(INSTANCE_DECL, module), patternVars(patternVars),
-              predicate(predicate), target(target), members(members) {
-        }
-    };
-
-    enum InlineAttribute {
-        IGNORE,
-        INLINE,
-        FORCE_INLINE,
-        NEVER_INLINE
-    };
-
-    struct Overload : public TopLevelItem {
-        const ExprPtr target;
-        const CodePtr code;
-
-        // pre-computed patterns for matchInvoke
-        vector<PatternCellPtr> cells;
-        vector<MultiPatternCellPtr> multiCells;
-        PatternPtr callablePattern;
-        vector<PatternPtr> argPatterns;
-        MultiPatternPtr varArgPattern;
-        InlineAttribute isInline: 3;
-        int patternsInitializedState: 2; // 0:notinit, -1:initing, +1:inited
-        bool callByName: 1;
-        bool nameIsPattern: 1;
-        bool hasAsConversion: 1;
-        bool isDefault: 1;
-
-        Overload(Module *module, ExprPtr target,
-                 CodePtr code,
-                 bool callByName,
-                 InlineAttribute isInline)
-            : TopLevelItem(OVERLOAD, module), target(target), code(code),
-              isInline(isInline), patternsInitializedState(0),
-              callByName(callByName), nameIsPattern(false),
-              hasAsConversion(false), isDefault(false) {
-        }
-
-        Overload(Module *module, ExprPtr target,
-                 CodePtr code,
-                 bool callByName,
-                 InlineAttribute isInline,
-                 bool hasAsConversion)
-            : TopLevelItem(OVERLOAD, module), target(target), code(code),
-              isInline(isInline), patternsInitializedState(0),
-              callByName(callByName), nameIsPattern(false),
-              hasAsConversion(hasAsConversion), isDefault(false) {
-        }
-    };
-
-    struct Procedure : public TopLevelItem {
-        const OverloadPtr interface;
-
-        OverloadPtr singleOverload;
-        vector<OverloadPtr> overloads;
-        ObjectTablePtr evaluatorCache; // HACK: used only for predicates
-        ProcedureMono mono;
-        LambdaPtr lambda;
-
-        const bool privateOverload: 1;
-
-        Procedure(Module *module, IdentifierPtr name, Visibility visibility, bool privateOverload);
-
-        Procedure(Module *module, IdentifierPtr name, Visibility visibility, bool privateOverload,
-                  OverloadPtr interface);
-
-        ~Procedure();
-    };
-
-    struct IntrinsicInstance {
-        llvm::Function *function;
-        MultiPValuePtr outputTypes;
-        std::string error;
-    };
-
-    struct IntrinsicSymbol : public TopLevelItem {
-        llvm::Intrinsic::ID id;
-        map<vector<TypePtr>, IntrinsicInstance> instances;
-
-        IntrinsicSymbol(Module *module, IdentifierPtr name, llvm::Intrinsic::ID id)
-            : TopLevelItem(INTRINSIC, module, name, PUBLIC), id(id) {
-        }
-    };
-
-    struct NewTypeDecl : public TopLevelItem {
-        const ExprPtr expr;
-        NewTypePtr type;
-        TypePtr baseType;
-        bool initialized: 1;
-
-        NewTypeDecl(Module *module, IdentifierPtr name,
-                    Visibility visibility,
-                    ExprPtr expr)
-            : TopLevelItem(NEW_TYPE_DECL, module, name, visibility), expr(expr),
-              initialized(false) {
-        }
-    };
-
-    struct EnumDecl : public TopLevelItem {
-        const vector<PatternVar> patternVars;
-        const ExprPtr predicate;
-
-        vector<EnumMemberPtr> members;
-        TypePtr type;
-
-        EnumDecl(Module *module, IdentifierPtr name, Visibility visibility,
-                 llvm::ArrayRef<PatternVar> patternVars, ExprPtr predicate)
-            : TopLevelItem(ENUM_DECL, module, name, visibility),
-              patternVars(patternVars), predicate(predicate) {
-        }
-
-        EnumDecl(Module *module, IdentifierPtr name, Visibility visibility,
-                 llvm::ArrayRef<PatternVar> patternVars, ExprPtr predicate,
-                 llvm::ArrayRef<EnumMemberPtr> members)
-            : TopLevelItem(ENUM_DECL, module, name, visibility),
-              patternVars(patternVars), predicate(predicate),
-              members(members) {
-        }
-    };
-
-    struct EnumMember : public ANode {
-        const IdentifierPtr name;
-        TypePtr type;
-        int index;
-
-        EnumMember(IdentifierPtr name)
-            : ANode(ENUM_MEMBER), name(name), index(-1) {
-        }
-    };
-
-    struct GlobalVariable : public TopLevelItem {
-        const vector<PatternVar> patternVars;
-        const ExprPtr predicate;
-
-        const vector<IdentifierPtr> params;
-        const IdentifierPtr varParam;
-        const ExprPtr expr;
-
-        ObjectTablePtr instances;
-
-        GlobalVariable(Module *module, IdentifierPtr name,
-                       Visibility visibility,
-                       llvm::ArrayRef<PatternVar> patternVars,
-                       ExprPtr predicate,
-                       llvm::ArrayRef<IdentifierPtr> params,
-                       IdentifierPtr varParam,
-                       ExprPtr expr);
-
-        ~GlobalVariable();
+                   ExprPtr expr);
 
-        bool hasParams() const {
-            return !params.empty() || (varParam.ptr() != nullptr);
-        }
-    };
+    ~GlobalVariable();
 
-    struct GVarInstance : public RefCounted {
-        const GlobalVariablePtr gvar;
-        const vector<ObjectPtr> params;
+    bool hasParams() const {
+        return !params.empty() || (varParam.ptr() != nullptr);
+    }
+};
 
-        ExprPtr expr;
-        EnvPtr env;
-        MultiPValuePtr analysis;
-        TypePtr type;
-        ValueHolderPtr staticGlobal;
-        llvm::GlobalVariable *llGlobal;
-        llvm::TrackingVH<llvm::MDNode> debugInfo;
+struct GVarInstance : public RefCounted {
+    const GlobalVariablePtr gvar;
+    const vector<ObjectPtr> params;
 
-        bool analyzing: 1;
+    ExprPtr expr;
+    EnvPtr env;
+    MultiPValuePtr analysis;
+    TypePtr type;
+    ValueHolderPtr staticGlobal;
+    llvm::GlobalVariable *llGlobal;
+    llvm::TrackingVH<llvm::MDNode> debugInfo;
 
-        GVarInstance(const GlobalVariablePtr &gvar,
-                     llvm::ArrayRef<ObjectPtr> params);
+    bool analyzing : 1;
 
-        ~GVarInstance();
+    GVarInstance(const GlobalVariablePtr &gvar,
+                 llvm::ArrayRef<ObjectPtr> params);
 
-        llvm::DIGlobalVariable getDebugInfo() { return llvm::DIGlobalVariable(debugInfo); }
-    };
+    ~GVarInstance();
 
-#define CALLING_CONV_MAP(XX) \
-    XX(CC_DEFAULT,  "AttributeCCall") \
-    XX(CC_STDCALL,  "AttributeStdCall") \
-    XX(CC_FASTCALL, "AttributeFastCall") \
-    XX(CC_THISCALL, "AttributeThisCall") \
-    XX(CC_LLVM,     "AttributeLLVMCall")
+    llvm::DIGlobalVariable *getDebugInfo() {
+        return llvm::dyn_cast_or_null<llvm::DIGlobalVariable>(
+            debugInfo.getValPtr());
+    }
+};
+
+#define CALLING_CONV_MAP(XX)                                                   \
+    XX(CC_DEFAULT, "AttributeCCall")                                           \
+    XX(CC_STDCALL, "AttributeStdCall")                                         \
+    XX(CC_FASTCALL, "AttributeFastCall")                                       \
+    XX(CC_THISCALL, "AttributeThisCall")                                       \
+    XX(CC_LLVM, "AttributeLLVMCall")
 #define CALLING_CONV_GEN(e, str) e,
 
-    enum CallingConv {
-        CALLING_CONV_MAP(CALLING_CONV_GEN)
-        CC_Count
-    };
+enum CallingConv { CALLING_CONV_MAP(CALLING_CONV_GEN) CC_Count };
 #undef CALLING_CONV_GEN
 
-    struct ExternalProcedure : public TopLevelItem {
-        vector<ExternalArgPtr> args;
-        ExprPtr returnType;
-        StatementPtr body;
-        ExprListPtr attributes;
-
-        llvm::SmallString<16> attrAsmLabel;
-
-        TypePtr returnType2;
-        TypePtr ptrType;
-
-        llvm::Function *llvmFunc;
-        llvm::TrackingVH<llvm::MDNode> debugInfo;
-
-        CallingConv callingConv: 4;
-        bool hasVarArgs: 1;
-        bool attributesVerified: 1;
-        bool attrDLLImport: 1;
-        bool attrDLLExport: 1;
-        bool analyzed: 1;
-        bool bodyCodegenned: 1;
-
-        ExternalProcedure(Module *module, Visibility visibility)
-            : TopLevelItem(EXTERNAL_PROCEDURE, module, visibility),
-              attributes(new ExprList()),
-              llvmFunc(nullptr), debugInfo(nullptr),
-              hasVarArgs(false),
-              attributesVerified(false),
-              analyzed(false), bodyCodegenned(false) {
-        }
-
-        ExternalProcedure(Module *module, IdentifierPtr name,
-                          Visibility visibility,
-                          llvm::ArrayRef<ExternalArgPtr> args,
-                          bool hasVarArgs,
-                          ExprPtr returnType,
-                          StatementPtr body,
-                          ExprListPtr attributes)
-            : TopLevelItem(EXTERNAL_PROCEDURE, module, name, visibility), args(args),
-              returnType(returnType), body(body),
-              attributes(attributes),
-              llvmFunc(nullptr), debugInfo(nullptr),
-              hasVarArgs(hasVarArgs),
-              attributesVerified(false),
-              analyzed(false), bodyCodegenned(false) {
-        }
-
-        llvm::DISubprogram getDebugInfo() { return llvm::DISubprogram(debugInfo); }
-    };
-
-    struct ExternalArg : public ANode {
-        const IdentifierPtr name;
-        const ExprPtr type;
-        TypePtr type2;
-
-        ExternalArg(IdentifierPtr name, ExprPtr type)
-            : ANode(EXTERNAL_ARG), name(name), type(type) {
-        }
-    };
-
-    struct ExternalVariable : public TopLevelItem {
-        ExprPtr type;
-        ExprListPtr attributes;
-
-        TypePtr type2;
-        llvm::GlobalVariable *llGlobal;
-        llvm::TrackingVH<llvm::MDNode> debugInfo;
-
-        bool attributesVerified: 1;
-        bool attrDLLImport: 1;
-        bool attrDLLExport: 1;
-
-        ExternalVariable(Module *module, Visibility visibility)
-            : TopLevelItem(EXTERNAL_VARIABLE, module, visibility),
-              attributes(new ExprList()),
-              llGlobal(nullptr), debugInfo(nullptr),
-              attributesVerified(false) {
-        }
-
-        ExternalVariable(Module *module, IdentifierPtr name,
-                         Visibility visibility,
-                         ExprPtr type,
-                         ExprListPtr attributes)
-            : TopLevelItem(EXTERNAL_VARIABLE, module, name, visibility),
-              type(type), attributes(attributes),
-              llGlobal(nullptr), debugInfo(nullptr),
-              attributesVerified(false) {
-        }
-
-        llvm::DIGlobalVariable getDebugInfo() { return llvm::DIGlobalVariable(debugInfo); }
-    };
-
-    struct EvalTopLevel : public TopLevelItem {
-        const ExprListPtr args;
-        vector<TopLevelItemPtr> value;
-        bool evaled: 1;
-
-        EvalTopLevel(Module *module, ExprListPtr args)
-            : TopLevelItem(EVAL_TOPLEVEL, module), args(args), evaled(false) {
-        }
-    };
-
-    struct StaticAssertTopLevel : public TopLevelItem {
-        ExprPtr cond;
-        ExprListPtr message;
-
-        StaticAssertTopLevel(Module *module, ExprPtr cond, ExprListPtr message)
-            : TopLevelItem(STATIC_ASSERT_TOP_LEVEL, module), cond(cond), message(message) {
-        }
-    };
-
-    //
-    // documentation
-    //
-
-    enum DocumentationAnnotation {
-        SectionAnnotation,
-        ModuleAnnotation,
-        OverloadAnnotation,
-        RecordAnnotion,
-        InvalidAnnotation
-    };
-
-    struct Documentation : public TopLevelItem {
-        const std::map<DocumentationAnnotation, string> annotation;
-        const std::string text;
-
-        Documentation(Module *module, const std::map<DocumentationAnnotation, string> &annotation,
-                      const std::string &text)
-            : TopLevelItem(DOCUMENTATION, module), annotation(annotation), text(text) {
-        }
-    };
-
-    //
-    // GlobalAlias
-    //
-
-    struct GlobalAlias : public TopLevelItem {
-        const vector<PatternVar> patternVars;
-        const ExprPtr predicate;
-
-        const vector<IdentifierPtr> params;
-        const IdentifierPtr varParam;
-        const ExprPtr expr;
-
-        vector<OverloadPtr> overloads;
-
-        GlobalAlias(Module *module, IdentifierPtr name,
-                    Visibility visibility,
-                    llvm::ArrayRef<PatternVar> patternVars,
-                    ExprPtr predicate,
-                    llvm::ArrayRef<IdentifierPtr> params,
-                    IdentifierPtr varParam,
-                    ExprPtr expr)
-            : TopLevelItem(GLOBAL_ALIAS, module, name, visibility),
-              patternVars(patternVars), predicate(predicate),
-              params(params), varParam(varParam), expr(expr) {
-        }
-
-        bool hasParams() const {
-            return !params.empty() || (varParam.ptr() != nullptr);
-        }
-    };
-
-    //
-    // Imports
-    //
-
-    enum ImportKind {
-        IMPORT_MODULE,
-        IMPORT_STAR,
-        IMPORT_MEMBERS
-    };
-
-    struct Import : public ANode {
-        const ImportKind importKind;
-        const DottedNamePtr dottedName;
-        Visibility visibility;
-        ModulePtr module;
-
-        Import(ImportKind importKind, const DottedNamePtr &dottedName)
-            : ANode(IMPORT), importKind(importKind), dottedName(dottedName),
-              visibility(PRIVATE) {
-        }
-    };
+struct ExternalProcedure : public TopLevelItem {
+    vector<ExternalArgPtr> args;
+    ExprPtr returnType;
+    StatementPtr body;
+    ExprListPtr attributes;
+
+    llvm::SmallString<16> attrAsmLabel;
+
+    TypePtr returnType2;
+    TypePtr ptrType;
+
+    llvm::Function *llvmFunc;
+    llvm::TrackingVH<llvm::MDNode> debugInfo;
+
+    CallingConv callingConv : 4;
+    bool hasVarArgs : 1;
+    bool attributesVerified : 1;
+    bool attrDLLImport : 1;
+    bool attrDLLExport : 1;
+    bool analyzed : 1;
+    bool bodyCodegenned : 1;
+
+    ExternalProcedure(Module *module, Visibility visibility)
+        : TopLevelItem(EXTERNAL_PROCEDURE, module, visibility),
+          attributes(new ExprList()), llvmFunc(nullptr), debugInfo(nullptr),
+          hasVarArgs(false), attributesVerified(false), analyzed(false),
+          bodyCodegenned(false) {}
+
+    ExternalProcedure(Module *module, IdentifierPtr name, Visibility visibility,
+                      llvm::ArrayRef<ExternalArgPtr> args, bool hasVarArgs,
+                      ExprPtr returnType, StatementPtr body,
+                      ExprListPtr attributes)
+        : TopLevelItem(EXTERNAL_PROCEDURE, module, name, visibility),
+          args(args), returnType(returnType), body(body),
+          attributes(attributes), llvmFunc(nullptr), debugInfo(nullptr),
+          hasVarArgs(hasVarArgs), attributesVerified(false), analyzed(false),
+          bodyCodegenned(false) {}
+
+    llvm::DISubprogram *getDebugInfo() {
+        return llvm::dyn_cast_or_null<llvm::DISubprogram>(
+            debugInfo.getValPtr());
+    }
+};
+
+struct ExternalArg : public ANode {
+    const IdentifierPtr name;
+    const ExprPtr type;
+    TypePtr type2;
+
+    ExternalArg(IdentifierPtr name, ExprPtr type)
+        : ANode(EXTERNAL_ARG), name(name), type(type) {}
+};
+
+struct ExternalVariable : public TopLevelItem {
+    ExprPtr type;
+    ExprListPtr attributes;
+
+    TypePtr type2;
+    llvm::GlobalVariable *llGlobal;
+    llvm::TrackingVH<llvm::MDNode> debugInfo;
+
+    bool attributesVerified : 1;
+    bool attrDLLImport : 1;
+    bool attrDLLExport : 1;
+
+    ExternalVariable(Module *module, Visibility visibility)
+        : TopLevelItem(EXTERNAL_VARIABLE, module, visibility),
+          attributes(new ExprList()), llGlobal(nullptr), debugInfo(nullptr),
+          attributesVerified(false) {}
+
+    ExternalVariable(Module *module, IdentifierPtr name, Visibility visibility,
+                     ExprPtr type, ExprListPtr attributes)
+        : TopLevelItem(EXTERNAL_VARIABLE, module, name, visibility), type(type),
+          attributes(attributes), llGlobal(nullptr), debugInfo(nullptr),
+          attributesVerified(false) {}
+
+    llvm::DIGlobalVariable *getDebugInfo() {
+        return llvm::dyn_cast_or_null<llvm::DIGlobalVariable>(
+            debugInfo.getValPtr());
+    }
+};
+
+struct EvalTopLevel : public TopLevelItem {
+    const ExprListPtr args;
+    vector<TopLevelItemPtr> value;
+    bool evaled : 1;
+
+    EvalTopLevel(Module *module, ExprListPtr args)
+        : TopLevelItem(EVAL_TOPLEVEL, module), args(args), evaled(false) {}
+};
+
+struct StaticAssertTopLevel : public TopLevelItem {
+    ExprPtr cond;
+    ExprListPtr message;
+
+    StaticAssertTopLevel(Module *module, ExprPtr cond, ExprListPtr message)
+        : TopLevelItem(STATIC_ASSERT_TOP_LEVEL, module), cond(cond),
+          message(message) {}
+};
+
+//
+// documentation
+//
+
+enum DocumentationAnnotation {
+    SectionAnnotation,
+    ModuleAnnotation,
+    OverloadAnnotation,
+    RecordAnnotation,
+    InvalidAnnotation
+};
+
+struct Documentation : public TopLevelItem {
+    const std::map<DocumentationAnnotation, string> annotation;
+    const std::string text;
+
+    Documentation(Module *module,
+                  const std::map<DocumentationAnnotation, string> &annotation,
+                  const std::string &text)
+        : TopLevelItem(DOCUMENTATION, module), annotation(annotation),
+          text(text) {}
+};
+
+//
+// GlobalAlias
+//
+
+struct GlobalAlias : public TopLevelItem {
+    const vector<PatternVar> patternVars;
+    const ExprPtr predicate;
+
+    const vector<IdentifierPtr> params;
+    const IdentifierPtr varParam;
+    const ExprPtr expr;
+
+    vector<OverloadPtr> overloads;
+
+    GlobalAlias(Module *module, IdentifierPtr name, Visibility visibility,
+                llvm::ArrayRef<PatternVar> patternVars, ExprPtr predicate,
+                llvm::ArrayRef<IdentifierPtr> params, IdentifierPtr varParam,
+                ExprPtr expr)
+        : TopLevelItem(GLOBAL_ALIAS, module, name, visibility),
+          patternVars(patternVars), predicate(predicate), params(params),
+          varParam(varParam), expr(expr) {}
+
+    bool hasParams() const {
+        return !params.empty() || (varParam.ptr() != nullptr);
+    }
+};
 
-    struct ImportModule : public Import {
-        const IdentifierPtr alias;
+//
+// Imports
+//
 
-        ImportModule(const DottedNamePtr &dottedName,
-                     const IdentifierPtr &alias)
-            : Import(IMPORT_MODULE, dottedName), alias(alias) {
-        }
-    };
+enum ImportKind { IMPORT_MODULE, IMPORT_STAR, IMPORT_MEMBERS };
 
-    struct ImportStar : public Import {
-        ImportStar(const DottedNamePtr &dottedName)
-            : Import(IMPORT_STAR, dottedName) {
-        }
-    };
+struct Import : public ANode {
+    const ImportKind importKind;
+    const DottedNamePtr dottedName;
+    Visibility visibility;
+    ModulePtr module;
 
-    struct ImportedMember {
-        Visibility visibility;
-        IdentifierPtr name;
-        IdentifierPtr alias;
+    Import(ImportKind importKind, const DottedNamePtr &dottedName)
+        : ANode(IMPORT), importKind(importKind), dottedName(dottedName),
+          visibility(PRIVATE) {}
+};
 
-        ImportedMember() = default;
+struct ImportModule : public Import {
+    const IdentifierPtr alias;
 
-        ImportedMember(Visibility visibility, const IdentifierPtr &name, const IdentifierPtr &alias)
-            : visibility(visibility), name(name), alias(alias) {
-        }
-    };
+    ImportModule(const DottedNamePtr &dottedName, const IdentifierPtr &alias)
+        : Import(IMPORT_MODULE, dottedName), alias(alias) {}
+};
 
-    struct ImportMembers : public Import {
-        vector<ImportedMember> members;
-        llvm::StringMap<IdentifierPtr> aliasMap;
+struct ImportStar : public Import {
+    ImportStar(const DottedNamePtr &dottedName)
+        : Import(IMPORT_STAR, dottedName) {}
+};
 
-        ImportMembers(const DottedNamePtr &dottedName)
-            : Import(IMPORT_MEMBERS, dottedName) {
-        }
-    };
+struct ImportedMember {
+    Visibility visibility;
+    IdentifierPtr name;
+    IdentifierPtr alias;
 
-    //
-    // Module
-    //
+    ImportedMember() = default;
 
-    struct ModuleDeclaration : public ANode {
-        const DottedNamePtr name;
-        const ExprListPtr attributes;
+    ImportedMember(Visibility visibility, const IdentifierPtr &name,
+                   const IdentifierPtr &alias)
+        : visibility(visibility), name(name), alias(alias) {}
+};
 
-        ModuleDeclaration(const DottedNamePtr &name, const ExprListPtr &attributes)
-            : ANode(MODULE_DECLARATION), name(name), attributes(attributes) {
-        }
-    };
-
-    struct ImportSet {
-        llvm::SmallVector<ObjectPtr, 2> values;
-
-        size_t size() const { return values.size(); }
-        bool empty() const { return values.empty(); }
-        ObjectPtr &operator[](size_t i) { return values[static_cast<unsigned>(i)]; }
-        ObjectPtr const &operator[](size_t i) const { return values[static_cast<unsigned>(i)]; }
-        ObjectPtr const *begin() const { return values.begin(); }
-        ObjectPtr const *end() const { return values.end(); }
-
-        void insert(ObjectPtr o) {
-            ObjectPtr const *x = std::find(values.begin(), values.end(), o);
-            if (x == values.end())
-                values.push_back(o);
-        }
+struct ImportMembers : public Import {
+    vector<ImportedMember> members;
+    llvm::StringMap<IdentifierPtr> aliasMap;
 
-        void clear() { values.clear(); }
-    };
+    ImportMembers(const DottedNamePtr &dottedName)
+        : Import(IMPORT_MEMBERS, dottedName) {}
+};
 
-    struct ModuleLookup {
-        ModulePtr module;
-        llvm::StringMap<ModuleLookup> parents;
+//
+// Module
+//
 
-        ModuleLookup() : module(nullptr), parents() {
-        }
+struct ModuleDeclaration : public ANode {
+    const DottedNamePtr name;
+    const ExprListPtr attributes;
 
-        ModuleLookup(Module *m) : module(m), parents() {
-        }
-    };
-
-    struct Module : public ANode {
-        enum InitState {
-            BEFORE,
-            RUNNING,
-            DONE
-        };
-
-        SourcePtr source;
-        string moduleName;
-        vector<ImportPtr> imports;
-        ModuleDeclarationPtr declaration;
-        LLVMCodePtr topLevelLLVM;
-        vector<TopLevelItemPtr> topLevelItems;
-
-        llvm::StringMap<ObjectPtr> globals;
-        llvm::StringMap<ObjectPtr> publicGlobals;
-
-        llvm::StringMap<ModuleLookup> importedModuleNames;
-
-        EnvPtr env;
-        InitState initState;
-        vector<llvm::SmallString<16> > attrBuildFlags;
-        IntegerTypePtr attrDefaultIntegerType;
-        FloatTypePtr attrDefaultFloatType;
-
-        llvm::StringMap<ImportSet> publicSymbols;
-
-        llvm::StringMap<ImportSet> allSymbols;
-
-        set<string> importedNames;
-
-        int publicSymbolsLoading; //:3;
-        int allSymbolsLoading; //:3;
-        bool attributesVerified: 1;
-        bool publicSymbolsLoaded: 1;
-        bool allSymbolsLoaded: 1;
-        bool topLevelLLVMGenerated: 1;
-        bool externalsGenerated: 1;
-        bool isIntrinsicsModule: 1;
-
-        llvm::TrackingVH<llvm::MDNode> debugInfo;
-
-        Module(llvm::StringRef moduleName)
-            : ANode(MODULE), moduleName(moduleName),
-              initState(BEFORE),
-              publicSymbolsLoading(0),
-              allSymbolsLoading(0),
-              attributesVerified(false),
-              publicSymbolsLoaded(false),
-              allSymbolsLoaded(false),
-              topLevelLLVMGenerated(false),
-              externalsGenerated(false),
-              isIntrinsicsModule(false),
-              debugInfo(nullptr) {
-        }
+    ModuleDeclaration(const DottedNamePtr &name, const ExprListPtr &attributes)
+        : ANode(MODULE_DECLARATION), name(name), attributes(attributes) {}
+};
 
-        Module(llvm::StringRef moduleName,
-               llvm::ArrayRef<ImportPtr> imports,
-               const ModuleDeclarationPtr &declaration,
-               const LLVMCodePtr &topLevelLLVM,
-               llvm::ArrayRef<TopLevelItemPtr> topLevelItems)
-            : ANode(MODULE), moduleName(moduleName), imports(imports),
-              declaration(declaration),
-              topLevelLLVM(topLevelLLVM), topLevelItems(topLevelItems),
-              initState(BEFORE),
-              publicSymbolsLoading(0),
-              allSymbolsLoading(0),
-              attributesVerified(false),
-              publicSymbolsLoaded(false),
-              allSymbolsLoaded(false),
-              topLevelLLVMGenerated(false),
-              externalsGenerated(false),
-              isIntrinsicsModule(false),
-              debugInfo(nullptr) {
-        }
+struct ImportSet {
+    llvm::SmallVector<ObjectPtr, 2> values;
 
-        llvm::DINamespace getDebugInfo() { return llvm::DINamespace(debugInfo); }
-    };
+    size_t size() const { return values.size(); }
+    bool empty() const { return values.empty(); }
+    ObjectPtr &operator[](size_t i) { return values[static_cast<unsigned>(i)]; }
+    ObjectPtr const &operator[](size_t i) const {
+        return values[static_cast<unsigned>(i)];
+    }
+    ObjectPtr const *begin() const { return values.begin(); }
+    ObjectPtr const *end() const { return values.end(); }
 
-    //
-    // analyzer
-    //
+    void insert(ObjectPtr o) {
+        ObjectPtr const *x = std::find(values.begin(), values.end(), o);
+        if (x == values.end())
+            values.push_back(o);
+    }
 
-    struct PVData {
-        TypePtr type;
-        bool isRValue: 1;
+    void clear() { values.clear(); }
+};
+
+struct ModuleLookup {
+    ModulePtr module;
+    llvm::StringMap<ModuleLookup> parents;
+
+    ModuleLookup() : module(nullptr), parents() {}
+
+    ModuleLookup(Module *m) : module(m), parents() {}
+};
+
+struct Module : public ANode {
+    enum InitState { BEFORE, RUNNING, DONE };
+
+    SourcePtr source;
+    string moduleName;
+    vector<ImportPtr> imports;
+    ModuleDeclarationPtr declaration;
+    LLVMCodePtr topLevelLLVM;
+    vector<TopLevelItemPtr> topLevelItems;
+
+    llvm::StringMap<ObjectPtr> globals;
+    llvm::StringMap<ObjectPtr> publicGlobals;
+
+    llvm::StringMap<ModuleLookup> importedModuleNames;
+
+    EnvPtr env;
+    InitState initState;
+    vector<llvm::SmallString<16>> attrBuildFlags;
+    IntegerTypePtr attrDefaultIntegerType;
+    FloatTypePtr attrDefaultFloatType;
+
+    llvm::StringMap<ImportSet> publicSymbols;
+
+    llvm::StringMap<ImportSet> allSymbols;
+
+    set<string> importedNames;
+
+    int publicSymbolsLoading; //: 3;
+    int allSymbolsLoading;    //: 3;
+    bool attributesVerified : 1;
+    bool publicSymbolsLoaded : 1;
+    bool allSymbolsLoaded : 1;
+    bool topLevelLLVMGenerated : 1;
+    bool externalsGenerated : 1;
+    bool isIntrinsicsModule : 1;
+
+    llvm::TrackingVH<llvm::MDNode> debugInfo;
+
+    Module(llvm::StringRef moduleName)
+        : ANode(MODULE), moduleName(moduleName), initState(BEFORE),
+          publicSymbolsLoading(0), allSymbolsLoading(0),
+          attributesVerified(false), publicSymbolsLoaded(false),
+          allSymbolsLoaded(false), topLevelLLVMGenerated(false),
+          externalsGenerated(false), isIntrinsicsModule(false),
+          debugInfo(nullptr) {}
+
+    Module(llvm::StringRef moduleName, llvm::ArrayRef<ImportPtr> imports,
+           const ModuleDeclarationPtr &declaration,
+           const LLVMCodePtr &topLevelLLVM,
+           llvm::ArrayRef<TopLevelItemPtr> topLevelItems)
+        : ANode(MODULE), moduleName(moduleName), imports(imports),
+          declaration(declaration), topLevelLLVM(topLevelLLVM),
+          topLevelItems(topLevelItems), initState(BEFORE),
+          publicSymbolsLoading(0), allSymbolsLoading(0),
+          attributesVerified(false), publicSymbolsLoaded(false),
+          allSymbolsLoaded(false), topLevelLLVMGenerated(false),
+          externalsGenerated(false), isIntrinsicsModule(false),
+          debugInfo(nullptr) {}
+
+    llvm::DINamespace *getDebugInfo() {
+        return llvm::dyn_cast_or_null<llvm::DINamespace>(debugInfo.getValPtr());
+    }
+};
 
-        PVData() : type(nullptr), isRValue(false) {
-        }
+//
+// analyzer
+//
 
-        PVData(TypePtr type, bool isRValue)
-            : type(type), isRValue(isRValue) {
-        }
+struct PVData {
+    TypePtr type;
+    bool isRValue : 1;
 
-        bool ok() const { return type != nullptr; }
+    PVData() : type(nullptr), isRValue(false) {}
 
-        bool operator==(PVData const &x) const { return type == x.type && isRValue == x.isRValue; }
-    };
+    PVData(TypePtr type, bool isRValue) : type(type), isRValue(isRValue) {}
 
-    // propagation value
-    struct PValue : public Object {
-        PVData data;
+    bool ok() const { return type != nullptr; }
 
-        PValue(TypePtr type, bool isTemp)
-            : Object(PVALUE), data(type, isTemp) {
-        }
-
-        PValue(PVData data)
-            : Object(PVALUE), data(data) {
-        }
-    };
+    bool operator==(PVData const &x) const {
+        return type == x.type && isRValue == x.isRValue;
+    }
+};
 
-    struct MultiPValue : public Object {
-        llvm::SmallVector<PVData, 4> values;
+// propagation value
+struct PValue : public Object {
+    PVData data;
 
-        MultiPValue()
-            : Object(MULTI_PVALUE) {
-        }
+    PValue(TypePtr type, bool isTemp) : Object(PVALUE), data(type, isTemp) {}
 
-        MultiPValue(PVData const &pv)
-            : Object(MULTI_PVALUE) {
-            values.push_back(pv);
-        }
+    PValue(PVData data) : Object(PVALUE), data(data) {}
+};
 
-        MultiPValue(llvm::ArrayRef<PVData> values)
-            : Object(MULTI_PVALUE), values(values.begin(), values.end()) {
-        }
+struct MultiPValue : public Object {
+    llvm::SmallVector<PVData, 4> values;
 
-        size_t size() { return values.size(); }
-        void add(PVData const &x) { values.push_back(x); }
+    MultiPValue() : Object(MULTI_PVALUE) {}
 
-        void add(MultiPValuePtr x) {
-            values.insert(values.end(), x->values.begin(), x->values.end());
-        }
-
-        void toArgsKey(vector<TypePtr> *args) {
-            for (PVData const *i = values.begin(), *end = values.end();
-                 i != end;
-                 ++i) {
-                args->push_back(i->type);
-            }
-        }
-    };
-
-    //
-    // Env
-    //
+    MultiPValue(PVData const &pv) : Object(MULTI_PVALUE) {
+        values.push_back(pv);
+    }
 
-    struct Env : public Object {
-        ObjectPtr parent;
-        const bool exceptionAvailable;
-        ExprPtr callByNameExprHead;
-        llvm::StringMap<ObjectPtr> entries;
+    MultiPValue(llvm::ArrayRef<PVData> values)
+        : Object(MULTI_PVALUE), values(values.begin(), values.end()) {}
 
-        Env()
-            : Object(ENV), exceptionAvailable(false) {
-        }
+    size_t size() { return values.size(); }
+    void add(PVData const &x) { values.push_back(x); }
 
-        Env(ModulePtr parent)
-            : Object(ENV), parent(parent.ptr()), exceptionAvailable(false) {
-        }
+    void add(MultiPValuePtr x) {
+        values.insert(values.end(), x->values.begin(), x->values.end());
+    }
 
-        Env(EnvPtr parent, bool exceptionAvailable = false)
-            : Object(ENV), parent(parent.ptr()), exceptionAvailable(exceptionAvailable) {
+    void toArgsKey(vector<TypePtr> *args) {
+        for (PVData const *i = values.begin(), *end = values.end(); i != end;
+             ++i) {
+            args->push_back(i->type);
         }
-    };
-
-    //
-    // interactive module
-    //
-
-    void runInteractive(llvm::Module *llvmModule, ModulePtr module);
-
-    //
-    // Types
-    //
-
-#define TYPE_KIND_MAP(XX) \
-    XX(BOOL_TYPE) \
-    XX(INTEGER_TYPE) \
-    XX(FLOAT_TYPE) \
-    XX(COMPLEX_TYPE) \
-    XX(POINTER_TYPE) \
-    XX(CODE_POINTER_TYPE) \
-    XX(CCODE_POINTER_TYPE) \
-    XX(ARRAY_TYPE) \
-    XX(VEC_TYPE) \
-    XX(TUPLE_TYPE) \
-    XX(UNION_TYPE) \
-    XX(RECORD_TYPE) \
-    XX(VARIANT_TYPE) \
-    XX(STATIC_TYPE) \
-    XX(ENUM_TYPE) \
+    }
+};
+
+//
+// Env
+//
+
+struct Env : public Object {
+    ObjectPtr parent;
+    const bool exceptionAvailable;
+    ExprPtr callByNameExprHead;
+    llvm::StringMap<ObjectPtr> entries;
+
+    Env() : Object(ENV), exceptionAvailable(false) {}
+
+    Env(ModulePtr parent)
+        : Object(ENV), parent(parent.ptr()), exceptionAvailable(false) {}
+
+    Env(EnvPtr parent, bool exceptionAvailable = false)
+        : Object(ENV), parent(parent.ptr()),
+          exceptionAvailable(exceptionAvailable) {}
+};
+
+//
+// interactive module
+//
+
+void runInteractive(llvm::Module *llvmModule, ModulePtr module);
+
+//
+// Types
+//
+
+#define TYPE_KIND_MAP(XX)                                                      \
+    XX(BOOL_TYPE)                                                              \
+    XX(INTEGER_TYPE)                                                           \
+    XX(FLOAT_TYPE)                                                             \
+    XX(COMPLEX_TYPE)                                                           \
+    XX(POINTER_TYPE)                                                           \
+    XX(CODE_POINTER_TYPE)                                                      \
+    XX(CCODE_POINTER_TYPE)                                                     \
+    XX(ARRAY_TYPE)                                                             \
+    XX(VEC_TYPE)                                                               \
+    XX(TUPLE_TYPE)                                                             \
+    XX(UNION_TYPE)                                                             \
+    XX(RECORD_TYPE)                                                            \
+    XX(VARIANT_TYPE)                                                           \
+    XX(STATIC_TYPE)                                                            \
+    XX(ENUM_TYPE)                                                              \
     XX(NEW_TYPE)
 #define TYPE_KIND_GEN(e) e,
 
-    enum TypeKind {
-        TYPE_KIND_MAP(TYPE_KIND_GEN)
-    };
+enum TypeKind { TYPE_KIND_MAP(TYPE_KIND_GEN) };
 #undef TYPE_KIND_GEN
 
-    llvm::raw_ostream &operator<<(llvm::raw_ostream &os, TypeKind);
+llvm::raw_ostream &operator<<(llvm::raw_ostream &os, TypeKind);
 
-    struct Type : public Object {
-        const TypeKind typeKind;
-        llvm::Type *llType;
-        llvm::TrackingVH<llvm::MDNode> debugInfo;
-        size_t typeSize;
-        size_t typeAlignment;
+struct Type : public Object {
+    const TypeKind typeKind;
+    llvm::Type *llType;
+    llvm::TrackingVH<llvm::MDNode> debugInfo;
+    size_t typeSize;
+    size_t typeAlignment;
 
-        vector<OverloadPtr> overloads;
+    vector<OverloadPtr> overloads;
 
-        bool overloadsInitialized: 1;
-        bool defined: 1;
-        bool typeInfoInitialized: 1;
+    bool overloadsInitialized : 1;
+    bool defined : 1;
+    bool typeInfoInitialized : 1;
 
-        Type(TypeKind typeKind)
-            : Object(TYPE), typeKind(typeKind),
-              llType(nullptr), debugInfo(nullptr),
-              overloadsInitialized(false),
-              defined(false),
-              typeInfoInitialized(false) {
-        }
+    Type(TypeKind typeKind)
+        : Object(TYPE), typeKind(typeKind), llType(nullptr), debugInfo(nullptr),
+          overloadsInitialized(false), defined(false),
+          typeInfoInitialized(false) {}
 
-        void *operator new(size_t num_bytes) {
-            return ANodeAllocator->Allocate(num_bytes, alignof(Type));
-        }
+    void *operator new(size_t num_bytes) {
+        return ANodeAllocator->Allocate(num_bytes, alignof(Type));
+    }
 
-        void operator delete(void *type) {
-            ANodeAllocator->Deallocate(type);
-        }
+    void operator delete(void *type) {
+        ANodeAllocator->Deallocate(type, sizeof(Type), alignof(Type));
+    }
 
-        llvm::MDNode *getDebugInfo() { return llvm::DIType(debugInfo); }
-    };
+    llvm::DIType *getDebugInfo() {
+        return llvm::dyn_cast_or_null<llvm::DIType>(debugInfo.getValPtr());
+    }
+};
 
-    struct BoolType : public Type {
-        BoolType() : Type(BOOL_TYPE) {
-        }
-    };
+struct BoolType : public Type {
+    BoolType() : Type(BOOL_TYPE) {}
+};
 
-    struct IntegerType : public Type {
-        const unsigned bits: 15;
-        const bool isSigned: 1;
+struct IntegerType : public Type {
+    const unsigned bits : 15;
+    const bool isSigned : 1;
 
-        IntegerType(unsigned bits, bool isSigned)
-            : Type(INTEGER_TYPE), bits(bits), isSigned(isSigned) {
-        }
-    };
+    IntegerType(unsigned bits, bool isSigned)
+        : Type(INTEGER_TYPE), bits(bits), isSigned(isSigned) {}
+};
 
-    struct FloatType : public Type {
-        const unsigned bits: 15;
-        const bool isImaginary: 1;
+struct FloatType : public Type {
+    const unsigned bits : 15;
+    const bool isImaginary : 1;
 
-        FloatType(unsigned bits, bool isImaginary)
-            : Type(FLOAT_TYPE), bits(bits), isImaginary(isImaginary) {
-        }
-    };
+    FloatType(unsigned bits, bool isImaginary)
+        : Type(FLOAT_TYPE), bits(bits), isImaginary(isImaginary) {}
+};
 
-    struct ComplexType : public Type {
-        const llvm::StructLayout *layout;
-        const unsigned bits: 15;
+struct ComplexType : public Type {
+    const llvm::StructLayout *layout;
+    const unsigned bits : 15;
 
-        ComplexType(unsigned bits)
-            : Type(COMPLEX_TYPE), layout(nullptr), bits(bits) {
-        }
-    };
+    ComplexType(unsigned bits)
+        : Type(COMPLEX_TYPE), layout(nullptr), bits(bits) {}
+};
 
-    struct PointerType : public Type {
-        const TypePtr pointeeType;
+struct PointerType : public Type {
+    const TypePtr pointeeType;
 
-        PointerType(TypePtr pointeeType)
-            : Type(POINTER_TYPE), pointeeType(pointeeType) {
-        }
-    };
+    PointerType(TypePtr pointeeType)
+        : Type(POINTER_TYPE), pointeeType(pointeeType) {}
+};
 
-    struct CodePointerType : public Type {
-        const vector<TypePtr> argTypes;
+struct CodePointerType : public Type {
+    const vector<TypePtr> argTypes;
 
-        const vector<uint8_t> returnIsRef;
-        const vector<TypePtr> returnTypes;
+    const vector<uint8_t> returnIsRef;
+    const vector<TypePtr> returnTypes;
 
-        CodePointerType(llvm::ArrayRef<TypePtr> argTypes,
-                        llvm::ArrayRef<uint8_t> returnIsRef,
-                        llvm::ArrayRef<TypePtr> returnTypes)
-            : Type(CODE_POINTER_TYPE), argTypes(argTypes),
-              returnIsRef(returnIsRef), returnTypes(returnTypes) {
-        }
-    };
+    CodePointerType(llvm::ArrayRef<TypePtr> argTypes,
+                    llvm::ArrayRef<uint8_t> returnIsRef,
+                    llvm::ArrayRef<TypePtr> returnTypes)
+        : Type(CODE_POINTER_TYPE), argTypes(argTypes), returnIsRef(returnIsRef),
+          returnTypes(returnTypes) {}
+};
 
-    struct CCodePointerType : public Type {
-        vector<TypePtr> argTypes;
-        TypePtr returnType; // nullptr if void return
+struct CCodePointerType : public Type {
+    vector<TypePtr> argTypes;
+    TypePtr returnType; // nullptr if void return
 
-        llvm::Type *callType;
+    llvm::Type *callType;
 
-        llvm::Type *getCallType();
+    llvm::Type *getCallType();
 
-        const CallingConv callingConv: 3;
-        const bool hasVarArgs: 1;
+    const CallingConv callingConv : 3;
+    const bool hasVarArgs : 1;
 
-        CCodePointerType(CallingConv callingConv,
-                         llvm::ArrayRef<TypePtr> argTypes,
-                         bool hasVarArgs,
-                         const TypePtr &returnType)
-            : Type(CCODE_POINTER_TYPE),
-              argTypes(argTypes),
-              returnType(returnType), callType(nullptr),
-              callingConv(callingConv), hasVarArgs(hasVarArgs) {
-        }
-    };
+    CCodePointerType(CallingConv callingConv, llvm::ArrayRef<TypePtr> argTypes,
+                     bool hasVarArgs, const TypePtr &returnType)
+        : Type(CCODE_POINTER_TYPE), argTypes(argTypes), returnType(returnType),
+          callType(nullptr), callingConv(callingConv), hasVarArgs(hasVarArgs) {}
+};
 
-    struct ArrayType : public Type {
-        const TypePtr elementType;
-        const unsigned size;
+struct ArrayType : public Type {
+    const TypePtr elementType;
+    const unsigned size;
 
-        ArrayType(const TypePtr &elementType, unsigned size)
-            : Type(ARRAY_TYPE), elementType(elementType), size(size) {
-        }
-    };
+    ArrayType(const TypePtr &elementType, unsigned size)
+        : Type(ARRAY_TYPE), elementType(elementType), size(size) {}
+};
 
-    struct VecType : public Type {
-        const TypePtr elementType;
-        const unsigned size;
+struct VecType : public Type {
+    const TypePtr elementType;
+    const unsigned size;
 
-        VecType(const TypePtr &elementType, unsigned size)
-            : Type(VEC_TYPE), elementType(elementType), size(size) {
-        }
-    };
+    VecType(const TypePtr &elementType, unsigned size)
+        : Type(VEC_TYPE), elementType(elementType), size(size) {}
+};
 
-    struct TupleType : public Type {
-        vector<TypePtr> elementTypes;
-        const llvm::StructLayout *layout;
+struct TupleType : public Type {
+    vector<TypePtr> elementTypes;
+    const llvm::StructLayout *layout;
 
-        TupleType()
-            : Type(TUPLE_TYPE), layout(nullptr) {
-        }
+    TupleType() : Type(TUPLE_TYPE), layout(nullptr) {}
 
-        TupleType(llvm::ArrayRef<TypePtr> elementTypes)
-            : Type(TUPLE_TYPE), elementTypes(elementTypes),
-              layout(nullptr) {
-        }
-    };
+    TupleType(llvm::ArrayRef<TypePtr> elementTypes)
+        : Type(TUPLE_TYPE), elementTypes(elementTypes), layout(nullptr) {}
+};
 
-    struct UnionType : public Type {
-        vector<TypePtr> memberTypes;
+struct UnionType : public Type {
+    vector<TypePtr> memberTypes;
 
-        UnionType()
-            : Type(UNION_TYPE) {
-        }
+    UnionType() : Type(UNION_TYPE) {}
 
-        UnionType(llvm::ArrayRef<TypePtr> memberTypes)
-            : Type(UNION_TYPE), memberTypes(memberTypes) {
-        }
-    };
+    UnionType(llvm::ArrayRef<TypePtr> memberTypes)
+        : Type(UNION_TYPE), memberTypes(memberTypes) {}
+};
 
-    struct RecordType : public Type {
-        const RecordDeclPtr record;
+struct RecordType : public Type {
+    const RecordDeclPtr record;
 
-        const vector<ObjectPtr> params;
+    const vector<ObjectPtr> params;
 
-        vector<IdentifierPtr> fieldNames;
-        vector<TypePtr> fieldTypes;
+    vector<IdentifierPtr> fieldNames;
+    vector<TypePtr> fieldTypes;
 
-        llvm::StringMap<size_t> fieldIndexMap;
+    llvm::StringMap<size_t> fieldIndexMap;
 
-        const llvm::StructLayout *layout;
+    const llvm::StructLayout *layout;
 
-        unsigned varFieldPosition;
-        bool fieldsInitialized: 1;
-        bool hasVarField: 1;
+    unsigned varFieldPosition;
+    bool fieldsInitialized : 1;
+    bool hasVarField : 1;
 
-        RecordType(RecordDeclPtr record, llvm::ArrayRef<ObjectPtr> params);
+    RecordType(RecordDeclPtr record, llvm::ArrayRef<ObjectPtr> params);
 
-        size_t varFieldSize() const {
-            return fieldTypes.size() - fieldNames.size() + 1;
-        }
+    size_t varFieldSize() const {
+        return fieldTypes.size() - fieldNames.size() + 1;
+    }
 
-        size_t fieldCount() const {
-            return fieldNames.size();
-        }
-    };
+    size_t fieldCount() const { return fieldNames.size(); }
+};
 
-    struct VariantType : public Type {
-        VariantDeclPtr variant;
-        vector<ObjectPtr> params;
+struct VariantType : public Type {
+    VariantDeclPtr variant;
+    vector<ObjectPtr> params;
 
-        vector<TypePtr> memberTypes;
-        TypePtr reprType;
+    vector<TypePtr> memberTypes;
+    TypePtr reprType;
 
-        bool initialized: 1;
+    bool initialized : 1;
 
-        VariantType(const VariantDeclPtr &variant)
-            : Type(VARIANT_TYPE), variant(variant),
-              initialized(false) {
-        }
+    VariantType(const VariantDeclPtr &variant)
+        : Type(VARIANT_TYPE), variant(variant), initialized(false) {}
 
-        VariantType(const VariantDeclPtr &variant, llvm::ArrayRef<ObjectPtr> params)
-            : Type(VARIANT_TYPE), variant(variant), params(params),
-              initialized(false) {
-        }
-    };
+    VariantType(const VariantDeclPtr &variant, llvm::ArrayRef<ObjectPtr> params)
+        : Type(VARIANT_TYPE), variant(variant), params(params),
+          initialized(false) {}
+};
 
-    struct StaticType : public Type {
-        const ObjectPtr obj;
+struct StaticType : public Type {
+    const ObjectPtr obj;
 
-        StaticType(const ObjectPtr &obj)
-            : Type(STATIC_TYPE), obj(obj) {
-        }
-    };
+    StaticType(const ObjectPtr &obj) : Type(STATIC_TYPE), obj(obj) {}
+};
 
-    struct EnumType : public Type {
-        const EnumDeclPtr enumeration;
-        bool initialized: 1;
+struct EnumType : public Type {
+    const EnumDeclPtr enumeration;
+    bool initialized : 1;
 
-        EnumType(const EnumDeclPtr &enumeration)
-            : Type(ENUM_TYPE), enumeration(enumeration), initialized(false) {
-        }
-    };
+    EnumType(const EnumDeclPtr &enumeration)
+        : Type(ENUM_TYPE), enumeration(enumeration), initialized(false) {}
+};
 
-    struct NewType : public Type {
-        const NewTypeDeclPtr newtype;
+struct NewType : public Type {
+    const NewTypeDeclPtr newtype;
 
-        NewType(const NewTypeDeclPtr &newtype)
-            : Type(NEW_TYPE), newtype(newtype) {
-        }
-    };
+    NewType(const NewTypeDeclPtr &newtype) : Type(NEW_TYPE), newtype(newtype) {}
+};
 
-    //
-    // Pattern
-    //
+//
+// Pattern
+//
 
-    enum PatternKind {
-        PATTERN_CELL,
-        PATTERN_STRUCT
-    };
+enum PatternKind { PATTERN_CELL, PATTERN_STRUCT };
 
-    struct Pattern : public Object {
-        const PatternKind kind;
+struct Pattern : public Object {
+    const PatternKind kind;
 
-        Pattern(PatternKind kind)
-            : Object(PATTERN), kind(kind) {
-        }
-    };
+    Pattern(PatternKind kind) : Object(PATTERN), kind(kind) {}
+};
 
-    struct PatternCell : public Pattern {
-        ObjectPtr obj;
+struct PatternCell : public Pattern {
+    ObjectPtr obj;
 
-        PatternCell(const ObjectPtr &obj)
-            : Pattern(PATTERN_CELL), obj(obj) {
-        }
-    };
+    PatternCell(const ObjectPtr &obj) : Pattern(PATTERN_CELL), obj(obj) {}
+};
 
-    struct PatternStruct : public Pattern {
-        const ObjectPtr head;
-        const MultiPatternPtr params;
+struct PatternStruct : public Pattern {
+    const ObjectPtr head;
+    const MultiPatternPtr params;
 
-        PatternStruct(const ObjectPtr &head, const MultiPatternPtr &params)
-            : Pattern(PATTERN_STRUCT), head(head), params(params) {
-        }
-    };
+    PatternStruct(const ObjectPtr &head, const MultiPatternPtr &params)
+        : Pattern(PATTERN_STRUCT), head(head), params(params) {}
+};
 
-    enum MultiPatternKind {
-        MULTI_PATTERN_CELL,
-        MULTI_PATTERN_LIST
-    };
+enum MultiPatternKind { MULTI_PATTERN_CELL, MULTI_PATTERN_LIST };
 
-    struct MultiPattern : public Object {
-        const MultiPatternKind kind;
+struct MultiPattern : public Object {
+    const MultiPatternKind kind;
 
-        MultiPattern(MultiPatternKind kind)
-            : Object(MULTI_PATTERN), kind(kind) {
-        }
-    };
+    MultiPattern(MultiPatternKind kind) : Object(MULTI_PATTERN), kind(kind) {}
+};
 
-    struct MultiPatternCell : public MultiPattern {
-        MultiPatternPtr data;
+struct MultiPatternCell : public MultiPattern {
+    MultiPatternPtr data;
 
-        MultiPatternCell(const MultiPatternPtr &data)
-            : MultiPattern(MULTI_PATTERN_CELL), data(data) {
-        }
-    };
+    MultiPatternCell(const MultiPatternPtr &data)
+        : MultiPattern(MULTI_PATTERN_CELL), data(data) {}
+};
 
-    struct MultiPatternList : public MultiPattern {
-        vector<PatternPtr> items;
-        MultiPatternPtr tail;
+struct MultiPatternList : public MultiPattern {
+    vector<PatternPtr> items;
+    MultiPatternPtr tail;
 
-        MultiPatternList(llvm::ArrayRef<PatternPtr> items,
-                         const MultiPatternPtr &tail)
-            : MultiPattern(MULTI_PATTERN_LIST), items(items), tail(tail) {
-        }
+    MultiPatternList(llvm::ArrayRef<PatternPtr> items,
+                     const MultiPatternPtr &tail)
+        : MultiPattern(MULTI_PATTERN_LIST), items(items), tail(tail) {}
 
-        MultiPatternList(const MultiPatternPtr &tail)
-            : MultiPattern(MULTI_PATTERN_LIST), tail(tail) {
-        }
+    MultiPatternList(const MultiPatternPtr &tail)
+        : MultiPattern(MULTI_PATTERN_LIST), tail(tail) {}
 
-        MultiPatternList(const PatternPtr &x)
-            : MultiPattern(MULTI_PATTERN_LIST) {
-            items.push_back(x);
-        }
+    MultiPatternList(const PatternPtr &x) : MultiPattern(MULTI_PATTERN_LIST) {
+        items.push_back(x);
+    }
 
-        MultiPatternList()
-            : MultiPattern(MULTI_PATTERN_LIST) {
-        }
-    };
+    MultiPatternList() : MultiPattern(MULTI_PATTERN_LIST) {}
+};
 
-    //
-    // MultiStatic
-    //
+//
+// MultiStatic
+//
 
-    struct MultiStatic : public Object {
-        vector<ObjectPtr> values;
+struct MultiStatic : public Object {
+    vector<ObjectPtr> values;
 
-        MultiStatic()
-            : Object(MULTI_STATIC) {
-        }
+    MultiStatic() : Object(MULTI_STATIC) {}
 
-        MultiStatic(const ObjectPtr &x)
-            : Object(MULTI_STATIC) {
-            values.push_back(x);
-        }
+    MultiStatic(const ObjectPtr &x) : Object(MULTI_STATIC) {
+        values.push_back(x);
+    }
 
-        MultiStatic(llvm::ArrayRef<ObjectPtr> values)
-            : Object(MULTI_STATIC), values(values) {
-        }
+    MultiStatic(llvm::ArrayRef<ObjectPtr> values)
+        : Object(MULTI_STATIC), values(values) {}
 
-        size_t size() const { return values.size(); }
-        void add(const ObjectPtr &x) { values.push_back(x); }
+    size_t size() const { return values.size(); }
+    void add(const ObjectPtr &x) { values.push_back(x); }
 
-        void add(const MultiStaticPtr &x) {
-            values.insert(values.end(), x->values.begin(), x->values.end());
-        }
-    };
-}
+    void add(const MultiStaticPtr &x) {
+        values.insert(values.end(), x->values.begin(), x->values.end());
+    }
+};
+} // namespace clay
diff --git a/compiler/claydoc.cpp b/compiler/claydoc.cpp
index f691e46c..4afaec32 100644
--- a/compiler/claydoc.cpp
+++ b/compiler/claydoc.cpp
@@ -1,5 +1,5 @@
-#include <llvm/Support/Path.h>
 #include <llvm/Support/FileSystem.h>
+#include <llvm/Support/Path.h>
 
 #include <sstream>
 #include <string>
@@ -14,7 +14,8 @@ static void usage(const char *argv0) {
     llvm::errs() << "usage: " << argv0 << " <sourceDir> <htmlOutputDir>\n";
 }
 
-DocModule *docParseModule(const string &fileName, DocState *state, const std::string& fqn) {
+DocModule *docParseModule(const string &fileName, DocState *state,
+                          const std::string &fqn) {
     SourcePtr src = new Source(fileName);
     ModulePtr m = parse(fileName, src, ParserKeepDocumentation);
 
@@ -27,48 +28,49 @@ DocModule *docParseModule(const string &fileName, DocState *state, const std::st
 
     DocumentationPtr lastAttachment;
 
-    for (const auto& item : m->topLevelItems) {
+    for (const auto &item : m->topLevelItems) {
         if (!item)
             continue;
         std::string name = identifierString(item->name);
 
         switch (item->objKind) {
-            case DOCUMENTATION: {
-                DocumentationPtr doc = dynamic_cast<Documentation *>(item.ptr());
-                if (doc->annotation.count(ModuleAnnotation)) {
-                    docMod->name = doc->annotation.find(ModuleAnnotation)->second;
-                    docMod->description = doc->text;
-                } else if (doc->annotation.count(SectionAnnotation)) {
-                    section = new DocSection;
-                    section->name = doc->annotation.find(SectionAnnotation)->second;
-                    section->description = doc->text;
-                    docMod->sections.push_back(section);
-                } else {
-                    lastAttachment = doc;
-                }
-                break;
+        case DOCUMENTATION: {
+            DocumentationPtr doc = dynamic_cast<Documentation *>(item.ptr());
+            if (doc->annotation.count(ModuleAnnotation)) {
+                docMod->name = doc->annotation.find(ModuleAnnotation)->second;
+                docMod->description = doc->text;
+            } else if (doc->annotation.count(SectionAnnotation)) {
+                section = new DocSection;
+                section->name = doc->annotation.find(SectionAnnotation)->second;
+                section->description = doc->text;
+                docMod->sections.push_back(section);
+            } else {
+                lastAttachment = doc;
             }
-            case OVERLOAD:
-                if (!!dynamic_cast<Overload *>(item.ptr())->target)
-                    name = dynamic_cast<Overload *>(item.ptr())->target->asString();
-            case RECORD_DECL:
-            case PROCEDURE: {
-                auto *obj = new DocObject;
-                obj->item = item;
-                obj->name = name;
-                if (!!lastAttachment) {
-                    obj->description = lastAttachment->text;
-                    lastAttachment = nullptr;
-                }
-                section->objects.push_back(obj);
+            break;
+        }
+        case OVERLOAD:
+            if (!!dynamic_cast<Overload *>(item.ptr())->target)
+                name = dynamic_cast<Overload *>(item.ptr())->target->asString();
+        case RECORD_DECL:
+        case PROCEDURE: {
+            auto *obj = new DocObject;
+            obj->item = item;
+            obj->name = name;
+            if (!!lastAttachment) {
+                obj->description = lastAttachment->text;
+                lastAttachment = nullptr;
+            }
+            section->objects.push_back(obj);
 
-                if (item->objKind != OVERLOAD)
-                    state->references.insert(std::pair<std::string, DocModule *>(name, docMod));
+            if (item->objKind != OVERLOAD)
+                state->references.insert(
+                    std::pair<std::string, DocModule *>(name, docMod));
 
-                break;
-            }
-            default: {
-            } // make compiler happy
+            break;
+        }
+        default: {
+        } // make compiler happy
         }
     }
     state->modules.insert(std::pair<std::string, DocModule *>(fqn, docMod));
@@ -78,7 +80,8 @@ DocModule *docParseModule(const string &fileName, DocState *state, const std::st
 
 bool endsWith(std::string const &fullString, std::string const &ending) {
     if (fullString.length() >= ending.length()) {
-        return (0 == fullString.compare(fullString.length() - ending.length(), ending.length(), ending));
+        return (0 == fullString.compare(fullString.length() - ending.length(),
+                                        ending.length(), ending));
     } else {
         return false;
     }
@@ -89,9 +92,8 @@ int main(int argc, char **argv) {
     string outputDir;
 
     for (int i = 1; i < argc; ++i) {
-        if (strcmp(argv[i], "-help") == 0
-            || strcmp(argv[i], "--help") == 0
-            || strcmp(argv[i], "/?") == 0) {
+        if (strcmp(argv[i], "-help") == 0 || strcmp(argv[i], "--help") == 0 ||
+            strcmp(argv[i], "/?") == 0) {
             usage(argv[0]);
             return 2;
         } else if (strstr(argv[i], "-") != argv[i]) {
@@ -125,13 +127,17 @@ int main(int argc, char **argv) {
     auto *state = new DocState;
     state->name = llvm::sys::path::filename(inputDir).str();
 
-    for (llvm::sys::fs::recursive_directory_iterator it(inputDir, ec2), ite; it != ite; it.increment(ec)) {
+    for (llvm::sys::fs::recursive_directory_iterator it(inputDir, ec2), ite;
+         it != ite; it.increment(ec)) {
         llvm::sys::fs::file_status status;
-        if (!it->status() && is_regular_file(status) && endsWith(it->path(), ".clay")) {
+        if (!it->status() && is_regular_file(status) &&
+            endsWith(it->path(), ".clay")) {
             std::string fqn;
 
-            llvm::sys::path::const_iterator word = llvm::sys::path::begin(it->path());
-            llvm::sys::path::const_iterator path_end = llvm::sys::path::end(it->path());
+            llvm::sys::path::const_iterator word =
+                llvm::sys::path::begin(it->path());
+            llvm::sys::path::const_iterator path_end =
+                llvm::sys::path::end(it->path());
 
             if (word != path_end)
                 ++word;
@@ -160,7 +166,7 @@ int main(int argc, char **argv) {
     emitHtmlIndex(outputDir, state);
 }
 
-std::string identifierString(const IdentifierPtr& id) {
+std::string identifierString(const IdentifierPtr &id) {
     if (!id)
         return {"<anonymous>"};
     return {id->str.str().begin(), id->str.str().end()};
diff --git a/compiler/claydoc.hpp b/compiler/claydoc.hpp
index 48ba7d8a..50ed7ac4 100644
--- a/compiler/claydoc.hpp
+++ b/compiler/claydoc.hpp
@@ -1,8 +1,8 @@
 #pragma once
 
+#include <map>
 #include <string>
 #include <vector>
-#include <map>
 
 #include "clay.hpp"
 
@@ -32,7 +32,7 @@ struct DocState {
     std::map<std::string, DocModule *> modules;
 };
 
-std::string identifierString(const clay::IdentifierPtr& id);
+std::string identifierString(const clay::IdentifierPtr &id);
 
 void emitHtmlModule(std::string outpath, DocModule *mod, std::string fqn);
 void emitHtmlIndex(std::string outpath, DocState *);
diff --git a/compiler/clone.cpp b/compiler/clone.cpp
index ce7b7f0e..247f8d42 100644
--- a/compiler/clone.cpp
+++ b/compiler/clone.cpp
@@ -1,473 +1,471 @@
 #include "clone.hpp"
-#include "clay.hpp"
 #include "analyzer.hpp"
+#include "clay.hpp"
 
 #pragma clang diagnostic ignored "-Wcovered-switch-default"
 
 namespace clay {
-    CodePtr clone(CodePtr x) {
-        CodePtr y = new Code();
-        y->location = x->location;
-        clone(x->patternVars, y->patternVars);
-        y->predicate = cloneOpt(x->predicate);
-        clone(x->formalArgs, y->formalArgs);
-        y->hasVarArg = x->hasVarArg;
-        y->returnSpecsDeclared = x->returnSpecsDeclared;
-        clone(x->returnSpecs, y->returnSpecs);
-        y->varReturnSpec = cloneOpt(x->varReturnSpec);
-        y->body = cloneOpt(x->body);
-        y->llvmBody = x->llvmBody;
-        return y;
-    }
-
-    void clone(llvm::ArrayRef<PatternVar> x, vector<PatternVar> &out) {
+CodePtr clone(CodePtr x) {
+    CodePtr y = new Code();
+    y->location = x->location;
+    clone(x->patternVars, y->patternVars);
+    y->predicate = cloneOpt(x->predicate);
+    clone(x->formalArgs, y->formalArgs);
+    y->hasVarArg = x->hasVarArg;
+    y->returnSpecsDeclared = x->returnSpecsDeclared;
+    clone(x->returnSpecs, y->returnSpecs);
+    y->varReturnSpec = cloneOpt(x->varReturnSpec);
+    y->body = cloneOpt(x->body);
+    y->llvmBody = x->llvmBody;
+    return y;
+}
+
+void clone(llvm::ArrayRef<PatternVar> x, vector<PatternVar> &out) { out = x; }
+
+void clone(llvm::ArrayRef<ObjectPtr> x, vector<ObjectPtr> &out) { out = x; }
+
+void clone(llvm::ArrayRef<IdentifierPtr> x, vector<IdentifierPtr> &out) {
+    for (unsigned i = 0; i < x.size(); ++i)
+        out.push_back(x[i]);
+}
+
+ExprPtr clone(ExprPtr x) {
+    ExprPtr out;
+
+    switch (x->exprKind) {
+    case BOOL_LITERAL: {
+        BoolLiteral *y = (BoolLiteral *)x.ptr();
+        out = new BoolLiteral(y->value);
+        break;
+    }
+
+    case INT_LITERAL: {
+        IntLiteral *y = (IntLiteral *)x.ptr();
+        out = new IntLiteral(y->value, y->suffix);
+        break;
+    }
+
+    case FLOAT_LITERAL: {
+        FloatLiteral *y = (FloatLiteral *)x.ptr();
+        out = new FloatLiteral(y->value, y->suffix);
+        break;
+    }
+
+    case CHAR_LITERAL: {
+        CharLiteral *y = (CharLiteral *)x.ptr();
+        out = new CharLiteral(y->value);
+        break;
+    }
+
+    case STRING_LITERAL: {
+        StringLiteral *y = (StringLiteral *)x.ptr();
+        out = new StringLiteral(y->value);
+        break;
+    }
+
+    case FILE_EXPR: {
+        out = new FILEExpr();
+        break;
+    }
+
+    case LINE_EXPR: {
+        out = new LINEExpr();
+        break;
+    }
+
+    case COLUMN_EXPR: {
+        out = new COLUMNExpr();
+        break;
+    }
+
+    case ARG_EXPR: {
+        ARGExpr *arg = (ARGExpr *)x.ptr();
+        out = new ARGExpr(arg->name);
+        break;
+    }
+
+    case NAME_REF: {
+        NameRef *y = (NameRef *)x.ptr();
+        out = new NameRef(y->name);
+        break;
+    }
+
+    case TUPLE: {
+        Tuple *y = (Tuple *)x.ptr();
+        out = new Tuple(clone(y->args));
+        break;
+    }
+
+    case PAREN: {
+        Paren *y = (Paren *)x.ptr();
+        out = new Paren(clone(y->args));
+        break;
+    }
+
+    case INDEXING: {
+        Indexing *y = (Indexing *)x.ptr();
+        out = new Indexing(clone(y->expr), clone(y->args));
+        break;
+    }
+
+    case CALL: {
+        Call *y = (Call *)x.ptr();
+        out = new Call(clone(y->expr), clone(y->parenArgs));
+        break;
+    }
+
+    case FIELD_REF: {
+        FieldRef *y = (FieldRef *)x.ptr();
+        out = new FieldRef(clone(y->expr), y->name);
+        break;
+    }
+
+    case STATIC_INDEXING: {
+        StaticIndexing *y = (StaticIndexing *)x.ptr();
+        out = new StaticIndexing(clone(y->expr), y->index);
+        break;
+    }
+
+    case VARIADIC_OP: {
+        VariadicOp *y = (VariadicOp *)x.ptr();
+        out = new VariadicOp(y->op, clone(y->exprs));
+        break;
+    }
+
+    case AND: {
+        And *y = (And *)x.ptr();
+        out = new And(clone(y->expr1), clone(y->expr2));
+        break;
+    }
+
+    case OR: {
+        Or *y = (Or *)x.ptr();
+        out = new Or(clone(y->expr1), clone(y->expr2));
+        break;
+    }
+
+    case LAMBDA: {
+        Lambda *y = (Lambda *)x.ptr();
+        LambdaPtr z =
+            new Lambda(y->captureBy, clone(y->formalArgs), y->hasVarArg,
+                       y->hasAsConversion, clone(y->body));
+        out = z.ptr();
+        break;
+    }
+
+    case UNPACK: {
+        Unpack *y = (Unpack *)x.ptr();
+        out = new Unpack(clone(y->expr));
+        break;
+    }
+
+    case STATIC_EXPR: {
+        StaticExpr *y = (StaticExpr *)x.ptr();
+        out = new StaticExpr(clone(y->expr));
+        break;
+    }
+
+    case DISPATCH_EXPR: {
+        DispatchExpr *y = (DispatchExpr *)x.ptr();
+        out = new DispatchExpr(clone(y->expr));
+        break;
+    }
+
+    case FOREIGN_EXPR: {
         out = x;
+        break;
+    }
+
+    case OBJECT_EXPR: {
+        ObjectExpr *y = (ObjectExpr *)x.ptr();
+        out = new ObjectExpr(y->obj);
+        break;
+    }
+
+    case EVAL_EXPR: {
+        EvalExpr *eval = (EvalExpr *)x.ptr();
+        out = new EvalExpr(clone(eval->args));
+        break;
     }
 
-    void clone(llvm::ArrayRef<ObjectPtr> x, vector<ObjectPtr> &out) {
+    default:
+        assert(false);
+        break;
+    }
+
+    out->location = x->location;
+    out->startLocation = x->startLocation;
+    out->endLocation = x->endLocation;
+    return out;
+}
+
+ExprPtr cloneOpt(ExprPtr x) {
+    if (!x)
+        return nullptr;
+    return clone(x);
+}
+
+ExprListPtr clone(ExprListPtr x) {
+    ExprListPtr out = new ExprList();
+    for (unsigned i = 0; i < x->size(); ++i)
+        out->add(clone(x->exprs[i]));
+    return out;
+}
+
+void clone(llvm::ArrayRef<FormalArgPtr> x, vector<FormalArgPtr> &out) {
+    for (unsigned i = 0; i < x.size(); ++i)
+        out.push_back(clone(x[i]));
+}
+
+vector<FormalArgPtr> clone(llvm::ArrayRef<FormalArgPtr> x) {
+    vector<FormalArgPtr> r;
+    clone(x, r);
+    return r;
+}
+
+FormalArgPtr clone(FormalArgPtr x) {
+    FormalArgPtr out = new FormalArg(x->name, cloneOpt(x->type), x->tempness,
+                                     cloneOpt(x->asType), x->varArg);
+    out->location = x->location;
+    return out;
+}
+
+FormalArgPtr cloneOpt(FormalArgPtr x) {
+    if (!x)
+        return nullptr;
+    return clone(x);
+}
+
+void clone(llvm::ArrayRef<ReturnSpecPtr> x, vector<ReturnSpecPtr> &out) {
+    for (unsigned i = 0; i < x.size(); ++i)
+        out.push_back(clone(x[i]));
+}
+
+ReturnSpecPtr clone(ReturnSpecPtr x) {
+    return new ReturnSpec(clone(x->type), x->name);
+}
+
+ReturnSpecPtr cloneOpt(ReturnSpecPtr x) {
+    if (!x)
+        return nullptr;
+    return clone(x);
+}
+
+StatementPtr clone(StatementPtr x) {
+    StatementPtr out;
+
+    switch (x->stmtKind) {
+    case BLOCK: {
+        Block *y = (Block *)x.ptr();
+        BlockPtr z = new Block();
+        clone(y->statements, z->statements);
+        out = z.ptr();
+        break;
+    }
+
+    case LABEL: {
+        Label *y = (Label *)x.ptr();
+        out = new Label(y->name);
+        break;
+    }
+
+    case BINDING: {
+        Binding *y = (Binding *)x.ptr();
+        vector<FormalArgPtr> args;
+        vector<PatternVar> patternVars;
+        vector<ObjectPtr> patternTypes;
+        clone(y->args, args);
+        clone(y->patternVars, patternVars);
+        clone(y->patternTypes, patternTypes);
+        out = new Binding(y->bindingKind, patternVars, patternTypes,
+                          cloneOpt(y->predicate), args, clone(y->values),
+                          y->hasVarArg);
+        break;
+    }
+
+    case ASSIGNMENT: {
+        Assignment *y = (Assignment *)x.ptr();
+        out = new Assignment(clone(y->left), clone(y->right));
+        break;
+    }
+
+    case INIT_ASSIGNMENT: {
+        InitAssignment *y = (InitAssignment *)x.ptr();
+        out = new InitAssignment(clone(y->left), clone(y->right));
+        break;
+    }
+
+    case VARIADIC_ASSIGNMENT: {
+        VariadicAssignment *y = (VariadicAssignment *)x.ptr();
+        out = new VariadicAssignment(y->op, clone(y->exprs));
+        break;
+    }
+
+    case GOTO: {
+        Goto *y = (Goto *)x.ptr();
+        out = new Goto(y->labelName);
+        break;
+    }
+
+    case RETURN: {
+        Return *y = (Return *)x.ptr();
+        out = new Return(y->returnKind, clone(y->values));
+        break;
+    }
+
+    case IF: {
+        If *y = (If *)x.ptr();
+        vector<StatementPtr> conditionStatements;
+        clone(y->conditionStatements, conditionStatements);
+        out = new If(conditionStatements, clone(y->condition),
+                     clone(y->thenPart), cloneOpt(y->elsePart));
+        break;
+    }
+
+    case SWITCH: {
+        Switch *y = (Switch *)x.ptr();
+        vector<StatementPtr> exprStatements;
+        clone(y->exprStatements, exprStatements);
+        vector<CaseBlockPtr> caseBlocks;
+        clone(y->caseBlocks, caseBlocks);
+        out = new Switch(exprStatements, clone(y->expr), caseBlocks,
+                         cloneOpt(y->defaultCase));
+        break;
+    }
+
+    case EXPR_STATEMENT: {
+        ExprStatement *y = (ExprStatement *)x.ptr();
+        out = new ExprStatement(clone(y->expr));
+        break;
+    }
+
+    case WHILE: {
+        While *y = (While *)x.ptr();
+        vector<StatementPtr> conditionStatements;
+        clone(y->conditionStatements, conditionStatements);
+        out =
+            new While(conditionStatements, clone(y->condition), clone(y->body));
+        break;
+    }
+
+    case BREAK: {
+        out = new Break();
+        break;
+    }
+
+    case CONTINUE: {
+        out = new Continue();
+        break;
+    }
+
+    case FOR: {
+        For *y = (For *)x.ptr();
+        vector<IdentifierPtr> variables;
+        clone(y->variables, variables);
+        out = new For(variables, clone(y->expr), clone(y->body));
+        break;
+    }
+
+    case FOREIGN_STATEMENT: {
         out = x;
+        break;
+    }
+
+    case TRY: {
+        Try *y = (Try *)x.ptr();
+        vector<CatchPtr> catchBlocks;
+        clone(y->catchBlocks, catchBlocks);
+        out = new Try(clone(y->tryBlock), catchBlocks);
+        break;
+    }
+
+    case THROW: {
+        Throw *y = (Throw *)x.ptr();
+        Throw *outThrow = new Throw(cloneOpt(y->expr), cloneOpt(y->context));
+        // this is weird part: in certain situations
+        // clone is called after desugar, and desugaredExpr is modified after
+        // desugar
+        outThrow->desugaredExpr = cloneOpt(y->desugaredExpr);
+        outThrow->desugaredContext = cloneOpt(y->desugaredContext);
+        out = outThrow;
+        break;
+    }
+
+    case STATIC_FOR: {
+        StaticFor *y = (StaticFor *)x.ptr();
+        out = new StaticFor(y->variable, clone(y->values), clone(y->body));
+        break;
+    }
+
+    case FINALLY: {
+        Finally *y = (Finally *)x.ptr();
+        out = new Finally(clone(y->body));
+        break;
+    }
+
+    case ONERROR: {
+        OnError *y = (OnError *)x.ptr();
+        out = new OnError(clone(y->body));
+        break;
+    }
+
+    case UNREACHABLE: {
+        out = new Unreachable();
+        break;
     }
 
-    void clone(llvm::ArrayRef<IdentifierPtr> x, vector<IdentifierPtr> &out) {
-        for (unsigned i = 0; i < x.size(); ++i)
-            out.push_back(x[i]);
-    }
-
-    ExprPtr clone(ExprPtr x) {
-        ExprPtr out;
-
-        switch (x->exprKind) {
-            case BOOL_LITERAL: {
-                BoolLiteral *y = (BoolLiteral *) x.ptr();
-                out = new BoolLiteral(y->value);
-                break;
-            }
-
-            case INT_LITERAL: {
-                IntLiteral *y = (IntLiteral *) x.ptr();
-                out = new IntLiteral(y->value, y->suffix);
-                break;
-            }
-
-            case FLOAT_LITERAL: {
-                FloatLiteral *y = (FloatLiteral *) x.ptr();
-                out = new FloatLiteral(y->value, y->suffix);
-                break;
-            }
-
-            case CHAR_LITERAL: {
-                CharLiteral *y = (CharLiteral *) x.ptr();
-                out = new CharLiteral(y->value);
-                break;
-            }
-
-            case STRING_LITERAL: {
-                StringLiteral *y = (StringLiteral *) x.ptr();
-                out = new StringLiteral(y->value);
-                break;
-            }
-
-            case FILE_EXPR: {
-                out = new FILEExpr();
-                break;
-            }
-
-            case LINE_EXPR: {
-                out = new LINEExpr();
-                break;
-            }
-
-            case COLUMN_EXPR: {
-                out = new COLUMNExpr();
-                break;
-            }
-
-            case ARG_EXPR: {
-                ARGExpr *arg = (ARGExpr *) x.ptr();
-                out = new ARGExpr(arg->name);
-                break;
-            }
-
-            case NAME_REF: {
-                NameRef *y = (NameRef *) x.ptr();
-                out = new NameRef(y->name);
-                break;
-            }
-
-            case TUPLE: {
-                Tuple *y = (Tuple *) x.ptr();
-                out = new Tuple(clone(y->args));
-                break;
-            }
-
-            case PAREN: {
-                Paren *y = (Paren *) x.ptr();
-                out = new Paren(clone(y->args));
-                break;
-            }
-
-            case INDEXING: {
-                Indexing *y = (Indexing *) x.ptr();
-                out = new Indexing(clone(y->expr), clone(y->args));
-                break;
-            }
-
-            case CALL: {
-                Call *y = (Call *) x.ptr();
-                out = new Call(clone(y->expr), clone(y->parenArgs));
-                break;
-            }
-
-            case FIELD_REF: {
-                FieldRef *y = (FieldRef *) x.ptr();
-                out = new FieldRef(clone(y->expr), y->name);
-                break;
-            }
-
-            case STATIC_INDEXING: {
-                StaticIndexing *y = (StaticIndexing *) x.ptr();
-                out = new StaticIndexing(clone(y->expr), y->index);
-                break;
-            }
-
-            case VARIADIC_OP: {
-                VariadicOp *y = (VariadicOp *) x.ptr();
-                out = new VariadicOp(y->op, clone(y->exprs));
-                break;
-            }
-
-            case AND: {
-                And *y = (And *) x.ptr();
-                out = new And(clone(y->expr1), clone(y->expr2));
-                break;
-            }
-
-            case OR: {
-                Or *y = (Or *) x.ptr();
-                out = new Or(clone(y->expr1), clone(y->expr2));
-                break;
-            }
-
-            case LAMBDA: {
-                Lambda *y = (Lambda *) x.ptr();
-                LambdaPtr z = new Lambda(y->captureBy, clone(y->formalArgs), y->hasVarArg, y->hasAsConversion,
-                                         clone(y->body));
-                out = z.ptr();
-                break;
-            }
-
-            case UNPACK: {
-                Unpack *y = (Unpack *) x.ptr();
-                out = new Unpack(clone(y->expr));
-                break;
-            }
-
-            case STATIC_EXPR: {
-                StaticExpr *y = (StaticExpr *) x.ptr();
-                out = new StaticExpr(clone(y->expr));
-                break;
-            }
-
-            case DISPATCH_EXPR: {
-                DispatchExpr *y = (DispatchExpr *) x.ptr();
-                out = new DispatchExpr(clone(y->expr));
-                break;
-            }
-
-            case FOREIGN_EXPR: {
-                out = x;
-                break;
-            }
-
-            case OBJECT_EXPR: {
-                ObjectExpr *y = (ObjectExpr *) x.ptr();
-                out = new ObjectExpr(y->obj);
-                break;
-            }
-
-            case EVAL_EXPR: {
-                EvalExpr *eval = (EvalExpr *) x.ptr();
-                out = new EvalExpr(clone(eval->args));
-                break;
-            }
-
-            default:
-                assert(false);
-                break;
-        }
-
-        out->location = x->location;
-        out->startLocation = x->startLocation;
-        out->endLocation = x->endLocation;
-        return out;
-    }
-
-    ExprPtr cloneOpt(ExprPtr x) {
-        if (!x)
-            return nullptr;
-        return clone(x);
-    }
-
-    ExprListPtr clone(ExprListPtr x) {
-        ExprListPtr out = new ExprList();
-        for (unsigned i = 0; i < x->size(); ++i)
-            out->add(clone(x->exprs[i]));
-        return out;
-    }
-
-    void clone(llvm::ArrayRef<FormalArgPtr> x, vector<FormalArgPtr> &out) {
-        for (unsigned i = 0; i < x.size(); ++i)
-            out.push_back(clone(x[i]));
-    }
-
-    vector<FormalArgPtr> clone(llvm::ArrayRef<FormalArgPtr> x) {
-        vector<FormalArgPtr> r;
-        clone(x, r);
-        return r;
-    }
-
-    FormalArgPtr clone(FormalArgPtr x) {
-        FormalArgPtr out = new FormalArg(x->name, cloneOpt(x->type), x->tempness, cloneOpt(x->asType), x->varArg);
-        out->location = x->location;
-        return out;
-    }
-
-    FormalArgPtr cloneOpt(FormalArgPtr x) {
-        if (!x)
-            return nullptr;
-        return clone(x);
-    }
-
-    void clone(llvm::ArrayRef<ReturnSpecPtr> x, vector<ReturnSpecPtr> &out) {
-        for (unsigned i = 0; i < x.size(); ++i)
-            out.push_back(clone(x[i]));
-    }
-
-    ReturnSpecPtr clone(ReturnSpecPtr x) {
-        return new ReturnSpec(clone(x->type), x->name);
-    }
-
-    ReturnSpecPtr cloneOpt(ReturnSpecPtr x) {
-        if (!x)
-            return nullptr;
-        return clone(x);
-    }
-
-    StatementPtr clone(StatementPtr x) {
-        StatementPtr out;
-
-        switch (x->stmtKind) {
-            case BLOCK: {
-                Block *y = (Block *) x.ptr();
-                BlockPtr z = new Block();
-                clone(y->statements, z->statements);
-                out = z.ptr();
-                break;
-            }
-
-            case LABEL: {
-                Label *y = (Label *) x.ptr();
-                out = new Label(y->name);
-                break;
-            }
-
-            case BINDING: {
-                Binding *y = (Binding *) x.ptr();
-                vector<FormalArgPtr> args;
-                vector<PatternVar> patternVars;
-                vector<ObjectPtr> patternTypes;
-                clone(y->args, args);
-                clone(y->patternVars, patternVars);
-                clone(y->patternTypes, patternTypes);
-                out = new Binding(y->bindingKind, patternVars, patternTypes, cloneOpt(y->predicate),
-                                  args, clone(y->values), y->hasVarArg);
-                break;
-            }
-
-            case ASSIGNMENT: {
-                Assignment *y = (Assignment *) x.ptr();
-                out = new Assignment(clone(y->left), clone(y->right));
-                break;
-            }
-
-            case INIT_ASSIGNMENT: {
-                InitAssignment *y = (InitAssignment *) x.ptr();
-                out = new InitAssignment(clone(y->left), clone(y->right));
-                break;
-            }
-
-            case VARIADIC_ASSIGNMENT: {
-                VariadicAssignment *y = (VariadicAssignment *) x.ptr();
-                out = new VariadicAssignment(y->op, clone(y->exprs));
-                break;
-            }
-
-            case GOTO: {
-                Goto *y = (Goto *) x.ptr();
-                out = new Goto(y->labelName);
-                break;
-            }
-
-            case RETURN: {
-                Return *y = (Return *) x.ptr();
-                out = new Return(y->returnKind, clone(y->values));
-                break;
-            }
-
-            case IF: {
-                If *y = (If *) x.ptr();
-                vector<StatementPtr> conditionStatements;
-                clone(y->conditionStatements, conditionStatements);
-                out = new If(conditionStatements, clone(y->condition), clone(y->thenPart),
-                             cloneOpt(y->elsePart));
-                break;
-            }
-
-            case SWITCH: {
-                Switch *y = (Switch *) x.ptr();
-                vector<StatementPtr> exprStatements;
-                clone(y->exprStatements, exprStatements);
-                vector<CaseBlockPtr> caseBlocks;
-                clone(y->caseBlocks, caseBlocks);
-                out = new Switch(exprStatements,
-                                 clone(y->expr),
-                                 caseBlocks,
-                                 cloneOpt(y->defaultCase));
-                break;
-            }
-
-            case EXPR_STATEMENT: {
-                ExprStatement *y = (ExprStatement *) x.ptr();
-                out = new ExprStatement(clone(y->expr));
-                break;
-            }
-
-            case WHILE: {
-                While *y = (While *) x.ptr();
-                vector<StatementPtr> conditionStatements;
-                clone(y->conditionStatements, conditionStatements);
-                out = new While(conditionStatements, clone(y->condition), clone(y->body));
-                break;
-            }
-
-            case BREAK: {
-                out = new Break();
-                break;
-            }
-
-            case CONTINUE: {
-                out = new Continue();
-                break;
-            }
-
-            case FOR: {
-                For *y = (For *) x.ptr();
-                vector<IdentifierPtr> variables;
-                clone(y->variables, variables);
-                out = new For(variables, clone(y->expr), clone(y->body));
-                break;
-            }
-
-            case FOREIGN_STATEMENT: {
-                out = x;
-                break;
-            }
-
-            case TRY: {
-                Try *y = (Try *) x.ptr();
-                vector<CatchPtr> catchBlocks;
-                clone(y->catchBlocks, catchBlocks);
-                out = new Try(clone(y->tryBlock), catchBlocks);
-                break;
-            }
-
-            case THROW: {
-                Throw *y = (Throw *) x.ptr();
-                Throw *outThrow = new Throw(cloneOpt(y->expr), cloneOpt(y->context));
-                // this is weird part: in certain situations
-                // clone is called after desugar, and desugaredExpr is modified after desugar
-                outThrow->desugaredExpr = cloneOpt(y->desugaredExpr);
-                outThrow->desugaredContext = cloneOpt(y->desugaredContext);
-                out = outThrow;
-                break;
-            }
-
-            case STATIC_FOR: {
-                StaticFor *y = (StaticFor *) x.ptr();
-                out = new StaticFor(y->variable, clone(y->values), clone(y->body));
-                break;
-            }
-
-            case FINALLY: {
-                Finally *y = (Finally *) x.ptr();
-                out = new Finally(clone(y->body));
-                break;
-            }
-
-            case ONERROR: {
-                OnError *y = (OnError *) x.ptr();
-                out = new OnError(clone(y->body));
-                break;
-            }
-
-            case UNREACHABLE: {
-                out = new Unreachable();
-                break;
-            }
-
-            case EVAL_STATEMENT: {
-                EvalStatement *eval = (EvalStatement *) x.ptr();
-                out = new EvalStatement(eval->args);
-                break;
-            }
-
-            case STATIC_ASSERT_STATEMENT: {
-                StaticAssertStatement *staticAssert = (StaticAssertStatement *) x.ptr();
-                out = new StaticAssertStatement(clone(staticAssert->cond), clone(staticAssert->message));
-                break;
-            }
-
-            default:
-                assert(false);
-        }
-
-        out->location = x->location;
-        return out;
-    }
-
-    StatementPtr cloneOpt(StatementPtr x) {
-        if (!x)
-            return nullptr;
-        return clone(x);
-    }
-
-    void clone(llvm::ArrayRef<StatementPtr> x, vector<StatementPtr> &out) {
-        for (unsigned i = 0; i < x.size(); ++i)
-            out.push_back(clone(x[i]));
-    }
-
-    CaseBlockPtr clone(CaseBlockPtr x) {
-        CaseBlockPtr y = new CaseBlock(clone(x->caseLabels), clone(x->body));
-        y->location = x->location;
-        return y;
-    }
-
-    void clone(llvm::ArrayRef<CaseBlockPtr> x, vector<CaseBlockPtr> &out) {
-        for (unsigned i = 0; i < x.size(); ++i)
-            out.push_back(clone(x[i]));
-    }
-
-    CatchPtr clone(CatchPtr x) {
-        CatchPtr y = new Catch(x->exceptionVar,
-                               cloneOpt(x->exceptionType),
-                               x->contextVar,
-                               clone(x->body));
-        y->location = x->location;
-        return y;
-    }
-
-    void clone(llvm::ArrayRef<CatchPtr> x, vector<CatchPtr> &out) {
-        for (unsigned i = 0; i < x.size(); ++i)
-            out.push_back(clone(x[i]));
+    case EVAL_STATEMENT: {
+        EvalStatement *eval = (EvalStatement *)x.ptr();
+        out = new EvalStatement(eval->args);
+        break;
     }
+
+    case STATIC_ASSERT_STATEMENT: {
+        StaticAssertStatement *staticAssert = (StaticAssertStatement *)x.ptr();
+        out = new StaticAssertStatement(clone(staticAssert->cond),
+                                        clone(staticAssert->message));
+        break;
+    }
+
+    default:
+        assert(false);
+    }
+
+    out->location = x->location;
+    return out;
+}
+
+StatementPtr cloneOpt(StatementPtr x) {
+    if (!x)
+        return nullptr;
+    return clone(x);
+}
+
+void clone(llvm::ArrayRef<StatementPtr> x, vector<StatementPtr> &out) {
+    for (unsigned i = 0; i < x.size(); ++i)
+        out.push_back(clone(x[i]));
+}
+
+CaseBlockPtr clone(CaseBlockPtr x) {
+    CaseBlockPtr y = new CaseBlock(clone(x->caseLabels), clone(x->body));
+    y->location = x->location;
+    return y;
+}
+
+void clone(llvm::ArrayRef<CaseBlockPtr> x, vector<CaseBlockPtr> &out) {
+    for (unsigned i = 0; i < x.size(); ++i)
+        out.push_back(clone(x[i]));
+}
+
+CatchPtr clone(CatchPtr x) {
+    CatchPtr y = new Catch(x->exceptionVar, cloneOpt(x->exceptionType),
+                           x->contextVar, clone(x->body));
+    y->location = x->location;
+    return y;
+}
+
+void clone(llvm::ArrayRef<CatchPtr> x, vector<CatchPtr> &out) {
+    for (unsigned i = 0; i < x.size(); ++i)
+        out.push_back(clone(x[i]));
 }
+} // namespace clay
diff --git a/compiler/clone.hpp b/compiler/clone.hpp
index 70c756c5..aa702f5a 100644
--- a/compiler/clone.hpp
+++ b/compiler/clone.hpp
@@ -8,22 +8,22 @@ namespace clay {
 
 CodePtr clone(CodePtr x);
 void clone(llvm::ArrayRef<PatternVar> x, vector<PatternVar> &out);
-    void clone(llvm::ArrayRef<IdentifierPtr> x, vector<IdentifierPtr> &out);
-    ExprPtr clone(ExprPtr x);
-    ExprPtr cloneOpt(ExprPtr x);
-    ExprListPtr clone(ExprListPtr x);
-    void clone(llvm::ArrayRef<FormalArgPtr> x, vector<FormalArgPtr> &out);
-    vector<FormalArgPtr> clone(llvm::ArrayRef<FormalArgPtr> x);
-    FormalArgPtr clone(FormalArgPtr x);
-    FormalArgPtr cloneOpt(FormalArgPtr x);
-    void clone(llvm::ArrayRef<ReturnSpecPtr> x, vector<ReturnSpecPtr> &out);
-    ReturnSpecPtr clone(ReturnSpecPtr x);
-    ReturnSpecPtr cloneOpt(ReturnSpecPtr x);
-    StatementPtr clone(StatementPtr x);
-    StatementPtr cloneOpt(StatementPtr x);
-    void clone(llvm::ArrayRef<StatementPtr> x, vector<StatementPtr> &out);
-    CaseBlockPtr clone(CaseBlockPtr x);
-    void clone(llvm::ArrayRef<CaseBlockPtr> x, vector<CaseBlockPtr> &out);
-    CatchPtr clone(CatchPtr x);
-    void clone(llvm::ArrayRef<CatchPtr> x, vector<CatchPtr> &out);
+void clone(llvm::ArrayRef<IdentifierPtr> x, vector<IdentifierPtr> &out);
+ExprPtr clone(ExprPtr x);
+ExprPtr cloneOpt(ExprPtr x);
+ExprListPtr clone(ExprListPtr x);
+void clone(llvm::ArrayRef<FormalArgPtr> x, vector<FormalArgPtr> &out);
+vector<FormalArgPtr> clone(llvm::ArrayRef<FormalArgPtr> x);
+FormalArgPtr clone(FormalArgPtr x);
+FormalArgPtr cloneOpt(FormalArgPtr x);
+void clone(llvm::ArrayRef<ReturnSpecPtr> x, vector<ReturnSpecPtr> &out);
+ReturnSpecPtr clone(ReturnSpecPtr x);
+ReturnSpecPtr cloneOpt(ReturnSpecPtr x);
+StatementPtr clone(StatementPtr x);
+StatementPtr cloneOpt(StatementPtr x);
+void clone(llvm::ArrayRef<StatementPtr> x, vector<StatementPtr> &out);
+CaseBlockPtr clone(CaseBlockPtr x);
+void clone(llvm::ArrayRef<CaseBlockPtr> x, vector<CaseBlockPtr> &out);
+CatchPtr clone(CatchPtr x);
+void clone(llvm::ArrayRef<CatchPtr> x, vector<CatchPtr> &out);
 } // namespace clay
diff --git a/compiler/codegen.cpp b/compiler/codegen.cpp
index 1cb89164..347799e8 100644
--- a/compiler/codegen.cpp
+++ b/compiler/codegen.cpp
@@ -1,4699 +1,4463 @@
-#include "clay.hpp"
-#include "evaluator.hpp"
 #include "codegen.hpp"
-#include "externals.hpp"
-#include "loader.hpp"
-#include "operators.hpp"
-#include "lambdas.hpp"
 #include "analyzer.hpp"
-#include "invoketables.hpp"
-#include "literals.hpp"
-#include "desugar.hpp"
+#include "clay.hpp"
+#include "codegen_op.hpp"
 #include "constructors.hpp"
-#include "parser.hpp"
+#include "desugar.hpp"
 #include "env.hpp"
-#include "objects.hpp"
 #include "error.hpp"
+#include "evaluator.hpp"
+#include "externals.hpp"
 #include "int128.hpp"
-#include "codegen_op.hpp"
+#include "invoketables.hpp"
+#include "lambdas.hpp"
+#include "literals.hpp"
+#include "loader.hpp"
+#include "objects.hpp"
+#include "operators.hpp"
+#include "parser.hpp"
 
 #include "codegen.hpp"
 
 #pragma clang diagnostic ignored "-Wcovered-switch-default"
 
 namespace clay {
-    llvm::Module *llvmModule = nullptr;
-    llvm::DIBuilder *llvmDIBuilder = nullptr;
-    llvm::ExecutionEngine *llvmEngine;
-    const llvm::DataLayout *llvmDataLayout;
-    llvm::LLVMContext llvmContext;
-
-    static vector<CValuePtr> initializedGlobals;
-    static CodegenContext *constructorsCtx = nullptr;
-    static CodegenContext *destructorsCtx = nullptr;
+llvm::Module *llvmModule = nullptr;
+llvm::DIBuilder *llvmDIBuilder = nullptr;
+llvm::ExecutionEngine *llvmEngine;
+const llvm::DataLayout *llvmDataLayout;
+llvm::LLVMContext llvmContext;
+
+static vector<CValuePtr> initializedGlobals;
+static CodegenContext *constructorsCtx = nullptr;
+static CodegenContext *destructorsCtx = nullptr;
+
+static bool isMsvcTarget() {
+    llvm::Triple target(llvmModule->getTargetTriple());
+    return (target.getOS() == llvm::Triple::Win32);
+}
 
-    static bool isMsvcTarget() {
-        llvm::Triple target(llvmModule->getTargetTriple());
-        return (target.getOS() == llvm::Triple::Win32);
-    }
+llvm::PointerType *exceptionReturnType() { return llvmPointerType(int8Type); }
 
-    llvm::PointerType *exceptionReturnType() {
-        return llvmPointerType(int8Type);
-    }
+llvm::Value *noExceptionReturnValue() {
+    return llvm::ConstantPointerNull::get(exceptionReturnType());
+}
 
-    llvm::Value *noExceptionReturnValue() {
-        return llvm::ConstantPointerNull::get(exceptionReturnType());
-    }
+void codegenValueInit(CValuePtr dest, CodegenContext *ctx);
 
-    void codegenValueInit(CValuePtr dest, CodegenContext *ctx);
+void codegenValueDestroy(CValuePtr dest, CodegenContext *ctx);
 
-    void codegenValueDestroy(CValuePtr dest, CodegenContext *ctx);
+void codegenStackEntryDestroy(ValueStackEntry const &entry, CodegenContext *ctx,
+                              bool exception);
 
-    void codegenStackEntryDestroy(ValueStackEntry const &entry,
-                                  CodegenContext *ctx,
-                                  bool exception);
+void codegenValueCopy(CValuePtr dest, CValuePtr src, CodegenContext *ctx);
 
-    void codegenValueCopy(CValuePtr dest, CValuePtr src, CodegenContext *ctx);
+void codegenValueMove(CValuePtr dest, CValuePtr src, CodegenContext *ctx);
 
-    void codegenValueMove(CValuePtr dest, CValuePtr src, CodegenContext *ctx);
+void codegenValueAssign(CValuePtr dest, CValuePtr src, CodegenContext *ctx);
 
-    void codegenValueAssign(CValuePtr dest, CValuePtr src, CodegenContext *ctx);
+void codegenValueMoveAssign(CValuePtr dest, CValuePtr src, CodegenContext *ctx);
 
-    void codegenValueMoveAssign(CValuePtr dest,
-                                CValuePtr src,
-                                CodegenContext *ctx);
+llvm::Value *codegenToBoolFlag(CValuePtr a, CodegenContext *ctx);
 
-    llvm::Value *codegenToBoolFlag(CValuePtr a, CodegenContext *ctx);
+size_t cgMarkStack(CodegenContext *ctx);
 
-    size_t cgMarkStack(CodegenContext *ctx);
+void cgDestroyStack(size_t marker, CodegenContext *ctx, bool exception);
 
-    void cgDestroyStack(size_t marker, CodegenContext *ctx, bool exception);
+void cgPopStack(size_t marker, CodegenContext *ctx);
 
-    void cgPopStack(size_t marker, CodegenContext *ctx);
+void cgDestroyAndPopStack(size_t marker, CodegenContext *ctx, bool exception);
 
-    void cgDestroyAndPopStack(size_t marker, CodegenContext *ctx, bool exception);
+void cgPushStackValue(CValuePtr cv, CodegenContext *ctx);
 
-    void cgPushStackValue(CValuePtr cv, CodegenContext *ctx);
+void cgPushStackStatement(ValueStackEntryType type, EnvPtr env,
+                          StatementPtr statement, CodegenContext *ctx);
 
-    void cgPushStackStatement(ValueStackEntryType type,
-                              EnvPtr env,
-                              StatementPtr statement,
-                              CodegenContext *ctx);
+CValuePtr codegenAllocValue(TypePtr t, CodegenContext *ctx);
 
-    CValuePtr codegenAllocValue(TypePtr t, CodegenContext *ctx);
+CValuePtr codegenAllocNewValue(TypePtr t, CodegenContext *ctx);
 
-    CValuePtr codegenAllocNewValue(TypePtr t, CodegenContext *ctx);
+CValuePtr codegenAllocValueForPValue(PVData const &pv, CodegenContext *ctx);
 
-    CValuePtr codegenAllocValueForPValue(PVData const &pv, CodegenContext *ctx);
+MultiCValuePtr codegenMultiArgsAsRef(ExprListPtr exprs, EnvPtr env,
+                                     CodegenContext *ctx);
 
-    MultiCValuePtr codegenMultiArgsAsRef(ExprListPtr exprs,
-                                         EnvPtr env,
-                                         CodegenContext *ctx);
+MultiCValuePtr codegenArgExprAsRef(ExprPtr x, EnvPtr env, CodegenContext *ctx);
 
-    MultiCValuePtr codegenArgExprAsRef(ExprPtr x,
-                                       EnvPtr env,
-                                       CodegenContext *ctx);
+CValuePtr codegenForwardOneAsRef(ExprPtr expr, EnvPtr env, CodegenContext *ctx);
 
-    CValuePtr codegenForwardOneAsRef(ExprPtr expr,
-                                     EnvPtr env,
-                                     CodegenContext *ctx);
+MultiCValuePtr codegenForwardMultiAsRef(ExprListPtr exprs, EnvPtr env,
+                                        CodegenContext *ctx);
 
-    MultiCValuePtr codegenForwardMultiAsRef(ExprListPtr exprs,
-                                            EnvPtr env,
-                                            CodegenContext *ctx);
+MultiCValuePtr codegenForwardExprAsRef(ExprPtr expr, EnvPtr env,
+                                       CodegenContext *ctx);
 
-    MultiCValuePtr codegenForwardExprAsRef(ExprPtr expr,
-                                           EnvPtr env,
-                                           CodegenContext *ctx);
+CValuePtr codegenOneAsRef(ExprPtr expr, EnvPtr env, CodegenContext *ctx);
 
-    CValuePtr codegenOneAsRef(ExprPtr expr,
-                              EnvPtr env,
-                              CodegenContext *ctx);
+MultiCValuePtr codegenMultiAsRef(ExprListPtr exprs, EnvPtr env,
+                                 CodegenContext *ctx);
 
-    MultiCValuePtr codegenMultiAsRef(ExprListPtr exprs,
-                                     EnvPtr env,
-                                     CodegenContext *ctx);
+MultiCValuePtr codegenExprAsRef(ExprPtr expr, EnvPtr env, CodegenContext *ctx);
 
-    MultiCValuePtr codegenExprAsRef(ExprPtr expr,
-                                    EnvPtr env,
-                                    CodegenContext *ctx);
-
-    void codegenOneInto(ExprPtr expr,
-                        EnvPtr env,
-                        CodegenContext *ctx,
-                        CValuePtr out);
-
-    void codegenMultiInto(ExprListPtr exprs,
-                          EnvPtr env,
-                          CodegenContext *ctx,
-                          MultiCValuePtr out,
-                          size_t count);
-
-    void codegenExprInto(ExprPtr expr,
-                         EnvPtr env,
-                         CodegenContext *ctx,
-                         MultiCValuePtr out);
-
-    void codegenMulti(ExprListPtr exprs,
-                      EnvPtr env,
-                      CodegenContext *ctx,
-                      MultiCValuePtr out,
-                      size_t count);
-
-    void codegenOne(ExprPtr expr,
-                    EnvPtr env,
-                    CodegenContext *ctx,
+void codegenOneInto(ExprPtr expr, EnvPtr env, CodegenContext *ctx,
                     CValuePtr out);
 
-    void codegenExpr(ExprPtr expr,
-                     EnvPtr env,
-                     CodegenContext *ctx,
+void codegenMultiInto(ExprListPtr exprs, EnvPtr env, CodegenContext *ctx,
+                      MultiCValuePtr out, size_t count);
+
+void codegenExprInto(ExprPtr expr, EnvPtr env, CodegenContext *ctx,
                      MultiCValuePtr out);
 
-    void codegenStaticObject(ObjectPtr x,
-                             CodegenContext *ctx,
-                             MultiCValuePtr out);
+void codegenMulti(ExprListPtr exprs, EnvPtr env, CodegenContext *ctx,
+                  MultiCValuePtr out, size_t count);
+
+void codegenOne(ExprPtr expr, EnvPtr env, CodegenContext *ctx, CValuePtr out);
 
-    void codegenGVarInstance(GVarInstancePtr x);
+void codegenExpr(ExprPtr expr, EnvPtr env, CodegenContext *ctx,
+                 MultiCValuePtr out);
 
-    void codegenExternalVariable(ExternalVariablePtr x);
+void codegenStaticObject(ObjectPtr x, CodegenContext *ctx, MultiCValuePtr out);
 
-    void codegenExternalProcedure(ExternalProcedurePtr x, bool codegenBody);
+void codegenGVarInstance(GVarInstancePtr x);
 
-    void codegenValueHolder(ValueHolderPtr x,
-                            CodegenContext *ctx,
-                            MultiCValuePtr out);
+void codegenExternalVariable(ExternalVariablePtr x);
 
-    void codegenCompileTimeValue(EValuePtr ev,
-                                 CodegenContext *ctx,
-                                 MultiCValuePtr out);
+void codegenExternalProcedure(ExternalProcedurePtr x, bool codegenBody);
 
-    llvm::Value *codegenSimpleConstant(EValuePtr ev);
+void codegenValueHolder(ValueHolderPtr x, CodegenContext *ctx,
+                        MultiCValuePtr out);
 
-    void codegenIndexingExpr(ExprPtr indexable,
-                             ExprListPtr args,
-                             EnvPtr env,
-                             CodegenContext *ctx,
+void codegenCompileTimeValue(EValuePtr ev, CodegenContext *ctx,
                              MultiCValuePtr out);
 
-    void codegenAliasIndexing(GlobalAliasPtr x,
-                              ExprListPtr args,
-                              EnvPtr env,
-                              CodegenContext *ctx,
-                              MultiCValuePtr out);
-
-    void codegenCallExpr(ExprPtr callable,
-                         ExprListPtr args,
-                         EnvPtr env,
-                         CodegenContext *ctx,
-                         MultiCValuePtr out);
+llvm::Value *codegenSimpleConstant(EValuePtr ev);
 
-    void codegenDispatch(ObjectPtr obj,
-                         MultiCValuePtr args,
-                         MultiPValuePtr pvArgs,
-                         llvm::ArrayRef<unsigned> dispatchIndices,
-                         CodegenContext *ctx,
-                         MultiCValuePtr out);
+void codegenIndexingExpr(ExprPtr indexable, ExprListPtr args, EnvPtr env,
+                         CodegenContext *ctx, MultiCValuePtr out);
 
-    bool codegenShortcut(ObjectPtr callable,
-                         MultiPValuePtr pvArgs,
-                         ExprListPtr args,
-                         EnvPtr env,
-                         CodegenContext *ctx,
-                         MultiCValuePtr out);
+void codegenAliasIndexing(GlobalAliasPtr x, ExprListPtr args, EnvPtr env,
+                          CodegenContext *ctx, MultiCValuePtr out);
 
-    void codegenCallPointer(CValuePtr x,
-                            MultiCValuePtr args,
-                            CodegenContext *ctx,
-                            MultiCValuePtr out);
+void codegenCallExpr(ExprPtr callable, ExprListPtr args, EnvPtr env,
+                     CodegenContext *ctx, MultiCValuePtr out);
 
-    void codegenCallCCode(CCodePointerTypePtr type,
-                          llvm::Value *llCallable,
-                          MultiCValuePtr args,
-                          CodegenContext *ctx,
-                          MultiCValuePtr out);
+void codegenDispatch(ObjectPtr obj, MultiCValuePtr args, MultiPValuePtr pvArgs,
+                     llvm::ArrayRef<unsigned> dispatchIndices,
+                     CodegenContext *ctx, MultiCValuePtr out);
 
-    void codegenCallCCodePointer(CValuePtr x,
-                                 MultiCValuePtr args,
-                                 CodegenContext *ctx,
-                                 MultiCValuePtr out);
+bool codegenShortcut(ObjectPtr callable, MultiPValuePtr pvArgs,
+                     ExprListPtr args, EnvPtr env, CodegenContext *ctx,
+                     MultiCValuePtr out);
 
-    void codegenCallCode(InvokeEntry *entry,
-                         MultiCValuePtr args,
-                         CodegenContext *ctx,
-                         MultiCValuePtr out);
+void codegenCallPointer(CValuePtr x, MultiCValuePtr args, CodegenContext *ctx,
+                        MultiCValuePtr out);
 
-    void codegenLowlevelCall(llvm::Value *llCallable,
-                             llvm::ArrayRef<llvm::Value *> args,
-                             CodegenContext *ctx);
+void codegenCallCCode(CCodePointerTypePtr type, llvm::Value *llCallable,
+                      MultiCValuePtr args, CodegenContext *ctx,
+                      MultiCValuePtr out);
 
-    void codegenCallInline(InvokeEntry *entry,
-                           MultiCValuePtr args,
-                           CodegenContext *ctx,
-                           MultiCValuePtr out);
+void codegenCallCCodePointer(CValuePtr x, MultiCValuePtr args,
+                             CodegenContext *ctx, MultiCValuePtr out);
 
-    void codegenCallByName(InvokeEntry *entry,
-                           ExprPtr callable,
-                           ExprListPtr args,
-                           EnvPtr env,
-                           CodegenContext *ctx,
-                           MultiCValuePtr out);
+void codegenCallCode(InvokeEntry *entry, MultiCValuePtr args,
+                     CodegenContext *ctx, MultiCValuePtr out);
 
-    void codegenCodeBody(InvokeEntry *entry);
+void codegenLowlevelCall(llvm::Value *llCallable,
+                         llvm::ArrayRef<llvm::Value *> args,
+                         CodegenContext *ctx);
 
-    void codegenCWrapper(InvokeEntry *entry, CallingConv cc);
+void codegenCallInline(InvokeEntry *entry, MultiCValuePtr args,
+                       CodegenContext *ctx, MultiCValuePtr out);
 
-    bool codegenStatement(StatementPtr stmt,
-                          EnvPtr env,
-                          CodegenContext *ctx);
+void codegenCallByName(InvokeEntry *entry, ExprPtr callable, ExprListPtr args,
+                       EnvPtr env, CodegenContext *ctx, MultiCValuePtr out);
 
-    void codegenCollectLabels(llvm::ArrayRef<StatementPtr> statements,
-                              unsigned startIndex,
-                              CodegenContext *ctx);
+void codegenCodeBody(InvokeEntry *entry);
 
-    EnvPtr codegenBinding(BindingPtr x, EnvPtr env, CodegenContext *ctx);
+void codegenCWrapper(InvokeEntry *entry, CallingConv cc);
 
-    void codegenExprAssign(ExprPtr left,
-                           CValuePtr cvRight,
-                           PVData const &pvRight,
-                           EnvPtr env,
-                           CodegenContext *ctx);
+bool codegenStatement(StatementPtr stmt, EnvPtr env, CodegenContext *ctx);
 
-    void codegenMultiExprAssign(ExprListPtr left,
-                                MultiCValuePtr mcvRight,
-                                MultiPValuePtr mpvRight,
-                                EnvPtr env,
-                                CodegenContext *ctx);
+void codegenCollectLabels(llvm::ArrayRef<StatementPtr> statements,
+                          unsigned startIndex, CodegenContext *ctx);
 
-    //
-    // flags for inline/exceptions
-    //
+EnvPtr codegenBinding(BindingPtr x, EnvPtr env, CodegenContext *ctx);
 
-    static bool _inlineEnabled = true;
-    static bool _exceptionsEnabled = true;
+void codegenExprAssign(ExprPtr left, CValuePtr cvRight, PVData const &pvRight,
+                       EnvPtr env, CodegenContext *ctx);
 
-    bool inlineEnabled() {
-        return _inlineEnabled;
-    }
+void codegenMultiExprAssign(ExprListPtr left, MultiCValuePtr mcvRight,
+                            MultiPValuePtr mpvRight, EnvPtr env,
+                            CodegenContext *ctx);
 
-    void setInlineEnabled(bool enabled) {
-        _inlineEnabled = enabled;
-    }
+//
+// flags for inline/exceptions
+//
 
-    bool exceptionsEnabled() {
-        return _exceptionsEnabled;
-    }
+static bool _inlineEnabled = true;
+static bool _exceptionsEnabled = true;
 
-    void setExceptionsEnabled(bool enabled) {
-        _exceptionsEnabled = enabled;
-    }
+bool inlineEnabled() { return _inlineEnabled; }
 
-    //
-    // utility procs
-    //
+void setInlineEnabled(bool enabled) { _inlineEnabled = enabled; }
 
-    llvm::BasicBlock *newBasicBlock(llvm::StringRef name, CodegenContext *ctx) {
-        return llvm::BasicBlock::Create(llvmContext,
-                                        name,
-                                        ctx->llvmFunc);
-    }
+bool exceptionsEnabled() { return _exceptionsEnabled; }
 
-    CValuePtr staticCValue(ObjectPtr obj, CodegenContext *ctx) {
-        TypePtr t = staticType(obj);
-        if (ctx->valueForStatics == nullptr)
-            ctx->valueForStatics = ctx->initBuilder->CreateAlloca(llvmType(t));
-        return new CValue(t, ctx->valueForStatics);
-    }
+void setExceptionsEnabled(bool enabled) { _exceptionsEnabled = enabled; }
 
-    static CValuePtr derefValue(CValuePtr cvPtr, CodegenContext *ctx) {
-        assert(cvPtr->type->typeKind == POINTER_TYPE);
-        PointerType *pt = (PointerType *) cvPtr->type.ptr();
-        llvm::Value *ptrValue = ctx->builder->CreateLoad(cvPtr->llValue);
-        return new CValue(pt->pointeeType, ptrValue);
-    }
+//
+// utility procs
+//
 
-    static CValuePtr derefValueForPValue(CValuePtr cv, PVData const &pv, CodegenContext *ctx) {
-        if (pv.isRValue) {
-            return cv;
-        } else {
-            assert(cv->type == pointerType(pv.type));
-            return derefValue(cv, ctx);
-        }
-    }
+llvm::BasicBlock *newBasicBlock(llvm::StringRef name, CodegenContext *ctx) {
+    return llvm::BasicBlock::Create(llvmContext, name, ctx->llvmFunc);
+}
 
-    //
-    // codegen value ops
-    //
+CValuePtr staticCValue(ObjectPtr obj, CodegenContext *ctx) {
+    TypePtr t = staticType(obj);
+    if (ctx->valueForStatics == nullptr)
+        ctx->valueForStatics = ctx->initBuilder->CreateAlloca(llvmType(t));
+    return new CValue(t, ctx->valueForStatics);
+}
 
-    void codegenValueInit(CValuePtr dest, CodegenContext *ctx) {
-        if (isPrimitiveAggregateType(dest->type))
-            return;
-        codegenCallValue(staticCValue(dest->type.ptr(), ctx),
-                         new MultiCValue(),
-                         ctx,
-                         new MultiCValue(dest));
+static CValuePtr derefValue(CValuePtr cvPtr, CodegenContext *ctx) {
+    assert(cvPtr->type->typeKind == POINTER_TYPE);
+    PointerType *pt = (PointerType *)cvPtr->type.ptr();
+    llvm::Value *ptrValue = ctx->builder->CreateLoad(cvPtr->llValue);
+    return new CValue(pt->pointeeType, ptrValue);
+}
+
+static CValuePtr derefValueForPValue(CValuePtr cv, PVData const &pv,
+                                     CodegenContext *ctx) {
+    if (pv.isRValue) {
+        return cv;
+    } else {
+        assert(cv->type == pointerType(pv.type));
+        return derefValue(cv, ctx);
     }
+}
 
-    void codegenValueDestroy(CValuePtr dest, CodegenContext *ctx) {
-        if (isPrimitiveAggregateType(dest->type))
-            return;
+//
+// codegen value ops
+//
+
+void codegenValueInit(CValuePtr dest, CodegenContext *ctx) {
+    if (isPrimitiveAggregateType(dest->type))
+        return;
+    codegenCallValue(staticCValue(dest->type.ptr(), ctx), new MultiCValue(),
+                     ctx, new MultiCValue(dest));
+}
+
+void codegenValueDestroy(CValuePtr dest, CodegenContext *ctx) {
+    if (isPrimitiveAggregateType(dest->type))
+        return;
+    bool savedCheckExceptions = ctx->checkExceptions;
+    ctx->checkExceptions = false;
+    codegenCallValue(staticCValue(operator_destroy(), ctx),
+                     new MultiCValue(dest), ctx, new MultiCValue());
+    ctx->checkExceptions = savedCheckExceptions;
+}
+
+void codegenStackEntryDestroy(ValueStackEntry const &entry, CodegenContext *ctx,
+                              bool exception) {
+    switch (entry.type) {
+    case LOCAL_VALUE:
+        codegenValueDestroy(entry.value, ctx);
+        break;
+    case FINALLY_STATEMENT: {
         bool savedCheckExceptions = ctx->checkExceptions;
         ctx->checkExceptions = false;
-        codegenCallValue(staticCValue(operator_destroy(), ctx),
-                         new MultiCValue(dest),
-                         ctx,
-                         new MultiCValue());
+        codegenStatement(entry.statement, entry.statementEnv, ctx);
         ctx->checkExceptions = savedCheckExceptions;
-    }
-
-    void codegenStackEntryDestroy(ValueStackEntry const &entry,
-                                  CodegenContext *ctx,
-                                  bool exception) {
-        switch (entry.type) {
-            case LOCAL_VALUE:
-                codegenValueDestroy(entry.value, ctx);
-                break;
-            case FINALLY_STATEMENT: {
-                bool savedCheckExceptions = ctx->checkExceptions;
-                ctx->checkExceptions = false;
-                codegenStatement(entry.statement, entry.statementEnv, ctx);
-                ctx->checkExceptions = savedCheckExceptions;
-            }
-            break;
-            case ONERROR_STATEMENT: {
-                if (exception) {
-                    bool savedCheckExceptions = ctx->checkExceptions;
-                    ctx->checkExceptions = false;
-                    codegenStatement(entry.statement, entry.statementEnv, ctx);
-                    ctx->checkExceptions = savedCheckExceptions;
-                }
-            }
-            break;
+    } break;
+    case ONERROR_STATEMENT: {
+        if (exception) {
+            bool savedCheckExceptions = ctx->checkExceptions;
+            ctx->checkExceptions = false;
+            codegenStatement(entry.statement, entry.statementEnv, ctx);
+            ctx->checkExceptions = savedCheckExceptions;
         }
+    } break;
     }
+}
 
-    void codegenValueCopy(CValuePtr dest, CValuePtr src, CodegenContext *ctx) {
-        if (isPrimitiveAggregateType(dest->type)
-            && (dest->type == src->type)
-            && (!isPrimitiveAggregateTooLarge(dest->type))) {
-            if (dest->type->typeKind != STATIC_TYPE) {
-                llvm::Value *v = ctx->builder->CreateLoad(src->llValue);
-                ctx->builder->CreateStore(v, dest->llValue);
-            }
-            return;
+void codegenValueCopy(CValuePtr dest, CValuePtr src, CodegenContext *ctx) {
+    if (isPrimitiveAggregateType(dest->type) && (dest->type == src->type) &&
+        (!isPrimitiveAggregateTooLarge(dest->type))) {
+        if (dest->type->typeKind != STATIC_TYPE) {
+            llvm::Value *v = ctx->builder->CreateLoad(src->llValue);
+            ctx->builder->CreateStore(v, dest->llValue);
         }
-        codegenCallValue(staticCValue(operator_copy(), ctx),
-                         new MultiCValue(src),
-                         ctx,
-                         new MultiCValue(dest));
-    }
-
-    void codegenValueMove(CValuePtr dest, CValuePtr src, CodegenContext *ctx) {
-        if (isPrimitiveAggregateType(dest->type)
-            && (dest->type == src->type)
-            && (!isPrimitiveAggregateTooLarge(dest->type))) {
-            if (dest->type->typeKind != STATIC_TYPE) {
-                llvm::Value *v = ctx->builder->CreateLoad(src->llValue);
-                ctx->builder->CreateStore(v, dest->llValue);
-            }
-            return;
-        }
-        codegenCallValue(staticCValue(operator_move(), ctx),
-                         new MultiCValue(src),
-                         ctx,
-                         new MultiCValue(dest));
+        return;
     }
+    codegenCallValue(staticCValue(operator_copy(), ctx), new MultiCValue(src),
+                     ctx, new MultiCValue(dest));
+}
 
-    void codegenValueForward(CValuePtr dest, CValuePtr src, CodegenContext *ctx) {
-        if (src->type == dest->type) {
-            codegenValueMove(dest, src, ctx);
-        } else {
-            assert(dest->type == pointerType(src->type));
-            ctx->builder->CreateStore(src->llValue, dest->llValue);
+void codegenValueMove(CValuePtr dest, CValuePtr src, CodegenContext *ctx) {
+    if (isPrimitiveAggregateType(dest->type) && (dest->type == src->type) &&
+        (!isPrimitiveAggregateTooLarge(dest->type))) {
+        if (dest->type->typeKind != STATIC_TYPE) {
+            llvm::Value *v = ctx->builder->CreateLoad(src->llValue);
+            ctx->builder->CreateStore(v, dest->llValue);
         }
+        return;
     }
+    codegenCallValue(staticCValue(operator_move(), ctx), new MultiCValue(src),
+                     ctx, new MultiCValue(dest));
+}
 
-    static void codegenValueAssign(
-        PVData const &pdest,
-        CValuePtr dest,
-        PVData const &psrc,
-        CValuePtr src,
-        CodegenContext *ctx) {
-        if (isPrimitiveAggregateType(dest->type)
-            && !pdest.isRValue
-            && (dest->type == src->type)
-            && (!isPrimitiveAggregateTooLarge(dest->type))) {
-            if (dest->type->typeKind != STATIC_TYPE) {
-                llvm::Value *v = ctx->builder->CreateLoad(src->llValue);
-                ctx->builder->CreateStore(v, dest->llValue);
-            }
-            return;
-        }
-        MultiCValuePtr args = new MultiCValue(dest);
-        args->add(src);
-        MultiPValuePtr pvArgs = new MultiPValue(pdest);
-        pvArgs->add(psrc);
-        codegenCallValue(staticCValue(operator_assign(), ctx),
-                         args,
-                         pvArgs,
-                         ctx,
-                         new MultiCValue());
+void codegenValueForward(CValuePtr dest, CValuePtr src, CodegenContext *ctx) {
+    if (src->type == dest->type) {
+        codegenValueMove(dest, src, ctx);
+    } else {
+        assert(dest->type == pointerType(src->type));
+        ctx->builder->CreateStore(src->llValue, dest->llValue);
     }
+}
 
-    llvm::Value *codegenToBoolFlag(CValuePtr a, CodegenContext *ctx) {
-        if (a->type != boolType)
-            typeError(boolType, a->type);
-        llvm::Value *flag = ctx->builder->CreateLoad(a->llValue);
-        assert(flag->getType() == llvmIntType(1));
-        return flag;
+static void codegenValueAssign(PVData const &pdest, CValuePtr dest,
+                               PVData const &psrc, CValuePtr src,
+                               CodegenContext *ctx) {
+    if (isPrimitiveAggregateType(dest->type) && !pdest.isRValue &&
+        (dest->type == src->type) &&
+        (!isPrimitiveAggregateTooLarge(dest->type))) {
+        if (dest->type->typeKind != STATIC_TYPE) {
+            llvm::Value *v = ctx->builder->CreateLoad(src->llValue);
+            ctx->builder->CreateStore(v, dest->llValue);
+        }
+        return;
     }
+    MultiCValuePtr args = new MultiCValue(dest);
+    args->add(src);
+    MultiPValuePtr pvArgs = new MultiPValue(pdest);
+    pvArgs->add(psrc);
+    codegenCallValue(staticCValue(operator_assign(), ctx), args, pvArgs, ctx,
+                     new MultiCValue());
+}
 
-    //
-    // temps
-    //
+llvm::Value *codegenToBoolFlag(CValuePtr a, CodegenContext *ctx) {
+    if (a->type != boolType)
+        typeError(boolType, a->type);
+    llvm::Value *flag = ctx->builder->CreateLoad(a->llValue);
+    assert(flag->getType() == llvmIntType(1));
+    return flag;
+}
 
-    static llvm::Value *allocTemp(llvm::Type *llType, CodegenContext *ctx) {
-        llvm::Value *llv = nullptr;
-        for (size_t i = ctx->discardedSlots.size(); i > 0; --i) {
-            if (ctx->discardedSlots[i - 1].llType == llType) {
-                llv = ctx->discardedSlots[i - 1].llValue;
-                ctx->discardedSlots.erase(ctx->discardedSlots.begin() + long(i) - 1);
-                break;
-            }
+//
+// temps
+//
+
+static llvm::Value *allocTemp(llvm::Type *llType, CodegenContext *ctx) {
+    llvm::Value *llv = nullptr;
+    for (size_t i = ctx->discardedSlots.size(); i > 0; --i) {
+        if (ctx->discardedSlots[i - 1].llType == llType) {
+            llv = ctx->discardedSlots[i - 1].llValue;
+            ctx->discardedSlots.erase(ctx->discardedSlots.begin() + long(i) -
+                                      1);
+            break;
         }
-        if (!llv)
-            llv = ctx->initBuilder->CreateAlloca(llType);
-        ctx->allocatedSlots.push_back(StackSlot(llType, llv));
-        return llv;
     }
+    if (!llv)
+        llv = ctx->initBuilder->CreateAlloca(llType);
+    ctx->allocatedSlots.push_back(StackSlot(llType, llv));
+    return llv;
+}
+
+static size_t markTemps(CodegenContext *ctx) {
+    return ctx->allocatedSlots.size();
+}
 
-    static size_t markTemps(CodegenContext *ctx) {
-        return ctx->allocatedSlots.size();
+static void clearTemps(size_t marker, CodegenContext *ctx) {
+    while (marker < ctx->allocatedSlots.size()) {
+        ctx->discardedSlots.push_back(ctx->allocatedSlots.back());
+        ctx->allocatedSlots.pop_back();
     }
+}
 
-    static void clearTemps(size_t marker, CodegenContext *ctx) {
-        while (marker < ctx->allocatedSlots.size()) {
-            ctx->discardedSlots.push_back(ctx->allocatedSlots.back());
-            ctx->allocatedSlots.pop_back();
-        }
+//
+// codegen value stack
+//
+
+size_t cgMarkStack(CodegenContext *ctx) { return ctx->valueStack.size(); }
+
+void cgDestroyStack(size_t marker, CodegenContext *ctx, bool exception) {
+    size_t i = ctx->valueStack.size();
+    assert(marker <= i);
+    while (marker < i) {
+        --i;
+        codegenStackEntryDestroy(ctx->valueStack[i], ctx, exception);
     }
+}
 
-    //
-    // codegen value stack
-    //
+void cgPopStack(size_t marker, CodegenContext *ctx) {
+    assert(marker <= ctx->valueStack.size());
+    while (marker < ctx->valueStack.size())
+        ctx->valueStack.pop_back();
+}
 
-    size_t cgMarkStack(CodegenContext *ctx) {
-        return ctx->valueStack.size();
+void cgDestroyAndPopStack(size_t marker, CodegenContext *ctx, bool exception) {
+    assert(marker <= ctx->valueStack.size());
+    while (marker < ctx->valueStack.size()) {
+        ValueStackEntry entry = ctx->valueStack.back();
+        ctx->valueStack.pop_back();
+        codegenStackEntryDestroy(entry, ctx, exception);
     }
+}
+
+void cgPushStackValue(CValuePtr cv, CodegenContext *ctx) {
+    ctx->valueStack.push_back(ValueStackEntry(cv));
+}
+
+void cgPushStackStatement(ValueStackEntryType type, EnvPtr env,
+                          StatementPtr statement, CodegenContext *ctx) {
+    ctx->valueStack.push_back(ValueStackEntry(type, env, statement));
+}
+
+CValuePtr codegenAllocValue(TypePtr t, CodegenContext *ctx) {
+    llvm::Value *llv = allocTemp(llvmType(t), ctx);
+    return new CValue(t, llv);
+}
+
+CValuePtr codegenAllocValueForPValue(PVData const &pv, CodegenContext *ctx) {
+    if (pv.isRValue)
+        return codegenAllocValue(pv.type, ctx);
+    else
+        return codegenAllocValue(pointerType(pv.type), ctx);
+}
+
+CValuePtr codegenAllocNewValue(TypePtr t, CodegenContext *ctx) {
+    llvm::Type *llt = llvmType(t);
+    llvm::Value *llv = ctx->initBuilder->CreateAlloca(llt);
+    return new CValue(t, llv);
+}
+
+//
+// codegenMultiArgsAsRef, codegenArgExprAsRef
+//
 
-    void cgDestroyStack(size_t marker, CodegenContext *ctx, bool exception) {
-        size_t i = ctx->valueStack.size();
-        assert(marker <= i);
-        while (marker < i) {
-            --i;
-            codegenStackEntryDestroy(ctx->valueStack[i], ctx, exception);
+MultiCValuePtr codegenMultiArgsAsRef(ExprListPtr exprs, EnvPtr env,
+                                     CodegenContext *ctx) {
+    MultiCValuePtr out = new MultiCValue();
+    for (size_t i = 0; i < exprs->size(); ++i) {
+        ExprPtr x = exprs->exprs[i];
+        if (x->exprKind == UNPACK) {
+            Unpack *y = (Unpack *)x.ptr();
+            MultiCValuePtr mcv = codegenArgExprAsRef(y->expr, env, ctx);
+            out->add(mcv);
+        } else if (x->exprKind == PAREN) {
+            MultiCValuePtr mcv = codegenArgExprAsRef(x, env, ctx);
+            out->add(mcv);
+        } else {
+            MultiCValuePtr mcv = codegenArgExprAsRef(x, env, ctx);
+            out->add(mcv);
         }
     }
+    return out;
+}
 
-    void cgPopStack(size_t marker, CodegenContext *ctx) {
-        assert(marker <= ctx->valueStack.size());
-        while (marker < ctx->valueStack.size())
-            ctx->valueStack.pop_back();
+MultiCValuePtr codegenArgExprAsRef(ExprPtr x, EnvPtr env, CodegenContext *ctx) {
+    if (x->exprKind == DISPATCH_EXPR) {
+        DispatchExpr *y = (DispatchExpr *)x.ptr();
+        return codegenExprAsRef(y->expr, env, ctx);
     }
+    return codegenExprAsRef(x, env, ctx);
+}
+
+//
+// codegenForwardOneAsRef, codegenForwardMultiAsRef, codegenForwardExprAsRef
+//
+
+CValuePtr codegenForwardOneAsRef(ExprPtr expr, EnvPtr env,
+                                 CodegenContext *ctx) {
+    MultiCValuePtr mcv = codegenForwardExprAsRef(expr, env, ctx);
+    LocationContext loc(expr->location);
+    ensureArity(mcv, 1);
+    return mcv->values[0];
+}
 
-    void cgDestroyAndPopStack(size_t marker, CodegenContext *ctx, bool exception) {
-        assert(marker <= ctx->valueStack.size());
-        while (marker < ctx->valueStack.size()) {
-            ValueStackEntry entry = ctx->valueStack.back();
-            ctx->valueStack.pop_back();
-            codegenStackEntryDestroy(entry, ctx, exception);
+MultiCValuePtr codegenForwardMultiAsRef(ExprListPtr exprs, EnvPtr env,
+                                        CodegenContext *ctx) {
+    MultiCValuePtr out = new MultiCValue();
+    for (size_t i = 0; i < exprs->size(); ++i) {
+        ExprPtr x = exprs->exprs[i];
+        if (x->exprKind == UNPACK) {
+            Unpack *y = (Unpack *)x.ptr();
+            MultiCValuePtr mcv = codegenForwardExprAsRef(y->expr, env, ctx);
+            out->add(mcv);
+        } else {
+            MultiCValuePtr mcv = codegenForwardExprAsRef(x, env, ctx);
+            out->add(mcv);
         }
     }
+    return out;
+}
 
-    void cgPushStackValue(CValuePtr cv, CodegenContext *ctx) {
-        ctx->valueStack.push_back(ValueStackEntry(cv));
+MultiCValuePtr codegenForwardExprAsRef(ExprPtr expr, EnvPtr env,
+                                       CodegenContext *ctx) {
+    MultiPValuePtr mpv = safeAnalyzeExpr(expr, env);
+    MultiCValuePtr mcv = codegenExprAsRef(expr, env, ctx);
+    assert(mpv->size() == mcv->size());
+    MultiCValuePtr out = new MultiCValue();
+    for (unsigned i = 0; i < mcv->size(); ++i) {
+        CValuePtr cv = mcv->values[i];
+        if (mpv->values[i].isRValue) {
+            cv = new CValue(cv->type, cv->llValue, true);
+        }
+        out->add(cv);
     }
+    return out;
+}
 
-    void cgPushStackStatement(ValueStackEntryType type,
-                              EnvPtr env,
-                              StatementPtr statement,
-                              CodegenContext *ctx) {
-        ctx->valueStack.push_back(ValueStackEntry(type, env, statement));
-    }
+//
+// codegenOneAsRef, codegenMultiAsRef, codegenExprAsRef
+//
 
-    CValuePtr codegenAllocValue(TypePtr t, CodegenContext *ctx) {
-        llvm::Value *llv = allocTemp(llvmType(t), ctx);
-        return new CValue(t, llv);
-    }
+CValuePtr codegenOneAsRef(ExprPtr expr, EnvPtr env, CodegenContext *ctx) {
+    MultiCValuePtr mcv = codegenExprAsRef(expr, env, ctx);
+    LocationContext loc(expr->location);
+    ensureArity(mcv, 1);
+    return mcv->values[0];
+}
 
-    CValuePtr codegenAllocValueForPValue(PVData const &pv, CodegenContext *ctx) {
-        if (pv.isRValue)
-            return codegenAllocValue(pv.type, ctx);
-        else
-            return codegenAllocValue(pointerType(pv.type), ctx);
+MultiCValuePtr codegenMultiAsRef(ExprListPtr exprs, EnvPtr env,
+                                 CodegenContext *ctx) {
+    MultiCValuePtr out = new MultiCValue();
+    for (size_t i = 0; i < exprs->size(); ++i) {
+        ExprPtr x = exprs->exprs[i];
+        if (x->exprKind == UNPACK) {
+            Unpack *y = (Unpack *)x.ptr();
+            MultiCValuePtr mcv = codegenExprAsRef(y->expr, env, ctx);
+            out->add(mcv);
+        } else if (x->exprKind == PAREN) {
+            MultiCValuePtr mcv = codegenExprAsRef(x, env, ctx);
+            out->add(mcv);
+        } else {
+            CValuePtr cv = codegenOneAsRef(x, env, ctx);
+            out->add(cv);
+        }
     }
+    return out;
+}
 
-    CValuePtr codegenAllocNewValue(TypePtr t, CodegenContext *ctx) {
-        llvm::Type *llt = llvmType(t);
-        llvm::Value *llv = ctx->initBuilder->CreateAlloca(llt);
-        return new CValue(t, llv);
+static MultiCValuePtr codegenExprAsRef2(ExprPtr expr, EnvPtr env,
+                                        CodegenContext *ctx) {
+    MultiPValuePtr mpv = safeAnalyzeExpr(expr, env);
+    MultiCValuePtr mcv = new MultiCValue();
+    for (unsigned i = 0; i < mpv->size(); ++i) {
+        PVData const &pv = mpv->values[i];
+        mcv->add(codegenAllocValueForPValue(pv, ctx));
     }
+    codegenExpr(expr, env, ctx, mcv);
+    MultiCValuePtr out = new MultiCValue();
+    for (unsigned i = 0; i < mpv->size(); ++i) {
+        if (mpv->values[i].isRValue) {
+            out->add(mcv->values[i]);
+            cgPushStackValue(mcv->values[i], ctx);
+        } else {
+            out->add(derefValue(mcv->values[i], ctx));
+        }
+    }
+    return out;
+}
 
-    //
-    // codegenMultiArgsAsRef, codegenArgExprAsRef
-    //
-
-    MultiCValuePtr codegenMultiArgsAsRef(ExprListPtr exprs,
-                                         EnvPtr env,
-                                         CodegenContext *ctx) {
+static MultiCValuePtr codegenStaticObjectAsRef(ObjectPtr x, ExprPtr expr,
+                                               EnvPtr env,
+                                               CodegenContext *ctx) {
+    switch (x->objKind) {
+    case CVALUE: {
+        CValuePtr y = (CValue *)x.ptr();
+        if (y->forwardedRValue)
+            y = new CValue(y->type, y->llValue);
+        return new MultiCValue(y);
+    }
+    case MULTI_CVALUE: {
+        MultiCValue *y = (MultiCValue *)x.ptr();
         MultiCValuePtr out = new MultiCValue();
-        for (size_t i = 0; i < exprs->size(); ++i) {
-            ExprPtr x = exprs->exprs[i];
-            if (x->exprKind == UNPACK) {
-                Unpack *y = (Unpack *) x.ptr();
-                MultiCValuePtr mcv = codegenArgExprAsRef(y->expr, env, ctx);
-                out->add(mcv);
-            } else if (x->exprKind == PAREN) {
-                MultiCValuePtr mcv = codegenArgExprAsRef(x, env, ctx);
-                out->add(mcv);
-            } else {
-                MultiCValuePtr mcv = codegenArgExprAsRef(x, env, ctx);
-                out->add(mcv);
-            }
+        for (size_t i = 0; i < y->size(); ++i) {
+            CValue *cv = y->values[i].ptr();
+            if (cv->forwardedRValue)
+                out->add(new CValue(cv->type, cv->llValue));
+            else
+                out->add(cv);
         }
         return out;
     }
+    default:
+        return codegenExprAsRef2(expr, env, ctx);
+    }
+}
 
-    MultiCValuePtr codegenArgExprAsRef(ExprPtr x,
-                                       EnvPtr env,
-                                       CodegenContext *ctx) {
-        if (x->exprKind == DISPATCH_EXPR) {
-            DispatchExpr *y = (DispatchExpr *) x.ptr();
-            return codegenExprAsRef(y->expr, env, ctx);
+MultiCValuePtr codegenExprAsRef(ExprPtr expr, EnvPtr env, CodegenContext *ctx) {
+    LocationContext loc(expr->location);
+
+    switch (expr->exprKind) {
+    case NAME_REF: {
+        NameRef *x = (NameRef *)expr.ptr();
+        ObjectPtr y = safeLookupEnv(env, x->name);
+        if (y->objKind == EXPRESSION) {
+            ExprPtr z = (Expr *)y.ptr();
+            return codegenExprAsRef(z, env, ctx);
+        } else if (y->objKind == EXPR_LIST) {
+            ExprListPtr z = (ExprList *)y.ptr();
+            return codegenMultiAsRef(z, env, ctx);
         }
-        return codegenExprAsRef(x, env, ctx);
+        return codegenStaticObjectAsRef(y, expr, env, ctx);
+    }
+    case OBJECT_EXPR: {
+        ObjectExpr *x = (ObjectExpr *)expr.ptr();
+        return codegenStaticObjectAsRef(x->obj, expr, env, ctx);
     }
+    default:
+        break;
+    }
+    return codegenExprAsRef2(expr, env, ctx);
+}
 
-    //
-    // codegenForwardOneAsRef, codegenForwardMultiAsRef, codegenForwardExprAsRef
-    //
+//
+// codegenOneInto, codegenMultiInto, codegenExprInto
+//
 
-    CValuePtr codegenForwardOneAsRef(ExprPtr expr,
-                                     EnvPtr env,
-                                     CodegenContext *ctx) {
-        MultiCValuePtr mcv = codegenForwardExprAsRef(expr, env, ctx);
-        LocationContext loc(expr->location);
-        ensureArity(mcv, 1);
-        return mcv->values[0];
+void codegenOneInto(ExprPtr expr, EnvPtr env, CodegenContext *ctx,
+                    CValuePtr out) {
+    PVData pv = safeAnalyzeOne(expr, env);
+    size_t marker = cgMarkStack(ctx);
+    if (pv.isRValue) {
+        codegenOne(expr, env, ctx, out);
+    } else {
+        CValuePtr cvPtr = codegenAllocValue(pointerType(pv.type), ctx);
+        codegenOne(expr, env, ctx, cvPtr);
+        codegenValueCopy(out, derefValue(cvPtr, ctx), ctx);
     }
+    cgDestroyAndPopStack(marker, ctx, false);
+}
 
-    MultiCValuePtr codegenForwardMultiAsRef(ExprListPtr exprs,
-                                            EnvPtr env,
-                                            CodegenContext *ctx) {
-        MultiCValuePtr out = new MultiCValue();
+void codegenMultiInto(ExprListPtr exprs, EnvPtr env, CodegenContext *ctx,
+                      MultiCValuePtr out, size_t wantCount) {
+    size_t marker = cgMarkStack(ctx);
+    size_t marker2 = marker;
+    size_t j = 0;
+    ExprPtr unpackExpr = implicitUnpackExpr(wantCount, exprs);
+    if (unpackExpr != nullptr) {
+        MultiPValuePtr mpv = safeAnalyzeExpr(unpackExpr, env);
+        assert(j + mpv->size() <= out->size());
+        MultiCValuePtr out2 = new MultiCValue();
+        for (size_t k = 0; k < mpv->size(); ++k)
+            out2->add(out->values[j + k]);
+        codegenExprInto(unpackExpr, env, ctx, out2);
+        j += mpv->size();
+    } else
         for (size_t i = 0; i < exprs->size(); ++i) {
+            size_t prevJ = j;
             ExprPtr x = exprs->exprs[i];
             if (x->exprKind == UNPACK) {
-                Unpack *y = (Unpack *) x.ptr();
-                MultiCValuePtr mcv = codegenForwardExprAsRef(y->expr, env, ctx);
-                out->add(mcv);
+                Unpack *y = (Unpack *)x.ptr();
+                MultiPValuePtr mpv = safeAnalyzeExpr(y->expr, env);
+                assert(j + mpv->size() <= out->size());
+                MultiCValuePtr out2 = new MultiCValue();
+                for (size_t k = 0; k < mpv->size(); ++k)
+                    out2->add(out->values[j + k]);
+                codegenExprInto(y->expr, env, ctx, out2);
+                j += mpv->size();
+            } else if (x->exprKind == PAREN) {
+                MultiPValuePtr mpv = safeAnalyzeExpr(x, env);
+                assert(j + mpv->size() <= out->size());
+                MultiCValuePtr out2 = new MultiCValue();
+                for (size_t k = 0; k < mpv->size(); ++k)
+                    out2->add(out->values[j + k]);
+                codegenExprInto(x, env, ctx, out2);
+                j += mpv->size();
             } else {
-                MultiCValuePtr mcv = codegenForwardExprAsRef(x, env, ctx);
-                out->add(mcv);
-            }
+                MultiPValuePtr mpv = safeAnalyzeExpr(x, env);
+                if (mpv->size() != 1)
+                    arityError(x, 1, mpv->size());
+                assert(j < out->size());
+                codegenOneInto(x, env, ctx, out->values[j]);
+                ++j;
+            }
+            cgDestroyAndPopStack(marker2, ctx, false);
+            for (size_t k = prevJ; k < j; ++k)
+                cgPushStackValue(out->values[k], ctx);
+            marker2 = cgMarkStack(ctx);
         }
-        return out;
-    }
+    assert(j == out->size());
+    cgPopStack(marker, ctx);
+}
 
-    MultiCValuePtr codegenForwardExprAsRef(ExprPtr expr,
-                                           EnvPtr env,
-                                           CodegenContext *ctx) {
-        MultiPValuePtr mpv = safeAnalyzeExpr(expr, env);
-        MultiCValuePtr mcv = codegenExprAsRef(expr, env, ctx);
-        assert(mpv->size() == mcv->size());
-        MultiCValuePtr out = new MultiCValue();
-        for (unsigned i = 0; i < mcv->size(); ++i) {
-            CValuePtr cv = mcv->values[i];
-            if (mpv->values[i].isRValue) {
-                cv = new CValue(cv->type, cv->llValue, true);
-            }
-            out->add(cv);
+void codegenExprInto(ExprPtr expr, EnvPtr env, CodegenContext *ctx,
+                     MultiCValuePtr out) {
+    MultiPValuePtr mpv = safeAnalyzeExpr(expr, env);
+    assert(out->size() == mpv->size());
+    size_t marker = cgMarkStack(ctx);
+    MultiCValuePtr mcv = new MultiCValue();
+    for (unsigned i = 0; i < mpv->size(); ++i) {
+        PVData const &pv = mpv->values[i];
+        if (pv.isRValue) {
+            mcv->add(out->values[i]);
+        } else {
+            CValuePtr cvPtr = codegenAllocValue(pointerType(pv.type), ctx);
+            mcv->add(cvPtr);
         }
-        return out;
     }
-
-    //
-    // codegenOneAsRef, codegenMultiAsRef, codegenExprAsRef
-    //
-
-    CValuePtr codegenOneAsRef(ExprPtr expr,
-                              EnvPtr env,
-                              CodegenContext *ctx) {
-        MultiCValuePtr mcv = codegenExprAsRef(expr, env, ctx);
-        LocationContext loc(expr->location);
-        ensureArity(mcv, 1);
-        return mcv->values[0];
+    codegenExpr(expr, env, ctx, mcv);
+    size_t marker2 = cgMarkStack(ctx);
+    for (unsigned i = 0; i < mpv->size(); ++i) {
+        if (!mpv->values[i].isRValue) {
+            CValuePtr cv = derefValue(mcv->values[i], ctx);
+            codegenValueCopy(out->values[i], cv, ctx);
+        }
+        cgPushStackValue(out->values[i], ctx);
     }
+    cgPopStack(marker2, ctx);
+    cgDestroyAndPopStack(marker, ctx, false);
+}
 
-    MultiCValuePtr codegenMultiAsRef(ExprListPtr exprs,
-                                     EnvPtr env,
-                                     CodegenContext *ctx) {
-        MultiCValuePtr out = new MultiCValue();
+//
+// codegenMulti, codegenOne, codegenExpr
+//
+
+void codegenMulti(ExprListPtr exprs, EnvPtr env, CodegenContext *ctx,
+                  MultiCValuePtr out, size_t wantCount) {
+    size_t marker = cgMarkStack(ctx);
+    size_t marker2 = marker;
+    unsigned j = 0;
+    ExprPtr unpackExpr = implicitUnpackExpr(wantCount, exprs);
+    if (unpackExpr != nullptr) {
+        MultiPValuePtr mpv = safeAnalyzeExpr(unpackExpr, env);
+        assert(j + mpv->size() <= out->size());
+        MultiCValuePtr out2 = new MultiCValue();
+        for (unsigned k = 0; k < mpv->size(); ++k)
+            out2->add(out->values[j + k]);
+        codegenExpr(unpackExpr, env, ctx, out2);
+        j += unsigned(mpv->size());
+    } else
         for (size_t i = 0; i < exprs->size(); ++i) {
+            unsigned prevJ = j;
             ExprPtr x = exprs->exprs[i];
             if (x->exprKind == UNPACK) {
-                Unpack *y = (Unpack *) x.ptr();
-                MultiCValuePtr mcv = codegenExprAsRef(y->expr, env, ctx);
-                out->add(mcv);
+                Unpack *y = (Unpack *)x.ptr();
+                MultiPValuePtr mpv = safeAnalyzeExpr(y->expr, env);
+                assert(j + mpv->size() <= out->size());
+                MultiCValuePtr out2 = new MultiCValue();
+                for (unsigned k = 0; k < mpv->size(); ++k)
+                    out2->add(out->values[j + k]);
+                codegenExpr(y->expr, env, ctx, out2);
+                j += unsigned(mpv->size());
             } else if (x->exprKind == PAREN) {
-                MultiCValuePtr mcv = codegenExprAsRef(x, env, ctx);
-                out->add(mcv);
+                MultiPValuePtr mpv = safeAnalyzeExpr(x, env);
+                assert(j + mpv->size() <= out->size());
+                MultiCValuePtr out2 = new MultiCValue();
+                for (unsigned k = 0; k < mpv->size(); ++k)
+                    out2->add(out->values[j + k]);
+                codegenExpr(x, env, ctx, out2);
+                j += unsigned(mpv->size());
             } else {
-                CValuePtr cv = codegenOneAsRef(x, env, ctx);
-                out->add(cv);
-            }
+                MultiPValuePtr mpv = safeAnalyzeExpr(x, env);
+                if (mpv->size() != 1)
+                    arityError(x, 1, mpv->size());
+                assert(j < out->size());
+                codegenOne(x, env, ctx, out->values[j]);
+                ++j;
+            }
+            cgDestroyAndPopStack(marker2, ctx, false);
+            for (unsigned k = prevJ; k < j; ++k)
+                cgPushStackValue(out->values[k], ctx);
+            marker2 = cgMarkStack(ctx);
         }
-        return out;
+    assert(j == out->size());
+    cgPopStack(marker, ctx);
+}
+
+void codegenOne(ExprPtr expr, EnvPtr env, CodegenContext *ctx, CValuePtr out) {
+    codegenExpr(expr, env, ctx, new MultiCValue(out));
+}
+
+void codegenExpr(ExprPtr expr, EnvPtr env, CodegenContext *ctx,
+                 MultiCValuePtr out) {
+    LocationContext loc(expr->location);
+
+    switch (expr->exprKind) {
+    case BOOL_LITERAL: {
+        BoolLiteral *x = (BoolLiteral *)expr.ptr();
+        ValueHolderPtr y = boolToValueHolder(x->value);
+        codegenValueHolder(y, ctx, out);
+        break;
     }
 
-    static MultiCValuePtr codegenExprAsRef2(ExprPtr expr,
-                                            EnvPtr env,
-                                            CodegenContext *ctx) {
-        MultiPValuePtr mpv = safeAnalyzeExpr(expr, env);
-        MultiCValuePtr mcv = new MultiCValue();
-        for (unsigned i = 0; i < mpv->size(); ++i) {
-            PVData const &pv = mpv->values[i];
-            mcv->add(codegenAllocValueForPValue(pv, ctx));
-        }
-        codegenExpr(expr, env, ctx, mcv);
-        MultiCValuePtr out = new MultiCValue();
-        for (unsigned i = 0; i < mpv->size(); ++i) {
-            if (mpv->values[i].isRValue) {
-                out->add(mcv->values[i]);
-                cgPushStackValue(mcv->values[i], ctx);
-            } else {
-                out->add(derefValue(mcv->values[i], ctx));
-            }
-        }
-        return out;
+    case INT_LITERAL: {
+        IntLiteral *x = (IntLiteral *)expr.ptr();
+        ValueHolderPtr y = parseIntLiteral(safeLookupModule(env), x);
+        codegenValueHolder(y, ctx, out);
+        break;
     }
 
-    static MultiCValuePtr codegenStaticObjectAsRef(ObjectPtr x,
-                                                   ExprPtr expr,
-                                                   EnvPtr env,
-                                                   CodegenContext *ctx) {
-        switch (x->objKind) {
-            case CVALUE: {
-                CValuePtr y = (CValue *) x.ptr();
-                if (y->forwardedRValue)
-                    y = new CValue(y->type, y->llValue);
-                return new MultiCValue(y);
-            }
-            case MULTI_CVALUE: {
-                MultiCValue *y = (MultiCValue *) x.ptr();
-                MultiCValuePtr out = new MultiCValue();
-                for (size_t i = 0; i < y->size(); ++i) {
-                    CValue *cv = y->values[i].ptr();
-                    if (cv->forwardedRValue)
-                        out->add(new CValue(cv->type, cv->llValue));
-                    else
-                        out->add(cv);
-                }
-                return out;
-            }
-            default:
-                return codegenExprAsRef2(expr, env, ctx);
-        }
+    case FLOAT_LITERAL: {
+        FloatLiteral *x = (FloatLiteral *)expr.ptr();
+        ValueHolderPtr y = parseFloatLiteral(safeLookupModule(env), x);
+        codegenValueHolder(y, ctx, out);
+        break;
     }
 
-    MultiCValuePtr codegenExprAsRef(ExprPtr expr,
-                                    EnvPtr env,
-                                    CodegenContext *ctx) {
-        LocationContext loc(expr->location);
-
-        switch (expr->exprKind) {
-            case NAME_REF: {
-                NameRef *x = (NameRef *) expr.ptr();
-                ObjectPtr y = safeLookupEnv(env, x->name);
-                if (y->objKind == EXPRESSION) {
-                    ExprPtr z = (Expr *) y.ptr();
-                    return codegenExprAsRef(z, env, ctx);
-                } else if (y->objKind == EXPR_LIST) {
-                    ExprListPtr z = (ExprList *) y.ptr();
-                    return codegenMultiAsRef(z, env, ctx);
-                }
-                return codegenStaticObjectAsRef(y, expr, env, ctx);
-            }
-            case OBJECT_EXPR: {
-                ObjectExpr *x = (ObjectExpr *) expr.ptr();
-                return codegenStaticObjectAsRef(x->obj, expr, env, ctx);
-            }
-            default:
-                break;
-        }
-        return codegenExprAsRef2(expr, env, ctx);
+    case CHAR_LITERAL: {
+        CharLiteral *x = (CharLiteral *)expr.ptr();
+        if (!x->desugared)
+            x->desugared = desugarCharLiteral(x->value);
+        codegenExpr(x->desugared, env, ctx, out);
+        break;
     }
 
-    //
-    // codegenOneInto, codegenMultiInto, codegenExprInto
-    //
+    case STRING_LITERAL:
+        break;
 
-    void codegenOneInto(ExprPtr expr,
-                        EnvPtr env,
-                        CodegenContext *ctx,
-                        CValuePtr out) {
-        PVData pv = safeAnalyzeOne(expr, env);
-        size_t marker = cgMarkStack(ctx);
-        if (pv.isRValue) {
-            codegenOne(expr, env, ctx, out);
+    case FILE_EXPR:
+    case ARG_EXPR:
+        break;
+
+    case LINE_EXPR: {
+        Location location = safeLookupCallByNameLocation(env);
+        unsigned line, column, tabColumn;
+        getLineCol(location, line, column, tabColumn);
+
+        ValueHolderPtr vh = sizeTToValueHolder(line + 1);
+        codegenStaticObject(vh.ptr(), ctx, out);
+        break;
+    }
+    case COLUMN_EXPR: {
+        Location location = safeLookupCallByNameLocation(env);
+        unsigned line, column, tabColumn;
+        getLineCol(location, line, column, tabColumn);
+
+        ValueHolderPtr vh = sizeTToValueHolder(column);
+        codegenStaticObject(vh.ptr(), ctx, out);
+        break;
+    }
+
+    case NAME_REF: {
+        NameRef *x = (NameRef *)expr.ptr();
+        ObjectPtr y = safeLookupEnv(env, x->name);
+        if (y->objKind == EXPRESSION) {
+            ExprPtr z = (Expr *)y.ptr();
+            codegenExpr(z, env, ctx, out);
+        } else if (y->objKind == EXPR_LIST) {
+            ExprListPtr z = (ExprList *)y.ptr();
+            codegenMulti(z, env, ctx, out, 0);
         } else {
-            CValuePtr cvPtr = codegenAllocValue(pointerType(pv.type), ctx);
-            codegenOne(expr, env, ctx, cvPtr);
-            codegenValueCopy(out, derefValue(cvPtr, ctx), ctx);
+            codegenStaticObject(y, ctx, out);
         }
-        cgDestroyAndPopStack(marker, ctx, false);
+        break;
     }
 
-    void codegenMultiInto(ExprListPtr exprs,
-                          EnvPtr env,
-                          CodegenContext *ctx,
-                          MultiCValuePtr out,
-                          size_t wantCount) {
-        size_t marker = cgMarkStack(ctx);
-        size_t marker2 = marker;
-        size_t j = 0;
-        ExprPtr unpackExpr = implicitUnpackExpr(wantCount, exprs);
-        if (unpackExpr != nullptr) {
-            MultiPValuePtr mpv = safeAnalyzeExpr(unpackExpr, env);
-            assert(j + mpv->size() <= out->size());
-            MultiCValuePtr out2 = new MultiCValue();
-            for (size_t k = 0; k < mpv->size(); ++k)
-                out2->add(out->values[j + k]);
-            codegenExprInto(unpackExpr, env, ctx, out2);
-            j += mpv->size();
-        } else
-            for (size_t i = 0; i < exprs->size(); ++i) {
-                size_t prevJ = j;
-                ExprPtr x = exprs->exprs[i];
-                if (x->exprKind == UNPACK) {
-                    Unpack *y = (Unpack *) x.ptr();
-                    MultiPValuePtr mpv = safeAnalyzeExpr(y->expr, env);
-                    assert(j + mpv->size() <= out->size());
-                    MultiCValuePtr out2 = new MultiCValue();
-                    for (size_t k = 0; k < mpv->size(); ++k)
-                        out2->add(out->values[j + k]);
-                    codegenExprInto(y->expr, env, ctx, out2);
-                    j += mpv->size();
-                } else if (x->exprKind == PAREN) {
-                    MultiPValuePtr mpv = safeAnalyzeExpr(x, env);
-                    assert(j + mpv->size() <= out->size());
-                    MultiCValuePtr out2 = new MultiCValue();
-                    for (size_t k = 0; k < mpv->size(); ++k)
-                        out2->add(out->values[j + k]);
-                    codegenExprInto(x, env, ctx, out2);
-                    j += mpv->size();
-                } else {
-                    MultiPValuePtr mpv = safeAnalyzeExpr(x, env);
-                    if (mpv->size() != 1)
-                        arityError(x, 1, mpv->size());
-                    assert(j < out->size());
-                    codegenOneInto(x, env, ctx, out->values[j]);
-                    ++j;
-                }
-                cgDestroyAndPopStack(marker2, ctx, false);
-                for (size_t k = prevJ; k < j; ++k)
-                    cgPushStackValue(out->values[k], ctx);
-                marker2 = cgMarkStack(ctx);
-            }
-        assert(j == out->size());
-        cgPopStack(marker, ctx);
+    case TUPLE: {
+        Tuple *x = (Tuple *)expr.ptr();
+        ExprPtr tupleLiteral = operator_expr_tupleLiteral();
+        codegenCallExpr(tupleLiteral, x->args, env, ctx, out);
+        break;
     }
 
-    void codegenExprInto(ExprPtr expr,
-                         EnvPtr env,
-                         CodegenContext *ctx,
-                         MultiCValuePtr out) {
-        MultiPValuePtr mpv = safeAnalyzeExpr(expr, env);
-        assert(out->size() == mpv->size());
-        size_t marker = cgMarkStack(ctx);
-        MultiCValuePtr mcv = new MultiCValue();
-        for (unsigned i = 0; i < mpv->size(); ++i) {
-            PVData const &pv = mpv->values[i];
-            if (pv.isRValue) {
-                mcv->add(out->values[i]);
-            } else {
-                CValuePtr cvPtr = codegenAllocValue(pointerType(pv.type), ctx);
-                mcv->add(cvPtr);
-            }
-        }
-        codegenExpr(expr, env, ctx, mcv);
-        size_t marker2 = cgMarkStack(ctx);
-        for (unsigned i = 0; i < mpv->size(); ++i) {
-            if (!mpv->values[i].isRValue) {
-                CValuePtr cv = derefValue(mcv->values[i], ctx);
-                codegenValueCopy(out->values[i], cv, ctx);
-            }
-            cgPushStackValue(out->values[i], ctx);
-        }
-        cgPopStack(marker2, ctx);
-        cgDestroyAndPopStack(marker, ctx, false);
+    case PAREN: {
+        Paren *x = (Paren *)expr.ptr();
+        codegenMulti(x->args, env, ctx, out, 0);
+        break;
     }
 
-    //
-    // codegenMulti, codegenOne, codegenExpr
-    //
-
-    void codegenMulti(ExprListPtr exprs,
-                      EnvPtr env,
-                      CodegenContext *ctx,
-                      MultiCValuePtr out,
-                      size_t wantCount) {
-        size_t marker = cgMarkStack(ctx);
-        size_t marker2 = marker;
-        unsigned j = 0;
-        ExprPtr unpackExpr = implicitUnpackExpr(wantCount, exprs);
-        if (unpackExpr != nullptr) {
-            MultiPValuePtr mpv = safeAnalyzeExpr(unpackExpr, env);
-            assert(j + mpv->size() <= out->size());
-            MultiCValuePtr out2 = new MultiCValue();
-            for (unsigned k = 0; k < mpv->size(); ++k)
-                out2->add(out->values[j + k]);
-            codegenExpr(unpackExpr, env, ctx, out2);
-            j += unsigned(mpv->size());
-        } else
-            for (size_t i = 0; i < exprs->size(); ++i) {
-                unsigned prevJ = j;
-                ExprPtr x = exprs->exprs[i];
-                if (x->exprKind == UNPACK) {
-                    Unpack *y = (Unpack *) x.ptr();
-                    MultiPValuePtr mpv = safeAnalyzeExpr(y->expr, env);
-                    assert(j + mpv->size() <= out->size());
-                    MultiCValuePtr out2 = new MultiCValue();
-                    for (unsigned k = 0; k < mpv->size(); ++k)
-                        out2->add(out->values[j + k]);
-                    codegenExpr(y->expr, env, ctx, out2);
-                    j += unsigned(mpv->size());
-                } else if (x->exprKind == PAREN) {
-                    MultiPValuePtr mpv = safeAnalyzeExpr(x, env);
-                    assert(j + mpv->size() <= out->size());
-                    MultiCValuePtr out2 = new MultiCValue();
-                    for (unsigned k = 0; k < mpv->size(); ++k)
-                        out2->add(out->values[j + k]);
-                    codegenExpr(x, env, ctx, out2);
-                    j += unsigned(mpv->size());
-                } else {
-                    MultiPValuePtr mpv = safeAnalyzeExpr(x, env);
-                    if (mpv->size() != 1)
-                        arityError(x, 1, mpv->size());
-                    assert(j < out->size());
-                    codegenOne(x, env, ctx, out->values[j]);
-                    ++j;
-                }
-                cgDestroyAndPopStack(marker2, ctx, false);
-                for (unsigned k = prevJ; k < j; ++k)
-                    cgPushStackValue(out->values[k], ctx);
-                marker2 = cgMarkStack(ctx);
-            }
-        assert(j == out->size());
-        cgPopStack(marker, ctx);
+    case INDEXING: {
+        Indexing *x = (Indexing *)expr.ptr();
+        codegenIndexingExpr(x->expr, x->args, env, ctx, out);
+        break;
     }
 
-    void codegenOne(ExprPtr expr,
-                    EnvPtr env,
-                    CodegenContext *ctx,
-                    CValuePtr out) {
-        codegenExpr(expr, env, ctx, new MultiCValue(out));
+    case CALL: {
+        Call *x = (Call *)expr.ptr();
+        codegenCallExpr(x->expr, x->allArgs(), env, ctx, out);
+        break;
     }
 
-    void codegenExpr(ExprPtr expr,
-                     EnvPtr env,
-                     CodegenContext *ctx,
-                     MultiCValuePtr out) {
-        LocationContext loc(expr->location);
+    case FIELD_REF: {
+        FieldRef *x = (FieldRef *)expr.ptr();
+        if (!x->desugared)
+            desugarFieldRef(x, safeLookupModule(env));
+        if (x->isDottedModuleName) {
+            codegenExpr(x->desugared, env, ctx, out);
+            break;
+        }
 
-        switch (expr->exprKind) {
-            case BOOL_LITERAL: {
-                BoolLiteral *x = (BoolLiteral *) expr.ptr();
-                ValueHolderPtr y = boolToValueHolder(x->value);
-                codegenValueHolder(y, ctx, out);
+        PVData pv = safeAnalyzeOne(x->expr, env);
+        if (pv.type->typeKind == STATIC_TYPE) {
+            StaticType *st = (StaticType *)pv.type.ptr();
+            if (st->obj->objKind == MODULE) {
+                Module *m = (Module *)st->obj.ptr();
+                ObjectPtr obj = safeLookupPublic(m, x->name);
+                codegenStaticObject(obj, ctx, out);
                 break;
             }
+        }
+        codegenExpr(x->desugared, env, ctx, out);
+        break;
+    }
 
-            case INT_LITERAL: {
-                IntLiteral *x = (IntLiteral *) expr.ptr();
-                ValueHolderPtr y = parseIntLiteral(safeLookupModule(env), x);
-                codegenValueHolder(y, ctx, out);
-                break;
-            }
+    case STATIC_INDEXING: {
+        StaticIndexing *x = (StaticIndexing *)expr.ptr();
+        if (!x->desugared)
+            x->desugared = desugarStaticIndexing(x);
+        codegenExpr(x->desugared, env, ctx, out);
+        break;
+    }
 
-            case FLOAT_LITERAL: {
-                FloatLiteral *x = (FloatLiteral *) expr.ptr();
-                ValueHolderPtr y = parseFloatLiteral(safeLookupModule(env), x);
-                codegenValueHolder(y, ctx, out);
-                break;
-            }
+    case VARIADIC_OP: {
+        VariadicOp *x = (VariadicOp *)expr.ptr();
+        if (x->op == ADDRESS_OF) {
+            PVData pv = safeAnalyzeOne(x->exprs->exprs.front(), env);
+            if (pv.isRValue)
+                error("can't take address of a temporary");
+        }
+        if (!x->desugared)
+            x->desugared = desugarVariadicOp(x);
+        codegenExpr(x->desugared, env, ctx, out);
+        break;
+    }
 
-            case CHAR_LITERAL: {
-                CharLiteral *x = (CharLiteral *) expr.ptr();
-                if (!x->desugared)
-                    x->desugared = desugarCharLiteral(x->value);
-                codegenExpr(x->desugared, env, ctx, out);
-                break;
-            }
-
-            case STRING_LITERAL:
-                break;
-
-            case FILE_EXPR:
-            case ARG_EXPR:
-                break;
-
-            case LINE_EXPR: {
-                Location location = safeLookupCallByNameLocation(env);
-                unsigned line, column, tabColumn;
-                getLineCol(location, line, column, tabColumn);
-
-                ValueHolderPtr vh = sizeTToValueHolder(line + 1);
-                codegenStaticObject(vh.ptr(), ctx, out);
-                break;
-            }
-            case COLUMN_EXPR: {
-                Location location = safeLookupCallByNameLocation(env);
-                unsigned line, column, tabColumn;
-                getLineCol(location, line, column, tabColumn);
-
-                ValueHolderPtr vh = sizeTToValueHolder(column);
-                codegenStaticObject(vh.ptr(), ctx, out);
-                break;
-            }
-
-            case NAME_REF: {
-                NameRef *x = (NameRef *) expr.ptr();
-                ObjectPtr y = safeLookupEnv(env, x->name);
-                if (y->objKind == EXPRESSION) {
-                    ExprPtr z = (Expr *) y.ptr();
-                    codegenExpr(z, env, ctx, out);
-                } else if (y->objKind == EXPR_LIST) {
-                    ExprListPtr z = (ExprList *) y.ptr();
-                    codegenMulti(z, env, ctx, out, 0);
-                } else {
-                    codegenStaticObject(y, ctx, out);
-                }
-                break;
-            }
-
-            case TUPLE: {
-                Tuple *x = (Tuple *) expr.ptr();
-                ExprPtr tupleLiteral = operator_expr_tupleLiteral();
-                codegenCallExpr(tupleLiteral, x->args, env, ctx, out);
-                break;
-            }
-
-            case PAREN: {
-                Paren *x = (Paren *) expr.ptr();
-                codegenMulti(x->args, env, ctx, out, 0);
-                break;
-            }
+    case EVAL_EXPR: {
+        EvalExpr *eval = (EvalExpr *)expr.ptr();
+        // XXX compilation context
+        ExprListPtr evaled = desugarEvalExpr(eval, env);
+        codegenMulti(evaled, env, ctx, out, 0);
+        break;
+    }
 
-            case INDEXING: {
-                Indexing *x = (Indexing *) expr.ptr();
-                codegenIndexingExpr(x->expr, x->args, env, ctx, out);
-                break;
-            }
+    case AND: {
+        And *x = (And *)expr.ptr();
+        CValuePtr cv1 = codegenOneAsRef(x->expr1, env, ctx);
+        llvm::Value *flag1 = codegenToBoolFlag(cv1, ctx);
+        llvm::BasicBlock *trueBlock = newBasicBlock("andTrue1", ctx);
+        llvm::BasicBlock *falseBlock = newBasicBlock("andFalse1", ctx);
+        llvm::BasicBlock *mergeBlock = newBasicBlock("andMerge", ctx);
+        ctx->builder->CreateCondBr(flag1, trueBlock, falseBlock);
 
-            case CALL: {
-                Call *x = (Call *) expr.ptr();
-                codegenCallExpr(x->expr, x->allArgs(), env, ctx, out);
-                break;
-            }
+        CValuePtr out0 = out->values[0];
+        assert(out0->type == boolType);
 
-            case FIELD_REF: {
-                FieldRef *x = (FieldRef *) expr.ptr();
-                if (!x->desugared)
-                    desugarFieldRef(x, safeLookupModule(env));
-                if (x->isDottedModuleName) {
-                    codegenExpr(x->desugared, env, ctx, out);
-                    break;
-                }
+        ctx->builder->SetInsertPoint(trueBlock);
+        size_t marker = cgMarkStack(ctx);
+        CValuePtr cv2 = codegenOneAsRef(x->expr2, env, ctx);
+        llvm::Value *flag2 = codegenToBoolFlag(cv2, ctx);
+        ctx->builder->CreateStore(flag2, out0->llValue);
+        cgDestroyAndPopStack(marker, ctx, false);
+        ctx->builder->CreateBr(mergeBlock);
 
-                PVData pv = safeAnalyzeOne(x->expr, env);
-                if (pv.type->typeKind == STATIC_TYPE) {
-                    StaticType *st = (StaticType *) pv.type.ptr();
-                    if (st->obj->objKind == MODULE) {
-                        Module *m = (Module *) st->obj.ptr();
-                        ObjectPtr obj = safeLookupPublic(m, x->name);
-                        codegenStaticObject(obj, ctx, out);
-                        break;
-                    }
-                }
-                codegenExpr(x->desugared, env, ctx, out);
-                break;
-            }
+        ctx->builder->SetInsertPoint(falseBlock);
+        llvm::Value *zero = llvm::ConstantInt::get(llvmType(boolType), 0);
+        ctx->builder->CreateStore(zero, out0->llValue);
+        ctx->builder->CreateBr(mergeBlock);
 
-            case STATIC_INDEXING: {
-                StaticIndexing *x = (StaticIndexing *) expr.ptr();
-                if (!x->desugared)
-                    x->desugared = desugarStaticIndexing(x);
-                codegenExpr(x->desugared, env, ctx, out);
-                break;
-            }
+        ctx->builder->SetInsertPoint(mergeBlock);
+        break;
+    }
 
-            case VARIADIC_OP: {
-                VariadicOp *x = (VariadicOp *) expr.ptr();
-                if (x->op == ADDRESS_OF) {
-                    PVData pv = safeAnalyzeOne(x->exprs->exprs.front(), env);
-                    if (pv.isRValue)
-                        error("can't take address of a temporary");
-                }
-                if (!x->desugared)
-                    x->desugared = desugarVariadicOp(x);
-                codegenExpr(x->desugared, env, ctx, out);
-                break;
-            }
+    case OR: {
+        Or *x = (Or *)expr.ptr();
+        CValuePtr cv1 = codegenOneAsRef(x->expr1, env, ctx);
+        llvm::Value *flag1 = codegenToBoolFlag(cv1, ctx);
+        llvm::BasicBlock *falseBlock = newBasicBlock("orFalse1", ctx);
+        llvm::BasicBlock *trueBlock = newBasicBlock("orTrue1", ctx);
+        llvm::BasicBlock *mergeBlock = newBasicBlock("orMerge", ctx);
+        ctx->builder->CreateCondBr(flag1, trueBlock, falseBlock);
 
-            case EVAL_EXPR: {
-                EvalExpr *eval = (EvalExpr *) expr.ptr();
-                // XXX compilation context
-                ExprListPtr evaled = desugarEvalExpr(eval, env);
-                codegenMulti(evaled, env, ctx, out, 0);
-                break;
-            }
+        CValuePtr out0 = out->values[0];
+        assert(out0->type == boolType);
 
-            case AND: {
-                And *x = (And *) expr.ptr();
-                CValuePtr cv1 = codegenOneAsRef(x->expr1, env, ctx);
-                llvm::Value *flag1 = codegenToBoolFlag(cv1, ctx);
-                llvm::BasicBlock *trueBlock = newBasicBlock("andTrue1", ctx);
-                llvm::BasicBlock *falseBlock = newBasicBlock("andFalse1", ctx);
-                llvm::BasicBlock *mergeBlock = newBasicBlock("andMerge", ctx);
-                ctx->builder->CreateCondBr(flag1, trueBlock, falseBlock);
-
-                CValuePtr out0 = out->values[0];
-                assert(out0->type == boolType);
-
-                ctx->builder->SetInsertPoint(trueBlock);
-                size_t marker = cgMarkStack(ctx);
-                CValuePtr cv2 = codegenOneAsRef(x->expr2, env, ctx);
-                llvm::Value *flag2 = codegenToBoolFlag(cv2, ctx);
-                ctx->builder->CreateStore(flag2, out0->llValue);
-                cgDestroyAndPopStack(marker, ctx, false);
-                ctx->builder->CreateBr(mergeBlock);
+        ctx->builder->SetInsertPoint(falseBlock);
+        size_t marker = cgMarkStack(ctx);
+        CValuePtr cv2 = codegenOneAsRef(x->expr2, env, ctx);
+        llvm::Value *flag2 = codegenToBoolFlag(cv2, ctx);
+        ctx->builder->CreateStore(flag2, out0->llValue);
+        cgDestroyAndPopStack(marker, ctx, false);
+        ctx->builder->CreateBr(mergeBlock);
 
-                ctx->builder->SetInsertPoint(falseBlock);
-                llvm::Value *zero = llvm::ConstantInt::get(llvmType(boolType), 0);
-                ctx->builder->CreateStore(zero, out0->llValue);
-                ctx->builder->CreateBr(mergeBlock);
+        ctx->builder->SetInsertPoint(trueBlock);
+        llvm::Value *one = llvm::ConstantInt::get(llvmType(boolType), 1);
+        ctx->builder->CreateStore(one, out0->llValue);
+        ctx->builder->CreateBr(mergeBlock);
 
-                ctx->builder->SetInsertPoint(mergeBlock);
-                break;
-            }
+        ctx->builder->SetInsertPoint(mergeBlock);
+        break;
+    }
 
-            case OR: {
-                Or *x = (Or *) expr.ptr();
-                CValuePtr cv1 = codegenOneAsRef(x->expr1, env, ctx);
-                llvm::Value *flag1 = codegenToBoolFlag(cv1, ctx);
-                llvm::BasicBlock *falseBlock = newBasicBlock("orFalse1", ctx);
-                llvm::BasicBlock *trueBlock = newBasicBlock("orTrue1", ctx);
-                llvm::BasicBlock *mergeBlock = newBasicBlock("orMerge", ctx);
-                ctx->builder->CreateCondBr(flag1, trueBlock, falseBlock);
-
-                CValuePtr out0 = out->values[0];
-                assert(out0->type == boolType);
-
-                ctx->builder->SetInsertPoint(falseBlock);
-                size_t marker = cgMarkStack(ctx);
-                CValuePtr cv2 = codegenOneAsRef(x->expr2, env, ctx);
-                llvm::Value *flag2 = codegenToBoolFlag(cv2, ctx);
-                ctx->builder->CreateStore(flag2, out0->llValue);
-                cgDestroyAndPopStack(marker, ctx, false);
-                ctx->builder->CreateBr(mergeBlock);
+    case LAMBDA: {
+        Lambda *x = (Lambda *)expr.ptr();
+        if (!x->initialized)
+            initializeLambda(x, env);
+        codegenExpr(x->converted, env, ctx, out);
+        break;
+    }
 
-                ctx->builder->SetInsertPoint(trueBlock);
-                llvm::Value *one = llvm::ConstantInt::get(llvmType(boolType), 1);
-                ctx->builder->CreateStore(one, out0->llValue);
-                ctx->builder->CreateBr(mergeBlock);
+    case UNPACK: {
+        Unpack *unpack = (Unpack *)expr.ptr();
+        if (unpack->expr->exprKind != FOREIGN_EXPR)
+            error("incorrect usage of unpack operator");
+        codegenExpr(unpack->expr, env, ctx, out);
+        break;
+    }
 
-                ctx->builder->SetInsertPoint(mergeBlock);
-                break;
-            }
+    case STATIC_EXPR: {
+        break;
+    }
 
-            case LAMBDA: {
-                Lambda *x = (Lambda *) expr.ptr();
-                if (!x->initialized)
-                    initializeLambda(x, env);
-                codegenExpr(x->converted, env, ctx, out);
-                break;
-            }
+    case DISPATCH_EXPR: {
+        error("incorrect usage of dispatch operator");
+        break;
+    }
 
-            case UNPACK: {
-                Unpack *unpack = (Unpack *) expr.ptr();
-                if (unpack->expr->exprKind != FOREIGN_EXPR)
-                    error("incorrect usage of unpack operator");
-                codegenExpr(unpack->expr, env, ctx, out);
-                break;
-            }
+    case FOREIGN_EXPR: {
+        ForeignExpr *x = (ForeignExpr *)expr.ptr();
+        codegenExpr(x->expr, x->getEnv(), ctx, out);
+        break;
+    }
 
-            case STATIC_EXPR: {
-                break;
-            }
+    case OBJECT_EXPR: {
+        ObjectExpr *x = (ObjectExpr *)expr.ptr();
+        codegenStaticObject(x->obj, ctx, out);
+        break;
+    }
 
-            case DISPATCH_EXPR: {
-                error("incorrect usage of dispatch operator");
-                break;
-            }
+    default:
+        assert(false);
+    }
+}
 
-            case FOREIGN_EXPR: {
-                ForeignExpr *x = (ForeignExpr *) expr.ptr();
-                codegenExpr(x->expr, x->getEnv(), ctx, out);
-                break;
-            }
+//
+// codegenStaticObject
+//
 
-            case OBJECT_EXPR: {
-                ObjectExpr *x = (ObjectExpr *) expr.ptr();
-                codegenStaticObject(x->obj, ctx, out);
-                break;
-            }
+void codegenStaticObject(ObjectPtr x, CodegenContext *ctx, MultiCValuePtr out) {
+    switch (x->objKind) {
+    case ENUM_MEMBER: {
+        EnumMember *y = (EnumMember *)x.ptr();
+        assert(out->size() == 1);
+        CValuePtr out0 = out->values[0];
+        assert(out0->type == y->type);
+        assert(out0->type->typeKind == ENUM_TYPE);
+        initializeEnumType((EnumType *)out0->type.ptr());
+        llvm::Value *llv =
+            llvm::ConstantInt::getSigned(llvmType(y->type), y->index);
+        ctx->builder->CreateStore(llv, out0->llValue);
+        break;
+    }
 
-            default:
-                assert(false);
+    case GLOBAL_VARIABLE: {
+        GlobalVariable *y = (GlobalVariable *)x.ptr();
+        if (y->hasParams()) {
+            assert(out->size() == 1);
+            assert(out->values[0]->type == staticType(x));
+        } else {
+            GVarInstancePtr z = defaultGVarInstance(y);
+            if (!z->llGlobal)
+                codegenGVarInstance(z);
+            assert(out->size() == 1);
+            CValuePtr out0 = out->values[0];
+            assert(out0->type == pointerType(z->type));
+            ctx->builder->CreateStore(z->llGlobal, out0->llValue);
         }
+        break;
     }
 
-    //
-    // codegenStaticObject
-    //
-
-    void codegenStaticObject(ObjectPtr x,
-                             CodegenContext *ctx,
-                             MultiCValuePtr out) {
-        switch (x->objKind) {
-            case ENUM_MEMBER: {
-                EnumMember *y = (EnumMember *) x.ptr();
-                assert(out->size() == 1);
-                CValuePtr out0 = out->values[0];
-                assert(out0->type == y->type);
-                assert(out0->type->typeKind == ENUM_TYPE);
-                initializeEnumType((EnumType *) out0->type.ptr());
-                llvm::Value *llv = llvm::ConstantInt::getSigned(
-                    llvmType(y->type), y->index);
-                ctx->builder->CreateStore(llv, out0->llValue);
-                break;
-            }
-
-            case GLOBAL_VARIABLE: {
-                GlobalVariable *y = (GlobalVariable *) x.ptr();
-                if (y->hasParams()) {
-                    assert(out->size() == 1);
-                    assert(out->values[0]->type == staticType(x));
-                } else {
-                    GVarInstancePtr z = defaultGVarInstance(y);
-                    if (!z->llGlobal)
-                        codegenGVarInstance(z);
-                    assert(out->size() == 1);
-                    CValuePtr out0 = out->values[0];
-                    assert(out0->type == pointerType(z->type));
-                    ctx->builder->CreateStore(z->llGlobal, out0->llValue);
-                }
-                break;
-            }
-
-            case EXTERNAL_VARIABLE: {
-                ExternalVariable *y = (ExternalVariable *) x.ptr();
-                if (!y->llGlobal)
-                    codegenExternalVariable(y);
-                assert(out->size() == 1);
-                CValuePtr out0 = out->values[0];
-                assert(out0->type == pointerType(y->type2));
-                ctx->builder->CreateStore(y->llGlobal, out0->llValue);
-                break;
-            }
-
-            case EXTERNAL_PROCEDURE: {
-                ExternalProcedure *y = (ExternalProcedure *) x.ptr();
-                if (!y->llvmFunc)
-                    codegenExternalProcedure(y, false);
-                assert(out->size() == 1);
-                CValuePtr out0 = out->values[0];
-                assert(out0->type == y->ptrType);
-                llvm::Value *opaqueValue = ctx->builder->CreateBitCast(
-                    y->llvmFunc, llvmType(out0->type));
-                ctx->builder->CreateStore(opaqueValue, out0->llValue);
-                break;
-            }
-
-            case GLOBAL_ALIAS: {
-                GlobalAlias *y = (GlobalAlias *) x.ptr();
-                if (y->hasParams()) {
-                    assert(out->size() == 1);
-                    assert(out->values[0]->type == staticType(x));
-                } else {
-                    codegenExpr(y->expr, y->env, ctx, out);
-                }
-                break;
-            }
-
-            case VALUE_HOLDER: {
-                ValueHolder *y = (ValueHolder *) x.ptr();
-                codegenValueHolder(y, ctx, out);
-                break;
-            }
-
-            case MULTI_STATIC: {
-                MultiStatic *y = (MultiStatic *) x.ptr();
-                assert(y->size() == out->size());
-                for (unsigned i = 0; i < y->size(); ++i) {
-                    MultiCValuePtr out2 = new MultiCValue(out->values[i]);
-                    codegenStaticObject(y->values[i], ctx, out2);
-                }
-                break;
-            }
+    case EXTERNAL_VARIABLE: {
+        ExternalVariable *y = (ExternalVariable *)x.ptr();
+        if (!y->llGlobal)
+            codegenExternalVariable(y);
+        assert(out->size() == 1);
+        CValuePtr out0 = out->values[0];
+        assert(out0->type == pointerType(y->type2));
+        ctx->builder->CreateStore(y->llGlobal, out0->llValue);
+        break;
+    }
 
-            case RECORD_DECL: {
-                RecordDecl *y = (RecordDecl *) x.ptr();
-                ObjectPtr z;
-                if (y->params.empty() && !y->varParam)
-                    z = recordType(y, vector<ObjectPtr>()).ptr();
-                else
-                    z = y;
-                assert(out->size() == 1);
-                assert(out->values[0]->type == staticType(z));
-                break;
-            }
+    case EXTERNAL_PROCEDURE: {
+        ExternalProcedure *y = (ExternalProcedure *)x.ptr();
+        if (!y->llvmFunc)
+            codegenExternalProcedure(y, false);
+        assert(out->size() == 1);
+        CValuePtr out0 = out->values[0];
+        assert(out0->type == y->ptrType);
+        llvm::Value *opaqueValue =
+            ctx->builder->CreateBitCast(y->llvmFunc, llvmType(out0->type));
+        ctx->builder->CreateStore(opaqueValue, out0->llValue);
+        break;
+    }
 
-            case VARIANT_DECL: {
-                VariantDecl *y = (VariantDecl *) x.ptr();
-                ObjectPtr z;
-                if (y->params.empty() && !y->varParam)
-                    z = variantType(y, vector<ObjectPtr>()).ptr();
-                else
-                    z = y;
-                assert(out->size() == 1);
-                assert(out->values[0]->type == staticType(z));
-                break;
-            }
+    case GLOBAL_ALIAS: {
+        GlobalAlias *y = (GlobalAlias *)x.ptr();
+        if (y->hasParams()) {
+            assert(out->size() == 1);
+            assert(out->values[0]->type == staticType(x));
+        } else {
+            codegenExpr(y->expr, y->env, ctx, out);
+        }
+        break;
+    }
 
-            case TYPE:
-            case PRIM_OP:
-            case PROCEDURE:
-            case MODULE:
-            case INTRINSIC:
-            case IDENTIFIER: {
-                assert(out->size() == 1);
-                assert(out->values[0]->type == staticType(x));
-                break;
-            }
+    case VALUE_HOLDER: {
+        ValueHolder *y = (ValueHolder *)x.ptr();
+        codegenValueHolder(y, ctx, out);
+        break;
+    }
 
-            case CVALUE: {
-                CValue *y = (CValue *) x.ptr();
-                assert(out->size() == 1);
-                CValuePtr out0 = out->values[0];
-                codegenValueForward(out0, y, ctx);
-                break;
-            }
+    case MULTI_STATIC: {
+        MultiStatic *y = (MultiStatic *)x.ptr();
+        assert(y->size() == out->size());
+        for (unsigned i = 0; i < y->size(); ++i) {
+            MultiCValuePtr out2 = new MultiCValue(out->values[i]);
+            codegenStaticObject(y->values[i], ctx, out2);
+        }
+        break;
+    }
 
-            case MULTI_CVALUE: {
-                MultiCValue *y = (MultiCValue *) x.ptr();
-                assert(out->size() == y->size());
-                for (unsigned i = 0; i < y->size(); ++i) {
-                    CValuePtr vi = y->values[i];
-                    CValuePtr outi = out->values[i];
-                    codegenValueForward(outi, vi, ctx);
-                }
-                break;
-            }
+    case RECORD_DECL: {
+        RecordDecl *y = (RecordDecl *)x.ptr();
+        ObjectPtr z;
+        if (y->params.empty() && !y->varParam)
+            z = recordType(y, vector<ObjectPtr>()).ptr();
+        else
+            z = y;
+        assert(out->size() == 1);
+        assert(out->values[0]->type == staticType(z));
+        break;
+    }
 
-            case PVALUE: {
-                // allow values of static type
-                PValue *yv = (PValue *) x.ptr();
-                PVData const &y = yv->data;
-                if (y.type->typeKind != STATIC_TYPE)
-                    invalidStaticObjectError(x);
-                assert(out->size() == 1);
-                CValuePtr out0 = out->values[0];
-                if (y.isRValue)
-                    assert(out0->type == y.type);
-                else
-                    assert(out0->type == pointerType(y.type));
-                break;
-            }
+    case VARIANT_DECL: {
+        VariantDecl *y = (VariantDecl *)x.ptr();
+        ObjectPtr z;
+        if (y->params.empty() && !y->varParam)
+            z = variantType(y, vector<ObjectPtr>()).ptr();
+        else
+            z = y;
+        assert(out->size() == 1);
+        assert(out->values[0]->type == staticType(z));
+        break;
+    }
 
-            case MULTI_PVALUE: {
-                // allow values of static type
-                MultiPValue *y = (MultiPValue *) x.ptr();
-                assert(out->size() == y->size());
-                for (unsigned i = 0; i < y->size(); ++i) {
-                    PVData const &pv = y->values[i];
-                    if (pv.type->typeKind != STATIC_TYPE)
-                        argumentInvalidStaticObjectError(i, new PValue(pv));
-                    CValuePtr outi = out->values[i];
-                    if (pv.isRValue)
-                        assert(outi->type == pv.type);
-                    else
-                        assert(outi->type == pointerType(pv.type));
-                }
-                break;
-            }
+    case TYPE:
+    case PRIM_OP:
+    case PROCEDURE:
+    case MODULE:
+    case INTRINSIC:
+    case IDENTIFIER: {
+        assert(out->size() == 1);
+        assert(out->values[0]->type == staticType(x));
+        break;
+    }
 
-            case PATTERN:
-            case MULTI_PATTERN:
-                error("pattern variable cannot be used as value");
-                break;
+    case CVALUE: {
+        CValue *y = (CValue *)x.ptr();
+        assert(out->size() == 1);
+        CValuePtr out0 = out->values[0];
+        codegenValueForward(out0, y, ctx);
+        break;
+    }
 
-            default:
-                invalidStaticObjectError(x);
-                break;
+    case MULTI_CVALUE: {
+        MultiCValue *y = (MultiCValue *)x.ptr();
+        assert(out->size() == y->size());
+        for (unsigned i = 0; i < y->size(); ++i) {
+            CValuePtr vi = y->values[i];
+            CValuePtr outi = out->values[i];
+            codegenValueForward(outi, vi, ctx);
         }
+        break;
     }
 
-    //
-    // codegenGVarInstance
-    //
+    case PVALUE: {
+        // allow values of static type
+        PValue *yv = (PValue *)x.ptr();
+        PVData const &y = yv->data;
+        if (y.type->typeKind != STATIC_TYPE)
+            invalidStaticObjectError(x);
+        assert(out->size() == 1);
+        CValuePtr out0 = out->values[0];
+        if (y.isRValue)
+            assert(out0->type == y.type);
+        else
+            assert(out0->type == pointerType(y.type));
+        break;
+    }
 
-    static void printModuleQualification(llvm::raw_ostream &os, ModulePtr mod) {
-        if (mod != nullptr)
-            os << mod->moduleName << '.';
+    case MULTI_PVALUE: {
+        // allow values of static type
+        MultiPValue *y = (MultiPValue *)x.ptr();
+        assert(out->size() == y->size());
+        for (unsigned i = 0; i < y->size(); ++i) {
+            PVData const &pv = y->values[i];
+            if (pv.type->typeKind != STATIC_TYPE)
+                argumentInvalidStaticObjectError(i, new PValue(pv));
+            CValuePtr outi = out->values[i];
+            if (pv.isRValue)
+                assert(outi->type == pv.type);
+            else
+                assert(outi->type == pointerType(pv.type));
+        }
+        break;
     }
 
-    void codegenGVarInstance(GVarInstancePtr x) {
-        assert(!x->llGlobal);
-        MultiPValuePtr mpv = safeAnalyzeGVarInstance(x);
-        assert(mpv->size() == 1);
-        PVData const &y = mpv->values[0];
-        llvm::Constant *initializer =
-                llvm::Constant::getNullValue(llvmType(y.type));
+    case PATTERN:
+    case MULTI_PATTERN:
+        error("pattern variable cannot be used as value");
+        break;
 
-        llvm::SmallString<128> nameBuf;
-        llvm::raw_svector_ostream nameStr(nameBuf);
-        printModuleQualification(nameStr, safeLookupModule(x->env));
-        nameStr << x->gvar->name->str;
-        if (!x->params.empty()) {
-            nameStr << '[';
-            printNameList(nameStr, x->params);
-            nameStr << ']';
-        }
+    default:
+        invalidStaticObjectError(x);
+        break;
+    }
+}
 
-        llvm::SmallString<128> symbolBuf;
-        llvm::raw_svector_ostream symbolStr(symbolBuf);
-        symbolStr << nameStr.str() << " " << y.type << " clay";
+//
+// codegenGVarInstance
+//
 
-        x->staticGlobal = new ValueHolder(y.type);
-        x->llGlobal = new llvm::GlobalVariable(
-            *llvmModule, llvmType(y.type), false,
-            llvm::GlobalVariable::InternalLinkage,
-            initializer, symbolStr.str());
-        if (llvmDIBuilder != nullptr) {
-            unsigned line, column;
-            llvm::DIFile file = getDebugLineCol(x->gvar->location, line, column);
-            x->debugInfo = (llvm::MDNode *) llvmDIBuilder->createGlobalVariable(
-                nameStr.str(),
-                file,
-                line,
-                llvmTypeDebugInfo(y.type),
-                true, // isLocalToUnit
-                x->llGlobal
-            );
-        }
+static void printModuleQualification(llvm::raw_ostream &os, ModulePtr mod) {
+    if (mod != nullptr)
+        os << mod->moduleName << '.';
+}
 
-        // generate initializer
-        ExprPtr lhs;
-        if (x->gvar->hasParams()) {
-            ExprListPtr indexingArgs = new ExprList();
-            for (size_t i = 0; i < x->params.size(); ++i)
-                indexingArgs->add(new ObjectExpr(x->params[i]));
-            lhs = new Indexing(new NameRef(x->gvar->name), indexingArgs);
-        } else {
-            lhs = new NameRef(x->gvar->name);
-        }
-        lhs->location = x->gvar->name->location;
-        StatementPtr init = new InitAssignment(lhs, x->expr);
-        init->location = x->gvar->location;
-        bool result = codegenStatement(init, x->env, constructorsCtx);
-        assert(!result);
-
-        // generate destructor procedure body
-        codegenCallable(operator_destroy(),
-                        PVData(y.type, false));
-
-        initializedGlobals.push_back(new CValue(y.type, x->llGlobal));
-    }
-
-    //
-    // codegenExternalVariable
-    //
-
-    void codegenExternalVariable(ExternalVariablePtr x) {
-        assert(!x->llGlobal);
-        if (!x->attributesVerified)
-            verifyAttributes(x);
-        PVData pv = analyzeExternalVariable(x);
-        llvm::GlobalVariable::LinkageTypes linkage;
-        if (x->attrDLLImport)
-            linkage = llvm::GlobalVariable::DLLImportLinkage;
-        else if (x->attrDLLExport)
-            linkage = llvm::GlobalVariable::DLLExportLinkage;
-        else
-            linkage = llvm::GlobalVariable::ExternalLinkage;
-        x->llGlobal =
-                new llvm::GlobalVariable(
-                    *llvmModule, llvmType(pv.type), false,
-                    linkage, nullptr, x->name->str.str());
-        if (llvmDIBuilder != nullptr) {
-            unsigned line, column;
-            llvm::DIFile file = getDebugLineCol(x->location, line, column);
-            x->debugInfo = (llvm::MDNode *) llvmDIBuilder->createGlobalVariable(
-                x->name->str,
-                file,
-                line,
-                llvmTypeDebugInfo(x->type2),
-                false, // isLocalToUnit
-                x->llGlobal
-            );
-        }
+void codegenGVarInstance(GVarInstancePtr x) {
+    assert(!x->llGlobal);
+    MultiPValuePtr mpv = safeAnalyzeGVarInstance(x);
+    assert(mpv->size() == 1);
+    PVData const &y = mpv->values[0];
+    llvm::Constant *initializer =
+        llvm::Constant::getNullValue(llvmType(y.type));
+
+    llvm::SmallString<128> nameBuf;
+    llvm::raw_svector_ostream nameStr(nameBuf);
+    printModuleQualification(nameStr, safeLookupModule(x->env));
+    nameStr << x->gvar->name->str;
+    if (!x->params.empty()) {
+        nameStr << '[';
+        printNameList(nameStr, x->params);
+        nameStr << ']';
     }
 
-    //
-    // codegenExternalProcedure
-    //
+    llvm::SmallString<128> symbolBuf;
+    llvm::raw_svector_ostream symbolStr(symbolBuf);
+    symbolStr << nameStr.str() << " " << y.type << " clay";
 
-    void codegenExternalProcedure(ExternalProcedurePtr x, bool codegenBody) {
-        CompileContextPusher pusher(x.ptr());
-
-        ExternalTargetPtr target = getExternalTarget();
+    x->staticGlobal = new ValueHolder(y.type);
+    x->llGlobal = new llvm::GlobalVariable(
+        *llvmModule, llvmType(y.type), false,
+        llvm::GlobalVariable::InternalLinkage, initializer, symbolStr.str());
+    if (llvmDIBuilder != nullptr) {
+        unsigned line, column;
+        llvm::DIFile file = getDebugLineCol(x->gvar->location, line, column);
+        x->debugInfo = (llvm::MDNode *)llvmDIBuilder->createGlobalVariable(
+            nameStr.str(), file, line, llvmTypeDebugInfo(y.type),
+            true, // isLocalToUnit
+            x->llGlobal);
+    }
 
-        if (x->llvmFunc != nullptr && (!codegenBody || x->bodyCodegenned))
-            return;
-        if (!x->analyzed)
-            analyzeExternalProcedure(x);
-        assert(x->analyzed);
+    // generate initializer
+    ExprPtr lhs;
+    if (x->gvar->hasParams()) {
+        ExprListPtr indexingArgs = new ExprList();
+        for (size_t i = 0; i < x->params.size(); ++i)
+            indexingArgs->add(new ObjectExpr(x->params[i]));
+        lhs = new Indexing(new NameRef(x->gvar->name), indexingArgs);
+    } else {
+        lhs = new NameRef(x->gvar->name);
+    }
+    lhs->location = x->gvar->name->location;
+    StatementPtr init = new InitAssignment(lhs, x->expr);
+    init->location = x->gvar->location;
+    bool result = codegenStatement(init, x->env, constructorsCtx);
+    assert(!result);
 
-        vector<TypePtr> argTypes;
-        for (size_t i = 0; i < x->args.size(); ++i)
-            argTypes.push_back(x->args[i]->type2);
+    // generate destructor procedure body
+    codegenCallable(operator_destroy(), PVData(y.type, false));
 
-        ExternalFunction *extFunc = target->getExternalFunction(
-            x->callingConv, x->returnType2, argTypes,
-            argTypes.size(), x->hasVarArgs);
+    initializedGlobals.push_back(new CValue(y.type, x->llGlobal));
+}
 
-        llvm::FunctionType *llFuncType = extFunc->getLLVMFunctionType();
+//
+// codegenExternalVariable
+//
+
+void codegenExternalVariable(ExternalVariablePtr x) {
+    assert(!x->llGlobal);
+    if (!x->attributesVerified)
+        verifyAttributes(x);
+    PVData pv = analyzeExternalVariable(x);
+    llvm::GlobalVariable::LinkageTypes linkage;
+    if (x->attrDLLImport)
+        linkage = llvm::GlobalVariable::DLLImportLinkage;
+    else if (x->attrDLLExport)
+        linkage = llvm::GlobalVariable::DLLExportLinkage;
+    else
+        linkage = llvm::GlobalVariable::ExternalLinkage;
+    x->llGlobal =
+        new llvm::GlobalVariable(*llvmModule, llvmType(pv.type), false, linkage,
+                                 nullptr, x->name->str.str());
+    if (llvmDIBuilder != nullptr) {
+        unsigned line, column;
+        llvm::DIFile file = getDebugLineCol(x->location, line, column);
+        x->debugInfo = (llvm::MDNode *)llvmDIBuilder->createGlobalVariable(
+            x->name->str, file, line, llvmTypeDebugInfo(x->type2),
+            false, // isLocalToUnit
+            x->llGlobal);
+    }
+}
 
-        llvm::GlobalVariable::LinkageTypes linkage;
-        if (x->attrDLLImport)
-            linkage = llvm::GlobalVariable::DLLImportLinkage;
-        else if (x->attrDLLExport)
-            linkage = llvm::GlobalVariable::DLLExportLinkage;
-        else
-            linkage = llvm::GlobalVariable::ExternalLinkage;
-
-        string llvmFuncName;
-        if (!x->attrAsmLabel.empty()) {
-            llvm::StringRef llvmIntrinsicsPrefix = "llvm.";
-            llvm::StringRef prefix(&x->attrAsmLabel[0], llvmIntrinsicsPrefix.size());
-            if (prefix != llvmIntrinsicsPrefix) {
-                // '\01' is the llvm marker to specify asm label
-                llvmFuncName.push_back('\01');
-                llvmFuncName.append(x->attrAsmLabel.begin(), x->attrAsmLabel.end());
-            } else {
-                llvmFuncName.append(x->attrAsmLabel.begin(), x->attrAsmLabel.end());
-            }
+//
+// codegenExternalProcedure
+//
+
+void codegenExternalProcedure(ExternalProcedurePtr x, bool codegenBody) {
+    CompileContextPusher pusher(x.ptr());
+
+    ExternalTargetPtr target = getExternalTarget();
+
+    if (x->llvmFunc != nullptr && (!codegenBody || x->bodyCodegenned))
+        return;
+    if (!x->analyzed)
+        analyzeExternalProcedure(x);
+    assert(x->analyzed);
+
+    vector<TypePtr> argTypes;
+    for (size_t i = 0; i < x->args.size(); ++i)
+        argTypes.push_back(x->args[i]->type2);
+
+    ExternalFunction *extFunc =
+        target->getExternalFunction(x->callingConv, x->returnType2, argTypes,
+                                    argTypes.size(), x->hasVarArgs);
+
+    llvm::FunctionType *llFuncType = extFunc->getLLVMFunctionType();
+
+    llvm::GlobalVariable::LinkageTypes linkage;
+    if (x->attrDLLImport)
+        linkage = llvm::GlobalVariable::DLLImportLinkage;
+    else if (x->attrDLLExport)
+        linkage = llvm::GlobalVariable::DLLExportLinkage;
+    else
+        linkage = llvm::GlobalVariable::ExternalLinkage;
+
+    string llvmFuncName;
+    if (!x->attrAsmLabel.empty()) {
+        llvm::StringRef llvmIntrinsicsPrefix = "llvm.";
+        llvm::StringRef prefix(&x->attrAsmLabel[0],
+                               llvmIntrinsicsPrefix.size());
+        if (prefix != llvmIntrinsicsPrefix) {
+            // '\01' is the llvm marker to specify asm label
+            llvmFuncName.push_back('\01');
+            llvmFuncName.append(x->attrAsmLabel.begin(), x->attrAsmLabel.end());
         } else {
-            llvmFuncName.append(x->name->str.begin(), x->name->str.end());
+            llvmFuncName.append(x->attrAsmLabel.begin(), x->attrAsmLabel.end());
         }
+    } else {
+        llvmFuncName.append(x->name->str.begin(), x->name->str.end());
+    }
 
-        llvm::DIFile file(nullptr);
-        unsigned line = 0, column = 0;
-        if (x->llvmFunc == nullptr) {
-            llvm::Function *func = llvmModule->getFunction(llvmFuncName);
-            if (!func) {
-                func = llvm::Function::Create(llFuncType,
-                                              linkage,
-                                              llvmFuncName,
-                                              llvmModule);
-            }
-            x->llvmFunc = func;
-            llvm::CallingConv::ID callingConv = extFunc->llConv;
-            x->llvmFunc->setCallingConv(callingConv);
-            for (vector<pair<unsigned, llvm::Attributes> >::iterator
-                 attr = extFunc->attrs.begin();
-                 attr != extFunc->attrs.end();
-                 ++attr)
-                func->addAttribute(attr->first, attr->second);
-
-            if (llvmDIBuilder != nullptr) {
-                file = getDebugLineCol(x->location, line, column);
-
-                vector<llvm::Value *> debugParamTypes;
-                if (x->returnType2 == nullptr)
-                    debugParamTypes.push_back(llvmVoidTypeDebugInfo());
-                else
-                    debugParamTypes.push_back(llvmTypeDebugInfo(x->returnType2));
-                for (size_t i = 0; i < x->args.size(); ++i)
-                    debugParamTypes.push_back(llvmTypeDebugInfo(x->args[i]->type2));
-
-                llvm::DIArray debugParamArray = llvmDIBuilder->getOrCreateArray(
-                    llvm::ArrayRef(debugParamTypes));
-
-                llvm::DIType typeDebugInfo = llvmDIBuilder->createSubroutineType(
-                    file, // file
-                    debugParamArray);
-
-                x->debugInfo = (llvm::MDNode *) llvmDIBuilder->createFunction(
-                    lookupModuleDebugInfo(x->env), // scope
-                    x->name->str, // name
-                    llvmFuncName, // linkage name
-                    file, // file
-                    line, // line
-                    typeDebugInfo, // type
-                    false, // isLocalToUnit
-                    !!x->body, // isDefinition XXX
-                    0, // flags
-                    false, // isOptimized
-                    x->llvmFunc // function
-                );
-            }
+    llvm::DIFile file(nullptr);
+    unsigned line = 0, column = 0;
+    if (x->llvmFunc == nullptr) {
+        llvm::Function *func = llvmModule->getFunction(llvmFuncName);
+        if (!func) {
+            func = llvm::Function::Create(llFuncType, linkage, llvmFuncName,
+                                          llvmModule);
         }
+        x->llvmFunc = func;
+        llvm::CallingConv::ID callingConv = extFunc->llConv;
+        x->llvmFunc->setCallingConv(callingConv);
+        for (vector<pair<unsigned, llvm::Attributes>>::iterator attr =
+                 extFunc->attrs.begin();
+             attr != extFunc->attrs.end(); ++attr)
+            func->addAttribute(attr->first, attr->second);
 
-        if (!codegenBody)
-            return;
+        if (llvmDIBuilder != nullptr) {
+            file = getDebugLineCol(x->location, line, column);
 
-        x->bodyCodegenned = true;
-        if (!x->body)
-            return;
+            vector<llvm::Value *> debugParamTypes;
+            if (x->returnType2 == nullptr)
+                debugParamTypes.push_back(llvmVoidTypeDebugInfo());
+            else
+                debugParamTypes.push_back(llvmTypeDebugInfo(x->returnType2));
+            for (size_t i = 0; i < x->args.size(); ++i)
+                debugParamTypes.push_back(llvmTypeDebugInfo(x->args[i]->type2));
 
-        CodegenContext ctx(x->llvmFunc);
+            llvm::DIArray debugParamArray = llvmDIBuilder->getOrCreateArray(
+                llvm::ArrayRef(debugParamTypes));
 
-        if (llvmDIBuilder != nullptr) {
-            ctx.pushDebugScope(llvmDIBuilder->createLexicalBlock(
-                x->getDebugInfo(),
-                file,
-                line,
-                column
-            ));
+            llvm::DIType typeDebugInfo =
+                llvmDIBuilder->createSubroutineType(file, // file
+                                                    debugParamArray);
+
+            x->debugInfo = (llvm::MDNode *)llvmDIBuilder->createFunction(
+                lookupModuleDebugInfo(x->env), // scope
+                x->name->str,                  // name
+                llvmFuncName,                  // linkage name
+                file,                          // file
+                line,                          // line
+                typeDebugInfo,                 // type
+                false,                         // isLocalToUnit
+                !!x->body,                     // isDefinition XXX
+                0,                             // flags
+                false,                         // isOptimized
+                x->llvmFunc                    // function
+            );
         }
+    }
 
-        llvm::BasicBlock *initBlock = newBasicBlock("init", &ctx);
-        llvm::BasicBlock *codeBlock = newBasicBlock("code", &ctx);
-        llvm::BasicBlock *returnBlock = newBasicBlock("return", &ctx);
-        llvm::BasicBlock *exceptionBlock = newBasicBlock("exception", &ctx);
-
-        ctx.initBuilder.reset(new llvm::IRBuilder<>(initBlock));
-        ctx.builder.reset(new llvm::IRBuilder<>(codeBlock));
+    if (!codegenBody)
+        return;
 
-        if (llvmDIBuilder != nullptr) {
-            llvm::DebugLoc debugLoc = llvm::DebugLoc::get(line, column, x->getDebugInfo());
-            ctx.initBuilder->SetCurrentDebugLocation(debugLoc);
-            ctx.builder->SetCurrentDebugLocation(debugLoc);
-        }
+    x->bodyCodegenned = true;
+    if (!x->body)
+        return;
 
-        ctx.exceptionValue = ctx.initBuilder->CreateAlloca(exceptionReturnType(), nullptr, "exception");
+    CodegenContext ctx(x->llvmFunc);
 
-        EnvPtr env = new Env(x->env);
-        vector<CReturn> returns;
+    if (llvmDIBuilder != nullptr) {
+        ctx.pushDebugScope(llvmDIBuilder->createLexicalBlock(
+            x->getDebugInfo(), file, line, column));
+    }
 
-        llvm::Function::arg_iterator ai = x->llvmFunc->arg_begin();
+    llvm::BasicBlock *initBlock = newBasicBlock("init", &ctx);
+    llvm::BasicBlock *codeBlock = newBasicBlock("code", &ctx);
+    llvm::BasicBlock *returnBlock = newBasicBlock("return", &ctx);
+    llvm::BasicBlock *exceptionBlock = newBasicBlock("exception", &ctx);
 
-        extFunc->allocReturnValue(extFunc->retInfo, ai, returns, &ctx);
+    ctx.initBuilder.reset(new llvm::IRBuilder<>(initBlock));
+    ctx.builder.reset(new llvm::IRBuilder<>(codeBlock));
 
-        for (size_t i = 0; i < x->args.size(); ++i) {
-            ExternalArgPtr arg = x->args[i];
-            CValuePtr cvalue = extFunc->allocArgumentValue(
-                extFunc->argInfos[i], arg->name->str, ai, &ctx);
-            addLocal(env, arg->name, cvalue.ptr());
-            if (llvmDIBuilder != nullptr) {
-                unsigned line, column;
-                Location argLocation = arg->location;
-                llvm::DIFile file = getDebugLineCol(argLocation, line, column);
-                llvm::DIVariable debugVar = llvmDIBuilder->createLocalVariable(
-                    llvm::dwarf::DW_TAG_variable, // tag
-                    x->getDebugInfo(), // scope
-                    arg->name->str, // name
-                    file, // file
-                    line, // line
-                    llvmTypeDebugInfo(arg->type2), // type
-                    true, // alwaysPreserve
-                    0, // flags
-                    unsigned(i) + 1 // argNo
-                );
-                llvm::Value *argValue = cvalue->llValue;
-                llvmDIBuilder->insertDeclare(
-                            argValue,
-                            debugVar,
-                            initBlock)
-                        ->setDebugLoc(ctx.initBuilder->getCurrentDebugLocation());
-            }
-        }
+    if (llvmDIBuilder != nullptr) {
+        llvm::DebugLoc debugLoc =
+            llvm::DebugLoc::get(line, column, x->getDebugInfo());
+        ctx.initBuilder->SetCurrentDebugLocation(debugLoc);
+        ctx.builder->SetCurrentDebugLocation(debugLoc);
+    }
 
-        ctx.returnLists.push_back(returns);
-        JumpTarget returnTarget(returnBlock, cgMarkStack(&ctx));
-        ctx.returnTargets.push_back(returnTarget);
-        JumpTarget exceptionTarget(exceptionBlock, cgMarkStack(&ctx));
-        ctx.exceptionTargets.push_back(exceptionTarget);
+    ctx.exceptionValue = ctx.initBuilder->CreateAlloca(exceptionReturnType(),
+                                                       nullptr, "exception");
 
-        bool terminated = codegenStatement(x->body, env, &ctx);
-        if (!terminated) {
-            if (x->returnType2.ptr()) {
-                error(x, "not all paths have a return statement");
-            }
-            cgDestroyStack(returnTarget.stackMarker, &ctx, false);
-            ctx.builder->CreateBr(returnBlock);
-        }
-        cgPopStack(returnTarget.stackMarker, &ctx);
+    EnvPtr env = new Env(x->env);
+    vector<CReturn> returns;
 
-        returnBlock->moveAfter(ctx.builder->GetInsertBlock());
-        exceptionBlock->moveAfter(returnBlock);
+    llvm::Function::arg_iterator ai = x->llvmFunc->arg_begin();
 
-        ctx.builder->SetInsertPoint(returnBlock);
-        extFunc->returnStatement(extFunc->retInfo, returns, &ctx);
+    extFunc->allocReturnValue(extFunc->retInfo, ai, returns, &ctx);
 
-        ctx.builder->SetInsertPoint(exceptionBlock);
-        if (exceptionsEnabled()) {
-            ObjectPtr callable = operator_unhandledExceptionInExternal();
-            codegenCallValue(staticCValue(callable, &ctx),
-                             new MultiCValue(),
-                             &ctx,
-                             new MultiCValue());
+    for (size_t i = 0; i < x->args.size(); ++i) {
+        ExternalArgPtr arg = x->args[i];
+        CValuePtr cvalue = extFunc->allocArgumentValue(
+            extFunc->argInfos[i], arg->name->str, ai, &ctx);
+        addLocal(env, arg->name, cvalue.ptr());
+        if (llvmDIBuilder != nullptr) {
+            unsigned line, column;
+            Location argLocation = arg->location;
+            llvm::DIFile file = getDebugLineCol(argLocation, line, column);
+            llvm::DIVariable debugVar = llvmDIBuilder->createLocalVariable(
+                llvm::dwarf::DW_TAG_variable,  // tag
+                x->getDebugInfo(),             // scope
+                arg->name->str,                // name
+                file,                          // file
+                line,                          // line
+                llvmTypeDebugInfo(arg->type2), // type
+                true,                          // alwaysPreserve
+                0,                             // flags
+                unsigned(i) + 1                // argNo
+            );
+            llvm::Value *argValue = cvalue->llValue;
+            llvmDIBuilder->insertDeclare(argValue, debugVar, initBlock)
+                ->setDebugLoc(ctx.initBuilder->getCurrentDebugLocation());
         }
-        ctx.builder->CreateUnreachable();
+    }
 
-        ctx.initBuilder->CreateBr(codeBlock);
+    ctx.returnLists.push_back(returns);
+    JumpTarget returnTarget(returnBlock, cgMarkStack(&ctx));
+    ctx.returnTargets.push_back(returnTarget);
+    JumpTarget exceptionTarget(exceptionBlock, cgMarkStack(&ctx));
+    ctx.exceptionTargets.push_back(exceptionTarget);
+
+    bool terminated = codegenStatement(x->body, env, &ctx);
+    if (!terminated) {
+        if (x->returnType2.ptr()) {
+            error(x, "not all paths have a return statement");
+        }
+        cgDestroyStack(returnTarget.stackMarker, &ctx, false);
+        ctx.builder->CreateBr(returnBlock);
     }
+    cgPopStack(returnTarget.stackMarker, &ctx);
 
-    //
-    // codegenValueHolder
-    //
+    returnBlock->moveAfter(ctx.builder->GetInsertBlock());
+    exceptionBlock->moveAfter(returnBlock);
 
-    void codegenValueHolder(ValueHolderPtr v,
-                            CodegenContext *ctx,
-                            MultiCValuePtr out) {
-        EValuePtr ev = new EValue(v->type, v->buf);
-        codegenCompileTimeValue(ev, ctx, out);
+    ctx.builder->SetInsertPoint(returnBlock);
+    extFunc->returnStatement(extFunc->retInfo, returns, &ctx);
+
+    ctx.builder->SetInsertPoint(exceptionBlock);
+    if (exceptionsEnabled()) {
+        ObjectPtr callable = operator_unhandledExceptionInExternal();
+        codegenCallValue(staticCValue(callable, &ctx), new MultiCValue(), &ctx,
+                         new MultiCValue());
     }
+    ctx.builder->CreateUnreachable();
 
-    //
-    // codegenCompileTimeValue
-    //
+    ctx.initBuilder->CreateBr(codeBlock);
+}
 
-    void codegenCompileTimeValue(EValuePtr ev,
-                                 CodegenContext *ctx,
-                                 MultiCValuePtr out) {
-        assert(out->size() == 1);
-        CValuePtr out0 = out->values[0];
-        assert(out0->type == ev->type);
-
-        switch (ev->type->typeKind) {
-            case BOOL_TYPE:
-            case INTEGER_TYPE:
-            case FLOAT_TYPE: {
-                llvm::Value *llv = codegenSimpleConstant(ev);
-                ctx->builder->CreateStore(llv, out0->llValue);
-                break;
-            }
+//
+// codegenValueHolder
+//
 
-            case COMPLEX_TYPE: {
-                ComplexType *tt = (ComplexType *) ev->type.ptr();
-                const llvm::StructLayout *layout = complexTypeLayout(tt);
-                char *srcPtr = ev->addr + layout->getElementOffset(1);
-                EValuePtr evSrc = new EValue(floatType(tt->bits), srcPtr);
-                llvm::Value *destPtr = ctx->builder->CreateConstGEP2_32(out0->llValue, 0, 0);
-                CValuePtr cgDest = new CValue(floatType(tt->bits), destPtr);
-                codegenCompileTimeValue(evSrc, ctx, new MultiCValue(cgDest));
-                char *srcPtr2 = ev->addr + layout->getElementOffset(0);
-                EValuePtr evSrc2 = new EValue(imagType(tt->bits), srcPtr2);
-                llvm::Value *destPtr2 = ctx->builder->CreateConstGEP2_32(out0->llValue, 0, 1);
-                CValuePtr cgDest2 = new CValue(imagType(tt->bits), destPtr2);
-                codegenCompileTimeValue(evSrc2, ctx, new MultiCValue(cgDest2));
-                break;
-            }
+void codegenValueHolder(ValueHolderPtr v, CodegenContext *ctx,
+                        MultiCValuePtr out) {
+    EValuePtr ev = new EValue(v->type, v->buf);
+    codegenCompileTimeValue(ev, ctx, out);
+}
 
-            case POINTER_TYPE:
-            case CODE_POINTER_TYPE:
-            case CCODE_POINTER_TYPE:
-                error("pointer constants are not supported");
-                break;
+//
+// codegenCompileTimeValue
+//
 
-            case STATIC_TYPE: {
-                break;
-            }
+void codegenCompileTimeValue(EValuePtr ev, CodegenContext *ctx,
+                             MultiCValuePtr out) {
+    assert(out->size() == 1);
+    CValuePtr out0 = out->values[0];
+    assert(out0->type == ev->type);
+
+    switch (ev->type->typeKind) {
+    case BOOL_TYPE:
+    case INTEGER_TYPE:
+    case FLOAT_TYPE: {
+        llvm::Value *llv = codegenSimpleConstant(ev);
+        ctx->builder->CreateStore(llv, out0->llValue);
+        break;
+    }
 
-            case TUPLE_TYPE: {
-                TupleType *tt = (TupleType *) ev->type.ptr();
-                const llvm::StructLayout *layout = tupleTypeLayout(tt);
-                for (unsigned i = 0; i < tt->elementTypes.size(); ++i) {
-                    char *srcPtr = ev->addr + layout->getElementOffset(i);
-                    EValuePtr evSrc = new EValue(tt->elementTypes[i], srcPtr);
-                    llvm::Value *destPtr =
-                            ctx->builder->CreateConstGEP2_32(out0->llValue, 0, i);
-                    CValuePtr cgDest = new CValue(tt->elementTypes[i], destPtr);
-                    codegenCompileTimeValue(evSrc, ctx, new MultiCValue(cgDest));
-                }
-                break;
-            }
+    case COMPLEX_TYPE: {
+        ComplexType *tt = (ComplexType *)ev->type.ptr();
+        const llvm::StructLayout *layout = complexTypeLayout(tt);
+        char *srcPtr = ev->addr + layout->getElementOffset(1);
+        EValuePtr evSrc = new EValue(floatType(tt->bits), srcPtr);
+        llvm::Value *destPtr =
+            ctx->builder->CreateConstGEP2_32(out0->llValue, 0, 0);
+        CValuePtr cgDest = new CValue(floatType(tt->bits), destPtr);
+        codegenCompileTimeValue(evSrc, ctx, new MultiCValue(cgDest));
+        char *srcPtr2 = ev->addr + layout->getElementOffset(0);
+        EValuePtr evSrc2 = new EValue(imagType(tt->bits), srcPtr2);
+        llvm::Value *destPtr2 =
+            ctx->builder->CreateConstGEP2_32(out0->llValue, 0, 1);
+        CValuePtr cgDest2 = new CValue(imagType(tt->bits), destPtr2);
+        codegenCompileTimeValue(evSrc2, ctx, new MultiCValue(cgDest2));
+        break;
+    }
 
-            case ARRAY_TYPE: {
-                ArrayType *arrayType = (ArrayType *) ev->type.ptr();
+    case POINTER_TYPE:
+    case CODE_POINTER_TYPE:
+    case CCODE_POINTER_TYPE:
+        error("pointer constants are not supported");
+        break;
 
-                for (size_t i = 0; i < (size_t) arrayType->size; ++i) {
-                    char *elementPtr = ev->addr + i * typeSize(arrayType->elementType);
-                    EValuePtr elementValue = new EValue(arrayType->elementType, elementPtr);
-                    llvm::Value *destPtr =
-                            ctx->builder->CreateConstGEP2_32(out0->llValue, 0, i);
-                    CValuePtr cgDest = new CValue(arrayType->elementType, destPtr);
-                    codegenCompileTimeValue(elementValue, ctx, new MultiCValue(cgDest));
-                }
-                break;
-            }
+    case STATIC_TYPE: {
+        break;
+    }
 
-            default: {
-                string buf;
-                llvm::raw_string_ostream sout(buf);
-                sout << "constants of type " << ev->type
-                        << " are not yet supported";
-                error(sout.str());
-                break;
-            }
+    case TUPLE_TYPE: {
+        TupleType *tt = (TupleType *)ev->type.ptr();
+        const llvm::StructLayout *layout = tupleTypeLayout(tt);
+        for (unsigned i = 0; i < tt->elementTypes.size(); ++i) {
+            char *srcPtr = ev->addr + layout->getElementOffset(i);
+            EValuePtr evSrc = new EValue(tt->elementTypes[i], srcPtr);
+            llvm::Value *destPtr =
+                ctx->builder->CreateConstGEP2_32(out0->llValue, 0, i);
+            CValuePtr cgDest = new CValue(tt->elementTypes[i], destPtr);
+            codegenCompileTimeValue(evSrc, ctx, new MultiCValue(cgDest));
         }
+        break;
     }
 
-    //
-    // codegenSimpleConstant
-    //
-
-    template<typename T>
-    llvm::Value *
-    _sintConstant(EValuePtr ev) {
-        return llvm::ConstantInt::getSigned(llvmType(ev->type),
-                                            *((T *) ev->addr));
+    case ARRAY_TYPE: {
+        ArrayType *arrayType = (ArrayType *)ev->type.ptr();
+
+        for (size_t i = 0; i < (size_t)arrayType->size; ++i) {
+            char *elementPtr = ev->addr + i * typeSize(arrayType->elementType);
+            EValuePtr elementValue =
+                new EValue(arrayType->elementType, elementPtr);
+            llvm::Value *destPtr =
+                ctx->builder->CreateConstGEP2_32(out0->llValue, 0, i);
+            CValuePtr cgDest = new CValue(arrayType->elementType, destPtr);
+            codegenCompileTimeValue(elementValue, ctx, new MultiCValue(cgDest));
+        }
+        break;
     }
 
-    template<typename T>
-    llvm::Value *
-    _uintConstant(EValuePtr ev) {
-        return llvm::ConstantInt::get(llvmType(ev->type),
-                                      *((T *) ev->addr));
+    default: {
+        string buf;
+        llvm::raw_string_ostream sout(buf);
+        sout << "constants of type " << ev->type << " are not yet supported";
+        error(sout.str());
+        break;
+    }
     }
+}
 
-    llvm::Value *codegenSimpleConstant(EValuePtr ev) {
-        llvm::Value *val = nullptr;
-        uint64_t bits[] = {0, 0};
+//
+// codegenSimpleConstant
+//
 
-        switch (ev->type->typeKind) {
-            case BOOL_TYPE: {
-                unsigned bv = (*(bool *) ev->addr) ? 1 : 0;
-                return llvm::ConstantInt::get(llvmType(boolType), bv);
-            }
-            case INTEGER_TYPE: {
-                IntegerType *t = (IntegerType *) ev->type.ptr();
-                if (t->isSigned) {
-                    switch (t->bits) {
-                        case 8:
-                            val = _sintConstant<char>(ev);
-                            break;
-                        case 16:
-                            val = _sintConstant<short>(ev);
-                            break;
-                        case 32:
-                            val = _sintConstant<int>(ev);
-                            break;
-                        case 64:
-                            val = _sintConstant<long long>(ev);
-                            break;
-                        case 128:
-                            val = _sintConstant<clay_int128>(ev);
-                            break;
-                        default:
-                            assert(false);
-                    }
-                } else {
-                    switch (t->bits) {
-                        case 8:
-                            val = _uintConstant<unsigned char>(ev);
-                            break;
-                        case 16:
-                            val = _uintConstant<unsigned short>(ev);
-                            break;
-                        case 32:
-                            val = _uintConstant<unsigned int>(ev);
-                            break;
-                        case 64:
-                            val = _uintConstant<unsigned long long>(ev);
-                            break;
-                        case 128:
-                            val = _uintConstant<clay_uint128>(ev);
-                            break;
-                        default:
-                            assert(false);
-                    }
-                }
+template <typename T> llvm::Value *_sintConstant(EValuePtr ev) {
+    return llvm::ConstantInt::getSigned(llvmType(ev->type), *((T *)ev->addr));
+}
+
+template <typename T> llvm::Value *_uintConstant(EValuePtr ev) {
+    return llvm::ConstantInt::get(llvmType(ev->type), *((T *)ev->addr));
+}
+
+llvm::Value *codegenSimpleConstant(EValuePtr ev) {
+    llvm::Value *val = nullptr;
+    uint64_t bits[] = {0, 0};
+
+    switch (ev->type->typeKind) {
+    case BOOL_TYPE: {
+        unsigned bv = (*(bool *)ev->addr) ? 1 : 0;
+        return llvm::ConstantInt::get(llvmType(boolType), bv);
+    }
+    case INTEGER_TYPE: {
+        IntegerType *t = (IntegerType *)ev->type.ptr();
+        if (t->isSigned) {
+            switch (t->bits) {
+            case 8:
+                val = _sintConstant<char>(ev);
                 break;
-            }
-            case FLOAT_TYPE: {
-                FloatType *t = (FloatType *) ev->type.ptr();
-                switch (t->bits) {
-                    case 32:
-                        val = llvm::ConstantFP::get(llvmType(t), *((float *) ev->addr));
-                        break;
-                    case 64:
-                        val = llvm::ConstantFP::get(llvmType(t), *((double *) ev->addr));
-                        break;
-                    case 80:
-                        //use APfloat to get an 80bit value
-                        bits[0] = *(uint64_t *) ev->addr;
-                        bits[1] = *(uint16_t *) ((uint64_t *) ev->addr + 1);
-                        val = llvm::ConstantFP::get(llvmContext, llvm::APFloat(llvm::APInt(80, 2, bits)));
-                        break;
-                    default:
-                        assert(false);
-                }
+            case 16:
+                val = _sintConstant<short>(ev);
+                break;
+            case 32:
+                val = _sintConstant<int>(ev);
+                break;
+            case 64:
+                val = _sintConstant<long long>(ev);
                 break;
+            case 128:
+                val = _sintConstant<clay_int128>(ev);
+                break;
+            default:
+                assert(false);
             }
-
+        } else {
+            switch (t->bits) {
+            case 8:
+                val = _uintConstant<unsigned char>(ev);
+                break;
+            case 16:
+                val = _uintConstant<unsigned short>(ev);
+                break;
+            case 32:
+                val = _uintConstant<unsigned int>(ev);
+                break;
+            case 64:
+                val = _uintConstant<unsigned long long>(ev);
+                break;
+            case 128:
+                val = _uintConstant<clay_uint128>(ev);
+                break;
             default:
                 assert(false);
+            }
+        }
+        break;
+    }
+    case FLOAT_TYPE: {
+        FloatType *t = (FloatType *)ev->type.ptr();
+        switch (t->bits) {
+        case 32:
+            val = llvm::ConstantFP::get(llvmType(t), *((float *)ev->addr));
+            break;
+        case 64:
+            val = llvm::ConstantFP::get(llvmType(t), *((double *)ev->addr));
+            break;
+        case 80:
+            // use APfloat to get an 80bit value
+            bits[0] = *(uint64_t *)ev->addr;
+            bits[1] = *(uint16_t *)((uint64_t *)ev->addr + 1);
+            val = llvm::ConstantFP::get(
+                llvmContext, llvm::APFloat(llvm::APInt(80, 2, bits)));
+            break;
+        default:
+            assert(false);
         }
-        return val;
+        break;
     }
 
-    //
-    // codegenIndexingExpr
-    //
+    default:
+        assert(false);
+    }
+    return val;
+}
 
-    void codegenIndexingExpr(ExprPtr indexable,
-                             ExprListPtr args,
-                             EnvPtr env,
-                             CodegenContext *ctx,
-                             MultiCValuePtr out) {
-        MultiPValuePtr mpv = safeAnalyzeIndexingExpr(indexable, args, env);
-        assert(mpv->size() == out->size());
-        bool allTempStatics = true;
-        for (unsigned i = 0; i < mpv->size(); ++i) {
-            PVData const &pv = mpv->values[i];
-            if (pv.isRValue)
-                assert(out->values[i]->type == pv.type);
-            else
-                assert(out->values[i]->type == pointerType(pv.type));
-            if ((pv.type->typeKind != STATIC_TYPE) || !pv.isRValue) {
-                allTempStatics = false;
-            }
+//
+// codegenIndexingExpr
+//
+
+void codegenIndexingExpr(ExprPtr indexable, ExprListPtr args, EnvPtr env,
+                         CodegenContext *ctx, MultiCValuePtr out) {
+    MultiPValuePtr mpv = safeAnalyzeIndexingExpr(indexable, args, env);
+    assert(mpv->size() == out->size());
+    bool allTempStatics = true;
+    for (unsigned i = 0; i < mpv->size(); ++i) {
+        PVData const &pv = mpv->values[i];
+        if (pv.isRValue)
+            assert(out->values[i]->type == pv.type);
+        else
+            assert(out->values[i]->type == pointerType(pv.type));
+        if ((pv.type->typeKind != STATIC_TYPE) || !pv.isRValue) {
+            allTempStatics = false;
         }
-        if (allTempStatics) {
-            // takes care of type constructors
+    }
+    if (allTempStatics) {
+        // takes care of type constructors
+        return;
+    }
+    PVData pv = safeAnalyzeOne(indexable, env);
+    if (pv.type->typeKind == STATIC_TYPE) {
+        StaticType *st = (StaticType *)pv.type.ptr();
+        ObjectPtr obj = st->obj;
+        if (obj->objKind == GLOBAL_ALIAS) {
+            GlobalAlias *x = (GlobalAlias *)obj.ptr();
+            codegenAliasIndexing(x, args, env, ctx, out);
             return;
         }
-        PVData pv = safeAnalyzeOne(indexable, env);
-        if (pv.type->typeKind == STATIC_TYPE) {
-            StaticType *st = (StaticType *) pv.type.ptr();
-            ObjectPtr obj = st->obj;
-            if (obj->objKind == GLOBAL_ALIAS) {
-                GlobalAlias *x = (GlobalAlias *) obj.ptr();
-                codegenAliasIndexing(x, args, env, ctx, out);
-                return;
-            }
-            if (obj->objKind == GLOBAL_VARIABLE) {
-                GlobalVariable *x = (GlobalVariable *) obj.ptr();
-                GVarInstancePtr y = analyzeGVarIndexing(x, args, env);
-                if (!y->llGlobal)
-                    codegenGVarInstance(y);
-                assert(out->size() == 1);
-                CValuePtr out0 = out->values[0];
-                assert(out0->type == pointerType(y->type));
-                ctx->builder->CreateStore(y->llGlobal, out0->llValue);
-                return;
-            }
-        }
-        ExprListPtr args2 = new ExprList(indexable);
-        args2->add(args);
-        codegenCallExpr(operator_expr_index(), args2, env, ctx, out);
-    }
-
-    //
-    // codegenAliasIndexing
-    //
-
-    void codegenAliasIndexing(GlobalAliasPtr x,
-                              ExprListPtr args,
-                              EnvPtr env,
-                              CodegenContext *ctx,
-                              MultiCValuePtr out) {
-        assert(x->hasParams());
-        MultiStaticPtr params = evaluateMultiStatic(args, env);
-        if (x->varParam.ptr()) {
-            if (params->size() < x->params.size())
-                arityError2(x->params.size(), params->size());
-        } else {
-            ensureArity(params, x->params.size());
-        }
-        EnvPtr bodyEnv = new Env(x->env);
-        for (size_t i = 0; i < x->params.size(); ++i) {
-            addLocal(bodyEnv, x->params[i], params->values[i]);
-        }
-        if (x->varParam.ptr()) {
-            MultiStaticPtr varParams = new MultiStatic();
-            for (size_t i = x->params.size(); i < params->size(); ++i)
-                varParams->add(params->values[i]);
-            addLocal(bodyEnv, x->varParam, varParams.ptr());
-        }
-        AnalysisCachingDisabler disabler;
-        codegenExpr(x->expr, bodyEnv, ctx, out);
-    }
-
-    //
-    // codegenIntrinsic
-    //
-
-    llvm::Constant *valueHolderToLLVMConstant(ValueHolder *vh, CodegenContext *ctx) {
-        switch (vh->type->typeKind) {
-            case INTEGER_TYPE: {
-                IntegerType *intType = (IntegerType *) vh->type.ptr();
-                switch (intType->bits) {
-                    case 8:
-                        return ctx->builder->getInt8(vh->as<uint8_t>());
-                    case 16:
-                        return ctx->builder->getInt16(vh->as<uint16_t>());
-                    case 32:
-                        return ctx->builder->getInt32(vh->as<uint32_t>());
-                    case 64:
-                        return ctx->builder->getInt64(vh->as<uint64_t>());
-                    case 128:
-                        error("static Int128 arguments to intrinsics not yet supported");
-                        return nullptr;
-                    default:
-                        assert(false && "unexpected int type used as static intrinsic argument!");
-                        return nullptr;
-                }
-            }
-            case BOOL_TYPE: {
-                return ctx->builder->getInt1(vh->as<bool>());
-            }
-            default:
-                // XXX should catch this at analysis time
-                error("static argument to intrinsic must be a boolean or integer static");
-                return nullptr;
+        if (obj->objKind == GLOBAL_VARIABLE) {
+            GlobalVariable *x = (GlobalVariable *)obj.ptr();
+            GVarInstancePtr y = analyzeGVarIndexing(x, args, env);
+            if (!y->llGlobal)
+                codegenGVarInstance(y);
+            assert(out->size() == 1);
+            CValuePtr out0 = out->values[0];
+            assert(out0->type == pointerType(y->type));
+            ctx->builder->CreateStore(y->llGlobal, out0->llValue);
+            return;
         }
     }
+    ExprListPtr args2 = new ExprList(indexable);
+    args2->add(args);
+    codegenCallExpr(operator_expr_index(), args2, env, ctx, out);
+}
 
-    static void codegenIntrinsic(IntrinsicSymbol *intrin, MultiCValue *args,
-                                 CodegenContext *ctx, MultiCValuePtr out) {
-        vector<TypePtr> argsKey;
-        args->toArgsKey(&argsKey);
-
-        map<vector<TypePtr>, IntrinsicInstance>::const_iterator instanceI
-                = intrin->instances.find(argsKey);
-        assert(instanceI != intrin->instances.end());
+//
+// codegenAliasIndexing
+//
+
+void codegenAliasIndexing(GlobalAliasPtr x, ExprListPtr args, EnvPtr env,
+                          CodegenContext *ctx, MultiCValuePtr out) {
+    assert(x->hasParams());
+    MultiStaticPtr params = evaluateMultiStatic(args, env);
+    if (x->varParam.ptr()) {
+        if (params->size() < x->params.size())
+            arityError2(x->params.size(), params->size());
+    } else {
+        ensureArity(params, x->params.size());
+    }
+    EnvPtr bodyEnv = new Env(x->env);
+    for (size_t i = 0; i < x->params.size(); ++i) {
+        addLocal(bodyEnv, x->params[i], params->values[i]);
+    }
+    if (x->varParam.ptr()) {
+        MultiStaticPtr varParams = new MultiStatic();
+        for (size_t i = x->params.size(); i < params->size(); ++i)
+            varParams->add(params->values[i]);
+        addLocal(bodyEnv, x->varParam, varParams.ptr());
+    }
+    AnalysisCachingDisabler disabler;
+    codegenExpr(x->expr, bodyEnv, ctx, out);
+}
 
-        IntrinsicInstance const &instance = instanceI->second;
-        if (instance.function == nullptr) {
-            assert(!instance.error.empty());
-            error(instance.error);
+//
+// codegenIntrinsic
+//
+
+llvm::Constant *valueHolderToLLVMConstant(ValueHolder *vh,
+                                          CodegenContext *ctx) {
+    switch (vh->type->typeKind) {
+    case INTEGER_TYPE: {
+        IntegerType *intType = (IntegerType *)vh->type.ptr();
+        switch (intType->bits) {
+        case 8:
+            return ctx->builder->getInt8(vh->as<uint8_t>());
+        case 16:
+            return ctx->builder->getInt16(vh->as<uint16_t>());
+        case 32:
+            return ctx->builder->getInt32(vh->as<uint32_t>());
+        case 64:
+            return ctx->builder->getInt64(vh->as<uint64_t>());
+        case 128:
+            error("static Int128 arguments to intrinsics not yet supported");
+            return nullptr;
+        default:
+            assert(false &&
+                   "unexpected int type used as static intrinsic argument!");
+            return nullptr;
         }
+    }
+    case BOOL_TYPE: {
+        return ctx->builder->getInt1(vh->as<bool>());
+    }
+    default:
+        // XXX should catch this at analysis time
+        error(
+            "static argument to intrinsic must be a boolean or integer static");
+        return nullptr;
+    }
+}
 
-        llvm::FunctionType *funTy = instance.function->getFunctionType();
-        llvm::SmallVector<llvm::Value *, 8> funArgs;
-
-        assert(args->size() == funTy->getNumParams());
-
-        for (vector<CValuePtr>::const_iterator i = args->values.begin(), end = args->values.end();
-             i != end;
-             ++i) {
-            Type *type = (*i)->type.ptr();
-            llvm::Value *value;
-            if (type->typeKind == STATIC_TYPE) {
-                StaticType *staticType = (StaticType *) type;
-                assert(staticType->obj->objKind == VALUE_HOLDER);
-                ValueHolder *vh = (ValueHolder *) staticType->obj.ptr();
-                value = valueHolderToLLVMConstant(vh, ctx);
-            } else {
-                value = ctx->builder->CreateLoad((*i)->llValue);
-            }
-            assert(funTy->getParamType(unsigned(funArgs.size())) == value->getType());
-            funArgs.push_back(value);
-        }
+static void codegenIntrinsic(IntrinsicSymbol *intrin, MultiCValue *args,
+                             CodegenContext *ctx, MultiCValuePtr out) {
+    vector<TypePtr> argsKey;
+    args->toArgsKey(&argsKey);
+
+    map<vector<TypePtr>, IntrinsicInstance>::const_iterator instanceI =
+        intrin->instances.find(argsKey);
+    assert(instanceI != intrin->instances.end());
 
-        llvm::Value *retValue = ctx->builder->CreateCall(instance.function, funArgs);
-        if (retValue->getType()->isVoidTy()) {
-            assert(out->size() == 0);
+    IntrinsicInstance const &instance = instanceI->second;
+    if (instance.function == nullptr) {
+        assert(!instance.error.empty());
+        error(instance.error);
+    }
+
+    llvm::FunctionType *funTy = instance.function->getFunctionType();
+    llvm::SmallVector<llvm::Value *, 8> funArgs;
+
+    assert(args->size() == funTy->getNumParams());
+
+    for (vector<CValuePtr>::const_iterator i = args->values.begin(),
+                                           end = args->values.end();
+         i != end; ++i) {
+        Type *type = (*i)->type.ptr();
+        llvm::Value *value;
+        if (type->typeKind == STATIC_TYPE) {
+            StaticType *staticType = (StaticType *)type;
+            assert(staticType->obj->objKind == VALUE_HOLDER);
+            ValueHolder *vh = (ValueHolder *)staticType->obj.ptr();
+            value = valueHolderToLLVMConstant(vh, ctx);
         } else {
-            assert(out->size() == 1);
-            ctx->builder->CreateStore(retValue, out->values[0]->llValue);
+            value = ctx->builder->CreateLoad((*i)->llValue);
         }
+        assert(funTy->getParamType(unsigned(funArgs.size())) ==
+               value->getType());
+        funArgs.push_back(value);
     }
 
-    //
-    // codegenCallExpr
-    //
+    llvm::Value *retValue =
+        ctx->builder->CreateCall(instance.function, funArgs);
+    if (retValue->getType()->isVoidTy()) {
+        assert(out->size() == 0);
+    } else {
+        assert(out->size() == 1);
+        ctx->builder->CreateStore(retValue, out->values[0]->llValue);
+    }
+}
 
-    void codegenCallExpr(ExprPtr callable,
-                         ExprListPtr args,
-                         EnvPtr env,
-                         CodegenContext *ctx,
-                         MultiCValuePtr out) {
-        PVData pv = safeAnalyzeOne(callable, env);
+//
+// codegenCallExpr
+//
 
-        switch (pv.type->typeKind) {
-            case CODE_POINTER_TYPE: {
-                CValuePtr cv = codegenOneAsRef(callable, env, ctx);
-                MultiCValuePtr mcv = codegenMultiAsRef(args, env, ctx);
-                codegenCallPointer(cv, mcv, ctx, out);
-                return;
-            }
-            default:
-                break;
-        }
+void codegenCallExpr(ExprPtr callable, ExprListPtr args, EnvPtr env,
+                     CodegenContext *ctx, MultiCValuePtr out) {
+    PVData pv = safeAnalyzeOne(callable, env);
 
-        if ((pv.type->typeKind == CCODE_POINTER_TYPE)
-            && (callable->exprKind == NAME_REF)) {
-            NameRef *x = (NameRef *) callable.ptr();
-            ObjectPtr y = safeLookupEnv(env, x->name);
-            if (y->objKind == EXTERNAL_PROCEDURE) {
-                ExternalProcedure *z = (ExternalProcedure *) y.ptr();
-                if (!z->llvmFunc)
-                    codegenExternalProcedure(z, false);
-                ExprListPtr args2 = new ExprList(callable);
-                args2->add(args);
-                codegenCallExpr(operator_expr_call(), args2, env, ctx, out);
-                return;
-            }
-        }
+    switch (pv.type->typeKind) {
+    case CODE_POINTER_TYPE: {
+        CValuePtr cv = codegenOneAsRef(callable, env, ctx);
+        MultiCValuePtr mcv = codegenMultiAsRef(args, env, ctx);
+        codegenCallPointer(cv, mcv, ctx, out);
+        return;
+    }
+    default:
+        break;
+    }
 
-        if (pv.type->typeKind != STATIC_TYPE) {
+    if ((pv.type->typeKind == CCODE_POINTER_TYPE) &&
+        (callable->exprKind == NAME_REF)) {
+        NameRef *x = (NameRef *)callable.ptr();
+        ObjectPtr y = safeLookupEnv(env, x->name);
+        if (y->objKind == EXTERNAL_PROCEDURE) {
+            ExternalProcedure *z = (ExternalProcedure *)y.ptr();
+            if (!z->llvmFunc)
+                codegenExternalProcedure(z, false);
             ExprListPtr args2 = new ExprList(callable);
             args2->add(args);
             codegenCallExpr(operator_expr_call(), args2, env, ctx, out);
             return;
         }
+    }
 
-        StaticType *st = (StaticType *) pv.type.ptr();
-        ObjectPtr obj = st->obj;
-
-        switch (obj->objKind) {
-            case TYPE:
-            case RECORD_DECL:
-            case VARIANT_DECL:
-            case PROCEDURE:
-            case GLOBAL_ALIAS:
-            case PRIM_OP: {
-                if ((obj->objKind == PRIM_OP) && !isOverloadablePrimOp(obj)) {
-                    PrimOpPtr x = (PrimOp *) obj.ptr();
-                    MultiCValuePtr mcv = codegenMultiAsRef(args, env, ctx);
-                    codegenPrimOp(x, mcv, ctx, out);
-                    break;
-                }
-                vector<unsigned> dispatchIndices;
-                MultiPValuePtr mpv = safeAnalyzeMultiArgs(args, env, dispatchIndices);
-                if (dispatchIndices.size() > 0) {
-                    MultiCValuePtr mcv = codegenMultiArgsAsRef(args, env, ctx);
-                    codegenDispatch(obj, mcv, mpv, dispatchIndices, ctx, out);
-                    break;
-                }
-                if (codegenShortcut(obj, mpv, args, env, ctx, out))
-                    break;
-                CompileContextPusher pusher(obj, mpv->values);
-                InvokeEntry *entry = safeAnalyzeCallable(obj, mpv->values);
-                if (entry->callByName) {
-                    codegenCallByName(entry, callable, args, env, ctx, out);
-                } else {
-                    assert(entry->analyzed);
-                    MultiCValuePtr mcv = codegenMultiAsRef(args, env, ctx);
-                    codegenCallCode(entry, mcv, ctx, out);
-                }
-                break;
-            }
-
-            case INTRINSIC: {
-                IntrinsicSymbol *intrin = (IntrinsicSymbol *) obj.ptr();
-                MultiCValuePtr mcv = codegenMultiAsRef(args, env, ctx);
-                codegenIntrinsic(intrin, mcv.ptr(), ctx, out);
-                break;
-            }
+    if (pv.type->typeKind != STATIC_TYPE) {
+        ExprListPtr args2 = new ExprList(callable);
+        args2->add(args);
+        codegenCallExpr(operator_expr_call(), args2, env, ctx, out);
+        return;
+    }
 
-            default:
-                error("invalid call expression");
-                break;
+    StaticType *st = (StaticType *)pv.type.ptr();
+    ObjectPtr obj = st->obj;
+
+    switch (obj->objKind) {
+    case TYPE:
+    case RECORD_DECL:
+    case VARIANT_DECL:
+    case PROCEDURE:
+    case GLOBAL_ALIAS:
+    case PRIM_OP: {
+        if ((obj->objKind == PRIM_OP) && !isOverloadablePrimOp(obj)) {
+            PrimOpPtr x = (PrimOp *)obj.ptr();
+            MultiCValuePtr mcv = codegenMultiAsRef(args, env, ctx);
+            codegenPrimOp(x, mcv, ctx, out);
+            break;
+        }
+        vector<unsigned> dispatchIndices;
+        MultiPValuePtr mpv = safeAnalyzeMultiArgs(args, env, dispatchIndices);
+        if (dispatchIndices.size() > 0) {
+            MultiCValuePtr mcv = codegenMultiArgsAsRef(args, env, ctx);
+            codegenDispatch(obj, mcv, mpv, dispatchIndices, ctx, out);
+            break;
+        }
+        if (codegenShortcut(obj, mpv, args, env, ctx, out))
+            break;
+        CompileContextPusher pusher(obj, mpv->values);
+        InvokeEntry *entry = safeAnalyzeCallable(obj, mpv->values);
+        if (entry->callByName) {
+            codegenCallByName(entry, callable, args, env, ctx, out);
+        } else {
+            assert(entry->analyzed);
+            MultiCValuePtr mcv = codegenMultiAsRef(args, env, ctx);
+            codegenCallCode(entry, mcv, ctx, out);
         }
+        break;
     }
 
-    //
-    // codegenDispatch
-    //
+    case INTRINSIC: {
+        IntrinsicSymbol *intrin = (IntrinsicSymbol *)obj.ptr();
+        MultiCValuePtr mcv = codegenMultiAsRef(args, env, ctx);
+        codegenIntrinsic(intrin, mcv.ptr(), ctx, out);
+        break;
+    }
 
-    llvm::Value *codegenDispatchTag(CValuePtr cv, CodegenContext *ctx) {
-        CValuePtr ctag = codegenAllocValue(cIntType, ctx);
-        codegenCallValue(staticCValue(operator_dispatchTag(), ctx),
-                         new MultiCValue(cv),
-                         ctx,
-                         new MultiCValue(ctag));
-        return ctx->builder->CreateLoad(ctag->llValue);
+    default:
+        error("invalid call expression");
+        break;
     }
+}
 
-    CValuePtr codegenDispatchIndex(CValuePtr cv, PVData const &pvOut, unsigned tag, CodegenContext *ctx) {
-        MultiCValuePtr args = new MultiCValue();
-        args->add(cv);
-        ValueHolderPtr vh = intToValueHolder((int) tag);
-        args->add(staticCValue(vh.ptr(), ctx));
+//
+// codegenDispatch
+//
 
-        CValuePtr cvOut = codegenAllocValueForPValue(pvOut, ctx);
-        MultiCValuePtr out = new MultiCValue(cvOut);
+llvm::Value *codegenDispatchTag(CValuePtr cv, CodegenContext *ctx) {
+    CValuePtr ctag = codegenAllocValue(cIntType, ctx);
+    codegenCallValue(staticCValue(operator_dispatchTag(), ctx),
+                     new MultiCValue(cv), ctx, new MultiCValue(ctag));
+    return ctx->builder->CreateLoad(ctag->llValue);
+}
 
-        codegenCallValue(staticCValue(operator_dispatchIndex(), ctx),
-                         args,
-                         ctx,
-                         out);
-        return derefValueForPValue(cvOut, pvOut, ctx);
-    }
+CValuePtr codegenDispatchIndex(CValuePtr cv, PVData const &pvOut, unsigned tag,
+                               CodegenContext *ctx) {
+    MultiCValuePtr args = new MultiCValue();
+    args->add(cv);
+    ValueHolderPtr vh = intToValueHolder((int)tag);
+    args->add(staticCValue(vh.ptr(), ctx));
 
-    void codegenDispatch(ObjectPtr obj,
-                         MultiCValuePtr args,
-                         MultiPValuePtr pvArgs,
-                         llvm::ArrayRef<unsigned> dispatchIndices,
-                         CodegenContext *ctx,
-                         MultiCValuePtr out) {
-        assert(args->size() == pvArgs->size());
+    CValuePtr cvOut = codegenAllocValueForPValue(pvOut, ctx);
+    MultiCValuePtr out = new MultiCValue(cvOut);
 
-        if (dispatchIndices.empty()) {
-            codegenCallValue(staticCValue(obj, ctx), args, pvArgs, ctx, out);
-            return;
-        }
+    codegenCallValue(staticCValue(operator_dispatchIndex(), ctx), args, ctx,
+                     out);
+    return derefValueForPValue(cvOut, pvOut, ctx);
+}
 
-        CompileContextPusher pusher(obj, pvArgs->values);
+void codegenDispatch(ObjectPtr obj, MultiCValuePtr args, MultiPValuePtr pvArgs,
+                     llvm::ArrayRef<unsigned> dispatchIndices,
+                     CodegenContext *ctx, MultiCValuePtr out) {
+    assert(args->size() == pvArgs->size());
 
-        unsigned index = dispatchIndices[0];
-        vector<unsigned> dispatchIndices2(dispatchIndices.begin() + 1,
-                                          dispatchIndices.end());
+    if (dispatchIndices.empty()) {
+        codegenCallValue(staticCValue(obj, ctx), args, pvArgs, ctx, out);
+        return;
+    }
 
-        MultiCValuePtr prefix = new MultiCValue();
-        MultiPValuePtr pvPrefix = new MultiPValue();
-        for (unsigned i = 0; i < index; ++i) {
-            prefix->add(args->values[i]);
-            pvPrefix->add(pvArgs->values[i]);
-        }
-        MultiCValuePtr suffix = new MultiCValue();
-        MultiPValuePtr pvSuffix = new MultiPValue();
-        for (unsigned i = index + 1; i < args->size(); ++i) {
-            suffix->add(args->values[i]);
-            pvSuffix->add(pvArgs->values[i]);
-        }
-        CValuePtr cvDispatch = args->values[index];
-        PVData const &pvDispatch = pvArgs->values[index];
+    CompileContextPusher pusher(obj, pvArgs->values);
 
-        unsigned memberCount = dispatchTagCount(pvDispatch.type);
-        llvm::Value *llTag = codegenDispatchTag(cvDispatch, ctx);
+    unsigned index = dispatchIndices[0];
+    vector<unsigned> dispatchIndices2(dispatchIndices.begin() + 1,
+                                      dispatchIndices.end());
 
-        vector<llvm::BasicBlock *> callBlocks;
-        vector<llvm::BasicBlock *> elseBlocks;
+    MultiCValuePtr prefix = new MultiCValue();
+    MultiPValuePtr pvPrefix = new MultiPValue();
+    for (unsigned i = 0; i < index; ++i) {
+        prefix->add(args->values[i]);
+        pvPrefix->add(pvArgs->values[i]);
+    }
+    MultiCValuePtr suffix = new MultiCValue();
+    MultiPValuePtr pvSuffix = new MultiPValue();
+    for (unsigned i = index + 1; i < args->size(); ++i) {
+        suffix->add(args->values[i]);
+        pvSuffix->add(pvArgs->values[i]);
+    }
+    CValuePtr cvDispatch = args->values[index];
+    PVData const &pvDispatch = pvArgs->values[index];
 
-        for (unsigned i = 0; i < memberCount; ++i) {
-            callBlocks.push_back(newBasicBlock("dispatchCase", ctx));
-            elseBlocks.push_back(newBasicBlock("dispatchNext", ctx));
-        }
-        llvm::BasicBlock *finalBlock = newBasicBlock("finalBlock", ctx);
+    unsigned memberCount = dispatchTagCount(pvDispatch.type);
+    llvm::Value *llTag = codegenDispatchTag(cvDispatch, ctx);
 
-        for (unsigned i = 0; i < memberCount; ++i) {
-            llvm::Value *tagCase = llvm::ConstantInt::get(llvmIntType(32), i);
-            llvm::Value *cond = ctx->builder->CreateICmpEQ(llTag, tagCase);
-            ctx->builder->CreateCondBr(cond, callBlocks[i], elseBlocks[i]);
+    vector<llvm::BasicBlock *> callBlocks;
+    vector<llvm::BasicBlock *> elseBlocks;
 
-            ctx->builder->SetInsertPoint(callBlocks[i]);
+    for (unsigned i = 0; i < memberCount; ++i) {
+        callBlocks.push_back(newBasicBlock("dispatchCase", ctx));
+        elseBlocks.push_back(newBasicBlock("dispatchNext", ctx));
+    }
+    llvm::BasicBlock *finalBlock = newBasicBlock("finalBlock", ctx);
 
-            MultiPValuePtr pvArgs2 = new MultiPValue();
-            pvArgs2->add(pvPrefix);
-            PVData pvDispatch2 = analyzeDispatchIndex(pvDispatch, i);
-            pvArgs2->add(pvDispatch2);
-            pvArgs2->add(pvSuffix);
-            MultiCValuePtr args2 = new MultiCValue();
-            args2->add(prefix);
-            args2->add(codegenDispatchIndex(cvDispatch, pvDispatch2, i, ctx));
-            args2->add(suffix);
+    for (unsigned i = 0; i < memberCount; ++i) {
+        llvm::Value *tagCase = llvm::ConstantInt::get(llvmIntType(32), i);
+        llvm::Value *cond = ctx->builder->CreateICmpEQ(llTag, tagCase);
+        ctx->builder->CreateCondBr(cond, callBlocks[i], elseBlocks[i]);
 
-            codegenDispatch(obj, args2, pvArgs2, dispatchIndices2, ctx, out);
+        ctx->builder->SetInsertPoint(callBlocks[i]);
 
-            ctx->builder->CreateBr(finalBlock);
+        MultiPValuePtr pvArgs2 = new MultiPValue();
+        pvArgs2->add(pvPrefix);
+        PVData pvDispatch2 = analyzeDispatchIndex(pvDispatch, i);
+        pvArgs2->add(pvDispatch2);
+        pvArgs2->add(pvSuffix);
+        MultiCValuePtr args2 = new MultiCValue();
+        args2->add(prefix);
+        args2->add(codegenDispatchIndex(cvDispatch, pvDispatch2, i, ctx));
+        args2->add(suffix);
 
-            ctx->builder->SetInsertPoint(elseBlocks[i]);
-        }
+        codegenDispatch(obj, args2, pvArgs2, dispatchIndices2, ctx, out);
 
-        codegenCallValue(staticCValue(operator_invalidDispatch(), ctx),
-                         new MultiCValue(cvDispatch),
-                         ctx,
-                         new MultiCValue());
         ctx->builder->CreateBr(finalBlock);
 
-        ctx->builder->SetInsertPoint(finalBlock);
+        ctx->builder->SetInsertPoint(elseBlocks[i]);
     }
 
-    //
-    // codegenCallValue
-    //
+    codegenCallValue(staticCValue(operator_invalidDispatch(), ctx),
+                     new MultiCValue(cvDispatch), ctx, new MultiCValue());
+    ctx->builder->CreateBr(finalBlock);
+
+    ctx->builder->SetInsertPoint(finalBlock);
+}
+
+//
+// codegenCallValue
+//
 
-    void codegenCallValue(CValuePtr callable,
-                          MultiCValuePtr args,
-                          CodegenContext *ctx,
-                          MultiCValuePtr out) {
-        MultiPValuePtr pvArgs = new MultiPValue();
-        for (unsigned i = 0; i < args->size(); ++i)
-            pvArgs->add(PVData(args->values[i]->type, false));
-        codegenCallValue(callable, args, pvArgs, ctx, out);
+void codegenCallValue(CValuePtr callable, MultiCValuePtr args,
+                      CodegenContext *ctx, MultiCValuePtr out) {
+    MultiPValuePtr pvArgs = new MultiPValue();
+    for (unsigned i = 0; i < args->size(); ++i)
+        pvArgs->add(PVData(args->values[i]->type, false));
+    codegenCallValue(callable, args, pvArgs, ctx, out);
+}
+
+void codegenCallValue(CValuePtr callable, MultiCValuePtr args,
+                      MultiPValuePtr pvArgs, CodegenContext *ctx,
+                      MultiCValuePtr out) {
+    assert(args->size() == pvArgs->size());
+
+    switch (callable->type->typeKind) {
+    case CODE_POINTER_TYPE:
+        codegenCallPointer(callable, args, ctx, out);
+        return;
+    default:
+        break;
     }
 
-    void codegenCallValue(CValuePtr callable,
-                          MultiCValuePtr args,
-                          MultiPValuePtr pvArgs,
-                          CodegenContext *ctx,
-                          MultiCValuePtr out) {
-        assert(args->size() == pvArgs->size());
+    if (callable->type->typeKind != STATIC_TYPE) {
+        MultiCValuePtr args2 = new MultiCValue(callable);
+        args2->add(args);
+        MultiPValuePtr pvArgs2 = new MultiPValue(PVData(callable->type, false));
+        pvArgs2->add(pvArgs);
+        codegenCallValue(staticCValue(operator_call(), ctx), args2, pvArgs2,
+                         ctx, out);
+        return;
+    }
 
-        switch (callable->type->typeKind) {
-            case CODE_POINTER_TYPE:
-                codegenCallPointer(callable, args, ctx, out);
-                return;
-            default:
-                break;
+    StaticType *st = (StaticType *)callable->type.ptr();
+    ObjectPtr obj = st->obj;
+
+    switch (obj->objKind) {
+    case TYPE:
+    case RECORD_DECL:
+    case VARIANT_DECL:
+    case PROCEDURE:
+    case GLOBAL_ALIAS:
+    case PRIM_OP: {
+        if ((obj->objKind == PRIM_OP) && !isOverloadablePrimOp(obj)) {
+            PrimOpPtr x = (PrimOp *)obj.ptr();
+            codegenPrimOp(x, args, ctx, out);
+            break;
         }
-
-        if (callable->type->typeKind != STATIC_TYPE) {
-            MultiCValuePtr args2 = new MultiCValue(callable);
-            args2->add(args);
-            MultiPValuePtr pvArgs2 =
-                    new MultiPValue(PVData(callable->type, false));
-            pvArgs2->add(pvArgs);
-            codegenCallValue(staticCValue(operator_call(), ctx),
-                             args2,
-                             pvArgs2,
-                             ctx,
-                             out);
-            return;
+        CompileContextPusher pusher(obj, pvArgs->values);
+        InvokeEntry *entry = safeAnalyzeCallable(obj, pvArgs->values);
+        if (entry->callByName) {
+            ExprListPtr objectExprs = new ExprList();
+            for (vector<CValuePtr>::const_iterator i = args->values.begin(),
+                                                   end = args->values.end();
+                 i != end; ++i) {
+                objectExprs->add(new ObjectExpr(i->ptr()));
+            }
+            ExprPtr callableObject = new ObjectExpr(callable.ptr());
+            callableObject->location = topLocation();
+            codegenCallByName(entry, callableObject, objectExprs, new Env(),
+                              ctx, out);
+        } else {
+            assert(entry->analyzed);
+            codegenCallCode(entry, args, ctx, out);
         }
+        break;
+    }
 
-        StaticType *st = (StaticType *) callable->type.ptr();
-        ObjectPtr obj = st->obj;
+    case INTRINSIC: {
+        IntrinsicSymbol *intrin = (IntrinsicSymbol *)obj.ptr();
+        codegenIntrinsic(intrin, args.ptr(), ctx, out);
+        break;
+    }
 
-        switch (obj->objKind) {
-            case TYPE:
-            case RECORD_DECL:
-            case VARIANT_DECL:
-            case PROCEDURE:
-            case GLOBAL_ALIAS:
-            case PRIM_OP: {
-                if ((obj->objKind == PRIM_OP) && !isOverloadablePrimOp(obj)) {
-                    PrimOpPtr x = (PrimOp *) obj.ptr();
-                    codegenPrimOp(x, args, ctx, out);
-                    break;
-                }
-                CompileContextPusher pusher(obj, pvArgs->values);
-                InvokeEntry *entry = safeAnalyzeCallable(obj, pvArgs->values);
-                if (entry->callByName) {
-                    ExprListPtr objectExprs = new ExprList();
-                    for (vector<CValuePtr>::const_iterator i = args->values.begin(), end = args->values.end();
-                         i != end;
-                         ++i) {
-                        objectExprs->add(new ObjectExpr(i->ptr()));
-                    }
-                    ExprPtr callableObject = new ObjectExpr(callable.ptr());
-                    callableObject->location = topLocation();
-                    codegenCallByName(entry, callableObject, objectExprs, new Env(), ctx, out);
-                } else {
-                    assert(entry->analyzed);
-                    codegenCallCode(entry, args, ctx, out);
-                }
-                break;
-            }
+    default:
+        error("invalid call operation");
+        break;
+    }
+}
 
-            case INTRINSIC: {
-                IntrinsicSymbol *intrin = (IntrinsicSymbol *) obj.ptr();
-                codegenIntrinsic(intrin, args.ptr(), ctx, out);
-                break;
-            }
+//
+// codegenShortcut
+//
 
-            default:
-                error("invalid call operation");
-                break;
+bool codegenShortcut(ObjectPtr callable, MultiPValuePtr pvArgs,
+                     ExprListPtr args, EnvPtr env, CodegenContext *ctx,
+                     MultiCValuePtr out) {
+    switch (callable->objKind) {
+    case TYPE: {
+        TypePtr t = (Type *)callable.ptr();
+        if (!isPrimitiveAggregateType(t))
+            return false;
+        if (pvArgs->size() != 1)
+            return false;
+        PVData const &pv = pvArgs->values[0];
+        if ((pv.type == t) && (!isPrimitiveAggregateTooLarge(t))) {
+            MultiCValuePtr cvArgs = codegenMultiAsRef(args, env, ctx);
+            assert(cvArgs->size() == 1);
+            CValuePtr cv = cvArgs->values[0];
+            assert(cv->type == t);
+            assert(out->size() == 1);
+            CValuePtr out0 = out->values[0];
+            assert(out0->type == t);
+            llvm::Value *v = ctx->builder->CreateLoad(cv->llValue);
+            ctx->builder->CreateStore(v, out0->llValue);
+            return true;
         }
+        return false;
     }
-
-    //
-    // codegenShortcut
-    //
-
-    bool codegenShortcut(ObjectPtr callable,
-                         MultiPValuePtr pvArgs,
-                         ExprListPtr args,
-                         EnvPtr env,
-                         CodegenContext *ctx,
-                         MultiCValuePtr out) {
-        switch (callable->objKind) {
-            case TYPE: {
-                TypePtr t = (Type *) callable.ptr();
-                if (!isPrimitiveAggregateType(t))
-                    return false;
-                if (pvArgs->size() != 1)
-                    return false;
-                PVData const &pv = pvArgs->values[0];
-                if ((pv.type == t) && (!isPrimitiveAggregateTooLarge(t))) {
-                    MultiCValuePtr cvArgs = codegenMultiAsRef(args, env, ctx);
-                    assert(cvArgs->size() == 1);
-                    CValuePtr cv = cvArgs->values[0];
-                    assert(cv->type == t);
-                    assert(out->size() == 1);
-                    CValuePtr out0 = out->values[0];
-                    assert(out0->type == t);
-                    llvm::Value *v = ctx->builder->CreateLoad(cv->llValue);
-                    ctx->builder->CreateStore(v, out0->llValue);
-                    return true;
-                }
+    case PROCEDURE: {
+        if (callable == operator_destroy()) {
+            if (pvArgs->size() != 1)
                 return false;
-            }
-            case PROCEDURE: {
-                if (callable == operator_destroy()) {
-                    if (pvArgs->size() != 1)
-                        return false;
-                    if (!isPrimitiveAggregateType(pvArgs->values[0].type))
-                        return false;
-                    return true;
-                }
-                return false;
-            }
-            default:
+            if (!isPrimitiveAggregateType(pvArgs->values[0].type))
                 return false;
+            return true;
         }
+        return false;
+    }
+    default:
+        return false;
     }
+}
 
-    //
-    // codegenCallPointer
-    //
-
-    void codegenCallPointer(CValuePtr x,
-                            MultiCValuePtr args,
-                            CodegenContext *ctx,
-                            MultiCValuePtr out) {
-        assert(x->type->typeKind == CODE_POINTER_TYPE);
-        CodePointerType *t = (CodePointerType *) x->type.ptr();
-        ensureArity(args, t->argTypes.size());
-        llvm::Value *llCallable = ctx->builder->CreateLoad(x->llValue);
-        vector<llvm::Value *> llArgs;
-        for (unsigned i = 0; i < args->size(); ++i) {
-            CValuePtr cv = args->values[i];
-            if (cv->type != t->argTypes[i])
-                argumentTypeError(i, t->argTypes[i], cv->type);
-            llArgs.push_back(cv->llValue);
-        }
-        assert(out->size() == t->returnTypes.size());
-        for (unsigned i = 0; i < out->size(); ++i) {
-            CValuePtr cv = out->values[i];
-            if (t->returnIsRef[i])
-                assert(cv->type == pointerType(t->returnTypes[i]));
-            else
-                assert(cv->type == t->returnTypes[i]);
-            llArgs.push_back(cv->llValue);
-        }
-        codegenLowlevelCall(llCallable, llArgs, ctx);
+//
+// codegenCallPointer
+//
+
+void codegenCallPointer(CValuePtr x, MultiCValuePtr args, CodegenContext *ctx,
+                        MultiCValuePtr out) {
+    assert(x->type->typeKind == CODE_POINTER_TYPE);
+    CodePointerType *t = (CodePointerType *)x->type.ptr();
+    ensureArity(args, t->argTypes.size());
+    llvm::Value *llCallable = ctx->builder->CreateLoad(x->llValue);
+    vector<llvm::Value *> llArgs;
+    for (unsigned i = 0; i < args->size(); ++i) {
+        CValuePtr cv = args->values[i];
+        if (cv->type != t->argTypes[i])
+            argumentTypeError(i, t->argTypes[i], cv->type);
+        llArgs.push_back(cv->llValue);
     }
+    assert(out->size() == t->returnTypes.size());
+    for (unsigned i = 0; i < out->size(); ++i) {
+        CValuePtr cv = out->values[i];
+        if (t->returnIsRef[i])
+            assert(cv->type == pointerType(t->returnTypes[i]));
+        else
+            assert(cv->type == t->returnTypes[i]);
+        llArgs.push_back(cv->llValue);
+    }
+    codegenLowlevelCall(llCallable, llArgs, ctx);
+}
 
-    //
-    // codegenCallCode
-    //
+//
+// codegenCallCode
+//
 
-    void codegenCallCode(InvokeEntry *entry,
-                         MultiCValuePtr args,
-                         CodegenContext *ctx,
-                         MultiCValuePtr out) {
-        if (inlineEnabled() && entry->isInline == FORCE_INLINE && !entry->code->isLLVMBody()) {
-            codegenCallInline(entry, args, ctx, out);
-            return;
-        }
-        if (!entry->llvmFunc)
-            codegenCodeBody(entry);
-        assert(entry->llvmFunc);
-        ensureArity(args, entry->argsKey.size());
-        vector<llvm::Value *> llArgs;
-        for (unsigned i = 0; i < args->size(); ++i) {
-            CValuePtr cv = args->values[i];
-            if (cv->type != entry->argsKey[i]) {
-                argumentTypeError(i, entry->argsKey[i], cv->type);
-            }
-            llArgs.push_back(cv->llValue);
-        }
-        assert(out->size() == entry->returnTypes.size());
-        for (unsigned i = 0; i < out->size(); ++i) {
-            CValuePtr cv = out->values[i];
-            if (entry->returnIsRef[i])
-                assert(cv->type == pointerType(entry->returnTypes[i]));
-            else
-                assert(cv->type == entry->returnTypes[i]);
-            llArgs.push_back(cv->llValue);
+void codegenCallCode(InvokeEntry *entry, MultiCValuePtr args,
+                     CodegenContext *ctx, MultiCValuePtr out) {
+    if (inlineEnabled() && entry->isInline == FORCE_INLINE &&
+        !entry->code->isLLVMBody()) {
+        codegenCallInline(entry, args, ctx, out);
+        return;
+    }
+    if (!entry->llvmFunc)
+        codegenCodeBody(entry);
+    assert(entry->llvmFunc);
+    ensureArity(args, entry->argsKey.size());
+    vector<llvm::Value *> llArgs;
+    for (unsigned i = 0; i < args->size(); ++i) {
+        CValuePtr cv = args->values[i];
+        if (cv->type != entry->argsKey[i]) {
+            argumentTypeError(i, entry->argsKey[i], cv->type);
         }
-        if (!entry->runtimeNop)
-            codegenLowlevelCall(entry->llvmFunc, llArgs, ctx);
+        llArgs.push_back(cv->llValue);
+    }
+    assert(out->size() == entry->returnTypes.size());
+    for (unsigned i = 0; i < out->size(); ++i) {
+        CValuePtr cv = out->values[i];
+        if (entry->returnIsRef[i])
+            assert(cv->type == pointerType(entry->returnTypes[i]));
+        else
+            assert(cv->type == entry->returnTypes[i]);
+        llArgs.push_back(cv->llValue);
     }
+    if (!entry->runtimeNop)
+        codegenLowlevelCall(entry->llvmFunc, llArgs, ctx);
+}
 
-    //
-    // codegenLowlevelCall - generate exception checked call
-    //
+//
+// codegenLowlevelCall - generate exception checked call
+//
+
+void codegenLowlevelCall(llvm::Value *llCallable,
+                         llvm::ArrayRef<llvm::Value *> args,
+                         CodegenContext *ctx) {
+    llvm::Value *result = ctx->builder->CreateCall(llCallable, args);
+    if (!exceptionsEnabled())
+        return;
+    if (!ctx->checkExceptions)
+        return;
+    llvm::Value *noException = noExceptionReturnValue();
+    llvm::Value *intNoException =
+        llvm::ConstantInt::get(llvmType(cSizeTType), 0);
+    llvm::Value *intResult =
+        ctx->builder->CreatePtrToInt(result, llvmType(cSizeTType));
+    llvm::Function *expect = llvm::Intrinsic::getDeclaration(
+        llvmModule, llvm::Intrinsic::expect, llvmType(cSizeTType));
+    llvm::Value *expectArgs[2] = {intResult, intNoException};
+    llvm::Value *expectResult = ctx->builder->CreateCall(expect, expectArgs);
+    llvm::Value *ptrResult =
+        ctx->builder->CreateIntToPtr(expectResult, exceptionReturnType());
+
+    llvm::Value *cond = ctx->builder->CreateICmpEQ(ptrResult, noException);
+    llvm::BasicBlock *landing = newBasicBlock("landing", ctx);
+    llvm::BasicBlock *normal = newBasicBlock("normal", ctx);
+    ctx->builder->CreateCondBr(cond, normal, landing);
+
+    ctx->builder->SetInsertPoint(landing);
+    assert(ctx->exceptionValue != nullptr);
+    ctx->builder->CreateStore(ptrResult, ctx->exceptionValue);
+    JumpTarget *jt = &ctx->exceptionTargets.back();
+    cgDestroyStack(jt->stackMarker, ctx, true);
+    // jt might be invalidated at this point
+    jt = &ctx->exceptionTargets.back();
+    ctx->builder->CreateBr(jt->block);
+    ++jt->useCount;
+
+    ctx->builder->SetInsertPoint(normal);
+}
 
-    void codegenLowlevelCall(llvm::Value *llCallable,
-                             llvm::ArrayRef<llvm::Value *> args,
-                             CodegenContext *ctx) {
-        llvm::Value *result = ctx->builder->CreateCall(llCallable, args);
-        if (!exceptionsEnabled())
-            return;
-        if (!ctx->checkExceptions)
-            return;
-        llvm::Value *noException = noExceptionReturnValue();
-        llvm::Value *intNoException = llvm::ConstantInt::get(llvmType(cSizeTType), 0);
-        llvm::Value *intResult = ctx->builder->CreatePtrToInt(
-            result, llvmType(cSizeTType));
-        llvm::Function *expect = llvm::Intrinsic::getDeclaration(
-            llvmModule,
-            llvm::Intrinsic::expect,
-            llvmType(cSizeTType));
-        llvm::Value *expectArgs[2] = {intResult, intNoException};
-        llvm::Value *expectResult = ctx->builder->CreateCall(expect, expectArgs);
-        llvm::Value *ptrResult = ctx->builder->CreateIntToPtr(expectResult, exceptionReturnType());
-
-        llvm::Value *cond = ctx->builder->CreateICmpEQ(ptrResult, noException);
-        llvm::BasicBlock *landing = newBasicBlock("landing", ctx);
-        llvm::BasicBlock *normal = newBasicBlock("normal", ctx);
-        ctx->builder->CreateCondBr(cond, normal, landing);
-
-        ctx->builder->SetInsertPoint(landing);
-        assert(ctx->exceptionValue != nullptr);
-        ctx->builder->CreateStore(ptrResult, ctx->exceptionValue);
-        JumpTarget *jt = &ctx->exceptionTargets.back();
-        cgDestroyStack(jt->stackMarker, ctx, true);
-        // jt might be invalidated at this point
-        jt = &ctx->exceptionTargets.back();
-        ctx->builder->CreateBr(jt->block);
-        ++jt->useCount;
+//
+// codegenCallable
+//
 
-        ctx->builder->SetInsertPoint(normal);
+InvokeEntry *codegenCallable(ObjectPtr x, llvm::ArrayRef<PVData> args) {
+    InvokeEntry *entry = safeAnalyzeCallable(x, args);
+    if (!entry->callByName) {
+        if (!entry->llvmFunc)
+            codegenCodeBody(entry);
     }
+    return entry;
+}
 
-    //
-    // codegenCallable
-    //
-
-    InvokeEntry *codegenCallable(ObjectPtr x,
-                                 llvm::ArrayRef<PVData> args) {
-        InvokeEntry *entry =
-                safeAnalyzeCallable(x, args);
-        if (!entry->callByName) {
-            if (!entry->llvmFunc)
-                codegenCodeBody(entry);
-        }
-        return entry;
-    }
+//
+// interpolateLLVMCode
+//
 
-    //
-    // interpolateLLVMCode
-    //
+static bool isFirstIdentChar(char c) {
+    if (c == '_')
+        return true;
+    if ((c >= 'a') && (c <= 'z'))
+        return true;
+    if ((c >= 'A') && (c <= 'Z'))
+        return true;
+    return false;
+}
 
-    static bool isFirstIdentChar(char c) {
-        if (c == '_') return true;
-        if ((c >= 'a') && (c <= 'z')) return true;
-        if ((c >= 'A') && (c <= 'Z')) return true;
-        return false;
-    }
+static bool isIdentChar(char c) {
+    if (isFirstIdentChar(c))
+        return true;
+    if ((c >= '0') && (c <= '9'))
+        return true;
+    if (c == '?')
+        return true;
+    return false;
+}
 
-    static bool isIdentChar(char c) {
-        if (isFirstIdentChar(c)) return true;
-        if ((c >= '0') && (c <= '9')) return true;
-        if (c == '?') return true;
-        return false;
-    }
+static const char *parseIdentifier(const char *first, const char *last) {
+    const char *i = first;
+    if ((i == last) || !isFirstIdentChar(*i))
+        return first;
+    ++i;
+    while ((i != last) && isIdentChar(*i))
+        ++i;
+    return i;
+}
 
-    static const char *parseIdentifier(const char *first, const char *last) {
-        const char *i = first;
-        if ((i == last) || !isFirstIdentChar(*i))
-            return first;
+static const char *parseBracketedExpr(const char *first, const char *last) {
+    const char *i = first;
+    if ((i == last) || (*i != '{'))
+        return first;
+    ++i;
+    int count = 1;
+    while (i != last) {
+        if (*i == '{')
+            ++count;
+        else if (*i == '}')
+            --count;
         ++i;
-        while ((i != last) && isIdentChar(*i))
-            ++i;
-        return i;
+        if (count == 0)
+            break;
     }
+    if (count != 0)
+        return first;
+    return i;
+}
 
-    static const char *parseBracketedExpr(const char *first,
-                                          const char *last) {
-        const char *i = first;
-        if ((i == last) || (*i != '{'))
-            return first;
-        ++i;
-        int count = 1;
-        while (i != last) {
-            if (*i == '{')
-                ++count;
-            else if (*i == '}')
-                --count;
-            ++i;
-            if (count == 0)
-                break;
-        }
-        if (count != 0)
-            return first;
-        return i;
-    }
-
-    static void interpolateExpr(SourcePtr source, unsigned offset, unsigned length,
-                                EnvPtr env, llvm::raw_ostream &outstream) {
-        ExprPtr expr = parseExpr(source, offset, length);
-        ObjectPtr x = evaluateOneStatic(expr, env);
-        LocationContext loc(expr->location);
-        if (x->objKind == TYPE) {
-            Type *type = (Type *) x.ptr();
-            llvmType(type)->print(outstream);
-        } else if (x->objKind == VALUE_HOLDER) {
-            ValueHolder *vh = (ValueHolder *) x.ptr();
-            if (vh->type->typeKind == BOOL_TYPE) {
-                bool result = (*(char *) vh->buf) != 0;
-                outstream << (result ? 1 : 0);
-            } else if ((vh->type->typeKind == INTEGER_TYPE)
-                       || (vh->type->typeKind == FLOAT_TYPE)) {
-                printValue(outstream, new EValue(vh->type, vh->buf));
-            } else {
-                error("only booleans, integers, and float values are supported");
-            }
-        } else if (x->objKind == IDENTIFIER) {
-            Identifier *y = (Identifier *) x.ptr();
-            outstream << y->str;
+static void interpolateExpr(SourcePtr source, unsigned offset, unsigned length,
+                            EnvPtr env, llvm::raw_ostream &outstream) {
+    ExprPtr expr = parseExpr(source, offset, length);
+    ObjectPtr x = evaluateOneStatic(expr, env);
+    LocationContext loc(expr->location);
+    if (x->objKind == TYPE) {
+        Type *type = (Type *)x.ptr();
+        llvmType(type)->print(outstream);
+    } else if (x->objKind == VALUE_HOLDER) {
+        ValueHolder *vh = (ValueHolder *)x.ptr();
+        if (vh->type->typeKind == BOOL_TYPE) {
+            bool result = (*(char *)vh->buf) != 0;
+            outstream << (result ? 1 : 0);
+        } else if ((vh->type->typeKind == INTEGER_TYPE) ||
+                   (vh->type->typeKind == FLOAT_TYPE)) {
+            printValue(outstream, new EValue(vh->type, vh->buf));
         } else {
-            printName(outstream, x);
+            error("only booleans, integers, and float values are supported");
         }
+    } else if (x->objKind == IDENTIFIER) {
+        Identifier *y = (Identifier *)x.ptr();
+        outstream << y->str;
+    } else {
+        printName(outstream, x);
     }
+}
 
-    static bool interpolateLLVMCode(LLVMCodePtr llvmBody, string &out, EnvPtr env) {
-        SourcePtr source = llvmBody->location.source;
-        unsigned startingOffset = llvmBody->location.offset;
-
-        llvm::StringRef body = llvmBody->body;
-        llvm::raw_string_ostream outstream(out);
-        const char *i = body.begin();
-        while (i != body.end()) {
-            if (*i != '$') {
-                outstream << *i;
-                ++i;
-                continue;
-            }
-
-            const char *first, *last;
-            first = i + 1;
-
-            last = parseIdentifier(first, body.end());
-            if (last != first) {
-                unsigned offset = unsigned(first - body.begin()) + startingOffset;
-                unsigned length = unsigned(last - first);
-                interpolateExpr(source, offset, length, env, outstream);
-                i = last;
-                continue;
-            }
-
-            last = parseBracketedExpr(first, body.end());
-            if (last != first) {
-                first += 1;
-                last -= 1;
-                unsigned offset = unsigned(first - body.begin()) + startingOffset;
-                unsigned length = unsigned(last - first);
-                interpolateExpr(source, offset, length, env, outstream);
-                i = last + 1;
-                continue;
-            }
+static bool interpolateLLVMCode(LLVMCodePtr llvmBody, string &out, EnvPtr env) {
+    SourcePtr source = llvmBody->location.source;
+    unsigned startingOffset = llvmBody->location.offset;
 
+    llvm::StringRef body = llvmBody->body;
+    llvm::raw_string_ostream outstream(out);
+    const char *i = body.begin();
+    while (i != body.end()) {
+        if (*i != '$') {
             outstream << *i;
             ++i;
+            continue;
         }
-        outstream.flush();
-        return true;
-    }
 
-    //
-    // codegenLLVMBody
-    //
+        const char *first, *last;
+        first = i + 1;
 
-    void codegenLLVMBody(InvokeEntry *entry, llvm::StringRef callableName) {
-        string llFunc;
-        llvm::raw_string_ostream out(llFunc);
-        int argCount = 0;
-        static int id = 1;
-        llvm::SmallString<128> functionNameBuf;
-        llvm::raw_svector_ostream functionName(functionNameBuf);
-
-        functionName << callableName << id;
-        id++;
-
-        out << string("define internal i8* @\"")
-                << functionName.str() << string("\"(");
-
-        vector<llvm::Type *> llArgTypes;
-        for (size_t i = 0; i < entry->argsKey.size(); ++i) {
-            llvm::Type *argType = llvmPointerType(entry->argsKey[i]);
-            if (argCount > 0) out << string(", ");
-            argType->print(out);
-            out << string(" %\"") << entry->fixedArgNames[i]->str << string("\"");
-            argCount++;
+        last = parseIdentifier(first, body.end());
+        if (last != first) {
+            unsigned offset = unsigned(first - body.begin()) + startingOffset;
+            unsigned length = unsigned(last - first);
+            interpolateExpr(source, offset, length, env, outstream);
+            i = last;
+            continue;
         }
-        for (size_t i = 0; i < entry->returnTypes.size(); ++i) {
-            llvm::Type *argType;
-            TypePtr rt = entry->returnTypes[i];
-            if (entry->returnIsRef[i])
-                argType = llvmPointerType(pointerType(rt));
-            else
-                argType = llvmPointerType(rt);
-            if (argCount > 0) out << string(", ");
-            argType->print(out);
-            assert(i < entry->code->returnSpecs.size());
-            const ReturnSpecPtr spec = entry->code->returnSpecs[i];
-            assert(spec->name.ptr());
-            out << string(" %") << spec->name->str;
-            argCount++;
+
+        last = parseBracketedExpr(first, body.end());
+        if (last != first) {
+            first += 1;
+            last -= 1;
+            unsigned offset = unsigned(first - body.begin()) + startingOffset;
+            unsigned length = unsigned(last - first);
+            interpolateExpr(source, offset, length, env, outstream);
+            i = last + 1;
+            continue;
         }
 
-        out << ") ";
-        if (entry->isInline == FORCE_INLINE)
-            out << "alwaysinline ";
+        outstream << *i;
+        ++i;
+    }
+    outstream.flush();
+    return true;
+}
+
+//
+// codegenLLVMBody
+//
+
+void codegenLLVMBody(InvokeEntry *entry, llvm::StringRef callableName) {
+    string llFunc;
+    llvm::raw_string_ostream out(llFunc);
+    int argCount = 0;
+    static int id = 1;
+    llvm::SmallString<128> functionNameBuf;
+    llvm::raw_svector_ostream functionName(functionNameBuf);
+
+    functionName << callableName << id;
+    id++;
+
+    out << string("define internal i8* @\"") << functionName.str()
+        << string("\"(");
+
+    vector<llvm::Type *> llArgTypes;
+    for (size_t i = 0; i < entry->argsKey.size(); ++i) {
+        llvm::Type *argType = llvmPointerType(entry->argsKey[i]);
+        if (argCount > 0)
+            out << string(", ");
+        argType->print(out);
+        out << string(" %\"") << entry->fixedArgNames[i]->str << string("\"");
+        argCount++;
+    }
+    for (size_t i = 0; i < entry->returnTypes.size(); ++i) {
+        llvm::Type *argType;
+        TypePtr rt = entry->returnTypes[i];
+        if (entry->returnIsRef[i])
+            argType = llvmPointerType(pointerType(rt));
+        else
+            argType = llvmPointerType(rt);
+        if (argCount > 0)
+            out << string(", ");
+        argType->print(out);
+        assert(i < entry->code->returnSpecs.size());
+        const ReturnSpecPtr spec = entry->code->returnSpecs[i];
+        assert(spec->name.ptr());
+        out << string(" %") << spec->name->str;
+        argCount++;
+    }
 
-        string body;
-        if (!interpolateLLVMCode(entry->code->llvmBody, body, entry->env))
-            error("failed to apply template");
+    out << ") ";
+    if (entry->isInline == FORCE_INLINE)
+        out << "alwaysinline ";
 
-        out << body;
+    string body;
+    if (!interpolateLLVMCode(entry->code->llvmBody, body, entry->env))
+        error("failed to apply template");
 
-        llvm::SMDiagnostic err;
-        llvm::MemoryBuffer *buf =
-                llvm::MemoryBuffer::getMemBuffer(llvm::StringRef(out.str()));
+    out << body;
 
-        if (!llvm::ParseAssembly(buf, llvmModule, err,
-                                 llvmContext)) {
-            llvm::errs() << out.str();
-            err.print("\n", llvm::errs());
-            llvm::errs() << "\n";
-            error("llvm assembly parse error");
-        }
+    llvm::SMDiagnostic err;
+    llvm::MemoryBuffer *buf =
+        llvm::MemoryBuffer::getMemBuffer(llvm::StringRef(out.str()));
 
-        entry->llvmFunc = llvmModule->getFunction(functionName.str());
-        assert(entry->llvmFunc);
+    if (!llvm::ParseAssembly(buf, llvmModule, err, llvmContext)) {
+        llvm::errs() << out.str();
+        err.print("\n", llvm::errs());
+        llvm::errs() << "\n";
+        error("llvm assembly parse error");
     }
 
-    //
-    // getCodeName
-    //
+    entry->llvmFunc = llvmModule->getFunction(functionName.str());
+    assert(entry->llvmFunc);
+}
 
-    string getCodeName(InvokeEntry *entry) {
-        SafePrintNameEnabler enabler;
-        ObjectPtr x = entry->callable;
-        llvm::SmallString<128> buf;
-        llvm::raw_svector_ostream sout(buf);
+//
+// getCodeName
+//
 
-        printModuleQualification(sout, staticModule(x));
+string getCodeName(InvokeEntry *entry) {
+    SafePrintNameEnabler enabler;
+    ObjectPtr x = entry->callable;
+    llvm::SmallString<128> buf;
+    llvm::raw_svector_ostream sout(buf);
 
-        switch (x->objKind) {
-            case TYPE: {
-                sout << x;
-                break;
-            }
-            case RECORD_DECL: {
-                RecordDecl *y = (RecordDecl *) x.ptr();
-                sout << y->name->str;
-                break;
-            }
-            case VARIANT_DECL: {
-                VariantDecl *y = (VariantDecl *) x.ptr();
-                sout << y->name->str;
-                break;
-            }
-            case PROCEDURE: {
-                Procedure *y = (Procedure *) x.ptr();
-                sout << y->name->str;
-                break;
-            }
-            case GLOBAL_ALIAS: {
-                GlobalAlias *y = (GlobalAlias *) x.ptr();
-                sout << y->name->str;
-                break;
-            }
-            case PRIM_OP: {
-                assert(isOverloadablePrimOp(x));
-                sout << primOpName((PrimOp *) x.ptr());
-                break;
-            }
-            default:
-                assert(false);
-        }
-        sout << '(';
-        for (size_t i = 0; i < entry->argsKey.size(); ++i) {
+    printModuleQualification(sout, staticModule(x));
+
+    switch (x->objKind) {
+    case TYPE: {
+        sout << x;
+        break;
+    }
+    case RECORD_DECL: {
+        RecordDecl *y = (RecordDecl *)x.ptr();
+        sout << y->name->str;
+        break;
+    }
+    case VARIANT_DECL: {
+        VariantDecl *y = (VariantDecl *)x.ptr();
+        sout << y->name->str;
+        break;
+    }
+    case PROCEDURE: {
+        Procedure *y = (Procedure *)x.ptr();
+        sout << y->name->str;
+        break;
+    }
+    case GLOBAL_ALIAS: {
+        GlobalAlias *y = (GlobalAlias *)x.ptr();
+        sout << y->name->str;
+        break;
+    }
+    case PRIM_OP: {
+        assert(isOverloadablePrimOp(x));
+        sout << primOpName((PrimOp *)x.ptr());
+        break;
+    }
+    default:
+        assert(false);
+    }
+    sout << '(';
+    for (size_t i = 0; i < entry->argsKey.size(); ++i) {
+        if (i != 0)
+            sout << ", ";
+        sout << entry->argsKey[i];
+    }
+    sout << ')';
+    if (!entry->returnTypes.empty()) {
+        sout << ' ';
+        for (size_t i = 0; i < entry->returnTypes.size(); ++i) {
             if (i != 0)
                 sout << ", ";
-            sout << entry->argsKey[i];
-        }
-        sout << ')';
-        if (!entry->returnTypes.empty()) {
-            sout << ' ';
-            for (size_t i = 0; i < entry->returnTypes.size(); ++i) {
-                if (i != 0)
-                    sout << ", ";
-                sout << entry->returnTypes[i];
-            }
+            sout << entry->returnTypes[i];
         }
+    }
+
+    sout << " clay";
 
-        sout << " clay";
+    return sout.str();
+}
 
-        return sout.str();
+//
+// codegenCodeBody
+//
+
+static bool blockIsNop(llvm::BasicBlock *codeBlock,
+                       llvm::BasicBlock *returnBlock) {
+    if (codeBlock->size() == 1) {
+        if (llvm::BranchInst *branch =
+                llvm::dyn_cast<llvm::BranchInst>(&codeBlock->front())) {
+            return branch->getNumSuccessors() == 1 &&
+                   branch->getSuccessor(0) == returnBlock;
+        }
     }
+    return false;
+}
 
-    //
-    // codegenCodeBody
-    //
+void codegenCodeBody(InvokeEntry *entry) {
+    assert(entry->analyzed);
+    assert(!entry->llvmFunc);
 
-    static bool blockIsNop(llvm::BasicBlock *codeBlock, llvm::BasicBlock *returnBlock) {
-        if (codeBlock->size() == 1) {
-            if (llvm::BranchInst *branch = llvm::dyn_cast<llvm::BranchInst>(&codeBlock->front())) {
-                return branch->getNumSuccessors() == 1 && branch->getSuccessor(0) == returnBlock;
-            }
-        }
-        return false;
+    string callableName = getCodeName(entry);
+
+    if (entry->code->isLLVMBody()) {
+        codegenLLVMBody(entry, callableName);
+        return;
     }
 
-    void codegenCodeBody(InvokeEntry *entry) {
-        assert(entry->analyzed);
-        assert(!entry->llvmFunc);
+    vector<llvm::Type *> llArgTypes;
+    for (size_t i = 0; i < entry->argsKey.size(); ++i)
+        llArgTypes.push_back(llvmPointerType(entry->argsKey[i]));
+    for (size_t i = 0; i < entry->returnTypes.size(); ++i) {
+        TypePtr rt = entry->returnTypes[i];
+        if (entry->returnIsRef[i])
+            llArgTypes.push_back(llvmPointerType(pointerType(rt)));
+        else
+            llArgTypes.push_back(llvmPointerType(rt));
+    }
 
-        string callableName = getCodeName(entry);
+    llvm::FunctionType *llFuncType =
+        llvm::FunctionType::get(exceptionReturnType(), llArgTypes, false);
 
-        if (entry->code->isLLVMBody()) {
-            codegenLLVMBody(entry, callableName);
-            return;
-        }
+    string llvmFuncName = callableName;
 
-        vector<llvm::Type *> llArgTypes;
-        for (size_t i = 0; i < entry->argsKey.size(); ++i)
-            llArgTypes.push_back(llvmPointerType(entry->argsKey[i]));
-        for (size_t i = 0; i < entry->returnTypes.size(); ++i) {
-            TypePtr rt = entry->returnTypes[i];
-            if (entry->returnIsRef[i])
-                llArgTypes.push_back(llvmPointerType(pointerType(rt)));
-            else
-                llArgTypes.push_back(llvmPointerType(rt));
-        }
+    llvm::Function *llFunc = llvm::Function::Create(
+        llFuncType, llvm::Function::InternalLinkage, llvmFuncName, llvmModule);
 
-        llvm::FunctionType *llFuncType =
-                llvm::FunctionType::get(exceptionReturnType(), llArgTypes, false);
+    switch (entry->isInline) {
+    case INLINE:
+        if (inlineEnabled())
+            llFunc->addFnAttr(llvm::Attribute::InlineHint);
+        break;
+    case NEVER_INLINE:
+        llFunc->addFnAttr(llvm::Attribute::NoInline);
+        break;
+    default:
+        break;
+    }
 
-        string llvmFuncName = callableName;
+    for (unsigned i = 1; i <= llArgTypes.size(); ++i) {
+        llvm::AttributeList attrs = llvm::Attribute::get(
+            llFunc->getContext(), llvm::Attribute::NoAlias);
+        llFunc->addAttribute(i, attrs);
+    }
 
-        llvm::Function *llFunc =
-                llvm::Function::Create(llFuncType,
-                                       llvm::Function::InternalLinkage,
-                                       llvmFuncName,
-                                       llvmModule);
+    entry->llvmFunc = llFunc;
 
-        switch (entry->isInline) {
-            case INLINE:
-                if (inlineEnabled())
-                    llFunc->addFnAttr(llvm::Attributes::InlineHint);
-                break;
-            case NEVER_INLINE:
-                llFunc->addFnAttr(llvm::Attributes::NoInline);
-                break;
-            default:
-                break;
-        }
+    CodegenContext ctx(entry->llvmFunc);
+
+    unsigned line, column;
+    llvm::DIFile file;
+    if (llvmDIBuilder != nullptr) {
+        file = getDebugLineCol(entry->origCode->location, line, column);
 
-        for (unsigned i = 1; i <= llArgTypes.size(); ++i) {
-            llvm::Attributes attrs = llvm::Attributes::get(
-                llFunc->getContext(),
-                llvm::Attributes::NoAlias);
-            llFunc->addAttribute(i, attrs);
+        vector<llvm::Value *> debugParamTypes;
+        debugParamTypes.push_back(llvmVoidTypeDebugInfo());
+        for (size_t i = 0; i < entry->argsKey.size(); ++i) {
+            llvm::DIType argType = llvmTypeDebugInfo(entry->argsKey[i]);
+            llvm::DIType argRefType = llvmDIBuilder->createReferenceType(
+                llvm::dwarf::DW_TAG_reference_type, argType);
+            debugParamTypes.push_back(argRefType);
+        }
+        for (size_t i = 0; i < entry->returnTypes.size(); ++i) {
+            llvm::DIType returnType = llvmTypeDebugInfo(entry->returnTypes[i]);
+            llvm::DIType returnRefType =
+                entry->returnIsRef[i]
+                    ? llvmDIBuilder->createReferenceType(
+                          llvm::dwarf::DW_TAG_reference_type,
+                          llvmDIBuilder->createReferenceType(
+                              llvm::dwarf::DW_TAG_reference_type, returnType))
+                    : llvmDIBuilder->createReferenceType(
+                          llvm::dwarf::DW_TAG_reference_type, returnType);
+
+            debugParamTypes.push_back(returnRefType);
         }
 
-        entry->llvmFunc = llFunc;
+        llvm::DIArray debugParamArray =
+            llvmDIBuilder->getOrCreateArray(llvm::ArrayRef(debugParamTypes));
 
-        CodegenContext ctx(entry->llvmFunc);
+        llvm::DIType typeDebugInfo =
+            llvmDIBuilder->createSubroutineType(file, debugParamArray);
 
-        unsigned line, column;
-        llvm::DIFile file;
-        if (llvmDIBuilder != nullptr) {
-            file = getDebugLineCol(entry->origCode->location, line, column);
+        entry->debugInfo = (llvm::MDNode *)llvmDIBuilder->createFunction(
+            lookupModuleDebugInfo(entry->env), callableName, llvmFuncName, file,
+            line, typeDebugInfo,
+            true, // isLocalToUnit
+            true, // isDefinition
+            0,
+            false, // isOptimized
+            entry->llvmFunc);
 
-            vector<llvm::Value *> debugParamTypes;
-            debugParamTypes.push_back(llvmVoidTypeDebugInfo());
-            for (size_t i = 0; i < entry->argsKey.size(); ++i) {
-                llvm::DIType argType = llvmTypeDebugInfo(entry->argsKey[i]);
-                llvm::DIType argRefType
-                        = llvmDIBuilder->createReferenceType(
-                            llvm::dwarf::DW_TAG_reference_type,
-                            argType);
-                debugParamTypes.push_back(argRefType);
-            }
-            for (size_t i = 0; i < entry->returnTypes.size(); ++i) {
-                llvm::DIType returnType = llvmTypeDebugInfo(entry->returnTypes[i]);
-                llvm::DIType returnRefType = entry->returnIsRef[i]
-                                                 ? llvmDIBuilder->createReferenceType(
-                                                     llvm::dwarf::DW_TAG_reference_type,
-                                                     llvmDIBuilder->createReferenceType(
-                                                         llvm::dwarf::DW_TAG_reference_type,
-                                                         returnType))
-                                                 : llvmDIBuilder->createReferenceType(
-                                                     llvm::dwarf::DW_TAG_reference_type,
-                                                     returnType);
-
-                debugParamTypes.push_back(returnRefType);
-            }
+        ctx.pushDebugScope(llvmDIBuilder->createLexicalBlock(
+            entry->getDebugInfo(), file, line, column));
+    }
 
-            llvm::DIArray debugParamArray = llvmDIBuilder->getOrCreateArray(
-                llvm::ArrayRef(debugParamTypes));
+    llvm::BasicBlock *initBlock = newBasicBlock("init", &ctx);
+    llvm::BasicBlock *codeBlock = newBasicBlock("code", &ctx);
+    llvm::BasicBlock *returnBlock = newBasicBlock("return", &ctx);
+    llvm::BasicBlock *exceptionBlock = newBasicBlock("exception", &ctx);
 
-            llvm::DIType typeDebugInfo = llvmDIBuilder->createSubroutineType(
-                file,
-                debugParamArray);
-
-            entry->debugInfo = (llvm::MDNode *) llvmDIBuilder->createFunction(
-                lookupModuleDebugInfo(entry->env),
-                callableName,
-                llvmFuncName,
-                file,
-                line,
-                typeDebugInfo,
-                true, // isLocalToUnit
-                true, // isDefinition
-                0,
-                false, // isOptimized
-                entry->llvmFunc
-            );
+    ctx.initBuilder = std::make_unique<llvm::IRBuilder<>>(initBlock);
+    ctx.builder = std::make_unique<llvm::IRBuilder<>>(codeBlock);
 
-            ctx.pushDebugScope(llvmDIBuilder->createLexicalBlock(
-                entry->getDebugInfo(),
-                file,
-                line,
-                column
-            ));
-        }
+    if (llvmDIBuilder != nullptr) {
+        llvm::DebugLoc debugLoc =
+            llvm::DebugLoc::get(line, column, entry->getDebugInfo());
+        ctx.initBuilder->SetCurrentDebugLocation(debugLoc);
+        ctx.builder->SetCurrentDebugLocation(debugLoc);
+    }
 
-        llvm::BasicBlock *initBlock = newBasicBlock("init", &ctx);
-        llvm::BasicBlock *codeBlock = newBasicBlock("code", &ctx);
-        llvm::BasicBlock *returnBlock = newBasicBlock("return", &ctx);
-        llvm::BasicBlock *exceptionBlock = newBasicBlock("exception", &ctx);
+    ctx.exceptionValue = ctx.initBuilder->CreateAlloca(exceptionReturnType(),
+                                                       nullptr, "exception");
 
-        ctx.initBuilder.reset(new llvm::IRBuilder<>(initBlock));
-        ctx.builder.reset(new llvm::IRBuilder<>(codeBlock));
+    EnvPtr env = new Env(entry->env);
 
+    llvm::Function::arg_iterator ai = llFunc->arg_begin();
+    unsigned argNo = 1;
+    unsigned i = 0;
+    for (; i < entry->varArgPosition; ++i, ++ai, ++argNo) {
+        llvm::Argument *llArgValue = &(*ai);
+        llArgValue->setName(entry->fixedArgNames[i]->str.str());
+        CValuePtr cvalue = new CValue(entry->fixedArgTypes[i], llArgValue,
+                                      entry->forwardedRValueFlags[i]);
+        addLocal(env, entry->fixedArgNames[i], cvalue.ptr());
         if (llvmDIBuilder != nullptr) {
-            llvm::DebugLoc debugLoc = llvm::DebugLoc::get(line, column, entry->getDebugInfo());
-            ctx.initBuilder->SetCurrentDebugLocation(debugLoc);
-            ctx.builder->SetCurrentDebugLocation(debugLoc);
+            unsigned line, column;
+            Location argLocation = entry->origCode->formalArgs[i]->location;
+            llvm::DIFile file = getDebugLineCol(argLocation, line, column);
+            llvm::DebugLoc debugLoc =
+                llvm::DebugLoc::get(line, column, entry->getDebugInfo());
+            llvm::DIVariable debugVar = llvmDIBuilder->createLocalVariable(
+                llvm::dwarf::DW_TAG_variable, // tag
+                entry->getDebugInfo(),        // scope
+                entry->fixedArgNames[i]->str, // name
+                file,                         // file
+                line,                         // line
+                llvmDIBuilder->createReferenceType(
+                    llvm::dwarf::DW_TAG_reference_type,
+                    llvmTypeDebugInfo(entry->fixedArgTypes[i])), // type
+                true, // alwaysPreserve
+                0,    // flags
+                argNo);
+            llvmDIBuilder->insertDeclare(llArgValue, debugVar, initBlock)
+                ->setDebugLoc(debugLoc);
+            llvm::Value *debugAlloca =
+                ctx.initBuilder->CreateAlloca(llArgValue->getType());
+            ctx.initBuilder->CreateStore(llArgValue, debugAlloca);
         }
+    }
 
-        ctx.exceptionValue = ctx.initBuilder->CreateAlloca(exceptionReturnType(), nullptr, "exception");
+    if (entry->varArgName.ptr()) {
+        MultiCValuePtr varArgs = new MultiCValue();
 
-        EnvPtr env = new Env(entry->env);
+        unsigned line, column;
+        Location argLocation =
+            entry->origCode->formalArgs[entry->varArgPosition]->location;
+        llvm::DIFile file = getDebugLineCol(argLocation, line, column);
+        unsigned j = 0;
+        for (; j < entry->varArgTypes.size(); ++j, ++ai, ++argNo) {
+            llvm::Argument *llArgValue = &(*ai);
+            llvm::SmallString<128> buf;
+            llvm::raw_svector_ostream sout(buf);
+            sout << entry->varArgName << ".." << j;
+            llArgValue->setName(sout.str());
+            CValuePtr cvalue = new CValue(entry->varArgTypes[j], llArgValue,
+                                          entry->forwardedRValueFlags[i + j]);
+            varArgs->add(cvalue);
 
-        llvm::Function::arg_iterator ai = llFunc->arg_begin();
-        unsigned argNo = 1;
-        unsigned i = 0;
-        for (; i < entry->varArgPosition; ++i, ++ai, ++argNo) {
+            if (llvmDIBuilder != nullptr) {
+                llvm::DebugLoc debugLoc =
+                    llvm::DebugLoc::get(line, column, entry->getDebugInfo());
+                llvm::DIVariable debugVar = llvmDIBuilder->createLocalVariable(
+                    llvm::dwarf::DW_TAG_variable, // tag
+                    entry->getDebugInfo(),        // scope
+                    sout.str(),                   // name
+                    file,                         // file
+                    line,                         // line
+                    llvmDIBuilder->createReferenceType(
+                        llvm::dwarf::DW_TAG_reference_type,
+                        llvmTypeDebugInfo(entry->varArgTypes[j])), // type
+                    true, // alwaysPreserve
+                    0,    // flags
+                    argNo);
+                llvmDIBuilder->insertDeclare(llArgValue, debugVar, initBlock)
+                    ->setDebugLoc(debugLoc);
+                llvm::Value *debugAlloca =
+                    ctx.initBuilder->CreateAlloca(llArgValue->getType());
+                ctx.initBuilder->CreateStore(llArgValue, debugAlloca);
+            }
+        }
+        addLocal(env, entry->varArgName, varArgs.ptr());
+        for (; i < entry->fixedArgNames.size(); ++i, ++ai, ++argNo) {
             llvm::Argument *llArgValue = &(*ai);
             llArgValue->setName(entry->fixedArgNames[i]->str.str());
-            CValuePtr cvalue = new CValue(entry->fixedArgTypes[i], llArgValue, entry->forwardedRValueFlags[i]);
+            CValuePtr cvalue = new CValue(entry->fixedArgTypes[i], llArgValue,
+                                          entry->forwardedRValueFlags[i + j]);
             addLocal(env, entry->fixedArgNames[i], cvalue.ptr());
             if (llvmDIBuilder != nullptr) {
                 unsigned line, column;
                 Location argLocation = entry->origCode->formalArgs[i]->location;
                 llvm::DIFile file = getDebugLineCol(argLocation, line, column);
-                llvm::DebugLoc debugLoc = llvm::DebugLoc::get(line, column, entry->getDebugInfo());
+                llvm::DebugLoc debugLoc =
+                    llvm::DebugLoc::get(line, column, entry->getDebugInfo());
                 llvm::DIVariable debugVar = llvmDIBuilder->createLocalVariable(
                     llvm::dwarf::DW_TAG_variable, // tag
-                    entry->getDebugInfo(), // scope
+                    entry->getDebugInfo(),        // scope
                     entry->fixedArgNames[i]->str, // name
-                    file, // file
-                    line, // line
+                    file,                         // file
+                    line,                         // line
                     llvmDIBuilder->createReferenceType(
                         llvm::dwarf::DW_TAG_reference_type,
                         llvmTypeDebugInfo(entry->fixedArgTypes[i])), // type
                     true, // alwaysPreserve
-                    0, // flags
-                    argNo
-                );
-                llvmDIBuilder->insertDeclare(
-                            llArgValue,
-                            debugVar,
-                            initBlock)
-                        ->setDebugLoc(debugLoc);
+                    0,    // flags
+                    argNo);
+                llvmDIBuilder->insertDeclare(llArgValue, debugVar, initBlock)
+                    ->setDebugLoc(debugLoc);
                 llvm::Value *debugAlloca =
-                        ctx.initBuilder->CreateAlloca(llArgValue->getType());
+                    ctx.initBuilder->CreateAlloca(llArgValue->getType());
                 ctx.initBuilder->CreateStore(llArgValue, debugAlloca);
             }
         }
+    }
 
-        if (entry->varArgName.ptr()) {
-            MultiCValuePtr varArgs = new MultiCValue();
-
-            unsigned line, column;
-            Location argLocation = entry->origCode->formalArgs[entry->varArgPosition]->location;
-            llvm::DIFile file = getDebugLineCol(argLocation, line, column);
-            unsigned j = 0;
-            for (; j < entry->varArgTypes.size(); ++j, ++ai, ++argNo) {
-                llvm::Argument *llArgValue = &(*ai);
-                llvm::SmallString<128> buf;
-                llvm::raw_svector_ostream sout(buf);
-                sout << entry->varArgName << ".." << j;
-                llArgValue->setName(sout.str());
-                CValuePtr cvalue = new CValue(entry->varArgTypes[j], llArgValue, entry->forwardedRValueFlags[i + j]);
-                varArgs->add(cvalue);
-
-                if (llvmDIBuilder != nullptr) {
-                    llvm::DebugLoc debugLoc = llvm::DebugLoc::get(line, column, entry->getDebugInfo());
-                    llvm::DIVariable debugVar = llvmDIBuilder->createLocalVariable(
-                        llvm::dwarf::DW_TAG_variable, // tag
-                        entry->getDebugInfo(), // scope
-                        sout.str(), // name
-                        file, // file
-                        line, // line
-                        llvmDIBuilder->createReferenceType(
-                            llvm::dwarf::DW_TAG_reference_type,
-                            llvmTypeDebugInfo(entry->varArgTypes[j])), // type
-                        true, // alwaysPreserve
-                        0, // flags
-                        argNo
-                    );
-                    llvmDIBuilder->insertDeclare(
-                                llArgValue,
-                                debugVar,
-                                initBlock)
-                            ->setDebugLoc(debugLoc);
-                    llvm::Value *debugAlloca =
-                            ctx.initBuilder->CreateAlloca(llArgValue->getType());
-                    ctx.initBuilder->CreateStore(llArgValue, debugAlloca);
-                }
-            }
-            addLocal(env, entry->varArgName, varArgs.ptr());
-            for (; i < entry->fixedArgNames.size(); ++i, ++ai, ++argNo) {
-                llvm::Argument *llArgValue = &(*ai);
-                llArgValue->setName(entry->fixedArgNames[i]->str.str());
-                CValuePtr cvalue = new CValue(entry->fixedArgTypes[i], llArgValue, entry->forwardedRValueFlags[i + j]);
-                addLocal(env, entry->fixedArgNames[i], cvalue.ptr());
-                if (llvmDIBuilder != nullptr) {
-                    unsigned line, column;
-                    Location argLocation = entry->origCode->formalArgs[i]->location;
-                    llvm::DIFile file = getDebugLineCol(argLocation, line, column);
-                    llvm::DebugLoc debugLoc = llvm::DebugLoc::get(line, column, entry->getDebugInfo());
-                    llvm::DIVariable debugVar = llvmDIBuilder->createLocalVariable(
-                        llvm::dwarf::DW_TAG_variable, // tag
-                        entry->getDebugInfo(), // scope
-                        entry->fixedArgNames[i]->str, // name
-                        file, // file
-                        line, // line
-                        llvmDIBuilder->createReferenceType(
-                            llvm::dwarf::DW_TAG_reference_type,
-                            llvmTypeDebugInfo(entry->fixedArgTypes[i])), // type
-                        true, // alwaysPreserve
-                        0, // flags
-                        argNo
-                    );
-                    llvmDIBuilder->insertDeclare(
-                                llArgValue,
-                                debugVar,
-                                initBlock)
-                            ->setDebugLoc(debugLoc);
-                    llvm::Value *debugAlloca =
-                            ctx.initBuilder->CreateAlloca(llArgValue->getType());
-                    ctx.initBuilder->CreateStore(llArgValue, debugAlloca);
-                }
-            }
-        }
-
-        // XXX debug info for returns
+    // XXX debug info for returns
 
-        vector<CReturn> returns;
-        for (size_t i = 0; i < entry->returnTypes.size(); ++i, ++ai) {
-            llvm::Argument *llArgValue = &(*ai);
-            TypePtr rt = entry->returnTypes[i];
-            CValuePtr cv;
-            if (entry->returnIsRef[i])
-                cv = new CValue(pointerType(rt), llArgValue);
-            else
-                cv = new CValue(rt, llArgValue);
-            returns.push_back(CReturn(entry->returnIsRef[i], rt, cv));
-        }
+    vector<CReturn> returns;
+    for (size_t i = 0; i < entry->returnTypes.size(); ++i, ++ai) {
+        llvm::Argument *llArgValue = &(*ai);
+        TypePtr rt = entry->returnTypes[i];
+        CValuePtr cv;
+        if (entry->returnIsRef[i])
+            cv = new CValue(pointerType(rt), llArgValue);
+        else
+            cv = new CValue(rt, llArgValue);
+        returns.push_back(CReturn(entry->returnIsRef[i], rt, cv));
+    }
 
-        bool hasNamedReturn = false;
-        if (entry->code->hasReturnSpecs()) {
-            llvm::ArrayRef<ReturnSpecPtr> returnSpecs = entry->code->returnSpecs;
-            size_t i = 0;
-            for (; i < returnSpecs.size(); ++i, ++argNo) {
-                ReturnSpecPtr rspec = returnSpecs[i];
-                llvm::SmallString<128> buf;
-                llvm::raw_svector_ostream sout(buf);
-                if (rspec->name != nullptr) {
-                    hasNamedReturn = true;
-                    addLocal(env, rspec->name, returns[i].value.ptr());
-                    sout << rspec->name->str;
-                } else
-                    sout << "return.." << i;
-                returns[i].value->llValue->setName(sout.str());
-
-                if (rspec->name != nullptr && llvmDIBuilder != nullptr) {
-                    unsigned line, column;
-                    Location argLocation = rspec->location;
-                    llvm::DIFile file = getDebugLineCol(argLocation, line, column);
-                    llvm::DebugLoc debugLoc = llvm::DebugLoc::get(line, column, entry->getDebugInfo());
-                    llvm::DIVariable debugVar = llvmDIBuilder->createLocalVariable(
-                        llvm::dwarf::DW_TAG_return_variable, // tag
-                        entry->getDebugInfo(), // scope
-                        rspec->name->str, // name
-                        file, // file
-                        line, // line
-                        llvmDIBuilder->createReferenceType(
-                            llvm::dwarf::DW_TAG_reference_type,
-                            llvmTypeDebugInfo(returns[i].type)), // type
-                        true, // alwaysPreserve
-                        0, // flags
-                        argNo
-                    );
-                    llvmDIBuilder->insertDeclare(
-                                returns[i].value->llValue,
-                                debugVar,
-                                initBlock)
-                            ->setDebugLoc(debugLoc);
-                    //llvm::Value *debugAlloca =
-                    //    ctx.initBuilder->CreateAlloca(llArgValue->getType());
-                    //ctx.initBuilder->CreateStore(llArgValue, debugAlloca);
-                }
-            }
-            ReturnSpecPtr varReturnSpec = entry->code->varReturnSpec;
-            if (!varReturnSpec)
-                assert(i == entry->returnTypes.size());
-            if (varReturnSpec.ptr() && varReturnSpec->name.ptr()) {
+    bool hasNamedReturn = false;
+    if (entry->code->hasReturnSpecs()) {
+        llvm::ArrayRef<ReturnSpecPtr> returnSpecs = entry->code->returnSpecs;
+        size_t i = 0;
+        for (; i < returnSpecs.size(); ++i, ++argNo) {
+            ReturnSpecPtr rspec = returnSpecs[i];
+            llvm::SmallString<128> buf;
+            llvm::raw_svector_ostream sout(buf);
+            if (rspec->name != nullptr) {
                 hasNamedReturn = true;
-                MultiCValuePtr mcv = new MultiCValue();
-                for (; i < entry->returnTypes.size(); ++i)
-                    mcv->add(returns[i].value);
-                addLocal(env, varReturnSpec->name, mcv.ptr());
+                addLocal(env, rspec->name, returns[i].value.ptr());
+                sout << rspec->name->str;
+            } else
+                sout << "return.." << i;
+            returns[i].value->llValue->setName(sout.str());
+
+            if (rspec->name != nullptr && llvmDIBuilder != nullptr) {
+                unsigned line, column;
+                Location argLocation = rspec->location;
+                llvm::DIFile file = getDebugLineCol(argLocation, line, column);
+                llvm::DebugLoc debugLoc =
+                    llvm::DebugLoc::get(line, column, entry->getDebugInfo());
+                llvm::DIVariable debugVar = llvmDIBuilder->createLocalVariable(
+                    llvm::dwarf::DW_TAG_return_variable, // tag
+                    entry->getDebugInfo(),               // scope
+                    rspec->name->str,                    // name
+                    file,                                // file
+                    line,                                // line
+                    llvmDIBuilder->createReferenceType(
+                        llvm::dwarf::DW_TAG_reference_type,
+                        llvmTypeDebugInfo(returns[i].type)), // type
+                    true,                                    // alwaysPreserve
+                    0,                                       // flags
+                    argNo);
+                llvmDIBuilder
+                    ->insertDeclare(returns[i].value->llValue, debugVar,
+                                    initBlock)
+                    ->setDebugLoc(debugLoc);
+                // llvm::Value *debugAlloca =
+                //     ctx.initBuilder->CreateAlloca(llArgValue->getType());
+                // ctx.initBuilder->CreateStore(llArgValue, debugAlloca);
             }
         }
+        ReturnSpecPtr varReturnSpec = entry->code->varReturnSpec;
+        if (!varReturnSpec)
+            assert(i == entry->returnTypes.size());
+        if (varReturnSpec.ptr() && varReturnSpec->name.ptr()) {
+            hasNamedReturn = true;
+            MultiCValuePtr mcv = new MultiCValue();
+            for (; i < entry->returnTypes.size(); ++i)
+                mcv->add(returns[i].value);
+            addLocal(env, varReturnSpec->name, mcv.ptr());
+        }
+    }
 
-        ctx.returnLists.push_back(returns);
-        JumpTarget returnTarget(returnBlock, cgMarkStack(&ctx));
-        ctx.returnTargets.push_back(returnTarget);
-        JumpTarget exceptionTarget(exceptionBlock, cgMarkStack(&ctx));
-        ctx.exceptionTargets.push_back(exceptionTarget);
-
-        assert(entry->code->body.ptr());
-        bool terminated = codegenStatement(entry->code->body, env, &ctx);
-        if (!terminated) {
-            if ((returns.size() > 0) && !hasNamedReturn) {
-                error(entry->code, "not all paths have a return statement");
-            }
-            cgDestroyStack(returnTarget.stackMarker, &ctx, false);
-            ctx.builder->CreateBr(returnBlock);
+    ctx.returnLists.push_back(returns);
+    JumpTarget returnTarget(returnBlock, cgMarkStack(&ctx));
+    ctx.returnTargets.push_back(returnTarget);
+    JumpTarget exceptionTarget(exceptionBlock, cgMarkStack(&ctx));
+    ctx.exceptionTargets.push_back(exceptionTarget);
+
+    assert(entry->code->body.ptr());
+    bool terminated = codegenStatement(entry->code->body, env, &ctx);
+    if (!terminated) {
+        if ((returns.size() > 0) && !hasNamedReturn) {
+            error(entry->code, "not all paths have a return statement");
         }
-        cgPopStack(returnTarget.stackMarker, &ctx);
+        cgDestroyStack(returnTarget.stackMarker, &ctx, false);
+        ctx.builder->CreateBr(returnBlock);
+    }
+    cgPopStack(returnTarget.stackMarker, &ctx);
 
-        entry->runtimeNop = blockIsNop(codeBlock, returnBlock);
+    entry->runtimeNop = blockIsNop(codeBlock, returnBlock);
 
-        ctx.initBuilder->CreateBr(codeBlock);
+    ctx.initBuilder->CreateBr(codeBlock);
 
-        returnBlock->moveAfter(ctx.builder->GetInsertBlock());
-        exceptionBlock->moveAfter(returnBlock);
+    returnBlock->moveAfter(ctx.builder->GetInsertBlock());
+    exceptionBlock->moveAfter(returnBlock);
 
-        ctx.builder->SetInsertPoint(returnBlock);
-        llvm::Value *llRet = noExceptionReturnValue();
-        ctx.builder->CreateRet(llRet);
+    ctx.builder->SetInsertPoint(returnBlock);
+    llvm::Value *llRet = noExceptionReturnValue();
+    ctx.builder->CreateRet(llRet);
 
-        ctx.builder->SetInsertPoint(exceptionBlock);
-        assert(ctx.exceptionValue != nullptr);
-        llvm::Value *llExcept = ctx.builder->CreateLoad(ctx.exceptionValue);
-        ctx.builder->CreateRet(llExcept);
-    }
+    ctx.builder->SetInsertPoint(exceptionBlock);
+    assert(ctx.exceptionValue != nullptr);
+    llvm::Value *llExcept = ctx.builder->CreateLoad(ctx.exceptionValue);
+    ctx.builder->CreateRet(llExcept);
+}
 
-    //
-    // codegenCallInline
-    //
+//
+// codegenCallInline
+//
 
-    void codegenCallInline(InvokeEntry *entry,
-                           MultiCValuePtr args,
-                           CodegenContext *ctx,
-                           MultiCValuePtr out) {
-        assert(entry->isInline==FORCE_INLINE);
-        assert(ctx->inlineDepth >= 0);
-        if (entry->code->isLLVMBody())
-            error(entry->code, "llvm procedures cannot be inlined");
+void codegenCallInline(InvokeEntry *entry, MultiCValuePtr args,
+                       CodegenContext *ctx, MultiCValuePtr out) {
+    assert(entry->isInline == FORCE_INLINE);
+    assert(ctx->inlineDepth >= 0);
+    if (entry->code->isLLVMBody())
+        error(entry->code, "llvm procedures cannot be inlined");
 
-        ++ctx->inlineDepth;
+    ++ctx->inlineDepth;
 
-        ensureArity(args, entry->argsKey.size());
+    ensureArity(args, entry->argsKey.size());
 
-        EnvPtr env = new Env(entry->env);
+    EnvPtr env = new Env(entry->env);
 
-        unsigned i = 0, j = 0;
-        for (; i < entry->varArgPosition; ++i) {
-            CValuePtr cv = args->values[i];
-            CValuePtr carg = new CValue(cv->type, cv->llValue, entry->forwardedRValueFlags[i]);
-            assert(carg->type == entry->argsKey[i]);
-            addLocal(env, entry->fixedArgNames[i], carg.ptr());
+    unsigned i = 0, j = 0;
+    for (; i < entry->varArgPosition; ++i) {
+        CValuePtr cv = args->values[i];
+        CValuePtr carg =
+            new CValue(cv->type, cv->llValue, entry->forwardedRValueFlags[i]);
+        assert(carg->type == entry->argsKey[i]);
+        addLocal(env, entry->fixedArgNames[i], carg.ptr());
+    }
+    if (entry->varArgName.ptr()) {
+        MultiCValuePtr varArgs = new MultiCValue();
+        for (; j < entry->varArgTypes.size(); ++j) {
+            CValuePtr cv = args->values[i + j];
+            CValuePtr carg = new CValue(cv->type, cv->llValue,
+                                        entry->forwardedRValueFlags[i + j]);
+            varArgs->add(carg);
         }
-        if (entry->varArgName.ptr()) {
-            MultiCValuePtr varArgs = new MultiCValue();
-            for (; j < entry->varArgTypes.size(); ++j) {
-                CValuePtr cv = args->values[i + j];
-                CValuePtr carg = new CValue(cv->type, cv->llValue, entry->forwardedRValueFlags[i + j]);
-                varArgs->add(carg);
-            }
-            addLocal(env, entry->varArgName, varArgs.ptr());
-            for (; i < entry->fixedArgNames.size(); ++i) {
-                CValuePtr cv = args->values[i + j];
-                CValuePtr carg = new CValue(cv->type, cv->llValue, entry->forwardedRValueFlags[i + j]);
-                assert(carg->type == entry->argsKey[i+j]);
-                addLocal(env, entry->fixedArgNames[i], carg.ptr());
-            }
+        addLocal(env, entry->varArgName, varArgs.ptr());
+        for (; i < entry->fixedArgNames.size(); ++i) {
+            CValuePtr cv = args->values[i + j];
+            CValuePtr carg = new CValue(cv->type, cv->llValue,
+                                        entry->forwardedRValueFlags[i + j]);
+            assert(carg->type == entry->argsKey[i + j]);
+            addLocal(env, entry->fixedArgNames[i], carg.ptr());
         }
+    }
 
-        vector<CReturn> returns;
-        for (size_t i = 0; i < entry->returnTypes.size(); ++i) {
-            TypePtr rt = entry->returnTypes[i];
-            bool isRef = entry->returnIsRef[i];
-            CValuePtr cv = out->values[i];
-            CValuePtr cret = new CValue(cv->type, cv->llValue);
-            if (isRef)
-                assert(cret->type == pointerType(rt));
-            else
-                assert(cret->type == rt);
-            returns.push_back(CReturn(isRef, rt, cret));
-        }
+    vector<CReturn> returns;
+    for (size_t i = 0; i < entry->returnTypes.size(); ++i) {
+        TypePtr rt = entry->returnTypes[i];
+        bool isRef = entry->returnIsRef[i];
+        CValuePtr cv = out->values[i];
+        CValuePtr cret = new CValue(cv->type, cv->llValue);
+        if (isRef)
+            assert(cret->type == pointerType(rt));
+        else
+            assert(cret->type == rt);
+        returns.push_back(CReturn(isRef, rt, cret));
+    }
 
-        bool hasNamedReturn = false;
-        if (entry->code->hasReturnSpecs()) {
-            llvm::ArrayRef<ReturnSpecPtr> returnSpecs = entry->code->returnSpecs;
-            size_t i = 0;
-            for (; i < returnSpecs.size(); ++i) {
-                ReturnSpecPtr rspec = returnSpecs[i];
-                if (rspec->name.ptr()) {
-                    hasNamedReturn = true;
-                    addLocal(env, rspec->name, returns[i].value.ptr());
-                }
-            }
-            ReturnSpecPtr varReturnSpec = entry->code->varReturnSpec;
-            if (!varReturnSpec)
-                assert(i == entry->returnTypes.size());
-            if (varReturnSpec.ptr() && (varReturnSpec->name.ptr())) {
+    bool hasNamedReturn = false;
+    if (entry->code->hasReturnSpecs()) {
+        llvm::ArrayRef<ReturnSpecPtr> returnSpecs = entry->code->returnSpecs;
+        size_t i = 0;
+        for (; i < returnSpecs.size(); ++i) {
+            ReturnSpecPtr rspec = returnSpecs[i];
+            if (rspec->name.ptr()) {
                 hasNamedReturn = true;
-                MultiCValuePtr mcv = new MultiCValue();
-                for (; i < entry->returnTypes.size(); ++i)
-                    mcv->add(returns[i].value);
-                addLocal(env, varReturnSpec->name, mcv.ptr());
+                addLocal(env, rspec->name, returns[i].value.ptr());
             }
         }
+        ReturnSpecPtr varReturnSpec = entry->code->varReturnSpec;
+        if (!varReturnSpec)
+            assert(i == entry->returnTypes.size());
+        if (varReturnSpec.ptr() && (varReturnSpec->name.ptr())) {
+            hasNamedReturn = true;
+            MultiCValuePtr mcv = new MultiCValue();
+            for (; i < entry->returnTypes.size(); ++i)
+                mcv->add(returns[i].value);
+            addLocal(env, varReturnSpec->name, mcv.ptr());
+        }
+    }
 
-        ctx->returnLists.push_back(returns);
-        llvm::BasicBlock *returnBlock = newBasicBlock("return", ctx);
-        JumpTarget returnTarget(returnBlock, cgMarkStack(ctx));
-        ctx->returnTargets.push_back(returnTarget);
+    ctx->returnLists.push_back(returns);
+    llvm::BasicBlock *returnBlock = newBasicBlock("return", ctx);
+    JumpTarget returnTarget(returnBlock, cgMarkStack(ctx));
+    ctx->returnTargets.push_back(returnTarget);
 
-        assert(entry->code->body.ptr());
-        bool terminated = codegenStatement(entry->code->body, env, ctx);
-        if (!terminated) {
-            if ((returns.size() > 0) && !hasNamedReturn) {
-                error(entry->code, "not all paths have a return statement");
-            }
-            cgDestroyStack(returnTarget.stackMarker, ctx, false);
-            ctx->builder->CreateBr(returnBlock);
+    assert(entry->code->body.ptr());
+    bool terminated = codegenStatement(entry->code->body, env, ctx);
+    if (!terminated) {
+        if ((returns.size() > 0) && !hasNamedReturn) {
+            error(entry->code, "not all paths have a return statement");
         }
-        cgPopStack(returnTarget.stackMarker, ctx);
+        cgDestroyStack(returnTarget.stackMarker, ctx, false);
+        ctx->builder->CreateBr(returnBlock);
+    }
+    cgPopStack(returnTarget.stackMarker, ctx);
 
-        ctx->returnLists.pop_back();
-        ctx->returnTargets.pop_back();
+    ctx->returnLists.pop_back();
+    ctx->returnTargets.pop_back();
 
-        returnBlock->moveAfter(ctx->builder->GetInsertBlock());
+    returnBlock->moveAfter(ctx->builder->GetInsertBlock());
 
-        ctx->builder->SetInsertPoint(returnBlock);
+    ctx->builder->SetInsertPoint(returnBlock);
 
-        --ctx->inlineDepth;
-        assert(ctx->inlineDepth >= 0);
-    }
+    --ctx->inlineDepth;
+    assert(ctx->inlineDepth >= 0);
+}
 
-    //
-    // codegenCallByName
-    //
+//
+// codegenCallByName
+//
 
-    void codegenCallByName(InvokeEntry *entry,
-                           ExprPtr callable,
-                           ExprListPtr args,
-                           EnvPtr env,
-                           CodegenContext *ctx,
-                           MultiCValuePtr out) {
-        assert(entry->callByName);
-        assert(ctx->inlineDepth >= 0);
-        if (entry->varArgName.ptr())
-            assert(args->size() >= entry->fixedArgNames.size());
-        else
-            assert(args->size() == entry->fixedArgNames.size());
+void codegenCallByName(InvokeEntry *entry, ExprPtr callable, ExprListPtr args,
+                       EnvPtr env, CodegenContext *ctx, MultiCValuePtr out) {
+    assert(entry->callByName);
+    assert(ctx->inlineDepth >= 0);
+    if (entry->varArgName.ptr())
+        assert(args->size() >= entry->fixedArgNames.size());
+    else
+        assert(args->size() == entry->fixedArgNames.size());
 
-        ++ctx->inlineDepth;
+    ++ctx->inlineDepth;
 
-        ++ctx->callByNameDepth;
-        if (ctx->callByNameDepth > 100) {
-            error("alias functions stack overflow");
-        }
+    ++ctx->callByNameDepth;
+    if (ctx->callByNameDepth > 100) {
+        error("alias functions stack overflow");
+    }
 
-        EnvPtr bodyEnv = new Env(entry->env);
-        bodyEnv->callByNameExprHead = callable;
+    EnvPtr bodyEnv = new Env(entry->env);
+    bodyEnv->callByNameExprHead = callable;
 
-        unsigned k = 0, j = 0;
-        for (; k < entry->varArgPosition; ++k) {
-            ExprPtr expr = foreignExpr(env, args->exprs[k]);
-            addLocal(bodyEnv, entry->fixedArgNames[k], expr.ptr());
+    unsigned k = 0, j = 0;
+    for (; k < entry->varArgPosition; ++k) {
+        ExprPtr expr = foreignExpr(env, args->exprs[k]);
+        addLocal(bodyEnv, entry->fixedArgNames[k], expr.ptr());
+    }
+    if (entry->varArgName.ptr()) {
+        ExprListPtr varArgs = new ExprList();
+        for (; j < args->size() - entry->fixedArgNames.size(); ++j) {
+            ExprPtr expr = foreignExpr(env, args->exprs[k + j]);
+            varArgs->add(expr);
         }
-        if (entry->varArgName.ptr()) {
-            ExprListPtr varArgs = new ExprList();
-            for (; j < args->size() - entry->fixedArgNames.size(); ++j) {
-                ExprPtr expr = foreignExpr(env, args->exprs[k + j]);
-                varArgs->add(expr);
-            }
-            addLocal(bodyEnv, entry->varArgName, varArgs.ptr());
-            for (; k < entry->fixedArgNames.size(); ++k) {
-                ExprPtr expr = foreignExpr(env, args->exprs[k + j]);
-                addLocal(bodyEnv, entry->fixedArgNames[k], expr.ptr());
-            }
+        addLocal(bodyEnv, entry->varArgName, varArgs.ptr());
+        for (; k < entry->fixedArgNames.size(); ++k) {
+            ExprPtr expr = foreignExpr(env, args->exprs[k + j]);
+            addLocal(bodyEnv, entry->fixedArgNames[k], expr.ptr());
         }
+    }
 
-        MultiPValuePtr mpv = safeAnalyzeCallByName(entry, callable, args, env);
-        assert(mpv->size() == out->size());
+    MultiPValuePtr mpv = safeAnalyzeCallByName(entry, callable, args, env);
+    assert(mpv->size() == out->size());
 
-        vector<CReturn> returns;
-        for (unsigned i = 0; i < mpv->size(); ++i) {
-            PVData const &pv = mpv->values[i];
-            CValuePtr cv = out->values[i];
-            if (pv.isRValue)
-                assert(cv->type == pv.type);
-            else
-                assert(cv->type == pointerType(pv.type));
-            returns.push_back(CReturn(!pv.isRValue, pv.type, cv));
-        }
+    vector<CReturn> returns;
+    for (unsigned i = 0; i < mpv->size(); ++i) {
+        PVData const &pv = mpv->values[i];
+        CValuePtr cv = out->values[i];
+        if (pv.isRValue)
+            assert(cv->type == pv.type);
+        else
+            assert(cv->type == pointerType(pv.type));
+        returns.push_back(CReturn(!pv.isRValue, pv.type, cv));
+    }
 
-        bool hasNamedReturn = false;
-        if (entry->code->hasReturnSpecs()) {
-            llvm::ArrayRef<ReturnSpecPtr> returnSpecs = entry->code->returnSpecs;
-            size_t i = 0;
-            for (; i < returnSpecs.size(); ++i) {
-                ReturnSpecPtr rspec = returnSpecs[i];
-                if (rspec->name.ptr()) {
-                    hasNamedReturn = true;
-                    addLocal(bodyEnv, rspec->name, returns[i].value.ptr());
-                }
-            }
-            ReturnSpecPtr varReturnSpec = entry->code->varReturnSpec;
-            if (!varReturnSpec)
-                assert(i == mpv->size());
-            if (varReturnSpec.ptr() && varReturnSpec->name.ptr()) {
+    bool hasNamedReturn = false;
+    if (entry->code->hasReturnSpecs()) {
+        llvm::ArrayRef<ReturnSpecPtr> returnSpecs = entry->code->returnSpecs;
+        size_t i = 0;
+        for (; i < returnSpecs.size(); ++i) {
+            ReturnSpecPtr rspec = returnSpecs[i];
+            if (rspec->name.ptr()) {
                 hasNamedReturn = true;
-                MultiCValuePtr mcv = new MultiCValue();
-                for (; i < mpv->size(); ++i)
-                    mcv->add(returns[i].value);
-                addLocal(bodyEnv, varReturnSpec->name, mcv.ptr());
+                addLocal(bodyEnv, rspec->name, returns[i].value.ptr());
             }
         }
+        ReturnSpecPtr varReturnSpec = entry->code->varReturnSpec;
+        if (!varReturnSpec)
+            assert(i == mpv->size());
+        if (varReturnSpec.ptr() && varReturnSpec->name.ptr()) {
+            hasNamedReturn = true;
+            MultiCValuePtr mcv = new MultiCValue();
+            for (; i < mpv->size(); ++i)
+                mcv->add(returns[i].value);
+            addLocal(bodyEnv, varReturnSpec->name, mcv.ptr());
+        }
+    }
 
-        llvm::BasicBlock *returnBlock = newBasicBlock("return", ctx);
+    llvm::BasicBlock *returnBlock = newBasicBlock("return", ctx);
 
-        ctx->returnLists.push_back(returns);
-        JumpTarget returnTarget(returnBlock, cgMarkStack(ctx));
-        ctx->returnTargets.push_back(returnTarget);
+    ctx->returnLists.push_back(returns);
+    JumpTarget returnTarget(returnBlock, cgMarkStack(ctx));
+    ctx->returnTargets.push_back(returnTarget);
 
-        assert(entry->code->body.ptr());
-        bool terminated = codegenStatement(entry->code->body, bodyEnv, ctx);
-        if (!terminated) {
-            if ((returns.size() > 0) && !hasNamedReturn) {
-                error(entry->code, "not all paths have a return statement");
-            }
-            cgDestroyStack(returnTarget.stackMarker, ctx, false);
-            ctx->builder->CreateBr(returnBlock);
+    assert(entry->code->body.ptr());
+    bool terminated = codegenStatement(entry->code->body, bodyEnv, ctx);
+    if (!terminated) {
+        if ((returns.size() > 0) && !hasNamedReturn) {
+            error(entry->code, "not all paths have a return statement");
         }
-        cgPopStack(returnTarget.stackMarker, ctx);
-
-        ctx->returnLists.pop_back();
-        ctx->returnTargets.pop_back();
-
-        returnBlock->moveAfter(ctx->builder->GetInsertBlock());
+        cgDestroyStack(returnTarget.stackMarker, ctx, false);
+        ctx->builder->CreateBr(returnBlock);
+    }
+    cgPopStack(returnTarget.stackMarker, ctx);
 
-        ctx->builder->SetInsertPoint(returnBlock);
+    ctx->returnLists.pop_back();
+    ctx->returnTargets.pop_back();
 
-        --ctx->inlineDepth;
-        assert(ctx->inlineDepth >= 0);
-        --ctx->callByNameDepth;
-        assert(ctx->callByNameDepth >= 0);
-    }
+    returnBlock->moveAfter(ctx->builder->GetInsertBlock());
 
-    //
-    // codegenStatement
-    //
+    ctx->builder->SetInsertPoint(returnBlock);
 
-    bool codegenStatement(StatementPtr stmt,
-                          EnvPtr env,
-                          CodegenContext *ctx);
+    --ctx->inlineDepth;
+    assert(ctx->inlineDepth >= 0);
+    --ctx->callByNameDepth;
+    assert(ctx->callByNameDepth >= 0);
+}
 
-    static void codegenBlockStatement(BlockPtr block,
-                                      unsigned i,
-                                      StatementPtr stmt,
-                                      EnvPtr &env,
-                                      CodegenContext *ctx,
-                                      bool &terminated) {
-        if (stmt->stmtKind == LABEL) {
-            Label *label = (Label *) stmt.ptr();
-            llvm::StringMap<JumpTarget>::iterator li =
-                    ctx->labels.find(label->name->str);
-            assert(li != ctx->labels.end());
-            JumpTarget &jt = li->second;
-            if (!terminated) {
-                ctx->builder->CreateBr(jt.block);
-                ++jt.useCount;
-            }
-            ctx->builder->SetInsertPoint(jt.block);
-        } else if (terminated) {
-            error(stmt, "unreachable code");
-        } else if (stmt->stmtKind == BINDING) {
-            env = codegenBinding((Binding *) stmt.ptr(), env, ctx);
-            codegenCollectLabels(block->statements, i + 1, ctx);
-        } else if (stmt->stmtKind == EVAL_STATEMENT) {
-            EvalStatement *eval = (EvalStatement *) stmt.ptr();
-            llvm::ArrayRef<StatementPtr> evaled = desugarEvalStatement(eval, env);
-            for (unsigned i = 0; i < evaled.size(); ++i)
-                codegenBlockStatement(block, i, evaled[i], env, ctx, terminated);
-        } else {
-            terminated = codegenStatement(stmt, env, ctx);
+//
+// codegenStatement
+//
+
+bool codegenStatement(StatementPtr stmt, EnvPtr env, CodegenContext *ctx);
+
+static void codegenBlockStatement(BlockPtr block, unsigned i, StatementPtr stmt,
+                                  EnvPtr &env, CodegenContext *ctx,
+                                  bool &terminated) {
+    if (stmt->stmtKind == LABEL) {
+        Label *label = (Label *)stmt.ptr();
+        llvm::StringMap<JumpTarget>::iterator li =
+            ctx->labels.find(label->name->str);
+        assert(li != ctx->labels.end());
+        JumpTarget &jt = li->second;
+        if (!terminated) {
+            ctx->builder->CreateBr(jt.block);
+            ++jt.useCount;
         }
+        ctx->builder->SetInsertPoint(jt.block);
+    } else if (terminated) {
+        error(stmt, "unreachable code");
+    } else if (stmt->stmtKind == BINDING) {
+        env = codegenBinding((Binding *)stmt.ptr(), env, ctx);
+        codegenCollectLabels(block->statements, i + 1, ctx);
+    } else if (stmt->stmtKind == EVAL_STATEMENT) {
+        EvalStatement *eval = (EvalStatement *)stmt.ptr();
+        llvm::ArrayRef<StatementPtr> evaled = desugarEvalStatement(eval, env);
+        for (unsigned i = 0; i < evaled.size(); ++i)
+            codegenBlockStatement(block, i, evaled[i], env, ctx, terminated);
+    } else {
+        terminated = codegenStatement(stmt, env, ctx);
     }
+}
 
-    static EnvPtr codegenStatementExpressionStatements(llvm::ArrayRef<StatementPtr> stmts,
-                                                       EnvPtr env,
-                                                       CodegenContext *ctx) {
-        EnvPtr env2 = env;
+static EnvPtr
+codegenStatementExpressionStatements(llvm::ArrayRef<StatementPtr> stmts,
+                                     EnvPtr env, CodegenContext *ctx) {
+    EnvPtr env2 = env;
 
-        for (StatementPtr const *i = stmts.begin(), *end = stmts.end();
-             i != end;
-             ++i) {
-            switch ((*i)->stmtKind) {
-                case BINDING: {
-                    env2 = codegenBinding((Binding *) i->ptr(), env2, ctx);
-                    break;
-                }
+    for (StatementPtr const *i = stmts.begin(), *end = stmts.end(); i != end;
+         ++i) {
+        switch ((*i)->stmtKind) {
+        case BINDING: {
+            env2 = codegenBinding((Binding *)i->ptr(), env2, ctx);
+            break;
+        }
 
-                case ASSIGNMENT:
-                case VARIADIC_ASSIGNMENT:
-                case INIT_ASSIGNMENT:
-                case EXPR_STATEMENT: {
-                    bool terminated = codegenStatement(*i, env2, ctx);
-                    assert(!terminated);
-                    break;
-                }
+        case ASSIGNMENT:
+        case VARIADIC_ASSIGNMENT:
+        case INIT_ASSIGNMENT:
+        case EXPR_STATEMENT: {
+            bool terminated = codegenStatement(*i, env2, ctx);
+            assert(!terminated);
+            break;
+        }
 
-                default:
-                    assert(false);
-                    return nullptr;
-            }
+        default:
+            assert(false);
+            return nullptr;
         }
-        return env2;
     }
+    return env2;
+}
 
-    static size_t codegenBeginScope(StatementPtr scopeStmt, CodegenContext *ctx) {
-        if (llvmDIBuilder != nullptr) {
-            llvm::DILexicalBlock outerScope = ctx->getDebugScope();
-            unsigned line, column;
-            llvm::DIFile file = getDebugLineCol(scopeStmt->location, line, column);
-            ctx->pushDebugScope(llvmDIBuilder->createLexicalBlock(
-                outerScope,
-                file,
-                line,
-                column
-            ));
-        }
-        return cgMarkStack(ctx);
-    }
-
-    static void codegenEndScope(size_t marker, bool terminated, CodegenContext *ctx) {
-        if (!terminated)
-            cgDestroyStack(marker, ctx, false);
-        cgPopStack(marker, ctx);
-        if (llvmDIBuilder != nullptr)
-            ctx->popDebugScope();
-    }
-
-    bool codegenStatement(StatementPtr stmt,
-                          EnvPtr env,
-                          CodegenContext *ctx) {
-        if (llvmDIBuilder != nullptr)
-            DebugLocationContext loc(stmt->location, ctx);
-
-        switch (stmt->stmtKind) {
-            case BLOCK: {
-                Block *block = (Block *) stmt.ptr();
-                size_t blockMarker = codegenBeginScope(stmt, ctx);
-                codegenCollectLabels(block->statements, 0, ctx);
-                bool terminated = false;
-                for (unsigned i = 0; i < block->statements.size(); ++i) {
-                    codegenBlockStatement(block, i, block->statements[i], env, ctx, terminated);
-                }
-                codegenEndScope(blockMarker, terminated, ctx);
-                return terminated;
-            }
+static size_t codegenBeginScope(StatementPtr scopeStmt, CodegenContext *ctx) {
+    if (llvmDIBuilder != nullptr) {
+        llvm::DILexicalBlock outerScope = ctx->getDebugScope();
+        unsigned line, column;
+        llvm::DIFile file = getDebugLineCol(scopeStmt->location, line, column);
+        ctx->pushDebugScope(
+            llvmDIBuilder->createLexicalBlock(outerScope, file, line, column));
+    }
+    return cgMarkStack(ctx);
+}
 
-            case LABEL:
-                error("invalid label. labels can only appear within blocks");
+static void codegenEndScope(size_t marker, bool terminated,
+                            CodegenContext *ctx) {
+    if (!terminated)
+        cgDestroyStack(marker, ctx, false);
+    cgPopStack(marker, ctx);
+    if (llvmDIBuilder != nullptr)
+        ctx->popDebugScope();
+}
 
-            case BINDING:
-                error("invalid binding. bindings can only appear within blocks");
+bool codegenStatement(StatementPtr stmt, EnvPtr env, CodegenContext *ctx) {
+    if (llvmDIBuilder != nullptr)
+        DebugLocationContext loc(stmt->location, ctx);
+
+    switch (stmt->stmtKind) {
+    case BLOCK: {
+        Block *block = (Block *)stmt.ptr();
+        size_t blockMarker = codegenBeginScope(stmt, ctx);
+        codegenCollectLabels(block->statements, 0, ctx);
+        bool terminated = false;
+        for (unsigned i = 0; i < block->statements.size(); ++i) {
+            codegenBlockStatement(block, i, block->statements[i], env, ctx,
+                                  terminated);
+        }
+        codegenEndScope(blockMarker, terminated, ctx);
+        return terminated;
+    }
 
-            case ASSIGNMENT: {
-                Assignment *x = (Assignment *) stmt.ptr();
-                MultiPValuePtr mpvLeft = safeAnalyzeMulti(x->left, env, 0);
-                MultiPValuePtr mpvRight = safeAnalyzeMulti(x->right, env, mpvLeft->size());
-                if (mpvLeft->size() != mpvRight->size())
-                    arityMismatchError(mpvLeft->size(), mpvRight->size(), /*hasVarArg=*/false);
+    case LABEL:
+        error("invalid label. labels can only appear within blocks");
 
-                size_t tempMarker = markTemps(ctx);
-                size_t marker = cgMarkStack(ctx);
+    case BINDING:
+        error("invalid binding. bindings can only appear within blocks");
 
-                MultiPValuePtr mpvRight2;
-                MultiCValuePtr mcvRight;
-                if (mpvRight->size() == 1) {
-                    mcvRight = codegenMultiAsRef(x->right, env, ctx);
-                    mpvRight2 = mpvRight;
-                } else {
-                    mpvRight2 = new MultiPValue();
-                    mcvRight = new MultiCValue();
-                    for (unsigned i = 0; i < mpvRight->size(); ++i) {
-                        PVData const &pv = mpvRight->values[i];
-                        PVData pv2(pv.type, true);
-                        mpvRight2->add(pv2);
-                        CValuePtr cv = codegenAllocValue(pv.type, ctx);
-                        mcvRight->add(cv);
-                    }
-                    codegenMultiInto(x->right, env, ctx, mcvRight, mpvLeft->size());
-                    for (unsigned i = 0; i < mcvRight->size(); ++i)
-                        cgPushStackValue(mcvRight->values[i], ctx);
-                }
-                unsigned j = 0;
-                for (unsigned i = 0; i < x->left->size(); ++i) {
-                    ExprPtr leftExpr = x->left->exprs[i];
-                    if (leftExpr->exprKind == UNPACK) {
-                        ExprListPtr leftExprList = new ExprList();
-                        leftExprList->add(leftExpr);
-                        MultiPValuePtr mpvLeftI = safeAnalyzeMulti(leftExprList, env, 0);
-                        MultiPValuePtr mpvRightI = new MultiPValue();
-                        MultiCValuePtr mcvRightI = new MultiCValue();
-                        for (unsigned k = 0; k < mpvLeftI->size(); ++k) {
-                            mpvRightI->add(mpvRight2->values[j + k]);
-                            mcvRightI->add(mcvRight->values[j + k]);
-                        }
-                        codegenMultiExprAssign(
-                            leftExprList, mcvRightI, mpvRightI, env, ctx
-                        );
-                        j += unsigned(mpvLeftI->size());
-                    } else {
-                        codegenExprAssign(
-                            leftExpr, mcvRight->values[j], mpvRight2->values[j],
-                            env, ctx
-                        );
-                        j += 1;
-                    }
-                }
-                assert(j == mpvRight2->size());
+    case ASSIGNMENT: {
+        Assignment *x = (Assignment *)stmt.ptr();
+        MultiPValuePtr mpvLeft = safeAnalyzeMulti(x->left, env, 0);
+        MultiPValuePtr mpvRight =
+            safeAnalyzeMulti(x->right, env, mpvLeft->size());
+        if (mpvLeft->size() != mpvRight->size())
+            arityMismatchError(mpvLeft->size(), mpvRight->size(),
+                               /*hasVarArg=*/false);
 
-                cgDestroyAndPopStack(marker, ctx, false);
-                clearTemps(tempMarker, ctx);
-                return false;
-            }
+        size_t tempMarker = markTemps(ctx);
+        size_t marker = cgMarkStack(ctx);
 
-            case INIT_ASSIGNMENT: {
-                InitAssignment *x = (InitAssignment *) stmt.ptr();
-                MultiPValuePtr mpvLeft = safeAnalyzeMulti(x->left, env, 0);
-                MultiPValuePtr mpvRight = safeAnalyzeMulti(x->right, env, mpvLeft->size());
-                if (mpvLeft->size() != mpvRight->size())
-                    arityMismatchError(mpvLeft->size(), mpvRight->size(), /*hasVarArg=*/false);
-                for (unsigned i = 0; i < mpvLeft->size(); ++i) {
-                    if (mpvLeft->values[i].isRValue)
-                        argumentError(i, "cannot assign to a temporary");
-                    if (mpvLeft->values[i].type != mpvRight->values[i].type) {
-                        argumentTypeError(i,
-                                          mpvLeft->values[i].type,
-                                          mpvRight->values[i].type);
-                    }
+        MultiPValuePtr mpvRight2;
+        MultiCValuePtr mcvRight;
+        if (mpvRight->size() == 1) {
+            mcvRight = codegenMultiAsRef(x->right, env, ctx);
+            mpvRight2 = mpvRight;
+        } else {
+            mpvRight2 = new MultiPValue();
+            mcvRight = new MultiCValue();
+            for (unsigned i = 0; i < mpvRight->size(); ++i) {
+                PVData const &pv = mpvRight->values[i];
+                PVData pv2(pv.type, true);
+                mpvRight2->add(pv2);
+                CValuePtr cv = codegenAllocValue(pv.type, ctx);
+                mcvRight->add(cv);
+            }
+            codegenMultiInto(x->right, env, ctx, mcvRight, mpvLeft->size());
+            for (unsigned i = 0; i < mcvRight->size(); ++i)
+                cgPushStackValue(mcvRight->values[i], ctx);
+        }
+        unsigned j = 0;
+        for (unsigned i = 0; i < x->left->size(); ++i) {
+            ExprPtr leftExpr = x->left->exprs[i];
+            if (leftExpr->exprKind == UNPACK) {
+                ExprListPtr leftExprList = new ExprList();
+                leftExprList->add(leftExpr);
+                MultiPValuePtr mpvLeftI =
+                    safeAnalyzeMulti(leftExprList, env, 0);
+                MultiPValuePtr mpvRightI = new MultiPValue();
+                MultiCValuePtr mcvRightI = new MultiCValue();
+                for (unsigned k = 0; k < mpvLeftI->size(); ++k) {
+                    mpvRightI->add(mpvRight2->values[j + k]);
+                    mcvRightI->add(mcvRight->values[j + k]);
                 }
-                size_t tempMarker = markTemps(ctx);
-                size_t marker = cgMarkStack(ctx);
-                MultiCValuePtr mcvLeft = codegenMultiAsRef(x->left, env, ctx);
-                codegenMultiInto(x->right, env, ctx, mcvLeft, mpvLeft->size());
-                cgDestroyAndPopStack(marker, ctx, false);
-                clearTemps(tempMarker, ctx);
-                return false;
+                codegenMultiExprAssign(leftExprList, mcvRightI, mpvRightI, env,
+                                       ctx);
+                j += unsigned(mpvLeftI->size());
+            } else {
+                codegenExprAssign(leftExpr, mcvRight->values[j],
+                                  mpvRight2->values[j], env, ctx);
+                j += 1;
             }
+        }
+        assert(j == mpvRight2->size());
 
-            case VARIADIC_ASSIGNMENT: {
-                VariadicAssignment *x = (VariadicAssignment *) stmt.ptr();
-                PVData pvLeft = safeAnalyzeOne(x->exprs->exprs[1], env);
-                if (x->exprs->exprs[1]->exprKind == INDEXING) {
-                    Indexing *y = (Indexing *) x->exprs->exprs[1].ptr();
-                    PVData pvIndexable = safeAnalyzeOne(y->expr, env);
-                    if (pvIndexable.type->typeKind != STATIC_TYPE) {
-                        CallPtr call = new Call(
-                            operator_expr_indexUpdateAssign(), new ExprList()
-                        );
-                        call->parenArgs->add(x->exprs->exprs[0]);
-                        call->parenArgs->add(y->expr);
-                        call->parenArgs->add(y->args);
-                        call->parenArgs->exprs.insert(call->parenArgs->exprs.end(), x->exprs->exprs.begin() + 2,
-                                                      x->exprs->exprs.end());
-                        return codegenStatement(new ExprStatement(call.ptr()), env, ctx);
-                    }
-                } else if (x->exprs->exprs[1]->exprKind == STATIC_INDEXING) {
-                    StaticIndexing *y = (StaticIndexing *) x->exprs->exprs[1].ptr();
-                    CallPtr call = new Call(
-                        operator_expr_staticIndexUpdateAssign(), new ExprList()
-                    );
-                    call->parenArgs->add(x->exprs->exprs[0]);
-                    call->parenArgs->add(y->expr);
-                    ValueHolderPtr vh = sizeTToValueHolder(y->index);
-                    call->parenArgs->add(new StaticExpr(new ObjectExpr(vh.ptr())));
-                    call->parenArgs->exprs.insert(call->parenArgs->exprs.end(), x->exprs->exprs.begin() + 2,
-                                                  x->exprs->exprs.end());
-                    return codegenStatement(new ExprStatement(call.ptr()), env, ctx);
-                } else if (x->exprs->exprs[1]->exprKind == FIELD_REF) {
-                    FieldRef *y = (FieldRef *) x->exprs->exprs[1].ptr();
-                    PVData pvBase = safeAnalyzeOne(y->expr, env);
-                    if (pvBase.type->typeKind != STATIC_TYPE) {
-                        CallPtr call = new Call(
-                            operator_expr_fieldRefUpdateAssign(), new ExprList()
-                        );
-                        call->parenArgs->add(x->exprs->exprs[0]);
-                        call->parenArgs->add(y->expr);
-                        call->parenArgs->add(new ObjectExpr(y->name.ptr()));
-                        call->parenArgs->exprs.insert(call->parenArgs->exprs.end(), x->exprs->exprs.begin() + 2,
-                                                      x->exprs->exprs.end());
-                        return codegenStatement(new ExprStatement(call.ptr()), env, ctx);
-                    }
-                }
-                CallPtr call;
-                if (x->op == PREFIX_OP)
-                    call = new Call(operator_expr_prefixUpdateAssign(), x->exprs);
-                else
-                    call = new Call(operator_expr_updateAssign(), x->exprs);
-                return codegenStatement(new ExprStatement(call.ptr()), env, ctx);
-            }
+        cgDestroyAndPopStack(marker, ctx, false);
+        clearTemps(tempMarker, ctx);
+        return false;
+    }
 
-            case GOTO: {
-                Goto *x = (Goto *) stmt.ptr();
-                llvm::StringMap<JumpTarget>::iterator li =
-                        ctx->labels.find(x->labelName->str);
-                if (li == ctx->labels.end()) {
-                    string buf;
-                    llvm::raw_string_ostream sout(buf);
-                    sout << "goto label not found: " << x->labelName->str;
-                    error(sout.str());
-                }
-                JumpTarget &jt = li->second;
-                cgDestroyStack(jt.stackMarker, ctx, false);
-                ctx->builder->CreateBr(jt.block);
-                ++jt.useCount;
-                return true;
+    case INIT_ASSIGNMENT: {
+        InitAssignment *x = (InitAssignment *)stmt.ptr();
+        MultiPValuePtr mpvLeft = safeAnalyzeMulti(x->left, env, 0);
+        MultiPValuePtr mpvRight =
+            safeAnalyzeMulti(x->right, env, mpvLeft->size());
+        if (mpvLeft->size() != mpvRight->size())
+            arityMismatchError(mpvLeft->size(), mpvRight->size(),
+                               /*hasVarArg=*/false);
+        for (unsigned i = 0; i < mpvLeft->size(); ++i) {
+            if (mpvLeft->values[i].isRValue)
+                argumentError(i, "cannot assign to a temporary");
+            if (mpvLeft->values[i].type != mpvRight->values[i].type) {
+                argumentTypeError(i, mpvLeft->values[i].type,
+                                  mpvRight->values[i].type);
             }
+        }
+        size_t tempMarker = markTemps(ctx);
+        size_t marker = cgMarkStack(ctx);
+        MultiCValuePtr mcvLeft = codegenMultiAsRef(x->left, env, ctx);
+        codegenMultiInto(x->right, env, ctx, mcvLeft, mpvLeft->size());
+        cgDestroyAndPopStack(marker, ctx, false);
+        clearTemps(tempMarker, ctx);
+        return false;
+    }
 
-            case RETURN: {
-                Return *x = (Return *) stmt.ptr();
-                MultiPValuePtr mpv = safeAnalyzeMulti(x->values, env, 1);
-                MultiCValuePtr mcv = new MultiCValue();
-                llvm::ArrayRef<CReturn> returns = ctx->returnLists.back();
-                ensureArity(mpv, returns.size());
-                for (unsigned i = 0; i < mpv->size(); ++i) {
-                    PVData const &pv = mpv->values[i];
-                    bool byRef = returnKindToByRef(x->returnKind, pv);
-                    const CReturn &y = returns[i];
-                    if (y.type != pv.type)
-                        argumentTypeError(i, y.type, pv.type);
-                    if (byRef != y.byRef)
-                        argumentError(i, "mismatching by-ref and by-value returns");
-                    if (byRef && pv.isRValue)
-                        argumentError(i, "cannot return a temporary by reference");
-                    mcv->add(y.value);
-                }
-                switch (x->returnKind) {
-                    case RETURN_VALUE:
-                        codegenMultiInto(x->values, env, ctx, mcv, 1);
-                        break;
-                    case RETURN_REF: {
-                        MultiCValuePtr mcvRef = codegenMultiAsRef(x->values, env, ctx);
-                        assert(mcv->size() == mcvRef->size());
-                        for (size_t i = 0; i < mcv->size(); ++i) {
-                            CValuePtr cvPtr = mcv->values[i];
-                            CValuePtr cvRef = mcvRef->values[i];
-                            ctx->builder->CreateStore(cvRef->llValue, cvPtr->llValue);
-                        }
-                        break;
-                    }
-                    case RETURN_FORWARD:
-                        codegenMulti(x->values, env, ctx, mcv, 1);
-                        break;
-                    default:
-                        assert(false);
-                }
-                JumpTarget *jt = &ctx->returnTargets.back();
-                cgDestroyStack(jt->stackMarker, ctx, false);
-                // jt might be invalidated at this point
-                jt = &ctx->returnTargets.back();
-                ctx->builder->CreateBr(jt->block);
-                ++jt->useCount;
-                return true;
+    case VARIADIC_ASSIGNMENT: {
+        VariadicAssignment *x = (VariadicAssignment *)stmt.ptr();
+        PVData pvLeft = safeAnalyzeOne(x->exprs->exprs[1], env);
+        if (x->exprs->exprs[1]->exprKind == INDEXING) {
+            Indexing *y = (Indexing *)x->exprs->exprs[1].ptr();
+            PVData pvIndexable = safeAnalyzeOne(y->expr, env);
+            if (pvIndexable.type->typeKind != STATIC_TYPE) {
+                CallPtr call =
+                    new Call(operator_expr_indexUpdateAssign(), new ExprList());
+                call->parenArgs->add(x->exprs->exprs[0]);
+                call->parenArgs->add(y->expr);
+                call->parenArgs->add(y->args);
+                call->parenArgs->exprs.insert(call->parenArgs->exprs.end(),
+                                              x->exprs->exprs.begin() + 2,
+                                              x->exprs->exprs.end());
+                return codegenStatement(new ExprStatement(call.ptr()), env,
+                                        ctx);
+            }
+        } else if (x->exprs->exprs[1]->exprKind == STATIC_INDEXING) {
+            StaticIndexing *y = (StaticIndexing *)x->exprs->exprs[1].ptr();
+            CallPtr call = new Call(operator_expr_staticIndexUpdateAssign(),
+                                    new ExprList());
+            call->parenArgs->add(x->exprs->exprs[0]);
+            call->parenArgs->add(y->expr);
+            ValueHolderPtr vh = sizeTToValueHolder(y->index);
+            call->parenArgs->add(new StaticExpr(new ObjectExpr(vh.ptr())));
+            call->parenArgs->exprs.insert(call->parenArgs->exprs.end(),
+                                          x->exprs->exprs.begin() + 2,
+                                          x->exprs->exprs.end());
+            return codegenStatement(new ExprStatement(call.ptr()), env, ctx);
+        } else if (x->exprs->exprs[1]->exprKind == FIELD_REF) {
+            FieldRef *y = (FieldRef *)x->exprs->exprs[1].ptr();
+            PVData pvBase = safeAnalyzeOne(y->expr, env);
+            if (pvBase.type->typeKind != STATIC_TYPE) {
+                CallPtr call = new Call(operator_expr_fieldRefUpdateAssign(),
+                                        new ExprList());
+                call->parenArgs->add(x->exprs->exprs[0]);
+                call->parenArgs->add(y->expr);
+                call->parenArgs->add(new ObjectExpr(y->name.ptr()));
+                call->parenArgs->exprs.insert(call->parenArgs->exprs.end(),
+                                              x->exprs->exprs.begin() + 2,
+                                              x->exprs->exprs.end());
+                return codegenStatement(new ExprStatement(call.ptr()), env,
+                                        ctx);
             }
+        }
+        CallPtr call;
+        if (x->op == PREFIX_OP)
+            call = new Call(operator_expr_prefixUpdateAssign(), x->exprs);
+        else
+            call = new Call(operator_expr_updateAssign(), x->exprs);
+        return codegenStatement(new ExprStatement(call.ptr()), env, ctx);
+    }
 
-            case IF: {
-                If *x = (If *) stmt.ptr();
-
-                size_t scopeMarker = codegenBeginScope(stmt, ctx);
-                EnvPtr env2 = codegenStatementExpressionStatements(x->conditionStatements, env, ctx);
+    case GOTO: {
+        Goto *x = (Goto *)stmt.ptr();
+        llvm::StringMap<JumpTarget>::iterator li =
+            ctx->labels.find(x->labelName->str);
+        if (li == ctx->labels.end()) {
+            string buf;
+            llvm::raw_string_ostream sout(buf);
+            sout << "goto label not found: " << x->labelName->str;
+            error(sout.str());
+        }
+        JumpTarget &jt = li->second;
+        cgDestroyStack(jt.stackMarker, ctx, false);
+        ctx->builder->CreateBr(jt.block);
+        ++jt.useCount;
+        return true;
+    }
 
-                size_t tempMarker = markTemps(ctx);
-                size_t marker = cgMarkStack(ctx);
-                CValuePtr cv = codegenOneAsRef(x->condition, env2, ctx);
-                BoolKind condBoolKind = typeBoolKind(cv->type);
-                cgDestroyAndPopStack(marker, ctx, false);
-                clearTemps(tempMarker, ctx);
+    case RETURN: {
+        Return *x = (Return *)stmt.ptr();
+        MultiPValuePtr mpv = safeAnalyzeMulti(x->values, env, 1);
+        MultiCValuePtr mcv = new MultiCValue();
+        llvm::ArrayRef<CReturn> returns = ctx->returnLists.back();
+        ensureArity(mpv, returns.size());
+        for (unsigned i = 0; i < mpv->size(); ++i) {
+            PVData const &pv = mpv->values[i];
+            bool byRef = returnKindToByRef(x->returnKind, pv);
+            const CReturn &y = returns[i];
+            if (y.type != pv.type)
+                argumentTypeError(i, y.type, pv.type);
+            if (byRef != y.byRef)
+                argumentError(i, "mismatching by-ref and by-value returns");
+            if (byRef && pv.isRValue)
+                argumentError(i, "cannot return a temporary by reference");
+            mcv->add(y.value);
+        }
+        switch (x->returnKind) {
+        case RETURN_VALUE:
+            codegenMultiInto(x->values, env, ctx, mcv, 1);
+            break;
+        case RETURN_REF: {
+            MultiCValuePtr mcvRef = codegenMultiAsRef(x->values, env, ctx);
+            assert(mcv->size() == mcvRef->size());
+            for (size_t i = 0; i < mcv->size(); ++i) {
+                CValuePtr cvPtr = mcv->values[i];
+                CValuePtr cvRef = mcvRef->values[i];
+                ctx->builder->CreateStore(cvRef->llValue, cvPtr->llValue);
+            }
+            break;
+        }
+        case RETURN_FORWARD:
+            codegenMulti(x->values, env, ctx, mcv, 1);
+            break;
+        default:
+            assert(false);
+        }
+        JumpTarget *jt = &ctx->returnTargets.back();
+        cgDestroyStack(jt->stackMarker, ctx, false);
+        // jt might be invalidated at this point
+        jt = &ctx->returnTargets.back();
+        ctx->builder->CreateBr(jt->block);
+        ++jt->useCount;
+        return true;
+    }
 
-                llvm::BasicBlock *trueBlock = nullptr;
-                llvm::BasicBlock *falseBlock = nullptr;
-                llvm::BasicBlock *mergeBlock = nullptr;
-                if (condBoolKind == BOOL_EXPR || condBoolKind == BOOL_STATIC_TRUE) {
-                    trueBlock = newBasicBlock("ifTrue", ctx);
-                }
-                if (condBoolKind == BOOL_EXPR || condBoolKind == BOOL_STATIC_FALSE) {
-                    falseBlock = newBasicBlock("ifFalse", ctx);
-                }
+    case IF: {
+        If *x = (If *)stmt.ptr();
 
-                if (condBoolKind == BOOL_EXPR) {
-                    llvm::Value *cond = codegenToBoolFlag(cv, ctx);
-                    ctx->builder->CreateCondBr(cond, trueBlock, falseBlock);
-                } else {
-                    ctx->builder->CreateBr(condBoolKind == BOOL_STATIC_TRUE ? trueBlock : falseBlock);
-                }
+        size_t scopeMarker = codegenBeginScope(stmt, ctx);
+        EnvPtr env2 = codegenStatementExpressionStatements(
+            x->conditionStatements, env, ctx);
 
-                bool terminated1 = false;
-                bool terminated2 = false;
+        size_t tempMarker = markTemps(ctx);
+        size_t marker = cgMarkStack(ctx);
+        CValuePtr cv = codegenOneAsRef(x->condition, env2, ctx);
+        BoolKind condBoolKind = typeBoolKind(cv->type);
+        cgDestroyAndPopStack(marker, ctx, false);
+        clearTemps(tempMarker, ctx);
 
-                if (condBoolKind == BOOL_EXPR || condBoolKind == BOOL_STATIC_TRUE) {
-                    ctx->builder->SetInsertPoint(trueBlock);
-                    terminated1 = codegenStatement(x->thenPart, env2, ctx);
-                    if (!terminated1) {
-                        if (!mergeBlock)
-                            mergeBlock = newBasicBlock("ifMerge", ctx);
-                        ctx->builder->CreateBr(mergeBlock);
-                    }
-                } else {
-                    terminated1 = true;
-                }
+        llvm::BasicBlock *trueBlock = nullptr;
+        llvm::BasicBlock *falseBlock = nullptr;
+        llvm::BasicBlock *mergeBlock = nullptr;
+        if (condBoolKind == BOOL_EXPR || condBoolKind == BOOL_STATIC_TRUE) {
+            trueBlock = newBasicBlock("ifTrue", ctx);
+        }
+        if (condBoolKind == BOOL_EXPR || condBoolKind == BOOL_STATIC_FALSE) {
+            falseBlock = newBasicBlock("ifFalse", ctx);
+        }
 
-                if (condBoolKind == BOOL_EXPR || condBoolKind == BOOL_STATIC_FALSE) {
-                    ctx->builder->SetInsertPoint(falseBlock);
-                    if (x->elsePart.ptr())
-                        terminated2 = codegenStatement(x->elsePart, env2, ctx);
-                    if (!terminated2) {
-                        if (!mergeBlock)
-                            mergeBlock = newBasicBlock("ifMerge", ctx);
-                        ctx->builder->CreateBr(mergeBlock);
-                    }
-                } else {
-                    terminated2 = true;
-                }
+        if (condBoolKind == BOOL_EXPR) {
+            llvm::Value *cond = codegenToBoolFlag(cv, ctx);
+            ctx->builder->CreateCondBr(cond, trueBlock, falseBlock);
+        } else {
+            ctx->builder->CreateBr(
+                condBoolKind == BOOL_STATIC_TRUE ? trueBlock : falseBlock);
+        }
 
-                if (!terminated1 || !terminated2)
-                    ctx->builder->SetInsertPoint(mergeBlock);
+        bool terminated1 = false;
+        bool terminated2 = false;
 
-                codegenEndScope(scopeMarker, terminated1 && terminated2, ctx);
+        if (condBoolKind == BOOL_EXPR || condBoolKind == BOOL_STATIC_TRUE) {
+            ctx->builder->SetInsertPoint(trueBlock);
+            terminated1 = codegenStatement(x->thenPart, env2, ctx);
+            if (!terminated1) {
+                if (!mergeBlock)
+                    mergeBlock = newBasicBlock("ifMerge", ctx);
+                ctx->builder->CreateBr(mergeBlock);
+            }
+        } else {
+            terminated1 = true;
+        }
 
-                return terminated1 && terminated2;
+        if (condBoolKind == BOOL_EXPR || condBoolKind == BOOL_STATIC_FALSE) {
+            ctx->builder->SetInsertPoint(falseBlock);
+            if (x->elsePart.ptr())
+                terminated2 = codegenStatement(x->elsePart, env2, ctx);
+            if (!terminated2) {
+                if (!mergeBlock)
+                    mergeBlock = newBasicBlock("ifMerge", ctx);
+                ctx->builder->CreateBr(mergeBlock);
             }
+        } else {
+            terminated2 = true;
+        }
 
-            case SWITCH: {
-                Switch *x = (Switch *) stmt.ptr();
-                if (!x->desugared)
-                    x->desugared = desugarSwitchStatement(x);
-                return codegenStatement(x->desugared, env, ctx);
-            }
+        if (!terminated1 || !terminated2)
+            ctx->builder->SetInsertPoint(mergeBlock);
 
-            case EVAL_STATEMENT: {
-                EvalStatement *eval = (EvalStatement *) stmt.ptr();
-                llvm::ArrayRef<StatementPtr> evaled = desugarEvalStatement(eval, env);
-                bool terminated = false;
-                for (size_t i = 0; i < evaled.size(); ++i) {
-                    if (terminated)
-                        error(evaled[i], "unreachable code");
-                    terminated = codegenStatement(evaled[i], env, ctx);
-                }
-                return terminated;
-            }
+        codegenEndScope(scopeMarker, terminated1 && terminated2, ctx);
 
-            case EXPR_STATEMENT: {
-                ExprStatement *x = (ExprStatement *) stmt.ptr();
-                size_t tempMarker = markTemps(ctx);
-                size_t marker = cgMarkStack(ctx);
-                codegenExprAsRef(x->expr, env, ctx);
-                cgDestroyAndPopStack(marker, ctx, false);
-                clearTemps(tempMarker, ctx);
-                return false;
-            }
+        return terminated1 && terminated2;
+    }
 
-            case WHILE: {
-                While *x = (While *) stmt.ptr();
+    case SWITCH: {
+        Switch *x = (Switch *)stmt.ptr();
+        if (!x->desugared)
+            x->desugared = desugarSwitchStatement(x);
+        return codegenStatement(x->desugared, env, ctx);
+    }
 
-                llvm::BasicBlock *whileBegin = newBasicBlock("whileBegin", ctx);
-                llvm::BasicBlock *whileBody = newBasicBlock("whileBody", ctx);
-                llvm::BasicBlock *whileContinue = newBasicBlock("whileContinue", ctx);
-                llvm::BasicBlock *whileEnd = newBasicBlock("whileEnd", ctx);
+    case EVAL_STATEMENT: {
+        EvalStatement *eval = (EvalStatement *)stmt.ptr();
+        llvm::ArrayRef<StatementPtr> evaled = desugarEvalStatement(eval, env);
+        bool terminated = false;
+        for (size_t i = 0; i < evaled.size(); ++i) {
+            if (terminated)
+                error(evaled[i], "unreachable code");
+            terminated = codegenStatement(evaled[i], env, ctx);
+        }
+        return terminated;
+    }
 
-                ctx->builder->CreateBr(whileBegin);
-                ctx->builder->SetInsertPoint(whileBegin);
+    case EXPR_STATEMENT: {
+        ExprStatement *x = (ExprStatement *)stmt.ptr();
+        size_t tempMarker = markTemps(ctx);
+        size_t marker = cgMarkStack(ctx);
+        codegenExprAsRef(x->expr, env, ctx);
+        cgDestroyAndPopStack(marker, ctx, false);
+        clearTemps(tempMarker, ctx);
+        return false;
+    }
 
-                size_t scopeMarker = codegenBeginScope(stmt, ctx);
-                EnvPtr env2 = codegenStatementExpressionStatements(x->conditionStatements, env, ctx);
+    case WHILE: {
+        While *x = (While *)stmt.ptr();
 
-                size_t tempMarker = markTemps(ctx);
-                size_t marker = cgMarkStack(ctx);
-                CValuePtr cv = codegenOneAsRef(x->condition, env2, ctx);
-                llvm::Value *cond = codegenToBoolFlag(cv, ctx);
-                cgDestroyAndPopStack(marker, ctx, false);
-                clearTemps(tempMarker, ctx);
+        llvm::BasicBlock *whileBegin = newBasicBlock("whileBegin", ctx);
+        llvm::BasicBlock *whileBody = newBasicBlock("whileBody", ctx);
+        llvm::BasicBlock *whileContinue = newBasicBlock("whileContinue", ctx);
+        llvm::BasicBlock *whileEnd = newBasicBlock("whileEnd", ctx);
 
-                ctx->builder->CreateCondBr(cond, whileBody, whileEnd);
+        ctx->builder->CreateBr(whileBegin);
+        ctx->builder->SetInsertPoint(whileBegin);
 
-                ctx->breaks.push_back(JumpTarget(whileEnd, cgMarkStack(ctx)));
-                ctx->continues.push_back(JumpTarget(whileContinue, cgMarkStack(ctx)));
-                ctx->builder->SetInsertPoint(whileBody);
-                bool terminated = codegenStatement(x->body, env2, ctx);
-                if (!terminated) {
-                    ctx->builder->CreateBr(whileContinue);
-                }
-                ctx->builder->SetInsertPoint(whileContinue);
-                cgDestroyStack(scopeMarker, ctx, false);
-                ctx->builder->CreateBr(whileBegin);
-
-                bool breakUsed = (ctx->breaks.back().useCount > 0);
-                ctx->breaks.pop_back();
-                ctx->continues.pop_back();
-                ctx->builder->SetInsertPoint(whileEnd);
-
-                if (!breakUsed && (x->condition->exprKind == BOOL_LITERAL)) {
-                    BoolLiteral *y = (BoolLiteral *) x->condition.ptr();
-                    if (y->value) {
-                        // it's a "while (true)" loop with no 'break'
-                        ctx->builder->CreateUnreachable();
-                        codegenEndScope(scopeMarker, true, ctx);
-                        return true;
-                    }
-                }
+        size_t scopeMarker = codegenBeginScope(stmt, ctx);
+        EnvPtr env2 = codegenStatementExpressionStatements(
+            x->conditionStatements, env, ctx);
 
-                codegenEndScope(scopeMarker, false, ctx);
-                return false;
-            }
+        size_t tempMarker = markTemps(ctx);
+        size_t marker = cgMarkStack(ctx);
+        CValuePtr cv = codegenOneAsRef(x->condition, env2, ctx);
+        llvm::Value *cond = codegenToBoolFlag(cv, ctx);
+        cgDestroyAndPopStack(marker, ctx, false);
+        clearTemps(tempMarker, ctx);
 
-            case BREAK: {
-                if (ctx->breaks.empty())
-                    error("invalid break statement");
-                JumpTarget *jt = &ctx->breaks.back();
-                cgDestroyStack(jt->stackMarker, ctx, false);
-                // jt might be invalidated at this point
-                jt = &ctx->breaks.back();
-                ctx->builder->CreateBr(jt->block);
-                ++jt->useCount;
-                return true;
-            }
+        ctx->builder->CreateCondBr(cond, whileBody, whileEnd);
 
-            case CONTINUE: {
-                if (ctx->continues.empty())
-                    error("invalid continue statement");
-                JumpTarget *jt = &ctx->continues.back();
-                cgDestroyStack(jt->stackMarker, ctx, false);
-                // jt might be invalidated at this point
-                jt = &ctx->continues.back();
-                ctx->builder->CreateBr(jt->block);
-                ++jt->useCount;
+        ctx->breaks.push_back(JumpTarget(whileEnd, cgMarkStack(ctx)));
+        ctx->continues.push_back(JumpTarget(whileContinue, cgMarkStack(ctx)));
+        ctx->builder->SetInsertPoint(whileBody);
+        bool terminated = codegenStatement(x->body, env2, ctx);
+        if (!terminated) {
+            ctx->builder->CreateBr(whileContinue);
+        }
+        ctx->builder->SetInsertPoint(whileContinue);
+        cgDestroyStack(scopeMarker, ctx, false);
+        ctx->builder->CreateBr(whileBegin);
+
+        bool breakUsed = (ctx->breaks.back().useCount > 0);
+        ctx->breaks.pop_back();
+        ctx->continues.pop_back();
+        ctx->builder->SetInsertPoint(whileEnd);
+
+        if (!breakUsed && (x->condition->exprKind == BOOL_LITERAL)) {
+            BoolLiteral *y = (BoolLiteral *)x->condition.ptr();
+            if (y->value) {
+                // it's a "while (true)" loop with no 'break'
+                ctx->builder->CreateUnreachable();
+                codegenEndScope(scopeMarker, true, ctx);
                 return true;
             }
+        }
 
-            case FOR: {
-                For *x = (For *) stmt.ptr();
-                if (!x->desugared)
-                    x->desugared = desugarForStatement(x);
-                return codegenStatement(x->desugared, env, ctx);
-            }
+        codegenEndScope(scopeMarker, false, ctx);
+        return false;
+    }
 
-            case FOREIGN_STATEMENT: {
-                ForeignStatement *x = (ForeignStatement *) stmt.ptr();
-                return codegenStatement(x->statement, x->getEnv(), ctx);
-            }
+    case BREAK: {
+        if (ctx->breaks.empty())
+            error("invalid break statement");
+        JumpTarget *jt = &ctx->breaks.back();
+        cgDestroyStack(jt->stackMarker, ctx, false);
+        // jt might be invalidated at this point
+        jt = &ctx->breaks.back();
+        ctx->builder->CreateBr(jt->block);
+        ++jt->useCount;
+        return true;
+    }
 
-            case TRY: {
-                Try *x = (Try *) stmt.ptr();
-                if (!exceptionsEnabled())
-                    return codegenStatement(x->tryBlock, env, ctx);
+    case CONTINUE: {
+        if (ctx->continues.empty())
+            error("invalid continue statement");
+        JumpTarget *jt = &ctx->continues.back();
+        cgDestroyStack(jt->stackMarker, ctx, false);
+        // jt might be invalidated at this point
+        jt = &ctx->continues.back();
+        ctx->builder->CreateBr(jt->block);
+        ++jt->useCount;
+        return true;
+    }
 
-                if (!x->desugaredCatchBlock)
-                    x->desugaredCatchBlock = desugarCatchBlocks(x->catchBlocks);
+    case FOR: {
+        For *x = (For *)stmt.ptr();
+        if (!x->desugared)
+            x->desugared = desugarForStatement(x);
+        return codegenStatement(x->desugared, env, ctx);
+    }
 
-                llvm::BasicBlock *catchBegin = newBasicBlock("catchBegin", ctx);
-                llvm::BasicBlock *catchEnd = nullptr;
+    case FOREIGN_STATEMENT: {
+        ForeignStatement *x = (ForeignStatement *)stmt.ptr();
+        return codegenStatement(x->statement, x->getEnv(), ctx);
+    }
 
-                JumpTarget exceptionTarget(catchBegin, cgMarkStack(ctx));
-                ctx->exceptionTargets.push_back(exceptionTarget);
-                bool tryTerminated = codegenStatement(x->tryBlock, env, ctx);
-                if (!tryTerminated) {
-                    if (!catchEnd)
-                        catchEnd = newBasicBlock("catchEnd", ctx);
-                    ctx->builder->CreateBr(catchEnd);
-                }
-                ctx->exceptionTargets.pop_back();
+    case TRY: {
+        Try *x = (Try *)stmt.ptr();
+        if (!exceptionsEnabled())
+            return codegenStatement(x->tryBlock, env, ctx);
 
-                ctx->builder->SetInsertPoint(catchBegin);
+        if (!x->desugaredCatchBlock)
+            x->desugaredCatchBlock = desugarCatchBlocks(x->catchBlocks);
 
-                EnvPtr catchEnv = new Env(env, true);
+        llvm::BasicBlock *catchBegin = newBasicBlock("catchBegin", ctx);
+        llvm::BasicBlock *catchEnd = nullptr;
 
-                bool catchTerminated =
-                        codegenStatement(x->desugaredCatchBlock, catchEnv, ctx);
-                if (!catchTerminated) {
-                    if (!catchEnd)
-                        catchEnd = newBasicBlock("catchEnd", ctx);
-                    ctx->builder->CreateBr(catchEnd);
-                }
+        JumpTarget exceptionTarget(catchBegin, cgMarkStack(ctx));
+        ctx->exceptionTargets.push_back(exceptionTarget);
+        bool tryTerminated = codegenStatement(x->tryBlock, env, ctx);
+        if (!tryTerminated) {
+            if (!catchEnd)
+                catchEnd = newBasicBlock("catchEnd", ctx);
+            ctx->builder->CreateBr(catchEnd);
+        }
+        ctx->exceptionTargets.pop_back();
 
-                if (catchEnd)
-                    ctx->builder->SetInsertPoint(catchEnd);
+        ctx->builder->SetInsertPoint(catchBegin);
 
-                return tryTerminated && catchTerminated;
-            }
+        EnvPtr catchEnv = new Env(env, true);
 
-            case THROW: {
-                Throw *x = (Throw *) stmt.ptr();
-
-                if (!x->expr && !lookupExceptionAvailable(env.ptr()))
-                    error("rethrow statement can be used only from within catch block");
-
-                desugarThrow(x);
-                ExprPtr callable = operator_expr_throwValue();
-                callable->location = stmt->location;
-                ExprListPtr args = new ExprList();
-                args->exprs.push_back(x->desugaredExpr);
-                if (x->desugaredContext != nullptr)
-                    args->exprs.push_back(x->desugaredContext);
-
-                size_t tempMarker = markTemps(ctx);
-                size_t marker = cgMarkStack(ctx);
-                codegenCallExpr(callable, args, env, ctx, new MultiCValue());
-                cgDestroyAndPopStack(marker, ctx, false);
-                clearTemps(tempMarker, ctx);
-                ctx->builder->CreateUnreachable();
-                return true;
-            }
+        bool catchTerminated =
+            codegenStatement(x->desugaredCatchBlock, catchEnv, ctx);
+        if (!catchTerminated) {
+            if (!catchEnd)
+                catchEnd = newBasicBlock("catchEnd", ctx);
+            ctx->builder->CreateBr(catchEnd);
+        }
 
-            case STATIC_FOR: {
-                StaticFor *x = (StaticFor *) stmt.ptr();
-                MultiCValuePtr mcv = codegenForwardMultiAsRef(x->values, env, ctx);
-                initializeStaticForClones(x, mcv->size());
-                bool terminated = false;
-                for (size_t i = 0; i < mcv->size(); ++i) {
-                    if (terminated) {
-                        string buf;
-                        llvm::raw_string_ostream ostr(buf);
-                        ostr << "unreachable code in iteration " << (i + 1);
-                        error(ostr.str());
-                    }
-                    EnvPtr env2 = new Env(env);
-                    addLocal(env2, x->variable, mcv->values[i].ptr());
-                    terminated = codegenStatement(x->clonedBodies[i], env2, ctx);
-                }
-                return terminated;
-            }
+        if (catchEnd)
+            ctx->builder->SetInsertPoint(catchEnd);
 
-            case FINALLY: {
-                Finally *x = (Finally *) stmt.ptr();
-                cgPushStackStatement(FINALLY_STATEMENT, env, x->body, ctx);
-                return false;
-            }
+        return tryTerminated && catchTerminated;
+    }
 
-            case ONERROR: {
-                OnError *x = (OnError *) stmt.ptr();
-                cgPushStackStatement(ONERROR_STATEMENT, env, x->body, ctx);
-                return false;
-            }
+    case THROW: {
+        Throw *x = (Throw *)stmt.ptr();
 
-            case UNREACHABLE: {
-                ctx->builder->CreateUnreachable();
-                return true;
-            }
+        if (!x->expr && !lookupExceptionAvailable(env.ptr()))
+            error("rethrow statement can be used only from within catch block");
 
-            case STATIC_ASSERT_STATEMENT: {
-                StaticAssertStatement *x = (StaticAssertStatement *) stmt.ptr();
-                evaluateStaticAssert(x->location, x->cond, x->message, env);
-                return false;
-            }
+        desugarThrow(x);
+        ExprPtr callable = operator_expr_throwValue();
+        callable->location = stmt->location;
+        ExprListPtr args = new ExprList();
+        args->exprs.push_back(x->desugaredExpr);
+        if (x->desugaredContext != nullptr)
+            args->exprs.push_back(x->desugaredContext);
 
-            default:
-                assert(false);
-                return false;
-        }
+        size_t tempMarker = markTemps(ctx);
+        size_t marker = cgMarkStack(ctx);
+        codegenCallExpr(callable, args, env, ctx, new MultiCValue());
+        cgDestroyAndPopStack(marker, ctx, false);
+        clearTemps(tempMarker, ctx);
+        ctx->builder->CreateUnreachable();
+        return true;
     }
 
-    //
-    // codegenCollectLabels
-    //
-
-    void codegenCollectLabels(llvm::ArrayRef<StatementPtr> statements,
-                              unsigned startIndex,
-                              CodegenContext *ctx) {
-        for (size_t i = startIndex; i < statements.size(); ++i) {
-            StatementPtr x = statements[i];
-            switch (x->stmtKind) {
-                case LABEL: {
-                    Label *y = (Label *) x.ptr();
-                    llvm::StringMap<JumpTarget>::iterator li =
-                            ctx->labels.find(y->name->str);
-                    if (li != ctx->labels.end())
-                        error(x, "label redefined");
-                    llvm::BasicBlock *bb = newBasicBlock(y->name->str, ctx);
-                    ctx->labels[y->name->str] = JumpTarget(bb, cgMarkStack(ctx));
-                    break;
-                }
-                case BINDING:
-                    return;
-                default:
-                    break;
+    case STATIC_FOR: {
+        StaticFor *x = (StaticFor *)stmt.ptr();
+        MultiCValuePtr mcv = codegenForwardMultiAsRef(x->values, env, ctx);
+        initializeStaticForClones(x, mcv->size());
+        bool terminated = false;
+        for (size_t i = 0; i < mcv->size(); ++i) {
+            if (terminated) {
+                string buf;
+                llvm::raw_string_ostream ostr(buf);
+                ostr << "unreachable code in iteration " << (i + 1);
+                error(ostr.str());
             }
+            EnvPtr env2 = new Env(env);
+            addLocal(env2, x->variable, mcv->values[i].ptr());
+            terminated = codegenStatement(x->clonedBodies[i], env2, ctx);
         }
+        return terminated;
+    }
+
+    case FINALLY: {
+        Finally *x = (Finally *)stmt.ptr();
+        cgPushStackStatement(FINALLY_STATEMENT, env, x->body, ctx);
+        return false;
+    }
+
+    case ONERROR: {
+        OnError *x = (OnError *)stmt.ptr();
+        cgPushStackStatement(ONERROR_STATEMENT, env, x->body, ctx);
+        return false;
     }
 
-    //
-    // codegenBinding
-    //
+    case UNREACHABLE: {
+        ctx->builder->CreateUnreachable();
+        return true;
+    }
 
-    llvm::SmallString<16> getBindingVariableName(BindingPtr x, unsigned i) {
-        if (i >= x->args.size()) {
-            assert(x->hasVarArg);
+    case STATIC_ASSERT_STATEMENT: {
+        StaticAssertStatement *x = (StaticAssertStatement *)stmt.ptr();
+        evaluateStaticAssert(x->location, x->cond, x->message, env);
+        return false;
+    }
 
-            llvm::SmallString<16> buf;
-            llvm::raw_svector_ostream ostr(buf);
-            ostr << x->args.back()->name->str << "_" << (i - x->args.size() + 1);
-            return ostr.str();
-        } else {
-            return x->args[i]->name->str;
-        }
+    default:
+        assert(false);
+        return false;
     }
+}
 
-    EnvPtr codegenBinding(BindingPtr x, EnvPtr env, CodegenContext *ctx) {
-        unsigned line, column;
-        llvm::DIFile file;
-        if (llvmDIBuilder != nullptr) {
-            DebugLocationContext loc(x->location, ctx);
-            getDebugLineCol(x->location, line, column);
+//
+// codegenCollectLabels
+//
+
+void codegenCollectLabels(llvm::ArrayRef<StatementPtr> statements,
+                          unsigned startIndex, CodegenContext *ctx) {
+    for (size_t i = startIndex; i < statements.size(); ++i) {
+        StatementPtr x = statements[i];
+        switch (x->stmtKind) {
+        case LABEL: {
+            Label *y = (Label *)x.ptr();
+            llvm::StringMap<JumpTarget>::iterator li =
+                ctx->labels.find(y->name->str);
+            if (li != ctx->labels.end())
+                error(x, "label redefined");
+            llvm::BasicBlock *bb = newBasicBlock(y->name->str, ctx);
+            ctx->labels[y->name->str] = JumpTarget(bb, cgMarkStack(ctx));
+            break;
+        }
+        case BINDING:
+            return;
+        default:
+            break;
         }
-        switch (x->bindingKind) {
-            case VAR: {
-                MultiPValuePtr mpv = safeAnalyzeMulti(x->values, env, 1);
-                if (x->hasVarArg) {
-                    if (mpv->values.size() < x->args.size() - 1)
-                        arityMismatchError(x->args.size() - 1, mpv->values.size(), /*hasVarArg=*/ true);
-                } else if (mpv->values.size() != x->args.size())
-                    arityMismatchError(x->args.size(), mpv->values.size(), /*hasVarArg=*/ false);
-                MultiCValuePtr mcv = new MultiCValue();
-                for (unsigned i = 0; i < mpv->values.size(); ++i) {
-                    CValuePtr cv = codegenAllocNewValue(mpv->values[i].type, ctx);
-                    mcv->add(cv);
-                    if (llvmDIBuilder != nullptr) {
-                        llvm::DILexicalBlock debugBlock = ctx->getDebugScope();
-                        llvm::DIVariable debugVar = llvmDIBuilder->createLocalVariable(
-                            llvm::dwarf::DW_TAG_variable, // tag
-                            debugBlock, // scope
-                            getBindingVariableName(x, i), // name
-                            file, // file
-                            line, // line
-                            llvmTypeDebugInfo(cv->type), // type
-                            true, // alwaysPreserve
-                            0, // flags
-                            0 // argNo
-                        );
-                        llvmDIBuilder->insertDeclare(
-                                    cv->llValue,
-                                    debugVar,
+    }
+}
+
+//
+// codegenBinding
+//
+
+llvm::SmallString<16> getBindingVariableName(BindingPtr x, unsigned i) {
+    if (i >= x->args.size()) {
+        assert(x->hasVarArg);
+
+        llvm::SmallString<16> buf;
+        llvm::raw_svector_ostream ostr(buf);
+        ostr << x->args.back()->name->str << "_" << (i - x->args.size() + 1);
+        return ostr.str();
+    } else {
+        return x->args[i]->name->str;
+    }
+}
+
+EnvPtr codegenBinding(BindingPtr x, EnvPtr env, CodegenContext *ctx) {
+    unsigned line, column;
+    llvm::DIFile file;
+    if (llvmDIBuilder != nullptr) {
+        DebugLocationContext loc(x->location, ctx);
+        getDebugLineCol(x->location, line, column);
+    }
+    switch (x->bindingKind) {
+    case VAR: {
+        MultiPValuePtr mpv = safeAnalyzeMulti(x->values, env, 1);
+        if (x->hasVarArg) {
+            if (mpv->values.size() < x->args.size() - 1)
+                arityMismatchError(x->args.size() - 1, mpv->values.size(),
+                                   /*hasVarArg=*/true);
+        } else if (mpv->values.size() != x->args.size())
+            arityMismatchError(x->args.size(), mpv->values.size(),
+                               /*hasVarArg=*/false);
+        MultiCValuePtr mcv = new MultiCValue();
+        for (unsigned i = 0; i < mpv->values.size(); ++i) {
+            CValuePtr cv = codegenAllocNewValue(mpv->values[i].type, ctx);
+            mcv->add(cv);
+            if (llvmDIBuilder != nullptr) {
+                llvm::DILexicalBlock debugBlock = ctx->getDebugScope();
+                llvm::DIVariable debugVar = llvmDIBuilder->createLocalVariable(
+                    llvm::dwarf::DW_TAG_variable, // tag
+                    debugBlock,                   // scope
+                    getBindingVariableName(x, i), // name
+                    file,                         // file
+                    line,                         // line
+                    llvmTypeDebugInfo(cv->type),  // type
+                    true,                         // alwaysPreserve
+                    0,                            // flags
+                    0                             // argNo
+                );
+                llvmDIBuilder
+                    ->insertDeclare(cv->llValue, debugVar,
                                     ctx->builder->GetInsertBlock())
-                                ->setDebugLoc(ctx->builder->getCurrentDebugLocation());
-                    }
-                }
-                size_t tempMarker = markTemps(ctx);
-                size_t marker = cgMarkStack(ctx);
-                codegenMultiInto(x->values, env, ctx, mcv, x->args.size());
-                cgDestroyAndPopStack(marker, ctx, false);
-                clearTemps(tempMarker, ctx);
-                EnvPtr env2 = new Env(env);
-                for (unsigned i = 0; i < x->patternVars.size(); ++i)
-                    addLocal(env2, x->patternVars[i].name, x->patternTypes[i]);
-                size_t varArgSize = mcv->values.size() - x->args.size() + 1;
-                for (unsigned i = 0, j = 0; i < x->args.size(); ++i) {
-                    if (x->args[i]->varArg) {
-                        MultiCValuePtr varArgs = new MultiCValue();
-                        for (; j < varArgSize; ++j) {
-                            CValuePtr cv = mcv->values[i + j];
-                            cgPushStackValue(cv, ctx);
-                            varArgs->add(cv);
-                        }
-                        --j;
-                        addLocal(env2, x->args[i]->name, varArgs.ptr());
-                    } else {
-                        CValuePtr cv = mcv->values[i + j];
-                        cgPushStackValue(cv, ctx);
-                        addLocal(env2, x->args[i]->name, cv.ptr());
-                        llvm::SmallString<128> buf;
-                        llvm::raw_svector_ostream ostr(buf);
-                        ostr << x->args[i]->name->str << ":" << cv->type;
-                        cv->llValue->setName(ostr.str());
-                    }
+                    ->setDebugLoc(ctx->builder->getCurrentDebugLocation());
+            }
+        }
+        size_t tempMarker = markTemps(ctx);
+        size_t marker = cgMarkStack(ctx);
+        codegenMultiInto(x->values, env, ctx, mcv, x->args.size());
+        cgDestroyAndPopStack(marker, ctx, false);
+        clearTemps(tempMarker, ctx);
+        EnvPtr env2 = new Env(env);
+        for (unsigned i = 0; i < x->patternVars.size(); ++i)
+            addLocal(env2, x->patternVars[i].name, x->patternTypes[i]);
+        size_t varArgSize = mcv->values.size() - x->args.size() + 1;
+        for (unsigned i = 0, j = 0; i < x->args.size(); ++i) {
+            if (x->args[i]->varArg) {
+                MultiCValuePtr varArgs = new MultiCValue();
+                for (; j < varArgSize; ++j) {
+                    CValuePtr cv = mcv->values[i + j];
+                    cgPushStackValue(cv, ctx);
+                    varArgs->add(cv);
                 }
-                return env2;
+                --j;
+                addLocal(env2, x->args[i]->name, varArgs.ptr());
+            } else {
+                CValuePtr cv = mcv->values[i + j];
+                cgPushStackValue(cv, ctx);
+                addLocal(env2, x->args[i]->name, cv.ptr());
+                llvm::SmallString<128> buf;
+                llvm::raw_svector_ostream ostr(buf);
+                ostr << x->args[i]->name->str << ":" << cv->type;
+                cv->llValue->setName(ostr.str());
             }
+        }
+        return env2;
+    }
 
-            case REF: {
-                MultiPValuePtr mpv = safeAnalyzeMulti(x->values, env, x->args.size());
-                if (x->hasVarArg) {
-                    if (mpv->values.size() < x->args.size())
-                        arityMismatchError(x->args.size(), mpv->values.size(), /*hasVarArg=*/true);
-                } else if (mpv->values.size() != x->args.size())
-                    arityMismatchError(x->args.size(), mpv->values.size(), /*hasVarArg=*/false);
-                MultiCValuePtr mcv = new MultiCValue();
-                for (unsigned i = 0; i < mpv->values.size(); ++i) {
-                    PVData const &pv = mpv->values[i];
-                    if (pv.isRValue)
-                        argumentError(i, "ref can only bind to an lvalue");
-                    TypePtr ptrType = pointerType(pv.type);
-                    CValuePtr cvRef = codegenAllocNewValue(ptrType, ctx);
-                    mcv->add(cvRef);
-                    if (llvmDIBuilder != nullptr) {
-                        llvm::DILexicalBlock debugBlock = ctx->getDebugScope();
-                        llvm::DIVariable debugVar = llvmDIBuilder->createLocalVariable(
-                            llvm::dwarf::DW_TAG_variable, // tag
-                            debugBlock, // scope
-                            getBindingVariableName(x, i), // name
-                            file, // file
-                            line, // line
-                            llvmDIBuilder->createReferenceType(
-                                llvm::dwarf::DW_TAG_reference_type,
-                                llvmTypeDebugInfo(pv.type)), // type
-                            true, // alwaysPreserve
-                            0, // flags
-                            0 // argNo
-                        );
-                        llvmDIBuilder->insertDeclare(
-                                    cvRef->llValue,
-                                    debugVar,
+    case REF: {
+        MultiPValuePtr mpv = safeAnalyzeMulti(x->values, env, x->args.size());
+        if (x->hasVarArg) {
+            if (mpv->values.size() < x->args.size())
+                arityMismatchError(x->args.size(), mpv->values.size(),
+                                   /*hasVarArg=*/true);
+        } else if (mpv->values.size() != x->args.size())
+            arityMismatchError(x->args.size(), mpv->values.size(),
+                               /*hasVarArg=*/false);
+        MultiCValuePtr mcv = new MultiCValue();
+        for (unsigned i = 0; i < mpv->values.size(); ++i) {
+            PVData const &pv = mpv->values[i];
+            if (pv.isRValue)
+                argumentError(i, "ref can only bind to an lvalue");
+            TypePtr ptrType = pointerType(pv.type);
+            CValuePtr cvRef = codegenAllocNewValue(ptrType, ctx);
+            mcv->add(cvRef);
+            if (llvmDIBuilder != nullptr) {
+                llvm::DILexicalBlock debugBlock = ctx->getDebugScope();
+                llvm::DIVariable debugVar = llvmDIBuilder->createLocalVariable(
+                    llvm::dwarf::DW_TAG_variable, // tag
+                    debugBlock,                   // scope
+                    getBindingVariableName(x, i), // name
+                    file,                         // file
+                    line,                         // line
+                    llvmDIBuilder->createReferenceType(
+                        llvm::dwarf::DW_TAG_reference_type,
+                        llvmTypeDebugInfo(pv.type)), // type
+                    true,                            // alwaysPreserve
+                    0,                               // flags
+                    0                                // argNo
+                );
+                llvmDIBuilder
+                    ->insertDeclare(cvRef->llValue, debugVar,
                                     ctx->builder->GetInsertBlock())
-                                ->setDebugLoc(ctx->builder->getCurrentDebugLocation());
-                    }
-                }
-                size_t tempMarker = markTemps(ctx);
-                size_t marker = cgMarkStack(ctx);
-                codegenMulti(x->values, env, ctx, mcv, x->args.size());
-                cgDestroyAndPopStack(marker, ctx, false);
-                clearTemps(tempMarker, ctx);
-                EnvPtr env2 = new Env(env);
-                for (unsigned i = 0; i < x->patternVars.size(); ++i)
-                    addLocal(env2, x->patternVars[i].name, x->patternTypes[i]);
-                size_t varArgSize = mcv->values.size() - x->args.size() + 1;
-                for (unsigned i = 0, j = 0; i < x->args.size(); ++i) {
-                    if (x->args[i]->varArg) {
-                        MultiCValuePtr varArgs = new MultiCValue();
-                        for (; j < varArgSize; ++j) {
-                            CValuePtr cv = derefValue(mcv->values[i + j], ctx);
-                            varArgs->add(cv);
-                        }
-                        --j;
-                        addLocal(env2, x->args[i]->name, varArgs.ptr());
-                    } else {
-                        CValuePtr cv = derefValue(mcv->values[i + j], ctx);
-                        addLocal(env2, x->args[i]->name, cv.ptr());
-                        llvm::SmallString<128> buf;
-                        llvm::raw_svector_ostream ostr(buf);
-                        ostr << x->args[i]->name->str << ":" << cv->type;
-                        cv->llValue->setName(ostr.str());
-                    }
+                    ->setDebugLoc(ctx->builder->getCurrentDebugLocation());
+            }
+        }
+        size_t tempMarker = markTemps(ctx);
+        size_t marker = cgMarkStack(ctx);
+        codegenMulti(x->values, env, ctx, mcv, x->args.size());
+        cgDestroyAndPopStack(marker, ctx, false);
+        clearTemps(tempMarker, ctx);
+        EnvPtr env2 = new Env(env);
+        for (unsigned i = 0; i < x->patternVars.size(); ++i)
+            addLocal(env2, x->patternVars[i].name, x->patternTypes[i]);
+        size_t varArgSize = mcv->values.size() - x->args.size() + 1;
+        for (unsigned i = 0, j = 0; i < x->args.size(); ++i) {
+            if (x->args[i]->varArg) {
+                MultiCValuePtr varArgs = new MultiCValue();
+                for (; j < varArgSize; ++j) {
+                    CValuePtr cv = derefValue(mcv->values[i + j], ctx);
+                    varArgs->add(cv);
                 }
-                return env2;
+                --j;
+                addLocal(env2, x->args[i]->name, varArgs.ptr());
+            } else {
+                CValuePtr cv = derefValue(mcv->values[i + j], ctx);
+                addLocal(env2, x->args[i]->name, cv.ptr());
+                llvm::SmallString<128> buf;
+                llvm::raw_svector_ostream ostr(buf);
+                ostr << x->args[i]->name->str << ":" << cv->type;
+                cv->llValue->setName(ostr.str());
             }
+        }
+        return env2;
+    }
 
-            case FORWARD: {
-                MultiPValuePtr mpv = safeAnalyzeMulti(x->values, env, x->args.size());
-                if (x->hasVarArg) {
-                    if (mpv->values.size() < x->args.size())
-                        arityMismatchError(x->args.size(), mpv->values.size(), /*hasVarArg=*/true);
-                } else if (mpv->values.size() != x->args.size())
-                    arityMismatchError(x->args.size(), mpv->values.size(), /*hasVarArg=*/false);
-                MultiCValuePtr mcv = new MultiCValue();
-                for (unsigned i = 0; i < mpv->values.size(); ++i) {
-                    PVData const &pv = mpv->values[i];
-                    CValuePtr cv;
-                    if (pv.isRValue) {
-                        cv = codegenAllocNewValue(pv.type, ctx);
-                    } else {
-                        TypePtr ptrType = pointerType(pv.type);
-                        cv = codegenAllocNewValue(ptrType, ctx);
-                    }
-                    mcv->add(cv);
-                    if (llvmDIBuilder != nullptr) {
-                        llvm::DILexicalBlock debugBlock = ctx->getDebugScope();
-                        llvm::DIType debugType = llvmTypeDebugInfo(pv.type);
-                        llvm::DIVariable debugVar = llvmDIBuilder->createLocalVariable(
-                            llvm::dwarf::DW_TAG_variable, // tag
-                            debugBlock, // scope
-                            getBindingVariableName(x, i), // name
-                            file, // file
-                            line, // line
-                            pv.isRValue
-                                ? debugType
+    case FORWARD: {
+        MultiPValuePtr mpv = safeAnalyzeMulti(x->values, env, x->args.size());
+        if (x->hasVarArg) {
+            if (mpv->values.size() < x->args.size())
+                arityMismatchError(x->args.size(), mpv->values.size(),
+                                   /*hasVarArg=*/true);
+        } else if (mpv->values.size() != x->args.size())
+            arityMismatchError(x->args.size(), mpv->values.size(),
+                               /*hasVarArg=*/false);
+        MultiCValuePtr mcv = new MultiCValue();
+        for (unsigned i = 0; i < mpv->values.size(); ++i) {
+            PVData const &pv = mpv->values[i];
+            CValuePtr cv;
+            if (pv.isRValue) {
+                cv = codegenAllocNewValue(pv.type, ctx);
+            } else {
+                TypePtr ptrType = pointerType(pv.type);
+                cv = codegenAllocNewValue(ptrType, ctx);
+            }
+            mcv->add(cv);
+            if (llvmDIBuilder != nullptr) {
+                llvm::DILexicalBlock debugBlock = ctx->getDebugScope();
+                llvm::DIType debugType = llvmTypeDebugInfo(pv.type);
+                llvm::DIVariable debugVar = llvmDIBuilder->createLocalVariable(
+                    llvm::dwarf::DW_TAG_variable, // tag
+                    debugBlock,                   // scope
+                    getBindingVariableName(x, i), // name
+                    file,                         // file
+                    line,                         // line
+                    pv.isRValue ? debugType
                                 : llvmDIBuilder->createReferenceType(
-                                    llvm::dwarf::DW_TAG_reference_type,
-                                    debugType), // type
-                            true, // alwaysPreserve
-                            0, // flags
-                            0 // argNo
-                        );
-                        llvmDIBuilder->insertDeclare(
-                                    cv->llValue,
-                                    debugVar,
+                                      llvm::dwarf::DW_TAG_reference_type,
+                                      debugType), // type
+                    true,                         // alwaysPreserve
+                    0,                            // flags
+                    0                             // argNo
+                );
+                llvmDIBuilder
+                    ->insertDeclare(cv->llValue, debugVar,
                                     ctx->builder->GetInsertBlock())
-                                ->setDebugLoc(ctx->builder->getCurrentDebugLocation());
-                    }
-                }
-                size_t tempMarker = markTemps(ctx);
-                size_t marker = cgMarkStack(ctx);
-                codegenMulti(x->values, env, ctx, mcv, x->args.size());
-                cgDestroyAndPopStack(marker, ctx, false);
-                clearTemps(tempMarker, ctx);
-                EnvPtr env2 = new Env(env);
-                for (unsigned i = 0; i < x->patternVars.size(); ++i)
-                    addLocal(env2, x->patternVars[i].name, x->patternTypes[i]);
-                size_t varArgSize = mcv->values.size() - x->args.size() + 1;
-                for (unsigned i = 0, j = 0; i < x->args.size(); ++i) {
-                    if (x->args[i]->varArg) {
-                        MultiCValuePtr varArgs = new MultiCValue();
-                        for (; j < varArgSize; ++j) {
-                            CValuePtr rcv, cv;
-                            rcv = mcv->values[i + j];
-                            if (mpv->values[i + j].isRValue) {
-                                cv = rcv;
-                                cgPushStackValue(cv, ctx);
-                            } else {
-                                cv = derefValue(rcv, ctx);
-                            }
-                            varArgs->add(cv);
-                        }
-                        --j;
-                        addLocal(env2, x->args[i]->name, varArgs.ptr());
+                    ->setDebugLoc(ctx->builder->getCurrentDebugLocation());
+            }
+        }
+        size_t tempMarker = markTemps(ctx);
+        size_t marker = cgMarkStack(ctx);
+        codegenMulti(x->values, env, ctx, mcv, x->args.size());
+        cgDestroyAndPopStack(marker, ctx, false);
+        clearTemps(tempMarker, ctx);
+        EnvPtr env2 = new Env(env);
+        for (unsigned i = 0; i < x->patternVars.size(); ++i)
+            addLocal(env2, x->patternVars[i].name, x->patternTypes[i]);
+        size_t varArgSize = mcv->values.size() - x->args.size() + 1;
+        for (unsigned i = 0, j = 0; i < x->args.size(); ++i) {
+            if (x->args[i]->varArg) {
+                MultiCValuePtr varArgs = new MultiCValue();
+                for (; j < varArgSize; ++j) {
+                    CValuePtr rcv, cv;
+                    rcv = mcv->values[i + j];
+                    if (mpv->values[i + j].isRValue) {
+                        cv = rcv;
+                        cgPushStackValue(cv, ctx);
                     } else {
-                        CValuePtr rcv, cv;
-                        rcv = mcv->values[i + j];
-                        if (mpv->values[i + j].isRValue) {
-                            cv = rcv;
-                            cgPushStackValue(cv, ctx);
-                        } else {
-                            cv = derefValue(rcv, ctx);
-                        }
-                        addLocal(env2, x->args[i]->name, cv.ptr());
-                        llvm::SmallString<128> buf;
-                        llvm::raw_svector_ostream ostr(buf);
-                        ostr << x->args[i]->name->str << ":" << cv->type;
-                        cv->llValue->setName(ostr.str());
+                        cv = derefValue(rcv, ctx);
                     }
+                    varArgs->add(cv);
+                }
+                --j;
+                addLocal(env2, x->args[i]->name, varArgs.ptr());
+            } else {
+                CValuePtr rcv, cv;
+                rcv = mcv->values[i + j];
+                if (mpv->values[i + j].isRValue) {
+                    cv = rcv;
+                    cgPushStackValue(cv, ctx);
+                } else {
+                    cv = derefValue(rcv, ctx);
                 }
-                return env2;
+                addLocal(env2, x->args[i]->name, cv.ptr());
+                llvm::SmallString<128> buf;
+                llvm::raw_svector_ostream ostr(buf);
+                ostr << x->args[i]->name->str << ":" << cv->type;
+                cv->llValue->setName(ostr.str());
             }
+        }
+        return env2;
+    }
 
-            case ALIAS: {
-                ensureArity(x->args, 1);
-                ensureArity(x->values->exprs, 1);
-                EnvPtr env2 = new Env(env);
-                ExprPtr y = foreignExpr(env, x->values->exprs[0]);
-                addLocal(env2, x->args[0]->name, y.ptr());
-                return env2;
-            }
+    case ALIAS: {
+        ensureArity(x->args, 1);
+        ensureArity(x->values->exprs, 1);
+        EnvPtr env2 = new Env(env);
+        ExprPtr y = foreignExpr(env, x->values->exprs[0]);
+        addLocal(env2, x->args[0]->name, y.ptr());
+        return env2;
+    }
 
-            default: {
-                assert(false);
-                return nullptr;
-            }
-        }
+    default: {
+        assert(false);
+        return nullptr;
     }
+    }
+}
 
-    //
-    // codegenExprAssign, codegenMultiExprAssign
-    //
-
-    void codegenExprAssign(ExprPtr left,
-                           CValuePtr cvRight,
-                           PVData const &pvRight,
-                           EnvPtr env,
-                           CodegenContext *ctx) {
-        if (left->exprKind == INDEXING) {
-            Indexing *x = (Indexing *) left.ptr();
-            ExprPtr indexable = x->expr;
-            ExprListPtr args = x->args;
-            PVData pvIndexable = safeAnalyzeOne(indexable, env);
-            if (pvIndexable.type->typeKind != STATIC_TYPE) {
-                MultiPValuePtr pvArgs = new MultiPValue(pvIndexable);
-                pvArgs->add(safeAnalyzeMulti(args, env, 0));
-                pvArgs->add(pvRight);
-                CValuePtr cvIndexable = codegenOneAsRef(indexable, env, ctx);
-                MultiCValuePtr cvArgs = new MultiCValue(cvIndexable);
-                cvArgs->add(codegenMultiAsRef(args, env, ctx));
-                cvArgs->add(cvRight);
-                codegenCallValue(
-                    staticCValue(operator_indexAssign(), ctx),
-                    cvArgs, pvArgs, ctx,
-                    new MultiCValue()
-                );
-                return;
-            }
-        } else if (left->exprKind == STATIC_INDEXING) {
-            StaticIndexing *x = (StaticIndexing *) left.ptr();
-            ValueHolderPtr vh = sizeTToValueHolder(x->index);
-            CValuePtr cvIndex = staticCValue(vh.ptr(), ctx);
-            MultiPValuePtr pvArgs = new MultiPValue(safeAnalyzeOne(x->expr, env));
-            pvArgs->add(PVData(cvIndex->type, true));
+//
+// codegenExprAssign, codegenMultiExprAssign
+//
+
+void codegenExprAssign(ExprPtr left, CValuePtr cvRight, PVData const &pvRight,
+                       EnvPtr env, CodegenContext *ctx) {
+    if (left->exprKind == INDEXING) {
+        Indexing *x = (Indexing *)left.ptr();
+        ExprPtr indexable = x->expr;
+        ExprListPtr args = x->args;
+        PVData pvIndexable = safeAnalyzeOne(indexable, env);
+        if (pvIndexable.type->typeKind != STATIC_TYPE) {
+            MultiPValuePtr pvArgs = new MultiPValue(pvIndexable);
+            pvArgs->add(safeAnalyzeMulti(args, env, 0));
             pvArgs->add(pvRight);
-            MultiCValuePtr cvArgs = new MultiCValue(codegenOneAsRef(x->expr, env, ctx));
-            cvArgs->add(cvIndex);
+            CValuePtr cvIndexable = codegenOneAsRef(indexable, env, ctx);
+            MultiCValuePtr cvArgs = new MultiCValue(cvIndexable);
+            cvArgs->add(codegenMultiAsRef(args, env, ctx));
             cvArgs->add(cvRight);
-            codegenCallValue(
-                staticCValue(operator_staticIndexAssign(), ctx),
-                cvArgs, pvArgs, ctx,
-                new MultiCValue()
-            );
+            codegenCallValue(staticCValue(operator_indexAssign(), ctx), cvArgs,
+                             pvArgs, ctx, new MultiCValue());
             return;
-        } else if (left->exprKind == FIELD_REF) {
-            FieldRef *x = (FieldRef *) left.ptr();
-            ExprPtr base = x->expr;
-            PVData pvBase = safeAnalyzeOne(base, env);
-            if (pvBase.type->typeKind != STATIC_TYPE) {
-                CValuePtr cvName = staticCValue(x->name.ptr(), ctx);
-                MultiPValuePtr pvArgs = new MultiPValue(pvBase);
-                pvArgs->add(PVData(cvName->type, true));
-                pvArgs->add(pvRight);
-                MultiCValuePtr cvArgs = new MultiCValue(codegenOneAsRef(base, env, ctx));
-                cvArgs->add(cvName);
-                cvArgs->add(cvRight);
-                codegenCallValue(
-                    staticCValue(operator_fieldRefAssign(), ctx),
-                    cvArgs, pvArgs, ctx,
-                    new MultiCValue()
-                );
-                return;
-            }
         }
-        PVData pvLeft = safeAnalyzeOne(left, env);
-        CValuePtr cvLeft = codegenOneAsRef(left, env, ctx);
-        codegenValueAssign(pvLeft, cvLeft, pvRight, cvRight, ctx);
-    }
-
-    void codegenMultiExprAssign(ExprListPtr left,
-                                MultiCValuePtr mcvRight,
-                                MultiPValuePtr mpvRight,
-                                EnvPtr env,
-                                CodegenContext *ctx) {
-        MultiPValuePtr mpvLeft = safeAnalyzeMulti(left, env, 0);
-        MultiCValuePtr mcvLeft = codegenMultiAsRef(left, env, ctx);
-        assert(mpvLeft->size() == mcvLeft->size() && mcvLeft->size() == mcvRight->size());
-        for (unsigned i = 0; i < mcvLeft->size(); ++i) {
-            PVData const &pvLeft = mpvLeft->values[i];
-            CValuePtr cvLeft = mcvLeft->values[i];
-            PVData const &pvRight = mpvRight->values[i];
-            CValuePtr cvRight = mcvRight->values[i];
-            codegenValueAssign(pvLeft, cvLeft, pvRight, cvRight, ctx);
+    } else if (left->exprKind == STATIC_INDEXING) {
+        StaticIndexing *x = (StaticIndexing *)left.ptr();
+        ValueHolderPtr vh = sizeTToValueHolder(x->index);
+        CValuePtr cvIndex = staticCValue(vh.ptr(), ctx);
+        MultiPValuePtr pvArgs = new MultiPValue(safeAnalyzeOne(x->expr, env));
+        pvArgs->add(PVData(cvIndex->type, true));
+        pvArgs->add(pvRight);
+        MultiCValuePtr cvArgs =
+            new MultiCValue(codegenOneAsRef(x->expr, env, ctx));
+        cvArgs->add(cvIndex);
+        cvArgs->add(cvRight);
+        codegenCallValue(staticCValue(operator_staticIndexAssign(), ctx),
+                         cvArgs, pvArgs, ctx, new MultiCValue());
+        return;
+    } else if (left->exprKind == FIELD_REF) {
+        FieldRef *x = (FieldRef *)left.ptr();
+        ExprPtr base = x->expr;
+        PVData pvBase = safeAnalyzeOne(base, env);
+        if (pvBase.type->typeKind != STATIC_TYPE) {
+            CValuePtr cvName = staticCValue(x->name.ptr(), ctx);
+            MultiPValuePtr pvArgs = new MultiPValue(pvBase);
+            pvArgs->add(PVData(cvName->type, true));
+            pvArgs->add(pvRight);
+            MultiCValuePtr cvArgs =
+                new MultiCValue(codegenOneAsRef(base, env, ctx));
+            cvArgs->add(cvName);
+            cvArgs->add(cvRight);
+            codegenCallValue(staticCValue(operator_fieldRefAssign(), ctx),
+                             cvArgs, pvArgs, ctx, new MultiCValue());
+            return;
         }
     }
+    PVData pvLeft = safeAnalyzeOne(left, env);
+    CValuePtr cvLeft = codegenOneAsRef(left, env, ctx);
+    codegenValueAssign(pvLeft, cvLeft, pvRight, cvRight, ctx);
+}
 
-    //
-    // codegenTopLevelLLVM
-    //
-
-    static string stripEnclosingBraces(llvm::StringRef s) {
-        const char *i = s.begin();
-        const char *j = s.end();
-        assert(i != j);
-        assert(*i == '{');
-        assert(*(j-1) == '}');
-        return string(i + 1, j - 1);
+void codegenMultiExprAssign(ExprListPtr left, MultiCValuePtr mcvRight,
+                            MultiPValuePtr mpvRight, EnvPtr env,
+                            CodegenContext *ctx) {
+    MultiPValuePtr mpvLeft = safeAnalyzeMulti(left, env, 0);
+    MultiCValuePtr mcvLeft = codegenMultiAsRef(left, env, ctx);
+    assert(mpvLeft->size() == mcvLeft->size() &&
+           mcvLeft->size() == mcvRight->size());
+    for (unsigned i = 0; i < mcvLeft->size(); ++i) {
+        PVData const &pvLeft = mpvLeft->values[i];
+        CValuePtr cvLeft = mcvLeft->values[i];
+        PVData const &pvRight = mpvRight->values[i];
+        CValuePtr cvRight = mcvRight->values[i];
+        codegenValueAssign(pvLeft, cvLeft, pvRight, cvRight, ctx);
     }
+}
 
-    static void codegenTopLevelLLVMRecursive(ModulePtr m) {
-        // XXX debug info for inline LLVM
+//
+// codegenTopLevelLLVM
+//
+
+static string stripEnclosingBraces(llvm::StringRef s) {
+    const char *i = s.begin();
+    const char *j = s.end();
+    assert(i != j);
+    assert(*i == '{');
+    assert(*(j - 1) == '}');
+    return string(i + 1, j - 1);
+}
 
-        if (m->topLevelLLVMGenerated) return;
-        m->topLevelLLVMGenerated = true;
-        vector<ImportPtr>::iterator ii, iend;
-        for (ii = m->imports.begin(), iend = m->imports.end(); ii != iend; ++ii)
-            codegenTopLevelLLVMRecursive((*ii)->module);
+static void codegenTopLevelLLVMRecursive(ModulePtr m) {
+    // XXX debug info for inline LLVM
 
-        if (!m->topLevelLLVM) return;
+    if (m->topLevelLLVMGenerated)
+        return;
+    m->topLevelLLVMGenerated = true;
+    vector<ImportPtr>::iterator ii, iend;
+    for (ii = m->imports.begin(), iend = m->imports.end(); ii != iend; ++ii)
+        codegenTopLevelLLVMRecursive((*ii)->module);
 
-        LocationContext loc(m->topLevelLLVM->location);
+    if (!m->topLevelLLVM)
+        return;
 
-        string code;
-        if (!interpolateLLVMCode(m->topLevelLLVM, code, m->env))
-            error("failed to generate top level llvm");
+    LocationContext loc(m->topLevelLLVM->location);
 
-        code = stripEnclosingBraces(code);
+    string code;
+    if (!interpolateLLVMCode(m->topLevelLLVM, code, m->env))
+        error("failed to generate top level llvm");
 
-        llvm::SMDiagnostic err;
-        llvm::MemoryBuffer *buf =
-                llvm::MemoryBuffer::getMemBuffer(llvm::StringRef(code));
+    code = stripEnclosingBraces(code);
 
-        if (!llvm::ParseAssembly(buf, llvmModule, err,
-                                 llvmContext)) {
-            err.print("\n", llvm::errs());
-            llvm::errs() << "\n";
-            error("llvm assembly parse error");
-        }
-    }
+    llvm::SMDiagnostic err;
+    llvm::MemoryBuffer *buf =
+        llvm::MemoryBuffer::getMemBuffer(llvm::StringRef(code));
 
-    void codegenTopLevelLLVM(ModulePtr m) {
-        codegenTopLevelLLVMRecursive(preludeModule());
-        codegenTopLevelLLVMRecursive(m);
+    if (!llvm::ParseAssembly(buf, llvmModule, err, llvmContext)) {
+        err.print("\n", llvm::errs());
+        llvm::errs() << "\n";
+        error("llvm assembly parse error");
     }
+}
 
-    //
-    // codegenEntryPoints, codegenMain
-    //
+void codegenTopLevelLLVM(ModulePtr m) {
+    codegenTopLevelLLVMRecursive(preludeModule());
+    codegenTopLevelLLVMRecursive(m);
+}
 
-    static CodegenContext *setUpSimpleContext(CodegenContext *ctx, const char *name) {
-        llvm::FunctionType *llFuncType =
-                llvm::FunctionType::get(llvmVoidType(),
-                                        vector<llvm::Type *>(),
-                                        false);
-        llvm::Function *initGlobals =
-                llvm::Function::Create(llFuncType,
-                                       llvm::Function::InternalLinkage,
-                                       name,
-                                       llvmModule);
+//
+// codegenEntryPoints, codegenMain
+//
 
-        ctx->llvmFunc = initGlobals;
+static CodegenContext *setUpSimpleContext(CodegenContext *ctx,
+                                          const char *name) {
+    llvm::FunctionType *llFuncType =
+        llvm::FunctionType::get(llvmVoidType(), vector<llvm::Type *>(), false);
+    llvm::Function *initGlobals = llvm::Function::Create(
+        llFuncType, llvm::Function::InternalLinkage, name, llvmModule);
 
-        llvm::BasicBlock *initBlock = newBasicBlock("init", ctx);
-        llvm::BasicBlock *codeBlock = newBasicBlock("code", ctx);
-        llvm::BasicBlock *returnBlock = newBasicBlock("return", ctx);
-        llvm::BasicBlock *exceptionBlock = newBasicBlock("exception", ctx);
+    ctx->llvmFunc = initGlobals;
 
-        ctx->initBuilder.reset(new llvm::IRBuilder<>(initBlock));
-        ctx->builder.reset(new llvm::IRBuilder<>(codeBlock));
+    llvm::BasicBlock *initBlock = newBasicBlock("init", ctx);
+    llvm::BasicBlock *codeBlock = newBasicBlock("code", ctx);
+    llvm::BasicBlock *returnBlock = newBasicBlock("return", ctx);
+    llvm::BasicBlock *exceptionBlock = newBasicBlock("exception", ctx);
 
-        ctx->exceptionValue = ctx->initBuilder->CreateAlloca(exceptionReturnType(), nullptr, "exception");
+    ctx->initBuilder.reset(new llvm::IRBuilder<>(initBlock));
+    ctx->builder.reset(new llvm::IRBuilder<>(codeBlock));
 
-        ctx->returnLists.push_back(vector<CReturn>());
-        JumpTarget returnTarget(returnBlock, cgMarkStack(ctx));
-        ctx->returnTargets.push_back(returnTarget);
-        JumpTarget exceptionTarget(exceptionBlock, cgMarkStack(ctx));
-        ctx->exceptionTargets.push_back(exceptionTarget);
+    ctx->exceptionValue = ctx->initBuilder->CreateAlloca(exceptionReturnType(),
+                                                         nullptr, "exception");
 
-        return ctx;
-    }
+    ctx->returnLists.push_back(vector<CReturn>());
+    JumpTarget returnTarget(returnBlock, cgMarkStack(ctx));
+    ctx->returnTargets.push_back(returnTarget);
+    JumpTarget exceptionTarget(exceptionBlock, cgMarkStack(ctx));
+    ctx->exceptionTargets.push_back(exceptionTarget);
 
-    static void finalizeSimpleContext(CodegenContext *ctx,
-                                      ObjectPtr errorProc) {
-        ctx->builder->CreateBr(ctx->returnTargets.back().block);
+    return ctx;
+}
 
-        ctx->builder->SetInsertPoint(ctx->returnTargets.back().block);
-        ctx->builder->CreateRetVoid();
+static void finalizeSimpleContext(CodegenContext *ctx, ObjectPtr errorProc) {
+    ctx->builder->CreateBr(ctx->returnTargets.back().block);
 
-        ctx->builder->SetInsertPoint(ctx->exceptionTargets.back().block);
-        if (exceptionsEnabled()) {
-            codegenCallValue(staticCValue(errorProc, ctx),
-                             new MultiCValue(),
-                             ctx,
-                             new MultiCValue());
-        }
-        ctx->builder->CreateUnreachable();
+    ctx->builder->SetInsertPoint(ctx->returnTargets.back().block);
+    ctx->builder->CreateRetVoid();
 
-        llvm::Function::iterator bbi = ctx->llvmFunc->begin();
-        ++bbi;
-        ctx->initBuilder->CreateBr(&(*bbi));
+    ctx->builder->SetInsertPoint(ctx->exceptionTargets.back().block);
+    if (exceptionsEnabled()) {
+        codegenCallValue(staticCValue(errorProc, ctx), new MultiCValue(), ctx,
+                         new MultiCValue());
     }
+    ctx->builder->CreateUnreachable();
 
-    static void initializeCtorsDtors() {
-        setUpSimpleContext(constructorsCtx, "clayglobals_init");
-        setUpSimpleContext(destructorsCtx, "clayglobals_destroy");
+    llvm::Function::iterator bbi = ctx->llvmFunc->begin();
+    ++bbi;
+    ctx->initBuilder->CreateBr(&(*bbi));
+}
 
-        if (isMsvcTarget()) {
-            constructorsCtx->llvmFunc->setSection(".text$yc");
-            destructorsCtx->llvmFunc->setSection(".text$yd");
-        }
+static void initializeCtorsDtors() {
+    setUpSimpleContext(constructorsCtx, "clayglobals_init");
+    setUpSimpleContext(destructorsCtx, "clayglobals_destroy");
 
-        if (exceptionsEnabled()) {
-            codegenCallable(operator_exceptionInInitializer(),
-                            llvm::ArrayRef<PVData>());
-            codegenCallable(operator_exceptionInFinalizer(),
-                            llvm::ArrayRef<PVData>());
-        }
+    if (isMsvcTarget()) {
+        constructorsCtx->llvmFunc->setSection(".text$yc");
+        destructorsCtx->llvmFunc->setSection(".text$yd");
     }
 
-    static void codegenAtexitDestructors() {
-        llvm::Function *atexitFunc = llvmModule->getFunction("atexit");
-        if (!atexitFunc) {
-            vector<llvm::Type *> atexitArgTypes;
-            atexitArgTypes.push_back(destructorsCtx->llvmFunc->getType());
+    if (exceptionsEnabled()) {
+        codegenCallable(operator_exceptionInInitializer(),
+                        llvm::ArrayRef<PVData>());
+        codegenCallable(operator_exceptionInFinalizer(),
+                        llvm::ArrayRef<PVData>());
+    }
+}
 
-            llvm::FunctionType *atexitType =
-                    llvm::FunctionType::get(llvmIntType(32), atexitArgTypes, false);
+static void codegenAtexitDestructors() {
+    llvm::Function *atexitFunc = llvmModule->getFunction("atexit");
+    if (!atexitFunc) {
+        vector<llvm::Type *> atexitArgTypes;
+        atexitArgTypes.push_back(destructorsCtx->llvmFunc->getType());
 
-            atexitFunc = llvm::Function::Create(atexitType,
-                                                llvm::Function::ExternalLinkage,
-                                                "atexit",
-                                                llvmModule);
-        }
+        llvm::FunctionType *atexitType =
+            llvm::FunctionType::get(llvmIntType(32), atexitArgTypes, false);
 
-        constructorsCtx->builder->CreateCall(atexitFunc, destructorsCtx->llvmFunc);
+        atexitFunc = llvm::Function::Create(
+            atexitType, llvm::Function::ExternalLinkage, "atexit", llvmModule);
     }
 
-    static void finalizeCtorsDtors() {
-        if (isMsvcTarget())
-            codegenAtexitDestructors();
+    constructorsCtx->builder->CreateCall(atexitFunc, destructorsCtx->llvmFunc);
+}
+
+static void finalizeCtorsDtors() {
+    if (isMsvcTarget())
+        codegenAtexitDestructors();
 
-        finalizeSimpleContext(constructorsCtx, operator_exceptionInInitializer());
+    finalizeSimpleContext(constructorsCtx, operator_exceptionInInitializer());
 
-        for (size_t i = initializedGlobals.size(); i > 0; --i) {
-            CValuePtr cv = initializedGlobals[i - 1];
-            codegenValueDestroy(cv, destructorsCtx);
-        }
-        finalizeSimpleContext(destructorsCtx, operator_exceptionInFinalizer());
-    }
-
-    static void generateLLVMCtorsAndDtors() {
-        // make types for llvm.global_ctors, llvm.global_dtors
-        vector<llvm::Type *> fieldTypes;
-        fieldTypes.push_back(llvmIntType(32));
-        llvm::Type *funcType = constructorsCtx->llvmFunc->getFunctionType();
-        llvm::Type *funcPtrType = llvm::PointerType::getUnqual(funcType);
-        fieldTypes.push_back(funcPtrType);
-        llvm::StructType *structType =
-                llvm::StructType::get(llvmContext, fieldTypes);
-        llvm::ArrayType *arrayType = llvm::ArrayType::get(structType, 1);
-
-        // make constants for llvm.global_ctors
-        vector<llvm::Constant *> structElems1;
-        llvm::ConstantInt *prio1 =
-                llvm::ConstantInt::get(llvmContext,
-                                       llvm::APInt(32, llvm::StringRef("65535"), 10));
-        structElems1.push_back(prio1);
-        structElems1.push_back(constructorsCtx->llvmFunc);
-        llvm::Constant *structVal1 = llvm::ConstantStruct::get(structType,
-                                                               structElems1);
-        vector<llvm::Constant *> arrayElems1;
-        arrayElems1.push_back(structVal1);
-        llvm::Constant *arrayVal1 = llvm::ConstantArray::get(arrayType,
-                                                             arrayElems1);
-
-        // define llvm.global_ctors
+    for (size_t i = initializedGlobals.size(); i > 0; --i) {
+        CValuePtr cv = initializedGlobals[i - 1];
+        codegenValueDestroy(cv, destructorsCtx);
+    }
+    finalizeSimpleContext(destructorsCtx, operator_exceptionInFinalizer());
+}
+
+static void generateLLVMCtorsAndDtors() {
+    // make types for llvm.global_ctors, llvm.global_dtors
+    vector<llvm::Type *> fieldTypes;
+    fieldTypes.push_back(llvmIntType(32));
+    llvm::Type *funcType = constructorsCtx->llvmFunc->getFunctionType();
+    llvm::Type *funcPtrType = llvm::PointerType::getUnqual(funcType);
+    fieldTypes.push_back(funcPtrType);
+    llvm::StructType *structType =
+        llvm::StructType::get(llvmContext, fieldTypes);
+    llvm::ArrayType *arrayType = llvm::ArrayType::get(structType, 1);
+
+    // make constants for llvm.global_ctors
+    vector<llvm::Constant *> structElems1;
+    llvm::ConstantInt *prio1 = llvm::ConstantInt::get(
+        llvmContext, llvm::APInt(32, llvm::StringRef("65535"), 10));
+    structElems1.push_back(prio1);
+    structElems1.push_back(constructorsCtx->llvmFunc);
+    llvm::Constant *structVal1 =
+        llvm::ConstantStruct::get(structType, structElems1);
+    vector<llvm::Constant *> arrayElems1;
+    arrayElems1.push_back(structVal1);
+    llvm::Constant *arrayVal1 =
+        llvm::ConstantArray::get(arrayType, arrayElems1);
+
+    // define llvm.global_ctors
+    new llvm::GlobalVariable(*llvmModule, arrayType, true,
+                             llvm::GlobalVariable::AppendingLinkage, arrayVal1,
+                             "llvm.global_ctors");
+
+    // MSVC does not support a dtors mechanism. dtors are registered atexit
+    // by the ctor
+    if (!isMsvcTarget()) {
+        // make constants for llvm.global_dtors
+        vector<llvm::Constant *> structElems2;
+        llvm::ConstantInt *prio2 = llvm::ConstantInt::get(
+            llvmContext, llvm::APInt(32, llvm::StringRef("65535"), 10));
+        structElems2.push_back(prio2);
+        structElems2.push_back(destructorsCtx->llvmFunc);
+        llvm::Constant *structVal2 =
+            llvm::ConstantStruct::get(structType, structElems2);
+        vector<llvm::Constant *> arrayElems2;
+        arrayElems2.push_back(structVal2);
+        llvm::Constant *arrayVal2 =
+            llvm::ConstantArray::get(arrayType, arrayElems2);
+
+        // define llvm.global_dtors
         new llvm::GlobalVariable(*llvmModule, arrayType, true,
                                  llvm::GlobalVariable::AppendingLinkage,
-                                 arrayVal1, "llvm.global_ctors");
-
-        // MSVC does not support a dtors mechanism. dtors are registered atexit
-        // by the ctor
-        if (!isMsvcTarget()) {
-            // make constants for llvm.global_dtors
-            vector<llvm::Constant *> structElems2;
-            llvm::ConstantInt *prio2 =
-                    llvm::ConstantInt::get(llvmContext,
-                                           llvm::APInt(32, llvm::StringRef("65535"), 10));
-            structElems2.push_back(prio2);
-            structElems2.push_back(destructorsCtx->llvmFunc);
-            llvm::Constant *structVal2 = llvm::ConstantStruct::get(structType,
-                                                                   structElems2);
-            vector<llvm::Constant *> arrayElems2;
-            arrayElems2.push_back(structVal2);
-            llvm::Constant *arrayVal2 = llvm::ConstantArray::get(arrayType,
-                                                                 arrayElems2);
-
-            // define llvm.global_dtors
-            new llvm::GlobalVariable(*llvmModule, arrayType, true,
-                                     llvm::GlobalVariable::AppendingLinkage,
-                                     arrayVal2, "llvm.global_dtors");
-        }
+                                 arrayVal2, "llvm.global_dtors");
     }
+}
 
-    void codegenMain(ModulePtr module) {
-        IdentifierPtr main = Identifier::get("main");
-        IdentifierPtr argc = Identifier::get("argc");
-        IdentifierPtr argv = Identifier::get("argv");
+void codegenMain(ModulePtr module) {
+    IdentifierPtr main = Identifier::get("main");
+    IdentifierPtr argc = Identifier::get("argc");
+    IdentifierPtr argv = Identifier::get("argv");
 
-        BlockPtr mainBody = new Block();
+    BlockPtr mainBody = new Block();
 
-        ExprListPtr args;
+    ExprListPtr args;
 
-        args = new ExprList(new NameRef(main));
-        args->add(new NameRef(argc));
-        args->add(new NameRef(argv));
-        CallPtr mainCall = new Call(operator_expr_callMain(), args);
+    args = new ExprList(new NameRef(main));
+    args->add(new NameRef(argc));
+    args->add(new NameRef(argv));
+    CallPtr mainCall = new Call(operator_expr_callMain(), args);
 
-        ReturnPtr ret = new Return(RETURN_VALUE, new ExprList(mainCall.ptr()));
-        mainBody->statements.push_back(ret.ptr());
+    ReturnPtr ret = new Return(RETURN_VALUE, new ExprList(mainCall.ptr()));
+    mainBody->statements.push_back(ret.ptr());
 
-        vector<ExternalArgPtr> mainArgs;
-        ExprPtr argcType = new ObjectExpr(cIntType.ptr());
-        mainArgs.push_back(new ExternalArg(argc, argcType));
-        TypePtr charPtrPtr = pointerType(pointerType(int8Type));
-        ExprPtr argvType = new ObjectExpr(charPtrPtr.ptr());
-        mainArgs.push_back(new ExternalArg(argv, argvType));
+    vector<ExternalArgPtr> mainArgs;
+    ExprPtr argcType = new ObjectExpr(cIntType.ptr());
+    mainArgs.push_back(new ExternalArg(argc, argcType));
+    TypePtr charPtrPtr = pointerType(pointerType(int8Type));
+    ExprPtr argvType = new ObjectExpr(charPtrPtr.ptr());
+    mainArgs.push_back(new ExternalArg(argv, argvType));
 
-        ExternalProcedurePtr entryProc =
-                new ExternalProcedure(module.ptr(),
-                                      main,
-                                      PUBLIC,
-                                      mainArgs,
-                                      false,
-                                      new ObjectExpr(cIntType.ptr()),
-                                      mainBody.ptr(),
-                                      new ExprList());
+    ExternalProcedurePtr entryProc = new ExternalProcedure(
+        module.ptr(), main, PUBLIC, mainArgs, false,
+        new ObjectExpr(cIntType.ptr()), mainBody.ptr(), new ExprList());
 
-        entryProc->env = module->env;
+    entryProc->env = module->env;
 
-        codegenExternalProcedure(entryProc, true);
-    }
+    codegenExternalProcedure(entryProc, true);
+}
 
-    static void codegenModuleEntryPoints(ModulePtr module, bool importedExternals) {
-        module->externalsGenerated = true;
-        for (size_t i = 0; i < module->topLevelItems.size(); ++i) {
-            TopLevelItemPtr x = module->topLevelItems[i];
-            if (x->objKind == EXTERNAL_PROCEDURE) {
-                ExternalProcedurePtr y = (ExternalProcedure *) x.ptr();
-                if (y->body.ptr())
-                    codegenExternalProcedure(y, true);
-            }
+static void codegenModuleEntryPoints(ModulePtr module, bool importedExternals) {
+    module->externalsGenerated = true;
+    for (size_t i = 0; i < module->topLevelItems.size(); ++i) {
+        TopLevelItemPtr x = module->topLevelItems[i];
+        if (x->objKind == EXTERNAL_PROCEDURE) {
+            ExternalProcedurePtr y = (ExternalProcedure *)x.ptr();
+            if (y->body.ptr())
+                codegenExternalProcedure(y, true);
         }
+    }
 
-        if (importedExternals) {
-            vector<ImportPtr>::iterator ii, iend;
-            for (ii = module->imports.begin(), iend = module->imports.end(); ii != iend; ++ii)
-                if (!(*ii)->module->externalsGenerated)
-                    codegenModuleEntryPoints((*ii)->module, importedExternals);
-        }
+    if (importedExternals) {
+        vector<ImportPtr>::iterator ii, iend;
+        for (ii = module->imports.begin(), iend = module->imports.end();
+             ii != iend; ++ii)
+            if (!(*ii)->module->externalsGenerated)
+                codegenModuleEntryPoints((*ii)->module, importedExternals);
     }
+}
 
-    void codegenEntryPoints(ModulePtr module, bool importedExternals) {
-        CodegenContext theConstructorCtx;
-        CodegenContext theDestructorCtx;
-
-        constructorsCtx = &theConstructorCtx;
-        destructorsCtx = &theDestructorCtx;
-
-        codegenTopLevelLLVM(module);
-        initializeCtorsDtors();
-        generateLLVMCtorsAndDtors();
-        codegenModuleEntryPoints(module, importedExternals);
-
-        ObjectPtr mainProc = lookupPrivate(module, Identifier::get("main"));
-
-        // Generate call to `main` function.
-        // But if `main` is external procedure, it was already generated in
-        // `codegenModuleEntryPoints`.
-        if (mainProc != nullptr && mainProc->objKind != EXTERNAL_PROCEDURE)
-            codegenMain(module);
-
-        finalizeCtorsDtors();
-
-        if (llvmDIBuilder != nullptr)
-            llvmDIBuilder->finalize();
-
-        constructorsCtx = nullptr;
-        destructorsCtx = nullptr;
-    }
-
-    //
-    // initLLVM
-    //
-
-    llvm::TargetMachine *initLLVM(llvm::StringRef targetTriple,
-                                  llvm::StringRef targetCPU,
-                                  llvm::StringRef targetFeatures,
-                                  bool softFloat,
-                                  llvm::StringRef name,
-                                  llvm::StringRef flags,
-                                  bool relocPic,
-                                  bool debug,
-                                  unsigned optLevel) {
-        llvm::InitializeAllTargets();
-        llvm::InitializeAllTargetMCs();
-        llvm::InitializeAllAsmPrinters();
-        llvm::InitializeAllAsmParsers();
-
-        llvmModule = new llvm::Module(name, llvmContext);
-        llvmModule->setTargetTriple(targetTriple);
-        if (debug) {
-            llvm::SmallString<260> absFileName(name);
-            llvm::sys::fs::make_absolute(absFileName);
-            llvmDIBuilder = new llvm::DIBuilder(*llvmModule);
-            llvmDIBuilder->createCompileUnit(
-                llvm::dwarf::DW_LANG_C_plus_plus, //DW_LANG_user_CLAY,
-                llvm::sys::path::filename(absFileName),
-                llvm::sys::path::parent_path(absFileName),
-                "clay compiler " CLAY_COMPILER_VERSION,
-                optLevel > 0,
-                flags,
-                0);
-        } else
-            llvmDIBuilder = nullptr;
-
-        string err;
-        const llvm::Target *target = llvm::TargetRegistry::lookupTarget(targetTriple, err);
-        if (target == nullptr) {
-            llvm::errs() << "error: unable to find target: " << err << '\n';
-            return nullptr;
-        }
-        llvm::Reloc::Model reloc = relocPic
-                                       ? llvm::Reloc::PIC_
-                                       : llvm::Reloc::Default;
-        llvm::CodeModel::Model codeModel = llvm::CodeModel::Default;
-
-        llvm::CodeGenOpt::Level level;
-        switch (optLevel) {
-            case 0: level = llvm::CodeGenOpt::None;
-                break;
-            case 1: level = llvm::CodeGenOpt::Less;
-                break;
-            case 2: level = llvm::CodeGenOpt::Default;
-                break;
-            default: level = llvm::CodeGenOpt::Aggressive;
-                break;
-        }
+void codegenEntryPoints(ModulePtr module, bool importedExternals) {
+    CodegenContext theConstructorCtx;
+    CodegenContext theDestructorCtx;
 
-        llvm::TargetOptions opts;
-        if (optLevel < 2 || debug)
-            opts.NoFramePointerElim = 1;
-        if (softFloat) {
-            opts.UseSoftFloat = 1;
-            opts.FloatABIType = llvm::FloatABI::Soft;
-        }
+    constructorsCtx = &theConstructorCtx;
+    destructorsCtx = &theDestructorCtx;
 
-        llvm::TargetMachine *targetMachine = target->createTargetMachine(
-            targetTriple, targetCPU, targetFeatures,
-            opts, reloc, codeModel, level);
+    codegenTopLevelLLVM(module);
+    initializeCtorsDtors();
+    generateLLVMCtorsAndDtors();
+    codegenModuleEntryPoints(module, importedExternals);
 
-        if (targetMachine != nullptr) {
-            llvmDataLayout = targetMachine->getDataLayout();
-            if (llvmDataLayout == nullptr) {
-                return nullptr;
-            }
-            llvmModule->setDataLayout(llvmDataLayout->getStringRepresentation());
-        }
+    ObjectPtr mainProc = lookupPrivate(module, Identifier::get("main"));
+
+    // Generate call to `main` function.
+    // But if `main` is external procedure, it was already generated in
+    // `codegenModuleEntryPoints`.
+    if (mainProc != nullptr && mainProc->objKind != EXTERNAL_PROCEDURE)
+        codegenMain(module);
+
+    finalizeCtorsDtors();
 
-        return targetMachine;
+    if (llvmDIBuilder != nullptr)
+        llvmDIBuilder->finalize();
+
+    constructorsCtx = nullptr;
+    destructorsCtx = nullptr;
+}
+
+//
+// initLLVM
+//
+
+llvm::TargetMachine *initLLVM(llvm::StringRef targetTriple,
+                              llvm::StringRef targetCPU,
+                              llvm::StringRef targetFeatures, bool softFloat,
+                              llvm::StringRef name, llvm::StringRef flags,
+                              bool relocPic, bool debug, unsigned optLevel) {
+    llvm::InitializeAllTargets();
+    llvm::InitializeAllTargetMCs();
+    llvm::InitializeAllAsmPrinters();
+    llvm::InitializeAllAsmParsers();
+
+    llvmModule = new llvm::Module(name, llvmContext);
+    llvmModule->setTargetTriple(targetTriple);
+    if (debug) {
+        llvm::SmallString<260> absFileName(name);
+        llvm::sys::fs::make_absolute(absFileName);
+        llvmDIBuilder = new llvm::DIBuilder(*llvmModule);
+        llvmDIBuilder->createCompileUnit(
+            llvm::dwarf::DW_LANG_C_plus_plus, // DW_LANG_user_CLAY,
+            llvm::sys::path::filename(absFileName),
+            llvm::sys::path::parent_path(absFileName),
+            "clay compiler " CLAY_COMPILER_VERSION, optLevel > 0, flags, 0);
+    } else
+        llvmDIBuilder = nullptr;
+
+    string err;
+    const llvm::Target *target =
+        llvm::TargetRegistry::lookupTarget(targetTriple, err);
+    if (target == nullptr) {
+        llvm::errs() << "error: unable to find target: " << err << '\n';
+        return nullptr;
+    }
+    llvm::Reloc::Model reloc =
+        relocPic ? llvm::Reloc::PIC_ : llvm::Reloc::Static;
+    llvm::CodeModel::Model codeModel = llvm::CodeModel::Small;
+
+    llvm::CodeGenOptLevel level;
+    switch (optLevel) {
+    case 0:
+        level = llvm::CodeGenOptLevel::None;
+        break;
+    case 1:
+        level = llvm::CodeGenOptLevel::Less;
+        break;
+    case 2:
+        level = llvm::CodeGenOptLevel::Default;
+        break;
+    default:
+        level = llvm::CodeGenOptLevel::Aggressive;
+        break;
     }
 
-    void codegenBeforeRepl(ModulePtr module) {
-        CodegenContext *theConstructorCtx = new CodegenContext();
-        CodegenContext *theDestructorCtx = new CodegenContext();
-        delete constructorsCtx;
-        delete destructorsCtx;
-        constructorsCtx = theConstructorCtx;
-        destructorsCtx = theDestructorCtx;
-        //codegenTopLevelLLVM(module);
-        codegenTopLevelLLVMRecursive(module);
-        initializeCtorsDtors();
-        generateLLVMCtorsAndDtors();
-        codegenModuleEntryPoints(module, false);
+    llvm::TargetOptions opts;
+    if (optLevel < 2 || debug)
+        opts.NoFramePointerElim = 1;
+    if (softFloat) {
+        opts.UseSoftFloat = 1;
+        opts.FloatABIType = llvm::FloatABI::Soft;
     }
 
-    void codegenAfterRepl(llvm::Function *&ctor, llvm::Function *&dtor) {
-        finalizeCtorsDtors();
-        ctor = constructorsCtx->llvmFunc;
-        dtor = destructorsCtx->llvmFunc;
+    llvm::TargetMachine *targetMachine = target->createTargetMachine(
+        targetTriple, targetCPU, targetFeatures, opts, reloc, codeModel, level);
+
+    if (targetMachine != nullptr) {
+        llvmDataLayout = targetMachine->getDataLayout();
+        if (llvmDataLayout == nullptr) {
+            return nullptr;
+        }
+        llvmModule->setDataLayout(llvmDataLayout->getStringRepresentation());
     }
+
+    return targetMachine;
+}
+
+void codegenBeforeRepl(ModulePtr module) {
+    CodegenContext *theConstructorCtx = new CodegenContext();
+    CodegenContext *theDestructorCtx = new CodegenContext();
+    delete constructorsCtx;
+    delete destructorsCtx;
+    constructorsCtx = theConstructorCtx;
+    destructorsCtx = theDestructorCtx;
+    // codegenTopLevelLLVM(module);
+    codegenTopLevelLLVMRecursive(module);
+    initializeCtorsDtors();
+    generateLLVMCtorsAndDtors();
+    codegenModuleEntryPoints(module, false);
+}
+
+void codegenAfterRepl(llvm::Function *&ctor, llvm::Function *&dtor) {
+    finalizeCtorsDtors();
+    ctor = constructorsCtx->llvmFunc;
+    dtor = destructorsCtx->llvmFunc;
 }
+} // namespace clay
diff --git a/compiler/codegen.hpp b/compiler/codegen.hpp
index a3353999..4945f9fd 100644
--- a/compiler/codegen.hpp
+++ b/compiler/codegen.hpp
@@ -4,257 +4,219 @@
 #include "types.hpp"
 
 namespace clay {
-    static const unsigned short DW_LANG_user_CLAY = 0xC1A4;
-
-    extern llvm::Module *llvmModule;
-    extern llvm::DIBuilder *llvmDIBuilder;
-    extern const llvm::DataLayout *llvmDataLayout;
-    extern llvm::LLVMContext llvmContext;
-
-    llvm::PointerType *exceptionReturnType();
-    llvm::Value *noExceptionReturnValue();
-
-    llvm::TargetMachine *initLLVM(llvm::StringRef targetTriple,
-                                  llvm::StringRef targetCPU,
-                                  llvm::StringRef targetFeatures,
-                                  bool softFloat,
-                                  llvm::StringRef name,
-                                  llvm::StringRef flags,
-                                  bool relocPic,
-                                  bool debug,
-                                  unsigned optLevel);
-
-    bool inlineEnabled();
-    void setInlineEnabled(bool enabled);
-    bool exceptionsEnabled();
-    void setExceptionsEnabled(bool enabled);
-
-    void initExternalTarget(string target);
-
-    // codegen value
-    struct CValue : public Object {
-        TypePtr type;
-        llvm::Value *llValue;
-        const bool forwardedRValue: 1;
-
-        CValue(TypePtr type, llvm::Value *llValue, bool forwardedRValue = false)
-            : Object(CVALUE), type(type), llValue(llValue),
-              forwardedRValue(forwardedRValue) {
-            llvmType(type); // force full definition of type
-        }
-    };
-
-    struct MultiCValue : public Object {
-        vector<CValuePtr> values;
-
-        MultiCValue()
-            : Object(MULTI_CVALUE) {
-        }
-
-        MultiCValue(CValuePtr pv)
-            : Object(MULTI_CVALUE) {
-            values.push_back(pv);
-        }
-
-        MultiCValue(llvm::ArrayRef<CValuePtr> values)
-            : Object(MULTI_CVALUE), values(values) {
-        }
-
-        size_t size() { return values.size(); }
-        void add(CValuePtr x) { values.push_back(x); }
-
-        void add(MultiCValuePtr x) {
-            values.insert(values.end(), x->values.begin(), x->values.end());
-        }
-
-        void toArgsKey(vector<TypePtr> *types) {
-            for (vector<CValuePtr>::const_iterator i = values.begin(), end = values.end();
-                 i != end;
-                 ++i) {
-                types->push_back((*i)->type);
-            }
-        }
-    };
-
-    struct JumpTarget {
-        llvm::BasicBlock *block;
-        size_t stackMarker;
-        int useCount;
-
-        JumpTarget() : block(nullptr), stackMarker(0), useCount(0) {
-        }
-
-        JumpTarget(llvm::BasicBlock *block, size_t stackMarker)
-            : block(block), stackMarker(stackMarker), useCount(0) {
-        }
-    };
-
-    struct CReturn {
-        TypePtr type;
-        CValuePtr value;
-        bool byRef: 1;
-
-        CReturn(bool byRef, TypePtr type, CValuePtr value)
-            : type(type), value(value), byRef(byRef) {
-        }
-    };
-
-    struct StackSlot {
-        llvm::Type *llType;
-        llvm::Value *llValue;
-
-        StackSlot(llvm::Type *llType, llvm::Value *llValue)
-            : llType(llType), llValue(llValue) {
-        }
-    };
-
-    enum ValueStackEntryType {
-        LOCAL_VALUE,
-        FINALLY_STATEMENT,
-        ONERROR_STATEMENT
-    };
-
-    struct ValueStackEntry {
-        ValueStackEntryType type;
-        CValuePtr value;
-        EnvPtr statementEnv;
-        StatementPtr statement;
-
-        explicit ValueStackEntry(CValuePtr value)
-            : type(LOCAL_VALUE), value(value), statementEnv(nullptr), statement(nullptr) {
-        }
-
-        ValueStackEntry(ValueStackEntryType type,
-                        EnvPtr statementEnv,
-                        StatementPtr statement)
-            : type(type), value(nullptr), statementEnv(statementEnv), statement(statement) {
-            assert(type != LOCAL_VALUE);
-        }
-    };
-
-    struct CodegenContext {
-        llvm::Function *llvmFunc;
-        vector<llvm::TrackingVH<llvm::MDNode> > debugScope;
-        std::unique_ptr<llvm::IRBuilder<> > initBuilder;
-        std::unique_ptr<llvm::IRBuilder<> > builder;
-
-        vector<ValueStackEntry> valueStack;
-        llvm::Value *valueForStatics;
-
-        vector<StackSlot> allocatedSlots;
-        vector<StackSlot> discardedSlots;
-
-        vector<vector<CReturn> > returnLists;
-        vector<JumpTarget> returnTargets;
-        llvm::StringMap<JumpTarget> labels;
-        vector<JumpTarget> breaks;
-        vector<JumpTarget> continues;
-        vector<JumpTarget> exceptionTargets;
-        llvm::Value *exceptionValue;
-        int inlineDepth; //:31;
-        bool checkExceptions: 1;
-
-        int callByNameDepth;
-
-        CodegenContext()
-            : llvmFunc(nullptr),
-              valueForStatics(nullptr),
-              exceptionValue(nullptr),
-              inlineDepth(0),
-              checkExceptions(true),
-              callByNameDepth(0) {
-        }
+static const unsigned short DW_LANG_user_CLAY = 0xC1A4;
 
-        CodegenContext(llvm::Function *llvmFunc)
-            : llvmFunc(llvmFunc),
-              valueForStatics(nullptr),
-              exceptionValue(nullptr),
-              inlineDepth(0),
-              checkExceptions(true),
-              callByNameDepth(0) {
-        }
+extern llvm::Module *llvmModule;
+extern llvm::DIBuilder *llvmDIBuilder;
+extern const llvm::DataLayout *llvmDataLayout;
+extern llvm::LLVMContext llvmContext;
 
-        llvm::DILexicalBlock getDebugScope() {
-            if (debugScope.empty())
-                return llvm::DILexicalBlock(nullptr);
-            else
-                return llvm::DILexicalBlock(debugScope.back());
-        }
+llvm::PointerType *exceptionReturnType();
+llvm::Value *noExceptionReturnValue();
 
-        void pushDebugScope(llvm::DILexicalBlock scope) {
-            debugScope.push_back((llvm::MDNode *) scope);
-        }
+llvm::TargetMachine *initLLVM(llvm::StringRef targetTriple,
+                              llvm::StringRef targetCPU,
+                              llvm::StringRef targetFeatures, bool softFloat,
+                              llvm::StringRef name, llvm::StringRef flags,
+                              bool relocPic, bool debug, unsigned optLevel);
+
+bool inlineEnabled();
+void setInlineEnabled(bool enabled);
+bool exceptionsEnabled();
+void setExceptionsEnabled(bool enabled);
+
+void initExternalTarget(string target);
 
-        void popDebugScope() {
-            debugScope.pop_back();
-        }
-    };
-
-    struct DebugLocationContext {
-        Location loc;
-        CodegenContext *ctx;
-
-        DebugLocationContext(Location const &loc, CodegenContext *ctx)
-            : loc(loc), ctx(ctx) {
-            if (loc.ok()) {
-                pushLocation(loc);
-                if (llvmDIBuilder != nullptr && ctx->inlineDepth == 0) {
-                    unsigned line, column;
-                    getDebugLineCol(loc, line, column);
-                    llvm::DebugLoc debugLoc = llvm::DebugLoc::get(line, column, ctx->getDebugScope());
-                    ctx->builder->SetCurrentDebugLocation(debugLoc);
-                }
+// codegen value
+struct CValue : public Object {
+    TypePtr type;
+    llvm::Value *llValue;
+    const bool forwardedRValue : 1;
+
+    CValue(TypePtr type, llvm::Value *llValue, bool forwardedRValue = false)
+        : Object(CVALUE), type(type), llValue(llValue),
+          forwardedRValue(forwardedRValue) {
+        llvmType(type); // force full definition of type
+    }
+};
+
+struct MultiCValue : public Object {
+    vector<CValuePtr> values;
+
+    MultiCValue() : Object(MULTI_CVALUE) {}
+
+    MultiCValue(CValuePtr pv) : Object(MULTI_CVALUE) { values.push_back(pv); }
+
+    MultiCValue(llvm::ArrayRef<CValuePtr> values)
+        : Object(MULTI_CVALUE), values(values) {}
+
+    size_t size() { return values.size(); }
+    void add(CValuePtr x) { values.push_back(x); }
+
+    void add(MultiCValuePtr x) {
+        values.insert(values.end(), x->values.begin(), x->values.end());
+    }
+
+    void toArgsKey(vector<TypePtr> *types) {
+        for (vector<CValuePtr>::const_iterator i = values.begin(),
+                                               end = values.end();
+             i != end; ++i) {
+            types->push_back((*i)->type);
+        }
+    }
+};
+
+struct JumpTarget {
+    llvm::BasicBlock *block;
+    size_t stackMarker;
+    int useCount;
+
+    JumpTarget() : block(nullptr), stackMarker(0), useCount(0) {}
+
+    JumpTarget(llvm::BasicBlock *block, size_t stackMarker)
+        : block(block), stackMarker(stackMarker), useCount(0) {}
+};
+
+struct CReturn {
+    TypePtr type;
+    CValuePtr value;
+    bool byRef : 1;
+
+    CReturn(bool byRef, TypePtr type, CValuePtr value)
+        : type(type), value(value), byRef(byRef) {}
+};
+
+struct StackSlot {
+    llvm::Type *llType;
+    llvm::Value *llValue;
+
+    StackSlot(llvm::Type *llType, llvm::Value *llValue)
+        : llType(llType), llValue(llValue) {}
+};
+
+enum ValueStackEntryType { LOCAL_VALUE, FINALLY_STATEMENT, ONERROR_STATEMENT };
+
+struct ValueStackEntry {
+    ValueStackEntryType type;
+    CValuePtr value;
+    EnvPtr statementEnv;
+    StatementPtr statement;
+
+    explicit ValueStackEntry(CValuePtr value)
+        : type(LOCAL_VALUE), value(value), statementEnv(nullptr),
+          statement(nullptr) {}
+
+    ValueStackEntry(ValueStackEntryType type, EnvPtr statementEnv,
+                    StatementPtr statement)
+        : type(type), value(nullptr), statementEnv(statementEnv),
+          statement(statement) {
+        assert(type != LOCAL_VALUE);
+    }
+};
+
+struct CodegenContext {
+    llvm::Function *llvmFunc;
+    vector<llvm::TrackingVH<llvm::MDNode>> debugScope;
+    std::unique_ptr<llvm::IRBuilder<>> initBuilder;
+    std::unique_ptr<llvm::IRBuilder<>> builder;
+
+    vector<ValueStackEntry> valueStack;
+    llvm::Value *valueForStatics;
+
+    vector<StackSlot> allocatedSlots;
+    vector<StackSlot> discardedSlots;
+
+    vector<vector<CReturn>> returnLists;
+    vector<JumpTarget> returnTargets;
+    llvm::StringMap<JumpTarget> labels;
+    vector<JumpTarget> breaks;
+    vector<JumpTarget> continues;
+    vector<JumpTarget> exceptionTargets;
+    llvm::Value *exceptionValue;
+    int inlineDepth; //: 31;
+    bool checkExceptions : 1;
+
+    int callByNameDepth;
+
+    CodegenContext()
+        : llvmFunc(nullptr), valueForStatics(nullptr), exceptionValue(nullptr),
+          inlineDepth(0), checkExceptions(true), callByNameDepth(0) {}
+
+    CodegenContext(llvm::Function *llvmFunc)
+        : llvmFunc(llvmFunc), valueForStatics(nullptr), exceptionValue(nullptr),
+          inlineDepth(0), checkExceptions(true), callByNameDepth(0) {}
+
+    llvm::DILexicalBlock getDebugScope() {
+        if (debugScope.empty())
+            return llvm::DILexicalBlock(nullptr);
+        else
+            return llvm::DILexicalBlock(debugScope.back());
+    }
+
+    void pushDebugScope(llvm::DILexicalBlock scope) {
+        debugScope.push_back((llvm::MDNode *)scope);
+    }
+
+    void popDebugScope() { debugScope.pop_back(); }
+};
+
+struct DebugLocationContext {
+    Location loc;
+    CodegenContext *ctx;
+
+    DebugLocationContext(Location const &loc, CodegenContext *ctx)
+        : loc(loc), ctx(ctx) {
+        if (loc.ok()) {
+            pushLocation(loc);
+            if (llvmDIBuilder != nullptr && ctx->inlineDepth == 0) {
+                unsigned line, column;
+                getDebugLineCol(loc, line, column);
+                llvm::DebugLoc debugLoc =
+                    llvm::DebugLoc::get(line, column, ctx->getDebugScope());
+                ctx->builder->SetCurrentDebugLocation(debugLoc);
             }
         }
+    }
 
-        ~DebugLocationContext() {
-            if (loc.ok()) {
-                popLocation();
-            }
+    ~DebugLocationContext() {
+        if (loc.ok()) {
+            popLocation();
         }
+    }
 
-    private :
-        DebugLocationContext(const DebugLocationContext &) {
-        }
+  private:
+    DebugLocationContext(const DebugLocationContext &) {}
 
-        void operator=(const DebugLocationContext &) {
-        }
-    };
+    void operator=(const DebugLocationContext &) {}
+};
 
-    void codegenGVarInstance(GVarInstancePtr x);
-    void codegenExternalVariable(ExternalVariablePtr x);
-    void codegenExternalProcedure(ExternalProcedurePtr x, bool codegenBody);
+void codegenGVarInstance(GVarInstancePtr x);
+void codegenExternalVariable(ExternalVariablePtr x);
+void codegenExternalProcedure(ExternalProcedurePtr x, bool codegenBody);
 
-    struct InvokeEntry;
+struct InvokeEntry;
 
-    InvokeEntry *codegenCallable(ObjectPtr x,
-                                 llvm::ArrayRef<PVData> args);
+InvokeEntry *codegenCallable(ObjectPtr x, llvm::ArrayRef<PVData> args);
 
-    void codegenCodeBody(InvokeEntry *entry);
-    void codegenCWrapper(InvokeEntry *entry);
+void codegenCodeBody(InvokeEntry *entry);
+void codegenCWrapper(InvokeEntry *entry);
 
-    void codegenCallValue(CValuePtr callable,
-                          MultiCValuePtr args,
-                          CodegenContext *ctx,
-                          MultiCValuePtr out);
-    void codegenCallValue(CValuePtr callable,
-                          MultiCValuePtr args,
-                          MultiPValuePtr pvArgs,
-                          CodegenContext *ctx,
-                          MultiCValuePtr out);
-    void codegenEntryPoints(ModulePtr module, bool importedExternals);
-    void codegenMain(ModulePtr module);
+void codegenCallValue(CValuePtr callable, MultiCValuePtr args,
+                      CodegenContext *ctx, MultiCValuePtr out);
+void codegenCallValue(CValuePtr callable, MultiCValuePtr args,
+                      MultiPValuePtr pvArgs, CodegenContext *ctx,
+                      MultiCValuePtr out);
+void codegenEntryPoints(ModulePtr module, bool importedExternals);
+void codegenMain(ModulePtr module);
 
-    void codegenBeforeRepl(ModulePtr module);
-    void codegenAfterRepl(llvm::Function *&ctor, llvm::Function *&dtor);
+void codegenBeforeRepl(ModulePtr module);
+void codegenAfterRepl(llvm::Function *&ctor, llvm::Function *&dtor);
 
-    void codegenValueForward(CValuePtr dest, CValuePtr src, CodegenContext *ctx);
-    void codegenStaticObject(ObjectPtr x,
-                             CodegenContext *ctx,
-                             MultiCValuePtr out);
+void codegenValueForward(CValuePtr dest, CValuePtr src, CodegenContext *ctx);
+void codegenStaticObject(ObjectPtr x, CodegenContext *ctx, MultiCValuePtr out);
 
-    llvm::Constant *valueHolderToLLVMConstant(ValueHolder *vh, CodegenContext *ctx);
-    CValuePtr staticCValue(ObjectPtr obj, CodegenContext *ctx);
+llvm::Constant *valueHolderToLLVMConstant(ValueHolder *vh, CodegenContext *ctx);
+CValuePtr staticCValue(ObjectPtr obj, CodegenContext *ctx);
 
-    std::string getCodeName(InvokeEntry *entry);
-}
+std::string getCodeName(InvokeEntry *entry);
+} // namespace clay
diff --git a/compiler/codegen_op.cpp b/compiler/codegen_op.cpp
index dbd5a8c3..5106cc4e 100644
--- a/compiler/codegen_op.cpp
+++ b/compiler/codegen_op.cpp
@@ -1,2335 +1,2310 @@
-#include "types.hpp"
-#include "error.hpp"
-#include "loader.hpp"
-#include "codegen.hpp"
-#include "objects.hpp"
-#include "evaluator.hpp"
+#include "codegen_op.hpp"
 #include "analyzer.hpp"
-#include "operators.hpp"
+#include "codegen.hpp"
 #include "constructors.hpp"
-#include "externals.hpp"
 #include "env.hpp"
-#include "codegen_op.hpp"
+#include "error.hpp"
+#include "evaluator.hpp"
+#include "externals.hpp"
 #include "invoketables.hpp"
+#include "loader.hpp"
+#include "objects.hpp"
+#include "operators.hpp"
+#include "types.hpp"
 
 namespace clay {
-    static llvm::StringMap<llvm::Constant *> stringTableConstants;
-
-    //
-    // valueToStatic, valueToStaticSizeTOrInt
-    // valueToType, valueToNumericType, valueToIntegerType,
-    // valueToPointerLikeType, valueToTupleType, valueToRecordType,
-    // valueToVariantType, valueToEnumType, valueToIdentifier
-    //
-
-    static ObjectPtr valueToStatic(CValuePtr cv) {
-        if (cv->type->typeKind != STATIC_TYPE)
-            return nullptr;
-        StaticType *st = (StaticType *) cv->type.ptr();
-        return st->obj;
-    }
-
-    static ObjectPtr valueToStatic(MultiCValuePtr args, unsigned index) {
-        ObjectPtr obj = valueToStatic(args->values[index]);
-        if (!obj)
-            argumentError(index, "expecting a static value");
-        return obj;
-    }
-
-    static size_t valueToStaticSizeTOrInt(MultiCValuePtr args, unsigned index) {
-        ObjectPtr obj = valueToStatic(args->values[index]);
-        if (!obj || (obj->objKind != VALUE_HOLDER))
-            argumentError(index, "expecting a static SizeT or Int value");
-        ValueHolder *vh = (ValueHolder *) obj.ptr();
-        if (vh->type == cSizeTType) {
-            return valueHolderToSizeT(vh);
-        } else if (vh->type == cIntType) {
-            return size_t(vh->as<int>());
-        } else {
-            argumentError(index, "expecting a static SizeT or Int value");
-            return 0;
-        }
+static llvm::StringMap<llvm::Constant *> stringTableConstants;
+
+//
+// valueToStatic, valueToStaticSizeTOrInt
+// valueToType, valueToNumericType, valueToIntegerType,
+// valueToPointerLikeType, valueToTupleType, valueToRecordType,
+// valueToVariantType, valueToEnumType, valueToIdentifier
+//
+
+static ObjectPtr valueToStatic(CValuePtr cv) {
+    if (cv->type->typeKind != STATIC_TYPE)
+        return nullptr;
+    StaticType *st = (StaticType *)cv->type.ptr();
+    return st->obj;
+}
+
+static ObjectPtr valueToStatic(MultiCValuePtr args, unsigned index) {
+    ObjectPtr obj = valueToStatic(args->values[index]);
+    if (!obj)
+        argumentError(index, "expecting a static value");
+    return obj;
+}
+
+static size_t valueToStaticSizeTOrInt(MultiCValuePtr args, unsigned index) {
+    ObjectPtr obj = valueToStatic(args->values[index]);
+    if (!obj || (obj->objKind != VALUE_HOLDER))
+        argumentError(index, "expecting a static SizeT or Int value");
+    ValueHolder *vh = (ValueHolder *)obj.ptr();
+    if (vh->type == cSizeTType) {
+        return valueHolderToSizeT(vh);
+    } else if (vh->type == cIntType) {
+        return size_t(vh->as<int>());
+    } else {
+        argumentError(index, "expecting a static SizeT or Int value");
+        return 0;
     }
+}
+
+static TypePtr valueToType(MultiCValuePtr args, unsigned index) {
+    ObjectPtr obj = valueToStatic(args->values[index]);
+    if (!obj || (obj->objKind != TYPE))
+        argumentError(index, "expecting a type");
+    return (Type *)obj.ptr();
+}
 
-    static TypePtr valueToType(MultiCValuePtr args, unsigned index) {
-        ObjectPtr obj = valueToStatic(args->values[index]);
-        if (!obj || (obj->objKind != TYPE))
-            argumentError(index, "expecting a type");
-        return (Type *) obj.ptr();
+static TypePtr valueToNumericType(MultiCValuePtr args, unsigned index) {
+    TypePtr t = valueToType(args, index);
+    switch (t->typeKind) {
+    case INTEGER_TYPE:
+    case FLOAT_TYPE:
+        return t;
+    default:
+        argumentTypeError(index, "numeric type", t);
+        return nullptr;
     }
+}
 
-    static TypePtr valueToNumericType(MultiCValuePtr args, unsigned index) {
-        TypePtr t = valueToType(args, index);
-        switch (t->typeKind) {
-            case INTEGER_TYPE:
-            case FLOAT_TYPE:
-                return t;
-            default:
-                argumentTypeError(index, "numeric type", t);
-                return nullptr;
+static IntegerTypePtr valueToIntegerType(MultiCValuePtr args, unsigned index) {
+    TypePtr t = valueToType(args, index);
+    if (t->typeKind != INTEGER_TYPE)
+        argumentTypeError(index, "integer type", t);
+    return (IntegerType *)t.ptr();
+}
+
+static TypePtr valueToPointerLikeType(MultiCValuePtr args, unsigned index) {
+    TypePtr t = valueToType(args, index);
+    if (!isPointerOrCodePointerType(t))
+        argumentTypeError(index, "pointer or code-pointer type", t);
+    return t;
+}
+
+static TupleTypePtr valueToTupleType(MultiCValuePtr args, unsigned index) {
+    TypePtr t = valueToType(args, index);
+    if (t->typeKind != TUPLE_TYPE)
+        argumentTypeError(index, "tuple type", t);
+    return (TupleType *)t.ptr();
+}
+
+static UnionTypePtr valueToUnionType(MultiCValuePtr args, unsigned index) {
+    TypePtr t = valueToType(args, index);
+    if (t->typeKind != UNION_TYPE)
+        argumentTypeError(index, "union type", t);
+    return (UnionType *)t.ptr();
+}
+
+static RecordTypePtr valueToRecordType(MultiCValuePtr args, unsigned index) {
+    TypePtr t = valueToType(args, index);
+    if (t->typeKind != RECORD_TYPE)
+        argumentTypeError(index, "record type", t);
+    return (RecordType *)t.ptr();
+}
+
+static VariantTypePtr valueToVariantType(MultiCValuePtr args, unsigned index) {
+    TypePtr t = valueToType(args, index);
+    if (t->typeKind != VARIANT_TYPE)
+        argumentTypeError(index, "variant type", t);
+    return (VariantType *)t.ptr();
+}
+
+static EnumTypePtr valueToEnumType(MultiCValuePtr args, unsigned index) {
+    TypePtr t = valueToType(args, index);
+    if (t->typeKind != ENUM_TYPE)
+        argumentTypeError(index, "enum type", t);
+    initializeEnumType((EnumType *)t.ptr());
+    return (EnumType *)t.ptr();
+}
+
+static IdentifierPtr valueToIdentifier(MultiCValuePtr args, unsigned index) {
+    ObjectPtr obj = valueToStatic(args->values[index]);
+    if (!obj || (obj->objKind != IDENTIFIER))
+        argumentError(index, "expecting identifier value");
+    return (Identifier *)obj.ptr();
+}
+
+static llvm::StringRef valueToStringRef(MultiCValuePtr args, unsigned index) {
+    return valueToIdentifier(args, index)->str;
+}
+
+//
+// numericValue, integerValue, pointerValue,
+// pointerLikeValue, cCodePointerValue,
+// arrayValue, tupleValue, recordValue, variantValue, enumValue
+//
+
+static llvm::Value *numericValue(MultiCValuePtr args, unsigned index,
+                                 TypePtr &type, CodegenContext *ctx) {
+    CValuePtr cv = args->values[index];
+    if (type.ptr()) {
+        if (cv->type != type)
+            argumentTypeError(index, type, cv->type);
+    } else {
+        switch (cv->type->typeKind) {
+        case INTEGER_TYPE:
+        case FLOAT_TYPE:
+            break;
+        default:
+            argumentTypeError(index, "numeric type", cv->type);
         }
+        type = cv->type;
     }
+    llvm::Type *llTy = llvmType(cv->type);
+    return ctx->builder->CreateLoad(llTy, cv->llValue);
+}
 
-    static IntegerTypePtr valueToIntegerType(MultiCValuePtr args, unsigned index) {
-        TypePtr t = valueToType(args, index);
-        if (t->typeKind != INTEGER_TYPE)
-            argumentTypeError(index, "integer type", t);
-        return (IntegerType *) t.ptr();
+static llvm::Value *floatValue(MultiCValuePtr args, unsigned index,
+                               FloatTypePtr &type, CodegenContext *ctx) {
+    CValuePtr cv = args->values[index];
+    if (type.ptr()) {
+        if (cv->type.ptr() != type.ptr())
+            argumentTypeError(index, type.ptr(), cv->type);
+    } else {
+        switch (cv->type->typeKind) {
+        case FLOAT_TYPE:
+            break;
+        default:
+            argumentTypeError(index, "float type", cv->type);
+        }
+        type = (FloatType *)cv->type.ptr();
     }
+    llvm::Type *llTy = llvmType(cv->type);
+    return ctx->builder->CreateLoad(llTy, cv->llValue);
+}
 
-    static TypePtr valueToPointerLikeType(MultiCValuePtr args, unsigned index) {
-        TypePtr t = valueToType(args, index);
-        if (!isPointerOrCodePointerType(t))
-            argumentTypeError(index, "pointer or code-pointer type", t);
-        return t;
+static llvm::Value *integerOrPointerLikeValue(MultiCValuePtr args,
+                                              unsigned index, TypePtr &type,
+                                              CodegenContext *ctx) {
+    CValuePtr cv = args->values[index];
+    if (type.ptr()) {
+        if (cv->type != type)
+            argumentTypeError(index, type, cv->type);
+    } else {
+        switch (cv->type->typeKind) {
+        case INTEGER_TYPE:
+        case POINTER_TYPE:
+        case CODE_POINTER_TYPE:
+        case CCODE_POINTER_TYPE:
+            break;
+        default:
+            argumentTypeError(index, "integer, pointer, or code pointer type",
+                              cv->type);
+        }
+        type = cv->type;
     }
+    llvm::Type *llTy = llvmType(cv->type);
+    return ctx->builder->CreateLoad(llTy, cv->llValue);
+}
 
-    static TupleTypePtr valueToTupleType(MultiCValuePtr args, unsigned index) {
-        TypePtr t = valueToType(args, index);
-        if (t->typeKind != TUPLE_TYPE)
-            argumentTypeError(index, "tuple type", t);
-        return (TupleType *) t.ptr();
+static void checkIntegerValue(MultiCValuePtr args, unsigned index,
+                              IntegerTypePtr &type, CodegenContext *ctx) {
+    CValuePtr cv = args->values[index];
+    if (type.ptr()) {
+        if (cv->type != type.ptr())
+            argumentTypeError(index, type.ptr(), cv->type);
+    } else {
+        if (cv->type->typeKind != INTEGER_TYPE)
+            argumentTypeError(index, "integer type", cv->type);
+        type = (IntegerType *)cv->type.ptr();
     }
+}
 
-    static UnionTypePtr valueToUnionType(MultiCValuePtr args, unsigned index) {
-        TypePtr t = valueToType(args, index);
-        if (t->typeKind != UNION_TYPE)
-            argumentTypeError(index, "union type", t);
-        return (UnionType *) t.ptr();
-    }
+static llvm::Value *integerValue(MultiCValuePtr args, unsigned index,
+                                 IntegerTypePtr &type, CodegenContext *ctx) {
+    checkIntegerValue(args, index, type, ctx);
+    CValuePtr cv = args->values[index];
+    llvm::Type *llTy = llvmType(cv->type);
+    return ctx->builder->CreateLoad(llTy, cv->llValue);
+}
 
-    static RecordTypePtr valueToRecordType(MultiCValuePtr args, unsigned index) {
-        TypePtr t = valueToType(args, index);
-        if (t->typeKind != RECORD_TYPE)
-            argumentTypeError(index, "record type", t);
-        return (RecordType *) t.ptr();
+static llvm::Value *pointerValue(MultiCValuePtr args, unsigned index,
+                                 PointerTypePtr &type, CodegenContext *ctx) {
+    CValuePtr cv = args->values[index];
+    if (type.ptr()) {
+        if (cv->type != (Type *)type.ptr())
+            argumentTypeError(index, type.ptr(), cv->type);
+    } else {
+        if (cv->type->typeKind != POINTER_TYPE)
+            argumentTypeError(index, "pointer type", cv->type);
+        type = (PointerType *)cv->type.ptr();
+        llvmType(type->pointeeType); // force the pointee type to be refined
     }
+    llvm::Type *llTy = llvmType(cv->type);
+    return ctx->builder->CreateLoad(llTy, cv->llValue);
+}
 
-    static VariantTypePtr valueToVariantType(MultiCValuePtr args, unsigned index) {
-        TypePtr t = valueToType(args, index);
-        if (t->typeKind != VARIANT_TYPE)
-            argumentTypeError(index, "variant type", t);
-        return (VariantType *) t.ptr();
+static llvm::Value *pointerLikeValue(MultiCValuePtr args, unsigned index,
+                                     TypePtr &type, CodegenContext *ctx) {
+    CValuePtr cv = args->values[index];
+    if (type.ptr()) {
+        if (cv->type != type)
+            argumentTypeError(index, type, cv->type);
+    } else {
+        if (!isPointerOrCodePointerType(cv->type))
+            argumentTypeError(index, "pointer or code-pointer type", cv->type);
+        type = cv->type;
     }
+    llvm::Type *llTy = llvmType(cv->type);
+    return ctx->builder->CreateLoad(llTy, cv->llValue);
+}
 
-    static EnumTypePtr valueToEnumType(MultiCValuePtr args, unsigned index) {
-        TypePtr t = valueToType(args, index);
-        if (t->typeKind != ENUM_TYPE)
-            argumentTypeError(index, "enum type", t);
-        initializeEnumType((EnumType *) t.ptr());
-        return (EnumType *) t.ptr();
+static llvm::Value *cCodePointerValue(MultiCValuePtr args, unsigned index,
+                                      CCodePointerTypePtr &type) {
+    CValuePtr cv = args->values[index];
+    if (type.ptr()) {
+        if (cv->type != (Type *)type.ptr())
+            argumentTypeError(index, type.ptr(), cv->type);
+    } else {
+        if (cv->type->typeKind != CCODE_POINTER_TYPE)
+            argumentTypeError(index, "c code pointer type", cv->type);
+        type = (CCodePointerType *)cv->type.ptr();
     }
+    return cv->llValue;
+}
 
-    static IdentifierPtr valueToIdentifier(MultiCValuePtr args, unsigned index) {
-        ObjectPtr obj = valueToStatic(args->values[index]);
-        if (!obj || (obj->objKind != IDENTIFIER))
-            argumentError(index, "expecting identifier value");
-        return (Identifier *) obj.ptr();
+static llvm::Value *arrayValue(MultiCValuePtr args, unsigned index,
+                               ArrayTypePtr &type) {
+    CValuePtr cv = args->values[index];
+    if (type.ptr()) {
+        if (cv->type != (Type *)type.ptr())
+            argumentTypeError(index, type.ptr(), cv->type);
+    } else {
+        if (cv->type->typeKind != ARRAY_TYPE)
+            argumentTypeError(index, "array type", cv->type);
+        type = (ArrayType *)cv->type.ptr();
     }
+    return cv->llValue;
+}
 
-    static llvm::StringRef valueToStringRef(MultiCValuePtr args, unsigned index) {
-        return valueToIdentifier(args, index)->str;
+static llvm::Value *tupleValue(MultiCValuePtr args, unsigned index,
+                               TupleTypePtr &type) {
+    CValuePtr cv = args->values[index];
+    if (type.ptr()) {
+        if (cv->type != (Type *)type.ptr())
+            argumentTypeError(index, type.ptr(), cv->type);
+    } else {
+        if (cv->type->typeKind != TUPLE_TYPE)
+            argumentTypeError(index, "tuple type", cv->type);
+        type = (TupleType *)cv->type.ptr();
     }
+    return cv->llValue;
+}
 
-    //
-    // numericValue, integerValue, pointerValue,
-    // pointerLikeValue, cCodePointerValue,
-    // arrayValue, tupleValue, recordValue, variantValue, enumValue
-    //
-
-    static llvm::Value *numericValue(MultiCValuePtr args,
-                                     unsigned index,
-                                     TypePtr &type,
-                                     CodegenContext *ctx) {
-        CValuePtr cv = args->values[index];
-        if (type.ptr()) {
-            if (cv->type != type)
-                argumentTypeError(index, type, cv->type);
-        } else {
-            switch (cv->type->typeKind) {
-                case INTEGER_TYPE:
-                case FLOAT_TYPE:
-                    break;
-                default:
-                    argumentTypeError(index, "numeric type", cv->type);
-            }
-            type = cv->type;
-        }
-        llvm::Type *llTy = llvmType(cv->type);
-        return ctx->builder->CreateLoad(llTy, cv->llValue);
-    }
-
-    static llvm::Value *floatValue(MultiCValuePtr args,
-                                   unsigned index,
-                                   FloatTypePtr &type,
-                                   CodegenContext *ctx) {
-        CValuePtr cv = args->values[index];
-        if (type.ptr()) {
-            if (cv->type.ptr() != type.ptr())
-                argumentTypeError(index, type.ptr(), cv->type);
-        } else {
-            switch (cv->type->typeKind) {
-                case FLOAT_TYPE:
-                    break;
-                default:
-                    argumentTypeError(index, "float type", cv->type);
-            }
-            type = (FloatType *) cv->type.ptr();
-        }
-        llvm::Type *llTy = llvmType(cv->type);
-        return ctx->builder->CreateLoad(llTy, cv->llValue);
-    }
-
-    static llvm::Value *integerOrPointerLikeValue(MultiCValuePtr args,
-                                                  unsigned index,
-                                                  TypePtr &type,
-                                                  CodegenContext *ctx) {
-        CValuePtr cv = args->values[index];
-        if (type.ptr()) {
-            if (cv->type != type)
-                argumentTypeError(index, type, cv->type);
-        } else {
-            switch (cv->type->typeKind) {
-                case INTEGER_TYPE:
-                case POINTER_TYPE:
-                case CODE_POINTER_TYPE:
-                case CCODE_POINTER_TYPE:
-                    break;
-                default:
-                    argumentTypeError(index, "integer, pointer, or code pointer type", cv->type);
-            }
-            type = cv->type;
-        }
-        llvm::Type *llTy = llvmType(cv->type);
-        return ctx->builder->CreateLoad(llTy, cv->llValue);
-    }
-
-    static void checkIntegerValue(MultiCValuePtr args,
-                                  unsigned index,
-                                  IntegerTypePtr &type,
-                                  CodegenContext *ctx) {
-        CValuePtr cv = args->values[index];
-        if (type.ptr()) {
-            if (cv->type != type.ptr())
-                argumentTypeError(index, type.ptr(), cv->type);
-        } else {
-            if (cv->type->typeKind != INTEGER_TYPE)
-                argumentTypeError(index, "integer type", cv->type);
-            type = (IntegerType *) cv->type.ptr();
-        }
+static llvm::Value *recordValue(MultiCValuePtr args, unsigned index,
+                                RecordTypePtr &type) {
+    CValuePtr cv = args->values[index];
+    if (type.ptr()) {
+        if (cv->type != (Type *)type.ptr())
+            argumentTypeError(index, type.ptr(), cv->type);
+    } else {
+        if (cv->type->typeKind != RECORD_TYPE)
+            argumentTypeError(index, "record type", cv->type);
+        type = (RecordType *)cv->type.ptr();
     }
+    return cv->llValue;
+}
 
-    static llvm::Value *integerValue(MultiCValuePtr args,
-                                     unsigned index,
-                                     IntegerTypePtr &type,
-                                     CodegenContext *ctx) {
-        checkIntegerValue(args, index, type, ctx);
-        CValuePtr cv = args->values[index];
-        llvm::Type *llTy = llvmType(cv->type);
-        return ctx->builder->CreateLoad(llTy, cv->llValue);
-    }
-
-    static llvm::Value *pointerValue(MultiCValuePtr args,
-                                     unsigned index,
-                                     PointerTypePtr &type,
-                                     CodegenContext *ctx) {
-        CValuePtr cv = args->values[index];
-        if (type.ptr()) {
-            if (cv->type != (Type *) type.ptr())
-                argumentTypeError(index, type.ptr(), cv->type);
-        } else {
-            if (cv->type->typeKind != POINTER_TYPE)
-                argumentTypeError(index, "pointer type", cv->type);
-            type = (PointerType *) cv->type.ptr();
-            llvmType(type->pointeeType); // force the pointee type to be refined
-        }
-        llvm::Type *llTy = llvmType(cv->type);
-        return ctx->builder->CreateLoad(llTy, cv->llValue);
-    }
-
-    static llvm::Value *pointerLikeValue(MultiCValuePtr args,
-                                         unsigned index,
-                                         TypePtr &type,
-                                         CodegenContext *ctx) {
-        CValuePtr cv = args->values[index];
-        if (type.ptr()) {
-            if (cv->type != type)
-                argumentTypeError(index, type, cv->type);
-        } else {
-            if (!isPointerOrCodePointerType(cv->type))
-                argumentTypeError(index,
-                                  "pointer or code-pointer type",
-                                  cv->type);
-            type = cv->type;
-        }
-        llvm::Type *llTy = llvmType(cv->type);
-        return ctx->builder->CreateLoad(llTy, cv->llValue);
+static llvm::Value *enumValue(MultiCValuePtr args, unsigned index,
+                              EnumTypePtr &type, CodegenContext *ctx) {
+    CValuePtr cv = args->values[index];
+    if (type.ptr()) {
+        if (cv->type != (Type *)type.ptr())
+            argumentTypeError(index, type.ptr(), cv->type);
+    } else {
+        if (cv->type->typeKind != ENUM_TYPE)
+            argumentTypeError(index, "enum type", cv->type);
+        type = (EnumType *)cv->type.ptr();
     }
+    llvm::Type *llTy = llvmType(cv->type);
+    return ctx->builder->CreateLoad(llTy, cv->llValue);
+}
 
-    static llvm::Value *cCodePointerValue(MultiCValuePtr args,
-                                          unsigned index,
-                                          CCodePointerTypePtr &type) {
-        CValuePtr cv = args->values[index];
-        if (type.ptr()) {
-            if (cv->type != (Type *) type.ptr())
-                argumentTypeError(index, type.ptr(), cv->type);
-        } else {
-            if (cv->type->typeKind != CCODE_POINTER_TYPE)
-                argumentTypeError(index, "c code pointer type", cv->type);
-            type = (CCodePointerType *) cv->type.ptr();
+llvm::AtomicOrdering atomicOrderValue(MultiCValuePtr args, unsigned index) {
+    CValuePtr cv = args->values[index];
+    ObjectPtr obj = unwrapStaticType(cv->type);
+    if (obj != nullptr && obj->objKind == PRIM_OP) {
+        PrimOp *prim = (PrimOp *)obj.ptr();
+        switch (prim->primOpCode) {
+        case PRIM_OrderUnordered:
+            return llvm::AtomicOrdering::Unordered;
+        case PRIM_OrderMonotonic:
+            return llvm::AtomicOrdering::Monotonic;
+        case PRIM_OrderAcquire:
+            return llvm::AtomicOrdering::Acquire;
+        case PRIM_OrderRelease:
+            return llvm::AtomicOrdering::Release;
+        case PRIM_OrderAcqRel:
+            return llvm::AtomicOrdering::AcquireRelease;
+        case PRIM_OrderSeqCst:
+            return llvm::AtomicOrdering::SequentiallyConsistent;
         }
-        return cv->llValue;
     }
+    argumentTypeError(index, "atomic ordering", cv->type);
+    return llvm::AtomicOrdering::Unordered;
+}
 
-    static llvm::Value *arrayValue(MultiCValuePtr args,
-                                   unsigned index,
-                                   ArrayTypePtr &type) {
-        CValuePtr cv = args->values[index];
-        if (type.ptr()) {
-            if (cv->type != (Type *) type.ptr())
-                argumentTypeError(index, type.ptr(), cv->type);
-        } else {
-            if (cv->type->typeKind != ARRAY_TYPE)
-                argumentTypeError(index, "array type", cv->type);
-            type = (ArrayType *) cv->type.ptr();
+llvm::AtomicRMWInst::BinOp atomicRMWOpValue(MultiCValuePtr args,
+                                            unsigned index) {
+    CValuePtr cv = args->values[index];
+    ObjectPtr obj = unwrapStaticType(cv->type);
+    if (obj != nullptr && obj->objKind == PRIM_OP) {
+        PrimOp *prim = (PrimOp *)obj.ptr();
+        switch (prim->primOpCode) {
+        case PRIM_RMWXchg:
+            return llvm::AtomicRMWInst::Xchg;
+        case PRIM_RMWAdd:
+            return llvm::AtomicRMWInst::Add;
+        case PRIM_RMWSubtract:
+            return llvm::AtomicRMWInst::Sub;
+        case PRIM_RMWAnd:
+            return llvm::AtomicRMWInst::And;
+        case PRIM_RMWNAnd:
+            return llvm::AtomicRMWInst::Nand;
+        case PRIM_RMWOr:
+            return llvm::AtomicRMWInst::Or;
+        case PRIM_RMWXor:
+            return llvm::AtomicRMWInst::Xor;
+        case PRIM_RMWMin:
+            return llvm::AtomicRMWInst::Min;
+        case PRIM_RMWMax:
+            return llvm::AtomicRMWInst::Max;
+        case PRIM_RMWUMin:
+            return llvm::AtomicRMWInst::UMin;
+        case PRIM_RMWUMax:
+            return llvm::AtomicRMWInst::UMax;
         }
-        return cv->llValue;
     }
+    argumentTypeError(index, "atomic rmw operation", cv->type);
+    return llvm::AtomicRMWInst::Xchg;
+}
 
-    static llvm::Value *tupleValue(MultiCValuePtr args,
-                                   unsigned index,
-                                   TupleTypePtr &type) {
-        CValuePtr cv = args->values[index];
-        if (type.ptr()) {
-            if (cv->type != (Type *) type.ptr())
-                argumentTypeError(index, type.ptr(), cv->type);
-        } else {
-            if (cv->type->typeKind != TUPLE_TYPE)
-                argumentTypeError(index, "tuple type", cv->type);
-            type = (TupleType *) cv->type.ptr();
-        }
-        return cv->llValue;
+//
+// codegenPrimOp
+//
+
+static llvm::Constant *codegenStringTableConstant(llvm::StringRef s) {
+    llvm::StringMap<llvm::Constant *>::const_iterator oldConstant =
+        stringTableConstants.find(s);
+    if (oldConstant != stringTableConstants.end())
+        return oldConstant->second;
+
+    llvm::Constant *sizeInitializer =
+        llvm::ConstantInt::get(llvmType(cSizeTType), s.size(), false);
+    llvm::Constant *stringInitializer =
+        llvm::ConstantDataArray::getString(llvmContext, s, true);
+    llvm::Constant *structEntries[] = {sizeInitializer, stringInitializer};
+    llvm::Constant *initializer =
+        llvm::ConstantStruct::getAnon(llvmContext, structEntries, false);
+
+    llvm::SmallString<128> buf;
+    llvm::raw_svector_ostream symbolName(buf);
+    symbolName << "\"" << s << "\" clay";
+
+    llvm::GlobalVariable *gvar = new llvm::GlobalVariable(
+        *llvmModule, initializer->getType(), true,
+        llvm::GlobalVariable::PrivateLinkage, initializer, symbolName.str());
+    llvm::Constant *idxs[] = {
+        llvm::ConstantInt::get(llvmType(int32Type), 0),
+        llvm::ConstantInt::get(llvmType(int32Type), 0),
+    };
+
+    llvm::Constant *theConstant =
+        llvm::ConstantExpr::getGetElementPtr(gvar, idxs);
+    stringTableConstants[s] = theConstant;
+    return theConstant;
+}
+
+//
+// codegenCWrapper
+//
+
+static void codegenCWrapper(InvokeEntry *entry, CallingConv cc) {
+    assert(!entry->llvmCWrappers[cc]);
+    ExternalTargetPtr target = getExternalTarget();
+
+    string callableName = getCodeName(entry);
+
+    TypePtr returnType;
+    if (entry->returnTypes.empty()) {
+        returnType = nullptr;
+    } else {
+        assert(entry->returnTypes.size() == 1);
+        assert(!entry->returnIsRef[0]);
+        returnType = entry->returnTypes[0];
     }
 
-    static llvm::Value *recordValue(MultiCValuePtr args,
-                                    unsigned index,
-                                    RecordTypePtr &type) {
-        CValuePtr cv = args->values[index];
-        if (type.ptr()) {
-            if (cv->type != (Type *) type.ptr())
-                argumentTypeError(index, type.ptr(), cv->type);
-        } else {
-            if (cv->type->typeKind != RECORD_TYPE)
-                argumentTypeError(index, "record type", cv->type);
-            type = (RecordType *) cv->type.ptr();
-        }
-        return cv->llValue;
+    ExternalFunction *extFunc = target->getExternalFunction(
+        cc, returnType, entry->argsKey, entry->argsKey.size(), false);
+
+    llvm::FunctionType *llFuncType = extFunc->getLLVMFunctionType();
+
+    std::string ccName;
+    switch (cc) {
+    case CC_DEFAULT:
+        ccName = "cdecl ";
+        break;
+    case CC_STDCALL:
+        ccName = "stdcall ";
+        break;
+    case CC_FASTCALL:
+        ccName = "fastcall ";
+        break;
+    case CC_THISCALL:
+        ccName = "thiscall ";
+        break;
+    default:
+        assert(false);
     }
 
-    static llvm::Value *enumValue(MultiCValuePtr args,
-                                  unsigned index,
-                                  EnumTypePtr &type,
-                                  CodegenContext *ctx) {
-        CValuePtr cv = args->values[index];
-        if (type.ptr()) {
-            if (cv->type != (Type *) type.ptr())
-                argumentTypeError(index, type.ptr(), cv->type);
-        } else {
-            if (cv->type->typeKind != ENUM_TYPE)
-                argumentTypeError(index, "enum type", cv->type);
-            type = (EnumType *) cv->type.ptr();
-        }
-        llvm::Type *llTy = llvmType(cv->type);
-        return ctx->builder->CreateLoad(llTy, cv->llValue);
-    }
-
-    llvm::AtomicOrdering atomicOrderValue(MultiCValuePtr args, unsigned index) {
-        CValuePtr cv = args->values[index];
-        ObjectPtr obj = unwrapStaticType(cv->type);
-        if (obj != nullptr && obj->objKind == PRIM_OP) {
-            PrimOp *prim = (PrimOp *) obj.ptr();
-            switch (prim->primOpCode) {
-                case PRIM_OrderUnordered:
-                    return llvm::AtomicOrdering::Unordered;
-                case PRIM_OrderMonotonic:
-                    return llvm::AtomicOrdering::Monotonic;
-                case PRIM_OrderAcquire:
-                    return llvm::AtomicOrdering::Acquire;
-                case PRIM_OrderRelease:
-                    return llvm::AtomicOrdering::Release;
-                case PRIM_OrderAcqRel:
-                    return llvm::AtomicOrdering::AcquireRelease;
-                case PRIM_OrderSeqCst:
-                    return llvm::AtomicOrdering::SequentiallyConsistent;
-            }
-        }
-        argumentTypeError(index, "atomic ordering", cv->type);
-        return llvm::AtomicOrdering::Unordered;
-    }
-
-    llvm::AtomicRMWInst::BinOp atomicRMWOpValue(MultiCValuePtr args, unsigned index) {
-        CValuePtr cv = args->values[index];
-        ObjectPtr obj = unwrapStaticType(cv->type);
-        if (obj != nullptr && obj->objKind == PRIM_OP) {
-            PrimOp *prim = (PrimOp *) obj.ptr();
-            switch (prim->primOpCode) {
-                case PRIM_RMWXchg:
-                    return llvm::AtomicRMWInst::Xchg;
-                case PRIM_RMWAdd:
-                    return llvm::AtomicRMWInst::Add;
-                case PRIM_RMWSubtract:
-                    return llvm::AtomicRMWInst::Sub;
-                case PRIM_RMWAnd:
-                    return llvm::AtomicRMWInst::And;
-                case PRIM_RMWNAnd:
-                    return llvm::AtomicRMWInst::Nand;
-                case PRIM_RMWOr:
-                    return llvm::AtomicRMWInst::Or;
-                case PRIM_RMWXor:
-                    return llvm::AtomicRMWInst::Xor;
-                case PRIM_RMWMin:
-                    return llvm::AtomicRMWInst::Min;
-                case PRIM_RMWMax:
-                    return llvm::AtomicRMWInst::Max;
-                case PRIM_RMWUMin:
-                    return llvm::AtomicRMWInst::UMin;
-                case PRIM_RMWUMax:
-                    return llvm::AtomicRMWInst::UMax;
-            }
-        }
-        argumentTypeError(index, "atomic rmw operation", cv->type);
-        return llvm::AtomicRMWInst::Xchg;
+    llvm::Function *llCWrapper =
+        llvm::Function::Create(llFuncType, llvm::Function::InternalLinkage,
+                               ccName + callableName, llvmModule);
+
+    // #include <llvm/IR/Function.h>
+    // #include <llvm/IR/Attributes.h>
+    // std::vector<std::pair<unsigned, llvm::Attribute>> attrs;
+    // for (const auto &attr : extFunc->attrs)
+    //     llCWrapper->addAttribute(attr.first, attr.second);
+
+    // for (vector<pair<unsigned, llvm::Attributes> >::const_iterator
+    //      attr = extFunc->attrs.begin();
+    //      attr != extFunc->attrs.end();
+    //      ++attr)
+    //     llCWrapper->addAttribute(attr->first, attr->second);
+
+    llCWrapper->setCallingConv(extFunc->llConv);
+
+    entry->llvmCWrappers[cc] = llCWrapper;
+    CodegenContext ctx(llCWrapper);
+
+    llvm::BasicBlock *llInitBlock =
+        llvm::BasicBlock::Create(llvmContext, "init", llCWrapper);
+    llvm::BasicBlock *llBlock =
+        llvm::BasicBlock::Create(llvmContext, "code", llCWrapper);
+    ctx.initBuilder.reset(new llvm::IRBuilder<>(llInitBlock));
+    ctx.builder.reset(new llvm::IRBuilder<>(llBlock));
+
+    ctx.exceptionValue = ctx.initBuilder->CreateAlloca(exceptionReturnType(),
+                                                       nullptr, "exception");
+
+    vector<llvm::Value *> innerArgs;
+    vector<CReturn> returns;
+    llvm::Function::arg_iterator ai = llCWrapper->arg_begin();
+    extFunc->allocReturnValue(extFunc->retInfo, ai, returns, &ctx);
+    for (size_t i = 0; i < entry->argsKey.size(); ++i) {
+        CValuePtr cv =
+            extFunc->allocArgumentValue(extFunc->argInfos[i], "x", ai, &ctx);
+        innerArgs.push_back(cv->llValue);
     }
 
-    //
-    // codegenPrimOp
-    //
+    for (vector<CReturn>::const_iterator ret = returns.begin();
+         ret != returns.end(); ++ret)
+        innerArgs.push_back(ret->value->llValue);
 
-    static llvm::Constant *codegenStringTableConstant(llvm::StringRef s) {
-        llvm::StringMap<llvm::Constant *>::const_iterator oldConstant = stringTableConstants.find(s);
-        if (oldConstant != stringTableConstants.end())
-            return oldConstant->second;
+    // XXX check exception
+    ctx.builder->CreateCall(entry->llvmFunc, llvm::ArrayRef(innerArgs));
 
-        llvm::Constant *sizeInitializer =
-                llvm::ConstantInt::get(llvmType(cSizeTType), s.size(), false);
-        llvm::Constant *stringInitializer =
-                llvm::ConstantDataArray::getString(llvmContext, s, true);
-        llvm::Constant *structEntries[] = {sizeInitializer, stringInitializer};
-        llvm::Constant *initializer =
-                llvm::ConstantStruct::getAnon(llvmContext,
-                                              structEntries,
-                                              false);
+    extFunc->returnStatement(extFunc->retInfo, returns, &ctx);
 
-        llvm::SmallString<128> buf;
-        llvm::raw_svector_ostream symbolName(buf);
-        symbolName << "\"" << s << "\" clay";
+    ctx.initBuilder->CreateBr(llBlock);
+}
+
+//
+// codegenCallCCode, codegenCallCCodePointer
+//
 
-        llvm::GlobalVariable *gvar = new llvm::GlobalVariable(
-            *llvmModule, initializer->getType(), true,
-            llvm::GlobalVariable::PrivateLinkage,
-            initializer, symbolName.str());
-        llvm::Constant *idxs[] = {
-            llvm::ConstantInt::get(llvmType(int32Type), 0),
-            llvm::ConstantInt::get(llvmType(int32Type), 0),
-        };
+static void codegenCallCCode(CCodePointerTypePtr t, llvm::Value *llCallable,
+                             MultiCValuePtr args, CodegenContext *ctx,
+                             MultiCValuePtr out) {
+    ExternalTargetPtr target = getExternalTarget();
 
-        llvm::Constant *theConstant = llvm::ConstantExpr::getGetElementPtr(gvar, idxs);
-        stringTableConstants[s] = theConstant;
-        return theConstant;
+    if (!t->hasVarArgs)
+        ensureArity(args, t->argTypes.size());
+    else if (args->size() < t->argTypes.size())
+        arityError2(t->argTypes.size(), args->size());
+
+    vector<TypePtr> argTypes;
+    for (size_t i = 0; i < args->size(); ++i) {
+        CValuePtr cv = args->values[i];
+        argTypes.push_back(cv->type);
     }
 
-    //
-    // codegenCWrapper
-    //
+    ExternalFunction *extFunc =
+        target->getExternalFunction(t->callingConv, t->returnType, argTypes,
+                                    t->argTypes.size(), t->hasVarArgs);
+
+    vector<llvm::Value *> llArgs;
+    extFunc->loadStructRetArgument(extFunc->retInfo, llArgs, ctx, out);
+    for (unsigned i = 0; i < t->argTypes.size(); ++i) {
+        CValuePtr cv = args->values[i];
+        if (cv->type != t->argTypes[i])
+            argumentTypeError(i, t->argTypes[i], cv->type);
+        extFunc->loadArgument(extFunc->argInfos[i], cv, llArgs, ctx, false);
+    }
+    if (t->hasVarArgs) {
+        for (size_t i = t->argTypes.size(); i < args->size(); ++i) {
+            CValuePtr cv = args->values[i];
+            extFunc->loadArgument(extFunc->argInfos[i], cv, llArgs, ctx, true);
+        }
+    }
+    llvm::Value *llCastCallable =
+        t->callingConv == CC_LLVM
+            ? llCallable
+            : ctx->builder->CreateBitCast(llCallable, t->getCallType());
+    llvm::CallInst *callInst =
+        ctx->builder->CreateCall(llCastCallable, llvm::ArrayRef(llArgs));
+    llvm::CallingConv::ID callingConv = extFunc->llConv;
+    callInst->setCallingConv(callingConv);
+    for (vector<pair<unsigned, llvm::Attributes>>::iterator attr =
+             extFunc->attrs.begin();
+         attr != extFunc->attrs.end(); ++attr)
+        callInst->addAttribute(attr->first, attr->second);
+
+    llvm::Value *llRet = callInst;
+    extFunc->storeReturnValue(extFunc->retInfo, llRet, ctx, out);
+}
 
-    static void codegenCWrapper(InvokeEntry *entry, CallingConv cc) {
-        assert(!entry->llvmCWrappers[cc]);
-        ExternalTargetPtr target = getExternalTarget();
+static void codegenCallCCodePointer(CValuePtr x, MultiCValuePtr args,
+                                    CodegenContext *ctx, MultiCValuePtr out) {
+    llvm::Value *llCallable = ctx->builder->CreateLoad(x->llValue);
+    assert(x->type->typeKind == CCODE_POINTER_TYPE);
+    CCodePointerType *t = (CCodePointerType *)x->type.ptr();
+    codegenCallCCode(t, llCallable, args, ctx, out);
+}
 
-        string callableName = getCodeName(entry);
+void codegenPrimOp(PrimOpPtr x, MultiCValuePtr args, CodegenContext *ctx,
+                   MultiCValuePtr out) {
+    switch (x->primOpCode) {
+    case PRIM_TypeP: {
+        ensureArity(args, 1);
+        ObjectPtr obj = valueToStatic(args->values[0]);
+        bool isType = (obj.ptr() && (obj->objKind == TYPE));
+        ValueHolderPtr vh = boolToValueHolder(isType);
+        codegenStaticObject(vh.ptr(), ctx, out);
+        break;
+    }
 
-        TypePtr returnType;
-        if (entry->returnTypes.empty()) {
-            returnType = nullptr;
-        } else {
-            assert(entry->returnTypes.size() == 1);
-            assert(!entry->returnIsRef[0]);
-            returnType = entry->returnTypes[0];
-        }
+    case PRIM_TypeSize: {
+        ensureArity(args, 1);
+        TypePtr t = valueToType(args, 0);
+        ValueHolderPtr vh = sizeTToValueHolder(typeSize(t));
+        codegenStaticObject(vh.ptr(), ctx, out);
+        break;
+    }
 
-        ExternalFunction *extFunc = target->getExternalFunction(
-            cc, returnType, entry->argsKey, entry->argsKey.size(), false);
+    case PRIM_TypeAlignment: {
+        ensureArity(args, 1);
+        TypePtr t = valueToType(args, 0);
+        ValueHolderPtr vh = sizeTToValueHolder(typeAlignment(t));
+        codegenStaticObject(vh.ptr(), ctx, out);
+        break;
+    }
 
-        llvm::FunctionType *llFuncType = extFunc->getLLVMFunctionType();
+    case PRIM_OperatorP: {
+        ensureArity(args, 1);
+        ObjectPtr obj = valueToStatic(args->values[0]);
+        bool isOperator = false;
+        if (!!obj.ptr() &&
+            (obj->objKind == PROCEDURE || obj->objKind == GLOBAL_ALIAS)) {
+            TopLevelItem *item = (TopLevelItem *)obj.ptr();
+            isOperator = item->name->isOperator;
+        }
+        ValueHolderPtr vh = boolToValueHolder(isOperator);
+        codegenStaticObject(vh.ptr(), ctx, out);
+        break;
+    }
 
-        std::string ccName;
-        switch (cc) {
-            case CC_DEFAULT:
-                ccName = "cdecl ";
-                break;
-            case CC_STDCALL:
-                ccName = "stdcall ";
-                break;
-            case CC_FASTCALL:
-                ccName = "fastcall ";
-                break;
-            case CC_THISCALL:
-                ccName = "thiscall ";
+    case PRIM_SymbolP: {
+        ensureArity(args, 1);
+        ObjectPtr obj = valueToStatic(args->values[0]);
+        bool isSymbol = false;
+        if (obj.ptr() != nullptr) {
+            switch (obj->objKind) {
+            case TYPE:
+            case RECORD_DECL:
+            case VARIANT_DECL:
+            case PROCEDURE:
+            case INTRINSIC:
+            case GLOBAL_ALIAS:
+                isSymbol = true;
                 break;
             default:
-                assert(false);
+                break;
+            }
         }
+        ValueHolderPtr vh = boolToValueHolder(isSymbol);
+        codegenStaticObject(vh.ptr(), ctx, out);
+        break;
+    }
 
-        llvm::Function *llCWrapper =
-                llvm::Function::Create(llFuncType,
-                                       llvm::Function::InternalLinkage,
-                                       ccName + callableName,
-                                       llvmModule);
-        for (vector<pair<unsigned, llvm::Attributes> >::const_iterator
-             attr = extFunc->attrs.begin();
-             attr != extFunc->attrs.end();
-             ++attr)
-            llCWrapper->addAttribute(attr->first, attr->second);
-
-        llCWrapper->setCallingConv(extFunc->llConv);
-
-        entry->llvmCWrappers[cc] = llCWrapper;
-        CodegenContext ctx(llCWrapper);
-
-        llvm::BasicBlock *llInitBlock =
-                llvm::BasicBlock::Create(llvmContext,
-                                         "init",
-                                         llCWrapper);
-        llvm::BasicBlock *llBlock =
-                llvm::BasicBlock::Create(llvmContext,
-                                         "code",
-                                         llCWrapper);
-        ctx.initBuilder.reset(new llvm::IRBuilder<>(llInitBlock));
-        ctx.builder.reset(new llvm::IRBuilder<>(llBlock));
-
-        ctx.exceptionValue = ctx.initBuilder->CreateAlloca(exceptionReturnType(), nullptr, "exception");
-
-        vector<llvm::Value *> innerArgs;
-        vector<CReturn> returns;
-        llvm::Function::arg_iterator ai = llCWrapper->arg_begin();
-        extFunc->allocReturnValue(extFunc->retInfo, ai, returns, &ctx);
-        for (size_t i = 0; i < entry->argsKey.size(); ++i) {
-            CValuePtr cv = extFunc->allocArgumentValue(
-                extFunc->argInfos[i], "x", ai, &ctx);
-            innerArgs.push_back(cv->llValue);
+    case PRIM_StaticCallDefinedP: {
+        if (args->size() < 1)
+            arityError2(1, args->size());
+        ObjectPtr callable = valueToStatic(args->values[0]);
+        if (!callable) {
+            argumentError(0, "static callable expected");
+        }
+        switch (callable->objKind) {
+        case TYPE:
+        case RECORD_DECL:
+        case VARIANT_DECL:
+        case PROCEDURE:
+        case INTRINSIC:
+        case GLOBAL_ALIAS:
+            break;
+        default:
+            argumentError(0, "invalid callable");
+        }
+        vector<PVData> argsPVData;
+        for (unsigned i = 1; i < args->size(); ++i) {
+            TypePtr t = valueToType(args, i);
+            argsPVData.push_back(PVData(t, false));
         }
+        CompileContextPusher pusher(callable, argsPVData);
+        bool isDefined = analyzeIsDefined(callable, argsPVData);
+        ValueHolderPtr vh = boolToValueHolder(isDefined);
+        codegenStaticObject(vh.ptr(), ctx, out);
+        break;
+    }
 
-        for (vector<CReturn>::const_iterator ret = returns.begin();
-             ret != returns.end();
-             ++ret)
-            innerArgs.push_back(ret->value->llValue);
+    case PRIM_StaticCallOutputTypes:
+        break;
 
-        // XXX check exception
-        ctx.builder->CreateCall(entry->llvmFunc, llvm::ArrayRef(innerArgs));
+    case PRIM_StaticMonoP: {
+        ensureArity(args, 1);
 
-        extFunc->returnStatement(extFunc->retInfo, returns, &ctx);
+        bool isMono;
 
-        ctx.initBuilder->CreateBr(llBlock);
-    }
+        ObjectPtr callable = valueToStatic(args->values[0]);
+        if (callable != nullptr && callable->objKind == PROCEDURE) {
+            Procedure *p = (Procedure *)callable.ptr();
+            isMono = p->mono.monoState == Procedure_MonoOverload;
+        } else
+            isMono = false;
 
-    //
-    // codegenCallCCode, codegenCallCCodePointer
-    //
+        ValueHolderPtr vh = boolToValueHolder(isMono);
+        codegenStaticObject(vh.ptr(), ctx, out);
+        break;
+    }
 
-    static void codegenCallCCode(CCodePointerTypePtr t,
-                                 llvm::Value *llCallable,
-                                 MultiCValuePtr args,
-                                 CodegenContext *ctx,
-                                 MultiCValuePtr out) {
-        ExternalTargetPtr target = getExternalTarget();
+    case PRIM_StaticMonoInputTypes:
+        break;
+
+    case PRIM_bitcopy: {
+        ensureArity(args, 2);
+        CValuePtr cv0 = args->values[0];
+        CValuePtr cv1 = args->values[1];
+        if (!isPrimitiveType(cv0->type))
+            argumentTypeError(0, "primitive type", cv0->type);
+        if (cv0->type != cv1->type)
+            argumentTypeError(1, cv0->type, cv1->type);
+        llvm::Value *v = ctx->builder->CreateLoad(cv1->llValue);
+        ctx->builder->CreateStore(v, cv0->llValue);
+        assert(out->size() == 0);
+        break;
+    }
 
-        if (!t->hasVarArgs)
-            ensureArity(args, t->argTypes.size());
-        else if (args->size() < t->argTypes.size())
-            arityError2(t->argTypes.size(), args->size());
+    case PRIM_boolNot: {
+        ensureArity(args, 1);
+        CValuePtr cv = args->values[0];
+        if (cv->type != boolType)
+            argumentTypeError(0, boolType, cv->type);
+        assert(out->size() == 1);
+        llvm::Value *v = ctx->builder->CreateLoad(cv->llValue);
+        llvm::Value *zero = llvm::ConstantInt::get(llvmType(boolType), 0);
+        llvm::Value *flag = ctx->builder->CreateICmpEQ(v, zero);
+        CValuePtr out0 = out->values[0];
+        assert(out0->type == boolType);
+        ctx->builder->CreateStore(flag, out0->llValue);
+        break;
+    }
 
-        vector<TypePtr> argTypes;
-        for (size_t i = 0; i < args->size(); ++i) {
-            CValuePtr cv = args->values[i];
-            argTypes.push_back(cv->type);
-        }
+    case PRIM_integerEqualsP:
+    case PRIM_integerLesserP: {
+        ensureArity(args, 2);
+        TypePtr t;
+        llvm::Value *v0 = integerOrPointerLikeValue(args, 0, t, ctx);
+        llvm::Value *v1 = integerOrPointerLikeValue(args, 1, t, ctx);
 
-        ExternalFunction *extFunc = target->getExternalFunction(
-            t->callingConv, t->returnType, argTypes,
-            t->argTypes.size(), t->hasVarArgs);
+        llvm::CmpInst::Predicate pred;
 
-        vector<llvm::Value *> llArgs;
-        extFunc->loadStructRetArgument(extFunc->retInfo, llArgs, ctx, out);
-        for (unsigned i = 0; i < t->argTypes.size(); ++i) {
-            CValuePtr cv = args->values[i];
-            if (cv->type != t->argTypes[i])
-                argumentTypeError(i, t->argTypes[i], cv->type);
-            extFunc->loadArgument(extFunc->argInfos[i], cv, llArgs, ctx, false);
-        }
-        if (t->hasVarArgs) {
-            for (size_t i = t->argTypes.size(); i < args->size(); ++i) {
-                CValuePtr cv = args->values[i];
-                extFunc->loadArgument(extFunc->argInfos[i], cv, llArgs,
-                                      ctx, true);
-            }
-        }
-        llvm::Value *llCastCallable = t->callingConv == CC_LLVM
-                                          ? llCallable
-                                          : ctx->builder->CreateBitCast(llCallable, t->getCallType());
-        llvm::CallInst *callInst =
-                ctx->builder->CreateCall(llCastCallable, llvm::ArrayRef(llArgs));
-        llvm::CallingConv::ID callingConv = extFunc->llConv;
-        callInst->setCallingConv(callingConv);
-        for (vector<pair<unsigned, llvm::Attributes> >::iterator
-             attr = extFunc->attrs.begin();
-             attr != extFunc->attrs.end();
-             ++attr)
-            callInst->addAttribute(attr->first, attr->second);
-
-        llvm::Value *llRet = callInst;
-        extFunc->storeReturnValue(extFunc->retInfo, llRet, ctx, out);
-    }
-
-    static void codegenCallCCodePointer(CValuePtr x,
-                                        MultiCValuePtr args,
-                                        CodegenContext *ctx,
-                                        MultiCValuePtr out) {
-        llvm::Value *llCallable = ctx->builder->CreateLoad(x->llValue);
-        assert(x->type->typeKind == CCODE_POINTER_TYPE);
-        CCodePointerType *t = (CCodePointerType *) x->type.ptr();
-        codegenCallCCode(t, llCallable, args, ctx, out);
-    }
-
-    void codegenPrimOp(PrimOpPtr x,
-                       MultiCValuePtr args,
-                       CodegenContext *ctx,
-                       MultiCValuePtr out) {
         switch (x->primOpCode) {
-            case PRIM_TypeP: {
-                ensureArity(args, 1);
-                ObjectPtr obj = valueToStatic(args->values[0]);
-                bool isType = (obj.ptr() && (obj->objKind == TYPE));
-                ValueHolderPtr vh = boolToValueHolder(isType);
-                codegenStaticObject(vh.ptr(), ctx, out);
+        case PRIM_integerEqualsP:
+            pred = llvm::CmpInst::ICMP_EQ;
+            break;
+        case PRIM_integerLesserP: {
+            bool isSigned;
+            switch (t->typeKind) {
+            case INTEGER_TYPE: {
+                IntegerType *it = (IntegerType *)t.ptr();
+                isSigned = it->isSigned;
                 break;
             }
-
-            case PRIM_TypeSize: {
-                ensureArity(args, 1);
-                TypePtr t = valueToType(args, 0);
-                ValueHolderPtr vh = sizeTToValueHolder(typeSize(t));
-                codegenStaticObject(vh.ptr(), ctx, out);
+            default:
+                isSigned = false;
                 break;
             }
+            pred = isSigned ? llvm::CmpInst::ICMP_SLT : llvm::CmpInst::ICMP_ULT;
+            break;
+        }
+        default:
+            assert(false);
+        }
 
-            case PRIM_TypeAlignment: {
-                ensureArity(args, 1);
-                TypePtr t = valueToType(args, 0);
-                ValueHolderPtr vh = sizeTToValueHolder(typeAlignment(t));
-                codegenStaticObject(vh.ptr(), ctx, out);
-                break;
-            }
+        llvm::Value *flag = ctx->builder->CreateICmp(pred, v0, v1);
+        assert(out->size() == 1);
+        CValuePtr out0 = out->values[0];
+        assert(out0->type == boolType);
+        ctx->builder->CreateStore(flag, out0->llValue);
+        break;
+    }
 
-            case PRIM_OperatorP: {
-                ensureArity(args, 1);
-                ObjectPtr obj = valueToStatic(args->values[0]);
-                bool isOperator = false;
-                if (!!obj.ptr() && (obj->objKind == PROCEDURE || obj->objKind == GLOBAL_ALIAS)) {
-                    TopLevelItem *item = (TopLevelItem *) obj.ptr();
-                    isOperator = item->name->isOperator;
-                }
-                ValueHolderPtr vh = boolToValueHolder(isOperator);
-                codegenStaticObject(vh.ptr(), ctx, out);
-                break;
-            }
+    case PRIM_floatOrderedEqualsP:
+    case PRIM_floatOrderedLesserP:
+    case PRIM_floatOrderedLesserEqualsP:
+    case PRIM_floatOrderedGreaterP:
+    case PRIM_floatOrderedGreaterEqualsP:
+    case PRIM_floatOrderedNotEqualsP:
+    case PRIM_floatOrderedP:
+    case PRIM_floatUnorderedEqualsP:
+    case PRIM_floatUnorderedLesserP:
+    case PRIM_floatUnorderedLesserEqualsP:
+    case PRIM_floatUnorderedGreaterP:
+    case PRIM_floatUnorderedGreaterEqualsP:
+    case PRIM_floatUnorderedNotEqualsP:
+    case PRIM_floatUnorderedP: {
+        ensureArity(args, 2);
+        FloatTypePtr t;
+        llvm::Value *v0 = floatValue(args, 0, t, ctx);
+        llvm::Value *v1 = floatValue(args, 1, t, ctx);
+
+        llvm::CmpInst::Predicate pred;
 
-            case PRIM_SymbolP: {
-                ensureArity(args, 1);
-                ObjectPtr obj = valueToStatic(args->values[0]);
-                bool isSymbol = false;
-                if (obj.ptr() != nullptr) {
-                    switch (obj->objKind) {
-                        case TYPE:
-                        case RECORD_DECL:
-                        case VARIANT_DECL:
-                        case PROCEDURE:
-                        case INTRINSIC:
-                        case GLOBAL_ALIAS:
-                            isSymbol = true;
-                            break;
-                        default:
-                            break;
-                    }
-                }
-                ValueHolderPtr vh = boolToValueHolder(isSymbol);
-                codegenStaticObject(vh.ptr(), ctx, out);
-                break;
-            }
+        switch (x->primOpCode) {
+        case PRIM_floatOrderedEqualsP:
+            pred = llvm::CmpInst::FCMP_OEQ;
+            break;
+        case PRIM_floatOrderedLesserP:
+            pred = llvm::CmpInst::FCMP_OLT;
+            break;
+        case PRIM_floatOrderedLesserEqualsP:
+            pred = llvm::CmpInst::FCMP_OLE;
+            break;
+        case PRIM_floatOrderedGreaterP:
+            pred = llvm::CmpInst::FCMP_OGT;
+            break;
+        case PRIM_floatOrderedGreaterEqualsP:
+            pred = llvm::CmpInst::FCMP_OGE;
+            break;
+        case PRIM_floatOrderedNotEqualsP:
+            pred = llvm::CmpInst::FCMP_ONE;
+            break;
+        case PRIM_floatOrderedP:
+            pred = llvm::CmpInst::FCMP_ORD;
+            break;
+        case PRIM_floatUnorderedEqualsP:
+            pred = llvm::CmpInst::FCMP_UEQ;
+            break;
+        case PRIM_floatUnorderedLesserP:
+            pred = llvm::CmpInst::FCMP_ULT;
+            break;
+        case PRIM_floatUnorderedLesserEqualsP:
+            pred = llvm::CmpInst::FCMP_ULE;
+            break;
+        case PRIM_floatUnorderedGreaterP:
+            pred = llvm::CmpInst::FCMP_UGT;
+            break;
+        case PRIM_floatUnorderedGreaterEqualsP:
+            pred = llvm::CmpInst::FCMP_UGE;
+            break;
+        case PRIM_floatUnorderedNotEqualsP:
+            pred = llvm::CmpInst::FCMP_UNE;
+            break;
+        case PRIM_floatUnorderedP:
+            pred = llvm::CmpInst::FCMP_UNO;
+            break;
+        default:
+            assert(false);
+        }
 
-            case PRIM_StaticCallDefinedP: {
-                if (args->size() < 1)
-                    arityError2(1, args->size());
-                ObjectPtr callable = valueToStatic(args->values[0]);
-                if (!callable) {
-                    argumentError(0, "static callable expected");
-                }
-                switch (callable->objKind) {
-                    case TYPE:
-                    case RECORD_DECL:
-                    case VARIANT_DECL:
-                    case PROCEDURE:
-                    case INTRINSIC:
-                    case GLOBAL_ALIAS:
-                        break;
-                    default:
-                        argumentError(0, "invalid callable");
-                }
-                vector<PVData> argsPVData;
-                for (unsigned i = 1; i < args->size(); ++i) {
-                    TypePtr t = valueToType(args, i);
-                    argsPVData.push_back(PVData(t, false));
-                }
-                CompileContextPusher pusher(callable, argsPVData);
-                bool isDefined = analyzeIsDefined(callable, argsPVData);
-                ValueHolderPtr vh = boolToValueHolder(isDefined);
-                codegenStaticObject(vh.ptr(), ctx, out);
-                break;
-            }
+        llvm::Value *flag = ctx->builder->CreateFCmp(pred, v0, v1);
+        assert(out->size() == 1);
+        CValuePtr out0 = out->values[0];
+        assert(out0->type == boolType);
+        ctx->builder->CreateStore(flag, out0->llValue);
+        break;
+    }
 
-            case PRIM_StaticCallOutputTypes:
-                break;
+    case PRIM_numericAdd: {
+        ensureArity(args, 2);
+        TypePtr t;
+        llvm::Value *v0 = numericValue(args, 0, t, ctx);
+        llvm::Value *v1 = numericValue(args, 1, t, ctx);
+        llvm::Value *result;
+        switch (t->typeKind) {
+        case INTEGER_TYPE:
+            result = ctx->builder->CreateAdd(v0, v1);
+            break;
+        case FLOAT_TYPE:
+            result = ctx->builder->CreateFAdd(v0, v1);
+            break;
+        default:
+            assert(false);
+        }
+        assert(out->size() == 1);
+        CValuePtr out0 = out->values[0];
+        assert(out0->type == t);
+        ctx->builder->CreateStore(result, out0->llValue);
+        break;
+    }
 
-            case PRIM_StaticMonoP: {
-                ensureArity(args, 1);
+    case PRIM_numericSubtract: {
+        ensureArity(args, 2);
+        TypePtr t;
+        llvm::Value *v0 = numericValue(args, 0, t, ctx);
+        llvm::Value *v1 = numericValue(args, 1, t, ctx);
+        llvm::Value *result;
+        switch (t->typeKind) {
+        case INTEGER_TYPE:
+            result = ctx->builder->CreateSub(v0, v1);
+            break;
+        case FLOAT_TYPE:
+            result = ctx->builder->CreateFSub(v0, v1);
+            break;
+        default:
+            assert(false);
+        }
+        assert(out->size() == 1);
+        CValuePtr out0 = out->values[0];
+        assert(out0->type == t);
+        ctx->builder->CreateStore(result, out0->llValue);
+        break;
+    }
 
-                bool isMono;
+    case PRIM_numericMultiply: {
+        ensureArity(args, 2);
+        TypePtr t;
+        llvm::Value *v0 = numericValue(args, 0, t, ctx);
+        llvm::Value *v1 = numericValue(args, 1, t, ctx);
+        llvm::Value *result;
+        switch (t->typeKind) {
+        case INTEGER_TYPE:
+            result = ctx->builder->CreateMul(v0, v1);
+            break;
+        case FLOAT_TYPE:
+            result = ctx->builder->CreateFMul(v0, v1);
+            break;
+        default:
+            assert(false);
+        }
+        assert(out->size() == 1);
+        CValuePtr out0 = out->values[0];
+        assert(out0->type == t);
+        ctx->builder->CreateStore(result, out0->llValue);
+        break;
+    }
 
-                ObjectPtr callable = valueToStatic(args->values[0]);
-                if (callable != nullptr && callable->objKind == PROCEDURE) {
-                    Procedure *p = (Procedure *) callable.ptr();
-                    isMono = p->mono.monoState == Procedure_MonoOverload;
-                } else
-                    isMono = false;
+    case PRIM_floatDivide: {
+        ensureArity(args, 2);
+        FloatTypePtr t;
+        llvm::Value *v0 = floatValue(args, 0, t, ctx);
+        llvm::Value *v1 = floatValue(args, 1, t, ctx);
+        llvm::Value *result;
+        result = ctx->builder->CreateFDiv(v0, v1);
+        assert(out->size() == 1);
+        CValuePtr out0 = out->values[0];
+        assert(out0->type == t.ptr());
+        ctx->builder->CreateStore(result, out0->llValue);
+        break;
+    }
 
-                ValueHolderPtr vh = boolToValueHolder(isMono);
-                codegenStaticObject(vh.ptr(), ctx, out);
-                break;
-            }
+    case PRIM_numericNegate: {
+        ensureArity(args, 1);
+        TypePtr t;
+        llvm::Value *v = numericValue(args, 0, t, ctx);
+        llvm::Value *result;
+        switch (t->typeKind) {
+        case INTEGER_TYPE:
+            result = ctx->builder->CreateNeg(v);
+            break;
+        case FLOAT_TYPE:
+            result = ctx->builder->CreateFNeg(v);
+            break;
+        default:
+            assert(false);
+        }
+        assert(out->size() == 1);
+        CValuePtr out0 = out->values[0];
+        assert(out0->type == t);
+        ctx->builder->CreateStore(result, out0->llValue);
+        break;
+    }
 
-            case PRIM_StaticMonoInputTypes:
-                break;
+    case PRIM_integerQuotient: {
+        ensureArity(args, 2);
+        IntegerTypePtr t;
+        llvm::Value *v0 = integerValue(args, 0, t, ctx);
+        llvm::Value *v1 = integerValue(args, 1, t, ctx);
+        llvm::Value *result;
+        IntegerType *it = (IntegerType *)t.ptr();
+        if (it->isSigned)
+            result = ctx->builder->CreateSDiv(v0, v1);
+        else
+            result = ctx->builder->CreateUDiv(v0, v1);
+        assert(out->size() == 1);
+        CValuePtr out0 = out->values[0];
+        assert(out0->type == t.ptr());
+        ctx->builder->CreateStore(result, out0->llValue);
+        break;
+    }
 
-            case PRIM_bitcopy: {
-                ensureArity(args, 2);
-                CValuePtr cv0 = args->values[0];
-                CValuePtr cv1 = args->values[1];
-                if (!isPrimitiveType(cv0->type))
-                    argumentTypeError(0, "primitive type", cv0->type);
-                if (cv0->type != cv1->type)
-                    argumentTypeError(1, cv0->type, cv1->type);
-                llvm::Value *v = ctx->builder->CreateLoad(cv1->llValue);
-                ctx->builder->CreateStore(v, cv0->llValue);
-                assert(out->size() == 0);
-                break;
-            }
+    case PRIM_integerRemainder: {
+        ensureArity(args, 2);
+        IntegerTypePtr t;
+        llvm::Value *v0 = integerValue(args, 0, t, ctx);
+        llvm::Value *v1 = integerValue(args, 1, t, ctx);
+        llvm::Value *result;
+        IntegerType *it = (IntegerType *)t.ptr();
+        if (it->isSigned)
+            result = ctx->builder->CreateSRem(v0, v1);
+        else
+            result = ctx->builder->CreateURem(v0, v1);
+        assert(out->size() == 1);
+        CValuePtr out0 = out->values[0];
+        assert(out0->type == t.ptr());
+        ctx->builder->CreateStore(result, out0->llValue);
+        break;
+    }
 
-            case PRIM_boolNot: {
-                ensureArity(args, 1);
-                CValuePtr cv = args->values[0];
-                if (cv->type != boolType)
-                    argumentTypeError(0, boolType, cv->type);
-                assert(out->size() == 1);
-                llvm::Value *v = ctx->builder->CreateLoad(cv->llValue);
-                llvm::Value *zero = llvm::ConstantInt::get(llvmType(boolType), 0);
-                llvm::Value *flag = ctx->builder->CreateICmpEQ(v, zero);
-                CValuePtr out0 = out->values[0];
-                assert(out0->type == boolType);
-                ctx->builder->CreateStore(flag, out0->llValue);
-                break;
-            }
+    case PRIM_integerShiftLeft: {
+        ensureArity(args, 2);
+        IntegerTypePtr t;
+        llvm::Value *v0 = integerValue(args, 0, t, ctx);
+        llvm::Value *v1 = integerValue(args, 1, t, ctx);
+        llvm::Value *result = ctx->builder->CreateShl(v0, v1);
+        assert(out->size() == 1);
+        CValuePtr out0 = out->values[0];
+        assert(out0->type == t.ptr());
+        ctx->builder->CreateStore(result, out0->llValue);
+        break;
+    }
 
-            case PRIM_integerEqualsP:
-            case PRIM_integerLesserP: {
-                ensureArity(args, 2);
-                TypePtr t;
-                llvm::Value *v0 = integerOrPointerLikeValue(args, 0, t, ctx);
-                llvm::Value *v1 = integerOrPointerLikeValue(args, 1, t, ctx);
-
-                llvm::CmpInst::Predicate pred;
-
-                switch (x->primOpCode) {
-                    case PRIM_integerEqualsP:
-                        pred = llvm::CmpInst::ICMP_EQ;
-                        break;
-                    case PRIM_integerLesserP: {
-                        bool isSigned;
-                        switch (t->typeKind) {
-                            case INTEGER_TYPE: {
-                                IntegerType *it = (IntegerType *) t.ptr();
-                                isSigned = it->isSigned;
-                                break;
-                            }
-                            default:
-                                isSigned = false;
-                                break;
-                        }
-                        pred = isSigned
-                                   ? llvm::CmpInst::ICMP_SLT
-                                   : llvm::CmpInst::ICMP_ULT;
-                        break;
-                    }
-                    default:
-                        assert(false);
-                }
+    case PRIM_integerShiftRight: {
+        ensureArity(args, 2);
+        IntegerTypePtr t;
+        llvm::Value *v0 = integerValue(args, 0, t, ctx);
+        llvm::Value *v1 = integerValue(args, 1, t, ctx);
+        llvm::Value *result;
+        if (t->isSigned)
+            result = ctx->builder->CreateAShr(v0, v1);
+        else
+            result = ctx->builder->CreateLShr(v0, v1);
+        assert(out->size() == 1);
+        CValuePtr out0 = out->values[0];
+        assert(out0->type == t.ptr());
+        ctx->builder->CreateStore(result, out0->llValue);
+        break;
+    }
 
-                llvm::Value *flag = ctx->builder->CreateICmp(pred, v0, v1);
-                assert(out->size() == 1);
-                CValuePtr out0 = out->values[0];
-                assert(out0->type == boolType);
-                ctx->builder->CreateStore(flag, out0->llValue);
-                break;
-            }
+    case PRIM_integerBitwiseAnd: {
+        ensureArity(args, 2);
+        IntegerTypePtr t;
+        llvm::Value *v0 = integerValue(args, 0, t, ctx);
+        llvm::Value *v1 = integerValue(args, 1, t, ctx);
+        llvm::Value *result = ctx->builder->CreateAnd(v0, v1);
+        assert(out->size() == 1);
+        CValuePtr out0 = out->values[0];
+        assert(out0->type == t.ptr());
+        ctx->builder->CreateStore(result, out0->llValue);
+        break;
+    }
 
-            case PRIM_floatOrderedEqualsP:
-            case PRIM_floatOrderedLesserP:
-            case PRIM_floatOrderedLesserEqualsP:
-            case PRIM_floatOrderedGreaterP:
-            case PRIM_floatOrderedGreaterEqualsP:
-            case PRIM_floatOrderedNotEqualsP:
-            case PRIM_floatOrderedP:
-            case PRIM_floatUnorderedEqualsP:
-            case PRIM_floatUnorderedLesserP:
-            case PRIM_floatUnorderedLesserEqualsP:
-            case PRIM_floatUnorderedGreaterP:
-            case PRIM_floatUnorderedGreaterEqualsP:
-            case PRIM_floatUnorderedNotEqualsP:
-            case PRIM_floatUnorderedP: {
-                ensureArity(args, 2);
-                FloatTypePtr t;
-                llvm::Value *v0 = floatValue(args, 0, t, ctx);
-                llvm::Value *v1 = floatValue(args, 1, t, ctx);
-
-                llvm::CmpInst::Predicate pred;
-
-                switch (x->primOpCode) {
-                    case PRIM_floatOrderedEqualsP:
-                        pred = llvm::CmpInst::FCMP_OEQ;
-                        break;
-                    case PRIM_floatOrderedLesserP:
-                        pred = llvm::CmpInst::FCMP_OLT;
-                        break;
-                    case PRIM_floatOrderedLesserEqualsP:
-                        pred = llvm::CmpInst::FCMP_OLE;
-                        break;
-                    case PRIM_floatOrderedGreaterP:
-                        pred = llvm::CmpInst::FCMP_OGT;
-                        break;
-                    case PRIM_floatOrderedGreaterEqualsP:
-                        pred = llvm::CmpInst::FCMP_OGE;
-                        break;
-                    case PRIM_floatOrderedNotEqualsP:
-                        pred = llvm::CmpInst::FCMP_ONE;
-                        break;
-                    case PRIM_floatOrderedP:
-                        pred = llvm::CmpInst::FCMP_ORD;
-                        break;
-                    case PRIM_floatUnorderedEqualsP:
-                        pred = llvm::CmpInst::FCMP_UEQ;
-                        break;
-                    case PRIM_floatUnorderedLesserP:
-                        pred = llvm::CmpInst::FCMP_ULT;
-                        break;
-                    case PRIM_floatUnorderedLesserEqualsP:
-                        pred = llvm::CmpInst::FCMP_ULE;
-                        break;
-                    case PRIM_floatUnorderedGreaterP:
-                        pred = llvm::CmpInst::FCMP_UGT;
-                        break;
-                    case PRIM_floatUnorderedGreaterEqualsP:
-                        pred = llvm::CmpInst::FCMP_UGE;
-                        break;
-                    case PRIM_floatUnorderedNotEqualsP:
-                        pred = llvm::CmpInst::FCMP_UNE;
-                        break;
-                    case PRIM_floatUnorderedP:
-                        pred = llvm::CmpInst::FCMP_UNO;
-                        break;
-                    default:
-                        assert(false);
-                }
+    case PRIM_integerBitwiseOr: {
+        ensureArity(args, 2);
+        IntegerTypePtr t;
+        llvm::Value *v0 = integerValue(args, 0, t, ctx);
+        llvm::Value *v1 = integerValue(args, 1, t, ctx);
+        llvm::Value *result = ctx->builder->CreateOr(v0, v1);
+        assert(out->size() == 1);
+        CValuePtr out0 = out->values[0];
+        assert(out0->type == t.ptr());
+        ctx->builder->CreateStore(result, out0->llValue);
+        break;
+    }
 
-                llvm::Value *flag = ctx->builder->CreateFCmp(pred, v0, v1);
-                assert(out->size() == 1);
-                CValuePtr out0 = out->values[0];
-                assert(out0->type == boolType);
-                ctx->builder->CreateStore(flag, out0->llValue);
-                break;
-            }
+    case PRIM_integerBitwiseXor: {
+        ensureArity(args, 2);
+        IntegerTypePtr t;
+        llvm::Value *v0 = integerValue(args, 0, t, ctx);
+        llvm::Value *v1 = integerValue(args, 1, t, ctx);
+        llvm::Value *result = ctx->builder->CreateXor(v0, v1);
+        assert(out->size() == 1);
+        CValuePtr out0 = out->values[0];
+        assert(out0->type == t.ptr());
+        ctx->builder->CreateStore(result, out0->llValue);
+        break;
+    }
 
-            case PRIM_numericAdd: {
-                ensureArity(args, 2);
-                TypePtr t;
-                llvm::Value *v0 = numericValue(args, 0, t, ctx);
-                llvm::Value *v1 = numericValue(args, 1, t, ctx);
-                llvm::Value *result;
-                switch (t->typeKind) {
-                    case INTEGER_TYPE:
-                        result = ctx->builder->CreateAdd(v0, v1);
-                        break;
-                    case FLOAT_TYPE:
-                        result = ctx->builder->CreateFAdd(v0, v1);
-                        break;
-                    default:
-                        assert(false);
-                }
-                assert(out->size() == 1);
-                CValuePtr out0 = out->values[0];
-                assert(out0->type == t);
-                ctx->builder->CreateStore(result, out0->llValue);
-                break;
-            }
+    case PRIM_integerBitwiseNot: {
+        ensureArity(args, 1);
+        IntegerTypePtr t;
+        llvm::Value *v = integerValue(args, 0, t, ctx);
+        llvm::Value *result = ctx->builder->CreateNot(v);
+        assert(out->size() == 1);
+        CValuePtr out0 = out->values[0];
+        assert(out0->type == t.ptr());
+        ctx->builder->CreateStore(result, out0->llValue);
+        break;
+    }
 
-            case PRIM_numericSubtract: {
-                ensureArity(args, 2);
-                TypePtr t;
-                llvm::Value *v0 = numericValue(args, 0, t, ctx);
-                llvm::Value *v1 = numericValue(args, 1, t, ctx);
-                llvm::Value *result;
-                switch (t->typeKind) {
-                    case INTEGER_TYPE:
-                        result = ctx->builder->CreateSub(v0, v1);
-                        break;
-                    case FLOAT_TYPE:
-                        result = ctx->builder->CreateFSub(v0, v1);
-                        break;
-                    default:
-                        assert(false);
+    case PRIM_numericConvert: {
+        ensureArity(args, 2);
+        TypePtr dest = valueToNumericType(args, 0);
+        TypePtr src;
+        llvm::Value *v = numericValue(args, 1, src, ctx);
+        llvm::Value *result;
+        if (src == dest) {
+            result = v;
+        } else {
+            switch (dest->typeKind) {
+            case INTEGER_TYPE: {
+                IntegerType *dest2 = (IntegerType *)dest.ptr();
+                if (src->typeKind == INTEGER_TYPE) {
+                    IntegerType *src2 = (IntegerType *)src.ptr();
+                    if (dest2->bits < src2->bits)
+                        result = ctx->builder->CreateTrunc(v, llvmType(dest));
+                    else if (src2->isSigned)
+                        result = ctx->builder->CreateSExt(v, llvmType(dest));
+                    else
+                        result = ctx->builder->CreateZExt(v, llvmType(dest));
+                } else if (src->typeKind == FLOAT_TYPE) {
+                    if (dest2->isSigned)
+                        result = ctx->builder->CreateFPToSI(v, llvmType(dest));
+                    else
+                        result = ctx->builder->CreateFPToUI(v, llvmType(dest));
+                } else {
+                    assert(false);
+                    result = nullptr;
                 }
-                assert(out->size() == 1);
-                CValuePtr out0 = out->values[0];
-                assert(out0->type == t);
-                ctx->builder->CreateStore(result, out0->llValue);
                 break;
             }
-
-            case PRIM_numericMultiply: {
-                ensureArity(args, 2);
-                TypePtr t;
-                llvm::Value *v0 = numericValue(args, 0, t, ctx);
-                llvm::Value *v1 = numericValue(args, 1, t, ctx);
-                llvm::Value *result;
-                switch (t->typeKind) {
-                    case INTEGER_TYPE:
-                        result = ctx->builder->CreateMul(v0, v1);
-                        break;
-                    case FLOAT_TYPE:
-                        result = ctx->builder->CreateFMul(v0, v1);
-                        break;
-                    default:
-                        assert(false);
+            case FLOAT_TYPE: {
+                FloatType *dest2 = (FloatType *)dest.ptr();
+                if (src->typeKind == INTEGER_TYPE) {
+                    IntegerType *src2 = (IntegerType *)src.ptr();
+                    if (src2->isSigned)
+                        result = ctx->builder->CreateSIToFP(v, llvmType(dest));
+                    else
+                        result = ctx->builder->CreateUIToFP(v, llvmType(dest));
+                } else if (src->typeKind == FLOAT_TYPE) {
+                    FloatType *src2 = (FloatType *)src.ptr();
+                    if (dest2->bits < src2->bits)
+                        result = ctx->builder->CreateFPTrunc(v, llvmType(dest));
+                    else
+                        result = ctx->builder->CreateFPExt(v, llvmType(dest));
+                } else {
+                    assert(false);
+                    result = nullptr;
                 }
-                assert(out->size() == 1);
-                CValuePtr out0 = out->values[0];
-                assert(out0->type == t);
-                ctx->builder->CreateStore(result, out0->llValue);
                 break;
             }
 
-            case PRIM_floatDivide: {
-                ensureArity(args, 2);
-                FloatTypePtr t;
-                llvm::Value *v0 = floatValue(args, 0, t, ctx);
-                llvm::Value *v1 = floatValue(args, 1, t, ctx);
-                llvm::Value *result;
-                result = ctx->builder->CreateFDiv(v0, v1);
-                assert(out->size() == 1);
-                CValuePtr out0 = out->values[0];
-                assert(out0->type == t.ptr());
-                ctx->builder->CreateStore(result, out0->llValue);
+            default:
+                assert(false);
+                result = nullptr;
                 break;
             }
+        }
+        assert(out->size() == 1);
+        CValuePtr out0 = out->values[0];
+        assert(out0->type == dest);
+        ctx->builder->CreateStore(result, out0->llValue);
+        break;
+    }
 
-            case PRIM_numericNegate: {
-                ensureArity(args, 1);
-                TypePtr t;
-                llvm::Value *v = numericValue(args, 0, t, ctx);
-                llvm::Value *result;
-                switch (t->typeKind) {
-                    case INTEGER_TYPE:
-                        result = ctx->builder->CreateNeg(v);
-                        break;
-                    case FLOAT_TYPE:
-                        result = ctx->builder->CreateFNeg(v);
-                        break;
-                    default:
-                        assert(false);
-                }
-                assert(out->size() == 1);
-                CValuePtr out0 = out->values[0];
-                assert(out0->type == t);
-                ctx->builder->CreateStore(result, out0->llValue);
-                break;
-            }
+    case PRIM_integerAddChecked: {
+        ensureArity(args, 2);
+        IntegerTypePtr t;
+        checkIntegerValue(args, 0, t, ctx);
+        checkIntegerValue(args, 1, t, ctx);
+        assert(out->size() == 1);
+        CValuePtr out0 = out->values[0];
+        assert(out0->type.ptr() == t.ptr());
+        codegenCallValue(staticCValue(operator_doIntegerAddChecked(), ctx),
+                         args, ctx, out);
+        break;
+    }
 
-            case PRIM_integerQuotient: {
-                ensureArity(args, 2);
-                IntegerTypePtr t;
-                llvm::Value *v0 = integerValue(args, 0, t, ctx);
-                llvm::Value *v1 = integerValue(args, 1, t, ctx);
-                llvm::Value *result;
-                IntegerType *it = (IntegerType *) t.ptr();
-                if (it->isSigned)
-                    result = ctx->builder->CreateSDiv(v0, v1);
-                else
-                    result = ctx->builder->CreateUDiv(v0, v1);
-                assert(out->size() == 1);
-                CValuePtr out0 = out->values[0];
-                assert(out0->type == t.ptr());
-                ctx->builder->CreateStore(result, out0->llValue);
-                break;
-            }
+    case PRIM_integerSubtractChecked: {
+        ensureArity(args, 2);
+        IntegerTypePtr t;
+        checkIntegerValue(args, 0, t, ctx);
+        checkIntegerValue(args, 1, t, ctx);
+        assert(out->size() == 1);
+        CValuePtr out0 = out->values[0];
+        assert(out0->type.ptr() == t.ptr());
+        codegenCallValue(staticCValue(operator_doIntegerSubtractChecked(), ctx),
+                         args, ctx, out);
+        break;
+    }
 
-            case PRIM_integerRemainder: {
-                ensureArity(args, 2);
-                IntegerTypePtr t;
-                llvm::Value *v0 = integerValue(args, 0, t, ctx);
-                llvm::Value *v1 = integerValue(args, 1, t, ctx);
-                llvm::Value *result;
-                IntegerType *it = (IntegerType *) t.ptr();
-                if (it->isSigned)
-                    result = ctx->builder->CreateSRem(v0, v1);
-                else
-                    result = ctx->builder->CreateURem(v0, v1);
-                assert(out->size() == 1);
-                CValuePtr out0 = out->values[0];
-                assert(out0->type == t.ptr());
-                ctx->builder->CreateStore(result, out0->llValue);
-                break;
-            }
+    case PRIM_integerMultiplyChecked: {
+        ensureArity(args, 2);
+        IntegerTypePtr t;
+        checkIntegerValue(args, 0, t, ctx);
+        checkIntegerValue(args, 1, t, ctx);
+        assert(out->size() == 1);
+        CValuePtr out0 = out->values[0];
+        assert(out0->type.ptr() == t.ptr());
+        codegenCallValue(staticCValue(operator_doIntegerMultiplyChecked(), ctx),
+                         args, ctx, out);
+        break;
+    }
 
-            case PRIM_integerShiftLeft: {
-                ensureArity(args, 2);
-                IntegerTypePtr t;
-                llvm::Value *v0 = integerValue(args, 0, t, ctx);
-                llvm::Value *v1 = integerValue(args, 1, t, ctx);
-                llvm::Value *result = ctx->builder->CreateShl(v0, v1);
-                assert(out->size() == 1);
-                CValuePtr out0 = out->values[0];
-                assert(out0->type == t.ptr());
-                ctx->builder->CreateStore(result, out0->llValue);
-                break;
-            }
+    case PRIM_integerQuotientChecked: {
+        ensureArity(args, 2);
+        IntegerTypePtr t;
+        checkIntegerValue(args, 0, t, ctx);
+        checkIntegerValue(args, 1, t, ctx);
+        assert(out->size() == 1);
+        CValuePtr out0 = out->values[0];
+        assert(out0->type.ptr() == t.ptr());
+        codegenCallValue(staticCValue(operator_doIntegerQuotientChecked(), ctx),
+                         args, ctx, out);
+        break;
+    }
 
-            case PRIM_integerShiftRight: {
-                ensureArity(args, 2);
-                IntegerTypePtr t;
-                llvm::Value *v0 = integerValue(args, 0, t, ctx);
-                llvm::Value *v1 = integerValue(args, 1, t, ctx);
-                llvm::Value *result;
-                if (t->isSigned)
-                    result = ctx->builder->CreateAShr(v0, v1);
-                else
-                    result = ctx->builder->CreateLShr(v0, v1);
-                assert(out->size() == 1);
-                CValuePtr out0 = out->values[0];
-                assert(out0->type == t.ptr());
-                ctx->builder->CreateStore(result, out0->llValue);
-                break;
-            }
+    case PRIM_integerRemainderChecked: {
+        ensureArity(args, 2);
+        IntegerTypePtr t;
+        checkIntegerValue(args, 0, t, ctx);
+        checkIntegerValue(args, 1, t, ctx);
+        assert(out->size() == 1);
+        CValuePtr out0 = out->values[0];
+        assert(out0->type.ptr() == t.ptr());
+        codegenCallValue(
+            staticCValue(operator_doIntegerRemainderChecked(), ctx), args, ctx,
+            out);
+        break;
+    }
 
-            case PRIM_integerBitwiseAnd: {
-                ensureArity(args, 2);
-                IntegerTypePtr t;
-                llvm::Value *v0 = integerValue(args, 0, t, ctx);
-                llvm::Value *v1 = integerValue(args, 1, t, ctx);
-                llvm::Value *result = ctx->builder->CreateAnd(v0, v1);
-                assert(out->size() == 1);
-                CValuePtr out0 = out->values[0];
-                assert(out0->type == t.ptr());
-                ctx->builder->CreateStore(result, out0->llValue);
-                break;
-            }
+    case PRIM_integerShiftLeftChecked: {
+        ensureArity(args, 2);
+        IntegerTypePtr t;
+        checkIntegerValue(args, 0, t, ctx);
+        checkIntegerValue(args, 1, t, ctx);
+        assert(out->size() == 1);
+        CValuePtr out0 = out->values[0];
+        assert(out0->type.ptr() == t.ptr());
+        codegenCallValue(
+            staticCValue(operator_doIntegerShiftLeftChecked(), ctx), args, ctx,
+            out);
+        break;
+    }
 
-            case PRIM_integerBitwiseOr: {
-                ensureArity(args, 2);
-                IntegerTypePtr t;
-                llvm::Value *v0 = integerValue(args, 0, t, ctx);
-                llvm::Value *v1 = integerValue(args, 1, t, ctx);
-                llvm::Value *result = ctx->builder->CreateOr(v0, v1);
-                assert(out->size() == 1);
-                CValuePtr out0 = out->values[0];
-                assert(out0->type == t.ptr());
-                ctx->builder->CreateStore(result, out0->llValue);
-                break;
-            }
+    case PRIM_integerNegateChecked: {
+        ensureArity(args, 1);
+        IntegerTypePtr t;
+        checkIntegerValue(args, 0, t, ctx);
+        assert(out->size() == 1);
+        CValuePtr out0 = out->values[0];
+        assert(out0->type.ptr() == t.ptr());
+        codegenCallValue(staticCValue(operator_doIntegerNegateChecked(), ctx),
+                         args, ctx, out);
+        break;
+    }
 
-            case PRIM_integerBitwiseXor: {
-                ensureArity(args, 2);
-                IntegerTypePtr t;
-                llvm::Value *v0 = integerValue(args, 0, t, ctx);
-                llvm::Value *v1 = integerValue(args, 1, t, ctx);
-                llvm::Value *result = ctx->builder->CreateXor(v0, v1);
-                assert(out->size() == 1);
-                CValuePtr out0 = out->values[0];
-                assert(out0->type == t.ptr());
-                ctx->builder->CreateStore(result, out0->llValue);
-                break;
-            }
+    case PRIM_integerConvertChecked: {
+        ensureArity(args, 2);
+        IntegerTypePtr dest = valueToIntegerType(args, 0);
+        assert(out->size() == 1);
+        CValuePtr out0 = out->values[0];
+        assert(out0->type == dest.ptr());
+        codegenCallValue(staticCValue(operator_doIntegerConvertChecked(), ctx),
+                         args, ctx, out);
+        break;
+    }
 
-            case PRIM_integerBitwiseNot: {
-                ensureArity(args, 1);
-                IntegerTypePtr t;
-                llvm::Value *v = integerValue(args, 0, t, ctx);
-                llvm::Value *result = ctx->builder->CreateNot(v);
-                assert(out->size() == 1);
-                CValuePtr out0 = out->values[0];
-                assert(out0->type == t.ptr());
-                ctx->builder->CreateStore(result, out0->llValue);
-                break;
-            }
+    case PRIM_Pointer:
+        error("no Pointer primitive overload found");
+
+    case PRIM_addressOf: {
+        ensureArity(args, 1);
+        CValuePtr cv = args->values[0];
+        assert(out->size() == 1);
+        CValuePtr out0 = out->values[0];
+        assert(out0->type == pointerType(cv->type));
+        ctx->builder->CreateStore(cv->llValue, out0->llValue);
+        break;
+    }
 
-            case PRIM_numericConvert: {
-                ensureArity(args, 2);
-                TypePtr dest = valueToNumericType(args, 0);
-                TypePtr src;
-                llvm::Value *v = numericValue(args, 1, src, ctx);
-                llvm::Value *result;
-                if (src == dest) {
-                    result = v;
-                } else {
-                    switch (dest->typeKind) {
-                        case INTEGER_TYPE: {
-                            IntegerType *dest2 = (IntegerType *) dest.ptr();
-                            if (src->typeKind == INTEGER_TYPE) {
-                                IntegerType *src2 = (IntegerType *) src.ptr();
-                                if (dest2->bits < src2->bits)
-                                    result = ctx->builder->CreateTrunc(v, llvmType(dest));
-                                else if (src2->isSigned)
-                                    result = ctx->builder->CreateSExt(v, llvmType(dest));
-                                else
-                                    result = ctx->builder->CreateZExt(v, llvmType(dest));
-                            } else if (src->typeKind == FLOAT_TYPE) {
-                                if (dest2->isSigned)
-                                    result = ctx->builder->CreateFPToSI(v, llvmType(dest));
-                                else
-                                    result = ctx->builder->CreateFPToUI(v, llvmType(dest));
-                            } else {
-                                assert(false);
-                                result = nullptr;
-                            }
-                            break;
-                        }
-                        case FLOAT_TYPE: {
-                            FloatType *dest2 = (FloatType *) dest.ptr();
-                            if (src->typeKind == INTEGER_TYPE) {
-                                IntegerType *src2 = (IntegerType *) src.ptr();
-                                if (src2->isSigned)
-                                    result = ctx->builder->CreateSIToFP(v, llvmType(dest));
-                                else
-                                    result = ctx->builder->CreateUIToFP(v, llvmType(dest));
-                            } else if (src->typeKind == FLOAT_TYPE) {
-                                FloatType *src2 = (FloatType *) src.ptr();
-                                if (dest2->bits < src2->bits)
-                                    result = ctx->builder->CreateFPTrunc(v, llvmType(dest));
-                                else
-                                    result = ctx->builder->CreateFPExt(v, llvmType(dest));
-                            } else {
-                                assert(false);
-                                result = nullptr;
-                            }
-                            break;
-                        }
-
-                        default:
-                            assert(false);
-                            result = nullptr;
-                            break;
-                    }
-                }
-                assert(out->size() == 1);
-                CValuePtr out0 = out->values[0];
-                assert(out0->type == dest);
-                ctx->builder->CreateStore(result, out0->llValue);
-                break;
-            }
+    case PRIM_pointerDereference: {
+        ensureArity(args, 1);
+        PointerTypePtr t;
+        llvm::Value *v = pointerValue(args, 0, t, ctx);
+        assert(out->size() == 1);
+        CValuePtr out0 = out->values[0];
+        assert(out0->type == t.ptr());
+        ctx->builder->CreateStore(v, out0->llValue);
+        break;
+    }
 
-            case PRIM_integerAddChecked: {
-                ensureArity(args, 2);
-                IntegerTypePtr t;
-                checkIntegerValue(args, 0, t, ctx);
-                checkIntegerValue(args, 1, t, ctx);
-                assert(out->size() == 1);
-                CValuePtr out0 = out->values[0];
-                assert(out0->type.ptr() == t.ptr());
-                codegenCallValue(staticCValue(operator_doIntegerAddChecked(), ctx),
-                                 args,
-                                 ctx,
-                                 out);
-                break;
-            }
+    case PRIM_pointerOffset: {
+        ensureArity(args, 2);
+        PointerTypePtr t;
+        llvm::Value *v0 = pointerValue(args, 0, t, ctx);
+        IntegerTypePtr offsetT;
+        llvm::Value *v1 = integerValue(args, 1, offsetT, ctx);
+        if (!offsetT->isSigned &&
+            (size_t)offsetT->bits < typeSize(cSizeTType) * 8)
+            v1 = ctx->builder->CreateZExt(v1, llvmType(cSizeTType));
+        vector<llvm::Value *> indices;
+        indices.push_back(v1);
+        llvm::Value *result =
+            ctx->builder->CreateGEP(v0, llvm::ArrayRef(indices));
+        assert(out->size() == 1);
+        CValuePtr out0 = out->values[0];
+        assert(out0->type == t.ptr());
+        ctx->builder->CreateStore(result, out0->llValue);
+        break;
+    }
 
-            case PRIM_integerSubtractChecked: {
-                ensureArity(args, 2);
-                IntegerTypePtr t;
-                checkIntegerValue(args, 0, t, ctx);
-                checkIntegerValue(args, 1, t, ctx);
-                assert(out->size() == 1);
-                CValuePtr out0 = out->values[0];
-                assert(out0->type.ptr() == t.ptr());
-                codegenCallValue(staticCValue(operator_doIntegerSubtractChecked(), ctx),
-                                 args,
-                                 ctx,
-                                 out);
-                break;
-            }
+    case PRIM_pointerToInt: {
+        ensureArity(args, 2);
+        IntegerTypePtr dest = valueToIntegerType(args, 0);
+        llvm::Type *llDest = llvmType(dest.ptr());
+        TypePtr pt;
+        llvm::Value *v = pointerLikeValue(args, 1, pt, ctx);
+        llvm::Value *result = ctx->builder->CreatePtrToInt(v, llDest);
+        assert(out->size() == 1);
+        CValuePtr out0 = out->values[0];
+        assert(out0->type == dest.ptr());
+        ctx->builder->CreateStore(result, out0->llValue);
+        break;
+    }
 
-            case PRIM_integerMultiplyChecked: {
-                ensureArity(args, 2);
-                IntegerTypePtr t;
-                checkIntegerValue(args, 0, t, ctx);
-                checkIntegerValue(args, 1, t, ctx);
-                assert(out->size() == 1);
-                CValuePtr out0 = out->values[0];
-                assert(out0->type.ptr() == t.ptr());
-                codegenCallValue(staticCValue(operator_doIntegerMultiplyChecked(), ctx),
-                                 args,
-                                 ctx,
-                                 out);
-                break;
-            }
+    case PRIM_intToPointer: {
+        ensureArity(args, 2);
+        TypePtr dest = valueToPointerLikeType(args, 0);
+        IntegerTypePtr t;
+        llvm::Value *v = integerValue(args, 1, t, ctx);
+        if (t->isSigned && (typeSize(t.ptr()) < typeSize(cPtrDiffTType)))
+            v = ctx->builder->CreateSExt(v, llvmType(cPtrDiffTType));
+        llvm::Value *result = ctx->builder->CreateIntToPtr(v, llvmType(dest));
+        assert(out->size() == 1);
+        CValuePtr out0 = out->values[0];
+        assert(out0->type == dest);
+        ctx->builder->CreateStore(result, out0->llValue);
+        break;
+    }
 
-            case PRIM_integerQuotientChecked: {
-                ensureArity(args, 2);
-                IntegerTypePtr t;
-                checkIntegerValue(args, 0, t, ctx);
-                checkIntegerValue(args, 1, t, ctx);
-                assert(out->size() == 1);
-                CValuePtr out0 = out->values[0];
-                assert(out0->type.ptr() == t.ptr());
-                codegenCallValue(staticCValue(operator_doIntegerQuotientChecked(), ctx),
-                                 args,
-                                 ctx,
-                                 out);
-                break;
-            }
+    case PRIM_nullPointer: {
+        ensureArity(args, 1);
+        TypePtr dest = valueToPointerLikeType(args, 0);
+        assert(out->size() == 1);
+        CValuePtr out0 = out->values[0];
+        assert(out0->type == dest);
+        llvm::PointerType *llType =
+            llvm::dyn_cast<llvm::PointerType>(llvmType(dest));
+        assert(llType != nullptr);
+        llvm::Value *result = llvm::ConstantPointerNull::get(llType);
+        ctx->builder->CreateStore(result, out0->llValue);
+        break;
+    }
 
-            case PRIM_integerRemainderChecked: {
-                ensureArity(args, 2);
-                IntegerTypePtr t;
-                checkIntegerValue(args, 0, t, ctx);
-                checkIntegerValue(args, 1, t, ctx);
-                assert(out->size() == 1);
-                CValuePtr out0 = out->values[0];
-                assert(out0->type.ptr() == t.ptr());
-                codegenCallValue(staticCValue(operator_doIntegerRemainderChecked(), ctx),
-                                 args,
-                                 ctx,
-                                 out);
-                break;
-            }
+    case PRIM_ByRef:
+        error("no ByRef primitive overload found");
+
+    case PRIM_RecordWithProperties:
+        error("no RecordWithProperties primitive overload found");
+
+    case PRIM_CodePointer:
+        error("no CodePointer primitive overload found");
+
+    case PRIM_makeCodePointer: {
+        if (args->size() < 1)
+            arityError2(1, args->size());
+        ObjectPtr callable = valueToStatic(args, 0);
+        switch (callable->objKind) {
+        case TYPE:
+        case RECORD_DECL:
+        case VARIANT_DECL:
+        case PROCEDURE:
+        case GLOBAL_ALIAS:
+            break;
+        case PRIM_OP:
+            if (!isOverloadablePrimOp(callable))
+                argumentError(0, "pointer to primitive cannot be taken");
+            break;
+        case INTRINSIC:
+            argumentError(0, "pointer to LLVM intrinsic cannot be taken");
+            break;
+        default:
+            argumentError(0, "invalid callable");
+        }
+        vector<PVData> argsPVData;
+        vector<TypePtr> argsKey;
+        for (unsigned i = 1; i < args->size(); ++i) {
+            TypePtr t = valueToType(args, i);
+            argsKey.push_back(t);
+            argsPVData.push_back(PVData(t, false));
+        }
 
-            case PRIM_integerShiftLeftChecked: {
-                ensureArity(args, 2);
-                IntegerTypePtr t;
-                checkIntegerValue(args, 0, t, ctx);
-                checkIntegerValue(args, 1, t, ctx);
-                assert(out->size() == 1);
-                CValuePtr out0 = out->values[0];
-                assert(out0->type.ptr() == t.ptr());
-                codegenCallValue(staticCValue(operator_doIntegerShiftLeftChecked(), ctx),
-                                 args,
-                                 ctx,
-                                 out);
-                break;
-            }
+        CompileContextPusher pusher(callable, argsPVData);
+
+        InvokeEntry *entry = safeAnalyzeCallable(callable, argsPVData);
+        if (entry->callByName)
+            argumentError(0, "cannot create pointer to call-by-name code");
+        assert(entry->analyzed);
+        if (!entry->llvmFunc)
+            codegenCodeBody(entry);
+        assert(entry->llvmFunc);
+        TypePtr cpType =
+            codePointerType(argsKey, entry->returnIsRef, entry->returnTypes);
+        assert(out->size() == 1);
+        CValuePtr out0 = out->values[0];
+        assert(out0->type == cpType);
+        ctx->builder->CreateStore(entry->llvmFunc, out0->llValue);
+        break;
+    }
 
-            case PRIM_integerNegateChecked: {
-                ensureArity(args, 1);
-                IntegerTypePtr t;
-                checkIntegerValue(args, 0, t, ctx);
-                assert(out->size() == 1);
-                CValuePtr out0 = out->values[0];
-                assert(out0->type.ptr() == t.ptr());
-                codegenCallValue(staticCValue(operator_doIntegerNegateChecked(), ctx),
-                                 args,
-                                 ctx,
-                                 out);
-                break;
-            }
+    case PRIM_ExternalCodePointer:
+        error("no ExternalCodePointer primitive overload found");
+
+    case PRIM_makeExternalCodePointer: {
+        if (args->size() < 3)
+            arityError2(3, args->size());
+        ObjectPtr callable = valueToStatic(args, 0);
+        switch (callable->objKind) {
+        case TYPE:
+        case RECORD_DECL:
+        case VARIANT_DECL:
+        case PROCEDURE:
+        case GLOBAL_ALIAS:
+            break;
+        case PRIM_OP:
+            if (!isOverloadablePrimOp(callable))
+                argumentError(0, "pointer to primitive cannot be taken");
+            break;
+        case INTRINSIC:
+            argumentError(0, "pointer to intrinsic cannot be taken");
+            break;
+        default:
+            argumentError(0, "invalid callable");
+        }
 
-            case PRIM_integerConvertChecked: {
-                ensureArity(args, 2);
-                IntegerTypePtr dest = valueToIntegerType(args, 0);
-                assert(out->size() == 1);
-                CValuePtr out0 = out->values[0];
-                assert(out0->type == dest.ptr());
-                codegenCallValue(staticCValue(operator_doIntegerConvertChecked(), ctx),
-                                 args,
-                                 ctx,
-                                 out);
-                break;
-            }
+        ObjectPtr ccObj = valueToStatic(args, 1);
+        ObjectPtr isVarArgObj = valueToStatic(args, 2);
+        CallingConv cc;
+        bool isVarArg;
+        if (!staticToCallingConv(ccObj, cc))
+            argumentError(1, "expecting a calling convention attribute");
+        TypePtr type;
+        if (!staticToBool(isVarArgObj, isVarArg, type))
+            argumentTypeError(2, "static boolean", type);
+
+        if (isVarArg)
+            argumentError(2, "implementing variadic external functions is not "
+                             "yet supported");
+
+        vector<PVData> argsPVData;
+        vector<TypePtr> argsKey;
+        for (unsigned i = 3; i < args->size(); ++i) {
+            TypePtr t = valueToType(args, i);
+            argsKey.push_back(t);
+            argsPVData.push_back(PVData(t, false));
+        }
 
-            case PRIM_Pointer:
-                error("no Pointer primitive overload found");
+        CompileContextPusher pusher(callable, argsPVData);
+
+        InvokeEntry *entry = safeAnalyzeCallable(callable, argsPVData);
+        if (entry->callByName)
+            argumentError(0, "cannot create pointer to call-by-name code");
+        assert(entry->analyzed);
+        if (!entry->llvmFunc)
+            codegenCodeBody(entry);
+        assert(entry->llvmFunc);
+        if (!entry->llvmCWrappers[cc])
+            codegenCWrapper(entry, cc);
+        assert(entry->llvmCWrappers[cc]);
+        TypePtr returnType;
+        if (entry->returnTypes.size() == 0) {
+            returnType = nullptr;
+        } else if (entry->returnTypes.size() == 1) {
+            if (entry->returnIsRef[0])
+                argumentError(0, "cannot create C compatible pointer "
+                                 " to return-by-reference code");
+            returnType = entry->returnTypes[0];
+        } else {
+            argumentError(0, "cannot create C compatible pointer "
+                             "to multi-return code");
+        }
+        TypePtr ccpType = cCodePointerType(cc, argsKey, isVarArg, returnType);
+        assert(out->size() == 1);
+        CValuePtr out0 = out->values[0];
+        assert(out0->type == ccpType);
+
+        llvm::Value *opaqueValue = ctx->builder->CreateBitCast(
+            entry->llvmCWrappers[cc], llvmType(out0->type));
+        ctx->builder->CreateStore(opaqueValue, out0->llValue);
+        break;
+    }
 
-            case PRIM_addressOf: {
-                ensureArity(args, 1);
-                CValuePtr cv = args->values[0];
-                assert(out->size() == 1);
-                CValuePtr out0 = out->values[0];
-                assert(out0->type == pointerType(cv->type));
-                ctx->builder->CreateStore(cv->llValue, out0->llValue);
-                break;
-            }
+    case PRIM_callExternalCodePointer: {
+        if (args->size() < 1)
+            arityError2(1, args->size());
+        CCodePointerTypePtr cpt;
+        cCodePointerValue(args, 0, cpt);
+        MultiCValuePtr args2 = new MultiCValue();
+        for (size_t i = 1; i < args->size(); ++i)
+            args2->add(args->values[i]);
+        codegenCallCCodePointer(args->values[0], args2, ctx, out);
+        break;
+    }
 
-            case PRIM_pointerDereference: {
-                ensureArity(args, 1);
-                PointerTypePtr t;
-                llvm::Value *v = pointerValue(args, 0, t, ctx);
-                assert(out->size() == 1);
-                CValuePtr out0 = out->values[0];
-                assert(out0->type == t.ptr());
-                ctx->builder->CreateStore(v, out0->llValue);
-                break;
-            }
+    case PRIM_bitcast: {
+        ensureArity(args, 2);
+        TypePtr dest = valueToType(args, 0);
+        CValuePtr src = args->values[1];
+        if (typeSize(dest) > typeSize(src->type))
+            error("destination type for bitcast is larger than source type");
+        if (typeAlignment(dest) > typeAlignment(src->type))
+            error("destination type for bitcast has stricter alignment than "
+                  "source type");
+        llvm::Value *arg1 = args->values[1]->llValue;
+        assert(out->size() == 1);
+        CValuePtr out0 = out->values[0];
+        assert(out0->type == pointerType(dest));
+        llvm::Value *result =
+            ctx->builder->CreateBitCast(arg1, llvmPointerType(dest));
+        ctx->builder->CreateStore(result, out0->llValue);
+        break;
+    }
 
-            case PRIM_pointerOffset: {
-                ensureArity(args, 2);
-                PointerTypePtr t;
-                llvm::Value *v0 = pointerValue(args, 0, t, ctx);
-                IntegerTypePtr offsetT;
-                llvm::Value *v1 = integerValue(args, 1, offsetT, ctx);
-                if (!offsetT->isSigned && (size_t) offsetT->bits < typeSize(cSizeTType) * 8)
-                    v1 = ctx->builder->CreateZExt(v1, llvmType(cSizeTType));
-                vector<llvm::Value *> indices;
-                indices.push_back(v1);
-                llvm::Value *result = ctx->builder->CreateGEP(v0,
-                                                              llvm::ArrayRef(indices));
-                assert(out->size() == 1);
-                CValuePtr out0 = out->values[0];
-                assert(out0->type == t.ptr());
-                ctx->builder->CreateStore(result, out0->llValue);
-                break;
-            }
+    case PRIM_Array:
+        error("no Array primitive overload found");
+
+    case PRIM_arrayRef: {
+        ensureArity(args, 2);
+        ArrayTypePtr at;
+        llvm::Value *av = arrayValue(args, 0, at);
+        IntegerTypePtr indexType;
+        llvm::Value *iv = integerValue(args, 1, indexType, ctx);
+        if (!indexType->isSigned &&
+            (size_t)indexType->bits < typeSize(cSizeTType) * 8)
+            iv = ctx->builder->CreateZExt(iv, llvmType(cSizeTType));
+        vector<llvm::Value *> indices;
+        indices.push_back(llvm::ConstantInt::get(llvmIntType(32), 0));
+        indices.push_back(iv);
+        llvm::Value *ptr = ctx->builder->CreateGEP(av, llvm::ArrayRef(indices));
+        assert(out->size() == 1);
+        CValuePtr out0 = out->values[0];
+        assert(out0->type == pointerType(at->elementType));
+        ctx->builder->CreateStore(ptr, out0->llValue);
+        break;
+    }
 
-            case PRIM_pointerToInt: {
-                ensureArity(args, 2);
-                IntegerTypePtr dest = valueToIntegerType(args, 0);
-                llvm::Type *llDest = llvmType(dest.ptr());
-                TypePtr pt;
-                llvm::Value *v = pointerLikeValue(args, 1, pt, ctx);
-                llvm::Value *result = ctx->builder->CreatePtrToInt(v, llDest);
-                assert(out->size() == 1);
-                CValuePtr out0 = out->values[0];
-                assert(out0->type == dest.ptr());
-                ctx->builder->CreateStore(result, out0->llValue);
-                break;
-            }
+    case PRIM_arrayElements: {
+        ensureArity(args, 1);
+        ArrayTypePtr at;
+        llvm::Value *varray = arrayValue(args, 0, at);
+        assert(out->size() == (size_t)at->size);
+        for (unsigned i = 0; i < at->size; ++i) {
+            CValuePtr outi = out->values[i];
+            assert(outi->type == pointerType(at->elementType));
+            llvm::Value *ptr = ctx->builder->CreateConstGEP2_32(varray, 0, i);
+            ctx->builder->CreateStore(ptr, outi->llValue);
+        }
+        break;
+    }
 
-            case PRIM_intToPointer: {
-                ensureArity(args, 2);
-                TypePtr dest = valueToPointerLikeType(args, 0);
-                IntegerTypePtr t;
-                llvm::Value *v = integerValue(args, 1, t, ctx);
-                if (t->isSigned && (typeSize(t.ptr()) < typeSize(cPtrDiffTType)))
-                    v = ctx->builder->CreateSExt(v, llvmType(cPtrDiffTType));
-                llvm::Value *result = ctx->builder->CreateIntToPtr(v, llvmType(dest));
-                assert(out->size() == 1);
-                CValuePtr out0 = out->values[0];
-                assert(out0->type == dest);
-                ctx->builder->CreateStore(result, out0->llValue);
-                break;
-            }
+    case PRIM_Vec:
+        error("no Vec primitive overload found");
 
-            case PRIM_nullPointer: {
-                ensureArity(args, 1);
-                TypePtr dest = valueToPointerLikeType(args, 0);
-                assert(out->size() == 1);
-                CValuePtr out0 = out->values[0];
-                assert(out0->type == dest);
-                llvm::PointerType *llType = llvm::dyn_cast<llvm::PointerType>(llvmType(dest));
-                assert(llType != nullptr);
-                llvm::Value *result = llvm::ConstantPointerNull::get(llType);
-                ctx->builder->CreateStore(result, out0->llValue);
-                break;
-            }
+    case PRIM_Tuple:
+        error("no Tuple primitive overload found");
 
-            case PRIM_ByRef:
-                error("no ByRef primitive overload found");
-
-            case PRIM_RecordWithProperties:
-                error("no RecordWithProperties primitive overload found");
-
-            case PRIM_CodePointer:
-                error("no CodePointer primitive overload found");
-
-            case PRIM_makeCodePointer: {
-                if (args->size() < 1)
-                    arityError2(1, args->size());
-                ObjectPtr callable = valueToStatic(args, 0);
-                switch (callable->objKind) {
-                    case TYPE:
-                    case RECORD_DECL:
-                    case VARIANT_DECL:
-                    case PROCEDURE:
-                    case GLOBAL_ALIAS:
-                        break;
-                    case PRIM_OP:
-                        if (!isOverloadablePrimOp(callable))
-                            argumentError(0, "pointer to primitive cannot be taken");
-                        break;
-                    case INTRINSIC:
-                        argumentError(0, "pointer to LLVM intrinsic cannot be taken");
-                        break;
-                    default:
-                        argumentError(0, "invalid callable");
-                }
-                vector<PVData> argsPVData;
-                vector<TypePtr> argsKey;
-                for (unsigned i = 1; i < args->size(); ++i) {
-                    TypePtr t = valueToType(args, i);
-                    argsKey.push_back(t);
-                    argsPVData.push_back(PVData(t, false));
-                }
+    case PRIM_TupleElementCount: {
+        ensureArity(args, 1);
+        TupleTypePtr t = valueToTupleType(args, 0);
+        ValueHolderPtr vh = sizeTToValueHolder(t->elementTypes.size());
+        codegenStaticObject(vh.ptr(), ctx, out);
+        break;
+    }
 
-                CompileContextPusher pusher(callable, argsPVData);
-
-                InvokeEntry *entry =
-                        safeAnalyzeCallable(callable, argsPVData);
-                if (entry->callByName)
-                    argumentError(0, "cannot create pointer to call-by-name code");
-                assert(entry->analyzed);
-                if (!entry->llvmFunc)
-                    codegenCodeBody(entry);
-                assert(entry->llvmFunc);
-                TypePtr cpType = codePointerType(argsKey,
-                                                 entry->returnIsRef,
-                                                 entry->returnTypes);
-                assert(out->size() == 1);
-                CValuePtr out0 = out->values[0];
-                assert(out0->type == cpType);
-                ctx->builder->CreateStore(entry->llvmFunc, out0->llValue);
-                break;
-            }
+    case PRIM_tupleRef: {
+        ensureArity(args, 2);
+        TupleTypePtr tt;
+        llvm::Value *vtuple = tupleValue(args, 0, tt);
+        size_t i = valueToStaticSizeTOrInt(args, 1);
+        if (i >= tt->elementTypes.size())
+            argumentIndexRangeError(1, "tuple element index", i,
+                                    tt->elementTypes.size());
+        llvm::Value *ptr =
+            ctx->builder->CreateConstGEP2_32(vtuple, 0, unsigned(i));
+        assert(out->size() == 1);
+        CValuePtr out0 = out->values[0];
+        assert(out0->type == pointerType(tt->elementTypes[i]));
+        ctx->builder->CreateStore(ptr, out0->llValue);
+        break;
+    }
 
-            case PRIM_ExternalCodePointer:
-                error("no ExternalCodePointer primitive overload found");
-
-            case PRIM_makeExternalCodePointer: {
-                if (args->size() < 3)
-                    arityError2(3, args->size());
-                ObjectPtr callable = valueToStatic(args, 0);
-                switch (callable->objKind) {
-                    case TYPE:
-                    case RECORD_DECL:
-                    case VARIANT_DECL:
-                    case PROCEDURE:
-                    case GLOBAL_ALIAS:
-                        break;
-                    case PRIM_OP:
-                        if (!isOverloadablePrimOp(callable))
-                            argumentError(0, "pointer to primitive cannot be taken");
-                        break;
-                    case INTRINSIC:
-                        argumentError(0, "pointer to intrinsic cannot be taken");
-                        break;
-                    default:
-                        argumentError(0, "invalid callable");
-                }
+    case PRIM_tupleElements: {
+        ensureArity(args, 1);
+        TupleTypePtr tt;
+        llvm::Value *vtuple = tupleValue(args, 0, tt);
+        assert(out->size() == tt->elementTypes.size());
+        for (unsigned i = 0; i < tt->elementTypes.size(); ++i) {
+            CValuePtr outi = out->values[i];
+            assert(outi->type == pointerType(tt->elementTypes[i]));
+            llvm::Value *ptr = ctx->builder->CreateConstGEP2_32(vtuple, 0, i);
+            ctx->builder->CreateStore(ptr, outi->llValue);
+        }
+        break;
+    }
 
-                ObjectPtr ccObj = valueToStatic(args, 1);
-                ObjectPtr isVarArgObj = valueToStatic(args, 2);
-                CallingConv cc;
-                bool isVarArg;
-                if (!staticToCallingConv(ccObj, cc))
-                    argumentError(1, "expecting a calling convention attribute");
-                TypePtr type;
-                if (!staticToBool(isVarArgObj, isVarArg, type))
-                    argumentTypeError(2, "static boolean", type);
-
-                if (isVarArg)
-                    argumentError(2, "implementing variadic external functions is not yet supported");
-
-                vector<PVData> argsPVData;
-                vector<TypePtr> argsKey;
-                for (unsigned i = 3; i < args->size(); ++i) {
-                    TypePtr t = valueToType(args, i);
-                    argsKey.push_back(t);
-                    argsPVData.push_back(PVData(t, false));
-                }
+    case PRIM_Union:
+        error("no Union primitive overload found");
 
-                CompileContextPusher pusher(callable, argsPVData);
-
-                InvokeEntry *entry =
-                        safeAnalyzeCallable(callable, argsPVData);
-                if (entry->callByName)
-                    argumentError(0, "cannot create pointer to call-by-name code");
-                assert(entry->analyzed);
-                if (!entry->llvmFunc)
-                    codegenCodeBody(entry);
-                assert(entry->llvmFunc);
-                if (!entry->llvmCWrappers[cc])
-                    codegenCWrapper(entry, cc);
-                assert(entry->llvmCWrappers[cc]);
-                TypePtr returnType;
-                if (entry->returnTypes.size() == 0) {
-                    returnType = nullptr;
-                } else if (entry->returnTypes.size() == 1) {
-                    if (entry->returnIsRef[0])
-                        argumentError(0, "cannot create C compatible pointer "
-                                      " to return-by-reference code");
-                    returnType = entry->returnTypes[0];
-                } else {
-                    argumentError(0, "cannot create C compatible pointer "
-                                  "to multi-return code");
-                }
-                TypePtr ccpType = cCodePointerType(cc,
-                                                   argsKey,
-                                                   isVarArg,
-                                                   returnType);
-                assert(out->size() == 1);
-                CValuePtr out0 = out->values[0];
-                assert(out0->type == ccpType);
+    case PRIM_UnionMemberCount: {
+        ensureArity(args, 1);
+        UnionTypePtr t = valueToUnionType(args, 0);
+        ValueHolderPtr vh = sizeTToValueHolder(t->memberTypes.size());
+        codegenStaticObject(vh.ptr(), ctx, out);
+        break;
+    }
 
-                llvm::Value *opaqueValue = ctx->builder->CreateBitCast(
-                    entry->llvmCWrappers[cc], llvmType(out0->type));
-                ctx->builder->CreateStore(opaqueValue, out0->llValue);
-                break;
-            }
+    case PRIM_RecordP: {
+        ensureArity(args, 1);
+        bool isRecordType = false;
+        ObjectPtr obj = valueToStatic(args->values[0]);
+        if (obj.ptr() && (obj->objKind == TYPE)) {
+            Type *t = (Type *)obj.ptr();
+            if (t->typeKind == RECORD_TYPE)
+                isRecordType = true;
+        }
+        ValueHolderPtr vh = boolToValueHolder(isRecordType);
+        codegenStaticObject(vh.ptr(), ctx, out);
+        break;
+    }
 
-            case PRIM_callExternalCodePointer: {
-                if (args->size() < 1)
-                    arityError2(1, args->size());
-                CCodePointerTypePtr cpt;
-                cCodePointerValue(args, 0, cpt);
-                MultiCValuePtr args2 = new MultiCValue();
-                for (size_t i = 1; i < args->size(); ++i)
-                    args2->add(args->values[i]);
-                codegenCallCCodePointer(args->values[0], args2, ctx, out);
-                break;
-            }
+    case PRIM_RecordFieldCount: {
+        ensureArity(args, 1);
+        RecordTypePtr rt = valueToRecordType(args, 0);
+        ValueHolderPtr vh = sizeTToValueHolder(rt->fieldCount());
+        codegenStaticObject(vh.ptr(), ctx, out);
+        break;
+    }
 
-            case PRIM_bitcast: {
-                ensureArity(args, 2);
-                TypePtr dest = valueToType(args, 0);
-                CValuePtr src = args->values[1];
-                if (typeSize(dest) > typeSize(src->type))
-                    error("destination type for bitcast is larger than source type");
-                if (typeAlignment(dest) > typeAlignment(src->type))
-                    error("destination type for bitcast has stricter alignment than source type");
-                llvm::Value *arg1 = args->values[1]->llValue;
-                assert(out->size() == 1);
-                CValuePtr out0 = out->values[0];
-                assert(out0->type == pointerType(dest));
-                llvm::Value *result = ctx->builder->CreateBitCast(arg1, llvmPointerType(dest));
-                ctx->builder->CreateStore(result, out0->llValue);
-                break;
-            }
+    case PRIM_RecordFieldName: {
+        ensureArity(args, 2);
+        RecordTypePtr rt = valueToRecordType(args, 0);
+        size_t i = valueToStaticSizeTOrInt(args, 1);
+        llvm::ArrayRef<IdentifierPtr> fieldNames = recordFieldNames(rt);
+        if (i >= fieldNames.size())
+            argumentIndexRangeError(1, "record field index", i,
+                                    fieldNames.size());
+        codegenStaticObject(fieldNames[i].ptr(), ctx, out);
+        break;
+    }
 
-            case PRIM_Array:
-                error("no Array primitive overload found");
-
-            case PRIM_arrayRef: {
-                ensureArity(args, 2);
-                ArrayTypePtr at;
-                llvm::Value *av = arrayValue(args, 0, at);
-                IntegerTypePtr indexType;
-                llvm::Value *iv = integerValue(args, 1, indexType, ctx);
-                if (!indexType->isSigned && (size_t) indexType->bits < typeSize(cSizeTType) * 8)
-                    iv = ctx->builder->CreateZExt(iv, llvmType(cSizeTType));
-                vector<llvm::Value *> indices;
-                indices.push_back(llvm::ConstantInt::get(llvmIntType(32), 0));
-                indices.push_back(iv);
-                llvm::Value *ptr =
-                        ctx->builder->CreateGEP(av, llvm::ArrayRef(indices));
-                assert(out->size() == 1);
-                CValuePtr out0 = out->values[0];
-                assert(out0->type == pointerType(at->elementType));
-                ctx->builder->CreateStore(ptr, out0->llValue);
-                break;
+    case PRIM_RecordWithFieldP: {
+        ensureArity(args, 2);
+        bool result = false;
+        ObjectPtr obj = valueToStatic(args->values[0]);
+        llvm::StringRef fname = valueToStringRef(args, 1);
+        if (obj.ptr() && (obj->objKind == TYPE)) {
+            Type *t = (Type *)obj.ptr();
+            if (t->typeKind == RECORD_TYPE) {
+                RecordType *rt = (RecordType *)t;
+                const llvm::StringMap<size_t> &fieldIndexMap =
+                    recordFieldIndexMap(rt);
+                result = (fieldIndexMap.find(fname) != fieldIndexMap.end());
             }
+        }
+        ValueHolderPtr vh = boolToValueHolder(result);
+        codegenStaticObject(vh.ptr(), ctx, out);
+        break;
+    }
 
-            case PRIM_arrayElements: {
-                ensureArity(args, 1);
-                ArrayTypePtr at;
-                llvm::Value *varray = arrayValue(args, 0, at);
-                assert(out->size() == (size_t)at->size);
-                for (unsigned i = 0; i < at->size; ++i) {
-                    CValuePtr outi = out->values[i];
-                    assert(outi->type == pointerType(at->elementType));
-                    llvm::Value *ptr = ctx->builder->CreateConstGEP2_32(varray, 0, i);
+    case PRIM_recordFieldRef: {
+        ensureArity(args, 2);
+        RecordTypePtr rt;
+        llvm::Value *vrec = recordValue(args, 0, rt);
+        size_t i = valueToStaticSizeTOrInt(args, 1);
+        llvm::ArrayRef<TypePtr> fieldTypes = recordFieldTypes(rt);
+        if (i >= rt->fieldCount())
+            argumentIndexRangeError(1, "record field index", i,
+                                    rt->fieldCount());
+
+        if (rt->hasVarField && i >= rt->varFieldPosition) {
+            if (i == rt->varFieldPosition) {
+                assert(out->size() == rt->varFieldSize());
+                for (unsigned j = 0; j < rt->varFieldSize(); ++j) {
+                    CValuePtr outi = out->values[j];
+                    assert(outi->type == pointerType(fieldTypes[i + j]));
+                    llvm::Value *ptr = ctx->builder->CreateConstGEP2_32(
+                        vrec, 0, unsigned(i) + j);
                     ctx->builder->CreateStore(ptr, outi->llValue);
                 }
-                break;
-            }
-
-            case PRIM_Vec:
-                error("no Vec primitive overload found");
-
-            case PRIM_Tuple:
-                error("no Tuple primitive overload found");
-
-            case PRIM_TupleElementCount: {
-                ensureArity(args, 1);
-                TupleTypePtr t = valueToTupleType(args, 0);
-                ValueHolderPtr vh = sizeTToValueHolder(t->elementTypes.size());
-                codegenStaticObject(vh.ptr(), ctx, out);
-                break;
-            }
-
-            case PRIM_tupleRef: {
-                ensureArity(args, 2);
-                TupleTypePtr tt;
-                llvm::Value *vtuple = tupleValue(args, 0, tt);
-                size_t i = valueToStaticSizeTOrInt(args, 1);
-                if (i >= tt->elementTypes.size())
-                    argumentIndexRangeError(1, "tuple element index",
-                                            i, tt->elementTypes.size());
-                llvm::Value *ptr = ctx->builder->CreateConstGEP2_32(vtuple, 0, unsigned(i));
+            } else {
+                unsigned k = unsigned(i + rt->varFieldSize() - 1);
+                llvm::Value *ptr = ctx->builder->CreateConstGEP2_32(vrec, 0, k);
                 assert(out->size() == 1);
                 CValuePtr out0 = out->values[0];
-                assert(out0->type == pointerType(tt->elementTypes[i]));
+                assert(out0->type == pointerType(fieldTypes[k]));
                 ctx->builder->CreateStore(ptr, out0->llValue);
-                break;
-            }
-
-            case PRIM_tupleElements: {
-                ensureArity(args, 1);
-                TupleTypePtr tt;
-                llvm::Value *vtuple = tupleValue(args, 0, tt);
-                assert(out->size() == tt->elementTypes.size());
-                for (unsigned i = 0; i < tt->elementTypes.size(); ++i) {
-                    CValuePtr outi = out->values[i];
-                    assert(outi->type == pointerType(tt->elementTypes[i]));
-                    llvm::Value *ptr = ctx->builder->CreateConstGEP2_32(vtuple, 0, i);
-                    ctx->builder->CreateStore(ptr, outi->llValue);
-                }
-                break;
-            }
-
-            case PRIM_Union:
-                error("no Union primitive overload found");
-
-            case PRIM_UnionMemberCount: {
-                ensureArity(args, 1);
-                UnionTypePtr t = valueToUnionType(args, 0);
-                ValueHolderPtr vh = sizeTToValueHolder(t->memberTypes.size());
-                codegenStaticObject(vh.ptr(), ctx, out);
-                break;
-            }
-
-            case PRIM_RecordP: {
-                ensureArity(args, 1);
-                bool isRecordType = false;
-                ObjectPtr obj = valueToStatic(args->values[0]);
-                if (obj.ptr() && (obj->objKind == TYPE)) {
-                    Type *t = (Type *) obj.ptr();
-                    if (t->typeKind == RECORD_TYPE)
-                        isRecordType = true;
-                }
-                ValueHolderPtr vh = boolToValueHolder(isRecordType);
-                codegenStaticObject(vh.ptr(), ctx, out);
-                break;
-            }
-
-            case PRIM_RecordFieldCount: {
-                ensureArity(args, 1);
-                RecordTypePtr rt = valueToRecordType(args, 0);
-                ValueHolderPtr vh = sizeTToValueHolder(rt->fieldCount());
-                codegenStaticObject(vh.ptr(), ctx, out);
-                break;
-            }
-
-            case PRIM_RecordFieldName: {
-                ensureArity(args, 2);
-                RecordTypePtr rt = valueToRecordType(args, 0);
-                size_t i = valueToStaticSizeTOrInt(args, 1);
-                llvm::ArrayRef<IdentifierPtr> fieldNames = recordFieldNames(rt);
-                if (i >= fieldNames.size())
-                    argumentIndexRangeError(1, "record field index",
-                                            i, fieldNames.size());
-                codegenStaticObject(fieldNames[i].ptr(), ctx, out);
-                break;
-            }
-
-            case PRIM_RecordWithFieldP: {
-                ensureArity(args, 2);
-                bool result = false;
-                ObjectPtr obj = valueToStatic(args->values[0]);
-                llvm::StringRef fname = valueToStringRef(args, 1);
-                if (obj.ptr() && (obj->objKind == TYPE)) {
-                    Type *t = (Type *) obj.ptr();
-                    if (t->typeKind == RECORD_TYPE) {
-                        RecordType *rt = (RecordType *) t;
-                        const llvm::StringMap<size_t> &fieldIndexMap =
-                                recordFieldIndexMap(rt);
-                        result = (fieldIndexMap.find(fname)
-                                  != fieldIndexMap.end());
-                    }
-                }
-                ValueHolderPtr vh = boolToValueHolder(result);
-                codegenStaticObject(vh.ptr(), ctx, out);
-                break;
-            }
-
-            case PRIM_recordFieldRef: {
-                ensureArity(args, 2);
-                RecordTypePtr rt;
-                llvm::Value *vrec = recordValue(args, 0, rt);
-                size_t i = valueToStaticSizeTOrInt(args, 1);
-                llvm::ArrayRef<TypePtr> fieldTypes = recordFieldTypes(rt);
-                if (i >= rt->fieldCount())
-                    argumentIndexRangeError(1, "record field index",
-                                            i, rt->fieldCount());
-
-                if (rt->hasVarField && i >= rt->varFieldPosition) {
-                    if (i == rt->varFieldPosition) {
-                        assert(out->size() == rt->varFieldSize());
-                        for (unsigned j = 0; j < rt->varFieldSize(); ++j) {
-                            CValuePtr outi = out->values[j];
-                            assert(outi->type == pointerType(fieldTypes[i+j]));
-                            llvm::Value *ptr = ctx->builder->CreateConstGEP2_32(vrec, 0, unsigned(i) + j);
-                            ctx->builder->CreateStore(ptr, outi->llValue);
-                        }
-                    } else {
-                        unsigned k = unsigned(i + rt->varFieldSize() - 1);
-                        llvm::Value *ptr = ctx->builder->CreateConstGEP2_32(vrec, 0, k);
-                        assert(out->size() == 1);
-                        CValuePtr out0 = out->values[0];
-                        assert(out0->type == pointerType(fieldTypes[k]));
-                        ctx->builder->CreateStore(ptr, out0->llValue);
-                    }
-                } else {
-                    llvm::Value *ptr = ctx->builder->CreateConstGEP2_32(vrec, 0, unsigned(i));
-                    assert(out->size() == 1);
-                    CValuePtr out0 = out->values[0];
-                    assert(out0->type == pointerType(fieldTypes[i]));
-                    ctx->builder->CreateStore(ptr, out0->llValue);
-                }
-
-                break;
-            }
-
-            case PRIM_recordFieldRefByName: {
-                ensureArity(args, 2);
-                RecordTypePtr rt;
-                llvm::Value *vrec = recordValue(args, 0, rt);
-                llvm::StringRef fname = valueToStringRef(args, 1);
-                const llvm::StringMap<size_t> &fieldIndexMap = recordFieldIndexMap(rt);
-                llvm::StringMap<size_t>::const_iterator fi =
-                        fieldIndexMap.find(fname);
-                if (fi == fieldIndexMap.end()) {
-                    string buf;
-                    llvm::raw_string_ostream sout(buf);
-                    sout << "field not found: " << fname;
-                    argumentError(1, sout.str());
-                }
-                unsigned i = unsigned(fi->second);
-                llvm::ArrayRef<TypePtr> fieldTypes = recordFieldTypes(rt);
-                if (rt->hasVarField && i >= rt->varFieldPosition) {
-                    if (i == rt->varFieldPosition) {
-                        assert(out->size() == rt->varFieldSize());
-                        for (unsigned j = 0; j < rt->varFieldSize(); ++j) {
-                            CValuePtr outi = out->values[j];
-                            assert(outi->type == pointerType(fieldTypes[i+j]));
-                            llvm::Value *ptr = ctx->builder->CreateConstGEP2_32(vrec, 0, i + j);
-                            ctx->builder->CreateStore(ptr, outi->llValue);
-                        }
-                    } else {
-                        unsigned k = i + unsigned(rt->varFieldSize()) - 1;
-                        llvm::Value *ptr = ctx->builder->CreateConstGEP2_32(vrec, 0, k);
-                        assert(out->size() == 1);
-                        CValuePtr out0 = out->values[0];
-                        assert(out0->type == pointerType(fieldTypes[k]));
-                        ctx->builder->CreateStore(ptr, out0->llValue);
-                    }
-                } else {
-                    llvm::Value *ptr = ctx->builder->CreateConstGEP2_32(vrec, 0, i);
-                    assert(out->size() == 1);
-                    CValuePtr out0 = out->values[0];
-                    assert(out0->type == pointerType(fieldTypes[i]));
-                    ctx->builder->CreateStore(ptr, out0->llValue);
-                }
-                break;
             }
+        } else {
+            llvm::Value *ptr =
+                ctx->builder->CreateConstGEP2_32(vrec, 0, unsigned(i));
+            assert(out->size() == 1);
+            CValuePtr out0 = out->values[0];
+            assert(out0->type == pointerType(fieldTypes[i]));
+            ctx->builder->CreateStore(ptr, out0->llValue);
+        }
 
-            case PRIM_recordFields: {
-                ensureArity(args, 1);
-                RecordTypePtr rt;
-                llvm::Value *vrec = recordValue(args, 0, rt);
-                llvm::ArrayRef<TypePtr> fieldTypes = recordFieldTypes(rt);
-                assert(out->size() == fieldTypes.size());
-                for (unsigned i = 0; i < fieldTypes.size(); ++i) {
-                    CValuePtr outi = out->values[i];
-                    assert(outi->type == pointerType(fieldTypes[i]));
-                    llvm::Value *ptr = ctx->builder->CreateConstGEP2_32(vrec, 0, i);
-                    ctx->builder->CreateStore(ptr, outi->llValue);
-                }
-                break;
-            }
+        break;
+    }
 
-            case PRIM_recordVariadicField: {
-                ensureArity(args, 1);
-                RecordTypePtr rt;
-                llvm::Value *vrec = recordValue(args, 0, rt);
-                llvm::ArrayRef<TypePtr> fieldTypes = recordFieldTypes(rt);
-                if (!rt->hasVarField)
-                    argumentError(0, "expecting a record with a variadic field");
+    case PRIM_recordFieldRefByName: {
+        ensureArity(args, 2);
+        RecordTypePtr rt;
+        llvm::Value *vrec = recordValue(args, 0, rt);
+        llvm::StringRef fname = valueToStringRef(args, 1);
+        const llvm::StringMap<size_t> &fieldIndexMap = recordFieldIndexMap(rt);
+        llvm::StringMap<size_t>::const_iterator fi = fieldIndexMap.find(fname);
+        if (fi == fieldIndexMap.end()) {
+            string buf;
+            llvm::raw_string_ostream sout(buf);
+            sout << "field not found: " << fname;
+            argumentError(1, sout.str());
+        }
+        unsigned i = unsigned(fi->second);
+        llvm::ArrayRef<TypePtr> fieldTypes = recordFieldTypes(rt);
+        if (rt->hasVarField && i >= rt->varFieldPosition) {
+            if (i == rt->varFieldPosition) {
                 assert(out->size() == rt->varFieldSize());
-                for (unsigned i = 0; i < rt->varFieldSize(); ++i) {
-                    unsigned k = rt->varFieldPosition + i;
-                    CValuePtr outi = out->values[i];
-                    assert(outi->type == pointerType(fieldTypes[k]));
-                    llvm::Value *ptr = ctx->builder->CreateConstGEP2_32(vrec, 0, k);
+                for (unsigned j = 0; j < rt->varFieldSize(); ++j) {
+                    CValuePtr outi = out->values[j];
+                    assert(outi->type == pointerType(fieldTypes[i + j]));
+                    llvm::Value *ptr =
+                        ctx->builder->CreateConstGEP2_32(vrec, 0, i + j);
                     ctx->builder->CreateStore(ptr, outi->llValue);
                 }
-                break;
-            }
-
-            case PRIM_VariantP: {
-                ensureArity(args, 1);
-                bool isVariantType = false;
-                ObjectPtr obj = valueToStatic(args->values[0]);
-                if (obj.ptr() && (obj->objKind == TYPE)) {
-                    Type *t = (Type *) obj.ptr();
-                    if (t->typeKind == VARIANT_TYPE)
-                        isVariantType = true;
-                }
-                ValueHolderPtr vh = boolToValueHolder(isVariantType);
-                codegenStaticObject(vh.ptr(), ctx, out);
-                break;
-            }
-
-            case PRIM_VariantMemberIndex: {
-                ensureArity(args, 2);
-                VariantTypePtr vt = valueToVariantType(args, 0);
-                TypePtr mt = valueToType(args, 1);
-                llvm::ArrayRef<TypePtr> memberTypes = variantMemberTypes(vt);
-                size_t index = (size_t) -1;
-                for (size_t i = 0; i < memberTypes.size(); ++i) {
-                    if (memberTypes[i] == mt) {
-                        index = i;
-                        break;
-                    }
-                }
-                ValueHolderPtr vh = sizeTToValueHolder(index);
-                codegenStaticObject(vh.ptr(), ctx, out);
-                break;
-            }
-
-            case PRIM_VariantMemberCount: {
-                ensureArity(args, 1);
-                VariantTypePtr vt = valueToVariantType(args, 0);
-                llvm::ArrayRef<TypePtr> memberTypes = variantMemberTypes(vt);
-                size_t size = memberTypes.size();
-                ValueHolderPtr vh = sizeTToValueHolder(size);
-                codegenStaticObject(vh.ptr(), ctx, out);
-                break;
-            }
-
-            case PRIM_VariantMembers:
-                break;
-
-            case PRIM_BaseType:
-                break;
-
-            case PRIM_Static:
-                error("no Static primitive overload found");
-
-            case PRIM_StaticName:
-            case PRIM_MainModule:
-            case PRIM_StaticModule:
-            case PRIM_ModuleName:
-            case PRIM_ModuleMemberNames:
-                break;
-
-            case PRIM_staticIntegers:
-                break;
-
-            case PRIM_integers: {
-                ensureArity(args, 1);
-                ObjectPtr obj = valueToStatic(args, 0);
-                if (obj->objKind != VALUE_HOLDER)
-                    argumentError(0, "expecting a static SizeT or Int value");
-                ValueHolder *vh = (ValueHolder *) obj.ptr();
-                if (vh->type == cIntType) {
-                    int count = vh->as<int>();
-                    if (count < 0)
-                        argumentError(0, "negative values are not allowed");
-                    assert(out->size() == (size_t)count);
-                    for (int i = 0; i < count; ++i) {
-                        ValueHolderPtr vhi = intToValueHolder(i);
-                        CValuePtr outi = out->values[(size_t) i];
-                        assert(outi->type == cIntType);
-                        llvm::Constant *value = llvm::ConstantInt::get(llvmIntType(32), (size_t) i);
-                        ctx->builder->CreateStore(value, outi->llValue);
-                    }
-                } else if (vh->type == cSizeTType) {
-                    size_t count = vh->as<size_t>();
-                    assert(out->size() == count);
-                    for (size_t i = 0; i < count; ++i) {
-                        ValueHolderPtr vhi = sizeTToValueHolder(i);
-                        CValuePtr outi = out->values[i];
-                        assert(outi->type == cSizeTType);
-                        llvm::Type *llSizeTType = llvmIntType(unsigned(typeSize(cSizeTType) * 8));
-                        llvm::Constant *value = llvm::ConstantInt::get(llSizeTType, i);
-                        ctx->builder->CreateStore(value, outi->llValue);
-                    }
-                } else {
-                    argumentError(0, "expecting a static SizeT or Int value");
-                }
-                break;
-            }
-
-            case PRIM_staticFieldRef: {
-                ensureArity(args, 2);
-                ObjectPtr moduleObj = valueToStatic(args, 0);
-                if (moduleObj->objKind != MODULE)
-                    argumentError(0, "expecting a module");
-                Module *module = (Module *) moduleObj.ptr();
-                IdentifierPtr ident = valueToIdentifier(args, 1);
-                ObjectPtr obj = safeLookupPublic(module, ident);
-                codegenStaticObject(obj, ctx, out);
-                break;
-            }
-
-            case PRIM_EnumP: {
-                ensureArity(args, 1);
-                bool isEnumType = false;
-                ObjectPtr obj = valueToStatic(args->values[0]);
-                if (obj.ptr() && (obj->objKind == TYPE)) {
-                    Type *t = (Type *) obj.ptr();
-                    if (t->typeKind == ENUM_TYPE)
-                        isEnumType = true;
-                }
-                ValueHolderPtr vh = boolToValueHolder(isEnumType);
-                codegenStaticObject(vh.ptr(), ctx, out);
-                break;
-            }
-
-            case PRIM_EnumMemberCount: {
-                ensureArity(args, 1);
-                EnumTypePtr et = valueToEnumType(args, 0);
-                size_t n = et->enumeration->members.size();
-                ValueHolderPtr vh = sizeTToValueHolder(n);
-                codegenStaticObject(vh.ptr(), ctx, out);
-                break;
-            }
-
-            case PRIM_EnumMemberName:
-                break;
-
-            case PRIM_enumToInt: {
-                ensureArity(args, 1);
-                EnumTypePtr et;
-                llvm::Value *v = enumValue(args, 0, et, ctx);
+            } else {
+                unsigned k = i + unsigned(rt->varFieldSize()) - 1;
+                llvm::Value *ptr = ctx->builder->CreateConstGEP2_32(vrec, 0, k);
                 assert(out->size() == 1);
                 CValuePtr out0 = out->values[0];
-                assert(out0->type == cIntType);
-                ctx->builder->CreateStore(v, out0->llValue);
-                break;
-            }
-
-            case PRIM_intToEnum: {
-                ensureArity(args, 2);
-                EnumTypePtr et = valueToEnumType(args, 0);
-                IntegerTypePtr it = (IntegerType *) cIntType.ptr();
-                llvm::Value *v = integerValue(args, 1, it, ctx);
-                assert(out->size() == 1);
-                CValuePtr out0 = out->values[0];
-                assert(out0->type == et.ptr());
-                ctx->builder->CreateStore(v, out0->llValue);
-                break;
-            }
-
-            case PRIM_StringLiteralP: {
-                ensureArity(args, 1);
-                bool result = false;
-                CValuePtr cv0 = args->values[0];
-                if (cv0->type->typeKind == STATIC_TYPE) {
-                    StaticType *st = (StaticType *) cv0->type.ptr();
-                    result = (st->obj->objKind == IDENTIFIER);
-                }
-                ValueHolderPtr vh = boolToValueHolder(result);
-                codegenStaticObject(vh.ptr(), ctx, out);
-                break;
+                assert(out0->type == pointerType(fieldTypes[k]));
+                ctx->builder->CreateStore(ptr, out0->llValue);
             }
+        } else {
+            llvm::Value *ptr = ctx->builder->CreateConstGEP2_32(vrec, 0, i);
+            assert(out->size() == 1);
+            CValuePtr out0 = out->values[0];
+            assert(out0->type == pointerType(fieldTypes[i]));
+            ctx->builder->CreateStore(ptr, out0->llValue);
+        }
+        break;
+    }
 
-            case PRIM_stringLiteralByteIndex: {
-                ensureArity(args, 2);
-                llvm::StringRef ident = valueToStringRef(args, 0);
-                unsigned n = unsigned(valueToStaticSizeTOrInt(args, 1));
-                if (n >= ident.size())
-                    argumentError(1, "string literal index out of bounds");
+    case PRIM_recordFields: {
+        ensureArity(args, 1);
+        RecordTypePtr rt;
+        llvm::Value *vrec = recordValue(args, 0, rt);
+        llvm::ArrayRef<TypePtr> fieldTypes = recordFieldTypes(rt);
+        assert(out->size() == fieldTypes.size());
+        for (unsigned i = 0; i < fieldTypes.size(); ++i) {
+            CValuePtr outi = out->values[i];
+            assert(outi->type == pointerType(fieldTypes[i]));
+            llvm::Value *ptr = ctx->builder->CreateConstGEP2_32(vrec, 0, i);
+            ctx->builder->CreateStore(ptr, outi->llValue);
+        }
+        break;
+    }
 
-                assert(out->size() == 1);
-                CValuePtr outi = out->values[0];
-                assert(outi->type == cIntType);
-                llvm::Constant *value = llvm::ConstantInt::get(llvmIntType(32), size_t(ident[n]));
-                ctx->builder->CreateStore(value, outi->llValue);
-                break;
-            }
+    case PRIM_recordVariadicField: {
+        ensureArity(args, 1);
+        RecordTypePtr rt;
+        llvm::Value *vrec = recordValue(args, 0, rt);
+        llvm::ArrayRef<TypePtr> fieldTypes = recordFieldTypes(rt);
+        if (!rt->hasVarField)
+            argumentError(0, "expecting a record with a variadic field");
+        assert(out->size() == rt->varFieldSize());
+        for (unsigned i = 0; i < rt->varFieldSize(); ++i) {
+            unsigned k = rt->varFieldPosition + i;
+            CValuePtr outi = out->values[i];
+            assert(outi->type == pointerType(fieldTypes[k]));
+            llvm::Value *ptr = ctx->builder->CreateConstGEP2_32(vrec, 0, k);
+            ctx->builder->CreateStore(ptr, outi->llValue);
+        }
+        break;
+    }
 
-            case PRIM_stringLiteralBytes: {
-                ensureArity(args, 1);
-                llvm::StringRef ident = valueToStringRef(args, 0);
-                assert(out->size() == ident.size());
-                for (unsigned i = 0; i < ident.size(); ++i) {
-                    CValuePtr outi = out->values[i];
-                    assert(outi->type == cIntType);
-                    llvm::Constant *value = llvm::ConstantInt::get(llvmIntType(32), size_t(ident[i]));
-                    ctx->builder->CreateStore(value, outi->llValue);
-                }
-                break;
-            }
+    case PRIM_VariantP: {
+        ensureArity(args, 1);
+        bool isVariantType = false;
+        ObjectPtr obj = valueToStatic(args->values[0]);
+        if (obj.ptr() && (obj->objKind == TYPE)) {
+            Type *t = (Type *)obj.ptr();
+            if (t->typeKind == VARIANT_TYPE)
+                isVariantType = true;
+        }
+        ValueHolderPtr vh = boolToValueHolder(isVariantType);
+        codegenStaticObject(vh.ptr(), ctx, out);
+        break;
+    }
 
-            case PRIM_stringLiteralByteSize: {
-                ensureArity(args, 1);
-                llvm::StringRef ident = valueToStringRef(args, 0);
-                ValueHolderPtr vh = sizeTToValueHolder(ident.size());
-                codegenStaticObject(vh.ptr(), ctx, out);
+    case PRIM_VariantMemberIndex: {
+        ensureArity(args, 2);
+        VariantTypePtr vt = valueToVariantType(args, 0);
+        TypePtr mt = valueToType(args, 1);
+        llvm::ArrayRef<TypePtr> memberTypes = variantMemberTypes(vt);
+        size_t index = (size_t)-1;
+        for (size_t i = 0; i < memberTypes.size(); ++i) {
+            if (memberTypes[i] == mt) {
+                index = i;
                 break;
             }
+        }
+        ValueHolderPtr vh = sizeTToValueHolder(index);
+        codegenStaticObject(vh.ptr(), ctx, out);
+        break;
+    }
 
-            case PRIM_stringLiteralByteSlice:
-            case PRIM_stringLiteralConcat:
-            case PRIM_stringLiteralFromBytes:
-                break;
-
-            case PRIM_stringTableConstant: {
-                ensureArity(args, 1);
-                llvm::StringRef ident = valueToStringRef(args, 0);
-                llvm::Value *value = codegenStringTableConstant(ident);
-
-                assert(out->size() == 1);
-                CValuePtr out0 = out->values[0];
-                assert(out0->type == pointerType(cSizeTType));
-                ctx->builder->CreateStore(value, out0->llValue);
-                break;
-            }
+    case PRIM_VariantMemberCount: {
+        ensureArity(args, 1);
+        VariantTypePtr vt = valueToVariantType(args, 0);
+        llvm::ArrayRef<TypePtr> memberTypes = variantMemberTypes(vt);
+        size_t size = memberTypes.size();
+        ValueHolderPtr vh = sizeTToValueHolder(size);
+        codegenStaticObject(vh.ptr(), ctx, out);
+        break;
+    }
 
-            case PRIM_FlagP: {
-                ensureArity(args, 1);
-                llvm::StringRef ident = valueToStringRef(args, 0);
-                llvm::StringMap<string>::const_iterator flag = globalFlags.find(ident);
-                ValueHolderPtr vh = boolToValueHolder(flag != globalFlags.end());
-                codegenStaticObject(vh.ptr(), ctx, out);
-                break;
+    case PRIM_VariantMembers:
+        break;
+
+    case PRIM_BaseType:
+        break;
+
+    case PRIM_Static:
+        error("no Static primitive overload found");
+
+    case PRIM_StaticName:
+    case PRIM_MainModule:
+    case PRIM_StaticModule:
+    case PRIM_ModuleName:
+    case PRIM_ModuleMemberNames:
+        break;
+
+    case PRIM_staticIntegers:
+        break;
+
+    case PRIM_integers: {
+        ensureArity(args, 1);
+        ObjectPtr obj = valueToStatic(args, 0);
+        if (obj->objKind != VALUE_HOLDER)
+            argumentError(0, "expecting a static SizeT or Int value");
+        ValueHolder *vh = (ValueHolder *)obj.ptr();
+        if (vh->type == cIntType) {
+            int count = vh->as<int>();
+            if (count < 0)
+                argumentError(0, "negative values are not allowed");
+            assert(out->size() == (size_t)count);
+            for (int i = 0; i < count; ++i) {
+                ValueHolderPtr vhi = intToValueHolder(i);
+                CValuePtr outi = out->values[(size_t)i];
+                assert(outi->type == cIntType);
+                llvm::Constant *value =
+                    llvm::ConstantInt::get(llvmIntType(32), (size_t)i);
+                ctx->builder->CreateStore(value, outi->llValue);
             }
-
-            case PRIM_Flag:
-                break;
-
-            case PRIM_atomicFence: {
-                ensureArity(args, 1);
-                llvm::AtomicOrdering order = atomicOrderValue(args, 0);
-
-                ctx->builder->CreateFence(order);
-                assert(out->size() == 0);
-                break;
+        } else if (vh->type == cSizeTType) {
+            size_t count = vh->as<size_t>();
+            assert(out->size() == count);
+            for (size_t i = 0; i < count; ++i) {
+                ValueHolderPtr vhi = sizeTToValueHolder(i);
+                CValuePtr outi = out->values[i];
+                assert(outi->type == cSizeTType);
+                llvm::Type *llSizeTType =
+                    llvmIntType(unsigned(typeSize(cSizeTType) * 8));
+                llvm::Constant *value = llvm::ConstantInt::get(llSizeTType, i);
+                ctx->builder->CreateStore(value, outi->llValue);
             }
+        } else {
+            argumentError(0, "expecting a static SizeT or Int value");
+        }
+        break;
+    }
 
-            case PRIM_atomicRMW: {
-                ensureArity(args, 4);
-                llvm::AtomicOrdering order = atomicOrderValue(args, 0);
-                llvm::AtomicRMWInst::BinOp op = atomicRMWOpValue(args, 1);
+    case PRIM_staticFieldRef: {
+        ensureArity(args, 2);
+        ObjectPtr moduleObj = valueToStatic(args, 0);
+        if (moduleObj->objKind != MODULE)
+            argumentError(0, "expecting a module");
+        Module *module = (Module *)moduleObj.ptr();
+        IdentifierPtr ident = valueToIdentifier(args, 1);
+        ObjectPtr obj = safeLookupPublic(module, ident);
+        codegenStaticObject(obj, ctx, out);
+        break;
+    }
 
-                PointerTypePtr ptrT;
-                llvm::Value *ptr = pointerValue(args, 2, ptrT, ctx);
-                TypePtr argT = args->values[3]->type;
-                llvm::Value *arg = ctx->builder->CreateLoad(args->values[3]->llValue);
+    case PRIM_EnumP: {
+        ensureArity(args, 1);
+        bool isEnumType = false;
+        ObjectPtr obj = valueToStatic(args->values[0]);
+        if (obj.ptr() && (obj->objKind == TYPE)) {
+            Type *t = (Type *)obj.ptr();
+            if (t->typeKind == ENUM_TYPE)
+                isEnumType = true;
+        }
+        ValueHolderPtr vh = boolToValueHolder(isEnumType);
+        codegenStaticObject(vh.ptr(), ctx, out);
+        break;
+    }
 
-                if (ptrT->pointeeType != argT)
-                    argumentTypeError(3, ptrT->pointeeType, argT);
+    case PRIM_EnumMemberCount: {
+        ensureArity(args, 1);
+        EnumTypePtr et = valueToEnumType(args, 0);
+        size_t n = et->enumeration->members.size();
+        ValueHolderPtr vh = sizeTToValueHolder(n);
+        codegenStaticObject(vh.ptr(), ctx, out);
+        break;
+    }
 
-                llvm::Value *result = ctx->builder->CreateAtomicRMW(op, ptr, arg, order);
+    case PRIM_EnumMemberName:
+        break;
+
+    case PRIM_enumToInt: {
+        ensureArity(args, 1);
+        EnumTypePtr et;
+        llvm::Value *v = enumValue(args, 0, et, ctx);
+        assert(out->size() == 1);
+        CValuePtr out0 = out->values[0];
+        assert(out0->type == cIntType);
+        ctx->builder->CreateStore(v, out0->llValue);
+        break;
+    }
 
-                assert(out->size() == 1);
-                CValuePtr out0 = out->values[0];
-                assert(out0->type == argT);
-                ctx->builder->CreateStore(result, out0->llValue);
-                break;
-            }
+    case PRIM_intToEnum: {
+        ensureArity(args, 2);
+        EnumTypePtr et = valueToEnumType(args, 0);
+        IntegerTypePtr it = (IntegerType *)cIntType.ptr();
+        llvm::Value *v = integerValue(args, 1, it, ctx);
+        assert(out->size() == 1);
+        CValuePtr out0 = out->values[0];
+        assert(out0->type == et.ptr());
+        ctx->builder->CreateStore(v, out0->llValue);
+        break;
+    }
 
-            case PRIM_atomicLoad: {
-                ensureArity(args, 2);
-                llvm::AtomicOrdering order = atomicOrderValue(args, 0);
+    case PRIM_StringLiteralP: {
+        ensureArity(args, 1);
+        bool result = false;
+        CValuePtr cv0 = args->values[0];
+        if (cv0->type->typeKind == STATIC_TYPE) {
+            StaticType *st = (StaticType *)cv0->type.ptr();
+            result = (st->obj->objKind == IDENTIFIER);
+        }
+        ValueHolderPtr vh = boolToValueHolder(result);
+        codegenStaticObject(vh.ptr(), ctx, out);
+        break;
+    }
 
-                PointerTypePtr ptrT;
-                llvm::Value *ptr = pointerValue(args, 1, ptrT, ctx);
+    case PRIM_stringLiteralByteIndex: {
+        ensureArity(args, 2);
+        llvm::StringRef ident = valueToStringRef(args, 0);
+        unsigned n = unsigned(valueToStaticSizeTOrInt(args, 1));
+        if (n >= ident.size())
+            argumentError(1, "string literal index out of bounds");
+
+        assert(out->size() == 1);
+        CValuePtr outi = out->values[0];
+        assert(outi->type == cIntType);
+        llvm::Constant *value =
+            llvm::ConstantInt::get(llvmIntType(32), size_t(ident[n]));
+        ctx->builder->CreateStore(value, outi->llValue);
+        break;
+    }
 
-                llvm::Value *result = ctx->builder->Insert(
-                    new llvm::LoadInst(ptr, "", false, unsigned(typeAlignment(ptrT->pointeeType)), order));
+    case PRIM_stringLiteralBytes: {
+        ensureArity(args, 1);
+        llvm::StringRef ident = valueToStringRef(args, 0);
+        assert(out->size() == ident.size());
+        for (unsigned i = 0; i < ident.size(); ++i) {
+            CValuePtr outi = out->values[i];
+            assert(outi->type == cIntType);
+            llvm::Constant *value =
+                llvm::ConstantInt::get(llvmIntType(32), size_t(ident[i]));
+            ctx->builder->CreateStore(value, outi->llValue);
+        }
+        break;
+    }
 
-                assert(out->size() == 1);
-                CValuePtr out0 = out->values[0];
-                assert(out0->type == ptrT->pointeeType);
-                ctx->builder->CreateStore(result, out0->llValue);
-                break;
-            }
+    case PRIM_stringLiteralByteSize: {
+        ensureArity(args, 1);
+        llvm::StringRef ident = valueToStringRef(args, 0);
+        ValueHolderPtr vh = sizeTToValueHolder(ident.size());
+        codegenStaticObject(vh.ptr(), ctx, out);
+        break;
+    }
 
-            case PRIM_atomicStore: {
-                ensureArity(args, 3);
-                llvm::AtomicOrdering order = atomicOrderValue(args, 0);
+    case PRIM_stringLiteralByteSlice:
+    case PRIM_stringLiteralConcat:
+    case PRIM_stringLiteralFromBytes:
+        break;
+
+    case PRIM_stringTableConstant: {
+        ensureArity(args, 1);
+        llvm::StringRef ident = valueToStringRef(args, 0);
+        llvm::Value *value = codegenStringTableConstant(ident);
+
+        assert(out->size() == 1);
+        CValuePtr out0 = out->values[0];
+        assert(out0->type == pointerType(cSizeTType));
+        ctx->builder->CreateStore(value, out0->llValue);
+        break;
+    }
 
-                PointerTypePtr ptrT;
-                llvm::Value *ptr = pointerValue(args, 1, ptrT, ctx);
-                TypePtr argT = args->values[2]->type;
-                llvm::Value *arg = ctx->builder->CreateLoad(args->values[2]->llValue);
+    case PRIM_FlagP: {
+        ensureArity(args, 1);
+        llvm::StringRef ident = valueToStringRef(args, 0);
+        llvm::StringMap<string>::const_iterator flag = globalFlags.find(ident);
+        ValueHolderPtr vh = boolToValueHolder(flag != globalFlags.end());
+        codegenStaticObject(vh.ptr(), ctx, out);
+        break;
+    }
 
-                if (ptrT->pointeeType != argT)
-                    argumentTypeError(2, ptrT->pointeeType, argT);
+    case PRIM_Flag:
+        break;
 
-                ctx->builder->Insert(new llvm::StoreInst(
-                    arg, ptr, false, unsigned(typeAlignment(argT)), order));
+    case PRIM_atomicFence: {
+        ensureArity(args, 1);
+        llvm::AtomicOrdering order = atomicOrderValue(args, 0);
 
-                assert(out->size() == 0);
-                break;
-            }
+        ctx->builder->CreateFence(order);
+        assert(out->size() == 0);
+        break;
+    }
 
-            case PRIM_atomicCompareExchange: {
-                ensureArity(args, 4);
-                llvm::AtomicOrdering order = atomicOrderValue(args, 0);
+    case PRIM_atomicRMW: {
+        ensureArity(args, 4);
+        llvm::AtomicOrdering order = atomicOrderValue(args, 0);
+        llvm::AtomicRMWInst::BinOp op = atomicRMWOpValue(args, 1);
 
-                PointerTypePtr ptrT;
-                llvm::Value *ptr = pointerValue(args, 1, ptrT, ctx);
-                TypePtr oldvT = args->values[2]->type;
-                llvm::Value *oldv = ctx->builder->CreateLoad(args->values[2]->llValue);
-                TypePtr newvT = args->values[3]->type;
-                llvm::Value *newv = ctx->builder->CreateLoad(args->values[3]->llValue);
+        PointerTypePtr ptrT;
+        llvm::Value *ptr = pointerValue(args, 2, ptrT, ctx);
+        TypePtr argT = args->values[3]->type;
+        llvm::Value *arg = ctx->builder->CreateLoad(args->values[3]->llValue);
 
-                if (ptrT->pointeeType != oldvT)
-                    argumentTypeError(2, ptrT->pointeeType, oldvT);
-                if (ptrT->pointeeType != newvT)
-                    argumentTypeError(3, ptrT->pointeeType, newvT);
+        if (ptrT->pointeeType != argT)
+            argumentTypeError(3, ptrT->pointeeType, argT);
 
-                llvm::Value *result = ctx->builder->CreateAtomicCmpXchg(ptr, oldv, newv, order);
+        llvm::Value *result =
+            ctx->builder->CreateAtomicRMW(op, ptr, arg, order);
 
-                assert(out->size() == 1);
-                CValuePtr out0 = out->values[0];
-                assert(out0->type == oldvT);
-                ctx->builder->CreateStore(result, out0->llValue);
-                break;
-            }
+        assert(out->size() == 1);
+        CValuePtr out0 = out->values[0];
+        assert(out0->type == argT);
+        ctx->builder->CreateStore(result, out0->llValue);
+        break;
+    }
 
-            case PRIM_activeException: {
-                ensureArity(args, 0);
-                assert(out->size() == 1);
-                CValuePtr out0 = out->values[0];
-                assert(out0->type == pointerType(uint8Type));
+    case PRIM_atomicLoad: {
+        ensureArity(args, 2);
+        llvm::AtomicOrdering order = atomicOrderValue(args, 0);
+
+        PointerTypePtr ptrT;
+        llvm::Value *ptr = pointerValue(args, 1, ptrT, ctx);
+
+        llvm::Type *elementLlTy = llvmType(ptrT->pointeeType);
+        auto li = new llvm::LoadInst(elementLlTy, ptr, "", false,
+                                     llvm::Align(static_cast<unsigned>(
+                                         typeAlignment(ptrT->pointeeType))),
+                                     order);
+        llvm::Value *result = ctx->builder->Insert(li);
+
+        assert(out->size() == 1);
+        CValuePtr out0 = out->values[0];
+        assert(out0->type == ptrT->pointeeType);
+        ctx->builder->CreateStore(result, out0->llValue);
+        break;
+    }
 
-                assert(ctx->exceptionValue != nullptr);
+    case PRIM_atomicStore: {
+        ensureArity(args, 3);
+        llvm::AtomicOrdering order = atomicOrderValue(args, 0);
 
-                llvm::Value *expv = ctx->builder->CreateLoad(ctx->exceptionValue);
-                ctx->builder->CreateStore(expv, out0->llValue);
-                break;
-            }
+        PointerTypePtr ptrT;
+        llvm::Value *ptr = pointerValue(args, 1, ptrT, ctx);
+        TypePtr argT = args->values[2]->type;
+        llvm::Value *arg = ctx->builder->CreateLoad(args->values[2]->llValue);
 
-            case PRIM_memcpy:
-            case PRIM_memmove: {
-                ensureArity(args, 3);
-                PointerTypePtr topt;
-                PointerTypePtr frompt;
-                llvm::Value *toptr = pointerValue(args, 0, topt, ctx);
-                llvm::Value *fromptr = pointerValue(args, 1, frompt, ctx);
-                IntegerTypePtr it;
-                llvm::Value *count = integerValue(args, 2, it, ctx);
+        if (ptrT->pointeeType != argT)
+            argumentTypeError(2, ptrT->pointeeType, argT);
 
-                size_t pointerSize = typeSize(topt.ptr());
-                llvm::Type *sizeType = llvmIntType(unsigned(8 * pointerSize));
+        ctx->builder->Insert(new llvm::StoreInst(
+            arg, ptr, false, unsigned(typeAlignment(argT)), order));
 
-                if (typeSize(it.ptr()) > pointerSize)
-                    argumentError(2, "integer type for memcpy must be pointer-sized or smaller");
-                if (typeSize(it.ptr()) < pointerSize)
-                    count = ctx->builder->CreateZExt(count, sizeType);
+        assert(out->size() == 0);
+        break;
+    }
 
-                unsigned alignment = unsigned(std::min(
-                    typeAlignment(topt->pointeeType), typeAlignment(frompt->pointeeType)));
+    case PRIM_atomicCompareExchange: {
+        ensureArity(args, 4);
+        llvm::AtomicOrdering order = atomicOrderValue(args, 0);
+
+        PointerTypePtr ptrT;
+        llvm::Value *ptr = pointerValue(args, 1, ptrT, ctx);
+        TypePtr oldvT = args->values[2]->type;
+        llvm::Value *oldv = ctx->builder->CreateLoad(args->values[2]->llValue);
+        TypePtr newvT = args->values[3]->type;
+        llvm::Value *newv = ctx->builder->CreateLoad(args->values[3]->llValue);
+
+        if (ptrT->pointeeType != oldvT)
+            argumentTypeError(2, ptrT->pointeeType, oldvT);
+        if (ptrT->pointeeType != newvT)
+            argumentTypeError(3, ptrT->pointeeType, newvT);
+
+        llvm::Value *result =
+            ctx->builder->CreateAtomicCmpXchg(ptr, oldv, newv, order);
+
+        assert(out->size() == 1);
+        CValuePtr out0 = out->values[0];
+        assert(out0->type == oldvT);
+        ctx->builder->CreateStore(result, out0->llValue);
+        break;
+    }
 
-                if (x->primOpCode == PRIM_memcpy)
-                    ctx->builder->CreateMemCpy(toptr, fromptr, count, alignment);
-                else
-                    ctx->builder->CreateMemMove(toptr, fromptr, count, alignment);
+    case PRIM_activeException: {
+        ensureArity(args, 0);
+        assert(out->size() == 1);
+        CValuePtr out0 = out->values[0];
+        assert(out0->type == pointerType(uint8Type));
 
-                break;
-            }
+        assert(ctx->exceptionValue != nullptr);
 
-            case PRIM_countValues: {
-                assert(out->size() == 1);
-                CValuePtr out0 = out->values[0];
-                assert(out0->type == cIntType);
-                llvm::Constant *value = llvm::ConstantInt::get(llvmIntType(32), args->size());
-                ctx->builder->CreateStore(value, out0->llValue);
-                break;
-            }
+        llvm::Value *expv = ctx->builder->CreateLoad(ctx->exceptionValue);
+        ctx->builder->CreateStore(expv, out0->llValue);
+        break;
+    }
 
-            case PRIM_nthValue: {
-                if (args->size() < 1)
-                    arityError2(1, args->size());
-                assert(out->size() == 1);
-                CValuePtr out0 = out->values[0];
+    case PRIM_memcpy:
+    case PRIM_memmove: {
+        ensureArity(args, 3);
+        PointerTypePtr topt;
+        PointerTypePtr frompt;
+        llvm::Value *toptr = pointerValue(args, 0, topt, ctx);
+        llvm::Value *fromptr = pointerValue(args, 1, frompt, ctx);
+        IntegerTypePtr it;
+        llvm::Value *count = integerValue(args, 2, it, ctx);
+
+        size_t pointerSize = typeSize(topt.ptr());
+        llvm::Type *sizeType = llvmIntType(unsigned(8 * pointerSize));
+
+        if (typeSize(it.ptr()) > pointerSize)
+            argumentError(
+                2, "integer type for memcpy must be pointer-sized or smaller");
+        if (typeSize(it.ptr()) < pointerSize)
+            count = ctx->builder->CreateZExt(count, sizeType);
+
+        unsigned alignment =
+            unsigned(std::min(typeAlignment(topt->pointeeType),
+                              typeAlignment(frompt->pointeeType)));
+
+        if (x->primOpCode == PRIM_memcpy)
+            ctx->builder->CreateMemCpy(toptr, fromptr, count, alignment);
+        else
+            ctx->builder->CreateMemMove(toptr, fromptr, count, alignment);
+
+        break;
+    }
 
-                size_t i = valueToStaticSizeTOrInt(args, 0);
-                if (i + 1 >= args->size())
-                    argumentError(0, "nthValue argument out of bounds");
+    case PRIM_countValues: {
+        assert(out->size() == 1);
+        CValuePtr out0 = out->values[0];
+        assert(out0->type == cIntType);
+        llvm::Constant *value =
+            llvm::ConstantInt::get(llvmIntType(32), args->size());
+        ctx->builder->CreateStore(value, out0->llValue);
+        break;
+    }
 
-                codegenValueForward(out0, args->values[i + 1], ctx);
-                break;
-            }
+    case PRIM_nthValue: {
+        if (args->size() < 1)
+            arityError2(1, args->size());
+        assert(out->size() == 1);
+        CValuePtr out0 = out->values[0];
 
-            case PRIM_withoutNthValue: {
-                if (args->size() < 1)
-                    arityError2(1, args->size());
-                assert(out->size() == args->size() - 2);
-
-                size_t i = valueToStaticSizeTOrInt(args, 0);
-                if (i + 1 >= args->size())
-                    argumentError(0, "withoutNthValue argument out of bounds");
-
-                for (size_t argi = 1, outi = 0; argi < args->size(); ++argi) {
-                    if (argi == i + 1)
-                        continue;
-                    assert(outi < out->size());
-                    codegenValueForward(out->values[outi], args->values[argi], ctx);
-                    ++outi;
-                }
-                break;
-            }
+        size_t i = valueToStaticSizeTOrInt(args, 0);
+        if (i + 1 >= args->size())
+            argumentError(0, "nthValue argument out of bounds");
 
-            case PRIM_takeValues: {
-                if (args->size() < 1)
-                    arityError2(1, args->size());
+        codegenValueForward(out0, args->values[i + 1], ctx);
+        break;
+    }
 
-                size_t i = valueToStaticSizeTOrInt(args, 0);
-                if (i + 1 >= args->size())
-                    i = args->size() - 1;
+    case PRIM_withoutNthValue: {
+        if (args->size() < 1)
+            arityError2(1, args->size());
+        assert(out->size() == args->size() - 2);
+
+        size_t i = valueToStaticSizeTOrInt(args, 0);
+        if (i + 1 >= args->size())
+            argumentError(0, "withoutNthValue argument out of bounds");
+
+        for (size_t argi = 1, outi = 0; argi < args->size(); ++argi) {
+            if (argi == i + 1)
+                continue;
+            assert(outi < out->size());
+            codegenValueForward(out->values[outi], args->values[argi], ctx);
+            ++outi;
+        }
+        break;
+    }
 
-                assert(out->size() == i);
-                for (size_t argi = 1, outi = 0; argi < i + 1; ++argi, ++outi) {
-                    assert(outi < out->size());
-                    codegenValueForward(out->values[outi], args->values[argi], ctx);
-                }
-                break;
-            }
+    case PRIM_takeValues: {
+        if (args->size() < 1)
+            arityError2(1, args->size());
 
-            case PRIM_dropValues: {
-                if (args->size() < 1)
-                    arityError2(1, args->size());
+        size_t i = valueToStaticSizeTOrInt(args, 0);
+        if (i + 1 >= args->size())
+            i = args->size() - 1;
 
-                size_t i = valueToStaticSizeTOrInt(args, 0);
-                if (i + 1 >= args->size())
-                    i = args->size() - 1;
+        assert(out->size() == i);
+        for (size_t argi = 1, outi = 0; argi < i + 1; ++argi, ++outi) {
+            assert(outi < out->size());
+            codegenValueForward(out->values[outi], args->values[argi], ctx);
+        }
+        break;
+    }
 
-                assert(out->size() == args->size() - i - 1);
-                for (size_t argi = i + 1, outi = 0; argi < args->size(); ++argi, ++outi) {
-                    assert(outi < out->size());
-                    codegenValueForward(out->values[outi], args->values[argi], ctx);
-                }
-                break;
-            }
+    case PRIM_dropValues: {
+        if (args->size() < 1)
+            arityError2(1, args->size());
 
-            case PRIM_LambdaRecordP: {
-                ensureArity(args, 1);
+        size_t i = valueToStaticSizeTOrInt(args, 0);
+        if (i + 1 >= args->size())
+            i = args->size() - 1;
 
-                bool isLambda;
+        assert(out->size() == args->size() - i - 1);
+        for (size_t argi = i + 1, outi = 0; argi < args->size();
+             ++argi, ++outi) {
+            assert(outi < out->size());
+            codegenValueForward(out->values[outi], args->values[argi], ctx);
+        }
+        break;
+    }
 
-                ObjectPtr callable = valueToStatic(args->values[0]);
-                if (callable != nullptr && callable->objKind == TYPE) {
-                    Type *t = (Type *) callable.ptr();
-                    if (t->typeKind == RECORD_TYPE) {
-                        RecordType *r = (RecordType *) t;
-                        isLambda = r->record->lambda != nullptr;
-                    } else
-                        isLambda = false;
-                } else {
-                    isLambda = false;
-                }
+    case PRIM_LambdaRecordP: {
+        ensureArity(args, 1);
 
-                ValueHolderPtr vh = boolToValueHolder(isLambda);
-                codegenStaticObject(vh.ptr(), ctx, out);
-                break;
-            }
+        bool isLambda;
 
-            case PRIM_LambdaSymbolP: {
-                ensureArity(args, 1);
+        ObjectPtr callable = valueToStatic(args->values[0]);
+        if (callable != nullptr && callable->objKind == TYPE) {
+            Type *t = (Type *)callable.ptr();
+            if (t->typeKind == RECORD_TYPE) {
+                RecordType *r = (RecordType *)t;
+                isLambda = r->record->lambda != nullptr;
+            } else
+                isLambda = false;
+        } else {
+            isLambda = false;
+        }
 
-                bool isLambda;
+        ValueHolderPtr vh = boolToValueHolder(isLambda);
+        codegenStaticObject(vh.ptr(), ctx, out);
+        break;
+    }
 
-                ObjectPtr callable = valueToStatic(args->values[0]);
-                if (callable != nullptr && callable->objKind == PROCEDURE) {
-                    Procedure *p = (Procedure *) callable.ptr();
-                    isLambda = p->lambda != nullptr;
-                } else
-                    isLambda = false;
+    case PRIM_LambdaSymbolP: {
+        ensureArity(args, 1);
 
-                ValueHolderPtr vh = boolToValueHolder(isLambda);
-                codegenStaticObject(vh.ptr(), ctx, out);
-                break;
-            }
+        bool isLambda;
 
-            case PRIM_LambdaMonoP: {
-                ensureArity(args, 1);
+        ObjectPtr callable = valueToStatic(args->values[0]);
+        if (callable != nullptr && callable->objKind == PROCEDURE) {
+            Procedure *p = (Procedure *)callable.ptr();
+            isLambda = p->lambda != nullptr;
+        } else
+            isLambda = false;
 
-                bool isMono;
+        ValueHolderPtr vh = boolToValueHolder(isLambda);
+        codegenStaticObject(vh.ptr(), ctx, out);
+        break;
+    }
 
-                ObjectPtr callable = valueToStatic(args->values[0]);
-                if (callable != nullptr && callable->objKind == TYPE) {
-                    Type *t = (Type *) callable.ptr();
-                    if (t->typeKind == RECORD_TYPE) {
-                        RecordType *r = (RecordType *) t;
-                        isMono = r->record->lambda->mono.monoState == Procedure_MonoOverload;
-                    } else
-                        isMono = false;
-                } else {
-                    isMono = false;
-                }
+    case PRIM_LambdaMonoP: {
+        ensureArity(args, 1);
 
-                ValueHolderPtr vh = boolToValueHolder(isMono);
-                codegenStaticObject(vh.ptr(), ctx, out);
-                break;
-            }
+        bool isMono;
 
-            case PRIM_LambdaMonoInputTypes:
-                break;
+        ObjectPtr callable = valueToStatic(args->values[0]);
+        if (callable != nullptr && callable->objKind == TYPE) {
+            Type *t = (Type *)callable.ptr();
+            if (t->typeKind == RECORD_TYPE) {
+                RecordType *r = (RecordType *)t;
+                isMono =
+                    r->record->lambda->mono.monoState == Procedure_MonoOverload;
+            } else
+                isMono = false;
+        } else {
+            isMono = false;
+        }
 
-            case PRIM_GetOverload:
-                break;
+        ValueHolderPtr vh = boolToValueHolder(isMono);
+        codegenStaticObject(vh.ptr(), ctx, out);
+        break;
+    }
 
-            case PRIM_usuallyEquals: {
-                ensureArity(args, 2);
-                if (!isPrimitiveType(args->values[0]->type))
-                    argumentTypeError(0, "primitive type", args->values[0]->type);
-                llvm::Value *expectee = ctx->builder->CreateLoad(args->values[0]->llValue);
-                ObjectPtr expectedValue = unwrapStaticType(args->values[1]->type);
-                if (expectedValue == nullptr
-                    || expectedValue->objKind != VALUE_HOLDER
-                    || ((ValueHolder *) expectedValue.ptr())->type != args->values[0]->type)
-                    error(
-                        "second argument to usuallyEquals must be a static value of the same type as the first argument");
-                llvm::Constant *expected =
-                        valueHolderToLLVMConstant((ValueHolder *) expectedValue.ptr(), ctx);
-
-                assert(expectee->getType() == expected->getType());
-
-                llvm::Value *argValues[2] = {expectee, expected};
-
-                llvm::Function *expectFunction = llvm::Intrinsic::getDeclaration(
-                    llvmModule,
-                    llvm::Intrinsic::expect,
-                    expectee->getType());
-
-                llvm::Value *hinted = ctx->builder->CreateCall(expectFunction, argValues);
-                assert(out->size() == 1);
-                CValuePtr out0 = out->values[0];
-                assert(out0->type == args->values[0]->type);
-                ctx->builder->CreateStore(hinted, out0->llValue);
-                break;
-            }
+    case PRIM_LambdaMonoInputTypes:
+        break;
+
+    case PRIM_GetOverload:
+        break;
+
+    case PRIM_usuallyEquals: {
+        ensureArity(args, 2);
+        if (!isPrimitiveType(args->values[0]->type))
+            argumentTypeError(0, "primitive type", args->values[0]->type);
+        llvm::Value *expectee =
+            ctx->builder->CreateLoad(args->values[0]->llValue);
+        ObjectPtr expectedValue = unwrapStaticType(args->values[1]->type);
+        if (expectedValue == nullptr ||
+            expectedValue->objKind != VALUE_HOLDER ||
+            ((ValueHolder *)expectedValue.ptr())->type != args->values[0]->type)
+            error("second argument to usuallyEquals must be a static value of "
+                  "the same type as the first argument");
+        llvm::Constant *expected =
+            valueHolderToLLVMConstant((ValueHolder *)expectedValue.ptr(), ctx);
+
+        assert(expectee->getType() == expected->getType());
+
+        llvm::Value *argValues[2] = {expectee, expected};
+
+        llvm::Function *expectFunction = llvm::Intrinsic::getDeclaration(
+            llvmModule, llvm::Intrinsic::expect, expectee->getType());
+
+        llvm::Value *hinted =
+            ctx->builder->CreateCall(expectFunction, argValues);
+        assert(out->size() == 1);
+        CValuePtr out0 = out->values[0];
+        assert(out0->type == args->values[0]->type);
+        ctx->builder->CreateStore(hinted, out0->llValue);
+        break;
+    }
 
-            default:
-                assert(false);
-                break;
-        }
+    default:
+        assert(false);
+        break;
     }
 }
+} // namespace clay
diff --git a/compiler/codegen_op.hpp b/compiler/codegen_op.hpp
index 0b35544b..ff0e27d0 100644
--- a/compiler/codegen_op.hpp
+++ b/compiler/codegen_op.hpp
@@ -3,8 +3,6 @@
 #include "clay.hpp"
 
 namespace clay {
-    void codegenPrimOp(PrimOpPtr x,
-                       MultiCValuePtr args,
-                       CodegenContext *ctx,
-                       MultiCValuePtr out);
+void codegenPrimOp(PrimOpPtr x, MultiCValuePtr args, CodegenContext *ctx,
+                   MultiCValuePtr out);
 }
diff --git a/compiler/constructors.cpp b/compiler/constructors.cpp
index 25b50147..63180ebe 100644
--- a/compiler/constructors.cpp
+++ b/compiler/constructors.cpp
@@ -6,134 +6,134 @@
 // #include "env.hpp"
 
 namespace clay {
-    vector<OverloadPtr> pointerOverloads;
-    vector<OverloadPtr> codePointerOverloads;
-    vector<OverloadPtr> cCodePointerOverloads;
-    vector<OverloadPtr> arrayOverloads;
-    vector<OverloadPtr> vecOverloads;
-    vector<OverloadPtr> tupleOverloads;
-    vector<OverloadPtr> unionOverloads;
-    vector<OverloadPtr> staticOverloads;
+vector<OverloadPtr> pointerOverloads;
+vector<OverloadPtr> codePointerOverloads;
+vector<OverloadPtr> cCodePointerOverloads;
+vector<OverloadPtr> arrayOverloads;
+vector<OverloadPtr> vecOverloads;
+vector<OverloadPtr> tupleOverloads;
+vector<OverloadPtr> unionOverloads;
+vector<OverloadPtr> staticOverloads;
 
-    vector<OverloadPtr> patternOverloads;
+vector<OverloadPtr> patternOverloads;
 
-    bool isOverloadablePrimOp(ObjectPtr x) {
-        if (x->objKind != PRIM_OP)
-            return false;
-        PrimOpPtr y = (PrimOp *) x.ptr();
-        switch (y->primOpCode) {
-            case PRIM_Pointer:
-            case PRIM_CodePointer:
-            case PRIM_ExternalCodePointer:
-            case PRIM_Array:
-            case PRIM_Vec:
-            case PRIM_Tuple:
-            case PRIM_Union:
-            case PRIM_Static:
-                return true;
-            default:
-                return false;
-        }
+bool isOverloadablePrimOp(ObjectPtr x) {
+    if (x->objKind != PRIM_OP)
+        return false;
+    PrimOpPtr y = (PrimOp *)x.ptr();
+    switch (y->primOpCode) {
+    case PRIM_Pointer:
+    case PRIM_CodePointer:
+    case PRIM_ExternalCodePointer:
+    case PRIM_Array:
+    case PRIM_Vec:
+    case PRIM_Tuple:
+    case PRIM_Union:
+    case PRIM_Static:
+        return true;
+    default:
+        return false;
     }
+}
 
-    vector<OverloadPtr> &primOpOverloads(PrimOpPtr x) {
-        vector<OverloadPtr> *ptr = nullptr;
-        switch (x->primOpCode) {
-            case PRIM_Pointer:
-                ptr = &pointerOverloads;
-                break;
-            case PRIM_CodePointer:
-                ptr = &codePointerOverloads;
-                break;
-            case PRIM_ExternalCodePointer:
-                ptr = &cCodePointerOverloads;
-                break;
-            case PRIM_Array:
-                ptr = &arrayOverloads;
-                break;
-            case PRIM_Vec:
-                ptr = &vecOverloads;
-                break;
-            case PRIM_Tuple:
-                ptr = &tupleOverloads;
-                break;
-            case PRIM_Union:
-                ptr = &unionOverloads;
-                break;
-            case PRIM_Static:
-                ptr = &staticOverloads;
-                break;
-            default:
-                assert(false);
-        }
-        return *ptr;
+vector<OverloadPtr> &primOpOverloads(PrimOpPtr x) {
+    vector<OverloadPtr> *ptr = nullptr;
+    switch (x->primOpCode) {
+    case PRIM_Pointer:
+        ptr = &pointerOverloads;
+        break;
+    case PRIM_CodePointer:
+        ptr = &codePointerOverloads;
+        break;
+    case PRIM_ExternalCodePointer:
+        ptr = &cCodePointerOverloads;
+        break;
+    case PRIM_Array:
+        ptr = &arrayOverloads;
+        break;
+    case PRIM_Vec:
+        ptr = &vecOverloads;
+        break;
+    case PRIM_Tuple:
+        ptr = &tupleOverloads;
+        break;
+    case PRIM_Union:
+        ptr = &unionOverloads;
+        break;
+    case PRIM_Static:
+        ptr = &staticOverloads;
+        break;
+    default:
+        assert(false);
     }
+    return *ptr;
+}
 
-    vector<OverloadPtr> &getPatternOverloads() {
-        return patternOverloads;
-    }
+vector<OverloadPtr> &getPatternOverloads() { return patternOverloads; }
 
-    void initBuiltinConstructor(RecordDeclPtr x) {
-        assert(!(x->builtinOverloadInitialized));
-        x->builtinOverloadInitialized = true;
+void initBuiltinConstructor(RecordDeclPtr x) {
+    assert(!(x->builtinOverloadInitialized));
+    x->builtinOverloadInitialized = true;
 
-        RecordBodyPtr y = x->body;
-        if (y->isComputed)
-            return;
+    RecordBodyPtr y = x->body;
+    if (y->isComputed)
+        return;
 
-        assert((x->params.size() > 0) || x->varParam.ptr());
+    assert((x->params.size() > 0) || x->varParam.ptr());
 
-        ExprPtr recName = new NameRef(x->name);
-        recName->location = x->name->location;
+    ExprPtr recName = new NameRef(x->name);
+    recName->location = x->name->location;
 
-        CodePtr code = new Code();
-        code->location = x->location;
-        code->hasVarArg = y->hasVarField;
-        for (size_t i = 0; i < x->params.size(); ++i) {
-            PatternVar pvar(false, x->params[i]);
-            code->patternVars.push_back(pvar);
-        }
-        if (x->varParam.ptr()) {
-            PatternVar pvar(true, x->varParam);
-            code->patternVars.push_back(pvar);
-        }
+    CodePtr code = new Code();
+    code->location = x->location;
+    code->hasVarArg = y->hasVarField;
+    for (size_t i = 0; i < x->params.size(); ++i) {
+        PatternVar pvar(false, x->params[i]);
+        code->patternVars.push_back(pvar);
+    }
+    if (x->varParam.ptr()) {
+        PatternVar pvar(true, x->varParam);
+        code->patternVars.push_back(pvar);
+    }
 
-        for (size_t i = 0; i < y->fields.size(); ++i) {
-            RecordFieldPtr f = y->fields[i];
-            FormalArgPtr arg = new FormalArg(f->name, f->type, TEMPNESS_DONTCARE, f->varField);
-            arg->location = f->location;
-            code->formalArgs.push_back(arg.ptr());
-        }
+    for (size_t i = 0; i < y->fields.size(); ++i) {
+        RecordFieldPtr f = y->fields[i];
+        FormalArgPtr arg =
+            new FormalArg(f->name, f->type, TEMPNESS_DONTCARE, f->varField);
+        arg->location = f->location;
+        code->formalArgs.push_back(arg.ptr());
+    }
 
-        IndexingPtr retType = new Indexing(recName, new ExprList());
-        retType->location = x->location;
-        for (size_t i = 0; i < x->params.size(); ++i) {
-            ExprPtr typeArg = new NameRef(x->params[i]);
-            typeArg->location = x->params[i]->location;
-            retType->args->add(typeArg);
-        }
-        if (x->varParam.ptr()) {
-            ExprPtr nameRef = new NameRef(x->varParam);
-            nameRef->location = x->varParam->location;
-            ExprPtr typeArg = new Unpack(nameRef);
-            typeArg->location = nameRef->location;
-            retType->args->add(typeArg);
-        }
+    IndexingPtr retType = new Indexing(recName, new ExprList());
+    retType->location = x->location;
+    for (size_t i = 0; i < x->params.size(); ++i) {
+        ExprPtr typeArg = new NameRef(x->params[i]);
+        typeArg->location = x->params[i]->location;
+        retType->args->add(typeArg);
+    }
+    if (x->varParam.ptr()) {
+        ExprPtr nameRef = new NameRef(x->varParam);
+        nameRef->location = x->varParam->location;
+        ExprPtr typeArg = new Unpack(nameRef);
+        typeArg->location = nameRef->location;
+        retType->args->add(typeArg);
+    }
 
-        CallPtr returnExpr = new Call(retType.ptr(), new ExprList());
-        returnExpr->location = x->location;
-        for (size_t i = 0; i < y->fields.size(); ++i) {
-            ExprPtr callArg = new NameRef(y->fields[i]->name);
-            callArg->location = y->fields[i]->location;
-            returnExpr->parenArgs->add(callArg);
-        }
+    CallPtr returnExpr = new Call(retType.ptr(), new ExprList());
+    returnExpr->location = x->location;
+    for (size_t i = 0; i < y->fields.size(); ++i) {
+        ExprPtr callArg = new NameRef(y->fields[i]->name);
+        callArg->location = y->fields[i]->location;
+        returnExpr->parenArgs->add(callArg);
+    }
 
-        code->body = new Return(RETURN_VALUE, new ExprList(returnExpr.ptr()));
-        code->body->location = returnExpr->location;
+    code->body = new Return(RETURN_VALUE, new ExprList(returnExpr.ptr()));
+    code->body->location = returnExpr->location;
 
-        OverloadPtr defaultOverload = new Overload(x->module, recName, code, true, IGNORE);
-        defaultOverload->location = x->location;
-        defaultOverload->env = x->env;
-        x->overloads.push_back(defaultOverload);
-    }
+    OverloadPtr defaultOverload =
+        new Overload(x->module, recName, code, true, IGNORE);
+    defaultOverload->location = x->location;
+    defaultOverload->env = x->env;
+    x->overloads.push_back(defaultOverload);
 }
+} // namespace clay
diff --git a/compiler/constructors.hpp b/compiler/constructors.hpp
index 3cf49fb7..dd8950c4 100644
--- a/compiler/constructors.hpp
+++ b/compiler/constructors.hpp
@@ -3,8 +3,8 @@
 #include "clay.hpp"
 
 namespace clay {
-    bool isOverloadablePrimOp(ObjectPtr x);
-    vector<OverloadPtr> &primOpOverloads(PrimOpPtr x);
-    vector<OverloadPtr> &getPatternOverloads();
-    void initBuiltinConstructor(RecordDeclPtr x);
-}
+bool isOverloadablePrimOp(ObjectPtr x);
+vector<OverloadPtr> &primOpOverloads(PrimOpPtr x);
+vector<OverloadPtr> &getPatternOverloads();
+void initBuiltinConstructor(RecordDeclPtr x);
+} // namespace clay
diff --git a/compiler/desugar.cpp b/compiler/desugar.cpp
index 1b713e1f..95bd278b 100644
--- a/compiler/desugar.cpp
+++ b/compiler/desugar.cpp
@@ -1,502 +1,516 @@
-#include "clay.hpp"
-#include "operators.hpp"
-#include "evaluator.hpp"
-#include "analyzer.hpp"
 #include "desugar.hpp"
-#include "parser.hpp"
+#include "analyzer.hpp"
+#include "clay.hpp"
 #include "clone.hpp"
-#include "objects.hpp"
 #include "error.hpp"
+#include "evaluator.hpp"
+#include "objects.hpp"
+#include "operators.hpp"
+#include "parser.hpp"
 
 namespace clay {
-    ExprPtr desugarCharLiteral(char c) {
-        ExprPtr nameRef = operator_expr_charLiteral();
-        CallPtr call = new Call(nameRef, new ExprList());
-        llvm::SmallString<128> buf;
-        llvm::raw_svector_ostream out(buf);
-        out << (int) c;
-        call->parenArgs->add(new IntLiteral(out.str(), "ss"));
-        return call.ptr();
-    }
+ExprPtr desugarCharLiteral(char c) {
+    ExprPtr nameRef = operator_expr_charLiteral();
+    CallPtr call = new Call(nameRef, new ExprList());
+    llvm::SmallString<128> buf;
+    llvm::raw_svector_ostream out(buf);
+    out << (int)c;
+    call->parenArgs->add(new IntLiteral(out.str(), "ss"));
+    return call.ptr();
+}
 
-    static ModulePtr dottedImportedModule(FieldRef *x, Module *module) {
-        llvm::StringMap<ModuleLookup> *moduleNode = &module->importedModuleNames;
-        FieldRef *fieldRefNode = x;
-        for (;;) {
-            llvm::StringMap<ModuleLookup>::iterator parent = moduleNode->find(fieldRefNode->name->str);
-            if (parent == moduleNode->end())
-                return nullptr;
-            moduleNode = &parent->getValue().parents;
-            if (fieldRefNode->expr->exprKind == FIELD_REF)
-                fieldRefNode = (FieldRef *) fieldRefNode->expr.ptr();
-            else
-                break;
-        }
-        if (fieldRefNode->expr->exprKind == NAME_REF) {
-            NameRef *nameNode = (NameRef *) fieldRefNode->expr.ptr();
-            llvm::StringMap<ModuleLookup>::iterator parent = moduleNode->find(nameNode->name->str);
-            if (parent == moduleNode->end())
-                return nullptr;
-            return parent->getValue().module;
-        }
-        return nullptr;
+static ModulePtr dottedImportedModule(FieldRef *x, Module *module) {
+    llvm::StringMap<ModuleLookup> *moduleNode = &module->importedModuleNames;
+    FieldRef *fieldRefNode = x;
+    for (;;) {
+        llvm::StringMap<ModuleLookup>::iterator parent =
+            moduleNode->find(fieldRefNode->name->str);
+        if (parent == moduleNode->end())
+            return nullptr;
+        moduleNode = &parent->getValue().parents;
+        if (fieldRefNode->expr->exprKind == FIELD_REF)
+            fieldRefNode = (FieldRef *)fieldRefNode->expr.ptr();
+        else
+            break;
+    }
+    if (fieldRefNode->expr->exprKind == NAME_REF) {
+        NameRef *nameNode = (NameRef *)fieldRefNode->expr.ptr();
+        llvm::StringMap<ModuleLookup>::iterator parent =
+            moduleNode->find(nameNode->name->str);
+        if (parent == moduleNode->end())
+            return nullptr;
+        return parent->getValue().module;
     }
+    return nullptr;
+}
 
-    void desugarFieldRef(FieldRefPtr x, ModulePtr module) {
-        if (x->expr->exprKind == FIELD_REF || x->expr->exprKind == NAME_REF) {
-            ModulePtr m = dottedImportedModule(x.ptr(), module.ptr());
-            if (m.ptr()) {
-                x->isDottedModuleName = true;
-                x->desugared = new ObjectExpr(m.ptr());
-                return;
-            }
+void desugarFieldRef(FieldRefPtr x, ModulePtr module) {
+    if (x->expr->exprKind == FIELD_REF || x->expr->exprKind == NAME_REF) {
+        ModulePtr m = dottedImportedModule(x.ptr(), module.ptr());
+        if (m.ptr()) {
+            x->isDottedModuleName = true;
+            x->desugared = new ObjectExpr(m.ptr());
+            return;
         }
-
-        ExprListPtr args = new ExprList(x->expr);
-        args->add(new ObjectExpr(x->name.ptr()));
-        CallPtr call = new Call(operator_expr_fieldRef(), args);
-        call->location = x->location;
-        x->desugared = call.ptr();
     }
 
-    ExprPtr desugarStaticIndexing(StaticIndexingPtr x) {
-        ExprListPtr args = new ExprList(x->expr);
-        ValueHolderPtr vh = sizeTToValueHolder(x->index);
-        args->add(new StaticExpr(new ObjectExpr(vh.ptr())));
-        CallPtr call = new Call(operator_expr_staticIndex(), args);
-        call->location = x->location;
-        return call.ptr();
-    }
+    ExprListPtr args = new ExprList(x->expr);
+    args->add(new ObjectExpr(x->name.ptr()));
+    CallPtr call = new Call(operator_expr_fieldRef(), args);
+    call->location = x->location;
+    x->desugared = call.ptr();
+}
 
-    ExprPtr lookupCallable(int op) {
-        ExprPtr callable;
-        switch (op) {
-            case DEREFERENCE:
-                callable = operator_expr_dereference();
-                break;
-            case ADDRESS_OF:
-                callable = primitive_expr_addressOf();
-                break;
-            case NOT:
-                callable = primitive_expr_boolNot();
-                break;
-            case PREFIX_OP:
-                callable = operator_expr_prefixOperator();
-                break;
-            case INFIX_OP:
-                callable = operator_expr_infixOperator();
-                break;
-            case IF_EXPR:
-                callable = operator_expr_ifExpression();
-                break;
-            default:
-                assert(false);
-        }
-        return callable;
-    }
+ExprPtr desugarStaticIndexing(StaticIndexingPtr x) {
+    ExprListPtr args = new ExprList(x->expr);
+    ValueHolderPtr vh = sizeTToValueHolder(x->index);
+    args->add(new StaticExpr(new ObjectExpr(vh.ptr())));
+    CallPtr call = new Call(operator_expr_staticIndex(), args);
+    call->location = x->location;
+    return call.ptr();
+}
 
-    ExprPtr desugarVariadicOp(VariadicOpPtr x) {
-        ExprPtr callable = lookupCallable(x->op);
-        CallPtr call = new Call(callable, new ExprList());
-        call->parenArgs->add(x->exprs);
-        call->location = x->location;
-        return call.ptr();
+ExprPtr lookupCallable(int op) {
+    ExprPtr callable;
+    switch (op) {
+    case DEREFERENCE:
+        callable = operator_expr_dereference();
+        break;
+    case ADDRESS_OF:
+        callable = primitive_expr_addressOf();
+        break;
+    case NOT:
+        callable = primitive_expr_boolNot();
+        break;
+    case PREFIX_OP:
+        callable = operator_expr_prefixOperator();
+        break;
+    case INFIX_OP:
+        callable = operator_expr_infixOperator();
+        break;
+    case IF_EXPR:
+        callable = operator_expr_ifExpression();
+        break;
+    default:
+        assert(false);
     }
+    return callable;
+}
 
-    static vector<FormalArgPtr> identV(IdentifierPtr x) {
-        vector<FormalArgPtr> v;
-        v.push_back(new FormalArg(x, nullptr));
-        return v;
-    }
+ExprPtr desugarVariadicOp(VariadicOpPtr x) {
+    ExprPtr callable = lookupCallable(x->op);
+    CallPtr call = new Call(callable, new ExprList());
+    call->parenArgs->add(x->exprs);
+    call->location = x->location;
+    return call.ptr();
+}
 
-    static vector<FormalArgPtr> identVtoFormalV(llvm::ArrayRef<IdentifierPtr> x) {
-        vector<FormalArgPtr> v;
-        for (size_t i = 0; i < x.size(); ++i)
-            v.push_back(new FormalArg(x[i], nullptr));
-        return v;
-    }
+static vector<FormalArgPtr> identV(IdentifierPtr x) {
+    vector<FormalArgPtr> v;
+    v.push_back(new FormalArg(x, nullptr));
+    return v;
+}
 
-    //  for (<vars> in <expr>) <body>
-    // becomes:
-    //  {
-    //      forward %expr = <expr>;
-    //      forward %iter = iterator(%expr);
-    //      while (var %value = nextValue(%iter); hasValue?(%value)) {
-    //          forward <vars> = getValue(%value);
-    //          <body>
-    //      }
-    //  }
-
-    StatementPtr desugarForStatement(ForPtr x) {
-        IdentifierPtr exprVar = Identifier::get("%expr", x->location);
-        IdentifierPtr iterVar = Identifier::get("%iter", x->location);
-        IdentifierPtr valueVar = Identifier::get("%value", x->location);
+static vector<FormalArgPtr> identVtoFormalV(llvm::ArrayRef<IdentifierPtr> x) {
+    vector<FormalArgPtr> v;
+    for (size_t i = 0; i < x.size(); ++i)
+        v.push_back(new FormalArg(x[i], nullptr));
+    return v;
+}
 
-        BlockPtr block = new Block();
-        block->location = x->body->location;
-        vector<StatementPtr> &bs = block->statements;
-        BindingPtr exprBinding = new Binding(FORWARD, identV(exprVar), new ExprList(x->expr));
-        exprBinding->location = x->body->location;
-        bs.push_back(exprBinding.ptr());
-
-        CallPtr iteratorCall = new Call(operator_expr_iterator(), new ExprList());
-        iteratorCall->location = x->body->location;
-        ExprPtr exprName = new NameRef(exprVar);
-        exprName->location = x->location;
-        iteratorCall->parenArgs->add(exprName);
-        BindingPtr iteratorBinding = new Binding(FORWARD,
-                                                 identV(iterVar),
-                                                 new ExprList(iteratorCall.ptr()));
-        iteratorBinding->location = x->body->location;
-        bs.push_back(iteratorBinding.ptr());
-
-        vector<StatementPtr> valueStatements;
-        CallPtr nextValueCall = new Call(operator_expr_nextValue(), new ExprList());
-        nextValueCall->location = x->body->location;
-        ExprPtr iterName = new NameRef(iterVar);
-        iterName->location = x->body->location;
-        nextValueCall->parenArgs->add(iterName);
-        BindingPtr nextValueBinding = new Binding(VAR,
-                                                  identV(valueVar),
-                                                  new ExprList(nextValueCall.ptr()));
-        nextValueBinding->location = x->body->location;
-        valueStatements.push_back(nextValueBinding.ptr());
-
-        CallPtr hasValueCall = new Call(operator_expr_hasValueP(), new ExprList());
-        hasValueCall->location = x->body->location;
-        ExprPtr valueName = new NameRef(valueVar);
-        valueName->location = x->body->location;
-        hasValueCall->parenArgs->add(valueName);
-
-        CallPtr getValueCall = new Call(operator_expr_getValue(), new ExprList());
-        getValueCall->location = x->body->location;
-        getValueCall->parenArgs->add(valueName);
-        BlockPtr whileBody = new Block();
-        whileBody->location = x->body->location;
-        vector<StatementPtr> &ws = whileBody->statements;
-        ws.push_back(new Binding(FORWARD, identVtoFormalV(x->variables), new ExprList(getValueCall.ptr())));
-        ws.push_back(x->body);
-
-        StatementPtr whileStmt = new While(valueStatements, hasValueCall.ptr(), whileBody.ptr());
-        whileStmt->location = x->location;
-        bs.push_back(whileStmt);
-        return block.ptr();
-    }
+//  for (<vars> in <expr>) <body>
+// becomes:
+//  {
+//      forward %expr = <expr>;
+//      forward %iter = iterator(%expr);
+//      while (var %value = nextValue(%iter); hasValue?(%value)) {
+//          forward <vars> = getValue(%value);
+//          <body>
+//      }
+//  }
+
+StatementPtr desugarForStatement(ForPtr x) {
+    IdentifierPtr exprVar = Identifier::get("%expr", x->location);
+    IdentifierPtr iterVar = Identifier::get("%iter", x->location);
+    IdentifierPtr valueVar = Identifier::get("%value", x->location);
+
+    BlockPtr block = new Block();
+    block->location = x->body->location;
+    vector<StatementPtr> &bs = block->statements;
+    BindingPtr exprBinding =
+        new Binding(FORWARD, identV(exprVar), new ExprList(x->expr));
+    exprBinding->location = x->body->location;
+    bs.push_back(exprBinding.ptr());
+
+    CallPtr iteratorCall = new Call(operator_expr_iterator(), new ExprList());
+    iteratorCall->location = x->body->location;
+    ExprPtr exprName = new NameRef(exprVar);
+    exprName->location = x->location;
+    iteratorCall->parenArgs->add(exprName);
+    BindingPtr iteratorBinding =
+        new Binding(FORWARD, identV(iterVar), new ExprList(iteratorCall.ptr()));
+    iteratorBinding->location = x->body->location;
+    bs.push_back(iteratorBinding.ptr());
+
+    vector<StatementPtr> valueStatements;
+    CallPtr nextValueCall = new Call(operator_expr_nextValue(), new ExprList());
+    nextValueCall->location = x->body->location;
+    ExprPtr iterName = new NameRef(iterVar);
+    iterName->location = x->body->location;
+    nextValueCall->parenArgs->add(iterName);
+    BindingPtr nextValueBinding =
+        new Binding(VAR, identV(valueVar), new ExprList(nextValueCall.ptr()));
+    nextValueBinding->location = x->body->location;
+    valueStatements.push_back(nextValueBinding.ptr());
+
+    CallPtr hasValueCall = new Call(operator_expr_hasValueP(), new ExprList());
+    hasValueCall->location = x->body->location;
+    ExprPtr valueName = new NameRef(valueVar);
+    valueName->location = x->body->location;
+    hasValueCall->parenArgs->add(valueName);
+
+    CallPtr getValueCall = new Call(operator_expr_getValue(), new ExprList());
+    getValueCall->location = x->body->location;
+    getValueCall->parenArgs->add(valueName);
+    BlockPtr whileBody = new Block();
+    whileBody->location = x->body->location;
+    vector<StatementPtr> &ws = whileBody->statements;
+    ws.push_back(new Binding(FORWARD, identVtoFormalV(x->variables),
+                             new ExprList(getValueCall.ptr())));
+    ws.push_back(x->body);
+
+    StatementPtr whileStmt =
+        new While(valueStatements, hasValueCall.ptr(), whileBody.ptr());
+    whileStmt->location = x->location;
+    bs.push_back(whileStmt);
+    return block.ptr();
+}
 
-    static void makeExceptionVars(vector<IdentifierPtr> &identifiers, CatchPtr x) {
-        identifiers.push_back(x->exceptionVar);
-        identifiers.push_back(
-            !!x->contextVar ? x->contextVar : Identifier::get("%context", x->location));
-    }
+static void makeExceptionVars(vector<IdentifierPtr> &identifiers, CatchPtr x) {
+    identifiers.push_back(x->exceptionVar);
+    identifiers.push_back(!!x->contextVar
+                              ? x->contextVar
+                              : Identifier::get("%context", x->location));
+}
 
-    StatementPtr desugarCatchBlocks(llvm::ArrayRef<CatchPtr> catchBlocks) {
-        assert(!catchBlocks.empty());
-        Location firstCatchLocation = catchBlocks.front()->location;
-        IdentifierPtr expVar = Identifier::get("%exp", firstCatchLocation);
-
-        CallPtr activeException = new Call(primitive_expr_activeException(), new ExprList());
-        activeException->location = firstCatchLocation;
-
-        BindingPtr expBinding =
-                new Binding(VAR,
-                            identVtoFormalV(vector<IdentifierPtr>(1, expVar)),
-                            new ExprList(activeException.ptr()));
-        expBinding->location = firstCatchLocation;
-
-        bool lastWasAny = false;
-        IfPtr lastIf;
-        StatementPtr result;
-        for (size_t i = 0; i < catchBlocks.size(); ++i) {
-            CatchPtr x = catchBlocks[i];
-            if (lastWasAny)
-                error(x, "unreachable catch block");
-            if (x->exceptionType.ptr()) {
-                ExprListPtr asTypeArgs = new ExprList(x->exceptionType);
-                ExprPtr expVarName = new NameRef(expVar);
-                expVarName->location = x->exceptionVar->location;
-                asTypeArgs->add(expVarName);
-                CallPtr cond = new Call(operator_expr_exceptionIsP(), asTypeArgs);
-                cond->location = x->exceptionType->location;
-
-                BlockPtr block = new Block();
-                block->location = x->location;
-
-                vector<IdentifierPtr> identifiers;
-                makeExceptionVars(identifiers, x);
-
-                CallPtr getter = new Call(operator_expr_exceptionAs(), asTypeArgs);
-                getter->location = x->exceptionVar->location;
-                BindingPtr binding =
-                        new Binding(VAR,
-                                    identVtoFormalV(identifiers),
-                                    new ExprList(getter.ptr()));
-                binding->location = x->exceptionVar->location;
-
-                BindingPtr exceptionVarForRethrow =
-                        new Binding(REF,
-                                    identVtoFormalV(
-                                        vector<IdentifierPtr>(1, Identifier::get("%exception", x->location))),
-                                    new ExprList(new NameRef(Identifier::get(x->exceptionVar->str, x->location))));
-                exceptionVarForRethrow->location = x->exceptionVar->location;
-
-                block->statements.push_back(binding.ptr());
-                block->statements.push_back(exceptionVarForRethrow.ptr());
-                block->statements.push_back(x->body);
-
-                IfPtr ifStatement = new If(cond.ptr(), block.ptr());
-                ifStatement->location = x->location;
-                if (!result)
-                    result = ifStatement.ptr();
-                if (lastIf.ptr())
-                    lastIf->elsePart = ifStatement.ptr();
-                lastIf = ifStatement;
-            } else {
-                BlockPtr block = new Block();
-                block->location = x->location;
-
-                vector<IdentifierPtr> identifiers;
-                makeExceptionVars(identifiers, x);
-
-                ExprListPtr asAnyArgs = new ExprList(new NameRef(expVar));
-                CallPtr getter = new Call(operator_expr_exceptionAsAny(),
-                                          asAnyArgs);
-                getter->location = x->exceptionVar->location;
-                BindingPtr binding =
-                        new Binding(VAR,
-                                    identVtoFormalV(identifiers),
-                                    new ExprList(getter.ptr()));
-                binding->location = x->exceptionVar->location;
-
-                BindingPtr exceptionVarForRethrow =
-                        new Binding(REF,
-                                    identVtoFormalV(
-                                        vector<IdentifierPtr>(1, Identifier::get("%exception", x->location))),
-                                    new ExprList(new NameRef(Identifier::get(x->exceptionVar->str, x->location))));
-                exceptionVarForRethrow->location = x->exceptionVar->location;
-
-                block->statements.push_back(binding.ptr());
-                block->statements.push_back(exceptionVarForRethrow.ptr());
-                block->statements.push_back(x->body);
-
-                if (!result)
-                    result = block.ptr();
-                if (lastIf.ptr())
-                    lastIf->elsePart = block.ptr();
-
-                lastWasAny = true;
-                lastIf = nullptr;
-            }
-        }
-        assert(result.ptr());
-        if (!lastWasAny) {
-            assert(lastIf.ptr());
-            BlockPtr block = new Block();
-            block->location = firstCatchLocation;
+StatementPtr desugarCatchBlocks(llvm::ArrayRef<CatchPtr> catchBlocks) {
+    assert(!catchBlocks.empty());
+    Location firstCatchLocation = catchBlocks.front()->location;
+    IdentifierPtr expVar = Identifier::get("%exp", firstCatchLocation);
+
+    CallPtr activeException =
+        new Call(primitive_expr_activeException(), new ExprList());
+    activeException->location = firstCatchLocation;
+
+    BindingPtr expBinding =
+        new Binding(VAR, identVtoFormalV(vector<IdentifierPtr>(1, expVar)),
+                    new ExprList(activeException.ptr()));
+    expBinding->location = firstCatchLocation;
+
+    bool lastWasAny = false;
+    IfPtr lastIf;
+    StatementPtr result;
+    for (size_t i = 0; i < catchBlocks.size(); ++i) {
+        CatchPtr x = catchBlocks[i];
+        if (lastWasAny)
+            error(x, "unreachable catch block");
+        if (x->exceptionType.ptr()) {
+            ExprListPtr asTypeArgs = new ExprList(x->exceptionType);
             ExprPtr expVarName = new NameRef(expVar);
-            expVarName->location = firstCatchLocation;
-            ExprListPtr continueArgs = new ExprList(expVarName);
-            CallPtr continueException = new Call(operator_expr_continueException(),
-                                                 continueArgs);
-            continueException->location = firstCatchLocation;
-            StatementPtr stmt = new ExprStatement(continueException.ptr());
-            stmt->location = firstCatchLocation;
-            block->statements.push_back(stmt);
-            block->statements.push_back(new Unreachable());
-            lastIf->elsePart = block.ptr();
-        }
+            expVarName->location = x->exceptionVar->location;
+            asTypeArgs->add(expVarName);
+            CallPtr cond = new Call(operator_expr_exceptionIsP(), asTypeArgs);
+            cond->location = x->exceptionType->location;
 
+            BlockPtr block = new Block();
+            block->location = x->location;
+
+            vector<IdentifierPtr> identifiers;
+            makeExceptionVars(identifiers, x);
+
+            CallPtr getter = new Call(operator_expr_exceptionAs(), asTypeArgs);
+            getter->location = x->exceptionVar->location;
+            BindingPtr binding = new Binding(VAR, identVtoFormalV(identifiers),
+                                             new ExprList(getter.ptr()));
+            binding->location = x->exceptionVar->location;
+
+            BindingPtr exceptionVarForRethrow =
+                new Binding(REF,
+                            identVtoFormalV(vector<IdentifierPtr>(
+                                1, Identifier::get("%exception", x->location))),
+                            new ExprList(new NameRef(Identifier::get(
+                                x->exceptionVar->str, x->location))));
+            exceptionVarForRethrow->location = x->exceptionVar->location;
+
+            block->statements.push_back(binding.ptr());
+            block->statements.push_back(exceptionVarForRethrow.ptr());
+            block->statements.push_back(x->body);
+
+            IfPtr ifStatement = new If(cond.ptr(), block.ptr());
+            ifStatement->location = x->location;
+            if (!result)
+                result = ifStatement.ptr();
+            if (lastIf.ptr())
+                lastIf->elsePart = ifStatement.ptr();
+            lastIf = ifStatement;
+        } else {
+            BlockPtr block = new Block();
+            block->location = x->location;
+
+            vector<IdentifierPtr> identifiers;
+            makeExceptionVars(identifiers, x);
+
+            ExprListPtr asAnyArgs = new ExprList(new NameRef(expVar));
+            CallPtr getter =
+                new Call(operator_expr_exceptionAsAny(), asAnyArgs);
+            getter->location = x->exceptionVar->location;
+            BindingPtr binding = new Binding(VAR, identVtoFormalV(identifiers),
+                                             new ExprList(getter.ptr()));
+            binding->location = x->exceptionVar->location;
+
+            BindingPtr exceptionVarForRethrow =
+                new Binding(REF,
+                            identVtoFormalV(vector<IdentifierPtr>(
+                                1, Identifier::get("%exception", x->location))),
+                            new ExprList(new NameRef(Identifier::get(
+                                x->exceptionVar->str, x->location))));
+            exceptionVarForRethrow->location = x->exceptionVar->location;
+
+            block->statements.push_back(binding.ptr());
+            block->statements.push_back(exceptionVarForRethrow.ptr());
+            block->statements.push_back(x->body);
+
+            if (!result)
+                result = block.ptr();
+            if (lastIf.ptr())
+                lastIf->elsePart = block.ptr();
+
+            lastWasAny = true;
+            lastIf = nullptr;
+        }
+    }
+    assert(result.ptr());
+    if (!lastWasAny) {
+        assert(lastIf.ptr());
         BlockPtr block = new Block();
         block->location = firstCatchLocation;
-        block->statements.push_back(expBinding.ptr());
-        block->statements.push_back(result.ptr());
-
-        return block.ptr();
+        ExprPtr expVarName = new NameRef(expVar);
+        expVarName->location = firstCatchLocation;
+        ExprListPtr continueArgs = new ExprList(expVarName);
+        CallPtr continueException =
+            new Call(operator_expr_continueException(), continueArgs);
+        continueException->location = firstCatchLocation;
+        StatementPtr stmt = new ExprStatement(continueException.ptr());
+        stmt->location = firstCatchLocation;
+        block->statements.push_back(stmt);
+        block->statements.push_back(new Unreachable());
+        lastIf->elsePart = block.ptr();
     }
 
-    void desugarThrow(Throw *thro) {
-        if (thro->desugaredExpr != nullptr)
-            return;
+    BlockPtr block = new Block();
+    block->location = firstCatchLocation;
+    block->statements.push_back(expBinding.ptr());
+    block->statements.push_back(result.ptr());
 
-        if (thro->expr != nullptr) {
-            thro->desugaredExpr = thro->expr;
-            thro->desugaredContext = thro->context;
-        } else {
-            thro->desugaredExpr = new NameRef(Identifier::get("%exception", thro->location));
-            thro->desugaredContext = new NameRef(Identifier::get("%context", thro->location));
-        }
+    return block.ptr();
+}
+
+void desugarThrow(Throw *thro) {
+    if (thro->desugaredExpr != nullptr)
+        return;
+
+    if (thro->expr != nullptr) {
+        thro->desugaredExpr = thro->expr;
+        thro->desugaredContext = thro->context;
+    } else {
+        thro->desugaredExpr =
+            new NameRef(Identifier::get("%exception", thro->location));
+        thro->desugaredContext =
+            new NameRef(Identifier::get("%context", thro->location));
     }
+}
 
-    StatementPtr desugarSwitchStatement(SwitchPtr x) {
-        BlockPtr block = new Block();
-        block->location = x->location;
+StatementPtr desugarSwitchStatement(SwitchPtr x) {
+    BlockPtr block = new Block();
+    block->location = x->location;
 
-        block->statements.insert(block->statements.end(),
-                                 x->exprStatements.begin(), x->exprStatements.end());
+    block->statements.insert(block->statements.end(), x->exprStatements.begin(),
+                             x->exprStatements.end());
 
-        // %thing is the value being switched on
-        IdentifierPtr thing = Identifier::get("%case", x->expr->location);
-        NameRefPtr thingRef = new NameRef(thing);
-        thingRef->location = x->expr->location;
+    // %thing is the value being switched on
+    IdentifierPtr thing = Identifier::get("%case", x->expr->location);
+    NameRefPtr thingRef = new NameRef(thing);
+    thingRef->location = x->expr->location;
 
-        // initialize %case
-        {
-            BindingPtr b = new Binding(FORWARD, identV(thing), new ExprList(x->expr));
-            b->location = x->expr->location;
-            block->statements.push_back(b.ptr());
-        }
+    // initialize %case
+    {
+        BindingPtr b =
+            new Binding(FORWARD, identV(thing), new ExprList(x->expr));
+        b->location = x->expr->location;
+        block->statements.push_back(b.ptr());
+    }
 
-        ExprPtr caseCallable = operator_expr_caseP();
+    ExprPtr caseCallable = operator_expr_caseP();
 
-        StatementPtr root;
-        StatementPtr *nextPtr = &root;
+    StatementPtr root;
+    StatementPtr *nextPtr = &root;
 
-        // dispatch logic
-        for (size_t i = 0; i < x->caseBlocks.size(); ++i) {
-            CaseBlockPtr caseBlock = x->caseBlocks[i];
+    // dispatch logic
+    for (size_t i = 0; i < x->caseBlocks.size(); ++i) {
+        CaseBlockPtr caseBlock = x->caseBlocks[i];
 
-            ExprListPtr caseArgs = new ExprList(thingRef.ptr());
-            ExprPtr caseCompareArgs = new Paren(caseBlock->caseLabels);
-            caseCompareArgs->location = caseBlock->location;
-            caseArgs->add(caseCompareArgs);
+        ExprListPtr caseArgs = new ExprList(thingRef.ptr());
+        ExprPtr caseCompareArgs = new Paren(caseBlock->caseLabels);
+        caseCompareArgs->location = caseBlock->location;
+        caseArgs->add(caseCompareArgs);
 
-            ExprPtr condition = new Call(caseCallable, caseArgs);
-            condition->location = caseBlock->location;
+        ExprPtr condition = new Call(caseCallable, caseArgs);
+        condition->location = caseBlock->location;
 
-            IfPtr ifStmt = new If(condition, caseBlock->body);
-            ifStmt->location = caseBlock->location;
-            *nextPtr = ifStmt.ptr();
-            nextPtr = &(ifStmt->elsePart);
-        }
+        IfPtr ifStmt = new If(condition, caseBlock->body);
+        ifStmt->location = caseBlock->location;
+        *nextPtr = ifStmt.ptr();
+        nextPtr = &(ifStmt->elsePart);
+    }
 
-        if (x->defaultCase.ptr())
-            *nextPtr = x->defaultCase;
-        else
-            *nextPtr = nullptr;
+    if (x->defaultCase.ptr())
+        *nextPtr = x->defaultCase;
+    else
+        *nextPtr = nullptr;
 
-        block->statements.push_back(root);
+    block->statements.push_back(root);
 
-        return block.ptr();
-    }
+    return block.ptr();
+}
 
-    ExprPtr wrapIntoStatic(ExprPtr expr) {
-        ExprPtr staticName =
-                new ForeignExpr("prelude",
-                                new NameRef(Identifier::get("Static")));
+ExprPtr wrapIntoStatic(ExprPtr expr) {
+    ExprPtr staticName =
+        new ForeignExpr("prelude", new NameRef(Identifier::get("Static")));
 
-        return new Indexing(staticName, new ExprList(expr));
-    }
+    return new Indexing(staticName, new ExprList(expr));
+}
 
-    static SourcePtr evalToSource(Location const &location, ExprListPtr args, EnvPtr env) {
-        llvm::SmallString<128> sourceTextBuf;
-        llvm::raw_svector_ostream sourceTextOut(sourceTextBuf);
+static SourcePtr evalToSource(Location const &location, ExprListPtr args,
+                              EnvPtr env) {
+    llvm::SmallString<128> sourceTextBuf;
+    llvm::raw_svector_ostream sourceTextOut(sourceTextBuf);
 
-        MultiStaticPtr values = evaluateMultiStatic(args, env);
-        for (size_t i = 0; i < values->size(); ++i) {
-            printStaticName(sourceTextOut, values->values[i]);
-        }
+    MultiStaticPtr values = evaluateMultiStatic(args, env);
+    for (size_t i = 0; i < values->size(); ++i) {
+        printStaticName(sourceTextOut, values->values[i]);
+    }
 
-        llvm::SmallString<128> sourceNameBuf;
-        llvm::raw_svector_ostream sourceNameOut(sourceNameBuf);
-        sourceNameOut << "<eval ";
-        printFileLineCol(sourceNameOut, location);
-        sourceNameOut << ">";
+    llvm::SmallString<128> sourceNameBuf;
+    llvm::raw_svector_ostream sourceNameOut(sourceNameBuf);
+    sourceNameOut << "<eval ";
+    printFileLineCol(sourceNameOut, location);
+    sourceNameOut << ">";
 
-        return new Source(sourceNameOut.str(),
-                          llvm::MemoryBuffer::getMemBufferCopy(sourceTextBuf).get());
-    }
+    return new Source(
+        sourceNameOut.str(),
+        llvm::MemoryBuffer::getMemBufferCopy(sourceTextBuf).get());
+}
 
-    ExprListPtr desugarEvalExpr(EvalExprPtr eval, EnvPtr env) {
-        if (!!eval->value)
-            return eval->value;
-        else {
-            SourcePtr source = evalToSource(eval->location, new ExprList(eval->args), env);
-            eval->value = parseExprList(source, 0, unsigned(source->size()));
-            assert(!!eval->value);
-            return eval->value;
-        }
+ExprListPtr desugarEvalExpr(EvalExprPtr eval, EnvPtr env) {
+    if (!!eval->value)
+        return eval->value;
+    else {
+        SourcePtr source =
+            evalToSource(eval->location, new ExprList(eval->args), env);
+        eval->value = parseExprList(source, 0, unsigned(source->size()));
+        assert(!!eval->value);
+        return eval->value;
     }
+}
 
-    llvm::ArrayRef<StatementPtr> desugarEvalStatement(EvalStatementPtr eval, EnvPtr env) {
-        if (eval->evaled)
-            return eval->value;
-        else {
-            SourcePtr source = evalToSource(eval->location, eval->args, env);
-            parseStatements(source, 0, unsigned(source->size()), eval->value);
-            eval->evaled = true;
-            return eval->value;
-        }
+llvm::ArrayRef<StatementPtr> desugarEvalStatement(EvalStatementPtr eval,
+                                                  EnvPtr env) {
+    if (eval->evaled)
+        return eval->value;
+    else {
+        SourcePtr source = evalToSource(eval->location, eval->args, env);
+        parseStatements(source, 0, unsigned(source->size()), eval->value);
+        eval->evaled = true;
+        return eval->value;
     }
+}
 
-    llvm::ArrayRef<TopLevelItemPtr> desugarEvalTopLevel(EvalTopLevelPtr eval, EnvPtr env) {
-        if (eval->evaled)
-            return eval->value;
-        else {
-            SourcePtr source = evalToSource(eval->location, eval->args, env);
-            parseTopLevelItems(source, 0, unsigned(source->size()), eval->value, eval->module);
-            eval->evaled = true;
-            return eval->value;
-        }
+llvm::ArrayRef<TopLevelItemPtr> desugarEvalTopLevel(EvalTopLevelPtr eval,
+                                                    EnvPtr env) {
+    if (eval->evaled)
+        return eval->value;
+    else {
+        SourcePtr source = evalToSource(eval->location, eval->args, env);
+        parseTopLevelItems(source, 0, unsigned(source->size()), eval->value,
+                           eval->module);
+        eval->evaled = true;
+        return eval->value;
     }
+}
 
-    OverloadPtr desugarAsOverload(OverloadPtr &x) {
-        assert(x->hasAsConversion);
-
-        //Generate specialised overload
-        CodePtr code = new Code();
-        code->location = x->location;
-        clone(x->code->patternVars, code->patternVars);
-
-        //Generate stub body
-        CallPtr returnExpr = new Call(x->target.ptr(), new ExprList());
-        returnExpr->location = x->code->body->location;
-
-        //Add patterns as static args
-        for (unsigned i = 0; i < x->code->patternVars.size(); ++i) {
-            llvm::SmallString<128> buf;
-            llvm::raw_svector_ostream sout(buf);
-            sout << "%asArg" << i;
-            IdentifierPtr argName = Identifier::get(sout.str());
+OverloadPtr desugarAsOverload(OverloadPtr &x) {
+    assert(x->hasAsConversion);
 
-            ExprPtr indexing = wrapIntoStatic(new NameRef(x->code->patternVars[i].name));
-            indexing->startLocation = code->patternVars[i].name->location;
-            indexing->endLocation = code->patternVars[i].name->location;
+    // Generate specialised overload
+    CodePtr code = new Code();
+    code->location = x->location;
+    clone(x->code->patternVars, code->patternVars);
 
-            FormalArgPtr arg = new FormalArg(argName, indexing.ptr());
-            arg->location = x->code->patternVars[i].name->location;
-            code->formalArgs.insert(code->formalArgs.begin(), arg);
+    // Generate stub body
+    CallPtr returnExpr = new Call(x->target.ptr(), new ExprList());
+    returnExpr->location = x->code->body->location;
 
-            //Add patterns as static call args
-            ExprPtr callArg = new NameRef(x->code->patternVars[i].name);
-            returnExpr->parenArgs->add(callArg);
-        }
+    // Add patterns as static args
+    for (unsigned i = 0; i < x->code->patternVars.size(); ++i) {
+        llvm::SmallString<128> buf;
+        llvm::raw_svector_ostream sout(buf);
+        sout << "%asArg" << i;
+        IdentifierPtr argName = Identifier::get(sout.str());
+
+        ExprPtr indexing =
+            wrapIntoStatic(new NameRef(x->code->patternVars[i].name));
+        indexing->startLocation = code->patternVars[i].name->location;
+        indexing->endLocation = code->patternVars[i].name->location;
+
+        FormalArgPtr arg = new FormalArg(argName, indexing.ptr());
+        arg->location = x->code->patternVars[i].name->location;
+        code->formalArgs.insert(code->formalArgs.begin(), arg);
+
+        // Add patterns as static call args
+        ExprPtr callArg = new NameRef(x->code->patternVars[i].name);
+        returnExpr->parenArgs->add(callArg);
+    }
 
-        //Add args
-        for (unsigned i = 0; i < x->code->formalArgs.size(); ++i) {
-            FormalArgPtr arg = clone(x->code->formalArgs[i]);
-            arg->tempness = TEMPNESS_FORWARD;
-            if (x->code->formalArgs[i]->asType != nullptr) {
-                arg->type = x->code->formalArgs[i]->asType;
-                ExprPtr typeArg = x->code->formalArgs[i]->asType;
-                CallPtr callArg = new Call(operator_expr_asExpression(), new ExprList());
-                callArg->parenArgs->add(new NameRef(x->code->formalArgs[i]->name));
-                callArg->parenArgs->add(x->code->formalArgs[i]->asType);
-                callArg->location = x->code->formalArgs[i]->location;
-                returnExpr->parenArgs->add(callArg.ptr());
-            } else {
-                ExprPtr arg0 = new NameRef(x->code->formalArgs[i]->name);
-                arg0->location = x->code->formalArgs[i]->location;
-                returnExpr->parenArgs->add(arg0);
-            }
-            code->formalArgs.push_back(arg.ptr());
+    // Add args
+    for (unsigned i = 0; i < x->code->formalArgs.size(); ++i) {
+        FormalArgPtr arg = clone(x->code->formalArgs[i]);
+        arg->tempness = TEMPNESS_FORWARD;
+        if (x->code->formalArgs[i]->asType != nullptr) {
+            arg->type = x->code->formalArgs[i]->asType;
+            ExprPtr typeArg = x->code->formalArgs[i]->asType;
+            CallPtr callArg =
+                new Call(operator_expr_asExpression(), new ExprList());
+            callArg->parenArgs->add(new NameRef(x->code->formalArgs[i]->name));
+            callArg->parenArgs->add(x->code->formalArgs[i]->asType);
+            callArg->location = x->code->formalArgs[i]->location;
+            returnExpr->parenArgs->add(callArg.ptr());
+        } else {
+            ExprPtr arg0 = new NameRef(x->code->formalArgs[i]->name);
+            arg0->location = x->code->formalArgs[i]->location;
+            returnExpr->parenArgs->add(arg0);
         }
+        code->formalArgs.push_back(arg.ptr());
+    }
 
-        code->body = x->code->body;
-        OverloadPtr spec = new Overload(x->module, x->target, code, x->callByName, x->isInline);
-        spec->location = x->location;
-        spec->env = x->env;
+    code->body = x->code->body;
+    OverloadPtr spec =
+        new Overload(x->module, x->target, code, x->callByName, x->isInline);
+    spec->location = x->location;
+    spec->env = x->env;
 
-        x->code->body = new Return(RETURN_FORWARD, new ExprList(new Unpack(returnExpr.ptr())), true);
-        x->isInline = FORCE_INLINE;
-        return spec;
-    }
+    x->code->body = new Return(
+        RETURN_FORWARD, new ExprList(new Unpack(returnExpr.ptr())), true);
+    x->isInline = FORCE_INLINE;
+    return spec;
 }
+} // namespace clay
diff --git a/compiler/desugar.hpp b/compiler/desugar.hpp
index 98fc1a23..6fc4f29a 100644
--- a/compiler/desugar.hpp
+++ b/compiler/desugar.hpp
@@ -3,19 +3,21 @@
 #include "clay.hpp"
 
 namespace clay {
-    ExprPtr desugarCharLiteral(char c);
-    void desugarFieldRef(FieldRefPtr x, ModulePtr module);
-    ExprPtr desugarStaticIndexing(StaticIndexingPtr x);
-    ExprPtr desugarVariadicOp(VariadicOpPtr x);
-    ExprListPtr desugarVariadicAssignmentRight(VariadicAssignment *x);
-    StatementPtr desugarForStatement(ForPtr x);
-    StatementPtr desugarCatchBlocks(llvm::ArrayRef<CatchPtr> catchBlocks);
-    void desugarThrow(Throw* thro);
-    StatementPtr desugarSwitchStatement(SwitchPtr x);
-    ExprPtr wrapIntoStatic(ExprPtr expr);
+ExprPtr desugarCharLiteral(char c);
+void desugarFieldRef(FieldRefPtr x, ModulePtr module);
+ExprPtr desugarStaticIndexing(StaticIndexingPtr x);
+ExprPtr desugarVariadicOp(VariadicOpPtr x);
+ExprListPtr desugarVariadicAssignmentRight(VariadicAssignment *x);
+StatementPtr desugarForStatement(ForPtr x);
+StatementPtr desugarCatchBlocks(llvm::ArrayRef<CatchPtr> catchBlocks);
+void desugarThrow(Throw *thro);
+StatementPtr desugarSwitchStatement(SwitchPtr x);
+ExprPtr wrapIntoStatic(ExprPtr expr);
 
-    ExprListPtr desugarEvalExpr(EvalExprPtr eval, EnvPtr env);
-    llvm::ArrayRef<StatementPtr> desugarEvalStatement(EvalStatementPtr eval, EnvPtr env);
-    llvm::ArrayRef<TopLevelItemPtr> desugarEvalTopLevel(EvalTopLevelPtr eval, EnvPtr env);
-    OverloadPtr desugarAsOverload(OverloadPtr &x);
-}
+ExprListPtr desugarEvalExpr(EvalExprPtr eval, EnvPtr env);
+llvm::ArrayRef<StatementPtr> desugarEvalStatement(EvalStatementPtr eval,
+                                                  EnvPtr env);
+llvm::ArrayRef<TopLevelItemPtr> desugarEvalTopLevel(EvalTopLevelPtr eval,
+                                                    EnvPtr env);
+OverloadPtr desugarAsOverload(OverloadPtr &x);
+} // namespace clay
diff --git a/compiler/env.cpp b/compiler/env.cpp
index 326cb7be..d68713c4 100644
--- a/compiler/env.cpp
+++ b/compiler/env.cpp
@@ -1,484 +1,483 @@
 #include "env.hpp"
 #include "clay.hpp"
-#include "loader.hpp"
 #include "error.hpp"
+#include "loader.hpp"
 
 namespace clay {
-    using namespace std;
-
-    typedef llvm::StringMap<ObjectPtr>::iterator MapIter;
-
-    //
-    // addGlobal
-    //
-
-    void addGlobal(ModulePtr module,
-                   IdentifierPtr name,
-                   Visibility visibility,
-                   ObjectPtr value) {
-        MapIter i = module->globals.find(name->str);
-        if (i != module->globals.end())
-            error(name, "name redefined: " + name->str);
-        module->globals[name->str] = value;
-        module->allSymbols[name->str].insert(value);
-        if (visibility == PUBLIC) {
-            module->publicGlobals[name->str] = value;
-            module->publicSymbols[name->str].insert(value);
-        }
+using namespace std;
+
+typedef llvm::StringMap<ObjectPtr>::iterator MapIter;
+
+//
+// addGlobal
+//
+
+void addGlobal(ModulePtr module, IdentifierPtr name, Visibility visibility,
+               ObjectPtr value) {
+    MapIter i = module->globals.find(name->str);
+    if (i != module->globals.end())
+        error(name, "name redefined: " + name->str);
+    module->globals[name->str] = value;
+    module->allSymbols[name->str].insert(value);
+    if (visibility == PUBLIC) {
+        module->publicGlobals[name->str] = value;
+        module->publicSymbols[name->str].insert(value);
     }
+}
 
-    //
-    // module errors
-    //
-
-    static void suggestModules(llvm::raw_ostream &err, set<string> const &moduleNames, llvm::StringRef name) {
-        for (set<string>::const_iterator i = moduleNames.begin(), end = moduleNames.end();
-             i != end;
-             ++i) {
-            err << "\n    import " << *i << ".(" << name << ");";
-        }
+//
+// module errors
+//
+
+static void suggestModules(llvm::raw_ostream &err,
+                           set<string> const &moduleNames,
+                           llvm::StringRef name) {
+    for (set<string>::const_iterator i = moduleNames.begin(),
+                                     end = moduleNames.end();
+         i != end; ++i) {
+        err << "\n    import " << *i << ".(" << name << ");";
     }
+}
 
-    static void ambiguousImportError(IdentifierPtr name, ImportSet const &candidates) {
-        string buf;
-        llvm::raw_string_ostream err(buf);
-        err << "ambiguous imported symbol: " << name->str;
-        set<string> moduleNames;
-        for (const ObjectPtr *i = candidates.begin(), *end = candidates.end();
-             i != end;
-             ++i) {
-            moduleNames.insert(staticModule(*i)->moduleName);
-        }
-
-        err << "\n  disambiguate with one of:";
-        suggestModules(err, moduleNames, name->str);
-        error(name, err.str());
+static void ambiguousImportError(IdentifierPtr name,
+                                 ImportSet const &candidates) {
+    string buf;
+    llvm::raw_string_ostream err(buf);
+    err << "ambiguous imported symbol: " << name->str;
+    set<string> moduleNames;
+    for (const ObjectPtr *i = candidates.begin(), *end = candidates.end();
+         i != end; ++i) {
+        moduleNames.insert(staticModule(*i)->moduleName);
     }
 
-    static void undefinedNameError(IdentifierPtr name) {
-        string buf;
-        llvm::raw_string_ostream err(buf);
-        err << "undefined name: " << name->str;
-        set<string> suggestModuleNames;
-
-        for (llvm::StringMap<ModulePtr>::const_iterator i = globalModules.begin(), end = globalModules.end();
-             i != end;
-             ++i) {
-            if (lookupPublic(i->second, name) != nullptr)
-                suggestModuleNames.insert(i->second->moduleName);
-        }
+    err << "\n  disambiguate with one of:";
+    suggestModules(err, moduleNames, name->str);
+    error(name, err.str());
+}
 
-        if (!suggestModuleNames.empty()) {
-            err << "\n  maybe you need one of:";
-            suggestModules(err, suggestModuleNames, name->str);
-        }
+static void undefinedNameError(IdentifierPtr name) {
+    string buf;
+    llvm::raw_string_ostream err(buf);
+    err << "undefined name: " << name->str;
+    set<string> suggestModuleNames;
+
+    for (llvm::StringMap<ModulePtr>::const_iterator i = globalModules.begin(),
+                                                    end = globalModules.end();
+         i != end; ++i) {
+        if (lookupPublic(i->second, name) != nullptr)
+            suggestModuleNames.insert(i->second->moduleName);
+    }
 
-        error(name, err.str());
+    if (!suggestModuleNames.empty()) {
+        err << "\n  maybe you need one of:";
+        suggestModules(err, suggestModuleNames, name->str);
     }
 
-    //
-    // getPublicSymbols, getAllSymbols
-    //
+    error(name, err.str());
+}
 
-    static const llvm::StringMap<ImportSet> &getPublicSymbols(ModulePtr module);
-    static const llvm::StringMap<ImportSet> &getAllSymbols(ModulePtr module);
+//
+// getPublicSymbols, getAllSymbols
+//
 
-    static void addImportedSymbols(ModulePtr module, bool publicOnly);
+static const llvm::StringMap<ImportSet> &getPublicSymbols(ModulePtr module);
+static const llvm::StringMap<ImportSet> &getAllSymbols(ModulePtr module);
 
-    static void getIntrinsicIdentifier(llvm::SmallVectorImpl<char> *out, llvm::StringRef in) {
-        // + 5 because all intrinsic names start with "llvm."
-        for (char const *i = in.begin() + 5, *end = in.end(); i != end; ++i)
-            if (*i == '.')
-                out->push_back('_');
-            else
-                out->push_back(*i);
-    }
+static void addImportedSymbols(ModulePtr module, bool publicOnly);
 
-    static void getIntrinsicSymbols(ModulePtr module) {
-        assert(module->isIntrinsicsModule);
-        module->publicSymbols.clear();
-        module->allSymbols.clear();
-        static const char *const intrinsicNames[] = {
-            "",
+static void getIntrinsicIdentifier(llvm::SmallVectorImpl<char> *out,
+                                   llvm::StringRef in) {
+    // + 5 because all intrinsic names start with "llvm."
+    for (char const *i = in.begin() + 5, *end = in.end(); i != end; ++i)
+        if (*i == '.')
+            out->push_back('_');
+        else
+            out->push_back(*i);
+}
+
+static void getIntrinsicSymbols(ModulePtr module) {
+    assert(module->isIntrinsicsModule);
+    module->publicSymbols.clear();
+    module->allSymbols.clear();
+    static const char *const intrinsicNames[] = {
+        "",
 #define GET_INTRINSIC_NAME_TABLE
-#include "llvm/Intrinsics.gen"
+#include "llvm/IR/IntrinsicImpl.inc"
 #undef GET_INTRINSIC_NAME_TABLE
-        };
-        for (size_t idIter = llvm::Intrinsic::ID(1);
-             idIter < llvm::Intrinsic::num_intrinsics;
-             ++idIter) {
-            llvm::Intrinsic::ID id = static_cast<llvm::Intrinsic::ID>(idIter);
-            llvm::SmallString<64> identifier;
-            getIntrinsicIdentifier(&identifier, intrinsicNames[id]);
-            module->publicSymbols[identifier].insert(
-                new IntrinsicSymbol(module.ptr(), Identifier::get(identifier), id));
-            module->allSymbols[identifier].insert(
-                new IntrinsicSymbol(module.ptr(), Identifier::get(identifier), id));
-        }
-        module->publicSymbolsLoaded = 1;
-        module->allSymbolsLoaded = 1;
+    };
+    for (size_t idIter = llvm::Intrinsic::ID(1);
+         idIter < llvm::Intrinsic::num_intrinsics; ++idIter) {
+        llvm::Intrinsic::ID id = static_cast<llvm::Intrinsic::ID>(idIter);
+        llvm::SmallString<64> identifier;
+        getIntrinsicIdentifier(&identifier, intrinsicNames[id]);
+        module->publicSymbols[identifier].insert(
+            new IntrinsicSymbol(module.ptr(), Identifier::get(identifier), id));
+        module->allSymbols[identifier].insert(
+            new IntrinsicSymbol(module.ptr(), Identifier::get(identifier), id));
     }
+    module->publicSymbolsLoaded = 1;
+    module->allSymbolsLoaded = 1;
+}
 
-    static const llvm::StringMap<ImportSet> &getPublicSymbols(ModulePtr module) {
-        if (module->publicSymbolsLoaded)
-            return module->publicSymbols;
-        if (module->publicSymbolsLoading >= 1)
-            return module->publicSymbols;
-        if (module->isIntrinsicsModule) {
-            getIntrinsicSymbols(module);
-            return module->publicSymbols;
-        }
-        module->publicSymbolsLoading += 1;
-        addImportedSymbols(module, /*publicOnly=*/ true);
-        module->publicSymbolsLoading -= 1;
+static const llvm::StringMap<ImportSet> &getPublicSymbols(ModulePtr module) {
+    if (module->publicSymbolsLoaded)
+        return module->publicSymbols;
+    if (module->publicSymbolsLoading >= 1)
+        return module->publicSymbols;
+    if (module->isIntrinsicsModule) {
+        getIntrinsicSymbols(module);
         return module->publicSymbols;
     }
+    module->publicSymbolsLoading += 1;
+    addImportedSymbols(module, /*publicOnly=*/true);
+    module->publicSymbolsLoading -= 1;
+    return module->publicSymbols;
+}
 
-    static const llvm::StringMap<ImportSet> &getAllSymbols(ModulePtr module) {
-        if (module->allSymbolsLoaded)
-            return module->allSymbols;
-        if (module->allSymbolsLoading >= 1)
-            return module->allSymbols;
-        if (module->isIntrinsicsModule) {
-            getIntrinsicSymbols(module);
-            return module->allSymbols;
-        }
-        module->allSymbolsLoading += 1;
+static const llvm::StringMap<ImportSet> &getAllSymbols(ModulePtr module) {
+    if (module->allSymbolsLoaded)
+        return module->allSymbols;
+    if (module->allSymbolsLoading >= 1)
+        return module->allSymbols;
+    if (module->isIntrinsicsModule) {
+        getIntrinsicSymbols(module);
+        return module->allSymbols;
+    }
+    module->allSymbolsLoading += 1;
 
-        addImportedSymbols(module, /*publicOnly=*/ false);
+    addImportedSymbols(module, /*publicOnly=*/false);
 
-        module->allSymbolsLoading -= 1;
-        return module->allSymbols;
+    module->allSymbolsLoading -= 1;
+    return module->allSymbols;
+}
+
+static void insertImported(IdentifierPtr name, ObjectPtr value,
+                           const llvm::StringMap<ObjectPtr> &globals,
+                           llvm::StringMap<ImportSet> &result,
+                           set<string> &specificImported,
+                           bool isSpecificImport) {
+    string nameStr(name->str.begin(), name->str.end());
+    if (specificImported.count(nameStr)) {
+        if (isSpecificImport)
+            error(name, "name imported already: " + name->str);
+        return;
     }
 
-    static void insertImported(IdentifierPtr name,
-                               ObjectPtr value,
-                               const llvm::StringMap<ObjectPtr> &globals,
-                               llvm::StringMap<ImportSet> &result,
-                               set<string> &specificImported,
-                               bool isSpecificImport) {
-        string nameStr(name->str.begin(), name->str.end());
-        if (specificImported.count(nameStr)) {
-            if (isSpecificImport)
-                error(name, "name imported already: " + name->str);
-            return;
+    if (!globals.count(nameStr)) {
+        if (isSpecificImport) {
+            result[nameStr].clear();
+            specificImported.insert(nameStr);
         }
+        result[nameStr].insert(value);
+    }
+}
 
-        if (!globals.count(nameStr)) {
-            if (isSpecificImport) {
-                result[nameStr].clear();
-                specificImported.insert(nameStr);
+static void addImportedSymbols(ModulePtr module, bool publicOnly) {
+    llvm::StringMap<ImportSet> &result =
+        publicOnly ? module->publicSymbols : module->allSymbols;
+    set<string> specificImported;
+
+    const llvm::StringMap<ObjectPtr> &globals = module->globals;
+
+    vector<ImportPtr>::iterator ii = module->imports.begin(),
+                                iend = module->imports.end();
+    for (; ii != iend; ++ii) {
+        Import *x = ii->ptr();
+        if (publicOnly && (x->visibility != PUBLIC))
+            continue;
+        if (x->importKind == IMPORT_MODULE) {
+            ImportModule *y = (ImportModule *)x;
+            IdentifierPtr name = nullptr;
+            if (y->alias.ptr()) {
+                name = y->alias;
+            } else {
+                if (y->dottedName->parts.size() == 1)
+                    name = y->dottedName->parts[0];
             }
-            result[nameStr].insert(value);
-        }
-    }
-    
-    static void addImportedSymbols(ModulePtr module,
-                                   bool publicOnly) {
-        llvm::StringMap<ImportSet> &result =
-                publicOnly ? module->publicSymbols : module->allSymbols;
-        set<string> specificImported;
-
-        const llvm::StringMap<ObjectPtr> &globals = module->globals;
-
-        vector<ImportPtr>::iterator
-                ii = module->imports.begin(),
-                iend = module->imports.end();
-        for (; ii != iend; ++ii) {
-            Import *x = ii->ptr();
-            if (publicOnly && (x->visibility != PUBLIC))
-                continue;
-            if (x->importKind == IMPORT_MODULE) {
-                ImportModule *y = (ImportModule *) x;
-                IdentifierPtr name = nullptr;
-                if (y->alias.ptr()) {
-                    name = y->alias;
-                } else {
-                    if (y->dottedName->parts.size() == 1)
-                        name = y->dottedName->parts[0];
-                }
-                if (name.ptr()) {
-                    // Module imports are set up by loadDependents, so don't alter them here;
-                    // only add them to specificImported so they catch conflicts with other imports
-                    string nameStr(name->str.begin(), name->str.end());
-                    if (specificImported.count(nameStr)) {
-                        error(name, "name imported already: " + nameStr);
-                    }
-                    specificImported.insert(nameStr);
+            if (name.ptr()) {
+                // Module imports are set up by loadDependents, so don't alter
+                // them here; only add them to specificImported so they catch
+                // conflicts with other imports
+                string nameStr(name->str.begin(), name->str.end());
+                if (specificImported.count(nameStr)) {
+                    error(name, "name imported already: " + nameStr);
                 }
-            } else if (x->importKind == IMPORT_STAR) {
-                ImportStar *y = (ImportStar *) x;
-                const llvm::StringMap<ImportSet> &symbols2 =
-                        getPublicSymbols(y->module);
-                llvm::StringMap<ImportSet>::const_iterator
-                        mmi = symbols2.begin(),
-                        mmend = symbols2.end();
-                for (; mmi != mmend; ++mmi) {
-                    const ObjectPtr *oi = mmi->second.begin(), *oend = mmi->second.end();
-                    for (; oi != oend; ++oi) {
-                        IdentifierPtr fakeIdent = Identifier::get(mmi->getKey(), y->location);
-                        insertImported(fakeIdent, *oi, globals, result, specificImported, false);
-                    }
-                }
-            } else if (x->importKind == IMPORT_MEMBERS) {
-                ImportMembers *y = (ImportMembers *) x;
-                const llvm::StringMap<ImportSet> &publicSymbols =
-                        getPublicSymbols(y->module);
-                const llvm::StringMap<ImportSet> &allSymbols =
-                        getAllSymbols(y->module);
-                for (size_t i = 0; i < y->members.size(); ++i) {
-                    const ImportedMember &z = y->members[i];
-                    const llvm::StringMap<ImportSet> &memberSymbols =
-                            z.visibility == PRIVATE ? allSymbols : publicSymbols;
-                    llvm::StringMap<ImportSet>::const_iterator si =
-                            memberSymbols.find(z.name->str);
-                    if ((si == memberSymbols.end()) || si->second.empty())
-                        error(z.name, "imported name not found");
-                    const ImportSet &objs = si->second;
-                    IdentifierPtr name = z.name;
-                    if (z.alias.ptr())
-                        name = z.alias;
-                    const ObjectPtr *oi = objs.begin(), *oend = objs.end();
-                    for (; oi != oend; ++oi)
-                        insertImported(name, *oi, globals, result, specificImported, true);
+                specificImported.insert(nameStr);
+            }
+        } else if (x->importKind == IMPORT_STAR) {
+            ImportStar *y = (ImportStar *)x;
+            const llvm::StringMap<ImportSet> &symbols2 =
+                getPublicSymbols(y->module);
+            llvm::StringMap<ImportSet>::const_iterator mmi = symbols2.begin(),
+                                                       mmend = symbols2.end();
+            for (; mmi != mmend; ++mmi) {
+                const ObjectPtr *oi = mmi->second.begin(),
+                                *oend = mmi->second.end();
+                for (; oi != oend; ++oi) {
+                    IdentifierPtr fakeIdent =
+                        Identifier::get(mmi->getKey(), y->location);
+                    insertImported(fakeIdent, *oi, globals, result,
+                                   specificImported, false);
                 }
-            } else {
-                assert(false);
             }
-        }
-    }
-    
-    //
-    // lookupPrivate
-    //
-
-    ObjectPtr lookupPrivate(ModulePtr module, IdentifierPtr name) {
-    retry:
-        llvm::StringMap<ImportSet>::const_iterator i =
-                module->allSymbols.find(name->str);
-        if ((i == module->allSymbols.end()) || (i->second.empty())) {
-            if (!module->allSymbolsLoaded) {
-                getAllSymbols(module);
-                module->allSymbolsLoaded = true;
-                goto retry;
+        } else if (x->importKind == IMPORT_MEMBERS) {
+            ImportMembers *y = (ImportMembers *)x;
+            const llvm::StringMap<ImportSet> &publicSymbols =
+                getPublicSymbols(y->module);
+            const llvm::StringMap<ImportSet> &allSymbols =
+                getAllSymbols(y->module);
+            for (size_t i = 0; i < y->members.size(); ++i) {
+                const ImportedMember &z = y->members[i];
+                const llvm::StringMap<ImportSet> &memberSymbols =
+                    z.visibility == PRIVATE ? allSymbols : publicSymbols;
+                llvm::StringMap<ImportSet>::const_iterator si =
+                    memberSymbols.find(z.name->str);
+                if ((si == memberSymbols.end()) || si->second.empty())
+                    error(z.name, "imported name not found");
+                const ImportSet &objs = si->second;
+                IdentifierPtr name = z.name;
+                if (z.alias.ptr())
+                    name = z.alias;
+                const ObjectPtr *oi = objs.begin(), *oend = objs.end();
+                for (; oi != oend; ++oi)
+                    insertImported(name, *oi, globals, result, specificImported,
+                                   true);
             }
-            ModulePtr prelude = preludeModule();
-            if (module == prelude)
-                return nullptr;
-            else
-                return lookupPublic(prelude, name);
-        }
-        const ImportSet &objs = i->second;
-        if (objs.size() > 1) {
-            ambiguousImportError(name, objs);
+        } else {
+            assert(false);
         }
-        return *objs.begin();
     }
-    
-    //
-    // lookupPublic, safeLookupPublic
-    //
-
-    ObjectPtr lookupPublic(ModulePtr module, IdentifierPtr name) {
-    retry:
-        llvm::StringMap<ImportSet>::const_iterator i =
-                module->publicSymbols.find(name->str);
-        if ((i == module->publicSymbols.end()) || (i->second.empty())) {
-            if (!module->publicSymbolsLoaded) {
-                getPublicSymbols(module);
-                module->publicSymbolsLoaded = true;
-                goto retry;
-            }
-            return nullptr;
-        }
-        const ImportSet &objs = i->second;
-        if (objs.size() > 1) {
-            ambiguousImportError(name, objs);
+}
+
+//
+// lookupPrivate
+//
+
+ObjectPtr lookupPrivate(ModulePtr module, IdentifierPtr name) {
+retry:
+    llvm::StringMap<ImportSet>::const_iterator i =
+        module->allSymbols.find(name->str);
+    if ((i == module->allSymbols.end()) || (i->second.empty())) {
+        if (!module->allSymbolsLoaded) {
+            getAllSymbols(module);
+            module->allSymbolsLoaded = true;
+            goto retry;
         }
-        return *objs.begin();
+        ModulePtr prelude = preludeModule();
+        if (module == prelude)
+            return nullptr;
+        else
+            return lookupPublic(prelude, name);
     }
+    const ImportSet &objs = i->second;
+    if (objs.size() > 1) {
+        ambiguousImportError(name, objs);
+    }
+    return *objs.begin();
+}
 
-    ObjectPtr safeLookupPublic(ModulePtr module, IdentifierPtr name) {
-        ObjectPtr x = lookupPublic(module, name);
-        if (!x)
-            undefinedNameError(name);
-        return x;
+//
+// lookupPublic, safeLookupPublic
+//
+
+ObjectPtr lookupPublic(ModulePtr module, IdentifierPtr name) {
+retry:
+    llvm::StringMap<ImportSet>::const_iterator i =
+        module->publicSymbols.find(name->str);
+    if ((i == module->publicSymbols.end()) || (i->second.empty())) {
+        if (!module->publicSymbolsLoaded) {
+            getPublicSymbols(module);
+            module->publicSymbolsLoaded = true;
+            goto retry;
+        }
+        return nullptr;
     }
-    
-    //
-    // addLocal, safeLookupEnv
-    //
-
-    void addLocal(EnvPtr env, IdentifierPtr name, ObjectPtr value) {
-        MapIter i = env->entries.find(name->str);
-        if (i != env->entries.end())
-            error(name, "duplicate name: " + name->str);
-        env->entries[name->str] = value;
+    const ImportSet &objs = i->second;
+    if (objs.size() > 1) {
+        ambiguousImportError(name, objs);
     }
+    return *objs.begin();
+}
 
-    ObjectPtr lookupEnv(EnvPtr env, IdentifierPtr name) {
-        MapIter i = env->entries.find(name->str);
-        if (i != env->entries.end())
-            return i->second;
-        if (env->parent.ptr()) {
-            switch (env->parent->objKind) {
-                case ENV: {
-                    Env *y = (Env *) env->parent.ptr();
-                    return lookupEnv(y, name);
-                }
-                case MODULE: {
-                    Module *y = (Module *) env->parent.ptr();
-                    ObjectPtr z = lookupPrivate(y, name);
-                    return z;
-                }
-                default:
-                    assert(false);
-                    return nullptr;
-            }
-        } else
-            return nullptr;
-    }
+ObjectPtr safeLookupPublic(ModulePtr module, IdentifierPtr name) {
+    ObjectPtr x = lookupPublic(module, name);
+    if (!x)
+        undefinedNameError(name);
+    return x;
+}
 
-    ObjectPtr safeLookupEnv(EnvPtr env, IdentifierPtr name) {
-        ObjectPtr obj = lookupEnv(env, name);
-        if (obj == nullptr)
-            undefinedNameError(name);
-        return obj;
-    }
+//
+// addLocal, safeLookupEnv
+//
+
+void addLocal(EnvPtr env, IdentifierPtr name, ObjectPtr value) {
+    MapIter i = env->entries.find(name->str);
+    if (i != env->entries.end())
+        error(name, "duplicate name: " + name->str);
+    env->entries[name->str] = value;
+}
 
-    ModulePtr safeLookupModule(EnvPtr env) {
+ObjectPtr lookupEnv(EnvPtr env, IdentifierPtr name) {
+    MapIter i = env->entries.find(name->str);
+    if (i != env->entries.end())
+        return i->second;
+    if (env->parent.ptr()) {
         switch (env->parent->objKind) {
-            case ENV: {
-                Env *parent = (Env *) env->parent.ptr();
-                return safeLookupModule(parent);
-            }
-            case MODULE: {
-                Module *module = (Module *) env->parent.ptr();
-                return module;
-            }
-            default:
-                assert(false);
-                return nullptr;
+        case ENV: {
+            Env *y = (Env *)env->parent.ptr();
+            return lookupEnv(y, name);
+        }
+        case MODULE: {
+            Module *y = (Module *)env->parent.ptr();
+            ObjectPtr z = lookupPrivate(y, name);
+            return z;
         }
+        default:
+            assert(false);
+        }
+    } else
+        return nullptr;
+}
+
+ObjectPtr safeLookupEnv(EnvPtr env, IdentifierPtr name) {
+    ObjectPtr obj = lookupEnv(env, name);
+    if (obj == nullptr)
+        undefinedNameError(name);
+    return obj;
+}
+
+ModulePtr safeLookupModule(EnvPtr env) {
+    switch (env->parent->objKind) {
+    case ENV: {
+        Env *parent = (Env *)env->parent.ptr();
+        return safeLookupModule(parent);
+    }
+    case MODULE: {
+        Module *module = (Module *)env->parent.ptr();
+        return module;
+    }
+    default:
+        assert(false);
+        return nullptr;
     }
+}
 
-    llvm::DINamespace lookupModuleDebugInfo(EnvPtr env) {
-        if (env == nullptr || env->parent == nullptr)
-            return llvm::DINamespace(nullptr);
+llvm::DINamespace *lookupModuleDebugInfo(EnvPtr env) {
+    if (env == nullptr || env->parent == nullptr)
+        return nullptr;
 
-        switch (env->parent->objKind) {
-            case ENV: {
-                Env *parent = (Env *) env->parent.ptr();
-                return lookupModuleDebugInfo(parent);
-            }
-            case MODULE: {
-                Module *module = (Module *) env->parent.ptr();
-                return module->getDebugInfo();
-            }
-            default:
-                return llvm::DINamespace(nullptr);
-        }
+    switch (env->parent->objKind) {
+    case ENV: {
+        Env *parent = (Env *)env->parent.ptr();
+        return lookupModuleDebugInfo(parent);
+    }
+    case MODULE: {
+        Module *module = (Module *)env->parent.ptr();
+        return module->getDebugInfo();
+    }
+    default:
+        return nullptr;
+    }
+}
+
+//
+// lookupEnvEx
+//
+
+ObjectPtr lookupEnvEx(EnvPtr env, IdentifierPtr name, EnvPtr nonLocalEnv,
+                      bool &isNonLocal, bool &isGlobal) {
+    if (nonLocalEnv == env)
+        nonLocalEnv = nullptr;
+
+    MapIter i = env->entries.find(name->str);
+    if (i != env->entries.end()) {
+        if (!nonLocalEnv)
+            isNonLocal = true;
+        else
+            isNonLocal = false;
+        isGlobal = false;
+        return i->second;
     }
 
-    //
-    // lookupEnvEx
-    //
-
-    ObjectPtr lookupEnvEx(EnvPtr env, IdentifierPtr name,
-                          EnvPtr nonLocalEnv, bool &isNonLocal,
-                          bool &isGlobal) {
-        if (nonLocalEnv == env)
-            nonLocalEnv = nullptr;
-
-        MapIter i = env->entries.find(name->str);
-        if (i != env->entries.end()) {
-            if (!nonLocalEnv)
-                isNonLocal = true;
-            else
-                isNonLocal = false;
-            isGlobal = false;
-            return i->second;
-        }
+    if (!env->parent) {
+        undefinedNameError(name);
+    }
 
-        if (!env->parent) {
+    switch (env->parent->objKind) {
+    case ENV: {
+        Env *y = (Env *)env->parent.ptr();
+        return lookupEnvEx(y, name, nonLocalEnv, isNonLocal, isGlobal);
+    }
+    case MODULE: {
+        Module *y = (Module *)env->parent.ptr();
+        ObjectPtr z = lookupPrivate(y, name);
+        if (!z)
             undefinedNameError(name);
-        }
-
-        switch (env->parent->objKind) {
-            case ENV: {
-                Env *y = (Env *) env->parent.ptr();
-                return lookupEnvEx(y, name, nonLocalEnv, isNonLocal, isGlobal);
-            }
-            case MODULE: {
-                Module *y = (Module *) env->parent.ptr();
-                ObjectPtr z = lookupPrivate(y, name);
-                if (!z)
-                    undefinedNameError(name);
-                isNonLocal = true;
-                isGlobal = true;
-                return z;
-            }
-            default:
-                assert(false);
-                return nullptr;
-        }
+        isNonLocal = true;
+        isGlobal = true;
+        return z;
     }
+    default:
+        assert(false);
+    }
+}
 
-    //
-    // foreignExpr
-    //
+//
+// foreignExpr
+//
 
-    ExprPtr foreignExpr(EnvPtr env, ExprPtr expr) {
-        if (expr->exprKind == UNPACK) {
-            Unpack *y = (Unpack *) expr.ptr();
-            return new Unpack(foreignExpr(env, y->expr));
-        }
-        return new ForeignExpr(env, expr);
+ExprPtr foreignExpr(EnvPtr env, ExprPtr expr) {
+    if (expr->exprKind == UNPACK) {
+        Unpack *y = (Unpack *)expr.ptr();
+        return new Unpack(foreignExpr(env, y->expr));
     }
+    return new ForeignExpr(env, expr);
+}
 
-    //
-    // lookupCallByNameExprHead
-    //
+//
+// lookupCallByNameExprHead
+//
 
-    ExprPtr lookupCallByNameExprHead(EnvPtr env) {
-        if (env->callByNameExprHead.ptr())
-            return env->callByNameExprHead;
+ExprPtr lookupCallByNameExprHead(EnvPtr env) {
+    if (env->callByNameExprHead.ptr())
+        return env->callByNameExprHead;
 
-        if (env->parent.ptr()) {
-            switch (env->parent->objKind) {
-                case ENV: {
-                    Env *p = (Env *) env->parent.ptr();
-                    return lookupCallByNameExprHead(p);
-                }
-                default: {
-                    return ExprPtr();
-                }
-            }
+    if (env->parent.ptr()) {
+        switch (env->parent->objKind) {
+        case ENV: {
+            Env *p = (Env *)env->parent.ptr();
+            return lookupCallByNameExprHead(p);
+        }
+        default: {
+            return ExprPtr();
+        }
         }
-
-        assert(false);
-        return nullptr;
     }
 
-    //
-    // safeLookupCallByNameLocation
-    //
+    assert(false);
+    return nullptr;
+}
 
-    Location safeLookupCallByNameLocation(EnvPtr env) {
-        ExprPtr head = lookupCallByNameExprHead(env);
-        if (head.ptr() == 0) {
-            error("__FILE__, __LINE__, and __COLUMN__ are only allowed in an alias function");
-        }
-        return head->location;
+//
+// safeLookupCallByNameLocation
+//
+
+Location safeLookupCallByNameLocation(EnvPtr env) {
+    ExprPtr head = lookupCallByNameExprHead(env);
+    if (head.ptr() == 0) {
+        error("__FILE__, __LINE__, and __COLUMN__ are only allowed in an alias "
+              "function");
     }
+    return head->location;
+}
 
-    bool lookupExceptionAvailable(const Env *env) {
-        if (env->exceptionAvailable)
-            return true;
+bool lookupExceptionAvailable(const Env *env) {
+    if (env->exceptionAvailable)
+        return true;
 
-        if (env->parent.ptr() && env->parent->objKind == ENV)
-            return lookupExceptionAvailable((const Env *) env->parent.ptr());
+    if (env->parent.ptr() && env->parent->objKind == ENV)
+        return lookupExceptionAvailable((const Env *)env->parent.ptr());
 
-        return false;
-    }
+    return false;
 }
+} // namespace clay
diff --git a/compiler/env.hpp b/compiler/env.hpp
index 776720b7..cfdbd4d3 100644
--- a/compiler/env.hpp
+++ b/compiler/env.hpp
@@ -3,29 +3,26 @@
 #include "clay.hpp"
 
 namespace clay {
-    void addGlobal(ModulePtr module,
-                   IdentifierPtr name,
-                   Visibility visibility,
-                   ObjectPtr value);
+void addGlobal(ModulePtr module, IdentifierPtr name, Visibility visibility,
+               ObjectPtr value);
 
-    ObjectPtr lookupPrivate(ModulePtr module, IdentifierPtr name);
-    ObjectPtr lookupPublic(ModulePtr module, IdentifierPtr name);
-    ObjectPtr safeLookupPublic(ModulePtr module, IdentifierPtr name);
+ObjectPtr lookupPrivate(ModulePtr module, IdentifierPtr name);
+ObjectPtr lookupPublic(ModulePtr module, IdentifierPtr name);
+ObjectPtr safeLookupPublic(ModulePtr module, IdentifierPtr name);
 
-    void addLocal(EnvPtr env, IdentifierPtr name, ObjectPtr value);
-    ObjectPtr lookupEnv(EnvPtr env, IdentifierPtr name);
-    ObjectPtr safeLookupEnv(EnvPtr env, IdentifierPtr name);
-    ModulePtr safeLookupModule(EnvPtr env);
-    llvm::DINamespace lookupModuleDebugInfo(EnvPtr env);
+void addLocal(EnvPtr env, IdentifierPtr name, ObjectPtr value);
+ObjectPtr lookupEnv(EnvPtr env, IdentifierPtr name);
+ObjectPtr safeLookupEnv(EnvPtr env, IdentifierPtr name);
+ModulePtr safeLookupModule(EnvPtr env);
+llvm::DINamespace *lookupModuleDebugInfo(EnvPtr env);
 
-    ObjectPtr lookupEnvEx(EnvPtr env, IdentifierPtr name,
-                          EnvPtr nonLocalEnv, bool &isNonLocal,
-                          bool &isGlobal);
+ObjectPtr lookupEnvEx(EnvPtr env, IdentifierPtr name, EnvPtr nonLocalEnv,
+                      bool &isNonLocal, bool &isGlobal);
 
-    ExprPtr foreignExpr(EnvPtr env, ExprPtr expr);
+ExprPtr foreignExpr(EnvPtr env, ExprPtr expr);
 
-    ExprPtr lookupCallByNameExprHead(EnvPtr env);
-    Location safeLookupCallByNameLocation(EnvPtr env);
+ExprPtr lookupCallByNameExprHead(EnvPtr env);
+Location safeLookupCallByNameLocation(EnvPtr env);
 
-    bool lookupExceptionAvailable(const Env *env);
+bool lookupExceptionAvailable(const Env *env);
 } // namespace clay
diff --git a/compiler/error.cpp b/compiler/error.cpp
index 35e4e592..da2127ea 100644
--- a/compiler/error.cpp
+++ b/compiler/error.cpp
@@ -1,492 +1,488 @@
+#include "error.hpp"
 #include "clay.hpp"
-#include "evaluator.hpp"
 #include "codegen.hpp"
-#include "matchinvoke.hpp"
+#include "evaluator.hpp"
 #include "invoketables.hpp"
-#include "error.hpp"
+#include "matchinvoke.hpp"
 #include "printer.hpp"
 
 #include <cstdarg>
 
 namespace clay {
-    bool shouldPrintFullMatchErrors;
-    set<pair<string, string> > logMatchSymbols;
+bool shouldPrintFullMatchErrors;
+set<pair<string, string>> logMatchSymbols;
 
-    //
-    // invoke stack - a compilation call stack
-    //
+//
+// invoke stack - a compilation call stack
+//
 
-    static vector<CompileContextEntry> contextStack;
+static vector<CompileContextEntry> contextStack;
 
-    static constexpr unsigned RECURSION_WARNING_LEVEL = 1000;
+static constexpr unsigned RECURSION_WARNING_LEVEL = 1000;
 
-    void pushCompileContext(const ObjectPtr &obj) {
-        if (contextStack.size() >= RECURSION_WARNING_LEVEL)
-            warning("potential runaway recursion");
-        if (!contextStack.empty())
-            contextStack.back().location = topLocation();
-        contextStack.emplace_back(obj);
-    }
+void pushCompileContext(const ObjectPtr &obj) {
+    if (contextStack.size() >= RECURSION_WARNING_LEVEL)
+        warning("potential runaway recursion");
+    if (!contextStack.empty())
+        contextStack.back().location = topLocation();
+    contextStack.emplace_back(obj);
+}
 
-    void pushCompileContext(const ObjectPtr &obj, const llvm::ArrayRef<ObjectPtr> params) {
-        if (contextStack.size() >= RECURSION_WARNING_LEVEL)
-            warning("potential runaway recursion");
-        if (!contextStack.empty())
-            contextStack.back().location = topLocation();
-        contextStack.emplace_back(obj, params);
-    }
+void pushCompileContext(const ObjectPtr &obj,
+                        const llvm::ArrayRef<ObjectPtr> params) {
+    if (contextStack.size() >= RECURSION_WARNING_LEVEL)
+        warning("potential runaway recursion");
+    if (!contextStack.empty())
+        contextStack.back().location = topLocation();
+    contextStack.emplace_back(obj, params);
+}
 
-    void pushCompileContext(ObjectPtr obj, llvm::ArrayRef<ObjectPtr> params, llvm::ArrayRef<unsigned> dispatchIndices) {
-        if (contextStack.size() >= RECURSION_WARNING_LEVEL)
-            warning("potential runaway recursion");
-        if (!contextStack.empty())
-            contextStack.back().location = topLocation();
-        contextStack.emplace_back(obj, params, dispatchIndices);
-    }
+void pushCompileContext(ObjectPtr obj, llvm::ArrayRef<ObjectPtr> params,
+                        llvm::ArrayRef<unsigned> dispatchIndices) {
+    if (contextStack.size() >= RECURSION_WARNING_LEVEL)
+        warning("potential runaway recursion");
+    if (!contextStack.empty())
+        contextStack.back().location = topLocation();
+    contextStack.emplace_back(obj, params, dispatchIndices);
+}
 
-    void popCompileContext() {
-        contextStack.pop_back();
-    }
+void popCompileContext() { contextStack.pop_back(); }
 
-    vector<CompileContextEntry> getCompileContext() {
-        return contextStack;
-    }
+vector<CompileContextEntry> getCompileContext() { return contextStack; }
 
-    void setCompileContext(llvm::ArrayRef<CompileContextEntry> x) {
-        contextStack = x;
-    }
+void setCompileContext(llvm::ArrayRef<CompileContextEntry> x) {
+    contextStack = x;
+}
 
-    CompileContextPusher::CompileContextPusher(ObjectPtr obj, llvm::ArrayRef<PVData> params,
-                                               llvm::ArrayRef<unsigned> dispatchIndices) {
-        vector<ObjectPtr> params2;
-        for (const auto & param : params) {
-            params2.emplace_back(param.type.ptr());
-        }
-        pushCompileContext(obj, params2, dispatchIndices);
+CompileContextPusher::CompileContextPusher(
+    ObjectPtr obj, llvm::ArrayRef<PVData> params,
+    llvm::ArrayRef<unsigned> dispatchIndices) {
+    vector<ObjectPtr> params2;
+    for (const auto &param : params) {
+        params2.emplace_back(param.type.ptr());
     }
+    pushCompileContext(obj, params2, dispatchIndices);
+}
 
-    //
-    // source location of the current item being processed
-    //
+//
+// source location of the current item being processed
+//
 
-    static vector<Location> errorLocations;
+static vector<Location> errorLocations;
 
-    void pushLocation(Location const &location) {
-        errorLocations.push_back(location);
-    }
+void pushLocation(Location const &location) {
+    errorLocations.push_back(location);
+}
 
-    void popLocation() {
-        errorLocations.pop_back();
-    }
+void popLocation() { errorLocations.pop_back(); }
 
-    Location topLocation() {
-        auto i = errorLocations.end();
-        auto begin = errorLocations.begin();
-        while (i != begin) {
-            --i;
-            if (i->ok()) return *i;
-        }
-        return {};
+Location topLocation() {
+    auto i = errorLocations.end();
+    auto begin = errorLocations.begin();
+    while (i != begin) {
+        --i;
+        if (i->ok())
+            return *i;
     }
+    return {};
+}
 
-    //
-    // DebugPrinter
-    //
-
-    static vector<ObjectPtr> debugStack;
-
-    int DebugPrinter::indent = 0;
+//
+// DebugPrinter
+//
 
-    DebugPrinter::DebugPrinter(ObjectPtr obj)
-        : obj(obj) {
-        for (int i = 0; i < indent; ++i)
-            llvm::outs() << ' ';
-        llvm::outs() << "BEGIN - " << obj << '\n';
-        ++indent;
-        debugStack.push_back(obj);
-    }
+static vector<ObjectPtr> debugStack;
 
-    DebugPrinter::~DebugPrinter() {
-        debugStack.pop_back();
-        --indent;
-        for (int i = 0; i < indent; ++i)
-            llvm::outs() << ' ';
-        llvm::outs() << "DONE - " << obj << '\n';
-    }
-
-    //
-    // report error
-    //
-
-    static void computeLineCol(Location const &location, unsigned &line, unsigned &column, unsigned &tabColumn) {
-        const char *p = location.source->data();
-        const char *end = p + location.offset;
-        line = column = tabColumn = 0;
-        for (; p != end; ++p) {
-            ++column;
-            ++tabColumn;
-            if (*p == '\n') {
-                ++line;
-                column = 0;
-                tabColumn = 0;
-            } else if (*p == '\t') {
-                tabColumn += 7;
-            }
-        }
-    }
+int DebugPrinter::indent = 0;
 
-    llvm::DIFile *getDebugLineCol(Location const &location, unsigned &line, unsigned &column) {
-        if (!location.ok()) {
-            line = 0;
-            column = 0;
-            return nullptr;
-        }
+DebugPrinter::DebugPrinter(ObjectPtr obj) : obj(obj) {
+    for (int i = 0; i < indent; ++i)
+        llvm::outs() << ' ';
+    llvm::outs() << "BEGIN - " << obj << '\n';
+    ++indent;
+    debugStack.push_back(obj);
+}
 
-        unsigned tabColumn;
-        computeLineCol(location, line, column, tabColumn);
-        line += 1;
-        column += 1;
-        return location.source->getDebugInfo();
-    }
+DebugPrinter::~DebugPrinter() {
+    debugStack.pop_back();
+    --indent;
+    for (int i = 0; i < indent; ++i)
+        llvm::outs() << ' ';
+    llvm::outs() << "DONE - " << obj << '\n';
+}
 
-    void getLineCol(Location const &location, unsigned &line, unsigned &column, unsigned &tabColumn) {
-        if (!location.ok()) {
-            line = 0;
+//
+// report error
+//
+
+static void computeLineCol(Location const &location, unsigned &line,
+                           unsigned &column, unsigned &tabColumn) {
+    const char *p = location.source->data();
+    const char *end = p + location.offset;
+    line = column = tabColumn = 0;
+    for (; p != end; ++p) {
+        ++column;
+        ++tabColumn;
+        if (*p == '\n') {
+            ++line;
             column = 0;
             tabColumn = 0;
-            return;
+        } else if (*p == '\t') {
+            tabColumn += 7;
         }
+    }
+}
 
-        computeLineCol(location, line, column, tabColumn);
+llvm::DIFile *getDebugLineCol(Location const &location, unsigned &line,
+                              unsigned &column) {
+    if (!location.ok()) {
+        line = 0;
+        column = 0;
+        return nullptr;
     }
 
-    static void splitLines(const SourcePtr &source, vector<string> &lines) {
-        lines.clear();
-        if (!source || source->data() == source->endData()) {
-            return;
-        }
-        const std::string_view sourceView(source->data(), source->endData() - source->data());
-        lines.emplace_back();
+    unsigned tabColumn;
+    computeLineCol(location, line, column, tabColumn);
+    line += 1;
+    column += 1;
+    return location.source->getDebugInfo();
+}
 
-        for (const char c : sourceView) {
-            lines.back().push_back(c);
-            if (c == '\n')
-                lines.emplace_back();
-        }
+void getLineCol(Location const &location, unsigned &line, unsigned &column,
+                unsigned &tabColumn) {
+    if (!location.ok()) {
+        line = 0;
+        column = 0;
+        tabColumn = 0;
+        return;
     }
 
-    static bool endsWithNewline(llvm::StringRef s) {
-        if (s.size() == 0) return false;
-        return s[s.size() - 1] == '\n';
+    computeLineCol(location, line, column, tabColumn);
+}
+
+static void splitLines(const SourcePtr &source, vector<string> &lines) {
+    lines.clear();
+    if (!source || source->data() == source->endData()) {
+        return;
     }
+    const std::string_view sourceView(source->data(),
+                                      source->endData() - source->data());
+    lines.emplace_back();
 
-    static void displayLocation(Location const &location, unsigned &line, unsigned &column) {
-        unsigned tabColumn;
-        getLineCol(location, line, column, tabColumn);
-        vector<string> lines;
-        splitLines(location.source, lines);
-        llvm::errs() << "###############################\n";
-        unsigned i = (line < 2) ? 0 : line - 2;
-        for (; i <= line + 2; ++i) {
-            if (i >= lines.size())
-                continue;
-            llvm::errs() << lines[i];
-            if (!endsWithNewline(lines[i]))
-                llvm::errs() << "\n";
-            if (i == line) {
-                for (unsigned j = 0; j < tabColumn; ++j)
-                    llvm::errs() << "-";
-                llvm::errs() << "^\n";
-            }
-        }
-        llvm::errs() << "###############################\n";
+    for (const char c : sourceView) {
+        lines.back().push_back(c);
+        if (c == '\n')
+            lines.emplace_back();
     }
+}
 
-    // This has to use stdio because it needs to be usable from the debugger
-    // and cerr or errs may be destroyed if there's a bug in global dtors
-    extern "C" void displayCompileContext() {
-        if (contextStack.empty())
-            return;
-        fprintf(stderr, "\ncompilation context: \n");
-        string buf;
-        llvm::raw_string_ostream errs(buf);
-        for (size_t i = contextStack.size(); i > 0; --i) {
-            ObjectPtr obj = contextStack[i - 1].callable;
-            llvm::ArrayRef<ObjectPtr> params = contextStack[i - 1].params;
-
-            if (i < contextStack.size() && contextStack[i - 1].location.ok()) {
-                errs << "  ";
-                printFileLineCol(errs, contextStack[i - 1].location);
-                errs << ":\n";
-            }
+static bool endsWithNewline(llvm::StringRef s) {
+    if (s.size() == 0)
+        return false;
+    return s[s.size() - 1] == '\n';
+}
 
-            errs << "    ";
-            if (obj->objKind == GLOBAL_VARIABLE) {
-                errs << "global ";
-                printName(errs, obj);
-                if (!params.empty()) {
-                    errs << "[";
-                    printNameList(errs, params);
-                    errs << "]";
-                }
-            } else {
-                printName(errs, obj);
-                if (contextStack[i - 1].hasParams) {
-                    errs << "(";
-                    printNameList(errs, params, contextStack[i - 1].dispatchIndices);
-                    errs << ")";
-                }
-            }
-            errs << "\n";
+static void displayLocation(Location const &location, unsigned &line,
+                            unsigned &column) {
+    unsigned tabColumn;
+    getLineCol(location, line, column, tabColumn);
+    vector<string> lines;
+    splitLines(location.source, lines);
+    llvm::errs() << "###############################\n";
+    unsigned i = (line < 2) ? 0 : line - 2;
+    for (; i <= line + 2; ++i) {
+        if (i >= lines.size())
+            continue;
+        llvm::errs() << lines[i];
+        if (!endsWithNewline(lines[i]))
+            llvm::errs() << "\n";
+        if (i == line) {
+            for (unsigned j = 0; j < tabColumn; ++j)
+                llvm::errs() << "-";
+            llvm::errs() << "^\n";
         }
-        fprintf(stderr, "%s", errs.str().c_str());
-        fflush(stderr);
     }
+    llvm::errs() << "###############################\n";
+}
 
-    static void displayDebugStack() {
-        if (debugStack.empty())
-            return;
-        llvm::errs() << "\ndebug stack:\n";
-        for (size_t i = debugStack.size(); i > 0; --i) {
-            llvm::errs() << "  " << debugStack[i - 1]->toString() << "\n";
+// This has to use stdio because it needs to be usable from the debugger
+// and cerr or errs may be destroyed if there's a bug in global dtors
+extern "C" void displayCompileContext() {
+    if (contextStack.empty())
+        return;
+    fprintf(stderr, "\ncompilation context: \n");
+    string buf;
+    llvm::raw_string_ostream errs(buf);
+    for (size_t i = contextStack.size(); i > 0; --i) {
+        ObjectPtr obj = contextStack[i - 1].callable;
+        llvm::ArrayRef<ObjectPtr> params = contextStack[i - 1].params;
+
+        if (i < contextStack.size() && contextStack[i - 1].location.ok()) {
+            errs << "  ";
+            printFileLineCol(errs, contextStack[i - 1].location);
+            errs << ":\n";
         }
-    }
 
-    void displayError(llvm::Twine const &msg, llvm::StringRef kind) {
-        string msgString = msg.str();
-        if (msgString.empty() || msgString[msgString.length() - 1] != '\n')
-            msgString += '\n';
-
-        Location location = topLocation();
-        if (location.ok()) {
-            unsigned line, column;
-            displayLocation(location, line, column);
-            llvm::errs() << location.source->fileName
-                    << '(' << line + 1 << ',' << column << "): " << kind << ": " << msgString;
-            llvm::errs().flush();
-            displayCompileContext();
-            displayDebugStack();
+        errs << "    ";
+        if (obj->objKind == GLOBAL_VARIABLE) {
+            errs << "global ";
+            printName(errs, obj);
+            if (!params.empty()) {
+                errs << "[";
+                printNameList(errs, params);
+                errs << "]";
+            }
         } else {
-            llvm::errs() << kind << ": " << msgString;
+            printName(errs, obj);
+            if (contextStack[i - 1].hasParams) {
+                errs << "(";
+                printNameList(errs, params,
+                              contextStack[i - 1].dispatchIndices);
+                errs << ")";
+            }
         }
+        errs << "\n";
     }
+    fprintf(stderr, "%s", errs.str().c_str());
+    fflush(stderr);
+}
 
-    void warning(llvm::Twine const &msg) {
-        displayError(msg, "warning");
-    }
-
-    void note(llvm::Twine const &msg) {
-        displayError(msg, "note");
+static void displayDebugStack() {
+    if (debugStack.empty())
+        return;
+    llvm::errs() << "\ndebug stack:\n";
+    for (size_t i = debugStack.size(); i > 0; --i) {
+        llvm::errs() << "  " << debugStack[i - 1]->toString() << "\n";
     }
+}
 
-    void error(llvm::Twine const &msg) {
-        displayError(msg, "error");
-        throw CompilerError();
+void displayError(llvm::Twine const &msg, llvm::StringRef kind) {
+    string msgString = msg.str();
+    if (msgString.empty() || msgString[msgString.length() - 1] != '\n')
+        msgString += '\n';
+
+    Location location = topLocation();
+    if (location.ok()) {
+        unsigned line, column;
+        displayLocation(location, line, column);
+        llvm::errs() << location.source->fileName << '(' << line + 1 << ','
+                     << column << "): " << kind << ": " << msgString;
+        llvm::errs().flush();
+        displayCompileContext();
+        displayDebugStack();
+    } else {
+        llvm::errs() << kind << ": " << msgString;
     }
+}
 
-    void error(Location const &location, llvm::Twine const &msg) {
-        if (location.ok())
-            pushLocation(location);
-        error(msg);
-    }
+void warning(llvm::Twine const &msg) { displayError(msg, "warning"); }
 
-    void fmtError(const char *fmt, ...) {
-        va_list ap;
-        char s[256];
-        va_start(ap, fmt);
-        vsnprintf(s, sizeof(s) - 1, fmt, ap);
-        va_end(ap);
-        error(s);
-    }
+void note(llvm::Twine const &msg) { displayError(msg, "note"); }
 
-    void argumentError(size_t index, llvm::StringRef msg) {
-        string buf;
-        llvm::raw_string_ostream sout(buf);
-        sout << "argument " << (index + 1) << ": " << msg;
-        error(sout.str());
-    }
+void error(llvm::Twine const &msg) {
+    displayError(msg, "error");
+    throw CompilerError();
+}
 
-    static const char *valuesStr(size_t n) {
-        return (n == 1) ? "value" : "values";
-    }
+void error(Location const &location, llvm::Twine const &msg) {
+    if (location.ok())
+        pushLocation(location);
+    error(msg);
+}
 
-    void arityError(size_t expected, size_t received) {
-        string buf;
-        llvm::raw_string_ostream sout(buf);
-        sout << "expected " << expected << " " << valuesStr(expected);
-        sout << ", but received " << received << " " << valuesStr(received);
-        error(sout.str());
-    }
+void fmtError(const char *fmt, ...) {
+    va_list ap;
+    char s[256];
+    va_start(ap, fmt);
+    vsnprintf(s, sizeof(s) - 1, fmt, ap);
+    va_end(ap);
+    error(s);
+}
 
-    void arityError2(size_t minExpected, size_t received) {
-        string buf;
-        llvm::raw_string_ostream sout(buf);
-        sout << "expected at least " << minExpected
-                << " " << valuesStr(minExpected);
-        sout << ", but received " << received << " " << valuesStr(received);
-        error(sout.str());
-    }
+void argumentError(size_t index, llvm::StringRef msg) {
+    string buf;
+    llvm::raw_string_ostream sout(buf);
+    sout << "argument " << (index + 1) << ": " << msg;
+    error(sout.str());
+}
 
-    void ensureArity(const MultiStaticPtr &args, size_t size) {
-        if (args->size() != size)
-            arityError(size, args->size());
-    }
+static const char *valuesStr(size_t n) { return (n == 1) ? "value" : "values"; }
 
-    void ensureArity(const MultiEValuePtr &args, size_t size) {
-        if (args->size() != size)
-            arityError(size, args->size());
-    }
+void arityError(size_t expected, size_t received) {
+    string buf;
+    llvm::raw_string_ostream sout(buf);
+    sout << "expected " << expected << " " << valuesStr(expected);
+    sout << ", but received " << received << " " << valuesStr(received);
+    error(sout.str());
+}
 
-    void ensureArity(const MultiPValuePtr &args, size_t size) {
-        if (args->size() != size)
-            arityError(size, args->size());
-    }
+void arityError2(size_t minExpected, size_t received) {
+    string buf;
+    llvm::raw_string_ostream sout(buf);
+    sout << "expected at least " << minExpected << " "
+         << valuesStr(minExpected);
+    sout << ", but received " << received << " " << valuesStr(received);
+    error(sout.str());
+}
 
-    void ensureArity(const MultiCValuePtr &args, size_t size) {
-        if (args->size() != size)
-            arityError(size, args->size());
-    }
+void ensureArity(const MultiStaticPtr &args, size_t size) {
+    if (args->size() != size)
+        arityError(size, args->size());
+}
 
-    void arityMismatchError(size_t leftArity, size_t rightArity, bool hasVarArg) {
-        string buf;
-        llvm::raw_string_ostream sout(buf);
-        if (hasVarArg)
-            sout << "left side takes " << leftArity << " or more " << valuesStr(leftArity);
-        else
-            sout << "left side has " << leftArity << " " << valuesStr(leftArity);
-        sout << ", but right side has " << rightArity
-                << " " << valuesStr(rightArity);
-        error(sout.str());
-    }
+void ensureArity(const MultiEValuePtr &args, size_t size) {
+    if (args->size() != size)
+        arityError(size, args->size());
+}
 
-    static string typeErrorMessage(llvm::StringRef expected,
-                                   const TypePtr &receivedType) {
-        string buf;
-        llvm::raw_string_ostream sout(buf);
-        sout << "expected " << expected << ", "
-                << "but received " << receivedType->toString() << " type";
-        return sout.str();
-    }
+void ensureArity(const MultiPValuePtr &args, size_t size) {
+    if (args->size() != size)
+        arityError(size, args->size());
+}
 
-    static string typeErrorMessage(const TypePtr &expectedType,
-                                   const TypePtr &receivedType) {
-        string buf;
-        llvm::raw_string_ostream sout(buf);
-        sout << expectedType->toString() << " type";
-        return typeErrorMessage(sout.str(), receivedType);
-    }
+void ensureArity(const MultiCValuePtr &args, size_t size) {
+    if (args->size() != size)
+        arityError(size, args->size());
+}
 
-    void typeError(const llvm::StringRef expected, const TypePtr &receivedType) {
-        error(typeErrorMessage(expected, receivedType));
-    }
+void arityMismatchError(size_t leftArity, size_t rightArity, bool hasVarArg) {
+    string buf;
+    llvm::raw_string_ostream sout(buf);
+    if (hasVarArg)
+        sout << "left side takes " << leftArity << " or more "
+             << valuesStr(leftArity);
+    else
+        sout << "left side has " << leftArity << " " << valuesStr(leftArity);
+    sout << ", but right side has " << rightArity << " "
+         << valuesStr(rightArity);
+    error(sout.str());
+}
 
-    void typeError(const TypePtr &expectedType, const TypePtr &receivedType) {
-        error(typeErrorMessage(expectedType, receivedType));
-    }
+static string typeErrorMessage(llvm::StringRef expected,
+                               const TypePtr &receivedType) {
+    string buf;
+    llvm::raw_string_ostream sout(buf);
+    sout << "expected " << expected << ", "
+         << "but received " << receivedType->toString() << " type";
+    return sout.str();
+}
 
-    void argumentTypeError(const unsigned index,
-                           const llvm::StringRef expected,
-                           const TypePtr &receivedType) {
-        argumentError(index, typeErrorMessage(expected, receivedType));
-    }
+static string typeErrorMessage(const TypePtr &expectedType,
+                               const TypePtr &receivedType) {
+    string buf;
+    llvm::raw_string_ostream sout(buf);
+    sout << expectedType->toString() << " type";
+    return typeErrorMessage(sout.str(), receivedType);
+}
 
-    void argumentTypeError(const unsigned index,
-                           const TypePtr &expectedType,
-                           const TypePtr &receivedType) {
-        argumentError(index, typeErrorMessage(expectedType, receivedType));
-    }
+void typeError(const llvm::StringRef expected, const TypePtr &receivedType) {
+    error(typeErrorMessage(expected, receivedType));
+}
 
-    void indexRangeError(const llvm::StringRef kind,
-                         const size_t value,
-                         const size_t maxValue) {
-        string buf;
-        llvm::raw_string_ostream sout(buf);
-        sout << kind << " " << value << " is out of range. ";
-        sout << "it should be less than " << maxValue;
-        error(sout.str());
-    }
+void typeError(const TypePtr &expectedType, const TypePtr &receivedType) {
+    error(typeErrorMessage(expectedType, receivedType));
+}
 
-    void argumentIndexRangeError(const unsigned index,
-                                 const llvm::StringRef kind,
-                                 const size_t value,
-                                 const size_t maxValue) {
-        string buf;
-        llvm::raw_string_ostream sout(buf);
-        sout << kind << " " << value << " is out of range. ";
-        sout << "it should be less than " << maxValue;
-        argumentError(index, sout.str());
-    }
+void argumentTypeError(const unsigned index, const llvm::StringRef expected,
+                       const TypePtr &receivedType) {
+    argumentError(index, typeErrorMessage(expected, receivedType));
+}
 
-    void invalidStaticObjectError(const ObjectPtr &obj) {
-        string buf;
-        llvm::raw_string_ostream sout(buf);
-        sout << "invalid static object: " << obj->toString();
-        error(sout.str());
-    }
+void argumentTypeError(const unsigned index, const TypePtr &expectedType,
+                       const TypePtr &receivedType) {
+    argumentError(index, typeErrorMessage(expectedType, receivedType));
+}
 
-    void argumentInvalidStaticObjectError(const unsigned index, const ObjectPtr &obj) {
-        string buf;
-        llvm::raw_string_ostream sout(buf);
-        sout << "invalid static object: " << obj->toString();
-        argumentError(index, sout.str());
-    }
+void indexRangeError(const llvm::StringRef kind, const size_t value,
+                     const size_t maxValue) {
+    string buf;
+    llvm::raw_string_ostream sout(buf);
+    sout << kind << " " << value << " is out of range. ";
+    sout << "it should be less than " << maxValue;
+    error(sout.str());
+}
 
-    void matchBindingError(MatchResultPtr const &result) {
-        string buf;
-        llvm::raw_string_ostream sout(buf);
-        printMatchError(sout, result);
-        error(sout.str());
-    }
+void argumentIndexRangeError(const unsigned index, const llvm::StringRef kind,
+                             const size_t value, const size_t maxValue) {
+    string buf;
+    llvm::raw_string_ostream sout(buf);
+    sout << kind << " " << value << " is out of range. ";
+    sout << "it should be less than " << maxValue;
+    argumentError(index, sout.str());
+}
 
-    static void matchFailureMessage(MatchFailureError const &err, string &outBuf) {
-        llvm::raw_string_ostream sout(outBuf);
-        int hiddenPatternOverloads = 0;
+void invalidStaticObjectError(const ObjectPtr &obj) {
+    string buf;
+    llvm::raw_string_ostream sout(buf);
+    sout << "invalid static object: " << obj->toString();
+    error(sout.str());
+}
 
-        for (const auto & failure : err.failures) {
-            OverloadPtr overload = failure.first;
-            if (!shouldPrintFullMatchErrors && overload->nameIsPattern) {
-                ++hiddenPatternOverloads;
-                continue;
-            }
-            sout << "\n    ";
-            Location location = overload->location;
-            unsigned line, column, tabColumn;
-            getLineCol(location, line, column, tabColumn);
-            sout << location.source->fileName.c_str()
-                    << "(" << line + 1 << "," << column << ")"
-                    << "\n        ";
-            printMatchError(sout, failure.second);
-        }
-        if (hiddenPatternOverloads > 0)
-            sout << "\n    " << hiddenPatternOverloads <<
-                    " universal overloads not shown (show with -full-match-errors option)";
-        sout.flush();
-    }
+void argumentInvalidStaticObjectError(const unsigned index,
+                                      const ObjectPtr &obj) {
+    string buf;
+    llvm::raw_string_ostream sout(buf);
+    sout << "invalid static object: " << obj->toString();
+    argumentError(index, sout.str());
+}
 
-    void matchFailureError(MatchFailureError const &err) {
-        string buf;
-        if (err.failedInterface)
-            buf = "call does not conform to function interface";
-        else if (err.ambiguousMatch)
-            buf = "call matches ambiguous overloads";
-        else
-            buf = "no matching overload found";
-
-        matchFailureMessage(err, buf);
-        error(buf);
-    }
+void matchBindingError(MatchResultPtr const &result) {
+    string buf;
+    llvm::raw_string_ostream sout(buf);
+    printMatchError(sout, result);
+    error(sout.str());
+}
 
-    void matchFailureLog(MatchFailureError const &err) {
-        if (err.failures.empty())
-            return;
-        string buf = "matched";
-        matchFailureMessage(err, buf);
-        note(buf);
-    }
+static void matchFailureMessage(MatchFailureError const &err, string &outBuf) {
+    llvm::raw_string_ostream sout(outBuf);
+    int hiddenPatternOverloads = 0;
 
-    void printFileLineCol(llvm::raw_ostream &out, Location const &location) {
+    for (const auto &failure : err.failures) {
+        OverloadPtr overload = failure.first;
+        if (!shouldPrintFullMatchErrors && overload->nameIsPattern) {
+            ++hiddenPatternOverloads;
+            continue;
+        }
+        sout << "\n    ";
+        Location location = overload->location;
         unsigned line, column, tabColumn;
         getLineCol(location, line, column, tabColumn);
-        out << location.source->fileName << "(" << line + 1 << "," << column << ")";
-    }
+        sout << location.source->fileName.c_str() << "(" << line + 1 << ","
+             << column << ")"
+             << "\n        ";
+        printMatchError(sout, failure.second);
+    }
+    if (hiddenPatternOverloads > 0)
+        sout << "\n    " << hiddenPatternOverloads
+             << " universal overloads not shown (show with -full-match-errors "
+                "option)";
+    sout.flush();
+}
+
+void matchFailureError(MatchFailureError const &err) {
+    string buf;
+    if (err.failedInterface)
+        buf = "call does not conform to function interface";
+    else if (err.ambiguousMatch)
+        buf = "call matches ambiguous overloads";
+    else
+        buf = "no matching overload found";
+
+    matchFailureMessage(err, buf);
+    error(buf);
+}
+
+void matchFailureLog(MatchFailureError const &err) {
+    if (err.failures.empty())
+        return;
+    string buf = "matched";
+    matchFailureMessage(err, buf);
+    note(buf);
+}
+
+void printFileLineCol(llvm::raw_ostream &out, Location const &location) {
+    unsigned line, column, tabColumn;
+    getLineCol(location, line, column, tabColumn);
+    out << location.source->fileName << "(" << line + 1 << "," << column << ")";
 }
+} // namespace clay
diff --git a/compiler/error.hpp b/compiler/error.hpp
index a08ed56f..e99594a2 100644
--- a/compiler/error.hpp
+++ b/compiler/error.hpp
@@ -12,115 +12,114 @@
 #endif
 
 namespace clay {
-    void error(llvm::Twine const &msg) CLAY_NORETURN;
-    void error(Location const &location, llvm::Twine const &msg) CLAY_NORETURN;
-
-    void warning(llvm::Twine const &msg);
-
-    void fmtError(const char *fmt, ...) CLAY_NORETURN;
-
-    template<class T>
-    void error(Pointer<T> context, llvm::Twine const &msg) CLAY_NORETURN;
-
-    template<class T>
-    void error(Pointer<T> context, llvm::Twine const &msg) {
-        if (context->location.ok())
-            pushLocation(context->location);
-        error(msg);
-    }
-
-    template<class T>
-    void error(T const *context, llvm::Twine const &msg) CLAY_NORETURN;
-
-    template<class T>
-    void error(T const *context, llvm::Twine const &msg) {
-        error(context->location, msg);
-    }
-
-    void argumentError(size_t index, llvm::StringRef msg) CLAY_NORETURN;
-
-    template<typename T>
-    void argumentError(size_t index, llvm::StringRef msg, const T &argument) CLAY_NORETURN;
-
-    template<typename T>
-    void argumentError(const size_t index, const llvm::StringRef msg, const T &argument) {
-        string buf;
-        llvm::raw_string_ostream sout(buf);
-        sout << "argument " << (index + 1) << ": " << msg << ", actual " << argument;
-        error(sout.str());
-    }
-
-    void arityError(size_t expected, size_t received) CLAY_NORETURN;
-    void arityError2(size_t minExpected, size_t received) CLAY_NORETURN;
-
-    template<class T>
-    void arityError(Pointer<T> context, size_t expected, size_t received) CLAY_NORETURN;
-
-    template<class T>
-    void arityError(Pointer<T> context, size_t expected, size_t received) {
-        if (context->location.ok())
-            pushLocation(context->location);
-        arityError(expected, received);
-    }
-
-    template<class T>
-    void arityError2(Pointer<T> context, size_t minExpected, size_t received) CLAY_NORETURN;
-
-    template<class T>
-    void arityError2(Pointer<T> context, size_t minExpected, size_t received) {
-        if (context->location.ok())
-            pushLocation(context->location);
-        arityError2(minExpected, received);
-    }
-
-    void ensureArity(const MultiStaticPtr &args, size_t size);
-    void ensureArity(const MultiEValuePtr &args, size_t size);
-    void ensureArity(const MultiPValuePtr &args, size_t size);
-    void ensureArity(const MultiCValuePtr &args, size_t size);
-
-    template<class T>
-    void ensureArity(T const &args, size_t size) {
-        if (args.size() != size)
-            arityError(size, args.size());
-    }
-
-    template<class T>
-    void ensureArity2(T const &args, size_t size, bool hasVarArgs) {
-        if (!hasVarArgs)
-            ensureArity(args, size);
-        else if (args.size() < size)
-            arityError2(size, args.size());
-    }
-
-    void arityMismatchError(size_t leftArity, size_t rightArity, bool hasVarArg) CLAY_NORETURN;
-
-    void typeError(llvm::StringRef expected, const TypePtr &receivedType) CLAY_NORETURN;
-    void typeError(const TypePtr &expectedType, const TypePtr &receivedType) CLAY_NORETURN;
-
-    void argumentTypeError(unsigned index,
-                           llvm::StringRef expected,
-                           const TypePtr &receivedType) CLAY_NORETURN;
-
-    void argumentTypeError(unsigned index,
-                           const TypePtr &expectedType,
-                           const TypePtr &receivedType) CLAY_NORETURN;
-
-    void indexRangeError(llvm::StringRef kind,
-                         size_t value,
-                         size_t maxValue) CLAY_NORETURN;
-
-    void argumentIndexRangeError(unsigned index,
-                                 llvm::StringRef kind,
-                                 size_t value,
-                                 size_t maxValue) CLAY_NORETURN;
-
-    extern bool shouldPrintFullMatchErrors;
-    extern set<pair<string, string> > logMatchSymbols;
-
-    void matchBindingError(MatchResultPtr const &result) CLAY_NORETURN;
-    void matchFailureLog(MatchFailureError const &err);
-    void matchFailureError(MatchFailureError const &err) CLAY_NORETURN;
-
-    class CompilerError : std::exception {
-    };
+void error(llvm::Twine const &msg) CLAY_NORETURN;
+void error(Location const &location, llvm::Twine const &msg) CLAY_NORETURN;
+
+void warning(llvm::Twine const &msg);
+
+void fmtError(const char *fmt, ...) CLAY_NORETURN;
+
+template <class T>
+void error(Pointer<T> context, llvm::Twine const &msg) CLAY_NORETURN;
+
+template <class T> void error(Pointer<T> context, llvm::Twine const &msg) {
+    if (context->location.ok())
+        pushLocation(context->location);
+    error(msg);
+}
+
+template <class T>
+void error(T const *context, llvm::Twine const &msg) CLAY_NORETURN;
+
+template <class T> void error(T const *context, llvm::Twine const &msg) {
+    error(context->location, msg);
+}
+
+void argumentError(size_t index, llvm::StringRef msg) CLAY_NORETURN;
+
+template <typename T>
+void argumentError(size_t index, llvm::StringRef msg,
+                   const T &argument) CLAY_NORETURN;
+
+template <typename T>
+void argumentError(const size_t index, const llvm::StringRef msg,
+                   const T &argument) {
+    string buf;
+    llvm::raw_string_ostream sout(buf);
+    sout << "argument " << (index + 1) << ": " << msg << ", actual "
+         << argument;
+    error(sout.str());
+}
+
+void arityError(size_t expected, size_t received) CLAY_NORETURN;
+void arityError2(size_t minExpected, size_t received) CLAY_NORETURN;
+
+template <class T>
+void arityError(Pointer<T> context, size_t expected,
+                size_t received) CLAY_NORETURN;
+
+template <class T>
+void arityError(Pointer<T> context, size_t expected, size_t received) {
+    if (context->location.ok())
+        pushLocation(context->location);
+    arityError(expected, received);
+}
+
+template <class T>
+void arityError2(Pointer<T> context, size_t minExpected,
+                 size_t received) CLAY_NORETURN;
+
+template <class T>
+void arityError2(Pointer<T> context, size_t minExpected, size_t received) {
+    if (context->location.ok())
+        pushLocation(context->location);
+    arityError2(minExpected, received);
+}
+
+void ensureArity(const MultiStaticPtr &args, size_t size);
+void ensureArity(const MultiEValuePtr &args, size_t size);
+void ensureArity(const MultiPValuePtr &args, size_t size);
+void ensureArity(const MultiCValuePtr &args, size_t size);
+
+template <class T> void ensureArity(T const &args, size_t size) {
+    if (args.size() != size)
+        arityError(size, args.size());
+}
+
+template <class T>
+void ensureArity2(T const &args, size_t size, bool hasVarArgs) {
+    if (!hasVarArgs)
+        ensureArity(args, size);
+    else if (args.size() < size)
+        arityError2(size, args.size());
 }
+
+void arityMismatchError(size_t leftArity, size_t rightArity,
+                        bool hasVarArg) CLAY_NORETURN;
+
+void typeError(llvm::StringRef expected,
+               const TypePtr &receivedType) CLAY_NORETURN;
+void typeError(const TypePtr &expectedType,
+               const TypePtr &receivedType) CLAY_NORETURN;
+
+void argumentTypeError(unsigned index, llvm::StringRef expected,
+                       const TypePtr &receivedType) CLAY_NORETURN;
+
+void argumentTypeError(unsigned index, const TypePtr &expectedType,
+                       const TypePtr &receivedType) CLAY_NORETURN;
+
+void indexRangeError(llvm::StringRef kind, size_t value,
+                     size_t maxValue) CLAY_NORETURN;
+
+void argumentIndexRangeError(unsigned index, llvm::StringRef kind, size_t value,
+                             size_t maxValue) CLAY_NORETURN;
+
+extern bool shouldPrintFullMatchErrors;
+extern set<pair<string, string>> logMatchSymbols;
+
+void matchBindingError(MatchResultPtr const &result) CLAY_NORETURN;
+void matchFailureLog(MatchFailureError const &err);
+void matchFailureError(MatchFailureError const &err) CLAY_NORETURN;
+
+class CompilerError : std::exception {};
+} // namespace clay
diff --git a/compiler/evaluator.cpp b/compiler/evaluator.cpp
index 1603c108..76cf5135 100644
--- a/compiler/evaluator.cpp
+++ b/compiler/evaluator.cpp
@@ -1,2407 +1,2357 @@
-#include "clay.hpp"
 #include "evaluator.hpp"
-#include "codegen.hpp"
-#include "loader.hpp"
-#include "operators.hpp"
-#include "lambdas.hpp"
 #include "analyzer.hpp"
-#include "invoketables.hpp"
-#include "literals.hpp"
-#include "desugar.hpp"
+#include "checkedcast.hpp"
+#include "clay.hpp"
+#include "codegen.hpp"
 #include "constructors.hpp"
+#include "desugar.hpp"
 #include "env.hpp"
-#include "objects.hpp"
 #include "error.hpp"
-#include "checkedcast.hpp"
 #include "evaluator_op.hpp"
+#include "invoketables.hpp"
+#include "lambdas.hpp"
+#include "literals.hpp"
+#include "loader.hpp"
+#include "objects.hpp"
+#include "operators.hpp"
 
 #pragma clang diagnostic ignored "-Wcovered-switch-default"
 
 namespace clay {
-    MultiEValuePtr evalMultiArgsAsRef(ExprListPtr exprs, EnvPtr env);
-    MultiEValuePtr evalArgExprAsRef(ExprPtr x, EnvPtr env);
-
-    EValuePtr evalForwardOneAsRef(ExprPtr expr, EnvPtr env);
-    MultiEValuePtr evalForwardMultiAsRef(ExprListPtr exprs, EnvPtr env);
-    MultiEValuePtr evalForwardExprAsRef(ExprPtr expr, EnvPtr env);
-
-    MultiEValuePtr evalMultiAsRef(ExprListPtr exprs, EnvPtr env);
-    MultiEValuePtr evalExprAsRef(ExprPtr expr, EnvPtr env);
-
-    void evalOneInto(ExprPtr expr, EnvPtr env, EValuePtr out);
-    void evalMultiInto(ExprListPtr exprs, EnvPtr env, MultiEValuePtr out, size_t wantCount);
-    void evalExprInto(ExprPtr expr, EnvPtr env, MultiEValuePtr out);
-
-    void evalMulti(ExprListPtr exprs, EnvPtr env, MultiEValuePtr out, size_t wantCount);
-    void evalOne(ExprPtr expr, EnvPtr env, EValuePtr out);
-    void evalExpr(ExprPtr expr, EnvPtr env, MultiEValuePtr out);
-    void evalStaticObject(ObjectPtr x, MultiEValuePtr out);
-    void evalValueHolder(ValueHolderPtr x, MultiEValuePtr out);
-    void evalIndexingExpr(ExprPtr indexable,
-                          ExprListPtr args,
-                          EnvPtr env,
-                          MultiEValuePtr out);
-    void evalAliasIndexing(GlobalAliasPtr x,
-                           ExprListPtr args,
-                           EnvPtr env,
-                           MultiEValuePtr out);
-    void evalCallExpr(ExprPtr callable,
-                      ExprListPtr args,
-                      EnvPtr env,
-                      MultiEValuePtr out);
-    void evalDispatch(ObjectPtr obj,
-                      MultiEValuePtr args,
-                      MultiPValuePtr pvArgs,
-                      llvm::ArrayRef<unsigned> dispatchIndices,
+MultiEValuePtr evalMultiArgsAsRef(ExprListPtr exprs, EnvPtr env);
+MultiEValuePtr evalArgExprAsRef(ExprPtr x, EnvPtr env);
+
+EValuePtr evalForwardOneAsRef(ExprPtr expr, EnvPtr env);
+MultiEValuePtr evalForwardMultiAsRef(ExprListPtr exprs, EnvPtr env);
+MultiEValuePtr evalForwardExprAsRef(ExprPtr expr, EnvPtr env);
+
+MultiEValuePtr evalMultiAsRef(ExprListPtr exprs, EnvPtr env);
+MultiEValuePtr evalExprAsRef(ExprPtr expr, EnvPtr env);
+
+void evalOneInto(ExprPtr expr, EnvPtr env, EValuePtr out);
+void evalMultiInto(ExprListPtr exprs, EnvPtr env, MultiEValuePtr out,
+                   size_t wantCount);
+void evalExprInto(ExprPtr expr, EnvPtr env, MultiEValuePtr out);
+
+void evalMulti(ExprListPtr exprs, EnvPtr env, MultiEValuePtr out,
+               size_t wantCount);
+void evalOne(ExprPtr expr, EnvPtr env, EValuePtr out);
+void evalExpr(ExprPtr expr, EnvPtr env, MultiEValuePtr out);
+void evalStaticObject(ObjectPtr x, MultiEValuePtr out);
+void evalValueHolder(ValueHolderPtr x, MultiEValuePtr out);
+void evalIndexingExpr(ExprPtr indexable, ExprListPtr args, EnvPtr env,
                       MultiEValuePtr out);
-    void evalCallValue(EValuePtr callable,
-                       MultiEValuePtr args,
+void evalAliasIndexing(GlobalAliasPtr x, ExprListPtr args, EnvPtr env,
                        MultiEValuePtr out);
-    void evalCallValue(EValuePtr callable,
-                       MultiEValuePtr args,
-                       MultiPValuePtr pvArgs,
-                       MultiEValuePtr out);
-    void evalCallPointer(EValuePtr x,
-                         MultiEValuePtr args,
-                         MultiEValuePtr out);
-    void evalCallCode(InvokeEntry *entry,
-                      MultiEValuePtr args,
-                      MultiEValuePtr out);
-    void evalCallCompiledCode(InvokeEntry *entry,
-                              MultiEValuePtr args,
-                              MultiEValuePtr out);
-    void evalCallByName(InvokeEntry *entry,
-                        ExprPtr callable,
-                        ExprListPtr args,
-                        EnvPtr env,
-                        MultiEValuePtr out);
+void evalCallExpr(ExprPtr callable, ExprListPtr args, EnvPtr env,
+                  MultiEValuePtr out);
+void evalDispatch(ObjectPtr obj, MultiEValuePtr args, MultiPValuePtr pvArgs,
+                  llvm::ArrayRef<unsigned> dispatchIndices, MultiEValuePtr out);
+void evalCallValue(EValuePtr callable, MultiEValuePtr args, MultiEValuePtr out);
+void evalCallValue(EValuePtr callable, MultiEValuePtr args,
+                   MultiPValuePtr pvArgs, MultiEValuePtr out);
+void evalCallPointer(EValuePtr x, MultiEValuePtr args, MultiEValuePtr out);
+void evalCallCode(InvokeEntry *entry, MultiEValuePtr args, MultiEValuePtr out);
+void evalCallCompiledCode(InvokeEntry *entry, MultiEValuePtr args,
+                          MultiEValuePtr out);
+void evalCallByName(InvokeEntry *entry, ExprPtr callable, ExprListPtr args,
+                    EnvPtr env, MultiEValuePtr out);
 
-    enum TerminationKind {
-        TERMINATE_RETURN,
-        TERMINATE_BREAK,
-        TERMINATE_CONTINUE,
-        TERMINATE_GOTO
-    };
+enum TerminationKind {
+    TERMINATE_RETURN,
+    TERMINATE_BREAK,
+    TERMINATE_CONTINUE,
+    TERMINATE_GOTO
+};
 
-    struct Termination : public RefCounted {
-        TerminationKind terminationKind;
-        Location location;
+struct Termination : public RefCounted {
+    TerminationKind terminationKind;
+    Location location;
 
-        Termination(TerminationKind terminationKind, Location const &location)
-            : terminationKind(terminationKind),
-              location(location) {
-        }
-    };
+    Termination(TerminationKind terminationKind, Location const &location)
+        : terminationKind(terminationKind), location(location) {}
+};
 
-    typedef Pointer<Termination> TerminationPtr;
+typedef Pointer<Termination> TerminationPtr;
 
-    struct TerminateReturn : Termination {
-        TerminateReturn(Location const &location)
-            : Termination(TERMINATE_RETURN, location) {
-        }
-    };
+struct TerminateReturn : Termination {
+    TerminateReturn(Location const &location)
+        : Termination(TERMINATE_RETURN, location) {}
+};
 
-    struct TerminateBreak : Termination {
-        TerminateBreak(Location const &location)
-            : Termination(TERMINATE_BREAK, location) {
-        }
-    };
+struct TerminateBreak : Termination {
+    TerminateBreak(Location const &location)
+        : Termination(TERMINATE_BREAK, location) {}
+};
 
-    struct TerminateContinue : Termination {
-        TerminateContinue(Location const &location)
-            : Termination(TERMINATE_CONTINUE, location) {
-        }
-    };
+struct TerminateContinue : Termination {
+    TerminateContinue(Location const &location)
+        : Termination(TERMINATE_CONTINUE, location) {}
+};
 
-    struct TerminateGoto : Termination {
-        IdentifierPtr targetLabel;
+struct TerminateGoto : Termination {
+    IdentifierPtr targetLabel;
 
-        TerminateGoto(IdentifierPtr targetLabel, Location const &location)
-            : Termination(TERMINATE_GOTO, location),
-              targetLabel(targetLabel) {
-        }
-    };
+    TerminateGoto(IdentifierPtr targetLabel, Location const &location)
+        : Termination(TERMINATE_GOTO, location), targetLabel(targetLabel) {}
+};
 
-    struct LabelInfo {
-        EnvPtr env;
-        unsigned stackMarker;
-        unsigned blockPosition;
+struct LabelInfo {
+    EnvPtr env;
+    unsigned stackMarker;
+    unsigned blockPosition;
 
-        LabelInfo() {
-        }
+    LabelInfo() {}
 
-        LabelInfo(EnvPtr env, unsigned stackMarker, unsigned blockPosition)
-            : env(env), stackMarker(stackMarker), blockPosition(blockPosition) {
-        }
-    };
+    LabelInfo(EnvPtr env, unsigned stackMarker, unsigned blockPosition)
+        : env(env), stackMarker(stackMarker), blockPosition(blockPosition) {}
+};
 
-    struct EReturn {
-        bool byRef;
-        TypePtr type;
-        EValuePtr value;
+struct EReturn {
+    bool byRef;
+    TypePtr type;
+    EValuePtr value;
 
-        EReturn(bool byRef, TypePtr type, EValuePtr value)
-            : byRef(byRef), type(type), value(value) {
-        }
-    };
+    EReturn(bool byRef, TypePtr type, EValuePtr value)
+        : byRef(byRef), type(type), value(value) {}
+};
 
-    struct EvalContext : public RefCounted {
-        vector<EReturn> returns;
+struct EvalContext : public RefCounted {
+    vector<EReturn> returns;
 
-        EvalContext(llvm::ArrayRef<EReturn> returns)
-            : returns(returns) {
-        }
-    };
+    EvalContext(llvm::ArrayRef<EReturn> returns) : returns(returns) {}
+};
 
-    typedef Pointer<EvalContext> EvalContextPtr;
+typedef Pointer<EvalContext> EvalContextPtr;
 
-    TerminationPtr evalStatement(StatementPtr stmt,
-                                 EnvPtr env,
-                                 EvalContextPtr ctx);
+TerminationPtr evalStatement(StatementPtr stmt, EnvPtr env, EvalContextPtr ctx);
 
-    void evalCollectLabels(llvm::ArrayRef<StatementPtr> statements,
-                           unsigned startIndex,
-                           EnvPtr env,
-                           llvm::StringMap<LabelInfo> &labels);
+void evalCollectLabels(llvm::ArrayRef<StatementPtr> statements,
+                       unsigned startIndex, EnvPtr env,
+                       llvm::StringMap<LabelInfo> &labels);
 
-    EnvPtr evalBinding(BindingPtr x, EnvPtr env);
-    
-    //
-    // staticToType
-    //
+EnvPtr evalBinding(BindingPtr x, EnvPtr env);
 
-    bool staticToType(ObjectPtr x, TypePtr &out) {
-        if (x->objKind != TYPE)
-            return false;
-        out = (Type *) x.ptr();
-        return true;
-    }
+//
+// staticToType
+//
 
-    TypePtr staticToType(MultiStaticPtr x, size_t index) {
-        TypePtr out;
-        if (!staticToType(x->values[index], out))
-            argumentError(index, "expecting a type");
-        return out;
-    }
-    
-    //
-    // evaluator wrappers
-    //
+bool staticToType(ObjectPtr x, TypePtr &out) {
+    if (x->objKind != TYPE)
+        return false;
+    out = (Type *)x.ptr();
+    return true;
+}
+
+TypePtr staticToType(MultiStaticPtr x, size_t index) {
+    TypePtr out;
+    if (!staticToType(x->values[index], out))
+        argumentError(index, "expecting a type");
+    return out;
+}
 
-    void evaluateReturnSpecs(llvm::ArrayRef<ReturnSpecPtr> returnSpecs,
-                             ReturnSpecPtr varReturnSpec,
-                             EnvPtr env,
-                             vector<uint8_t> &returnIsRef,
-                             vector<TypePtr> &returnTypes) {
-        returnIsRef.clear();
-        returnTypes.clear();
-        for (size_t i = 0; i < returnSpecs.size(); ++i) {
-            ReturnSpecPtr x = returnSpecs[i];
-            TypePtr t = evaluateType(x->type, env);
+//
+// evaluator wrappers
+//
+
+void evaluateReturnSpecs(llvm::ArrayRef<ReturnSpecPtr> returnSpecs,
+                         ReturnSpecPtr varReturnSpec, EnvPtr env,
+                         vector<uint8_t> &returnIsRef,
+                         vector<TypePtr> &returnTypes) {
+    returnIsRef.clear();
+    returnTypes.clear();
+    for (size_t i = 0; i < returnSpecs.size(); ++i) {
+        ReturnSpecPtr x = returnSpecs[i];
+        TypePtr t = evaluateType(x->type, env);
+        bool isRef = unwrapByRef(t);
+        returnIsRef.push_back(isRef);
+        returnTypes.push_back(t);
+    }
+    if (varReturnSpec.ptr()) {
+        LocationContext loc(varReturnSpec->type->location);
+        MultiStaticPtr ms = evaluateExprStatic(varReturnSpec->type, env);
+        for (size_t i = 0; i < ms->size(); ++i) {
+            TypePtr t = staticToType(ms, i);
             bool isRef = unwrapByRef(t);
             returnIsRef.push_back(isRef);
             returnTypes.push_back(t);
         }
-        if (varReturnSpec.ptr()) {
-            LocationContext loc(varReturnSpec->type->location);
-            MultiStaticPtr ms = evaluateExprStatic(varReturnSpec->type, env);
-            for (size_t i = 0; i < ms->size(); ++i) {
-                TypePtr t = staticToType(ms, i);
-                bool isRef = unwrapByRef(t);
-                returnIsRef.push_back(isRef);
-                returnTypes.push_back(t);
-            }
-        }
     }
+}
 
-    MultiStaticPtr evaluateExprStatic(ExprPtr expr, EnvPtr env) {
-        AnalysisCachingDisabler disabler;
-        MultiPValuePtr mpv = safeAnalyzeExpr(expr, env);
-        vector<ValueHolderPtr> valueHolders;
-        MultiEValuePtr mev = new MultiEValue();
-        bool allStatic = true;
-        for (unsigned i = 0; i < mpv->size(); ++i) {
-            TypePtr t = mpv->values[i].type;
-            if (!isStaticOrTupleOfStatics(t))
-                allStatic = false;
-            ValueHolderPtr vh = new ValueHolder(t);
-            valueHolders.push_back(vh);
-            EValuePtr ev = new EValue(t, vh->buf);
-            mev->add(ev);
-        }
-        if (!allStatic) {
-            unsigned marker = evalMarkStack();
-            evalExprInto(expr, env, mev);
-            evalDestroyAndPopStack(marker);
-        }
-        MultiStaticPtr ms = new MultiStatic();
-        for (size_t i = 0; i < valueHolders.size(); ++i) {
-            Type *t = valueHolders[i]->type.ptr();
-            if (t->typeKind == STATIC_TYPE) {
-                StaticType *st = (StaticType *) t;
-                ms->add(st->obj);
-            } else {
-                ms->add(valueHolders[i].ptr());
-            }
+MultiStaticPtr evaluateExprStatic(ExprPtr expr, EnvPtr env) {
+    AnalysisCachingDisabler disabler;
+    MultiPValuePtr mpv = safeAnalyzeExpr(expr, env);
+    vector<ValueHolderPtr> valueHolders;
+    MultiEValuePtr mev = new MultiEValue();
+    bool allStatic = true;
+    for (unsigned i = 0; i < mpv->size(); ++i) {
+        TypePtr t = mpv->values[i].type;
+        if (!isStaticOrTupleOfStatics(t))
+            allStatic = false;
+        ValueHolderPtr vh = new ValueHolder(t);
+        valueHolders.push_back(vh);
+        EValuePtr ev = new EValue(t, vh->buf);
+        mev->add(ev);
+    }
+    if (!allStatic) {
+        unsigned marker = evalMarkStack();
+        evalExprInto(expr, env, mev);
+        evalDestroyAndPopStack(marker);
+    }
+    MultiStaticPtr ms = new MultiStatic();
+    for (size_t i = 0; i < valueHolders.size(); ++i) {
+        Type *t = valueHolders[i]->type.ptr();
+        if (t->typeKind == STATIC_TYPE) {
+            StaticType *st = (StaticType *)t;
+            ms->add(st->obj);
+        } else {
+            ms->add(valueHolders[i].ptr());
         }
-        return ms;
     }
+    return ms;
+}
 
-    ObjectPtr evaluateOneStatic(ExprPtr expr, EnvPtr env) {
-        MultiStaticPtr ms = evaluateExprStatic(expr, env);
-        if (ms->size() != 1)
-            arityError(expr, 1, ms->size());
-        return ms->values[0];
-    }
+ObjectPtr evaluateOneStatic(ExprPtr expr, EnvPtr env) {
+    MultiStaticPtr ms = evaluateExprStatic(expr, env);
+    if (ms->size() != 1)
+        arityError(expr, 1, ms->size());
+    return ms->values[0];
+}
 
-    MultiStaticPtr evaluateMultiStatic(ExprListPtr exprs, EnvPtr env) {
-        MultiStaticPtr out = new MultiStatic();
-        for (size_t i = 0; i < exprs->size(); ++i) {
-            ExprPtr x = exprs->exprs[i];
-            if (x->exprKind == UNPACK) {
-                Unpack *y = (Unpack *) x.ptr();
-                MultiStaticPtr z = evaluateExprStatic(y->expr, env);
-                out->add(z);
-            } else if (x->exprKind == PAREN) {
-                MultiStaticPtr z = evaluateExprStatic(x, env);
-                out->add(z);
-            } else {
-                ObjectPtr y = evaluateOneStatic(x, env);
-                out->add(y);
-            }
+MultiStaticPtr evaluateMultiStatic(ExprListPtr exprs, EnvPtr env) {
+    MultiStaticPtr out = new MultiStatic();
+    for (size_t i = 0; i < exprs->size(); ++i) {
+        ExprPtr x = exprs->exprs[i];
+        if (x->exprKind == UNPACK) {
+            Unpack *y = (Unpack *)x.ptr();
+            MultiStaticPtr z = evaluateExprStatic(y->expr, env);
+            out->add(z);
+        } else if (x->exprKind == PAREN) {
+            MultiStaticPtr z = evaluateExprStatic(x, env);
+            out->add(z);
+        } else {
+            ObjectPtr y = evaluateOneStatic(x, env);
+            out->add(y);
         }
-        return out;
     }
+    return out;
+}
+
+TypePtr evaluateType(ExprPtr expr, EnvPtr env) {
+    ObjectPtr v = evaluateOneStatic(expr, env);
+    if (v->objKind != TYPE) {
+        string buf;
+        llvm::raw_string_ostream sout(buf);
+        sout << "expecting a type but got ";
+        printStaticName(sout, v);
+        error(expr, sout.str());
+    }
+    return (Type *)v.ptr();
+}
 
-    TypePtr evaluateType(ExprPtr expr, EnvPtr env) {
-        ObjectPtr v = evaluateOneStatic(expr, env);
-        if (v->objKind != TYPE) {
+void evaluateMultiType(ExprListPtr exprs, EnvPtr env, vector<TypePtr> &out) {
+    MultiStaticPtr types = evaluateMultiStatic(exprs, env);
+    for (size_t i = 0; i < types->size(); ++i) {
+        if (types->values[i]->objKind != TYPE) {
             string buf;
             llvm::raw_string_ostream sout(buf);
             sout << "expecting a type but got ";
-            printStaticName(sout, v);
-            error(expr, sout.str());
+            printStaticName(sout, types->values[i]);
+            error(sout.str());
         }
-        return (Type *) v.ptr();
+        out.push_back((Type *)types->values[i].ptr());
     }
+}
 
-    void evaluateMultiType(ExprListPtr exprs, EnvPtr env, vector<TypePtr> &out) {
-        MultiStaticPtr types = evaluateMultiStatic(exprs, env);
-        for (size_t i = 0; i < types->size(); ++i) {
-            if (types->values[i]->objKind != TYPE) {
-                string buf;
-                llvm::raw_string_ostream sout(buf);
-                sout << "expecting a type but got ";
-                printStaticName(sout, types->values[i]);
-                error(sout.str());
-            }
-            out.push_back((Type *) types->values[i].ptr());
-        }
-    }
+bool evaluateBool(ExprPtr expr, EnvPtr env) {
+    ObjectPtr v = evaluateOneStatic(expr, env);
+    LocationContext loc(expr->location);
+    if (v->objKind != VALUE_HOLDER)
+        error(expr, "expecting a bool value");
+    ValueHolderPtr vh = (ValueHolder *)v.ptr();
+    if (vh->type != boolType)
+        typeError(boolType, vh->type);
+    return vh->as<bool>();
+}
 
-    bool evaluateBool(ExprPtr expr, EnvPtr env) {
-        ObjectPtr v = evaluateOneStatic(expr, env);
-        LocationContext loc(expr->location);
-        if (v->objKind != VALUE_HOLDER)
-            error(expr, "expecting a bool value");
-        ValueHolderPtr vh = (ValueHolder *) v.ptr();
-        if (vh->type != boolType)
-            typeError(boolType, vh->type);
-        return vh->as<bool>();
+void evaluatePredicate(llvm::ArrayRef<PatternVar> patternVars,
+                       ExprPtr predicate, EnvPtr env) {
+    for (size_t i = 0; i < patternVars.size(); ++i) {
+        if (lookupEnv(env, patternVars[i].name) == nullptr)
+            error(patternVars[i].name, "unbound pattern variable");
     }
-
-    void evaluatePredicate(llvm::ArrayRef<PatternVar> patternVars,
-                           ExprPtr predicate, EnvPtr env) {
-        for (size_t i = 0; i < patternVars.size(); ++i) {
-            if (lookupEnv(env, patternVars[i].name) == nullptr)
-                error(patternVars[i].name, "unbound pattern variable");
-        }
-        if (predicate != nullptr) {
-            if (!evaluateBool(predicate, env))
-                error(predicate, "definition predicate failed");
-        }
+    if (predicate != nullptr) {
+        if (!evaluateBool(predicate, env))
+            error(predicate, "definition predicate failed");
     }
+}
 
-    void evaluateStaticAssert(Location const &location,
-                              const ExprPtr &cond, const ExprListPtr &message, EnvPtr env) {
-        bool r = evaluateBool(cond, env);
+void evaluateStaticAssert(Location const &location, const ExprPtr &cond,
+                          const ExprListPtr &message, EnvPtr env) {
+    bool r = evaluateBool(cond, env);
 
-        // Note, message is evaluated even if assert does not fail.
-        // It is slower, but results is better code.
-        MultiStaticPtr str = evaluateMultiStatic(message, env);
+    // Note, message is evaluated even if assert does not fail.
+    // It is slower, but results is better code.
+    MultiStaticPtr str = evaluateMultiStatic(message, env);
 
-        if (!r) {
-            std::string s;
-            llvm::raw_string_ostream ss(s);
+    if (!r) {
+        std::string s;
+        llvm::raw_string_ostream ss(s);
 
-            for (size_t i = 0; i < str->size(); ++i) {
-                printStaticName(ss, str->values[i]);
-            }
+        for (size_t i = 0; i < str->size(); ++i) {
+            printStaticName(ss, str->values[i]);
+        }
 
-            if (!s.empty()) {
-                error(location, "static assert failed: " + s);
-            } else {
-                error(location, "static assert failed");
-            }
+        if (!s.empty()) {
+            error(location, "static assert failed: " + s);
+        } else {
+            error(location, "static assert failed");
         }
     }
+}
 
-    ValueHolderPtr intToValueHolder(int x) {
-        ValueHolderPtr v = new ValueHolder(cIntType);
-        v->as<int>() = x;
-        return v;
-    }
+ValueHolderPtr intToValueHolder(int x) {
+    ValueHolderPtr v = new ValueHolder(cIntType);
+    v->as<int>() = x;
+    return v;
+}
 
-    ValueHolderPtr sizeTToValueHolder(size_t x) {
-        ValueHolderPtr v = new ValueHolder(cSizeTType);
-        switch (typeSize(cSizeTType)) {
-            case 4: v->as<size32_t>() = size32_t(x);
-                break;
-            case 8: v->as<size64_t>() = size64_t(x);
-                break;
-            default: assert(false);
-        }
-        return v;
-    }
+ValueHolderPtr sizeTToValueHolder(size_t x) {
+    ValueHolderPtr v = new ValueHolder(cSizeTType);
+    switch (typeSize(cSizeTType)) {
+    case 4:
+        v->as<size32_t>() = size32_t(x);
+        break;
+    case 8:
+        v->as<size64_t>() = size64_t(x);
+        break;
+    default:
+        assert(false);
+    }
+    return v;
+}
 
-    ValueHolderPtr ptrDiffTToValueHolder(ptrdiff_t x) {
-        ValueHolderPtr v = new ValueHolder(cPtrDiffTType);
-        switch (typeSize(cPtrDiffTType)) {
-            case 4: v->as<ptrdiff32_t>() = ptrdiff32_t(x);
-                break;
-            case 8: v->as<ptrdiff64_t>() = ptrdiff64_t(x);
-                break;
-            default: assert(false);
-        }
-        return v;
-    }
-
-    ValueHolderPtr boolToValueHolder(bool x) {
-        ValueHolderPtr v = new ValueHolder(boolType);
-        v->as<bool>() = x;
-        return v;
-    }
-
-    //
-    // makeTupleValue
-    //
-
-    ObjectPtr makeTupleValue(llvm::ArrayRef<ObjectPtr> elements) {
-        bool allStatics = true;
-        for (size_t i = 0; i < elements.size(); ++i) {
-            switch (elements[i]->objKind) {
-                case TYPE:
-                case PRIM_OP:
-                case PROCEDURE:
-                case INTRINSIC:
-                case GLOBAL_ALIAS:
-                case RECORD_DECL:
-                case VARIANT_DECL:
-                case MODULE:
-                case IDENTIFIER:
-                    break;
-                default:
-                    allStatics = false;
-                    break;
-            }
-            if (!allStatics)
-                break;
-        }
-        if (allStatics) {
-            vector<TypePtr> elementTypes;
-            for (size_t i = 0; i < elements.size(); ++i)
-                elementTypes.push_back(staticType(elements[i]));
-            TypePtr t = tupleType(elementTypes);
-            return new ValueHolder(t);
-        }
-        ExprListPtr elementExprs = new ExprList();
+ValueHolderPtr ptrDiffTToValueHolder(ptrdiff_t x) {
+    ValueHolderPtr v = new ValueHolder(cPtrDiffTType);
+    switch (typeSize(cPtrDiffTType)) {
+    case 4:
+        v->as<ptrdiff32_t>() = ptrdiff32_t(x);
+        break;
+    case 8:
+        v->as<ptrdiff64_t>() = ptrdiff64_t(x);
+        break;
+    default:
+        assert(false);
+    }
+    return v;
+}
+
+ValueHolderPtr boolToValueHolder(bool x) {
+    ValueHolderPtr v = new ValueHolder(boolType);
+    v->as<bool>() = x;
+    return v;
+}
+
+//
+// makeTupleValue
+//
+
+ObjectPtr makeTupleValue(llvm::ArrayRef<ObjectPtr> elements) {
+    bool allStatics = true;
+    for (size_t i = 0; i < elements.size(); ++i) {
+        switch (elements[i]->objKind) {
+        case TYPE:
+        case PRIM_OP:
+        case PROCEDURE:
+        case INTRINSIC:
+        case GLOBAL_ALIAS:
+        case RECORD_DECL:
+        case VARIANT_DECL:
+        case MODULE:
+        case IDENTIFIER:
+            break;
+        default:
+            allStatics = false;
+            break;
+        }
+        if (!allStatics)
+            break;
+    }
+    if (allStatics) {
+        vector<TypePtr> elementTypes;
         for (size_t i = 0; i < elements.size(); ++i)
-            elementExprs->add(new ObjectExpr(elements[i]));
-        ExprPtr tupleExpr = new Tuple(elementExprs);
-        return evaluateOneStatic(tupleExpr, new Env());
-    }
+            elementTypes.push_back(staticType(elements[i]));
+        TypePtr t = tupleType(elementTypes);
+        return new ValueHolder(t);
+    }
+    ExprListPtr elementExprs = new ExprList();
+    for (size_t i = 0; i < elements.size(); ++i)
+        elementExprs->add(new ObjectExpr(elements[i]));
+    ExprPtr tupleExpr = new Tuple(elementExprs);
+    return evaluateOneStatic(tupleExpr, new Env());
+}
 
-    //
-    // evalueToStatic
-    //
+//
+// evalueToStatic
+//
 
-    ObjectPtr evalueToStatic(EValuePtr ev) {
-        if (ev->type->typeKind == STATIC_TYPE) {
-            StaticType *st = (StaticType *) ev->type.ptr();
-            return st->obj;
-        } else {
-            ValueHolderPtr vh = new ValueHolder(ev->type);
-            EValuePtr dest = new EValue(vh->type, vh->buf);
-            evalValueCopy(dest, ev);
-            return vh.ptr();
-        }
+ObjectPtr evalueToStatic(EValuePtr ev) {
+    if (ev->type->typeKind == STATIC_TYPE) {
+        StaticType *st = (StaticType *)ev->type.ptr();
+        return st->obj;
+    } else {
+        ValueHolderPtr vh = new ValueHolder(ev->type);
+        EValuePtr dest = new EValue(vh->type, vh->buf);
+        evalValueCopy(dest, ev);
+        return vh.ptr();
     }
+}
 
-    //
-    // evaluator
-    //
+//
+// evaluator
+//
 
-    static vector<EValuePtr> stackEValues;
+static vector<EValuePtr> stackEValues;
 
-    //
-    // utility procs
-    //
+//
+// utility procs
+//
 
-    static EValuePtr staticEValue(ObjectPtr obj) {
-        TypePtr t = staticType(obj);
-        return new EValue(t, nullptr);
-    }
+static EValuePtr staticEValue(ObjectPtr obj) {
+    TypePtr t = staticType(obj);
+    return new EValue(t, nullptr);
+}
 
-    static EValuePtr derefValue(EValuePtr evPtr) {
-        assert(evPtr->type->typeKind == POINTER_TYPE);
-        PointerType *pt = (PointerType *) evPtr->type.ptr();
-        char *addr = evPtr->as<char *>();
-        return new EValue(pt->pointeeType, addr);
-    }
+static EValuePtr derefValue(EValuePtr evPtr) {
+    assert(evPtr->type->typeKind == POINTER_TYPE);
+    PointerType *pt = (PointerType *)evPtr->type.ptr();
+    char *addr = evPtr->as<char *>();
+    return new EValue(pt->pointeeType, addr);
+}
 
-    static EValuePtr derefValueForPValue(EValuePtr ev, PVData const &pv) {
-        if (pv.isRValue) {
-            return ev;
-        } else {
-            assert(ev->type == pointerType(pv.type));
-            return derefValue(ev);
-        }
+static EValuePtr derefValueForPValue(EValuePtr ev, PVData const &pv) {
+    if (pv.isRValue) {
+        return ev;
+    } else {
+        assert(ev->type == pointerType(pv.type));
+        return derefValue(ev);
     }
+}
 
-    //
-    // evaluate value ops
-    //
+//
+// evaluate value ops
+//
 
-    void evalValueInit(EValuePtr dest) {
+void evalValueInit(EValuePtr dest) {}
+
+void evalValueDestroy(EValuePtr dest) {}
+
+void evalValueCopy(EValuePtr dest, EValuePtr src) {
+    if (dest->type == src->type) {
+        if (dest->type->typeKind != STATIC_TYPE)
+            memcpy(dest->addr, src->addr, typeSize(dest->type));
+        return;
     }
+    evalCallValue(staticEValue(operator_copy()), new MultiEValue(src),
+                  new MultiEValue(dest));
+}
 
-    void evalValueDestroy(EValuePtr dest) {
+void evalValueMove(EValuePtr dest, EValuePtr src) {
+    if (dest->type == src->type) {
+        if (dest->type->typeKind != STATIC_TYPE)
+            memcpy(dest->addr, src->addr, typeSize(dest->type));
+        return;
     }
+    evalCallValue(staticEValue(operator_move()), new MultiEValue(src),
+                  new MultiEValue(dest));
+}
 
-    void evalValueCopy(EValuePtr dest, EValuePtr src) {
-        if (dest->type == src->type) {
-            if (dest->type->typeKind != STATIC_TYPE)
-                memcpy(dest->addr, src->addr, typeSize(dest->type));
-            return;
-        }
-        evalCallValue(staticEValue(operator_copy()),
-                      new MultiEValue(src),
-                      new MultiEValue(dest));
+void evalValueForward(EValuePtr dest, EValuePtr src) {
+    if (dest->type == src->type) {
+        evalValueMove(dest, src);
+    } else {
+        assert(dest->type == pointerType(src->type));
+        dest->as<void *>() = (void *)src->addr;
     }
+}
 
-    void evalValueMove(EValuePtr dest, EValuePtr src) {
-        if (dest->type == src->type) {
-            if (dest->type->typeKind != STATIC_TYPE)
-                memcpy(dest->addr, src->addr, typeSize(dest->type));
-            return;
-        }
-        evalCallValue(staticEValue(operator_move()),
-                      new MultiEValue(src),
-                      new MultiEValue(dest));
+void evalValueAssign(EValuePtr dest, EValuePtr src) {
+    if (dest->type == src->type) {
+        if (dest->type->typeKind != STATIC_TYPE)
+            memcpy(dest->addr, src->addr, typeSize(dest->type));
+        return;
     }
+    MultiEValuePtr args = new MultiEValue(dest);
+    args->add(src);
+    evalCallValue(staticEValue(operator_assign()), args, new MultiEValue());
+}
 
-    void evalValueForward(EValuePtr dest, EValuePtr src) {
-        if (dest->type == src->type) {
-            evalValueMove(dest, src);
-        } else {
-            assert(dest->type == pointerType(src->type));
-            dest->as<void *>() = (void *) src->addr;
+void evalValueMoveAssign(EValuePtr dest, EValuePtr src) {
+    if (dest->type == src->type) {
+        if (dest->type->typeKind != STATIC_TYPE)
+            memcpy(dest->addr, src->addr, typeSize(dest->type));
+        return;
+    }
+    MultiEValuePtr args = new MultiEValue(dest);
+    args->add(src);
+    MultiPValuePtr pvArgs = new MultiPValue(PVData(dest->type, false));
+    pvArgs->add(PVData(src->type, true));
+    evalCallValue(staticEValue(operator_assign()), args, pvArgs,
+                  new MultiEValue());
+}
+
+bool evalToBoolFlag(EValuePtr a, bool acceptStatics) {
+    BoolKind boolKind = typeBoolKind(a->type);
+
+    if (boolKind == BOOL_EXPR) {
+        return a->as<bool>();
+    } else {
+        if (!acceptStatics) {
+            typeError(boolType, a->type);
         }
+        return boolKind == BOOL_STATIC_TRUE;
+    }
+    return a->as<bool>();
+}
+
+//
+// evaluator temps
+//
+
+unsigned evalMarkStack() { return unsigned(stackEValues.size()); }
+
+void evalDestroyStack(unsigned marker) {
+    size_t i = stackEValues.size();
+    assert(marker <= i);
+    while (marker < i) {
+        --i;
+        evalValueDestroy(stackEValues[i]);
     }
+}
 
-    void evalValueAssign(EValuePtr dest, EValuePtr src) {
-        if (dest->type == src->type) {
-            if (dest->type->typeKind != STATIC_TYPE)
-                memcpy(dest->addr, src->addr, typeSize(dest->type));
-            return;
-        }
-        MultiEValuePtr args = new MultiEValue(dest);
-        args->add(src);
-        evalCallValue(staticEValue(operator_assign()),
-                      args,
-                      new MultiEValue());
+void evalPopStack(unsigned marker) {
+    assert(marker <= stackEValues.size());
+    while (marker < stackEValues.size()) {
+        free(stackEValues.back()->addr);
+        stackEValues.pop_back();
     }
+}
 
-    void evalValueMoveAssign(EValuePtr dest, EValuePtr src) {
-        if (dest->type == src->type) {
-            if (dest->type->typeKind != STATIC_TYPE)
-                memcpy(dest->addr, src->addr, typeSize(dest->type));
-            return;
-        }
-        MultiEValuePtr args = new MultiEValue(dest);
-        args->add(src);
-        MultiPValuePtr pvArgs = new MultiPValue(PVData(dest->type, false));
-        pvArgs->add(PVData(src->type, true));
-        evalCallValue(staticEValue(operator_assign()),
-                      args,
-                      pvArgs,
-                      new MultiEValue());
+void evalDestroyAndPopStack(unsigned marker) {
+    assert(marker <= stackEValues.size());
+    while (marker < stackEValues.size()) {
+        evalValueDestroy(stackEValues.back());
+        free(stackEValues.back()->addr);
+        stackEValues.pop_back();
     }
+}
+
+EValuePtr evalAllocValue(TypePtr t) {
+    char *buf = (char *)calloc(1, typeSize(t));
+    EValuePtr ev = new EValue(t, buf);
+    stackEValues.push_back(ev);
+    return ev;
+}
 
-    bool evalToBoolFlag(EValuePtr a, bool acceptStatics) {
-        BoolKind boolKind = typeBoolKind(a->type);
+EValuePtr evalAllocValueForPValue(PVData const &pv) {
+    if (pv.isRValue)
+        return evalAllocValue(pv.type);
+    else
+        return evalAllocValue(pointerType(pv.type));
+}
 
-        if (boolKind == BOOL_EXPR) {
-            return a->as<bool>();
+//
+// evalMultiArgsAsRef, evalArgExprAsRef
+//
+
+MultiEValuePtr evalMultiArgsAsRef(ExprListPtr exprs, EnvPtr env) {
+    MultiEValuePtr out = new MultiEValue();
+    for (size_t i = 0; i < exprs->size(); ++i) {
+        ExprPtr x = exprs->exprs[i];
+        if (x->exprKind == UNPACK) {
+            Unpack *y = (Unpack *)x.ptr();
+            MultiEValuePtr mev = evalArgExprAsRef(y->expr, env);
+            out->add(mev);
+        } else if (x->exprKind == PAREN) {
+            MultiEValuePtr mev = evalArgExprAsRef(x, env);
+            out->add(mev);
         } else {
-            if (!acceptStatics) {
-                typeError(boolType, a->type);
-            }
-            return boolKind == BOOL_STATIC_TRUE;
+            MultiEValuePtr mev = evalArgExprAsRef(x, env);
+            out->add(mev);
         }
-        return a->as<bool>();
     }
+    return out;
+}
 
-    //
-    // evaluator temps
-    //
-
-    unsigned evalMarkStack() {
-        return unsigned(stackEValues.size());
+MultiEValuePtr evalArgExprAsRef(ExprPtr x, EnvPtr env) {
+    if (x->exprKind == DISPATCH_EXPR) {
+        DispatchExpr *y = (DispatchExpr *)x.ptr();
+        return evalExprAsRef(y->expr, env);
     }
+    return evalExprAsRef(x, env);
+}
 
-    void evalDestroyStack(unsigned marker) {
-        size_t i = stackEValues.size();
-        assert(marker <= i);
-        while (marker < i) {
-            --i;
-            evalValueDestroy(stackEValues[i]);
-        }
-    }
+//
+// evalForwardOneAsRef, evalForwardMultiAsRef, evalForwardExprAsRef
+//
+
+EValuePtr evalForwardOneAsRef(ExprPtr expr, EnvPtr env) {
+    MultiEValuePtr mev = evalForwardExprAsRef(expr, env);
+    LocationContext loc(expr->location);
+    ensureArity(mev, 1);
+    return mev->values[0];
+}
 
-    void evalPopStack(unsigned marker) {
-        assert(marker <= stackEValues.size());
-        while (marker < stackEValues.size()) {
-            free(stackEValues.back()->addr);
-            stackEValues.pop_back();
+MultiEValuePtr evalForwardMultiAsRef(ExprListPtr exprs, EnvPtr env) {
+    MultiEValuePtr out = new MultiEValue();
+    for (size_t i = 0; i < exprs->size(); ++i) {
+        ExprPtr x = exprs->exprs[i];
+        if (x->exprKind == UNPACK) {
+            Unpack *y = (Unpack *)x.ptr();
+            MultiEValuePtr mev = evalForwardExprAsRef(y->expr, env);
+            out->add(mev);
+        } else {
+            MultiEValuePtr mev = evalForwardExprAsRef(x, env);
+            out->add(mev);
         }
     }
+    return out;
+}
 
-    void evalDestroyAndPopStack(unsigned marker) {
-        assert(marker <= stackEValues.size());
-        while (marker < stackEValues.size()) {
-            evalValueDestroy(stackEValues.back());
-            free(stackEValues.back()->addr);
-            stackEValues.pop_back();
+MultiEValuePtr evalForwardExprAsRef(ExprPtr expr, EnvPtr env) {
+    MultiPValuePtr mpv = safeAnalyzeExpr(expr, env);
+    MultiEValuePtr mev = new MultiEValue();
+    for (unsigned i = 0; i < mpv->size(); ++i) {
+        PVData const &pv = mpv->values[i];
+        mev->add(evalAllocValueForPValue(pv));
+    }
+    evalExpr(expr, env, mev);
+    MultiEValuePtr out = new MultiEValue();
+    for (unsigned i = 0; i < mpv->size(); ++i) {
+        if (mpv->values[i].isRValue) {
+            mev->values[i]->forwardedRValue = true;
+            out->add(mev->values[i]);
+        } else {
+            out->add(derefValue(mev->values[i]));
         }
     }
+    return out;
+}
 
-    EValuePtr evalAllocValue(TypePtr t) {
-        char *buf = (char *) calloc(1, typeSize(t));
-        EValuePtr ev = new EValue(t, buf);
-        stackEValues.push_back(ev);
-        return ev;
+//
+// evalOneAsRef, evalMultiAsRef, evalExprAsRef
+//
+
+EValuePtr evalOneAsRef(ExprPtr expr, EnvPtr env) {
+    MultiEValuePtr mev = evalExprAsRef(expr, env);
+    LocationContext loc(expr->location);
+    ensureArity(mev, 1);
+    return mev->values[0];
+}
+
+MultiEValuePtr evalMultiAsRef(ExprListPtr exprs, EnvPtr env) {
+    MultiEValuePtr out = new MultiEValue();
+    for (size_t i = 0; i < exprs->size(); ++i) {
+        ExprPtr x = exprs->exprs[i];
+        if (x->exprKind == UNPACK) {
+            Unpack *y = (Unpack *)x.ptr();
+            MultiEValuePtr mev = evalExprAsRef(y->expr, env);
+            out->add(mev);
+        } else if (x->exprKind == PAREN) {
+            MultiEValuePtr mev = evalExprAsRef(x, env);
+            out->add(mev);
+        } else {
+            EValuePtr ev = evalOneAsRef(x, env);
+            out->add(ev);
+        }
     }
+    return out;
+}
 
-    EValuePtr evalAllocValueForPValue(PVData const &pv) {
-        if (pv.isRValue)
-            return evalAllocValue(pv.type);
+MultiEValuePtr evalExprAsRef(ExprPtr expr, EnvPtr env) {
+    MultiPValuePtr mpv = safeAnalyzeExpr(expr, env);
+    MultiEValuePtr mev = new MultiEValue();
+    for (unsigned i = 0; i < mpv->size(); ++i) {
+        PVData const &pv = mpv->values[i];
+        mev->add(evalAllocValueForPValue(pv));
+    }
+    evalExpr(expr, env, mev);
+    MultiEValuePtr out = new MultiEValue();
+    for (unsigned i = 0; i < mpv->size(); ++i) {
+        if (mpv->values[i].isRValue)
+            out->add(mev->values[i]);
         else
-            return evalAllocValue(pointerType(pv.type));
+            out->add(derefValue(mev->values[i]));
     }
+    return out;
+}
 
-    //
-    // evalMultiArgsAsRef, evalArgExprAsRef
-    //
+//
+// evalOneInto, evalMultiInto, evalExprInto
+//
 
-    MultiEValuePtr evalMultiArgsAsRef(ExprListPtr exprs, EnvPtr env) {
-        MultiEValuePtr out = new MultiEValue();
+void evalOneInto(ExprPtr expr, EnvPtr env, EValuePtr out) {
+    PVData pv = safeAnalyzeOne(expr, env);
+    if (pv.isRValue) {
+        evalOne(expr, env, out);
+    } else {
+        EValuePtr evPtr = evalAllocValue(pointerType(pv.type));
+        evalOne(expr, env, evPtr);
+        evalValueCopy(out, derefValue(evPtr));
+    }
+}
+
+void evalMultiInto(ExprListPtr exprs, EnvPtr env, MultiEValuePtr out,
+                   size_t wantCount) {
+    size_t j = 0;
+    ExprPtr unpackExpr = implicitUnpackExpr(wantCount, exprs);
+    if (unpackExpr != nullptr) {
+        MultiPValuePtr mpv = safeAnalyzeExpr(unpackExpr, env);
+        assert(j + mpv->size() <= out->size());
+        MultiEValuePtr out2 = new MultiEValue();
+        for (size_t k = 0; k < mpv->size(); ++k)
+            out2->add(out->values[j + k]);
+        evalExprInto(unpackExpr, env, out2);
+        j += mpv->size();
+    } else
         for (size_t i = 0; i < exprs->size(); ++i) {
             ExprPtr x = exprs->exprs[i];
             if (x->exprKind == UNPACK) {
-                Unpack *y = (Unpack *) x.ptr();
-                MultiEValuePtr mev = evalArgExprAsRef(y->expr, env);
-                out->add(mev);
+                Unpack *y = (Unpack *)x.ptr();
+                MultiPValuePtr mpv = safeAnalyzeExpr(y->expr, env);
+                assert(j + mpv->size() <= out->size());
+                MultiEValuePtr out2 = new MultiEValue();
+                for (size_t k = 0; k < mpv->size(); ++k)
+                    out2->add(out->values[j + k]);
+                evalExprInto(y->expr, env, out2);
+                j += mpv->size();
             } else if (x->exprKind == PAREN) {
-                MultiEValuePtr mev = evalArgExprAsRef(x, env);
-                out->add(mev);
+                MultiPValuePtr mpv = safeAnalyzeExpr(x, env);
+                assert(j + mpv->size() <= out->size());
+                MultiEValuePtr out2 = new MultiEValue();
+                for (size_t k = 0; k < mpv->size(); ++k)
+                    out2->add(out->values[j + k]);
+                evalExprInto(x, env, out2);
+                j += mpv->size();
             } else {
-                MultiEValuePtr mev = evalArgExprAsRef(x, env);
-                out->add(mev);
+                MultiPValuePtr mpv = safeAnalyzeExpr(x, env);
+                if (mpv->size() != 1)
+                    arityError(x, 1, mpv->size());
+                assert(j < out->size());
+                evalOneInto(x, env, out->values[j]);
+                ++j;
             }
         }
-        return out;
-    }
+    assert(j == out->size());
+}
 
-    MultiEValuePtr evalArgExprAsRef(ExprPtr x, EnvPtr env) {
-        if (x->exprKind == DISPATCH_EXPR) {
-            DispatchExpr *y = (DispatchExpr *) x.ptr();
-            return evalExprAsRef(y->expr, env);
+void evalExprInto(ExprPtr expr, EnvPtr env, MultiEValuePtr out) {
+    MultiPValuePtr mpv = safeAnalyzeExpr(expr, env);
+    assert(out->size() == mpv->size());
+    MultiEValuePtr mev = new MultiEValue();
+    for (unsigned i = 0; i < mpv->size(); ++i) {
+        PVData const &pv = mpv->values[i];
+        if (pv.isRValue) {
+            mev->add(out->values[i]);
+        } else {
+            EValuePtr evPtr = evalAllocValue(pointerType(pv.type));
+            mev->add(evPtr);
         }
-        return evalExprAsRef(x, env);
     }
-
-    //
-    // evalForwardOneAsRef, evalForwardMultiAsRef, evalForwardExprAsRef
-    //
-
-    EValuePtr evalForwardOneAsRef(ExprPtr expr, EnvPtr env) {
-        MultiEValuePtr mev = evalForwardExprAsRef(expr, env);
-        LocationContext loc(expr->location);
-        ensureArity(mev, 1);
-        return mev->values[0];
+    evalExpr(expr, env, mev);
+    for (unsigned i = 0; i < mpv->size(); ++i) {
+        if (!mpv->values[i].isRValue) {
+            evalValueCopy(out->values[i], derefValue(mev->values[i]));
+        }
     }
+}
 
-    MultiEValuePtr evalForwardMultiAsRef(ExprListPtr exprs, EnvPtr env) {
-        MultiEValuePtr out = new MultiEValue();
+//
+// evalMulti
+//
+
+void evalMulti(ExprListPtr exprs, EnvPtr env, MultiEValuePtr out,
+               size_t wantCount) {
+    size_t j = 0;
+    ExprPtr unpackExpr = implicitUnpackExpr(wantCount, exprs);
+    if (unpackExpr != nullptr) {
+        MultiPValuePtr mpv = safeAnalyzeExpr(unpackExpr, env);
+        assert(j + mpv->size() <= out->size());
+        MultiEValuePtr out2 = new MultiEValue();
+        for (size_t k = 0; k < mpv->size(); ++k)
+            out2->add(out->values[j + k]);
+        evalExpr(unpackExpr, env, out2);
+        j += mpv->size();
+    } else
         for (size_t i = 0; i < exprs->size(); ++i) {
             ExprPtr x = exprs->exprs[i];
             if (x->exprKind == UNPACK) {
-                Unpack *y = (Unpack *) x.ptr();
-                MultiEValuePtr mev = evalForwardExprAsRef(y->expr, env);
-                out->add(mev);
+                Unpack *y = (Unpack *)x.ptr();
+                MultiPValuePtr mpv = safeAnalyzeExpr(y->expr, env);
+                assert(j + mpv->size() <= out->size());
+                MultiEValuePtr out2 = new MultiEValue();
+                for (size_t k = 0; k < mpv->size(); ++k)
+                    out2->add(out->values[j + k]);
+                evalExpr(y->expr, env, out2);
+                j += mpv->size();
+            } else if (x->exprKind == PAREN) {
+                MultiPValuePtr mpv = safeAnalyzeExpr(x, env);
+                assert(j + mpv->size() <= out->size());
+                MultiEValuePtr out2 = new MultiEValue();
+                for (size_t k = 0; k < mpv->size(); ++k)
+                    out2->add(out->values[j + k]);
+                evalExpr(x, env, out2);
+                j += mpv->size();
             } else {
-                MultiEValuePtr mev = evalForwardExprAsRef(x, env);
-                out->add(mev);
+                MultiPValuePtr mpv = safeAnalyzeExpr(x, env);
+                if (mpv->size() != 1)
+                    arityError(x, 1, mpv->size());
+                assert(j < out->size());
+                evalOne(x, env, out->values[j]);
+                ++j;
             }
         }
-        return out;
+    assert(j == out->size());
+}
+
+//
+// evalOne
+//
+
+void evalOne(ExprPtr expr, EnvPtr env, EValuePtr out) {
+    evalExpr(expr, env, new MultiEValue(out));
+}
+
+//
+// evalExpr
+//
+
+void evalExpr(ExprPtr expr, EnvPtr env, MultiEValuePtr out) {
+    LocationContext loc(expr->location);
+
+    switch (expr->exprKind) {
+    case BOOL_LITERAL: {
+        BoolLiteral *x = (BoolLiteral *)expr.ptr();
+        ValueHolderPtr y = boolToValueHolder(x->value);
+        evalValueHolder(y, out);
+        break;
     }
 
-    MultiEValuePtr evalForwardExprAsRef(ExprPtr expr, EnvPtr env) {
-        MultiPValuePtr mpv = safeAnalyzeExpr(expr, env);
-        MultiEValuePtr mev = new MultiEValue();
-        for (unsigned i = 0; i < mpv->size(); ++i) {
-            PVData const &pv = mpv->values[i];
-            mev->add(evalAllocValueForPValue(pv));
-        }
-        evalExpr(expr, env, mev);
-        MultiEValuePtr out = new MultiEValue();
-        for (unsigned i = 0; i < mpv->size(); ++i) {
-            if (mpv->values[i].isRValue) {
-                mev->values[i]->forwardedRValue = true;
-                out->add(mev->values[i]);
-            } else {
-                out->add(derefValue(mev->values[i]));
-            }
-        }
-        return out;
+    case INT_LITERAL: {
+        IntLiteral *x = (IntLiteral *)expr.ptr();
+        ValueHolderPtr y = parseIntLiteral(safeLookupModule(env), x);
+        evalValueHolder(y, out);
+        break;
     }
 
-    //
-    // evalOneAsRef, evalMultiAsRef, evalExprAsRef
-    //
+    case FLOAT_LITERAL: {
+        FloatLiteral *x = (FloatLiteral *)expr.ptr();
+        ValueHolderPtr y = parseFloatLiteral(safeLookupModule(env), x);
+        evalValueHolder(y, out);
+        break;
+    }
 
-    EValuePtr evalOneAsRef(ExprPtr expr, EnvPtr env) {
-        MultiEValuePtr mev = evalExprAsRef(expr, env);
-        LocationContext loc(expr->location);
-        ensureArity(mev, 1);
-        return mev->values[0];
+    case CHAR_LITERAL: {
+        CharLiteral *x = (CharLiteral *)expr.ptr();
+        if (!x->desugared)
+            x->desugared = desugarCharLiteral(x->value);
+        evalExpr(x->desugared, env, out);
+        break;
     }
 
-    MultiEValuePtr evalMultiAsRef(ExprListPtr exprs, EnvPtr env) {
-        MultiEValuePtr out = new MultiEValue();
-        for (size_t i = 0; i < exprs->size(); ++i) {
-            ExprPtr x = exprs->exprs[i];
-            if (x->exprKind == UNPACK) {
-                Unpack *y = (Unpack *) x.ptr();
-                MultiEValuePtr mev = evalExprAsRef(y->expr, env);
-                out->add(mev);
-            } else if (x->exprKind == PAREN) {
-                MultiEValuePtr mev = evalExprAsRef(x, env);
-                out->add(mev);
-            } else {
-                EValuePtr ev = evalOneAsRef(x, env);
-                out->add(ev);
-            }
-        }
-        return out;
+    case STRING_LITERAL:
+        break;
+
+    case FILE_EXPR:
+    case ARG_EXPR:
+        break;
+
+    case LINE_EXPR: {
+        Location location = safeLookupCallByNameLocation(env);
+        unsigned line, column, tabColumn;
+        getLineCol(location, line, column, tabColumn);
+
+        ValueHolderPtr vh = sizeTToValueHolder(line + 1);
+        evalStaticObject(vh.ptr(), out);
+        break;
     }
+    case COLUMN_EXPR: {
+        Location location = safeLookupCallByNameLocation(env);
+        unsigned line, column, tabColumn;
+        getLineCol(location, line, column, tabColumn);
 
-    MultiEValuePtr evalExprAsRef(ExprPtr expr, EnvPtr env) {
-        MultiPValuePtr mpv = safeAnalyzeExpr(expr, env);
-        MultiEValuePtr mev = new MultiEValue();
-        for (unsigned i = 0; i < mpv->size(); ++i) {
-            PVData const &pv = mpv->values[i];
-            mev->add(evalAllocValueForPValue(pv));
-        }
-        evalExpr(expr, env, mev);
-        MultiEValuePtr out = new MultiEValue();
-        for (unsigned i = 0; i < mpv->size(); ++i) {
-            if (mpv->values[i].isRValue)
-                out->add(mev->values[i]);
-            else
-                out->add(derefValue(mev->values[i]));
+        ValueHolderPtr vh = sizeTToValueHolder(column);
+        evalStaticObject(vh.ptr(), out);
+        break;
+    }
+
+    case NAME_REF: {
+        NameRef *x = (NameRef *)expr.ptr();
+        ObjectPtr y = safeLookupEnv(env, x->name);
+        if (y->objKind == EXPRESSION) {
+            ExprPtr z = (Expr *)y.ptr();
+            evalExpr(z, env, out);
+        } else if (y->objKind == EXPR_LIST) {
+            ExprListPtr z = (ExprList *)y.ptr();
+            evalMulti(z, env, out, 0);
+        } else {
+            evalStaticObject(y, out);
         }
-        return out;
+        break;
     }
 
-    //
-    // evalOneInto, evalMultiInto, evalExprInto
-    //
+    case TUPLE: {
+        Tuple *x = (Tuple *)expr.ptr();
+        evalCallExpr(operator_expr_tupleLiteral(), x->args, env, out);
+        break;
+    }
 
-    void evalOneInto(ExprPtr expr, EnvPtr env, EValuePtr out) {
-        PVData pv = safeAnalyzeOne(expr, env);
-        if (pv.isRValue) {
-            evalOne(expr, env, out);
-        } else {
-            EValuePtr evPtr = evalAllocValue(pointerType(pv.type));
-            evalOne(expr, env, evPtr);
-            evalValueCopy(out, derefValue(evPtr));
-        }
-    }
-
-    void evalMultiInto(ExprListPtr exprs, EnvPtr env, MultiEValuePtr out, size_t wantCount) {
-        size_t j = 0;
-        ExprPtr unpackExpr = implicitUnpackExpr(wantCount, exprs);
-        if (unpackExpr != nullptr) {
-            MultiPValuePtr mpv = safeAnalyzeExpr(unpackExpr, env);
-            assert(j + mpv->size() <= out->size());
-            MultiEValuePtr out2 = new MultiEValue();
-            for (size_t k = 0; k < mpv->size(); ++k)
-                out2->add(out->values[j + k]);
-            evalExprInto(unpackExpr, env, out2);
-            j += mpv->size();
-        } else
-            for (size_t i = 0; i < exprs->size(); ++i) {
-                ExprPtr x = exprs->exprs[i];
-                if (x->exprKind == UNPACK) {
-                    Unpack *y = (Unpack *) x.ptr();
-                    MultiPValuePtr mpv = safeAnalyzeExpr(y->expr, env);
-                    assert(j + mpv->size() <= out->size());
-                    MultiEValuePtr out2 = new MultiEValue();
-                    for (size_t k = 0; k < mpv->size(); ++k)
-                        out2->add(out->values[j + k]);
-                    evalExprInto(y->expr, env, out2);
-                    j += mpv->size();
-                } else if (x->exprKind == PAREN) {
-                    MultiPValuePtr mpv = safeAnalyzeExpr(x, env);
-                    assert(j + mpv->size() <= out->size());
-                    MultiEValuePtr out2 = new MultiEValue();
-                    for (size_t k = 0; k < mpv->size(); ++k)
-                        out2->add(out->values[j + k]);
-                    evalExprInto(x, env, out2);
-                    j += mpv->size();
-                } else {
-                    MultiPValuePtr mpv = safeAnalyzeExpr(x, env);
-                    if (mpv->size() != 1)
-                        arityError(x, 1, mpv->size());
-                    assert(j < out->size());
-                    evalOneInto(x, env, out->values[j]);
-                    ++j;
-                }
-            }
-        assert(j == out->size());
+    case PAREN: {
+        Paren *x = (Paren *)expr.ptr();
+        evalMulti(x->args, env, out, 0);
+        break;
     }
 
-    void evalExprInto(ExprPtr expr, EnvPtr env, MultiEValuePtr out) {
-        MultiPValuePtr mpv = safeAnalyzeExpr(expr, env);
-        assert(out->size() == mpv->size());
-        MultiEValuePtr mev = new MultiEValue();
-        for (unsigned i = 0; i < mpv->size(); ++i) {
-            PVData const &pv = mpv->values[i];
-            if (pv.isRValue) {
-                mev->add(out->values[i]);
-            } else {
-                EValuePtr evPtr = evalAllocValue(pointerType(pv.type));
-                mev->add(evPtr);
-            }
+    case INDEXING: {
+        Indexing *x = (Indexing *)expr.ptr();
+        evalIndexingExpr(x->expr, x->args, env, out);
+        break;
+    }
+
+    case CALL: {
+        Call *x = (Call *)expr.ptr();
+        evalCallExpr(x->expr, x->allArgs(), env, out);
+        break;
+    }
+
+    case FIELD_REF: {
+        FieldRef *x = (FieldRef *)expr.ptr();
+        if (!x->desugared)
+            desugarFieldRef(x, safeLookupModule(env));
+        if (x->isDottedModuleName) {
+            evalExpr(x->desugared, env, out);
+            break;
         }
-        evalExpr(expr, env, mev);
-        for (unsigned i = 0; i < mpv->size(); ++i) {
-            if (!mpv->values[i].isRValue) {
-                evalValueCopy(out->values[i], derefValue(mev->values[i]));
+        PVData pv = safeAnalyzeOne(x->expr, env);
+        if (pv.type->typeKind == STATIC_TYPE) {
+            StaticType *st = (StaticType *)pv.type.ptr();
+            if (st->obj->objKind == MODULE) {
+                Module *m = (Module *)st->obj.ptr();
+                ObjectPtr obj = safeLookupPublic(m, x->name);
+                evalStaticObject(obj, out);
+                break;
             }
         }
+        evalExpr(x->desugared, env, out);
+        break;
     }
 
-    //
-    // evalMulti
-    //
-
-    void evalMulti(ExprListPtr exprs, EnvPtr env, MultiEValuePtr out, size_t wantCount) {
-        size_t j = 0;
-        ExprPtr unpackExpr = implicitUnpackExpr(wantCount, exprs);
-        if (unpackExpr != nullptr) {
-            MultiPValuePtr mpv = safeAnalyzeExpr(unpackExpr, env);
-            assert(j + mpv->size() <= out->size());
-            MultiEValuePtr out2 = new MultiEValue();
-            for (size_t k = 0; k < mpv->size(); ++k)
-                out2->add(out->values[j + k]);
-            evalExpr(unpackExpr, env, out2);
-            j += mpv->size();
-        } else
-            for (size_t i = 0; i < exprs->size(); ++i) {
-                ExprPtr x = exprs->exprs[i];
-                if (x->exprKind == UNPACK) {
-                    Unpack *y = (Unpack *) x.ptr();
-                    MultiPValuePtr mpv = safeAnalyzeExpr(y->expr, env);
-                    assert(j + mpv->size() <= out->size());
-                    MultiEValuePtr out2 = new MultiEValue();
-                    for (size_t k = 0; k < mpv->size(); ++k)
-                        out2->add(out->values[j + k]);
-                    evalExpr(y->expr, env, out2);
-                    j += mpv->size();
-                } else if (x->exprKind == PAREN) {
-                    MultiPValuePtr mpv = safeAnalyzeExpr(x, env);
-                    assert(j + mpv->size() <= out->size());
-                    MultiEValuePtr out2 = new MultiEValue();
-                    for (size_t k = 0; k < mpv->size(); ++k)
-                        out2->add(out->values[j + k]);
-                    evalExpr(x, env, out2);
-                    j += mpv->size();
-                } else {
-                    MultiPValuePtr mpv = safeAnalyzeExpr(x, env);
-                    if (mpv->size() != 1)
-                        arityError(x, 1, mpv->size());
-                    assert(j < out->size());
-                    evalOne(x, env, out->values[j]);
-                    ++j;
-                }
-            }
-        assert(j == out->size());
+    case STATIC_INDEXING: {
+        StaticIndexing *x = (StaticIndexing *)expr.ptr();
+        if (!x->desugared)
+            x->desugared = desugarStaticIndexing(x);
+        evalExpr(x->desugared, env, out);
+        break;
     }
 
-    //
-    // evalOne
-    //
+    case VARIADIC_OP: {
+        VariadicOp *x = (VariadicOp *)expr.ptr();
+        if (x->op == ADDRESS_OF) {
+            PVData pv = safeAnalyzeOne(x->exprs->exprs.front(), env);
+            if (pv.isRValue)
+                error("can't take address of a temporary");
+        }
+        if (!x->desugared)
+            x->desugared = desugarVariadicOp(x);
+        evalExpr(x->desugared, env, out);
+        break;
+    }
 
-    void evalOne(ExprPtr expr, EnvPtr env, EValuePtr out) {
-        evalExpr(expr, env, new MultiEValue(out));
+    case EVAL_EXPR: {
+        EvalExpr *eval = (EvalExpr *)expr.ptr();
+        // XXX compilation context
+        ExprListPtr evaled = desugarEvalExpr(eval, env);
+        evalMulti(evaled, env, out, 0);
+        break;
     }
 
-    //
-    // evalExpr
-    //
+    case AND: {
+        And *x = (And *)expr.ptr();
+        EValuePtr ev1 = evalOneAsRef(x->expr1, env);
+        bool result = false;
+        if (evalToBoolFlag(ev1, false)) {
+            EValuePtr ev2 = evalOneAsRef(x->expr2, env);
+            result = evalToBoolFlag(ev2, false);
+        }
+        assert(out->size() == 1);
+        EValuePtr out0 = out->values[0];
+        assert(out0->type == boolType);
+        out0->as<bool>() = result;
+        break;
+    }
 
-    void evalExpr(ExprPtr expr, EnvPtr env, MultiEValuePtr out) {
-        LocationContext loc(expr->location);
+    case OR: {
+        Or *x = (Or *)expr.ptr();
+        EValuePtr ev1 = evalOneAsRef(x->expr1, env);
+        bool result = true;
+        if (!evalToBoolFlag(ev1, false)) {
+            EValuePtr ev2 = evalOneAsRef(x->expr2, env);
+            result = evalToBoolFlag(ev2, false);
+        }
+        assert(out->size() == 1);
+        EValuePtr out0 = out->values[0];
+        assert(out0->type == boolType);
+        out0->as<bool>() = result;
+        break;
+    }
 
-        switch (expr->exprKind) {
-            case BOOL_LITERAL: {
-                BoolLiteral *x = (BoolLiteral *) expr.ptr();
-                ValueHolderPtr y = boolToValueHolder(x->value);
-                evalValueHolder(y, out);
-                break;
-            }
+    case LAMBDA: {
+        Lambda *x = (Lambda *)expr.ptr();
+        if (!x->initialized)
+            initializeLambda(x, env);
+        evalExpr(x->converted, env, out);
+        break;
+    }
 
-            case INT_LITERAL: {
-                IntLiteral *x = (IntLiteral *) expr.ptr();
-                ValueHolderPtr y = parseIntLiteral(safeLookupModule(env), x);
-                evalValueHolder(y, out);
-                break;
-            }
+    case UNPACK: {
+        Unpack *unpack = (Unpack *)expr.ptr();
+        if (unpack->expr->exprKind != FOREIGN_EXPR)
+            error("incorrect usage of unpack operator");
+        evalExpr(unpack->expr, env, out);
+        break;
+    }
 
-            case FLOAT_LITERAL: {
-                FloatLiteral *x = (FloatLiteral *) expr.ptr();
-                ValueHolderPtr y = parseFloatLiteral(safeLookupModule(env), x);
-                evalValueHolder(y, out);
-                break;
-            }
+    case STATIC_EXPR: {
+        break;
+    }
 
-            case CHAR_LITERAL: {
-                CharLiteral *x = (CharLiteral *) expr.ptr();
-                if (!x->desugared)
-                    x->desugared = desugarCharLiteral(x->value);
-                evalExpr(x->desugared, env, out);
-                break;
-            }
-
-            case STRING_LITERAL:
-                break;
-
-            case FILE_EXPR:
-            case ARG_EXPR:
-                break;
-
-            case LINE_EXPR: {
-                Location location = safeLookupCallByNameLocation(env);
-                unsigned line, column, tabColumn;
-                getLineCol(location, line, column, tabColumn);
-
-                ValueHolderPtr vh = sizeTToValueHolder(line + 1);
-                evalStaticObject(vh.ptr(), out);
-                break;
-            }
-            case COLUMN_EXPR: {
-                Location location = safeLookupCallByNameLocation(env);
-                unsigned line, column, tabColumn;
-                getLineCol(location, line, column, tabColumn);
-
-                ValueHolderPtr vh = sizeTToValueHolder(column);
-                evalStaticObject(vh.ptr(), out);
-                break;
-            }
-
-            case NAME_REF: {
-                NameRef *x = (NameRef *) expr.ptr();
-                ObjectPtr y = safeLookupEnv(env, x->name);
-                if (y->objKind == EXPRESSION) {
-                    ExprPtr z = (Expr *) y.ptr();
-                    evalExpr(z, env, out);
-                } else if (y->objKind == EXPR_LIST) {
-                    ExprListPtr z = (ExprList *) y.ptr();
-                    evalMulti(z, env, out, 0);
-                } else {
-                    evalStaticObject(y, out);
-                }
-                break;
-            }
-
-            case TUPLE: {
-                Tuple *x = (Tuple *) expr.ptr();
-                evalCallExpr(operator_expr_tupleLiteral(),
-                             x->args,
-                             env,
-                             out);
-                break;
-            }
-
-            case PAREN: {
-                Paren *x = (Paren *) expr.ptr();
-                evalMulti(x->args, env, out, 0);
-                break;
-            }
-
-            case INDEXING: {
-                Indexing *x = (Indexing *) expr.ptr();
-                evalIndexingExpr(x->expr, x->args, env, out);
-                break;
-            }
-
-            case CALL: {
-                Call *x = (Call *) expr.ptr();
-                evalCallExpr(x->expr, x->allArgs(), env, out);
-                break;
-            }
-
-            case FIELD_REF: {
-                FieldRef *x = (FieldRef *) expr.ptr();
-                if (!x->desugared)
-                    desugarFieldRef(x, safeLookupModule(env));
-                if (x->isDottedModuleName) {
-                    evalExpr(x->desugared, env, out);
-                    break;
-                }
-                PVData pv = safeAnalyzeOne(x->expr, env);
-                if (pv.type->typeKind == STATIC_TYPE) {
-                    StaticType *st = (StaticType *) pv.type.ptr();
-                    if (st->obj->objKind == MODULE) {
-                        Module *m = (Module *) st->obj.ptr();
-                        ObjectPtr obj = safeLookupPublic(m, x->name);
-                        evalStaticObject(obj, out);
-                        break;
-                    }
-                }
-                evalExpr(x->desugared, env, out);
-                break;
-            }
-
-            case STATIC_INDEXING: {
-                StaticIndexing *x = (StaticIndexing *) expr.ptr();
-                if (!x->desugared)
-                    x->desugared = desugarStaticIndexing(x);
-                evalExpr(x->desugared, env, out);
-                break;
-            }
-
-            case VARIADIC_OP: {
-                VariadicOp *x = (VariadicOp *) expr.ptr();
-                if (x->op == ADDRESS_OF) {
-                    PVData pv = safeAnalyzeOne(x->exprs->exprs.front(), env);
-                    if (pv.isRValue)
-                        error("can't take address of a temporary");
-                }
-                if (!x->desugared)
-                    x->desugared = desugarVariadicOp(x);
-                evalExpr(x->desugared, env, out);
-                break;
-            }
-
-            case EVAL_EXPR: {
-                EvalExpr *eval = (EvalExpr *) expr.ptr();
-                // XXX compilation context
-                ExprListPtr evaled = desugarEvalExpr(eval, env);
-                evalMulti(evaled, env, out, 0);
-                break;
-            }
-
-            case AND: {
-                And *x = (And *) expr.ptr();
-                EValuePtr ev1 = evalOneAsRef(x->expr1, env);
-                bool result = false;
-                if (evalToBoolFlag(ev1, false)) {
-                    EValuePtr ev2 = evalOneAsRef(x->expr2, env);
-                    result = evalToBoolFlag(ev2, false);
-                }
-                assert(out->size() == 1);
-                EValuePtr out0 = out->values[0];
-                assert(out0->type == boolType);
-                out0->as<bool>() = result;
-                break;
-            }
-
-            case OR: {
-                Or *x = (Or *) expr.ptr();
-                EValuePtr ev1 = evalOneAsRef(x->expr1, env);
-                bool result = true;
-                if (!evalToBoolFlag(ev1, false)) {
-                    EValuePtr ev2 = evalOneAsRef(x->expr2, env);
-                    result = evalToBoolFlag(ev2, false);
-                }
-                assert(out->size() == 1);
-                EValuePtr out0 = out->values[0];
-                assert(out0->type == boolType);
-                out0->as<bool>() = result;
-                break;
-            }
-
-            case LAMBDA: {
-                Lambda *x = (Lambda *) expr.ptr();
-                if (!x->initialized)
-                    initializeLambda(x, env);
-                evalExpr(x->converted, env, out);
-                break;
-            }
-
-            case UNPACK: {
-                Unpack *unpack = (Unpack *) expr.ptr();
-                if (unpack->expr->exprKind != FOREIGN_EXPR)
-                    error("incorrect usage of unpack operator");
-                evalExpr(unpack->expr, env, out);
-                break;
-            }
+    case DISPATCH_EXPR: {
+        error("incorrect usage of dispatch operator");
+        break;
+    }
 
-            case STATIC_EXPR: {
-                break;
-            }
+    case FOREIGN_EXPR: {
+        ForeignExpr *x = (ForeignExpr *)expr.ptr();
+        evalExpr(x->expr, x->getEnv(), out);
+        break;
+    }
 
-            case DISPATCH_EXPR: {
-                error("incorrect usage of dispatch operator");
-                break;
-            }
+    case OBJECT_EXPR: {
+        ObjectExpr *x = (ObjectExpr *)expr.ptr();
+        evalStaticObject(x->obj, out);
+        break;
+    }
 
-            case FOREIGN_EXPR: {
-                ForeignExpr *x = (ForeignExpr *) expr.ptr();
-                evalExpr(x->expr, x->getEnv(), out);
-                break;
-            }
+    default:
+        assert(false);
+    }
+}
 
-            case OBJECT_EXPR: {
-                ObjectExpr *x = (ObjectExpr *) expr.ptr();
-                evalStaticObject(x->obj, out);
-                break;
-            }
+//
+// evalStaticObject
+//
 
-            default:
-                assert(false);
+void evalStaticObject(ObjectPtr x, MultiEValuePtr out) {
+    switch (x->objKind) {
+    case ENUM_MEMBER: {
+        EnumMember *y = (EnumMember *)x.ptr();
+        assert(out->size() == 1);
+        EValuePtr out0 = out->values[0];
+        assert(out0->type == y->type);
+        assert(out0->type->typeKind == ENUM_TYPE);
+        initializeEnumType((EnumType *)out0->type.ptr());
+        out0->as<int>() = y->index;
+        break;
+    }
+
+    case GLOBAL_VARIABLE: {
+        GlobalVariable *y = (GlobalVariable *)x.ptr();
+        if (y->hasParams()) {
+            assert(out->size() == 1);
+            assert(out->values[0]->type == staticType(x));
+        } else {
+            GVarInstancePtr z = defaultGVarInstance(y);
+            if (z->staticGlobal == nullptr)
+                codegenGVarInstance(z);
+            assert(z->staticGlobal != nullptr);
+            assert(out->size() == 1);
+            EValuePtr out0 = out->values[0];
+            assert(out0->type == pointerType(z->type));
+            out0->as<void *>() = (void *)z->staticGlobal->buf;
         }
+        break;
     }
 
-    //
-    // evalStaticObject
-    //
+    case EXTERNAL_VARIABLE: {
+        error("compile-time access to C global variables not supported");
+        break;
+    }
 
-    void evalStaticObject(ObjectPtr x, MultiEValuePtr out) {
-        switch (x->objKind) {
-            case ENUM_MEMBER: {
-                EnumMember *y = (EnumMember *) x.ptr();
-                assert(out->size() == 1);
-                EValuePtr out0 = out->values[0];
-                assert(out0->type == y->type);
-                assert(out0->type->typeKind == ENUM_TYPE);
-                initializeEnumType((EnumType *) out0->type.ptr());
-                out0->as<int>() = y->index;
-                break;
-            }
+    case EXTERNAL_PROCEDURE: {
+        error("compile-time access to C functions not supported");
+        break;
+    }
 
-            case GLOBAL_VARIABLE: {
-                GlobalVariable *y = (GlobalVariable *) x.ptr();
-                if (y->hasParams()) {
-                    assert(out->size() == 1);
-                    assert(out->values[0]->type == staticType(x));
-                } else {
-                    GVarInstancePtr z = defaultGVarInstance(y);
-                    if (z->staticGlobal == nullptr)
-                        codegenGVarInstance(z);
-                    assert(z->staticGlobal != nullptr);
-                    assert(out->size() == 1);
-                    EValuePtr out0 = out->values[0];
-                    assert(out0->type == pointerType(z->type));
-                    out0->as<void *>() = (void *) z->staticGlobal->buf;
-                }
-                break;
-            }
+    case GLOBAL_ALIAS: {
+        GlobalAlias *y = (GlobalAlias *)x.ptr();
+        if (y->hasParams()) {
+            assert(out->size() == 1);
+            assert(out->values[0]->type == staticType(x));
+        } else {
+            evalExpr(y->expr, y->env, out);
+        }
+        break;
+    }
 
-            case EXTERNAL_VARIABLE: {
-                error("compile-time access to C global variables not supported");
-                break;
-            }
+    case VALUE_HOLDER: {
+        ValueHolder *y = (ValueHolder *)x.ptr();
+        evalValueHolder(y, out);
+        break;
+    }
 
-            case EXTERNAL_PROCEDURE: {
-                error("compile-time access to C functions not supported");
-                break;
-            }
+    case MULTI_STATIC: {
+        MultiStatic *y = (MultiStatic *)x.ptr();
+        assert(y->size() == out->size());
+        for (size_t i = 0; i < y->size(); ++i)
+            evalStaticObject(y->values[i], new MultiEValue(out->values[i]));
+        break;
+    }
 
-            case GLOBAL_ALIAS: {
-                GlobalAlias *y = (GlobalAlias *) x.ptr();
-                if (y->hasParams()) {
-                    assert(out->size() == 1);
-                    assert(out->values[0]->type == staticType(x));
-                } else {
-                    evalExpr(y->expr, y->env, out);
-                }
-                break;
-            }
+    case RECORD_DECL: {
+        RecordDecl *y = (RecordDecl *)x.ptr();
+        ObjectPtr z;
+        if (y->params.empty() && !y->varParam)
+            z = recordType(y, vector<ObjectPtr>()).ptr();
+        else
+            z = y;
+        assert(out->size() == 1);
+        assert(out->values[0]->type == staticType(z));
+        break;
+    }
 
-            case VALUE_HOLDER: {
-                ValueHolder *y = (ValueHolder *) x.ptr();
-                evalValueHolder(y, out);
-                break;
-            }
+    case VARIANT_DECL: {
+        VariantDecl *y = (VariantDecl *)x.ptr();
+        ObjectPtr z;
+        if (y->params.empty() && !y->varParam)
+            z = variantType(y, vector<ObjectPtr>()).ptr();
+        else
+            z = y;
+        assert(out->size() == 1);
+        assert(out->values[0]->type == staticType(z));
+        break;
+    }
 
-            case MULTI_STATIC: {
-                MultiStatic *y = (MultiStatic *) x.ptr();
-                assert(y->size() == out->size());
-                for (size_t i = 0; i < y->size(); ++i)
-                    evalStaticObject(y->values[i], new MultiEValue(out->values[i]));
-                break;
-            }
+    case TYPE:
+    case PRIM_OP:
+    case PROCEDURE:
+    case MODULE:
+    case INTRINSIC:
+    case IDENTIFIER: {
+        assert(out->size() == 1);
+        assert(out->values[0]->type == staticType(x));
+        break;
+    }
 
-            case RECORD_DECL: {
-                RecordDecl *y = (RecordDecl *) x.ptr();
-                ObjectPtr z;
-                if (y->params.empty() && !y->varParam)
-                    z = recordType(y, vector<ObjectPtr>()).ptr();
-                else
-                    z = y;
-                assert(out->size() == 1);
-                assert(out->values[0]->type == staticType(z));
-                break;
-            }
+    case EVALUE: {
+        EValue *y = (EValue *)x.ptr();
+        assert(out->size() == 1);
+        EValuePtr out0 = out->values[0];
+        evalValueForward(out0, y);
+        break;
+    }
 
-            case VARIANT_DECL: {
-                VariantDecl *y = (VariantDecl *) x.ptr();
-                ObjectPtr z;
-                if (y->params.empty() && !y->varParam)
-                    z = variantType(y, vector<ObjectPtr>()).ptr();
-                else
-                    z = y;
-                assert(out->size() == 1);
-                assert(out->values[0]->type == staticType(z));
-                break;
-            }
+    case MULTI_EVALUE: {
+        MultiEValue *y = (MultiEValue *)x.ptr();
+        assert(out->size() == y->size());
+        for (size_t i = 0; i < y->size(); ++i) {
+            EValuePtr ev = y->values[i];
+            EValuePtr outi = out->values[i];
+            evalValueForward(outi, ev);
+        }
+        break;
+    }
 
-            case TYPE:
-            case PRIM_OP:
-            case PROCEDURE:
-            case MODULE:
-            case INTRINSIC:
-            case IDENTIFIER: {
-                assert(out->size() == 1);
-                assert(out->values[0]->type == staticType(x));
-                break;
-            }
+    case CVALUE: {
+        // allow values of static type
+        CValue *y = (CValue *)x.ptr();
+        if (y->type->typeKind != STATIC_TYPE)
+            invalidStaticObjectError(x);
+        assert(out->size() == 1);
+        EValuePtr out0 = out->values[0];
+        if (y->forwardedRValue)
+            assert(out0->type == y->type);
+        else
+            assert(out0->type == pointerType(y->type));
+        break;
+    }
+
+    case MULTI_CVALUE: {
+        // allow values of static type
+        MultiCValue *y = (MultiCValue *)x.ptr();
+        assert(out->size() == y->size());
+        for (unsigned i = 0; i < y->size(); ++i) {
+            CValuePtr cv = y->values[i];
+            if (cv->type->typeKind != STATIC_TYPE)
+                argumentInvalidStaticObjectError(i, cv.ptr());
+            EValuePtr outi = out->values[i];
+            if (cv->forwardedRValue)
+                assert(outi->type == cv->type);
+            else
+                assert(outi->type == pointerType(cv->type));
+        }
+        break;
+    }
 
-            case EVALUE: {
-                EValue *y = (EValue *) x.ptr();
-                assert(out->size() == 1);
-                EValuePtr out0 = out->values[0];
-                evalValueForward(out0, y);
-                break;
-            }
+    case PVALUE: {
+        // allow values of static type
+        PValue *yv = (PValue *)x.ptr();
+        PVData const &y = yv->data;
+        if (y.type->typeKind != STATIC_TYPE)
+            invalidStaticObjectError(new PValue(y));
+        assert(out->size() == 1);
+        EValuePtr out0 = out->values[0];
+        if (y.isRValue)
+            assert(out0->type == y.type);
+        else
+            assert(out0->type == pointerType(y.type));
+        break;
+    }
+
+    case MULTI_PVALUE: {
+        // allow values of static type
+        MultiPValue *y = (MultiPValue *)x.ptr();
+        assert(out->size() == y->size());
+        for (unsigned i = 0; i < y->size(); ++i) {
+            PVData const &pv = y->values[i];
+            if (pv.type->typeKind != STATIC_TYPE)
+                argumentInvalidStaticObjectError(i, new PValue(pv));
+            EValuePtr outi = out->values[i];
+            if (pv.isRValue)
+                assert(outi->type == pv.type);
+            else
+                assert(outi->type == pointerType(pv.type));
+        }
+        break;
+    }
 
-            case MULTI_EVALUE: {
-                MultiEValue *y = (MultiEValue *) x.ptr();
-                assert(out->size() == y->size());
-                for (size_t i = 0; i < y->size(); ++i) {
-                    EValuePtr ev = y->values[i];
-                    EValuePtr outi = out->values[i];
-                    evalValueForward(outi, ev);
-                }
-                break;
-            }
+    case PATTERN:
+    case MULTI_PATTERN:
+        error("pattern variable cannot be used as value");
+        break;
 
-            case CVALUE: {
-                // allow values of static type
-                CValue *y = (CValue *) x.ptr();
-                if (y->type->typeKind != STATIC_TYPE)
-                    invalidStaticObjectError(x);
-                assert(out->size() == 1);
-                EValuePtr out0 = out->values[0];
-                if (y->forwardedRValue)
-                    assert(out0->type == y->type);
-                else
-                    assert(out0->type == pointerType(y->type));
-                break;
-            }
+    default:
+        invalidStaticObjectError(x);
+        break;
+    }
+}
 
-            case MULTI_CVALUE: {
-                // allow values of static type
-                MultiCValue *y = (MultiCValue *) x.ptr();
-                assert(out->size() == y->size());
-                for (unsigned i = 0; i < y->size(); ++i) {
-                    CValuePtr cv = y->values[i];
-                    if (cv->type->typeKind != STATIC_TYPE)
-                        argumentInvalidStaticObjectError(i, cv.ptr());
-                    EValuePtr outi = out->values[i];
-                    if (cv->forwardedRValue)
-                        assert(outi->type == cv->type);
-                    else
-                        assert(outi->type == pointerType(cv->type));
-                }
-                break;
-            }
+//
+// evalValueHolder
+//
 
-            case PVALUE: {
-                // allow values of static type
-                PValue *yv = (PValue *) x.ptr();
-                PVData const &y = yv->data;
-                if (y.type->typeKind != STATIC_TYPE)
-                    invalidStaticObjectError(new PValue(y));
-                assert(out->size() == 1);
-                EValuePtr out0 = out->values[0];
-                if (y.isRValue)
-                    assert(out0->type == y.type);
-                else
-                    assert(out0->type == pointerType(y.type));
-                break;
-            }
+void evalValueHolder(ValueHolderPtr x, MultiEValuePtr out) {
+    assert(out->size() == 1);
+    EValuePtr out0 = out->values[0];
+    assert(out0->type == x->type);
 
-            case MULTI_PVALUE: {
-                // allow values of static type
-                MultiPValue *y = (MultiPValue *) x.ptr();
-                assert(out->size() == y->size());
-                for (unsigned i = 0; i < y->size(); ++i) {
-                    PVData const &pv = y->values[i];
-                    if (pv.type->typeKind != STATIC_TYPE)
-                        argumentInvalidStaticObjectError(i, new PValue(pv));
-                    EValuePtr outi = out->values[i];
-                    if (pv.isRValue)
-                        assert(outi->type == pv.type);
-                    else
-                        assert(outi->type == pointerType(pv.type));
-                }
-                break;
-            }
+    switch (x->type->typeKind) {
+    case BOOL_TYPE:
+    case INTEGER_TYPE:
+    case FLOAT_TYPE:
+    case COMPLEX_TYPE:
+    case ENUM_TYPE:
+        memcpy(out0->addr, x->buf, typeSize(x->type));
+        break;
 
-            case PATTERN:
-            case MULTI_PATTERN:
-                error("pattern variable cannot be used as value");
-                break;
+    case STATIC_TYPE:
+        break;
 
-            default:
-                invalidStaticObjectError(x);
-                break;
-        }
+    default:
+        evalValueCopy(out0, new EValue(x->type, x->buf));
+        break;
     }
+}
 
-    //
-    // evalValueHolder
-    //
-
-    void evalValueHolder(ValueHolderPtr x, MultiEValuePtr out) {
-        assert(out->size() == 1);
-        EValuePtr out0 = out->values[0];
-        assert(out0->type == x->type);
-
-        switch (x->type->typeKind) {
-            case BOOL_TYPE:
-            case INTEGER_TYPE:
-            case FLOAT_TYPE:
-            case COMPLEX_TYPE:
-            case ENUM_TYPE:
-                memcpy(out0->addr, x->buf, typeSize(x->type));
-                break;
-
-            case STATIC_TYPE:
-                break;
+//
+// evalIndexingExpr
+//
 
-            default:
-                evalValueCopy(out0, new EValue(x->type, x->buf));
-                break;
+void evalIndexingExpr(ExprPtr indexable, ExprListPtr args, EnvPtr env,
+                      MultiEValuePtr out) {
+    MultiPValuePtr mpv = safeAnalyzeIndexingExpr(indexable, args, env);
+    assert(mpv->size() == out->size());
+    bool allTempStatics = true;
+    for (unsigned i = 0; i < mpv->size(); ++i) {
+        PVData const &pv = mpv->values[i];
+        if (pv.isRValue)
+            assert(out->values[i]->type == pv.type);
+        else
+            assert(out->values[i]->type == pointerType(pv.type));
+        if ((pv.type->typeKind != STATIC_TYPE) || !pv.isRValue) {
+            allTempStatics = false;
         }
     }
-
-    //
-    // evalIndexingExpr
-    //
-
-    void evalIndexingExpr(ExprPtr indexable,
-                          ExprListPtr args,
-                          EnvPtr env,
-                          MultiEValuePtr out) {
-        MultiPValuePtr mpv = safeAnalyzeIndexingExpr(indexable, args, env);
-        assert(mpv->size() == out->size());
-        bool allTempStatics = true;
-        for (unsigned i = 0; i < mpv->size(); ++i) {
-            PVData const &pv = mpv->values[i];
-            if (pv.isRValue)
-                assert(out->values[i]->type == pv.type);
-            else
-                assert(out->values[i]->type == pointerType(pv.type));
-            if ((pv.type->typeKind != STATIC_TYPE) || !pv.isRValue) {
-                allTempStatics = false;
-            }
-        }
-        if (allTempStatics) {
-            // takes care of type constructors
+    if (allTempStatics) {
+        // takes care of type constructors
+        return;
+    }
+    PVData pv = safeAnalyzeOne(indexable, env);
+    if (pv.type->typeKind == STATIC_TYPE) {
+        StaticType *st = (StaticType *)pv.type.ptr();
+        ObjectPtr obj = st->obj;
+        if (obj->objKind == GLOBAL_ALIAS) {
+            GlobalAlias *x = (GlobalAlias *)obj.ptr();
+            evalAliasIndexing(x, args, env, out);
             return;
         }
-        PVData pv = safeAnalyzeOne(indexable, env);
-        if (pv.type->typeKind == STATIC_TYPE) {
-            StaticType *st = (StaticType *) pv.type.ptr();
-            ObjectPtr obj = st->obj;
-            if (obj->objKind == GLOBAL_ALIAS) {
-                GlobalAlias *x = (GlobalAlias *) obj.ptr();
-                evalAliasIndexing(x, args, env, out);
-                return;
-            }
-            if (obj->objKind == GLOBAL_VARIABLE) {
-                GlobalVariable *x = (GlobalVariable *) obj.ptr();
-                GVarInstancePtr y = analyzeGVarIndexing(x, args, env);
-                if (y->staticGlobal == nullptr)
-                    codegenGVarInstance(y);
-                assert(y->staticGlobal != nullptr);
-                assert(out->size() == 1);
-                EValuePtr out0 = out->values[0];
-                assert(out0->type == pointerType(y->type));
-                out0->as<void *>() = (void *) y->staticGlobal->buf;
-                return;
-            }
-        }
-        ExprListPtr args2 = new ExprList(indexable);
-        args2->add(args);
-        evalCallExpr(operator_expr_index(), args2, env, out);
-    }
-
-    //
-    // evalAliasIndexing
-    //
-
-    void evalAliasIndexing(GlobalAliasPtr x,
-                           ExprListPtr args,
-                           EnvPtr env,
-                           MultiEValuePtr out) {
-        assert(x->hasParams());
-        MultiStaticPtr params = evaluateMultiStatic(args, env);
-        if (x->varParam.ptr()) {
-            if (params->size() < x->params.size())
-                arityError2(x->params.size(), params->size());
-        } else {
-            ensureArity(params, x->params.size());
-        }
-        EnvPtr bodyEnv = new Env(x->env);
-        for (size_t i = 0; i < x->params.size(); ++i) {
-            addLocal(bodyEnv, x->params[i], params->values[i]);
-        }
-        if (x->varParam.ptr()) {
-            MultiStaticPtr varParams = new MultiStatic();
-            for (size_t i = x->params.size(); i < params->size(); ++i)
-                varParams->add(params->values[i]);
-            addLocal(bodyEnv, x->varParam, varParams.ptr());
+        if (obj->objKind == GLOBAL_VARIABLE) {
+            GlobalVariable *x = (GlobalVariable *)obj.ptr();
+            GVarInstancePtr y = analyzeGVarIndexing(x, args, env);
+            if (y->staticGlobal == nullptr)
+                codegenGVarInstance(y);
+            assert(y->staticGlobal != nullptr);
+            assert(out->size() == 1);
+            EValuePtr out0 = out->values[0];
+            assert(out0->type == pointerType(y->type));
+            out0->as<void *>() = (void *)y->staticGlobal->buf;
+            return;
         }
-        evalExpr(x->expr, bodyEnv, out);
     }
+    ExprListPtr args2 = new ExprList(indexable);
+    args2->add(args);
+    evalCallExpr(operator_expr_index(), args2, env, out);
+}
 
-    //
-    // evalCallExpr
-    //
+//
+// evalAliasIndexing
+//
 
-    static bool isMemoizable(ObjectPtr callable) {
-        // UGLY HACK: memoize if procedure name ends with '?'
-        if (callable->objKind != PROCEDURE)
-            return false;
-        Procedure *x = (Procedure *) callable.ptr();
-        llvm::StringRef s = x->name->str;
-        return s[s.size() - 1] == '?';
-    }
+void evalAliasIndexing(GlobalAliasPtr x, ExprListPtr args, EnvPtr env,
+                       MultiEValuePtr out) {
+    assert(x->hasParams());
+    MultiStaticPtr params = evaluateMultiStatic(args, env);
+    if (x->varParam.ptr()) {
+        if (params->size() < x->params.size())
+            arityError2(x->params.size(), params->size());
+    } else {
+        ensureArity(params, x->params.size());
+    }
+    EnvPtr bodyEnv = new Env(x->env);
+    for (size_t i = 0; i < x->params.size(); ++i) {
+        addLocal(bodyEnv, x->params[i], params->values[i]);
+    }
+    if (x->varParam.ptr()) {
+        MultiStaticPtr varParams = new MultiStatic();
+        for (size_t i = x->params.size(); i < params->size(); ++i)
+            varParams->add(params->values[i]);
+        addLocal(bodyEnv, x->varParam, varParams.ptr());
+    }
+    evalExpr(x->expr, bodyEnv, out);
+}
 
-    void evalCallExpr(ExprPtr callable,
-                      ExprListPtr args,
-                      EnvPtr env,
-                      MultiEValuePtr out) {
-        PVData pv = safeAnalyzeOne(callable, env);
-
-        switch (pv.type->typeKind) {
-            case CODE_POINTER_TYPE: {
-                EValuePtr ev = evalOneAsRef(callable, env);
-                MultiEValuePtr mev = evalMultiAsRef(args, env);
-                evalCallPointer(ev, mev, out);
-                return;
-            }
-            default:
-                break;
-        }
+//
+// evalCallExpr
+//
+
+static bool isMemoizable(ObjectPtr callable) {
+    // UGLY HACK: memoize if procedure name ends with '?'
+    if (callable->objKind != PROCEDURE)
+        return false;
+    Procedure *x = (Procedure *)callable.ptr();
+    llvm::StringRef s = x->name->str;
+    return s[s.size() - 1] == '?';
+}
 
-        if (pv.type->typeKind != STATIC_TYPE) {
-            ExprListPtr args2 = new ExprList(callable);
-            args2->add(args);
-            evalCallExpr(operator_expr_call(), args2, env, out);
-            return;
-        }
+void evalCallExpr(ExprPtr callable, ExprListPtr args, EnvPtr env,
+                  MultiEValuePtr out) {
+    PVData pv = safeAnalyzeOne(callable, env);
 
-        StaticType *st = (StaticType *) pv.type.ptr();
-        ObjectPtr obj = st->obj;
+    switch (pv.type->typeKind) {
+    case CODE_POINTER_TYPE: {
+        EValuePtr ev = evalOneAsRef(callable, env);
+        MultiEValuePtr mev = evalMultiAsRef(args, env);
+        evalCallPointer(ev, mev, out);
+        return;
+    }
+    default:
+        break;
+    }
 
-        switch (obj->objKind) {
-            case TYPE:
-            case RECORD_DECL:
-            case VARIANT_DECL:
-            case PROCEDURE:
-            case GLOBAL_ALIAS:
-            case PRIM_OP: {
-                if ((obj->objKind == PRIM_OP) && !isOverloadablePrimOp(obj)) {
-                    PrimOpPtr x = (PrimOp *) obj.ptr();
-                    MultiEValuePtr mev = evalMultiAsRef(args, env);
-                    evalPrimOp(x, mev, out);
-                    break;
-                }
-                vector<unsigned> dispatchIndices;
-                MultiPValuePtr mpv = safeAnalyzeMultiArgs(args, env, dispatchIndices);
-                if (dispatchIndices.size() > 0) {
-                    MultiEValuePtr mev = evalMultiArgsAsRef(args, env);
-                    evalDispatch(obj, mev, mpv, dispatchIndices, out);
-                    break;
-                }
-                CompileContextPusher pusher(obj, mpv->values);
-                InvokeEntry *entry = safeAnalyzeCallable(obj, mpv->values);
-                if (entry->callByName) {
-                    evalCallByName(entry, callable, args, env, out);
+    if (pv.type->typeKind != STATIC_TYPE) {
+        ExprListPtr args2 = new ExprList(callable);
+        args2->add(args);
+        evalCallExpr(operator_expr_call(), args2, env, out);
+        return;
+    }
+
+    StaticType *st = (StaticType *)pv.type.ptr();
+    ObjectPtr obj = st->obj;
+
+    switch (obj->objKind) {
+    case TYPE:
+    case RECORD_DECL:
+    case VARIANT_DECL:
+    case PROCEDURE:
+    case GLOBAL_ALIAS:
+    case PRIM_OP: {
+        if ((obj->objKind == PRIM_OP) && !isOverloadablePrimOp(obj)) {
+            PrimOpPtr x = (PrimOp *)obj.ptr();
+            MultiEValuePtr mev = evalMultiAsRef(args, env);
+            evalPrimOp(x, mev, out);
+            break;
+        }
+        vector<unsigned> dispatchIndices;
+        MultiPValuePtr mpv = safeAnalyzeMultiArgs(args, env, dispatchIndices);
+        if (dispatchIndices.size() > 0) {
+            MultiEValuePtr mev = evalMultiArgsAsRef(args, env);
+            evalDispatch(obj, mev, mpv, dispatchIndices, out);
+            break;
+        }
+        CompileContextPusher pusher(obj, mpv->values);
+        InvokeEntry *entry = safeAnalyzeCallable(obj, mpv->values);
+        if (entry->callByName) {
+            evalCallByName(entry, callable, args, env, out);
+        } else {
+            assert(entry->analyzed);
+            MultiEValuePtr mev = evalMultiAsRef(args, env);
+            if (isMemoizable(obj)) {
+                assert(obj->objKind == PROCEDURE);
+                Procedure *x = (Procedure *)obj.ptr();
+                vector<ObjectPtr> args2;
+                for (size_t i = 0; i < mev->size(); ++i)
+                    args2.push_back(evalueToStatic(mev->values[i]));
+                if (!x->evaluatorCache)
+                    x->evaluatorCache = new ObjectTable();
+                Pointer<RefCounted> result = x->evaluatorCache->lookup(args2);
+                if (!result) {
+                    evalCallCode(entry, mev, out);
+                    MultiStaticPtr ms = new MultiStatic();
+                    for (size_t i = 0; i < out->size(); ++i)
+                        ms->add(evalueToStatic(out->values[i]));
+                    x->evaluatorCache->lookup(args2) = ms.ptr();
                 } else {
-                    assert(entry->analyzed);
-                    MultiEValuePtr mev = evalMultiAsRef(args, env);
-                    if (isMemoizable(obj)) {
-                        assert(obj->objKind == PROCEDURE);
-                        Procedure *x = (Procedure *) obj.ptr();
-                        vector<ObjectPtr> args2;
-                        for (size_t i = 0; i < mev->size(); ++i)
-                            args2.push_back(evalueToStatic(mev->values[i]));
-                        if (!x->evaluatorCache)
-                            x->evaluatorCache = new ObjectTable();
-                        Pointer<RefCounted> result = x->evaluatorCache->lookup(args2);
-                        if (!result) {
-                            evalCallCode(entry, mev, out);
-                            MultiStaticPtr ms = new MultiStatic();
-                            for (size_t i = 0; i < out->size(); ++i)
-                                ms->add(evalueToStatic(out->values[i]));
-                            x->evaluatorCache->lookup(args2) = ms.ptr();
-                        } else {
-                            evalStaticObject(checked_cast<MultiStatic *>(result.ptr()), out);
-                        }
-                    } else {
-                        evalCallCode(entry, mev, out);
-                    }
+                    evalStaticObject(checked_cast<MultiStatic *>(result.ptr()),
+                                     out);
                 }
-                break;
-            }
-
-            case INTRINSIC: {
-                error(callable, "compile-time calls to LLVM intrinsics are not supported");
-                break;
+            } else {
+                evalCallCode(entry, mev, out);
             }
-
-            default:
-                error("invalid call expression");
-                break;
         }
+        break;
     }
 
-    //
-    // evalDispatch
-    //
-
-    unsigned evalDispatchTag(EValuePtr ev) {
-        unsigned tag;
-        EValuePtr etag = new EValue(cIntType, (char *) &tag);
-        evalCallValue(staticEValue(operator_dispatchTag()),
-                      new MultiEValue(ev),
-                      new MultiEValue(etag));
-        if (!tag)
-            error("dispatch tag uninitialized");
-        return tag;
+    case INTRINSIC: {
+        error(callable,
+              "compile-time calls to LLVM intrinsics are not supported");
+        break;
     }
 
-    EValuePtr evalDispatchIndex(EValuePtr ev, PVData const &pvOut, unsigned tag) {
-        MultiEValuePtr args = new MultiEValue();
-        args->add(ev);
-        ValueHolderPtr vh = intToValueHolder((int) tag);
-        args->add(staticEValue(vh.ptr()));
-
-        EValuePtr evOut = evalAllocValueForPValue(pvOut);
-        MultiEValuePtr out = new MultiEValue(evOut);
-        evalCallValue(staticEValue(operator_dispatchIndex()), args, out);
-        return derefValueForPValue(evOut, pvOut);
+    default:
+        error("invalid call expression");
+        break;
     }
+}
 
-    void evalDispatch(ObjectPtr obj,
-                      MultiEValuePtr args,
-                      MultiPValuePtr pvArgs,
-                      llvm::ArrayRef<unsigned> dispatchIndices,
-                      MultiEValuePtr out) {
-        assert(args->size() == pvArgs->size());
-
-        if (dispatchIndices.empty()) {
-            evalCallValue(staticEValue(obj), args, pvArgs, out);
-            return;
-        }
+//
+// evalDispatch
+//
+
+unsigned evalDispatchTag(EValuePtr ev) {
+    unsigned tag;
+    EValuePtr etag = new EValue(cIntType, (char *)&tag);
+    evalCallValue(staticEValue(operator_dispatchTag()), new MultiEValue(ev),
+                  new MultiEValue(etag));
+    if (!tag)
+        error("dispatch tag uninitialized");
+    return tag;
+}
 
-        CompileContextPusher pusher(obj, pvArgs->values);
+EValuePtr evalDispatchIndex(EValuePtr ev, PVData const &pvOut, unsigned tag) {
+    MultiEValuePtr args = new MultiEValue();
+    args->add(ev);
+    ValueHolderPtr vh = intToValueHolder((int)tag);
+    args->add(staticEValue(vh.ptr()));
 
-        unsigned index = dispatchIndices[0];
-        vector<unsigned> dispatchIndices2(dispatchIndices.begin() + 1,
-                                          dispatchIndices.end());
+    EValuePtr evOut = evalAllocValueForPValue(pvOut);
+    MultiEValuePtr out = new MultiEValue(evOut);
+    evalCallValue(staticEValue(operator_dispatchIndex()), args, out);
+    return derefValueForPValue(evOut, pvOut);
+}
 
-        MultiEValuePtr prefix = new MultiEValue();
-        MultiPValuePtr pvPrefix = new MultiPValue();
-        for (unsigned i = 0; i < index; ++i) {
-            prefix->add(args->values[i]);
-            pvPrefix->add(pvArgs->values[i]);
-        }
-        MultiEValuePtr suffix = new MultiEValue();
-        MultiPValuePtr pvSuffix = new MultiPValue();
-        for (unsigned i = index + 1; i < args->size(); ++i) {
-            suffix->add(args->values[i]);
-            pvSuffix->add(pvArgs->values[i]);
-        }
-        EValuePtr evDispatch = args->values[index];
-        PVData const &pvDispatch = pvArgs->values[index];
+void evalDispatch(ObjectPtr obj, MultiEValuePtr args, MultiPValuePtr pvArgs,
+                  llvm::ArrayRef<unsigned> dispatchIndices,
+                  MultiEValuePtr out) {
+    assert(args->size() == pvArgs->size());
 
-        unsigned tag = evalDispatchTag(evDispatch);
-        unsigned tagCount = dispatchTagCount(evDispatch->type);
-        if (tag >= tagCount)
-            argumentError(index, "invalid variant value");
+    if (dispatchIndices.empty()) {
+        evalCallValue(staticEValue(obj), args, pvArgs, out);
+        return;
+    }
 
-        MultiEValuePtr args2 = new MultiEValue();
-        MultiPValuePtr pvArgs2 = new MultiPValue();
-        pvArgs2->add(pvPrefix);
-        PVData pvDispatch2 = analyzeDispatchIndex(pvDispatch, tag);
-        pvArgs2->add(pvDispatch2);
-        pvArgs2->add(pvSuffix);
+    CompileContextPusher pusher(obj, pvArgs->values);
 
-        args2->add(prefix);
-        args2->add(evalDispatchIndex(evDispatch, pvDispatch2, tag));
-        args2->add(suffix);
+    unsigned index = dispatchIndices[0];
+    vector<unsigned> dispatchIndices2(dispatchIndices.begin() + 1,
+                                      dispatchIndices.end());
 
-        evalDispatch(obj, args2, pvArgs2, dispatchIndices2, out);
+    MultiEValuePtr prefix = new MultiEValue();
+    MultiPValuePtr pvPrefix = new MultiPValue();
+    for (unsigned i = 0; i < index; ++i) {
+        prefix->add(args->values[i]);
+        pvPrefix->add(pvArgs->values[i]);
+    }
+    MultiEValuePtr suffix = new MultiEValue();
+    MultiPValuePtr pvSuffix = new MultiPValue();
+    for (unsigned i = index + 1; i < args->size(); ++i) {
+        suffix->add(args->values[i]);
+        pvSuffix->add(pvArgs->values[i]);
     }
+    EValuePtr evDispatch = args->values[index];
+    PVData const &pvDispatch = pvArgs->values[index];
 
-    //
-    // evalCallValue
-    //
+    unsigned tag = evalDispatchTag(evDispatch);
+    unsigned tagCount = dispatchTagCount(evDispatch->type);
+    if (tag >= tagCount)
+        argumentError(index, "invalid variant value");
 
-    void evalCallValue(EValuePtr callable,
-                       MultiEValuePtr args,
-                       MultiEValuePtr out) {
-        MultiPValuePtr pvArgs = new MultiPValue();
-        for (size_t i = 0; i < args->size(); ++i)
-            pvArgs->add(PVData(args->values[i]->type, false));
-        evalCallValue(callable, args, pvArgs, out);
-    }
+    MultiEValuePtr args2 = new MultiEValue();
+    MultiPValuePtr pvArgs2 = new MultiPValue();
+    pvArgs2->add(pvPrefix);
+    PVData pvDispatch2 = analyzeDispatchIndex(pvDispatch, tag);
+    pvArgs2->add(pvDispatch2);
+    pvArgs2->add(pvSuffix);
 
-    void evalCallValue(EValuePtr callable,
-                       MultiEValuePtr args,
-                       MultiPValuePtr pvArgs,
-                       MultiEValuePtr out) {
-        assert(args->size() == pvArgs->size());
+    args2->add(prefix);
+    args2->add(evalDispatchIndex(evDispatch, pvDispatch2, tag));
+    args2->add(suffix);
 
-        switch (callable->type->typeKind) {
-            case CODE_POINTER_TYPE:
-                evalCallPointer(callable, args, out);
-                return;
-            default:
-                break;
-        }
+    evalDispatch(obj, args2, pvArgs2, dispatchIndices2, out);
+}
 
-        if (callable->type->typeKind != STATIC_TYPE) {
-            MultiEValuePtr args2 = new MultiEValue(callable);
-            args2->add(args);
-            MultiPValuePtr pvArgs2 =
-                    new MultiPValue(PVData(callable->type, false));
-            pvArgs2->add(pvArgs);
-            evalCallValue(staticEValue(operator_call()), args2, pvArgs2, out);
-            return;
-        }
+//
+// evalCallValue
+//
 
-        StaticType *st = (StaticType *) callable->type.ptr();
-        ObjectPtr obj = st->obj;
+void evalCallValue(EValuePtr callable, MultiEValuePtr args,
+                   MultiEValuePtr out) {
+    MultiPValuePtr pvArgs = new MultiPValue();
+    for (size_t i = 0; i < args->size(); ++i)
+        pvArgs->add(PVData(args->values[i]->type, false));
+    evalCallValue(callable, args, pvArgs, out);
+}
 
-        switch (obj->objKind) {
-            case TYPE:
-            case RECORD_DECL:
-            case VARIANT_DECL:
-            case PROCEDURE:
-            case GLOBAL_ALIAS:
-            case PRIM_OP: {
-                if ((obj->objKind == PRIM_OP) && !isOverloadablePrimOp(obj)) {
-                    PrimOpPtr x = (PrimOp *) obj.ptr();
-                    evalPrimOp(x, args, out);
-                    break;
-                }
-                CompileContextPusher pusher(obj, pvArgs->values);
-                InvokeEntry *entry = safeAnalyzeCallable(obj, pvArgs->values);
-                if (entry->callByName) {
-                    ExprListPtr objectExprs = new ExprList();
-                    for (vector<EValuePtr>::const_iterator i = args->values.begin();
-                         i != args->values.end();
-                         ++i) {
-                        objectExprs->add(new ObjectExpr(i->ptr()));
-                    }
-                    ExprPtr callableObject = new ObjectExpr(callable.ptr());
-                    callableObject->location = topLocation();
-                    evalCallByName(entry, callableObject, objectExprs, new Env(), out);
-                } else {
-                    assert(entry->analyzed);
-                    evalCallCode(entry, args, out);
-                }
-                break;
-            }
+void evalCallValue(EValuePtr callable, MultiEValuePtr args,
+                   MultiPValuePtr pvArgs, MultiEValuePtr out) {
+    assert(args->size() == pvArgs->size());
 
-            case INTRINSIC: {
-                error("compile-time calls to LLVM intrinsics are not supported");
-                break;
-            }
+    switch (callable->type->typeKind) {
+    case CODE_POINTER_TYPE:
+        evalCallPointer(callable, args, out);
+        return;
+    default:
+        break;
+    }
 
-            default:
-                error("invalid call operation");
-                break;
+    if (callable->type->typeKind != STATIC_TYPE) {
+        MultiEValuePtr args2 = new MultiEValue(callable);
+        args2->add(args);
+        MultiPValuePtr pvArgs2 = new MultiPValue(PVData(callable->type, false));
+        pvArgs2->add(pvArgs);
+        evalCallValue(staticEValue(operator_call()), args2, pvArgs2, out);
+        return;
+    }
+
+    StaticType *st = (StaticType *)callable->type.ptr();
+    ObjectPtr obj = st->obj;
+
+    switch (obj->objKind) {
+    case TYPE:
+    case RECORD_DECL:
+    case VARIANT_DECL:
+    case PROCEDURE:
+    case GLOBAL_ALIAS:
+    case PRIM_OP: {
+        if ((obj->objKind == PRIM_OP) && !isOverloadablePrimOp(obj)) {
+            PrimOpPtr x = (PrimOp *)obj.ptr();
+            evalPrimOp(x, args, out);
+            break;
+        }
+        CompileContextPusher pusher(obj, pvArgs->values);
+        InvokeEntry *entry = safeAnalyzeCallable(obj, pvArgs->values);
+        if (entry->callByName) {
+            ExprListPtr objectExprs = new ExprList();
+            for (vector<EValuePtr>::const_iterator i = args->values.begin();
+                 i != args->values.end(); ++i) {
+                objectExprs->add(new ObjectExpr(i->ptr()));
+            }
+            ExprPtr callableObject = new ObjectExpr(callable.ptr());
+            callableObject->location = topLocation();
+            evalCallByName(entry, callableObject, objectExprs, new Env(), out);
+        } else {
+            assert(entry->analyzed);
+            evalCallCode(entry, args, out);
         }
+        break;
     }
 
-    //
-    // evalCallPointer
-    //
+    case INTRINSIC: {
+        error("compile-time calls to LLVM intrinsics are not supported");
+        break;
+    }
 
-    void evalCallPointer(EValuePtr /*x*/,
-                         MultiEValuePtr /*args*/,
-                         MultiEValuePtr /*out*/) {
-        error("invoking a code pointer not yet supported in evaluator");
+    default:
+        error("invalid call operation");
+        break;
     }
+}
 
-    //
-    // evalCallCode
-    //
+//
+// evalCallPointer
+//
 
-    void evalCallCode(InvokeEntry *entry,
-                      MultiEValuePtr args,
-                      MultiEValuePtr out) {
-        assert(!entry->callByName);
-        assert(entry->analyzed);
-        if (entry->code->isLLVMBody()) {
-            evalCallCompiledCode(entry, args, out);
-            return;
-        }
+void evalCallPointer(EValuePtr /*x*/, MultiEValuePtr /*args*/,
+                     MultiEValuePtr /*out*/) {
+    error("invoking a code pointer not yet supported in evaluator");
+}
 
-        ensureArity(args, entry->argsKey.size());
+//
+// evalCallCode
+//
 
-        EnvPtr env = new Env(entry->env);
+void evalCallCode(InvokeEntry *entry, MultiEValuePtr args, MultiEValuePtr out) {
+    assert(!entry->callByName);
+    assert(entry->analyzed);
+    if (entry->code->isLLVMBody()) {
+        evalCallCompiledCode(entry, args, out);
+        return;
+    }
 
-        unsigned k = 0;
-        for (; k < entry->varArgPosition; ++k) {
-            EValuePtr ev = args->values[k];
+    ensureArity(args, entry->argsKey.size());
+
+    EnvPtr env = new Env(entry->env);
+
+    unsigned k = 0;
+    for (; k < entry->varArgPosition; ++k) {
+        EValuePtr ev = args->values[k];
+        EValuePtr earg = new EValue(ev->type, ev->addr);
+        earg->forwardedRValue = entry->forwardedRValueFlags[k];
+        addLocal(env, entry->fixedArgNames[k], earg.ptr());
+    }
+    if (entry->varArgName.ptr()) {
+        MultiEValuePtr varArgs = new MultiEValue();
+        unsigned j = 0;
+        for (; j < entry->varArgTypes.size(); ++j) {
+            EValuePtr ev = args->values[k + j];
             EValuePtr earg = new EValue(ev->type, ev->addr);
-            earg->forwardedRValue = entry->forwardedRValueFlags[k];
-            addLocal(env, entry->fixedArgNames[k], earg.ptr());
+            earg->forwardedRValue = entry->forwardedRValueFlags[k + j];
+            varArgs->add(earg);
         }
-        if (entry->varArgName.ptr()) {
-            MultiEValuePtr varArgs = new MultiEValue();
-            unsigned j = 0;
-            for (; j < entry->varArgTypes.size(); ++j) {
-                EValuePtr ev = args->values[k + j];
-                EValuePtr earg = new EValue(ev->type, ev->addr);
-                earg->forwardedRValue = entry->forwardedRValueFlags[k + j];
-                varArgs->add(earg);
-            }
-            addLocal(env, entry->varArgName, varArgs.ptr());
-            for (; k < entry->fixedArgNames.size(); ++k) {
-                EValuePtr ev = args->values[k + j];
-                EValuePtr earg = new EValue(ev->type, ev->addr);
-                earg->forwardedRValue = entry->forwardedRValueFlags[k + j];
-                addLocal(env, entry->fixedArgNames[k], earg.ptr());
-            }
+        addLocal(env, entry->varArgName, varArgs.ptr());
+        for (; k < entry->fixedArgNames.size(); ++k) {
+            EValuePtr ev = args->values[k + j];
+            EValuePtr earg = new EValue(ev->type, ev->addr);
+            earg->forwardedRValue = entry->forwardedRValueFlags[k + j];
+            addLocal(env, entry->fixedArgNames[k], earg.ptr());
         }
+    }
 
-        assert(out->size() == entry->returnTypes.size());
-        vector<EReturn> returns;
-        for (size_t i = 0; i < entry->returnTypes.size(); ++i) {
-            bool isRef = entry->returnIsRef[i];
-            TypePtr rt = entry->returnTypes[i];
-            EValuePtr ev = out->values[i];
-            returns.push_back(EReturn(isRef, rt, ev));
-        }
+    assert(out->size() == entry->returnTypes.size());
+    vector<EReturn> returns;
+    for (size_t i = 0; i < entry->returnTypes.size(); ++i) {
+        bool isRef = entry->returnIsRef[i];
+        TypePtr rt = entry->returnTypes[i];
+        EValuePtr ev = out->values[i];
+        returns.push_back(EReturn(isRef, rt, ev));
+    }
 
-        if (entry->code->hasReturnSpecs()) {
-            llvm::ArrayRef<ReturnSpecPtr> returnSpecs = entry->code->returnSpecs;
-            size_t i = 0;
-            for (; i < returnSpecs.size(); ++i) {
-                ReturnSpecPtr rspec = returnSpecs[i];
-                if (rspec->name.ptr())
-                    addLocal(env, rspec->name, returns[i].value.ptr());
-            }
-            ReturnSpecPtr varReturnSpec = entry->code->varReturnSpec;
-            if (!varReturnSpec)
-                assert(i == entry->returnTypes.size());
-            if (varReturnSpec.ptr() && varReturnSpec->name.ptr()) {
-                MultiEValuePtr mev = new MultiEValue();
-                for (; i < entry->returnTypes.size(); ++i)
-                    mev->add(returns[i].value);
-                addLocal(env, varReturnSpec->name, mev.ptr());
-            }
+    if (entry->code->hasReturnSpecs()) {
+        llvm::ArrayRef<ReturnSpecPtr> returnSpecs = entry->code->returnSpecs;
+        size_t i = 0;
+        for (; i < returnSpecs.size(); ++i) {
+            ReturnSpecPtr rspec = returnSpecs[i];
+            if (rspec->name.ptr())
+                addLocal(env, rspec->name, returns[i].value.ptr());
         }
-
-        EvalContextPtr ctx = new EvalContext(returns);
-
-        assert(entry->code->body.ptr());
-        TerminationPtr term = evalStatement(entry->code->body, env, ctx);
-        if (term.ptr()) {
-            switch (term->terminationKind) {
-                case TERMINATE_RETURN:
-                    break;
-                case TERMINATE_BREAK:
-                    error(term, "invalid 'break' statement");
-                case TERMINATE_CONTINUE:
-                    error(term, "invalid 'continue' statement");
-                case TERMINATE_GOTO:
-                    error(term, "invalid 'goto' statement");
-                default:
-                    assert(false);
-            }
+        ReturnSpecPtr varReturnSpec = entry->code->varReturnSpec;
+        if (!varReturnSpec)
+            assert(i == entry->returnTypes.size());
+        if (varReturnSpec.ptr() && varReturnSpec->name.ptr()) {
+            MultiEValuePtr mev = new MultiEValue();
+            for (; i < entry->returnTypes.size(); ++i)
+                mev->add(returns[i].value);
+            addLocal(env, varReturnSpec->name, mev.ptr());
         }
     }
 
-    //
-    // evalCallCompiledCode
-    //
+    EvalContextPtr ctx = new EvalContext(returns);
 
-    void evalCallCompiledCode(InvokeEntry *entry,
-                              MultiEValuePtr args,
-                              MultiEValuePtr out) {
-        if (!entry->llvmFunc)
-            codegenCodeBody(entry);
-        assert(entry->llvmFunc);
-
-        vector<llvm::GenericValue> gvArgs;
-
-        for (size_t i = 0; i < args->size(); ++i) {
-            EValuePtr earg = args->values[i];
-            assert(earg->type == entry->argsKey[i]);
-            gvArgs.push_back(llvm::GenericValue(earg->addr));
+    assert(entry->code->body.ptr());
+    TerminationPtr term = evalStatement(entry->code->body, env, ctx);
+    if (term.ptr()) {
+        switch (term->terminationKind) {
+        case TERMINATE_RETURN:
+            break;
+        case TERMINATE_BREAK:
+            error(term, "invalid 'break' statement");
+        case TERMINATE_CONTINUE:
+            error(term, "invalid 'continue' statement");
+        case TERMINATE_GOTO:
+            error(term, "invalid 'goto' statement");
+        default:
+            assert(false);
         }
-
-        assert(out->size() == entry->returnTypes.size());
-        for (size_t i = 0; i < entry->returnTypes.size(); ++i) {
-            TypePtr t = entry->returnTypes[i];
-            EValuePtr ev = out->values[i];
-            if (entry->returnIsRef[i]) {
-                assert(ev->type == pointerType(t));
-                gvArgs.push_back(llvm::GenericValue(out->values[i]->addr));
-            } else {
-                assert(ev->type == t);
-                gvArgs.push_back(llvm::GenericValue(out->values[i]->addr));
-            }
-        }
-        error("calling compiled code is not supported in the evaluator");
     }
+}
 
-    //
-    // evalCallByName
-    //
-
-    void evalCallByName(InvokeEntry *entry,
-                        ExprPtr callable,
-                        ExprListPtr args,
-                        EnvPtr env,
-                        MultiEValuePtr out) {
-        assert(entry->callByName);
-        if (entry->varArgName.ptr())
-            assert(args->size() >= entry->fixedArgNames.size());
-        else
-            assert(args->size() == entry->fixedArgNames.size());
+//
+// evalCallCompiledCode
+//
 
-        EnvPtr bodyEnv = new Env(entry->env);
-        bodyEnv->callByNameExprHead = callable;
+void evalCallCompiledCode(InvokeEntry *entry, MultiEValuePtr args,
+                          MultiEValuePtr out) {
+    if (!entry->llvmFunc)
+        codegenCodeBody(entry);
+    assert(entry->llvmFunc);
 
-        unsigned i = 0, j = 0;
-        for (; i < entry->varArgPosition; ++i) {
-            ExprPtr expr = foreignExpr(env, args->exprs[i]);
-            addLocal(bodyEnv, entry->fixedArgNames[i], expr.ptr());
-        }
-        if (entry->varArgName.ptr()) {
-            ExprListPtr varArgs = new ExprList();
-            for (; j < args->size() - entry->fixedArgNames.size(); ++j) {
-                ExprPtr expr = foreignExpr(env, args->exprs[i + j]);
-                varArgs->add(expr);
-            }
-            addLocal(bodyEnv, entry->varArgName, varArgs.ptr());
-            for (; i < entry->fixedArgNames.size(); ++i) {
-                ExprPtr expr = foreignExpr(env, args->exprs[i + j]);
-                addLocal(bodyEnv, entry->fixedArgNames[i], expr.ptr());
-            }
-        }
+    vector<llvm::GenericValue> gvArgs;
 
-        MultiPValuePtr mpv = safeAnalyzeCallByName(entry, callable, args, env);
-        assert(mpv->size() == out->size());
+    for (size_t i = 0; i < args->size(); ++i) {
+        EValuePtr earg = args->values[i];
+        assert(earg->type == entry->argsKey[i]);
+        gvArgs.emplace_back(earg->addr);
+    }
 
-        vector<EReturn> returns;
-        for (unsigned i = 0; i < mpv->size(); ++i) {
-            PVData const &pv = mpv->values[i];
-            EValuePtr ev = out->values[i];
-            if (pv.isRValue)
-                assert(ev->type == pv.type);
-            else
-                assert(ev->type == pointerType(pv.type));
-            returns.push_back(EReturn(!pv.isRValue, pv.type, ev));
+    assert(out->size() == entry->returnTypes.size());
+    for (size_t i = 0; i < entry->returnTypes.size(); ++i) {
+        TypePtr t = entry->returnTypes[i];
+        EValuePtr ev = out->values[i];
+        if (entry->returnIsRef[i]) {
+            assert(ev->type == pointerType(t));
+            gvArgs.emplace_back(out->values[i]->addr);
+        } else {
+            assert(ev->type == t);
+            gvArgs.emplace_back(out->values[i]->addr);
         }
+    }
+    error("calling compiled code is not supported in the evaluator");
+}
 
-        if (entry->code->hasReturnSpecs()) {
-            llvm::ArrayRef<ReturnSpecPtr> returnSpecs = entry->code->returnSpecs;
-            size_t i = 0;
-            for (; i < returnSpecs.size(); ++i) {
-                ReturnSpecPtr rspec = returnSpecs[i];
-                if (rspec->name.ptr())
-                    addLocal(bodyEnv, rspec->name, returns[i].value.ptr());
-            }
-            ReturnSpecPtr varReturnSpec = entry->code->varReturnSpec;
-            if (!varReturnSpec)
-                assert(i == mpv->size());
-            if (varReturnSpec.ptr() && varReturnSpec->name.ptr()) {
-                MultiEValuePtr mev = new MultiEValue();
-                for (; i < mpv->size(); ++i)
-                    mev->add(returns[i].value);
-                addLocal(bodyEnv, varReturnSpec->name, mev.ptr());
-            }
+//
+// evalCallByName
+//
+
+void evalCallByName(InvokeEntry *entry, ExprPtr callable, ExprListPtr args,
+                    EnvPtr env, MultiEValuePtr out) {
+    assert(entry->callByName);
+    if (entry->varArgName.ptr())
+        assert(args->size() >= entry->fixedArgNames.size());
+    else
+        assert(args->size() == entry->fixedArgNames.size());
+
+    EnvPtr bodyEnv = new Env(entry->env);
+    bodyEnv->callByNameExprHead = callable;
+
+    unsigned i = 0, j = 0;
+    for (; i < entry->varArgPosition; ++i) {
+        ExprPtr expr = foreignExpr(env, args->exprs[i]);
+        addLocal(bodyEnv, entry->fixedArgNames[i], expr.ptr());
+    }
+    if (entry->varArgName.ptr()) {
+        ExprListPtr varArgs = new ExprList();
+        for (; j < args->size() - entry->fixedArgNames.size(); ++j) {
+            ExprPtr expr = foreignExpr(env, args->exprs[i + j]);
+            varArgs->add(expr);
+        }
+        addLocal(bodyEnv, entry->varArgName, varArgs.ptr());
+        for (; i < entry->fixedArgNames.size(); ++i) {
+            ExprPtr expr = foreignExpr(env, args->exprs[i + j]);
+            addLocal(bodyEnv, entry->fixedArgNames[i], expr.ptr());
         }
+    }
 
-        EvalContextPtr ctx = new EvalContext(returns);
+    MultiPValuePtr mpv = safeAnalyzeCallByName(entry, callable, args, env);
+    assert(mpv->size() == out->size());
 
-        assert(entry->code->body.ptr());
-        TerminationPtr term = evalStatement(entry->code->body, bodyEnv, ctx);
-        if (term.ptr()) {
-            switch (term->terminationKind) {
-                case TERMINATE_RETURN:
-                    break;
-                case TERMINATE_BREAK:
-                    error(term, "invalid 'break' statement");
-                case TERMINATE_CONTINUE:
-                    error(term, "invalid 'continue' statement");
-                case TERMINATE_GOTO:
-                    error(term, "invalid 'goto' statement");
-                default:
-                    assert(false);
-            }
+    vector<EReturn> returns;
+    for (unsigned i = 0; i < mpv->size(); ++i) {
+        PVData const &pv = mpv->values[i];
+        EValuePtr ev = out->values[i];
+        if (pv.isRValue)
+            assert(ev->type == pv.type);
+        else
+            assert(ev->type == pointerType(pv.type));
+        returns.push_back(EReturn(!pv.isRValue, pv.type, ev));
+    }
+
+    if (entry->code->hasReturnSpecs()) {
+        llvm::ArrayRef<ReturnSpecPtr> returnSpecs = entry->code->returnSpecs;
+        size_t i = 0;
+        for (; i < returnSpecs.size(); ++i) {
+            ReturnSpecPtr rspec = returnSpecs[i];
+            if (rspec->name.ptr())
+                addLocal(bodyEnv, rspec->name, returns[i].value.ptr());
+        }
+        ReturnSpecPtr varReturnSpec = entry->code->varReturnSpec;
+        if (!varReturnSpec)
+            assert(i == mpv->size());
+        if (varReturnSpec.ptr() && varReturnSpec->name.ptr()) {
+            MultiEValuePtr mev = new MultiEValue();
+            for (; i < mpv->size(); ++i)
+                mev->add(returns[i].value);
+            addLocal(bodyEnv, varReturnSpec->name, mev.ptr());
+        }
+    }
+
+    EvalContextPtr ctx = new EvalContext(returns);
+
+    assert(entry->code->body.ptr());
+    TerminationPtr term = evalStatement(entry->code->body, bodyEnv, ctx);
+    if (term.ptr()) {
+        switch (term->terminationKind) {
+        case TERMINATE_RETURN:
+            break;
+        case TERMINATE_BREAK:
+            error(term, "invalid 'break' statement");
+        case TERMINATE_CONTINUE:
+            error(term, "invalid 'continue' statement");
+        case TERMINATE_GOTO:
+            error(term, "invalid 'goto' statement");
+        default:
+            assert(false);
         }
     }
+}
 
-    //
-    // evalStatement
-    //
+//
+// evalStatement
+//
 
-    static EnvPtr evalStatementExpressionStatements(llvm::ArrayRef<StatementPtr> stmts,
-                                                    EnvPtr env,
-                                                    EvalContextPtr ctx) {
-        EnvPtr env2 = env;
+static EnvPtr
+evalStatementExpressionStatements(llvm::ArrayRef<StatementPtr> stmts,
+                                  EnvPtr env, EvalContextPtr ctx) {
+    EnvPtr env2 = env;
 
-        for (StatementPtr const *i = stmts.begin(), *end = stmts.end();
-             i != end;
-             ++i) {
-            switch ((*i)->stmtKind) {
-                case BINDING: {
-                    env2 = evalBinding((Binding *) i->ptr(), env2);
-                    break;
-                }
+    for (StatementPtr const *i = stmts.begin(), *end = stmts.end(); i != end;
+         ++i) {
+        switch ((*i)->stmtKind) {
+        case BINDING: {
+            env2 = evalBinding((Binding *)i->ptr(), env2);
+            break;
+        }
 
-                case ASSIGNMENT:
-                case VARIADIC_ASSIGNMENT:
-                case INIT_ASSIGNMENT:
-                case EXPR_STATEMENT: {
-                    TerminationPtr term = evalStatement(*i, env2, ctx);
-                    assert(term == nullptr);
-                    break;
-                }
+        case ASSIGNMENT:
+        case VARIADIC_ASSIGNMENT:
+        case INIT_ASSIGNMENT:
+        case EXPR_STATEMENT: {
+            TerminationPtr term = evalStatement(*i, env2, ctx);
+            assert(term == nullptr);
+            break;
+        }
 
-                default:
-                    assert(false);
-                    return nullptr;
-            }
+        default:
+            assert(false);
+            return nullptr;
         }
-        return env2;
     }
+    return env2;
+}
 
-    TerminationPtr evalStatement(StatementPtr stmt,
-                                 EnvPtr env,
-                                 EvalContextPtr ctx) {
-        LocationContext loc(stmt->location);
-
-        switch (stmt->stmtKind) {
-            case BLOCK: {
-                Block *x = (Block *) stmt.ptr();
-                unsigned blockMarker = evalMarkStack();
-                llvm::StringMap<LabelInfo> labels;
-                evalCollectLabels(x->statements, 0, env, labels);
-                TerminationPtr termination;
-                unsigned pos = 0;
-                while (pos < x->statements.size()) {
-                    StatementPtr y = x->statements[pos];
-                    if (y->stmtKind == LABEL) {
-                    } else if (y->stmtKind == BINDING) {
-                        env = evalBinding((Binding *) y.ptr(), env);
-                        evalCollectLabels(x->statements, pos + 1, env, labels);
-                    } else {
-                        termination = evalStatement(y, env, ctx);
-                        if (termination.ptr()) {
-                            if (termination->terminationKind == TERMINATE_GOTO) {
-                                TerminateGoto *z = (TerminateGoto *) termination.ptr();
-                                if (labels.count(z->targetLabel->str)) {
-                                    LabelInfo &info = labels[z->targetLabel->str];
-                                    env = info.env;
-                                    evalDestroyAndPopStack(info.stackMarker);
-                                    pos = info.blockPosition;
-                                    termination = nullptr;
-                                    continue;
-                                }
-                            }
-                            break;
-                        }
-                    }
-                    ++pos;
-                }
-                evalDestroyAndPopStack(blockMarker);
-                return termination;
-            }
-
-            case LABEL:
-                error("invalid label. labels can only appear within blocks");
-                return nullptr;
-
-            case BINDING:
-                error("invalid binding. bindings can only appear within blocks");
-                return nullptr;
-
-            case ASSIGNMENT: {
-                Assignment *x = (Assignment *) stmt.ptr();
-                MultiPValuePtr mpvLeft = safeAnalyzeMulti(x->left, env, 0);
-                MultiPValuePtr mpvRight = safeAnalyzeMulti(x->right, env, mpvLeft->size());
-                if (mpvLeft->size() != mpvRight->size())
-                    arityMismatchError(mpvLeft->size(), mpvRight->size(), /*hasVarArg=*/false);
-                for (unsigned i = 0; i < mpvLeft->size(); ++i) {
-                    if (mpvLeft->values[i].isRValue)
-                        argumentError(i, "cannot assign to a temporary");
-                }
-                unsigned marker = evalMarkStack();
-                if (mpvLeft->size() == 1) {
-                    ExprListPtr args = new ExprList();
-                    args->add(x->left);
-                    args->add(x->right);
-                    ExprPtr assignCall = new Call(operator_expr_assign(), args);
-                    evalExprAsRef(assignCall, env);
-                } else {
-                    MultiEValuePtr mevRight = new MultiEValue();
-                    for (unsigned i = 0; i < mpvRight->size(); ++i) {
-                        PVData const &pv = mpvRight->values[i];
-                        EValuePtr ev = evalAllocValue(pv.type);
-                        mevRight->add(ev);
-                    }
-                    evalMultiInto(x->right, env, mevRight, mpvLeft->size());
-                    MultiEValuePtr mevLeft = evalMultiAsRef(x->left, env);
-                    assert(mevLeft->size() == mevRight->size());
-                    for (size_t i = 0; i < mevLeft->size(); ++i) {
-                        EValuePtr evLeft = mevLeft->values[i];
-                        EValuePtr evRight = mevRight->values[i];
-                        evalValueMoveAssign(evLeft, evRight);
-                    }
-                }
-                evalDestroyAndPopStack(marker);
-                return nullptr;
-            }
-
-            case INIT_ASSIGNMENT: {
-                InitAssignment *x = (InitAssignment *) stmt.ptr();
-                MultiPValuePtr mpvLeft = safeAnalyzeMulti(x->left, env, 0);
-                MultiPValuePtr mpvRight = safeAnalyzeMulti(x->right, env, mpvLeft->size());
-                if (mpvLeft->size() != mpvRight->size())
-                    arityMismatchError(mpvLeft->size(), mpvRight->size(), /*hasVarArg=*/false);
-                for (unsigned i = 0; i < mpvLeft->size(); ++i) {
-                    if (mpvLeft->values[i].isRValue)
-                        argumentError(i, "cannot assign to a temporary");
-                    if (mpvLeft->values[i].type != mpvRight->values[i].type) {
-                        argumentTypeError(i,
-                                          mpvLeft->values[i].type,
-                                          mpvRight->values[i].type);
-                    }
-                }
-                unsigned marker = evalMarkStack();
-                MultiEValuePtr mevLeft = evalMultiAsRef(x->left, env);
-                evalMultiInto(x->right, env, mevLeft, mpvLeft->size());
-                evalDestroyAndPopStack(marker);
-                return nullptr;
-            }
-
-            case VARIADIC_ASSIGNMENT: {
-                VariadicAssignment *x = (VariadicAssignment *) stmt.ptr();
-                PVData pvLeft = safeAnalyzeOne(x->exprs->exprs[1], env);
-                if (pvLeft.isRValue)
-                    error(x->exprs->exprs[1], "cannot assign to a temporary");
-                CallPtr call;
-                if (x->op == PREFIX_OP)
-                    call = new Call(operator_expr_prefixUpdateAssign(), new ExprList());
-                else
-                    call = new Call(operator_expr_updateAssign(), new ExprList());
-                call->parenArgs->add(x->exprs);
-                return evalStatement(new ExprStatement(call.ptr()), env, ctx);
-            }
-
-            case GOTO: {
-                Goto *x = (Goto *) stmt.ptr();
-                return new TerminateGoto(x->labelName, x->location);
-            }
-
-            case RETURN: {
-                Return *x = (Return *) stmt.ptr();
-                size_t wantCount = x->isReturnSpecs ? 1 : 0;
-                MultiPValuePtr mpv = safeAnalyzeMulti(x->values, env, wantCount);
-                MultiEValuePtr mev = new MultiEValue();
-                ensureArity(mpv, ctx->returns.size());
-                for (unsigned i = 0; i < mpv->size(); ++i) {
-                    PVData const &pv = mpv->values[i];
-                    bool byRef = returnKindToByRef(x->returnKind, pv);
-                    EReturn &y = ctx->returns[i];
-                    if (y.type != pv.type)
-                        argumentTypeError(i, y.type, pv.type);
-                    if (byRef != y.byRef)
-                        argumentError(i, "mismatching by-ref and by-value returns");
-                    if (byRef && pv.isRValue)
-                        argumentError(i, "cannot return a temporary by reference");
-                    mev->add(y.value);
-                }
-                unsigned marker = evalMarkStack();
-                switch (x->returnKind) {
-                    case RETURN_VALUE:
-                        evalMultiInto(x->values, env, mev, wantCount);
-                        break;
-                    case RETURN_REF: {
-                        MultiEValuePtr mevRef = evalMultiAsRef(x->values, env);
-                        assert(mev->size() == mevRef->size());
-                        for (size_t i = 0; i < mev->size(); ++i) {
-                            EValuePtr evPtr = mev->values[i];
-                            EValuePtr evRef = mevRef->values[i];
-                            evPtr->as<void *>() = (void *) evRef->addr;
+TerminationPtr evalStatement(StatementPtr stmt, EnvPtr env,
+                             EvalContextPtr ctx) {
+    LocationContext loc(stmt->location);
+
+    switch (stmt->stmtKind) {
+    case BLOCK: {
+        Block *x = (Block *)stmt.ptr();
+        unsigned blockMarker = evalMarkStack();
+        llvm::StringMap<LabelInfo> labels;
+        evalCollectLabels(x->statements, 0, env, labels);
+        TerminationPtr termination;
+        unsigned pos = 0;
+        while (pos < x->statements.size()) {
+            StatementPtr y = x->statements[pos];
+            if (y->stmtKind == LABEL) {
+            } else if (y->stmtKind == BINDING) {
+                env = evalBinding((Binding *)y.ptr(), env);
+                evalCollectLabels(x->statements, pos + 1, env, labels);
+            } else {
+                termination = evalStatement(y, env, ctx);
+                if (termination.ptr()) {
+                    if (termination->terminationKind == TERMINATE_GOTO) {
+                        TerminateGoto *z = (TerminateGoto *)termination.ptr();
+                        if (labels.count(z->targetLabel->str)) {
+                            LabelInfo &info = labels[z->targetLabel->str];
+                            env = info.env;
+                            evalDestroyAndPopStack(info.stackMarker);
+                            pos = info.blockPosition;
+                            termination = nullptr;
+                            continue;
                         }
-                        break;
                     }
-                    case RETURN_FORWARD:
-                        evalMulti(x->values, env, mev, wantCount);
-                        break;
-                    default:
-                        assert(false);
+                    break;
                 }
-                evalDestroyAndPopStack(marker);
-                return new TerminateReturn(x->location);
             }
+            ++pos;
+        }
+        evalDestroyAndPopStack(blockMarker);
+        return termination;
+    }
+
+    case LABEL:
+        error("invalid label. labels can only appear within blocks");
+        return nullptr;
+
+    case BINDING:
+        error("invalid binding. bindings can only appear within blocks");
+        return nullptr;
+
+    case ASSIGNMENT: {
+        Assignment *x = (Assignment *)stmt.ptr();
+        MultiPValuePtr mpvLeft = safeAnalyzeMulti(x->left, env, 0);
+        MultiPValuePtr mpvRight =
+            safeAnalyzeMulti(x->right, env, mpvLeft->size());
+        if (mpvLeft->size() != mpvRight->size())
+            arityMismatchError(mpvLeft->size(), mpvRight->size(),
+                               /*hasVarArg=*/false);
+        for (unsigned i = 0; i < mpvLeft->size(); ++i) {
+            if (mpvLeft->values[i].isRValue)
+                argumentError(i, "cannot assign to a temporary");
+        }
+        unsigned marker = evalMarkStack();
+        if (mpvLeft->size() == 1) {
+            ExprListPtr args = new ExprList();
+            args->add(x->left);
+            args->add(x->right);
+            ExprPtr assignCall = new Call(operator_expr_assign(), args);
+            evalExprAsRef(assignCall, env);
+        } else {
+            MultiEValuePtr mevRight = new MultiEValue();
+            for (unsigned i = 0; i < mpvRight->size(); ++i) {
+                PVData const &pv = mpvRight->values[i];
+                EValuePtr ev = evalAllocValue(pv.type);
+                mevRight->add(ev);
+            }
+            evalMultiInto(x->right, env, mevRight, mpvLeft->size());
+            MultiEValuePtr mevLeft = evalMultiAsRef(x->left, env);
+            assert(mevLeft->size() == mevRight->size());
+            for (size_t i = 0; i < mevLeft->size(); ++i) {
+                EValuePtr evLeft = mevLeft->values[i];
+                EValuePtr evRight = mevRight->values[i];
+                evalValueMoveAssign(evLeft, evRight);
+            }
+        }
+        evalDestroyAndPopStack(marker);
+        return nullptr;
+    }
+
+    case INIT_ASSIGNMENT: {
+        InitAssignment *x = (InitAssignment *)stmt.ptr();
+        MultiPValuePtr mpvLeft = safeAnalyzeMulti(x->left, env, 0);
+        MultiPValuePtr mpvRight =
+            safeAnalyzeMulti(x->right, env, mpvLeft->size());
+        if (mpvLeft->size() != mpvRight->size())
+            arityMismatchError(mpvLeft->size(), mpvRight->size(),
+                               /*hasVarArg=*/false);
+        for (unsigned i = 0; i < mpvLeft->size(); ++i) {
+            if (mpvLeft->values[i].isRValue)
+                argumentError(i, "cannot assign to a temporary");
+            if (mpvLeft->values[i].type != mpvRight->values[i].type) {
+                argumentTypeError(i, mpvLeft->values[i].type,
+                                  mpvRight->values[i].type);
+            }
+        }
+        unsigned marker = evalMarkStack();
+        MultiEValuePtr mevLeft = evalMultiAsRef(x->left, env);
+        evalMultiInto(x->right, env, mevLeft, mpvLeft->size());
+        evalDestroyAndPopStack(marker);
+        return nullptr;
+    }
+
+    case VARIADIC_ASSIGNMENT: {
+        VariadicAssignment *x = (VariadicAssignment *)stmt.ptr();
+        PVData pvLeft = safeAnalyzeOne(x->exprs->exprs[1], env);
+        if (pvLeft.isRValue)
+            error(x->exprs->exprs[1], "cannot assign to a temporary");
+        CallPtr call;
+        if (x->op == PREFIX_OP)
+            call = new Call(operator_expr_prefixUpdateAssign(), new ExprList());
+        else
+            call = new Call(operator_expr_updateAssign(), new ExprList());
+        call->parenArgs->add(x->exprs);
+        return evalStatement(new ExprStatement(call.ptr()), env, ctx);
+    }
 
-            case IF: {
-                If *x = (If *) stmt.ptr();
-
-                unsigned scopeMarker = evalMarkStack();
+    case GOTO: {
+        Goto *x = (Goto *)stmt.ptr();
+        return new TerminateGoto(x->labelName, x->location);
+    }
 
-                EnvPtr env2 = evalStatementExpressionStatements(x->conditionStatements, env, ctx);
+    case RETURN: {
+        Return *x = (Return *)stmt.ptr();
+        size_t wantCount = x->isReturnSpecs ? 1 : 0;
+        MultiPValuePtr mpv = safeAnalyzeMulti(x->values, env, wantCount);
+        MultiEValuePtr mev = new MultiEValue();
+        ensureArity(mpv, ctx->returns.size());
+        for (unsigned i = 0; i < mpv->size(); ++i) {
+            PVData const &pv = mpv->values[i];
+            bool byRef = returnKindToByRef(x->returnKind, pv);
+            EReturn &y = ctx->returns[i];
+            if (y.type != pv.type)
+                argumentTypeError(i, y.type, pv.type);
+            if (byRef != y.byRef)
+                argumentError(i, "mismatching by-ref and by-value returns");
+            if (byRef && pv.isRValue)
+                argumentError(i, "cannot return a temporary by reference");
+            mev->add(y.value);
+        }
+        unsigned marker = evalMarkStack();
+        switch (x->returnKind) {
+        case RETURN_VALUE:
+            evalMultiInto(x->values, env, mev, wantCount);
+            break;
+        case RETURN_REF: {
+            MultiEValuePtr mevRef = evalMultiAsRef(x->values, env);
+            assert(mev->size() == mevRef->size());
+            for (size_t i = 0; i < mev->size(); ++i) {
+                EValuePtr evPtr = mev->values[i];
+                EValuePtr evRef = mevRef->values[i];
+                evPtr->as<void *>() = (void *)evRef->addr;
+            }
+            break;
+        }
+        case RETURN_FORWARD:
+            evalMulti(x->values, env, mev, wantCount);
+            break;
+        default:
+            assert(false);
+        }
+        evalDestroyAndPopStack(marker);
+        return new TerminateReturn(x->location);
+    }
+
+    case IF: {
+        If *x = (If *)stmt.ptr();
+
+        unsigned scopeMarker = evalMarkStack();
+
+        EnvPtr env2 =
+            evalStatementExpressionStatements(x->conditionStatements, env, ctx);
+
+        unsigned tempMarker = evalMarkStack();
+        EValuePtr ev = evalOneAsRef(x->condition, env2);
+        bool flag = evalToBoolFlag(ev, true);
+        evalDestroyAndPopStack(tempMarker);
+        if (flag)
+            return evalStatement(x->thenPart, env2, ctx);
+        if (x->elsePart.ptr())
+            return evalStatement(x->elsePart, env2, ctx);
+
+        evalDestroyAndPopStack(scopeMarker);
+
+        return nullptr;
+    }
+
+    case SWITCH: {
+        Switch *x = (Switch *)stmt.ptr();
+        if (!x->desugared)
+            x->desugared = desugarSwitchStatement(x);
+        return evalStatement(x->desugared, env, ctx);
+    }
+
+    case EVAL_STATEMENT: {
+        EvalStatement *eval = (EvalStatement *)stmt.ptr();
+        llvm::ArrayRef<StatementPtr> evaled = desugarEvalStatement(eval, env);
+        TerminationPtr termination;
+        for (size_t i = 0; i < evaled.size(); ++i) {
+            termination = evalStatement(evaled[i], env, ctx);
+            if (termination != nullptr)
+                return termination;
+        }
+        return nullptr;
+    }
 
-                unsigned tempMarker = evalMarkStack();
-                EValuePtr ev = evalOneAsRef(x->condition, env2);
-                bool flag = evalToBoolFlag(ev, true);
-                evalDestroyAndPopStack(tempMarker);
-                if (flag)
-                    return evalStatement(x->thenPart, env2, ctx);
-                if (x->elsePart.ptr())
-                    return evalStatement(x->elsePart, env2, ctx);
+    case EXPR_STATEMENT: {
+        ExprStatement *x = (ExprStatement *)stmt.ptr();
+        unsigned marker = evalMarkStack();
+        evalExprAsRef(x->expr, env);
+        evalDestroyAndPopStack(marker);
+        return nullptr;
+    }
 
-                evalDestroyAndPopStack(scopeMarker);
+    case WHILE: {
+        While *x = (While *)stmt.ptr();
 
-                return nullptr;
-            }
+        unsigned scopeMarker = evalMarkStack();
 
-            case SWITCH: {
-                Switch *x = (Switch *) stmt.ptr();
-                if (!x->desugared)
-                    x->desugared = desugarSwitchStatement(x);
-                return evalStatement(x->desugared, env, ctx);
-            }
+        while (true) {
+            EnvPtr env2 = evalStatementExpressionStatements(
+                x->conditionStatements, env, ctx);
 
-            case EVAL_STATEMENT: {
-                EvalStatement *eval = (EvalStatement *) stmt.ptr();
-                llvm::ArrayRef<StatementPtr> evaled = desugarEvalStatement(eval, env);
-                TerminationPtr termination;
-                for (size_t i = 0; i < evaled.size(); ++i) {
-                    termination = evalStatement(evaled[i], env, ctx);
-                    if (termination != nullptr)
-                        return termination;
-                }
-                return nullptr;
-            }
+            unsigned tempMarker = evalMarkStack();
+            EValuePtr ev = evalOneAsRef(x->condition, env2);
+            bool flag = evalToBoolFlag(ev, false);
+            evalDestroyAndPopStack(tempMarker);
 
-            case EXPR_STATEMENT: {
-                ExprStatement *x = (ExprStatement *) stmt.ptr();
-                unsigned marker = evalMarkStack();
-                evalExprAsRef(x->expr, env);
-                evalDestroyAndPopStack(marker);
-                return nullptr;
+            if (!flag)
+                break;
+            TerminationPtr term = evalStatement(x->body, env2, ctx);
+            if (term.ptr()) {
+                if (term->terminationKind == TERMINATE_BREAK)
+                    break;
+                if (term->terminationKind == TERMINATE_CONTINUE)
+                    goto whileContinue;
+                return term;
             }
+        whileContinue:
+            evalDestroyStack(scopeMarker);
+        }
+        evalDestroyAndPopStack(scopeMarker);
 
-            case WHILE: {
-                While *x = (While *) stmt.ptr();
-
-                unsigned scopeMarker = evalMarkStack();
-
-                while (true) {
-                    EnvPtr env2 = evalStatementExpressionStatements(x->conditionStatements, env, ctx);
-
-                    unsigned tempMarker = evalMarkStack();
-                    EValuePtr ev = evalOneAsRef(x->condition, env2);
-                    bool flag = evalToBoolFlag(ev, false);
-                    evalDestroyAndPopStack(tempMarker);
-
-                    if (!flag) break;
-                    TerminationPtr term = evalStatement(x->body, env2, ctx);
-                    if (term.ptr()) {
-                        if (term->terminationKind == TERMINATE_BREAK)
-                            break;
-                        if (term->terminationKind == TERMINATE_CONTINUE)
-                            goto whileContinue;
-                        return term;
-                    }
-                whileContinue:
-                    evalDestroyStack(scopeMarker);
-                }
-                evalDestroyAndPopStack(scopeMarker);
+        return nullptr;
+    }
 
-                return nullptr;
-            }
+    case BREAK: {
+        return new TerminateBreak(stmt->location);
+    }
 
-            case BREAK: {
-                return new TerminateBreak(stmt->location);
-            }
+    case CONTINUE: {
+        return new TerminateContinue(stmt->location);
+    }
 
-            case CONTINUE: {
-                return new TerminateContinue(stmt->location);
-            }
+    case FOR: {
+        For *x = (For *)stmt.ptr();
+        if (!x->desugared)
+            x->desugared = desugarForStatement(x);
+        return evalStatement(x->desugared, env, ctx);
+    }
 
-            case FOR: {
-                For *x = (For *) stmt.ptr();
-                if (!x->desugared)
-                    x->desugared = desugarForStatement(x);
-                return evalStatement(x->desugared, env, ctx);
-            }
+    case FOREIGN_STATEMENT: {
+        ForeignStatement *x = (ForeignStatement *)stmt.ptr();
+        return evalStatement(x->statement, x->getEnv(), ctx);
+    }
 
-            case FOREIGN_STATEMENT: {
-                ForeignStatement *x = (ForeignStatement *) stmt.ptr();
-                return evalStatement(x->statement, x->getEnv(), ctx);
-            }
+    case TRY: {
+        Try *x = (Try *)stmt.ptr();
+        // exception handling not supported in the evaluator.
+        return evalStatement(x->tryBlock, env, ctx);
+    }
 
-            case TRY: {
-                Try *x = (Try *) stmt.ptr();
-                // exception handling not supported in the evaluator.
-                return evalStatement(x->tryBlock, env, ctx);
-            }
+    case THROW: {
+        error("throw statement not supported in the evaluator");
+        return nullptr;
+    }
 
-            case THROW: {
-                error("throw statement not supported in the evaluator");
-                return nullptr;
-            }
+    case STATIC_FOR: {
+        StaticFor *x = (StaticFor *)stmt.ptr();
+        MultiEValuePtr mev = evalForwardMultiAsRef(x->values, env);
+        initializeStaticForClones(x, mev->size());
+        for (size_t i = 0; i < mev->size(); ++i) {
+            EnvPtr env2 = new Env(env);
+            addLocal(env2, x->variable, mev->values[i].ptr());
+            TerminationPtr termination =
+                evalStatement(x->clonedBodies[i], env2, ctx);
+            if (termination.ptr())
+                return termination;
+        }
+        return nullptr;
+    }
 
-            case STATIC_FOR: {
-                StaticFor *x = (StaticFor *) stmt.ptr();
-                MultiEValuePtr mev = evalForwardMultiAsRef(x->values, env);
-                initializeStaticForClones(x, mev->size());
-                for (size_t i = 0; i < mev->size(); ++i) {
-                    EnvPtr env2 = new Env(env);
-                    addLocal(env2, x->variable, mev->values[i].ptr());
-                    TerminationPtr termination =
-                            evalStatement(x->clonedBodies[i], env2, ctx);
-                    if (termination.ptr())
-                        return termination;
-                }
-                return nullptr;
-            }
+    case ONERROR:
+    case FINALLY:
+        // exception handling not supported in the evaluator.
+        return nullptr;
 
-            case ONERROR:
-            case FINALLY:
-                // exception handling not supported in the evaluator.
-                return nullptr;
+    case UNREACHABLE: {
+        error("unreachable statement");
+        return nullptr;
+    }
 
-            case UNREACHABLE: {
-                error("unreachable statement");
-                return nullptr;
-            }
+    case STATIC_ASSERT_STATEMENT: {
+        StaticAssertStatement *x = (StaticAssertStatement *)stmt.ptr();
+        evaluateStaticAssert(x->location, x->cond, x->message, env);
+        return nullptr;
+    }
 
-            case STATIC_ASSERT_STATEMENT: {
-                StaticAssertStatement *x = (StaticAssertStatement *) stmt.ptr();
-                evaluateStaticAssert(x->location, x->cond, x->message, env);
-                return nullptr;
-            }
+    default:
+        assert(false);
+        return nullptr;
+    }
+}
 
-            default:
-                assert(false);
-                return nullptr;
+//
+// evalCollectLabels
+//
+
+void evalCollectLabels(llvm::ArrayRef<StatementPtr> statements,
+                       unsigned startIndex, EnvPtr env,
+                       llvm::StringMap<LabelInfo> &labels) {
+    for (unsigned i = startIndex; i < statements.size(); ++i) {
+        StatementPtr x = statements[i];
+        switch (x->stmtKind) {
+        case LABEL: {
+            Label *y = (Label *)x.ptr();
+            if (labels.count(y->name->str))
+                error(x, "label redefined");
+            labels[y->name->str] = LabelInfo(env, evalMarkStack(), i + 1);
+            break;
+        }
+        case BINDING:
+            return;
+        default:
+            break;
         }
     }
+}
 
-    //
-    // evalCollectLabels
-    //
-
-    void evalCollectLabels(llvm::ArrayRef<StatementPtr> statements,
-                           unsigned startIndex,
-                           EnvPtr env,
-                           llvm::StringMap<LabelInfo> &labels) {
-        for (unsigned i = startIndex; i < statements.size(); ++i) {
-            StatementPtr x = statements[i];
-            switch (x->stmtKind) {
-                case LABEL: {
-                    Label *y = (Label *) x.ptr();
-                    if (labels.count(y->name->str))
-                        error(x, "label redefined");
-                    labels[y->name->str] = LabelInfo(env, evalMarkStack(), i + 1);
-                    break;
+//
+// evalBinding
+//
+
+EnvPtr evalBinding(BindingPtr x, EnvPtr env) {
+    LocationContext loc(x->location);
+    switch (x->bindingKind) {
+    case VAR: {
+        MultiPValuePtr mpv = safeAnalyzeMulti(x->values, env, x->args.size());
+        if (x->hasVarArg) {
+            if (mpv->values.size() < x->args.size() - 1)
+                arityMismatchError(x->args.size() - 1, mpv->values.size(),
+                                   /*hasVarArg=*/true);
+        } else if (mpv->values.size() != x->args.size())
+            arityMismatchError(x->args.size(), mpv->values.size(),
+                               /*hasVarArg=*/false);
+        MultiEValuePtr mev = new MultiEValue();
+        for (unsigned i = 0; i < x->args.size(); ++i) {
+            EValuePtr ev = evalAllocValue(mpv->values[i].type);
+            mev->add(ev);
+        }
+        unsigned marker = evalMarkStack();
+        evalMultiInto(x->values, env, mev, x->args.size());
+        evalDestroyAndPopStack(marker);
+        EnvPtr env2 = new Env(env);
+        for (size_t i = 0; i < x->patternVars.size(); ++i)
+            addLocal(env2, x->patternVars[i].name, x->patternTypes[i]);
+        size_t varArgSize = mev->values.size() - x->args.size() + 1;
+        for (size_t i = 0, j = 0; i < x->args.size(); ++i) {
+            if (x->args[i]->varArg) {
+                MultiEValuePtr varArgs = new MultiEValue();
+                for (; j < varArgSize; ++j) {
+                    EValuePtr ev = mev->values[i + j];
+                    varArgs->add(ev);
                 }
-                case BINDING:
-                    return;
-                default:
-                    break;
-            }
+                --j;
+                addLocal(env2, x->args[i]->name, varArgs.ptr());
+            } else
+                addLocal(env2, x->args[i]->name, mev->values[i + j].ptr());
         }
+        return env2;
     }
 
-    //
-    // evalBinding
-    //
-
-    EnvPtr evalBinding(BindingPtr x, EnvPtr env) {
-        LocationContext loc(x->location);
-        switch (x->bindingKind) {
-            case VAR: {
-                MultiPValuePtr mpv = safeAnalyzeMulti(x->values, env, x->args.size());
-                if (x->hasVarArg) {
-                    if (mpv->values.size() < x->args.size() - 1)
-                        arityMismatchError(x->args.size() - 1, mpv->values.size(), /*hasVarArg=*/true);
-                } else if (mpv->values.size() != x->args.size())
-                    arityMismatchError(x->args.size(), mpv->values.size(), /*hasVarArg=*/false);
-                MultiEValuePtr mev = new MultiEValue();
-                for (unsigned i = 0; i < x->args.size(); ++i) {
-                    EValuePtr ev = evalAllocValue(mpv->values[i].type);
-                    mev->add(ev);
-                }
-                unsigned marker = evalMarkStack();
-                evalMultiInto(x->values, env, mev, x->args.size());
-                evalDestroyAndPopStack(marker);
-                EnvPtr env2 = new Env(env);
-                for (size_t i = 0; i < x->patternVars.size(); ++i)
-                    addLocal(env2, x->patternVars[i].name, x->patternTypes[i]);
-                size_t varArgSize = mev->values.size() - x->args.size() + 1;
-                for (size_t i = 0, j = 0; i < x->args.size(); ++i) {
-                    if (x->args[i]->varArg) {
-                        MultiEValuePtr varArgs = new MultiEValue();
-                        for (; j < varArgSize; ++j) {
-                            EValuePtr ev = mev->values[i + j];
-                            varArgs->add(ev);
-                        }
-                        --j;
-                        addLocal(env2, x->args[i]->name, varArgs.ptr());
-                    } else
-                        addLocal(env2, x->args[i]->name, mev->values[i + j].ptr());
+    case REF: {
+        MultiPValuePtr mpv = safeAnalyzeMulti(x->values, env, x->args.size());
+        if (x->hasVarArg) {
+            if (mpv->values.size() < x->args.size() - 1)
+                arityMismatchError(x->args.size() - 1, mpv->values.size(),
+                                   /*hasVarArg=*/true);
+        } else if (mpv->values.size() != x->args.size())
+            arityMismatchError(x->args.size(), mpv->values.size(),
+                               /*hasVarArg=*/false);
+        MultiEValuePtr mev = new MultiEValue();
+        for (unsigned i = 0; i < x->args.size(); ++i) {
+            PVData const &pv = mpv->values[i];
+            if (pv.isRValue)
+                argumentError(i, "ref can only bind to an rvalue");
+            EValuePtr evPtr = evalAllocValue(pointerType(pv.type));
+            mev->add(evPtr);
+        }
+        unsigned marker = evalMarkStack();
+        evalMulti(x->values, env, mev, x->args.size());
+        evalDestroyAndPopStack(marker);
+        EnvPtr env2 = new Env(env);
+        for (size_t i = 0; i < x->patternVars.size(); ++i)
+            addLocal(env2, x->patternVars[i].name, x->patternTypes[i]);
+        size_t varArgSize = mev->values.size() - x->args.size() + 1;
+        for (size_t i = 0, j = 0; i < x->args.size(); ++i) {
+            if (x->args[i]->varArg) {
+                MultiEValuePtr varArgs = new MultiEValue();
+                for (; j < varArgSize; ++j) {
+                    EValuePtr ev = derefValue(mev->values[i + j]);
+                    varArgs->add(ev);
                 }
-                return env2;
+                --j;
+                addLocal(env2, x->args[i]->name, varArgs.ptr());
+            } else {
+                EValuePtr evPtr = mev->values[i + j];
+                addLocal(env2, x->args[i]->name, derefValue(evPtr).ptr());
             }
+        }
 
-            case REF: {
-                MultiPValuePtr mpv = safeAnalyzeMulti(x->values, env, x->args.size());
-                if (x->hasVarArg) {
-                    if (mpv->values.size() < x->args.size() - 1)
-                        arityMismatchError(x->args.size() - 1, mpv->values.size(), /*hasVarArg=*/true);
-                } else if (mpv->values.size() != x->args.size())
-                    arityMismatchError(x->args.size(), mpv->values.size(), /*hasVarArg=*/false);
-                MultiEValuePtr mev = new MultiEValue();
-                for (unsigned i = 0; i < x->args.size(); ++i) {
-                    PVData const &pv = mpv->values[i];
-                    if (pv.isRValue)
-                        argumentError(i, "ref can only bind to an rvalue");
-                    EValuePtr evPtr = evalAllocValue(pointerType(pv.type));
-                    mev->add(evPtr);
-                }
-                unsigned marker = evalMarkStack();
-                evalMulti(x->values, env, mev, x->args.size());
-                evalDestroyAndPopStack(marker);
-                EnvPtr env2 = new Env(env);
-                for (size_t i = 0; i < x->patternVars.size(); ++i)
-                    addLocal(env2, x->patternVars[i].name, x->patternTypes[i]);
-                size_t varArgSize = mev->values.size() - x->args.size() + 1;
-                for (size_t i = 0, j = 0; i < x->args.size(); ++i) {
-                    if (x->args[i]->varArg) {
-                        MultiEValuePtr varArgs = new MultiEValue();
-                        for (; j < varArgSize; ++j) {
-                            EValuePtr ev = derefValue(mev->values[i + j]);
-                            varArgs->add(ev);
-                        }
-                        --j;
-                        addLocal(env2, x->args[i]->name, varArgs.ptr());
-                    } else {
-                        EValuePtr evPtr = mev->values[i + j];
-                        addLocal(env2, x->args[i]->name, derefValue(evPtr).ptr());
-                    }
-                }
-
-                return env2;
-            }
+        return env2;
+    }
 
-            case FORWARD: {
-                MultiPValuePtr mpv = safeAnalyzeMulti(x->values, env, x->args.size());
-                if (x->hasVarArg) {
-                    if (mpv->values.size() < x->args.size() - 1)
-                        arityMismatchError(x->args.size() - 1, mpv->values.size(), /*hasVarArg=*/true);
-                } else if (mpv->values.size() != x->args.size())
-                    arityMismatchError(x->args.size(), mpv->values.size(), /*hasVarArg=*/false);
-                MultiEValuePtr mev = new MultiEValue();
-                for (unsigned i = 0; i < x->args.size(); ++i) {
-                    PVData const &pv = mpv->values[i];
-                    mev->add(evalAllocValueForPValue(pv));
-                }
-                unsigned marker = evalMarkStack();
-                evalMulti(x->values, env, mev, x->args.size());
-                evalDestroyAndPopStack(marker);
-                EnvPtr env2 = new Env(env);
-                for (size_t i = 0; i < x->patternVars.size(); ++i)
-                    addLocal(env2, x->patternVars[i].name, x->patternTypes[i]);
-                size_t varArgSize = mev->values.size() - x->args.size() + 1;
-                for (unsigned i = 0, j = 0; i < x->args.size(); ++i) {
-                    if (x->args[i]->varArg) {
-                        MultiEValuePtr varArgs = new MultiEValue();
-                        for (; j < varArgSize; ++j) {
-                            EValuePtr rev, ev;
-                            rev = mev->values[i + j];
-                            if (mpv->values[i + j].isRValue) {
-                                ev = rev;
-                            } else {
-                                ev = derefValue(rev);
-                            }
-                            varArgs->add(ev);
-                        }
-                        --j;
-                        addLocal(env2, x->args[i]->name, varArgs.ptr());
+    case FORWARD: {
+        MultiPValuePtr mpv = safeAnalyzeMulti(x->values, env, x->args.size());
+        if (x->hasVarArg) {
+            if (mpv->values.size() < x->args.size() - 1)
+                arityMismatchError(x->args.size() - 1, mpv->values.size(),
+                                   /*hasVarArg=*/true);
+        } else if (mpv->values.size() != x->args.size())
+            arityMismatchError(x->args.size(), mpv->values.size(),
+                               /*hasVarArg=*/false);
+        MultiEValuePtr mev = new MultiEValue();
+        for (unsigned i = 0; i < x->args.size(); ++i) {
+            PVData const &pv = mpv->values[i];
+            mev->add(evalAllocValueForPValue(pv));
+        }
+        unsigned marker = evalMarkStack();
+        evalMulti(x->values, env, mev, x->args.size());
+        evalDestroyAndPopStack(marker);
+        EnvPtr env2 = new Env(env);
+        for (size_t i = 0; i < x->patternVars.size(); ++i)
+            addLocal(env2, x->patternVars[i].name, x->patternTypes[i]);
+        size_t varArgSize = mev->values.size() - x->args.size() + 1;
+        for (unsigned i = 0, j = 0; i < x->args.size(); ++i) {
+            if (x->args[i]->varArg) {
+                MultiEValuePtr varArgs = new MultiEValue();
+                for (; j < varArgSize; ++j) {
+                    EValuePtr rev, ev;
+                    rev = mev->values[i + j];
+                    if (mpv->values[i + j].isRValue) {
+                        ev = rev;
                     } else {
-                        if (mpv->values[i + j].isRValue) {
-                            EValuePtr ev = mev->values[i + j];
-                            addLocal(env2, x->args[i]->name, ev.ptr());
-                        } else {
-                            EValuePtr evPtr = mev->values[i + j];
-                            addLocal(env2, x->args[i]->name, derefValue(evPtr).ptr());
-                        }
+                        ev = derefValue(rev);
                     }
+                    varArgs->add(ev);
+                }
+                --j;
+                addLocal(env2, x->args[i]->name, varArgs.ptr());
+            } else {
+                if (mpv->values[i + j].isRValue) {
+                    EValuePtr ev = mev->values[i + j];
+                    addLocal(env2, x->args[i]->name, ev.ptr());
+                } else {
+                    EValuePtr evPtr = mev->values[i + j];
+                    addLocal(env2, x->args[i]->name, derefValue(evPtr).ptr());
                 }
-
-                return env2;
             }
+        }
 
-            case ALIAS: {
-                ensureArity(x->args, 1);
-                ensureArity(x->values->exprs, 1);
-                EnvPtr env2 = new Env(env);
-                ExprPtr y = foreignExpr(env, x->values->exprs[0]);
-                addLocal(env2, x->args[0]->name, y.ptr());
-                return env2;
-            }
+        return env2;
+    }
 
-            default: {
-                assert(false);
-                return nullptr;
-            }
-        }
+    case ALIAS: {
+        ensureArity(x->args, 1);
+        ensureArity(x->values->exprs, 1);
+        EnvPtr env2 = new Env(env);
+        ExprPtr y = foreignExpr(env, x->values->exprs[0]);
+        addLocal(env2, x->args[0]->name, y.ptr());
+        return env2;
+    }
+
+    default: {
+        assert(false);
+        return nullptr;
+    }
     }
 }
+} // namespace clay
diff --git a/compiler/evaluator.hpp b/compiler/evaluator.hpp
index 85658c3a..a6d6444c 100644
--- a/compiler/evaluator.hpp
+++ b/compiler/evaluator.hpp
@@ -3,101 +3,88 @@
 #include "clay.hpp"
 
 namespace clay {
-    // evaluation value
-    struct EValue : public Object {
-        TypePtr type;
-        char *addr;
-        bool forwardedRValue: 1;
-
-        EValue(TypePtr type, char *addr)
-            : Object(EVALUE), type(type), addr(addr),
-              forwardedRValue(false) {
-        }
-
-        EValue(TypePtr type, char *addr, bool forwardedRValue)
-            : Object(EVALUE), type(type), addr(addr),
-              forwardedRValue(forwardedRValue) {
-        }
-
-        template<typename T>
-        T &as() { return *(T *) addr; }
-
-        template<typename T>
-        T const &as() const { return *(T const *) addr; }
-    };
-
-    struct MultiEValue : public Object {
-        vector<EValuePtr> values;
-
-        MultiEValue()
-            : Object(MULTI_EVALUE) {
-        }
-
-        MultiEValue(EValuePtr pv)
-            : Object(MULTI_EVALUE) {
-            values.push_back(pv);
-        }
-
-        MultiEValue(llvm::ArrayRef<EValuePtr> values)
-            : Object(MULTI_EVALUE), values(values) {
-        }
-
-        size_t size() { return values.size(); }
-        void add(EValuePtr x) { values.push_back(x); }
-
-        void add(MultiEValuePtr x) {
-            values.insert(values.end(), x->values.begin(), x->values.end());
-        }
-    };
-
-    bool staticToType(ObjectPtr x, TypePtr &out);
-
-    TypePtr staticToType(MultiStaticPtr x, size_t index);
-
-    void evaluateReturnSpecs(llvm::ArrayRef<ReturnSpecPtr> returnSpecs,
-                             ReturnSpecPtr varReturnSpec,
-                             EnvPtr env,
-                             vector<uint8_t> &isRef,
-                             vector<TypePtr> &types);
-
-    MultiStaticPtr evaluateExprStatic(ExprPtr expr, EnvPtr env);
-    ObjectPtr evaluateOneStatic(ExprPtr expr, EnvPtr env);
-    MultiStaticPtr evaluateMultiStatic(ExprListPtr exprs, EnvPtr env);
-
-    TypePtr evaluateType(ExprPtr expr, EnvPtr env);
-    void evaluateMultiType(ExprListPtr exprs, EnvPtr env, vector<TypePtr> &out);
-    IdentifierPtr evaluateIdentifier(ExprPtr expr, EnvPtr env);
-    bool evaluateBool(ExprPtr expr, EnvPtr env);
-    void evaluatePredicate(llvm::ArrayRef<PatternVar> patternVars,
-                           ExprPtr expr, EnvPtr env);
-    void evaluateStaticAssert(Location const &location,
-                              const ExprPtr &cond, const ExprListPtr &message, EnvPtr env);
-
-    ValueHolderPtr intToValueHolder(int x);
-    ValueHolderPtr sizeTToValueHolder(size_t x);
-    ValueHolderPtr ptrDiffTToValueHolder(ptrdiff_t x);
-    ValueHolderPtr boolToValueHolder(bool x);
-
-    size_t valueHolderToSizeT(ValueHolderPtr vh);
-
-    ObjectPtr makeTupleValue(llvm::ArrayRef<ObjectPtr> elements);
-    ObjectPtr evalueToStatic(EValuePtr ev);
-
-    void evalValueInit(EValuePtr dest);
-    void evalValueDestroy(EValuePtr dest);
-    void evalValueCopy(EValuePtr dest, EValuePtr src);
-    void evalValueMove(EValuePtr dest, EValuePtr src);
-    void evalValueAssign(EValuePtr dest, EValuePtr src);
-    void evalValueMoveAssign(EValuePtr dest, EValuePtr src);
-    bool evalToBoolFlag(EValuePtr a, bool acceptStatics);
-    void evalValueForward(EValuePtr dest, EValuePtr src);
-    void evalStaticObject(ObjectPtr x, MultiEValuePtr out);
-
-    unsigned evalMarkStack();
-    void evalDestroyStack(unsigned marker);
-    void evalPopStack(unsigned marker);
-    void evalDestroyAndPopStack(unsigned marker);
-    EValuePtr evalAllocValue(TypePtr t);
-
-    EValuePtr evalOneAsRef(ExprPtr expr, EnvPtr env);
-}
+// evaluation value
+struct EValue : public Object {
+    TypePtr type;
+    char *addr;
+    bool forwardedRValue : 1;
+
+    EValue(TypePtr type, char *addr)
+        : Object(EVALUE), type(type), addr(addr), forwardedRValue(false) {}
+
+    EValue(TypePtr type, char *addr, bool forwardedRValue)
+        : Object(EVALUE), type(type), addr(addr),
+          forwardedRValue(forwardedRValue) {}
+
+    template <typename T> T &as() { return *(T *)addr; }
+
+    template <typename T> T const &as() const { return *(T const *)addr; }
+};
+
+struct MultiEValue : public Object {
+    vector<EValuePtr> values;
+
+    MultiEValue() : Object(MULTI_EVALUE) {}
+
+    MultiEValue(EValuePtr pv) : Object(MULTI_EVALUE) { values.push_back(pv); }
+
+    MultiEValue(llvm::ArrayRef<EValuePtr> values)
+        : Object(MULTI_EVALUE), values(values) {}
+
+    size_t size() { return values.size(); }
+    void add(EValuePtr x) { values.push_back(x); }
+
+    void add(MultiEValuePtr x) {
+        values.insert(values.end(), x->values.begin(), x->values.end());
+    }
+};
+
+bool staticToType(ObjectPtr x, TypePtr &out);
+
+TypePtr staticToType(MultiStaticPtr x, size_t index);
+
+void evaluateReturnSpecs(llvm::ArrayRef<ReturnSpecPtr> returnSpecs,
+                         ReturnSpecPtr varReturnSpec, EnvPtr env,
+                         vector<uint8_t> &isRef, vector<TypePtr> &types);
+
+MultiStaticPtr evaluateExprStatic(ExprPtr expr, EnvPtr env);
+ObjectPtr evaluateOneStatic(ExprPtr expr, EnvPtr env);
+MultiStaticPtr evaluateMultiStatic(ExprListPtr exprs, EnvPtr env);
+
+TypePtr evaluateType(ExprPtr expr, EnvPtr env);
+void evaluateMultiType(ExprListPtr exprs, EnvPtr env, vector<TypePtr> &out);
+IdentifierPtr evaluateIdentifier(ExprPtr expr, EnvPtr env);
+bool evaluateBool(ExprPtr expr, EnvPtr env);
+void evaluatePredicate(llvm::ArrayRef<PatternVar> patternVars, ExprPtr expr,
+                       EnvPtr env);
+void evaluateStaticAssert(Location const &location, const ExprPtr &cond,
+                          const ExprListPtr &message, EnvPtr env);
+
+ValueHolderPtr intToValueHolder(int x);
+ValueHolderPtr sizeTToValueHolder(size_t x);
+ValueHolderPtr ptrDiffTToValueHolder(ptrdiff_t x);
+ValueHolderPtr boolToValueHolder(bool x);
+
+size_t valueHolderToSizeT(ValueHolderPtr vh);
+
+ObjectPtr makeTupleValue(llvm::ArrayRef<ObjectPtr> elements);
+ObjectPtr evalueToStatic(EValuePtr ev);
+
+void evalValueInit(EValuePtr dest);
+void evalValueDestroy(EValuePtr dest);
+void evalValueCopy(EValuePtr dest, EValuePtr src);
+void evalValueMove(EValuePtr dest, EValuePtr src);
+void evalValueAssign(EValuePtr dest, EValuePtr src);
+void evalValueMoveAssign(EValuePtr dest, EValuePtr src);
+bool evalToBoolFlag(EValuePtr a, bool acceptStatics);
+void evalValueForward(EValuePtr dest, EValuePtr src);
+void evalStaticObject(ObjectPtr x, MultiEValuePtr out);
+
+unsigned evalMarkStack();
+void evalDestroyStack(unsigned marker);
+void evalPopStack(unsigned marker);
+void evalDestroyAndPopStack(unsigned marker);
+EValuePtr evalAllocValue(TypePtr t);
+
+EValuePtr evalOneAsRef(ExprPtr expr, EnvPtr env);
+} // namespace clay
diff --git a/compiler/evaluator_op.cpp b/compiler/evaluator_op.cpp
index 422e7b68..02f307aa 100644
--- a/compiler/evaluator_op.cpp
+++ b/compiler/evaluator_op.cpp
@@ -1,567 +1,595 @@
-#include "evaluator.hpp"
-#include "types.hpp"
-#include "error.hpp"
-#include "objects.hpp"
-#include "loader.hpp"
-#include "env.hpp"
 #include "analyzer.hpp"
+#include "env.hpp"
+#include "error.hpp"
+#include "evaluator.hpp"
 #include "int128.hpp"
+#include "loader.hpp"
+#include "objects.hpp"
+#include "types.hpp"
 
 #include "evaluator_op.hpp"
 
 namespace clay {
-    static llvm::StringMap<const void *> staticStringTableConstants;
-
-    static void setSizeTEValue(EValuePtr v, size_t x) {
-        switch (typeSize(cSizeTType)) {
-            case 4: *(size32_t *) v->addr = size32_t(x);
-                break;
-            case 8: *(size64_t *) v->addr = size64_t(x);
-                break;
-            default: assert(false);
-        }
+static llvm::StringMap<const void *> staticStringTableConstants;
+
+static void setSizeTEValue(EValuePtr v, size_t x) {
+    switch (typeSize(cSizeTType)) {
+    case 4:
+        *(size32_t *)v->addr = size32_t(x);
+        break;
+    case 8:
+        *(size64_t *)v->addr = size64_t(x);
+        break;
+    default:
+        assert(false);
     }
+}
 
-    /* not used yet
-    static void setPtrDiffTEValue(EValuePtr v, ptrdiff_t x) {
-        switch (typeSize(cPtrDiffTType)) {
-        case 4 : *(ptrdiff32_t *)v->addr = ptrdiff32_t(x); break;
-        case 8 : *(ptrdiff64_t *)v->addr = ptrdiff64_t(x); break;
-        default : assert(false);
-        }
+/* not used yet
+static void setPtrDiffTEValue(EValuePtr v, ptrdiff_t x) {
+    switch (typeSize(cPtrDiffTType)) {
+    case 4 : *(ptrdiff32_t *)v->addr = ptrdiff32_t(x); break;
+    case 8 : *(ptrdiff64_t *)v->addr = ptrdiff64_t(x); break;
+    default : assert(false);
     }
-    */
-
-    //
-    // valueToStatic, valueToStaticSizeTOrInt
-    // valueToType, valueToNumericType, valueToIntegerType,
-    // valueToPointerLikeType, valueToTupleType, valueToRecordType,
-    // valueToVariantType, valueToEnumType, valueToIdentifier
-    //
+}
+*/
+
+//
+// valueToStatic, valueToStaticSizeTOrInt
+// valueToType, valueToNumericType, valueToIntegerType,
+// valueToPointerLikeType, valueToTupleType, valueToRecordType,
+// valueToVariantType, valueToEnumType, valueToIdentifier
+//
+
+static ObjectPtr valueToStatic(EValuePtr ev) {
+    if (ev->type->typeKind != STATIC_TYPE)
+        return nullptr;
+    StaticType *st = (StaticType *)ev->type.ptr();
+    return st->obj;
+}
 
-    static ObjectPtr valueToStatic(EValuePtr ev) {
-        if (ev->type->typeKind != STATIC_TYPE)
-            return nullptr;
-        StaticType *st = (StaticType *) ev->type.ptr();
-        return st->obj;
-    }
+static ObjectPtr valueToStatic(MultiEValuePtr args, unsigned index) {
+    ObjectPtr obj = valueToStatic(args->values[index]);
+    if (!obj)
+        argumentError(index, "expecting a static value");
+    return obj;
+}
 
-    static ObjectPtr valueToStatic(MultiEValuePtr args, unsigned index) {
-        ObjectPtr obj = valueToStatic(args->values[index]);
-        if (!obj)
-            argumentError(index, "expecting a static value");
-        return obj;
+size_t valueHolderToSizeT(ValueHolderPtr vh) {
+    switch (typeSize(cSizeTType)) {
+    case 4:
+        return vh->as<size32_t>();
+    case 8:
+        return (size_t)vh->as<size64_t>();
+    default:
+        llvm_unreachable("unexpected pointer size");
     }
+}
 
-    size_t valueHolderToSizeT(ValueHolderPtr vh) {
-        switch (typeSize(cSizeTType)) {
-            case 4: return vh->as<size32_t>();
-            case 8: return (size_t) vh->as<size64_t>();
-            default: llvm_unreachable("unexpected pointer size");
-        }
+static size_t valueToStaticSizeTOrInt(MultiEValuePtr args, unsigned index) {
+    ObjectPtr obj = valueToStatic(args->values[index]);
+    if (!obj || (obj->objKind != VALUE_HOLDER))
+        argumentError(index, "expecting a static SizeT or Int value");
+    ValueHolder *vh = (ValueHolder *)obj.ptr();
+    if (vh->type == cSizeTType) {
+        return valueHolderToSizeT(vh);
+    } else if (vh->type == cIntType) {
+        return size_t(vh->as<int>());
+    } else {
+        argumentError(index, "expecting a static SizeT or Int value");
+        return 0;
     }
+}
 
-    static size_t valueToStaticSizeTOrInt(MultiEValuePtr args, unsigned index) {
-        ObjectPtr obj = valueToStatic(args->values[index]);
-        if (!obj || (obj->objKind != VALUE_HOLDER))
-            argumentError(index, "expecting a static SizeT or Int value");
-        ValueHolder *vh = (ValueHolder *) obj.ptr();
-        if (vh->type == cSizeTType) {
-            return valueHolderToSizeT(vh);
-        } else if (vh->type == cIntType) {
-            return size_t(vh->as<int>());
-        } else {
-            argumentError(index, "expecting a static SizeT or Int value");
-            return 0;
-        }
-    }
+static TypePtr valueToType(MultiEValuePtr args, unsigned index) {
+    ObjectPtr obj = valueToStatic(args->values[index]);
+    if (!obj || (obj->objKind != TYPE))
+        argumentError(index, "expecting a type");
+    return (Type *)obj.ptr();
+}
 
-    static TypePtr valueToType(MultiEValuePtr args, unsigned index) {
-        ObjectPtr obj = valueToStatic(args->values[index]);
-        if (!obj || (obj->objKind != TYPE))
-            argumentError(index, "expecting a type");
-        return (Type *) obj.ptr();
+static TypePtr valueToNumericType(MultiEValuePtr args, unsigned index) {
+    TypePtr t = valueToType(args, index);
+    switch (t->typeKind) {
+    case INTEGER_TYPE:
+    case FLOAT_TYPE:
+        return t;
+    default:
+        argumentTypeError(index, "numeric type", t);
+        return nullptr;
     }
+}
 
-    static TypePtr valueToNumericType(MultiEValuePtr args, unsigned index) {
-        TypePtr t = valueToType(args, index);
-        switch (t->typeKind) {
-            case INTEGER_TYPE:
-            case FLOAT_TYPE:
-                return t;
-            default:
-                argumentTypeError(index, "numeric type", t);
-                return nullptr;
-        }
-    }
+static IntegerTypePtr valueToIntegerType(MultiEValuePtr args, unsigned index) {
+    TypePtr t = valueToType(args, index);
+    if (t->typeKind != INTEGER_TYPE)
+        argumentTypeError(index, "integer type", t);
+    return (IntegerType *)t.ptr();
+}
 
-    static IntegerTypePtr valueToIntegerType(MultiEValuePtr args, unsigned index) {
-        TypePtr t = valueToType(args, index);
-        if (t->typeKind != INTEGER_TYPE)
-            argumentTypeError(index, "integer type", t);
-        return (IntegerType *) t.ptr();
-    }
+static TypePtr valueToPointerLikeType(MultiEValuePtr args, unsigned index) {
+    TypePtr t = valueToType(args, index);
+    if (!isPointerOrCodePointerType(t))
+        argumentTypeError(index, "pointer or code-pointer type", t);
+    return t;
+}
 
-    static TypePtr valueToPointerLikeType(MultiEValuePtr args, unsigned index) {
-        TypePtr t = valueToType(args, index);
-        if (!isPointerOrCodePointerType(t))
-            argumentTypeError(index, "pointer or code-pointer type", t);
-        return t;
-    }
+static TupleTypePtr valueToTupleType(MultiEValuePtr args, unsigned index) {
+    TypePtr t = valueToType(args, index);
+    if (t->typeKind != TUPLE_TYPE)
+        argumentTypeError(index, "tuple type", t);
+    return (TupleType *)t.ptr();
+}
 
-    static TupleTypePtr valueToTupleType(MultiEValuePtr args, unsigned index) {
-        TypePtr t = valueToType(args, index);
-        if (t->typeKind != TUPLE_TYPE)
-            argumentTypeError(index, "tuple type", t);
-        return (TupleType *) t.ptr();
-    }
+static UnionTypePtr valueToUnionType(MultiEValuePtr args, unsigned index) {
+    TypePtr t = valueToType(args, index);
+    if (t->typeKind != UNION_TYPE)
+        argumentTypeError(index, "union type", t);
+    return (UnionType *)t.ptr();
+}
 
-    static UnionTypePtr valueToUnionType(MultiEValuePtr args, unsigned index) {
-        TypePtr t = valueToType(args, index);
-        if (t->typeKind != UNION_TYPE)
-            argumentTypeError(index, "union type", t);
-        return (UnionType *) t.ptr();
-    }
+static RecordTypePtr valueToRecordType(MultiEValuePtr args, unsigned index) {
+    TypePtr t = valueToType(args, index);
+    if (t->typeKind != RECORD_TYPE)
+        argumentTypeError(index, "record type", t);
+    return (RecordType *)t.ptr();
+}
 
-    static RecordTypePtr valueToRecordType(MultiEValuePtr args, unsigned index) {
-        TypePtr t = valueToType(args, index);
-        if (t->typeKind != RECORD_TYPE)
-            argumentTypeError(index, "record type", t);
-        return (RecordType *) t.ptr();
-    }
+static VariantTypePtr valueToVariantType(MultiEValuePtr args, unsigned index) {
+    TypePtr t = valueToType(args, index);
+    if (t->typeKind != VARIANT_TYPE)
+        argumentTypeError(index, "variant type", t);
+    return (VariantType *)t.ptr();
+}
 
-    static VariantTypePtr valueToVariantType(MultiEValuePtr args, unsigned index) {
-        TypePtr t = valueToType(args, index);
-        if (t->typeKind != VARIANT_TYPE)
-            argumentTypeError(index, "variant type", t);
-        return (VariantType *) t.ptr();
-    }
+static EnumTypePtr valueToEnumType(MultiEValuePtr args, unsigned index) {
+    TypePtr t = valueToType(args, index);
+    if (t->typeKind != ENUM_TYPE)
+        argumentTypeError(index, "enum type", t);
+    initializeEnumType((EnumType *)t.ptr());
+    return (EnumType *)t.ptr();
+}
 
-    static EnumTypePtr valueToEnumType(MultiEValuePtr args, unsigned index) {
-        TypePtr t = valueToType(args, index);
-        if (t->typeKind != ENUM_TYPE)
-            argumentTypeError(index, "enum type", t);
-        initializeEnumType((EnumType *) t.ptr());
-        return (EnumType *) t.ptr();
-    }
+static IdentifierPtr valueToIdentifier(MultiEValuePtr args, unsigned index) {
+    ObjectPtr obj = valueToStatic(args->values[index]);
+    if (!obj || (obj->objKind != IDENTIFIER))
+        argumentError(index, "expecting identifier value");
+    return (Identifier *)obj.ptr();
+}
 
-    static IdentifierPtr valueToIdentifier(MultiEValuePtr args, unsigned index) {
-        ObjectPtr obj = valueToStatic(args->values[index]);
-        if (!obj || (obj->objKind != IDENTIFIER))
-            argumentError(index, "expecting identifier value");
-        return (Identifier *) obj.ptr();
-    }
+static llvm::StringRef valueToStringRef(MultiEValuePtr args, unsigned index) {
+    return valueToIdentifier(args, index)->str;
+}
 
-    static llvm::StringRef valueToStringRef(MultiEValuePtr args, unsigned index) {
-        return valueToIdentifier(args, index)->str;
+//
+// numericValue, integerValue, pointerValue, pointerLikeValue,
+// arrayValue, tupleValue, recordValue, variantValue, enumValue
+//
+
+static EValuePtr numericValue(MultiEValuePtr args, unsigned index,
+                              TypePtr &type) {
+    EValuePtr ev = args->values[index];
+    if (type.ptr()) {
+        if (ev->type != type)
+            argumentTypeError(index, type, ev->type);
+    } else {
+        switch (ev->type->typeKind) {
+        case INTEGER_TYPE:
+        case FLOAT_TYPE:
+            break;
+        default:
+            argumentTypeError(index, "numeric type", ev->type);
+        }
+        type = ev->type;
     }
+    return ev;
+}
 
-    //
-    // numericValue, integerValue, pointerValue, pointerLikeValue,
-    // arrayValue, tupleValue, recordValue, variantValue, enumValue
-    //
-
-    static EValuePtr numericValue(MultiEValuePtr args, unsigned index,
-                                  TypePtr &type) {
-        EValuePtr ev = args->values[index];
-        if (type.ptr()) {
-            if (ev->type != type)
-                argumentTypeError(index, type, ev->type);
-        } else {
-            switch (ev->type->typeKind) {
-                case INTEGER_TYPE:
-                case FLOAT_TYPE:
-                    break;
-                default:
-                    argumentTypeError(index, "numeric type", ev->type);
-            }
-            type = ev->type;
+static EValuePtr floatValue(MultiEValuePtr args, unsigned index,
+                            FloatTypePtr &type) {
+    EValuePtr ev = args->values[index];
+    if (type.ptr()) {
+        if (ev->type.ptr() != type.ptr())
+            argumentTypeError(index, type.ptr(), ev->type);
+    } else {
+        switch (ev->type->typeKind) {
+        case FLOAT_TYPE:
+            break;
+        default:
+            argumentTypeError(index, "float type", ev->type);
         }
-        return ev;
+        type = (FloatType *)ev->type.ptr();
     }
+    return ev;
+}
 
-    static EValuePtr floatValue(MultiEValuePtr args, unsigned index,
-                                FloatTypePtr &type) {
-        EValuePtr ev = args->values[index];
-        if (type.ptr()) {
-            if (ev->type.ptr() != type.ptr())
-                argumentTypeError(index, type.ptr(), ev->type);
-        } else {
-            switch (ev->type->typeKind) {
-                case FLOAT_TYPE:
-                    break;
-                default:
-                    argumentTypeError(index, "float type", ev->type);
-            }
-            type = (FloatType *) ev->type.ptr();
+static EValuePtr integerOrPointerLikeValue(MultiEValuePtr args, unsigned index,
+                                           TypePtr &type) {
+    EValuePtr ev = args->values[index];
+    if (type.ptr()) {
+        if (ev->type != type)
+            argumentTypeError(index, type, ev->type);
+    } else {
+        switch (ev->type->typeKind) {
+        case INTEGER_TYPE:
+        case POINTER_TYPE:
+        case CODE_POINTER_TYPE:
+        case CCODE_POINTER_TYPE:
+            break;
+        default:
+            argumentTypeError(index, "integer, pointer, or code pointer type",
+                              ev->type);
         }
-        return ev;
+        type = ev->type;
     }
+    return ev;
+}
 
-    static EValuePtr integerOrPointerLikeValue(MultiEValuePtr args, unsigned index,
-                                               TypePtr &type) {
-        EValuePtr ev = args->values[index];
-        if (type.ptr()) {
-            if (ev->type != type)
-                argumentTypeError(index, type, ev->type);
-        } else {
-            switch (ev->type->typeKind) {
-                case INTEGER_TYPE:
-                case POINTER_TYPE:
-                case CODE_POINTER_TYPE:
-                case CCODE_POINTER_TYPE:
-                    break;
-                default:
-                    argumentTypeError(index, "integer, pointer, or code pointer type", ev->type);
-            }
-            type = ev->type;
-        }
-        return ev;
+static EValuePtr integerValue(MultiEValuePtr args, unsigned index,
+                              IntegerTypePtr &type) {
+    EValuePtr ev = args->values[index];
+    if (type.ptr()) {
+        if (ev->type != type.ptr())
+            argumentTypeError(index, type.ptr(), ev->type);
+    } else {
+        if (ev->type->typeKind != INTEGER_TYPE)
+            argumentTypeError(index, "integer type", ev->type);
+        type = (IntegerType *)ev->type.ptr();
     }
+    return ev;
+}
 
-    static EValuePtr integerValue(MultiEValuePtr args, unsigned index,
-                                  IntegerTypePtr &type) {
-        EValuePtr ev = args->values[index];
-        if (type.ptr()) {
-            if (ev->type != type.ptr())
-                argumentTypeError(index, type.ptr(), ev->type);
-        } else {
-            if (ev->type->typeKind != INTEGER_TYPE)
-                argumentTypeError(index, "integer type", ev->type);
-            type = (IntegerType *) ev->type.ptr();
-        }
-        return ev;
+static EValuePtr pointerValue(MultiEValuePtr args, unsigned index,
+                              PointerTypePtr &type) {
+    EValuePtr ev = args->values[index];
+    if (type.ptr()) {
+        if (ev->type != (Type *)type.ptr())
+            argumentTypeError(index, type.ptr(), ev->type);
+    } else {
+        if (ev->type->typeKind != POINTER_TYPE)
+            argumentTypeError(index, "pointer type", ev->type);
+        type = (PointerType *)ev->type.ptr();
     }
+    return ev;
+}
 
-    static EValuePtr pointerValue(MultiEValuePtr args, unsigned index,
-                                  PointerTypePtr &type) {
-        EValuePtr ev = args->values[index];
-        if (type.ptr()) {
-            if (ev->type != (Type *) type.ptr())
-                argumentTypeError(index, type.ptr(), ev->type);
-        } else {
-            if (ev->type->typeKind != POINTER_TYPE)
-                argumentTypeError(index, "pointer type", ev->type);
-            type = (PointerType *) ev->type.ptr();
-        }
-        return ev;
+static EValuePtr pointerLikeValue(MultiEValuePtr args, unsigned index,
+                                  TypePtr &type) {
+    EValuePtr ev = args->values[index];
+    if (type.ptr()) {
+        if (ev->type != type)
+            argumentTypeError(index, type, ev->type);
+    } else {
+        if (!isPointerOrCodePointerType(ev->type))
+            argumentTypeError(index, "pointer or code-pointer type", ev->type);
+        type = ev->type;
     }
+    return ev;
+}
 
-    static EValuePtr pointerLikeValue(MultiEValuePtr args, unsigned index,
-                                      TypePtr &type) {
-        EValuePtr ev = args->values[index];
-        if (type.ptr()) {
-            if (ev->type != type)
-                argumentTypeError(index, type, ev->type);
-        } else {
-            if (!isPointerOrCodePointerType(ev->type))
-                argumentTypeError(index,
-                                  "pointer or code-pointer type",
-                                  ev->type);
-            type = ev->type;
-        }
-        return ev;
+static EValuePtr arrayValue(MultiEValuePtr args, unsigned index,
+                            ArrayTypePtr &type) {
+    EValuePtr ev = args->values[index];
+    if (type.ptr()) {
+        if (ev->type != (Type *)type.ptr())
+            argumentTypeError(index, type.ptr(), ev->type);
+    } else {
+        if (ev->type->typeKind != ARRAY_TYPE)
+            argumentTypeError(index, "array type", ev->type);
+        type = (ArrayType *)ev->type.ptr();
     }
+    return ev;
+}
 
-    static EValuePtr arrayValue(MultiEValuePtr args, unsigned index,
-                                ArrayTypePtr &type) {
-        EValuePtr ev = args->values[index];
-        if (type.ptr()) {
-            if (ev->type != (Type *) type.ptr())
-                argumentTypeError(index, type.ptr(), ev->type);
-        } else {
-            if (ev->type->typeKind != ARRAY_TYPE)
-                argumentTypeError(index, "array type", ev->type);
-            type = (ArrayType *) ev->type.ptr();
-        }
-        return ev;
+static EValuePtr tupleValue(MultiEValuePtr args, unsigned index,
+                            TupleTypePtr &type) {
+    EValuePtr ev = args->values[index];
+    if (type.ptr()) {
+        if (ev->type != (Type *)type.ptr())
+            argumentTypeError(index, type.ptr(), ev->type);
+    } else {
+        if (ev->type->typeKind != TUPLE_TYPE)
+            argumentTypeError(index, "tuple type", ev->type);
+        type = (TupleType *)ev->type.ptr();
     }
+    return ev;
+}
 
-    static EValuePtr tupleValue(MultiEValuePtr args, unsigned index,
-                                TupleTypePtr &type) {
-        EValuePtr ev = args->values[index];
-        if (type.ptr()) {
-            if (ev->type != (Type *) type.ptr())
-                argumentTypeError(index, type.ptr(), ev->type);
-        } else {
-            if (ev->type->typeKind != TUPLE_TYPE)
-                argumentTypeError(index, "tuple type", ev->type);
-            type = (TupleType *) ev->type.ptr();
-        }
-        return ev;
+static EValuePtr recordValue(MultiEValuePtr args, unsigned index,
+                             RecordTypePtr &type) {
+    EValuePtr ev = args->values[index];
+    if (type.ptr()) {
+        if (ev->type != (Type *)type.ptr())
+            argumentTypeError(index, type.ptr(), ev->type);
+    } else {
+        if (ev->type->typeKind != RECORD_TYPE)
+            argumentTypeError(index, "record type", ev->type);
+        type = (RecordType *)ev->type.ptr();
     }
+    return ev;
+}
 
-    static EValuePtr recordValue(MultiEValuePtr args, unsigned index,
-                                 RecordTypePtr &type) {
-        EValuePtr ev = args->values[index];
-        if (type.ptr()) {
-            if (ev->type != (Type *) type.ptr())
-                argumentTypeError(index, type.ptr(), ev->type);
-        } else {
-            if (ev->type->typeKind != RECORD_TYPE)
-                argumentTypeError(index, "record type", ev->type);
-            type = (RecordType *) ev->type.ptr();
-        }
-        return ev;
+static EValuePtr enumValue(MultiEValuePtr args, unsigned index,
+                           EnumTypePtr &type) {
+    EValuePtr ev = args->values[index];
+    if (type.ptr()) {
+        if (ev->type != (Type *)type.ptr())
+            argumentTypeError(index, type.ptr(), ev->type);
+    } else {
+        if (ev->type->typeKind != ENUM_TYPE)
+            argumentTypeError(index, "enum type", ev->type);
+        type = (EnumType *)ev->type.ptr();
     }
+    return ev;
+}
 
-    static EValuePtr enumValue(MultiEValuePtr args, unsigned index,
-                               EnumTypePtr &type) {
-        EValuePtr ev = args->values[index];
-        if (type.ptr()) {
-            if (ev->type != (Type *) type.ptr())
-                argumentTypeError(index, type.ptr(), ev->type);
-        } else {
-            if (ev->type->typeKind != ENUM_TYPE)
-                argumentTypeError(index, "enum type", ev->type);
-            type = (EnumType *) ev->type.ptr();
-        }
-        return ev;
-    }
-
-    //
-    // binaryNumericOp
-    //
-
-    template<template<typename> class T>
-    static void binaryNumericOp(EValuePtr a, EValuePtr b, EValuePtr out) {
-        assert(a->type == b->type);
-        switch (a->type->typeKind) {
-            case INTEGER_TYPE: {
-                IntegerType *t = (IntegerType *) a->type.ptr();
-                if (t->isSigned) {
-                    switch (t->bits) {
-                        case 8: T<char>().eval(a, b, out);
-                            break;
-                        case 16: T<short>().eval(a, b, out);
-                            break;
-                        case 32: T<int>().eval(a, b, out);
-                            break;
-                        case 64: T<long long>().eval(a, b, out);
-                            break;
-                        case 128: T<clay_int128>().eval(a, b, out);
-                            break;
-                        default: assert(false);
-                    }
-                } else {
-                    switch (t->bits) {
-                        case 8: T<unsigned char>().eval(a, b, out);
-                            break;
-                        case 16: T<unsigned short>().eval(a, b, out);
-                            break;
-                        case 32: T<unsigned int>().eval(a, b, out);
-                            break;
-                        case 64: T<unsigned long long>().eval(a, b, out);
-                            break;
-                        case 128: T<clay_uint128>().eval(a, b, out);
-                            break;
-                        default: assert(false);
-                    }
-                }
-                break;
-            }
+//
+// binaryNumericOp
+//
 
-            case FLOAT_TYPE: {
-                FloatType *t = (FloatType *) a->type.ptr();
-                switch (t->bits) {
-                    case 32: T<float>().eval(a, b, out);
-                        break;
-                    case 64: T<double>().eval(a, b, out);
-                        break;
-                    case 80: T<long double>().eval(a, b, out);
-                        break;
-                    default: assert(false);
-                }
+template <template <typename> class T>
+static void binaryNumericOp(EValuePtr a, EValuePtr b, EValuePtr out) {
+    assert(a->type == b->type);
+    switch (a->type->typeKind) {
+    case INTEGER_TYPE: {
+        IntegerType *t = (IntegerType *)a->type.ptr();
+        if (t->isSigned) {
+            switch (t->bits) {
+            case 8:
+                T<char>().eval(a, b, out);
                 break;
-            }
-
-            case POINTER_TYPE:
-            case CODE_POINTER_TYPE:
-            case CCODE_POINTER_TYPE: {
-                switch (typeSize(a->type)) {
-                    case 2: T<unsigned short>().eval(a, b, out);
-                        break;
-                    case 4: T<size32_t>().eval(a, b, out);
-                        break;
-                    case 8: T<size64_t>().eval(a, b, out);
-                        break;
-                    default: error("unsupported pointer size");
-                }
+            case 16:
+                T<short>().eval(a, b, out);
+                break;
+            case 32:
+                T<int>().eval(a, b, out);
                 break;
+            case 64:
+                T<long long>().eval(a, b, out);
+                break;
+            case 128:
+                T<clay_int128>().eval(a, b, out);
+                break;
+            default:
+                assert(false);
             }
-
+        } else {
+            switch (t->bits) {
+            case 8:
+                T<unsigned char>().eval(a, b, out);
+                break;
+            case 16:
+                T<unsigned short>().eval(a, b, out);
+                break;
+            case 32:
+                T<unsigned int>().eval(a, b, out);
+                break;
+            case 64:
+                T<unsigned long long>().eval(a, b, out);
+                break;
+            case 128:
+                T<clay_uint128>().eval(a, b, out);
+                break;
             default:
                 assert(false);
+            }
         }
+        break;
     }
 
-    template<typename T>
-    static void overflowError(const char *op, T a, T b) {
-        string buf;
-        llvm::raw_string_ostream sout(buf);
-        sout << "integer overflow: " << a << " " << op << " " << b;
-        error(sout.str());
+    case FLOAT_TYPE: {
+        FloatType *t = (FloatType *)a->type.ptr();
+        switch (t->bits) {
+        case 32:
+            T<float>().eval(a, b, out);
+            break;
+        case 64:
+            T<double>().eval(a, b, out);
+            break;
+        case 80:
+            T<long double>().eval(a, b, out);
+            break;
+        default:
+            assert(false);
+        }
+        break;
     }
 
-    template<typename T>
-    static void invalidShiftError(const char *op, T a, T b) {
-        string buf;
-        llvm::raw_string_ostream sout(buf);
-        sout << "invalid shift: " << a << " " << op << " " << b;
-        error(sout.str());
+    case POINTER_TYPE:
+    case CODE_POINTER_TYPE:
+    case CCODE_POINTER_TYPE: {
+        switch (typeSize(a->type)) {
+        case 2:
+            T<unsigned short>().eval(a, b, out);
+            break;
+        case 4:
+            T<size32_t>().eval(a, b, out);
+            break;
+        case 8:
+            T<size64_t>().eval(a, b, out);
+            break;
+        default:
+            error("unsupported pointer size");
+        }
+        break;
     }
 
-    template<typename T>
-    static void overflowError(const char *op, T a) {
-        string buf;
-        llvm::raw_string_ostream sout(buf);
-        sout << "integer overflow: " << op << a;
-        error(sout.str());
+    default:
+        assert(false);
     }
+}
 
-    static void divideByZeroError() {
-        error("integer division by zero");
-    }
+template <typename T> static void overflowError(const char *op, T a, T b) {
+    string buf;
+    llvm::raw_string_ostream sout(buf);
+    sout << "integer overflow: " << a << " " << op << " " << b;
+    error(sout.str());
+}
 
-    template<typename T>
-    class BinaryOpHelper {
-    public :
-        void eval(EValuePtr a, EValuePtr b, EValuePtr out) {
-            perform(a->as<T>(), b->as<T>(), out->addr);
-        }
+template <typename T> static void invalidShiftError(const char *op, T a, T b) {
+    string buf;
+    llvm::raw_string_ostream sout(buf);
+    sout << "invalid shift: " << a << " " << op << " " << b;
+    error(sout.str());
+}
 
-        virtual void perform(T &a, T &b, void *out) = 0;
-    };
+template <typename T> static void overflowError(const char *op, T a) {
+    string buf;
+    llvm::raw_string_ostream sout(buf);
+    sout << "integer overflow: " << op << a;
+    error(sout.str());
+}
+
+static void divideByZeroError() { error("integer division by zero"); }
 
-#define BINARY_OP(name, type, expr) \
-    template <typename T>                               \
-    class name : public BinaryOpHelper<T> {             \
-    public :                                            \
-        virtual void perform(T &a, T &b, void *out) {   \
-            *((type *)out) = (expr);                    \
-        }                                               \
+template <typename T> class BinaryOpHelper {
+  public:
+    void eval(EValuePtr a, EValuePtr b, EValuePtr out) {
+        perform(a->as<T>(), b->as<T>(), out->addr);
+    }
+
+    virtual void perform(T &a, T &b, void *out) = 0;
+};
+
+#define BINARY_OP(name, type, expr)                                            \
+    template <typename T> class name : public BinaryOpHelper<T> {              \
+      public:                                                                  \
+        virtual void perform(T &a, T &b, void *out) {                          \
+            *((type *)out) = (expr);                                           \
+        }                                                                      \
     }
 
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wtautological-compare"
 
-    BINARY_OP(Op_orderedEqualsP, bool, a == b);
-    BINARY_OP(Op_orderedLesserP, bool, a < b);
-    BINARY_OP(Op_orderedLesserEqualsP, bool, a <= b);
-    BINARY_OP(Op_orderedGreaterP, bool, a > b);
-    BINARY_OP(Op_orderedGreaterEqualsP, bool, a >= b);
-    BINARY_OP(Op_orderedNotEqualsP, bool, a != b && a == a && b == b);
-    BINARY_OP(Op_orderedP, bool, a == a && b == b);
-    BINARY_OP(Op_unorderedEqualsP, bool, a == b || a != a || b != b);
-    BINARY_OP(Op_unorderedLesserP, bool, !(a >= b));
-    BINARY_OP(Op_unorderedLesserEqualsP, bool, !(a > b));
-    BINARY_OP(Op_unorderedGreaterP, bool, !(a <= b));
-    BINARY_OP(Op_unorderedGreaterEqualsP, bool, !(a < b));
-    BINARY_OP(Op_unorderedNotEqualsP, bool, a != b);
-    BINARY_OP(Op_unorderedP, bool, a != a || b != b);
-    BINARY_OP(Op_numericAdd, T, a + b);
-    BINARY_OP(Op_numericSubtract, T, a - b);
-    BINARY_OP(Op_numericMultiply, T, a * b);
-    BINARY_OP(Op_floatDivide, T, a / b);
-    BINARY_OP(Op_integerQuotient, T, a / b);
-    BINARY_OP(Op_integerRemainder, T, a % b);
-    BINARY_OP(Op_integerShiftLeft, T, a << b);
-    BINARY_OP(Op_integerShiftRight, T, a >> b);
-    BINARY_OP(Op_integerBitwiseAnd, T, a & b);
-    BINARY_OP(Op_integerBitwiseOr, T, a | b);
-    BINARY_OP(Op_integerBitwiseXor, T, a ^ b);
+BINARY_OP(Op_orderedEqualsP, bool, a == b);
+BINARY_OP(Op_orderedLesserP, bool, a < b);
+BINARY_OP(Op_orderedLesserEqualsP, bool, a <= b);
+BINARY_OP(Op_orderedGreaterP, bool, a > b);
+BINARY_OP(Op_orderedGreaterEqualsP, bool, a >= b);
+BINARY_OP(Op_orderedNotEqualsP, bool, a != b && a == a && b == b);
+BINARY_OP(Op_orderedP, bool, a == a && b == b);
+BINARY_OP(Op_unorderedEqualsP, bool, a == b || a != a || b != b);
+BINARY_OP(Op_unorderedLesserP, bool, !(a >= b));
+BINARY_OP(Op_unorderedLesserEqualsP, bool, !(a > b));
+BINARY_OP(Op_unorderedGreaterP, bool, !(a <= b));
+BINARY_OP(Op_unorderedGreaterEqualsP, bool, !(a < b));
+BINARY_OP(Op_unorderedNotEqualsP, bool, a != b);
+BINARY_OP(Op_unorderedP, bool, a != a || b != b);
+BINARY_OP(Op_numericAdd, T, a + b);
+BINARY_OP(Op_numericSubtract, T, a - b);
+BINARY_OP(Op_numericMultiply, T, a *b);
+BINARY_OP(Op_floatDivide, T, a / b);
+BINARY_OP(Op_integerQuotient, T, a / b);
+BINARY_OP(Op_integerRemainder, T, a % b);
+BINARY_OP(Op_integerShiftLeft, T, a << b);
+BINARY_OP(Op_integerShiftRight, T, a >> b);
+BINARY_OP(Op_integerBitwiseAnd, T, a &b);
+BINARY_OP(Op_integerBitwiseOr, T, a | b);
+BINARY_OP(Op_integerBitwiseXor, T, a ^ b);
 
 #pragma clang diagnostic pop
 
 #undef BINARY_OP
 
-    //
-    // unaryNumericOp
-    //
-
-    template<template<typename> class T>
-    static void unaryNumericOp(EValuePtr a, EValuePtr out) {
-        switch (a->type->typeKind) {
-            case INTEGER_TYPE: {
-                IntegerType *t = (IntegerType *) a->type.ptr();
-                if (t->isSigned) {
-                    switch (t->bits) {
-                        case 8: T<char>().eval(a, out);
-                            break;
-                        case 16: T<short>().eval(a, out);
-                            break;
-                        case 32: T<int>().eval(a, out);
-                            break;
-                        case 64: T<long long>().eval(a, out);
-                            break;
-                        case 128: T<clay_int128>().eval(a, out);
-                            break;
-                        default: assert(false);
-                    }
-                } else {
-                    switch (t->bits) {
-                        case 8: T<unsigned char>().eval(a, out);
-                            break;
-                        case 16: T<unsigned short>().eval(a, out);
-                            break;
-                        case 32: T<unsigned int>().eval(a, out);
-                            break;
-                        case 64: T<unsigned long long>().eval(a, out);
-                            break;
-                        case 128: T<clay_uint128>().eval(a, out);
-                            break;
-                        default: assert(false);
-                    }
-                }
-                break;
-            }
+//
+// unaryNumericOp
+//
 
-            case FLOAT_TYPE: {
-                FloatType *t = (FloatType *) a->type.ptr();
-                switch (t->bits) {
-                    case 32: T<float>().eval(a, out);
-                        break;
-                    case 64: T<double>().eval(a, out);
-                        break;
-                    case 80: T<long double>().eval(a, out);
-                        break;
-                    default: assert(false);
-                }
+template <template <typename> class T>
+static void unaryNumericOp(EValuePtr a, EValuePtr out) {
+    switch (a->type->typeKind) {
+    case INTEGER_TYPE: {
+        IntegerType *t = (IntegerType *)a->type.ptr();
+        if (t->isSigned) {
+            switch (t->bits) {
+            case 8:
+                T<char>().eval(a, out);
+                break;
+            case 16:
+                T<short>().eval(a, out);
+                break;
+            case 32:
+                T<int>().eval(a, out);
                 break;
+            case 64:
+                T<long long>().eval(a, out);
+                break;
+            case 128:
+                T<clay_int128>().eval(a, out);
+                break;
+            default:
+                assert(false);
             }
-
+        } else {
+            switch (t->bits) {
+            case 8:
+                T<unsigned char>().eval(a, out);
+                break;
+            case 16:
+                T<unsigned short>().eval(a, out);
+                break;
+            case 32:
+                T<unsigned int>().eval(a, out);
+                break;
+            case 64:
+                T<unsigned long long>().eval(a, out);
+                break;
+            case 128:
+                T<clay_uint128>().eval(a, out);
+                break;
             default:
                 assert(false);
+            }
         }
+        break;
     }
 
-    template<typename T>
-    class UnaryOpHelper {
-    public :
-        void eval(EValuePtr a, EValuePtr out) {
-            perform(a->as<T>(), out->addr);
+    case FLOAT_TYPE: {
+        FloatType *t = (FloatType *)a->type.ptr();
+        switch (t->bits) {
+        case 32:
+            T<float>().eval(a, out);
+            break;
+        case 64:
+            T<double>().eval(a, out);
+            break;
+        case 80:
+            T<long double>().eval(a, out);
+            break;
+        default:
+            assert(false);
         }
+        break;
+    }
 
-        virtual void perform(T &a, void *out) = 0;
-    };
+    default:
+        assert(false);
+    }
+}
+
+template <typename T> class UnaryOpHelper {
+  public:
+    void eval(EValuePtr a, EValuePtr out) { perform(a->as<T>(), out->addr); }
+
+    virtual void perform(T &a, void *out) = 0;
+};
 
 #ifdef _MSC_VER
 #pragma warning(push)
-#pragma warning(disable: 4146)
+#pragma warning(disable : 4146)
 #endif
 
-#define UNARY_OP(name, type, expr) \
-    template <typename T>                       \
-    class name : public UnaryOpHelper<T> {      \
-    public :                                    \
-        virtual void perform(T &a, void *out) { \
-            *((type *)out) = (expr);            \
-        }                                       \
+#define UNARY_OP(name, type, expr)                                             \
+    template <typename T> class name : public UnaryOpHelper<T> {               \
+      public:                                                                  \
+        virtual void perform(T &a, void *out) { *((type *)out) = (expr); }     \
     };
 
-    UNARY_OP(Op_numericNegate, T, -a)
+UNARY_OP(Op_numericNegate, T, -a)
 
-    UNARY_OP(Op_integerBitwiseNot, T, ~a)
+UNARY_OP(Op_integerBitwiseNot, T, ~a)
 
 #undef UNARY_OP
 
@@ -569,1831 +597,1915 @@ namespace clay {
 #pragma warning(pop)
 #endif
 
-    //
-    // binaryIntegerOp
-    //
-
-    template<template<typename> class T>
-    static void binaryIntegerOp(EValuePtr a, EValuePtr b, EValuePtr out) {
-        assert(a->type == b->type);
-        assert(a->type->typeKind == INTEGER_TYPE);
-        IntegerType *t = (IntegerType *) a->type.ptr();
-        if (t->isSigned) {
-            switch (t->bits) {
-                case 8: T<char>().eval(a, b, out);
-                    break;
-                case 16: T<short>().eval(a, b, out);
-                    break;
-                case 32: T<int>().eval(a, b, out);
-                    break;
-                case 64: T<long long>().eval(a, b, out);
-                    break;
-                case 128: T<clay_int128>().eval(a, b, out);
-                    break;
-                default: assert(false);
-            }
-        } else {
-            switch (t->bits) {
-                case 8: T<unsigned char>().eval(a, b, out);
-                    break;
-                case 16: T<unsigned short>().eval(a, b, out);
-                    break;
-                case 32: T<unsigned int>().eval(a, b, out);
-                    break;
-                case 64: T<unsigned long long>().eval(a, b, out);
-                    break;
-                case 128: T<clay_uint128>().eval(a, b, out);
-                    break;
-                default: assert(false);
-            }
+//
+// binaryIntegerOp
+//
+
+template <template <typename> class T>
+static void binaryIntegerOp(EValuePtr a, EValuePtr b, EValuePtr out) {
+    assert(a->type == b->type);
+    assert(a->type->typeKind == INTEGER_TYPE);
+    IntegerType *t = (IntegerType *)a->type.ptr();
+    if (t->isSigned) {
+        switch (t->bits) {
+        case 8:
+            T<char>().eval(a, b, out);
+            break;
+        case 16:
+            T<short>().eval(a, b, out);
+            break;
+        case 32:
+            T<int>().eval(a, b, out);
+            break;
+        case 64:
+            T<long long>().eval(a, b, out);
+            break;
+        case 128:
+            T<clay_int128>().eval(a, b, out);
+            break;
+        default:
+            assert(false);
+        }
+    } else {
+        switch (t->bits) {
+        case 8:
+            T<unsigned char>().eval(a, b, out);
+            break;
+        case 16:
+            T<unsigned short>().eval(a, b, out);
+            break;
+        case 32:
+            T<unsigned int>().eval(a, b, out);
+            break;
+        case 64:
+            T<unsigned long long>().eval(a, b, out);
+            break;
+        case 128:
+            T<clay_uint128>().eval(a, b, out);
+            break;
+        default:
+            assert(false);
         }
     }
+}
 
 #if defined(__clang__)
-#  pragma clang diagnostic push
-#  pragma clang diagnostic ignored "-Wtautological-compare"
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wtautological-compare"
 #elif defined(__GNUC__)
-#  if __GNUC__ < 4 || __GNUC__ == 4 && __GNUC_MINOR__ < 6
-#    warning "--- The following warnings are expected ---"
-#  else
-#    pragma GCC diagnostic push
-#    pragma GCC diagnostic ignored "-Wtype-limits"
-#  endif
+#if __GNUC__ < 4 || __GNUC__ == 4 && __GNUC_MINOR__ < 6
+#warning "--- The following warnings are expected ---"
+#else
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wtype-limits"
+#endif
 #endif
 
-    template<typename T>
-    class Op_integerAddChecked : public BinaryOpHelper<T> {
-    public :
-        virtual void perform(T &a, T &b, void *out) {
-            if ((b < T(0) && a < std::numeric_limits<T>::min() - b)
-                || (b > T(0) && a > std::numeric_limits<T>::max() - b))
-                overflowError("+", a, b);
-            else
-                *((T *) out) = a + b;
-        }
-    };
-
-    template<typename T>
-    class Op_integerSubtractChecked : public BinaryOpHelper<T> {
-    public :
-        virtual void perform(T &a, T &b, void *out) {
-            if ((b < T(0) && a > std::numeric_limits<T>::max() + b)
-                || (b > T(0) && a < std::numeric_limits<T>::min() + b))
-                overflowError("-", a, b);
-            else
-                *((T *) out) = a - b;
-        }
-    };
+template <typename T> class Op_integerAddChecked : public BinaryOpHelper<T> {
+  public:
+    virtual void perform(T &a, T &b, void *out) {
+        if ((b < T(0) && a < std::numeric_limits<T>::min() - b) ||
+            (b > T(0) && a > std::numeric_limits<T>::max() - b))
+            overflowError("+", a, b);
+        else
+            *((T *)out) = a + b;
+    }
+};
+
+template <typename T>
+class Op_integerSubtractChecked : public BinaryOpHelper<T> {
+  public:
+    virtual void perform(T &a, T &b, void *out) {
+        if ((b < T(0) && a > std::numeric_limits<T>::max() + b) ||
+            (b > T(0) && a < std::numeric_limits<T>::min() + b))
+            overflowError("-", a, b);
+        else
+            *((T *)out) = a - b;
+    }
+};
 
-    template<typename T>
-    class Op_integerShiftLeftChecked : public BinaryOpHelper<T> {
-        virtual void perform(T &a, T &b, void *out) {
-            if (b < 0)
-                invalidShiftError("bitshl", a, b);
+template <typename T>
+class Op_integerShiftLeftChecked : public BinaryOpHelper<T> {
+    virtual void perform(T &a, T &b, void *out) {
+        if (b < 0)
+            invalidShiftError("bitshl", a, b);
 
-            if (b == 0) {
-                *((T *) out) = a;
-                return;
-            }
+        if (b == 0) {
+            *((T *)out) = a;
+            return;
+        }
 
-            if (std::numeric_limits<T>::min() != 0) {
-                // signed
-                T testa = a < 0 ? ~a : a;
-                if (b > T(sizeof(T) * 8 - 1) || (testa >> (sizeof(T) * 8 - (size_t) b - 1)) != 0)
-                    overflowError("bitshl", a, b);
-            } else {
-                // unsigned
-                if (b > T(sizeof(T) * 8) || (a >> (sizeof(T) * 8 - (size_t) b)) != 0)
-                    overflowError("bitshl", a, b);
-            }
-            *((T *) out) = a << b;
+        if (std::numeric_limits<T>::min() != 0) {
+            // signed
+            T testa = a < 0 ? ~a : a;
+            if (b > T(sizeof(T) * 8 - 1) ||
+                (testa >> (sizeof(T) * 8 - (size_t)b - 1)) != 0)
+                overflowError("bitshl", a, b);
+        } else {
+            // unsigned
+            if (b > T(sizeof(T) * 8) || (a >> (sizeof(T) * 8 - (size_t)b)) != 0)
+                overflowError("bitshl", a, b);
         }
-    };
+        *((T *)out) = a << b;
+    }
+};
 
 #if defined(__clang__)
-#  pragma clang diagnostic pop
+#pragma clang diagnostic pop
 #elif defined(__GNUC__)
-#  if __GNUC__ > 4 || __GNUC__ == 4 && __GNUC_MINOR__ >= 6
-#    pragma GCC diagnostic pop
-#  endif
+#if __GNUC__ > 4 || __GNUC__ == 4 && __GNUC_MINOR__ >= 6
+#pragma GCC diagnostic pop
+#endif
 #endif
 
-    template<typename T>
-    class Op_integerRemainderChecked : public BinaryOpHelper<T> {
-        virtual void perform(T &a, T &b, void *out) {
-            if (b == 0)
-                divideByZeroError();
-            *((T *) out) = a % b;
-        }
-    };
-
-    template<typename T>
-    struct next_larger_type;
-
-    template<>
-    struct next_larger_type<char> {
-        typedef short type;
-    };
-
-    template<>
-    struct next_larger_type<short> {
-        typedef int type;
-    };
-
-    template<>
-    struct next_larger_type<int> {
-        typedef ptrdiff64_t type;
-    };
-
-    template<>
-    struct next_larger_type<ptrdiff64_t> {
-        typedef clay_int128 type;
-    };
-
-    template<>
-    struct next_larger_type<clay_int128> {
-        typedef clay_int128 type;
-    };
-
-    template<>
-    struct next_larger_type<unsigned char> {
-        typedef unsigned short type;
-    };
-
-    template<>
-    struct next_larger_type<unsigned short> {
-        typedef unsigned type;
-    };
-
-    template<>
-    struct next_larger_type<unsigned> {
-        typedef size64_t type;
-    };
-
-    template<>
-    struct next_larger_type<size64_t> {
-        typedef clay_uint128 type;
-    };
-
-    template<>
-    struct next_larger_type<clay_uint128> {
-        typedef clay_uint128 type;
-    };
-
-    template<typename T>
-    class Op_integerMultiplyChecked : public BinaryOpHelper<T> {
-    public :
-        typedef typename next_larger_type<T>::type BigT;
-
-        virtual void perform(T &a, T &b, void *out) {
-            // XXX this won't work for 128-bit types or 64-bit types without
-            // compiler int128 support
-            BigT bigout = BigT(a) * BigT(b);
-            if (bigout < std::numeric_limits<T>::min() || std::numeric_limits<T>::max() < bigout)
-                overflowError("*", a, b);
-            *((T *) out) = a * b;
-        }
-    };
-
-    template<typename T>
-    class Op_integerQuotientChecked : public BinaryOpHelper<T> {
-    public :
-        virtual void perform(T &a, T &b, void *out) {
-            if (std::numeric_limits<T>::min() != 0
-                && a == std::numeric_limits<T>::min()
-                && b == (-1))
-                overflowError("/", a, b);
-            if (b == 0)
-                divideByZeroError();
-            *((T *) out) = a / b;
+template <typename T>
+class Op_integerRemainderChecked : public BinaryOpHelper<T> {
+    virtual void perform(T &a, T &b, void *out) {
+        if (b == 0)
+            divideByZeroError();
+        *((T *)out) = a % b;
+    }
+};
+
+template <typename T> struct next_larger_type;
+
+template <> struct next_larger_type<char> {
+    typedef short type;
+};
+
+template <> struct next_larger_type<short> {
+    typedef int type;
+};
+
+template <> struct next_larger_type<int> {
+    typedef ptrdiff64_t type;
+};
+
+template <> struct next_larger_type<ptrdiff64_t> {
+    typedef clay_int128 type;
+};
+
+template <> struct next_larger_type<clay_int128> {
+    typedef clay_int128 type;
+};
+
+template <> struct next_larger_type<unsigned char> {
+    typedef unsigned short type;
+};
+
+template <> struct next_larger_type<unsigned short> {
+    typedef unsigned type;
+};
+
+template <> struct next_larger_type<unsigned> {
+    typedef size64_t type;
+};
+
+template <> struct next_larger_type<size64_t> {
+    typedef clay_uint128 type;
+};
+
+template <> struct next_larger_type<clay_uint128> {
+    typedef clay_uint128 type;
+};
+
+template <typename T>
+class Op_integerMultiplyChecked : public BinaryOpHelper<T> {
+  public:
+    typedef typename next_larger_type<T>::type BigT;
+
+    virtual void perform(T &a, T &b, void *out) {
+        // XXX this won't work for 128-bit types or 64-bit types without
+        // compiler int128 support
+        BigT bigout = BigT(a) * BigT(b);
+        if (bigout < std::numeric_limits<T>::min() ||
+            std::numeric_limits<T>::max() < bigout)
+            overflowError("*", a, b);
+        *((T *)out) = a * b;
+    }
+};
+
+template <typename T>
+class Op_integerQuotientChecked : public BinaryOpHelper<T> {
+  public:
+    virtual void perform(T &a, T &b, void *out) {
+        if (std::numeric_limits<T>::min() != 0 &&
+            a == std::numeric_limits<T>::min() && b == (-1))
+            overflowError("/", a, b);
+        if (b == 0)
+            divideByZeroError();
+        *((T *)out) = a / b;
+    }
+};
+
+//
+// unaryIntegerOp
+//
+
+template <template <typename> class T>
+static void unaryIntegerOp(EValuePtr a, EValuePtr out) {
+    assert(a->type->typeKind == INTEGER_TYPE);
+    IntegerType *t = (IntegerType *)a->type.ptr();
+    if (t->isSigned) {
+        switch (t->bits) {
+        case 8:
+            T<char>().eval(a, out);
+            break;
+        case 16:
+            T<short>().eval(a, out);
+            break;
+        case 32:
+            T<int>().eval(a, out);
+            break;
+        case 64:
+            T<long long>().eval(a, out);
+            break;
+        case 128:
+            T<clay_int128>().eval(a, out);
+            break;
+        default:
+            assert(false);
         }
-    };
-
-    //
-    // unaryIntegerOp
-    //
-
-    template<template<typename> class T>
-    static void unaryIntegerOp(EValuePtr a, EValuePtr out) {
-        assert(a->type->typeKind == INTEGER_TYPE);
-        IntegerType *t = (IntegerType *) a->type.ptr();
-        if (t->isSigned) {
-            switch (t->bits) {
-                case 8: T<char>().eval(a, out);
-                    break;
-                case 16: T<short>().eval(a, out);
-                    break;
-                case 32: T<int>().eval(a, out);
-                    break;
-                case 64: T<long long>().eval(a, out);
-                    break;
-                case 128: T<clay_int128>().eval(a, out);
-                    break;
-                default: assert(false);
-            }
-        } else {
-            switch (t->bits) {
-                case 8: T<unsigned char>().eval(a, out);
-                    break;
-                case 16: T<unsigned short>().eval(a, out);
-                    break;
-                case 32: T<unsigned int>().eval(a, out);
-                    break;
-                case 64: T<unsigned long long>().eval(a, out);
-                    break;
-                case 128: T<clay_uint128>().eval(a, out);
-                    break;
-                default: assert(false);
-            }
+    } else {
+        switch (t->bits) {
+        case 8:
+            T<unsigned char>().eval(a, out);
+            break;
+        case 16:
+            T<unsigned short>().eval(a, out);
+            break;
+        case 32:
+            T<unsigned int>().eval(a, out);
+            break;
+        case 64:
+            T<unsigned long long>().eval(a, out);
+            break;
+        case 128:
+            T<clay_uint128>().eval(a, out);
+            break;
+        default:
+            assert(false);
         }
     }
+}
 
 #ifdef _MSC_VER
 #pragma warning(push)
-#pragma warning(disable: 4146)
+#pragma warning(disable : 4146)
 #endif
 
-    template<typename T>
-    class Op_integerNegateChecked : public UnaryOpHelper<T> {
-    public :
-        virtual void perform(T &a, void *out) {
-            if (std::numeric_limits<T>::min() != 0
-                && a == std::numeric_limits<T>::min())
-                overflowError("-", a);
-            *((T *) out) = -a;
-        }
-    };
+template <typename T> class Op_integerNegateChecked : public UnaryOpHelper<T> {
+  public:
+    virtual void perform(T &a, void *out) {
+        if (std::numeric_limits<T>::min() != 0 &&
+            a == std::numeric_limits<T>::min())
+            overflowError("-", a);
+        *((T *)out) = -a;
+    }
+};
 
 #ifdef _MSC_VER
 #pragma warning(pop)
 #endif
 
-    //
-    // op_numericConvert
-    //
+//
+// op_numericConvert
+//
 
-    template<typename DEST, typename SRC, bool CHECK>
-    struct op_numericConvert3;
+template <typename DEST, typename SRC, bool CHECK> struct op_numericConvert3;
 
 #ifdef _MSC_VER
 #pragma warning(push)
-#pragma warning(disable: 4244)
+#pragma warning(disable : 4244)
 #endif
-    template<typename DEST, typename SRC>
-    struct op_numericConvert3<DEST, SRC, false> {
-        static void perform(EValuePtr dest, EValuePtr src) {
-            SRC value = src->as<SRC>();
-            dest->as<DEST>() = DEST(value);
-        }
-    };
-
-    template<typename DEST, typename SRC>
-    struct op_numericConvert3<DEST, SRC, true> {
-        static void perform(EValuePtr dest, EValuePtr src) {
-            SRC value = src->as<SRC>();
-            // ???
-            dest->as<DEST>() = DEST(value);
-        }
-    };
+template <typename DEST, typename SRC>
+struct op_numericConvert3<DEST, SRC, false> {
+    static void perform(EValuePtr dest, EValuePtr src) {
+        SRC value = src->as<SRC>();
+        dest->as<DEST>() = DEST(value);
+    }
+};
+
+template <typename DEST, typename SRC>
+struct op_numericConvert3<DEST, SRC, true> {
+    static void perform(EValuePtr dest, EValuePtr src) {
+        SRC value = src->as<SRC>();
+        // ???
+        dest->as<DEST>() = DEST(value);
+    }
+};
 #ifdef _MSC_VER
 #pragma warning(pop)
 #endif
 
-    template<typename D, bool CHECK>
-    static void op_numericConvert2(EValuePtr dest, EValuePtr src) {
-        switch (src->type->typeKind) {
-            case INTEGER_TYPE: {
-                IntegerType *t = (IntegerType *) src->type.ptr();
-                if (t->isSigned) {
-                    switch (t->bits) {
-                        case 8: op_numericConvert3<D, char, CHECK>::perform(dest, src);
-                            break;
-                        case 16: op_numericConvert3<D, short, CHECK>::perform(dest, src);
-                            break;
-                        case 32: op_numericConvert3<D, int, CHECK>::perform(dest, src);
-                            break;
-                        case 64: op_numericConvert3<D, long long, CHECK>::perform(dest, src);
-                            break;
-                        case 128: op_numericConvert3<D, clay_int128, CHECK>::perform(dest, src);
-                            break;
-                        default: assert(false);
-                    }
-                } else {
-                    switch (t->bits) {
-                        case 8: op_numericConvert3<D, unsigned char, CHECK>::perform(dest, src);
-                            break;
-                        case 16: op_numericConvert3<D, unsigned short, CHECK>::perform(dest, src);
-                            break;
-                        case 32: op_numericConvert3<D, unsigned int, CHECK>::perform(dest, src);
-                            break;
-                        case 64: op_numericConvert3<D, unsigned long long, CHECK>::perform(dest, src);
-                            break;
-                        case 128: op_numericConvert3<D, clay_uint128, CHECK>::perform(dest, src);
-                            break;
-                        default: assert(false);
-                    }
-                }
+template <typename D, bool CHECK>
+static void op_numericConvert2(EValuePtr dest, EValuePtr src) {
+    switch (src->type->typeKind) {
+    case INTEGER_TYPE: {
+        IntegerType *t = (IntegerType *)src->type.ptr();
+        if (t->isSigned) {
+            switch (t->bits) {
+            case 8:
+                op_numericConvert3<D, char, CHECK>::perform(dest, src);
                 break;
-            }
-            case FLOAT_TYPE: {
-                FloatType *t = (FloatType *) src->type.ptr();
-                switch (t->bits) {
-                    case 32: op_numericConvert3<D, float, CHECK>::perform(dest, src);
-                        break;
-                    case 64: op_numericConvert3<D, double, CHECK>::perform(dest, src);
-                        break;
-                    case 80: op_numericConvert3<D, long double, CHECK>::perform(dest, src);
-                        break;
-                    default: assert(false);
-                }
+            case 16:
+                op_numericConvert3<D, short, CHECK>::perform(dest, src);
                 break;
+            case 32:
+                op_numericConvert3<D, int, CHECK>::perform(dest, src);
+                break;
+            case 64:
+                op_numericConvert3<D, long long, CHECK>::perform(dest, src);
+                break;
+            case 128:
+                op_numericConvert3<D, clay_int128, CHECK>::perform(dest, src);
+                break;
+            default:
+                assert(false);
             }
-
+        } else {
+            switch (t->bits) {
+            case 8:
+                op_numericConvert3<D, unsigned char, CHECK>::perform(dest, src);
+                break;
+            case 16:
+                op_numericConvert3<D, unsigned short, CHECK>::perform(dest,
+                                                                      src);
+                break;
+            case 32:
+                op_numericConvert3<D, unsigned int, CHECK>::perform(dest, src);
+                break;
+            case 64:
+                op_numericConvert3<D, unsigned long long, CHECK>::perform(dest,
+                                                                          src);
+                break;
+            case 128:
+                op_numericConvert3<D, clay_uint128, CHECK>::perform(dest, src);
+                break;
             default:
                 assert(false);
+            }
         }
+        break;
     }
-
-    template<bool CHECK>
-    static void op_numericConvert(EValuePtr dest, EValuePtr src) {
-        switch (dest->type->typeKind) {
-            case INTEGER_TYPE: {
-                IntegerType *t = (IntegerType *) dest->type.ptr();
-                if (t->isSigned) {
-                    switch (t->bits) {
-                        case 8: op_numericConvert2<char, CHECK>(dest, src);
-                            break;
-                        case 16: op_numericConvert2<short, CHECK>(dest, src);
-                            break;
-                        case 32: op_numericConvert2<int, CHECK>(dest, src);
-                            break;
-                        case 64: op_numericConvert2<long long, CHECK>(dest, src);
-                            break;
-                        case 128: op_numericConvert2<clay_int128, CHECK>(dest, src);
-                            break;
-                        default: assert(false);
-                    }
-                } else {
-                    switch (t->bits) {
-                        case 8: op_numericConvert2<unsigned char, CHECK>(dest, src);
-                            break;
-                        case 16: op_numericConvert2<unsigned short, CHECK>(dest, src);
-                            break;
-                        case 32: op_numericConvert2<unsigned int, CHECK>(dest, src);
-                            break;
-                        case 64: op_numericConvert2<unsigned long long, CHECK>(dest, src);
-                            break;
-                        case 128: op_numericConvert2<clay_uint128, CHECK>(dest, src);
-                            break;
-                        default: assert(false);
-                    }
-                }
-                break;
-            }
-            case FLOAT_TYPE: {
-                FloatType *t = (FloatType *) dest->type.ptr();
-                switch (t->bits) {
-                    case 32: op_numericConvert2<float, false>(dest, src);
-                        break;
-                    case 64: op_numericConvert2<double, false>(dest, src);
-                        break;
-                    case 80: op_numericConvert2<long double, false>(dest, src);
-                        break;
-                    default: assert(false);
-                }
-                break;
-            }
-
-            default:
-                assert(false);
+    case FLOAT_TYPE: {
+        FloatType *t = (FloatType *)src->type.ptr();
+        switch (t->bits) {
+        case 32:
+            op_numericConvert3<D, float, CHECK>::perform(dest, src);
+            break;
+        case 64:
+            op_numericConvert3<D, double, CHECK>::perform(dest, src);
+            break;
+        case 80:
+            op_numericConvert3<D, long double, CHECK>::perform(dest, src);
+            break;
+        default:
+            assert(false);
         }
+        break;
     }
 
-    //
-    // op_intToPtrInt
-    //
+    default:
+        assert(false);
+    }
+}
 
-    static ptrdiff_t op_intToPtrInt(EValuePtr a) {
-        assert(a->type->typeKind == INTEGER_TYPE);
-        IntegerType *t = (IntegerType *) a->type.ptr();
+template <bool CHECK>
+static void op_numericConvert(EValuePtr dest, EValuePtr src) {
+    switch (dest->type->typeKind) {
+    case INTEGER_TYPE: {
+        IntegerType *t = (IntegerType *)dest->type.ptr();
         if (t->isSigned) {
             switch (t->bits) {
-                case 8: return ptrdiff_t(a->as<char>());
-                case 16: return ptrdiff_t(a->as<short>());
-                case 32: return ptrdiff_t(a->as<int>());
-                case 64: return ptrdiff_t(a->as<long long>());
-                case 128: return ptrdiff_t(a->as<clay_int128>());
-                default: assert(false);
+            case 8:
+                op_numericConvert2<char, CHECK>(dest, src);
+                break;
+            case 16:
+                op_numericConvert2<short, CHECK>(dest, src);
+                break;
+            case 32:
+                op_numericConvert2<int, CHECK>(dest, src);
+                break;
+            case 64:
+                op_numericConvert2<long long, CHECK>(dest, src);
+                break;
+            case 128:
+                op_numericConvert2<clay_int128, CHECK>(dest, src);
+                break;
+            default:
+                assert(false);
             }
         } else {
             switch (t->bits) {
-                case 8: return ptrdiff_t(a->as<unsigned char>());
-                case 16: return ptrdiff_t(a->as<unsigned short>());
-                case 32: return ptrdiff_t(a->as<unsigned int>());
-                case 64: return ptrdiff_t(a->as<unsigned long long>());
-                case 128: return ptrdiff_t(a->as<clay_uint128>());
-                default: assert(false);
+            case 8:
+                op_numericConvert2<unsigned char, CHECK>(dest, src);
+                break;
+            case 16:
+                op_numericConvert2<unsigned short, CHECK>(dest, src);
+                break;
+            case 32:
+                op_numericConvert2<unsigned int, CHECK>(dest, src);
+                break;
+            case 64:
+                op_numericConvert2<unsigned long long, CHECK>(dest, src);
+                break;
+            case 128:
+                op_numericConvert2<clay_uint128, CHECK>(dest, src);
+                break;
+            default:
+                assert(false);
             }
         }
-        return 0;
+        break;
     }
-
-    //
-    // op_intToSizeT
-    //
-
-    static size_t op_intToSizeT(EValuePtr a) {
-        assert(a->type->typeKind == INTEGER_TYPE);
-        IntegerType *t = (IntegerType *) a->type.ptr();
-        if (t->isSigned) {
-            switch (t->bits) {
-                case 8: return size_t(a->as<char>());
-                case 16: return size_t(a->as<short>());
-                case 32: return size_t(a->as<int>());
-                case 64: return size_t(a->as<long long>());
-                case 128: return size_t(a->as<clay_int128>());
-                default: assert(false);
-            }
-        } else {
-            switch (t->bits) {
-                case 8: return size_t(a->as<unsigned char>());
-                case 16: return size_t(a->as<unsigned short>());
-                case 32: return size_t(a->as<unsigned int>());
-                case 64: return size_t(a->as<unsigned long long>());
-                case 128: return size_t(a->as<clay_uint128>());
-                default: assert(false);
-            }
+    case FLOAT_TYPE: {
+        FloatType *t = (FloatType *)dest->type.ptr();
+        switch (t->bits) {
+        case 32:
+            op_numericConvert2<float, false>(dest, src);
+            break;
+        case 64:
+            op_numericConvert2<double, false>(dest, src);
+            break;
+        case 80:
+            op_numericConvert2<long double, false>(dest, src);
+            break;
+        default:
+            assert(false);
         }
-        return 0;
+        break;
     }
 
-    //
-    // op_pointerToInt
-    //
+    default:
+        assert(false);
+    }
+}
 
-    static void op_pointerToInt(EValuePtr dest, EValuePtr ev) {
-        assert(dest->type->typeKind == INTEGER_TYPE);
-        IntegerType *t = (IntegerType *) dest->type.ptr();
-        if (t->isSigned) {
-            switch (t->bits) {
-                case 8: dest->as<char>() = ev->as<char>();
-                    break;
-                case 16: dest->as<short>() = ev->as<short>();
-                    break;
-                case 32: dest->as<int>() = ev->as<int>();
-                    break;
-                case 64: dest->as<long long>() = ev->as<long long>();
-                    break;
-                case 128: dest->as<clay_int128>() = ev->as<clay_int128>();
-                    break;
-                default: assert(false);
-            }
-        } else {
-            switch (t->bits) {
-                case 8: dest->as<unsigned char>() = ev->as<unsigned char>();
-                    break;
-                case 16: dest->as<unsigned short>() = ev->as<unsigned short>();
-                    break;
-                case 32: dest->as<unsigned int>() = ev->as<unsigned int>();
-                    break;
-                case 64: dest->as<unsigned long long>() = ev->as<unsigned long long>();
-                    break;
-                case 128: dest->as<clay_uint128>() = ev->as<clay_uint128>();
-                    break;
-                default: assert(false);
-            }
+//
+// op_intToPtrInt
+//
+
+static ptrdiff_t op_intToPtrInt(EValuePtr a) {
+    assert(a->type->typeKind == INTEGER_TYPE);
+    IntegerType *t = (IntegerType *)a->type.ptr();
+    if (t->isSigned) {
+        switch (t->bits) {
+        case 8:
+            return ptrdiff_t(a->as<char>());
+        case 16:
+            return ptrdiff_t(a->as<short>());
+        case 32:
+            return ptrdiff_t(a->as<int>());
+        case 64:
+            return ptrdiff_t(a->as<long long>());
+        case 128:
+            return ptrdiff_t(a->as<clay_int128>());
+        default:
+            assert(false);
+        }
+    } else {
+        switch (t->bits) {
+        case 8:
+            return ptrdiff_t(a->as<unsigned char>());
+        case 16:
+            return ptrdiff_t(a->as<unsigned short>());
+        case 32:
+            return ptrdiff_t(a->as<unsigned int>());
+        case 64:
+            return ptrdiff_t(a->as<unsigned long long>());
+        case 128:
+            return ptrdiff_t(a->as<clay_uint128>());
+        default:
+            assert(false);
         }
     }
+    return 0;
+}
 
-    //
-    // evalPrimOp
-    //
-    static const void *evalStringTableConstant(llvm::StringRef s) {
-        llvm::StringMap<const void *>::const_iterator oldConstant = staticStringTableConstants.find(s);
-        if (oldConstant != staticStringTableConstants.end())
-            return oldConstant->second;
-        size_t bits = typeSize(cSizeTType);
-        size_t size = s.size();
-        void *buf = malloc(size + bits + 1);
-        switch (bits) {
-            case 4:
-                *(size32_t *) buf = (size32_t) size;
-                break;
-            case 8:
-                *(size64_t *) buf = size;
-                break;
-            default:
-                error("unsupported pointer width");
+//
+// op_intToSizeT
+//
+
+static size_t op_intToSizeT(EValuePtr a) {
+    assert(a->type->typeKind == INTEGER_TYPE);
+    IntegerType *t = (IntegerType *)a->type.ptr();
+    if (t->isSigned) {
+        switch (t->bits) {
+        case 8:
+            return size_t(a->as<char>());
+        case 16:
+            return size_t(a->as<short>());
+        case 32:
+            return size_t(a->as<int>());
+        case 64:
+            return size_t(a->as<long long>());
+        case 128:
+            return size_t(a->as<clay_int128>());
+        default:
+            assert(false);
+        }
+    } else {
+        switch (t->bits) {
+        case 8:
+            return size_t(a->as<unsigned char>());
+        case 16:
+            return size_t(a->as<unsigned short>());
+        case 32:
+            return size_t(a->as<unsigned int>());
+        case 64:
+            return size_t(a->as<unsigned long long>());
+        case 128:
+            return size_t(a->as<clay_uint128>());
+        default:
+            assert(false);
         }
-        memcpy((void *) ((char *) buf + bits), (const void *) s.begin(), s.size());
-        ((char *) buf)[bits + s.size()] = 0;
-        staticStringTableConstants[s] = (const void *) buf;
-        return buf;
     }
+    return 0;
+}
 
-    void evalPrimOp(PrimOpPtr x, MultiEValuePtr args, MultiEValuePtr out) {
-        switch (x->primOpCode) {
-            case PRIM_TypeP: {
-                ensureArity(args, 1);
-                ObjectPtr obj = valueToStatic(args->values[0]);
-                bool isType = (obj.ptr() && (obj->objKind == TYPE));
-                assert(out->size() == 1);
-                EValuePtr out0 = out->values[0];
-                assert(out0->type == boolType);
-                out0->as<bool>() = isType;
-                break;
-            }
+//
+// op_pointerToInt
+//
+
+static void op_pointerToInt(EValuePtr dest, EValuePtr ev) {
+    assert(dest->type->typeKind == INTEGER_TYPE);
+    IntegerType *t = (IntegerType *)dest->type.ptr();
+    if (t->isSigned) {
+        switch (t->bits) {
+        case 8:
+            dest->as<char>() = ev->as<char>();
+            break;
+        case 16:
+            dest->as<short>() = ev->as<short>();
+            break;
+        case 32:
+            dest->as<int>() = ev->as<int>();
+            break;
+        case 64:
+            dest->as<long long>() = ev->as<long long>();
+            break;
+        case 128:
+            dest->as<clay_int128>() = ev->as<clay_int128>();
+            break;
+        default:
+            assert(false);
+        }
+    } else {
+        switch (t->bits) {
+        case 8:
+            dest->as<unsigned char>() = ev->as<unsigned char>();
+            break;
+        case 16:
+            dest->as<unsigned short>() = ev->as<unsigned short>();
+            break;
+        case 32:
+            dest->as<unsigned int>() = ev->as<unsigned int>();
+            break;
+        case 64:
+            dest->as<unsigned long long>() = ev->as<unsigned long long>();
+            break;
+        case 128:
+            dest->as<clay_uint128>() = ev->as<clay_uint128>();
+            break;
+        default:
+            assert(false);
+        }
+    }
+}
 
-            case PRIM_TypeSize: {
-                ensureArity(args, 1);
-                TypePtr t = valueToType(args, 0);
-                ValueHolderPtr vh = sizeTToValueHolder(typeSize(t));
-                evalStaticObject(vh.ptr(), out);
-                break;
-            }
+//
+// evalPrimOp
+//
+static const void *evalStringTableConstant(llvm::StringRef s) {
+    llvm::StringMap<const void *>::const_iterator oldConstant =
+        staticStringTableConstants.find(s);
+    if (oldConstant != staticStringTableConstants.end())
+        return oldConstant->second;
+    size_t bits = typeSize(cSizeTType);
+    size_t size = s.size();
+    void *buf = malloc(size + bits + 1);
+    switch (bits) {
+    case 4:
+        *(size32_t *)buf = (size32_t)size;
+        break;
+    case 8:
+        *(size64_t *)buf = size;
+        break;
+    default:
+        error("unsupported pointer width");
+    }
+    memcpy((void *)((char *)buf + bits), (const void *)s.begin(), s.size());
+    ((char *)buf)[bits + s.size()] = 0;
+    staticStringTableConstants[s] = (const void *)buf;
+    return buf;
+}
 
-            case PRIM_TypeAlignment: {
-                ensureArity(args, 1);
-                TypePtr t = valueToType(args, 0);
-                ValueHolderPtr vh = sizeTToValueHolder(typeAlignment(t));
-                evalStaticObject(vh.ptr(), out);
-                break;
-            }
+void evalPrimOp(PrimOpPtr x, MultiEValuePtr args, MultiEValuePtr out) {
+    switch (x->primOpCode) {
+    case PRIM_TypeP: {
+        ensureArity(args, 1);
+        ObjectPtr obj = valueToStatic(args->values[0]);
+        bool isType = (obj.ptr() && (obj->objKind == TYPE));
+        assert(out->size() == 1);
+        EValuePtr out0 = out->values[0];
+        assert(out0->type == boolType);
+        out0->as<bool>() = isType;
+        break;
+    }
 
-            case PRIM_OperatorP: {
-                ensureArity(args, 1);
-                ObjectPtr obj = valueToStatic(args->values[0]);
-                bool isOperator = false;
-                if (!!obj.ptr() && (obj->objKind == PROCEDURE || obj->objKind == GLOBAL_ALIAS)) {
-                    TopLevelItem *item = (TopLevelItem *) obj.ptr();
-                    isOperator = item->name->isOperator;
-                }
-                assert(out->size() == 1);
-                EValuePtr out0 = out->values[0];
-                assert(out0->type == boolType);
-                out0->as<bool>() = isOperator;
-                break;
-            }
+    case PRIM_TypeSize: {
+        ensureArity(args, 1);
+        TypePtr t = valueToType(args, 0);
+        ValueHolderPtr vh = sizeTToValueHolder(typeSize(t));
+        evalStaticObject(vh.ptr(), out);
+        break;
+    }
 
-            case PRIM_SymbolP: {
-                ensureArity(args, 1);
-                ObjectPtr obj = valueToStatic(args->values[0]);
-                bool isSymbol = false;
-                if (obj.ptr() != nullptr) {
-                    switch (obj->objKind) {
-                        case TYPE:
-                        case RECORD_DECL:
-                        case VARIANT_DECL:
-                        case PROCEDURE:
-                        case INTRINSIC:
-                        case GLOBAL_ALIAS:
-                            isSymbol = true;
-                            break;
-                        default:
-                            break;
-                    }
-                }
-                assert(out->size() == 1);
-                EValuePtr out0 = out->values[0];
-                assert(out0->type == boolType);
-                out0->as<bool>() = isSymbol;
-                break;
-            }
+    case PRIM_TypeAlignment: {
+        ensureArity(args, 1);
+        TypePtr t = valueToType(args, 0);
+        ValueHolderPtr vh = sizeTToValueHolder(typeAlignment(t));
+        evalStaticObject(vh.ptr(), out);
+        break;
+    }
 
-            case PRIM_StaticCallDefinedP: {
-                if (args->size() < 1)
-                    arityError2(1, args->size());
-                ObjectPtr callable = valueToStatic(args->values[0]);
-                if (callable == nullptr) {
-                    argumentError(0, "static callable expected");
-                }
-                switch (callable->objKind) {
-                    case TYPE:
-                    case RECORD_DECL:
-                    case VARIANT_DECL:
-                    case PROCEDURE:
-                    case INTRINSIC:
-                    case GLOBAL_ALIAS:
-                        break;
-                    default:
-                        argumentError(0, "invalid callable");
-                }
-                vector<PVData> pvArgs;
-                for (unsigned i = 1; i < args->size(); ++i) {
-                    TypePtr t = valueToType(args, i);
-                    pvArgs.push_back(PVData(t, false));
-                }
-                CompileContextPusher pusher(callable, pvArgs);
-                bool isDefined = analyzeIsDefined(callable, pvArgs);
-                ValueHolderPtr vh = boolToValueHolder(isDefined);
-                evalStaticObject(vh.ptr(), out);
-                break;
-            }
+    case PRIM_OperatorP: {
+        ensureArity(args, 1);
+        ObjectPtr obj = valueToStatic(args->values[0]);
+        bool isOperator = false;
+        if (!!obj.ptr() &&
+            (obj->objKind == PROCEDURE || obj->objKind == GLOBAL_ALIAS)) {
+            TopLevelItem *item = (TopLevelItem *)obj.ptr();
+            isOperator = item->name->isOperator;
+        }
+        assert(out->size() == 1);
+        EValuePtr out0 = out->values[0];
+        assert(out0->type == boolType);
+        out0->as<bool>() = isOperator;
+        break;
+    }
 
-            case PRIM_StaticCallOutputTypes:
+    case PRIM_SymbolP: {
+        ensureArity(args, 1);
+        ObjectPtr obj = valueToStatic(args->values[0]);
+        bool isSymbol = false;
+        if (obj.ptr() != nullptr) {
+            switch (obj->objKind) {
+            case TYPE:
+            case RECORD_DECL:
+            case VARIANT_DECL:
+            case PROCEDURE:
+            case INTRINSIC:
+            case GLOBAL_ALIAS:
+                isSymbol = true;
                 break;
-
-            case PRIM_StaticMonoP: {
-                ensureArity(args, 1);
-
-                bool isMono;
-
-                ObjectPtr callable = valueToStatic(args->values[0]);
-                if (callable != nullptr && callable->objKind == PROCEDURE) {
-                    Procedure *p = (Procedure *) callable.ptr();
-                    isMono = p->mono.monoState == Procedure_MonoOverload;
-                } else
-                    isMono = false;
-
-                ValueHolderPtr vh = boolToValueHolder(isMono);
-                evalStaticObject(vh.ptr(), out);
+            default:
                 break;
             }
+        }
+        assert(out->size() == 1);
+        EValuePtr out0 = out->values[0];
+        assert(out0->type == boolType);
+        out0->as<bool>() = isSymbol;
+        break;
+    }
 
-            case PRIM_StaticMonoInputTypes:
-                break;
-
-            case PRIM_bitcopy: {
-                ensureArity(args, 2);
-                EValuePtr ev0 = args->values[0];
-                EValuePtr ev1 = args->values[1];
-                if (!isPrimitiveType(ev0->type))
-                    argumentTypeError(0, "primitive type", ev0->type);
-                if (ev0->type != ev1->type)
-                    argumentTypeError(1, ev0->type, ev1->type);
-                memcpy(ev0->addr, ev1->addr, typeSize(ev0->type));
-                assert(out->size() == 0);
-                break;
-            }
+    case PRIM_StaticCallDefinedP: {
+        if (args->size() < 1)
+            arityError2(1, args->size());
+        ObjectPtr callable = valueToStatic(args->values[0]);
+        if (callable == nullptr) {
+            argumentError(0, "static callable expected");
+        }
+        switch (callable->objKind) {
+        case TYPE:
+        case RECORD_DECL:
+        case VARIANT_DECL:
+        case PROCEDURE:
+        case INTRINSIC:
+        case GLOBAL_ALIAS:
+            break;
+        default:
+            argumentError(0, "invalid callable");
+        }
+        vector<PVData> pvArgs;
+        for (unsigned i = 1; i < args->size(); ++i) {
+            TypePtr t = valueToType(args, i);
+            pvArgs.push_back(PVData(t, false));
+        }
+        CompileContextPusher pusher(callable, pvArgs);
+        bool isDefined = analyzeIsDefined(callable, pvArgs);
+        ValueHolderPtr vh = boolToValueHolder(isDefined);
+        evalStaticObject(vh.ptr(), out);
+        break;
+    }
 
-            case PRIM_boolNot: {
-                ensureArity(args, 1);
-                EValuePtr ev = args->values[0];
-                if (ev->type != boolType)
-                    argumentTypeError(0, boolType, ev->type);
-                assert(out->size() == 1);
-                EValuePtr out0 = out->values[0];
-                assert(out0->type == boolType);
-                out0->as<bool>() = !ev->as<bool>();
-                break;
-            }
+    case PRIM_StaticCallOutputTypes:
+        break;
 
-            case PRIM_integerEqualsP:
-            case PRIM_integerLesserP: {
-                ensureArity(args, 2);
-                TypePtr t;
-                EValuePtr ev0 = integerOrPointerLikeValue(args, 0, t);
-                EValuePtr ev1 = integerOrPointerLikeValue(args, 1, t);
-                assert(out->size() == 1);
-                EValuePtr out0 = out->values[0];
-                assert(out0->type == boolType);
-                switch (x->primOpCode) {
-                    case PRIM_integerEqualsP:
-                        binaryNumericOp<Op_orderedEqualsP>(ev0, ev1, out0);
-                        break;
-                    case PRIM_integerLesserP:
-                        binaryNumericOp<Op_orderedLesserP>(ev0, ev1, out0);
-                        break;
-                    default:
-                        assert(false);
-                }
-                break;
-            }
+    case PRIM_StaticMonoP: {
+        ensureArity(args, 1);
 
-            case PRIM_floatOrderedEqualsP:
-            case PRIM_floatOrderedLesserP:
-            case PRIM_floatOrderedLesserEqualsP:
-            case PRIM_floatOrderedGreaterP:
-            case PRIM_floatOrderedGreaterEqualsP:
-            case PRIM_floatOrderedNotEqualsP:
-            case PRIM_floatOrderedP:
-            case PRIM_floatUnorderedEqualsP:
-            case PRIM_floatUnorderedLesserP:
-            case PRIM_floatUnorderedLesserEqualsP:
-            case PRIM_floatUnorderedGreaterP:
-            case PRIM_floatUnorderedGreaterEqualsP:
-            case PRIM_floatUnorderedNotEqualsP:
-            case PRIM_floatUnorderedP: {
-                ensureArity(args, 2);
-                FloatTypePtr t;
-                EValuePtr ev0 = floatValue(args, 0, t);
-                EValuePtr ev1 = floatValue(args, 1, t);
-                assert(out->size() == 1);
-                EValuePtr out0 = out->values[0];
-                assert(out0->type == boolType);
-                switch (x->primOpCode) {
-                    case PRIM_floatOrderedEqualsP:
-                        binaryNumericOp<Op_orderedEqualsP>(ev0, ev1, out0);
-                        break;
-                    case PRIM_floatOrderedLesserP:
-                        binaryNumericOp<Op_orderedLesserP>(ev0, ev1, out0);
-                        break;
-                    case PRIM_floatOrderedLesserEqualsP:
-                        binaryNumericOp<Op_orderedLesserEqualsP>(ev0, ev1, out0);
-                        break;
-                    case PRIM_floatOrderedGreaterP:
-                        binaryNumericOp<Op_orderedGreaterP>(ev0, ev1, out0);
-                        break;
-                    case PRIM_floatOrderedGreaterEqualsP:
-                        binaryNumericOp<Op_orderedGreaterEqualsP>(ev0, ev1, out0);
-                        break;
-                    case PRIM_floatOrderedNotEqualsP:
-                        binaryNumericOp<Op_orderedNotEqualsP>(ev0, ev1, out0);
-                        break;
-                    case PRIM_floatOrderedP:
-                        binaryNumericOp<Op_orderedP>(ev0, ev1, out0);
-                        break;
-                    case PRIM_floatUnorderedEqualsP:
-                        binaryNumericOp<Op_unorderedEqualsP>(ev0, ev1, out0);
-                        break;
-                    case PRIM_floatUnorderedLesserP:
-                        binaryNumericOp<Op_unorderedLesserP>(ev0, ev1, out0);
-                        break;
-                    case PRIM_floatUnorderedLesserEqualsP:
-                        binaryNumericOp<Op_unorderedLesserEqualsP>(ev0, ev1, out0);
-                        break;
-                    case PRIM_floatUnorderedGreaterP:
-                        binaryNumericOp<Op_unorderedGreaterP>(ev0, ev1, out0);
-                        break;
-                    case PRIM_floatUnorderedGreaterEqualsP:
-                        binaryNumericOp<Op_unorderedGreaterEqualsP>(ev0, ev1, out0);
-                        break;
-                    case PRIM_floatUnorderedNotEqualsP:
-                        binaryNumericOp<Op_unorderedNotEqualsP>(ev0, ev1, out0);
-                        break;
-                    case PRIM_floatUnorderedP:
-                        binaryNumericOp<Op_unorderedP>(ev0, ev1, out0);
-                        break;
-                    default:
-                        assert(false);
-                }
-                break;
-            }
+        bool isMono;
 
-            case PRIM_numericAdd: {
-                ensureArity(args, 2);
-                TypePtr t;
-                EValuePtr ev0 = numericValue(args, 0, t);
-                EValuePtr ev1 = numericValue(args, 1, t);
-                assert(out->size() == 1);
-                EValuePtr out0 = out->values[0];
-                assert(out0->type == t);
-                binaryNumericOp<Op_numericAdd>(ev0, ev1, out0);
-                break;
-            }
+        ObjectPtr callable = valueToStatic(args->values[0]);
+        if (callable != nullptr && callable->objKind == PROCEDURE) {
+            Procedure *p = (Procedure *)callable.ptr();
+            isMono = p->mono.monoState == Procedure_MonoOverload;
+        } else
+            isMono = false;
 
-            case PRIM_numericSubtract: {
-                ensureArity(args, 2);
-                TypePtr t;
-                EValuePtr ev0 = numericValue(args, 0, t);
-                EValuePtr ev1 = numericValue(args, 1, t);
-                assert(out->size() == 1);
-                EValuePtr out0 = out->values[0];
-                assert(out0->type == t);
-                binaryNumericOp<Op_numericSubtract>(ev0, ev1, out0);
-                break;
-            }
+        ValueHolderPtr vh = boolToValueHolder(isMono);
+        evalStaticObject(vh.ptr(), out);
+        break;
+    }
 
-            case PRIM_numericMultiply: {
-                ensureArity(args, 2);
-                TypePtr t;
-                EValuePtr ev0 = numericValue(args, 0, t);
-                EValuePtr ev1 = numericValue(args, 1, t);
-                assert(out->size() == 1);
-                EValuePtr out0 = out->values[0];
-                assert(out0->type == t);
-                binaryNumericOp<Op_numericMultiply>(ev0, ev1, out0);
-                break;
-            }
+    case PRIM_StaticMonoInputTypes:
+        break;
+
+    case PRIM_bitcopy: {
+        ensureArity(args, 2);
+        EValuePtr ev0 = args->values[0];
+        EValuePtr ev1 = args->values[1];
+        if (!isPrimitiveType(ev0->type))
+            argumentTypeError(0, "primitive type", ev0->type);
+        if (ev0->type != ev1->type)
+            argumentTypeError(1, ev0->type, ev1->type);
+        memcpy(ev0->addr, ev1->addr, typeSize(ev0->type));
+        assert(out->size() == 0);
+        break;
+    }
 
-            case PRIM_floatDivide: {
-                ensureArity(args, 2);
-                FloatTypePtr t;
-                EValuePtr ev0 = floatValue(args, 0, t);
-                EValuePtr ev1 = floatValue(args, 1, t);
-                assert(out->size() == 1);
-                EValuePtr out0 = out->values[0];
-                assert(out0->type == t.ptr());
-                binaryNumericOp<Op_floatDivide>(ev0, ev1, out0);
-                break;
-            }
+    case PRIM_boolNot: {
+        ensureArity(args, 1);
+        EValuePtr ev = args->values[0];
+        if (ev->type != boolType)
+            argumentTypeError(0, boolType, ev->type);
+        assert(out->size() == 1);
+        EValuePtr out0 = out->values[0];
+        assert(out0->type == boolType);
+        out0->as<bool>() = !ev->as<bool>();
+        break;
+    }
 
-            case PRIM_numericNegate: {
-                ensureArity(args, 1);
-                TypePtr t;
-                EValuePtr ev = numericValue(args, 0, t);
-                assert(out->size() == 1);
-                EValuePtr out0 = out->values[0];
-                assert(out0->type == t);
-                unaryNumericOp<Op_numericNegate>(ev, out0);
-                break;
-            }
+    case PRIM_integerEqualsP:
+    case PRIM_integerLesserP: {
+        ensureArity(args, 2);
+        TypePtr t;
+        EValuePtr ev0 = integerOrPointerLikeValue(args, 0, t);
+        EValuePtr ev1 = integerOrPointerLikeValue(args, 1, t);
+        assert(out->size() == 1);
+        EValuePtr out0 = out->values[0];
+        assert(out0->type == boolType);
+        switch (x->primOpCode) {
+        case PRIM_integerEqualsP:
+            binaryNumericOp<Op_orderedEqualsP>(ev0, ev1, out0);
+            break;
+        case PRIM_integerLesserP:
+            binaryNumericOp<Op_orderedLesserP>(ev0, ev1, out0);
+            break;
+        default:
+            assert(false);
+        }
+        break;
+    }
 
-            case PRIM_integerQuotient: {
-                ensureArity(args, 2);
-                IntegerTypePtr t;
-                EValuePtr ev0 = integerValue(args, 0, t);
-                EValuePtr ev1 = integerValue(args, 1, t);
-                assert(out->size() == 1);
-                EValuePtr out0 = out->values[0];
-                assert(out0->type.ptr() == t.ptr());
-                binaryIntegerOp<Op_integerQuotient>(ev0, ev1, out0);
-                break;
-            }
+    case PRIM_floatOrderedEqualsP:
+    case PRIM_floatOrderedLesserP:
+    case PRIM_floatOrderedLesserEqualsP:
+    case PRIM_floatOrderedGreaterP:
+    case PRIM_floatOrderedGreaterEqualsP:
+    case PRIM_floatOrderedNotEqualsP:
+    case PRIM_floatOrderedP:
+    case PRIM_floatUnorderedEqualsP:
+    case PRIM_floatUnorderedLesserP:
+    case PRIM_floatUnorderedLesserEqualsP:
+    case PRIM_floatUnorderedGreaterP:
+    case PRIM_floatUnorderedGreaterEqualsP:
+    case PRIM_floatUnorderedNotEqualsP:
+    case PRIM_floatUnorderedP: {
+        ensureArity(args, 2);
+        FloatTypePtr t;
+        EValuePtr ev0 = floatValue(args, 0, t);
+        EValuePtr ev1 = floatValue(args, 1, t);
+        assert(out->size() == 1);
+        EValuePtr out0 = out->values[0];
+        assert(out0->type == boolType);
+        switch (x->primOpCode) {
+        case PRIM_floatOrderedEqualsP:
+            binaryNumericOp<Op_orderedEqualsP>(ev0, ev1, out0);
+            break;
+        case PRIM_floatOrderedLesserP:
+            binaryNumericOp<Op_orderedLesserP>(ev0, ev1, out0);
+            break;
+        case PRIM_floatOrderedLesserEqualsP:
+            binaryNumericOp<Op_orderedLesserEqualsP>(ev0, ev1, out0);
+            break;
+        case PRIM_floatOrderedGreaterP:
+            binaryNumericOp<Op_orderedGreaterP>(ev0, ev1, out0);
+            break;
+        case PRIM_floatOrderedGreaterEqualsP:
+            binaryNumericOp<Op_orderedGreaterEqualsP>(ev0, ev1, out0);
+            break;
+        case PRIM_floatOrderedNotEqualsP:
+            binaryNumericOp<Op_orderedNotEqualsP>(ev0, ev1, out0);
+            break;
+        case PRIM_floatOrderedP:
+            binaryNumericOp<Op_orderedP>(ev0, ev1, out0);
+            break;
+        case PRIM_floatUnorderedEqualsP:
+            binaryNumericOp<Op_unorderedEqualsP>(ev0, ev1, out0);
+            break;
+        case PRIM_floatUnorderedLesserP:
+            binaryNumericOp<Op_unorderedLesserP>(ev0, ev1, out0);
+            break;
+        case PRIM_floatUnorderedLesserEqualsP:
+            binaryNumericOp<Op_unorderedLesserEqualsP>(ev0, ev1, out0);
+            break;
+        case PRIM_floatUnorderedGreaterP:
+            binaryNumericOp<Op_unorderedGreaterP>(ev0, ev1, out0);
+            break;
+        case PRIM_floatUnorderedGreaterEqualsP:
+            binaryNumericOp<Op_unorderedGreaterEqualsP>(ev0, ev1, out0);
+            break;
+        case PRIM_floatUnorderedNotEqualsP:
+            binaryNumericOp<Op_unorderedNotEqualsP>(ev0, ev1, out0);
+            break;
+        case PRIM_floatUnorderedP:
+            binaryNumericOp<Op_unorderedP>(ev0, ev1, out0);
+            break;
+        default:
+            assert(false);
+        }
+        break;
+    }
 
-            case PRIM_integerRemainder: {
-                ensureArity(args, 2);
-                IntegerTypePtr t;
-                EValuePtr ev0 = integerValue(args, 0, t);
-                EValuePtr ev1 = integerValue(args, 1, t);
-                assert(out->size() == 1);
-                EValuePtr out0 = out->values[0];
-                assert(out0->type.ptr() == t.ptr());
-                binaryIntegerOp<Op_integerRemainder>(ev0, ev1, out0);
-                break;
-            }
+    case PRIM_numericAdd: {
+        ensureArity(args, 2);
+        TypePtr t;
+        EValuePtr ev0 = numericValue(args, 0, t);
+        EValuePtr ev1 = numericValue(args, 1, t);
+        assert(out->size() == 1);
+        EValuePtr out0 = out->values[0];
+        assert(out0->type == t);
+        binaryNumericOp<Op_numericAdd>(ev0, ev1, out0);
+        break;
+    }
 
-            case PRIM_integerAddChecked: {
-                ensureArity(args, 2);
-                IntegerTypePtr t;
-                EValuePtr ev0 = integerValue(args, 0, t);
-                EValuePtr ev1 = integerValue(args, 1, t);
-                assert(out->size() == 1);
-                EValuePtr out0 = out->values[0];
-                assert(out0->type.ptr() == t.ptr());
-                binaryIntegerOp<Op_integerAddChecked>(ev0, ev1, out0);
-                break;
-            }
+    case PRIM_numericSubtract: {
+        ensureArity(args, 2);
+        TypePtr t;
+        EValuePtr ev0 = numericValue(args, 0, t);
+        EValuePtr ev1 = numericValue(args, 1, t);
+        assert(out->size() == 1);
+        EValuePtr out0 = out->values[0];
+        assert(out0->type == t);
+        binaryNumericOp<Op_numericSubtract>(ev0, ev1, out0);
+        break;
+    }
 
-            case PRIM_integerSubtractChecked: {
-                ensureArity(args, 2);
-                IntegerTypePtr t;
-                EValuePtr ev0 = integerValue(args, 0, t);
-                EValuePtr ev1 = integerValue(args, 1, t);
-                assert(out->size() == 1);
-                EValuePtr out0 = out->values[0];
-                assert(out0->type.ptr() == t.ptr());
-                binaryIntegerOp<Op_integerSubtractChecked>(ev0, ev1, out0);
-                break;
-            }
+    case PRIM_numericMultiply: {
+        ensureArity(args, 2);
+        TypePtr t;
+        EValuePtr ev0 = numericValue(args, 0, t);
+        EValuePtr ev1 = numericValue(args, 1, t);
+        assert(out->size() == 1);
+        EValuePtr out0 = out->values[0];
+        assert(out0->type == t);
+        binaryNumericOp<Op_numericMultiply>(ev0, ev1, out0);
+        break;
+    }
 
-            case PRIM_integerMultiplyChecked: {
-                ensureArity(args, 2);
-                IntegerTypePtr t;
-                EValuePtr ev0 = integerValue(args, 0, t);
-                EValuePtr ev1 = integerValue(args, 1, t);
-                assert(out->size() == 1);
-                EValuePtr out0 = out->values[0];
-                assert(out0->type.ptr() == t.ptr());
-                binaryIntegerOp<Op_integerMultiplyChecked>(ev0, ev1, out0);
-                break;
-            }
+    case PRIM_floatDivide: {
+        ensureArity(args, 2);
+        FloatTypePtr t;
+        EValuePtr ev0 = floatValue(args, 0, t);
+        EValuePtr ev1 = floatValue(args, 1, t);
+        assert(out->size() == 1);
+        EValuePtr out0 = out->values[0];
+        assert(out0->type == t.ptr());
+        binaryNumericOp<Op_floatDivide>(ev0, ev1, out0);
+        break;
+    }
 
-            case PRIM_integerQuotientChecked: {
-                ensureArity(args, 2);
-                IntegerTypePtr t;
-                EValuePtr ev0 = integerValue(args, 0, t);
-                EValuePtr ev1 = integerValue(args, 1, t);
-                assert(out->size() == 1);
-                EValuePtr out0 = out->values[0];
-                assert(out0->type.ptr() == t.ptr());
-                binaryIntegerOp<Op_integerQuotientChecked>(ev0, ev1, out0);
-                break;
-            }
+    case PRIM_numericNegate: {
+        ensureArity(args, 1);
+        TypePtr t;
+        EValuePtr ev = numericValue(args, 0, t);
+        assert(out->size() == 1);
+        EValuePtr out0 = out->values[0];
+        assert(out0->type == t);
+        unaryNumericOp<Op_numericNegate>(ev, out0);
+        break;
+    }
 
-            case PRIM_integerRemainderChecked: {
-                ensureArity(args, 2);
-                IntegerTypePtr t;
-                EValuePtr ev0 = integerValue(args, 0, t);
-                EValuePtr ev1 = integerValue(args, 1, t);
-                assert(out->size() == 1);
-                EValuePtr out0 = out->values[0];
-                assert(out0->type.ptr() == t.ptr());
-                binaryIntegerOp<Op_integerRemainderChecked>(ev0, ev1, out0);
-                break;
-            }
+    case PRIM_integerQuotient: {
+        ensureArity(args, 2);
+        IntegerTypePtr t;
+        EValuePtr ev0 = integerValue(args, 0, t);
+        EValuePtr ev1 = integerValue(args, 1, t);
+        assert(out->size() == 1);
+        EValuePtr out0 = out->values[0];
+        assert(out0->type.ptr() == t.ptr());
+        binaryIntegerOp<Op_integerQuotient>(ev0, ev1, out0);
+        break;
+    }
 
-            case PRIM_integerNegateChecked: {
-                ensureArity(args, 1);
-                IntegerTypePtr t;
-                EValuePtr ev = integerValue(args, 0, t);
-                assert(out->size() == 1);
-                EValuePtr out0 = out->values[0];
-                assert(out0->type == t.ptr());
-                unaryIntegerOp<Op_integerNegateChecked>(ev, out0);
-                break;
-            }
+    case PRIM_integerRemainder: {
+        ensureArity(args, 2);
+        IntegerTypePtr t;
+        EValuePtr ev0 = integerValue(args, 0, t);
+        EValuePtr ev1 = integerValue(args, 1, t);
+        assert(out->size() == 1);
+        EValuePtr out0 = out->values[0];
+        assert(out0->type.ptr() == t.ptr());
+        binaryIntegerOp<Op_integerRemainder>(ev0, ev1, out0);
+        break;
+    }
 
-            case PRIM_integerShiftLeft: {
-                ensureArity(args, 2);
-                IntegerTypePtr t;
-                EValuePtr ev0 = integerValue(args, 0, t);
-                EValuePtr ev1 = integerValue(args, 1, t);
-                assert(out->size() == 1);
-                EValuePtr out0 = out->values[0];
-                assert(out0->type == t.ptr());
-                binaryIntegerOp<Op_integerShiftLeft>(ev0, ev1, out0);
-                break;
-            }
+    case PRIM_integerAddChecked: {
+        ensureArity(args, 2);
+        IntegerTypePtr t;
+        EValuePtr ev0 = integerValue(args, 0, t);
+        EValuePtr ev1 = integerValue(args, 1, t);
+        assert(out->size() == 1);
+        EValuePtr out0 = out->values[0];
+        assert(out0->type.ptr() == t.ptr());
+        binaryIntegerOp<Op_integerAddChecked>(ev0, ev1, out0);
+        break;
+    }
 
-            case PRIM_integerShiftRight: {
-                ensureArity(args, 2);
-                IntegerTypePtr t;
-                EValuePtr ev0 = integerValue(args, 0, t);
-                EValuePtr ev1 = integerValue(args, 1, t);
-                assert(out->size() == 1);
-                EValuePtr out0 = out->values[0];
-                assert(out0->type == t.ptr());
-                binaryIntegerOp<Op_integerShiftRight>(ev0, ev1, out0);
-                break;
-            }
+    case PRIM_integerSubtractChecked: {
+        ensureArity(args, 2);
+        IntegerTypePtr t;
+        EValuePtr ev0 = integerValue(args, 0, t);
+        EValuePtr ev1 = integerValue(args, 1, t);
+        assert(out->size() == 1);
+        EValuePtr out0 = out->values[0];
+        assert(out0->type.ptr() == t.ptr());
+        binaryIntegerOp<Op_integerSubtractChecked>(ev0, ev1, out0);
+        break;
+    }
 
-            case PRIM_integerBitwiseAnd: {
-                ensureArity(args, 2);
-                IntegerTypePtr t;
-                EValuePtr ev0 = integerValue(args, 0, t);
-                EValuePtr ev1 = integerValue(args, 1, t);
-                assert(out->size() == 1);
-                EValuePtr out0 = out->values[0];
-                assert(out0->type == t.ptr());
-                binaryIntegerOp<Op_integerBitwiseAnd>(ev0, ev1, out0);
-                break;
-            }
+    case PRIM_integerMultiplyChecked: {
+        ensureArity(args, 2);
+        IntegerTypePtr t;
+        EValuePtr ev0 = integerValue(args, 0, t);
+        EValuePtr ev1 = integerValue(args, 1, t);
+        assert(out->size() == 1);
+        EValuePtr out0 = out->values[0];
+        assert(out0->type.ptr() == t.ptr());
+        binaryIntegerOp<Op_integerMultiplyChecked>(ev0, ev1, out0);
+        break;
+    }
 
-            case PRIM_integerBitwiseOr: {
-                ensureArity(args, 2);
-                IntegerTypePtr t;
-                EValuePtr ev0 = integerValue(args, 0, t);
-                EValuePtr ev1 = integerValue(args, 1, t);
-                assert(out->size() == 1);
-                EValuePtr out0 = out->values[0];
-                assert(out0->type == t.ptr());
-                binaryIntegerOp<Op_integerBitwiseOr>(ev0, ev1, out0);
-                break;
-            }
+    case PRIM_integerQuotientChecked: {
+        ensureArity(args, 2);
+        IntegerTypePtr t;
+        EValuePtr ev0 = integerValue(args, 0, t);
+        EValuePtr ev1 = integerValue(args, 1, t);
+        assert(out->size() == 1);
+        EValuePtr out0 = out->values[0];
+        assert(out0->type.ptr() == t.ptr());
+        binaryIntegerOp<Op_integerQuotientChecked>(ev0, ev1, out0);
+        break;
+    }
 
-            case PRIM_integerBitwiseXor: {
-                ensureArity(args, 2);
-                IntegerTypePtr t;
-                EValuePtr ev0 = integerValue(args, 0, t);
-                EValuePtr ev1 = integerValue(args, 1, t);
-                assert(out->size() == 1);
-                EValuePtr out0 = out->values[0];
-                assert(out0->type == t.ptr());
-                binaryIntegerOp<Op_integerBitwiseXor>(ev0, ev1, out0);
-                break;
-            }
+    case PRIM_integerRemainderChecked: {
+        ensureArity(args, 2);
+        IntegerTypePtr t;
+        EValuePtr ev0 = integerValue(args, 0, t);
+        EValuePtr ev1 = integerValue(args, 1, t);
+        assert(out->size() == 1);
+        EValuePtr out0 = out->values[0];
+        assert(out0->type.ptr() == t.ptr());
+        binaryIntegerOp<Op_integerRemainderChecked>(ev0, ev1, out0);
+        break;
+    }
 
-            case PRIM_integerBitwiseNot: {
-                ensureArity(args, 1);
-                IntegerTypePtr t;
-                EValuePtr ev = integerValue(args, 0, t);
-                assert(out->size() == 1);
-                EValuePtr out0 = out->values[0];
-                assert(out0->type == t.ptr());
-                unaryIntegerOp<Op_integerBitwiseNot>(ev, out0);
-                break;
-            }
+    case PRIM_integerNegateChecked: {
+        ensureArity(args, 1);
+        IntegerTypePtr t;
+        EValuePtr ev = integerValue(args, 0, t);
+        assert(out->size() == 1);
+        EValuePtr out0 = out->values[0];
+        assert(out0->type == t.ptr());
+        unaryIntegerOp<Op_integerNegateChecked>(ev, out0);
+        break;
+    }
 
-            case PRIM_numericConvert: {
-                ensureArity(args, 2);
-                TypePtr dest = valueToNumericType(args, 0);
-                TypePtr src;
-                EValuePtr ev = numericValue(args, 1, src);
-                assert(out->size() == 1);
-                EValuePtr out0 = out->values[0];
-                assert(out0->type == dest);
-                op_numericConvert<false>(out0, ev);
-                break;
-            }
+    case PRIM_integerShiftLeft: {
+        ensureArity(args, 2);
+        IntegerTypePtr t;
+        EValuePtr ev0 = integerValue(args, 0, t);
+        EValuePtr ev1 = integerValue(args, 1, t);
+        assert(out->size() == 1);
+        EValuePtr out0 = out->values[0];
+        assert(out0->type == t.ptr());
+        binaryIntegerOp<Op_integerShiftLeft>(ev0, ev1, out0);
+        break;
+    }
 
-            case PRIM_integerConvertChecked: {
-                ensureArity(args, 2);
-                TypePtr dest = valueToIntegerType(args, 0).ptr();
-                TypePtr src;
-                EValuePtr ev = numericValue(args, 1, src);
-                assert(out->size() == 1);
-                EValuePtr out0 = out->values[0];
-                assert(out0->type == dest);
-                op_numericConvert<true>(out0, ev);
-                break;
-            }
+    case PRIM_integerShiftRight: {
+        ensureArity(args, 2);
+        IntegerTypePtr t;
+        EValuePtr ev0 = integerValue(args, 0, t);
+        EValuePtr ev1 = integerValue(args, 1, t);
+        assert(out->size() == 1);
+        EValuePtr out0 = out->values[0];
+        assert(out0->type == t.ptr());
+        binaryIntegerOp<Op_integerShiftRight>(ev0, ev1, out0);
+        break;
+    }
 
-            case PRIM_integerShiftLeftChecked: {
-                ensureArity(args, 2);
-                IntegerTypePtr t;
-                EValuePtr ev0 = integerValue(args, 0, t);
-                EValuePtr ev1 = integerValue(args, 1, t);
-                assert(out->size() == 1);
-                EValuePtr out0 = out->values[0];
-                assert(out0->type == t.ptr());
-                binaryIntegerOp<Op_integerShiftLeftChecked>(ev0, ev1, out0);
-                break;
-            }
+    case PRIM_integerBitwiseAnd: {
+        ensureArity(args, 2);
+        IntegerTypePtr t;
+        EValuePtr ev0 = integerValue(args, 0, t);
+        EValuePtr ev1 = integerValue(args, 1, t);
+        assert(out->size() == 1);
+        EValuePtr out0 = out->values[0];
+        assert(out0->type == t.ptr());
+        binaryIntegerOp<Op_integerBitwiseAnd>(ev0, ev1, out0);
+        break;
+    }
 
-            case PRIM_Pointer:
-                error("Pointer type constructor cannot be called");
+    case PRIM_integerBitwiseOr: {
+        ensureArity(args, 2);
+        IntegerTypePtr t;
+        EValuePtr ev0 = integerValue(args, 0, t);
+        EValuePtr ev1 = integerValue(args, 1, t);
+        assert(out->size() == 1);
+        EValuePtr out0 = out->values[0];
+        assert(out0->type == t.ptr());
+        binaryIntegerOp<Op_integerBitwiseOr>(ev0, ev1, out0);
+        break;
+    }
 
-            case PRIM_addressOf: {
-                ensureArity(args, 1);
-                EValuePtr ev = args->values[0];
-                assert(out->size() == 1);
-                EValuePtr out0 = out->values[0];
-                assert(out0->type == pointerType(ev->type));
-                out0->as<void *>() = (void *) ev->addr;
-                break;
-            }
+    case PRIM_integerBitwiseXor: {
+        ensureArity(args, 2);
+        IntegerTypePtr t;
+        EValuePtr ev0 = integerValue(args, 0, t);
+        EValuePtr ev1 = integerValue(args, 1, t);
+        assert(out->size() == 1);
+        EValuePtr out0 = out->values[0];
+        assert(out0->type == t.ptr());
+        binaryIntegerOp<Op_integerBitwiseXor>(ev0, ev1, out0);
+        break;
+    }
 
-            case PRIM_pointerDereference: {
-                ensureArity(args, 1);
-                PointerTypePtr t;
-                EValuePtr ev = pointerValue(args, 0, t);
-                assert(out->size() == 1);
-                EValuePtr out0 = out->values[0];
-                assert(out0->type == t.ptr());
-                out0->as<void *>() = ev->as<void *>();
-                break;
-            }
+    case PRIM_integerBitwiseNot: {
+        ensureArity(args, 1);
+        IntegerTypePtr t;
+        EValuePtr ev = integerValue(args, 0, t);
+        assert(out->size() == 1);
+        EValuePtr out0 = out->values[0];
+        assert(out0->type == t.ptr());
+        unaryIntegerOp<Op_integerBitwiseNot>(ev, out0);
+        break;
+    }
 
-            case PRIM_pointerOffset: {
-                ensureArity(args, 2);
-                PointerTypePtr t;
-                EValuePtr v0 = pointerValue(args, 0, t);
-                IntegerTypePtr offsetT;
-                EValuePtr v1 = integerValue(args, 1, offsetT);
-                ptrdiff_t offset = op_intToPtrInt(v1);
-                char *ptr = v0->as<char *>();
-                ptr += offset * (ptrdiff_t) typeSize(t->pointeeType);
-                assert(out->size() == 1);
-                EValuePtr out0 = out->values[0];
-                assert(out0->type == t.ptr());
-                out0->as<void *>() = (void *) ptr;
-                break;
-            }
+    case PRIM_numericConvert: {
+        ensureArity(args, 2);
+        TypePtr dest = valueToNumericType(args, 0);
+        TypePtr src;
+        EValuePtr ev = numericValue(args, 1, src);
+        assert(out->size() == 1);
+        EValuePtr out0 = out->values[0];
+        assert(out0->type == dest);
+        op_numericConvert<false>(out0, ev);
+        break;
+    }
 
-            case PRIM_pointerToInt: {
-                ensureArity(args, 2);
-                IntegerTypePtr dest = valueToIntegerType(args, 0);
-                TypePtr pt;
-                EValuePtr ev = pointerLikeValue(args, 1, pt);
-                assert(out->size() == 1);
-                EValuePtr out0 = out->values[0];
-                assert(out0->type == dest.ptr());
-                op_pointerToInt(out0, ev);
-                break;
-            }
+    case PRIM_integerConvertChecked: {
+        ensureArity(args, 2);
+        TypePtr dest = valueToIntegerType(args, 0).ptr();
+        TypePtr src;
+        EValuePtr ev = numericValue(args, 1, src);
+        assert(out->size() == 1);
+        EValuePtr out0 = out->values[0];
+        assert(out0->type == dest);
+        op_numericConvert<true>(out0, ev);
+        break;
+    }
 
-            case PRIM_intToPointer: {
-                ensureArity(args, 2);
-                TypePtr dest = valueToPointerLikeType(args, 0);
-                IntegerTypePtr t;
-                EValuePtr ev = integerValue(args, 1, t);
-                assert(out->size() == 1);
-                EValuePtr out0 = out->values[0];
-                assert(out0->type == dest);
-                ptrdiff_t ptrInt = op_intToPtrInt(ev);
-                out0->as<void *>() = (void *) ptrInt;
-                break;
-            }
+    case PRIM_integerShiftLeftChecked: {
+        ensureArity(args, 2);
+        IntegerTypePtr t;
+        EValuePtr ev0 = integerValue(args, 0, t);
+        EValuePtr ev1 = integerValue(args, 1, t);
+        assert(out->size() == 1);
+        EValuePtr out0 = out->values[0];
+        assert(out0->type == t.ptr());
+        binaryIntegerOp<Op_integerShiftLeftChecked>(ev0, ev1, out0);
+        break;
+    }
 
-            case PRIM_nullPointer: {
-                ensureArity(args, 1);
-                TypePtr dest = valueToPointerLikeType(args, 0);
-                assert(out->size() == 1);
-                EValuePtr out0 = out->values[0];
-                assert(out0->type == dest);
-                out0->as<void *>() = 0;
-                break;
-            }
+    case PRIM_Pointer:
+        error("Pointer type constructor cannot be called");
+
+    case PRIM_addressOf: {
+        ensureArity(args, 1);
+        EValuePtr ev = args->values[0];
+        assert(out->size() == 1);
+        EValuePtr out0 = out->values[0];
+        assert(out0->type == pointerType(ev->type));
+        out0->as<void *>() = (void *)ev->addr;
+        break;
+    }
 
-            case PRIM_CodePointer:
-                error("CodePointer type constructor cannot be called");
+    case PRIM_pointerDereference: {
+        ensureArity(args, 1);
+        PointerTypePtr t;
+        EValuePtr ev = pointerValue(args, 0, t);
+        assert(out->size() == 1);
+        EValuePtr out0 = out->values[0];
+        assert(out0->type == t.ptr());
+        out0->as<void *>() = ev->as<void *>();
+        break;
+    }
 
-            case PRIM_makeCodePointer: {
-                error("code pointers cannot be taken at compile time");
-                break;
-            }
+    case PRIM_pointerOffset: {
+        ensureArity(args, 2);
+        PointerTypePtr t;
+        EValuePtr v0 = pointerValue(args, 0, t);
+        IntegerTypePtr offsetT;
+        EValuePtr v1 = integerValue(args, 1, offsetT);
+        ptrdiff_t offset = op_intToPtrInt(v1);
+        char *ptr = v0->as<char *>();
+        ptr += offset * (ptrdiff_t)typeSize(t->pointeeType);
+        assert(out->size() == 1);
+        EValuePtr out0 = out->values[0];
+        assert(out0->type == t.ptr());
+        out0->as<void *>() = (void *)ptr;
+        break;
+    }
 
-            case PRIM_ExternalCodePointer:
-                error("ExternalCodePointer type constructor cannot be called");
+    case PRIM_pointerToInt: {
+        ensureArity(args, 2);
+        IntegerTypePtr dest = valueToIntegerType(args, 0);
+        TypePtr pt;
+        EValuePtr ev = pointerLikeValue(args, 1, pt);
+        assert(out->size() == 1);
+        EValuePtr out0 = out->values[0];
+        assert(out0->type == dest.ptr());
+        op_pointerToInt(out0, ev);
+        break;
+    }
 
-            case PRIM_makeExternalCodePointer: {
-                error("code pointers cannot be created at compile time");
-                break;
-            }
+    case PRIM_intToPointer: {
+        ensureArity(args, 2);
+        TypePtr dest = valueToPointerLikeType(args, 0);
+        IntegerTypePtr t;
+        EValuePtr ev = integerValue(args, 1, t);
+        assert(out->size() == 1);
+        EValuePtr out0 = out->values[0];
+        assert(out0->type == dest);
+        ptrdiff_t ptrInt = op_intToPtrInt(ev);
+        out0->as<void *>() = (void *)ptrInt;
+        break;
+    }
 
-            case PRIM_callExternalCodePointer: {
-                error("invoking a code pointer not yet supported in evaluator");
-                break;
-            }
+    case PRIM_nullPointer: {
+        ensureArity(args, 1);
+        TypePtr dest = valueToPointerLikeType(args, 0);
+        assert(out->size() == 1);
+        EValuePtr out0 = out->values[0];
+        assert(out0->type == dest);
+        out0->as<void *>() = 0;
+        break;
+    }
 
-            case PRIM_bitcast: {
-                ensureArity(args, 2);
-                TypePtr dest = valueToType(args, 0);
-                EValuePtr ev = args->values[1];
-                if (typeSize(dest) > typeSize(ev->type))
-                    error("destination type for bitcast is larger than source type");
-                if (typeAlignment(dest) > typeAlignment(ev->type))
-                    error("destination type for bitcast has stricter alignment than source type");
-                assert(out->size() == 1);
-                EValuePtr out0 = out->values[0];
-                assert(out0->type == pointerType(dest));
-                out0->as<void *>() = (void *) ev->addr;
-                break;
-            }
+    case PRIM_CodePointer:
+        error("CodePointer type constructor cannot be called");
 
-            case PRIM_Array:
-                error("Array type constructor cannot be called");
+    case PRIM_makeCodePointer: {
+        error("code pointers cannot be taken at compile time");
+        break;
+    }
 
-            case PRIM_Vec:
-                error("Vec type constructor cannot be called");
+    case PRIM_ExternalCodePointer:
+        error("ExternalCodePointer type constructor cannot be called");
 
-            case PRIM_arrayRef: {
-                ensureArity(args, 2);
-                ArrayTypePtr at;
-                EValuePtr earray = arrayValue(args, 0, at);
-                IntegerTypePtr indexType;
-                EValuePtr iv = integerValue(args, 1, indexType);
-                ptrdiff_t i = op_intToPtrInt(iv);
-                char *ptr = earray->addr + i * (ptrdiff_t) typeSize(at->elementType);
-                assert(out->size() == 1);
-                EValuePtr out0 = out->values[0];
-                assert(out0->type == pointerType(at->elementType));
-                out0->as<void *>() = (void *) ptr;
-                break;
-            }
+    case PRIM_makeExternalCodePointer: {
+        error("code pointers cannot be created at compile time");
+        break;
+    }
 
-            case PRIM_arrayElements: {
-                ensureArity(args, 1);
-                ArrayTypePtr at;
-                EValuePtr earray = arrayValue(args, 0, at);
-                assert(out->size() == (size_t)at->size);
-                for (size_t i = 0; i < (size_t) at->size; ++i) {
-                    EValuePtr outi = out->values[i];
-                    assert(outi->type == pointerType(at->elementType));
-                    char *ptr = earray->addr + i * typeSize(at->elementType);
-                    outi->as<void *>() = (void *) ptr;
-                }
-                break;
-            }
+    case PRIM_callExternalCodePointer: {
+        error("invoking a code pointer not yet supported in evaluator");
+        break;
+    }
 
-            case PRIM_Tuple:
-                error("Tuple type constructor cannot be called");
+    case PRIM_bitcast: {
+        ensureArity(args, 2);
+        TypePtr dest = valueToType(args, 0);
+        EValuePtr ev = args->values[1];
+        if (typeSize(dest) > typeSize(ev->type))
+            error("destination type for bitcast is larger than source type");
+        if (typeAlignment(dest) > typeAlignment(ev->type))
+            error("destination type for bitcast has stricter alignment than "
+                  "source type");
+        assert(out->size() == 1);
+        EValuePtr out0 = out->values[0];
+        assert(out0->type == pointerType(dest));
+        out0->as<void *>() = (void *)ev->addr;
+        break;
+    }
 
-            case PRIM_TupleElementCount: {
-                ensureArity(args, 1);
-                TupleTypePtr t = valueToTupleType(args, 0);
-                ValueHolderPtr vh = sizeTToValueHolder(t->elementTypes.size());
-                evalStaticObject(vh.ptr(), out);
-                break;
-            }
+    case PRIM_Array:
+        error("Array type constructor cannot be called");
+
+    case PRIM_Vec:
+        error("Vec type constructor cannot be called");
+
+    case PRIM_arrayRef: {
+        ensureArity(args, 2);
+        ArrayTypePtr at;
+        EValuePtr earray = arrayValue(args, 0, at);
+        IntegerTypePtr indexType;
+        EValuePtr iv = integerValue(args, 1, indexType);
+        ptrdiff_t i = op_intToPtrInt(iv);
+        char *ptr = earray->addr + i * (ptrdiff_t)typeSize(at->elementType);
+        assert(out->size() == 1);
+        EValuePtr out0 = out->values[0];
+        assert(out0->type == pointerType(at->elementType));
+        out0->as<void *>() = (void *)ptr;
+        break;
+    }
 
-            case PRIM_tupleRef: {
-                ensureArity(args, 2);
-                TupleTypePtr tt;
-                EValuePtr etuple = tupleValue(args, 0, tt);
-                size_t i = valueToStaticSizeTOrInt(args, 1);
-                if (i >= tt->elementTypes.size())
-                    argumentIndexRangeError(1, "tuple element index",
-                                            i, tt->elementTypes.size());
-                const llvm::StructLayout *layout = tupleTypeLayout(tt.ptr());
-                char *ptr = etuple->addr + layout->getElementOffset(unsigned(i));
-                assert(out->size() == 1);
-                EValuePtr out0 = out->values[0];
-                assert(out0->type == pointerType(tt->elementTypes[i]));
-                out0->as<void *>() = (void *) ptr;
-                break;
-            }
+    case PRIM_arrayElements: {
+        ensureArity(args, 1);
+        ArrayTypePtr at;
+        EValuePtr earray = arrayValue(args, 0, at);
+        assert(out->size() == (size_t)at->size);
+        for (size_t i = 0; i < (size_t)at->size; ++i) {
+            EValuePtr outi = out->values[i];
+            assert(outi->type == pointerType(at->elementType));
+            char *ptr = earray->addr + i * typeSize(at->elementType);
+            outi->as<void *>() = (void *)ptr;
+        }
+        break;
+    }
 
-            case PRIM_tupleElements: {
-                ensureArity(args, 1);
-                TupleTypePtr tt;
-                EValuePtr etuple = tupleValue(args, 0, tt);
-                assert(out->size() == tt->elementTypes.size());
-                const llvm::StructLayout *layout = tupleTypeLayout(tt.ptr());
-                for (unsigned i = 0; i < tt->elementTypes.size(); ++i) {
-                    EValuePtr outi = out->values[i];
-                    assert(outi->type == pointerType(tt->elementTypes[i]));
-                    char *ptr = etuple->addr + layout->getElementOffset(i);
-                    outi->as<void *>() = (void *) ptr;
-                }
-                break;
-            }
+    case PRIM_Tuple:
+        error("Tuple type constructor cannot be called");
 
-            case PRIM_Union:
-                error("Union type constructor cannot be called");
+    case PRIM_TupleElementCount: {
+        ensureArity(args, 1);
+        TupleTypePtr t = valueToTupleType(args, 0);
+        ValueHolderPtr vh = sizeTToValueHolder(t->elementTypes.size());
+        evalStaticObject(vh.ptr(), out);
+        break;
+    }
 
-            case PRIM_UnionMemberCount: {
-                ensureArity(args, 1);
-                UnionTypePtr t = valueToUnionType(args, 0);
-                ValueHolderPtr vh = sizeTToValueHolder(t->memberTypes.size());
-                evalStaticObject(vh.ptr(), out);
-                break;
-            }
+    case PRIM_tupleRef: {
+        ensureArity(args, 2);
+        TupleTypePtr tt;
+        EValuePtr etuple = tupleValue(args, 0, tt);
+        size_t i = valueToStaticSizeTOrInt(args, 1);
+        if (i >= tt->elementTypes.size())
+            argumentIndexRangeError(1, "tuple element index", i,
+                                    tt->elementTypes.size());
+        const llvm::StructLayout *layout = tupleTypeLayout(tt.ptr());
+        char *ptr = etuple->addr + layout->getElementOffset(unsigned(i));
+        assert(out->size() == 1);
+        EValuePtr out0 = out->values[0];
+        assert(out0->type == pointerType(tt->elementTypes[i]));
+        out0->as<void *>() = (void *)ptr;
+        break;
+    }
 
-            case PRIM_RecordP: {
-                ensureArity(args, 1);
-                bool isRecordType = false;
-                ObjectPtr obj = valueToStatic(args->values[0]);
-                if (obj.ptr() && (obj->objKind == TYPE)) {
-                    Type *t = (Type *) obj.ptr();
-                    if (t->typeKind == RECORD_TYPE)
-                        isRecordType = true;
-                }
-                assert(out->size() == 1);
-                EValuePtr out0 = out->values[0];
-                assert(out0->type == boolType);
-                out0->as<bool>() = isRecordType;
-                break;
-            }
+    case PRIM_tupleElements: {
+        ensureArity(args, 1);
+        TupleTypePtr tt;
+        EValuePtr etuple = tupleValue(args, 0, tt);
+        assert(out->size() == tt->elementTypes.size());
+        const llvm::StructLayout *layout = tupleTypeLayout(tt.ptr());
+        for (unsigned i = 0; i < tt->elementTypes.size(); ++i) {
+            EValuePtr outi = out->values[i];
+            assert(outi->type == pointerType(tt->elementTypes[i]));
+            char *ptr = etuple->addr + layout->getElementOffset(i);
+            outi->as<void *>() = (void *)ptr;
+        }
+        break;
+    }
 
-            case PRIM_RecordFieldCount: {
-                ensureArity(args, 1);
-                RecordTypePtr rt = valueToRecordType(args, 0);
-                ValueHolderPtr vh = sizeTToValueHolder(rt->fieldCount());
-                evalStaticObject(vh.ptr(), out);
-                break;
-            }
+    case PRIM_Union:
+        error("Union type constructor cannot be called");
 
-            case PRIM_RecordFieldName: {
-                ensureArity(args, 2);
-                RecordTypePtr rt = valueToRecordType(args, 0);
-                size_t i = valueToStaticSizeTOrInt(args, 1);
-                llvm::ArrayRef<IdentifierPtr> fieldNames = recordFieldNames(rt);
-                if (i >= fieldNames.size())
-                    argumentIndexRangeError(1, "record field index",
-                                            i, fieldNames.size());
-                evalStaticObject(fieldNames[i].ptr(), out);
-                break;
-            }
+    case PRIM_UnionMemberCount: {
+        ensureArity(args, 1);
+        UnionTypePtr t = valueToUnionType(args, 0);
+        ValueHolderPtr vh = sizeTToValueHolder(t->memberTypes.size());
+        evalStaticObject(vh.ptr(), out);
+        break;
+    }
 
-            case PRIM_RecordWithFieldP: {
-                ensureArity(args, 2);
-                bool result = false;
-                ObjectPtr obj = valueToStatic(args->values[0]);
-                llvm::StringRef fname = valueToStringRef(args, 1);
-                if (obj.ptr() && (obj->objKind == TYPE)) {
-                    Type *t = (Type *) obj.ptr();
-                    if (t->typeKind == RECORD_TYPE) {
-                        RecordType *rt = (RecordType *) t;
-                        const llvm::StringMap<size_t> &fieldIndexMap =
-                                recordFieldIndexMap(rt);
-                        result = (fieldIndexMap.find(fname)
-                                  != fieldIndexMap.end());
-                    }
-                }
-                ValueHolderPtr vh = boolToValueHolder(result);
-                evalStaticObject(vh.ptr(), out);
-                break;
-            }
+    case PRIM_RecordP: {
+        ensureArity(args, 1);
+        bool isRecordType = false;
+        ObjectPtr obj = valueToStatic(args->values[0]);
+        if (obj.ptr() && (obj->objKind == TYPE)) {
+            Type *t = (Type *)obj.ptr();
+            if (t->typeKind == RECORD_TYPE)
+                isRecordType = true;
+        }
+        assert(out->size() == 1);
+        EValuePtr out0 = out->values[0];
+        assert(out0->type == boolType);
+        out0->as<bool>() = isRecordType;
+        break;
+    }
 
-            case PRIM_recordFieldRef: {
-                ensureArity(args, 2);
-                RecordTypePtr rt;
-                EValuePtr erec = recordValue(args, 0, rt);
-                unsigned i = unsigned(valueToStaticSizeTOrInt(args, 1));
-                llvm::ArrayRef<TypePtr> fieldTypes = recordFieldTypes(rt);
-                if (i >= rt->fieldCount())
-                    argumentIndexRangeError(1, "record field index",
-                                            i, rt->fieldCount());
-                const llvm::StructLayout *layout = recordTypeLayout(rt.ptr());
-
-                if (rt->hasVarField && i >= rt->varFieldPosition) {
-                    if (i == rt->varFieldPosition) {
-                        assert(out->size() == rt->varFieldSize());
-                        for (unsigned j = 0; j < rt->varFieldSize(); ++j) {
-                            char *ptr = erec->addr + layout->getElementOffset(i + j);
-                            EValuePtr out0 = out->values[j];
-                            assert(out0->type == pointerType(fieldTypes[i+j]));
-                            out0->as<void *>() = (void *) ptr;
-                        }
-                    } else {
-                        unsigned k = i + unsigned(rt->varFieldSize() - 1);
-                        char *ptr = erec->addr + layout->getElementOffset(k);
-                        assert(out->size() == 1);
-                        EValuePtr out0 = out->values[0];
-                        assert(out0->type == pointerType(fieldTypes[k]));
-                        out0->as<void *>() = (void *) ptr;
-                    }
-                } else {
-                    char *ptr = erec->addr + layout->getElementOffset(i);
-                    assert(out->size() == 1);
-                    EValuePtr out0 = out->values[0];
-                    assert(out0->type == pointerType(fieldTypes[i]));
-                    out0->as<void *>() = (void *) ptr;
-                }
-                break;
-            }
+    case PRIM_RecordFieldCount: {
+        ensureArity(args, 1);
+        RecordTypePtr rt = valueToRecordType(args, 0);
+        ValueHolderPtr vh = sizeTToValueHolder(rt->fieldCount());
+        evalStaticObject(vh.ptr(), out);
+        break;
+    }
 
-            case PRIM_recordFieldRefByName: {
-                ensureArity(args, 2);
-                RecordTypePtr rt;
-                EValuePtr erec = recordValue(args, 0, rt);
-                llvm::StringRef fname = valueToStringRef(args, 1);
-                const llvm::StringMap<size_t> &fieldIndexMap = recordFieldIndexMap(rt);
-                llvm::StringMap<size_t>::const_iterator fi =
-                        fieldIndexMap.find(fname);
-                if (fi == fieldIndexMap.end()) {
-                    string buf;
-                    llvm::raw_string_ostream sout(buf);
-                    sout << "field not found: " << fname;
-                    argumentError(1, sout.str());
-                }
-                unsigned i = unsigned(fi->second);
-                llvm::ArrayRef<TypePtr> fieldTypes = recordFieldTypes(rt);
-                const llvm::StructLayout *layout = recordTypeLayout(rt.ptr());
-
-                if (rt->hasVarField && i >= rt->varFieldPosition) {
-                    if (i == rt->varFieldPosition) {
-                        assert(out->size() == rt->varFieldSize());
-                        for (unsigned j = 0; j < rt->varFieldSize(); ++j) {
-                            char *ptr = erec->addr + layout->getElementOffset(i + j);
-                            EValuePtr out0 = out->values[j];
-                            assert(out0->type == pointerType(fieldTypes[i+j]));
-                            out0->as<void *>() = (void *) ptr;
-                        }
-                    } else {
-                        unsigned k = i + unsigned(rt->varFieldSize()) - 1;
-                        char *ptr = erec->addr + layout->getElementOffset(k);
-                        assert(out->size() == 1);
-                        EValuePtr out0 = out->values[0];
-                        assert(out0->type == pointerType(fieldTypes[k]));
-                        out0->as<void *>() = (void *) ptr;
-                    }
-                } else {
-                    char *ptr = erec->addr + layout->getElementOffset(i);
-                    assert(out->size() == 1);
-                    EValuePtr out0 = out->values[0];
-                    assert(out0->type == pointerType(fieldTypes[i]));
-                    out0->as<void *>() = (void *) ptr;
-                }
-                break;
-            }
+    case PRIM_RecordFieldName: {
+        ensureArity(args, 2);
+        RecordTypePtr rt = valueToRecordType(args, 0);
+        size_t i = valueToStaticSizeTOrInt(args, 1);
+        llvm::ArrayRef<IdentifierPtr> fieldNames = recordFieldNames(rt);
+        if (i >= fieldNames.size())
+            argumentIndexRangeError(1, "record field index", i,
+                                    fieldNames.size());
+        evalStaticObject(fieldNames[i].ptr(), out);
+        break;
+    }
 
-            case PRIM_recordFields: {
-                ensureArity(args, 1);
-                RecordTypePtr rt;
-                EValuePtr erec = recordValue(args, 0, rt);
-                llvm::ArrayRef<TypePtr> fieldTypes = recordFieldTypes(rt);
-                assert(out->size() == fieldTypes.size());
-                const llvm::StructLayout *layout = recordTypeLayout(rt.ptr());
-                for (unsigned i = 0; i < fieldTypes.size(); ++i) {
-                    EValuePtr outi = out->values[i];
-                    assert(outi->type == pointerType(fieldTypes[i]));
-                    char *ptr = erec->addr + layout->getElementOffset(i);
-                    outi->as<void *>() = (void *) ptr;
-                }
-                break;
+    case PRIM_RecordWithFieldP: {
+        ensureArity(args, 2);
+        bool result = false;
+        ObjectPtr obj = valueToStatic(args->values[0]);
+        llvm::StringRef fname = valueToStringRef(args, 1);
+        if (obj.ptr() && (obj->objKind == TYPE)) {
+            Type *t = (Type *)obj.ptr();
+            if (t->typeKind == RECORD_TYPE) {
+                RecordType *rt = (RecordType *)t;
+                const llvm::StringMap<size_t> &fieldIndexMap =
+                    recordFieldIndexMap(rt);
+                result = (fieldIndexMap.find(fname) != fieldIndexMap.end());
             }
+        }
+        ValueHolderPtr vh = boolToValueHolder(result);
+        evalStaticObject(vh.ptr(), out);
+        break;
+    }
 
-            case PRIM_recordVariadicField: {
-                ensureArity(args, 1);
-                RecordTypePtr rt;
-                EValuePtr erec = recordValue(args, 0, rt);
-                llvm::ArrayRef<TypePtr> fieldTypes = recordFieldTypes(rt);
-                if (!rt->hasVarField)
-                    argumentError(0, "expecting a record with a variadic field");
-                assert(out->size() == fieldTypes.size());
-                const llvm::StructLayout *layout = recordTypeLayout(rt.ptr());
+    case PRIM_recordFieldRef: {
+        ensureArity(args, 2);
+        RecordTypePtr rt;
+        EValuePtr erec = recordValue(args, 0, rt);
+        unsigned i = unsigned(valueToStaticSizeTOrInt(args, 1));
+        llvm::ArrayRef<TypePtr> fieldTypes = recordFieldTypes(rt);
+        if (i >= rt->fieldCount())
+            argumentIndexRangeError(1, "record field index", i,
+                                    rt->fieldCount());
+        const llvm::StructLayout *layout = recordTypeLayout(rt.ptr());
+
+        if (rt->hasVarField && i >= rt->varFieldPosition) {
+            if (i == rt->varFieldPosition) {
                 assert(out->size() == rt->varFieldSize());
-                for (unsigned i = 0; i < rt->varFieldSize(); ++i) {
-                    unsigned k = unsigned(rt->varFieldPosition) + i;
-                    EValuePtr outi = out->values[i];
-                    assert(outi->type == pointerType(fieldTypes[k]));
-                    char *ptr = erec->addr + layout->getElementOffset(k);
-                    outi->as<void *>() = (void *) ptr;
-                }
-                break;
-            }
-
-            case PRIM_VariantP: {
-                ensureArity(args, 1);
-                bool isVariantType = false;
-                ObjectPtr obj = valueToStatic(args->values[0]);
-                if (obj.ptr() && (obj->objKind == TYPE)) {
-                    Type *t = (Type *) obj.ptr();
-                    if (t->typeKind == VARIANT_TYPE)
-                        isVariantType = true;
+                for (unsigned j = 0; j < rt->varFieldSize(); ++j) {
+                    char *ptr = erec->addr + layout->getElementOffset(i + j);
+                    EValuePtr out0 = out->values[j];
+                    assert(out0->type == pointerType(fieldTypes[i + j]));
+                    out0->as<void *>() = (void *)ptr;
                 }
+            } else {
+                unsigned k = i + unsigned(rt->varFieldSize() - 1);
+                char *ptr = erec->addr + layout->getElementOffset(k);
                 assert(out->size() == 1);
                 EValuePtr out0 = out->values[0];
-                assert(out0->type == boolType);
-                out0->as<bool>() = isVariantType;
-                break;
+                assert(out0->type == pointerType(fieldTypes[k]));
+                out0->as<void *>() = (void *)ptr;
             }
+        } else {
+            char *ptr = erec->addr + layout->getElementOffset(i);
+            assert(out->size() == 1);
+            EValuePtr out0 = out->values[0];
+            assert(out0->type == pointerType(fieldTypes[i]));
+            out0->as<void *>() = (void *)ptr;
+        }
+        break;
+    }
 
-            case PRIM_VariantMemberIndex: {
-                ensureArity(args, 2);
-                VariantTypePtr vt = valueToVariantType(args, 0);
-                TypePtr mt = valueToType(args, 1);
-                llvm::ArrayRef<TypePtr> memberTypes = variantMemberTypes(vt);
-                size_t index = (size_t) -1;
-                for (size_t i = 0; i < memberTypes.size(); ++i) {
-                    if (memberTypes[i] == mt) {
-                        index = i;
-                        break;
-                    }
-                }
-                assert(out->size() == 1);
-                EValuePtr out0 = out->values[0];
-                assert(out0->type == cSizeTType);
-                setSizeTEValue(out0, index);
-                break;
-            }
+    case PRIM_recordFieldRefByName: {
+        ensureArity(args, 2);
+        RecordTypePtr rt;
+        EValuePtr erec = recordValue(args, 0, rt);
+        llvm::StringRef fname = valueToStringRef(args, 1);
+        const llvm::StringMap<size_t> &fieldIndexMap = recordFieldIndexMap(rt);
+        llvm::StringMap<size_t>::const_iterator fi = fieldIndexMap.find(fname);
+        if (fi == fieldIndexMap.end()) {
+            string buf;
+            llvm::raw_string_ostream sout(buf);
+            sout << "field not found: " << fname;
+            argumentError(1, sout.str());
+        }
+        unsigned i = unsigned(fi->second);
+        llvm::ArrayRef<TypePtr> fieldTypes = recordFieldTypes(rt);
+        const llvm::StructLayout *layout = recordTypeLayout(rt.ptr());
 
-            case PRIM_VariantMemberCount: {
-                ensureArity(args, 1);
-                VariantTypePtr vt = valueToVariantType(args, 0);
-                llvm::ArrayRef<TypePtr> memberTypes = variantMemberTypes(vt);
-                size_t size = memberTypes.size();
+        if (rt->hasVarField && i >= rt->varFieldPosition) {
+            if (i == rt->varFieldPosition) {
+                assert(out->size() == rt->varFieldSize());
+                for (unsigned j = 0; j < rt->varFieldSize(); ++j) {
+                    char *ptr = erec->addr + layout->getElementOffset(i + j);
+                    EValuePtr out0 = out->values[j];
+                    assert(out0->type == pointerType(fieldTypes[i + j]));
+                    out0->as<void *>() = (void *)ptr;
+                }
+            } else {
+                unsigned k = i + unsigned(rt->varFieldSize()) - 1;
+                char *ptr = erec->addr + layout->getElementOffset(k);
                 assert(out->size() == 1);
                 EValuePtr out0 = out->values[0];
-                assert(out0->type == cSizeTType);
-                setSizeTEValue(out0, size);
-                break;
+                assert(out0->type == pointerType(fieldTypes[k]));
+                out0->as<void *>() = (void *)ptr;
             }
+        } else {
+            char *ptr = erec->addr + layout->getElementOffset(i);
+            assert(out->size() == 1);
+            EValuePtr out0 = out->values[0];
+            assert(out0->type == pointerType(fieldTypes[i]));
+            out0->as<void *>() = (void *)ptr;
+        }
+        break;
+    }
 
-            case PRIM_VariantMembers:
-                break;
-
-            case PRIM_BaseType:
-                break;
-
-            case PRIM_Static:
-                error("Static type constructor cannot be called");
+    case PRIM_recordFields: {
+        ensureArity(args, 1);
+        RecordTypePtr rt;
+        EValuePtr erec = recordValue(args, 0, rt);
+        llvm::ArrayRef<TypePtr> fieldTypes = recordFieldTypes(rt);
+        assert(out->size() == fieldTypes.size());
+        const llvm::StructLayout *layout = recordTypeLayout(rt.ptr());
+        for (unsigned i = 0; i < fieldTypes.size(); ++i) {
+            EValuePtr outi = out->values[i];
+            assert(outi->type == pointerType(fieldTypes[i]));
+            char *ptr = erec->addr + layout->getElementOffset(i);
+            outi->as<void *>() = (void *)ptr;
+        }
+        break;
+    }
 
-            case PRIM_staticIntegers:
-                break;
+    case PRIM_recordVariadicField: {
+        ensureArity(args, 1);
+        RecordTypePtr rt;
+        EValuePtr erec = recordValue(args, 0, rt);
+        llvm::ArrayRef<TypePtr> fieldTypes = recordFieldTypes(rt);
+        if (!rt->hasVarField)
+            argumentError(0, "expecting a record with a variadic field");
+        assert(out->size() == fieldTypes.size());
+        const llvm::StructLayout *layout = recordTypeLayout(rt.ptr());
+        assert(out->size() == rt->varFieldSize());
+        for (unsigned i = 0; i < rt->varFieldSize(); ++i) {
+            unsigned k = unsigned(rt->varFieldPosition) + i;
+            EValuePtr outi = out->values[i];
+            assert(outi->type == pointerType(fieldTypes[k]));
+            char *ptr = erec->addr + layout->getElementOffset(k);
+            outi->as<void *>() = (void *)ptr;
+        }
+        break;
+    }
 
-            case PRIM_integers: {
-                ensureArity(args, 1);
-                ObjectPtr obj = valueToStatic(args, 0);
-                if (obj->objKind != VALUE_HOLDER)
-                    argumentError(0, "expecting a static SizeT or Int value");
-                ValueHolder *vh = (ValueHolder *) obj.ptr();
-                if (vh->type == cIntType) {
-                    int count = vh->as<int>();
-                    if (count < 0)
-                        argumentError(0, "negative values are not allowed");
-                    assert(out->size() == (size_t)count);
-                    for (int i = 0; i < count; ++i) {
-                        ValueHolderPtr vhi = intToValueHolder(i);
-                        EValuePtr outi = out->values[size_t(i)];
-                        assert(outi->type == cIntType);
-                        outi->as<int>() = i;
-                    }
-                } else if (vh->type == cSizeTType) {
-                    size_t count = valueHolderToSizeT(vh);
-                    assert(out->size() == count);
-                    for (size_t i = 0; i < count; ++i) {
-                        ValueHolderPtr vhi = sizeTToValueHolder(i);
-                        EValuePtr outi = out->values[i];
-                        assert(outi->type == cSizeTType);
-                        outi->as<size_t>() = i;
-                    }
-                } else {
-                    argumentError(0, "expecting a static SizeT or Int value");
-                }
-                break;
-            }
+    case PRIM_VariantP: {
+        ensureArity(args, 1);
+        bool isVariantType = false;
+        ObjectPtr obj = valueToStatic(args->values[0]);
+        if (obj.ptr() && (obj->objKind == TYPE)) {
+            Type *t = (Type *)obj.ptr();
+            if (t->typeKind == VARIANT_TYPE)
+                isVariantType = true;
+        }
+        assert(out->size() == 1);
+        EValuePtr out0 = out->values[0];
+        assert(out0->type == boolType);
+        out0->as<bool>() = isVariantType;
+        break;
+    }
 
-            case PRIM_staticFieldRef: {
-                ensureArity(args, 2);
-                ObjectPtr moduleObj = valueToStatic(args, 0);
-                if (moduleObj->objKind != MODULE)
-                    argumentError(0, "expecting a module");
-                Module *module = (Module *) moduleObj.ptr();
-                IdentifierPtr ident = valueToIdentifier(args, 1);
-                ObjectPtr obj = safeLookupPublic(module, ident);
-                evalStaticObject(obj, out);
+    case PRIM_VariantMemberIndex: {
+        ensureArity(args, 2);
+        VariantTypePtr vt = valueToVariantType(args, 0);
+        TypePtr mt = valueToType(args, 1);
+        llvm::ArrayRef<TypePtr> memberTypes = variantMemberTypes(vt);
+        size_t index = (size_t)-1;
+        for (size_t i = 0; i < memberTypes.size(); ++i) {
+            if (memberTypes[i] == mt) {
+                index = i;
                 break;
             }
+        }
+        assert(out->size() == 1);
+        EValuePtr out0 = out->values[0];
+        assert(out0->type == cSizeTType);
+        setSizeTEValue(out0, index);
+        break;
+    }
 
-            case PRIM_EnumP: {
-                ensureArity(args, 1);
-                bool isEnumType = false;
-                ObjectPtr obj = valueToStatic(args->values[0]);
-                if (obj.ptr() && (obj->objKind == TYPE)) {
-                    Type *t = (Type *) obj.ptr();
-                    if (t->typeKind == ENUM_TYPE)
-                        isEnumType = true;
-                }
-                assert(out->size() == 1);
-                EValuePtr out0 = out->values[0];
-                assert(out0->type == boolType);
-                out0->as<bool>() = isEnumType;
-                break;
-            }
+    case PRIM_VariantMemberCount: {
+        ensureArity(args, 1);
+        VariantTypePtr vt = valueToVariantType(args, 0);
+        llvm::ArrayRef<TypePtr> memberTypes = variantMemberTypes(vt);
+        size_t size = memberTypes.size();
+        assert(out->size() == 1);
+        EValuePtr out0 = out->values[0];
+        assert(out0->type == cSizeTType);
+        setSizeTEValue(out0, size);
+        break;
+    }
 
-            case PRIM_EnumMemberCount: {
-                ensureArity(args, 1);
-                EnumTypePtr et = valueToEnumType(args, 0);
-                size_t n = et->enumeration->members.size();
-                ValueHolderPtr vh = sizeTToValueHolder(n);
-                evalStaticObject(vh.ptr(), out);
-                break;
+    case PRIM_VariantMembers:
+        break;
+
+    case PRIM_BaseType:
+        break;
+
+    case PRIM_Static:
+        error("Static type constructor cannot be called");
+
+    case PRIM_staticIntegers:
+        break;
+
+    case PRIM_integers: {
+        ensureArity(args, 1);
+        ObjectPtr obj = valueToStatic(args, 0);
+        if (obj->objKind != VALUE_HOLDER)
+            argumentError(0, "expecting a static SizeT or Int value");
+        ValueHolder *vh = (ValueHolder *)obj.ptr();
+        if (vh->type == cIntType) {
+            int count = vh->as<int>();
+            if (count < 0)
+                argumentError(0, "negative values are not allowed");
+            assert(out->size() == (size_t)count);
+            for (int i = 0; i < count; ++i) {
+                ValueHolderPtr vhi = intToValueHolder(i);
+                EValuePtr outi = out->values[size_t(i)];
+                assert(outi->type == cIntType);
+                outi->as<int>() = i;
             }
-
-            case PRIM_EnumMemberName:
-                break;
-
-            case PRIM_enumToInt: {
-                ensureArity(args, 1);
-                EnumTypePtr et;
-                EValuePtr ev = enumValue(args, 0, et);
-                assert(out->size() == 1);
-                EValuePtr out0 = out->values[0];
-                assert(out0->type == cIntType);
-                out0->as<int>() = ev->as<int>();
-                break;
+        } else if (vh->type == cSizeTType) {
+            size_t count = valueHolderToSizeT(vh);
+            assert(out->size() == count);
+            for (size_t i = 0; i < count; ++i) {
+                ValueHolderPtr vhi = sizeTToValueHolder(i);
+                EValuePtr outi = out->values[i];
+                assert(outi->type == cSizeTType);
+                outi->as<size_t>() = i;
             }
+        } else {
+            argumentError(0, "expecting a static SizeT or Int value");
+        }
+        break;
+    }
 
-            case PRIM_intToEnum: {
-                ensureArity(args, 2);
-                EnumTypePtr et = valueToEnumType(args, 0);
-                IntegerTypePtr it = (IntegerType *) cIntType.ptr();
-                EValuePtr ev = integerValue(args, 1, it);
-                assert(out->size() == 1);
-                EValuePtr out0 = out->values[0];
-                assert(out0->type == et.ptr());
-                out0->as<int>() = ev->as<int>();
-                break;
-            }
+    case PRIM_staticFieldRef: {
+        ensureArity(args, 2);
+        ObjectPtr moduleObj = valueToStatic(args, 0);
+        if (moduleObj->objKind != MODULE)
+            argumentError(0, "expecting a module");
+        Module *module = (Module *)moduleObj.ptr();
+        IdentifierPtr ident = valueToIdentifier(args, 1);
+        ObjectPtr obj = safeLookupPublic(module, ident);
+        evalStaticObject(obj, out);
+        break;
+    }
 
-            case PRIM_StringLiteralP: {
-                ensureArity(args, 1);
-                bool result = false;
-                EValuePtr ev0 = args->values[0];
-                if (ev0->type->typeKind == STATIC_TYPE) {
-                    StaticType *st = (StaticType *) ev0->type.ptr();
-                    result = (st->obj->objKind == IDENTIFIER);
-                }
-                ValueHolderPtr vh = boolToValueHolder(result);
-                evalStaticObject(vh.ptr(), out);
-                break;
-            }
+    case PRIM_EnumP: {
+        ensureArity(args, 1);
+        bool isEnumType = false;
+        ObjectPtr obj = valueToStatic(args->values[0]);
+        if (obj.ptr() && (obj->objKind == TYPE)) {
+            Type *t = (Type *)obj.ptr();
+            if (t->typeKind == ENUM_TYPE)
+                isEnumType = true;
+        }
+        assert(out->size() == 1);
+        EValuePtr out0 = out->values[0];
+        assert(out0->type == boolType);
+        out0->as<bool>() = isEnumType;
+        break;
+    }
 
-            case PRIM_stringLiteralByteIndex: {
-                ensureArity(args, 2);
-                llvm::StringRef ident = valueToStringRef(args, 0);
-                size_t n = valueToStaticSizeTOrInt(args, 1);
-                if (n >= ident.size())
-                    argumentError(1, "string literal index out of bounds");
+    case PRIM_EnumMemberCount: {
+        ensureArity(args, 1);
+        EnumTypePtr et = valueToEnumType(args, 0);
+        size_t n = et->enumeration->members.size();
+        ValueHolderPtr vh = sizeTToValueHolder(n);
+        evalStaticObject(vh.ptr(), out);
+        break;
+    }
 
-                assert(out->size() == 1);
-                EValuePtr outi = out->values[0];
-                assert(outi->type == cIntType);
-                outi->as<int>() = ident[unsigned(n)];
-                break;
-            }
+    case PRIM_EnumMemberName:
+        break;
+
+    case PRIM_enumToInt: {
+        ensureArity(args, 1);
+        EnumTypePtr et;
+        EValuePtr ev = enumValue(args, 0, et);
+        assert(out->size() == 1);
+        EValuePtr out0 = out->values[0];
+        assert(out0->type == cIntType);
+        out0->as<int>() = ev->as<int>();
+        break;
+    }
 
-            case PRIM_stringLiteralBytes: {
-                ensureArity(args, 1);
-                llvm::StringRef ident = valueToStringRef(args, 0);
-                assert(out->size() == ident.size());
-                for (unsigned i = 0, sz = unsigned(ident.size()); i < sz; ++i) {
-                    EValuePtr outi = out->values[i];
-                    assert(outi->type == cIntType);
-                    outi->as<int>() = ident[i];
-                }
-                break;
-            }
+    case PRIM_intToEnum: {
+        ensureArity(args, 2);
+        EnumTypePtr et = valueToEnumType(args, 0);
+        IntegerTypePtr it = (IntegerType *)cIntType.ptr();
+        EValuePtr ev = integerValue(args, 1, it);
+        assert(out->size() == 1);
+        EValuePtr out0 = out->values[0];
+        assert(out0->type == et.ptr());
+        out0->as<int>() = ev->as<int>();
+        break;
+    }
 
-            case PRIM_stringLiteralByteSize: {
-                ensureArity(args, 1);
-                llvm::StringRef ident = valueToStringRef(args, 0);
-                ValueHolderPtr vh = sizeTToValueHolder(ident.size());
-                evalStaticObject(vh.ptr(), out);
-                break;
-            }
+    case PRIM_StringLiteralP: {
+        ensureArity(args, 1);
+        bool result = false;
+        EValuePtr ev0 = args->values[0];
+        if (ev0->type->typeKind == STATIC_TYPE) {
+            StaticType *st = (StaticType *)ev0->type.ptr();
+            result = (st->obj->objKind == IDENTIFIER);
+        }
+        ValueHolderPtr vh = boolToValueHolder(result);
+        evalStaticObject(vh.ptr(), out);
+        break;
+    }
 
-            case PRIM_stringLiteralByteSlice:
-            case PRIM_stringLiteralConcat:
-            case PRIM_stringLiteralFromBytes:
-                break;
+    case PRIM_stringLiteralByteIndex: {
+        ensureArity(args, 2);
+        llvm::StringRef ident = valueToStringRef(args, 0);
+        size_t n = valueToStaticSizeTOrInt(args, 1);
+        if (n >= ident.size())
+            argumentError(1, "string literal index out of bounds");
+
+        assert(out->size() == 1);
+        EValuePtr outi = out->values[0];
+        assert(outi->type == cIntType);
+        outi->as<int>() = ident[unsigned(n)];
+        break;
+    }
 
-            case PRIM_stringTableConstant: {
-                ensureArity(args, 1);
-                llvm::StringRef ident = valueToStringRef(args, 0);
-                const void *value = evalStringTableConstant(ident);
+    case PRIM_stringLiteralBytes: {
+        ensureArity(args, 1);
+        llvm::StringRef ident = valueToStringRef(args, 0);
+        assert(out->size() == ident.size());
+        for (unsigned i = 0, sz = unsigned(ident.size()); i < sz; ++i) {
+            EValuePtr outi = out->values[i];
+            assert(outi->type == cIntType);
+            outi->as<int>() = ident[i];
+        }
+        break;
+    }
 
-                assert(out->size() == 1);
-                EValuePtr out0 = out->values[0];
-                assert(out0->type == pointerType(cSizeTType));
-                out0->as<const void *>() = value;
-                break;
-            }
+    case PRIM_stringLiteralByteSize: {
+        ensureArity(args, 1);
+        llvm::StringRef ident = valueToStringRef(args, 0);
+        ValueHolderPtr vh = sizeTToValueHolder(ident.size());
+        evalStaticObject(vh.ptr(), out);
+        break;
+    }
 
-            case PRIM_StaticName:
-            case PRIM_MainModule:
-            case PRIM_StaticModule:
-            case PRIM_ModuleName:
-            case PRIM_ModuleMemberNames:
-                break;
+    case PRIM_stringLiteralByteSlice:
+    case PRIM_stringLiteralConcat:
+    case PRIM_stringLiteralFromBytes:
+        break;
+
+    case PRIM_stringTableConstant: {
+        ensureArity(args, 1);
+        llvm::StringRef ident = valueToStringRef(args, 0);
+        const void *value = evalStringTableConstant(ident);
+
+        assert(out->size() == 1);
+        EValuePtr out0 = out->values[0];
+        assert(out0->type == pointerType(cSizeTType));
+        out0->as<const void *>() = value;
+        break;
+    }
 
-            case PRIM_FlagP: {
-                ensureArity(args, 1);
-                llvm::StringRef ident = valueToStringRef(args, 0);
-                llvm::StringMap<string>::const_iterator flag = globalFlags.find(ident);
-                assert(out->size() == 1);
-                EValuePtr out0 = out->values[0];
-                assert(out0->type == boolType);
-                out0->as<bool>() = flag != globalFlags.end();
-                break;
-            }
+    case PRIM_StaticName:
+    case PRIM_MainModule:
+    case PRIM_StaticModule:
+    case PRIM_ModuleName:
+    case PRIM_ModuleMemberNames:
+        break;
+
+    case PRIM_FlagP: {
+        ensureArity(args, 1);
+        llvm::StringRef ident = valueToStringRef(args, 0);
+        llvm::StringMap<string>::const_iterator flag = globalFlags.find(ident);
+        assert(out->size() == 1);
+        EValuePtr out0 = out->values[0];
+        assert(out0->type == boolType);
+        out0->as<bool>() = flag != globalFlags.end();
+        break;
+    }
 
-            case PRIM_Flag:
-                break;
+    case PRIM_Flag:
+        break;
+
+    case PRIM_atomicFence:
+    case PRIM_atomicRMW:
+    case PRIM_atomicLoad:
+    case PRIM_atomicStore:
+    case PRIM_atomicCompareExchange:
+        error("atomic operations not supported in evaluator");
+        break;
+
+    case PRIM_activeException:
+        error("exceptions not supported in evaluator");
+        break;
+
+    case PRIM_memcpy:
+    case PRIM_memmove: {
+        ensureArity(args, 3);
+        PointerTypePtr topt;
+        PointerTypePtr frompt;
+        EValuePtr tov = pointerValue(args, 0, topt);
+        EValuePtr fromv = pointerValue(args, 1, frompt);
+        IntegerTypePtr it;
+        EValuePtr countv = integerValue(args, 2, it);
+
+        void *to = tov->as<void *>();
+        void *from = fromv->as<void *>();
+        size_t size = op_intToSizeT(countv);
+
+        if (x->primOpCode == PRIM_memcpy)
+            memcpy(to, from, size);
+        else
+            memmove(to, from, size);
+
+        break;
+    }
 
-            case PRIM_atomicFence:
-            case PRIM_atomicRMW:
-            case PRIM_atomicLoad:
-            case PRIM_atomicStore:
-            case PRIM_atomicCompareExchange:
-                error("atomic operations not supported in evaluator");
-                break;
+    case PRIM_countValues: {
+        assert(out->size() == 1);
+        EValuePtr out0 = out->values[0];
+        assert(out0->type == cIntType);
+        out0->as<int>() = int(args->size());
+        break;
+    }
 
-            case PRIM_activeException:
-                error("exceptions not supported in evaluator");
-                break;
+    case PRIM_nthValue: {
+        if (args->size() < 1)
+            arityError2(1, args->size());
+        assert(out->size() == 1);
+        EValuePtr out0 = out->values[0];
 
-            case PRIM_memcpy:
-            case PRIM_memmove: {
-                ensureArity(args, 3);
-                PointerTypePtr topt;
-                PointerTypePtr frompt;
-                EValuePtr tov = pointerValue(args, 0, topt);
-                EValuePtr fromv = pointerValue(args, 1, frompt);
-                IntegerTypePtr it;
-                EValuePtr countv = integerValue(args, 2, it);
-
-                void *to = tov->as<void *>();
-                void *from = fromv->as<void *>();
-                size_t size = op_intToSizeT(countv);
-
-                if (x->primOpCode == PRIM_memcpy)
-                    memcpy(to, from, size);
-                else
-                    memmove(to, from, size);
+        size_t i = valueToStaticSizeTOrInt(args, 0);
+        if (i + 1 >= args->size())
+            argumentError(0, "nthValue argument out of bounds");
 
-                break;
-            }
+        evalValueForward(out0, args->values[i + 1]);
+        break;
+    }
 
-            case PRIM_countValues: {
-                assert(out->size() == 1);
-                EValuePtr out0 = out->values[0];
-                assert(out0->type == cIntType);
-                out0->as<int>() = int(args->size());
-                break;
-            }
+    case PRIM_withoutNthValue: {
+        if (args->size() < 1)
+            arityError2(1, args->size());
+        assert(out->size() == args->size() - 2);
+
+        size_t i = valueToStaticSizeTOrInt(args, 0);
+        if (i + 1 >= args->size())
+            argumentError(0, "withoutNthValue argument out of bounds");
+
+        for (size_t argi = 1, outi = 0; argi < args->size(); ++argi) {
+            if (argi == i + 1)
+                continue;
+            assert(outi < out->size());
+            evalValueForward(out->values[outi], args->values[argi]);
+            ++outi;
+        }
+        break;
+    }
 
-            case PRIM_nthValue: {
-                if (args->size() < 1)
-                    arityError2(1, args->size());
-                assert(out->size() == 1);
-                EValuePtr out0 = out->values[0];
+    case PRIM_takeValues: {
+        if (args->size() < 1)
+            arityError2(1, args->size());
 
-                size_t i = valueToStaticSizeTOrInt(args, 0);
-                if (i + 1 >= args->size())
-                    argumentError(0, "nthValue argument out of bounds");
+        size_t i = valueToStaticSizeTOrInt(args, 0);
+        if (i + 1 >= args->size())
+            i = args->size() - 1;
 
-                evalValueForward(out0, args->values[i + 1]);
-                break;
-            }
+        assert(out->size() == i);
+        for (size_t argi = 1, outi = 0; argi < i + 1; ++argi, ++outi) {
+            assert(outi < out->size());
+            evalValueForward(out->values[outi], args->values[argi]);
+        }
+        break;
+    }
 
-            case PRIM_withoutNthValue: {
-                if (args->size() < 1)
-                    arityError2(1, args->size());
-                assert(out->size() == args->size() - 2);
-
-                size_t i = valueToStaticSizeTOrInt(args, 0);
-                if (i + 1 >= args->size())
-                    argumentError(0, "withoutNthValue argument out of bounds");
-
-                for (size_t argi = 1, outi = 0; argi < args->size(); ++argi) {
-                    if (argi == i + 1)
-                        continue;
-                    assert(outi < out->size());
-                    evalValueForward(out->values[outi], args->values[argi]);
-                    ++outi;
-                }
-                break;
-            }
+    case PRIM_dropValues: {
+        if (args->size() < 1)
+            arityError2(1, args->size());
 
-            case PRIM_takeValues: {
-                if (args->size() < 1)
-                    arityError2(1, args->size());
+        size_t i = valueToStaticSizeTOrInt(args, 0);
+        if (i + 1 >= args->size())
+            i = args->size() - 1;
 
-                size_t i = valueToStaticSizeTOrInt(args, 0);
-                if (i + 1 >= args->size())
-                    i = args->size() - 1;
+        assert(out->size() == args->size() - i - 1);
+        for (size_t argi = i + 1, outi = 0; argi < args->size();
+             ++argi, ++outi) {
+            assert(outi < out->size());
+            evalValueForward(out->values[outi], args->values[argi]);
+        }
+        break;
+    }
 
-                assert(out->size() == i);
-                for (size_t argi = 1, outi = 0; argi < i + 1; ++argi, ++outi) {
-                    assert(outi < out->size());
-                    evalValueForward(out->values[outi], args->values[argi]);
-                }
-                break;
-            }
+    case PRIM_LambdaRecordP: {
+        ensureArity(args, 1);
 
-            case PRIM_dropValues: {
-                if (args->size() < 1)
-                    arityError2(1, args->size());
+        bool isLambda;
 
-                size_t i = valueToStaticSizeTOrInt(args, 0);
-                if (i + 1 >= args->size())
-                    i = args->size() - 1;
+        ObjectPtr callable = valueToStatic(args->values[0]);
+        if (callable != nullptr && callable->objKind == TYPE) {
+            Type *t = (Type *)callable.ptr();
+            if (t->typeKind == RECORD_TYPE) {
+                RecordType *r = (RecordType *)t;
+                isLambda = r->record->lambda != nullptr;
+            } else
+                isLambda = false;
+        } else {
+            isLambda = false;
+        }
 
-                assert(out->size() == args->size() - i - 1);
-                for (size_t argi = i + 1, outi = 0; argi < args->size(); ++argi, ++outi) {
-                    assert(outi < out->size());
-                    evalValueForward(out->values[outi], args->values[argi]);
-                }
-                break;
-            }
+        ValueHolderPtr vh = boolToValueHolder(isLambda);
+        evalStaticObject(vh.ptr(), out);
+        break;
+    }
 
-            case PRIM_LambdaRecordP: {
-                ensureArity(args, 1);
-
-                bool isLambda;
-
-                ObjectPtr callable = valueToStatic(args->values[0]);
-                if (callable != nullptr && callable->objKind == TYPE) {
-                    Type *t = (Type *) callable.ptr();
-                    if (t->typeKind == RECORD_TYPE) {
-                        RecordType *r = (RecordType *) t;
-                        isLambda = r->record->lambda != nullptr;
-                    } else
-                        isLambda = false;
-                } else {
-                    isLambda = false;
-                }
+    case PRIM_LambdaSymbolP: {
+        ensureArity(args, 1);
 
-                ValueHolderPtr vh = boolToValueHolder(isLambda);
-                evalStaticObject(vh.ptr(), out);
-                break;
-            }
+        bool isLambda;
 
-            case PRIM_LambdaSymbolP: {
-                ensureArity(args, 1);
+        ObjectPtr callable = valueToStatic(args->values[0]);
+        if (callable != nullptr && callable->objKind == PROCEDURE) {
+            Procedure *p = (Procedure *)callable.ptr();
+            isLambda = p->lambda != nullptr;
+        } else
+            isLambda = false;
 
-                bool isLambda;
+        ValueHolderPtr vh = boolToValueHolder(isLambda);
+        evalStaticObject(vh.ptr(), out);
+        break;
+    }
 
-                ObjectPtr callable = valueToStatic(args->values[0]);
-                if (callable != nullptr && callable->objKind == PROCEDURE) {
-                    Procedure *p = (Procedure *) callable.ptr();
-                    isLambda = p->lambda != nullptr;
-                } else
-                    isLambda = false;
+    case PRIM_LambdaMonoP: {
+        ensureArity(args, 1);
 
-                ValueHolderPtr vh = boolToValueHolder(isLambda);
-                evalStaticObject(vh.ptr(), out);
-                break;
-            }
+        bool isMono;
 
-            case PRIM_LambdaMonoP: {
-                ensureArity(args, 1);
-
-                bool isMono;
-
-                ObjectPtr callable = valueToStatic(args->values[0]);
-                if (callable != nullptr && callable->objKind == TYPE) {
-                    Type *t = (Type *) callable.ptr();
-                    if (t->typeKind == RECORD_TYPE) {
-                        RecordType *r = (RecordType *) t;
-                        isMono = r->record->lambda->mono.monoState == Procedure_MonoOverload;
-                    } else
-                        isMono = false;
-                } else {
-                    isMono = false;
-                }
+        ObjectPtr callable = valueToStatic(args->values[0]);
+        if (callable != nullptr && callable->objKind == TYPE) {
+            Type *t = (Type *)callable.ptr();
+            if (t->typeKind == RECORD_TYPE) {
+                RecordType *r = (RecordType *)t;
+                isMono =
+                    r->record->lambda->mono.monoState == Procedure_MonoOverload;
+            } else
+                isMono = false;
+        } else {
+            isMono = false;
+        }
 
-                ValueHolderPtr vh = boolToValueHolder(isMono);
-                evalStaticObject(vh.ptr(), out);
-                break;
-            }
+        ValueHolderPtr vh = boolToValueHolder(isMono);
+        evalStaticObject(vh.ptr(), out);
+        break;
+    }
 
-            case PRIM_LambdaMonoInputTypes:
-                break;
+    case PRIM_LambdaMonoInputTypes:
+        break;
 
-            case PRIM_GetOverload:
-                break;
+    case PRIM_GetOverload:
+        break;
 
-            case PRIM_usuallyEquals: {
-                ensureArity(args, 2);
-                EValuePtr ev0 = args->values[0];
-                if (!isPrimitiveType(ev0->type))
-                    argumentTypeError(0, "primitive type", ev0->type);
+    case PRIM_usuallyEquals: {
+        ensureArity(args, 2);
+        EValuePtr ev0 = args->values[0];
+        if (!isPrimitiveType(ev0->type))
+            argumentTypeError(0, "primitive type", ev0->type);
 
-                assert(out->values.size() == 1);
-                EValuePtr out0 = out->values[0];
-                assert(out0->type == ev0->type);
-                memcpy(out0->addr, ev0->addr, typeSize(ev0->type));
-                break;
-            }
+        assert(out->values.size() == 1);
+        EValuePtr out0 = out->values[0];
+        assert(out0->type == ev0->type);
+        memcpy(out0->addr, ev0->addr, typeSize(ev0->type));
+        break;
+    }
 
-            default:
-                assert(false);
-        }
+    default:
+        assert(false);
     }
 }
+} // namespace clay
diff --git a/compiler/evaluator_op.hpp b/compiler/evaluator_op.hpp
index 7b9cd7a0..c77aaef7 100644
--- a/compiler/evaluator_op.hpp
+++ b/compiler/evaluator_op.hpp
@@ -3,5 +3,5 @@
 #include "clay.hpp"
 
 namespace clay {
-    void evalPrimOp(PrimOpPtr x, MultiEValuePtr args, MultiEValuePtr out);
+void evalPrimOp(PrimOpPtr x, MultiEValuePtr args, MultiEValuePtr out);
 }
diff --git a/compiler/externals.cpp b/compiler/externals.cpp
index 3ae023a1..16ae8d7b 100644
--- a/compiler/externals.cpp
+++ b/compiler/externals.cpp
@@ -1,1205 +1,1226 @@
-#include "clay.hpp"
 #include "externals.hpp"
-#include "objects.hpp"
+#include "clay.hpp"
 #include "error.hpp"
+#include "objects.hpp"
 
 #pragma clang diagnostic ignored "-Wcovered-switch-default"
 
 namespace clay {
-    static llvm::Value *promoteCVarArg(CallingConv conv,
-                                       TypePtr t,
-                                       llvm::Value *llv,
-                                       CodegenContext *ctx) {
-        if (conv == CC_LLVM)
-            return llv;
-
-        switch (t->typeKind) {
-            case INTEGER_TYPE: {
-                IntegerType *it = (IntegerType *) t.ptr();
-                if (it->bits < 32) {
-                    if (it->isSigned)
-                        return ctx->builder->CreateSExt(llv, llvmType(int32Type));
-                    else
-                        return ctx->builder->CreateZExt(llv, llvmType(uint32Type));
-                }
-                return llv;
-            }
-            case FLOAT_TYPE: {
-                FloatType *ft = (FloatType *) t.ptr();
-                if (ft->bits == 32) {
-                    if (ft->isImaginary)
-                        return ctx->builder->CreateFPExt(llv, llvmType(imag64Type));
-                    else
-                        return ctx->builder->CreateFPExt(llv, llvmType(float64Type));
-                }
-                return llv;
-            }
-            case NEW_TYPE: {
-                NewType *nt = (NewType *) t.ptr();
-                return promoteCVarArg(conv, newtypeReprType(nt), llv, ctx);
-            }
-            default:
-                return llv;
+static llvm::Value *promoteCVarArg(CallingConv conv, TypePtr t,
+                                   llvm::Value *llv, CodegenContext *ctx) {
+    if (conv == CC_LLVM)
+        return llv;
+
+    switch (t->typeKind) {
+    case INTEGER_TYPE: {
+        IntegerType *it = (IntegerType *)t.ptr();
+        if (it->bits < 32) {
+            if (it->isSigned)
+                return ctx->builder->CreateSExt(llv, llvmType(int32Type));
+            else
+                return ctx->builder->CreateZExt(llv, llvmType(uint32Type));
         }
+        return llv;
+    }
+    case FLOAT_TYPE: {
+        FloatType *ft = (FloatType *)t.ptr();
+        if (ft->bits == 32) {
+            if (ft->isImaginary)
+                return ctx->builder->CreateFPExt(llv, llvmType(imag64Type));
+            else
+                return ctx->builder->CreateFPExt(llv, llvmType(float64Type));
+        }
+        return llv;
+    }
+    case NEW_TYPE: {
+        NewType *nt = (NewType *)t.ptr();
+        return promoteCVarArg(conv, newtypeReprType(nt), llv, ctx);
     }
+    default:
+        return llv;
+    }
+}
 
-    llvm::FunctionType *ExternalFunction::getLLVMFunctionType() const {
-        llvm::Type *retType;
-        vector<llvm::Type *> argTypes;
+llvm::FunctionType *ExternalFunction::getLLVMFunctionType() const {
+    llvm::Type *retType;
+    vector<llvm::Type *> argTypes;
+
+    if (retInfo.type == nullptr) {
+        retType = llvmVoidType();
+    } else if (retInfo.ext.isIndirect()) {
+        retType = llvmVoidType();
+        argTypes.push_back(llvmPointerType(retInfo.type));
+    } else {
+        retType = retInfo.ext.type ? retInfo.ext.type : llvmType(retInfo.type);
+    }
 
-        if (retInfo.type == nullptr) {
-            retType = llvmVoidType();
-        } else if (retInfo.ext.isIndirect()) {
-            retType = llvmVoidType();
-            argTypes.push_back(llvmPointerType(retInfo.type));
+    for (vector<ArgInfo>::const_iterator it = argInfos.begin(),
+                                         ie = argInfos.end();
+         it != ie; ++it) {
+        llvm::Type *type;
+        if (it->ext.isIndirect()) {
+            type = llvmPointerType(it->type);
         } else {
-            retType = retInfo.ext.type ? retInfo.ext.type : llvmType(retInfo.type);
+            type = it->ext.type ? it->ext.type : llvmType(it->type);
         }
+        argTypes.push_back(type);
+    }
 
-        for (vector<ArgInfo>::const_iterator
-                     it = argInfos.begin(), ie = argInfos.end();
-             it != ie; ++it) {
-            llvm::Type *type;
-            if (it->ext.isIndirect()) {
-                type = llvmPointerType(it->type);
-            } else {
-                type = it->ext.type ? it->ext.type : llvmType(it->type);
-            }
-            argTypes.push_back(type);
-        }
+    return llvm::FunctionType::get(retType, argTypes, isVarArg);
+}
 
-        return llvm::FunctionType::get(retType, argTypes, isVarArg);
+void ExternalFunction::allocReturnValue(ArgInfo info,
+                                        llvm::Function::arg_iterator &ai,
+                                        vector<CReturn> &returns,
+                                        CodegenContext *ctx) {
+    if (info.type == nullptr)
+        return;
+    else if (info.ext.isIndirect()) {
+        llvm::Argument *structReturnArg = &(*ai);
+        assert(structReturnArg->getType() == llvmPointerType(info.type));
+        structReturnArg->setName("returned");
+        ++ai;
+        CValuePtr cret = new CValue(info.type, structReturnArg);
+        returns.push_back(CReturn(false, info.type, cret));
+    } else {
+        llvm::Value *llRetVal =
+            ctx->initBuilder->CreateAlloca(llvmType(info.type));
+        CValuePtr cret = new CValue(info.type, llRetVal);
+        returns.push_back(CReturn(false, info.type, cret));
     }
+}
 
-    void ExternalFunction::allocReturnValue(ArgInfo info,
-                                            llvm::Function::arg_iterator &ai,
-                                            vector<CReturn> &returns,
-                                            CodegenContext *ctx) {
-        if (info.type == nullptr)
-            return;
-        else if (info.ext.isIndirect()) {
-            llvm::Argument *structReturnArg = &(*ai);
-            assert(structReturnArg->getType() == llvmPointerType(info.type));
-            structReturnArg->setName("returned");
+CValuePtr ExternalFunction::allocArgumentValue(ArgInfo info,
+                                               llvm::StringRef name,
+                                               llvm::Function::arg_iterator &ai,
+                                               CodegenContext *ctx) {
+    if (info.ext.isIndirect()) {
+        llvm::Argument *llArg = &(*ai);
+        assert(llArg->getType() == llvmPointerType(info.type));
+        llArg->setName(name);
+        CValuePtr cvalue = new CValue(info.type, llArg);
+        ++ai;
+        return cvalue;
+    } else {
+        llvm::Type *bitcastType = info.ext.type;
+        if (bitcastType != nullptr) {
+            llvm::Argument *llArg = &(*ai);
+            assert(llArg->getType() == bitcastType);
+            llArg->setName(name);
+            llvm::Value *llArgAlloc =
+                ctx->initBuilder->CreateAlloca(bitcastType);
+            ctx->builder->CreateStore(llArg, llArgAlloc);
+            llvm::Value *llArgVar = ctx->initBuilder->CreateBitCast(
+                llArgAlloc, llvmPointerType(info.type));
+            CValuePtr cvalue = new CValue(info.type, llArgVar);
             ++ai;
-            CValuePtr cret = new CValue(info.type, structReturnArg);
-            returns.push_back(CReturn(false, info.type, cret));
+            return cvalue;
         } else {
-            llvm::Value *llRetVal =
-                    ctx->initBuilder->CreateAlloca(llvmType(info.type));
-            CValuePtr cret = new CValue(info.type, llRetVal);
-            returns.push_back(CReturn(false, info.type, cret));
-        }
-    }
-
-    CValuePtr ExternalFunction::allocArgumentValue(ArgInfo info,
-                                                   llvm::StringRef name,
-                                                   llvm::Function::arg_iterator &ai,
-                                                   CodegenContext *ctx) {
-        if (info.ext.isIndirect()) {
             llvm::Argument *llArg = &(*ai);
-            assert(llArg->getType() == llvmPointerType(info.type));
             llArg->setName(name);
-            CValuePtr cvalue = new CValue(info.type, llArg);
+            llvm::Value *llArgVar =
+                ctx->initBuilder->CreateAlloca(llvmType(info.type));
+            llArgVar->setName(name);
+            ctx->builder->CreateStore(llArg, llArgVar);
+            CValuePtr cvalue = new CValue(info.type, llArgVar);
             ++ai;
             return cvalue;
-        } else {
-            llvm::Type *bitcastType = info.ext.type;
-            if (bitcastType != nullptr) {
-                llvm::Argument *llArg = &(*ai);
-                assert(llArg->getType() == bitcastType);
-                llArg->setName(name);
-                llvm::Value *llArgAlloc =
-                        ctx->initBuilder->CreateAlloca(bitcastType);
-                ctx->builder->CreateStore(llArg, llArgAlloc);
-                llvm::Value *llArgVar =
-                        ctx->initBuilder->CreateBitCast(
-                            llArgAlloc, llvmPointerType(info.type));
-                CValuePtr cvalue = new CValue(info.type, llArgVar);
-                ++ai;
-                return cvalue;
-            } else {
-                llvm::Argument *llArg = &(*ai);
-                llArg->setName(name);
-                llvm::Value *llArgVar =
-                        ctx->initBuilder->CreateAlloca(llvmType(info.type));
-                llArgVar->setName(name);
-                ctx->builder->CreateStore(llArg, llArgVar);
-                CValuePtr cvalue = new CValue(info.type, llArgVar);
-                ++ai;
-                return cvalue;
-            }
         }
     }
+}
 
-    void ExternalFunction::returnStatement(ArgInfo info,
-                                           vector<CReturn> &returns,
-                                           CodegenContext *ctx) {
-        if (info.type == nullptr || info.ext.isIndirect()) {
-            ctx->builder->CreateRetVoid();
+void ExternalFunction::returnStatement(ArgInfo info, vector<CReturn> &returns,
+                                       CodegenContext *ctx) {
+    if (info.type == nullptr || info.ext.isIndirect()) {
+        ctx->builder->CreateRetVoid();
+    } else {
+        llvm::Type *bitcastType = info.ext.type;
+        if (bitcastType != nullptr) {
+            CValuePtr retVal = returns[0].value;
+            llvm::Value *bitcast = ctx->builder->CreateBitCast(
+                retVal->llValue, llvm::PointerType::getUnqual(bitcastType));
+            llvm::Value *v = ctx->builder->CreateLoad(bitcast);
+            ctx->builder->CreateRet(v);
         } else {
-            llvm::Type *bitcastType = info.ext.type;
-            if (bitcastType != nullptr) {
-                CValuePtr retVal = returns[0].value;
-                llvm::Value *bitcast = ctx->builder->CreateBitCast(retVal->llValue,
-                                                                   llvm::PointerType::getUnqual(bitcastType));
-                llvm::Value *v = ctx->builder->CreateLoad(bitcast);
-                ctx->builder->CreateRet(v);
-            } else {
-                CValuePtr retVal = returns[0].value;
-                llvm::Value *v = ctx->builder->CreateLoad(retVal->llValue);
-                ctx->builder->CreateRet(v);
-            }
+            CValuePtr retVal = returns[0].value;
+            llvm::Value *v = ctx->builder->CreateLoad(retVal->llValue);
+            ctx->builder->CreateRet(v);
         }
     }
+}
 
-    void ExternalFunction::loadStructRetArgument(ArgInfo info,
-                                                 vector<llvm::Value *> &llArgs,
-                                                 CodegenContext *ctx,
-                                                 MultiCValuePtr out) {
-        if (info.type != nullptr && info.ext.isIndirect()) {
-            assert(out->size() == 1);
-            CValuePtr out0 = out->values[0];
-            assert(out0->type == info.type);
-            llArgs.push_back(out0->llValue);
-        }
+void ExternalFunction::loadStructRetArgument(ArgInfo info,
+                                             vector<llvm::Value *> &llArgs,
+                                             CodegenContext *ctx,
+                                             MultiCValuePtr out) {
+    if (info.type != nullptr && info.ext.isIndirect()) {
+        assert(out->size() == 1);
+        CValuePtr out0 = out->values[0];
+        assert(out0->type == info.type);
+        llArgs.push_back(out0->llValue);
     }
+}
 
-    void ExternalFunction::loadArgument(ArgInfo info,
-                                        CValuePtr cv,
-                                        vector<llvm::Value *> &llArgs,
-                                        CodegenContext *ctx,
-                                        bool varArg) {
-        if (info.ext.isIndirect()) {
-            llArgs.push_back(cv->llValue);
+void ExternalFunction::loadArgument(ArgInfo info, CValuePtr cv,
+                                    vector<llvm::Value *> &llArgs,
+                                    CodegenContext *ctx, bool varArg) {
+    if (info.ext.isIndirect()) {
+        llArgs.push_back(cv->llValue);
+    } else {
+        llvm::Type *bitcastType = info.ext.type;
+        if (bitcastType != nullptr) {
+            llvm::Value *llArg = ctx->builder->CreateBitCast(
+                cv->llValue, llvm::PointerType::getUnqual(bitcastType));
+            llvm::Value *llv = ctx->builder->CreateLoad(llArg);
+            llArgs.push_back(llv);
         } else {
-            llvm::Type *bitcastType = info.ext.type;
-            if (bitcastType != nullptr) {
-                llvm::Value *llArg = ctx->builder->CreateBitCast(cv->llValue,
-                                                                 llvm::PointerType::getUnqual(bitcastType));
-                llvm::Value *llv = ctx->builder->CreateLoad(llArg);
-                llArgs.push_back(llv);
-            } else {
-                llvm::Value *llv = ctx->builder->CreateLoad(cv->llValue);
-                if (varArg) {
-                    llv = promoteCVarArg(conv, info.type, llv, ctx);
-                }
-                llArgs.push_back(llv);
+            llvm::Value *llv = ctx->builder->CreateLoad(cv->llValue);
+            if (varArg) {
+                llv = promoteCVarArg(conv, info.type, llv, ctx);
             }
+            llArgs.push_back(llv);
         }
     }
+}
 
-    void ExternalFunction::storeReturnValue(ArgInfo info,
-                                            llvm::Value *callReturnValue,
-                                            CodegenContext *ctx,
-                                            MultiCValuePtr out) {
-        if (info.type == nullptr || info.ext.isIndirect()) {
-            return;
+void ExternalFunction::storeReturnValue(ArgInfo info,
+                                        llvm::Value *callReturnValue,
+                                        CodegenContext *ctx,
+                                        MultiCValuePtr out) {
+    if (info.type == nullptr || info.ext.isIndirect()) {
+        return;
+    } else {
+        llvm::Type *bitcastType = info.ext.type;
+        assert(out->size() == 1);
+        if (bitcastType != nullptr) {
+            CValuePtr out0 = out->values[0];
+            assert(out0->type == info.type);
+            llvm::Value *outRet = ctx->builder->CreateBitCast(
+                out0->llValue, llvm::PointerType::getUnqual(bitcastType));
+            ctx->builder->CreateStore(callReturnValue, outRet);
         } else {
-            llvm::Type *bitcastType = info.ext.type;
-            assert(out->size() == 1);
-            if (bitcastType != nullptr) {
-                CValuePtr out0 = out->values[0];
-                assert(out0->type == info.type);
-                llvm::Value *outRet = ctx->builder->CreateBitCast(out0->llValue,
-                                                                  llvm::PointerType::getUnqual(bitcastType));
-                ctx->builder->CreateStore(callReturnValue, outRet);
-            } else {
-                CValuePtr out0 = out->values[0];
-                assert(out0->type == info.type);
-                ctx->builder->CreateStore(callReturnValue, out0->llValue);
-            }
+            CValuePtr out0 = out->values[0];
+            assert(out0->type == info.type);
+            ctx->builder->CreateStore(callReturnValue, out0->llValue);
         }
     }
+}
 
-    //
-    // ExternalTarget
-    //
-
-    ExternalFunction *ExternalTarget::getExternalFunction(
-        CallingConv conv, TypePtr ret, vector<TypePtr> &args,
-        size_t numReqArg, bool isVarArg) {
-        llvm::FoldingSetNodeID ID;
-        ExternalFunction::Profile(ID, conv, ret, args, numReqArg, isVarArg);
+//
+// ExternalTarget
+//
+
+ExternalFunction *ExternalTarget::getExternalFunction(CallingConv conv,
+                                                      TypePtr ret,
+                                                      vector<TypePtr> &args,
+                                                      size_t numReqArg,
+                                                      bool isVarArg) {
+    llvm::FoldingSetNodeID ID;
+    ExternalFunction::Profile(ID, conv, ret, args, numReqArg, isVarArg);
+
+    void *insertPos = 0;
+    ExternalFunction *func = extFuncs.FindNodeOrInsertPos(ID, insertPos);
+    if (func)
+        return func;
 
-        void *insertPos = 0;
-        ExternalFunction *func = extFuncs.FindNodeOrInsertPos(ID, insertPos);
-        if (func)
-            return func;
+    func = new ExternalFunction(conv, ret, args, numReqArg, isVarArg);
+    extFuncs.InsertNode(func, insertPos);
+    computeInfo(func);
 
-        func = new ExternalFunction(conv, ret, args, numReqArg, isVarArg);
-        extFuncs.InsertNode(func, insertPos);
-        computeInfo(func);
+    return func;
+}
 
-        return func;
-    }
+//
+// Use the LLVM calling convention as-is with no argument mangling.
+//
 
-    //
-    // Use the LLVM calling convention as-is with no argument mangling.
-    //
+struct LLVMExternalTarget : public ExternalTarget {
+    llvm::Triple target;
 
-    struct LLVMExternalTarget : public ExternalTarget {
-        llvm::Triple target;
+    explicit LLVMExternalTarget(llvm::Triple target)
+        : ExternalTarget(), target(target) {}
 
-        explicit LLVMExternalTarget(llvm::Triple target)
-            : ExternalTarget(), target(target) {
-        }
+    virtual void computeInfo(ExternalFunction *f);
 
-        virtual void computeInfo(ExternalFunction *f);
+    ExtArgInfo pushReturnType(CallingConv conv, TypePtr type,
+                              vector<pair<unsigned, llvm::Attributes>> &llAttrs,
+                              unsigned &attrPos);
 
-        ExtArgInfo pushReturnType(
-            CallingConv conv, TypePtr type,
-            vector<pair<unsigned, llvm::Attributes> > &llAttrs,
-            unsigned &attrPos);
+    ExtArgInfo
+    pushArgumentType(CallingConv conv, TypePtr type,
+                     vector<pair<unsigned, llvm::Attributes>> &llAttrs,
+                     unsigned &argPos, bool varArg);
 
-        ExtArgInfo pushArgumentType(
-            CallingConv conv, TypePtr type,
-            vector<pair<unsigned, llvm::Attributes> > &llAttrs,
-            unsigned &argPos, bool varArg);
+    virtual llvm::CallingConv::ID callingConvention(CallingConv conv) {
+        return llvm::CallingConv::C;
+    }
 
-        virtual llvm::CallingConv::ID callingConvention(CallingConv conv) {
-            return llvm::CallingConv::C;
-        }
+    virtual llvm::Type *typeReturnsAsBitcastType(CallingConv conv,
+                                                 TypePtr type) {
+        return nullptr;
+    }
 
-        virtual llvm::Type *typeReturnsAsBitcastType(CallingConv conv, TypePtr type) {
-            return nullptr;
-        }
+    virtual llvm::Type *typePassesAsBitcastType(CallingConv conv, TypePtr type,
+                                                bool varArg) {
+        return nullptr;
+    }
 
-        virtual llvm::Type *typePassesAsBitcastType(CallingConv conv, TypePtr type, bool varArg) {
-            return nullptr;
-        }
+    virtual bool typeReturnsBySretPointer(CallingConv conv, TypePtr type) {
+        return false;
+    }
 
-        virtual bool typeReturnsBySretPointer(CallingConv conv, TypePtr type) {
-            return false;
-        }
+    virtual bool typePassesByByvalPointer(CallingConv conv, TypePtr type,
+                                          bool varArg) {
+        return false;
+    }
+};
 
-        virtual bool typePassesByByvalPointer(CallingConv conv, TypePtr type, bool varArg) {
-            return false;
-        }
-    };
+void LLVMExternalTarget::computeInfo(ExternalFunction *f) {
+    unsigned attrPos = 1;
 
-    void LLVMExternalTarget::computeInfo(ExternalFunction *f) {
-        unsigned attrPos = 1;
+    f->llConv = callingConvention(f->conv);
+    f->retInfo.ext =
+        pushReturnType(f->conv, f->retInfo.type, f->attrs, attrPos);
 
-        f->llConv = callingConvention(f->conv);
-        f->retInfo.ext = pushReturnType(
-            f->conv, f->retInfo.type, f->attrs, attrPos);
+    for (size_t i = 0, e = f->argInfos.size(); i < e; ++i) {
+        f->argInfos[i].ext = pushArgumentType(
+            f->conv, f->argInfos[i].type, f->attrs, attrPos, i >= f->numReqArg);
+    }
+}
 
-        for (size_t i = 0, e = f->argInfos.size(); i < e; ++i) {
-            f->argInfos[i].ext = pushArgumentType(
-                f->conv, f->argInfos[i].type, f->attrs,
-                attrPos, i >= f->numReqArg);
-        }
+ExtArgInfo LLVMExternalTarget::pushReturnType(
+    CallingConv conv, TypePtr type,
+    vector<pair<unsigned, llvm::Attributes>> &llAttrs, unsigned &attrPos) {
+    if (type == nullptr)
+        return ExtArgInfo::getDirect();
+    else if (typeReturnsBySretPointer(conv, type)) {
+        llvm::Attributes attrs =
+            llvm::Attributes::get(llvmContext, llvm::Attributes::StructRet);
+        llAttrs.push_back(make_pair(attrPos++, attrs));
+        return ExtArgInfo::getIndirect();
+    } else {
+        llvm::Type *bitcastType = typeReturnsAsBitcastType(conv, type);
+        if (bitcastType != nullptr)
+            return ExtArgInfo::getDirect(bitcastType);
+        else
+            return ExtArgInfo::getDirect();
     }
+}
 
-    ExtArgInfo LLVMExternalTarget::pushReturnType(
-        CallingConv conv, TypePtr type,
-        vector<pair<unsigned, llvm::Attributes> > &llAttrs,
-        unsigned &attrPos) {
-        if (type == nullptr)
+ExtArgInfo LLVMExternalTarget::pushArgumentType(
+    CallingConv conv, TypePtr type,
+    vector<pair<unsigned, llvm::Attributes>> &llAttrs, unsigned &attrPos,
+    bool varArg) {
+    if (typePassesByByvalPointer(conv, type, varArg)) {
+        llvm::Attributes attrs =
+            llvm::Attributes::get(llvmContext, llvm::Attributes::ByVal);
+        llAttrs.push_back(make_pair(attrPos++, attrs));
+        return ExtArgInfo::getIndirect();
+    } else {
+        llvm::Type *bitcastType = typePassesAsBitcastType(conv, type, varArg);
+        if (bitcastType != nullptr)
+            return ExtArgInfo::getDirect(bitcastType);
+        else
             return ExtArgInfo::getDirect();
-        else if (typeReturnsBySretPointer(conv, type)) {
-            llvm::Attributes attrs = llvm::Attributes::get(
-                llvmContext,
-                llvm::Attributes::StructRet);
-            llAttrs.push_back(make_pair(attrPos++, attrs));
-            return ExtArgInfo::getIndirect();
-        } else {
-            llvm::Type *bitcastType = typeReturnsAsBitcastType(conv, type);
-            if (bitcastType != nullptr)
-                return ExtArgInfo::getDirect(bitcastType);
-            else
-                return ExtArgInfo::getDirect();
-        }
     }
+}
 
-    ExtArgInfo LLVMExternalTarget::pushArgumentType(
-        CallingConv conv, TypePtr type,
-        vector<pair<unsigned, llvm::Attributes> > &llAttrs,
-        unsigned &attrPos, bool varArg) {
-        if (typePassesByByvalPointer(conv, type, varArg)) {
-            llvm::Attributes attrs = llvm::Attributes::get(
-                llvmContext,
-                llvm::Attributes::ByVal);
-            llAttrs.push_back(make_pair(attrPos++, attrs));
-            return ExtArgInfo::getIndirect();
-        } else {
-            llvm::Type *bitcastType = typePassesAsBitcastType(conv, type, varArg);
-            if (bitcastType != nullptr)
-                return ExtArgInfo::getDirect(bitcastType);
-            else
-                return ExtArgInfo::getDirect();
+//
+// x86-32 (and Windows x64)
+//
+
+struct X86_32_ExternalTarget : public LLVMExternalTarget {
+    // Linux, Solaris, and NetBSD pass all aggregates on the stack
+    // (except long long and complex float32)
+    bool alwaysPassStructsOnStack : 1;
+
+    // Windows x64 has only one calling convention
+    bool alwaysUseCCallingConv : 1;
+
+    // MacOS X passes XMM vectors in registers; other platforms treat them
+    // as aggregates
+    bool passVecAsNonaggregate : 1;
+
+    // MacOS X returns aggregates containing a single float or double
+    // on the x87 stack
+    bool returnSingleFloatAggregateAsNonaggregate : 1;
+
+    explicit X86_32_ExternalTarget(llvm::Triple target)
+        : LLVMExternalTarget(target) {
+        alwaysUseCCallingConv = target.getArch() == llvm::Triple::x86_64;
+        alwaysPassStructsOnStack = target.getOS() == llvm::Triple::NetBSD ||
+                                   target.getOS() == llvm::Triple::Linux ||
+                                   target.getOS() == llvm::Triple::Solaris;
+        passVecAsNonaggregate = target.getOS() == llvm::Triple::Darwin;
+        returnSingleFloatAggregateAsNonaggregate =
+            target.getOS() != llvm::Triple::Win32;
+    }
+
+    virtual llvm::CallingConv::ID callingConvention(CallingConv conv) {
+        if (alwaysUseCCallingConv)
+            return llvm::CallingConv::C;
+
+        switch (conv) {
+        case CC_DEFAULT:
+        case CC_LLVM:
+            return llvm::CallingConv::C;
+        case CC_STDCALL:
+            return llvm::CallingConv::X86_StdCall;
+        case CC_FASTCALL:
+            return llvm::CallingConv::X86_FastCall;
+        case CC_THISCALL:
+            return llvm::CallingConv::X86_ThisCall;
+        default:
+            assert(false);
+            return llvm::CallingConv::C;
         }
     }
 
-    //
-    // x86-32 (and Windows x64)
-    //
+    static const int PASS_ON_STACK = -1;
+    static const int PASS_THROUGH = -2;
 
-    struct X86_32_ExternalTarget : public LLVMExternalTarget {
-        // Linux, Solaris, and NetBSD pass all aggregates on the stack
-        // (except long long and complex float32)
-        bool alwaysPassStructsOnStack: 1;
+    int aggregateTypeSize(TypePtr type) {
+        switch (type->typeKind) {
+        case BOOL_TYPE:
+        case INTEGER_TYPE:
+        case FLOAT_TYPE:
+        case POINTER_TYPE:
+        case CODE_POINTER_TYPE:
+        case CCODE_POINTER_TYPE:
+        case STATIC_TYPE:
+        case ENUM_TYPE:
+            return PASS_THROUGH;
+
+        case VEC_TYPE:
+            if (passVecAsNonaggregate)
+                return PASS_THROUGH;
+            else
+                return int(typeSize(type));
 
-        // Windows x64 has only one calling convention
-        bool alwaysUseCCallingConv: 1;
+        case COMPLEX_TYPE:
+            return int(typeSize(type));
 
-        // MacOS X passes XMM vectors in registers; other platforms treat them
-        // as aggregates
-        bool passVecAsNonaggregate: 1;
+        case VARIANT_TYPE:
+        case UNION_TYPE:
+        case RECORD_TYPE:
+        case TUPLE_TYPE:
+            if (alwaysPassStructsOnStack)
+                return PASS_ON_STACK;
+            else
+                return int(typeSize(type));
 
-        // MacOS X returns aggregates containing a single float or double
-        // on the x87 stack
-        bool returnSingleFloatAggregateAsNonaggregate: 1;
+        case NEW_TYPE: {
+            NewType *nt = (NewType *)type.ptr();
+            return aggregateTypeSize(newtypeReprType(nt));
+        }
 
-        explicit X86_32_ExternalTarget(llvm::Triple target)
-            : LLVMExternalTarget(target) {
-            alwaysUseCCallingConv = target.getArch() == llvm::Triple::x86_64;
-            alwaysPassStructsOnStack = target.getOS() == llvm::Triple::NetBSD
-                                       || target.getOS() == llvm::Triple::Linux
-                                       || target.getOS() == llvm::Triple::Solaris;
-            passVecAsNonaggregate = target.getOS() == llvm::Triple::Darwin;
-            returnSingleFloatAggregateAsNonaggregate
-                    = target.getOS() != llvm::Triple::Win32;
+        default:
+            assert(false);
+            return 0;
         }
+    }
 
-        virtual llvm::CallingConv::ID callingConvention(CallingConv conv) {
-            if (alwaysUseCCallingConv)
-                return llvm::CallingConv::C;
-
-            switch (conv) {
-                case CC_DEFAULT:
-                case CC_LLVM:
-                    return llvm::CallingConv::C;
-                case CC_STDCALL:
-                    return llvm::CallingConv::X86_StdCall;
-                case CC_FASTCALL:
-                    return llvm::CallingConv::X86_FastCall;
-                case CC_THISCALL:
-                    return llvm::CallingConv::X86_ThisCall;
-                default:
-                    assert(false);
-                    return llvm::CallingConv::C;
-            }
+    llvm::Type *intTypeForAggregateSize(int size) {
+        switch (size) {
+        case 1:
+        case 2:
+        case 4:
+        case 8:
+            return llvmIntType(unsigned(8 * size));
+        default:
+            return nullptr;
         }
+    }
 
-        static const int PASS_ON_STACK = -1;
-        static const int PASS_THROUGH = -2;
-
-        int aggregateTypeSize(TypePtr type) {
-            switch (type->typeKind) {
-                case BOOL_TYPE:
-                case INTEGER_TYPE:
-                case FLOAT_TYPE:
-                case POINTER_TYPE:
-                case CODE_POINTER_TYPE:
-                case CCODE_POINTER_TYPE:
-                case STATIC_TYPE:
-                case ENUM_TYPE:
-                    return PASS_THROUGH;
-
-                case VEC_TYPE:
-                    if (passVecAsNonaggregate)
-                        return PASS_THROUGH;
-                    else
-                        return int(typeSize(type));
-
-                case COMPLEX_TYPE:
-                    return int(typeSize(type));
-
-                case VARIANT_TYPE:
-                case UNION_TYPE:
-                case RECORD_TYPE:
-                case TUPLE_TYPE:
-                    if (alwaysPassStructsOnStack)
-                        return PASS_ON_STACK;
-                    else
-                        return int(typeSize(type));
-
-                case NEW_TYPE: {
-                    NewType *nt = (NewType *) type.ptr();
-                    return aggregateTypeSize(newtypeReprType(nt));
-                }
+    bool isSingleFloatMemberType(TypePtr type) {
+        if (type->typeKind == FLOAT_TYPE) {
+            FloatType *ft = (FloatType *)type.ptr();
+            return ft->bits <= 64;
+        } else
+            return false;
+    }
 
-                default:
-                    assert(false);
-                    return 0;
-            }
+    llvm::Type *singleFloatAggregateType(TypePtr type) {
+        switch (type->typeKind) {
+        case BOOL_TYPE:
+        case INTEGER_TYPE:
+        case FLOAT_TYPE:
+        case POINTER_TYPE:
+        case CODE_POINTER_TYPE:
+        case CCODE_POINTER_TYPE:
+        case STATIC_TYPE:
+        case ENUM_TYPE:
+        case VEC_TYPE:
+        case COMPLEX_TYPE:
+        case VARIANT_TYPE:
+            return nullptr;
+
+        case NEW_TYPE: {
+            NewType *nt = (NewType *)type.ptr();
+            return singleFloatAggregateType(newtypeReprType(nt));
         }
 
-        llvm::Type *intTypeForAggregateSize(int size) {
-            switch (size) {
-                case 1:
-                case 2:
-                case 4:
-                case 8:
-                    return llvmIntType(unsigned(8 * size));
-                default:
-                    return nullptr;
-            }
+        case UNION_TYPE: {
+            UnionType *u = (UnionType *)type.ptr();
+            if (u->memberTypes.size() == 1 &&
+                isSingleFloatMemberType(u->memberTypes[0]))
+                return llvmType(u->memberTypes[0]);
+            return nullptr;
         }
 
-        bool isSingleFloatMemberType(TypePtr type) {
-            if (type->typeKind == FLOAT_TYPE) {
-                FloatType *ft = (FloatType *) type.ptr();
-                return ft->bits <= 64;
-            } else
-                return false;
+        case RECORD_TYPE: {
+            RecordType *r = (RecordType *)type.ptr();
+            llvm::ArrayRef<TypePtr> fieldTypes = recordFieldTypes(r);
+            if (fieldTypes.size() == 1 &&
+                isSingleFloatMemberType(fieldTypes[0]))
+                return llvmType(fieldTypes[0]);
+            return nullptr;
         }
 
-        llvm::Type *singleFloatAggregateType(TypePtr type) {
-            switch (type->typeKind) {
-                case BOOL_TYPE:
-                case INTEGER_TYPE:
-                case FLOAT_TYPE:
-                case POINTER_TYPE:
-                case CODE_POINTER_TYPE:
-                case CCODE_POINTER_TYPE:
-                case STATIC_TYPE:
-                case ENUM_TYPE:
-                case VEC_TYPE:
-                case COMPLEX_TYPE:
-                case VARIANT_TYPE:
-                    return nullptr;
-
-                case NEW_TYPE: {
-                    NewType *nt = (NewType *) type.ptr();
-                    return singleFloatAggregateType(newtypeReprType(nt));
-                }
+        case TUPLE_TYPE: {
+            TupleType *t = (TupleType *)type.ptr();
+            if (t->elementTypes.size() == 1 &&
+                isSingleFloatMemberType(t->elementTypes[0]))
+                return llvmType(t->elementTypes[0]);
+            return nullptr;
+        }
 
-                case UNION_TYPE: {
-                    UnionType *u = (UnionType *) type.ptr();
-                    if (u->memberTypes.size() == 1 && isSingleFloatMemberType(u->memberTypes[0]))
-                        return llvmType(u->memberTypes[0]);
-                    return nullptr;
-                }
+        default:
+            assert(false);
+            return nullptr;
+        }
+    }
 
-                case RECORD_TYPE: {
-                    RecordType *r = (RecordType *) type.ptr();
-                    llvm::ArrayRef<TypePtr> fieldTypes = recordFieldTypes(r);
-                    if (fieldTypes.size() == 1 && isSingleFloatMemberType(fieldTypes[0]))
-                        return llvmType(fieldTypes[0]);
-                    return nullptr;
-                }
+    virtual llvm::Type *typeReturnsAsBitcastType(CallingConv conv,
+                                                 TypePtr type) {
+        if (conv == CC_LLVM)
+            return nullptr;
+        if (returnSingleFloatAggregateAsNonaggregate) {
+            llvm::Type *singleType = singleFloatAggregateType(type);
+            if (singleType != nullptr)
+                return singleType;
+        }
+        return intTypeForAggregateSize(aggregateTypeSize(type));
+    }
 
-                case TUPLE_TYPE: {
-                    TupleType *t = (TupleType *) type.ptr();
-                    if (t->elementTypes.size() == 1 && isSingleFloatMemberType(t->elementTypes[0]))
-                        return llvmType(t->elementTypes[0]);
-                    return nullptr;
-                }
+    virtual llvm::Type *typePassesAsBitcastType(CallingConv conv, TypePtr type,
+                                                bool varArg) {
+        if (conv == CC_LLVM)
+            return nullptr;
+        return intTypeForAggregateSize(aggregateTypeSize(type));
+    }
 
-                default:
-                    assert(false);
-                    return nullptr;
-            }
+    virtual bool typeReturnsBySretPointer(CallingConv conv, TypePtr type) {
+        if (conv == CC_LLVM)
+            return false;
+        if (returnSingleFloatAggregateAsNonaggregate) {
+            llvm::Type *singleType = singleFloatAggregateType(type);
+            if (singleType != nullptr)
+                return false;
         }
 
-        virtual llvm::Type *typeReturnsAsBitcastType(CallingConv conv, TypePtr type) {
-            if (conv == CC_LLVM) return nullptr;
-            if (returnSingleFloatAggregateAsNonaggregate) {
-                llvm::Type *singleType = singleFloatAggregateType(type);
-                if (singleType != nullptr)
-                    return singleType;
-            }
-            return intTypeForAggregateSize(aggregateTypeSize(type));
-        }
+        int size = aggregateTypeSize(type);
+        return size != PASS_THROUGH && intTypeForAggregateSize(size) == nullptr;
+    }
 
-        virtual llvm::Type *typePassesAsBitcastType(CallingConv conv, TypePtr type, bool varArg) {
-            if (conv == CC_LLVM) return nullptr;
-            return intTypeForAggregateSize(aggregateTypeSize(type));
-        }
+    virtual bool typePassesByByvalPointer(CallingConv conv, TypePtr type,
+                                          bool varArg) {
+        if (conv == CC_LLVM)
+            return false;
+        int size = aggregateTypeSize(type);
+        return size != PASS_THROUGH && intTypeForAggregateSize(size) == nullptr;
+    }
+};
+
+//
+// Unix x86-64
+//
+
+enum WordClass {
+    NO_CLASS,
+    INTEGER,
+    // Vector and scalar SSE values are treated equivalently by the
+    // classification algorithm, but LLVM breaks stuff if we don't emit the
+    // right vec type
+    SSE_FLOAT_SCALAR,
+    SSE_DOUBLE_SCALAR,
+    SSE_FLOAT_VECTOR,
+    SSE_DOUBLE_VECTOR,
+    SSE_INT_VECTOR,
+    SSEUP,
+    X87,
+    X87UP,
+    COMPLEX_X87,
+    MEMORY
+};
+
+struct X86_64_ExternalTarget : public LLVMExternalTarget {
+    map<TypePtr, vector<WordClass>> typeClassifications;
+    map<TypePtr, llvm::Type *> llvmWordTypes;
+    // Mac OS X does its own thing with X87UP chunks not preceded by X87
+    bool passesOrphanX87UPAsSSE : 1;
+
+    explicit X86_64_ExternalTarget(llvm::Triple target)
+        : LLVMExternalTarget(target) {
+        passesOrphanX87UPAsSSE = target.getOS() == llvm::Triple::Darwin;
+    }
 
-        virtual bool typeReturnsBySretPointer(CallingConv conv, TypePtr type) {
-            if (conv == CC_LLVM) return false;
-            if (returnSingleFloatAggregateAsNonaggregate) {
-                llvm::Type *singleType = singleFloatAggregateType(type);
-                if (singleType != nullptr)
-                    return false;
-            }
+    llvm::ArrayRef<WordClass> getTypeClassification(TypePtr type);
 
-            int size = aggregateTypeSize(type);
-            return size != PASS_THROUGH && intTypeForAggregateSize(size) == nullptr;
-        }
+    llvm::Type *getLLVMWordType(TypePtr type);
 
-        virtual bool typePassesByByvalPointer(CallingConv conv, TypePtr type, bool varArg) {
-            if (conv == CC_LLVM) return false;
-            int size = aggregateTypeSize(type);
-            return size != PASS_THROUGH && intTypeForAggregateSize(size) == nullptr;
-        }
-    };
-
-    //
-    // Unix x86-64
-    //
-
-    enum WordClass {
-        NO_CLASS,
-        INTEGER,
-        // Vector and scalar SSE values are treated equivalently by the classification
-        // algorithm, but LLVM breaks stuff if we don't emit the right vec type
-        SSE_FLOAT_SCALAR,
-        SSE_DOUBLE_SCALAR,
-        SSE_FLOAT_VECTOR,
-        SSE_DOUBLE_VECTOR,
-        SSE_INT_VECTOR,
-        SSEUP,
-        X87,
-        X87UP,
-        COMPLEX_X87,
-        MEMORY
-    };
-
-    struct X86_64_ExternalTarget : public LLVMExternalTarget {
-        map<TypePtr, vector<WordClass> > typeClassifications;
-        map<TypePtr, llvm::Type *> llvmWordTypes;
-        // Mac OS X does its own thing with X87UP chunks not preceded by X87
-        bool passesOrphanX87UPAsSSE: 1;
-
-        explicit X86_64_ExternalTarget(llvm::Triple target)
-            : LLVMExternalTarget(target) {
-            passesOrphanX87UPAsSSE = target.getOS() == llvm::Triple::Darwin;
-        }
+    llvm::Type *llvmWordType(TypePtr type);
 
-        llvm::ArrayRef<WordClass> getTypeClassification(TypePtr type);
-
-        llvm::Type *getLLVMWordType(TypePtr type);
-
-        llvm::Type *llvmWordType(TypePtr type);
-
-        vector<WordClass> classifyType(TypePtr type);
-
-        static bool canPassThrough(TypePtr type) {
-            switch (type->typeKind) {
-                case BOOL_TYPE:
-                case INTEGER_TYPE:
-                case FLOAT_TYPE:
-                case POINTER_TYPE:
-                case CODE_POINTER_TYPE:
-                case CCODE_POINTER_TYPE:
-                case STATIC_TYPE:
-                case ENUM_TYPE:
-                case VEC_TYPE:
-                    return true;
-                case COMPLEX_TYPE:
-                case VARIANT_TYPE:
-                case UNION_TYPE:
-                case RECORD_TYPE:
-                case TUPLE_TYPE:
-                    return false;
-                case NEW_TYPE: {
-                    NewType *nt = (NewType *) type.ptr();
-                    return canPassThrough(newtypeReprType(nt));
-                }
-                default:
-                    assert(false);
-                    return false;
-            }
-        }
+    vector<WordClass> classifyType(TypePtr type);
 
-        static bool isSSEClass(WordClass c) {
-            return c == SSE_FLOAT_SCALAR
-                   || c == SSE_DOUBLE_SCALAR
-                   || c == SSE_FLOAT_VECTOR
-                   || c == SSE_DOUBLE_VECTOR
-                   || c == SSE_INT_VECTOR;
+    static bool canPassThrough(TypePtr type) {
+        switch (type->typeKind) {
+        case BOOL_TYPE:
+        case INTEGER_TYPE:
+        case FLOAT_TYPE:
+        case POINTER_TYPE:
+        case CODE_POINTER_TYPE:
+        case CCODE_POINTER_TYPE:
+        case STATIC_TYPE:
+        case ENUM_TYPE:
+        case VEC_TYPE:
+            return true;
+        case COMPLEX_TYPE:
+        case VARIANT_TYPE:
+        case UNION_TYPE:
+        case RECORD_TYPE:
+        case TUPLE_TYPE:
+            return false;
+        case NEW_TYPE: {
+            NewType *nt = (NewType *)type.ptr();
+            return canPassThrough(newtypeReprType(nt));
         }
-
-        static bool areYmmWordClasses(llvm::ArrayRef<WordClass> wordClasses) {
-            return (wordClasses.size() > 2
-                    && isSSEClass(wordClasses[0]) && wordClasses[1] == SSEUP && wordClasses[2] == SSEUP)
-                   || (wordClasses.size() > 3
-                       && isSSEClass(wordClasses[1]) && wordClasses[2] == SSEUP && wordClasses[3] == SSEUP);
+        default:
+            assert(false);
+            return false;
         }
+    }
 
-        void fixupClassification(TypePtr type, vector<WordClass> &wordClasses);
+    static bool isSSEClass(WordClass c) {
+        return c == SSE_FLOAT_SCALAR || c == SSE_DOUBLE_SCALAR ||
+               c == SSE_FLOAT_VECTOR || c == SSE_DOUBLE_VECTOR ||
+               c == SSE_INT_VECTOR;
+    }
 
-        virtual llvm::CallingConv::ID callingConvention(CallingConv conv) {
-            return llvm::CallingConv::C;
-        }
+    static bool areYmmWordClasses(llvm::ArrayRef<WordClass> wordClasses) {
+        return (wordClasses.size() > 2 && isSSEClass(wordClasses[0]) &&
+                wordClasses[1] == SSEUP && wordClasses[2] == SSEUP) ||
+               (wordClasses.size() > 3 && isSSEClass(wordClasses[1]) &&
+                wordClasses[2] == SSEUP && wordClasses[3] == SSEUP);
+    }
 
-        virtual llvm::Type *typeReturnsAsBitcastType(CallingConv conv, TypePtr type) {
-            if (conv == CC_LLVM) return nullptr;
-            if (typeReturnsBySretPointer(conv, type)) return nullptr;
-            if (canPassThrough(type)) return nullptr;
+    void fixupClassification(TypePtr type, vector<WordClass> &wordClasses);
 
-            return getLLVMWordType(type);
-        }
+    virtual llvm::CallingConv::ID callingConvention(CallingConv conv) {
+        return llvm::CallingConv::C;
+    }
 
-        virtual llvm::Type *typePassesAsBitcastType(CallingConv conv, TypePtr type, bool varArg) {
-            if (conv == CC_LLVM) return nullptr;
-            if (typePassesByByvalPointer(conv, type, varArg)) return nullptr;
-            if (canPassThrough(type)) return nullptr;
+    virtual llvm::Type *typeReturnsAsBitcastType(CallingConv conv,
+                                                 TypePtr type) {
+        if (conv == CC_LLVM)
+            return nullptr;
+        if (typeReturnsBySretPointer(conv, type))
+            return nullptr;
+        if (canPassThrough(type))
+            return nullptr;
 
-            return getLLVMWordType(type);
-        }
+        return getLLVMWordType(type);
+    }
 
-        virtual bool typeReturnsBySretPointer(CallingConv conv, TypePtr type) {
-            if (conv == CC_LLVM) return false;
+    virtual llvm::Type *typePassesAsBitcastType(CallingConv conv, TypePtr type,
+                                                bool varArg) {
+        if (conv == CC_LLVM)
+            return nullptr;
+        if (typePassesByByvalPointer(conv, type, varArg))
+            return nullptr;
+        if (canPassThrough(type))
+            return nullptr;
 
-            llvm::ArrayRef<WordClass> wordClasses = getTypeClassification(type);
-            assert(!wordClasses.empty());
+        return getLLVMWordType(type);
+    }
 
-            return wordClasses[0] == MEMORY;
-        }
+    virtual bool typeReturnsBySretPointer(CallingConv conv, TypePtr type) {
+        if (conv == CC_LLVM)
+            return false;
 
-        virtual bool typePassesByByvalPointer(CallingConv conv, TypePtr type, bool varArg) {
-            if (conv == CC_LLVM) return false;
+        llvm::ArrayRef<WordClass> wordClasses = getTypeClassification(type);
+        assert(!wordClasses.empty());
 
-            llvm::ArrayRef<WordClass> wordClasses = getTypeClassification(type);
-            assert(!wordClasses.empty());
+        return wordClasses[0] == MEMORY;
+    }
 
-            if (varArg && areYmmWordClasses(wordClasses))
-                return true;
+    virtual bool typePassesByByvalPointer(CallingConv conv, TypePtr type,
+                                          bool varArg) {
+        if (conv == CC_LLVM)
+            return false;
 
-            // According to the spec, X87-class arguments should also be passed by byval
-            // here; however, as of LLVM 3.1, LLVM appears not to pass an x87_fp80 correctly
-            // unless it is passed by value instead of by byval pointer.
-            return wordClasses[0] == MEMORY
-                   || wordClasses[0] == COMPLEX_X87;
-        }
-    };
+        llvm::ArrayRef<WordClass> wordClasses = getTypeClassification(type);
+        assert(!wordClasses.empty());
 
-    static void unifyWordClass(vector<WordClass>::iterator wordi, WordClass newClass) {
-        if (*wordi == newClass)
-            return;
-        else if (*wordi == NO_CLASS)
-            *wordi = newClass;
-        else if (newClass == NO_CLASS)
-            return;
-        else if (*wordi == MEMORY || newClass == MEMORY)
-            *wordi = MEMORY;
-        else if (*wordi == INTEGER || newClass == INTEGER)
-            *wordi = INTEGER;
-        else if (*wordi == X87 || *wordi == X87UP || *wordi == COMPLEX_X87
-                 || newClass == X87 || newClass == X87UP || newClass == COMPLEX_X87)
-            *wordi = MEMORY;
-        else {
-            assert(X86_64_ExternalTarget::isSSEClass(newClass));
-            *wordi = newClass;
-        }
+        if (varArg && areYmmWordClasses(wordClasses))
+            return true;
+
+        // According to the spec, X87-class arguments should also be passed by
+        // byval here; however, as of LLVM 3.1, LLVM appears not to pass an
+        // x87_fp80 correctly unless it is passed by value instead of by byval
+        // pointer.
+        return wordClasses[0] == MEMORY || wordClasses[0] == COMPLEX_X87;
+    }
+};
+
+static void unifyWordClass(vector<WordClass>::iterator wordi,
+                           WordClass newClass) {
+    if (*wordi == newClass)
+        return;
+    else if (*wordi == NO_CLASS)
+        *wordi = newClass;
+    else if (newClass == NO_CLASS)
+        return;
+    else if (*wordi == MEMORY || newClass == MEMORY)
+        *wordi = MEMORY;
+    else if (*wordi == INTEGER || newClass == INTEGER)
+        *wordi = INTEGER;
+    else if (*wordi == X87 || *wordi == X87UP || *wordi == COMPLEX_X87 ||
+             newClass == X87 || newClass == X87UP || newClass == COMPLEX_X87)
+        *wordi = MEMORY;
+    else {
+        assert(X86_64_ExternalTarget::isSSEClass(newClass));
+        *wordi = newClass;
     }
+}
 
-    static void _classifyStructType(llvm::ArrayRef<TypePtr> fields,
-                                    vector<WordClass>::iterator begin,
-                                    size_t offset);
+static void _classifyStructType(llvm::ArrayRef<TypePtr> fields,
+                                vector<WordClass>::iterator begin,
+                                size_t offset);
+
+static void _classifyType(TypePtr type, vector<WordClass>::iterator begin,
+                          size_t offset) {
+    size_t misalign = offset % typeAlignment(type);
+    if (misalign != 0) {
+        for (size_t i = offset / 8; i < (offset + typeSize(type) + 7) / 8; ++i)
+            unifyWordClass(begin + (long int)i, MEMORY);
+        return;
+    }
 
-    static void _classifyType(TypePtr type, vector<WordClass>::iterator begin, size_t offset) {
-        size_t misalign = offset % typeAlignment(type);
-        if (misalign != 0) {
-            for (size_t i = offset / 8; i < (offset + typeSize(type) + 7) / 8; ++i)
-                unifyWordClass(begin + (long int) i, MEMORY);
-            return;
+    switch (type->typeKind) {
+    case BOOL_TYPE:
+    case STATIC_TYPE:
+    case ENUM_TYPE:
+    case INTEGER_TYPE:
+    case POINTER_TYPE:
+    case CODE_POINTER_TYPE:
+    case CCODE_POINTER_TYPE: {
+        unifyWordClass(begin + (long int)offset / 8, INTEGER);
+        break;
+    }
+    case FLOAT_TYPE: {
+        FloatType *x = (FloatType *)type.ptr();
+        switch (x->bits) {
+        case 32:
+            if (offset % 8 == 4)
+                unifyWordClass(begin + (long int)offset / 8, SSE_FLOAT_VECTOR);
+            else
+                unifyWordClass(begin + (long int)offset / 8, SSE_FLOAT_SCALAR);
+            break;
+        case 64:
+            unifyWordClass(begin + (long int)offset / 8, SSE_DOUBLE_SCALAR);
+            break;
+        case 80:
+            unifyWordClass(begin + (long int)offset / 8, X87);
+            unifyWordClass(begin + (long int)offset / 8 + 1, X87UP);
+            break;
+        default:
+            assert(false);
+            break;
         }
-
-        switch (type->typeKind) {
-            case BOOL_TYPE:
-            case STATIC_TYPE:
-            case ENUM_TYPE:
-            case INTEGER_TYPE:
-            case POINTER_TYPE:
-            case CODE_POINTER_TYPE:
-            case CCODE_POINTER_TYPE: {
-                unifyWordClass(begin + (long int) offset / 8, INTEGER);
-                break;
-            }
-            case FLOAT_TYPE: {
-                FloatType *x = (FloatType *) type.ptr();
-                switch (x->bits) {
-                    case 32:
-                        if (offset % 8 == 4)
-                            unifyWordClass(begin + (long int) offset / 8, SSE_FLOAT_VECTOR);
-                        else
-                            unifyWordClass(begin + (long int) offset / 8, SSE_FLOAT_SCALAR);
-                        break;
-                    case 64:
-                        unifyWordClass(begin + (long int) offset / 8, SSE_DOUBLE_SCALAR);
-                        break;
-                    case 80:
-                        unifyWordClass(begin + (long int) offset / 8, X87);
-                        unifyWordClass(begin + (long int) offset / 8 + 1, X87UP);
-                        break;
-                    default:
-                        assert(false);
-                        break;
-                }
-                break;
-            }
-            case COMPLEX_TYPE: {
-                ComplexType *complexType = (ComplexType *) type.ptr();
-                switch (complexType->bits) {
-                    case 32:
-                    case 64:
-                        _classifyType(floatType(complexType->bits), begin, offset);
-                        _classifyType(imagType(complexType->bits), begin, offset + (size_t) complexType->bits / 8);
-                        break;
-                    case 80:
-                        unifyWordClass(begin + (long int) offset / 8, COMPLEX_X87);
-                        unifyWordClass(begin + (long int) offset / 8 + 1, COMPLEX_X87);
-                        unifyWordClass(begin + (long int) offset / 8 + 2, COMPLEX_X87);
-                        unifyWordClass(begin + (long int) offset / 8 + 3, COMPLEX_X87);
-                        break;
-                    default:
-                        assert(false);
-                        break;
-                }
-                break;
-            }
-            case ARRAY_TYPE: {
-                ArrayType *arrayType = (ArrayType *) type.ptr();
-                for (size_t i = 0; i < (size_t) arrayType->size; ++i)
-                    _classifyType(arrayType->elementType, begin,
-                                  offset + i * typeSize(arrayType->elementType));
-                break;
-            }
-            case VEC_TYPE: {
-                VecType *vecType = (VecType *) type.ptr();
-                switch (vecType->elementType->typeKind) {
-                    case FLOAT_TYPE: {
-                        FloatType *floatElementType = (FloatType *) vecType->elementType.ptr();
-                        switch (floatElementType->bits) {
-                            case 32:
-                                unifyWordClass(begin + (long int) offset / 8, SSE_FLOAT_VECTOR);
-                                break;
-                            case 64:
-                                unifyWordClass(begin + (long int) offset / 8, SSE_DOUBLE_VECTOR);
-                                break;
-                            case 80:
-                                error("Float80 vec types not supported");
-                                break;
-                        }
-                    }
-                    default:
-                        unifyWordClass(begin + (long int) offset / 8, SSE_INT_VECTOR);
-                        break;
-                }
-                for (size_t i = 1; i < (typeSize(type) + 7) / 8; ++i)
-                    unifyWordClass(begin + (long int) (offset / 8 + i), SSEUP);
-                break;
-            }
-            case VARIANT_TYPE: {
-                VariantType *x = (VariantType *) type.ptr();
-                _classifyType(variantReprType(x), begin, offset);
+        break;
+    }
+    case COMPLEX_TYPE: {
+        ComplexType *complexType = (ComplexType *)type.ptr();
+        switch (complexType->bits) {
+        case 32:
+        case 64:
+            _classifyType(floatType(complexType->bits), begin, offset);
+            _classifyType(imagType(complexType->bits), begin,
+                          offset + (size_t)complexType->bits / 8);
+            break;
+        case 80:
+            unifyWordClass(begin + (long int)offset / 8, COMPLEX_X87);
+            unifyWordClass(begin + (long int)offset / 8 + 1, COMPLEX_X87);
+            unifyWordClass(begin + (long int)offset / 8 + 2, COMPLEX_X87);
+            unifyWordClass(begin + (long int)offset / 8 + 3, COMPLEX_X87);
+            break;
+        default:
+            assert(false);
+            break;
+        }
+        break;
+    }
+    case ARRAY_TYPE: {
+        ArrayType *arrayType = (ArrayType *)type.ptr();
+        for (size_t i = 0; i < (size_t)arrayType->size; ++i)
+            _classifyType(arrayType->elementType, begin,
+                          offset + i * typeSize(arrayType->elementType));
+        break;
+    }
+    case VEC_TYPE: {
+        VecType *vecType = (VecType *)type.ptr();
+        switch (vecType->elementType->typeKind) {
+        case FLOAT_TYPE: {
+            FloatType *floatElementType =
+                (FloatType *)vecType->elementType.ptr();
+            switch (floatElementType->bits) {
+            case 32:
+                unifyWordClass(begin + (long int)offset / 8, SSE_FLOAT_VECTOR);
                 break;
-            }
-            case UNION_TYPE: {
-                UnionType *unionType = (UnionType *) type.ptr();
-                for (size_t i = 0; i < unionType->memberTypes.size(); ++i)
-                    _classifyType(unionType->memberTypes[i], begin, offset);
+            case 64:
+                unifyWordClass(begin + (long int)offset / 8, SSE_DOUBLE_VECTOR);
                 break;
-            }
-            case TUPLE_TYPE: {
-                TupleType *tupleType = (TupleType *) type.ptr();
-                _classifyStructType(tupleType->elementTypes,
-                                    begin,
-                                    offset);
+            case 80:
+                error("Float80 vec types not supported");
                 break;
             }
-            case RECORD_TYPE: {
-                RecordType *recordType = (RecordType *) type.ptr();
-                llvm::ArrayRef<TypePtr> fieldTypes = recordFieldTypes(recordType);
-                _classifyStructType(fieldTypes,
-                                    begin,
-                                    offset);
-                break;
-            }
-            case NEW_TYPE: {
-                NewType *nt = (NewType *) type.ptr();
-                _classifyType(newtypeReprType(nt), begin, offset);
-            }
         }
+        default:
+            unifyWordClass(begin + (long int)offset / 8, SSE_INT_VECTOR);
+            break;
+        }
+        for (size_t i = 1; i < (typeSize(type) + 7) / 8; ++i)
+            unifyWordClass(begin + (long int)(offset / 8 + i), SSEUP);
+        break;
+    }
+    case VARIANT_TYPE: {
+        VariantType *x = (VariantType *)type.ptr();
+        _classifyType(variantReprType(x), begin, offset);
+        break;
+    }
+    case UNION_TYPE: {
+        UnionType *unionType = (UnionType *)type.ptr();
+        for (size_t i = 0; i < unionType->memberTypes.size(); ++i)
+            _classifyType(unionType->memberTypes[i], begin, offset);
+        break;
+    }
+    case TUPLE_TYPE: {
+        TupleType *tupleType = (TupleType *)type.ptr();
+        _classifyStructType(tupleType->elementTypes, begin, offset);
+        break;
+    }
+    case RECORD_TYPE: {
+        RecordType *recordType = (RecordType *)type.ptr();
+        llvm::ArrayRef<TypePtr> fieldTypes = recordFieldTypes(recordType);
+        _classifyStructType(fieldTypes, begin, offset);
+        break;
+    }
+    case NEW_TYPE: {
+        NewType *nt = (NewType *)type.ptr();
+        _classifyType(newtypeReprType(nt), begin, offset);
+    }
     }
+}
 
-    static void _classifyStructType(llvm::ArrayRef<TypePtr> fields,
-                                    vector<WordClass>::iterator begin,
-                                    size_t offset) {
-        if (fields.empty())
-            _classifyType(intType(8), begin, offset);
-        else {
-            size_t fieldOffset = offset;
-            for (TypePtr const *i = fields.begin(), *end = fields.end();
-                 i != end;
-                 ++i) {
-                fieldOffset = alignedUpTo(fieldOffset, *i);
-                _classifyType(*i, begin, fieldOffset);
-                fieldOffset += typeSize(*i);
-            }
+static void _classifyStructType(llvm::ArrayRef<TypePtr> fields,
+                                vector<WordClass>::iterator begin,
+                                size_t offset) {
+    if (fields.empty())
+        _classifyType(intType(8), begin, offset);
+    else {
+        size_t fieldOffset = offset;
+        for (TypePtr const *i = fields.begin(), *end = fields.end(); i != end;
+             ++i) {
+            fieldOffset = alignedUpTo(fieldOffset, *i);
+            _classifyType(*i, begin, fieldOffset);
+            fieldOffset += typeSize(*i);
         }
     }
+}
 
-    static void _allMemory(vector<WordClass> &wordClasses) {
-        fill(wordClasses.begin(), wordClasses.end(), MEMORY);
-    }
+static void _allMemory(vector<WordClass> &wordClasses) {
+    fill(wordClasses.begin(), wordClasses.end(), MEMORY);
+}
 
-    void X86_64_ExternalTarget::fixupClassification(TypePtr type, vector<WordClass> &wordClasses) {
-        vector<WordClass>::iterator i = wordClasses.begin(),
-                end = wordClasses.end();
-        if (wordClasses.size() > 2 &&
-            (type->typeKind == ARRAY_TYPE || type->typeKind == RECORD_TYPE
-             || type->typeKind == VARIANT_TYPE || type->typeKind == UNION_TYPE
-             || type->typeKind == TUPLE_TYPE || type->typeKind == RECORD_TYPE)) {
-            assert(i != end);
-            if (X86_64_ExternalTarget::isSSEClass(*i)) {
-                ++i;
-                for (; i != end; ++i) {
-                    if (*i != SSEUP) {
-                        _allMemory(wordClasses);
-                        return;
-                    }
+void X86_64_ExternalTarget::fixupClassification(
+    TypePtr type, vector<WordClass> &wordClasses) {
+    vector<WordClass>::iterator i = wordClasses.begin(),
+                                end = wordClasses.end();
+    if (wordClasses.size() > 2 &&
+        (type->typeKind == ARRAY_TYPE || type->typeKind == RECORD_TYPE ||
+         type->typeKind == VARIANT_TYPE || type->typeKind == UNION_TYPE ||
+         type->typeKind == TUPLE_TYPE || type->typeKind == RECORD_TYPE)) {
+        assert(i != end);
+        if (X86_64_ExternalTarget::isSSEClass(*i)) {
+            ++i;
+            for (; i != end; ++i) {
+                if (*i != SSEUP) {
+                    _allMemory(wordClasses);
+                    return;
                 }
-            } else {
+            }
+        } else {
+            _allMemory(wordClasses);
+            return;
+        }
+    } else
+        while (i != end) {
+            if (*i == MEMORY) {
                 _allMemory(wordClasses);
                 return;
             }
-        } else
-            while (i != end) {
-                if (*i == MEMORY) {
+            if (*i == X87UP) {
+                if (passesOrphanX87UPAsSSE)
+                    *i = SSE_DOUBLE_SCALAR;
+                else
                     _allMemory(wordClasses);
-                    return;
-                }
-                if (*i == X87UP) {
-                    if (passesOrphanX87UPAsSSE)
-                        *i = SSE_DOUBLE_SCALAR;
-                    else
-                        _allMemory(wordClasses);
-                    return;
-                }
-                if (*i == SSEUP) {
-                    *i = SSE_DOUBLE_VECTOR;
-                } else if (X86_64_ExternalTarget::isSSEClass(*i)) {
-                    do { ++i; } while ((i != end) && (*i == SSEUP));
-                } else if (*i == X87) {
-                    do { ++i; } while ((i != end) && (*i == X87UP));
-                } else
-                    ++i;
+                return;
             }
-    }
-
-    vector<WordClass> X86_64_ExternalTarget::classifyType(TypePtr type) {
-        size_t wordSize = (typeSize(type) + 7) / 8;
-        assert(wordSize > 0);
-        vector<WordClass> wordClasses(wordSize, NO_CLASS);
-
-        if (wordSize > 4) {
-            _allMemory(wordClasses);
-            return wordClasses;
+            if (*i == SSEUP) {
+                *i = SSE_DOUBLE_VECTOR;
+            } else if (X86_64_ExternalTarget::isSSEClass(*i)) {
+                do {
+                    ++i;
+                } while ((i != end) && (*i == SSEUP));
+            } else if (*i == X87) {
+                do {
+                    ++i;
+                } while ((i != end) && (*i == X87UP));
+            } else
+                ++i;
         }
-        _classifyType(type, wordClasses.begin(), 0);
-        fixupClassification(type, wordClasses);
+}
 
+vector<WordClass> X86_64_ExternalTarget::classifyType(TypePtr type) {
+    size_t wordSize = (typeSize(type) + 7) / 8;
+    assert(wordSize > 0);
+    vector<WordClass> wordClasses(wordSize, NO_CLASS);
+
+    if (wordSize > 4) {
+        _allMemory(wordClasses);
         return wordClasses;
     }
+    _classifyType(type, wordClasses.begin(), 0);
+    fixupClassification(type, wordClasses);
 
-    llvm::ArrayRef<WordClass> X86_64_ExternalTarget::getTypeClassification(TypePtr type) {
-        map<TypePtr, vector<WordClass> >::iterator found = typeClassifications.find(type);
-        if (found == typeClassifications.end())
-            return typeClassifications.insert(make_pair(type, classifyType(type))).first->second;
-        else
-            return found->second;
-    }
+    return wordClasses;
+}
 
-    llvm::Type *X86_64_ExternalTarget::llvmWordType(TypePtr type) {
-        llvm::ArrayRef<WordClass> wordClasses = getTypeClassification(type);
-        assert(!wordClasses.empty());
+llvm::ArrayRef<WordClass>
+X86_64_ExternalTarget::getTypeClassification(TypePtr type) {
+    map<TypePtr, vector<WordClass>>::iterator found =
+        typeClassifications.find(type);
+    if (found == typeClassifications.end())
+        return typeClassifications.insert(make_pair(type, classifyType(type)))
+            .first->second;
+    else
+        return found->second;
+}
 
-        llvm::StructType *llType = llvm::StructType::create(llvmContext, "x86-64 " + typeName(type));
-        vector<llvm::Type *> llWordTypes;
-        WordClass const *i = wordClasses.begin();
-        size_t size = typeSize(type);
-        while (i != wordClasses.end()) {
-            assert(size > 0);
-            switch (*i) {
-                // docs don't cover this case. is it possible?
-                // e.g. struct { __m128 a; __m256 b; };
-                case NO_CLASS:
-                    assert(false);
-                    break;
-                case INTEGER: {
-                    unsigned wordSize = size >= 8 ? 64 : unsigned(size * 8);
-                    llWordTypes.push_back(llvmIntType(wordSize));
-                    ++i;
-                    break;
-                }
-                case SSE_INT_VECTOR: {
-                    unsigned vectorRun = 0;
-                    do {
-                        ++vectorRun;
-                        ++i;
-                    } while (i != wordClasses.end() && *i == SSEUP);
-                    // 8-byte int vectors are allocated to MMX registers, so always generate
-                    // a <float x n> vector for 64-bit SSE words.
-                    if (vectorRun == 1)
-                        llWordTypes.push_back(llvm::VectorType::get(llvmFloatType(64), vectorRun));
-                    else
-                        llWordTypes.push_back(llvm::VectorType::get(llvmIntType(64), vectorRun));
-                    break;
-                }
-                case SSE_FLOAT_VECTOR: {
-                    unsigned vectorRun = 0;
-                    do {
-                        ++vectorRun;
-                        ++i;
-                    } while (i != wordClasses.end() && *i == SSEUP);
-                    llWordTypes.push_back(llvm::VectorType::get(llvmFloatType(32), vectorRun * 2));
-                    break;
-                }
-                case SSE_DOUBLE_VECTOR: {
-                    unsigned vectorRun = 0;
-                    do {
-                        ++vectorRun;
-                        ++i;
-                    } while (i != wordClasses.end() && *i == SSEUP);
-                    llWordTypes.push_back(llvm::VectorType::get(llvmFloatType(64), vectorRun));
-                    break;
-                }
-                case SSE_FLOAT_SCALAR:
-                    llWordTypes.push_back(llvmFloatType(32));
-                    ++i;
-                    break;
-                case SSE_DOUBLE_SCALAR:
-                    llWordTypes.push_back(llvmFloatType(64));
-                    ++i;
-                    break;
-                case SSEUP:
-                    assert(false);
-                    break;
-                case X87:
-                    assert(wordClasses.end() - i >= 2 && i[1] == X87UP);
-                    llWordTypes.push_back(llvmFloatType(80));
-                    i += 2;
-                    break;
-                case X87UP:
-                    assert(false);
-                    break;
-                case COMPLEX_X87:
-                    assert(wordClasses.end() - i >= 4
-                        && i[1] == COMPLEX_X87
-                        && i[2] == COMPLEX_X87
-                        && i[3] == COMPLEX_X87);
-                    llWordTypes.push_back(llvmFloatType(80));
-                    llWordTypes.push_back(llvmFloatType(80));
-                    i += 4;
-                    break;
-                case MEMORY:
-                    assert(false);
-                    break;
-                default:
-                    assert(false);
-                    break;
-            }
-            assert(size >= 8 || i == wordClasses.end());
-            size -= 8;
+llvm::Type *X86_64_ExternalTarget::llvmWordType(TypePtr type) {
+    llvm::ArrayRef<WordClass> wordClasses = getTypeClassification(type);
+    assert(!wordClasses.empty());
+
+    llvm::StructType *llType =
+        llvm::StructType::create(llvmContext, "x86-64 " + typeName(type));
+    vector<llvm::Type *> llWordTypes;
+    WordClass const *i = wordClasses.begin();
+    size_t size = typeSize(type);
+    while (i != wordClasses.end()) {
+        assert(size > 0);
+        switch (*i) {
+        // docs don't cover this case. is it possible?
+        // e.g. struct { __m128 a; __m256 b; };
+        case NO_CLASS:
+            assert(false);
+            break;
+        case INTEGER: {
+            unsigned wordSize = size >= 8 ? 64 : unsigned(size * 8);
+            llWordTypes.push_back(llvmIntType(wordSize));
+            ++i;
+            break;
+        }
+        case SSE_INT_VECTOR: {
+            unsigned vectorRun = 0;
+            do {
+                ++vectorRun;
+                ++i;
+            } while (i != wordClasses.end() && *i == SSEUP);
+            // 8-byte int vectors are allocated to MMX registers, so always
+            // generate a <float x n> vector for 64-bit SSE words.
+            if (vectorRun == 1)
+                llWordTypes.push_back(
+                    llvm::VectorType::get(llvmFloatType(64), vectorRun));
+            else
+                llWordTypes.push_back(
+                    llvm::VectorType::get(llvmIntType(64), vectorRun));
+            break;
+        }
+        case SSE_FLOAT_VECTOR: {
+            unsigned vectorRun = 0;
+            do {
+                ++vectorRun;
+                ++i;
+            } while (i != wordClasses.end() && *i == SSEUP);
+            llWordTypes.push_back(
+                llvm::VectorType::get(llvmFloatType(32), vectorRun * 2));
+            break;
+        }
+        case SSE_DOUBLE_VECTOR: {
+            unsigned vectorRun = 0;
+            do {
+                ++vectorRun;
+                ++i;
+            } while (i != wordClasses.end() && *i == SSEUP);
+            llWordTypes.push_back(
+                llvm::VectorType::get(llvmFloatType(64), vectorRun));
+            break;
         }
-        llType->setBody(llWordTypes);
-        return llType;
+        case SSE_FLOAT_SCALAR:
+            llWordTypes.push_back(llvmFloatType(32));
+            ++i;
+            break;
+        case SSE_DOUBLE_SCALAR:
+            llWordTypes.push_back(llvmFloatType(64));
+            ++i;
+            break;
+        case SSEUP:
+            assert(false);
+            break;
+        case X87:
+            assert(wordClasses.end() - i >= 2 && i[1] == X87UP);
+            llWordTypes.push_back(llvmFloatType(80));
+            i += 2;
+            break;
+        case X87UP:
+            assert(false);
+            break;
+        case COMPLEX_X87:
+            assert(wordClasses.end() - i >= 4 && i[1] == COMPLEX_X87 &&
+                   i[2] == COMPLEX_X87 && i[3] == COMPLEX_X87);
+            llWordTypes.push_back(llvmFloatType(80));
+            llWordTypes.push_back(llvmFloatType(80));
+            i += 4;
+            break;
+        case MEMORY:
+            assert(false);
+            break;
+        default:
+            assert(false);
+            break;
+        }
+        assert(size >= 8 || i == wordClasses.end());
+        size -= 8;
     }
+    llType->setBody(llWordTypes);
+    return llType;
+}
 
-    llvm::Type *X86_64_ExternalTarget::getLLVMWordType(TypePtr type) {
-        map<TypePtr, llvm::Type *>::iterator found = llvmWordTypes.find(type);
-        if (found == llvmWordTypes.end()) {
-            return llvmWordTypes.insert(make_pair(type, llvmWordType(type))).first->second;
-        } else {
-            return found->second;
-        }
+llvm::Type *X86_64_ExternalTarget::getLLVMWordType(TypePtr type) {
+    map<TypePtr, llvm::Type *>::iterator found = llvmWordTypes.find(type);
+    if (found == llvmWordTypes.end()) {
+        return llvmWordTypes.insert(make_pair(type, llvmWordType(type)))
+            .first->second;
+    } else {
+        return found->second;
     }
+}
 
-    //
-    // Unix MIPS
-    //
+//
+// Unix MIPS
+//
 
-    struct Mips32_ExternalTarget : public ExternalTarget {
-        size_t stackAlign;
-        size_t minABIAlign;
+struct Mips32_ExternalTarget : public ExternalTarget {
+    size_t stackAlign;
+    size_t minABIAlign;
 
-        explicit Mips32_ExternalTarget() {
-            minABIAlign = 4;
-            stackAlign = 8;
-        }
+    explicit Mips32_ExternalTarget() {
+        minABIAlign = 4;
+        stackAlign = 8;
+    }
 
-        void coerceToIntArgs(size_t tySize, vector<llvm::Type *> &argList) const;
-
-        llvm::Type *getPaddingType(size_t align, size_t offset) const;
-
-        llvm::Type *getLLVMWordType(TypePtr type,
-                                    llvm::Type *padding,
-                                    bool coercion) const;
-
-        ExtArgInfo classifyArgumentType(TypePtr type, size_t &offset);
-
-        ExtArgInfo classifyReturnType(TypePtr type);
-
-        static bool canPassThrough(TypePtr type) {
-            switch (type->typeKind) {
-                case BOOL_TYPE:
-                case INTEGER_TYPE:
-                case FLOAT_TYPE:
-                case POINTER_TYPE:
-                case CODE_POINTER_TYPE:
-                case CCODE_POINTER_TYPE:
-                case STATIC_TYPE:
-                case ENUM_TYPE:
-                    return true;
-                case VEC_TYPE:
-                case COMPLEX_TYPE:
-                case VARIANT_TYPE:
-                case UNION_TYPE:
-                case RECORD_TYPE:
-                case TUPLE_TYPE:
-                    return false;
-                case NEW_TYPE: {
-                    NewType *nt = (NewType *) type.ptr();
-                    return canPassThrough(newtypeReprType(nt));
-                }
-                default:
-                    assert(false);
-                    return false;
-            }
-        }
+    void coerceToIntArgs(size_t tySize, vector<llvm::Type *> &argList) const;
 
-        void addAttrs(
-            vector<pair<unsigned, llvm::Attributes> > &attrs,
-            unsigned &pos, llvm::Attributes::AttrVal val) {
-            attrs.push_back(make_pair(
-                pos++, llvm::Attributes::get(llvmContext, val)));
-        }
+    llvm::Type *getPaddingType(size_t align, size_t offset) const;
 
-        virtual void computeInfo(ExternalFunction *f) {
-            f->llConv = llvm::CallingConv::C;
-            f->retInfo.ext = classifyReturnType(f->retInfo.type);
-
-            unsigned attrPos = 1;
-            bool sret = f->retInfo.ext.isIndirect();
-            if (sret)
-                addAttrs(f->attrs, attrPos, llvm::Attributes::StructRet);
-
-            size_t offset = sret ? minABIAlign : 0;
-            for (vector<ExternalFunction::ArgInfo>::iterator
-                         it = f->argInfos.begin(), ie = f->argInfos.end();
-                 it != ie; ++it) {
-                it->ext = classifyArgumentType(it->type, offset);
-                if (it->ext.isIndirect())
-                    addAttrs(f->attrs, attrPos, llvm::Attributes::ByVal);
-            }
-        }
-    };
+    llvm::Type *getLLVMWordType(TypePtr type, llvm::Type *padding,
+                                bool coercion) const;
 
-    void Mips32_ExternalTarget::coerceToIntArgs(size_t tySize,
-                                                vector<llvm::Type *> &argList)
-    const {
-        llvm::Type *intType = llvmIntType(minABIAlign * 8);
+    ExtArgInfo classifyArgumentType(TypePtr type, size_t &offset);
 
-        for (unsigned n = tySize / (minABIAlign * 8); n > 0; --n) {
-            argList.push_back(intType);
+    ExtArgInfo classifyReturnType(TypePtr type);
+
+    static bool canPassThrough(TypePtr type) {
+        switch (type->typeKind) {
+        case BOOL_TYPE:
+        case INTEGER_TYPE:
+        case FLOAT_TYPE:
+        case POINTER_TYPE:
+        case CODE_POINTER_TYPE:
+        case CCODE_POINTER_TYPE:
+        case STATIC_TYPE:
+        case ENUM_TYPE:
+            return true;
+        case VEC_TYPE:
+        case COMPLEX_TYPE:
+        case VARIANT_TYPE:
+        case UNION_TYPE:
+        case RECORD_TYPE:
+        case TUPLE_TYPE:
+            return false;
+        case NEW_TYPE: {
+            NewType *nt = (NewType *)type.ptr();
+            return canPassThrough(newtypeReprType(nt));
         }
+        default:
+            assert(false);
+            return false;
+        }
+    }
+
+    void addAttrs(vector<pair<unsigned, llvm::Attributes>> &attrs,
+                  unsigned &pos, llvm::Attributes::AttrVal val) {
+        attrs.push_back(
+            make_pair(pos++, llvm::Attributes::get(llvmContext, val)));
+    }
 
-        unsigned r = tySize % (minABIAlign * 8);
+    virtual void computeInfo(ExternalFunction *f) {
+        f->llConv = llvm::CallingConv::C;
+        f->retInfo.ext = classifyReturnType(f->retInfo.type);
 
-        if (r > 0) {
-            argList.push_back(llvmIntType(r));
+        unsigned attrPos = 1;
+        bool sret = f->retInfo.ext.isIndirect();
+        if (sret)
+            addAttrs(f->attrs, attrPos, llvm::Attributes::StructRet);
+
+        size_t offset = sret ? minABIAlign : 0;
+        for (vector<ExternalFunction::ArgInfo>::iterator
+                 it = f->argInfos.begin(),
+                 ie = f->argInfos.end();
+             it != ie; ++it) {
+            it->ext = classifyArgumentType(it->type, offset);
+            if (it->ext.isIndirect())
+                addAttrs(f->attrs, attrPos, llvm::Attributes::ByVal);
         }
     }
+};
 
-    llvm::Type *Mips32_ExternalTarget::getPaddingType(size_t align,
-                                                      size_t offset) const {
-        if (((align - 1) & offset) > 0) {
-            return llvmIntType(minABIAlign * 8);
-        }
+void Mips32_ExternalTarget::coerceToIntArgs(
+    size_t tySize, vector<llvm::Type *> &argList) const {
+    llvm::Type *intType = llvmIntType(minABIAlign * 8);
 
-        return nullptr;
+    for (unsigned n = tySize / (minABIAlign * 8); n > 0; --n) {
+        argList.push_back(intType);
     }
 
-    llvm::Type *Mips32_ExternalTarget::getLLVMWordType(TypePtr type,
-                                                       llvm::Type *padding,
-                                                       bool coercion) const {
-        size_t tySize = typeSize(type) * 8;
-        vector<llvm::Type *> argList;
+    unsigned r = tySize % (minABIAlign * 8);
 
-        if (padding) {
-            argList.push_back(padding);
-        }
-        if (coercion) {
-            coerceToIntArgs(tySize, argList);
-        } else {
-            argList.push_back(llvmType(type));
-        }
+    if (r > 0) {
+        argList.push_back(llvmIntType(r));
+    }
+}
 
-        llvm::StructType *llType = llvm::StructType::get(
-            llvmContext, argList);
+llvm::Type *Mips32_ExternalTarget::getPaddingType(size_t align,
+                                                  size_t offset) const {
+    if (((align - 1) & offset) > 0) {
+        return llvmIntType(minABIAlign * 8);
+    }
 
-        return llType;
+    return nullptr;
+}
+
+llvm::Type *Mips32_ExternalTarget::getLLVMWordType(TypePtr type,
+                                                   llvm::Type *padding,
+                                                   bool coercion) const {
+    size_t tySize = typeSize(type) * 8;
+    vector<llvm::Type *> argList;
+
+    if (padding) {
+        argList.push_back(padding);
     }
+    if (coercion) {
+        coerceToIntArgs(tySize, argList);
+    } else {
+        argList.push_back(llvmType(type));
+    }
+
+    llvm::StructType *llType = llvm::StructType::get(llvmContext, argList);
 
-    ExtArgInfo Mips32_ExternalTarget::classifyArgumentType(
-        TypePtr type, size_t &offset) {
-        size_t origOffset = offset;
-        size_t tySize = typeSize(type) * 8;
-        size_t align = typeAlignment(type);
+    return llType;
+}
 
-        align = std::min(std::max(align, minABIAlign), stackAlign);
-        offset = alignedUpTo(offset, align);
-        offset += alignedUpTo(tySize, align * 8) / 8;
+ExtArgInfo Mips32_ExternalTarget::classifyArgumentType(TypePtr type,
+                                                       size_t &offset) {
+    size_t origOffset = offset;
+    size_t tySize = typeSize(type) * 8;
+    size_t align = typeAlignment(type);
 
-        llvm::Type *padding = getPaddingType(align, origOffset);
-        llvm::Type *llType = nullptr;
+    align = std::min(std::max(align, minABIAlign), stackAlign);
+    offset = alignedUpTo(offset, align);
+    offset += alignedUpTo(tySize, align * 8) / 8;
 
-        if (!canPassThrough(type)) {
-            llType = getLLVMWordType(type, padding, true);
-        } else if (padding) {
-            llType = getLLVMWordType(type, padding, false);
-        }
+    llvm::Type *padding = getPaddingType(align, origOffset);
+    llvm::Type *llType = nullptr;
 
-        return ExtArgInfo::getDirect(llType);
+    if (!canPassThrough(type)) {
+        llType = getLLVMWordType(type, padding, true);
+    } else if (padding) {
+        llType = getLLVMWordType(type, padding, false);
     }
 
-    ExtArgInfo Mips32_ExternalTarget::classifyReturnType(TypePtr type) {
-        if (type == nullptr) return ExtArgInfo::getDirect();
+    return ExtArgInfo::getDirect(llType);
+}
 
-        size_t tySize = typeSize(type) * 8;
+ExtArgInfo Mips32_ExternalTarget::classifyReturnType(TypePtr type) {
+    if (type == nullptr)
+        return ExtArgInfo::getDirect();
 
-        if (!canPassThrough(type)) {
-            if (tySize <= 128) {
-                if (type->typeKind == COMPLEX_TYPE) {
-                    return ExtArgInfo::getDirect();
-                }
+    size_t tySize = typeSize(type) * 8;
 
-                if (type->typeKind == VEC_TYPE) {
-                    VecType *vecType = (VecType *) type.ptr();
-                    if (vecType->elementType->typeKind != FLOAT_TYPE) {
-                        return ExtArgInfo::getDirect(
-                            getLLVMWordType(type, nullptr, true));
-                    }
-                }
+    if (!canPassThrough(type)) {
+        if (tySize <= 128) {
+            if (type->typeKind == COMPLEX_TYPE) {
+                return ExtArgInfo::getDirect();
             }
 
-            return ExtArgInfo::getIndirect();
+            if (type->typeKind == VEC_TYPE) {
+                VecType *vecType = (VecType *)type.ptr();
+                if (vecType->elementType->typeKind != FLOAT_TYPE) {
+                    return ExtArgInfo::getDirect(
+                        getLLVMWordType(type, nullptr, true));
+                }
+            }
         }
 
-        return ExtArgInfo::getDirect();;
+        return ExtArgInfo::getIndirect();
     }
 
-    //
-    // getExternalTarget
-    //
-
-    static ExternalTargetPtr externalTarget;
-
-    void initExternalTarget(string targetString) {
-        llvm::Triple target(targetString);
-        if (target.getArch() == llvm::Triple::x86_64
-            && target.getOS() != llvm::Triple::Win32
-            && target.getOS() != llvm::Triple::MinGW32
-            && target.getOS() != llvm::Triple::Cygwin) {
-            externalTarget = new X86_64_ExternalTarget(target);
-        } else if (target.getArch() == llvm::Triple::x86
-                   || target.getArch() == llvm::Triple::x86_64) {
-            externalTarget = new X86_32_ExternalTarget(target);
-        } else if (target.getArch() == llvm::Triple::mips) {
-            externalTarget = new Mips32_ExternalTarget();
-        } else
-            externalTarget = new LLVMExternalTarget(target);
-    }
+    return ExtArgInfo::getDirect();
+    ;
+}
 
-    ExternalTargetPtr getExternalTarget() {
-        return externalTarget;
-    }
+//
+// getExternalTarget
+//
+
+static ExternalTargetPtr externalTarget;
+
+void initExternalTarget(string targetString) {
+    llvm::Triple target(targetString);
+    if (target.getArch() == llvm::Triple::x86_64 &&
+        target.getOS() != llvm::Triple::Win32 &&
+        target.getOS() != llvm::Triple::MinGW32 &&
+        target.getOS() != llvm::Triple::Cygwin) {
+        externalTarget = new X86_64_ExternalTarget(target);
+    } else if (target.getArch() == llvm::Triple::x86 ||
+               target.getArch() == llvm::Triple::x86_64) {
+        externalTarget = new X86_32_ExternalTarget(target);
+    } else if (target.getArch() == llvm::Triple::mips) {
+        externalTarget = new Mips32_ExternalTarget();
+    } else
+        externalTarget = new LLVMExternalTarget(target);
 }
+
+ExternalTargetPtr getExternalTarget() { return externalTarget; }
+} // namespace clay
diff --git a/compiler/externals.hpp b/compiler/externals.hpp
index b5f6f284..d286a5c7 100644
--- a/compiler/externals.hpp
+++ b/compiler/externals.hpp
@@ -6,139 +6,117 @@
 #include "codegen.hpp"
 
 namespace clay {
-    struct ExtArgInfo {
-        enum Kind {
-            Direct, Indirect
-        };
+struct ExtArgInfo {
+    enum Kind { Direct, Indirect };
 
-        Kind kind;
-        llvm::Type *type;
+    Kind kind;
+    llvm::Type *type;
 
-        ExtArgInfo(enum Kind k = Direct, llvm::Type *ll = nullptr)
-            : kind(k), type(ll) {
-        }
+    ExtArgInfo(enum Kind k = Direct, llvm::Type *ll = nullptr)
+        : kind(k), type(ll) {}
 
-        static ExtArgInfo getDirect(llvm::Type *ll = nullptr) {
-            return ExtArgInfo(Direct, ll);
-        }
+    static ExtArgInfo getDirect(llvm::Type *ll = nullptr) {
+        return ExtArgInfo(Direct, ll);
+    }
 
-        static ExtArgInfo getIndirect() {
-            return ExtArgInfo(Indirect, nullptr);
-        }
+    static ExtArgInfo getIndirect() { return ExtArgInfo(Indirect, nullptr); }
+
+    bool isDirect() const { return kind == Direct; }
+    bool isIndirect() const { return kind == Indirect; }
+};
 
-        bool isDirect() const { return kind == Direct; }
-        bool isIndirect() const { return kind == Indirect; }
+struct ExternalFunction : public llvm::FoldingSetNode {
+    struct ArgInfo {
+        TypePtr type;
+        ExtArgInfo ext;
     };
 
-    struct ExternalFunction : public llvm::FoldingSetNode {
-        struct ArgInfo {
-            TypePtr type;
-            ExtArgInfo ext;
-        };
-
-        CallingConv conv;
-        size_t numReqArg;
-        bool isVarArg;
-
-        llvm::CallingConv::ID llConv;
-        ArgInfo retInfo;
-        vector<ArgInfo> argInfos;
-        llvm::AttributeList attrs;
-
-        ExternalFunction(CallingConv conv, TypePtr ret,
-                         vector<TypePtr> &args, size_t numReqArg,
-                         bool isVarArg) {
-            this->conv = conv;
-            this->retInfo.type = ret;
-            for (vector<TypePtr>::iterator it = args.begin(), ie = args.end();
-                 it != ie; ++it) {
-                ArgInfo info = {*it, ExtArgInfo::getDirect()};
-                this->argInfos.push_back(info);
-            }
-            this->numReqArg = numReqArg;
-            this->isVarArg = isVarArg;
+    CallingConv conv;
+    size_t numReqArg;
+    bool isVarArg;
+
+    llvm::CallingConv::ID llConv;
+    ArgInfo retInfo;
+    vector<ArgInfo> argInfos;
+    llvm::AttributeList attrs;
+
+    ExternalFunction(CallingConv conv, TypePtr ret, vector<TypePtr> &args,
+                     size_t numReqArg, bool isVarArg) {
+        this->conv = conv;
+        this->retInfo.type = ret;
+        for (vector<TypePtr>::iterator it = args.begin(), ie = args.end();
+             it != ie; ++it) {
+            ArgInfo info = {*it, ExtArgInfo::getDirect()};
+            this->argInfos.push_back(info);
         }
-
-        static void Profile(llvm::FoldingSetNodeID &ID,
-                            CallingConv conv, TypePtr ret,
-                            vector<TypePtr> &args, size_t numReqArg,
-                            bool isVarArg) {
-            ID.AddInteger(conv);
-            ID.AddPointer(ret.ptr());
-            for (vector<TypePtr>::iterator it = args.begin(), ie = args.end();
-                 it != ie; ++it) {
-                ID.AddPointer(it->ptr());
-            }
-            ID.AddInteger(numReqArg);
-            ID.AddBoolean(isVarArg);
+        this->numReqArg = numReqArg;
+        this->isVarArg = isVarArg;
+    }
+
+    static void Profile(llvm::FoldingSetNodeID &ID, CallingConv conv,
+                        TypePtr ret, vector<TypePtr> &args, size_t numReqArg,
+                        bool isVarArg) {
+        ID.AddInteger(conv);
+        ID.AddPointer(ret.ptr());
+        for (vector<TypePtr>::iterator it = args.begin(), ie = args.end();
+             it != ie; ++it) {
+            ID.AddPointer(it->ptr());
         }
-
-        void Profile(llvm::FoldingSetNodeID &ID) {
-            ID.AddInteger(conv);
-            ID.AddPointer(retInfo.type.ptr());
-            for (vector<ArgInfo>::iterator
-                         it = argInfos.begin(), ie = argInfos.end();
-                 it != ie; ++it) {
-                ID.AddPointer(it->type.ptr());
-            }
-            ID.AddInteger(numReqArg);
-            ID.AddBoolean(isVarArg);
+        ID.AddInteger(numReqArg);
+        ID.AddBoolean(isVarArg);
+    }
+
+    void Profile(llvm::FoldingSetNodeID &ID) {
+        ID.AddInteger(conv);
+        ID.AddPointer(retInfo.type.ptr());
+        for (vector<ArgInfo>::iterator it = argInfos.begin(),
+                                       ie = argInfos.end();
+             it != ie; ++it) {
+            ID.AddPointer(it->type.ptr());
         }
+        ID.AddInteger(numReqArg);
+        ID.AddBoolean(isVarArg);
+    }
 
-        llvm::FunctionType *getLLVMFunctionType() const;
-
-        // for generating C function definitions
-        void allocReturnValue(ArgInfo info,
-                              llvm::Function::arg_iterator &ai,
-                              vector<CReturn> &returns,
-                              CodegenContext *ctx);
-
-        CValuePtr allocArgumentValue(ArgInfo info,
-                                     llvm::StringRef name,
-                                     llvm::Function::arg_iterator &ai,
-                                     CodegenContext *ctx);
-
-        void returnStatement(ArgInfo info,
-                             vector<CReturn> &returns,
-                             CodegenContext *ctx);
-
-        // for calling C functions
-        void loadStructRetArgument(ArgInfo info,
-                                   vector<llvm::Value *> &llArgs,
-                                   CodegenContext *ctx,
-                                   MultiCValuePtr out);
-
-        void loadArgument(ArgInfo info,
-                          CValuePtr cv,
-                          vector<llvm::Value *> &llArgs,
-                          CodegenContext *ctx,
-                          bool isVarArg);
-
-        void storeReturnValue(ArgInfo info,
-                              llvm::Value *callReturnValue,
-                              CodegenContext *ctx,
-                              MultiCValuePtr out);
-    };
+    llvm::FunctionType *getLLVMFunctionType() const;
 
-    struct ExternalTarget : public RefCounted {
-        llvm::FoldingSet<ExternalFunction> extFuncs;
+    // for generating C function definitions
+    void allocReturnValue(ArgInfo info, llvm::Function::arg_iterator &ai,
+                          vector<CReturn> &returns, CodegenContext *ctx);
 
-        ExternalTarget() {
-        }
+    CValuePtr allocArgumentValue(ArgInfo info, llvm::StringRef name,
+                                 llvm::Function::arg_iterator &ai,
+                                 CodegenContext *ctx);
 
-        virtual ~ExternalTarget() {
-        }
+    void returnStatement(ArgInfo info, vector<CReturn> &returns,
+                         CodegenContext *ctx);
 
-        ExternalFunction *getExternalFunction(
-            CallingConv conv,
-            TypePtr ret,
-            vector<TypePtr> &args,
-            size_t numReqArg, bool varArg);
+    // for calling C functions
+    void loadStructRetArgument(ArgInfo info, vector<llvm::Value *> &llArgs,
+                               CodegenContext *ctx, MultiCValuePtr out);
 
-        virtual void computeInfo(ExternalFunction *f) = 0;
-    };
+    void loadArgument(ArgInfo info, CValuePtr cv, vector<llvm::Value *> &llArgs,
+                      CodegenContext *ctx, bool isVarArg);
+
+    void storeReturnValue(ArgInfo info, llvm::Value *callReturnValue,
+                          CodegenContext *ctx, MultiCValuePtr out);
+};
+
+struct ExternalTarget : public RefCounted {
+    llvm::FoldingSet<ExternalFunction> extFuncs;
+
+    ExternalTarget() {}
+
+    virtual ~ExternalTarget() {}
+
+    ExternalFunction *getExternalFunction(CallingConv conv, TypePtr ret,
+                                          vector<TypePtr> &args,
+                                          size_t numReqArg, bool varArg);
+
+    virtual void computeInfo(ExternalFunction *f) = 0;
+};
 
-    typedef Pointer<ExternalTarget> ExternalTargetPtr;
+typedef Pointer<ExternalTarget> ExternalTargetPtr;
 
-    ExternalTargetPtr getExternalTarget();
-}
+ExternalTargetPtr getExternalTarget();
+} // namespace clay
diff --git a/compiler/hirestimer.cpp b/compiler/hirestimer.cpp
index fc8b05c3..c27d5d0b 100644
--- a/compiler/hirestimer.cpp
+++ b/compiler/hirestimer.cpp
@@ -7,30 +7,28 @@
 #include <mach/mach_time.h>
 
 namespace clay {
-    HiResTimer::HiResTimer()
-        : elapsedTicks(0), startTicks(0), running(0) {
-    }
+HiResTimer::HiResTimer() : elapsedTicks(0), startTicks(0), running(0) {}
 
-    void HiResTimer::start() {
-        if (++running == 1)
-            startTicks = mach_absolute_time();
-    }
+void HiResTimer::start() {
+    if (++running == 1)
+        startTicks = mach_absolute_time();
+}
 
-    void HiResTimer::stop() {
-        if (--running == 0) {
-            unsigned long long end = mach_absolute_time();
-            elapsedTicks += (end - startTicks);
-        }
+void HiResTimer::stop() {
+    if (--running == 0) {
+        unsigned long long end = mach_absolute_time();
+        elapsedTicks += (end - startTicks);
     }
+}
 
-    unsigned long long HiResTimer::elapsedNanos() {
-        static mach_timebase_info_data_t timeBaseInfo;
-        if (timeBaseInfo.denom == 0) {
-            mach_timebase_info(&timeBaseInfo);
-        }
-        return elapsedTicks * timeBaseInfo.numer / timeBaseInfo.denom;
+unsigned long long HiResTimer::elapsedNanos() {
+    static mach_timebase_info_data_t timeBaseInfo;
+    if (timeBaseInfo.denom == 0) {
+        mach_timebase_info(&timeBaseInfo);
     }
+    return elapsedTicks * timeBaseInfo.numer / timeBaseInfo.denom;
 }
+} // namespace clay
 
 #elif defined(_WIN32) || defined(_WIN64)
 
@@ -38,77 +36,72 @@ namespace clay {
 #include <windows.h>
 
 namespace clay {
-    HiResTimer::HiResTimer()
-        : elapsedTicks(0), running(0), startTicks(0) {
-    }
+HiResTimer::HiResTimer() : elapsedTicks(0), running(0), startTicks(0) {}
 
-    static unsigned long long _get_counter() {
-        LARGE_INTEGER counter;
-        BOOL status = QueryPerformanceCounter(&counter);
-        assert(status != 0);
+static unsigned long long _get_counter() {
+    LARGE_INTEGER counter;
+    BOOL status = QueryPerformanceCounter(&counter);
+    assert(status != 0);
 
-        return (unsigned long long) counter.QuadPart;
-    }
+    return (unsigned long long)counter.QuadPart;
+}
 
-    void HiResTimer::start() {
-        if (++running == 1)
-            startTicks = _get_counter();
-    }
+void HiResTimer::start() {
+    if (++running == 1)
+        startTicks = _get_counter();
+}
 
-    void HiResTimer::stop() {
-        if (--running == 0) {
-            unsigned long long end = _get_counter();
-            elapsedTicks += (end - startTicks);
-        }
+void HiResTimer::stop() {
+    if (--running == 0) {
+        unsigned long long end = _get_counter();
+        elapsedTicks += (end - startTicks);
     }
+}
 
-    unsigned long long HiResTimer::elapsedNanos() {
-        LARGE_INTEGER frequency;
-        BOOL status = QueryPerformanceFrequency(&frequency);
-        assert(status != 0);
+unsigned long long HiResTimer::elapsedNanos() {
+    LARGE_INTEGER frequency;
+    BOOL status = QueryPerformanceFrequency(&frequency);
+    assert(status != 0);
 
-        double performanceCounterRate = 1000000000.0 / (double) frequency.QuadPart;
+    double performanceCounterRate = 1000000000.0 / (double)frequency.QuadPart;
 
-        return (unsigned long long) ((double) elapsedTicks * performanceCounterRate);
-    }
+    return (unsigned long long)((double)elapsedTicks * performanceCounterRate);
 }
+} // namespace clay
 
 #else // Unixes
 
 #if defined(CLOCK_PROCESS_CPUTIME_ID) && defined(__linux__)
-#    define CLOCK CLOCK_PROCESS_CPUTIME_ID
+#define CLOCK CLOCK_PROCESS_CPUTIME_ID
 #elif defined(CLOCK_PROF) && defined(__FreeBSD__)
-#    define CLOCK CLOCK_PROF
+#define CLOCK CLOCK_PROF
 #else
-#    define CLOCK CLOCK_REALTIME
+#define CLOCK CLOCK_REALTIME
 #endif
 
 #include <time.h>
 
 namespace clay {
-    HiResTimer::HiResTimer()
-        : elapsedTicks(0), startTicks(0), running(0) {
-    }
+HiResTimer::HiResTimer() : elapsedTicks(0), startTicks(0), running(0) {}
 
-    void HiResTimer::start() {
-        if (++running == 1) {
-            struct timespec t;
-            clock_gettime(CLOCK, &t);
-            startTicks = (unsigned long long) (t.tv_sec * 1000000000 + t.tv_nsec);
-        }
-    }
-
-    void HiResTimer::stop() {
-        if (--running == 0) {
-            struct timespec t;
-            clock_gettime(CLOCK, &t);
-            elapsedTicks = (unsigned long long) (t.tv_sec * 1000000000 + t.tv_nsec) - startTicks;
-        }
+void HiResTimer::start() {
+    if (++running == 1) {
+        struct timespec t;
+        clock_gettime(CLOCK, &t);
+        startTicks = (unsigned long long)(t.tv_sec * 1000000000 + t.tv_nsec);
     }
+}
 
-    unsigned long long HiResTimer::elapsedNanos() {
-        return elapsedTicks;
+void HiResTimer::stop() {
+    if (--running == 0) {
+        struct timespec t;
+        clock_gettime(CLOCK, &t);
+        elapsedTicks = (unsigned long long)(t.tv_sec * 1000000000 + t.tv_nsec) -
+                       startTicks;
     }
 }
 
+unsigned long long HiResTimer::elapsedNanos() { return elapsedTicks; }
+} // namespace clay
+
 #endif // __APPLE__
diff --git a/compiler/hirestimer.hpp b/compiler/hirestimer.hpp
index 349881da..68ec8045 100644
--- a/compiler/hirestimer.hpp
+++ b/compiler/hirestimer.hpp
@@ -1,15 +1,15 @@
 #pragma once
 
 namespace clay {
-    struct HiResTimer {
-        unsigned long long elapsedTicks;
-        unsigned long long startTicks;
-        int running;
+struct HiResTimer {
+    unsigned long long elapsedTicks;
+    unsigned long long startTicks;
+    int running;
 
-        HiResTimer();
-        void start();
-        void stop();
-        unsigned long long elapsedNanos();
-        double elapsedMillis() { return (double) elapsedNanos() / (1000 * 1000); }
-    };
-}
+    HiResTimer();
+    void start();
+    void stop();
+    unsigned long long elapsedNanos();
+    double elapsedMillis() { return (double)elapsedNanos() / (1000 * 1000); }
+};
+} // namespace clay
diff --git a/compiler/html.cpp b/compiler/html.cpp
index df32e062..afbf9e27 100644
--- a/compiler/html.cpp
+++ b/compiler/html.cpp
@@ -1,7 +1,7 @@
 #include "claydoc.hpp"
+#include <errno.h>
 #include <fstream>
 #include <sstream>
-#include <errno.h>
 
 using namespace clay;
 using namespace std;
@@ -11,18 +11,24 @@ static void htmlEncode(std::string &data) {
     buffer.reserve(data.size());
     for (size_t pos = 0; pos != data.size(); ++pos) {
         switch (data[pos]) {
-            case '&': buffer.append("&amp;");
-                break;
-            case '\"': buffer.append("&quot;");
-                break;
-            case '\'': buffer.append("&apos;");
-                break;
-            case '<': buffer.append("&lt;");
-                break;
-            case '>': buffer.append("&gt;");
-                break;
-            default: buffer.append(1, data[pos]);
-                break;
+        case '&':
+            buffer.append("&amp;");
+            break;
+        case '\"':
+            buffer.append("&quot;");
+            break;
+        case '\'':
+            buffer.append("&apos;");
+            break;
+        case '<':
+            buffer.append("&lt;");
+            break;
+        case '>':
+            buffer.append("&gt;");
+            break;
+        default:
+            buffer.append(1, data[pos]);
+            break;
         }
     }
     data.swap(buffer);
@@ -40,8 +46,9 @@ static void emitInlineDoc(std::ostream &o, const std::string &str) {
     o << "</div>\n";
 }
 
-static void emitHtmlOverload(std::ostream &o, DocState *state, DocObject *item) {
-    clay::OverloadPtr overload = (clay::Overload *) item->item.ptr();
+static void emitHtmlOverload(std::ostream &o, DocState *state,
+                             DocObject *item) {
+    clay::OverloadPtr overload = (clay::Overload *)item->item.ptr();
     std::string htmlName(item->name);
     htmlEncode(htmlName);
     o << "<div class='overload'> <h3> ";
@@ -54,7 +61,8 @@ static void emitHtmlOverload(std::ostream &o, DocState *state, DocObject *item)
     }
 
     if (state->references[item->name])
-        o << "<a class='reference' href='" << state->references[item->name]->fqn << ".html#" << htmlName << "'> ";
+        o << "<a class='reference' href='" << state->references[item->name]->fqn
+          << ".html#" << htmlName << "'> ";
     else
         o << "<span class='brokenreference'>";
 
@@ -77,7 +85,8 @@ static void emitHtmlOverload(std::ostream &o, DocState *state, DocObject *item)
         if (!!arg->name) {
             std::string name = identifierString(arg->name);
             htmlEncode(name);
-            o << "    <span class='functionArgumentName' > " << name << "</span>";
+            o << "    <span class='functionArgumentName' > " << name
+              << "</span>";
         }
         if (!!arg->type) {
             std::string type = arg->type->asString();
@@ -95,14 +104,15 @@ static void emitHtmlOverload(std::ostream &o, DocState *state, DocObject *item)
     o << "</div>" << endl;
 }
 
-static void emitHtmlProcedure(std::ostream &o, DocState *state, DocObject *item) {
+static void emitHtmlProcedure(std::ostream &o, DocState *state,
+                              DocObject *item) {
     std::string htmlName(item->name);
     htmlEncode(htmlName);
     o << "<div class='definition'> "
-            << "<h3>"
-            << "<a name='" << htmlName << "'>"
-            << "<span class='keyword'> public </span>"
-            << "<span class='identifier'>" << htmlName << "</span>  </a> </h3>";
+      << "<h3>"
+      << "<a name='" << htmlName << "'>"
+      << "<span class='keyword'> public </span>"
+      << "<span class='identifier'>" << htmlName << "</span>  </a> </h3>";
     emitInlineDoc(o, item->description);
     o << "</div>" << endl;
 }
@@ -111,30 +121,30 @@ static void emitHtmlRecord(std::ostream &o, DocState *state, DocObject *item) {
     std::string htmlName(item->name);
     htmlEncode(htmlName);
     o << "<div class='record'> "
-            << "<h3>"
-            << "<a name='" << htmlName << "'>"
-            << "<span class='keyword'> record </span>"
-            << "<span class='identifier'>" << htmlName << "</span>  </a> </h3>";
+      << "<h3>"
+      << "<a name='" << htmlName << "'>"
+      << "<span class='keyword'> record </span>"
+      << "<span class='identifier'>" << htmlName << "</span>  </a> </h3>";
     emitInlineDoc(o, item->description);
     o << "</div>" << endl;
 }
 
 static void emitHtmlHeader(std::ostream &o, std::string title) {
     o << "<!doctype html>\n"
-            << "<html lang='en'>\n"
-            << "<head>\n"
-            << "<title>" << title << "</title>\n"
-            << "<link rel='stylesheet' href='style.css'>\n"
-            << "</head><body>"
-            << "<div id='navigation'><ul>\n"
-            << "  <li><a href='index.html'> Module Index </a> </li>\n"
-            << "</ul><div class='post-ul'></div></div> \n"
-            << "<div id='main'> \n";
+      << "<html lang='en'>\n"
+      << "<head>\n"
+      << "<title>" << title << "</title>\n"
+      << "<link rel='stylesheet' href='style.css'>\n"
+      << "</head><body>"
+      << "<div id='navigation'><ul>\n"
+      << "  <li><a href='index.html'> Module Index </a> </li>\n"
+      << "</ul><div class='post-ul'></div></div> \n"
+      << "<div id='main'> \n";
 }
 
 static void emitHtmlFooter(std::ostream &o) {
     o << "\n</div>\n"
-            << "\n</body>\n</html>\n";
+      << "\n</body>\n</html>\n";
 }
 
 void emitHtmlModule(std::string outpath, DocState *state, DocModule *mod) {
@@ -146,7 +156,8 @@ void emitHtmlModule(std::string outpath, DocState *state, DocModule *mod) {
         exit(errno);
     }
     emitHtmlHeader(o, mod->fqn);
-    o << "<div id='mainContentOuter'> <div id='mainContentHeader'>   \n<h1>" << mod->fqn << "</h1> \n";
+    o << "<div id='mainContentOuter'> <div id='mainContentHeader'>   \n<h1>"
+      << mod->fqn << "</h1> \n";
     emitInlineDoc(o, mod->description);
     o << "</div><div id='mainContentInner'>";
 
@@ -159,17 +170,17 @@ void emitHtmlModule(std::string outpath, DocState *state, DocModule *mod) {
         for (std::vector<DocObject *>::iterator i2 = (*it)->objects.begin();
              i2 != (*it)->objects.end(); i2++) {
             switch ((*i2)->item->objKind) {
-                case clay::PROCEDURE:
-                    emitHtmlProcedure(o, state, *i2);
-                    break;
-                case clay::RECORD_DECL:
-                    emitHtmlRecord(o, state, *i2);
-                    break;
-                case clay::OVERLOAD:
-                    emitHtmlOverload(o, state, *i2);
-                    break;
-                default: {
-                } // make compiler happy
+            case clay::PROCEDURE:
+                emitHtmlProcedure(o, state, *i2);
+                break;
+            case clay::RECORD_DECL:
+                emitHtmlRecord(o, state, *i2);
+                break;
+            case clay::OVERLOAD:
+                emitHtmlOverload(o, state, *i2);
+                break;
+            default: {
+            } // make compiler happy
             }
         }
         o << "</section>" << endl;
@@ -194,7 +205,8 @@ void emitHtmlIndex(std::string outpath, DocState *state) {
 
     char a = 0;
 
-    for (std::map<std::string, DocModule *>::iterator j = state->modules.begin();
+    for (std::map<std::string, DocModule *>::iterator j =
+             state->modules.begin();
          j != state->modules.end(); j++) {
         if (j->first.empty())
             continue;
@@ -203,11 +215,14 @@ void emitHtmlIndex(std::string outpath, DocState *state) {
             if (a != 0)
                 index << "</ul></section>";
             a = j->first.at(0);
-            index << "<section class='moduleIndexSection' ><h2 class='moduleIndexSectionHeader'>" << a << "</h2> <ul>";
+            index << "<section class='moduleIndexSection' ><h2 "
+                     "class='moduleIndexSectionHeader'>"
+                  << a << "</h2> <ul>";
         }
 
-        index << "<li class='moduleIndexItem'> <a href='" << string(j->first) + ".html" << "'> " << string(j->first) <<
-                " </a> </li>\n";
+        index << "<li class='moduleIndexItem'> <a href='"
+              << string(j->first) + ".html" << "'> " << string(j->first)
+              << " </a> </li>\n";
         emitHtmlModule(outpath, state, j->second);
     }
 
diff --git a/compiler/int128.hpp b/compiler/int128.hpp
index df3ee42d..40f73f97 100644
--- a/compiler/int128.hpp
+++ b/compiler/int128.hpp
@@ -9,151 +9,181 @@
 #if defined(__GNUC__) && defined(_INT128_DEFINED)
 
 namespace clay {
-    typedef __int128 clay_int128;
-    typedef unsigned __int128 clay_uint128;
-}
+typedef __int128 clay_int128;
+typedef unsigned __int128 clay_uint128;
+} // namespace clay
 
-//#elif (defined(__clang__))
-//typedef __int128_t clay_int128;
-//typedef __uint128_t clay_uint128;
+// #elif (defined(__clang__))
+// typedef __int128_t clay_int128;
+// typedef __uint128_t clay_uint128;
 
 #else
 
 namespace clay {
-    // fake it by doing 64-bit math in a 128-bit padded container
-    struct uint128_holder;
-
-    struct int128_holder {
-        ptrdiff64_t lowValue;
-        ptrdiff64_t highPad; // not used in static math
+// fake it by doing 64-bit math in a 128-bit padded container
+struct uint128_holder;
 
-        int128_holder() {
-        }
+struct int128_holder {
+    ptrdiff64_t lowValue;
+    ptrdiff64_t highPad; // not used in static math
 
-        explicit int128_holder(ptrdiff64_t low) : lowValue(low), highPad(low < 0 ? -1 : 0) {
-        }
+    int128_holder() : lowValue(0), highPad(0) {}
 
-        int128_holder(ptrdiff64_t low, ptrdiff64_t high)
-            : lowValue(low), highPad(high) {
-        }
+    explicit int128_holder(ptrdiff64_t low)
+        : lowValue(low), highPad(low < 0 ? -1 : 0) {}
 
-        explicit int128_holder(uint128_holder y);
+    int128_holder(ptrdiff64_t low, ptrdiff64_t high)
+        : lowValue(low), highPad(high) {}
 
-        int128_holder &operator=(ptrdiff64_t low) {
-            new((void *) this) int128_holder(low);
-            return *this;
-        }
+    explicit int128_holder(uint128_holder y);
 
-        int128_holder operator-() const { return int128_holder(-lowValue); }
-        int128_holder operator~() const { return int128_holder(~lowValue); }
+    int128_holder &operator=(ptrdiff64_t low) {
+        new ((void *)this) int128_holder(low);
+        return *this;
+    }
 
-        bool operator==(int128_holder y) const { return lowValue == y.lowValue; }
-        bool operator<(int128_holder y) const { return lowValue < y.lowValue; }
+    int128_holder operator-() const { return int128_holder(-lowValue); }
+    int128_holder operator~() const { return int128_holder(~lowValue); }
 
-        int128_holder operator+(int128_holder y) const { return int128_holder(lowValue + y.lowValue); }
-        int128_holder operator-(int128_holder y) const { return int128_holder(lowValue - y.lowValue); }
-        int128_holder operator*(int128_holder y) const { return int128_holder(lowValue * y.lowValue); }
-        int128_holder operator/(int128_holder y) const { return int128_holder(lowValue / y.lowValue); }
-        int128_holder operator%(int128_holder y) const { return int128_holder(lowValue % y.lowValue); }
-        int128_holder operator<<(int128_holder y) const { return int128_holder(lowValue << y.lowValue); }
-        int128_holder operator>>(int128_holder y) const { return int128_holder(lowValue >> y.lowValue); }
-        int128_holder operator&(int128_holder y) const { return int128_holder(lowValue & y.lowValue); }
-        int128_holder operator|(int128_holder y) const { return int128_holder(lowValue | y.lowValue); }
-        int128_holder operator^(int128_holder y) const { return int128_holder(lowValue ^ y.lowValue); }
+    bool operator==(int128_holder y) const { return lowValue == y.lowValue; }
+    bool operator<(int128_holder y) const { return lowValue < y.lowValue; }
 
-        operator ptrdiff64_t() const { return lowValue; }
+    int128_holder operator+(int128_holder y) const {
+        return int128_holder(lowValue + y.lowValue);
+    }
+    int128_holder operator-(int128_holder y) const {
+        return int128_holder(lowValue - y.lowValue);
+    }
+    int128_holder operator*(int128_holder y) const {
+        return int128_holder(lowValue * y.lowValue);
+    }
+    int128_holder operator/(int128_holder y) const {
+        return int128_holder(lowValue / y.lowValue);
+    }
+    int128_holder operator%(int128_holder y) const {
+        return int128_holder(lowValue % y.lowValue);
+    }
+    int128_holder operator<<(int128_holder y) const {
+        return int128_holder(lowValue << y.lowValue);
+    }
+    int128_holder operator>>(int128_holder y) const {
+        return int128_holder(lowValue >> y.lowValue);
+    }
+    int128_holder operator&(int128_holder y) const {
+        return int128_holder(lowValue & y.lowValue);
+    }
+    int128_holder operator|(int128_holder y) const {
+        return int128_holder(lowValue | y.lowValue);
+    }
+    int128_holder operator^(int128_holder y) const {
+        return int128_holder(lowValue ^ y.lowValue);
     }
-            CLAY_ALIGN(16);
 
-    struct uint128_holder {
-        size64_t lowValue;
-        size64_t highPad; // not used in static math
+    operator ptrdiff64_t() const { return lowValue; }
+} CLAY_ALIGN(16);
 
-        uint128_holder() {
-        }
+struct uint128_holder {
+    size64_t lowValue;
+    size64_t highPad; // not used in static math
 
-        explicit uint128_holder(size64_t low) : lowValue(low), highPad(0) {
-        }
+    uint128_holder() : lowValue(0), highPad(0) {}
 
-        uint128_holder(size64_t low, size64_t high) : lowValue(low), highPad(high) {
-        }
+    explicit uint128_holder(size64_t low) : lowValue(low), highPad(0) {}
 
-        explicit uint128_holder(int128_holder y) : lowValue((size64_t) y.lowValue), highPad((size64_t) y.highPad) {
-        }
+    uint128_holder(size64_t low, size64_t high)
+        : lowValue(low), highPad(high) {}
 
-        uint128_holder &operator=(size64_t low) {
-            new((void *) this) uint128_holder(low);
-            return *this;
-        }
+    explicit uint128_holder(int128_holder y)
+        : lowValue((size64_t)y.lowValue), highPad((size64_t)y.highPad) {}
 
-        uint128_holder operator-() const { return uint128_holder((size64_t) (-(ptrdiff64_t) lowValue)); }
-        uint128_holder operator~() const { return uint128_holder(~lowValue); }
+    uint128_holder &operator=(size64_t low) {
+        new ((void *)this) uint128_holder(low);
+        return *this;
+    }
 
-        bool operator==(uint128_holder y) const { return lowValue == y.lowValue; }
-        bool operator<(uint128_holder y) const { return lowValue < y.lowValue; }
+    uint128_holder operator-() const {
+        return uint128_holder((size64_t)(-(ptrdiff64_t)lowValue));
+    }
+    uint128_holder operator~() const { return uint128_holder(~lowValue); }
 
-        uint128_holder operator+(uint128_holder y) const { return uint128_holder(lowValue + y.lowValue); }
-        uint128_holder operator-(uint128_holder y) const { return uint128_holder(lowValue - y.lowValue); }
-        uint128_holder operator*(uint128_holder y) const { return uint128_holder(lowValue * y.lowValue); }
-        uint128_holder operator/(uint128_holder y) const { return uint128_holder(lowValue / y.lowValue); }
-        uint128_holder operator%(uint128_holder y) const { return uint128_holder(lowValue % y.lowValue); }
-        uint128_holder operator<<(uint128_holder y) const { return uint128_holder(lowValue << y.lowValue); }
-        uint128_holder operator>>(uint128_holder y) const { return uint128_holder(lowValue >> y.lowValue); }
-        uint128_holder operator&(uint128_holder y) const { return uint128_holder(lowValue & y.lowValue); }
-        uint128_holder operator|(uint128_holder y) const { return uint128_holder(lowValue | y.lowValue); }
-        uint128_holder operator^(uint128_holder y) const { return uint128_holder(lowValue ^ y.lowValue); }
+    bool operator==(uint128_holder y) const { return lowValue == y.lowValue; }
+    bool operator<(uint128_holder y) const { return lowValue < y.lowValue; }
 
-        operator size64_t() const { return lowValue; }
+    uint128_holder operator+(uint128_holder y) const {
+        return uint128_holder(lowValue + y.lowValue);
+    }
+    uint128_holder operator-(uint128_holder y) const {
+        return uint128_holder(lowValue - y.lowValue);
+    }
+    uint128_holder operator*(uint128_holder y) const {
+        return uint128_holder(lowValue * y.lowValue);
+    }
+    uint128_holder operator/(uint128_holder y) const {
+        return uint128_holder(lowValue / y.lowValue);
+    }
+    uint128_holder operator%(uint128_holder y) const {
+        return uint128_holder(lowValue % y.lowValue);
+    }
+    uint128_holder operator<<(uint128_holder y) const {
+        return uint128_holder(lowValue << y.lowValue);
+    }
+    uint128_holder operator>>(uint128_holder y) const {
+        return uint128_holder(lowValue >> y.lowValue);
+    }
+    uint128_holder operator&(uint128_holder y) const {
+        return uint128_holder(lowValue & y.lowValue);
+    }
+    uint128_holder operator|(uint128_holder y) const {
+        return uint128_holder(lowValue | y.lowValue);
+    }
+    uint128_holder operator^(uint128_holder y) const {
+        return uint128_holder(lowValue ^ y.lowValue);
     }
-            CLAY_ALIGN(16);
-}
+
+    operator size64_t() const { return lowValue; }
+} CLAY_ALIGN(16);
+} // namespace clay
 
 namespace std {
-    template<>
-    class numeric_limits<clay::int128_holder> {
-    public:
-        static clay::int128_holder min() throw() {
-            return clay::int128_holder(0, std::numeric_limits<clay::ptrdiff64_t>::min());
-        }
-
-        static clay::int128_holder max() throw() {
-            return clay::int128_holder(-1, std::numeric_limits<clay::ptrdiff64_t>::max());
-        }
-    };
-
-    template<>
-    class numeric_limits<clay::uint128_holder> {
-    public:
-        static clay::uint128_holder min() throw() {
-            return clay::uint128_holder(0, 0);
-        }
-
-        static clay::uint128_holder max() throw() {
-            return clay::uint128_holder(
-                std::numeric_limits<clay::size64_t>::max(),
-                std::numeric_limits<clay::size64_t>::max()
-            );
-        }
-    };
-}
+template <> struct numeric_limits<clay::int128_holder> {
+    static clay::int128_holder min() noexcept {
+        return {0, std::numeric_limits<clay::ptrdiff64_t>::min()};
+    }
 
-namespace clay {
-    inline int128_holder::int128_holder(uint128_holder y)
-        : lowValue((ptrdiff64_t) y.lowValue), highPad((ptrdiff64_t) y.highPad) {
+    static clay::int128_holder max() noexcept {
+        return {-1, std::numeric_limits<clay::ptrdiff64_t>::max()};
     }
+};
 
-    typedef int128_holder clay_int128;
-    typedef uint128_holder clay_uint128;
-}
+template <> struct numeric_limits<clay::uint128_holder> {
+    static clay::uint128_holder min() noexcept { return {0, 0}; }
+
+    static clay::uint128_holder max() noexcept {
+        return {std::numeric_limits<clay::size64_t>::max(),
+                std::numeric_limits<clay::size64_t>::max()};
+    }
+};
+} // namespace std
+
+namespace clay {
+inline int128_holder::int128_holder(uint128_holder y)
+    : lowValue(static_cast<ptrdiff64_t>(y.lowValue)),
+      highPad(static_cast<ptrdiff64_t>(y.highPad)) {}
+
+typedef int128_holder clay_int128;
+typedef uint128_holder clay_uint128;
+} // namespace clay
 
 #endif
 
 namespace clay {
-    inline llvm::raw_ostream &operator<<(llvm::raw_ostream &os, const clay_int128 &x) {
-        return os << ptrdiff64_t(x);
-    }
+inline llvm::raw_ostream &operator<<(llvm::raw_ostream &os,
+                                     const clay_int128 &x) {
+    return os << static_cast<ptrdiff64_t>(x);
+}
 
-    inline llvm::raw_ostream &operator<<(llvm::raw_ostream &os, const clay_uint128 &x) {
-        return os << size64_t(x);
-    }
+inline llvm::raw_ostream &operator<<(llvm::raw_ostream &os,
+                                     const clay_uint128 &x) {
+    return os << static_cast<size64_t>(x);
 }
+} // namespace clay
diff --git a/compiler/interactive.cpp b/compiler/interactive.cpp
index 9896819b..2a6ae958 100644
--- a/compiler/interactive.cpp
+++ b/compiler/interactive.cpp
@@ -1,343 +1,344 @@
 #include "clay.hpp"
-#include "lexer.hpp"
-#include "parser.hpp"
 #include "codegen.hpp"
+#include "env.hpp"
 #include "error.hpp"
-#include "loader.hpp"
 #include "invoketables.hpp"
-#include "env.hpp"
+#include "lexer.hpp"
+#include "loader.hpp"
+#include "parser.hpp"
 
 #include <csetjmp>
 #include <csignal>
 #include <cstdio>
 
 namespace clay {
-    typedef llvm::SmallString<16U> Str;
+typedef llvm::SmallString<16U> Str;
 
-    const char *replAnonymousFunctionName = "__replAnonymousFunction__";
+const char *replAnonymousFunctionName = "__replAnonymousFunction__";
 
-    static ModulePtr module;
-    static std::unique_ptr<llvm::orc::LLJIT> jit;
+static ModulePtr module;
+static std::unique_ptr<llvm::orc::LLJIT> jit;
 
-    jmp_buf recovery;
+jmp_buf recovery;
 
-    static bool printAST = false;
+static bool printAST = false;
 
-    static void eval(llvm::StringRef line);
+static void eval(llvm::StringRef line);
 
-    string newFunctionName() {
-        static int funNum = 0;
-        string buf;
-        llvm::raw_string_ostream funName(buf);
-        funName << replAnonymousFunctionName << funNum;
-        ++funNum;
-        return funName.str();
-    }
+string newFunctionName() {
+    static int funNum = 0;
+    string buf;
+    llvm::raw_string_ostream funName(buf);
+    funName << replAnonymousFunctionName << funNum;
+    ++funNum;
+    return funName.str();
+}
 
-    string stripSpaces(string const &s) {
-        size_t i;
-        for (i = 0; i < s.size(); ++i) {
-            if (!isSpace(s[i]))
-                break;
-        }
-        return s.substr(i, s.length());
+string stripSpaces(string const &s) {
+    size_t i;
+    for (i = 0; i < s.size(); ++i) {
+        if (!isSpace(s[i]))
+            break;
     }
+    return s.substr(i, s.length());
+}
 
-    static vector<Token> addTokens() {
-        char buf[255];
-        string line = fgets(buf, 255, stdin);
-        line = stripSpaces(line);
-        SourcePtr source = new Source(line, 0);
-        vector<Token> tokens;
-        tokenize(source, 0, line.length(), tokens);
-        return tokens;
-    }
+static vector<Token> addTokens() {
+    char buf[255];
+    string line = fgets(buf, 255, stdin);
+    line = stripSpaces(line);
+    SourcePtr source = new Source(line, 0);
+    vector<Token> tokens;
+    tokenize(source, 0, line.length(), tokens);
+    return tokens;
+}
 
-    static void cmdGlobals(const vector<Token> &tokens) {
-        ModulePtr m;
-        if (tokens.size() == 1) {
-            m = module;
-        } else if (tokens.size() == 2) {
-            m = globalModules[tokens[1].str];
-        } else {
-            llvm::errs() << ":globals [module name]\n";
-            return;
-        }
+static void cmdGlobals(const vector<Token> &tokens) {
+    ModulePtr m;
+    if (tokens.size() == 1) {
+        m = module;
+    } else if (tokens.size() == 2) {
+        m = globalModules[tokens[1].str];
+    } else {
+        llvm::errs() << ":globals [module name]\n";
+        return;
+    }
 
-        string buf;
-        llvm::raw_string_ostream code(buf);
+    string buf;
+    llvm::raw_string_ostream code(buf);
 
-        llvm::StringMap<ObjectPtr>::const_iterator g = m->globals.begin();
-        for (; g != m->globals.end(); ++g) {
-            if (g->second->objKind == GLOBAL_VARIABLE) {
-                IdentifierPtr name = ((GlobalVariable *) g->second.ptr())->name;
-                code << "println(\"" << name->str << " : \", "
-                        << "Type(" << name->str << "), \" : \", "
-                        << name->str << ");\n";
-            }
+    llvm::StringMap<ObjectPtr>::const_iterator g = m->globals.begin();
+    for (; g != m->globals.end(); ++g) {
+        if (g->second->objKind == GLOBAL_VARIABLE) {
+            IdentifierPtr name = ((GlobalVariable *)g->second.ptr())->name;
+            code << "println(\"" << name->str << " : \", "
+                 << "Type(" << name->str << "), \" : \", " << name->str
+                 << ");\n";
         }
-        code.flush();
-        eval(buf);
     }
+    code.flush();
+    eval(buf);
+}
 
-    static void cmdModules(const vector<Token> &tokens) {
-        if (tokens.size() != 1) {
-            llvm::errs() << "Warning: command parameters are ignored\n";
-        }
-        llvm::StringMap<ModulePtr>::const_iterator iter = globalModules.begin();
-        for (; iter != globalModules.end(); ++iter) {
-            llvm::errs() << iter->getKey() << "\n";
-        }
+static void cmdModules(const vector<Token> &tokens) {
+    if (tokens.size() != 1) {
+        llvm::errs() << "Warning: command parameters are ignored\n";
+    }
+    llvm::StringMap<ModulePtr>::const_iterator iter = globalModules.begin();
+    for (; iter != globalModules.end(); ++iter) {
+        llvm::errs() << iter->getKey() << "\n";
     }
+}
 
-    static void cmdOverloads(const vector<Token> &tokens) {
-        for (size_t i = 1; i < tokens.size(); ++i) {
-            if (tokens[i].tokenKind == T_IDENTIFIER) {
-                Str identStr = tokens[i].str;
+static void cmdOverloads(const vector<Token> &tokens) {
+    for (size_t i = 1; i < tokens.size(); ++i) {
+        if (tokens[i].tokenKind == T_IDENTIFIER) {
+            Str identStr = tokens[i].str;
 
-                ObjectPtr obj = lookupPrivate(module, Identifier::get(identStr));
-                if (obj == nullptr || obj->objKind != PROCEDURE) {
-                    llvm::errs() << identStr << " is not a procedure name\n";
-                    continue;
-                }
+            ObjectPtr obj = lookupPrivate(module, Identifier::get(identStr));
+            if (obj == nullptr || obj->objKind != PROCEDURE) {
+                llvm::errs() << identStr << " is not a procedure name\n";
+                continue;
+            }
 
-                vector<InvokeSet *> sets = lookupInvokeSets(obj.ptr());
-                for (size_t k = 0; k < sets.size(); ++k) {
-                    llvm::errs() << "        ";
-                    for (size_t l = 0; l < sets[k]->argsKey.size(); ++l) {
-                        llvm::errs() << sets[k]->argsKey[l]->toString() << " : ";
-                    }
-                    llvm::errs() << "\n";
+            vector<InvokeSet *> sets = lookupInvokeSets(obj.ptr());
+            for (size_t k = 0; k < sets.size(); ++k) {
+                llvm::errs() << "        ";
+                for (size_t l = 0; l < sets[k]->argsKey.size(); ++l) {
+                    llvm::errs() << sets[k]->argsKey[l]->toString() << " : ";
                 }
+                llvm::errs() << "\n";
             }
         }
     }
+}
 
-    static void cmdPrint(const vector<Token> &tokens) {
-        for (size_t i = 1; i < tokens.size(); ++i) {
-            if (tokens[i].tokenKind == T_IDENTIFIER) {
-                Str identifier = tokens[i].str;
-                llvm::StringMap<ImportSet>::const_iterator iter = module->allSymbols.find(identifier);
-                if (iter == module->allSymbols.end()) {
-                    llvm::errs() << "Can't find identifier " << identifier.c_str();
-                } else {
-                    for (size_t i = 0; i < iter->second.size(); ++i) {
-                        llvm::errs() << iter->second[i]->toString() << "\n";
-                    }
+static void cmdPrint(const vector<Token> &tokens) {
+    for (size_t i = 1; i < tokens.size(); ++i) {
+        if (tokens[i].tokenKind == T_IDENTIFIER) {
+            Str identifier = tokens[i].str;
+            llvm::StringMap<ImportSet>::const_iterator iter =
+                module->allSymbols.find(identifier);
+            if (iter == module->allSymbols.end()) {
+                llvm::errs() << "Can't find identifier " << identifier.c_str();
+            } else {
+                for (size_t i = 0; i < iter->second.size(); ++i) {
+                    llvm::errs() << iter->second[i]->toString() << "\n";
                 }
             }
         }
     }
+}
 
-    static void replCommand(string const &line) {
-        SourcePtr source = new Source(line, 0);
-        vector<Token> tokens;
-        //TODO: don't use compiler's tokenizer
-        tokenize(source, 0, line.length(), tokens);
-        Str cmd = tokens[0].str;
-        if (cmd == "q") {
-            exit(0);
-        } else if (cmd == "globals") {
-            cmdGlobals(tokens);
-        } else if (cmd == "modules") {
-            cmdModules(tokens);
-        } else if (cmd == "overloads") {
-            cmdOverloads(tokens);
-        } else if (cmd == "print") {
-            cmdPrint(tokens);
-        } else if (cmd == "ast_on") {
-            printAST = true;
-        } else if (cmd == "ast_off") {
-            printAST = false;
-        } else if (cmd == "rebuild") {
-            //TODO : this command should re-codegen everything
-        } else {
-            llvm::errs() << "Unknown interactive mode command: " << cmd.c_str() << "\n";
-        }
+static void replCommand(string const &line) {
+    SourcePtr source = new Source(line, 0);
+    vector<Token> tokens;
+    // TODO: don't use compiler's tokenizer
+    tokenize(source, 0, line.length(), tokens);
+    Str cmd = tokens[0].str;
+    if (cmd == "q") {
+        exit(0);
+    } else if (cmd == "globals") {
+        cmdGlobals(tokens);
+    } else if (cmd == "modules") {
+        cmdModules(tokens);
+    } else if (cmd == "overloads") {
+        cmdOverloads(tokens);
+    } else if (cmd == "print") {
+        cmdPrint(tokens);
+    } else if (cmd == "ast_on") {
+        printAST = true;
+    } else if (cmd == "ast_off") {
+        printAST = false;
+    } else if (cmd == "rebuild") {
+        // TODO : this command should re-codegen everything
+    } else {
+        llvm::errs() << "Unknown interactive mode command: " << cmd.c_str()
+                     << "\n";
     }
+}
 
-    static void loadImports(const llvm::ArrayRef<ImportPtr> imports) {
-        for (const auto & import : imports) {
-            module->imports.push_back(import);
-        }
-        for (const auto & import : imports) {
-            loadDependent(module, nullptr, import, false);
-        }
-        for (const auto & import : imports) {
-            initModule(import->module);
-        }
+static void loadImports(const llvm::ArrayRef<ImportPtr> imports) {
+    for (const auto &import : imports) {
+        module->imports.push_back(import);
+    }
+    for (const auto &import : imports) {
+        loadDependent(module, nullptr, import, false);
     }
+    for (const auto &import : imports) {
+        initModule(import->module);
+    }
+}
 
-    static void jitTopLevel(llvm::ArrayRef<TopLevelItemPtr> toplevels) {
-        if (toplevels.empty()) {
-            return;
-        }
-        if (printAST) {
-            for (size_t i = 0; i < toplevels.size(); ++i) {
-                llvm::errs() << i << ": " << toplevels[i]->toString() << "\n";
-            }
+static void jitTopLevel(llvm::ArrayRef<TopLevelItemPtr> toplevels) {
+    if (toplevels.empty()) {
+        return;
+    }
+    if (printAST) {
+        for (size_t i = 0; i < toplevels.size(); ++i) {
+            llvm::errs() << i << ": " << toplevels[i]->toString() << "\n";
         }
-        addGlobals(module, toplevels);
     }
+    addGlobals(module, toplevels);
+}
 
-    static void jitStatements(llvm::ArrayRef<StatementPtr> statements) {
-        if (statements.empty()) {
-            return;
-        }
+static void jitStatements(llvm::ArrayRef<StatementPtr> statements) {
+    if (statements.empty()) {
+        return;
+    }
 
-        if (printAST) {
-            for (const auto & statement : statements) {
-                llvm::errs() << statement->toString() << "\n";
-            }
+    if (printAST) {
+        for (const auto &statement : statements) {
+            llvm::errs() << statement->toString() << "\n";
         }
+    }
 
-        IdentifierPtr fun = Identifier::get(newFunctionName());
-
-        BlockPtr funBody = new Block(statements);
-        ExternalProcedurePtr entryProc =
-                new ExternalProcedure(nullptr,
-                                      fun,
-                                      PRIVATE,
-                                      vector<ExternalArgPtr>(),
-                                      false,
-                                      nullptr,
-                                      funBody.ptr(),
-                                      new ExprList());
-
-        entryProc->env = module->env;
-
-        codegenBeforeRepl(module);
-        try {
-            codegenExternalProcedure(entryProc, true);
-        } catch (std::exception) {
-            return;
-        }
+    IdentifierPtr fun = Identifier::get(newFunctionName());
 
-        llvm::Function *ctor;
-        llvm::Function *dtor;
-        codegenAfterRepl(ctor, dtor);
+    BlockPtr funBody = new Block(statements);
+    ExternalProcedurePtr entryProc =
+        new ExternalProcedure(nullptr, fun, PRIVATE, vector<ExternalArgPtr>(),
+                              false, nullptr, funBody.ptr(), new ExprList());
 
-        // hacky voodoo raw memory address returned by LLJIT symbol lookup
-        // https://llvm.org/docs/ORCv2.html
-        using CtorPtr = void (*)();
-        using PFN = void (*)();
+    entryProc->env = module->env;
 
-        auto ctorAddExpected = jit->lookup(ctor->getName());
-        if (!ctorAddExpected) {
-            llvm::errs() << "error: cannot look up constructor: " << llvm::toString(ctorAddExpected.takeError()) << "\n";
-            return;
-        }
-        CtorPtr ctorFunc = reinterpret_cast<CtorPtr>(ctorAddExpected->getValue());
-        ctorFunc();
+    codegenBeforeRepl(module);
+    try {
+        codegenExternalProcedure(entryProc, true);
+    } catch (std::exception) {
+        return;
+    }
 
-        auto dtorAddExpected = jit->lookup(dtor->getName());
-        if (!dtorAddExpected) {
-            llvm::errs() << "error: cannot look up destructor: " << llvm::toString(dtorAddExpected.takeError()) << "\n";
-            return;
-        }
-        void *dtorLlvmFun = reinterpret_cast<void *>(dtorAddExpected->getValue());
-        atexit((PFN) (uintptr_t) dtorLlvmFun);
+    llvm::Function *ctor;
+    llvm::Function *dtor;
+    codegenAfterRepl(ctor, dtor);
 
-        auto entryAddrExpected = jit->lookup(entryProc->llvmFunc->getName());
-        if (!entryAddrExpected) {
-            llvm::errs() << "error: cannot look up entry function: " << llvm::toString(entryAddrExpected.takeError()) << "\n";
-            return;
-        }
-        PFN entryFunc = reinterpret_cast<PFN>(entryAddrExpected->getValue());
-        entryFunc();
-    }
+    // hacky voodoo raw memory address returned by LLJIT symbol lookup
+    // https://llvm.org/docs/ORCv2.html
+    using CtorPtr = void (*)();
+    using PFN = void (*)();
 
-    static void jitAndPrintExpr(ExprPtr expr) {
-        //expr -> println(expr);
-        NameRefPtr println = new NameRef(Identifier::get("println"));
-        ExprPtr call = new Call(println.ptr(), new ExprList(expr));
-        ExprStatementPtr callStmt = new ExprStatement(call);
-        jitStatements(vector<StatementPtr>(1, callStmt.ptr()));
+    auto ctorAddExpected = jit->lookup(ctor->getName());
+    if (!ctorAddExpected) {
+        llvm::errs() << "error: cannot look up constructor: "
+                     << llvm::toString(ctorAddExpected.takeError()) << "\n";
+        return;
+    }
+    CtorPtr ctorFunc = reinterpret_cast<CtorPtr>(ctorAddExpected->getValue());
+    ctorFunc();
+
+    auto dtorAddExpected = jit->lookup(dtor->getName());
+    if (!dtorAddExpected) {
+        llvm::errs() << "error: cannot look up destructor: "
+                     << llvm::toString(dtorAddExpected.takeError()) << "\n";
+        return;
     }
+    void *dtorLlvmFun = reinterpret_cast<void *>(dtorAddExpected->getValue());
+    atexit((PFN)(uintptr_t)dtorLlvmFun);
+
+    auto entryAddrExpected = jit->lookup(entryProc->llvmFunc->getName());
+    if (!entryAddrExpected) {
+        llvm::errs() << "error: cannot look up entry function: "
+                     << llvm::toString(entryAddrExpected.takeError()) << "\n";
+        return;
+    }
+    PFN entryFunc = reinterpret_cast<PFN>(entryAddrExpected->getValue());
+    entryFunc();
+}
 
-    static void eval(llvm::StringRef line) {
-        SourcePtr source = new Source(line, 0);
-        try {
-            ReplItem x = parseInteractive(source, 0, source->size());
-            if (x.isExprSet) {
-                jitAndPrintExpr(x.expr);
-            } else {
-                loadImports(x.imports);
-                jitTopLevel(x.toplevels);
-                jitStatements(x.stmts);
-            }
-        } catch (CompilerError) {
-            return;
+static void jitAndPrintExpr(ExprPtr expr) {
+    // expr -> println(expr);
+    NameRefPtr println = new NameRef(Identifier::get("println"));
+    ExprPtr call = new Call(println.ptr(), new ExprList(expr));
+    ExprStatementPtr callStmt = new ExprStatement(call);
+    jitStatements(vector<StatementPtr>(1, callStmt.ptr()));
+}
+
+static void eval(llvm::StringRef line) {
+    SourcePtr source = new Source(line, 0);
+    try {
+        ReplItem x = parseInteractive(source, 0, source->size());
+        if (x.isExprSet) {
+            jitAndPrintExpr(x.expr);
+        } else {
+            loadImports(x.imports);
+            jitTopLevel(x.toplevels);
+            jitStatements(x.stmts);
         }
+    } catch (CompilerError) {
+        return;
     }
+}
 
-    [[noreturn]] static void interactiveLoop() {
-        setjmp(recovery);
-        while (true) {
-            llvm::errs().flush();
-            llvm::errs() << "clay>";
-            char buf[255];
-            string line = fgets(buf, 255, stdin);
-            line = stripSpaces(line);
-            if (line[0] == ':') {
-                replCommand(line.substr(1, line.size() - 1));
-            } else {
-                eval(line);
-            }
+[[noreturn]] static void interactiveLoop() {
+    setjmp(recovery);
+    while (true) {
+        llvm::errs().flush();
+        llvm::errs() << "clay>";
+        char buf[255];
+        string line = fgets(buf, 255, stdin);
+        line = stripSpaces(line);
+        if (line[0] == ':') {
+            replCommand(line.substr(1, line.size() - 1));
+        } else {
+            eval(line);
         }
     }
+}
 
-    static void exceptionHandler(int i) {
-        llvm::errs() << "SIGABRT called\n";
-        longjmp(recovery, 1);
-    }
+static void exceptionHandler(int i) {
+    llvm::errs() << "SIGABRT called\n";
+    longjmp(recovery, 1);
+}
 
-    void runInteractive(llvm::Module *llvmModule_, ModulePtr module_) {
-        signal(SIGABRT, exceptionHandler);
-
-        llvmModule = llvmModule_;
-        module = module_;
-        llvm::errs() << "Clay interpreter\n";
-        llvm::errs() << ":q to exit\n";
-        llvm::errs() << ":print {identifier} to print an identifier\n";
-        llvm::errs() << ":modules to list global modules\n";
-        llvm::errs() << ":globals to list globals\n";
-        llvm::errs() << "In multi-line mode empty line to exit\n";
-
-        auto expectedJIT = llvm::orc::LLJITBuilder().create();
-        if (!expectedJIT) {
-            llvm::errs() << "error: could not create JIT: " << llvm::toString(expectedJIT.takeError()) << "\n";
-            return;
-        }
-        jit = std::move(*expectedJIT);
+void runInteractive(llvm::Module *llvmModule_, ModulePtr module_) {
+    signal(SIGABRT, exceptionHandler);
+
+    llvmModule = llvmModule_;
+    module = module_;
+    llvm::errs() << "Clay interpreter\n";
+    llvm::errs() << ":q to exit\n";
+    llvm::errs() << ":print {identifier} to print an identifier\n";
+    llvm::errs() << ":modules to list global modules\n";
+    llvm::errs() << ":globals to list globals\n";
+    llvm::errs() << "In multi-line mode empty line to exit\n";
+
+    auto expectedJIT = llvm::orc::LLJITBuilder().create();
+    if (!expectedJIT) {
+        llvm::errs() << "error: could not create JIT: "
+                     << llvm::toString(expectedJIT.takeError()) << "\n";
+        return;
+    }
+    jit = std::move(*expectedJIT);
 
-        llvm::orc::JITDylib& mainDylib = jit->getMainJITDylib();
+    llvm::orc::JITDylib &mainDylib = jit->getMainJITDylib();
 
-        auto generatorExpected = llvm::orc::DynamicLibrarySearchGenerator::GetForCurrentProcess(
-            jit->getDataLayout().getGlobalPrefix()
-        );
+    auto generatorExpected =
+        llvm::orc::DynamicLibrarySearchGenerator::GetForCurrentProcess(
+            jit->getDataLayout().getGlobalPrefix());
 
-        if (!generatorExpected) {
-            llvm::errs() << "error: setting up symbol" << llvm::toString(generatorExpected.takeError()) << "\n";
-        } else {
-            std::unique_ptr<llvm::orc::DynamicLibrarySearchGenerator> generator =
-                std::move(*generatorExpected);
-            mainDylib.addGenerator(std::move(generator));
-        }
+    if (!generatorExpected) {
+        llvm::errs() << "error: setting up symbol"
+                     << llvm::toString(generatorExpected.takeError()) << "\n";
+    } else {
+        std::unique_ptr<llvm::orc::DynamicLibrarySearchGenerator> generator =
+            std::move(*generatorExpected);
+        mainDylib.addGenerator(std::move(generator));
+    }
 
-        llvmModule->setDataLayout(jit->getDataLayout());
+    llvmModule->setDataLayout(jit->getDataLayout());
 
-        auto tsm = llvm::orc::ThreadSafeModule(
-            std::unique_ptr<llvm::Module>(llvmModule),
-            std::make_unique<llvm::LLVMContext>());
+    auto tsm =
+        llvm::orc::ThreadSafeModule(std::unique_ptr<llvm::Module>(llvmModule),
+                                    std::make_unique<llvm::LLVMContext>());
 
-        if (llvm::Error addIRErr = jit->addIRModule(std::move(tsm))) {
-            llvm::errs() << "error: " << addIRErr << "\n";
-            return;
-        }
+    if (llvm::Error addIRErr = jit->addIRModule(std::move(tsm))) {
+        llvm::errs() << "error: " << addIRErr << "\n";
+        return;
+    }
 
-        setAddTokens(&addTokens);
+    setAddTokens(&addTokens);
 
-        interactiveLoop();
-    }
+    interactiveLoop();
 }
+} // namespace clay
diff --git a/compiler/invoketables.cpp b/compiler/invoketables.cpp
index b8c6789b..697bcfad 100644
--- a/compiler/invoketables.cpp
+++ b/compiler/invoketables.cpp
@@ -1,428 +1,413 @@
-#include "clay.hpp"
-#include "loader.hpp"
-#include "error.hpp"
 #include "invoketables.hpp"
-#include "constructors.hpp"
+#include "clay.hpp"
 #include "clone.hpp"
+#include "constructors.hpp"
+#include "error.hpp"
+#include "loader.hpp"
 #include "objects.hpp"
 
 #pragma clang diagnostic ignored "-Wcovered-switch-default"
 
 namespace clay {
-    static bool _finalOverloadsEnabled = false;
+static bool _finalOverloadsEnabled = false;
+
+void setFinalOverloadsEnabled(bool enabled) {
+    _finalOverloadsEnabled = enabled;
+}
 
-    void setFinalOverloadsEnabled(bool enabled) {
-        _finalOverloadsEnabled = enabled;
+//
+// callableOverloads
+//
+
+static void initCallable(ObjectPtr x) {
+    switch (x->objKind) {
+    case TYPE:
+        break;
+    case RECORD_DECL: {
+        RecordDecl *y = (RecordDecl *)x.ptr();
+        if (!y->builtinOverloadInitialized)
+            initBuiltinConstructor(y);
+        break;
     }
-    
-    //
-    // callableOverloads
-    //
-
-    static void initCallable(ObjectPtr x) {
-        switch (x->objKind) {
-            case TYPE:
-                break;
-            case RECORD_DECL: {
-                RecordDecl *y = (RecordDecl *) x.ptr();
-                if (!y->builtinOverloadInitialized)
-                    initBuiltinConstructor(y);
-                break;
-            }
-            case VARIANT_DECL:
-            case PROCEDURE:
-            case GLOBAL_ALIAS:
-                break;
-            case PRIM_OP: {
-                assert(isOverloadablePrimOp(x));
-                break;
-            }
-            default:
-                assert(false);
-        }
+    case VARIANT_DECL:
+    case PROCEDURE:
+    case GLOBAL_ALIAS:
+        break;
+    case PRIM_OP: {
+        assert(isOverloadablePrimOp(x));
+        break;
+    }
+    default:
+        assert(false);
     }
+}
 
-    const OverloadPtr callableInterface(ObjectPtr x) {
-        switch (x->objKind) {
-            case PROCEDURE: {
-                Procedure *y = (Procedure *) x.ptr();
-                return y->interface;
-            }
-            default: {
-                return nullptr;
-            }
-        }
+const OverloadPtr callableInterface(ObjectPtr x) {
+    switch (x->objKind) {
+    case PROCEDURE: {
+        Procedure *y = (Procedure *)x.ptr();
+        return y->interface;
+    }
+    default: {
+        return nullptr;
     }
+    }
+}
 
-    static llvm::ArrayRef<OverloadPtr> callableOverloads(ObjectPtr x) {
-        initCallable(x);
-        switch (x->objKind) {
-            case TYPE: {
-                Type *y = (Type *) x.ptr();
-                return y->overloads;
-            }
-            case RECORD_DECL: {
-                RecordDecl *y = (RecordDecl *) x.ptr();
-                return y->overloads;
-            }
-            case VARIANT_DECL: {
-                VariantDecl *y = (VariantDecl *) x.ptr();
-                return y->overloads;
-            }
-            case PROCEDURE: {
-                Procedure *y = (Procedure *) x.ptr();
-                return y->overloads;
-            }
-            case PRIM_OP: {
-                assert(isOverloadablePrimOp(x));
-                PrimOp *y = (PrimOp *) x.ptr();
-                return primOpOverloads(y);
-            }
-            case GLOBAL_ALIAS: {
-                GlobalAlias *a = (GlobalAlias *) x.ptr();
-                assert(a->hasParams());
-                return a->overloads;
-            }
-            default: {
-                assert(false);
-                const vector<OverloadPtr> *ptr = nullptr;
-                return *ptr;
-            }
-        }
+static llvm::ArrayRef<OverloadPtr> callableOverloads(ObjectPtr x) {
+    initCallable(x);
+    switch (x->objKind) {
+    case TYPE: {
+        Type *y = (Type *)x.ptr();
+        return y->overloads;
+    }
+    case RECORD_DECL: {
+        RecordDecl *y = (RecordDecl *)x.ptr();
+        return y->overloads;
+    }
+    case VARIANT_DECL: {
+        VariantDecl *y = (VariantDecl *)x.ptr();
+        return y->overloads;
     }
+    case PROCEDURE: {
+        Procedure *y = (Procedure *)x.ptr();
+        return y->overloads;
+    }
+    case PRIM_OP: {
+        assert(isOverloadablePrimOp(x));
+        PrimOp *y = (PrimOp *)x.ptr();
+        return primOpOverloads(y);
+    }
+    case GLOBAL_ALIAS: {
+        GlobalAlias *a = (GlobalAlias *)x.ptr();
+        assert(a->hasParams());
+        return a->overloads;
+    }
+    default: {
+        assert(false);
+        const vector<OverloadPtr> *ptr = nullptr;
+        return *ptr;
+    }
+    }
+}
 
-    //
-    // invoke tables
-    //
+//
+// invoke tables
+//
 
-    static bool invokeTablesInitialized = false;
-    static const size_t INVOKE_TABLE_SIZE = 16384;
+static bool invokeTablesInitialized = false;
+static constexpr size_t INVOKE_TABLE_SIZE = 16384;
 
-    static vector<llvm::SmallVector<InvokeSet *, 2> > invokeTable;
+static vector<llvm::SmallVector<InvokeSet *, 2>> invokeTable;
 
-    static void initInvokeTables() {
-        assert(!invokeTablesInitialized);
-        invokeTable.resize(INVOKE_TABLE_SIZE);
-        invokeTablesInitialized = true;
-    }
+static void initInvokeTables() {
+    assert(!invokeTablesInitialized);
+    invokeTable.resize(INVOKE_TABLE_SIZE);
+    invokeTablesInitialized = true;
+}
 
-    //
-    // lookupInvokeSet
-    //
+//
+// lookupInvokeSet
+//
 
-    static bool shouldLogCallable(ObjectPtr callable) {
-        if (logMatchSymbols.empty())
-            return false;
+static bool shouldLogCallable(ObjectPtr callable) {
+    if (logMatchSymbols.empty())
+        return false;
 
-        ModulePtr m = staticModule(callable);
-        if (!m)
-            return false;
+    ModulePtr m = staticModule(callable);
+    if (!m)
+        return false;
 
-        string name;
-        llvm::raw_string_ostream sout(name);
-        printStaticName(sout, callable);
+    string name;
+    llvm::raw_string_ostream sout(name);
+    printStaticName(sout, callable);
 
-        pair<string, string> specificKey = make_pair(m->moduleName, name);
-        pair<string, string> moduleGlobKey = make_pair(m->moduleName, string("*"));
-        pair<string, string> anyModuleKey = make_pair(string("*"), name);
-        return logMatchSymbols.find(specificKey) != logMatchSymbols.end()
-               || logMatchSymbols.find(moduleGlobKey) != logMatchSymbols.end()
-               || logMatchSymbols.find(anyModuleKey) != logMatchSymbols.end();
-    }
+    pair<string, string> specificKey = make_pair(m->moduleName, name);
+    pair<string, string> moduleGlobKey = make_pair(m->moduleName, string("*"));
+    pair<string, string> anyModuleKey = make_pair(string("*"), name);
+    return logMatchSymbols.find(specificKey) != logMatchSymbols.end() ||
+           logMatchSymbols.find(moduleGlobKey) != logMatchSymbols.end() ||
+           logMatchSymbols.find(anyModuleKey) != logMatchSymbols.end();
+}
 
-    InvokeSet *lookupInvokeSet(ObjectPtr callable,
-                               llvm::ArrayRef<TypePtr> argsKey) {
-        if (!invokeTablesInitialized)
-            initInvokeTables();
-        unsigned h = objectHash(callable) + objectVectorHash(argsKey);
-        h &= unsigned(invokeTable.size() - 1);
-        llvm::SmallVector<InvokeSet *, 2> &bucket = invokeTable[h];
-        for (unsigned i = 0; i < bucket.size(); ++i) {
-            InvokeSet *invokeSet = bucket[i];
-            if (objectEquals(invokeSet->callable, callable) &&
-                objectVectorEquals(invokeSet->argsKey, argsKey)) {
-                return invokeSet;
-            }
+InvokeSet *lookupInvokeSet(ObjectPtr callable,
+                           llvm::ArrayRef<TypePtr> argsKey) {
+    if (!invokeTablesInitialized)
+        initInvokeTables();
+    unsigned h = objectHash(callable) + objectVectorHash(argsKey);
+    h &= unsigned(invokeTable.size() - 1);
+    llvm::SmallVector<InvokeSet *, 2> &bucket = invokeTable[h];
+    for (unsigned i = 0; i < bucket.size(); ++i) {
+        InvokeSet *invokeSet = bucket[i];
+        if (objectEquals(invokeSet->callable, callable) &&
+            objectVectorEquals(invokeSet->argsKey, argsKey)) {
+            return invokeSet;
         }
-        OverloadPtr interface = callableInterface(callable);
-        llvm::ArrayRef<OverloadPtr> overloads = callableOverloads(callable);
-        InvokeSet *invokeSet = new InvokeSet(callable, argsKey, interface, overloads);
-        invokeSet->shouldLog = shouldLogCallable(callable);
-
-        bucket.push_back(invokeSet);
-        return invokeSet;
     }
+    OverloadPtr interface = callableInterface(callable);
+    llvm::ArrayRef<OverloadPtr> overloads = callableOverloads(callable);
+    InvokeSet *invokeSet =
+        new InvokeSet(callable, argsKey, interface, overloads);
+    invokeSet->shouldLog = shouldLogCallable(callable);
+
+    bucket.push_back(invokeSet);
+    return invokeSet;
+}
 
-    vector<InvokeSet *> lookupInvokeSets(ObjectPtr callable) {
-        assert(invokeTablesInitialized);
-        vector<InvokeSet *> r;
-        for (unsigned i = 0; i < invokeTable.size(); ++i) {
-            for (unsigned j = 0; j < invokeTable[i].size(); ++j) {
-                InvokeSet *set = invokeTable[i][j];
-                if (objectEquals(set->callable, callable)) {
-                    r.push_back(set);
-                }
+vector<InvokeSet *> lookupInvokeSets(ObjectPtr callable) {
+    assert(invokeTablesInitialized);
+    vector<InvokeSet *> r;
+    for (unsigned i = 0; i < invokeTable.size(); ++i) {
+        for (unsigned j = 0; j < invokeTable[i].size(); ++j) {
+            InvokeSet *set = invokeTable[i][j];
+            if (objectEquals(set->callable, callable)) {
+                r.push_back(set);
             }
         }
-        return r;
     }
+    return r;
+}
 
-    //
-    // lookupInvokeEntry
-    //
-
-    static
-    MatchSuccessPtr findMatchingInvoke(llvm::ArrayRef<OverloadPtr> overloads,
-                                       unsigned &overloadIndex,
-                                       ObjectPtr callable,
-                                       llvm::ArrayRef<TypePtr> argsKey,
-                                       MatchFailureError &failures) {
-        while (overloadIndex < overloads.size()) {
-            OverloadPtr x = overloads[overloadIndex++];
-            MatchResultPtr result = matchInvoke(x, callable, argsKey);
-            failures.failures.push_back(make_pair(x, result));
-            if (result->matchCode == MATCH_SUCCESS) {
-                MatchSuccess *y = (MatchSuccess *) result.ptr();
-                return y;
-            }
+//
+// lookupInvokeEntry
+//
+
+static MatchSuccessPtr findMatchingInvoke(llvm::ArrayRef<OverloadPtr> overloads,
+                                          unsigned &overloadIndex,
+                                          ObjectPtr callable,
+                                          llvm::ArrayRef<TypePtr> argsKey,
+                                          MatchFailureError &failures) {
+    while (overloadIndex < overloads.size()) {
+        OverloadPtr x = overloads[overloadIndex++];
+        MatchResultPtr result = matchInvoke(x, callable, argsKey);
+        failures.failures.push_back(make_pair(x, result));
+        if (result->matchCode == MATCH_SUCCESS) {
+            MatchSuccess *y = (MatchSuccess *)result.ptr();
+            return y;
         }
-        return nullptr;
     }
+    return nullptr;
+}
 
-    static MatchSuccessPtr getMatch(InvokeSet *invokeSet,
-                                    unsigned entryIndex,
-                                    MatchFailureError &failures) {
-        if (entryIndex < invokeSet->matches.size())
-            return invokeSet->matches[entryIndex];
-        assert(entryIndex == invokeSet->matches.size());
-
-        unsigned nextOverloadIndex = invokeSet->nextOverloadIndex;
-        MatchSuccessPtr match = findMatchingInvoke(invokeSet->overloads,
-                                                   nextOverloadIndex,
-                                                   invokeSet->callable,
-                                                   invokeSet->argsKey,
-                                                   failures);
-        if (!match)
-            return nullptr;
-        invokeSet->matches.push_back(match);
-        invokeSet->nextOverloadIndex = nextOverloadIndex;
-        return match;
-    }
+static MatchSuccessPtr getMatch(InvokeSet *invokeSet, unsigned entryIndex,
+                                MatchFailureError &failures) {
+    if (entryIndex < invokeSet->matches.size())
+        return invokeSet->matches[entryIndex];
+    assert(entryIndex == invokeSet->matches.size());
+
+    unsigned nextOverloadIndex = invokeSet->nextOverloadIndex;
+    MatchSuccessPtr match =
+        findMatchingInvoke(invokeSet->overloads, nextOverloadIndex,
+                           invokeSet->callable, invokeSet->argsKey, failures);
+    if (!match)
+        return nullptr;
+    invokeSet->matches.push_back(match);
+    invokeSet->nextOverloadIndex = nextOverloadIndex;
+    return match;
+}
 
-    static bool tempnessMatches(bool rvalue,
-                                ValueTempness formalTempness) {
-        if (!rvalue) {
-            return ((formalTempness == TEMPNESS_DONTCARE) ||
-                    (formalTempness == TEMPNESS_LVALUE) ||
-                    (formalTempness == TEMPNESS_FORWARD));
-        } else {
-            return ((formalTempness == TEMPNESS_DONTCARE) ||
-                    (formalTempness == TEMPNESS_RVALUE) ||
-                    (formalTempness == TEMPNESS_FORWARD));
-        }
+static bool tempnessMatches(bool rvalue, ValueTempness formalTempness) {
+    if (!rvalue) {
+        return ((formalTempness == TEMPNESS_DONTCARE) ||
+                (formalTempness == TEMPNESS_LVALUE) ||
+                (formalTempness == TEMPNESS_FORWARD));
+    } else {
+        return ((formalTempness == TEMPNESS_DONTCARE) ||
+                (formalTempness == TEMPNESS_RVALUE) ||
+                (formalTempness == TEMPNESS_FORWARD));
     }
+}
 
-    static ValueTempness tempnessKeyItem(ValueTempness formalTempness,
-                                         bool rvalue) {
-        switch (formalTempness) {
-            case TEMPNESS_LVALUE:
-            case TEMPNESS_RVALUE:
-            case TEMPNESS_DONTCARE:
-                return formalTempness;
-            case TEMPNESS_FORWARD:
-                return rvalue ? TEMPNESS_RVALUE : TEMPNESS_LVALUE;
-            default:
-                assert(false);
-                return formalTempness;
-        }
+static ValueTempness tempnessKeyItem(ValueTempness formalTempness,
+                                     bool rvalue) {
+    switch (formalTempness) {
+    case TEMPNESS_LVALUE:
+    case TEMPNESS_RVALUE:
+    case TEMPNESS_DONTCARE:
+        return formalTempness;
+    case TEMPNESS_FORWARD:
+        return rvalue ? TEMPNESS_RVALUE : TEMPNESS_LVALUE;
+    default:
+        assert(false);
+        return formalTempness;
     }
+}
 
-    static bool matchTempness(CodePtr code,
-                              const vector<bool> &argsRValues,
-                              bool callByName,
-                              vector<ValueTempness> &tempnessKey,
-                              vector<uint8_t> &forwardedRValueFlags) {
-        llvm::ArrayRef<FormalArgPtr> fargs = code->formalArgs;
-
-        if (code->hasVarArg)
-            assert(fargs.size()-1 <= argsRValues.size());
-        else
-            assert(fargs.size() == argsRValues.size());
-
-        assert(tempnessKey.empty());
-        assert(forwardedRValueFlags.empty());
-
-        size_t varArgSize = argsRValues.size() - fargs.size() + 1;
-        for (size_t i = 0, j = 0; i < fargs.size(); ++i) {
-            if (callByName && (fargs[i]->tempness == TEMPNESS_FORWARD)) {
-                error(fargs[i], "forwarded arguments are not allowed "
-                      "in call-by-name procedures");
-            }
-            if (fargs[i]->varArg) {
-                for (; j < varArgSize; ++j) {
-                    if (!tempnessMatches(argsRValues[i + j], fargs[i]->tempness))
-                        return false;
-                    tempnessKey.push_back(
-                        tempnessKeyItem(fargs[i]->tempness,
-                                        argsRValues[i + j]));
-                    bool forwardedRValue =
-                            (fargs[i]->tempness == TEMPNESS_FORWARD) &&
-                            argsRValues[i + j];
-                    forwardedRValueFlags.push_back(forwardedRValue);
-                }
-                --j;
-            } else {
+static bool matchTempness(CodePtr code, const vector<bool> &argsRValues,
+                          bool callByName, vector<ValueTempness> &tempnessKey,
+                          vector<uint8_t> &forwardedRValueFlags) {
+    llvm::ArrayRef<FormalArgPtr> fargs = code->formalArgs;
+
+    if (code->hasVarArg)
+        assert(fargs.size() - 1 <= argsRValues.size());
+    else
+        assert(fargs.size() == argsRValues.size());
+
+    assert(tempnessKey.empty());
+    assert(forwardedRValueFlags.empty());
+
+    size_t varArgSize = argsRValues.size() - fargs.size() + 1;
+    for (size_t i = 0, j = 0; i < fargs.size(); ++i) {
+        if (callByName && (fargs[i]->tempness == TEMPNESS_FORWARD)) {
+            error(fargs[i], "forwarded arguments are not allowed "
+                            "in call-by-name procedures");
+        }
+        if (fargs[i]->varArg) {
+            for (; j < varArgSize; ++j) {
                 if (!tempnessMatches(argsRValues[i + j], fargs[i]->tempness))
                     return false;
                 tempnessKey.push_back(
-                    tempnessKeyItem(fargs[i]->tempness,
-                                    argsRValues[i + j]));
+                    tempnessKeyItem(fargs[i]->tempness, argsRValues[i + j]));
                 bool forwardedRValue =
-                        (fargs[i]->tempness == TEMPNESS_FORWARD) &&
-                        argsRValues[i + j];
+                    (fargs[i]->tempness == TEMPNESS_FORWARD) &&
+                    argsRValues[i + j];
                 forwardedRValueFlags.push_back(forwardedRValue);
             }
+            --j;
+        } else {
+            if (!tempnessMatches(argsRValues[i + j], fargs[i]->tempness))
+                return false;
+            tempnessKey.push_back(
+                tempnessKeyItem(fargs[i]->tempness, argsRValues[i + j]));
+            bool forwardedRValue =
+                (fargs[i]->tempness == TEMPNESS_FORWARD) && argsRValues[i + j];
+            forwardedRValueFlags.push_back(forwardedRValue);
         }
-        return true;
     }
+    return true;
+}
 
-    static InvokeEntry *newInvokeEntry(InvokeSet *parent,
-                                       MatchSuccessPtr match,
-                                       MatchSuccessPtr interfaceMatch) {
-        InvokeEntry *entry = new InvokeEntry(parent, match->callable, match->argsKey);
-        entry->origCode = match->overload->code;
-        entry->code = clone(match->overload->code);
-        entry->env = match->env;
-        if (interfaceMatch != nullptr)
-            entry->interfaceEnv = interfaceMatch->env;
-        entry->fixedArgNames = match->fixedArgNames;
-        entry->fixedArgTypes = match->fixedArgTypes;
-        entry->varArgName = match->varArgName;
-        entry->varArgTypes = match->varArgTypes;
-        entry->varArgPosition = match->varArgPosition;
-        entry->callByName = match->overload->callByName;
-        entry->isInline = match->overload->isInline;
-
-        return entry;
-    }
+static InvokeEntry *newInvokeEntry(InvokeSet *parent, MatchSuccessPtr match,
+                                   MatchSuccessPtr interfaceMatch) {
+    InvokeEntry *entry =
+        new InvokeEntry(parent, match->callable, match->argsKey);
+    entry->origCode = match->overload->code;
+    entry->code = clone(match->overload->code);
+    entry->env = match->env;
+    if (interfaceMatch != nullptr)
+        entry->interfaceEnv = interfaceMatch->env;
+    entry->fixedArgNames = match->fixedArgNames;
+    entry->fixedArgTypes = match->fixedArgTypes;
+    entry->varArgName = match->varArgName;
+    entry->varArgTypes = match->varArgTypes;
+    entry->varArgPosition = match->varArgPosition;
+    entry->callByName = match->overload->callByName;
+    entry->isInline = match->overload->isInline;
+
+    return entry;
+}
 
-    namespace {
-        class FinallyClearEvaluatingPredicate {
-        private:
-            InvokeSet *invokeSet;
+namespace {
+class FinallyClearEvaluatingPredicate {
+  private:
+    InvokeSet *invokeSet;
 
-        public:
-            FinallyClearEvaluatingPredicate(InvokeSet *invokeSet) : invokeSet(invokeSet) {
-            }
+  public:
+    FinallyClearEvaluatingPredicate(InvokeSet *invokeSet)
+        : invokeSet(invokeSet) {}
 
-            ~FinallyClearEvaluatingPredicate() {
-                assert(invokeSet->evaluatingPredicate);
-                invokeSet->evaluatingPredicate = false;
-            }
-        };
+    ~FinallyClearEvaluatingPredicate() {
+        assert(invokeSet->evaluatingPredicate);
+        invokeSet->evaluatingPredicate = false;
     }
+};
+} // namespace
 
-    InvokeEntry *lookupInvokeEntry(ObjectPtr callable,
-                                   llvm::ArrayRef<PVData> args,
-                                   MatchFailureError &failures) {
-        vector<TypePtr> argTypes;
-        vector<bool> argRValues;
+InvokeEntry *lookupInvokeEntry(ObjectPtr callable, llvm::ArrayRef<PVData> args,
+                               MatchFailureError &failures) {
+    vector<TypePtr> argTypes;
+    vector<bool> argRValues;
 
-        argTypes.reserve(args.size());
-        argRValues.reserve(args.size());
+    argTypes.reserve(args.size());
+    argRValues.reserve(args.size());
 
-        for (llvm::ArrayRef<PVData>::const_iterator arg = args.begin(); arg != args.end(); ++arg) {
-            argTypes.push_back(arg->type);
-            argRValues.push_back(arg->isRValue);
-        }
-
-        InvokeSet *invokeSet = lookupInvokeSet(callable, argTypes);
+    for (llvm::ArrayRef<PVData>::const_iterator arg = args.begin();
+         arg != args.end(); ++arg) {
+        argTypes.push_back(arg->type);
+        argRValues.push_back(arg->isRValue);
+    }
 
-        if (invokeSet->evaluatingPredicate) {
-            // matchInvoke calls the same lookupInvokeEntry
-            error("predicate evaluation loop");
-        }
+    InvokeSet *invokeSet = lookupInvokeSet(callable, argTypes);
 
-        invokeSet->evaluatingPredicate = true;
-        FinallyClearEvaluatingPredicate FinallyClearEvaluatingPredicate(invokeSet);
-
-        map<vector<bool>, InvokeEntry *>::iterator iter1 =
-                invokeSet->tempnessMap.find(argRValues);
-        if (iter1 != invokeSet->tempnessMap.end())
-            return iter1->second;
-
-        MatchResultPtr interfaceResult;
-        if (invokeSet->interface != nullptr) {
-            interfaceResult = matchInvoke(invokeSet->interface,
-                                          invokeSet->callable,
-                                          invokeSet->argsKey);
-            if (interfaceResult->matchCode != MATCH_SUCCESS) {
-                failures.failedInterface = true;
-                failures.failures.push_back(make_pair(invokeSet->interface, interfaceResult));
-                return nullptr;
-            }
-        }
+    if (invokeSet->evaluatingPredicate) {
+        // matchInvoke calls the same lookupInvokeEntry
+        error("predicate evaluation loop");
+    }
 
-        MatchSuccessPtr match;
-        vector<ValueTempness> tempnessKey;
-        vector<uint8_t> forwardedRValueFlags;
-
-        unsigned i = 0;
-        while ((match = getMatch(invokeSet, i, failures)).ptr() != nullptr) {
-            tempnessKey.clear();
-            forwardedRValueFlags.clear();
-            if (matchTempness(match->overload->code,
-                              argRValues,
-                              match->overload->callByName,
-                              tempnessKey,
-                              forwardedRValueFlags)) {
-                break;
-            }
-            ++i;
-        }
-        if (!match)
+    invokeSet->evaluatingPredicate = true;
+    FinallyClearEvaluatingPredicate FinallyClearEvaluatingPredicate(invokeSet);
+
+    map<vector<bool>, InvokeEntry *>::iterator iter1 =
+        invokeSet->tempnessMap.find(argRValues);
+    if (iter1 != invokeSet->tempnessMap.end())
+        return iter1->second;
+
+    MatchResultPtr interfaceResult;
+    if (invokeSet->interface != nullptr) {
+        interfaceResult = matchInvoke(invokeSet->interface, invokeSet->callable,
+                                      invokeSet->argsKey);
+        if (interfaceResult->matchCode != MATCH_SUCCESS) {
+            failures.failedInterface = true;
+            failures.failures.push_back(
+                make_pair(invokeSet->interface, interfaceResult));
             return nullptr;
+        }
+    }
 
-        map<vector<ValueTempness>, InvokeEntry *>::iterator iter2 =
-                invokeSet->tempnessMap2.find(tempnessKey);
-        if (iter2 != invokeSet->tempnessMap2.end()) {
-            invokeSet->tempnessMap[argRValues] = iter2->second;
-            return iter2->second;
+    MatchSuccessPtr match;
+    vector<ValueTempness> tempnessKey;
+    vector<uint8_t> forwardedRValueFlags;
+
+    unsigned i = 0;
+    while ((match = getMatch(invokeSet, i, failures)).ptr() != nullptr) {
+        tempnessKey.clear();
+        forwardedRValueFlags.clear();
+        if (matchTempness(match->overload->code, argRValues,
+                          match->overload->callByName, tempnessKey,
+                          forwardedRValueFlags)) {
+            break;
         }
+        ++i;
+    }
+    if (!match)
+        return nullptr;
 
-        InvokeEntry *entry = newInvokeEntry(invokeSet, match,
-                                            (MatchSuccess *) interfaceResult.ptr());
-        entry->forwardedRValueFlags = forwardedRValueFlags;
-
-        invokeSet->tempnessMap2[tempnessKey] = entry;
-        invokeSet->tempnessMap[argRValues] = entry;
-
-        if (_finalOverloadsEnabled) {
-            MatchSuccessPtr match2;
-            vector<ValueTempness> tempnessKey2;
-            vector<uint8_t> forwardedRValueFlags2;
-            unsigned j = invokeSet->nextOverloadIndex;
-            while ((match2 = findMatchingInvoke(callableOverloads(callable),
-                                                j,
-                                                callable,
-                                                argTypes,
-                                                failures)).ptr() != nullptr) {
-                if (matchTempness(match2->overload->code,
-                                  argRValues,
-                                  match2->overload->callByName,
-                                  tempnessKey2,
-                                  forwardedRValueFlags2)) {
-                    break;
-                }
-                ++j;
-            }
+    map<vector<ValueTempness>, InvokeEntry *>::iterator iter2 =
+        invokeSet->tempnessMap2.find(tempnessKey);
+    if (iter2 != invokeSet->tempnessMap2.end()) {
+        invokeSet->tempnessMap[argRValues] = iter2->second;
+        return iter2->second;
+    }
 
-            if (match2 != nullptr && !match2->overload->isDefault) {
-                failures.ambiguousMatch = true;
-                return nullptr;
+    InvokeEntry *entry =
+        newInvokeEntry(invokeSet, match, (MatchSuccess *)interfaceResult.ptr());
+    entry->forwardedRValueFlags = forwardedRValueFlags;
+
+    invokeSet->tempnessMap2[tempnessKey] = entry;
+    invokeSet->tempnessMap[argRValues] = entry;
+
+    if (_finalOverloadsEnabled) {
+        MatchSuccessPtr match2;
+        vector<ValueTempness> tempnessKey2;
+        vector<uint8_t> forwardedRValueFlags2;
+        unsigned j = invokeSet->nextOverloadIndex;
+        while ((match2 = findMatchingInvoke(callableOverloads(callable), j,
+                                            callable, argTypes, failures))
+                   .ptr() != nullptr) {
+            if (matchTempness(match2->overload->code, argRValues,
+                              match2->overload->callByName, tempnessKey2,
+                              forwardedRValueFlags2)) {
+                break;
             }
+            ++j;
         }
 
-        return entry;
+        if (match2 != nullptr && !match2->overload->isDefault) {
+            failures.ambiguousMatch = true;
+            return nullptr;
+        }
     }
+
+    return entry;
 }
+} // namespace clay
diff --git a/compiler/invoketables.hpp b/compiler/invoketables.hpp
index 19815b6e..827d40b8 100644
--- a/compiler/invoketables.hpp
+++ b/compiler/invoketables.hpp
@@ -4,133 +4,127 @@
 #include "matchinvoke.hpp"
 
 namespace clay {
-    struct InvokeSet;
-    struct InvokeEntry;
-
-    static auto invokeEntryAllocator
-            = new llvm::SpecificBumpPtrAllocator<InvokeEntry>();
-    static auto invokeSetAllocator
-            = new llvm::SpecificBumpPtrAllocator<InvokeSet>();
-
-    struct InvokeEntry {
-        virtual ~InvokeEntry() = default;
-
-        InvokeSet *parent;
-        ObjectPtr callable;
-        vector<TypePtr> argsKey;
-        vector<uint8_t> forwardedRValueFlags;
-
-        CodePtr origCode;
-        CodePtr code;
-        EnvPtr env;
-        EnvPtr interfaceEnv;
-
-        vector<TypePtr> fixedArgTypes;
-        vector<IdentifierPtr> fixedArgNames;
-        IdentifierPtr varArgName;
-        vector<TypePtr> varArgTypes;
-        unsigned varArgPosition;
-
-        InlineAttribute isInline;
-
-        ObjectPtr analysis;
-        vector<uint8_t> returnIsRef;
-        vector<TypePtr> returnTypes;
-
-        llvm::Function *llvmFunc;
-        llvm::Function *llvmCWrappers[CC_Count]{};
-
-        llvm::TrackingMDNodeRef debugInfo;
-
-        bool analyzed: 1;
-        bool analyzing: 1;
-        bool callByName: 1; // if callByName the rest of InvokeEntry is not set
-        bool runtimeNop: 1;
-
-        InvokeEntry(InvokeSet *parent,
-                    const ObjectPtr &callable,
-                    llvm::ArrayRef<TypePtr> argsKey)
-            : parent(parent), callable(callable),
-              argsKey(argsKey),
-              varArgPosition(0),
-              isInline(IGNORE),
-              llvmFunc(nullptr),
-              debugInfo(nullptr),
-              analyzed(false),
-              analyzing(false),
-              callByName(false),
-              runtimeNop(false) {
-            for (auto & llvmCWrapper : llvmCWrappers)
-                llvmCWrapper = nullptr;
-        }
-
-        void *operator new(size_t num_bytes) {
-            return invokeEntryAllocator->Allocate();
-        }
-
-        virtual void dealloc() { ANodeAllocator->Deallocate(this); }
-        llvm::DISubprogram *getDebugInfo() const {
-            return llvm::dyn_cast_or_null<llvm::DISubprogram>(debugInfo.get());
-        }
-    };
-
-    extern vector<OverloadPtr> patternOverloads;
-
-    struct InvokeSet {
-        virtual ~InvokeSet() = default;
-
-        ObjectPtr callable;
-        vector<TypePtr> argsKey;
-        OverloadPtr interface;
-        vector<OverloadPtr> overloads;
-
-        vector<MatchSuccessPtr> matches;
-        map<vector<bool>, InvokeEntry *> tempnessMap;
-        map<vector<ValueTempness>, InvokeEntry *> tempnessMap2;
-
-        unsigned nextOverloadIndex; //:31;
-
-        bool shouldLog: 1;
-        bool evaluatingPredicate: 1;
-
-        InvokeSet(const ObjectPtr &callable,
-                  llvm::ArrayRef<TypePtr> argsKey,
-                  const OverloadPtr &symbolInterface,
-                  llvm::ArrayRef<OverloadPtr> symbolOverloads)
-            : callable(callable), argsKey(argsKey),
-              interface(symbolInterface),
-              overloads(symbolOverloads), nextOverloadIndex(0),
-              shouldLog(false),
-              evaluatingPredicate(false) {
-            overloads.insert(overloads.end(), patternOverloads.begin(), patternOverloads.end());
-        }
-
-        void *operator new(size_t num_bytes) {
-            return invokeSetAllocator->Allocate();
-        }
-
-        virtual void dealloc() { ANodeAllocator->Deallocate(this); }
-    };
-
-    typedef vector<pair<OverloadPtr, MatchResultPtr> > MatchFailureVector;
-
-    struct MatchFailureError {
-        MatchFailureVector failures;
-        bool failedInterface: 1;
-        bool ambiguousMatch: 1;
-
-        MatchFailureError() : failedInterface(false), ambiguousMatch(false) {
-        }
-    };
-
-    InvokeSet *lookupInvokeSet(ObjectPtr callable,
-                               llvm::ArrayRef<TypePtr> argsKey);
-
-    vector<InvokeSet *> lookupInvokeSets(ObjectPtr callable);
-
-    InvokeEntry *lookupInvokeEntry(ObjectPtr callable,
-                                   llvm::ArrayRef<PVData> args,
-                                   MatchFailureError &failures);
-
-    void setFinalOverloadsEnabled(bool enabled);
-}
+struct InvokeSet;
+struct InvokeEntry;
+
+static auto invokeEntryAllocator =
+    new llvm::SpecificBumpPtrAllocator<InvokeEntry>();
+static auto invokeSetAllocator =
+    new llvm::SpecificBumpPtrAllocator<InvokeSet>();
+
+struct InvokeEntry {
+    virtual ~InvokeEntry() = default;
+
+    InvokeSet *parent;
+    ObjectPtr callable;
+    vector<TypePtr> argsKey;
+    vector<uint8_t> forwardedRValueFlags;
+
+    CodePtr origCode;
+    CodePtr code;
+    EnvPtr env;
+    EnvPtr interfaceEnv;
+
+    vector<TypePtr> fixedArgTypes;
+    vector<IdentifierPtr> fixedArgNames;
+    IdentifierPtr varArgName;
+    vector<TypePtr> varArgTypes;
+    unsigned varArgPosition;
+
+    InlineAttribute isInline;
+
+    ObjectPtr analysis;
+    vector<uint8_t> returnIsRef;
+    vector<TypePtr> returnTypes;
+
+    llvm::Function *llvmFunc;
+    llvm::Function *llvmCWrappers[CC_Count]{};
+
+    llvm::TrackingMDNodeRef debugInfo;
+
+    bool analyzed : 1;
+    bool analyzing : 1;
+    bool callByName : 1; // if callByName the rest of InvokeEntry is not set
+    bool runtimeNop : 1;
+
+    InvokeEntry(InvokeSet *parent, const ObjectPtr &callable,
+                llvm::ArrayRef<TypePtr> argsKey)
+        : parent(parent), callable(callable), argsKey(argsKey),
+          varArgPosition(0), isInline(IGNORE), llvmFunc(nullptr),
+          debugInfo(nullptr), analyzed(false), analyzing(false),
+          callByName(false), runtimeNop(false) {
+        for (auto &llvmCWrapper : llvmCWrappers)
+            llvmCWrapper = nullptr;
+    }
+
+    void *operator new(size_t num_bytes) {
+        return invokeEntryAllocator->Allocate();
+    }
+
+    virtual void dealloc() {
+        ANodeAllocator->Deallocate(this, sizeof(*this),
+                                   alignof(decltype(*this)));
+    }
+    llvm::DISubprogram *getDebugInfo() const {
+        return llvm::dyn_cast_or_null<llvm::DISubprogram>(debugInfo.get());
+    }
+};
+
+extern vector<OverloadPtr> patternOverloads;
+
+struct InvokeSet {
+    virtual ~InvokeSet() = default;
+
+    ObjectPtr callable;
+    vector<TypePtr> argsKey;
+    OverloadPtr interface;
+    vector<OverloadPtr> overloads;
+
+    vector<MatchSuccessPtr> matches;
+    map<vector<bool>, InvokeEntry *> tempnessMap;
+    map<vector<ValueTempness>, InvokeEntry *> tempnessMap2;
+
+    unsigned nextOverloadIndex; //: 31;
+
+    bool shouldLog : 1;
+    bool evaluatingPredicate : 1;
+
+    InvokeSet(const ObjectPtr &callable, llvm::ArrayRef<TypePtr> argsKey,
+              const OverloadPtr &symbolInterface,
+              llvm::ArrayRef<OverloadPtr> symbolOverloads)
+        : callable(callable), argsKey(argsKey), interface(symbolInterface),
+          overloads(symbolOverloads), nextOverloadIndex(0), shouldLog(false),
+          evaluatingPredicate(false) {
+        overloads.insert(overloads.end(), patternOverloads.begin(),
+                         patternOverloads.end());
+    }
+
+    void *operator new(size_t num_bytes) {
+        return invokeSetAllocator->Allocate();
+    }
+
+    virtual void dealloc() {
+        ANodeAllocator->Deallocate(this, sizeof(*this),
+                                   alignof(decltype(*this)));
+    }
+};
+
+typedef vector<pair<OverloadPtr, MatchResultPtr>> MatchFailureVector;
+
+struct MatchFailureError {
+    MatchFailureVector failures;
+    bool failedInterface : 1;
+    bool ambiguousMatch : 1;
+
+    MatchFailureError() : failedInterface(false), ambiguousMatch(false) {}
+};
+
+InvokeSet *lookupInvokeSet(ObjectPtr callable, llvm::ArrayRef<TypePtr> argsKey);
+
+vector<InvokeSet *> lookupInvokeSets(ObjectPtr callable);
+
+InvokeEntry *lookupInvokeEntry(ObjectPtr callable, llvm::ArrayRef<PVData> args,
+                               MatchFailureError &failures);
+
+void setFinalOverloadsEnabled(bool enabled);
+} // namespace clay
diff --git a/compiler/lambdas.cpp b/compiler/lambdas.cpp
index c96abf15..ce2bab0a 100644
--- a/compiler/lambdas.cpp
+++ b/compiler/lambdas.cpp
@@ -1,699 +1,711 @@
+#include "lambdas.hpp"
+#include "analyzer.hpp"
 #include "clay.hpp"
 #include "codegen.hpp"
-#include "operators.hpp"
-#include "lambdas.hpp"
 #include "desugar.hpp"
-#include "analyzer.hpp"
-#include "loader.hpp"
 #include "env.hpp"
 #include "error.hpp"
+#include "loader.hpp"
+#include "operators.hpp"
 
 namespace clay {
-    struct LambdaContext {
-        LambdaCapture captureBy;
-        EnvPtr nonLocalEnv;
-        llvm::StringRef closureDataName;
-        vector<string> &freeVars;
-
-        LambdaContext(LambdaCapture captureBy,
-                      const EnvPtr& nonLocalEnv,
-                      llvm::StringRef closureDataName,
-                      vector<string> &freeVars)
-            : captureBy(captureBy), nonLocalEnv(nonLocalEnv),
-              closureDataName(closureDataName), freeVars(freeVars) {
-        }
-    };
-
-    void convertFreeVars(const LambdaPtr &x, const EnvPtr &env,
-                         llvm::StringRef closureDataName,
-                         vector<string> &freeVars);
-
-    void convertFreeVars(const StatementPtr &x, EnvPtr env, LambdaContext &ctx);
-
-    void convertFreeVars(ExprPtr &x, const EnvPtr &env, LambdaContext &ctx);
-
-    void convertFreeVars(ExprList *x, const EnvPtr &env, LambdaContext &ctx);
-    
-    //
-    // initializeLambda
-    //
-
-    static TypePtr typeOfValue(const ObjectPtr& obj) {
-        switch (obj->objKind) {
-            case PVALUE: return dynamic_cast<PValue *>(obj.ptr())->data.type;
-            case CVALUE: return dynamic_cast<CValue *>(obj.ptr())->type;
-            default: assert(false);
-        }
+struct LambdaContext {
+    LambdaCapture captureBy;
+    EnvPtr nonLocalEnv;
+    llvm::StringRef closureDataName;
+    vector<string> &freeVars;
+
+    LambdaContext(LambdaCapture captureBy, const EnvPtr &nonLocalEnv,
+                  llvm::StringRef closureDataName, vector<string> &freeVars)
+        : captureBy(captureBy), nonLocalEnv(nonLocalEnv),
+          closureDataName(closureDataName), freeVars(freeVars) {}
+};
+
+void convertFreeVars(const LambdaPtr &x, const EnvPtr &env,
+                     llvm::StringRef closureDataName, vector<string> &freeVars);
+
+void convertFreeVars(const StatementPtr &x, EnvPtr env, LambdaContext &ctx);
+
+void convertFreeVars(ExprPtr &x, const EnvPtr &env, LambdaContext &ctx);
+
+void convertFreeVars(ExprList *x, const EnvPtr &env, LambdaContext &ctx);
+
+//
+// initializeLambda
+//
+
+static TypePtr typeOfValue(const ObjectPtr &obj) {
+    switch (obj->objKind) {
+    case PVALUE:
+        return dynamic_cast<PValue *>(obj.ptr())->data.type;
+    case CVALUE:
+        return dynamic_cast<CValue *>(obj.ptr())->type;
+    default:
+        assert(false);
     }
+}
 
-    static vector<TypePtr> typesOfValues(const ObjectPtr &obj) {
-        vector<TypePtr> types;
-        switch (obj->objKind) {
-            case MULTI_PVALUE: {
-                auto mpv = dynamic_cast<MultiPValue *>(obj.ptr());
-                for (unsigned i = 0; i < mpv->size(); ++i)
-                    types.push_back(mpv->values[i].type);
-                break;
-            }
-            case MULTI_CVALUE: {
-                auto mcv = dynamic_cast<MultiCValue *>(obj.ptr());
-                for (unsigned i = 0; i < mcv->size(); ++i)
-                    types.push_back(mcv->values[i]->type);
-                break;
-            }
-            default:
-                assert(false);
-        }
-        return types;
+static vector<TypePtr> typesOfValues(const ObjectPtr &obj) {
+    vector<TypePtr> types;
+    switch (obj->objKind) {
+    case MULTI_PVALUE: {
+        auto mpv = dynamic_cast<MultiPValue *>(obj.ptr());
+        for (unsigned i = 0; i < mpv->size(); ++i)
+            types.push_back(mpv->values[i].type);
+        break;
+    }
+    case MULTI_CVALUE: {
+        auto mcv = dynamic_cast<MultiCValue *>(obj.ptr());
+        for (unsigned i = 0; i < mcv->size(); ++i)
+            types.push_back(mcv->values[i]->type);
+        break;
+    }
+    default:
+        assert(false);
     }
+    return types;
+}
 
-    static void initializeLambdaWithFreeVars(const LambdaPtr &x, const EnvPtr &env,
-                                             llvm::StringRef closureDataName, llvm::StringRef lname);
+static void initializeLambdaWithFreeVars(const LambdaPtr &x, const EnvPtr &env,
+                                         llvm::StringRef closureDataName,
+                                         llvm::StringRef lname);
 
-    static void initializeLambdaWithoutFreeVars(const LambdaPtr &x, const EnvPtr &env,
-                                                llvm::StringRef lname);
+static void initializeLambdaWithoutFreeVars(const LambdaPtr &x,
+                                            const EnvPtr &env,
+                                            llvm::StringRef lname);
 
-    static string lambdaName(const LambdaPtr &x) {
-        string fullName = shortString(x->asString());
+static string lambdaName(const LambdaPtr &x) {
+    string fullName = shortString(x->asString());
 
-        if (fullName.size() <= 80)
-            return "(" + fullName + ")";
-        else {
-            llvm::SmallString<128> shortNameBuf;
-            llvm::raw_svector_ostream shortName(shortNameBuf);
-            shortName << "<lambda ";
-            printFileLineCol(shortName, x->location);
-            shortName << ">";
+    if (fullName.size() <= 80)
+        return "(" + fullName + ")";
+    else {
+        llvm::SmallString<128> shortNameBuf;
+        llvm::raw_svector_ostream shortName(shortNameBuf);
+        shortName << "<lambda ";
+        printFileLineCol(shortName, x->location);
+        shortName << ">";
 
-            return shortName.str().str(); // what is this abomination
-        }
+        return shortName.str().str(); // what is this abomination
     }
+}
 
-    void initializeLambda(const LambdaPtr& x, const EnvPtr &env) {
-        assert(!x->initialized);
-        x->initialized = true;
+void initializeLambda(const LambdaPtr &x, const EnvPtr &env) {
+    assert(!x->initialized);
+    x->initialized = true;
 
-        string lname = lambdaName(x);
+    string lname = lambdaName(x);
 
-        llvm::SmallString<128> buf;
-        llvm::raw_svector_ostream ostr(buf);
-        ostr << "%closureData:" << lname;
-        string closureDataName = ostr.str().str(); // again
+    llvm::SmallString<128> buf;
+    llvm::raw_svector_ostream ostr(buf);
+    ostr << "%closureData:" << lname;
+    string closureDataName = ostr.str().str(); // again
 
-        convertFreeVars(x, env, closureDataName, x->freeVars);
-        getProcedureMonoTypes(x->mono, env, x->formalArgs, x->hasVarArg);
+    convertFreeVars(x, env, closureDataName, x->freeVars);
+    getProcedureMonoTypes(x->mono, env, x->formalArgs, x->hasVarArg);
 
-        switch (x->captureBy) {
-            case REF_CAPTURE:
-            case VALUE_CAPTURE: {
-                if (x->freeVars.empty()) {
-                    initializeLambdaWithoutFreeVars(x, env, lname);
-                } else {
-                    initializeLambdaWithFreeVars(x, env, closureDataName, lname);
-                }
-                break;
-            }
-            case STATELESS: {
-                assert(x->freeVars.empty());
-                initializeLambdaWithoutFreeVars(x, env, lname);
-                break;
-            }
-            default:
-                assert(false);
+    switch (x->captureBy) {
+    case REF_CAPTURE:
+    case VALUE_CAPTURE: {
+        if (x->freeVars.empty()) {
+            initializeLambdaWithoutFreeVars(x, env, lname);
+        } else {
+            initializeLambdaWithFreeVars(x, env, closureDataName, lname);
         }
+        break;
     }
+    case STATELESS: {
+        assert(x->freeVars.empty());
+        initializeLambdaWithoutFreeVars(x, env, lname);
+        break;
+    }
+    default:
+        assert(false);
+    }
+}
 
-    static void checkForeignExpr(ObjectPtr &obj, const EnvPtr &env) {
-        if (obj->objKind == EXPRESSION) {
-            ExprPtr expr = dynamic_cast<Expr *>(obj.ptr());
-            if (expr->exprKind == FOREIGN_EXPR) {
-                MultiPValuePtr mpv = safeAnalyzeMulti(new ExprList(expr), env, 0);
-                obj = mpv.ptr();
-            }
-        } else if (obj->objKind == EXPR_LIST) {
-            ExprListPtr expr = dynamic_cast<ExprList *>(obj.ptr());
-            switch (expr->exprs[0]->exprKind) {
-                case FOREIGN_EXPR:
-                case UNPACK: {
-                    MultiPValuePtr mpv = safeAnalyzeMulti(
-                        new ExprList(foreignExpr(env, expr->exprs[0])), env, 0);
-                    obj = mpv.ptr();
-                }
-                default: {
-                } // make compiler happy
-            }
+static void checkForeignExpr(ObjectPtr &obj, const EnvPtr &env) {
+    if (obj->objKind == EXPRESSION) {
+        ExprPtr expr = dynamic_cast<Expr *>(obj.ptr());
+        if (expr->exprKind == FOREIGN_EXPR) {
+            MultiPValuePtr mpv = safeAnalyzeMulti(new ExprList(expr), env, 0);
+            obj = mpv.ptr();
+        }
+    } else if (obj->objKind == EXPR_LIST) {
+        ExprListPtr expr = dynamic_cast<ExprList *>(obj.ptr());
+        switch (expr->exprs[0]->exprKind) {
+        case FOREIGN_EXPR:
+        case UNPACK: {
+            MultiPValuePtr mpv = safeAnalyzeMulti(
+                new ExprList(foreignExpr(env, expr->exprs[0])), env, 0);
+            obj = mpv.ptr();
+        }
+        default: {
+        } // make compiler happy
         }
     }
+}
 
-    static void initializeLambdaWithFreeVars(const LambdaPtr &x, const EnvPtr &env,
-                                             llvm::StringRef closureDataName, llvm::StringRef lname) {
-        RecordDeclPtr r = new RecordDecl(nullptr, PRIVATE);
-        r->location = x->location;
-        r->name = Identifier::get(lname);
-        r->env = env;
-        x->lambdaRecord = r;
-        r->lambda = x;
-        vector<RecordFieldPtr> fields;
-
-        CallPtr converted = new Call(nullptr, new ExprList());
-        for (size_t i = 0; i < x->freeVars.size(); ++i) {
-            IdentifierPtr ident = Identifier::get(x->freeVars[i]);
-            NameRefPtr nameRef = new NameRef(ident);
-
-            TypePtr type;
-            ObjectPtr obj = safeLookupEnv(env, ident);
-            checkForeignExpr(obj, env);
-            switch (obj->objKind) {
-                case PVALUE:
-                case CVALUE: {
-                    type = typeOfValue(obj);
-                    if (x->captureBy == REF_CAPTURE) {
-                        type = pointerType(type);
-                        ExprPtr addr = new VariadicOp(ADDRESS_OF, new ExprList(nameRef.ptr()));
-                        converted->parenArgs->add(addr);
-                    } else {
-                        converted->parenArgs->add(nameRef.ptr());
-                    }
-                    break;
-                }
-                case MULTI_PVALUE:
-                case MULTI_CVALUE: {
-                    vector<TypePtr> types = typesOfValues(obj);
-                    vector<TypePtr> elementTypes;
-                    for (auto t : types) {
-                        if (x->captureBy == REF_CAPTURE)
-                            t = pointerType(t);
-                        elementTypes.push_back(t);
-                    }
-                    type = tupleType(elementTypes);
-                    if (x->captureBy == REF_CAPTURE) {
-                        ExprPtr e = operator_expr_packMultiValuedFreeVarByRef();
-                        CallPtr call = new Call(e, new ExprList());
-                        call->parenArgs->add(new Unpack(nameRef.ptr()));
-                        converted->parenArgs->add(call.ptr());
-                    } else {
-                        ExprPtr e = operator_expr_packMultiValuedFreeVar();
-                        CallPtr call = new Call(e, new ExprList());
-                        call->parenArgs->add(new Unpack(nameRef.ptr()));
-                        converted->parenArgs->add(call.ptr());
-                    }
-                    break;
-                }
-                default:
-                    assert(false);
-            }
-
-            ExprPtr fieldType = new ObjectExpr(type.ptr());
-            RecordFieldPtr field = new RecordField(ident, fieldType);
-            fields.push_back(field);
+static void initializeLambdaWithFreeVars(const LambdaPtr &x, const EnvPtr &env,
+                                         llvm::StringRef closureDataName,
+                                         llvm::StringRef lname) {
+    RecordDeclPtr r = new RecordDecl(nullptr, PRIVATE);
+    r->location = x->location;
+    r->name = Identifier::get(lname);
+    r->env = env;
+    x->lambdaRecord = r;
+    r->lambda = x;
+    vector<RecordFieldPtr> fields;
+
+    CallPtr converted = new Call(nullptr, new ExprList());
+    for (size_t i = 0; i < x->freeVars.size(); ++i) {
+        IdentifierPtr ident = Identifier::get(x->freeVars[i]);
+        NameRefPtr nameRef = new NameRef(ident);
+
+        TypePtr type;
+        ObjectPtr obj = safeLookupEnv(env, ident);
+        checkForeignExpr(obj, env);
+        switch (obj->objKind) {
+        case PVALUE:
+        case CVALUE: {
+            type = typeOfValue(obj);
+            if (x->captureBy == REF_CAPTURE) {
+                type = pointerType(type);
+                ExprPtr addr =
+                    new VariadicOp(ADDRESS_OF, new ExprList(nameRef.ptr()));
+                converted->parenArgs->add(addr);
+            } else {
+                converted->parenArgs->add(nameRef.ptr());
+            }
+            break;
         }
-        r->body = new RecordBody(fields);
-
-        TypePtr t = recordType(r, vector<ObjectPtr>());
-        x->lambdaType = t;
-        ExprPtr typeExpr = new ObjectExpr(t.ptr());
-        converted->expr = typeExpr;
-        x->converted = converted.ptr();
-
-        CodePtr code = new Code();
-        code->location = x->location;
-        IdentifierPtr closureDataIdent = Identifier::get(closureDataName);
-        FormalArgPtr closureDataArg = new FormalArg(closureDataIdent, typeExpr);
-        code->formalArgs.emplace_back(closureDataArg.ptr());
-        for (const auto & formalArg : x->formalArgs) {
-            code->formalArgs.push_back(formalArg);
+        case MULTI_PVALUE:
+        case MULTI_CVALUE: {
+            vector<TypePtr> types = typesOfValues(obj);
+            vector<TypePtr> elementTypes;
+            for (auto t : types) {
+                if (x->captureBy == REF_CAPTURE)
+                    t = pointerType(t);
+                elementTypes.push_back(t);
+            }
+            type = tupleType(elementTypes);
+            if (x->captureBy == REF_CAPTURE) {
+                ExprPtr e = operator_expr_packMultiValuedFreeVarByRef();
+                CallPtr call = new Call(e, new ExprList());
+                call->parenArgs->add(new Unpack(nameRef.ptr()));
+                converted->parenArgs->add(call.ptr());
+            } else {
+                ExprPtr e = operator_expr_packMultiValuedFreeVar();
+                CallPtr call = new Call(e, new ExprList());
+                call->parenArgs->add(new Unpack(nameRef.ptr()));
+                converted->parenArgs->add(call.ptr());
+            }
+            break;
         }
-        code->hasVarArg = x->hasVarArg;
-        code->body = x->body;
-
-        OverloadPtr overload = new Overload(
-            nullptr, operator_expr_call(), code, false, IGNORE, x->hasAsConversion
-        );
-        overload->env = env;
-        overload->location = x->location;
-        ObjectPtr obj = operator_call();
-        if (obj->objKind != PROCEDURE)
-            error("'call' operator not found!");
-        auto *callObj = dynamic_cast<Procedure *>(obj.ptr());
-        addOverload(callObj->overloads, overload);
-    }
-
-    static void initializeLambdaWithoutFreeVars(const LambdaPtr &x, const EnvPtr &env,
-                                                llvm::StringRef lname) {
-        IdentifierPtr name = Identifier::get(lname, x->location);
-        x->lambdaProc = new Procedure(nullptr, name, PRIVATE, false);
-        x->lambdaProc->lambda = x;
-
-        CodePtr code = new Code();
-        code->location = x->location;
-        for (const auto & formalArg : x->formalArgs) {
-            code->formalArgs.push_back(formalArg);
+        default:
+            assert(false);
         }
-        code->hasVarArg = x->hasVarArg;
-        code->body = x->body;
 
-        ExprPtr procRef = new ObjectExpr(x->lambdaProc.ptr());
-        procRef->location = x->location;
-        OverloadPtr overload = new Overload(nullptr, procRef, code, false, IGNORE, x->hasAsConversion);
-        overload->env = env;
-        overload->location = x->location;
-        addProcedureOverload(x->lambdaProc, env, overload);
+        ExprPtr fieldType = new ObjectExpr(type.ptr());
+        RecordFieldPtr field = new RecordField(ident, fieldType);
+        fields.push_back(field);
+    }
+    r->body = new RecordBody(fields);
+
+    TypePtr t = recordType(r, vector<ObjectPtr>());
+    x->lambdaType = t;
+    ExprPtr typeExpr = new ObjectExpr(t.ptr());
+    converted->expr = typeExpr;
+    x->converted = converted.ptr();
+
+    CodePtr code = new Code();
+    code->location = x->location;
+    IdentifierPtr closureDataIdent = Identifier::get(closureDataName);
+    FormalArgPtr closureDataArg = new FormalArg(closureDataIdent, typeExpr);
+    code->formalArgs.emplace_back(closureDataArg.ptr());
+    for (const auto &formalArg : x->formalArgs) {
+        code->formalArgs.push_back(formalArg);
+    }
+    code->hasVarArg = x->hasVarArg;
+    code->body = x->body;
+
+    OverloadPtr overload = new Overload(nullptr, operator_expr_call(), code,
+                                        false, IGNORE, x->hasAsConversion);
+    overload->env = env;
+    overload->location = x->location;
+    ObjectPtr obj = operator_call();
+    if (obj->objKind != PROCEDURE)
+        error("'call' operator not found!");
+    auto *callObj = dynamic_cast<Procedure *>(obj.ptr());
+    addOverload(callObj->overloads, overload);
+}
+
+static void initializeLambdaWithoutFreeVars(const LambdaPtr &x,
+                                            const EnvPtr &env,
+                                            llvm::StringRef lname) {
+    IdentifierPtr name = Identifier::get(lname, x->location);
+    x->lambdaProc = new Procedure(nullptr, name, PRIVATE, false);
+    x->lambdaProc->lambda = x;
+
+    CodePtr code = new Code();
+    code->location = x->location;
+    for (const auto &formalArg : x->formalArgs) {
+        code->formalArgs.push_back(formalArg);
+    }
+    code->hasVarArg = x->hasVarArg;
+    code->body = x->body;
+
+    ExprPtr procRef = new ObjectExpr(x->lambdaProc.ptr());
+    procRef->location = x->location;
+    OverloadPtr overload =
+        new Overload(nullptr, procRef, code, false, IGNORE, x->hasAsConversion);
+    overload->env = env;
+    overload->location = x->location;
+    addProcedureOverload(x->lambdaProc, env, overload);
+
+    x->converted = procRef;
+}
+
+//
+// addFreeVar, typeOfValue, typesOfValues
+//
 
-        x->converted = procRef;
+static void addFreeVar(const LambdaContext &ctx, llvm::StringRef str) {
+    auto i = std::find(ctx.freeVars.begin(), ctx.freeVars.end(), str);
+    if (i == ctx.freeVars.end()) {
+        ctx.freeVars.push_back(str.str());
     }
+}
 
-    //
-    // addFreeVar, typeOfValue, typesOfValues
-    //
+//
+// convertFreeVars
+//
 
-    static void addFreeVar(const LambdaContext &ctx, llvm::StringRef str) {
-        auto i = std::find(ctx.freeVars.begin(), ctx.freeVars.end(), str);
-        if (i == ctx.freeVars.end()) {
-            ctx.freeVars.push_back(str.str());
-        }
+void convertFreeVars(const LambdaPtr &x, const EnvPtr &env,
+                     llvm::StringRef closureDataName,
+                     vector<string> &freeVars) {
+    EnvPtr env2 = new Env(env);
+    for (const auto &arg : x->formalArgs) {
+        addLocal(env2, arg->name, arg->name.ptr());
     }
+    LambdaContext ctx(x->captureBy, env, closureDataName, freeVars);
+    convertFreeVars(x->body, env2, ctx);
+}
 
-    //
-    // convertFreeVars
-    //
+static EnvPtr convertFreeVarsFromBinding(const BindingPtr &binding,
+                                         const EnvPtr &env,
+                                         LambdaContext &ctx) {
+    convertFreeVars(binding->values.ptr(), env, ctx);
+    EnvPtr env2 = new Env(env);
+    for (const auto &arg : binding->args)
+        addLocal(env2, arg->name, arg->name.ptr());
+    return env2;
+}
 
-    void convertFreeVars(const LambdaPtr &x, const EnvPtr &env,
-                         llvm::StringRef closureDataName,
-                         vector<string> &freeVars) {
-        EnvPtr env2 = new Env(env);
-        for (const auto& arg : x->formalArgs) {
-            addLocal(env2, arg->name, arg->name.ptr());
+static EnvPtr convertFreeVarsFromStatementExpressionStatements(
+    llvm::ArrayRef<StatementPtr> stmts, const EnvPtr &env, LambdaContext &ctx) {
+    EnvPtr env2 = env;
+    for (const auto &stmt : stmts) {
+        switch (stmt->stmtKind) {
+        case BINDING:
+            env2 = convertFreeVarsFromBinding(
+                dynamic_cast<Binding *>(stmt.ptr()), env2, ctx);
+            break;
+
+        case ASSIGNMENT:
+        case VARIADIC_ASSIGNMENT:
+        case INIT_ASSIGNMENT:
+        case EXPR_STATEMENT:
+            convertFreeVars(stmt, env2, ctx);
+            break;
+
+        default:
+            assert(false);
         }
-        LambdaContext ctx(x->captureBy, env, closureDataName, freeVars);
-        convertFreeVars(x->body, env2, ctx);
     }
+    return env2;
+}
 
-    static EnvPtr convertFreeVarsFromBinding(const BindingPtr &binding, const EnvPtr &env, LambdaContext &ctx) {
-        convertFreeVars(binding->values.ptr(), env, ctx);
-        EnvPtr env2 = new Env(env);
-        for (const auto & arg : binding->args)
-            addLocal(env2, arg->name, arg->name.ptr());
-        return env2;
-    }
-
-    static EnvPtr convertFreeVarsFromStatementExpressionStatements(
-        llvm::ArrayRef<StatementPtr> stmts,
-        const EnvPtr &env,
-        LambdaContext &ctx) {
-        EnvPtr env2 = env;
-        for (const auto & stmt : stmts) {
-            switch (stmt->stmtKind) {
-                case BINDING:
-                    env2 = convertFreeVarsFromBinding(dynamic_cast<Binding *>(stmt.ptr()), env2, ctx);
-                    break;
-
-                case ASSIGNMENT:
-                case VARIADIC_ASSIGNMENT:
-                case INIT_ASSIGNMENT:
-                case EXPR_STATEMENT:
-                    convertFreeVars(stmt, env2, ctx);
-                    break;
-
-                default:
-                    assert(false);
-            }
+void convertFreeVars(const StatementPtr &x, EnvPtr env, LambdaContext &ctx) {
+    switch (x->stmtKind) {
+    case BLOCK: {
+        auto y = dynamic_cast<Block *>(x.ptr());
+        for (const auto &z : y->statements) {
+            if (z->stmtKind == BINDING)
+                env = convertFreeVarsFromBinding(
+                    dynamic_cast<Binding *>(z.ptr()), env, ctx);
+            else
+                convertFreeVars(z, env, ctx);
         }
-        return env2;
-    }
-
-    void convertFreeVars(const StatementPtr &x, EnvPtr env, LambdaContext &ctx) {
-        switch (x->stmtKind) {
-            case BLOCK: {
-                auto y = dynamic_cast<Block *>(x.ptr());
-                for (const auto& z : y->statements) {
-                    if (z->stmtKind == BINDING)
-                        env = convertFreeVarsFromBinding(dynamic_cast<Binding *>(z.ptr()), env, ctx);
-                    else
-                        convertFreeVars(z, env, ctx);
-                }
-                break;
-            }
+        break;
+    }
 
-            case LABEL:
-            case BINDING: {
-                break;
-            }
+    case LABEL:
+    case BINDING: {
+        break;
+    }
 
-            case ASSIGNMENT: {
-                auto y = dynamic_cast<Assignment *>(x.ptr());
-                convertFreeVars(y->left.ptr(), env, ctx);
-                convertFreeVars(y->right.ptr(), env, ctx);
-                break;
-            }
+    case ASSIGNMENT: {
+        auto y = dynamic_cast<Assignment *>(x.ptr());
+        convertFreeVars(y->left.ptr(), env, ctx);
+        convertFreeVars(y->right.ptr(), env, ctx);
+        break;
+    }
 
-            case INIT_ASSIGNMENT: {
-                auto y = dynamic_cast<InitAssignment *>(x.ptr());
-                convertFreeVars(y->left.ptr(), env, ctx);
-                convertFreeVars(y->right.ptr(), env, ctx);
-                break;
-            }
+    case INIT_ASSIGNMENT: {
+        auto y = dynamic_cast<InitAssignment *>(x.ptr());
+        convertFreeVars(y->left.ptr(), env, ctx);
+        convertFreeVars(y->right.ptr(), env, ctx);
+        break;
+    }
 
-            case VARIADIC_ASSIGNMENT: {
-                auto y = dynamic_cast<VariadicAssignment *>(x.ptr());
-                convertFreeVars(y->exprs.ptr(), env, ctx);
-                break;
-            }
+    case VARIADIC_ASSIGNMENT: {
+        auto y = dynamic_cast<VariadicAssignment *>(x.ptr());
+        convertFreeVars(y->exprs.ptr(), env, ctx);
+        break;
+    }
 
-            case GOTO: {
-                break;
-            }
+    case GOTO: {
+        break;
+    }
 
-            case RETURN: {
-                auto y = dynamic_cast<Return *>(x.ptr());
-                convertFreeVars(y->values.ptr(), env, ctx);
-                break;
-            }
+    case RETURN: {
+        auto y = dynamic_cast<Return *>(x.ptr());
+        convertFreeVars(y->values.ptr(), env, ctx);
+        break;
+    }
 
-            case IF: {
-                auto y = dynamic_cast<If *>(x.ptr());
-                env = convertFreeVarsFromStatementExpressionStatements(y->conditionStatements, env, ctx);
-                convertFreeVars(y->condition, env, ctx);
-                convertFreeVars(y->thenPart, env, ctx);
-                if (y->elsePart.ptr())
-                    convertFreeVars(y->elsePart, env, ctx);
-                break;
-            }
+    case IF: {
+        auto y = dynamic_cast<If *>(x.ptr());
+        env = convertFreeVarsFromStatementExpressionStatements(
+            y->conditionStatements, env, ctx);
+        convertFreeVars(y->condition, env, ctx);
+        convertFreeVars(y->thenPart, env, ctx);
+        if (y->elsePart.ptr())
+            convertFreeVars(y->elsePart, env, ctx);
+        break;
+    }
 
-            case SWITCH: {
-                auto y = dynamic_cast<Switch *>(x.ptr());
-                env = convertFreeVarsFromStatementExpressionStatements(y->exprStatements, env, ctx);
-                convertFreeVars(y->expr, env, ctx);
-                for (const auto& z : y->caseBlocks) {
-                    convertFreeVars(z->caseLabels.ptr(), env, ctx);
-                    convertFreeVars(z->body, env, ctx);
-                }
-                if (y->defaultCase.ptr())
-                    convertFreeVars(y->defaultCase, env, ctx);
-                break;
-            }
+    case SWITCH: {
+        auto y = dynamic_cast<Switch *>(x.ptr());
+        env = convertFreeVarsFromStatementExpressionStatements(
+            y->exprStatements, env, ctx);
+        convertFreeVars(y->expr, env, ctx);
+        for (const auto &z : y->caseBlocks) {
+            convertFreeVars(z->caseLabels.ptr(), env, ctx);
+            convertFreeVars(z->body, env, ctx);
+        }
+        if (y->defaultCase.ptr())
+            convertFreeVars(y->defaultCase, env, ctx);
+        break;
+    }
 
-            case EVAL_STATEMENT: {
-                auto eval = dynamic_cast<EvalStatement *>(x.ptr());
-                convertFreeVars(eval->args.ptr(), env, ctx);
-                break;
-            }
+    case EVAL_STATEMENT: {
+        auto eval = dynamic_cast<EvalStatement *>(x.ptr());
+        convertFreeVars(eval->args.ptr(), env, ctx);
+        break;
+    }
 
-            case EXPR_STATEMENT: {
-                auto y = dynamic_cast<ExprStatement *>(x.ptr());
-                convertFreeVars(y->expr, env, ctx);
-                break;
-            }
+    case EXPR_STATEMENT: {
+        auto y = dynamic_cast<ExprStatement *>(x.ptr());
+        convertFreeVars(y->expr, env, ctx);
+        break;
+    }
 
-            case WHILE: {
-                auto y = dynamic_cast<While *>(x.ptr());
-                env = convertFreeVarsFromStatementExpressionStatements(y->conditionStatements, env, ctx);
-                convertFreeVars(y->condition, env, ctx);
-                convertFreeVars(y->body, env, ctx);
-                break;
-            }
+    case WHILE: {
+        auto y = dynamic_cast<While *>(x.ptr());
+        env = convertFreeVarsFromStatementExpressionStatements(
+            y->conditionStatements, env, ctx);
+        convertFreeVars(y->condition, env, ctx);
+        convertFreeVars(y->body, env, ctx);
+        break;
+    }
 
-            case BREAK:
-            case CONTINUE: {
-                break;
-            }
+    case BREAK:
+    case CONTINUE: {
+        break;
+    }
 
-            case FOR: {
-                auto y = dynamic_cast<For *>(x.ptr());
-                convertFreeVars(y->expr, env, ctx);
-                EnvPtr env2 = new Env(env);
-                for (const auto & variable : y->variables)
-                    addLocal(env2, variable, variable.ptr());
-                convertFreeVars(y->body, env2, ctx);
-                break;
-            }
+    case FOR: {
+        auto y = dynamic_cast<For *>(x.ptr());
+        convertFreeVars(y->expr, env, ctx);
+        EnvPtr env2 = new Env(env);
+        for (const auto &variable : y->variables)
+            addLocal(env2, variable, variable.ptr());
+        convertFreeVars(y->body, env2, ctx);
+        break;
+    }
 
-            case FOREIGN_STATEMENT: {
-                break;
-            }
+    case FOREIGN_STATEMENT: {
+        break;
+    }
 
-            case TRY: {
-                auto y = dynamic_cast<Try *>(x.ptr());
-                convertFreeVars(y->tryBlock, env, ctx);
-                for (const auto & catchBlock : y->catchBlocks) {
-                    EnvPtr env2 = new Env(env);
-                    addLocal(env2,
-                             catchBlock->exceptionVar,
-                             catchBlock->exceptionVar.ptr()
-                    );
-                    if (catchBlock->exceptionType.ptr())
-                        convertFreeVars(catchBlock->exceptionType, env, ctx);
-                    convertFreeVars(catchBlock->body, env2, ctx);
-                }
+    case TRY: {
+        auto y = dynamic_cast<Try *>(x.ptr());
+        convertFreeVars(y->tryBlock, env, ctx);
+        for (const auto &catchBlock : y->catchBlocks) {
+            EnvPtr env2 = new Env(env);
+            addLocal(env2, catchBlock->exceptionVar,
+                     catchBlock->exceptionVar.ptr());
+            if (catchBlock->exceptionType.ptr())
+                convertFreeVars(catchBlock->exceptionType, env, ctx);
+            convertFreeVars(catchBlock->body, env2, ctx);
+        }
 
-                break;
-            }
+        break;
+    }
 
-            case THROW: {
-                auto y = dynamic_cast<Throw *>(x.ptr());
-                desugarThrow(y);
-                convertFreeVars(y->desugaredExpr, env, ctx);
-                if (y->desugaredContext != nullptr)
-                    convertFreeVars(y->desugaredContext, env, ctx);
-                break;
-            }
+    case THROW: {
+        auto y = dynamic_cast<Throw *>(x.ptr());
+        desugarThrow(y);
+        convertFreeVars(y->desugaredExpr, env, ctx);
+        if (y->desugaredContext != nullptr)
+            convertFreeVars(y->desugaredContext, env, ctx);
+        break;
+    }
 
-            case STATIC_FOR: {
-                auto y = dynamic_cast<StaticFor *>(x.ptr());
-                convertFreeVars(y->values.ptr(), env, ctx);
-                EnvPtr env2 = new Env(env);
-                addLocal(env2, y->variable, y->variable.ptr());
-                convertFreeVars(y->body, env2, ctx);
-                break;
-            }
+    case STATIC_FOR: {
+        auto y = dynamic_cast<StaticFor *>(x.ptr());
+        convertFreeVars(y->values.ptr(), env, ctx);
+        EnvPtr env2 = new Env(env);
+        addLocal(env2, y->variable, y->variable.ptr());
+        convertFreeVars(y->body, env2, ctx);
+        break;
+    }
 
-            case FINALLY: {
-                auto y = dynamic_cast<Finally *>(x.ptr());
-                convertFreeVars(y->body, env, ctx);
-                break;
-            }
+    case FINALLY: {
+        auto y = dynamic_cast<Finally *>(x.ptr());
+        convertFreeVars(y->body, env, ctx);
+        break;
+    }
 
-            case ONERROR: {
-                auto y = dynamic_cast<OnError *>(x.ptr());
-                convertFreeVars(y->body, env, ctx);
-                break;
-            }
+    case ONERROR: {
+        auto y = dynamic_cast<OnError *>(x.ptr());
+        convertFreeVars(y->body, env, ctx);
+        break;
+    }
 
-            case UNREACHABLE:
-            case STATIC_ASSERT_STATEMENT:
-                break;
+    case UNREACHABLE:
+    case STATIC_ASSERT_STATEMENT:
+        break;
 
-            default:
-                assert(false);
-        }
+    default:
+        assert(false);
     }
+}
 
-    void convertFreeVars(ExprPtr &x, const EnvPtr &env, LambdaContext &ctx) {
-        switch (x->exprKind) {
-            case BOOL_LITERAL:
-            case INT_LITERAL:
-            case FLOAT_LITERAL:
-            case CHAR_LITERAL:
-            case STRING_LITERAL:
-                break;
-
-            case NAME_REF: {
-                auto y = dynamic_cast<NameRef *>(x.ptr());
-                bool isNonLocal = false;
-                bool isGlobal = false;
-                ObjectPtr z = lookupEnvEx(env, y->name, ctx.nonLocalEnv,
-                                          isNonLocal, isGlobal);
-                if (isNonLocal && !isGlobal) {
-                    checkForeignExpr(z, env);
-                    if ((z->objKind == PVALUE) || (z->objKind == CVALUE)) {
-                        TypePtr t = typeOfValue(z);
-                        if (isStaticOrTupleOfStatics(t)) {
-                            ExprListPtr args = new ExprList();
-                            args->add(new ObjectExpr(t.ptr()));
-                            CallPtr call = new Call(operator_expr_typeToRValue(), args);
-                            call->location = y->location;
-                            x = call.ptr();
-                        } else {
-                            addFreeVar(ctx, y->name->str);
-                            IdentifierPtr a = Identifier::get(ctx.closureDataName, y->location);
-                            NameRefPtr b = new NameRef(a);
-                            b->location = y->location;
-                            FieldRefPtr c = new FieldRef(b.ptr(), y->name);
-                            c->location = y->location;
-                            switch (ctx.captureBy) {
-                                case REF_CAPTURE: {
-                                    ExprPtr d = new VariadicOp(DEREFERENCE, new ExprList(c.ptr()));
-                                    d->location = y->location;
-                                    x = d.ptr();
-                                    break;
-                                }
-                                case VALUE_CAPTURE: {
-                                    x = c.ptr();
-                                    break;
-                                }
-                                case STATELESS:
-                                    error(c->location,
-                                          "cannot capture free variable in stateless lambda function");
-                                default:
-                                    assert(false);
-                            }
-                        }
-                    } else if ((z->objKind == MULTI_PVALUE) || (z->objKind == MULTI_CVALUE)) {
-                        vector<TypePtr> types = typesOfValues(z);
-                        bool allStatic = true;
-                        for (const auto & type : types) {
-                            if (!isStaticOrTupleOfStatics(type)) {
-                                allStatic = false;
-                                break;
-                            }
-                        }
-                        if (allStatic) {
-                            ExprListPtr args = new ExprList();
-                            for (const auto & type : types)
-                                args->add(new ObjectExpr(type.ptr()));
-                            CallPtr call = new Call(operator_expr_typesToRValues(), args);
-                            call->location = y->location;
-                            x = call.ptr();
-                        } else {
-                            addFreeVar(ctx, y->name->str);
-                            IdentifierPtr a = Identifier::get(ctx.closureDataName, y->location);
-                            NameRefPtr b = new NameRef(a);
-                            b->location = y->location;
-                            FieldRefPtr c = new FieldRef(b.ptr(), y->name);
-                            c->location = y->location;
-                            switch (ctx.captureBy) {
-                                case REF_CAPTURE: {
-                                    ExprPtr f =
-                                            operator_expr_unpackMultiValuedFreeVarAndDereference();
-                                    CallPtr d = new Call(f, new ExprList());
-                                    d->parenArgs->add(c.ptr());
-                                    x = d.ptr();
-                                    break;
-                                }
-                                case VALUE_CAPTURE: {
-                                    ExprPtr f = operator_expr_unpackMultiValuedFreeVar();
-                                    CallPtr d = new Call(f, new ExprList());
-                                    d->parenArgs->add(c.ptr());
-                                    x = d.ptr();
-                                    break;
-                                }
-                                case STATELESS:
-                                    error(c->location,
-                                          "cannot capture free variable in stateless lambda function");
-                                default:
-                                    assert(false);
-                            }
-                        }
+void convertFreeVars(ExprPtr &x, const EnvPtr &env, LambdaContext &ctx) {
+    switch (x->exprKind) {
+    case BOOL_LITERAL:
+    case INT_LITERAL:
+    case FLOAT_LITERAL:
+    case CHAR_LITERAL:
+    case STRING_LITERAL:
+        break;
+
+    case NAME_REF: {
+        auto y = dynamic_cast<NameRef *>(x.ptr());
+        bool isNonLocal = false;
+        bool isGlobal = false;
+        ObjectPtr z =
+            lookupEnvEx(env, y->name, ctx.nonLocalEnv, isNonLocal, isGlobal);
+        if (isNonLocal && !isGlobal) {
+            checkForeignExpr(z, env);
+            if ((z->objKind == PVALUE) || (z->objKind == CVALUE)) {
+                TypePtr t = typeOfValue(z);
+                if (isStaticOrTupleOfStatics(t)) {
+                    ExprListPtr args = new ExprList();
+                    args->add(new ObjectExpr(t.ptr()));
+                    CallPtr call = new Call(operator_expr_typeToRValue(), args);
+                    call->location = y->location;
+                    x = call.ptr();
+                } else {
+                    addFreeVar(ctx, y->name->str);
+                    IdentifierPtr a =
+                        Identifier::get(ctx.closureDataName, y->location);
+                    NameRefPtr b = new NameRef(a);
+                    b->location = y->location;
+                    FieldRefPtr c = new FieldRef(b.ptr(), y->name);
+                    c->location = y->location;
+                    switch (ctx.captureBy) {
+                    case REF_CAPTURE: {
+                        ExprPtr d =
+                            new VariadicOp(DEREFERENCE, new ExprList(c.ptr()));
+                        d->location = y->location;
+                        x = d.ptr();
+                        break;
+                    }
+                    case VALUE_CAPTURE: {
+                        x = c.ptr();
+                        break;
+                    }
+                    case STATELESS:
+                        error(c->location, "cannot capture free variable in "
+                                           "stateless lambda function");
+                    default:
+                        assert(false);
+                    }
+                }
+            } else if ((z->objKind == MULTI_PVALUE) ||
+                       (z->objKind == MULTI_CVALUE)) {
+                vector<TypePtr> types = typesOfValues(z);
+                bool allStatic = true;
+                for (const auto &type : types) {
+                    if (!isStaticOrTupleOfStatics(type)) {
+                        allStatic = false;
+                        break;
+                    }
+                }
+                if (allStatic) {
+                    ExprListPtr args = new ExprList();
+                    for (const auto &type : types)
+                        args->add(new ObjectExpr(type.ptr()));
+                    CallPtr call =
+                        new Call(operator_expr_typesToRValues(), args);
+                    call->location = y->location;
+                    x = call.ptr();
+                } else {
+                    addFreeVar(ctx, y->name->str);
+                    IdentifierPtr a =
+                        Identifier::get(ctx.closureDataName, y->location);
+                    NameRefPtr b = new NameRef(a);
+                    b->location = y->location;
+                    FieldRefPtr c = new FieldRef(b.ptr(), y->name);
+                    c->location = y->location;
+                    switch (ctx.captureBy) {
+                    case REF_CAPTURE: {
+                        ExprPtr f =
+                            operator_expr_unpackMultiValuedFreeVarAndDereference();
+                        CallPtr d = new Call(f, new ExprList());
+                        d->parenArgs->add(c.ptr());
+                        x = d.ptr();
+                        break;
+                    }
+                    case VALUE_CAPTURE: {
+                        ExprPtr f = operator_expr_unpackMultiValuedFreeVar();
+                        CallPtr d = new Call(f, new ExprList());
+                        d->parenArgs->add(c.ptr());
+                        x = d.ptr();
+                        break;
+                    }
+                    case STATELESS:
+                        error(c->location, "cannot capture free variable in "
+                                           "stateless lambda function");
+                    default:
+                        assert(false);
                     }
                 }
-                break;
-            }
-
-            case TUPLE: {
-                auto y = dynamic_cast<Tuple *>(x.ptr());
-                convertFreeVars(y->args.ptr(), env, ctx);
-                break;
             }
+        }
+        break;
+    }
 
-            case PAREN: {
-                auto y = dynamic_cast<Paren *>(x.ptr());
-                convertFreeVars(y->args.ptr(), env, ctx);
-                break;
-            }
+    case TUPLE: {
+        auto y = dynamic_cast<Tuple *>(x.ptr());
+        convertFreeVars(y->args.ptr(), env, ctx);
+        break;
+    }
 
-            case INDEXING: {
-                auto y = dynamic_cast<Indexing *>(x.ptr());
-                convertFreeVars(y->expr, env, ctx);
-                convertFreeVars(y->args.ptr(), env, ctx);
-                break;
-            }
+    case PAREN: {
+        auto y = dynamic_cast<Paren *>(x.ptr());
+        convertFreeVars(y->args.ptr(), env, ctx);
+        break;
+    }
 
-            case CALL: {
-                auto y = dynamic_cast<Call *>(x.ptr());
-                convertFreeVars(y->expr, env, ctx);
-                convertFreeVars(y->parenArgs.ptr(), env, ctx);
-                break;
-            }
+    case INDEXING: {
+        auto y = dynamic_cast<Indexing *>(x.ptr());
+        convertFreeVars(y->expr, env, ctx);
+        convertFreeVars(y->args.ptr(), env, ctx);
+        break;
+    }
 
-            case FIELD_REF: {
-                auto y = dynamic_cast<FieldRef *>(x.ptr());
-                if (y->desugared == nullptr)
-                    desugarFieldRef(y, safeLookupModule(env));
-                if (!y->isDottedModuleName)
-                    convertFreeVars(y->expr, env, ctx);
-                break;
-            }
+    case CALL: {
+        auto y = dynamic_cast<Call *>(x.ptr());
+        convertFreeVars(y->expr, env, ctx);
+        convertFreeVars(y->parenArgs.ptr(), env, ctx);
+        break;
+    }
 
-            case STATIC_INDEXING: {
-                auto y = dynamic_cast<StaticIndexing *>(x.ptr());
-                convertFreeVars(y->expr, env, ctx);
-                break;
-            }
+    case FIELD_REF: {
+        auto y = dynamic_cast<FieldRef *>(x.ptr());
+        if (y->desugared == nullptr)
+            desugarFieldRef(y, safeLookupModule(env));
+        if (!y->isDottedModuleName)
+            convertFreeVars(y->expr, env, ctx);
+        break;
+    }
 
-            case VARIADIC_OP: {
-                auto y = dynamic_cast<VariadicOp *>(x.ptr());
-                convertFreeVars(y->exprs.ptr(), env, ctx);
-                break;
-            }
+    case STATIC_INDEXING: {
+        auto y = dynamic_cast<StaticIndexing *>(x.ptr());
+        convertFreeVars(y->expr, env, ctx);
+        break;
+    }
 
-            case AND: {
-                auto y = dynamic_cast<And *>(x.ptr());
-                convertFreeVars(y->expr1, env, ctx);
-                convertFreeVars(y->expr2, env, ctx);
-                break;
-            }
+    case VARIADIC_OP: {
+        auto y = dynamic_cast<VariadicOp *>(x.ptr());
+        convertFreeVars(y->exprs.ptr(), env, ctx);
+        break;
+    }
 
-            case OR: {
-                auto y = dynamic_cast<Or *>(x.ptr());
-                convertFreeVars(y->expr1, env, ctx);
-                convertFreeVars(y->expr2, env, ctx);
-                break;
-            }
+    case AND: {
+        auto y = dynamic_cast<And *>(x.ptr());
+        convertFreeVars(y->expr1, env, ctx);
+        convertFreeVars(y->expr2, env, ctx);
+        break;
+    }
 
-            case LAMBDA: {
-                auto y = dynamic_cast<Lambda *>(x.ptr());
-                EnvPtr env2 = new Env(env);
-                for (const auto & formalArg : y->formalArgs)
-                    addLocal(env2, formalArg->name, formalArg->name.ptr());
-                convertFreeVars(y->body, env2, ctx);
-                break;
-            }
+    case OR: {
+        auto y = dynamic_cast<Or *>(x.ptr());
+        convertFreeVars(y->expr1, env, ctx);
+        convertFreeVars(y->expr2, env, ctx);
+        break;
+    }
 
-            case UNPACK: {
-                auto y = dynamic_cast<Unpack *>(x.ptr());
-                convertFreeVars(y->expr, env, ctx);
-                break;
-            }
+    case LAMBDA: {
+        auto y = dynamic_cast<Lambda *>(x.ptr());
+        EnvPtr env2 = new Env(env);
+        for (const auto &formalArg : y->formalArgs)
+            addLocal(env2, formalArg->name, formalArg->name.ptr());
+        convertFreeVars(y->body, env2, ctx);
+        break;
+    }
 
-            case STATIC_EXPR: {
-                auto y = dynamic_cast<StaticExpr *>(x.ptr());
-                convertFreeVars(y->expr, env, ctx);
-                break;
-            }
+    case UNPACK: {
+        auto y = dynamic_cast<Unpack *>(x.ptr());
+        convertFreeVars(y->expr, env, ctx);
+        break;
+    }
 
-            case DISPATCH_EXPR: {
-                auto y = dynamic_cast<DispatchExpr *>(x.ptr());
-                convertFreeVars(y->expr, env, ctx);
-                break;
-            }
+    case STATIC_EXPR: {
+        auto y = dynamic_cast<StaticExpr *>(x.ptr());
+        convertFreeVars(y->expr, env, ctx);
+        break;
+    }
 
-            case EVAL_EXPR: {
-                auto eval = dynamic_cast<EvalExpr *>(x.ptr());
-                convertFreeVars(eval->args, env, ctx);
-                break;
-            }
+    case DISPATCH_EXPR: {
+        auto y = dynamic_cast<DispatchExpr *>(x.ptr());
+        convertFreeVars(y->expr, env, ctx);
+        break;
+    }
 
-            case FOREIGN_EXPR:
-            case OBJECT_EXPR:
-            case FILE_EXPR:
-            case LINE_EXPR:
-            case COLUMN_EXPR:
-            case ARG_EXPR:
-                break;
-        }
+    case EVAL_EXPR: {
+        auto eval = dynamic_cast<EvalExpr *>(x.ptr());
+        convertFreeVars(eval->args, env, ctx);
+        break;
     }
 
-    void convertFreeVars(ExprList *x, const EnvPtr &env, LambdaContext &ctx) {
-        for (unsigned i = 0; i < x->size(); ++i)
-            convertFreeVars(x->exprs[i], env, ctx);
+    case FOREIGN_EXPR:
+    case OBJECT_EXPR:
+    case FILE_EXPR:
+    case LINE_EXPR:
+    case COLUMN_EXPR:
+    case ARG_EXPR:
+        break;
     }
 }
+
+void convertFreeVars(ExprList *x, const EnvPtr &env, LambdaContext &ctx) {
+    for (unsigned i = 0; i < x->size(); ++i)
+        convertFreeVars(x->exprs[i], env, ctx);
+}
+} // namespace clay
diff --git a/compiler/lambdas.hpp b/compiler/lambdas.hpp
index a9310232..e946ee77 100644
--- a/compiler/lambdas.hpp
+++ b/compiler/lambdas.hpp
@@ -3,5 +3,5 @@
 #include "clay.hpp"
 
 namespace clay {
-    void initializeLambda(const LambdaPtr& x, EnvPtr env);
+void initializeLambda(const LambdaPtr &x, EnvPtr env);
 }
diff --git a/compiler/lexer.cpp b/compiler/lexer.cpp
index 1adf874c..49f695fe 100644
--- a/compiler/lexer.cpp
+++ b/compiler/lexer.cpp
@@ -1,922 +1,1038 @@
-#include "clay.hpp"
 #include "lexer.hpp"
+#include "clay.hpp"
 #include "error.hpp"
 
 namespace clay {
-    static void initLexer(SourcePtr s, unsigned offset, size_t length);
-    static void cleanupLexer();
-    static bool nextToken(Token &x);
-    static bool nextDocToken(Token &x);
-
-    void tokenize(SourcePtr source, vector<Token> &tokens) {
-        tokenize(source, 0, source->size(), tokens);
-    }
-
-    void tokenize(SourcePtr source, unsigned offset, size_t length,
-                  vector<Token> &tokens) {
-        initLexer(source, offset, length);
-        tokens.push_back(Token());
-        while (nextToken(tokens.back())) {
-            switch (tokens.back().tokenKind) {
-                case T_SPACE:
-                case T_LINE_COMMENT:
-                case T_BLOCK_COMMENT:
-                    break;
-                case T_DOC_START:
-                    while (nextDocToken(tokens.back())) {
-                        if (tokens.back().tokenKind == T_DOC_END)
-                            break;
-                        tokens.push_back(Token());
-                    }
+static void initLexer(SourcePtr s, unsigned offset, size_t length);
+static void cleanupLexer();
+static bool nextToken(Token &x);
+static bool nextDocToken(Token &x);
+
+void tokenize(SourcePtr source, vector<Token> &tokens) {
+    tokenize(source, 0, source->size(), tokens);
+}
+
+void tokenize(SourcePtr source, unsigned offset, size_t length,
+              vector<Token> &tokens) {
+    initLexer(source, offset, length);
+    tokens.push_back(Token());
+    while (nextToken(tokens.back())) {
+        switch (tokens.back().tokenKind) {
+        case T_SPACE:
+        case T_LINE_COMMENT:
+        case T_BLOCK_COMMENT:
+            break;
+        case T_DOC_START:
+            while (nextDocToken(tokens.back())) {
+                if (tokens.back().tokenKind == T_DOC_END)
                     break;
-                default:
-                    tokens.push_back(Token());
+                tokens.push_back(Token());
             }
+            break;
+        default:
+            tokens.push_back(Token());
         }
-        tokens.pop_back();
-        cleanupLexer();
     }
+    tokens.pop_back();
+    cleanupLexer();
+}
 
-    static Source *lexerSource;
-    static unsigned beginOffset;
-    static const char *begin;
-    static const char *ptr;
-    static const char *end;
-    static const char *maxPtr;
+static Source *lexerSource;
+static unsigned beginOffset;
+static const char *begin;
+static const char *ptr;
+static const char *end;
+static const char *maxPtr;
+
+static void initLexer(SourcePtr source, unsigned offset, size_t length) {
+    lexerSource = source.ptr();
+    begin = source->data() + offset;
+    end = begin + length;
+    ptr = begin;
+    maxPtr = begin;
+    beginOffset = offset;
+}
 
-    static void initLexer(SourcePtr source, unsigned offset, size_t length) {
-        lexerSource = source.ptr();
-        begin = source->data() + offset;
-        end = begin + length;
-        ptr = begin;
-        maxPtr = begin;
-        beginOffset = offset;
-    }
+static void cleanupLexer() {
+    lexerSource = nullptr;
+    begin = ptr = end = maxPtr = nullptr;
+}
 
-    static void cleanupLexer() {
-        lexerSource = nullptr;
-        begin = ptr = end = maxPtr = nullptr;
-    }
+static Location locationFor(const char *ptr) {
+    unsigned offset = unsigned(ptr - begin) + beginOffset;
+    return Location(lexerSource, offset);
+}
 
-    static Location locationFor(const char *ptr) {
-        unsigned offset = unsigned(ptr - begin) + beginOffset;
-        return Location(lexerSource, offset);
-    }
+static const char *save() { return ptr; }
+static void restore(const char *p) { ptr = p; }
 
-    static const char *save() { return ptr; }
-    static void restore(const char *p) { ptr = p; }
+static bool next(char &x) {
+    if (ptr == end)
+        return false;
+    if (ptr > maxPtr)
+        maxPtr = ptr;
+    x = *(ptr++);
+    return true;
+}
 
-    static bool next(char &x) {
-        if (ptr == end) return false;
-        if (ptr > maxPtr) maxPtr = ptr;
-        x = *(ptr++);
-        return true;
+static bool str(const char *s) {
+    while (*s) {
+        char x;
+        if (!next(x))
+            return false;
+        if (*s != x)
+            return false;
+        ++s;
     }
+    return true;
+}
 
-    static bool str(const char *s) {
-        while (*s) {
-            char x;
-            if (!next(x)) return false;
-            if (*s != x) return false;
-            ++s;
-        }
+//
+// keywords and identifiers
+//
+
+static bool identChar1(char &x) {
+    if (!next(x))
+        return false;
+    if ((x >= 'a') && (x <= 'z'))
         return true;
-    }
+    if ((x >= 'A') && (x <= 'Z'))
+        return true;
+    if (x == '_')
+        return true;
+    if (x == '?')
+        return true;
+    return false;
+}
 
-    //
-    // keywords and identifiers
-    //
+static bool identChar2(char &x) {
+    if (!next(x))
+        return false;
+    if ((x >= 'a') && (x <= 'z'))
+        return true;
+    if ((x >= 'A') && (x <= 'Z'))
+        return true;
+    if ((x >= '0') && (x <= '9'))
+        return true;
+    if (x == '_')
+        return true;
+    if (x == '?')
+        return true;
+    return false;
+}
 
-    static bool identChar1(char &x) {
-        if (!next(x)) return false;
-        if ((x >= 'a') && (x <= 'z')) return true;
-        if ((x >= 'A') && (x <= 'Z')) return true;
-        if (x == '_') return true;
-        if (x == '?') return true;
+static bool identStr(llvm::SmallString<16> &x) {
+    char c;
+    if (!identChar1(c))
         return false;
+    x.clear();
+    x.push_back(c);
+    while (true) {
+        const char *p = save();
+        if (!identChar2(c)) {
+            restore(p);
+            break;
+        }
+        x.push_back(c);
     }
+    return true;
+}
+
+static std::set<llvm::StringRef> *keywords = nullptr;
+
+static void initKeywords() {
+    const char *s[] = {
+        "public",   "private",      "import",      "as",       "record",
+        "variant",  "instance",     "define",      "overload", "default",
+        "external", "alias",        "rvalue",      "ref",      "forward",
+        "inline",   "noinline",     "forceinline", "enum",     "var",
+        "and",      "or",           "not",         "if",       "else",
+        "goto",     "return",       "while",       "switch",   "case",
+        "break",    "continue",     "for",         "in",       "true",
+        "false",    "try",          "catch",       "throw",    "finally",
+        "onerror",  "staticassert", "eval",        "when",     "newtype",
+        "__FILE__", "__LINE__",     "__COLUMN__",  "__ARG__",  nullptr};
+    keywords = new std::set<llvm::StringRef>();
+    for (const char **p = s; *p; ++p)
+        keywords->insert(*p);
+}
 
-    static bool identChar2(char &x) {
-        if (!next(x)) return false;
-        if ((x >= 'a') && (x <= 'z')) return true;
-        if ((x >= 'A') && (x <= 'Z')) return true;
-        if ((x >= '0') && (x <= '9')) return true;
-        if (x == '_') return true;
-        if (x == '?') return true;
+static bool keywordIdentifier(Token &x) {
+    x.str.clear();
+    if (!identStr(x.str))
         return false;
-    }
+    if (!keywords)
+        initKeywords();
+    if (keywords->find(x.str) != keywords->end())
+        x.tokenKind = T_KEYWORD;
+    else
+        x.tokenKind = T_IDENTIFIER;
+    return true;
+}
 
-    static bool identStr(llvm::SmallString<16> &x) {
-        char c;
-        if (!identChar1(c)) return false;
-        x.clear();
-        x.push_back(c);
-        while (true) {
-            const char *p = save();
-            if (!identChar2(c)) {
-                restore(p);
-                break;
-            }
-            x.push_back(c);
+//
+// symbols
+//
+
+static const char *symbols[] = {"..", "::", "^", "@", "(", ")", "[", "]",
+                                "{",  "}",  ":", ";", ",", ".", "#", nullptr};
+
+static bool symbol(Token &x) {
+    const char **s = symbols;
+    const char *p = save();
+    while (*s) {
+        restore(p);
+        if (str(*s)) {
+            x = Token(T_SYMBOL, *s);
+            return true;
         }
-        return true;
+        ++s;
     }
+    return false;
+}
+
+//
+// operator strings
+//
 
-    static std::set<llvm::StringRef> *keywords = nullptr;
-
-    static void initKeywords() {
-        const char *s[] =
-        {
-            "public", "private", "import", "as",
-            "record", "variant", "instance",
-            "define", "overload", "default",
-            "external", "alias",
-            "rvalue", "ref", "forward",
-            "inline", "noinline", "forceinline",
-            "enum", "var", "and", "or", "not",
-            "if", "else", "goto", "return", "while",
-            "switch", "case", "break", "continue", "for", "in",
-            "true", "false", "try", "catch", "throw",
-            "finally", "onerror", "staticassert",
-            "eval", "when", "newtype",
-            "__FILE__", "__LINE__", "__COLUMN__", "__ARG__", nullptr
-        };
-        keywords = new std::set<llvm::StringRef>();
-        for (const char **p = s; *p; ++p)
-            keywords->insert(*p);
-    }
-
-    static bool keywordIdentifier(Token &x) {
-        x.str.clear();
-        if (!identStr(x.str)) return false;
-        if (!keywords) initKeywords();
-        if (keywords->find(x.str) != keywords->end())
-            x.tokenKind = T_KEYWORD;
+static llvm::StringRef opchars("=!<>+-*/\\%~|&");
+
+static bool opstring(llvm::SmallString<16> &x) {
+    const char *p = save();
+    const char *q = p;
+    char y;
+    while (next(y)) {
+        if (opchars.find(y) != llvm::StringRef::npos)
+            q = save();
         else
-            x.tokenKind = T_IDENTIFIER;
-        return true;
+            break;
     }
-    
-    //
-    // symbols
-    //
-
-    static const char *symbols[] = {
-        "..", "::", "^", "@",
-        "(", ")", "[", "]", "{", "}",
-        ":", ";", ",", ".", "#",
-        nullptr
-    };
+    restore(q);
+    if (p == q)
+        return false;
+    x = llvm::StringRef(p, (size_t)(q - p));
+    return true;
+}
 
-    static bool symbol(Token &x) {
-        const char **s = symbols;
-        const char *p = save();
-        while (*s) {
-            restore(p);
-            if (str(*s)) {
-                x = Token(T_SYMBOL, *s);
-                return true;
-            }
-            ++s;
-        }
+static bool op(Token &x) {
+    x.str.clear();
+    if (!opstring(x.str))
         return false;
+    char c;
+    const char *p = save();
+    if (next(c) && c == ':') {
+        x.tokenKind = T_UOPSTRING;
+    } else {
+        restore(p);
+        x.tokenKind = T_OPSTRING;
     }
+    return true;
+}
 
-    //
-    // operator strings
-    //
+static bool opIdentifier(Token &x) {
+    char c;
+    if (!next(c))
+        return false;
+    if (c != '(')
+        return false;
+    x.str.clear();
+    if (!opstring(x.str))
+        return false;
+    if (!next(c))
+        return false;
+    if (c != ')')
+        return false;
+    x.tokenKind = T_OPIDENTIFIER;
+    return true;
+}
 
-    static llvm::StringRef opchars("=!<>+-*/\\%~|&");
+//
+// hex and decimal digits
+//
 
-    static bool opstring(llvm::SmallString<16> &x) {
-        const char *p = save();
-        const char *q = p;
-        char y;
-        while (next(y)) {
-            if (opchars.find(y) != llvm::StringRef::npos)
-                q = save();
-            else
-                break;
-        }
-        restore(q);
-        if (p == q) return false;
-        x = llvm::StringRef(p, (size_t) (q - p));
+static bool hexDigit(int &x) {
+    char c;
+    if (!next(c))
+        return false;
+    if ((c >= '0') && (c <= '9')) {
+        x = c - '0';
         return true;
     }
-
-    static bool op(Token &x) {
-        x.str.clear();
-        if (!opstring(x.str)) return false;
-        char c;
-        const char *p = save();
-        if (next(c) && c == ':') {
-            x.tokenKind = T_UOPSTRING;
-        } else {
-            restore(p);
-            x.tokenKind = T_OPSTRING;
-        }
+    if ((c >= 'a') && (c <= 'f')) {
+        x = c - 'a' + 10;
         return true;
     }
-
-    static bool opIdentifier(Token &x) {
-        char c;
-        if (!next(c)) return false;
-        if (c != '(') return false;
-        x.str.clear();
-        if (!opstring(x.str)) return false;
-        if (!next(c)) return false;
-        if (c != ')') return false;
-        x.tokenKind = T_OPIDENTIFIER;
+    if ((c >= 'A') && (c <= 'F')) {
+        x = c - 'A' + 10;
         return true;
     }
+    return false;
+}
 
-    //
-    // hex and decimal digits
-    //
+static bool decimalDigit(int &x) {
+    char c;
+    if (!next(c) || (c < '0') || (c > '9'))
+        return false;
+    x = c - '0';
+    return true;
+}
 
-    static bool hexDigit(int &x) {
-        char c;
-        if (!next(c)) return false;
-        if ((c >= '0') && (c <= '9')) {
-            x = c - '0';
-            return true;
-        }
-        if ((c >= 'a') && (c <= 'f')) {
-            x = c - 'a' + 10;
-            return true;
-        }
-        if ((c >= 'A') && (c <= 'F')) {
-            x = c - 'A' + 10;
-            return true;
-        }
+//
+// characters and strings
+//
+
+static bool hexEscapeChar(char &x) {
+    int digit1, digit2;
+    if (!hexDigit(digit1))
         return false;
-    }
+    if (!hexDigit(digit2))
+        return false;
+    x = (char)(digit1 * 16 + digit2);
+    return true;
+}
 
-    static bool decimalDigit(int &x) {
-        char c;
-        if (!next(c) || (c < '0') || (c > '9'))
-            return false;
-        x = c - '0';
+static bool escapeChar(char &x) {
+    char c;
+    if (!next(c))
+        return false;
+    if (c != '\\')
+        return false;
+    if (!next(c))
+        return false;
+    switch (c) {
+    case 'n':
+        x = '\n';
+        return true;
+    case 'r':
+        x = '\r';
         return true;
+    case 't':
+        x = '\t';
+        return true;
+    case 'f':
+        x = '\f';
+        return true;
+    case '\\':
+    case '\'':
+    case '"':
+    case '$':
+        x = c;
+        return true;
+    case '0':
+        x = '\0';
+        return true;
+    case 'x':
+        return hexEscapeChar(x);
+    default:
+        return false;
     }
+}
 
-    //
-    // characters and strings
-    //
-
-    static bool hexEscapeChar(char &x) {
-        int digit1, digit2;
-        if (!hexDigit(digit1)) return false;
-        if (!hexDigit(digit2)) return false;
-        x = (char) (digit1 * 16 + digit2);
+static bool oneChar(char &x) {
+    const char *p = save();
+    if (escapeChar(x))
         return true;
-    }
+    restore(p);
+    if (!next(x))
+        return false;
+    if (x == '\\')
+        return false;
+    return true;
+}
 
-    static bool escapeChar(char &x) {
-        char c;
-        if (!next(c)) return false;
-        if (c != '\\') return false;
-        if (!next(c)) return false;
-        switch (c) {
-            case 'n': x = '\n';
-                return true;
-            case 'r': x = '\r';
-                return true;
-            case 't': x = '\t';
-                return true;
-            case 'f': x = '\f';
-                return true;
-            case '\\':
-            case '\'':
-            case '"':
-            case '$':
-                x = c;
-                return true;
-            case '0':
-                x = '\0';
-                return true;
-            case 'x':
-                return hexEscapeChar(x);
-            default: return false;
-        }
-    }
+static bool charToken(Token &x) {
+    char c;
+    if (!next(c) || (c != '\''))
+        return false;
+    const char *p = save();
+    if (next(c) && (c == '\''))
+        return false;
+    restore(p);
+    char v;
+    if (!oneChar(v))
+        return false;
+    if (!next(c) || (c != '\''))
+        return false;
+    x = Token(T_CHAR_LITERAL, llvm::StringRef(&v, 1));
+    return true;
+}
 
-    static bool oneChar(char &x) {
+static bool singleQuoteStringToken(Token &x) {
+    char c;
+    if (!next(c) || (c != '"'))
+        return false;
+    x.tokenKind = T_STRING_LITERAL;
+    x.str.clear();
+    while (true) {
         const char *p = save();
-        if (escapeChar(x)) return true;
+        if (next(c) && (c == '"'))
+            break;
         restore(p);
-        if (!next(x)) return false;
-        if (x == '\\') return false;
-        return true;
+        if (!oneChar(c))
+            return false;
+        x.str.push_back(c);
     }
+    return true;
+}
 
-    static bool charToken(Token &x) {
-        char c;
-        if (!next(c) || (c != '\'')) return false;
-        const char *p = save();
-        if (next(c) && (c == '\'')) return false;
+static bool stringToken(Token &x) {
+    const char *p = save();
+    char c;
+    if (!next(c) || (c != '"'))
+        return false;
+    if (!next(c) || (c != '"') || !next(c) || (c != '"')) {
         restore(p);
-        char v;
-        if (!oneChar(v)) return false;
-        if (!next(c) || (c != '\'')) return false;
-        x = Token(T_CHAR_LITERAL, llvm::StringRef(&v, 1));
-        return true;
+        return singleQuoteStringToken(x);
     }
-
-    static bool singleQuoteStringToken(Token &x) {
-        char c;
-        if (!next(c) || (c != '"')) return false;
-        x.tokenKind = T_STRING_LITERAL;
-        x.str.clear();
-        while (true) {
-            const char *p = save();
-            if (next(c) && (c == '"'))
+    x.tokenKind = T_STRING_LITERAL;
+    x.str.clear();
+    while (true) {
+        p = save();
+        if (next(c) && (c == '"') && next(c) && (c == '"') && next(c) &&
+            (c == '"')) {
+            const char *q = save();
+            if (!next(c) || c != '"') {
+                restore(q);
                 break;
-            restore(p);
-            if (!oneChar(c)) return false;
-            x.str.push_back(c);
+            }
         }
-        return true;
+
+        restore(p);
+        if (!oneChar(c))
+            return false;
+        x.str.push_back(c);
     }
+    return true;
+}
+
+//
+// integer tokens
+//
+
+static void optNumericSeparator() {
+    const char *p = save();
+    char c;
+    if (!next(c) || (c != '_'))
+        restore(p);
+}
 
-    static bool stringToken(Token &x) {
+static bool decimalDigits() {
+    int x;
+    while (true) {
+        optNumericSeparator();
         const char *p = save();
-        char c;
-        if (!next(c) || (c != '"')) return false;
-        if (!next(c) || (c != '"') || !next(c) || (c != '"')) {
+        if (!decimalDigit(x)) {
             restore(p);
-            return singleQuoteStringToken(x);
+            break;
         }
-        x.tokenKind = T_STRING_LITERAL;
-        x.str.clear();
-        while (true) {
-            p = save();
-            if (next(c) && (c == '"')
-                && next(c) && (c == '"')
-                && next(c) && (c == '"')) {
-                const char *q = save();
-                if (!next(c) || c != '"') {
-                    restore(q);
-                    break;
-                }
-            }
+    }
+    return true;
+}
 
+static bool hexDigits() {
+    int x;
+    while (true) {
+        optNumericSeparator();
+        const char *p = save();
+        if (!hexDigit(x)) {
             restore(p);
-            if (!oneChar(c)) return false;
-            x.str.push_back(c);
+            break;
         }
-        return true;
     }
+    return true;
+}
 
-    //
-    // integer tokens
-    //
+static bool hexInt() {
+    if (!str("0x"))
+        return false;
+    int x;
+    if (!hexDigit(x))
+        return false;
+    return hexDigits();
+}
 
-    static void optNumericSeparator() {
+static bool decimalInt() {
+    int x;
+    if (!decimalDigit(x))
+        return false;
+    while (true) {
+        optNumericSeparator();
         const char *p = save();
-        char c;
-        if (!next(c) || (c != '_'))
+        if (!decimalDigit(x)) {
             restore(p);
-    }
-
-    static bool decimalDigits() {
-        int x;
-        while (true) {
-            optNumericSeparator();
-            const char *p = save();
-            if (!decimalDigit(x)) {
-                restore(p);
-                break;
-            }
+            break;
         }
-        return true;
     }
+    return true;
+}
 
-    static bool hexDigits() {
-        int x;
-        while (true) {
-            optNumericSeparator();
-            const char *p = save();
-            if (!hexDigit(x)) {
-                restore(p);
-                break;
-            }
-        }
-        return true;
-    }
+static bool sign() {
+    char c;
+    if (!next(c))
+        return false;
+    return (c == '+') || (c == '-');
+}
 
-    static bool hexInt() {
-        if (!str("0x")) return false;
-        int x;
-        if (!hexDigit(x)) return false;
-        return hexDigits();
-    }
+static bool intToken(Token &x) {
+    const char *begin = save();
+    if (!sign())
+        restore(begin);
+    const char *p = save();
+    if (hexInt())
+        goto success;
+    restore(p);
+    if (decimalInt())
+        goto success;
+    return false;
+success:
+    const char *end = save();
+    x = Token(T_INT_LITERAL, llvm::StringRef(begin, (size_t)(end - begin)));
+    return true;
+}
 
-    static bool decimalInt() {
-        int x;
-        if (!decimalDigit(x)) return false;
-        while (true) {
-            optNumericSeparator();
-            const char *p = save();
-            if (!decimalDigit(x)) {
-                restore(p);
-                break;
-            }
-        }
-        return true;
-    }
+//
+// float tokens
+//
 
-    static bool sign() {
-        char c;
-        if (!next(c)) return false;
-        return (c == '+') || (c == '-');
-    }
-
-    static bool intToken(Token &x) {
-        const char *begin = save();
-        if (!sign()) restore(begin);
-        const char *p = save();
-        if (hexInt()) goto success;
-        restore(p);
-        if (decimalInt()) goto success;
+static bool exponentPart() {
+    char c;
+    if (!next(c))
         return false;
-    success :
-        const char *end = save();
-        x = Token(T_INT_LITERAL, llvm::StringRef(begin, (size_t) (end - begin)));
-        return true;
-    }
-
-    //
-    // float tokens
-    //
-
-    static bool exponentPart() {
-        char c;
-        if (!next(c)) return false;
-        if ((c != 'e') && (c != 'E')) return false;
-        const char *begin = save();
-        if (!sign()) restore(begin);
-        return decimalInt();
-    }
+    if ((c != 'e') && (c != 'E'))
+        return false;
+    const char *begin = save();
+    if (!sign())
+        restore(begin);
+    return decimalInt();
+}
 
-    static bool fractionalPart() {
-        char c;
-        if (!next(c) || (c != '.')) return false;
-        return decimalDigits();
-    }
+static bool fractionalPart() {
+    char c;
+    if (!next(c) || (c != '.'))
+        return false;
+    return decimalDigits();
+}
 
-    static bool hexExponentPart() {
-        char c;
-        if (!next(c)) return false;
-        if ((c != 'p') && (c != 'P')) return false;
-        const char *begin = save();
-        if (!sign()) restore(begin);
-        return decimalInt();
-    }
+static bool hexExponentPart() {
+    char c;
+    if (!next(c))
+        return false;
+    if ((c != 'p') && (c != 'P'))
+        return false;
+    const char *begin = save();
+    if (!sign())
+        restore(begin);
+    return decimalInt();
+}
 
-    static bool hexFractionalPart() {
-        char c;
-        if (!next(c) || (c != '.')) return false;
-        return hexDigits();
-    }
+static bool hexFractionalPart() {
+    char c;
+    if (!next(c) || (c != '.'))
+        return false;
+    return hexDigits();
+}
 
-    static bool floatToken(Token &x) {
-        const char *begin = save();
-        if (!sign()) restore(begin);
-        const char *afterSign = save();
-        if (hexInt()) {
+static bool floatToken(Token &x) {
+    const char *begin = save();
+    if (!sign())
+        restore(begin);
+    const char *afterSign = save();
+    if (hexInt()) {
+        const char *p = save();
+        if (hexFractionalPart()) {
+            if (!hexExponentPart())
+                return false;
+        } else {
+            restore(p);
+            if (!hexExponentPart())
+                return false;
+        }
+        const char *end = save();
+        x = Token(T_FLOAT_LITERAL,
+                  llvm::StringRef(begin, (size_t)(end - begin)));
+        return true;
+    } else {
+        restore(afterSign);
+        if (decimalInt()) {
             const char *p = save();
-            if (hexFractionalPart()) {
-                if (!hexExponentPart())
-                    return false;
+            if (fractionalPart()) {
+                p = save();
+                if (!exponentPart())
+                    restore(p);
             } else {
                 restore(p);
-                if (!hexExponentPart())
+                if (!exponentPart())
                     return false;
             }
             const char *end = save();
-            x = Token(T_FLOAT_LITERAL, llvm::StringRef(begin, (size_t) (end - begin)));
+            x = Token(T_FLOAT_LITERAL,
+                      llvm::StringRef(begin, (size_t)(end - begin)));
             return true;
-        } else {
-            restore(afterSign);
-            if (decimalInt()) {
-                const char *p = save();
-                if (fractionalPart()) {
-                    p = save();
-                    if (!exponentPart())
-                        restore(p);
-                } else {
-                    restore(p);
-                    if (!exponentPart())
-                        return false;
-                }
-                const char *end = save();
-                x = Token(T_FLOAT_LITERAL, llvm::StringRef(begin, (size_t) (end - begin)));
-                return true;
-            } else
-                return false;
-        }
+        } else
+            return false;
     }
+}
 
-    //
-    // space
-    //
+//
+// space
+//
 
-    bool isSpace(char c) {
-        return ((c == ' ') || (c == '\t') || (c == '\n') || (c == '\r') ||
-                (c == '\f') || (c == '\v'));
-    }
+bool isSpace(char c) {
+    return ((c == ' ') || (c == '\t') || (c == '\n') || (c == '\r') ||
+            (c == '\f') || (c == '\v'));
+}
 
-    static bool space(Token &x) {
-        char c;
-        if (!next(c) || !isSpace(c)) return false;
-        while (true) {
-            const char *p = save();
-            if (!next(c) || !isSpace(c)) {
-                restore(p);
-                break;
-            }
+static bool space(Token &x) {
+    char c;
+    if (!next(c) || !isSpace(c))
+        return false;
+    while (true) {
+        const char *p = save();
+        if (!next(c) || !isSpace(c)) {
+            restore(p);
+            break;
         }
-        x = Token(T_SPACE);
-        return true;
     }
+    x = Token(T_SPACE);
+    return true;
+}
 
-    //
-    // comments
-    //
-
-    static bool lineComment(Token &x) {
-        char c;
-        if (!next(c) || (c != '/')) return false;
-        if (!next(c) || (c != '/')) return false;
-        while (true) {
-            const char *p = save();
-            if (!next(c)) break;
-            if ((c == '\r') || (c == '\n')) {
-                restore(p);
-                break;
-            }
-        }
-        x = Token(T_LINE_COMMENT);
-        return true;
-    }
+//
+// comments
+//
 
-    static bool blockComment(Token &x) {
-        char c;
-        if (!next(c) || (c != '/')) return false;
-        if (!next(c) || (c != '*')) return false;
-        bool lastWasStar = false;
-        while (true) {
-            if (!next(c)) return false;
-            if (lastWasStar && (c == '/'))
-                break;
-            lastWasStar = (c == '*');
+static bool lineComment(Token &x) {
+    char c;
+    if (!next(c) || (c != '/'))
+        return false;
+    if (!next(c) || (c != '/'))
+        return false;
+    while (true) {
+        const char *p = save();
+        if (!next(c))
+            break;
+        if ((c == '\r') || (c == '\n')) {
+            restore(p);
+            break;
         }
-        x = Token(T_BLOCK_COMMENT);
-        return true;
     }
+    x = Token(T_LINE_COMMENT);
+    return true;
+}
 
-    //
-    // llvmToken
-    //
-    //  LLVMBody -> '__llvm__' ZeroPlus(Space) Braces
-    //
-    //  Braces -> '{' Body '}'
-    //
-    //  Body -> ZeroPlus(BodyItem)
-    //
-    //  BodyItem -> Comment
-    //            | Braces
-    //            | StringLiteral
-    //            | Not('}')
-    //
-    //  Comment -> ';' ZeroPlus(Not('\n')) '\n'
-    //
-    //  StringLiteral -> '"' ZeroPlus(StringChar) '"'
-    //
-    //  StringChar -> '\' AnyChar
-    //              | Not('"')
-    //
-
-    static bool llvmBraces();
-    static bool llvmBody();
-    static bool llvmBodyItem();
-    static bool llvmComment();
-    static bool llvmStringLiteral();
-    static bool llvmStringChar();
-
-    static bool llvmToken(Token &x) {
-        const char *prefix = "__llvm__";
-        while (*prefix) {
-            char c;
-            if (!next(c)) return false;
-            if (c != *prefix) return false;
-            ++prefix;
-        }
-        const char *p = save();
-        while (true) {
-            char c;
-            if (!next(c)) return false;
-            if (!isSpace(c))
-                break;
-            p = save();
-        }
-        restore(p);
-        const char *begin = save();
-        if (!llvmBraces()) return false;
-        const char *end = save();
-        x = Token(T_LLVM, llvm::StringRef(begin, (size_t) (end - begin)));
-        x.location = locationFor(begin);
-        return true;
+static bool blockComment(Token &x) {
+    char c;
+    if (!next(c) || (c != '/'))
+        return false;
+    if (!next(c) || (c != '*'))
+        return false;
+    bool lastWasStar = false;
+    while (true) {
+        if (!next(c))
+            return false;
+        if (lastWasStar && (c == '/'))
+            break;
+        lastWasStar = (c == '*');
     }
+    x = Token(T_BLOCK_COMMENT);
+    return true;
+}
 
-    static bool llvmBraces() {
+//
+// llvmToken
+//
+//  LLVMBody -> '__llvm__' ZeroPlus(Space) Braces
+//
+//  Braces -> '{' Body '}'
+//
+//  Body -> ZeroPlus(BodyItem)
+//
+//  BodyItem -> Comment
+//            | Braces
+//            | StringLiteral
+//            | Not('}')
+//
+//  Comment -> ';' ZeroPlus(Not('\n')) '\n'
+//
+//  StringLiteral -> '"' ZeroPlus(StringChar) '"'
+//
+//  StringChar -> '\' AnyChar
+//              | Not('"')
+//
+
+static bool llvmBraces();
+static bool llvmBody();
+static bool llvmBodyItem();
+static bool llvmComment();
+static bool llvmStringLiteral();
+static bool llvmStringChar();
+
+static bool llvmToken(Token &x) {
+    const char *prefix = "__llvm__";
+    while (*prefix) {
         char c;
-        if (!next(c) || (c != '{')) return false;
-        if (!llvmBody()) return false;
-        if (!next(c) || (c != '}')) return false;
-        return true;
+        if (!next(c))
+            return false;
+        if (c != *prefix)
+            return false;
+        ++prefix;
     }
-
-    static bool llvmBody() {
-        while (true) {
-            const char *p = save();
-            if (!llvmBodyItem()) {
-                restore(p);
-                break;
-            }
-        }
-        return true;
+    const char *p = save();
+    while (true) {
+        char c;
+        if (!next(c))
+            return false;
+        if (!isSpace(c))
+            break;
+        p = save();
     }
+    restore(p);
+    const char *begin = save();
+    if (!llvmBraces())
+        return false;
+    const char *end = save();
+    x = Token(T_LLVM, llvm::StringRef(begin, (size_t)(end - begin)));
+    x.location = locationFor(begin);
+    return true;
+}
 
-    static bool llvmBodyItem() {
-        const char *p = save();
-        if (llvmComment()) return true;
-        if (restore(p), llvmBraces()) return true;
-        if (restore(p), llvmStringLiteral()) return true;
-        char c;
-        if (restore(p), (next(c) && (c != '}'))) return true;
+static bool llvmBraces() {
+    char c;
+    if (!next(c) || (c != '{'))
         return false;
-    }
+    if (!llvmBody())
+        return false;
+    if (!next(c) || (c != '}'))
+        return false;
+    return true;
+}
 
-    static bool llvmComment() {
-        char c;
-        if (!next(c) || (c != ';')) return false;
-        while (next(c) && (c != '\n')) {
+static bool llvmBody() {
+    while (true) {
+        const char *p = save();
+        if (!llvmBodyItem()) {
+            restore(p);
+            break;
         }
-        return true;
     }
+    return true;
+}
 
-    static bool llvmStringLiteral() {
-        char c;
-        if (!next(c) || (c != '"')) return false;
-        while (true) {
-            const char *p = save();
-            if (!llvmStringChar()) {
-                restore(p);
-                break;
-            }
-        }
-        if (!next(c) || (c != '"')) return false;
+static bool llvmBodyItem() {
+    const char *p = save();
+    if (llvmComment())
         return true;
-    }
+    if (restore(p), llvmBraces())
+        return true;
+    if (restore(p), llvmStringLiteral())
+        return true;
+    char c;
+    if (restore(p), (next(c) && (c != '}')))
+        return true;
+    return false;
+}
 
-    static bool llvmStringChar() {
-        char c;
-        if (!next(c)) return false;
-        if (c == '\\')
-            return next(c);
-        return c != '"';
+static bool llvmComment() {
+    char c;
+    if (!next(c) || (c != ';'))
+        return false;
+    while (next(c) && (c != '\n')) {
     }
+    return true;
+}
 
-    //
-    // static index
-    //
-
-    static bool staticIndex(Token &x) {
-        char c;
-        if (!next(c)) return false;
-        if (c != '.') return false;
-
-        const char *begin = save();
-        if (hexInt()) {
-            const char *end = save();
-            x = Token(T_STATIC_INDEX, llvm::StringRef(begin, (size_t) (end - begin)));
-            return true;
-        } else {
-            restore(begin);
-            if (decimalInt()) {
-                const char *end = save();
-                x = Token(T_STATIC_INDEX, llvm::StringRef(begin, (size_t) (end - begin)));
-                return true;
-            } else
-                return false;
+static bool llvmStringLiteral() {
+    char c;
+    if (!next(c) || (c != '"'))
+        return false;
+    while (true) {
+        const char *p = save();
+        if (!llvmStringChar()) {
+            restore(p);
+            break;
         }
     }
+    if (!next(c) || (c != '"'))
+        return false;
+    return true;
+}
 
-    //
-    // nextToken
-    //
+static bool llvmStringChar() {
+    char c;
+    if (!next(c))
+        return false;
+    if (c == '\\')
+        return next(c);
+    return c != '"';
+}
 
-    static bool docStartLine(Token &x);
-    static bool docStartBlock(Token &x);
+//
+// static index
+//
 
-    static bool nextToken(Token &x) {
-        x = Token();
-        const char *p = save();
-        if (space(x)) goto success;
-        restore(p);
-        if (docStartLine(x)) goto success;
-        restore(p);
-        if (docStartBlock(x)) goto success;
-        restore(p);
-        if (lineComment(x)) goto success;
-        restore(p);
-        if (blockComment(x)) goto success;
-        restore(p);
-        if (staticIndex(x)) goto success;
-        restore(p);
-        if (opIdentifier(x)) goto success;
-        restore(p);
-        if (symbol(x)) goto success;
-        restore(p);
-        if (op(x)) goto success;
-        restore(p);
-        if (llvmToken(x)) goto success;
-        restore(p);
-        if (keywordIdentifier(x)) goto success;
-        restore(p);
-        if (charToken(x)) goto success;
-        restore(p);
-        if (stringToken(x)) goto success;
-        restore(p);
-        if (floatToken(x)) goto success;
-        restore(p);
-        if (intToken(x)) goto success;
-        if (p != end) {
-            pushLocation(locationFor(p));
-            error("invalid token");
-        }
+static bool staticIndex(Token &x) {
+    char c;
+    if (!next(c))
+        return false;
+    if (c != '.')
         return false;
-    success :
-        assert(x.tokenKind != T_NONE);
-        if (!x.location.ok())
-            x.location = locationFor(p);
+
+    const char *begin = save();
+    if (hexInt()) {
+        const char *end = save();
+        x = Token(T_STATIC_INDEX,
+                  llvm::StringRef(begin, (size_t)(end - begin)));
         return true;
+    } else {
+        restore(begin);
+        if (decimalInt()) {
+            const char *end = save();
+            x = Token(T_STATIC_INDEX,
+                      llvm::StringRef(begin, (size_t)(end - begin)));
+            return true;
+        } else
+            return false;
     }
+}
 
-    //
-    // documentation
-    //
+//
+// nextToken
+//
+
+static bool docStartLine(Token &x);
+static bool docStartBlock(Token &x);
+
+static bool nextToken(Token &x) {
+    x = Token();
+    const char *p = save();
+    if (space(x))
+        goto success;
+    restore(p);
+    if (docStartLine(x))
+        goto success;
+    restore(p);
+    if (docStartBlock(x))
+        goto success;
+    restore(p);
+    if (lineComment(x))
+        goto success;
+    restore(p);
+    if (blockComment(x))
+        goto success;
+    restore(p);
+    if (staticIndex(x))
+        goto success;
+    restore(p);
+    if (opIdentifier(x))
+        goto success;
+    restore(p);
+    if (symbol(x))
+        goto success;
+    restore(p);
+    if (op(x))
+        goto success;
+    restore(p);
+    if (llvmToken(x))
+        goto success;
+    restore(p);
+    if (keywordIdentifier(x))
+        goto success;
+    restore(p);
+    if (charToken(x))
+        goto success;
+    restore(p);
+    if (stringToken(x))
+        goto success;
+    restore(p);
+    if (floatToken(x))
+        goto success;
+    restore(p);
+    if (intToken(x))
+        goto success;
+    if (p != end) {
+        pushLocation(locationFor(p));
+        error("invalid token");
+    }
+    return false;
+success:
+    assert(x.tokenKind != T_NONE);
+    if (!x.location.ok())
+        x.location = locationFor(p);
+    return true;
+}
 
-    static bool docIsBlock = false;
+//
+// documentation
+//
 
-    static bool docStartLine(Token &x) {
-        char c;
-        if (!next(c) || (c != '/')) return false;
-        if (!next(c) || (c != '/')) return false;
-        if (!next(c) || (c != '/')) return false;
-        x = Token(T_DOC_START);
-        docIsBlock = false;
-        return true;
-    }
+static bool docIsBlock = false;
 
-    static bool docStartBlock(Token &x) {
-        char c;
-        if (!next(c) || (c != '/')) return false;
-        if (!next(c) || (c != '*')) return false;
-        if (!next(c) || (c != '*')) return false;
+static bool docStartLine(Token &x) {
+    char c;
+    if (!next(c) || (c != '/'))
+        return false;
+    if (!next(c) || (c != '/'))
+        return false;
+    if (!next(c) || (c != '/'))
+        return false;
+    x = Token(T_DOC_START);
+    docIsBlock = false;
+    return true;
+}
 
-        docIsBlock = true;
-        x = Token(T_DOC_START);
-        return true;
-    }
+static bool docStartBlock(Token &x) {
+    char c;
+    if (!next(c) || (c != '/'))
+        return false;
+    if (!next(c) || (c != '*'))
+        return false;
+    if (!next(c) || (c != '*'))
+        return false;
 
-    static bool docEndLine(Token &x) {
-        char c;
-        if (!next(c)) return false;
+    docIsBlock = true;
+    x = Token(T_DOC_START);
+    return true;
+}
 
-        if ((c == '\r') || (c == '\n')) {
-            x = Token(T_DOC_END);
-            return true;
-        }
+static bool docEndLine(Token &x) {
+    char c;
+    if (!next(c))
         return false;
-    }
 
-    static bool docEndBlock(Token &x) {
-        char c;
-        do {
-            if (!next(c)) return false;
-        } while (c == '*');
-        if (c != '/') return false;
+    if ((c == '\r') || (c == '\n')) {
         x = Token(T_DOC_END);
         return true;
     }
+    return false;
+}
 
-    static bool docProperty(Token &x) {
-        char c;
-        if (!next(c)) return false;
-        while (isSpace(c))
-            if (!next(c))
-                break;
-        if (c != '@') return false;
+static bool docEndBlock(Token &x) {
+    char c;
+    do {
+        if (!next(c))
+            return false;
+    } while (c == '*');
+    if (c != '/')
+        return false;
+    x = Token(T_DOC_END);
+    return true;
+}
 
-        const char *begin = save();
-        while (!isSpace(c))
-            if (!next(c)) return false;
+static bool docProperty(Token &x) {
+    char c;
+    if (!next(c))
+        return false;
+    while (isSpace(c))
+        if (!next(c))
+            break;
+    if (c != '@')
+        return false;
 
-        const char *end = save();
-        x = Token(T_DOC_PROPERTY, llvm::StringRef(begin, (size_t) (end - begin - 1)));
-        x.location = locationFor(begin);
-        return true;
-    }
+    const char *begin = save();
+    while (!isSpace(c))
+        if (!next(c))
+            return false;
 
-    static bool maybeDocEnd() {
-        char c = '*';
-        while (c == '*')
-            if (!next(c))
-                return false;
-        return (c == '/');
-    }
+    const char *end = save();
+    x = Token(T_DOC_PROPERTY,
+              llvm::StringRef(begin, (size_t)(end - begin - 1)));
+    x.location = locationFor(begin);
+    return true;
+}
 
-    static bool docText(Token &x) {
-        const char *begin = save();
-        char c;
-        if (!next(c)) return false;
+static bool maybeDocEnd() {
+    char c = '*';
+    while (c == '*')
+        if (!next(c))
+            return false;
+    return (c == '/');
+}
 
-        const char *end = begin;
-        for (;;) {
-            end = save();
-            if (!next(c)) return false;
-            if (c == '\n' || c == '\r') {
+static bool docText(Token &x) {
+    const char *begin = save();
+    char c;
+    if (!next(c))
+        return false;
+
+    const char *end = begin;
+    for (;;) {
+        end = save();
+        if (!next(c))
+            return false;
+        if (c == '\n' || c == '\r') {
+            restore(end);
+            break;
+        }
+        end = save();
+        if (docIsBlock && (c == '*')) {
+            if (maybeDocEnd()) {
                 restore(end);
                 break;
-            }
-            end = save();
-            if (docIsBlock && (c == '*')) {
-                if (maybeDocEnd()) {
-                    restore(end);
-                    break;
-                } else {
-                    restore(end);
-                }
+            } else {
+                restore(end);
             }
         }
-        x = Token(T_DOC_TEXT, llvm::StringRef(begin, (size_t) (end - begin)));
-        return true;
     }
+    x = Token(T_DOC_TEXT, llvm::StringRef(begin, (size_t)(end - begin)));
+    return true;
+}
 
-    static bool docSpace() {
-        char c;
-        if (!next(c)) return false;
-        if (!docIsBlock && (c == '\n' || c == '\r'))
-            return false;
-        else if (isSpace(c))
-            return true;
-        else if (docIsBlock && c == '*') {
-            const char *p = save();
-            if (!next(c))
-                return true;
-            if (c == '/') {
-                return false;
-            }
-            restore(p);
+static bool docSpace() {
+    char c;
+    if (!next(c))
+        return false;
+    if (!docIsBlock && (c == '\n' || c == '\r'))
+        return false;
+    else if (isSpace(c))
+        return true;
+    else if (docIsBlock && c == '*') {
+        const char *p = save();
+        if (!next(c))
             return true;
+        if (c == '/') {
+            return false;
         }
-        return false;
+        restore(p);
+        return true;
     }
+    return false;
+}
 
-    static bool nextDocToken(Token &x) {
-        x = Token();
-        const char *p = save();
+static bool nextDocToken(Token &x) {
+    x = Token();
+    const char *p = save();
 
-        for (;;) {
-            p = save();
-            if (!docSpace()) {
-                restore(p);
-                break;
-            }
+    for (;;) {
+        p = save();
+        if (!docSpace()) {
+            restore(p);
+            break;
         }
+    }
 
-        if (docIsBlock) {
-            if (docEndBlock(x)) goto success;
-        } else {
-            if (docEndLine(x)) goto success;
-        }
+    if (docIsBlock) {
+        if (docEndBlock(x))
+            goto success;
+    } else {
+        if (docEndLine(x))
+            goto success;
+    }
 
-        restore(p);
-        if (docProperty(x)) goto success;
-        restore(p);
-        if (docText(x)) goto success;
-        if (p != end) {
-            pushLocation(locationFor(p));
-            error("invalid doc token");
-        }
-        return false;
-    success :
-        assert(x.tokenKind != T_NONE);
-        if (!x.location.ok())
-            x.location = locationFor(p);
-        return true;
+    restore(p);
+    if (docProperty(x))
+        goto success;
+    restore(p);
+    if (docText(x))
+        goto success;
+    if (p != end) {
+        pushLocation(locationFor(p));
+        error("invalid doc token");
     }
+    return false;
+success:
+    assert(x.tokenKind != T_NONE);
+    if (!x.location.ok())
+        x.location = locationFor(p);
+    return true;
 }
+} // namespace clay
diff --git a/compiler/lexer.hpp b/compiler/lexer.hpp
index 0b74db53..bc7e1442 100644
--- a/compiler/lexer.hpp
+++ b/compiler/lexer.hpp
@@ -3,52 +3,50 @@
 #include "clay.hpp"
 
 namespace clay {
-    //
-    // Token
-    //
-
-    enum TokenKind {
-        T_NONE,
-        T_UOPSTRING,
-        T_OPSTRING,
-        T_SYMBOL,
-        T_KEYWORD,
-        T_IDENTIFIER,
-        T_OPIDENTIFIER,
-        T_STRING_LITERAL,
-        T_CHAR_LITERAL,
-        T_INT_LITERAL,
-        T_FLOAT_LITERAL,
-        T_STATIC_INDEX,
-        T_SPACE,
-        T_LINE_COMMENT,
-        T_BLOCK_COMMENT,
-        T_LLVM,
-        T_DOC_START,
-        T_DOC_PROPERTY,
-        T_DOC_TEXT,
-        T_DOC_END
-    };
-
-    struct Token {
-        Location location;
-        llvm::SmallString<16> str;
-        TokenKind tokenKind;
-
-        Token() : tokenKind(T_NONE) {
-        }
-
-        explicit Token(TokenKind tokenKind) : tokenKind(tokenKind) {
-        }
-
-        explicit Token(TokenKind tokenKind, llvm::StringRef str) : str(str), tokenKind(tokenKind) {
-        }
-    };
-
-    void tokenize(SourcePtr source, vector<Token> &tokens);
-
-    void tokenize(SourcePtr source, unsigned offset, size_t length,
-                  vector<Token> &tokens);
-
-    bool isSpace(char c);
-}
+//
+// Token
+//
+
+enum TokenKind {
+    T_NONE,
+    T_UOPSTRING,
+    T_OPSTRING,
+    T_SYMBOL,
+    T_KEYWORD,
+    T_IDENTIFIER,
+    T_OPIDENTIFIER,
+    T_STRING_LITERAL,
+    T_CHAR_LITERAL,
+    T_INT_LITERAL,
+    T_FLOAT_LITERAL,
+    T_STATIC_INDEX,
+    T_SPACE,
+    T_LINE_COMMENT,
+    T_BLOCK_COMMENT,
+    T_LLVM,
+    T_DOC_START,
+    T_DOC_PROPERTY,
+    T_DOC_TEXT,
+    T_DOC_END
+};
+
+struct Token {
+    Location location;
+    llvm::SmallString<16> str;
+    TokenKind tokenKind;
+
+    Token() : tokenKind(T_NONE) {}
+
+    explicit Token(TokenKind tokenKind) : tokenKind(tokenKind) {}
+
+    explicit Token(TokenKind tokenKind, llvm::StringRef str)
+        : str(str), tokenKind(tokenKind) {}
+};
+
+void tokenize(SourcePtr source, vector<Token> &tokens);
+
+void tokenize(SourcePtr source, unsigned offset, size_t length,
+              vector<Token> &tokens);
+
+bool isSpace(char c);
+} // namespace clay
diff --git a/compiler/literals.cpp b/compiler/literals.cpp
index f862216e..887dd55c 100644
--- a/compiler/literals.cpp
+++ b/compiler/literals.cpp
@@ -1,366 +1,366 @@
 #include "clay.hpp"
-#include "types.hpp"
-#include "objects.hpp"
 #include "error.hpp"
 #include "int128.hpp"
+#include "objects.hpp"
+#include "types.hpp"
 
 namespace clay {
-    static bool ishex(char *ptr) {
-        return
-                ((ptr[0] == '+' || ptr[0] == '-')
-                 && ptr[1] == '0'
-                 && (ptr[2] == 'x' || ptr[2] == 'X'))
-                || (ptr[0] == '0' && (ptr[1] == 'x' || ptr[1] == 'X'));
-    }
+static bool ishex(char *ptr) {
+    return ((ptr[0] == '+' || ptr[0] == '-') && ptr[1] == '0' &&
+            (ptr[2] == 'x' || ptr[2] == 'X')) ||
+           (ptr[0] == '0' && (ptr[1] == 'x' || ptr[1] == 'X'));
+}
 
-    static int bitcount(unsigned long long bits) {
-        int k = 0;
-        while (bits != 0) {
-            k += 1;
-            bits = bits >> 1;
-        }
-        return k - 1;
+static int bitcount(unsigned long long bits) {
+    int k = 0;
+    while (bits != 0) {
+        k += 1;
+        bits = bits >> 1;
     }
+    return k - 1;
+}
 
-    static int hexdigit(char c) {
-        if (c >= '0' && c <= '9')
-            return c - '0';
-        if (c >= 'A' && c <= 'F')
-            return c - 'A' + 10;
-        if (c >= 'a' && c <= 'f')
-            return c - 'a' + 10;
-        assert(false);
-        return 0;
-    }
+static int hexdigit(char c) {
+    if (c >= '0' && c <= '9')
+        return c - '0';
+    if (c >= 'A' && c <= 'F')
+        return c - 'A' + 10;
+    if (c >= 'a' && c <= 'f')
+        return c - 'a' + 10;
+    assert(false);
+    return 0;
+}
 
-    static double floatFromParts(bool negp, int exponent, unsigned long long mantissa) {
-        union {
-            double f;
-            unsigned long long bits;
-        } x;
-        x.bits = ((unsigned long long) negp << 63)
-                 | ((unsigned long long) (exponent & 0x7FF) << 52)
-                 | (mantissa & 0xFFFFFFFFFFFFFULL);
-        return x.f;
-    }
+static double floatFromParts(bool negp, int exponent,
+                             unsigned long long mantissa) {
+    union {
+        double f;
+        unsigned long long bits;
+    } x;
+    x.bits = ((unsigned long long)negp << 63) |
+             ((unsigned long long)(exponent & 0x7FF) << 52) |
+             (mantissa & 0xFFFFFFFFFFFFFULL);
+    return x.f;
+}
 
-    template<typename F>
-    static F parseHexFloat(char *number, char **end) {
-        bool negp = false;
-        unsigned long long mantissa = 0;
-        int mantissaBits = 0;
-        int usedMantissaBits = 0;
-        size_t exponentI = 0;
-        int point = 0;
-        int pointp = false;
+template <typename F> static F parseHexFloat(char *number, char **end) {
+    bool negp = false;
+    unsigned long long mantissa = 0;
+    int mantissaBits = 0;
+    int usedMantissaBits = 0;
+    size_t exponentI = 0;
+    int point = 0;
+    int pointp = false;
 
-        for (size_t i = 0; number[i] != '\0'; ++i) {
-            char c = number[i];
+    for (size_t i = 0; number[i] != '\0'; ++i) {
+        char c = number[i];
 
-            if (c == '-') {
-                assert(i == 0); // "junk before negative sign in hex float literal"
-                negp = true;
-            } else if (c == '+') {
-                assert(i == 0); // "junk before positive sign in hex float literal"
-                negp = false;
-            } else if (c == '.') {
-                assert(!pointp); // "multiple decimal points in hex float literal"
-                pointp = true;
-            } else if (c == 'p' || c == 'P') {
-                assert(exponentI == 0); // "multiple P markers in hex float literal"
-                exponentI = i;
-                break;
-            } else if (c == 'x') {
-                assert(mantissa == 0); // "junk before hex designator in hex float literal"
+        if (c == '-') {
+            assert(i == 0); // "junk before negative sign in hex float literal"
+            negp = true;
+        } else if (c == '+') {
+            assert(i == 0); // "junk before positive sign in hex float literal"
+            negp = false;
+        } else if (c == '.') {
+            assert(!pointp); // "multiple decimal points in hex float literal"
+            pointp = true;
+        } else if (c == 'p' || c == 'P') {
+            assert(exponentI == 0); // "multiple P markers in hex float literal"
+            exponentI = i;
+            break;
+        } else if (c == 'x') {
+            assert(mantissa ==
+                   0); // "junk before hex designator in hex float literal"
+            continue;
+        } else {
+            if (pointp)
+                point += 4;
+            if (c == '0' && mantissa == 0)
                 continue;
-            } else {
-                if (pointp)
-                    point += 4;
-                if (c == '0' && mantissa == 0)
-                    continue;
-                mantissaBits += 4;
-                if (c != '0')
-                    usedMantissaBits = mantissaBits;
-                if (mantissaBits <= 64)
-                    mantissa = (mantissa << 4) | unsigned(hexdigit(c));
-            }
+            mantissaBits += 4;
+            if (c != '0')
+                usedMantissaBits = mantissaBits;
+            if (mantissaBits <= 64)
+                mantissa = (mantissa << 4) | unsigned(hexdigit(c));
         }
+    }
 
-        assert(number[exponentI] == 'p' || number[exponentI] == 'P'); // "no exponent in hex float literal"
-
-        long exponent = strtol(number + exponentI + 1, end, 10);
-        assert(**end == '\0'); // "junk after exponent in hex float literal"
-        double value = 0.0;
+    assert(number[exponentI] == 'p' ||
+           number[exponentI] == 'P'); // "no exponent in hex float literal"
 
-        if (mantissa == 0) {
-            value = floatFromParts(negp, 0, 0);
-        } else {
-            int mantissaLog = bitcount(mantissa);
-            int mantissaExponent = mantissaLog
-                                   + (mantissaBits > 64 ? mantissaBits - 64 : 0)
-                                   - point
-                                   + int(exponent)
-                                   + 1023;
+    long exponent = strtol(number + exponentI + 1, end, 10);
+    assert(**end == '\0'); // "junk after exponent in hex float literal"
+    double value = 0.0;
 
-            mantissa = mantissa << (60 - mantissaLog);
-            int mantissaShift = 8 + std::max(0, 1 - mantissaExponent);
+    if (mantissa == 0) {
+        value = floatFromParts(negp, 0, 0);
+    } else {
+        int mantissaLog = bitcount(mantissa);
+        int mantissaExponent = mantissaLog +
+                               (mantissaBits > 64 ? mantissaBits - 64 : 0) -
+                               point + int(exponent) + 1023;
 
-            if (mantissaShift > 61) {
-                mantissaExponent = 0;
-                mantissa = 0;
-            } else if (mantissaExponent >= 2047) {
-                mantissaExponent = 2047;
-                mantissa = 0;
-            } else {
-                unsigned long long roundBit = mantissa & (1ULL << (mantissaShift - 1));
-                unsigned long long roundMask = mantissa & ((1ULL << (mantissaShift - 1)) - 1);
-                unsigned long long evenBit = mantissa & (1ULL << mantissaShift);
+        mantissa = mantissa << (60 - mantissaLog);
+        int mantissaShift = 8 + std::max(0, 1 - mantissaExponent);
 
-                mantissa = mantissa >> mantissaShift;
+        if (mantissaShift > 61) {
+            mantissaExponent = 0;
+            mantissa = 0;
+        } else if (mantissaExponent >= 2047) {
+            mantissaExponent = 2047;
+            mantissa = 0;
+        } else {
+            unsigned long long roundBit =
+                mantissa & (1ULL << (mantissaShift - 1));
+            unsigned long long roundMask =
+                mantissa & ((1ULL << (mantissaShift - 1)) - 1);
+            unsigned long long evenBit = mantissa & (1ULL << mantissaShift);
 
-                if (roundBit != 0 && (roundMask != 0 || usedMantissaBits > 60 || evenBit != 0))
-                    mantissa += 1;
+            mantissa = mantissa >> mantissaShift;
 
-                if (mantissaExponent < 0)
-                    mantissaExponent = 0;
-            }
+            if (roundBit != 0 &&
+                (roundMask != 0 || usedMantissaBits > 60 || evenBit != 0))
+                mantissa += 1;
 
-            value = floatFromParts(negp, mantissaExponent, mantissa);
+            if (mantissaExponent < 0)
+                mantissaExponent = 0;
         }
 
-        return value;
+        value = floatFromParts(negp, mantissaExponent, mantissa);
     }
 
-    static double clay_strtod(char *ptr, char **end) {
-        if (ishex(ptr))
-            return parseHexFloat<double>(ptr, end);
-        else
-            return strtod(ptr, end);
-    }
+    return value;
+}
 
-    static long double clay_strtold(char *ptr, char **end) {
-        // XXX parse hex long doubles
-        return strtold(ptr, end);
-    }
+static double clay_strtod(char *ptr, char **end) {
+    if (ishex(ptr))
+        return parseHexFloat<double>(ptr, end);
+    else
+        return strtod(ptr, end);
+}
+
+static long double clay_strtold(char *ptr, char **end) {
+    // XXX parse hex long doubles
+    return strtold(ptr, end);
+}
+
+static bool typeSuffix(llvm::StringRef suffix, TypePtr defaultType,
+                       llvm::StringRef testSuffix, TypePtr testDefaultType) {
+    return suffix == testSuffix ||
+           (suffix.empty() && defaultType == testDefaultType);
+}
 
-    static bool typeSuffix(llvm::StringRef suffix,
-                           TypePtr defaultType,
+static bool imagTypeSuffix(llvm::StringRef suffix, TypePtr defaultType,
                            llvm::StringRef testSuffix,
                            TypePtr testDefaultType) {
-        return suffix == testSuffix || (suffix.empty() && defaultType == testDefaultType);
-    }
-
-    static bool imagTypeSuffix(llvm::StringRef suffix,
-                               TypePtr defaultType,
-                               llvm::StringRef testSuffix,
-                               TypePtr testDefaultType) {
-        return suffix == testSuffix || (suffix == "j" && defaultType == testDefaultType);
-    }
+    return suffix == testSuffix ||
+           (suffix == "j" && defaultType == testDefaultType);
+}
 
-    ValueHolderPtr parseIntLiteral(ModulePtr module, IntLiteral *x) {
-        TypePtr defaultType = module->attrDefaultIntegerType.ptr();
-        if (defaultType == nullptr)
-            defaultType = int32Type;
+ValueHolderPtr parseIntLiteral(ModulePtr module, IntLiteral *x) {
+    TypePtr defaultType = module->attrDefaultIntegerType.ptr();
+    if (defaultType == nullptr)
+        defaultType = int32Type;
 
-        char *ptr = const_cast<char *>(x->value.c_str());
-        char *end = ptr;
-        int base = ishex(ptr) ? 16 : 10;
-        ValueHolderPtr vh;
-        if (typeSuffix(x->suffix, defaultType, "ss", int8Type)) {
-            long y = strtol(ptr, &end, base);
-            if (*end != 0)
-                error("invalid int8 literal");
-            if ((errno == ERANGE) || (y < SCHAR_MIN) || (y > SCHAR_MAX))
-                error("int8 literal out of range");
-            vh = new ValueHolder(int8Type);
-            *((char *) vh->buf) = (char) y;
-        } else if (typeSuffix(x->suffix, defaultType, "s", int16Type)) {
-            long y = strtol(ptr, &end, base);
-            if (*end != 0)
-                error("invalid int16 literal");
-            if ((errno == ERANGE) || (y < SHRT_MIN) || (y > SHRT_MAX))
-                error("int16 literal out of range");
-            vh = new ValueHolder(int16Type);
-            *((short *) vh->buf) = (short) y;
-        } else if (typeSuffix(x->suffix, defaultType, "i", int32Type)) {
-            long y = strtol(ptr, &end, base);
-            if (*end != 0)
-                error("invalid int32 literal");
-            if (errno == ERANGE || (y < INT_MIN) || (y > INT_MAX))
-                error("int32 literal out of range");
-            vh = new ValueHolder(int32Type);
-            *((int *) vh->buf) = (int) y;
-        } else if (typeSuffix(x->suffix, defaultType, "l", int64Type)) {
-            long long y = strtoll(ptr, &end, base);
-            if (*end != 0)
-                error("invalid int64 literal");
-            if (errno == ERANGE)
-                error("int64 literal out of range");
-            vh = new ValueHolder(int64Type);
-            *((long long *) vh->buf) = y;
-        } else if (typeSuffix(x->suffix, defaultType, "ll", int128Type)) {
-            long long y = strtoll(ptr, &end, base);
-            if (*end != 0)
-                error("invalid int128 literal");
-            if (errno == ERANGE)
-                error("int128 literal out of range");
-            vh = new ValueHolder(int128Type);
-            *((clay_int128 *) vh->buf) = y;
-        } else if (typeSuffix(x->suffix, defaultType, "uss", uint8Type)) {
-            unsigned long y = strtoul(ptr, &end, base);
-            if (*end != 0)
-                error("invalid uint8 literal");
-            if ((errno == ERANGE) || (y > UCHAR_MAX))
-                error("uint8 literal out of range");
-            vh = new ValueHolder(uint8Type);
-            *((unsigned char *) vh->buf) = (unsigned char) y;
-        } else if (typeSuffix(x->suffix, defaultType, "us", uint16Type)) {
-            unsigned long y = strtoul(ptr, &end, base);
-            if (*end != 0)
-                error("invalid uint16 literal");
-            if ((errno == ERANGE) || (y > USHRT_MAX))
-                error("uint16 literal out of range");
-            vh = new ValueHolder(uint16Type);
-            *((unsigned short *) vh->buf) = (unsigned short) y;
-        } else if (typeSuffix(x->suffix, defaultType, "u", uint32Type)) {
-            unsigned long y = strtoul(ptr, &end, base);
-            if (*end != 0)
-                error("invalid uint32 literal");
-            if (errno == ERANGE)
-                error("uint32 literal out of range");
-            vh = new ValueHolder(uint32Type);
-            *((unsigned int *) vh->buf) = (unsigned int) y;
-        } else if (typeSuffix(x->suffix, defaultType, "ul", uint64Type)) {
-            unsigned long long y = strtoull(ptr, &end, base);
-            if (*end != 0)
-                error("invalid uint64 literal");
-            if (errno == ERANGE)
-                error("uint64 literal out of range");
-            vh = new ValueHolder(uint64Type);
-            *((unsigned long long *) vh->buf) = y;
-        } else if (typeSuffix(x->suffix, defaultType, "ull", uint128Type)) {
-            unsigned long long y = strtoull(ptr, &end, base);
-            if (*end != 0)
-                error("invalid uint128 literal");
-            if (errno == ERANGE)
-                error("uint128 literal out of range");
-            vh = new ValueHolder(uint128Type);
-            *((clay_uint128 *) vh->buf) = y;
-        } else if (x->suffix == "f") {
-            float y = (float) clay_strtod(ptr, &end);
-            if (*end != 0)
-                error("invalid float32 literal");
-            if (errno == ERANGE)
-                error("float32 literal out of range");
-            vh = new ValueHolder(float32Type);
-            *((float *) vh->buf) = y;
-        } else if (x->suffix == "ff") {
-            double y = clay_strtod(ptr, &end);
-            if (*end != 0)
-                error("invalid float64 literal");
-            if (errno == ERANGE)
-                error("float64 literal out of range");
-            vh = new ValueHolder(float64Type);
-            *((double *) vh->buf) = y;
-        } else if (x->suffix == "fl") {
-            long double y = clay_strtold(ptr, &end);
-            if (*end != 0)
-                error("invalid float80 literal");
-            if (errno == ERANGE)
-                error("float80 literal out of range");
-            vh = new ValueHolder(float80Type);
-            *((long double *) vh->buf) = y;
-        } else if (x->suffix == "fj") {
-            float y = (float) clay_strtod(ptr, &end);
-            if (*end != 0)
-                error("invalid imag32 literal");
-            if (errno == ERANGE)
-                error("imag32 literal out of range");
-            vh = new ValueHolder(imag32Type);
-            *((float *) vh->buf) = y;
-        } else if (x->suffix == "j" || x->suffix == "ffj") {
-            double y = clay_strtod(ptr, &end);
-            if (*end != 0)
-                error("invalid imag64 literal");
-            if (errno == ERANGE)
-                error("imag64 literal out of range");
-            vh = new ValueHolder(imag64Type);
-            *((double *) vh->buf) = y;
-        } else if (x->suffix == "lj" || x->suffix == "flj") {
-            long double y = clay_strtold(ptr, &end);
-            if (*end != 0)
-                error("invalid imag80 literal");
-            if (errno == ERANGE)
-                error("imag80 literal out of range");
-            vh = new ValueHolder(imag80Type);
-            *((long double *) vh->buf) = y;
-        } else {
-            error("invalid literal suffix: " + x->suffix);
-        }
-        return vh;
+    char *ptr = const_cast<char *>(x->value.c_str());
+    char *end = ptr;
+    int base = ishex(ptr) ? 16 : 10;
+    ValueHolderPtr vh;
+    if (typeSuffix(x->suffix, defaultType, "ss", int8Type)) {
+        long y = strtol(ptr, &end, base);
+        if (*end != 0)
+            error("invalid int8 literal");
+        if ((errno == ERANGE) || (y < SCHAR_MIN) || (y > SCHAR_MAX))
+            error("int8 literal out of range");
+        vh = new ValueHolder(int8Type);
+        *((char *)vh->buf) = (char)y;
+    } else if (typeSuffix(x->suffix, defaultType, "s", int16Type)) {
+        long y = strtol(ptr, &end, base);
+        if (*end != 0)
+            error("invalid int16 literal");
+        if ((errno == ERANGE) || (y < SHRT_MIN) || (y > SHRT_MAX))
+            error("int16 literal out of range");
+        vh = new ValueHolder(int16Type);
+        *((short *)vh->buf) = (short)y;
+    } else if (typeSuffix(x->suffix, defaultType, "i", int32Type)) {
+        long y = strtol(ptr, &end, base);
+        if (*end != 0)
+            error("invalid int32 literal");
+        if (errno == ERANGE || (y < INT_MIN) || (y > INT_MAX))
+            error("int32 literal out of range");
+        vh = new ValueHolder(int32Type);
+        *((int *)vh->buf) = (int)y;
+    } else if (typeSuffix(x->suffix, defaultType, "l", int64Type)) {
+        long long y = strtoll(ptr, &end, base);
+        if (*end != 0)
+            error("invalid int64 literal");
+        if (errno == ERANGE)
+            error("int64 literal out of range");
+        vh = new ValueHolder(int64Type);
+        *((long long *)vh->buf) = y;
+    } else if (typeSuffix(x->suffix, defaultType, "ll", int128Type)) {
+        long long y = strtoll(ptr, &end, base);
+        if (*end != 0)
+            error("invalid int128 literal");
+        if (errno == ERANGE)
+            error("int128 literal out of range");
+        vh = new ValueHolder(int128Type);
+        *((clay_int128 *)vh->buf) = y;
+    } else if (typeSuffix(x->suffix, defaultType, "uss", uint8Type)) {
+        unsigned long y = strtoul(ptr, &end, base);
+        if (*end != 0)
+            error("invalid uint8 literal");
+        if ((errno == ERANGE) || (y > UCHAR_MAX))
+            error("uint8 literal out of range");
+        vh = new ValueHolder(uint8Type);
+        *((unsigned char *)vh->buf) = (unsigned char)y;
+    } else if (typeSuffix(x->suffix, defaultType, "us", uint16Type)) {
+        unsigned long y = strtoul(ptr, &end, base);
+        if (*end != 0)
+            error("invalid uint16 literal");
+        if ((errno == ERANGE) || (y > USHRT_MAX))
+            error("uint16 literal out of range");
+        vh = new ValueHolder(uint16Type);
+        *((unsigned short *)vh->buf) = (unsigned short)y;
+    } else if (typeSuffix(x->suffix, defaultType, "u", uint32Type)) {
+        unsigned long y = strtoul(ptr, &end, base);
+        if (*end != 0)
+            error("invalid uint32 literal");
+        if (errno == ERANGE)
+            error("uint32 literal out of range");
+        vh = new ValueHolder(uint32Type);
+        *((unsigned int *)vh->buf) = (unsigned int)y;
+    } else if (typeSuffix(x->suffix, defaultType, "ul", uint64Type)) {
+        unsigned long long y = strtoull(ptr, &end, base);
+        if (*end != 0)
+            error("invalid uint64 literal");
+        if (errno == ERANGE)
+            error("uint64 literal out of range");
+        vh = new ValueHolder(uint64Type);
+        *((unsigned long long *)vh->buf) = y;
+    } else if (typeSuffix(x->suffix, defaultType, "ull", uint128Type)) {
+        unsigned long long y = strtoull(ptr, &end, base);
+        if (*end != 0)
+            error("invalid uint128 literal");
+        if (errno == ERANGE)
+            error("uint128 literal out of range");
+        vh = new ValueHolder(uint128Type);
+        *((clay_uint128 *)vh->buf) = y;
+    } else if (x->suffix == "f") {
+        float y = (float)clay_strtod(ptr, &end);
+        if (*end != 0)
+            error("invalid float32 literal");
+        if (errno == ERANGE)
+            error("float32 literal out of range");
+        vh = new ValueHolder(float32Type);
+        *((float *)vh->buf) = y;
+    } else if (x->suffix == "ff") {
+        double y = clay_strtod(ptr, &end);
+        if (*end != 0)
+            error("invalid float64 literal");
+        if (errno == ERANGE)
+            error("float64 literal out of range");
+        vh = new ValueHolder(float64Type);
+        *((double *)vh->buf) = y;
+    } else if (x->suffix == "fl") {
+        long double y = clay_strtold(ptr, &end);
+        if (*end != 0)
+            error("invalid float80 literal");
+        if (errno == ERANGE)
+            error("float80 literal out of range");
+        vh = new ValueHolder(float80Type);
+        *((long double *)vh->buf) = y;
+    } else if (x->suffix == "fj") {
+        float y = (float)clay_strtod(ptr, &end);
+        if (*end != 0)
+            error("invalid imag32 literal");
+        if (errno == ERANGE)
+            error("imag32 literal out of range");
+        vh = new ValueHolder(imag32Type);
+        *((float *)vh->buf) = y;
+    } else if (x->suffix == "j" || x->suffix == "ffj") {
+        double y = clay_strtod(ptr, &end);
+        if (*end != 0)
+            error("invalid imag64 literal");
+        if (errno == ERANGE)
+            error("imag64 literal out of range");
+        vh = new ValueHolder(imag64Type);
+        *((double *)vh->buf) = y;
+    } else if (x->suffix == "lj" || x->suffix == "flj") {
+        long double y = clay_strtold(ptr, &end);
+        if (*end != 0)
+            error("invalid imag80 literal");
+        if (errno == ERANGE)
+            error("imag80 literal out of range");
+        vh = new ValueHolder(imag80Type);
+        *((long double *)vh->buf) = y;
+    } else {
+        error("invalid literal suffix: " + x->suffix);
     }
+    return vh;
+}
 
-    ValueHolderPtr parseFloatLiteral(ModulePtr module, FloatLiteral *x) {
-        TypePtr defaultType = module->attrDefaultFloatType.ptr();
-        if (defaultType == nullptr)
-            defaultType = float64Type;
+ValueHolderPtr parseFloatLiteral(ModulePtr module, FloatLiteral *x) {
+    TypePtr defaultType = module->attrDefaultFloatType.ptr();
+    if (defaultType == nullptr)
+        defaultType = float64Type;
 
-        char *ptr = const_cast<char *>(x->value.c_str());
-        char *end = ptr;
-        ValueHolderPtr vh;
-        if (typeSuffix(x->suffix, defaultType, "f", float32Type)) {
-            float y = (float) clay_strtod(ptr, &end);
-            if (*end != 0)
-                error("invalid float32 literal");
-            if (errno == ERANGE)
-                error("float32 literal out of range");
-            vh = new ValueHolder(float32Type);
-            *((float *) vh->buf) = y;
-        } else if (typeSuffix(x->suffix, defaultType, "ff", float64Type)) {
-            double y = clay_strtod(ptr, &end);
-            if (*end != 0)
-                error("invalid float64 literal");
-            if (errno == ERANGE)
-                error("float64 literal out of range");
-            vh = new ValueHolder(float64Type);
-            *((double *) vh->buf) = y;
-        } else if (x->suffix == "fl" || x->suffix == "l"
-                   || (x->suffix.empty() && defaultType == float80Type)) {
-            long double y = clay_strtold(ptr, &end);
-            if (*end != 0)
-                error("invalid float80 literal");
-            if (errno == ERANGE)
-                error("float80 literal out of range");
-            vh = new ValueHolder(float80Type);
-            *((long double *) vh->buf) = y;
-        } else if (imagTypeSuffix(x->suffix, defaultType, "fj", float32Type)) {
-            float y = (float) clay_strtod(ptr, &end);
-            if (*end != 0)
-                error("invalid imag32 literal");
-            if (errno == ERANGE)
-                error("imag32 literal out of range");
-            vh = new ValueHolder(imag32Type);
-            *((float *) vh->buf) = y;
-        } else if (imagTypeSuffix(x->suffix, defaultType, "ffj", float64Type)) {
-            double y = clay_strtod(ptr, &end);
-            if (*end != 0)
-                error("invalid imag64 literal");
-            if (errno == ERANGE)
-                error("imag64 literal out of range");
-            vh = new ValueHolder(imag64Type);
-            *((double *) vh->buf) = y;
-        } else if (x->suffix == "lj" || x->suffix == "flj"
-                   || (x->suffix == "j" && defaultType == float80Type)) {
-            long double y = clay_strtold(ptr, &end);
-            if (*end != 0)
-                error("invalid imag80 literal");
-            if (errno == ERANGE)
-                error("imag80 literal out of range");
-            vh = new ValueHolder(imag80Type);
-            *((long double *) vh->buf) = y;
-        } else {
-            error("invalid float literal suffix: " + x->suffix);
-        }
-        return vh;
+    char *ptr = const_cast<char *>(x->value.c_str());
+    char *end = ptr;
+    ValueHolderPtr vh;
+    if (typeSuffix(x->suffix, defaultType, "f", float32Type)) {
+        float y = (float)clay_strtod(ptr, &end);
+        if (*end != 0)
+            error("invalid float32 literal");
+        if (errno == ERANGE)
+            error("float32 literal out of range");
+        vh = new ValueHolder(float32Type);
+        *((float *)vh->buf) = y;
+    } else if (typeSuffix(x->suffix, defaultType, "ff", float64Type)) {
+        double y = clay_strtod(ptr, &end);
+        if (*end != 0)
+            error("invalid float64 literal");
+        if (errno == ERANGE)
+            error("float64 literal out of range");
+        vh = new ValueHolder(float64Type);
+        *((double *)vh->buf) = y;
+    } else if (x->suffix == "fl" || x->suffix == "l" ||
+               (x->suffix.empty() && defaultType == float80Type)) {
+        long double y = clay_strtold(ptr, &end);
+        if (*end != 0)
+            error("invalid float80 literal");
+        if (errno == ERANGE)
+            error("float80 literal out of range");
+        vh = new ValueHolder(float80Type);
+        *((long double *)vh->buf) = y;
+    } else if (imagTypeSuffix(x->suffix, defaultType, "fj", float32Type)) {
+        float y = (float)clay_strtod(ptr, &end);
+        if (*end != 0)
+            error("invalid imag32 literal");
+        if (errno == ERANGE)
+            error("imag32 literal out of range");
+        vh = new ValueHolder(imag32Type);
+        *((float *)vh->buf) = y;
+    } else if (imagTypeSuffix(x->suffix, defaultType, "ffj", float64Type)) {
+        double y = clay_strtod(ptr, &end);
+        if (*end != 0)
+            error("invalid imag64 literal");
+        if (errno == ERANGE)
+            error("imag64 literal out of range");
+        vh = new ValueHolder(imag64Type);
+        *((double *)vh->buf) = y;
+    } else if (x->suffix == "lj" || x->suffix == "flj" ||
+               (x->suffix == "j" && defaultType == float80Type)) {
+        long double y = clay_strtold(ptr, &end);
+        if (*end != 0)
+            error("invalid imag80 literal");
+        if (errno == ERANGE)
+            error("imag80 literal out of range");
+        vh = new ValueHolder(imag80Type);
+        *((long double *)vh->buf) = y;
+    } else {
+        error("invalid float literal suffix: " + x->suffix);
     }
+    return vh;
 }
+} // namespace clay
diff --git a/compiler/literals.hpp b/compiler/literals.hpp
index cbc38fe1..75b26e71 100644
--- a/compiler/literals.hpp
+++ b/compiler/literals.hpp
@@ -3,6 +3,6 @@
 #include "clay.hpp"
 
 namespace clay {
-    ValueHolderPtr parseIntLiteral(ModulePtr module, IntLiteral *x);
-    ValueHolderPtr parseFloatLiteral(ModulePtr module, FloatLiteral *x);
-}
+ValueHolderPtr parseIntLiteral(ModulePtr module, IntLiteral *x);
+ValueHolderPtr parseFloatLiteral(ModulePtr module, FloatLiteral *x);
+} // namespace clay
diff --git a/compiler/loader.cpp b/compiler/loader.cpp
index d2bbc060..3548b01c 100644
--- a/compiler/loader.cpp
+++ b/compiler/loader.cpp
@@ -1,1484 +1,1499 @@
 #include <system_error>
 
-#include "clay.hpp"
-#include "loader.hpp"
-#include "patterns.hpp"
 #include "analyzer.hpp"
+#include "clay.hpp"
 #include "codegen.hpp"
-#include "evaluator.hpp"
 #include "constructors.hpp"
-#include "parser.hpp"
 #include "desugar.hpp"
 #include "env.hpp"
 #include "error.hpp"
+#include "evaluator.hpp"
+#include "loader.hpp"
+#include "parser.hpp"
+#include "patterns.hpp"
 
 #pragma clang diagnostic ignored "-Wcovered-switch-default"
 
 namespace clay {
-    using namespace std;
+using namespace std;
 
-    static vector<PathString> searchPath;
-    static vector<llvm::SmallString<32> > moduleSuffixes;
+static vector<PathString> searchPath;
+static vector<llvm::SmallString<32>> moduleSuffixes;
 
-    llvm::StringMap<ModulePtr> globalModules;
-    llvm::StringMap<string> globalFlags;
-    ModulePtr globalMainModule;
+llvm::StringMap<ModulePtr> globalModules;
+llvm::StringMap<string> globalFlags;
+ModulePtr globalMainModule;
 
-    Source::Source(llvm::StringRef fileName)
-        : Object(SOURCE), fileName(fileName), debugInfo(nullptr) {
-        if (llvm::error_code ec = llvm::MemoryBuffer::getFileOrSTDIN(fileName, buffer))
-            error("unable to open file " + fileName + ": " + ec.message());
-    }
+Source::Source(llvm::StringRef fileName)
+    : Object(SOURCE), fileName(fileName), debugInfo(nullptr) {
+    if (std::error_code ec =
+            llvm::MemoryBuffer::getFileOrSTDIN(fileName, buffer))
+        error("unable to open file " + fileName + ": " + ec.message());
+}
 
-    Source::Source(llvm::StringRef lineOfCode, int dummy)
-        : Object(SOURCE), debugInfo(nullptr) {
-        buffer.reset(llvm::MemoryBuffer::getMemBufferCopy(lineOfCode).get());
-    }
+Source::Source(llvm::StringRef lineOfCode, int dummy)
+    : Object(SOURCE), debugInfo(nullptr) {
+    buffer.reset(llvm::MemoryBuffer::getMemBufferCopy(lineOfCode).get());
+}
 
-    //
-    // initModuleSuffixes
-    //
-
-    static llvm::StringRef getOS(llvm::Triple const &triple) {
-        switch (triple.getOS()) {
-            case llvm::Triple::Darwin: return "macosx";
-            case llvm::Triple::DragonFly: return "dragonfly";
-            case llvm::Triple::FreeBSD: return "freebsd";
-            case llvm::Triple::Linux: return "linux";
-            case llvm::Triple::Cygwin:
-            case llvm::Triple::MinGW32:
-            case llvm::Triple::Win32: return "windows";
-            case llvm::Triple::NetBSD: return "netbsd";
-            case llvm::Triple::OpenBSD: return "openbsd";
-            case llvm::Triple::Solaris: return "solaris";
-            case llvm::Triple::Haiku: return "haiku";
-            case llvm::Triple::Minix: return "minix";
-            default: {
-                llvm::StringRef os = triple.getOSName();
-                if (os.empty())
-                    error("cannot initialize os name");
-                return os;
-            }
-        }
+//
+// initModuleSuffixes
+//
+
+static llvm::StringRef getOS(llvm::Triple const &triple) {
+    switch (triple.getOS()) {
+    case llvm::Triple::Darwin:
+        return "macosx";
+    case llvm::Triple::DragonFly:
+        return "dragonfly";
+    case llvm::Triple::FreeBSD:
+        return "freebsd";
+    case llvm::Triple::Linux:
+        return "linux";
+    case llvm::Triple::Win32:
+        return "windows";
+    case llvm::Triple::NetBSD:
+        return "netbsd";
+    case llvm::Triple::OpenBSD:
+        return "openbsd";
+    case llvm::Triple::Solaris:
+        return "solaris";
+    case llvm::Triple::Haiku:
+        return "haiku";
+    // case llvm::Triple::Minix: return "minix";
+    default: {
+        llvm::StringRef os = triple.getOSName();
+        if (os.empty())
+            error("cannot initialize os name");
+        return os;
     }
-
-    static llvm::StringRef getOSGroup(llvm::Triple const &triple) {
-        switch (triple.getOS()) {
-            case llvm::Triple::Darwin:
-            case llvm::Triple::DragonFly:
-            case llvm::Triple::FreeBSD:
-            case llvm::Triple::Linux:
-            case llvm::Triple::NetBSD:
-            case llvm::Triple::OpenBSD:
-            case llvm::Triple::Solaris:
-            case llvm::Triple::Haiku:
-            case llvm::Triple::Minix: return "unix";
-            default: return "";
-        }
     }
+}
 
-    static llvm::StringRef getCPU(llvm::Triple const &triple) {
-        switch (triple.getArch()) {
-            case llvm::Triple::arm:
-            case llvm::Triple::thumb: return "arm";
-            case llvm::Triple::ppc:
-            case llvm::Triple::ppc64: return "ppc";
-            case llvm::Triple::sparc:
-            case llvm::Triple::sparcv9: return "sparc";
-            case llvm::Triple::x86:
-            case llvm::Triple::x86_64: return "x86";
-            default: {
-                llvm::StringRef archName = triple.getArchName();
-                if (archName.empty())
-                    error("cannot initialize cpu name");
-                return archName;
-            }
-        }
+static llvm::StringRef getOSGroup(llvm::Triple const &triple) {
+    switch (triple.getOS()) {
+    case llvm::Triple::Darwin:
+    case llvm::Triple::DragonFly:
+    case llvm::Triple::FreeBSD:
+    case llvm::Triple::Linux:
+    case llvm::Triple::NetBSD:
+    case llvm::Triple::OpenBSD:
+    case llvm::Triple::Solaris:
+    case llvm::Triple::Haiku:
+    // case llvm::Triple::Minix: return "unix";
+    default:
+        return "";
     }
+}
 
-    static llvm::StringRef getPtrSize(const llvm::DataLayout *dataLayout) {
-        switch (dataLayout->getPointerSizeInBits()) {
-            case 16: return "16";
-            case 32: return "32";
-            case 64: return "64";
-            default: error("cannot initialize ptr size");
-                return "";
-        }
+static llvm::StringRef getCPU(llvm::Triple const &triple) {
+    switch (triple.getArch()) {
+    case llvm::Triple::arm:
+    case llvm::Triple::thumb:
+        return "arm";
+    case llvm::Triple::ppc:
+    case llvm::Triple::ppc64:
+        return "ppc";
+    case llvm::Triple::sparc:
+    case llvm::Triple::sparcv9:
+        return "sparc";
+    case llvm::Triple::x86:
+    case llvm::Triple::x86_64:
+        return "x86";
+    default: {
+        llvm::StringRef archName = triple.getArchName();
+        if (archName.empty())
+            error("cannot initialize cpu name");
+        return archName;
     }
-
-    static void initModuleSuffixes() {
-        llvm::Triple triple(llvmModule->getTargetTriple());
-
-        llvm::StringRef os = getOS(triple);
-        llvm::StringRef osgroup = getOSGroup(triple);
-        llvm::StringRef cpu = getCPU(triple);
-        llvm::StringRef bits = getPtrSize(llvmDataLayout);
-
-        llvm::SmallString<128> buf;
-        llvm::raw_svector_ostream sout(buf);
-
-#define ADD_SUFFIX(fmt) \
-    sout << fmt; \
-    moduleSuffixes.push_back(sout.str()); \
-    buf.clear(); sout.resync();
-
-        ADD_SUFFIX("." << os << "." << cpu << "." << bits << ".clay")
-        ADD_SUFFIX("." << os << "." << cpu << ".clay")
-        ADD_SUFFIX("." << os << "." << bits << ".clay")
-        ADD_SUFFIX("." << cpu << "." << bits << ".clay")
-        ADD_SUFFIX("." << os << ".clay")
-        ADD_SUFFIX("." << cpu << ".clay")
-        ADD_SUFFIX("." << bits << ".clay")
-        if (!osgroup.empty()) {
-            ADD_SUFFIX("." << osgroup << ".clay")
-        }
-
-#undef ADD_SUFFIX
-
-        moduleSuffixes.push_back(llvm::StringRef(".clay"));
     }
+}
 
-    void initLoader() {
-        initModuleSuffixes();
+static llvm::StringRef getPtrSize(const llvm::DataLayout *dataLayout) {
+    switch (dataLayout->getPointerSizeInBits()) {
+    case 16:
+        return "16";
+    case 32:
+        return "32";
+    case 64:
+        return "64";
+    default:
+        error("cannot initialize ptr size");
+        return "";
     }
+}
 
-    //
-    // toKey
-    //
-
-    static string toKey(DottedNamePtr name) {
-        string key;
-        for (unsigned i = 0; i < name->parts.size(); ++i) {
-            if (i != 0)
-                key.push_back('.');
-            key.append(name->parts[i]->str.begin(), name->parts[i]->str.end());
-        }
-        return key;
+static void initModuleSuffixes() {
+    llvm::Triple triple(llvmModule->getTargetTriple());
+
+    llvm::StringRef os = getOS(triple);
+    llvm::StringRef osgroup = getOSGroup(triple);
+    llvm::StringRef cpu = getCPU(triple);
+    llvm::StringRef bits = getPtrSize(llvmDataLayout);
+
+    llvm::SmallString<128> buf;
+    llvm::raw_svector_ostream sout(buf);
+
+#define ADD_SUFFIX(fmt)                                                        \
+    sout << fmt;                                                               \
+    moduleSuffixes.push_back(sout.str());                                      \
+    buf.clear();                                                               \
+    sout.resync();
+
+    ADD_SUFFIX("." << os << "." << cpu << "." << bits << ".clay")
+    ADD_SUFFIX("." << os << "." << cpu << ".clay")
+    ADD_SUFFIX("." << os << "." << bits << ".clay")
+    ADD_SUFFIX("." << cpu << "." << bits << ".clay")
+    ADD_SUFFIX("." << os << ".clay")
+    ADD_SUFFIX("." << cpu << ".clay")
+    ADD_SUFFIX("." << bits << ".clay")
+    if (!osgroup.empty()) {
+        ADD_SUFFIX("." << osgroup << ".clay")
     }
 
-    //
-    // addSearchPath, locateFile, toRelativePath,
-    // locateModule
-    //
+#undef ADD_SUFFIX
 
-    void setSearchPath(llvm::ArrayRef<PathString> path) {
-        searchPath = path;
-    }
+    moduleSuffixes.emplace_back(llvm::StringRef(".clay"));
+}
 
-    static bool locateFile(llvm::StringRef relativePath, PathString &path) {
-        // relativePath has no suffix
-        for (size_t i = 0; i < searchPath.size(); ++i) {
-            PathString pathWOSuffix(searchPath[i]);
-            llvm::sys::path::append(pathWOSuffix, relativePath);
-            for (size_t j = 0; j < moduleSuffixes.size(); ++j) {
-                path = pathWOSuffix;
-                path.append(moduleSuffixes[j].begin(), moduleSuffixes[j].end());
-                if (llvm::sys::fs::exists(path.str()))
-                    return true;
-            }
-        }
-        return false;
-    }
+void initLoader() { initModuleSuffixes(); }
 
-    template<typename Iterator>
-    static PathString toRelativePathUpto(DottedNamePtr name, Iterator limit) {
-        PathString relativePath;
-        for (Iterator i = name->parts.begin(); i < limit; ++i)
-            llvm::sys::path::append(relativePath, (*i)->str.str());
-        llvm::sys::path::append(relativePath, name->parts.back()->str.str());
-        // relative path has no suffix
-        return relativePath;
-    }
+//
+// toKey
+//
 
-    // foo.bar -> foo/bar/bar
-    static PathString toRelativePath1(DottedNamePtr name) {
-        return toRelativePathUpto(name, name->parts.end());
+static string toKey(DottedNamePtr name) {
+    string key;
+    for (unsigned i = 0; i < name->parts.size(); ++i) {
+        if (i != 0)
+            key.push_back('.');
+        key.append(name->parts[i]->str.begin(), name->parts[i]->str.end());
     }
+    return key;
+}
 
-    // foo.bar -> foo/bar
-    static PathString toRelativePath2(DottedNamePtr name) {
-        return toRelativePathUpto(name, name->parts.end() - 1);
+//
+// addSearchPath, locateFile, toRelativePath,
+// locateModule
+//
+
+void setSearchPath(llvm::ArrayRef<PathString> path) { searchPath = path; }
+
+static bool locateFile(llvm::StringRef relativePath, PathString &path) {
+    // relativePath has no suffix
+    for (size_t i = 0; i < searchPath.size(); ++i) {
+        PathString pathWOSuffix(searchPath[i]);
+        llvm::sys::path::append(pathWOSuffix, relativePath);
+        for (size_t j = 0; j < moduleSuffixes.size(); ++j) {
+            path = pathWOSuffix;
+            path.append(moduleSuffixes[j].begin(), moduleSuffixes[j].end());
+            if (llvm::sys::fs::exists(path.str()))
+                return true;
+        }
     }
+    return false;
+}
 
-    static PathString locateModule(DottedNamePtr name) {
-        PathString path;
+template <typename Iterator>
+static PathString toRelativePathUpto(DottedNamePtr name, Iterator limit) {
+    PathString relativePath;
+    for (Iterator i = name->parts.begin(); i < limit; ++i)
+        llvm::sys::path::append(relativePath, (*i)->str.str());
+    llvm::sys::path::append(relativePath, name->parts.back()->str.str());
+    // relative path has no suffix
+    return relativePath;
+}
 
-        PathString relativePath1 = toRelativePath1(name);
-        if (locateFile(relativePath1, path))
-            return path;
+// foo.bar -> foo/bar/bar
+static PathString toRelativePath1(DottedNamePtr name) {
+    return toRelativePathUpto(name, name->parts.end());
+}
 
-        PathString relativePath2 = toRelativePath2(name);
-        if (locateFile(relativePath2, path))
-            return path;
+// foo.bar -> foo/bar
+static PathString toRelativePath2(DottedNamePtr name) {
+    return toRelativePathUpto(name, name->parts.end() - 1);
+}
 
-        string s;
-        llvm::raw_string_ostream ss(s);
+static PathString locateModule(DottedNamePtr name) {
+    PathString path;
 
-        ss << "module not found: " + toKey(name) << "\n";
+    PathString relativePath1 = toRelativePath1(name);
+    if (locateFile(relativePath1, path))
+        return path;
 
-        ss << "tried relative paths:\n";
-        ss << "    " << relativePath1 << "\n";
-        ss << "    " << relativePath2 << "\n";
+    PathString relativePath2 = toRelativePath2(name);
+    if (locateFile(relativePath2, path))
+        return path;
 
-        ss << "with suffixes:\n";
-        for (vector<llvm::SmallString<32> >::const_iterator entry = moduleSuffixes.begin();
-             entry != moduleSuffixes.end(); ++entry) {
-            ss << "    " << *entry << "\n";
-        }
+    string s;
+    llvm::raw_string_ostream ss(s);
 
-        ss << "in search path:\n";
-        for (vector<PathString>::const_iterator entry = searchPath.begin();
-             entry != searchPath.end(); ++entry) {
-            ss << "    " << *entry << "\n";
-        }
+    ss << "module not found: " + toKey(name) << "\n";
 
-        ss.flush();
+    ss << "tried relative paths:\n";
+    ss << "    " << relativePath1 << "\n";
+    ss << "    " << relativePath2 << "\n";
 
-        error(name, s);
-        llvm_unreachable("module not found");
+    ss << "with suffixes:\n";
+    for (vector<llvm::SmallString<32>>::const_iterator entry =
+             moduleSuffixes.begin();
+         entry != moduleSuffixes.end(); ++entry) {
+        ss << "    " << *entry << "\n";
     }
 
-    //
-    // loadFile
-    //
-
-    static SourcePtr loadFile(llvm::StringRef fileName, vector<string> *sourceFiles) {
-        if (sourceFiles != nullptr)
-            sourceFiles->push_back(fileName);
-
-        SourcePtr src = new Source(fileName);
-        if (llvmDIBuilder != nullptr) {
-            PathString absFileName(fileName);
-            llvm::sys::fs::make_absolute(absFileName);
-            src->debugInfo = (llvm::MDNode *) llvmDIBuilder->createFile(
-                llvm::sys::path::filename(absFileName),
-                llvm::sys::path::parent_path(absFileName));
-        }
-        return src;
+    ss << "in search path:\n";
+    for (vector<PathString>::const_iterator entry = searchPath.begin();
+         entry != searchPath.end(); ++entry) {
+        ss << "    " << *entry << "\n";
     }
 
-    //
-    // loadModuleByName, loadDependents, loadProgram
-    //
-
-    static void loadDependents(ModulePtr m, vector<string> *sourceFiles, bool verbose);
-
-    void initModule(ModulePtr m);
-
-    static ModulePtr makePrimitivesModule();
-
-    static ModulePtr makeOperatorsModule();
-
-    static ModulePtr makeIntrinsicsModule();
-
-    static void installGlobals(ModulePtr m) {
-        m->env = new Env(m);
-        vector<TopLevelItemPtr>::iterator i, end;
-        for (i = m->topLevelItems.begin(), end = m->topLevelItems.end();
-             i != end; ++i) {
-            TopLevelItem *x = i->ptr();
-            x->env = m->env;
-            switch (x->objKind) {
-                case ENUM_DECL: {
-                    EnumDecl *enumer = (EnumDecl *) x;
-                    TypePtr t = enumType(enumer);
-                    addGlobal(m, enumer->name, enumer->visibility, t.ptr());
-                    for (size_t i = 0; i < enumer->members.size(); ++i) {
-                        EnumMember *member = enumer->members[i].ptr();
-                        member->index = (int) i;
-                        member->type = t;
-                        addGlobal(m, member->name, enumer->visibility, member);
-                    }
-                    break;
-                }
-                case NEW_TYPE_DECL: {
-                    NewTypeDecl *nt = (NewTypeDecl *) x;
-                    TypePtr t = newType(nt);
-                    addGlobal(m, nt->name, nt->visibility, t.ptr());
-                    break;
-                }
-                case PROCEDURE: {
-                    Procedure *proc = (Procedure *) x;
-                    if (proc->interface != nullptr)
-                        proc->interface->env = m->env;
-                    // fallthrough
-                }
-                default:
-                    if (x->name.ptr())
-                        addGlobal(m, x->name, x->visibility, x);
-                    break;
-            }
-        }
-    }
+    ss.flush();
 
-    static ModulePtr loadModuleByName(DottedNamePtr name, vector<string> *sourceFiles, bool verbose) {
-        string key = toKey(name);
+    error(name, s);
+    llvm_unreachable("module not found");
+}
 
-        llvm::StringMap<ModulePtr>::iterator i = globalModules.find(key);
-        if (i != globalModules.end())
-            return i->second;
+//
+// loadFile
+//
+
+static SourcePtr loadFile(llvm::StringRef fileName,
+                          vector<string> *sourceFiles) {
+    if (sourceFiles != nullptr)
+        sourceFiles->push_back(fileName.str());
+
+    SourcePtr src = new Source(fileName);
+    if (llvmDIBuilder != nullptr) {
+        PathString absFileName(fileName);
+        llvm::sys::fs::make_absolute(absFileName);
+        src->debugInfo = (llvm::MDNode *)llvmDIBuilder->createFile(
+            llvm::sys::path::filename(absFileName),
+            llvm::sys::path::parent_path(absFileName));
+    }
+    return src;
+}
 
-        ModulePtr module;
+//
+// loadModuleByName, loadDependents, loadProgram
+//
 
-        if (key == "__primitives__") {
-            module = makePrimitivesModule();
-        } else if (key == "__operators__") {
-            module = makeOperatorsModule();
-        } else if (key == "__intrinsics__") {
-            module = makeIntrinsicsModule();
-        } else {
-            PathString path = locateModule(name);
-            if (verbose) {
-                llvm::errs() << "loading module " << name->join() << " from " << path << "\n";
-            }
-            module = parse(key, loadFile(path, sourceFiles));
-        }
+static void loadDependents(ModulePtr m, vector<string> *sourceFiles,
+                           bool verbose);
 
-        globalModules[key] = module;
-        loadDependents(module, sourceFiles, verbose);
-        installGlobals(module);
+void initModule(ModulePtr m);
 
-        return module;
-    }
+static ModulePtr makePrimitivesModule();
 
-    void loadDependent(ModulePtr m, vector<string> *sourceFiles, ImportPtr dependent, bool verbose) {
-        ImportPtr x = dependent;
-        x->module = loadModuleByName(x->dottedName, sourceFiles, verbose);
-        switch (x->importKind) {
-            case IMPORT_MODULE: {
-                ImportModule *im = (ImportModule *) x.ptr();
-                IdentifierPtr name = nullptr;
-                if (im->alias.ptr()) {
-                    name = im->alias;
-                    m->importedModuleNames[im->alias->str].module = x->module;
-                } else {
-                    llvm::ArrayRef<IdentifierPtr> parts = im->dottedName->parts;
-                    if (parts.size() == 1)
-                        name = parts[0];
-                    else if (x->visibility == PUBLIC)
-                        error(x->location,
-                              "public imports of dotted module paths must have an \"as <name>\" alias");
-                    llvm::StringMap<ModuleLookup> *node = &m->importedModuleNames;
-                    for (size_t i = parts.size() - 1; i >= 1; --i) {
-                        node = &(*node)[parts[i]->str].parents;
-                    }
-                    (*node)[parts[0]->str].module = x->module;
-                }
+static ModulePtr makeOperatorsModule();
 
-                if (name.ptr()) {
-                    string nameStr(name->str.begin(), name->str.end());
-                    if (m->importedNames.count(nameStr))
-                        error(name, "name imported already: " + nameStr);
-                    m->importedNames.insert(nameStr);
-                    m->allSymbols[nameStr].insert(x->module.ptr());
-                    if (x->visibility == PUBLIC)
-                        m->publicSymbols[nameStr].insert(x->module.ptr());
-                }
+static ModulePtr makeIntrinsicsModule();
 
-                break;
-            }
-            case IMPORT_STAR:
-                break;
-            case IMPORT_MEMBERS: {
-                ImportMembers *y = (ImportMembers *) x.ptr();
-                for (size_t i = 0; i < y->members.size(); ++i) {
-                    ImportedMember &z = y->members[i];
-                    IdentifierPtr alias = z.alias.ptr() ? z.alias : z.name;
-                    string aliasStr(alias->str.begin(), alias->str.end());
-                    if (m->importedNames.count(aliasStr))
-                        error(alias, "name imported already: " + aliasStr);
-                    assert(y->aliasMap.count(aliasStr) == 0);
-                    m->importedNames.insert(aliasStr);
-                    y->aliasMap[aliasStr] = z.name;
-                }
-                break;
+static void installGlobals(ModulePtr m) {
+    m->env = new Env(m);
+    vector<TopLevelItemPtr>::iterator i, end;
+    for (i = m->topLevelItems.begin(), end = m->topLevelItems.end(); i != end;
+         ++i) {
+        TopLevelItem *x = i->ptr();
+        x->env = m->env;
+        switch (x->objKind) {
+        case ENUM_DECL: {
+            EnumDecl *enumer = (EnumDecl *)x;
+            TypePtr t = enumType(enumer);
+            addGlobal(m, enumer->name, enumer->visibility, t.ptr());
+            for (size_t i = 0; i < enumer->members.size(); ++i) {
+                EnumMember *member = enumer->members[i].ptr();
+                member->index = (int)i;
+                member->type = t;
+                addGlobal(m, member->name, enumer->visibility, member);
             }
-            default:
-                assert(false);
+            break;
+        }
+        case NEW_TYPE_DECL: {
+            NewTypeDecl *nt = (NewTypeDecl *)x;
+            TypePtr t = newType(nt);
+            addGlobal(m, nt->name, nt->visibility, t.ptr());
+            break;
+        }
+        case PROCEDURE: {
+            Procedure *proc = (Procedure *)x;
+            if (proc->interface != nullptr)
+                proc->interface->env = m->env;
+            // fallthrough
+        }
+        default:
+            if (x->name.ptr())
+                addGlobal(m, x->name, x->visibility, x);
+            break;
         }
     }
+}
+
+static ModulePtr loadModuleByName(DottedNamePtr name,
+                                  vector<string> *sourceFiles, bool verbose) {
+    string key = toKey(name);
 
-    static void loadDependents(ModulePtr m, vector<string> *sourceFiles, bool verbose) {
-        vector<ImportPtr>::iterator ii, iend;
-        for (ii = m->imports.begin(), iend = m->imports.end(); ii != iend; ++ii) {
-            loadDependent(m, sourceFiles, *ii, verbose);
+    llvm::StringMap<ModulePtr>::iterator i = globalModules.find(key);
+    if (i != globalModules.end())
+        return i->second;
+
+    ModulePtr module;
+
+    if (key == "__primitives__") {
+        module = makePrimitivesModule();
+    } else if (key == "__operators__") {
+        module = makeOperatorsModule();
+    } else if (key == "__intrinsics__") {
+        module = makeIntrinsicsModule();
+    } else {
+        PathString path = locateModule(name);
+        if (verbose) {
+            llvm::errs() << "loading module " << name->join() << " from "
+                         << path << "\n";
         }
+        module = parse(key, loadFile(path, sourceFiles));
     }
 
-    static ModulePtr loadPrelude(vector<string> *sourceFiles, bool verbose, bool repl) {
-        if (!repl) {
-            DottedNamePtr dottedName = new DottedName();
-            dottedName->parts.push_back(Identifier::get("prelude"));
-            return loadModuleByName(dottedName, sourceFiles, verbose);
+    globalModules[key] = module;
+    loadDependents(module, sourceFiles, verbose);
+    installGlobals(module);
+
+    return module;
+}
+
+void loadDependent(ModulePtr m, vector<string> *sourceFiles,
+                   ImportPtr dependent, bool verbose) {
+    ImportPtr x = dependent;
+    x->module = loadModuleByName(x->dottedName, sourceFiles, verbose);
+    switch (x->importKind) {
+    case IMPORT_MODULE: {
+        ImportModule *im = (ImportModule *)x.ptr();
+        IdentifierPtr name = nullptr;
+        if (im->alias.ptr()) {
+            name = im->alias;
+            m->importedModuleNames[im->alias->str].module = x->module;
         } else {
-            DottedNamePtr dottedName = new DottedName();
-            dottedName->parts.push_back(Identifier::get("prelude"));
-            dottedName->parts.push_back(Identifier::get("repl"));
-            ModulePtr m = loadModuleByName(dottedName, sourceFiles, verbose);
-            globalModules["prelude"] = m;
-            return m;
+            llvm::ArrayRef<IdentifierPtr> parts = im->dottedName->parts;
+            if (parts.size() == 1)
+                name = parts[0];
+            else if (x->visibility == PUBLIC)
+                error(x->location, "public imports of dotted module paths must "
+                                   "have an \"as <name>\" alias");
+            llvm::StringMap<ModuleLookup> *node = &m->importedModuleNames;
+            for (size_t i = parts.size() - 1; i >= 1; --i) {
+                node = &(*node)[parts[i]->str].parents;
+            }
+            (*node)[parts[0]->str].module = x->module;
         }
-    }
 
-    ModulePtr loadProgram(llvm::StringRef fileName, vector<string> *sourceFiles, bool verbose, bool repl) {
-        globalMainModule = parse("", loadFile(fileName, sourceFiles));
-        ModulePtr prelude = loadPrelude(sourceFiles, verbose, repl);
-        loadDependents(globalMainModule, sourceFiles, verbose);
-        installGlobals(globalMainModule);
-        initModule(prelude);
-        initModule(globalMainModule);
-        return globalMainModule;
-    }
-
-    ModulePtr loadProgramSource(llvm::StringRef name, llvm::StringRef source, bool verbose, bool repl) {
-        SourcePtr mainSource = new Source(name,
-                                          llvm::MemoryBuffer::getMemBufferCopy(source));
-        if (llvmDIBuilder != nullptr) {
-            mainSource->debugInfo = (llvm::MDNode *) llvmDIBuilder->createFile(
-                "-e",
-                "");
+        if (name.ptr()) {
+            string nameStr(name->str.begin(), name->str.end());
+            if (m->importedNames.count(nameStr))
+                error(name, "name imported already: " + nameStr);
+            m->importedNames.insert(nameStr);
+            m->allSymbols[nameStr].insert(x->module.ptr());
+            if (x->visibility == PUBLIC)
+                m->publicSymbols[nameStr].insert(x->module.ptr());
         }
 
-        globalMainModule = parse("", mainSource);
-        // Don't keep track of source files for -e script
-        ModulePtr prelude = loadPrelude(nullptr, verbose, repl);
-        loadDependents(globalMainModule, nullptr, verbose);
-        installGlobals(globalMainModule);
-        initModule(prelude);
-        initModule(globalMainModule);
-        return globalMainModule;
+        break;
+    }
+    case IMPORT_STAR:
+        break;
+    case IMPORT_MEMBERS: {
+        ImportMembers *y = (ImportMembers *)x.ptr();
+        for (size_t i = 0; i < y->members.size(); ++i) {
+            ImportedMember &z = y->members[i];
+            IdentifierPtr alias = z.alias.ptr() ? z.alias : z.name;
+            string aliasStr(alias->str.begin(), alias->str.end());
+            if (m->importedNames.count(aliasStr))
+                error(alias, "name imported already: " + aliasStr);
+            assert(y->aliasMap.count(aliasStr) == 0);
+            m->importedNames.insert(aliasStr);
+            y->aliasMap[aliasStr] = z.name;
+        }
+        break;
     }
+    default:
+        assert(false);
+    }
+}
 
-    ModulePtr loadedModule(llvm::StringRef module) {
-        if (!globalModules.count(module))
-            error("module not loaded: " + module);
-        return globalModules[module];
+static void loadDependents(ModulePtr m, vector<string> *sourceFiles,
+                           bool verbose) {
+    vector<ImportPtr>::iterator ii, iend;
+    for (ii = m->imports.begin(), iend = m->imports.end(); ii != iend; ++ii) {
+        loadDependent(m, sourceFiles, *ii, verbose);
     }
+}
 
-    //
-    // initOverload, initVariantInstance, initModule
-    //
-
-    static EnvPtr overloadPatternEnv(OverloadPtr x) {
-        EnvPtr env = new Env(x->env);
-        llvm::ArrayRef<PatternVar> pvars = x->code->patternVars;
-        for (size_t i = 0; i < pvars.size(); ++i) {
-            if (pvars[i].isMulti) {
-                MultiPatternCellPtr cell = new MultiPatternCell(nullptr);
-                addLocal(env, pvars[i].name, cell.ptr());
-            } else {
-                PatternCellPtr cell = new PatternCell(nullptr);
-                addLocal(env, pvars[i].name, cell.ptr());
-            }
-        }
-        return env;
+static ModulePtr loadPrelude(vector<string> *sourceFiles, bool verbose,
+                             bool repl) {
+    if (!repl) {
+        DottedNamePtr dottedName = new DottedName();
+        dottedName->parts.push_back(Identifier::get("prelude"));
+        return loadModuleByName(dottedName, sourceFiles, verbose);
+    } else {
+        DottedNamePtr dottedName = new DottedName();
+        dottedName->parts.push_back(Identifier::get("prelude"));
+        dottedName->parts.push_back(Identifier::get("repl"));
+        ModulePtr m = loadModuleByName(dottedName, sourceFiles, verbose);
+        globalModules["prelude"] = m;
+        return m;
     }
+}
 
-    void getProcedureMonoTypes(ProcedureMono &mono, EnvPtr env,
-                               llvm::ArrayRef<FormalArgPtr> formalArgs, bool hasVarArg) {
-        if (mono.monoState == Procedure_NoOverloads && !hasVarArg) {
-            assert(mono.monoTypes.empty());
-            mono.monoState = Procedure_MonoOverload;
-            for (size_t i = 0; i < formalArgs.size(); ++i) {
-                if (formalArgs[i]->type == nullptr)
-                    goto poly;
-                LocationContext loc(formalArgs[i]->type->location);
-                PatternPtr argPattern =
-                        evaluateOnePattern(formalArgs[i]->type, env);
-                ObjectPtr argTypeObj = derefDeep(argPattern);
-                if (argTypeObj == nullptr)
-                    goto poly;
-                TypePtr argType;
-                if (!staticToType(argTypeObj, argType))
-                    error(formalArgs[i], "expecting a type");
-
-                mono.monoTypes.push_back(argType);
-            }
-        } else
-            goto poly;
-        return;
+ModulePtr loadProgram(llvm::StringRef fileName, vector<string> *sourceFiles,
+                      bool verbose, bool repl) {
+    globalMainModule = parse("", loadFile(fileName, sourceFiles));
+    ModulePtr prelude = loadPrelude(sourceFiles, verbose, repl);
+    loadDependents(globalMainModule, sourceFiles, verbose);
+    installGlobals(globalMainModule);
+    initModule(prelude);
+    initModule(globalMainModule);
+    return globalMainModule;
+}
 
-    poly:
-        mono.monoTypes.clear();
-        mono.monoState = Procedure_PolyOverload;
-        return;
+ModulePtr loadProgramSource(llvm::StringRef name, llvm::StringRef source,
+                            bool verbose, bool repl) {
+    SourcePtr mainSource =
+        new Source(name, llvm::MemoryBuffer::getMemBufferCopy(source));
+    if (llvmDIBuilder != nullptr) {
+        mainSource->debugInfo =
+            (llvm::MDNode *)llvmDIBuilder->createFile("-e", "");
     }
 
-    static size_t maxParamCount(const CodePtr &code) {
-        if (code->hasVarArg)
-            return std::numeric_limits<size_t>::max();
-        else
-            return code->formalArgs.size();
-    }
+    globalMainModule = parse("", mainSource);
+    // Don't keep track of source files for -e script
+    ModulePtr prelude = loadPrelude(nullptr, verbose, repl);
+    loadDependents(globalMainModule, nullptr, verbose);
+    installGlobals(globalMainModule);
+    initModule(prelude);
+    initModule(globalMainModule);
+    return globalMainModule;
+}
 
-    static size_t minParamCount(const CodePtr &code) {
-        if (code->hasVarArg)
-            return code->formalArgs.size() - 1;
-        else
-            return code->formalArgs.size();
-    }
+ModulePtr loadedModule(llvm::StringRef module) {
+    if (!globalModules.count(module))
+        error("module not loaded: " + module);
+    return globalModules[module];
+}
 
-    static string paramCountString(const CodePtr &code) {
-        string s;
-        llvm::raw_string_ostream ss(s);
-        if (code->hasVarArg) {
-            ss << (code->formalArgs.size() - 1) << "+";
+//
+// initOverload, initVariantInstance, initModule
+//
+
+static EnvPtr overloadPatternEnv(OverloadPtr x) {
+    EnvPtr env = new Env(x->env);
+    llvm::ArrayRef<PatternVar> pvars = x->code->patternVars;
+    for (size_t i = 0; i < pvars.size(); ++i) {
+        if (pvars[i].isMulti) {
+            MultiPatternCellPtr cell = new MultiPatternCell(nullptr);
+            addLocal(env, pvars[i].name, cell.ptr());
         } else {
-            ss << code->formalArgs.size();
+            PatternCellPtr cell = new PatternCell(nullptr);
+            addLocal(env, pvars[i].name, cell.ptr());
         }
-        return s;
     }
+    return env;
+}
+
+void getProcedureMonoTypes(ProcedureMono &mono, EnvPtr env,
+                           llvm::ArrayRef<FormalArgPtr> formalArgs,
+                           bool hasVarArg) {
+    if (mono.monoState == Procedure_NoOverloads && !hasVarArg) {
+        assert(mono.monoTypes.empty());
+        mono.monoState = Procedure_MonoOverload;
+        for (size_t i = 0; i < formalArgs.size(); ++i) {
+            if (formalArgs[i]->type == nullptr)
+                goto poly;
+            LocationContext loc(formalArgs[i]->type->location);
+            PatternPtr argPattern =
+                evaluateOnePattern(formalArgs[i]->type, env);
+            ObjectPtr argTypeObj = derefDeep(argPattern);
+            if (argTypeObj == nullptr)
+                goto poly;
+            TypePtr argType;
+            if (!staticToType(argTypeObj, argType))
+                error(formalArgs[i], "expecting a type");
+
+            mono.monoTypes.push_back(argType);
+        }
+    } else
+        goto poly;
+    return;
+
+poly:
+    mono.monoTypes.clear();
+    mono.monoState = Procedure_PolyOverload;
+    return;
+}
+
+static size_t maxParamCount(const CodePtr &code) {
+    if (code->hasVarArg)
+        return std::numeric_limits<size_t>::max();
+    else
+        return code->formalArgs.size();
+}
 
-    template<typename T>
-    static string toString(const T &t) {
-        string s;
-        llvm::raw_string_ostream ss(s);
-        ss << t;
-        return s;
+static size_t minParamCount(const CodePtr &code) {
+    if (code->hasVarArg)
+        return code->formalArgs.size() - 1;
+    else
+        return code->formalArgs.size();
+}
+
+static string paramCountString(const CodePtr &code) {
+    string s;
+    llvm::raw_string_ostream ss(s);
+    if (code->hasVarArg) {
+        ss << (code->formalArgs.size() - 1) << "+";
+    } else {
+        ss << code->formalArgs.size();
     }
+    return s;
+}
+
+template <typename T> static string toString(const T &t) {
+    string s;
+    llvm::raw_string_ostream ss(s);
+    ss << t;
+    return s;
+}
+
+void addOverload(vector<OverloadPtr> &overloads, OverloadPtr &x) {
+    overloads.insert(overloads.begin(), x);
+    if (x->hasAsConversion)
+        overloads.insert(overloads.begin(), desugarAsOverload(x));
+}
 
-    void addOverload(vector<OverloadPtr> &overloads, OverloadPtr &x) {
-        overloads.insert(overloads.begin(), x);
-        if (x->hasAsConversion)
-            overloads.insert(overloads.begin(), desugarAsOverload(x));
+void addProcedureOverload(ProcedurePtr proc, EnvPtr env, OverloadPtr x) {
+    if (!!proc->singleOverload && proc->singleOverload != x) {
+        // TODO: points to wrong line
+        error(x->location, "standalone functions cannot be overloaded");
     }
 
-    void addProcedureOverload(ProcedurePtr proc, EnvPtr env, OverloadPtr x) {
-        if (!!proc->singleOverload && proc->singleOverload != x) {
-            // TODO: points to wrong line
-            error(x->location, "standalone functions cannot be overloaded");
+    if (proc->privateOverload) {
+        if (proc->module != x->module) {
+            error("symbol " + toString(proc->name->str) +
+                  " is declared as private for overload");
         }
+    }
 
-        if (proc->privateOverload) {
-            if (proc->module != x->module) {
-                error("symbol " + toString(proc->name->str) + " is declared as private for overload");
-            }
+    if (proc->interface != nullptr) {
+        if (maxParamCount(proc->interface->code) < minParamCount(x->code)) {
+            error(x->location,
+                  "overload has more parameters (" + paramCountString(x->code) +
+                      ")"
+                      " than declaration (" +
+                      paramCountString(proc->interface->code) + ")");
         }
 
-        if (proc->interface != nullptr) {
-            if (maxParamCount(proc->interface->code) < minParamCount(x->code)) {
-                error(x->location,
-                      "overload has more parameters (" + paramCountString(x->code) + ")"
-                      " than declaration (" + paramCountString(proc->interface->code) + ")");
-            }
+        if (maxParamCount(x->code) < minParamCount(proc->interface->code)) {
+            error(x->location, "overload has fewer parameters (" +
+                                   paramCountString(x->code) +
+                                   ")"
+                                   " than declaration (" +
+                                   paramCountString(proc->interface->code) +
+                                   ")");
+        }
 
-            if (maxParamCount(x->code) < minParamCount(proc->interface->code)) {
+        if (proc->interface->code->returnSpecsDeclared &&
+            x->code->returnSpecsDeclared) {
+            if (x->code->returnSpecs.size() !=
+                proc->interface->code->returnSpecs.size()) {
                 error(x->location,
-                      "overload has fewer parameters (" + paramCountString(x->code) + ")"
-                      " than declaration (" + paramCountString(proc->interface->code) + ")");
-            }
-
-            if (proc->interface->code->returnSpecsDeclared && x->code->returnSpecsDeclared) {
-                if (x->code->returnSpecs.size() != proc->interface->code->returnSpecs.size()) {
-                    error(x->location, string() +
-                                       "overload return count (" + toString(x->code->returnSpecs.size()) + ")"
-                                       " must be equal to define return count (" + toString(
-                                           proc->interface->code->returnSpecs.size()) + ")");
-                }
+                      string() + "overload return count (" +
+                          toString(x->code->returnSpecs.size()) +
+                          ")"
+                          " must be equal to define return count (" +
+                          toString(proc->interface->code->returnSpecs.size()) +
+                          ")");
             }
         }
-
-        addOverload(proc->overloads, x);
-        getProcedureMonoTypes(proc->mono, env,
-                              x->code->formalArgs,
-                              x->code->hasVarArg);
     }
 
-    static void initOverload(OverloadPtr x) {
-        EnvPtr env = overloadPatternEnv(x);
-        PatternPtr pattern = evaluateOnePattern(x->target, env);
-        ObjectPtr obj = derefDeep(pattern);
-        if (obj == nullptr) {
-            x->nameIsPattern = true;
-            addOverload(getPatternOverloads(), x);
-        } else {
-            switch (obj->objKind) {
-                case PROCEDURE: {
-                    Procedure *proc = (Procedure *) obj.ptr();
-                    addProcedureOverload(proc, env, x);
-                    break;
-                }
-                case RECORD_DECL: {
-                    RecordDecl *r = (RecordDecl *) obj.ptr();
-                    addOverload(r->overloads, x);
-                    break;
-                }
-                case VARIANT_DECL: {
-                    VariantDecl *v = (VariantDecl *) obj.ptr();
-                    addOverload(v->overloads, x);
-                    break;
-                }
-                case TYPE: {
-                    Type *t = (Type *) obj.ptr();
-                    addOverload(t->overloads, x);
-                    break;
-                }
-                case PRIM_OP: {
-                    if (isOverloadablePrimOp(obj))
-                        addOverload(primOpOverloads((PrimOp *) obj.ptr()), x);
-                    else
-                        error(x->target, "invalid overload target");
-                    break;
-                }
-                case GLOBAL_ALIAS: {
-                    GlobalAlias *a = (GlobalAlias *) obj.ptr();
-                    if (!a->hasParams())
-                        error(x->target, "invalid overload target");
-                    addOverload(a->overloads, x);
-                    break;
-                }
-                case INTRINSIC: {
-                    error(x->target, "invalid overload target");
-                }
-                default: {
-                    error(x->target, "invalid overload target");
-                }
-            }
+    addOverload(proc->overloads, x);
+    getProcedureMonoTypes(proc->mono, env, x->code->formalArgs,
+                          x->code->hasVarArg);
+}
+
+static void initOverload(OverloadPtr x) {
+    EnvPtr env = overloadPatternEnv(x);
+    PatternPtr pattern = evaluateOnePattern(x->target, env);
+    ObjectPtr obj = derefDeep(pattern);
+    if (obj == nullptr) {
+        x->nameIsPattern = true;
+        addOverload(getPatternOverloads(), x);
+    } else {
+        switch (obj->objKind) {
+        case PROCEDURE: {
+            Procedure *proc = (Procedure *)obj.ptr();
+            addProcedureOverload(proc, env, x);
+            break;
+        }
+        case RECORD_DECL: {
+            RecordDecl *r = (RecordDecl *)obj.ptr();
+            addOverload(r->overloads, x);
+            break;
+        }
+        case VARIANT_DECL: {
+            VariantDecl *v = (VariantDecl *)obj.ptr();
+            addOverload(v->overloads, x);
+            break;
+        }
+        case TYPE: {
+            Type *t = (Type *)obj.ptr();
+            addOverload(t->overloads, x);
+            break;
+        }
+        case PRIM_OP: {
+            if (isOverloadablePrimOp(obj))
+                addOverload(primOpOverloads((PrimOp *)obj.ptr()), x);
+            else
+                error(x->target, "invalid overload target");
+            break;
+        }
+        case GLOBAL_ALIAS: {
+            GlobalAlias *a = (GlobalAlias *)obj.ptr();
+            if (!a->hasParams())
+                error(x->target, "invalid overload target");
+            addOverload(a->overloads, x);
+            break;
+        }
+        case INTRINSIC: {
+            error(x->target, "invalid overload target");
+        }
+        default: {
+            error(x->target, "invalid overload target");
+        }
         }
     }
+}
 
-    static void initVariantInstance(InstanceDeclPtr x) {
-        EnvPtr env = new Env(x->env);
-        llvm::ArrayRef<PatternVar> pvars = x->patternVars;
-        for (size_t i = 0; i < pvars.size(); ++i) {
-            if (pvars[i].isMulti) {
-                MultiPatternCellPtr cell = new MultiPatternCell(nullptr);
-                addLocal(env, pvars[i].name, cell.ptr());
-            } else {
-                PatternCellPtr cell = new PatternCell(nullptr);
-                addLocal(env, pvars[i].name, cell.ptr());
-            }
-        }
-        PatternPtr pattern = evaluateOnePattern(x->target, env);
-        ObjectPtr y = derefDeep(pattern);
-        if (y.ptr()) {
-            if (y->objKind != TYPE)
-                error(x->target, "not a variant type");
-            Type *z = (Type *) y.ptr();
-            if (z->typeKind != VARIANT_TYPE)
-                error(x->target, "not a variant type");
-            VariantType *vt = (VariantType *) z;
-            if (!vt->variant->open)
-                error(x->target, "cannot add instances to closed variant");
-            vt->variant->instances.push_back(x);
+static void initVariantInstance(InstanceDeclPtr x) {
+    EnvPtr env = new Env(x->env);
+    llvm::ArrayRef<PatternVar> pvars = x->patternVars;
+    for (size_t i = 0; i < pvars.size(); ++i) {
+        if (pvars[i].isMulti) {
+            MultiPatternCellPtr cell = new MultiPatternCell(nullptr);
+            addLocal(env, pvars[i].name, cell.ptr());
         } else {
-            if (pattern->kind != PATTERN_STRUCT)
-                error(x->target, "not a variant type");
-            PatternStruct *ps = (PatternStruct *) pattern.ptr();
-            if ((!ps->head) || (ps->head->objKind != VARIANT_DECL))
-                error(x->target, "not a variant type");
-            VariantDecl *v = (VariantDecl *) ps->head.ptr();
-            v->instances.push_back(x);
+            PatternCellPtr cell = new PatternCell(nullptr);
+            addLocal(env, pvars[i].name, cell.ptr());
         }
     }
-
-    static void checkStaticAssert(StaticAssertTopLevelPtr a) {
-        evaluateStaticAssert(a->location, a->cond, a->message, a->env);
+    PatternPtr pattern = evaluateOnePattern(x->target, env);
+    ObjectPtr y = derefDeep(pattern);
+    if (y.ptr()) {
+        if (y->objKind != TYPE)
+            error(x->target, "not a variant type");
+        Type *z = (Type *)y.ptr();
+        if (z->typeKind != VARIANT_TYPE)
+            error(x->target, "not a variant type");
+        VariantType *vt = (VariantType *)z;
+        if (!vt->variant->open)
+            error(x->target, "cannot add instances to closed variant");
+        vt->variant->instances.push_back(x);
+    } else {
+        if (pattern->kind != PATTERN_STRUCT)
+            error(x->target, "not a variant type");
+        PatternStruct *ps = (PatternStruct *)pattern.ptr();
+        if ((!ps->head) || (ps->head->objKind != VARIANT_DECL))
+            error(x->target, "not a variant type");
+        VariantDecl *v = (VariantDecl *)ps->head.ptr();
+        v->instances.push_back(x);
     }
+}
 
-    static void circularImportsError(llvm::ArrayRef<string> modules) {
-        string s;
-        llvm::raw_string_ostream ss(s);
-        ss << "import loop:\n";
-        for (string const *it = modules.begin(); it != modules.end(); ++it) {
-            ss << "    " << *it;
-            if (it + 1 != modules.end()) {
-                // because error() function adds trailing newline
-                ss << "\n";
-            }
+static void checkStaticAssert(StaticAssertTopLevelPtr a) {
+    evaluateStaticAssert(a->location, a->cond, a->message, a->env);
+}
+
+static void circularImportsError(llvm::ArrayRef<string> modules) {
+    string s;
+    llvm::raw_string_ostream ss(s);
+    ss << "import loop:\n";
+    for (string const *it = modules.begin(); it != modules.end(); ++it) {
+        ss << "    " << *it;
+        if (it + 1 != modules.end()) {
+            // because error() function adds trailing newline
+            ss << "\n";
         }
-        return error(ss.str());
     }
+    return error(ss.str());
+}
 
-    static void initModule(ModulePtr m, llvm::ArrayRef<string> importChain) {
-        if (m->initState == Module::DONE) return;
-
-        if (m->declaration != nullptr) {
-            if (m->moduleName == "")
-                m->moduleName = toKey(m->declaration->name);
-            else if (m->moduleName != toKey(m->declaration->name))
-                error(m->declaration,
-                      "module imported by name " + m->moduleName
-                      + " but declared with name " + toKey(m->declaration->name)
-                );
-        } else if (m->moduleName == "")
-            m->moduleName = "__main__";
-
-        if (m->initState == Module::RUNNING && !importChain.empty()) {
-            // allow prelude to import self
-            if (importChain.back() == m->moduleName) {
-                return;
-            }
+static void initModule(ModulePtr m, llvm::ArrayRef<string> importChain) {
+    if (m->initState == Module::DONE)
+        return;
+
+    if (m->declaration != nullptr) {
+        if (m->moduleName == "")
+            m->moduleName = toKey(m->declaration->name);
+        else if (m->moduleName != toKey(m->declaration->name))
+            error(m->declaration, "module imported by name " + m->moduleName +
+                                      " but declared with name " +
+                                      toKey(m->declaration->name));
+    } else if (m->moduleName == "")
+        m->moduleName = "__main__";
+
+    if (m->initState == Module::RUNNING && !importChain.empty()) {
+        // allow prelude to import self
+        if (importChain.back() == m->moduleName) {
+            return;
         }
+    }
 
-        vector<string> importChainNext = importChain;
-        importChainNext.push_back(m->moduleName);
+    vector<string> importChainNext = importChain;
+    importChainNext.push_back(m->moduleName);
 
-        if (m->initState == Module::RUNNING) {
-            circularImportsError(importChainNext);
-        }
+    if (m->initState == Module::RUNNING) {
+        circularImportsError(importChainNext);
+    }
 
-        m->initState = Module::RUNNING;
-
-        vector<ImportPtr>::iterator ii, iend;
-        for (ii = m->imports.begin(), iend = m->imports.end(); ii != iend; ++ii)
-            initModule((*ii)->module, importChainNext);
-
-        m->initState = Module::DONE;
-
-        verifyAttributes(m);
-
-        llvm::ArrayRef<TopLevelItemPtr> items = m->topLevelItems;
-        TopLevelItemPtr const *ti, *tend;
-        for (ti = items.begin(), tend = items.end(); ti != tend; ++ti) {
-            Object *obj = ti->ptr();
-            switch (obj->objKind) {
-                case OVERLOAD:
-                    initOverload((Overload *) obj);
-                    break;
-                case INSTANCE_DECL:
-                    initVariantInstance((InstanceDecl *) obj);
-                    break;
-                case STATIC_ASSERT_TOP_LEVEL:
-                    checkStaticAssert((StaticAssertTopLevel *) obj);
-                    break;
-                case GLOBAL_ALIAS: {
-                    GlobalAlias *y = (GlobalAlias *) obj;
-                    if (y->name->isOperator) {
-                        PatternPtr pattern = evaluateOnePattern(y->expr, m->env);
-                        ObjectPtr obj = derefDeep(pattern);
-                        if (!!obj.ptr() && (obj->objKind == PROCEDURE || obj->objKind == GLOBAL_ALIAS)) {
-                            TopLevelItem *item = (TopLevelItem *) obj.ptr();
-                            item->name->isOperator = true;
-                        }
-                    }
-                    break;
+    m->initState = Module::RUNNING;
+
+    vector<ImportPtr>::iterator ii, iend;
+    for (ii = m->imports.begin(), iend = m->imports.end(); ii != iend; ++ii)
+        initModule((*ii)->module, importChainNext);
+
+    m->initState = Module::DONE;
+
+    verifyAttributes(m);
+
+    llvm::ArrayRef<TopLevelItemPtr> items = m->topLevelItems;
+    TopLevelItemPtr const *ti, *tend;
+    for (ti = items.begin(), tend = items.end(); ti != tend; ++ti) {
+        Object *obj = ti->ptr();
+        switch (obj->objKind) {
+        case OVERLOAD:
+            initOverload((Overload *)obj);
+            break;
+        case INSTANCE_DECL:
+            initVariantInstance((InstanceDecl *)obj);
+            break;
+        case STATIC_ASSERT_TOP_LEVEL:
+            checkStaticAssert((StaticAssertTopLevel *)obj);
+            break;
+        case GLOBAL_ALIAS: {
+            GlobalAlias *y = (GlobalAlias *)obj;
+            if (y->name->isOperator) {
+                PatternPtr pattern = evaluateOnePattern(y->expr, m->env);
+                ObjectPtr obj = derefDeep(pattern);
+                if (!!obj.ptr() && (obj->objKind == PROCEDURE ||
+                                    obj->objKind == GLOBAL_ALIAS)) {
+                    TopLevelItem *item = (TopLevelItem *)obj.ptr();
+                    item->name->isOperator = true;
                 }
-                default:
-                    break;
             }
+            break;
         }
-
-        if (llvmDIBuilder != nullptr) {
-            llvm::DIFile file = m->location.ok()
-                                    ? m->location.source->getDebugInfo()
-                                    : llvm::DIFile();
-            m->debugInfo = (llvm::MDNode *) llvmDIBuilder->createNameSpace(
-                llvm::DICompileUnit(llvmDIBuilder->getCU()), // scope
-                m->moduleName, // name
-                file, // file
-                1 // line
-            );
+        default:
+            break;
         }
     }
 
-    void initModule(ModulePtr m) {
-        initModule(m, vector<string>());
+    if (llvmDIBuilder != nullptr) {
+        llvm::DIFile file = m->location.ok()
+                                ? m->location.source->getDebugInfo()
+                                : llvm::DIFile();
+        m->debugInfo = (llvm::MDNode *)llvmDIBuilder->createNameSpace(
+            llvm::DICompileUnit(llvmDIBuilder->getCU()), // scope
+            m->moduleName,                               // name
+            file,                                        // file
+            1                                            // line
+        );
     }
+}
 
-    //
-    // staticModule
-    //
-
-    static ModulePtr envModule(EnvPtr env) {
-        if (env == nullptr || env->parent == nullptr)
-            return nullptr;
-        switch (env->parent->objKind) {
-            case ENV:
-                return envModule((Env *) env->parent.ptr());
-            case MODULE:
-                return (Module *) env->parent.ptr();
-            default:
-                assert(false);
-                return nullptr;
-        }
+void initModule(ModulePtr m) { initModule(m, vector<string>()); }
+
+//
+// staticModule
+//
+
+static ModulePtr envModule(EnvPtr env) {
+    if (env == nullptr || env->parent == nullptr)
+        return nullptr;
+    switch (env->parent->objKind) {
+    case ENV:
+        return envModule((Env *)env->parent.ptr());
+    case MODULE:
+        return (Module *)env->parent.ptr();
+    default:
+        assert(false);
+        return nullptr;
     }
+}
 
-    static ModulePtr typeModule(TypePtr t) {
-        switch (t->typeKind) {
-            case BOOL_TYPE:
-            case INTEGER_TYPE:
-            case FLOAT_TYPE:
-            case COMPLEX_TYPE:
-            case POINTER_TYPE:
-            case CODE_POINTER_TYPE:
-            case CCODE_POINTER_TYPE:
-            case ARRAY_TYPE:
-            case VEC_TYPE:
-            case TUPLE_TYPE:
-            case UNION_TYPE:
-            case STATIC_TYPE:
-                return primitivesModule();
-            case RECORD_TYPE: {
-                RecordType *rt = (RecordType *) t.ptr();
-                return envModule(rt->record->env);
-            }
-            case VARIANT_TYPE: {
-                VariantType *vt = (VariantType *) t.ptr();
-                return envModule(vt->variant->env);
-            }
-            case ENUM_TYPE: {
-                EnumType *et = (EnumType *) t.ptr();
-                return envModule(et->enumeration->env);
-            }
-            case NEW_TYPE: {
-                NewType *et = (NewType *) t.ptr();
-                return envModule(et->newtype->env);
-            }
-            default:
-                assert(false);
-                return nullptr;
-        }
+static ModulePtr typeModule(TypePtr t) {
+    switch (t->typeKind) {
+    case BOOL_TYPE:
+    case INTEGER_TYPE:
+    case FLOAT_TYPE:
+    case COMPLEX_TYPE:
+    case POINTER_TYPE:
+    case CODE_POINTER_TYPE:
+    case CCODE_POINTER_TYPE:
+    case ARRAY_TYPE:
+    case VEC_TYPE:
+    case TUPLE_TYPE:
+    case UNION_TYPE:
+    case STATIC_TYPE:
+        return primitivesModule();
+    case RECORD_TYPE: {
+        RecordType *rt = (RecordType *)t.ptr();
+        return envModule(rt->record->env);
     }
+    case VARIANT_TYPE: {
+        VariantType *vt = (VariantType *)t.ptr();
+        return envModule(vt->variant->env);
+    }
+    case ENUM_TYPE: {
+        EnumType *et = (EnumType *)t.ptr();
+        return envModule(et->enumeration->env);
+    }
+    case NEW_TYPE: {
+        NewType *et = (NewType *)t.ptr();
+        return envModule(et->newtype->env);
+    }
+    default:
+        assert(false);
+        return nullptr;
+    }
+}
 
-    ModulePtr staticModule(ObjectPtr x) {
-        switch (x->objKind) {
-            case TYPE: {
-                Type *y = (Type *) x.ptr();
-                return typeModule(y);
-            }
-            case PRIM_OP: {
-                return primitivesModule();
-            }
-            case MODULE: {
-                return (Module *) x.ptr();
-            }
-            case INTRINSIC: {
-                return intrinsicsModule();
-            }
-            case GLOBAL_VARIABLE:
-            case GLOBAL_ALIAS:
-            case EXTERNAL_PROCEDURE:
-            case EXTERNAL_VARIABLE:
-            case PROCEDURE:
-            case RECORD_DECL:
-            case VARIANT_DECL: {
-                TopLevelItem *t = (TopLevelItem *) x.ptr();
-                return envModule(t->env);
-            }
-            default:
-                return nullptr;
-        }
+ModulePtr staticModule(ObjectPtr x) {
+    switch (x->objKind) {
+    case TYPE: {
+        Type *y = (Type *)x.ptr();
+        return typeModule(y);
+    }
+    case PRIM_OP: {
+        return primitivesModule();
+    }
+    case MODULE: {
+        return (Module *)x.ptr();
     }
+    case INTRINSIC: {
+        return intrinsicsModule();
+    }
+    case GLOBAL_VARIABLE:
+    case GLOBAL_ALIAS:
+    case EXTERNAL_PROCEDURE:
+    case EXTERNAL_VARIABLE:
+    case PROCEDURE:
+    case RECORD_DECL:
+    case VARIANT_DECL: {
+        TopLevelItem *t = (TopLevelItem *)x.ptr();
+        return envModule(t->env);
+    }
+    default:
+        return nullptr;
+    }
+}
 
-    //
-    // ForeignExpr::getEnv, ForeignStatement::getEnv
-    //
+//
+// ForeignExpr::getEnv, ForeignStatement::getEnv
+//
 
-    EnvPtr ForeignExpr::getEnv() {
-        if (!foreignEnv) {
-            assert(moduleName.size() > 0);
-            foreignEnv = loadedModule(moduleName)->env;
-        }
-        return foreignEnv;
+EnvPtr ForeignExpr::getEnv() {
+    if (!foreignEnv) {
+        assert(moduleName.size() > 0);
+        foreignEnv = loadedModule(moduleName)->env;
     }
+    return foreignEnv;
+}
 
-    EnvPtr ForeignStatement::getEnv() {
-        if (!foreignEnv) {
-            assert(moduleName.size() > 0);
-            foreignEnv = loadedModule(moduleName)->env;
-        }
-        return foreignEnv;
+EnvPtr ForeignStatement::getEnv() {
+    if (!foreignEnv) {
+        assert(moduleName.size() > 0);
+        foreignEnv = loadedModule(moduleName)->env;
     }
+    return foreignEnv;
+}
 
-    //
-    // prim op names
-    //
+//
+// prim op names
+//
 
-    static map<int, string> primOpNames;
+static map<int, string> primOpNames;
 
-    llvm::StringRef primOpName(PrimOpCode op) {
-        map<int, string>::iterator i = primOpNames.find(op);
-        assert(i != primOpNames.end());
-        return i->second;
-    }
+llvm::StringRef primOpName(PrimOpCode op) {
+    map<int, string>::iterator i = primOpNames.find(op);
+    assert(i != primOpNames.end());
+    return i->second;
+}
 
-    //
-    // makePrimitivesModule
-    //
+//
+// makePrimitivesModule
+//
 
-    static string toPrimStr(llvm::StringRef s) {
-        string name = s;
-        if (name[s.size() - 1] == 'P')
-            name[s.size() - 1] = '?';
-        return name;
-    }
+static string toPrimStr(llvm::StringRef s) {
+    string name = s.str();
+    if (name[s.size() - 1] == 'P')
+        name[s.size() - 1] = '?';
+    return name;
+}
 
-    static void addPrim(ModulePtr m, llvm::StringRef name, ObjectPtr x) {
-        m->globals[name] = x;
-        m->allSymbols[name].insert(x);
-        m->publicGlobals[name] = x;
-        m->publicSymbols[name].insert(x);
-    }
+static void addPrim(ModulePtr m, llvm::StringRef name, ObjectPtr x) {
+    m->globals[name] = x;
+    m->allSymbols[name].insert(x);
+    m->publicGlobals[name] = x;
+    m->publicSymbols[name].insert(x);
+}
 
-    static void addPrimOp(ModulePtr m, llvm::StringRef name, PrimOpPtr x) {
-        primOpNames[x->primOpCode] = name;
-        addPrim(m, name, x.ptr());
-    }
+static void addPrimOp(ModulePtr m, llvm::StringRef name, PrimOpPtr x) {
+    primOpNames[x->primOpCode] = name;
+    addPrim(m, name, x.ptr());
+}
 
-    static ModulePtr makePrimitivesModule() {
-        ModulePtr prims = new Module("__primitives__");
-
-        addPrim(prims, "Bool", boolType.ptr());
-        addPrim(prims, "Int8", int8Type.ptr());
-        addPrim(prims, "Int16", int16Type.ptr());
-        addPrim(prims, "Int32", int32Type.ptr());
-        addPrim(prims, "Int64", int64Type.ptr());
-        addPrim(prims, "Int128", int128Type.ptr());
-        addPrim(prims, "UInt8", uint8Type.ptr());
-        addPrim(prims, "UInt16", uint16Type.ptr());
-        addPrim(prims, "UInt32", uint32Type.ptr());
-        addPrim(prims, "UInt64", uint64Type.ptr());
-        addPrim(prims, "UInt128", uint128Type.ptr());
-        addPrim(prims, "Float32", float32Type.ptr());
-        addPrim(prims, "Float64", float64Type.ptr());
-        addPrim(prims, "Float80", float80Type.ptr());
-        addPrim(prims, "Imag32", imag32Type.ptr());
-        addPrim(prims, "Imag64", imag64Type.ptr());
-        addPrim(prims, "Imag80", imag80Type.ptr());
-        addPrim(prims, "Complex32", complex32Type.ptr());
-        addPrim(prims, "Complex64", complex64Type.ptr());
-        addPrim(prims, "Complex80", complex80Type.ptr());
-
-        GlobalAliasPtr v =
-                new GlobalAlias(prims.ptr(),
-                                Identifier::get("ExceptionsEnabled?"),
-                                PUBLIC,
-                                vector<PatternVar>(),
-                                nullptr,
-                                vector<IdentifierPtr>(),
-                                nullptr,
-                                new BoolLiteral(exceptionsEnabled()));
-        addPrim(prims, "ExceptionsEnabled?", v.ptr());
-
-        vector<IdentifierPtr> recordParams;
-        RecordBodyPtr recordBody = new RecordBody(vector<RecordFieldPtr>());
-        recordParams.push_back(Identifier::get("T"));
-        RecordDeclPtr byRefRecord = new RecordDecl(
-            prims.ptr(),
-            Identifier::get("ByRef"),
-            PUBLIC,
-            vector<PatternVar>(),
-            nullptr,
-            recordParams,
-            nullptr,
-            recordBody);
-        byRefRecord->env = new Env(prims);
-        addPrim(prims, "ByRef", byRefRecord.ptr());
-
-        recordParams.clear();
-        recordParams.push_back(Identifier::get("Properties"));
-        recordParams.push_back(Identifier::get("Fields"));
-        RecordDeclPtr rwpRecord = new RecordDecl(
-            prims.ptr(),
-            Identifier::get("RecordWithProperties"),
-            PUBLIC,
-            vector<PatternVar>(),
-            nullptr,
-            recordParams,
-            nullptr,
-            recordBody);
-        rwpRecord->env = new Env(prims);
-        addPrim(prims, "RecordWithProperties", rwpRecord.ptr());
+static ModulePtr makePrimitivesModule() {
+    ModulePtr prims = new Module("__primitives__");
+
+    addPrim(prims, "Bool", boolType.ptr());
+    addPrim(prims, "Int8", int8Type.ptr());
+    addPrim(prims, "Int16", int16Type.ptr());
+    addPrim(prims, "Int32", int32Type.ptr());
+    addPrim(prims, "Int64", int64Type.ptr());
+    addPrim(prims, "Int128", int128Type.ptr());
+    addPrim(prims, "UInt8", uint8Type.ptr());
+    addPrim(prims, "UInt16", uint16Type.ptr());
+    addPrim(prims, "UInt32", uint32Type.ptr());
+    addPrim(prims, "UInt64", uint64Type.ptr());
+    addPrim(prims, "UInt128", uint128Type.ptr());
+    addPrim(prims, "Float32", float32Type.ptr());
+    addPrim(prims, "Float64", float64Type.ptr());
+    addPrim(prims, "Float80", float80Type.ptr());
+    addPrim(prims, "Imag32", imag32Type.ptr());
+    addPrim(prims, "Imag64", imag64Type.ptr());
+    addPrim(prims, "Imag80", imag80Type.ptr());
+    addPrim(prims, "Complex32", complex32Type.ptr());
+    addPrim(prims, "Complex64", complex64Type.ptr());
+    addPrim(prims, "Complex80", complex80Type.ptr());
+
+    GlobalAliasPtr v = new GlobalAlias(
+        prims.ptr(), Identifier::get("ExceptionsEnabled?"), PUBLIC,
+        vector<PatternVar>(), nullptr, vector<IdentifierPtr>(), nullptr,
+        new BoolLiteral(exceptionsEnabled()));
+    addPrim(prims, "ExceptionsEnabled?", v.ptr());
+
+    vector<IdentifierPtr> recordParams;
+    RecordBodyPtr recordBody = new RecordBody(vector<RecordFieldPtr>());
+    recordParams.push_back(Identifier::get("T"));
+    RecordDeclPtr byRefRecord = new RecordDecl(
+        prims.ptr(), Identifier::get("ByRef"), PUBLIC, vector<PatternVar>(),
+        nullptr, recordParams, nullptr, recordBody);
+    byRefRecord->env = new Env(prims);
+    addPrim(prims, "ByRef", byRefRecord.ptr());
+
+    recordParams.clear();
+    recordParams.push_back(Identifier::get("Properties"));
+    recordParams.push_back(Identifier::get("Fields"));
+    RecordDeclPtr rwpRecord = new RecordDecl(
+        prims.ptr(), Identifier::get("RecordWithProperties"), PUBLIC,
+        vector<PatternVar>(), nullptr, recordParams, nullptr, recordBody);
+    rwpRecord->env = new Env(prims);
+    addPrim(prims, "RecordWithProperties", rwpRecord.ptr());
 
 #define PRIMITIVE(x) addPrimOp(prims, toPrimStr(#x), new PrimOp(PRIM_##x))
 
-        PRIMITIVE(TypeP);
-        PRIMITIVE(TypeSize);
-        PRIMITIVE(TypeAlignment);
-
-        PRIMITIVE(OperatorP);
-        PRIMITIVE(SymbolP);
-
-        PRIMITIVE(StaticCallDefinedP);
-        PRIMITIVE(StaticCallOutputTypes);
-
-        PRIMITIVE(StaticMonoP);
-        PRIMITIVE(StaticMonoInputTypes);
-
-        PRIMITIVE(bitcopy);
-        PRIMITIVE(bitcast);
-
-        PRIMITIVE(boolNot);
-
-        PRIMITIVE(integerEqualsP);
-        PRIMITIVE(integerLesserP);
-
-        PRIMITIVE(numericAdd);
-        PRIMITIVE(numericSubtract);
-        PRIMITIVE(numericMultiply);
-        PRIMITIVE(floatDivide);
-        PRIMITIVE(numericNegate);
-
-        PRIMITIVE(integerQuotient);
-        PRIMITIVE(integerRemainder);
-        PRIMITIVE(integerShiftLeft);
-        PRIMITIVE(integerShiftRight);
-        PRIMITIVE(integerBitwiseAnd);
-        PRIMITIVE(integerBitwiseOr);
-        PRIMITIVE(integerBitwiseXor);
-        PRIMITIVE(integerBitwiseNot);
-
-        PRIMITIVE(numericConvert);
-
-        PRIMITIVE(integerAddChecked);
-        PRIMITIVE(integerSubtractChecked);
-        PRIMITIVE(integerMultiplyChecked);
-        PRIMITIVE(integerQuotientChecked);
-        PRIMITIVE(integerRemainderChecked);
-        PRIMITIVE(integerShiftLeftChecked);
-        PRIMITIVE(integerNegateChecked);
-        PRIMITIVE(integerConvertChecked);
-
-        PRIMITIVE(floatOrderedEqualsP);
-        PRIMITIVE(floatOrderedLesserP);
-        PRIMITIVE(floatOrderedLesserEqualsP);
-        PRIMITIVE(floatOrderedGreaterP);
-        PRIMITIVE(floatOrderedGreaterEqualsP);
-        PRIMITIVE(floatOrderedNotEqualsP);
-        PRIMITIVE(floatOrderedP);
-        PRIMITIVE(floatUnorderedEqualsP);
-        PRIMITIVE(floatUnorderedLesserP);
-        PRIMITIVE(floatUnorderedLesserEqualsP);
-        PRIMITIVE(floatUnorderedGreaterP);
-        PRIMITIVE(floatUnorderedGreaterEqualsP);
-        PRIMITIVE(floatUnorderedNotEqualsP);
-        PRIMITIVE(floatUnorderedP);
-
-        PRIMITIVE(Pointer);
-
-        PRIMITIVE(addressOf);
-        PRIMITIVE(pointerDereference);
-        PRIMITIVE(pointerOffset);
-        PRIMITIVE(pointerToInt);
-        PRIMITIVE(intToPointer);
-        PRIMITIVE(nullPointer);
-
-        PRIMITIVE(CodePointer);
-        PRIMITIVE(makeCodePointer);
-
-        PRIMITIVE(AttributeStdCall);
-        PRIMITIVE(AttributeFastCall);
-        PRIMITIVE(AttributeCCall);
-        PRIMITIVE(AttributeThisCall);
-        PRIMITIVE(AttributeLLVMCall);
-        PRIMITIVE(AttributeDLLImport);
-        PRIMITIVE(AttributeDLLExport);
-
-        PRIMITIVE(ExternalCodePointer);
-        PRIMITIVE(makeExternalCodePointer);
-        PRIMITIVE(callExternalCodePointer);
-
-        PRIMITIVE(Array);
-        PRIMITIVE(arrayRef);
-        PRIMITIVE(arrayElements);
-
-        PRIMITIVE(Vec);
-
-        PRIMITIVE(Tuple);
-        PRIMITIVE(TupleElementCount);
-        PRIMITIVE(tupleRef);
-        PRIMITIVE(tupleElements);
-
-        PRIMITIVE(Union);
-        PRIMITIVE(UnionMemberCount);
-
-        PRIMITIVE(RecordP);
-        PRIMITIVE(RecordFieldCount);
-        PRIMITIVE(RecordFieldName);
-        PRIMITIVE(RecordWithFieldP);
-        PRIMITIVE(recordFieldRef);
-        PRIMITIVE(recordFieldRefByName);
-        PRIMITIVE(recordFields);
-        PRIMITIVE(recordVariadicField);
-
-        PRIMITIVE(VariantP);
-        PRIMITIVE(VariantMemberIndex);
-        PRIMITIVE(VariantMemberCount);
-        PRIMITIVE(VariantMembers);
-
-        PRIMITIVE(BaseType);
-
-        PRIMITIVE(Static);
-        PRIMITIVE(StaticName);
-        PRIMITIVE(staticIntegers);
-        PRIMITIVE(integers);
-        PRIMITIVE(staticFieldRef);
-
-        PRIMITIVE(MainModule);
-        PRIMITIVE(StaticModule);
-        PRIMITIVE(ModuleName);
-        PRIMITIVE(ModuleMemberNames);
-
-        PRIMITIVE(EnumP);
-        PRIMITIVE(EnumMemberCount);
-        PRIMITIVE(EnumMemberName);
-        PRIMITIVE(enumToInt);
-        PRIMITIVE(intToEnum);
-
-        PRIMITIVE(StringLiteralP);
-        PRIMITIVE(stringLiteralByteIndex);
-        PRIMITIVE(stringLiteralBytes);
-        PRIMITIVE(stringLiteralByteSize);
-        PRIMITIVE(stringLiteralByteSlice);
-        PRIMITIVE(stringLiteralConcat);
-        PRIMITIVE(stringLiteralFromBytes);
-
-        PRIMITIVE(stringTableConstant);
-
-        PRIMITIVE(OrderUnordered);
-        PRIMITIVE(OrderMonotonic);
-        PRIMITIVE(OrderAcquire);
-        PRIMITIVE(OrderRelease);
-        PRIMITIVE(OrderAcqRel);
-        PRIMITIVE(OrderSeqCst);
-
-        PRIMITIVE(FlagP);
-        PRIMITIVE(Flag);
-
-        PRIMITIVE(atomicFence);
-        PRIMITIVE(atomicRMW);
-        PRIMITIVE(atomicLoad);
-        PRIMITIVE(atomicStore);
-        PRIMITIVE(atomicCompareExchange);
-
-        PRIMITIVE(RMWXchg);
-        PRIMITIVE(RMWAdd);
-        PRIMITIVE(RMWSubtract);
-        PRIMITIVE(RMWAnd);
-        PRIMITIVE(RMWNAnd);
-        PRIMITIVE(RMWOr);
-        PRIMITIVE(RMWXor);
-        PRIMITIVE(RMWMin);
-        PRIMITIVE(RMWMax);
-        PRIMITIVE(RMWUMin);
-        PRIMITIVE(RMWUMax);
-
-        PRIMITIVE(activeException);
-
-        PRIMITIVE(memcpy);
-        PRIMITIVE(memmove);
-
-        PRIMITIVE(countValues);
-        PRIMITIVE(nthValue);
-        PRIMITIVE(withoutNthValue);
-        PRIMITIVE(takeValues);
-        PRIMITIVE(dropValues);
-
-        PRIMITIVE(LambdaRecordP);
-        PRIMITIVE(LambdaSymbolP);
-        PRIMITIVE(LambdaMonoP);
-        PRIMITIVE(LambdaMonoInputTypes);
-
-        PRIMITIVE(GetOverload);
-
-        PRIMITIVE(usuallyEquals);
+    PRIMITIVE(TypeP);
+    PRIMITIVE(TypeSize);
+    PRIMITIVE(TypeAlignment);
+
+    PRIMITIVE(OperatorP);
+    PRIMITIVE(SymbolP);
+
+    PRIMITIVE(StaticCallDefinedP);
+    PRIMITIVE(StaticCallOutputTypes);
+
+    PRIMITIVE(StaticMonoP);
+    PRIMITIVE(StaticMonoInputTypes);
+
+    PRIMITIVE(bitcopy);
+    PRIMITIVE(bitcast);
+
+    PRIMITIVE(boolNot);
+
+    PRIMITIVE(integerEqualsP);
+    PRIMITIVE(integerLesserP);
+
+    PRIMITIVE(numericAdd);
+    PRIMITIVE(numericSubtract);
+    PRIMITIVE(numericMultiply);
+    PRIMITIVE(floatDivide);
+    PRIMITIVE(numericNegate);
+
+    PRIMITIVE(integerQuotient);
+    PRIMITIVE(integerRemainder);
+    PRIMITIVE(integerShiftLeft);
+    PRIMITIVE(integerShiftRight);
+    PRIMITIVE(integerBitwiseAnd);
+    PRIMITIVE(integerBitwiseOr);
+    PRIMITIVE(integerBitwiseXor);
+    PRIMITIVE(integerBitwiseNot);
+
+    PRIMITIVE(numericConvert);
+
+    PRIMITIVE(integerAddChecked);
+    PRIMITIVE(integerSubtractChecked);
+    PRIMITIVE(integerMultiplyChecked);
+    PRIMITIVE(integerQuotientChecked);
+    PRIMITIVE(integerRemainderChecked);
+    PRIMITIVE(integerShiftLeftChecked);
+    PRIMITIVE(integerNegateChecked);
+    PRIMITIVE(integerConvertChecked);
+
+    PRIMITIVE(floatOrderedEqualsP);
+    PRIMITIVE(floatOrderedLesserP);
+    PRIMITIVE(floatOrderedLesserEqualsP);
+    PRIMITIVE(floatOrderedGreaterP);
+    PRIMITIVE(floatOrderedGreaterEqualsP);
+    PRIMITIVE(floatOrderedNotEqualsP);
+    PRIMITIVE(floatOrderedP);
+    PRIMITIVE(floatUnorderedEqualsP);
+    PRIMITIVE(floatUnorderedLesserP);
+    PRIMITIVE(floatUnorderedLesserEqualsP);
+    PRIMITIVE(floatUnorderedGreaterP);
+    PRIMITIVE(floatUnorderedGreaterEqualsP);
+    PRIMITIVE(floatUnorderedNotEqualsP);
+    PRIMITIVE(floatUnorderedP);
+
+    PRIMITIVE(Pointer);
+
+    PRIMITIVE(addressOf);
+    PRIMITIVE(pointerDereference);
+    PRIMITIVE(pointerOffset);
+    PRIMITIVE(pointerToInt);
+    PRIMITIVE(intToPointer);
+    PRIMITIVE(nullPointer);
+
+    PRIMITIVE(CodePointer);
+    PRIMITIVE(makeCodePointer);
+
+    PRIMITIVE(AttributeStdCall);
+    PRIMITIVE(AttributeFastCall);
+    PRIMITIVE(AttributeCCall);
+    PRIMITIVE(AttributeThisCall);
+    PRIMITIVE(AttributeLLVMCall);
+    PRIMITIVE(AttributeDLLImport);
+    PRIMITIVE(AttributeDLLExport);
+
+    PRIMITIVE(ExternalCodePointer);
+    PRIMITIVE(makeExternalCodePointer);
+    PRIMITIVE(callExternalCodePointer);
+
+    PRIMITIVE(Array);
+    PRIMITIVE(arrayRef);
+    PRIMITIVE(arrayElements);
+
+    PRIMITIVE(Vec);
+
+    PRIMITIVE(Tuple);
+    PRIMITIVE(TupleElementCount);
+    PRIMITIVE(tupleRef);
+    PRIMITIVE(tupleElements);
+
+    PRIMITIVE(Union);
+    PRIMITIVE(UnionMemberCount);
+
+    PRIMITIVE(RecordP);
+    PRIMITIVE(RecordFieldCount);
+    PRIMITIVE(RecordFieldName);
+    PRIMITIVE(RecordWithFieldP);
+    PRIMITIVE(recordFieldRef);
+    PRIMITIVE(recordFieldRefByName);
+    PRIMITIVE(recordFields);
+    PRIMITIVE(recordVariadicField);
+
+    PRIMITIVE(VariantP);
+    PRIMITIVE(VariantMemberIndex);
+    PRIMITIVE(VariantMemberCount);
+    PRIMITIVE(VariantMembers);
+
+    PRIMITIVE(BaseType);
+
+    PRIMITIVE(Static);
+    PRIMITIVE(StaticName);
+    PRIMITIVE(staticIntegers);
+    PRIMITIVE(integers);
+    PRIMITIVE(staticFieldRef);
+
+    PRIMITIVE(MainModule);
+    PRIMITIVE(StaticModule);
+    PRIMITIVE(ModuleName);
+    PRIMITIVE(ModuleMemberNames);
+
+    PRIMITIVE(EnumP);
+    PRIMITIVE(EnumMemberCount);
+    PRIMITIVE(EnumMemberName);
+    PRIMITIVE(enumToInt);
+    PRIMITIVE(intToEnum);
+
+    PRIMITIVE(StringLiteralP);
+    PRIMITIVE(stringLiteralByteIndex);
+    PRIMITIVE(stringLiteralBytes);
+    PRIMITIVE(stringLiteralByteSize);
+    PRIMITIVE(stringLiteralByteSlice);
+    PRIMITIVE(stringLiteralConcat);
+    PRIMITIVE(stringLiteralFromBytes);
+
+    PRIMITIVE(stringTableConstant);
+
+    PRIMITIVE(OrderUnordered);
+    PRIMITIVE(OrderMonotonic);
+    PRIMITIVE(OrderAcquire);
+    PRIMITIVE(OrderRelease);
+    PRIMITIVE(OrderAcqRel);
+    PRIMITIVE(OrderSeqCst);
+
+    PRIMITIVE(FlagP);
+    PRIMITIVE(Flag);
+
+    PRIMITIVE(atomicFence);
+    PRIMITIVE(atomicRMW);
+    PRIMITIVE(atomicLoad);
+    PRIMITIVE(atomicStore);
+    PRIMITIVE(atomicCompareExchange);
+
+    PRIMITIVE(RMWXchg);
+    PRIMITIVE(RMWAdd);
+    PRIMITIVE(RMWSubtract);
+    PRIMITIVE(RMWAnd);
+    PRIMITIVE(RMWNAnd);
+    PRIMITIVE(RMWOr);
+    PRIMITIVE(RMWXor);
+    PRIMITIVE(RMWMin);
+    PRIMITIVE(RMWMax);
+    PRIMITIVE(RMWUMin);
+    PRIMITIVE(RMWUMax);
+
+    PRIMITIVE(activeException);
+
+    PRIMITIVE(memcpy);
+    PRIMITIVE(memmove);
+
+    PRIMITIVE(countValues);
+    PRIMITIVE(nthValue);
+    PRIMITIVE(withoutNthValue);
+    PRIMITIVE(takeValues);
+    PRIMITIVE(dropValues);
+
+    PRIMITIVE(LambdaRecordP);
+    PRIMITIVE(LambdaSymbolP);
+    PRIMITIVE(LambdaMonoP);
+    PRIMITIVE(LambdaMonoInputTypes);
+
+    PRIMITIVE(GetOverload);
+
+    PRIMITIVE(usuallyEquals);
 
 #undef PRIMITIVE
 
-        return prims;
-    }
+    return prims;
+}
 
-    static void addOperator(ModulePtr module, llvm::StringRef name) {
-        IdentifierPtr ident = Identifier::get(name);
-        ProcedurePtr opProc = new Procedure(module.ptr(), ident, PUBLIC, false);
-        opProc->env = new Env(module);
-        addGlobal(module, ident, PUBLIC, opProc.ptr());
-    }
+static void addOperator(ModulePtr module, llvm::StringRef name) {
+    IdentifierPtr ident = Identifier::get(name);
+    ProcedurePtr opProc = new Procedure(module.ptr(), ident, PUBLIC, false);
+    opProc->env = new Env(module);
+    addGlobal(module, ident, PUBLIC, opProc.ptr());
+}
 
-    static ModulePtr makeOperatorsModule() {
-        ModulePtr operators = new Module("__operators__");
+static ModulePtr makeOperatorsModule() {
+    ModulePtr operators = new Module("__operators__");
 
 #define OPERATOR(x) addOperator(operators, toPrimStr(#x))
 
-        OPERATOR(dereference);
-        OPERATOR(prefixOperator);
-        OPERATOR(infixOperator);
-        OPERATOR(caseP);
-        OPERATOR(tupleLiteral);
-        OPERATOR(staticIndex);
-        OPERATOR(index);
-        OPERATOR(fieldRef);
-        OPERATOR(call);
-        OPERATOR(destroy);
-        OPERATOR(copy);
-        OPERATOR(move);
-        OPERATOR(assign);
-        OPERATOR(updateAssign);
-        OPERATOR(prefixUpdateAssign);
-        OPERATOR(indexAssign);
-        OPERATOR(indexUpdateAssign);
-        OPERATOR(fieldRefAssign);
-        OPERATOR(fieldRefUpdateAssign);
-        OPERATOR(staticIndexAssign);
-        OPERATOR(staticIndexUpdateAssign);
-        OPERATOR(callMain);
-        OPERATOR(charLiteral);
-        OPERATOR(wrapStatic);
-        OPERATOR(iterator);
-        OPERATOR(nextValue);
-        OPERATOR(hasValueP);
-        OPERATOR(getValue);
-        OPERATOR(throwValue);
-        OPERATOR(exceptionIsP);
-        OPERATOR(exceptionAs);
-        OPERATOR(exceptionAsAny);
-        OPERATOR(continueException);
-        OPERATOR(unhandledExceptionInExternal);
-        OPERATOR(exceptionInInitializer);
-        OPERATOR(exceptionInFinalizer);
-        OPERATOR(packMultiValuedFreeVarByRef);
-        OPERATOR(packMultiValuedFreeVar);
-        OPERATOR(unpackMultiValuedFreeVarAndDereference);
-        OPERATOR(unpackMultiValuedFreeVar);
-        OPERATOR(variantReprType);
-        OPERATOR(DispatchTagCount);
-        OPERATOR(dispatchTag);
-        OPERATOR(dispatchIndex);
-        OPERATOR(invalidDispatch);
-        OPERATOR(stringLiteral);
-        OPERATOR(ifExpression);
-        OPERATOR(asExpression);
-        OPERATOR(typeToRValue);
-        OPERATOR(typesToRValues);
-        OPERATOR(doIntegerAddChecked);
-        OPERATOR(doIntegerSubtractChecked);
-        OPERATOR(doIntegerMultiplyChecked);
-        OPERATOR(doIntegerQuotientChecked);
-        OPERATOR(doIntegerRemainderChecked);
-        OPERATOR(doIntegerShiftLeftChecked);
-        OPERATOR(doIntegerNegateChecked);
-        OPERATOR(doIntegerConvertChecked);
+    OPERATOR(dereference);
+    OPERATOR(prefixOperator);
+    OPERATOR(infixOperator);
+    OPERATOR(caseP);
+    OPERATOR(tupleLiteral);
+    OPERATOR(staticIndex);
+    OPERATOR(index);
+    OPERATOR(fieldRef);
+    OPERATOR(call);
+    OPERATOR(destroy);
+    OPERATOR(copy);
+    OPERATOR(move);
+    OPERATOR(assign);
+    OPERATOR(updateAssign);
+    OPERATOR(prefixUpdateAssign);
+    OPERATOR(indexAssign);
+    OPERATOR(indexUpdateAssign);
+    OPERATOR(fieldRefAssign);
+    OPERATOR(fieldRefUpdateAssign);
+    OPERATOR(staticIndexAssign);
+    OPERATOR(staticIndexUpdateAssign);
+    OPERATOR(callMain);
+    OPERATOR(charLiteral);
+    OPERATOR(wrapStatic);
+    OPERATOR(iterator);
+    OPERATOR(nextValue);
+    OPERATOR(hasValueP);
+    OPERATOR(getValue);
+    OPERATOR(throwValue);
+    OPERATOR(exceptionIsP);
+    OPERATOR(exceptionAs);
+    OPERATOR(exceptionAsAny);
+    OPERATOR(continueException);
+    OPERATOR(unhandledExceptionInExternal);
+    OPERATOR(exceptionInInitializer);
+    OPERATOR(exceptionInFinalizer);
+    OPERATOR(packMultiValuedFreeVarByRef);
+    OPERATOR(packMultiValuedFreeVar);
+    OPERATOR(unpackMultiValuedFreeVarAndDereference);
+    OPERATOR(unpackMultiValuedFreeVar);
+    OPERATOR(variantReprType);
+    OPERATOR(DispatchTagCount);
+    OPERATOR(dispatchTag);
+    OPERATOR(dispatchIndex);
+    OPERATOR(invalidDispatch);
+    OPERATOR(stringLiteral);
+    OPERATOR(ifExpression);
+    OPERATOR(asExpression);
+    OPERATOR(typeToRValue);
+    OPERATOR(typesToRValues);
+    OPERATOR(doIntegerAddChecked);
+    OPERATOR(doIntegerSubtractChecked);
+    OPERATOR(doIntegerMultiplyChecked);
+    OPERATOR(doIntegerQuotientChecked);
+    OPERATOR(doIntegerRemainderChecked);
+    OPERATOR(doIntegerShiftLeftChecked);
+    OPERATOR(doIntegerNegateChecked);
+    OPERATOR(doIntegerConvertChecked);
 
 #undef OPERATOR
 
-        return operators;
-    }
+    return operators;
+}
 
-    ModulePtr makeIntrinsicsModule() {
-        ModulePtr intrinsics = new Module("__intrinsics__");
-        intrinsics->isIntrinsicsModule = true;
-        return intrinsics;
-    }
+ModulePtr makeIntrinsicsModule() {
+    ModulePtr intrinsics = new Module("__intrinsics__");
+    intrinsics->isIntrinsicsModule = true;
+    return intrinsics;
+}
 
-    //
-    // access names from other modules
-    //
+//
+// access names from other modules
+//
 
-    ModulePtr primitivesModule() {
-        static ModulePtr cached;
-        if (!cached)
-            cached = loadedModule("__primitives__");
-        return cached;
-    }
+ModulePtr primitivesModule() {
+    static ModulePtr cached;
+    if (!cached)
+        cached = loadedModule("__primitives__");
+    return cached;
+}
 
-    ModulePtr intrinsicsModule() {
-        static ModulePtr cached;
-        if (!cached)
-            cached = loadedModule("__intrinsics__");
-        return cached;
-    }
+ModulePtr intrinsicsModule() {
+    static ModulePtr cached;
+    if (!cached)
+        cached = loadedModule("__intrinsics__");
+    return cached;
+}
 
-    ModulePtr operatorsModule() {
-        static ModulePtr cached;
-        if (!cached)
-            cached = loadedModule("__operators__");
-        return cached;
-    }
+ModulePtr operatorsModule() {
+    static ModulePtr cached;
+    if (!cached)
+        cached = loadedModule("__operators__");
+    return cached;
+}
 
-    ModulePtr preludeModule() {
-        static ModulePtr cached;
-        if (!cached)
-            cached = loadedModule("prelude");
-        return cached;
-    }
+ModulePtr preludeModule() {
+    static ModulePtr cached;
+    if (!cached)
+        cached = loadedModule("prelude");
+    return cached;
+}
 
-    static IdentifierPtr fnameToIdent(llvm::StringRef str) {
-        string s = str;
-        if ((s.size() > 0) && (s[s.size() - 1] == 'P'))
-            s[s.size() - 1] = '?';
-        return Identifier::get(s);
-    }
+static IdentifierPtr fnameToIdent(llvm::StringRef str) {
+    string s = str;
+    if ((s.size() > 0) && (s[s.size() - 1] == 'P'))
+        s[s.size() - 1] = '?';
+    return Identifier::get(s);
+}
 
-    static ObjectPtr convertObject(ObjectPtr x) {
-        switch (x->objKind) {
-            case RECORD_DECL: {
-                RecordDecl *y = (RecordDecl *) x.ptr();
-                if (y->params.empty() && !y->varParam.ptr())
-                    return recordType(y, vector<ObjectPtr>()).ptr();
-                return x;
-            }
-            case VARIANT_DECL: {
-                VariantDecl *y = (VariantDecl *) x.ptr();
-                if (y->params.empty() && !y->varParam.ptr())
-                    return variantType(y, vector<ObjectPtr>()).ptr();
-                return x;
-            }
-            default:
-                return x;
-        }
+static ObjectPtr convertObject(ObjectPtr x) {
+    switch (x->objKind) {
+    case RECORD_DECL: {
+        RecordDecl *y = (RecordDecl *)x.ptr();
+        if (y->params.empty() && !y->varParam.ptr())
+            return recordType(y, vector<ObjectPtr>()).ptr();
+        return x;
     }
+    case VARIANT_DECL: {
+        VariantDecl *y = (VariantDecl *)x.ptr();
+        if (y->params.empty() && !y->varParam.ptr())
+            return variantType(y, vector<ObjectPtr>()).ptr();
+        return x;
+    }
+    default:
+        return x;
+    }
+}
 
-#define DEFINE_PRIMITIVE_ACCESSOR(name) \
-    ObjectPtr primitive_##name() { \
-        static ObjectPtr cached; \
-        if (!cached) { \
-            cached = safeLookupPublic(primitivesModule(), fnameToIdent(#name)); \
-            cached = convertObject(cached); \
-        } \
-        return cached; \
-    } \
-    \
-    ExprPtr primitive_expr_##name() { \
-        static ExprPtr cached; \
-        if (!cached) \
-            cached = new ObjectExpr(primitive_##name()); \
-        return cached; \
+#define DEFINE_PRIMITIVE_ACCESSOR(name)                                        \
+    ObjectPtr primitive_##name() {                                             \
+        static ObjectPtr cached;                                               \
+        if (!cached) {                                                         \
+            cached =                                                           \
+                safeLookupPublic(primitivesModule(), fnameToIdent(#name));     \
+            cached = convertObject(cached);                                    \
+        }                                                                      \
+        return cached;                                                         \
+    }                                                                          \
+                                                                               \
+    ExprPtr primitive_expr_##name() {                                          \
+        static ExprPtr cached;                                                 \
+        if (!cached)                                                           \
+            cached = new ObjectExpr(primitive_##name());                       \
+        return cached;                                                         \
     }
 
-    DEFINE_PRIMITIVE_ACCESSOR(addressOf)
-    DEFINE_PRIMITIVE_ACCESSOR(boolNot)
-    DEFINE_PRIMITIVE_ACCESSOR(Pointer)
-    DEFINE_PRIMITIVE_ACCESSOR(CodePointer)
-    DEFINE_PRIMITIVE_ACCESSOR(ExternalCodePointer)
-    DEFINE_PRIMITIVE_ACCESSOR(AttributeCCall)
-    DEFINE_PRIMITIVE_ACCESSOR(AttributeStdCall)
-    DEFINE_PRIMITIVE_ACCESSOR(AttributeFastCall)
-    DEFINE_PRIMITIVE_ACCESSOR(AttributeThisCall)
-    DEFINE_PRIMITIVE_ACCESSOR(AttributeLLVMCall)
-    DEFINE_PRIMITIVE_ACCESSOR(Array)
-    DEFINE_PRIMITIVE_ACCESSOR(Vec)
-    DEFINE_PRIMITIVE_ACCESSOR(Tuple)
-    DEFINE_PRIMITIVE_ACCESSOR(Union)
-    DEFINE_PRIMITIVE_ACCESSOR(Static)
-    DEFINE_PRIMITIVE_ACCESSOR(activeException)
-    DEFINE_PRIMITIVE_ACCESSOR(ByRef)
-    DEFINE_PRIMITIVE_ACCESSOR(RecordWithProperties)
-
-#define DEFINE_OPERATOR_ACCESSOR(name) \
-    ObjectPtr operator_##name() { \
-        static ObjectPtr cached; \
-        if (!cached) { \
+DEFINE_PRIMITIVE_ACCESSOR(addressOf)
+DEFINE_PRIMITIVE_ACCESSOR(boolNot)
+DEFINE_PRIMITIVE_ACCESSOR(Pointer)
+DEFINE_PRIMITIVE_ACCESSOR(CodePointer)
+DEFINE_PRIMITIVE_ACCESSOR(ExternalCodePointer)
+DEFINE_PRIMITIVE_ACCESSOR(AttributeCCall)
+DEFINE_PRIMITIVE_ACCESSOR(AttributeStdCall)
+DEFINE_PRIMITIVE_ACCESSOR(AttributeFastCall)
+DEFINE_PRIMITIVE_ACCESSOR(AttributeThisCall)
+DEFINE_PRIMITIVE_ACCESSOR(AttributeLLVMCall)
+DEFINE_PRIMITIVE_ACCESSOR(Array)
+DEFINE_PRIMITIVE_ACCESSOR(Vec)
+DEFINE_PRIMITIVE_ACCESSOR(Tuple)
+DEFINE_PRIMITIVE_ACCESSOR(Union)
+DEFINE_PRIMITIVE_ACCESSOR(Static)
+DEFINE_PRIMITIVE_ACCESSOR(activeException)
+DEFINE_PRIMITIVE_ACCESSOR(ByRef)
+DEFINE_PRIMITIVE_ACCESSOR(RecordWithProperties)
+
+#define DEFINE_OPERATOR_ACCESSOR(name)                                         \
+    ObjectPtr operator_##name() {                                              \
+        static ObjectPtr cached;                                               \
+        if (!cached) {                                                         \
             cached = safeLookupPublic(operatorsModule(), fnameToIdent(#name)); \
-            cached = convertObject(cached); \
-        } \
-        return cached; \
-    } \
-    \
-    ExprPtr operator_expr_##name() { \
-        static ExprPtr cached; \
-        if (!cached) \
-            cached = new ObjectExpr(operator_##name()); \
-        return cached; \
+            cached = convertObject(cached);                                    \
+        }                                                                      \
+        return cached;                                                         \
+    }                                                                          \
+                                                                               \
+    ExprPtr operator_expr_##name() {                                           \
+        static ExprPtr cached;                                                 \
+        if (!cached)                                                           \
+            cached = new ObjectExpr(operator_##name());                        \
+        return cached;                                                         \
     }
 
-    DEFINE_OPERATOR_ACCESSOR(dereference)
-    DEFINE_OPERATOR_ACCESSOR(prefixOperator)
-    DEFINE_OPERATOR_ACCESSOR(infixOperator)
-    DEFINE_OPERATOR_ACCESSOR(caseP)
-    DEFINE_OPERATOR_ACCESSOR(tupleLiteral)
-    DEFINE_OPERATOR_ACCESSOR(staticIndex)
-    DEFINE_OPERATOR_ACCESSOR(index)
-    DEFINE_OPERATOR_ACCESSOR(fieldRef)
-    DEFINE_OPERATOR_ACCESSOR(call)
-    DEFINE_OPERATOR_ACCESSOR(destroy)
-    DEFINE_OPERATOR_ACCESSOR(copy)
-    DEFINE_OPERATOR_ACCESSOR(move)
-    DEFINE_OPERATOR_ACCESSOR(assign)
-    DEFINE_OPERATOR_ACCESSOR(updateAssign)
-    DEFINE_OPERATOR_ACCESSOR(prefixUpdateAssign)
-    DEFINE_OPERATOR_ACCESSOR(indexAssign)
-    DEFINE_OPERATOR_ACCESSOR(indexUpdateAssign)
-    DEFINE_OPERATOR_ACCESSOR(fieldRefAssign)
-    DEFINE_OPERATOR_ACCESSOR(fieldRefUpdateAssign)
-    DEFINE_OPERATOR_ACCESSOR(staticIndexAssign)
-    DEFINE_OPERATOR_ACCESSOR(staticIndexUpdateAssign)
-    DEFINE_OPERATOR_ACCESSOR(callMain)
-    DEFINE_OPERATOR_ACCESSOR(charLiteral)
-    DEFINE_OPERATOR_ACCESSOR(iterator)
-    DEFINE_OPERATOR_ACCESSOR(nextValue)
-    DEFINE_OPERATOR_ACCESSOR(hasValueP)
-    DEFINE_OPERATOR_ACCESSOR(getValue)
-    DEFINE_OPERATOR_ACCESSOR(throwValue)
-    DEFINE_OPERATOR_ACCESSOR(exceptionIsP)
-    DEFINE_OPERATOR_ACCESSOR(exceptionAs)
-    DEFINE_OPERATOR_ACCESSOR(exceptionAsAny)
-    DEFINE_OPERATOR_ACCESSOR(continueException)
-    DEFINE_OPERATOR_ACCESSOR(unhandledExceptionInExternal)
-    DEFINE_OPERATOR_ACCESSOR(exceptionInInitializer)
-    DEFINE_OPERATOR_ACCESSOR(exceptionInFinalizer)
-    DEFINE_OPERATOR_ACCESSOR(packMultiValuedFreeVarByRef)
-    DEFINE_OPERATOR_ACCESSOR(packMultiValuedFreeVar)
-    DEFINE_OPERATOR_ACCESSOR(unpackMultiValuedFreeVarAndDereference)
-    DEFINE_OPERATOR_ACCESSOR(unpackMultiValuedFreeVar)
-    DEFINE_OPERATOR_ACCESSOR(variantReprType)
-    DEFINE_OPERATOR_ACCESSOR(DispatchTagCount)
-    DEFINE_OPERATOR_ACCESSOR(dispatchTag)
-    DEFINE_OPERATOR_ACCESSOR(dispatchIndex)
-    DEFINE_OPERATOR_ACCESSOR(invalidDispatch)
-    DEFINE_OPERATOR_ACCESSOR(stringLiteral)
-    DEFINE_OPERATOR_ACCESSOR(ifExpression)
-    DEFINE_OPERATOR_ACCESSOR(asExpression)
-    DEFINE_OPERATOR_ACCESSOR(typeToRValue)
-    DEFINE_OPERATOR_ACCESSOR(typesToRValues)
-    DEFINE_OPERATOR_ACCESSOR(doIntegerAddChecked)
-    DEFINE_OPERATOR_ACCESSOR(doIntegerSubtractChecked)
-    DEFINE_OPERATOR_ACCESSOR(doIntegerMultiplyChecked)
-    DEFINE_OPERATOR_ACCESSOR(doIntegerQuotientChecked)
-    DEFINE_OPERATOR_ACCESSOR(doIntegerRemainderChecked)
-    DEFINE_OPERATOR_ACCESSOR(doIntegerShiftLeftChecked)
-    DEFINE_OPERATOR_ACCESSOR(doIntegerNegateChecked)
-    DEFINE_OPERATOR_ACCESSOR(doIntegerConvertChecked)
-
-    void addGlobals(ModulePtr m, llvm::ArrayRef<TopLevelItemPtr> toplevels) {
-        TopLevelItemPtr const *i, *end;
-        for (i = toplevels.begin(), end = toplevels.end();
-             i != end; ++i) {
-            m->topLevelItems.push_back(*i);
-            TopLevelItem *x = i->ptr();
-            x->env = m->env;
-            switch (x->objKind) {
-                case ENUM_DECL: {
-                    EnumDecl *enumer = (EnumDecl *) x;
-                    TypePtr t = enumType(enumer);
-                    addGlobal(m, enumer->name, enumer->visibility, t.ptr());
-                    for (size_t i = 0; i < enumer->members.size(); ++i) {
-                        EnumMember *member = enumer->members[i].ptr();
-                        member->index = (int) i;
-                        member->type = t;
-                        addGlobal(m, member->name, enumer->visibility, member);
-                    }
-                    break;
-                }
-                case PROCEDURE: {
-                    Procedure *proc = (Procedure *) x;
-                    if (proc->interface != nullptr)
-                        proc->interface->env = m->env;
-                    // fallthrough
-                }
-                default:
-                    if (x->name.ptr())
-                        addGlobal(m, x->name, x->visibility, x);
-                    break;
+DEFINE_OPERATOR_ACCESSOR(dereference)
+DEFINE_OPERATOR_ACCESSOR(prefixOperator)
+DEFINE_OPERATOR_ACCESSOR(infixOperator)
+DEFINE_OPERATOR_ACCESSOR(caseP)
+DEFINE_OPERATOR_ACCESSOR(tupleLiteral)
+DEFINE_OPERATOR_ACCESSOR(staticIndex)
+DEFINE_OPERATOR_ACCESSOR(index)
+DEFINE_OPERATOR_ACCESSOR(fieldRef)
+DEFINE_OPERATOR_ACCESSOR(call)
+DEFINE_OPERATOR_ACCESSOR(destroy)
+DEFINE_OPERATOR_ACCESSOR(copy)
+DEFINE_OPERATOR_ACCESSOR(move)
+DEFINE_OPERATOR_ACCESSOR(assign)
+DEFINE_OPERATOR_ACCESSOR(updateAssign)
+DEFINE_OPERATOR_ACCESSOR(prefixUpdateAssign)
+DEFINE_OPERATOR_ACCESSOR(indexAssign)
+DEFINE_OPERATOR_ACCESSOR(indexUpdateAssign)
+DEFINE_OPERATOR_ACCESSOR(fieldRefAssign)
+DEFINE_OPERATOR_ACCESSOR(fieldRefUpdateAssign)
+DEFINE_OPERATOR_ACCESSOR(staticIndexAssign)
+DEFINE_OPERATOR_ACCESSOR(staticIndexUpdateAssign)
+DEFINE_OPERATOR_ACCESSOR(callMain)
+DEFINE_OPERATOR_ACCESSOR(charLiteral)
+DEFINE_OPERATOR_ACCESSOR(iterator)
+DEFINE_OPERATOR_ACCESSOR(nextValue)
+DEFINE_OPERATOR_ACCESSOR(hasValueP)
+DEFINE_OPERATOR_ACCESSOR(getValue)
+DEFINE_OPERATOR_ACCESSOR(throwValue)
+DEFINE_OPERATOR_ACCESSOR(exceptionIsP)
+DEFINE_OPERATOR_ACCESSOR(exceptionAs)
+DEFINE_OPERATOR_ACCESSOR(exceptionAsAny)
+DEFINE_OPERATOR_ACCESSOR(continueException)
+DEFINE_OPERATOR_ACCESSOR(unhandledExceptionInExternal)
+DEFINE_OPERATOR_ACCESSOR(exceptionInInitializer)
+DEFINE_OPERATOR_ACCESSOR(exceptionInFinalizer)
+DEFINE_OPERATOR_ACCESSOR(packMultiValuedFreeVarByRef)
+DEFINE_OPERATOR_ACCESSOR(packMultiValuedFreeVar)
+DEFINE_OPERATOR_ACCESSOR(unpackMultiValuedFreeVarAndDereference)
+DEFINE_OPERATOR_ACCESSOR(unpackMultiValuedFreeVar)
+DEFINE_OPERATOR_ACCESSOR(variantReprType)
+DEFINE_OPERATOR_ACCESSOR(DispatchTagCount)
+DEFINE_OPERATOR_ACCESSOR(dispatchTag)
+DEFINE_OPERATOR_ACCESSOR(dispatchIndex)
+DEFINE_OPERATOR_ACCESSOR(invalidDispatch)
+DEFINE_OPERATOR_ACCESSOR(stringLiteral)
+DEFINE_OPERATOR_ACCESSOR(ifExpression)
+DEFINE_OPERATOR_ACCESSOR(asExpression)
+DEFINE_OPERATOR_ACCESSOR(typeToRValue)
+DEFINE_OPERATOR_ACCESSOR(typesToRValues)
+DEFINE_OPERATOR_ACCESSOR(doIntegerAddChecked)
+DEFINE_OPERATOR_ACCESSOR(doIntegerSubtractChecked)
+DEFINE_OPERATOR_ACCESSOR(doIntegerMultiplyChecked)
+DEFINE_OPERATOR_ACCESSOR(doIntegerQuotientChecked)
+DEFINE_OPERATOR_ACCESSOR(doIntegerRemainderChecked)
+DEFINE_OPERATOR_ACCESSOR(doIntegerShiftLeftChecked)
+DEFINE_OPERATOR_ACCESSOR(doIntegerNegateChecked)
+DEFINE_OPERATOR_ACCESSOR(doIntegerConvertChecked)
+
+void addGlobals(ModulePtr m, llvm::ArrayRef<TopLevelItemPtr> toplevels) {
+    TopLevelItemPtr const *i, *end;
+    for (i = toplevels.begin(), end = toplevels.end(); i != end; ++i) {
+        m->topLevelItems.push_back(*i);
+        TopLevelItem *x = i->ptr();
+        x->env = m->env;
+        switch (x->objKind) {
+        case ENUM_DECL: {
+            EnumDecl *enumer = (EnumDecl *)x;
+            TypePtr t = enumType(enumer);
+            addGlobal(m, enumer->name, enumer->visibility, t.ptr());
+            for (size_t i = 0; i < enumer->members.size(); ++i) {
+                EnumMember *member = enumer->members[i].ptr();
+                member->index = (int)i;
+                member->type = t;
+                addGlobal(m, member->name, enumer->visibility, member);
             }
+            break;
+        }
+        case PROCEDURE: {
+            Procedure *proc = (Procedure *)x;
+            if (proc->interface != nullptr)
+                proc->interface->env = m->env;
+            // fallthrough
         }
+        default:
+            if (x->name.ptr())
+                addGlobal(m, x->name, x->visibility, x);
+            break;
+        }
+    }
 
-        llvm::ArrayRef<TopLevelItemPtr> items = m->topLevelItems;
-        for (size_t i = items.size() - toplevels.size(); i < items.size(); ++i) {
-            Object *obj = items[i].ptr();
-            switch (obj->objKind) {
-                case OVERLOAD:
-                    initOverload((Overload *) obj);
-                    break;
-                case INSTANCE_DECL:
-                    initVariantInstance((InstanceDecl *) obj);
-                    break;
-                case STATIC_ASSERT_TOP_LEVEL:
-                    checkStaticAssert((StaticAssertTopLevel *) obj);
-                    break;
-                default:
-                    break;
-            }
+    llvm::ArrayRef<TopLevelItemPtr> items = m->topLevelItems;
+    for (size_t i = items.size() - toplevels.size(); i < items.size(); ++i) {
+        Object *obj = items[i].ptr();
+        switch (obj->objKind) {
+        case OVERLOAD:
+            initOverload((Overload *)obj);
+            break;
+        case INSTANCE_DECL:
+            initVariantInstance((InstanceDecl *)obj);
+            break;
+        case STATIC_ASSERT_TOP_LEVEL:
+            checkStaticAssert((StaticAssertTopLevel *)obj);
+            break;
+        default:
+            break;
         }
     }
 }
+} // namespace clay
diff --git a/compiler/loader.hpp b/compiler/loader.hpp
index 0f0cada9..60e125ec 100644
--- a/compiler/loader.hpp
+++ b/compiler/loader.hpp
@@ -3,241 +3,242 @@
 #include "clay.hpp"
 
 namespace clay {
-    extern llvm::StringMap<ModulePtr> globalModules;
-    extern llvm::StringMap<string> globalFlags;
-    extern ModulePtr globalMainModule;
-
-    void addOverload(vector<OverloadPtr> &overloads, OverloadPtr &x);
-    void addProcedureOverload(ProcedurePtr proc, EnvPtr Env, OverloadPtr x);
-    void getProcedureMonoTypes(ProcedureMono &mono, EnvPtr env,
-                               llvm::ArrayRef<FormalArgPtr> formalArgs, bool hasVarArg);
-
-    void initLoader();
-    void setSearchPath(llvm::ArrayRef<PathString> path);
-    ModulePtr loadProgram(llvm::StringRef fileName, vector<string> *sourceFiles, bool verbose, bool repl);
-    ModulePtr loadProgramSource(llvm::StringRef name, llvm::StringRef source, bool verbose, bool repl);
-    ModulePtr loadedModule(llvm::StringRef module);
-    ModulePtr preludeModule();
-    ModulePtr primitivesModule();
-    ModulePtr operatorsModule();
-    ModulePtr intrinsicsModule();
-    ModulePtr staticModule(ObjectPtr x);
-
-    void addGlobals(ModulePtr m, llvm::ArrayRef<TopLevelItemPtr> toplevels);
-    void loadDependent(ModulePtr m, vector<string> *sourceFiles, ImportPtr dependent, bool verbose);
-    void initModule(ModulePtr m);
-
-
-    //
-    // PrimOp
-    //
-
-    enum PrimOpCode {
-        PRIM_TypeP,
-        PRIM_TypeSize,
-        PRIM_TypeAlignment,
-
-        PRIM_OperatorP,
-        PRIM_SymbolP,
-
-        PRIM_StaticCallDefinedP,
-        PRIM_StaticCallOutputTypes,
-
-        PRIM_StaticMonoP,
-        PRIM_StaticMonoInputTypes,
-
-        PRIM_bitcopy,
-        PRIM_bitcast,
-
-        PRIM_boolNot,
-
-        PRIM_numericAdd,
-        PRIM_numericSubtract,
-        PRIM_numericMultiply,
-        PRIM_floatDivide,
-        PRIM_numericNegate,
-
-        PRIM_integerQuotient,
-        PRIM_integerRemainder,
-        PRIM_integerShiftLeft,
-        PRIM_integerShiftRight,
-        PRIM_integerBitwiseAnd,
-        PRIM_integerBitwiseOr,
-        PRIM_integerBitwiseXor,
-        PRIM_integerBitwiseNot,
-        PRIM_integerEqualsP,
-        PRIM_integerLesserP,
-
-        PRIM_numericConvert,
-
-        PRIM_integerAddChecked,
-        PRIM_integerSubtractChecked,
-        PRIM_integerMultiplyChecked,
-        PRIM_integerQuotientChecked,
-        PRIM_integerRemainderChecked,
-        PRIM_integerNegateChecked,
-        PRIM_integerShiftLeftChecked,
-        PRIM_integerConvertChecked,
-
-        PRIM_floatOrderedEqualsP,
-        PRIM_floatOrderedLesserP,
-        PRIM_floatOrderedLesserEqualsP,
-        PRIM_floatOrderedGreaterP,
-        PRIM_floatOrderedGreaterEqualsP,
-        PRIM_floatOrderedNotEqualsP,
-        PRIM_floatOrderedP,
-        PRIM_floatUnorderedEqualsP,
-        PRIM_floatUnorderedLesserP,
-        PRIM_floatUnorderedLesserEqualsP,
-        PRIM_floatUnorderedGreaterP,
-        PRIM_floatUnorderedGreaterEqualsP,
-        PRIM_floatUnorderedNotEqualsP,
-        PRIM_floatUnorderedP,
-
-        PRIM_Pointer,
-
-        PRIM_addressOf,
-        PRIM_pointerDereference,
-        PRIM_pointerOffset,
-        PRIM_pointerToInt,
-        PRIM_intToPointer,
-        PRIM_nullPointer,
-
-        PRIM_CodePointer,
-        PRIM_makeCodePointer,
-
-        PRIM_AttributeStdCall,
-        PRIM_AttributeFastCall,
-        PRIM_AttributeThisCall,
-        PRIM_AttributeCCall,
-        PRIM_AttributeLLVMCall,
-        PRIM_AttributeDLLImport,
-        PRIM_AttributeDLLExport,
-
-        PRIM_ExternalCodePointer,
-        PRIM_makeExternalCodePointer,
-        PRIM_callExternalCodePointer,
-
-        PRIM_Array,
-        PRIM_arrayRef,
-        PRIM_arrayElements,
-
-        PRIM_Vec,
-
-        PRIM_Tuple,
-        PRIM_TupleElementCount,
-        PRIM_tupleRef,
-        PRIM_tupleElements,
-
-        PRIM_Union,
-        PRIM_UnionMemberCount,
-
-        PRIM_RecordP,
-        PRIM_RecordFieldCount,
-        PRIM_RecordFieldName,
-        PRIM_RecordWithFieldP,
-        PRIM_recordFieldRef,
-        PRIM_recordFieldRefByName,
-        PRIM_recordFields,
-        PRIM_recordVariadicField,
-
-        PRIM_VariantP,
-        PRIM_VariantMemberIndex,
-        PRIM_VariantMemberCount,
-        PRIM_VariantMembers,
-
-        PRIM_BaseType,
-
-        PRIM_Static,
-        PRIM_StaticName,
-        PRIM_staticIntegers,
-        PRIM_integers,
-        PRIM_staticFieldRef,
-
-        PRIM_MainModule,
-        PRIM_StaticModule,
-        PRIM_ModuleName,
-        PRIM_ModuleMemberNames,
-
-        PRIM_EnumP,
-        PRIM_EnumMemberCount,
-        PRIM_EnumMemberName,
-        PRIM_enumToInt,
-        PRIM_intToEnum,
-
-        PRIM_StringLiteralP,
-        PRIM_stringLiteralByteIndex,
-        PRIM_stringLiteralBytes,
-        PRIM_stringLiteralByteSize,
-        PRIM_stringLiteralByteSlice,
-        PRIM_stringLiteralConcat,
-        PRIM_stringLiteralFromBytes,
-
-        PRIM_stringTableConstant,
-
-        PRIM_FlagP,
-        PRIM_Flag,
-
-        PRIM_atomicFence,
-        PRIM_atomicRMW,
-        PRIM_atomicLoad,
-        PRIM_atomicStore,
-        PRIM_atomicCompareExchange,
-
-        PRIM_OrderUnordered,
-        PRIM_OrderMonotonic,
-        PRIM_OrderAcquire,
-        PRIM_OrderRelease,
-        PRIM_OrderAcqRel,
-        PRIM_OrderSeqCst,
-
-        PRIM_RMWXchg,
-        PRIM_RMWAdd,
-        PRIM_RMWSubtract,
-        PRIM_RMWAnd,
-        PRIM_RMWNAnd,
-        PRIM_RMWOr,
-        PRIM_RMWXor,
-        PRIM_RMWMin,
-        PRIM_RMWMax,
-        PRIM_RMWUMin,
-        PRIM_RMWUMax,
-
-        PRIM_ByRef,
-        PRIM_RecordWithProperties,
-
-        PRIM_activeException,
-
-        PRIM_memcpy,
-        PRIM_memmove,
-
-        PRIM_countValues,
-        PRIM_nthValue,
-        PRIM_withoutNthValue,
-        PRIM_takeValues,
-        PRIM_dropValues,
-
-        PRIM_LambdaRecordP,
-        PRIM_LambdaSymbolP,
-        PRIM_LambdaMonoP,
-        PRIM_LambdaMonoInputTypes,
-
-        PRIM_GetOverload,
-
-        PRIM_usuallyEquals
-    };
-
-    struct PrimOp : public Object {
-        const PrimOpCode primOpCode;
-
-        PrimOp(PrimOpCode primOpCode)
-            : Object(PRIM_OP), primOpCode(primOpCode) {
-        }
-    };
-
-    llvm::StringRef primOpName(PrimOpCode op);
-
-    static inline llvm::StringRef primOpName(const PrimOpPtr &x) {
-        return primOpName(x->primOpCode);
-    }
+extern llvm::StringMap<ModulePtr> globalModules;
+extern llvm::StringMap<string> globalFlags;
+extern ModulePtr globalMainModule;
+
+void addOverload(vector<OverloadPtr> &overloads, OverloadPtr &x);
+void addProcedureOverload(ProcedurePtr proc, EnvPtr Env, OverloadPtr x);
+void getProcedureMonoTypes(ProcedureMono &mono, EnvPtr env,
+                           llvm::ArrayRef<FormalArgPtr> formalArgs,
+                           bool hasVarArg);
+
+void initLoader();
+void setSearchPath(llvm::ArrayRef<PathString> path);
+ModulePtr loadProgram(llvm::StringRef fileName, vector<string> *sourceFiles,
+                      bool verbose, bool repl);
+ModulePtr loadProgramSource(llvm::StringRef name, llvm::StringRef source,
+                            bool verbose, bool repl);
+ModulePtr loadedModule(llvm::StringRef module);
+ModulePtr preludeModule();
+ModulePtr primitivesModule();
+ModulePtr operatorsModule();
+ModulePtr intrinsicsModule();
+ModulePtr staticModule(ObjectPtr x);
+
+void addGlobals(ModulePtr m, llvm::ArrayRef<TopLevelItemPtr> toplevels);
+void loadDependent(ModulePtr m, vector<string> *sourceFiles,
+                   ImportPtr dependent, bool verbose);
+void initModule(ModulePtr m);
+
+//
+// PrimOp
+//
+
+enum PrimOpCode {
+    PRIM_TypeP,
+    PRIM_TypeSize,
+    PRIM_TypeAlignment,
+
+    PRIM_OperatorP,
+    PRIM_SymbolP,
+
+    PRIM_StaticCallDefinedP,
+    PRIM_StaticCallOutputTypes,
+
+    PRIM_StaticMonoP,
+    PRIM_StaticMonoInputTypes,
+
+    PRIM_bitcopy,
+    PRIM_bitcast,
+
+    PRIM_boolNot,
+
+    PRIM_numericAdd,
+    PRIM_numericSubtract,
+    PRIM_numericMultiply,
+    PRIM_floatDivide,
+    PRIM_numericNegate,
+
+    PRIM_integerQuotient,
+    PRIM_integerRemainder,
+    PRIM_integerShiftLeft,
+    PRIM_integerShiftRight,
+    PRIM_integerBitwiseAnd,
+    PRIM_integerBitwiseOr,
+    PRIM_integerBitwiseXor,
+    PRIM_integerBitwiseNot,
+    PRIM_integerEqualsP,
+    PRIM_integerLesserP,
+
+    PRIM_numericConvert,
+
+    PRIM_integerAddChecked,
+    PRIM_integerSubtractChecked,
+    PRIM_integerMultiplyChecked,
+    PRIM_integerQuotientChecked,
+    PRIM_integerRemainderChecked,
+    PRIM_integerNegateChecked,
+    PRIM_integerShiftLeftChecked,
+    PRIM_integerConvertChecked,
+
+    PRIM_floatOrderedEqualsP,
+    PRIM_floatOrderedLesserP,
+    PRIM_floatOrderedLesserEqualsP,
+    PRIM_floatOrderedGreaterP,
+    PRIM_floatOrderedGreaterEqualsP,
+    PRIM_floatOrderedNotEqualsP,
+    PRIM_floatOrderedP,
+    PRIM_floatUnorderedEqualsP,
+    PRIM_floatUnorderedLesserP,
+    PRIM_floatUnorderedLesserEqualsP,
+    PRIM_floatUnorderedGreaterP,
+    PRIM_floatUnorderedGreaterEqualsP,
+    PRIM_floatUnorderedNotEqualsP,
+    PRIM_floatUnorderedP,
+
+    PRIM_Pointer,
+
+    PRIM_addressOf,
+    PRIM_pointerDereference,
+    PRIM_pointerOffset,
+    PRIM_pointerToInt,
+    PRIM_intToPointer,
+    PRIM_nullPointer,
+
+    PRIM_CodePointer,
+    PRIM_makeCodePointer,
+
+    PRIM_AttributeStdCall,
+    PRIM_AttributeFastCall,
+    PRIM_AttributeThisCall,
+    PRIM_AttributeCCall,
+    PRIM_AttributeLLVMCall,
+    PRIM_AttributeDLLImport,
+    PRIM_AttributeDLLExport,
+
+    PRIM_ExternalCodePointer,
+    PRIM_makeExternalCodePointer,
+    PRIM_callExternalCodePointer,
+
+    PRIM_Array,
+    PRIM_arrayRef,
+    PRIM_arrayElements,
+
+    PRIM_Vec,
+
+    PRIM_Tuple,
+    PRIM_TupleElementCount,
+    PRIM_tupleRef,
+    PRIM_tupleElements,
+
+    PRIM_Union,
+    PRIM_UnionMemberCount,
+
+    PRIM_RecordP,
+    PRIM_RecordFieldCount,
+    PRIM_RecordFieldName,
+    PRIM_RecordWithFieldP,
+    PRIM_recordFieldRef,
+    PRIM_recordFieldRefByName,
+    PRIM_recordFields,
+    PRIM_recordVariadicField,
+
+    PRIM_VariantP,
+    PRIM_VariantMemberIndex,
+    PRIM_VariantMemberCount,
+    PRIM_VariantMembers,
+
+    PRIM_BaseType,
+
+    PRIM_Static,
+    PRIM_StaticName,
+    PRIM_staticIntegers,
+    PRIM_integers,
+    PRIM_staticFieldRef,
+
+    PRIM_MainModule,
+    PRIM_StaticModule,
+    PRIM_ModuleName,
+    PRIM_ModuleMemberNames,
+
+    PRIM_EnumP,
+    PRIM_EnumMemberCount,
+    PRIM_EnumMemberName,
+    PRIM_enumToInt,
+    PRIM_intToEnum,
+
+    PRIM_StringLiteralP,
+    PRIM_stringLiteralByteIndex,
+    PRIM_stringLiteralBytes,
+    PRIM_stringLiteralByteSize,
+    PRIM_stringLiteralByteSlice,
+    PRIM_stringLiteralConcat,
+    PRIM_stringLiteralFromBytes,
+
+    PRIM_stringTableConstant,
+
+    PRIM_FlagP,
+    PRIM_Flag,
+
+    PRIM_atomicFence,
+    PRIM_atomicRMW,
+    PRIM_atomicLoad,
+    PRIM_atomicStore,
+    PRIM_atomicCompareExchange,
+
+    PRIM_OrderUnordered,
+    PRIM_OrderMonotonic,
+    PRIM_OrderAcquire,
+    PRIM_OrderRelease,
+    PRIM_OrderAcqRel,
+    PRIM_OrderSeqCst,
+
+    PRIM_RMWXchg,
+    PRIM_RMWAdd,
+    PRIM_RMWSubtract,
+    PRIM_RMWAnd,
+    PRIM_RMWNAnd,
+    PRIM_RMWOr,
+    PRIM_RMWXor,
+    PRIM_RMWMin,
+    PRIM_RMWMax,
+    PRIM_RMWUMin,
+    PRIM_RMWUMax,
+
+    PRIM_ByRef,
+    PRIM_RecordWithProperties,
+
+    PRIM_activeException,
+
+    PRIM_memcpy,
+    PRIM_memmove,
+
+    PRIM_countValues,
+    PRIM_nthValue,
+    PRIM_withoutNthValue,
+    PRIM_takeValues,
+    PRIM_dropValues,
+
+    PRIM_LambdaRecordP,
+    PRIM_LambdaSymbolP,
+    PRIM_LambdaMonoP,
+    PRIM_LambdaMonoInputTypes,
+
+    PRIM_GetOverload,
+
+    PRIM_usuallyEquals
+};
+
+struct PrimOp : public Object {
+    const PrimOpCode primOpCode;
+
+    PrimOp(PrimOpCode primOpCode) : Object(PRIM_OP), primOpCode(primOpCode) {}
+};
+
+llvm::StringRef primOpName(PrimOpCode op);
+
+static inline llvm::StringRef primOpName(const PrimOpPtr &x) {
+    return primOpName(x->primOpCode);
 }
+} // namespace clay
diff --git a/compiler/matchinvoke.cpp b/compiler/matchinvoke.cpp
index 1cca9e6f..ed2a8dd3 100644
--- a/compiler/matchinvoke.cpp
+++ b/compiler/matchinvoke.cpp
@@ -1,240 +1,242 @@
-#include "clay.hpp"
-#include "patterns.hpp"
 #include "matchinvoke.hpp"
-#include "evaluator.hpp"
+#include "clay.hpp"
 #include "env.hpp"
 #include "error.hpp"
-
+#include "evaluator.hpp"
+#include "patterns.hpp"
 
 namespace clay {
-    void initializePatternEnv(EnvPtr patternEnv, llvm::ArrayRef<PatternVar> pvars,
-                              vector<PatternCellPtr> &cells, vector<MultiPatternCellPtr> &multiCells) {
-        for (size_t i = 0; i < pvars.size(); ++i) {
-            if (pvars[i].isMulti) {
-                MultiPatternCellPtr multiCell = new MultiPatternCell(nullptr);
-                multiCells.push_back(multiCell);
-                cells.push_back(nullptr);
-                addLocal(patternEnv, pvars[i].name, multiCell.ptr());
-            } else {
-                PatternCellPtr cell = new PatternCell(nullptr);
-                cells.push_back(cell);
-                multiCells.push_back(nullptr);
-                addLocal(patternEnv, pvars[i].name, cell.ptr());
-            }
-        }
-    }
-
-    static void initializePatterns(OverloadPtr x) {
-        if (x->patternsInitializedState == 1)
-            return;
-        if (x->patternsInitializedState == -1)
-            error("unholy recursion detected");
-        assert(x->patternsInitializedState == 0);
-        x->patternsInitializedState = -1;
-
-        CodePtr code = x->code;
-        llvm::ArrayRef<PatternVar> pvars = code->patternVars;
-        EnvPtr patternEnv = new Env(x->env);
-        initializePatternEnv(patternEnv, pvars, x->cells, x->multiCells);
-        assert(x->target.ptr());
-        x->callablePattern = evaluateOnePattern(x->target, patternEnv);
-
-        llvm::ArrayRef<FormalArgPtr> formalArgs = code->formalArgs;
-        for (size_t i = 0; i < formalArgs.size(); ++i) {
-            FormalArgPtr y = formalArgs[i];
-            PatternPtr pattern;
-            if (y->type.ptr()) {
-                if (y->varArg) {
-                    ExprPtr unpack = new Unpack(y->type.ptr());
-                    unpack->location = y->type->location;
-                    x->varArgPattern = evaluateMultiPattern(new ExprList(unpack), patternEnv);
-                    pattern = nullptr;
-                } else {
-                    pattern = evaluateOnePattern(y->type, patternEnv);
-                }
-            }
-            x->argPatterns.push_back(pattern);
+void initializePatternEnv(EnvPtr patternEnv, llvm::ArrayRef<PatternVar> pvars,
+                          vector<PatternCellPtr> &cells,
+                          vector<MultiPatternCellPtr> &multiCells) {
+    for (size_t i = 0; i < pvars.size(); ++i) {
+        if (pvars[i].isMulti) {
+            MultiPatternCellPtr multiCell = new MultiPatternCell(nullptr);
+            multiCells.push_back(multiCell);
+            cells.push_back(nullptr);
+            addLocal(patternEnv, pvars[i].name, multiCell.ptr());
+        } else {
+            PatternCellPtr cell = new PatternCell(nullptr);
+            cells.push_back(cell);
+            multiCells.push_back(nullptr);
+            addLocal(patternEnv, pvars[i].name, cell.ptr());
         }
-
-        x->patternsInitializedState = 1;
     }
+}
 
-    static void resetPatterns(OverloadPtr x) {
-        assert(x->cells.size() == x->multiCells.size());
-        for (size_t i = 0; i < x->cells.size(); ++i) {
-            if (x->cells[i].ptr()) {
-                x->cells[i]->obj = nullptr;
-                assert(!x->multiCells[i]);
+static void initializePatterns(OverloadPtr x) {
+    if (x->patternsInitializedState == 1)
+        return;
+    if (x->patternsInitializedState == -1)
+        error("unholy recursion detected");
+    assert(x->patternsInitializedState == 0);
+    x->patternsInitializedState = -1;
+
+    CodePtr code = x->code;
+    llvm::ArrayRef<PatternVar> pvars = code->patternVars;
+    EnvPtr patternEnv = new Env(x->env);
+    initializePatternEnv(patternEnv, pvars, x->cells, x->multiCells);
+    assert(x->target.ptr());
+    x->callablePattern = evaluateOnePattern(x->target, patternEnv);
+
+    llvm::ArrayRef<FormalArgPtr> formalArgs = code->formalArgs;
+    for (size_t i = 0; i < formalArgs.size(); ++i) {
+        FormalArgPtr y = formalArgs[i];
+        PatternPtr pattern;
+        if (y->type.ptr()) {
+            if (y->varArg) {
+                ExprPtr unpack = new Unpack(y->type.ptr());
+                unpack->location = y->type->location;
+                x->varArgPattern =
+                    evaluateMultiPattern(new ExprList(unpack), patternEnv);
+                pattern = nullptr;
             } else {
-                assert(x->multiCells[i].ptr());
-                x->multiCells[i]->data = nullptr;
+                pattern = evaluateOnePattern(y->type, patternEnv);
             }
         }
+        x->argPatterns.push_back(pattern);
     }
 
-    struct PatternResetter {
-        OverloadPtr x;
-
-        PatternResetter(OverloadPtr x)
-            : x(x) {
-        }
-
-        ~PatternResetter() {
-            reset();
-        }
+    x->patternsInitializedState = 1;
+}
 
-        void reset() {
-            if (!x)
-                return;
-            resetPatterns(x);
-            x = nullptr;
+static void resetPatterns(OverloadPtr x) {
+    assert(x->cells.size() == x->multiCells.size());
+    for (size_t i = 0; i < x->cells.size(); ++i) {
+        if (x->cells[i].ptr()) {
+            x->cells[i]->obj = nullptr;
+            assert(!x->multiCells[i]);
+        } else {
+            assert(x->multiCells[i].ptr());
+            x->multiCells[i]->data = nullptr;
         }
-    };
+    }
+}
 
-    MatchResultPtr matchInvoke(OverloadPtr overload,
-                               ObjectPtr callable,
-                               llvm::ArrayRef<TypePtr> argsKey) {
-        initializePatterns(overload);
+struct PatternResetter {
+    OverloadPtr x;
 
-        PatternResetter resetter(overload);
+    PatternResetter(OverloadPtr x) : x(x) {}
 
-        if (!unifyPatternObj(overload->callablePattern, callable))
-            return new MatchCallableError(overload->target, callable);
+    ~PatternResetter() { reset(); }
 
-        CodePtr code = overload->code;
-        if (code->hasVarArg) {
-            if (argsKey.size() < code->formalArgs.size() - 1)
-                return new MatchArityError(unsigned(code->formalArgs.size()), unsigned(argsKey.size()), true);
-        } else {
-            if (code->formalArgs.size() != argsKey.size())
-                return new MatchArityError(unsigned(code->formalArgs.size()), unsigned(argsKey.size()), false);
-        }
-        llvm::ArrayRef<FormalArgPtr> formalArgs = code->formalArgs;
-        unsigned varArgSize = unsigned(argsKey.size() - formalArgs.size() + 1);
-        for (unsigned i = 0, j = 0; i < formalArgs.size(); ++i) {
-            FormalArgPtr x = formalArgs[i];
-            if (x->varArg) {
-                if (x->type.ptr()) {
-                    MultiStaticPtr types = new MultiStatic();
-                    for (; j < varArgSize; ++j)
-                        types->add(argsKey[i + j].ptr());
-                    --j;
-                    MultiPatternPtr pattern = overload->varArgPattern;
-                    if (!unifyMulti(pattern, types))
-                        return new MatchMultiArgumentError(unsigned(formalArgs.size()), types, x);
-                } else {
-                    j = varArgSize - 1;
-                }
+    void reset() {
+        if (!x)
+            return;
+        resetPatterns(x);
+        x = nullptr;
+    }
+};
+
+MatchResultPtr matchInvoke(OverloadPtr overload, ObjectPtr callable,
+                           llvm::ArrayRef<TypePtr> argsKey) {
+    initializePatterns(overload);
+
+    PatternResetter resetter(overload);
+
+    if (!unifyPatternObj(overload->callablePattern, callable))
+        return new MatchCallableError(overload->target, callable);
+
+    CodePtr code = overload->code;
+    if (code->hasVarArg) {
+        if (argsKey.size() < code->formalArgs.size() - 1)
+            return new MatchArityError(unsigned(code->formalArgs.size()),
+                                       unsigned(argsKey.size()), true);
+    } else {
+        if (code->formalArgs.size() != argsKey.size())
+            return new MatchArityError(unsigned(code->formalArgs.size()),
+                                       unsigned(argsKey.size()), false);
+    }
+    llvm::ArrayRef<FormalArgPtr> formalArgs = code->formalArgs;
+    unsigned varArgSize = unsigned(argsKey.size() - formalArgs.size() + 1);
+    for (unsigned i = 0, j = 0; i < formalArgs.size(); ++i) {
+        FormalArgPtr x = formalArgs[i];
+        if (x->varArg) {
+            if (x->type.ptr()) {
+                MultiStaticPtr types = new MultiStatic();
+                for (; j < varArgSize; ++j)
+                    types->add(argsKey[i + j].ptr());
+                --j;
+                MultiPatternPtr pattern = overload->varArgPattern;
+                if (!unifyMulti(pattern, types))
+                    return new MatchMultiArgumentError(
+                        unsigned(formalArgs.size()), types, x);
             } else {
-                if (x->type.ptr()) {
-                    PatternPtr pattern = overload->argPatterns[i];
-                    if (!unifyPatternObj(pattern, argsKey[i + j].ptr()))
-                        return new MatchArgumentError(i + j, argsKey[i + j], x);
-                }
+                j = varArgSize - 1;
+            }
+        } else {
+            if (x->type.ptr()) {
+                PatternPtr pattern = overload->argPatterns[i];
+                if (!unifyPatternObj(pattern, argsKey[i + j].ptr()))
+                    return new MatchArgumentError(i + j, argsKey[i + j], x);
             }
         }
+    }
 
-        EnvPtr staticEnv = new Env(overload->env);
-        llvm::ArrayRef<PatternVar> pvars = code->patternVars;
-        for (size_t i = 0; i < pvars.size(); ++i) {
-            if (pvars[i].isMulti) {
-                MultiStaticPtr ms = derefDeep(overload->multiCells[i].ptr());
-                if (!ms)
-                    error(pvars[i].name, "unbound pattern variable");
-                addLocal(staticEnv, pvars[i].name, ms.ptr());
-            } else {
-                ObjectPtr v = derefDeep(overload->cells[i].ptr());
-                if (!v)
-                    error(pvars[i].name, "unbound pattern variable");
-                addLocal(staticEnv, pvars[i].name, v.ptr());
-            }
+    EnvPtr staticEnv = new Env(overload->env);
+    llvm::ArrayRef<PatternVar> pvars = code->patternVars;
+    for (size_t i = 0; i < pvars.size(); ++i) {
+        if (pvars[i].isMulti) {
+            MultiStaticPtr ms = derefDeep(overload->multiCells[i].ptr());
+            if (!ms)
+                error(pvars[i].name, "unbound pattern variable");
+            addLocal(staticEnv, pvars[i].name, ms.ptr());
+        } else {
+            ObjectPtr v = derefDeep(overload->cells[i].ptr());
+            if (!v)
+                error(pvars[i].name, "unbound pattern variable");
+            addLocal(staticEnv, pvars[i].name, v.ptr());
         }
+    }
 
-        resetter.reset();
+    resetter.reset();
 
-        if (code->predicate.ptr())
-            if (!evaluateBool(code->predicate, staticEnv))
-                return new MatchPredicateError(code->predicate);
+    if (code->predicate.ptr())
+        if (!evaluateBool(code->predicate, staticEnv))
+            return new MatchPredicateError(code->predicate);
 
-        MatchSuccessPtr result = new MatchSuccess(
-            overload, staticEnv, callable, argsKey
-        );
+    MatchSuccessPtr result =
+        new MatchSuccess(overload, staticEnv, callable, argsKey);
 
-        for (unsigned i = 0, j = 0; i < formalArgs.size(); ++i) {
-            FormalArgPtr x = formalArgs[i];
-            if (x->varArg) {
-                result->varArgName = x->name;
-                result->varArgPosition = i;
-                for (; j < varArgSize; ++j) {
-                    result->varArgTypes.push_back(argsKey[i + j]);
-                }
-                --j;
-            } else {
-                result->fixedArgNames.push_back(x->name);
-                result->fixedArgTypes.push_back(argsKey[i + j]);
-            }
-        }
-        if (!code->hasVarArg) result->varArgPosition = unsigned(result->fixedArgNames.size());
-        return result.ptr();
-    }
-
-    void printMatchError(llvm::raw_ostream &os, const MatchResultPtr &result) {
-        switch (result->matchCode) {
-            case MATCH_SUCCESS:
-                os << "matched";
-                break;
-            case MATCH_CALLABLE_ERROR: {
-                MatchCallableError *e = (MatchCallableError *) result.ptr();
-                os << "callable pattern \"" << shortString(e->patternExpr->asString());
-                os << "\" did not match \"";
-                printStaticName(os, e->callable);
-                os << "\"";
-                break;
-            }
-            case MATCH_ARITY_ERROR: {
-                MatchArityError *e = (MatchArityError *) result.ptr();
-                os << "incorrect number of arguments: expected ";
-                if (e->variadic)
-                    os << "at least ";
-                os << e->expectedArgs << " arguments, got " << e->gotArgs << " arguments";
-                break;
-            }
-            case MATCH_ARGUMENT_ERROR: {
-                MatchArgumentError *e = (MatchArgumentError *) result.ptr();
-                os << "pattern \"" << shortString(e->arg->type->asString());
-                os << "\" did not match type \"";
-                printStaticName(os, e->type.ptr());
-                os << "\" of argument " << e->argIndex + 1;
-                break;
-            }
-            case MATCH_MULTI_ARGUMENT_ERROR: {
-                MatchMultiArgumentError *e = (MatchMultiArgumentError *) result.ptr();
-                os << "variadic argument type pattern did not match types of arguments ";
-                os << "starting at " << e->argIndex + 1;
-                break;
+    for (unsigned i = 0, j = 0; i < formalArgs.size(); ++i) {
+        FormalArgPtr x = formalArgs[i];
+        if (x->varArg) {
+            result->varArgName = x->name;
+            result->varArgPosition = i;
+            for (; j < varArgSize; ++j) {
+                result->varArgTypes.push_back(argsKey[i + j]);
             }
-            case MATCH_PREDICATE_ERROR: {
-                MatchPredicateError *e = (MatchPredicateError *) result.ptr();
-                os << "predicate \"" << shortString(e->predicateExpr->asString()) << "\" failed";
-                break;
-            }
-            case MATCH_BINDING_ERROR: {
-                MatchBindingError *e = (MatchBindingError *) result.ptr();
-                os << "pattern \"" << shortString(e->arg->type->asString());
-                os << "\" did not match type \"";
-                printStaticName(os, e->type.ptr());
-                os << "\" of binding " << e->argIndex + 1;
-                break;
-            }
-            case MATCH_MULTI_BINDING_ERROR: {
-                MatchMultiBindingError *e = (MatchMultiBindingError *) result.ptr();
-                os << "variadic binding type pattern did not match types of values ";
-                os << "starting at " << e->argIndex + 1;
-                break;
-            }
-            default:
-                assert(false);
-                break;
+            --j;
+        } else {
+            result->fixedArgNames.push_back(x->name);
+            result->fixedArgTypes.push_back(argsKey[i + j]);
         }
     }
+    if (!code->hasVarArg)
+        result->varArgPosition = unsigned(result->fixedArgNames.size());
+    return result.ptr();
+}
+
+void printMatchError(llvm::raw_ostream &os, const MatchResultPtr &result) {
+    switch (result->matchCode) {
+    case MATCH_SUCCESS:
+        os << "matched";
+        break;
+    case MATCH_CALLABLE_ERROR: {
+        MatchCallableError *e = (MatchCallableError *)result.ptr();
+        os << "callable pattern \"" << shortString(e->patternExpr->asString());
+        os << "\" did not match \"";
+        printStaticName(os, e->callable);
+        os << "\"";
+        break;
+    }
+    case MATCH_ARITY_ERROR: {
+        MatchArityError *e = (MatchArityError *)result.ptr();
+        os << "incorrect number of arguments: expected ";
+        if (e->variadic)
+            os << "at least ";
+        os << e->expectedArgs << " arguments, got " << e->gotArgs
+           << " arguments";
+        break;
+    }
+    case MATCH_ARGUMENT_ERROR: {
+        MatchArgumentError *e = (MatchArgumentError *)result.ptr();
+        os << "pattern \"" << shortString(e->arg->type->asString());
+        os << "\" did not match type \"";
+        printStaticName(os, e->type.ptr());
+        os << "\" of argument " << e->argIndex + 1;
+        break;
+    }
+    case MATCH_MULTI_ARGUMENT_ERROR: {
+        MatchMultiArgumentError *e = (MatchMultiArgumentError *)result.ptr();
+        os << "variadic argument type pattern did not match types of "
+              "arguments ";
+        os << "starting at " << e->argIndex + 1;
+        break;
+    }
+    case MATCH_PREDICATE_ERROR: {
+        MatchPredicateError *e = (MatchPredicateError *)result.ptr();
+        os << "predicate \"" << shortString(e->predicateExpr->asString())
+           << "\" failed";
+        break;
+    }
+    case MATCH_BINDING_ERROR: {
+        MatchBindingError *e = (MatchBindingError *)result.ptr();
+        os << "pattern \"" << shortString(e->arg->type->asString());
+        os << "\" did not match type \"";
+        printStaticName(os, e->type.ptr());
+        os << "\" of binding " << e->argIndex + 1;
+        break;
+    }
+    case MATCH_MULTI_BINDING_ERROR: {
+        MatchMultiBindingError *e = (MatchMultiBindingError *)result.ptr();
+        os << "variadic binding type pattern did not match types of values ";
+        os << "starting at " << e->argIndex + 1;
+        break;
+    }
+    default:
+        assert(false);
+        break;
+    }
 }
+} // namespace clay
diff --git a/compiler/matchinvoke.hpp b/compiler/matchinvoke.hpp
index 33c53d1c..a4f21663 100644
--- a/compiler/matchinvoke.hpp
+++ b/compiler/matchinvoke.hpp
@@ -1,138 +1,127 @@
 #pragma once
 
-
 #include "clay.hpp"
 
 namespace clay {
-    //
-    // match invoke
-    //
-
-    enum MatchCode {
-        MATCH_SUCCESS,
-        MATCH_CALLABLE_ERROR,
-        MATCH_ARITY_ERROR,
-        MATCH_ARGUMENT_ERROR,
-        MATCH_MULTI_ARGUMENT_ERROR,
-        MATCH_PREDICATE_ERROR,
-        MATCH_BINDING_ERROR,
-        MATCH_MULTI_BINDING_ERROR
-    };
-
-    struct MatchResult : public RefCounted {
-        const MatchCode matchCode;
-
-        MatchResult(MatchCode matchCode)
-            : matchCode(matchCode) {
-        }
-    };
-
-    struct MatchSuccess : public MatchResult {
-        OverloadPtr overload;
-        EnvPtr env;
-
-        ObjectPtr callable;
-        vector<TypePtr> argsKey;
-
-        vector<TypePtr> fixedArgTypes;
-        vector<IdentifierPtr> fixedArgNames;
-        IdentifierPtr varArgName;
-        vector<TypePtr> varArgTypes;
-
-        unsigned varArgPosition;
-        InlineAttribute isInline: 3;
-        bool callByName: 1;
-
-        MatchSuccess(OverloadPtr overload, EnvPtr env,
-                     ObjectPtr callable, llvm::ArrayRef<TypePtr> argsKey)
-            : MatchResult(MATCH_SUCCESS),
-              overload(overload), env(env), callable(callable),
-              argsKey(argsKey), varArgPosition(0) {
-        }
-    };
-
-    typedef Pointer<MatchSuccess> MatchSuccessPtr;
-
-    struct MatchCallableError : public MatchResult {
-        ExprPtr patternExpr;
-        ObjectPtr callable;
-
-        MatchCallableError(ExprPtr patternExpr, ObjectPtr callable)
-            : MatchResult(MATCH_CALLABLE_ERROR), patternExpr(patternExpr), callable(callable) {
-        }
-    };
-
-    struct MatchArityError : public MatchResult {
-        unsigned expectedArgs;
-        unsigned gotArgs;
-        bool variadic;
-
-        MatchArityError(unsigned expectedArgs, unsigned gotArgs, bool variadic)
-            : MatchResult(MATCH_ARITY_ERROR),
-              expectedArgs(expectedArgs),
-              gotArgs(gotArgs),
-              variadic(variadic) {
-        }
-    };
-
-    struct MatchArgumentError : public MatchResult {
-        unsigned argIndex;
-        TypePtr type;
-        FormalArgPtr arg;
-
-        MatchArgumentError(unsigned argIndex, TypePtr type, FormalArgPtr arg)
-            : MatchResult(MATCH_ARGUMENT_ERROR), argIndex(argIndex),
-              type(type), arg(arg) {
-        }
-    };
-
-    struct MatchMultiArgumentError : public MatchResult {
-        unsigned argIndex;
-        MultiStaticPtr types;
-        FormalArgPtr varArg;
-
-        MatchMultiArgumentError(unsigned argIndex, MultiStaticPtr types, FormalArgPtr varArg)
-            : MatchResult(MATCH_MULTI_ARGUMENT_ERROR),
-              argIndex(argIndex), types(types), varArg(varArg) {
-        }
-    };
-
-    struct MatchPredicateError : public MatchResult {
-        ExprPtr predicateExpr;
-
-        MatchPredicateError(ExprPtr predicateExpr)
-            : MatchResult(MATCH_PREDICATE_ERROR), predicateExpr(predicateExpr) {
-        }
-    };
-
-    struct MatchBindingError : public MatchResult {
-        unsigned argIndex;
-        TypePtr type;
-        FormalArgPtr arg;
-
-        MatchBindingError(unsigned argIndex, TypePtr type, FormalArgPtr arg)
-            : MatchResult(MATCH_BINDING_ERROR), argIndex(argIndex),
-              type(type), arg(arg) {
-        }
-    };
-
-    struct MatchMultiBindingError : public MatchResult {
-        unsigned argIndex;
-        MultiStaticPtr types;
-        FormalArgPtr varArg;
-
-        MatchMultiBindingError(unsigned argIndex, MultiStaticPtr types, FormalArgPtr varArg)
-            : MatchResult(MATCH_MULTI_BINDING_ERROR),
-              argIndex(argIndex), types(types), varArg(varArg) {
-        }
-    };
-
-    void initializePatternEnv(EnvPtr patternEnv, llvm::ArrayRef<PatternVar> pvars, vector<PatternCellPtr> &cells,
-                              vector<MultiPatternCellPtr> &multiCells);
-
-    MatchResultPtr matchInvoke(OverloadPtr overload,
-                               ObjectPtr callable,
-                               llvm::ArrayRef<TypePtr> argsKey);
-
-    void printMatchError(llvm::raw_ostream &os, const MatchResultPtr &result);
-}
+//
+// match invoke
+//
+
+enum MatchCode {
+    MATCH_SUCCESS,
+    MATCH_CALLABLE_ERROR,
+    MATCH_ARITY_ERROR,
+    MATCH_ARGUMENT_ERROR,
+    MATCH_MULTI_ARGUMENT_ERROR,
+    MATCH_PREDICATE_ERROR,
+    MATCH_BINDING_ERROR,
+    MATCH_MULTI_BINDING_ERROR
+};
+
+struct MatchResult : public RefCounted {
+    const MatchCode matchCode;
+
+    MatchResult(MatchCode matchCode) : matchCode(matchCode) {}
+};
+
+struct MatchSuccess : public MatchResult {
+    OverloadPtr overload;
+    EnvPtr env;
+
+    ObjectPtr callable;
+    vector<TypePtr> argsKey;
+
+    vector<TypePtr> fixedArgTypes;
+    vector<IdentifierPtr> fixedArgNames;
+    IdentifierPtr varArgName;
+    vector<TypePtr> varArgTypes;
+
+    unsigned varArgPosition;
+    InlineAttribute isInline : 3;
+    bool callByName : 1;
+
+    MatchSuccess(OverloadPtr overload, EnvPtr env, ObjectPtr callable,
+                 llvm::ArrayRef<TypePtr> argsKey)
+        : MatchResult(MATCH_SUCCESS), overload(overload), env(env),
+          callable(callable), argsKey(argsKey), varArgPosition(0) {}
+};
+
+typedef Pointer<MatchSuccess> MatchSuccessPtr;
+
+struct MatchCallableError : public MatchResult {
+    ExprPtr patternExpr;
+    ObjectPtr callable;
+
+    MatchCallableError(ExprPtr patternExpr, ObjectPtr callable)
+        : MatchResult(MATCH_CALLABLE_ERROR), patternExpr(patternExpr),
+          callable(callable) {}
+};
+
+struct MatchArityError : public MatchResult {
+    unsigned expectedArgs;
+    unsigned gotArgs;
+    bool variadic;
+
+    MatchArityError(unsigned expectedArgs, unsigned gotArgs, bool variadic)
+        : MatchResult(MATCH_ARITY_ERROR), expectedArgs(expectedArgs),
+          gotArgs(gotArgs), variadic(variadic) {}
+};
+
+struct MatchArgumentError : public MatchResult {
+    unsigned argIndex;
+    TypePtr type;
+    FormalArgPtr arg;
+
+    MatchArgumentError(unsigned argIndex, TypePtr type, FormalArgPtr arg)
+        : MatchResult(MATCH_ARGUMENT_ERROR), argIndex(argIndex), type(type),
+          arg(arg) {}
+};
+
+struct MatchMultiArgumentError : public MatchResult {
+    unsigned argIndex;
+    MultiStaticPtr types;
+    FormalArgPtr varArg;
+
+    MatchMultiArgumentError(unsigned argIndex, MultiStaticPtr types,
+                            FormalArgPtr varArg)
+        : MatchResult(MATCH_MULTI_ARGUMENT_ERROR), argIndex(argIndex),
+          types(types), varArg(varArg) {}
+};
+
+struct MatchPredicateError : public MatchResult {
+    ExprPtr predicateExpr;
+
+    MatchPredicateError(ExprPtr predicateExpr)
+        : MatchResult(MATCH_PREDICATE_ERROR), predicateExpr(predicateExpr) {}
+};
+
+struct MatchBindingError : public MatchResult {
+    unsigned argIndex;
+    TypePtr type;
+    FormalArgPtr arg;
+
+    MatchBindingError(unsigned argIndex, TypePtr type, FormalArgPtr arg)
+        : MatchResult(MATCH_BINDING_ERROR), argIndex(argIndex), type(type),
+          arg(arg) {}
+};
+
+struct MatchMultiBindingError : public MatchResult {
+    unsigned argIndex;
+    MultiStaticPtr types;
+    FormalArgPtr varArg;
+
+    MatchMultiBindingError(unsigned argIndex, MultiStaticPtr types,
+                           FormalArgPtr varArg)
+        : MatchResult(MATCH_MULTI_BINDING_ERROR), argIndex(argIndex),
+          types(types), varArg(varArg) {}
+};
+
+void initializePatternEnv(EnvPtr patternEnv, llvm::ArrayRef<PatternVar> pvars,
+                          vector<PatternCellPtr> &cells,
+                          vector<MultiPatternCellPtr> &multiCells);
+
+MatchResultPtr matchInvoke(OverloadPtr overload, ObjectPtr callable,
+                           llvm::ArrayRef<TypePtr> argsKey);
+
+void printMatchError(llvm::raw_ostream &os, const MatchResultPtr &result);
+} // namespace clay
diff --git a/compiler/objects.cpp b/compiler/objects.cpp
index b7339b56..9283a605 100644
--- a/compiler/objects.cpp
+++ b/compiler/objects.cpp
@@ -1,139 +1,139 @@
-#include "clay.hpp"
 #include "objects.hpp"
+#include "clay.hpp"
 #include "types.hpp"
 
 namespace clay {
-    //
-    // ValueHolder constructor and destructor
-    //
+//
+// ValueHolder constructor and destructor
+//
 
-    ValueHolder::ValueHolder(TypePtr type)
-        : Object(VALUE_HOLDER), type(type) {
-        this->buf = (char *) calloc(1, typeSize(type));
-    }
+ValueHolder::ValueHolder(TypePtr type) : Object(VALUE_HOLDER), type(type) {
+    this->buf = (char *)calloc(1, typeSize(type));
+}
 
-    ValueHolder::~ValueHolder() {
-        // FIXME: call clay 'destroy'
-        free(this->buf);
-    }
+ValueHolder::~ValueHolder() {
+    // FIXME: call clay 'destroy'
+    free(this->buf);
+}
+
+//
+// objectEquals
+//
 
-    //
+// FIXME: this doesn't handle arbitrary values (need to call clay)
+bool _objectValueEquals(ObjectPtr a, ObjectPtr b) {
+    // at this point pointer identity should already have been checked by
     // objectEquals
-    //
 
-    // FIXME: this doesn't handle arbitrary values (need to call clay)
-    bool _objectValueEquals(ObjectPtr a, ObjectPtr b) {
-        // at this point pointer identity should already have been checked by objectEquals
+    int aKind = a->objKind, bKind = b->objKind;
+    if (aKind != bKind)
+        return false;
 
-        int aKind = a->objKind, bKind = b->objKind;
-        if (aKind != bKind)
+    switch (aKind) {
+    case IDENTIFIER: {
+        Identifier *a1 = (Identifier *)a.ptr();
+        Identifier *b1 = (Identifier *)b.ptr();
+        return a1->str == b1->str;
+    }
+
+    case VALUE_HOLDER: {
+        ValueHolder *a1 = (ValueHolder *)a.ptr();
+        ValueHolder *b1 = (ValueHolder *)b.ptr();
+        if (a1->type != b1->type)
             return false;
+        size_t n = typeSize(a1->type);
+        return memcmp(a1->buf, b1->buf, n) == 0;
+    }
 
-        switch (aKind) {
-            case IDENTIFIER: {
-                Identifier *a1 = (Identifier *) a.ptr();
-                Identifier *b1 = (Identifier *) b.ptr();
-                return a1->str == b1->str;
-            }
-
-            case VALUE_HOLDER: {
-                ValueHolder *a1 = (ValueHolder *) a.ptr();
-                ValueHolder *b1 = (ValueHolder *) b.ptr();
-                if (a1->type != b1->type)
-                    return false;
-                size_t n = typeSize(a1->type);
-                return memcmp(a1->buf, b1->buf, n) == 0;
-            }
-
-            case PVALUE: {
-                PValue *a1 = (PValue *) a.ptr();
-                PValue *b1 = (PValue *) b.ptr();
-                return a1->data == b1->data;
-            }
-
-            default:
-                return false;
-        }
+    case PVALUE: {
+        PValue *a1 = (PValue *)a.ptr();
+        PValue *b1 = (PValue *)b.ptr();
+        return a1->data == b1->data;
+    }
+
+    default:
+        return false;
+    }
+}
+
+//
+// objectHash
+//
+
+static unsigned identityHash(Object *a) {
+    size_t v = (size_t)a;
+    return unsigned(int(v));
+}
+
+// FIXME: this doesn't handle arbitrary values (need to call clay)
+unsigned objectHash(ObjectPtr a) {
+    switch (a->objKind) {
+    case IDENTIFIER: {
+        Identifier *b = (Identifier *)a.ptr();
+        unsigned h = 0;
+        for (unsigned i = 0; i < b->str.size(); ++i)
+            h += unsigned(b->str[i]);
+        return h;
     }
 
-    //
-    // objectHash
-    //
+    case VALUE_HOLDER: {
+        ValueHolder *b = (ValueHolder *)a.ptr();
+        // TODO: call clay 'hash'
+        unsigned h = 0;
+        size_t n = typeSize(b->type);
+        for (unsigned i = 0; i < n; ++i)
+            h += unsigned(b->buf[i]);
+        h = h * 11 + identityHash(b->type.ptr());
+        return h;
+    }
 
-    static unsigned identityHash(Object *a) {
-        size_t v = (size_t) a;
-        return unsigned(int(v));
+    case PVALUE: {
+        PValue *b = (PValue *)a.ptr();
+        unsigned h = identityHash(b->data.type.ptr());
+        h *= b->data.isRValue ? 11 : 23;
+        return h;
     }
 
-    // FIXME: this doesn't handle arbitrary values (need to call clay)
-    unsigned objectHash(ObjectPtr a) {
-        switch (a->objKind) {
-            case IDENTIFIER: {
-                Identifier *b = (Identifier *) a.ptr();
-                unsigned h = 0;
-                for (unsigned i = 0; i < b->str.size(); ++i)
-                    h += unsigned(b->str[i]);
-                return h;
-            }
-
-            case VALUE_HOLDER: {
-                ValueHolder *b = (ValueHolder *) a.ptr();
-                // TODO: call clay 'hash'
-                unsigned h = 0;
-                size_t n = typeSize(b->type);
-                for (unsigned i = 0; i < n; ++i)
-                    h += unsigned(b->buf[i]);
-                h = h * 11 + identityHash(b->type.ptr());
-                return h;
-            }
-
-            case PVALUE: {
-                PValue *b = (PValue *) a.ptr();
-                unsigned h = identityHash(b->data.type.ptr());
-                h *= b->data.isRValue ? 11 : 23;
-                return h;
-            }
-
-            default: {
-                return identityHash(a.ptr());
-            }
-        }
+    default: {
+        return identityHash(a.ptr());
     }
+    }
+}
 
-    //
-    // ObjectTable
-    //
-
-    Pointer<RefCounted> &ObjectTable::lookup(llvm::ArrayRef<ObjectPtr> key) {
-        if (this->buckets.empty())
-            this->buckets.resize(16);
-        if (this->buckets.size() < 2 * this->size)
-            rehash();
-        unsigned h = objectVectorHash(key);
-        h &= unsigned(buckets.size() - 1);
-        vector<ObjectTableNode> &bucket = buckets[h];
-        for (unsigned i = 0; i < bucket.size(); ++i) {
-            if (objectVectorEquals(key, bucket[i].key))
-                return bucket[i].value;
-        }
-        bucket.push_back(ObjectTableNode(key, nullptr));
-        ++this->size;
-        return bucket.back().value;
+//
+// ObjectTable
+//
+
+Pointer<RefCounted> &ObjectTable::lookup(llvm::ArrayRef<ObjectPtr> key) {
+    if (this->buckets.empty())
+        this->buckets.resize(16);
+    if (this->buckets.size() < 2 * this->size)
+        rehash();
+    unsigned h = objectVectorHash(key);
+    h &= unsigned(buckets.size() - 1);
+    vector<ObjectTableNode> &bucket = buckets[h];
+    for (unsigned i = 0; i < bucket.size(); ++i) {
+        if (objectVectorEquals(key, bucket[i].key))
+            return bucket[i].value;
     }
+    bucket.push_back(ObjectTableNode(key, nullptr));
+    ++this->size;
+    return bucket.back().value;
+}
 
-    void ObjectTable::rehash() {
-        vector<vector<ObjectTableNode> > newBuckets;
-        newBuckets.resize(4 * this->buckets.size());
-
-        for (unsigned i = 0; i < this->buckets.size(); ++i) {
-            vector<ObjectTableNode> &bucket = this->buckets[i];
-            for (unsigned j = 0; j < bucket.size(); ++j) {
-                unsigned h = objectVectorHash(bucket[j].key);
-                h &= unsigned(newBuckets.size() - 1);
-                newBuckets[h].push_back(bucket[j]);
-            }
-        }
+void ObjectTable::rehash() {
+    vector<vector<ObjectTableNode>> newBuckets;
+    newBuckets.resize(4 * this->buckets.size());
 
-        this->buckets = newBuckets;
+    for (unsigned i = 0; i < this->buckets.size(); ++i) {
+        vector<ObjectTableNode> &bucket = this->buckets[i];
+        for (unsigned j = 0; j < bucket.size(); ++j) {
+            unsigned h = objectVectorHash(bucket[j].key);
+            h &= unsigned(newBuckets.size() - 1);
+            newBuckets[h].push_back(bucket[j]);
+        }
     }
+
+    this->buckets = newBuckets;
 }
+} // namespace clay
diff --git a/compiler/objects.hpp b/compiler/objects.hpp
index 3758d37f..6a18ece8 100644
--- a/compiler/objects.hpp
+++ b/compiler/objects.hpp
@@ -3,68 +3,63 @@
 #include "clay.hpp"
 
 namespace clay {
-    struct ValueHolder : public Object {
-        TypePtr type;
-        char *buf;
-        ValueHolder(TypePtr type);
-        ~ValueHolder();
+struct ValueHolder : public Object {
+    TypePtr type;
+    char *buf;
+    ValueHolder(TypePtr type);
+    ~ValueHolder();
 
-        template<typename T>
-        T &as() { return *(T *) buf; }
+    template <typename T> T &as() { return *(T *)buf; }
 
-        template<typename T>
-        T const &as() const { return *(T const *) buf; }
-    };
+    template <typename T> T const &as() const { return *(T const *)buf; }
+};
 
-    bool _objectValueEquals(ObjectPtr a, ObjectPtr b);
-    unsigned objectHash(ObjectPtr a);
+bool _objectValueEquals(ObjectPtr a, ObjectPtr b);
+unsigned objectHash(ObjectPtr a);
 
-    inline bool objectEquals(ObjectPtr a, ObjectPtr b) {
-        if (a == b)
-            return true;
-        return _objectValueEquals(a, b);
-    }
-
-    template<typename ObjectVectorA, typename ObjectVectorB>
-    inline bool objectVectorEquals(ObjectVectorA const &a,
-                                   ObjectVectorB const &b) {
-        if (a.size() != b.size()) return false;
-        for (unsigned i = 0; i < a.size(); ++i) {
-            if (!objectEquals(a[i].ptr(), b[i].ptr()))
-                return false;
-        }
+inline bool objectEquals(ObjectPtr a, ObjectPtr b) {
+    if (a == b)
         return true;
-    }
+    return _objectValueEquals(a, b);
+}
 
-    template<typename ObjectVector>
-    inline unsigned objectVectorHash(ObjectVector const &a) {
-        unsigned h = 0;
-        for (unsigned i = 0; i < a.size(); ++i)
-            h += objectHash(a[i].ptr());
-        return h;
+template <typename ObjectVectorA, typename ObjectVectorB>
+inline bool objectVectorEquals(ObjectVectorA const &a, ObjectVectorB const &b) {
+    if (a.size() != b.size())
+        return false;
+    for (unsigned i = 0; i < a.size(); ++i) {
+        if (!objectEquals(a[i].ptr(), b[i].ptr()))
+            return false;
     }
+    return true;
+}
+
+template <typename ObjectVector>
+inline unsigned objectVectorHash(ObjectVector const &a) {
+    unsigned h = 0;
+    for (unsigned i = 0; i < a.size(); ++i)
+        h += objectHash(a[i].ptr());
+    return h;
+}
 
-    struct ObjectTableNode {
-        vector<ObjectPtr> key;
-        Pointer<RefCounted> value;
+struct ObjectTableNode {
+    vector<ObjectPtr> key;
+    Pointer<RefCounted> value;
 
-        ObjectTableNode(llvm::ArrayRef<ObjectPtr> key,
-                        Pointer<RefCounted> value)
-            : key(key), value(value) {
-        }
-    };
+    ObjectTableNode(llvm::ArrayRef<ObjectPtr> key, Pointer<RefCounted> value)
+        : key(key), value(value) {}
+};
 
-    struct ObjectTable : public RefCounted {
-        vector<vector<ObjectTableNode> > buckets;
-        unsigned size;
+struct ObjectTable : public RefCounted {
+    vector<vector<ObjectTableNode>> buckets;
+    unsigned size;
 
-    public :
-        ObjectTable() : size(0) {
-        }
+  public:
+    ObjectTable() : size(0) {}
 
-        Pointer<RefCounted> &lookup(llvm::ArrayRef<ObjectPtr> key);
+    Pointer<RefCounted> &lookup(llvm::ArrayRef<ObjectPtr> key);
 
-    private :
-        void rehash();
-    };
+  private:
+    void rehash();
+};
 } // namespace clay
diff --git a/compiler/operators.hpp b/compiler/operators.hpp
index 86669a02..0b05b56e 100644
--- a/compiler/operators.hpp
+++ b/compiler/operators.hpp
@@ -1,155 +1,155 @@
 #pragma once
 
 namespace clay {
-    ObjectPtr primitive_addressOf();
-    ObjectPtr primitive_boolNot();
-    ObjectPtr primitive_Pointer();
-    ObjectPtr primitive_CodePointer();
-    ObjectPtr primitive_ExternalCodePointer();
-    ObjectPtr primitive_AttributeCCall();
-    ObjectPtr primitive_AttributeStdCall();
-    ObjectPtr primitive_AttributeFastCall();
-    ObjectPtr primitive_AttributeThisCall();
-    ObjectPtr primitive_AttributeLLVMCall();
-    ObjectPtr primitive_Array();
-    ObjectPtr primitive_Vec();
-    ObjectPtr primitive_Tuple();
-    ObjectPtr primitive_Union();
-    ObjectPtr primitive_Static();
-    ObjectPtr primitive_ByRef();
-    ObjectPtr primitive_RecordWithProperties();
-    ObjectPtr primitive_activeException();
+ObjectPtr primitive_addressOf();
+ObjectPtr primitive_boolNot();
+ObjectPtr primitive_Pointer();
+ObjectPtr primitive_CodePointer();
+ObjectPtr primitive_ExternalCodePointer();
+ObjectPtr primitive_AttributeCCall();
+ObjectPtr primitive_AttributeStdCall();
+ObjectPtr primitive_AttributeFastCall();
+ObjectPtr primitive_AttributeThisCall();
+ObjectPtr primitive_AttributeLLVMCall();
+ObjectPtr primitive_Array();
+ObjectPtr primitive_Vec();
+ObjectPtr primitive_Tuple();
+ObjectPtr primitive_Union();
+ObjectPtr primitive_Static();
+ObjectPtr primitive_ByRef();
+ObjectPtr primitive_RecordWithProperties();
+ObjectPtr primitive_activeException();
 
-    ExprPtr primitive_expr_addressOf();
-    ExprPtr primitive_expr_boolNot();
-    ExprPtr primitive_expr_Pointer();
-    ExprPtr primitive_expr_CodePointer();
-    ExprPtr primitive_expr_ExternalCodePointer();
-    ExprPtr primitive_expr_AttributeCCall();
-    ExprPtr primitive_expr_AttributeStdCall();
-    ExprPtr primitive_expr_AttributeFastCall();
-    ExprPtr primitive_expr_AttributeThisCall();
-    ExprPtr primitive_expr_AttributeLLVMCall();
-    ExprPtr primitive_expr_Array();
-    ExprPtr primitive_expr_Vec();
-    ExprPtr primitive_expr_Tuple();
-    ExprPtr primitive_expr_Union();
-    ExprPtr primitive_expr_Static();
-    ExprPtr primitive_expr_ByRef();
-    ExprPtr primitive_expr_RecordWithProperties();
-    ExprPtr primitive_expr_activeException();
+ExprPtr primitive_expr_addressOf();
+ExprPtr primitive_expr_boolNot();
+ExprPtr primitive_expr_Pointer();
+ExprPtr primitive_expr_CodePointer();
+ExprPtr primitive_expr_ExternalCodePointer();
+ExprPtr primitive_expr_AttributeCCall();
+ExprPtr primitive_expr_AttributeStdCall();
+ExprPtr primitive_expr_AttributeFastCall();
+ExprPtr primitive_expr_AttributeThisCall();
+ExprPtr primitive_expr_AttributeLLVMCall();
+ExprPtr primitive_expr_Array();
+ExprPtr primitive_expr_Vec();
+ExprPtr primitive_expr_Tuple();
+ExprPtr primitive_expr_Union();
+ExprPtr primitive_expr_Static();
+ExprPtr primitive_expr_ByRef();
+ExprPtr primitive_expr_RecordWithProperties();
+ExprPtr primitive_expr_activeException();
 
-    ObjectPtr operator_dereference();
-    ObjectPtr operator_prefixOperator();
-    ObjectPtr operator_infixOperator();
-    ObjectPtr operator_caseP();
-    ObjectPtr operator_tupleLiteral();
-    ObjectPtr operator_staticIndex();
-    ObjectPtr operator_index();
-    ObjectPtr operator_fieldRef();
-    ObjectPtr operator_call();
-    ObjectPtr operator_destroy();
-    ObjectPtr operator_copy();
-    ObjectPtr operator_move();
-    ObjectPtr operator_assign();
-    ObjectPtr operator_updateAssign();
-    ObjectPtr operator_prefixUpdateAssign();
-    ObjectPtr operator_indexAssign();
-    ObjectPtr operator_indexUpdateAssign();
-    ObjectPtr operator_fieldRefAssign();
-    ObjectPtr operator_fieldRefUpdateAssign();
-    ObjectPtr operator_staticIndexAssign();
-    ObjectPtr operator_staticIndexUpdateAssign();
-    ObjectPtr operator_callMain();
-    ObjectPtr operator_charLiteral();
-    ObjectPtr operator_iterator();
-    ObjectPtr operator_nextValue();
-    ObjectPtr operator_hasValueP();
-    ObjectPtr operator_getValue();
-    ObjectPtr operator_throwValue();
-    ObjectPtr operator_exceptionIsP();
-    ObjectPtr operator_exceptionAs();
-    ObjectPtr operator_exceptionAsAny();
-    ObjectPtr operator_continueException();
-    ObjectPtr operator_unhandledExceptionInExternal();
-    ObjectPtr operator_exceptionInInitializer();
-    ObjectPtr operator_exceptionInFinalizer();
-    ObjectPtr operator_packMultiValuedFreeVarByRef();
-    ObjectPtr operator_packMultiValuedFreeVar();
-    ObjectPtr operator_unpackMultiValuedFreeVarAndDereference();
-    ObjectPtr operator_unpackMultiValuedFreeVar();
-    ObjectPtr operator_variantReprType();
-    ObjectPtr operator_DispatchTagCount();
-    ObjectPtr operator_dispatchTag();
-    ObjectPtr operator_dispatchIndex();
-    ObjectPtr operator_invalidDispatch();
-    ObjectPtr operator_ifExpression();
-    ObjectPtr operator_asExpression();
-    ObjectPtr operator_typeToRValue();
-    ObjectPtr operator_typesToRValues();
-    ObjectPtr operator_doIntegerAddChecked();
-    ObjectPtr operator_doIntegerSubtractChecked();
-    ObjectPtr operator_doIntegerMultiplyChecked();
-    ObjectPtr operator_doIntegerQuotientChecked();
-    ObjectPtr operator_doIntegerRemainderChecked();
-    ObjectPtr operator_doIntegerShiftLeftChecked();
-    ObjectPtr operator_doIntegerNegateChecked();
-    ObjectPtr operator_doIntegerConvertChecked();
+ObjectPtr operator_dereference();
+ObjectPtr operator_prefixOperator();
+ObjectPtr operator_infixOperator();
+ObjectPtr operator_caseP();
+ObjectPtr operator_tupleLiteral();
+ObjectPtr operator_staticIndex();
+ObjectPtr operator_index();
+ObjectPtr operator_fieldRef();
+ObjectPtr operator_call();
+ObjectPtr operator_destroy();
+ObjectPtr operator_copy();
+ObjectPtr operator_move();
+ObjectPtr operator_assign();
+ObjectPtr operator_updateAssign();
+ObjectPtr operator_prefixUpdateAssign();
+ObjectPtr operator_indexAssign();
+ObjectPtr operator_indexUpdateAssign();
+ObjectPtr operator_fieldRefAssign();
+ObjectPtr operator_fieldRefUpdateAssign();
+ObjectPtr operator_staticIndexAssign();
+ObjectPtr operator_staticIndexUpdateAssign();
+ObjectPtr operator_callMain();
+ObjectPtr operator_charLiteral();
+ObjectPtr operator_iterator();
+ObjectPtr operator_nextValue();
+ObjectPtr operator_hasValueP();
+ObjectPtr operator_getValue();
+ObjectPtr operator_throwValue();
+ObjectPtr operator_exceptionIsP();
+ObjectPtr operator_exceptionAs();
+ObjectPtr operator_exceptionAsAny();
+ObjectPtr operator_continueException();
+ObjectPtr operator_unhandledExceptionInExternal();
+ObjectPtr operator_exceptionInInitializer();
+ObjectPtr operator_exceptionInFinalizer();
+ObjectPtr operator_packMultiValuedFreeVarByRef();
+ObjectPtr operator_packMultiValuedFreeVar();
+ObjectPtr operator_unpackMultiValuedFreeVarAndDereference();
+ObjectPtr operator_unpackMultiValuedFreeVar();
+ObjectPtr operator_variantReprType();
+ObjectPtr operator_DispatchTagCount();
+ObjectPtr operator_dispatchTag();
+ObjectPtr operator_dispatchIndex();
+ObjectPtr operator_invalidDispatch();
+ObjectPtr operator_ifExpression();
+ObjectPtr operator_asExpression();
+ObjectPtr operator_typeToRValue();
+ObjectPtr operator_typesToRValues();
+ObjectPtr operator_doIntegerAddChecked();
+ObjectPtr operator_doIntegerSubtractChecked();
+ObjectPtr operator_doIntegerMultiplyChecked();
+ObjectPtr operator_doIntegerQuotientChecked();
+ObjectPtr operator_doIntegerRemainderChecked();
+ObjectPtr operator_doIntegerShiftLeftChecked();
+ObjectPtr operator_doIntegerNegateChecked();
+ObjectPtr operator_doIntegerConvertChecked();
 
-    ExprPtr operator_expr_dereference();
-    ExprPtr operator_expr_prefixOperator();
-    ExprPtr operator_expr_infixOperator();
-    ExprPtr operator_expr_caseP();
-    ExprPtr operator_expr_tupleLiteral();
-    ExprPtr operator_expr_staticIndex();
-    ExprPtr operator_expr_index();
-    ExprPtr operator_expr_fieldRef();
-    ExprPtr operator_expr_call();
-    ExprPtr operator_expr_destroy();
-    ExprPtr operator_expr_copy();
-    ExprPtr operator_expr_move();
-    ExprPtr operator_expr_assign();
-    ExprPtr operator_expr_updateAssign();
-    ExprPtr operator_expr_prefixUpdateAssign();
-    ExprPtr operator_expr_indexAssign();
-    ExprPtr operator_expr_indexUpdateAssign();
-    ExprPtr operator_expr_fieldRefAssign();
-    ExprPtr operator_expr_fieldRefUpdateAssign();
-    ExprPtr operator_expr_staticIndexAssign();
-    ExprPtr operator_expr_staticIndexUpdateAssign();
-    ExprPtr operator_expr_callMain();
-    ExprPtr operator_expr_charLiteral();
-    ExprPtr operator_expr_iterator();
-    ExprPtr operator_expr_nextValue();
-    ExprPtr operator_expr_hasValueP();
-    ExprPtr operator_expr_getValue();
-    ExprPtr operator_expr_throwValue();
-    ExprPtr operator_expr_exceptionIsP();
-    ExprPtr operator_expr_exceptionAs();
-    ExprPtr operator_expr_exceptionAsAny();
-    ExprPtr operator_expr_continueException();
-    ExprPtr operator_expr_unhandledExceptionInExternal();
-    ExprPtr operator_expr_exceptionInInitializer();
-    ExprPtr operator_expr_exceptionInFinalizer();
-    ExprPtr operator_expr_packMultiValuedFreeVarByRef();
-    ExprPtr operator_expr_packMultiValuedFreeVar();
-    ExprPtr operator_expr_unpackMultiValuedFreeVarAndDereference();
-    ExprPtr operator_expr_unpackMultiValuedFreeVar();
-    ExprPtr operator_expr_variantReprType();
-    ExprPtr operator_expr_DispatchTagCount();
-    ExprPtr operator_expr_dispatchTag();
-    ExprPtr operator_expr_dispatchIndex();
-    ExprPtr operator_expr_invalidDispatch();
-    ExprPtr operator_expr_ifExpression();
-    ExprPtr operator_expr_asExpression();
-    ExprPtr operator_expr_typeToRValue();
-    ExprPtr operator_expr_typesToRValues();
-    ExprPtr operator_expr_doIntegerAddChecked();
-    ExprPtr operator_expr_doIntegerSubtractChecked();
-    ExprPtr operator_expr_doIntegerMultiplyChecked();
-    ExprPtr operator_expr_doIntegerQuotientChecked();
-    ExprPtr operator_expr_doIntegerRemainderChecked();
-    ExprPtr operator_expr_doIntegerShiftLeftChecked();
-    ExprPtr operator_expr_doIntegerNegateChecked();
-    ExprPtr operator_expr_doIntegerConvertChecked();
-}
+ExprPtr operator_expr_dereference();
+ExprPtr operator_expr_prefixOperator();
+ExprPtr operator_expr_infixOperator();
+ExprPtr operator_expr_caseP();
+ExprPtr operator_expr_tupleLiteral();
+ExprPtr operator_expr_staticIndex();
+ExprPtr operator_expr_index();
+ExprPtr operator_expr_fieldRef();
+ExprPtr operator_expr_call();
+ExprPtr operator_expr_destroy();
+ExprPtr operator_expr_copy();
+ExprPtr operator_expr_move();
+ExprPtr operator_expr_assign();
+ExprPtr operator_expr_updateAssign();
+ExprPtr operator_expr_prefixUpdateAssign();
+ExprPtr operator_expr_indexAssign();
+ExprPtr operator_expr_indexUpdateAssign();
+ExprPtr operator_expr_fieldRefAssign();
+ExprPtr operator_expr_fieldRefUpdateAssign();
+ExprPtr operator_expr_staticIndexAssign();
+ExprPtr operator_expr_staticIndexUpdateAssign();
+ExprPtr operator_expr_callMain();
+ExprPtr operator_expr_charLiteral();
+ExprPtr operator_expr_iterator();
+ExprPtr operator_expr_nextValue();
+ExprPtr operator_expr_hasValueP();
+ExprPtr operator_expr_getValue();
+ExprPtr operator_expr_throwValue();
+ExprPtr operator_expr_exceptionIsP();
+ExprPtr operator_expr_exceptionAs();
+ExprPtr operator_expr_exceptionAsAny();
+ExprPtr operator_expr_continueException();
+ExprPtr operator_expr_unhandledExceptionInExternal();
+ExprPtr operator_expr_exceptionInInitializer();
+ExprPtr operator_expr_exceptionInFinalizer();
+ExprPtr operator_expr_packMultiValuedFreeVarByRef();
+ExprPtr operator_expr_packMultiValuedFreeVar();
+ExprPtr operator_expr_unpackMultiValuedFreeVarAndDereference();
+ExprPtr operator_expr_unpackMultiValuedFreeVar();
+ExprPtr operator_expr_variantReprType();
+ExprPtr operator_expr_DispatchTagCount();
+ExprPtr operator_expr_dispatchTag();
+ExprPtr operator_expr_dispatchIndex();
+ExprPtr operator_expr_invalidDispatch();
+ExprPtr operator_expr_ifExpression();
+ExprPtr operator_expr_asExpression();
+ExprPtr operator_expr_typeToRValue();
+ExprPtr operator_expr_typesToRValues();
+ExprPtr operator_expr_doIntegerAddChecked();
+ExprPtr operator_expr_doIntegerSubtractChecked();
+ExprPtr operator_expr_doIntegerMultiplyChecked();
+ExprPtr operator_expr_doIntegerQuotientChecked();
+ExprPtr operator_expr_doIntegerRemainderChecked();
+ExprPtr operator_expr_doIntegerShiftLeftChecked();
+ExprPtr operator_expr_doIntegerNegateChecked();
+ExprPtr operator_expr_doIntegerConvertChecked();
+} // namespace clay
diff --git a/compiler/parachute.cpp b/compiler/parachute.cpp
index 6bb047c2..a00b6cbb 100644
--- a/compiler/parachute.cpp
+++ b/compiler/parachute.cpp
@@ -1,55 +1,53 @@
-#include "error.hpp"
 #include "parachute.hpp"
+#include "error.hpp"
 
 #if defined(_WIN32) || defined(_WIN64)
 
-# ifdef _MSC_VER
-#  define WIN32_LEAN_AND_MEAN
-#  include <windows.h>
+#ifdef _MSC_VER
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
 
 namespace clay {
-    // SEH parachute
-
-    static int emergencyCompileContext(LPEXCEPTION_POINTERS exceptionInfo) {
-        fprintf(stderr, "exception code 0x%08X!\n", exceptionInfo->ExceptionRecord->ExceptionCode);
-        __try{
-            displayCompileContext();
-
-        }
-        __except(EXCEPTION_EXECUTE_HANDLER)
-        {
-            fprintf(stderr, "exception code 0x%08X displaying compile context!\n", GetExceptionCode());
-        }
-        fflush(stderr);
-        return EXCEPTION_CONTINUE_SEARCH;
+// SEH parachute
+
+static int emergencyCompileContext(LPEXCEPTION_POINTERS exceptionInfo) {
+    fprintf(stderr, "exception code 0x%08X!\n",
+            exceptionInfo->ExceptionRecord->ExceptionCode);
+    __try {
+        displayCompileContext();
+
+    } __except (EXCEPTION_EXECUTE_HANDLER) {
+        fprintf(stderr, "exception code 0x%08X displaying compile context!\n",
+                GetExceptionCode());
     }
+    fflush(stderr);
+    return EXCEPTION_CONTINUE_SEARCH;
+}
 
-    int parachute(int (*mainfn)(int, char **, char const *const*),
-                  int argc, char **argv, char const *const*envp) {
-        __try{
+int parachute(int (*mainfn)(int, char **, char const *const *), int argc,
+              char **argv, char const *const *envp) {
+    __try {
         return mainfn(argc, argv, envp);
 
-        }
-        __except(emergencyCompileContext(GetExceptionInformation()))
-        {
-        }
-        assert(false);
-        return 86;
+    } __except (emergencyCompileContext(GetExceptionInformation())) {
     }
+    assert(false);
+    return 86;
 }
+} // namespace clay
 
-# else
+#else
 
 // FIXME should at least try to use VEH for mingw/cygwin
 
 namespace clay {
-    int parachute(int (*mainfn)(int, char **, char const *const*),
-                  int argc, char **argv, char const *const*envp) {
-        return mainfn(argc, argv, envp);
-    }
+int parachute(int (*mainfn)(int, char **, char const *const *), int argc,
+              char **argv, char const *const *envp) {
+    return mainfn(argc, argv, envp);
 }
+} // namespace clay
 
-# endif
+#endif
 
 #else
 
@@ -58,29 +56,29 @@ namespace clay {
 #include <csignal>
 
 namespace clay {
-    static volatile int threatLevel = 0;
-
-    static void emergencyCompileContext(const int sig) {
-        const int oldThreatLevel = __sync_fetch_and_add(&threatLevel, 1);
-        if (oldThreatLevel == 0) {
-            fprintf(stderr, "signal %d!\n", sig);
-            displayCompileContext();
-        } else {
-            fprintf(stderr, "signal %d displaying compile context!\n", sig);
-        }
-        fflush(stderr);
-        signal(sig, SIG_DFL);
-        raise(sig);
+static volatile int threatLevel = 0;
+
+static void emergencyCompileContext(const int sig) {
+    const int oldThreatLevel = __sync_fetch_and_add(&threatLevel, 1);
+    if (oldThreatLevel == 0) {
+        fprintf(stderr, "signal %d!\n", sig);
+        displayCompileContext();
+    } else {
+        fprintf(stderr, "signal %d displaying compile context!\n", sig);
     }
+    fflush(stderr);
+    signal(sig, SIG_DFL);
+    raise(sig);
+}
 
-    int parachute(int (*mainfn)(int, char **, char const *const*),
-                  int argc, char **argv, char const *const*envp) {
-        signal(SIGSEGV, emergencyCompileContext);
-        signal(SIGBUS, emergencyCompileContext);
-        signal(SIGILL, emergencyCompileContext);
-        signal(SIGABRT, emergencyCompileContext);
-        return mainfn(argc, argv, envp);
-    }
+int parachute(int (*mainfn)(int, char **, char const *const *), int argc,
+              char **argv, char const *const *envp) {
+    signal(SIGSEGV, emergencyCompileContext);
+    signal(SIGBUS, emergencyCompileContext);
+    signal(SIGILL, emergencyCompileContext);
+    signal(SIGABRT, emergencyCompileContext);
+    return mainfn(argc, argv, envp);
 }
+} // namespace clay
 
 #endif
diff --git a/compiler/parachute.hpp b/compiler/parachute.hpp
index 864d2005..3f2a160a 100644
--- a/compiler/parachute.hpp
+++ b/compiler/parachute.hpp
@@ -1,6 +1,6 @@
 #pragma once
 
 namespace clay {
-    int parachute(int (*mainfn)(int, char **, char const *const*),
-                  int argc, char **argv, char const *const*envp);
+int parachute(int (*mainfn)(int, char **, char const *const *), int argc,
+              char **argv, char const *const *envp);
 }
diff --git a/compiler/parser.cpp b/compiler/parser.cpp
index 2d79761b..ceda2618 100644
--- a/compiler/parser.cpp
+++ b/compiler/parser.cpp
@@ -1,3291 +1,3797 @@
-#include "clay.hpp"
 #include "parser.hpp"
-#include "error.hpp"
+#include "clay.hpp"
 #include "desugar.hpp"
+#include "error.hpp"
 
 namespace clay {
-    map<llvm::StringRef, IdentifierPtr> Identifier::freeIdentifiers;
+map<llvm::StringRef, IdentifierPtr> Identifier::freeIdentifiers;
 
-    static vector<Token> *tokens;
-    static unsigned position;
-    static unsigned maxPosition;
-    static bool parserOptionKeepDocumentation = false;
+static vector<Token> *tokens;
+static unsigned position;
+static unsigned maxPosition;
+static bool parserOptionKeepDocumentation = false;
 
-    static AddTokensCallback addTokens = nullptr;
+static AddTokensCallback addTokens = nullptr;
 
-    void setAddTokens(AddTokensCallback f) {
-        addTokens = f;
-    }
+void setAddTokens(AddTokensCallback f) { addTokens = f; }
 
-    static bool inRepl = false;
+static bool inRepl = false;
 
-    static bool next(Token *&x) {
-        if (position == tokens->size()) {
-            if (inRepl) {
-                assert(addTokens != nullptr);
-                vector<Token> toks = addTokens();
-                if (toks.empty()) {
-                    inRepl = false;
-                    return false;
-                }
-                tokens->insert(tokens->end(), toks.begin(), toks.end());
-            } else {
+static bool next(Token *&x) {
+    if (position == tokens->size()) {
+        if (inRepl) {
+            assert(addTokens != nullptr);
+            vector<Token> toks = addTokens();
+            if (toks.empty()) {
+                inRepl = false;
                 return false;
             }
+            tokens->insert(tokens->end(), toks.begin(), toks.end());
+        } else {
+            return false;
         }
-        x = &(*tokens)[position];
-        if (position > maxPosition)
-            maxPosition = position;
-        ++position;
-        return true;
-    }
-
-    static unsigned save() {
-        return position;
-    }
-
-    static void restore(unsigned p) {
-        position = p;
-    }
-
-    static Location currentLocation() {
-        if (position == tokens->size())
-            return {};
-        return (*tokens)[position].location;
     }
+    x = &(*tokens)[position];
+    if (position > maxPosition)
+        maxPosition = position;
+    ++position;
+    return true;
+}
 
-    //
-    // symbol, keyword
-    //
-
-    static bool opstring(llvm::StringRef &op) {
-        Token *t;
-        if (!next(t) || (t->tokenKind != T_OPSTRING))
-            return false;
-        op = llvm::StringRef(t->str);
-        return true;
-    }
+static unsigned save() { return position; }
 
-    static bool uopstring(llvm::StringRef &op) {
-        Token *t;
-        if (!next(t) || (t->tokenKind != T_UOPSTRING))
-            return false;
-        op = llvm::StringRef(t->str);
-        return true;
-    }
+static void restore(unsigned p) { position = p; }
 
-    static bool opsymbol(const char *s) {
-        Token *t;
-        if (!next(t) || (t->tokenKind != T_OPSTRING))
-            return false;
-        return t->str == s;
-    }
+static Location currentLocation() {
+    if (position == tokens->size())
+        return {};
+    return (*tokens)[position].location;
+}
 
-    static bool symbol(const char *s) {
-        Token *t;
-        if (!next(t) || (t->tokenKind != T_SYMBOL))
-            return false;
-        return t->str == s;
-    }
+//
+// symbol, keyword
+//
 
-    static bool keyword(const char *s) {
-        Token *t;
-        if (!next(t) || (t->tokenKind != T_KEYWORD))
-            return false;
-        return t->str == s;
-    }
+static bool opstring(llvm::StringRef &op) {
+    Token *t;
+    if (!next(t) || (t->tokenKind != T_OPSTRING))
+        return false;
+    op = llvm::StringRef(t->str);
+    return true;
+}
 
-    static bool ellipsis() {
-        return symbol("..");
-    }
+static bool uopstring(llvm::StringRef &op) {
+    Token *t;
+    if (!next(t) || (t->tokenKind != T_UOPSTRING))
+        return false;
+    op = llvm::StringRef(t->str);
+    return true;
+}
 
-    //
-    // identifier, identifierList,
-    // identifierListNoTail, dottedName
-    //
+static bool opsymbol(const char *s) {
+    Token *t;
+    if (!next(t) || (t->tokenKind != T_OPSTRING))
+        return false;
+    return t->str == s;
+}
 
-    static bool identifier(IdentifierPtr &x) {
-        Location location = currentLocation();
-        Token *t;
-        if (!next(t) || (t->tokenKind != T_IDENTIFIER && t->tokenKind != T_OPIDENTIFIER))
-            return false;
-        if (t->tokenKind == T_IDENTIFIER)
-            x = Identifier::get(t->str, location);
-        else
-            x = Identifier::get(t->str, location, true);
-        return true;
-    }
+static bool symbol(const char *s) {
+    Token *t;
+    if (!next(t) || (t->tokenKind != T_SYMBOL))
+        return false;
+    return t->str == s;
+}
 
-    static bool identifierList(vector<IdentifierPtr> &x) {
-        IdentifierPtr y;
-        if (!identifier(y)) return false;
-        x.clear();
-        while (true) {
-            x.push_back(y);
-            unsigned p = save();
-            if (!symbol(",")) {
-                restore(p);
-                break;
-            }
-            p = save();
-            if (!identifier(y)) {
-                restore(p);
-                break;
-            }
-        }
-        return true;
-    }
+static bool keyword(const char *s) {
+    Token *t;
+    if (!next(t) || (t->tokenKind != T_KEYWORD))
+        return false;
+    return t->str == s;
+}
 
-    static bool identifierListNoTail(vector<IdentifierPtr> &x) {
-        IdentifierPtr y;
-        if (!identifier(y)) return false;
-        x.clear();
-        while (true) {
-            x.push_back(y);
-            unsigned p = save();
-            if (!symbol(",") || !identifier(y)) {
-                restore(p);
-                break;
-            }
-        }
-        return true;
-    }
+static bool ellipsis() { return symbol(".."); }
 
-    static bool dottedName(DottedNamePtr &x) {
-        Location location = currentLocation();
-        DottedNamePtr y = new DottedName();
-        IdentifierPtr ident;
-        if (!identifier(ident)) return false;
-        while (true) {
-            y->parts.push_back(ident);
-            unsigned p = save();
-            if (!symbol(".") || !identifier(ident)) {
-                restore(p);
-                break;
-            }
-        }
-        x = y;
-        x->location = location;
-        return true;
-    }
+//
+// identifier, identifierList,
+// identifierListNoTail, dottedName
+//
 
-    //
-    // literals
-    //
+static bool identifier(IdentifierPtr &x) {
+    Location location = currentLocation();
+    Token *t;
+    if (!next(t) ||
+        (t->tokenKind != T_IDENTIFIER && t->tokenKind != T_OPIDENTIFIER))
+        return false;
+    if (t->tokenKind == T_IDENTIFIER)
+        x = Identifier::get(t->str, location);
+    else
+        x = Identifier::get(t->str, location, true);
+    return true;
+}
 
-    static bool boolLiteral(ExprPtr &x) {
-        Location location = currentLocation();
+static bool identifierList(vector<IdentifierPtr> &x) {
+    IdentifierPtr y;
+    if (!identifier(y))
+        return false;
+    x.clear();
+    while (true) {
+        x.push_back(y);
         unsigned p = save();
-        if (keyword("true"))
-            x = new BoolLiteral(true);
-        else if (restore(p), keyword("false"))
-            x = new BoolLiteral(false);
-        else
-            return false;
-        x->location = location;
-        return true;
-    }
-
-    static string cleanNumericSeparator(llvm::StringRef op, llvm::StringRef s) {
-        string out;
-        if (op == "-")
-            out.push_back('-');
-        for (size_t i = 0; i < s.size(); ++i) {
-            if (s[i] != '_')
-                out.push_back(s[i]);
+        if (!symbol(",")) {
+            restore(p);
+            break;
+        }
+        p = save();
+        if (!identifier(y)) {
+            restore(p);
+            break;
         }
-        return out;
     }
+    return true;
+}
 
-    static bool intLiteral(llvm::StringRef op, ExprPtr &x) {
-        Location location = currentLocation();
-        Token *t;
-        if (!next(t) || (t->tokenKind != T_INT_LITERAL))
-            return false;
-        Token *t2;
+static bool identifierListNoTail(vector<IdentifierPtr> &x) {
+    IdentifierPtr y;
+    if (!identifier(y))
+        return false;
+    x.clear();
+    while (true) {
+        x.push_back(y);
         unsigned p = save();
-        if (next(t2) && (t2->tokenKind == T_IDENTIFIER)) {
-            x = new IntLiteral(cleanNumericSeparator(op, t->str), t2->str);
-        } else {
+        if (!symbol(",") || !identifier(y)) {
             restore(p);
-            x = new IntLiteral(cleanNumericSeparator(op, t->str));
+            break;
         }
-        x->location = location;
-        return true;
     }
+    return true;
+}
 
-    static bool floatLiteral(llvm::StringRef op, ExprPtr &x) {
-        Location location = currentLocation();
-        Token *t;
-        if (!next(t) || (t->tokenKind != T_FLOAT_LITERAL))
-            return false;
-        Token *t2;
+static bool dottedName(DottedNamePtr &x) {
+    Location location = currentLocation();
+    DottedNamePtr y = new DottedName();
+    IdentifierPtr ident;
+    if (!identifier(ident))
+        return false;
+    while (true) {
+        y->parts.push_back(ident);
         unsigned p = save();
-        if (next(t2) && (t2->tokenKind == T_IDENTIFIER)) {
-            x = new FloatLiteral(cleanNumericSeparator(op, t->str), t2->str);
-        } else {
+        if (!symbol(".") || !identifier(ident)) {
             restore(p);
-            x = new FloatLiteral(cleanNumericSeparator(op, t->str));
+            break;
         }
-        x->location = location;
-        return true;
     }
+    x = y;
+    x->location = location;
+    return true;
+}
 
-    static bool charLiteral(ExprPtr &x) {
-        Location location = currentLocation();
-        Token *t;
-        if (!next(t) || (t->tokenKind != T_CHAR_LITERAL))
-            return false;
-        x = new CharLiteral(t->str[0]);
-        x->location = location;
-        return true;
+//
+// literals
+//
+
+static bool boolLiteral(ExprPtr &x) {
+    Location location = currentLocation();
+    unsigned p = save();
+    if (keyword("true"))
+        x = new BoolLiteral(true);
+    else if (restore(p), keyword("false"))
+        x = new BoolLiteral(false);
+    else
+        return false;
+    x->location = location;
+    return true;
+}
+
+static string cleanNumericSeparator(llvm::StringRef op, llvm::StringRef s) {
+    string out;
+    if (op == "-")
+        out.push_back('-');
+    for (size_t i = 0; i < s.size(); ++i) {
+        if (s[i] != '_')
+            out.push_back(s[i]);
     }
+    return out;
+}
 
-    static bool stringLiteral(ExprPtr &x) {
-        Location location = currentLocation();
-        Token *t;
-        if (!next(t) || (t->tokenKind != T_STRING_LITERAL))
-            return false;
-        IdentifierPtr id = Identifier::get(t->str, location);
-        x = new StringLiteral(id);
-        x->location = location;
-        return true;
+static bool intLiteral(llvm::StringRef op, ExprPtr &x) {
+    Location location = currentLocation();
+    Token *t;
+    if (!next(t) || (t->tokenKind != T_INT_LITERAL))
+        return false;
+    Token *t2;
+    unsigned p = save();
+    if (next(t2) && (t2->tokenKind == T_IDENTIFIER)) {
+        x = new IntLiteral(cleanNumericSeparator(op, t->str), t2->str);
+    } else {
+        restore(p);
+        x = new IntLiteral(cleanNumericSeparator(op, t->str));
     }
+    x->location = location;
+    return true;
+}
 
-    static bool literal(ExprPtr &x) {
-        unsigned p = save();
-        if (boolLiteral(x)) return true;
-        if (restore(p), intLiteral("+", x)) return true;
-        if (restore(p), floatLiteral("+", x)) return true;
-        if (restore(p), charLiteral(x)) return true;
-        if (restore(p), stringLiteral(x)) return true;
+static bool floatLiteral(llvm::StringRef op, ExprPtr &x) {
+    Location location = currentLocation();
+    Token *t;
+    if (!next(t) || (t->tokenKind != T_FLOAT_LITERAL))
         return false;
+    Token *t2;
+    unsigned p = save();
+    if (next(t2) && (t2->tokenKind == T_IDENTIFIER)) {
+        x = new FloatLiteral(cleanNumericSeparator(op, t->str), t2->str);
+    } else {
+        restore(p);
+        x = new FloatLiteral(cleanNumericSeparator(op, t->str));
     }
+    x->location = location;
+    return true;
+}
 
-    //
-    // expression misc
-    //
+static bool charLiteral(ExprPtr &x) {
+    Location location = currentLocation();
+    Token *t;
+    if (!next(t) || (t->tokenKind != T_CHAR_LITERAL))
+        return false;
+    x = new CharLiteral(t->str[0]);
+    x->location = location;
+    return true;
+}
 
-    static bool expression(ExprPtr &x, bool = false);
+static bool stringLiteral(ExprPtr &x) {
+    Location location = currentLocation();
+    Token *t;
+    if (!next(t) || (t->tokenKind != T_STRING_LITERAL))
+        return false;
+    IdentifierPtr id = Identifier::get(t->str, location);
+    x = new StringLiteral(id);
+    x->location = location;
+    return true;
+}
 
-    static bool optExpression(ExprPtr &x) {
-        unsigned p = save();
-        if (!expression(x)) {
-            restore(p);
-            x = nullptr;
-        }
+static bool literal(ExprPtr &x) {
+    unsigned p = save();
+    if (boolLiteral(x))
         return true;
-    }
-
-    static bool expressionList(ExprListPtr &x, bool = false) {
-        ExprPtr b;
-        if (!expression(b)) return false;
-        ExprListPtr a = new ExprList(b);
-        while (true) {
-            unsigned p = save();
-            if (!symbol(",")) {
-                restore(p);
-                break;
-            }
-            p = save();
-            if (!expression(b)) {
-                restore(p);
-                break;
-            }
-            a->add(b);
-        }
-        x = a;
+    if (restore(p), intLiteral("+", x))
+        return true;
+    if (restore(p), floatLiteral("+", x))
+        return true;
+    if (restore(p), charLiteral(x))
+        return true;
+    if (restore(p), stringLiteral(x))
         return true;
+    return false;
+}
+
+//
+// expression misc
+//
+
+static bool expression(ExprPtr &x, bool = false);
+
+static bool optExpression(ExprPtr &x) {
+    unsigned p = save();
+    if (!expression(x)) {
+        restore(p);
+        x = nullptr;
     }
+    return true;
+}
 
-    static bool optExpressionList(ExprListPtr &x) {
+static bool expressionList(ExprListPtr &x, bool = false) {
+    ExprPtr b;
+    if (!expression(b))
+        return false;
+    ExprListPtr a = new ExprList(b);
+    while (true) {
         unsigned p = save();
-        if (!expressionList(x)) {
+        if (!symbol(",")) {
             restore(p);
-            x = new ExprList();
+            break;
         }
-        return true;
+        p = save();
+        if (!expression(b)) {
+            restore(p);
+            break;
+        }
+        a->add(b);
     }
+    x = a;
+    return true;
+}
 
-    //
-    // atomic expr
-    //
-
-    static bool tupleExpr(ExprPtr &x) {
-        Location location = currentLocation();
-        if (!symbol("[")) return false;
-        ExprListPtr args;
-        if (!optExpressionList(args)) return false;
-        if (!symbol("]")) return false;
-        x = new Tuple(args);
-        x->location = location;
-        return true;
+static bool optExpressionList(ExprListPtr &x) {
+    unsigned p = save();
+    if (!expressionList(x)) {
+        restore(p);
+        x = new ExprList();
     }
+    return true;
+}
 
-    static bool parenExpr(ExprPtr &x) {
-        Location location = currentLocation();
-        if (!symbol("(")) return false;
-        ExprListPtr args;
-        if (!optExpressionList(args)) return false;
-        if (!symbol(")")) return false;
-        x = new Paren(args);
-        x->location = location;
-        return true;
-    }
+//
+// atomic expr
+//
 
-    static bool nameRef(ExprPtr &x) {
-        Location location = currentLocation();
-        IdentifierPtr a;
-        if (!identifier(a)) return false;
-        x = new NameRef(a);
-        x->location = location;
-        return true;
-    }
+static bool tupleExpr(ExprPtr &x) {
+    Location location = currentLocation();
+    if (!symbol("["))
+        return false;
+    ExprListPtr args;
+    if (!optExpressionList(args))
+        return false;
+    if (!symbol("]"))
+        return false;
+    x = new Tuple(args);
+    x->location = location;
+    return true;
+}
 
-    static bool fileExpr(ExprPtr &x) {
-        Location location = currentLocation();
-        if (!keyword("__FILE__")) return false;
-        x = new FILEExpr();
-        x->location = location;
-        return true;
-    }
+static bool parenExpr(ExprPtr &x) {
+    Location location = currentLocation();
+    if (!symbol("("))
+        return false;
+    ExprListPtr args;
+    if (!optExpressionList(args))
+        return false;
+    if (!symbol(")"))
+        return false;
+    x = new Paren(args);
+    x->location = location;
+    return true;
+}
 
-    static bool lineExpr(ExprPtr &x) {
-        Location location = currentLocation();
-        if (!keyword("__LINE__")) return false;
-        x = new LINEExpr();
-        x->location = location;
-        return true;
-    }
+static bool nameRef(ExprPtr &x) {
+    Location location = currentLocation();
+    IdentifierPtr a;
+    if (!identifier(a))
+        return false;
+    x = new NameRef(a);
+    x->location = location;
+    return true;
+}
 
-    static bool columnExpr(ExprPtr &x) {
-        Location location = currentLocation();
-        if (!keyword("__COLUMN__")) return false;
-        x = new COLUMNExpr();
-        x->location = location;
-        return true;
-    }
+static bool fileExpr(ExprPtr &x) {
+    Location location = currentLocation();
+    if (!keyword("__FILE__"))
+        return false;
+    x = new FILEExpr();
+    x->location = location;
+    return true;
+}
 
-    static bool argExpr(ExprPtr &x) {
-        Location location = currentLocation();
-        if (!keyword("__ARG__")) return false;
-        IdentifierPtr name;
-        if (!identifier(name)) return false;
-        x = new ARGExpr(name);
-        x->location = location;
-        return true;
-    }
+static bool lineExpr(ExprPtr &x) {
+    Location location = currentLocation();
+    if (!keyword("__LINE__"))
+        return false;
+    x = new LINEExpr();
+    x->location = location;
+    return true;
+}
 
-    static bool evalExpr(ExprPtr &ev) {
-        Location location = currentLocation();
-        if (!keyword("eval")) return false;
-        ExprPtr args;
-        if (!expression(args)) return false;
-        ev = new EvalExpr(args);
-        ev->location = location;
-        return true;
-    }
+static bool columnExpr(ExprPtr &x) {
+    Location location = currentLocation();
+    if (!keyword("__COLUMN__"))
+        return false;
+    x = new COLUMNExpr();
+    x->location = location;
+    return true;
+}
 
-    static bool atomicExpr(ExprPtr &x) {
-        unsigned p = save();
-        if (nameRef(x)) return true;
-        if (restore(p), parenExpr(x)) return true;
-        if (restore(p), literal(x)) return true;
-        if (restore(p), tupleExpr(x)) return true;
-        if (restore(p), fileExpr(x)) return true;
-        if (restore(p), lineExpr(x)) return true;
-        if (restore(p), columnExpr(x)) return true;
-        if (restore(p), argExpr(x)) return true;
-        if (restore(p), evalExpr(x)) return true;
+static bool argExpr(ExprPtr &x) {
+    Location location = currentLocation();
+    if (!keyword("__ARG__"))
         return false;
-    }
+    IdentifierPtr name;
+    if (!identifier(name))
+        return false;
+    x = new ARGExpr(name);
+    x->location = location;
+    return true;
+}
 
-    //
-    // suffix expr
-    //
+static bool evalExpr(ExprPtr &ev) {
+    Location location = currentLocation();
+    if (!keyword("eval"))
+        return false;
+    ExprPtr args;
+    if (!expression(args))
+        return false;
+    ev = new EvalExpr(args);
+    ev->location = location;
+    return true;
+}
 
-    static bool stringLiteralSuffix(ExprPtr &x) {
-        Location location = currentLocation();
-        ExprPtr str;
-        if (!stringLiteral(str)) return false;
-        ExprListPtr strArgs = new ExprList(str);
-        x = new Call(nullptr, strArgs);
-        x->location = location;
+static bool atomicExpr(ExprPtr &x) {
+    unsigned p = save();
+    if (nameRef(x))
         return true;
-    }
-
-    static bool indexingSuffix(ExprPtr &x) {
-        Location location = currentLocation();
-        if (!symbol("[")) return false;
-        ExprListPtr args;
-        if (!optExpressionList(args)) return false;
-        if (!symbol("]")) return false;
-        x = new Indexing(nullptr, args);
-        x->location = location;
+    if (restore(p), parenExpr(x))
         return true;
-    }
-
-    static bool callSuffix(ExprPtr &x) {
-        Location location = currentLocation();
-        if (!symbol("(")) return false;
-        ExprListPtr args;
-        if (!optExpressionList(args)) return false;
-        if (!symbol(")")) return false;
-        x = new Call(nullptr, args);
-        x->location = location;
+    if (restore(p), literal(x))
         return true;
-    }
-
-    static bool fieldRefSuffix(ExprPtr &x) {
-        Location location = currentLocation();
-        if (!symbol(".")) return false;
-        IdentifierPtr a;
-        if (!identifier(a)) return false;
-        x = new FieldRef(nullptr, a);
-        x->location = location;
+    if (restore(p), tupleExpr(x))
         return true;
-    }
-
-    static bool staticIndexingSuffix(ExprPtr &x) {
-        Location location = currentLocation();
-        Token *t;
-        if (!next(t) || (t->tokenKind != T_STATIC_INDEX))
-            return false;
-        char *b = const_cast<char *>(t->str.c_str());
-        char *end = b;
-        unsigned long c = strtoul(b, &end, 0);
-        if (*end != 0)
-            error(t, "invalid static index value");
-        x = new StaticIndexing(nullptr, (size_t) c);
-        x->location = location;
+    if (restore(p), fileExpr(x))
         return true;
-    }
-
-    static bool dereferenceSuffix(ExprPtr &x) {
-        Location location = currentLocation();
-        if (!symbol("^")) return false;
-        x = new VariadicOp(DEREFERENCE, new ExprList());
-        x->location = location;
+    if (restore(p), lineExpr(x))
         return true;
-    }
+    if (restore(p), columnExpr(x))
+        return true;
+    if (restore(p), argExpr(x))
+        return true;
+    if (restore(p), evalExpr(x))
+        return true;
+    return false;
+}
 
-    static bool suffix(ExprPtr &x) {
-        unsigned p = save();
-        if (stringLiteralSuffix(x)) return true;
-        if (restore(p), indexingSuffix(x)) return true;
-        if (restore(p), callSuffix(x)) return true;
-        if (restore(p), fieldRefSuffix(x)) return true;
-        if (restore(p), staticIndexingSuffix(x)) return true;
-        if (restore(p), dereferenceSuffix(x)) return true;
+//
+// suffix expr
+//
+
+static bool stringLiteralSuffix(ExprPtr &x) {
+    Location location = currentLocation();
+    ExprPtr str;
+    if (!stringLiteral(str))
         return false;
-    }
+    ExprListPtr strArgs = new ExprList(str);
+    x = new Call(nullptr, strArgs);
+    x->location = location;
+    return true;
+}
 
-    static void setSuffixBase(Expr *a, const ExprPtr &base) {
-        switch (a->exprKind) {
-            case INDEXING: {
-                auto b = dynamic_cast<Indexing *>(a);
-                b->expr = base;
-                break;
-            }
-            case CALL: {
-                Call *b = dynamic_cast<Call *>(a);
-                b->expr = base;
-                break;
-            }
-            case FIELD_REF: {
-                auto b = dynamic_cast<FieldRef *>(a);
-                b->expr = base;
-                break;
-            }
-            case STATIC_INDEXING: {
-                auto b = dynamic_cast<StaticIndexing *>(a);
-                b->expr = base;
-                break;
-            }
-            case VARIADIC_OP: {
-                auto *b = dynamic_cast<VariadicOp *>(a);
-                assert(b->op == DEREFERENCE);
-                b->exprs->add(base);
-                break;
-            }
-            default:
-                assert(false);
-        }
-    }
+static bool indexingSuffix(ExprPtr &x) {
+    Location location = currentLocation();
+    if (!symbol("["))
+        return false;
+    ExprListPtr args;
+    if (!optExpressionList(args))
+        return false;
+    if (!symbol("]"))
+        return false;
+    x = new Indexing(nullptr, args);
+    x->location = location;
+    return true;
+}
 
-    static bool suffixExpr(ExprPtr &x) {
-        if (!atomicExpr(x)) return false;
-        while (true) {
-            unsigned p = save();
-            ExprPtr y;
-            if (!suffix(y)) {
-                restore(p);
-                break;
-            }
-            setSuffixBase(y.ptr(), x);
-            x = y;
-        }
-        return true;
-    }
+static bool callSuffix(ExprPtr &x) {
+    Location location = currentLocation();
+    if (!symbol("("))
+        return false;
+    ExprListPtr args;
+    if (!optExpressionList(args))
+        return false;
+    if (!symbol(")"))
+        return false;
+    x = new Call(nullptr, args);
+    x->location = location;
+    return true;
+}
+
+static bool fieldRefSuffix(ExprPtr &x) {
+    Location location = currentLocation();
+    if (!symbol("."))
+        return false;
+    IdentifierPtr a;
+    if (!identifier(a))
+        return false;
+    x = new FieldRef(nullptr, a);
+    x->location = location;
+    return true;
+}
 
-    //
-    // prefix expr
-    //
+static bool staticIndexingSuffix(ExprPtr &x) {
+    Location location = currentLocation();
+    Token *t;
+    if (!next(t) || (t->tokenKind != T_STATIC_INDEX))
+        return false;
+    char *b = const_cast<char *>(t->str.c_str());
+    char *end = b;
+    unsigned long c = strtoul(b, &end, 0);
+    if (*end != 0)
+        error(t, "invalid static index value");
+    x = new StaticIndexing(nullptr, (size_t)c);
+    x->location = location;
+    return true;
+}
 
-    static bool prefixExpr(ExprPtr &x);
+static bool dereferenceSuffix(ExprPtr &x) {
+    Location location = currentLocation();
+    if (!symbol("^"))
+        return false;
+    x = new VariadicOp(DEREFERENCE, new ExprList());
+    x->location = location;
+    return true;
+}
 
-    static bool addressOfExpr(ExprPtr &x) {
-        Location location = currentLocation();
-        if (!symbol("@")) return false;
-        ExprPtr a;
-        if (!prefixExpr(a)) return false;
-        x = new VariadicOp(ADDRESS_OF, new ExprList(a));
-        x->location = location;
+static bool suffix(ExprPtr &x) {
+    unsigned p = save();
+    if (stringLiteralSuffix(x))
         return true;
-    }
+    if (restore(p), indexingSuffix(x))
+        return true;
+    if (restore(p), callSuffix(x))
+        return true;
+    if (restore(p), fieldRefSuffix(x))
+        return true;
+    if (restore(p), staticIndexingSuffix(x))
+        return true;
+    if (restore(p), dereferenceSuffix(x))
+        return true;
+    return false;
+}
 
-    static bool plusOrMinus(llvm::StringRef &op) {
-        unsigned p = save();
-        if (opsymbol("+")) {
-            op = llvm::StringRef("+");
-            return true;
-        } else if (restore(p), opsymbol("-")) {
-            op = llvm::StringRef("-");
-            return true;
-        } else
-            return false;
+static void setSuffixBase(Expr *a, const ExprPtr &base) {
+    switch (a->exprKind) {
+    case INDEXING: {
+        auto b = dynamic_cast<Indexing *>(a);
+        b->expr = base;
+        break;
+    }
+    case CALL: {
+        Call *b = dynamic_cast<Call *>(a);
+        b->expr = base;
+        break;
+    }
+    case FIELD_REF: {
+        auto b = dynamic_cast<FieldRef *>(a);
+        b->expr = base;
+        break;
+    }
+    case STATIC_INDEXING: {
+        auto b = dynamic_cast<StaticIndexing *>(a);
+        b->expr = base;
+        break;
+    }
+    case VARIADIC_OP: {
+        auto *b = dynamic_cast<VariadicOp *>(a);
+        assert(b->op == DEREFERENCE);
+        b->exprs->add(base);
+        break;
+    }
+    default:
+        assert(false);
     }
+}
 
-    static bool signedLiteral(llvm::StringRef op, ExprPtr &x) {
-        unsigned p = save();
-        if (restore(p), intLiteral(op, x)) return true;
-        if (restore(p), floatLiteral(op, x)) return true;
+static bool suffixExpr(ExprPtr &x) {
+    if (!atomicExpr(x))
         return false;
-    }
-
-    static bool dispatchExpr(ExprPtr &x) {
-        Location location = currentLocation();
-        if (!opsymbol("*")) return false;
-        ExprPtr a;
-        if (!prefixExpr(a)) return false;
-        x = new DispatchExpr(a);
-        x->location = location;
-        return true;
-    }
-
-    static bool staticExpr(ExprPtr &x) {
-        Location location = currentLocation();
-        if (!symbol("#")) return false;
-        ExprPtr y;
-        if (!prefixExpr(y)) return false;
-        x = new StaticExpr(y);
-        x->location = location;
-        return true;
-    }
-
-    static bool operatorOp(llvm::StringRef &op) {
+    while (true) {
         unsigned p = save();
-
-        const char *s[] = {
-            "<--", "-->", "=>", "->", "~>", "=", nullptr
-        };
-        for (const char **a = s; *a; ++a) {
-            if (opsymbol(*a)) return false;
+        ExprPtr y;
+        if (!suffix(y)) {
             restore(p);
+            break;
         }
-        if (!opstring(op)) return false;
-        return true;
+        setSuffixBase(y.ptr(), x);
+        x = y;
     }
+    return true;
+}
 
-    static bool preopExpr(ExprPtr &x) {
-        Location location = currentLocation();
-        llvm::StringRef op;
-        unsigned p = save();
-        if (plusOrMinus(op)) {
-            if (signedLiteral(op, x)) return true;
-        }
-        restore(p);
-        if (!operatorOp(op)) return false;
-        ExprPtr y;
-        if (!prefixExpr(y)) return false;
-        ExprListPtr exprs = new ExprList(new NameRef(Identifier::get(op, true)));
-        exprs->add(y);
-        x = new VariadicOp(PREFIX_OP, exprs);
-        x->location = location;
-        return true;
-    }
+//
+// prefix expr
+//
 
-    static bool prefixExpr(ExprPtr &x) {
-        unsigned p = save();
-        if (addressOfExpr(x)) return true;
-        if (restore(p), dispatchExpr(x)) return true;
-        if (restore(p), preopExpr(x)) return true;
-        if (restore(p), staticExpr(x)) return true;
-        if (restore(p), suffixExpr(x)) return true;
-        return false;
-    }
+static bool prefixExpr(ExprPtr &x);
 
-    //
-    // infix binary operator expr
-    //
+static bool addressOfExpr(ExprPtr &x) {
+    Location location = currentLocation();
+    if (!symbol("@"))
+        return false;
+    ExprPtr a;
+    if (!prefixExpr(a))
+        return false;
+    x = new VariadicOp(ADDRESS_OF, new ExprList(a));
+    x->location = location;
+    return true;
+}
 
-    static bool operatorTail(VariadicOpPtr &x) {
-        Location location = currentLocation();
-        ExprListPtr exprs = new ExprList();
-        ExprPtr b;
-        llvm::StringRef op;
-        if (!operatorOp(op)) return false;
-        unsigned p = save();
-        while (true) {
-            if (!prefixExpr(b)) return false;
-            exprs->add(new NameRef(Identifier::get(op, true)));
-            exprs->add(b);
-            p = save();
-            if (!operatorOp(op)) {
-                restore(p);
-                break;
-            }
-        }
-        x = new VariadicOp(INFIX_OP, exprs);
-        x->location = location;
+static bool plusOrMinus(llvm::StringRef &op) {
+    unsigned p = save();
+    if (opsymbol("+")) {
+        op = llvm::StringRef("+");
         return true;
-    }
+    } else if (restore(p), opsymbol("-")) {
+        op = llvm::StringRef("-");
+        return true;
+    } else
+        return false;
+}
 
-    static bool operatorExpr(ExprPtr &x) {
-        if (!prefixExpr(x)) return false;
-        while (true) {
-            unsigned p = save();
-            VariadicOpPtr y;
-            if (!operatorTail(y)) {
-                restore(p);
-                break;
-            }
-            y->exprs->insert(x);
-            x = y.ptr();
-        }
+static bool signedLiteral(llvm::StringRef op, ExprPtr &x) {
+    unsigned p = save();
+    if (restore(p), intLiteral(op, x))
         return true;
-    }
+    if (restore(p), floatLiteral(op, x))
+        return true;
+    return false;
+}
 
-    //
-    // not, and, or
-    //
+static bool dispatchExpr(ExprPtr &x) {
+    Location location = currentLocation();
+    if (!opsymbol("*"))
+        return false;
+    ExprPtr a;
+    if (!prefixExpr(a))
+        return false;
+    x = new DispatchExpr(a);
+    x->location = location;
+    return true;
+}
 
-    static bool notExpr(ExprPtr &x) {
-        Location location = currentLocation();
-        unsigned p = save();
-        if (!keyword("not")) {
-            restore(p);
-            return operatorExpr(x);
-        }
-        ExprPtr y;
-        if (!operatorExpr(y)) return false;
-        x = new VariadicOp(NOT, new ExprList(y));
-        x->location = location;
-        return true;
-    }
+static bool staticExpr(ExprPtr &x) {
+    Location location = currentLocation();
+    if (!symbol("#"))
+        return false;
+    ExprPtr y;
+    if (!prefixExpr(y))
+        return false;
+    x = new StaticExpr(y);
+    x->location = location;
+    return true;
+}
 
-    static bool andExprTail(AndPtr &x) {
-        Location location = currentLocation();
-        if (!keyword("and")) return false;
-        ExprPtr y;
-        if (!notExpr(y)) return false;
-        x = new And(nullptr, y);
-        x->location = location;
-        return true;
+static bool operatorOp(llvm::StringRef &op) {
+    unsigned p = save();
+
+    const char *s[] = {"<--", "-->", "=>", "->", "~>", "=", nullptr};
+    for (const char **a = s; *a; ++a) {
+        if (opsymbol(*a))
+            return false;
+        restore(p);
     }
+    if (!opstring(op))
+        return false;
+    return true;
+}
 
-    static bool andExpr(ExprPtr &x) {
-        if (!notExpr(x)) return false;
-        while (true) {
-            unsigned p = save();
-            AndPtr y;
-            if (!andExprTail(y)) {
-                restore(p);
-                break;
-            }
-            y->expr1 = x;
-            x = y.ptr();
-        }
-        return true;
+static bool preopExpr(ExprPtr &x) {
+    Location location = currentLocation();
+    llvm::StringRef op;
+    unsigned p = save();
+    if (plusOrMinus(op)) {
+        if (signedLiteral(op, x))
+            return true;
     }
+    restore(p);
+    if (!operatorOp(op))
+        return false;
+    ExprPtr y;
+    if (!prefixExpr(y))
+        return false;
+    ExprListPtr exprs = new ExprList(new NameRef(Identifier::get(op, true)));
+    exprs->add(y);
+    x = new VariadicOp(PREFIX_OP, exprs);
+    x->location = location;
+    return true;
+}
 
-    static bool orExprTail(OrPtr &x) {
-        Location location = currentLocation();
-        if (!keyword("or")) return false;
-        ExprPtr y;
-        if (!andExpr(y)) return false;
-        x = new Or(nullptr, y);
-        x->location = location;
+static bool prefixExpr(ExprPtr &x) {
+    unsigned p = save();
+    if (addressOfExpr(x))
         return true;
-    }
+    if (restore(p), dispatchExpr(x))
+        return true;
+    if (restore(p), preopExpr(x))
+        return true;
+    if (restore(p), staticExpr(x))
+        return true;
+    if (restore(p), suffixExpr(x))
+        return true;
+    return false;
+}
 
-    static bool orExpr(ExprPtr &x) {
-        if (!andExpr(x)) return false;
-        while (true) {
-            unsigned p = save();
-            OrPtr y;
-            if (!orExprTail(y)) {
-                restore(p);
-                break;
-            }
-            y->expr1 = x;
-            x = y.ptr();
+//
+// infix binary operator expr
+//
+
+static bool operatorTail(VariadicOpPtr &x) {
+    Location location = currentLocation();
+    ExprListPtr exprs = new ExprList();
+    ExprPtr b;
+    llvm::StringRef op;
+    if (!operatorOp(op))
+        return false;
+    unsigned p = save();
+    while (true) {
+        if (!prefixExpr(b))
+            return false;
+        exprs->add(new NameRef(Identifier::get(op, true)));
+        exprs->add(b);
+        p = save();
+        if (!operatorOp(op)) {
+            restore(p);
+            break;
         }
-        return true;
     }
+    x = new VariadicOp(INFIX_OP, exprs);
+    x->location = location;
+    return true;
+}
 
-    //
-    // ifExpr
-    //
-
-    static bool ifExpr(ExprPtr &x) {
-        Location location = currentLocation();
-        ExprPtr expr;
-        if (!keyword("if")) return false;
-        if (!symbol("(")) return false;
-        if (!expression(expr)) return false;
-        ExprListPtr exprs = new ExprList(expr);
-        if (!symbol(")")) return false;
-        if (!expression(expr)) return false;
-        exprs->add(expr);
-        if (!keyword("else")) return false;
-        if (!expression(expr)) return false;
-        exprs->add(expr);
-        x = new VariadicOp(IF_EXPR, exprs);
-        x->location = location;
-        return true;
-    }
-
-    //
-    // returnKind, returnExprList, returnExpr
-    //
-
-    static bool returnKind(ReturnKind &x) {
+static bool operatorExpr(ExprPtr &x) {
+    if (!prefixExpr(x))
+        return false;
+    while (true) {
         unsigned p = save();
-        if (keyword("ref")) {
-            x = RETURN_REF;
-        } else if (restore(p), keyword("forward")) {
-            x = RETURN_FORWARD;
-        } else {
+        VariadicOpPtr y;
+        if (!operatorTail(y)) {
             restore(p);
-            x = RETURN_VALUE;
+            break;
         }
-        return true;
+        y->exprs->insert(x);
+        x = y.ptr();
     }
+    return true;
+}
 
-    static bool returnExprList(ReturnKind &rkind, ExprListPtr &exprs) {
-        if (!returnKind(rkind)) return false;
-        if (!optExpressionList(exprs)) return false;
-        return true;
-    }
+//
+// not, and, or
+//
 
-    static bool returnExpr(ReturnKind &rkind, ExprPtr &expr) {
-        if (!returnKind(rkind)) return false;
-        if (!expression(expr)) return false;
-        return true;
+static bool notExpr(ExprPtr &x) {
+    Location location = currentLocation();
+    unsigned p = save();
+    if (!keyword("not")) {
+        restore(p);
+        return operatorExpr(x);
     }
+    ExprPtr y;
+    if (!operatorExpr(y))
+        return false;
+    x = new VariadicOp(NOT, new ExprList(y));
+    x->location = location;
+    return true;
+}
 
-    //
-    // lambda
-    //
-
-    static bool block(StatementPtr &x);
-
-    static bool arguments(vector<FormalArgPtr> &args, bool &hasVarArg, bool &hasAsConversion);
+static bool andExprTail(AndPtr &x) {
+    Location location = currentLocation();
+    if (!keyword("and"))
+        return false;
+    ExprPtr y;
+    if (!notExpr(y))
+        return false;
+    x = new And(nullptr, y);
+    x->location = location;
+    return true;
+}
 
-    static bool lambdaArgs(vector<FormalArgPtr> &formalArgs,
-                           bool &hasVarArg, bool &hasAsConversion) {
+static bool andExpr(ExprPtr &x) {
+    if (!notExpr(x))
+        return false;
+    while (true) {
         unsigned p = save();
-        IdentifierPtr name;
-        if (identifier(name)) {
-            formalArgs.clear();
-            FormalArgPtr arg = new FormalArg(name, nullptr, TEMPNESS_DONTCARE);
-            arg->location = name->location;
-            formalArgs.push_back(arg);
-            return true;
+        AndPtr y;
+        if (!andExprTail(y)) {
+            restore(p);
+            break;
         }
-        restore(p);
-        if (arguments(formalArgs, hasVarArg, hasAsConversion)) return true;
-        restore(p);
-        return true;
+        y->expr1 = x;
+        x = y.ptr();
     }
+    return true;
+}
 
-    static bool lambdaExprBody(StatementPtr &x) {
-        Location location = currentLocation();
-        ReturnKind rkind;
-        ExprPtr expr;
-        if (!returnExpr(rkind, expr)) return false;
-        x = new Return(rkind, new ExprList(expr));
-        x->location = location;
-        return true;
-    }
+static bool orExprTail(OrPtr &x) {
+    Location location = currentLocation();
+    if (!keyword("or"))
+        return false;
+    ExprPtr y;
+    if (!andExpr(y))
+        return false;
+    x = new Or(nullptr, y);
+    x->location = location;
+    return true;
+}
 
-    static bool lambdaArrow(LambdaCapture &captureBy) {
+static bool orExpr(ExprPtr &x) {
+    if (!andExpr(x))
+        return false;
+    while (true) {
         unsigned p = save();
-        if (opsymbol("->")) {
-            captureBy = REF_CAPTURE;
-            return true;
-        } else if (restore(p), opsymbol("=>")) {
-            captureBy = VALUE_CAPTURE;
-            return true;
-        } else if (restore(p), opsymbol("~>")) {
-            captureBy = STATELESS;
-            return true;
+        OrPtr y;
+        if (!orExprTail(y)) {
+            restore(p);
+            break;
         }
-        return false;
+        y->expr1 = x;
+        x = y.ptr();
     }
+    return true;
+}
 
-    static bool lambdaBody(StatementPtr &x) {
-        unsigned p = save();
-        if (lambdaExprBody(x)) return true;
-        if (restore(p), block(x)) return true;
+//
+// ifExpr
+//
+
+static bool ifExpr(ExprPtr &x) {
+    Location location = currentLocation();
+    ExprPtr expr;
+    if (!keyword("if"))
         return false;
-    }
+    if (!symbol("("))
+        return false;
+    if (!expression(expr))
+        return false;
+    ExprListPtr exprs = new ExprList(expr);
+    if (!symbol(")"))
+        return false;
+    if (!expression(expr))
+        return false;
+    exprs->add(expr);
+    if (!keyword("else"))
+        return false;
+    if (!expression(expr))
+        return false;
+    exprs->add(expr);
+    x = new VariadicOp(IF_EXPR, exprs);
+    x->location = location;
+    return true;
+}
 
-    static bool lambda(ExprPtr &x) {
-        Location location = currentLocation();
-        vector<FormalArgPtr> formalArgs;
-        bool hasVarArg = false;
-        bool hasAsConversion = false;
-        LambdaCapture captureBy;
-        StatementPtr body;
-        if (!lambdaArgs(formalArgs, hasVarArg, hasAsConversion)) return false;
-        if (!lambdaArrow(captureBy)) return false;
-        if (!lambdaBody(body)) return false;
-        x = new Lambda(captureBy, formalArgs, hasVarArg, hasAsConversion, body);
-        x->location = location;
-        return true;
+//
+// returnKind, returnExprList, returnExpr
+//
+
+static bool returnKind(ReturnKind &x) {
+    unsigned p = save();
+    if (keyword("ref")) {
+        x = RETURN_REF;
+    } else if (restore(p), keyword("forward")) {
+        x = RETURN_FORWARD;
+    } else {
+        restore(p);
+        x = RETURN_VALUE;
     }
+    return true;
+}
 
-    //
-    // unpack
-    //
+static bool returnExprList(ReturnKind &rkind, ExprListPtr &exprs) {
+    if (!returnKind(rkind))
+        return false;
+    if (!optExpressionList(exprs))
+        return false;
+    return true;
+}
 
-    static bool unpack(ExprPtr &x) {
-        Location location = currentLocation();
-        if (!ellipsis()) return false;
-        ExprPtr y;
-        if (!expression(y)) return false;
-        x = new Unpack(y);
-        x->location = location;
-        return true;
-    }
+static bool returnExpr(ReturnKind &rkind, ExprPtr &expr) {
+    if (!returnKind(rkind))
+        return false;
+    if (!expression(expr))
+        return false;
+    return true;
+}
+
+//
+// lambda
+//
 
-    //
-    // pairExpr
-    //
+static bool block(StatementPtr &x);
 
-    static bool pairExpr(ExprPtr &x) {
-        Location location = currentLocation();
-        IdentifierPtr y;
-        if (!identifier(y)) return false;
-        if (!symbol(":")) return false;
-        ExprPtr z;
-        if (!expression(z)) return false;
-        ExprPtr ident = new StringLiteral(y);
-        ident->location = location;
-        ExprListPtr args = new ExprList();
-        args->add(ident);
-        args->add(z);
-        x = new Tuple(args);
-        x->location = location;
+static bool arguments(vector<FormalArgPtr> &args, bool &hasVarArg,
+                      bool &hasAsConversion);
+
+static bool lambdaArgs(vector<FormalArgPtr> &formalArgs, bool &hasVarArg,
+                       bool &hasAsConversion) {
+    unsigned p = save();
+    IdentifierPtr name;
+    if (identifier(name)) {
+        formalArgs.clear();
+        FormalArgPtr arg = new FormalArg(name, nullptr, TEMPNESS_DONTCARE);
+        arg->location = name->location;
+        formalArgs.push_back(arg);
         return true;
     }
+    restore(p);
+    if (arguments(formalArgs, hasVarArg, hasAsConversion))
+        return true;
+    restore(p);
+    return true;
+}
 
-    //
-    // expression
-    //
-
-    static bool expression(ExprPtr &x, bool) {
-        Location startLocation = currentLocation();
-        unsigned p = save();
-        if (restore(p), lambda(x)) goto success;
-        if (restore(p), pairExpr(x)) goto success;
-        if (restore(p), orExpr(x)) goto success;
-        if (restore(p), ifExpr(x)) goto success;
-        if (restore(p), unpack(x)) goto success;
+static bool lambdaExprBody(StatementPtr &x) {
+    Location location = currentLocation();
+    ReturnKind rkind;
+    ExprPtr expr;
+    if (!returnExpr(rkind, expr))
         return false;
+    x = new Return(rkind, new ExprList(expr));
+    x->location = location;
+    return true;
+}
 
-    success:
-        x->startLocation = startLocation;
-        x->endLocation = currentLocation();
+static bool lambdaArrow(LambdaCapture &captureBy) {
+    unsigned p = save();
+    if (opsymbol("->")) {
+        captureBy = REF_CAPTURE;
+        return true;
+    } else if (restore(p), opsymbol("=>")) {
+        captureBy = VALUE_CAPTURE;
+        return true;
+    } else if (restore(p), opsymbol("~>")) {
+        captureBy = STATELESS;
         return true;
     }
+    return false;
+}
 
-    //
-    // pattern
-    //
-
-    static bool dottedNameRef(ExprPtr &x) {
-        if (!nameRef(x)) return false;
-        while (true) {
-            unsigned p = save();
-            ExprPtr y;
-            if (!fieldRefSuffix(y)) {
-                restore(p);
-                break;
-            }
-            setSuffixBase(y.ptr(), x);
-            x = y;
-        }
+static bool lambdaBody(StatementPtr &x) {
+    unsigned p = save();
+    if (lambdaExprBody(x))
         return true;
-    }
+    if (restore(p), block(x))
+        return true;
+    return false;
+}
 
-    static bool atomicPattern(ExprPtr &x) {
-        unsigned p = save();
-        if (dottedNameRef(x)) return true;
-        if (restore(p), intLiteral("+", x)) return true;
+static bool lambda(ExprPtr &x) {
+    Location location = currentLocation();
+    vector<FormalArgPtr> formalArgs;
+    bool hasVarArg = false;
+    bool hasAsConversion = false;
+    LambdaCapture captureBy;
+    StatementPtr body;
+    if (!lambdaArgs(formalArgs, hasVarArg, hasAsConversion))
         return false;
-    }
+    if (!lambdaArrow(captureBy))
+        return false;
+    if (!lambdaBody(body))
+        return false;
+    x = new Lambda(captureBy, formalArgs, hasVarArg, hasAsConversion, body);
+    x->location = location;
+    return true;
+}
 
-    static bool patternSuffix(IndexingPtr &x) {
-        Location location = currentLocation();
-        if (!symbol("[")) return false;
-        ExprListPtr args;
-        if (!optExpressionList(args)) return false;
-        if (!symbol("]")) return false;
-        x = new Indexing(nullptr, args);
-        x->location = location;
-        return true;
-    }
+//
+// unpack
+//
 
-    static bool pattern(ExprPtr &x) {
-        Location start = currentLocation();
-        if (!atomicPattern(x)) return false;
-        unsigned p = save();
-        IndexingPtr y;
-        if (!patternSuffix(y)) {
-            restore(p);
-            x->startLocation = start;
-            x->endLocation = currentLocation();
-            return true;
-        }
-        y->expr = x;
-        x = y.ptr();
-        x->startLocation = start;
-        x->endLocation = currentLocation();
-        return true;
-    }
+static bool unpack(ExprPtr &x) {
+    Location location = currentLocation();
+    if (!ellipsis())
+        return false;
+    ExprPtr y;
+    if (!expression(y))
+        return false;
+    x = new Unpack(y);
+    x->location = location;
+    return true;
+}
 
-    //
-    // typeSpec, optTypeSpec, exprTypeSpec, optExprTypeSpec
-    //
+//
+// pairExpr
+//
 
-    static bool typeSpec(ExprPtr &x) {
-        if (!symbol(":")) return false;
-        return pattern(x);
-    }
+static bool pairExpr(ExprPtr &x) {
+    Location location = currentLocation();
+    IdentifierPtr y;
+    if (!identifier(y))
+        return false;
+    if (!symbol(":"))
+        return false;
+    ExprPtr z;
+    if (!expression(z))
+        return false;
+    ExprPtr ident = new StringLiteral(y);
+    ident->location = location;
+    ExprListPtr args = new ExprList();
+    args->add(ident);
+    args->add(z);
+    x = new Tuple(args);
+    x->location = location;
+    return true;
+}
 
-    static bool optTypeSpec(ExprPtr &x) {
-        unsigned p = save();
-        if (!typeSpec(x)) {
-            restore(p);
-            x = nullptr;
-        }
-        return true;
-    }
+//
+// expression
+//
+
+static bool expression(ExprPtr &x, bool) {
+    Location startLocation = currentLocation();
+    unsigned p = save();
+    if (restore(p), lambda(x))
+        goto success;
+    if (restore(p), pairExpr(x))
+        goto success;
+    if (restore(p), orExpr(x))
+        goto success;
+    if (restore(p), ifExpr(x))
+        goto success;
+    if (restore(p), unpack(x))
+        goto success;
+    return false;
+
+success:
+    x->startLocation = startLocation;
+    x->endLocation = currentLocation();
+    return true;
+}
 
-    static bool exprTypeSpec(ExprPtr &x) {
-        if (!symbol(":")) return false;
-        return expression(x);
-    }
+//
+// pattern
+//
 
-    static bool optExprTypeSpec(ExprPtr &x) {
+static bool dottedNameRef(ExprPtr &x) {
+    if (!nameRef(x))
+        return false;
+    while (true) {
         unsigned p = save();
-        if (!exprTypeSpec(x)) {
+        ExprPtr y;
+        if (!fieldRefSuffix(y)) {
             restore(p);
-            x = nullptr;
+            break;
         }
-        return true;
+        setSuffixBase(y.ptr(), x);
+        x = y;
     }
+    return true;
+}
 
-    //
-    // statements
-    //
-
-    static bool statement(StatementPtr &x, bool = false);
-
-    static bool labelDef(StatementPtr &x) {
-        Location location = currentLocation();
-        IdentifierPtr y;
-        if (!identifier(y)) return false;
-        if (!symbol(":")) return false;
-        x = new Label(y);
-        x->location = location;
+static bool atomicPattern(ExprPtr &x) {
+    unsigned p = save();
+    if (dottedNameRef(x))
         return true;
-    }
-
-    static bool bindingKind(BindingKind &bindingKind) {
-        unsigned p = save();
-        if (keyword("var"))
-            bindingKind = VAR;
-        else if (restore(p), keyword("ref"))
-            bindingKind = REF;
-        else if (restore(p), keyword("alias"))
-            bindingKind = ALIAS;
-        else if (restore(p), keyword("forward"))
-            bindingKind = FORWARD;
-        else
-            return false;
+    if (restore(p), intLiteral("+", x))
         return true;
-    }
-
-    static bool optPatternVarsWithCond(vector<PatternVar> &x, ExprPtr &y);
+    return false;
+}
 
-    static bool bindingsBody(vector<FormalArgPtr> &x, bool &hasVarArg);
+static bool patternSuffix(IndexingPtr &x) {
+    Location location = currentLocation();
+    if (!symbol("["))
+        return false;
+    ExprListPtr args;
+    if (!optExpressionList(args))
+        return false;
+    if (!symbol("]"))
+        return false;
+    x = new Indexing(nullptr, args);
+    x->location = location;
+    return true;
+}
 
-    static bool localBinding(StatementPtr &x) {
-        Location location = currentLocation();
-        BindingKind bk;
-        if (!bindingKind(bk)) return false;
-        vector<PatternVar> patternVars;
-        ExprPtr predicate;
-        if (!optPatternVarsWithCond(patternVars, predicate)) return false;
-        vector<FormalArgPtr> args;
-        bool hasVarArg = false;
-        if (!bindingsBody(args, hasVarArg)) return false;
-        unsigned p = save();
-        if (!symbol(",")) restore(p);
-        if (!opsymbol("=")) return false;
-        ExprListPtr z;
-        if (!expressionList(z)) return false;
-        if (!symbol(";")) return false;
-        vector<ObjectPtr> patternTypes;
-        x = new Binding(bk, patternVars, patternTypes, predicate, args, z, hasVarArg);
-        x->location = location;
+static bool pattern(ExprPtr &x) {
+    Location start = currentLocation();
+    if (!atomicPattern(x))
+        return false;
+    unsigned p = save();
+    IndexingPtr y;
+    if (!patternSuffix(y)) {
+        restore(p);
+        x->startLocation = start;
+        x->endLocation = currentLocation();
         return true;
     }
+    y->expr = x;
+    x = y.ptr();
+    x->startLocation = start;
+    x->endLocation = currentLocation();
+    return true;
+}
 
-    static bool blockItem(StatementPtr &x) {
-        unsigned p = save();
-        if (labelDef(x)) return true;
-        if (restore(p), localBinding(x)) return true;
-        if (restore(p), statement(x)) return true;
+//
+// typeSpec, optTypeSpec, exprTypeSpec, optExprTypeSpec
+//
+
+static bool typeSpec(ExprPtr &x) {
+    if (!symbol(":"))
         return false;
-    }
+    return pattern(x);
+}
 
-    static bool blockItems(vector<StatementPtr> &stmts, bool) {
-        while (true) {
-            unsigned p = save();
-            StatementPtr z;
-            if (!blockItem(z)) {
-                restore(p);
-                break;
-            }
-            stmts.push_back(z);
-        }
-        return true;
+static bool optTypeSpec(ExprPtr &x) {
+    unsigned p = save();
+    if (!typeSpec(x)) {
+        restore(p);
+        x = nullptr;
     }
+    return true;
+}
 
-    static bool statementExprStatement(StatementPtr &stmt);
-
-    static bool statementExpression(vector<StatementPtr> &stmts, ExprPtr &expr) {
-        ExprPtr tailExpr;
-        StatementPtr stmt;
-        while (true) {
-            unsigned p = save();
-            if (statementExprStatement(stmt)) {
-                stmts.push_back(stmt);
-            } else if (restore(p), expression(tailExpr)) {
-                unsigned q = save();
-                if (symbol(";")) {
-                    stmts.push_back(new ExprStatement(tailExpr));
-                } else {
-                    restore(q);
-                    expr = tailExpr;
-                    return true;
-                }
-            } else {
-                return false;
-            }
-        }
-    }
+static bool exprTypeSpec(ExprPtr &x) {
+    if (!symbol(":"))
+        return false;
+    return expression(x);
+}
 
-    static bool block(StatementPtr &x) {
-        Location location = currentLocation();
-        if (!symbol("{")) return false;
-        BlockPtr y = new Block();
-        if (!blockItems(y->statements, false)) return false;
-        if (!symbol("}")) return false;
-        x = y.ptr();
-        x->location = location;
-        return true;
+static bool optExprTypeSpec(ExprPtr &x) {
+    unsigned p = save();
+    if (!exprTypeSpec(x)) {
+        restore(p);
+        x = nullptr;
     }
+    return true;
+}
 
-    static bool assignment(StatementPtr &x) {
-        Location location = currentLocation();
-        ExprListPtr y, z;
-        if (!expressionList(y)) return false;
-        if (!opsymbol("=")) return false;
-        if (!expressionList(z)) return false;
-        if (!symbol(";")) return false;
-        x = new Assignment(y, z);
-        x->location = location;
-        return true;
-    }
+//
+// statements
+//
 
-    static bool initAssignment(StatementPtr &x) {
-        Location location = currentLocation();
-        ExprListPtr y, z;
-        if (!expressionList(y)) return false;
-        if (!opsymbol("<--")) return false;
-        if (!expressionList(z)) return false;
-        if (!symbol(";")) return false;
-        x = new InitAssignment(y, z);
-        x->location = location;
-        return true;
-    }
+static bool statement(StatementPtr &x, bool = false);
 
-    static bool prefixUpdate(StatementPtr &x) {
-        Location location = currentLocation();
-        ExprPtr z;
-        llvm::StringRef op;
-        if (!uopstring(op)) return false;
-        if (!expression(z)) return false;
-        if (!symbol(";")) return false;
-        ExprListPtr exprs = new ExprList(new NameRef(Identifier::get(op, true)));
-        if (z->exprKind == VARIADIC_OP) {
-            auto y = dynamic_cast<VariadicOp *>(z.ptr());
-            exprs->add(y->exprs);
-        } else {
-            exprs->add(z);
-        }
-        x = new VariadicAssignment(PREFIX_OP, exprs);
-        x->location = location;
-        return true;
-    }
-
-    static bool updateAssignment(StatementPtr &x) {
-        Location location = currentLocation();
-        ExprPtr y, z;
-        if (!expression(y)) return false;
-        llvm::StringRef op;
-        if (!uopstring(op)) return false;
-        if (!expression(z)) return false;
-        if (!symbol(";")) return false;
-        ExprListPtr exprs = new ExprList(new NameRef(Identifier::get(op, true)));
-        exprs->add(y);
-        if (z->exprKind == VARIADIC_OP) {
-            auto variadic_op = dynamic_cast<VariadicOp *>(z.ptr());
-            exprs->add(variadic_op->exprs);
-        } else {
-            exprs->add(z);
-        }
-        x = new VariadicAssignment(INFIX_OP, exprs);
-        x->location = location;
-        return true;
-    }
-
-    static bool gotoStatement(StatementPtr &x) {
-        Location location = currentLocation();
-        IdentifierPtr y;
-        if (!keyword("goto")) return false;
-        if (!identifier(y)) return false;
-        if (!symbol(";")) return false;
-        x = new Goto(y);
-        x->location = location;
-        return true;
-    }
+static bool labelDef(StatementPtr &x) {
+    Location location = currentLocation();
+    IdentifierPtr y;
+    if (!identifier(y))
+        return false;
+    if (!symbol(":"))
+        return false;
+    x = new Label(y);
+    x->location = location;
+    return true;
+}
 
-    static bool returnStatement(StatementPtr &x) {
-        Location location = currentLocation();
-        if (!keyword("return")) return false;
-        ReturnKind rkind;
-        ExprListPtr exprs;
-        if (!returnExprList(rkind, exprs)) return false;
-        if (!symbol(";")) return false;
-        x = new Return(rkind, exprs);
-        x->location = location;
-        return true;
-    }
+static bool bindingKind(BindingKind &bindingKind) {
+    unsigned p = save();
+    if (keyword("var"))
+        bindingKind = VAR;
+    else if (restore(p), keyword("ref"))
+        bindingKind = REF;
+    else if (restore(p), keyword("alias"))
+        bindingKind = ALIAS;
+    else if (restore(p), keyword("forward"))
+        bindingKind = FORWARD;
+    else
+        return false;
+    return true;
+}
 
-    static bool optElse(StatementPtr &x) {
-        unsigned p = save();
-        if (!keyword("else")) {
-            restore(p);
-            return true;
-        }
-        return statement(x);
-    }
+static bool optPatternVarsWithCond(vector<PatternVar> &x, ExprPtr &y);
 
-    static bool ifStatement(StatementPtr &x) {
-        Location location = currentLocation();
-        vector<StatementPtr> condStmts;
-        ExprPtr condition;
-        StatementPtr thenPart, elsePart;
-        if (!keyword("if")) return false;
-        if (!symbol("(")) return false;
-        if (!statementExpression(condStmts, condition)) return false;
-        if (!symbol(")")) return false;
-        if (!statement(thenPart)) return false;
-        if (!optElse(elsePart)) return false;
-        x = new If(condStmts, condition, thenPart, elsePart);
-        x->location = location;
-        return true;
-    }
+static bool bindingsBody(vector<FormalArgPtr> &x, bool &hasVarArg);
 
-    static bool caseList(ExprListPtr &x) {
-        if (!keyword("case")) return false;
-        if (!symbol("(")) return false;
-        if (!expressionList(x)) return false;
-        if (!symbol(")")) return false;
-        return true;
-    }
+static bool localBinding(StatementPtr &x) {
+    Location location = currentLocation();
+    BindingKind bk;
+    if (!bindingKind(bk))
+        return false;
+    vector<PatternVar> patternVars;
+    ExprPtr predicate;
+    if (!optPatternVarsWithCond(patternVars, predicate))
+        return false;
+    vector<FormalArgPtr> args;
+    bool hasVarArg = false;
+    if (!bindingsBody(args, hasVarArg))
+        return false;
+    unsigned p = save();
+    if (!symbol(","))
+        restore(p);
+    if (!opsymbol("="))
+        return false;
+    ExprListPtr z;
+    if (!expressionList(z))
+        return false;
+    if (!symbol(";"))
+        return false;
+    vector<ObjectPtr> patternTypes;
+    x = new Binding(bk, patternVars, patternTypes, predicate, args, z,
+                    hasVarArg);
+    x->location = location;
+    return true;
+}
 
-    static bool caseBlock(CaseBlockPtr &x) {
-        Location location = currentLocation();
-        ExprListPtr caseLabels;
-        StatementPtr body;
-        if (!caseList(caseLabels)) return false;
-        if (!statement(body)) return false;
-        x = new CaseBlock(caseLabels, body);
-        x->location = location;
+static bool blockItem(StatementPtr &x) {
+    unsigned p = save();
+    if (labelDef(x))
         return true;
-    }
-
-    static bool caseBlockList(vector<CaseBlockPtr> &x) {
-        CaseBlockPtr a;
-        if (!caseBlock(a)) return false;
-        x.clear();
-        while (true) {
-            x.push_back(a);
-            unsigned p = save();
-            if (!caseBlock(a)) {
-                restore(p);
-                break;
-            }
-        }
+    if (restore(p), localBinding(x))
         return true;
-    }
-
-    static bool switchStatement(StatementPtr &x) {
-        Location location = currentLocation();
-        vector<StatementPtr> exprStmts;
-        ExprPtr expr;
-        if (!keyword("switch")) return false;
-        if (!symbol("(")) return false;
-        if (!statementExpression(exprStmts, expr)) return false;
-        if (!symbol(")")) return false;
-        vector<CaseBlockPtr> caseBlocks;
-        if (!caseBlockList(caseBlocks)) return false;
-        StatementPtr defaultCase;
-        if (!optElse(defaultCase)) return false;
-        x = new Switch(exprStmts, expr, caseBlocks, defaultCase);
-        x->location = location;
+    if (restore(p), statement(x))
         return true;
-    }
+    return false;
+}
 
-    static bool exprStatement(StatementPtr &x) {
-        Location location = currentLocation();
-        ExprPtr y;
-        if (!expression(y)) return false;
-        if (!symbol(";")) return false;
-        x = new ExprStatement(y);
-        x->location = location;
-        return true;
-    }
-
-    static bool whileStatement(StatementPtr &x) {
-        Location location = currentLocation();
-        vector<StatementPtr> condStmts;
-        ExprPtr cond;
-        StatementPtr body;
-        if (!keyword("while")) return false;
-        if (!symbol("(")) return false;
-        if (!statementExpression(condStmts, cond)) return false;
-        if (!symbol(")")) return false;
-        if (!statement(body)) return false;
-        x = new While(condStmts, cond, body);
-        x->location = location;
-        return true;
-    }
-
-    static bool breakStatement(StatementPtr &x) {
-        Location location = currentLocation();
-        if (!keyword("break")) return false;
-        if (!symbol(";")) return false;
-        x = new Break();
-        x->location = location;
-        return true;
-    }
-
-    static bool continueStatement(StatementPtr &x) {
-        Location location = currentLocation();
-        if (!keyword("continue")) return false;
-        if (!symbol(";")) return false;
-        x = new Continue();
-        x->location = location;
-        return true;
-    }
-
-    static bool forStatement(StatementPtr &x) {
-        Location location = currentLocation();
-        vector<IdentifierPtr> a;
-        ExprPtr b;
-        StatementPtr c;
-        if (!keyword("for")) return false;
-        if (!symbol("(")) return false;
-        if (!identifierList(a)) return false;
-        if (!keyword("in")) return false;
-        if (!expression(b)) return false;
-        if (!symbol(")")) return false;
-        if (!statement(c)) return false;
-        x = new For(a, b, c);
-        x->location = location;
-        return true;
-    }
-
-    static bool catchBlock(CatchPtr &x) {
-        Location location = currentLocation();
-        if (!keyword("catch")) return false;
-        if (!symbol("(")) return false;
-        IdentifierPtr evar;
-        if (!identifier(evar)) return false;
-        ExprPtr etype;
-        if (!optExprTypeSpec(etype)) return false;
-        IdentifierPtr contextVar;
+static bool blockItems(vector<StatementPtr> &stmts, bool) {
+    while (true) {
         unsigned p = save();
-        if (keyword("in")) {
-            if (!identifier(contextVar)) return false;
-        } else {
+        StatementPtr z;
+        if (!blockItem(z)) {
             restore(p);
+            break;
         }
-        if (!symbol(")")) return false;
-        StatementPtr body;
-        if (!block(body)) return false;
-        x = new Catch(evar, etype, contextVar, body);
-        x->location = location;
-        return true;
-    }
-
-    static bool catchBlockList(vector<CatchPtr> &x) {
-        CatchPtr a;
-        if (!catchBlock(a)) return false;
-        x.clear();
-        while (true) {
-            x.push_back(a);
-            unsigned p = save();
-            if (!catchBlock(a)) {
-                restore(p);
-                break;
-            }
-        }
-        return true;
+        stmts.push_back(z);
     }
+    return true;
+}
 
-    static bool tryStatement(StatementPtr &x) {
-        Location location = currentLocation();
-        StatementPtr a;
-        if (!keyword("try")) return false;
-        if (!block(a)) return false;
-        vector<CatchPtr> b;
-        if (!catchBlockList(b)) return false;
-        x = new Try(a, b);
-        x->location = location;
-        return true;
-    }
+static bool statementExprStatement(StatementPtr &stmt);
 
-    static bool throwStatement(StatementPtr &x) {
-        Location location = currentLocation();
-        ExprPtr a;
-        ExprPtr context;
-        if (!keyword("throw")) return false;
+static bool statementExpression(vector<StatementPtr> &stmts, ExprPtr &expr) {
+    ExprPtr tailExpr;
+    StatementPtr stmt;
+    while (true) {
         unsigned p = save();
-        if (!symbol(";")) {
-            restore(p);
-            if (!optExpression(a)) return false;
+        if (statementExprStatement(stmt)) {
+            stmts.push_back(stmt);
+        } else if (restore(p), expression(tailExpr)) {
             unsigned q = save();
-            if (keyword("in")) {
-                if (!optExpression(context)) return false;
+            if (symbol(";")) {
+                stmts.push_back(new ExprStatement(tailExpr));
             } else {
                 restore(q);
+                expr = tailExpr;
+                return true;
             }
         } else {
-            restore(p);
+            return false;
         }
-        if (!symbol(";")) return false;
-        x = new Throw(a, context);
-        x->location = location;
-        return true;
     }
+}
 
-    static bool staticFor(StatementPtr &x) {
-        Location location = currentLocation();
-        if (!ellipsis()) return false;
-        if (!keyword("for")) return false;
-        if (!symbol("(")) return false;
-        IdentifierPtr a;
-        if (!identifier(a)) return false;
-        if (!keyword("in")) return false;
-        ExprListPtr b;
-        if (!expressionList(b)) return false;
-        if (!symbol(")")) return false;
-        StatementPtr c;
-        if (!statement(c)) return false;
-        x = new StaticFor(a, b, c);
-        x->location = location;
-        return true;
-    }
+static bool block(StatementPtr &x) {
+    Location location = currentLocation();
+    if (!symbol("{"))
+        return false;
+    BlockPtr y = new Block();
+    if (!blockItems(y->statements, false))
+        return false;
+    if (!symbol("}"))
+        return false;
+    x = y.ptr();
+    x->location = location;
+    return true;
+}
 
-    static bool finallyStatement(StatementPtr &x) {
-        Location location = currentLocation();
+static bool assignment(StatementPtr &x) {
+    Location location = currentLocation();
+    ExprListPtr y, z;
+    if (!expressionList(y))
+        return false;
+    if (!opsymbol("="))
+        return false;
+    if (!expressionList(z))
+        return false;
+    if (!symbol(";"))
+        return false;
+    x = new Assignment(y, z);
+    x->location = location;
+    return true;
+}
 
-        if (!keyword("finally")) return false;
-        StatementPtr body;
-        if (!statement(body)) return false;
-        x = new Finally(body);
-        x->location = location;
-        return true;
-    }
+static bool initAssignment(StatementPtr &x) {
+    Location location = currentLocation();
+    ExprListPtr y, z;
+    if (!expressionList(y))
+        return false;
+    if (!opsymbol("<--"))
+        return false;
+    if (!expressionList(z))
+        return false;
+    if (!symbol(";"))
+        return false;
+    x = new InitAssignment(y, z);
+    x->location = location;
+    return true;
+}
 
-    static bool onerrorStatement(StatementPtr &x) {
-        Location location = currentLocation();
+static bool prefixUpdate(StatementPtr &x) {
+    Location location = currentLocation();
+    ExprPtr z;
+    llvm::StringRef op;
+    if (!uopstring(op))
+        return false;
+    if (!expression(z))
+        return false;
+    if (!symbol(";"))
+        return false;
+    ExprListPtr exprs = new ExprList(new NameRef(Identifier::get(op, true)));
+    if (z->exprKind == VARIADIC_OP) {
+        auto y = dynamic_cast<VariadicOp *>(z.ptr());
+        exprs->add(y->exprs);
+    } else {
+        exprs->add(z);
+    }
+    x = new VariadicAssignment(PREFIX_OP, exprs);
+    x->location = location;
+    return true;
+}
 
-        if (!keyword("onerror")) return false;
-        StatementPtr body;
-        if (!statement(body)) return false;
-        x = new OnError(body);
-        x->location = location;
-        return true;
-    }
+static bool updateAssignment(StatementPtr &x) {
+    Location location = currentLocation();
+    ExprPtr y, z;
+    if (!expression(y))
+        return false;
+    llvm::StringRef op;
+    if (!uopstring(op))
+        return false;
+    if (!expression(z))
+        return false;
+    if (!symbol(";"))
+        return false;
+    ExprListPtr exprs = new ExprList(new NameRef(Identifier::get(op, true)));
+    exprs->add(y);
+    if (z->exprKind == VARIADIC_OP) {
+        auto variadic_op = dynamic_cast<VariadicOp *>(z.ptr());
+        exprs->add(variadic_op->exprs);
+    } else {
+        exprs->add(z);
+    }
+    x = new VariadicAssignment(INFIX_OP, exprs);
+    x->location = location;
+    return true;
+}
+
+static bool gotoStatement(StatementPtr &x) {
+    Location location = currentLocation();
+    IdentifierPtr y;
+    if (!keyword("goto"))
+        return false;
+    if (!identifier(y))
+        return false;
+    if (!symbol(";"))
+        return false;
+    x = new Goto(y);
+    x->location = location;
+    return true;
+}
 
-    static bool evalStatement(StatementPtr &x) {
-        Location location = currentLocation();
+static bool returnStatement(StatementPtr &x) {
+    Location location = currentLocation();
+    if (!keyword("return"))
+        return false;
+    ReturnKind rkind;
+    ExprListPtr exprs;
+    if (!returnExprList(rkind, exprs))
+        return false;
+    if (!symbol(";"))
+        return false;
+    x = new Return(rkind, exprs);
+    x->location = location;
+    return true;
+}
 
-        if (!keyword("eval")) return false;
-        ExprListPtr args;
-        if (!expressionList(args)) return false;
-        if (!symbol(";")) return false;
-        x = new EvalStatement(args);
-        x->location = location;
+static bool optElse(StatementPtr &x) {
+    unsigned p = save();
+    if (!keyword("else")) {
+        restore(p);
         return true;
     }
+    return statement(x);
+}
+
+static bool ifStatement(StatementPtr &x) {
+    Location location = currentLocation();
+    vector<StatementPtr> condStmts;
+    ExprPtr condition;
+    StatementPtr thenPart, elsePart;
+    if (!keyword("if"))
+        return false;
+    if (!symbol("("))
+        return false;
+    if (!statementExpression(condStmts, condition))
+        return false;
+    if (!symbol(")"))
+        return false;
+    if (!statement(thenPart))
+        return false;
+    if (!optElse(elsePart))
+        return false;
+    x = new If(condStmts, condition, thenPart, elsePart);
+    x->location = location;
+    return true;
+}
 
-    // parse staticassert top level or statement
-    static bool staticAssert(ExprPtr &cond, ExprListPtr &message, Location &location) {
-        location = currentLocation();
-        if (!keyword("staticassert")) return false;
-        if (!symbol("(")) return false;
-        if (!expression(cond)) return false;
+static bool caseList(ExprListPtr &x) {
+    if (!keyword("case"))
+        return false;
+    if (!symbol("("))
+        return false;
+    if (!expressionList(x))
+        return false;
+    if (!symbol(")"))
+        return false;
+    return true;
+}
 
-        message = new ExprList();
+static bool caseBlock(CaseBlockPtr &x) {
+    Location location = currentLocation();
+    ExprListPtr caseLabels;
+    StatementPtr body;
+    if (!caseList(caseLabels))
+        return false;
+    if (!statement(body))
+        return false;
+    x = new CaseBlock(caseLabels, body);
+    x->location = location;
+    return true;
+}
 
-        unsigned s = save();
-        while (symbol(",")) {
-            ExprPtr expr;
-            if (!expression(expr)) return false;
-            message->add(expr);
-            s = save();
+static bool caseBlockList(vector<CaseBlockPtr> &x) {
+    CaseBlockPtr a;
+    if (!caseBlock(a))
+        return false;
+    x.clear();
+    while (true) {
+        x.push_back(a);
+        unsigned p = save();
+        if (!caseBlock(a)) {
+            restore(p);
+            break;
         }
-        restore(s);
-
-        if (!symbol(")")) return false;
-        if (!symbol(";")) return false;
-        return true;
     }
+    return true;
+}
 
-    static bool staticAssertTopLevel(TopLevelItemPtr &x, Module *module) {
-        ExprPtr cond;
-        ExprListPtr message;
-        Location location;
-        if (!staticAssert(cond, message, location)) return false;
-        x = new StaticAssertTopLevel(module, cond, message);
-        x->location = location;
-        return true;
-    }
+static bool switchStatement(StatementPtr &x) {
+    Location location = currentLocation();
+    vector<StatementPtr> exprStmts;
+    ExprPtr expr;
+    if (!keyword("switch"))
+        return false;
+    if (!symbol("("))
+        return false;
+    if (!statementExpression(exprStmts, expr))
+        return false;
+    if (!symbol(")"))
+        return false;
+    vector<CaseBlockPtr> caseBlocks;
+    if (!caseBlockList(caseBlocks))
+        return false;
+    StatementPtr defaultCase;
+    if (!optElse(defaultCase))
+        return false;
+    x = new Switch(exprStmts, expr, caseBlocks, defaultCase);
+    x->location = location;
+    return true;
+}
 
-    static bool staticAssertStatement(StatementPtr &x) {
-        ExprPtr cond;
-        ExprListPtr message;
-        Location location;
-        if (!staticAssert(cond, message, location)) return false;
-        x = new StaticAssertStatement(cond, message);
-        x->location = location;
-        return true;
-    }
+static bool exprStatement(StatementPtr &x) {
+    Location location = currentLocation();
+    ExprPtr y;
+    if (!expression(y))
+        return false;
+    if (!symbol(";"))
+        return false;
+    x = new ExprStatement(y);
+    x->location = location;
+    return true;
+}
 
-    static bool statement(StatementPtr &x, bool) {
-        unsigned p = save();
-        if (block(x)) return true;
-        if (restore(p), assignment(x)) return true;
-        if (restore(p), initAssignment(x)) return true;
-        if (restore(p), updateAssignment(x)) return true;
-        if (restore(p), prefixUpdate(x)) return true;
-        if (restore(p), ifStatement(x)) return true;
-        if (restore(p), switchStatement(x)) return true;
-        if (restore(p), returnStatement(x)) return true;
-        if (restore(p), evalStatement(x)) return true;
-        if (restore(p), exprStatement(x)) return true;
-        if (restore(p), whileStatement(x)) return true;
-        if (restore(p), breakStatement(x)) return true;
-        if (restore(p), continueStatement(x)) return true;
-        if (restore(p), forStatement(x)) return true;
-        if (restore(p), staticFor(x)) return true;
-        if (restore(p), tryStatement(x)) return true;
-        if (restore(p), throwStatement(x)) return true;
-        if (restore(p), finallyStatement(x)) return true;
-        if (restore(p), onerrorStatement(x)) return true;
-        if (restore(p), staticAssertStatement(x)) return true;
-        if (restore(p), gotoStatement(x)) return true;
-
-        return false;
-    }
-
-    static bool statementExprStatement(StatementPtr &stmt) {
-        unsigned p = save();
-        if (localBinding(stmt)) return true;
-        if (restore(p), assignment(stmt)) return true;
-        if (restore(p), initAssignment(stmt)) return true;
-        if (restore(p), updateAssignment(stmt)) return true;
+static bool whileStatement(StatementPtr &x) {
+    Location location = currentLocation();
+    vector<StatementPtr> condStmts;
+    ExprPtr cond;
+    StatementPtr body;
+    if (!keyword("while"))
         return false;
-    }
+    if (!symbol("("))
+        return false;
+    if (!statementExpression(condStmts, cond))
+        return false;
+    if (!symbol(")"))
+        return false;
+    if (!statement(body))
+        return false;
+    x = new While(condStmts, cond, body);
+    x->location = location;
+    return true;
+}
 
-    //
-    // staticParams
-    //
+static bool breakStatement(StatementPtr &x) {
+    Location location = currentLocation();
+    if (!keyword("break"))
+        return false;
+    if (!symbol(";"))
+        return false;
+    x = new Break();
+    x->location = location;
+    return true;
+}
 
-    static bool staticVarParam(IdentifierPtr &varParam) {
-        if (!ellipsis()) return false;
-        if (!identifier(varParam)) return false;
-        return true;
+static bool continueStatement(StatementPtr &x) {
+    Location location = currentLocation();
+    if (!keyword("continue"))
+        return false;
+    if (!symbol(";"))
+        return false;
+    x = new Continue();
+    x->location = location;
+    return true;
+}
+
+static bool forStatement(StatementPtr &x) {
+    Location location = currentLocation();
+    vector<IdentifierPtr> a;
+    ExprPtr b;
+    StatementPtr c;
+    if (!keyword("for"))
+        return false;
+    if (!symbol("("))
+        return false;
+    if (!identifierList(a))
+        return false;
+    if (!keyword("in"))
+        return false;
+    if (!expression(b))
+        return false;
+    if (!symbol(")"))
+        return false;
+    if (!statement(c))
+        return false;
+    x = new For(a, b, c);
+    x->location = location;
+    return true;
+}
+
+static bool catchBlock(CatchPtr &x) {
+    Location location = currentLocation();
+    if (!keyword("catch"))
+        return false;
+    if (!symbol("("))
+        return false;
+    IdentifierPtr evar;
+    if (!identifier(evar))
+        return false;
+    ExprPtr etype;
+    if (!optExprTypeSpec(etype))
+        return false;
+    IdentifierPtr contextVar;
+    unsigned p = save();
+    if (keyword("in")) {
+        if (!identifier(contextVar))
+            return false;
+    } else {
+        restore(p);
     }
+    if (!symbol(")"))
+        return false;
+    StatementPtr body;
+    if (!block(body))
+        return false;
+    x = new Catch(evar, etype, contextVar, body);
+    x->location = location;
+    return true;
+}
 
-    static bool optStaticVarParam(IdentifierPtr &varParam) {
+static bool catchBlockList(vector<CatchPtr> &x) {
+    CatchPtr a;
+    if (!catchBlock(a))
+        return false;
+    x.clear();
+    while (true) {
+        x.push_back(a);
         unsigned p = save();
-        if (!staticVarParam(varParam)) {
+        if (!catchBlock(a)) {
             restore(p);
-            varParam = nullptr;
+            break;
         }
-        return true;
     }
+    return true;
+}
 
-    static bool trailingVarParam(IdentifierPtr &varParam) {
-        if (!symbol(",")) return false;
-        if (!staticVarParam(varParam)) return false;
-        return true;
-    }
+static bool tryStatement(StatementPtr &x) {
+    Location location = currentLocation();
+    StatementPtr a;
+    if (!keyword("try"))
+        return false;
+    if (!block(a))
+        return false;
+    vector<CatchPtr> b;
+    if (!catchBlockList(b))
+        return false;
+    x = new Try(a, b);
+    x->location = location;
+    return true;
+}
 
-    static bool optTrailingVarParam(IdentifierPtr &varParam) {
-        unsigned p = save();
-        if (!trailingVarParam(varParam)) {
-            restore(p);
-            varParam = nullptr;
+static bool throwStatement(StatementPtr &x) {
+    Location location = currentLocation();
+    ExprPtr a;
+    ExprPtr context;
+    if (!keyword("throw"))
+        return false;
+    unsigned p = save();
+    if (!symbol(";")) {
+        restore(p);
+        if (!optExpression(a))
+            return false;
+        unsigned q = save();
+        if (keyword("in")) {
+            if (!optExpression(context))
+                return false;
+        } else {
+            restore(q);
         }
-        return true;
+    } else {
+        restore(p);
     }
+    if (!symbol(";"))
+        return false;
+    x = new Throw(a, context);
+    x->location = location;
+    return true;
+}
 
-    static bool paramsAndVarParam(vector<IdentifierPtr> &params,
-                                  IdentifierPtr &varParam) {
-        if (!identifierListNoTail(params)) return false;
-        if (!optTrailingVarParam(varParam)) return false;
-        unsigned p = save();
-        if (!symbol(","))
-            restore(p);
-        return true;
+static bool staticFor(StatementPtr &x) {
+    Location location = currentLocation();
+    if (!ellipsis())
+        return false;
+    if (!keyword("for"))
+        return false;
+    if (!symbol("("))
+        return false;
+    IdentifierPtr a;
+    if (!identifier(a))
+        return false;
+    if (!keyword("in"))
+        return false;
+    ExprListPtr b;
+    if (!expressionList(b))
+        return false;
+    if (!symbol(")"))
+        return false;
+    StatementPtr c;
+    if (!statement(c))
+        return false;
+    x = new StaticFor(a, b, c);
+    x->location = location;
+    return true;
+}
+
+static bool finallyStatement(StatementPtr &x) {
+    Location location = currentLocation();
+
+    if (!keyword("finally"))
+        return false;
+    StatementPtr body;
+    if (!statement(body))
+        return false;
+    x = new Finally(body);
+    x->location = location;
+    return true;
+}
+
+static bool onerrorStatement(StatementPtr &x) {
+    Location location = currentLocation();
+
+    if (!keyword("onerror"))
+        return false;
+    StatementPtr body;
+    if (!statement(body))
+        return false;
+    x = new OnError(body);
+    x->location = location;
+    return true;
+}
+
+static bool evalStatement(StatementPtr &x) {
+    Location location = currentLocation();
+
+    if (!keyword("eval"))
+        return false;
+    ExprListPtr args;
+    if (!expressionList(args))
+        return false;
+    if (!symbol(";"))
+        return false;
+    x = new EvalStatement(args);
+    x->location = location;
+    return true;
+}
+
+// parse staticassert top level or statement
+static bool staticAssert(ExprPtr &cond, ExprListPtr &message,
+                         Location &location) {
+    location = currentLocation();
+    if (!keyword("staticassert"))
+        return false;
+    if (!symbol("("))
+        return false;
+    if (!expression(cond))
+        return false;
+
+    message = new ExprList();
+
+    unsigned s = save();
+    while (symbol(",")) {
+        ExprPtr expr;
+        if (!expression(expr))
+            return false;
+        message->add(expr);
+        s = save();
     }
+    restore(s);
 
-    static bool staticParamsInner(vector<IdentifierPtr> &params,
-                                  IdentifierPtr &varParam) {
-        unsigned p = save();
-        if (paramsAndVarParam(params, varParam)) return true;
+    if (!symbol(")"))
+        return false;
+    if (!symbol(";"))
+        return false;
+    return true;
+}
+
+static bool staticAssertTopLevel(TopLevelItemPtr &x, Module *module) {
+    ExprPtr cond;
+    ExprListPtr message;
+    Location location;
+    if (!staticAssert(cond, message, location))
+        return false;
+    x = new StaticAssertTopLevel(module, cond, message);
+    x->location = location;
+    return true;
+}
+
+static bool staticAssertStatement(StatementPtr &x) {
+    ExprPtr cond;
+    ExprListPtr message;
+    Location location;
+    if (!staticAssert(cond, message, location))
+        return false;
+    x = new StaticAssertStatement(cond, message);
+    x->location = location;
+    return true;
+}
+
+static bool statement(StatementPtr &x, bool) {
+    unsigned p = save();
+    if (block(x))
+        return true;
+    if (restore(p), assignment(x))
+        return true;
+    if (restore(p), initAssignment(x))
+        return true;
+    if (restore(p), updateAssignment(x))
+        return true;
+    if (restore(p), prefixUpdate(x))
+        return true;
+    if (restore(p), ifStatement(x))
+        return true;
+    if (restore(p), switchStatement(x))
+        return true;
+    if (restore(p), returnStatement(x))
+        return true;
+    if (restore(p), evalStatement(x))
+        return true;
+    if (restore(p), exprStatement(x))
+        return true;
+    if (restore(p), whileStatement(x))
+        return true;
+    if (restore(p), breakStatement(x))
+        return true;
+    if (restore(p), continueStatement(x))
+        return true;
+    if (restore(p), forStatement(x))
+        return true;
+    if (restore(p), staticFor(x))
+        return true;
+    if (restore(p), tryStatement(x))
+        return true;
+    if (restore(p), throwStatement(x))
+        return true;
+    if (restore(p), finallyStatement(x))
+        return true;
+    if (restore(p), onerrorStatement(x))
+        return true;
+    if (restore(p), staticAssertStatement(x))
+        return true;
+    if (restore(p), gotoStatement(x))
+        return true;
+
+    return false;
+}
+
+static bool statementExprStatement(StatementPtr &stmt) {
+    unsigned p = save();
+    if (localBinding(stmt))
+        return true;
+    if (restore(p), assignment(stmt))
+        return true;
+    if (restore(p), initAssignment(stmt))
+        return true;
+    if (restore(p), updateAssignment(stmt))
+        return true;
+    return false;
+}
+
+//
+// staticParams
+//
+
+static bool staticVarParam(IdentifierPtr &varParam) {
+    if (!ellipsis())
+        return false;
+    if (!identifier(varParam))
+        return false;
+    return true;
+}
+
+static bool optStaticVarParam(IdentifierPtr &varParam) {
+    unsigned p = save();
+    if (!staticVarParam(varParam)) {
         restore(p);
-        params.clear();
         varParam = nullptr;
-        return optStaticVarParam(varParam);
     }
+    return true;
+}
 
-    static bool staticParams(vector<IdentifierPtr> &params,
-                             IdentifierPtr &varParam) {
-        if (!symbol("[")) return false;
-        if (!staticParamsInner(params, varParam)) return false;
-        if (!symbol("]")) return false;
-        return true;
+static bool trailingVarParam(IdentifierPtr &varParam) {
+    if (!symbol(","))
+        return false;
+    if (!staticVarParam(varParam))
+        return false;
+    return true;
+}
+
+static bool optTrailingVarParam(IdentifierPtr &varParam) {
+    unsigned p = save();
+    if (!trailingVarParam(varParam)) {
+        restore(p);
+        varParam = nullptr;
     }
+    return true;
+}
 
-    static bool optStaticParams(vector<IdentifierPtr> &params,
-                                IdentifierPtr &varParam) {
-        unsigned p = save();
-        if (!staticParams(params, varParam)) {
-            restore(p);
-            params.clear();
-            varParam = nullptr;
-        }
+static bool paramsAndVarParam(vector<IdentifierPtr> &params,
+                              IdentifierPtr &varParam) {
+    if (!identifierListNoTail(params))
+        return false;
+    if (!optTrailingVarParam(varParam))
+        return false;
+    unsigned p = save();
+    if (!symbol(","))
+        restore(p);
+    return true;
+}
+
+static bool staticParamsInner(vector<IdentifierPtr> &params,
+                              IdentifierPtr &varParam) {
+    unsigned p = save();
+    if (paramsAndVarParam(params, varParam))
         return true;
+    restore(p);
+    params.clear();
+    varParam = nullptr;
+    return optStaticVarParam(varParam);
+}
+
+static bool staticParams(vector<IdentifierPtr> &params,
+                         IdentifierPtr &varParam) {
+    if (!symbol("["))
+        return false;
+    if (!staticParamsInner(params, varParam))
+        return false;
+    if (!symbol("]"))
+        return false;
+    return true;
+}
+
+static bool optStaticParams(vector<IdentifierPtr> &params,
+                            IdentifierPtr &varParam) {
+    unsigned p = save();
+    if (!staticParams(params, varParam)) {
+        restore(p);
+        params.clear();
+        varParam = nullptr;
     }
+    return true;
+}
 
-    //
-    // code
-    //
+//
+// code
+//
 
-    static bool varArgTypeSpec(ExprPtr &vargType) {
-        if (!symbol(":")) return false;
-        Location start = currentLocation();
-        if (!nameRef(vargType)) return false;
-        vargType->startLocation = start;
-        vargType->endLocation = currentLocation();
-        return true;
+static bool varArgTypeSpec(ExprPtr &vargType) {
+    if (!symbol(":"))
+        return false;
+    Location start = currentLocation();
+    if (!nameRef(vargType))
+        return false;
+    vargType->startLocation = start;
+    vargType->endLocation = currentLocation();
+    return true;
+}
+
+static bool optVarArgTypeSpec(ExprPtr &vargType) {
+    unsigned p = save();
+    if (!varArgTypeSpec(vargType)) {
+        restore(p);
+        vargType = nullptr;
     }
+    return true;
+}
 
-    static bool optVarArgTypeSpec(ExprPtr &vargType) {
-        unsigned p = save();
-        if (!varArgTypeSpec(vargType)) {
-            restore(p);
-            vargType = nullptr;
-        }
+static bool optArgTempness(ValueTempness &tempness) {
+    unsigned p = save();
+    if (keyword("rvalue")) {
+        tempness = TEMPNESS_RVALUE;
         return true;
     }
-
-    static bool optArgTempness(ValueTempness &tempness) {
-        unsigned p = save();
-        if (keyword("rvalue")) {
-            tempness = TEMPNESS_RVALUE;
-            return true;
-        }
-        restore(p);
-        if (keyword("ref")) {
-            tempness = TEMPNESS_LVALUE;
-            return true;
-        }
-        restore(p);
-        if (keyword("forward")) {
-            tempness = TEMPNESS_FORWARD;
-            return true;
-        }
-        restore(p);
-        tempness = TEMPNESS_DONTCARE;
+    restore(p);
+    if (keyword("ref")) {
+        tempness = TEMPNESS_LVALUE;
         return true;
     }
-
-    static bool valueFormalArg(FormalArgPtr &x, bool &hasVarArg, bool &hasAsConversion) {
-        Location location = currentLocation();
-        ValueTempness tempness;
-        if (!optArgTempness(tempness)) return false;
-        IdentifierPtr y;
-        ExprPtr z;
-        bool varArg = false;
-        unsigned p = save();
-        if (ellipsis()) {
-            if (hasVarArg)
-                return false;
-            else
-                hasVarArg = true;
-            varArg = true;
-        } else
-            restore(p);
-        if (!identifier(y)) return false;
-        if (varArg) {
-            if (!optVarArgTypeSpec(z)) return false;
-        } else {
-            if (!optTypeSpec(z)) return false;
-        }
-        p = save();
-        if (keyword("as")) {
-            if (varArg) return false;
-            ExprPtr w;
-            if (!pattern(w)) return false;
-            hasAsConversion = true;
-            x = new FormalArg(y, z, tempness, w);
-        } else {
-            restore(p);
-            x = new FormalArg(y, z, tempness, varArg);
-        }
-        x->location = location;
+    restore(p);
+    if (keyword("forward")) {
+        tempness = TEMPNESS_FORWARD;
         return true;
     }
+    restore(p);
+    tempness = TEMPNESS_DONTCARE;
+    return true;
+}
 
-    static FormalArgPtr makeStaticFormalArg(size_t index, const ExprPtr &expr, Location const &location) {
-        // desugar static args
-        llvm::SmallString<128> buf;
-        llvm::raw_svector_ostream sout(buf);
-        sout << "%arg" << index;
-        IdentifierPtr argName = Identifier::get(sout.str());
-
-        ExprPtr indexing = wrapIntoStatic(expr);
-        indexing->startLocation = location;
-        indexing->endLocation = currentLocation();
-
-        FormalArgPtr arg = new FormalArg(argName, indexing.ptr());
-        arg->location = location;
-        return arg;
+static bool valueFormalArg(FormalArgPtr &x, bool &hasVarArg,
+                           bool &hasAsConversion) {
+    Location location = currentLocation();
+    ValueTempness tempness;
+    if (!optArgTempness(tempness))
+        return false;
+    IdentifierPtr y;
+    ExprPtr z;
+    bool varArg = false;
+    unsigned p = save();
+    if (ellipsis()) {
+        if (hasVarArg)
+            return false;
+        else
+            hasVarArg = true;
+        varArg = true;
+    } else
+        restore(p);
+    if (!identifier(y))
+        return false;
+    if (varArg) {
+        if (!optVarArgTypeSpec(z))
+            return false;
+    } else {
+        if (!optTypeSpec(z))
+            return false;
+    }
+    p = save();
+    if (keyword("as")) {
+        if (varArg)
+            return false;
+        ExprPtr w;
+        if (!pattern(w))
+            return false;
+        hasAsConversion = true;
+        x = new FormalArg(y, z, tempness, w);
+    } else {
+        restore(p);
+        x = new FormalArg(y, z, tempness, varArg);
     }
+    x->location = location;
+    return true;
+}
 
-    static bool staticFormalArg(size_t index, FormalArgPtr &x) {
-        Location location = currentLocation();
-        ExprPtr expr;
-        if (!symbol("#")) return false;
-        if (!expression(expr)) return false;
+static FormalArgPtr makeStaticFormalArg(size_t index, const ExprPtr &expr,
+                                        Location const &location) {
+    // desugar static args
+    llvm::SmallString<128> buf;
+    llvm::raw_svector_ostream sout(buf);
+    sout << "%arg" << index;
+    IdentifierPtr argName = Identifier::get(sout.str());
+
+    ExprPtr indexing = wrapIntoStatic(expr);
+    indexing->startLocation = location;
+    indexing->endLocation = currentLocation();
+
+    FormalArgPtr arg = new FormalArg(argName, indexing.ptr());
+    arg->location = location;
+    return arg;
+}
 
-        if (expr->exprKind == UNPACK) {
-            error(expr, "#static variadic arguments are not yet supported");
-        }
+static bool staticFormalArg(size_t index, FormalArgPtr &x) {
+    Location location = currentLocation();
+    ExprPtr expr;
+    if (!symbol("#"))
+        return false;
+    if (!expression(expr))
+        return false;
 
-        x = makeStaticFormalArg(index, expr, location);
-        return true;
+    if (expr->exprKind == UNPACK) {
+        error(expr, "#static variadic arguments are not yet supported");
     }
 
-    static bool stringFormalArg(size_t index, FormalArgPtr &x) {
-        Location location = currentLocation();
-        ExprPtr expr;
-        if (!stringLiteral(expr)) return false;
-        x = makeStaticFormalArg(index, expr, location);
-        return true;
-    }
+    x = makeStaticFormalArg(index, expr, location);
+    return true;
+}
 
-    static bool formalArg(size_t index, FormalArgPtr &x, bool &hasVarArg, bool &hasAsConversion) {
-        unsigned p = save();
-        if (valueFormalArg(x, hasVarArg, hasAsConversion)) return true;
-        if (restore(p), staticFormalArg(index, x)) return true;
-        if (restore(p), stringFormalArg(index, x)) return true;
+static bool stringFormalArg(size_t index, FormalArgPtr &x) {
+    Location location = currentLocation();
+    ExprPtr expr;
+    if (!stringLiteral(expr))
         return false;
-    }
+    x = makeStaticFormalArg(index, expr, location);
+    return true;
+}
 
-    static bool formalArgs(vector<FormalArgPtr> &x, bool &hasVarArg, bool &hasAsConversion) {
-        FormalArgPtr y;
-        if (!formalArg(x.size(), y, hasVarArg, hasAsConversion)) return false;
-        x.clear();
-        while (true) {
-            x.push_back(y);
-            unsigned p = save();
-            if (!symbol(",") || !formalArg(x.size(), y, hasVarArg, hasAsConversion)) {
-                restore(p);
-                break;
-            }
-        }
+static bool formalArg(size_t index, FormalArgPtr &x, bool &hasVarArg,
+                      bool &hasAsConversion) {
+    unsigned p = save();
+    if (valueFormalArg(x, hasVarArg, hasAsConversion))
         return true;
-    }
-
-    static bool argumentsBody(vector<FormalArgPtr> &args, bool &hasVarArg, bool &hasAsConversion) {
-        unsigned p = save();
-        if (!formalArgs(args, hasVarArg, hasAsConversion)) {
-            restore(p);
-            args.clear();
-        }
+    if (restore(p), staticFormalArg(index, x))
         return true;
-    }
-
-    static bool arguments(vector<FormalArgPtr> &args, bool &hasVarArg, bool &hasAsConversion) {
-        if (!symbol("(")) return false;
-        if (!argumentsBody(args, hasVarArg, hasAsConversion)) return false;
-        if (!symbol(")")) return false;
+    if (restore(p), stringFormalArg(index, x))
         return true;
-    }
+    return false;
+}
 
-    static bool bindingArg(FormalArgPtr &x, bool &hasVarArg) {
-        Location location = currentLocation();
-        IdentifierPtr y;
-        ExprPtr z;
-        bool varArg = false;
+static bool formalArgs(vector<FormalArgPtr> &x, bool &hasVarArg,
+                       bool &hasAsConversion) {
+    FormalArgPtr y;
+    if (!formalArg(x.size(), y, hasVarArg, hasAsConversion))
+        return false;
+    x.clear();
+    while (true) {
+        x.push_back(y);
         unsigned p = save();
-        if (ellipsis()) {
-            if (hasVarArg)
-                return false;
-            else
-                hasVarArg = true;
-            varArg = true;
-        } else
+        if (!symbol(",") ||
+            !formalArg(x.size(), y, hasVarArg, hasAsConversion)) {
             restore(p);
-        if (!identifier(y)) return false;
-        if (varArg) {
-            if (!optVarArgTypeSpec(z)) return false;
-        } else {
-            if (!optTypeSpec(z)) return false;
+            break;
         }
-        x = new FormalArg(y, z);
-        x->location = location;
-        x->varArg = varArg;
-        return true;
     }
+    return true;
+}
 
-    static bool bindingsBody(vector<FormalArgPtr> &x, bool &hasVarArg) {
-        FormalArgPtr y;
-        if (!bindingArg(y, hasVarArg)) return false;
-        x.clear();
-        while (true) {
-            x.push_back(y);
-            unsigned p = save();
-            if (!symbol(",") || !bindingArg(y, hasVarArg)) {
-                restore(p);
-                break;
-            }
-        }
-        return true;
+static bool argumentsBody(vector<FormalArgPtr> &args, bool &hasVarArg,
+                          bool &hasAsConversion) {
+    unsigned p = save();
+    if (!formalArgs(args, hasVarArg, hasAsConversion)) {
+        restore(p);
+        args.clear();
     }
+    return true;
+}
 
-    static bool predicate(ExprPtr &x) {
-        if (!keyword("when")) return false;
-        return expression(x);
-    }
+static bool arguments(vector<FormalArgPtr> &args, bool &hasVarArg,
+                      bool &hasAsConversion) {
+    if (!symbol("("))
+        return false;
+    if (!argumentsBody(args, hasVarArg, hasAsConversion))
+        return false;
+    if (!symbol(")"))
+        return false;
+    return true;
+}
 
-    static bool optPredicate(ExprPtr &x) {
-        unsigned p = save();
-        if (!predicate(x)) {
-            restore(p);
-            x = nullptr;
-        }
-        return true;
+static bool bindingArg(FormalArgPtr &x, bool &hasVarArg) {
+    Location location = currentLocation();
+    IdentifierPtr y;
+    ExprPtr z;
+    bool varArg = false;
+    unsigned p = save();
+    if (ellipsis()) {
+        if (hasVarArg)
+            return false;
+        else
+            hasVarArg = true;
+        varArg = true;
+    } else
+        restore(p);
+    if (!identifier(y))
+        return false;
+    if (varArg) {
+        if (!optVarArgTypeSpec(z))
+            return false;
+    } else {
+        if (!optTypeSpec(z))
+            return false;
     }
+    x = new FormalArg(y, z);
+    x->location = location;
+    x->varArg = varArg;
+    return true;
+}
 
-    static bool patternVar(PatternVar &x) {
+static bool bindingsBody(vector<FormalArgPtr> &x, bool &hasVarArg) {
+    FormalArgPtr y;
+    if (!bindingArg(y, hasVarArg))
+        return false;
+    x.clear();
+    while (true) {
+        x.push_back(y);
         unsigned p = save();
-        x.isMulti = true;
-        if (!ellipsis()) {
+        if (!symbol(",") || !bindingArg(y, hasVarArg)) {
             restore(p);
-            x.isMulti = false;
-        }
-        if (!identifier(x.name)) return false;
-        return true;
-    }
-
-    static bool patternVarList(vector<PatternVar> &x) {
-        PatternVar y;
-        if (!patternVar(y)) return false;
-        x.clear();
-        while (true) {
-            x.push_back(y);
-            unsigned p = save();
-            if (!symbol(",") || !patternVar(y)) {
-                restore(p);
-                break;
-            }
+            break;
         }
-        return true;
     }
+    return true;
+}
 
-    static bool optPatternVarList(vector<PatternVar> &x) {
-        unsigned p = save();
-        if (!patternVarList(x)) {
-            restore(p);
-            x.clear();
-        }
-        return true;
-    }
+static bool predicate(ExprPtr &x) {
+    if (!keyword("when"))
+        return false;
+    return expression(x);
+}
 
-    static bool patternVarsWithCond(vector<PatternVar> &x, ExprPtr &y) {
-        if (!symbol("[")) return false;
-        if (!optPatternVarList(x)) return false;
-        if (!optPredicate(y) || !symbol("]")) {
-            x.clear();
-            y = nullptr;
-            return false;
-        }
-        return true;
+static bool optPredicate(ExprPtr &x) {
+    unsigned p = save();
+    if (!predicate(x)) {
+        restore(p);
+        x = nullptr;
     }
+    return true;
+}
 
-    static bool optPatternVarsWithCond(vector<PatternVar> &x, ExprPtr &y) {
-        unsigned p = save();
-        if (!patternVarsWithCond(x, y)) {
-            restore(p);
-            x.clear();
-            y = nullptr;
-        }
-        return true;
+static bool patternVar(PatternVar &x) {
+    unsigned p = save();
+    x.isMulti = true;
+    if (!ellipsis()) {
+        restore(p);
+        x.isMulti = false;
     }
+    if (!identifier(x.name))
+        return false;
+    return true;
+}
 
-    static void skipOptPatternVar() {
+static bool patternVarList(vector<PatternVar> &x) {
+    PatternVar y;
+    if (!patternVar(y))
+        return false;
+    x.clear();
+    while (true) {
+        x.push_back(y);
         unsigned p = save();
-        if (!symbol("[")) {
+        if (!symbol(",") || !patternVar(y)) {
             restore(p);
-        } else {
-            int bracket = 1;
-            while (bracket) {
-                unsigned i = save();
-                if (symbol("[")) {
-                    ++bracket;
-                    continue;
-                }
-                restore(i);
-                if (symbol("]"))
-                    --bracket;
-            }
+            break;
         }
     }
+    return true;
+}
 
-    static bool exprBody(StatementPtr &x) {
-        if (!opsymbol("=")) return false;
-        Location location = currentLocation();
-        ReturnKind rkind;
-        ExprListPtr exprs;
-        if (!returnExprList(rkind, exprs)) return false;
-        if (!symbol(";")) return false;
-        x = new Return(rkind, exprs, true);
-        x->location = location;
-        return true;
+static bool optPatternVarList(vector<PatternVar> &x) {
+    unsigned p = save();
+    if (!patternVarList(x)) {
+        restore(p);
+        x.clear();
     }
+    return true;
+}
 
-    static bool body(StatementPtr &x) {
-        unsigned p = save();
-        if (exprBody(x)) return true;
-        if (restore(p), block(x)) return true;
+static bool patternVarsWithCond(vector<PatternVar> &x, ExprPtr &y) {
+    if (!symbol("["))
+        return false;
+    if (!optPatternVarList(x))
+        return false;
+    if (!optPredicate(y) || !symbol("]")) {
+        x.clear();
+        y = nullptr;
         return false;
     }
+    return true;
+}
 
-    static bool optBody(StatementPtr &x) {
-        unsigned p = save();
-        if (body(x)) return true;
+static bool optPatternVarsWithCond(vector<PatternVar> &x, ExprPtr &y) {
+    unsigned p = save();
+    if (!patternVarsWithCond(x, y)) {
         restore(p);
-        x = nullptr;
-        if (symbol(";")) return true;
-        return false;
+        x.clear();
+        y = nullptr;
     }
+    return true;
+}
 
-    //
-    // topLevelVisibility, importVisibility
-    //
-
-    bool optVisibility(Visibility defaultVisibility, Visibility &x) {
-        unsigned p = save();
-        if (keyword("public")) {
-            x = PUBLIC;
-            return true;
-        }
+static void skipOptPatternVar() {
+    unsigned p = save();
+    if (!symbol("[")) {
         restore(p);
-        if (keyword("private")) {
-            x = PRIVATE;
-            return true;
+    } else {
+        int bracket = 1;
+        while (bracket) {
+            unsigned i = save();
+            if (symbol("[")) {
+                ++bracket;
+                continue;
+            }
+            restore(i);
+            if (symbol("]"))
+                --bracket;
         }
-        restore(p);
-        x = defaultVisibility;
-        return true;
     }
+}
 
-    bool topLevelVisibility(Visibility &x) {
-        return optVisibility(PUBLIC, x);
-    }
+static bool exprBody(StatementPtr &x) {
+    if (!opsymbol("="))
+        return false;
+    Location location = currentLocation();
+    ReturnKind rkind;
+    ExprListPtr exprs;
+    if (!returnExprList(rkind, exprs))
+        return false;
+    if (!symbol(";"))
+        return false;
+    x = new Return(rkind, exprs, true);
+    x->location = location;
+    return true;
+}
 
-    bool importVisibility(Visibility &x) {
-        return optVisibility(VISIBILITY_UNDEFINED, x);
-    }
+static bool body(StatementPtr &x) {
+    unsigned p = save();
+    if (exprBody(x))
+        return true;
+    if (restore(p), block(x))
+        return true;
+    return false;
+}
+
+static bool optBody(StatementPtr &x) {
+    unsigned p = save();
+    if (body(x))
+        return true;
+    restore(p);
+    x = nullptr;
+    if (symbol(";"))
+        return true;
+    return false;
+}
 
-    //
-    // records
-    //
+//
+// topLevelVisibility, importVisibility
+//
 
-    static bool recordField(RecordFieldPtr &x, bool &hasVarField) {
-        Location location = currentLocation();
-        IdentifierPtr y;
-        ExprPtr z;
-        bool varField = false;
-        unsigned p = save();
-        if (ellipsis()) {
-            if (hasVarField)
-                return false;
-            else
-                hasVarField = true;
-            varField = true;
-        } else
-            restore(p);
-        if (!identifier(y)) return false;
-        if (varField) {
-            if (!varArgTypeSpec(z)) return false;
-        } else {
-            if (!exprTypeSpec(z)) return false;
-        }
-        x = new RecordField(y, z);
-        x->location = location;
-        x->varField = varField;
+bool optVisibility(Visibility defaultVisibility, Visibility &x) {
+    unsigned p = save();
+    if (keyword("public")) {
+        x = PUBLIC;
         return true;
     }
-
-    static bool recordFields(vector<RecordFieldPtr> &x, bool &hasVarField) {
-        RecordFieldPtr y;
-        if (!recordField(y, hasVarField)) return false;
-        x.clear();
-        while (true) {
-            x.push_back(y);
-            unsigned p = save();
-            if (!symbol(",")) {
-                restore(p);
-                break;
-            }
-            p = save();
-            if (!recordField(y, hasVarField)) {
-                restore(p);
-                break;
-            }
-        }
+    restore(p);
+    if (keyword("private")) {
+        x = PRIVATE;
         return true;
     }
+    restore(p);
+    x = defaultVisibility;
+    return true;
+}
+
+bool topLevelVisibility(Visibility &x) { return optVisibility(PUBLIC, x); }
+
+bool importVisibility(Visibility &x) {
+    return optVisibility(VISIBILITY_UNDEFINED, x);
+}
+
+//
+// records
+//
+
+static bool recordField(RecordFieldPtr &x, bool &hasVarField) {
+    Location location = currentLocation();
+    IdentifierPtr y;
+    ExprPtr z;
+    bool varField = false;
+    unsigned p = save();
+    if (ellipsis()) {
+        if (hasVarField)
+            return false;
+        else
+            hasVarField = true;
+        varField = true;
+    } else
+        restore(p);
+    if (!identifier(y))
+        return false;
+    if (varField) {
+        if (!varArgTypeSpec(z))
+            return false;
+    } else {
+        if (!exprTypeSpec(z))
+            return false;
+    }
+    x = new RecordField(y, z);
+    x->location = location;
+    x->varField = varField;
+    return true;
+}
 
-    static bool optRecordFields(vector<RecordFieldPtr> &x, bool &hasVarField) {
+static bool recordFields(vector<RecordFieldPtr> &x, bool &hasVarField) {
+    RecordFieldPtr y;
+    if (!recordField(y, hasVarField))
+        return false;
+    x.clear();
+    while (true) {
+        x.push_back(y);
         unsigned p = save();
-        if (!recordFields(x, hasVarField)) {
+        if (!symbol(",")) {
             restore(p);
-            x.clear();
+            break;
+        }
+        p = save();
+        if (!recordField(y, hasVarField)) {
+            restore(p);
+            break;
         }
-        return true;
     }
+    return true;
+}
 
-    static bool recordBodyFields(RecordBodyPtr &x) {
-        Location location = currentLocation();
-        if (!symbol("(")) return false;
-        vector<RecordFieldPtr> y;
-        bool hasVarField = false;
-        if (!optRecordFields(y, hasVarField)) return false;
-        if (!symbol(")")) return false;
-        if (!symbol(";")) return false;
-        x = new RecordBody(y, hasVarField);
-        x->location = location;
-        return true;
+static bool optRecordFields(vector<RecordFieldPtr> &x, bool &hasVarField) {
+    unsigned p = save();
+    if (!recordFields(x, hasVarField)) {
+        restore(p);
+        x.clear();
     }
+    return true;
+}
 
-    static bool recordBodyComputed(RecordBodyPtr &x) {
-        Location location = currentLocation();
-        if (!opsymbol("=")) return false;
-        ExprListPtr y;
-        if (!optExpressionList(y)) return false;
-        if (!symbol(";")) return false;
-        x = new RecordBody(y);
-        x->location = location;
-        return true;
-    }
+static bool recordBodyFields(RecordBodyPtr &x) {
+    Location location = currentLocation();
+    if (!symbol("("))
+        return false;
+    vector<RecordFieldPtr> y;
+    bool hasVarField = false;
+    if (!optRecordFields(y, hasVarField))
+        return false;
+    if (!symbol(")"))
+        return false;
+    if (!symbol(";"))
+        return false;
+    x = new RecordBody(y, hasVarField);
+    x->location = location;
+    return true;
+}
 
-    static bool recordBody(RecordBodyPtr &x) {
-        unsigned p = save();
-        if (recordBodyFields(x)) return true;
-        if (restore(p), recordBodyComputed(x)) return true;
+static bool recordBodyComputed(RecordBodyPtr &x) {
+    Location location = currentLocation();
+    if (!opsymbol("="))
         return false;
-    }
+    ExprListPtr y;
+    if (!optExpressionList(y))
+        return false;
+    if (!symbol(";"))
+        return false;
+    x = new RecordBody(y);
+    x->location = location;
+    return true;
+}
 
-    static bool record(TopLevelItemPtr &x, Module *module, unsigned s) {
-        Visibility vis;
-        if (!topLevelVisibility(vis)) return false;
-        if (!keyword("record")) return false;
-        unsigned e = save();
-        restore(s);
-        Location location = currentLocation();
-        vector<PatternVar> patternVars;
-        ExprPtr predicate;
-        if (!optPatternVarsWithCond(patternVars, predicate)) return false;
-        restore(e);
+static bool recordBody(RecordBodyPtr &x) {
+    unsigned p = save();
+    if (recordBodyFields(x))
+        return true;
+    if (restore(p), recordBodyComputed(x))
+        return true;
+    return false;
+}
 
-        IdentifierPtr name;
-        vector<IdentifierPtr> params;
-        IdentifierPtr varParam;
-        RecordBodyPtr body;
+static bool record(TopLevelItemPtr &x, Module *module, unsigned s) {
+    Visibility vis;
+    if (!topLevelVisibility(vis))
+        return false;
+    if (!keyword("record"))
+        return false;
+    unsigned e = save();
+    restore(s);
+    Location location = currentLocation();
+    vector<PatternVar> patternVars;
+    ExprPtr predicate;
+    if (!optPatternVarsWithCond(patternVars, predicate))
+        return false;
+    restore(e);
 
-        if (!identifier(name)) return false;
-        if (!optStaticParams(params, varParam)) return false;
-        if (!recordBody(body)) return false;
-        x = new RecordDecl(module, name, vis, patternVars, predicate, params, varParam, body);
-        x->location = location;
-        return true;
-    }
+    IdentifierPtr name;
+    vector<IdentifierPtr> params;
+    IdentifierPtr varParam;
+    RecordBodyPtr body;
 
-    //
-    // variant, instance
-    //
+    if (!identifier(name))
+        return false;
+    if (!optStaticParams(params, varParam))
+        return false;
+    if (!recordBody(body))
+        return false;
+    x = new RecordDecl(module, name, vis, patternVars, predicate, params,
+                       varParam, body);
+    x->location = location;
+    return true;
+}
 
-    static bool instances(ExprListPtr &x) {
-        return symbol("(") && optExpressionList(x) && symbol(")");
-    }
+//
+// variant, instance
+//
 
-    static bool optInstances(ExprListPtr &x, bool &open) {
-        unsigned p = save();
-        if (symbol("(")) {
-            open = false;
-            return optExpressionList(x) && symbol(")");
-        } else {
-            open = true;
-            restore(p);
-            x = new ExprList();
-            return true;
-        }
-    }
+static bool instances(ExprListPtr &x) {
+    return symbol("(") && optExpressionList(x) && symbol(")");
+}
 
-    static bool variant(TopLevelItemPtr &x, Module *module, unsigned s) {
-        Visibility vis;
-        if (!topLevelVisibility(vis)) return false;
-        if (!keyword("variant")) return false;
-        unsigned e = save();
-        restore(s);
-        Location location = currentLocation();
-        vector<PatternVar> patternVars;
-        ExprPtr predicate;
-        if (!optPatternVarsWithCond(patternVars, predicate)) return false;
-        restore(e);
-        IdentifierPtr name;
-        if (!identifier(name)) return false;
-        vector<IdentifierPtr> params;
-        IdentifierPtr varParam;
-        if (!optStaticParams(params, varParam)) return false;
-        ExprListPtr defaultInstances;
-        bool open;
-        if (!optInstances(defaultInstances, open)) return false;
-        if (!symbol(";")) return false;
-        x = new VariantDecl(module, name, vis, patternVars, predicate, params, varParam, open, defaultInstances);
-        x->location = location;
-        return true;
-    }
-
-    static bool instance(TopLevelItemPtr &x, Module *module, unsigned s) {
-        if (!keyword("instance")) return false;
-        unsigned e = save();
-        restore(s);
-        Location location = currentLocation();
-        vector<PatternVar> patternVars;
-        ExprPtr predicate;
-        if (!optPatternVarsWithCond(patternVars, predicate)) return false;
-        restore(e);
-        ExprPtr target;
-        if (!pattern(target)) return false;
-        ExprListPtr members;
-        if (!instances(members)) return false;
-        if (!symbol(";")) return false;
-        x = new InstanceDecl(module, patternVars, predicate, target, members);
-        x->location = location;
-        return true;
-    }
-
-    static bool newtype(TopLevelItemPtr &x, Module *module) {
-        Location location = currentLocation();
-        Visibility vis;
-        if (!topLevelVisibility(vis)) return false;
-        if (!keyword("newtype")) return false;
-        IdentifierPtr name;
-        if (!identifier(name)) return false;
-        if (!opsymbol("=")) return false;
-        ExprPtr expr;
-        if (!expression(expr)) return false;
-        if (!symbol(";")) return false;
-        x = new NewTypeDecl(module, name, vis, expr);
-        x->location = location;
+static bool optInstances(ExprListPtr &x, bool &open) {
+    unsigned p = save();
+    if (symbol("(")) {
+        open = false;
+        return optExpressionList(x) && symbol(")");
+    } else {
+        open = true;
+        restore(p);
+        x = new ExprList();
         return true;
     }
+}
 
-    //
-    // returnSpec
-    //
+static bool variant(TopLevelItemPtr &x, Module *module, unsigned s) {
+    Visibility vis;
+    if (!topLevelVisibility(vis))
+        return false;
+    if (!keyword("variant"))
+        return false;
+    unsigned e = save();
+    restore(s);
+    Location location = currentLocation();
+    vector<PatternVar> patternVars;
+    ExprPtr predicate;
+    if (!optPatternVarsWithCond(patternVars, predicate))
+        return false;
+    restore(e);
+    IdentifierPtr name;
+    if (!identifier(name))
+        return false;
+    vector<IdentifierPtr> params;
+    IdentifierPtr varParam;
+    if (!optStaticParams(params, varParam))
+        return false;
+    ExprListPtr defaultInstances;
+    bool open;
+    if (!optInstances(defaultInstances, open))
+        return false;
+    if (!symbol(";"))
+        return false;
+    x = new VariantDecl(module, name, vis, patternVars, predicate, params,
+                        varParam, open, defaultInstances);
+    x->location = location;
+    return true;
+}
 
-    static bool namedReturnName(IdentifierPtr &x) {
-        IdentifierPtr y;
-        if (!identifier(y)) return false;
-        if (!symbol(":")) return false;
-        x = y;
-        return true;
-    }
+static bool instance(TopLevelItemPtr &x, Module *module, unsigned s) {
+    if (!keyword("instance"))
+        return false;
+    unsigned e = save();
+    restore(s);
+    Location location = currentLocation();
+    vector<PatternVar> patternVars;
+    ExprPtr predicate;
+    if (!optPatternVarsWithCond(patternVars, predicate))
+        return false;
+    restore(e);
+    ExprPtr target;
+    if (!pattern(target))
+        return false;
+    ExprListPtr members;
+    if (!instances(members))
+        return false;
+    if (!symbol(";"))
+        return false;
+    x = new InstanceDecl(module, patternVars, predicate, target, members);
+    x->location = location;
+    return true;
+}
 
-    static bool returnTypeExpression(ExprPtr &x) {
-        return orExpr(x);
-    }
+static bool newtype(TopLevelItemPtr &x, Module *module) {
+    Location location = currentLocation();
+    Visibility vis;
+    if (!topLevelVisibility(vis))
+        return false;
+    if (!keyword("newtype"))
+        return false;
+    IdentifierPtr name;
+    if (!identifier(name))
+        return false;
+    if (!opsymbol("="))
+        return false;
+    ExprPtr expr;
+    if (!expression(expr))
+        return false;
+    if (!symbol(";"))
+        return false;
+    x = new NewTypeDecl(module, name, vis, expr);
+    x->location = location;
+    return true;
+}
 
-    static bool returnType(ReturnSpecPtr &x) {
-        Location location = currentLocation();
-        ExprPtr z;
-        if (!returnTypeExpression(z)) return false;
-        x = new ReturnSpec(z, nullptr);
-        x->location = location;
-        return true;
-    }
+//
+// returnSpec
+//
 
-    static bool returnTypeList(vector<ReturnSpecPtr> &x) {
-        ReturnSpecPtr y;
-        if (!returnType(y)) return false;
-        x.clear();
-        while (true) {
-            x.push_back(y);
-            unsigned p = save();
-            if (!symbol(",") || !returnType(y)) {
-                restore(p);
-                break;
-            }
-        }
-        return true;
-    }
+static bool namedReturnName(IdentifierPtr &x) {
+    IdentifierPtr y;
+    if (!identifier(y))
+        return false;
+    if (!symbol(":"))
+        return false;
+    x = y;
+    return true;
+}
+
+static bool returnTypeExpression(ExprPtr &x) { return orExpr(x); }
 
-    static bool optReturnTypeList(vector<ReturnSpecPtr> &x) {
+static bool returnType(ReturnSpecPtr &x) {
+    Location location = currentLocation();
+    ExprPtr z;
+    if (!returnTypeExpression(z))
+        return false;
+    x = new ReturnSpec(z, nullptr);
+    x->location = location;
+    return true;
+}
+
+static bool returnTypeList(vector<ReturnSpecPtr> &x) {
+    ReturnSpecPtr y;
+    if (!returnType(y))
+        return false;
+    x.clear();
+    while (true) {
+        x.push_back(y);
         unsigned p = save();
-        if (!returnTypeList(x)) {
+        if (!symbol(",") || !returnType(y)) {
             restore(p);
-            x.clear();
+            break;
         }
-        return true;
-    }
-
-    static bool namedReturn(ReturnSpecPtr &x) {
-        Location location = currentLocation();
-        IdentifierPtr y;
-        if (!namedReturnName(y)) return false;
-        ExprPtr z;
-        if (!returnTypeExpression(z)) return false;
-        x = new ReturnSpec(z, y);
-        x->location = location;
-        return true;
     }
+    return true;
+}
 
-    static bool namedReturnList(vector<ReturnSpecPtr> &x) {
-        ReturnSpecPtr y;
-        if (!namedReturn(y)) return false;
+static bool optReturnTypeList(vector<ReturnSpecPtr> &x) {
+    unsigned p = save();
+    if (!returnTypeList(x)) {
+        restore(p);
         x.clear();
-        while (true) {
-            x.push_back(y);
-            unsigned p = save();
-            if (!symbol(",") || !namedReturn(y)) {
-                restore(p);
-                break;
-            }
-        }
-        return true;
     }
+    return true;
+}
+
+static bool namedReturn(ReturnSpecPtr &x) {
+    Location location = currentLocation();
+    IdentifierPtr y;
+    if (!namedReturnName(y))
+        return false;
+    ExprPtr z;
+    if (!returnTypeExpression(z))
+        return false;
+    x = new ReturnSpec(z, y);
+    x->location = location;
+    return true;
+}
 
-    static bool optNamedReturnList(vector<ReturnSpecPtr> &x) {
+static bool namedReturnList(vector<ReturnSpecPtr> &x) {
+    ReturnSpecPtr y;
+    if (!namedReturn(y))
+        return false;
+    x.clear();
+    while (true) {
+        x.push_back(y);
         unsigned p = save();
-        if (!namedReturnList(x)) {
+        if (!symbol(",") || !namedReturn(y)) {
             restore(p);
-            x.clear();
+            break;
         }
-        return true;
     }
+    return true;
+}
 
-    static bool varReturnType(ReturnSpecPtr &x) {
-        Location location = currentLocation();
-        if (!ellipsis()) return false;
-        ExprPtr z;
-        if (!returnTypeExpression(z)) return false;
-        x = new ReturnSpec(z, nullptr);
-        x->location = location;
-        return true;
+static bool optNamedReturnList(vector<ReturnSpecPtr> &x) {
+    unsigned p = save();
+    if (!namedReturnList(x)) {
+        restore(p);
+        x.clear();
     }
+    return true;
+}
 
-    static bool optVarReturnType(ReturnSpecPtr &x) {
-        unsigned p = save();
-        if (!varReturnType(x)) {
-            restore(p);
-            x = nullptr;
-        }
-        return true;
-    }
+static bool varReturnType(ReturnSpecPtr &x) {
+    Location location = currentLocation();
+    if (!ellipsis())
+        return false;
+    ExprPtr z;
+    if (!returnTypeExpression(z))
+        return false;
+    x = new ReturnSpec(z, nullptr);
+    x->location = location;
+    return true;
+}
 
-    static bool varNamedReturn(ReturnSpecPtr &x) {
-        Location location = currentLocation();
-        if (!ellipsis()) return false;
-        IdentifierPtr y;
-        if (!namedReturnName(y)) return false;
-        ExprPtr z;
-        if (!returnTypeExpression(z)) return false;
-        x = new ReturnSpec(z, y);
-        x->location = location;
-        return true;
+static bool optVarReturnType(ReturnSpecPtr &x) {
+    unsigned p = save();
+    if (!varReturnType(x)) {
+        restore(p);
+        x = nullptr;
     }
+    return true;
+}
 
-    static bool optVarNamedReturn(ReturnSpecPtr &x) {
-        unsigned p = save();
-        if (!varNamedReturn(x)) {
-            restore(p);
-            x = nullptr;
-        }
-        return true;
+static bool varNamedReturn(ReturnSpecPtr &x) {
+    Location location = currentLocation();
+    if (!ellipsis())
+        return false;
+    IdentifierPtr y;
+    if (!namedReturnName(y))
+        return false;
+    ExprPtr z;
+    if (!returnTypeExpression(z))
+        return false;
+    x = new ReturnSpec(z, y);
+    x->location = location;
+    return true;
+}
+
+static bool optVarNamedReturn(ReturnSpecPtr &x) {
+    unsigned p = save();
+    if (!varNamedReturn(x)) {
+        restore(p);
+        x = nullptr;
     }
+    return true;
+}
 
-    static bool allReturnSpecsWithFlag(vector<ReturnSpecPtr> &returnSpecs,
-                                       ReturnSpecPtr &varReturnSpec, bool &exprRetSpecs) {
-        returnSpecs.clear();
-        varReturnSpec = nullptr;
-        unsigned p = save();
-        if (symbol(":")) {
-            if (!optReturnTypeList(returnSpecs)) return false;
-            if (!optVarReturnType(varReturnSpec)) return false;
-            if (!returnSpecs.empty() || varReturnSpec != nullptr)
-                exprRetSpecs = true;
+static bool allReturnSpecsWithFlag(vector<ReturnSpecPtr> &returnSpecs,
+                                   ReturnSpecPtr &varReturnSpec,
+                                   bool &exprRetSpecs) {
+    returnSpecs.clear();
+    varReturnSpec = nullptr;
+    unsigned p = save();
+    if (symbol(":")) {
+        if (!optReturnTypeList(returnSpecs))
+            return false;
+        if (!optVarReturnType(varReturnSpec))
+            return false;
+        if (!returnSpecs.empty() || varReturnSpec != nullptr)
+            exprRetSpecs = true;
+        return true;
+    } else {
+        restore(p);
+        if (opsymbol("-->")) {
+            if (!optNamedReturnList(returnSpecs))
+                return false;
+            if (!optVarNamedReturn(varReturnSpec))
+                return false;
             return true;
         } else {
             restore(p);
-            if (opsymbol("-->")) {
-                if (!optNamedReturnList(returnSpecs)) return false;
-                if (!optVarNamedReturn(varReturnSpec)) return false;
-                return true;
-            } else {
-                restore(p);
-                return false;
-            }
+            return false;
         }
     }
+}
 
-    static bool allReturnSpecs(vector<ReturnSpecPtr> &returnSpecs,
-                               ReturnSpecPtr &varReturnSpec) {
-        bool exprRetSpecs = false;
-        return allReturnSpecsWithFlag(returnSpecs, varReturnSpec, exprRetSpecs);
-    }
-
-    //
-    // define, overload
-    //
+static bool allReturnSpecs(vector<ReturnSpecPtr> &returnSpecs,
+                           ReturnSpecPtr &varReturnSpec) {
+    bool exprRetSpecs = false;
+    return allReturnSpecsWithFlag(returnSpecs, varReturnSpec, exprRetSpecs);
+}
 
-    static bool isOverload(bool &isDefault) {
-        int p = static_cast<int>(save());
-        if (keyword("overload"))
-            isDefault = false;
-        else if (restore(p), keyword("default"))
-            isDefault = true;
-        else {
-            return false;
-        }
-        return true;
+//
+// define, overload
+//
+
+static bool isOverload(bool &isDefault) {
+    int p = static_cast<int>(save());
+    if (keyword("overload"))
+        isDefault = false;
+    else if (restore(p), keyword("default"))
+        isDefault = true;
+    else {
+        return false;
     }
+    return true;
+}
 
-    static bool optInline(InlineAttribute &isInline) {
-        unsigned p = save();
-        if (keyword("inline"))
-            isInline = INLINE;
-        else if (restore(p), keyword("forceinline"))
-            isInline = FORCE_INLINE;
-        else if (restore(p), keyword("noinline"))
-            isInline = NEVER_INLINE;
-        else {
-            restore(p);
-            isInline = IGNORE;
-        }
-        return true;
+static bool optInline(InlineAttribute &isInline) {
+    unsigned p = save();
+    if (keyword("inline"))
+        isInline = INLINE;
+    else if (restore(p), keyword("forceinline"))
+        isInline = FORCE_INLINE;
+    else if (restore(p), keyword("noinline"))
+        isInline = NEVER_INLINE;
+    else {
+        restore(p);
+        isInline = IGNORE;
     }
+    return true;
+}
 
-    static bool optCallByName(bool &callByName) {
-        unsigned p = save();
-        if (!keyword("alias")) {
-            restore(p);
-            callByName = false;
-            return true;
-        }
-        callByName = true;
+static bool optCallByName(bool &callByName) {
+    unsigned p = save();
+    if (!keyword("alias")) {
+        restore(p);
+        callByName = false;
         return true;
     }
+    callByName = true;
+    return true;
+}
 
-    static bool optPrivateOverload(bool &privateOverload) {
-        unsigned p = save();
-        if (!keyword("private")) {
-            restore(p);
-            privateOverload = false;
-            return true;
-        }
-        if (!keyword("overload")) {
-            return false;
-        }
-        privateOverload = true;
+static bool optPrivateOverload(bool &privateOverload) {
+    unsigned p = save();
+    if (!keyword("private")) {
+        restore(p);
+        privateOverload = false;
         return true;
     }
-
-    static bool llvmCode(LLVMCodePtr &b) {
-        Token *t;
-        if (!next(t) || (t->tokenKind != T_LLVM))
-            return false;
-        b = new LLVMCode(t->str);
-        b->location = t->location;
-        return true;
-    }
-
-    static bool llvmProcedure(vector<TopLevelItemPtr> &x, Module *module) {
-        Location location = currentLocation();
-        CodePtr y = new Code();
-        if (!optPatternVarsWithCond(y->patternVars, y->predicate)) return false;
-        Visibility vis;
-        if (!topLevelVisibility(vis)) return false;
-        InlineAttribute isInline;
-        if (!optInline(isInline)) return false;
-        IdentifierPtr z;
-        Location targetStartLocation = currentLocation();
-        if (!identifier(z)) return false;
-        Location targetEndLocation = currentLocation();
-        bool hasVarArg = false;
-        bool hasAsConversion = false;
-        if (!arguments(y->formalArgs, hasVarArg, hasAsConversion)) return false;
-        y->hasVarArg = hasVarArg;
-        y->returnSpecsDeclared = allReturnSpecs(y->returnSpecs, y->varReturnSpec);
-        if (!llvmCode(y->llvmBody)) return false;
-        y->location = location;
-
-        ProcedurePtr u = new Procedure(module, z, vis, true);
-        u->location = location;
-        x.emplace_back(u.ptr());
-
-        ExprPtr target = new NameRef(z);
-        target->location = location;
-        target->startLocation = targetStartLocation;
-        target->endLocation = targetEndLocation;
-        OverloadPtr v = new Overload(module, target, y, false, isInline, hasAsConversion);
-        v->location = location;
-        x.emplace_back(v.ptr());
-
-        u->singleOverload = v;
-
-        return true;
-    }
-
-    static bool procedureWithInterface(vector<TopLevelItemPtr> &x, Module *module, unsigned s) {
-        Visibility vis;
-        if (!topLevelVisibility(vis)) return false;
-        if (!keyword("define")) return false;
-        unsigned e = save();
-        restore(s);
-        Location location = currentLocation();
-        CodePtr interfaceCode = new Code();
-        if (!optPatternVarsWithCond(interfaceCode->patternVars, interfaceCode->predicate)) return false;
-        restore(e);
-        IdentifierPtr name;
-        Location targetStartLocation = currentLocation();
-        if (!identifier(name)) return false;
-        Location targetEndLocation = currentLocation();
-        bool hasVarArg = false;
-        bool hasAsConversion = false;
-        if (!arguments(interfaceCode->formalArgs, hasVarArg, hasAsConversion)) return false;
-        interfaceCode->hasVarArg = hasVarArg;
-        interfaceCode->returnSpecsDeclared = allReturnSpecs(interfaceCode->returnSpecs, interfaceCode->varReturnSpec);
-
-        bool privateOverload;
-        if (!optPrivateOverload(privateOverload)) return false;
-
-        if (!symbol(";")) return false;
-        interfaceCode->location = location;
-
-        ExprPtr target = new NameRef(name);
-        target->location = location;
-        target->startLocation = targetStartLocation;
-        target->endLocation = targetEndLocation;
-        OverloadPtr interface = new Overload(module, target, interfaceCode, false, IGNORE);
-        interface->location = location;
-
-        ProcedurePtr proc = new Procedure(module, name, vis, privateOverload, interface);
-        proc->location = location;
-        x.emplace_back(proc.ptr());
-
-        return true;
-    }
-
-    static bool procedureWithBody(vector<TopLevelItemPtr> &x, Module *module, unsigned s) {
-        Visibility vis;
-        if (!topLevelVisibility(vis)) return false;
-        InlineAttribute isInline;
-        if (!optInline(isInline)) return false;
-        bool callByName;
-        if (!optCallByName(callByName)) return false;
-        IdentifierPtr name;
-        Location targetStartLocation = currentLocation();
-        if (!identifier(name)) return false;
-        Location targetEndLocation = currentLocation();
-        unsigned e = save();
-        restore(s);
-        Location location = currentLocation();
-        CodePtr code = new Code();
-        if (!optPatternVarsWithCond(code->patternVars, code->predicate)) return false;
-        restore(e);
-        bool hasVarArg = false;
-        bool hasAsConversion = false;
-        if (!arguments(code->formalArgs, hasVarArg, hasAsConversion)) return false;
-        code->hasVarArg = hasVarArg;
-        bool exprRetSpecs = false;
-        code->returnSpecsDeclared = allReturnSpecsWithFlag(code->returnSpecs, code->varReturnSpec, exprRetSpecs);
-        if (!body(code->body)) return false;
-        code->location = location;
-        if (exprRetSpecs && code->body->stmtKind == RETURN) {
-            auto return_ = dynamic_cast<Return *>(code->body.ptr());
-            if (return_->isExprReturn)
-                return_->isReturnSpecs = true;
-        }
-
-        ProcedurePtr proc = new Procedure(module, name, vis, true);
-        proc->location = location;
-        x.emplace_back(proc.ptr());
-
-        ExprPtr target = new NameRef(name);
-        target->location = location;
-        target->startLocation = targetStartLocation;
-        target->endLocation = targetEndLocation;
-        OverloadPtr oload = new Overload(module, target, code, callByName, isInline, hasAsConversion);
-        oload->location = location;
-        x.emplace_back(oload.ptr());
-
-        proc->singleOverload = oload;
-
-        return true;
-    }
-
-    static bool procedure(TopLevelItemPtr &x, Module *module) {
-        Location location = currentLocation();
-        Visibility vis;
-        if (!topLevelVisibility(vis)) return false;
-        if (!keyword("define")) return false;
-        IdentifierPtr name;
-        if (!identifier(name)) return false;
-        bool privateOverload;
-        if (!optPrivateOverload(privateOverload)) return false;
-        if (!symbol(";")) return false;
-        x = new Procedure(module, name, vis, privateOverload);
-        x->location = location;
-        return true;
-    }
-
-    static bool overload(TopLevelItemPtr &x, Module *module, unsigned s) {
-        InlineAttribute isInline;
-        if (!optInline(isInline)) return false;
-        bool callByName;
-        if (!optCallByName(callByName)) return false;
-        bool isDefault;
-        if (!isOverload(isDefault)) return false;
-        unsigned e = save();
-        restore(s);
-        Location location = currentLocation();
-        CodePtr code = new Code();
-        if (!optPatternVarsWithCond(code->patternVars, code->predicate)) return false;
-        restore(e);
-        ExprPtr target;
-        Location targetStartLocation = currentLocation();
-        if (!pattern(target)) return false;
-        Location targetEndLocation = currentLocation();
-        bool hasVarArg = false;
-        bool hasAsConversion = false;
-        if (!arguments(code->formalArgs, hasVarArg, hasAsConversion)) return false;
-        code->hasVarArg = hasVarArg;
-        bool exprRetSpecs = false;
-        code->returnSpecsDeclared = allReturnSpecsWithFlag(code->returnSpecs, code->varReturnSpec, exprRetSpecs);
-        unsigned p = save();
-        if (!optBody(code->body)) {
-            restore(p);
-            if (callByName) return false;
-            if (!llvmCode(code->llvmBody)) return false;
-        }
-        if (exprRetSpecs && code->body->stmtKind == RETURN) {
-            auto return_ = dynamic_cast<Return *>(code->body.ptr());
-            if (return_->isExprReturn)
-                return_->isReturnSpecs = true;
-        }
-        target->location = location;
-        target->startLocation = targetStartLocation;
-        target->endLocation = targetEndLocation;
-        code->location = location;
-        OverloadPtr oload = new Overload(module, target, code, callByName, isInline, hasAsConversion);
-        oload->location = location;
-        oload->isDefault = isDefault;
-        x = oload.ptr();
-        return true;
+    if (!keyword("overload")) {
+        return false;
     }
+    privateOverload = true;
+    return true;
+}
 
-    //
-    // enumerations
-    //
+static bool llvmCode(LLVMCodePtr &b) {
+    Token *t;
+    if (!next(t) || (t->tokenKind != T_LLVM))
+        return false;
+    b = new LLVMCode(t->str);
+    b->location = t->location;
+    return true;
+}
 
-    static bool enumMember(EnumMemberPtr &x) {
-        Location location = currentLocation();
-        IdentifierPtr y;
-        if (!identifier(y)) return false;
-        x = new EnumMember(y);
-        x->location = location;
-        return true;
-    }
+static bool llvmProcedure(vector<TopLevelItemPtr> &x, Module *module) {
+    Location location = currentLocation();
+    CodePtr y = new Code();
+    if (!optPatternVarsWithCond(y->patternVars, y->predicate))
+        return false;
+    Visibility vis;
+    if (!topLevelVisibility(vis))
+        return false;
+    InlineAttribute isInline;
+    if (!optInline(isInline))
+        return false;
+    IdentifierPtr z;
+    Location targetStartLocation = currentLocation();
+    if (!identifier(z))
+        return false;
+    Location targetEndLocation = currentLocation();
+    bool hasVarArg = false;
+    bool hasAsConversion = false;
+    if (!arguments(y->formalArgs, hasVarArg, hasAsConversion))
+        return false;
+    y->hasVarArg = hasVarArg;
+    y->returnSpecsDeclared = allReturnSpecs(y->returnSpecs, y->varReturnSpec);
+    if (!llvmCode(y->llvmBody))
+        return false;
+    y->location = location;
 
-    static bool enumMemberList(vector<EnumMemberPtr> &x) {
-        EnumMemberPtr y;
-        if (!enumMember(y)) return false;
-        x.clear();
-        while (true) {
-            x.push_back(y);
-            unsigned p = save();
-            if (!symbol(",")) {
-                restore(p);
-                break;
-            }
-            p = save();
-            if (!enumMember(y)) {
-                restore(p);
-                break;
-            }
-        }
-        return true;
-    }
+    ProcedurePtr u = new Procedure(module, z, vis, true);
+    u->location = location;
+    x.emplace_back(u.ptr());
 
-    static bool enumeration(TopLevelItemPtr &x, Module *module, unsigned s) {
-        Visibility vis;
-        if (!topLevelVisibility(vis)) return false;
-        if (!keyword("enum")) return false;
-        unsigned e = save();
-        restore(s);
-        Location location = currentLocation();
-        vector<PatternVar> patternVars;
-        ExprPtr predicate;
-        if (!optPatternVarsWithCond(patternVars, predicate)) return false;
-        restore(e);
-        IdentifierPtr y;
-        if (!identifier(y)) return false;
-        EnumDeclPtr z = new EnumDecl(module, y, vis, patternVars, predicate);
-        if (!symbol("(")) return false;
-        if (!enumMemberList(z->members)) return false;
-        if (!symbol(")")) return false;
-        if (!symbol(";")) return false;
-        x = z.ptr();
-        x->location = location;
-        return true;
-    }
-
-    //
-    // global variable
-    //
-
-    static bool globalVariable(TopLevelItemPtr &x, Module *module, unsigned s) {
-        Visibility vis;
-        if (!topLevelVisibility(vis)) return false;
-        if (!keyword("var")) return false;
-        unsigned e = save();
-        restore(s);
-        Location location = currentLocation();
-        vector<PatternVar> patternVars;
-        ExprPtr predicate;
-        if (!optPatternVarsWithCond(patternVars, predicate)) return false;
-        restore(e);
-        IdentifierPtr name;
-        if (!identifier(name)) return false;
-        vector<IdentifierPtr> params;
-        IdentifierPtr varParam;
-        if (!optStaticParams(params, varParam)) return false;
-        if (!opsymbol("=")) return false;
-        ExprPtr expr;
-        if (!expression(expr)) return false;
-        if (!symbol(";")) return false;
-        x = new GlobalVariable(module, name, vis, patternVars, predicate, params, varParam, expr);
-        x->location = location;
-        return true;
-    }
+    ExprPtr target = new NameRef(z);
+    target->location = location;
+    target->startLocation = targetStartLocation;
+    target->endLocation = targetEndLocation;
+    OverloadPtr v =
+        new Overload(module, target, y, false, isInline, hasAsConversion);
+    v->location = location;
+    x.emplace_back(v.ptr());
 
-    //
-    // external procedure, external variable
-    //
+    u->singleOverload = v;
 
-    static bool externalAttributes(ExprListPtr &x) {
-        if (!symbol("(")) return false;
-        if (!expressionList(x)) return false;
-        if (!symbol(")")) return false;
-        return true;
-    }
+    return true;
+}
 
-    static bool optExternalAttributes(ExprListPtr &x) {
-        unsigned p = save();
-        if (!externalAttributes(x)) {
-            restore(p);
-            x = new ExprList();
-        }
-        return true;
-    }
+static bool procedureWithInterface(vector<TopLevelItemPtr> &x, Module *module,
+                                   unsigned s) {
+    Visibility vis;
+    if (!topLevelVisibility(vis))
+        return false;
+    if (!keyword("define"))
+        return false;
+    unsigned e = save();
+    restore(s);
+    Location location = currentLocation();
+    CodePtr interfaceCode = new Code();
+    if (!optPatternVarsWithCond(interfaceCode->patternVars,
+                                interfaceCode->predicate))
+        return false;
+    restore(e);
+    IdentifierPtr name;
+    Location targetStartLocation = currentLocation();
+    if (!identifier(name))
+        return false;
+    Location targetEndLocation = currentLocation();
+    bool hasVarArg = false;
+    bool hasAsConversion = false;
+    if (!arguments(interfaceCode->formalArgs, hasVarArg, hasAsConversion))
+        return false;
+    interfaceCode->hasVarArg = hasVarArg;
+    interfaceCode->returnSpecsDeclared = allReturnSpecs(
+        interfaceCode->returnSpecs, interfaceCode->varReturnSpec);
 
-    static bool externalArg(ExternalArgPtr &x) {
-        Location location = currentLocation();
-        IdentifierPtr y;
-        if (!identifier(y)) return false;
-        ExprPtr z;
-        if (!exprTypeSpec(z)) return false;
-        x = new ExternalArg(y, z);
-        x->location = location;
-        return true;
-    }
+    bool privateOverload;
+    if (!optPrivateOverload(privateOverload))
+        return false;
 
-    static bool externalArgs(vector<ExternalArgPtr> &x) {
-        ExternalArgPtr y;
-        if (!externalArg(y)) return false;
-        x.clear();
-        while (true) {
-            x.push_back(y);
-            unsigned p = save();
-            if (!symbol(",") || !externalArg(y)) {
-                restore(p);
-                break;
-            }
-        }
-        return true;
-    }
+    if (!symbol(";"))
+        return false;
+    interfaceCode->location = location;
+
+    ExprPtr target = new NameRef(name);
+    target->location = location;
+    target->startLocation = targetStartLocation;
+    target->endLocation = targetEndLocation;
+    OverloadPtr interface =
+        new Overload(module, target, interfaceCode, false, IGNORE);
+    interface->location = location;
+
+    ProcedurePtr proc =
+        new Procedure(module, name, vis, privateOverload, interface);
+    proc->location = location;
+    x.emplace_back(proc.ptr());
+
+    return true;
+}
 
-    static bool externalVarArgs(bool &hasVarArgs) {
-        if (!ellipsis()) return false;
-        hasVarArgs = true;
-        return true;
+static bool procedureWithBody(vector<TopLevelItemPtr> &x, Module *module,
+                              unsigned s) {
+    Visibility vis;
+    if (!topLevelVisibility(vis))
+        return false;
+    InlineAttribute isInline;
+    if (!optInline(isInline))
+        return false;
+    bool callByName;
+    if (!optCallByName(callByName))
+        return false;
+    IdentifierPtr name;
+    Location targetStartLocation = currentLocation();
+    if (!identifier(name))
+        return false;
+    Location targetEndLocation = currentLocation();
+    unsigned e = save();
+    restore(s);
+    Location location = currentLocation();
+    CodePtr code = new Code();
+    if (!optPatternVarsWithCond(code->patternVars, code->predicate))
+        return false;
+    restore(e);
+    bool hasVarArg = false;
+    bool hasAsConversion = false;
+    if (!arguments(code->formalArgs, hasVarArg, hasAsConversion))
+        return false;
+    code->hasVarArg = hasVarArg;
+    bool exprRetSpecs = false;
+    code->returnSpecsDeclared = allReturnSpecsWithFlag(
+        code->returnSpecs, code->varReturnSpec, exprRetSpecs);
+    if (!body(code->body))
+        return false;
+    code->location = location;
+    if (exprRetSpecs && code->body->stmtKind == RETURN) {
+        auto return_ = dynamic_cast<Return *>(code->body.ptr());
+        if (return_->isExprReturn)
+            return_->isReturnSpecs = true;
     }
 
-    static bool optExternalVarArgs(bool &hasVarArgs) {
-        unsigned p = save();
-        if (!externalVarArgs(hasVarArgs)) {
-            restore(p);
-            hasVarArgs = false;
-        }
-        return true;
-    }
+    ProcedurePtr proc = new Procedure(module, name, vis, true);
+    proc->location = location;
+    x.emplace_back(proc.ptr());
 
-    static bool trailingExternalVarArgs(bool &hasVarArgs) {
-        if (!symbol(",")) return false;
-        if (!externalVarArgs(hasVarArgs)) return false;
-        return true;
-    }
+    ExprPtr target = new NameRef(name);
+    target->location = location;
+    target->startLocation = targetStartLocation;
+    target->endLocation = targetEndLocation;
+    OverloadPtr oload = new Overload(module, target, code, callByName, isInline,
+                                     hasAsConversion);
+    oload->location = location;
+    x.emplace_back(oload.ptr());
 
-    static bool optTrailingExternalVarArgs(bool &hasVarArgs) {
-        unsigned p = save();
-        if (!trailingExternalVarArgs(hasVarArgs)) {
-            restore(p);
-            hasVarArgs = false;
-        }
-        return true;
-    }
+    proc->singleOverload = oload;
 
-    static bool externalArgsWithVArgs(vector<ExternalArgPtr> &x,
-                                      bool &hasVarArgs) {
-        if (!externalArgs(x)) return false;
-        if (!optTrailingExternalVarArgs(hasVarArgs)) return false;
-        return true;
-    }
+    return true;
+}
 
-    static bool externalArgsBody(vector<ExternalArgPtr> &x,
-                                 bool &hasVarArgs) {
-        unsigned p = save();
-        if (externalArgsWithVArgs(x, hasVarArgs)) return true;
+static bool procedure(TopLevelItemPtr &x, Module *module) {
+    Location location = currentLocation();
+    Visibility vis;
+    if (!topLevelVisibility(vis))
+        return false;
+    if (!keyword("define"))
+        return false;
+    IdentifierPtr name;
+    if (!identifier(name))
+        return false;
+    bool privateOverload;
+    if (!optPrivateOverload(privateOverload))
+        return false;
+    if (!symbol(";"))
+        return false;
+    x = new Procedure(module, name, vis, privateOverload);
+    x->location = location;
+    return true;
+}
+
+static bool overload(TopLevelItemPtr &x, Module *module, unsigned s) {
+    InlineAttribute isInline;
+    if (!optInline(isInline))
+        return false;
+    bool callByName;
+    if (!optCallByName(callByName))
+        return false;
+    bool isDefault;
+    if (!isOverload(isDefault))
+        return false;
+    unsigned e = save();
+    restore(s);
+    Location location = currentLocation();
+    CodePtr code = new Code();
+    if (!optPatternVarsWithCond(code->patternVars, code->predicate))
+        return false;
+    restore(e);
+    ExprPtr target;
+    Location targetStartLocation = currentLocation();
+    if (!pattern(target))
+        return false;
+    Location targetEndLocation = currentLocation();
+    bool hasVarArg = false;
+    bool hasAsConversion = false;
+    if (!arguments(code->formalArgs, hasVarArg, hasAsConversion))
+        return false;
+    code->hasVarArg = hasVarArg;
+    bool exprRetSpecs = false;
+    code->returnSpecsDeclared = allReturnSpecsWithFlag(
+        code->returnSpecs, code->varReturnSpec, exprRetSpecs);
+    unsigned p = save();
+    if (!optBody(code->body)) {
         restore(p);
-        x.clear();
-        hasVarArgs = false;
-        if (!optExternalVarArgs(hasVarArgs)) return false;
-        return true;
+        if (callByName)
+            return false;
+        if (!llvmCode(code->llvmBody))
+            return false;
     }
+    if (exprRetSpecs && code->body->stmtKind == RETURN) {
+        auto return_ = dynamic_cast<Return *>(code->body.ptr());
+        if (return_->isExprReturn)
+            return_->isReturnSpecs = true;
+    }
+    target->location = location;
+    target->startLocation = targetStartLocation;
+    target->endLocation = targetEndLocation;
+    code->location = location;
+    OverloadPtr oload = new Overload(module, target, code, callByName, isInline,
+                                     hasAsConversion);
+    oload->location = location;
+    oload->isDefault = isDefault;
+    x = oload.ptr();
+    return true;
+}
 
-    static bool externalBody(StatementPtr &x) {
-        unsigned p = save();
-        if (exprBody(x)) return true;
-        if (restore(p), block(x)) return true;
-        if (restore(p), symbol(";")) {
-            x = nullptr;
-            return true;
-        }
+//
+// enumerations
+//
+
+static bool enumMember(EnumMemberPtr &x) {
+    Location location = currentLocation();
+    IdentifierPtr y;
+    if (!identifier(y))
         return false;
-    }
+    x = new EnumMember(y);
+    x->location = location;
+    return true;
+}
 
-    static bool optExternalReturn(ExprPtr &x) {
+static bool enumMemberList(vector<EnumMemberPtr> &x) {
+    EnumMemberPtr y;
+    if (!enumMember(y))
+        return false;
+    x.clear();
+    while (true) {
+        x.push_back(y);
         unsigned p = save();
-        if (!symbol(":")) {
+        if (!symbol(",")) {
             restore(p);
-            return true;
+            break;
+        }
+        p = save();
+        if (!enumMember(y)) {
+            restore(p);
+            break;
         }
-        return optExpression(x);
-    }
-
-    static bool external(TopLevelItemPtr &x, Module *module) {
-        Location location = currentLocation();
-        Visibility vis;
-        if (!topLevelVisibility(vis)) return false;
-        if (!keyword("external")) return false;
-        ExternalProcedurePtr y = new ExternalProcedure(module, vis);
-        if (!optExternalAttributes(y->attributes)) return false;
-        if (!identifier(y->name)) return false;
-        if (!symbol("(")) return false;
-        bool hasVarArg = false;
-        if (!externalArgsBody(y->args, hasVarArg)) return false;
-        y->hasVarArgs = hasVarArg;
-        if (!symbol(")")) return false;
-        if (!optExternalReturn(y->returnType)) return false;
-        if (!externalBody(y->body)) return false;
-        x = y.ptr();
-        x->location = location;
-        return true;
     }
+    return true;
+}
 
-    static bool externalVariable(TopLevelItemPtr &x, Module *module) {
-        Location location = currentLocation();
-        Visibility vis;
-        if (!topLevelVisibility(vis)) return false;
-        if (!keyword("external")) return false;
-        ExternalVariablePtr y = new ExternalVariable(module, vis);
-        if (!optExternalAttributes(y->attributes)) return false;
-        if (!identifier(y->name)) return false;
-        if (!exprTypeSpec(y->type)) return false;
-        if (!symbol(";")) return false;
-        x = y.ptr();
-        x->location = location;
-        return true;
-    }
-
-    //
-    // global alias
-    //
-
-    static bool globalAlias(TopLevelItemPtr &x, Module *module, unsigned s) {
-        Visibility vis;
-        if (!topLevelVisibility(vis)) return false;
-        if (!keyword("alias")) return false;
-        unsigned e = save();
-        restore(s);
-        Location location = currentLocation();
-        vector<PatternVar> patternVars;
-        ExprPtr predicate;
-        if (!optPatternVarsWithCond(patternVars, predicate)) return false;
-        restore(e);
-        IdentifierPtr name;
-        if (!identifier(name)) return false;
-        vector<IdentifierPtr> params;
-        IdentifierPtr varParam;
-        if (!optStaticParams(params, varParam)) return false;
-        if (!opsymbol("=")) return false;
-        ExprPtr expr;
-        if (!expression(expr)) return false;
-        if (!symbol(";")) return false;
-        x = new GlobalAlias(module, name, vis, patternVars, predicate, params, varParam, expr);
-        x->location = location;
-        return true;
-    }
+static bool enumeration(TopLevelItemPtr &x, Module *module, unsigned s) {
+    Visibility vis;
+    if (!topLevelVisibility(vis))
+        return false;
+    if (!keyword("enum"))
+        return false;
+    unsigned e = save();
+    restore(s);
+    Location location = currentLocation();
+    vector<PatternVar> patternVars;
+    ExprPtr predicate;
+    if (!optPatternVarsWithCond(patternVars, predicate))
+        return false;
+    restore(e);
+    IdentifierPtr y;
+    if (!identifier(y))
+        return false;
+    EnumDeclPtr z = new EnumDecl(module, y, vis, patternVars, predicate);
+    if (!symbol("("))
+        return false;
+    if (!enumMemberList(z->members))
+        return false;
+    if (!symbol(")"))
+        return false;
+    if (!symbol(";"))
+        return false;
+    x = z.ptr();
+    x->location = location;
+    return true;
+}
 
-    //
-    // imports
-    //
+//
+// global variable
+//
 
-    static bool importAlias(IdentifierPtr &x) {
-        if (!keyword("as")) return false;
-        if (!identifier(x)) return false;
-        return true;
+static bool globalVariable(TopLevelItemPtr &x, Module *module, unsigned s) {
+    Visibility vis;
+    if (!topLevelVisibility(vis))
+        return false;
+    if (!keyword("var"))
+        return false;
+    unsigned e = save();
+    restore(s);
+    Location location = currentLocation();
+    vector<PatternVar> patternVars;
+    ExprPtr predicate;
+    if (!optPatternVarsWithCond(patternVars, predicate))
+        return false;
+    restore(e);
+    IdentifierPtr name;
+    if (!identifier(name))
+        return false;
+    vector<IdentifierPtr> params;
+    IdentifierPtr varParam;
+    if (!optStaticParams(params, varParam))
+        return false;
+    if (!opsymbol("="))
+        return false;
+    ExprPtr expr;
+    if (!expression(expr))
+        return false;
+    if (!symbol(";"))
+        return false;
+    x = new GlobalVariable(module, name, vis, patternVars, predicate, params,
+                           varParam, expr);
+    x->location = location;
+    return true;
+}
+
+//
+// external procedure, external variable
+//
+
+static bool externalAttributes(ExprListPtr &x) {
+    if (!symbol("("))
+        return false;
+    if (!expressionList(x))
+        return false;
+    if (!symbol(")"))
+        return false;
+    return true;
+}
+
+static bool optExternalAttributes(ExprListPtr &x) {
+    unsigned p = save();
+    if (!externalAttributes(x)) {
+        restore(p);
+        x = new ExprList();
     }
+    return true;
+}
+
+static bool externalArg(ExternalArgPtr &x) {
+    Location location = currentLocation();
+    IdentifierPtr y;
+    if (!identifier(y))
+        return false;
+    ExprPtr z;
+    if (!exprTypeSpec(z))
+        return false;
+    x = new ExternalArg(y, z);
+    x->location = location;
+    return true;
+}
 
-    static bool optImportAlias(IdentifierPtr &x) {
+static bool externalArgs(vector<ExternalArgPtr> &x) {
+    ExternalArgPtr y;
+    if (!externalArg(y))
+        return false;
+    x.clear();
+    while (true) {
+        x.push_back(y);
         unsigned p = save();
-        if (!importAlias(x)) {
+        if (!symbol(",") || !externalArg(y)) {
             restore(p);
-            x = nullptr;
+            break;
         }
-        return true;
     }
+    return true;
+}
 
-    static bool importModule(ImportPtr &x) {
-        Location location = currentLocation();
-        DottedNamePtr y;
-        if (!dottedName(y)) return false;
-        IdentifierPtr z;
-        if (!optImportAlias(z)) return false;
-        x = new ImportModule(y, z);
-        x->location = location;
-        return true;
-    }
+static bool externalVarArgs(bool &hasVarArgs) {
+    if (!ellipsis())
+        return false;
+    hasVarArgs = true;
+    return true;
+}
 
-    static bool importStar(ImportPtr &x) {
-        Location location = currentLocation();
-        DottedNamePtr y;
-        if (!dottedName(y)) return false;
-        if (!symbol(".")) return false;
-        if (!opsymbol("*")) return false;
-        x = new ImportStar(y);
-        x->location = location;
-        return true;
+static bool optExternalVarArgs(bool &hasVarArgs) {
+    unsigned p = save();
+    if (!externalVarArgs(hasVarArgs)) {
+        restore(p);
+        hasVarArgs = false;
     }
+    return true;
+}
 
-    static bool importedMember(ImportedMember &x) {
-        if (!topLevelVisibility(x.visibility)) return false;
-        if (!identifier(x.name)) return false;
-        if (!optImportAlias(x.alias)) return false;
-        return true;
-    }
+static bool trailingExternalVarArgs(bool &hasVarArgs) {
+    if (!symbol(","))
+        return false;
+    if (!externalVarArgs(hasVarArgs))
+        return false;
+    return true;
+}
 
-    static bool importedMemberList(vector<ImportedMember> &x) {
-        ImportedMember y;
-        if (!importedMember(y)) return false;
-        x.clear();
-        while (true) {
-            x.push_back(y);
-            unsigned p = save();
-            if (!symbol(",")) {
-                restore(p);
-                break;
-            }
-            p = save();
-            if (!importedMember(y)) {
-                restore(p);
-                break;
-            }
-        }
-        return true;
+static bool optTrailingExternalVarArgs(bool &hasVarArgs) {
+    unsigned p = save();
+    if (!trailingExternalVarArgs(hasVarArgs)) {
+        restore(p);
+        hasVarArgs = false;
     }
+    return true;
+}
 
-    static bool importMembers(ImportPtr &x) {
-        Location location = currentLocation();
-        DottedNamePtr y;
-        if (!dottedName(y)) return false;
-        if (!symbol(".")) return false;
-        if (!symbol("(")) return false;
-        ImportMembersPtr z = new ImportMembers(y);
-        if (!importedMemberList(z->members)) return false;
-        if (!symbol(")")) return false;
-        x = z.ptr();
-        x->location = location;
-        return true;
-    }
+static bool externalArgsWithVArgs(vector<ExternalArgPtr> &x, bool &hasVarArgs) {
+    if (!externalArgs(x))
+        return false;
+    if (!optTrailingExternalVarArgs(hasVarArgs))
+        return false;
+    return true;
+}
 
-    static bool import2(ImportPtr &x, Visibility visTop) {
-        Visibility vis;
-        if (!importVisibility(vis)) return false;
-        unsigned p = save();
-        if (importStar(x)) goto importsuccess;
-        if (restore(p), importMembers(x)) goto importsuccess;
-        if (restore(p), importModule(x)) goto importsuccess;
-        return false;
-    importsuccess:
-        if (vis == VISIBILITY_UNDEFINED) {
-            if (visTop == VISIBILITY_UNDEFINED)
-                x->visibility = PRIVATE;
-            else
-                x->visibility = visTop;
-        } else
-            x->visibility = vis;
-        return true;
-    }
-
-    static bool importList(vector<ImportPtr> &x, Visibility vis) {
-        ImportPtr y;
-        if (!import2(y, vis)) return false;
-        while (true) {
-            x.push_back(y);
-            unsigned p = save();
-            if (!symbol(",") || !import2(y, vis)) {
-                restore(p);
-                break;
-            }
-        }
+static bool externalArgsBody(vector<ExternalArgPtr> &x, bool &hasVarArgs) {
+    unsigned p = save();
+    if (externalArgsWithVArgs(x, hasVarArgs))
         return true;
-    }
+    restore(p);
+    x.clear();
+    hasVarArgs = false;
+    if (!optExternalVarArgs(hasVarArgs))
+        return false;
+    return true;
+}
 
-    static bool import(vector<ImportPtr> &x) {
-        Visibility vis;
-        if (!importVisibility(vis)) return false;
-        if (!keyword("import")) return false;
-        if (!importList(x, vis)) return false;
-        if (!symbol(";")) return false;
+static bool externalBody(StatementPtr &x) {
+    unsigned p = save();
+    if (exprBody(x))
         return true;
-    }
-
-    static bool imports(vector<ImportPtr> &x) {
-        x.clear();
-        while (true) {
-            unsigned p = save();
-            if (!import(x)) {
-                restore(p);
-                break;
-            }
-        }
+    if (restore(p), block(x))
+        return true;
+    if (restore(p), symbol(";")) {
+        x = nullptr;
         return true;
     }
+    return false;
+}
 
-    static bool evalTopLevel(TopLevelItemPtr &x, Module *module) {
-        Location location = currentLocation();
-        if (!keyword("eval")) return false;
-        ExprListPtr args;
-        if (!expressionList(args)) return false;
-        if (!symbol(";")) return false;
-        x = new EvalTopLevel(module, args);
-        x->location = location;
+static bool optExternalReturn(ExprPtr &x) {
+    unsigned p = save();
+    if (!symbol(":")) {
+        restore(p);
         return true;
     }
+    return optExpression(x);
+}
+
+static bool external(TopLevelItemPtr &x, Module *module) {
+    Location location = currentLocation();
+    Visibility vis;
+    if (!topLevelVisibility(vis))
+        return false;
+    if (!keyword("external"))
+        return false;
+    ExternalProcedurePtr y = new ExternalProcedure(module, vis);
+    if (!optExternalAttributes(y->attributes))
+        return false;
+    if (!identifier(y->name))
+        return false;
+    if (!symbol("("))
+        return false;
+    bool hasVarArg = false;
+    if (!externalArgsBody(y->args, hasVarArg))
+        return false;
+    y->hasVarArgs = hasVarArg;
+    if (!symbol(")"))
+        return false;
+    if (!optExternalReturn(y->returnType))
+        return false;
+    if (!externalBody(y->body))
+        return false;
+    x = y.ptr();
+    x->location = location;
+    return true;
+}
 
-    //
-    // documentation
-    //
+static bool externalVariable(TopLevelItemPtr &x, Module *module) {
+    Location location = currentLocation();
+    Visibility vis;
+    if (!topLevelVisibility(vis))
+        return false;
+    if (!keyword("external"))
+        return false;
+    ExternalVariablePtr y = new ExternalVariable(module, vis);
+    if (!optExternalAttributes(y->attributes))
+        return false;
+    if (!identifier(y->name))
+        return false;
+    if (!exprTypeSpec(y->type))
+        return false;
+    if (!symbol(";"))
+        return false;
+    x = y.ptr();
+    x->location = location;
+    return true;
+}
 
-    static bool documentationAnnotation(std::map<DocumentationAnnotation, string> &an) {
-        Location location = currentLocation();
-        Token *t;
-        if (!next(t) || t->tokenKind != T_DOC_PROPERTY) return false;
-        auto key = llvm::StringRef(t->str);
+//
+// global alias
+//
 
-        DocumentationAnnotation ano;
-        if (key == "section") {
-            ano = SectionAnnotation;
-        } else if (key == "module") {
-            ano = ModuleAnnotation;
-        } else if (key == "overload" || key == "default") {
-            ano = OverloadAnnotation;
-        } else if (key == "record") {
-            ano = RecordAnnotion;
-        } else {
-            ano = InvalidAnnotation;
-            pushLocation(location);
-            fmtError("invalid annotation '%s'\n", key.str().c_str());
-        }
+static bool globalAlias(TopLevelItemPtr &x, Module *module, unsigned s) {
+    Visibility vis;
+    if (!topLevelVisibility(vis))
+        return false;
+    if (!keyword("alias"))
+        return false;
+    unsigned e = save();
+    restore(s);
+    Location location = currentLocation();
+    vector<PatternVar> patternVars;
+    ExprPtr predicate;
+    if (!optPatternVarsWithCond(patternVars, predicate))
+        return false;
+    restore(e);
+    IdentifierPtr name;
+    if (!identifier(name))
+        return false;
+    vector<IdentifierPtr> params;
+    IdentifierPtr varParam;
+    if (!optStaticParams(params, varParam))
+        return false;
+    if (!opsymbol("="))
+        return false;
+    ExprPtr expr;
+    if (!expression(expr))
+        return false;
+    if (!symbol(";"))
+        return false;
+    x = new GlobalAlias(module, name, vis, patternVars, predicate, params,
+                        varParam, expr);
+    x->location = location;
+    return true;
+}
 
-        if (!next(t) || t->tokenKind != T_DOC_TEXT) return false;
-        auto value = llvm::StringRef(t->str);
+//
+// imports
+//
 
-        an.insert(std::pair<DocumentationAnnotation, string>(ano, value.str()));
-        return true;
-    }
+static bool importAlias(IdentifierPtr &x) {
+    if (!keyword("as"))
+        return false;
+    if (!identifier(x))
+        return false;
+    return true;
+}
 
-    static bool documentationText(std::string &text) {
-        Token *t;
-        if (!next(t) || t->tokenKind != T_DOC_TEXT) return false;
-        if (parserOptionKeepDocumentation)
-            text.append(t->str.str());
-        text.append("\n");
-        return true;
+static bool optImportAlias(IdentifierPtr &x) {
+    unsigned p = save();
+    if (!importAlias(x)) {
+        restore(p);
+        x = nullptr;
     }
+    return true;
+}
+
+static bool importModule(ImportPtr &x) {
+    Location location = currentLocation();
+    DottedNamePtr y;
+    if (!dottedName(y))
+        return false;
+    IdentifierPtr z;
+    if (!optImportAlias(z))
+        return false;
+    x = new ImportModule(y, z);
+    x->location = location;
+    return true;
+}
 
-    static bool documentation(TopLevelItemPtr &x, Module *module) {
-        Location location = currentLocation();
-        std::map<DocumentationAnnotation, string> annotation;
-        std::string text;
+static bool importStar(ImportPtr &x) {
+    Location location = currentLocation();
+    DottedNamePtr y;
+    if (!dottedName(y))
+        return false;
+    if (!symbol("."))
+        return false;
+    if (!opsymbol("*"))
+        return false;
+    x = new ImportStar(y);
+    x->location = location;
+    return true;
+}
 
-        bool success = false;
-        bool hasAttachmentAnnotation = false;
+static bool importedMember(ImportedMember &x) {
+    if (!topLevelVisibility(x.visibility))
+        return false;
+    if (!identifier(x.name))
+        return false;
+    if (!optImportAlias(x.alias))
+        return false;
+    return true;
+}
 
-        for (;;) {
-            unsigned p = save();
-            if (documentationAnnotation(annotation)) {
-                if (hasAttachmentAnnotation) {
-                    restore(p);
-                    break;
-                }
-                hasAttachmentAnnotation = true;
-                success = true;
-                continue;
-            }
+static bool importedMemberList(vector<ImportedMember> &x) {
+    ImportedMember y;
+    if (!importedMember(y))
+        return false;
+    x.clear();
+    while (true) {
+        x.push_back(y);
+        unsigned p = save();
+        if (!symbol(",")) {
             restore(p);
-            if (documentationText(text)) {
-                success = true;
-                continue;
-            }
+            break;
+        }
+        p = save();
+        if (!importedMember(y)) {
             restore(p);
             break;
         }
+    }
+    return true;
+}
 
-        if (success) {
-            x = new Documentation(module, annotation, text);
-            return true;
-        }
+static bool importMembers(ImportPtr &x) {
+    Location location = currentLocation();
+    DottedNamePtr y;
+    if (!dottedName(y))
         return false;
-    }
+    if (!symbol("."))
+        return false;
+    if (!symbol("("))
+        return false;
+    ImportMembersPtr z = new ImportMembers(y);
+    if (!importedMemberList(z->members))
+        return false;
+    if (!symbol(")"))
+        return false;
+    x = z.ptr();
+    x->location = location;
+    return true;
+}
 
-    //
-    // module
-    //
+static bool import2(ImportPtr &x, Visibility visTop) {
+    Visibility vis;
+    if (!importVisibility(vis))
+        return false;
+    unsigned p = save();
+    if (importStar(x))
+        goto importsuccess;
+    if (restore(p), importMembers(x))
+        goto importsuccess;
+    if (restore(p), importModule(x))
+        goto importsuccess;
+    return false;
+importsuccess:
+    if (vis == VISIBILITY_UNDEFINED) {
+        if (visTop == VISIBILITY_UNDEFINED)
+            x->visibility = PRIVATE;
+        else
+            x->visibility = visTop;
+    } else
+        x->visibility = vis;
+    return true;
+}
 
-    static bool topLevelItem(vector<TopLevelItemPtr> &x, Module *module) {
+static bool importList(vector<ImportPtr> &x, Visibility vis) {
+    ImportPtr y;
+    if (!import2(y, vis))
+        return false;
+    while (true) {
+        x.push_back(y);
         unsigned p = save();
+        if (!symbol(",") || !import2(y, vis)) {
+            restore(p);
+            break;
+        }
+    }
+    return true;
+}
 
-        TopLevelItemPtr y;
-        skipOptPatternVar();
-        unsigned q = save();
-        if (restore(q), overload(y, module, p)) goto success;
-        if (restore(q), procedureWithInterface(x, module, p)) goto success2;
-        if (restore(q), procedureWithBody(x, module, p)) goto success2;
-        if (restore(q), record(y, module, p)) goto success;
-        if (restore(q), variant(y, module, p)) goto success;
-        if (restore(q), instance(y, module, p)) goto success;
-        if (restore(q), enumeration(y, module, p)) goto success;
-        if (restore(q), globalVariable(y, module, p)) goto success;
-        if (restore(q), globalAlias(y, module, p)) goto success;
-        if (restore(p), procedure(y, module)) goto success;
-        if (restore(p), documentation(y, module)) goto success;
-        if (restore(p), llvmProcedure(x, module)) goto success2;
-        if (restore(p), external(y, module)) goto success;
-        if (restore(p), externalVariable(y, module)) goto success;
-        if (restore(p), newtype(y, module)) goto success;
-        if (restore(p), evalTopLevel(y, module)) goto success;
-        if (restore(p), staticAssertTopLevel(y, module)) goto success;
-        return false;
-    success :
-        assert(y.ptr());
-        x.push_back(y);
-    success2 :
-        return true;
+static bool import(vector<ImportPtr> &x) {
+    Visibility vis;
+    if (!importVisibility(vis))
+        return false;
+    if (!keyword("import"))
+        return false;
+    if (!importList(x, vis))
+        return false;
+    if (!symbol(";"))
+        return false;
+    return true;
+}
+
+static bool imports(vector<ImportPtr> &x) {
+    x.clear();
+    while (true) {
+        unsigned p = save();
+        if (!import(x)) {
+            restore(p);
+            break;
+        }
     }
+    return true;
+}
 
-    static bool topLevelItems(vector<TopLevelItemPtr> &x, Module *module) {
-        x.clear();
+static bool evalTopLevel(TopLevelItemPtr &x, Module *module) {
+    Location location = currentLocation();
+    if (!keyword("eval"))
+        return false;
+    ExprListPtr args;
+    if (!expressionList(args))
+        return false;
+    if (!symbol(";"))
+        return false;
+    x = new EvalTopLevel(module, args);
+    x->location = location;
+    return true;
+}
+
+//
+// documentation
+//
+
+static bool
+documentationAnnotation(std::map<DocumentationAnnotation, string> &an) {
+    Location location = currentLocation();
+    Token *t;
+    if (!next(t) || t->tokenKind != T_DOC_PROPERTY)
+        return false;
+    auto key = llvm::StringRef(t->str);
+
+    DocumentationAnnotation ano;
+    if (key == "section") {
+        ano = SectionAnnotation;
+    } else if (key == "module") {
+        ano = ModuleAnnotation;
+    } else if (key == "overload" || key == "default") {
+        ano = OverloadAnnotation;
+    } else if (key == "record") {
+        ano = RecordAnnotation;
+    } else {
+        ano = InvalidAnnotation;
+        pushLocation(location);
+        fmtError("invalid annotation '%s'\n", key.str().c_str());
+    }
+
+    if (!next(t) || t->tokenKind != T_DOC_TEXT)
+        return false;
+    auto value = llvm::StringRef(t->str);
+
+    an.insert(std::pair<DocumentationAnnotation, string>(ano, value.str()));
+    return true;
+}
+
+static bool documentationText(std::string &text) {
+    Token *t;
+    if (!next(t) || t->tokenKind != T_DOC_TEXT)
+        return false;
+    if (parserOptionKeepDocumentation)
+        text.append(t->str.str());
+    text.append("\n");
+    return true;
+}
+
+static bool documentation(TopLevelItemPtr &x, Module *module) {
+    Location location = currentLocation();
+    std::map<DocumentationAnnotation, string> annotation;
+    std::string text;
+
+    bool success = false;
+    bool hasAttachmentAnnotation = false;
 
-        while (true) {
-            unsigned p = save();
-            if (!topLevelItem(x, module)) {
+    for (;;) {
+        unsigned p = save();
+        if (documentationAnnotation(annotation)) {
+            if (hasAttachmentAnnotation) {
                 restore(p);
                 break;
             }
+            hasAttachmentAnnotation = true;
+            success = true;
+            continue;
         }
-        return true;
+        restore(p);
+        if (documentationText(text)) {
+            success = true;
+            continue;
+        }
+        restore(p);
+        break;
     }
 
-    static bool optModuleDeclarationAttributes(ExprListPtr &x) {
-        unsigned p = save();
-        if (!symbol("(")) {
-            restore(p);
-            x = nullptr;
-            return true;
-        }
-        if (!optExpressionList(x))
-            return false;
-        if (!symbol(")"))
-            return false;
+    if (success) {
+        x = new Documentation(module, annotation, text);
         return true;
     }
+    return false;
+}
 
-    static bool optModuleDeclaration(ModuleDeclarationPtr &x) {
-        Location location = currentLocation();
+//
+// module
+//
+
+static bool topLevelItem(vector<TopLevelItemPtr> &x, Module *module) {
+    unsigned p = save();
+
+    TopLevelItemPtr y;
+    skipOptPatternVar();
+    unsigned q = save();
+    if (restore(q), overload(y, module, p))
+        goto success;
+    if (restore(q), procedureWithInterface(x, module, p))
+        goto success2;
+    if (restore(q), procedureWithBody(x, module, p))
+        goto success2;
+    if (restore(q), record(y, module, p))
+        goto success;
+    if (restore(q), variant(y, module, p))
+        goto success;
+    if (restore(q), instance(y, module, p))
+        goto success;
+    if (restore(q), enumeration(y, module, p))
+        goto success;
+    if (restore(q), globalVariable(y, module, p))
+        goto success;
+    if (restore(q), globalAlias(y, module, p))
+        goto success;
+    if (restore(p), procedure(y, module))
+        goto success;
+    if (restore(p), documentation(y, module))
+        goto success;
+    if (restore(p), llvmProcedure(x, module))
+        goto success2;
+    if (restore(p), external(y, module))
+        goto success;
+    if (restore(p), externalVariable(y, module))
+        goto success;
+    if (restore(p), newtype(y, module))
+        goto success;
+    if (restore(p), evalTopLevel(y, module))
+        goto success;
+    if (restore(p), staticAssertTopLevel(y, module))
+        goto success;
+    return false;
+success:
+    assert(y.ptr());
+    x.push_back(y);
+success2:
+    return true;
+}
+
+static bool topLevelItems(vector<TopLevelItemPtr> &x, Module *module) {
+    x.clear();
 
+    while (true) {
         unsigned p = save();
-        if (!keyword("in")) {
+        if (!topLevelItem(x, module)) {
             restore(p);
-            x = nullptr;
-            return true;
+            break;
         }
-        DottedNamePtr name;
-        ExprListPtr attributes;
-        if (!dottedName(name))
-            return false;
-        if (!optModuleDeclarationAttributes(attributes))
-            return false;
-        if (!symbol(";"))
-            return false;
-
-        x = new ModuleDeclaration(name, attributes);
-        x->location = location;
-        return true;
     }
+    return true;
+}
 
-    static bool optTopLevelLLVM(LLVMCodePtr &x) {
-        unsigned p = save();
-        if (!llvmCode(x)) {
-            restore(p);
-            x = nullptr;
-        }
+static bool optModuleDeclarationAttributes(ExprListPtr &x) {
+    unsigned p = save();
+    if (!symbol("(")) {
+        restore(p);
+        x = nullptr;
         return true;
     }
+    if (!optExpressionList(x))
+        return false;
+    if (!symbol(")"))
+        return false;
+    return true;
+}
 
-    static bool module(llvm::StringRef moduleName, ModulePtr &x) {
-        Location location = currentLocation();
-        ModulePtr y = new Module(moduleName);
-        if (!imports(y->imports)) return false;
-        if (!optModuleDeclaration(y->declaration)) return false;
-        if (!optTopLevelLLVM(y->topLevelLLVM)) return false;
-        if (!topLevelItems(y->topLevelItems, y.ptr())) return false;
-        x = y.ptr();
-        x->location = location;
+static bool optModuleDeclaration(ModuleDeclarationPtr &x) {
+    Location location = currentLocation();
+
+    unsigned p = save();
+    if (!keyword("in")) {
+        restore(p);
+        x = nullptr;
         return true;
     }
+    DottedNamePtr name;
+    ExprListPtr attributes;
+    if (!dottedName(name))
+        return false;
+    if (!optModuleDeclarationAttributes(attributes))
+        return false;
+    if (!symbol(";"))
+        return false;
 
-    //
-    // REPL
-    //
+    x = new ModuleDeclaration(name, attributes);
+    x->location = location;
+    return true;
+}
 
-    static bool replItems(ReplItem &x, bool = false) {
-        inRepl = false;
-        unsigned p = save();
-        if (expression(x.expr) && position == tokens->size()) {
-            x.isExprSet = true;
-            return true;
-        }
+static bool optTopLevelLLVM(LLVMCodePtr &x) {
+    unsigned p = save();
+    if (!llvmCode(x)) {
         restore(p);
+        x = nullptr;
+    }
+    return true;
+}
 
-        inRepl = true;
-        x.toplevels.clear();
-        x.imports.clear();
-        x.stmts.clear();
-        StatementPtr stmtItem;
+static bool module(llvm::StringRef moduleName, ModulePtr &x) {
+    Location location = currentLocation();
+    ModulePtr y = new Module(moduleName);
+    if (!imports(y->imports))
+        return false;
+    if (!optModuleDeclaration(y->declaration))
+        return false;
+    if (!optTopLevelLLVM(y->topLevelLLVM))
+        return false;
+    if (!topLevelItems(y->topLevelItems, y.ptr()))
+        return false;
+    x = y.ptr();
+    x->location = location;
+    return true;
+}
 
-        while (true) {
-            if (position == tokens->size()) {
-                break;
-            }
+//
+// REPL
+//
 
-            unsigned i = save();
+static bool replItems(ReplItem &x, bool = false) {
+    inRepl = false;
+    unsigned p = save();
+    if (expression(x.expr) && position == tokens->size()) {
+        x.isExprSet = true;
+        return true;
+    }
+    restore(p);
 
-            if (!topLevelItem(x.toplevels, nullptr)) {
-                restore(i);
-            } else {
-                continue;
-            }
+    inRepl = true;
+    x.toplevels.clear();
+    x.imports.clear();
+    x.stmts.clear();
+    StatementPtr stmtItem;
 
-            if (!import(x.imports)) {
-                restore(i);
-            } else {
-                continue;
-            }
+    while (true) {
+        if (position == tokens->size()) {
+            break;
+        }
 
-            if (!blockItem(stmtItem)) {
-                restore(i);
-                break;
-            } else {
-                x.stmts.push_back(stmtItem);
-            }
+        unsigned i = save();
+
+        if (!topLevelItem(x.toplevels, nullptr)) {
+            restore(i);
+        } else {
+            continue;
         }
 
-        x.isExprSet = false;
+        if (!import(x.imports)) {
+            restore(i);
+        } else {
+            continue;
+        }
 
-        return true;
+        if (!blockItem(stmtItem)) {
+            restore(i);
+            break;
+        } else {
+            x.stmts.push_back(stmtItem);
+        }
     }
 
-    //
-    // parse
-    //
+    x.isExprSet = false;
 
-    template<typename Parser, typename ParserParam, typename Node>
-    void applyParser(const SourcePtr& source, unsigned offset, size_t length, Parser parser, ParserParam parserParam,
-                     Node &node) {
-        vector<Token> t;
-        tokenize(source, offset, length, t);
+    return true;
+}
 
-        tokens = &t;
-        position = maxPosition = 0;
+//
+// parse
+//
 
-        if (!parser(node, parserParam) || (position < t.size())) {
-            Location location;
-            if (maxPosition == t.size())
-                location = Location(source.ptr(), static_cast<unsigned>(source->size()));
-            else
-                location = t[maxPosition].location;
-            pushLocation(location);
-            error("parse error");
-        }
+template <typename Parser, typename ParserParam, typename Node>
+void applyParser(const SourcePtr &source, unsigned offset, size_t length,
+                 Parser parser, ParserParam parserParam, Node &node) {
+    vector<Token> t;
+    tokenize(source, offset, length, t);
 
-        tokens = nullptr;
-        position = maxPosition = 0;
+    tokens = &t;
+    position = maxPosition = 0;
+
+    if (!parser(node, parserParam) || (position < t.size())) {
+        Location location;
+        if (maxPosition == t.size())
+            location =
+                Location(source.ptr(), static_cast<unsigned>(source->size()));
+        else
+            location = t[maxPosition].location;
+        pushLocation(location);
+        error("parse error");
     }
 
-    struct ModuleParser {
-        llvm::StringRef moduleName;
-        bool operator()(ModulePtr &m, Module *) const { return module(moduleName, m); }
-    };
+    tokens = nullptr;
+    position = maxPosition = 0;
+}
 
-    ModulePtr parse(llvm::StringRef moduleName, const SourcePtr &source, ParserFlags flags) {
-        if (flags)
-            parserOptionKeepDocumentation = true;
-        ModulePtr m;
-        ModuleParser p = {moduleName};
-        applyParser(source, 0, source->size(), p, m.ptr(), m);
-        m->source = source;
-        return m;
-    }
+struct ModuleParser {
+    llvm::StringRef moduleName;
+    bool operator()(ModulePtr &m, Module *) const {
+        return module(moduleName, m);
+    }
+};
+
+ModulePtr parse(llvm::StringRef moduleName, const SourcePtr &source,
+                ParserFlags flags) {
+    if (flags)
+        parserOptionKeepDocumentation = true;
+    ModulePtr m;
+    ModuleParser p = {moduleName};
+    applyParser(source, 0, source->size(), p, m.ptr(), m);
+    m->source = source;
+    return m;
+}
 
-    //
-    // parseExpr
-    //
+//
+// parseExpr
+//
 
-    ExprPtr parseExpr(const SourcePtr &source, unsigned offset, size_t length) {
-        ExprPtr expr;
-        applyParser(source, offset, length, expression, false, expr);
-        return expr;
-    }
+ExprPtr parseExpr(const SourcePtr &source, unsigned offset, size_t length) {
+    ExprPtr expr;
+    applyParser(source, offset, length, expression, false, expr);
+    return expr;
+}
 
-    //
-    // parseExprList
-    //
+//
+// parseExprList
+//
 
-    ExprListPtr parseExprList(const SourcePtr &source, unsigned offset, size_t length) {
-        ExprListPtr exprList;
-        applyParser(source, offset, length, expressionList, false, exprList);
-        return exprList;
-    }
+ExprListPtr parseExprList(const SourcePtr &source, unsigned offset,
+                          size_t length) {
+    ExprListPtr exprList;
+    applyParser(source, offset, length, expressionList, false, exprList);
+    return exprList;
+}
 
-    //
-    // parseStatements
-    //
+//
+// parseStatements
+//
 
-    void parseStatements(const SourcePtr &source, unsigned offset, size_t length,
-                         vector<StatementPtr> &stmts) {
-        applyParser(source, offset, length, blockItems, false, stmts);
-    }
+void parseStatements(const SourcePtr &source, unsigned offset, size_t length,
+                     vector<StatementPtr> &stmts) {
+    applyParser(source, offset, length, blockItems, false, stmts);
+}
 
-    //
-    // parseTopLevelItems
-    //
+//
+// parseTopLevelItems
+//
 
-    void parseTopLevelItems(const SourcePtr &source, unsigned offset, size_t length,
-                            vector<TopLevelItemPtr> &topLevels, Module *module) {
-        applyParser(source, offset, length, topLevelItems, module, topLevels);
-    }
+void parseTopLevelItems(const SourcePtr &source, unsigned offset, size_t length,
+                        vector<TopLevelItemPtr> &topLevels, Module *module) {
+    applyParser(source, offset, length, topLevelItems, module, topLevels);
+}
 
-    //
-    // parseInteractive
-    //
+//
+// parseInteractive
+//
 
-    ReplItem parseInteractive(const SourcePtr &source, unsigned offset, size_t length) {
-        ReplItem x;
-        applyParser(source, offset, length, replItems, false, x);
-        return x;
-    }
+ReplItem parseInteractive(const SourcePtr &source, unsigned offset,
+                          size_t length) {
+    ReplItem x;
+    applyParser(source, offset, length, replItems, false, x);
+    return x;
 }
+} // namespace clay
diff --git a/compiler/parser.hpp b/compiler/parser.hpp
index a8243843..0dbab8c5 100644
--- a/compiler/parser.hpp
+++ b/compiler/parser.hpp
@@ -4,34 +4,34 @@
 #include "lexer.hpp"
 
 namespace clay {
-    enum ParserFlags {
-        NoParserFlags = 0,
-        ParserKeepDocumentation = 1
-    };
+enum ParserFlags { NoParserFlags = 0, ParserKeepDocumentation = 1 };
 
-    struct ReplItem {
-        bool isExprSet;
-        ExprPtr expr;
-        vector<TopLevelItemPtr> toplevels;
-        vector<ImportPtr> imports;
-        vector<StatementPtr> stmts;
-    };
+struct ReplItem {
+    bool isExprSet;
+    ExprPtr expr;
+    vector<TopLevelItemPtr> toplevels;
+    vector<ImportPtr> imports;
+    vector<StatementPtr> stmts;
+};
 
-    ModulePtr parse(llvm::StringRef moduleName, const SourcePtr &source, ParserFlags flags = NoParserFlags);
+ModulePtr parse(llvm::StringRef moduleName, const SourcePtr &source,
+                ParserFlags flags = NoParserFlags);
 
-    ExprPtr parseExpr(const SourcePtr &source, unsigned offset, size_t length);
+ExprPtr parseExpr(const SourcePtr &source, unsigned offset, size_t length);
 
-    ExprListPtr parseExprList(const SourcePtr &source, unsigned offset, size_t length);
+ExprListPtr parseExprList(const SourcePtr &source, unsigned offset,
+                          size_t length);
 
-    void parseStatements(const SourcePtr &source, unsigned offset, size_t length,
-                         vector<StatementPtr> &statements);
+void parseStatements(const SourcePtr &source, unsigned offset, size_t length,
+                     vector<StatementPtr> &statements);
 
-    void parseTopLevelItems(const SourcePtr &source, unsigned offset, size_t length,
-                            vector<TopLevelItemPtr> &topLevels, Module *);
+void parseTopLevelItems(const SourcePtr &source, unsigned offset, size_t length,
+                        vector<TopLevelItemPtr> &topLevels, Module *);
 
-    ReplItem parseInteractive(const SourcePtr &source, unsigned offset, size_t length);
+ReplItem parseInteractive(const SourcePtr &source, unsigned offset,
+                          size_t length);
 
-    typedef vector<Token> (*AddTokensCallback)();
+typedef vector<Token> (*AddTokensCallback)();
 
-    void setAddTokens(AddTokensCallback f);
-}
+void setAddTokens(AddTokensCallback f);
+} // namespace clay
diff --git a/compiler/patterns.cpp b/compiler/patterns.cpp
index 752c4d10..9c50777f 100644
--- a/compiler/patterns.cpp
+++ b/compiler/patterns.cpp
@@ -1,727 +1,728 @@
+#include "patterns.hpp"
+#include "analyzer.hpp"
 #include "clay.hpp"
 #include "codegen.hpp"
+#include "env.hpp"
+#include "error.hpp"
 #include "evaluator.hpp"
 #include "loader.hpp"
-#include "operators.hpp"
-#include "patterns.hpp"
-#include "analyzer.hpp"
-#include "env.hpp"
 #include "objects.hpp"
-#include "error.hpp"
+#include "operators.hpp"
 
 #pragma clang diagnostic ignored "-Wcovered-switch-default"
 
 namespace clay {
-    //
-    // derefDeep
-    //
-
-    static ObjectPtr computeStruct(ObjectPtr head, MultiStaticPtr params) {
-        if (!head) {
-            return makeTupleValue(params->values);
-        } else {
-            TypePtr t = constructType(head, params);
-            return t.ptr();
-        }
+//
+// derefDeep
+//
+
+static ObjectPtr computeStruct(ObjectPtr head, MultiStaticPtr params) {
+    if (!head) {
+        return makeTupleValue(params->values);
+    } else {
+        TypePtr t = constructType(head, params);
+        return t.ptr();
     }
+}
 
-    ObjectPtr derefDeep(PatternPtr x) {
-        switch (x->kind) {
-            case PATTERN_CELL: {
-                PatternCell *y = (PatternCell *) x.ptr();
-                if (y->obj.ptr() && (y->obj->objKind == PATTERN)) {
-                    Pattern *z = (Pattern *) y->obj.ptr();
-                    return derefDeep(z);
-                }
-                return y->obj;
-            }
-            case PATTERN_STRUCT: {
-                PatternStruct *y = (PatternStruct *) x.ptr();
-                MultiStaticPtr params = derefDeep(y->params);
-                if (!params)
-                    return nullptr;
-                return computeStruct(y->head, params);
-            }
-            default:
-                assert(false);
-                return nullptr;
+ObjectPtr derefDeep(PatternPtr x) {
+    switch (x->kind) {
+    case PATTERN_CELL: {
+        PatternCell *y = (PatternCell *)x.ptr();
+        if (y->obj.ptr() && (y->obj->objKind == PATTERN)) {
+            Pattern *z = (Pattern *)y->obj.ptr();
+            return derefDeep(z);
         }
+        return y->obj;
     }
+    case PATTERN_STRUCT: {
+        PatternStruct *y = (PatternStruct *)x.ptr();
+        MultiStaticPtr params = derefDeep(y->params);
+        if (!params)
+            return nullptr;
+        return computeStruct(y->head, params);
+    }
+    default:
+        assert(false);
+        return nullptr;
+    }
+}
 
-    MultiStaticPtr derefDeep(MultiPatternPtr x) {
-        switch (x->kind) {
-            case MULTI_PATTERN_CELL: {
-                MultiPatternCell *y = (MultiPatternCell *) x.ptr();
-                if (!y->data)
-                    return nullptr;
-                return derefDeep(y->data);
-            }
-            case MULTI_PATTERN_LIST: {
-                MultiPatternList *y = (MultiPatternList *) x.ptr();
-                MultiStaticPtr out = new MultiStatic();
-                for (size_t i = 0; i < y->items.size(); ++i) {
-                    ObjectPtr z = derefDeep(y->items[i]);
-                    if (!z)
-                        return nullptr;
-                    out->add(z);
-                }
-                if (y->tail.ptr()) {
-                    MultiStaticPtr tail = derefDeep(y->tail);
-                    if (!tail)
-                        return nullptr;
-                    out->add(tail);
-                }
-                return out;
-            }
-            default:
-                assert(false);
+MultiStaticPtr derefDeep(MultiPatternPtr x) {
+    switch (x->kind) {
+    case MULTI_PATTERN_CELL: {
+        MultiPatternCell *y = (MultiPatternCell *)x.ptr();
+        if (!y->data)
+            return nullptr;
+        return derefDeep(y->data);
+    }
+    case MULTI_PATTERN_LIST: {
+        MultiPatternList *y = (MultiPatternList *)x.ptr();
+        MultiStaticPtr out = new MultiStatic();
+        for (size_t i = 0; i < y->items.size(); ++i) {
+            ObjectPtr z = derefDeep(y->items[i]);
+            if (!z)
                 return nullptr;
+            out->add(z);
         }
-    }
-
-    //
-    // objectToPattern, objectToPatternStruct
-    //
-
-    static PatternPtr objectToPattern(ObjectPtr obj) {
-        switch (obj->objKind) {
-            case PATTERN: {
-                Pattern *x = (Pattern *) obj.ptr();
-                return x;
-            }
-            case MULTI_PATTERN: {
-                error("incorrect usage of multi-valued pattern "
-                    "in single valued context");
+        if (y->tail.ptr()) {
+            MultiStaticPtr tail = derefDeep(y->tail);
+            if (!tail)
                 return nullptr;
-            }
-            case VALUE_HOLDER: {
-                ValueHolder *x = (ValueHolder *) obj.ptr();
-                if (x->type->typeKind == TUPLE_TYPE) {
-                    TupleType *tt = (TupleType *) x->type.ptr();
-                    const llvm::StructLayout *layout = tupleTypeLayout(tt);
-                    MultiPatternListPtr params = new MultiPatternList();
-                    for (unsigned i = 0; i < tt->elementTypes.size(); ++i) {
-                        char *addr = x->buf + layout->getElementOffset(i);
-                        EValuePtr evElement = new EValue(tt->elementTypes[i], addr);
-                        PatternPtr y = objectToPattern(evalueToStatic(evElement));
-                        params->items.push_back(y);
-                    }
-                    return new PatternStruct(nullptr, params.ptr());
-                }
-                return new PatternCell(obj);
-            }
-            case TYPE: {
-                Type *t = (Type *) obj.ptr();
-                switch (t->typeKind) {
-                    case POINTER_TYPE: {
-                        PointerType *pt = (PointerType *) t;
-                        ObjectPtr head = primitive_Pointer();
-                        MultiPatternListPtr params = new MultiPatternList();
-                        params->items.push_back(objectToPattern(pt->pointeeType.ptr()));
-                        return new PatternStruct(head, params.ptr());
-                    }
-                    case CODE_POINTER_TYPE: {
-                        CodePointerType *cpt = (CodePointerType *) t;
-                        ObjectPtr head = primitive_CodePointer();
-                        MultiPatternListPtr argTypes = new MultiPatternList();
-                        for (size_t i = 0; i < cpt->argTypes.size(); ++i) {
-                            PatternPtr x = objectToPattern(cpt->argTypes[i].ptr());
-                            argTypes->items.push_back(x);
-                        }
-                        MultiPatternListPtr returnTypes = new MultiPatternList();
-                        for (size_t i = 0; i < cpt->returnTypes.size(); ++i) {
-                            TypePtr t = cpt->returnTypes[i];
-                            if (cpt->returnIsRef[i]) {
-                                ObjectPtr obj = primitive_ByRef();
-                                assert(obj->objKind == RECORD_DECL);
-                                t = recordType((RecordDecl *) obj.ptr(),
-                                               vector<ObjectPtr>(1, t.ptr()));
-                            }
-                            PatternPtr x = objectToPattern(t.ptr());
-                            returnTypes->items.push_back(x);
-                        }
-                        MultiPatternListPtr params = new MultiPatternList();
-                        PatternPtr a = new PatternStruct(nullptr, argTypes.ptr());
-                        PatternPtr b = new PatternStruct(nullptr, returnTypes.ptr());
-                        params->items.push_back(a);
-                        params->items.push_back(b);
-                        return new PatternStruct(head, params.ptr());
-                    }
-                    case CCODE_POINTER_TYPE: {
-                        CCodePointerType *cpt = (CCodePointerType *) t;
-                        ObjectPtr head = primitive_ExternalCodePointer();;
-                        ObjectPtr ccParam;
-
-                        switch (cpt->callingConv) {
-                            case CC_DEFAULT:
-                                ccParam = primitive_AttributeCCall();
-                                break;
-                            case CC_STDCALL:
-                                ccParam = primitive_AttributeStdCall();
-                                break;
-                            case CC_FASTCALL:
-                                ccParam = primitive_AttributeFastCall();
-                                break;
-                            case CC_THISCALL:
-                                ccParam = primitive_AttributeThisCall();
-                                break;
-                            case CC_LLVM:
-                                ccParam = primitive_AttributeLLVMCall();
-                                break;
-                            default:
-                                assert(false);
-                        }
-                        assert(ccParam != nullptr);
-
-                        ValueHolderPtr varArgParam = boolToValueHolder(cpt->hasVarArgs);
-
-                        MultiPatternListPtr argTypes = new MultiPatternList();
-                        for (size_t i = 0; i < cpt->argTypes.size(); ++i) {
-                            PatternPtr x = objectToPattern(cpt->argTypes[i].ptr());
-                            argTypes->items.push_back(x);
-                        }
-                        MultiPatternListPtr returnTypes = new MultiPatternList();
-                        if (cpt->returnType.ptr()) {
-                            PatternPtr x = objectToPattern(cpt->returnType.ptr());
-                            returnTypes->items.push_back(x);
-                        }
-                        MultiPatternListPtr params = new MultiPatternList();
-                        PatternPtr argTypesParam = new PatternStruct(nullptr, argTypes.ptr());
-                        PatternPtr retTypesParam = new PatternStruct(nullptr, returnTypes.ptr());
-                        params->items.push_back(objectToPattern(ccParam));
-                        params->items.push_back(objectToPattern(varArgParam.ptr()));
-                        params->items.push_back(argTypesParam);
-                        params->items.push_back(retTypesParam);
-                        return new PatternStruct(head, params.ptr());
-                    }
-                    case ARRAY_TYPE: {
-                        ArrayType *at = (ArrayType *) t;
-                        ObjectPtr head = primitive_Array();
-                        MultiPatternListPtr params = new MultiPatternList();
-                        params->items.push_back(objectToPattern(at->elementType.ptr()));
-                        ValueHolderPtr vh = intToValueHolder((int) at->size);
-                        params->items.push_back(objectToPattern(vh.ptr()));
-                        return new PatternStruct(head, params.ptr());
-                    }
-                    case VEC_TYPE: {
-                        VecType *vt = (VecType *) t;
-                        ObjectPtr head = primitive_Vec();
-                        MultiPatternListPtr params = new MultiPatternList();
-                        params->items.push_back(objectToPattern(vt->elementType.ptr()));
-                        ValueHolderPtr vh = intToValueHolder((int) vt->size);
-                        params->items.push_back(objectToPattern(vh.ptr()));
-                        return new PatternStruct(head, params.ptr());
-                    }
-                    case TUPLE_TYPE: {
-                        TupleType *tt = (TupleType *) t;
-                        ObjectPtr head = primitive_Tuple();
-                        MultiPatternListPtr params = new MultiPatternList();
-                        for (size_t i = 0; i < tt->elementTypes.size(); ++i) {
-                            PatternPtr x = objectToPattern(tt->elementTypes[i].ptr());
-                            params->items.push_back(x);
-                        }
-                        return new PatternStruct(head, params.ptr());
-                    }
-                    case UNION_TYPE: {
-                        UnionType *ut = (UnionType *) t;
-                        ObjectPtr head = primitive_Union();
-                        MultiPatternListPtr params = new MultiPatternList();
-                        for (size_t i = 0; i < ut->memberTypes.size(); ++i) {
-                            PatternPtr x = objectToPattern(ut->memberTypes[i].ptr());
-                            params->items.push_back(x);
-                        }
-                        return new PatternStruct(head, params.ptr());
-                    }
-                    case STATIC_TYPE: {
-                        StaticType *st = (StaticType *) t;
-                        ObjectPtr head = primitive_Static();
-                        MultiPatternListPtr params = new MultiPatternList();
-                        params->items.push_back(objectToPattern(st->obj));
-                        return new PatternStruct(head, params.ptr());
-                    }
-                    case RECORD_TYPE: {
-                        RecordType *rt = (RecordType *) t;
-                        ObjectPtr head = rt->record.ptr();
-                        MultiPatternListPtr params = new MultiPatternList();
-                        for (size_t i = 0; i < rt->params.size(); ++i) {
-                            PatternPtr x = objectToPattern(rt->params[i]);
-                            params->items.push_back(x);
-                        }
-                        return new PatternStruct(head, params.ptr());
-                    }
-                    case VARIANT_TYPE: {
-                        VariantType *vt = (VariantType *) t;
-                        ObjectPtr head = vt->variant.ptr();
-                        MultiPatternListPtr params = new MultiPatternList();
-                        for (size_t i = 0; i < vt->params.size(); ++i) {
-                            PatternPtr x = objectToPattern(vt->params[i]);
-                            params->items.push_back(x);
-                        }
-                        return new PatternStruct(head, params.ptr());
-                    }
-                    default:
-                        return new PatternCell(obj);
-                }
-            }
-            default:
-                return new PatternCell(obj);
+            out->add(tail);
         }
+        return out;
+    }
+    default:
+        assert(false);
+        return nullptr;
     }
+}
 
-    //
-    // unify
-    //
+//
+// objectToPattern, objectToPatternStruct
+//
 
-    bool unifyObjObj(ObjectPtr a, ObjectPtr b) {
-        if (a->objKind == PATTERN) {
-            PatternPtr a2 = (Pattern *) a.ptr();
-            return unifyPatternObj(a2, b);
-        } else if (a->objKind == MULTI_PATTERN) {
-            error("incorrect usage of multi-valued pattern "
-                "in single-valued context");
-            return false;
-        } else if (b->objKind == PATTERN) {
-            PatternPtr b2 = (Pattern *) b.ptr();
-            return unifyObjPattern(a, b2);
-        } else if (b->objKind == MULTI_PATTERN) {
-            error("incorrect usage of multi-valued pattern "
-                "in single-valued context");
-            return false;
+static PatternPtr objectToPattern(ObjectPtr obj) {
+    switch (obj->objKind) {
+    case PATTERN: {
+        Pattern *x = (Pattern *)obj.ptr();
+        return x;
+    }
+    case MULTI_PATTERN: {
+        error("incorrect usage of multi-valued pattern "
+              "in single valued context");
+        return nullptr;
+    }
+    case VALUE_HOLDER: {
+        ValueHolder *x = (ValueHolder *)obj.ptr();
+        if (x->type->typeKind == TUPLE_TYPE) {
+            TupleType *tt = (TupleType *)x->type.ptr();
+            const llvm::StructLayout *layout = tupleTypeLayout(tt);
+            MultiPatternListPtr params = new MultiPatternList();
+            for (unsigned i = 0; i < tt->elementTypes.size(); ++i) {
+                char *addr = x->buf + layout->getElementOffset(i);
+                EValuePtr evElement = new EValue(tt->elementTypes[i], addr);
+                PatternPtr y = objectToPattern(evalueToStatic(evElement));
+                params->items.push_back(y);
+            }
+            return new PatternStruct(nullptr, params.ptr());
         }
-        return objectEquals(a, b);
+        return new PatternCell(obj);
     }
-
-    bool unifyObjPattern(ObjectPtr a, PatternPtr b) {
-        assert(a.ptr() && b.ptr());
-        if (a->objKind == PATTERN) {
-            PatternPtr a2 = (Pattern *) a.ptr();
-            return unify(a2, b);
-        } else if (a->objKind == MULTI_PATTERN) {
-            error("incorrect usage of multi-valued pattern "
-                "in single-valued context");
-            return false;
-        } else if (b->kind == PATTERN_CELL) {
-            PatternCell *b2 = (PatternCell *) b.ptr();
-            if (!b2->obj) {
-                b2->obj = a;
-                return true;
-            }
-            return unifyObjObj(b2->obj, a);
-        } else {
-            assert(b->kind == PATTERN_STRUCT);
-            PatternPtr a2 = objectToPattern(a);
-            PatternStruct *b2 = (PatternStruct *) b.ptr();
-            if (a2->kind == PATTERN_STRUCT) {
-                PatternStruct *a3 = (PatternStruct *) a2.ptr();
-                if (a3->head == b2->head)
-                    return unifyMulti(a3->params, b2->params);
+    case TYPE: {
+        Type *t = (Type *)obj.ptr();
+        switch (t->typeKind) {
+        case POINTER_TYPE: {
+            PointerType *pt = (PointerType *)t;
+            ObjectPtr head = primitive_Pointer();
+            MultiPatternListPtr params = new MultiPatternList();
+            params->items.push_back(objectToPattern(pt->pointeeType.ptr()));
+            return new PatternStruct(head, params.ptr());
+        }
+        case CODE_POINTER_TYPE: {
+            CodePointerType *cpt = (CodePointerType *)t;
+            ObjectPtr head = primitive_CodePointer();
+            MultiPatternListPtr argTypes = new MultiPatternList();
+            for (size_t i = 0; i < cpt->argTypes.size(); ++i) {
+                PatternPtr x = objectToPattern(cpt->argTypes[i].ptr());
+                argTypes->items.push_back(x);
+            }
+            MultiPatternListPtr returnTypes = new MultiPatternList();
+            for (size_t i = 0; i < cpt->returnTypes.size(); ++i) {
+                TypePtr t = cpt->returnTypes[i];
+                if (cpt->returnIsRef[i]) {
+                    ObjectPtr obj = primitive_ByRef();
+                    assert(obj->objKind == RECORD_DECL);
+                    t = recordType((RecordDecl *)obj.ptr(),
+                                   vector<ObjectPtr>(1, t.ptr()));
+                }
+                PatternPtr x = objectToPattern(t.ptr());
+                returnTypes->items.push_back(x);
+            }
+            MultiPatternListPtr params = new MultiPatternList();
+            PatternPtr a = new PatternStruct(nullptr, argTypes.ptr());
+            PatternPtr b = new PatternStruct(nullptr, returnTypes.ptr());
+            params->items.push_back(a);
+            params->items.push_back(b);
+            return new PatternStruct(head, params.ptr());
+        }
+        case CCODE_POINTER_TYPE: {
+            CCodePointerType *cpt = (CCodePointerType *)t;
+            ObjectPtr head = primitive_ExternalCodePointer();
+            ;
+            ObjectPtr ccParam;
+
+            switch (cpt->callingConv) {
+            case CC_DEFAULT:
+                ccParam = primitive_AttributeCCall();
+                break;
+            case CC_STDCALL:
+                ccParam = primitive_AttributeStdCall();
+                break;
+            case CC_FASTCALL:
+                ccParam = primitive_AttributeFastCall();
+                break;
+            case CC_THISCALL:
+                ccParam = primitive_AttributeThisCall();
+                break;
+            case CC_LLVM:
+                ccParam = primitive_AttributeLLVMCall();
+                break;
+            default:
+                assert(false);
             }
-            return false;
+            assert(ccParam != nullptr);
+
+            ValueHolderPtr varArgParam = boolToValueHolder(cpt->hasVarArgs);
+
+            MultiPatternListPtr argTypes = new MultiPatternList();
+            for (size_t i = 0; i < cpt->argTypes.size(); ++i) {
+                PatternPtr x = objectToPattern(cpt->argTypes[i].ptr());
+                argTypes->items.push_back(x);
+            }
+            MultiPatternListPtr returnTypes = new MultiPatternList();
+            if (cpt->returnType.ptr()) {
+                PatternPtr x = objectToPattern(cpt->returnType.ptr());
+                returnTypes->items.push_back(x);
+            }
+            MultiPatternListPtr params = new MultiPatternList();
+            PatternPtr argTypesParam =
+                new PatternStruct(nullptr, argTypes.ptr());
+            PatternPtr retTypesParam =
+                new PatternStruct(nullptr, returnTypes.ptr());
+            params->items.push_back(objectToPattern(ccParam));
+            params->items.push_back(objectToPattern(varArgParam.ptr()));
+            params->items.push_back(argTypesParam);
+            params->items.push_back(retTypesParam);
+            return new PatternStruct(head, params.ptr());
+        }
+        case ARRAY_TYPE: {
+            ArrayType *at = (ArrayType *)t;
+            ObjectPtr head = primitive_Array();
+            MultiPatternListPtr params = new MultiPatternList();
+            params->items.push_back(objectToPattern(at->elementType.ptr()));
+            ValueHolderPtr vh = intToValueHolder((int)at->size);
+            params->items.push_back(objectToPattern(vh.ptr()));
+            return new PatternStruct(head, params.ptr());
+        }
+        case VEC_TYPE: {
+            VecType *vt = (VecType *)t;
+            ObjectPtr head = primitive_Vec();
+            MultiPatternListPtr params = new MultiPatternList();
+            params->items.push_back(objectToPattern(vt->elementType.ptr()));
+            ValueHolderPtr vh = intToValueHolder((int)vt->size);
+            params->items.push_back(objectToPattern(vh.ptr()));
+            return new PatternStruct(head, params.ptr());
+        }
+        case TUPLE_TYPE: {
+            TupleType *tt = (TupleType *)t;
+            ObjectPtr head = primitive_Tuple();
+            MultiPatternListPtr params = new MultiPatternList();
+            for (size_t i = 0; i < tt->elementTypes.size(); ++i) {
+                PatternPtr x = objectToPattern(tt->elementTypes[i].ptr());
+                params->items.push_back(x);
+            }
+            return new PatternStruct(head, params.ptr());
         }
+        case UNION_TYPE: {
+            UnionType *ut = (UnionType *)t;
+            ObjectPtr head = primitive_Union();
+            MultiPatternListPtr params = new MultiPatternList();
+            for (size_t i = 0; i < ut->memberTypes.size(); ++i) {
+                PatternPtr x = objectToPattern(ut->memberTypes[i].ptr());
+                params->items.push_back(x);
+            }
+            return new PatternStruct(head, params.ptr());
+        }
+        case STATIC_TYPE: {
+            StaticType *st = (StaticType *)t;
+            ObjectPtr head = primitive_Static();
+            MultiPatternListPtr params = new MultiPatternList();
+            params->items.push_back(objectToPattern(st->obj));
+            return new PatternStruct(head, params.ptr());
+        }
+        case RECORD_TYPE: {
+            RecordType *rt = (RecordType *)t;
+            ObjectPtr head = rt->record.ptr();
+            MultiPatternListPtr params = new MultiPatternList();
+            for (size_t i = 0; i < rt->params.size(); ++i) {
+                PatternPtr x = objectToPattern(rt->params[i]);
+                params->items.push_back(x);
+            }
+            return new PatternStruct(head, params.ptr());
+        }
+        case VARIANT_TYPE: {
+            VariantType *vt = (VariantType *)t;
+            ObjectPtr head = vt->variant.ptr();
+            MultiPatternListPtr params = new MultiPatternList();
+            for (size_t i = 0; i < vt->params.size(); ++i) {
+                PatternPtr x = objectToPattern(vt->params[i]);
+                params->items.push_back(x);
+            }
+            return new PatternStruct(head, params.ptr());
+        }
+        default:
+            return new PatternCell(obj);
+        }
+    }
+    default:
+        return new PatternCell(obj);
     }
+}
 
-    bool unifyPatternObj(PatternPtr a, ObjectPtr b) {
-        return unifyObjPattern(b, a);
+//
+// unify
+//
+
+bool unifyObjObj(ObjectPtr a, ObjectPtr b) {
+    if (a->objKind == PATTERN) {
+        PatternPtr a2 = (Pattern *)a.ptr();
+        return unifyPatternObj(a2, b);
+    } else if (a->objKind == MULTI_PATTERN) {
+        error("incorrect usage of multi-valued pattern "
+              "in single-valued context");
+        return false;
+    } else if (b->objKind == PATTERN) {
+        PatternPtr b2 = (Pattern *)b.ptr();
+        return unifyObjPattern(a, b2);
+    } else if (b->objKind == MULTI_PATTERN) {
+        error("incorrect usage of multi-valued pattern "
+              "in single-valued context");
+        return false;
     }
+    return objectEquals(a, b);
+}
 
-    bool unify(PatternPtr a, PatternPtr b) {
-        assert(a.ptr() && b.ptr());
-        if (a->kind == PATTERN_CELL) {
-            PatternCell *a2 = (PatternCell *) a.ptr();
-            if (!a2->obj) {
-                a2->obj = b.ptr();
-                return true;
-            }
-            return unifyObjPattern(a2->obj, b);
-        } else if (b->kind == PATTERN_CELL) {
-            PatternCell *b2 = (PatternCell *) b.ptr();
-            if (!b2->obj) {
-                b2->obj = a.ptr();
-                return true;
-            }
-            return unifyPatternObj(a, b2->obj);
-        } else {
-            assert(a->kind == PATTERN_STRUCT);
-            assert(b->kind == PATTERN_STRUCT);
-            PatternStruct *a2 = (PatternStruct *) a.ptr();
-            PatternStruct *b2 = (PatternStruct *) b.ptr();
-            if (a2->head == b2->head) {
-                return unifyMulti(a2->params, b2->params);
-            }
-            return false;
+bool unifyObjPattern(ObjectPtr a, PatternPtr b) {
+    assert(a.ptr() && b.ptr());
+    if (a->objKind == PATTERN) {
+        PatternPtr a2 = (Pattern *)a.ptr();
+        return unify(a2, b);
+    } else if (a->objKind == MULTI_PATTERN) {
+        error("incorrect usage of multi-valued pattern "
+              "in single-valued context");
+        return false;
+    } else if (b->kind == PATTERN_CELL) {
+        PatternCell *b2 = (PatternCell *)b.ptr();
+        if (!b2->obj) {
+            b2->obj = a;
+            return true;
         }
+        return unifyObjObj(b2->obj, a);
+    } else {
+        assert(b->kind == PATTERN_STRUCT);
+        PatternPtr a2 = objectToPattern(a);
+        PatternStruct *b2 = (PatternStruct *)b.ptr();
+        if (a2->kind == PATTERN_STRUCT) {
+            PatternStruct *a3 = (PatternStruct *)a2.ptr();
+            if (a3->head == b2->head)
+                return unifyMulti(a3->params, b2->params);
+        }
+        return false;
     }
+}
 
-    bool unifyMulti(MultiPatternPtr a, MultiStaticPtr b) {
-        assert(a.ptr() && b.ptr());
-        MultiPatternListPtr b2 = new MultiPatternList();
-        for (size_t i = 0; i < b->size(); ++i)
-            b2->items.push_back(objectToPattern(b->values[i]));
-        return unifyMulti(a, b2.ptr());
-    }
+bool unifyPatternObj(PatternPtr a, ObjectPtr b) {
+    return unifyObjPattern(b, a);
+}
 
-    bool unifyMulti(MultiPatternPtr a, MultiPatternPtr b) {
-        assert(a.ptr() && b.ptr());
-        switch (a->kind) {
-            case MULTI_PATTERN_CELL: {
-                MultiPatternCell *a2 = (MultiPatternCell *) a.ptr();
-                if (!a2->data) {
-                    a2->data = b;
-                    return true;
-                }
-                return unifyMulti(a2->data, b);
-            }
-            case MULTI_PATTERN_LIST: {
-                MultiPatternList *a2 = (MultiPatternList *) a.ptr();
-                return unifyMulti(a2, 0, b);
-            }
-            default:
-                assert(false);
-                return false;
+bool unify(PatternPtr a, PatternPtr b) {
+    assert(a.ptr() && b.ptr());
+    if (a->kind == PATTERN_CELL) {
+        PatternCell *a2 = (PatternCell *)a.ptr();
+        if (!a2->obj) {
+            a2->obj = b.ptr();
+            return true;
         }
+        return unifyObjPattern(a2->obj, b);
+    } else if (b->kind == PATTERN_CELL) {
+        PatternCell *b2 = (PatternCell *)b.ptr();
+        if (!b2->obj) {
+            b2->obj = a.ptr();
+            return true;
+        }
+        return unifyPatternObj(a, b2->obj);
+    } else {
+        assert(a->kind == PATTERN_STRUCT);
+        assert(b->kind == PATTERN_STRUCT);
+        PatternStruct *a2 = (PatternStruct *)a.ptr();
+        PatternStruct *b2 = (PatternStruct *)b.ptr();
+        if (a2->head == b2->head) {
+            return unifyMulti(a2->params, b2->params);
+        }
+        return false;
     }
+}
 
-    static MultiPatternListPtr subList(MultiPatternListPtr x, unsigned index) {
-        MultiPatternListPtr subList = new MultiPatternList();
-        for (size_t i = index; i < x->items.size(); ++i)
-            subList->items.push_back(x->items[i]);
-        subList->tail = x->tail;
-        return subList;
-    }
+bool unifyMulti(MultiPatternPtr a, MultiStaticPtr b) {
+    assert(a.ptr() && b.ptr());
+    MultiPatternListPtr b2 = new MultiPatternList();
+    for (size_t i = 0; i < b->size(); ++i)
+        b2->items.push_back(objectToPattern(b->values[i]));
+    return unifyMulti(a, b2.ptr());
+}
 
-    bool unifyMulti(MultiPatternListPtr a, unsigned indexA,
-                    MultiPatternPtr b) {
-        assert(a.ptr() && b.ptr());
-        switch (b->kind) {
-            case MULTI_PATTERN_CELL: {
-                MultiPatternCell *b2 = (MultiPatternCell *) b.ptr();
-                if (!b2->data) {
-                    b2->data = subList(a, indexA).ptr();
-                    return true;
-                }
-                return unifyMulti(a, indexA, b2->data);
-            }
-            case MULTI_PATTERN_LIST: {
-                MultiPatternList *b2 = (MultiPatternList *) b.ptr();
-                return unifyMulti(a, indexA, b2, 0);
-            }
-            default:
-                assert(false);
-                return false;
+bool unifyMulti(MultiPatternPtr a, MultiPatternPtr b) {
+    assert(a.ptr() && b.ptr());
+    switch (a->kind) {
+    case MULTI_PATTERN_CELL: {
+        MultiPatternCell *a2 = (MultiPatternCell *)a.ptr();
+        if (!a2->data) {
+            a2->data = b;
+            return true;
         }
+        return unifyMulti(a2->data, b);
     }
-
-    bool unifyMulti(MultiPatternPtr a,
-                    MultiPatternListPtr b, unsigned indexB) {
-        assert(a.ptr() && b.ptr());
-        return unifyMulti(b, indexB, a);
+    case MULTI_PATTERN_LIST: {
+        MultiPatternList *a2 = (MultiPatternList *)a.ptr();
+        return unifyMulti(a2, 0, b);
     }
+    default:
+        assert(false);
+        return false;
+    }
+}
 
-    bool unifyMulti(MultiPatternListPtr a, unsigned indexA,
-                    MultiPatternListPtr b, unsigned indexB) {
-        assert(a.ptr() && b.ptr());
-        while ((indexA < a->items.size()) &&
-               (indexB < b->items.size())) {
-            if (!unify(a->items[indexA++], b->items[indexB++]))
-                return false;
-        }
-        if (indexA < a->items.size()) {
-            assert(indexB == b->items.size());
-            if (!b->tail)
-                return false;
-            return unifyMulti(a, indexA, b->tail);
-        } else if (a->tail.ptr()) {
-            return unifyMulti(a->tail, b, indexB);
+static MultiPatternListPtr subList(MultiPatternListPtr x, unsigned index) {
+    MultiPatternListPtr subList = new MultiPatternList();
+    for (size_t i = index; i < x->items.size(); ++i)
+        subList->items.push_back(x->items[i]);
+    subList->tail = x->tail;
+    return subList;
+}
+
+bool unifyMulti(MultiPatternListPtr a, unsigned indexA, MultiPatternPtr b) {
+    assert(a.ptr() && b.ptr());
+    switch (b->kind) {
+    case MULTI_PATTERN_CELL: {
+        MultiPatternCell *b2 = (MultiPatternCell *)b.ptr();
+        if (!b2->data) {
+            b2->data = subList(a, indexA).ptr();
+            return true;
         }
-        return unifyEmpty(b, indexB);
+        return unifyMulti(a, indexA, b2->data);
+    }
+    case MULTI_PATTERN_LIST: {
+        MultiPatternList *b2 = (MultiPatternList *)b.ptr();
+        return unifyMulti(a, indexA, b2, 0);
     }
+    default:
+        assert(false);
+        return false;
+    }
+}
+
+bool unifyMulti(MultiPatternPtr a, MultiPatternListPtr b, unsigned indexB) {
+    assert(a.ptr() && b.ptr());
+    return unifyMulti(b, indexB, a);
+}
 
-    bool unifyEmpty(MultiPatternListPtr x, unsigned index) {
-        if (index < x->items.size())
+bool unifyMulti(MultiPatternListPtr a, unsigned indexA, MultiPatternListPtr b,
+                unsigned indexB) {
+    assert(a.ptr() && b.ptr());
+    while ((indexA < a->items.size()) && (indexB < b->items.size())) {
+        if (!unify(a->items[indexA++], b->items[indexB++]))
             return false;
-        if (x->tail.ptr())
-            return unifyEmpty(x->tail);
-        return true;
     }
+    if (indexA < a->items.size()) {
+        assert(indexB == b->items.size());
+        if (!b->tail)
+            return false;
+        return unifyMulti(a, indexA, b->tail);
+    } else if (a->tail.ptr()) {
+        return unifyMulti(a->tail, b, indexB);
+    }
+    return unifyEmpty(b, indexB);
+}
 
-    bool unifyEmpty(MultiPatternPtr x) {
-        switch (x->kind) {
-            case MULTI_PATTERN_CELL: {
-                MultiPatternCell *y = (MultiPatternCell *) x.ptr();
-                if (!y->data) {
-                    y->data = new MultiPatternList();
-                    return true;
-                }
-                return unifyEmpty(y->data);
-            }
-            case MULTI_PATTERN_LIST: {
-                MultiPatternList *y = (MultiPatternList *) x.ptr();
-                return unifyEmpty(y, 0);
-            }
-            default:
-                assert(false);
-                return false;
+bool unifyEmpty(MultiPatternListPtr x, unsigned index) {
+    if (index < x->items.size())
+        return false;
+    if (x->tail.ptr())
+        return unifyEmpty(x->tail);
+    return true;
+}
+
+bool unifyEmpty(MultiPatternPtr x) {
+    switch (x->kind) {
+    case MULTI_PATTERN_CELL: {
+        MultiPatternCell *y = (MultiPatternCell *)x.ptr();
+        if (!y->data) {
+            y->data = new MultiPatternList();
+            return true;
         }
+        return unifyEmpty(y->data);
+    }
+    case MULTI_PATTERN_LIST: {
+        MultiPatternList *y = (MultiPatternList *)x.ptr();
+        return unifyEmpty(y, 0);
+    }
+    default:
+        assert(false);
+        return false;
     }
+}
 
-    //
-    // isPatternHead
-    //
-
-    static bool isPatternHead(ObjectPtr x) {
-        switch (x->objKind) {
-            case PRIM_OP: {
-                PrimOpPtr y = (PrimOp *) x.ptr();
-                switch (y->primOpCode) {
-                    case PRIM_Pointer:
-
-                    case PRIM_CodePointer:
-                    case PRIM_ExternalCodePointer:
-
-                    case PRIM_Array:
-                    case PRIM_Vec:
-                    case PRIM_Tuple:
-                    case PRIM_Union:
-                    case PRIM_Static:
-                        return true;
-                    default:
-                        return false;
-                }
-                assert(false);
-            }
-            case RECORD_DECL:
-            case VARIANT_DECL:
-                return true;
-            default:
-                return false;
+//
+// isPatternHead
+//
+
+static bool isPatternHead(ObjectPtr x) {
+    switch (x->objKind) {
+    case PRIM_OP: {
+        PrimOpPtr y = (PrimOp *)x.ptr();
+        switch (y->primOpCode) {
+        case PRIM_Pointer:
+
+        case PRIM_CodePointer:
+        case PRIM_ExternalCodePointer:
+
+        case PRIM_Array:
+        case PRIM_Vec:
+        case PRIM_Tuple:
+        case PRIM_Union:
+        case PRIM_Static:
+            return true;
+        default:
+            return false;
         }
         assert(false);
     }
-
-    //
-    // evaluateOnePattern
-    //
-
-    template<typename XValuePtr>
-    static PatternPtr xvalueToPatternCell(XValuePtr xv) {
-        ObjectPtr stat = unwrapStaticType(xv->type);
-        if (stat == nullptr) {
-            error("non-static value used in pattern context");
-            return nullptr;
-        } else
-            return new PatternCell(stat);
+    case RECORD_DECL:
+    case VARIANT_DECL:
+        return true;
+    default:
+        return false;
     }
+    assert(false);
+}
 
-    static PatternPtr namedToPattern(ObjectPtr x) {
-        switch (x->objKind) {
-            case PATTERN: {
-                PatternPtr y = (Pattern *) x.ptr();
-                assert(y->kind == PATTERN_CELL);
-                return y;
-            }
-            case MULTI_PATTERN: {
-                error("incorrect usage of multi-valued pattern "
-                    "in single valued context");
-                return nullptr;
-            }
-            case GLOBAL_ALIAS: {
-                GlobalAlias *y = (GlobalAlias *) x.ptr();
-                if (y->hasParams()) {
-                    return new PatternCell(x);
-                }
-                return evaluateOnePattern(y->expr, y->env);
-            }
-            case RECORD_DECL: {
-                RecordDecl *y = (RecordDecl *) x.ptr();
-                ObjectPtr z;
-                if (y->params.empty() && !y->varParam)
-                    z = recordType(y, vector<ObjectPtr>()).ptr();
-                else
-                    z = y;
-                return new PatternCell(z);
-            }
-            case VARIANT_DECL: {
-                VariantDecl *y = (VariantDecl *) x.ptr();
-                ObjectPtr z;
-                if (y->params.empty() && !y->varParam)
-                    z = variantType(y, vector<ObjectPtr>()).ptr();
-                else
-                    z = y;
-                return new PatternCell(z);
-            }
-            case ENUM_MEMBER: {
-                EnumMember *member = (EnumMember *) x.ptr();
-                ValueHolderPtr vh = new ValueHolder(member->type);
-                vh->as<int>() = member->index;
-                return new PatternCell(vh.ptr());
-            }
-            case PVALUE: {
-                PValue *pv = (PValue *) x.ptr();
-                return xvalueToPatternCell(&pv->data);
-            }
-            case CVALUE: {
-                CValue *cv = (CValue *) x.ptr();
-                return xvalueToPatternCell(cv);
-            }
-            case EVALUE: {
-                EValue *ev = (EValue *) x.ptr();
-                return xvalueToPatternCell(ev);
-            }
+//
+// evaluateOnePattern
+//
+
+template <typename XValuePtr>
+static PatternPtr xvalueToPatternCell(XValuePtr xv) {
+    ObjectPtr stat = unwrapStaticType(xv->type);
+    if (stat == nullptr) {
+        error("non-static value used in pattern context");
+        return nullptr;
+    } else
+        return new PatternCell(stat);
+}
 
-            default:
-                return new PatternCell(x);
+static PatternPtr namedToPattern(ObjectPtr x) {
+    switch (x->objKind) {
+    case PATTERN: {
+        PatternPtr y = (Pattern *)x.ptr();
+        assert(y->kind == PATTERN_CELL);
+        return y;
+    }
+    case MULTI_PATTERN: {
+        error("incorrect usage of multi-valued pattern "
+              "in single valued context");
+        return nullptr;
+    }
+    case GLOBAL_ALIAS: {
+        GlobalAlias *y = (GlobalAlias *)x.ptr();
+        if (y->hasParams()) {
+            return new PatternCell(x);
         }
+        return evaluateOnePattern(y->expr, y->env);
+    }
+    case RECORD_DECL: {
+        RecordDecl *y = (RecordDecl *)x.ptr();
+        ObjectPtr z;
+        if (y->params.empty() && !y->varParam)
+            z = recordType(y, vector<ObjectPtr>()).ptr();
+        else
+            z = y;
+        return new PatternCell(z);
+    }
+    case VARIANT_DECL: {
+        VariantDecl *y = (VariantDecl *)x.ptr();
+        ObjectPtr z;
+        if (y->params.empty() && !y->varParam)
+            z = variantType(y, vector<ObjectPtr>()).ptr();
+        else
+            z = y;
+        return new PatternCell(z);
+    }
+    case ENUM_MEMBER: {
+        EnumMember *member = (EnumMember *)x.ptr();
+        ValueHolderPtr vh = new ValueHolder(member->type);
+        vh->as<int>() = member->index;
+        return new PatternCell(vh.ptr());
+    }
+    case PVALUE: {
+        PValue *pv = (PValue *)x.ptr();
+        return xvalueToPatternCell(&pv->data);
+    }
+    case CVALUE: {
+        CValue *cv = (CValue *)x.ptr();
+        return xvalueToPatternCell(cv);
+    }
+    case EVALUE: {
+        EValue *ev = (EValue *)x.ptr();
+        return xvalueToPatternCell(ev);
     }
 
-    PatternPtr evaluateOnePattern(ExprPtr expr, EnvPtr env) {
-        LocationContext loc(expr->location);
-
-        switch (expr->exprKind) {
-            case NAME_REF: {
-                NameRef *x = (NameRef *) expr.ptr();
-                ObjectPtr y = safeLookupEnv(env, x->name);
-                return namedToPattern(y);
-            }
+    default:
+        return new PatternCell(x);
+    }
+}
 
-            case INDEXING: {
-                Indexing *x = (Indexing *) expr.ptr();
-                ObjectPtr indexable = evaluateOneStatic(x->expr, env);
-                if (isPatternHead(indexable)) {
-                    MultiPatternPtr params = evaluateMultiPattern(x->args, env);
-                    return new PatternStruct(indexable, params);
-                }
-                if (indexable->objKind == GLOBAL_ALIAS) {
-                    GlobalAlias *y = (GlobalAlias *) indexable.ptr();
-                    MultiPatternPtr params = evaluateMultiPattern(x->args, env);
-                    return evaluateAliasPattern(y, params);
-                }
-                return new PatternCell(evaluateOneStatic(expr, env));
-            }
+PatternPtr evaluateOnePattern(ExprPtr expr, EnvPtr env) {
+    LocationContext loc(expr->location);
 
-            case TUPLE: {
-                Tuple *x = (Tuple *) expr.ptr();
-                MultiPatternPtr params = evaluateMultiPattern(x->args, env);
-                return new PatternStruct(nullptr, params);
-            }
+    switch (expr->exprKind) {
+    case NAME_REF: {
+        NameRef *x = (NameRef *)expr.ptr();
+        ObjectPtr y = safeLookupEnv(env, x->name);
+        return namedToPattern(y);
+    }
 
-            default: {
-                ObjectPtr y = evaluateOneStatic(expr, env);
-                return new PatternCell(y);
-            }
+    case INDEXING: {
+        Indexing *x = (Indexing *)expr.ptr();
+        ObjectPtr indexable = evaluateOneStatic(x->expr, env);
+        if (isPatternHead(indexable)) {
+            MultiPatternPtr params = evaluateMultiPattern(x->args, env);
+            return new PatternStruct(indexable, params);
+        }
+        if (indexable->objKind == GLOBAL_ALIAS) {
+            GlobalAlias *y = (GlobalAlias *)indexable.ptr();
+            MultiPatternPtr params = evaluateMultiPattern(x->args, env);
+            return evaluateAliasPattern(y, params);
         }
+        return new PatternCell(evaluateOneStatic(expr, env));
     }
 
-    //
-    // evaluateAliasPattern
-    //
+    case TUPLE: {
+        Tuple *x = (Tuple *)expr.ptr();
+        MultiPatternPtr params = evaluateMultiPattern(x->args, env);
+        return new PatternStruct(nullptr, params);
+    }
 
-    PatternPtr evaluateAliasPattern(GlobalAliasPtr x, MultiPatternPtr params) {
-        MultiPatternListPtr args = new MultiPatternList();
-        EnvPtr env = new Env(x->env);
-        for (size_t i = 0; i < x->params.size(); ++i) {
-            PatternCellPtr cell = new PatternCell(nullptr);
-            args->items.push_back(cell.ptr());
-            addLocal(env, x->params[i], cell.ptr());
-        }
-        if (x->varParam.ptr()) {
-            MultiPatternCellPtr multiCell = new MultiPatternCell(nullptr);
-            args->tail = multiCell.ptr();
-            addLocal(env, x->varParam, multiCell.ptr());
-        }
-        PatternPtr out = evaluateOnePattern(x->expr, env);
-        if (!unifyMulti(args.ptr(), params))
-            error("non-matching alias");
-        return out;
+    default: {
+        ObjectPtr y = evaluateOneStatic(expr, env);
+        return new PatternCell(y);
     }
+    }
+}
 
-    //
-    // evaluateMultiPattern
-    //
+//
+// evaluateAliasPattern
+//
+
+PatternPtr evaluateAliasPattern(GlobalAliasPtr x, MultiPatternPtr params) {
+    MultiPatternListPtr args = new MultiPatternList();
+    EnvPtr env = new Env(x->env);
+    for (size_t i = 0; i < x->params.size(); ++i) {
+        PatternCellPtr cell = new PatternCell(nullptr);
+        args->items.push_back(cell.ptr());
+        addLocal(env, x->params[i], cell.ptr());
+    }
+    if (x->varParam.ptr()) {
+        MultiPatternCellPtr multiCell = new MultiPatternCell(nullptr);
+        args->tail = multiCell.ptr();
+        addLocal(env, x->varParam, multiCell.ptr());
+    }
+    PatternPtr out = evaluateOnePattern(x->expr, env);
+    if (!unifyMulti(args.ptr(), params))
+        error("non-matching alias");
+    return out;
+}
 
-    static MultiPatternPtr checkMultiPatternNameRef(ExprPtr expr, EnvPtr env) {
-        if (expr->exprKind != NAME_REF)
-            return nullptr;
-        NameRef *x = (NameRef *) expr.ptr();
-        ObjectPtr obj = safeLookupEnv(env, x->name);
-        if (obj->objKind == PATTERN) {
-            error(expr, "single-valued pattern incorrectly used in multi-valued context");
-        }
-        if (obj->objKind != MULTI_PATTERN)
-            return nullptr;
-        MultiPattern *mp = (MultiPattern *) obj.ptr();
-        return mp;
+//
+// evaluateMultiPattern
+//
+
+static MultiPatternPtr checkMultiPatternNameRef(ExprPtr expr, EnvPtr env) {
+    if (expr->exprKind != NAME_REF)
+        return nullptr;
+    NameRef *x = (NameRef *)expr.ptr();
+    ObjectPtr obj = safeLookupEnv(env, x->name);
+    if (obj->objKind == PATTERN) {
+        error(expr,
+              "single-valued pattern incorrectly used in multi-valued context");
     }
+    if (obj->objKind != MULTI_PATTERN)
+        return nullptr;
+    MultiPattern *mp = (MultiPattern *)obj.ptr();
+    return mp;
+}
 
-    static bool appendPattern(MultiPatternListPtr &cur, MultiPatternPtr x) {
-        assert(!cur || !cur->tail);
-        assert(x.ptr());
-        switch (x->kind) {
-            case MULTI_PATTERN_CELL: {
-                if (!cur)
-                    return false;
-                MultiPatternCell *y = (MultiPatternCell *) x.ptr();
-                if (y->data.ptr())
-                    return appendPattern(cur, y->data);
-                cur->tail = y;
-                cur = nullptr;
-                return true;
-            }
-            case MULTI_PATTERN_LIST: {
-                MultiPatternList *y = (MultiPatternList *) x.ptr();
-                if (!y->items.empty()) {
-                    if (!cur)
-                        return false;
-                    for (size_t i = 0; i < y->items.size(); ++i)
-                        cur->items.push_back(y->items[i]);
-                }
-                if (y->tail.ptr())
-                    return appendPattern(cur, y->tail);
-                return true;
-            }
-            default:
-                assert(false);
+static bool appendPattern(MultiPatternListPtr &cur, MultiPatternPtr x) {
+    assert(!cur || !cur->tail);
+    assert(x.ptr());
+    switch (x->kind) {
+    case MULTI_PATTERN_CELL: {
+        if (!cur)
+            return false;
+        MultiPatternCell *y = (MultiPatternCell *)x.ptr();
+        if (y->data.ptr())
+            return appendPattern(cur, y->data);
+        cur->tail = y;
+        cur = nullptr;
+        return true;
+    }
+    case MULTI_PATTERN_LIST: {
+        MultiPatternList *y = (MultiPatternList *)x.ptr();
+        if (!y->items.empty()) {
+            if (!cur)
                 return false;
+            for (size_t i = 0; i < y->items.size(); ++i)
+                cur->items.push_back(y->items[i]);
         }
+        if (y->tail.ptr())
+            return appendPattern(cur, y->tail);
+        return true;
     }
+    default:
+        assert(false);
+        return false;
+    }
+}
 
-    MultiPatternPtr evaluateMultiPattern(ExprListPtr exprs, EnvPtr env) {
-        MultiPatternListPtr out = new MultiPatternList();
-        MultiPatternListPtr cur = out;
-        for (size_t i = 0; i < exprs->size(); ++i) {
-            assert(!cur || !cur->tail);
-            ExprPtr x = exprs->exprs[i];
-            if (x->exprKind == UNPACK) {
-                Unpack *y = (Unpack *) x.ptr();
-                MultiPatternPtr mp = checkMultiPatternNameRef(y->expr, env);
-                if (mp.ptr()) {
-                    if (!appendPattern(cur, mp))
-                        error(x, "expressions cannot occur after "
-                              "multi-pattern variable");
-                } else {
-                    MultiStaticPtr z = evaluateExprStatic(y->expr, env);
-                    if (!cur && (z->size() > 0))
-                        error(x, "expressions cannot occur after "
-                              "multi-pattern variable");
-                    for (size_t j = 0; j < z->size(); ++j) {
-                        PatternPtr p = new PatternCell(z->values[i]);
-                        cur->items.push_back(p);
-                    }
-                }
-            } else if (x->exprKind == PAREN) {
-                Paren *y = (Paren *) x.ptr();
-                MultiPatternPtr mp = evaluateMultiPattern(y->args, env);
-                if (!appendPattern(cur, mp)) {
+MultiPatternPtr evaluateMultiPattern(ExprListPtr exprs, EnvPtr env) {
+    MultiPatternListPtr out = new MultiPatternList();
+    MultiPatternListPtr cur = out;
+    for (size_t i = 0; i < exprs->size(); ++i) {
+        assert(!cur || !cur->tail);
+        ExprPtr x = exprs->exprs[i];
+        if (x->exprKind == UNPACK) {
+            Unpack *y = (Unpack *)x.ptr();
+            MultiPatternPtr mp = checkMultiPatternNameRef(y->expr, env);
+            if (mp.ptr()) {
+                if (!appendPattern(cur, mp))
                     error(x, "expressions cannot occur after "
-                          "multi-pattern variable");
-                }
+                             "multi-pattern variable");
             } else {
-                if (!cur)
+                MultiStaticPtr z = evaluateExprStatic(y->expr, env);
+                if (!cur && (z->size() > 0))
                     error(x, "expressions cannot occur after "
-                          "multi-pattern variable");
-                PatternPtr y = evaluateOnePattern(x, env);
-                cur->items.push_back(y);
+                             "multi-pattern variable");
+                for (size_t j = 0; j < z->size(); ++j) {
+                    PatternPtr p = new PatternCell(z->values[i]);
+                    cur->items.push_back(p);
+                }
+            }
+        } else if (x->exprKind == PAREN) {
+            Paren *y = (Paren *)x.ptr();
+            MultiPatternPtr mp = evaluateMultiPattern(y->args, env);
+            if (!appendPattern(cur, mp)) {
+                error(x, "expressions cannot occur after "
+                         "multi-pattern variable");
             }
+        } else {
+            if (!cur)
+                error(x, "expressions cannot occur after "
+                         "multi-pattern variable");
+            PatternPtr y = evaluateOnePattern(x, env);
+            cur->items.push_back(y);
         }
-        return out.ptr();
     }
+    return out.ptr();
 }
+} // namespace clay
diff --git a/compiler/patterns.hpp b/compiler/patterns.hpp
index 5cea21f3..80e7aca8 100644
--- a/compiler/patterns.hpp
+++ b/compiler/patterns.hpp
@@ -3,27 +3,25 @@
 #include "clay.hpp"
 
 namespace clay {
-    ObjectPtr derefDeep(PatternPtr x);
-    MultiStaticPtr derefDeep(MultiPatternPtr x);
-    bool unifyObjObj(ObjectPtr a, ObjectPtr b);
-    bool unifyObjPattern(ObjectPtr a, PatternPtr b);
-    bool unifyPatternObj(PatternPtr a, ObjectPtr b);
-    bool unify(PatternPtr a, PatternPtr b);
-    bool unifyMulti(MultiPatternPtr a, MultiStaticPtr b);
-    bool unifyMulti(MultiPatternPtr a, MultiPatternPtr b);
-    bool unifyMulti(MultiPatternListPtr a, unsigned indexA,
-                    MultiPatternPtr b);
-    bool unifyMulti(MultiPatternPtr a,
-                    MultiPatternListPtr b, unsigned indexB);
-    bool unifyMulti(MultiPatternListPtr a, unsigned indexA,
-                    MultiPatternListPtr b, unsigned indexB);
-    bool unifyEmpty(MultiPatternListPtr x, unsigned index);
-    bool unifyEmpty(MultiPatternPtr x);
+ObjectPtr derefDeep(PatternPtr x);
+MultiStaticPtr derefDeep(MultiPatternPtr x);
+bool unifyObjObj(ObjectPtr a, ObjectPtr b);
+bool unifyObjPattern(ObjectPtr a, PatternPtr b);
+bool unifyPatternObj(PatternPtr a, ObjectPtr b);
+bool unify(PatternPtr a, PatternPtr b);
+bool unifyMulti(MultiPatternPtr a, MultiStaticPtr b);
+bool unifyMulti(MultiPatternPtr a, MultiPatternPtr b);
+bool unifyMulti(MultiPatternListPtr a, unsigned indexA, MultiPatternPtr b);
+bool unifyMulti(MultiPatternPtr a, MultiPatternListPtr b, unsigned indexB);
+bool unifyMulti(MultiPatternListPtr a, unsigned indexA, MultiPatternListPtr b,
+                unsigned indexB);
+bool unifyEmpty(MultiPatternListPtr x, unsigned index);
+bool unifyEmpty(MultiPatternPtr x);
 
-    PatternPtr evaluateOnePattern(ExprPtr expr, EnvPtr env);
-    PatternPtr evaluateAliasPattern(GlobalAliasPtr x, MultiPatternPtr params);
-    MultiPatternPtr evaluateMultiPattern(ExprListPtr exprs, EnvPtr env);
+PatternPtr evaluateOnePattern(ExprPtr expr, EnvPtr env);
+PatternPtr evaluateAliasPattern(GlobalAliasPtr x, MultiPatternPtr params);
+MultiPatternPtr evaluateMultiPattern(ExprListPtr exprs, EnvPtr env);
 
-    void patternPrint(llvm::raw_ostream &out, PatternPtr x);
-    void patternPrint(llvm::raw_ostream &out, MultiPatternPtr x);
-}
+void patternPrint(llvm::raw_ostream &out, PatternPtr x);
+void patternPrint(llvm::raw_ostream &out, MultiPatternPtr x);
+} // namespace clay
diff --git a/compiler/printer.cpp b/compiler/printer.cpp
index fb4190f8..4d4a7663 100644
--- a/compiler/printer.cpp
+++ b/compiler/printer.cpp
@@ -1,1346 +1,1368 @@
 #include "clay.hpp"
-#include "evaluator.hpp"
 #include "codegen.hpp"
+#include "evaluator.hpp"
 #include "loader.hpp"
-#include "patterns.hpp"
 #include "objects.hpp"
+#include "patterns.hpp"
 
 #include "printer.hpp"
 
 #pragma clang diagnostic ignored "-Wcovered-switch-default"
 
 namespace clay {
-    using namespace std;
+using namespace std;
 
-    void Object::print() const {
-        llvm::errs() << *this << "\n";
+void Object::print() const { llvm::errs() << *this << "\n"; }
+
+std::string Object::toString() const {
+    std::string r;
+    llvm::raw_string_ostream os(r);
+    os << *this;
+    return r;
+}
+
+//
+// overload <<
+//
+
+llvm::raw_ostream &operator<<(llvm::raw_ostream &os, ObjectKind objectKind) {
+#define OBJECT_KIND_PRINT(e)                                                   \
+    case e:                                                                    \
+        os << #e;                                                              \
+        break;
+
+    switch (objectKind) {
+        OBJECT_KIND_MAP(OBJECT_KIND_PRINT)
+    default:
+        os << "unknown value: " << int(objectKind);
+        break;
     }
 
-    std::string Object::toString() const {
-        std::string r;
-        llvm::raw_string_ostream os(r);
-        os << *this;
-        return r;
+#undef OBJECT_KIND_PRINT
+    return os;
+}
+
+llvm::raw_ostream &operator<<(llvm::raw_ostream &os, ExprKind exprKind) {
+#define EXPR_KIND_PRINT(e)                                                     \
+    case e:                                                                    \
+        os << #e;                                                              \
+        break;
+
+    switch (exprKind) {
+        EXPR_KIND_MAP(EXPR_KIND_PRINT)
+    default:
+        os << "unknown value: " << int(exprKind);
+        break;
     }
 
-    //
-    // overload <<
-    //
+#undef EXPR_KIND_PRINT
+    return os;
+}
 
-    llvm::raw_ostream &operator<<(llvm::raw_ostream &os, ObjectKind objectKind) {
-#define OBJECT_KIND_PRINT(e) case e: os << #e; break;
+llvm::raw_ostream &operator<<(llvm::raw_ostream &os,
+                              VariadicOpKind variadicOpKind) {
+#define VARIADIC_OP_KIND_PRINT(e)                                              \
+    case e:                                                                    \
+        os << #e;                                                              \
+        break;
+
+    switch (variadicOpKind) {
+        VARIADIC_OP_KIND_MAP(VARIADIC_OP_KIND_PRINT)
+    default:
+        os << "unknown value: " << int(variadicOpKind);
+        break;
+    }
 
-        switch (objectKind) {
-            OBJECT_KIND_MAP(OBJECT_KIND_PRINT)
-            default:
-                os << "unknown value: " << int(objectKind);
-                break;
-        }
+#undef VARIADIC_OP_KIND_PRINT
+    return os;
+}
 
-#undef OBJECT_KIND_PRINT
-        return os;
+llvm::raw_ostream &operator<<(llvm::raw_ostream &os,
+                              StatementKind statementKind) {
+#define STATEMENT_KIND_PRINT(e)                                                \
+    case e:                                                                    \
+        os << #e;                                                              \
+        break;
+
+    switch (statementKind) {
+        STATEMENT_KIND_MAP(STATEMENT_KIND_PRINT)
+    default:
+        os << "unknown value: " << int(statementKind);
+        break;
     }
 
-    llvm::raw_ostream &operator<<(llvm::raw_ostream &os, ExprKind exprKind) {
-#define EXPR_KIND_PRINT(e) case e: os << #e; break;
+#undef STATEMENT_KIND_PRINT
+    return os;
+}
 
-        switch (exprKind) {
-            EXPR_KIND_MAP(EXPR_KIND_PRINT)
-            default:
-                os << "unknown value: " << int(exprKind);
-                break;
-        }
+llvm::raw_ostream &operator<<(llvm::raw_ostream &os, BindingKind bindingKind) {
+#define BINDING_KIND_PRINT(e)                                                  \
+    case e:                                                                    \
+        os << #e;                                                              \
+        break;
+
+    switch (bindingKind) {
+        BINDING_KIND_MAP(BINDING_KIND_PRINT)
+    default:
+        os << "unknown value: " << int(bindingKind);
+        break;
+    }
 
-#undef EXPR_KIND_PRINT
-        return os;
+#undef BINDING_KIND_PRINT
+    return os;
+}
+
+llvm::raw_ostream &operator<<(llvm::raw_ostream &os, TypeKind typeKind) {
+#define TYPE_KIND_PRINT(e)                                                     \
+    case e:                                                                    \
+        os << #e;                                                              \
+        break;
+
+    switch (typeKind) {
+        TYPE_KIND_MAP(TYPE_KIND_PRINT)
+    default:
+        os << "unknown value: " << int(typeKind);
+        break;
     }
 
-    llvm::raw_ostream &operator<<(llvm::raw_ostream &os, VariadicOpKind variadicOpKind) {
-#define VARIADIC_OP_KIND_PRINT(e) case e: os << #e; break;
+#undef TYPE_KIND_PRINT
+    return os;
+}
 
-        switch (variadicOpKind) {
-            VARIADIC_OP_KIND_MAP(VARIADIC_OP_KIND_PRINT)
-            default:
-                os << "unknown value: " << int(variadicOpKind);
-                break;
-        }
+static void print(llvm::raw_ostream &out, const Object *x);
 
-#undef VARIADIC_OP_KIND_PRINT
-        return os;
+llvm::raw_ostream &operator<<(llvm::raw_ostream &out, const Object &obj) {
+    print(out, &obj);
+    return out;
+}
+
+llvm::raw_ostream &operator<<(llvm::raw_ostream &out, const Object *obj) {
+    print(out, obj);
+    return out;
+}
+
+static llvm::raw_ostream &writeFloat(llvm::raw_ostream &out, float x) {
+    char buf[64];
+    snprintf(buf, 63, "%.8g", x);
+    buf[63] = 0;
+    return out << buf;
+}
+
+static llvm::raw_ostream &writeFloat(llvm::raw_ostream &out, double x) {
+    char buf[64];
+    snprintf(buf, 63, "%.16g", x);
+    buf[63] = 0;
+    return out << buf;
+}
+
+static llvm::raw_ostream &writeFloat(llvm::raw_ostream &out, long double x) {
+    char buf[64];
+    snprintf(buf, 63, "%.19Lg", x);
+    buf[63] = 0;
+    return out << buf;
+}
+
+static llvm::raw_ostream &writeFloat(llvm::raw_ostream &out, clay_cfloat x) {
+    char buf[128];
+    snprintf(buf, 127, "%.8g%+.8gj", clay_creal(x), clay_cimag(x));
+    buf[127] = 0;
+    return out << buf;
+}
+
+static llvm::raw_ostream &writeFloat(llvm::raw_ostream &out, clay_cdouble x) {
+    char buf[128];
+    snprintf(buf, 127, "%.16g%+.16gj", clay_creal(x), clay_cimag(x));
+    buf[127] = 0;
+    return out << buf;
+}
+
+static llvm::raw_ostream &writeFloat(llvm::raw_ostream &out, clay_cldouble x) {
+    char buf[128];
+    snprintf(buf, 127, "%.19Lg%+.19Lgj", clay_creal(x), clay_cimag(x));
+    buf[127] = 0;
+    return out << buf;
+}
+
+template <class T>
+llvm::raw_ostream &operator<<(llvm::raw_ostream &out, const vector<T> &v) {
+    return out << llvm::ArrayRef(v);
+}
+
+template <class T>
+llvm::raw_ostream &operator<<(llvm::raw_ostream &out,
+                              const llvm::SmallVector<T, 3> &v) {
+    return out << llvm::ArrayRef(v);
+}
+
+llvm::raw_ostream &operator<<(llvm::raw_ostream &out, PVData const &pv) {
+    return out << "PVData(" << pv.type << ", " << pv.isRValue << ")";
+}
+
+//
+// big vec
+//
+
+template <class T> struct BigVec {
+    llvm::ArrayRef<T> v;
+
+    BigVec(llvm::ArrayRef<T> v) : v(v) {}
+};
+
+template <class T> BigVec<T> bigVec(const vector<T> &v) { return BigVec<T>(v); }
+
+static int indent = 0;
+
+template <class T>
+llvm::raw_ostream &operator<<(llvm::raw_ostream &out, const BigVec<T> &v) {
+    ++indent;
+    out << "[";
+    T const *i, *end;
+    bool first = true;
+    for (i = v.v.begin(), end = v.v.end(); i != end; ++i) {
+        if (!first)
+            out << ",";
+        first = false;
+        out << "\n";
+        for (int j = 0; j < indent; ++j)
+            out << "  ";
+        out << *i;
     }
+    out << "]";
+    --indent;
+    return out;
+}
 
-    llvm::raw_ostream &operator<<(llvm::raw_ostream &os, StatementKind statementKind) {
-#define STATEMENT_KIND_PRINT(e) case e: os << #e; break;
+//
+// print PatternVar
+//
 
-        switch (statementKind) {
-            STATEMENT_KIND_MAP(STATEMENT_KIND_PRINT)
-            default:
-                os << "unknown value: " << int(statementKind);
-                break;
-        }
+llvm::raw_ostream &operator<<(llvm::raw_ostream &out, const PatternVar &pvar) {
+    out << "PatternVar(" << pvar.isMulti << ", " << pvar.name << ")";
+    return out;
+}
 
-#undef STATEMENT_KIND_PRINT
-        return os;
+//
+// print
+//
+
+static void printExpr(llvm::raw_ostream &out, const Expr *x) {
+    switch (x->exprKind) {
+    case BOOL_LITERAL: {
+        const BoolLiteral *y = (const BoolLiteral *)x;
+        out << "BoolLiteral(" << y->value << ")";
+        break;
+    }
+    case INT_LITERAL: {
+        const IntLiteral *y = (const IntLiteral *)x;
+        out << "IntLiteral(" << y->value;
+        if (!y->suffix.empty())
+            out << ", " << y->suffix;
+        out << ")";
+        break;
+    }
+    case FLOAT_LITERAL: {
+        const FloatLiteral *y = (const FloatLiteral *)x;
+        out << "FloatLiteral(" << y->value;
+        if (!y->suffix.empty())
+            out << ", " << y->suffix;
+        out << ")";
+        break;
+    }
+    case CHAR_LITERAL: {
+        const CharLiteral *y = (const CharLiteral *)x;
+        out << "CharLiteral(" << y->value << ")";
+        break;
+    }
+    case STRING_LITERAL: {
+        const StringLiteral *y = (const StringLiteral *)x;
+        out << "StringLiteral(" << y->value << ")";
+        break;
     }
 
-    llvm::raw_ostream &operator<<(llvm::raw_ostream &os, BindingKind bindingKind) {
-#define BINDING_KIND_PRINT(e) case e: os << #e; break;
+    case NAME_REF: {
+        const NameRef *y = (const NameRef *)x;
+        out << "NameRef(" << y->name << ")";
+        break;
+    }
+    case TUPLE: {
+        const Tuple *y = (const Tuple *)x;
+        out << "Tuple(" << y->args << ")";
+        break;
+    }
+    case PAREN: {
+        const Paren *y = (const Paren *)x;
+        out << "Paren(" << y->args << ")";
+        break;
+    }
+    case INDEXING: {
+        const Indexing *y = (const Indexing *)x;
+        out << "Indexing(" << y->expr << ", " << y->args << ")";
+        break;
+    }
+    case CALL: {
+        const Call *y = (const Call *)x;
+        out << "Call(" << y->expr << ", " << y->parenArgs << ")";
+        break;
+    }
+    case FIELD_REF: {
+        const FieldRef *y = (const FieldRef *)x;
+        out << "FieldRef(" << y->expr << ", " << y->name << ")";
+        break;
+    }
+    case STATIC_INDEXING: {
+        const StaticIndexing *y = (const StaticIndexing *)x;
+        out << "StaticIndexing(" << y->expr << ", " << y->index << ")";
+        break;
+    }
 
-        switch (bindingKind) {
-            BINDING_KIND_MAP(BINDING_KIND_PRINT)
-            default:
-                os << "unknown value: " << int(bindingKind);
-                break;
+    case VARIADIC_OP: {
+        const VariadicOp *y = (const VariadicOp *)x;
+        out << "VariadicOp(" << y->op << ", " << y->exprs << ")";
+        break;
+    }
+    case AND: {
+        const And *y = (const And *)x;
+        out << "And(" << y->expr1 << ", " << y->expr2 << ")";
+        break;
+    }
+    case OR: {
+        const Or *y = (const Or *)x;
+        out << "Or(" << y->expr1 << ", " << y->expr2 << ")";
+        break;
+    }
+    case LAMBDA: {
+        const Lambda *y = (const Lambda *)x;
+        out << "Lambda(" << y->captureBy << ", " << y->formalArgs << ", "
+            << y->hasVarArg << ", " << y->body << ")";
+        break;
+    }
+    case UNPACK: {
+        const Unpack *y = (const Unpack *)x;
+        out << "Unpack(" << y->expr << ")";
+        break;
+    }
+    case STATIC_EXPR: {
+        const StaticExpr *y = (const StaticExpr *)x;
+        out << "StaticExpr(" << y->expr << ")";
+        break;
+    }
+    case DISPATCH_EXPR: {
+        const DispatchExpr *y = (const DispatchExpr *)x;
+        out << "DispatchExpr(" << y->expr << ")";
+        break;
+    }
+    case FOREIGN_EXPR: {
+        const ForeignExpr *y = (const ForeignExpr *)x;
+        out << "ForeignExpr(" << y->expr << ")";
+        break;
+    }
+    case OBJECT_EXPR: {
+        const ObjectExpr *y = (const ObjectExpr *)x;
+        out << "ObjectExpr(" << y->obj << ")";
+        break;
+    }
+    case EVAL_EXPR: {
+        const EvalExpr *eval = (const EvalExpr *)x;
+        out << "EvalExpr(" << eval->args << ")";
+        break;
+    }
+    case FILE_EXPR: {
+        out << "FILEExpr()";
+        break;
+    }
+    case LINE_EXPR: {
+        out << "LINEExpr()";
+        break;
+    }
+    case COLUMN_EXPR: {
+        out << "COLUMNExpr()";
+        break;
+    }
+    case ARG_EXPR: {
+        const ARGExpr *arg = (const ARGExpr *)x;
+        out << "ARGExpr(" << arg->name << ")";
+        break;
+    }
+    }
+}
+
+static void printStatement(llvm::raw_ostream &out, const Statement *x) {
+    switch (x->stmtKind) {
+    case BLOCK: {
+        const Block *y = (const Block *)x;
+        out << "Block(" << bigVec(y->statements) << ")";
+        break;
+    }
+    case LABEL: {
+        const Label *y = (const Label *)x;
+        out << "Label(" << y->name << ")";
+        break;
+    }
+    case BINDING: {
+        const Binding *y = (const Binding *)x;
+        out << "Binding(" << y->bindingKind << ", " << y->args << ", "
+            << y->values << ")";
+        break;
+    }
+    case ASSIGNMENT: {
+        const Assignment *y = (const Assignment *)x;
+        out << "Assignment(" << y->left << ", " << y->right << ")";
+        break;
+    }
+    case INIT_ASSIGNMENT: {
+        const InitAssignment *y = (const InitAssignment *)x;
+        out << "InitAssignment(" << y->left << ", " << y->right << ")";
+        break;
+    }
+    case VARIADIC_ASSIGNMENT: {
+        const VariadicAssignment *y = (const VariadicAssignment *)x;
+        out << "VariadicAssignment(" << y->op;
+        out << ", " << y->exprs->exprs << ")";
+        break;
+    }
+    case GOTO: {
+        const Goto *y = (const Goto *)x;
+        out << "Goto(" << y->labelName << ")";
+        break;
+    }
+    case RETURN: {
+        const Return *y = (const Return *)x;
+        out << "Return(" << y->returnKind << ", " << y->values << ")";
+        break;
+    }
+    case IF: {
+        const If *y = (const If *)x;
+        out << "If(" << y->condition << ", " << y->thenPart;
+        out << ", " << y->elsePart << ")";
+        break;
+    }
+    case SWITCH: {
+        const Switch *y = (const Switch *)x;
+        out << "Switch(" << y->expr << ", " << y->caseBlocks << ", "
+            << y->defaultCase << ")";
+        break;
+    }
+    case EXPR_STATEMENT: {
+        const ExprStatement *y = (const ExprStatement *)x;
+        out << "ExprStatement(" << y->expr << ")";
+        break;
+    }
+    case WHILE: {
+        const While *y = (const While *)x;
+        out << "While(" << y->condition << ", " << y->body << ")";
+        break;
+    }
+    case BREAK: {
+        out << "Break()";
+        break;
+    }
+    case CONTINUE: {
+        out << "Continue()";
+        break;
+    }
+    case FOR: {
+        const For *y = (const For *)x;
+        out << "For(" << y->variables << ", " << y->expr;
+        out << ", " << y->body << ")";
+        break;
+    }
+    case FOREIGN_STATEMENT: {
+        const ForeignStatement *y = (const ForeignStatement *)x;
+        out << "ForeignStatement(" << y->statement << ")";
+        break;
+    }
+    case TRY: {
+        const Try *y = (const Try *)x;
+        out << "Try(" << y->tryBlock << ", " << y->catchBlocks << ")";
+        break;
+    }
+    case THROW: {
+        const Throw *y = (const Throw *)x;
+        out << "Throw(" << y->expr << ", " << y->context << ")";
+        break;
+    }
+    case STATIC_FOR: {
+        const StaticFor *y = (const StaticFor *)x;
+        out << "StaticFor(" << y->variable << ", " << y->values << ", "
+            << y->body << ")";
+        break;
+    }
+    case FINALLY: {
+        const Finally *y = (const Finally *)x;
+        out << "Finally(" << y->body << ")";
+        break;
+    }
+    case ONERROR: {
+        const OnError *y = (const OnError *)x;
+        out << "OnError(" << y->body << ")";
+        break;
+    }
+    case UNREACHABLE: {
+        out << "Unreachable()";
+        break;
+    }
+    case EVAL_STATEMENT: {
+        const EvalStatement *eval = (const EvalStatement *)x;
+        out << "EvalStatement(" << eval->args << ")";
+        break;
+    }
+    case STATIC_ASSERT_STATEMENT: {
+        const StaticAssertStatement *staticAssert =
+            (const StaticAssertStatement *)x;
+        out << "StaticAssertStatement(" << staticAssert->cond;
+        for (size_t i = 0; i < staticAssert->message->size(); ++i) {
+            out << ", " << staticAssert->message->exprs[i];
         }
+        out << ")";
+        break;
+    }
+    }
+}
 
-#undef BINDING_KIND_PRINT
-        return os;
+static void print(llvm::raw_ostream &out, const Object *x) {
+    if (x == nullptr) {
+        out << "NULL";
+        return;
     }
 
-    llvm::raw_ostream &operator<<(llvm::raw_ostream &os, TypeKind typeKind) {
-#define TYPE_KIND_PRINT(e) case e: os << #e; break;
+    switch (x->objKind) {
+    case SOURCE: {
+        const Source *y = (const Source *)x;
+        out << "Source(" << y->fileName << ")";
+        break;
+    }
+    case IDENTIFIER: {
+        const Identifier *y = (const Identifier *)x;
+        out << "Identifier(" << y->str << ")";
+        break;
+    }
+    case DOTTED_NAME: {
+        const DottedName *y = (const DottedName *)x;
+        out << "DottedName(" << llvm::ArrayRef(y->parts) << ")";
+        break;
+    }
 
-        switch (typeKind) {
-            TYPE_KIND_MAP(TYPE_KIND_PRINT)
-            default:
-                os << "unknown value: " << int(typeKind);
-                break;
-        }
+    case EXPRESSION: {
+        const Expr *y = (const Expr *)x;
+        printExpr(out, y);
+        break;
+    }
 
-#undef TYPE_KIND_PRINT
-        return os;
+    case EXPR_LIST: {
+        const ExprList *y = (const ExprList *)x;
+        out << "ExprList(" << y->exprs << ")";
+        break;
     }
 
-    static void print(llvm::raw_ostream &out, const Object *x);
+    case STATEMENT: {
+        const Statement *y = (const Statement *)x;
+        printStatement(out, y);
+        break;
+    }
+
+    case CASE_BLOCK: {
+        const CaseBlock *y = (const CaseBlock *)x;
+        out << "CaseBlock(" << y->caseLabels << ", " << y->body << ")";
+        break;
+    }
 
-    llvm::raw_ostream &operator<<(llvm::raw_ostream &out, const Object &obj) {
-        print(out, &obj);
-        return out;
+    case CATCH: {
+        const Catch *y = (const Catch *)x;
+        out << "Catch(" << y->exceptionVar << ", " << y->exceptionType << ", "
+            << y->body << ")";
+        break;
     }
 
-    llvm::raw_ostream &operator<<(llvm::raw_ostream &out, const Object *obj) {
-        print(out, obj);
-        return out;
+    case CODE: {
+        const Code *y = (const Code *)x;
+        out << "Code(" << y->patternVars << ", " << y->predicate;
+        out << ", " << y->formalArgs << ", " << y->hasVarArg;
+        out << ", " << y->returnSpecs << ", " << y->varReturnSpec;
+        out << ", " << y->body << ")";
+        break;
+    }
+    case FORMAL_ARG: {
+        const FormalArg *y = (const FormalArg *)x;
+        out << "FormalArg(" << y->name << ", " << y->type << ", " << y->tempness
+            << ")";
+        break;
+    }
+    case RETURN_SPEC: {
+        const ReturnSpec *y = (const ReturnSpec *)x;
+        out << "ReturnSpec(" << y->type << ", " << y->name << ")";
+        break;
     }
 
-    static llvm::raw_ostream &writeFloat(llvm::raw_ostream &out, float x) {
-        char buf[64];
-        snprintf(buf, 63, "%.8g", x);
-        buf[63] = 0;
-        return out << buf;
+    case RECORD_DECL: {
+        const RecordDecl *y = (const RecordDecl *)x;
+        out << "RecordDecl(" << y->name << ", " << y->params;
+        out << ", " << y->varParam << ", " << y->body << ")";
+        break;
+    }
+    case RECORD_BODY: {
+        const RecordBody *y = (const RecordBody *)x;
+        out << "RecordBody(" << y->isComputed << ", " << y->computed;
+        out << ", " << y->fields << ")";
+        break;
+    }
+    case RECORD_FIELD: {
+        const RecordField *y = (const RecordField *)x;
+        out << "RecordField(" << y->name << ", " << y->type << ")";
+        break;
     }
 
-    static llvm::raw_ostream &writeFloat(llvm::raw_ostream &out, double x) {
-        char buf[64];
-        snprintf(buf, 63, "%.16g", x);
-        buf[63] = 0;
-        return out << buf;
+    case VARIANT_DECL: {
+        const VariantDecl *y = (const VariantDecl *)x;
+        out << "VariantDecl(" << y->name << ", " << y->params;
+        out << ", " << y->varParam << ")";
+        break;
+    }
+    case INSTANCE_DECL: {
+        const InstanceDecl *y = (const InstanceDecl *)x;
+        out << "InstanceDecl(" << y->patternVars << ", " << y->predicate;
+        out << ", " << y->target << ", " << y->members << ")";
+        break;
     }
 
-    static llvm::raw_ostream &writeFloat(llvm::raw_ostream &out, long double x) {
-        char buf[64];
-        snprintf(buf, 63, "%.19Lg", x);
-        buf[63] = 0;
-        return out << buf;
+    case OVERLOAD: {
+        const Overload *y = (const Overload *)x;
+        out << "Overload(" << y->target << ", " << y->code << ", "
+            << y->callByName << ", " << y->isInline << ")";
+        break;
+    }
+    case PROCEDURE: {
+        const Procedure *y = (const Procedure *)x;
+        out << "Procedure(" << y->name << ")";
+        break;
+    }
+    case INTRINSIC: {
+        const IntrinsicSymbol *intrin = (const IntrinsicSymbol *)x;
+        out << "IntrinsicSymbol(" << intrin->name << ", " << intrin->id << ")";
+        break;
     }
 
-    static llvm::raw_ostream &writeFloat(llvm::raw_ostream &out, clay_cfloat x) {
-        char buf[128];
-        snprintf(buf, 127, "%.8g%+.8gj", clay_creal(x), clay_cimag(x));
-        buf[127] = 0;
-        return out << buf;
+    case ENUM_DECL: {
+        const EnumDecl *y = (const EnumDecl *)x;
+        out << "EnumDecl(" << y->name << ", " << y->members << ")";
+        break;
+    }
+    case ENUM_MEMBER: {
+        const EnumMember *y = (const EnumMember *)x;
+        out << "EnumMember(" << y->name << ")";
+        break;
     }
 
-    static llvm::raw_ostream &writeFloat(llvm::raw_ostream &out, clay_cdouble x) {
-        char buf[128];
-        snprintf(buf, 127, "%.16g%+.16gj", clay_creal(x), clay_cimag(x));
-        buf[127] = 0;
-        return out << buf;
+    case NEW_TYPE_DECL: {
+        const NewTypeDecl *y = (const NewTypeDecl *)x;
+        out << "NewTypeDecl(" << y->name << ")";
+        break;
     }
 
-    static llvm::raw_ostream &writeFloat(llvm::raw_ostream &out, clay_cldouble x) {
-        char buf[128];
-        snprintf(buf, 127, "%.19Lg%+.19Lgj", clay_creal(x), clay_cimag(x));
-        buf[127] = 0;
-        return out << buf;
+    case GLOBAL_VARIABLE: {
+        const GlobalVariable *y = (const GlobalVariable *)x;
+        out << "GlobalVariable(" << y->name << ", " << y->params << ", "
+            << y->varParam << ", " << y->expr << ")";
+        break;
     }
 
-    template<class T>
-    llvm::raw_ostream &operator<<(llvm::raw_ostream &out, const vector<T> &v) {
-        return out << llvm::ArrayRef(v);
+    case EXTERNAL_PROCEDURE: {
+        const ExternalProcedure *y = (const ExternalProcedure *)x;
+        out << "ExternalProcedure(" << y->name << ", " << y->args;
+        out << ", " << y->hasVarArgs << ", " << y->returnType;
+        out << ", " << y->body << ")";
+        break;
+    }
+    case EXTERNAL_ARG: {
+        const ExternalArg *y = (const ExternalArg *)x;
+        out << "ExternalArg(" << y->name << ", " << y->type << ")";
+        break;
     }
 
-    template<class T>
-    llvm::raw_ostream &operator<<(llvm::raw_ostream &out, const llvm::SmallVector<T, 3> &v) {
-        return out << llvm::ArrayRef(v);
+    case EXTERNAL_VARIABLE: {
+        const ExternalVariable *y = (const ExternalVariable *)x;
+        out << "ExternalVariable(" << y->name << ", " << y->type << ")";
+        break;
     }
 
-    llvm::raw_ostream &operator<<(llvm::raw_ostream &out, PVData const &pv) {
-        return out << "PVData(" << pv.type << ", " << pv.isRValue << ")";
+    case GLOBAL_ALIAS: {
+        const GlobalAlias *y = (const GlobalAlias *)x;
+        out << "GlobalAlias(" << y->name << ", " << y->params << ", "
+            << y->varParam << ", " << y->expr << ")";
+        break;
     }
 
-    //
-    // big vec
-    //
+    case IMPORT: {
+        const Import *y = (const Import *)x;
+        switch (y->importKind) {
+        case IMPORT_MODULE: {
+            const ImportModule *z = (const ImportModule *)y;
+            out << "Import(" << z->dottedName << ", " << z->alias << ")";
+            break;
+        }
+        case IMPORT_STAR: {
+            const ImportStar *z = (const ImportStar *)y;
+            out << "ImportStar(" << z->dottedName << ")";
+            break;
+        }
+        case IMPORT_MEMBERS: {
+            const ImportMembers *z = (const ImportMembers *)y;
+            out << "ImportMembers(" << z->visibility << ", " << z->dottedName
+                << ", [";
+            for (size_t i = 0; i < z->members.size(); ++i) {
+                if (i != 0)
+                    out << ", ";
+                const ImportedMember &a = z->members[i];
+                out << "(" << a.name << ", " << a.alias << ")";
+            }
+            out << "])";
+            break;
+        }
+        default:
+            assert(false);
+        }
+        break;
+    }
 
-    template<class T>
-    struct BigVec {
-        llvm::ArrayRef<T> v;
+    case EVAL_TOPLEVEL: {
+        const EvalTopLevel *eval = (const EvalTopLevel *)x;
+        out << "EvalTopLevel(" << eval->args << ")";
+        break;
+    }
 
-        BigVec(llvm::ArrayRef<T> v)
-            : v(v) {
+    case STATIC_ASSERT_TOP_LEVEL: {
+        const StaticAssertTopLevel *staticAssert =
+            (const StaticAssertTopLevel *)x;
+        out << "StaticAssertTopLevel(" << staticAssert->cond;
+        for (size_t i = 0; i < staticAssert->message->size(); ++i) {
+            out << ", " << staticAssert->message->exprs[i];
         }
-    };
+        out << ")";
+        break;
+    }
+
+    case MODULE_DECLARATION: {
+        const ModuleDeclaration *y = (const ModuleDeclaration *)x;
+        out << "ModuleDeclaration(" << y->name << ", " << y->attributes << ")";
+        break;
+    }
+    case MODULE: {
+        const Module *y = (const Module *)x;
+        out << "Module(" << bigVec(y->imports) << ", "
+            << bigVec(y->topLevelItems) << ")";
+        break;
+    }
+
+    case PRIM_OP: {
+        const PrimOp *y = (const PrimOp *)x;
+        out << "PrimOp(" << primOpName(const_cast<PrimOp *>(y)) << ")";
+        break;
+    }
+
+    case TYPE: {
+        const Type *y = (const Type *)x;
+        typePrint(out, const_cast<Type *>(y));
+        break;
+    }
+
+    case PATTERN: {
+        const Pattern *y = (const Pattern *)x;
+        patternPrint(out, const_cast<Pattern *>(y));
+        break;
+    }
+    case MULTI_PATTERN: {
+        const MultiPattern *y = (const MultiPattern *)x;
+        patternPrint(out, const_cast<MultiPattern *>(y));
+        break;
+    }
+
+    case VALUE_HOLDER: {
+        const ValueHolder *y = (const ValueHolder *)x;
+        EValuePtr ev = new EValue(y->type, y->buf);
+        out << "ValueHolder(";
+        printTypeAndValue(out, ev);
+        out << ")";
+        break;
+    }
+
+    case MULTI_STATIC: {
+        const MultiStatic *y = (const MultiStatic *)x;
+        out << "MultiStatic(" << y->values << ")";
+        break;
+    }
+
+    case PVALUE: {
+        const PValue *y = (const PValue *)x;
+        out << "PValue(" << y->data << ")";
+        break;
+    }
+
+    case MULTI_PVALUE: {
+        const MultiPValue *y = (const MultiPValue *)x;
+        out << "MultiPValue(" << llvm::ArrayRef(y->values) << ")";
+        break;
+    }
+
+    case EVALUE: {
+        const EValue *y = (const EValue *)x;
+        out << "EValue(" << y->type << ")";
+        break;
+    }
+
+    case MULTI_EVALUE: {
+        const MultiEValue *y = (const MultiEValue *)x;
+        out << "MultiEValue(" << y->values << ")";
+        break;
+    }
+
+    case CVALUE: {
+        const CValue *y = (const CValue *)x;
+        out << "CValue(" << y->type << ")";
+        break;
+    }
+
+    case MULTI_CVALUE: {
+        const MultiCValue *y = (const MultiCValue *)x;
+        out << "MultiCValue(" << y->values << ")";
+        break;
+    }
+
+    case DOCUMENTATION: {
+        const Documentation *d = (const Documentation *)x;
+        out << "Documentation(" << d->text << ")";
+        break;
+    }
+
+    default:
+        out << "UnknownObj(" << x->objKind << ")";
+        break;
+    }
+}
+
+//
+// printName
+//
+
+static int _safeNames = 0;
+
+void enableSafePrintName() { ++_safeNames; }
+
+void disableSafePrintName() {
+    --_safeNames;
+    assert(_safeNames >= 0);
+}
+
+void printNameList(llvm::raw_ostream &out, llvm::ArrayRef<ObjectPtr> x) {
+    for (size_t i = 0; i < x.size(); ++i) {
+        if (i != 0)
+            out << ", ";
+        printName(out, x[i]);
+    }
+}
 
-    template<class T>
-    BigVec<T> bigVec(const vector<T> &v) {
-        return BigVec<T>(v);
+void printNameList(llvm::raw_ostream &out, llvm::ArrayRef<ObjectPtr> x,
+                   llvm::ArrayRef<unsigned> dispatchIndices) {
+    for (size_t i = 0; i < x.size(); ++i) {
+        if (i != 0)
+            out << ", ";
+        if (find(dispatchIndices.begin(), dispatchIndices.end(), i) !=
+            dispatchIndices.end())
+            out << "*";
+        printName(out, x[i]);
     }
+}
 
-    static int indent = 0;
+void printNameList(llvm::raw_ostream &out, llvm::ArrayRef<TypePtr> x) {
+    for (size_t i = 0; i < x.size(); ++i) {
+        if (i != 0)
+            out << ", ";
+        printName(out, x[i].ptr());
+    }
+}
 
-    template<class T>
-    llvm::raw_ostream &operator<<(llvm::raw_ostream &out, const BigVec<T> &v) {
-        ++indent;
+static void printStaticOrTupleOfStatics(llvm::raw_ostream &out, TypePtr t) {
+    switch (t->typeKind) {
+    case STATIC_TYPE: {
+        StaticType *st = (StaticType *)t.ptr();
+        printName(out, st->obj);
+        break;
+    }
+    case TUPLE_TYPE: {
+        TupleType *tt = (TupleType *)t.ptr();
         out << "[";
-        T const *i, *end;
-        bool first = true;
-        for (i = v.v.begin(), end = v.v.end(); i != end; ++i) {
-            if (!first)
-                out << ",";
-            first = false;
-            out << "\n";
-            for (int j = 0; j < indent; ++j)
-                out << "  ";
-            out << *i;
+        for (size_t i = 0; i < tt->elementTypes.size(); ++i) {
+            if (i != 0)
+                out << ", ";
+            printStaticOrTupleOfStatics(out, tt->elementTypes[i]);
         }
         out << "]";
-        --indent;
-        return out;
+        break;
     }
+    default:
+        assert(false);
+    }
+}
 
-    //
-    // print PatternVar
-    //
+static bool isSafe(char ch) {
+    if ((ch >= '0') && (ch <= '9'))
+        return true;
+    if ((ch >= 'a') && (ch <= 'z'))
+        return true;
+    if ((ch >= 'A') && (ch <= 'Z'))
+        return true;
+    if (ch == '_')
+        return true;
+    return false;
+}
 
-    llvm::raw_ostream &operator<<(llvm::raw_ostream &out, const PatternVar &pvar) {
-        out << "PatternVar(" << pvar.isMulti << ", " << pvar.name << ")";
-        return out;
+void printStaticName(llvm::raw_ostream &out, ObjectPtr x) {
+    if (x->objKind == IDENTIFIER) {
+        Identifier *y = (Identifier *)x.ptr();
+        out << y->str;
+    } else {
+        printName(out, x);
     }
+}
 
-    //
-    // print
-    //
-
-    static void printExpr(llvm::raw_ostream &out, const Expr *x) {
-        switch (x->exprKind) {
-            case BOOL_LITERAL: {
-                const BoolLiteral *y = (const BoolLiteral *) x;
-                out << "BoolLiteral(" << y->value << ")";
-                break;
-            }
-            case INT_LITERAL: {
-                const IntLiteral *y = (const IntLiteral *) x;
-                out << "IntLiteral(" << y->value;
-                if (!y->suffix.empty())
-                    out << ", " << y->suffix;
-                out << ")";
-                break;
-            }
-            case FLOAT_LITERAL: {
-                const FloatLiteral *y = (const FloatLiteral *) x;
-                out << "FloatLiteral(" << y->value;
-                if (!y->suffix.empty())
-                    out << ", " << y->suffix;
-                out << ")";
-                break;
-            }
-            case CHAR_LITERAL: {
-                const CharLiteral *y = (const CharLiteral *) x;
-                out << "CharLiteral(" << y->value << ")";
-                break;
+void printName(llvm::raw_ostream &out, ObjectPtr x) {
+    switch (x->objKind) {
+    case IDENTIFIER: {
+        Identifier *y = (Identifier *)x.ptr();
+        if (_safeNames > 0) {
+            out << "#";
+            for (unsigned i = 0; i < y->str.size(); ++i) {
+                char ch = y->str[i];
+                if (isSafe(ch))
+                    out << ch;
+                else
+                    out << 'c' << (unsigned int)ch;
             }
-            case STRING_LITERAL: {
-                const StringLiteral *y = (const StringLiteral *) x;
-                out << "StringLiteral(" << y->value << ")";
-                break;
+        } else {
+            out << "\"";
+            for (unsigned i = 0; i < y->str.size(); ++i) {
+                char ch = y->str[i];
+                switch (ch) {
+                case '\0':
+                    out << "\\0";
+                    break;
+                case '\n':
+                    out << "\\n";
+                    break;
+                case '\r':
+                    out << "\\r";
+                    break;
+                case '\t':
+                    out << "\\t";
+                    break;
+                case '\f':
+                    out << "\\f";
+                    break;
+                case '\\':
+                    out << "\\\\";
+                    break;
+                case '\'':
+                    out << "\\'";
+                    break;
+                case '\"':
+                    out << "\\\"";
+                    break;
+                default:
+                    if (ch >= '\x20' && ch <= '\x7E')
+                        out << ch;
+                    else {
+                        out << "\\x";
+                        if (ch < 16)
+                            out << '0';
+                        out.write_hex((unsigned long long int)ch);
+                    }
+                    break;
+                }
             }
+            out << "\"";
+        }
+        break;
+    }
+    case GLOBAL_VARIABLE: {
+        GlobalVariable *y = (GlobalVariable *)x.ptr();
+        out << y->name->str;
+        break;
+    }
+    case GLOBAL_ALIAS: {
+        GlobalAlias *y = (GlobalAlias *)x.ptr();
+        out << y->name->str;
+        break;
+    }
+    case RECORD_DECL: {
+        RecordDecl *y = (RecordDecl *)x.ptr();
+        out << y->name->str;
+        break;
+    }
+    case VARIANT_DECL: {
+        VariantDecl *y = (VariantDecl *)x.ptr();
+        out << y->name->str;
+        break;
+    }
+    case PROCEDURE: {
+        Procedure *y = (Procedure *)x.ptr();
+        out << y->name->str;
+        break;
+    }
+    case MODULE: {
+        Module *m = (Module *)x.ptr();
+        out << m->moduleName;
+        break;
+    }
+    case INTRINSIC: {
+        IntrinsicSymbol *intrin = (IntrinsicSymbol *)x.ptr();
+        out << intrin->name->str;
+        break;
+    }
+    case PRIM_OP: {
+        out << primOpName((PrimOp *)x.ptr());
+        break;
+    }
+    case TYPE: {
+        typePrint(out, (Type *)x.ptr());
+        break;
+    }
+    case VALUE_HOLDER: {
+        ValueHolder *y = (ValueHolder *)x.ptr();
+        if (isStaticOrTupleOfStatics(y->type)) {
+            printStaticOrTupleOfStatics(out, y->type);
+        } else {
+            EValuePtr ev = new EValue(y->type, y->buf);
+            printValue(out, ev);
+        }
+        break;
+    }
+    case EXTERNAL_PROCEDURE: {
+        ExternalProcedure *proc = (ExternalProcedure *)x.ptr();
+        out << "external " << proc->name->str;
+        break;
+    }
+    default: {
+        out << "UnknownNamedObject(" << x->objKind << ")";
+        break;
+    }
+    }
+}
 
-            case NAME_REF: {
-                const NameRef *y = (const NameRef *) x;
-                out << "NameRef(" << y->name << ")";
-                break;
-            }
-            case TUPLE: {
-                const Tuple *y = (const Tuple *) x;
-                out << "Tuple(" << y->args << ")";
-                break;
-            }
-            case PAREN: {
-                const Paren *y = (const Paren *) x;
-                out << "Paren(" << y->args << ")";
-                break;
-            }
-            case INDEXING: {
-                const Indexing *y = (const Indexing *) x;
-                out << "Indexing(" << y->expr << ", " << y->args << ")";
+//
+// printTypeAndValue, printValue
+//
+
+void printTypeAndValue(llvm::raw_ostream &out, EValuePtr ev) {
+    printName(out, ev->type.ptr());
+    out << "(";
+    printValue(out, ev);
+    out << ")";
+}
+
+void printValue(llvm::raw_ostream &out, EValuePtr ev) {
+    switch (ev->type->typeKind) {
+    case BOOL_TYPE: {
+        bool v = ev->as<bool>();
+        out << (v ? "true" : "false");
+        break;
+    }
+    case INTEGER_TYPE: {
+        IntegerType *t = (IntegerType *)ev->type.ptr();
+        if (t->isSigned) {
+            switch (t->bits) {
+            case 8:
+                out << int(ev->as<signed char>());
                 break;
-            }
-            case CALL: {
-                const Call *y = (const Call *) x;
-                out << "Call(" << y->expr << ", " << y->parenArgs << ")";
+            case 16:
+                out << ev->as<short>();
                 break;
-            }
-            case FIELD_REF: {
-                const FieldRef *y = (const FieldRef *) x;
-                out << "FieldRef(" << y->expr << ", " << y->name << ")";
+            case 32:
+                out << ev->as<int>();
                 break;
-            }
-            case STATIC_INDEXING: {
-                const StaticIndexing *y = (const StaticIndexing *) x;
-                out << "StaticIndexing(" << y->expr << ", " << y->index << ")";
+            case 64:
+                out << ev->as<long long>();
                 break;
+            default:
+                assert(false);
             }
-
-            case VARIADIC_OP: {
-                const VariadicOp *y = (const VariadicOp *) x;
-                out << "VariadicOp(" << y->op << ", " << y->exprs << ")";
+        } else {
+            switch (t->bits) {
+            case 8:
+                out << int(ev->as<unsigned char>());
                 break;
-            }
-            case AND: {
-                const And *y = (const And *) x;
-                out << "And(" << y->expr1 << ", " << y->expr2 << ")";
+            case 16:
+                out << ev->as<unsigned short>();
                 break;
-            }
-            case OR: {
-                const Or *y = (const Or *) x;
-                out << "Or(" << y->expr1 << ", " << y->expr2 << ")";
+            case 32:
+                out << ev->as<unsigned int>();
                 break;
-            }
-            case LAMBDA: {
-                const Lambda *y = (const Lambda *) x;
-                out << "Lambda(" << y->captureBy << ", " << y->formalArgs
-                        << ", " << y->hasVarArg << ", " << y->body << ")";
-                break;
-            }
-            case UNPACK: {
-                const Unpack *y = (const Unpack *) x;
-                out << "Unpack(" << y->expr << ")";
-                break;
-            }
-            case STATIC_EXPR: {
-                const StaticExpr *y = (const StaticExpr *) x;
-                out << "StaticExpr(" << y->expr << ")";
-                break;
-            }
-            case DISPATCH_EXPR: {
-                const DispatchExpr *y = (const DispatchExpr *) x;
-                out << "DispatchExpr(" << y->expr << ")";
-                break;
-            }
-            case FOREIGN_EXPR: {
-                const ForeignExpr *y = (const ForeignExpr *) x;
-                out << "ForeignExpr(" << y->expr << ")";
-                break;
-            }
-            case OBJECT_EXPR: {
-                const ObjectExpr *y = (const ObjectExpr *) x;
-                out << "ObjectExpr(" << y->obj << ")";
-                break;
-            }
-            case EVAL_EXPR: {
-                const EvalExpr *eval = (const EvalExpr *) x;
-                out << "EvalExpr(" << eval->args << ")";
-                break;
-            }
-            case FILE_EXPR: {
-                out << "FILEExpr()";
-                break;
-            }
-            case LINE_EXPR: {
-                out << "LINEExpr()";
-                break;
-            }
-            case COLUMN_EXPR: {
-                out << "COLUMNExpr()";
-                break;
-            }
-            case ARG_EXPR: {
-                const ARGExpr *arg = (const ARGExpr *) x;
-                out << "ARGExpr(" << arg->name << ")";
+            case 64:
+                out << ev->as<unsigned long long>();
                 break;
+            default:
+                assert(false);
             }
         }
+        break;
     }
-
-    static void printStatement(llvm::raw_ostream &out, const Statement *x) {
-        switch (x->stmtKind) {
-            case BLOCK: {
-                const Block *y = (const Block *) x;
-                out << "Block(" << bigVec(y->statements) << ")";
-                break;
-            }
-            case LABEL: {
-                const Label *y = (const Label *) x;
-                out << "Label(" << y->name << ")";
-                break;
-            }
-            case BINDING: {
-                const Binding *y = (const Binding *) x;
-                out << "Binding(" << y->bindingKind << ", " << y->args << ", " << y->values << ")";
-                break;
-            }
-            case ASSIGNMENT: {
-                const Assignment *y = (const Assignment *) x;
-                out << "Assignment(" << y->left << ", " << y->right << ")";
-                break;
-            }
-            case INIT_ASSIGNMENT: {
-                const InitAssignment *y = (const InitAssignment *) x;
-                out << "InitAssignment(" << y->left << ", " << y->right << ")";
-                break;
-            }
-            case VARIADIC_ASSIGNMENT: {
-                const VariadicAssignment *y = (const VariadicAssignment *) x;
-                out << "VariadicAssignment(" << y->op;
-                out << ", " << y->exprs->exprs << ")";
-                break;
-            }
-            case GOTO: {
-                const Goto *y = (const Goto *) x;
-                out << "Goto(" << y->labelName << ")";
-                break;
-            }
-            case RETURN: {
-                const Return *y = (const Return *) x;
-                out << "Return(" << y->returnKind << ", " << y->values << ")";
-                break;
-            }
-            case IF: {
-                const If *y = (const If *) x;
-                out << "If(" << y->condition << ", " << y->thenPart;
-                out << ", " << y->elsePart << ")";
-                break;
-            }
-            case SWITCH: {
-                const Switch *y = (const Switch *) x;
-                out << "Switch(" << y->expr << ", " << y->caseBlocks
-                        << ", " << y->defaultCase << ")";
-                break;
-            }
-            case EXPR_STATEMENT: {
-                const ExprStatement *y = (const ExprStatement *) x;
-                out << "ExprStatement(" << y->expr << ")";
-                break;
-            }
-            case WHILE: {
-                const While *y = (const While *) x;
-                out << "While(" << y->condition << ", " << y->body << ")";
-                break;
-            }
-            case BREAK: {
-                out << "Break()";
-                break;
-            }
-            case CONTINUE: {
-                out << "Continue()";
-                break;
-            }
-            case FOR: {
-                const For *y = (const For *) x;
-                out << "For(" << y->variables << ", " << y->expr;
-                out << ", " << y->body << ")";
-                break;
-            }
-            case FOREIGN_STATEMENT: {
-                const ForeignStatement *y = (const ForeignStatement *) x;
-                out << "ForeignStatement(" << y->statement << ")";
-                break;
-            }
-            case TRY: {
-                const Try *y = (const Try *) x;
-                out << "Try(" << y->tryBlock << ", " << y->catchBlocks << ")";
-                break;
-            }
-            case THROW: {
-                const Throw *y = (const Throw *) x;
-                out << "Throw(" << y->expr << ", " << y->context << ")";
-                break;
-            }
-            case STATIC_FOR: {
-                const StaticFor *y = (const StaticFor *) x;
-                out << "StaticFor(" << y->variable << ", " << y->values
-                        << ", " << y->body << ")";
-                break;
-            }
-            case FINALLY: {
-                const Finally *y = (const Finally *) x;
-                out << "Finally(" << y->body << ")";
-                break;
-            }
-            case ONERROR: {
-                const OnError *y = (const OnError *) x;
-                out << "OnError(" << y->body << ")";
-                break;
-            }
-            case UNREACHABLE: {
-                out << "Unreachable()";
-                break;
-            }
-            case EVAL_STATEMENT: {
-                const EvalStatement *eval = (const EvalStatement *) x;
-                out << "EvalStatement(" << eval->args << ")";
-                break;
-            }
-            case STATIC_ASSERT_STATEMENT: {
-                const StaticAssertStatement *staticAssert = (const StaticAssertStatement *) x;
-                out << "StaticAssertStatement(" << staticAssert->cond;
-                for (size_t i = 0; i < staticAssert->message->size(); ++i) {
-                    out << ", " << staticAssert->message->exprs[i];
-                }
-                out << ")";
-                break;
-            }
+    case FLOAT_TYPE: {
+        FloatType *t = (FloatType *)ev->type.ptr();
+        switch (t->bits) {
+        case 32:
+            writeFloat(out, ev->as<float>());
+            break;
+        case 64:
+            writeFloat(out, ev->as<double>());
+            break;
+        case 80:
+            writeFloat(out, ev->as<long double>());
+            break;
+        default:
+            assert(false);
         }
+        break;
     }
-
-    static void print(llvm::raw_ostream &out, const Object *x) {
-        if (x == nullptr) {
-            out << "NULL";
-            return;
+    case COMPLEX_TYPE: {
+        ComplexType *t = (ComplexType *)ev->type.ptr();
+        switch (t->bits) {
+        case 32:
+            writeFloat(out, ev->as<clay_cfloat>());
+            break;
+        case 64:
+            writeFloat(out, ev->as<clay_cdouble>());
+            break;
+        case 80:
+            writeFloat(out, ev->as<clay_cldouble>());
+            break;
+        default:
+            assert(false);
         }
+        break;
+    }
+    case ENUM_TYPE: {
+        EnumType *t = (EnumType *)ev->type.ptr();
+        llvm::ArrayRef<EnumMemberPtr> members = t->enumeration->members;
+        int member = ev->as<int>();
 
-        switch (x->objKind) {
-            case SOURCE: {
-                const Source *y = (const Source *) x;
-                out << "Source(" << y->fileName << ")";
-                break;
-            }
-            case IDENTIFIER: {
-                const Identifier *y = (const Identifier *) x;
-                out << "Identifier(" << y->str << ")";
-                break;
-            }
-            case DOTTED_NAME: {
-                const DottedName *y = (const DottedName *) x;
-                out << "DottedName(" << llvm::ArrayRef(y->parts) << ")";
-                break;
-            }
-
-            case EXPRESSION: {
-                const Expr *y = (const Expr *) x;
-                printExpr(out, y);
-                break;
-            }
-
-            case EXPR_LIST: {
-                const ExprList *y = (const ExprList *) x;
-                out << "ExprList(" << y->exprs << ")";
-                break;
-            }
-
-            case STATEMENT: {
-                const Statement *y = (const Statement *) x;
-                printStatement(out, y);
-                break;
-            }
-
-            case CASE_BLOCK: {
-                const CaseBlock *y = (const CaseBlock *) x;
-                out << "CaseBlock(" << y->caseLabels << ", " << y->body << ")";
-                break;
-            }
-
-            case CATCH: {
-                const Catch *y = (const Catch *) x;
-                out << "Catch(" << y->exceptionVar << ", "
-                        << y->exceptionType << ", " << y->body << ")";
-                break;
-            }
-
-            case CODE: {
-                const Code *y = (const Code *) x;
-                out << "Code(" << y->patternVars << ", " << y->predicate;
-                out << ", " << y->formalArgs << ", " << y->hasVarArg;
-                out << ", " << y->returnSpecs << ", " << y->varReturnSpec;
-                out << ", " << y->body << ")";
-                break;
-            }
-            case FORMAL_ARG: {
-                const FormalArg *y = (const FormalArg *) x;
-                out << "FormalArg(" << y->name << ", " << y->type << ", "
-                        << y->tempness << ")";
-                break;
-            }
-            case RETURN_SPEC: {
-                const ReturnSpec *y = (const ReturnSpec *) x;
-                out << "ReturnSpec(" << y->type << ", " << y->name << ")";
-                break;
-            }
-
-            case RECORD_DECL: {
-                const RecordDecl *y = (const RecordDecl *) x;
-                out << "RecordDecl(" << y->name << ", " << y->params;
-                out << ", " << y->varParam << ", " << y->body << ")";
-                break;
-            }
-            case RECORD_BODY: {
-                const RecordBody *y = (const RecordBody *) x;
-                out << "RecordBody(" << y->isComputed << ", " << y->computed;
-                out << ", " << y->fields << ")";
-                break;
-            }
-            case RECORD_FIELD: {
-                const RecordField *y = (const RecordField *) x;
-                out << "RecordField(" << y->name << ", " << y->type << ")";
-                break;
-            }
-
-            case VARIANT_DECL: {
-                const VariantDecl *y = (const VariantDecl *) x;
-                out << "VariantDecl(" << y->name << ", " << y->params;
-                out << ", " << y->varParam << ")";
-                break;
-            }
-            case INSTANCE_DECL: {
-                const InstanceDecl *y = (const InstanceDecl *) x;
-                out << "InstanceDecl(" << y->patternVars << ", " << y->predicate;
-                out << ", " << y->target << ", " << y->members << ")";
-                break;
-            }
-
-            case OVERLOAD: {
-                const Overload *y = (const Overload *) x;
-                out << "Overload(" << y->target << ", " << y->code << ", "
-                        << y->callByName << ", " << y->isInline << ")";
-                break;
-            }
-            case PROCEDURE: {
-                const Procedure *y = (const Procedure *) x;
-                out << "Procedure(" << y->name << ")";
-                break;
-            }
-            case INTRINSIC: {
-                const IntrinsicSymbol *intrin = (const IntrinsicSymbol *) x;
-                out << "IntrinsicSymbol(" << intrin->name << ", " << intrin->id << ")";
-                break;
-            }
-
-            case ENUM_DECL: {
-                const EnumDecl *y = (const EnumDecl *) x;
-                out << "EnumDecl(" << y->name << ", " << y->members << ")";
-                break;
-            }
-            case ENUM_MEMBER: {
-                const EnumMember *y = (const EnumMember *) x;
-                out << "EnumMember(" << y->name << ")";
-                break;
-            }
-
-            case NEW_TYPE_DECL: {
-                const NewTypeDecl *y = (const NewTypeDecl *) x;
-                out << "NewTypeDecl(" << y->name << ")";
-                break;
-            }
-
-            case GLOBAL_VARIABLE: {
-                const GlobalVariable *y = (const GlobalVariable *) x;
-                out << "GlobalVariable(" << y->name << ", " << y->params
-                        << ", " << y->varParam << ", " << y->expr << ")";
-                break;
-            }
-
-            case EXTERNAL_PROCEDURE: {
-                const ExternalProcedure *y = (const ExternalProcedure *) x;
-                out << "ExternalProcedure(" << y->name << ", " << y->args;
-                out << ", " << y->hasVarArgs << ", " << y->returnType;
-                out << ", " << y->body << ")";
-                break;
-            }
-            case EXTERNAL_ARG: {
-                const ExternalArg *y = (const ExternalArg *) x;
-                out << "ExternalArg(" << y->name << ", " << y->type << ")";
-                break;
-            }
-
-            case EXTERNAL_VARIABLE: {
-                const ExternalVariable *y = (const ExternalVariable *) x;
-                out << "ExternalVariable(" << y->name << ", " << y->type << ")";
-                break;
-            }
-
-            case GLOBAL_ALIAS: {
-                const GlobalAlias *y = (const GlobalAlias *) x;
-                out << "GlobalAlias(" << y->name << ", " << y->params
-                        << ", " << y->varParam << ", " << y->expr << ")";
-                break;
-            }
-
-            case IMPORT: {
-                const Import *y = (const Import *) x;
-                switch (y->importKind) {
-                    case IMPORT_MODULE: {
-                        const ImportModule *z = (const ImportModule *) y;
-                        out << "Import(" << z->dottedName << ", " << z->alias << ")";
-                        break;
-                    }
-                    case IMPORT_STAR: {
-                        const ImportStar *z = (const ImportStar *) y;
-                        out << "ImportStar(" << z->dottedName << ")";
-                        break;
-                    }
-                    case IMPORT_MEMBERS: {
-                        const ImportMembers *z = (const ImportMembers *) y;
-                        out << "ImportMembers(" << z->visibility << ", " << z->dottedName << ", [";
-                        for (size_t i = 0; i < z->members.size(); ++i) {
-                            if (i != 0)
-                                out << ", ";
-                            const ImportedMember &a = z->members[i];
-                            out << "(" << a.name << ", " << a.alias << ")";
-                        }
-                        out << "])";
-                        break;
-                    }
-                    default:
-                        assert(false);
-                }
-                break;
-            }
-
-            case EVAL_TOPLEVEL: {
-                const EvalTopLevel *eval = (const EvalTopLevel *) x;
-                out << "EvalTopLevel(" << eval->args << ")";
-                break;
-            }
-
-            case STATIC_ASSERT_TOP_LEVEL: {
-                const StaticAssertTopLevel *staticAssert = (const StaticAssertTopLevel *) x;
-                out << "StaticAssertTopLevel(" << staticAssert->cond;
-                for (size_t i = 0; i < staticAssert->message->size(); ++i) {
-                    out << ", " << staticAssert->message->exprs[i];
-                }
-                out << ")";
-                break;
-            }
-
-            case MODULE_DECLARATION: {
-                const ModuleDeclaration *y = (const ModuleDeclaration *) x;
-                out << "ModuleDeclaration(" << y->name << ", " << y->attributes << ")";
-                break;
-            }
-            case MODULE: {
-                const Module *y = (const Module *) x;
-                out << "Module(" << bigVec(y->imports) << ", "
-                        << bigVec(y->topLevelItems) << ")";
-                break;
-            }
-
-            case PRIM_OP: {
-                const PrimOp *y = (const PrimOp *) x;
-                out << "PrimOp(" << primOpName(const_cast<PrimOp *>(y)) << ")";
-                break;
-            }
-
-            case TYPE: {
-                const Type *y = (const Type *) x;
-                typePrint(out, const_cast<Type *>(y));
-                break;
-            }
-
-            case PATTERN: {
-                const Pattern *y = (const Pattern *) x;
-                patternPrint(out, const_cast<Pattern *>(y));
-                break;
-            }
-            case MULTI_PATTERN: {
-                const MultiPattern *y = (const MultiPattern *) x;
-                patternPrint(out, const_cast<MultiPattern *>(y));
-                break;
-            }
-
-            case VALUE_HOLDER: {
-                const ValueHolder *y = (const ValueHolder *) x;
-                EValuePtr ev = new EValue(y->type, y->buf);
-                out << "ValueHolder(";
-                printTypeAndValue(out, ev);
-                out << ")";
-                break;
-            }
-
-            case MULTI_STATIC: {
-                const MultiStatic *y = (const MultiStatic *) x;
-                out << "MultiStatic(" << y->values << ")";
-                break;
-            }
-
-            case PVALUE: {
-                const PValue *y = (const PValue *) x;
-                out << "PValue(" << y->data << ")";
-                break;
-            }
-
-            case MULTI_PVALUE: {
-                const MultiPValue *y = (const MultiPValue *) x;
-                out << "MultiPValue(" << llvm::ArrayRef(y->values) << ")";
-                break;
-            }
-
-            case EVALUE: {
-                const EValue *y = (const EValue *) x;
-                out << "EValue(" << y->type << ")";
-                break;
-            }
-
-            case MULTI_EVALUE: {
-                const MultiEValue *y = (const MultiEValue *) x;
-                out << "MultiEValue(" << y->values << ")";
-                break;
-            }
-
-            case CVALUE: {
-                const CValue *y = (const CValue *) x;
-                out << "CValue(" << y->type << ")";
-                break;
-            }
+        if (member >= 0 && size_t(member) < members.size()) {
+            out << members[(size_t)member]->name->str;
+        } else {
+            printName(out, t);
+            out << '(' << member << ')';
+        }
+        break;
+    }
+    default:
+        break;
+    }
+}
 
-            case MULTI_CVALUE: {
-                const MultiCValue *y = (const MultiCValue *) x;
-                out << "MultiCValue(" << y->values << ")";
-                break;
-            }
+string shortString(llvm::StringRef in) {
+    string out;
+    bool wasSpace = false;
 
-            case DOCUMENTATION: {
-                const Documentation *d = (const Documentation *) x;
-                out << "Documentation(" << d->text << ")";
-                break;
+    for (const char *i = in.begin(); i != in.end(); ++i) {
+        if (isspace(*i)) {
+            if (!wasSpace) {
+                out.push_back(' ');
+                wasSpace = true;
             }
-
-            default:
-                out << "UnknownObj(" << x->objKind << ")";
-                break;
+        } else {
+            out.push_back(*i);
+            wasSpace = false;
         }
     }
-    
-    //
-    // printName
-    //
+    return out;
+}
 
-    static int _safeNames = 0;
+//
+// patternPrint
+//
 
-    void enableSafePrintName() {
-        ++_safeNames;
+void patternPrint(llvm::raw_ostream &out, PatternPtr x) {
+    switch (x->kind) {
+    case PATTERN_CELL: {
+        PatternCell *y = (PatternCell *)x.ptr();
+        out << "PatternCell(" << y->obj << ")";
+        break;
+    }
+    case PATTERN_STRUCT: {
+        PatternStruct *y = (PatternStruct *)x.ptr();
+        out << "PatternStruct(" << y->head << ", " << y->params << ")";
+        break;
     }
+    default:
+        assert(false);
+    }
+}
 
-    void disableSafePrintName() {
-        --_safeNames;
-        assert(_safeNames >= 0);
+void patternPrint(llvm::raw_ostream &out, MultiPatternPtr x) {
+    switch (x->kind) {
+    case MULTI_PATTERN_CELL: {
+        MultiPatternCell *y = (MultiPatternCell *)x.ptr();
+        out << "MultiPatternCell(" << y->data << ")";
+        break;
+    }
+    case MULTI_PATTERN_LIST: {
+        MultiPatternList *y = (MultiPatternList *)x.ptr();
+        out << "MultiPatternList(" << y->items << ", " << y->tail << ")";
+        break;
     }
+    default:
+        assert(false);
+    }
+}
 
-    void printNameList(llvm::raw_ostream &out, llvm::ArrayRef<ObjectPtr> x) {
-        for (size_t i = 0; i < x.size(); ++i) {
-            if (i != 0)
-                out << ", ";
-            printName(out, x[i]);
+// typePrint
+
+void typePrint(llvm::raw_ostream &out, TypePtr t) {
+    switch (t->typeKind) {
+    case BOOL_TYPE:
+        out << "Bool";
+        break;
+    case INTEGER_TYPE: {
+        IntegerType *x = (IntegerType *)t.ptr();
+        if (!x->isSigned)
+            out << "U";
+        out << "Int" << x->bits;
+        break;
+    }
+    case FLOAT_TYPE: {
+        FloatType *x = (FloatType *)t.ptr();
+        if (x->isImaginary) {
+            out << "Imag" << x->bits;
+        } else {
+            out << "Float" << x->bits;
         }
+        break;
     }
-
-    void printNameList(llvm::raw_ostream &out, llvm::ArrayRef<ObjectPtr> x, llvm::ArrayRef<unsigned> dispatchIndices) {
-        for (size_t i = 0; i < x.size(); ++i) {
+    case COMPLEX_TYPE: {
+        ComplexType *x = (ComplexType *)t.ptr();
+        out << "Complex" << x->bits;
+        break;
+    }
+    case POINTER_TYPE: {
+        PointerType *x = (PointerType *)t.ptr();
+        out << "Pointer[" << x->pointeeType << "]";
+        break;
+    }
+    case CODE_POINTER_TYPE: {
+        CodePointerType *x = (CodePointerType *)t.ptr();
+        out << "CodePointer[[";
+        for (size_t i = 0; i < x->argTypes.size(); ++i) {
             if (i != 0)
                 out << ", ";
-            if (find(dispatchIndices.begin(), dispatchIndices.end(), i) != dispatchIndices.end())
-                out << "*";
-            printName(out, x[i]);
+            out << x->argTypes[i];
         }
-    }
-
-    void printNameList(llvm::raw_ostream &out, llvm::ArrayRef<TypePtr> x) {
-        for (size_t i = 0; i < x.size(); ++i) {
+        out << "], [";
+        for (size_t i = 0; i < x->returnTypes.size(); ++i) {
             if (i != 0)
                 out << ", ";
-            printName(out, x[i].ptr());
+            if (x->returnIsRef[i])
+                out << "ByRef[" << x->returnTypes[i] << "]";
+            else
+                out << x->returnTypes[i];
         }
+        out << "]]";
+        break;
     }
+    case CCODE_POINTER_TYPE: {
+        CCodePointerType *x = (CCodePointerType *)t.ptr();
+        out << "ExternalCodePointer[";
+
+#define CALLING_CONV_PRINT(e, str)                                             \
+    case e:                                                                    \
+        out << str << ", ";                                                    \
+        break;
+        switch (x->callingConv) {
+            CALLING_CONV_MAP(CALLING_CONV_PRINT)
+        default:
+            assert(false);
+        }
+#undef CALLING_CONV_PRINT
 
-    static void printStaticOrTupleOfStatics(llvm::raw_ostream &out, TypePtr t) {
-        switch (t->typeKind) {
-            case STATIC_TYPE: {
-                StaticType *st = (StaticType *) t.ptr();
-                printName(out, st->obj);
-                break;
-            }
-            case TUPLE_TYPE: {
-                TupleType *tt = (TupleType *) t.ptr();
-                out << "[";
-                for (size_t i = 0; i < tt->elementTypes.size(); ++i) {
-                    if (i != 0)
-                        out << ", ";
-                    printStaticOrTupleOfStatics(out, tt->elementTypes[i]);
-                }
-                out << "]";
-                break;
-            }
-            default:
-                assert(false);
+        if (x->hasVarArgs)
+            out << "true, ";
+        else
+            out << "false, ";
+        out << "[";
+        for (size_t i = 0; i < x->argTypes.size(); ++i) {
+            if (i != 0)
+                out << ", ";
+            out << x->argTypes[i];
         }
+        out << "], [";
+        if (x->returnType.ptr())
+            out << x->returnType;
+        out << "]]";
+        break;
     }
-
-    static bool isSafe(char ch) {
-        if ((ch >= '0') && (ch <= '9'))
-            return true;
-        if ((ch >= 'a') && (ch <= 'z'))
-            return true;
-        if ((ch >= 'A') && (ch <= 'Z'))
-            return true;
-        if (ch == '_')
-            return true;
-        return false;
+    case ARRAY_TYPE: {
+        ArrayType *x = (ArrayType *)t.ptr();
+        out << "Array[" << x->elementType << ", " << x->size << "]";
+        break;
     }
-
-    void printStaticName(llvm::raw_ostream &out, ObjectPtr x) {
-        if (x->objKind == IDENTIFIER) {
-            Identifier *y = (Identifier *) x.ptr();
-            out << y->str;
-        } else {
-            printName(out, x);
-        }
+    case VEC_TYPE: {
+        VecType *x = (VecType *)t.ptr();
+        out << "Vec[" << x->elementType << ", " << x->size << "]";
+        break;
     }
-
-    void printName(llvm::raw_ostream &out, ObjectPtr x) {
-        switch (x->objKind) {
-            case IDENTIFIER: {
-                Identifier *y = (Identifier *) x.ptr();
-                if (_safeNames > 0) {
-                    out << "#";
-                    for (unsigned i = 0; i < y->str.size(); ++i) {
-                        char ch = y->str[i];
-                        if (isSafe(ch))
-                            out << ch;
-                        else
-                            out << 'c' << (unsigned int) ch;
-                    }
-                } else {
-                    out << "\"";
-                    for (unsigned i = 0; i < y->str.size(); ++i) {
-                        char ch = y->str[i];
-                        switch (ch) {
-                            case '\0':
-                                out << "\\0";
-                                break;
-                            case '\n':
-                                out << "\\n";
-                                break;
-                            case '\r':
-                                out << "\\r";
-                                break;
-                            case '\t':
-                                out << "\\t";
-                                break;
-                            case '\f':
-                                out << "\\f";
-                                break;
-                            case '\\':
-                                out << "\\\\";
-                                break;
-                            case '\'':
-                                out << "\\'";
-                                break;
-                            case '\"':
-                                out << "\\\"";
-                                break;
-                            default:
-                                if (ch >= '\x20' && ch <= '\x7E')
-                                    out << ch;
-                                else {
-                                    out << "\\x";
-                                    if (ch < 16)
-                                        out << '0';
-                                    out.write_hex((unsigned long long int) ch);
-                                }
-                                break;
-                        }
-                    }
-                    out << "\"";
-                }
-                break;
-            }
-            case GLOBAL_VARIABLE: {
-                GlobalVariable *y = (GlobalVariable *) x.ptr();
-                out << y->name->str;
-                break;
-            }
-            case GLOBAL_ALIAS: {
-                GlobalAlias *y = (GlobalAlias *) x.ptr();
-                out << y->name->str;
-                break;
-            }
-            case RECORD_DECL: {
-                RecordDecl *y = (RecordDecl *) x.ptr();
-                out << y->name->str;
-                break;
-            }
-            case VARIANT_DECL: {
-                VariantDecl *y = (VariantDecl *) x.ptr();
-                out << y->name->str;
-                break;
-            }
-            case PROCEDURE: {
-                Procedure *y = (Procedure *) x.ptr();
-                out << y->name->str;
-                break;
-            }
-            case MODULE: {
-                Module *m = (Module *) x.ptr();
-                out << m->moduleName;
-                break;
-            }
-            case INTRINSIC: {
-                IntrinsicSymbol *intrin = (IntrinsicSymbol *) x.ptr();
-                out << intrin->name->str;
-                break;
-            }
-            case PRIM_OP: {
-                out << primOpName((PrimOp *) x.ptr());
-                break;
-            }
-            case TYPE: {
-                typePrint(out, (Type *) x.ptr());
-                break;
-            }
-            case VALUE_HOLDER: {
-                ValueHolder *y = (ValueHolder *) x.ptr();
-                if (isStaticOrTupleOfStatics(y->type)) {
-                    printStaticOrTupleOfStatics(out, y->type);
-                } else {
-                    EValuePtr ev = new EValue(y->type, y->buf);
-                    printValue(out, ev);
-                }
-                break;
-            }
-            case EXTERNAL_PROCEDURE: {
-                ExternalProcedure *proc = (ExternalProcedure *) x.ptr();
-                out << "external " << proc->name->str;
-                break;
-            }
-            default: {
-                out << "UnknownNamedObject(" << x->objKind << ")";
-                break;
-            }
-        }
+    case TUPLE_TYPE: {
+        TupleType *x = (TupleType *)t.ptr();
+        out << "Tuple" << x->elementTypes;
+        break;
     }
-    
-    //
-    // printTypeAndValue, printValue
-    //
-
-    void printTypeAndValue(llvm::raw_ostream &out, EValuePtr ev) {
-        printName(out, ev->type.ptr());
-        out << "(";
-        printValue(out, ev);
-        out << ")";
+    case UNION_TYPE: {
+        UnionType *x = (UnionType *)t.ptr();
+        out << "Union" << x->memberTypes;
+        break;
     }
-
-    void printValue(llvm::raw_ostream &out, EValuePtr ev) {
-        switch (ev->type->typeKind) {
-            case BOOL_TYPE: {
-                bool v = ev->as<bool>();
-                out << (v ? "true" : "false");
-                break;
-            }
-            case INTEGER_TYPE: {
-                IntegerType *t = (IntegerType *) ev->type.ptr();
-                if (t->isSigned) {
-                    switch (t->bits) {
-                        case 8:
-                            out << int(ev->as<signed char>());
-                            break;
-                        case 16:
-                            out << ev->as<short>();
-                            break;
-                        case 32:
-                            out << ev->as<int>();
-                            break;
-                        case 64:
-                            out << ev->as<long long>();
-                            break;
-                        default:
-                            assert(false);
-                    }
-                } else {
-                    switch (t->bits) {
-                        case 8:
-                            out << int(ev->as<unsigned char>());
-                            break;
-                        case 16:
-                            out << ev->as<unsigned short>();
-                            break;
-                        case 32:
-                            out << ev->as<unsigned int>();
-                            break;
-                        case 64:
-                            out << ev->as<unsigned long long>();
-                            break;
-                        default:
-                            assert(false);
-                    }
-                }
-                break;
-            }
-            case FLOAT_TYPE: {
-                FloatType *t = (FloatType *) ev->type.ptr();
-                switch (t->bits) {
-                    case 32:
-                        writeFloat(out, ev->as<float>());
-                        break;
-                    case 64:
-                        writeFloat(out, ev->as<double>());
-                        break;
-                    case 80:
-                        writeFloat(out, ev->as<long double>());
-                        break;
-                    default:
-                        assert(false);
-                }
-                break;
-            }
-            case COMPLEX_TYPE: {
-                ComplexType *t = (ComplexType *) ev->type.ptr();
-                switch (t->bits) {
-                    case 32:
-                        writeFloat(out, ev->as<clay_cfloat>());
-                        break;
-                    case 64:
-                        writeFloat(out, ev->as<clay_cdouble>());
-                        break;
-                    case 80:
-                        writeFloat(out, ev->as<clay_cldouble>());
-                        break;
-                    default:
-                        assert(false);
-                }
-                break;
-            }
-            case ENUM_TYPE: {
-                EnumType *t = (EnumType *) ev->type.ptr();
-                llvm::ArrayRef<EnumMemberPtr> members = t->enumeration->members;
-                int member = ev->as<int>();
-
-                if (member >= 0 && size_t(member) < members.size()) {
-                    out << members[(size_t) member]->name->str;
-                } else {
-                    printName(out, t);
-                    out << '(' << member << ')';
-                }
-                break;
-            }
-            default:
-                break;
+    case RECORD_TYPE: {
+        RecordType *x = (RecordType *)t.ptr();
+        out << x->record->name->str;
+        if (!x->params.empty()) {
+            out << "[";
+            printNameList(out, x->params);
+            out << "]";
         }
+        break;
     }
-
-    string shortString(llvm::StringRef in) {
-        string out;
-        bool wasSpace = false;
-
-        for (const char *i = in.begin(); i != in.end(); ++i) {
-            if (isspace(*i)) {
-                if (!wasSpace) {
-                    out.push_back(' ');
-                    wasSpace = true;
-                }
-            } else {
-                out.push_back(*i);
-                wasSpace = false;
-            }
+    case VARIANT_TYPE: {
+        VariantType *x = (VariantType *)t.ptr();
+        out << x->variant->name->str;
+        if (!x->params.empty()) {
+            out << "[";
+            printNameList(out, x->params);
+            out << "]";
         }
-        return out;
+        break;
     }
-
-    //
-    // patternPrint
-    //
-
-    void patternPrint(llvm::raw_ostream &out, PatternPtr x) {
-        switch (x->kind) {
-            case PATTERN_CELL: {
-                PatternCell *y = (PatternCell *) x.ptr();
-                out << "PatternCell(" << y->obj << ")";
-                break;
-            }
-            case PATTERN_STRUCT: {
-                PatternStruct *y = (PatternStruct *) x.ptr();
-                out << "PatternStruct(" << y->head << ", " << y->params << ")";
-                break;
-            }
-            default:
-                assert(false);
-        }
+    case STATIC_TYPE: {
+        StaticType *x = (StaticType *)t.ptr();
+        out << "Static[";
+        printName(out, x->obj);
+        out << "]";
+        break;
     }
-
-    void patternPrint(llvm::raw_ostream &out, MultiPatternPtr x) {
-        switch (x->kind) {
-            case MULTI_PATTERN_CELL: {
-                MultiPatternCell *y = (MultiPatternCell *) x.ptr();
-                out << "MultiPatternCell(" << y->data << ")";
-                break;
-            }
-            case MULTI_PATTERN_LIST: {
-                MultiPatternList *y = (MultiPatternList *) x.ptr();
-                out << "MultiPatternList(" << y->items << ", " << y->tail << ")";
-                break;
-            }
-            default:
-                assert(false);
-        }
+    case ENUM_TYPE: {
+        EnumType *x = (EnumType *)t.ptr();
+        out << x->enumeration->name->str;
+        break;
     }
-
-    // typePrint
-
-    void typePrint(llvm::raw_ostream &out, TypePtr t) {
-        switch (t->typeKind) {
-            case BOOL_TYPE:
-                out << "Bool";
-                break;
-            case INTEGER_TYPE: {
-                IntegerType *x = (IntegerType *) t.ptr();
-                if (!x->isSigned)
-                    out << "U";
-                out << "Int" << x->bits;
-                break;
-            }
-            case FLOAT_TYPE: {
-                FloatType *x = (FloatType *) t.ptr();
-                if (x->isImaginary) {
-                    out << "Imag" << x->bits;
-                } else {
-                    out << "Float" << x->bits;
-                }
-                break;
-            }
-            case COMPLEX_TYPE: {
-                ComplexType *x = (ComplexType *) t.ptr();
-                out << "Complex" << x->bits;
-                break;
-            }
-            case POINTER_TYPE: {
-                PointerType *x = (PointerType *) t.ptr();
-                out << "Pointer[" << x->pointeeType << "]";
-                break;
-            }
-            case CODE_POINTER_TYPE: {
-                CodePointerType *x = (CodePointerType *) t.ptr();
-                out << "CodePointer[[";
-                for (size_t i = 0; i < x->argTypes.size(); ++i) {
-                    if (i != 0)
-                        out << ", ";
-                    out << x->argTypes[i];
-                }
-                out << "], [";
-                for (size_t i = 0; i < x->returnTypes.size(); ++i) {
-                    if (i != 0)
-                        out << ", ";
-                    if (x->returnIsRef[i])
-                        out << "ByRef[" << x->returnTypes[i] << "]";
-                    else
-                        out << x->returnTypes[i];
-                }
-                out << "]]";
-                break;
-            }
-            case CCODE_POINTER_TYPE: {
-                CCodePointerType *x = (CCodePointerType *) t.ptr();
-                out << "ExternalCodePointer[";
-
-#define CALLING_CONV_PRINT(e, str) case e: out << str << ", "; break;
-                switch (x->callingConv) {
-                    CALLING_CONV_MAP(CALLING_CONV_PRINT)
-                    default: assert(false);
-                }
-#undef CALLING_CONV_PRINT
-
-                if (x->hasVarArgs)
-                    out << "true, ";
-                else
-                    out << "false, ";
-                out << "[";
-                for (size_t i = 0; i < x->argTypes.size(); ++i) {
-                    if (i != 0)
-                        out << ", ";
-                    out << x->argTypes[i];
-                }
-                out << "], [";
-                if (x->returnType.ptr())
-                    out << x->returnType;
-                out << "]]";
-                break;
-            }
-            case ARRAY_TYPE: {
-                ArrayType *x = (ArrayType *) t.ptr();
-                out << "Array[" << x->elementType << ", " << x->size << "]";
-                break;
-            }
-            case VEC_TYPE: {
-                VecType *x = (VecType *) t.ptr();
-                out << "Vec[" << x->elementType << ", " << x->size << "]";
-                break;
-            }
-            case TUPLE_TYPE: {
-                TupleType *x = (TupleType *) t.ptr();
-                out << "Tuple" << x->elementTypes;
-                break;
-            }
-            case UNION_TYPE: {
-                UnionType *x = (UnionType *) t.ptr();
-                out << "Union" << x->memberTypes;
-                break;
-            }
-            case RECORD_TYPE: {
-                RecordType *x = (RecordType *) t.ptr();
-                out << x->record->name->str;
-                if (!x->params.empty()) {
-                    out << "[";
-                    printNameList(out, x->params);
-                    out << "]";
-                }
-                break;
-            }
-            case VARIANT_TYPE: {
-                VariantType *x = (VariantType *) t.ptr();
-                out << x->variant->name->str;
-                if (!x->params.empty()) {
-                    out << "[";
-                    printNameList(out, x->params);
-                    out << "]";
-                }
-                break;
-            }
-            case STATIC_TYPE: {
-                StaticType *x = (StaticType *) t.ptr();
-                out << "Static[";
-                printName(out, x->obj);
-                out << "]";
-                break;
-            }
-            case ENUM_TYPE: {
-                EnumType *x = (EnumType *) t.ptr();
-                out << x->enumeration->name->str;
-                break;
-            }
-            case NEW_TYPE: {
-                NewType *x = (NewType *) t.ptr();
-                out << x->newtype->name->str;
-                break;
-            }
-            default:
-                assert(false);
-        }
+    case NEW_TYPE: {
+        NewType *x = (NewType *)t.ptr();
+        out << x->newtype->name->str;
+        break;
+    }
+    default:
+        assert(false);
     }
 }
+} // namespace clay
 
 std::string clay::DottedName::join() const {
     std::string s;
     llvm::raw_string_ostream ss(s);
-    for (llvm::SmallVector<clay::IdentifierPtr, 2>::const_iterator part = parts.begin();
+    for (llvm::SmallVector<clay::IdentifierPtr, 2>::const_iterator part =
+             parts.begin();
          part != parts.end(); ++part) {
         if (part != parts.begin())
             ss << ".";
diff --git a/compiler/printer.hpp b/compiler/printer.hpp
index 96cc34be..386d50f9 100644
--- a/compiler/printer.hpp
+++ b/compiler/printer.hpp
@@ -3,52 +3,53 @@
 #include "clay.hpp"
 
 namespace clay {
-    template<class T>
-    llvm::raw_ostream &operator<<(llvm::raw_ostream &out, llvm::ArrayRef<T> v) {
-        out << "[";
-        const T *i, *end;
-        bool first = true;
-        for (i = v.begin(), end = v.end(); i != end; ++i) {
-            if (!first)
-                out << ", ";
-            first = false;
-            out << *i;
-        }
-        out << "]";
-        return out;
+template <class T>
+llvm::raw_ostream &operator<<(llvm::raw_ostream &out, llvm::ArrayRef<T> v) {
+    out << "[";
+    const T *i, *end;
+    bool first = true;
+    for (i = v.begin(), end = v.end(); i != end; ++i) {
+        if (!first)
+            out << ", ";
+        first = false;
+        out << *i;
     }
+    out << "]";
+    return out;
+}
 
-    //
-    // printer module
-    //
+//
+// printer module
+//
 
-    llvm::raw_ostream &operator<<(llvm::raw_ostream &out, const Object &obj);
-    llvm::raw_ostream &operator<<(llvm::raw_ostream &out, const Object *obj);
-    llvm::raw_ostream &operator<<(llvm::raw_ostream &out, PVData const &pv);
+llvm::raw_ostream &operator<<(llvm::raw_ostream &out, const Object &obj);
+llvm::raw_ostream &operator<<(llvm::raw_ostream &out, const Object *obj);
+llvm::raw_ostream &operator<<(llvm::raw_ostream &out, PVData const &pv);
 
-    template<class T>
-    llvm::raw_ostream &operator<<(llvm::raw_ostream &out, const Pointer<T> &p) {
-        out << *p;
-        return out;
-    }
+template <class T>
+llvm::raw_ostream &operator<<(llvm::raw_ostream &out, const Pointer<T> &p) {
+    out << *p;
+    return out;
+}
 
-    llvm::raw_ostream &operator<<(llvm::raw_ostream &out, const PatternVar &pvar);
+llvm::raw_ostream &operator<<(llvm::raw_ostream &out, const PatternVar &pvar);
 
-    void enableSafePrintName();
-    void disableSafePrintName();
+void enableSafePrintName();
+void disableSafePrintName();
 
-    struct SafePrintNameEnabler {
-        SafePrintNameEnabler() { enableSafePrintName(); }
-        ~SafePrintNameEnabler() { disableSafePrintName(); }
-    };
+struct SafePrintNameEnabler {
+    SafePrintNameEnabler() { enableSafePrintName(); }
+    ~SafePrintNameEnabler() { disableSafePrintName(); }
+};
 
-    void printNameList(llvm::raw_ostream &out, llvm::ArrayRef<ObjectPtr> x);
-    void printNameList(llvm::raw_ostream &out, llvm::ArrayRef<ObjectPtr> x, llvm::ArrayRef<unsigned> dispatchIndices);
-    void printNameList(llvm::raw_ostream &out, llvm::ArrayRef<TypePtr> x);
-    void printStaticName(llvm::raw_ostream &out, ObjectPtr x);
-    void printName(llvm::raw_ostream &out, ObjectPtr x);
-    void printTypeAndValue(llvm::raw_ostream &out, EValuePtr ev);
-    void printValue(llvm::raw_ostream &out, EValuePtr ev);
+void printNameList(llvm::raw_ostream &out, llvm::ArrayRef<ObjectPtr> x);
+void printNameList(llvm::raw_ostream &out, llvm::ArrayRef<ObjectPtr> x,
+                   llvm::ArrayRef<unsigned> dispatchIndices);
+void printNameList(llvm::raw_ostream &out, llvm::ArrayRef<TypePtr> x);
+void printStaticName(llvm::raw_ostream &out, ObjectPtr x);
+void printName(llvm::raw_ostream &out, ObjectPtr x);
+void printTypeAndValue(llvm::raw_ostream &out, EValuePtr ev);
+void printValue(llvm::raw_ostream &out, EValuePtr ev);
 
-    string shortString(llvm::StringRef in);
-}
+string shortString(llvm::StringRef in);
+} // namespace clay
diff --git a/compiler/profiler.cpp b/compiler/profiler.cpp
index 56940757..263926a9 100644
--- a/compiler/profiler.cpp
+++ b/compiler/profiler.cpp
@@ -1,32 +1,32 @@
-#include "clay.hpp"
 #include "profiler.hpp"
+#include "clay.hpp"
 
 namespace clay {
-    static llvm::StringMap<int> countsMap;
+static llvm::StringMap<int> countsMap;
 
-    void incrementCount(const ObjectPtr &obj) {
-        string buf;
-        llvm::raw_string_ostream sout(buf);
-        sout << obj->toString();
-        string s = sout.str();
-        llvm::StringMap<int>::iterator i = countsMap.find(s);
-        if (i == countsMap.end()) {
-            countsMap[s] = 1;
-        } else {
-            i->second += 1;
-        }
+void incrementCount(const ObjectPtr &obj) {
+    string buf;
+    llvm::raw_string_ostream sout(buf);
+    sout << obj->toString();
+    string s = sout.str();
+    llvm::StringMap<int>::iterator i = countsMap.find(s);
+    if (i == countsMap.end()) {
+        countsMap[s] = 1;
+    } else {
+        i->second += 1;
     }
+}
 
-    void displayCounts() {
-        vector<pair<int, string> > counts;
-        llvm::StringMap<int>::iterator cmi = countsMap.begin();
-        while (cmi != countsMap.end()) {
-            counts.emplace_back(cmi->getValue(), cmi->getKey());
-            ++cmi;
-        }
-        sort(counts.begin(), counts.end());
-        for (auto & count : counts) {
-            llvm::outs() << count.second << " - " << count.first << '\n';
-        }
+void displayCounts() {
+    vector<pair<int, string>> counts;
+    llvm::StringMap<int>::iterator cmi = countsMap.begin();
+    while (cmi != countsMap.end()) {
+        counts.emplace_back(cmi->getValue(), cmi->getKey());
+        ++cmi;
+    }
+    sort(counts.begin(), counts.end());
+    for (auto &count : counts) {
+        llvm::outs() << count.second << " - " << count.first << '\n';
     }
 }
+} // namespace clay
diff --git a/compiler/profiler.hpp b/compiler/profiler.hpp
index 3b1f1401..f89b911f 100644
--- a/compiler/profiler.hpp
+++ b/compiler/profiler.hpp
@@ -3,6 +3,6 @@
 #include "clay.hpp"
 
 namespace clay {
-    void incrementCount(const ObjectPtr &obj);
-    void displayCounts();
-}
+void incrementCount(const ObjectPtr &obj);
+void displayCounts();
+} // namespace clay
diff --git a/compiler/refcounted.hpp b/compiler/refcounted.hpp
index 286310a2..303f1107 100644
--- a/compiler/refcounted.hpp
+++ b/compiler/refcounted.hpp
@@ -1,80 +1,68 @@
 #pragma once
 
 namespace clay {
-    template<class T>
-    class Pointer {
-        T *p;
+template <class T> class Pointer {
+    T *p;
 
-    public :
-        Pointer()
-            : p(nullptr) {
-        }
+  public:
+    Pointer() : p(nullptr) {}
 
-        Pointer(T *p)
-            : p(p) {
-            if (p)
-                p->incRef();
-        }
+    Pointer(T *p) : p(p) {
+        if (p)
+            p->incRef();
+    }
 
-        Pointer(const Pointer<T> &other)
-            : p(other.p) {
-            if (p)
-                p->incRef();
-        }
+    Pointer(const Pointer<T> &other) : p(other.p) {
+        if (p)
+            p->incRef();
+    }
 
-        ~Pointer() {
-            if (p)
-                p->decRef();
-        }
+    ~Pointer() {
+        if (p)
+            p->decRef();
+    }
 
-        Pointer<T> &operator=(const Pointer<T> &other) {
-            T *q = other.p;
-            if (q) q->incRef();
-            if (p) p->decRef();
-            p = q;
-            return *this;
-        }
+    Pointer<T> &operator=(const Pointer<T> &other) {
+        T *q = other.p;
+        if (q)
+            q->incRef();
+        if (p)
+            p->decRef();
+        p = q;
+        return *this;
+    }
 
-        T &operator*() const { return *p; }
-        T *operator->() const { return p; }
-        T *ptr() const { return p; }
-        bool operator!() const { return p == nullptr; }
+    T &operator*() const { return *p; }
+    T *operator->() const { return p; }
+    T *ptr() const { return p; }
+    bool operator!() const { return p == nullptr; }
 
-        bool operator==(const Pointer<T> &other) const {
-            return p == other.p;
-        }
+    bool operator==(const Pointer<T> &other) const { return p == other.p; }
 
-        bool operator!=(const Pointer<T> &other) const {
-            return p != other.p;
-        }
+    bool operator!=(const Pointer<T> &other) const { return p != other.p; }
 
-        bool operator<(const Pointer<T> &other) const {
-            return p < other.p;
-        }
-    };
+    bool operator<(const Pointer<T> &other) const { return p < other.p; }
+};
 
-    struct RefCounted {
-    private:
-        int refCount;
+struct RefCounted {
+  private:
+    int refCount;
 
-    public:
-        RefCounted()
-            : refCount(0) {
-        }
+  public:
+    RefCounted() : refCount(0) {}
 
-        RefCounted(const RefCounted &that) : refCount(0) {
-        }
+    RefCounted(const RefCounted &that) : refCount(0) {}
 
-        void incRef() { ++refCount; }
+    void incRef() { ++refCount; }
 
-        void decRef() {
-            if (--refCount == 0) {
-                delete this;
-            }
+    void decRef() {
+        if (--refCount == 0) {
+            delete this;
         }
+    }
 
-        [[nodiscard]] int getRefCount() const { return refCount; }
+    [[nodiscard]] int getRefCount() const { return refCount; }
 
-        virtual ~RefCounted() = default;
-    };
-}
+    virtual ~RefCounted() = default;
+};
+} // namespace clay
diff --git a/compiler/refcounted_ut.cpp b/compiler/refcounted_ut.cpp
index 0d61a641..e8ec5489 100644
--- a/compiler/refcounted_ut.cpp
+++ b/compiler/refcounted_ut.cpp
@@ -4,12 +4,12 @@
 #include "ut.hpp"
 
 namespace clay {
-    CLAY_UNITTEST(RefCounted_copy_constructor) {
-        Pointer p(new RefCounted);
-        UT_ASSERT(p->getRefCount() == 1);
+CLAY_UNITTEST(RefCounted_copy_constructor) {
+    Pointer p(new RefCounted);
+    UT_ASSERT(p->getRefCount() == 1);
 
-        Pointer p2(new RefCounted(*p));
-        UT_ASSERT(p->getRefCount() == 1);
-        UT_ASSERT(p2->getRefCount() == 1);
-    }
+    Pointer p2(new RefCounted(*p));
+    UT_ASSERT(p->getRefCount() == 1);
+    UT_ASSERT(p2->getRefCount() == 1);
 }
+} // namespace clay
diff --git a/compiler/types.cpp b/compiler/types.cpp
index ba7e4f06..af5f4b1a 100644
--- a/compiler/types.cpp
+++ b/compiler/types.cpp
@@ -1,1585 +1,1508 @@
-#include "clay.hpp"
 #include "types.hpp"
-#include "evaluator.hpp"
+#include "analyzer.hpp"
+#include "clay.hpp"
 #include "codegen.hpp"
+#include "env.hpp"
+#include "error.hpp"
+#include "evaluator.hpp"
 #include "externals.hpp"
-#include "operators.hpp"
-#include "patterns.hpp"
-#include "analyzer.hpp"
 #include "loader.hpp"
-#include "env.hpp"
 #include "objects.hpp"
-#include "error.hpp"
+#include "operators.hpp"
+#include "patterns.hpp"
 
 #pragma clang diagnostic ignored "-Wcovered-switch-default"
 
 namespace clay {
-    TypePtr boolType;
-    TypePtr int8Type;
-    TypePtr int16Type;
-    TypePtr int32Type;
-    TypePtr int64Type;
-    TypePtr int128Type;
-    TypePtr uint8Type;
-    TypePtr uint16Type;
-    TypePtr uint32Type;
-    TypePtr uint64Type;
-    TypePtr uint128Type;
-    TypePtr float32Type;
-    TypePtr float64Type;
-    TypePtr float80Type;
-    TypePtr imag32Type;
-    TypePtr imag64Type;
-    TypePtr imag80Type;
-    TypePtr complex32Type;
-    TypePtr complex64Type;
-    TypePtr complex80Type;
-
-    TypePtr cIntType;
-    TypePtr cSizeTType;
-    TypePtr cPtrDiffTType;
-
-    static vector<vector<PointerTypePtr> > pointerTypes;
-    static vector<vector<CodePointerTypePtr> > codePointerTypes;
-    static vector<vector<CCodePointerTypePtr> > cCodePointerTypes;
-    static vector<vector<ArrayTypePtr> > arrayTypes;
-    static vector<vector<VecTypePtr> > vecTypes;
-    static vector<vector<TupleTypePtr> > tupleTypes;
-    static vector<vector<UnionTypePtr> > unionTypes;
-    static vector<vector<RecordTypePtr> > recordTypes;
-    static vector<vector<VariantTypePtr> > variantTypes;
-    static vector<vector<StaticTypePtr> > staticTypes;
-
-    RecordType::RecordType(RecordDeclPtr record, llvm::ArrayRef<ObjectPtr> params)
-        : Type(RECORD_TYPE), record(record), params(params),
-          layout(nullptr), fieldsInitialized(false), hasVarField(false) {
-        if (!!record->varParam) {
-            assert(params.size() >= record->params.size());
-        } else {
-            assert(params.size() == record->params.size());
-        }
-
-        for (size_t i = 0; i < params.size(); ++i) {
-            ObjectKind objKind = params[i]->objKind;
-            assert(objKind == TYPE || objKind == VALUE_HOLDER
-                || objKind == IDENTIFIER || objKind == PROCEDURE);
-        }
+TypePtr boolType;
+TypePtr int8Type;
+TypePtr int16Type;
+TypePtr int32Type;
+TypePtr int64Type;
+TypePtr int128Type;
+TypePtr uint8Type;
+TypePtr uint16Type;
+TypePtr uint32Type;
+TypePtr uint64Type;
+TypePtr uint128Type;
+TypePtr float32Type;
+TypePtr float64Type;
+TypePtr float80Type;
+TypePtr imag32Type;
+TypePtr imag64Type;
+TypePtr imag80Type;
+TypePtr complex32Type;
+TypePtr complex64Type;
+TypePtr complex80Type;
+
+TypePtr cIntType;
+TypePtr cSizeTType;
+TypePtr cPtrDiffTType;
+
+static vector<vector<PointerTypePtr>> pointerTypes;
+static vector<vector<CodePointerTypePtr>> codePointerTypes;
+static vector<vector<CCodePointerTypePtr>> cCodePointerTypes;
+static vector<vector<ArrayTypePtr>> arrayTypes;
+static vector<vector<VecTypePtr>> vecTypes;
+static vector<vector<TupleTypePtr>> tupleTypes;
+static vector<vector<UnionTypePtr>> unionTypes;
+static vector<vector<RecordTypePtr>> recordTypes;
+static vector<vector<VariantTypePtr>> variantTypes;
+static vector<vector<StaticTypePtr>> staticTypes;
+
+RecordType::RecordType(RecordDeclPtr record, llvm::ArrayRef<ObjectPtr> params)
+    : Type(RECORD_TYPE), record(record), params(params), layout(nullptr),
+      fieldsInitialized(false), hasVarField(false) {
+    if (!!record->varParam) {
+        assert(params.size() >= record->params.size());
+    } else {
+        assert(params.size() == record->params.size());
+    }
+
+    for (size_t i = 0; i < params.size(); ++i) {
+        ObjectKind objKind = params[i]->objKind;
+        assert(objKind == TYPE || objKind == VALUE_HOLDER ||
+               objKind == IDENTIFIER || objKind == PROCEDURE);
     }
+}
 
-    //
-    // type size and alignment for debug generation
-    //
-
-    static size_t llTypeSize(llvm::Type *llt) {
-        return llvmDataLayout->getTypeAllocSize(llt);
-    }
-
-    static size_t llTypeAlignment(llvm::Type *llt) {
-        return llvmDataLayout->getABITypeAlign(llt).value();
-    }
-
-    static size_t debugTypeSize(llvm::Type *llt) {
-        return llTypeSize(llt) * 8;
-    }
-
-    static size_t debugTypeAlignment(llvm::Type *llt) {
-        return llTypeAlignment(llt) * 8;
-    }
-
-    void initTypes() {
-        boolType = new BoolType();
-        int8Type = new IntegerType(8, true);
-        int16Type = new IntegerType(16, true);
-        int32Type = new IntegerType(32, true);
-        int64Type = new IntegerType(64, true);
-        int128Type = new IntegerType(128, true);
-        uint8Type = new IntegerType(8, false);
-        uint16Type = new IntegerType(16, false);
-        uint32Type = new IntegerType(32, false);
-        uint64Type = new IntegerType(64, false);
-        uint128Type = new IntegerType(128, false);
-        float32Type = new FloatType(32, false);
-        float64Type = new FloatType(64, false);
-        float80Type = new FloatType(80, false);
-        imag32Type = new FloatType(32, true);
-        imag64Type = new FloatType(64, true);
-        imag80Type = new FloatType(80, true);
-        complex32Type = new ComplexType(32);
-        complex64Type = new ComplexType(64);
-        complex80Type = new ComplexType(80);
-
-        cIntType = int32Type;
-        switch (llvmDataLayout->getPointerSizeInBits()) {
-            case 32:
-                cSizeTType = uint32Type;
-                cPtrDiffTType = int32Type;
-                break;
-            case 64:
-                cSizeTType = uint64Type;
-                cPtrDiffTType = int64Type;
-                break;
-            default:
-                assert(false);
-        }
+//
+// type size and alignment for debug generation
+//
 
-        unsigned N = 1024;
-        pointerTypes.resize(N);
-        codePointerTypes.resize(N);
-        cCodePointerTypes.resize(N);
-        arrayTypes.resize(N);
-        vecTypes.resize(N);
-        tupleTypes.resize(N);
-        unionTypes.resize(N);
-        recordTypes.resize(N);
-        variantTypes.resize(N);
-        staticTypes.resize(N);
-    }
-
-    TypePtr integerType(unsigned bits, bool isSigned) {
-        if (isSigned)
-            return intType(bits);
-        else
-            return uintType(bits);
-    }
-
-    TypePtr intType(unsigned bits) {
-        switch (bits) {
-            case 8: return int8Type;
-            case 16: return int16Type;
-            case 32: return int32Type;
-            case 64: return int64Type;
-            case 128: return int128Type;
-            default:
-                assert(false);
-                return nullptr;
-        }
-    }
+static size_t llTypeSize(llvm::Type *llt) {
+    return llvmDataLayout->getTypeAllocSize(llt);
+}
 
-    TypePtr uintType(unsigned bits) {
-        switch (bits) {
-            case 8: return uint8Type;
-            case 16: return uint16Type;
-            case 32: return uint32Type;
-            case 64: return uint64Type;
-            case 128: return uint128Type;
-            default:
-                assert(false);
-                return nullptr;
-        }
+static size_t llTypeAlignment(llvm::Type *llt) {
+    return llvmDataLayout->getABITypeAlign(llt).value();
+}
+
+static size_t debugTypeSize(llvm::Type *llt) { return llTypeSize(llt) * 8; }
+
+static size_t debugTypeAlignment(llvm::Type *llt) {
+    return llTypeAlignment(llt) * 8;
+}
+
+void initTypes() {
+    boolType = new BoolType();
+    int8Type = new IntegerType(8, true);
+    int16Type = new IntegerType(16, true);
+    int32Type = new IntegerType(32, true);
+    int64Type = new IntegerType(64, true);
+    int128Type = new IntegerType(128, true);
+    uint8Type = new IntegerType(8, false);
+    uint16Type = new IntegerType(16, false);
+    uint32Type = new IntegerType(32, false);
+    uint64Type = new IntegerType(64, false);
+    uint128Type = new IntegerType(128, false);
+    float32Type = new FloatType(32, false);
+    float64Type = new FloatType(64, false);
+    float80Type = new FloatType(80, false);
+    imag32Type = new FloatType(32, true);
+    imag64Type = new FloatType(64, true);
+    imag80Type = new FloatType(80, true);
+    complex32Type = new ComplexType(32);
+    complex64Type = new ComplexType(64);
+    complex80Type = new ComplexType(80);
+
+    cIntType = int32Type;
+    switch (llvmDataLayout->getPointerSizeInBits()) {
+    case 32:
+        cSizeTType = uint32Type;
+        cPtrDiffTType = int32Type;
+        break;
+    case 64:
+        cSizeTType = uint64Type;
+        cPtrDiffTType = int64Type;
+        break;
+    default:
+        assert(false);
+    }
+
+    unsigned N = 1024;
+    pointerTypes.resize(N);
+    codePointerTypes.resize(N);
+    cCodePointerTypes.resize(N);
+    arrayTypes.resize(N);
+    vecTypes.resize(N);
+    tupleTypes.resize(N);
+    unionTypes.resize(N);
+    recordTypes.resize(N);
+    variantTypes.resize(N);
+    staticTypes.resize(N);
+}
+
+TypePtr integerType(unsigned bits, bool isSigned) {
+    if (isSigned)
+        return intType(bits);
+    else
+        return uintType(bits);
+}
+
+TypePtr intType(unsigned bits) {
+    switch (bits) {
+    case 8:
+        return int8Type;
+    case 16:
+        return int16Type;
+    case 32:
+        return int32Type;
+    case 64:
+        return int64Type;
+    case 128:
+        return int128Type;
+    default:
+        assert(false);
+        return nullptr;
     }
+}
 
-    TypePtr floatType(unsigned bits) {
-        switch (bits) {
-            case 32: return float32Type;
-            case 64: return float64Type;
-            case 80: return float80Type;
-            default:
-                assert(false);
-                return nullptr;
-        }
+TypePtr uintType(unsigned bits) {
+    switch (bits) {
+    case 8:
+        return uint8Type;
+    case 16:
+        return uint16Type;
+    case 32:
+        return uint32Type;
+    case 64:
+        return uint64Type;
+    case 128:
+        return uint128Type;
+    default:
+        assert(false);
+        return nullptr;
     }
+}
 
-    TypePtr imagType(unsigned bits) {
-        switch (bits) {
-            case 32: return imag32Type;
-            case 64: return imag64Type;
-            case 80: return imag80Type;
-            default:
-                assert(false);
-                return nullptr;
-        }
+TypePtr floatType(unsigned bits) {
+    switch (bits) {
+    case 32:
+        return float32Type;
+    case 64:
+        return float64Type;
+    case 80:
+        return float80Type;
+    default:
+        assert(false);
+        return nullptr;
     }
+}
 
-    TypePtr complexType(unsigned bits) {
-        switch (bits) {
-            case 32: return complex32Type;
-            case 64: return complex64Type;
-            case 80: return complex80Type;
-            default:
-                assert(false);
-                return nullptr;
-        }
+TypePtr imagType(unsigned bits) {
+    switch (bits) {
+    case 32:
+        return imag32Type;
+    case 64:
+        return imag64Type;
+    case 80:
+        return imag80Type;
+    default:
+        assert(false);
+        return nullptr;
     }
+}
 
-    static unsigned pointerHash(void *p) {
-        return unsigned(int(size_t(p)));
+TypePtr complexType(unsigned bits) {
+    switch (bits) {
+    case 32:
+        return complex32Type;
+    case 64:
+        return complex64Type;
+    case 80:
+        return complex80Type;
+    default:
+        assert(false);
+        return nullptr;
     }
+}
 
-    TypePtr pointerType(TypePtr pointeeType) {
-        unsigned h = pointerHash(pointeeType.ptr());
-        h &= unsigned(pointerTypes.size() - 1);
-        vector<PointerTypePtr>::iterator i, end;
-        for (i = pointerTypes[h].begin(), end = pointerTypes[h].end();
-             i != end; ++i) {
-            PointerType *t = i->ptr();
-            if (t->pointeeType == pointeeType)
-                return t;
-        }
-        PointerTypePtr t = new PointerType(pointeeType);
-        pointerTypes[h].push_back(t);
-        return t.ptr();
-    }
-
-    TypePtr codePointerType(llvm::ArrayRef<TypePtr> argTypes,
-                            llvm::ArrayRef<uint8_t> returnIsRef,
-                            llvm::ArrayRef<TypePtr> returnTypes) {
-        assert(returnIsRef.size() == returnTypes.size());
-        unsigned h = 0;
-        for (unsigned i = 0; i < argTypes.size(); ++i) {
-            h += pointerHash(argTypes[i].ptr());
-        }
-        for (unsigned i = 0; i < returnTypes.size(); ++i) {
-            h += (returnIsRef[i] ? 23 : 11) * pointerHash(returnTypes[i].ptr());
-        }
-        h &= unsigned(codePointerTypes.size() - 1);
-        vector<CodePointerTypePtr> &bucket = codePointerTypes[h];
-        for (unsigned i = 0; i < bucket.size(); ++i) {
-            CodePointerType *t = bucket[i].ptr();
-            if ((argTypes.equals(t->argTypes)) &&
-                (returnIsRef.equals(t->returnIsRef)) &&
-                (returnTypes.equals(t->returnTypes))) {
-                return t;
-            }
-        }
-        CodePointerTypePtr t =
-                new CodePointerType(argTypes, returnIsRef, returnTypes);
-        bucket.push_back(t);
-        return t.ptr();
-    }
-
-    TypePtr cCodePointerType(CallingConv callingConv,
-                             llvm::ArrayRef<TypePtr> argTypes,
-                             bool hasVarArgs,
-                             const TypePtr& returnType) {
-        unsigned h = unsigned(callingConv) * 100;
-        for (unsigned i = 0; i < argTypes.size(); ++i) {
-            h += pointerHash(argTypes[i].ptr());
-        }
-        h += (hasVarArgs ? 1 : 0);
-        if (returnType.ptr())
-            h += pointerHash(returnType.ptr());
-        h &= unsigned(cCodePointerTypes.size() - 1);
-        vector<CCodePointerTypePtr> &bucket = cCodePointerTypes[h];
-        for (unsigned i = 0; i < bucket.size(); ++i) {
-            CCodePointerType *t = bucket[i].ptr();
-            if ((t->callingConv == callingConv) &&
-                (argTypes.equals(t->argTypes)) &&
-                (t->hasVarArgs == hasVarArgs) &&
-                (t->returnType == returnType)) {
-                return t;
-            }
-        }
-        CCodePointerTypePtr t = new CCodePointerType(callingConv,
-                                                     argTypes,
-                                                     hasVarArgs,
-                                                     returnType);
-        bucket.push_back(t);
-        return t.ptr();
-    }
-
-    TypePtr arrayType(const TypePtr& elementType, const unsigned size) {
-        unsigned h = pointerHash(elementType.ptr()) + size;
-        h &= unsigned(arrayTypes.size() - 1);
-        vector<ArrayTypePtr>::iterator i, end;
-        for (i = arrayTypes[h].begin(), end = arrayTypes[h].end();
-             i != end; ++i) {
-            ArrayType *t = i->ptr();
-            if ((t->elementType == elementType) && (t->size == size))
-                return t;
-        }
-        ArrayTypePtr t = new ArrayType(elementType, size);
-        arrayTypes[h].push_back(t);
-        return t.ptr();
-    }
-
-    TypePtr vecType(const TypePtr& elementType, const unsigned size) {
-        if (elementType->typeKind != INTEGER_TYPE && elementType->typeKind != FLOAT_TYPE)
-            error("Vec element type must be an integer or float type");
-        unsigned h = pointerHash(elementType.ptr()) + size;
-        h &= unsigned(vecTypes.size() - 1);
-        vector<VecTypePtr>::iterator i, end;
-        for (i = vecTypes[h].begin(), end = vecTypes[h].end();
-             i != end; ++i) {
-            VecType *t = i->ptr();
-            if ((t->elementType == elementType) && (t->size == size))
-                return t;
+static unsigned pointerHash(void *p) { return unsigned(int(size_t(p))); }
+
+TypePtr pointerType(TypePtr pointeeType) {
+    unsigned h = pointerHash(pointeeType.ptr());
+    h &= unsigned(pointerTypes.size() - 1);
+    vector<PointerTypePtr>::iterator i, end;
+    for (i = pointerTypes[h].begin(), end = pointerTypes[h].end(); i != end;
+         ++i) {
+        PointerType *t = i->ptr();
+        if (t->pointeeType == pointeeType)
+            return t;
+    }
+    PointerTypePtr t = new PointerType(pointeeType);
+    pointerTypes[h].push_back(t);
+    return t.ptr();
+}
+
+TypePtr codePointerType(llvm::ArrayRef<TypePtr> argTypes,
+                        llvm::ArrayRef<uint8_t> returnIsRef,
+                        llvm::ArrayRef<TypePtr> returnTypes) {
+    assert(returnIsRef.size() == returnTypes.size());
+    unsigned h = 0;
+    for (unsigned i = 0; i < argTypes.size(); ++i) {
+        h += pointerHash(argTypes[i].ptr());
+    }
+    for (unsigned i = 0; i < returnTypes.size(); ++i) {
+        h += (returnIsRef[i] ? 23 : 11) * pointerHash(returnTypes[i].ptr());
+    }
+    h &= unsigned(codePointerTypes.size() - 1);
+    vector<CodePointerTypePtr> &bucket = codePointerTypes[h];
+    for (unsigned i = 0; i < bucket.size(); ++i) {
+        CodePointerType *t = bucket[i].ptr();
+        if ((argTypes.equals(t->argTypes)) &&
+            (returnIsRef.equals(t->returnIsRef)) &&
+            (returnTypes.equals(t->returnTypes))) {
+            return t;
         }
-        VecTypePtr t = new VecType(elementType, size);
-        vecTypes[h].push_back(t);
-        return t.ptr();
     }
+    CodePointerTypePtr t =
+        new CodePointerType(argTypes, returnIsRef, returnTypes);
+    bucket.push_back(t);
+    return t.ptr();
+}
 
-    TypePtr tupleType(llvm::ArrayRef<TypePtr> elementTypes) {
-        unsigned h = 0;
-        TypePtr const *ei, *eend;
-        for (ei = elementTypes.begin(), eend = elementTypes.end();
-             ei != eend; ++ei) {
-            h += pointerHash(ei->ptr());
-        }
-        h &= unsigned(tupleTypes.size() - 1);
-        vector<TupleTypePtr>::iterator i, end;
-        for (i = tupleTypes[h].begin(), end = tupleTypes[h].end();
-             i != end; ++i) {
-            TupleType *t = i->ptr();
-            if (elementTypes.equals(t->elementTypes))
-                return t;
+TypePtr cCodePointerType(CallingConv callingConv,
+                         llvm::ArrayRef<TypePtr> argTypes, bool hasVarArgs,
+                         const TypePtr &returnType) {
+    unsigned h = unsigned(callingConv) * 100;
+    for (unsigned i = 0; i < argTypes.size(); ++i) {
+        h += pointerHash(argTypes[i].ptr());
+    }
+    h += (hasVarArgs ? 1 : 0);
+    if (returnType.ptr())
+        h += pointerHash(returnType.ptr());
+    h &= unsigned(cCodePointerTypes.size() - 1);
+    vector<CCodePointerTypePtr> &bucket = cCodePointerTypes[h];
+    for (unsigned i = 0; i < bucket.size(); ++i) {
+        CCodePointerType *t = bucket[i].ptr();
+        if ((t->callingConv == callingConv) && (argTypes.equals(t->argTypes)) &&
+            (t->hasVarArgs == hasVarArgs) && (t->returnType == returnType)) {
+            return t;
         }
-        TupleTypePtr t = new TupleType(elementTypes);
-        tupleTypes[h].push_back(t);
-        return t.ptr();
     }
+    CCodePointerTypePtr t =
+        new CCodePointerType(callingConv, argTypes, hasVarArgs, returnType);
+    bucket.push_back(t);
+    return t.ptr();
+}
 
-    TypePtr unionType(const llvm::ArrayRef<TypePtr> memberTypes) {
-        unsigned h = 0;
-        TypePtr const *mi, *mend;
-        for (mi = memberTypes.begin(), mend = memberTypes.end();
-             mi != mend; ++mi) {
-            h += pointerHash(mi->ptr());
-        }
-        h &= unsigned(memberTypes.size() - 1);
-        vector<UnionTypePtr>::iterator i, end;
-        for (i = unionTypes[h].begin(), end = unionTypes[h].end();
-             i != end; ++i) {
-            UnionType *t = i->ptr();
-            if (memberTypes.equals(t->memberTypes))
-                return t;
-        }
-        UnionTypePtr t = new UnionType(memberTypes);
-        unionTypes[h].push_back(t);
-        return t.ptr();
-    }
-
-    TypePtr recordType(RecordDeclPtr record, llvm::ArrayRef<ObjectPtr> params) {
-        unsigned h = pointerHash(record.ptr());
-        ObjectPtr const *pi, *pend;
-        for (pi = params.begin(), pend = params.end(); pi != pend; ++pi)
-            h += objectHash(*pi);
-        h &= unsigned(recordTypes.size() - 1);
-        vector<RecordTypePtr>::iterator i, end;
-        for (i = recordTypes[h].begin(), end = recordTypes[h].end();
-             i != end; ++i) {
-            RecordType *t = i->ptr();
-            if ((t->record == record) && objectVectorEquals(t->params, params))
-                return t;
-        }
+TypePtr arrayType(const TypePtr &elementType, const unsigned size) {
+    unsigned h = pointerHash(elementType.ptr()) + size;
+    h &= unsigned(arrayTypes.size() - 1);
+    vector<ArrayTypePtr>::iterator i, end;
+    for (i = arrayTypes[h].begin(), end = arrayTypes[h].end(); i != end; ++i) {
+        ArrayType *t = i->ptr();
+        if ((t->elementType == elementType) && (t->size == size))
+            return t;
+    }
+    ArrayTypePtr t = new ArrayType(elementType, size);
+    arrayTypes[h].push_back(t);
+    return t.ptr();
+}
 
-        RecordTypePtr t = new RecordType(record, params);
-        recordTypes[h].push_back(t);
-        t->hasVarField = record->body->hasVarField;
-        initializeRecordFields(t);
-        return t.ptr();
-    }
-
-    TypePtr variantType(const VariantDeclPtr& variant, llvm::ArrayRef<ObjectPtr> params) {
-        unsigned h = pointerHash(variant.ptr());
-        for (unsigned i = 0; i < params.size(); ++i)
-            h += objectHash(params[i]);
-        h &= unsigned(variantTypes.size() - 1);
-        vector<VariantTypePtr> &bucket = variantTypes[h];
-        for (unsigned i = 0; i < bucket.size(); ++i) {
-            VariantType *t = bucket[i].ptr();
-            if ((t->variant == variant) && objectVectorEquals(t->params, params))
-                return t;
-        }
-        VariantTypePtr t = new VariantType(variant);
-        for (size_t i = 0; i < params.size(); ++i)
-            t->params.push_back(params[i]);
-        bucket.push_back(t);
-        return t.ptr();
-    }
-
-    TypePtr staticType(const ObjectPtr& obj) {
-        unsigned h = objectHash(obj);
-        h &= unsigned(staticTypes.size() - 1);
-        vector<StaticTypePtr> &bucket = staticTypes[h];
-        for (unsigned i = 0; i < bucket.size(); ++i) {
-            if (objectEquals(obj, bucket[i]->obj))
-                return bucket[i].ptr();
-        }
-        StaticTypePtr t = new StaticType(obj);
-        bucket.push_back(t);
-        return t.ptr();
-    }
+TypePtr vecType(const TypePtr &elementType, const unsigned size) {
+    if (elementType->typeKind != INTEGER_TYPE &&
+        elementType->typeKind != FLOAT_TYPE)
+        error("Vec element type must be an integer or float type");
+    unsigned h = pointerHash(elementType.ptr()) + size;
+    h &= unsigned(vecTypes.size() - 1);
+    vector<VecTypePtr>::iterator i, end;
+    for (i = vecTypes[h].begin(), end = vecTypes[h].end(); i != end; ++i) {
+        VecType *t = i->ptr();
+        if ((t->elementType == elementType) && (t->size == size))
+            return t;
+    }
+    VecTypePtr t = new VecType(elementType, size);
+    vecTypes[h].push_back(t);
+    return t.ptr();
+}
 
-    void initializeEnumType(EnumTypePtr t) {
-        if (t->initialized)
-            return;
+TypePtr tupleType(llvm::ArrayRef<TypePtr> elementTypes) {
+    unsigned h = 0;
+    TypePtr const *ei, *eend;
+    for (ei = elementTypes.begin(), eend = elementTypes.end(); ei != eend;
+         ++ei) {
+        h += pointerHash(ei->ptr());
+    }
+    h &= unsigned(tupleTypes.size() - 1);
+    vector<TupleTypePtr>::iterator i, end;
+    for (i = tupleTypes[h].begin(), end = tupleTypes[h].end(); i != end; ++i) {
+        TupleType *t = i->ptr();
+        if (elementTypes.equals(t->elementTypes))
+            return t;
+    }
+    TupleTypePtr t = new TupleType(elementTypes);
+    tupleTypes[h].push_back(t);
+    return t.ptr();
+}
 
-        CompileContextPusher pusher(t.ptr());
+TypePtr unionType(const llvm::ArrayRef<TypePtr> memberTypes) {
+    unsigned h = 0;
+    TypePtr const *mi, *mend;
+    for (mi = memberTypes.begin(), mend = memberTypes.end(); mi != mend; ++mi) {
+        h += pointerHash(mi->ptr());
+    }
+    h &= unsigned(memberTypes.size() - 1);
+    vector<UnionTypePtr>::iterator i, end;
+    for (i = unionTypes[h].begin(), end = unionTypes[h].end(); i != end; ++i) {
+        UnionType *t = i->ptr();
+        if (memberTypes.equals(t->memberTypes))
+            return t;
+    }
+    UnionTypePtr t = new UnionType(memberTypes);
+    unionTypes[h].push_back(t);
+    return t.ptr();
+}
 
-        EnvPtr env = new Env(t->enumeration->env);
-        evaluatePredicate(t->enumeration->patternVars, t->enumeration->predicate, env);
-        t->initialized = true;
-    }
+TypePtr recordType(RecordDeclPtr record, llvm::ArrayRef<ObjectPtr> params) {
+    unsigned h = pointerHash(record.ptr());
+    ObjectPtr const *pi, *pend;
+    for (pi = params.begin(), pend = params.end(); pi != pend; ++pi)
+        h += objectHash(*pi);
+    h &= unsigned(recordTypes.size() - 1);
+    vector<RecordTypePtr>::iterator i, end;
+    for (i = recordTypes[h].begin(), end = recordTypes[h].end(); i != end;
+         ++i) {
+        RecordType *t = i->ptr();
+        if ((t->record == record) && objectVectorEquals(t->params, params))
+            return t;
+    }
+
+    RecordTypePtr t = new RecordType(record, params);
+    recordTypes[h].push_back(t);
+    t->hasVarField = record->body->hasVarField;
+    initializeRecordFields(t);
+    return t.ptr();
+}
 
-    TypePtr enumType(const EnumDeclPtr& enumeration) {
-        if (!enumeration->type)
-            enumeration->type = new EnumType(enumeration);
-        return enumeration->type;
-    }
+TypePtr variantType(const VariantDeclPtr &variant,
+                    llvm::ArrayRef<ObjectPtr> params) {
+    unsigned h = pointerHash(variant.ptr());
+    for (unsigned i = 0; i < params.size(); ++i)
+        h += objectHash(params[i]);
+    h &= unsigned(variantTypes.size() - 1);
+    vector<VariantTypePtr> &bucket = variantTypes[h];
+    for (unsigned i = 0; i < bucket.size(); ++i) {
+        VariantType *t = bucket[i].ptr();
+        if ((t->variant == variant) && objectVectorEquals(t->params, params))
+            return t;
+    }
+    VariantTypePtr t = new VariantType(variant);
+    for (size_t i = 0; i < params.size(); ++i)
+        t->params.push_back(params[i]);
+    bucket.push_back(t);
+    return t.ptr();
+}
 
-    void initializeNewType(const NewTypePtr& t) {
-        if (t->newtype->initialized)
-            return;
-        CompileContextPusher pusher(t.ptr());
-        t->newtype->baseType = evaluateType(t->newtype->expr, t->newtype->env);
-        t->newtype->initialized = true;
-    }
+TypePtr staticType(const ObjectPtr &obj) {
+    unsigned h = objectHash(obj);
+    h &= unsigned(staticTypes.size() - 1);
+    vector<StaticTypePtr> &bucket = staticTypes[h];
+    for (unsigned i = 0; i < bucket.size(); ++i) {
+        if (objectEquals(obj, bucket[i]->obj))
+            return bucket[i].ptr();
+    }
+    StaticTypePtr t = new StaticType(obj);
+    bucket.push_back(t);
+    return t.ptr();
+}
 
-    TypePtr newType(const NewTypeDeclPtr& newtype) {
-        if (!newtype->type)
-            newtype->type = new NewType(newtype);
-        return newtype->type.ptr();
-    }
+void initializeEnumType(EnumTypePtr t) {
+    if (t->initialized)
+        return;
 
-    TypePtr newtypeReprType(const NewTypePtr& t) {
-        if (!t->newtype->initialized)
-            initializeNewType(t);
-        return t->newtype->baseType;
-    }
+    CompileContextPusher pusher(t.ptr());
 
-    //
-    // isPrimitiveType, isPrimitiveAggregateType, isPointerOrCodePointerType
-    //
+    EnvPtr env = new Env(t->enumeration->env);
+    evaluatePredicate(t->enumeration->patternVars, t->enumeration->predicate,
+                      env);
+    t->initialized = true;
+}
 
-    bool isPrimitiveType(TypePtr t) {
-        switch (t->typeKind) {
-            case BOOL_TYPE:
-            case INTEGER_TYPE:
-            case FLOAT_TYPE:
-            case COMPLEX_TYPE:
-            case POINTER_TYPE:
-            case CODE_POINTER_TYPE:
-            case CCODE_POINTER_TYPE:
-            case STATIC_TYPE:
-            case ENUM_TYPE:
-            case NEW_TYPE:
-                return true;
-            default:
-                return false;
-        }
-    }
+TypePtr enumType(const EnumDeclPtr &enumeration) {
+    if (!enumeration->type)
+        enumeration->type = new EnumType(enumeration);
+    return enumeration->type;
+}
 
-    bool isPrimitiveAggregateType(TypePtr t) {
-        switch (t->typeKind) {
-            case BOOL_TYPE:
-            case INTEGER_TYPE:
-            case FLOAT_TYPE:
-            case COMPLEX_TYPE:
-            case POINTER_TYPE:
-            case CODE_POINTER_TYPE:
-            case CCODE_POINTER_TYPE:
-            case STATIC_TYPE:
-            case ENUM_TYPE:
-            case NEW_TYPE:
-                return true;
-            case TUPLE_TYPE: {
-                TupleType *tt = (TupleType *) t.ptr();
-                for (size_t i = 0; i < tt->elementTypes.size(); ++i) {
-                    if (!isPrimitiveAggregateType(tt->elementTypes[i]))
-                        return false;
-                }
-                return true;
-            }
-            case ARRAY_TYPE: {
-                ArrayType *at = (ArrayType *) t.ptr();
-                return isPrimitiveAggregateType(at->elementType);
-            }
-            default:
-                return false;
-        }
-    }
+void initializeNewType(const NewTypePtr &t) {
+    if (t->newtype->initialized)
+        return;
+    CompileContextPusher pusher(t.ptr());
+    t->newtype->baseType = evaluateType(t->newtype->expr, t->newtype->env);
+    t->newtype->initialized = true;
+}
 
-    bool isPrimitiveAggregateTooLarge(TypePtr t) {
-        switch (t->typeKind) {
-            case BOOL_TYPE:
-            case INTEGER_TYPE:
-            case FLOAT_TYPE:
-            case COMPLEX_TYPE:
-            case POINTER_TYPE:
-            case CODE_POINTER_TYPE:
-            case CCODE_POINTER_TYPE:
-            case STATIC_TYPE:
-            case ENUM_TYPE:
-            case NEW_TYPE:
-                return false;
-            case TUPLE_TYPE: {
-                TupleType *tt = (TupleType *) t.ptr();
-                for (unsigned i = 0; i < tt->elementTypes.size(); ++i) {
-                    if (isPrimitiveAggregateTooLarge(tt->elementTypes[i]))
-                        return true;
-                }
-                return false;
-            }
-            case ARRAY_TYPE: {
-                ArrayType *at = (ArrayType *) t.ptr();
-                if (at->size > 8)
-                    return true;
-                if (isPrimitiveAggregateTooLarge(at->elementType))
-                    return true;
-                return false;
-            }
-            default:
-                return false;
-        }
+TypePtr newType(const NewTypeDeclPtr &newtype) {
+    if (!newtype->type)
+        newtype->type = new NewType(newtype);
+    return newtype->type.ptr();
+}
+
+TypePtr newtypeReprType(const NewTypePtr &t) {
+    if (!t->newtype->initialized)
+        initializeNewType(t);
+    return t->newtype->baseType;
+}
+
+//
+// isPrimitiveType, isPrimitiveAggregateType, isPointerOrCodePointerType
+//
+
+bool isPrimitiveType(TypePtr t) {
+    switch (t->typeKind) {
+    case BOOL_TYPE:
+    case INTEGER_TYPE:
+    case FLOAT_TYPE:
+    case COMPLEX_TYPE:
+    case POINTER_TYPE:
+    case CODE_POINTER_TYPE:
+    case CCODE_POINTER_TYPE:
+    case STATIC_TYPE:
+    case ENUM_TYPE:
+    case NEW_TYPE:
+        return true;
+    default:
+        return false;
     }
+}
 
-    bool isPointerOrCodePointerType(TypePtr t) {
-        switch (t->typeKind) {
-            case POINTER_TYPE:
-            case CODE_POINTER_TYPE:
-            case CCODE_POINTER_TYPE:
-                return true;
-            default:
+bool isPrimitiveAggregateType(TypePtr t) {
+    switch (t->typeKind) {
+    case BOOL_TYPE:
+    case INTEGER_TYPE:
+    case FLOAT_TYPE:
+    case COMPLEX_TYPE:
+    case POINTER_TYPE:
+    case CODE_POINTER_TYPE:
+    case CCODE_POINTER_TYPE:
+    case STATIC_TYPE:
+    case ENUM_TYPE:
+    case NEW_TYPE:
+        return true;
+    case TUPLE_TYPE: {
+        TupleType *tt = (TupleType *)t.ptr();
+        for (size_t i = 0; i < tt->elementTypes.size(); ++i) {
+            if (!isPrimitiveAggregateType(tt->elementTypes[i]))
                 return false;
         }
+        return true;
+    }
+    case ARRAY_TYPE: {
+        ArrayType *at = (ArrayType *)t.ptr();
+        return isPrimitiveAggregateType(at->elementType);
+    }
+    default:
+        return false;
     }
+}
 
-    bool isStaticOrTupleOfStatics(TypePtr t) {
-        switch (t->typeKind) {
-            case STATIC_TYPE:
-                return true;
-            case TUPLE_TYPE: {
-                TupleType *tt = (TupleType *) t.ptr();
-                for (unsigned i = 0; i < tt->elementTypes.size(); ++i) {
-                    if (!isStaticOrTupleOfStatics(tt->elementTypes[i]))
-                        return false;
-                }
+bool isPrimitiveAggregateTooLarge(TypePtr t) {
+    switch (t->typeKind) {
+    case BOOL_TYPE:
+    case INTEGER_TYPE:
+    case FLOAT_TYPE:
+    case COMPLEX_TYPE:
+    case POINTER_TYPE:
+    case CODE_POINTER_TYPE:
+    case CCODE_POINTER_TYPE:
+    case STATIC_TYPE:
+    case ENUM_TYPE:
+    case NEW_TYPE:
+        return false;
+    case TUPLE_TYPE: {
+        TupleType *tt = (TupleType *)t.ptr();
+        for (unsigned i = 0; i < tt->elementTypes.size(); ++i) {
+            if (isPrimitiveAggregateTooLarge(tt->elementTypes[i]))
                 return true;
-            }
-            default:
-                return false;
         }
+        return false;
     }
+    case ARRAY_TYPE: {
+        ArrayType *at = (ArrayType *)t.ptr();
+        if (at->size > 8)
+            return true;
+        if (isPrimitiveAggregateTooLarge(at->elementType))
+            return true;
+        return false;
+    }
+    default:
+        return false;
+    }
+}
 
-    //
-    // recordFieldTypes
-    //
-
-    static bool unpackField(TypePtr x, IdentifierPtr &name, TypePtr &type) {
-        if (x->typeKind != TUPLE_TYPE)
-            return false;
-        TupleType *tt = (TupleType *) x.ptr();
-        if (tt->elementTypes.size() != 2)
-            return false;
-        if (tt->elementTypes[0]->typeKind != STATIC_TYPE)
-            return false;
-        StaticType *st0 = (StaticType *) tt->elementTypes[0].ptr();
-        if (st0->obj->objKind != IDENTIFIER)
-            return false;
-        name = (Identifier *) st0->obj.ptr();
-        if (tt->elementTypes[1]->typeKind != STATIC_TYPE)
-            return false;
-        StaticType *st1 = (StaticType *) tt->elementTypes[1].ptr();
-        if (st1->obj->objKind != TYPE)
-            return false;
-        type = (Type *) st1->obj.ptr();
+bool isPointerOrCodePointerType(TypePtr t) {
+    switch (t->typeKind) {
+    case POINTER_TYPE:
+    case CODE_POINTER_TYPE:
+    case CCODE_POINTER_TYPE:
         return true;
+    default:
+        return false;
     }
+}
 
-    static void setProperty(TypePtr type,
-                            ProcedurePtr proc,
-                            llvm::ArrayRef<ExprPtr> exprs) {
-        CodePtr code = new Code();
-
-        TypePtr typeType = staticType(type.ptr());
-        ExprPtr argType = new ObjectExpr(typeType.ptr());
-        FormalArgPtr arg = new FormalArg(Identifier::get("x"), argType);
-        code->formalArgs.push_back(arg.ptr());
-
-        ExprListPtr returnExprs = new ExprList();
-        for (unsigned i = 0; i < exprs.size(); ++i)
-            returnExprs->add(exprs[i]);
-        code->body = new Return(RETURN_VALUE, returnExprs);
-
-        ExprPtr target = new ObjectExpr(proc.ptr());
-        OverloadPtr overload = new Overload(nullptr, target, code, false, IGNORE);
-        overload->env = new Env();
-        proc->overloads.insert(proc->overloads.begin(), overload);
-    }
-
-    static ExprPtr convertStaticObjectToExpr(TypePtr t) {
-        if (t->typeKind == STATIC_TYPE) {
-            StaticType *st = (StaticType *) t.ptr();
-            return new ObjectExpr(st->obj);
-        } else if (t->typeKind == TUPLE_TYPE) {
-            TupleType *tt = (TupleType *) t.ptr();
-            ExprListPtr exprs = new ExprList();
-            for (unsigned i = 0; i < tt->elementTypes.size(); ++i)
-                exprs->add(convertStaticObjectToExpr(tt->elementTypes[i]));
-            return new Tuple(exprs);
-        } else {
-            error("non-static value found in object property");
-            return nullptr;
+bool isStaticOrTupleOfStatics(TypePtr t) {
+    switch (t->typeKind) {
+    case STATIC_TYPE:
+        return true;
+    case TUPLE_TYPE: {
+        TupleType *tt = (TupleType *)t.ptr();
+        for (unsigned i = 0; i < tt->elementTypes.size(); ++i) {
+            if (!isStaticOrTupleOfStatics(tt->elementTypes[i]))
+                return false;
         }
+        return true;
     }
-
-    static void setProperty(TypePtr type, TypePtr propType) {
-        if (propType->typeKind != TUPLE_TYPE)
-            error("each property should be a tuple [procedure, ... static values]");
-        TupleTypePtr tt = (TupleType *) propType.ptr();
-        if (tt->elementTypes.size() < 1)
-            error("each property should be a tuple [procedure, ... static values]");
-        TypePtr t0 = tt->elementTypes[0];
-        if (t0->typeKind != STATIC_TYPE)
-            error("each property should be a tuple [procedure, ... static values]");
-        StaticTypePtr st0 = (StaticType *) t0.ptr();
-        if (st0->obj->objKind != PROCEDURE)
-            error("each property should be a tuple [procedure, ... static values]");
-        ProcedurePtr proc = (Procedure *) st0->obj.ptr();
-        vector<ExprPtr> exprs;
-        for (unsigned i = 1; i < tt->elementTypes.size(); ++i) {
-            TypePtr ti = tt->elementTypes[i];
-            exprs.push_back(convertStaticObjectToExpr(ti));
-        }
-        setProperty(type, proc, exprs);
+    default:
+        return false;
     }
+}
+
+//
+// recordFieldTypes
+//
+
+static bool unpackField(TypePtr x, IdentifierPtr &name, TypePtr &type) {
+    if (x->typeKind != TUPLE_TYPE)
+        return false;
+    TupleType *tt = (TupleType *)x.ptr();
+    if (tt->elementTypes.size() != 2)
+        return false;
+    if (tt->elementTypes[0]->typeKind != STATIC_TYPE)
+        return false;
+    StaticType *st0 = (StaticType *)tt->elementTypes[0].ptr();
+    if (st0->obj->objKind != IDENTIFIER)
+        return false;
+    name = (Identifier *)st0->obj.ptr();
+    if (tt->elementTypes[1]->typeKind != STATIC_TYPE)
+        return false;
+    StaticType *st1 = (StaticType *)tt->elementTypes[1].ptr();
+    if (st1->obj->objKind != TYPE)
+        return false;
+    type = (Type *)st1->obj.ptr();
+    return true;
+}
+
+static void setProperty(TypePtr type, ProcedurePtr proc,
+                        llvm::ArrayRef<ExprPtr> exprs) {
+    CodePtr code = new Code();
+
+    TypePtr typeType = staticType(type.ptr());
+    ExprPtr argType = new ObjectExpr(typeType.ptr());
+    FormalArgPtr arg = new FormalArg(Identifier::get("x"), argType);
+    code->formalArgs.push_back(arg.ptr());
 
-    static void setProperties(TypePtr type, llvm::ArrayRef<TypePtr> props) {
-        for (unsigned i = 0; i < props.size(); ++i)
-            setProperty(type, props[i]);
+    ExprListPtr returnExprs = new ExprList();
+    for (unsigned i = 0; i < exprs.size(); ++i)
+        returnExprs->add(exprs[i]);
+    code->body = new Return(RETURN_VALUE, returnExprs);
+
+    ExprPtr target = new ObjectExpr(proc.ptr());
+    OverloadPtr overload = new Overload(nullptr, target, code, false, IGNORE);
+    overload->env = new Env();
+    proc->overloads.insert(proc->overloads.begin(), overload);
+}
+
+static ExprPtr convertStaticObjectToExpr(TypePtr t) {
+    if (t->typeKind == STATIC_TYPE) {
+        StaticType *st = (StaticType *)t.ptr();
+        return new ObjectExpr(st->obj);
+    } else if (t->typeKind == TUPLE_TYPE) {
+        TupleType *tt = (TupleType *)t.ptr();
+        ExprListPtr exprs = new ExprList();
+        for (unsigned i = 0; i < tt->elementTypes.size(); ++i)
+            exprs->add(convertStaticObjectToExpr(tt->elementTypes[i]));
+        return new Tuple(exprs);
+    } else {
+        error("non-static value found in object property");
+        return nullptr;
     }
+}
 
-    void initializeRecordFields(const RecordTypePtr& t) {
-        CompileContextPusher pusher(t.ptr());
+static void setProperty(TypePtr type, TypePtr propType) {
+    if (propType->typeKind != TUPLE_TYPE)
+        error("each property should be a tuple [procedure, ... static values]");
+    TupleTypePtr tt = (TupleType *)propType.ptr();
+    if (tt->elementTypes.size() < 1)
+        error("each property should be a tuple [procedure, ... static values]");
+    TypePtr t0 = tt->elementTypes[0];
+    if (t0->typeKind != STATIC_TYPE)
+        error("each property should be a tuple [procedure, ... static values]");
+    StaticTypePtr st0 = (StaticType *)t0.ptr();
+    if (st0->obj->objKind != PROCEDURE)
+        error("each property should be a tuple [procedure, ... static values]");
+    ProcedurePtr proc = (Procedure *)st0->obj.ptr();
+    vector<ExprPtr> exprs;
+    for (unsigned i = 1; i < tt->elementTypes.size(); ++i) {
+        TypePtr ti = tt->elementTypes[i];
+        exprs.push_back(convertStaticObjectToExpr(ti));
+    }
+    setProperty(type, proc, exprs);
+}
 
-        assert(!t->fieldsInitialized);
-        t->fieldsInitialized = true;
-        RecordDeclPtr r = t->record;
-        EnvPtr env = new Env(r->env);
-        for (unsigned i = 0; i < r->params.size(); ++i)
-            addLocal(env, r->params[i], t->params[i].ptr());
-        if (r->varParam.ptr()) {
-            MultiStaticPtr rest = new MultiStatic();
-            for (size_t i = r->params.size(); i < t->params.size(); ++i)
-                rest->add(t->params[i]);
-            addLocal(env, r->varParam, rest.ptr());
-        }
+static void setProperties(TypePtr type, llvm::ArrayRef<TypePtr> props) {
+    for (unsigned i = 0; i < props.size(); ++i)
+        setProperty(type, props[i]);
+}
 
-        evaluatePredicate(r->patternVars, r->predicate, env);
-
-        RecordBodyPtr body = r->body;
-        if (body->isComputed) {
-            LocationContext loc(body->location);
-            AnalysisCachingDisabler disabler;
-            MultiPValuePtr mpv = analyzeMulti(body->computed, env, 0);
-            vector<TypePtr> fieldInfoTypes;
-            if ((mpv->size() == 1) &&
-                (mpv->values[0].type->typeKind == RECORD_TYPE) &&
-                (((RecordType *) mpv->values[0].type.ptr())->record.ptr() ==
-                 primitive_RecordWithProperties().ptr())) {
-                llvm::ArrayRef<ObjectPtr> params =
-                        ((RecordType *) mpv->values[0].type.ptr())->params;
-                assert(params.size() == 2);
-                if (params[0]->objKind != TYPE)
-                    argumentError(0, "expecting a tuple of properties");
-                TypePtr param0 = (Type *) params[0].ptr();
-                if (param0->typeKind != TUPLE_TYPE)
-                    argumentError(0, "expecting a tuple of properties");
-                TupleTypePtr props = (TupleType *) param0.ptr();
-                if (params[1]->objKind != TYPE)
-                    argumentError(1, "expecting a tuple of fields");
-                TypePtr param1 = (Type *) params[1].ptr();
-                if (param1->typeKind != TUPLE_TYPE)
-                    argumentError(1, "expecting a tuple of fields");
-                TupleTypePtr fields = (TupleType *) param1.ptr();
-                fieldInfoTypes = fields->elementTypes;
-                setProperties(t.ptr(), props->elementTypes);
-            } else {
-                for (unsigned i = 0; i < mpv->size(); ++i)
-                    fieldInfoTypes.push_back(mpv->values[i].type);
-            }
-            for (unsigned i = 0; i < fieldInfoTypes.size(); ++i) {
-                TypePtr x = fieldInfoTypes[i];
-                IdentifierPtr name;
-                TypePtr type;
-                if (!unpackField(x, name, type))
-                    argumentError(i, "each field should be a "
-                                  "tuple of (name,type)");
-                t->fieldIndexMap[name->str] = i;
-                t->fieldTypes.push_back(type);
-                t->fieldNames.push_back(name);
-            }
+void initializeRecordFields(const RecordTypePtr &t) {
+    CompileContextPusher pusher(t.ptr());
+
+    assert(!t->fieldsInitialized);
+    t->fieldsInitialized = true;
+    RecordDeclPtr r = t->record;
+    EnvPtr env = new Env(r->env);
+    for (unsigned i = 0; i < r->params.size(); ++i)
+        addLocal(env, r->params[i], t->params[i].ptr());
+    if (r->varParam.ptr()) {
+        MultiStaticPtr rest = new MultiStatic();
+        for (size_t i = r->params.size(); i < t->params.size(); ++i)
+            rest->add(t->params[i]);
+        addLocal(env, r->varParam, rest.ptr());
+    }
+
+    evaluatePredicate(r->patternVars, r->predicate, env);
+
+    RecordBodyPtr body = r->body;
+    if (body->isComputed) {
+        LocationContext loc(body->location);
+        AnalysisCachingDisabler disabler;
+        MultiPValuePtr mpv = analyzeMulti(body->computed, env, 0);
+        vector<TypePtr> fieldInfoTypes;
+        if ((mpv->size() == 1) &&
+            (mpv->values[0].type->typeKind == RECORD_TYPE) &&
+            (((RecordType *)mpv->values[0].type.ptr())->record.ptr() ==
+             primitive_RecordWithProperties().ptr())) {
+            llvm::ArrayRef<ObjectPtr> params =
+                ((RecordType *)mpv->values[0].type.ptr())->params;
+            assert(params.size() == 2);
+            if (params[0]->objKind != TYPE)
+                argumentError(0, "expecting a tuple of properties");
+            TypePtr param0 = (Type *)params[0].ptr();
+            if (param0->typeKind != TUPLE_TYPE)
+                argumentError(0, "expecting a tuple of properties");
+            TupleTypePtr props = (TupleType *)param0.ptr();
+            if (params[1]->objKind != TYPE)
+                argumentError(1, "expecting a tuple of fields");
+            TypePtr param1 = (Type *)params[1].ptr();
+            if (param1->typeKind != TUPLE_TYPE)
+                argumentError(1, "expecting a tuple of fields");
+            TupleTypePtr fields = (TupleType *)param1.ptr();
+            fieldInfoTypes = fields->elementTypes;
+            setProperties(t.ptr(), props->elementTypes);
         } else {
-            for (unsigned i = 0; i < body->fields.size(); ++i) {
-                RecordField *x = body->fields[i].ptr();
-                if (x->varField) {
-                    LocationContext loc(x->type->location);
-                    MultiStaticPtr ms = evaluateExprStatic(x->type, env);
-                    for (unsigned j = 0; j < ms->size(); ++j) {
-                        TypePtr z = staticToType(ms, j);
-                        t->fieldTypes.push_back(z);
-                    }
-                    t->varFieldPosition = i;
-                } else {
-                    TypePtr ftype = evaluateType(x->type, env);
-                    t->fieldTypes.push_back(ftype);
+            for (unsigned i = 0; i < mpv->size(); ++i)
+                fieldInfoTypes.push_back(mpv->values[i].type);
+        }
+        for (unsigned i = 0; i < fieldInfoTypes.size(); ++i) {
+            TypePtr x = fieldInfoTypes[i];
+            IdentifierPtr name;
+            TypePtr type;
+            if (!unpackField(x, name, type))
+                argumentError(i, "each field should be a "
+                                 "tuple of (name,type)");
+            t->fieldIndexMap[name->str] = i;
+            t->fieldTypes.push_back(type);
+            t->fieldNames.push_back(name);
+        }
+    } else {
+        for (unsigned i = 0; i < body->fields.size(); ++i) {
+            RecordField *x = body->fields[i].ptr();
+            if (x->varField) {
+                LocationContext loc(x->type->location);
+                MultiStaticPtr ms = evaluateExprStatic(x->type, env);
+                for (unsigned j = 0; j < ms->size(); ++j) {
+                    TypePtr z = staticToType(ms, j);
+                    t->fieldTypes.push_back(z);
                 }
-                t->fieldNames.push_back(x->name);
-                t->fieldIndexMap[x->name->str] = i;
+                t->varFieldPosition = i;
+            } else {
+                TypePtr ftype = evaluateType(x->type, env);
+                t->fieldTypes.push_back(ftype);
             }
+            t->fieldNames.push_back(x->name);
+            t->fieldIndexMap[x->name->str] = i;
         }
     }
+}
 
-    llvm::ArrayRef<IdentifierPtr> recordFieldNames(RecordTypePtr t) {
-        if (!t->fieldsInitialized)
-            initializeRecordFields(t);
-        return t->fieldNames;
-    }
-
-    llvm::ArrayRef<TypePtr> recordFieldTypes(const RecordTypePtr& t) {
-        if (!t->fieldsInitialized)
-            initializeRecordFields(t);
-        return t->fieldTypes;
-    }
+llvm::ArrayRef<IdentifierPtr> recordFieldNames(RecordTypePtr t) {
+    if (!t->fieldsInitialized)
+        initializeRecordFields(t);
+    return t->fieldNames;
+}
 
-    const llvm::StringMap<size_t> &recordFieldIndexMap(RecordTypePtr t) {
-        if (!t->fieldsInitialized)
-            initializeRecordFields(t);
-        return t->fieldIndexMap;
-    }
+llvm::ArrayRef<TypePtr> recordFieldTypes(const RecordTypePtr &t) {
+    if (!t->fieldsInitialized)
+        initializeRecordFields(t);
+    return t->fieldTypes;
+}
 
-    //
-    // variantMemberTypes, variantReprType, dispatchTagCount
-    //
+const llvm::StringMap<size_t> &recordFieldIndexMap(RecordTypePtr t) {
+    if (!t->fieldsInitialized)
+        initializeRecordFields(t);
+    return t->fieldIndexMap;
+}
 
-    static TypePtr getVariantReprType(const VariantTypePtr& t) {
-        ExprPtr variantReprType = operator_expr_variantReprType();
-        ExprPtr reprExpr = new Call(variantReprType, new ExprList(new ObjectExpr(t.ptr())));
+//
+// variantMemberTypes, variantReprType, dispatchTagCount
+//
 
-        return evaluateType(reprExpr, new Env());
-    }
+static TypePtr getVariantReprType(const VariantTypePtr &t) {
+    ExprPtr variantReprType = operator_expr_variantReprType();
+    ExprPtr reprExpr =
+        new Call(variantReprType, new ExprList(new ObjectExpr(t.ptr())));
 
-    static void initializeVariantType(const VariantTypePtr& t) {
-        assert(!t->initialized);
+    return evaluateType(reprExpr, new Env());
+}
 
-        CompileContextPusher pusher(t.ptr());
+static void initializeVariantType(const VariantTypePtr &t) {
+    assert(!t->initialized);
+
+    CompileContextPusher pusher(t.ptr());
+
+    EnvPtr variantEnv = new Env(t->variant->env);
+    {
+        llvm::ArrayRef<IdentifierPtr> params = t->variant->params;
+        IdentifierPtr varParam = t->variant->varParam;
+        assert(params.size() <= t->params.size());
+        for (unsigned j = 0; j < params.size(); ++j)
+            addLocal(variantEnv, params[j], t->params[j]);
+        if (varParam.ptr()) {
+            MultiStaticPtr ms = new MultiStatic();
+            for (size_t j = params.size(); j < t->params.size(); ++j)
+                ms->add(t->params[j]);
+            addLocal(variantEnv, varParam, ms.ptr());
+        } else {
+            assert(params.size() == t->params.size());
+        }
+    }
 
-        EnvPtr variantEnv = new Env(t->variant->env);
-        {
-            llvm::ArrayRef<IdentifierPtr> params = t->variant->params;
-            IdentifierPtr varParam = t->variant->varParam;
-            assert(params.size() <= t->params.size());
-            for (unsigned j = 0; j < params.size(); ++j)
-                addLocal(variantEnv, params[j], t->params[j]);
-            if (varParam.ptr()) {
-                MultiStaticPtr ms = new MultiStatic();
-                for (size_t j = params.size(); j < t->params.size(); ++j)
-                    ms->add(t->params[j]);
-                addLocal(variantEnv, varParam, ms.ptr());
+    evaluatePredicate(t->variant->patternVars, t->variant->predicate,
+                      variantEnv);
+
+    ExprListPtr defaultInstances = t->variant->defaultInstances;
+    evaluateMultiType(defaultInstances, variantEnv, t->memberTypes);
+
+    llvm::ArrayRef<InstanceDeclPtr> instances = t->variant->instances;
+    for (unsigned i = 0; i < instances.size(); ++i) {
+        InstanceDeclPtr x = instances[i];
+        vector<PatternCellPtr> cells;
+        vector<MultiPatternCellPtr> multiCells;
+        llvm::ArrayRef<PatternVar> pvars = x->patternVars;
+        EnvPtr patternEnv = new Env(x->env);
+        for (unsigned j = 0; j < pvars.size(); ++j) {
+            if (pvars[j].isMulti) {
+                MultiPatternCellPtr multiCell = new MultiPatternCell(nullptr);
+                multiCells.push_back(multiCell);
+                cells.push_back(nullptr);
+                addLocal(patternEnv, pvars[j].name, multiCell.ptr());
             } else {
-                assert(params.size() == t->params.size());
+                PatternCellPtr cell = new PatternCell(nullptr);
+                cells.push_back(cell);
+                multiCells.push_back(nullptr);
+                addLocal(patternEnv, pvars[j].name, cell.ptr());
             }
         }
-
-        evaluatePredicate(t->variant->patternVars,
-                          t->variant->predicate,
-                          variantEnv);
-
-        ExprListPtr defaultInstances = t->variant->defaultInstances;
-        evaluateMultiType(defaultInstances, variantEnv, t->memberTypes);
-
-        llvm::ArrayRef<InstanceDeclPtr> instances = t->variant->instances;
-        for (unsigned i = 0; i < instances.size(); ++i) {
-            InstanceDeclPtr x = instances[i];
-            vector<PatternCellPtr> cells;
-            vector<MultiPatternCellPtr> multiCells;
-            llvm::ArrayRef<PatternVar> pvars = x->patternVars;
-            EnvPtr patternEnv = new Env(x->env);
-            for (unsigned j = 0; j < pvars.size(); ++j) {
-                if (pvars[j].isMulti) {
-                    MultiPatternCellPtr multiCell = new MultiPatternCell(nullptr);
-                    multiCells.push_back(multiCell);
-                    cells.push_back(nullptr);
-                    addLocal(patternEnv, pvars[j].name, multiCell.ptr());
-                } else {
-                    PatternCellPtr cell = new PatternCell(nullptr);
-                    cells.push_back(cell);
-                    multiCells.push_back(nullptr);
-                    addLocal(patternEnv, pvars[j].name, cell.ptr());
-                }
-            }
-            PatternPtr pattern = evaluateOnePattern(x->target, patternEnv);
-            if (!unifyPatternObj(pattern, t.ptr()))
-                continue;
-            EnvPtr staticEnv = new Env(x->env);
-            for (unsigned j = 0; j < pvars.size(); ++j) {
-                if (pvars[j].isMulti) {
-                    MultiStaticPtr ms = derefDeep(multiCells[j].ptr());
-                    if (!ms)
-                        error(pvars[j].name, "unbound pattern variable");
-                    addLocal(staticEnv, pvars[j].name, ms.ptr());
-                } else {
-                    ObjectPtr v = derefDeep(cells[j].ptr());
-                    if (!v)
-                        error(pvars[j].name, "unbound pattern variable");
-                    addLocal(staticEnv, pvars[j].name, v.ptr());
-                }
+        PatternPtr pattern = evaluateOnePattern(x->target, patternEnv);
+        if (!unifyPatternObj(pattern, t.ptr()))
+            continue;
+        EnvPtr staticEnv = new Env(x->env);
+        for (unsigned j = 0; j < pvars.size(); ++j) {
+            if (pvars[j].isMulti) {
+                MultiStaticPtr ms = derefDeep(multiCells[j].ptr());
+                if (!ms)
+                    error(pvars[j].name, "unbound pattern variable");
+                addLocal(staticEnv, pvars[j].name, ms.ptr());
+            } else {
+                ObjectPtr v = derefDeep(cells[j].ptr());
+                if (!v)
+                    error(pvars[j].name, "unbound pattern variable");
+                addLocal(staticEnv, pvars[j].name, v.ptr());
             }
-            if (x->predicate.ptr())
-                if (!evaluateBool(x->predicate, staticEnv))
-                    continue;
-            evaluateMultiType(x->members, staticEnv, t->memberTypes);
         }
-
-        if (t->memberTypes.empty())
-            error(t->variant, "variant type must have at least one instance");
-
-        t->initialized = true;
-        t->reprType = getVariantReprType(t);
+        if (x->predicate.ptr())
+            if (!evaluateBool(x->predicate, staticEnv))
+                continue;
+        evaluateMultiType(x->members, staticEnv, t->memberTypes);
     }
 
-    llvm::ArrayRef<TypePtr> variantMemberTypes(VariantTypePtr t) {
-        if (!t->initialized)
-            initializeVariantType(t);
-        return t->memberTypes;
-    }
+    if (t->memberTypes.empty())
+        error(t->variant, "variant type must have at least one instance");
 
-    TypePtr variantReprType(VariantTypePtr t) {
-        if (!t->initialized)
-            initializeVariantType(t);
-        return t->reprType;
-    }
+    t->initialized = true;
+    t->reprType = getVariantReprType(t);
+}
 
-    unsigned dispatchTagCount(TypePtr t) {
-        ExprPtr dtc = operator_expr_DispatchTagCount();
-        ExprPtr dtcExpr = new Call(dtc, new ExprList(new ObjectExpr(t.ptr())));
+llvm::ArrayRef<TypePtr> variantMemberTypes(VariantTypePtr t) {
+    if (!t->initialized)
+        initializeVariantType(t);
+    return t->memberTypes;
+}
 
-        EValuePtr ev = evalOneAsRef(dtcExpr, new Env());
-        if (ev->type != cIntType)
-            error("DispatchTagCount must return an Int");
-        int tag = ev->as<int>();
-        if (tag <= 0)
-            error("DispatchTagCount must return a value greater than zero");
-        return unsigned(tag);
-    }
+TypePtr variantReprType(VariantTypePtr t) {
+    if (!t->initialized)
+        initializeVariantType(t);
+    return t->reprType;
+}
 
-    //
-    // tupleTypeLayout, recordTypeLayout
-    //
+unsigned dispatchTagCount(TypePtr t) {
+    ExprPtr dtc = operator_expr_DispatchTagCount();
+    ExprPtr dtcExpr = new Call(dtc, new ExprList(new ObjectExpr(t.ptr())));
+
+    EValuePtr ev = evalOneAsRef(dtcExpr, new Env());
+    if (ev->type != cIntType)
+        error("DispatchTagCount must return an Int");
+    int tag = ev->as<int>();
+    if (tag <= 0)
+        error("DispatchTagCount must return a value greater than zero");
+    return unsigned(tag);
+}
 
-    const llvm::StructLayout *tupleTypeLayout(TupleType *t) {
-        if (t->layout == nullptr) {
-            llvm::StructType *st =
-                    llvm::cast<llvm::StructType>(llvmType(t));
-            t->layout = llvmDataLayout->getStructLayout(st);
-        }
-        return t->layout;
-    }
+//
+// tupleTypeLayout, recordTypeLayout
+//
 
-    const llvm::StructLayout *complexTypeLayout(ComplexType *t) {
-        if (t->layout == nullptr) {
-            llvm::StructType *st =
-                    llvm::cast<llvm::StructType>(llvmType(t));
-            t->layout = llvmDataLayout->getStructLayout(st);
-        }
-        return t->layout;
+const llvm::StructLayout *tupleTypeLayout(TupleType *t) {
+    if (t->layout == nullptr) {
+        llvm::StructType *st = llvm::cast<llvm::StructType>(llvmType(t));
+        t->layout = llvmDataLayout->getStructLayout(st);
     }
+    return t->layout;
+}
 
-    const llvm::StructLayout *recordTypeLayout(RecordType *t) {
-        if (t->layout == nullptr) {
-            llvm::StructType *st =
-                    llvm::cast<llvm::StructType>(llvmType(t));
-            t->layout = llvmDataLayout->getStructLayout(st);
-        }
-        return t->layout;
+const llvm::StructLayout *complexTypeLayout(ComplexType *t) {
+    if (t->layout == nullptr) {
+        llvm::StructType *st = llvm::cast<llvm::StructType>(llvmType(t));
+        t->layout = llvmDataLayout->getStructLayout(st);
     }
+    return t->layout;
+}
 
-    //
-    // verifyRecursionCorrectness
-    //
-
-    static void verifyRecursionCorrectness(TypePtr t,
-                                           set<TypePtr> &visited);
-
-    static void verifyRecursionCorrectness(TypePtr t) {
-        set<TypePtr> visited;
-        verifyRecursionCorrectness(t, visited);
+const llvm::StructLayout *recordTypeLayout(RecordType *t) {
+    if (t->layout == nullptr) {
+        llvm::StructType *st = llvm::cast<llvm::StructType>(llvmType(t));
+        t->layout = llvmDataLayout->getStructLayout(st);
     }
+    return t->layout;
+}
 
-    static void verifyRecursionCorrectness(TypePtr t,
-                                           set<TypePtr> &visited) {
-        pair<set<TypePtr>::iterator, bool>
-                result = visited.insert(t);
-        if (!result.second) {
-            string buf;
-            llvm::raw_string_ostream sout(buf);
-            sout << "invalid recursion in type: " << t;
-            error(sout.str());
-        }
+//
+// verifyRecursionCorrectness
+//
 
-        switch (t->typeKind) {
-            case ARRAY_TYPE: {
-                ArrayType *at = (ArrayType *) t.ptr();
-                verifyRecursionCorrectness(at->elementType, visited);
-                break;
-            }
-            case VEC_TYPE: {
-                VecType *vt = (VecType *) t.ptr();
-                verifyRecursionCorrectness(vt->elementType, visited);
-                break;
-            }
-            case TUPLE_TYPE: {
-                TupleType *tt = (TupleType *) t.ptr();
-                for (size_t i = 0; i < tt->elementTypes.size(); ++i)
-                    verifyRecursionCorrectness(tt->elementTypes[i], visited);
-                break;
-            }
-            case UNION_TYPE: {
-                UnionType *ut = (UnionType *) t.ptr();
-                for (size_t i = 0; i < ut->memberTypes.size(); ++i)
-                    verifyRecursionCorrectness(ut->memberTypes[i], visited);
-                break;
-            }
-            case RECORD_TYPE: {
-                RecordType *rt = (RecordType *) t.ptr();
-                llvm::ArrayRef<TypePtr> fieldTypes = recordFieldTypes(rt);
-                for (size_t i = 0; i < fieldTypes.size(); ++i)
-                    verifyRecursionCorrectness(fieldTypes[i], visited);
-                break;
-            }
-            case VARIANT_TYPE: {
-                VariantType *vt = (VariantType *) t.ptr();
-                llvm::ArrayRef<TypePtr> memberTypes = variantMemberTypes(vt);
-                for (size_t i = 0; i < memberTypes.size(); ++i)
-                    verifyRecursionCorrectness(memberTypes[i], visited);
-                break;
-            }
-            case NEW_TYPE: {
-                NewType *nt = (NewType *) t.ptr();
-                verifyRecursionCorrectness(newtypeReprType(nt), visited);
-                break;
-            }
-            default:
-                break;
-        }
+static void verifyRecursionCorrectness(TypePtr t, set<TypePtr> &visited);
 
-        visited.erase(result.first);
-    }
+static void verifyRecursionCorrectness(TypePtr t) {
+    set<TypePtr> visited;
+    verifyRecursionCorrectness(t, visited);
+}
 
-    //
-    // llvmIntType, llvmFloatType, llvmPointerType, llvmArrayType, llvmVoidType
-    //
+static void verifyRecursionCorrectness(TypePtr t, set<TypePtr> &visited) {
+    pair<set<TypePtr>::iterator, bool> result = visited.insert(t);
+    if (!result.second) {
+        string buf;
+        llvm::raw_string_ostream sout(buf);
+        sout << "invalid recursion in type: " << t;
+        error(sout.str());
+    }
+
+    switch (t->typeKind) {
+    case ARRAY_TYPE: {
+        ArrayType *at = (ArrayType *)t.ptr();
+        verifyRecursionCorrectness(at->elementType, visited);
+        break;
+    }
+    case VEC_TYPE: {
+        VecType *vt = (VecType *)t.ptr();
+        verifyRecursionCorrectness(vt->elementType, visited);
+        break;
+    }
+    case TUPLE_TYPE: {
+        TupleType *tt = (TupleType *)t.ptr();
+        for (size_t i = 0; i < tt->elementTypes.size(); ++i)
+            verifyRecursionCorrectness(tt->elementTypes[i], visited);
+        break;
+    }
+    case UNION_TYPE: {
+        UnionType *ut = (UnionType *)t.ptr();
+        for (size_t i = 0; i < ut->memberTypes.size(); ++i)
+            verifyRecursionCorrectness(ut->memberTypes[i], visited);
+        break;
+    }
+    case RECORD_TYPE: {
+        RecordType *rt = (RecordType *)t.ptr();
+        llvm::ArrayRef<TypePtr> fieldTypes = recordFieldTypes(rt);
+        for (size_t i = 0; i < fieldTypes.size(); ++i)
+            verifyRecursionCorrectness(fieldTypes[i], visited);
+        break;
+    }
+    case VARIANT_TYPE: {
+        VariantType *vt = (VariantType *)t.ptr();
+        llvm::ArrayRef<TypePtr> memberTypes = variantMemberTypes(vt);
+        for (size_t i = 0; i < memberTypes.size(); ++i)
+            verifyRecursionCorrectness(memberTypes[i], visited);
+        break;
+    }
+    case NEW_TYPE: {
+        NewType *nt = (NewType *)t.ptr();
+        verifyRecursionCorrectness(newtypeReprType(nt), visited);
+        break;
+    }
+    default:
+        break;
+    }
+
+    visited.erase(result.first);
+}
 
-    llvm::Type *llvmIntType(unsigned bits) {
-        return llvm::IntegerType::get(llvmContext, bits);
-    }
+//
+// llvmIntType, llvmFloatType, llvmPointerType, llvmArrayType, llvmVoidType
+//
 
-    llvm::Type *llvmFloatType(unsigned bits) {
-        switch (bits) {
-            case 32:
-                return llvm::Type::getFloatTy(llvmContext);
-            case 64:
-                return llvm::Type::getDoubleTy(llvmContext);
-            case 80:
-                return llvm::Type::getX86_FP80Ty(llvmContext);
-            default:
-                assert(false);
-                return nullptr;
-        }
-    }
+llvm::Type *llvmIntType(unsigned bits) {
+    return llvm::IntegerType::get(llvmContext, bits);
+}
 
-    llvm::PointerType *llvmPointerType(llvm::Type *llType) {
-        return llvm::PointerType::getUnqual(llType);
+llvm::Type *llvmFloatType(unsigned bits) {
+    switch (bits) {
+    case 32:
+        return llvm::Type::getFloatTy(llvmContext);
+    case 64:
+        return llvm::Type::getDoubleTy(llvmContext);
+    case 80:
+        return llvm::Type::getX86_FP80Ty(llvmContext);
+    default:
+        assert(false);
+        return nullptr;
     }
+}
 
-    static void declareLLVMType(TypePtr t);
-
-    static void defineLLVMType(TypePtr t);
+llvm::PointerType *llvmPointerType(llvm::Type *llType) {
+    return llvm::PointerType::getUnqual(llType);
+}
 
-    static void makeLLVMType(const TypePtr& t);
+static void declareLLVMType(TypePtr t);
 
-    llvm::PointerType *llvmPointerType(TypePtr t) {
-        if (!t->llType)
-            declareLLVMType(t);
-        return llvmPointerType(t->llType);
-    }
+static void defineLLVMType(TypePtr t);
 
-    llvm::Type *llvmArrayType(llvm::Type *llType, unsigned size) {
-        return llvm::ArrayType::get(llType, size);
-    }
+static void makeLLVMType(const TypePtr &t);
 
-    llvm::Type *llvmArrayType(TypePtr type, unsigned size) {
-        return llvmArrayType(llvmType(type), size);
-    }
+llvm::PointerType *llvmPointerType(TypePtr t) {
+    if (!t->llType)
+        declareLLVMType(t);
+    return llvmPointerType(t->llType);
+}
 
-    llvm::Type *llvmVoidType() {
-        return llvm::Type::getVoidTy(llvmContext);
-    }
+llvm::Type *llvmArrayType(llvm::Type *llType, unsigned size) {
+    return llvm::ArrayType::get(llType, size);
+}
 
-    llvm::Type *CCodePointerType::getCallType() {
-        if (this->callType == nullptr) {
-            ExternalTargetPtr target = getExternalTarget();
-            ExternalFunction *extFunc = target->getExternalFunction(
-                this->callingConv, this->returnType, this->argTypes,
-                this->argTypes.size(), this->hasVarArgs);
+llvm::Type *llvmArrayType(TypePtr type, unsigned size) {
+    return llvmArrayType(llvmType(type), size);
+}
 
-            llvm::FunctionType *llFuncType = extFunc->getLLVMFunctionType();
-            this->callType = llvm::PointerType::getUnqual(llFuncType);
-        }
-        return this->callType;
-    }
+llvm::Type *llvmVoidType() { return llvm::Type::getVoidTy(llvmContext); }
 
-    //
-    // llvmType
-    //
+llvm::Type *CCodePointerType::getCallType() {
+    if (this->callType == nullptr) {
+        ExternalTargetPtr target = getExternalTarget();
+        ExternalFunction *extFunc = target->getExternalFunction(
+            this->callingConv, this->returnType, this->argTypes,
+            this->argTypes.size(), this->hasVarArgs);
 
-    static void makeLLVMType(const TypePtr& t) {
-        if (t->llType == nullptr) {
-            verifyRecursionCorrectness(t);
-            declareLLVMType(t);
-        }
-        if (!t->defined) {
-            defineLLVMType(t);
-        }
+        llvm::FunctionType *llFuncType = extFunc->getLLVMFunctionType();
+        this->callType = llvm::PointerType::getUnqual(llFuncType);
     }
+    return this->callType;
+}
 
-    llvm::Type *llvmType(const TypePtr& t) {
-        makeLLVMType(t);
+//
+// llvmType
+//
 
-        return t->llType;
+static void makeLLVMType(const TypePtr &t) {
+    if (t->llType == nullptr) {
+        verifyRecursionCorrectness(t);
+        declareLLVMType(t);
     }
-
-    llvm::StructType *llvmStaticType() {
-        static llvm::StructType *theType = nullptr;
-        if (theType == nullptr) {
-            llvm::SmallVector<llvm::Type *, 2> llTypes;
-            llTypes.push_back(llvmIntType(8));
-            theType = llvm::StructType::get(llvmContext, llTypes);
-        }
-        return theType;
+    if (!t->defined) {
+        defineLLVMType(t);
     }
+}
 
-    llvm::DIType llvmTypeDebugInfo(const TypePtr& t) {
-        if (t->llType == nullptr)
-            declareLLVMType(t);
+llvm::Type *llvmType(const TypePtr &t) {
+    makeLLVMType(t);
 
-        llvm::DIType r = t->getDebugInfo();
-        assert(r.Verify());
-        return r;
-    }
+    return t->llType;
+}
 
-    llvm::DIType llvmVoidTypeDebugInfo() {
-        return llvm::DIType(nullptr);
+llvm::StructType *llvmStaticType() {
+    static llvm::StructType *theType = nullptr;
+    if (theType == nullptr) {
+        llvm::SmallVector<llvm::Type *, 2> llTypes;
+        llTypes.push_back(llvmIntType(8));
+        theType = llvm::StructType::get(llvmContext, llTypes);
     }
+    return theType;
+}
 
-    static void declareLLVMType(TypePtr t) {
-        assert(t->llType == nullptr);
+llvm::DIType llvmTypeDebugInfo(const TypePtr &t) {
+    if (t->llType == nullptr)
+        declareLLVMType(t);
 
-        switch (t->typeKind) {
-            case BOOL_TYPE: {
-                t->llType = llvmIntType(1);
-                if (llvmDIBuilder != nullptr)
-                    t->debugInfo = (llvm::MDNode *) llvmDIBuilder->createBasicType(
-                        typeName(t),
-                        debugTypeSize(t->llType),
-                        debugTypeAlignment(t->llType),
-                        llvm::dwarf::DW_ATE_boolean);
-                break;
-            }
-            case INTEGER_TYPE: {
-                IntegerType *x = (IntegerType *) t.ptr();
-                t->llType = llvmIntType(x->bits);
-                if (llvmDIBuilder != nullptr)
-                    t->debugInfo = (llvm::MDNode *) llvmDIBuilder->createBasicType(
-                        typeName(t),
-                        debugTypeSize(t->llType),
-                        debugTypeAlignment(t->llType),
-                        x->isSigned ? llvm::dwarf::DW_ATE_signed : llvm::dwarf::DW_ATE_unsigned);
-                break;
-            }
-            case FLOAT_TYPE: {
-                FloatType *x = (FloatType *) t.ptr();
-                t->llType = llvmFloatType(x->bits);
-                if (llvmDIBuilder != nullptr)
-                    t->debugInfo = (llvm::MDNode *) llvmDIBuilder->createBasicType(
-                        typeName(t),
-                        debugTypeSize(t->llType),
-                        debugTypeAlignment(t->llType),
-                        x->isImaginary ? llvm::dwarf::DW_ATE_imaginary_float : llvm::dwarf::DW_ATE_float);
-                break;
-            }
-            case COMPLEX_TYPE: {
-                ComplexType *x = (ComplexType *) t.ptr();
-                vector<llvm::Type *> llTypes;
-                TypePtr realT = floatType(x->bits), imagT = imagType(x->bits);
-                llTypes.push_back(llvmType(realT));
-                llTypes.push_back(llvmType(imagT));
-                t->llType = llvm::StructType::create(llvmContext, llTypes, typeName(t));
-                if (llvmDIBuilder != nullptr) {
-                    t->debugInfo = (llvm::MDNode *) llvmDIBuilder->createBasicType(
-                        typeName(t),
-                        debugTypeSize(t->llType),
-                        debugTypeAlignment(t->llType),
-                        llvm::dwarf::DW_ATE_complex_float);
-                }
-                break;
+    llvm::DIType r = t->getDebugInfo();
+    assert(r.Verify());
+    return r;
+}
+
+llvm::DIType llvmVoidTypeDebugInfo() { return llvm::DIType(nullptr); }
+
+static void declareLLVMType(TypePtr t) {
+    assert(t->llType == nullptr);
+
+    switch (t->typeKind) {
+    case BOOL_TYPE: {
+        t->llType = llvmIntType(1);
+        if (llvmDIBuilder != nullptr)
+            t->debugInfo = (llvm::MDNode *)llvmDIBuilder->createBasicType(
+                typeName(t), debugTypeSize(t->llType),
+                debugTypeAlignment(t->llType), llvm::dwarf::DW_ATE_boolean);
+        break;
+    }
+    case INTEGER_TYPE: {
+        IntegerType *x = (IntegerType *)t.ptr();
+        t->llType = llvmIntType(x->bits);
+        if (llvmDIBuilder != nullptr)
+            t->debugInfo = (llvm::MDNode *)llvmDIBuilder->createBasicType(
+                typeName(t), debugTypeSize(t->llType),
+                debugTypeAlignment(t->llType),
+                x->isSigned ? llvm::dwarf::DW_ATE_signed
+                            : llvm::dwarf::DW_ATE_unsigned);
+        break;
+    }
+    case FLOAT_TYPE: {
+        FloatType *x = (FloatType *)t.ptr();
+        t->llType = llvmFloatType(x->bits);
+        if (llvmDIBuilder != nullptr)
+            t->debugInfo = (llvm::MDNode *)llvmDIBuilder->createBasicType(
+                typeName(t), debugTypeSize(t->llType),
+                debugTypeAlignment(t->llType),
+                x->isImaginary ? llvm::dwarf::DW_ATE_imaginary_float
+                               : llvm::dwarf::DW_ATE_float);
+        break;
+    }
+    case COMPLEX_TYPE: {
+        ComplexType *x = (ComplexType *)t.ptr();
+        vector<llvm::Type *> llTypes;
+        TypePtr realT = floatType(x->bits), imagT = imagType(x->bits);
+        llTypes.push_back(llvmType(realT));
+        llTypes.push_back(llvmType(imagT));
+        t->llType = llvm::StructType::create(llvmContext, llTypes, typeName(t));
+        if (llvmDIBuilder != nullptr) {
+            t->debugInfo = (llvm::MDNode *)llvmDIBuilder->createBasicType(
+                typeName(t), debugTypeSize(t->llType),
+                debugTypeAlignment(t->llType),
+                llvm::dwarf::DW_ATE_complex_float);
+        }
+        break;
+    }
+    case POINTER_TYPE: {
+        PointerType *x = (PointerType *)t.ptr();
+        t->llType = llvmPointerType(x->pointeeType);
+        if (llvmDIBuilder != nullptr)
+            t->debugInfo = (llvm::MDNode *)llvmDIBuilder->createPointerType(
+                llvmTypeDebugInfo(x->pointeeType), debugTypeSize(t->llType),
+                debugTypeAlignment(t->llType), typeName(t));
+        break;
+    }
+    case CODE_POINTER_TYPE: {
+        CodePointerType *x = (CodePointerType *)t.ptr();
+        vector<llvm::Type *> llArgTypes;
+        for (size_t i = 0; i < x->argTypes.size(); ++i)
+            llArgTypes.push_back(llvmPointerType(x->argTypes[i]));
+        for (size_t i = 0; i < x->returnTypes.size(); ++i) {
+            TypePtr t = x->returnTypes[i];
+            if (x->returnIsRef[i])
+                llArgTypes.push_back(llvmPointerType(pointerType(t)));
+            else
+                llArgTypes.push_back(llvmPointerType(t));
+        }
+        llvm::FunctionType *llFuncType =
+            llvm::FunctionType::get(exceptionReturnType(), llArgTypes, false);
+        t->llType = llvm::PointerType::getUnqual(llFuncType);
+        if (llvmDIBuilder != nullptr) {
+            vector<llvm::Value *> debugParamTypes;
+            debugParamTypes.push_back(llvmVoidTypeDebugInfo());
+            for (size_t i = 0; i < x->argTypes.size(); ++i) {
+                llvm::DIType argType = llvmTypeDebugInfo(x->argTypes[i]);
+                llvm::DIType argRefType = llvmDIBuilder->createReferenceType(
+                    llvm::dwarf::DW_TAG_reference_type, argType);
+                debugParamTypes.push_back(argRefType);
             }
-            case POINTER_TYPE: {
-                PointerType *x = (PointerType *) t.ptr();
-                t->llType = llvmPointerType(x->pointeeType);
-                if (llvmDIBuilder != nullptr)
-                    t->debugInfo = (llvm::MDNode *) llvmDIBuilder->createPointerType(
-                        llvmTypeDebugInfo(x->pointeeType),
-                        debugTypeSize(t->llType),
-                        debugTypeAlignment(t->llType),
-                        typeName(t));
-                break;
+            for (size_t i = 0; i < x->returnTypes.size(); ++i) {
+                llvm::DIType returnType = llvmTypeDebugInfo(x->returnTypes[i]);
+                llvm::DIType returnRefType =
+                    x->returnIsRef[i]
+                        ? llvmDIBuilder->createReferenceType(
+                              llvm::dwarf::DW_TAG_reference_type,
+                              llvmDIBuilder->createReferenceType(
+                                  llvm::dwarf::DW_TAG_reference_type,
+                                  returnType))
+                        : llvmDIBuilder->createReferenceType(
+                              llvm::dwarf::DW_TAG_reference_type, returnType);
+
+                debugParamTypes.push_back(returnRefType);
             }
-            case CODE_POINTER_TYPE: {
-                CodePointerType *x = (CodePointerType *) t.ptr();
-                vector<llvm::Type *> llArgTypes;
-                for (size_t i = 0; i < x->argTypes.size(); ++i)
-                    llArgTypes.push_back(llvmPointerType(x->argTypes[i]));
-                for (size_t i = 0; i < x->returnTypes.size(); ++i) {
-                    TypePtr t = x->returnTypes[i];
-                    if (x->returnIsRef[i])
-                        llArgTypes.push_back(llvmPointerType(pointerType(t)));
-                    else
-                        llArgTypes.push_back(llvmPointerType(t));
-                }
-                llvm::FunctionType *llFuncType =
-                        llvm::FunctionType::get(exceptionReturnType(), llArgTypes, false);
-                t->llType = llvm::PointerType::getUnqual(llFuncType);
-                if (llvmDIBuilder != nullptr) {
-                    vector<llvm::Value *> debugParamTypes;
-                    debugParamTypes.push_back(llvmVoidTypeDebugInfo());
-                    for (size_t i = 0; i < x->argTypes.size(); ++i) {
-                        llvm::DIType argType = llvmTypeDebugInfo(x->argTypes[i]);
-                        llvm::DIType argRefType
-                                = llvmDIBuilder->createReferenceType(
-                                    llvm::dwarf::DW_TAG_reference_type,
-                                    argType);
-                        debugParamTypes.push_back(argRefType);
-                    }
-                    for (size_t i = 0; i < x->returnTypes.size(); ++i) {
-                        llvm::DIType returnType = llvmTypeDebugInfo(x->returnTypes[i]);
-                        llvm::DIType returnRefType = x->returnIsRef[i]
-                                                         ? llvmDIBuilder->createReferenceType(
-                                                             llvm::dwarf::DW_TAG_reference_type,
-                                                             llvmDIBuilder->createReferenceType(
-                                                                 llvm::dwarf::DW_TAG_reference_type,
-                                                                 returnType))
-                                                         : llvmDIBuilder->createReferenceType(
-                                                             llvm::dwarf::DW_TAG_reference_type,
-                                                             returnType);
-
-                        debugParamTypes.push_back(returnRefType);
-                    }
 
-                    llvm::DIArray debugParamArray = llvmDIBuilder->getOrCreateArray(
-                        llvm::ArrayRef(debugParamTypes));
+            llvm::DIArray debugParamArray = llvmDIBuilder->getOrCreateArray(
+                llvm::ArrayRef(debugParamTypes));
 
-                    llvm::DIType pointeeType = llvmDIBuilder->createSubroutineType(
-                        llvm::DIFile(),
-                        debugParamArray);
+            llvm::DIType pointeeType = llvmDIBuilder->createSubroutineType(
+                llvm::DIFile(), debugParamArray);
 
-                    t->debugInfo = (llvm::MDNode *) llvmDIBuilder->createPointerType(
-                        pointeeType,
-                        debugTypeSize(t->llType),
-                        debugTypeAlignment(t->llType),
-                        typeName(t));
-                }
-                break;
-            }
-            case CCODE_POINTER_TYPE: {
-                CCodePointerType *x = (CCodePointerType *) t.ptr();
-
-                if (x->callingConv == CC_LLVM) {
-                    // LLVM intrinsic function pointers can't be bitcast. Generate the LLVM type
-                    // directly.
-                    llvm::Type *returnType = llvmType(x->returnType);
-                    vector<llvm::Type *> argTypes;
-                    for (size_t i = 0; i < x->argTypes.size(); ++i)
-                        argTypes.push_back(llvmType(x->argTypes[i]));
-                    llvm::FunctionType *funcType =
-                            llvm::FunctionType::get(returnType, argTypes, x->hasVarArgs);
-                    t->llType = llvm::PointerType::getUnqual(funcType);
-                } else {
-                    // Deriving the C ABI type may require type recursion, so cast to void()*
-                    // for now. We can bitcast to the proper type when we know it.
-                    llvm::FunctionType *llOpaqueFuncType =
-                            llvm::FunctionType::get(llvmVoidType(), vector<llvm::Type *>(), false);
-                    t->llType = llvm::PointerType::getUnqual(llOpaqueFuncType);
-                }
+            t->debugInfo = (llvm::MDNode *)llvmDIBuilder->createPointerType(
+                pointeeType, debugTypeSize(t->llType),
+                debugTypeAlignment(t->llType), typeName(t));
+        }
+        break;
+    }
+    case CCODE_POINTER_TYPE: {
+        CCodePointerType *x = (CCodePointerType *)t.ptr();
+
+        if (x->callingConv == CC_LLVM) {
+            // LLVM intrinsic function pointers can't be bitcast. Generate the
+            // LLVM type directly.
+            llvm::Type *returnType = llvmType(x->returnType);
+            vector<llvm::Type *> argTypes;
+            for (size_t i = 0; i < x->argTypes.size(); ++i)
+                argTypes.push_back(llvmType(x->argTypes[i]));
+            llvm::FunctionType *funcType =
+                llvm::FunctionType::get(returnType, argTypes, x->hasVarArgs);
+            t->llType = llvm::PointerType::getUnqual(funcType);
+        } else {
+            // Deriving the C ABI type may require type recursion, so cast to
+            // void()* for now. We can bitcast to the proper type when we know
+            // it.
+            llvm::FunctionType *llOpaqueFuncType = llvm::FunctionType::get(
+                llvmVoidType(), vector<llvm::Type *>(), false);
+            t->llType = llvm::PointerType::getUnqual(llOpaqueFuncType);
+        }
 
-                if (llvmDIBuilder != nullptr) {
-                    llvm::SmallVector<llvm::Value *, 16> debugParamTypes;
-                    debugParamTypes.push_back(x->returnType == nullptr
-                                                  ? llvmVoidTypeDebugInfo()
-                                                  : llvmTypeDebugInfo(x->returnType));
+        if (llvmDIBuilder != nullptr) {
+            llvm::SmallVector<llvm::Value *, 16> debugParamTypes;
+            debugParamTypes.push_back(x->returnType == nullptr
+                                          ? llvmVoidTypeDebugInfo()
+                                          : llvmTypeDebugInfo(x->returnType));
 
-                    for (size_t i = 0; i < x->argTypes.size(); ++i) {
-                        debugParamTypes.push_back(llvmTypeDebugInfo(x->argTypes[i]));
-                    }
+            for (size_t i = 0; i < x->argTypes.size(); ++i) {
+                debugParamTypes.push_back(llvmTypeDebugInfo(x->argTypes[i]));
+            }
 
-                    llvm::DIArray debugParamArray = llvmDIBuilder->getOrCreateArray(debugParamTypes);
+            llvm::DIArray debugParamArray =
+                llvmDIBuilder->getOrCreateArray(debugParamTypes);
 
-                    llvm::DIType pointeeType = llvmDIBuilder->createSubroutineType(
-                        llvm::DIFile(),
-                        debugParamArray);
+            llvm::DIType pointeeType = llvmDIBuilder->createSubroutineType(
+                llvm::DIFile(), debugParamArray);
 
-                    t->debugInfo = (llvm::MDNode *) llvmDIBuilder->createPointerType(
-                        pointeeType,
-                        debugTypeSize(t->llType),
-                        debugTypeAlignment(t->llType),
-                        typeName(t));
-                }
+            t->debugInfo = (llvm::MDNode *)llvmDIBuilder->createPointerType(
+                pointeeType, debugTypeSize(t->llType),
+                debugTypeAlignment(t->llType), typeName(t));
+        }
 
-                break;
-            }
-            case ARRAY_TYPE: {
-                ArrayType *x = (ArrayType *) t.ptr();
-                t->llType = llvmArrayType(x->elementType, x->size);
-                if (llvmDIBuilder != nullptr) {
-                    llvm::Value *elementRange = llvmDIBuilder->getOrCreateSubrange(
-                        0,
-                        x->size - 1);
-                    llvm::DIArray elementRangeArray = llvmDIBuilder->getOrCreateArray(
-                        llvm::ArrayRef(&elementRange, &elementRange + 1));
-                    t->debugInfo = (llvm::MDNode *) llvmDIBuilder->createArrayType(
-                        debugTypeSize(t->llType),
-                        debugTypeAlignment(t->llType),
-                        llvmTypeDebugInfo(x->elementType),
-                        elementRangeArray);
-                }
-                break;
-            }
-            case VEC_TYPE: {
-                VecType *x = (VecType *) t.ptr();
-                t->llType = llvm::VectorType::get(llvmType(x->elementType), x->size);
-                if (llvmDIBuilder != nullptr) {
-                    llvm::Value *elementRange = llvmDIBuilder->getOrCreateSubrange(
-                        0,
-                        x->size - 1);
-                    llvm::DIArray elementRangeArray = llvmDIBuilder->getOrCreateArray(
-                        llvm::ArrayRef(&elementRange, &elementRange + 1));
-                    t->debugInfo = (llvm::MDNode *) llvmDIBuilder->createVectorType(
-                        x->size,
-                        debugTypeAlignment(llvmType(x->elementType)),
-                        llvmTypeDebugInfo(x->elementType),
-                        elementRangeArray);
-                }
-                break;
-            }
-            case TUPLE_TYPE: {
-                t->llType = llvm::StructType::create(llvmContext, typeName(t));
-                if (llvmDIBuilder != nullptr)
-                    t->debugInfo = (llvm::MDNode *) llvmDIBuilder->createTemporaryType();
-                break;
-            }
-            case UNION_TYPE: {
-                t->llType = llvm::StructType::create(llvmContext, typeName(t));
-                if (llvmDIBuilder != nullptr)
-                    t->debugInfo = (llvm::MDNode *) llvmDIBuilder->createTemporaryType();
-                break;
-            }
-            case RECORD_TYPE: {
-                t->llType = llvm::StructType::create(llvmContext, typeName(t));
-                if (llvmDIBuilder != nullptr)
-                    t->debugInfo = (llvm::MDNode *) llvmDIBuilder->createTemporaryType();
-                break;
-            }
-            case VARIANT_TYPE: {
-                VariantType *x = (VariantType *) t.ptr();
-                TypePtr reprType = variantReprType(x);
-                if (!reprType->llType)
-                    declareLLVMType(reprType);
-                t->llType = reprType->llType;
-                if (llvmDIBuilder != nullptr)
-                    t->debugInfo = (llvm::MDNode *) llvmDIBuilder->createTemporaryType();
-                break;
-            }
-            case STATIC_TYPE: {
-                t->llType = llvmStaticType();
-                if (llvmDIBuilder != nullptr)
-                    t->debugInfo = (llvm::MDNode *) llvmDIBuilder->createBasicType(
-                        typeName(t),
-                        debugTypeSize(t->llType),
-                        debugTypeAlignment(t->llType),
-                        llvm::dwarf::DW_ATE_signed);
-                break;
-            }
-            case ENUM_TYPE: {
-                t->llType = llvmType(cIntType);
-                if (llvmDIBuilder != nullptr) {
-                    EnumType *en = (EnumType *) t.ptr();
-                    llvm::SmallVector<llvm::Value *, 16> enumerators;
-                    for (vector<EnumMemberPtr>::const_iterator i = en->enumeration->members.begin(),
-                                 end = en->enumeration->members.end();
-                         i != end;
-                         ++i) {
-                        enumerators.push_back(
-                            llvmDIBuilder->createEnumerator((*i)->name->str, (unsigned) ((*i)->index)));
-                    }
-                    llvm::DIArray enumArray = llvmDIBuilder->getOrCreateArray(enumerators);
-
-                    unsigned line, column;
-                    llvm::DIFile file = getDebugLineCol(en->enumeration->location, line, column);
-
-                    t->debugInfo = (llvm::MDNode *) llvmDIBuilder->createEnumerationType(
-                        lookupModuleDebugInfo(en->enumeration->env), // scope
-                        typeName(t),
-                        file,
-                        line,
-                        debugTypeSize(t->llType),
-                        debugTypeAlignment(t->llType),
-                        enumArray,
-                        llvm::DIType());
-                }
-                break;
-            }
-            case NEW_TYPE: {
-                NewType *x = (NewType *) t.ptr();
-                TypePtr reprType = newtypeReprType(x);
-                if (!reprType->llType)
-                    declareLLVMType(reprType);
-                t->llType = reprType->llType;
-                if (llvmDIBuilder != nullptr)
-                    t->debugInfo = (llvm::MDNode *) llvmDIBuilder->createTemporaryType();
-                break;
+        break;
+    }
+    case ARRAY_TYPE: {
+        ArrayType *x = (ArrayType *)t.ptr();
+        t->llType = llvmArrayType(x->elementType, x->size);
+        if (llvmDIBuilder != nullptr) {
+            llvm::Value *elementRange =
+                llvmDIBuilder->getOrCreateSubrange(0, x->size - 1);
+            llvm::DIArray elementRangeArray = llvmDIBuilder->getOrCreateArray(
+                llvm::ArrayRef(&elementRange, &elementRange + 1));
+            t->debugInfo = (llvm::MDNode *)llvmDIBuilder->createArrayType(
+                debugTypeSize(t->llType), debugTypeAlignment(t->llType),
+                llvmTypeDebugInfo(x->elementType), elementRangeArray);
+        }
+        break;
+    }
+    case VEC_TYPE: {
+        VecType *x = (VecType *)t.ptr();
+        t->llType = llvm::VectorType::get(llvmType(x->elementType), x->size);
+        if (llvmDIBuilder != nullptr) {
+            llvm::Value *elementRange =
+                llvmDIBuilder->getOrCreateSubrange(0, x->size - 1);
+            llvm::DIArray elementRangeArray = llvmDIBuilder->getOrCreateArray(
+                llvm::ArrayRef(&elementRange, &elementRange + 1));
+            t->debugInfo = (llvm::MDNode *)llvmDIBuilder->createVectorType(
+                x->size, debugTypeAlignment(llvmType(x->elementType)),
+                llvmTypeDebugInfo(x->elementType), elementRangeArray);
+        }
+        break;
+    }
+    case TUPLE_TYPE: {
+        t->llType = llvm::StructType::create(llvmContext, typeName(t));
+        if (llvmDIBuilder != nullptr)
+            t->debugInfo = (llvm::MDNode *)llvmDIBuilder->createTemporaryType();
+        break;
+    }
+    case UNION_TYPE: {
+        t->llType = llvm::StructType::create(llvmContext, typeName(t));
+        if (llvmDIBuilder != nullptr)
+            t->debugInfo = (llvm::MDNode *)llvmDIBuilder->createTemporaryType();
+        break;
+    }
+    case RECORD_TYPE: {
+        t->llType = llvm::StructType::create(llvmContext, typeName(t));
+        if (llvmDIBuilder != nullptr)
+            t->debugInfo = (llvm::MDNode *)llvmDIBuilder->createTemporaryType();
+        break;
+    }
+    case VARIANT_TYPE: {
+        VariantType *x = (VariantType *)t.ptr();
+        TypePtr reprType = variantReprType(x);
+        if (!reprType->llType)
+            declareLLVMType(reprType);
+        t->llType = reprType->llType;
+        if (llvmDIBuilder != nullptr)
+            t->debugInfo = (llvm::MDNode *)llvmDIBuilder->createTemporaryType();
+        break;
+    }
+    case STATIC_TYPE: {
+        t->llType = llvmStaticType();
+        if (llvmDIBuilder != nullptr)
+            t->debugInfo = (llvm::MDNode *)llvmDIBuilder->createBasicType(
+                typeName(t), debugTypeSize(t->llType),
+                debugTypeAlignment(t->llType), llvm::dwarf::DW_ATE_signed);
+        break;
+    }
+    case ENUM_TYPE: {
+        t->llType = llvmType(cIntType);
+        if (llvmDIBuilder != nullptr) {
+            EnumType *en = (EnumType *)t.ptr();
+            llvm::SmallVector<llvm::Value *, 16> enumerators;
+            for (vector<EnumMemberPtr>::const_iterator
+                     i = en->enumeration->members.begin(),
+                     end = en->enumeration->members.end();
+                 i != end; ++i) {
+                enumerators.push_back(llvmDIBuilder->createEnumerator(
+                    (*i)->name->str, (unsigned)((*i)->index)));
             }
-            default:
-                assert(false);
+            llvm::DIArray enumArray =
+                llvmDIBuilder->getOrCreateArray(enumerators);
+
+            unsigned line, column;
+            llvm::DIFile file =
+                getDebugLineCol(en->enumeration->location, line, column);
+
+            t->debugInfo = (llvm::MDNode *)llvmDIBuilder->createEnumerationType(
+                lookupModuleDebugInfo(en->enumeration->env), // scope
+                typeName(t), file, line, debugTypeSize(t->llType),
+                debugTypeAlignment(t->llType), enumArray, llvm::DIType());
         }
+        break;
+    }
+    case NEW_TYPE: {
+        NewType *x = (NewType *)t.ptr();
+        TypePtr reprType = newtypeReprType(x);
+        if (!reprType->llType)
+            declareLLVMType(reprType);
+        t->llType = reprType->llType;
+        if (llvmDIBuilder != nullptr)
+            t->debugInfo = (llvm::MDNode *)llvmDIBuilder->createTemporaryType();
+        break;
     }
+    default:
+        assert(false);
+    }
+}
 
-    static void defineLLVMType(TypePtr t) {
-        assert(t->llType != nullptr && !t->defined);
-
-        switch (t->typeKind) {
-            case BOOL_TYPE:
-            case INTEGER_TYPE:
-            case FLOAT_TYPE:
-            case COMPLEX_TYPE:
-            case POINTER_TYPE:
-            case CODE_POINTER_TYPE:
-            case CCODE_POINTER_TYPE:
-            case ARRAY_TYPE:
-            case VEC_TYPE:
-            case STATIC_TYPE:
-            case ENUM_TYPE:
-                break;
-
-            case TUPLE_TYPE: {
-                TupleType *x = (TupleType *) t.ptr();
-
-                llvm::StructType *theType = llvm::cast<llvm::StructType>(t->llType);
-
-                vector<llvm::Type *> llTypes;
-                vector<TypePtr>::iterator i, end;
-                for (i = x->elementTypes.begin(), end = x->elementTypes.end();
-                     i != end; ++i)
-                    llTypes.push_back(llvmType(*i));
-                if (x->elementTypes.empty())
-                    llTypes.push_back(llvmIntType(8));
-
-                theType->setBody(llTypes);
-
-                if (llvmDIBuilder != nullptr) {
-                    llvm::TrackingVH<llvm::MDNode> placeholderNode = (llvm::MDNode *) x->getDebugInfo();
-                    llvm::DIType placeholder(placeholderNode);
-
-                    vector<llvm::Value *> members;
-                    size_t debugOffset = 0;
-                    vector<TypePtr>::iterator i, end;
-                    for (i = x->elementTypes.begin(), end = x->elementTypes.end();
-                         i != end;
-                         ++i) {
-                        llvm::Type *memberLLT = llvmType(*i);
-                        size_t debugAlign = debugTypeAlignment(memberLLT);
-                        size_t debugSize = debugTypeSize(memberLLT);
-                        debugOffset = alignedUpTo(debugOffset, debugAlign);
-                        llvm::SmallString<128> buf;
-                        llvm::raw_svector_ostream name(buf);
-                        name << "element" << i - x->elementTypes.begin();
-                        members.push_back(llvmDIBuilder->createMemberType(
-                            placeholder,
-                            name.str(),
-                            llvm::DIFile(), // file
-                            0, // lineNo
-                            debugSize, // size
-                            debugAlign, // align
-                            debugOffset, // offset
-                            0, // flags
-                            llvmTypeDebugInfo(*i) // type
-                        ));
-                        debugOffset += debugSize;
-                    }
+static void defineLLVMType(TypePtr t) {
+    assert(t->llType != nullptr && !t->defined);
+
+    switch (t->typeKind) {
+    case BOOL_TYPE:
+    case INTEGER_TYPE:
+    case FLOAT_TYPE:
+    case COMPLEX_TYPE:
+    case POINTER_TYPE:
+    case CODE_POINTER_TYPE:
+    case CCODE_POINTER_TYPE:
+    case ARRAY_TYPE:
+    case VEC_TYPE:
+    case STATIC_TYPE:
+    case ENUM_TYPE:
+        break;
+
+    case TUPLE_TYPE: {
+        TupleType *x = (TupleType *)t.ptr();
+
+        llvm::StructType *theType = llvm::cast<llvm::StructType>(t->llType);
+
+        vector<llvm::Type *> llTypes;
+        vector<TypePtr>::iterator i, end;
+        for (i = x->elementTypes.begin(), end = x->elementTypes.end(); i != end;
+             ++i)
+            llTypes.push_back(llvmType(*i));
+        if (x->elementTypes.empty())
+            llTypes.push_back(llvmIntType(8));
 
-                    llvm::DIArray memberArray = llvmDIBuilder->getOrCreateArray(
-                        llvm::ArrayRef(members));
-
-                    t->debugInfo = (llvm::MDNode *) llvmDIBuilder->createStructType(
-                        primitivesModule()->getDebugInfo(), // scope
-                        typeName(t),
-                        globalMainModule->source->getDebugInfo(), // file
-                        0, // lineNo
-                        debugTypeSize(t->llType),
-                        debugTypeAlignment(t->llType),
-                        0, // flags
-                        memberArray);
-                    llvm::DIType(placeholderNode).replaceAllUsesWith(t->getDebugInfo());
-                }
-                break;
+        theType->setBody(llTypes);
+
+        if (llvmDIBuilder != nullptr) {
+            llvm::TrackingVH<llvm::MDNode> placeholderNode =
+                (llvm::MDNode *)x->getDebugInfo();
+            llvm::DIType placeholder(placeholderNode);
+
+            vector<llvm::Value *> members;
+            size_t debugOffset = 0;
+            vector<TypePtr>::iterator i, end;
+            for (i = x->elementTypes.begin(), end = x->elementTypes.end();
+                 i != end; ++i) {
+                llvm::Type *memberLLT = llvmType(*i);
+                size_t debugAlign = debugTypeAlignment(memberLLT);
+                size_t debugSize = debugTypeSize(memberLLT);
+                debugOffset = alignedUpTo(debugOffset, debugAlign);
+                llvm::SmallString<128> buf;
+                llvm::raw_svector_ostream name(buf);
+                name << "element" << i - x->elementTypes.begin();
+                members.push_back(llvmDIBuilder->createMemberType(
+                    placeholder, name.str(),
+                    llvm::DIFile(),       // file
+                    0,                    // lineNo
+                    debugSize,            // size
+                    debugAlign,           // align
+                    debugOffset,          // offset
+                    0,                    // flags
+                    llvmTypeDebugInfo(*i) // type
+                    ));
+                debugOffset += debugSize;
             }
-            case UNION_TYPE: {
-                UnionType *x = (UnionType *) t.ptr();
-
-                llvm::StructType *theType = llvm::cast<llvm::StructType>(t->llType);
-
-                llvm::Type *maxAlignType = nullptr;
-                size_t maxAlign = 0;
-                size_t maxAlignSize = 0;
-                size_t maxSize = 0;
-                for (size_t i = 0; i < x->memberTypes.size(); ++i) {
-                    llvm::Type *llt = llvmType(x->memberTypes[i]);
-                    size_t align = (size_t) llvmDataLayout->getABITypeAlign(llt);
-                    size_t size = (size_t) llvmDataLayout->getTypeAllocSize(llt);
-                    if (align > maxAlign) {
-                        maxAlign = align;
-                        maxAlignType = llt;
-                        maxAlignSize = size;
-                    }
-                    if (size > maxSize)
-                        maxSize = size;
-                }
-                if (!maxAlignType) {
-                    maxAlignType = llvmIntType(8);
-                    maxAlign = 1;
-                }
-                vector<llvm::Type *> llTypes;
-                llTypes.push_back(maxAlignType);
-                if (maxSize > maxAlignSize) {
-                    llvm::Type *padding =
-                            llvm::ArrayType::get(llvmIntType(8), maxSize - maxAlignSize);
-                    llTypes.push_back(padding);
-                }
 
-                theType->setBody(llTypes);
+            llvm::DIArray memberArray =
+                llvmDIBuilder->getOrCreateArray(llvm::ArrayRef(members));
+
+            t->debugInfo = (llvm::MDNode *)llvmDIBuilder->createStructType(
+                primitivesModule()->getDebugInfo(), // scope
+                typeName(t),
+                globalMainModule->source->getDebugInfo(), // file
+                0,                                        // lineNo
+                debugTypeSize(t->llType), debugTypeAlignment(t->llType),
+                0, // flags
+                memberArray);
+            llvm::DIType(placeholderNode).replaceAllUsesWith(t->getDebugInfo());
+        }
+        break;
+    }
+    case UNION_TYPE: {
+        UnionType *x = (UnionType *)t.ptr();
+
+        llvm::StructType *theType = llvm::cast<llvm::StructType>(t->llType);
+
+        llvm::Type *maxAlignType = nullptr;
+        size_t maxAlign = 0;
+        size_t maxAlignSize = 0;
+        size_t maxSize = 0;
+        for (size_t i = 0; i < x->memberTypes.size(); ++i) {
+            llvm::Type *llt = llvmType(x->memberTypes[i]);
+            size_t align = (size_t)llvmDataLayout->getABITypeAlign(llt);
+            size_t size = (size_t)llvmDataLayout->getTypeAllocSize(llt);
+            if (align > maxAlign) {
+                maxAlign = align;
+                maxAlignType = llt;
+                maxAlignSize = size;
+            }
+            if (size > maxSize)
+                maxSize = size;
+        }
+        if (!maxAlignType) {
+            maxAlignType = llvmIntType(8);
+            maxAlign = 1;
+        }
+        vector<llvm::Type *> llTypes;
+        llTypes.push_back(maxAlignType);
+        if (maxSize > maxAlignSize) {
+            llvm::Type *padding =
+                llvm::ArrayType::get(llvmIntType(8), maxSize - maxAlignSize);
+            llTypes.push_back(padding);
+        }
 
-                if (llvmDIBuilder != nullptr) {
-                    llvm::TrackingVH<llvm::MDNode> placeholderNode = (llvm::MDNode *) x->getDebugInfo();
-                    llvm::DIType placeholder(placeholderNode);
+        theType->setBody(llTypes);
+
+        if (llvmDIBuilder != nullptr) {
+            llvm::TrackingVH<llvm::MDNode> placeholderNode =
+                (llvm::MDNode *)x->getDebugInfo();
+            llvm::DIType placeholder(placeholderNode);
+
+            vector<llvm::Value *> members;
+            vector<TypePtr>::iterator i, end;
+            for (i = x->memberTypes.begin(), end = x->memberTypes.end();
+                 i != end; ++i) {
+                llvm::Type *memberLLT = llvmType(*i);
+                size_t debugAlign = debugTypeAlignment(memberLLT);
+                size_t debugSize = debugTypeSize(memberLLT);
+                llvm::SmallString<128> buf;
+                llvm::raw_svector_ostream name(buf);
+                name << "element" << i - x->memberTypes.begin();
+                members.push_back(llvmDIBuilder->createMemberType(
+                    placeholder, name.str(),
+                    llvm::DIFile(),       // file
+                    0,                    // lineNo
+                    debugSize,            // size
+                    debugAlign,           // align
+                    0,                    // offset
+                    0,                    // flags
+                    llvmTypeDebugInfo(*i) // type
+                    ));
+            }
 
-                    vector<llvm::Value *> members;
-                    vector<TypePtr>::iterator i, end;
-                    for (i = x->memberTypes.begin(), end = x->memberTypes.end();
-                         i != end;
-                         ++i) {
-                        llvm::Type *memberLLT = llvmType(*i);
-                        size_t debugAlign = debugTypeAlignment(memberLLT);
-                        size_t debugSize = debugTypeSize(memberLLT);
-                        llvm::SmallString<128> buf;
-                        llvm::raw_svector_ostream name(buf);
-                        name << "element" << i - x->memberTypes.begin();
-                        members.push_back(llvmDIBuilder->createMemberType(
-                            placeholder,
-                            name.str(),
-                            llvm::DIFile(), // file
-                            0, // lineNo
-                            debugSize, // size
-                            debugAlign, // align
-                            0, // offset
-                            0, // flags
-                            llvmTypeDebugInfo(*i) // type
-                        ));
-                    }
+            llvm::DIArray memberArray =
+                llvmDIBuilder->getOrCreateArray(llvm::ArrayRef(members));
+
+            t->debugInfo = (llvm::MDNode *)llvmDIBuilder->createUnionType(
+                primitivesModule()->getDebugInfo(), // scope
+                typeName(t),
+                globalMainModule->source->getDebugInfo(), // file
+                0,                                        // lineNo
+                debugTypeSize(t->llType), debugTypeAlignment(t->llType),
+                0, // flags
+                memberArray);
+            llvm::DIType(placeholderNode).replaceAllUsesWith(t->getDebugInfo());
+        }
+        break;
+    }
+    case RECORD_TYPE: {
+        RecordType *x = (RecordType *)t.ptr();
 
-                    llvm::DIArray memberArray = llvmDIBuilder->getOrCreateArray(
-                        llvm::ArrayRef(members));
-
-                    t->debugInfo = (llvm::MDNode *) llvmDIBuilder->createUnionType(
-                        primitivesModule()->getDebugInfo(), // scope
-                        typeName(t),
-                        globalMainModule->source->getDebugInfo(), // file
-                        0, // lineNo
-                        debugTypeSize(t->llType),
-                        debugTypeAlignment(t->llType),
-                        0, // flags
-                        memberArray);
-                    llvm::DIType(placeholderNode).replaceAllUsesWith(t->getDebugInfo());
-                }
-                break;
-            }
-            case RECORD_TYPE: {
-                RecordType *x = (RecordType *) t.ptr();
-
-                llvm::StructType *theType = llvm::cast<llvm::StructType>(t->llType);
-
-                llvm::ArrayRef<TypePtr> fieldTypes = recordFieldTypes(x);
-                vector<llvm::Type *> llTypes;
-                TypePtr const *i, *end;
-                for (i = fieldTypes.begin(), end = fieldTypes.end(); i != end; ++i)
-                    llTypes.push_back(llvmType(*i));
-                if (fieldTypes.empty())
-                    llTypes.push_back(llvmIntType(8));
-
-                theType->setBody(llTypes);
-
-                if (llvmDIBuilder != nullptr) {
-                    llvm::TrackingVH<llvm::MDNode> placeholderNode = (llvm::MDNode *) x->getDebugInfo();
-                    llvm::DIType placeholder(placeholderNode);
-                    llvm::ArrayRef<IdentifierPtr> fieldNames = recordFieldNames(x);
-                    vector<llvm::Value *> members;
-                    size_t debugOffset = 0;
-                    for (size_t i = 0; i < fieldNames.size(); ++i) {
-                        if (x->hasVarField && i >= x->varFieldPosition) {
-                            if (i == x->varFieldPosition) {
-                                for (size_t j = 0; j < x->varFieldSize(); ++j) {
-                                    llvm::SmallString<128> buf;
-                                    llvm::raw_svector_ostream sout(buf);
-                                    sout << fieldNames[i] << ".." << j;
-                                    llvm::Type *memberLLT = llvmType(fieldTypes[i + j]);
-                                    size_t debugAlign = debugTypeAlignment(memberLLT);
-                                    size_t debugSize = debugTypeSize(memberLLT);
-                                    debugOffset = alignedUpTo(debugOffset, debugAlign);
-
-                                    Location fieldLocation = fieldNames[i]->location;
-                                    if (!fieldLocation.ok())
-                                        fieldLocation = x->record->location;
-                                    unsigned fieldLine, fieldColumn;
-                                    llvm::DIFile fieldFile = getDebugLineCol(fieldLocation, fieldLine, fieldColumn);
-                                    members.push_back(llvmDIBuilder->createMemberType(
-                                        placeholder,
-                                        sout.str(),
-                                        fieldFile, // file
-                                        fieldLine, // lineNo
-                                        debugSize, // size
-                                        debugAlign, // align
-                                        debugOffset, // offset
-                                        0, // flags
-                                        llvmTypeDebugInfo(fieldTypes[i + j]) // type
-                                    ));
-                                    debugOffset += debugSize;
-                                }
-                            } else {
-                                size_t k = i + x->varFieldSize() - 1;
-                                llvm::Type *memberLLT = llvmType(fieldTypes[k]);
-                                size_t debugAlign = debugTypeAlignment(memberLLT);
-                                size_t debugSize = debugTypeSize(memberLLT);
-                                debugOffset = alignedUpTo(debugOffset, debugAlign);
-
-                                Location fieldLocation = fieldNames[i]->location;
-                                if (!fieldLocation.ok())
-                                    fieldLocation = x->record->location;
-                                unsigned fieldLine, fieldColumn;
-                                llvm::DIFile fieldFile = getDebugLineCol(fieldLocation, fieldLine, fieldColumn);
-                                members.push_back(llvmDIBuilder->createMemberType(
-                                    placeholder,
-                                    fieldNames[i]->str,
-                                    fieldFile, // file
-                                    fieldLine, // lineNo
-                                    debugSize, // size
-                                    debugAlign, // align
-                                    debugOffset, // offset
-                                    0, // flags
-                                    llvmTypeDebugInfo(fieldTypes[k]) // type
-                                ));
-                                debugOffset += debugSize;
-                            }
-                        } else {
-                            llvm::Type *memberLLT = llvmType(fieldTypes[i]);
+        llvm::StructType *theType = llvm::cast<llvm::StructType>(t->llType);
+
+        llvm::ArrayRef<TypePtr> fieldTypes = recordFieldTypes(x);
+        vector<llvm::Type *> llTypes;
+        TypePtr const *i, *end;
+        for (i = fieldTypes.begin(), end = fieldTypes.end(); i != end; ++i)
+            llTypes.push_back(llvmType(*i));
+        if (fieldTypes.empty())
+            llTypes.push_back(llvmIntType(8));
+
+        theType->setBody(llTypes);
+
+        if (llvmDIBuilder != nullptr) {
+            llvm::TrackingVH<llvm::MDNode> placeholderNode =
+                (llvm::MDNode *)x->getDebugInfo();
+            llvm::DIType placeholder(placeholderNode);
+            llvm::ArrayRef<IdentifierPtr> fieldNames = recordFieldNames(x);
+            vector<llvm::Value *> members;
+            size_t debugOffset = 0;
+            for (size_t i = 0; i < fieldNames.size(); ++i) {
+                if (x->hasVarField && i >= x->varFieldPosition) {
+                    if (i == x->varFieldPosition) {
+                        for (size_t j = 0; j < x->varFieldSize(); ++j) {
+                            llvm::SmallString<128> buf;
+                            llvm::raw_svector_ostream sout(buf);
+                            sout << fieldNames[i] << ".." << j;
+                            llvm::Type *memberLLT = llvmType(fieldTypes[i + j]);
                             size_t debugAlign = debugTypeAlignment(memberLLT);
                             size_t debugSize = debugTypeSize(memberLLT);
                             debugOffset = alignedUpTo(debugOffset, debugAlign);
@@ -1588,104 +1511,157 @@ namespace clay {
                             if (!fieldLocation.ok())
                                 fieldLocation = x->record->location;
                             unsigned fieldLine, fieldColumn;
-                            llvm::DIFile fieldFile = getDebugLineCol(fieldLocation, fieldLine, fieldColumn);
+                            llvm::DIFile fieldFile = getDebugLineCol(
+                                fieldLocation, fieldLine, fieldColumn);
                             members.push_back(llvmDIBuilder->createMemberType(
-                                placeholder,
-                                fieldNames[i]->str,
-                                fieldFile, // file
-                                fieldLine, // lineNo
-                                debugSize, // size
-                                debugAlign, // align
-                                debugOffset, // offset
-                                0, // flags
-                                llvmTypeDebugInfo(fieldTypes[i]) // type
-                            ));
+                                placeholder, sout.str(),
+                                fieldFile,                           // file
+                                fieldLine,                           // lineNo
+                                debugSize,                           // size
+                                debugAlign,                          // align
+                                debugOffset,                         // offset
+                                0,                                   // flags
+                                llvmTypeDebugInfo(fieldTypes[i + j]) // type
+                                ));
                             debugOffset += debugSize;
                         }
-                    }
+                    } else {
+                        size_t k = i + x->varFieldSize() - 1;
+                        llvm::Type *memberLLT = llvmType(fieldTypes[k]);
+                        size_t debugAlign = debugTypeAlignment(memberLLT);
+                        size_t debugSize = debugTypeSize(memberLLT);
+                        debugOffset = alignedUpTo(debugOffset, debugAlign);
 
-                    llvm::DIArray memberArray = llvmDIBuilder->getOrCreateArray(
-                        llvm::ArrayRef(members));
-
-                    unsigned line, column;
-                    llvm::DIFile file = getDebugLineCol(x->record->location, line, column);
-
-                    t->debugInfo = (llvm::MDNode *) llvmDIBuilder->createStructType(
-                        lookupModuleDebugInfo(x->record->env), // scope
-                        typeName(t),
-                        file, // file
-                        line, // lineNo
-                        debugTypeSize(t->llType),
-                        debugTypeAlignment(t->llType),
-                        0, // flags
-                        memberArray);
-                    llvm::DIType(placeholderNode).replaceAllUsesWith(t->getDebugInfo());
-                }
-                break;
-            }
-            case VARIANT_TYPE: {
-                VariantType *x = (VariantType *) t.ptr();
-                TypePtr reprType = variantReprType(x);
-                if (!reprType->llType)
-                    declareLLVMType(reprType);
-                if (!reprType->defined)
-                    defineLLVMType(reprType);
-
-                if (llvmDIBuilder != nullptr) {
-                    llvm::TrackingVH<llvm::MDNode> placeholderNode = (llvm::MDNode *) x->getDebugInfo();
-
-                    llvm::DIType(placeholderNode).replaceAllUsesWith(llvmTypeDebugInfo(reprType));
-                }
-                break;
-            }
-            case NEW_TYPE: {
-                NewType *x = (NewType *) t.ptr();
-                TypePtr reprType = newtypeReprType(x);
-                if (!reprType->llType)
-                    declareLLVMType(reprType);
-                if (!reprType->defined)
-                    defineLLVMType(reprType);
-
-                if (llvmDIBuilder != nullptr) {
-                    llvm::TrackingVH<llvm::MDNode> placeholderNode = (llvm::MDNode *) x->getDebugInfo();
-
-                    llvm::DIType(placeholderNode).replaceAllUsesWith(llvmTypeDebugInfo(reprType));
+                        Location fieldLocation = fieldNames[i]->location;
+                        if (!fieldLocation.ok())
+                            fieldLocation = x->record->location;
+                        unsigned fieldLine, fieldColumn;
+                        llvm::DIFile fieldFile = getDebugLineCol(
+                            fieldLocation, fieldLine, fieldColumn);
+                        members.push_back(llvmDIBuilder->createMemberType(
+                            placeholder, fieldNames[i]->str,
+                            fieldFile,                       // file
+                            fieldLine,                       // lineNo
+                            debugSize,                       // size
+                            debugAlign,                      // align
+                            debugOffset,                     // offset
+                            0,                               // flags
+                            llvmTypeDebugInfo(fieldTypes[k]) // type
+                            ));
+                        debugOffset += debugSize;
+                    }
+                } else {
+                    llvm::Type *memberLLT = llvmType(fieldTypes[i]);
+                    size_t debugAlign = debugTypeAlignment(memberLLT);
+                    size_t debugSize = debugTypeSize(memberLLT);
+                    debugOffset = alignedUpTo(debugOffset, debugAlign);
+
+                    Location fieldLocation = fieldNames[i]->location;
+                    if (!fieldLocation.ok())
+                        fieldLocation = x->record->location;
+                    unsigned fieldLine, fieldColumn;
+                    llvm::DIFile fieldFile =
+                        getDebugLineCol(fieldLocation, fieldLine, fieldColumn);
+                    members.push_back(llvmDIBuilder->createMemberType(
+                        placeholder, fieldNames[i]->str,
+                        fieldFile,                       // file
+                        fieldLine,                       // lineNo
+                        debugSize,                       // size
+                        debugAlign,                      // align
+                        debugOffset,                     // offset
+                        0,                               // flags
+                        llvmTypeDebugInfo(fieldTypes[i]) // type
+                        ));
+                    debugOffset += debugSize;
                 }
-                break;
             }
-            default:
-                assert(false);
+
+            llvm::DIArray memberArray =
+                llvmDIBuilder->getOrCreateArray(llvm::ArrayRef(members));
+
+            unsigned line, column;
+            llvm::DIFile file =
+                getDebugLineCol(x->record->location, line, column);
+
+            t->debugInfo = (llvm::MDNode *)llvmDIBuilder->createStructType(
+                lookupModuleDebugInfo(x->record->env), // scope
+                typeName(t),
+                file, // file
+                line, // lineNo
+                debugTypeSize(t->llType), debugTypeAlignment(t->llType),
+                0, // flags
+                memberArray);
+            llvm::DIType(placeholderNode).replaceAllUsesWith(t->getDebugInfo());
+        }
+        break;
+    }
+    case VARIANT_TYPE: {
+        VariantType *x = (VariantType *)t.ptr();
+        TypePtr reprType = variantReprType(x);
+        if (!reprType->llType)
+            declareLLVMType(reprType);
+        if (!reprType->defined)
+            defineLLVMType(reprType);
+
+        if (llvmDIBuilder != nullptr) {
+            llvm::TrackingVH<llvm::MDNode> placeholderNode =
+                (llvm::MDNode *)x->getDebugInfo();
+
+            llvm::DIType(placeholderNode)
+                .replaceAllUsesWith(llvmTypeDebugInfo(reprType));
         }
-        t->defined = true;
+        break;
+    }
+    case NEW_TYPE: {
+        NewType *x = (NewType *)t.ptr();
+        TypePtr reprType = newtypeReprType(x);
+        if (!reprType->llType)
+            declareLLVMType(reprType);
+        if (!reprType->defined)
+            defineLLVMType(reprType);
+
+        if (llvmDIBuilder != nullptr) {
+            llvm::TrackingVH<llvm::MDNode> placeholderNode =
+                (llvm::MDNode *)x->getDebugInfo();
+
+            llvm::DIType(placeholderNode)
+                .replaceAllUsesWith(llvmTypeDebugInfo(reprType));
+        }
+        break;
+    }
+    default:
+        assert(false);
     }
+    t->defined = true;
+}
 
-    //
-    // typeSize
-    //
+//
+// typeSize
+//
 
-    static void initTypeInfo(TypePtr t) {
-        if (!t->typeInfoInitialized) {
-            t->typeInfoInitialized = true;
-            llvm::Type *llt = llvmType(t);
-            t->typeSize = llTypeSize(llt);
-            t->typeAlignment = llTypeAlignment(llt);
-        }
+static void initTypeInfo(const TypePtr &t) {
+    if (!t->typeInfoInitialized) {
+        t->typeInfoInitialized = true;
+        llvm::Type *llt = llvmType(t);
+        t->typeSize = llTypeSize(llt);
+        t->typeAlignment = llTypeAlignment(llt);
     }
+}
 
-    size_t typeSize(TypePtr t) {
-        initTypeInfo(t.ptr());
-        return t->typeSize;
-    }
+size_t typeSize(TypePtr t) {
+    initTypeInfo(t.ptr());
+    return t->typeSize;
+}
 
-    size_t typeAlignment(TypePtr t) {
-        initTypeInfo(t.ptr());
-        return t->typeAlignment;
-    }
+size_t typeAlignment(TypePtr t) {
+    initTypeInfo(t.ptr());
+    return t->typeAlignment;
+}
 
-    string typeName(TypePtr type) {
-        llvm::SmallString<128> buf;
-        llvm::raw_svector_ostream os(buf);
-        typePrint(os, type);
-        return string(os.str());
-    }
+string typeName(TypePtr type) {
+    llvm::SmallString<128> buf;
+    llvm::raw_svector_ostream os(buf);
+    typePrint(os, type);
+    return string(os.str());
 }
+} // namespace clay
diff --git a/compiler/types.hpp b/compiler/types.hpp
index 06d01c11..f1fe623e 100644
--- a/compiler/types.hpp
+++ b/compiler/types.hpp
@@ -3,134 +3,135 @@
 #include "clay.hpp"
 
 namespace clay {
-    //
-    // types module
-    //
+//
+// types module
+//
 
-    extern TypePtr boolType;
-    extern TypePtr int8Type;
-    extern TypePtr int16Type;
-    extern TypePtr int32Type;
-    extern TypePtr int64Type;
-    extern TypePtr int128Type;
-    extern TypePtr uint8Type;
-    extern TypePtr uint16Type;
-    extern TypePtr uint32Type;
-    extern TypePtr uint64Type;
-    extern TypePtr uint128Type;
-    extern TypePtr float32Type;
-    extern TypePtr float64Type;
-    extern TypePtr float80Type;
-    extern TypePtr imag32Type;
-    extern TypePtr imag64Type;
-    extern TypePtr imag80Type;
-    extern TypePtr complex32Type;
-    extern TypePtr complex64Type;
-    extern TypePtr complex80Type;
+extern TypePtr boolType;
+extern TypePtr int8Type;
+extern TypePtr int16Type;
+extern TypePtr int32Type;
+extern TypePtr int64Type;
+extern TypePtr int128Type;
+extern TypePtr uint8Type;
+extern TypePtr uint16Type;
+extern TypePtr uint32Type;
+extern TypePtr uint64Type;
+extern TypePtr uint128Type;
+extern TypePtr float32Type;
+extern TypePtr float64Type;
+extern TypePtr float80Type;
+extern TypePtr imag32Type;
+extern TypePtr imag64Type;
+extern TypePtr imag80Type;
+extern TypePtr complex32Type;
+extern TypePtr complex64Type;
+extern TypePtr complex80Type;
 
-    // aliases
-    extern TypePtr cIntType;
-    extern TypePtr cSizeTType;
-    extern TypePtr cPtrDiffTType;
+// aliases
+extern TypePtr cIntType;
+extern TypePtr cSizeTType;
+extern TypePtr cPtrDiffTType;
 
-    void initTypes();
+void initTypes();
 
-    TypePtr integerType(unsigned bits, bool isSigned);
-    TypePtr intType(unsigned bits);
-    TypePtr uintType(unsigned bits);
-    TypePtr floatType(unsigned bits);
-    TypePtr imagType(unsigned bits);
-    TypePtr complexType(unsigned bits);
+TypePtr integerType(unsigned bits, bool isSigned);
+TypePtr intType(unsigned bits);
+TypePtr uintType(unsigned bits);
+TypePtr floatType(unsigned bits);
+TypePtr imagType(unsigned bits);
+TypePtr complexType(unsigned bits);
 
-    TypePtr pointerType(const TypePtr &pointeeType);
+TypePtr pointerType(const TypePtr &pointeeType);
 
-    TypePtr codePointerType(llvm::ArrayRef<TypePtr> argTypes,
-                            llvm::ArrayRef<uint8_t> returnIsRef,
-                            llvm::ArrayRef<TypePtr> returnTypes);
+TypePtr codePointerType(llvm::ArrayRef<TypePtr> argTypes,
+                        llvm::ArrayRef<uint8_t> returnIsRef,
+                        llvm::ArrayRef<TypePtr> returnTypes);
 
-    TypePtr cCodePointerType(CallingConv callingConv,
-                             llvm::ArrayRef<TypePtr> argTypes,
-                             bool hasVarArgs,
-                             const TypePtr &returnType);
+TypePtr cCodePointerType(CallingConv callingConv,
+                         llvm::ArrayRef<TypePtr> argTypes, bool hasVarArgs,
+                         const TypePtr &returnType);
 
-    TypePtr arrayType(const TypePtr &elementType, unsigned size);
+TypePtr arrayType(const TypePtr &elementType, unsigned size);
 
-    TypePtr vecType(const TypePtr &elementType, unsigned size);
+TypePtr vecType(const TypePtr &elementType, unsigned size);
 
-    TypePtr tupleType(llvm::ArrayRef<TypePtr> elementTypes);
-    TypePtr unionType(llvm::ArrayRef<TypePtr> memberTypes);
+TypePtr tupleType(llvm::ArrayRef<TypePtr> elementTypes);
+TypePtr unionType(llvm::ArrayRef<TypePtr> memberTypes);
 
-    TypePtr recordType(const RecordDeclPtr &record, llvm::ArrayRef<ObjectPtr> params);
+TypePtr recordType(const RecordDeclPtr &record,
+                   llvm::ArrayRef<ObjectPtr> params);
 
-    TypePtr variantType(const VariantDeclPtr &variant, llvm::ArrayRef<ObjectPtr> params);
+TypePtr variantType(const VariantDeclPtr &variant,
+                    llvm::ArrayRef<ObjectPtr> params);
 
-    TypePtr staticType(const ObjectPtr &obj);
+TypePtr staticType(const ObjectPtr &obj);
 
-    TypePtr enumType(const EnumDeclPtr &enumeration);
+TypePtr enumType(const EnumDeclPtr &enumeration);
 
-    TypePtr newType(const NewTypeDeclPtr &decl);
+TypePtr newType(const NewTypeDeclPtr &decl);
 
-    bool isPrimitiveType(TypePtr t);
-    bool isPrimitiveAggregateType(TypePtr t);
-    bool isPrimitiveAggregateTooLarge(TypePtr t);
-    bool isPointerOrCodePointerType(TypePtr t);
-    bool isStaticOrTupleOfStatics(TypePtr t);
+bool isPrimitiveType(TypePtr t);
+bool isPrimitiveAggregateType(TypePtr t);
+bool isPrimitiveAggregateTooLarge(TypePtr t);
+bool isPointerOrCodePointerType(TypePtr t);
+bool isStaticOrTupleOfStatics(TypePtr t);
 
-    void initializeRecordFields(const RecordTypePtr &t);
+void initializeRecordFields(const RecordTypePtr &t);
 
-    llvm::ArrayRef<IdentifierPtr> recordFieldNames(const RecordTypePtr &t);
+llvm::ArrayRef<IdentifierPtr> recordFieldNames(const RecordTypePtr &t);
 
-    llvm::ArrayRef<TypePtr> recordFieldTypes(const RecordTypePtr &t);
+llvm::ArrayRef<TypePtr> recordFieldTypes(const RecordTypePtr &t);
 
-    const llvm::StringMap<size_t> &recordFieldIndexMap(const RecordTypePtr &t);
+const llvm::StringMap<size_t> &recordFieldIndexMap(const RecordTypePtr &t);
 
-    llvm::ArrayRef<TypePtr> variantMemberTypes(const VariantTypePtr &t);
+llvm::ArrayRef<TypePtr> variantMemberTypes(const VariantTypePtr &t);
 
-    TypePtr variantReprType(const VariantTypePtr &t);
+TypePtr variantReprType(const VariantTypePtr &t);
 
-    unsigned dispatchTagCount(TypePtr t);
+unsigned dispatchTagCount(TypePtr t);
 
-    TypePtr newtypeReprType(const NewTypePtr &t);
+TypePtr newtypeReprType(const NewTypePtr &t);
 
-    void initializeEnumType(const EnumTypePtr &t);
+void initializeEnumType(const EnumTypePtr &t);
 
-    void initializeNewType(const NewTypePtr &t);
+void initializeNewType(const NewTypePtr &t);
 
-    const llvm::StructLayout *tupleTypeLayout(TupleType *t);
-    const llvm::StructLayout *complexTypeLayout(ComplexType *t);
-    const llvm::StructLayout *recordTypeLayout(RecordType *t);
+const llvm::StructLayout *tupleTypeLayout(TupleType *t);
+const llvm::StructLayout *complexTypeLayout(ComplexType *t);
+const llvm::StructLayout *recordTypeLayout(RecordType *t);
 
-    llvm::Type *llvmIntType(unsigned bits);
-    llvm::Type *llvmFloatType(unsigned bits);
-    llvm::PointerType *llvmPointerType(llvm::Type *llType);
+llvm::Type *llvmIntType(unsigned bits);
+llvm::Type *llvmFloatType(unsigned bits);
+llvm::PointerType *llvmPointerType(llvm::Type *llType);
 
-    llvm::PointerType *llvmPointerType(const TypePtr &t);
+llvm::PointerType *llvmPointerType(const TypePtr &t);
 
-    llvm::Type *llvmArrayType(llvm::Type *llType, unsigned size);
+llvm::Type *llvmArrayType(llvm::Type *llType, unsigned size);
 
-    llvm::Type *llvmArrayType(const TypePtr &type, unsigned size);
+llvm::Type *llvmArrayType(const TypePtr &type, unsigned size);
 
-    llvm::Type *llvmVoidType();
+llvm::Type *llvmVoidType();
 
-    llvm::Type *llvmType(const TypePtr &t);
+llvm::Type *llvmType(const TypePtr &t);
 
-    llvm::DIType *llvmTypeDebugInfo(const TypePtr &t);
+llvm::DIType *llvmTypeDebugInfo(const TypePtr &t);
 
-    llvm::DIType llvmVoidTypeDebugInfo();
+llvm::DIType llvmVoidTypeDebugInfo();
 
-    size_t typeSize(const TypePtr &t);
+size_t typeSize(const TypePtr &t);
 
-    size_t typeAlignment(const TypePtr &t);
+size_t typeAlignment(const TypePtr &t);
 
-    void typePrint(llvm::raw_ostream &out, TypePtr t);
+void typePrint(llvm::raw_ostream &out, TypePtr t);
 
-    llvm::StringRef typeName(const TypePtr &t);
+llvm::StringRef typeName(const TypePtr &t);
 
-    inline size_t alignedUpTo(const size_t offset, const size_t align) {
-        return (offset + align - 1) / align * align;
-    }
+inline size_t alignedUpTo(const size_t offset, const size_t align) {
+    return (offset + align - 1) / align * align;
+}
 
-    inline size_t alignedUpTo(const size_t offset, const TypePtr &type) {
-        return alignedUpTo(offset, typeAlignment(type));
-    }
+inline size_t alignedUpTo(const size_t offset, const TypePtr &type) {
+    return alignedUpTo(offset, typeAlignment(type));
 }
+} // namespace clay
diff --git a/compiler/ut.hpp b/compiler/ut.hpp
index bbb6cb11..47a0c3d9 100644
--- a/compiler/ut.hpp
+++ b/compiler/ut.hpp
@@ -3,33 +3,36 @@
 #include <stdexcept>
 
 namespace clay {
-    typedef void (*TestFunc)();
+typedef void (*TestFunc)();
 
-    void register_test(const char *name, TestFunc);
+void register_test(const char *name, TestFunc);
 
-#define CLAY_UNITTEST(NAME) \
-    void NAME ## _testImpl (); \
-    struct TestRegistrator_ ## NAME { \
-        TestRegistrator_ ## NAME () { \
-            ::clay::register_test(#NAME, &NAME ## _testImpl); \
-        } \
-    }; \
-    static TestRegistrator_ ## NAME testRegistrator_ ## NAME; \
-    void NAME ## _testImpl()
+#define CLAY_UNITTEST(NAME)                                                    \
+    void NAME##_testImpl();                                                    \
+    struct TestRegistrator_##NAME {                                            \
+        TestRegistrator_##NAME() {                                             \
+            ::clay::register_test(#NAME, &NAME##_testImpl);                    \
+        }                                                                      \
+    };                                                                         \
+    static TestRegistrator_##NAME testRegistrator_##NAME;                      \
+    void NAME##_testImpl()
 
-    struct AssertionError  : std::runtime_error {
-        AssertionError() : std::runtime_error("AssertionError") {}
-    };
+struct AssertionError : std::runtime_error {
+    AssertionError() : std::runtime_error("AssertionError") {}
+};
 
-#define UT_FAIL() do { \
-        printf("failure in %s at %s:%d\n", __func__, __FILE__, __LINE__); \
-        throw AssertionError(); \
+#define UT_FAIL()                                                              \
+    do {                                                                       \
+        printf("failure in %s at %s:%d\n", __func__, __FILE__, __LINE__);      \
+        throw AssertionError();                                                \
     } while (0)
 
-#define UT_ASSERT(COND) do { \
-        if (!(COND)) { \
-            printf("condition %s failed in %s at %s:%d\n", #COND, __func__, __FILE__, __LINE__); \
-            throw AssertionError(); \
-        } \
+#define UT_ASSERT(COND)                                                        \
+    do {                                                                       \
+        if (!(COND)) {                                                         \
+            printf("condition %s failed in %s at %s:%d\n", #COND, __func__,    \
+                   __FILE__, __LINE__);                                        \
+            throw AssertionError();                                            \
+        }                                                                      \
     } while (0)
-}
+} // namespace clay
diff --git a/compiler/ut_main.cpp b/compiler/ut_main.cpp
index f91ae7aa..de6a3937 100644
--- a/compiler/ut_main.cpp
+++ b/compiler/ut_main.cpp
@@ -1,40 +1,40 @@
 #include <iostream>
 #include <vector>
 
-#include "ut.hpp"
 #include "parachute.hpp"
+#include "ut.hpp"
 
 namespace clay {
-    struct Test {
-        const char *name;
-        TestFunc func;
-    };
+struct Test {
+    const char *name;
+    TestFunc func;
+};
 
-    static std::vector<Test> *tests;
+static std::vector<Test> *tests;
 
-    void register_test(const char *name, const TestFunc func) {
-        if (tests == nullptr) {
-            tests = new std::vector<Test>;
-        }
-        tests->emplace_back();
-        tests->back().name = name;
-        tests->back().func = func;
+void register_test(const char *name, const TestFunc func) {
+    if (tests == nullptr) {
+        tests = new std::vector<Test>;
     }
+    tests->emplace_back();
+    tests->back().name = name;
+    tests->back().func = func;
+}
 
-    int real_main(int argc, char **argv, char const *const *envp) {
-        for (const auto test : *tests) {
-            std::cout << test.name << "...\n";
-            try {
-                test.func();
+int real_main(int argc, char **argv, char const *const *envp) {
+    for (const auto test : *tests) {
+        std::cout << test.name << "...\n";
+        try {
+            test.func();
 
-                std::cout << test.name << " OK\n";
-            } catch (const AssertionError &) {
-                std::cout << test.name << " FAILED\n";
-            }
+            std::cout << test.name << " OK\n";
+        } catch (const AssertionError &) {
+            std::cout << test.name << " FAILED\n";
         }
-        return 0;
     }
+    return 0;
 }
+} // namespace clay
 
 int main(const int argc, char **argv, char const *const *envp) {
     return clay::parachute(&clay::real_main, argc, argv, envp);