Sync to upstream/release/645

Analysis/include/Luau/ConstraintSolver.h

@@ -12,6 +12,7 @@
 #include "Luau/ToString.h"
 #include "Luau/Type.h"
 #include "Luau/TypeCheckLimits.h"
+#include "Luau/TypeFunction.h"
 #include "Luau/TypeFwd.h"
 #include "Luau/Variant.h"
 
@@ -62,6 +63,7 @@ struct ConstraintSolver
     NotNull<BuiltinTypes> builtinTypes;
     InternalErrorReporter iceReporter;
     NotNull<Normalizer> normalizer;
+    NotNull<TypeFunctionRuntime> typeFunctionRuntime;
     // The entire set of constraints that the solver is trying to resolve.
     std::vector<NotNull<Constraint>> constraints;
     NotNull<Scope> rootScope;
@@ -111,6 +113,7 @@ struct ConstraintSolver
 
     explicit ConstraintSolver(
         NotNull<Normalizer> normalizer,
+        NotNull<TypeFunctionRuntime> typeFunctionRuntime,
         NotNull<Scope> rootScope,
         std::vector<NotNull<Constraint>> constraints,
         ModuleName moduleName,
@@ -278,18 +281,18 @@ struct ConstraintSolver
     /**
      * @returns true if the TypeId is in a blocked state.
      */
-    bool isBlocked(TypeId ty);
+    bool isBlocked(TypeId ty) const;
 
     /**
      * @returns true if the TypePackId is in a blocked state.
      */
-    bool isBlocked(TypePackId tp);
+    bool isBlocked(TypePackId tp) const;
 
     /**
      * Returns whether the constraint is blocked on anything.
      * @param constraint the constraint to check.
      */
-    bool isBlocked(NotNull<const Constraint> constraint);
+    bool isBlocked(NotNull<const Constraint> constraint) const;
 
     /** Pushes a new solver constraint to the solver.
      * @param cv the body of the constraint.
@@ -381,8 +384,8 @@ struct ConstraintSolver
 
     TypePackId anyifyModuleReturnTypePackGenerics(TypePackId tp);
 
-    void throwTimeLimitError();
-    void throwUserCancelError();
+    void throwTimeLimitError() const;
+    void throwUserCancelError() const;
 
     ToStringOptions opts;
 };

Analysis/include/Luau/Error.h

@@ -448,6 +448,13 @@ struct UnexpectedTypePackInSubtyping
     bool operator==(const UnexpectedTypePackInSubtyping& rhs) const;
 };
 
+struct UserDefinedTypeFunctionError
+{
+    std::string message;
+
+    bool operator==(const UserDefinedTypeFunctionError& rhs) const;
+};
+
 using TypeErrorData = Variant<
     TypeMismatch,
     UnknownSymbol,
@@ -496,7 +503,8 @@ using TypeErrorData = Variant<
     CheckedFunctionIncorrectArgs,
     UnexpectedTypeInSubtyping,
     UnexpectedTypePackInSubtyping,
-    ExplicitFunctionAnnotationRecommended>;
+    ExplicitFunctionAnnotationRecommended,
+    UserDefinedTypeFunctionError>;
 
 struct TypeErrorSummary
 {

Analysis/include/Luau/FragmentAutocomplete.h

@@ -0,0 +1,23 @@
+// This file is part of the Luau programming language and is licensed under MIT License; see LICENSE.txt for details
+#pragma once
+
+#include "Luau/DenseHash.h"
+#include "Luau/Ast.h"
+
+#include <vector>
+
+
+namespace Luau
+{
+
+struct FragmentAutocompleteAncestryResult
+{
+    DenseHashMap<AstName, AstLocal*> localMap{AstName()};
+    std::vector<AstLocal*> localStack;
+    std::vector<AstNode*> ancestry;
+    AstStat* nearestStatement;
+};
+
+FragmentAutocompleteAncestryResult findAncestryForFragmentParse(AstStatBlock* root, const Position& cursorPos);
+
+} // namespace Luau

Analysis/include/Luau/OverloadResolution.h

@@ -35,6 +35,7 @@ struct OverloadResolver
         NotNull<BuiltinTypes> builtinTypes,
         NotNull<TypeArena> arena,
         NotNull<Normalizer> normalizer,
+        NotNull<TypeFunctionRuntime> typeFunctionRuntime,
         NotNull<Scope> scope,
         NotNull<InternalErrorReporter> reporter,
         NotNull<TypeCheckLimits> limits,
@@ -44,6 +45,7 @@ struct OverloadResolver
     NotNull<BuiltinTypes> builtinTypes;
     NotNull<TypeArena> arena;
     NotNull<Normalizer> normalizer;
+    NotNull<TypeFunctionRuntime> typeFunctionRuntime;
     NotNull<Scope> scope;
     NotNull<InternalErrorReporter> ice;
     NotNull<TypeCheckLimits> limits;
@@ -109,6 +111,7 @@ SolveResult solveFunctionCall(
     NotNull<TypeArena> arena,
     NotNull<BuiltinTypes> builtinTypes,
     NotNull<Normalizer> normalizer,
+    NotNull<TypeFunctionRuntime> typeFunctionRuntime,
     NotNull<InternalErrorReporter> iceReporter,
     NotNull<TypeCheckLimits> limits,
     NotNull<Scope> scope,

Analysis/include/Luau/Subtyping.h

@@ -135,6 +135,7 @@ struct Subtyping
     NotNull<BuiltinTypes> builtinTypes;
     NotNull<TypeArena> arena;
     NotNull<Normalizer> normalizer;
+    NotNull<TypeFunctionRuntime> typeFunctionRuntime;
     NotNull<InternalErrorReporter> iceReporter;
 
     TypeCheckLimits limits;
@@ -155,6 +156,7 @@ struct Subtyping
         NotNull<BuiltinTypes> builtinTypes,
         NotNull<TypeArena> typeArena,
         NotNull<Normalizer> normalizer,
+        NotNull<TypeFunctionRuntime> typeFunctionRuntime,
         NotNull<InternalErrorReporter> iceReporter
     );
 

Analysis/include/Luau/TypeChecker2.h

@@ -83,6 +83,7 @@ struct TypeChecker2
     DenseHashSet<TypeId> seenTypeFunctionInstances{nullptr};
 
     Normalizer normalizer;
+    TypeFunctionRuntime typeFunctionRuntime;
     Subtyping _subtyping;
     NotNull<Subtyping> subtyping;
 

Analysis/include/Luau/TypeFunction.h

@@ -1,10 +1,11 @@
 // This file is part of the Luau programming language and is licensed under MIT License; see LICENSE.txt for details
 #pragma once
 
-#include "Luau/ConstraintSolver.h"
+#include "Luau/Constraint.h"
 #include "Luau/Error.h"
 #include "Luau/NotNull.h"
 #include "Luau/TypeCheckLimits.h"
+#include "Luau/TypeFunctionRuntime.h"
 #include "Luau/TypeFwd.h"
 
 #include <functional>
@@ -16,14 +17,23 @@ namespace Luau
 
 struct TypeArena;
 struct TxnLog;
+struct ConstraintSolver;
 class Normalizer;
 
+struct TypeFunctionRuntime
+{
+    // For user-defined type functions, we store all generated types and packs for the duration of the typecheck
+    TypedAllocator<TypeFunctionType> typeArena;
+    TypedAllocator<TypeFunctionTypePackVar> typePackArena;
+};
+
 struct TypeFunctionContext
 {
     NotNull<TypeArena> arena;
     NotNull<BuiltinTypes> builtins;
     NotNull<Scope> scope;
     NotNull<Normalizer> normalizer;
+    NotNull<TypeFunctionRuntime> typeFunctionRuntime;
     NotNull<InternalErrorReporter> ice;
     NotNull<TypeCheckLimits> limits;
 
@@ -35,38 +45,30 @@ struct TypeFunctionContext
     std::optional<AstName> userFuncName;          // Name of the user-defined type function; only available for UDTFs
     std::optional<AstExprFunction*> userFuncBody; // Body of the user-defined type function; only available for UDTFs
 
-    TypeFunctionContext(NotNull<ConstraintSolver> cs, NotNull<Scope> scope, NotNull<const Constraint> constraint)
-        : arena(cs->arena)
-        , builtins(cs->builtinTypes)
-        , scope(scope)
-        , normalizer(cs->normalizer)
-        , ice(NotNull{&cs->iceReporter})
-        , limits(NotNull{&cs->limits})
-        , solver(cs.get())
-        , constraint(constraint.get())
-    {
-    }
+    TypeFunctionContext(NotNull<ConstraintSolver> cs, NotNull<Scope> scope, NotNull<const Constraint> constraint);
 
     TypeFunctionContext(
         NotNull<TypeArena> arena,
         NotNull<BuiltinTypes> builtins,
         NotNull<Scope> scope,
         NotNull<Normalizer> normalizer,
+        NotNull<TypeFunctionRuntime> typeFunctionRuntime,
         NotNull<InternalErrorReporter> ice,
         NotNull<TypeCheckLimits> limits
     )
         : arena(arena)
         , builtins(builtins)
         , scope(scope)
         , normalizer(normalizer)
+        , typeFunctionRuntime(typeFunctionRuntime)
         , ice(ice)
         , limits(limits)
         , solver(nullptr)
         , constraint(nullptr)
     {
     }
 
-    NotNull<Constraint> pushConstraint(ConstraintV&& c);
+    NotNull<Constraint> pushConstraint(ConstraintV&& c) const;
 };
 
 /// Represents a reduction result, which may have successfully reduced the type,
@@ -88,6 +90,8 @@ struct TypeFunctionReductionResult
     /// Any type packs that need to be progressed or mutated before the
     /// reduction may proceed.
     std::vector<TypePackId> blockedPacks;
+    /// A runtime error message from user-defined type functions
+    std::optional<std::string> error;
 };
 
 template<typename T>