Sync to upstream/release/716 (luau-lang#2339)

Hi everyone! Another week, another release 🌺 🐰 

This week we've made some major performance boosts for property
accesses, feature fixes, as well as our regular bug fixes and
improvements!

### Analysis
* `Luau/OverloadResolution.h` has been renamed to
`Luau/OverloadResolver.h` (to match the struct name)
* Added syntax highlighting for the `const` keyword!
* Fixed an internal compiler error that could occur when type checking
erroneous uses of `const`, for example:

```luau
-- This is not a valid `const` declaration as we require that `const` declarations
-- have values, as it is almost certainly a mistake if they don't (as you cannot assign 
-- to them later). Previously this _also_ caused an ICE in the new solver, which is not
-- desirable.
const foobar

return foobar
```

* Fixed a bug that could result in function calls failing to type check
due to ungeneralized free types:
```luau
function add(a, b)
    return a + b
end
local vec2 = {}
function vec2.new(x, y)
    return setmetatable({ x = x or 0, y = y or 0 }, {
        __add = function(v1, v2)
            return { x = v1.x + v2.x, y = v1.y + v2.y }
        end,
    })
end
-- Prior, this would fail to type check and we'd get warnings
-- about ungeneralized types (`number <: 'a` isn't a subtype of blah)
local a = add(vec2.new(0, 0), vec2.new(1, 1))
```

* Fixed a bug where `type(x) == "vector"` always refined `x` to `never`:
```luau
local x: unknown

if type(x) == "vector" then
    local y = x -- Prior, x would be `never`
end
```

### Compiler & Runtime

* 10-30% performance improvement for Luau userdata property accesses via
new property descriptor bytecode caching
* Increased precision for `math.noise()`
* Fixed a bug where generic `for` loops were incorrectly optimized when
the global environment was modified
```luau
local env = getfenv(1)
env.next = {1, 2, 3} 

-- This will now disable `LOP_FORGPREP_NEXT` optimization, and run successfully
local ok, err = pcall(function() 
    for k, v in next, {} do end 
end)
```
* Added 64-bit Integer output to the AST Json Encoder, and fixed some
bugs from the initial implementation
* NCG: fixed an issue where certain fast-call sequences with multiple
return values could cause incorrect register tracking
* NCG: improved compiler performance by caching register tags and
computing them only when consumed by an instruction

### Miscellaneous

* Improved `lldb` debugger support by adding visualization for
`lua_State`, including a new `set_userdata_type_name` method to
configure the debugger for custom `userdata` structures.


--------------------------------------

Thank you to all our contributors this week!

Co-authored-by: Andy Friesen <afriesen@roblox.com>
Co-authored-by: David Cope <dcope@roblox.com>
Co-authored-by: Hunter Goldstein <hgoldstein@roblox.com>
Co-authored-by: Ilya Rezvov <irezvov@roblox.com>
Co-authored-by: Karl Rehm <krehm@roblox.com>
Co-authored-by: Simone Guggiari <sguggiari@roblox.com>
Co-authored-by: Thomas Schollenberger <tschollenberger@roblox.com>
Co-authored-by: Vyacheslav Egorov <vegorov@roblox.com>
Co-authored-by: @PhoenixWhitefire

---------

Co-authored-by: Vyacheslav Egorov <vegorov@roblox.com>
Co-authored-by: Ariel Weiss <arielweiss@roblox.com>
Co-authored-by: Andy Friesen <afriesen@roblox.com>
Co-authored-by: Hunter Goldstein <hgoldstein@roblox.com>
Co-authored-by: Varun Saini <61795485+vrn-sn@users.noreply.github.com>
Co-authored-by: Sora Kanosue <skanosue@roblox.com>

Author: 7 people

…alysis/include/Luau/OverloadResolution.h Analysis/include/Luau/OverloadResolver.hAnalysis/include/Luau/OverloadResolution.h renamed to Analysis/include/Luau/OverloadResolver.h Analysis/include/Luau/OverloadResolution.h renamed to Analysis/include/Luau/OverloadResolver.h

@@ -414,4 +414,16 @@ bool containsGeneric(TypePackId ty, NotNull<DenseHashSet<const void*>> generics)
  */
 bool isBlocked(TypeId ty);
 
+
+/**
+ * **YOU SHOULD PROBABLY NOT USE THIS FUNCTION.**
+ *
+ * This function is a stop-gap while we rework function call inference and
+ * eager generalization.
+ *
+ * @return An approximate return type of `ty`, assuming `ty` is a function or
+ *         union of functions.
+ */
+std::optional<TypePackId> getApproximateReturnTypeForFunctionCall(TypeId ty);
+
 } // namespace Luau

Analysis/include/Luau/TypeUtils.h

@@ -314,6 +314,18 @@ struct AstJsonEncoder : public AstVisitor
         );
     }
 
+    void write(class AstExprConstantInteger* node)
+    {
+        writeNode(
+            node,
+            "AstExprConstantInteger",
+            [&]()
+            {
+                write("value", node->value);
+            }
+        );
+    }
+
     void write(class AstExprConstantString* node)
     {
         writeNode(

Analysis/src/AstJsonEncoder.cpp

@@ -5,7 +5,7 @@
 #include "Luau/Common.h"
 #include "Luau/ConstraintSolver.h"
 #include "Luau/Instantiation.h"
-#include "Luau/OverloadResolution.h"
+#include "Luau/OverloadResolver.h"
 #include "Luau/Scope.h"
 #include "Luau/Simplify.h"
 #include "Luau/Subtyping.h"
@@ -20,7 +20,7 @@
 LUAU_DYNAMIC_FASTINT(LuauTypeFamilyApplicationCartesianProductLimit)
 LUAU_DYNAMIC_FASTINTVARIABLE(LuauStepRefineRecursionLimit, 64)
 
-LUAU_FASTFLAG(LuauOverloadGetsInstantiated)
+LUAU_FASTFLAG(LuauOverloadGetsInstantiated2)
 LUAU_FASTFLAGVARIABLE(LuauTypeFunctionsCaptureNestedInstances)
 LUAU_FASTFLAGVARIABLE(LuauTypeFunctionsAddFreeTypePackWithPositivePolarity)
 LUAU_FASTFLAGVARIABLE(LuauThreadUniferStateThroughTypeFunctionReduction)
@@ -171,20 +171,29 @@ static std::optional<TypePackId> solveFunctionCall(NotNull<TypeFunctionContext>
         return std::nullopt;
     }
 
-    if (!unifier.genericSubstitutions.empty() || !unifier.genericPackSubstitutions.empty())
+    if (FFlag::LuauOverloadGetsInstantiated2)
     {
-        Subtyping subtyping{ctx->builtins, ctx->arena, ctx->normalizer, ctx->typeFunctionRuntime, ctx->ice};
-        std::optional<TypePackId> subst = instantiate2(
-            ctx->arena, std::move(unifier.genericSubstitutions), std::move(unifier.genericPackSubstitutions), NotNull{&subtyping}, ctx->scope, retPack
-        );
-        if (!subst)
-            return std::nullopt;
-        else
+
+        if (!unifier.genericSubstitutions.empty() || !unifier.genericPackSubstitutions.empty())
+        {
+            Subtyping subtyping{ctx->builtins, ctx->arena, ctx->normalizer, ctx->typeFunctionRuntime, ctx->ice};
+            auto newRetTp = getApproximateReturnTypeForFunctionCall(*selected.overload).value_or(ctx->builtins->errorTypePack);
+
+            std::optional<TypePackId> subst = instantiate2(
+                ctx->arena,
+                std::move(unifier.genericSubstitutions),
+                std::move(unifier.genericPackSubstitutions),
+                NotNull{&subtyping},
+                ctx->scope,
+                newRetTp
+            );
+
+            if (!subst)
+                return std::nullopt;
+
             retPack = *subst;
-    }
+        }
 
-    if (FFlag::LuauOverloadGetsInstantiated)
-    {
         // After we solve for the instantiated function type of this metamethod,
         // we may have new free types if the metamethod was generic. We capture
         // these so that they can be generalized later and we don't end up with
@@ -195,6 +204,26 @@ static std::optional<TypePackId> solveFunctionCall(NotNull<TypeFunctionContext>
         for (const auto& tp : unifier.newFreshTypePacks)
             trackInteriorFreeTypePack(ctx->scope, tp);
     }
+    else
+    {
+
+        if (!unifier.genericSubstitutions.empty() || !unifier.genericPackSubstitutions.empty())
+        {
+            Subtyping subtyping{ctx->builtins, ctx->arena, ctx->normalizer, ctx->typeFunctionRuntime, ctx->ice};
+            std::optional<TypePackId> subst = instantiate2(
+                ctx->arena,
+                std::move(unifier.genericSubstitutions),
+                std::move(unifier.genericPackSubstitutions),
+                NotNull{&subtyping},
+                ctx->scope,
+                retPack
+            );
+            if (!subst)
+                return std::nullopt;
+            else
+                retPack = *subst;
+        }
+    }
 
     return retPack;
 }

Analysis/src/BuiltinTypeFunctions.cpp

@@ -15,7 +15,7 @@
 #include "Luau/IterativeTypeVisitor.h"
 #include "Luau/Location.h"
 #include "Luau/ModuleResolver.h"
-#include "Luau/OverloadResolution.h"
+#include "Luau/OverloadResolver.h"
 #include "Luau/RecursionCounter.h"
 #include "Luau/ScopedSeenSet.h"
 #include "Luau/Simplify.h"
@@ -47,7 +47,7 @@ LUAU_FASTFLAGVARIABLE(LuauUnifyWithSubtyping2)
 LUAU_FASTFLAG(LuauRelateHandlesCoincidentTables)
 LUAU_FASTFLAG(LuauUnpackRespectsAnnotations)
 LUAU_FASTFLAG(LuauReplacerRespectsReboundGenerics)
-LUAU_FASTFLAGVARIABLE(LuauOverloadGetsInstantiated)
+LUAU_FASTFLAGVARIABLE(LuauOverloadGetsInstantiated2)
 LUAU_FASTFLAGVARIABLE(LuauFollowInExplicitInstantiation)
 LUAU_FASTFLAGVARIABLE(LuauUseConstraintSetsToTrackFreeTypes)
 
@@ -1668,26 +1668,24 @@ bool ConstraintSolver::tryDispatch(const FunctionCallConstraint& c, NotNull<cons
             argsPack = arena->addTypePack(TypePack{{fn}, argsPack});
     }
 
-    if (!usedMagic)
+
+    if (FFlag::LuauOverloadGetsInstantiated2)
     {
-        emplace<FreeTypePack>(constraint, c.result, constraint->scope, Polarity::Positive);
-        trackInteriorFreeTypePack(constraint->scope, c.result);
-    }
+        TypePackId retTp = arena->freshTypePack(constraint->scope, Polarity::Positive);
+        trackInteriorFreeTypePack(constraint->scope, retTp);
 
-    TypeId inferredTy = arena->addType(FunctionType{TypeLevel{}, argsPack, c.result});
+        TypeId inferredTy = arena->addType(FunctionType{TypeLevel{}, argsPack, retTp});
 
-    Unifier2 u2{NotNull{arena}, builtinTypes, constraint->scope, NotNull{&iceReporter}};
+        Unifier2 u2{NotNull{arena}, builtinTypes, constraint->scope, NotNull{&iceReporter}};
 
-    // TODO: This should probably use ConstraintSolver::unify
-    const UnifyResult unifyResult = u2.unify(overloadToUse, inferredTy);
+        // TODO: This should probably use ConstraintSolver::unify
+        const UnifyResult unifyResult = u2.unify(overloadToUse, inferredTy);
 
-    for (TypeId freeTy : u2.newFreshTypes)
-        trackInteriorFreeType(constraint->scope, freeTy);
-    for (TypePackId freeTp : u2.newFreshTypePacks)
-        trackInteriorFreeTypePack(constraint->scope, freeTp);
+        for (TypeId freeTy : u2.newFreshTypes)
+            trackInteriorFreeType(constraint->scope, freeTy);
+        for (TypePackId freeTp : u2.newFreshTypePacks)
+            trackInteriorFreeTypePack(constraint->scope, freeTp);
 
-    if (FFlag::LuauOverloadGetsInstantiated)
-    {
         if (!u2.genericSubstitutions.empty() || !u2.genericPackSubstitutions.empty())
         {
             Subtyping subtyping{builtinTypes, arena, normalizer, typeFunctionRuntime, NotNull{&iceReporter}};
@@ -1714,77 +1712,62 @@ bool ConstraintSolver::tryDispatch(const FunctionCallConstraint& c, NotNull<cons
                 if (auto ft = get<FreeType>(ty))
                     hasBound |= !is<NeverType>(follow(ft->lowerBound)) || !is<UnknownType>(follow(ft->upperBound));
 
-            if (auto overloadAsFn = get<FunctionType>(overloadToUse))
+            // If we have generics we can bind *and* 
+            if (auto overloadAsFn = get<FunctionType>(overloadToUse); overloadAsFn && hasBound)
             {
-                if (hasBound)
-                {
-                    CloneState cs{builtinTypes};
-                    // We want to clone persistent types here, for example if we try to instantiate
-                    // `table.insert`
-                    auto clonedTy = shallowClone(overloadToUse, *arena, cs, true);
-                    auto clonedFn = getMutable<FunctionType>(clonedTy);
-                    LUAU_ASSERT(clonedFn);
-                    clonedFn->generics.clear();
-                    clonedFn->genericPacks.clear();
-                    // NOTE: This can be one call!
-                    if (auto inst = instantiate2(
-                            arena,
-                            // Intentional copy, could be by reference.
-                            std::move(u2.genericSubstitutions),
-                            // Intentional copy, could be by reference.
-                            std::move(u2.genericPackSubstitutions),
-                            NotNull{&subtyping},
-                            constraint->scope,
-                            clonedTy
-                        ))
-                    {
-                        auto instantiatedFn = get<FunctionType>(inst);
-                        LUAU_ASSERT(instantiatedFn);
-                        overloadToUse = *inst;
-                        result = follow(instantiatedFn->retTypes);
-                    }
-                    else
-                    {
-                        reportError(CodeTooComplex{}, constraint->location);
-                        result = builtinTypes->errorTypePack;
-                    }
-                }
-                else
-                {
-                    auto tp = instantiate2(
+                CloneState cs{builtinTypes};
+                // We want to clone persistent types here, for example if we try to instantiate
+                // `table.insert`
+                auto clonedTy = shallowClone(overloadToUse, *arena, cs, true);
+                auto clonedFn = getMutable<FunctionType>(clonedTy);
+                LUAU_ASSERT(clonedFn);
+                clonedFn->generics.clear();
+                clonedFn->genericPacks.clear();
+                if (auto inst = instantiate2(
                         arena,
+                        // Intentional copy, could be by reference.
                         std::move(u2.genericSubstitutions),
+                        // Intentional copy, could be by reference.
                         std::move(u2.genericPackSubstitutions),
                         NotNull{&subtyping},
                         constraint->scope,
-                        overloadAsFn->retTypes
-                    );
-                    if (tp)
-                        result = *tp;
-                    else
-                    {
-                        reportError(CodeTooComplex{}, constraint->location);
-                        result = builtinTypes->errorTypePack;
-                    }
+                        clonedTy
+                    ))
+                {
+                    auto instantiatedFn = get<FunctionType>(inst);
+                    LUAU_ASSERT(instantiatedFn);
+                    overloadToUse = *inst;
+                    retTp = follow(instantiatedFn->retTypes);
+                }
+                else
+                {
+                    reportError(CodeTooComplex{}, constraint->location);
+                    result = builtinTypes->errorTypePack;
                 }
             }
             else
             {
+                auto newRetTp = getApproximateReturnTypeForFunctionCall(overloadToUse)
+                    .value_or(builtinTypes->errorTypePack);
+
                 std::optional<TypePackId> subst = instantiate2(
-                    arena, std::move(u2.genericSubstitutions), std::move(u2.genericPackSubstitutions), NotNull{&subtyping}, constraint->scope, result
+                    arena,
+                    std::move(u2.genericSubstitutions),
+                    std::move(u2.genericPackSubstitutions),
+                    NotNull{&subtyping},
+                    constraint->scope,
+                    newRetTp
                 );
-                if (!subst)
-                {
-                    reportError(CodeTooComplex{}, constraint->location);
-                    result = builtinTypes->errorTypePack;
-                }
+
+                if (subst)
+                    retTp = *subst;
                 else
-                    result = *subst;
+                    reportError(CodeTooComplex{}, constraint->location);
             }
         }
 
-        if (c.result != result && !usedMagic)
-            emplaceTypePack<BoundTypePack>(asMutable(c.result), result);
+        if (!usedMagic)
+            bind(constraint, c.result, retTp);
 
         for (const auto& [expanded, additions] : u2.expandedFreeTypes)
         {
@@ -1811,9 +1794,32 @@ bool ConstraintSolver::tryDispatch(const FunctionCallConstraint& c, NotNull<cons
             reportError(OccursCheckFailed{}, constraint->location);
             break;
         }
+
+        InstantiationQueuer queuer{constraint->scope, constraint->location, this};
+        queuer.traverse(overloadToUse);
+        queuer.traverse(result);
+
     }
     else
     {
+        if (!usedMagic)
+        {
+            emplace<FreeTypePack>(constraint, c.result, constraint->scope, Polarity::Positive);
+            trackInteriorFreeTypePack(constraint->scope, c.result);
+        }
+
+        TypeId inferredTy = arena->addType(FunctionType{TypeLevel{}, argsPack, c.result});
+
+        Unifier2 u2{NotNull{arena}, builtinTypes, constraint->scope, NotNull{&iceReporter}};
+
+        // TODO: This should probably use ConstraintSolver::unify
+        const UnifyResult unifyResult = u2.unify(overloadToUse, inferredTy);
+
+        for (TypeId freeTy : u2.newFreshTypes)
+            trackInteriorFreeType(constraint->scope, freeTy);
+        for (TypePackId freeTp : u2.newFreshTypePacks)
+            trackInteriorFreeTypePack(constraint->scope, freeTp);
+
         if (!u2.genericSubstitutions.empty() || !u2.genericPackSubstitutions.empty())
         {
             Subtyping subtyping{builtinTypes, arena, normalizer, typeFunctionRuntime, NotNull{&iceReporter}};
@@ -1854,15 +1860,16 @@ bool ConstraintSolver::tryDispatch(const FunctionCallConstraint& c, NotNull<cons
                 break;
             }
         }
-    }
 
-    InstantiationQueuer queuer{constraint->scope, constraint->location, this};
-    queuer.traverse(overloadToUse);
-    queuer.traverse(inferredTy);
+        InstantiationQueuer queuer{constraint->scope, constraint->location, this};
+        queuer.traverse(overloadToUse);
+        queuer.traverse(inferredTy);
+
+        // This can potentially contain free types if the return type of
+        // `inferredTy` is never unified elsewhere.
+        trackInteriorFreeType(constraint->scope, inferredTy);
+    }
 
-    // This can potentially contain free types if the return type of
-    // `inferredTy` is never unified elsewhere.
-    trackInteriorFreeType(constraint->scope, inferredTy);
 
     unblock(c.result, constraint->location);
 
@@ -4049,7 +4056,7 @@ void ConstraintSolver::shiftReferences(TypeId source, TypeId target)
         if (auto sourcerefs = typeToConstraintSet.find(source); sourcerefs != typeToConstraintSet.end())
         {
             auto [targetrefs, _] = typeToConstraintSet.try_emplace(target, Set<const Constraint*>{nullptr});
-            
+
             // This is a little sketchy as we are iterating over a hash set.
             // It _should_ be fine as we aren't depending on the order here,
             // this is all just moving values into different hash sets.

Analysis/src/ConstraintSolver.cpp

@@ -8,7 +8,7 @@
 #include "Luau/TypeUtils.h"
 #include "Luau/VisitType.h"
 
-LUAU_FASTFLAG(LuauOverloadGetsInstantiated)
+LUAU_FASTFLAG(LuauOverloadGetsInstantiated2)
 
 namespace Luau
 {
@@ -28,7 +28,7 @@ ExpectedTypeVisitor::ExpectedTypeVisitor(
     , builtinTypes(builtinTypes)
     , rootScope(rootScope)
 {
-    LUAU_ASSERT(!FFlag::LuauOverloadGetsInstantiated);
+    LUAU_ASSERT(!FFlag::LuauOverloadGetsInstantiated2);
 }
 
 ExpectedTypeVisitor::ExpectedTypeVisitor(
@@ -48,7 +48,7 @@ ExpectedTypeVisitor::ExpectedTypeVisitor(
     , builtinTypes(builtinTypes)
     , rootScope(rootScope)
 {
-    LUAU_ASSERT(FFlag::LuauOverloadGetsInstantiated);
+    LUAU_ASSERT(FFlag::LuauOverloadGetsInstantiated2);
 }
 
 bool ExpectedTypeVisitor::visit(AstStatAssign* stat)
@@ -191,7 +191,7 @@ bool ExpectedTypeVisitor::visit(AstExprIndexExpr* expr)
 bool ExpectedTypeVisitor::visit(AstExprCall* expr)
 {
     TypeId* ty = nullptr;
-    if (FFlag::LuauOverloadGetsInstantiated)
+    if (FFlag::LuauOverloadGetsInstantiated2)
     {
         ty = astOverloadResolvedTypes->find(expr);
         if (!ty)