Sync to origin/release/692 (#2012)

Another week, another release!

## Analysis/Autocomplete

- Improve recursive type lookups by using scoped tracking of processed
types.
- Enforce recursion limits in subtyping on type packs, not just on
types.
- Simplify type checking for intersections between tables and
discriminants containing read-only table properties.
- Allow fields provided by `__index` to satisfy subtyping relationships.
- Improve the ability for the type checker to do proper generic
substitution in `for ... in` loops.
- Fix a fragment autocomplete bug that caused fragments to be selected
incorrectly in `for ... in` loops.
- Fix a crash caused by `typeof` containing an unterminated function
definition: `typeof(function())`.
- Fix a flagging issue that may have been causing stack overflows in the
previous release.

## Runtime

- Support constant folding for interpolated strings.
- Fix a bug caused by the empty string being the result of constant
folding.
- Add helper macros in Bytecode.h to help access data in Luau auxiliary
instruction bits.
- Add support for branchless `==`/`~=` comparisons in CodeGen (in
certain cases).

---

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

Author: 9 people

Analysis/include/Luau/AstUtils.h

@@ -13,7 +13,15 @@ namespace Luau
 // uniquely held references. Append these types to 'uniqueTypes'.
 void findUniqueTypes(NotNull<DenseHashSet<TypeId>> uniqueTypes, AstExpr* expr, NotNull<const DenseHashMap<const AstExpr*, TypeId>> astTypes);
 
-void findUniqueTypes(NotNull<DenseHashSet<TypeId>> uniqueTypes, AstArray<AstExpr*> exprs, NotNull<const DenseHashMap<const AstExpr*, TypeId>> astTypes);
-void findUniqueTypes(NotNull<DenseHashSet<TypeId>> uniqueTypes, const std::vector<AstExpr*>& exprs, NotNull<const DenseHashMap<const AstExpr*, TypeId>> astTypes);
+void findUniqueTypes(
+    NotNull<DenseHashSet<TypeId>> uniqueTypes,
+    AstArray<AstExpr*> exprs,
+    NotNull<const DenseHashMap<const AstExpr*, TypeId>> astTypes
+);
+void findUniqueTypes(
+    NotNull<DenseHashSet<TypeId>> uniqueTypes,
+    const std::vector<AstExpr*>& exprs,
+    NotNull<const DenseHashMap<const AstExpr*, TypeId>> astTypes
+);
 
-}
+} // namespace Luau

Analysis/include/Luau/ConstraintSolver.h

@@ -300,7 +300,7 @@ struct ConstraintSolver
         ValueContext context,
         bool inConditional,
         bool suppressSimplification,
-        DenseHashSet<TypeId>& seen
+        Set<TypeId>& seen
     );
 
     /**

Analysis/include/Luau/Subtyping.h

@@ -59,8 +59,8 @@ inline const SubtypingReasoning kEmptyReasoning = SubtypingReasoning{TypePath::k
  * isn't strictly lexical (see test nested_generic_argument_type_packs), and that nested generic packs can shadow existing ones
  * such as with the type <A...>(<A...>(A...) -> (), <A...>(A...) -> ()) -> (), which should result in three independent bindings for A... .
  * To handle this, we maintain a stack of frames, each of which contains a mapping for the generic packs bound in that scope, as well as a pointers to
- * its parent and child scopes. Inside each frame, we map the generic pack to an optional type pack, which is nullopt if we have not yet encountered a mapping
- * for that generic pack in this scope.
+ * its parent and child scopes. Inside each frame, we map the generic pack to an optional type pack, which is nullopt if we have not yet encountered a
+ * mapping for that generic pack in this scope.
  */
 
 struct MappedGenericEnvironment
@@ -282,7 +282,6 @@ struct Subtyping
     SubtypingResult cache(SubtypingEnvironment& env, SubtypingResult res, TypeId subTy, TypeId superTy);
 
     SubtypingResult isCovariantWith(SubtypingEnvironment& env, TypeId subTy, TypeId superTy, NotNull<Scope> scope);
-    SubtypingResult isCovariantWith(SubtypingEnvironment& env, TypePackId subTp, TypePackId superTp, NotNull<Scope> scope);
 
     template<typename SubTy, typename SuperTy>
     SubtypingResult isContravariantWith(SubtypingEnvironment& env, SubTy&& subTy, SuperTy&& superTy, NotNull<Scope> scope);
@@ -321,7 +320,13 @@ struct Subtyping
         NotNull<Scope> scope
     );
     SubtypingResult isCovariantWith(SubtypingEnvironment& env, const TableType* subTable, const TableType* superTable, NotNull<Scope> scope);
-    SubtypingResult isCovariantWith(SubtypingEnvironment& env, const TableType* subTable, const TableType* superTable, bool forceCovariantTest, NotNull<Scope> scope);
+    SubtypingResult isCovariantWith(
+        SubtypingEnvironment& env,
+        const TableType* subTable,
+        const TableType* superTable,
+        bool forceCovariantTest,
+        NotNull<Scope> scope
+    );
     SubtypingResult isCovariantWith(SubtypingEnvironment& env, const MetatableType* subMt, const MetatableType* superMt, NotNull<Scope> scope);
     SubtypingResult isCovariantWith(SubtypingEnvironment& env, const MetatableType* subMt, const TableType* superTable, NotNull<Scope> scope);
     SubtypingResult isCovariantWith(
@@ -420,6 +425,31 @@ struct Subtyping
         NotNull<Scope> scope
     );
 
+    // Pack subtyping
+    SubtypingResult isCovariantWith(SubtypingEnvironment& env, TypePackId subTp, TypePackId superTp, NotNull<Scope> scope);
+    std::optional<SubtypingResult> isSubTailCovariantWith(
+        SubtypingEnvironment& env,
+        std::vector<SubtypingResult>& outputResults,
+        TypePackId subTp,
+        TypePackId subTail,
+        TypePackId superTp,
+        size_t superHeadStartIndex,
+        const std::vector<TypeId>& superHead,
+        std::optional<TypePackId> superTail,
+        NotNull<Scope> scope
+    );
+    std::optional<SubtypingResult> isCovariantWithSuperTail(
+        SubtypingEnvironment& env,
+        std::vector<SubtypingResult>& outputResults,
+        TypePackId subTp,
+        size_t subHeadStartIndex,
+        const std::vector<TypeId>& subHead,
+        std::optional<TypePackId> subTail,
+        TypePackId superTp,
+        TypePackId superTail,
+        NotNull<Scope> scope
+    );
+
     bool bindGeneric(SubtypingEnvironment& env, TypeId subTp, TypeId superTp);
     // Clip with LuauSubtypingGenericPacksDoesntUseVariance
     bool bindGeneric_DEPRECATED(SubtypingEnvironment& env, TypePackId subTp, TypePackId superTp) const;

Analysis/include/Luau/TypeChecker2.h

@@ -200,6 +200,12 @@ struct TypeChecker2
 
     bool testIsSubtype(TypeId subTy, TypeId superTy, Location location);
     bool testIsSubtype(TypePackId subTy, TypePackId superTy, Location location);
+
+    void maybeReportSubtypingError(TypeId subTy, TypeId superTy, const Location& location);
+    // Tests whether subTy is a subtype of superTy in the context of a function iterator for a for-in statement.
+    // Includes some extra logic to help locate errors to the values and variables of the for-in statement.
+    void testIsSubtypeForInStat(TypeId iterFunc, TypeId prospectiveFunc, const AstStatForIn& forInStat);
+
     void reportError(TypeError e);
     void reportErrors(ErrorVec errors);
     PropertyTypes lookupProp(

Analysis/include/Luau/TypePack.h

@@ -267,7 +267,7 @@ LUAU_NOINLINE Unifiable::Bound<TypePackId>* emplaceTypePack<BoundTypePack>(TypeP
 TypePackId sliceTypePack(
     size_t sliceIndex,
     TypePackId toBeSliced,
-    std::vector<TypeId>& head,
+    const std::vector<TypeId>& head,
     std::optional<TypePackId> tail,
     NotNull<BuiltinTypes> builtinTypes,
     NotNull<TypeArena> arena

Analysis/include/Luau/TypePath.h

@@ -242,18 +242,13 @@ std::string toString(const TypePath::Path& path, bool prefixDot = false);
 std::string toStringHuman(const TypePath::Path& path);
 
 // To keep my head straight when clipping:
-// LuauReturnMappedGenericPacksFromSubtyping2 expects mappedGenericPacks AND arena
+// LuauReturnMappedGenericPacksFromSubtyping3 expects mappedGenericPacks AND arena
 // LuauSubtypingGenericPacksDoesntUseVariance expects just arena. this is the final state
 
-// TODO: clip below two along with `LuauReturnMappedGenericPacksFromSubtyping2`
+// TODO: clip below two along with `LuauReturnMappedGenericPacksFromSubtyping3`
 std::optional<TypeOrPack> traverse_DEPRECATED(TypeId root, const Path& path, NotNull<BuiltinTypes> builtinTypes);
 std::optional<TypeOrPack> traverse_DEPRECATED(TypePackId root, const Path& path, NotNull<BuiltinTypes> builtinTypes);
-std::optional<TypeOrPack> traverse(
-    TypePackId root,
-    const Path& path,
-    NotNull<BuiltinTypes> builtinTypes,
-    NotNull<TypeArena> arena
-);
+std::optional<TypeOrPack> traverse(TypePackId root, const Path& path, NotNull<BuiltinTypes> builtinTypes, NotNull<TypeArena> arena);
 // TODO: Clip with LuauSubtypingGenericPacksDoesntUseVariance
 std::optional<TypeOrPack> traverse_DEPRECATED(
     TypePackId root,
@@ -262,12 +257,7 @@ std::optional<TypeOrPack> traverse_DEPRECATED(
     NotNull<const DenseHashMap<TypePackId, TypePackId>> mappedGenericPacks,
     NotNull<TypeArena> arena
 );
-std::optional<TypeOrPack> traverse(
-    TypeId root,
-    const Path& path,
-    NotNull<BuiltinTypes> builtinTypes,
-    NotNull<TypeArena> arena
-);
+std::optional<TypeOrPack> traverse(TypeId root, const Path& path, NotNull<BuiltinTypes> builtinTypes, NotNull<TypeArena> arena);
 // TODO: Clip with LuauSubtypingGenericPacksDoesntUseVariance
 std::optional<TypeOrPack> traverse_DEPRECATED(
     TypeId root,
@@ -306,12 +296,7 @@ std::optional<TypeId> traverseForType_DEPRECATED(
 /// @param builtinTypes the built-in types in use (used to acquire the string metatable)
 /// @param arena a TypeArena, required if path has a PackSlice component
 /// @returns the TypeId at the end of the path, or nullopt if the traversal failed.
-std::optional<TypeId> traverseForType(
-    TypeId root,
-    const Path& path,
-    NotNull<BuiltinTypes> builtinTypes,
-    NotNull<TypeArena> arena
-);
+std::optional<TypeId> traverseForType(TypeId root, const Path& path, NotNull<BuiltinTypes> builtinTypes, NotNull<TypeArena> arena);
 
 /// Traverses a path from a type pack to its end point, which must be a type.
 /// @param root the entry point of the traversal
@@ -341,12 +326,7 @@ std::optional<TypeId> traverseForType_DEPRECATED(
 /// @param builtinTypes the built-in types in use (used to acquire the string metatable)
 /// @param arena a TypeArena, required if path has a PackSlice component
 /// @returns the TypeId at the end of the path, or nullopt if the traversal failed.
-std::optional<TypeId> traverseForType(
-    TypePackId root,
-    const Path& path,
-    NotNull<BuiltinTypes> builtinTypes,
-    NotNull<TypeArena> arena
-);
+std::optional<TypeId> traverseForType(TypePackId root, const Path& path, NotNull<BuiltinTypes> builtinTypes, NotNull<TypeArena> arena);
 
 /// Traverses a path from a type to its end point, which must be a type pack. This overload will fail if the path contains a PackSlice component or a
 /// mapped generic pack.
@@ -377,12 +357,7 @@ std::optional<TypePackId> traverseForPack_DEPRECATED(
 /// @param builtinTypes the built-in types in use (used to acquire the string metatable)
 /// @param arena a TypeArena, required if path has a PackSlice component
 /// @returns the TypePackId at the end of the path, or nullopt if the traversal failed.
-std::optional<TypePackId> traverseForPack(
-    TypeId root,
-    const Path& path,
-    NotNull<BuiltinTypes> builtinTypes,
-    NotNull<TypeArena> arena
-);
+std::optional<TypePackId> traverseForPack(TypeId root, const Path& path, NotNull<BuiltinTypes> builtinTypes, NotNull<TypeArena> arena);
 
 /// Traverses a path from a type pack to its end point, which must be a type pack.
 /// @param root the entry point of the traversal
@@ -412,12 +387,7 @@ std::optional<TypePackId> traverseForPack_DEPRECATED(
 /// @param builtinTypes the built-in types in use (used to acquire the string metatable)
 /// @param arena a TypeArena, required if path has a PackSlice component
 /// @returns the TypePackId at the end of the path, or nullopt if the traversal failed.
-std::optional<TypePackId> traverseForPack(
-    TypePackId root,
-    const Path& path,
-    NotNull<BuiltinTypes> builtinTypes,
-    NotNull<TypeArena> arena
-);
+std::optional<TypePackId> traverseForPack(TypePackId root, const Path& path, NotNull<BuiltinTypes> builtinTypes, NotNull<TypeArena> arena);
 
 /// Traverses a path of Index and PackSlices to compute the index of the type the path points to
 /// Returns std::nullopt if the path isn't n PackSlice components followed by an Index component

Analysis/include/Luau/VisitType.h

@@ -336,7 +336,7 @@ struct GenericTypeVisitor
                 {
                     if (auto ty = prop.readTy)
                         traverse(*ty);
-                    
+
                     // In the case that the readType and the writeType are
                     // the same pointer, just traverse once. Traversing each
                     // property twice would have pretty significant

Analysis/src/AstUtils.cpp

@@ -14,7 +14,8 @@ struct AstExprTableFinder : AstVisitor
     explicit AstExprTableFinder(NotNull<DenseHashSet<TypeId>> result, NotNull<const DenseHashMap<const AstExpr*, TypeId>> astTypes)
         : result(result)
         , astTypes(astTypes)
-    {}
+    {
+    }
 
     bool visit(AstExpr* expr) override
     {
@@ -38,8 +39,13 @@ void findUniqueTypes(NotNull<DenseHashSet<TypeId>> uniqueTypes, AstExpr* expr, N
     expr->visit(&finder);
 }
 
-template <typename Iter>
-void findUniqueTypes(NotNull<DenseHashSet<TypeId>> uniqueTypes, Iter startIt, Iter endIt, NotNull<const DenseHashMap<const AstExpr*, TypeId>> astTypes)
+template<typename Iter>
+void findUniqueTypes(
+    NotNull<DenseHashSet<TypeId>> uniqueTypes,
+    Iter startIt,
+    Iter endIt,
+    NotNull<const DenseHashMap<const AstExpr*, TypeId>> astTypes
+)
 {
     while (startIt != endIt)
     {
@@ -51,14 +57,22 @@ void findUniqueTypes(NotNull<DenseHashSet<TypeId>> uniqueTypes, Iter startIt, It
 }
 
 
-void findUniqueTypes(NotNull<DenseHashSet<TypeId>> uniqueTypes, AstArray<AstExpr*> exprs, NotNull<const DenseHashMap<const AstExpr*, TypeId>> astTypes)
+void findUniqueTypes(
+    NotNull<DenseHashSet<TypeId>> uniqueTypes,
+    AstArray<AstExpr*> exprs,
+    NotNull<const DenseHashMap<const AstExpr*, TypeId>> astTypes
+)
 {
     findUniqueTypes(uniqueTypes, exprs.begin(), exprs.end(), astTypes);
 }
 
-void findUniqueTypes(NotNull<DenseHashSet<TypeId>> uniqueTypes, const std::vector<AstExpr*>& exprs, NotNull<const DenseHashMap<const AstExpr*, TypeId>> astTypes)
+void findUniqueTypes(
+    NotNull<DenseHashSet<TypeId>> uniqueTypes,
+    const std::vector<AstExpr*>& exprs,
+    NotNull<const DenseHashMap<const AstExpr*, TypeId>> astTypes
+)
 {
     findUniqueTypes(uniqueTypes, exprs.begin(), exprs.end(), astTypes);
 }
 
-}
+} // namespace Luau

Analysis/src/Constraint.cpp

@@ -5,6 +5,7 @@
 #include "Luau/VisitType.h"
 
 LUAU_FASTFLAGVARIABLE(LuauExplicitSkipBoundTypes)
+LUAU_FASTFLAG(LuauNoOrderingTypeFunctions)
 
 namespace Luau
 {
@@ -87,7 +88,8 @@ TypeIds Constraint::getMaybeMutatedFreeTypes() const
     if (auto ec = get<EqualityConstraint>(*this))
     {
         rci.traverse(ec->resultType);
-        // `EqualityConstraints` should not mutate `assignmentType`.
+        if (FFlag::LuauNoOrderingTypeFunctions)
+            rci.traverse(ec->assignmentType);
     }
     else if (auto sc = get<SubtypeConstraint>(*this))
     {