Sync to upstream/release/687 (#1954)

## What's Changed?

This week we have an update with an implementation for one of the RFCs
we had approved before, an improvement of the new type solver and a
small Lua 5.1 C API compatibility improvement.

* `@deprecated` attribute can now have a custom suggestion for a
replacement and a reason message as described in [deprecated attribute
parameters
RFC](https://rfcs.luau.org/syntax-attribute-functions-deprecated.html)

For example:
```luau
@[deprecated {reason = "foo suffers from performance issues", use = "bar"}]
local function foo()
    ...
end

-- Function 'foo' is deprecated, use 'bar' instead. foo suffers from performance issues
foo()
```

* `lua_cpcall` C API function has been restored both for compatibility
with Lua 5.1 and as a safe way to enter protected call environment to
work with Luau C API functions that may error

Instead of
```
if (!lua_checkstack(L, 2))
    return -1;
lua_pushcfunction(L, test, nullptr);
lua_pushlightuserdata(L, context);
int status = lua_pcall(L, 1, 0, 0);
```
you can simply do 
```
int status = lua_cpcall(L, test, context);
```

* In Luau CLI, required module return values can now have any type

## New Type Solver
- Additional improvements on type refinements used with external types
should fix some reported false positive errors where types refined to
`never`
- Fixed an issue in recursive refinement types in a form of `t1 where t1
= refine<t1, _>` getting 'stuck'
- Fixed an issue in subtyping of generic functions, it is now possible
to assign `<T>(T, (T) -> T) -> T` to `(number, <X>(X) -> X) -> number`
- Fixed an ICE caused by recursive types (Fixes #1686)
- Added additional iteration and recursion limits to stop the type
solver before system resources are used up

## Internal Contributors

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: 8 people

Analysis/include/Luau/Constraint.h

@@ -52,6 +52,7 @@ struct GeneralizationConstraint
 
     std::vector<TypeId> interiorTypes;
     bool hasDeprecatedAttribute = false;
+    AstAttr::DeprecatedInfo deprecatedInfo;
 
     /// If true, never introduce generics.  Always replace free types by their
     /// bounds or unknown. Presently used only to generalize the whole module.

Analysis/include/Luau/Error.h

@@ -504,6 +504,15 @@ struct MultipleNonviableOverloads
     bool operator==(const MultipleNonviableOverloads& rhs) const;
 };
 
+// Error where a type alias violates the recursive restraint, ie when a type alias T<A> has T with different arguments on the RHS.
+struct RecursiveRestraintViolation
+{
+    bool operator==(const RecursiveRestraintViolation& rhs) const
+    {
+        return true;
+    }
+};
+
 using TypeErrorData = Variant<
     TypeMismatch,
     UnknownSymbol,
@@ -559,7 +568,8 @@ using TypeErrorData = Variant<
     CannotCheckDynamicStringFormatCalls,
     GenericTypeCountMismatch,
     GenericTypePackCountMismatch,
-    MultipleNonviableOverloads>;
+    MultipleNonviableOverloads,
+    RecursiveRestraintViolation>;
 
 struct TypeErrorSummary
 {

Analysis/include/Luau/Frontend.h

@@ -176,7 +176,7 @@ struct Frontend
 
     Frontend(FileResolver* fileResolver, ConfigResolver* configResolver, const FrontendOptions& options = {});
 
-    void setLuauSolverSelectionFromWorkspace(SolverMode mode);
+    void setLuauSolverMode(SolverMode mode);
     SolverMode getLuauSolverMode() const;
     // The default value assuming there is no workspace setup yet
     std::atomic<SolverMode> useNewLuauSolver{FFlag::LuauSolverV2 ? SolverMode::New : SolverMode::Old};
@@ -330,7 +330,7 @@ ModulePtr check(
     NotNull<InternalErrorReporter> iceHandler,
     NotNull<ModuleResolver> moduleResolver,
     NotNull<FileResolver> fileResolver,
-    const ScopePtr& globalScope,
+    const ScopePtr& parentScope,
     const ScopePtr& typeFunctionScope,
     std::function<void(const ModuleName&, const ScopePtr&)> prepareModuleScope,
     FrontendOptions options,

Analysis/include/Luau/Scope.h

@@ -102,6 +102,10 @@ struct Scope
     std::optional<std::vector<TypeId>> interiorFreeTypes;
     std::optional<std::vector<TypePackId>> interiorFreeTypePacks;
 
+    // A set of type alias names that are invalid because they violate the recursion restrictions of type aliases.
+    DenseHashSet<std::string> invalidTypeAliasNames{""};
+    bool isInvalidTypeAliasName(const std::string& name) const;
+
     NotNull<Scope> findNarrowestScopeContaining(Location);
 };
 

Analysis/include/Luau/Substitution.h

@@ -66,6 +66,13 @@ struct TarjanWorklistVertex
     int index;
     int currEdge;
     int lastEdge;
+
+    TarjanWorklistVertex(int index, int currEdge, int lastEdge)
+        : index(index)
+        , currEdge(currEdge)
+        , lastEdge(lastEdge)
+    {
+    }
 };
 
 struct TarjanNode
@@ -79,6 +86,15 @@ struct TarjanNode
     // Tarjan calculates the lowlink for each vertex,
     // which is the lowest ancestor index reachable from the vertex.
     int lowlink;
+
+    TarjanNode(TypeId ty, TypePackId tp, bool onStack, bool dirty, int lowlink)
+        : ty(ty)
+        , tp(tp)
+        , onStack(onStack)
+        , dirty(dirty)
+        , lowlink(lowlink)
+    {
+    }
 };
 
 // Tarjan's algorithm for finding the SCCs in a cyclic structure.

Analysis/include/Luau/Subtyping.h

@@ -88,6 +88,13 @@ struct SubtypingResult
 struct SubtypingEnvironment
 {
     struct GenericBounds
+    {
+        TypeIds lowerBound;
+        TypeIds upperBound;
+    };
+
+    // TODO: Clip with LuauSubtypingGenericsDoesntUseVariance
+    struct GenericBounds_DEPRECATED
     {
         DenseHashSet<TypeId> lowerBound{nullptr};
         DenseHashSet<TypeId> upperBound{nullptr};
@@ -98,22 +105,36 @@ struct SubtypingEnvironment
 
     /// Applies `mappedGenerics` to the given type.
     /// This is used specifically to substitute for generics in type function instances.
-    std::optional<TypeId> applyMappedGenerics(NotNull<BuiltinTypes> builtinTypes, NotNull<TypeArena> arena, TypeId ty);
+    std::optional<TypeId> applyMappedGenerics(
+        NotNull<BuiltinTypes> builtinTypes,
+        NotNull<TypeArena> arena,
+        TypeId ty,
+        NotNull<InternalErrorReporter> iceReporter
+    );
+    // TODO: Clip with LuauSubtypingGenericsDoesntUseVariance
+    std::optional<TypeId> applyMappedGenerics_DEPRECATED(NotNull<BuiltinTypes> builtinTypes, NotNull<TypeArena> arena, TypeId ty);
 
     const TypeId* tryFindSubstitution(TypeId ty) const;
+    // TODO: Clip with LuauSubtypingGenericsDoesntUseVariance
     const SubtypingResult* tryFindSubtypingResult(std::pair<TypeId, TypeId> subAndSuper) const;
 
     bool containsMappedType(TypeId ty) const;
     bool containsMappedPack(TypePackId tp) const;
 
-    GenericBounds& getMappedTypeBounds(TypeId ty);
+    GenericBounds& getMappedTypeBounds(TypeId ty, NotNull<InternalErrorReporter> iceReporter);
+    // TODO: Clip with LuauSubtypingGenericsDoesntUseVariance
+    GenericBounds_DEPRECATED& getMappedTypeBounds_DEPRECATED(TypeId ty);
     TypePackId* getMappedPackBounds(TypePackId tp);
 
     /*
      * When we encounter a generic over the course of a subtyping test, we need
-     * to tentatively map that generic onto a type on the other side.
+     * to tentatively map that generic onto a type on the other side. We map to a
+     * vector of bounds, since generics may be shadowed by nested types. The back
+     * of each vector represents the current scope.
      */
-    DenseHashMap<TypeId, GenericBounds> mappedGenerics{nullptr};
+    DenseHashMap<TypeId, std::vector<GenericBounds>> mappedGenerics{nullptr};
+    // TODO: Clip with LuauSubtypingGenericsDoesntUseVariance
+    DenseHashMap<TypeId, GenericBounds_DEPRECATED> mappedGenerics_DEPRECATED{nullptr};
     DenseHashMap<TypePackId, TypePackId> mappedGenericPacks{nullptr};
 
     /*
@@ -124,7 +145,14 @@ struct SubtypingEnvironment
      */
     DenseHashMap<TypeId, TypeId> substitutions{nullptr};
 
+    // TODO: Clip with LuauSubtypingGenericsDoesntUseVariance
     DenseHashMap<std::pair<TypeId, TypeId>, SubtypingResult, TypePairHash> ephemeralCache{{}};
+
+    // We use this cache to track pairs of subtypes that we tried to subtype, and found them to be in the seen set at the time.
+    // In those situations, we return True, but mark the result as not cacheable, because we don't want to cache broader results which
+    // led to the seen pair. However, those results were previously being cache in the ephemeralCache, and we still want to cache them somewhere
+    // for performance reasons.
+    DenseHashMap<std::pair<TypeId, TypeId>, SubtypingResult, TypePairHash> seenSetCache{{}};
 };
 
 struct Subtyping
@@ -144,6 +172,7 @@ struct Subtyping
         Contravariant
     };
 
+    // TODO: Clip this along with LuauSubtypingGenericsDoesntUseVariance?
     Variance variance = Variance::Covariant;
 
     using SeenSet = Set<std::pair<TypeId, TypeId>, TypePairHash>;
@@ -178,7 +207,12 @@ struct Subtyping
     // TODO recursion limits
 
     SubtypingResult isSubtype(TypeId subTy, TypeId superTy, NotNull<Scope> scope);
-    SubtypingResult isSubtype(TypePackId subTy, TypePackId superTy, NotNull<Scope> scope);
+    SubtypingResult isSubtype(
+        TypePackId subTp,
+        TypePackId superTp,
+        NotNull<Scope> scope,
+        std::optional<std::vector<TypeId>> bindableGenerics = std::nullopt
+    );
 
 private:
     DenseHashMap<std::pair<TypeId, TypeId>, SubtypingResult, TypePairHash> resultCache{{}};
@@ -323,6 +357,16 @@ struct Subtyping
                                          TypeId superTy,
                                          NotNull<Scope> scope,
                                          SubtypingResult& original);
+
+    SubtypingResult checkGenericBounds(const SubtypingEnvironment::GenericBounds& bounds, SubtypingEnvironment& env, NotNull<Scope> scope);
+
+    static void maybeUpdateBounds(
+        TypeId here,
+        TypeId there,
+        TypeIds& boundsToUpdate,
+        const TypeIds& firstBoundsToCheck,
+        const TypeIds& secondBoundsToCheck
+    );
 };
 
 } // namespace Luau

Analysis/include/Luau/SubtypingVariance.h

@@ -7,11 +7,9 @@ namespace Luau
 
 enum class SubtypingVariance
 {
-    // Used for an empty key. Should never appear in actual code.
+    // Useful for an empty hash table key. Should never arise from actual code.
     Invalid,
     Covariant,
-    // This is used to identify cases where we have a covariant + a
-    // contravariant reason and we need to merge them.
     Contravariant,
     Invariant,
 };

Analysis/include/Luau/Transpiler.h

@@ -3,6 +3,7 @@
 
 #include "Luau/Location.h"
 #include "Luau/ParseOptions.h"
+#include "Luau/ParseResult.h"
 
 #include <string>
 
@@ -24,6 +25,7 @@ void dump(AstNode* node);
 // Never fails on a well-formed AST
 std::string transpile(AstStatBlock& ast);
 std::string transpileWithTypes(AstStatBlock& block);
+std::string transpileWithTypes(AstStatBlock &block, const CstNodeMap& cstNodeMap);
 
 // Only fails when parsing fails
 TranspileResult transpile(std::string_view source, ParseOptions options = ParseOptions{}, bool withTypes = false);

Analysis/include/Luau/Type.h

@@ -391,6 +391,7 @@ struct FunctionType
     bool hasNoFreeOrGenericTypes = false;
     bool isCheckedFunction = false;
     bool isDeprecatedFunction = false;
+    std::shared_ptr<AstAttr::DeprecatedInfo> deprecatedInfo;
 };
 
 enum class TableState

Analysis/include/Luau/TypeIds.h

@@ -52,6 +52,8 @@ class TypeIds
     bool empty() const;
     size_t count(TypeId ty) const;
 
+    void reserve(size_t n);
+
     template<class Iterator>
     void insert(Iterator begin, Iterator end)
     {