Sync to upstream/release/696 (#2050)

Hey everyone. In preparation for the next phase of the New Type Solver
rollout, we have another round of important bugfixes.

We've also got a few improvements to the new require alias machinery and
a little optimization to native codegen.

## New Type Solver

* Fix a case where Luau would erroneously simplify `{} & { p: number |
string }` to `number`.
* Fix a crash that could occur within generic substitution. TODO: Sora
to help word this.
* Fix a case where Luau would infer a spurious union type as the result
of a `setmetatable` call.
* Fix #1803
* Improve bidirectional inference of table literals in the case that the
expected type has an indexer.

## Luau.Require

* Zero-initialize `luarequire_Configuration` function pointers before
user initialization
* Error if ambiguity is detected during alias discovery

## Native Codegen

* Do not replace known constant value with a load propagation in
STORE_TVALUE

---------

Co-authored-by: Annie Tang <[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: Vyacheslav Egorov <[email protected]>

Author: 6 people

Analysis/include/Luau/BuiltinDefinitions.h

@@ -88,6 +88,7 @@ TypeId getGlobalBinding(GlobalTypes& globals, const std::string& name);
 bool matchSetMetatable(const AstExprCall& call);
 bool matchTableFreeze(const AstExprCall& call);
 bool matchAssert(const AstExprCall& call);
+bool matchTypeOf(const AstExprCall& call);
 
 // Returns `true` if the function should introduce typestate for its first argument.
 bool shouldTypestateForFirstArgument(const AstExprCall& call);

Analysis/include/Luau/ConstraintSolver.h

@@ -462,7 +462,12 @@ struct ConstraintSolver
     void reproduceConstraints(NotNull<Scope> scope, const Location& location, const Substitution& subst);
 
     TypeId simplifyIntersection(NotNull<Scope> scope, Location location, TypeId left, TypeId right);
-    TypeId simplifyIntersection(NotNull<Scope> scope, Location location, std::set<TypeId> parts);
+
+    // Clip with LuauSimplifyIntersectionNoTreeSet
+    TypeId simplifyIntersection_DEPRECATED(NotNull<Scope> scope, Location location, std::set<TypeId> parts);
+
+    TypeId simplifyIntersection(NotNull<Scope> scope, Location location, TypeIds parts);
+
     TypeId simplifyUnion(NotNull<Scope> scope, Location location, TypeId left, TypeId right);
 
     TypePackId anyifyModuleReturnTypePackGenerics(TypePackId tp);

Analysis/include/Luau/Simplify.h

@@ -5,6 +5,7 @@
 #include "Luau/DenseHash.h"
 #include "Luau/NotNull.h"
 #include "Luau/TypeFwd.h"
+#include "Luau/TypeIds.h"
 
 #include <optional>
 #include <set>
@@ -22,7 +23,11 @@ struct SimplifyResult
 };
 
 SimplifyResult simplifyIntersection(NotNull<BuiltinTypes> builtinTypes, NotNull<TypeArena> arena, TypeId left, TypeId right);
-SimplifyResult simplifyIntersection(NotNull<BuiltinTypes> builtinTypes, NotNull<TypeArena> arena, std::set<TypeId> parts);
+
+// Clip with LuauSimplifyIntersectionNoTreeSet
+SimplifyResult simplifyIntersection_DEPRECATED(NotNull<BuiltinTypes> builtinTypes, NotNull<TypeArena> arena, std::set<TypeId> parts);
+
+SimplifyResult simplifyIntersection(NotNull<BuiltinTypes> builtinTypes, NotNull<TypeArena> arena, TypeIds parts);
 
 SimplifyResult simplifyUnion(NotNull<BuiltinTypes> builtinTypes, NotNull<TypeArena> arena, TypeId left, TypeId right);
 

Analysis/include/Luau/Subtyping.h

@@ -168,7 +168,9 @@ struct SubtypingEnvironment
     // TODO: Clip with LuauSubtypingGenericsDoesntUseVariance
     std::optional<TypeId> applyMappedGenerics_DEPRECATED(NotNull<BuiltinTypes> builtinTypes, NotNull<TypeArena> arena, TypeId ty);
 
-    const TypeId* tryFindSubstitution(TypeId ty) const;
+    // TODO: Clip with LuauTryFindSubstitutionReturnOptional
+    const TypeId* tryFindSubstitution_DEPRECATED(TypeId ty) const;
+    std::optional<TypeId> tryFindSubstitution(TypeId ty) const;
     // TODO: Clip with LuauSubtypingGenericsDoesntUseVariance
     const SubtypingResult* tryFindSubtypingResult(std::pair<TypeId, TypeId> subAndSuper) const;
 

Analysis/include/Luau/TypeIds.h

@@ -40,6 +40,8 @@ class TypeIds
     void retain(const TypeIds& tys);
     void clear();
 
+    void clearWithoutRealloc();
+
     TypeId front() const;
     iterator begin();
     iterator end();

Analysis/src/BuiltinDefinitions.cpp

@@ -1880,6 +1880,18 @@ bool matchAssert(const AstExprCall& call)
     return true;
 }
 
+bool matchTypeOf(const AstExprCall& call)
+{
+    if (call.args.size != 1)
+        return false;
+
+    const AstExprGlobal* funcAsGlobal = call.func->as<AstExprGlobal>();
+    if (!funcAsGlobal || (funcAsGlobal->name != "typeof" && funcAsGlobal->name != "type"))
+        return false;
+
+    return true;
+}
+
 bool shouldTypestateForFirstArgument(const AstExprCall& call)
 {
     // TODO: magic function for setmetatable and assert and then add them

Analysis/src/BuiltinTypeFunctions.cpp

@@ -26,7 +26,6 @@ LUAU_FASTFLAGVARIABLE(LuauRefineNoRefineAlways)
 LUAU_FASTFLAGVARIABLE(LuauRefineDistributesOverUnions)
 LUAU_FASTFLAG(LuauEGFixGenericsList)
 LUAU_FASTFLAG(LuauExplicitSkipBoundTypes)
-LUAU_FASTFLAG(LuauRawGetHandlesNil)
 LUAU_FASTFLAG(LuauNoMoreComparisonTypeFunctions)
 LUAU_FASTFLAGVARIABLE(LuauBuiltinTypeFunctionsArentGlobal)
 LUAU_FASTFLAG(LuauPassBindableGenericsByReference)
@@ -2326,7 +2325,7 @@ TypeFunctionReductionResult<TypeId> indexFunctionImpl(
             for (TypeId ty : *typesToFind)
                 if (!tblIndexInto(ty, *tablesIter, properties, ctx, isRaw))
                 {
-                    if (FFlag::LuauRawGetHandlesNil && isRaw)
+                    if (isRaw)
                         properties.insert(ctx->builtins->nilType);
                     else
                         return {std::nullopt, Reduction::Erroneous, {}, {}};

Analysis/src/ConstraintGenerator.cpp

@@ -54,6 +54,8 @@ LUAU_FASTFLAGVARIABLE(LuauNoMoreComparisonTypeFunctions)
 LUAU_FASTFLAG(LuauNoOrderingTypeFunctions)
 LUAU_FASTFLAGVARIABLE(LuauDontReferenceScopePtrFromHashTable)
 LUAU_FASTFLAG(LuauBuiltinTypeFunctionsArentGlobal)
+LUAU_FASTFLAGVARIABLE(LuauMetatableAvoidSingletonUnion)
+LUAU_FASTFLAGVARIABLE(LuauAddRefinementToAssertions)
 
 namespace Luau
 {
@@ -710,7 +712,7 @@ void ConstraintGenerator::applyRefinements(const ScopePtr& scope, Location locat
             discriminants.clear();
             return resultType;
         }
-        
+
     };
 
     for (auto& [def, partition] : refinements)
@@ -2471,9 +2473,19 @@ InferencePack ConstraintGenerator::checkPack(const ScopePtr& scope, AstExprCall*
             {
                 expectedType = expectedTypesForCall[i];
             }
-            auto [ty, refinement] = check(scope, arg, expectedType, /*forceSingleton*/ false, /*generalize*/ false);
-            args.push_back(ty);
-            argumentRefinements.push_back(refinement);
+            if (FFlag::LuauAddRefinementToAssertions && i == 0 && matchAssert(*call))
+            {
+                InConditionalContext flipper{&typeContext};
+                auto [ty, refinement] = check(scope, arg, expectedType, /*forceSingleton*/ false, /*generalize*/ false);
+                args.push_back(ty);
+                argumentRefinements.push_back(refinement);
+            }
+            else
+            {
+                auto [ty, refinement] = check(scope, arg, expectedType, /*forceSingleton*/ false, /*generalize*/ false);
+                args.push_back(ty);
+                argumentRefinements.push_back(refinement);
+            }
         }
         else
         {
@@ -2535,13 +2547,26 @@ InferencePack ConstraintGenerator::checkPack(const ScopePtr& scope, AstExprCall*
 
         if (isTableUnion(target))
         {
-            const UnionType* targetUnion = get<UnionType>(target);
-            std::vector<TypeId> newParts;
+            if (FFlag::LuauMetatableAvoidSingletonUnion)
+            {
+                const UnionType* targetUnion = get<UnionType>(target);
+                UnionBuilder ub{arena, builtinTypes};
 
-            for (TypeId ty : targetUnion)
-                newParts.push_back(arena->addType(MetatableType{ty, mt}));
+                for (TypeId ty : targetUnion)
+                    ub.add(arena->addType(MetatableType{ty, mt}));
 
-            resultTy = arena->addType(UnionType{std::move(newParts)});
+                resultTy = ub.build();
+            }
+            else
+            {
+                const UnionType* targetUnion = get<UnionType>(target);
+                std::vector<TypeId> newParts;
+
+                for (TypeId ty : targetUnion)
+                    newParts.push_back(arena->addType(MetatableType{ty, mt}));
+
+                resultTy = arena->addType(UnionType{std::move(newParts)});
+            }
         }
         else
             resultTy = arena->addType(MetatableType{target, mt});

Analysis/src/ConstraintSolver.cpp

@@ -52,6 +52,7 @@ LUAU_FASTFLAG(LuauPushTypeConstraint2)
 LUAU_FASTFLAGVARIABLE(LuauScopedSeenSetInLookupTableProp)
 LUAU_FASTFLAGVARIABLE(LuauIterableBindNotUnify)
 LUAU_FASTFLAGVARIABLE(LuauAvoidOverloadSelectionForFunctionType)
+LUAU_FASTFLAG(LuauSimplifyIntersectionNoTreeSet)
 
 namespace Luau
 {
@@ -2412,46 +2413,95 @@ bool ConstraintSolver::tryDispatch(const AssignIndexConstraint& c, NotNull<const
 
     if (auto lhsIntersection = getMutable<IntersectionType>(lhsType))
     {
-        std::set<TypeId> parts;
 
-        for (TypeId t : lhsIntersection)
+        if (FFlag::LuauSimplifyIntersectionNoTreeSet)
         {
-            if (auto tbl = getMutable<TableType>(follow(t)))
+
+            TypeIds parts;
+
+            for (TypeId t : lhsIntersection)
             {
-                if (tbl->indexer)
+                if (auto tbl = getMutable<TableType>(follow(t)))
                 {
-                    unify(constraint, indexType, tbl->indexer->indexType);
-                    parts.insert(tbl->indexer->indexResultType);
-                }
+                    if (tbl->indexer)
+                    {
+                        unify(constraint, indexType, tbl->indexer->indexType);
+                        parts.insert(tbl->indexer->indexResultType);
+                    }
 
-                if (tbl->state == TableState::Unsealed || tbl->state == TableState::Free)
+                    if (tbl->state == TableState::Unsealed || tbl->state == TableState::Free)
+                    {
+                        tbl->indexer = TableIndexer{indexType, rhsType};
+                        parts.insert(rhsType);
+                    }
+                }
+                else if (auto cls = get<ExternType>(follow(t)))
                 {
-                    tbl->indexer = TableIndexer{indexType, rhsType};
-                    parts.insert(rhsType);
+                    while (true)
+                    {
+                        if (cls->indexer)
+                        {
+                            unify(constraint, indexType, cls->indexer->indexType);
+                            parts.insert(cls->indexer->indexResultType);
+                            break;
+                        }
+
+                        if (cls->parent)
+                            cls = get<ExternType>(cls->parent);
+                        else
+                            break;
+                    }
                 }
             }
-            else if (auto cls = get<ExternType>(follow(t)))
+
+            TypeId res = simplifyIntersection(constraint->scope, constraint->location, std::move(parts));
+
+            unify(constraint, rhsType, res);
+        }
+        else
+        {
+
+            std::set<TypeId> parts;
+
+            for (TypeId t : lhsIntersection)
             {
-                while (true)
+                if (auto tbl = getMutable<TableType>(follow(t)))
                 {
-                    if (cls->indexer)
+                    if (tbl->indexer)
                     {
-                        unify(constraint, indexType, cls->indexer->indexType);
-                        parts.insert(cls->indexer->indexResultType);
-                        break;
+                        unify(constraint, indexType, tbl->indexer->indexType);
+                        parts.insert(tbl->indexer->indexResultType);
                     }
 
-                    if (cls->parent)
-                        cls = get<ExternType>(cls->parent);
-                    else
-                        break;
+                    if (tbl->state == TableState::Unsealed || tbl->state == TableState::Free)
+                    {
+                        tbl->indexer = TableIndexer{indexType, rhsType};
+                        parts.insert(rhsType);
+                    }
+                }
+                else if (auto cls = get<ExternType>(follow(t)))
+                {
+                    while (true)
+                    {
+                        if (cls->indexer)
+                        {
+                            unify(constraint, indexType, cls->indexer->indexType);
+                            parts.insert(cls->indexer->indexResultType);
+                            break;
+                        }
+
+                        if (cls->parent)
+                            cls = get<ExternType>(cls->parent);
+                        else
+                            break;
+                    }
                 }
             }
-        }
 
-        TypeId res = simplifyIntersection(constraint->scope, constraint->location, std::move(parts));
+            TypeId res = simplifyIntersection_DEPRECATED(constraint->scope, constraint->location, std::move(parts));
 
-        unify(constraint, rhsType, res);
+            unify(constraint, rhsType, res);
+        }
     }
 
     // Other types do not support index assignment.
@@ -3805,11 +3855,11 @@ TypeId ConstraintSolver::simplifyIntersection(NotNull<Scope> scope, Location loc
         return ::Luau::simplifyIntersection(builtinTypes, arena, left, right).result;
 }
 
-TypeId ConstraintSolver::simplifyIntersection(NotNull<Scope> scope, Location location, std::set<TypeId> parts)
+TypeId ConstraintSolver::simplifyIntersection(NotNull<Scope> scope, Location location, TypeIds parts)
 {
     if (FFlag::DebugLuauEqSatSimplification)
     {
-        TypeId ty = arena->addType(IntersectionType{std::vector(parts.begin(), parts.end())});
+        TypeId ty = arena->addType(IntersectionType{parts.take()});
 
         std::optional<EqSatSimplificationResult> res = eqSatSimplify(simplifier, ty);
         if (!res)
@@ -3824,6 +3874,25 @@ TypeId ConstraintSolver::simplifyIntersection(NotNull<Scope> scope, Location loc
         return ::Luau::simplifyIntersection(builtinTypes, arena, std::move(parts)).result;
 }
 
+TypeId ConstraintSolver::simplifyIntersection_DEPRECATED(NotNull<Scope> scope, Location location, std::set<TypeId> parts)
+{
+    if (FFlag::DebugLuauEqSatSimplification)
+    {
+        TypeId ty = arena->addType(IntersectionType{std::vector(parts.begin(), parts.end())});
+
+        std::optional<EqSatSimplificationResult> res = eqSatSimplify(simplifier, ty);
+        if (!res)
+            return ty;
+
+        for (TypeId ty : res->newTypeFunctions)
+            pushConstraint(scope, location, ReduceConstraint{ty});
+
+        return res->result;
+    }
+    else
+        return ::Luau::simplifyIntersection_DEPRECATED(builtinTypes, arena, std::move(parts)).result;
+}
+
 TypeId ConstraintSolver::simplifyUnion(NotNull<Scope> scope, Location location, TypeId left, TypeId right)
 {
     if (FFlag::DebugLuauEqSatSimplification)