nomsu/error_handling.lua

local debug_getinfo = debug.getinfo
local ok, to_lua = pcall(function()
  return require('moonscript.base').to_lua
end)
if not ok then
  to_lua = nil
end
local moonscript_line_tables = setmetatable({ }, {
  __index = function(self, filename)
    if not (to_lua) then
      return nil
    end
    local _, line_table = to_lua(FILE_CACHE[filename])
    self[filename] = line_table
    return line_table
  end
})
debug.getinfo = function(thread, f, what)
  if what == nil then
    f, what, thread = thread, f, nil
  end
  if type(f) == 'number' then
    f = f + 1
  end
  local info
  if thread == nil then
    info = debug_getinfo(f, what)
  else
    info = debug_getinfo(thread, f, what)
  end
  if not info or not info.func then
    return info
  end
  if info.short_src or info.source or info.linedefine or info.currentline then
    do
      local map = SOURCE_MAP[info.source]
      if map then
        if info.currentline then
          info.currentline = assert(map[info.currentline])
        end
        if info.linedefined then
          info.linedefined = assert(map[info.linedefined])
        end
        if info.lastlinedefined then
          info.lastlinedefined = assert(map[info.lastlinedefined])
        end
        info.short_src = info.source:match('@([^[]*)') or info.short_src
      end
    end
  end
  return info
end
local print_err_msg
print_err_msg = function(error_message, stack_offset)
  if stack_offset == nil then
    stack_offset = 3
  end
  io.stderr:write(tostring(colored.red("ERROR:")) .. " " .. tostring(colored.bright(colored.red((error_message or "")))) .. "\n")
  io.stderr:write("stack traceback:\n")
  ok, to_lua = pcall(function()
    return require('moonscript.base').to_lua
  end)
  if not ok then
    to_lua = function()
      return nil
    end
  end
  local LINE_TABLES = setmetatable({ }, {
    __index = function(self, file)
      local _, line_table = to_lua(file)
      self[file] = line_table or false
      return line_table or false
    end
  })
  local get_line
  get_line = function(file, line_no)
    local start = LINE_STARTS[file][line_no] or 1
    local stop = (LINE_STARTS[file][line_no + 1] or 0) - 1
    return file:sub(start, stop)
  end
  local level = stack_offset
  while true do
    local _continue_0 = false
    repeat
      local calling_fn = debug_getinfo(level)
      if not calling_fn then
        break
      end
      if calling_fn.func == run then
        break
      end
      level = level + 1
      local name = calling_fn.name and "function '" .. tostring(calling_fn.name) .. "'" or nil
      if calling_fn.linedefined == 0 then
        name = "main chunk"
      end
      if name == "run_lua_fn" then
        _continue_0 = true
        break
      end
      local line = nil
      do
        local map = SOURCE_MAP[calling_fn.source]
        if map then
          if calling_fn.currentline then
            calling_fn.currentline = assert(map[calling_fn.currentline])
          end
          if calling_fn.linedefined then
            calling_fn.linedefined = assert(map[calling_fn.linedefined])
          end
          if calling_fn.lastlinedefined then
            calling_fn.lastlinedefined = assert(map[calling_fn.lastlinedefined])
          end
          local filename, start, stop = calling_fn.source:match('@([^[]*)%[([0-9]+):([0-9]+)]')
          assert(filename)
          local file = FILE_CACHE[filename]:sub(tonumber(start), tonumber(stop))
          local err_line = get_line(file, calling_fn.currentline):sub(1, -2)
          local offending_statement = colored.bright(colored.red(err_line:match("^[ ]*(.*)")))
          name = "action '" .. tostring(calling_fn.name) .. "'"
          line = colored.yellow(tostring(filename) .. ":" .. tostring(calling_fn.currentline) .. " in " .. tostring(name) .. "\n        " .. tostring(offending_statement))
        else
          local file
          ok, file = pcall(function()
            return FILE_CACHE[calling_fn.short_src]
          end)
          if not ok then
            file = nil
          end
          local line_num
          if name == nil then
            local search_level = level
            local _info = debug.getinfo(search_level)
            while _info and (_info.func == pcall or _info.func == xpcall) do
              search_level = search_level + 1
              _info = debug.getinfo(search_level)
            end
            if _info then
              for i = 1, 999 do
                local varname, val = debug.getlocal(search_level, i)
                if not varname then
                  break
                end
                if val == calling_fn.func then
                  name = "local '" .. tostring(varname) .. "'"
                  if not varname:match("%(") then
                    break
                  end
                end
              end
              if not (name) then
                for i = 1, _info.nups do
                  local varname, val = debug.getupvalue(_info.func, i)
                  if not varname then
                    break
                  end
                  if val == calling_fn.func then
                    name = "upvalue '" .. tostring(varname) .. "'"
                    if not varname:match("%(") then
                      break
                    end
                  end
                end
              end
            end
          end
          if file and calling_fn.short_src:match(".moon$") and LINE_TABLES[file] then
            local char = LINE_TABLES[file][calling_fn.currentline]
            line_num = 1
            for _ in file:sub(1, char):gmatch("\n") do
              line_num = line_num + 1
            end
            line = colored.cyan(tostring(calling_fn.short_src) .. ":" .. tostring(line_num) .. " in " .. tostring(name or '?'))
          else
            line_num = calling_fn.currentline
            if calling_fn.short_src == '[C]' then
              line = colored.green(tostring(calling_fn.short_src) .. " in " .. tostring(name or '?'))
            else
              line = colored.blue(tostring(calling_fn.short_src) .. ":" .. tostring(calling_fn.currentline) .. " in " .. tostring(name or '?'))
            end
          end
          if file then
            local err_line = get_line(file, line_num):sub(1, -2)
            local offending_statement = colored.bright(colored.red(err_line:match("^[ ]*(.*)$")))
            line = line .. ("\n        " .. offending_statement)
          end
        end
      end
      io.stderr:write("    " .. tostring(line) .. "\n")
      if calling_fn.istailcall then
        io.stderr:write("    " .. tostring(colored.dim(colored.white("  (...tail calls...)"))) .. "\n")
      end
      _continue_0 = true
    until true
    if not _continue_0 then
      break
    end
  end
  return io.stderr:flush()
end
local err_hand
err_hand = function(error_message)
  print_err_msg(error_message)
  return os.exit(false, true)
end
local has_ldt, ldt = pcall(require, 'ldt')
local safe_run
if has_ldt then
  safe_run = ldt.guard
else
  safe_run = function(fn)
    return xpcall(fn, err_hand)
  end
end
return safe_run