E2E Tests for Query

lute/std/libs/syntax/printer.luau

@@ -168,8 +168,12 @@ local function printVisitor(replacements: types.replacements?)
 		return false
 	end
 	printer.visitToken = function(node: types.Token)
-		printer:printToken(node)
-		return false
+		if replacements ~= nil and replacements[node] then
+			return maybeReplace(node)
+		else
+			printer:printToken(node)
+			return false
+		end
 	end
 	printer.visitString = function(node: types.AstExprConstantString)
 		printer:printString(node)

lute/std/libs/syntax/transform.luau

@@ -0,0 +1,59 @@
+local luau = require("@lute/luau")
+local query = require("@std/syntax/query")
+local printer = require("@std/syntax/printer")
+local types = require("@std/syntax/types")
+local tableext = require("@std/tableext")
+export type query<T> = query.query<T>
+type node = types.AstNode
+type ParseResult = types.ParseResult
+
+local transform = {}
+transform.__index = transform
+
+export type TransformData = {
+	replacements: types.replacements,
+	__fileRoot: types.AstStatBlock,
+}
+
+export type transform = typeof(setmetatable({} :: TransformData, transform))
+
+-- transform is entry point for a codemod; exposes base tools you'll need
+
+function transform.new(fileRoot: types.AstStatBlock)
+	local self = {
+		replacements = {} :: types.replacements,
+		__fileRoot = fileRoot,
+	}
+
+	return setmetatable(self, transform)
+end
+
+-- how do we enforce that this is always called on desc of our root?
+function transform.selectFromRoot<T>(self: transform, ast: node, fn: (node) -> T?): query<T>
+	local q = query.selectFromRoot(ast, fn)
+	local t = self
+	q.replace = function<V>(self: query<V>, repl: (V) -> types.replacement?)
+		local replacements = query.replace(self, repl)
+		tableext.merge(t.replacements, replacements)
+		return replacements
+	end
+	return q
+end
+
+transform.query = transform.selectFromRoot
+
+function transform.transform(self: transform): string
+	return printer.printnode(self.__fileRoot :: any, self.replacements)
+end
+
+return table.freeze(transform)
+
+--[[
+
+example usage:
+
+local t = transform.new(block)
+
+t:selectFromRoot()
+
+]]

lute/std/libs/syntax/types.luau

@@ -158,7 +158,7 @@ export type AstNode = luau.AstNode
 
 export type ParseResult = luau.ParseResult
 
-export type replacement = string | AstNode
-export type replacements = { [AstNode]: replacement }
+export type replacement = string | AstNode | Token
+export type replacements = { [AstNode | Token]: replacement }
 
 return {}

lute/std/libs/syntax/visitor.luau

@@ -999,6 +999,8 @@ local function visit(node: types.AstNode, visitor: Visitor)
 		visitLocal(node, visitor)
 	elseif node.kind == "attribute" then
 		visitAttribute(node, visitor)
+	elseif node.istoken == true then
+		visitToken(node, visitor)
 	else
 		exhaustiveMatch(node.kind)
 	end

lute/std/libs/tableext.luau

@@ -40,9 +40,30 @@ function tableext.fold<K, V, A>(table: { [K]: V }, f: (A, V) -> A, initial: A):
 	return acc
 end
 
-function tableext.extend<T>(tbl: array<T>, other: array<T>)
-	for _, entry in other do
-		table.insert(tbl, entry)
+function tableext.extend<T>(tbl: array<T>, ...: array<T>)
+	local extendees = table.pack(...)
+	extendees.n = nil
+	for _, extendee in extendees do
+		for _, entry in extendee do
+			table.insert(tbl, entry)
+		end
+	end
+end
+
+function tableext.merge<K, V>(tbl: { [K]: V }, ...: { [K]: V }): { [K]: V }
+	local mergees = table.pack(...)
+	mergees.n = nil
+	for _, mergee in mergees do
+		for key, val in mergee do
+			tbl[key] = val
+		end
+	end
+	return tbl
+end
+
+function tableext.foreach<K, V>(tbl: { [K]: V }, callback: (K, V) -> ())
+	for k, v in tbl do
+		callback(k, v)
 	end
 end
 

tests/std/syntax/e2eCases/apiSurfaceChange/cases.luau

@@ -0,0 +1,61 @@
+local types = require("../types")
+type Case = types.Case
+
+return {
+	-- Test 1: Simple function rename
+	{
+		initial = [[
+local sameLibrary = require(packagesRoot.sameLibrary)
+
+local result = sameLibrary.numFunc(1)
+]],
+		expected = [[
+local sameLibrary = require(packagesRoot.sameLibrary)
+
+local result = sameLibrary.processNumber(1)
+]],
+	},
+	-- Test 2: Function rename with type change (number -> string)
+	{
+		initial = [[
+local sameLibrary = require(packagesRoot.sameLibrary)
+
+local result = sameLibrary.arrayFunc({1, 2, 3})
+]],
+		expected = [[
+local sameLibrary = require(packagesRoot.sameLibrary)
+
+local result = sameLibrary.processArray(table.unpack({1, 2, 3}))
+]],
+	},
+	-- Test 3: Multiple function calls with renames and type changes
+	{
+		initial = [[
+local sameLibrary = require(packagesRoot.sameLibrary)
+
+local a = sameLibrary.numFunc(42)
+local b = sameLibrary.arrayFunc({10, 20, 30})
+local c = sameLibrary.stringFunc("hello")
+]],
+		expected = [[
+local sameLibrary = require(packagesRoot.sameLibrary)
+
+local a = sameLibrary.processNumber(42)
+local b = sameLibrary.processArray(table.unpack({10, 20, 30}))
+local c = sameLibrary.handleText("hello")
+]],
+	},
+	-- Test 4: Nested function calls
+	{
+		initial = [[
+local sameLibrary = require(packagesRoot.sameLibrary)
+
+local result = sameLibrary.numFunc(sameLibrary.getCount())
+]],
+		expected = [[
+local sameLibrary = require(packagesRoot.sameLibrary)
+
+local result = sameLibrary.processNumber(sameLibrary.retrieveCount())
+]],
+	},
+} :: { Case }

tests/std/syntax/e2eCases/apiSurfaceChange/init.luau

@@ -0,0 +1,44 @@
+local luau = require("@lute/luau")
+local t = require("@std/syntax/transform")
+local utils = require("@std/syntax/utils")
+local printer = require("@std/syntax/printer")
+local qUtils = require("./utils")
+
+local apiMap = {
+	numFunc = "processNumber",
+	stringFunc = "handleText",
+	arrayFunc = "processArray",
+	processData = "handleData",
+	getCount = "retrieveCount",
+}
+
+local argReplacements = {
+	arrayFunc = function(t: t.transform, node: luau.AstExprCall)
+		local arg = node.arguments[1].node
+		t.replacements[arg :: any] = `table.unpack({printer.printnode(arg :: any)})`
+	end,
+}
+
+local function transformCallArgs(t: t.transform, block: luau.AstStatBlock)
+	t:selectFromRoot(block, utils.isExprCall)
+		:filter(function(node)
+			return node.func.index and argReplacements[node.func.index.text] ~= nil
+		end)
+		:replace(function(node)
+			return node.func.index and argReplacements[node.func.index.text](t, node)
+		end)
+end
+
+local function transform(block: luau.AstStatBlock): string
+	local transform = t.new(block :: any)
+	qUtils.transformLibraryAccess(transform, block, "sameLibrary", function(expr, index: luau.Token)
+		return `{printer.printnode(expr :: any)}.{apiMap[index.text]}`
+	end)
+	transformCallArgs(transform, block)
+	return transform:transform()
+end
+
+return {
+	transform = transform,
+	cases = require("./apiSurfaceChange/cases"),
+}

tests/std/syntax/e2eCases/init.luau

@@ -0,0 +1,5 @@
+return {
+	mockLibrary = require("./e2eCases/libraryMigration"),
+	mockApiSurfaceChange = require("./e2eCases/apiSurfaceChange"),
+	mockRoactToReact = require("./e2eCases/roactToReact"),
+}

tests/std/syntax/e2eCases/libraryMigration/cases.luau

@@ -0,0 +1,55 @@
+local types = require("../types")
+type Case = types.Case
+
+return {
+	{
+		initial = [[
+local oldLibrary = require(packagesRoot.old)
+
+local function myDependentFunction(input: { string }): boolean
+    for _, s in input do
+        if oldLibrary.oldFunction(input) then
+            return true
+        end
+    end
+    return false
+end
+
+local function myIndexUsingDependentFunction(input: string): boolean
+    return oldLibrary.anotherFunction(input)
+end
+]],
+		expected = [[
+local newLibrary = require(packagesRoot.new)
+
+local function myDependentFunction(input: { string }): boolean
+    for _, s in input do
+        if newLibrary.newFunction(input) then
+            return true
+        end
+    end
+    return false
+end
+
+local function myIndexUsingDependentFunction(input: string): boolean
+    return newLibrary.anotherNewFunction(input)
+end
+]],
+	},
+	{
+		initial = [[
+local oldLibraryDiffAlias = require(root.nested.packages.old)
+
+local myEl = oldLibraryDiffAlias.oldFunction("lol")
+
+return oldLibraryDiffAlias.anotherFunction(myEl)
+]],
+		expected = [[
+local newLibrary = require(root.nested.packages.new)
+
+local myEl = newLibrary.newFunction("lol")
+
+return newLibrary.anotherNewFunction(myEl)
+]],
+	},
+} :: { Case }

tests/std/syntax/e2eCases/libraryMigration/init.luau

@@ -0,0 +1,56 @@
+local luau = require("@lute/luau")
+local t = require("@std/syntax/transform")
+local utils = require("@std/syntax/utils")
+local printer = require("@std/syntax/printer")
+local cases = require("./libraryMigration/cases")
+local qUtils = require("./utils")
+local getRequireStatements = qUtils.getRequireStatements
+local transformLibraryAccess = qUtils.transformLibraryAccess
+
+-- local newFunction = newLibrary.newFunction
+-- local oldFunction = oldLibrary.oldFunction
+local function transformLocal() -- need to transform newFunction use
+end
+
+-- maps oldLibrary function names to newLibrary functions
+local functionMap = {
+	["oldFunction"] = "newFunction",
+	["anotherFunction"] = "anotherNewFunction",
+}
+
+local function transformRequires(q: t.transform, block: luau.AstStatBlock): string
+	local oldLibRequires = getRequireStatements(block, "old")
+
+	q:selectFromRoot(oldLibRequires.nodes[1] :: any, utils.isExprCall)
+		:map(function(node)
+			return node.arguments[1].node.index
+		end)
+		:replace(function(node)
+			return "new"
+		end)
+
+	local oldLibVar = oldLibRequires.nodes[1].variables[1].node
+	local oldLibAlias
+	q:selectFromRoot(oldLibVar :: any, utils.isToken):replace(function(node: luau.Token)
+		oldLibAlias = node.text
+		return "newLibrary"
+	end)
+	return oldLibAlias
+end
+
+local function transform(block: luau.AstStatBlock): string
+	local transform = t.new(block :: any)
+	local oldLibAlias = transformRequires(transform, block)
+	transformLibraryAccess(transform, block, oldLibAlias, function(_, index)
+		local oldFunction = index.text
+		return `newLibrary.{functionMap[oldFunction]}`
+	end)
+	return transform:transform()
+end
+
+return {
+	transform = transform,
+	cases = cases,
+}
+
+-- having parent nodes will be goated! context in the tree is huge