First version of lute lint (#597)

Initial implementation of `lute lint`. It currently supports exactly one
rule and one source file, with multiple rules and source files coming in
a future PR. By default, it pretty prints reported violations (barring
tab shenanigans).

Some notes:
- I had to copy `cli.luau` over from batteries because `@batteries`
isn't embedded with lute commands.
- I added a `@commands` alias so that the lint rules I wrote could have
access to lint-related types. Longer term, we should probably figure out
a better place to put those types.

Author: skberkeley

.luaurc

@@ -3,6 +3,7 @@
     "aliases": {
         "batteries": "./batteries",
         "std": "./lute/std/libs",
-        "lute": "./definitions"
+        "lute": "./definitions",
+        "commands": "./lute/cli/commands"
     }
 }

.luaurc.ci

@@ -2,5 +2,6 @@
     "languageMode": "strict",
     "aliases": {
         "batteries": "./batteries",
+        "commands": "./lute/cli/commands"
     }
 }

batteries/cli.luau

@@ -151,7 +151,7 @@ function cli.parse(self: Parser, args: { string }): ()
 	end
 end
 
-function cli.get(self: Parser, name: string): string
+function cli.get(self: Parser, name: string): string?
 	return self.parsed.values[name]
 end
 

examples/lints/almost_swapped.luau

@@ -0,0 +1,105 @@
+local lintTypes = require("@commands/lint/types")
+local path = require("@std/path")
+local query = require("@std/syntax/query")
+local syntax = require("@std/syntax")
+local utils = require("@std/syntax/utils")
+
+local name = "almost_swapped"
+local message = "This looks like a failed attempt to swap."
+
+local compFuncs = {}
+
+function compFuncs.exprLocalsSame(a: syntax.AstExprLocal, b: syntax.AstExprLocal): boolean
+	return a["local"] == b["local"]
+end
+
+function compFuncs.exprGlobalsSame(a: syntax.AstExprGlobal, b: syntax.AstExprGlobal): boolean
+	return a.name.text == b.name.text
+end
+
+function compFuncs.exprIndexNamesSame(a: syntax.AstExprIndexName, b: syntax.AstExprIndexName): boolean
+	if a.index.text ~= b.index.text then
+		return false
+	end
+
+	return compFuncs.refExprsSame(a.expression, b.expression)
+end
+
+function compFuncs.exprIndexExprsSame(a: syntax.AstExprIndexExpr, b: syntax.AstExprIndexExpr): boolean
+	if a.index.tag == "string" and b.index.tag == "string" then
+		if a.index.text ~= b.index.text then
+			return false
+		else
+			return compFuncs.refExprsSame(a.expression, b.expression)
+		end
+	else
+		return compFuncs.refExprsSame(a.expression, b.expression) and compFuncs.refExprsSame(a.index, b.index)
+	end
+end
+
+function compFuncs.refExprsSame(a: syntax.AstExpr, b: syntax.AstExpr): boolean
+	if a.tag ~= b.tag then
+		return false
+	end
+
+	if a.tag == "local" then
+		return compFuncs.exprLocalsSame(a, b :: syntax.AstExprLocal)
+	elseif a.tag == "global" then
+		return compFuncs.exprGlobalsSame(a, b :: syntax.AstExprGlobal)
+	elseif a.tag == "indexname" then
+		return compFuncs.exprIndexNamesSame(a, b :: syntax.AstExprIndexName)
+	elseif a.tag == "index" then
+		return compFuncs.exprIndexExprsSame(a, b :: syntax.AstExprIndexExpr)
+	else
+		return false
+	end
+end
+
+-- Report instances of attempted swaps like:
+-- a = b; b = a
+local function lint(ast: syntax.AstStatBlock, sourcepath: path.path): { lintTypes.LintViolation }
+	local violations = {}
+
+	local nodes = query.findallfromroot(ast, utils.isStatBlock).nodes
+
+	for _, block in nodes do
+		for i = 1, #block.statements - 1 do
+			local currStat = block.statements[i]
+			if currStat.tag ~= "assign" or #currStat.values ~= 1 or #currStat.variables ~= 1 then
+				continue
+			end
+
+			local nextStat = block.statements[i + 1]
+			if nextStat.tag ~= "assign" or #nextStat.values ~= 1 or #nextStat.variables ~= 1 then
+				continue
+			end
+
+			local currVar, currVal = currStat.variables[1].node, currStat.values[1].node
+			local nextVar, nextVal = nextStat.variables[1].node, nextStat.values[1].node
+
+			if compFuncs.refExprsSame(currVar, nextVal) and compFuncs.refExprsSame(nextVar, currVal) then
+				table.insert(violations, { -- LUAUFIX: severity isn't inferred as a singleton, so table.insert is mad
+					lintname = name,
+					location = syntax.span.create({
+						beginline = currStat.location.beginline,
+						begincolumn = currStat.location.begincolumn,
+						endline = nextStat.location.endline,
+						endcolumn = nextStat.location.endcolumn,
+					}),
+					message = message,
+					severity = "warning",
+					sourcepath = sourcepath,
+				})
+			end
+		end
+	end
+
+	return violations
+end
+
+local rule: lintTypes.LintRule = {
+	name = name,
+	lint = lint,
+}
+
+return table.freeze(rule)

examples/lints/divide_by_zero.luau

@@ -0,0 +1,39 @@
+local lintTypes = require("@commands/lint/types")
+local path = require("@std/path")
+local query = require("@std/syntax/query")
+local syntax = require("@std/syntax")
+local utils = require("@std/syntax/utils")
+
+local name = "divide_by_zero"
+local message = "Division by zero detected."
+
+local function lint(ast: syntax.AstStatBlock, sourcepath: path.path): { lintTypes.LintViolation }
+	return query
+		.findallfromroot(ast, utils.isExprBinary)
+		:filter(function(bin)
+			return bin.operator.text == "/" or bin.operator.text == "//" or bin.operator.text == "%"
+		end)
+		:filter(function(bin)
+			return bin.rhsoperand.kind == "expr" and bin.rhsoperand.tag == "number" and bin.rhsoperand.value == 0
+		end)
+		:maptoarray(
+			function(
+				n: syntax.AstExprBinary
+			): lintTypes.LintViolation -- LUAUFIX: Bidiretional inference of generics should let us not need this annotation
+				return {
+					lintname = name,
+					location = n.location,
+					message = message,
+					severity = "warning",
+					sourcepath = sourcepath,
+				}
+			end
+		)
+end
+
+local rule: lintTypes.LintRule = {
+	name = name,
+	lint = lint,
+}
+
+return table.freeze(rule)

lute/cli/commands/cli.luau

@@ -0,0 +1,175 @@
+local cli = {}
+cli.__index = cli
+
+type ArgKind = "positional" | "flag" | "option"
+type ArgOptions = {
+	help: string?,
+	aliases: { string }?,
+	default: string?,
+	required: boolean?,
+}
+
+type ArgData = {
+	name: string,
+	kind: ArgKind,
+	options: ArgOptions,
+}
+
+type ParseResult = {
+	values: { [string]: string },
+	flags: { [string]: boolean },
+	fwdArgs: { string },
+}
+
+type ParserData = {
+	arguments: { [number]: ArgData },
+	positional: { [number]: ArgData },
+	parsed: ParseResult,
+}
+
+type ParserInterface = typeof(cli)
+export type Parser = setmetatable<ParserData, ParserInterface>
+
+function cli.parser(): Parser
+	local self = {
+		arguments = {},
+		positional = {},
+		parsed = { values = {}, flags = {}, fwdArgs = {} },
+	}
+
+	return setmetatable(self, cli)
+end
+
+function cli.add(self: Parser, name: string, kind: ArgKind, options: ArgOptions): ()
+	local argument = {
+		name = name,
+		kind = kind,
+		options = options or { aliases = {}, required = false },
+	}
+
+	table.insert(self.arguments, argument)
+	if kind == "positional" then
+		table.insert(self.positional, argument)
+	end
+end
+
+function cli.parse(self: Parser, args: { string }): ()
+	local i = 0
+	local pos_index = 1
+
+	while i < #args do
+		i += 1
+
+		local arg = args[i]
+
+		-- if the argument is exactly "--", we pass everything along
+		if arg == "--" then
+			table.move(args, i + 1, #args, 1, self.parsed.fwdArgs)
+			break
+		end
+
+		-- if the argument starts with two dashes, we're parsing either a flag or an option
+		if string.sub(arg, 1, 2) == "--" then
+			local name = string.sub(arg, 3)
+			local found = false
+
+			for _, argument in self.arguments do
+				local aliases = argument.options.aliases or {}
+
+				if argument.name == name or table.find(aliases, name) then
+					found = true
+
+					if argument.kind == "option" then
+						-- advance past the argument
+						i += 1
+
+						assert(i <= #args, "Missing value for argument: " .. argument.name)
+						self.parsed.values[argument.name] = args[i]
+
+						break
+					end
+
+					self.parsed.flags[argument.name] = true
+					break
+				end
+			end
+
+			assert(found, "Unknown argument: " .. name)
+			continue
+		end
+
+		-- if the argument starts with a single dash, we're parsing a flag
+		if string.sub(arg, 1, 1) == "-" then
+			local flags = string.sub(arg, 2)
+
+			for j = 1, #flags do
+				local name = string.sub(flags, j, j)
+				local found = false
+				for _, argument in self.arguments do
+					local aliases = argument.options.aliases or {}
+					if argument.name == name or table.find(aliases, name) then
+						found = true
+						if argument.kind == "option" then
+							i += 1
+							assert(i <= #args, "Missing value for argument: " .. argument.name)
+							self.parsed.values[argument.name] = args[i]
+						else
+							self.parsed.flags[argument.name] = true
+						end
+						break
+					end
+				end
+
+				assert(found, "Unknown argument: " .. name)
+			end
+
+			continue
+		end
+
+		-- if we have positional arguments left, we can take this argument as one
+		if pos_index <= #self.positional then
+			self.parsed.values[self.positional[pos_index].name] = arg
+			pos_index += 1
+			continue
+		end
+
+		-- otherwise, the argument is forwarded on
+		table.insert(self.parsed.fwdArgs, arg)
+	end
+
+	-- check that all required arguments are present, and set any default values as needed
+	for _, argument in self.arguments do
+		assert(argument)
+
+		if argument.options.required and self.parsed.values[argument.name] == nil then
+			assert(self.parsed.values[argument.name], "Missing required argument: " .. argument.name)
+		end
+
+		if self.parsed.values[argument.name] == nil and argument.options.default then
+			self.parsed.values[argument.name] = argument.options.default
+		end
+	end
+end
+
+function cli.get(self: Parser, name: string): string?
+	return self.parsed.values[name]
+end
+
+function cli.has(self: Parser, name: string): boolean
+	return self.parsed.flags[name] ~= nil
+end
+
+function cli.forwarded(self: Parser): { string }?
+	return self.parsed.fwdArgs
+end
+
+function cli.help(self: Parser): ()
+	print("Usage:")
+	for _, argument in self.arguments do
+		local aliasStr = table.concat(argument.options.aliases or {}, ", ")
+		local reqStr = if argument.options.required then "(required) " else ""
+		print(string.format("  --%s (-%s) - %s%s", argument.name, aliasStr, reqStr, argument.options.help or ""))
+	end
+end
+
+return table.freeze(cli)