Sync to upstream/release/565 (#845)

We've made a few small changes to reduce the amount of stack we use when
typechecking nested method calls (eg `foo:bar():baz():quux()`).

We've also fixed a small bytecode compiler issue that caused us to emit
redundant jump instructions in code that conditionally uses `break` or
`continue`.

On the new solver, we've switched to a new, better way to handle
augmentations to unsealed tables. We've also made some substantial
improvements to type inference and error reporting on function calls.
These things should both be on par with the old solver now.

The main improvements to the native code generator have been elimination
of some redundant type tag checks. Also, we are starting to inline
particular fastcalls directly to IR.

---------

Co-authored-by: Arseny Kapoulkine <[email protected]>
Co-authored-by: Vyacheslav Egorov <[email protected]>

Analysis/include/Luau/Constraint.h

@@ -159,6 +159,20 @@ struct SetPropConstraint
     TypeId propType;
 };
 
+// result ~ setIndexer subjectType indexType propType
+//
+// If the subject is a table or table-like thing that already has an indexer,
+// unify its indexType and propType with those from this constraint.
+//
+// If the table is a free or unsealed table, we augment it with a new indexer.
+struct SetIndexerConstraint
+{
+    TypeId resultType;
+    TypeId subjectType;
+    TypeId indexType;
+    TypeId propType;
+};
+
 // if negation:
 //   result ~ if isSingleton D then ~D else unknown where D = discriminantType
 // if not negation:
@@ -170,9 +184,19 @@ struct SingletonOrTopTypeConstraint
     bool negated;
 };
 
+// resultType ~ unpack sourceTypePack
+//
+// Similar to PackSubtypeConstraint, but with one important difference: If the
+// sourcePack is blocked, this constraint blocks.
+struct UnpackConstraint
+{
+    TypePackId resultPack;
+    TypePackId sourcePack;
+};
+
 using ConstraintV = Variant<SubtypeConstraint, PackSubtypeConstraint, GeneralizationConstraint, InstantiationConstraint, UnaryConstraint,
     BinaryConstraint, IterableConstraint, NameConstraint, TypeAliasExpansionConstraint, FunctionCallConstraint, PrimitiveTypeConstraint,
-    HasPropConstraint, SetPropConstraint, SingletonOrTopTypeConstraint>;
+    HasPropConstraint, SetPropConstraint, SetIndexerConstraint, SingletonOrTopTypeConstraint, UnpackConstraint>;
 
 struct Constraint
 {

Analysis/include/Luau/ConstraintGraphBuilder.h

@@ -191,7 +191,7 @@ struct ConstraintGraphBuilder
     Inference check(const ScopePtr& scope, AstExprTable* expr, std::optional<TypeId> expectedType);
     std::tuple<TypeId, TypeId, RefinementId> checkBinary(const ScopePtr& scope, AstExprBinary* binary, std::optional<TypeId> expectedType);
 
-    TypePackId checkLValues(const ScopePtr& scope, AstArray<AstExpr*> exprs);
+    std::vector<TypeId> checkLValues(const ScopePtr& scope, AstArray<AstExpr*> exprs);
 
     TypeId checkLValue(const ScopePtr& scope, AstExpr* expr);
 
@@ -244,10 +244,31 @@ struct ConstraintGraphBuilder
      **/
     TypePackId resolveTypePack(const ScopePtr& scope, const AstTypeList& list, bool inTypeArguments);
 
+    /**
+     * Creates generic types given a list of AST definitions, resolving default
+     * types as required.
+     * @param scope the scope that the generics should belong to.
+     * @param generics the AST generics to create types for.
+     * @param useCache whether to use the generic type cache for the given
+     * scope.
+     * @param addTypes whether to add the types to the scope's
+     * privateTypeBindings map.
+     **/
     std::vector<std::pair<Name, GenericTypeDefinition>> createGenerics(
-        const ScopePtr& scope, AstArray<AstGenericType> generics, bool useCache = false);
+        const ScopePtr& scope, AstArray<AstGenericType> generics, bool useCache = false, bool addTypes = true);
+
+    /**
+     * Creates generic type packs given a list of AST definitions, resolving
+     * default type packs as required.
+     * @param scope the scope that the generic packs should belong to.
+     * @param generics the AST generics to create type packs for.
+     * @param useCache whether to use the generic type pack cache for the given
+     * scope.
+     * @param addTypes whether to add the types to the scope's
+     * privateTypePackBindings map.
+     **/
     std::vector<std::pair<Name, GenericTypePackDefinition>> createGenericPacks(
-        const ScopePtr& scope, AstArray<AstGenericTypePack> packs, bool useCache = false);
+        const ScopePtr& scope, AstArray<AstGenericTypePack> packs, bool useCache = false, bool addTypes = true);
 
     Inference flattenPack(const ScopePtr& scope, Location location, InferencePack pack);
 

Analysis/include/Luau/ConstraintSolver.h

@@ -8,6 +8,7 @@
 #include "Luau/Normalize.h"
 #include "Luau/ToString.h"
 #include "Luau/Type.h"
+#include "Luau/TypeReduction.h"
 #include "Luau/Variant.h"
 
 #include <vector>
@@ -19,7 +20,12 @@ struct DcrLogger;
 
 // TypeId, TypePackId, or Constraint*. It is impossible to know which, but we
 // never dereference this pointer.
-using BlockedConstraintId = const void*;
+using BlockedConstraintId = Variant<TypeId, TypePackId, const Constraint*>;
+
+struct HashBlockedConstraintId
+{
+    size_t operator()(const BlockedConstraintId& bci) const;
+};
 
 struct ModuleResolver;
 
@@ -47,6 +53,7 @@ struct ConstraintSolver
     NotNull<BuiltinTypes> builtinTypes;
     InternalErrorReporter iceReporter;
     NotNull<Normalizer> normalizer;
+    NotNull<TypeReduction> reducer;
     // The entire set of constraints that the solver is trying to resolve.
     std::vector<NotNull<Constraint>> constraints;
     NotNull<Scope> rootScope;
@@ -65,7 +72,7 @@ struct ConstraintSolver
     // anything.
     std::unordered_map<NotNull<const Constraint>, size_t> blockedConstraints;
     // A mapping of type/pack pointers to the constraints they block.
-    std::unordered_map<BlockedConstraintId, std::vector<NotNull<const Constraint>>> blocked;
+    std::unordered_map<BlockedConstraintId, std::vector<NotNull<const Constraint>>, HashBlockedConstraintId> blocked;
     // Memoized instantiations of type aliases.
     DenseHashMap<InstantiationSignature, TypeId, HashInstantiationSignature> instantiatedAliases{{}};
 
@@ -78,7 +85,8 @@ struct ConstraintSolver
     DcrLogger* logger;
 
     explicit ConstraintSolver(NotNull<Normalizer> normalizer, NotNull<Scope> rootScope, std::vector<NotNull<Constraint>> constraints,
-        ModuleName moduleName, NotNull<ModuleResolver> moduleResolver, std::vector<RequireCycle> requireCycles, DcrLogger* logger);
+        ModuleName moduleName, NotNull<TypeReduction> reducer, NotNull<ModuleResolver> moduleResolver, std::vector<RequireCycle> requireCycles,
+        DcrLogger* logger);
 
     // Randomize the order in which to dispatch constraints
     void randomize(unsigned seed);
@@ -112,7 +120,9 @@ struct ConstraintSolver
     bool tryDispatch(const PrimitiveTypeConstraint& c, NotNull<const Constraint> constraint);
     bool tryDispatch(const HasPropConstraint& c, NotNull<const Constraint> constraint);
     bool tryDispatch(const SetPropConstraint& c, NotNull<const Constraint> constraint, bool force);
+    bool tryDispatch(const SetIndexerConstraint& c, NotNull<const Constraint> constraint, bool force);
     bool tryDispatch(const SingletonOrTopTypeConstraint& c, NotNull<const Constraint> constraint);
+    bool tryDispatch(const UnpackConstraint& c, NotNull<const Constraint> constraint);
 
     // for a, ... in some_table do
     // also handles __iter metamethod
@@ -123,6 +133,7 @@ struct ConstraintSolver
         TypeId nextTy, TypeId tableTy, TypeId firstIndexTy, const IterableConstraint& c, NotNull<const Constraint> constraint, bool force);
 
     std::optional<TypeId> lookupTableProp(TypeId subjectType, const std::string& propName);
+    std::optional<TypeId> lookupTableProp(TypeId subjectType, const std::string& propName, std::unordered_set<TypeId>& seen);
 
     void block(NotNull<const Constraint> target, NotNull<const Constraint> constraint);
     /**

Analysis/include/Luau/DcrLogger.h

@@ -4,6 +4,7 @@
 #include "Luau/Constraint.h"
 #include "Luau/NotNull.h"
 #include "Luau/Scope.h"
+#include "Luau/Module.h"
 #include "Luau/ToString.h"
 #include "Luau/Error.h"
 #include "Luau/Variant.h"
@@ -34,11 +35,26 @@ struct TypeBindingSnapshot
     std::string typeString;
 };
 
+struct ExprTypesAtLocation
+{
+    Location location;
+    TypeId ty;
+    std::optional<TypeId> expectedTy;
+};
+
+struct AnnotationTypesAtLocation
+{
+    Location location;
+    TypeId resolvedTy;
+};
+
 struct ConstraintGenerationLog
 {
     std::string source;
-    std::unordered_map<std::string, Location> constraintLocations;
     std::vector<ErrorSnapshot> errors;
+
+    std::vector<ExprTypesAtLocation> exprTypeLocations;
+    std::vector<AnnotationTypesAtLocation> annotationTypeLocations;
 };
 
 struct ScopeSnapshot
@@ -49,16 +65,11 @@ struct ScopeSnapshot
     std::vector<ScopeSnapshot> children;
 };
 
-enum class ConstraintBlockKind
-{
-    TypeId,
-    TypePackId,
-    ConstraintId,
-};
+using ConstraintBlockTarget = Variant<TypeId, TypePackId, NotNull<const Constraint>>;
 
 struct ConstraintBlock
 {
-    ConstraintBlockKind kind;
+    ConstraintBlockTarget target;
     std::string stringification;
 };
 
@@ -71,16 +82,18 @@ struct ConstraintSnapshot
 
 struct BoundarySnapshot
 {
-    std::unordered_map<std::string, ConstraintSnapshot> constraints;
+    DenseHashMap<const Constraint*, ConstraintSnapshot> unsolvedConstraints{nullptr};
     ScopeSnapshot rootScope;
+    DenseHashMap<const void*, std::string> typeStrings{nullptr};
 };
 
 struct StepSnapshot
 {
-    std::string currentConstraint;
+    const Constraint* currentConstraint;
     bool forced;
-    std::unordered_map<std::string, ConstraintSnapshot> unsolvedConstraints;
+    DenseHashMap<const Constraint*, ConstraintSnapshot> unsolvedConstraints{nullptr};
     ScopeSnapshot rootScope;
+    DenseHashMap<const void*, std::string> typeStrings{nullptr};
 };
 
 struct TypeSolveLog
@@ -95,15 +108,14 @@ struct TypeCheckLog
     std::vector<ErrorSnapshot> errors;
 };
 
-using ConstraintBlockTarget = Variant<TypeId, TypePackId, NotNull<const Constraint>>;
-
 struct DcrLogger
 {
     std::string compileOutput();
 
     void captureSource(std::string source);
     void captureGenerationError(const TypeError& error);
     void captureConstraintLocation(NotNull<const Constraint> constraint, Location location);
+    void captureGenerationModule(const ModulePtr& module);
 
     void pushBlock(NotNull<const Constraint> constraint, TypeId block);
     void pushBlock(NotNull<const Constraint> constraint, TypePackId block);
@@ -126,9 +138,10 @@ struct DcrLogger
     TypeSolveLog solveLog;
     TypeCheckLog checkLog;
 
-    ToStringOptions opts;
+    ToStringOptions opts{true};
 
     std::vector<ConstraintBlock> snapshotBlocks(NotNull<const Constraint> constraint);
+    void captureBoundaryState(BoundarySnapshot& target, const Scope* rootScope, const std::vector<NotNull<const Constraint>>& unsolvedConstraints);
 };
 
 } // namespace Luau

Analysis/include/Luau/Scope.h

@@ -52,7 +52,7 @@ struct Scope
 
     std::optional<TypeId> lookup(Symbol sym) const;
     std::optional<TypeId> lookup(DefId def) const;
-    std::optional<std::pair<TypeId, Scope*>> lookupEx(Symbol sym);
+    std::optional<std::pair<Binding*, Scope*>> lookupEx(Symbol sym);
 
     std::optional<TypeFun> lookupType(const Name& name);
     std::optional<TypeFun> lookupImportedType(const Name& moduleAlias, const Name& name);

Analysis/include/Luau/Symbol.h

@@ -37,6 +37,11 @@ struct Symbol
     AstLocal* local;
     AstName global;
 
+    explicit operator bool() const
+    {
+        return local != nullptr || global.value != nullptr;
+    }
+
     bool operator==(const Symbol& rhs) const
     {
         if (local)

Analysis/include/Luau/Type.h

@@ -246,6 +246,18 @@ struct WithPredicate
 {
     T type;
     PredicateVec predicates;
+
+    WithPredicate() = default;
+    explicit WithPredicate(T type)
+        : type(type)
+    {
+    }
+
+    WithPredicate(T type, PredicateVec predicates)
+        : type(type)
+        , predicates(std::move(predicates))
+    {
+    }
 };
 
 using MagicFunction = std::function<std::optional<WithPredicate<TypePackId>>(
@@ -853,4 +865,15 @@ bool hasTag(TypeId ty, const std::string& tagName);
 bool hasTag(const Property& prop, const std::string& tagName);
 bool hasTag(const Tags& tags, const std::string& tagName); // Do not use in new work.
 
+/*
+ * Use this to change the kind of a particular type.
+ *
+ * LUAU_NOINLINE so that the calling frame doesn't have to pay the stack storage for the new variant.
+ */
+template<typename T, typename... Args>
+LUAU_NOINLINE T* emplaceType(Type* ty, Args&&... args)
+{
+    return &ty->ty.emplace<T>(std::forward<Args>(args)...);
+}
+
 } // namespace Luau

Analysis/include/Luau/TypeInfer.h

@@ -146,10 +146,12 @@ struct TypeChecker
 
     WithPredicate<TypePackId> checkExprPackHelper(const ScopePtr& scope, const AstExpr& expr);
     WithPredicate<TypePackId> checkExprPackHelper(const ScopePtr& scope, const AstExprCall& expr);
+    WithPredicate<TypePackId> checkExprPackHelper2(
+        const ScopePtr& scope, const AstExprCall& expr, TypeId selfType, TypeId actualFunctionType, TypeId functionType, TypePackId retPack);
 
     std::vector<std::optional<TypeId>> getExpectedTypesForCall(const std::vector<TypeId>& overloads, size_t argumentCount, bool selfCall);
 
-    std::optional<WithPredicate<TypePackId>> checkCallOverload(const ScopePtr& scope, const AstExprCall& expr, TypeId fn, TypePackId retPack,
+    std::unique_ptr<WithPredicate<TypePackId>> checkCallOverload(const ScopePtr& scope, const AstExprCall& expr, TypeId fn, TypePackId retPack,
         TypePackId argPack, TypePack* args, const std::vector<Location>* argLocations, const WithPredicate<TypePackId>& argListResult,
         std::vector<TypeId>& overloadsThatMatchArgCount, std::vector<TypeId>& overloadsThatDont, std::vector<OverloadErrorEntry>& errors);
     bool handleSelfCallMismatch(const ScopePtr& scope, const AstExprCall& expr, TypePack* args, const std::vector<Location>& argLocations,

Analysis/include/Luau/TypeReduction.h

@@ -12,11 +12,36 @@ namespace Luau
 namespace detail
 {
 template<typename T>
-struct ReductionContext
+struct ReductionEdge
 {
     T type = nullptr;
     bool irreducible = false;
 };
+
+struct TypeReductionMemoization
+{
+    TypeReductionMemoization() = default;
+
+    TypeReductionMemoization(const TypeReductionMemoization&) = delete;
+    TypeReductionMemoization& operator=(const TypeReductionMemoization&) = delete;
+
+    TypeReductionMemoization(TypeReductionMemoization&&) = default;
+    TypeReductionMemoization& operator=(TypeReductionMemoization&&) = default;
+
+    DenseHashMap<TypeId, ReductionEdge<TypeId>> types{nullptr};
+    DenseHashMap<TypePackId, ReductionEdge<TypePackId>> typePacks{nullptr};
+
+    bool isIrreducible(TypeId ty);
+    bool isIrreducible(TypePackId tp);
+
+    TypeId memoize(TypeId ty, TypeId reducedTy);
+    TypePackId memoize(TypePackId tp, TypePackId reducedTp);
+
+    // Reducing A into B may have a non-irreducible edge A to B for which B is not irreducible, which means B could be reduced into C.
+    // Because reduction should always be transitive, A should point to C if A points to B and B points to C.
+    std::optional<ReductionEdge<TypeId>> memoizedof(TypeId ty) const;
+    std::optional<ReductionEdge<TypePackId>> memoizedof(TypePackId tp) const;
+};
 } // namespace detail
 
 struct TypeReductionOptions
@@ -42,29 +67,19 @@ struct TypeReduction
     std::optional<TypePackId> reduce(TypePackId tp);
     std::optional<TypeFun> reduce(const TypeFun& fun);
 
-    /// Creating a child TypeReduction will allow the parent TypeReduction to share its memoization with the child TypeReductions.
-    /// This is safe as long as the parent's TypeArena continues to outlive both TypeReduction memoization.
-    TypeReduction fork(NotNull<TypeArena> arena, const TypeReductionOptions& opts = {}) const;
-
 private:
-    const TypeReduction* parent = nullptr;
-
     NotNull<TypeArena> arena;
     NotNull<BuiltinTypes> builtinTypes;
     NotNull<struct InternalErrorReporter> handle;
-    TypeReductionOptions options;
 
-    DenseHashMap<TypeId, detail::ReductionContext<TypeId>> memoizedTypes{nullptr};
-    DenseHashMap<TypePackId, detail::ReductionContext<TypePackId>> memoizedTypePacks{nullptr};
+    TypeReductionOptions options;
+    detail::TypeReductionMemoization memoization;
 
     // Computes an *estimated length* of the cartesian product of the given type.
     size_t cartesianProductSize(TypeId ty) const;
 
     bool hasExceededCartesianProductLimit(TypeId ty) const;
     bool hasExceededCartesianProductLimit(TypePackId tp) const;
-
-    std::optional<TypeId> memoizedof(TypeId ty) const;
-    std::optional<TypePackId> memoizedof(TypePackId tp) const;
 };
 
 } // namespace Luau