Sync to upstream/release/701 (#2099)

Hello everyone!
This week we have type inference improvements for refinements and
user-defined type functions as well as new optimizations in Native Code
Generation.

Merged earlier, but now available in the release are implementations of
[math.isnan, math.isinf and math.isfinite for Math
Library](https://rfcs.luau.org/math-isnan-isfinite-isinf.html) RFC and
long awaited [Explicit type parameter
instantiation](https://rfcs.luau.org/explicit-type-parameter-instantiation.html)
RFC!

### What's New
- Fixed a bug that incorrectly allowed chained aliases to depend on
aliases defined in deeper directories
- Added an optional `to_alias_fallback` C API to natively support
host-injected aliases
- Fixed building fuzzers using make
- Fixed serialization of userdata type mappings from `userdataTypes`
compiler option which caused a crash on bytecode load

## Analysis
- Recursion counters have been added to the non-strict mode typechecker
to prevent crashes
- Irreducible user-defined type functions are now marked as solved,
improving consistency of type inference results
- Refinements against `unknown` type now work more consistently,
resulting in more accurate inference
```luau
--!strict

local Class = {}
Class.__index = Class

type Class = setmetatable<{ A: number }, typeof(Class)>

function Class.Foo(x: Class, y: Class, z: Class)
    if y == z then
        return
    end
    local bar = y.A -- correctly infers number instead of any
end
```

## Runtime
- Added load-store optimizations for loading components of a vector in
Native Code Generation (NCG). This should reduce the need to place
repeatedly accessed vector components in locals and improve vector
component shuffling
- NCG will exit to VM earlier when unsafe environment is detected,
reducing work it has to throw away
- NCG will now optimize better across interrupt callback invocations;
interrupts are to observe state and error/yield, general modification of
VM state is not allowed in it

## 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: Sora Kanosue <[email protected]>
Co-authored-by: Varun Saini <[email protected]>
Co-authored-by: Vyacheslav Egorov <[email protected]>

Author: 8 people

Analysis/include/Luau/TypeFunctionRuntimeBuilder.h

@@ -31,6 +31,9 @@ struct TypeFunctionRuntimeBuilderState
 };
 
 TypeFunctionTypeId serialize(TypeId ty, TypeFunctionRuntimeBuilderState* state);
+TypeFunctionTypePackId serialize(TypePackId tp, TypeFunctionRuntimeBuilderState* state);
+
 TypeId deserialize(TypeFunctionTypeId ty, TypeFunctionRuntimeBuilderState* state);
+TypePackId deserialize(TypeFunctionTypePackId tp, TypeFunctionRuntimeBuilderState* state);
 
 } // namespace Luau

Analysis/src/BuiltinTypeFunctions.cpp

@@ -22,7 +22,7 @@ LUAU_DYNAMIC_FASTINT(LuauTypeFamilyApplicationCartesianProductLimit)
 LUAU_DYNAMIC_FASTINTVARIABLE(LuauStepRefineRecursionLimit, 64)
 LUAU_FASTFLAG(LuauReduceSetTypeStackPressure)
 
-LUAU_FASTFLAGVARIABLE(LuauRefineNoRefineAlways)
+LUAU_FASTFLAGVARIABLE(LuauRefineNoRefineAlways2)
 LUAU_FASTFLAGVARIABLE(LuauRefineDistributesOverUnions)
 LUAU_FASTFLAG(LuauEGFixGenericsList)
 LUAU_FASTFLAG(LuauNoMoreComparisonTypeFunctions)
@@ -1304,28 +1304,38 @@ TypeFunctionReductionResult<TypeId> refineTypeFunction(
     }
 
     std::vector<TypeId> discriminantTypes;
-    for (size_t i = 1; i < typeParams.size(); i++)
-        discriminantTypes.push_back(follow(typeParams.at(i)));
-
-    if (FFlag::LuauRefineNoRefineAlways)
+    if (FFlag::LuauRefineNoRefineAlways2)
     {
-        bool hasAnyRealRefinements = false;
-        for (auto discriminant : discriminantTypes)
+        for (size_t i = 1; i < typeParams.size(); i++)
         {
+            auto discriminant = follow(typeParams[i]);
+
+            // Filter out any top level types that are meaningless to refine 
+            // against.
+            if (is<UnknownType, NoRefineType>(discriminant))
+                continue;
+
             // If the discriminant type is only:
-            // - The `*no-refine*` type or,
-            // - tables, metatables, unions, intersections, functions, or negations _containing_ `*no-refine*`.
+            // - The `*no-refine*` type (covered above) or;
+            // - tables, metatables, unions, intersections, functions, or 
+            //   negations containing `*no-refine*` (covered below).
             // There's no point in refining against it.
             ContainsRefinableType crt;
             crt.traverse(discriminant);
 
-            hasAnyRealRefinements = hasAnyRealRefinements || crt.found;
+            if (crt.found)
+                discriminantTypes.push_back(discriminant);
         }
 
         // if we don't have any real refinements, i.e. they're all `*no-refine*`, then we can reduce immediately.
-        if (!hasAnyRealRefinements)
+        if (discriminantTypes.empty())
             return {targetTy, {}};
     }
+    else
+    {
+        for (size_t i = 1; i < typeParams.size(); i++)
+            discriminantTypes.push_back(follow(typeParams.at(i)));
+    }
 
     const bool targetIsPending = isBlockedOrUnsolvedType(targetTy);
 
@@ -1385,8 +1395,8 @@ TypeFunctionReductionResult<TypeId> refineTypeFunction(
         }
         else
         {
-            // FFlag::LuauRefineNoRefineAlways moves this check upwards so that it runs even if the thing being refined is pending.
-            if (!FFlag::LuauRefineNoRefineAlways)
+            // FFlag::LuauRefineNoRefineAlways2 moves this check upwards so that it runs even if the thing being refined is pending.
+            if (!FFlag::LuauRefineNoRefineAlways2)
             {
                 // If the discriminant type is only:
                 // - The `*no-refine*` type or,

Analysis/src/ConstraintSolver.cpp

@@ -47,13 +47,13 @@ LUAU_FASTFLAG(LuauReduceSetTypeStackPressure)
 LUAU_FASTFLAG(DebugLuauStringSingletonBasedOnQuotes)
 LUAU_FASTFLAG(LuauExplicitTypeExpressionInstantiation)
 LUAU_FASTFLAG(LuauPushTypeConstraint2)
-LUAU_FASTFLAGVARIABLE(LuauScopedSeenSetInLookupTableProp)
 LUAU_FASTFLAGVARIABLE(LuauIterableBindNotUnify)
 LUAU_FASTFLAGVARIABLE(LuauAvoidOverloadSelectionForFunctionType)
 LUAU_FASTFLAG(LuauSimplifyIntersectionNoTreeSet)
 LUAU_FASTFLAG(LuauInstantiationUsesGenericPolarity)
 LUAU_FASTFLAG(LuauPushTypeConstraintLambdas2)
 LUAU_FASTFLAGVARIABLE(LuauPushTypeConstriantAlwaysCompletes)
+LUAU_FASTFLAG(LuauMarkUnscopedGenericsAsSolved)
 
 namespace Luau
 {
@@ -2672,7 +2672,11 @@ bool ConstraintSolver::tryDispatch(const ReduceConstraint& c, NotNull<const Cons
         unblock(r, constraint->location);
 
     for (TypeId ity : result.irreducibleTypes)
+    {
         uninhabitedTypeFunctions.insert(ity);
+        if (FFlag::LuauMarkUnscopedGenericsAsSolved)
+            unblock(ity, constraint->location);
+    }
 
     bool reductionFinished = result.blockedTypes.empty() && result.blockedPacks.empty();
 
@@ -3228,12 +3232,7 @@ TablePropLookupResult ConstraintSolver::lookupTableProp(
     if (seen.contains(subjectType))
         return {};
 
-    std::optional<ScopedSeenSet<Set<TypeId>, TypeId>> ss; // This won't be needed once LuauScopedSeenSetInLookupTableProp is clipped.
-
-    if (FFlag::LuauScopedSeenSetInLookupTableProp)
-        ss.emplace(seen, subjectType);
-    else
-        seen.insert(subjectType);
+    ScopedSeenSet<Set<TypeId>, TypeId> ss{seen, subjectType};
 
     subjectType = follow(subjectType);
 

Analysis/src/EqSatSimplification.cpp

@@ -365,7 +365,7 @@ Id toId(
         return res;
     };
 
-    if (auto tt = get<TableType>(ty))
+    if (get<TableType>(ty))
         return egraph.add(TImportedTable{ty});
     else if (get<MetatableType>(ty))
         return egraph.add(TOpaque{ty});

Analysis/src/NonStrictTypeChecker.cpp

@@ -4,25 +4,28 @@
 #include "Luau/Ast.h"
 #include "Luau/AstQuery.h"
 #include "Luau/Common.h"
+#include "Luau/Def.h"
+#include "Luau/Error.h"
+#include "Luau/Normalize.h"
+#include "Luau/RecursionCounter.h"
 #include "Luau/Simplify.h"
-#include "Luau/Type.h"
 #include "Luau/Subtyping.h"
-#include "Luau/Normalize.h"
-#include "Luau/Error.h"
 #include "Luau/TimeTrace.h"
+#include "Luau/ToString.h"
+#include "Luau/Type.h"
 #include "Luau/TypeArena.h"
 #include "Luau/TypeFunction.h"
-#include "Luau/Def.h"
-#include "Luau/ToString.h"
 #include "Luau/TypeUtils.h"
 
 #include <iterator>
 
 LUAU_FASTFLAG(DebugLuauMagicTypes)
 
+LUAU_FASTINTVARIABLE(LuauNonStrictTypeCheckerRecursionLimit, 300)
 LUAU_FASTFLAG(LuauEmplaceNotPushBack)
 LUAU_FASTFLAGVARIABLE(LuauUnreducedTypeFunctionsDontTriggerWarnings)
 LUAU_FASTFLAGVARIABLE(LuauNonStrictFetchScopeOnce)
+LUAU_FASTFLAGVARIABLE(LuauAddRecursionCounterToNonStrictTypeChecker)
 
 namespace Luau
 {
@@ -318,6 +321,14 @@ struct NonStrictTypeChecker
 
     NonStrictContext visit(AstStatBlock* block)
     {
+        std::optional<RecursionCounter> _rc;
+        if (FFlag::LuauAddRecursionCounterToNonStrictTypeChecker)
+        {
+            _rc.emplace(&nonStrictRecursionCount);
+            if (FInt::LuauNonStrictTypeCheckerRecursionLimit > 0 && nonStrictRecursionCount >= FInt::LuauNonStrictTypeCheckerRecursionLimit)
+                return {};
+        }
+
         auto StackPusher = pushStack(block);
         NonStrictContext ctx;
 
@@ -511,6 +522,14 @@ struct NonStrictTypeChecker
 
     NonStrictContext visit(AstExpr* expr, ValueContext context)
     {
+        std::optional<RecursionCounter> _rc;
+        if (FFlag::LuauAddRecursionCounterToNonStrictTypeChecker)
+        {
+            _rc.emplace(&nonStrictRecursionCount);
+            if (FInt::LuauNonStrictTypeCheckerRecursionLimit > 0 && nonStrictRecursionCount >= FInt::LuauNonStrictTypeCheckerRecursionLimit)
+                return {};
+        }
+
         auto pusher = pushStack(expr);
         if (auto e = expr->as<AstExprGroup>())
             return visit(e, context);
@@ -809,6 +828,14 @@ struct NonStrictTypeChecker
 
     NonStrictContext visit(AstExprTable* table)
     {
+        std::optional<RecursionCounter> _rc;
+        if (FFlag::LuauAddRecursionCounterToNonStrictTypeChecker)
+        {
+            _rc.emplace(&nonStrictRecursionCount);
+            if (FInt::LuauNonStrictTypeCheckerRecursionLimit > 0 && nonStrictRecursionCount >= FInt::LuauNonStrictTypeCheckerRecursionLimit)
+                return {};
+        }
+
         for (auto [_, key, value] : table->items)
         {
             if (key)
@@ -1291,6 +1318,8 @@ struct NonStrictTypeChecker
     }
 
 private:
+    int nonStrictRecursionCount = 0;
+
     TypeId getOrCreateNegation(TypeId baseType)
     {
         TypeId& cachedResult = cachedNegations[baseType];
@@ -1326,7 +1355,7 @@ void checkNonStrict(
     typeChecker.visit(sourceModule.root);
     unfreeze(module->interfaceTypes);
     copyErrors(module->errors, module->interfaceTypes, builtinTypes);
-    
+
     module->errors.erase(
         std::remove_if(
             module->errors.begin(),

Analysis/src/Subtyping.cpp

@@ -27,7 +27,6 @@ LUAU_FASTINTVARIABLE(LuauSubtypingReasoningLimit, 100)
 LUAU_FASTFLAG(LuauEmplaceNotPushBack)
 LUAU_FASTFLAGVARIABLE(LuauSubtypingReportGenericBoundMismatches2)
 LUAU_FASTFLAGVARIABLE(LuauTrackUniqueness)
-LUAU_FASTFLAGVARIABLE(LuauSubtypingUnionsAndIntersectionsInGenericBounds)
 LUAU_FASTFLAGVARIABLE(LuauIndexInMetatableSubtyping)
 LUAU_FASTFLAGVARIABLE(LuauSubtypingPackRecursionLimits)
 LUAU_FASTFLAGVARIABLE(LuauSubtypingPrimitiveAndGenericTableTypes)
@@ -865,23 +864,7 @@ SubtypingResult Subtyping::isCovariantWith(SubtypingEnvironment& env, TypeId sub
 
     SubtypingResult result;
 
-    if (auto subUnion = get<UnionType>(subTy); subUnion && !FFlag::LuauSubtypingUnionsAndIntersectionsInGenericBounds)
-        result = isCovariantWith(env, subUnion, superTy, scope);
-    else if (auto superUnion = get<UnionType>(superTy); superUnion && !FFlag::LuauSubtypingUnionsAndIntersectionsInGenericBounds)
-    {
-        result = isCovariantWith(env, subTy, superUnion, scope);
-        if (!result.isSubtype && !result.normalizationTooComplex)
-            result = trySemanticSubtyping(env, subTy, superTy, scope, result);
-    }
-    else if (auto superIntersection = get<IntersectionType>(superTy); superIntersection && !FFlag::LuauSubtypingUnionsAndIntersectionsInGenericBounds)
-        result = isCovariantWith(env, subTy, superIntersection, scope);
-    else if (auto subIntersection = get<IntersectionType>(subTy); subIntersection && !FFlag::LuauSubtypingUnionsAndIntersectionsInGenericBounds)
-    {
-        result = isCovariantWith(env, subIntersection, superTy, scope);
-        if (!result.isSubtype && !result.normalizationTooComplex)
-            result = trySemanticSubtyping(env, subTy, superTy, scope, result);
-    }
-    else if (get<AnyType>(superTy))
+    if (get<AnyType>(superTy))
         result = {true};
 
     // We have added this as an exception - the set of inhabitants of any is exactly the set of inhabitants of unknown (since error has no
@@ -895,8 +878,7 @@ SubtypingResult Subtyping::isCovariantWith(SubtypingEnvironment& env, TypeId sub
         result =
             isCovariantWith(env, builtinTypes->unknownType, superTy, scope).andAlso(isCovariantWith(env, builtinTypes->errorType, superTy, scope));
     }
-    else if (get<UnknownType>(superTy) && // flag delays recursing into unions and inters, so only handle this case if subTy isn't a union or inter
-             (FFlag::LuauSubtypingUnionsAndIntersectionsInGenericBounds ? !get<UnionType>(subTy) && !get<IntersectionType>(subTy) : true))
+    else if (get<UnknownType>(superTy) && !get<UnionType>(subTy) && !get<IntersectionType>(subTy))
     {
         LUAU_ASSERT(!get<AnyType>(subTy));          // TODO: replace with ice.
         LUAU_ASSERT(!get<UnionType>(subTy));        // TODO: replace with ice.
@@ -951,25 +933,17 @@ SubtypingResult Subtyping::isCovariantWith(SubtypingEnvironment& env, TypeId sub
         }
     }
     else if (auto subUnion = get<UnionType>(subTy))
-    {
-        LUAU_ASSERT(FFlag::LuauSubtypingUnionsAndIntersectionsInGenericBounds);
         result = isCovariantWith(env, subUnion, superTy, scope);
-    }
     else if (auto superUnion = get<UnionType>(superTy))
     {
-        LUAU_ASSERT(FFlag::LuauSubtypingUnionsAndIntersectionsInGenericBounds);
         result = isCovariantWith(env, subTy, superUnion, scope);
         if (!result.isSubtype && !result.normalizationTooComplex)
             result = trySemanticSubtyping(env, subTy, superTy, scope, result);
     }
     else if (auto superIntersection = get<IntersectionType>(superTy))
-    {
-        LUAU_ASSERT(FFlag::LuauSubtypingUnionsAndIntersectionsInGenericBounds);
         result = isCovariantWith(env, subTy, superIntersection, scope);
-    }
     else if (auto subIntersection = get<IntersectionType>(subTy))
     {
-        LUAU_ASSERT(FFlag::LuauSubtypingUnionsAndIntersectionsInGenericBounds);
         result = isCovariantWith(env, subIntersection, superTy, scope);
         if (!result.isSubtype && !result.normalizationTooComplex)
             result = trySemanticSubtyping(env, subTy, superTy, scope, result);
@@ -2797,26 +2771,21 @@ SubtypingResult Subtyping::checkGenericBounds(
         result.genericBoundsMismatches.emplace_back(genericName, bounds.lowerBound, bounds.upperBound);
     else if (!boundsResult.isSubtype)
     {
-        if (FFlag::LuauSubtypingUnionsAndIntersectionsInGenericBounds)
+        // Check if the bounds are error suppressing before reporting a mismatch
+        switch (shouldSuppressErrors(normalizer, lowerBound).orElse(shouldSuppressErrors(normalizer, upperBound)))
         {
-            // Check if the bounds are error suppressing before reporting a mismatch
-            switch (shouldSuppressErrors(normalizer, lowerBound).orElse(shouldSuppressErrors(normalizer, upperBound)))
-            {
-            case ErrorSuppression::Suppress:
-                break;
-            case ErrorSuppression::NormalizationFailed:
-                // intentionally fallthrough here since we couldn't prove this was error-suppressing
-                [[fallthrough]];
-            case ErrorSuppression::DoNotSuppress:
-                result.genericBoundsMismatches.emplace_back(genericName, bounds.lowerBound, bounds.upperBound);
-                break;
-            default:
-                LUAU_ASSERT(0);
-                break;
-            }
-        }
-        else
+        case ErrorSuppression::Suppress:
+            break;
+        case ErrorSuppression::NormalizationFailed:
+            // intentionally fallthrough here since we couldn't prove this was error-suppressing
+            [[fallthrough]];
+        case ErrorSuppression::DoNotSuppress:
             result.genericBoundsMismatches.emplace_back(genericName, bounds.lowerBound, bounds.upperBound);
+            break;
+        default:
+            LUAU_ASSERT(0);
+            break;
+        }
     }
 
     result.andAlso(boundsResult);

Analysis/src/TxnLog.cpp

@@ -9,8 +9,6 @@
 #include <algorithm>
 #include <stdexcept>
 
-LUAU_FASTFLAGVARIABLE(LuauOccursCheckInCommit)
-
 namespace Luau
 {
 
@@ -228,12 +226,7 @@ void TxnLog::commit()
         {
             const TypeId unfollowed = &rep.get()->pending;
 
-            if (FFlag::LuauOccursCheckInCommit)
-            {
-                if (!occurs(*this, unfollowed, ty))
-                    asMutable(ty)->reassign(*unfollowed);
-            }
-            else
+            if (!occurs(*this, unfollowed, ty))
                 asMutable(ty)->reassign(*unfollowed);
         }
     }

Analysis/src/TypeChecker2.cpp

@@ -45,7 +45,6 @@ LUAU_FASTFLAGVARIABLE(LuauNewOverloadResolver)
 LUAU_FASTFLAG(LuauPassBindableGenericsByReference)
 LUAU_FASTFLAG(LuauSimplifyIntersectionNoTreeSet)
 LUAU_FASTFLAG(LuauAddRefinementToAssertions)
-LUAU_FASTFLAGVARIABLE(LuauNoCustomHandlingOfReasonsingsForForIn)
 LUAU_FASTFLAGVARIABLE(LuauSuppressIndexingIntoError)
 
 namespace Luau
@@ -550,7 +549,7 @@ TypeId TypeChecker2::lookupAnnotation(AstType* annotation)
         {
             if (auto ann = ref->parameters.data[0].type)
             {
-                TypeId argTy = lookupAnnotation(ref->parameters.data[0].type);
+                TypeId argTy = lookupAnnotation(ann);
                 luauPrintLine(
                     format("_luau_print (%d, %d): %s\n", annotation->location.begin.line, annotation->location.begin.column, toString(argTy).c_str())
                 );

Analysis/src/TypeFunction.cpp

@@ -35,6 +35,7 @@ LUAU_FASTFLAG(DebugLuauEqSatSimplification)
 
 LUAU_FASTFLAGVARIABLE(DebugLuauLogTypeFamilies)
 LUAU_FASTFLAGVARIABLE(LuauEnqueueUnionsOfDistributedTypeFunctions)
+LUAU_FASTFLAGVARIABLE(LuauMarkUnscopedGenericsAsSolved)
 
 namespace Luau
 {
@@ -586,6 +587,12 @@ struct TypeFunctionReducer
                     // Let the caller know this type will not become reducible
                     result.irreducibleTypes.insert(subject);
 
+                    if (FFlag::LuauMarkUnscopedGenericsAsSolved)
+                    {
+                        if (getState(subject) == TypeFunctionInstanceState::Unsolved)
+                            setState(subject, TypeFunctionInstanceState::Solved);
+                    }
+
                     if (FFlag::DebugLuauLogTypeFamilies)
                         printf("Irreducible due to an unscoped generic type\n");