lint stages wip

Author: leafo

bin/moonc

@@ -5,7 +5,26 @@ local lfs = require "lfs"
 
 local parser = argparse()
 
-parser:flag("-l --lint", "Perform a lint on the file instead of compiling")
+parser:group("Lint mode",
+  parser:flag("-l --lint", "Perform a lint on the file instead of compiling"),
+  parser:option("--lint-config-module", "Module name used for lint configuration", "lint_config"),
+  parser:option("--lint-stages", "Which stages of lint to perform", "globals,unused"):convert(function(stages_string)
+    local valid_stages = { globals = true, unused = true }
+    local stages = {}
+    for stage in stages_string:gmatch("([^%s,]+)") do
+      if not valid_stages[stage] then
+        return nil, "--lint-stages: Invalid stage name `" .. stage .. "`"
+      end
+      table.insert(stages, stage)
+    end
+
+    if not next(stages) then
+      return nil, "--lint-stages: Can not be empty"
+    end
+
+    return stages
+  end)
+)
 
 parser:flag("-v --version", "Print version")
 parser:flag("-w --watch", "Watch file/directory for updates")
@@ -149,12 +168,20 @@ local function create_watcher(files)
   return watchers.SleepWatcher(files):each_update()
 end
 
+-- lint options to pass through
+local lint_opts = {
+  stages = opts.lint_stages,
+  config_module = opts.lint_config_module
+}
+
 if opts.watch then
   -- build function to check for lint or compile in watch
   local handle_file
   if opts.lint then
     local lint = require "moonscript.cmd.lint"
-    handle_file = lint.lint_file
+    handle_file = function(fname, target)
+      return lint.lint_file(fname, lint_opts)
+    end
   else
     handle_file = compile_and_write
   end
@@ -202,7 +229,7 @@ elseif opts.lint then
   local lint = require "moonscript.cmd.lint"
   for _, tuple in pairs(files) do
     local fname = tuple[1]
-    local res, err = lint.lint_file(fname)
+    local res, err = lint.lint_file(fname, lint_opts)
     if res then
       has_linted_with_error = true
       io.stderr:write(res .. "\n\n")

moonscript/cmd/lint.lua

@@ -50,6 +50,10 @@ local default_whitelist = Set({
   "true",
   "false"
 })
+local default_stages = {
+  globals = true,
+  unused = true
+}
 local LinterBlock
 do
   local _class_0
@@ -65,6 +69,9 @@ do
       end
     end,
     lint_check_unused = function(self)
+      if not (self.stages.unused) then
+        return 
+      end
       if not (self.lint_unused_names and next(self.lint_unused_names)) then
         return 
       end
@@ -141,26 +148,34 @@ do
   _base_0.__index = _base_0
   setmetatable(_base_0, _parent_0.__base)
   _class_0 = setmetatable({
-    __init = function(self, whitelist_globals, ...)
+    __init = function(self, whitelist_globals, stages, ...)
       if whitelist_globals == nil then
         whitelist_globals = default_whitelist
       end
+      if stages == nil then
+        stages = default_stages
+      end
       _class_0.__parent.__init(self, ...)
       self.get_root_block = function()
         return self
       end
+      self.stages = stages
       self.lint_errors = { }
       local vc = self.value_compilers
       self.value_compilers = setmetatable({
         ref = function(block, val)
           local name = val[2]
-          if not (block:has_name(name) or whitelist_globals[name] or name:match("%.")) then
-            insert(self.lint_errors, {
-              "accessing global `" .. tostring(name) .. "`",
-              val[-1]
-            })
+          if self.stages.globals then
+            if not (block:has_name(name) or whitelist_globals[name] or name:match("%.")) then
+              insert(self.lint_errors, {
+                "accessing global `" .. tostring(name) .. "`",
+                val[-1]
+              })
+            end
+          end
+          if self.stages.unused then
+            block:lint_mark_used(name)
           end
-          block:lint_mark_used(name)
           return vc.ref(block, val)
         end
       }, {
@@ -169,30 +184,32 @@ do
       local sc = self.statement_compilers
       self.statement_compilers = setmetatable({
         assign = function(block, node)
-          local names = node[2]
-          for _index_0 = 1, #names do
-            local _continue_0 = false
-            repeat
-              local name = names[_index_0]
-              if type(name) == "table" and name[1] == "temp_name" then
-                _continue_0 = true
-                break
-              end
-              local real_name, is_local = block:extract_assign_name(name)
-              if not (is_local or real_name and not block:has_name(real_name, true)) then
-                _continue_0 = true
-                break
-              end
-              if real_name == "_" then
+          if self.stages.unused then
+            local names = node[2]
+            for _index_0 = 1, #names do
+              local _continue_0 = false
+              repeat
+                local name = names[_index_0]
+                if type(name) == "table" and name[1] == "temp_name" then
+                  _continue_0 = true
+                  break
+                end
+                local real_name, is_local = block:extract_assign_name(name)
+                if not (is_local or real_name and not block:has_name(real_name, true)) then
+                  _continue_0 = true
+                  break
+                end
+                if real_name == "_" then
+                  _continue_0 = true
+                  break
+                end
+                block.lint_unused_names = block.lint_unused_names or { }
+                block.lint_unused_names[real_name] = node[-1] or 0
                 _continue_0 = true
+              until true
+              if not _continue_0 then
                 break
               end
-              block.lint_unused_names = block.lint_unused_names or { }
-              block.lint_unused_names[real_name] = node[-1] or 0
-              _continue_0 = true
-            until true
-            if not _continue_0 then
-              break
             end
           end
           return sc.assign(block, node)
@@ -270,14 +287,18 @@ format_lint = function(errors, code, header)
 end
 local whitelist_for_file
 do
-  local lint_config
-  whitelist_for_file = function(fname)
-    if not (lint_config) then
-      lint_config = { }
+  local loaded_configs = { }
+  whitelist_for_file = function(fname, config_module)
+    if config_module == nil then
+      config_module = "lint_config"
+    end
+    if not (loaded_configs[config_module]) then
+      loaded_configs[config_module] = { }
       pcall(function()
-        lint_config = require("lint_config")
+        loaded_configs[config_module] = require(config_module)
       end)
     end
+    local lint_config = loaded_configs[config_module]
     if not (lint_config.whitelist_globals) then
       return default_whitelist
     end
@@ -295,28 +316,55 @@ do
     })
   end
 end
+local normalize_stages
+normalize_stages = function(stages)
+  if not (stages) then
+    return default_stages
+  end
+  if stages.globals ~= nil or stages.unused ~= nil then
+    return stages
+  end
+  local out = { }
+  for _index_0 = 1, #stages do
+    local stage = stages[_index_0]
+    out[stage] = true
+  end
+  return out
+end
 local lint_code
-lint_code = function(code, name, whitelist_globals)
+lint_code = function(code, name, opts)
   if name == nil then
     name = "string input"
   end
+  if opts == nil then
+    opts = { }
+  end
   local parse = require("moonscript.parse")
   local tree, err = parse.string(code)
   if not (tree) then
     return nil, err
   end
-  local scope = LinterBlock(whitelist_globals)
+  local whitelist_globals = opts.whitelist_globals or default_whitelist
+  local stages = normalize_stages(opts.stages)
+  local scope = LinterBlock(whitelist_globals, stages)
   scope:stms(tree)
   scope:lint_check_unused()
   return format_lint(scope.lint_errors, code, name)
 end
 local lint_file
-lint_file = function(fname)
+lint_file = function(fname, opts)
+  if opts == nil then
+    opts = { }
+  end
   local f, err = io.open(fname)
   if not (f) then
     return nil, err
   end
-  return lint_code(f:read("*a"), fname, whitelist_for_file(fname))
+  local config_module = opts.config_module or "lint_config"
+  return lint_code(f:read("*a"), fname, {
+    whitelist_globals = whitelist_for_file(fname, config_module),
+    stages = opts.stages
+  })
 end
 return {
   lint_code = lint_code,