Sync to upstream/release/693 (#2021)

# New Solver
* Avoid bidirectional inference always forcing constraints for simple
code such as the example below. Fixes #2017.
```luau
type Suit = "Hearts" | "Spades" | "Clubs" | "Diamonds"

local getSuits(): { Suit }
    return { "Hearts", "Spades", "Clubs", "Diamonds" }
end
```
* Iterating over an empty pack, such as in the below example, should
error but still allow type inference to complete.
```luau
local function foo() end -- has type `() -> ()`
for _ in foo() do end -- Errors, as you can't iterate over `()`, but type inference still completes.
```
* Implement arity based overload selection: this allows for overloaded
functions with generics to more consistently infer reasonable results.
For example:
```luau
-- This code no longer errors  as we determine that the first overload to 
-- table.insert is what the author intended.
table.insert({} :: { any }, 42)
```
* Allow the`table` type to be a subtype of generic tables. This means
code like the following no longer raises a type error:
```luau
local function doSomething(t: unknown)
    if type(t) == "table" then
        -- Prior we would error as `table` is not a subtype of a generic table
        -- Also works with `pairs` and similar builtin functions.
        local foo, bar = next(t)
    end
end
```
* Descend into intersection types when performing bidirectional
inference, this allows us to correctly bidirectionally infer code like:
```luau
type A = { foo: "a" }
type B = { bar: "b" }
type AB = A & B
-- No longer errors as the literals "a" and "b" will be inferred to be their singleton types.
local t: AB = { foo = "a", bar = "b" }
```
* #2008
* Fix intersections between table types and extern types to preserve
intersections when either type contains an indexer, fixing a regression
introduced when trying to refine table and extern types more precisely:
```luau
function f(obj: { [any]: any }, functionName: string)
    if typeof(obj) == "userdata" then
        -- No longer errors as we still have a `class & { [any]: any }` rather than a `class`
        local _ = obj[functionName]
    end
end
```
* Separated recursion limits for different parts of the new solver. No
immediate changes, but this creates more tools to tamp down on stack
overflows without affecting other subsystems.

# Runtime
* Implement "stackless" `pcall` / `xpcall` in yieldable contexts: this
lets recursive calls to `pcall` nest further, erroring at the Luau call
stack limit (20000 calls as of this writing) rather than the C call
stack limit (200 calls as of this writing)

---

Co-authored-by: Ariel Weiss <[email protected]>
Co-authored-by: Hunter Goldstein <[email protected]>
Co-authored-by: Sora Kanosue <[email protected]>
Co-authored-by: Varun Saini <[email protected]>
Co-authored-by: Vighnesh Vijay <[email protected]>
Co-authored-by: Vyacheslav Egorov <[email protected]>

---------

Co-authored-by: Varun Saini <[email protected]>
Co-authored-by: Alexander Youngblood <[email protected]>
Co-authored-by: Menarul Alam <[email protected]>
Co-authored-by: Aviral Goel <[email protected]>
Co-authored-by: Vighnesh <[email protected]>
Co-authored-by: Vyacheslav Egorov <[email protected]>
Co-authored-by: Ariel Weiss <[email protected]>
Co-authored-by: Andy Friesen <[email protected]>

Author: 9 people

Analysis/include/Luau/BuiltinTypeFunctions.h

@@ -9,6 +9,8 @@ namespace Luau
 struct BuiltinTypeFunctions
 {
     BuiltinTypeFunctions();
+    BuiltinTypeFunctions(const BuiltinTypeFunctions&) = delete;
+    void operator=(const BuiltinTypeFunctions&) = delete;
 
     TypeFunction userFunc;
 
@@ -51,6 +53,6 @@ struct BuiltinTypeFunctions
     void addToScope(NotNull<TypeArena> arena, NotNull<Scope> scope) const;
 };
 
-const BuiltinTypeFunctions& builtinTypeFunctions();
+const BuiltinTypeFunctions& builtinTypeFunctions_DEPRECATED();
 
 } // namespace Luau

Analysis/include/Luau/Frontend.h

@@ -225,14 +225,19 @@ struct Frontend
     );
 
     // Batch module checking. Queue modules and check them together, retrieve results with 'getCheckResult'
-    // If provided, 'executeTask' function is allowed to call the 'task' function on any thread and return without waiting for 'task' to complete
+    // If provided, 'executeTasks' function is allowed to call any item in 'tasks' on any thread and return without waiting for them to complete
     void queueModuleCheck(const std::vector<ModuleName>& names);
     void queueModuleCheck(const ModuleName& name);
-    std::vector<ModuleName> checkQueuedModules(
+    std::vector<ModuleName> checkQueuedModules_DEPRECATED(
         std::optional<FrontendOptions> optionOverride = {},
         std::function<void(std::function<void()> task)> executeTask = {},
         std::function<bool(size_t done, size_t total)> progress = {}
     );
+    std::vector<ModuleName> checkQueuedModules(
+        std::optional<FrontendOptions> optionOverride = {},
+        std::function<void(std::vector<std::function<void()>> tasks)> executeTasks = {},
+        std::function<bool(size_t done, size_t total)> progress = {}
+    );
 
     std::optional<CheckResult> getCheckResult(const ModuleName& name, bool accumulateNested, bool forAutocomplete = false);
     std::vector<ModuleName> getRequiredScripts(const ModuleName& name);
@@ -270,7 +275,8 @@ struct Frontend
     void checkBuildQueueItems(std::vector<BuildQueueItem>& items);
     void recordItemResult(const BuildQueueItem& item);
     void performQueueItemTask(std::shared_ptr<BuildQueueWorkState> state, size_t itemPos);
-    void sendQueueItemTask(std::shared_ptr<BuildQueueWorkState> state, size_t itemPos);
+    void sendQueueItemTask_DEPRECATED(std::shared_ptr<BuildQueueWorkState> state, size_t itemPos);
+    void sendQueueItemTasks(std::shared_ptr<BuildQueueWorkState> state, const std::vector<size_t>& items);
     void sendQueueCycleItemTask(std::shared_ptr<BuildQueueWorkState> state);
 
     static LintResult classifyLints(const std::vector<LintWarning>& warnings, const Config& config);

Analysis/include/Luau/OverloadResolution.h

@@ -107,6 +107,18 @@ struct OverloadResolver
         std::optional<TypeId> failedSubTy,
         std::optional<TypeId> failedSuperTy
     ) const;
+
+    // Checks if the candidate args are arity-compatible with the desired parameters.
+    // Used during overload selection to do arity-based filtering of overloads.
+    // We do not accept nil in place of a generic unless that generic is explicitly optional.
+    bool isArityCompatible(TypePackId candidate, TypePackId desired, NotNull<BuiltinTypes> builtinTypes) const;
+
+    bool testFunctionTypeForOverloadSelection(
+        const FunctionType* ftv,
+        NotNull<DenseHashSet<TypeId>> uniqueTypes,
+        TypePackId argsPack,
+        bool useFreeTypeBounds
+    );
 };
 
 struct SolveResult

Analysis/include/Luau/Subtyping.h

@@ -269,7 +269,9 @@ struct Subtyping
     // TODO recursion limits
 
     SubtypingResult isSubtype(TypeId subTy, TypeId superTy, NotNull<Scope> scope);
-    SubtypingResult isSubtype(
+    SubtypingResult isSubtype(TypePackId subTp, TypePackId superTp, NotNull<Scope> scope, const std::vector<TypeId>& bindableGenerics);
+    // Clip with FFlagLuauPassBindableGenericsByReference
+    SubtypingResult isSubtype_DEPRECATED(
         TypePackId subTp,
         TypePackId superTp,
         NotNull<Scope> scope,

Analysis/include/Luau/TableLiteralInference.h

@@ -3,6 +3,7 @@
 #pragma once
 
 #include "Luau/Ast.h"
+#include "Luau/ConstraintSolver.h"
 #include "Luau/DenseHash.h"
 #include "Luau/NotNull.h"
 #include "Luau/TypeFwd.h"
@@ -27,8 +28,8 @@ struct PushTypeResult
 PushTypeResult pushTypeInto(
     NotNull<DenseHashMap<const AstExpr*, TypeId>> astTypes,
     NotNull<DenseHashMap<const AstExpr*, TypeId>> astExpectedTypes,
-    NotNull<BuiltinTypes> builtinTypes,
-    NotNull<TypeArena> arena,
+    NotNull<ConstraintSolver> solver,
+    NotNull<const Constraint> constraint,
     NotNull<Unifier2> unifier,
     NotNull<Subtyping> subtyping,
     TypeId expectedType,

Analysis/include/Luau/Type.h

@@ -38,6 +38,7 @@ struct TypeFun;
 struct Constraint;
 struct Subtyping;
 struct TypeChecker2;
+struct BuiltinTypeFunctions;
 
 enum struct SolverMode
 {
@@ -1000,6 +1001,7 @@ struct BuiltinTypes
     bool debugFreezeArena = false;
 
 public:
+    std::unique_ptr<BuiltinTypeFunctions> typeFunctions;
     const TypeId nilType;
     const TypeId numberType;
     const TypeId stringType;

Analysis/include/Luau/TypeUtils.h

@@ -336,6 +336,9 @@ bool isApproximatelyTruthyType(TypeId ty);
 // Unwraps any grouping expressions iteratively.
 AstExpr* unwrapGroup(AstExpr* expr);
 
+// Returns true if ty is optional, ie if it is a supertype of nil
+bool isOptionalType(TypeId ty, NotNull<BuiltinTypes> builtinTypes);
+
 // These are magic types used in `TypeChecker2` and `NonStrictTypeChecker`
 //
 // `_luau_print` causes it's argument to be printed out, as in:

Analysis/src/BuiltinDefinitions.cpp

@@ -35,6 +35,7 @@ LUAU_FASTFLAG(LuauSolverV2)
 LUAU_FASTFLAGVARIABLE(LuauTableCloneClonesType3)
 LUAU_FASTFLAG(LuauUseWorkspacePropToChooseSolver)
 LUAU_FASTFLAG(LuauEmplaceNotPushBack)
+LUAU_FASTFLAG(LuauBuiltinTypeFunctionsArentGlobal)
 
 namespace Luau
 {
@@ -368,8 +369,17 @@ void registerBuiltinGlobals(Frontend& frontend, GlobalTypes& globals, bool typeC
     NotNull<BuiltinTypes> builtinTypes = globals.builtinTypes;
     NotNull<Scope> globalScope{globals.globalScope.get()};
 
-    if (frontend.getLuauSolverMode() == SolverMode::New)
-        builtinTypeFunctions().addToScope(NotNull{&arena}, NotNull{globals.globalScope.get()});
+    if (FFlag::LuauBuiltinTypeFunctionsArentGlobal)
+    {
+        if (frontend.getLuauSolverMode() == SolverMode::New)
+            builtinTypes->typeFunctions->addToScope(NotNull{&arena}, NotNull{globals.globalScope.get()});
+    }
+    else
+    {
+        if (frontend.getLuauSolverMode() == SolverMode::New)
+            builtinTypeFunctions_DEPRECATED().addToScope(NotNull{&arena}, NotNull{globals.globalScope.get()});
+    }
+
 
     LoadDefinitionFileResult loadResult = frontend.loadDefinitionFile(
         globals, globals.globalScope, getBuiltinDefinitionSource(), "@luau", /* captureComments */ false, typeCheckForAutocomplete
@@ -438,7 +448,13 @@ void registerBuiltinGlobals(Frontend& frontend, GlobalTypes& globals, bool typeC
     if (frontend.getLuauSolverMode() == SolverMode::New)
     {
         // getmetatable : <T>(T) -> getmetatable<T>
-        TypeId getmtReturn = arena.addType(TypeFunctionInstanceType{builtinTypeFunctions().getmetatableFunc, {genericT}});
+        TypeId getmtReturn = arena.addType(
+            TypeFunctionInstanceType{
+                FFlag::LuauBuiltinTypeFunctionsArentGlobal ? builtinTypes->typeFunctions->getmetatableFunc
+                                                           : builtinTypeFunctions_DEPRECATED().getmetatableFunc,
+                {genericT}
+            }
+        );
         addGlobalBinding(globals, "getmetatable", makeFunction(arena, std::nullopt, {genericT}, {}, {genericT}, {getmtReturn}), "@luau");
     }
     else
@@ -450,7 +466,13 @@ void registerBuiltinGlobals(Frontend& frontend, GlobalTypes& globals, bool typeC
     if (frontend.getLuauSolverMode() == SolverMode::New)
     {
         // setmetatable<T: {}, MT>(T, MT) -> setmetatable<T, MT>
-        TypeId setmtReturn = arena.addType(TypeFunctionInstanceType{builtinTypeFunctions().setmetatableFunc, {genericT, genericMT}});
+        TypeId setmtReturn = arena.addType(
+            TypeFunctionInstanceType{
+                FFlag::LuauBuiltinTypeFunctionsArentGlobal ? builtinTypes->typeFunctions->setmetatableFunc
+                                                           : builtinTypeFunctions_DEPRECATED().setmetatableFunc,
+                {genericT, genericMT}
+            }
+        );
         addGlobalBinding(
             globals, "setmetatable", makeFunction(arena, std::nullopt, {genericT, genericMT}, {}, {genericT, genericMT}, {setmtReturn}), "@luau"
         );
@@ -482,7 +504,12 @@ void registerBuiltinGlobals(Frontend& frontend, GlobalTypes& globals, bool typeC
         TypeId genericT = arena.addType(GenericType{globalScope, "T"});
         TypeId refinedTy = arena.addType(
             TypeFunctionInstanceType{
-                NotNull{&builtinTypeFunctions().intersectFunc}, {genericT, arena.addType(NegationType{builtinTypes->falsyType})}, {}
+                NotNull{
+                    FFlag::LuauBuiltinTypeFunctionsArentGlobal ? &builtinTypes->typeFunctions->intersectFunc
+                                                               : &builtinTypeFunctions_DEPRECATED().intersectFunc
+                },
+                {genericT, arena.addType(NegationType{builtinTypes->falsyType})},
+                {}
             }
         );
 

Analysis/src/BuiltinTypeFunctions.cpp

@@ -29,6 +29,8 @@ LUAU_FASTFLAG(LuauEGFixGenericsList)
 LUAU_FASTFLAG(LuauExplicitSkipBoundTypes)
 LUAU_FASTFLAG(LuauRawGetHandlesNil)
 LUAU_FASTFLAG(LuauNoMoreComparisonTypeFunctions)
+LUAU_FASTFLAGVARIABLE(LuauBuiltinTypeFunctionsArentGlobal)
+LUAU_FASTFLAG(LuauPassBindableGenericsByReference)
 
 namespace Luau
 {
@@ -110,7 +112,10 @@ std::optional<TypeFunctionReductionResult<TypeId>> tryDistributeTypeFunctionApp(
 
         TypeId resultTy = ctx->arena->addType(
             TypeFunctionInstanceType{
-                NotNull{&builtinTypeFunctions().unionFunc},
+                NotNull{
+                    FFlag::LuauBuiltinTypeFunctionsArentGlobal ? &ctx->builtins->typeFunctions->unionFunc
+                                                               : &builtinTypeFunctions_DEPRECATED().unionFunc
+                },
                 std::move(results),
                 {},
             }
@@ -238,7 +243,12 @@ TypeFunctionReductionResult<TypeId> lenTypeFunction(
         return {std::nullopt, Reduction::Erroneous, {}, {}}; // occurs check failed
 
     Subtyping subtyping{ctx->builtins, ctx->arena, ctx->simplifier, ctx->normalizer, ctx->typeFunctionRuntime, ctx->ice};
-    if (!subtyping.isSubtype(inferredArgPack, instantiatedMmFtv->argTypes, ctx->scope).isSubtype) // TODO: is this the right variance?
+    if (FFlag::LuauPassBindableGenericsByReference)
+    {
+        if (!subtyping.isSubtype(inferredArgPack, instantiatedMmFtv->argTypes, ctx->scope, {}).isSubtype)
+            return {std::nullopt, Reduction::Erroneous, {}, {}};
+    }
+    else if (!subtyping.isSubtype_DEPRECATED(inferredArgPack, instantiatedMmFtv->argTypes, ctx->scope).isSubtype) // TODO: is this the right variance?
         return {std::nullopt, Reduction::Erroneous, {}, {}};
 
     // `len` must return a `number`.
@@ -322,7 +332,13 @@ TypeFunctionReductionResult<TypeId> unmTypeFunction(
     if (!FFlag::LuauEGFixGenericsList)
     {
         Subtyping subtyping{ctx->builtins, ctx->arena, ctx->simplifier, ctx->normalizer, ctx->typeFunctionRuntime, ctx->ice};
-        if (!subtyping.isSubtype(inferredArgPack, instantiatedMmFtv->argTypes, ctx->scope).isSubtype) // TODO: is this the right variance?
+        if (FFlag::LuauPassBindableGenericsByReference)
+        {
+            if (!subtyping.isSubtype(inferredArgPack, instantiatedMmFtv->argTypes, ctx->scope, {}).isSubtype)
+                return {std::nullopt, Reduction::Erroneous, {}, {}};
+        }
+        else if (!subtyping.isSubtype_DEPRECATED(inferredArgPack, instantiatedMmFtv->argTypes, ctx->scope)
+                      .isSubtype) // TODO: is this the right variance?
             return {std::nullopt, Reduction::Erroneous, {}, {}};
     }
 
@@ -679,7 +695,12 @@ TypeFunctionReductionResult<TypeId> concatTypeFunction(
         return {std::nullopt, Reduction::Erroneous, {}, {}}; // occurs check failed
 
     Subtyping subtyping{ctx->builtins, ctx->arena, ctx->simplifier, ctx->normalizer, ctx->typeFunctionRuntime, ctx->ice};
-    if (!subtyping.isSubtype(inferredArgPack, instantiatedMmFtv->argTypes, ctx->scope).isSubtype) // TODO: is this the right variance?
+    if (FFlag::LuauPassBindableGenericsByReference)
+    {
+        if (!subtyping.isSubtype(inferredArgPack, instantiatedMmFtv->argTypes, ctx->scope, {}).isSubtype)
+            return {std::nullopt, Reduction::Erroneous, {}, {}};
+    }
+    else if (!subtyping.isSubtype_DEPRECATED(inferredArgPack, instantiatedMmFtv->argTypes, ctx->scope).isSubtype) // TODO: is this the right variance?
         return {std::nullopt, Reduction::Erroneous, {}, {}};
 
     return {ctx->builtins->stringType, Reduction::MaybeOk, {}, {}};
@@ -888,7 +909,12 @@ static TypeFunctionReductionResult<TypeId> comparisonTypeFunction(
         return {std::nullopt, Reduction::Erroneous, {}, {}}; // occurs check failed
 
     Subtyping subtyping{ctx->builtins, ctx->arena, ctx->simplifier, ctx->normalizer, ctx->typeFunctionRuntime, ctx->ice};
-    if (!subtyping.isSubtype(inferredArgPack, instantiatedMmFtv->argTypes, ctx->scope).isSubtype) // TODO: is this the right variance?
+    if (FFlag::LuauPassBindableGenericsByReference)
+    {
+        if (!subtyping.isSubtype(inferredArgPack, instantiatedMmFtv->argTypes, ctx->scope, {}).isSubtype)
+            return {std::nullopt, Reduction::Erroneous, {}, {}};
+    }
+    else if (!subtyping.isSubtype_DEPRECATED(inferredArgPack, instantiatedMmFtv->argTypes, ctx->scope).isSubtype) // TODO: is this the right variance?
         return {std::nullopt, Reduction::Erroneous, {}, {}};
 
     return {ctx->builtins->booleanType, Reduction::MaybeOk, {}, {}};
@@ -1017,7 +1043,12 @@ TypeFunctionReductionResult<TypeId> eqTypeFunction(
         return {std::nullopt, Reduction::Erroneous, {}, {}}; // occurs check failed
 
     Subtyping subtyping{ctx->builtins, ctx->arena, ctx->simplifier, ctx->normalizer, ctx->typeFunctionRuntime, ctx->ice};
-    if (!subtyping.isSubtype(inferredArgPack, instantiatedMmFtv->argTypes, ctx->scope).isSubtype) // TODO: is this the right variance?
+    if (FFlag::LuauPassBindableGenericsByReference)
+    {
+        if (!subtyping.isSubtype(inferredArgPack, instantiatedMmFtv->argTypes, ctx->scope, {}).isSubtype)
+            return {std::nullopt, Reduction::Erroneous, {}, {}};
+    }
+    else if (!subtyping.isSubtype_DEPRECATED(inferredArgPack, instantiatedMmFtv->argTypes, ctx->scope).isSubtype) // TODO: is this the right variance?
         return {std::nullopt, Reduction::Erroneous, {}, {}};
 
     return {ctx->builtins->booleanType, Reduction::MaybeOk, {}, {}};
@@ -1575,11 +1606,23 @@ struct CollectUnionTypeOptions : TypeOnceVisitor
 
     bool visit(TypeId ty, const TypeFunctionInstanceType& tfit) override
     {
-        if (tfit.function->name != builtinTypeFunctions().unionFunc.name)
+        if (FFlag::LuauBuiltinTypeFunctionsArentGlobal)
         {
-            options.insert(ty);
-            blockingTypes.insert(ty);
-            return false;
+            if (tfit.function->name != ctx->builtins->typeFunctions->unionFunc.name)
+            {
+                options.insert(ty);
+                blockingTypes.insert(ty);
+                return false;
+            }
+        }
+        else
+        {
+            if (tfit.function->name != builtinTypeFunctions_DEPRECATED().unionFunc.name)
+            {
+                options.insert(ty);
+                blockingTypes.insert(ty);
+                return false;
+            }
         }
         return true;
     }
@@ -2031,8 +2074,16 @@ bool searchPropsAndIndexer(
         if (auto tfit = get<TypeFunctionInstanceType>(indexType))
         {
             // if we have an index function here, it means we're in a cycle, so let's see if it's well-founded if we tie the knot
-            if (tfit->function.get() == &builtinTypeFunctions().indexFunc)
-                indexType = follow(tblIndexer->indexResultType);
+            if (FFlag::LuauBuiltinTypeFunctionsArentGlobal)
+            {
+                if (tfit->function.get() == &ctx->builtins->typeFunctions->indexFunc)
+                    indexType = follow(tblIndexer->indexResultType);
+            }
+            else
+            {
+                if (tfit->function.get() == &builtinTypeFunctions_DEPRECATED().indexFunc)
+                    indexType = follow(tblIndexer->indexResultType);
+            }
         }
 
         if (isSubtype(ty, indexType, ctx->scope, ctx->builtins, ctx->simplifier, *ctx->ice, SolverMode::New))
@@ -2677,7 +2728,8 @@ void BuiltinTypeFunctions::addToScope(NotNull<TypeArena> arena, NotNull<Scope> s
     scope->exportedTypeBindings[getmetatableFunc.name] = mkUnaryTypeFunction(&getmetatableFunc);
 }
 
-const BuiltinTypeFunctions& builtinTypeFunctions()
+
+const BuiltinTypeFunctions& builtinTypeFunctions_DEPRECATED()
 {
     static std::unique_ptr<const BuiltinTypeFunctions> result = std::make_unique<BuiltinTypeFunctions>();