Lots of cleanups, including expanded use of (... compiles to "text

literal") shorthand, deprecating Lua value, and more use of Lua "..."
with text interpolations.

22 files changed, 282 insertions, 309 deletions

diff --git a/code_obj.lua b/code_obj.lua
index 124064f..4fd01d6 100644
--- a/code_obj.lua
+++ b/code_obj.lua
@@ -499,6 +499,7 @@ do
   NomsuCode = _class_0
 end
 Code.__base.add_1_joined_with = assert(Code.__base.concat_append)
+Code.__base.add = assert(Code.__base.append)
 return {
   Code = Code,
   NomsuCode = NomsuCode,
diff --git a/code_obj.moon b/code_obj.moon
index 39a59c6..fcf2217 100644
--- a/code_obj.moon
+++ b/code_obj.moon
@@ -255,5 +255,6 @@ class NomsuCode extends Code
     __len: Code.__len
 
 Code.__base.add_1_joined_with = assert Code.__base.concat_append
+Code.__base.add = assert Code.__base.append
 
 return {:Code, :NomsuCode, :LuaCode, :Source}
diff --git a/core/collections.nom b/core/collections.nom
index 684f3f6..9a7dbe4 100644
--- a/core/collections.nom
+++ b/core/collections.nom
@@ -151,26 +151,25 @@ test:
     %t = {}
     set %t 's metatable to {__tostring:[%] -> "XXX"}
     assume ("\%t" == "XXX")
-(set %dict 's metatable to %metatable) compiles to (..)
-    Lua "setmetatable(\(%dict as lua expr), \(%metatable as lua expr));"
+(set %dict 's metatable to %metatable) compiles to "\
+    ..setmetatable(\(%dict as lua expr), \(%metatable as lua expr));"
 
-[% 's metatable, % 'metatable] all compile to (..)
-    Lua value "getmetatable(\(% as lua expr))"
+[% 's metatable, % 'metatable] all compile to "\
+    ..getmetatable(\(% as lua expr))"
 
 test:
     assume (({} with fallback % -> (% + 1)).10 == 11)
-(%dict with fallback %key -> %value) compiles to (..)
-    Lua value "\
-        ..(function(d)
-            local mt = {}
-            for k,v in pairs(getmetatable(d) or {}) do mt[k] = v end
-            mt.__index = function(self, \(%key as lua expr))
-                local value = \(%value as lua expr)
-                self[\(%key as lua expr)] = value
-                return value
-            end
-            return setmetatable(d, mt)
-        end)(\(%dict as lua expr))"
+(%dict with fallback %key -> %value) compiles to "\
+    ..(function(d)
+        local mt = {}
+        for k,v in pairs(getmetatable(d) or {}) do mt[k] = v end
+        mt.__index = function(self, \(%key as lua expr))
+            local value = \(%value as lua expr)
+            self[\(%key as lua expr)] = value
+            return value
+        end
+        return setmetatable(d, mt)
+    end)(\(%dict as lua expr))"
 
 # Sorting
 test:
@@ -182,7 +181,7 @@ test:
     %keys = {1:999, 2:0, 3:50}
     sort %x by % = %keys.%
     assume (%x == [2, 3, 1])
-(sort %items) compiles to (Lua "table.sort(\(%items as lua expr));")
+(sort %items) compiles to "table.sort(\(%items as lua expr));"
 [..]
     sort %items by %item = %key_expr, sort %items by %item -> %key_expr
 ..all parse as (..)
diff --git a/core/control_flow.nom b/core/control_flow.nom
index f7a8423..236c9a8 100644
--- a/core/control_flow.nom
+++ b/core/control_flow.nom
@@ -12,19 +12,16 @@ use "core/errors.nom"
 
 # No-Op
 test: do nothing
-(do nothing) compiles to (Lua "")
+(do nothing) compiles to ""
 
 # Conditionals
 test:
     if (no):
         barf "conditional fail"
-(if %condition %if_body) compiles to:
-    %lua = (Lua "if ")
-    %lua::append (%condition as lua expr)
-    %lua::append " then\n    "
-    %lua::append (%if_body as lua statements)
-    %lua::append "\nend"
-    return %lua
+(if %condition %if_body) compiles to "\
+    ..if \(%condition as lua expr) then
+        \(%if_body as lua statements)
+    end"
 
 test:
     unless (yes):
@@ -32,15 +29,12 @@ test:
 (unless %condition %unless_body) parses as (if (not %condition) %unless_body)
 [..]
     if %condition %if_body else %else_body, unless %condition %else_body else %if_body
-..all compile to:
-    %lua = (Lua "if ")
-    %lua::append (%condition as lua expr)
-    %lua::append " then\n    "
-    %lua::append (%if_body as lua statements)
-    %lua::append "\nelse\n    "
-    %lua::append (%else_body as lua statements)
-    %lua::append "\nend"
-    return %lua
+..all compile to "\
+    ..if \(%condition as lua expr) then
+        \(%if_body as lua statements)
+    else
+        \(%else_body as lua statements)
+    end"
 
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
@@ -60,7 +54,7 @@ test:
         equivalent of a conditional expression: (cond and if_true or if_false)
     if {Text:yes, List:yes, Dict:yes, Number:yes}.(%when_true_expr.type):
         return (..)
-            Lua value "\
+            Lua "\
                 ..(\(%condition as lua expr) and \(%when_true_expr as lua expr) or \(..)
                     %when_false_expr as lua expr
                 ..)"
@@ -69,7 +63,7 @@ test:
             doesn't have a proper ternary operator!)
             To see why this is necessary consider: (random()<.5 and false or 99)
         return (..)
-            Lua value "\
+            Lua "\
                 ..((function()
                     if \(%condition as lua expr) then
                         return \(%when_true_expr as lua expr)
@@ -91,17 +85,15 @@ test:
     %i -= 1
     unless (%i == 0): go to (Loop)
     assume (%i == 0)
-[=== %label ===, --- %label ---, *** %label ***] all compile to (..)
-    Lua "\
-        ..::label_\(..)
-            (%label.stub if (%label.type == "Action") else %label) as lua identifier
-        ..::"
-
-(go to %label) compiles to (..)
-    Lua "\
-        ..goto label_\(..)
-            (%label.stub if (%label.type == "Action") else %label) as lua identifier
-        .."
+[=== %label ===, --- %label ---, *** %label ***] all compile to "\
+    ..::label_\(..)
+        (%label.stub if (%label.type == "Action") else %label) as lua identifier
+    ..::"
+
+(go to %label) compiles to "\
+    ..goto label_\(..)
+        (%label.stub if (%label.type == "Action") else %label) as lua identifier
+    .."
 
 # Basic loop control
 (stop %var) compiles to:
@@ -114,10 +106,10 @@ test:
         return (..)
             Lua "goto continue_\((%var.stub if (%var.type == "action") else %var) as lua identifier)"
     ..else: return (Lua "goto continue")
-[===stop %var ===, ---stop %var ---, ***stop %var ***] all compile to (..)
-    Lua "::stop_\((%var.stub if (%var.type == "action") else %var) as lua identifier)::"
-[===next %var ===, ---next %var ---, ***next %var ***] all compile to (..)
-    Lua "::continue_\((%var.stub if (%var.type == "action") else %var) as lua identifier)::"
+[===stop %var ===, ---stop %var ---, ***stop %var ***] all compile to "\
+    ..::stop_\((%var.stub if (%var.type == "action") else %var) as lua identifier)::"
+[===next %var ===, ---next %var ---, ***next %var ***] all compile to "\
+    ..::continue_\((%var.stub if (%var.type == "action") else %var) as lua identifier)::"
 
 # While loops
 test:
@@ -139,8 +131,8 @@ test:
         barf "Failed to 'do next repeat'"
     
     assume (%x == 30)
-(do next repeat) compiles to (Lua "goto continue_repeat")
-(stop repeating) compiles to (Lua "goto stop_repeat")
+(do next repeat) compiles to "goto continue_repeat"
+(stop repeating) compiles to "goto stop_repeat"
 (repeat while %condition %body) compiles to:
     %lua = (..)
         Lua "\
@@ -155,8 +147,7 @@ test:
     if (%body has subtree \(stop repeating)):
         %inner_lua = %lua
         %lua = (Lua "do -- scope of 'stop repeating' label\n    ")
-        %lua::append %inner_lua
-        %lua::append "\
+        %lua::append %inner_lua "\
             ..
                 ::stop_repeat::
             end -- end of 'stop repeating' label scope"
@@ -183,8 +174,7 @@ test:
     if (%body has subtree \(stop repeating)):
         %inner_lua = %lua
         %lua = (Lua "do -- scope of 'stop repeating' label\n    ")
-        %lua::append %inner_lua
-        %lua::append "\
+        %lua::append %inner_lua "\
             ..
                 ::stop_repeat::
             end -- end of 'stop repeating' label scope"
@@ -226,20 +216,17 @@ test:
                 %step as lua expr
             .. do"
     
-    %lua::append "\n    "
-    %lua::append (%body as lua statements)
+    %lua::append "\n    " (%body as lua statements)
     if (%body has subtree \(do next)):
         %lua::append "\n    ::continue::"
     if (%body has subtree \(do next %var)):
-        %lua::append "\n    "
-        %lua::append (what (===next %var ===) compiles to)
+        %lua::append "\n    " (what (===next %var ===) compiles to)
     
     %lua::append "\nend --numeric for-loop"
     if (%body has subtree \(stop %var)):
         %inner_lua = %lua
         %lua = (Lua "do -- scope for stopping for-loop\n    ")
-        %lua::append %inner_lua
-        %lua::append "\n    "
+        %lua::append %inner_lua "\n    "
         %lua::append (what (===stop %var ===) compiles to)
         %lua::append "\nend -- end of scope for stopping for-loop"
     
@@ -273,15 +260,13 @@ test:
     if (%body has subtree \(do next)):
         %lua::append "\n    ::continue::"
     if (%body has subtree \(do next %var)):
-        %lua::append "\n    "
-        %lua::append (what (===next %var ===) compiles to)
+        %lua::append "\n    " (what (===next %var ===) compiles to)
     
     %lua::append "\nend --foreach-loop"
     if (%body has subtree \(stop %var)):
         %inner_lua = %lua
         %lua = (Lua "do -- scope for stopping for-loop\n    ")
-        %lua::append %inner_lua
-        %lua::append "\n    "
+        %lua::append %inner_lua "\n    "
         %lua::append (what (===stop %var ===) compiles to)
         %lua::append "\nend -- end of scope for stopping for-loop"
     
@@ -296,15 +281,13 @@ test:
     if (%body has subtree \(do next)):
         %lua::append "\n    ::continue::"
     if (%body has subtree \(do next %var)):
-        %lua::append "\n    "
-        %lua::append (what (===next %var ===) compiles to)
+        %lua::append "\n    " (what (===next %var ===) compiles to)
     
     %lua::append "\nend --foreach-loop"
     if (%body has subtree \(stop %var)):
         %inner_lua = %lua
         %lua = (Lua "do -- scope for stopping for-loop\n    ")
-        %lua::append %inner_lua
-        %lua::append "\n    "
+        %lua::append %inner_lua "\n    "
         %lua::append (what (===stop %var ===) compiles to)
         %lua::append "\nend -- end of scope for stopping for-loop"
     
@@ -335,34 +318,27 @@ test:
                 %iterable as lua expr
             ..) do"
     
-    %lua::append "\n    "
-    %lua::append (%body as lua statements)
+    %lua::append "\n    " (%body as lua statements)
     if (%body has subtree \(do next)):
         %lua::append "\n    ::continue::"
     if (%body has subtree \(do next %key)):
-        %lua::append "\n    "
-        %lua::append (what (===next %key ===) compiles to)
+        %lua::append "\n    " (what (===next %key ===) compiles to)
     
     if (%body has subtree \(do next %value)):
-        %lua::append "\n    "
-        %lua::append (what (===next %value ===) compiles to)
+        %lua::append "\n    " (what (===next %value ===) compiles to)
     
     %lua::append "\nend --foreach-loop"
     %stop_labels = (Lua "")
     if (%body has subtree \(stop %key)):
-        %stop_labels::append "\n"
-        %stop_labels::append (what (===stop %key ===) compiles to)
+        %stop_labels::append "\n" (what (===stop %key ===) compiles to)
     
     if (%body has subtree \(stop %value)):
-        %stop_labels::append "\n"
-        %stop_labels::append (what (===stop %value ===) compiles to)
+        %stop_labels::append "\n" (what (===stop %value ===) compiles to)
     
     if ((size of "\%stop_labels") > 0):
         %inner_lua = %lua
         %lua = (Lua "do -- scope for stopping for % = % loop\n    ")
-        %lua::append %inner_lua
-        %lua::append %stop_labels
-        %lua::append "\nend"
+        %lua::append %inner_lua %stop_labels "\nend"
     
     return %lua
 
@@ -411,19 +387,16 @@ test:
                     ..need a conditional block around it. Otherwise, make sure the 'else' \
                     ..block comes last."
             
-            %code::append "\nelse\n    "
-            %code::append (%action as lua statements)
+            %code::append "\nelse\n    " (%action as lua statements)
             %else_allowed = (no)
         ..else:
-            %code::append %clause
-            %code::append " "
+            %code::append %clause " "
             for %i in 1 to ((size of %line) - 1):
                 if (%i > 1):
                     %code::append " or "
                 %code::append (%line.%i as lua expr)
             
-            %code::append " then\n    "
-            %code::append (%action as lua statements)
+            %code::append " then\n    " (%action as lua statements)
             %clause = "\nelseif"
     
     if ((size of "\%code") == 0):
@@ -472,42 +445,34 @@ test:
                     ..need a conditional block around it. Otherwise, make sure the 'else' \
                     ..block comes last."
             
-            %code::append "\nelse\n    "
-            %code::append (%action as lua statements)
+            %code::append "\nelse\n    " (%action as lua statements)
             %else_allowed = (no)
         ..else:
-            %code::append %clause
-            %code::append " "
+            %code::append %clause " "
             for %i in 1 to ((size of %line) - 1):
                 if (%i > 1):
                     %code::append " or "
-                %code::append "\(mangle "branch value") == "
-                %code::append (%line.%i as lua expr)
+                %code::append "\(mangle "branch value") == " (%line.%i as lua expr)
             
-            %code::append " then\n    "
-            %code::append (%action as lua statements)
+            %code::append " then\n    " (%action as lua statements)
             %clause = "\nelseif"
     
     if ((size of "\%code") == 0):
         compile error at %body "'if' block has an empty body."
         ..hint "This means nothing would happen, so the 'if' block should be deleted."
     %code::append "\nend --when"
-    %lua = (..)
+    return (..)
         Lua "\
             ..do --if % is...
-                local \(mangle "branch value") = "
-    %lua::append (%branch_value as lua expr)
-    %lua::append "\n    "
-    %lua::append %code
-    %lua::append "\nend --if % is..."
-    return %lua
+                local \(mangle "branch value") = \(%branch_value as lua expr)
+                \%code
+            end -- if % is..."
 
 # Do/finally
-(do %action) compiles to:
-    %lua = (Lua "do\n    ")
-    %lua::append (%action as lua statements)
-    %lua::append "\nend -- do"
-    return %lua
+(do %action) compiles to "\
+    ..do
+        \(%action as lua statements)
+    end -- do"
 
 test:
     %d = {}
@@ -519,29 +484,24 @@ test:
     assume (%d.x == "good")
 (do %action then always %final_action) compiles to:
     define mangler
-    %lua = (..)
+    return (..)
         Lua "\
             ..do
                 local \(mangle "fell_through") = false
-                local \(mangle "ok"), \(mangle "ret") = pcall(function()"
-    %lua::append "\n        "
-    %lua::append (%action as lua statements)
-    %lua::append "\
-        ..        \(mangle "fell_through") = true
-            end)"
-    %lua::append "\n    "
-    %lua::append (%final_action as lua statements)
-    %lua::append "\
-        ..    if not \(mangle "ok") then error(ret, 0) end
-            if not \(mangle "fell_through") then return ret end
-        end"
-    return %lua
+                local \(mangle "ok"), \(mangle "ret") = pcall(function()
+                    \(%action as lua statements)
+                    \(mangle "fell_through") = true
+                end)
+                \(%final_action as lua statements)
+                if not \(mangle "ok") then error(ret, 0) end
+                if not \(mangle "fell_through") then return ret end
+            end"
 
 test:
     assume ((result of (: return 99)) == 99)
 
 # Inline thunk:
-(result of %body) compiles to (Lua value "\(what ([] -> %body) compiles to)()")
+(result of %body) compiles to "\(what ([] -> %body) compiles to)()"
 
 test:
     %t = [1, [2, [[3], 4], 5, [[[6]]]]]
@@ -564,9 +524,8 @@ test:
                 ..do
                     local \(mangle "stack \(%var.1)") = List{\(%structure as lua expr)}
                     while #\(mangle "stack \(%var.1)") > 0 do
-                        \(%var as lua expr) = table.remove(\(mangle "stack \(%var.1)"), 1)"
-        %lua::append "\n        "
-        %lua::append (%body as lua statements)
+                        \(%var as lua expr) = table.remove(\(mangle "stack \(%var.1)"), 1)
+                        \(%body as lua statements)"
         if (%body has subtree \(do next)):
             %lua::append "\n        ::continue::"
         if (%body has subtree \(do next %var)):
diff --git a/core/coroutines.nom b/core/coroutines.nom
index f03cfc8..782c20e 100644
--- a/core/coroutines.nom
+++ b/core/coroutines.nom
@@ -16,16 +16,13 @@ test:
     
     for % in coroutine %co: %nums::add %
     assume (%nums == [4, 5, 6, 6, 6]) or barf "Coroutine iteration failed"
-[coroutine %body, generator %body] all compile to (..)
-    Lua value "\
-        ..(function()
-            \(%body as lua statements)
-        end)"
+[coroutine %body, generator %body] all compile to "\
+    ..(function()
+        \(%body as lua statements)
+    end)"
 
-(->) compiles to (Lua value "coroutine.yield(true)")
-(-> %) compiles to (Lua value "coroutine.yield(true, \(% as lua expr))")
-(for % in coroutine %co %body) compiles to (..)
-    Lua "\
-        ..for junk,\(% as lua expr) in coroutine.wrap(\(%co as lua expr)) do
-            \(%body as lua statements)
-        end"
+(-> %) compiles to "coroutine.yield(true, \((% as lua expr) if % else "nil"))"
+(for % in coroutine %co %body) compiles to "\
+    ..for _junk,\(% as lua expr) in coroutine.wrap(\(%co as lua expr)) do
+        \(%body as lua statements)
+    end"
diff --git a/core/errors.nom b/core/errors.nom
index 74c0a54..b2222ee 100644
--- a/core/errors.nom
+++ b/core/errors.nom
@@ -6,11 +6,11 @@ use "core/metaprogramming.nom"
 
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-(barf %msg) compiles to (Lua "error(\(=lua "\%msg and \(%msg as lua expr) or 'nil'"), 0);")
-(compile error at %tree %msg) compiles to (..)
-    Lua "nomsu:compile_error(\(%tree as lua expr), \(%msg as lua expr))"
-(compile error at %tree %msg hint %hint) compiles to (..)
-    Lua "nomsu:compile_error(\(%tree as lua expr), \(%msg as lua expr), \(%hint as lua expr))"
+(barf %msg) compiles to "error(\(=lua "\%msg and \(%msg as lua expr) or 'nil'"), 0);"
+(compile error at %tree %msg) compiles to "\
+    ..nomsu:compile_error(\(%tree as lua expr), \(%msg as lua expr))"
+(compile error at %tree %msg hint %hint) compiles to "\
+    ..nomsu:compile_error(\(%tree as lua expr), \(%msg as lua expr), \(%hint as lua expr))"
 
 (assume %condition) compiles to:
     lua> "\
@@ -36,11 +36,10 @@ use "core/metaprogramming.nom"
                 end
             end"
 
-(assume %condition or barf %message) compiles to (..)
-    Lua "\
-        ..if not \(%condition as lua expr) then
-            error(\(%message as lua expr), 0)
-        end"
+(assume %condition or barf %message) compiles to "\
+    ..if not \(%condition as lua expr) then
+        error(\(%message as lua expr), 0)
+    end"
 
 test:
     try (barf) and if it succeeds: barf "try failed."
@@ -59,29 +58,28 @@ test:
 [..]
     try %action and if it succeeds %success or if it barfs %msg %fallback
     try %action and if it barfs %msg %fallback or if it succeeds %success
-..all compile to (..)
-    Lua "\
-        ..do
-            local fell_through = false
-            local err, erred = nil, false
-            local ok, ret = xpcall(function()
-                \(%action as lua statements)
-                fell_through = true
-            end, function(\(=lua "\%fallback and \(%msg as lua expr) or ''"))
-                local ok, ret = pcall(function()
-                    \((=lua "\%fallback or \%msg") as lua statements)
-                end)
-                if not ok then err, erred = ret, true end
+..all compile to "\
+    ..do
+        local fell_through = false
+        local err, erred = nil, false
+        local ok, ret = xpcall(function()
+            \(%action as lua statements)
+            fell_through = true
+        end, function(\(=lua "\%fallback and \(%msg as lua expr) or ''"))
+            local ok, ret = pcall(function()
+                \((=lua "\%fallback or \%msg") as lua statements)
             end)
-            if ok then
-                \(%success as lua statements)
-                if not fell_through then
-                    return ret
-                end
-            elseif erred then
-                error(err, 0)
+            if not ok then err, erred = ret, true end
+        end)
+        if ok then
+            \(%success as lua statements)
+            if not fell_through then
+                return ret
             end
-        end"
+        elseif erred then
+            error(err, 0)
+        end
+    end"
 
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
diff --git a/core/io.nom b/core/io.nom
index e12e4eb..edeeab4 100644
--- a/core/io.nom
+++ b/core/io.nom
@@ -17,9 +17,9 @@ use "core/metaprogramming.nom"
 (ask %prompt) compiles to:
     lua> "\
         ..if \%prompt.type == "Text" then
-            return LuaCode.Value(tree.source, "(io.write(", \(%prompt as lua expr), ") and io.read())");
+            return LuaCode(tree.source, "(io.write(", \(%prompt as lua expr), ") and io.read())");
         else
-            return LuaCode.Value(tree.source, "(io.write(tostring(", \(..)
+            return LuaCode(tree.source, "(io.write(tostring(", \(..)
             %prompt as lua expr
         .., ")) and io.read())");
         end"
diff --git a/core/math.nom b/core/math.nom
index 36d1d90..1c7306e 100644
--- a/core/math.nom
+++ b/core/math.nom
@@ -16,18 +16,18 @@ test:
         ..math constants failed"
     %nan = (NaN)
     assume (%nan != %nan) or barf "NaN failed"
-[infinity, inf] all compile to (Lua value "math.huge")
-[not a number, NaN, nan] all compile to (Lua value "(0/0)")
-[pi, Pi, PI] all compile to (Lua value "math.pi")
-[tau, Tau, TAU] all compile to (Lua value "(2*math.pi)")
-(golden ratio) compiles to (Lua value "((1+math.sqrt(5))/2)")
-(e) compiles to (Lua value "math.exp(1)")
+[infinity, inf] all compile to "math.huge"
+[not a number, NaN, nan] all compile to "(0/0)"
+[pi, Pi, PI] all compile to "math.pi"
+[tau, Tau, TAU] all compile to "(2*math.pi)"
+(golden ratio) compiles to "((1+math.sqrt(5))/2)"
+(e) compiles to "math.exp(1)"
 
 # Functions:
 test:
     assume (("5" as a number) == 5)
-[% as a number, % as number] all compile to (..)
-    Lua value "tonumber(\(% as lua expr))"
+((% as a number)'s meaning) = ((tonumber %)'s meaning)
+((% as number)'s meaning) = ((tonumber %)'s meaning)
 
 test:
     assume (..)
@@ -37,40 +37,40 @@ test:
             hyperbolic tangent 5, e^ 5, ln 5, log base 2 of 5, floor 5, ceiling 5, round 5
     ..or barf "math functions failed"
 [absolute value %, | % |, abs %] all compile to (..)
-    Lua value "math.abs(\(% as lua expr))"
+    "math.abs(\(% as lua expr))"
 
 [square root %, square root of %, √ %, sqrt %] all compile to (..)
-    Lua value "math.sqrt(\(% as lua expr))"
-
-[sine %, sin %] all compile to (Lua value "math.sin(\(% as lua expr))")
-[cosine %, cos %] all compile to (Lua value "math.cos(\(% as lua expr))")
-[tangent %, tan %] all compile to (Lua value "math.tan(\(% as lua expr))")
-[arc sine %, asin %] all compile to (Lua value "math.asin(\(% as lua expr))")
-[arc cosine %, acos %] all compile to (Lua value "math.acos(\(% as lua expr))")
-[arc tangent %, atan %] all compile to (Lua value "math.atan(\(% as lua expr))")
+    "math.sqrt(\(% as lua expr))"
+
+[sine %, sin %] all compile to "math.sin(\(% as lua expr))"
+[cosine %, cos %] all compile to "math.cos(\(% as lua expr))"
+[tangent %, tan %] all compile to "math.tan(\(% as lua expr))"
+[arc sine %, asin %] all compile to "math.asin(\(% as lua expr))"
+[arc cosine %, acos %] all compile to "math.acos(\(% as lua expr))"
+[arc tangent %, atan %] all compile to "math.atan(\(% as lua expr))"
 [arc tangent %y / %x, atan2 %y %x] all compile to (..)
-    Lua value "math.atan2(\(%y as lua expr), \(%x as lua expr))"
+    "math.atan2(\(%y as lua expr), \(%x as lua expr))"
 
 [hyperbolic sine %, sinh %] all compile to (..)
-    Lua value "math.sinh(\(% as lua expr))"
+    "math.sinh(\(% as lua expr))"
 
 [hyperbolic cosine %, cosh %] all compile to (..)
-    Lua value "math.cosh(\(% as lua expr))"
+    "math.cosh(\(% as lua expr))"
 
 [hyperbolic tangent %, tanh %] all compile to (..)
-    Lua value "math.tanh(\(% as lua expr))"
+    "math.tanh(\(% as lua expr))"
 
-[e^ %, exp %] all compile to (Lua value "math.exp(\(% as lua expr))")
+[e^ %, exp %] all compile to "math.exp(\(% as lua expr))"
 [natural log %, ln %, log %] all compile to (..)
-    Lua value "math.log(\(% as lua expr))"
+    "math.log(\(% as lua expr))"
 
 [log % base %base, log base %base of %] all compile to (..)
-    Lua value "math.log(\(% as lua expr), \(%base as lua expr))"
+    "math.log(\(% as lua expr), \(%base as lua expr))"
 
-(floor %) compiles to (Lua value "math.floor(\(% as lua expr))")
-[ceiling %, ceil %] all compile to (Lua value "math.ceil(\(% as lua expr))")
+(floor %) compiles to "math.floor(\(% as lua expr))"
+[ceiling %, ceil %] all compile to "math.ceil(\(% as lua expr))"
 [round %, % rounded] all compile to (..)
-    Lua value "math.floor(\(% as lua expr) + .5)"
+    "math.floor(\(% as lua expr) + .5)"
 
 test:
     assume ((463 to the nearest 100) == 500) or barf "rounding failed"
@@ -86,8 +86,11 @@ externally [all of %items, all %items] all mean:
 [all of %items, all %items] all compile to:
     unless (%items.type is "List"):
         return %tree
-    %clauses = (((% as lua expr)::text) for % in %items)
-    return (Lua value "(\(%clauses::joined with " and "))")
+    if ((size of %items) == 0): return (Lua "true")
+    %lua = (Lua "(")
+    %lua::add ((% as lua expr) for % in %items) joined with " and "
+    %lua::append ")"
+    return %lua
 [not all of %items, not all %items] all parse as (not (all of %items))
 
 externally [any of %items, any %items] all mean:
@@ -97,8 +100,11 @@ externally [any of %items, any %items] all mean:
 [any of %items, any %items] all compile to:
     unless (%items.type is "List"):
         return %tree
-    %clauses = (((% as lua expr)::text) for % in %items)
-    return (Lua value "(\(%clauses::joined with " or "))")
+    if ((size of %items) == 0): return (Lua "false")
+    %lua = (Lua "(")
+    %lua::add ((% as lua expr) for % in %items) joined with " or "
+    %lua::append ")"
+    return %lua
 [none of %items, none %items] all parse as (not (any of %items))
 
 # Sum/product
@@ -109,8 +115,11 @@ externally [sum of %items, sum %items] all mean:
 [sum of %items, sum %items] all compile to:
     unless (%items.type is "List"):
         return %tree
-    %clauses = (((% as lua expr)::text) for % in %items)
-    return (Lua value "(\(%clauses::joined with " + "))")
+    if ((size of %items) == 0): return (Lua "0")
+    %lua = (Lua "(")
+    %lua::add ((% as lua expr) for % in %items) joined with " + "
+    %lua::append ")"
+    return %lua
 
 externally [product of %items, product %items] all mean:
     %prod = 1
@@ -119,8 +128,11 @@ externally [product of %items, product %items] all mean:
 [product of %items, product %items] all compile to:
     unless (%items.type is "List"):
         return %tree
-    %clauses = (((% as lua expr)::text) for % in %items)
-    return (Lua value "(\(%clauses::joined with " * "))")
+    if ((size of %items) == 0): return (Lua "1")
+    %lua = (Lua "(")
+    %lua::add ((% as lua expr) for % in %items) joined with " * "
+    %lua::append ")"
+    return %lua
 
 externally [avg of %items, average of %items] all mean (..)
     (sum of %items) / (size of %items)
@@ -212,12 +224,12 @@ externally (seed random with %) means:
         for i=1,20 do math.random(); end"
 
 (seed random) parses as (seed random with (=lua "os.time()"))
-[random number, random, rand] all compile to (Lua value "math.random()")
+[random number, random, rand] all compile to "math.random()"
 [random int %n, random integer %n, randint %n] all compile to (..)
-    Lua value "math.random(\(%n as lua expr))"
+    "math.random(\(%n as lua expr))"
 
 [random from %low to %high, random number from %low to %high, rand %low %high] all \
-..compile to (Lua value "math.random(\(%low as lua expr), \(%high as lua expr))")
+..compile to "math.random(\(%low as lua expr), \(%high as lua expr))"
 
 externally [..]
     random choice from %elements, random choice %elements, random %elements
diff --git a/core/metaprogramming.nom b/core/metaprogramming.nom
index be7450a..2ae8b1b 100644
--- a/core/metaprogramming.nom
+++ b/core/metaprogramming.nom
@@ -71,9 +71,8 @@ lua> "\
         if \%body.type == "Text" then
             \%body = SyntaxTree{source=\%body.source, type="Action", "Lua", \%body}
         end
-        local lua = LuaCode(tree.source, "compile.action[", \%action.stub:as_lua(),
+        return LuaCode(tree.source, "compile.action[", \%action.stub:as_lua(),
             "] = ", \(what (%args -> %body) compiles to))
-        return lua
     end"
 
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -332,7 +331,7 @@ test:
                 ..one
                 "two""
         ..== "\"one\\n\\\"two\\\"\""
-(quote %s) compiles to (Lua "tostring(\(%s as lua expr)):as_lua()")
+(quote %s) compiles to "tostring(\(%s as lua expr)):as_lua()"
 
 test:
     assume (lua type of {}) == "table"
diff --git a/core/operators.nom b/core/operators.nom
index 1d8e63f..66185f7 100644
--- a/core/operators.nom
+++ b/core/operators.nom
@@ -11,15 +11,14 @@ test:
     assume (all [1 < 2, 2 > 1, 1 <= 2, 2 >= 1, 1 == 1, 1 != 2])
 
 # Comparison Operators
-(%x < %y) compiles to (Lua value "(\(%x as lua expr) < \(%y as lua expr))")
-(%x > %y) compiles to (Lua value "(\(%x as lua expr) > \(%y as lua expr))")
-(%x <= %y) compiles to (Lua value "(\(%x as lua expr) <= \(%y as lua expr))")
-(%x >= %y) compiles to (Lua value "(\(%x as lua expr) >= \(%y as lua expr))")
-[%a is %b, %a == %b] all compile to (..)
-    Lua value "(\(%a as lua expr) == \(%b as lua expr))"
+(%x < %y) compiles to "(\(%x as lua expr) < \(%y as lua expr))"
+(%x > %y) compiles to "(\(%x as lua expr) > \(%y as lua expr))"
+(%x <= %y) compiles to "(\(%x as lua expr) <= \(%y as lua expr))"
+(%x >= %y) compiles to "(\(%x as lua expr) >= \(%y as lua expr))"
+[%a is %b, %a == %b] all compile to "(\(%a as lua expr) == \(%b as lua expr))"
 
-[%a isn't %b, %a is not %b, %a not= %b, %a != %b] all compile to (..)
-    Lua value "(\(%a as lua expr) ~= \(%b as lua expr))"
+[%a isn't %b, %a is not %b, %a not= %b, %a != %b] all compile to "\
+    ..(\(%a as lua expr) ~= \(%b as lua expr))"
 
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
@@ -45,6 +44,7 @@ test:
     assume ((%y == 10) and (%x == 20)) or barf "swapping vars failed."
 
 # Simultaneous mutli-assignments like: x,y,z = 1,x,3;
+# TODO: deprecate?
 (set %assignments) compiles to:
     assume (%assignments.type is "Dict") or barf "\
         ..Expected a Dict for the assignments part of '<- %' statement, not \%assignments"
@@ -143,7 +143,7 @@ test:
 test:
     assume ((5 wrapped around 2) == 1) or barf "mod not working"
 [%x wrapped around %y, %x mod %y] all compile to (..)
-    Lua value "((\(%x as lua expr)) % (\(%y as lua expr)))"
+    "((\(%x as lua expr)) % (\(%y as lua expr)))"
 
 # 3-part chained comparisons
 # (uses a lambda to avoid re-evaluating middle value, while still being an expression)
@@ -187,8 +187,8 @@ test:
     assume (((no) and (barfer)) == (no))
     assume ((no) or (yes))
     assume ((yes) or (barfer))
-(%x and %y) compiles to (Lua value "(\(%x as lua expr) and \(%y as lua expr))")
-(%x or %y) compiles to (Lua value "(\(%x as lua expr) or \(%y as lua expr))")
+(%x and %y) compiles to "(\(%x as lua expr) and \(%y as lua expr))"
+(%x or %y) compiles to "(\(%x as lua expr) or \(%y as lua expr))"
 
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
@@ -204,49 +204,39 @@ test:
 
 # Lua 5.3 introduced bit operators like | and &. Use them when possible, otherwise
     fall back to bit.bor(), bit.band(), etc.
-%use_bitops = ((is jit) or ((Lua version) == "Lua 5.2"))
-[NOT %, ~ %] all compile to (..)
-    Lua value (..)
-        (%use_bitops and "bit.bnot(\(% as lua expr))") or "~(\(% as lua expr))"
-
-[%a OR %b, %a | %b] all compile to (..)
-    Lua value (..)
-        (%use_bitops and "bit.bor(\(%a as lua expr), \(%b as lua expr))") or "\
-            ..(\(%a as lua expr) | \(%b as lua expr))"
-
-[%a XOR %b, %a ~ %b] all compile to (..)
-    Lua value (..)
-        (%use_bitops and "bit.bxor(\(%a as lua expr), \(%b as lua expr))") or "\
-            ..(\(%a as lua expr) ~ \(%b as lua expr))"
-
-[%a AND %b, %a & %b] all compile to (..)
-    Lua value (..)
-        (%use_bitops and "bit.band(\(%a as lua expr), \(%b as lua expr))") or "\
-            ..(\(%a as lua expr) & \(%b as lua expr))"
-
-[%x LSHIFT %shift, %x << %shift] all compile to (..)
-    Lua value (..)
-        (%use_bitops and "bit.lshift(\(%x as lua expr), \(%shift as lua expr))") or "\
-            ..(\(%x as lua expr) << \(%shift as lua expr))"
-
-[%x RSHIFT %shift, %x >> %shift] all compile to (..)
-    Lua value (..)
-        (%use_bitops and "bit.rshift(\(%x as lua expr), \(%shift as lua expr))") or "\
-            ..(\(%x as lua expr) >> \(%shift as lua expr))"
+lua> "if \((is jit) or ((Lua version) == "Lua 5.2")) then"
+[NOT %, ~ %] all compile to "bit.bnot(\(% as lua expr))"
+[%x OR %y, %x | %y] all compile to "bit.bor(\(%x as lua expr), \(%y as lua expr))"
+[%x XOR %y, %x ~ %y] all compile to "bit.bxor(\(%x as lua expr), \(%y as lua expr))"
+[%x AND %y, %x & %y] all compile to "bit.band(\(%x as lua expr), \(%y as lua expr))"
+[%x LSHIFT %shift, %x << %shift] all compile to "\
+    ..bit.lshift(\(%x as lua expr), \(%shift as lua expr))"
+[%x RSHIFT %shift, %x >> %shift] all compile to "\
+    ..bit.rshift(\(%x as lua expr), \(%shift as lua expr))"
+lua> "else"
+[NOT %, ~ %] all compile to "~(\(% as lua expr))"
+[%x OR %y, %x | %y] all compile to "(\(%x as lua expr) | \(%y as lua expr))"
+[%x XOR %y, %x ~ %y] all compile to "(\(%x as lua expr) ~ \(%y as lua expr))"
+[%x AND %y, %x & %y] all compile to "(\(%x as lua expr) & \(%y as lua expr))"
+[%x LSHIFT %shift, %x << %shift] all compile to "\
+    ..(\(%x as lua expr) << \(%shift as lua expr))"
+[%x RSHIFT %shift, %x >> %shift] all compile to "\
+    ..(\(%x as lua expr) >> \(%shift as lua expr))"
+lua> "end"
 
 # Unary operators
 test:
     assume ((- 5) == -5)
     assume ((not (yes)) == (no))
-(- %) compiles to (Lua value "(- \(% as lua expr))")
-(not %) compiles to (Lua value "(not \(% as lua expr))")
+(- %) compiles to "(- \(% as lua expr))"
+(not %) compiles to "(not \(% as lua expr))"
 
 test:
     assume ((size of [1, 2, 3]) == 3)
 [size of %list, size of %list, size of %list, size of %list] all compile to (..)
-    Lua value "(#\(%list as lua expr))"
+    "(#\(%list as lua expr))"
 
-(%list is empty) compiles to (Lua value "(#\(%list as lua expr) == 0)")
+(%list is empty) compiles to "(#\(%list as lua expr) == 0)"
 
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
diff --git a/core/text.nom b/core/text.nom
index 38fa08b..1e297aa 100644
--- a/core/text.nom
+++ b/core/text.nom
@@ -29,17 +29,19 @@ test:
     %こんにちは = "こんにちは"
     (% と言う) とは "\(%)世界"
     assume (%こんにちは と言う) == "こんにちは世界"
-(%expr for %match in %text matching %patt) compiles to (..)
-    Lua value "\
-        ..(function()
-            local ret = _List{}
-            for \(%match as lua expr) in (\(%text as lua expr)):gmatch(\(..)
-            %patt as lua expr
-        ..) do
-                ret[#ret+1] = \(%expr as lua statements)
-            end
-            return ret
-        end)()"
+(%expr for %match in %text matching %patt) compiles to:
+    define mangler
+    return (..)
+        Lua "\
+            ..(function()
+                local \(mangle "comprehension") = _List{}
+                for \(%match as lua expr) in (\(%text as lua expr)):gmatch(\(..)
+                %patt as lua expr
+            ..) do
+                    \(mangle "comprehension")[#\(mangle "comprehension")+1] = \(%expr as lua statements)
+                end
+                return \(mangle "comprehension")
+            end)()"
 
 test:
     assume "\n" == (newline)
diff --git a/files.lua b/files.lua
index d08d7df..272002b 100644
--- a/files.lua
+++ b/files.lua
@@ -256,7 +256,7 @@ Files.get_line = function(str, line_no)
   if not (stop) then
     return 
   end
-  return str:sub(start, stop - 2)
+  return (str:sub(start, stop - 2))
 end
 local get_lines = re.compile([[    lines <- {| line (%nl line)* |}
     line <- {[^%nl]*}
diff --git a/files.moon b/files.moon
index ca50290..118b660 100644
--- a/files.moon
+++ b/files.moon
@@ -152,7 +152,7 @@ Files.get_line = (str, line_no)->
     return unless start
     stop = line_starts[line_no+1]
     return unless stop
-    return str\sub(start, stop - 2)
+    return (str\sub(start, stop - 2))
 
 get_lines = re.compile([[
     lines <- {| line (%nl line)* |}
diff --git a/lib/consolecolor.nom b/lib/consolecolor.nom
index 4b231a9..d8b078f 100644
--- a/lib/consolecolor.nom
+++ b/lib/consolecolor.nom
@@ -15,9 +15,9 @@ test:
 for %name = %colornum in %colors:
     %colornum = "\%colornum"
     #(=lua "COMPILE_ACTIONS").%name = (..)
-        [%nomsu, %tree] -> (Lua value "'\\027[\(%colornum)m'")
+        [%nomsu, %tree] -> (Lua "'\\027[\(%colornum)m'")
     %compile.action.%name = (..)
         [%nomsu, %tree, %text] ->:
             if %text:
-                return (Lua value "('\\027[\(%colornum)m'..\(%text as lua expr)..'\\027[0m')")
-            ..else: return (Lua value "'\\027[\(%colornum)m'")
+                return (Lua "('\\027[\(%colornum)m'..\(%text as lua expr)..'\\027[0m')")
+            ..else: return (Lua "'\\027[\(%colornum)m'")
diff --git a/lib/os.nom b/lib/os.nom
index 2da395c..64b46c2 100644
--- a/lib/os.nom
+++ b/lib/os.nom
@@ -21,23 +21,21 @@ externally (read file %filename) means (=lua "Files.read(\%filename)")
 
 test:
     for file %f in "core": do nothing
-(for file %f in %path %body) compiles to (..)
-    Lua "\
-        ..for i,\(%f as lua expr) in Files.walk(\(%path as lua expr)) do
-            \(%body as lua statements)
-            \(what (===next %f ===) compiles to)
-        end
-        \(what (===stop %f ===) compiles to)"
+(for file %f in %path %body) compiles to "\
+    ..for i,\(%f as lua expr) in Files.walk(\(%path as lua expr)) do
+        \(%body as lua statements)
+        \(what (===next %f ===) compiles to)
+    end
+    \(what (===stop %f ===) compiles to)"
 
-(%expr for file %f in %path) compiles to (..)
-    Lua value "\
-        ..(function()
-            local ret = List{}
-            for i,\(%f as lua expr) in Files.walk(\(%path as lua expr)) do
-                ret[#ret+1] = \(%expr as lua statements)
-            end
-            return ret
-        end)()"
+(%expr for file %f in %path) compiles to "\
+    ..(function()
+        local ret = List{}
+        for i,\(%f as lua expr) in Files.walk(\(%path as lua expr)) do
+            ret[#ret+1] = \(%expr as lua statements)
+        end
+        return ret
+    end)()"
 
 externally [..]
     write to file %filename %text, to file %filename write %text
diff --git a/lib/version.nom b/lib/version.nom
index 2f4003f..ee9ac92 100644
--- a/lib/version.nom
+++ b/lib/version.nom
@@ -1,3 +1,3 @@
 #!/usr/bin/env nomsu -V4.8.10
 # This file sets the current library version.
-lua> "NOMSU_LIB_VERSION = 6"
+lua> "NOMSU_LIB_VERSION = 7"
diff --git a/nomsu_compiler.lua b/nomsu_compiler.lua
index 0538776..d293d99 100644
--- a/nomsu_compiler.lua
+++ b/nomsu_compiler.lua
@@ -50,13 +50,18 @@ compile_error = function(tree, err_msg, hint)
     title = "Compile error",
     error = err_msg,
     hint = hint,
-    source = tree:get_source_code(),
+    source = tree:get_source_file(),
     start = tree.source.start,
     stop = tree.source.stop,
     filename = tree.source.filename
   })
   return error(err_str, 0)
 end
+local tree_to_nomsu, tree_to_inline_nomsu
+do
+  local _obj_0 = require("nomsu_decompiler")
+  tree_to_nomsu, tree_to_inline_nomsu = _obj_0.tree_to_nomsu, _obj_0.tree_to_inline_nomsu
+end
 local math_expression = re.compile([[ (([*/^+-] / [0-9]+) " ")* [*/^+-] !. ]])
 local compile_math_expression
 compile_math_expression = function(compile, tree, ...)
@@ -125,9 +130,6 @@ local compile = setmetatable({
       end
       return operate_on_text(code)
     end,
-    ["Lua value"] = function(compile, tree, code)
-      return compile.action["Lua"](compile, tree, code)
-    end,
     ["lua >"] = function(compile, tree, code)
       if code.type ~= "Text" then
         return tree
@@ -159,7 +161,17 @@ local compile = setmetatable({
       return LuaCode(tree.source, "TESTS")
     end,
     ["test"] = function(compile, tree, body)
-      return LuaCode(tree.source, "TESTS[" .. tostring(tostring(tree.source):as_lua()) .. "] = ", body:as_lua())
+      if not (body.type == 'Block') then
+        compile_error(tree, "This should be a Block")
+      end
+      local test_nomsu = body:get_source_code():match(":[ ]*(.*)")
+      do
+        local indent = test_nomsu:match("\n([ ]*)")
+        if indent then
+          test_nomsu = test_nomsu:gsub("\n" .. indent, "\n")
+        end
+      end
+      return LuaCode(tree.source, "TESTS[" .. tostring(tostring(tree.source):as_lua()) .. "] = ", test_nomsu:as_lua())
     end,
     ["is jit"] = function(compile, tree, code)
       return LuaCode(tree.source, "jit")
diff --git a/nomsu_compiler.moon b/nomsu_compiler.moon
index 8c21eef..847da21 100644
--- a/nomsu_compiler.moon
+++ b/nomsu_compiler.moon
@@ -30,11 +30,11 @@ pretty_error = require("pretty_errors")
 compile_error = (tree, err_msg, hint=nil)->
     err_str = pretty_error{
         title: "Compile error"
-        error:err_msg, hint:hint, source:tree\get_source_code!
+        error:err_msg, hint:hint, source:tree\get_source_file!
         start:tree.source.start, stop:tree.source.stop, filename:tree.source.filename
     }
     error(err_str, 0)
-
+{:tree_to_nomsu, :tree_to_inline_nomsu} = require "nomsu_decompiler"
 
 -- This is a bit of a hack, but this code handles arbitrarily complex
 -- math expressions like 2*x + 3^2 without having to define a single
@@ -88,9 +88,6 @@ compile = setmetatable({
                 return lua
             return operate_on_text code
 
-        -- TODO: remove shim
-        ["Lua value"]: (compile, tree, code)-> compile.action["Lua"](compile, tree, code)
-
         ["lua >"]: (compile, tree, code)->
             if code.type != "Text"
                 return tree
@@ -116,8 +113,12 @@ compile = setmetatable({
 
         ["tests"]: (compile, tree)-> LuaCode(tree.source, "TESTS")
         ["test"]: (compile, tree, body)->
-            -- TODO: maybe go back to storing nomsu code instead of syntax tree
-            LuaCode tree.source, "TESTS[#{tostring(tree.source)\as_lua!}] = ", body\as_lua!
+            unless body.type == 'Block'
+                compile_error(tree, "This should be a Block")
+            test_nomsu = body\get_source_code!\match(":[ ]*(.*)")
+            if indent = test_nomsu\match("\n([ ]*)")
+                test_nomsu = test_nomsu\gsub("\n"..indent, "\n")
+            LuaCode tree.source, "TESTS[#{tostring(tree.source)\as_lua!}] = ", test_nomsu\as_lua!
 
         ["is jit"]: (compile, tree, code)-> LuaCode(tree.source, "jit")
         ["Lua version"]: (compile, tree, code)-> LuaCode(tree.source, "_VERSION")
diff --git a/nomsu_environment.lua b/nomsu_environment.lua
index 3bb54b1..4735561 100644
--- a/nomsu_environment.lua
+++ b/nomsu_environment.lua
@@ -164,7 +164,7 @@ local nomsu_environment = Importer({
               title = "Parse error",
               error = e.error,
               hint = e.hint,
-              source = e:get_source_code(),
+              source = e:get_source_file(),
               start = e.source.start,
               stop = e.source.stop,
               filename = e.source.filename
@@ -312,7 +312,7 @@ local nomsu_environment = Importer({
       title = "Compile error",
       error = err_msg,
       hint = hint,
-      source = tree:get_source_code(),
+      source = tree:get_source_file(),
       start = tree.source.start,
       stop = tree.source.stop,
       filename = tree.source.filename
diff --git a/nomsu_environment.moon b/nomsu_environment.moon
index 6f38c70..4802ce7 100644
--- a/nomsu_environment.moon
+++ b/nomsu_environment.moon
@@ -75,7 +75,7 @@ nomsu_environment = Importer{
         if num_errs > 0
             err_strings = [pretty_error{
                     title:"Parse error"
-                    error:e.error, hint:e.hint, source:e\get_source_code!
+                    error:e.error, hint:e.hint, source:e\get_source_file!
                     start:e.source.start, stop:e.source.stop, filename:e.source.filename
                 } for i, e in ipairs(errs) when i <= 3]
             if num_errs > #err_strings
@@ -170,7 +170,7 @@ nomsu_environment = Importer{
     compile_error_at: (tree, err_msg, hint=nil)->
         err_str = pretty_error{
             title: "Compile error"
-            error:err_msg, hint:hint, source:tree\get_source_code!
+            error:err_msg, hint:hint, source:tree\get_source_file!
             start:tree.source.start, stop:tree.source.stop, filename:tree.source.filename
         }
         error(err_str, 0)
diff --git a/syntax_tree.lua b/syntax_tree.lua
index 6615f9b..098dbce 100644
--- a/syntax_tree.lua
+++ b/syntax_tree.lua
@@ -83,9 +83,12 @@ do
       end
       return "SyntaxTree{" .. tostring(table.concat(bits, ", ")) .. "}"
     end,
-    get_source_code = function(self)
+    get_source_file = function(self)
       return self.__class.source_code_for_tree[self]
     end,
+    get_source_code = function(self)
+      return self.__class.source_code_for_tree[self]:sub(self.source.start, self.source.stop)
+    end,
     map = function(self, fn)
       local replacement = fn(self)
       if replacement == false then
diff --git a/syntax_tree.moon b/syntax_tree.moon
index 207fb9b..dd10d77 100644
--- a/syntax_tree.moon
+++ b/syntax_tree.moon
@@ -45,7 +45,8 @@ class SyntaxTree
         f = Files.read(s.filename)
         return f
     })
-    get_source_code: => @@source_code_for_tree[@]
+    get_source_file: => @@source_code_for_tree[@]
+    get_source_code: => @@source_code_for_tree[@]\sub(@source.start, @source.stop)
     map: (fn)=>
         replacement = fn(@)
         if replacement == false then return nil