E2E Tests for Query

.gitignore

@@ -21,3 +21,5 @@ extern/*/
 generated
 **/generated-types.luau
 WARP.md
+
+**/**.luau.result

lute/std/libs/fs.luau

@@ -18,6 +18,7 @@ export type watchhandle = fs.WatchHandle
 export type watchevent = fs.WatchEvent
 
 type pathlike = pathlib.pathlike
+type path = pathlib.path
 
 export type createdirectoryoptions = {
 	makeparents: boolean?,

lute/std/libs/syntax/query.luau

@@ -18,6 +18,7 @@ export type query<T = node> = {
 	findall: <U>(self: query<T>, fn: (node) -> U?) -> query<U>,
 	flatmap: <U>(self: query<T>, fn: (T) -> { U }) -> query<U>,
 	maptoarray: <U>(self: query<T>, fn: (T) -> U?) -> { U },
+	exists: (self: query<T>, pred: ((T) -> boolean)?) -> boolean,
 }
 
 local queryLib = {}
@@ -64,6 +65,19 @@ function queryLib.foreach<T>(self: query<T>, callback: (T) -> ()): query<T>
 	return self
 end
 
+function queryLib.exists<T>(self: query<T>, predicate: ((T) -> boolean)?): boolean
+	if not predicate then
+		return #self.nodes > 0
+	end
+
+	for _, node in self.nodes do
+		if predicate(node) then
+			return true
+		end
+	end
+	return false
+end
+
 local function newSelectVisitor<T>(nodes: { T }, fn: (node) -> T?): visitor.Visitor
 	local function visit(n: node) -- LUAUFIX: type checker doesn't like assigning visit in the visitor fields with n: node
 		local selected = fn(n)
@@ -145,6 +159,7 @@ function queryLib.findallfromroot<T>(ast: types.ParseResult | node, fn: (node) -
 		findall = queryLib.findall,
 		flatmap = queryLib.flatmap,
 		maptoarray = queryLib.maptoarray,
+		exists = queryLib.exists,
 	} -- LUAUFIX: queryLib.map has generics quantified at a different level than expected
 end
 

lute/std/libs/syntax/types.luau

@@ -157,7 +157,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 {}

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

@@ -0,0 +1,3 @@
+{
+    "languageMode": "nocheck"
+}

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

@@ -0,0 +1,3 @@
+local sameLibrary = require(packagesRoot.sameLibrary)
+
+local result = sameLibrary.numFunc(1)

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

@@ -0,0 +1,3 @@
+local sameLibrary = require(packagesRoot.sameLibrary)
+
+local result = sameLibrary.processNumber(1)

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

@@ -0,0 +1,3 @@
+local sameLibrary = require(packagesRoot.sameLibrary)
+
+local result = sameLibrary.arrayFunc({ 1, 2, 3 })

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

@@ -0,0 +1,3 @@
+local sameLibrary = require(packagesRoot.sameLibrary)
+
+local result = sameLibrary.processArray(table.unpack({ 1, 2, 3 }))

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

@@ -0,0 +1,5 @@
+local sameLibrary = require(packagesRoot.sameLibrary)
+
+local a = sameLibrary.numFunc(42)
+local b = sameLibrary.arrayFunc({ 10, 20, 30 })
+local c = sameLibrary.stringFunc("hello")

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

@@ -0,0 +1,5 @@
+local sameLibrary = require(packagesRoot.sameLibrary)
+
+local a = sameLibrary.processNumber(42)
+local b = sameLibrary.processArray(table.unpack({ 10, 20, 30 }))
+local c = sameLibrary.handleText("hello")

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

@@ -0,0 +1,3 @@
+local sameLibrary = require(packagesRoot.sameLibrary)
+
+local result = sameLibrary.numFunc(sameLibrary.getCount())

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

@@ -0,0 +1,3 @@
+local sameLibrary = require(packagesRoot.sameLibrary)
+
+local result = sameLibrary.processNumber(sameLibrary.retrieveCount())

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

@@ -0,0 +1,49 @@
+local luau = require("@lute/luau")
+local utils = require("@std/syntax/utils")
+local printer = require("@std/syntax/printer")
+local qUtils = require("./utils")
+local tableext = require("@std/tableext")
+local query = require("@std/syntax/query")
+
+local apiMap = {
+	numFunc = "processNumber",
+	stringFunc = "handleText",
+	arrayFunc = "processArray",
+	processData = "handleData",
+	getCount = "retrieveCount",
+}
+
+local argReplacements = {
+	arrayFunc = function(arg: luau.AstExpr)
+		return `table.unpack({printer.printnode(arg :: any)})`
+	end,
+}
+
+local function transformCallArgs(block: luau.AstStatBlock)
+	local argNodeToFuncName = {} :: { [luau.AstNode]: string }
+	return query
+		.findallfromroot(block, utils.isExprCall)
+		:filter(function(node: luau.AstExprCall)
+			return node.func.index and argReplacements[node.func.index.text] ~= nil
+		end)
+		:map(function(node: luau.AstExprCall)
+			local arg = node.arguments[1].node
+			argNodeToFuncName[arg] = (node.func :: luau.AstExprIndexName).index.text
+			return arg
+		end)
+		:replace(function(node: luau.AstExpr)
+			return (argReplacements[argNodeToFuncName[node]] :: (luau.AstExpr) -> string)(node)
+		end)
+end
+
+local function transform(ctx)
+	local parseresult = ctx.parseresult
+	local block = parseresult.root
+	local libAccessReplacements = qUtils.transformLibraryAccess(block, "sameLibrary", function(expr, index: luau.Token)
+		return `{printer.printnode(expr :: any)}.{apiMap[index.text]}`
+	end)
+	local argReplacements = transformCallArgs(block)
+	return tableext.combine(libAccessReplacements, argReplacements)
+end
+
+return transform

tests/std/syntax/e2eCases/init.luau

@@ -0,0 +1,7 @@
+local types = require("./e2eCases/types")
+
+return {
+	libraryMigration = require("./e2eCases/libraryMigration"),
+	apiSurfaceChange = require("./e2eCases/apiSurfaceChange"),
+	roactToReact = require("./e2eCases/roactToReact"),
+} :: { [string]: types.e2e }

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

@@ -0,0 +1,3 @@
+{
+    "languageMode": "nocheck"
+}

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

@@ -0,0 +1,14 @@
+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

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

@@ -0,0 +1,14 @@
+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

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

@@ -0,0 +1,5 @@
+local oldLibraryDiffAlias = require(root.nested.packages.old)
+
+local myEl = oldLibraryDiffAlias.oldFunction("lol")
+
+return oldLibraryDiffAlias.anotherFunction(myEl)

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

@@ -0,0 +1,5 @@
+local newLibrary = require(root.nested.packages.new)
+
+local myEl = newLibrary.newFunction("lol")
+
+return newLibrary.anotherNewFunction(myEl)

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

@@ -0,0 +1,51 @@
+local types = require("@std/syntax/types")
+local utils = require("@std/syntax/utils")
+local qUtils = require("./utils")
+local query = require("@std/syntax/query")
+local tableext = require("@std/tableext")
+local getRequireStatements = qUtils.getRequireStatements
+local transformLibraryAccess = qUtils.transformLibraryAccess
+
+local functionMap = {
+	["oldFunction"] = "newFunction",
+	["anotherFunction"] = "anotherNewFunction",
+}
+
+local function transformRequires(block: types.AstStatBlock): (string, types.replacements)
+	local oldLibRequires = getRequireStatements(block, "old")
+
+	local requireArgRepl = query
+		.findallfromroot(oldLibRequires.nodes[1] :: types.AstNode, utils.isExprCall)
+		:map(function(node: types.AstExprCall): types.Token?
+			if utils.isExprIndexName(node.arguments[1].node) ~= nil then
+				return node.arguments[1].node.index
+			end
+			return nil
+		end)
+		:replace(function(node)
+			return "new"
+		end)
+
+	local oldLibVar = oldLibRequires.nodes[1].variables[1].node
+	local oldLibAlias = ""
+	local requiredVarAliasRepl = query
+		.findallfromroot(oldLibVar :: any, utils.isToken)
+		:replace(function(node: types.Token)
+			oldLibAlias = node.text
+			return "newLibrary"
+		end)
+	return oldLibAlias, tableext.combine(requireArgRepl, requiredVarAliasRepl)
+end
+
+local function transform(ctx): types.replacements
+	local parseresult = ctx.parseresult
+	local block = parseresult.root
+	local oldLibAlias, requireRepl = transformRequires(block)
+	local libAccessRepl = transformLibraryAccess(block, oldLibAlias, function(_, index)
+		local oldFunction = index.text
+		return `newLibrary.{functionMap[oldFunction]}`
+	end)
+	return tableext.combine(requireRepl, libAccessRepl)
+end
+
+return transform

tests/std/syntax/e2eCases/roactToReact/cases/.luaurc

@@ -0,0 +1,3 @@
+{
+    "languageMode": "nocheck"
+}

tests/std/syntax/e2eCases/roactToReact/cases/case1.luau

@@ -0,0 +1,3 @@
+local Roact = require(PackagesRoot.Roact)
+
+return Roact.createFragment(arbitraryElement)

tests/std/syntax/e2eCases/roactToReact/cases/case1.luau.expect

@@ -0,0 +1,3 @@
+local React = require(PackagesRoot.React)
+
+return React.createElement(React.Fragment, nil, arbitraryElement)

tests/std/syntax/e2eCases/roactToReact/cases/case2.luau

@@ -0,0 +1,3 @@
+local Roact = require(PackagesRoot.Roact)
+
+return Roact.createElement(arbitraryElement, nil, Roact.oneChild(otherArbitraryElement))

tests/std/syntax/e2eCases/roactToReact/cases/case2.luau.expect

@@ -0,0 +1,11 @@
+local React = require(PackagesRoot.React)
+
+return React.createElement(
+	arbitraryElement,
+	nil,
+	if not otherArbitraryElement
+			or not select(2, next(otherArbitraryElement))
+			or next(otherArbitraryElement, table.pack(select(1, next(otherArbitraryElement) :: string))[1])
+		then nil
+		else React.Children.only(select(2, next(otherArbitraryElement) :: any))
+)

tests/std/syntax/e2eCases/roactToReact/cases/case3.luau

@@ -0,0 +1,5 @@
+local Roact = require(PackagesRoot.Roact)
+
+return Roact.createElement(Roact.Portal, {
+	target = arbitraryRoot,
+}, children)

tests/std/syntax/e2eCases/roactToReact/cases/case3.luau.expect

@@ -0,0 +1,3 @@
+local ReactRoblox = require(PackagesRoot.ReactRoblox)
+
+return ReactRoblox.createPortal(children, arbitraryRoot)

tests/std/syntax/e2eCases/roactToReact/cases/case4.luau

@@ -0,0 +1,6 @@
+local Roact = require(PackagesRoot.Roact)
+
+return Roact.createElement(abitraryElement, {
+	[Roact.Ref] = arbitraryRef,
+	[Roact.Children] = arbitraryChildren,
+})

tests/std/syntax/e2eCases/roactToReact/cases/case4.luau.expect

@@ -0,0 +1,6 @@
+local React = require(PackagesRoot.React)
+
+return React.createElement(abitraryElement, {
+	ref = arbitraryRef,
+	children = arbitraryChildren,
+})

tests/std/syntax/e2eCases/roactToReact/cases/case5.luau

@@ -0,0 +1,4 @@
+local Roact = require(PackagesRoot.Roact)
+
+local instance = Roact.mount(element, nil, "Root")
+Roact.unmount(instance)

tests/std/syntax/e2eCases/roactToReact/cases/case5.luau.expect

@@ -0,0 +1,10 @@
+local ReactRoblox = require(PackagesRoot.ReactRoblox)
+
+local root = ReactRoblox.createRoot(Instance.new("Folder"))
+local actualParent = Instance.new("Folder")
+local actualKey = "Root"
+ReactRoblox.act(function()
+	root:render(ReactRoblox.createPortal({ [actualKey] = element } :: any, actualParent))
+end)
+local instance = { root = root, parent = actualParent, key = actualKey }
+instance.root:unmount()

tests/std/syntax/e2eCases/roactToReact/cases/case6.luau

@@ -0,0 +1,5 @@
+local Roact = require(PackagesRoot.Roact)
+
+local container = Instance.new("Folder")
+local instance = Roact.mount(arbitraryElement, container)
+Roact.update(instance, otherElement)

tests/std/syntax/e2eCases/roactToReact/cases/case6.luau.expect

@@ -0,0 +1,13 @@
+local ReactRoblox = require(PackagesRoot.ReactRoblox)
+
+local container = Instance.new("Folder")
+local root = ReactRoblox.createRoot(Instance.new("Folder"))
+local actualParent = container
+local actualKey = "ReactRoot"
+ReactRoblox.act(function()
+	root:render(ReactRoblox.createPortal({ [actualKey] = arbitraryElement } :: any, actualParent))
+end)
+local instance = { root = root, parent = actualParent, key = actualKey }
+ReactRoblox.act(function()
+	instance.root:render(ReactRoblox.createPortal({ [instance.key] = otherElement } :: any, instance.parent))
+end)