implicit return done in transform

Author: leafo

moonscript/compile/format.moon

@@ -19,7 +19,7 @@ manual_return = Set{"foreach", "for", "while"}
 
 default_return = (exp) ->
   t = ntype exp
-  if t == "chain" and exp[2] == "return"
+  if t == "chain" and exp[2] == "return" -- return is a first class citizen now
     -- extract the return
     items = {"explist"}
     insert items, v for v in *exp[3][2]

moonscript/compile/value.lua

@@ -240,7 +240,7 @@ value_compile = {
           self_arg_values
         })
       end
-      _with_0:ret_stms(block)
+      _with_0:stms(block)
       if #args > #arg_names then
         arg_names = (function()
           local _accum_0 = { }

moonscript/compile/value.moon

@@ -127,7 +127,9 @@ value_compile =
       self_arg_values = [arg[2] for arg in *self_args]
       \stm {"assign", self_args, self_arg_values} if #self_args > 0
 
-      \ret_stms block
+      \stms block
+
+      -- inject more args if the block manipulated arguments
       if #args > #arg_names -- will only work for simple adjustments
         arg_names = for arg in *args
           arg[1]

moonscript/transform.lua

@@ -5,6 +5,10 @@ local data = require("moonscript.data")
 local reversed = util.reversed
 local ntype, build, smart_node, is_slice = types.ntype, types.build, types.smart_node, types.is_slice
 local insert = table.insert
+local is_value
+is_value = function(stm)
+  return moonscript.compile.Block:is_value(stm) or value.can_transform(stm)
+end
 NameProxy = (function()
   local _parent_0 = nil
   local _base_0 = {
@@ -152,25 +156,35 @@ local constructor_name = "new"
 local Transformer
 Transformer = function(transformers)
   local seen_nodes = { }
-  return function(n, ...)
-    if seen_nodes[n] then
-      return n
-    end
-    seen_nodes[n] = true
-    while true do
-      local transformer = transformers[ntype(n)]
-      local res
-      if transformer then
-        res = transformer(n, ...) or n
-      else
-        res = n
-      end
-      if res == n then
+  local tf = {
+    transform = function(n, ...)
+      if seen_nodes[n] then
         return n
       end
-      n = res
+      seen_nodes[n] = true
+      while true do
+        local transformer = transformers[ntype(n)]
+        local res
+        if transformer then
+          res = transformer(n, ...) or n
+        else
+          res = n
+        end
+        if res == n then
+          return n
+        end
+        n = res
+      end
+    end,
+    can_transform = function(node)
+      return transformers[ntype(node)] ~= nil
     end
-  end
+  }
+  return setmetatable(tf, {
+    __call = function(self, ...)
+      return self.transform(...)
+    end
+  })
 end
 stm = Transformer({
   comprehension = function(node, action)
@@ -587,6 +601,21 @@ value = Transformer({
     end)
     return a:wrap(node)
   end,
+  fndef = function(node)
+    smart_node(node)
+    node.body = apply_to_last(node.body, function(stm)
+      local t = ntype(stm)
+      if types.manual_return[t] or not is_value(stm) then
+        return stm
+      else
+        return {
+          "return",
+          stm
+        }
+      end
+    end)
+    return node
+  end,
   chain = function(node)
     local stub = node[#node]
     if type(stub) == "table" and stub[1] == "colon_stub" then

moonscript/transform.moon

@@ -11,6 +11,10 @@ import insert from table
 
 export stm, value, NameProxy, Run
 
+-- TODO refactor
+is_value = (stm) ->
+  moonscript.compile.Block\is_value(stm) or value.can_transform stm
+
 class NameProxy
   new: (@prefix) =>
     self[1] = "temp_name"
@@ -81,17 +85,25 @@ constructor_name = "new"
 Transformer = (transformers) ->
   -- this is bad, instance it for compiler
   seen_nodes = {}
-  (n, ...) ->
-    return n if seen_nodes[n]
-    seen_nodes[n] = true
-    while true
-      transformer = transformers[ntype n]
-      res = if transformer
-        transformer(n, ...) or n
-      else
-        n
-      return n if res == n
-      n = res
+  tf = {
+    transform: (n, ...) ->
+      return n if seen_nodes[n]
+      seen_nodes[n] = true
+      while true
+        transformer = transformers[ntype n]
+        res = if transformer
+          transformer(n, ...) or n
+        else
+          n
+        return n if res == n
+        n = res
+    can_transform: (node) ->
+      transformers[ntype node] != nil
+  }
+
+  setmetatable tf, {
+    __call: (...) => self.transform ...
+  }
 
 stm = Transformer {
   comprehension: (node, action) ->
@@ -327,6 +339,18 @@ value = Transformer {
       a\mutate_body {exp}, false
     a\wrap node
 
+  fndef: (node) ->
+    smart_node node
+
+    node.body = apply_to_last node.body, (stm) ->
+      t = ntype stm
+      -- TODO okay this needs a refactor
+      if types.manual_return[t] or not is_value stm
+        stm
+      else
+        {"return", stm}
+
+    node
   -- pull out colon chain
   chain: (node) ->
     stub = node[#node]

moonscript/types.lua

@@ -2,6 +2,12 @@ module("moonscript.types", package.seeall)
 local util = require("moonscript.util")
 local data = require("moonscript.data")
 local insert = table.insert
+manual_return = data.Set({
+  "foreach",
+  "for",
+  "while",
+  "return"
+})
 ntype = function(node)
   if type(node) ~= "table" then
     return "value"

moonscript/types.moon

@@ -3,9 +3,11 @@ util = require "moonscript.util"
 data = require "moonscript.data"
 
 export ntype, smart_node, build
-export is_slice
+export is_slice, manual_return
+
 import insert from table
 
+manual_return = data.Set{"foreach", "for", "while", "return"}
 
 -- type of node as string
 ntype = (node) ->

todo

@@ -1,5 +1,8 @@
 # TODO
 
+- don't reuse _, put a local on it, so we don't keep around trash
+
+
 - or= and=
 
 - move stuff out of format that should be in types