Sync to upstream/release/694 (#2033)

## What's Changed?

This week we have improvements in new type solver inference, performance
optimizations for the new type solver as well as fixes for optimization
passes in native code generation.

- Fixed the order of errors returned by `Frontend::getCheckResult` with
`accumulateNested` flag
- Typechecker now uses `userdata` instead of `class` as the extern type
name

## New Type Solver
- When a string is passed to a function expecting an argument that might
be a string singleton, bidirectional type inference will choose the
lower bound (string literal) for that argument (Fixes #2010)
- Fixed incorrect definition of `vector.lerp` (Fixes #2024)
- Added error suppression in type path traversal. Without it, errors
with `*error-type*` were sometimes visible (Fixes #1840)
- Fixed another case of combinatorial explosion in union type
normalization which could have caused a hang
- Fixed a crash on out-of-bounds access during `for..in` statement
typechecking

## Runtime
- Fixed an assertion in native code generation in a sequence of `nil`
and `boolean` stores to a local
- Fixed incorrect lowering in rare cases when LuauCodegenDirectCompare
was enabled

## Internal Contributors

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

Author: 6 people

Analysis/include/Luau/Normalize.h

@@ -202,6 +202,8 @@ enum class NormalizationResult
 // * G is a union of generic/free/blocked types, intersected with a normalized type
 struct NormalizedType
 {
+    NotNull<BuiltinTypes> builtinTypes;
+
     // The top part of the type.
     // This type is either never, unknown, or any.
     // If this type is not never, all the other fields are null.

Analysis/src/AutocompleteCore.cpp

@@ -27,7 +27,6 @@ LUAU_FASTFLAG(LuauSolverV2)
 LUAU_FASTINT(LuauTypeInferIterationLimit)
 LUAU_FASTINT(LuauTypeInferRecursionLimit)
 LUAU_FASTFLAGVARIABLE(DebugLuauMagicVariableNames)
-LUAU_FASTFLAGVARIABLE(LuauIncludeBreakContinueStatements)
 LUAU_FASTFLAGVARIABLE(LuauSuggestHotComments)
 LUAU_FASTFLAG(LuauAutocompleteAttributes)
 
@@ -1203,7 +1202,6 @@ static bool isBindingLegalAtCurrentPosition(const Symbol& symbol, const Binding&
 
 static bool isValidBreakContinueContext(const std::vector<AstNode*>& ancestry, Position position)
 {
-    LUAU_ASSERT(FFlag::LuauIncludeBreakContinueStatements);
     for (auto it = ancestry.rbegin(); it != ancestry.rend(); ++it)
     {
         if ((*it)->is<AstStatFunction>() || (*it)->is<AstStatLocalFunction>() || (*it)->is<AstExprFunction>() || (*it)->is<AstStatTypeFunction>() ||
@@ -1267,18 +1265,10 @@ static AutocompleteEntryMap autocompleteStatement(
         scope = scope->parent;
     }
 
-    if (FFlag::LuauIncludeBreakContinueStatements)
+    bool shouldIncludeBreakAndContinue = isValidBreakContinueContext(ancestry, position);
+    for (const std::string_view kw : kStatementStartingKeywords)
     {
-        bool shouldIncludeBreakAndContinue = isValidBreakContinueContext(ancestry, position);
-        for (const std::string_view kw : kStatementStartingKeywords)
-        {
-            if ((kw != "break" && kw != "continue") || shouldIncludeBreakAndContinue)
-                result.emplace(kw, AutocompleteEntry{AutocompleteEntryKind::Keyword});
-        }
-    }
-    else
-    {
-        for (const std::string_view kw : kStatementStartingKeywords)
+        if ((kw != "break" && kw != "continue") || shouldIncludeBreakAndContinue)
             result.emplace(kw, AutocompleteEntry{AutocompleteEntryKind::Keyword});
     }
 

Analysis/src/ConstraintSolver.cpp

@@ -52,6 +52,7 @@ LUAU_FASTFLAG(DebugLuauStringSingletonBasedOnQuotes)
 LUAU_FASTFLAG(LuauPushTypeConstraint2)
 LUAU_FASTFLAGVARIABLE(LuauScopedSeenSetInLookupTableProp)
 LUAU_FASTFLAGVARIABLE(LuauIterableBindNotUnify)
+LUAU_FASTFLAGVARIABLE(LuauAvoidOverloadSelectionForFunctionType)
 
 namespace Luau
 {
@@ -1579,10 +1580,15 @@ bool ConstraintSolver::tryDispatch(const FunctionCallConstraint& c, NotNull<cons
     if (FFlag::LuauTrackUniqueness && c.callSite)
         findUniqueTypes(NotNull{&uniqueTypes}, c.callSite->args, NotNull{&module->astTypes});
 
-    auto [status, overload] = resolver.selectOverload(fn, argsPack, NotNull{&uniqueTypes}, /*useFreeTypeBounds*/ force);
     TypeId overloadToUse = fn;
-    if (status == OverloadResolver::Analysis::Ok)
-        overloadToUse = overload;
+    // NOTE: This probably ends up capturing union types as well, but
+    // that should be fairly uncommon.
+    if (!FFlag::LuauAvoidOverloadSelectionForFunctionType || !is<FunctionType>(fn))
+    {
+        auto [status, overload] = resolver.selectOverload(fn, argsPack, NotNull{&uniqueTypes}, /*useFreeTypeBounds*/ force);
+        if (status == OverloadResolver::Analysis::Ok)
+            overloadToUse = overload;
+    }
 
     TypeId inferredTy = arena->addType(FunctionType{TypeLevel{}, argsPack, c.result});
     Unifier2 u2{NotNull{arena}, builtinTypes, constraint->scope, NotNull{&iceReporter}};

Analysis/src/EmbeddedBuiltinDefinitions.cpp

@@ -1,7 +1,7 @@
 // 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(LuauTypeCheckerVectorLerp)
+LUAU_FASTFLAGVARIABLE(LuauTypeCheckerVectorLerp2)
 LUAU_FASTFLAGVARIABLE(LuauRawGetHandlesNil)
 
 namespace Luau
@@ -339,7 +339,7 @@ declare vector: {
     clamp: @checked (vec: vector, min: vector, max: vector) -> vector,
     max: @checked (vector, ...vector) -> vector,
     min: @checked (vector, ...vector) -> vector,
-    lerp: @checked (vec1: vector, vec2: vector, t: number) -> number,
+    lerp: @checked (vec1: vector, vec2: vector, t: number) -> vector,
 
     zero: vector,
     one: vector,
@@ -389,7 +389,7 @@ std::string getBuiltinDefinitionSource()
     result += kBuiltinDefinitionDebugSrc;
     result += kBuiltinDefinitionUtf8Src;
     result += kBuiltinDefinitionBufferSrc;
-    if (FFlag::LuauTypeCheckerVectorLerp)
+    if (FFlag::LuauTypeCheckerVectorLerp2)
     {
         result += kBuiltinDefinitionVectorSrc;
     }

Analysis/src/Frontend.cpp

@@ -47,6 +47,7 @@ LUAU_FASTFLAG(LuauEmplaceNotPushBack)
 LUAU_FASTFLAG(LuauExplicitSkipBoundTypes)
 LUAU_FASTFLAG(LuauNoConstraintGenRecursionLimitIce)
 LUAU_FASTFLAGVARIABLE(LuauBatchedExecuteTask)
+LUAU_FASTFLAGVARIABLE(LuauAccumulateErrorsInOrder)
 
 namespace Luau
 {
@@ -286,18 +287,39 @@ ErrorVec accumulateErrors(
 
         Module& module = *modulePtr;
 
-        std::sort(
-            module.errors.begin(),
-            module.errors.end(),
-            [](const TypeError& e1, const TypeError& e2) -> bool
-            {
-                return e1.location.begin > e2.location.begin;
-            }
-        );
+        if (FFlag::LuauAccumulateErrorsInOrder)
+        {
+            size_t prevSize = result.size();
+
+            // Append module errors in reverse order
+            result.insert(result.end(), module.errors.rbegin(), module.errors.rend());
+
+            // Sort them in the reverse order as well
+            std::stable_sort(
+                result.begin() + prevSize,
+                result.end(),
+                [](const TypeError& e1, const TypeError& e2) -> bool
+                {
+                    return e1.location.begin > e2.location.begin;
+                }
+            );
+        }
+        else
+        {
+            std::sort(
+                module.errors.begin(),
+                module.errors.end(),
+                [](const TypeError& e1, const TypeError& e2) -> bool
+                {
+                    return e1.location.begin > e2.location.begin;
+                }
+            );
 
-        result.insert(result.end(), module.errors.begin(), module.errors.end());
+            result.insert(result.end(), module.errors.begin(), module.errors.end());
+        }
     }
 
+    // Now we reverse errors from all modules and since they were inserted and sorted in reverse, it should be in order
     std::reverse(result.begin(), result.end());
 
     return result;

Analysis/src/Normalize.cpp

@@ -24,7 +24,9 @@ LUAU_FASTINTVARIABLE(LuauNormalizeUnionLimit, 100)
 LUAU_FASTFLAG(LuauSolverV2)
 LUAU_FASTFLAG(LuauUseWorkspacePropToChooseSolver)
 LUAU_FASTFLAG(LuauReduceSetTypeStackPressure)
+LUAU_FASTFLAGVARIABLE(LuauImproveNormalizeExternTypeCheck)
 LUAU_FASTFLAG(LuauPassBindableGenericsByReference)
+LUAU_FASTFLAGVARIABLE(LuauNormalizerUnionTyvarsTakeMaxSize)
 
 namespace Luau
 {
@@ -144,7 +146,8 @@ bool NormalizedFunctionType::isNever() const
 }
 
 NormalizedType::NormalizedType(NotNull<BuiltinTypes> builtinTypes)
-    : tops(builtinTypes->neverType)
+    : builtinTypes(builtinTypes)
+    , tops(builtinTypes->neverType)
     , booleans(builtinTypes->neverType)
     , errors(builtinTypes->neverType)
     , nils(builtinTypes->neverType)
@@ -170,10 +173,21 @@ bool NormalizedType::isUnknown() const
     {
         if (auto ct = get<ExternType>(t))
         {
-            if (ct->name == "class" && disj.empty())
+            if (FFlag::LuauImproveNormalizeExternTypeCheck)
             {
-                isTopExternType = true;
-                break;
+                if (t == builtinTypes->externType && disj.empty())
+                {
+                    isTopExternType = true;
+                    break;
+                }
+            }
+            else
+            {
+                if (ct->name == "userdata" && disj.empty())
+                {
+                    isTopExternType = true;
+                    break;
+                }
             }
         }
     }
@@ -1539,8 +1553,17 @@ NormalizationResult Normalizer::unionNormals(NormalizedType& here, const Normali
         return NormalizationResult::True;
     }
 
-    if (here.tyvars.size() * there.tyvars.size() >= size_t(FInt::LuauNormalizeUnionLimit))
-        return NormalizationResult::HitLimits;
+    if (FFlag::LuauNormalizerUnionTyvarsTakeMaxSize)
+    {
+        auto maxSize = std::max(here.tyvars.size(), there.tyvars.size());
+        if (maxSize * maxSize >= size_t(FInt::LuauNormalizeUnionLimit))
+            return NormalizationResult::HitLimits;
+    }
+    else
+    {
+        if (here.tyvars.size() * there.tyvars.size() >= size_t(FInt::LuauNormalizeUnionLimit))
+            return NormalizationResult::HitLimits;
+    }
 
     for (auto it = there.tyvars.begin(); it != there.tyvars.end(); it++)
     {

Analysis/src/Simplify.cpp

@@ -21,12 +21,12 @@ LUAU_FASTFLAG(LuauSolverV2)
 LUAU_DYNAMIC_FASTINTVARIABLE(LuauSimplificationComplexityLimit, 8)
 LUAU_DYNAMIC_FASTINTVARIABLE(LuauTypeSimplificationIterationLimit, 128)
 LUAU_FASTFLAG(LuauRefineDistributesOverUnions)
-LUAU_FASTFLAGVARIABLE(LuauSimplifyAnyAndUnion)
 LUAU_FASTFLAG(LuauReduceSetTypeStackPressure)
 LUAU_FASTFLAG(LuauPushTypeConstraint2)
 LUAU_FASTFLAGVARIABLE(LuauMorePreciseExternTableRelation)
 LUAU_FASTFLAGVARIABLE(LuauSimplifyRefinementOfReadOnlyProperty)
 LUAU_FASTFLAGVARIABLE(LuauExternTableIndexersIntersect)
+LUAU_FASTFLAGVARIABLE(LuauSimplifyMoveTableProps)
 
 namespace Luau
 {
@@ -1467,11 +1467,25 @@ std::optional<TypeId> TypeSimplifier::basicIntersect(TypeId left, TypeId right)
 
             if (areDisjoint)
             {
-                TableType::Props mergedProps = lt->props;
-                for (const auto& [name, rightProp] : rt->props)
-                    mergedProps[name] = rightProp;
 
-                return arena->addType(TableType{mergedProps, std::nullopt, TypeLevel{}, lt->scope, TableState::Sealed});
+                if (FFlag::LuauSimplifyMoveTableProps)
+                {
+                    TableType merged{TableState::Sealed, TypeLevel{}, lt->scope};
+                    merged.props = lt->props;
+
+                    for (const auto& [name, rightProp] : rt->props)
+                        merged.props[name] = rightProp;
+
+                    return arena->addType(std::move(merged));
+                }
+                else
+                {
+                    TableType::Props mergedProps = lt->props;
+                    for (const auto& [name, rightProp] : rt->props)
+                        mergedProps[name] = rightProp;
+
+                    return arena->addType(TableType{mergedProps, std::nullopt, TypeLevel{}, lt->scope, TableState::Sealed});
+                }
             }
         }
 
@@ -1527,9 +1541,9 @@ TypeId TypeSimplifier::intersect(TypeId left, TypeId right)
         return right;
     if (get<UnknownType>(right) && !get<ErrorType>(left))
         return left;
-    if (FFlag::LuauSimplifyAnyAndUnion && get<AnyType>(left) && get<UnionType>(right))
+    if (get<AnyType>(left) && get<UnionType>(right))
         return union_(builtinTypes->errorType, right);
-    if (FFlag::LuauSimplifyAnyAndUnion && get<UnionType>(left) && get<AnyType>(right))
+    if (get<UnionType>(left) && get<AnyType>(right))
         return union_(builtinTypes->errorType, left);
     if (get<AnyType>(left))
         return arena->addType(UnionType{{right, builtinTypes->errorType}});

Analysis/src/TableLiteralInference.cpp

@@ -14,6 +14,7 @@
 #include "Luau/Unifier2.h"
 
 LUAU_FASTFLAGVARIABLE(LuauPushTypeConstraintIntersection)
+LUAU_FASTFLAGVARIABLE(LuauPushTypeConstraintSingleton)
 
 namespace Luau
 {
@@ -124,6 +125,23 @@ struct BidirectionalTypePusher
             if (ft && get<SingletonType>(ft->lowerBound) && fastIsSubtype(solver->builtinTypes->stringType, ft->upperBound) &&
                 fastIsSubtype(ft->lowerBound, solver->builtinTypes->stringType))
             {
+                if (FFlag::LuauPushTypeConstraintSingleton && maybeSingleton(expectedType) && maybeSingleton(ft->lowerBound))
+                {
+                    // If we see a pattern like:
+                    //
+                    //  local function foo<T>(my_enum: "foo" | "bar" | T) -> T
+                    //      return my_enum
+                    //  end
+                    //  local var = foo("meow")
+                    //
+                    // ... where we are attempting to push a singleton onto any string
+                    // literal, and the lower bound is still a singleton, then snap
+                    // to said lower bound.
+                    emplaceType<BoundType>(asMutable(exprType), ft->lowerBound);
+                    solver->unblock(exprType, expr->location);
+                    return exprType;
+                }
+
                 // if the upper bound is a subtype of the expected type, we can push the expected type in
                 Relation upperBoundRelation = relate(ft->upperBound, expectedType);
                 if (upperBoundRelation == Relation::Subset || upperBoundRelation == Relation::Coincident)

Analysis/src/Type.cpp

@@ -1011,7 +1011,7 @@ BuiltinTypes::BuiltinTypes()
     , threadType(arena->addType(Type{PrimitiveType{PrimitiveType::Thread}, /*persistent*/ true}))
     , bufferType(arena->addType(Type{PrimitiveType{PrimitiveType::Buffer}, /*persistent*/ true}))
     , functionType(arena->addType(Type{PrimitiveType{PrimitiveType::Function}, /*persistent*/ true}))
-    , externType(arena->addType(Type{ExternType{"class", {}, std::nullopt, std::nullopt, {}, {}, {}, {}}, /*persistent*/ true}))
+    , externType(arena->addType(Type{ExternType{"userdata", {}, std::nullopt, std::nullopt, {}, {}, {}, {}}, /*persistent*/ true}))
     , tableType(arena->addType(Type{PrimitiveType{PrimitiveType::Table}, /*persistent*/ true}))
     , emptyTableType(arena->addType(Type{TableType{TableState::Sealed, TypeLevel{}, nullptr}, /*persistent*/ true}))
     , trueType(arena->addType(Type{SingletonType{BooleanSingleton{true}}, /*persistent*/ true}))

Analysis/src/TypeChecker2.cpp

@@ -48,7 +48,7 @@ LUAU_FASTFLAGVARIABLE(LuauRemoveGenericErrorForParams)
 LUAU_FASTFLAG(LuauNoConstraintGenRecursionLimitIce)
 LUAU_FASTFLAGVARIABLE(LuauAddErrorCaseForIncompatibleTypePacks)
 LUAU_FASTFLAGVARIABLE(LuauAddConditionalContextForTernary)
-LUAU_FASTFLAGVARIABLE(LuauCheckForInWithSubtyping)
+LUAU_FASTFLAGVARIABLE(LuauCheckForInWithSubtyping2)
 LUAU_FASTFLAGVARIABLE(LuauNoOrderingTypeFunctions)
 LUAU_FASTFLAG(LuauPassBindableGenericsByReference)
 
@@ -1000,11 +1000,11 @@ void TypeChecker2::visit(AstStatForIn* forInStatement)
             else
                 reportError(GenericError{"next() does not return enough values"}, forInStatement->values.data[0]->location);
 
-            if (FFlag::LuauCheckForInWithSubtyping)
+            if (FFlag::LuauCheckForInWithSubtyping2)
                 return;
         }
 
-        if (!FFlag::LuauCheckForInWithSubtyping)
+        if (!FFlag::LuauCheckForInWithSubtyping2)
         {
             for (size_t i = 0; i < std::min(expectedVariableTypes.head.size(), variableTypes.size()); ++i)
                 testIsSubtype(variableTypes[i], expectedVariableTypes.head[i], forInStatement->vars.data[i]->location);
@@ -1039,7 +1039,7 @@ void TypeChecker2::visit(AstStatForIn* forInStatement)
             else
                 reportError(CountMismatch{2, std::nullopt, firstIterationArgCount, CountMismatch::Arg}, forInStatement->values.data[0]->location);
 
-            if (FFlag::LuauCheckForInWithSubtyping)
+            if (FFlag::LuauCheckForInWithSubtyping2)
                 return;
         }
         else if (actualArgCount < minCount)
@@ -1049,11 +1049,11 @@ void TypeChecker2::visit(AstStatForIn* forInStatement)
             else
                 reportError(CountMismatch{2, std::nullopt, firstIterationArgCount, CountMismatch::Arg}, forInStatement->values.data[0]->location);
 
-            if (FFlag::LuauCheckForInWithSubtyping)
+            if (FFlag::LuauCheckForInWithSubtyping2)
                 return;
         }
 
-        if (FFlag::LuauCheckForInWithSubtyping)
+        if (FFlag::LuauCheckForInWithSubtyping2)
         {
             const TypeId iterFunc = follow(iterTys[0]);
 
@@ -3401,7 +3401,7 @@ bool TypeChecker2::testIsSubtype(TypePackId subTy, TypePackId superTy, Location
 
 void TypeChecker2::maybeReportSubtypingError(const TypeId subTy, const TypeId superTy, const Location& location)
 {
-    LUAU_ASSERT(FFlag::LuauCheckForInWithSubtyping);
+    LUAU_ASSERT(FFlag::LuauCheckForInWithSubtyping2);
     switch (shouldSuppressErrors(NotNull{&normalizer}, subTy).orElse(shouldSuppressErrors(NotNull{&normalizer}, superTy)))
     {
     case ErrorSuppression::Suppress:
@@ -3420,7 +3420,7 @@ void TypeChecker2::maybeReportSubtypingError(const TypeId subTy, const TypeId su
 
 void TypeChecker2::testIsSubtypeForInStat(const TypeId iterFunc, const TypeId prospectiveFunc, const AstStatForIn& forInStat)
 {
-    LUAU_ASSERT(FFlag::LuauCheckForInWithSubtyping);
+    LUAU_ASSERT(FFlag::LuauCheckForInWithSubtyping2);
     LUAU_ASSERT(get<FunctionType>(follow(iterFunc)));
     LUAU_ASSERT(get<FunctionType>(follow(prospectiveFunc)));
 
@@ -3481,7 +3481,9 @@ void TypeChecker2::testIsSubtypeForInStat(const TypeId iterFunc, const TypeId pr
         if (*pf == TypePath::PackField::Arguments)
         {
             // The first component of `forInStat.values` is the iterator function itself
-            Location loc = index->index >= forInStat.values.size ? iterFuncLocation : forInStat.values.data[index->index + 1]->location;
+            Location loc = index->index + 1 >= forInStat.values.size
+                               ? iterFuncLocation
+                               : forInStat.values.data[index->index + 1]->location;
             maybeReportSubtypingError(*subLeaf, *superLeaf, loc);
         }
         else if (*pf == TypePath::PackField::Returns)