Sync to upstream/release/740

Analysis/include/Luau/Constraint.h

@@ -3,6 +3,7 @@
 
 #include "Luau/Ast.h" // Used for some of the enumerations
 #include "Luau/DenseHash.h"
+#include "Luau/IterativeTypeVisitor.h"
 #include "Luau/NotNull.h"
 #include "Luau/Variant.h"
 #include "Luau/TypeFwd.h"
@@ -331,8 +332,14 @@ struct Constraint
     /**
      * Return the types and type packs that may be mutated by this constraint.
      * Currently we do not do anything with type packs.
+     * clip with LuauReferenceCountInitializerIsIterative
      */
-    std::pair<TypeIds, TypePackIds> getMaybeMutatedTypes() const;
+    std::pair<TypeIds, TypePackIds> getMaybeMutatedTypes_DEPRECATED() const;
+
+    /**
+     * Return the types and type packs that may be mutated by this constraint.
+     */
+    std::pair<TypeIds, TypePackIds> getMaybeMutatedTypesIn(NotNull<TypeArena> currentArena) const;
 };
 
 using ConstraintPtr = std::unique_ptr<Constraint>;
@@ -357,13 +364,39 @@ const T* get(const Constraint& c)
     return getMutable<T>(asMutable(c));
 }
 
-struct ReferenceCountInitializer : TypeOnceVisitor
+struct ReferenceCountInitializer_DEPRECATED : TypeOnceVisitor
 {
     NotNull<TypeIds> mutatedTypes;
     TypePackIds* mutatedTypePacks;
     bool traverseIntoTypeFunctions = true;
 
-    explicit ReferenceCountInitializer(NotNull<TypeIds> mutatedTypes, NotNull<TypePackIds> mutatedTypePacks);
+    explicit ReferenceCountInitializer_DEPRECATED(NotNull<TypeIds> mutatedTypes, NotNull<TypePackIds> mutatedTypePacks);
+
+    bool visit(TypeId ty, const FreeType&) override;
+
+    bool visit(TypeId ty, const BlockedType&) override;
+
+    bool visit(TypeId ty, const PendingExpansionType&) override;
+
+    bool visit(TypeId ty, const TableType& tt) override;
+
+    bool visit(TypeId ty, const ExternType&) override;
+
+    bool visit(TypeId, const TypeFunctionInstanceType& tfit) override;
+
+    bool visit(TypePackId tp, const BlockedTypePack&) override;
+    bool visit(TypePackId tp, const FreeTypePack&) override;
+};
+
+struct ReferenceCountInitializer : IterativeTypeVisitor
+{
+    NotNull<TypeArena> currentArena;
+    NotNull<TypeIds> mutatedTypes;
+    NotNull<TypePackIds> mutatedTypePacks;
+
+    explicit ReferenceCountInitializer(NotNull<TypeArena> currentArena, NotNull<TypeIds> mutatedTypes, NotNull<TypePackIds> mutatedTypePacks);
+
+    bool visit(TypeId ty) override;
 
     bool visit(TypeId ty, const FreeType&) override;
 

Analysis/include/Luau/ConstraintGenerator.h

@@ -15,7 +15,7 @@
 #include "Luau/NotNull.h"
 #include "Luau/Polarity.h"
 #include "Luau/Refinement.h"
-#include "Luau/Set.h"
+#include "Luau/DenseHash.h"
 #include "Luau/Symbol.h"
 #include "Luau/TypeFwd.h"
 #include "Luau/TypeIds.h"
@@ -201,7 +201,7 @@ struct ConstraintGenerator
 
     std::vector<TypeId> unionsToSimplify;
 
-    Set<AstName> uninitializedGlobals;
+    DenseHashSet<AstName> uninitializedGlobals;
 
     Polarity polarity = Polarity::None;
 

Analysis/include/Luau/ConstraintGraph.h

@@ -3,7 +3,6 @@
 #pragma once
 
 #include "Luau/Constraint.h"
-#include "Luau/Set.h"
 #include "Luau/ToString.h"
 #include "Luau/Type.h"
 

Analysis/include/Luau/ConstraintSolver.h

@@ -233,7 +233,7 @@ struct ConstraintSolver
         TypeId subjectType,
         TypeId indexType,
         TypeId resultType,
-        Set<TypeId>& seen
+        DenseHashSet<TypeId>& seen
     );
     bool tryDispatch(const HasIndexerConstraint& c, NotNull<const Constraint> constraint);
 
@@ -272,7 +272,7 @@ struct ConstraintSolver
         ValueContext context,
         bool inConditional,
         bool suppressSimplification,
-        Set<TypeId>& seen
+        DenseHashSet<TypeId>& seen
     );
 
     /**

Analysis/include/Luau/ControlFlowGraph.h

@@ -7,7 +7,6 @@
 #include "Luau/Symbol.h"
 #include "Luau/TypedAllocator.h"
 #include "Luau/Variant.h"
-#include "Luau/Set.h"
 
 #include <memory>
 #include <optional>
@@ -412,7 +411,7 @@ struct CFGBuilder
     DenseHashMap<Symbol, size_t> versionCounter;
 
     // Maps defs to the Instructions that use them
-    DenseHashMap<Definition*, Set<Instruction*>> usingInstructions;
+    DenseHashMap<Definition*, DenseHashSet<Instruction*>> usingInstructions;
 };
 
 } // namespace Luau::CFG

Analysis/include/Luau/Frontend.h

@@ -9,7 +9,6 @@
 #include "Luau/ModuleResolver.h"
 #include "Luau/RequireTracer.h"
 #include "Luau/Scope.h"
-#include "Luau/Set.h"
 #include "Luau/TypeCheckLimits.h"
 
 #include <mutex>
@@ -83,7 +82,7 @@ struct SourceNode
     DenseHashSet<ModuleName> requireSet;
 
     std::vector<std::pair<ModuleName, Location>> requireLocations;
-    Set<ModuleName> dependents;
+    DenseHashSet<ModuleName> dependents;
 
     bool dirtySourceModule = true;
     bool dirtyModule = true;

Analysis/include/Luau/Generalization.h

@@ -50,7 +50,7 @@ GeneralizationResult<TypePackId> generalizeTypePack(
     const GeneralizationParams<TypePackId>& params
 );
 
-void sealTable(NotNull<Scope> scope, TypeId ty);
+void sealTable(NotNull<Scope> scope, TypeId ty, TableState targetState);
 
 
 /** Attempt to generalize a type.

Analysis/include/Luau/IterativeTypeFunctionTypeVisitor.h

@@ -3,14 +3,14 @@
 
 #include "Luau/TypeFunctionRuntime.h"
 #include "Luau/TypeFwd.h"
-#include "Luau/Set.h"
+#include "Luau/DenseHash.h"
 
 namespace Luau
 {
 
 struct IterativeTypeFunctionTypeVisitor
 {
-    using SeenSet = Set<const void*>;
+    using SeenSet = DenseHashSet<const void*>;
 
     // We avoid Luau::Variant here because we can move the tag bit and make this struct 64 bits shorter.
     struct WorkItem

Analysis/include/Luau/IterativeTypeVisitor.h

@@ -3,7 +3,7 @@
 
 #include "Luau/Type.h"
 #include "Luau/TypePack.h"
-#include "Luau/Set.h"
+#include "Luau/DenseHash.h"
 
 #include <string>
 
@@ -12,7 +12,7 @@ namespace Luau
 
 struct IterativeTypeVisitor
 {
-    using SeenSet = Set<const void*>;
+    using SeenSet = DenseHashSet<const void*>;
 
     // We avoid Luau::Variant here because we can move the tag bit and make this struct 64 bits shorter.
     struct WorkItem

Analysis/include/Luau/Normalize.h

@@ -2,7 +2,7 @@
 #pragma once
 
 #include "Luau/NotNull.h"
-#include "Luau/Set.h"
+#include "Luau/DenseHash.h"
 #include "Luau/TypeFwd.h"
 #include "Luau/TypeIds.h"
 #include "Luau/UnifierSharedState.h"
@@ -297,7 +297,7 @@ struct NormalizedType
 };
 
 
-using SeenTablePropPairs = Set<std::pair<TypeId, TypeId>, TypeIdPairHash>;
+using SeenTablePropPairs = DenseHashSet<std::pair<TypeId, TypeId>, TypeIdPairHash>;
 
 class Normalizer
 {
@@ -380,7 +380,7 @@ class Normalizer
         NormalizedType& here,
         TypeId there,
         SeenTablePropPairs& seenTablePropPairs,
-        Set<TypeId>& seenSetTypes,
+        DenseHashSet<TypeId>& seenSetTypes,
         int ignoreSmallerTyvars = -1
     );
 
@@ -399,8 +399,10 @@ class Normalizer
     void intersectExternTypesWithExternType(NormalizedExternType& heres, TypeId there);
     void intersectExternTypesWithShape(NormalizedExternType& heres, TypeId there);
     void intersectStrings(NormalizedStringType& here, const NormalizedStringType& there);
-    std::optional<TypeId> intersectionOfTables(TypeId here, TypeId there, SeenTablePropPairs& seenTablePropPairs, Set<TypeId>& seenSet);
-    void intersectTablesWithTable(TypeIds& heres, TypeId there, SeenTablePropPairs& seenTablePropPairs, Set<TypeId>& seenSetTypes);
+    bool hasStringIndexer(const TableType* tt);
+    std::optional<TypeId> intersectionOfTables(TypeId here, TypeId there, SeenTablePropPairs& seenTablePropPairs, DenseHashSet<TypeId>& seenSet);
+    std::optional<TypeId> DEPRECATED_intersectionOfTables(TypeId here, TypeId there, SeenTablePropPairs& seenTablePropPairs, DenseHashSet<TypeId>& seenSet);
+    void intersectTablesWithTable(TypeIds& heres, TypeId there, SeenTablePropPairs& seenTablePropPairs, DenseHashSet<TypeId>& seenSetTypes);
     void intersectTables(TypeIds& heres, const TypeIds& theres);
     std::optional<TypeId> intersectionOfFunctions(TypeId here, TypeId there);
     void intersectFunctionsWithFunction(NormalizedFunctionType& heress, TypeId there);
@@ -409,22 +411,27 @@ class Normalizer
         NormalizedTyvars& here,
         TypeId there,
         SeenTablePropPairs& seenTablePropPairs,
-        Set<TypeId>& seenSetTypes
+        DenseHashSet<TypeId>& seenSetTypes
     );
     NormalizationResult intersectNormals(NormalizedType& here, const NormalizedType& there, int ignoreSmallerTyvars = -1);
-    NormalizationResult intersectNormalWithTy(NormalizedType& here, TypeId there, SeenTablePropPairs& seenTablePropPairs, Set<TypeId>& seenSetTypes);
+    NormalizationResult intersectNormalWithTy(
+        NormalizedType& here,
+        TypeId there,
+        SeenTablePropPairs& seenTablePropPairs,
+        DenseHashSet<TypeId>& seenSetTypes
+    );
     NormalizationResult normalizeIntersections(
         const std::vector<TypeId>& intersections,
         NormalizedType& outType,
         SeenTablePropPairs& seenTablePropPairs,
-        Set<TypeId>& seenSet
+        DenseHashSet<TypeId>& seenSet
     );
 
-    NormalizationResult isInhabited(TypeId ty, Set<TypeId>& seen);
-    NormalizationResult isInhabited(const NormalizedType* norm, Set<TypeId>& seen);
+    NormalizationResult isInhabited(TypeId ty, DenseHashSet<TypeId>& seen);
+    NormalizationResult isInhabited(const NormalizedType* norm, DenseHashSet<TypeId>& seen);
 
     // Check for intersections being inhabited
-    NormalizationResult isIntersectionInhabited(TypeId left, TypeId right, SeenTablePropPairs& seenTablePropPairs, Set<TypeId>& seenSet);
+    NormalizationResult isIntersectionInhabited(TypeId left, TypeId right, SeenTablePropPairs& seenTablePropPairs, DenseHashSet<TypeId>& seenSet);
 
 
     // Fuel setup