Sync to upstream/release/715 (luau-lang#2325)

The Luau team has been cooking for this week's release! 🍳

We have implemented an initial version of the [64-bit Integer
Type](https://rfcs.luau.org/type-long-integer.html)! Please keep in mind
that although the RFC has been accepted, we are currently in the process
of identifying and fixing bugs, which may require amending the original
RFC.

Additionally, we've been working on the following:

### Analysis
- Fix crash reported in luau-lang#2305.
- Reword type-function error messages.
- Fix various crashes found by fuzzer and in unit tests.
- Rework how we track generalizable free types.

### Runtime
- NCG: Propagate register tags across block chains.
- NCG: Fix a bug in how register information was set up when entering a
new block.
- NCG: Fix a bug where register tag information for non-live registers
was incorrectly propagated.
- NCG: Remove duplicate stores of doubles and integers.
- NCG: Unconditionally provide tags to read/write functions for buffers.

### Miscellaneous
- Various Makefile, lldb_formatter, and lldb-dap improvements.

---

Co-authored-by: Ariel Weiss <arielweiss@roblox.com>
Co-authored-by: David Cope <dcope@roblox.com>
Co-authored-by: Hunter Goldstein <hgoldstein@roblox.com>
Co-authored-by: James McNellis <jmcnellis@roblox.com>
Co-authored-by: Sora Kanosue <skanosue@roblox.com>
Co-authored-by: Thomas Schollenberger <tschollenberger@roblox.com>
Co-authored-by: Vyacheslav Egorov <vegorov@roblox.com>

---------

Co-authored-by: Vyacheslav Egorov <vegorov@roblox.com>
Co-authored-by: Ariel Weiss <arielweiss@roblox.com>
Co-authored-by: Andy Friesen <afriesen@roblox.com>
Co-authored-by: Hunter Goldstein <hgoldstein@roblox.com>
Co-authored-by: Varun Saini <61795485+vrn-sn@users.noreply.github.com>

Author: 6 people

Analysis/include/Luau/Constraint.h

@@ -350,11 +350,19 @@ struct Constraint
 
     std::vector<NotNull<Constraint>> dependencies;
 
-    TypeIds getMaybeMutatedFreeTypes() const;
+    TypeIds DEPRECATED_getMaybeMutatedFreeTypes() const;
+
+    /**
+     * Return the types and type packs that may be mutated by this constraint.
+     * Currently we do not do anything with type packs.
+     */
+    std::pair<TypeIds, TypePackIds> getMaybeMutatedTypes() const;
+
 };
 
 using ConstraintPtr = std::unique_ptr<Constraint>;
 
+bool isReferenceCountedType(TypePackId tp);
 bool isReferenceCountedType(const TypeId typ);
 
 inline Constraint& asMutable(const Constraint& c)

Analysis/include/Luau/ConstraintGenerator.h

@@ -179,7 +179,7 @@ struct ConstraintGenerator
 
     std::vector<TypeId> unionsToSimplify;
 
-    Set<TypeId> uninitializedGlobals{nullptr};
+    Set<AstName> uninitializedGlobals{{}};
 
     Polarity polarity = Polarity::None;
 

Analysis/include/Luau/ConstraintSolver.h

@@ -138,10 +138,29 @@ struct ConstraintSolver
     DenseHashMap<TypeId, std::vector<std::pair<Location, TypeId>>> upperBoundContributors{nullptr};
 
     // A mapping from free types to the number of unresolved constraints that mention them.
-    DenseHashMap<TypeId, size_t> unresolvedConstraints{{}};
+    DenseHashMap<TypeId, size_t> DEPRECATED_unresolvedConstraints{{}};
 
-    std::unordered_map<NotNull<const Constraint>, TypeIds> maybeMutatedFreeTypes;
-    std::unordered_map<TypeId, OrderedSet<const Constraint*>> mutatedFreeTypeToConstraint;
+    std::unordered_map<NotNull<const Constraint>, TypeIds> DEPRECATED_maybeMutatedFreeTypes;
+    std::unordered_map<TypeId, OrderedSet<const Constraint*>> DEPRECATED_mutatedFreeTypeToConstraint;
+
+    /**
+     * A mapping from reference counted types (blocked types, free types,
+     * unsealed table types, etc.) to the constraints that may mutate them.
+     * When this set is empty, we can eagerly generalize the respective key.
+     *
+     * NOTE: Preferrably this would be a DenseHashMap rather than an
+     * unordered_map, but DenseHashMaps require that their elements are
+     * trivially constructable.
+     */
+    std::unordered_map<TypeId, Set<const Constraint*>> typeToConstraintSet;
+
+
+    /**
+     * A mapping from constraints to the types that they mutate. We
+     * use this set to keep track of what constraints to remove
+     * from the values in the typeToConstraintSet.
+     */
+    DenseHashMap<const Constraint*, TypeIds> constraintToMutatedTypes{nullptr};
 
     // Irreducible/uninhabited type functions or type pack functions.
     DenseHashSet<const void*> uninhabitedTypeFunctions{{}};
@@ -400,15 +419,6 @@ struct ConstraintSolver
     void bind(NotNull<const Constraint> constraint, TypeId ty, TypeId boundTo);
     void bind(NotNull<const Constraint> constraint, TypePackId tp, TypePackId boundTo);
 
-    /**
-     * Generalizes the given free type if the reference counting allows it.
-     * @param the scope to generalize in
-     * @param type the free type we want to generalize
-     * @returns a non-free type that generalizes the argument, or `std::nullopt` if one
-     * does not exist
-     */
-    std::optional<TypeId> generalizeFreeType(NotNull<Scope> scope, TypeId type);
-
     /**
      * Checks the existing set of constraints to see if there exist any that contain
      * the provided free type, indicating that it is not yet ready to be replaced by

Analysis/include/Luau/Error.h

@@ -5,6 +5,7 @@
 #include "Luau/Location.h"
 #include "Luau/NotNull.h"
 #include "Luau/Type.h"
+#include "Luau/TypeFunctionError.h"
 #include "Luau/TypeIds.h"
 #include "Luau/Variant.h"
 
@@ -465,6 +466,13 @@ struct UserDefinedTypeFunctionError
     bool operator==(const UserDefinedTypeFunctionError& rhs) const;
 };
 
+struct BuiltInTypeFunctionError
+{
+    TypeFunctionError error;
+
+    bool operator==(const BuiltInTypeFunctionError& rhs) const;
+};
+
 struct ReservedIdentifier
 {
     std::string name;
@@ -645,6 +653,7 @@ using TypeErrorData = Variant<
     UnexpectedTypePackInSubtyping,
     ExplicitFunctionAnnotationRecommended,
     UserDefinedTypeFunctionError,
+    BuiltInTypeFunctionError,
     ReservedIdentifier,
     UnexpectedArrayLikeTableItem,
     CannotCheckDynamicStringFormatCalls,

Analysis/include/Luau/Instantiation2.h

@@ -58,7 +58,11 @@ struct Replacer : Substitution
     NotNull<DenseHashMap<TypeId, TypeId>> replacements;
     NotNull<DenseHashMap<TypePackId, TypePackId>> replacementPacks;
 
-    Replacer(NotNull<TypeArena> arena, NotNull<DenseHashMap<TypeId, TypeId>> replacements, NotNull<DenseHashMap<TypePackId, TypePackId>> replacementPacks);
+    Replacer(
+        NotNull<TypeArena> arena,
+        NotNull<DenseHashMap<TypeId, TypeId>> replacements,
+        NotNull<DenseHashMap<TypePackId, TypePackId>> replacementPacks
+    );
 
     bool isDirty(TypeId ty) override;
 
@@ -77,7 +81,6 @@ struct Replacer : Substitution
      * isn't the case.
      */
     bool checkReplacementKeys() const;
-
 };
 
 // A substitution which replaces generic functions by monomorphic functions

Analysis/include/Luau/Normalize.h

@@ -18,25 +18,18 @@ namespace Luau
 struct InternalErrorReporter;
 struct Module;
 struct Scope;
+struct TypeFunctionRuntime;
 
 using ModulePtr = std::shared_ptr<Module>;
 
-bool isSubtype(
+bool isSubtype_DEPRECATED(
     TypeId subTy,
     TypeId superTy,
     NotNull<Scope> scope,
     NotNull<BuiltinTypes> builtinTypes,
     InternalErrorReporter& ice,
     SolverMode solverMode
 );
-bool isSubtype(
-    TypePackId subPack,
-    TypePackId superPack,
-    NotNull<Scope> scope,
-    NotNull<BuiltinTypes> builtinTypes,
-    InternalErrorReporter& ice,
-    SolverMode solverMode
-);
 
 } // namespace Luau
 
@@ -230,6 +223,10 @@ struct NormalizedType
     // This type is either never or number.
     TypeId numbers;
 
+    // The integer part of the type.
+    // This type is either never or integer.
+    TypeId integers;
+
     // The string part of the type.
     // This may be the `string` type, or a union of singletons.
     NormalizedStringType strings;
@@ -296,6 +293,7 @@ struct NormalizedType
     bool hasErrors() const;
     bool hasNils() const;
     bool hasNumbers() const;
+    bool hasIntegers() const;
     bool hasStrings() const;
     bool hasThreads() const;
     bool hasBuffers() const;
@@ -447,4 +445,16 @@ class Normalizer
     friend struct FuelInitializer;
 };
 
+bool isSubtype(
+    TypeId subTy,
+    TypeId superTy,
+    NotNull<TypeArena> arena,
+    NotNull<BuiltinTypes> builtinTypes,
+    NotNull<Scope> scope,
+    NotNull<Normalizer> normalizer,
+    NotNull<TypeFunctionRuntime> typeFunctionRuntime,
+    NotNull<InternalErrorReporter> reporter
+);
+
+
 } // namespace Luau

Analysis/include/Luau/OrderedSet.h

@@ -11,6 +11,7 @@ namespace Luau
 template<typename T>
 struct OrderedSet
 {
+    static_assert(std::is_pointer_v<T>, "OrderedSet can only be used with pointers!");
     using iterator = typename std::vector<T>::iterator;
     using const_iterator = typename std::vector<T>::const_iterator;
 

Analysis/include/Luau/OverloadResolution.h

@@ -210,7 +210,6 @@ struct OverloadResolver
     // Used during overload selection to do arity-based filtering of overloads.
     // We do not accept nil in place of a generic unless that generic is explicitly optional.
     bool isArityCompatible(TypePackId candidate, TypePackId desired, NotNull<BuiltinTypes> builtinTypes) const;
-
 };
 
 // Helper utility, presently used for binary operator type functions.

Analysis/include/Luau/Scope.h

@@ -111,11 +111,6 @@ struct Scope
     DenseHashMap<std::string, Location> invalidTypeAliases{{}};
     std::optional<Location> isInvalidTypeAlias(const std::string& name) const;
 
-    // Clip with LuauReworkInfiniteTypeFinder
-    // A set of type alias names that are invalid because they violate the recursion restrictions of type aliases.
-    DenseHashSet<std::string> invalidTypeAliasNames_DEPRECATED{""};
-    bool isInvalidTypeAliasName_DEPRECATED(const std::string& name) const;
-
     NotNull<Scope> findNarrowestScopeContaining(Location);
 };
 

Analysis/include/Luau/Subtyping.h

@@ -406,7 +406,8 @@ struct Subtyping
     // Pack subtyping
     SubtypingResult isCovariantWith(SubtypingEnvironment& env, TypePackId subTp, TypePackId superTp, NotNull<Scope> scope);
 
-    enum class EarlyExit {
+    enum class EarlyExit
+    {
         Yes,
         No
     };