Sync to upstream/release/707 (#2222)

Hello Luaunators! This release comes with an API change for users of
`Luau.Require` and some nice improvements for the bytecode compiler
_and_ native codegen!

# Require Library

For users of `Luau.Require`'s `RequireNavigator`:
`getRequirerIdentifier` and `reset` have been merged into a single
`resetToRequirer` API. This reflects existing usage, where the
identifier returned by `getRequirerIdentifier` was always immediately
passed to `reset`. The API surface is simpler, and this eliminates the
artificial bottleneck of communicating requirer state via a
`std::string` identifier.

# Runtime

* Inlining at bytecode compile time now retains information about
builtin symbols, so `FASTCALL`s can be emitted when appropriate, such as
in:
```luau
local function tryWithZero(f, x)
    return f(x, 0)
end

return function (n)
    -- If we inline `tryWithZero`, we'll be able to emit a
    -- FASTCALL opcode when compiling the now inlined 
    -- `math.max(n, 0)`
    return tryWithZero(math.max, n)
end
```
* NCG: Fixed a crash resulting from partially eliminated dead store
instructions: we would incidentally mark a floating point value as a
potential pointer into the heap, which could crash during garbage
collection.
* NCG: Add vectorized instruction support for `min`, `max`, `floor`,
`ceil`, and `abs`
* NCG: Fixed a crash when constant folding a buffer access using an
offset outside the representable range of integers.
* Add support for constant folding vector component access at bytecode
compile time.

---

Co-authored-by: Andy Friesen <afriesen@roblox.com>
Co-authored-by: Sora Kanosue <skanosue@roblox.com>
Co-authored-by: Varun Saini <vsaini@roblox.com>
Co-authored-by: Vighnesh Vijay <vvijay@roblox.com>
Co-authored-by: Vyacheslav Egorov <vegorov@roblox.com>

Author: 6 people

Analysis/include/Luau/FileResolver.h

@@ -70,9 +70,8 @@ struct RequireNode
         return {};
     }
 
-    // TODO: resolvePathToNode() can ultimately be replaced with a call into
-    // require-by-string's path resolution algorithm. This will first require
-    // generalizing that algorithm to work with a virtual file system.
+    // Resolve a path relative to the current node. The Luau.Require library
+    // provides utilities that can help with implementing this logic.
     virtual std::unique_ptr<RequireNode> resolvePathToNode(const std::string& path) const = 0;
 
     // Get children of this node, if any (if this node represents a directory).

Analysis/include/Luau/Module.h

@@ -156,8 +156,6 @@ struct Module
     // Once a module has been typechecked, we clone its public interface into a
     // separate arena. This helps us to force Type ownership into a DAG rather
     // than a DCG.
-    void clonePublicInterface_DEPRECATED(NotNull<BuiltinTypes> builtinTypes, InternalErrorReporter& ice);
-
     void clonePublicInterface(NotNull<BuiltinTypes> builtinTypes, InternalErrorReporter& ice, SolverMode mode);
 
     bool constraintGenerationDidNotComplete = true;

Analysis/include/Luau/Subtyping.h

@@ -166,8 +166,6 @@ struct SubtypingEnvironment
         NotNull<InternalErrorReporter> iceReporter
     );
 
-    // TODO: Clip with LuauTryFindSubstitutionReturnOptional
-    const TypeId* tryFindSubstitution_DEPRECATED(TypeId ty) const;
     std::optional<TypeId> tryFindSubstitution(TypeId ty) const;
     const SubtypingResult* tryFindSubtypingResult(std::pair<TypeId, TypeId> subAndSuper) const;
 

Analysis/include/Luau/TypeUtils.h

@@ -57,14 +57,6 @@ struct InConditionalContext
 
 using ScopePtr = std::shared_ptr<struct Scope>;
 
-std::optional<Property> findTableProperty(
-    NotNull<BuiltinTypes> builtinTypes,
-    ErrorVec& errors,
-    TypeId ty,
-    const std::string& name,
-    Location location
-);
-
 std::optional<TypeId> findMetatableEntry(
     NotNull<BuiltinTypes> builtinTypes,
     ErrorVec& errors,

Analysis/src/BuiltinDefinitions.cpp

@@ -33,7 +33,6 @@
 
 LUAU_FASTFLAG(LuauSolverV2)
 LUAU_FASTFLAGVARIABLE(LuauTableCloneClonesType4)
-LUAU_FASTFLAG(LuauUseWorkspacePropToChooseSolver)
 LUAU_FASTFLAGVARIABLE(LuauCloneForIntersectionsUnions)
 LUAU_FASTFLAG(LuauStorePolarityInline)
 LUAU_FASTFLAGVARIABLE(LuauTableFreezeCheckIsSubtype)
@@ -1156,9 +1155,9 @@ TypeId makeStringMetatable(NotNull<BuiltinTypes> builtinTypes, SolverMode mode)
     const TypePackId oneStringPack = arena->addTypePack({stringType});
     const TypePackId anyTypePack = builtinTypes->anyTypePack;
 
-    const TypePackId variadicTailPack = (FFlag::LuauUseWorkspacePropToChooseSolver && mode == SolverMode::New) ? builtinTypes->unknownTypePack
-                                        : FFlag::LuauSolverV2                                                  ? builtinTypes->unknownTypePack
-                                                                                                               : anyTypePack;
+    const TypePackId variadicTailPack = mode == SolverMode::New ? builtinTypes->unknownTypePack
+                                        : FFlag::LuauSolverV2   ? builtinTypes->unknownTypePack
+                                                                : anyTypePack;
     const TypePackId emptyPack = arena->addTypePack({});
     const TypePackId stringVariadicList = arena->addTypePack(TypePackVar{VariadicTypePack{stringType}});
     const TypePackId numberVariadicList = arena->addTypePack(TypePackVar{VariadicTypePack{numberType}});

Analysis/src/ConstraintGenerator.cpp

@@ -41,10 +41,8 @@ LUAU_FASTINTVARIABLE(LuauPrimitiveInferenceInTableLimit, 500)
 LUAU_FASTFLAG(LuauExplicitTypeInstantiationSyntax)
 LUAU_FASTFLAG(LuauExplicitTypeInstantiationSupport)
 LUAU_FASTFLAGVARIABLE(LuauNumericUnaryOpsDontProduceNegationRefinements)
-LUAU_FASTFLAGVARIABLE(LuauTypeFunctions)
 LUAU_FASTFLAG(LuauPushTypeConstraintLambdas3)
 LUAU_FASTFLAGVARIABLE(LuauAvoidMintingMultipleBlockedTypesForGlobals)
-LUAU_FASTFLAGVARIABLE(LuauUseIterativeTypeVisitor)
 LUAU_FASTFLAGVARIABLE(LuauPropagateTypeAnnotationsInForInLoops)
 LUAU_FASTFLAGVARIABLE(LuauStorePolarityInline)
 LUAU_FASTFLAGVARIABLE(LuauDontIncludeVarargWithAnnotation)
@@ -587,13 +585,12 @@ namespace
  * FindSimplificationBlockers to recognize these typeArguments and defer the
  * simplification until constraint solution.
  */
-template<typename BaseVisitor>
-struct FindSimplificationBlockers : BaseVisitor
+struct FindSimplificationBlockers : IterativeTypeVisitor
 {
     bool found = false;
 
     FindSimplificationBlockers()
-        : BaseVisitor("FindSimplificationBlockers", /* skipBoundTypes */ true)
+        : IterativeTypeVisitor("FindSimplificationBlockers", /* skipBoundTypes */ true)
     {
     }
 
@@ -635,18 +632,9 @@ struct FindSimplificationBlockers : BaseVisitor
 
 bool mustDeferIntersection(TypeId ty)
 {
-    if (FFlag::LuauUseIterativeTypeVisitor)
-    {
-        FindSimplificationBlockers<IterativeTypeVisitor> bts;
-        bts.run(ty);
-        return bts.found;
-    }
-    else
-    {
-        FindSimplificationBlockers<TypeOnceVisitor> bts;
-        bts.traverse(ty);
-        return bts.found;
-    }
+    FindSimplificationBlockers bts;
+    bts.run(ty);
+    return bts.found;
 }
 } // namespace
 

Analysis/src/ConstraintSolver.cpp

@@ -42,14 +42,12 @@ LUAU_FASTFLAGVARIABLE(DebugLuauAssertOnForcedConstraint)
 LUAU_FASTFLAGVARIABLE(DebugLuauLogSolver)
 LUAU_FASTFLAGVARIABLE(DebugLuauLogSolverIncludeDependencies)
 LUAU_FASTFLAGVARIABLE(DebugLuauLogBindings)
-LUAU_FASTFLAGVARIABLE(LuauDontDynamicallyCreateRedundantSubtypeConstraints)
 LUAU_FASTFLAG(LuauExplicitTypeInstantiationSupport)
 LUAU_FASTFLAG(LuauInstantiationUsesGenericPolarity2)
 LUAU_FASTFLAG(LuauPushTypeConstraintLambdas3)
 LUAU_FASTFLAG(LuauMarkUnscopedGenericsAsSolved)
 LUAU_FASTFLAGVARIABLE(LuauUseFastSubtypeForIndexerWithName)
 LUAU_FASTFLAGVARIABLE(LuauUnifyWithSubtyping)
-LUAU_FASTFLAG(LuauUseIterativeTypeVisitor)
 LUAU_FASTFLAGVARIABLE(LuauDoNotUseApplyTypeFunctionToClone)
 LUAU_FASTFLAGVARIABLE(LuauReworkInfiniteTypeFinder)
 
@@ -333,16 +331,15 @@ struct InstantiationQueuer : TypeOnceVisitor
     }
 };
 
-template<typename BaseVisitor>
-struct InfiniteTypeFinder : BaseVisitor
+struct InfiniteTypeFinder : IterativeTypeVisitor
 {
     NotNull<ConstraintSolver> solver;
     const InstantiationSignature& signature;
     NotNull<Scope> scope;
     bool foundInfiniteType = false;
 
     explicit InfiniteTypeFinder(ConstraintSolver* solver, const InstantiationSignature& signature, NotNull<Scope> scope)
-        : BaseVisitor("InfiniteTypeFinder", /* skipBoundTypes */ true)
+        : IterativeTypeVisitor("InfiniteTypeFinder", /* skipBoundTypes */ true)
         , solver(solver)
         , signature(signature)
         , scope(scope)
@@ -1192,37 +1189,18 @@ bool ConstraintSolver::tryDispatch(const NameConstraint& c, NotNull<const Constr
             c.typePackParameters,
         };
 
-        if (FFlag::LuauUseIterativeTypeVisitor)
-        {
-            InfiniteTypeFinder<IterativeTypeVisitor> itf{this, signature, constraint->scope};
-            itf.run(target);
+        InfiniteTypeFinder itf{this, signature, constraint->scope};
+        itf.run(target);
 
-            if (itf.foundInfiniteType)
-            {
-                if (FFlag::LuauReworkInfiniteTypeFinder)
-                    constraint->scope->invalidTypeAliases[c.name] = constraint->location;
-                else
-                    constraint->scope->invalidTypeAliasNames_DEPRECATED.insert(c.name);
-                shiftReferences(target, builtinTypes->errorType);
-                emplaceType<BoundType>(asMutable(target), builtinTypes->errorType);
-                return true;
-            }
-        }
-        else
+        if (itf.foundInfiniteType)
         {
-            InfiniteTypeFinder<TypeOnceVisitor> itf{this, signature, constraint->scope};
-            itf.traverse(target);
-
-            if (itf.foundInfiniteType)
-            {
-                if (FFlag::LuauReworkInfiniteTypeFinder)
-                    constraint->scope->invalidTypeAliases[c.name] = constraint->location;
-                else
-                    constraint->scope->invalidTypeAliasNames_DEPRECATED.insert(c.name);
-                shiftReferences(target, builtinTypes->errorType);
-                emplaceType<BoundType>(asMutable(target), builtinTypes->errorType);
-                return true;
-            }
+            if (FFlag::LuauReworkInfiniteTypeFinder)
+                constraint->scope->invalidTypeAliases[c.name] = constraint->location;
+            else
+                constraint->scope->invalidTypeAliasNames_DEPRECATED.insert(c.name);
+            shiftReferences(target, builtinTypes->errorType);
+            emplaceType<BoundType>(asMutable(target), builtinTypes->errorType);
+            return true;
         }
     }
 
@@ -1360,37 +1338,18 @@ bool ConstraintSolver::tryDispatch(const TypeAliasExpansionConstraint& c, NotNul
     // https://github.com/luau-lang/luau/pull/68 for the RFC responsible for
     // this. This is a little nicer than using a recursion limit because we can
     // catch the infinite expansion before actually trying to expand it.
-    if (FFlag::LuauUseIterativeTypeVisitor)
-    {
-        InfiniteTypeFinder<IterativeTypeVisitor> itf{this, signature, constraint->scope};
-        itf.run(tf->type);
+    InfiniteTypeFinder itf{this, signature, constraint->scope};
+    itf.run(tf->type);
 
-        if (itf.foundInfiniteType)
-        {
-            // TODO (CLI-56761): Report an error.
-            bindResult(builtinTypes->errorType);
-            if (FFlag::LuauReworkInfiniteTypeFinder)
-                constraint->scope->invalidTypeAliases[petv->name.value] = constraint->location;
-            else
-                reportError(GenericError{"Recursive type being used with different parameters"}, constraint->location);
-            return true;
-        }
-    }
-    else
+    if (itf.foundInfiniteType)
     {
-        InfiniteTypeFinder<TypeOnceVisitor> itf{this, signature, constraint->scope};
-        itf.traverse(tf->type);
-
-        if (itf.foundInfiniteType)
-        {
-            // TODO (CLI-56761): Report an error.
-            bindResult(builtinTypes->errorType);
-            if (FFlag::LuauReworkInfiniteTypeFinder)
-                constraint->scope->invalidTypeAliases[petv->name.value] = constraint->location;
-            else
-                reportError(GenericError{"Recursive type being used with different parameters"}, constraint->location);
-            return true;
-        }
+        // TODO (CLI-56761): Report an error.
+        bindResult(builtinTypes->errorType);
+        if (FFlag::LuauReworkInfiniteTypeFinder)
+            constraint->scope->invalidTypeAliases[petv->name.value] = constraint->location;
+        else
+            reportError(GenericError{"Recursive type being used with different parameters"}, constraint->location);
+        return true;
     }
 
     // FIXME: this does not actually implement instantiation properly, it puts
@@ -3894,13 +3853,10 @@ bool ConstraintSolver::isBlocked(NotNull<const Constraint> constraint) const
 NotNull<Constraint> ConstraintSolver::pushConstraint(NotNull<Scope> scope, const Location& location, ConstraintV cv)
 {
     std::optional<SubtypeConstraintRecord> scr;
-    if (FFlag::LuauDontDynamicallyCreateRedundantSubtypeConstraints)
-    {
-        if (auto sc = cv.get_if<SubtypeConstraint>())
-            scr.emplace(SubtypeConstraintRecord{sc->subType, sc->superType, SubtypingVariance::Covariant});
-        else if (auto ec = cv.get_if<EqualityConstraint>())
-            scr.emplace(SubtypeConstraintRecord{ec->assignmentType, ec->resultType, SubtypingVariance::Invariant});
-    }
+    if (auto sc = cv.get_if<SubtypeConstraint>())
+        scr.emplace(SubtypeConstraintRecord{sc->subType, sc->superType, SubtypingVariance::Covariant});
+    else if (auto ec = cv.get_if<EqualityConstraint>())
+        scr.emplace(SubtypeConstraintRecord{ec->assignmentType, ec->resultType, SubtypingVariance::Invariant});
 
     if (scr)
     {

Analysis/src/FileResolver.cpp

@@ -61,9 +61,6 @@ static RequireSuggestions makeSuggestionsFromNode(std::unique_ptr<RequireNode> n
         RequireSuggestion parentSuggestion;
         parentSuggestion.label = "..";
 
-        // TODO: after exposing require-by-string's path normalization API, this
-        // if-else can be replaced. Instead, we can simply normalize the result
-        // of inserting ".." at the end of the current path.
         if (lastSlashInPath >= 2 && path.substr(lastSlashInPath - 2, 3) == "../")
         {
             parentSuggestion.fullPath = path.substr(0, lastSlashInPath + 1);

Analysis/src/FragmentAutocomplete.cpp

@@ -30,7 +30,6 @@ LUAU_FASTINT(LuauTypeInferIterationLimit);
 LUAU_FASTINT(LuauTarjanChildLimit)
 
 LUAU_FASTFLAGVARIABLE(DebugLogFragmentsFromAutocomplete)
-LUAU_FASTFLAG(LuauUseWorkspacePropToChooseSolver)
 LUAU_FASTFLAGVARIABLE(LuauFragmentRequiresCanBeResolvedToAModule)
 
 namespace Luau
@@ -756,14 +755,6 @@ void cloneTypesFromFragment(
         destScope->returnType = Luau::cloneIncremental(staleScope->returnType, *destArena, cloneState, destScope);
 }
 
-static FrontendModuleResolver& getModuleResolver_DEPRECATED(Frontend& frontend, std::optional<FrontendOptions> options)
-{
-    if (FFlag::LuauSolverV2 || !options)
-        return frontend.moduleResolver;
-
-    return options->forAutocomplete ? frontend.moduleResolverForAutocomplete : frontend.moduleResolver;
-}
-
 static FrontendModuleResolver& getModuleResolver(Frontend& frontend, std::optional<FrontendOptions> options)
 {
     if ((frontend.getLuauSolverMode() == SolverMode::New) || !options)
@@ -1298,8 +1289,7 @@ FragmentTypeCheckResult typecheckFragment__DEPRECATED(
     DataFlowGraph dfg = DataFlowGraphBuilder::build(root, NotNull{&incrementalModule->defArena}, NotNull{&incrementalModule->keyArena}, iceHandler);
     reportWaypoint(reporter, FragmentAutocompleteWaypoint::DfgBuildEnd);
 
-    FrontendModuleResolver& resolver =
-        FFlag::LuauUseWorkspacePropToChooseSolver ? getModuleResolver(frontend, opts) : getModuleResolver_DEPRECATED(frontend, opts);
+    FrontendModuleResolver& resolver = getModuleResolver(frontend, opts);
     std::shared_ptr<Scope> freshChildOfNearestScope = std::make_shared<Scope>(nullptr);
     /// Contraint Generator
     ConstraintGenerator cg{
@@ -1416,8 +1406,7 @@ std::pair<FragmentTypeCheckStatus, FragmentTypeCheckResult> typecheckFragment(
     if (!frontend.allModuleDependenciesValid(moduleName, opts && opts->forAutocomplete))
         return {FragmentTypeCheckStatus::SkipAutocomplete, {}};
 
-    FrontendModuleResolver& resolver =
-        FFlag::LuauUseWorkspacePropToChooseSolver ? getModuleResolver(frontend, opts) : getModuleResolver_DEPRECATED(frontend, opts);
+    FrontendModuleResolver& resolver = getModuleResolver(frontend, opts);
     ModulePtr module = resolver.getModule(moduleName);
     if (!module)
     {

Analysis/src/Frontend.cpp

@@ -40,7 +40,6 @@ LUAU_FASTFLAGVARIABLE(DebugLuauLogSolverToJsonFile)
 LUAU_FASTFLAGVARIABLE(DebugLuauForbidInternalTypes)
 LUAU_FASTFLAGVARIABLE(DebugLuauForceStrictMode)
 LUAU_FASTFLAGVARIABLE(DebugLuauForceNonStrictMode)
-LUAU_FASTFLAGVARIABLE(LuauUseWorkspacePropToChooseSolver)
 LUAU_FASTFLAGVARIABLE(DebugLuauAlwaysShowConstraintSolvingIncomplete)
 LUAU_FASTFLAG(LuauStandaloneParseType)
 
@@ -449,12 +448,7 @@ void Frontend::setLuauSolverMode(SolverMode mode)
 
 SolverMode Frontend::getLuauSolverMode() const
 {
-    if (FFlag::LuauUseWorkspacePropToChooseSolver)
-        return useNewLuauSolver.load();
-    else if (FFlag::LuauSolverV2)
-        return SolverMode::New;
-    else
-        return SolverMode::Old;
+    return useNewLuauSolver.load();
 }
 
 void Frontend::parse(const ModuleName& name)
@@ -1664,10 +1658,7 @@ ModulePtr check(
 
 
     unfreeze(module->interfaceTypes);
-    if (FFlag::LuauUseWorkspacePropToChooseSolver)
-        module->clonePublicInterface(builtinTypes, *iceHandler, SolverMode::New);
-    else
-        module->clonePublicInterface_DEPRECATED(builtinTypes, *iceHandler);
+    module->clonePublicInterface(builtinTypes, *iceHandler, SolverMode::New);
 
     // It would be nice if we could freeze the arenas before doing type
     // checking, but we'll have to do some work to get there.