Sync to upstream/release/699 (#2082)

Hello all! Another week, another release!

# Analysis

* Fixed `table.clone` in the old solver to ensure intersections of
tables were being entirely cloned: prior only the _first_ table in the
intersection would be copied:
```luau
type FIRST = { some: string }
type SECOND = FIRST & { thing: string }
local b: SECOND
-- c's type used to be FIRST, but should be the full type of SECOND
local c = table.clone(b)
```
* Fixed `table.clone` in the old solver to be more permissive and treat
a variadic return as having _at least_ one element. This works around
some unfortunate behavior in the old solver version of nonstrict mode,
see:
```luau
-- A.luau
--!nonstrict
return function()
    return {}
end
-- B.luau
local A = require("A")
-- This line would previously error as `A` has type `() -> (...any)`, so
-- we might not be providing enough parameters to `table.clone`.
local _ = table.clone(A())
```
* Fixed a bug in the new solver where error suppression was not kicking
in for indexing, as in:
```luau
local function f(value: any)
    if value ~= nil then
        for k = 1, #value do
            -- Previously this would error, claiming you cannot index into a `*error-type* | ~nil`
            local _ = value[k]
        end
    end
end
```
* Fix the `getmetatable` type function in the new solver to accept
`*error-type*` and `table` as valid type inputs.
* Changed how error reporting for invalid `for ... in` loops works: for
now this may result in slightly worse error messages (see the example
below), but should mean error suppression is more consistent going
forward:
```luau
function my_iter(state: string, index: number)
    return state, index
end
local my_state = {}
local first_index = "first"
-- Prior we would claim `my_state` and `first_index` are of the incorrect types,
-- now we claim that `my_iter` is of the incorrect type, which can be considered
-- true, but is less helpful.
for a, b in my_iter, my_state, first_index do
end
```

# Runtime

* Introduced `lua_rawgetptagged` and `lua_rawsetptagged`, as well as Lua
5.2+ compatibility macros `lua_rawgetp` and `lua_rawsetp`, to be able to
perform lookups into tables using tagged or untagged `lightuserdata`
without additional calls and stack manipulation. This enables a more
efficient lookup way for `lightuserdata` keys similar to how
`lua_rawgetfield` and `lua_rawgeti` avoid extra operations for their
corresponding types.

---

Co-authored-by: Andy Friesen <[email protected]>
Co-authored-by: Annie Tang <[email protected]>
Co-authored-by: Ariel Weiss <[email protected]>
Co-authored-by: Hunter Goldstein <[email protected]>
Co-authored-by: Varun Saini <[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/Frontend.h

@@ -228,11 +228,6 @@ struct Frontend
     // 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_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 = {},
@@ -275,7 +270,6 @@ 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_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);
 

Analysis/include/Luau/Instantiation.h

@@ -7,7 +7,6 @@
 #include "Luau/Unifiable.h"
 #include "Luau/VisitType.h"
 
-LUAU_FASTFLAG(LuauExplicitSkipBoundTypes)
 
 namespace Luau
 {
@@ -95,7 +94,7 @@ struct GenericTypeFinder : TypeOnceVisitor
     bool found = false;
 
     GenericTypeFinder()
-        : TypeOnceVisitor("GenericTypeFinder", FFlag::LuauExplicitSkipBoundTypes)
+        : TypeOnceVisitor("GenericTypeFinder", /* skipBoundTypes */ true)
     {
     }
 

Analysis/src/BuiltinDefinitions.cpp

@@ -32,10 +32,11 @@
  */
 
 LUAU_FASTFLAG(LuauSolverV2)
-LUAU_FASTFLAGVARIABLE(LuauTableCloneClonesType3)
+LUAU_FASTFLAGVARIABLE(LuauTableCloneClonesType4)
 LUAU_FASTFLAG(LuauUseWorkspacePropToChooseSolver)
 LUAU_FASTFLAG(LuauEmplaceNotPushBack)
 LUAU_FASTFLAG(LuauBuiltinTypeFunctionsArentGlobal)
+LUAU_FASTFLAGVARIABLE(LuauCloneForIntersectionsUnions)
 
 namespace Luau
 {
@@ -556,7 +557,7 @@ void registerBuiltinGlobals(Frontend& frontend, GlobalTypes& globals, bool typeC
         ttv->props["foreachi"].deprecated = true;
 
         attachMagicFunction(*ttv->props["pack"].readTy, std::make_shared<MagicPack>());
-        if (FFlag::LuauTableCloneClonesType3)
+        if (FFlag::LuauTableCloneClonesType4)
             attachMagicFunction(*ttv->props["clone"].readTy, std::make_shared<MagicClone>());
         attachMagicFunction(*ttv->props["freeze"].readTy, std::make_shared<MagicFreeze>());
     }
@@ -1579,20 +1580,24 @@ bool MagicPack::infer(const MagicFunctionCallContext& context)
     return true;
 }
 
+// ({+ +}) -> {+ +}
+// <T: {}>(T) -> T
 std::optional<WithPredicate<TypePackId>> MagicClone::handleOldSolver(
     TypeChecker& typechecker,
     const ScopePtr& scope,
     const AstExprCall& expr,
     WithPredicate<TypePackId> withPredicate
 )
 {
-    LUAU_ASSERT(FFlag::LuauTableCloneClonesType3);
+    LUAU_ASSERT(FFlag::LuauTableCloneClonesType4);
 
     auto [paramPack, _predicates] = std::move(withPredicate);
 
     TypeArena& arena = typechecker.currentModule->internalTypes;
 
-    const auto& [paramTypes, paramTail] = flatten(paramPack);
+    // in the old solver, nonstrict in particular is really bad about inferring `...any` for things that are definitely present
+    // and the only real way for us to deal with this is to just be more permissive here
+    const auto& [paramTypes, paramTail] = extendTypePack(arena, typechecker.builtinTypes, paramPack, 1);
     if (paramTypes.empty() || expr.args.size == 0)
     {
         typechecker.reportError(expr.argLocation, CountMismatch{1, std::nullopt, 0});
@@ -1601,8 +1606,23 @@ std::optional<WithPredicate<TypePackId>> MagicClone::handleOldSolver(
 
     TypeId inputType = follow(paramTypes[0]);
 
-    if (!get<TableType>(inputType))
-        return std::nullopt;
+    if (FFlag::LuauCloneForIntersectionsUnions)
+    {
+        if (!get<TableType>(inputType) && !get<IntersectionType>(inputType))
+            return std::nullopt;
+
+        if (auto intersectionTy = get<IntersectionType>(inputType))
+        {
+            for (auto ty : intersectionTy)
+                if (!get<TableType>(ty))
+                    return std::nullopt;
+        }
+    }
+    else
+    {
+        if (!get<TableType>(inputType))
+            return std::nullopt;
+    }
 
     CloneState cloneState{typechecker.builtinTypes};
     TypeId resultType = shallowClone(inputType, arena, cloneState, /* clonePersistentTypes */ false);
@@ -1613,7 +1633,7 @@ std::optional<WithPredicate<TypePackId>> MagicClone::handleOldSolver(
 
 bool MagicClone::infer(const MagicFunctionCallContext& context)
 {
-    LUAU_ASSERT(FFlag::LuauTableCloneClonesType3);
+    LUAU_ASSERT(FFlag::LuauTableCloneClonesType4);
 
     TypeArena* arena = context.solver->arena;
 

Analysis/src/BuiltinTypeFunctions.cpp

@@ -25,11 +25,11 @@ LUAU_FASTFLAG(LuauReduceSetTypeStackPressure)
 LUAU_FASTFLAGVARIABLE(LuauRefineNoRefineAlways)
 LUAU_FASTFLAGVARIABLE(LuauRefineDistributesOverUnions)
 LUAU_FASTFLAG(LuauEGFixGenericsList)
-LUAU_FASTFLAG(LuauExplicitSkipBoundTypes)
 LUAU_FASTFLAG(LuauNoMoreComparisonTypeFunctions)
 LUAU_FASTFLAGVARIABLE(LuauBuiltinTypeFunctionsArentGlobal)
 LUAU_FASTFLAG(LuauPassBindableGenericsByReference)
 LUAU_FASTFLAG(LuauEnqueueUnionsOfDistributedTypeFunctions)
+LUAU_FASTFLAGVARIABLE(LuauGetmetatableError)
 
 namespace Luau
 {
@@ -1062,7 +1062,7 @@ struct FindRefinementBlockers : TypeOnceVisitor
     DenseHashSet<TypeId> found{nullptr};
 
     FindRefinementBlockers()
-        : TypeOnceVisitor("FindRefinementBlockers", FFlag::LuauExplicitSkipBoundTypes)
+        : TypeOnceVisitor("FindRefinementBlockers", /* skipBoundTypes */ true)
     {
     }
 
@@ -2489,7 +2489,16 @@ static TypeFunctionReductionResult<TypeId> getmetatableHelper(TypeId targetTy, c
 
     if (auto primitive = get<PrimitiveType>(targetTy))
     {
-        result = primitive->metatable;
+        if (FFlag::LuauGetmetatableError && primitive->type == PrimitiveType::Table)
+        {
+            // If we have `table` then we could have something with a
+            // metatable, so claim the result is `table?`.
+            result = ctx->arena->addType(UnionType{{ctx->builtins->tableType, ctx->builtins->nilType}});
+        }
+        else
+        {
+            result = primitive->metatable;
+        }
         erroneous = false;
     }
 
@@ -2510,6 +2519,13 @@ static TypeFunctionReductionResult<TypeId> getmetatableHelper(TypeId targetTy, c
         erroneous = false;
     }
 
+    if (FFlag::LuauGetmetatableError && get<ErrorType>(targetTy))
+    {
+        // getmetatable<error> ~ error
+        result = targetTy;
+        erroneous = false;
+    }
+
     if (erroneous)
         return {std::nullopt, Reduction::Erroneous, {}, {}};
 

Analysis/src/Clone.cpp

@@ -6,6 +6,7 @@
 #include "Luau/Type.h"
 #include "Luau/TypeOrPack.h"
 #include "Luau/TypePack.h"
+#include "Luau/TypeUtils.h"
 #include "Luau/Unifiable.h"
 #include "Luau/VisitType.h"
 

Analysis/src/Constraint.cpp

@@ -4,7 +4,6 @@
 #include "Luau/TypeFunction.h"
 #include "Luau/VisitType.h"
 
-LUAU_FASTFLAGVARIABLE(LuauExplicitSkipBoundTypes)
 LUAU_FASTFLAG(LuauNoOrderingTypeFunctions)
 
 namespace Luau
@@ -23,7 +22,7 @@ struct ReferenceCountInitializer : TypeOnceVisitor
     bool traverseIntoTypeFunctions = true;
 
     explicit ReferenceCountInitializer(NotNull<TypeIds> result)
-        : TypeOnceVisitor("ReferenceCountInitializer", FFlag::LuauExplicitSkipBoundTypes)
+        : TypeOnceVisitor("ReferenceCountInitializer", /* skipBoundTypes */ true)
         , result(result)
     {
     }

Analysis/src/ConstraintGenerator.cpp

@@ -40,9 +40,7 @@ LUAU_FASTFLAG(DebugLuauMagicTypes)
 LUAU_FASTINTVARIABLE(LuauPrimitiveInferenceInTableLimit, 500)
 LUAU_FASTFLAG(LuauEmplaceNotPushBack)
 LUAU_FASTFLAG(LuauReduceSetTypeStackPressure)
-LUAU_FASTFLAG(LuauExplicitSkipBoundTypes)
 LUAU_FASTFLAG(DebugLuauStringSingletonBasedOnQuotes)
-LUAU_FASTFLAGVARIABLE(LuauInstantiateResolvedTypeFunctions)
 LUAU_FASTFLAGVARIABLE(LuauPushTypeConstraint2)
 LUAU_FASTFLAGVARIABLE(LuauEGFixGenericsList)
 LUAU_FASTFLAGVARIABLE(LuauNumericUnaryOpsDontProduceNegationRefinements)
@@ -145,7 +143,7 @@ struct HasFreeType : TypeOnceVisitor
     bool result = false;
 
     HasFreeType()
-        : TypeOnceVisitor("TypeOnceVisitor", FFlag::LuauExplicitSkipBoundTypes)
+        : TypeOnceVisitor("TypeOnceVisitor", /* skipBoundTypes */ true)
     {
     }
 
@@ -619,7 +617,7 @@ struct FindSimplificationBlockers : TypeOnceVisitor
     bool found = false;
 
     FindSimplificationBlockers()
-        : TypeOnceVisitor("FindSimplificationBlockers", FFlag::LuauExplicitSkipBoundTypes)
+        : TypeOnceVisitor("FindSimplificationBlockers", /* skipBoundTypes */ true)
     {
     }
 
@@ -4096,16 +4094,12 @@ TypeId ConstraintGenerator::resolveReferenceType(
             result = freshType(scope, Polarity::Mixed);
     }
 
-    if (FFlag::LuauInstantiateResolvedTypeFunctions)
+    if (is<TypeFunctionInstanceType>(follow(result)))
     {
-        if (is<TypeFunctionInstanceType>(follow(result)))
-        {
-            reportError(ty->location, UnappliedTypeFunction{});
-            addConstraint(scope, ty->location, ReduceConstraint{result});
-        }
+        reportError(ty->location, UnappliedTypeFunction{});
+        addConstraint(scope, ty->location, ReduceConstraint{result});
     }
 
-
     return result;
 }
 

Analysis/src/ConstraintSolver.cpp

@@ -44,7 +44,6 @@ LUAU_FASTFLAGVARIABLE(LuauCollapseShouldNotCrash)
 LUAU_FASTFLAGVARIABLE(LuauDontDynamicallyCreateRedundantSubtypeConstraints)
 LUAU_FASTFLAGVARIABLE(LuauExtendSealedTableUpperBounds)
 LUAU_FASTFLAG(LuauReduceSetTypeStackPressure)
-LUAU_FASTFLAG(LuauExplicitSkipBoundTypes)
 LUAU_FASTFLAG(DebugLuauStringSingletonBasedOnQuotes)
 LUAU_FASTFLAG(LuauPushTypeConstraint2)
 LUAU_FASTFLAGVARIABLE(LuauScopedSeenSetInLookupTableProp)
@@ -341,7 +340,7 @@ struct InfiniteTypeFinder : TypeOnceVisitor
     bool foundInfiniteType = false;
 
     explicit InfiniteTypeFinder(ConstraintSolver* solver, const InstantiationSignature& signature, NotNull<Scope> scope)
-        : TypeOnceVisitor("InfiniteTypeFinder", FFlag::LuauExplicitSkipBoundTypes)
+        : TypeOnceVisitor("InfiniteTypeFinder", /* skipBoundTypes */ true)
         , solver(solver)
         , signature(signature)
         , scope(scope)
@@ -670,7 +669,7 @@ struct TypeSearcher : TypeVisitor
     }
 
     explicit TypeSearcher(TypeId needle, Polarity initialPolarity)
-        : TypeVisitor("TypeSearcher", FFlag::LuauExplicitSkipBoundTypes)
+        : TypeVisitor("TypeSearcher", /* skipBoundTypes */ true)
         , needle(needle)
         , current(initialPolarity)
     {
@@ -1635,7 +1634,7 @@ struct ContainsGenerics : public TypeOnceVisitor
     NotNull<DenseHashSet<const void*>> generics;
 
     explicit ContainsGenerics(NotNull<DenseHashSet<const void*>> generics)
-        : TypeOnceVisitor("ContainsGenerics", FFlag::LuauExplicitSkipBoundTypes)
+        : TypeOnceVisitor("ContainsGenerics", /* skipBoundTypes */ true)
         , generics{generics}
     {
     }
@@ -2149,7 +2148,7 @@ struct BlockedTypeFinder : TypeOnceVisitor
     std::optional<TypeId> blocked;
 
     BlockedTypeFinder()
-        : TypeOnceVisitor("ContainsGenerics_DEPRECATED", FFlag::LuauExplicitSkipBoundTypes)
+        : TypeOnceVisitor("ContainsGenerics_DEPRECATED", /* skipBoundTypes */ true)
     {
     }
 
@@ -3521,7 +3520,7 @@ struct Blocker : TypeOnceVisitor
     bool blocked = false;
 
     explicit Blocker(NotNull<ConstraintSolver> solver, NotNull<const Constraint> constraint)
-        : TypeOnceVisitor("Blocker", FFlag::LuauExplicitSkipBoundTypes)
+        : TypeOnceVisitor("Blocker", /* skipBoundTypes */ true)
         , solver(solver)
         , constraint(constraint)
     {

Analysis/src/Error.cpp

@@ -20,6 +20,7 @@ LUAU_FASTINTVARIABLE(LuauIndentTypeMismatchMaxTypeLength, 10)
 
 LUAU_FASTFLAGVARIABLE(LuauNewNonStrictReportsOneIndexedErrors)
 LUAU_FASTFLAG(LuauSubtypingReportGenericBoundMismatches2)
+LUAU_FASTFLAG(LuauUnknownGlobalFixSuggestion)
 LUAU_FASTFLAGVARIABLE(LuauNewNonStrictBetterCheckedFunctionErrorMessage)
 
 static std::string wrongNumberOfArgsString(
@@ -172,7 +173,8 @@ struct ErrorConverter
         switch (e.context)
         {
         case UnknownSymbol::Binding:
-            return "Unknown global '" + e.name + "'";
+            return FFlag::LuauUnknownGlobalFixSuggestion ? "Unknown global '" + e.name + "'; consider assigning to it first"
+                                                         : "Unknown global '" + e.name + "'";
         case UnknownSymbol::Type:
             return "Unknown type '" + e.name + "'";
         }