Sync to upstream/release/709 (luau-lang#2253)

We skipped the release last week, but we're back today with some new
additions to the VM and Native Code Generation (and as always,
improvements to typechecking).

## Analysis

- Fixed some instances of "unreduced table types" like { x: number } | {
x: number }, especially for data-like arrays (extremely large tables
that have the same element of a given type).

```luau
-- Prior, hovering would claim `t: {{number} | {number}}`, and now
-- we will claim it is a `{{number}}`
local t = {
    {1, 2, 3},
    {4, 5, 6}
}
```
- Fixed a bug where user defined type function could crash if passed too
many arguments.
- Enables autocomplete to use type information for function arguments to
suggest results when those types are variadic. For example:
```luau
local function foo(...: "Val1") end
foo(@1)
```
will now suggest "Val1"

- Partially annotated local statements with type packs on the
right-hand-side (see example) are now correctly inferred. Prior, we
mishandled this case in a way that caused subsequent assignments to
assume the first element of the type pack corresponded to the first
unannotated element:
```luau
local function foo(): (number, boolean, string)
    return 1, true "three"
end

-- Prior to this fix, we inferred that `y: number` for this statement ...
local x: number, y, z: string = foo()
--  ... similarly, this would have inferred `z: number` ...
local x: number, y: boolean, z = foo()
--  ... and this would have inferred `y: number` and `z: boolean`
local x: number, y, z = foo()
```
## VM
- Fix a use-after-free in `table.find`.

## Native Code Generation
- Fix a bug in NCG caused by using an incorrect operand in a buffer
length check.
- NCG now unmaps executable pages when functions are garbage-collected.
- Provide a native implementation for `math.isnan`

---
Co-authored-by: Hunter Goldstein <hgoldstein@roblox.com>
Co-authored-by: Ilya Rezvov <irezvov@roblox.com>
Co-authored-by: Sora Kanosue <skanosue@roblox.com>
Co-authored-by: Varun Saini <vsaini@roblox.com>
Co-authored-by: Vyacheslav Egorov <vegorov@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: Alexander Youngblood <ayoungblood@roblox.com>
Co-authored-by: Menarul Alam <malam@roblox.com>
Co-authored-by: Aviral Goel <agoel@roblox.com>
Co-authored-by: Vyacheslav Egorov <vegorov@roblox.com>
Co-authored-by: Ariel Weiss <aaronweiss@roblox.com>
Co-authored-by: Andy Friesen <afriesen@roblox.com>
Co-authored-by: Ilya Rezvov <irezvov@roblox.com>
Co-authored-by: Ariel Weiss <arielweiss@roblox.com>
Co-authored-by: Sora Kanosue <skanosue@roblox.com>
Co-authored-by: Varun Saini <vsaini@roblox.com>

Author: 11 people

Analysis/src/AutocompleteCore.cpp

@@ -26,7 +26,7 @@
 LUAU_FASTINT(LuauTypeInferIterationLimit)
 LUAU_FASTINT(LuauTypeInferRecursionLimit)
 LUAU_FASTFLAGVARIABLE(DebugLuauMagicVariableNames)
-LUAU_FASTFLAGVARIABLE(LuauAutocompleteSingletonsInIndexer)
+LUAU_FASTFLAGVARIABLE(LuauAutocompleteFunctionCallArgTails)
 
 static constexpr std::array<std::string_view, 12> kStatementStartingKeywords =
     {"while", "if", "local", "repeat", "function", "do", "for", "return", "break", "continue", "type", "export"};
@@ -141,6 +141,8 @@ static std::optional<TypeId> findExpectedTypeAt(const Module& module, AstNode* n
 
             if (index < head.size())
                 return head[index];
+            else if (FFlag::LuauAutocompleteFunctionCallArgTails && index == head.size() && tail.has_value() && isVariadic(*tail))
+                return first(*tail);
 
             return std::nullopt;
         }
@@ -423,7 +425,7 @@ static void autocompleteProps(
     else if (auto tbl = get<TableType>(ty))
     {
         fillProps(tbl->props);
-        if (FFlag::LuauAutocompleteSingletonsInIndexer && tbl->indexer && indexType == PropIndexType::Point)
+        if (tbl->indexer && indexType == PropIndexType::Point)
         {
             auto indexerTy = follow(tbl->indexer->indexType);
             if (auto utv = get<UnionType>(indexerTy))

Analysis/src/BuiltinTypeFunctions.cpp

@@ -22,7 +22,6 @@ LUAU_DYNAMIC_FASTINTVARIABLE(LuauStepRefineRecursionLimit, 64)
 
 LUAU_FASTFLAG(LuauInstantiationUsesGenericPolarity2)
 LUAU_FASTFLAGVARIABLE(LuauBuiltinTypeFunctionsUseNewOverloadResolution)
-LUAU_FASTFLAGVARIABLE(LuauSetmetatableWaitForPendingTypes)
 LUAU_FASTFLAGVARIABLE(LuauTypeFunctionsUseSolveFunctionCall)
 
 namespace Luau
@@ -2431,11 +2430,8 @@ TypeFunctionReductionResult<TypeId> setmetatableTypeFunction(
     TypeId targetTy = follow(typeParams.at(0));
     TypeId metatableTy = follow(typeParams.at(1));
 
-    if (FFlag::LuauSetmetatableWaitForPendingTypes)
-    {
-        if (isPending(targetTy, ctx->solver))
-            return {std::nullopt, Reduction::MaybeOk, {targetTy}, {}};
-    }
+    if (isPending(targetTy, ctx->solver))
+        return {std::nullopt, Reduction::MaybeOk, {targetTy}, {}};
 
     std::shared_ptr<const NormalizedType> targetNorm = ctx->normalizer->normalize(targetTy);
 
@@ -2453,11 +2449,8 @@ TypeFunctionReductionResult<TypeId> setmetatableTypeFunction(
         targetNorm->hasExternTypes())
         return {std::nullopt, Reduction::Erroneous, {}, {}};
 
-    if (FFlag::LuauSetmetatableWaitForPendingTypes)
-    {
-        if (isPending(metatableTy, ctx->solver))
-            return {std::nullopt, Reduction::MaybeOk, {metatableTy}, {}};
-    }
+    if (isPending(metatableTy, ctx->solver))
+        return {std::nullopt, Reduction::MaybeOk, {metatableTy}, {}};
 
     // if the supposed metatable is not a table, we will fail to reduce.
     if (!get<TableType>(metatableTy) && !get<MetatableType>(metatableTy))

Analysis/src/ConstraintGenerator.cpp

@@ -41,12 +41,12 @@ LUAU_FASTINTVARIABLE(LuauPrimitiveInferenceInTableLimit, 500)
 LUAU_FASTFLAG(LuauExplicitTypeInstantiationSyntax)
 LUAU_FASTFLAG(LuauExplicitTypeInstantiationSupport)
 LUAU_FASTFLAG(LuauPushTypeConstraintLambdas3)
-LUAU_FASTFLAGVARIABLE(LuauAvoidMintingMultipleBlockedTypesForGlobals)
 LUAU_FASTFLAGVARIABLE(LuauPropagateTypeAnnotationsInForInLoops)
 LUAU_FASTFLAGVARIABLE(LuauStorePolarityInline)
 LUAU_FASTFLAGVARIABLE(LuauDontIncludeVarargWithAnnotation)
 LUAU_FASTFLAGVARIABLE(LuauUdtfIndirectAliases)
 LUAU_FASTFLAGVARIABLE(LuauDisallowRedefiningBuiltinTypes)
+LUAU_FASTFLAGVARIABLE(LuauUnpackRespectsAnnotations)
 
 namespace Luau
 {
@@ -1152,6 +1152,8 @@ ControlFlow ConstraintGenerator::visit(const ScopePtr& scope, AstStatLocal* stat
     std::vector<TypeId> deferredTypes;
     auto [head, tail] = flatten(rvaluePack);
 
+    DenseHashSet<BlockedType*> freshBlockedTypes{nullptr};
+
     for (size_t i = 0; i < statLocal->vars.size; ++i)
     {
         LUAU_ASSERT(get<BlockedType>(assignees[i]));
@@ -1161,6 +1163,8 @@ ControlFlow ConstraintGenerator::visit(const ScopePtr& scope, AstStatLocal* stat
         if (statLocal->vars.data[i]->annotation)
         {
             localDomain->insert(annotatedTypes[i]);
+            if (FFlag::LuauUnpackRespectsAnnotations && i >= head.size() && tail)
+                deferredTypes.emplace_back(annotatedTypes[i]);
         }
         else
         {
@@ -1172,6 +1176,8 @@ ControlFlow ConstraintGenerator::visit(const ScopePtr& scope, AstStatLocal* stat
             {
                 deferredTypes.push_back(arena->addType(BlockedType{}));
                 localDomain->insert(deferredTypes.back());
+                if (FFlag::LuauUnpackRespectsAnnotations)
+                    freshBlockedTypes.insert(getMutable<BlockedType>(deferredTypes.back()));
             }
             else
             {
@@ -1201,8 +1207,19 @@ ControlFlow ConstraintGenerator::visit(const ScopePtr& scope, AstStatLocal* stat
             }
         );
 
-        for (TypeId t : deferredTypes)
-            getMutable<BlockedType>(t)->setOwner(uc);
+        if (FFlag::LuauUnpackRespectsAnnotations)
+        {
+            // This is a separate set from `deferredTypes` to
+            // distinguish between blocked types we just minted
+            // and blocked types that correspond to annotations.
+            for (BlockedType* bt : freshBlockedTypes)
+                bt->setOwner(uc);
+        }
+        else
+        {
+            for (TypeId t : deferredTypes)
+                getMutable<BlockedType>(t)->setOwner(uc);
+        }
     }
 
     if (statLocal->vars.size == 1 && statLocal->values.size == 1 && firstValueType && scope.get() == rootScope && !hasAnnotation)
@@ -4507,7 +4524,7 @@ struct GlobalPrepopulator : AstVisitor
                 if (!globalScope->lookup(g->name))
                     globalScope->globalsToWarn.insert(g->name.value);
 
-                if (!FFlag::LuauAvoidMintingMultipleBlockedTypesForGlobals || globalScope->bindings.find(g->name) == globalScope->bindings.end())
+                if (globalScope->bindings.find(g->name) == globalScope->bindings.end())
                 {
                     TypeId bt = arena->addType(BlockedType{});
                     globalScope->bindings[g->name] = Binding{bt, g->location};

Analysis/src/ConstraintSolver.cpp

@@ -50,6 +50,8 @@ LUAU_FASTFLAGVARIABLE(LuauUseFastSubtypeForIndexerWithName)
 LUAU_FASTFLAGVARIABLE(LuauUnifyWithSubtyping2)
 LUAU_FASTFLAGVARIABLE(LuauDoNotUseApplyTypeFunctionToClone)
 LUAU_FASTFLAGVARIABLE(LuauReworkInfiniteTypeFinder)
+LUAU_FASTFLAG(LuauRelateHandlesCoincidentTables)
+LUAU_FASTFLAG(LuauUnpackRespectsAnnotations)
 
 namespace Luau
 {
@@ -1016,6 +1018,9 @@ bool ConstraintSolver::tryDispatch(const GeneralizationConstraint& c, NotNull<co
             }
             else if (get<TableType>(ty))
                 sealTable(constraint->scope, ty);
+
+            if (FFlag::LuauRelateHandlesCoincidentTables)
+                unblock(ty, constraint->location);
         }
     }
 
@@ -2574,11 +2579,16 @@ bool ConstraintSolver::tryDispatch(const UnpackConstraint& c, NotNull<const Cons
         TypeId srcTy = follow(srcPack.head[i]);
         TypeId resultTy = follow(*resultIter);
 
-        LUAU_ASSERT(get<BlockedType>(resultTy));
-        LUAU_ASSERT(canMutate(resultTy, constraint));
+        if (!FFlag::LuauUnpackRespectsAnnotations)
+        {
+            LUAU_ASSERT(get<BlockedType>(resultTy));
+            LUAU_ASSERT(canMutate(resultTy, constraint));
+        }
 
         if (get<BlockedType>(resultTy))
         {
+            if (FFlag::LuauUnpackRespectsAnnotations)
+                LUAU_ASSERT(canMutate(resultTy, constraint));
             if (follow(srcTy) == resultTy)
             {
                 // It is sometimes the case that we find that a blocked type
@@ -2765,6 +2775,15 @@ struct FindAllUnionMembers : TypeOnceVisitor
     {
         return true;
     }
+
+    bool visit(TypeId ty, const TableType& tbl) override
+    {
+        if (FFlag::LuauRelateHandlesCoincidentTables && tbl.state != TableState::Sealed)
+            blockedTys.insert(ty);
+        else
+            recordedTys.insert(ty);
+        return false;
+    }
 };
 
 bool ConstraintSolver::tryDispatch(const SimplifyConstraint& c, NotNull<const Constraint> constraint, bool force)

Analysis/src/EmbeddedBuiltinDefinitions.cpp

@@ -1,7 +1,6 @@
 // This file is part of the Luau programming language and is licensed under MIT License; see LICENSE.txt for details
 #include "Luau/BuiltinDefinitions.h"
 
-LUAU_FASTFLAGVARIABLE(LuauUseTopTableForTableClearAndIsFrozen)
 LUAU_FASTFLAGVARIABLE(LuauTypeCheckerUdtfRenameClassToExtern)
 LUAU_FASTFLAGVARIABLE(LuauMorePermissiveNewtableType)
 
@@ -184,31 +183,6 @@ declare coroutine: {
     close: @checked (co: thread) -> (boolean, any)
 }
 
-)BUILTIN_SRC";
-static constexpr const char* kBuiltinDefinitionTableSrc_DEPRECATED = R"BUILTIN_SRC(
-
-declare table: {
-    concat: <V>(t: {V}, sep: string?, i: number?, j: number?) -> string,
-    insert: (<V>(t: {V}, value: V) -> ()) & (<V>(t: {V}, pos: number, value: V) -> ()),
-    maxn: <V>(t: {V}) -> number,
-    remove: <V>(t: {V}, number?) -> V?,
-    sort: <V>(t: {V}, comp: ((V, V) -> boolean)?) -> (),
-    create: <V>(count: number, value: V?) -> {V},
-    find: <V>(haystack: {V}, needle: V, init: number?) -> number?,
-
-    unpack: <V>(list: {V}, i: number?, j: number?) -> ...V,
-    pack: <V>(...V) -> { n: number, [number]: V },
-
-    getn: <V>(t: {V}) -> number,
-    foreach: <K, V>(t: {[K]: V}, f: (K, V) -> ()) -> (),
-    foreachi: <V>({V}, (number, V) -> ()) -> (),
-
-    move: <V>(src: {V}, a: number, b: number, t: number, dst: {V}?) -> {V},
-    clear: <K, V>(table: {[K]: V}) -> (),
-
-    isfrozen: <K, V>(t: {[K]: V}) -> boolean,
-}
-
 )BUILTIN_SRC";
 
 static constexpr const char* kBuiltinDefinitionTableSrc = R"BUILTIN_SRC(
@@ -331,14 +305,7 @@ std::string getBuiltinDefinitionSource()
     result += kBuiltinDefinitionMathSrc;
     result += kBuiltinDefinitionOsSrc;
     result += kBuiltinDefinitionCoroutineSrc;
-    if (FFlag::LuauUseTopTableForTableClearAndIsFrozen)
-    {
-        result += kBuiltinDefinitionTableSrc;
-    }
-    else
-    {
-        result += kBuiltinDefinitionTableSrc_DEPRECATED;
-    }
+    result += kBuiltinDefinitionTableSrc;
     result += kBuiltinDefinitionDebugSrc;
     result += kBuiltinDefinitionUtf8Src;
     result += kBuiltinDefinitionBufferSrc;