Sync to upstream/release/672 (#1800)

# What's Changed?

Hi there, folks! It's been another busy week in the type mines, trying
to bring you all the very best type inference system we can. We've got a
bunch of updates to large pain points across the new type solver, and
our next big update (currently under a debug flag) improving type
generalization is finally nearing completion (and should hopefully
eliminate quite a lot of "type solver failed to complete" errors). We've
also continued polishing both the CST Parser and the `Luau.Require`
library we introduced a few releases ago based on user feedback and bug
reports, and we're really happy with how they're turning out.

# Parser
- Fixes a bug in the CST tooling where the spacing on return type
annotations for functions was not being printed correctly.
- Resolves some issues with the JSON encoding of `AstGenericType` and
`AstGenericTypePack`

# Runtime
- Implements support for yielding requires in `Luau.Require` library.
- Improves the error messages for require-by-string to include the chunk
name that was problematic where possible and the overall require path
that failed to be required.
- Fixes a bug that prevented the use of `require` within C functions and
`pcall`.
- Adds an API to support selectively removing chunks from the require
cache in `Luau.Require`
- Adds an API to support clearing the entire require cache in
`Luau.Require`

# New Type Solver

- Fixes a crash in the new non-strict mode when visiting function return
types in incomplete ASTs (e.g. during editing).
- Improves type simplification to support intersections of tables with
extern types, resolving _one_ of the causes of frequent refinements
unexpectedly leading to `never`.
- Improves type inference to better understand diverging branches in
functions, reducing false negatives where the type system fails to learn
that a binding must now always be initialized.
- Fixes a typo in the type definitions for user-defined function types
where the `intersection` tag was misspelled.
- Improves the overall accuracy of free type tracking during constraint
solving, leading to better inference results overall.
- Implements `types.optional` as a new library function for user-defined
type functions to make it easier to union a type with `nil`.
- Resolves a number of bugs caused by local type inference expanding the
domain of upvalues

# Internal Contributors

Co-authored-by: Andy Friesen <afriesen@roblox.com>
Co-authored-by: Ariel Weiss <aaronweiss@roblox.com>
Co-authored-by: Hunter Goldstein <hgoldstein@roblox.com>
Co-authored-by: Talha Pathan <tpathan@roblox.com>
Co-authored-by: Varun Saini <vsaini@roblox.com>
Co-authored-by: Vighnesh Vijay <vvijay@roblox.com>

---------

Co-authored-by: Hunter Goldstein <hgoldstein@roblox.com>
Co-authored-by: Varun Saini <61795485+vrn-sn@users.noreply.github.com>
Co-authored-by: Alexander Youngblood <ayoungblood@roblox.com>
Co-authored-by: Menarul Alam <malam@roblox.com>
Co-authored-by: Aviral Goel <agoel@roblox.com>
Co-authored-by: Vighnesh <vvijay@roblox.com>
Co-authored-by: Vyacheslav Egorov <vegorov@roblox.com>
Co-authored-by: Andy Friesen <afriesen@roblox.com>

Analysis/include/Luau/AnyTypeSummary.h

@@ -1,148 +0,0 @@
-// This file is part of the Luau programming language and is licensed under MIT License; see LICENSE.txt for details
-#pragma once
-
-#include "Luau/AstQuery.h"
-#include "Luau/Config.h"
-#include "Luau/ModuleResolver.h"
-#include "Luau/Scope.h"
-#include "Luau/Variant.h"
-#include "Luau/Normalize.h"
-#include "Luau/TypePack.h"
-#include "Luau/TypeArena.h"
-
-#include <mutex>
-#include <string>
-#include <vector>
-#include <optional>
-
-namespace Luau
-{
-
-class AstStat;
-class ParseError;
-struct TypeError;
-struct LintWarning;
-struct GlobalTypes;
-struct ModuleResolver;
-struct ParseResult;
-struct DcrLogger;
-
-struct TelemetryTypePair
-{
-    std::string annotatedType;
-    std::string inferredType;
-};
-
-struct AnyTypeSummary
-{
-    TypeArena arena;
-
-    AstStatBlock* rootSrc = nullptr;
-    DenseHashSet<TypeId> seenTypeFamilyInstances{nullptr};
-
-    int recursionCount = 0;
-
-    std::string root;
-    int strictCount = 0;
-
-    DenseHashMap<const void*, bool> seen{nullptr};
-
-    AnyTypeSummary();
-
-    void traverse(const Module* module, AstStat* src, NotNull<BuiltinTypes> builtinTypes);
-
-    std::pair<bool, TypeId> checkForAnyCast(const Scope* scope, AstExprTypeAssertion* expr);
-
-    bool containsAny(TypePackId typ);
-    bool containsAny(TypeId typ);
-
-    bool isAnyCast(const Scope* scope, AstExpr* expr, const Module* module, NotNull<BuiltinTypes> builtinTypes);
-    bool isAnyCall(const Scope* scope, AstExpr* expr, const Module* module, NotNull<BuiltinTypes> builtinTypes);
-
-    bool hasVariadicAnys(const Scope* scope, AstExprFunction* expr, const Module* module, NotNull<BuiltinTypes> builtinTypes);
-    bool hasArgAnys(const Scope* scope, AstExprFunction* expr, const Module* module, NotNull<BuiltinTypes> builtinTypes);
-    bool hasAnyReturns(const Scope* scope, AstExprFunction* expr, const Module* module, NotNull<BuiltinTypes> builtinTypes);
-
-    TypeId checkForFamilyInhabitance(const TypeId instance, Location location);
-    TypeId lookupType(const AstExpr* expr, const Module* module, NotNull<BuiltinTypes> builtinTypes);
-    TypePackId reconstructTypePack(const AstArray<AstExpr*> exprs, const Module* module, NotNull<BuiltinTypes> builtinTypes);
-
-    DenseHashSet<TypeId> seenTypeFunctionInstances{nullptr};
-    TypeId lookupAnnotation(AstType* annotation, const Module* module, NotNull<BuiltinTypes> builtintypes);
-    std::optional<TypePackId> lookupPackAnnotation(AstTypePack* annotation, const Module* module);
-    TypeId checkForTypeFunctionInhabitance(const TypeId instance, const Location location);
-
-    enum Pattern : uint64_t
-    {
-        Casts,
-        FuncArg,
-        FuncRet,
-        FuncApp,
-        VarAnnot,
-        VarAny,
-        TableProp,
-        Alias,
-        Assign,
-        TypePk
-    };
-
-    struct TypeInfo
-    {
-        Pattern code;
-        std::string node;
-        TelemetryTypePair type;
-
-        explicit TypeInfo(Pattern code, std::string node, TelemetryTypePair type);
-    };
-
-    struct FindReturnAncestry final : public AstVisitor
-    {
-        AstNode* currNode{nullptr};
-        AstNode* stat{nullptr};
-        Position rootEnd;
-        bool found = false;
-
-        explicit FindReturnAncestry(AstNode* stat, Position rootEnd);
-
-        bool visit(AstType* node) override;
-        bool visit(AstNode* node) override;
-        bool visit(AstStatFunction* node) override;
-        bool visit(AstStatLocalFunction* node) override;
-    };
-
-    std::vector<TypeInfo> typeInfo;
-
-    /**
-     * Fabricates a scope that is a child of another scope.
-     * @param node the lexical node that the scope belongs to.
-     * @param parent the parent scope of the new scope. Must not be null.
-     */
-    const Scope* childScope(const AstNode* node, const Scope* parent);
-
-    std::optional<AstExpr*> matchRequire(const AstExprCall& call);
-    AstNode* getNode(AstStatBlock* root, AstNode* node);
-    const Scope* findInnerMostScope(const Location location, const Module* module);
-    const AstNode* findAstAncestryAtLocation(const AstStatBlock* root, AstNode* node);
-
-    void visit(const Scope* scope, AstStat* stat, const Module* module, NotNull<BuiltinTypes> builtinTypes);
-    void visit(const Scope* scope, AstStatBlock* block, const Module* module, NotNull<BuiltinTypes> builtinTypes);
-    void visit(const Scope* scope, AstStatIf* ifStatement, const Module* module, NotNull<BuiltinTypes> builtinTypes);
-    void visit(const Scope* scope, AstStatWhile* while_, const Module* module, NotNull<BuiltinTypes> builtinTypes);
-    void visit(const Scope* scope, AstStatRepeat* repeat, const Module* module, NotNull<BuiltinTypes> builtinTypes);
-    void visit(const Scope* scope, AstStatReturn* ret, const Module* module, NotNull<BuiltinTypes> builtinTypes);
-    void visit(const Scope* scope, AstStatLocal* local, const Module* module, NotNull<BuiltinTypes> builtinTypes);
-    void visit(const Scope* scope, AstStatFor* for_, const Module* module, NotNull<BuiltinTypes> builtinTypes);
-    void visit(const Scope* scope, AstStatForIn* forIn, const Module* module, NotNull<BuiltinTypes> builtinTypes);
-    void visit(const Scope* scope, AstStatAssign* assign, const Module* module, NotNull<BuiltinTypes> builtinTypes);
-    void visit(const Scope* scope, AstStatCompoundAssign* assign, const Module* module, NotNull<BuiltinTypes> builtinTypes);
-    void visit(const Scope* scope, AstStatFunction* function, const Module* module, NotNull<BuiltinTypes> builtinTypes);
-    void visit(const Scope* scope, AstStatLocalFunction* function, const Module* module, NotNull<BuiltinTypes> builtinTypes);
-    void visit(const Scope* scope, AstStatTypeAlias* alias, const Module* module, NotNull<BuiltinTypes> builtinTypes);
-    void visit(const Scope* scope, AstStatExpr* expr, const Module* module, NotNull<BuiltinTypes> builtinTypes);
-    void visit(const Scope* scope, AstStatDeclareGlobal* declareGlobal, const Module* module, NotNull<BuiltinTypes> builtinTypes);
-    void visit(const Scope* scope, AstStatDeclareClass* declareClass, const Module* module, NotNull<BuiltinTypes> builtinTypes);
-    void visit(const Scope* scope, AstStatDeclareFunction* declareFunction, const Module* module, NotNull<BuiltinTypes> builtinTypes);
-    void visit(const Scope* scope, AstStatError* error, const Module* module, NotNull<BuiltinTypes> builtinTypes);
-};
-
-} // namespace Luau

Analysis/include/Luau/AutocompleteTypes.h

@@ -57,7 +57,7 @@ struct AutocompleteEntry
     // Set if this suggestion matches the type expected in the context
     TypeCorrectKind typeCorrect = TypeCorrectKind::None;
 
-    std::optional<const ClassType*> containingClass = std::nullopt;
+    std::optional<const ExternType*> containingExternType = std::nullopt;
     std::optional<const Property*> prop = std::nullopt;
     std::optional<std::string> documentationSymbol = std::nullopt;
     Tags tags;
@@ -85,7 +85,7 @@ struct AutocompleteResult
 };
 
 using StringCompletionCallback =
-    std::function<std::optional<AutocompleteEntryMap>(std::string tag, std::optional<const ClassType*> ctx, std::optional<std::string> contents)>;
+    std::function<std::optional<AutocompleteEntryMap>(std::string tag, std::optional<const ExternType*> ctx, std::optional<std::string> contents)>;
 
 constexpr char kGeneratedAnonymousFunctionEntryName[] = "function (anonymous autofilled)";
 

Analysis/include/Luau/BuiltinDefinitions.h

@@ -70,6 +70,7 @@ Property makeProperty(TypeId ty, std::optional<std::string> documentationSymbol
 void assignPropDocumentationSymbols(TableType::Props& props, const std::string& baseName);
 
 std::string getBuiltinDefinitionSource();
+std::string getTypeFunctionDefinitionSource();
 
 void addGlobalBinding(GlobalTypes& globals, const std::string& name, TypeId ty, const std::string& packageName);
 void addGlobalBinding(GlobalTypes& globals, const std::string& name, Binding binding);

Analysis/include/Luau/Clone.h

@@ -40,4 +40,9 @@ TypeId clone(TypeId tp, TypeArena& dest, CloneState& cloneState);
 TypeFun clone(const TypeFun& typeFun, TypeArena& dest, CloneState& cloneState);
 Binding clone(const Binding& binding, TypeArena& dest, CloneState& cloneState);
 
+TypePackId cloneIncremental(TypePackId tp, TypeArena& dest, CloneState& cloneState, Scope* freshScopeForFreeTypes);
+TypeId cloneIncremental(TypeId typeId, TypeArena& dest, CloneState& cloneState, Scope* freshScopeForFreeTypes);
+TypeFun cloneIncremental(const TypeFun& typeFun, TypeArena& dest, CloneState& cloneState, Scope* freshScopeForFreeTypes);
+Binding cloneIncremental(const Binding& binding, TypeArena& dest, CloneState& cloneState, Scope* freshScopeForFreeTypes);
+
 } // namespace Luau

Analysis/include/Luau/Constraint.h

@@ -50,6 +50,7 @@ struct GeneralizationConstraint
     TypeId sourceType;
 
     std::vector<TypeId> interiorTypes;
+    bool hasDeprecatedAttribute = false;
 };
 
 // variables ~ iterate iterator

Analysis/include/Luau/ConstraintGenerator.h

@@ -3,6 +3,7 @@
 
 #include "Luau/Ast.h"
 #include "Luau/Constraint.h"
+#include "Luau/ConstraintSet.h"
 #include "Luau/ControlFlow.h"
 #include "Luau/DataFlowGraph.h"
 #include "Luau/EqSatSimplification.h"
@@ -11,15 +12,14 @@
 #include "Luau/ModuleResolver.h"
 #include "Luau/Normalize.h"
 #include "Luau/NotNull.h"
+#include "Luau/Polarity.h"
 #include "Luau/Refinement.h"
 #include "Luau/Symbol.h"
 #include "Luau/TypeFwd.h"
 #include "Luau/TypeUtils.h"
-#include "Luau/Variant.h"
 
 #include <memory>
 #include <vector>
-#include <unordered_map>
 
 namespace Luau
 {
@@ -92,9 +92,8 @@ struct ConstraintGenerator
     // Constraints that go straight to the solver.
     std::vector<ConstraintPtr> constraints;
 
-    // Constraints that do not go to the solver right away.  Other constraints
-    // will enqueue them during solving.
-    std::vector<ConstraintPtr> unqueuedConstraints;
+    // The set of all free types introduced during constraint generation.
+    DenseHashSet<TypeId> freeTypes{nullptr};
 
     // Map a function's signature scope back to its signature type.
     DenseHashMap<Scope*, TypeId> scopeToFunction{nullptr};
@@ -117,18 +116,23 @@ struct ConstraintGenerator
 
     // Needed to register all available type functions for execution at later stages.
     NotNull<TypeFunctionRuntime> typeFunctionRuntime;
+    DenseHashMap<const AstStatTypeFunction*, ScopePtr> astTypeFunctionEnvironmentScopes{nullptr};
+
     // Needed to resolve modules to make 'require' import types properly.
     NotNull<ModuleResolver> moduleResolver;
     // Occasionally constraint generation needs to produce an ICE.
     const NotNull<InternalErrorReporter> ice;
 
     ScopePtr globalScope;
+    ScopePtr typeFunctionScope;
 
     std::function<void(const ModuleName&, const ScopePtr&)> prepareModuleScope;
     std::vector<RequireCycle> requireCycles;
 
     DenseHashMap<TypeId, TypeIds> localTypes{nullptr};
 
+    DenseHashMap<AstExpr*, Inference> inferredExprCache{nullptr};
+
     DcrLogger* logger;
 
     ConstraintGenerator(
@@ -140,12 +144,16 @@ struct ConstraintGenerator
         NotNull<BuiltinTypes> builtinTypes,
         NotNull<InternalErrorReporter> ice,
         const ScopePtr& globalScope,
+        const ScopePtr& typeFunctionScope,
         std::function<void(const ModuleName&, const ScopePtr&)> prepareModuleScope,
         DcrLogger* logger,
         NotNull<DataFlowGraph> dfg,
         std::vector<RequireCycle> requireCycles
     );
 
+    ConstraintSet run(AstStatBlock* block);
+    ConstraintSet runOnFragment(const ScopePtr& resumeScope, AstStatBlock* block);
+
     /**
      * The entry point to the ConstraintGenerator. This will construct a set
      * of scopes, constraints, and free types that can be solved later.
@@ -156,19 +164,26 @@ struct ConstraintGenerator
     void visitFragmentRoot(const ScopePtr& resumeScope, AstStatBlock* block);
 
 private:
-    std::vector<std::vector<TypeId>> interiorTypes;
+    struct InteriorFreeTypes
+    {
+        std::vector<TypeId> types;
+        std::vector<TypePackId> typePacks;
+    };
+
+    std::vector<std::vector<TypeId>> DEPRECATED_interiorTypes;
+    std::vector<InteriorFreeTypes> interiorFreeTypes;
 
     /**
      * Fabricates a new free type belonging to a given scope.
      * @param scope the scope the free type belongs to.
      */
-    TypeId freshType(const ScopePtr& scope);
+    TypeId freshType(const ScopePtr& scope, Polarity polarity = Polarity::Unknown);
 
     /**
      * Fabricates a new free type pack belonging to a given scope.
      * @param scope the scope the free type pack belongs to.
      */
-    TypePackId freshTypePack(const ScopePtr& scope);
+    TypePackId freshTypePack(const ScopePtr& scope, Polarity polarity = Polarity::Unknown);
 
     /**
      * Allocate a new TypePack with the given head and tail.
@@ -257,7 +272,7 @@ private:
     ControlFlow visit(const ScopePtr& scope, AstStatTypeAlias* alias);
     ControlFlow visit(const ScopePtr& scope, AstStatTypeFunction* function);
     ControlFlow visit(const ScopePtr& scope, AstStatDeclareGlobal* declareGlobal);
-    ControlFlow visit(const ScopePtr& scope, AstStatDeclareClass* declareClass);
+    ControlFlow visit(const ScopePtr& scope, AstStatDeclareExternType* declareExternType);
     ControlFlow visit(const ScopePtr& scope, AstStatDeclareFunction* declareFunction);
     ControlFlow visit(const ScopePtr& scope, AstStatError* error);
 
@@ -289,7 +304,7 @@ private:
     );
 
     Inference check(const ScopePtr& scope, AstExprConstantString* string, std::optional<TypeId> expectedType, bool forceSingleton);
-    Inference check(const ScopePtr& scope, AstExprConstantBool* bool_, std::optional<TypeId> expectedType, bool forceSingleton);
+    Inference check(const ScopePtr& scope, AstExprConstantBool* boolExpr, std::optional<TypeId> expectedType, bool forceSingleton);
     Inference check(const ScopePtr& scope, AstExprLocal* local);
     Inference check(const ScopePtr& scope, AstExprGlobal* global);
     Inference checkIndexName(const ScopePtr& scope, const RefinementKey* key, AstExpr* indexee, const std::string& index, Location indexLocation);
@@ -365,6 +380,11 @@ private:
      **/
     TypeId resolveType(const ScopePtr& scope, AstType* ty, bool inTypeArguments, bool replaceErrorWithFresh = false);
 
+    // resolveType() is recursive, but we only want to invoke
+    // inferGenericPolarities() once at the very end.  We thus isolate the
+    // recursive part of the algorithm to this internal helper.
+    TypeId resolveType_(const ScopePtr& scope, AstType* ty, bool inTypeArguments, bool replaceErrorWithFresh = false);
+
     /**
      * Resolves a type pack from its AST annotation.
      * @param scope the scope that the type annotation appears within.
@@ -374,6 +394,9 @@ private:
      **/
     TypePackId resolveTypePack(const ScopePtr& scope, AstTypePack* tp, bool inTypeArguments, bool replaceErrorWithFresh = false);
 
+    // Inner hepler for resolveTypePack
+    TypePackId resolveTypePack_(const ScopePtr& scope, AstTypePack* tp, bool inTypeArguments, bool replaceErrorWithFresh = false);
+
     /**
      * Resolves a type pack from its AST annotation.
      * @param scope the scope that the type annotation appears within.
@@ -412,7 +435,7 @@ private:
      **/
     std::vector<std::pair<Name, GenericTypePackDefinition>> createGenericPacks(
         const ScopePtr& scope,
-        AstArray<AstGenericTypePack*> packs,
+        AstArray<AstGenericTypePack*> generics,
         bool useCache = false,
         bool addTypes = true
     );
@@ -461,9 +484,4 @@ private:
     TypeId simplifyUnion(const ScopePtr& scope, Location location, TypeId left, TypeId right);
 };
 
-/** Borrow a vector of pointers from a vector of owning pointers to constraints.
- */
-std::vector<NotNull<Constraint>> borrowConstraints(const std::vector<ConstraintPtr>& constraints);
-
-
 } // namespace Luau

Analysis/include/Luau/ConstraintSet.h

@@ -0,0 +1,32 @@
+// This file is part of the Luau programming language and is licensed under MIT License; see LICENSE.txt for details
+
+#pragma once
+
+#include "Luau/Constraint.h"
+#include "Luau/DenseHash.h"
+#include "Luau/Error.h"
+
+#include <vector>
+
+namespace Luau
+{
+
+struct ConstraintSet
+{
+    NotNull<Scope> rootScope;
+
+    std::vector<ConstraintPtr> constraints;
+
+    // The set of all free types created during constraint generation
+    DenseHashSet<TypeId> freeTypes{nullptr};
+
+    // Map a function's signature scope back to its signature type.   Once we've
+    // dispatched all of the constraints pertaining to a particular free type,
+    // we use this mapping to generalize that free type.
+    DenseHashMap<Scope*, TypeId> scopeToFunction{nullptr};
+
+    // It is pretty uncommon for constraint generation to itself produce errors, but it can happen.
+    std::vector<TypeError> errors;
+};
+
+}

Analysis/include/Luau/ConstraintSolver.h

@@ -3,6 +3,7 @@
 #pragma once
 
 #include "Luau/Constraint.h"
+#include "Luau/ConstraintSet.h"
 #include "Luau/DataFlowGraph.h"
 #include "Luau/DenseHash.h"
 #include "Luau/EqSatSimplification.h"
@@ -87,6 +88,7 @@ struct ConstraintSolver
     NotNull<Simplifier> simplifier;
     NotNull<TypeFunctionRuntime> typeFunctionRuntime;
     // The entire set of constraints that the solver is trying to resolve.
+    ConstraintSet constraintSet;
     std::vector<NotNull<Constraint>> constraints;
     NotNull<DenseHashMap<Scope*, TypeId>> scopeToFunction;
     NotNull<Scope> rootScope;
@@ -140,6 +142,19 @@ struct ConstraintSolver
 
     DenseHashMap<TypeId, const Constraint*> typeFunctionsToFinalize{nullptr};
 
+    explicit ConstraintSolver(
+        NotNull<Normalizer> normalizer,
+        NotNull<Simplifier> simplifier,
+        NotNull<TypeFunctionRuntime> typeFunctionRuntime,
+        ModuleName moduleName,
+        NotNull<ModuleResolver> moduleResolver,
+        std::vector<RequireCycle> requireCycles,
+        DcrLogger* logger,
+        NotNull<const DataFlowGraph> dfg,
+        TypeCheckLimits limits,
+        ConstraintSet constraintSet
+    );
+
     explicit ConstraintSolver(
         NotNull<Normalizer> normalizer,
         NotNull<Simplifier> simplifier,
@@ -174,6 +189,9 @@ struct ConstraintSolver
     bool isDone() const;
 
 private:
+    /// A helper that does most of the setup work that is shared between the two constructors.
+    void initFreeTypeTracking();
+
     void generalizeOneType(TypeId ty);
 
     /**
@@ -365,7 +383,7 @@ public:
      * @returns a non-free type that generalizes the argument, or `std::nullopt` if one
      * does not exist
      */
-    std::optional<TypeId> generalizeFreeType(NotNull<Scope> scope, TypeId type, bool avoidSealingTables = false);
+    std::optional<TypeId> generalizeFreeType(NotNull<Scope> scope, TypeId type);
 
     /**
      * Checks the existing set of constraints to see if there exist any that contain
@@ -432,6 +450,10 @@ public:
     void fillInDiscriminantTypes(NotNull<const Constraint> constraint, const std::vector<std::optional<TypeId>>& discriminantTypes);
 };
 
+/** Borrow a vector of pointers from a vector of owning pointers to constraints.
+ */
+std::vector<NotNull<Constraint>> borrowConstraints(const std::vector<ConstraintPtr>& constraints);
+
 void dump(NotNull<Scope> rootScope, struct ToStringOptions& opts);
 
 } // namespace Luau

Analysis/include/Luau/DataFlowGraph.h

@@ -38,8 +38,6 @@ struct DataFlowGraph
     DefId getDef(const AstExpr* expr) const;
     // Look up the definition optionally, knowing it may not be present.
     std::optional<DefId> getDefOptional(const AstExpr* expr) const;
-    // Look up for the rvalue def for a compound assignment.
-    std::optional<DefId> getRValueDefForCompoundAssign(const AstExpr* expr) const;
 
     DefId getDef(const AstLocal* local) const;
 
@@ -66,10 +64,6 @@ private:
     // All keys in this maps are really only statements that ambiently declares a symbol.
     DenseHashMap<const AstStat*, const Def*> declaredDefs{nullptr};
 
-    // Compound assignments are in a weird situation where the local being assigned to is also being used at its
-    // previous type implicitly in an rvalue position. This map provides the previous binding.
-    DenseHashMap<const AstExpr*, const Def*> compoundAssignDefs{nullptr};
-
     DenseHashMap<const AstExpr*, const RefinementKey*> astRefinementKeys{nullptr};
     friend struct DataFlowGraphBuilder;
 };
@@ -135,8 +129,8 @@ private:
 
     /// A stack of scopes used by the visitor to see where we are.
     ScopeStack scopeStack;
-
-    DfgScope* currentScope();
+    NotNull<DfgScope> currentScope();
+    DfgScope* currentScope_DEPRECATED();
 
     struct FunctionCapture
     {
@@ -154,8 +148,8 @@ private:
     void joinBindings(DfgScope* p, const DfgScope& a, const DfgScope& b);
     void joinProps(DfgScope* p, const DfgScope& a, const DfgScope& b);
 
-    DefId lookup(Symbol symbol);
-    DefId lookup(DefId def, const std::string& key);
+    DefId lookup(Symbol symbol, Location location);
+    DefId lookup(DefId def, const std::string& key, Location location);
 
     ControlFlow visit(AstStatBlock* b);
     ControlFlow visitBlockWithoutChildScope(AstStatBlock* b);
@@ -179,7 +173,7 @@ private:
     ControlFlow visit(AstStatTypeFunction* f);
     ControlFlow visit(AstStatDeclareGlobal* d);
     ControlFlow visit(AstStatDeclareFunction* d);
-    ControlFlow visit(AstStatDeclareClass* d);
+    ControlFlow visit(AstStatDeclareExternType* d);
     ControlFlow visit(AstStatError* error);
 
     DataFlowResult visitExpr(AstExpr* e);

Analysis/include/Luau/Def.h

@@ -4,7 +4,8 @@
 #include "Luau/NotNull.h"
 #include "Luau/TypedAllocator.h"
 #include "Luau/Variant.h"
-
+#include "Luau/Location.h"
+#include "Luau/Symbol.h"
 #include <string>
 #include <optional>
 
@@ -13,6 +14,7 @@ namespace Luau
 
 struct Def;
 using DefId = NotNull<const Def>;
+struct AstLocal;
 
 /**
  * A cell is a "single-object" value.
@@ -64,6 +66,8 @@ struct Def
     using V = Variant<struct Cell, struct Phi>;
 
     V v;
+    Symbol name;
+    Location location;
 };
 
 template<typename T>
@@ -79,7 +83,7 @@ struct DefArena
 {
     TypedAllocator<Def> allocator;
 
-    DefId freshCell(bool subscripted = false);
+    DefId freshCell(Symbol sym, Location location, bool subscripted = false);
     DefId phi(DefId a, DefId b);
     DefId phi(const std::vector<DefId>& defs);
 };

Analysis/include/Luau/Error.h

@@ -332,11 +332,11 @@ struct TypePackMismatch
     bool operator==(const TypePackMismatch& rhs) const;
 };
 
-struct DynamicPropertyLookupOnClassesUnsafe
+struct DynamicPropertyLookupOnExternTypesUnsafe
 {
     TypeId ty;
 
-    bool operator==(const DynamicPropertyLookupOnClassesUnsafe& rhs) const;
+    bool operator==(const DynamicPropertyLookupOnExternTypesUnsafe& rhs) const;
 };
 
 struct UninhabitedTypeFunction
@@ -455,6 +455,13 @@ struct UserDefinedTypeFunctionError
     bool operator==(const UserDefinedTypeFunctionError& rhs) const;
 };
 
+struct ReservedIdentifier
+{
+    std::string name;
+
+    bool operator==(const ReservedIdentifier& rhs) const;
+};
+
 using TypeErrorData = Variant<
     TypeMismatch,
     UnknownSymbol,
@@ -492,7 +499,7 @@ using TypeErrorData = Variant<
     TypesAreUnrelated,
     NormalizationTooComplex,
     TypePackMismatch,
-    DynamicPropertyLookupOnClassesUnsafe,
+    DynamicPropertyLookupOnExternTypesUnsafe,
     UninhabitedTypeFunction,
     UninhabitedTypePackFunction,
     WhereClauseNeeded,
@@ -504,7 +511,8 @@ using TypeErrorData = Variant<
     UnexpectedTypeInSubtyping,
     UnexpectedTypePackInSubtyping,
     ExplicitFunctionAnnotationRecommended,
-    UserDefinedTypeFunctionError>;
+    UserDefinedTypeFunctionError,
+    ReservedIdentifier>;
 
 struct TypeErrorSummary
 {

Analysis/include/Luau/FileResolver.h

@@ -1,8 +1,9 @@
 // This file is part of the Luau programming language and is licensed under MIT License; see LICENSE.txt for details
 #pragma once
 
-#include <string>
+#include <memory>
 #include <optional>
+#include <string>
 #include <vector>
 
 namespace Luau
@@ -19,7 +20,7 @@ struct SourceCode
         None,
         Module,
         Script,
-        Local
+        Local_DEPRECATED
     };
 
     std::string source;
@@ -32,15 +33,71 @@ struct ModuleInfo
     bool optional = false;
 };
 
+struct RequireAlias
+{
+    std::string alias; // Unprefixed alias name (no leading `@`).
+    std::vector<std::string> tags = {};
+};
+
+struct RequireNode
+{
+    virtual ~RequireNode() {}
+
+    // Get the path component representing this node.
+    virtual std::string getPathComponent() const = 0;
+
+    // Get the displayed user-facing label for this node, defaults to getPathComponent()
+    virtual std::string getLabel() const
+    {
+        return getPathComponent();
+    }
+
+    // Get tags to attach to this node's RequireSuggestion (defaults to none).
+    virtual std::vector<std::string> getTags() const
+    {
+        return {};
+    }
+
+    // TODO: resolvePathToNode() can ultimately be replaced with a call into
+    // require-by-string's path resolution algorithm. This will first require
+    // generalizing that algorithm to work with a virtual file system.
+    virtual std::unique_ptr<RequireNode> resolvePathToNode(const std::string& path) const = 0;
+
+    // Get children of this node, if any (if this node represents a directory).
+    virtual std::vector<std::unique_ptr<RequireNode>> getChildren() const = 0;
+
+    // A list of the aliases available to this node.
+    virtual std::vector<RequireAlias> getAvailableAliases() const = 0;
+};
+
 struct RequireSuggestion
 {
     std::string label;
     std::string fullPath;
+    std::vector<std::string> tags;
 };
 using RequireSuggestions = std::vector<RequireSuggestion>;
 
+struct RequireSuggester
+{
+    virtual ~RequireSuggester() {}
+    std::optional<RequireSuggestions> getRequireSuggestions(const ModuleName& requirer, const std::optional<std::string>& pathString) const;
+
+protected:
+    virtual std::unique_ptr<RequireNode> getNode(const ModuleName& name) const = 0;
+
+private:
+    std::optional<RequireSuggestions> getRequireSuggestionsImpl(const ModuleName& requirer, const std::optional<std::string>& path) const;
+};
+
 struct FileResolver
 {
+    FileResolver() = default;
+    FileResolver(std::shared_ptr<RequireSuggester> requireSuggester)
+        : requireSuggester(std::move(requireSuggester))
+    {
+    }
+
     virtual ~FileResolver() {}
 
     virtual std::optional<SourceCode> readSource(const ModuleName& name) = 0;
@@ -60,10 +117,9 @@ struct FileResolver
         return std::nullopt;
     }
 
-    virtual std::optional<RequireSuggestions> getRequireSuggestions(const ModuleName& requirer, const std::optional<std::string>& pathString) const
-    {
-        return std::nullopt;
-    }
+    std::optional<RequireSuggestions> getRequireSuggestions(const ModuleName& requirer, const std::optional<std::string>& pathString) const;
+
+    std::shared_ptr<RequireSuggester> requireSuggester;
 };
 
 struct NullFileResolver : FileResolver

Analysis/include/Luau/FragmentAutocomplete.h

@@ -15,6 +15,28 @@ namespace Luau
 {
 struct FrontendOptions;
 
+enum class FragmentAutocompleteWaypoint
+{
+    ParseFragmentEnd,
+    CloneModuleStart,
+    CloneModuleEnd,
+    DfgBuildEnd,
+    CloneAndSquashScopeStart,
+    CloneAndSquashScopeEnd,
+    ConstraintSolverStart,
+    ConstraintSolverEnd,
+    TypecheckFragmentEnd,
+    AutocompleteEnd,
+    COUNT,
+};
+
+class IFragmentAutocompleteReporter
+{
+public:
+    virtual void reportWaypoint(FragmentAutocompleteWaypoint) = 0;
+    virtual void reportFragmentString(std::string_view) = 0;
+};
+
 enum class FragmentTypeCheckStatus
 {
     SkipAutocomplete,
@@ -27,6 +49,8 @@ struct FragmentAutocompleteAncestryResult
     std::vector<AstLocal*> localStack;
     std::vector<AstNode*> ancestry;
     AstStat* nearestStatement = nullptr;
+    AstStatBlock* parentBlock = nullptr;
+    Location fragmentSelectionRegion;
 };
 
 struct FragmentParseResult
@@ -37,6 +61,7 @@ struct FragmentParseResult
     AstStat* nearestStatement = nullptr;
     std::vector<Comment> commentLocations;
     std::unique_ptr<Allocator> alloc = std::make_unique<Allocator>();
+    Position scopePos{0, 0};
 };
 
 struct FragmentTypeCheckResult
@@ -50,14 +75,34 @@ struct FragmentAutocompleteResult
 {
     ModulePtr incrementalModule;
     Scope* freshScope;
-    TypeArena arenaForAutocomplete;
+    TypeArena arenaForAutocomplete_DEPRECATED;
     AutocompleteResult acResults;
 };
 
-FragmentAutocompleteAncestryResult findAncestryForFragmentParse(AstStatBlock* root, const Position& cursorPos);
+struct FragmentRegion
+{
+    Location fragmentLocation;
+    AstStat* nearestStatement = nullptr; // used for tests
+    AstStatBlock* parentBlock = nullptr; // used for scope detection
+};
+
+std::optional<Position> blockDiffStart(AstStatBlock* blockOld, AstStatBlock* blockNew, AstStat* nearestStatementNewAst);
+FragmentRegion getFragmentRegion(AstStatBlock* root, const Position& cursorPosition);
+FragmentAutocompleteAncestryResult findAncestryForFragmentParse(AstStatBlock* stale, const Position& cursorPos, AstStatBlock* lastGoodParse);
+FragmentAutocompleteAncestryResult findAncestryForFragmentParse_DEPRECATED(AstStatBlock* root, const Position& cursorPos);
+
+std::optional<FragmentParseResult> parseFragment_DEPRECATED(
+    AstStatBlock* root,
+    AstNameTable* names,
+    std::string_view src,
+    const Position& cursorPos,
+    std::optional<Position> fragmentEndPosition
+);
 
 std::optional<FragmentParseResult> parseFragment(
-    const SourceModule& srcModule,
+    AstStatBlock* stale,
+    AstStatBlock* mostRecentParse,
+    AstNameTable* names,
     std::string_view src,
     const Position& cursorPos,
     std::optional<Position> fragmentEndPosition
@@ -69,7 +114,9 @@ std::pair<FragmentTypeCheckStatus, FragmentTypeCheckResult> typecheckFragment(
     const Position& cursorPos,
     std::optional<FrontendOptions> opts,
     std::string_view src,
-    std::optional<Position> fragmentEndPosition
+    std::optional<Position> fragmentEndPosition,
+    AstStatBlock* recentParse = nullptr,
+    IFragmentAutocompleteReporter* reporter = nullptr
 );
 
 FragmentAutocompleteResult fragmentAutocomplete(
@@ -79,7 +126,9 @@ FragmentAutocompleteResult fragmentAutocomplete(
     Position cursorPosition,
     std::optional<FrontendOptions> opts,
     StringCompletionCallback callback,
-    std::optional<Position> fragmentEndPosition = std::nullopt
+    std::optional<Position> fragmentEndPosition = std::nullopt,
+    AstStatBlock* recentParse = nullptr,
+    IFragmentAutocompleteReporter* reporter = nullptr
 );
 
 enum class FragmentAutocompleteStatus
@@ -98,9 +147,10 @@ struct FragmentAutocompleteStatusResult
 struct FragmentContext
 {
     std::string_view newSrc;
-    const ParseResult& newAstRoot;
+    const ParseResult& freshParse;
     std::optional<FrontendOptions> opts;
     std::optional<Position> DEPRECATED_fragmentEndPosition;
+    IFragmentAutocompleteReporter* reporter = nullptr;
 };
 
 /**

Analysis/include/Luau/Frontend.h

@@ -10,7 +10,6 @@
 #include "Luau/Set.h"
 #include "Luau/TypeCheckLimits.h"
 #include "Luau/Variant.h"
-#include "Luau/AnyTypeSummary.h"
 
 #include <mutex>
 #include <string>
@@ -32,8 +31,8 @@ struct ModuleResolver;
 struct ParseResult;
 struct HotComment;
 struct BuildQueueItem;
+struct BuildQueueWorkState;
 struct FrontendCancellationToken;
-struct AnyTypeSummary;
 
 struct LoadDefinitionFileResult
 {
@@ -251,6 +250,9 @@ private:
     void checkBuildQueueItem(BuildQueueItem& item);
     void checkBuildQueueItems(std::vector<BuildQueueItem>& items);
     void recordItemResult(const BuildQueueItem& item);
+    void performQueueItemTask(std::shared_ptr<BuildQueueWorkState> state, size_t itemPos);
+    void sendQueueItemTask(std::shared_ptr<BuildQueueWorkState> state, size_t itemPos);
+    void sendQueueCycleItemTask(std::shared_ptr<BuildQueueWorkState> state);
 
     static LintResult classifyLints(const std::vector<LintWarning>& warnings, const Config& config);
 
@@ -296,6 +298,7 @@ ModulePtr check(
     NotNull<ModuleResolver> moduleResolver,
     NotNull<FileResolver> fileResolver,
     const ScopePtr& globalScope,
+    const ScopePtr& typeFunctionScope,
     std::function<void(const ModuleName&, const ScopePtr&)> prepareModuleScope,
     FrontendOptions options,
     TypeCheckLimits limits
@@ -310,6 +313,7 @@ ModulePtr check(
     NotNull<ModuleResolver> moduleResolver,
     NotNull<FileResolver> fileResolver,
     const ScopePtr& globalScope,
+    const ScopePtr& typeFunctionScope,
     std::function<void(const ModuleName&, const ScopePtr&)> prepareModuleScope,
     FrontendOptions options,
     TypeCheckLimits limits,

Analysis/include/Luau/Generalization.h

@@ -8,12 +8,75 @@
 namespace Luau
 {
 
+template<typename TID>
+struct GeneralizationParams
+{
+    bool foundOutsideFunctions = false;
+    size_t useCount = 0;
+    Polarity polarity = Polarity::None;
+};
+
+template<typename TID>
+struct GeneralizationResult
+{
+    std::optional<TID> result;
+
+    // True if the provided type was replaced with a generic.
+    bool wasReplacedByGeneric = false;
+
+    bool resourceLimitsExceeded = false;
+
+    explicit operator bool() const
+    {
+        return bool(result);
+    }
+};
+
+// Replace a single free type by its bounds according to the polarity provided.
+GeneralizationResult<TypeId> generalizeType(
+    NotNull<TypeArena> arena,
+    NotNull<BuiltinTypes> builtinTypes,
+    NotNull<Scope> scope,
+    TypeId freeTy,
+    const GeneralizationParams<TypeId>& params
+);
+
+// Generalize one type pack
+GeneralizationResult<TypePackId> generalizeTypePack(
+    NotNull<TypeArena> arena,
+    NotNull<BuiltinTypes> builtinTypes,
+    NotNull<Scope> scope,
+    TypePackId tp,
+    const GeneralizationParams<TypePackId>& params
+);
+
+void sealTable(NotNull<Scope> scope, TypeId ty);
+
+/** Attempt to generalize a type.
+ *
+ * If generalizationTarget is set, then only that type will be replaced by its
+ * bounds.  The way this is intended to be used is that ty is some function that
+ * is not fully generalized, and generalizationTarget is a type within its
+ * signature.  There should be no further constraints that could affect the
+ * bounds of generalizationTarget.
+ *
+ * Returns nullopt if generalization failed due to resources limits.
+ */
 std::optional<TypeId> generalize(
     NotNull<TypeArena> arena,
     NotNull<BuiltinTypes> builtinTypes,
     NotNull<Scope> scope,
-    NotNull<DenseHashSet<TypeId>> bakedTypes,
+    NotNull<DenseHashSet<TypeId>> cachedTypes,
     TypeId ty,
-    /* avoid sealing tables*/ bool avoidSealingTables = false
+    std::optional<TypeId> generalizationTarget = {}
 );
-}
+
+void pruneUnnecessaryGenerics(
+    NotNull<TypeArena> arena,
+    NotNull<BuiltinTypes> builtinTypes,
+    NotNull<Scope> scope,
+    NotNull<DenseHashSet<TypeId>> cachedTypes,
+    TypeId ty
+);
+
+} // namespace Luau

Analysis/include/Luau/GlobalTypes.h

@@ -19,7 +19,9 @@ struct GlobalTypes
 
     TypeArena globalTypes;
     SourceModule globalNames; // names for symbols entered into globalScope
+
     ScopePtr globalScope;     // shared by all modules
+    ScopePtr globalTypeFunctionScope; // shared by all modules
 };
 
 } // namespace Luau

Analysis/include/Luau/InferPolarity.h

@@ -0,0 +1,16 @@
+// This file is part of the Luau programming language and is licensed under MIT License; see LICENSE.txt for details
+#pragma once
+
+#include "Luau/NotNull.h"
+#include "Luau/TypeFwd.h"
+
+namespace Luau
+{
+
+struct Scope;
+struct TypeArena;
+
+void inferGenericPolarities(NotNull<TypeArena> arena, NotNull<Scope> scope, TypeId ty);
+void inferGenericPolarities(NotNull<TypeArena> arena, NotNull<Scope> scope, TypePackId tp);
+
+} // namespace Luau

Analysis/include/Luau/InsertionOrderedMap.h

@@ -67,6 +67,19 @@ public:
             return &pairs.at(it->second).second;
     }
 
+    V& operator[](const K& k)
+    {
+        auto it = indices.find(k);
+        if (it == indices.end())
+        {
+            pairs.push_back(std::make_pair(k, V()));
+            indices[k] = pairs.size() - 1;
+            return pairs.back().second;
+        }
+        else
+            return pairs.at(it->second).second;
+    }
+
     const_iterator begin() const
     {
         return pairs.begin();

Analysis/include/Luau/Instantiation.h

@@ -133,9 +133,9 @@ struct GenericTypeFinder : TypeOnceVisitor
         return false;
     }
 
-    bool visit(TypeId ty, const Luau::ClassType&) override
+    bool visit(TypeId ty, const Luau::ExternType&) override
     {
-        // During function instantiation, classes are not traversed even if they have generics
+        // During function instantiation, extern types are not traversed even if they have generics
         return false;
     }
 };

Analysis/include/Luau/Module.h

@@ -8,7 +8,6 @@
 #include "Luau/ParseResult.h"
 #include "Luau/Scope.h"
 #include "Luau/TypeArena.h"
-#include "Luau/AnyTypeSummary.h"
 #include "Luau/DataFlowGraph.h"
 
 #include <memory>
@@ -16,19 +15,16 @@
 #include <unordered_map>
 #include <optional>
 
-LUAU_FASTFLAG(LuauIncrementalAutocompleteCommentDetection)
-
 namespace Luau
 {
 
-using LogLuauProc = void (*)(std::string_view);
+using LogLuauProc = void (*)(std::string_view, std::string_view);
 extern LogLuauProc logLuau;
 
 void setLogLuau(LogLuauProc ll);
 void resetLogLuauProc();
 
 struct Module;
-struct AnyTypeSummary;
 
 using ScopePtr = std::shared_ptr<struct Scope>;
 using ModulePtr = std::shared_ptr<Module>;
@@ -86,13 +82,10 @@ struct Module
     TypeArena interfaceTypes;
     TypeArena internalTypes;
 
-    // Summary of Ast Nodes that either contain
-    // user annotated anys or typechecker inferred anys
-    AnyTypeSummary ats{};
-
     // Scopes and AST types refer to parse data, so we need to keep that alive
     std::shared_ptr<Allocator> allocator;
     std::shared_ptr<AstNameTable> names;
+    AstStatBlock* root = nullptr;
 
     std::vector<std::pair<Location, ScopePtr>> scopes; // never empty
 

Analysis/include/Luau/NonStrictTypeChecker.h

@@ -1,9 +1,10 @@
 // This file is part of the Luau programming language and is licensed under MIT License; see LICENSE.txt for details
 #pragma once
 
+#include "Luau/DataFlowGraph.h"
+#include "Luau/EqSatSimplification.h"
 #include "Luau/Module.h"
 #include "Luau/NotNull.h"
-#include "Luau/DataFlowGraph.h"
 
 namespace Luau
 {

Analysis/include/Luau/Normalize.h

@@ -181,7 +181,7 @@ struct NormalizedStringType
 
 bool isSubtype(const NormalizedStringType& subStr, const NormalizedStringType& superStr);
 
-struct NormalizedClassType
+struct NormalizedExternType
 {
     /** Has the following structure:
      *
@@ -192,7 +192,7 @@ struct NormalizedClassType
      *
      * Each TypeId is a class type.
      */
-    std::unordered_map<TypeId, TypeIds> classes;
+    std::unordered_map<TypeId, TypeIds> externTypes;
 
     /**
      * In order to maintain a consistent insertion order, we use this vector to
@@ -245,7 +245,7 @@ enum class NormalizationResult
 };
 
 // A normalized type is either any, unknown, or one of the form P | T | F | G where
-// * P is a union of primitive types (including singletons, classes and the error type)
+// * P is a union of primitive types (including singletons, extern types and the error type)
 // * T is a union of table types
 // * F is a union of an intersection of function types
 // * G is a union of generic/free/blocked types, intersected with a normalized type
@@ -260,7 +260,7 @@ struct NormalizedType
     // This type is either never, boolean type, or a boolean singleton.
     TypeId booleans;
 
-    NormalizedClassType classes;
+    NormalizedExternType externTypes;
 
     // The error part of the type.
     // This type is either never or the error type.
@@ -333,7 +333,7 @@ struct NormalizedType
     // Helpers that improve readability of the above (they just say if the component is present)
     bool hasTops() const;
     bool hasBooleans() const;
-    bool hasClasses() const;
+    bool hasExternTypes() const;
     bool hasErrors() const;
     bool hasNils() const;
     bool hasNumbers() const;
@@ -391,10 +391,10 @@ public:
     void unionTysWithTy(TypeIds& here, TypeId there);
     TypeId unionOfTops(TypeId here, TypeId there);
     TypeId unionOfBools(TypeId here, TypeId there);
-    void unionClassesWithClass(TypeIds& heres, TypeId there);
-    void unionClasses(TypeIds& heres, const TypeIds& theres);
-    void unionClassesWithClass(NormalizedClassType& heres, TypeId there);
-    void unionClasses(NormalizedClassType& heres, const NormalizedClassType& theres);
+    void unionExternTypesWithExternType(TypeIds& heres, TypeId there);
+    void unionExternTypes(TypeIds& heres, const TypeIds& theres);
+    void unionExternTypesWithExternType(NormalizedExternType& heres, TypeId there);
+    void unionExternTypes(NormalizedExternType& heres, const NormalizedExternType& theres);
     void unionStrings(NormalizedStringType& here, const NormalizedStringType& there);
     std::optional<TypePackId> unionOfTypePacks(TypePackId here, TypePackId there);
     std::optional<TypeId> unionOfFunctions(TypeId here, TypeId there);
@@ -423,8 +423,8 @@ public:
     // ------- Normalizing intersections
     TypeId intersectionOfTops(TypeId here, TypeId there);
     TypeId intersectionOfBools(TypeId here, TypeId there);
-    void intersectClasses(NormalizedClassType& heres, const NormalizedClassType& theres);
-    void intersectClassesWithClass(NormalizedClassType& heres, TypeId there);
+    void intersectExternTypes(NormalizedExternType& heres, const NormalizedExternType& theres);
+    void intersectExternTypesWithExternType(NormalizedExternType& heres, TypeId there);
     void intersectStrings(NormalizedStringType& here, const NormalizedStringType& there);
     std::optional<TypePackId> intersectionOfTypePacks(TypePackId here, TypePackId there);
     std::optional<TypeId> intersectionOfTables(TypeId here, TypeId there, SeenTablePropPairs& seenTablePropPairs, Set<TypeId>& seenSet);

Analysis/include/Luau/Polarity.h

@@ -0,0 +1,68 @@
+// This file is part of the Luau programming language and is licensed under MIT License; see LICENSE.txt for details
+#pragma once
+
+#include <cstdint>
+
+namespace Luau
+{
+
+enum struct Polarity : uint8_t
+{
+    None = 0b000,
+    Positive = 0b001,
+    Negative = 0b010,
+    Mixed = 0b011,
+    Unknown = 0b100,
+};
+
+inline Polarity operator|(Polarity lhs, Polarity rhs)
+{
+    return Polarity(uint8_t(lhs) | uint8_t(rhs));
+}
+
+inline Polarity& operator|=(Polarity& lhs, Polarity rhs)
+{
+    lhs = lhs | rhs;
+    return lhs;
+}
+
+inline Polarity operator&(Polarity lhs, Polarity rhs)
+{
+    return Polarity(uint8_t(lhs) & uint8_t(rhs));
+}
+
+inline Polarity& operator&=(Polarity& lhs, Polarity rhs)
+{
+    lhs = lhs & rhs;
+    return lhs;
+}
+
+inline bool isPositive(Polarity p)
+{
+    return bool(p & Polarity::Positive);
+}
+
+inline bool isNegative(Polarity p)
+{
+    return bool(p & Polarity::Negative);
+}
+
+inline bool isKnown(Polarity p)
+{
+    return p != Polarity::Unknown;
+}
+
+inline Polarity invert(Polarity p)
+{
+    switch (p)
+    {
+    case Polarity::Positive:
+        return Polarity::Negative;
+    case Polarity::Negative:
+        return Polarity::Positive;
+    default:
+        return p;
+    }
+}
+
+} // namespace Luau

Analysis/include/Luau/Quantify.h

@@ -16,7 +16,7 @@ struct Scope;
 
 void quantify(TypeId ty, TypeLevel level);
 
-// TODO: This is eerily similar to the pattern that NormalizedClassType
+// TODO: This is eerily similar to the pattern that NormalizedExternType
 // implements. We could, and perhaps should, merge them together.
 template<typename K, typename V>
 struct OrderedMap
@@ -31,13 +31,4 @@ struct OrderedMap
     }
 };
 
-struct QuantifierResult
-{
-    TypeId result;
-    OrderedMap<TypeId, TypeId> insertedGenerics;
-    OrderedMap<TypePackId, TypePackId> insertedGenericPacks;
-};
-
-std::optional<QuantifierResult> quantify(TypeArena* arena, TypeId ty, Scope* scope);
-
 } // namespace Luau

Analysis/include/Luau/Refinement.h

@@ -53,6 +53,7 @@ struct Proposition
 {
     const RefinementKey* key;
     TypeId discriminantTy;
+    bool implicitFromCall;
 };
 
 template<typename T>
@@ -69,6 +70,7 @@ struct RefinementArena
     RefinementId disjunction(RefinementId lhs, RefinementId rhs);
     RefinementId equivalence(RefinementId lhs, RefinementId rhs);
     RefinementId proposition(const RefinementKey* key, TypeId discriminantTy);
+    RefinementId implicitProposition(const RefinementKey* key, TypeId discriminantTy);
 
 private:
     TypedAllocator<Refinement> allocator;

Analysis/include/Luau/Scope.h

@@ -35,12 +35,12 @@ struct Scope
     explicit Scope(TypePackId returnType);                    // root scope
     explicit Scope(const ScopePtr& parent, int subLevel = 0); // child scope.  Parent must not be nullptr.
 
-    const ScopePtr parent; // null for the root
+    ScopePtr parent; // null for the root
 
     // All the children of this scope.
     std::vector<NotNull<Scope>> children;
     std::unordered_map<Symbol, Binding> bindings;
-    TypePackId returnType;
+    TypePackId returnType = nullptr;
     std::optional<TypePackId> varargPack;
 
     TypeLevel level;
@@ -59,6 +59,8 @@ struct Scope
 
     std::optional<TypeId> lookup(Symbol sym) const;
     std::optional<TypeId> lookupUnrefinedType(DefId def) const;
+
+    std::optional<TypeId> lookupRValueRefinementType(DefId def) const;
     std::optional<TypeId> lookup(DefId def) const;
     std::optional<std::pair<TypeId, Scope*>> lookupEx(DefId def);
     std::optional<std::pair<Binding*, Scope*>> lookupEx(Symbol sym);
@@ -71,6 +73,7 @@ struct Scope
 
     // WARNING: This function linearly scans for a string key of equal value!  It is thus O(n**2)
     std::optional<Binding> linearSearchForBinding(const std::string& name, bool traverseScopeChain = true) const;
+    std::optional<std::pair<Symbol, Binding>> linearSearchForBindingPair(const std::string& name, bool traverseScopeChain) const;
 
     RefinementMap refinements;
 
@@ -97,6 +100,7 @@ struct Scope
     std::unordered_map<Name, TypePackId> typeAliasTypePackParameters;
 
     std::optional<std::vector<TypeId>> interiorFreeTypes;
+    std::optional<std::vector<TypePackId>> interiorFreeTypePacks;
 };
 
 // Returns true iff the left scope encloses the right scope.  A Scope* equal to

Analysis/include/Luau/Simplify.h

@@ -24,6 +24,9 @@ SimplifyResult simplifyIntersection(NotNull<BuiltinTypes> builtinTypes, NotNull<
 
 SimplifyResult simplifyUnion(NotNull<BuiltinTypes> builtinTypes, NotNull<TypeArena> arena, TypeId left, TypeId right);
 
+SimplifyResult simplifyIntersectWithTruthy(NotNull<BuiltinTypes> builtinTypes, NotNull<TypeArena> arena, TypeId target);
+SimplifyResult simplifyIntersectWithFalsy(NotNull<BuiltinTypes> builtinTypes, NotNull<TypeArena> arena, TypeId target);
+
 enum class Relation
 {
     Disjoint,   // No A is a B or vice versa

Analysis/include/Luau/Substitution.h

@@ -86,6 +86,7 @@ struct TarjanNode
 struct Tarjan
 {
     Tarjan();
+    virtual ~Tarjan() = default;
 
     // Vertices (types and type packs) are indexed, using pre-order traversal.
     DenseHashMap<TypeId, int> typeToIndex{nullptr};
@@ -121,7 +122,7 @@ struct Tarjan
     void visitChildren(TypePackId tp, int index);
 
     void visitChild(TypeId ty);
-    void visitChild(TypePackId ty);
+    void visitChild(TypePackId tp);
 
     template<typename Ty>
     void visitChild(std::optional<Ty> ty)
@@ -132,7 +133,7 @@ struct Tarjan
 
     // Visit the root vertex.
     TarjanResult visitRoot(TypeId ty);
-    TarjanResult visitRoot(TypePackId ty);
+    TarjanResult visitRoot(TypePackId tp);
 
     // Used to reuse the object for a new operation
     void clearTarjan(const TxnLog* log);
@@ -150,26 +151,12 @@ struct Tarjan
     void visitSCC(int index);
 
     // Each subclass can decide to ignore some nodes.
-    virtual bool ignoreChildren(TypeId ty)
-    {
-        return false;
-    }
-
-    virtual bool ignoreChildren(TypePackId ty)
-    {
-        return false;
-    }
+    virtual bool ignoreChildren(TypeId ty);
+    virtual bool ignoreChildren(TypePackId ty);
 
     // Some subclasses might ignore children visit, but not other actions like replacing the children
-    virtual bool ignoreChildrenVisit(TypeId ty)
-    {
-        return ignoreChildren(ty);
-    }
-
-    virtual bool ignoreChildrenVisit(TypePackId ty)
-    {
-        return ignoreChildren(ty);
-    }
+    virtual bool ignoreChildrenVisit(TypeId ty);
+    virtual bool ignoreChildrenVisit(TypePackId ty);
 
     // Subclasses should say which vertices are dirty,
     // and what to do with dirty vertices.
@@ -184,6 +171,7 @@ struct Tarjan
 struct Substitution : Tarjan
 {
 protected:
+    explicit Substitution(TypeArena* arena);
     Substitution(const TxnLog* log_, TypeArena* arena);
 
     /*
@@ -232,28 +220,23 @@ public:
     virtual TypeId clean(TypeId ty) = 0;
     virtual TypePackId clean(TypePackId tp) = 0;
 
+protected:
     // Helper functions to create new types (used by subclasses)
     template<typename T>
-    TypeId addType(const T& tv)
+    TypeId addType(T tv)
     {
-        return arena->addType(tv);
+        return arena->addType(std::move(tv));
     }
 
     template<typename T>
-    TypePackId addTypePack(const T& tp)
+    TypePackId addTypePack(T tp)
     {
-        return arena->addTypePack(TypePackVar{tp});
+        return arena->addTypePack(TypePackVar{std::move(tp)});
     }
 
 private:
     template<typename Ty>
-    std::optional<Ty> replace(std::optional<Ty> ty)
-    {
-        if (ty)
-            return replace(*ty);
-        else
-            return std::nullopt;
-    }
+    std::optional<Ty> replace(std::optional<Ty> ty);
 };
 
 } // namespace Luau

Analysis/include/Luau/Subtyping.h

@@ -22,7 +22,7 @@ struct InternalErrorReporter;
 
 class TypeIds;
 class Normalizer;
-struct NormalizedClassType;
+struct NormalizedExternType;
 struct NormalizedFunctionType;
 struct NormalizedStringType;
 struct NormalizedType;
@@ -121,7 +121,7 @@ struct SubtypingEnvironment
     DenseHashMap<TypePackId, TypePackId> mappedGenericPacks{nullptr};
 
     /*
-     * See the test cyclic_tables_are_assumed_to_be_compatible_with_classes for
+     * See the test cyclic_tables_are_assumed_to_be_compatible_with_extern_types for
      * details.
      *
      * An empty value is equivalent to a nonexistent key.
@@ -229,9 +229,8 @@ private:
     SubtypingResult isCovariantWith(SubtypingEnvironment& env, const TableType* subTable, const TableType* superTable, 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(SubtypingEnvironment& env, const ClassType* subClass, const ClassType* superClass, NotNull<Scope> scope);
-    SubtypingResult
-    isCovariantWith(SubtypingEnvironment& env, TypeId subTy, const ClassType* subClass, TypeId superTy, const TableType* superTable, NotNull<Scope>);
+    SubtypingResult isCovariantWith(SubtypingEnvironment& env, const ExternType* subExternType, const ExternType* superExternType, NotNull<Scope> scope);
+    SubtypingResult isCovariantWith(SubtypingEnvironment& env, TypeId subTy, const ExternType* subExternType, TypeId superTy, const TableType* superTable, NotNull<Scope>);
     SubtypingResult isCovariantWith(
         SubtypingEnvironment& env,
         const FunctionType* subFunction,
@@ -259,11 +258,11 @@ private:
     );
     SubtypingResult isCovariantWith(
         SubtypingEnvironment& env,
-        const NormalizedClassType& subClass,
-        const NormalizedClassType& superClass,
+        const NormalizedExternType& subExternType,
+        const NormalizedExternType& superExternType,
         NotNull<Scope> scope
     );
-    SubtypingResult isCovariantWith(SubtypingEnvironment& env, const NormalizedClassType& subClass, const TypeIds& superTables, NotNull<Scope> scope);
+    SubtypingResult isCovariantWith(SubtypingEnvironment& env, const NormalizedExternType& subExternType, const TypeIds& superTables, NotNull<Scope> scope);
     SubtypingResult isCovariantWith(
         SubtypingEnvironment& env,
         const NormalizedStringType& subString,

Analysis/include/Luau/TableLiteralInference.h

@@ -14,6 +14,7 @@ namespace Luau
 struct TypeArena;
 struct BuiltinTypes;
 struct Unifier2;
+struct Subtyping;
 class AstExpr;
 
 TypeId matchLiteralType(
@@ -22,6 +23,7 @@ TypeId matchLiteralType(
     NotNull<BuiltinTypes> builtinTypes,
     NotNull<TypeArena> arena,
     NotNull<Unifier2> unifier,
+    NotNull<Subtyping> subtyping,
     TypeId expectedType,
     TypeId exprType,
     const AstExpr* expr,

Analysis/include/Luau/ToString.h

@@ -44,6 +44,7 @@ struct ToStringOptions
     bool hideTableKind = false;                   // If true, all tables will be surrounded with plain '{}'
     bool hideNamedFunctionTypeParameters = false; // If true, type parameters of functions will be hidden at top-level.
     bool hideFunctionSelfArgument = false;        // If true, `self: X` will be omitted from the function signature if the function has self
+    bool hideTableAliasExpansions = false;        // If true, all table aliases will not be expanded
     bool useQuestionMarks = true;                 // If true, use a postfix ? for options, else write them out as unions that include nil.
     size_t maxTableLength = size_t(FInt::LuauTableTypeMaximumStringifierLength); // Only applied to TableTypes
     size_t maxTypeLength = size_t(FInt::LuauTypeMaximumStringifierLength);

Analysis/include/Luau/TxnLog.h

@@ -192,16 +192,6 @@ struct TxnLog
     // The pointer returned lives until `commit` or `clear` is called.
     PendingTypePack* changeLevel(TypePackId tp, TypeLevel newLevel);
 
-    // Queues the replacement of a type's scope with the provided scope.
-    //
-    // The pointer returned lives until `commit` or `clear` is called.
-    PendingType* changeScope(TypeId ty, NotNull<Scope> scope);
-
-    // Queues the replacement of a type pack's scope with the provided scope.
-    //
-    // The pointer returned lives until `commit` or `clear` is called.
-    PendingTypePack* changeScope(TypePackId tp, NotNull<Scope> scope);
-
     // Queues a replacement of a table type with another table type with a new
     // indexer.
     //

Analysis/include/Luau/Type.h

@@ -5,10 +5,11 @@
 
 #include "Luau/Ast.h"
 #include "Luau/Common.h"
-#include "Luau/Refinement.h"
 #include "Luau/DenseHash.h"
 #include "Luau/NotNull.h"
+#include "Luau/Polarity.h"
 #include "Luau/Predicate.h"
+#include "Luau/Refinement.h"
 #include "Luau/Unifiable.h"
 #include "Luau/Variant.h"
 #include "Luau/VecDeque.h"
@@ -19,7 +20,6 @@
 #include <optional>
 #include <set>
 #include <string>
-#include <unordered_map>
 #include <vector>
 
 LUAU_FASTINT(LuauTableTypeMaximumStringifierLength)
@@ -72,12 +72,8 @@ struct FreeType
     // New constructors
     explicit FreeType(TypeLevel level, TypeId lowerBound, TypeId upperBound);
     // This one got promoted to explicit
-    explicit FreeType(Scope* scope, TypeId lowerBound, TypeId upperBound);
+    explicit FreeType(Scope* scope, TypeId lowerBound, TypeId upperBound, Polarity polarity = Polarity::Unknown);
     explicit FreeType(Scope* scope, TypeLevel level, TypeId lowerBound, TypeId upperBound);
-    // Old constructors
-    explicit FreeType(TypeLevel level);
-    explicit FreeType(Scope* scope);
-    FreeType(Scope* scope, TypeLevel level);
 
     int index;
     TypeLevel level;
@@ -91,6 +87,8 @@ struct FreeType
     // Only used under local type inference
     TypeId lowerBound = nullptr;
     TypeId upperBound = nullptr;
+
+    Polarity polarity = Polarity::Unknown;
 };
 
 struct GenericType
@@ -99,8 +97,8 @@ struct GenericType
     GenericType();
 
     explicit GenericType(TypeLevel level);
-    explicit GenericType(const Name& name);
-    explicit GenericType(Scope* scope);
+    explicit GenericType(const Name& name, Polarity polarity = Polarity::Unknown);
+    explicit GenericType(Scope* scope, Polarity polarity = Polarity::Unknown);
 
     GenericType(TypeLevel level, const Name& name);
     GenericType(Scope* scope, const Name& name);
@@ -110,6 +108,8 @@ struct GenericType
     Scope* scope = nullptr;
     Name name;
     bool explicitName = false;
+
+    Polarity polarity = Polarity::Unknown;
 };
 
 // When an equality constraint is found, it is then "bound" to that type,
@@ -287,7 +287,7 @@ struct MagicFunctionCallContext
 {
     NotNull<struct ConstraintSolver> solver;
     NotNull<const Constraint> constraint;
-    const class AstExprCall* callSite;
+    NotNull<const AstExprCall> callSite;
     TypePackId arguments;
     TypePackId result;
 };
@@ -348,10 +348,8 @@ struct FunctionType
     );
 
     // Local monomorphic function
-    FunctionType(TypeLevel level, TypePackId argTypes, TypePackId retTypes, std::optional<FunctionDefinition> defn = {}, bool hasSelf = false);
     FunctionType(
         TypeLevel level,
-        Scope* scope,
         TypePackId argTypes,
         TypePackId retTypes,
         std::optional<FunctionDefinition> defn = {},
@@ -368,16 +366,6 @@ struct FunctionType
         std::optional<FunctionDefinition> defn = {},
         bool hasSelf = false
     );
-    FunctionType(
-        TypeLevel level,
-        Scope* scope,
-        std::vector<TypeId> generics,
-        std::vector<TypePackId> genericPacks,
-        TypePackId argTypes,
-        TypePackId retTypes,
-        std::optional<FunctionDefinition> defn = {},
-        bool hasSelf = false
-    );
 
     std::optional<FunctionDefinition> definition;
     /// These should all be generic
@@ -386,7 +374,6 @@ struct FunctionType
     std::vector<std::optional<FunctionArgument>> argNames;
     Tags tags;
     TypeLevel level;
-    Scope* scope = nullptr;
     TypePackId argTypes;
     TypePackId retTypes;
     std::shared_ptr<MagicFunction> magic = nullptr;
@@ -396,6 +383,7 @@ struct FunctionType
     // this flag is used as an optimization to exit early from procedures that manipulate free or generic types.
     bool hasNoFreeOrGenericTypes = false;
     bool isCheckedFunction = false;
+    bool isDeprecatedFunction = false;
 };
 
 enum class TableState
@@ -472,7 +460,9 @@ struct Property
     TypeId type() const;
     void setType(TypeId ty);
 
-    // Sets the write type of this property to the read type.
+    // If this property has a present `writeTy`, set it equal to the `readTy`.
+    // This is to ensure that if we normalize a property that has divergent
+    // read and write types, we make them converge (for now).
     void makeShared();
 
     bool isShared() const;
@@ -517,9 +507,6 @@ struct TableType
     std::optional<TypeId> boundTo;
     Tags tags;
 
-    // Methods of this table that have an untyped self will use the same shared self type.
-    std::optional<TypeId> selfTy;
-
     // We track the number of as-yet-unadded properties to unsealed tables.
     // Some constraints will use this information to decide whether or not they
     // are able to dispatch.
@@ -545,15 +532,15 @@ struct ClassUserData
     virtual ~ClassUserData() {}
 };
 
-/** The type of a class.
+/** The type of an external userdata exposed to Luau.
  *
- * Classes behave like tables in many ways, but there are some important differences:
+ * Extern types behave like tables in many ways, but there are some important differences:
  *
  * The properties of a class are always exactly known.
- * Classes optionally have a parent class.
- * Two different classes that share the same properties are nevertheless distinct and mutually incompatible.
+ * Extern types optionally have a parent type.
+ * Two different extern types that share the same properties are nevertheless distinct and mutually incompatible.
  */
-struct ClassType
+struct ExternType
 {
     using Props = TableType::Props;
 
@@ -567,7 +554,7 @@ struct ClassType
     std::optional<Location> definitionLocation;
     std::optional<TableIndexer> indexer;
 
-    ClassType(
+    ExternType(
         Name name,
         Props props,
         std::optional<TypeId> parent,
@@ -588,7 +575,7 @@ struct ClassType
     {
     }
 
-    ClassType(
+    ExternType(
         Name name,
         Props props,
         std::optional<TypeId> parent,
@@ -622,7 +609,6 @@ struct UserDefinedFunctionData
     AstStatTypeFunction* definition = nullptr;
 
     DenseHashMap<Name, std::pair<AstStatTypeFunction*, size_t>> environment{""};
-    DenseHashMap<Name, AstStatTypeFunction*> environment_DEPRECATED{""};
 };
 
 /**
@@ -789,7 +775,7 @@ using TypeVariant = Unifiable::Variant<
     FunctionType,
     TableType,
     MetatableType,
-    ClassType,
+    ExternType,
     AnyType,
     UnionType,
     IntersectionType,
@@ -882,6 +868,9 @@ struct TypeFun
      */
     TypeId type;
 
+    // The location of where this TypeFun was defined, if available
+    std::optional<Location> definitionLocation;
+
     TypeFun() = default;
 
     explicit TypeFun(TypeId ty)
@@ -889,16 +878,23 @@ struct TypeFun
     {
     }
 
-    TypeFun(std::vector<GenericTypeDefinition> typeParams, TypeId type)
+    TypeFun(std::vector<GenericTypeDefinition> typeParams, TypeId type, std::optional<Location> definitionLocation = std::nullopt)
         : typeParams(std::move(typeParams))
         , type(type)
+        , definitionLocation(definitionLocation)
     {
     }
 
-    TypeFun(std::vector<GenericTypeDefinition> typeParams, std::vector<GenericTypePackDefinition> typePackParams, TypeId type)
+    TypeFun(
+        std::vector<GenericTypeDefinition> typeParams,
+        std::vector<GenericTypePackDefinition> typePackParams,
+        TypeId type,
+        std::optional<Location> definitionLocation = std::nullopt
+    )
         : typeParams(std::move(typeParams))
         , typePackParams(std::move(typePackParams))
         , type(type)
+        , definitionLocation(definitionLocation)
     {
     }
 
@@ -990,7 +986,7 @@ public:
     const TypeId threadType;
     const TypeId bufferType;
     const TypeId functionType;
-    const TypeId classType;
+    const TypeId externType;
     const TypeId tableType;
     const TypeId emptyTableType;
     const TypeId trueType;
@@ -1002,6 +998,7 @@ public:
     const TypeId noRefineType;
     const TypeId falsyType;
     const TypeId truthyType;
+    const TypeId notNilType;
 
     const TypeId optionalNumberType;
     const TypeId optionalStringType;
@@ -1022,10 +1019,10 @@ TypeLevel* getMutableLevel(TypeId ty);
 
 std::optional<TypeLevel> getLevel(TypePackId tp);
 
-const Property* lookupClassProp(const ClassType* cls, const Name& name);
+const Property* lookupExternTypeProp(const ExternType* cls, const Name& name);
 
 // Whether `cls` is a subclass of `parent`
-bool isSubclass(const ClassType* cls, const ClassType* parent);
+bool isSubclass(const ExternType* cls, const ExternType* parent);
 
 Type* asMutable(TypeId ty);
 
@@ -1202,7 +1199,7 @@ private:
     }
 };
 
-TypeId freshType(NotNull<TypeArena> arena, NotNull<BuiltinTypes> builtinTypes, Scope* scope);
+TypeId freshType(NotNull<TypeArena> arena, NotNull<BuiltinTypes> builtinTypes, Scope* scope, Polarity polarity = Polarity::Unknown);
 
 using TypeIdPredicate = std::function<std::optional<TypeId>(TypeId)>;
 std::vector<TypeId> filterMap(TypeId type, TypeIdPredicate predicate);

Analysis/include/Luau/TypeArena.h

@@ -1,6 +1,7 @@
 // This file is part of the Luau programming language and is licensed under MIT License; see LICENSE.txt for details
 #pragma once
 
+#include "Luau/Polarity.h"
 #include "Luau/TypedAllocator.h"
 #include "Luau/Type.h"
 #include "Luau/TypePack.h"
@@ -36,11 +37,7 @@ struct TypeArena
     TypeId freshType(NotNull<BuiltinTypes> builtins, Scope* scope);
     TypeId freshType(NotNull<BuiltinTypes> builtins, Scope* scope, TypeLevel level);
 
-    TypeId freshType_DEPRECATED(TypeLevel level);
-    TypeId freshType_DEPRECATED(Scope* scope);
-    TypeId freshType_DEPRECATED(Scope* scope, TypeLevel level);
-
-    TypePackId freshTypePack(Scope* scope);
+    TypePackId freshTypePack(Scope* scope, Polarity polarity = Polarity::Unknown);
 
     TypePackId addTypePack(std::initializer_list<TypeId> types);
     TypePackId addTypePack(std::vector<TypeId> types, std::optional<TypePackId> tail = {});

Analysis/include/Luau/TypeAttach.h

@@ -11,7 +11,7 @@ namespace Luau
 struct TypeRehydrationOptions
 {
     std::unordered_set<std::string> bannedNames;
-    bool expandClassProps = false;
+    bool expandExternTypeProps = false;
 };
 
 void attachTypeData(SourceModule& source, Module& result);

Analysis/include/Luau/TypeChecker2.h

@@ -13,6 +13,8 @@
 #include "Luau/TypeOrPack.h"
 #include "Luau/TypeUtils.h"
 
+LUAU_FASTFLAG(LuauImproveTypePathsInErrors)
+
 namespace Luau
 {
 
@@ -38,18 +40,29 @@ struct Reasonings
 
     std::string toString()
     {
+        if (FFlag::LuauImproveTypePathsInErrors && reasons.empty())
+            return "";
+
         // DenseHashSet ordering is entirely undefined, so we want to
         // sort the reasons here to achieve a stable error
         // stringification.
         std::sort(reasons.begin(), reasons.end());
-        std::string allReasons;
+        std::string allReasons = FFlag::LuauImproveTypePathsInErrors ? "\nthis is because " : "";
         bool first = true;
         for (const std::string& reason : reasons)
         {
-            if (first)
-                first = false;
+            if (FFlag::LuauImproveTypePathsInErrors)
+            {
+                if (reasons.size() > 1)
+                    allReasons += "\n\t * ";
+            }
             else
-                allReasons += "\n\t";
+            {
+                if (first)
+                    first = false;
+                else
+                    allReasons += "\n\t";
+            }
 
             allReasons += reason;
         }
@@ -147,7 +160,7 @@ private:
     void visit(AstTypeList types);
     void visit(AstStatDeclareFunction* stat);
     void visit(AstStatDeclareGlobal* stat);
-    void visit(AstStatDeclareClass* stat);
+    void visit(AstStatDeclareExternType* stat);
     void visit(AstStatError* stat);
     void visit(AstExpr* expr, ValueContext context);
     void visit(AstExprGroup* expr, ValueContext context);

Analysis/include/Luau/TypeFunction.h

@@ -48,6 +48,9 @@ struct TypeFunctionRuntime
     // Evaluation of type functions should only be performed in the absence of parse errors in the source module
     bool allowEvaluation = true;
 
+    // Root scope in which the type function operates in, set up by ConstraintGenerator
+    ScopePtr rootScope;
+
     // Output created by 'print' function
     std::vector<std::string> messages;
 
@@ -152,6 +155,9 @@ struct TypeFunction
 
     /// The reducer function for the type function.
     ReducerFunction<TypeId> reducer;
+
+    /// If true, this type function can reduce even if it is parameterized on a generic.
+    bool canReduceGenerics = false;
 };
 
 /// Represents a type function that may be applied to map a series of types and
@@ -164,6 +170,9 @@ struct TypePackFunction
 
     /// The reducer function for the type pack function.
     ReducerFunction<TypePackId> reducer;
+
+    /// If true, this type function can reduce even if it is parameterized on a generic.
+    bool canReduceGenerics = false;
 };
 
 struct FunctionGraphReductionResult
@@ -174,6 +183,7 @@ struct FunctionGraphReductionResult
     DenseHashSet<TypePackId> blockedPacks{nullptr};
     DenseHashSet<TypeId> reducedTypes{nullptr};
     DenseHashSet<TypePackId> reducedPacks{nullptr};
+    DenseHashSet<TypeId> irreducibleTypes{nullptr};
 };
 
 /**
@@ -244,6 +254,8 @@ struct BuiltinTypeFunctions
     TypeFunction setmetatableFunc;
     TypeFunction getmetatableFunc;
 
+    TypeFunction weakoptionalFunc;
+
     void addToScope(NotNull<TypeArena> arena, NotNull<Scope> scope) const;
 };
 

Analysis/include/Luau/TypeFunctionRuntime.h

@@ -205,7 +205,7 @@ struct TypeFunctionTableType
     std::optional<TypeFunctionTypeId> metatable;
 };
 
-struct TypeFunctionClassType
+struct TypeFunctionExternType
 {
     using Name = std::string;
     using Props = std::map<Name, TypeFunctionProperty>;
@@ -222,9 +222,7 @@ struct TypeFunctionClassType
     std::optional<TypeFunctionTypeId> readParent;
     std::optional<TypeFunctionTypeId> writeParent;
 
-    TypeId classTy;
-
-    std::string name_DEPRECATED;
+    TypeId externTy;
 };
 
 struct TypeFunctionGenericType
@@ -246,7 +244,7 @@ using TypeFunctionTypeVariant = Luau::Variant<
     TypeFunctionNegationType,
     TypeFunctionFunctionType,
     TypeFunctionTableType,
-    TypeFunctionClassType,
+    TypeFunctionExternType,
     TypeFunctionGenericType>;
 
 struct TypeFunctionType

Analysis/include/Luau/TypeFunctionRuntimeBuilder.h

@@ -28,14 +28,8 @@ struct TypeFunctionRuntimeBuilderState
 {
     NotNull<TypeFunctionContext> ctx;
 
-    // Mapping of class name to ClassType
-    // Invariant: users can not create a new class types -> any class types that get deserialized must have been an argument to the type function
-    // Using this invariant, whenever a ClassType is serialized, we can put it into this map
-    // whenever a ClassType is deserialized, we can use this map to return the corresponding value
-    DenseHashMap<std::string, TypeId> classesSerialized_DEPRECATED{{}};
-
     // List of errors that occur during serialization/deserialization
-    // At every iteration of serialization/deserialzation, if this list.size() != 0, we halt the process
+    // At every iteration of serialization/deserialization, if this list.size() != 0, we halt the process
     std::vector<std::string> errors{};
 
     TypeFunctionRuntimeBuilderState(NotNull<TypeFunctionContext> ctx)

Analysis/include/Luau/TypeFwd.h

@@ -29,7 +29,7 @@ struct SingletonType;
 struct FunctionType;
 struct TableType;
 struct MetatableType;
-struct ClassType;
+struct ExternType;
 struct AnyType;
 struct UnionType;
 struct IntersectionType;

Analysis/include/Luau/TypeInfer.h

@@ -90,11 +90,11 @@ struct TypeChecker
     ControlFlow check(const ScopePtr& scope, TypeId ty, const ScopePtr& funScope, const AstStatLocalFunction& function);
     ControlFlow check(const ScopePtr& scope, const AstStatTypeAlias& typealias);
     ControlFlow check(const ScopePtr& scope, const AstStatTypeFunction& typefunction);
-    ControlFlow check(const ScopePtr& scope, const AstStatDeclareClass& declaredClass);
+    ControlFlow check(const ScopePtr& scope, const AstStatDeclareExternType& declaredExternType);
     ControlFlow check(const ScopePtr& scope, const AstStatDeclareFunction& declaredFunction);
 
     void prototype(const ScopePtr& scope, const AstStatTypeAlias& typealias, int subLevel = 0);
-    void prototype(const ScopePtr& scope, const AstStatDeclareClass& declaredClass);
+    void prototype(const ScopePtr& scope, const AstStatDeclareExternType& declaredExternType);
 
     ControlFlow checkBlock(const ScopePtr& scope, const AstStatBlock& statement);
     ControlFlow checkBlockWithoutRecursionCheck(const ScopePtr& scope, const AstStatBlock& statement);
@@ -130,6 +130,7 @@ struct TypeChecker
         const PredicateVec& predicates = {}
     );
     WithPredicate<TypeId> checkExpr(const ScopePtr& scope, const AstExprBinary& expr, std::optional<TypeId> expectedType = std::nullopt);
+    WithPredicate<TypeId> checkExpr_DEPRECATED(const ScopePtr& scope, const AstExprBinary& expr, std::optional<TypeId> expectedType = std::nullopt);
     WithPredicate<TypeId> checkExpr(const ScopePtr& scope, const AstExprTypeAssertion& expr);
     WithPredicate<TypeId> checkExpr(const ScopePtr& scope, const AstExprError& expr);
     WithPredicate<TypeId> checkExpr(const ScopePtr& scope, const AstExprIfElse& expr, std::optional<TypeId> expectedType = std::nullopt);
@@ -486,7 +487,7 @@ private:
     /**
      * A set of incorrect class definitions which is used to avoid a second-pass analysis.
      */
-    DenseHashSet<const AstStatDeclareClass*> incorrectClassDefinitions{nullptr};
+    DenseHashSet<const AstStatDeclareExternType*> incorrectExternTypeDefinitions{nullptr};
 
     std::vector<std::pair<TypeId, ScopePtr>> deferredQuantification;
 };

Analysis/include/Luau/TypePack.h

@@ -1,11 +1,12 @@
 // This file is part of the Luau programming language and is licensed under MIT License; see LICENSE.txt for details
 #pragma once
 
+#include "Luau/Common.h"
+#include "Luau/NotNull.h"
+#include "Luau/Polarity.h"
+#include "Luau/TypeFwd.h"
 #include "Luau/Unifiable.h"
 #include "Luau/Variant.h"
-#include "Luau/TypeFwd.h"
-#include "Luau/NotNull.h"
-#include "Luau/Common.h"
 
 #include <optional>
 #include <set>
@@ -26,12 +27,14 @@ struct TypeFunctionInstanceTypePack;
 struct FreeTypePack
 {
     explicit FreeTypePack(TypeLevel level);
-    explicit FreeTypePack(Scope* scope);
+    explicit FreeTypePack(Scope* scope, Polarity polarity = Polarity::Unknown);
     FreeTypePack(Scope* scope, TypeLevel level);
 
     int index;
     TypeLevel level;
     Scope* scope = nullptr;
+
+    Polarity polarity = Polarity::Unknown;
 };
 
 struct GenericTypePack
@@ -40,7 +43,7 @@ struct GenericTypePack
     GenericTypePack();
     explicit GenericTypePack(TypeLevel level);
     explicit GenericTypePack(const Name& name);
-    explicit GenericTypePack(Scope* scope);
+    explicit GenericTypePack(Scope* scope, Polarity polarity = Polarity::Unknown);
     GenericTypePack(TypeLevel level, const Name& name);
     GenericTypePack(Scope* scope, const Name& name);
 
@@ -49,6 +52,8 @@ struct GenericTypePack
     Scope* scope = nullptr;
     Name name;
     bool explicitName = false;
+
+    Polarity polarity = Polarity::Unknown;
 };
 
 using BoundTypePack = Unifiable::Bound<TypePackId>;
@@ -100,9 +105,9 @@ struct TypeFunctionInstanceTypePack
 
 struct TypePackVar
 {
-    explicit TypePackVar(const TypePackVariant& ty);
-    explicit TypePackVar(TypePackVariant&& ty);
-    TypePackVar(TypePackVariant&& ty, bool persistent);
+    explicit TypePackVar(const TypePackVariant& tp);
+    explicit TypePackVar(TypePackVariant&& tp);
+    TypePackVar(TypePackVariant&& tp, bool persistent);
 
     bool operator==(const TypePackVar& rhs) const;
 
@@ -169,6 +174,7 @@ struct TypePackIterator
 
 private:
     TypePackId currentTypePack = nullptr;
+    TypePackId tailCycleCheck = nullptr;
     const TypePack* tp = nullptr;
     size_t currentIndex = 0;
 
@@ -179,6 +185,8 @@ TypePackIterator begin(TypePackId tp);
 TypePackIterator begin(TypePackId tp, const TxnLog* log);
 TypePackIterator end(TypePackId tp);
 
+TypePackId getTail(TypePackId tp);
+
 using SeenSet = std::set<std::pair<const void*, const void*>>;
 
 bool areEqual(SeenSet& seen, const TypePackVar& lhs, const TypePackVar& rhs);

Analysis/include/Luau/TypePath.h

@@ -42,9 +42,19 @@ struct Property
 /// element.
 struct Index
 {
+    enum class Variant
+    {
+        Pack,
+        Union,
+        Intersection
+    };
+
     /// The 0-based index to use for the lookup.
     size_t index;
 
+    /// The sort of thing we're indexing from, this is used in stringifying the type path for errors.
+    Variant variant;
+
     bool operator==(const Index& other) const;
 };
 
@@ -205,6 +215,9 @@ using Path = TypePath::Path;
 /// terribly clear to end users of the Luau type system.
 std::string toString(const TypePath::Path& path, bool prefixDot = false);
 
+/// Converts a Path to a human readable string for error reporting.
+std::string toStringHuman(const TypePath::Path& path);
+
 std::optional<TypeOrPack> traverse(TypeId root, const Path& path, NotNull<BuiltinTypes> builtinTypes);
 std::optional<TypeOrPack> traverse(TypePackId root, const Path& path, NotNull<BuiltinTypes> builtinTypes);
 

Analysis/include/Luau/TypeUtils.h

@@ -289,4 +289,6 @@ std::vector<TypeId> findBlockedArgTypesIn(AstExprCall* expr, NotNull<DenseHashMa
  */
 void trackInteriorFreeType(Scope* scope, TypeId ty);
 
+void trackInteriorFreeTypePack(Scope* scope, TypePackId tp);
+
 } // namespace Luau

Analysis/include/Luau/Unifier.h

@@ -140,7 +140,7 @@ private:
     void tryUnifyTables(TypeId subTy, TypeId superTy, bool isIntersection = false, const LiteralProperties* aliasableMap = nullptr);
     void tryUnifyScalarShape(TypeId subTy, TypeId superTy, bool reversed);
     void tryUnifyWithMetatable(TypeId subTy, TypeId superTy, bool reversed);
-    void tryUnifyWithClass(TypeId subTy, TypeId superTy, bool reversed);
+    void tryUnifyWithExternType(TypeId subTy, TypeId superTy, bool reversed);
     void tryUnifyNegations(TypeId subTy, TypeId superTy);
 
     TypePackId tryApplyOverloadedFunction(TypeId function, const NormalizedFunctionType& overloads, TypePackId args);

Analysis/include/Luau/Unifier2.h

@@ -44,6 +44,12 @@ struct Unifier2
     // Mapping from generic type packs to `TypePack`s of free types to be used in instantiation.
     DenseHashMap<TypePackId, TypePackId> genericPackSubstitutions{nullptr};
 
+    // Unification sometimes results in the creation of new free types.
+    // We collect them here so that other systems can perform necessary
+    // bookkeeping.
+    std::vector<TypeId> newFreshTypes;
+    std::vector<TypePackId> newFreshTypePacks;
+
     int recursionCount = 0;
     int recursionLimit = 0;
 
@@ -87,6 +93,9 @@ struct Unifier2
     bool unify(const AnyType* subAny, const TableType* superTable);
     bool unify(const TableType* subTable, const AnyType* superAny);
 
+    bool unify(const MetatableType* subMetatable, const AnyType*);
+    bool unify(const AnyType*, const MetatableType* superMetatable);
+
     // TODO think about this one carefully.  We don't do unions or intersections of type packs
     bool unify(TypePackId subTp, TypePackId superTp);
 
@@ -110,6 +119,9 @@ private:
     // Returns true if needle occurs within haystack already.  ie if we bound
     // needle to haystack, would a cyclic TypePack result?
     OccursCheckResult occursCheck(DenseHashSet<TypePackId>& seen, TypePackId needle, TypePackId haystack);
+
+    TypeId freshType(NotNull<Scope> scope, Polarity polarity);
+    TypePackId freshTypePack(NotNull<Scope> scope, Polarity polarity);
 };
 
 } // namespace Luau

Analysis/include/Luau/VisitType.h

@@ -126,7 +126,7 @@ struct GenericTypeVisitor
     {
         return visit(ty);
     }
-    virtual bool visit(TypeId ty, const ClassType& ctv)
+    virtual bool visit(TypeId ty, const ExternType& etv)
     {
         return visit(ty);
     }
@@ -313,11 +313,11 @@ struct GenericTypeVisitor
                 traverse(mtv->metatable);
             }
         }
-        else if (auto ctv = get<ClassType>(ty))
+        else if (auto etv = get<ExternType>(ty))
         {
-            if (visit(ty, *ctv))
+            if (visit(ty, *etv))
             {
-                for (const auto& [name, prop] : ctv->props)
+                for (const auto& [name, prop] : etv->props)
                 {
                     if (FFlag::LuauSolverV2)
                     {
@@ -335,16 +335,16 @@ struct GenericTypeVisitor
                         traverse(prop.type());
                 }
 
-                if (ctv->parent)
-                    traverse(*ctv->parent);
+                if (etv->parent)
+                    traverse(*etv->parent);
 
-                if (ctv->metatable)
-                    traverse(*ctv->metatable);
+                if (etv->metatable)
+                    traverse(*etv->metatable);
 
-                if (ctv->indexer)
+                if (etv->indexer)
                 {
-                    traverse(ctv->indexer->indexType);
-                    traverse(ctv->indexer->indexResultType);
+                    traverse(etv->indexer->indexType);
+                    traverse(etv->indexer->indexResultType);
                 }
             }
         }
@@ -396,7 +396,7 @@ struct GenericTypeVisitor
                 traverse(unwrapped);
 
             // Visiting into LazyType that hasn't been unwrapped may necessarily cause infinite expansion, so we don't do that on purpose.
-            // Asserting also makes no sense, because the type _will_ happen here, most likely as a property of some ClassType
+            // Asserting also makes no sense, because the type _will_ happen here, most likely as a property of some ExternType
             // that doesn't need to be expanded.
         }
         else if (auto stv = get<SingletonType>(ty))

Analysis/src/AnyTypeSummary.cpp

@@ -1,902 +0,0 @@
-// This file is part of the Luau programming language and is licensed under MIT License; see LICENSE.txt for details
-#include "Luau/AnyTypeSummary.h"
-
-#include "Luau/BuiltinDefinitions.h"
-#include "Luau/Clone.h"
-#include "Luau/Common.h"
-#include "Luau/Config.h"
-#include "Luau/ConstraintGenerator.h"
-#include "Luau/ConstraintSolver.h"
-#include "Luau/DataFlowGraph.h"
-#include "Luau/DcrLogger.h"
-#include "Luau/Module.h"
-#include "Luau/Parser.h"
-#include "Luau/Scope.h"
-#include "Luau/StringUtils.h"
-#include "Luau/TimeTrace.h"
-#include "Luau/ToString.h"
-#include "Luau/Transpiler.h"
-#include "Luau/TypeArena.h"
-#include "Luau/TypeChecker2.h"
-#include "Luau/NonStrictTypeChecker.h"
-#include "Luau/TypeInfer.h"
-#include "Luau/Variant.h"
-#include "Luau/VisitType.h"
-#include "Luau/TypePack.h"
-#include "Luau/TypeOrPack.h"
-
-#include <algorithm>
-#include <memory>
-#include <chrono>
-#include <condition_variable>
-#include <exception>
-#include <mutex>
-#include <stdexcept>
-#include <string>
-#include <iostream>
-
-
-#include <stdio.h>
-
-LUAU_FASTFLAGVARIABLE(StudioReportLuauAny2);
-LUAU_FASTINTVARIABLE(LuauAnySummaryRecursionLimit, 300);
-
-LUAU_FASTFLAG(DebugLuauMagicTypes);
-
-namespace Luau
-{
-
-void AnyTypeSummary::traverse(const Module* module, AstStat* src, NotNull<BuiltinTypes> builtinTypes)
-{
-    visit(findInnerMostScope(src->location, module), src, module, builtinTypes);
-}
-
-void AnyTypeSummary::visit(const Scope* scope, AstStat* stat, const Module* module, NotNull<BuiltinTypes> builtinTypes)
-{
-    RecursionLimiter limiter{&recursionCount, FInt::LuauAnySummaryRecursionLimit};
-
-    if (auto s = stat->as<AstStatBlock>())
-        return visit(scope, s, module, builtinTypes);
-    else if (auto i = stat->as<AstStatIf>())
-        return visit(scope, i, module, builtinTypes);
-    else if (auto s = stat->as<AstStatWhile>())
-        return visit(scope, s, module, builtinTypes);
-    else if (auto s = stat->as<AstStatRepeat>())
-        return visit(scope, s, module, builtinTypes);
-    else if (auto r = stat->as<AstStatReturn>())
-        return visit(scope, r, module, builtinTypes);
-    else if (auto e = stat->as<AstStatExpr>())
-        return visit(scope, e, module, builtinTypes);
-    else if (auto s = stat->as<AstStatLocal>())
-        return visit(scope, s, module, builtinTypes);
-    else if (auto s = stat->as<AstStatFor>())
-        return visit(scope, s, module, builtinTypes);
-    else if (auto s = stat->as<AstStatForIn>())
-        return visit(scope, s, module, builtinTypes);
-    else if (auto a = stat->as<AstStatAssign>())
-        return visit(scope, a, module, builtinTypes);
-    else if (auto a = stat->as<AstStatCompoundAssign>())
-        return visit(scope, a, module, builtinTypes);
-    else if (auto f = stat->as<AstStatFunction>())
-        return visit(scope, f, module, builtinTypes);
-    else if (auto f = stat->as<AstStatLocalFunction>())
-        return visit(scope, f, module, builtinTypes);
-    else if (auto a = stat->as<AstStatTypeAlias>())
-        return visit(scope, a, module, builtinTypes);
-    else if (auto s = stat->as<AstStatDeclareGlobal>())
-        return visit(scope, s, module, builtinTypes);
-    else if (auto s = stat->as<AstStatDeclareFunction>())
-        return visit(scope, s, module, builtinTypes);
-    else if (auto s = stat->as<AstStatDeclareClass>())
-        return visit(scope, s, module, builtinTypes);
-    else if (auto s = stat->as<AstStatError>())
-        return visit(scope, s, module, builtinTypes);
-}
-
-void AnyTypeSummary::visit(const Scope* scope, AstStatBlock* block, const Module* module, NotNull<BuiltinTypes> builtinTypes)
-{
-    RecursionCounter counter{&recursionCount};
-
-    if (recursionCount >= FInt::LuauAnySummaryRecursionLimit)
-        return; // don't report
-
-    for (AstStat* stat : block->body)
-        visit(scope, stat, module, builtinTypes);
-}
-
-void AnyTypeSummary::visit(const Scope* scope, AstStatIf* ifStatement, const Module* module, NotNull<BuiltinTypes> builtinTypes)
-{
-    if (ifStatement->thenbody)
-    {
-        const Scope* thenScope = findInnerMostScope(ifStatement->thenbody->location, module);
-        visit(thenScope, ifStatement->thenbody, module, builtinTypes);
-    }
-
-    if (ifStatement->elsebody)
-    {
-        const Scope* elseScope = findInnerMostScope(ifStatement->elsebody->location, module);
-        visit(elseScope, ifStatement->elsebody, module, builtinTypes);
-    }
-}
-
-void AnyTypeSummary::visit(const Scope* scope, AstStatWhile* while_, const Module* module, NotNull<BuiltinTypes> builtinTypes)
-{
-    const Scope* whileScope = findInnerMostScope(while_->location, module);
-    visit(whileScope, while_->body, module, builtinTypes);
-}
-
-void AnyTypeSummary::visit(const Scope* scope, AstStatRepeat* repeat, const Module* module, NotNull<BuiltinTypes> builtinTypes)
-{
-    const Scope* repeatScope = findInnerMostScope(repeat->location, module);
-    visit(repeatScope, repeat->body, module, builtinTypes);
-}
-
-void AnyTypeSummary::visit(const Scope* scope, AstStatReturn* ret, const Module* module, NotNull<BuiltinTypes> builtinTypes)
-{
-    const Scope* retScope = findInnerMostScope(ret->location, module);
-
-    auto ctxNode = getNode(rootSrc, ret);
-    bool seenTP = false;
-
-    for (auto val : ret->list)
-    {
-        if (isAnyCall(retScope, val, module, builtinTypes))
-        {
-            TelemetryTypePair types;
-            types.inferredType = toString(lookupType(val, module, builtinTypes));
-            TypeInfo ti{Pattern::FuncApp, toString(ctxNode), types};
-            typeInfo.push_back(ti);
-        }
-
-        if (isAnyCast(retScope, val, module, builtinTypes))
-        {
-            if (auto cast = val->as<AstExprTypeAssertion>())
-            {
-                TelemetryTypePair types;
-
-                types.annotatedType = toString(lookupAnnotation(cast->annotation, module, builtinTypes));
-                types.inferredType = toString(lookupType(cast->expr, module, builtinTypes));
-
-                TypeInfo ti{Pattern::Casts, toString(ctxNode), types};
-                typeInfo.push_back(ti);
-            }
-        }
-
-        if (ret->list.size > 1 && !seenTP)
-        {
-            if (containsAny(retScope->returnType))
-            {
-                seenTP = true;
-
-                TelemetryTypePair types;
-
-                types.inferredType = toString(retScope->returnType);
-
-                TypeInfo ti{Pattern::TypePk, toString(ctxNode), types};
-                typeInfo.push_back(ti);
-            }
-        }
-    }
-}
-
-void AnyTypeSummary::visit(const Scope* scope, AstStatLocal* local, const Module* module, NotNull<BuiltinTypes> builtinTypes)
-{
-    auto ctxNode = getNode(rootSrc, local);
-
-    TypePackId values = reconstructTypePack(local->values, module, builtinTypes);
-    auto [head, tail] = flatten(values);
-
-    size_t posn = 0;
-    for (AstLocal* loc : local->vars)
-    {
-        if (local->vars.data[0] == loc && posn < local->values.size)
-        {
-            if (loc->annotation)
-            {
-                auto annot = lookupAnnotation(loc->annotation, module, builtinTypes);
-                if (containsAny(annot))
-                {
-                    TelemetryTypePair types;
-
-                    types.annotatedType = toString(annot);
-                    types.inferredType = toString(lookupType(local->values.data[posn], module, builtinTypes));
-
-                    TypeInfo ti{Pattern::VarAnnot, toString(ctxNode), types};
-                    typeInfo.push_back(ti);
-                }
-            }
-
-            const AstExprTypeAssertion* maybeRequire = local->values.data[posn]->as<AstExprTypeAssertion>();
-            if (!maybeRequire)
-                continue;
-
-            if (std::min(local->values.size - 1, posn) < head.size())
-            {
-                if (isAnyCast(scope, local->values.data[posn], module, builtinTypes))
-                {
-                    TelemetryTypePair types;
-
-                    types.inferredType = toString(head[std::min(local->values.size - 1, posn)]);
-
-                    TypeInfo ti{Pattern::Casts, toString(ctxNode), types};
-                    typeInfo.push_back(ti);
-                }
-            }
-        }
-        else
-        {
-
-            if (std::min(local->values.size - 1, posn) < head.size())
-            {
-                if (loc->annotation)
-                {
-                    auto annot = lookupAnnotation(loc->annotation, module, builtinTypes);
-                    if (containsAny(annot))
-                    {
-                        TelemetryTypePair types;
-
-                        types.annotatedType = toString(annot);
-                        types.inferredType = toString(head[std::min(local->values.size - 1, posn)]);
-
-                        TypeInfo ti{Pattern::VarAnnot, toString(ctxNode), types};
-                        typeInfo.push_back(ti);
-                    }
-                }
-            }
-            else
-            {
-                if (tail)
-                {
-                    if (containsAny(*tail))
-                    {
-                        TelemetryTypePair types;
-
-                        types.inferredType = toString(*tail);
-
-                        TypeInfo ti{Pattern::VarAny, toString(ctxNode), types};
-                        typeInfo.push_back(ti);
-                    }
-                }
-            }
-        }
-
-        ++posn;
-    }
-}
-
-void AnyTypeSummary::visit(const Scope* scope, AstStatFor* for_, const Module* module, NotNull<BuiltinTypes> builtinTypes)
-{
-    const Scope* forScope = findInnerMostScope(for_->location, module);
-    visit(forScope, for_->body, module, builtinTypes);
-}
-
-void AnyTypeSummary::visit(const Scope* scope, AstStatForIn* forIn, const Module* module, NotNull<BuiltinTypes> builtinTypes)
-{
-    const Scope* loopScope = findInnerMostScope(forIn->location, module);
-    visit(loopScope, forIn->body, module, builtinTypes);
-}
-
-void AnyTypeSummary::visit(const Scope* scope, AstStatAssign* assign, const Module* module, NotNull<BuiltinTypes> builtinTypes)
-{
-    auto ctxNode = getNode(rootSrc, assign);
-
-    TypePackId values = reconstructTypePack(assign->values, module, builtinTypes);
-    auto [head, tail] = flatten(values);
-
-    size_t posn = 0;
-    for (AstExpr* var : assign->vars)
-    {
-        TypeId tp = lookupType(var, module, builtinTypes);
-        if (containsAny(tp))
-        {
-            TelemetryTypePair types;
-
-            types.annotatedType = toString(tp);
-
-            auto loc = std::min(assign->vars.size - 1, posn);
-            if (head.size() >= assign->vars.size && posn < head.size())
-            {
-                types.inferredType = toString(head[posn]);
-            }
-            else if (loc < head.size())
-                types.inferredType = toString(head[loc]);
-            else
-                types.inferredType = toString(builtinTypes->nilType);
-
-            TypeInfo ti{Pattern::Assign, toString(ctxNode), types};
-            typeInfo.push_back(ti);
-        }
-        ++posn;
-    }
-
-    for (AstExpr* val : assign->values)
-    {
-        if (isAnyCall(scope, val, module, builtinTypes))
-        {
-            TelemetryTypePair types;
-
-            types.inferredType = toString(lookupType(val, module, builtinTypes));
-
-            TypeInfo ti{Pattern::FuncApp, toString(ctxNode), types};
-            typeInfo.push_back(ti);
-        }
-
-        if (isAnyCast(scope, val, module, builtinTypes))
-        {
-            if (auto cast = val->as<AstExprTypeAssertion>())
-            {
-                TelemetryTypePair types;
-
-                types.annotatedType = toString(lookupAnnotation(cast->annotation, module, builtinTypes));
-                types.inferredType = toString(lookupType(val, module, builtinTypes));
-
-                TypeInfo ti{Pattern::Casts, toString(ctxNode), types};
-                typeInfo.push_back(ti);
-            }
-        }
-    }
-
-    if (tail)
-    {
-        if (containsAny(*tail))
-        {
-            TelemetryTypePair types;
-
-            types.inferredType = toString(*tail);
-
-            TypeInfo ti{Pattern::Assign, toString(ctxNode), types};
-            typeInfo.push_back(ti);
-        }
-    }
-}
-
-void AnyTypeSummary::visit(const Scope* scope, AstStatCompoundAssign* assign, const Module* module, NotNull<BuiltinTypes> builtinTypes)
-{
-    auto ctxNode = getNode(rootSrc, assign);
-
-    TelemetryTypePair types;
-
-    types.inferredType = toString(lookupType(assign->value, module, builtinTypes));
-    types.annotatedType = toString(lookupType(assign->var, module, builtinTypes));
-
-    if (module->astTypes.contains(assign->var))
-    {
-        if (containsAny(*module->astTypes.find(assign->var)))
-        {
-            TypeInfo ti{Pattern::Assign, toString(ctxNode), types};
-            typeInfo.push_back(ti);
-        }
-    }
-    else if (module->astTypePacks.contains(assign->var))
-    {
-        if (containsAny(*module->astTypePacks.find(assign->var)))
-        {
-            TypeInfo ti{Pattern::Assign, toString(ctxNode), types};
-            typeInfo.push_back(ti);
-        }
-    }
-
-    if (isAnyCall(scope, assign->value, module, builtinTypes))
-    {
-        TypeInfo ti{Pattern::FuncApp, toString(ctxNode), types};
-        typeInfo.push_back(ti);
-    }
-
-    if (isAnyCast(scope, assign->value, module, builtinTypes))
-    {
-        if (auto cast = assign->value->as<AstExprTypeAssertion>())
-        {
-            types.annotatedType = toString(lookupAnnotation(cast->annotation, module, builtinTypes));
-            types.inferredType = toString(lookupType(cast->expr, module, builtinTypes));
-
-            TypeInfo ti{Pattern::Casts, toString(ctxNode), types};
-            typeInfo.push_back(ti);
-        }
-    }
-}
-
-void AnyTypeSummary::visit(const Scope* scope, AstStatFunction* function, const Module* module, NotNull<BuiltinTypes> builtinTypes)
-{
-    TelemetryTypePair types;
-    types.inferredType = toString(lookupType(function->func, module, builtinTypes));
-
-    if (hasVariadicAnys(scope, function->func, module, builtinTypes))
-    {
-        TypeInfo ti{Pattern::VarAny, toString(function), types};
-        typeInfo.push_back(ti);
-    }
-
-    if (hasArgAnys(scope, function->func, module, builtinTypes))
-    {
-        TypeInfo ti{Pattern::FuncArg, toString(function), types};
-        typeInfo.push_back(ti);
-    }
-
-    if (hasAnyReturns(scope, function->func, module, builtinTypes))
-    {
-        TypeInfo ti{Pattern::FuncRet, toString(function), types};
-        typeInfo.push_back(ti);
-    }
-
-    if (function->func->body->body.size > 0)
-        visit(scope, function->func->body, module, builtinTypes);
-}
-
-void AnyTypeSummary::visit(const Scope* scope, AstStatLocalFunction* function, const Module* module, NotNull<BuiltinTypes> builtinTypes)
-{
-    TelemetryTypePair types;
-
-    if (hasVariadicAnys(scope, function->func, module, builtinTypes))
-    {
-        types.inferredType = toString(lookupType(function->func, module, builtinTypes));
-        TypeInfo ti{Pattern::VarAny, toString(function), types};
-        typeInfo.push_back(ti);
-    }
-
-    if (hasArgAnys(scope, function->func, module, builtinTypes))
-    {
-        types.inferredType = toString(lookupType(function->func, module, builtinTypes));
-        TypeInfo ti{Pattern::FuncArg, toString(function), types};
-        typeInfo.push_back(ti);
-    }
-
-    if (hasAnyReturns(scope, function->func, module, builtinTypes))
-    {
-        types.inferredType = toString(lookupType(function->func, module, builtinTypes));
-        TypeInfo ti{Pattern::FuncRet, toString(function), types};
-        typeInfo.push_back(ti);
-    }
-
-    if (function->func->body->body.size > 0)
-        visit(scope, function->func->body, module, builtinTypes);
-}
-
-void AnyTypeSummary::visit(const Scope* scope, AstStatTypeAlias* alias, const Module* module, NotNull<BuiltinTypes> builtinTypes)
-{
-    auto ctxNode = getNode(rootSrc, alias);
-
-    auto annot = lookupAnnotation(alias->type, module, builtinTypes);
-    if (containsAny(annot))
-    {
-        // no expr => no inference for aliases
-        TelemetryTypePair types;
-
-        types.annotatedType = toString(annot);
-        TypeInfo ti{Pattern::Alias, toString(ctxNode), types};
-        typeInfo.push_back(ti);
-    }
-}
-
-void AnyTypeSummary::visit(const Scope* scope, AstStatExpr* expr, const Module* module, NotNull<BuiltinTypes> builtinTypes)
-{
-    auto ctxNode = getNode(rootSrc, expr);
-
-    if (isAnyCall(scope, expr->expr, module, builtinTypes))
-    {
-        TelemetryTypePair types;
-        types.inferredType = toString(lookupType(expr->expr, module, builtinTypes));
-
-        TypeInfo ti{Pattern::FuncApp, toString(ctxNode), types};
-        typeInfo.push_back(ti);
-    }
-}
-
-void AnyTypeSummary::visit(const Scope* scope, AstStatDeclareGlobal* declareGlobal, const Module* module, NotNull<BuiltinTypes> builtinTypes) {}
-
-void AnyTypeSummary::visit(const Scope* scope, AstStatDeclareClass* declareClass, const Module* module, NotNull<BuiltinTypes> builtinTypes) {}
-
-void AnyTypeSummary::visit(const Scope* scope, AstStatDeclareFunction* declareFunction, const Module* module, NotNull<BuiltinTypes> builtinTypes) {}
-
-void AnyTypeSummary::visit(const Scope* scope, AstStatError* error, const Module* module, NotNull<BuiltinTypes> builtinTypes) {}
-
-TypeId AnyTypeSummary::checkForFamilyInhabitance(const TypeId instance, const Location location)
-{
-    if (seenTypeFamilyInstances.find(instance))
-        return instance;
-
-    seenTypeFamilyInstances.insert(instance);
-    return instance;
-}
-
-TypeId AnyTypeSummary::lookupType(const AstExpr* expr, const Module* module, NotNull<BuiltinTypes> builtinTypes)
-{
-    const TypeId* ty = module->astTypes.find(expr);
-    if (ty)
-        return checkForFamilyInhabitance(follow(*ty), expr->location);
-
-    const TypePackId* tp = module->astTypePacks.find(expr);
-    if (tp)
-    {
-        if (auto fst = first(*tp, /*ignoreHiddenVariadics*/ false))
-            return checkForFamilyInhabitance(*fst, expr->location);
-        else if (finite(*tp) && size(*tp) == 0)
-            return checkForFamilyInhabitance(builtinTypes->nilType, expr->location);
-    }
-
-    return builtinTypes->errorRecoveryType();
-}
-
-TypePackId AnyTypeSummary::reconstructTypePack(AstArray<AstExpr*> exprs, const Module* module, NotNull<BuiltinTypes> builtinTypes)
-{
-    if (exprs.size == 0)
-        return arena.addTypePack(TypePack{{}, std::nullopt});
-
-    std::vector<TypeId> head;
-
-    for (size_t i = 0; i < exprs.size - 1; ++i)
-    {
-        head.push_back(lookupType(exprs.data[i], module, builtinTypes));
-    }
-
-    const TypePackId* tail = module->astTypePacks.find(exprs.data[exprs.size - 1]);
-    if (tail)
-        return arena.addTypePack(TypePack{std::move(head), follow(*tail)});
-    else
-        return arena.addTypePack(TypePack{std::move(head), builtinTypes->errorRecoveryTypePack()});
-}
-
-bool AnyTypeSummary::isAnyCall(const Scope* scope, AstExpr* expr, const Module* module, NotNull<BuiltinTypes> builtinTypes)
-{
-    if (auto call = expr->as<AstExprCall>())
-    {
-        TypePackId args = reconstructTypePack(call->args, module, builtinTypes);
-        if (containsAny(args))
-            return true;
-
-        TypeId func = lookupType(call->func, module, builtinTypes);
-        if (containsAny(func))
-            return true;
-    }
-    return false;
-}
-
-bool AnyTypeSummary::hasVariadicAnys(const Scope* scope, AstExprFunction* expr, const Module* module, NotNull<BuiltinTypes> builtinTypes)
-{
-    if (expr->vararg && expr->varargAnnotation)
-    {
-        auto annot = lookupPackAnnotation(expr->varargAnnotation, module);
-        if (annot && containsAny(*annot))
-        {
-            return true;
-        }
-    }
-    return false;
-}
-
-bool AnyTypeSummary::hasArgAnys(const Scope* scope, AstExprFunction* expr, const Module* module, NotNull<BuiltinTypes> builtinTypes)
-{
-    if (expr->args.size > 0)
-    {
-        for (const AstLocal* arg : expr->args)
-        {
-            if (arg->annotation)
-            {
-                auto annot = lookupAnnotation(arg->annotation, module, builtinTypes);
-                if (containsAny(annot))
-                {
-                    return true;
-                }
-            }
-        }
-    }
-    return false;
-}
-
-bool AnyTypeSummary::hasAnyReturns(const Scope* scope, AstExprFunction* expr, const Module* module, NotNull<BuiltinTypes> builtinTypes)
-{
-    if (!expr->returnAnnotation)
-    {
-        return false;
-    }
-
-    for (AstType* ret : expr->returnAnnotation->types)
-    {
-        if (containsAny(lookupAnnotation(ret, module, builtinTypes)))
-        {
-            return true;
-        }
-    }
-
-    if (expr->returnAnnotation->tailType)
-    {
-        auto annot = lookupPackAnnotation(expr->returnAnnotation->tailType, module);
-        if (annot && containsAny(*annot))
-        {
-            return true;
-        }
-    }
-
-    return false;
-}
-
-bool AnyTypeSummary::isAnyCast(const Scope* scope, AstExpr* expr, const Module* module, NotNull<BuiltinTypes> builtinTypes)
-{
-    if (auto cast = expr->as<AstExprTypeAssertion>())
-    {
-        auto annot = lookupAnnotation(cast->annotation, module, builtinTypes);
-        if (containsAny(annot))
-        {
-            return true;
-        }
-    }
-    return false;
-}
-
-TypeId AnyTypeSummary::lookupAnnotation(AstType* annotation, const Module* module, NotNull<BuiltinTypes> builtintypes)
-{
-    if (FFlag::DebugLuauMagicTypes)
-    {
-        if (auto ref = annotation->as<AstTypeReference>(); ref && ref->parameters.size > 0)
-        {
-            if (auto ann = ref->parameters.data[0].type)
-            {
-                TypeId argTy = lookupAnnotation(ref->parameters.data[0].type, module, builtintypes);
-                return follow(argTy);
-            }
-        }
-    }
-
-    const TypeId* ty = module->astResolvedTypes.find(annotation);
-    if (ty)
-        return checkForTypeFunctionInhabitance(follow(*ty), annotation->location);
-    else
-        return checkForTypeFunctionInhabitance(builtintypes->errorRecoveryType(), annotation->location);
-}
-
-TypeId AnyTypeSummary::checkForTypeFunctionInhabitance(const TypeId instance, const Location location)
-{
-    if (seenTypeFunctionInstances.find(instance))
-        return instance;
-    seenTypeFunctionInstances.insert(instance);
-
-    return instance;
-}
-
-std::optional<TypePackId> AnyTypeSummary::lookupPackAnnotation(AstTypePack* annotation, const Module* module)
-{
-    const TypePackId* tp = module->astResolvedTypePacks.find(annotation);
-    if (tp != nullptr)
-        return {follow(*tp)};
-    return {};
-}
-
-bool AnyTypeSummary::containsAny(TypeId typ)
-{
-    typ = follow(typ);
-
-    if (auto t = seen.find(typ); t && !*t)
-    {
-        return false;
-    }
-
-    seen[typ] = false;
-
-    RecursionCounter counter{&recursionCount};
-    if (recursionCount >= FInt::LuauAnySummaryRecursionLimit)
-    {
-        return false;
-    }
-
-    bool found = false;
-
-    if (auto ty = get<AnyType>(typ))
-    {
-        found = true;
-    }
-    else if (auto ty = get<UnknownType>(typ))
-    {
-        found = true;
-    }
-    else if (auto ty = get<TableType>(typ))
-    {
-        for (auto& [_name, prop] : ty->props)
-        {
-            if (FFlag::LuauSolverV2)
-            {
-                if (auto newT = follow(prop.readTy))
-                {
-                    if (containsAny(*newT))
-                        found = true;
-                }
-                else if (auto newT = follow(prop.writeTy))
-                {
-                    if (containsAny(*newT))
-                        found = true;
-                }
-            }
-            else
-            {
-                if (containsAny(prop.type()))
-                    found = true;
-            }
-        }
-    }
-    else if (auto ty = get<IntersectionType>(typ))
-    {
-        for (auto part : ty->parts)
-        {
-            if (containsAny(part))
-            {
-                found = true;
-            }
-        }
-    }
-    else if (auto ty = get<UnionType>(typ))
-    {
-        for (auto option : ty->options)
-        {
-            if (containsAny(option))
-            {
-                found = true;
-            }
-        }
-    }
-    else if (auto ty = get<FunctionType>(typ))
-    {
-        if (containsAny(ty->argTypes))
-            found = true;
-        else if (containsAny(ty->retTypes))
-            found = true;
-    }
-
-    seen[typ] = found;
-
-    return found;
-}
-
-bool AnyTypeSummary::containsAny(TypePackId typ)
-{
-    typ = follow(typ);
-
-    if (auto t = seen.find(typ); t && !*t)
-    {
-        return false;
-    }
-
-    seen[typ] = false;
-
-    auto [head, tail] = flatten(typ);
-    bool found = false;
-
-    for (auto tp : head)
-    {
-        if (containsAny(tp))
-            found = true;
-    }
-
-    if (tail)
-    {
-        if (auto vtp = get<VariadicTypePack>(tail))
-        {
-            if (auto ty = get<AnyType>(follow(vtp->ty)))
-            {
-                found = true;
-            }
-        }
-        else if (auto tftp = get<TypeFunctionInstanceTypePack>(tail))
-        {
-
-            for (TypePackId tp : tftp->packArguments)
-            {
-                if (containsAny(tp))
-                {
-                    found = true;
-                }
-            }
-
-            for (TypeId t : tftp->typeArguments)
-            {
-                if (containsAny(t))
-                {
-                    found = true;
-                }
-            }
-        }
-    }
-
-    seen[typ] = found;
-
-    return found;
-}
-
-const Scope* AnyTypeSummary::findInnerMostScope(const Location location, const Module* module)
-{
-    const Scope* bestScope = module->getModuleScope().get();
-
-    bool didNarrow = false;
-    do
-    {
-        didNarrow = false;
-        for (auto scope : bestScope->children)
-        {
-            if (scope->location.encloses(location))
-            {
-                bestScope = scope.get();
-                didNarrow = true;
-                break;
-            }
-        }
-    } while (didNarrow && bestScope->children.size() > 0);
-
-    return bestScope;
-}
-
-std::optional<AstExpr*> AnyTypeSummary::matchRequire(const AstExprCall& call)
-{
-    const char* require = "require";
-
-    if (call.args.size != 1)
-        return std::nullopt;
-
-    const AstExprGlobal* funcAsGlobal = call.func->as<AstExprGlobal>();
-    if (!funcAsGlobal || funcAsGlobal->name != require)
-        return std::nullopt;
-
-    if (call.args.size != 1)
-        return std::nullopt;
-
-    return call.args.data[0];
-}
-
-AstNode* AnyTypeSummary::getNode(AstStatBlock* root, AstNode* node)
-{
-    FindReturnAncestry finder(node, root->location.end);
-    root->visit(&finder);
-
-    if (!finder.currNode)
-        finder.currNode = node;
-
-    LUAU_ASSERT(finder.found && finder.currNode);
-    return finder.currNode;
-}
-
-bool AnyTypeSummary::FindReturnAncestry::visit(AstStatLocalFunction* node)
-{
-    currNode = node;
-    return !found;
-}
-
-bool AnyTypeSummary::FindReturnAncestry::visit(AstStatFunction* node)
-{
-    currNode = node;
-    return !found;
-}
-
-bool AnyTypeSummary::FindReturnAncestry::visit(AstType* node)
-{
-    return !found;
-}
-
-bool AnyTypeSummary::FindReturnAncestry::visit(AstNode* node)
-{
-    if (node == stat)
-    {
-        found = true;
-    }
-
-    if (node->location.end == rootEnd && stat->location.end >= rootEnd)
-    {
-        currNode = node;
-        found = true;
-    }
-
-    return !found;
-}
-
-
-AnyTypeSummary::TypeInfo::TypeInfo(Pattern code, std::string node, TelemetryTypePair type)
-    : code(code)
-    , node(node)
-    , type(type)
-{
-}
-
-AnyTypeSummary::FindReturnAncestry::FindReturnAncestry(AstNode* stat, Position rootEnd)
-    : stat(stat)
-    , rootEnd(rootEnd)
-{
-}
-
-AnyTypeSummary::AnyTypeSummary() {}
-
-} // namespace Luau

Analysis/src/Anyification.cpp

@@ -88,7 +88,7 @@ TypePackId Anyification::clean(TypePackId tp)
 
 bool Anyification::ignoreChildren(TypeId ty)
 {
-    if (get<ClassType>(ty))
+    if (get<ExternType>(ty))
         return true;
 
     return ty->persistent;

Analysis/src/ApplyTypeFunction.cpp

@@ -31,7 +31,7 @@ bool ApplyTypeFunction::ignoreChildren(TypeId ty)
 {
     if (get<GenericType>(ty))
         return true;
-    else if (get<ClassType>(ty))
+    else if (get<ExternType>(ty))
         return true;
     else
         return false;

Analysis/src/AstJsonEncoder.cpp

@@ -8,6 +8,8 @@
 
 #include <math.h>
 
+LUAU_FASTFLAG(LuauStoreReturnTypesAsPackOnAst)
+
 namespace Luau
 {
 
@@ -431,8 +433,16 @@ struct AstJsonEncoder : public AstVisitor
                 if (node->self)
                     PROP(self);
                 PROP(args);
-                if (node->returnAnnotation)
-                    PROP(returnAnnotation);
+                if (FFlag::LuauStoreReturnTypesAsPackOnAst)
+                {
+                    if (node->returnAnnotation)
+                        PROP(returnAnnotation);
+                }
+                else
+                {
+                    if (node->returnAnnotation_DEPRECATED)
+                        write("returnAnnotation", node->returnAnnotation_DEPRECATED);
+                }
                 PROP(vararg);
                 PROP(varargLocation);
                 if (node->varargAnnotation)
@@ -465,26 +475,26 @@ struct AstJsonEncoder : public AstVisitor
         writeRaw("}");
     }
 
-    void write(const AstGenericType& genericType)
+    void write(class AstGenericType* genericType)
     {
         writeRaw("{");
         bool c = pushComma();
         writeType("AstGenericType");
-        write("name", genericType.name);
-        if (genericType.defaultValue)
-            write("luauType", genericType.defaultValue);
+        write("name", genericType->name);
+        if (genericType->defaultValue)
+            write("luauType", genericType->defaultValue);
         popComma(c);
         writeRaw("}");
     }
 
-    void write(const AstGenericTypePack& genericTypePack)
+    void write(class AstGenericTypePack* genericTypePack)
     {
         writeRaw("{");
         bool c = pushComma();
         writeType("AstGenericTypePack");
-        write("name", genericTypePack.name);
-        if (genericTypePack.defaultValue)
-            write("luauType", genericTypePack.defaultValue);
+        write("name", genericTypePack->name);
+        if (genericTypePack->defaultValue)
+            write("luauType", genericTypePack->defaultValue);
         popComma(c);
         writeRaw("}");
     }
@@ -902,7 +912,10 @@ struct AstJsonEncoder : public AstVisitor
                 PROP(paramNames);
                 PROP(vararg);
                 PROP(varargLocation);
-                PROP(retTypes);
+                if (FFlag::LuauStoreReturnTypesAsPackOnAst)
+                    PROP(retTypes);
+                else
+                    write("retTypes", node->retTypes_DEPRECATED);
                 PROP(generics);
                 PROP(genericPacks);
             }
@@ -923,7 +936,7 @@ struct AstJsonEncoder : public AstVisitor
         );
     }
 
-    void write(const AstDeclaredClassProp& prop)
+    void write(const AstDeclaredExternTypeProperty& prop)
     {
         writeRaw("{");
         bool c = pushComma();
@@ -936,7 +949,7 @@ struct AstJsonEncoder : public AstVisitor
         writeRaw("}");
     }
 
-    void write(class AstStatDeclareClass* node)
+    void write(class AstStatDeclareExternType* node)
     {
         writeNode(
             node,
@@ -1048,7 +1061,10 @@ struct AstJsonEncoder : public AstVisitor
                 PROP(genericPacks);
                 PROP(argTypes);
                 PROP(argNames);
-                PROP(returnTypes);
+                if (FFlag::LuauStoreReturnTypesAsPackOnAst)
+                    PROP(returnTypes);
+                else
+                    write("returnTypes", node->returnTypes_DEPRECATED);
             }
         );
     }
@@ -1065,6 +1081,11 @@ struct AstJsonEncoder : public AstVisitor
         );
     }
 
+    void write(class AstTypeOptional* node)
+    {
+        writeNode(node, "AstTypeOptional", [&]() {});
+    }
+
     void write(class AstTypeUnion* node)
     {
         writeNode(
@@ -1146,6 +1167,8 @@ struct AstJsonEncoder : public AstVisitor
             return writeString("checked");
         case AstAttr::Type::Native:
             return writeString("native");
+        case AstAttr::Type::Deprecated:
+            return writeString("deprecated");
         }
     }
 
@@ -1422,7 +1445,7 @@ struct AstJsonEncoder : public AstVisitor
         return false;
     }
 
-    bool visit(class AstStatDeclareClass* node) override
+    bool visit(class AstStatDeclareExternType* node) override
     {
         write(node);
         return false;

Analysis/src/AstQuery.cpp

@@ -13,8 +13,6 @@
 
 LUAU_FASTFLAG(LuauSolverV2)
 
-LUAU_FASTFLAG(LuauExtendStatEndPosWithSemicolon)
-
 namespace Luau
 {
 
@@ -43,24 +41,13 @@ struct AutocompleteNodeFinder : public AstVisitor
 
     bool visit(AstStat* stat) override
     {
-        if (FFlag::LuauExtendStatEndPosWithSemicolon)
+        // Consider 'local myLocal = 4;|' and 'local myLocal = 4', where '|' is the cursor position. In both cases, the cursor position is equal
+        // to `AstStatLocal.location.end`. However, in the first case (semicolon), we are starting a new statement, whilst in the second case
+        // (no semicolon) we are still part of the AstStatLocal, hence the different comparison check.
+        if (stat->location.begin < pos && (stat->hasSemicolon ? pos < stat->location.end : pos <= stat->location.end))
         {
-            // Consider 'local myLocal = 4;|' and 'local myLocal = 4', where '|' is the cursor position. In both cases, the cursor position is equal
-            // to `AstStatLocal.location.end`. However, in the first case (semicolon), we are starting a new statement, whilst in the second case
-            // (no semicolon) we are still part of the AstStatLocal, hence the different comparison check.
-            if (stat->location.begin < pos && (stat->hasSemicolon ? pos < stat->location.end : pos <= stat->location.end))
-            {
-                ancestry.push_back(stat);
-                return true;
-            }
-        }
-        else
-        {
-            if (stat->location.begin < pos && pos <= stat->location.end)
-            {
-                ancestry.push_back(stat);
-                return true;
-            }
+            ancestry.push_back(stat);
+            return true;
         }
 
         return false;
@@ -587,11 +574,11 @@ std::optional<DocumentationSymbol> getDocumentationSymbolAtPosition(const Source
                             return checkOverloadedDocumentationSymbol(module, propIt->second.type(), parentExpr, propIt->second.documentationSymbol);
                     }
                 }
-                else if (const ClassType* ctv = get<ClassType>(parentTy))
+                else if (const ExternType* etv = get<ExternType>(parentTy))
                 {
-                    while (ctv)
+                    while (etv)
                     {
-                        if (auto propIt = ctv->props.find(indexName->index.value); propIt != ctv->props.end())
+                        if (auto propIt = etv->props.find(indexName->index.value); propIt != etv->props.end())
                         {
                             if (FFlag::LuauSolverV2)
                             {
@@ -603,7 +590,7 @@ std::optional<DocumentationSymbol> getDocumentationSymbolAtPosition(const Source
                                     module, propIt->second.type(), parentExpr, propIt->second.documentationSymbol
                                 );
                         }
-                        ctv = ctv->parent ? Luau::get<Luau::ClassType>(*ctv->parent) : nullptr;
+                        etv = etv->parent ? Luau::get<Luau::ExternType>(*etv->parent) : nullptr;
                     }
                 }
                 else if (const PrimitiveType* ptv = get<PrimitiveType>(parentTy); ptv && ptv->metatable)

Analysis/src/AutocompleteCore.cpp

@@ -23,10 +23,11 @@
 LUAU_FASTFLAG(LuauSolverV2)
 LUAU_FASTINT(LuauTypeInferIterationLimit)
 LUAU_FASTINT(LuauTypeInferRecursionLimit)
-
-LUAU_FASTFLAGVARIABLE(LuauAutocompleteRefactorsForIncrementalAutocomplete)
-
+LUAU_FASTFLAGVARIABLE(DebugLuauMagicVariableNames)
 LUAU_FASTFLAGVARIABLE(LuauAutocompleteUsesModuleForTypeCompatibility)
+LUAU_FASTFLAGVARIABLE(LuauAutocompleteUnionCopyPreviousSeen)
+LUAU_FASTFLAGVARIABLE(LuauAutocompleteMissingFollows)
+LUAU_FASTFLAG(LuauStoreReturnTypesAsPackOnAst)
 
 static const std::unordered_set<std::string> kStatementStartingKeywords =
     {"while", "if", "local", "repeat", "function", "do", "for", "return", "break", "continue", "type", "export"};
@@ -79,6 +80,8 @@ static ParenthesesRecommendation getParenRecommendationForIntersect(const Inters
     ParenthesesRecommendation rec = ParenthesesRecommendation::None;
     for (Luau::TypeId partId : intersect->parts)
     {
+        if (FFlag::LuauAutocompleteMissingFollows)
+            partId = follow(partId);
         if (auto partFunc = Luau::get<FunctionType>(partId))
         {
             rec = std::max(rec, getParenRecommendationForFunc(partFunc, nodes));
@@ -304,7 +307,7 @@ static void autocompleteProps(
     const std::vector<AstNode*>& nodes,
     AutocompleteEntryMap& result,
     std::unordered_set<TypeId>& seen,
-    std::optional<const ClassType*> containingClass = std::nullopt
+    std::optional<const ExternType*> containingExternType = std::nullopt
 )
 {
     rootTy = follow(rootTy);
@@ -327,8 +330,8 @@ static void autocompleteProps(
             if (calledWithSelf == ftv->hasSelf)
                 return true;
 
-            // Calls on classes require strict match between how function is declared and how it's called
-            if (get<ClassType>(rootTy))
+            // Calls on extern types require strict match between how function is declared and how it's called
+            if (get<ExternType>(rootTy))
                 return false;
 
             // When called with ':', but declared without 'self', it is invalid if a function has incompatible first argument or no arguments at all
@@ -361,7 +364,7 @@ static void autocompleteProps(
         return calledWithSelf;
     };
 
-    auto fillProps = [&](const ClassType::Props& props)
+    auto fillProps = [&](const ExternType::Props& props)
     {
         for (const auto& [name, prop] : props)
         {
@@ -394,7 +397,7 @@ static void autocompleteProps(
                     prop.deprecated,
                     isWrongIndexer(type),
                     typeCorrect,
-                    containingClass,
+                    containingExternType,
                     &prop,
                     prop.documentationSymbol,
                     {},
@@ -425,12 +428,12 @@ static void autocompleteProps(
         }
     };
 
-    if (auto cls = get<ClassType>(ty))
+    if (auto cls = get<ExternType>(ty))
     {
-        containingClass = containingClass.value_or(cls);
+        containingExternType = containingExternType.value_or(cls);
         fillProps(cls->props);
         if (cls->parent)
-            autocompleteProps(module, typeArena, builtinTypes, rootTy, *cls->parent, indexType, nodes, result, seen, containingClass);
+            autocompleteProps(module, typeArena, builtinTypes, rootTy, *cls->parent, indexType, nodes, result, seen, containingExternType);
     }
     else if (auto tbl = get<TableType>(ty))
         fillProps(tbl->props);
@@ -481,6 +484,21 @@ static void autocompleteProps(
             AutocompleteEntryMap inner;
             std::unordered_set<TypeId> innerSeen;
 
+            // If we don't do this, and we have the misfortune of receiving a
+            // recursive union like:
+            //
+            //  t1 where t1 = t1 | ExternType
+            //
+            // Then we are on a one way journey to a stack overflow.
+            if (FFlag::LuauAutocompleteUnionCopyPreviousSeen)
+            {
+                for (auto ty : seen)
+                {
+                    if (is<UnionType, IntersectionType>(ty))
+                        innerSeen.insert(ty);
+                }
+            }
+
             if (isNil(*iter))
             {
                 ++iter;
@@ -569,7 +587,7 @@ AutocompleteEntryMap autocompleteProps(
 AutocompleteEntryMap autocompleteModuleTypes(const Module& module, const ScopePtr& scopeAtPosition, Position position, std::string_view moduleName)
 {
     AutocompleteEntryMap result;
-    ScopePtr startScope = FFlag::LuauAutocompleteRefactorsForIncrementalAutocomplete ? scopeAtPosition : findScopeAtPosition(module, position);
+    ScopePtr startScope = scopeAtPosition;
     for (ScopePtr& scope = startScope; scope; scope = scope->parent)
     {
         if (auto it = scope->importedTypeBindings.find(std::string(moduleName)); it != scope->importedTypeBindings.end())
@@ -681,6 +699,30 @@ static std::optional<TypeId> findTypeElementAt(const AstTypeList& astTypeList, T
     return {};
 }
 
+static std::optional<TypeId> findTypeElementAt(AstTypePack* astTypePack, TypePackId tp, Position position)
+{
+    LUAU_ASSERT(FFlag::LuauStoreReturnTypesAsPackOnAst);
+    if (const auto typePack = astTypePack->as<AstTypePackExplicit>())
+    {
+        return findTypeElementAt(typePack->typeList, tp, position);
+    }
+    else if (const auto variadic = astTypePack->as<AstTypePackVariadic>())
+    {
+        if (variadic->location.containsClosed(position))
+        {
+            auto [_, tail] = flatten(tp);
+
+            if (tail)
+            {
+                if (const VariadicTypePack* vtp = get<VariadicTypePack>(follow(*tail)))
+                    return findTypeElementAt(variadic->variadicType, vtp->ty, position);
+            }
+        }
+    }
+
+    return {};
+}
+
 static std::optional<TypeId> findTypeElementAt(AstType* astType, TypeId ty, Position position)
 {
     ty = follow(ty);
@@ -701,8 +743,16 @@ static std::optional<TypeId> findTypeElementAt(AstType* astType, TypeId ty, Posi
         if (auto element = findTypeElementAt(type->argTypes, ftv->argTypes, position))
             return element;
 
-        if (auto element = findTypeElementAt(type->returnTypes, ftv->retTypes, position))
-            return element;
+        if (FFlag::LuauStoreReturnTypesAsPackOnAst)
+        {
+            if (auto element = findTypeElementAt(type->returnTypes, ftv->retTypes, position))
+                return element;
+        }
+        else
+        {
+            if (auto element = findTypeElementAt(type->returnTypes_DEPRECATED, ftv->retTypes, position))
+                return element;
+        }
     }
 
     // It's possible to walk through other types like intrsection and unions if we find value in doing that
@@ -711,7 +761,7 @@ static std::optional<TypeId> findTypeElementAt(AstType* astType, TypeId ty, Posi
 
 std::optional<TypeId> getLocalTypeInScopeAt(const Module& module, const ScopePtr& scopeAtPosition, Position position, AstLocal* local)
 {
-    if (ScopePtr scope = FFlag::LuauAutocompleteRefactorsForIncrementalAutocomplete ? scopeAtPosition : findScopeAtPosition(module, position))
+    if (ScopePtr scope = scopeAtPosition)
     {
         for (const auto& [name, binding] : scope->bindings)
         {
@@ -853,7 +903,7 @@ AutocompleteEntryMap autocompleteTypeNames(
 {
     AutocompleteEntryMap result;
 
-    ScopePtr startScope = FFlag::LuauAutocompleteRefactorsForIncrementalAutocomplete ? scopeAtPosition : findScopeAtPosition(module, position);
+    ScopePtr startScope = scopeAtPosition;
 
     for (ScopePtr scope = startScope; scope; scope = scope->parent)
     {
@@ -1032,29 +1082,46 @@ AutocompleteEntryMap autocompleteTypeNames(
             }
         }
 
-        if (!node->returnAnnotation)
-            return result;
-
-        for (size_t i = 0; i < node->returnAnnotation->types.size; i++)
+        if (FFlag::LuauStoreReturnTypesAsPackOnAst)
         {
-            AstType* ret = node->returnAnnotation->types.data[i];
+            if (!node->returnAnnotation)
+                return result;
 
-            if (ret->location.containsClosed(position))
+            if (const auto typePack = node->returnAnnotation->as<AstTypePackExplicit>())
             {
-                if (const FunctionType* ftv = tryGetExpectedFunctionType(module, node))
+                for (size_t i = 0; i < typePack->typeList.types.size; i++)
                 {
-                    if (auto ty = tryGetTypePackTypeAt(ftv->retTypes, i))
-                        tryAddTypeCorrectSuggestion(result, startScope, topType, *ty, position);
+                    AstType* ret = typePack->typeList.types.data[i];
+
+                    if (ret->location.containsClosed(position))
+                    {
+                        if (const FunctionType* ftv = tryGetExpectedFunctionType(module, node))
+                        {
+                            if (auto ty = tryGetTypePackTypeAt(ftv->retTypes, i))
+                                tryAddTypeCorrectSuggestion(result, startScope, topType, *ty, position);
+                        }
+
+                        // TODO: with additional type information, we could suggest inferred return type here
+                        break;
+                    }
                 }
 
-                // TODO: with additional type information, we could suggest inferred return type here
-                break;
+                if (AstTypePack* retTp = typePack->typeList.tailType)
+                {
+                    if (auto variadic = retTp->as<AstTypePackVariadic>())
+                    {
+                        if (variadic->location.containsClosed(position))
+                        {
+                            if (const FunctionType* ftv = tryGetExpectedFunctionType(module, node))
+                            {
+                                if (auto ty = tryGetTypePackTypeAt(ftv->retTypes, ~0u))
+                                    tryAddTypeCorrectSuggestion(result, startScope, topType, *ty, position);
+                            }
+                        }
+                    }
+                }
             }
-        }
-
-        if (AstTypePack* retTp = node->returnAnnotation->tailType)
-        {
-            if (auto variadic = retTp->as<AstTypePackVariadic>())
+            else if (auto variadic = node->returnAnnotation->as<AstTypePackVariadic>())
             {
                 if (variadic->location.containsClosed(position))
                 {
@@ -1066,6 +1133,43 @@ AutocompleteEntryMap autocompleteTypeNames(
                 }
             }
         }
+        else
+        {
+            if (!node->returnAnnotation_DEPRECATED)
+                return result;
+
+            for (size_t i = 0; i < node->returnAnnotation_DEPRECATED->types.size; i++)
+            {
+                AstType* ret = node->returnAnnotation_DEPRECATED->types.data[i];
+
+                if (ret->location.containsClosed(position))
+                {
+                    if (const FunctionType* ftv = tryGetExpectedFunctionType(module, node))
+                    {
+                        if (auto ty = tryGetTypePackTypeAt(ftv->retTypes, i))
+                            tryAddTypeCorrectSuggestion(result, startScope, topType, *ty, position);
+                    }
+
+                    // TODO: with additional type information, we could suggest inferred return type here
+                    break;
+                }
+            }
+
+            if (AstTypePack* retTp = node->returnAnnotation_DEPRECATED->tailType)
+            {
+                if (auto variadic = retTp->as<AstTypePackVariadic>())
+                {
+                    if (variadic->location.containsClosed(position))
+                    {
+                        if (const FunctionType* ftv = tryGetExpectedFunctionType(module, node))
+                        {
+                            if (auto ty = tryGetTypePackTypeAt(ftv->retTypes, ~0u))
+                                tryAddTypeCorrectSuggestion(result, startScope, topType, *ty, position);
+                        }
+                    }
+                }
+            }
+        }
     }
 
     return result;
@@ -1186,7 +1290,7 @@ static AutocompleteEntryMap autocompleteStatement(
 )
 {
     // This is inefficient. :(
-    ScopePtr scope = FFlag::LuauAutocompleteRefactorsForIncrementalAutocomplete ? scopeAtPosition : findScopeAtPosition(module, position);
+    ScopePtr scope = scopeAtPosition;
 
     AutocompleteEntryMap result;
 
@@ -1343,6 +1447,15 @@ static AutocompleteContext autocompleteExpression(
 
     AstNode* node = ancestry.rbegin()[0];
 
+    if (FFlag::DebugLuauMagicVariableNames)
+    {
+        InternalErrorReporter ice;
+        if (auto local = node->as<AstExprLocal>(); local && local->local->name == "_luau_autocomplete_ice")
+            ice.ice("_luau_autocomplete_ice encountered", local->location);
+        if (auto global = node->as<AstExprGlobal>(); global && global->name == "_luau_autocomplete_ice")
+            ice.ice("_luau_autocomplete_ice encountered", global->location);
+    }
+
     if (node->is<AstExprIndexName>())
     {
         if (auto it = module.astTypes.find(node->asExpr()))
@@ -1355,7 +1468,7 @@ static AutocompleteContext autocompleteExpression(
     else
     {
         // This is inefficient. :(
-        ScopePtr scope = FFlag::LuauAutocompleteRefactorsForIncrementalAutocomplete ? scopeAtPosition : findScopeAtPosition(module, position);
+        ScopePtr scope = scopeAtPosition;
 
         while (scope)
         {
@@ -1424,7 +1537,7 @@ static AutocompleteResult autocompleteExpression(
     return {result, ancestry, context};
 }
 
-static std::optional<const ClassType*> getMethodContainingClass(const ModulePtr& module, AstExpr* funcExpr)
+static std::optional<const ExternType*> getMethodContainingExternType(const ModulePtr& module, AstExpr* funcExpr)
 {
     AstExpr* parentExpr = nullptr;
     if (auto indexName = funcExpr->as<AstExprIndexName>())
@@ -1448,14 +1561,14 @@ static std::optional<const ClassType*> getMethodContainingClass(const ModulePtr&
 
     Luau::TypeId parentType = Luau::follow(*parentIt);
 
-    if (auto parentClass = Luau::get<ClassType>(parentType))
+    if (auto parentExternType = Luau::get<ExternType>(parentType))
     {
-        return parentClass;
+        return parentExternType;
     }
 
     if (auto parentUnion = Luau::get<UnionType>(parentType))
     {
-        return returnFirstNonnullOptionOfType<ClassType>(parentUnion);
+        return returnFirstNonnullOptionOfType<ExternType>(parentUnion);
     }
 
     return std::nullopt;
@@ -1509,10 +1622,11 @@ static std::optional<AutocompleteEntryMap> convertRequireSuggestionsToAutocomple
         return std::nullopt;
 
     AutocompleteEntryMap result;
-    for (const RequireSuggestion& suggestion : *suggestions)
+    for (RequireSuggestion& suggestion : *suggestions)
     {
         AutocompleteEntry entry = {AutocompleteEntryKind::RequirePath};
         entry.insertText = std::move(suggestion.fullPath);
+        entry.tags = std::move(suggestion.tags);
         result[std::move(suggestion.label)] = std::move(entry);
     }
     return result;
@@ -1573,7 +1687,7 @@ static std::optional<AutocompleteEntryMap> autocompleteStringParams(
             {
                 return convertRequireSuggestionsToAutocompleteEntryMap(fileResolver->getRequireSuggestions(module->name, candidateString));
             }
-            if (std::optional<AutocompleteEntryMap> ret = callback(tag, getMethodContainingClass(module, candidate->func), candidateString))
+            if (std::optional<AutocompleteEntryMap> ret = callback(tag, getMethodContainingExternType(module, candidate->func), candidateString))
             {
                 return ret;
             }
@@ -1591,6 +1705,8 @@ static std::optional<AutocompleteEntryMap> autocompleteStringParams(
     {
         for (TypeId part : intersect->parts)
         {
+            if (FFlag::LuauAutocompleteMissingFollows)
+                part = follow(part);
             if (auto candidateFunctionType = Luau::get<FunctionType>(part))
             {
                 if (std::optional<AutocompleteEntryMap> ret = performCallback(candidateFunctionType))
@@ -1739,7 +1855,7 @@ static std::optional<AutocompleteEntry> makeAnonymousAutofilled(
     if (!type)
         return std::nullopt;
 
-    const ScopePtr scope = FFlag::LuauAutocompleteRefactorsForIncrementalAutocomplete ? scopeAtPosition : findScopeAtPosition(*module, position);
+    const ScopePtr scope = scopeAtPosition;
     if (!scope)
         return std::nullopt;
 

Analysis/src/BuiltinDefinitions.cpp

@@ -3,22 +3,23 @@
 
 #include "Luau/Ast.h"
 #include "Luau/Clone.h"
+#include "Luau/Common.h"
+#include "Luau/ConstraintGenerator.h"
+#include "Luau/ConstraintSolver.h"
 #include "Luau/DenseHash.h"
 #include "Luau/Error.h"
 #include "Luau/Frontend.h"
-#include "Luau/Symbol.h"
-#include "Luau/Common.h"
-#include "Luau/ToString.h"
-#include "Luau/ConstraintSolver.h"
-#include "Luau/ConstraintGenerator.h"
+#include "Luau/InferPolarity.h"
 #include "Luau/NotNull.h"
-#include "Luau/TypeInfer.h"
+#include "Luau/Subtyping.h"
+#include "Luau/Symbol.h"
+#include "Luau/ToString.h"
+#include "Luau/Type.h"
 #include "Luau/TypeChecker2.h"
 #include "Luau/TypeFunction.h"
+#include "Luau/TypeInfer.h"
 #include "Luau/TypePack.h"
-#include "Luau/Type.h"
 #include "Luau/TypeUtils.h"
-#include "Luau/Subtyping.h"
 
 #include <algorithm>
 
@@ -29,11 +30,11 @@
  */
 
 LUAU_FASTFLAG(LuauSolverV2)
-LUAU_FASTFLAGVARIABLE(LuauStringFormatErrorSuppression)
+LUAU_FASTFLAG(LuauNonReentrantGeneralization2)
 LUAU_FASTFLAGVARIABLE(LuauTableCloneClonesType3)
-LUAU_FASTFLAG(LuauTrackInteriorFreeTypesOnScope)
-LUAU_FASTFLAGVARIABLE(LuauFreezeIgnorePersistent)
-LUAU_FASTFLAGVARIABLE(LuauFollowTableFreeze)
+LUAU_FASTFLAGVARIABLE(LuauUserTypeFunTypecheck)
+LUAU_FASTFLAGVARIABLE(LuauMagicFreezeCheckBlocked)
+LUAU_FASTFLAGVARIABLE(LuauFormatUseLastPosition)
 
 namespace Luau
 {
@@ -247,6 +248,7 @@ void addGlobalBinding(GlobalTypes& globals, const ScopePtr& scope, const std::st
 
 void addGlobalBinding(GlobalTypes& globals, const ScopePtr& scope, const std::string& name, Binding binding)
 {
+    inferGenericPolarities(NotNull{&globals.globalTypes}, NotNull{scope.get()}, binding.typeId);
     scope->bindings[globals.globalNames.names->getOrAdd(name.c_str())] = binding;
 }
 
@@ -288,6 +290,22 @@ void assignPropDocumentationSymbols(TableType::Props& props, const std::string&
     }
 }
 
+static void finalizeGlobalBindings(ScopePtr scope)
+{
+    LUAU_ASSERT(FFlag::LuauUserTypeFunTypecheck);
+
+    for (const auto& pair : scope->bindings)
+    {
+        persist(pair.second.typeId);
+
+        if (TableType* ttv = getMutable<TableType>(pair.second.typeId))
+        {
+            if (!ttv->name)
+                ttv->name = "typeof(" + toString(pair.first) + ")";
+        }
+    }
+}
+
 void registerBuiltinGlobals(Frontend& frontend, GlobalTypes& globals, bool typeCheckForAutocomplete)
 {
     LUAU_ASSERT(!globals.globalTypes.types.isFrozen());
@@ -295,6 +313,9 @@ void registerBuiltinGlobals(Frontend& frontend, GlobalTypes& globals, bool typeC
 
     TypeArena& arena = globals.globalTypes;
     NotNull<BuiltinTypes> builtinTypes = globals.builtinTypes;
+    Scope* globalScope = nullptr; // NotNull<Scope> when removing FFlag::LuauNonReentrantGeneralization2
+    if (FFlag::LuauNonReentrantGeneralization2)
+        globalScope = globals.globalScope.get();
 
     if (FFlag::LuauSolverV2)
         builtinTypeFunctions().addToScope(NotNull{&arena}, NotNull{globals.globalScope.get()});
@@ -304,8 +325,8 @@ void registerBuiltinGlobals(Frontend& frontend, GlobalTypes& globals, bool typeC
     );
     LUAU_ASSERT(loadResult.success);
 
-    TypeId genericK = arena.addType(GenericType{"K"});
-    TypeId genericV = arena.addType(GenericType{"V"});
+    TypeId genericK = arena.addType(GenericType{globalScope, "K"});
+    TypeId genericV = arena.addType(GenericType{globalScope, "V"});
     TypeId mapOfKtoV = arena.addType(TableType{{}, TableIndexer(genericK, genericV), globals.globalScope->level, TableState::Generic});
 
     std::optional<TypeId> stringMetatableTy = getMetatable(builtinTypes->stringType, builtinTypes);
@@ -322,7 +343,7 @@ void registerBuiltinGlobals(Frontend& frontend, GlobalTypes& globals, bool typeC
     if (auto it = globals.globalScope->exportedTypeBindings.find("vector"); it != globals.globalScope->exportedTypeBindings.end())
     {
         TypeId vectorTy = it->second.type;
-        ClassType* vectorCls = getMutable<ClassType>(vectorTy);
+        ExternType* vectorCls = getMutable<ExternType>(vectorTy);
 
         vectorCls->metatable = arena.addType(TableType{{}, std::nullopt, TypeLevel{}, TableState::Sealed});
         TableType* metatableTy = Luau::getMutable<TableType>(vectorCls->metatable);
@@ -353,7 +374,7 @@ void registerBuiltinGlobals(Frontend& frontend, GlobalTypes& globals, bool typeC
     // pairs<K, V>(t: Table<K, V>) -> ((Table<K, V>, K?) -> (K, V), Table<K, V>, nil)
     addGlobalBinding(globals, "pairs", arena.addType(FunctionType{{genericK, genericV}, {}, pairsArgsTypePack, pairsReturnTypePack}), "@luau");
 
-    TypeId genericMT = arena.addType(GenericType{"MT"});
+    TypeId genericMT = arena.addType(GenericType{globalScope, "MT"});
 
     TableType tab{TableState::Generic, globals.globalScope->level};
     TypeId tabTy = arena.addType(tab);
@@ -365,7 +386,7 @@ void registerBuiltinGlobals(Frontend& frontend, GlobalTypes& globals, bool typeC
 
     if (FFlag::LuauSolverV2)
     {
-        TypeId genericT = arena.addType(GenericType{"T"});
+        TypeId genericT = arena.addType(GenericType{globalScope, "T"});
         TypeId tMetaMT = arena.addType(MetatableType{genericT, genericMT});
 
         // clang-format off
@@ -399,14 +420,21 @@ void registerBuiltinGlobals(Frontend& frontend, GlobalTypes& globals, bool typeC
         // clang-format on
     }
 
-    for (const auto& pair : globals.globalScope->bindings)
+    if (FFlag::LuauUserTypeFunTypecheck)
     {
-        persist(pair.second.typeId);
-
-        if (TableType* ttv = getMutable<TableType>(pair.second.typeId))
+        finalizeGlobalBindings(globals.globalScope);
+    }
+    else
+    {
+        for (const auto& pair : globals.globalScope->bindings)
         {
-            if (!ttv->name)
-                ttv->name = "typeof(" + toString(pair.first) + ")";
+            persist(pair.second.typeId);
+
+            if (TableType* ttv = getMutable<TableType>(pair.second.typeId))
+            {
+                if (!ttv->name)
+                    ttv->name = "typeof(" + toString(pair.first) + ")";
+            }
         }
     }
 
@@ -415,7 +443,7 @@ void registerBuiltinGlobals(Frontend& frontend, GlobalTypes& globals, bool typeC
     if (FFlag::LuauSolverV2)
     {
         // declare function assert<T>(value: T, errorMessage: string?): intersect<T, ~(false?)>
-        TypeId genericT = arena.addType(GenericType{"T"});
+        TypeId genericT = arena.addType(GenericType{globalScope, "T"});
         TypeId refinedTy = arena.addType(TypeFunctionInstanceType{
             NotNull{&builtinTypeFunctions().intersectFunc}, {genericT, arena.addType(NegationType{builtinTypes->falsyType})}, {}
         });
@@ -438,12 +466,16 @@ void registerBuiltinGlobals(Frontend& frontend, GlobalTypes& globals, bool typeC
             // the top table type.  We do the best we can by modelling these
             // functions using unconstrained generics.  It's not quite right,
             // but it'll be ok for now.
-            TypeId genericTy = arena.addType(GenericType{"T"});
+            TypeId genericTy = arena.addType(GenericType{globalScope, "T"});
             TypePackId thePack = arena.addTypePack({genericTy});
             TypeId idTyWithMagic = arena.addType(FunctionType{{genericTy}, {}, thePack, thePack});
             ttv->props["freeze"] = makeProperty(idTyWithMagic, "@luau/global/table.freeze");
+            if (globalScope)
+                inferGenericPolarities(NotNull{&globals.globalTypes}, NotNull{globalScope}, idTyWithMagic);
 
             TypeId idTy = arena.addType(FunctionType{{genericTy}, {}, thePack, thePack});
+            if (globalScope)
+                inferGenericPolarities(NotNull{&globals.globalTypes}, NotNull{globalScope}, idTy);
             ttv->props["clone"] = makeProperty(idTy, "@luau/global/table.clone");
         }
         else
@@ -467,6 +499,59 @@ void registerBuiltinGlobals(Frontend& frontend, GlobalTypes& globals, bool typeC
     TypeId requireTy = getGlobalBinding(globals, "require");
     attachTag(requireTy, kRequireTagName);
     attachMagicFunction(requireTy, std::make_shared<MagicRequire>());
+
+    if (FFlag::LuauUserTypeFunTypecheck)
+    {
+        // Global scope cannot be the parent of the type checking environment because it can be changed by the embedder
+        globals.globalTypeFunctionScope->exportedTypeBindings = globals.globalScope->exportedTypeBindings;
+        globals.globalTypeFunctionScope->builtinTypeNames = globals.globalScope->builtinTypeNames;
+
+        // Type function runtime also removes a few standard libraries and globals, so we will take only the ones that are defined
+        static const char* typeFunctionRuntimeBindings[] = {
+            // Libraries
+            "math",
+            "table",
+            "string",
+            "bit32",
+            "utf8",
+            "buffer",
+
+            // Globals
+            "assert",
+            "error",
+            "print",
+            "next",
+            "ipairs",
+            "pairs",
+            "select",
+            "unpack",
+            "getmetatable",
+            "setmetatable",
+            "rawget",
+            "rawset",
+            "rawlen",
+            "rawequal",
+            "tonumber",
+            "tostring",
+            "type",
+            "typeof",
+        };
+
+        for (auto& name : typeFunctionRuntimeBindings)
+        {
+            AstName astName = globals.globalNames.names->get(name);
+            LUAU_ASSERT(astName.value);
+
+            globals.globalTypeFunctionScope->bindings[astName] = globals.globalScope->bindings[astName];
+        }
+
+        LoadDefinitionFileResult typeFunctionLoadResult = frontend.loadDefinitionFile(
+            globals, globals.globalTypeFunctionScope, getTypeFunctionDefinitionSource(), "@luau", /* captureComments */ false, false
+        );
+        LUAU_ASSERT(typeFunctionLoadResult.success);
+
+        finalizeGlobalBindings(globals.globalTypeFunctionScope);
+    }
 }
 
 static std::vector<TypeId> parseFormatString(NotNull<BuiltinTypes> builtinTypes, const char* data, size_t size)
@@ -619,6 +704,14 @@ bool MagicFormat::typeCheck(const MagicFunctionTypeCheckContext& context)
         return true;
     }
 
+    // CLI-150726: The block below effectively constructs a type pack and then type checks it by going parameter-by-parameter.
+    // This does _not_ handle cases like:
+    //
+    //  local foo : () -> (...string) = (nil :: any)
+    //  print(string.format("%s %d %s", foo()))
+    //
+    // ... which should be disallowed.
+
     std::vector<TypeId> expected = parseFormatString(context.builtinTypes, fmt->value.data, fmt->value.size);
     const auto& [params, tail] = flatten(context.arguments);
 
@@ -630,31 +723,25 @@ bool MagicFormat::typeCheck(const MagicFunctionTypeCheckContext& context)
     {
         TypeId actualTy = params[i + paramOffset];
         TypeId expectedTy = expected[i];
-        Location location = context.callSite->args.data[i + (calledWithSelf ? 0 : paramOffset)]->location;
+        Location location = FFlag::LuauFormatUseLastPosition
+            ? context.callSite->args.data[std::min(context.callSite->args.size - 1, i + (calledWithSelf ? 0 : paramOffset))]->location
+            : context.callSite->args.data[i + (calledWithSelf ? 0 : paramOffset)]->location;
         // use subtyping instead here
         SubtypingResult result = context.typechecker->subtyping->isSubtype(actualTy, expectedTy, context.checkScope);
 
         if (!result.isSubtype)
         {
-            if (FFlag::LuauStringFormatErrorSuppression)
-            {
-                switch (shouldSuppressErrors(NotNull{&context.typechecker->normalizer}, actualTy))
-                {
-                case ErrorSuppression::Suppress:
-                    break;
-                case ErrorSuppression::NormalizationFailed:
-                    break;
-                case ErrorSuppression::DoNotSuppress:
-                    Reasonings reasonings = context.typechecker->explainReasonings(actualTy, expectedTy, location, result);
-
-                    if (!reasonings.suppressed)
-                        context.typechecker->reportError(TypeMismatch{expectedTy, actualTy, reasonings.toString()}, location);
-                }
-            }
-            else
+            switch (shouldSuppressErrors(NotNull{&context.typechecker->normalizer}, actualTy))
             {
+            case ErrorSuppression::Suppress:
+                break;
+            case ErrorSuppression::NormalizationFailed:
+                break;
+            case ErrorSuppression::DoNotSuppress:
                 Reasonings reasonings = context.typechecker->explainReasonings(actualTy, expectedTy, location, result);
-                context.typechecker->reportError(TypeMismatch{expectedTy, actualTy, reasonings.toString()}, location);
+
+                if (!reasonings.suppressed)
+                    context.typechecker->reportError(TypeMismatch{expectedTy, actualTy, reasonings.toString()}, location);
             }
         }
     }
@@ -1444,15 +1531,14 @@ bool MagicClone::infer(const MagicFunctionCallContext& context)
         return false;
 
     CloneState cloneState{context.solver->builtinTypes};
-    TypeId resultType = shallowClone(inputType, *arena, cloneState, /* ignorePersistent */ FFlag::LuauFreezeIgnorePersistent);
+    TypeId resultType = shallowClone(inputType, *arena, cloneState, /* ignorePersistent */ true);
 
     if (auto tableType = getMutable<TableType>(resultType))
     {
         tableType->scope = context.constraint->scope.get();
     }
 
-    if (FFlag::LuauTrackInteriorFreeTypesOnScope)
-        trackInteriorFreeType(context.constraint->scope.get(), resultType);
+    trackInteriorFreeType(context.constraint->scope.get(), resultType);
 
     TypePackId clonedTypePack = arena->addTypePack({resultType});
     asMutable(context.result)->ty.emplace<BoundTypePack>(clonedTypePack);
@@ -1463,8 +1549,7 @@ bool MagicClone::infer(const MagicFunctionCallContext& context)
 static std::optional<TypeId> freezeTable(TypeId inputType, const MagicFunctionCallContext& context)
 {
     TypeArena* arena = context.solver->arena;
-    if (FFlag::LuauFollowTableFreeze)
-        inputType = follow(inputType);
+    inputType = follow(inputType);
     if (auto mt = get<MetatableType>(inputType))
     {
         std::optional<TypeId> frozenTable = freezeTable(mt->table, context);
@@ -1481,7 +1566,7 @@ static std::optional<TypeId> freezeTable(TypeId inputType, const MagicFunctionCa
     {
         // Clone the input type, this will become our final result type after we mutate it.
         CloneState cloneState{context.solver->builtinTypes};
-        TypeId resultType = shallowClone(inputType, *arena, cloneState, /* ignorePersistent */ FFlag::LuauFreezeIgnorePersistent);
+        TypeId resultType = shallowClone(inputType, *arena, cloneState, /* ignorePersistent */ true);
         auto tableTy = getMutable<TableType>(resultType);
         // `clone` should not break this.
         LUAU_ASSERT(tableTy);
@@ -1531,6 +1616,17 @@ bool MagicFreeze::infer(const MagicFunctionCallContext& context)
     std::optional<DefId> resultDef = dfg->getDefOptional(targetExpr);
     std::optional<TypeId> resultTy = resultDef ? scope->lookup(*resultDef) : std::nullopt;
 
+    if (FFlag::LuauMagicFreezeCheckBlocked)
+    {
+        if (resultTy && !get<BlockedType>(resultTy))
+        {
+            // If there's an existing result type but it's _not_ blocked, then
+            // we aren't type stating this builtin and should fall back to
+            // regular inference.
+            return false;
+        }
+    }
+
     std::optional<TypeId> frozenType = freezeTable(inputType, context);
 
     if (!frozenType)

Analysis/src/Clone.cpp

@@ -1,17 +1,20 @@
 // This file is part of the Luau programming language and is licensed under MIT License; see LICENSE.txt for details
 #include "Luau/Clone.h"
 
+#include "Luau/Common.h"
 #include "Luau/NotNull.h"
 #include "Luau/Type.h"
 #include "Luau/TypePack.h"
 #include "Luau/Unifiable.h"
+#include "Luau/VisitType.h"
 
 LUAU_FASTFLAG(LuauSolverV2)
-LUAU_FASTFLAG(LuauFreezeIgnorePersistent)
 
 // For each `Luau::clone` call, we will clone only up to N amount of types _and_ packs, as controlled by this limit.
 LUAU_FASTINTVARIABLE(LuauTypeCloneIterationLimit, 100'000)
-
+LUAU_FASTFLAGVARIABLE(LuauClonedTableAndFunctionTypesMustHaveScopes)
+LUAU_FASTFLAGVARIABLE(LuauDoNotClonePersistentBindings)
+LUAU_FASTFLAG(LuauIncrementalAutocompleteDemandBasedCloning)
 namespace Luau
 {
 
@@ -28,6 +31,8 @@ const T* get(const Kind& kind)
 
 class TypeCloner
 {
+
+protected:
     NotNull<TypeArena> arena;
     NotNull<BuiltinTypes> builtinTypes;
 
@@ -62,6 +67,8 @@ public:
     {
     }
 
+    virtual ~TypeCloner() = default;
+
     TypeId clone(TypeId ty)
     {
         shallowClone(ty);
@@ -120,12 +127,13 @@ private:
         }
     }
 
+protected:
     std::optional<TypeId> find(TypeId ty) const
     {
         ty = follow(ty, FollowOption::DisableLazyTypeThunks);
         if (auto it = types->find(ty); it != types->end())
             return it->second;
-        else if (ty->persistent && (!FFlag::LuauFreezeIgnorePersistent || ty != forceTy))
+        else if (ty->persistent && ty != forceTy)
             return ty;
         return std::nullopt;
     }
@@ -135,7 +143,7 @@ private:
         tp = follow(tp);
         if (auto it = packs->find(tp); it != packs->end())
             return it->second;
-        else if (tp->persistent && (!FFlag::LuauFreezeIgnorePersistent || tp != forceTp))
+        else if (tp->persistent && tp != forceTp)
             return tp;
         return std::nullopt;
     }
@@ -154,14 +162,14 @@ private:
     }
 
 public:
-    TypeId shallowClone(TypeId ty)
+    virtual TypeId shallowClone(TypeId ty)
     {
         // We want to [`Luau::follow`] but without forcing the expansion of [`LazyType`]s.
         ty = follow(ty, FollowOption::DisableLazyTypeThunks);
 
         if (auto clone = find(ty))
             return *clone;
-        else if (ty->persistent && (!FFlag::LuauFreezeIgnorePersistent || ty != forceTy))
+        else if (ty->persistent && ty != forceTy)
             return ty;
 
         TypeId target = arena->addType(ty->ty);
@@ -171,8 +179,6 @@ public:
             generic->scope = nullptr;
         else if (auto free = getMutable<FreeType>(target))
             free->scope = nullptr;
-        else if (auto fn = getMutable<FunctionType>(target))
-            fn->scope = nullptr;
         else if (auto table = getMutable<TableType>(target))
             table->scope = nullptr;
 
@@ -181,13 +187,13 @@ public:
         return target;
     }
 
-    TypePackId shallowClone(TypePackId tp)
+    virtual TypePackId shallowClone(TypePackId tp)
     {
         tp = follow(tp);
 
         if (auto clone = find(tp))
             return *clone;
-        else if (tp->persistent && (!FFlag::LuauFreezeIgnorePersistent || tp != forceTp))
+        else if (tp->persistent && tp != forceTp)
             return tp;
 
         TypePackId target = arena->addTypePack(tp->ty);
@@ -349,7 +355,7 @@ private:
         t->metatable = shallowClone(t->metatable);
     }
 
-    void cloneChildren(ClassType* t)
+    void cloneChildren(ExternType* t)
     {
         for (auto& [_, p] : t->props)
             p = shallowClone(p);
@@ -389,7 +395,7 @@ private:
             ty = shallowClone(ty);
     }
 
-    void cloneChildren(LazyType* t)
+    virtual void cloneChildren(LazyType* t)
     {
         if (auto unwrapped = t->unwrapped.load())
             t->unwrapped.store(shallowClone(unwrapped));
@@ -469,11 +475,94 @@ private:
     }
 };
 
+class FragmentAutocompleteTypeCloner final : public TypeCloner
+{
+    Scope* replacementForNullScope = nullptr;
+
+public:
+    FragmentAutocompleteTypeCloner(
+        NotNull<TypeArena> arena,
+        NotNull<BuiltinTypes> builtinTypes,
+        NotNull<SeenTypes> types,
+        NotNull<SeenTypePacks> packs,
+        TypeId forceTy,
+        TypePackId forceTp,
+        Scope* replacementForNullScope
+    )
+        : TypeCloner(arena, builtinTypes, types, packs, forceTy, forceTp)
+        , replacementForNullScope(replacementForNullScope)
+    {
+        LUAU_ASSERT(replacementForNullScope);
+    }
+
+    TypeId shallowClone(TypeId ty) override
+    {
+        // We want to [`Luau::follow`] but without forcing the expansion of [`LazyType`]s.
+        ty = follow(ty, FollowOption::DisableLazyTypeThunks);
+
+        if (auto clone = find(ty))
+            return *clone;
+        else if (ty->persistent && ty != forceTy)
+            return ty;
+
+        TypeId target = arena->addType(ty->ty);
+        asMutable(target)->documentationSymbol = ty->documentationSymbol;
+
+        if (auto generic = getMutable<GenericType>(target))
+            generic->scope = nullptr;
+        else if (auto free = getMutable<FreeType>(target))
+        {
+            free->scope = replacementForNullScope;
+        }
+        else if (auto tt = getMutable<TableType>(target))
+        {
+            if (FFlag::LuauClonedTableAndFunctionTypesMustHaveScopes)
+                tt->scope = replacementForNullScope;
+        }
+
+        (*types)[ty] = target;
+        queue.emplace_back(target);
+        return target;
+    }
+
+    TypePackId shallowClone(TypePackId tp) override
+    {
+        tp = follow(tp);
+
+        if (auto clone = find(tp))
+            return *clone;
+        else if (tp->persistent && tp != forceTp)
+            return tp;
+
+        TypePackId target = arena->addTypePack(tp->ty);
+
+        if (auto generic = getMutable<GenericTypePack>(target))
+            generic->scope = nullptr;
+        else if (auto free = getMutable<FreeTypePack>(target))
+            free->scope = replacementForNullScope;
+
+        (*packs)[tp] = target;
+        queue.emplace_back(target);
+        return target;
+    }
+
+    void cloneChildren(LazyType* t) override
+    {
+        // Do not clone lazy types
+        if (!FFlag::LuauIncrementalAutocompleteDemandBasedCloning)
+        {
+            if (auto unwrapped = t->unwrapped.load())
+                t->unwrapped.store(shallowClone(unwrapped));
+        }
+    }
+};
+
+
 } // namespace
 
 TypePackId shallowClone(TypePackId tp, TypeArena& dest, CloneState& cloneState, bool ignorePersistent)
 {
-    if (tp->persistent && (!FFlag::LuauFreezeIgnorePersistent || !ignorePersistent))
+    if (tp->persistent && !ignorePersistent)
         return tp;
 
     TypeCloner cloner{
@@ -482,7 +571,7 @@ TypePackId shallowClone(TypePackId tp, TypeArena& dest, CloneState& cloneState,
         NotNull{&cloneState.seenTypes},
         NotNull{&cloneState.seenTypePacks},
         nullptr,
-        FFlag::LuauFreezeIgnorePersistent && ignorePersistent ? tp : nullptr
+        ignorePersistent ? tp : nullptr
     };
 
     return cloner.shallowClone(tp);
@@ -490,7 +579,7 @@ TypePackId shallowClone(TypePackId tp, TypeArena& dest, CloneState& cloneState,
 
 TypeId shallowClone(TypeId typeId, TypeArena& dest, CloneState& cloneState, bool ignorePersistent)
 {
-    if (typeId->persistent && (!FFlag::LuauFreezeIgnorePersistent || !ignorePersistent))
+    if (typeId->persistent && !ignorePersistent)
         return typeId;
 
     TypeCloner cloner{
@@ -498,7 +587,7 @@ TypeId shallowClone(TypeId typeId, TypeArena& dest, CloneState& cloneState, bool
         cloneState.builtinTypes,
         NotNull{&cloneState.seenTypes},
         NotNull{&cloneState.seenTypePacks},
-        FFlag::LuauFreezeIgnorePersistent && ignorePersistent ? typeId : nullptr,
+        ignorePersistent ? typeId : nullptr,
         nullptr
     };
 
@@ -564,4 +653,96 @@ Binding clone(const Binding& binding, TypeArena& dest, CloneState& cloneState)
     return b;
 }
 
+TypePackId cloneIncremental(TypePackId tp, TypeArena& dest, CloneState& cloneState, Scope* freshScopeForFreeTypes)
+{
+    if (tp->persistent)
+        return tp;
+
+    FragmentAutocompleteTypeCloner cloner{
+        NotNull{&dest},
+        cloneState.builtinTypes,
+        NotNull{&cloneState.seenTypes},
+        NotNull{&cloneState.seenTypePacks},
+        nullptr,
+        nullptr,
+        freshScopeForFreeTypes
+    };
+    return cloner.clone(tp);
+}
+
+TypeId cloneIncremental(TypeId typeId, TypeArena& dest, CloneState& cloneState, Scope* freshScopeForFreeTypes)
+{
+    if (typeId->persistent)
+        return typeId;
+
+    FragmentAutocompleteTypeCloner cloner{
+        NotNull{&dest},
+        cloneState.builtinTypes,
+        NotNull{&cloneState.seenTypes},
+        NotNull{&cloneState.seenTypePacks},
+        nullptr,
+        nullptr,
+        freshScopeForFreeTypes
+    };
+    return cloner.clone(typeId);
+}
+
+TypeFun cloneIncremental(const TypeFun& typeFun, TypeArena& dest, CloneState& cloneState, Scope* freshScopeForFreeTypes)
+{
+    FragmentAutocompleteTypeCloner cloner{
+        NotNull{&dest},
+        cloneState.builtinTypes,
+        NotNull{&cloneState.seenTypes},
+        NotNull{&cloneState.seenTypePacks},
+        nullptr,
+        nullptr,
+        freshScopeForFreeTypes
+    };
+
+    TypeFun copy = typeFun;
+
+    for (auto& param : copy.typeParams)
+    {
+        param.ty = cloner.clone(param.ty);
+
+        if (param.defaultValue)
+            param.defaultValue = cloner.clone(*param.defaultValue);
+    }
+
+    for (auto& param : copy.typePackParams)
+    {
+        param.tp = cloner.clone(param.tp);
+
+        if (param.defaultValue)
+            param.defaultValue = cloner.clone(*param.defaultValue);
+    }
+
+    copy.type = cloner.clone(copy.type);
+
+    return copy;
+}
+
+Binding cloneIncremental(const Binding& binding, TypeArena& dest, CloneState& cloneState, Scope* freshScopeForFreeTypes)
+{
+    FragmentAutocompleteTypeCloner cloner{
+        NotNull{&dest},
+        cloneState.builtinTypes,
+        NotNull{&cloneState.seenTypes},
+        NotNull{&cloneState.seenTypePacks},
+        nullptr,
+        nullptr,
+        freshScopeForFreeTypes
+    };
+
+    Binding b;
+    b.deprecated = binding.deprecated;
+    b.deprecatedSuggestion = binding.deprecatedSuggestion;
+    b.documentationSymbol = binding.documentationSymbol;
+    b.location = binding.location;
+    b.typeId = FFlag::LuauDoNotClonePersistentBindings && binding.typeId->persistent ? binding.typeId : cloner.clone(binding.typeId);
+
+    return b;
+}
+
+
 } // namespace Luau

Analysis/src/Constraint.cpp

@@ -20,7 +20,7 @@ struct ReferenceCountInitializer : TypeOnceVisitor
 
     DenseHashSet<TypeId>* result;
 
-    ReferenceCountInitializer(DenseHashSet<TypeId>* result)
+    explicit ReferenceCountInitializer(DenseHashSet<TypeId>* result)
         : result(result)
     {
     }
@@ -43,24 +43,15 @@ struct ReferenceCountInitializer : TypeOnceVisitor
         return false;
     }
 
-    bool visit(TypeId ty, const ClassType&) override
+    bool visit(TypeId ty, const ExternType&) override
     {
-        // ClassTypes never contain free types.
+        // ExternTypes never contain free types.
         return false;
     }
 
     bool visit(TypeId, const TypeFunctionInstanceType&) override
     {
-        // We do not consider reference counted types that are inside a type
-        // function to be part of the reachable reference counted types.
-        // Otherwise, code can be constructed in just the right way such
-        // that two type functions both claim to mutate a free type, which
-        // prevents either type function from trying to generalize it, so
-        // we potentially get stuck.
-        //
-        // The default behavior here is `true` for "visit the child types"
-        // of this type, hence:
-        return false;
+        return FFlag::DebugLuauGreedyGeneralization;
     }
 };
 
@@ -130,8 +121,10 @@ DenseHashSet<TypeId> Constraint::getMaybeMutatedFreeTypes() const
     }
     else if (auto hic = get<HasIndexerConstraint>(*this))
     {
+        if (FFlag::DebugLuauGreedyGeneralization)
+            rci.traverse(hic->subjectType);
         rci.traverse(hic->resultType);
-        // `HasIndexerConstraint` should not mutate `subjectType` or `indexType`.
+        // `HasIndexerConstraint` should not mutate `indexType`.
     }
     else if (auto apc = get<AssignPropConstraint>(*this))
     {
@@ -150,6 +143,10 @@ DenseHashSet<TypeId> Constraint::getMaybeMutatedFreeTypes() const
             rci.traverse(ty);
         // `UnpackConstraint` should not mutate `sourcePack`.
     }
+    else if (auto rpc = get<ReduceConstraint>(*this); FFlag::DebugLuauGreedyGeneralization && rpc)
+    {
+        rci.traverse(rpc->ty);
+    }
     else if (auto rpc = get<ReducePackConstraint>(*this))
     {
         rci.traverse(rpc->tp);

Analysis/src/DataFlowGraph.cpp

@@ -13,32 +13,25 @@
 
 LUAU_FASTFLAG(DebugLuauFreezeArena)
 LUAU_FASTFLAG(LuauSolverV2)
-
+LUAU_FASTFLAGVARIABLE(LuauPreprocessTypestatedArgument)
+LUAU_FASTFLAGVARIABLE(LuauDfgScopeStackTrueReset)
+LUAU_FASTFLAGVARIABLE(LuauDfgScopeStackNotNull)
+LUAU_FASTFLAG(LuauStoreReturnTypesAsPackOnAst)
+LUAU_FASTFLAGVARIABLE(LuauDoNotAddUpvalueTypesToLocalType)
+LUAU_FASTFLAGVARIABLE(LuauDfgIfBlocksShouldRespectControlFlow)
 namespace Luau
 {
 
 bool doesCallError(const AstExprCall* call); // TypeInfer.cpp
 
-struct ReferencedDefFinder : public AstVisitor
-{
-    bool visit(AstExprLocal* local) override
-    {
-        referencedLocalDefs.push_back(local->local);
-        return true;
-    }
-    // ast defs is just a mapping from expr -> def in general
-    // will get built up by the dfg builder
-
-    // localDefs, we need to copy over
-    std::vector<AstLocal*> referencedLocalDefs;
-};
-
 struct PushScope
 {
     ScopeStack& stack;
+    size_t previousSize;
 
     PushScope(ScopeStack& stack, DfgScope* scope)
         : stack(stack)
+        , previousSize(stack.size())
     {
         // `scope` should never be `nullptr` here.
         LUAU_ASSERT(scope);
@@ -47,7 +40,18 @@ struct PushScope
 
     ~PushScope()
     {
-        stack.pop_back();
+        if (FFlag::LuauDfgScopeStackTrueReset)
+        {
+            // If somehow this stack has _shrunk_ to be smaller than we expect,
+            // something very strange has happened.
+            LUAU_ASSERT(stack.size() > previousSize);
+            while (stack.size() > previousSize)
+                stack.pop_back();
+        }
+        else
+        {
+            stack.pop_back();
+        }
     }
 };
 
@@ -82,12 +86,6 @@ std::optional<DefId> DataFlowGraph::getDefOptional(const AstExpr* expr) const
     return NotNull{*def};
 }
 
-std::optional<DefId> DataFlowGraph::getRValueDefForCompoundAssign(const AstExpr* expr) const
-{
-    auto def = compoundAssignDefs.find(expr);
-    return def ? std::optional<DefId>(*def) : std::nullopt;
-}
-
 DefId DataFlowGraph::getDef(const AstLocal* local) const
 {
     auto def = localDefs.find(local);
@@ -201,7 +199,15 @@ DataFlowGraph DataFlowGraphBuilder::build(
 
     DataFlowGraphBuilder builder(defArena, keyArena);
     builder.handle = handle;
-    DfgScope* moduleScope = builder.makeChildScope();
+
+    DfgScope* moduleScope;
+    // We're not explicitly calling makeChildScope here because that function relies on currentScope
+    // which guarantees that the scope being returned is NotNull
+    // This means that while the scope stack is empty, we'll have to manually initialize the global scope
+    if (FFlag::LuauDfgScopeStackNotNull)
+        moduleScope = builder.scopes.emplace_back(new DfgScope{nullptr, DfgScope::ScopeType::Linear}).get();
+    else
+        moduleScope = builder.makeChildScope();
     PushScope ps{builder.scopeStack, moduleScope};
     builder.visitBlockWithoutChildScope(block);
     builder.resolveCaptures();
@@ -233,7 +239,13 @@ void DataFlowGraphBuilder::resolveCaptures()
     }
 }
 
-DfgScope* DataFlowGraphBuilder::currentScope()
+NotNull<DfgScope> DataFlowGraphBuilder::currentScope()
+{
+    LUAU_ASSERT(!scopeStack.empty());
+    return NotNull{scopeStack.back()};
+}
+
+DfgScope* DataFlowGraphBuilder::currentScope_DEPRECATED()
 {
     if (scopeStack.empty())
         return nullptr; // nullptr is the root DFG scope.
@@ -242,7 +254,10 @@ DfgScope* DataFlowGraphBuilder::currentScope()
 
 DfgScope* DataFlowGraphBuilder::makeChildScope(DfgScope::ScopeType scopeType)
 {
-    return scopes.emplace_back(new DfgScope{currentScope(), scopeType}).get();
+    if (FFlag::LuauDfgScopeStackNotNull)
+        return scopes.emplace_back(new DfgScope{currentScope(), scopeType}).get();
+    else
+        return scopes.emplace_back(new DfgScope{currentScope_DEPRECATED(), scopeType}).get();
 }
 
 void DataFlowGraphBuilder::join(DfgScope* p, DfgScope* a, DfgScope* b)
@@ -317,9 +332,9 @@ void DataFlowGraphBuilder::joinProps(DfgScope* result, const DfgScope& a, const
     }
 }
 
-DefId DataFlowGraphBuilder::lookup(Symbol symbol)
+DefId DataFlowGraphBuilder::lookup(Symbol symbol, Location location)
 {
-    DfgScope* scope = currentScope();
+    DfgScope* scope = FFlag::LuauDfgScopeStackNotNull ? currentScope() : currentScope_DEPRECATED();
 
     // true if any of the considered scopes are a loop.
     bool outsideLoopScope = false;
@@ -344,15 +359,15 @@ DefId DataFlowGraphBuilder::lookup(Symbol symbol)
         }
     }
 
-    DefId result = defArena->freshCell();
+    DefId result = defArena->freshCell(symbol, location);
     scope->bindings[symbol] = result;
     captures[symbol].allVersions.push_back(result);
     return result;
 }
 
-DefId DataFlowGraphBuilder::lookup(DefId def, const std::string& key)
+DefId DataFlowGraphBuilder::lookup(DefId def, const std::string& key, Location location)
 {
-    DfgScope* scope = currentScope();
+    DfgScope* scope = FFlag::LuauDfgScopeStackNotNull ? currentScope() : currentScope_DEPRECATED();
     for (DfgScope* current = scope; current; current = current->parent)
     {
         if (auto props = current->props.find(def))
@@ -362,7 +377,7 @@ DefId DataFlowGraphBuilder::lookup(DefId def, const std::string& key)
         }
         else if (auto phi = get<Phi>(def); phi && phi->operands.empty()) // Unresolved phi nodes
         {
-            DefId result = defArena->freshCell();
+            DefId result = defArena->freshCell(def->name, location);
             scope->props[def][key] = result;
             return result;
         }
@@ -372,7 +387,7 @@ DefId DataFlowGraphBuilder::lookup(DefId def, const std::string& key)
     {
         std::vector<DefId> defs;
         for (DefId operand : phi->operands)
-            defs.push_back(lookup(operand, key));
+            defs.push_back(lookup(operand, key, location));
 
         DefId result = defArena->phi(defs);
         scope->props[def][key] = result;
@@ -380,7 +395,7 @@ DefId DataFlowGraphBuilder::lookup(DefId def, const std::string& key)
     }
     else if (get<Cell>(def))
     {
-        DefId result = defArena->freshCell();
+        DefId result = defArena->freshCell(def->name, location);
         scope->props[def][key] = result;
         return result;
     }
@@ -398,7 +413,10 @@ ControlFlow DataFlowGraphBuilder::visit(AstStatBlock* b)
         cf = visitBlockWithoutChildScope(b);
     }
 
-    currentScope()->inherit(child);
+    if (FFlag::LuauDfgScopeStackNotNull)
+        currentScope()->inherit(child);
+    else
+        currentScope_DEPRECATED()->inherit(child);
     return cf;
 }
 
@@ -455,7 +473,7 @@ ControlFlow DataFlowGraphBuilder::visit(AstStat* s)
         return visit(d);
     else if (auto d = s->as<AstStatDeclareFunction>())
         return visit(d);
-    else if (auto d = s->as<AstStatDeclareClass>())
+    else if (auto d = s->as<AstStatDeclareExternType>())
         return visit(d);
     else if (auto error = s->as<AstStatError>())
         return visit(error);
@@ -483,13 +501,27 @@ ControlFlow DataFlowGraphBuilder::visit(AstStatIf* i)
         elsecf = visit(i->elsebody);
     }
 
-    DfgScope* scope = currentScope();
-    if (thencf != ControlFlow::None && elsecf == ControlFlow::None)
-        join(scope, scope, elseScope);
-    else if (thencf == ControlFlow::None && elsecf != ControlFlow::None)
-        join(scope, thenScope, scope);
-    else if ((thencf | elsecf) == ControlFlow::None)
-        join(scope, thenScope, elseScope);
+    DfgScope* scope = FFlag::LuauDfgScopeStackNotNull ? currentScope() : currentScope_DEPRECATED();
+    if (FFlag::LuauDfgIfBlocksShouldRespectControlFlow)
+    {
+        // If the control flow from the `if` or `else` block is non-linear,
+        // then we should assume that the _other_ branch is the one taken.
+        if (thencf != ControlFlow::None && elsecf == ControlFlow::None)
+            scope->inherit(elseScope);
+        else if (thencf == ControlFlow::None && elsecf != ControlFlow::None)
+            scope->inherit(thenScope);
+        else if ((thencf | elsecf) == ControlFlow::None)
+            join(scope, thenScope, elseScope);
+    }
+    else
+    {
+        if (thencf != ControlFlow::None && elsecf == ControlFlow::None)
+            join(scope, scope, elseScope);
+        else if (thencf == ControlFlow::None && elsecf != ControlFlow::None)
+            join(scope, thenScope, scope);
+        else if ((thencf | elsecf) == ControlFlow::None)
+            join(scope, thenScope, elseScope);
+    }
 
     if (thencf == elsecf)
         return thencf;
@@ -510,7 +542,10 @@ ControlFlow DataFlowGraphBuilder::visit(AstStatWhile* w)
         visit(w->body);
     }
 
-    currentScope()->inherit(whileScope);
+    if (FFlag::LuauDfgScopeStackNotNull)
+        currentScope()->inherit(whileScope);
+    else
+        currentScope_DEPRECATED()->inherit(whileScope);
 
     return ControlFlow::None;
 }
@@ -526,7 +561,10 @@ ControlFlow DataFlowGraphBuilder::visit(AstStatRepeat* r)
         visitExpr(r->condition);
     }
 
-    currentScope()->inherit(repeatScope);
+    if (FFlag::LuauDfgScopeStackNotNull)
+        currentScope()->inherit(repeatScope);
+    else
+        currentScope_DEPRECATED()->inherit(repeatScope);
 
     return ControlFlow::None;
 }
@@ -575,7 +613,7 @@ ControlFlow DataFlowGraphBuilder::visit(AstStatLocal* l)
         // We need to create a new def to intentionally avoid alias tracking, but we'd like to
         // make sure that the non-aliased defs are also marked as a subscript for refinements.
         bool subscripted = i < defs.size() && containsSubscriptedDefinition(defs[i]);
-        DefId def = defArena->freshCell(subscripted);
+        DefId def = defArena->freshCell(local, local->location, subscripted);
         if (i < l->values.size)
         {
             AstExpr* e = l->values.data[i];
@@ -585,7 +623,10 @@ ControlFlow DataFlowGraphBuilder::visit(AstStatLocal* l)
             }
         }
         graph.localDefs[local] = def;
-        currentScope()->bindings[local] = def;
+        if (FFlag::LuauDfgScopeStackNotNull)
+            currentScope()->bindings[local] = def;
+        else
+            currentScope_DEPRECATED()->bindings[local] = def;
         captures[local].allVersions.push_back(def);
     }
 
@@ -607,16 +648,22 @@ ControlFlow DataFlowGraphBuilder::visit(AstStatFor* f)
         if (f->var->annotation)
             visitType(f->var->annotation);
 
-        DefId def = defArena->freshCell();
+        DefId def = defArena->freshCell(f->var, f->var->location);
         graph.localDefs[f->var] = def;
-        currentScope()->bindings[f->var] = def;
+        if (FFlag::LuauDfgScopeStackNotNull)
+            currentScope()->bindings[f->var] = def;
+        else
+            currentScope_DEPRECATED()->bindings[f->var] = def;
         captures[f->var].allVersions.push_back(def);
 
         // TODO(controlflow): entry point has a back edge from exit point
         visit(f->body);
     }
 
-    currentScope()->inherit(forScope);
+    if (FFlag::LuauDfgScopeStackNotNull)
+        currentScope()->inherit(forScope);
+    else
+        currentScope_DEPRECATED()->inherit(forScope);
 
     return ControlFlow::None;
 }
@@ -633,9 +680,12 @@ ControlFlow DataFlowGraphBuilder::visit(AstStatForIn* f)
             if (local->annotation)
                 visitType(local->annotation);
 
-            DefId def = defArena->freshCell();
+            DefId def = defArena->freshCell(local, local->location);
             graph.localDefs[local] = def;
-            currentScope()->bindings[local] = def;
+            if (FFlag::LuauDfgScopeStackNotNull)
+                currentScope()->bindings[local] = def;
+            else
+                currentScope_DEPRECATED()->bindings[local] = def;
             captures[local].allVersions.push_back(def);
         }
 
@@ -646,8 +696,10 @@ ControlFlow DataFlowGraphBuilder::visit(AstStatForIn* f)
 
         visit(f->body);
     }
-
-    currentScope()->inherit(forScope);
+    if (FFlag::LuauDfgScopeStackNotNull)
+        currentScope()->inherit(forScope);
+    else
+        currentScope_DEPRECATED()->inherit(forScope);
 
     return ControlFlow::None;
 }
@@ -662,7 +714,7 @@ ControlFlow DataFlowGraphBuilder::visit(AstStatAssign* a)
     for (size_t i = 0; i < a->vars.size; ++i)
     {
         AstExpr* v = a->vars.data[i];
-        visitLValue(v, i < defs.size() ? defs[i] : defArena->freshCell());
+        visitLValue(v, i < defs.size() ? defs[i] : defArena->freshCell(Symbol{}, v->location));
     }
 
     return ControlFlow::None;
@@ -688,7 +740,7 @@ ControlFlow DataFlowGraphBuilder::visit(AstStatFunction* f)
     //
     // which is evidence that references to variables must be a phi node of all possible definitions,
     // but for bug compatibility, we'll assume the same thing here.
-    visitLValue(f->name, defArena->freshCell());
+    visitLValue(f->name, defArena->freshCell(Symbol{}, f->name->location));
     visitExpr(f->func);
 
     if (auto local = f->name->as<AstExprLocal>())
@@ -708,9 +760,12 @@ ControlFlow DataFlowGraphBuilder::visit(AstStatFunction* f)
 
 ControlFlow DataFlowGraphBuilder::visit(AstStatLocalFunction* l)
 {
-    DefId def = defArena->freshCell();
+    DefId def = defArena->freshCell(l->name, l->location);
     graph.localDefs[l->name] = def;
-    currentScope()->bindings[l->name] = def;
+    if (FFlag::LuauDfgScopeStackNotNull)
+        currentScope()->bindings[l->name] = def;
+    else
+        currentScope_DEPRECATED()->bindings[l->name] = def;
     captures[l->name].allVersions.push_back(def);
     visitExpr(l->func);
 
@@ -741,9 +796,12 @@ ControlFlow DataFlowGraphBuilder::visit(AstStatTypeFunction* f)
 
 ControlFlow DataFlowGraphBuilder::visit(AstStatDeclareGlobal* d)
 {
-    DefId def = defArena->freshCell();
+    DefId def = defArena->freshCell(d->name, d->nameLocation);
     graph.declaredDefs[d] = def;
-    currentScope()->bindings[d->name] = def;
+    if (FFlag::LuauDfgScopeStackNotNull)
+        currentScope()->bindings[d->name] = def;
+    else
+        currentScope_DEPRECATED()->bindings[d->name] = def;
     captures[d->name].allVersions.push_back(def);
 
     visitType(d->type);
@@ -753,9 +811,12 @@ ControlFlow DataFlowGraphBuilder::visit(AstStatDeclareGlobal* d)
 
 ControlFlow DataFlowGraphBuilder::visit(AstStatDeclareFunction* d)
 {
-    DefId def = defArena->freshCell();
+    DefId def = defArena->freshCell(d->name, d->nameLocation);
     graph.declaredDefs[d] = def;
-    currentScope()->bindings[d->name] = def;
+    if (FFlag::LuauDfgScopeStackNotNull)
+        currentScope()->bindings[d->name] = def;
+    else
+        currentScope_DEPRECATED()->bindings[d->name] = def;
     captures[d->name].allVersions.push_back(def);
 
     DfgScope* unreachable = makeChildScope();
@@ -764,12 +825,15 @@ ControlFlow DataFlowGraphBuilder::visit(AstStatDeclareFunction* d)
     visitGenerics(d->generics);
     visitGenericPacks(d->genericPacks);
     visitTypeList(d->params);
-    visitTypeList(d->retTypes);
+    if (FFlag::LuauStoreReturnTypesAsPackOnAst)
+        visitTypePack(d->retTypes);
+    else
+        visitTypeList(d->retTypes_DEPRECATED);
 
     return ControlFlow::None;
 }
 
-ControlFlow DataFlowGraphBuilder::visit(AstStatDeclareClass* d)
+ControlFlow DataFlowGraphBuilder::visit(AstStatDeclareExternType* d)
 {
     // This declaration does not "introduce" any bindings in value namespace,
     // so there's no symbolic value to begin with. We'll traverse the properties
@@ -777,7 +841,7 @@ ControlFlow DataFlowGraphBuilder::visit(AstStatDeclareClass* d)
     DfgScope* unreachable = makeChildScope();
     PushScope ps{scopeStack, unreachable};
 
-    for (AstDeclaredClassProp prop : d->props)
+    for (AstDeclaredExternTypeProperty prop : d->props)
         visitType(prop.ty);
 
     return ControlFlow::None;
@@ -810,19 +874,19 @@ DataFlowResult DataFlowGraphBuilder::visitExpr(AstExpr* e)
         if (auto g = e->as<AstExprGroup>())
             return visitExpr(g);
         else if (auto c = e->as<AstExprConstantNil>())
-            return {defArena->freshCell(), nullptr}; // ok
+            return {defArena->freshCell(Symbol{}, c->location), nullptr}; // ok
         else if (auto c = e->as<AstExprConstantBool>())
-            return {defArena->freshCell(), nullptr}; // ok
+            return {defArena->freshCell(Symbol{}, c->location), nullptr}; // ok
         else if (auto c = e->as<AstExprConstantNumber>())
-            return {defArena->freshCell(), nullptr}; // ok
+            return {defArena->freshCell(Symbol{}, c->location), nullptr}; // ok
         else if (auto c = e->as<AstExprConstantString>())
-            return {defArena->freshCell(), nullptr}; // ok
+            return {defArena->freshCell(Symbol{}, c->location), nullptr}; // ok
         else if (auto l = e->as<AstExprLocal>())
             return visitExpr(l);
         else if (auto g = e->as<AstExprGlobal>())
             return visitExpr(g);
         else if (auto v = e->as<AstExprVarargs>())
-            return {defArena->freshCell(), nullptr}; // ok
+            return {defArena->freshCell(Symbol{}, v->location), nullptr}; // ok
         else if (auto c = e->as<AstExprCall>())
             return visitExpr(c);
         else if (auto i = e->as<AstExprIndexName>())
@@ -863,14 +927,14 @@ DataFlowResult DataFlowGraphBuilder::visitExpr(AstExprGroup* group)
 
 DataFlowResult DataFlowGraphBuilder::visitExpr(AstExprLocal* l)
 {
-    DefId def = lookup(l->local);
+    DefId def = lookup(l->local, l->local->location);
     const RefinementKey* key = keyArena->leaf(def);
     return {def, key};
 }
 
 DataFlowResult DataFlowGraphBuilder::visitExpr(AstExprGlobal* g)
 {
-    DefId def = lookup(g->name);
+    DefId def = lookup(g->name, g->location);
     return {def, keyArena->leaf(def)};
 }
 
@@ -878,6 +942,12 @@ DataFlowResult DataFlowGraphBuilder::visitExpr(AstExprCall* c)
 {
     visitExpr(c->func);
 
+    if (FFlag::LuauPreprocessTypestatedArgument)
+    {
+        for (AstExpr* arg : c->args)
+            visitExpr(arg);
+    }
+
     if (shouldTypestateForFirstArgument(*c) && c->args.size > 1 && isLValue(*c->args.begin()))
     {
         AstExpr* firstArg = *c->args.begin();
@@ -908,11 +978,23 @@ DataFlowResult DataFlowGraphBuilder::visitExpr(AstExprCall* c)
         visitLValue(firstArg, def);
     }
 
-    for (AstExpr* arg : c->args)
-        visitExpr(arg);
+    if (!FFlag::LuauPreprocessTypestatedArgument)
+    {
+        for (AstExpr* arg : c->args)
+            visitExpr(arg);
+    }
 
-    // calls should be treated as subscripted.
-    return {defArena->freshCell(/* subscripted */ true), nullptr};
+    // We treat function calls as "subscripted" as they could potentially
+    // return a subscripted value, consider:
+    //
+    //  local function foo(tbl: {[string]: woof)
+    //      return tbl["foobarbaz"]
+    //  end
+    //
+    //  local v = foo({})
+    //
+    // We want to consider `v` to be subscripted here.
+    return {defArena->freshCell(Symbol{}, c->location, /*subscripted=*/true)};
 }
 
 DataFlowResult DataFlowGraphBuilder::visitExpr(AstExprIndexName* i)
@@ -920,7 +1002,7 @@ DataFlowResult DataFlowGraphBuilder::visitExpr(AstExprIndexName* i)
     auto [parentDef, parentKey] = visitExpr(i->expr);
     std::string index = i->index.value;
 
-    DefId def = lookup(parentDef, index);
+    DefId def = lookup(parentDef, index, i->location);
     return {def, keyArena->node(parentKey, def, index)};
 }
 
@@ -933,11 +1015,11 @@ DataFlowResult DataFlowGraphBuilder::visitExpr(AstExprIndexExpr* i)
     {
         std::string index{string->value.data, string->value.size};
 
-        DefId def = lookup(parentDef, index);
+        DefId def = lookup(parentDef, index, i->location);
         return {def, keyArena->node(parentKey, def, index)};
     }
 
-    return {defArena->freshCell(/* subscripted= */ true), nullptr};
+    return {defArena->freshCell(Symbol{}, i->location, /* subscripted= */ true), nullptr};
 }
 
 DataFlowResult DataFlowGraphBuilder::visitExpr(AstExprFunction* f)
@@ -950,7 +1032,7 @@ DataFlowResult DataFlowGraphBuilder::visitExpr(AstExprFunction* f)
         // There's no syntax for `self` to have an annotation if using `function t:m()`
         LUAU_ASSERT(!self->annotation);
 
-        DefId def = defArena->freshCell();
+        DefId def = defArena->freshCell(f->debugname, f->location);
         graph.localDefs[self] = def;
         signatureScope->bindings[self] = def;
         captures[self].allVersions.push_back(def);
@@ -961,7 +1043,7 @@ DataFlowResult DataFlowGraphBuilder::visitExpr(AstExprFunction* f)
         if (param->annotation)
             visitType(param->annotation);
 
-        DefId def = defArena->freshCell();
+        DefId def = defArena->freshCell(param, param->location);
         graph.localDefs[param] = def;
         signatureScope->bindings[param] = def;
         captures[param].allVersions.push_back(def);
@@ -970,8 +1052,16 @@ DataFlowResult DataFlowGraphBuilder::visitExpr(AstExprFunction* f)
     if (f->varargAnnotation)
         visitTypePack(f->varargAnnotation);
 
-    if (f->returnAnnotation)
-        visitTypeList(*f->returnAnnotation);
+    if (FFlag::LuauStoreReturnTypesAsPackOnAst)
+    {
+        if (f->returnAnnotation)
+            visitTypePack(f->returnAnnotation);
+    }
+    else
+    {
+        if (f->returnAnnotation_DEPRECATED)
+            visitTypeList(*f->returnAnnotation_DEPRECATED);
+    }
 
     // TODO: function body can be re-entrant, as in mutations that occurs at the end of the function can also be
     // visible to the beginning of the function, so statically speaking, the body of the function has an exit point
@@ -983,13 +1073,16 @@ DataFlowResult DataFlowGraphBuilder::visitExpr(AstExprFunction* f)
     // g() --> 5
     visit(f->body);
 
-    return {defArena->freshCell(), nullptr};
+    return {defArena->freshCell(f->debugname, f->location), nullptr};
 }
 
 DataFlowResult DataFlowGraphBuilder::visitExpr(AstExprTable* t)
 {
-    DefId tableCell = defArena->freshCell();
-    currentScope()->props[tableCell] = {};
+    DefId tableCell = defArena->freshCell(Symbol{}, t->location);
+    if (FFlag::LuauDfgScopeStackNotNull)
+        currentScope()->props[tableCell] = {};
+    else
+        currentScope_DEPRECATED()->props[tableCell] = {};
     for (AstExprTable::Item item : t->items)
     {
         DataFlowResult result = visitExpr(item.value);
@@ -997,7 +1090,12 @@ DataFlowResult DataFlowGraphBuilder::visitExpr(AstExprTable* t)
         {
             visitExpr(item.key);
             if (auto string = item.key->as<AstExprConstantString>())
-                currentScope()->props[tableCell][string->value.data] = result.def;
+            {
+                if (FFlag::LuauDfgScopeStackNotNull)
+                    currentScope()->props[tableCell][string->value.data] = result.def;
+                else
+                    currentScope_DEPRECATED()->props[tableCell][string->value.data] = result.def;
+            }
         }
     }
 
@@ -1008,7 +1106,7 @@ DataFlowResult DataFlowGraphBuilder::visitExpr(AstExprUnary* u)
 {
     visitExpr(u->expr);
 
-    return {defArena->freshCell(), nullptr};
+    return {defArena->freshCell(Symbol{}, u->location), nullptr};
 }
 
 DataFlowResult DataFlowGraphBuilder::visitExpr(AstExprBinary* b)
@@ -1016,7 +1114,7 @@ DataFlowResult DataFlowGraphBuilder::visitExpr(AstExprBinary* b)
     visitExpr(b->left);
     visitExpr(b->right);
 
-    return {defArena->freshCell(), nullptr};
+    return {defArena->freshCell(Symbol{}, b->location), nullptr};
 }
 
 DataFlowResult DataFlowGraphBuilder::visitExpr(AstExprTypeAssertion* t)
@@ -1033,7 +1131,7 @@ DataFlowResult DataFlowGraphBuilder::visitExpr(AstExprIfElse* i)
     visitExpr(i->trueExpr);
     visitExpr(i->falseExpr);
 
-    return {defArena->freshCell(), nullptr};
+    return {defArena->freshCell(Symbol{}, i->location), nullptr};
 }
 
 DataFlowResult DataFlowGraphBuilder::visitExpr(AstExprInterpString* i)
@@ -1041,7 +1139,7 @@ DataFlowResult DataFlowGraphBuilder::visitExpr(AstExprInterpString* i)
     for (AstExpr* e : i->expressions)
         visitExpr(e);
 
-    return {defArena->freshCell(), nullptr};
+    return {defArena->freshCell(Symbol{}, i->location), nullptr};
 }
 
 DataFlowResult DataFlowGraphBuilder::visitExpr(AstExprError* error)
@@ -1052,7 +1150,7 @@ DataFlowResult DataFlowGraphBuilder::visitExpr(AstExprError* error)
     for (AstExpr* e : error->expressions)
         visitExpr(e);
 
-    return {defArena->freshCell(), nullptr};
+    return {defArena->freshCell(Symbol{}, error->location), nullptr};
 }
 
 void DataFlowGraphBuilder::visitLValue(AstExpr* e, DefId incomingDef)
@@ -1078,12 +1176,12 @@ void DataFlowGraphBuilder::visitLValue(AstExpr* e, DefId incomingDef)
 
 DefId DataFlowGraphBuilder::visitLValue(AstExprLocal* l, DefId incomingDef)
 {
-    DfgScope* scope = currentScope();
+    DfgScope* scope = FFlag::LuauDfgScopeStackNotNull ? currentScope() : currentScope_DEPRECATED();
 
     // In order to avoid alias tracking, we need to clip the reference to the parent def.
-    if (scope->canUpdateDefinition(l->local))
+    if (scope->canUpdateDefinition(l->local) && !(FFlag::LuauDoNotAddUpvalueTypesToLocalType && l->upvalue))
     {
-        DefId updated = defArena->freshCell(containsSubscriptedDefinition(incomingDef));
+        DefId updated = defArena->freshCell(l->local, l->location, containsSubscriptedDefinition(incomingDef));
         scope->bindings[l->local] = updated;
         captures[l->local].allVersions.push_back(updated);
         return updated;
@@ -1094,12 +1192,12 @@ DefId DataFlowGraphBuilder::visitLValue(AstExprLocal* l, DefId incomingDef)
 
 DefId DataFlowGraphBuilder::visitLValue(AstExprGlobal* g, DefId incomingDef)
 {
-    DfgScope* scope = currentScope();
+    DfgScope* scope = FFlag::LuauDfgScopeStackNotNull ? currentScope() : currentScope_DEPRECATED();
 
     // In order to avoid alias tracking, we need to clip the reference to the parent def.
     if (scope->canUpdateDefinition(g->name))
     {
-        DefId updated = defArena->freshCell(containsSubscriptedDefinition(incomingDef));
+        DefId updated = defArena->freshCell(g->name, g->location, containsSubscriptedDefinition(incomingDef));
         scope->bindings[g->name] = updated;
         captures[g->name].allVersions.push_back(updated);
         return updated;
@@ -1112,10 +1210,10 @@ DefId DataFlowGraphBuilder::visitLValue(AstExprIndexName* i, DefId incomingDef)
 {
     DefId parentDef = visitExpr(i->expr).def;
 
-    DfgScope* scope = currentScope();
+    DfgScope* scope = FFlag::LuauDfgScopeStackNotNull ? currentScope() : currentScope_DEPRECATED();
     if (scope->canUpdateDefinition(parentDef, i->index.value))
     {
-        DefId updated = defArena->freshCell(containsSubscriptedDefinition(incomingDef));
+        DefId updated = defArena->freshCell(i->index, i->location, containsSubscriptedDefinition(incomingDef));
         scope->props[parentDef][i->index.value] = updated;
         return updated;
     }
@@ -1128,12 +1226,12 @@ DefId DataFlowGraphBuilder::visitLValue(AstExprIndexExpr* i, DefId incomingDef)
     DefId parentDef = visitExpr(i->expr).def;
     visitExpr(i->index);
 
-    DfgScope* scope = currentScope();
+    DfgScope* scope = FFlag::LuauDfgScopeStackNotNull ? currentScope() : currentScope_DEPRECATED();
     if (auto string = i->index->as<AstExprConstantString>())
     {
         if (scope->canUpdateDefinition(parentDef, string->value.data))
         {
-            DefId updated = defArena->freshCell(containsSubscriptedDefinition(incomingDef));
+            DefId updated = defArena->freshCell(Symbol{}, i->location, containsSubscriptedDefinition(incomingDef));
             scope->props[parentDef][string->value.data] = updated;
             return updated;
         }
@@ -1141,7 +1239,7 @@ DefId DataFlowGraphBuilder::visitLValue(AstExprIndexExpr* i, DefId incomingDef)
             return visitExpr(static_cast<AstExpr*>(i)).def;
     }
     else
-        return defArena->freshCell(/*subscripted=*/true);
+        return defArena->freshCell(Symbol{}, i->location, /*subscripted=*/true);
 }
 
 DefId DataFlowGraphBuilder::visitLValue(AstExprError* error, DefId incomingDef)
@@ -1159,6 +1257,8 @@ void DataFlowGraphBuilder::visitType(AstType* t)
         return visitType(f);
     else if (auto tyof = t->as<AstTypeTypeof>())
         return visitType(tyof);
+    else if (auto o = t->as<AstTypeOptional>())
+        return;
     else if (auto u = t->as<AstTypeUnion>())
         return visitType(u);
     else if (auto i = t->as<AstTypeIntersection>())
@@ -1203,7 +1303,10 @@ void DataFlowGraphBuilder::visitType(AstTypeFunction* f)
     visitGenerics(f->generics);
     visitGenericPacks(f->genericPacks);
     visitTypeList(f->argTypes);
-    visitTypeList(f->returnTypes);
+    if (FFlag::LuauStoreReturnTypesAsPackOnAst)
+        visitTypePack(f->returnTypes);
+    else
+        visitTypeList(f->returnTypes_DEPRECATED);
 }
 
 void DataFlowGraphBuilder::visitType(AstTypeTypeof* t)

Analysis/src/Def.cpp

@@ -36,9 +36,9 @@ void collectOperands(DefId def, std::vector<DefId>* operands)
     }
 }
 
-DefId DefArena::freshCell(bool subscripted)
+DefId DefArena::freshCell(Symbol sym, Location location, bool subscripted)
 {
-    return NotNull{allocator.allocate(Def{Cell{subscripted}})};
+    return NotNull{allocator.allocate(Def{Cell{subscripted}, sym, location})};
 }
 
 DefId DefArena::phi(DefId a, DefId b)

Analysis/src/Differ.cpp

@@ -277,7 +277,7 @@ static DifferResult diffSingleton(DifferEnvironment& env, TypeId left, TypeId ri
 static DifferResult diffFunction(DifferEnvironment& env, TypeId left, TypeId right);
 static DifferResult diffGeneric(DifferEnvironment& env, TypeId left, TypeId right);
 static DifferResult diffNegation(DifferEnvironment& env, TypeId left, TypeId right);
-static DifferResult diffClass(DifferEnvironment& env, TypeId left, TypeId right);
+static DifferResult diffExternType(DifferEnvironment& env, TypeId left, TypeId right);
 struct FindSeteqCounterexampleResult
 {
     // nullopt if no counterexample found
@@ -481,14 +481,14 @@ static DifferResult diffNegation(DifferEnvironment& env, TypeId left, TypeId rig
     return differResult;
 }
 
-static DifferResult diffClass(DifferEnvironment& env, TypeId left, TypeId right)
+static DifferResult diffExternType(DifferEnvironment& env, TypeId left, TypeId right)
 {
-    const ClassType* leftClass = get<ClassType>(left);
-    const ClassType* rightClass = get<ClassType>(right);
-    LUAU_ASSERT(leftClass);
-    LUAU_ASSERT(rightClass);
+    const ExternType* leftExternType = get<ExternType>(left);
+    const ExternType* rightExternType = get<ExternType>(right);
+    LUAU_ASSERT(leftExternType);
+    LUAU_ASSERT(rightExternType);
 
-    if (leftClass == rightClass)
+    if (leftExternType == rightExternType)
     {
         return DifferResult{};
     }
@@ -651,9 +651,9 @@ static DifferResult diffUsingEnv(DifferEnvironment& env, TypeId left, TypeId rig
         {
             return diffNegation(env, left, right);
         }
-        else if (auto lc = get<ClassType>(left))
+        else if (auto lc = get<ExternType>(left))
         {
-            return diffClass(env, left, right);
+            return diffExternType(env, left, right);
         }
 
         throw InternalCompilerError{"Unimplemented Simple TypeId variant for diffing"};
@@ -960,7 +960,7 @@ bool isSimple(TypeId ty)
 {
     ty = follow(ty);
     // TODO: think about GenericType, etc.
-    return get<PrimitiveType>(ty) || get<SingletonType>(ty) || get<AnyType>(ty) || get<NegationType>(ty) || get<ClassType>(ty) ||
+    return get<PrimitiveType>(ty) || get<SingletonType>(ty) || get<AnyType>(ty) || get<NegationType>(ty) || get<ExternType>(ty) ||
            get<UnknownType>(ty) || get<NeverType>(ty);
 }
 

Analysis/src/EmbeddedBuiltinDefinitions.cpp

@@ -1,7 +1,8 @@
 // This file is part of the Luau programming language and is licensed under MIT License; see LICENSE.txt for details
 #include "Luau/BuiltinDefinitions.h"
 
-LUAU_FASTFLAGVARIABLE(LuauDebugInfoDefn)
+LUAU_FASTFLAG(LuauDeclareExternType)
+LUAU_FASTFLAG(LuauTypeFunOptional)
 
 namespace Luau
 {
@@ -215,15 +216,6 @@ declare debug: {
 
 )BUILTIN_SRC";
 
-static const std::string kBuiltinDefinitionDebugSrc_DEPRECATED = R"BUILTIN_SRC(
-
-declare debug: {
-    info: (<R...>(thread: thread, level: number, options: string) -> R...) & (<R...>(level: number, options: string) -> R...) & (<A..., R1..., R2...>(func: (A...) -> R1..., options: string) -> R2...),
-    traceback: ((message: string?, level: number?) -> string) & ((thread: thread, message: string?, level: number?) -> string),
-}
-
-)BUILTIN_SRC";
-
 static const std::string kBuiltinDefinitionUtf8Src = R"BUILTIN_SRC(
 
 declare utf8: {
@@ -270,7 +262,37 @@ declare buffer: {
 
 )BUILTIN_SRC";
 
-static const std::string kBuiltinDefinitionVectorSrc = R"BUILTIN_SRC(
+static const std::string kBuiltinDefinitionVectorSrc = (FFlag::LuauDeclareExternType)
+    ? R"BUILTIN_SRC(
+
+-- While vector would have been better represented as a built-in primitive type, type solver extern type handling covers most of the properties
+declare extern type vector with
+    x: number
+    y: number
+    z: number
+end
+
+declare vector: {
+    create: @checked (x: number, y: number, z: number?) -> vector,
+    magnitude: @checked (vec: vector) -> number,
+    normalize: @checked (vec: vector) -> vector,
+    cross: @checked (vec1: vector, vec2: vector) -> vector,
+    dot: @checked (vec1: vector, vec2: vector) -> number,
+    angle: @checked (vec1: vector, vec2: vector, axis: vector?) -> number,
+    floor: @checked (vec: vector) -> vector,
+    ceil: @checked (vec: vector) -> vector,
+    abs: @checked (vec: vector) -> vector,
+    sign: @checked (vec: vector) -> vector,
+    clamp: @checked (vec: vector, min: vector, max: vector) -> vector,
+    max: @checked (vector, ...vector) -> vector,
+    min: @checked (vector, ...vector) -> vector,
+
+    zero: vector,
+    one: vector,
+}
+
+)BUILTIN_SRC"
+    : R"BUILTIN_SRC(
 
 -- While vector would have been better represented as a built-in primitive type, type solver class handling covers most of the properties
 declare class vector
@@ -309,7 +331,7 @@ std::string getBuiltinDefinitionSource()
     result += kBuiltinDefinitionOsSrc;
     result += kBuiltinDefinitionCoroutineSrc;
     result += kBuiltinDefinitionTableSrc;
-    result += FFlag::LuauDebugInfoDefn ? kBuiltinDefinitionDebugSrc : kBuiltinDefinitionDebugSrc_DEPRECATED;
+    result += kBuiltinDefinitionDebugSrc;
     result += kBuiltinDefinitionUtf8Src;
     result += kBuiltinDefinitionBufferSrc;
     result += kBuiltinDefinitionVectorSrc;
@@ -317,4 +339,119 @@ std::string getBuiltinDefinitionSource()
     return result;
 }
 
+// TODO: split into separate tagged unions when the new solver can appropriately handle that.
+static const std::string kBuiltinDefinitionTypeMethodSrc = R"BUILTIN_SRC(
+
+export type type = {
+    tag: "nil" | "unknown" | "never" | "any" | "boolean" | "number" | "string" | "buffer" | "thread" |
+         "singleton" | "negation" | "union" | "intersection" | "table" | "function" | "class" | "generic",
+
+    is: (self: type, arg: string) -> boolean,
+
+    -- for singleton type
+    value: (self: type) -> (string | boolean | nil),
+
+    -- for negation type
+    inner: (self: type) -> type,
+
+    -- for union and intersection types
+    components: (self: type) -> {type},
+
+    -- for table type
+    setproperty: (self: type, key: type, value: type?) -> (),
+    setreadproperty: (self: type, key: type, value: type?) -> (),
+    setwriteproperty: (self: type, key: type, value: type?) -> (),
+    readproperty: (self: type, key: type) -> type?,
+    writeproperty: (self: type, key: type) -> type?,
+    properties: (self: type) -> { [type]: { read: type?, write: type? } },
+    setindexer: (self: type, index: type, result: type) -> (),
+    setreadindexer: (self: type, index: type, result: type) -> (),
+    setwriteindexer: (self: type, index: type, result: type) -> (),
+    indexer: (self: type) -> { index: type, readresult: type, writeresult: type }?,
+    readindexer: (self: type) -> { index: type, result: type }?,
+    writeindexer: (self: type) -> { index: type, result: type }?,
+    setmetatable: (self: type, arg: type) -> (),
+    metatable: (self: type) -> type?,
+
+    -- for function type
+    setparameters: (self: type, head: {type}?, tail: type?) -> (),
+    parameters: (self: type) -> { head: {type}?, tail: type? },
+    setreturns: (self: type, head: {type}?, tail: type? ) -> (),
+    returns: (self: type) -> { head: {type}?, tail: type? },
+    setgenerics: (self: type, {type}?) -> (),
+    generics: (self: type) -> {type},
+
+    -- for class type
+    -- 'properties', 'metatable', 'indexer', 'readindexer' and 'writeindexer' are shared with table type
+    readparent: (self: type) -> type?,
+    writeparent: (self: type) -> type?,
+
+    -- for generic type
+    name: (self: type) -> string?,
+    ispack: (self: type) -> boolean,
+}
+
+)BUILTIN_SRC";
+
+static const std::string kBuiltinDefinitionTypesLibSrc = R"BUILTIN_SRC(
+
+declare types: {
+    unknown: type,
+    never: type,
+    any: type,
+    boolean: type,
+    number: type,
+    string: type,
+    thread: type,
+    buffer: type,
+
+    singleton: @checked (arg: string | boolean | nil) -> type,
+    generic: @checked (name: string, ispack: boolean?) -> type,
+    negationof: @checked (arg: type) -> type,
+    unionof: @checked (...type) -> type,
+    intersectionof: @checked (...type) -> type,
+    newtable: @checked (props: {[type]: type} | {[type]: { read: type, write: type } } | nil, indexer: { index: type, readresult: type, writeresult: type }?, metatable: type?) -> type,
+    newfunction: @checked (parameters: { head: {type}?, tail: type? }?, returns: { head: {type}?, tail: type? }?, generics: {type}?) -> type,
+    copy: @checked (arg: type) -> type,
+}
+)BUILTIN_SRC";
+
+static const std::string kBuiltinDefinitionTypesLibWithOptionalSrc = R"BUILTIN_SRC(
+
+declare types: {
+    unknown: type,
+    never: type,
+    any: type,
+    boolean: type,
+    number: type,
+    string: type,
+    thread: type,
+    buffer: type,
+
+    singleton: @checked (arg: string | boolean | nil) -> type,
+    optional: @checked (arg: type) -> type,
+    generic: @checked (name: string, ispack: boolean?) -> type,
+    negationof: @checked (arg: type) -> type,
+    unionof: @checked (...type) -> type,
+    intersectionof: @checked (...type) -> type,
+    newtable: @checked (props: {[type]: type} | {[type]: { read: type, write: type } } | nil, indexer: { index: type, readresult: type, writeresult: type }?, metatable: type?) -> type,
+    newfunction: @checked (parameters: { head: {type}?, tail: type? }?, returns: { head: {type}?, tail: type? }?, generics: {type}?) -> type,
+    copy: @checked (arg: type) -> type,
+}
+)BUILTIN_SRC";
+
+
+std::string getTypeFunctionDefinitionSource()
+{
+
+    std::string result = kBuiltinDefinitionTypeMethodSrc;
+
+    if (FFlag::LuauTypeFunOptional)
+        result += kBuiltinDefinitionTypesLibWithOptionalSrc;
+    else
+        result += kBuiltinDefinitionTypesLibSrc;
+
+    return result;
+}
+
 } // namespace Luau

Analysis/src/EqSatSimplification.cpp

@@ -330,9 +330,9 @@ Id toId(
         return egraph.add(TOpaque{ty});
     else if (get<FunctionType>(ty))
         return egraph.add(TFunction{ty});
-    else if (ty == builtinTypes->classType)
+    else if (ty == builtinTypes->externType)
         return egraph.add(TTopClass{});
-    else if (get<ClassType>(ty))
+    else if (get<ExternType>(ty))
         return egraph.add(TClass{ty});
     else if (get<AnyType>(ty))
         return egraph.add(TAny{});
@@ -752,7 +752,7 @@ TypeId fromId(
     else if (node.get<TTopTable>())
         return builtinTypes->tableType;
     else if (node.get<TTopClass>())
-        return builtinTypes->classType;
+        return builtinTypes->externType;
     else if (node.get<TBuffer>())
         return builtinTypes->bufferType;
     else if (auto opaque = node.get<TOpaque>())
@@ -1007,7 +1007,7 @@ static std::string getNodeName(const StringCache& strings, const EType& node)
         return "\xe2\x88\xa9";
     else if (auto cls = node.get<TClass>())
     {
-        const ClassType* ct = get<ClassType>(cls->value());
+        const ExternType* ct = get<ExternType>(cls->value());
         LUAU_ASSERT(ct);
         return ct->name;
     }
@@ -1177,12 +1177,12 @@ enum SubclassRelationship
 
 static SubclassRelationship relateClasses(const TClass* leftClass, const TClass* rightClass)
 {
-    const ClassType* leftClassType = Luau::get<ClassType>(leftClass->value());
-    const ClassType* rightClassType = Luau::get<ClassType>(rightClass->value());
+    const ExternType* leftExternType = Luau::get<ExternType>(leftClass->value());
+    const ExternType* rightExternType = Luau::get<ExternType>(rightClass->value());
 
-    if (isSubclass(leftClassType, rightClassType))
+    if (isSubclass(leftExternType, rightExternType))
         return RightSuper;
-    else if (isSubclass(rightClassType, leftClassType))
+    else if (isSubclass(rightExternType, leftExternType))
         return LeftSuper;
     else
         return Unrelated;

Analysis/src/Error.cpp

@@ -8,6 +8,7 @@
 #include "Luau/StringUtils.h"
 #include "Luau/ToString.h"
 #include "Luau/Type.h"
+#include "Luau/TypeChecker2.h"
 #include "Luau/TypeFunction.h"
 
 #include <optional>
@@ -17,6 +18,7 @@
 #include <unordered_set>
 
 LUAU_FASTINTVARIABLE(LuauIndentTypeMismatchMaxTypeLength, 10)
+LUAU_FASTFLAG(DebugLuauGreedyGeneralization)
 
 static std::string wrongNumberOfArgsString(
     size_t expectedCount,
@@ -68,7 +70,7 @@ namespace Luau
 {
 
 // this list of binary operator type functions is used for better stringification of type functions errors
-static const std::unordered_map<std::string, const char*> kBinaryOps{
+static const std::unordered_map<std::string, const char*> DEPRECATED_kBinaryOps{
     {"add", "+"},
     {"sub", "-"},
     {"mul", "*"},
@@ -84,12 +86,27 @@ static const std::unordered_map<std::string, const char*> kBinaryOps{
     {"eq", "== or ~="}
 };
 
+static const std::unordered_map<std::string, const char*> kBinaryOps{
+    {"add", "+"},
+    {"sub", "-"},
+    {"mul", "*"},
+    {"div", "/"},
+    {"idiv", "//"},
+    {"pow", "^"},
+    {"mod", "%"},
+    {"concat", ".."},
+    {"lt", "< or >="},
+    {"le", "<= or >"},
+    {"eq", "== or ~="}
+};
+
 // this list of unary operator type functions is used for better stringification of type functions errors
 static const std::unordered_map<std::string, const char*> kUnaryOps{{"unm", "-"}, {"len", "#"}, {"not", "not"}};
 
 // this list of type functions will receive a special error indicating that the user should file a bug on the GitHub repository
 // putting a type function in this list indicates that it is expected to _always_ reduce
-static const std::unordered_set<std::string> kUnreachableTypeFunctions{"refine", "singleton", "union", "intersect"};
+static const std::unordered_set<std::string> DEPRECATED_kUnreachableTypeFunctions{"refine", "singleton", "union", "intersect"};
+static const std::unordered_set<std::string> kUnreachableTypeFunctions{"refine", "singleton", "union", "intersect", "and", "or"};
 
 struct ErrorConverter
 {
@@ -116,7 +133,10 @@ struct ErrorConverter
             size_t luauIndentTypeMismatchMaxTypeLength = size_t(FInt::LuauIndentTypeMismatchMaxTypeLength);
             if (givenType.length() <= luauIndentTypeMismatchMaxTypeLength || wantedType.length() <= luauIndentTypeMismatchMaxTypeLength)
                 return "Type " + given + " could not be converted into " + wanted;
-            return "Type\n    " + given + "\ncould not be converted into\n    " + wanted;
+            if (FFlag::LuauImproveTypePathsInErrors)
+                return "Type\n\t" + given + "\ncould not be converted into\n\t" + wanted;
+            else
+                return "Type\n    " + given + "\ncould not be converted into\n    " + wanted;
         };
 
         if (givenTypeName == wantedTypeName)
@@ -183,7 +203,7 @@ struct ErrorConverter
         TypeId t = follow(e.table);
         if (get<TableType>(t))
             return "Key '" + e.key + "' not found in table '" + Luau::toString(t) + "'";
-        else if (get<ClassType>(t))
+        else if (get<ExternType>(t))
             return "Key '" + e.key + "' not found in class '" + Luau::toString(t) + "'";
         else
             return "Type '" + Luau::toString(e.table) + "' does not have key '" + e.key + "'";
@@ -351,7 +371,7 @@ struct ErrorConverter
         std::string s = "Key '" + e.key + "' not found in ";
 
         TypeId t = follow(e.table);
-        if (get<ClassType>(t))
+        if (get<ExternType>(t))
             s += "class";
         else
             s += "table";
@@ -382,8 +402,8 @@ struct ErrorConverter
         std::optional<TypeId> metatable;
         if (const MetatableType* mtType = get<MetatableType>(type))
             metatable = mtType->metatable;
-        else if (const ClassType* classType = get<ClassType>(type))
-            metatable = classType->metatable;
+        else if (const ExternType* externType = get<ExternType>(type))
+            metatable = externType->metatable;
 
         if (!metatable)
             return std::nullopt;
@@ -591,7 +611,7 @@ struct ErrorConverter
         return ss;
     }
 
-    std::string operator()(const DynamicPropertyLookupOnClassesUnsafe& e) const
+    std::string operator()(const DynamicPropertyLookupOnExternTypesUnsafe& e) const
     {
         return "Attempting a dynamic property access on type '" + Luau::toString(e.ty) + "' is unsafe and may cause exceptions at runtime";
     }
@@ -601,7 +621,7 @@ struct ErrorConverter
         auto tfit = get<TypeFunctionInstanceType>(e.ty);
         LUAU_ASSERT(tfit); // Luau analysis has actually done something wrong if this type is not a type function.
         if (!tfit)
-            return "Unexpected type " + Luau::toString(e.ty) + " flagged as an uninhabited type function.";
+            return "Internal error: Unexpected type " + Luau::toString(e.ty) + " flagged as an uninhabited type function.";
 
         // unary operators
         if (auto unaryString = kUnaryOps.find(tfit->function->name); unaryString != kUnaryOps.end())
@@ -638,7 +658,8 @@ struct ErrorConverter
         }
 
         // binary operators
-        if (auto binaryString = kBinaryOps.find(tfit->function->name); binaryString != kBinaryOps.end())
+        const auto binaryOps = FFlag::DebugLuauGreedyGeneralization ? kBinaryOps : DEPRECATED_kBinaryOps;
+        if (auto binaryString = binaryOps.find(tfit->function->name); binaryString != binaryOps.end())
         {
             std::string result = "Operator '" + std::string(binaryString->second) + "' could not be applied to operands of types ";
 
@@ -692,10 +713,10 @@ struct ErrorConverter
                        "'";
         }
 
-        if (kUnreachableTypeFunctions.count(tfit->function->name))
+        if ((FFlag::DebugLuauGreedyGeneralization ? kUnreachableTypeFunctions : DEPRECATED_kUnreachableTypeFunctions).count(tfit->function->name))
         {
             return "Type function instance " + Luau::toString(e.ty) + " is uninhabited\n" +
-                   "This is likely to be a bug, please report it at https://github.com/luau-lang/luau/issues";
+                "This is likely to be a bug, please report it at https://github.com/luau-lang/luau/issues";
         }
 
         // Everything should be specialized above to report a more descriptive error that hopefully does not mention "type functions" explicitly.
@@ -751,8 +772,15 @@ struct ErrorConverter
 
     std::string operator()(const NonStrictFunctionDefinitionError& e) const
     {
-        return "Argument " + e.argument + " with type '" + toString(e.argumentType) + "' in function '" + e.functionName +
-               "' is used in a way that will run time error";
+        if (e.functionName.empty())
+        {
+            return "Argument " + e.argument + " with type '" + toString(e.argumentType) + "' is used in a way that will run time error";
+        }
+        else
+        {
+            return "Argument " + e.argument + " with type '" + toString(e.argumentType) + "' in function '" + e.functionName +
+                   "' is used in a way that will run time error";
+        }
     }
 
     std::string operator()(const PropertyAccessViolation& e) const
@@ -791,6 +819,11 @@ struct ErrorConverter
         return e.message;
     }
 
+    std::string operator()(const ReservedIdentifier& e) const
+    {
+        return e.name + " cannot be used as an identifier for a type function or alias";
+    }
+
     std::string operator()(const CannotAssignToNever& e) const
     {
         std::string result = "Cannot assign a value of type " + toString(e.rhsType) + " to a field of type never";
@@ -1116,7 +1149,7 @@ bool TypePackMismatch::operator==(const TypePackMismatch& rhs) const
     return *wantedTp == *rhs.wantedTp && *givenTp == *rhs.givenTp;
 }
 
-bool DynamicPropertyLookupOnClassesUnsafe::operator==(const DynamicPropertyLookupOnClassesUnsafe& rhs) const
+bool DynamicPropertyLookupOnExternTypesUnsafe::operator==(const DynamicPropertyLookupOnExternTypesUnsafe& rhs) const
 {
     return ty == rhs.ty;
 }
@@ -1178,6 +1211,11 @@ bool UserDefinedTypeFunctionError::operator==(const UserDefinedTypeFunctionError
     return message == rhs.message;
 }
 
+bool ReservedIdentifier::operator==(const ReservedIdentifier& rhs) const
+{
+    return name == rhs.name;
+}
+
 bool CannotAssignToNever::operator==(const CannotAssignToNever& rhs) const
 {
     if (cause.size() != rhs.cause.size())
@@ -1353,7 +1391,7 @@ void copyError(T& e, TypeArena& destArena, CloneState& cloneState)
         e.wantedTp = clone(e.wantedTp);
         e.givenTp = clone(e.givenTp);
     }
-    else if constexpr (std::is_same_v<T, DynamicPropertyLookupOnClassesUnsafe>)
+    else if constexpr (std::is_same_v<T, DynamicPropertyLookupOnExternTypesUnsafe>)
         e.ty = clone(e.ty);
     else if constexpr (std::is_same_v<T, UninhabitedTypeFunction>)
         e.ty = clone(e.ty);
@@ -1397,6 +1435,9 @@ void copyError(T& e, TypeArena& destArena, CloneState& cloneState)
         for (auto& ty : e.cause)
             ty = clone(ty);
     }
+    else if constexpr (std::is_same_v<T, ReservedIdentifier>)
+    {
+    }
     else
         static_assert(always_false_v<T>, "Non-exhaustive type switch");
 }

Analysis/src/FileResolver.cpp

@@ -0,0 +1,160 @@
+// This file is part of the Luau programming language and is licensed under MIT License; see LICENSE.txt for details
+#include "Luau/FileResolver.h"
+
+#include "Luau/Common.h"
+#include "Luau/StringUtils.h"
+
+#include <algorithm>
+#include <memory>
+#include <optional>
+#include <string_view>
+#include <utility>
+
+namespace Luau
+{
+
+static std::optional<RequireSuggestions> processRequireSuggestions(std::optional<RequireSuggestions> suggestions)
+{
+    if (!suggestions)
+        return suggestions;
+
+    for (RequireSuggestion& suggestion : *suggestions)
+    {
+        suggestion.fullPath = escape(suggestion.fullPath);
+    }
+
+    return suggestions;
+}
+
+static RequireSuggestions makeSuggestionsFromAliases(std::vector<RequireAlias> aliases)
+{
+    RequireSuggestions result;
+    for (RequireAlias& alias : aliases)
+    {
+        RequireSuggestion suggestion;
+        suggestion.label = "@" + std::move(alias.alias);
+        suggestion.fullPath = suggestion.label;
+        suggestion.tags = std::move(alias.tags);
+        result.push_back(std::move(suggestion));
+    }
+    return result;
+}
+
+static RequireSuggestions makeSuggestionsForFirstComponent(std::unique_ptr<RequireNode> node)
+{
+    RequireSuggestions result = makeSuggestionsFromAliases(node->getAvailableAliases());
+    result.push_back(RequireSuggestion{"./", "./", {}});
+    result.push_back(RequireSuggestion{"../", "../", {}});
+    return result;
+}
+
+static RequireSuggestions makeSuggestionsFromNode(std::unique_ptr<RequireNode> node, const std::string_view path, bool isPartialPath)
+{
+    LUAU_ASSERT(!path.empty());
+
+    RequireSuggestions result;
+
+    const size_t lastSlashInPath = path.find_last_of('/');
+
+    if (lastSlashInPath != std::string_view::npos)
+    {
+        // Add a suggestion for the parent directory
+        RequireSuggestion parentSuggestion;
+        parentSuggestion.label = "..";
+
+        // TODO: after exposing require-by-string's path normalization API, this
+        // if-else can be replaced. Instead, we can simply normalize the result
+        // of inserting ".." at the end of the current path.
+        if (lastSlashInPath >= 2 && path.substr(lastSlashInPath - 2, 3) == "../")
+        {
+            parentSuggestion.fullPath = path.substr(0, lastSlashInPath + 1);
+            parentSuggestion.fullPath += "..";
+        }
+        else
+        {
+            parentSuggestion.fullPath = path.substr(0, lastSlashInPath);
+        }
+
+        result.push_back(std::move(parentSuggestion));
+    }
+
+    std::string fullPathPrefix;
+    if (isPartialPath)
+    {
+        // ./path/to/chi -> ./path/to/
+        fullPathPrefix += path.substr(0, lastSlashInPath + 1);
+    }
+    else
+    {
+        if (path.back() == '/')
+        {
+            // ./path/to/ -> ./path/to/
+            fullPathPrefix += path;
+        }
+        else
+        {
+            // ./path/to -> ./path/to/
+            fullPathPrefix += path;
+            fullPathPrefix += "/";
+        }
+    }
+
+    for (const std::unique_ptr<RequireNode>& child : node->getChildren())
+    {
+        if (!child)
+            continue;
+
+        std::string pathComponent = child->getPathComponent();
+
+        // If path component contains a slash, it cannot be required by string.
+        // There's no point suggesting it.
+        if (pathComponent.find('/') != std::string::npos)
+            continue;
+
+        RequireSuggestion suggestion;
+        suggestion.label = isPartialPath || path.back() == '/' ? child->getLabel() : "/" + child->getLabel();
+        suggestion.fullPath = fullPathPrefix + std::move(pathComponent);
+        suggestion.tags = child->getTags();
+        result.push_back(std::move(suggestion));
+    }
+
+    return result;
+}
+
+std::optional<RequireSuggestions> RequireSuggester::getRequireSuggestionsImpl(const ModuleName& requirer, const std::optional<std::string>& path)
+    const
+{
+    if (!path)
+        return std::nullopt;
+
+    std::unique_ptr<RequireNode> requirerNode = getNode(requirer);
+    if (!requirerNode)
+        return std::nullopt;
+
+    const size_t slashPos = path->find_last_of('/');
+
+    if (slashPos == std::string::npos)
+        return makeSuggestionsForFirstComponent(std::move(requirerNode));
+
+    // If path already points at a Node, return the Node's children as paths.
+    if (std::unique_ptr<RequireNode> node = requirerNode->resolvePathToNode(*path))
+        return makeSuggestionsFromNode(std::move(node), *path, /* isPartialPath = */ false);
+
+    // Otherwise, recover a partial path and use this to generate suggestions.
+    if (std::unique_ptr<RequireNode> partialNode = requirerNode->resolvePathToNode(path->substr(0, slashPos)))
+        return makeSuggestionsFromNode(std::move(partialNode), *path, /* isPartialPath = */ true);
+
+    return std::nullopt;
+}
+
+std::optional<RequireSuggestions> RequireSuggester::getRequireSuggestions(const ModuleName& requirer, const std::optional<std::string>& path) const
+{
+    return processRequireSuggestions(getRequireSuggestionsImpl(requirer, path));
+}
+
+std::optional<RequireSuggestions> FileResolver::getRequireSuggestions(const ModuleName& requirer, const std::optional<std::string>& path) const
+{
+    return requireSuggester ? requireSuggester->getRequireSuggestions(requirer, path) : std::nullopt;
+}
+
+} // namespace Luau

Analysis/src/Frontend.cpp

@@ -1,7 +1,6 @@
 // This file is part of the Luau programming language and is licensed under MIT License; see LICENSE.txt for details
 #include "Luau/Frontend.h"
 
-#include "Luau/AnyTypeSummary.h"
 #include "Luau/BuiltinDefinitions.h"
 #include "Luau/Clone.h"
 #include "Luau/Common.h"
@@ -40,19 +39,15 @@ LUAU_FASTINT(LuauTarjanChildLimit)
 LUAU_FASTFLAG(LuauInferInNoCheckMode)
 LUAU_FASTFLAGVARIABLE(LuauKnowsTheDataModel3)
 LUAU_FASTFLAG(LuauSolverV2)
+LUAU_DYNAMIC_FASTFLAGVARIABLE(LuauRethrowKnownExceptions, false)
+LUAU_FASTFLAG(DebugLuauGreedyGeneralization)
 LUAU_FASTFLAGVARIABLE(DebugLuauLogSolverToJson)
 LUAU_FASTFLAGVARIABLE(DebugLuauLogSolverToJsonFile)
 LUAU_FASTFLAGVARIABLE(DebugLuauForbidInternalTypes)
 LUAU_FASTFLAGVARIABLE(DebugLuauForceStrictMode)
 LUAU_FASTFLAGVARIABLE(DebugLuauForceNonStrictMode)
-LUAU_DYNAMIC_FASTFLAGVARIABLE(LuauRunCustomModuleChecks, false)
 
-LUAU_FASTFLAGVARIABLE(LuauBetterReverseDependencyTracking)
-
-LUAU_FASTFLAG(StudioReportLuauAny2)
-LUAU_FASTFLAGVARIABLE(LuauStoreSolverTypeOnModule)
-
-LUAU_FASTFLAGVARIABLE(LuauSelectivelyRetainDFGArena)
+LUAU_FASTFLAG(LuauTypeFunResultInAutocomplete)
 
 namespace Luau
 {
@@ -82,6 +77,20 @@ struct BuildQueueItem
     Frontend::Stats stats;
 };
 
+struct BuildQueueWorkState
+{
+    std::function<void(std::function<void()> task)> executeTask;
+
+    std::vector<BuildQueueItem> buildQueueItems;
+
+    std::mutex mtx;
+    std::condition_variable cv;
+    std::vector<size_t> readyQueueItems;
+
+    size_t processing = 0;
+    size_t remaining = 0;
+};
+
 std::optional<Mode> parseMode(const std::vector<HotComment>& hotcomments)
 {
     for (const HotComment& hc : hotcomments)
@@ -120,9 +129,9 @@ static void generateDocumentationSymbols(TypeId ty, const std::string& rootName)
             prop.documentationSymbol = rootName + "." + name;
         }
     }
-    else if (ClassType* ctv = getMutable<ClassType>(ty))
+    else if (ExternType* etv = getMutable<ExternType>(ty))
     {
-        for (auto& [name, prop] : ctv->props)
+        for (auto& [name, prop] : etv->props)
         {
             prop.documentationSymbol = rootName + "." + name;
         }
@@ -446,20 +455,6 @@ CheckResult Frontend::check(const ModuleName& name, std::optional<FrontendOption
 
         if (item.name == name)
             checkResult.lintResult = item.module->lintResult;
-
-        if (FFlag::StudioReportLuauAny2 && item.options.retainFullTypeGraphs)
-        {
-            if (item.module)
-            {
-                const SourceModule& sourceModule = *item.sourceModule;
-                if (sourceModule.mode == Luau::Mode::Strict)
-                {
-                    item.module->ats.root = toString(sourceModule.root);
-                }
-                item.module->ats.rootSrc = sourceModule.root;
-                item.module->ats.traverse(item.module.get(), sourceModule.root, NotNull{&builtinTypes_});
-            }
-        }
     }
 
     return checkResult;
@@ -490,7 +485,8 @@ std::vector<ModuleName> Frontend::checkQueuedModules(
     std::swap(currModuleQueue, moduleQueue);
 
     DenseHashSet<Luau::ModuleName> seen{{}};
-    std::vector<BuildQueueItem> buildQueueItems;
+
+    std::shared_ptr<BuildQueueWorkState> state = std::make_shared<BuildQueueWorkState>();
 
     for (const ModuleName& name : currModuleQueue)
     {
@@ -514,18 +510,18 @@ std::vector<ModuleName> Frontend::checkQueuedModules(
             }
         );
 
-        addBuildQueueItems(buildQueueItems, queue, cycleDetected, seen, frontendOptions);
+        addBuildQueueItems(state->buildQueueItems, queue, cycleDetected, seen, frontendOptions);
     }
 
-    if (buildQueueItems.empty())
+    if (state->buildQueueItems.empty())
         return {};
 
     // We need a mapping from modules to build queue slots
     std::unordered_map<ModuleName, size_t> moduleNameToQueue;
 
-    for (size_t i = 0; i < buildQueueItems.size(); i++)
+    for (size_t i = 0; i < state->buildQueueItems.size(); i++)
     {
-        BuildQueueItem& item = buildQueueItems[i];
+        BuildQueueItem& item = state->buildQueueItems[i];
         moduleNameToQueue[item.name] = i;
     }
 
@@ -538,67 +534,13 @@ std::vector<ModuleName> Frontend::checkQueuedModules(
         };
     }
 
-    std::mutex mtx;
-    std::condition_variable cv;
-    std::vector<size_t> readyQueueItems;
+    state->executeTask = executeTask;
+    state->remaining = state->buildQueueItems.size();
 
-    size_t processing = 0;
-    size_t remaining = buildQueueItems.size();
-
-    auto itemTask = [&](size_t i)
+    // Record dependencies between modules
+    for (size_t i = 0; i < state->buildQueueItems.size(); i++)
     {
-        BuildQueueItem& item = buildQueueItems[i];
-
-        try
-        {
-            checkBuildQueueItem(item);
-        }
-        catch (...)
-        {
-            item.exception = std::current_exception();
-        }
-
-        {
-            std::unique_lock guard(mtx);
-            readyQueueItems.push_back(i);
-        }
-
-        cv.notify_one();
-    };
-
-    auto sendItemTask = [&](size_t i)
-    {
-        BuildQueueItem& item = buildQueueItems[i];
-
-        item.processing = true;
-        processing++;
-
-        executeTask(
-            [&itemTask, i]()
-            {
-                itemTask(i);
-            }
-        );
-    };
-
-    auto sendCycleItemTask = [&]
-    {
-        for (size_t i = 0; i < buildQueueItems.size(); i++)
-        {
-            BuildQueueItem& item = buildQueueItems[i];
-
-            if (!item.processing)
-            {
-                sendItemTask(i);
-                break;
-            }
-        }
-    };
-
-    // In a first pass, check modules that have no dependencies and record info of those modules that wait
-    for (size_t i = 0; i < buildQueueItems.size(); i++)
-    {
-        BuildQueueItem& item = buildQueueItems[i];
+        BuildQueueItem& item = state->buildQueueItems[i];
 
         for (const ModuleName& dep : item.sourceNode->requireSet)
         {
@@ -608,41 +550,45 @@ std::vector<ModuleName> Frontend::checkQueuedModules(
                 {
                     item.dirtyDependencies++;
 
-                    buildQueueItems[moduleNameToQueue[dep]].reverseDeps.push_back(i);
+                    state->buildQueueItems[moduleNameToQueue[dep]].reverseDeps.push_back(i);
                 }
             }
         }
-
-        if (item.dirtyDependencies == 0)
-            sendItemTask(i);
     }
 
-    // Not a single item was found, a cycle in the graph was hit
-    if (processing == 0)
-        sendCycleItemTask();
+    // In the first pass, check all modules with no pending dependencies
+    for (size_t i = 0; i < state->buildQueueItems.size(); i++)
+    {
+        if (state->buildQueueItems[i].dirtyDependencies == 0)
+            sendQueueItemTask(state, i);
+    }
+
+    // If not a single item was found, a cycle in the graph was hit
+    if (state->processing == 0)
+        sendQueueCycleItemTask(state);
 
     std::vector<size_t> nextItems;
     std::optional<size_t> itemWithException;
     bool cancelled = false;
 
-    while (remaining != 0)
+    while (state->remaining != 0)
     {
         {
-            std::unique_lock guard(mtx);
+            std::unique_lock guard(state->mtx);
 
             // If nothing is ready yet, wait
-            cv.wait(
+            state->cv.wait(
                 guard,
-                [&readyQueueItems]
+                [state]
                 {
-                    return !readyQueueItems.empty();
+                    return !state->readyQueueItems.empty();
                 }
             );
 
             // Handle checked items
-            for (size_t i : readyQueueItems)
+            for (size_t i : state->readyQueueItems)
             {
-                const BuildQueueItem& item = buildQueueItems[i];
+                const BuildQueueItem& item = state->buildQueueItems[i];
 
                 // If exception was thrown, stop adding new items and wait for processing items to complete
                 if (item.exception)
@@ -659,7 +605,7 @@ std::vector<ModuleName> Frontend::checkQueuedModules(
                 // Notify items that were waiting for this dependency
                 for (size_t reverseDep : item.reverseDeps)
                 {
-                    BuildQueueItem& reverseDepItem = buildQueueItems[reverseDep];
+                    BuildQueueItem& reverseDepItem = state->buildQueueItems[reverseDep];
 
                     LUAU_ASSERT(reverseDepItem.dirtyDependencies != 0);
                     reverseDepItem.dirtyDependencies--;
@@ -670,26 +616,26 @@ std::vector<ModuleName> Frontend::checkQueuedModules(
                 }
             }
 
-            LUAU_ASSERT(processing >= readyQueueItems.size());
-            processing -= readyQueueItems.size();
+            LUAU_ASSERT(state->processing >= state->readyQueueItems.size());
+            state->processing -= state->readyQueueItems.size();
 
-            LUAU_ASSERT(remaining >= readyQueueItems.size());
-            remaining -= readyQueueItems.size();
-            readyQueueItems.clear();
+            LUAU_ASSERT(state->remaining >= state->readyQueueItems.size());
+            state->remaining -= state->readyQueueItems.size();
+            state->readyQueueItems.clear();
         }
 
         if (progress)
         {
-            if (!progress(buildQueueItems.size() - remaining, buildQueueItems.size()))
+            if (!progress(state->buildQueueItems.size() - state->remaining, state->buildQueueItems.size()))
                 cancelled = true;
         }
 
         // Items cannot be submitted while holding the lock
         for (size_t i : nextItems)
-            sendItemTask(i);
+            sendQueueItemTask(state, i);
         nextItems.clear();
 
-        if (processing == 0)
+        if (state->processing == 0)
         {
             // Typechecking might have been cancelled by user, don't return partial results
             if (cancelled)
@@ -697,19 +643,19 @@ std::vector<ModuleName> Frontend::checkQueuedModules(
 
             // We might have stopped because of a pending exception
             if (itemWithException)
-                recordItemResult(buildQueueItems[*itemWithException]);
+                recordItemResult(state->buildQueueItems[*itemWithException]);
         }
 
         // If we aren't done, but don't have anything processing, we hit a cycle
-        if (remaining != 0 && processing == 0)
-            sendCycleItemTask();
+        if (state->remaining != 0 && state->processing == 0)
+            sendQueueCycleItemTask(state);
     }
 
     std::vector<ModuleName> checkedModules;
-    checkedModules.reserve(buildQueueItems.size());
+    checkedModules.reserve(state->buildQueueItems.size());
 
-    for (size_t i = 0; i < buildQueueItems.size(); i++)
-        checkedModules.push_back(std::move(buildQueueItems[i].name));
+    for (size_t i = 0; i < state->buildQueueItems.size(); i++)
+        checkedModules.push_back(std::move(state->buildQueueItems[i].name));
 
     return checkedModules;
 }
@@ -822,14 +768,11 @@ bool Frontend::parseGraph(
 
             buildQueue.push_back(top->name);
 
-            if (FFlag::LuauBetterReverseDependencyTracking)
+            // at this point we know all valid dependencies are processed into SourceNodes
+            for (const ModuleName& dep : top->requireSet)
             {
-                // at this point we know all valid dependencies are processed into SourceNodes
-                for (const ModuleName& dep : top->requireSet)
-                {
-                    if (auto it = sourceNodes.find(dep); it != sourceNodes.end())
-                        it->second->dependents.insert(top->name);
-                }
+                if (auto it = sourceNodes.find(dep); it != sourceNodes.end())
+                    it->second->dependents.insert(top->name);
             }
         }
         else
@@ -1008,7 +951,7 @@ void Frontend::checkBuildQueueItem(BuildQueueItem& item)
         item.stats.timeCheck += duration;
         item.stats.filesStrict += 1;
 
-        if (DFFlag::LuauRunCustomModuleChecks && item.options.customModuleCheck)
+        if (item.options.customModuleCheck)
             item.options.customModuleCheck(sourceModule, *moduleForAutocomplete);
 
         item.module = moduleForAutocomplete;
@@ -1028,7 +971,7 @@ void Frontend::checkBuildQueueItem(BuildQueueItem& item)
     item.stats.filesStrict += mode == Mode::Strict;
     item.stats.filesNonstrict += mode == Mode::Nonstrict;
 
-    if (DFFlag::LuauRunCustomModuleChecks && item.options.customModuleCheck)
+    if (item.options.customModuleCheck)
         item.options.customModuleCheck(sourceModule, *module);
 
     if (FFlag::LuauSolverV2 && mode == Mode::NoCheck)
@@ -1060,11 +1003,8 @@ void Frontend::checkBuildQueueItem(BuildQueueItem& item)
         freeze(module->interfaceTypes);
 
         module->internalTypes.clear();
-        if (FFlag::LuauSelectivelyRetainDFGArena)
-        {
-            module->defArena.allocator.clear();
-            module->keyArena.allocator.clear();
-        }
+        module->defArena.allocator.clear();
+        module->keyArena.allocator.clear();
 
         module->astTypes.clear();
         module->astTypePacks.clear();
@@ -1118,51 +1058,35 @@ void Frontend::recordItemResult(const BuildQueueItem& item)
     if (item.exception)
         std::rethrow_exception(item.exception);
 
-    if (FFlag::LuauBetterReverseDependencyTracking)
+    bool replacedModule = false;
+    if (item.options.forAutocomplete)
     {
-        bool replacedModule = false;
-        if (item.options.forAutocomplete)
-        {
-            replacedModule = moduleResolverForAutocomplete.setModule(item.name, item.module);
-            item.sourceNode->dirtyModuleForAutocomplete = false;
-        }
-        else
-        {
-            replacedModule = moduleResolver.setModule(item.name, item.module);
-            item.sourceNode->dirtyModule = false;
-        }
-
-        if (replacedModule)
-        {
-            LUAU_TIMETRACE_SCOPE("Frontend::invalidateDependentModules", "Frontend");
-            LUAU_TIMETRACE_ARGUMENT("name", item.name.c_str());
-            traverseDependents(
-                item.name,
-                [forAutocomplete = item.options.forAutocomplete](SourceNode& sourceNode)
-                {
-                    bool traverseSubtree = !sourceNode.hasInvalidModuleDependency(forAutocomplete);
-                    sourceNode.setInvalidModuleDependency(true, forAutocomplete);
-                    return traverseSubtree;
-                }
-            );
-        }
-
-        item.sourceNode->setInvalidModuleDependency(false, item.options.forAutocomplete);
+        replacedModule = moduleResolverForAutocomplete.setModule(item.name, item.module);
+        item.sourceNode->dirtyModuleForAutocomplete = false;
     }
     else
     {
-        if (item.options.forAutocomplete)
-        {
-            moduleResolverForAutocomplete.setModule(item.name, item.module);
-            item.sourceNode->dirtyModuleForAutocomplete = false;
-        }
-        else
-        {
-            moduleResolver.setModule(item.name, item.module);
-            item.sourceNode->dirtyModule = false;
-        }
+        replacedModule = moduleResolver.setModule(item.name, item.module);
+        item.sourceNode->dirtyModule = false;
     }
 
+    if (replacedModule)
+    {
+        LUAU_TIMETRACE_SCOPE("Frontend::invalidateDependentModules", "Frontend");
+        LUAU_TIMETRACE_ARGUMENT("name", item.name.c_str());
+        traverseDependents(
+            item.name,
+            [forAutocomplete = item.options.forAutocomplete](SourceNode& sourceNode)
+            {
+                bool traverseSubtree = !sourceNode.hasInvalidModuleDependency(forAutocomplete);
+                sourceNode.setInvalidModuleDependency(true, forAutocomplete);
+                return traverseSubtree;
+            }
+        );
+    }
+
+    item.sourceNode->setInvalidModuleDependency(false, item.options.forAutocomplete);
+
     stats.timeCheck += item.stats.timeCheck;
     stats.timeLint += item.stats.timeLint;
 
@@ -1170,6 +1094,72 @@ void Frontend::recordItemResult(const BuildQueueItem& item)
     stats.filesNonstrict += item.stats.filesNonstrict;
 }
 
+void Frontend::performQueueItemTask(std::shared_ptr<BuildQueueWorkState> state, size_t itemPos)
+{
+    BuildQueueItem& item = state->buildQueueItems[itemPos];
+
+    if (DFFlag::LuauRethrowKnownExceptions)
+    {
+        try
+        {
+            checkBuildQueueItem(item);
+        }
+        catch (const Luau::InternalCompilerError&)
+        {
+            item.exception = std::current_exception();
+        }
+    }
+    else
+    {
+        try
+        {
+            checkBuildQueueItem(item);
+        }
+        catch (...)
+        {
+            item.exception = std::current_exception();
+        }
+    }
+
+    {
+        std::unique_lock guard(state->mtx);
+        state->readyQueueItems.push_back(itemPos);
+    }
+
+    state->cv.notify_one();
+}
+
+void Frontend::sendQueueItemTask(std::shared_ptr<BuildQueueWorkState> state, size_t itemPos)
+{
+    BuildQueueItem& item = state->buildQueueItems[itemPos];
+
+    LUAU_ASSERT(!item.processing);
+    item.processing = true;
+
+    state->processing++;
+
+    state->executeTask(
+        [this, state, itemPos]()
+        {
+            performQueueItemTask(state, itemPos);
+        }
+    );
+}
+
+void Frontend::sendQueueCycleItemTask(std::shared_ptr<BuildQueueWorkState> state)
+{
+    for (size_t i = 0; i < state->buildQueueItems.size(); i++)
+    {
+        BuildQueueItem& item = state->buildQueueItems[i];
+
+        if (!item.processing)
+        {
+            sendQueueItemTask(state, i);
+            break;
+        }
+    }
+}
+
 ScopePtr Frontend::getModuleEnvironment(const SourceModule& module, const Config& config, bool forAutocomplete) const
 {
     ScopePtr result;
@@ -1199,7 +1189,6 @@ ScopePtr Frontend::getModuleEnvironment(const SourceModule& module, const Config
 
 bool Frontend::allModuleDependenciesValid(const ModuleName& name, bool forAutocomplete) const
 {
-    LUAU_ASSERT(FFlag::LuauBetterReverseDependencyTracking);
     auto it = sourceNodes.find(name);
     return it != sourceNodes.end() && !it->second->hasInvalidModuleDependency(forAutocomplete);
 }
@@ -1221,72 +1210,27 @@ void Frontend::markDirty(const ModuleName& name, std::vector<ModuleName>* marked
     LUAU_TIMETRACE_SCOPE("Frontend::markDirty", "Frontend");
     LUAU_TIMETRACE_ARGUMENT("name", name.c_str());
 
-    if (FFlag::LuauBetterReverseDependencyTracking)
-    {
-        traverseDependents(
-            name,
-            [markedDirty](SourceNode& sourceNode)
-            {
-                if (markedDirty)
-                    markedDirty->push_back(sourceNode.name);
-
-                if (sourceNode.dirtySourceModule && sourceNode.dirtyModule && sourceNode.dirtyModuleForAutocomplete)
-                    return false;
-
-                sourceNode.dirtySourceModule = true;
-                sourceNode.dirtyModule = true;
-                sourceNode.dirtyModuleForAutocomplete = true;
-
-                return true;
-            }
-        );
-    }
-    else
-    {
-        if (sourceNodes.count(name) == 0)
-            return;
-
-        std::unordered_map<ModuleName, std::vector<ModuleName>> reverseDeps;
-        for (const auto& module : sourceNodes)
+    traverseDependents(
+        name,
+        [markedDirty](SourceNode& sourceNode)
         {
-            for (const auto& dep : module.second->requireSet)
-                reverseDeps[dep].push_back(module.first);
-        }
-
-        std::vector<ModuleName> queue{name};
-
-        while (!queue.empty())
-        {
-            ModuleName next = std::move(queue.back());
-            queue.pop_back();
-
-            LUAU_ASSERT(sourceNodes.count(next) > 0);
-            SourceNode& sourceNode = *sourceNodes[next];
-
             if (markedDirty)
-                markedDirty->push_back(next);
+                markedDirty->push_back(sourceNode.name);
 
             if (sourceNode.dirtySourceModule && sourceNode.dirtyModule && sourceNode.dirtyModuleForAutocomplete)
-                continue;
+                return false;
 
             sourceNode.dirtySourceModule = true;
             sourceNode.dirtyModule = true;
             sourceNode.dirtyModuleForAutocomplete = true;
 
-            if (0 == reverseDeps.count(next))
-                continue;
-
-            sourceModules.erase(next);
-
-            const std::vector<ModuleName>& dependents = reverseDeps[next];
-            queue.insert(queue.end(), dependents.begin(), dependents.end());
+            return true;
         }
-    }
+    );
 }
 
 void Frontend::traverseDependents(const ModuleName& name, std::function<bool(SourceNode&)> processSubtree)
 {
-    LUAU_ASSERT(FFlag::LuauBetterReverseDependencyTracking);
     LUAU_TIMETRACE_SCOPE("Frontend::traverseDependents", "Frontend");
 
     if (sourceNodes.count(name) == 0)
@@ -1333,6 +1277,7 @@ ModulePtr check(
     NotNull<ModuleResolver> moduleResolver,
     NotNull<FileResolver> fileResolver,
     const ScopePtr& parentScope,
+    const ScopePtr& typeFunctionScope,
     std::function<void(const ModuleName&, const ScopePtr&)> prepareModuleScope,
     FrontendOptions options,
     TypeCheckLimits limits,
@@ -1349,6 +1294,7 @@ ModulePtr check(
         moduleResolver,
         fileResolver,
         parentScope,
+        typeFunctionScope,
         std::move(prepareModuleScope),
         options,
         limits,
@@ -1359,7 +1305,7 @@ ModulePtr check(
 
 struct InternalTypeFinder : TypeOnceVisitor
 {
-    bool visit(TypeId, const ClassType&) override
+    bool visit(TypeId, const ExternType&) override
     {
         return false;
     }
@@ -1410,6 +1356,7 @@ ModulePtr check(
     NotNull<ModuleResolver> moduleResolver,
     NotNull<FileResolver> fileResolver,
     const ScopePtr& parentScope,
+    const ScopePtr& typeFunctionScope,
     std::function<void(const ModuleName&, const ScopePtr&)> prepareModuleScope,
     FrontendOptions options,
     TypeCheckLimits limits,
@@ -1422,8 +1369,7 @@ ModulePtr check(
     LUAU_TIMETRACE_ARGUMENT("name", sourceModule.humanReadableName.c_str());
 
     ModulePtr result = std::make_shared<Module>();
-    if (FFlag::LuauStoreSolverTypeOnModule)
-        result->checkedInNewSolver = true;
+    result->checkedInNewSolver = true;
     result->name = sourceModule.name;
     result->humanReadableName = sourceModule.humanReadableName;
     result->mode = mode;
@@ -1431,6 +1377,7 @@ ModulePtr check(
     result->interfaceTypes.owningModule = result.get();
     result->allocator = sourceModule.allocator;
     result->names = sourceModule.names;
+    result->root = sourceModule.root;
 
     iceHandler->moduleName = sourceModule.name;
 
@@ -1455,7 +1402,7 @@ ModulePtr check(
     SimplifierPtr simplifier = newSimplifier(NotNull{&result->internalTypes}, builtinTypes);
     TypeFunctionRuntime typeFunctionRuntime{iceHandler, NotNull{&limits}};
 
-    typeFunctionRuntime.allowEvaluation = sourceModule.parseErrors.empty();
+    typeFunctionRuntime.allowEvaluation = FFlag::LuauTypeFunResultInAutocomplete || sourceModule.parseErrors.empty();
 
     ConstraintGenerator cg{
         result,
@@ -1466,36 +1413,66 @@ ModulePtr check(
         builtinTypes,
         iceHandler,
         parentScope,
+        typeFunctionScope,
         std::move(prepareModuleScope),
         logger.get(),
         NotNull{&dfg},
         requireCycles
     };
 
-    cg.visitModuleRoot(sourceModule.root);
-    result->errors = std::move(cg.errors);
+    // FIXME: Delete this flag when clipping FFlag::DebugLuauGreedyGeneralization.
+    //
+    // This optional<> only exists so that we can run one constructor when the flag
+    // is set, and another when it is unset.
+    std::optional<ConstraintSolver> cs;
 
-    ConstraintSolver cs{
-        NotNull{&normalizer},
-        NotNull{simplifier.get()},
-        NotNull{&typeFunctionRuntime},
-        NotNull(cg.rootScope),
-        borrowConstraints(cg.constraints),
-        NotNull{&cg.scopeToFunction},
-        result->name,
-        moduleResolver,
-        requireCycles,
-        logger.get(),
-        NotNull{&dfg},
-        limits
-    };
+    if (FFlag::DebugLuauGreedyGeneralization)
+    {
+        ConstraintSet constraintSet = cg.run(sourceModule.root);
+        result->errors = std::move(constraintSet.errors);
+
+        cs.emplace(
+            NotNull{&normalizer},
+            NotNull{simplifier.get()},
+            NotNull{&typeFunctionRuntime},
+            result->name,
+            moduleResolver,
+            requireCycles,
+            logger.get(),
+            NotNull{&dfg},
+            limits,
+            std::move(constraintSet)
+        );
+    }
+    else
+    {
+        cg.visitModuleRoot(sourceModule.root);
+        result->errors = std::move(cg.errors);
+
+        cs.emplace(
+            NotNull{&normalizer},
+            NotNull{simplifier.get()},
+            NotNull{&typeFunctionRuntime},
+            NotNull(cg.rootScope),
+            borrowConstraints(cg.constraints),
+            NotNull{&cg.scopeToFunction},
+            result->name,
+            moduleResolver,
+            requireCycles,
+            logger.get(),
+            NotNull{&dfg},
+            limits
+        );
+    }
+
+    LUAU_ASSERT(bool(cs));
 
     if (options.randomizeConstraintResolutionSeed)
-        cs.randomize(*options.randomizeConstraintResolutionSeed);
+        cs->randomize(*options.randomizeConstraintResolutionSeed);
 
     try
     {
-        cs.run();
+        cs->run();
     }
     catch (const TimeLimitError&)
     {
@@ -1515,12 +1492,12 @@ ModulePtr check(
             printf("%s\n", output.c_str());
     }
 
-    for (TypeError& e : cs.errors)
+    for (TypeError& e : cs->errors)
         result->errors.emplace_back(std::move(e));
 
     result->scopes = std::move(cg.scopes);
     result->type = sourceModule.type;
-    result->upperBoundContributors = std::move(cs.upperBoundContributors);
+    result->upperBoundContributors = std::move(cs->upperBoundContributors);
 
     if (result->timeout || result->cancelled)
     {
@@ -1648,6 +1625,7 @@ ModulePtr Frontend::check(
                 NotNull{forAutocomplete ? &moduleResolverForAutocomplete : &moduleResolver},
                 NotNull{fileResolver},
                 environmentScope ? *environmentScope : globals.globalScope,
+                globals.globalTypeFunctionScope,
                 prepareModuleScopeWrap,
                 options,
                 typeCheckLimits,
@@ -1746,14 +1724,11 @@ std::pair<SourceNode*, SourceModule*> Frontend::getSourceNode(const ModuleName&
     sourceNode->name = sourceModule->name;
     sourceNode->humanReadableName = sourceModule->humanReadableName;
 
-    if (FFlag::LuauBetterReverseDependencyTracking)
+    // clear all prior dependents. we will re-add them after parsing the rest of the graph
+    for (const auto& [moduleName, _] : sourceNode->requireLocations)
     {
-        // clear all prior dependents. we will re-add them after parsing the rest of the graph
-        for (const auto& [moduleName, _] : sourceNode->requireLocations)
-        {
-            if (auto depIt = sourceNodes.find(moduleName); depIt != sourceNodes.end())
-                depIt->second->dependents.erase(sourceNode->name);
-        }
+        if (auto depIt = sourceNodes.find(moduleName); depIt != sourceNodes.end())
+            depIt->second->dependents.erase(sourceNode->name);
     }
 
     sourceNode->requireSet.clear();
@@ -1881,17 +1856,9 @@ bool FrontendModuleResolver::setModule(const ModuleName& moduleName, ModulePtr m
 {
     std::scoped_lock lock(moduleMutex);
 
-    if (FFlag::LuauBetterReverseDependencyTracking)
-    {
-        bool replaced = modules.count(moduleName) > 0;
-        modules[moduleName] = std::move(module);
-        return replaced;
-    }
-    else
-    {
-        modules[moduleName] = std::move(module);
-        return false;
-    }
+    bool replaced = modules.count(moduleName) > 0;
+    modules[moduleName] = std::move(module);
+    return replaced;
 }
 
 void FrontendModuleResolver::clearModules()

Analysis/src/GlobalTypes.cpp

@@ -9,6 +9,7 @@ GlobalTypes::GlobalTypes(NotNull<BuiltinTypes> builtinTypes)
     : builtinTypes(builtinTypes)
 {
     globalScope = std::make_shared<Scope>(globalTypes.addTypePack(TypePackVar{FreeTypePack{TypeLevel{}}}));
+    globalTypeFunctionScope = std::make_shared<Scope>(globalTypes.addTypePack(TypePackVar{FreeTypePack{TypeLevel{}}}));
 
     globalScope->addBuiltinTypeBinding("any", TypeFun{{}, builtinTypes->anyType});
     globalScope->addBuiltinTypeBinding("nil", TypeFun{{}, builtinTypes->nilType});

Analysis/src/InferPolarity.cpp

@@ -0,0 +1,169 @@
+// This file is part of the Luau programming language and is licensed under MIT License; see LICENSE.txt for details
+
+#include "Luau/DenseHash.h"
+#include "Luau/Polarity.h"
+#include "Luau/Scope.h"
+#include "Luau/VisitType.h"
+
+LUAU_FASTFLAG(LuauNonReentrantGeneralization2)
+
+namespace Luau
+{
+
+struct InferPolarity : TypeVisitor
+{
+    NotNull<TypeArena> arena;
+    NotNull<Scope> scope;
+
+    DenseHashMap<TypeId, Polarity> types{nullptr};
+    DenseHashMap<TypePackId, Polarity> packs{nullptr};
+
+    Polarity polarity = Polarity::Positive;
+
+    explicit InferPolarity(NotNull<TypeArena> arena, NotNull<Scope> scope)
+        : arena(arena)
+        , scope(scope)
+    {
+    }
+
+    void flip()
+    {
+        polarity = invert(polarity);
+    }
+
+    bool visit(TypeId ty, const GenericType& gt) override
+    {
+        if (ty->owningArena != arena)
+            return false;
+
+        if (subsumes(scope, gt.scope))
+            types[ty] |= polarity;
+
+        return false;
+    }
+
+    bool visit(TypeId ty, const TableType& tt) override
+    {
+        if (ty->owningArena != arena)
+            return false;
+
+        const Polarity p = polarity;
+        for (const auto& [name, prop] : tt.props)
+        {
+            if (prop.isShared())
+            {
+                polarity = Polarity::Mixed;
+                traverse(prop.type());
+            }
+            else if (prop.isReadOnly())
+            {
+                polarity = p;
+                traverse(*prop.readTy);
+            }
+            else if (prop.isWriteOnly())
+            {
+                polarity = invert(p);
+                traverse(*prop.writeTy);
+            }
+            else
+                LUAU_ASSERT(!"Unreachable");
+        }
+
+        if (tt.indexer)
+        {
+            polarity = Polarity::Mixed;
+            traverse(tt.indexer->indexType);
+            traverse(tt.indexer->indexResultType);
+        }
+
+        polarity = p;
+
+        return false;
+    }
+
+    bool visit(TypeId ty, const FunctionType& ft) override
+    {
+        if (ty->owningArena != arena)
+            return false;
+
+        const Polarity p = polarity;
+
+        polarity = Polarity::Positive;
+
+        // If these types actually occur within the function signature, their
+        // polarity will be overwritten. If not, we infer that they are phantom
+        // types.
+        for (TypeId generic : ft.generics)
+        {
+            generic = follow(generic);
+            const auto gen = get<GenericType>(generic);
+            if (gen && subsumes(scope, gen->scope))
+                types[generic] = Polarity::None;
+        }
+        for (TypePackId genericPack : ft.genericPacks)
+        {
+            genericPack = follow(genericPack);
+            const auto gen = get<GenericTypePack>(genericPack);
+            if (gen && subsumes(scope, gen->scope))
+                packs[genericPack] = Polarity::None;
+        }
+
+        flip();
+        traverse(ft.argTypes);
+        flip();
+        traverse(ft.retTypes);
+
+        polarity = p;
+
+        return false;
+    }
+
+    bool visit(TypeId, const ExternType&) override
+    {
+        return false;
+    }
+
+    bool visit(TypePackId tp, const GenericTypePack& gtp) override
+    {
+        packs[tp] |= polarity;
+        return false;
+    }
+};
+
+template<typename TID>
+static void inferGenericPolarities_(NotNull<TypeArena> arena, NotNull<Scope> scope, TID ty)
+{
+    if (!FFlag::LuauNonReentrantGeneralization2)
+        return;
+
+    InferPolarity infer{arena, scope};
+    infer.traverse(ty);
+
+    for (const auto& [ty, polarity] : infer.types)
+    {
+        auto gt = getMutable<GenericType>(ty);
+        LUAU_ASSERT(gt);
+        gt->polarity = polarity;
+    }
+
+    for (const auto& [tp, polarity] : infer.packs)
+    {
+        if (tp->owningArena != arena)
+            continue;
+        auto gp = getMutable<GenericTypePack>(tp);
+        LUAU_ASSERT(gp);
+        gp->polarity = polarity;
+    }
+}
+
+void inferGenericPolarities(NotNull<TypeArena> arena, NotNull<Scope> scope, TypeId ty)
+{
+    inferGenericPolarities_(arena, scope, ty);
+}
+
+void inferGenericPolarities(NotNull<TypeArena> arena, NotNull<Scope> scope, TypePackId tp)
+{
+    inferGenericPolarities_(arena, scope, tp);
+}
+
+} // namespace Luau

Analysis/src/Instantiation.cpp

@@ -11,7 +11,6 @@
 #include <algorithm>
 
 LUAU_FASTFLAG(LuauSolverV2)
-LUAU_FASTFLAG(LuauFreeTypesMustHaveBounds)
 
 namespace Luau
 {
@@ -50,7 +49,7 @@ bool Instantiation::ignoreChildren(TypeId ty)
 {
     if (log->getMutable<FunctionType>(ty))
         return true;
-    else if (get<ClassType>(ty))
+    else if (get<ExternType>(ty))
         return true;
     else
         return false;
@@ -61,7 +60,7 @@ TypeId Instantiation::clean(TypeId ty)
     const FunctionType* ftv = log->getMutable<FunctionType>(ty);
     LUAU_ASSERT(ftv);
 
-    FunctionType clone = FunctionType{level, scope, ftv->argTypes, ftv->retTypes, ftv->definition, ftv->hasSelf};
+    FunctionType clone = FunctionType{level, ftv->argTypes, ftv->retTypes, ftv->definition, ftv->hasSelf};
     clone.magic = ftv->magic;
     clone.tags = ftv->tags;
     clone.argNames = ftv->argNames;
@@ -120,7 +119,7 @@ bool ReplaceGenerics::ignoreChildren(TypeId ty)
         // whenever we quantify, so the vectors overlap if and only if they are equal.
         return (!generics.empty() || !genericPacks.empty()) && (ftv->generics == generics) && (ftv->genericPacks == genericPacks);
     }
-    else if (get<ClassType>(ty))
+    else if (get<ExternType>(ty))
         return true;
     else
     {
@@ -164,7 +163,7 @@ TypeId ReplaceGenerics::clean(TypeId ty)
     }
     else
     {
-        return FFlag::LuauFreeTypesMustHaveBounds ? arena->freshType(builtinTypes, scope, level) : addType(FreeType{scope, level});
+        return arena->freshType(builtinTypes, scope, level);
     }
 }
 

Analysis/src/Instantiation2.cpp

@@ -6,7 +6,7 @@ namespace Luau
 
 bool Instantiation2::ignoreChildren(TypeId ty)
 {
-    if (get<ClassType>(ty))
+    if (get<ExternType>(ty))
         return true;
 
     if (auto ftv = get<FunctionType>(ty))

Analysis/src/IostreamHelpers.cpp

@@ -193,8 +193,8 @@ static void errorToString(std::ostream& stream, const T& err)
         stream << "NormalizationTooComplex { }";
     else if constexpr (std::is_same_v<T, TypePackMismatch>)
         stream << "TypePackMismatch { wanted = '" + toString(err.wantedTp) + "', given = '" + toString(err.givenTp) + "' }";
-    else if constexpr (std::is_same_v<T, DynamicPropertyLookupOnClassesUnsafe>)
-        stream << "DynamicPropertyLookupOnClassesUnsafe { " << toString(err.ty) << " }";
+    else if constexpr (std::is_same_v<T, DynamicPropertyLookupOnExternTypesUnsafe>)
+        stream << "DynamicPropertyLookupOnExternTypesUnsafe { " << toString(err.ty) << " }";
     else if constexpr (std::is_same_v<T, UninhabitedTypeFunction>)
         stream << "UninhabitedTypeFunction { " << toString(err.ty) << " }";
     else if constexpr (std::is_same_v<T, ExplicitFunctionAnnotationRecommended>)
@@ -229,6 +229,8 @@ static void errorToString(std::ostream& stream, const T& err)
         stream << "UnexpectedTypePackInSubtyping {  tp = '" + toString(err.tp) + "' }";
     else if constexpr (std::is_same_v<T, UserDefinedTypeFunctionError>)
         stream << "UserDefinedTypeFunctionError { " << err.message << " }";
+    else if constexpr (std::is_same_v<T, ReservedIdentifier>)
+        stream << "ReservedIdentifier { " << err.name << " }";
     else if constexpr (std::is_same_v<T, CannotAssignToNever>)
     {
         stream << "CannotAssignToNever { rvalueType = '" << toString(err.rhsType) << "', reason = '" << err.reason << "', cause = { ";

Analysis/src/Linter.cpp

@@ -19,6 +19,9 @@ LUAU_FASTFLAG(LuauSolverV2)
 LUAU_FASTFLAG(LuauAttribute)
 LUAU_FASTFLAGVARIABLE(LintRedundantNativeAttribute)
 
+LUAU_FASTFLAG(LuauDeprecatedAttribute)
+LUAU_FASTFLAG(LuauStoreReturnTypesAsPackOnAst)
+
 namespace Luau
 {
 
@@ -906,6 +909,11 @@ private:
         return true;
     }
 
+    bool visit(AstTypePack* node) override
+    {
+        return FFlag::LuauStoreReturnTypesAsPackOnAst;
+    }
+
     bool visit(AstTypeReference* node) override
     {
         if (!node->prefix)
@@ -1968,6 +1976,11 @@ private:
         return true;
     }
 
+    bool visit(AstTypePack* node) override
+    {
+        return FFlag::LuauStoreReturnTypesAsPackOnAst;
+    }
+
     bool visit(AstTypeTable* node) override
     {
         if (FFlag::LuauSolverV2)
@@ -2280,6 +2293,57 @@ private:
     {
     }
 
+    bool visit(AstExprLocal* node) override
+    {
+        if (FFlag::LuauDeprecatedAttribute)
+        {
+
+            const FunctionType* fty = getFunctionType(node);
+            bool shouldReport = fty && fty->isDeprecatedFunction && !inScope(fty);
+
+            if (shouldReport)
+                report(node->location, node->local->name.value);
+        }
+
+        return true;
+    }
+
+    bool visit(AstExprGlobal* node) override
+    {
+        if (FFlag::LuauDeprecatedAttribute)
+        {
+            const FunctionType* fty = getFunctionType(node);
+            bool shouldReport = fty && fty->isDeprecatedFunction && !inScope(fty);
+
+            if (shouldReport)
+                report(node->location, node->name.value);
+        }
+
+        return true;
+    }
+
+    bool visit(AstStatLocalFunction* node) override
+    {
+        if (FFlag::LuauDeprecatedAttribute)
+        {
+            check(node->func);
+            return false;
+        }
+        else
+            return true;
+    }
+
+    bool visit(AstStatFunction* node) override
+    {
+        if (FFlag::LuauDeprecatedAttribute)
+        {
+            check(node->func);
+            return false;
+        }
+        else
+            return true;
+    }
+
     bool visit(AstExprIndexName* node) override
     {
         if (std::optional<TypeId> ty = context->getType(node->expr))
@@ -2319,24 +2383,65 @@ private:
 
     void check(AstExprIndexName* node, TypeId ty)
     {
-        if (const ClassType* cty = get<ClassType>(ty))
+        if (const ExternType* cty = get<ExternType>(ty))
         {
-            const Property* prop = lookupClassProp(cty, node->index.value);
+            const Property* prop = lookupExternTypeProp(cty, node->index.value);
 
             if (prop && prop->deprecated)
                 report(node->location, *prop, cty->name.c_str(), node->index.value);
+            else if (FFlag::LuauDeprecatedAttribute && prop)
+            {
+                if (std::optional<TypeId> ty = prop->readTy)
+                {
+                    const FunctionType* fty = get<FunctionType>(follow(ty));
+                    bool shouldReport = fty && fty->isDeprecatedFunction && !inScope(fty);
+
+                    if (shouldReport)
+                    {
+                        const char* className = nullptr;
+                        if (AstExprGlobal* global = node->expr->as<AstExprGlobal>())
+                            className = global->name.value;
+
+                        const char* functionName = node->index.value;
+
+                        report(node->location, className, functionName);
+                    }
+                }
+            }
         }
         else if (const TableType* tty = get<TableType>(ty))
         {
             auto prop = tty->props.find(node->index.value);
 
-            if (prop != tty->props.end() && prop->second.deprecated)
+            if (prop != tty->props.end())
             {
-                // strip synthetic typeof() for builtin tables
-                if (tty->name && tty->name->compare(0, 7, "typeof(") == 0 && tty->name->back() == ')')
-                    report(node->location, prop->second, tty->name->substr(7, tty->name->length() - 8).c_str(), node->index.value);
-                else
-                    report(node->location, prop->second, tty->name ? tty->name->c_str() : nullptr, node->index.value);
+                if (prop->second.deprecated)
+                {
+                    // strip synthetic typeof() for builtin tables
+                    if (tty->name && tty->name->compare(0, 7, "typeof(") == 0 && tty->name->back() == ')')
+                        report(node->location, prop->second, tty->name->substr(7, tty->name->length() - 8).c_str(), node->index.value);
+                    else
+                        report(node->location, prop->second, tty->name ? tty->name->c_str() : nullptr, node->index.value);
+                }
+                else if (FFlag::LuauDeprecatedAttribute)
+                {
+                    if (std::optional<TypeId> ty = prop->second.readTy)
+                    {
+                        const FunctionType* fty = get<FunctionType>(follow(ty));
+                        bool shouldReport = fty && fty->isDeprecatedFunction && !inScope(fty);
+
+                        if (shouldReport)
+                        {
+                            const char* className = nullptr;
+                            if (AstExprGlobal* global = node->expr->as<AstExprGlobal>())
+                                className = global->name.value;
+
+                            const char* functionName = node->index.value;
+
+                            report(node->location, className, functionName);
+                        }
+                    }
+                }
             }
         }
     }
@@ -2355,6 +2460,26 @@ private:
         }
     }
 
+    void check(AstExprFunction* func)
+    {
+        LUAU_ASSERT(FFlag::LuauDeprecatedAttribute);
+        LUAU_ASSERT(func);
+
+        const FunctionType* fty = getFunctionType(func);
+        bool isDeprecated = fty && fty->isDeprecatedFunction;
+
+        // If a function is deprecated, we don't want to flag its recursive uses.
+        // So we push it on a stack while its body is being analyzed.
+        // When a deprecated function is used, we check the stack to ensure that we are not inside that function.
+        if (isDeprecated)
+            pushScope(fty);
+
+        func->visit(this);
+
+        if (isDeprecated)
+            popScope(fty);
+    }
+
     void report(const Location& location, const Property& prop, const char* container, const char* field)
     {
         std::string suggestion = prop.deprecatedSuggestion.empty() ? "" : format(", use '%s' instead", prop.deprecatedSuggestion.c_str());
@@ -2364,6 +2489,63 @@ private:
         else
             emitWarning(*context, LintWarning::Code_DeprecatedApi, location, "Member '%s' is deprecated%s", field, suggestion.c_str());
     }
+
+    void report(const Location& location, const char* tableName, const char* functionName)
+    {
+        LUAU_ASSERT(FFlag::LuauDeprecatedAttribute);
+
+        if (tableName)
+            emitWarning(*context, LintWarning::Code_DeprecatedApi, location, "Member '%s.%s' is deprecated", tableName, functionName);
+        else
+            emitWarning(*context, LintWarning::Code_DeprecatedApi, location, "Member '%s' is deprecated", functionName);
+    }
+
+    void report(const Location& location, const char* functionName)
+    {
+        LUAU_ASSERT(FFlag::LuauDeprecatedAttribute);
+
+        emitWarning(*context, LintWarning::Code_DeprecatedApi, location, "Function '%s' is deprecated", functionName);
+    }
+
+    std::vector<const FunctionType*> functionTypeScopeStack;
+
+    void pushScope(const FunctionType* fty)
+    {
+        LUAU_ASSERT(FFlag::LuauDeprecatedAttribute);
+        LUAU_ASSERT(fty);
+
+        functionTypeScopeStack.push_back(fty);
+    }
+
+    void popScope(const FunctionType* fty)
+    {
+        LUAU_ASSERT(FFlag::LuauDeprecatedAttribute);
+        LUAU_ASSERT(fty);
+
+        LUAU_ASSERT(fty == functionTypeScopeStack.back());
+        functionTypeScopeStack.pop_back();
+    }
+
+    bool inScope(const FunctionType* fty) const
+    {
+        LUAU_ASSERT(FFlag::LuauDeprecatedAttribute);
+        LUAU_ASSERT(fty);
+
+        return std::find(functionTypeScopeStack.begin(), functionTypeScopeStack.end(), fty) != functionTypeScopeStack.end();
+    }
+
+    const FunctionType* getFunctionType(AstExpr* node)
+    {
+        LUAU_ASSERT(FFlag::LuauDeprecatedAttribute);
+
+        std::optional<TypeId> ty = context->getType(node);
+        if (!ty)
+            return nullptr;
+
+        const FunctionType* fty = get<FunctionType>(follow(ty));
+
+        return fty;
+    }
 };
 
 class LintTableOperations : AstVisitor

Analysis/src/Module.cpp

@@ -15,12 +15,12 @@
 #include <algorithm>
 
 LUAU_FASTFLAG(LuauSolverV2);
-LUAU_FASTFLAGVARIABLE(LuauIncrementalAutocompleteCommentDetection)
+LUAU_FASTFLAG(LuauRetainDefinitionAliasLocations)
 
 namespace Luau
 {
 
-static void defaultLogLuau(std::string_view input)
+static void defaultLogLuau(std::string_view context, std::string_view input)
 {
     // The default is to do nothing because we don't want to mess with
     // the xml parsing done by the dcr script.
@@ -38,21 +38,6 @@ void resetLogLuauProc()
     logLuau = &defaultLogLuau;
 }
 
-
-
-static bool contains_DEPRECATED(Position pos, Comment comment)
-{
-    if (comment.location.contains(pos))
-        return true;
-    else if (comment.type == Lexeme::BrokenComment && comment.location.begin <= pos) // Broken comments are broken specifically because they don't
-                                                                                     // have an end
-        return true;
-    else if (comment.type == Lexeme::Comment && comment.location.end == pos)
-        return true;
-    else
-        return false;
-}
-
 static bool contains(Position pos, Comment comment)
 {
     if (comment.location.contains(pos))
@@ -76,11 +61,8 @@ bool isWithinComment(const std::vector<Comment>& commentLocations, Position pos)
         Comment{Lexeme::Comment, Location{pos, pos}},
         [](const Comment& a, const Comment& b)
         {
-            if (FFlag::LuauIncrementalAutocompleteCommentDetection)
-            {
-                if (a.type == Lexeme::Comment)
-                    return a.location.end.line < b.location.end.line;
-            }
+            if (a.type == Lexeme::Comment)
+                return a.location.end.line < b.location.end.line;
             return a.location.end < b.location.end;
         }
     );
@@ -88,7 +70,7 @@ bool isWithinComment(const std::vector<Comment>& commentLocations, Position pos)
     if (iter == commentLocations.end())
         return false;
 
-    if (FFlag::LuauIncrementalAutocompleteCommentDetection ? contains(pos, *iter) : contains_DEPRECATED(pos, *iter))
+    if (contains(pos, *iter))
         return true;
 
     // Due to the nature of std::lower_bound, it is possible that iter points at a comment that ends
@@ -172,8 +154,6 @@ struct ClonePublicInterface : Substitution
             }
 
             ftv->level = TypeLevel{0, 0};
-            if (FFlag::LuauSolverV2)
-                ftv->scope = nullptr;
         }
         else if (TableType* ttv = getMutable<TableType>(result))
         {
@@ -285,7 +265,10 @@ struct ClonePublicInterface : Substitution
 
         TypeId type = cloneType(tf.type);
 
-        return TypeFun{typeParams, typePackParams, type};
+        if (FFlag::LuauRetainDefinitionAliasLocations)
+            return TypeFun{typeParams, typePackParams, type, tf.definitionLocation};
+        else
+            return TypeFun{typeParams, typePackParams, type};
     }
 };
 

Analysis/src/NonStrictTypeChecker.cpp

@@ -2,6 +2,7 @@
 #include "Luau/NonStrictTypeChecker.h"
 
 #include "Luau/Ast.h"
+#include "Luau/AstQuery.h"
 #include "Luau/Common.h"
 #include "Luau/Simplify.h"
 #include "Luau/Type.h"
@@ -19,9 +20,12 @@
 #include <iostream>
 #include <iterator>
 
-LUAU_FASTFLAG(LuauFreeTypesMustHaveBounds)
+LUAU_FASTFLAG(DebugLuauMagicTypes)
+
 LUAU_FASTFLAGVARIABLE(LuauNonStrictVisitorImprovements)
 LUAU_FASTFLAGVARIABLE(LuauNewNonStrictWarnOnUnknownGlobals)
+LUAU_FASTFLAGVARIABLE(LuauNewNonStrictVisitTypes2)
+LUAU_FASTFLAG(LuauStoreReturnTypesAsPackOnAst)
 
 namespace Luau
 {
@@ -213,7 +217,7 @@ struct NonStrictTypeChecker
             return *fst;
         else if (auto ftp = get<FreeTypePack>(pack))
         {
-            TypeId result = FFlag::LuauFreeTypesMustHaveBounds ? arena->freshType(builtinTypes, ftp->scope) : arena->addType(FreeType{ftp->scope});
+            TypeId result = arena->freshType(builtinTypes, ftp->scope);
             TypePackId freeTail = arena->addTypePack(FreeTypePack{ftp->scope});
 
             TypePack* resultPack = emplaceTypePack<TypePack>(asMutable(pack));
@@ -307,7 +311,7 @@ struct NonStrictTypeChecker
             return visit(s);
         else if (auto s = stat->as<AstStatDeclareGlobal>())
             return visit(s);
-        else if (auto s = stat->as<AstStatDeclareClass>())
+        else if (auto s = stat->as<AstStatDeclareExternType>())
             return visit(s);
         else if (auto s = stat->as<AstStatError>())
             return visit(s);
@@ -333,7 +337,12 @@ struct NonStrictTypeChecker
                 // local x ; B generates the context of B without x
                 visit(local);
                 for (auto local : local->vars)
+                {
                     ctx.remove(dfg->getDef(local));
+
+                    if (FFlag::LuauNewNonStrictVisitTypes2)
+                        visit(local->annotation);
+                }
             }
             else
                 ctx = NonStrictContext::disjunction(builtinTypes, arena, visit(stat), ctx);
@@ -418,6 +427,9 @@ struct NonStrictTypeChecker
 
     NonStrictContext visit(AstStatFor* forStatement)
     {
+        if (FFlag::LuauNewNonStrictVisitTypes2)
+            visit(forStatement->var->annotation);
+
         if (FFlag::LuauNonStrictVisitorImprovements)
         {
             // TODO: throwing out context based on same principle as existing code?
@@ -437,6 +449,12 @@ struct NonStrictTypeChecker
 
     NonStrictContext visit(AstStatForIn* forInStatement)
     {
+        if (FFlag::LuauNewNonStrictVisitTypes2)
+        {
+            for (auto var : forInStatement->vars)
+                visit(var->annotation);
+        }
+
         if (FFlag::LuauNonStrictVisitorImprovements)
         {
             for (AstExpr* rhs : forInStatement->values)
@@ -485,6 +503,12 @@ struct NonStrictTypeChecker
 
     NonStrictContext visit(AstStatTypeAlias* typeAlias)
     {
+        if (FFlag::LuauNewNonStrictVisitTypes2)
+        {
+            visitGenerics(typeAlias->generics, typeAlias->genericPacks);
+            visit(typeAlias->type);
+        }
+
         return {};
     }
 
@@ -495,16 +519,38 @@ struct NonStrictTypeChecker
 
     NonStrictContext visit(AstStatDeclareFunction* declFn)
     {
+        if (FFlag::LuauNewNonStrictVisitTypes2)
+        {
+            visitGenerics(declFn->generics, declFn->genericPacks);
+            visit(declFn->params);
+            visit(declFn->retTypes);
+        }
+
         return {};
     }
 
     NonStrictContext visit(AstStatDeclareGlobal* declGlobal)
     {
+        if (FFlag::LuauNewNonStrictVisitTypes2)
+            visit(declGlobal->type);
+
         return {};
     }
 
-    NonStrictContext visit(AstStatDeclareClass* declClass)
+    NonStrictContext visit(AstStatDeclareExternType* declClass)
     {
+        if (FFlag::LuauNewNonStrictVisitTypes2)
+        {
+            if (declClass->indexer)
+            {
+                visit(declClass->indexer->indexType);
+                visit(declClass->indexer->resultType);
+            }
+
+            for (auto prop : declClass->props)
+                visit(prop.ty);
+        }
+
         return {};
     }
 
@@ -763,9 +809,32 @@ struct NonStrictTypeChecker
         for (AstLocal* local : exprFn->args)
         {
             if (std::optional<TypeId> ty = willRunTimeErrorFunctionDefinition(local, remainder))
-                reportError(NonStrictFunctionDefinitionError{exprFn->debugname.value, local->name.value, *ty}, local->location);
+            {
+                const char* debugname = exprFn->debugname.value;
+                reportError(NonStrictFunctionDefinitionError{debugname ? debugname : "", local->name.value, *ty}, local->location);
+            }
             remainder.remove(dfg->getDef(local));
+
+            if (FFlag::LuauNewNonStrictVisitTypes2)
+                visit(local->annotation);
         }
+
+        if (FFlag::LuauNewNonStrictVisitTypes2)
+        {
+            visitGenerics(exprFn->generics, exprFn->genericPacks);
+
+            if (FFlag::LuauStoreReturnTypesAsPackOnAst)
+                visit(exprFn->returnAnnotation);
+            else
+            {
+                if (exprFn->returnAnnotation_DEPRECATED)
+                    visit(*exprFn->returnAnnotation_DEPRECATED);
+            }
+
+            if (exprFn->varargAnnotation)
+                visit(exprFn->varargAnnotation);
+        }
+
         return remainder;
     }
 
@@ -806,6 +875,9 @@ struct NonStrictTypeChecker
 
     NonStrictContext visit(AstExprTypeAssertion* typeAssertion)
     {
+        if (FFlag::LuauNewNonStrictVisitTypes2)
+            visit(typeAssertion->annotation);
+
         if (FFlag::LuauNonStrictVisitorImprovements)
             return visit(typeAssertion->expr, ValueContext::RValue);
         else
@@ -842,6 +914,331 @@ struct NonStrictTypeChecker
         return {};
     }
 
+    void visit(AstType* ty)
+    {
+        LUAU_ASSERT(FFlag::LuauNewNonStrictVisitTypes2);
+
+        // If this node is `nullptr`, early exit.
+        if (!ty)
+            return;
+
+        if (auto t = ty->as<AstTypeReference>())
+            return visit(t);
+        else if (auto t = ty->as<AstTypeTable>())
+            return visit(t);
+        else if (auto t = ty->as<AstTypeFunction>())
+            return visit(t);
+        else if (auto t = ty->as<AstTypeTypeof>())
+            return visit(t);
+        else if (auto t = ty->as<AstTypeUnion>())
+            return visit(t);
+        else if (auto t = ty->as<AstTypeIntersection>())
+            return visit(t);
+        else if (auto t = ty->as<AstTypeGroup>())
+            return visit(t->type);
+    }
+
+    void visit(AstTypeReference* ty)
+    {
+        // No further validation is necessary in this case. The main logic for
+        // _luau_print is contained in lookupAnnotation.
+        if (FFlag::DebugLuauMagicTypes && ty->name == "_luau_print")
+            return;
+
+        for (const AstTypeOrPack& param : ty->parameters)
+        {
+            if (param.type)
+                visit(param.type);
+            else
+                visit(param.typePack);
+        }
+
+        Scope* scope = findInnermostScope(ty->location);
+        LUAU_ASSERT(scope);
+
+        std::optional<TypeFun> alias = ty->prefix ? scope->lookupImportedType(ty->prefix->value, ty->name.value) : scope->lookupType(ty->name.value);
+
+        if (alias.has_value())
+        {
+            size_t typesRequired = alias->typeParams.size();
+            size_t packsRequired = alias->typePackParams.size();
+
+            bool hasDefaultTypes = std::any_of(
+                alias->typeParams.begin(),
+                alias->typeParams.end(),
+                [](auto&& el)
+                {
+                    return el.defaultValue.has_value();
+                }
+            );
+
+            bool hasDefaultPacks = std::any_of(
+                alias->typePackParams.begin(),
+                alias->typePackParams.end(),
+                [](auto&& el)
+                {
+                    return el.defaultValue.has_value();
+                }
+            );
+
+            if (!ty->hasParameterList)
+            {
+                if ((!alias->typeParams.empty() && !hasDefaultTypes) || (!alias->typePackParams.empty() && !hasDefaultPacks))
+                    reportError(GenericError{"Type parameter list is required"}, ty->location);
+            }
+
+            size_t typesProvided = 0;
+            size_t extraTypes = 0;
+            size_t packsProvided = 0;
+
+            for (const AstTypeOrPack& p : ty->parameters)
+            {
+                if (p.type)
+                {
+                    if (packsProvided != 0)
+                    {
+                        reportError(GenericError{"Type parameters must come before type pack parameters"}, ty->location);
+                        continue;
+                    }
+
+                    if (typesProvided < typesRequired)
+                        typesProvided += 1;
+                    else
+                        extraTypes += 1;
+                }
+                else if (p.typePack)
+                {
+                    std::optional<TypePackId> tp = lookupPackAnnotation(p.typePack);
+                    if (!tp.has_value())
+                        continue;
+
+                    if (typesProvided < typesRequired && size(*tp) == 1 && finite(*tp) && first(*tp))
+                        typesProvided += 1;
+                    else
+                        packsProvided += 1;
+                }
+            }
+
+            if (extraTypes != 0 && packsProvided == 0)
+            {
+                // Extra types are only collected into a pack if a pack is expected
+                if (packsRequired != 0)
+                    packsProvided += 1;
+                else
+                    typesProvided += extraTypes;
+            }
+
+            for (size_t i = typesProvided; i < typesRequired; ++i)
+            {
+                if (alias->typeParams[i].defaultValue)
+                    typesProvided += 1;
+            }
+
+            for (size_t i = packsProvided; i < packsRequired; ++i)
+            {
+                if (alias->typePackParams[i].defaultValue)
+                    packsProvided += 1;
+            }
+
+            if (extraTypes == 0 && packsProvided + 1 == packsRequired)
+                packsProvided += 1;
+
+
+            if (typesProvided != typesRequired || packsProvided != packsRequired)
+            {
+                reportError(
+                    IncorrectGenericParameterCount{
+                        /* name */ ty->name.value,
+                        /* typeFun */ *alias,
+                        /* actualParameters */ typesProvided,
+                        /* actualPackParameters */ packsProvided,
+                    },
+                    ty->location
+                );
+            }
+        }
+        else
+        {
+            if (scope->lookupPack(ty->name.value))
+            {
+                reportError(
+                    SwappedGenericTypeParameter{
+                        ty->name.value,
+                        SwappedGenericTypeParameter::Kind::Type,
+                    },
+                    ty->location
+                );
+            }
+            else
+            {
+                std::string symbol = "";
+                if (ty->prefix)
+                {
+                    symbol += (*(ty->prefix)).value;
+                    symbol += ".";
+                }
+                symbol += ty->name.value;
+
+                reportError(UnknownSymbol{symbol, UnknownSymbol::Context::Type}, ty->location);
+            }
+        }
+    }
+
+    void visit(AstTypeTable* table)
+    {
+        if (table->indexer)
+        {
+            visit(table->indexer->indexType);
+            visit(table->indexer->resultType);
+        }
+
+        for (auto prop : table->props)
+            visit(prop.type);
+    }
+
+    void visit(AstTypeFunction* function)
+    {
+        visit(function->argTypes);
+        visit(function->returnTypes);
+    }
+
+    void visit(AstTypeTypeof* typeOf)
+    {
+        visit(typeOf->expr, ValueContext::RValue);
+    }
+
+    void visit(AstTypeUnion* unionType)
+    {
+        for (auto typ : unionType->types)
+            visit(typ);
+    }
+
+    void visit(AstTypeIntersection* intersectionType)
+    {
+        for (auto typ : intersectionType->types)
+            visit(typ);
+    }
+
+    void visit(AstTypeList& list)
+    {
+        for (auto typ : list.types)
+            visit(typ);
+        if (list.tailType)
+            visit(list.tailType);
+    }
+
+    void visit(AstTypePack* pack)
+    {
+        LUAU_ASSERT(FFlag::LuauNewNonStrictVisitTypes2);
+
+        // If there is no pack node, early exit.
+        if (!pack)
+            return;
+
+        if (auto p = pack->as<AstTypePackExplicit>())
+            return visit(p);
+        else if (auto p = pack->as<AstTypePackVariadic>())
+            return visit(p);
+        else if (auto p = pack->as<AstTypePackGeneric>())
+            return visit(p);
+    }
+
+    void visit(AstTypePackExplicit* tp)
+    {
+        for (AstType* type : tp->typeList.types)
+            visit(type);
+
+        if (tp->typeList.tailType)
+            visit(tp->typeList.tailType);
+    }
+
+    void visit(AstTypePackVariadic* tp)
+    {
+        visit(tp->variadicType);
+    }
+
+    void visit(AstTypePackGeneric* tp)
+    {
+        Scope* scope = findInnermostScope(tp->location);
+        LUAU_ASSERT(scope);
+
+        std::optional<TypePackId> alias = scope->lookupPack(tp->genericName.value);
+        if (!alias.has_value())
+        {
+            if (scope->lookupType(tp->genericName.value))
+            {
+                reportError(
+                    SwappedGenericTypeParameter{
+                        tp->genericName.value,
+                        SwappedGenericTypeParameter::Kind::Pack,
+                    },
+                    tp->location
+                );
+            }
+        }
+        else
+        {
+            reportError(UnknownSymbol{tp->genericName.value, UnknownSymbol::Context::Type}, tp->location);
+        }
+    }
+
+    void visitGenerics(AstArray<AstGenericType*> generics, AstArray<AstGenericTypePack*> genericPacks)
+    {
+        DenseHashSet<AstName> seen{AstName{}};
+
+        for (const auto* g : generics)
+        {
+            if (seen.contains(g->name))
+                reportError(DuplicateGenericParameter{g->name.value}, g->location);
+            else
+                seen.insert(g->name);
+
+            if (g->defaultValue)
+                visit(g->defaultValue);
+        }
+
+        for (const auto* g : genericPacks)
+        {
+            if (seen.contains(g->name))
+                reportError(DuplicateGenericParameter{g->name.value}, g->location);
+            else
+                seen.insert(g->name);
+
+            if (g->defaultValue)
+                visit(g->defaultValue);
+        }
+    }
+
+    Scope* findInnermostScope(Location location) const
+    {
+        Scope* bestScope = module->getModuleScope().get();
+
+        bool didNarrow;
+        do
+        {
+            didNarrow = false;
+            for (auto scope : bestScope->children)
+            {
+                if (scope->location.encloses(location))
+                {
+                    bestScope = scope.get();
+                    didNarrow = true;
+                    break;
+                }
+            }
+        } while (didNarrow && bestScope->children.size() > 0);
+
+        return bestScope;
+    }
+
+    std::optional<TypePackId> lookupPackAnnotation(AstTypePack* annotation) const
+    {
+        TypePackId* tp = module->astResolvedTypePacks.find(annotation);
+        if (tp != nullptr)
+            return {follow(*tp)};
+        return {};
+    }
+
     void reportError(TypeErrorData data, const Location& location)
     {
         module->errors.emplace_back(location, module->name, std::move(data));

Analysis/src/Normalize.cpp

@@ -19,9 +19,10 @@ LUAU_FASTFLAGVARIABLE(DebugLuauCheckNormalizeInvariant)
 
 LUAU_FASTINTVARIABLE(LuauNormalizeCacheLimit, 100000)
 LUAU_FASTINTVARIABLE(LuauNormalizeIntersectionLimit, 200)
+LUAU_FASTINTVARIABLE(LuauNormalizeUnionLimit, 100)
 LUAU_FASTFLAG(LuauSolverV2)
 LUAU_FASTFLAGVARIABLE(LuauFixInfiniteRecursionInNormalization)
-LUAU_FASTFLAGVARIABLE(LuauFixNormalizedIntersectionOfNegatedClass)
+LUAU_FASTFLAGVARIABLE(LuauNormalizationCatchMetatableCycles)
 
 namespace Luau
 {
@@ -248,23 +249,23 @@ bool isSubtype(const NormalizedStringType& subStr, const NormalizedStringType& s
     return true;
 }
 
-void NormalizedClassType::pushPair(TypeId ty, TypeIds negations)
+void NormalizedExternType::pushPair(TypeId ty, TypeIds negations)
 {
-    auto result = classes.insert(std::make_pair(ty, std::move(negations)));
+    auto result = externTypes.insert(std::make_pair(ty, std::move(negations)));
     if (result.second)
         ordering.push_back(ty);
-    LUAU_ASSERT(ordering.size() == classes.size());
+    LUAU_ASSERT(ordering.size() == externTypes.size());
 }
 
-void NormalizedClassType::resetToNever()
+void NormalizedExternType::resetToNever()
 {
     ordering.clear();
-    classes.clear();
+    externTypes.clear();
 }
 
-bool NormalizedClassType::isNever() const
+bool NormalizedExternType::isNever() const
 {
-    return classes.empty();
+    return externTypes.empty();
 }
 
 void NormalizedFunctionType::resetToTop()
@@ -303,17 +304,17 @@ bool NormalizedType::isUnknown() const
 
     // Otherwise, we can still be unknown!
     bool hasAllPrimitives = isPrim(booleans, PrimitiveType::Boolean) && isPrim(nils, PrimitiveType::NilType) && isNumber(numbers) &&
-                            strings.isString() && isPrim(threads, PrimitiveType::Thread) && isThread(threads);
+                            strings.isString() && isThread(threads) && isBuffer(buffers);
 
     // Check is class
-    bool isTopClass = false;
-    for (auto [t, disj] : classes.classes)
+    bool isTopExternType = false;
+    for (const auto& [t, disj] : externTypes.externTypes)
     {
-        if (auto ct = get<ClassType>(t))
+        if (auto ct = get<ExternType>(t))
         {
             if (ct->name == "class" && disj.empty())
             {
-                isTopClass = true;
+                isTopExternType = true;
                 break;
             }
         }
@@ -329,24 +330,24 @@ bool NormalizedType::isUnknown() const
         }
     }
     // any = unknown or error ==> we need to make sure we have all the unknown components, but not errors
-    return get<NeverType>(errors) && hasAllPrimitives && isTopClass && isTopTable && functions.isTop;
+    return get<NeverType>(errors) && hasAllPrimitives && isTopExternType && isTopTable && functions.isTop;
 }
 
 bool NormalizedType::isExactlyNumber() const
 {
-    return hasNumbers() && !hasTops() && !hasBooleans() && !hasClasses() && !hasErrors() && !hasNils() && !hasStrings() && !hasThreads() &&
+    return hasNumbers() && !hasTops() && !hasBooleans() && !hasExternTypes() && !hasErrors() && !hasNils() && !hasStrings() && !hasThreads() &&
            !hasBuffers() && !hasTables() && !hasFunctions() && !hasTyvars();
 }
 
 bool NormalizedType::isSubtypeOfString() const
 {
-    return hasStrings() && !hasTops() && !hasBooleans() && !hasClasses() && !hasErrors() && !hasNils() && !hasNumbers() && !hasThreads() &&
+    return hasStrings() && !hasTops() && !hasBooleans() && !hasExternTypes() && !hasErrors() && !hasNils() && !hasNumbers() && !hasThreads() &&
            !hasBuffers() && !hasTables() && !hasFunctions() && !hasTyvars();
 }
 
 bool NormalizedType::isSubtypeOfBooleans() const
 {
-    return hasBooleans() && !hasTops() && !hasClasses() && !hasErrors() && !hasNils() && !hasNumbers() && !hasStrings() && !hasThreads() &&
+    return hasBooleans() && !hasTops() && !hasExternTypes() && !hasErrors() && !hasNils() && !hasNumbers() && !hasStrings() && !hasThreads() &&
            !hasBuffers() && !hasTables() && !hasFunctions() && !hasTyvars();
 }
 
@@ -379,9 +380,9 @@ bool NormalizedType::hasBooleans() const
     return !get<NeverType>(booleans);
 }
 
-bool NormalizedType::hasClasses() const
+bool NormalizedType::hasExternTypes() const
 {
-    return !classes.isNever();
+    return !externTypes.isNever();
 }
 
 bool NormalizedType::hasErrors() const
@@ -439,7 +440,7 @@ bool NormalizedType::isFalsy() const
             hasAFalse = !bs->value;
     }
 
-    return (hasAFalse || hasNils()) && (!hasTops() && !hasClasses() && !hasErrors() && !hasNumbers() && !hasStrings() && !hasThreads() &&
+    return (hasAFalse || hasNils()) && (!hasTops() && !hasExternTypes() && !hasErrors() && !hasNumbers() && !hasStrings() && !hasThreads() &&
                                         !hasBuffers() && !hasTables() && !hasFunctions() && !hasTyvars());
 }
 
@@ -451,7 +452,7 @@ bool NormalizedType::isTruthy() const
 static bool isShallowInhabited(const NormalizedType& norm)
 {
     // This test is just a shallow check, for example it returns `true` for `{ p : never }`
-    return !get<NeverType>(norm.tops) || !get<NeverType>(norm.booleans) || !norm.classes.isNever() || !get<NeverType>(norm.errors) ||
+    return !get<NeverType>(norm.tops) || !get<NeverType>(norm.booleans) || !norm.externTypes.isNever() || !get<NeverType>(norm.errors) ||
            !get<NeverType>(norm.nils) || !get<NeverType>(norm.numbers) || !norm.strings.isNever() || !get<NeverType>(norm.threads) ||
            !get<NeverType>(norm.buffers) || !norm.functions.isNever() || !norm.tables.empty() || !norm.tyvars.empty();
 }
@@ -470,7 +471,7 @@ NormalizationResult Normalizer::isInhabited(const NormalizedType* norm, Set<Type
         return NormalizationResult::HitLimits;
 
     if (!get<NeverType>(norm->tops) || !get<NeverType>(norm->booleans) || !get<NeverType>(norm->errors) || !get<NeverType>(norm->nils) ||
-        !get<NeverType>(norm->numbers) || !get<NeverType>(norm->threads) || !get<NeverType>(norm->buffers) || !norm->classes.isNever() ||
+        !get<NeverType>(norm->numbers) || !get<NeverType>(norm->threads) || !get<NeverType>(norm->buffers) || !norm->externTypes.isNever() ||
         !norm->strings.isNever() || !norm->functions.isNever())
         return NormalizationResult::True;
 
@@ -578,7 +579,7 @@ NormalizationResult Normalizer::isIntersectionInhabited(TypeId left, TypeId righ
 {
     left = follow(left);
     right = follow(right);
-    // We're asking if intersection is inahbited between left and right but we've already seen them ....
+    // We're asking if intersection is inhabited between left and right but we've already seen them ....
 
     if (cacheInhabitance)
     {
@@ -618,13 +619,13 @@ static int tyvarIndex(TypeId ty)
         return 0;
 }
 
-static bool isTop(NotNull<BuiltinTypes> builtinTypes, const NormalizedClassType& classes)
+static bool isTop(NotNull<BuiltinTypes> builtinTypes, const NormalizedExternType& externTypes)
 {
-    if (classes.classes.size() != 1)
+    if (externTypes.externTypes.size() != 1)
         return false;
 
-    auto first = classes.classes.begin();
-    if (first->first != builtinTypes->classType)
+    auto first = externTypes.externTypes.begin();
+    if (first->first != builtinTypes->externType)
         return false;
 
     if (!first->second.empty())
@@ -633,11 +634,11 @@ static bool isTop(NotNull<BuiltinTypes> builtinTypes, const NormalizedClassType&
     return true;
 }
 
-static void resetToTop(NotNull<BuiltinTypes> builtinTypes, NormalizedClassType& classes)
+static void resetToTop(NotNull<BuiltinTypes> builtinTypes, NormalizedExternType& externTypes)
 {
-    classes.ordering.clear();
-    classes.classes.clear();
-    classes.pushPair(builtinTypes->classType, TypeIds{});
+    externTypes.ordering.clear();
+    externTypes.externTypes.clear();
+    externTypes.pushPair(builtinTypes->externType, TypeIds{});
 }
 
 #ifdef LUAU_ASSERTENABLED
@@ -761,50 +762,50 @@ static bool areNormalizedTables(const TypeIds& tys)
     return true;
 }
 
-static bool areNormalizedClasses(const NormalizedClassType& tys)
+static bool areNormalizedExternTypes(const NormalizedExternType& tys)
 {
-    for (const auto& [ty, negations] : tys.classes)
+    for (const auto& [ty, negations] : tys.externTypes)
     {
-        const ClassType* ctv = get<ClassType>(ty);
-        if (!ctv)
+        const ExternType* etv = get<ExternType>(ty);
+        if (!etv)
         {
             return false;
         }
 
         for (TypeId negation : negations)
         {
-            const ClassType* nctv = get<ClassType>(negation);
+            const ExternType* nctv = get<ExternType>(negation);
             if (!nctv)
             {
                 return false;
             }
 
-            if (!isSubclass(nctv, ctv))
+            if (!isSubclass(nctv, etv))
             {
                 return false;
             }
         }
 
-        for (const auto& [otherTy, otherNegations] : tys.classes)
+        for (const auto& [otherTy, otherNegations] : tys.externTypes)
         {
             if (otherTy == ty)
                 continue;
 
-            const ClassType* octv = get<ClassType>(otherTy);
+            const ExternType* octv = get<ExternType>(otherTy);
             if (!octv)
             {
                 return false;
             }
 
-            if (isSubclass(ctv, octv))
+            if (isSubclass(etv, octv))
             {
-                auto iss = [ctv](TypeId t)
+                auto iss = [etv](TypeId t)
                 {
-                    const ClassType* c = get<ClassType>(t);
+                    const ExternType* c = get<ExternType>(t);
                     if (!c)
                         return false;
 
-                    return isSubclass(ctv, c);
+                    return isSubclass(etv, c);
                 };
 
                 if (!std::any_of(otherNegations.begin(), otherNegations.end(), iss))
@@ -846,7 +847,7 @@ static void assertInvariant(const NormalizedType& norm)
 
     LUAU_ASSERT(isNormalizedTop(norm.tops));
     LUAU_ASSERT(isNormalizedBoolean(norm.booleans));
-    LUAU_ASSERT(areNormalizedClasses(norm.classes));
+    LUAU_ASSERT(areNormalizedExternTypes(norm.externTypes));
     LUAU_ASSERT(isNormalizedError(norm.errors));
     LUAU_ASSERT(isNormalizedNil(norm.nils));
     LUAU_ASSERT(isNormalizedNumber(norm.numbers));
@@ -987,7 +988,7 @@ void Normalizer::clearNormal(NormalizedType& norm)
 {
     norm.tops = builtinTypes->neverType;
     norm.booleans = builtinTypes->neverType;
-    norm.classes.resetToNever();
+    norm.externTypes.resetToNever();
     norm.errors = builtinTypes->neverType;
     norm.nils = builtinTypes->neverType;
     norm.numbers = builtinTypes->neverType;
@@ -1137,17 +1138,17 @@ TypeId Normalizer::unionOfBools(TypeId here, TypeId there)
     return builtinTypes->booleanType;
 }
 
-void Normalizer::unionClassesWithClass(TypeIds& heres, TypeId there)
+void Normalizer::unionExternTypesWithExternType(TypeIds& heres, TypeId there)
 {
     if (heres.count(there))
         return;
 
-    const ClassType* tctv = get<ClassType>(there);
+    const ExternType* tctv = get<ExternType>(there);
 
     for (auto it = heres.begin(); it != heres.end();)
     {
         TypeId here = *it;
-        const ClassType* hctv = get<ClassType>(here);
+        const ExternType* hctv = get<ExternType>(here);
         if (isSubclass(tctv, hctv))
             return;
         else if (isSubclass(hctv, tctv))
@@ -1159,16 +1160,16 @@ void Normalizer::unionClassesWithClass(TypeIds& heres, TypeId there)
     heres.insert(there);
 }
 
-void Normalizer::unionClasses(TypeIds& heres, const TypeIds& theres)
+void Normalizer::unionExternTypes(TypeIds& heres, const TypeIds& theres)
 {
     for (TypeId there : theres)
-        unionClassesWithClass(heres, there);
+        unionExternTypesWithExternType(heres, there);
 }
 
 static bool isSubclass(TypeId test, TypeId parent)
 {
-    const ClassType* testCtv = get<ClassType>(test);
-    const ClassType* parentCtv = get<ClassType>(parent);
+    const ExternType* testCtv = get<ExternType>(test);
+    const ExternType* parentCtv = get<ExternType>(parent);
 
     LUAU_ASSERT(testCtv);
     LUAU_ASSERT(parentCtv);
@@ -1176,12 +1177,12 @@ static bool isSubclass(TypeId test, TypeId parent)
     return isSubclass(testCtv, parentCtv);
 }
 
-void Normalizer::unionClassesWithClass(NormalizedClassType& heres, TypeId there)
+void Normalizer::unionExternTypesWithExternType(NormalizedExternType& heres, TypeId there)
 {
     for (auto it = heres.ordering.begin(); it != heres.ordering.end();)
     {
         TypeId hereTy = *it;
-        TypeIds& hereNegations = heres.classes.at(hereTy);
+        TypeIds& hereNegations = heres.externTypes.at(hereTy);
 
         // If the incoming class is a subclass of another class in the map, we
         // must ensure that it is negated by one of the negations in the same
@@ -1203,7 +1204,7 @@ void Normalizer::unionClassesWithClass(NormalizedClassType& heres, TypeId there)
                 }
                 // If the incoming class is a superclass of one of the
                 // negations, then the negation no longer applies and must be
-                // removed. This is also true if they are equal. Since classes
+                // removed. This is also true if they are equal. Since extern types
                 // are, at this time, entirely persistent (we do not clone
                 // them), a pointer identity check is sufficient.
                 else if (isSubclass(hereNegation, there))
@@ -1230,7 +1231,7 @@ void Normalizer::unionClassesWithClass(NormalizedClassType& heres, TypeId there)
         {
             TypeIds negations = std::move(hereNegations);
             it = heres.ordering.erase(it);
-            heres.classes.erase(hereTy);
+            heres.externTypes.erase(hereTy);
 
             heres.pushPair(there, std::move(negations));
             return;
@@ -1247,10 +1248,10 @@ void Normalizer::unionClassesWithClass(NormalizedClassType& heres, TypeId there)
     heres.pushPair(there, TypeIds{});
 }
 
-void Normalizer::unionClasses(NormalizedClassType& heres, const NormalizedClassType& theres)
+void Normalizer::unionExternTypes(NormalizedExternType& heres, const NormalizedExternType& theres)
 {
-    // This method bears much similarity with unionClassesWithClass, but is
-    // solving a more general problem. In unionClassesWithClass, we are dealing
+    // This method bears much similarity with unionExternTypesWithExternType, but is
+    // solving a more general problem. In unionExternTypesWithExternType, we are dealing
     // with a singular positive type. Since it's one type, we can use early
     // returns as control flow. Since it's guaranteed to be positive, we do not
     // have negations to worry about combining. The two aspects combine to make
@@ -1259,9 +1260,9 @@ void Normalizer::unionClasses(NormalizedClassType& heres, const NormalizedClassT
 
     for (const TypeId thereTy : theres.ordering)
     {
-        const TypeIds& thereNegations = theres.classes.at(thereTy);
+        const TypeIds& thereNegations = theres.externTypes.at(thereTy);
 
-        // If it happens that there are _no_ classes in the current map, or the
+        // If it happens that there are _no_ extern types in the current map, or the
         // incoming class is completely unrelated to any class in the current
         // map, we must insert the incoming pair as-is.
         bool insert = true;
@@ -1269,7 +1270,7 @@ void Normalizer::unionClasses(NormalizedClassType& heres, const NormalizedClassT
         for (auto it = heres.ordering.begin(); it != heres.ordering.end();)
         {
             TypeId hereTy = *it;
-            TypeIds& hereNegations = heres.classes.at(hereTy);
+            TypeIds& hereNegations = heres.externTypes.at(hereTy);
 
             if (isSubclass(thereTy, hereTy))
             {
@@ -1293,7 +1294,7 @@ void Normalizer::unionClasses(NormalizedClassType& heres, const NormalizedClassT
                     // If the incoming class is a superclass of one of the
                     // negations, then the negation no longer applies and must
                     // be removed. This is also true if they are equal. Since
-                    // classes are, at this time, entirely persistent (we do not
+                    // extern types are, at this time, entirely persistent (we do not
                     // clone them), a pointer identity check is sufficient.
                     else if (isSubclass(hereNegateTy, thereTy))
                     {
@@ -1318,17 +1319,17 @@ void Normalizer::unionClasses(NormalizedClassType& heres, const NormalizedClassT
             else if (isSubclass(hereTy, thereTy))
             {
                 TypeIds negations = std::move(hereNegations);
-                unionClasses(negations, thereNegations);
+                unionExternTypes(negations, thereNegations);
 
                 it = heres.ordering.erase(it);
-                heres.classes.erase(hereTy);
+                heres.externTypes.erase(hereTy);
                 heres.pushPair(thereTy, std::move(negations));
                 insert = false;
                 break;
             }
             else if (hereTy == thereTy)
             {
-                unionClasses(hereNegations, thereNegations);
+                unionExternTypes(hereNegations, thereNegations);
                 insert = false;
                 break;
             }
@@ -1684,8 +1685,12 @@ NormalizationResult Normalizer::unionNormals(NormalizedType& here, const Normali
             return res;
     }
 
+    // Limit based on worst-case expansion of the function unions
+    if (here.functions.parts.size() * there.functions.parts.size() >= size_t(FInt::LuauNormalizeUnionLimit))
+        return NormalizationResult::HitLimits;
+
     here.booleans = unionOfBools(here.booleans, there.booleans);
-    unionClasses(here.classes, there.classes);
+    unionExternTypes(here.externTypes, there.externTypes);
 
     here.errors = (get<NeverType>(there.errors) ? here.errors : there.errors);
     here.nils = (get<NeverType>(there.nils) ? here.nils : there.nils);
@@ -1695,6 +1700,7 @@ NormalizationResult Normalizer::unionNormals(NormalizedType& here, const Normali
     here.buffers = (get<NeverType>(there.buffers) ? here.buffers : there.buffers);
     unionFunctions(here.functions, there.functions);
     unionTables(here.tables, there.tables);
+
     return NormalizationResult::True;
 }
 
@@ -1734,7 +1740,7 @@ NormalizationResult Normalizer::intersectNormalWithNegationTy(TypeId toNegate, N
     return NormalizationResult::True;
 }
 
-// See above for an explaination of `ignoreSmallerTyvars`.
+// See above for an explanation of `ignoreSmallerTyvars`.
 NormalizationResult Normalizer::unionNormalWithTy(
     NormalizedType& here,
     TypeId there,
@@ -1824,8 +1830,8 @@ NormalizationResult Normalizer::unionNormalWithTy(
         unionFunctionsWithFunction(here.functions, there);
     else if (get<TableType>(there) || get<MetatableType>(there))
         unionTablesWithTable(here.tables, there);
-    else if (get<ClassType>(there))
-        unionClassesWithClass(here.classes, there);
+    else if (get<ExternType>(there))
+        unionExternTypesWithExternType(here.externTypes, there);
     else if (get<ErrorType>(there))
         here.errors = there;
     else if (const PrimitiveType* ptv = get<PrimitiveType>(there))
@@ -1938,29 +1944,29 @@ std::optional<NormalizedType> Normalizer::negateNormal(const NormalizedType& her
             result.booleans = builtinTypes->trueType;
     }
 
-    if (here.classes.isNever())
+    if (here.externTypes.isNever())
     {
-        resetToTop(builtinTypes, result.classes);
+        resetToTop(builtinTypes, result.externTypes);
     }
-    else if (isTop(builtinTypes, result.classes))
+    else if (isTop(builtinTypes, result.externTypes))
     {
-        result.classes.resetToNever();
+        result.externTypes.resetToNever();
     }
     else
     {
         TypeIds rootNegations{};
 
-        for (const auto& [hereParent, hereNegations] : here.classes.classes)
+        for (const auto& [hereParent, hereNegations] : here.externTypes.externTypes)
         {
-            if (hereParent != builtinTypes->classType)
+            if (hereParent != builtinTypes->externType)
                 rootNegations.insert(hereParent);
 
             for (TypeId hereNegation : hereNegations)
-                unionClassesWithClass(result.classes, hereNegation);
+                unionExternTypesWithExternType(result.externTypes, hereNegation);
         }
 
         if (!rootNegations.empty())
-            result.classes.pushPair(builtinTypes->classType, rootNegations);
+            result.externTypes.pushPair(builtinTypes->externType, rootNegations);
     }
 
     result.nils = get<NeverType>(here.nils) ? builtinTypes->nilType : builtinTypes->neverType;
@@ -2138,7 +2144,7 @@ TypeId Normalizer::intersectionOfBools(TypeId here, TypeId there)
         return there;
 }
 
-void Normalizer::intersectClasses(NormalizedClassType& heres, const NormalizedClassType& theres)
+void Normalizer::intersectExternTypes(NormalizedExternType& heres, const NormalizedExternType& theres)
 {
     if (theres.isNever())
     {
@@ -2172,12 +2178,12 @@ void Normalizer::intersectClasses(NormalizedClassType& heres, const NormalizedCl
     //   declare the result of the intersection operation to be never.
     for (const TypeId thereTy : theres.ordering)
     {
-        const TypeIds& thereNegations = theres.classes.at(thereTy);
+        const TypeIds& thereNegations = theres.externTypes.at(thereTy);
 
         for (auto it = heres.ordering.begin(); it != heres.ordering.end();)
         {
             TypeId hereTy = *it;
-            TypeIds& hereNegations = heres.classes.at(hereTy);
+            TypeIds& hereNegations = heres.externTypes.at(hereTy);
 
             if (isSubclass(thereTy, hereTy))
             {
@@ -2200,10 +2206,10 @@ void Normalizer::intersectClasses(NormalizedClassType& heres, const NormalizedCl
                     }
                 }
 
-                unionClasses(negations, thereNegations);
+                unionExternTypes(negations, thereNegations);
 
                 it = heres.ordering.erase(it);
-                heres.classes.erase(hereTy);
+                heres.externTypes.erase(hereTy);
                 heres.pushPair(thereTy, std::move(negations));
                 break;
             }
@@ -2228,15 +2234,15 @@ void Normalizer::intersectClasses(NormalizedClassType& heres, const NormalizedCl
                 {
                     if (isSubclass(hereTy, *nIt))
                     {
-                        // eg SomeClass & (class & ~SomeClass)
-                        // or SomeClass & (class & ~ParentClass)
-                        heres.classes.erase(hereTy);
+                        // eg SomeExternType & (class & ~SomeExternType)
+                        // or SomeExternType & (class & ~ParentExternType)
+                        heres.externTypes.erase(hereTy);
                         it = heres.ordering.erase(it);
                         erasedHere = true;
                         break;
                     }
 
-                    // eg SomeClass & (class & ~Unrelated)
+                    // eg SomeExternType & (class & ~Unrelated)
                     if (!isSubclass(*nIt, hereTy))
                         nIt = negations.erase(nIt);
                     else
@@ -2245,30 +2251,30 @@ void Normalizer::intersectClasses(NormalizedClassType& heres, const NormalizedCl
 
                 if (!erasedHere)
                 {
-                    unionClasses(hereNegations, negations);
+                    unionExternTypes(hereNegations, negations);
                     ++it;
                 }
             }
             else if (hereTy == thereTy)
             {
-                unionClasses(hereNegations, thereNegations);
+                unionExternTypes(hereNegations, thereNegations);
                 break;
             }
             else
             {
                 it = heres.ordering.erase(it);
-                heres.classes.erase(hereTy);
+                heres.externTypes.erase(hereTy);
             }
         }
     }
 }
 
-void Normalizer::intersectClassesWithClass(NormalizedClassType& heres, TypeId there)
+void Normalizer::intersectExternTypesWithExternType(NormalizedExternType& heres, TypeId there)
 {
     for (auto it = heres.ordering.begin(); it != heres.ordering.end();)
     {
         TypeId hereTy = *it;
-        const TypeIds& hereNegations = heres.classes.at(hereTy);
+        const TypeIds& hereNegations = heres.externTypes.at(hereTy);
 
         // If the incoming class _is_ the current class, we skip it. Maybe
         // another entry will have a different story. We check for this first
@@ -2288,7 +2294,7 @@ void Normalizer::intersectClassesWithClass(NormalizedClassType& heres, TypeId th
 
             for (auto nIt = negations.begin(); nIt != negations.end();)
             {
-                if (FFlag::LuauFixNormalizedIntersectionOfNegatedClass && isSubclass(there, *nIt))
+                if (isSubclass(there, *nIt))
                 {
                     // Hitting this block means that the incoming class is a
                     // subclass of this type, _and_ one of its negations is a
@@ -2313,7 +2319,7 @@ void Normalizer::intersectClassesWithClass(NormalizedClassType& heres, TypeId th
             }
 
             it = heres.ordering.erase(it);
-            heres.classes.erase(hereTy);
+            heres.externTypes.erase(hereTy);
             if (!emptyIntersectWithNegation)
                 heres.pushPair(there, std::move(negations));
             break;
@@ -2329,7 +2335,7 @@ void Normalizer::intersectClassesWithClass(NormalizedClassType& heres, TypeId th
         else
         {
             it = heres.ordering.erase(it);
-            heres.classes.erase(hereTy);
+            heres.externTypes.erase(hereTy);
         }
     }
 }
@@ -3049,7 +3055,7 @@ NormalizationResult Normalizer::intersectTyvarsWithTy(
     return NormalizationResult::True;
 }
 
-// See above for an explaination of `ignoreSmallerTyvars`.
+// See above for an explanation of `ignoreSmallerTyvars`.
 NormalizationResult Normalizer::intersectNormals(NormalizedType& here, const NormalizedType& there, int ignoreSmallerTyvars)
 {
     RecursionCounter _rc(&sharedState->counters.recursionCount);
@@ -3067,14 +3073,17 @@ NormalizationResult Normalizer::intersectNormals(NormalizedType& here, const Nor
         return unionNormals(here, there, ignoreSmallerTyvars);
     }
 
-    // Limit based on worst-case expansion of the table intersection
+    // Limit based on worst-case expansion of the table/function intersections
     // This restriction can be relaxed when table intersection simplification is improved
     if (here.tables.size() * there.tables.size() >= size_t(FInt::LuauNormalizeIntersectionLimit))
         return NormalizationResult::HitLimits;
 
+    if (here.functions.parts.size() * there.functions.parts.size() >= size_t(FInt::LuauNormalizeIntersectionLimit))
+        return NormalizationResult::HitLimits;
+
     here.booleans = intersectionOfBools(here.booleans, there.booleans);
 
-    intersectClasses(here.classes, there.classes);
+    intersectExternTypes(here.externTypes, there.externTypes);
     here.errors = (get<NeverType>(there.errors) ? there.errors : here.errors);
     here.nils = (get<NeverType>(there.nils) ? there.nils : here.nils);
     here.numbers = (get<NeverType>(there.numbers) ? there.numbers : here.numbers);
@@ -3196,18 +3205,18 @@ NormalizationResult Normalizer::intersectNormalWithTy(
         intersectTablesWithTable(tables, there, seenTablePropPairs, seenSetTypes);
         here.tables = std::move(tables);
     }
-    else if (get<ClassType>(there))
+    else if (get<ExternType>(there))
     {
-        NormalizedClassType nct = std::move(here.classes);
+        NormalizedExternType nct = std::move(here.externTypes);
         clearNormal(here);
-        intersectClassesWithClass(nct, there);
-        here.classes = std::move(nct);
+        intersectExternTypesWithExternType(nct, there);
+        here.externTypes = std::move(nct);
     }
     else if (get<ErrorType>(there))
     {
         TypeId errors = here.errors;
         clearNormal(here);
-        here.errors = errors;
+        here.errors = get<ErrorType>(errors) ? errors : there;
     }
     else if (const PrimitiveType* ptv = get<PrimitiveType>(there))
     {
@@ -3265,7 +3274,7 @@ NormalizationResult Normalizer::intersectNormalWithTy(
             subtractPrimitive(here, ntv->ty);
         else if (const SingletonType* stv = get<SingletonType>(t))
             subtractSingleton(here, follow(ntv->ty));
-        else if (get<ClassType>(t))
+        else if (get<ExternType>(t))
         {
             NormalizationResult res = intersectNormalWithNegationTy(t, here);
             if (shouldEarlyExit(res))
@@ -3304,8 +3313,18 @@ NormalizationResult Normalizer::intersectNormalWithTy(
             clearNormal(here);
             return NormalizationResult::True;
         }
+        else if (get<ErrorType>(t))
+        {
+            // ~error is still an error, so intersecting with the negation is the same as intersecting with a type
+            TypeId errors = here.errors;
+            clearNormal(here);
+            here.errors = get<ErrorType>(errors) ? errors : t;
+        }
         else if (auto nt = get<NegationType>(t))
+        {
+            here.tyvars = std::move(tyvars);
             return intersectNormalWithTy(here, nt->ty, seenTablePropPairs, seenSetTypes);
+        }
         else
         {
             // TODO negated unions, intersections, table, and function.
@@ -3315,7 +3334,7 @@ NormalizationResult Normalizer::intersectNormalWithTy(
     }
     else if (get<NeverType>(there))
     {
-        here.classes.resetToNever();
+        here.externTypes.resetToNever();
     }
     else if (get<NoRefineType>(there))
     {
@@ -3333,7 +3352,7 @@ NormalizationResult Normalizer::intersectNormalWithTy(
     return NormalizationResult::True;
 }
 
-void makeTableShared(TypeId ty)
+void makeTableShared_DEPRECATED(TypeId ty)
 {
     ty = follow(ty);
     if (auto tableTy = getMutable<TableType>(ty))
@@ -3343,11 +3362,35 @@ void makeTableShared(TypeId ty)
     }
     else if (auto metatableTy = get<MetatableType>(ty))
     {
-        makeTableShared(metatableTy->metatable);
-        makeTableShared(metatableTy->table);
+        makeTableShared_DEPRECATED(metatableTy->metatable);
+        makeTableShared_DEPRECATED(metatableTy->table);
     }
 }
 
+void makeTableShared(TypeId ty, DenseHashSet<TypeId>& seen)
+{
+    ty = follow(ty);
+    if (seen.contains(ty))
+        return;
+    seen.insert(ty);
+    if (auto tableTy = getMutable<TableType>(ty))
+    {
+        for (auto& [_, prop] : tableTy->props)
+            prop.makeShared();
+    }
+    else if (auto metatableTy = get<MetatableType>(ty))
+    {
+        makeTableShared(metatableTy->metatable, seen);
+        makeTableShared(metatableTy->table, seen);
+    }
+}
+
+void makeTableShared(TypeId ty)
+{
+    DenseHashSet<TypeId> seen{nullptr};
+    makeTableShared(ty, seen);
+}
+
 // -------- Convert back from a normalized type to a type
 TypeId Normalizer::typeFromNormal(const NormalizedType& norm)
 {
@@ -3360,18 +3403,18 @@ TypeId Normalizer::typeFromNormal(const NormalizedType& norm)
     if (!get<NeverType>(norm.booleans))
         result.push_back(norm.booleans);
 
-    if (isTop(builtinTypes, norm.classes))
+    if (isTop(builtinTypes, norm.externTypes))
     {
-        result.push_back(builtinTypes->classType);
+        result.push_back(builtinTypes->externType);
     }
-    else if (!norm.classes.isNever())
+    else if (!norm.externTypes.isNever())
     {
         std::vector<TypeId> parts;
-        parts.reserve(norm.classes.classes.size());
+        parts.reserve(norm.externTypes.externTypes.size());
 
-        for (const TypeId normTy : norm.classes.ordering)
+        for (const TypeId normTy : norm.externTypes.ordering)
         {
-            const TypeIds& normNegations = norm.classes.classes.at(normTy);
+            const TypeIds& normNegations = norm.externTypes.externTypes.at(normTy);
 
             if (normNegations.empty())
             {
@@ -3447,7 +3490,10 @@ TypeId Normalizer::typeFromNormal(const NormalizedType& norm)
         result.reserve(result.size() + norm.tables.size());
         for (auto table : norm.tables)
         {
-            makeTableShared(table);
+            if (FFlag::LuauNormalizationCatchMetatableCycles)
+                makeTableShared(table);
+            else
+                makeTableShared_DEPRECATED(table);
             result.push_back(table);
         }
     }

Analysis/src/OverloadResolution.cpp

@@ -10,6 +10,8 @@
 #include "Luau/TypeUtils.h"
 #include "Luau/Unifier2.h"
 
+LUAU_FASTFLAGVARIABLE(LuauArityMismatchOnUndersaturatedUnknownArguments)
+
 namespace Luau
 {
 
@@ -254,15 +256,32 @@ std::pair<OverloadResolver::Analysis, ErrorVec> OverloadResolver::checkOverload_
             }
 
             // If any of the unsatisfied arguments are not supertypes of
-            // nil, then this overload does not match.
+            // nil or are `unknown`, then this overload does not match.
             for (size_t i = firstUnsatisfiedArgument; i < requiredHead.size(); ++i)
             {
-                if (!subtyping.isSubtype(builtinTypes->nilType, requiredHead[i], scope).isSubtype)
+                if (FFlag::LuauArityMismatchOnUndersaturatedUnknownArguments)
                 {
-                    auto [minParams, optMaxParams] = getParameterExtents(TxnLog::empty(), fn->argTypes);
-                    TypeError error{fnExpr->location, CountMismatch{minParams, optMaxParams, args->head.size(), CountMismatch::Arg, isVariadic}};
+                    if (get<UnknownType>(follow(requiredHead[i])) || !subtyping.isSubtype(builtinTypes->nilType, requiredHead[i], scope).isSubtype)
+                    {
+                        auto [minParams, optMaxParams] = getParameterExtents(TxnLog::empty(), fn->argTypes);
+                        for (auto arg : fn->argTypes)
+                            if (get<UnknownType>(follow(arg)))
+                                minParams += 1;
 
-                    return {Analysis::ArityMismatch, {error}};
+                        TypeError error{fnExpr->location, CountMismatch{minParams, optMaxParams, args->head.size(), CountMismatch::Arg, isVariadic}};
+
+                        return {Analysis::ArityMismatch, {error}};
+                    }
+                }
+                else
+                {
+                    if (!subtyping.isSubtype(builtinTypes->nilType, requiredHead[i], scope).isSubtype)
+                    {
+                        auto [minParams, optMaxParams] = getParameterExtents(TxnLog::empty(), fn->argTypes);
+                        TypeError error{fnExpr->location, CountMismatch{minParams, optMaxParams, args->head.size(), CountMismatch::Arg, isVariadic}};
+
+                        return {Analysis::ArityMismatch, {error}};
+                    }
                 }
             }
 
@@ -454,7 +473,7 @@ SolveResult solveFunctionCall(
 
     TypePackId resultPack = arena->freshTypePack(scope);
 
-    TypeId inferredTy = arena->addType(FunctionType{TypeLevel{}, scope.get(), argsPack, resultPack});
+    TypeId inferredTy = arena->addType(FunctionType{TypeLevel{}, argsPack, resultPack});
     Unifier2 u2{NotNull{arena}, builtinTypes, scope, iceReporter};
 
     const bool occursCheckPassed = u2.unify(*overloadToUse, inferredTy);

Analysis/src/Quantify.cpp

@@ -107,134 +107,4 @@ void quantify(TypeId ty, TypeLevel level)
     ftv->genericPacks.insert(ftv->genericPacks.end(), q.genericPacks.begin(), q.genericPacks.end());
 }
 
-struct PureQuantifier : Substitution
-{
-    Scope* scope;
-    OrderedMap<TypeId, TypeId> insertedGenerics;
-    OrderedMap<TypePackId, TypePackId> insertedGenericPacks;
-    bool seenMutableType = false;
-    bool seenGenericType = false;
-
-    PureQuantifier(TypeArena* arena, Scope* scope)
-        : Substitution(TxnLog::empty(), arena)
-        , scope(scope)
-    {
-    }
-
-    bool isDirty(TypeId ty) override
-    {
-        LUAU_ASSERT(ty == follow(ty));
-
-        if (auto ftv = get<FreeType>(ty))
-        {
-            bool result = subsumes(scope, ftv->scope);
-            seenMutableType |= result;
-            return result;
-        }
-        else if (auto ttv = get<TableType>(ty))
-        {
-            if (ttv->state == TableState::Free)
-                seenMutableType = true;
-            else if (ttv->state == TableState::Generic)
-                seenGenericType = true;
-
-            return (ttv->state == TableState::Unsealed || ttv->state == TableState::Free) && subsumes(scope, ttv->scope);
-        }
-
-        return false;
-    }
-
-    bool isDirty(TypePackId tp) override
-    {
-        if (auto ftp = get<FreeTypePack>(tp))
-        {
-            return subsumes(scope, ftp->scope);
-        }
-
-        return false;
-    }
-
-    TypeId clean(TypeId ty) override
-    {
-        if (auto ftv = get<FreeType>(ty))
-        {
-            TypeId result = arena->addType(GenericType{scope});
-            insertedGenerics.push(ty, result);
-            return result;
-        }
-        else if (auto ttv = get<TableType>(ty))
-        {
-            TypeId result = arena->addType(TableType{});
-            TableType* resultTable = getMutable<TableType>(result);
-            LUAU_ASSERT(resultTable);
-
-            *resultTable = *ttv;
-            resultTable->level = TypeLevel{};
-            resultTable->scope = scope;
-
-            if (ttv->state == TableState::Free)
-            {
-                resultTable->state = TableState::Generic;
-                insertedGenerics.push(ty, result);
-            }
-            else if (ttv->state == TableState::Unsealed)
-                resultTable->state = TableState::Sealed;
-
-            return result;
-        }
-
-        return ty;
-    }
-
-    TypePackId clean(TypePackId tp) override
-    {
-        if (auto ftp = get<FreeTypePack>(tp))
-        {
-            TypePackId result = arena->addTypePack(TypePackVar{GenericTypePack{scope}});
-            insertedGenericPacks.push(tp, result);
-            return result;
-        }
-
-        return tp;
-    }
-
-    bool ignoreChildren(TypeId ty) override
-    {
-        if (get<ClassType>(ty))
-            return true;
-
-        return ty->persistent;
-    }
-    bool ignoreChildren(TypePackId ty) override
-    {
-        return ty->persistent;
-    }
-};
-
-std::optional<QuantifierResult> quantify(TypeArena* arena, TypeId ty, Scope* scope)
-{
-    PureQuantifier quantifier{arena, scope};
-    std::optional<TypeId> result = quantifier.substitute(ty);
-    if (!result)
-        return std::nullopt;
-
-    FunctionType* ftv = getMutable<FunctionType>(*result);
-    LUAU_ASSERT(ftv);
-    ftv->scope = scope;
-
-    for (auto k : quantifier.insertedGenerics.keys)
-    {
-        TypeId g = quantifier.insertedGenerics.pairings[k];
-        if (get<GenericType>(g))
-            ftv->generics.push_back(g);
-    }
-
-    for (auto k : quantifier.insertedGenericPacks.keys)
-        ftv->genericPacks.push_back(quantifier.insertedGenericPacks.pairings[k]);
-
-    ftv->hasNoFreeOrGenericTypes = ftv->generics.empty() && ftv->genericPacks.empty() && !quantifier.seenGenericType && !quantifier.seenMutableType;
-
-    return std::optional<QuantifierResult>({*result, std::move(quantifier.insertedGenerics), std::move(quantifier.insertedGenericPacks)});
-}
-
 } // namespace Luau

Analysis/src/Refinement.cpp

@@ -54,7 +54,15 @@ RefinementId RefinementArena::proposition(const RefinementKey* key, TypeId discr
     if (!key)
         return nullptr;
 
-    return NotNull{allocator.allocate(Proposition{key, discriminantTy})};
+    return NotNull{allocator.allocate(Proposition{key, discriminantTy, false})};
+}
+
+RefinementId RefinementArena::implicitProposition(const RefinementKey* key, TypeId discriminantTy)
+{
+    if (!key)
+        return nullptr;
+
+    return NotNull{allocator.allocate(Proposition{key, discriminantTy, true})};
 }
 
 } // namespace Luau

Analysis/src/RequireTracer.cpp

@@ -4,7 +4,7 @@
 #include "Luau/Ast.h"
 #include "Luau/Module.h"
 
-LUAU_FASTFLAGVARIABLE(LuauExtendedSimpleRequire)
+LUAU_FASTFLAG(LuauStoreReturnTypesAsPackOnAst)
 
 namespace Luau
 {
@@ -67,6 +67,12 @@ struct RequireTracer : AstVisitor
         return true;
     }
 
+    bool visit(AstTypePack* node) override
+    {
+        // allow resolving require inside `typeof` annotations
+        return FFlag::LuauStoreReturnTypesAsPackOnAst;
+    }
+
     AstExpr* getDependent_DEPRECATED(AstExpr* node)
     {
         if (AstExprLocal* expr = node->as<AstExprLocal>())
@@ -106,96 +112,50 @@ struct RequireTracer : AstVisitor
     {
         ModuleInfo moduleContext{currentModuleName};
 
-        if (FFlag::LuauExtendedSimpleRequire)
+        // seed worklist with require arguments
+        work.reserve(requireCalls.size());
+
+        for (AstExprCall* require : requireCalls)
+            work.push_back(require->args.data[0]);
+
+        // push all dependent expressions to the work stack; note that the vector is modified during traversal
+        for (size_t i = 0; i < work.size(); ++i)
         {
-            // seed worklist with require arguments
-            work.reserve(requireCalls.size());
-
-            for (AstExprCall* require : requireCalls)
-                work.push_back(require->args.data[0]);
-
-            // push all dependent expressions to the work stack; note that the vector is modified during traversal
-            for (size_t i = 0; i < work.size(); ++i)
-            {
-                if (AstNode* dep = getDependent(work[i]))
-                    work.push_back(dep);
-            }
-
-            // resolve all expressions to a module info
-            for (size_t i = work.size(); i > 0; --i)
-            {
-                AstNode* expr = work[i - 1];
-
-                // when multiple expressions depend on the same one we push it to work queue multiple times
-                if (result.exprs.contains(expr))
-                    continue;
-
-                std::optional<ModuleInfo> info;
-
-                if (AstNode* dep = getDependent(expr))
-                {
-                    const ModuleInfo* context = result.exprs.find(dep);
-
-                    if (context && expr->is<AstExprLocal>())
-                        info = *context; // locals just inherit their dependent context, no resolution required
-                    else if (context && (expr->is<AstExprGroup>() || expr->is<AstTypeGroup>()))
-                        info = *context; // simple group nodes propagate their value
-                    else if (context && (expr->is<AstTypeTypeof>() || expr->is<AstExprTypeAssertion>()))
-                        info = *context; // typeof type annotations will resolve to the typeof content
-                    else if (AstExpr* asExpr = expr->asExpr())
-                        info = fileResolver->resolveModule(context, asExpr);
-                }
-                else if (AstExpr* asExpr = expr->asExpr())
-                {
-                    info = fileResolver->resolveModule(&moduleContext, asExpr);
-                }
-
-                if (info)
-                    result.exprs[expr] = std::move(*info);
-            }
+            if (AstNode* dep = getDependent(work[i]))
+                work.push_back(dep);
         }
-        else
+
+        // resolve all expressions to a module info
+        for (size_t i = work.size(); i > 0; --i)
         {
-            // seed worklist with require arguments
-            work_DEPRECATED.reserve(requireCalls.size());
+            AstNode* expr = work[i - 1];
 
-            for (AstExprCall* require : requireCalls)
-                work_DEPRECATED.push_back(require->args.data[0]);
+            // when multiple expressions depend on the same one we push it to work queue multiple times
+            if (result.exprs.contains(expr))
+                continue;
 
-            // push all dependent expressions to the work stack; note that the vector is modified during traversal
-            for (size_t i = 0; i < work_DEPRECATED.size(); ++i)
-                if (AstExpr* dep = getDependent_DEPRECATED(work_DEPRECATED[i]))
-                    work_DEPRECATED.push_back(dep);
+            std::optional<ModuleInfo> info;
 
-            // resolve all expressions to a module info
-            for (size_t i = work_DEPRECATED.size(); i > 0; --i)
+            if (AstNode* dep = getDependent(expr))
             {
-                AstExpr* expr = work_DEPRECATED[i - 1];
+                const ModuleInfo* context = result.exprs.find(dep);
 
-                // when multiple expressions depend on the same one we push it to work queue multiple times
-                if (result.exprs.contains(expr))
-                    continue;
-
-                std::optional<ModuleInfo> info;
-
-                if (AstExpr* dep = getDependent_DEPRECATED(expr))
-                {
-                    const ModuleInfo* context = result.exprs.find(dep);
-
-                    // locals just inherit their dependent context, no resolution required
-                    if (expr->is<AstExprLocal>())
-                        info = context ? std::optional<ModuleInfo>(*context) : std::nullopt;
-                    else
-                        info = fileResolver->resolveModule(context, expr);
-                }
-                else
-                {
-                    info = fileResolver->resolveModule(&moduleContext, expr);
-                }
-
-                if (info)
-                    result.exprs[expr] = std::move(*info);
+                if (context && expr->is<AstExprLocal>())
+                    info = *context; // locals just inherit their dependent context, no resolution required
+                else if (context && (expr->is<AstExprGroup>() || expr->is<AstTypeGroup>()))
+                    info = *context; // simple group nodes propagate their value
+                else if (context && (expr->is<AstTypeTypeof>() || expr->is<AstExprTypeAssertion>()))
+                    info = *context; // typeof type annotations will resolve to the typeof content
+                else if (AstExpr* asExpr = expr->asExpr())
+                    info = fileResolver->resolveModule(context, asExpr);
             }
+            else if (AstExpr* asExpr = expr->asExpr())
+            {
+                info = fileResolver->resolveModule(&moduleContext, asExpr);
+            }
+
+            if (info)
+                result.exprs[expr] = std::move(*info);
         }
 
         // resolve all requires according to their argument
@@ -224,7 +184,6 @@ struct RequireTracer : AstVisitor
     ModuleName currentModuleName;
 
     DenseHashMap<AstLocal*, AstExpr*> locals;
-    std::vector<AstExpr*> work_DEPRECATED;
     std::vector<AstNode*> work;
     std::vector<AstExprCall*> requireCalls;
 };

Analysis/src/Scope.cpp

@@ -84,6 +84,17 @@ std::optional<TypeId> Scope::lookupUnrefinedType(DefId def) const
     return std::nullopt;
 }
 
+std::optional<TypeId> Scope::lookupRValueRefinementType(DefId def) const
+{
+    for (const Scope* current = this; current; current = current->parent.get())
+    {
+        if (auto ty = current->rvalueRefinements.find(def))
+            return *ty;
+    }
+
+    return std::nullopt;
+}
+
 std::optional<TypeId> Scope::lookup(DefId def) const
 {
     for (const Scope* current = this; current; current = current->parent.get())
@@ -181,6 +192,29 @@ std::optional<Binding> Scope::linearSearchForBinding(const std::string& name, bo
     return std::nullopt;
 }
 
+std::optional<std::pair<Symbol, Binding>> Scope::linearSearchForBindingPair(const std::string& name, bool traverseScopeChain) const
+{
+    const Scope* scope = this;
+
+    while (scope)
+    {
+        for (auto& [n, binding] : scope->bindings)
+        {
+            if (n.local && n.local->name == name.c_str())
+                return {{n, binding}};
+            else if (n.global.value && n.global == name.c_str())
+                return {{n, binding}};
+        }
+
+        scope = scope->parent.get();
+
+        if (!traverseScopeChain)
+            break;
+    }
+
+    return std::nullopt;
+}
+
 // Updates the `this` scope with the assignments from the `childScope` including ones that doesn't exist in `this`.
 void Scope::inheritAssignments(const ScopePtr& childScope)
 {

Analysis/src/Simplify.cpp

@@ -6,6 +6,7 @@
 #include "Luau/DenseHash.h"
 #include "Luau/RecursionCounter.h"
 #include "Luau/Set.h"
+#include "Luau/Type.h"
 #include "Luau/TypeArena.h"
 #include "Luau/TypePairHash.h"
 #include "Luau/TypeUtils.h"
@@ -14,8 +15,10 @@
 
 LUAU_FASTINT(LuauTypeReductionRecursionLimit)
 LUAU_FASTFLAG(LuauSolverV2)
-LUAU_DYNAMIC_FASTINTVARIABLE(LuauSimplificationComplexityLimit, 8);
-LUAU_FASTFLAGVARIABLE(LuauFlagBasicIntersectFollows);
+LUAU_DYNAMIC_FASTINTVARIABLE(LuauSimplificationComplexityLimit, 8)
+LUAU_FASTFLAGVARIABLE(LuauSimplificationRecheckAssumption)
+LUAU_FASTFLAGVARIABLE(LuauOptimizeFalsyAndTruthyIntersect)
+LUAU_FASTFLAGVARIABLE(LuauSimplificationTableExternType)
 
 namespace Luau
 {
@@ -47,6 +50,8 @@ struct TypeSimplifier
     // Attempt to intersect the two types.  Does not recurse.  Does not handle
     // unions, intersections, or negations.
     std::optional<TypeId> basicIntersect(TypeId left, TypeId right);
+    std::optional<TypeId> basicIntersectWithTruthy(TypeId target) const;
+    std::optional<TypeId> basicIntersectWithFalsy(TypeId target) const;
 
     TypeId intersect(TypeId left, TypeId right);
     TypeId union_(TypeId left, TypeId right);
@@ -313,12 +318,14 @@ Relation relate(TypeId left, TypeId right, SimplifierSeenSet& seen)
     {
         if (get<AnyType>(right))
             return Relation::Subset;
-        else if (get<UnknownType>(right))
+
+        if (get<UnknownType>(right))
             return Relation::Coincident;
-        else if (get<ErrorType>(right))
+
+        if (get<ErrorType>(right))
             return Relation::Disjoint;
-        else
-            return Relation::Superset;
+
+        return Relation::Superset;
     }
 
     if (get<UnknownType>(right))
@@ -328,8 +335,8 @@ Relation relate(TypeId left, TypeId right, SimplifierSeenSet& seen)
     {
         if (get<AnyType>(right))
             return Relation::Coincident;
-        else
-            return Relation::Superset;
+
+        return Relation::Superset;
     }
 
     if (get<AnyType>(right))
@@ -353,7 +360,7 @@ Relation relate(TypeId left, TypeId right, SimplifierSeenSet& seen)
     // * FunctionType
     // * TableType
     // * MetatableType
-    // * ClassType
+    // * ExternType
     // * UnionType
     // * IntersectionType
     // * NegationType
@@ -361,26 +368,33 @@ Relation relate(TypeId left, TypeId right, SimplifierSeenSet& seen)
     if (isTypeVariable(left) || isTypeVariable(right))
         return Relation::Intersects;
 
+    if (FFlag::LuauSimplificationTableExternType)
+    {
+        // if either type is a type function, we cannot know if they'll be related.
+        if (get<TypeFunctionInstanceType>(left) || get<TypeFunctionInstanceType>(right))
+            return Relation::Intersects;
+    }
+
     if (get<ErrorType>(left))
     {
         if (get<ErrorType>(right))
             return Relation::Coincident;
         else if (get<AnyType>(right))
             return Relation::Subset;
-        else
-            return Relation::Disjoint;
+
+        return Relation::Disjoint;
     }
-    if (get<ErrorType>(right))
+    else if (get<ErrorType>(right))
         return flip(relate(right, left, seen));
 
     if (get<NeverType>(left))
     {
         if (get<NeverType>(right))
             return Relation::Coincident;
-        else
-            return Relation::Subset;
+
+        return Relation::Subset;
     }
-    if (get<NeverType>(right))
+    else if (get<NeverType>(right))
         return flip(relate(right, left, seen));
 
     if (auto ut = get<IntersectionType>(left))
@@ -444,52 +458,54 @@ Relation relate(TypeId left, TypeId right, SimplifierSeenSet& seen)
         {
             if (lp->type == rp->type)
                 return Relation::Coincident;
-            else
-                return Relation::Disjoint;
+
+            return Relation::Disjoint;
         }
 
         if (auto rs = get<SingletonType>(right))
         {
             if (lp->type == PrimitiveType::String && rs->variant.get_if<StringSingleton>())
                 return Relation::Superset;
-            else if (lp->type == PrimitiveType::Boolean && rs->variant.get_if<BooleanSingleton>())
+
+            if (lp->type == PrimitiveType::Boolean && rs->variant.get_if<BooleanSingleton>())
                 return Relation::Superset;
-            else
-                return Relation::Disjoint;
+
+            return Relation::Disjoint;
         }
 
         if (lp->type == PrimitiveType::Function)
         {
             if (get<FunctionType>(right))
                 return Relation::Superset;
-            else
-                return Relation::Disjoint;
+
+            return Relation::Disjoint;
         }
         if (lp->type == PrimitiveType::Table)
         {
             if (get<TableType>(right))
                 return Relation::Superset;
-            else
-                return Relation::Disjoint;
+
+            return Relation::Disjoint;
         }
 
-        if (get<FunctionType>(right) || get<TableType>(right) || get<MetatableType>(right) || get<ClassType>(right))
+        if (get<FunctionType>(right) || get<TableType>(right) || get<MetatableType>(right) || get<ExternType>(right))
             return Relation::Disjoint;
     }
 
     if (auto ls = get<SingletonType>(left))
     {
-        if (get<FunctionType>(right) || get<TableType>(right) || get<MetatableType>(right) || get<ClassType>(right))
+        if (get<FunctionType>(right) || get<TableType>(right) || get<MetatableType>(right) || get<ExternType>(right))
             return Relation::Disjoint;
 
         if (get<PrimitiveType>(right))
             return flip(relate(right, left, seen));
+
         if (auto rs = get<SingletonType>(right))
         {
             if (ls->variant == rs->variant)
                 return Relation::Coincident;
-            else
-                return Relation::Disjoint;
+
+            return Relation::Disjoint;
         }
     }
 
@@ -499,11 +515,11 @@ Relation relate(TypeId left, TypeId right, SimplifierSeenSet& seen)
         {
             if (rp->type == PrimitiveType::Function)
                 return Relation::Subset;
-            else
-                return Relation::Disjoint;
+
+            return Relation::Disjoint;
         }
-        else
-            return Relation::Intersects;
+
+        return Relation::Intersects;
     }
 
     if (auto lt = get<TableType>(left))
@@ -512,10 +528,11 @@ Relation relate(TypeId left, TypeId right, SimplifierSeenSet& seen)
         {
             if (rp->type == PrimitiveType::Table)
                 return Relation::Subset;
-            else
-                return Relation::Disjoint;
+
+            return Relation::Disjoint;
         }
-        else if (auto rt = get<TableType>(right))
+
+        if (auto rt = get<TableType>(right))
         {
             // TODO PROBABLY indexers and metatables.
             if (1 == rt->props.size())
@@ -535,29 +552,58 @@ Relation relate(TypeId left, TypeId right, SimplifierSeenSet& seen)
                  */
                 if (lt->props.size() > 1 && r == Relation::Superset)
                     return Relation::Intersects;
-                else
-                    return r;
+
+                return r;
             }
-            else if (1 == lt->props.size())
+
+            if (1 == lt->props.size())
                 return flip(relate(right, left, seen));
-            else
-                return Relation::Intersects;
+
+            return Relation::Intersects;
         }
+
+        if (FFlag::LuauSimplificationTableExternType)
+        {
+            if (auto re = get<ExternType>(right))
+            {
+                Relation overall = Relation::Coincident;
+
+                for (auto& [name, prop] : lt->props)
+                {
+                    if (auto propInExternType = re->props.find(name); propInExternType != re->props.end())
+                    {
+                        Relation propRel = relate(prop.type(), propInExternType->second.type());
+
+                        if (propRel == Relation::Disjoint)
+                            return Relation::Disjoint;
+
+                        if (propRel == Relation::Coincident)
+                            continue;
+
+                        overall = Relation::Intersects;
+                    }
+                }
+
+                return overall;
+            }
+        }
+
         // TODO metatables
 
         return Relation::Disjoint;
     }
 
-    if (auto ct = get<ClassType>(left))
+    if (auto ct = get<ExternType>(left))
     {
-        if (auto rct = get<ClassType>(right))
+        if (auto rct = get<ExternType>(right))
         {
             if (isSubclass(ct, rct))
                 return Relation::Subset;
-            else if (isSubclass(rct, ct))
+
+            if (isSubclass(rct, ct))
                 return Relation::Superset;
-            else
-                return Relation::Disjoint;
+
+            return Relation::Disjoint;
         }
 
         return Relation::Disjoint;
@@ -707,7 +753,9 @@ TypeId TypeSimplifier::intersectUnionWithType(TypeId left, TypeId right)
     bool changed = false;
     std::set<TypeId> newParts;
 
-    if (leftUnion->options.size() > (size_t)DFInt::LuauSimplificationComplexityLimit)
+    size_t maxSize = DFInt::LuauSimplificationComplexityLimit;
+
+    if (leftUnion->options.size() > maxSize)
         return arena->addType(IntersectionType{{left, right}});
 
     for (TypeId part : leftUnion)
@@ -722,6 +770,13 @@ TypeId TypeSimplifier::intersectUnionWithType(TypeId left, TypeId right)
         }
 
         newParts.insert(simplified);
+
+        if (FFlag::LuauSimplificationRecheckAssumption)
+        {
+            // Initial combination size check could not predict nested union iteration
+            if (newParts.size() > maxSize)
+                return arena->addType(IntersectionType{{left, right}});
+        }
     }
 
     if (!changed)
@@ -762,6 +817,13 @@ TypeId TypeSimplifier::intersectUnions(TypeId left, TypeId right)
                 continue;
 
             newParts.insert(simplified);
+
+            if (FFlag::LuauSimplificationRecheckAssumption)
+            {
+                // Initial combination size check could not predict nested union iteration
+                if (newParts.size() > maxSize)
+                    return arena->addType(IntersectionType{{left, right}});
+            }
         }
     }
 
@@ -840,6 +902,78 @@ TypeId TypeSimplifier::intersectNegatedUnion(TypeId left, TypeId right)
         return intersectFromParts(std::move(newParts));
 }
 
+std::optional<TypeId> TypeSimplifier::basicIntersectWithTruthy(TypeId target) const
+{
+    target = follow(target);
+
+    if (is<UnknownType>(target))
+        return builtinTypes->truthyType;
+
+    if (is<AnyType>(target))
+        // any = *error-type* | unknown, so truthy & any = *error-type* | truthy
+        return arena->addType(UnionType{{builtinTypes->truthyType, builtinTypes->errorType}});
+
+    if (is<NeverType, ErrorType>(target))
+        return target;
+
+    if (is<FunctionType, TableType, MetatableType, ExternType>(target))
+        return target;
+
+    if (auto pt = get<PrimitiveType>(target))
+    {
+        switch (pt->type)
+        {
+        case PrimitiveType::NilType:
+            return builtinTypes->neverType;
+        case PrimitiveType::Boolean:
+            return builtinTypes->trueType;
+        default:
+            return target;
+        }
+    }
+
+    if (auto st = get<SingletonType>(target))
+        return st->variant == BooleanSingleton{false} ? builtinTypes->neverType : target;
+
+    return std::nullopt;
+}
+
+std::optional<TypeId> TypeSimplifier::basicIntersectWithFalsy(TypeId target) const
+{
+    target = follow(target);
+
+    if (is<NeverType, ErrorType>(target))
+        return target;
+
+    if (is<AnyType>(target))
+        // any = *error-type* | unknown, so falsy & any = *error-type* | falsy
+        return arena->addType(UnionType{{builtinTypes->falsyType, builtinTypes->errorType}});
+
+    if (is<UnknownType>(target))
+        return builtinTypes->falsyType;
+
+    if (is<FunctionType, TableType, MetatableType, ExternType>(target))
+        return builtinTypes->neverType;
+
+    if (auto pt = get<PrimitiveType>(target))
+    {
+        switch (pt->type)
+        {
+        case PrimitiveType::NilType:
+            return builtinTypes->nilType;
+        case PrimitiveType::Boolean:
+            return builtinTypes->falseType;
+        default:
+            return builtinTypes->neverType;
+        }
+    }
+
+    if (auto st = get<SingletonType>(target))
+        return st->variant == BooleanSingleton{false} ? builtinTypes->falseType : builtinTypes->neverType;
+
+    return std::nullopt;
+}
+
 TypeId TypeSimplifier::intersectTypeWithNegation(TypeId left, TypeId right)
 {
     const NegationType* leftNegation = get<NegationType>(left);
@@ -1066,11 +1200,8 @@ TypeId TypeSimplifier::intersectIntersectionWithType(TypeId left, TypeId right)
 
 std::optional<TypeId> TypeSimplifier::basicIntersect(TypeId left, TypeId right)
 {
-    if (FFlag::LuauFlagBasicIntersectFollows)
-    {
-        left = follow(left);
-        right = follow(right);
-    }
+    left = follow(left);
+    right = follow(right);
 
     if (get<AnyType>(left) && get<ErrorType>(right))
         return right;
@@ -1179,6 +1310,25 @@ std::optional<TypeId> TypeSimplifier::basicIntersect(TypeId left, TypeId right)
         return std::nullopt;
     }
 
+    if (FFlag::LuauOptimizeFalsyAndTruthyIntersect)
+    {
+        if (isTruthyType(left))
+            if (auto res = basicIntersectWithTruthy(right))
+                return res;
+
+        if (isTruthyType(right))
+            if (auto res = basicIntersectWithTruthy(left))
+                return res;
+
+        if (isFalsyType(left))
+            if (auto res = basicIntersectWithFalsy(right))
+                return res;
+
+        if (isFalsyType(right))
+            if (auto res = basicIntersectWithFalsy(left))
+                return res;
+    }
+
     Relation relation = relate(left, right);
     if (left == right || Relation::Coincident == relation)
         return left;

Analysis/src/Substitution.cpp

@@ -2,24 +2,23 @@
 #include "Luau/Substitution.h"
 
 #include "Luau/Common.h"
-#include "Luau/Clone.h"
 #include "Luau/TxnLog.h"
 #include "Luau/Type.h"
 
 #include <algorithm>
-#include <stdexcept>
 
 LUAU_FASTINTVARIABLE(LuauTarjanChildLimit, 10000)
 LUAU_FASTFLAG(LuauSolverV2)
 LUAU_FASTINTVARIABLE(LuauTarjanPreallocationSize, 256)
 LUAU_FASTFLAG(LuauSyntheticErrors)
+LUAU_FASTFLAG(LuauDeprecatedAttribute)
 
 namespace Luau
 {
 
-static TypeId shallowClone(TypeId ty, TypeArena& dest, const TxnLog* log, bool alwaysClone)
+static TypeId shallowClone(TypeId ty, TypeArena& dest, const TxnLog* log)
 {
-    auto go = [ty, &dest, alwaysClone](auto&& a)
+    auto go = [ty, &dest](auto&& a)
     {
         using T = std::decay_t<decltype(a)>;
 
@@ -95,13 +94,15 @@ static TypeId shallowClone(TypeId ty, TypeArena& dest, const TxnLog* log, bool a
             return dest.addType(a);
         else if constexpr (std::is_same_v<T, FunctionType>)
         {
-            FunctionType clone = FunctionType{a.level, a.scope, a.argTypes, a.retTypes, a.definition, a.hasSelf};
+            FunctionType clone = FunctionType{a.level, a.argTypes, a.retTypes, a.definition, a.hasSelf};
             clone.generics = a.generics;
             clone.genericPacks = a.genericPacks;
             clone.magic = a.magic;
             clone.tags = a.tags;
             clone.argNames = a.argNames;
             clone.isCheckedFunction = a.isCheckedFunction;
+            if (FFlag::LuauDeprecatedAttribute)
+                clone.isDeprecatedFunction = a.isDeprecatedFunction;
             return dest.addType(std::move(clone));
         }
         else if constexpr (std::is_same_v<T, TableType>)
@@ -135,15 +136,10 @@ static TypeId shallowClone(TypeId ty, TypeArena& dest, const TxnLog* log, bool a
             clone.parts = a.parts;
             return dest.addType(std::move(clone));
         }
-        else if constexpr (std::is_same_v<T, ClassType>)
+        else if constexpr (std::is_same_v<T, ExternType>)
         {
-            if (alwaysClone)
-            {
-                ClassType clone{a.name, a.props, a.parent, a.metatable, a.tags, a.userData, a.definitionModuleName, a.definitionLocation, a.indexer};
-                return dest.addType(std::move(clone));
-            }
-            else
-                return ty;
+            ExternType clone{a.name, a.props, a.parent, a.metatable, a.tags, a.userData, a.definitionModuleName, a.definitionLocation, a.indexer};
+            return dest.addType(std::move(clone));
         }
         else if constexpr (std::is_same_v<T, NegationType>)
             return dest.addType(NegationType{a.ty});
@@ -256,21 +252,21 @@ void Tarjan::visitChildren(TypeId ty, int index)
         for (TypePackId a : tfit->packArguments)
             visitChild(a);
     }
-    else if (const ClassType* ctv = get<ClassType>(ty))
+    else if (const ExternType* etv = get<ExternType>(ty))
     {
-        for (const auto& [name, prop] : ctv->props)
+        for (const auto& [name, prop] : etv->props)
             visitChild(prop.type());
 
-        if (ctv->parent)
-            visitChild(*ctv->parent);
+        if (etv->parent)
+            visitChild(*etv->parent);
 
-        if (ctv->metatable)
-            visitChild(*ctv->metatable);
+        if (etv->metatable)
+            visitChild(*etv->metatable);
 
-        if (ctv->indexer)
+        if (etv->indexer)
         {
-            visitChild(ctv->indexer->indexType);
-            visitChild(ctv->indexer->indexResultType);
+            visitChild(etv->indexer->indexType);
+            visitChild(etv->indexer->indexResultType);
         }
     }
     else if (const NegationType* ntv = get<NegationType>(ty))
@@ -544,6 +540,27 @@ void Tarjan::visitSCC(int index)
     }
 }
 
+bool Tarjan::ignoreChildren(TypeId ty)
+{
+    return false;
+}
+
+bool Tarjan::ignoreChildren(TypePackId ty)
+{
+    return false;
+}
+
+// Some subclasses might ignore children visit, but not other actions like replacing the children
+bool Tarjan::ignoreChildrenVisit(TypeId ty)
+{
+    return ignoreChildren(ty);
+}
+
+bool Tarjan::ignoreChildrenVisit(TypePackId ty)
+{
+    return ignoreChildren(ty);
+}
+
 TarjanResult Tarjan::findDirty(TypeId ty)
 {
     return visitRoot(ty);
@@ -554,6 +571,11 @@ TarjanResult Tarjan::findDirty(TypePackId tp)
     return visitRoot(tp);
 }
 
+Substitution::Substitution(TypeArena* arena)
+    : Substitution(TxnLog::empty(), arena)
+{
+}
+
 Substitution::Substitution(const TxnLog* log_, TypeArena* arena)
     : arena(arena)
 {
@@ -654,7 +676,7 @@ void Substitution::resetState(const TxnLog* log, TypeArena* arena)
 
 TypeId Substitution::clone(TypeId ty)
 {
-    return shallowClone(ty, *arena, log, /* alwaysClone */ true);
+    return shallowClone(ty, *arena, log);
 }
 
 TypePackId Substitution::clone(TypePackId tp)
@@ -816,21 +838,21 @@ void Substitution::replaceChildren(TypeId ty)
         for (TypePackId& a : tfit->packArguments)
             a = replace(a);
     }
-    else if (ClassType* ctv = getMutable<ClassType>(ty))
+    else if (ExternType* etv = getMutable<ExternType>(ty))
     {
-        for (auto& [name, prop] : ctv->props)
+        for (auto& [name, prop] : etv->props)
             prop.setType(replace(prop.type()));
 
-        if (ctv->parent)
-            ctv->parent = replace(*ctv->parent);
+        if (etv->parent)
+            etv->parent = replace(*etv->parent);
 
-        if (ctv->metatable)
-            ctv->metatable = replace(*ctv->metatable);
+        if (etv->metatable)
+            etv->metatable = replace(*etv->metatable);
 
-        if (ctv->indexer)
+        if (etv->indexer)
         {
-            ctv->indexer->indexType = replace(ctv->indexer->indexType);
-            ctv->indexer->indexResultType = replace(ctv->indexer->indexResultType);
+            etv->indexer->indexType = replace(etv->indexer->indexType);
+            etv->indexer->indexResultType = replace(etv->indexer->indexResultType);
         }
     }
     else if (NegationType* ntv = getMutable<NegationType>(ty))
@@ -870,4 +892,13 @@ void Substitution::replaceChildren(TypePackId tp)
     }
 }
 
+template<typename Ty>
+std::optional<Ty> Substitution::replace(std::optional<Ty> ty)
+{
+    if (ty)
+        return replace(*ty);
+    else
+        return std::nullopt;
+}
+
 } // namespace Luau

Analysis/src/Subtyping.cpp

@@ -7,13 +7,11 @@
 #include "Luau/Normalize.h"
 #include "Luau/RecursionCounter.h"
 #include "Luau/Scope.h"
-#include "Luau/StringUtils.h"
 #include "Luau/Substitution.h"
 #include "Luau/ToString.h"
 #include "Luau/TxnLog.h"
 #include "Luau/Type.h"
 #include "Luau/TypeArena.h"
-#include "Luau/TypeCheckLimits.h"
 #include "Luau/TypeFunction.h"
 #include "Luau/TypePack.h"
 #include "Luau/TypePath.h"
@@ -22,7 +20,8 @@
 #include <algorithm>
 
 LUAU_FASTFLAGVARIABLE(DebugLuauSubtypingCheckPathValidity)
-LUAU_FASTFLAGVARIABLE(LuauSubtypingFixTailPack)
+LUAU_FASTINTVARIABLE(LuauSubtypingReasoningLimit, 100)
+LUAU_FASTFLAGVARIABLE(LuauSubtypingEnableReasoningLimit)
 
 namespace Luau
 {
@@ -32,7 +31,7 @@ struct VarianceFlipper
     Subtyping::Variance* variance;
     Subtyping::Variance oldValue;
 
-    VarianceFlipper(Subtyping::Variance* v)
+    explicit VarianceFlipper(Subtyping::Variance* v)
         : variance(v)
         , oldValue(*v)
     {
@@ -100,6 +99,9 @@ static SubtypingReasonings mergeReasonings(const SubtypingReasonings& a, const S
             else
                 result.insert(r);
         }
+
+        if (FFlag::LuauSubtypingEnableReasoningLimit && result.size() >= size_t(FInt::LuauSubtypingReasoningLimit))
+            return result;
     }
 
     for (const SubtypingReasoning& r : b)
@@ -116,6 +118,9 @@ static SubtypingReasonings mergeReasonings(const SubtypingReasonings& a, const S
             else
                 result.insert(r);
         }
+
+        if (FFlag::LuauSubtypingEnableReasoningLimit && result.size() >= size_t(FInt::LuauSubtypingReasoningLimit))
+            return result;
     }
 
     return result;
@@ -308,7 +313,7 @@ struct ApplyMappedGenerics : Substitution
 
     bool ignoreChildren(TypeId ty) override
     {
-        if (get<ClassType>(ty))
+        if (get<ExternType>(ty))
             return true;
 
         return ty->persistent;
@@ -416,6 +421,14 @@ SubtypingResult Subtyping::isSubtype(TypeId subTy, TypeId superTy, NotNull<Scope
 
     SubtypingResult result = isCovariantWith(env, subTy, superTy, scope);
 
+    if (result.normalizationTooComplex)
+    {
+        if (result.isCacheable)
+            resultCache[{subTy, superTy}] = result;
+
+        return result;
+    }
+
     for (const auto& [subTy, bounds] : env.mappedGenerics)
     {
         const auto& lb = bounds.lowerBound;
@@ -593,7 +606,12 @@ SubtypingResult Subtyping::isCovariantWith(SubtypingEnvironment& env, TypeId sub
         if (!result.isSubtype && !result.normalizationTooComplex)
         {
             SubtypingResult semantic = isCovariantWith(env, normalizer->normalize(subTy), normalizer->normalize(superTy), scope);
-            if (semantic.isSubtype)
+
+            if (semantic.normalizationTooComplex)
+            {
+                result = semantic;
+            }
+            else if (semantic.isSubtype)
             {
                 semantic.reasoning.clear();
                 result = semantic;
@@ -608,7 +626,12 @@ SubtypingResult Subtyping::isCovariantWith(SubtypingEnvironment& env, TypeId sub
         if (!result.isSubtype && !result.normalizationTooComplex)
         {
             SubtypingResult semantic = isCovariantWith(env, normalizer->normalize(subTy), normalizer->normalize(superTy), scope);
-            if (semantic.isSubtype)
+
+            if (semantic.normalizationTooComplex)
+            {
+                result = semantic;
+            }
+            else if (semantic.isSubtype)
             {
                 // Clear the semantic reasoning, as any reasonings within
                 // potentially contain invalid paths.
@@ -719,9 +742,9 @@ SubtypingResult Subtyping::isCovariantWith(SubtypingEnvironment& env, TypeId sub
         result = isCovariantWith(env, p, scope);
     else if (auto p = get2<MetatableType, TableType>(subTy, superTy))
         result = isCovariantWith(env, p, scope);
-    else if (auto p = get2<ClassType, ClassType>(subTy, superTy))
+    else if (auto p = get2<ExternType, ExternType>(subTy, superTy))
         result = isCovariantWith(env, p, scope);
-    else if (auto p = get2<ClassType, TableType>(subTy, superTy))
+    else if (auto p = get2<ExternType, TableType>(subTy, superTy))
         result = isCovariantWith(env, subTy, p.first, superTy, p.second, scope);
     else if (auto p = get2<TableType, PrimitiveType>(subTy, superTy))
         result = isCovariantWith(env, p, scope);
@@ -754,7 +777,8 @@ SubtypingResult Subtyping::isCovariantWith(SubtypingEnvironment& env, TypePackId
     // Match head types pairwise
 
     for (size_t i = 0; i < headSize; ++i)
-        results.push_back(isCovariantWith(env, subHead[i], superHead[i], scope).withBothComponent(TypePath::Index{i}));
+        results.push_back(isCovariantWith(env, subHead[i], superHead[i], scope).withBothComponent(TypePath::Index{i, TypePath::Index::Variant::Pack})
+        );
 
     // Handle mismatched head sizes
 
@@ -767,7 +791,7 @@ SubtypingResult Subtyping::isCovariantWith(SubtypingEnvironment& env, TypePackId
                 for (size_t i = headSize; i < superHead.size(); ++i)
                     results.push_back(isCovariantWith(env, vt->ty, superHead[i], scope)
                                           .withSubPath(TypePath::PathBuilder().tail().variadic().build())
-                                          .withSuperComponent(TypePath::Index{i}));
+                                          .withSuperComponent(TypePath::Index{i, TypePath::Index::Variant::Pack}));
             }
             else if (auto gt = get<GenericTypePack>(*subTail))
             {
@@ -821,7 +845,7 @@ SubtypingResult Subtyping::isCovariantWith(SubtypingEnvironment& env, TypePackId
             {
                 for (size_t i = headSize; i < subHead.size(); ++i)
                     results.push_back(isCovariantWith(env, subHead[i], vt->ty, scope)
-                                          .withSubComponent(TypePath::Index{i})
+                                          .withSubComponent(TypePath::Index{i, TypePath::Index::Variant::Pack})
                                           .withSuperPath(TypePath::PathBuilder().tail().variadic().build()));
             }
             else if (auto gt = get<GenericTypePack>(*superTail))
@@ -859,7 +883,7 @@ SubtypingResult Subtyping::isCovariantWith(SubtypingEnvironment& env, TypePackId
             else
                 return SubtypingResult{false}
                     .withSuperComponent(TypePath::PackField::Tail)
-                    .withError({scope->location, UnexpectedTypePackInSubtyping{FFlag::LuauSubtypingFixTailPack ? *superTail : *subTail}});
+                    .withError({scope->location, UnexpectedTypePackInSubtyping{*superTail}});
         }
         else
             return {false};
@@ -1082,6 +1106,10 @@ SubtypingResult Subtyping::isCovariantWith(SubtypingEnvironment& env, TypeId sub
     for (TypeId ty : superUnion)
     {
         SubtypingResult next = isCovariantWith(env, subTy, ty, scope);
+
+        if (next.normalizationTooComplex)
+            return SubtypingResult{false, /* normalizationTooComplex */ true};
+
         if (next.isSubtype)
             return SubtypingResult{true};
     }
@@ -1100,7 +1128,13 @@ SubtypingResult Subtyping::isCovariantWith(SubtypingEnvironment& env, const Unio
     std::vector<SubtypingResult> subtypings;
     size_t i = 0;
     for (TypeId ty : subUnion)
-        subtypings.push_back(isCovariantWith(env, ty, superTy, scope).withSubComponent(TypePath::Index{i++}));
+    {
+        subtypings.push_back(isCovariantWith(env, ty, superTy, scope).withSubComponent(TypePath::Index{i++, TypePath::Index::Variant::Union}));
+
+        if (subtypings.back().normalizationTooComplex)
+            return SubtypingResult{false, /* normalizationTooComplex */ true};
+    }
+
     return SubtypingResult::all(subtypings);
 }
 
@@ -1110,7 +1144,13 @@ SubtypingResult Subtyping::isCovariantWith(SubtypingEnvironment& env, TypeId sub
     std::vector<SubtypingResult> subtypings;
     size_t i = 0;
     for (TypeId ty : superIntersection)
-        subtypings.push_back(isCovariantWith(env, subTy, ty, scope).withSuperComponent(TypePath::Index{i++}));
+    {
+        subtypings.push_back(isCovariantWith(env, subTy, ty, scope).withSuperComponent(TypePath::Index{i++, TypePath::Index::Variant::Intersection}));
+
+        if (subtypings.back().normalizationTooComplex)
+            return SubtypingResult{false, /* normalizationTooComplex */ true};
+    }
+
     return SubtypingResult::all(subtypings);
 }
 
@@ -1120,7 +1160,13 @@ SubtypingResult Subtyping::isCovariantWith(SubtypingEnvironment& env, const Inte
     std::vector<SubtypingResult> subtypings;
     size_t i = 0;
     for (TypeId ty : subIntersection)
-        subtypings.push_back(isCovariantWith(env, ty, superTy, scope).withSubComponent(TypePath::Index{i++}));
+    {
+        subtypings.push_back(isCovariantWith(env, ty, superTy, scope).withSubComponent(TypePath::Index{i++, TypePath::Index::Variant::Intersection}));
+
+        if (subtypings.back().normalizationTooComplex)
+            return SubtypingResult{false, /* normalizationTooComplex */ true};
+    }
+
     return SubtypingResult::any(subtypings);
 }
 
@@ -1288,7 +1334,7 @@ SubtypingResult Subtyping::isCovariantWith(SubtypingEnvironment& env, const Type
     }
     // the top class type is not actually a primitive type, so the negation of
     // any one of them includes the top class type.
-    else if (auto p = get2<ClassType, PrimitiveType>(subTy, negatedTy))
+    else if (auto p = get2<ExternType, PrimitiveType>(subTy, negatedTy))
         result = {true};
     else if (auto p = get<PrimitiveType>(negatedTy); p && is<TableType, MetatableType>(subTy))
         result = {p->type != PrimitiveType::Table};
@@ -1296,9 +1342,9 @@ SubtypingResult Subtyping::isCovariantWith(SubtypingEnvironment& env, const Type
         result = {p.second->type != PrimitiveType::Function};
     else if (auto p = get2<SingletonType, SingletonType>(subTy, negatedTy))
         result = {*p.first != *p.second};
-    else if (auto p = get2<ClassType, ClassType>(subTy, negatedTy))
+    else if (auto p = get2<ExternType, ExternType>(subTy, negatedTy))
         result = SubtypingResult::negate(isCovariantWith(env, p.first, p.second, scope));
-    else if (get2<FunctionType, ClassType>(subTy, negatedTy))
+    else if (get2<FunctionType, ExternType>(subTy, negatedTy))
         result = {true};
     else if (is<ErrorType, FunctionType, TableType, MetatableType>(negatedTy))
         iceReporter->ice("attempting to negate a non-testable type");
@@ -1410,7 +1456,7 @@ SubtypingResult Subtyping::isCovariantWith(SubtypingEnvironment& env, const Meta
         // of the supertype table.
         //
         // There's a flaw here in that if the __index metamethod contributes a new
-        // field that would satisfy the subtyping relationship, we'll erronously say
+        // field that would satisfy the subtyping relationship, we'll erroneously say
         // that the metatable isn't a subtype of the table, even though they have
         // compatible properties/shapes. We'll revisit this later when we have a
         // better understanding of how important this is.
@@ -1423,15 +1469,15 @@ SubtypingResult Subtyping::isCovariantWith(SubtypingEnvironment& env, const Meta
     }
 }
 
-SubtypingResult Subtyping::isCovariantWith(SubtypingEnvironment& env, const ClassType* subClass, const ClassType* superClass, NotNull<Scope> scope)
+SubtypingResult Subtyping::isCovariantWith(SubtypingEnvironment& env, const ExternType* subExternType, const ExternType* superExternType, NotNull<Scope> scope)
 {
-    return {isSubclass(subClass, superClass)};
+    return {isSubclass(subExternType, superExternType)};
 }
 
 SubtypingResult Subtyping::isCovariantWith(
     SubtypingEnvironment& env,
     TypeId subTy,
-    const ClassType* subClass,
+    const ExternType* subExternType,
     TypeId superTy,
     const TableType* superTable,
     NotNull<Scope> scope
@@ -1443,7 +1489,7 @@ SubtypingResult Subtyping::isCovariantWith(
 
     for (const auto& [name, prop] : superTable->props)
     {
-        if (auto classProp = lookupClassProp(subClass, name))
+        if (auto classProp = lookupExternTypeProp(subExternType, name))
         {
             result.andAlso(isCovariantWith(env, *classProp, prop, name, scope));
         }
@@ -1613,7 +1659,7 @@ SubtypingResult Subtyping::isCovariantWith(
     SubtypingResult result = isCovariantWith(env, subNorm->tops, superNorm->tops, scope);
     result.andAlso(isCovariantWith(env, subNorm->booleans, superNorm->booleans, scope));
     result.andAlso(
-        isCovariantWith(env, subNorm->classes, superNorm->classes, scope).orElse(isCovariantWith(env, subNorm->classes, superNorm->tables, scope))
+        isCovariantWith(env, subNorm->externTypes, superNorm->externTypes, scope).orElse(isCovariantWith(env, subNorm->externTypes, superNorm->tables, scope))
     );
     result.andAlso(isCovariantWith(env, subNorm->errors, superNorm->errors, scope));
     result.andAlso(isCovariantWith(env, subNorm->nils, superNorm->nils, scope));
@@ -1630,24 +1676,24 @@ SubtypingResult Subtyping::isCovariantWith(
 
 SubtypingResult Subtyping::isCovariantWith(
     SubtypingEnvironment& env,
-    const NormalizedClassType& subClass,
-    const NormalizedClassType& superClass,
+    const NormalizedExternType& subExternType,
+    const NormalizedExternType& superExternType,
     NotNull<Scope> scope
 )
 {
-    for (const auto& [subClassTy, _] : subClass.classes)
+    for (const auto& [subExternTypeTy, _] : subExternType.externTypes)
     {
         SubtypingResult result;
 
-        for (const auto& [superClassTy, superNegations] : superClass.classes)
+        for (const auto& [superExternTypeTy, superNegations] : superExternType.externTypes)
         {
-            result.orElse(isCovariantWith(env, subClassTy, superClassTy, scope));
+            result.orElse(isCovariantWith(env, subExternTypeTy, superExternTypeTy, scope));
             if (!result.isSubtype)
                 continue;
 
             for (TypeId negation : superNegations)
             {
-                result.andAlso(SubtypingResult::negate(isCovariantWith(env, subClassTy, negation, scope)));
+                result.andAlso(SubtypingResult::negate(isCovariantWith(env, subExternTypeTy, negation, scope)));
                 if (result.isSubtype)
                     break;
             }
@@ -1662,17 +1708,17 @@ SubtypingResult Subtyping::isCovariantWith(
 
 SubtypingResult Subtyping::isCovariantWith(
     SubtypingEnvironment& env,
-    const NormalizedClassType& subClass,
+    const NormalizedExternType& subExternType,
     const TypeIds& superTables,
     NotNull<Scope> scope
 )
 {
-    for (const auto& [subClassTy, _] : subClass.classes)
+    for (const auto& [subExternTypeTy, _] : subExternType.externTypes)
     {
         SubtypingResult result;
 
         for (TypeId superTableTy : superTables)
-            result.orElse(isCovariantWith(env, subClassTy, superTableTy, scope));
+            result.orElse(isCovariantWith(env, subExternTypeTy, superTableTy, scope));
 
         if (!result.isSubtype)
             return result;
@@ -1760,7 +1806,12 @@ SubtypingResult Subtyping::isCovariantWith(SubtypingEnvironment& env, const Type
     {
         results.emplace_back();
         for (TypeId superTy : superTypes)
+        {
             results.back().orElse(isCovariantWith(env, subTy, superTy, scope));
+
+            if (results.back().normalizationTooComplex)
+                return SubtypingResult{false, /* normalizationTooComplex */ true};
+        }
     }
 
     return SubtypingResult::all(results);

Analysis/src/Symbol.cpp

@@ -4,7 +4,6 @@
 #include "Luau/Common.h"
 
 LUAU_FASTFLAG(LuauSolverV2)
-LUAU_FASTFLAGVARIABLE(LuauSymbolEquality)
 
 namespace Luau
 {
@@ -15,10 +14,8 @@ bool Symbol::operator==(const Symbol& rhs) const
         return local == rhs.local;
     else if (global.value)
         return rhs.global.value && global == rhs.global.value; // Subtlety: AstName::operator==(const char*) uses strcmp, not pointer identity.
-    else if (FFlag::LuauSolverV2 || FFlag::LuauSymbolEquality)
-        return !rhs.local && !rhs.global.value; // Reflexivity: we already know `this` Symbol is empty, so check that rhs is.
     else
-        return false;
+        return !rhs.local && !rhs.global.value; // Reflexivity: we already know `this` Symbol is empty, so check that rhs is.
 }
 
 std::string toString(const Symbol& name)

Analysis/src/TableLiteralInference.cpp

@@ -1,16 +1,21 @@
 // This file is part of the Luau programming language and is licensed under MIT License; see LICENSE.txt for details
 
+#include "Luau/TableLiteralInference.h"
+
 #include "Luau/Ast.h"
+#include "Luau/Common.h"
 #include "Luau/Normalize.h"
 #include "Luau/Simplify.h"
+#include "Luau/Subtyping.h"
 #include "Luau/Type.h"
 #include "Luau/ToString.h"
 #include "Luau/TypeArena.h"
 #include "Luau/TypeUtils.h"
 #include "Luau/Unifier2.h"
 
-LUAU_FASTFLAGVARIABLE(LuauDontInPlaceMutateTableType)
-LUAU_FASTFLAGVARIABLE(LuauAllowNonSharedTableTypesInLiteral)
+LUAU_FASTFLAGVARIABLE(LuauBidirectionalInferenceCollectIndexerTypes)
+LUAU_FASTFLAGVARIABLE(LuauBidirectionalFailsafe)
+LUAU_FASTFLAGVARIABLE(LuauBidirectionalInferenceElideAssert)
 
 namespace Luau
 {
@@ -112,6 +117,7 @@ TypeId matchLiteralType(
     NotNull<BuiltinTypes> builtinTypes,
     NotNull<TypeArena> arena,
     NotNull<Unifier2> unifier,
+    NotNull<Subtyping> subtyping,
     TypeId expectedType,
     TypeId exprType,
     const AstExpr* expr,
@@ -132,17 +138,33 @@ TypeId matchLiteralType(
      * things like replace explicit named properties with indexers as required
      * by the expected type.
      */
+
     if (!isLiteral(expr))
-        return exprType;
+    {
+        auto result = subtyping->isSubtype(/*subTy=*/exprType, /*superTy=*/expectedType, unifier->scope);
+        return result.isSubtype ? expectedType : exprType;
+    }
 
     expectedType = follow(expectedType);
     exprType = follow(exprType);
 
-    if (get<AnyType>(expectedType) || get<UnknownType>(expectedType))
+    if (FFlag::LuauBidirectionalInferenceCollectIndexerTypes)
     {
-        // "Narrowing" to unknown or any is not going to do anything useful.
-        return exprType;
+        // The intent of `matchLiteralType` is to upcast values when it's safe
+        // to do so. it's always safe to upcast to `any` or `unknown`, so we
+        // can unconditionally do so here.
+        if (is<AnyType, UnknownType>(expectedType))
+            return expectedType;
     }
+    else
+    {
+        if (get<AnyType>(expectedType) || get<UnknownType>(expectedType))
+        {
+            // "Narrowing" to unknown or any is not going to do anything useful.
+            return exprType;
+        }
+    }
+
 
     if (expr->is<AstExprConstantString>())
     {
@@ -210,11 +232,27 @@ TypeId matchLiteralType(
         return exprType;
     }
 
-    // TODO: lambdas
+
+    if (expr->is<AstExprFunction>())
+    {
+        // TODO: Push argument / return types into the lambda. For now, just do
+        // the non-literal thing: check for a subtype and upcast if valid.
+        auto result = subtyping->isSubtype(/*subTy=*/exprType, /*superTy=*/expectedType, unifier->scope);
+        return result.isSubtype ? expectedType : exprType;
+    }
 
     if (auto exprTable = expr->as<AstExprTable>())
     {
         TableType* const tableTy = getMutable<TableType>(exprType);
+
+        // This can occur if we have an expression like:
+        //
+        //  { x = {}, x = 42 }
+        //
+        // The type of this will be `{ x: number }`
+        if (FFlag::LuauBidirectionalFailsafe && !tableTy)
+            return exprType;
+
         LUAU_ASSERT(tableTy);
 
         const TableType* expectedTableTy = get<TableType>(expectedType);
@@ -229,7 +267,7 @@ TypeId matchLiteralType(
 
                 if (tt)
                 {
-                    TypeId res = matchLiteralType(astTypes, astExpectedTypes, builtinTypes, arena, unifier, *tt, exprType, expr, toBlock);
+                    TypeId res = matchLiteralType(astTypes, astExpectedTypes, builtinTypes, arena, unifier, subtyping, *tt, exprType, expr, toBlock);
 
                     parts.push_back(res);
                     return arena->addType(UnionType{std::move(parts)});
@@ -241,6 +279,9 @@ TypeId matchLiteralType(
 
         DenseHashSet<AstExprConstantString*> keysToDelete{nullptr};
 
+        DenseHashSet<TypeId> indexerKeyTypes{nullptr};
+        DenseHashSet<TypeId> indexerValueTypes{nullptr};
+
         for (const AstExprTable::Item& item : exprTable->items)
         {
             if (isRecord(item))
@@ -248,23 +289,20 @@ TypeId matchLiteralType(
                 const AstArray<char>& s = item.key->as<AstExprConstantString>()->value;
                 std::string keyStr{s.data, s.data + s.size};
                 auto it = tableTy->props.find(keyStr);
+
+                // This can occur, potentially, if we are re-entrant.
+                if (FFlag::LuauBidirectionalFailsafe && it == tableTy->props.end())
+                    continue;
+
                 LUAU_ASSERT(it != tableTy->props.end());
 
                 Property& prop = it->second;
 
-                if (FFlag::LuauAllowNonSharedTableTypesInLiteral)
-                {
-                    // If we encounter a duplcate property, we may have already
-                    // set it to be read-only. If that's the case, the only thing
-                    // that will definitely crash is trying to access a write
-                    // only property.
-                    LUAU_ASSERT(!prop.isWriteOnly());
-                }
-                else
-                {
-                    // Table literals always initially result in shared read-write types
-                    LUAU_ASSERT(prop.isShared());
-                }
+                // If we encounter a duplcate property, we may have already
+                // set it to be read-only. If that's the case, the only thing
+                // that will definitely crash is trying to access a write
+                // only property.
+                LUAU_ASSERT(!prop.isWriteOnly());
                 TypeId propTy = *prop.readTy;
 
                 auto it2 = expectedTableTy->props.find(keyStr);
@@ -285,21 +323,27 @@ TypeId matchLiteralType(
                             builtinTypes,
                             arena,
                             unifier,
+                            subtyping,
                             expectedTableTy->indexer->indexResultType,
                             propTy,
                             item.value,
                             toBlock
                         );
 
-                        if (tableTy->indexer)
-                            unifier->unify(matchedType, tableTy->indexer->indexResultType);
+                        if (FFlag::LuauBidirectionalInferenceCollectIndexerTypes)
+                        {
+                            indexerKeyTypes.insert(arena->addType(SingletonType{StringSingleton{keyStr}}));
+                            indexerValueTypes.insert(matchedType);
+                        }
                         else
-                            tableTy->indexer = TableIndexer{expectedTableTy->indexer->indexType, matchedType};
+                        {
+                            if (tableTy->indexer)
+                                unifier->unify(matchedType, tableTy->indexer->indexResultType);
+                            else
+                                tableTy->indexer = TableIndexer{expectedTableTy->indexer->indexType, matchedType};
+                        }
 
-                        if (FFlag::LuauDontInPlaceMutateTableType)
-                            keysToDelete.insert(item.key->as<AstExprConstantString>());
-                        else
-                            tableTy->props.erase(keyStr);
+                        keysToDelete.insert(item.key->as<AstExprConstantString>());
                     }
 
                     // If it's just an extra property and the expected type
@@ -322,22 +366,25 @@ TypeId matchLiteralType(
                 // quadratic in a hurry.
                 if (expectedProp.isShared())
                 {
-                    matchedType =
-                        matchLiteralType(astTypes, astExpectedTypes, builtinTypes, arena, unifier, *expectedReadTy, propTy, item.value, toBlock);
+                    matchedType = matchLiteralType(
+                        astTypes, astExpectedTypes, builtinTypes, arena, unifier, subtyping, *expectedReadTy, propTy, item.value, toBlock
+                    );
                     prop.readTy = matchedType;
                     prop.writeTy = matchedType;
                 }
                 else if (expectedReadTy)
                 {
-                    matchedType =
-                        matchLiteralType(astTypes, astExpectedTypes, builtinTypes, arena, unifier, *expectedReadTy, propTy, item.value, toBlock);
+                    matchedType = matchLiteralType(
+                        astTypes, astExpectedTypes, builtinTypes, arena, unifier, subtyping, *expectedReadTy, propTy, item.value, toBlock
+                    );
                     prop.readTy = matchedType;
                     prop.writeTy.reset();
                 }
                 else if (expectedWriteTy)
                 {
-                    matchedType =
-                        matchLiteralType(astTypes, astExpectedTypes, builtinTypes, arena, unifier, *expectedWriteTy, propTy, item.value, toBlock);
+                    matchedType = matchLiteralType(
+                        astTypes, astExpectedTypes, builtinTypes, arena, unifier, subtyping, *expectedWriteTy, propTy, item.value, toBlock
+                    );
                     prop.readTy.reset();
                     prop.writeTy = matchedType;
                 }
@@ -354,10 +401,16 @@ TypeId matchLiteralType(
                 LUAU_ASSERT(matchedType);
 
                 (*astExpectedTypes)[item.value] = matchedType;
+                // NOTE: We do *not* add to the potential indexer types here.
+                // I think this is correct to support something like:
+                //
+                //  { [string]: number, foo: boolean }
+                //
             }
             else if (item.kind == AstExprTable::Item::List)
             {
-                LUAU_ASSERT(tableTy->indexer);
+                if (!FFlag::LuauBidirectionalInferenceCollectIndexerTypes || !FFlag::LuauBidirectionalInferenceElideAssert)
+                    LUAU_ASSERT(tableTy->indexer);
 
                 if (expectedTableTy->indexer)
                 {
@@ -371,15 +424,24 @@ TypeId matchLiteralType(
                         builtinTypes,
                         arena,
                         unifier,
+                        subtyping,
                         expectedTableTy->indexer->indexResultType,
                         *propTy,
                         item.value,
                         toBlock
                     );
 
-                    // if the index result type is the prop type, we can replace it with the matched type here.
-                    if (tableTy->indexer->indexResultType == *propTy)
-                        tableTy->indexer->indexResultType = matchedType;
+                    if (FFlag::LuauBidirectionalInferenceCollectIndexerTypes)
+                    {
+                        indexerKeyTypes.insert(builtinTypes->numberType);
+                        indexerValueTypes.insert(matchedType);
+                    }
+                    else
+                    {
+                        // if the index result type is the prop type, we can replace it with the matched type here.
+                        if (tableTy->indexer->indexResultType == *propTy)
+                            tableTy->indexer->indexResultType = matchedType;
+                    }
                 }
             }
             else if (item.kind == AstExprTable::Item::General)
@@ -401,19 +463,22 @@ TypeId matchLiteralType(
                 // Populate expected types for non-string keys declared with [] (the code below will handle the case where they are strings)
                 if (!item.key->as<AstExprConstantString>() && expectedTableTy->indexer)
                     (*astExpectedTypes)[item.key] = expectedTableTy->indexer->indexType;
+
+                if (FFlag::LuauBidirectionalInferenceCollectIndexerTypes)
+                {
+                    indexerKeyTypes.insert(tKey);
+                    indexerValueTypes.insert(tProp);
+                }
             }
             else
                 LUAU_ASSERT(!"Unexpected");
         }
 
-        if (FFlag::LuauDontInPlaceMutateTableType)
+        for (const auto& key : keysToDelete)
         {
-            for (const auto& key : keysToDelete)
-            {
-                const AstArray<char>& s = key->value;
-                std::string keyStr{s.data, s.data + s.size};
-                tableTy->props.erase(keyStr);
-            }
+            const AstArray<char>& s = key->value;
+            std::string keyStr{s.data, s.data + s.size};
+            tableTy->props.erase(keyStr);
         }
 
         // Keys that the expectedType says we should have, but that aren't
@@ -465,9 +530,39 @@ TypeId matchLiteralType(
         // have one too.
         // TODO: If the expected table also has an indexer, we might want to
         // push the expected indexer's types into it.
-        if (expectedTableTy->indexer && !tableTy->indexer)
+        if (FFlag::LuauBidirectionalInferenceCollectIndexerTypes && expectedTableTy->indexer)
         {
-            tableTy->indexer = expectedTableTy->indexer;
+            if (indexerValueTypes.size() > 0 && indexerKeyTypes.size() > 0)
+            {
+                TypeId inferredKeyType = builtinTypes->neverType;
+                TypeId inferredValueType = builtinTypes->neverType;
+                for (auto kt : indexerKeyTypes)
+                {
+                    auto simplified = simplifyUnion(builtinTypes, arena, inferredKeyType, kt);
+                    inferredKeyType = simplified.result;
+                }
+                for (auto vt : indexerValueTypes)
+                {
+                    auto simplified = simplifyUnion(builtinTypes, arena, inferredValueType, vt);
+                    inferredValueType = simplified.result;
+                }
+                tableTy->indexer = TableIndexer{inferredKeyType, inferredValueType};
+                auto keyCheck = subtyping->isSubtype(inferredKeyType, expectedTableTy->indexer->indexType, unifier->scope);
+                if (keyCheck.isSubtype)
+                    tableTy->indexer->indexType = expectedTableTy->indexer->indexType;
+                auto valueCheck = subtyping->isSubtype(inferredValueType, expectedTableTy->indexer->indexResultType, unifier->scope);
+                if (valueCheck.isSubtype)
+                    tableTy->indexer->indexResultType = expectedTableTy->indexer->indexResultType;
+            }
+            else
+                LUAU_ASSERT(indexerKeyTypes.empty() && indexerValueTypes.empty());
+        }
+        else
+        {
+            if (expectedTableTy->indexer && !tableTy->indexer)
+            {
+                tableTy->indexer = expectedTableTy->indexer;
+            }
         }
     }
 

Analysis/src/ToDot.cpp

@@ -299,9 +299,9 @@ void StateDot::visitChildren(TypeId ty, int index)
             finishNodeLabel(ty);
             finishNode();
         }
-        else if constexpr (std::is_same_v<T, ClassType>)
+        else if constexpr (std::is_same_v<T, ExternType>)
         {
-            formatAppend(result, "ClassType %s", t.name.c_str());
+            formatAppend(result, "ExternType %s", t.name.c_str());
             finishNodeLabel(ty);
             finishNode();
 

Analysis/src/ToString.cpp

@@ -19,8 +19,11 @@
 #include <stdexcept>
 #include <string>
 
+LUAU_FASTFLAGVARIABLE(LuauEnableDenseTableAlias)
+
 LUAU_FASTFLAG(LuauSolverV2)
 LUAU_FASTFLAGVARIABLE(LuauSyntheticErrors)
+LUAU_FASTFLAGVARIABLE(LuauStringPartLengthLimit)
 
 /*
  * Enables increasing levels of verbosity for Luau type names when stringifying.
@@ -120,7 +123,7 @@ struct FindCyclicTypes final : TypeVisitor
         return true;
     }
 
-    bool visit(TypeId ty, const ClassType&) override
+    bool visit(TypeId ty, const ExternType&) override
     {
         return false;
     }
@@ -301,6 +304,28 @@ struct StringifierState
         emit(std::to_string(i).c_str());
     }
 
+    void emit(Polarity p)
+    {
+        switch (p)
+        {
+        case Polarity::None:
+            emit("  ");
+            break;
+        case Polarity::Negative:
+            emit(" -");
+            break;
+        case Polarity::Positive:
+            emit("+ ");
+            break;
+        case Polarity::Mixed:
+            emit("+-");
+            break;
+        default:
+            emit("!!");
+            break;
+        }
+    }
+
     void indent()
     {
         indentation += 4;
@@ -482,6 +507,8 @@ struct TypeStringifier
             {
                 state.emit("'");
                 state.emit(state.getName(ty));
+                if (FInt::DebugLuauVerboseTypeNames >= 1)
+                    state.emit(ftv.polarity);
             }
             else
             {
@@ -494,6 +521,9 @@ struct TypeStringifier
                 state.emit("'");
                 state.emit(state.getName(ty));
 
+                if (FInt::DebugLuauVerboseTypeNames >= 1)
+                    state.emit(ftv.polarity);
+
                 if (!get<UnknownType>(upperBound))
                 {
                     state.emit(" <: ");
@@ -509,6 +539,9 @@ struct TypeStringifier
 
         state.emit(state.getName(ty));
 
+        if (FFlag::LuauSolverV2 && FInt::DebugLuauVerboseTypeNames >= 1)
+            state.emit(ftv.polarity);
+
         if (FInt::DebugLuauVerboseTypeNames >= 2)
         {
             state.emit("-");
@@ -538,6 +571,9 @@ struct TypeStringifier
         else
             state.emit(state.getName(ty));
 
+        if (FInt::DebugLuauVerboseTypeNames >= 1)
+            state.emit(gtv.polarity);
+
         if (FInt::DebugLuauVerboseTypeNames >= 2)
         {
             state.emit("-");
@@ -686,7 +722,13 @@ struct TypeStringifier
         if (ttv.boundTo)
             return stringify(*ttv.boundTo);
 
-        if (!state.exhaustive)
+        bool showName = !state.exhaustive;
+        if (FFlag::LuauEnableDenseTableAlias)
+        {
+            // if hide table alias expansions are enabled and there is a name found for the table, use it
+            showName = !state.exhaustive || state.opts.hideTableAliasExpansions;
+        }
+        if (showName)
         {
             if (ttv.name)
             {
@@ -709,6 +751,10 @@ struct TypeStringifier
                 stringify(ttv.instantiatedTypeParams, ttv.instantiatedTypePackParams);
                 return;
             }
+        }
+
+        if (!state.exhaustive)
+        {
             if (ttv.syntheticName)
             {
                 state.result.invalid = true;
@@ -847,9 +893,9 @@ struct TypeStringifier
         state.emit(" }");
     }
 
-    void operator()(TypeId, const ClassType& ctv)
+    void operator()(TypeId, const ExternType& etv)
     {
-        state.emit(ctv.name);
+        state.emit(etv.name);
     }
 
     void operator()(TypeId, const AnyType&)
@@ -877,6 +923,9 @@ struct TypeStringifier
         bool hasNonNilDisjunct = false;
 
         std::vector<std::string> results = {};
+        size_t resultsLength = 0;
+        bool lengthLimitHit = false;
+
         for (auto el : &uv)
         {
             el = follow(el);
@@ -903,14 +952,34 @@ struct TypeStringifier
             if (needParens)
                 state.emit(")");
 
+            if (FFlag::LuauStringPartLengthLimit)
+                resultsLength += state.result.name.length();
+
             results.push_back(std::move(state.result.name));
+
             state.result.name = std::move(saved);
+
+            if (FFlag::LuauStringPartLengthLimit)
+            {
+                lengthLimitHit = state.opts.maxTypeLength > 0 && resultsLength > state.opts.maxTypeLength;
+
+                if (lengthLimitHit)
+                    break;
+            }
         }
 
         state.unsee(&uv);
 
-        if (!FFlag::DebugLuauToStringNoLexicalSort)
-            std::sort(results.begin(), results.end());
+        if (FFlag::LuauStringPartLengthLimit)
+        {
+            if (!lengthLimitHit && !FFlag::DebugLuauToStringNoLexicalSort)
+                std::sort(results.begin(), results.end());
+        }
+        else
+        {
+            if (!FFlag::DebugLuauToStringNoLexicalSort)
+                std::sort(results.begin(), results.end());
+        }
 
         if (optional && results.size() > 1)
             state.emit("(");
@@ -954,6 +1023,9 @@ struct TypeStringifier
         }
 
         std::vector<std::string> results = {};
+        size_t resultsLength = 0;
+        bool lengthLimitHit = false;
+
         for (auto el : uv.parts)
         {
             el = follow(el);
@@ -970,14 +1042,34 @@ struct TypeStringifier
             if (needParens)
                 state.emit(")");
 
+            if (FFlag::LuauStringPartLengthLimit)
+                resultsLength += state.result.name.length();
+
             results.push_back(std::move(state.result.name));
+
             state.result.name = std::move(saved);
+
+            if (FFlag::LuauStringPartLengthLimit)
+            {
+                lengthLimitHit = state.opts.maxTypeLength > 0 && resultsLength > state.opts.maxTypeLength;
+
+                if (lengthLimitHit)
+                    break;
+            }
         }
 
         state.unsee(&uv);
 
-        if (!FFlag::DebugLuauToStringNoLexicalSort)
-            std::sort(results.begin(), results.end());
+        if (FFlag::LuauStringPartLengthLimit)
+        {
+            if (!lengthLimitHit && !FFlag::DebugLuauToStringNoLexicalSort)
+                std::sort(results.begin(), results.end());
+        }
+        else
+        {
+            if (!FFlag::DebugLuauToStringNoLexicalSort)
+                std::sort(results.begin(), results.end());
+        }
 
         bool first = true;
         bool shouldPlaceOnNewlines = results.size() > state.opts.compositeTypesSingleLineLimit || isOverloadedFunction(ty);
@@ -1222,6 +1314,9 @@ struct TypePackStringifier
             state.emit(state.getName(tp));
         }
 
+        if (FInt::DebugLuauVerboseTypeNames >= 1)
+            state.emit(pack.polarity);
+
         if (FInt::DebugLuauVerboseTypeNames >= 2)
         {
             state.emit("-");
@@ -1241,6 +1336,9 @@ struct TypePackStringifier
             state.emit("free-");
         state.emit(state.getName(tp));
 
+        if (FInt::DebugLuauVerboseTypeNames >= 1)
+            state.emit(pack.polarity);
+
         if (FInt::DebugLuauVerboseTypeNames >= 2)
         {
             state.emit("-");

Analysis/src/TopoSortStatements.cpp

@@ -41,6 +41,8 @@
 #include <stdexcept>
 #include <optional>
 
+LUAU_FASTFLAG(LuauStoreReturnTypesAsPackOnAst)
+
 namespace Luau
 {
 
@@ -297,6 +299,11 @@ struct ArcCollector : public AstVisitor
             add(*name);
         return true;
     }
+
+    bool visit(AstTypePack* node) override
+    {
+        return FFlag::LuauStoreReturnTypesAsPackOnAst;
+    }
 };
 
 struct ContainsFunctionCall : public AstVisitor

Analysis/src/Transpiler.cpp

@@ -10,10 +10,11 @@
 #include <limits>
 #include <math.h>
 
-LUAU_FASTFLAG(LuauStoreCSTData)
-LUAU_FASTFLAG(LuauExtendStatEndPosWithSemicolon)
-LUAU_FASTFLAG(LuauAstTypeGroup2)
-LUAU_FASTFLAG(LuauFixDoBlockEndLocation)
+LUAU_FASTFLAG(LuauStoreCSTData2)
+LUAU_FASTFLAG(LuauAstTypeGroup3)
+LUAU_FASTFLAG(LuauParseOptionalAsNode2)
+LUAU_FASTFLAG(LuauFixFunctionWithAttributesStartLocation)
+LUAU_FASTFLAG(LuauStoreReturnTypesAsPackOnAst)
 
 namespace
 {
@@ -166,7 +167,7 @@ struct StringWriter : Writer
 
     void symbol(std::string_view s) override
     {
-        if (FFlag::LuauStoreCSTData)
+        if (FFlag::LuauStoreCSTData2)
         {
             write(s);
         }
@@ -256,7 +257,7 @@ public:
             first = !first;
         else
         {
-            if (FFlag::LuauStoreCSTData && commaPosition)
+            if (FFlag::LuauStoreCSTData2 && commaPosition)
             {
                 writer.advance(*commaPosition);
                 commaPosition++;
@@ -271,6 +272,43 @@ private:
     const Position* commaPosition;
 };
 
+class ArgNameInserter
+{
+public:
+    ArgNameInserter(Writer& w, AstArray<std::optional<AstArgumentName>> names, AstArray<std::optional<Position>> colonPositions)
+        : writer(w)
+        , names(names)
+        , colonPositions(colonPositions)
+    {
+    }
+
+    void operator()()
+    {
+        if (idx < names.size)
+        {
+            const auto name = names.data[idx];
+            if (name.has_value())
+            {
+                writer.advance(name->second.begin);
+                writer.identifier(name->first.value);
+                if (idx < colonPositions.size)
+                {
+                    LUAU_ASSERT(colonPositions.data[idx].has_value());
+                    writer.advance(*colonPositions.data[idx]);
+                }
+                writer.symbol(":");
+            }
+        }
+        idx++;
+    }
+
+private:
+    Writer& writer;
+    AstArray<std::optional<AstArgumentName>> names;
+    AstArray<std::optional<Position>> colonPositions;
+    size_t idx = 0;
+};
+
 struct Printer_DEPRECATED
 {
     explicit Printer_DEPRECATED(Writer& writer)
@@ -293,7 +331,7 @@ struct Printer_DEPRECATED
         }
     }
 
-    void visualizeTypePackAnnotation(const AstTypePack& annotation, bool forVarArg)
+    void visualizeTypePackAnnotation(const AstTypePack& annotation, bool forVarArg, bool unconditionallyParenthesize = true)
     {
         advance(annotation.location.begin);
         if (const AstTypePackVariadic* variadicTp = annotation.as<AstTypePackVariadic>())
@@ -311,7 +349,7 @@ struct Printer_DEPRECATED
         else if (const AstTypePackExplicit* explicitTp = annotation.as<AstTypePackExplicit>())
         {
             LUAU_ASSERT(!forVarArg);
-            visualizeTypeList(explicitTp->typeList, true);
+            visualizeTypeList(explicitTp->typeList, unconditionallyParenthesize);
         }
         else
         {
@@ -330,7 +368,7 @@ struct Printer_DEPRECATED
         else if (typeCount == 1)
         {
             bool shouldParenthesize = unconditionallyParenthesize && (list.types.size == 0 || !list.types.data[0]->is<AstTypeGroup>());
-            if (FFlag::LuauAstTypeGroup2 ? shouldParenthesize : unconditionallyParenthesize)
+            if (FFlag::LuauAstTypeGroup3 ? shouldParenthesize : unconditionallyParenthesize)
                 writer.symbol("(");
 
             // Only variadic tail
@@ -343,7 +381,7 @@ struct Printer_DEPRECATED
                 visualizeTypeAnnotation(*list.types.data[0]);
             }
 
-            if (FFlag::LuauAstTypeGroup2 ? shouldParenthesize : unconditionallyParenthesize)
+            if (FFlag::LuauAstTypeGroup3 ? shouldParenthesize : unconditionallyParenthesize)
                 writer.symbol(")");
         }
         else
@@ -667,8 +705,6 @@ struct Printer_DEPRECATED
             writer.keyword("do");
             for (const auto& s : block->body)
                 visualize(*s);
-            if (!FFlag::LuauFixDoBlockEndLocation)
-                writer.advance(block->location.end);
             writeEnd(program.location);
         }
         else if (const auto& a = program.as<AstStatIf>())
@@ -1027,12 +1063,15 @@ struct Printer_DEPRECATED
 
         writer.symbol(")");
 
-        if (writeTypes && func.returnAnnotation)
+        if (writeTypes && (FFlag::LuauStoreReturnTypesAsPackOnAst ? func.returnAnnotation != nullptr : func.returnAnnotation_DEPRECATED.has_value()))
         {
             writer.symbol(":");
             writer.space();
 
-            visualizeTypeList(*func.returnAnnotation, false);
+            if (FFlag::LuauStoreReturnTypesAsPackOnAst)
+                visualizeTypePackAnnotation(*func.returnAnnotation, false, false);
+            else
+                visualizeTypeList(*func.returnAnnotation_DEPRECATED, false);
         }
 
         visualizeBlock(*func.body);
@@ -1136,7 +1175,10 @@ struct Printer_DEPRECATED
             }
 
             writer.symbol("->");
-            visualizeTypeList(a->returnTypes, true);
+            if (FFlag::LuauStoreReturnTypesAsPackOnAst)
+                visualizeTypePackAnnotation(*a->returnTypes, false);
+            else
+                visualizeTypeList(a->returnTypes_DEPRECATED, true);
         }
         else if (const auto& a = typeAnnotation.as<AstTypeTable>())
         {
@@ -1191,9 +1233,18 @@ struct Printer_DEPRECATED
                 AstType* l = a->types.data[0];
                 AstType* r = a->types.data[1];
 
-                auto lta = l->as<AstTypeReference>();
-                if (lta && lta->name == "nil")
-                    std::swap(l, r);
+                if (FFlag::LuauParseOptionalAsNode2)
+                {
+                    auto lta = l->as<AstTypeReference>();
+                    if (lta && lta->name == "nil" && !r->is<AstTypeOptional>())
+                        std::swap(l, r);
+                }
+                else
+                {
+                    auto lta = l->as<AstTypeReference>();
+                    if (lta && lta->name == "nil")
+                        std::swap(l, r);
+                }
 
                 // it's still possible that we had a (T | U) or (T | nil) and not (nil | T)
                 auto rta = r->as<AstTypeReference>();
@@ -1216,6 +1267,15 @@ struct Printer_DEPRECATED
 
             for (size_t i = 0; i < a->types.size; ++i)
             {
+                if (FFlag::LuauParseOptionalAsNode2)
+                {
+                    if (a->types.data[i]->is<AstTypeOptional>())
+                    {
+                        writer.symbol("?");
+                        continue;
+                    }
+                }
+
                 if (i > 0)
                 {
                     writer.maybeSpace(a->types.data[i]->location.begin, 2);
@@ -1312,7 +1372,7 @@ struct Printer
         }
     }
 
-    void visualizeTypePackAnnotation(const AstTypePack& annotation, bool forVarArg)
+    void visualizeTypePackAnnotation(AstTypePack& annotation, bool forVarArg, bool unconditionallyParenthesize = true)
     {
         advance(annotation.location.begin);
         if (const AstTypePackVariadic* variadicTp = annotation.as<AstTypePackVariadic>())
@@ -1322,15 +1382,22 @@ struct Printer
 
             visualizeTypeAnnotation(*variadicTp->variadicType);
         }
-        else if (const AstTypePackGeneric* genericTp = annotation.as<AstTypePackGeneric>())
+        else if (AstTypePackGeneric* genericTp = annotation.as<AstTypePackGeneric>())
         {
             writer.symbol(genericTp->genericName.value);
+            if (const auto cstNode = lookupCstNode<CstTypePackGeneric>(genericTp))
+                advance(cstNode->ellipsisPosition);
             writer.symbol("...");
         }
-        else if (const AstTypePackExplicit* explicitTp = annotation.as<AstTypePackExplicit>())
+        else if (AstTypePackExplicit* explicitTp = annotation.as<AstTypePackExplicit>())
         {
             LUAU_ASSERT(!forVarArg);
-            visualizeTypeList(explicitTp->typeList, true);
+            if (const auto cstNode = lookupCstNode<CstTypePackExplicit>(explicitTp))
+                visualizeTypeList(
+                    explicitTp->typeList, FFlag::LuauStoreReturnTypesAsPackOnAst ? cstNode->hasParentheses : true, cstNode->openParenthesesPosition, cstNode->closeParenthesesPosition, cstNode->commaPositions
+                );
+            else
+                visualizeTypeList(explicitTp->typeList, unconditionallyParenthesize);
         }
         else
         {
@@ -1338,19 +1405,37 @@ struct Printer
         }
     }
 
-    void visualizeTypeList(const AstTypeList& list, bool unconditionallyParenthesize)
+    void visualizeNamedTypeList(
+        const AstTypeList& list,
+        bool unconditionallyParenthesize,
+        std::optional<Position> openParenthesesPosition,
+        std::optional<Position> closeParenthesesPosition,
+        AstArray<Position> commaPositions,
+        AstArray<std::optional<AstArgumentName>> argNames,
+        AstArray<std::optional<Position>> argNamesColonPositions
+    )
     {
         size_t typeCount = list.types.size + (list.tailType != nullptr ? 1 : 0);
         if (typeCount == 0)
         {
+            if (openParenthesesPosition)
+                advance(*openParenthesesPosition);
             writer.symbol("(");
+            if (closeParenthesesPosition)
+                advance(*closeParenthesesPosition);
             writer.symbol(")");
         }
         else if (typeCount == 1)
         {
             bool shouldParenthesize = unconditionallyParenthesize && (list.types.size == 0 || !list.types.data[0]->is<AstTypeGroup>());
-            if (FFlag::LuauAstTypeGroup2 ? shouldParenthesize : unconditionallyParenthesize)
+            if (FFlag::LuauAstTypeGroup3 ? shouldParenthesize : unconditionallyParenthesize)
+            {
+                if (openParenthesesPosition)
+                    advance(*openParenthesesPosition);
                 writer.symbol("(");
+            }
+
+            ArgNameInserter(writer, argNames, argNamesColonPositions)();
 
             // Only variadic tail
             if (list.types.size == 0)
@@ -1362,34 +1447,51 @@ struct Printer
                 visualizeTypeAnnotation(*list.types.data[0]);
             }
 
-            if (FFlag::LuauAstTypeGroup2 ? shouldParenthesize : unconditionallyParenthesize)
+            if (FFlag::LuauAstTypeGroup3 ? shouldParenthesize : unconditionallyParenthesize)
+            {
+                if (closeParenthesesPosition)
+                    advance(*closeParenthesesPosition);
                 writer.symbol(")");
+            }
         }
         else
         {
+            if (openParenthesesPosition)
+                advance(*openParenthesesPosition);
             writer.symbol("(");
 
-            bool first = true;
+            CommaSeparatorInserter comma(writer, commaPositions.size > 0 ? commaPositions.begin() : nullptr);
+            ArgNameInserter argName(writer, argNames, argNamesColonPositions);
             for (const auto& el : list.types)
             {
-                if (first)
-                    first = false;
-                else
-                    writer.symbol(",");
-
+                comma();
+                argName();
                 visualizeTypeAnnotation(*el);
             }
 
             if (list.tailType)
             {
-                writer.symbol(",");
+                comma();
                 visualizeTypePackAnnotation(*list.tailType, false);
             }
 
+            if (closeParenthesesPosition)
+                advance(*closeParenthesesPosition);
             writer.symbol(")");
         }
     }
 
+    void visualizeTypeList(
+        const AstTypeList& list,
+        bool unconditionallyParenthesize,
+        std::optional<Position> openParenthesesPosition = std::nullopt,
+        std::optional<Position> closeParenthesesPosition = std::nullopt,
+        AstArray<Position> commaPositions = {}
+    )
+    {
+        visualizeNamedTypeList(list, unconditionallyParenthesize, openParenthesesPosition, closeParenthesesPosition, commaPositions, {}, {});
+    }
+
     bool isIntegerish(double d)
     {
         if (d <= std::numeric_limits<int>::max() && d >= std::numeric_limits<int>::min())
@@ -1400,13 +1502,14 @@ struct Printer
 
     void visualize(AstExpr& expr)
     {
-        advance(expr.location.begin);
+        if (!expr.is<AstExprFunction>() || FFlag::LuauFixFunctionWithAttributesStartLocation)
+            advance(expr.location.begin);
 
         if (const auto& a = expr.as<AstExprGroup>())
         {
             writer.symbol("(");
             visualize(*a->expr);
-            advance(Position{a->location.end.line, a->location.end.column - 1});
+            advanceBefore(a->location.end, 1);
             writer.symbol(")");
         }
         else if (expr.is<AstExprConstantNil>())
@@ -1534,6 +1637,17 @@ struct Printer
         }
         else if (const auto& a = expr.as<AstExprFunction>())
         {
+            for (const auto& attribute : a->attributes)
+                visualizeAttribute(*attribute);
+            if (FFlag::LuauFixFunctionWithAttributesStartLocation)
+            {
+                if (const auto cstNode = lookupCstNode<CstExprFunction>(a))
+                    advance(cstNode->functionKeywordPosition);
+            }
+            else
+            {
+                advance(a->location.begin);
+            }
             writer.keyword("function");
             visualizeFunctionBody(*a);
         }
@@ -1775,9 +1889,18 @@ struct Printer
         writer.advance(newPos);
     }
 
+    void advanceBefore(const Position& newPos, unsigned int tokenLength)
+    {
+        if (newPos.column >= tokenLength)
+            advance(Position{newPos.line, newPos.column - tokenLength});
+        else
+            advance(newPos);
+    }
+
     void visualize(AstStat& program)
     {
-        advance(program.location.begin);
+        if ((!program.is<AstStatLocalFunction>() && !program.is<AstStatFunction>()) || FFlag::LuauFixFunctionWithAttributesStartLocation)
+            advance(program.location.begin);
 
         if (const auto& block = program.as<AstStatBlock>())
         {
@@ -1817,8 +1940,8 @@ struct Printer
             visualizeBlock(*a->body);
             if (const auto cstNode = lookupCstNode<CstStatRepeat>(a))
                 writer.advance(cstNode->untilPosition);
-            else if (a->condition->location.begin.column > 5)
-                writer.advance(Position{a->condition->location.begin.line, a->condition->location.begin.column - 6});
+            else
+                advanceBefore(a->condition->location.begin, 6);
             writer.keyword("until");
             visualize(*a->condition);
         }
@@ -2014,13 +2137,36 @@ struct Printer
         }
         else if (const auto& a = program.as<AstStatFunction>())
         {
+            for (const auto& attribute : a->func->attributes)
+                visualizeAttribute(*attribute);
+            if (FFlag::LuauFixFunctionWithAttributesStartLocation)
+            {
+                if (const auto cstNode = lookupCstNode<CstStatFunction>(a))
+                    advance(cstNode->functionKeywordPosition);
+            }
+            else
+            {
+                advance(a->location.begin);
+            }
             writer.keyword("function");
             visualize(*a->name);
             visualizeFunctionBody(*a->func);
         }
         else if (const auto& a = program.as<AstStatLocalFunction>())
         {
+            for (const auto& attribute : a->func->attributes)
+                visualizeAttribute(*attribute);
+
             const auto cstNode = lookupCstNode<CstStatLocalFunction>(a);
+            if (FFlag::LuauFixFunctionWithAttributesStartLocation)
+            {
+                if (cstNode)
+                    advance(cstNode->localKeywordPosition);
+            }
+            else
+            {
+                advance(a->location.begin);
+            }
 
             writer.keyword("local");
 
@@ -2121,7 +2267,20 @@ struct Printer
         {
             if (writeTypes)
             {
-                writer.keyword("type function");
+                const auto cstNode = lookupCstNode<CstStatTypeFunction>(t);
+                if (t->exported)
+                    writer.keyword("export");
+                if (cstNode)
+                    advance(cstNode->typeKeywordPosition);
+                else
+                    writer.space();
+                writer.keyword("type");
+                if (cstNode)
+                    advance(cstNode->functionKeywordPosition);
+                else
+                    writer.space();
+                writer.keyword("function");
+                advance(t->nameLocation.begin);
                 writer.identifier(t->name.value);
                 visualizeFunctionBody(*t->body);
             }
@@ -2151,17 +2310,21 @@ struct Printer
 
         if (program.hasSemicolon)
         {
-            if (FFlag::LuauStoreCSTData)
-                advance(Position{program.location.end.line, program.location.end.column - 1});
+            if (FFlag::LuauStoreCSTData2)
+                advanceBefore(program.location.end, 1);
             writer.symbol(";");
         }
     }
 
     void visualizeFunctionBody(AstExprFunction& func)
     {
+        const auto cstNode = lookupCstNode<CstExprFunction>(&func);
+
         if (func.generics.size > 0 || func.genericPacks.size > 0)
         {
-            CommaSeparatorInserter comma(writer);
+            CommaSeparatorInserter comma(writer, cstNode ? cstNode->genericsCommaPositions.begin() : nullptr);
+            if (cstNode)
+                advance(cstNode->openGenericsPosition);
             writer.symbol("<");
             for (const auto& o : func.generics)
             {
@@ -2176,13 +2339,19 @@ struct Printer
 
                 writer.advance(o->location.begin);
                 writer.identifier(o->name.value);
+                if (const auto* genericTypePackCstNode = lookupCstNode<CstGenericTypePack>(o))
+                    advance(genericTypePackCstNode->ellipsisPosition);
                 writer.symbol("...");
             }
+            if (cstNode)
+                advance(cstNode->closeGenericsPosition);
             writer.symbol(">");
         }
 
+        if (func.argLocation)
+            advance(func.argLocation->begin);
         writer.symbol("(");
-        CommaSeparatorInserter comma(writer);
+        CommaSeparatorInserter comma(writer, cstNode ? cstNode->argsCommaPositions.begin() : nullptr);
 
         for (size_t i = 0; i < func.args.size; ++i)
         {
@@ -2212,14 +2381,27 @@ struct Printer
             }
         }
 
+        if (func.argLocation)
+            advanceBefore(func.argLocation->end, 1);
         writer.symbol(")");
 
-        if (writeTypes && func.returnAnnotation)
+        if (writeTypes && FFlag::LuauStoreReturnTypesAsPackOnAst ? func.returnAnnotation != nullptr : func.returnAnnotation_DEPRECATED.has_value())
         {
+            if (cstNode)
+                advance(cstNode->returnSpecifierPosition);
             writer.symbol(":");
-            writer.space();
 
-            visualizeTypeList(*func.returnAnnotation, false);
+            if (FFlag::LuauStoreReturnTypesAsPackOnAst)
+            {
+                if (!cstNode)
+                    writer.space();
+                visualizeTypePackAnnotation(*func.returnAnnotation, false, false);
+            }
+            else
+            {
+                writer.space();
+                visualizeTypeList(*func.returnAnnotation_DEPRECATED, false);
+            }
         }
 
         visualizeBlock(*func.body);
@@ -2301,6 +2483,23 @@ struct Printer
         }
     }
 
+    void visualizeAttribute(AstAttr& attribute)
+    {
+        advance(attribute.location.begin);
+        switch (attribute.type)
+        {
+        case AstAttr::Checked:
+            writer.keyword("@checked");
+            break;
+        case AstAttr::Native:
+            writer.keyword("@native");
+            break;
+        case AstAttr::Deprecated:
+            writer.keyword("@deprecated");
+            break;
+        }
+    }
+
     void visualizeTypeAnnotation(AstType& typeAnnotation)
     {
         advance(typeAnnotation.location.begin);
@@ -2340,9 +2539,13 @@ struct Printer
         }
         else if (const auto& a = typeAnnotation.as<AstTypeFunction>())
         {
+            const auto cstNode = lookupCstNode<CstTypeFunction>(a);
+
             if (a->generics.size > 0 || a->genericPacks.size > 0)
             {
-                CommaSeparatorInserter comma(writer);
+                CommaSeparatorInserter comma(writer, cstNode ? cstNode->genericsCommaPositions.begin() : nullptr);
+                if (cstNode)
+                    advance(cstNode->openGenericsPosition);
                 writer.symbol("<");
                 for (const auto& o : a->generics)
                 {
@@ -2357,17 +2560,34 @@ struct Printer
 
                     writer.advance(o->location.begin);
                     writer.identifier(o->name.value);
+                    if (const auto* genericTypePackCstNode = lookupCstNode<CstGenericTypePack>(o))
+                        advance(genericTypePackCstNode->ellipsisPosition);
                     writer.symbol("...");
                 }
+                if (cstNode)
+                    advance(cstNode->closeGenericsPosition);
                 writer.symbol(">");
             }
 
             {
-                visualizeTypeList(a->argTypes, true);
+                visualizeNamedTypeList(
+                    a->argTypes,
+                    true,
+                    cstNode ? std::make_optional(cstNode->openArgsPosition) : std::nullopt,
+                    cstNode ? std::make_optional(cstNode->closeArgsPosition) : std::nullopt,
+                    cstNode ? cstNode->argumentsCommaPositions : Luau::AstArray<Position>{},
+                    a->argNames,
+                    cstNode ? cstNode->argumentNameColonPositions : Luau::AstArray<std::optional<Position>>{}
+                );
             }
 
+            if (cstNode)
+                advance(cstNode->returnArrowPosition);
             writer.symbol("->");
-            visualizeTypeList(a->returnTypes, true);
+            if (FFlag::LuauStoreReturnTypesAsPackOnAst)
+                visualizeTypePackAnnotation(*a->returnTypes, false);
+            else
+                visualizeTypeList(a->returnTypes_DEPRECATED, true);
         }
         else if (const auto& a = typeAnnotation.as<AstTypeTable>())
         {
@@ -2440,6 +2660,7 @@ struct Printer
                             {
                                 advance(item.indexerOpenPosition);
                                 writer.symbol("[");
+                                advance(item.stringPosition);
                                 writer.sourceString(
                                     std::string_view(item.stringInfo->sourceString.data, item.stringInfo->sourceString.size),
                                     item.stringInfo->quoteStyle,
@@ -2527,14 +2748,25 @@ struct Printer
         }
         else if (const auto& a = typeAnnotation.as<AstTypeUnion>())
         {
-            if (a->types.size == 2)
+            const auto cstNode = lookupCstNode<CstTypeUnion>(a);
+
+            if (!cstNode && a->types.size == 2)
             {
                 AstType* l = a->types.data[0];
                 AstType* r = a->types.data[1];
 
-                auto lta = l->as<AstTypeReference>();
-                if (lta && lta->name == "nil")
-                    std::swap(l, r);
+                if (FFlag::LuauParseOptionalAsNode2)
+                {
+                    auto lta = l->as<AstTypeReference>();
+                    if (lta && lta->name == "nil" && !r->is<AstTypeOptional>())
+                        std::swap(l, r);
+                }
+                else
+                {
+                    auto lta = l->as<AstTypeReference>();
+                    if (lta && lta->name == "nil")
+                        std::swap(l, r);
+                }
 
                 // it's still possible that we had a (T | U) or (T | nil) and not (nil | T)
                 auto rta = r->as<AstTypeReference>();
@@ -2555,15 +2787,39 @@ struct Printer
                 }
             }
 
+            if (cstNode && cstNode->leadingPosition)
+            {
+                advance(*cstNode->leadingPosition);
+                writer.symbol("|");
+            }
+
+            size_t separatorIndex = 0;
             for (size_t i = 0; i < a->types.size; ++i)
             {
+                if (FFlag::LuauParseOptionalAsNode2)
+                {
+                    if (const auto optional = a->types.data[i]->as<AstTypeOptional>())
+                    {
+                        advance(optional->location.begin);
+                        writer.symbol("?");
+                        continue;
+                    }
+                }
+
                 if (i > 0)
                 {
-                    writer.maybeSpace(a->types.data[i]->location.begin, 2);
+                    if (cstNode && FFlag::LuauParseOptionalAsNode2)
+                    {
+                        // separatorIndex is only valid if `?` is handled as an AstTypeOptional
+                        advance(cstNode->separatorPositions.data[separatorIndex]);
+                        separatorIndex++;
+                    }
+                    else
+                        writer.maybeSpace(a->types.data[i]->location.begin, 2);
                     writer.symbol("|");
                 }
 
-                bool wrap = a->types.data[i]->as<AstTypeIntersection>() || a->types.data[i]->as<AstTypeFunction>();
+                bool wrap = !cstNode && (a->types.data[i]->as<AstTypeIntersection>() || a->types.data[i]->as<AstTypeFunction>());
 
                 if (wrap)
                     writer.symbol("(");
@@ -2576,15 +2832,27 @@ struct Printer
         }
         else if (const auto& a = typeAnnotation.as<AstTypeIntersection>())
         {
+            const auto cstNode = lookupCstNode<CstTypeIntersection>(a);
+
+            // If the sizes are equal, we know there is a leading & token
+            if (cstNode && cstNode->leadingPosition)
+            {
+                advance(*cstNode->leadingPosition);
+                writer.symbol("&");
+            }
+
             for (size_t i = 0; i < a->types.size; ++i)
             {
                 if (i > 0)
                 {
-                    writer.maybeSpace(a->types.data[i]->location.begin, 2);
+                    if (cstNode)
+                        advance(cstNode->separatorPositions.data[i - 1]);
+                    else
+                        writer.maybeSpace(a->types.data[i]->location.begin, 2);
                     writer.symbol("&");
                 }
 
-                bool wrap = a->types.data[i]->as<AstTypeUnion>() || a->types.data[i]->as<AstTypeFunction>();
+                bool wrap = !cstNode && (a->types.data[i]->as<AstTypeUnion>() || a->types.data[i]->as<AstTypeFunction>());
 
                 if (wrap)
                     writer.symbol("(");
@@ -2599,7 +2867,7 @@ struct Printer
         {
             writer.symbol("(");
             visualizeTypeAnnotation(*a->type);
-            advance(Position{a->location.end.line, a->location.end.column - 1});
+            advanceBefore(a->location.end, 1);
             writer.symbol(")");
         }
         else if (const auto& a = typeAnnotation.as<AstTypeSingletonBool>())
@@ -2633,7 +2901,7 @@ std::string toString(AstNode* node)
     StringWriter writer;
     writer.pos = node->location.begin;
 
-    if (FFlag::LuauStoreCSTData)
+    if (FFlag::LuauStoreCSTData2)
     {
         Printer printer(writer, CstNodeMap{nullptr});
         printer.writeTypes = true;
@@ -2669,7 +2937,7 @@ void dump(AstNode* node)
 std::string transpile(AstStatBlock& block, const CstNodeMap& cstNodeMap)
 {
     StringWriter writer;
-    if (FFlag::LuauStoreCSTData)
+    if (FFlag::LuauStoreCSTData2)
     {
         Printer(writer, cstNodeMap).visualizeBlock(block);
     }
@@ -2683,7 +2951,7 @@ std::string transpile(AstStatBlock& block, const CstNodeMap& cstNodeMap)
 std::string transpileWithTypes(AstStatBlock& block, const CstNodeMap& cstNodeMap)
 {
     StringWriter writer;
-    if (FFlag::LuauStoreCSTData)
+    if (FFlag::LuauStoreCSTData2)
     {
         Printer printer(writer, cstNodeMap);
         printer.writeTypes = true;

Analysis/src/TxnLog.cpp

@@ -407,41 +407,6 @@ PendingTypePack* TxnLog::changeLevel(TypePackId tp, TypeLevel newLevel)
     return newTp;
 }
 
-PendingType* TxnLog::changeScope(TypeId ty, NotNull<Scope> newScope)
-{
-    LUAU_ASSERT(get<FreeType>(ty) || get<TableType>(ty) || get<FunctionType>(ty));
-
-    PendingType* newTy = queue(ty);
-    if (FreeType* ftv = Luau::getMutable<FreeType>(newTy))
-    {
-        ftv->scope = newScope;
-    }
-    else if (TableType* ttv = Luau::getMutable<TableType>(newTy))
-    {
-        LUAU_ASSERT(ttv->state == TableState::Free || ttv->state == TableState::Generic);
-        ttv->scope = newScope;
-    }
-    else if (FunctionType* ftv = Luau::getMutable<FunctionType>(newTy))
-    {
-        ftv->scope = newScope;
-    }
-
-    return newTy;
-}
-
-PendingTypePack* TxnLog::changeScope(TypePackId tp, NotNull<Scope> newScope)
-{
-    LUAU_ASSERT(get<FreeTypePack>(tp));
-
-    PendingTypePack* newTp = queue(tp);
-    if (FreeTypePack* ftp = Luau::getMutable<FreeTypePack>(newTp))
-    {
-        ftp->scope = newScope;
-    }
-
-    return newTp;
-}
-
 PendingType* TxnLog::changeIndexer(TypeId ty, std::optional<TableIndexer> indexer)
 {
     LUAU_ASSERT(get<TableType>(ty));

Analysis/src/Type.cpp

@@ -282,8 +282,8 @@ std::optional<TypeId> getMetatable(TypeId type, NotNull<BuiltinTypes> builtinTyp
 
     if (const MetatableType* mtType = get<MetatableType>(type))
         return mtType->metatable;
-    else if (const ClassType* classType = get<ClassType>(type))
-        return classType->metatable;
+    else if (const ExternType* externType = get<ExternType>(type))
+        return externType->metatable;
     else if (isString(type))
     {
         auto ptv = get<PrimitiveType>(builtinTypes->stringType);
@@ -346,10 +346,10 @@ std::optional<ModuleName> getDefinitionModuleName(TypeId type)
         if (ftv->definition)
             return ftv->definition->definitionModuleName;
     }
-    else if (auto ctv = get<ClassType>(type))
+    else if (auto etv = get<ExternType>(type))
     {
-        if (!ctv->definitionModuleName.empty())
-            return ctv->definitionModuleName;
+        if (!etv->definitionModuleName.empty())
+            return etv->definitionModuleName;
     }
 
     return std::nullopt;
@@ -488,11 +488,12 @@ FreeType::FreeType(TypeLevel level, TypeId lowerBound, TypeId upperBound)
 {
 }
 
-FreeType::FreeType(Scope* scope, TypeId lowerBound, TypeId upperBound)
+FreeType::FreeType(Scope* scope, TypeId lowerBound, TypeId upperBound, Polarity polarity)
     : index(Unifiable::freshIndex())
     , scope(scope)
     , lowerBound(lowerBound)
     , upperBound(upperBound)
+    , polarity(polarity)
 {
 }
 
@@ -505,31 +506,6 @@ FreeType::FreeType(Scope* scope, TypeLevel level, TypeId lowerBound, TypeId uppe
 {
 }
 
-// Old constructors
-FreeType::FreeType(TypeLevel level)
-    : index(Unifiable::freshIndex())
-    , level(level)
-    , scope(nullptr)
-{
-    LUAU_ASSERT(!FFlag::LuauFreeTypesMustHaveBounds);
-}
-
-FreeType::FreeType(Scope* scope)
-    : index(Unifiable::freshIndex())
-    , level{}
-    , scope(scope)
-{
-    LUAU_ASSERT(!FFlag::LuauFreeTypesMustHaveBounds);
-}
-
-FreeType::FreeType(Scope* scope, TypeLevel level)
-    : index(Unifiable::freshIndex())
-    , level(level)
-    , scope(scope)
-{
-    LUAU_ASSERT(!FFlag::LuauFreeTypesMustHaveBounds);
-}
-
 GenericType::GenericType()
     : index(Unifiable::freshIndex())
     , name("g" + std::to_string(index))
@@ -543,16 +519,18 @@ GenericType::GenericType(TypeLevel level)
 {
 }
 
-GenericType::GenericType(const Name& name)
+GenericType::GenericType(const Name& name, Polarity polarity)
     : index(Unifiable::freshIndex())
     , name(name)
     , explicitName(true)
+    , polarity(polarity)
 {
 }
 
-GenericType::GenericType(Scope* scope)
+GenericType::GenericType(Scope* scope, Polarity polarity)
     : index(Unifiable::freshIndex())
     , scope(scope)
+    , polarity(polarity)
 {
 }
 
@@ -630,23 +608,6 @@ FunctionType::FunctionType(TypeLevel level, TypePackId argTypes, TypePackId retT
 {
 }
 
-FunctionType::FunctionType(
-    TypeLevel level,
-    Scope* scope,
-    TypePackId argTypes,
-    TypePackId retTypes,
-    std::optional<FunctionDefinition> defn,
-    bool hasSelf
-)
-    : definition(std::move(defn))
-    , level(level)
-    , scope(scope)
-    , argTypes(argTypes)
-    , retTypes(retTypes)
-    , hasSelf(hasSelf)
-{
-}
-
 FunctionType::FunctionType(
     std::vector<TypeId> generics,
     std::vector<TypePackId> genericPacks,
@@ -683,27 +644,6 @@ FunctionType::FunctionType(
 {
 }
 
-FunctionType::FunctionType(
-    TypeLevel level,
-    Scope* scope,
-    std::vector<TypeId> generics,
-    std::vector<TypePackId> genericPacks,
-    TypePackId argTypes,
-    TypePackId retTypes,
-    std::optional<FunctionDefinition> defn,
-    bool hasSelf
-)
-    : definition(std::move(defn))
-    , generics(generics)
-    , genericPacks(genericPacks)
-    , level(level)
-    , scope(scope)
-    , argTypes(argTypes)
-    , retTypes(retTypes)
-    , hasSelf(hasSelf)
-{
-}
-
 Property::Property() {}
 
 Property::Property(
@@ -1049,7 +989,7 @@ BuiltinTypes::BuiltinTypes()
     , threadType(arena->addType(Type{PrimitiveType{PrimitiveType::Thread}, /*persistent*/ true}))
     , bufferType(arena->addType(Type{PrimitiveType{PrimitiveType::Buffer}, /*persistent*/ true}))
     , functionType(arena->addType(Type{PrimitiveType{PrimitiveType::Function}, /*persistent*/ true}))
-    , classType(arena->addType(Type{ClassType{"class", {}, std::nullopt, std::nullopt, {}, {}, {}, {}}, /*persistent*/ true}))
+    , externType(arena->addType(Type{ExternType{"class", {}, std::nullopt, std::nullopt, {}, {}, {}, {}}, /*persistent*/ true}))
     , tableType(arena->addType(Type{PrimitiveType{PrimitiveType::Table}, /*persistent*/ true}))
     , emptyTableType(arena->addType(Type{TableType{TableState::Sealed, TypeLevel{}, nullptr}, /*persistent*/ true}))
     , trueType(arena->addType(Type{SingletonType{BooleanSingleton{true}}, /*persistent*/ true}))
@@ -1061,6 +1001,7 @@ BuiltinTypes::BuiltinTypes()
     , noRefineType(arena->addType(Type{NoRefineType{}, /*persistent*/ true}))
     , falsyType(arena->addType(Type{UnionType{{falseType, nilType}}, /*persistent*/ true}))
     , truthyType(arena->addType(Type{NegationType{falsyType}, /*persistent*/ true}))
+    , notNilType(arena->addType(Type{NegationType{nilType}, /*persistent*/ true}))
     , optionalNumberType(arena->addType(Type{UnionType{{numberType, nilType}}, /*persistent*/ true}))
     , optionalStringType(arena->addType(Type{UnionType{{stringType, nilType}}, /*persistent*/ true}))
     , emptyTypePack(arena->addTypePack(TypePackVar{TypePack{{}}, /*persistent*/ true}))
@@ -1139,9 +1080,9 @@ void persist(TypeId ty)
                 queue.push_back(ttv->indexer->indexResultType);
             }
         }
-        else if (auto ctv = get<ClassType>(t))
+        else if (auto etv= get<ExternType>(t))
         {
-            for (const auto& [_name, prop] : ctv->props)
+            for (const auto& [_name, prop] : etv->props)
                 queue.push_back(prop.type());
         }
         else if (auto utv = get<UnionType>(t))
@@ -1241,7 +1182,7 @@ std::optional<TypeLevel> getLevel(TypePackId tp)
         return std::nullopt;
 }
 
-const Property* lookupClassProp(const ClassType* cls, const Name& name)
+const Property* lookupExternTypeProp(const ExternType* cls, const Name& name)
 {
     while (cls)
     {
@@ -1250,7 +1191,7 @@ const Property* lookupClassProp(const ClassType* cls, const Name& name)
             return &it->second;
 
         if (cls->parent)
-            cls = get<ClassType>(*cls->parent);
+            cls = get<ExternType>(*cls->parent);
         else
             return nullptr;
 
@@ -1260,7 +1201,7 @@ const Property* lookupClassProp(const ClassType* cls, const Name& name)
     return nullptr;
 }
 
-bool isSubclass(const ClassType* cls, const ClassType* parent)
+bool isSubclass(const ExternType* cls, const ExternType* parent)
 {
     while (cls)
     {
@@ -1269,7 +1210,7 @@ bool isSubclass(const ClassType* cls, const ClassType* parent)
         else if (!cls->parent)
             return false;
 
-        cls = get<ClassType>(*cls->parent);
+        cls = get<ExternType>(*cls->parent);
         LUAU_ASSERT(cls);
     }
 
@@ -1306,9 +1247,9 @@ IntersectionTypeIterator end(const IntersectionType* itv)
     return IntersectionTypeIterator{};
 }
 
-TypeId freshType(NotNull<TypeArena> arena, NotNull<BuiltinTypes> builtinTypes, Scope* scope)
+TypeId freshType(NotNull<TypeArena> arena, NotNull<BuiltinTypes> builtinTypes, Scope* scope, Polarity polarity)
 {
-    return arena->addType(FreeType{scope, builtinTypes->neverType, builtinTypes->unknownType});
+    return arena->addType(FreeType{scope, builtinTypes->neverType, builtinTypes->unknownType, polarity});
 }
 
 std::vector<TypeId> filterMap(TypeId type, TypeIdPredicate predicate)
@@ -1338,8 +1279,8 @@ static Tags* getTags(TypeId ty)
         return &ftv->tags;
     else if (auto ttv = getMutable<TableType>(ty))
         return &ttv->tags;
-    else if (auto ctv = getMutable<ClassType>(ty))
-        return &ctv->tags;
+    else if (auto etv = getMutable<ExternType>(ty))
+        return &etv->tags;
 
     return nullptr;
 }
@@ -1369,19 +1310,19 @@ bool hasTag(TypeId ty, const std::string& tagName)
 {
     ty = follow(ty);
 
-    // We special case classes because getTags only returns a pointer to one vector of tags.
-    // But classes has multiple vector of tags, represented throughout the hierarchy.
-    if (auto ctv = get<ClassType>(ty))
+    // We special case extern types because getTags only returns a pointer to one vector of tags.
+    // But extern types has multiple vector of tags, represented throughout the hierarchy.
+    if (auto etv = get<ExternType>(ty))
     {
-        while (ctv)
+        while (etv)
         {
-            if (hasTag(ctv->tags, tagName))
+            if (hasTag(etv->tags, tagName))
                 return true;
-            else if (!ctv->parent)
+            else if (!etv->parent)
                 return false;
 
-            ctv = get<ClassType>(*ctv->parent);
-            LUAU_ASSERT(ctv);
+            etv = get<ExternType>(*etv->parent);
+            LUAU_ASSERT(etv);
         }
     }
     else if (auto tags = getTags(ty))

Analysis/src/TypeArena.cpp

@@ -50,36 +50,9 @@ TypeId TypeArena::freshType(NotNull<BuiltinTypes> builtins, Scope* scope, TypeLe
     return allocated;
 }
 
-TypeId TypeArena::freshType_DEPRECATED(TypeLevel level)
+TypePackId TypeArena::freshTypePack(Scope* scope, Polarity polarity)
 {
-    TypeId allocated = types.allocate(FreeType{level});
-
-    asMutable(allocated)->owningArena = this;
-
-    return allocated;
-}
-
-TypeId TypeArena::freshType_DEPRECATED(Scope* scope)
-{
-    TypeId allocated = types.allocate(FreeType{scope});
-
-    asMutable(allocated)->owningArena = this;
-
-    return allocated;
-}
-
-TypeId TypeArena::freshType_DEPRECATED(Scope* scope, TypeLevel level)
-{
-    TypeId allocated = types.allocate(FreeType{scope, level});
-
-    asMutable(allocated)->owningArena = this;
-
-    return allocated;
-}
-
-TypePackId TypeArena::freshTypePack(Scope* scope)
-{
-    TypePackId allocated = typePacks.allocate(FreeTypePack{scope});
+    TypePackId allocated = typePacks.allocate(FreeTypePack{scope, polarity});
 
     asMutable(allocated)->owningArena = this;
 

Analysis/src/TypeAttach.cpp

@@ -13,6 +13,9 @@
 
 #include <string>
 
+LUAU_FASTFLAG(LuauStoreCSTData2)
+LUAU_FASTFLAG(LuauStoreReturnTypesAsPackOnAst)
+
 static char* allocateString(Luau::Allocator& allocator, std::string_view contents)
 {
     char* result = (char*)allocator.allocate(contents.size() + 1);
@@ -217,21 +220,21 @@ public:
         return Luau::visit(*this, mtv.table->ty);
     }
 
-    AstType* operator()(const ClassType& ctv)
+    AstType* operator()(const ExternType& etv)
     {
         RecursionCounter counter(&count);
 
-        char* name = allocateString(*allocator, ctv.name);
+        char* name = allocateString(*allocator, etv.name);
 
-        if (!options.expandClassProps || hasSeen(&ctv) || count > 1)
+        if (!options.expandExternTypeProps || hasSeen(&etv) || count > 1)
             return allocator->alloc<AstTypeReference>(Location(), std::nullopt, AstName{name}, std::nullopt, Location());
 
         AstArray<AstTableProp> props;
-        props.size = ctv.props.size();
+        props.size = etv.props.size();
         props.data = static_cast<AstTableProp*>(allocator->allocate(sizeof(AstTableProp) * props.size));
 
         int idx = 0;
-        for (const auto& [propName, prop] : ctv.props)
+        for (const auto& [propName, prop] : etv.props)
         {
             char* name = allocateString(*allocator, propName);
 
@@ -242,13 +245,13 @@ public:
         }
 
         AstTableIndexer* indexer = nullptr;
-        if (ctv.indexer)
+        if (etv.indexer)
         {
             RecursionCounter counter(&count);
 
             indexer = allocator->alloc<AstTableIndexer>();
-            indexer->indexType = Luau::visit(*this, ctv.indexer->indexType->ty);
-            indexer->resultType = Luau::visit(*this, ctv.indexer->indexResultType->ty);
+            indexer->indexType = Luau::visit(*this, etv.indexer->indexType->ty);
+            indexer->resultType = Luau::visit(*this, etv.indexer->indexResultType->ty);
         }
 
         return allocator->alloc<AstTypeTable>(Location(), props, indexer);
@@ -305,7 +308,8 @@ public:
             std::optional<AstArgumentName>* arg = &argNames.data[i++];
 
             if (el)
-                new (arg) std::optional<AstArgumentName>(AstArgumentName(AstName(el->name.c_str()), el->location));
+                new (arg)
+                    std::optional<AstArgumentName>(AstArgumentName(AstName(el->name.c_str()), FFlag::LuauStoreCSTData2 ? Location() : el->location));
             else
                 new (arg) std::optional<AstArgumentName>();
         }
@@ -325,9 +329,19 @@ public:
         if (retTail)
             retTailAnnotation = rehydrate(*retTail);
 
-        return allocator->alloc<AstTypeFunction>(
-            Location(), generics, genericPacks, AstTypeList{argTypes, argTailAnnotation}, argNames, AstTypeList{returnTypes, retTailAnnotation}
-        );
+        if (FFlag::LuauStoreReturnTypesAsPackOnAst)
+        {
+            auto returnAnnotation = allocator->alloc<AstTypePackExplicit>(Location(), AstTypeList{returnTypes, retTailAnnotation});
+            return allocator->alloc<AstTypeFunction>(
+                Location(), generics, genericPacks, AstTypeList{argTypes, argTailAnnotation}, argNames, returnAnnotation
+            );
+        }
+        else
+        {
+            return allocator->alloc<AstTypeFunction>(
+                Location(), generics, genericPacks, AstTypeList{argTypes, argTailAnnotation}, argNames, AstTypeList{returnTypes, retTailAnnotation}
+            );
+        }
     }
     AstType* operator()(const ErrorType&)
     {
@@ -582,19 +596,40 @@ public:
             visitLocal(arg);
         }
 
-        if (!fn->returnAnnotation)
+        if (FFlag::LuauStoreReturnTypesAsPackOnAst)
         {
-            if (auto result = getScope(fn->body->location))
+            if (!fn->returnAnnotation)
             {
-                TypePackId ret = result->returnType;
+                if (auto result = getScope(fn->body->location))
+                {
+                    TypePackId ret = result->returnType;
 
-                AstTypePack* variadicAnnotation = nullptr;
-                const auto& [v, tail] = flatten(ret);
+                    AstTypePack* variadicAnnotation = nullptr;
+                    const auto& [v, tail] = flatten(ret);
 
-                if (tail)
-                    variadicAnnotation = TypeRehydrationVisitor(allocator, &syntheticNames).rehydrate(*tail);
+                    if (tail)
+                        variadicAnnotation = TypeRehydrationVisitor(allocator, &syntheticNames).rehydrate(*tail);
 
-                fn->returnAnnotation = AstTypeList{typeAstPack(ret), variadicAnnotation};
+                    fn->returnAnnotation = allocator->alloc<AstTypePackExplicit>(Location(), AstTypeList{typeAstPack(ret), variadicAnnotation});
+                }
+            }
+        }
+        else
+        {
+            if (!fn->returnAnnotation_DEPRECATED)
+            {
+                if (auto result = getScope(fn->body->location))
+                {
+                    TypePackId ret = result->returnType;
+
+                    AstTypePack* variadicAnnotation = nullptr;
+                    const auto& [v, tail] = flatten(ret);
+
+                    if (tail)
+                        variadicAnnotation = TypeRehydrationVisitor(allocator, &syntheticNames).rehydrate(*tail);
+
+                    fn->returnAnnotation_DEPRECATED = AstTypeList{typeAstPack(ret), variadicAnnotation};
+                }
             }
         }
 

Analysis/src/TypeChecker2.cpp

@@ -26,10 +26,15 @@
 #include "Luau/VisitType.h"
 
 #include <algorithm>
+#include <sstream>
 
 LUAU_FASTFLAG(DebugLuauMagicTypes)
 
-LUAU_FASTFLAG(LuauFreeTypesMustHaveBounds)
+LUAU_FASTFLAGVARIABLE(LuauImproveTypePathsInErrors)
+LUAU_FASTFLAG(LuauUserTypeFunTypecheck)
+LUAU_FASTFLAGVARIABLE(LuauTypeCheckerAcceptNumberConcats)
+LUAU_FASTFLAGVARIABLE(LuauTypeCheckerStricterIndexCheck)
+LUAU_FASTFLAG(LuauStoreReturnTypesAsPackOnAst)
 
 namespace Luau
 {
@@ -657,7 +662,7 @@ void TypeChecker2::visit(AstStat* stat)
         return visit(s);
     else if (auto s = stat->as<AstStatDeclareGlobal>())
         return visit(s);
-    else if (auto s = stat->as<AstStatDeclareClass>())
+    else if (auto s = stat->as<AstStatDeclareExternType>())
         return visit(s);
     else if (auto s = stat->as<AstStatError>())
         return visit(s);
@@ -1201,7 +1206,8 @@ void TypeChecker2::visit(AstStatTypeAlias* stat)
 
 void TypeChecker2::visit(AstStatTypeFunction* stat)
 {
-    // TODO: add type checking for user-defined type functions
+    if (FFlag::LuauUserTypeFunTypecheck)
+        visit(stat->body);
 }
 
 void TypeChecker2::visit(AstTypeList types)
@@ -1216,7 +1222,10 @@ void TypeChecker2::visit(AstStatDeclareFunction* stat)
 {
     visitGenerics(stat->generics, stat->genericPacks);
     visit(stat->params);
-    visit(stat->retTypes);
+    if (FFlag::LuauStoreReturnTypesAsPackOnAst)
+        visit(stat->retTypes);
+    else
+        visit(stat->retTypes_DEPRECATED);
 }
 
 void TypeChecker2::visit(AstStatDeclareGlobal* stat)
@@ -1224,9 +1233,9 @@ void TypeChecker2::visit(AstStatDeclareGlobal* stat)
     visit(stat->type);
 }
 
-void TypeChecker2::visit(AstStatDeclareClass* stat)
+void TypeChecker2::visit(AstStatDeclareExternType* stat)
 {
-    for (const AstDeclaredClassProp& prop : stat->props)
+    for (const AstDeclaredExternTypeProperty& prop : stat->props)
         visit(prop.ty);
 }
 
@@ -1670,12 +1679,12 @@ void TypeChecker2::visit(AstExprIndexExpr* indexExpr, ValueContext context)
     {
         return indexExprMetatableHelper(indexExpr, mt, exprType, indexType);
     }
-    else if (auto cls = get<ClassType>(exprType))
+    else if (auto cls = get<ExternType>(exprType))
     {
         if (cls->indexer)
             testIsSubtype(indexType, cls->indexer->indexType, indexExpr->index->location);
         else
-            reportError(DynamicPropertyLookupOnClassesUnsafe{exprType}, indexExpr->location);
+            reportError(DynamicPropertyLookupOnExternTypesUnsafe{exprType}, indexExpr->location);
     }
     else if (get<UnionType>(exprType) && isOptional(exprType))
     {
@@ -1816,8 +1825,16 @@ void TypeChecker2::visit(AstExprFunction* fn)
     visit(fn->body);
 
     // we need to typecheck the return annotation itself, if it exists.
-    if (fn->returnAnnotation)
-        visit(*fn->returnAnnotation);
+    if (FFlag::LuauStoreReturnTypesAsPackOnAst)
+    {
+        if (fn->returnAnnotation)
+            visit(fn->returnAnnotation);
+    }
+    else
+    {
+        if (fn->returnAnnotation_DEPRECATED)
+            visit(*fn->returnAnnotation_DEPRECATED);
+    }
 
 
     // If the function type has a function annotation, we need to see if we can suggest an annotation
@@ -2031,7 +2048,7 @@ TypeId TypeChecker2::visit(AstExprBinary* expr, AstNode* overrideKey)
         // If we're working with things that are not tables, the metatable comparisons above are a little excessive
         // It's ok for one type to have a meta table and the other to not. In that case, we should fall back on
         // checking if the intersection of the types is inhabited. If `typesHaveIntersection` failed due to limits,
-        // TODO: Maybe add more checks here (e.g. for functions, classes, etc)
+        // TODO: Maybe add more checks here (e.g. for functions, extern types, etc)
         if (!(get<TableType>(leftType) || get<TableType>(rightType)))
             if (!leftMt.has_value() || !rightMt.has_value())
                 matches = matches || typesHaveIntersection != NormalizationResult::False;
@@ -2096,10 +2113,7 @@ TypeId TypeChecker2::visit(AstExprBinary* expr, AstNode* overrideKey)
                 }
                 else
                 {
-                    expectedRets = module->internalTypes.addTypePack(
-                        {FFlag::LuauFreeTypesMustHaveBounds ? module->internalTypes.freshType(builtinTypes, scope, TypeLevel{})
-                                                            : module->internalTypes.freshType_DEPRECATED(scope, TypeLevel{})}
-                    );
+                    expectedRets = module->internalTypes.addTypePack({module->internalTypes.freshType(builtinTypes, scope, TypeLevel{})});
                 }
 
                 TypeId expectedTy = module->internalTypes.addType(FunctionType(expectedArgs, expectedRets));
@@ -2225,10 +2239,21 @@ TypeId TypeChecker2::visit(AstExprBinary* expr, AstNode* overrideKey)
 
         return builtinTypes->numberType;
     case AstExprBinary::Op::Concat:
-        testIsSubtype(leftType, builtinTypes->stringType, expr->left->location);
-        testIsSubtype(rightType, builtinTypes->stringType, expr->right->location);
+    {
+        if (FFlag::LuauTypeCheckerAcceptNumberConcats)
+        {
+            const TypeId numberOrString = module->internalTypes.addType(UnionType{{builtinTypes->numberType, builtinTypes->stringType}});
+            testIsSubtype(leftType, numberOrString, expr->left->location);
+            testIsSubtype(rightType, numberOrString, expr->right->location);
+        }
+        else
+        {
+            testIsSubtype(leftType, builtinTypes->stringType, expr->left->location);
+            testIsSubtype(rightType, builtinTypes->stringType, expr->right->location);
+        }
 
         return builtinTypes->stringType;
+    }
     case AstExprBinary::Op::CompareGe:
     case AstExprBinary::Op::CompareGt:
     case AstExprBinary::Op::CompareLe:
@@ -2351,8 +2376,7 @@ TypeId TypeChecker2::flattenPack(TypePackId pack)
         return *fst;
     else if (auto ftp = get<FreeTypePack>(pack))
     {
-        TypeId result = FFlag::LuauFreeTypesMustHaveBounds ? module->internalTypes.freshType(builtinTypes, ftp->scope)
-                                                           : module->internalTypes.addType(FreeType{ftp->scope});
+        TypeId result = module->internalTypes.freshType(builtinTypes, ftp->scope);
         TypePackId freeTail = module->internalTypes.addTypePack(FreeTypePack{ftp->scope});
 
         TypePack* resultPack = emplaceTypePack<TypePack>(asMutable(pack));
@@ -2597,7 +2621,10 @@ void TypeChecker2::visit(AstTypeFunction* ty)
 {
     visitGenerics(ty->generics, ty->genericPacks);
     visit(ty->argTypes);
-    visit(ty->returnTypes);
+    if (FFlag::LuauStoreReturnTypesAsPackOnAst)
+        visit(ty->returnTypes);
+    else
+        visit(ty->returnTypes_DEPRECATED);
 }
 
 void TypeChecker2::visit(AstTypeTypeof* ty)
@@ -2701,20 +2728,61 @@ Reasonings TypeChecker2::explainReasonings_(TID subTy, TID superTy, Location loc
         if (!subLeafTy && !superLeafTy && !subLeafTp && !superLeafTp)
             ice->ice("Subtyping test returned a reasoning where one path ends at a type and the other ends at a pack.", location);
 
-        std::string relation = "a subtype of";
-        if (reasoning.variance == SubtypingVariance::Invariant)
-            relation = "exactly";
-        else if (reasoning.variance == SubtypingVariance::Contravariant)
-            relation = "a supertype of";
+        if (FFlag::LuauImproveTypePathsInErrors)
+        {
+            std::string relation = "a subtype of";
+            if (reasoning.variance == SubtypingVariance::Invariant)
+                relation = "exactly";
+            else if (reasoning.variance == SubtypingVariance::Contravariant)
+                relation = "a supertype of";
 
-        std::string reason;
-        if (reasoning.subPath == reasoning.superPath)
-            reason = "at " + toString(reasoning.subPath) + ", " + toString(subLeaf) + " is not " + relation + " " + toString(superLeaf);
+            std::string subLeafAsString = toString(subLeaf);
+            // if the string is empty, it must be an empty type pack
+            if (subLeafAsString.empty())
+                subLeafAsString = "()";
+
+            std::string superLeafAsString = toString(superLeaf);
+            // if the string is empty, it must be an empty type pack
+            if (superLeafAsString.empty())
+                superLeafAsString = "()";
+
+            std::stringstream baseReasonBuilder;
+            baseReasonBuilder << "`" << subLeafAsString << "` is not " << relation << " `" << superLeafAsString << "`";
+            std::string baseReason = baseReasonBuilder.str();
+
+            std::stringstream reason;
+
+            if (reasoning.subPath == reasoning.superPath)
+                reason << toStringHuman(reasoning.subPath) << "`" << subLeafAsString << "` in the former type and `" << superLeafAsString
+                       << "` in the latter type, and " << baseReason;
+            else if (!reasoning.subPath.empty() && !reasoning.superPath.empty())
+                reason << toStringHuman(reasoning.subPath) << "`" << subLeafAsString << "` and " << toStringHuman(reasoning.superPath) << "`"
+                       << superLeafAsString << "`, and " << baseReason;
+            else if (!reasoning.subPath.empty())
+                reason << toStringHuman(reasoning.subPath) << "`" << subLeafAsString << "`, which is not " << relation << " `" << superLeafAsString
+                       << "`";
+            else
+                reason << toStringHuman(reasoning.superPath) << "`" << superLeafAsString << "`, and " << baseReason;
+
+            reasons.push_back(reason.str());
+        }
         else
-            reason = "type " + toString(subTy) + toString(reasoning.subPath, /* prefixDot */ true) + " (" + toString(subLeaf) + ") is not " +
-                     relation + " " + toString(superTy) + toString(reasoning.superPath, /* prefixDot */ true) + " (" + toString(superLeaf) + ")";
+        {
+            std::string relation = "a subtype of";
+            if (reasoning.variance == SubtypingVariance::Invariant)
+                relation = "exactly";
+            else if (reasoning.variance == SubtypingVariance::Contravariant)
+                relation = "a supertype of";
 
-        reasons.push_back(reason);
+            std::string reason;
+            if (reasoning.subPath == reasoning.superPath)
+                reason = "at " + toString(reasoning.subPath) + ", " + toString(subLeaf) + " is not " + relation + " " + toString(superLeaf);
+            else
+                reason = "type " + toString(subTy) + toString(reasoning.subPath, /* prefixDot */ true) + " (" + toString(subLeaf) + ") is not " +
+                         relation + " " + toString(superTy) + toString(reasoning.superPath, /* prefixDot */ true) + " (" + toString(superLeaf) + ")";
+
+            reasons.push_back(reason);
+        }
 
         // if we haven't already proved this isn't suppressing, we have to keep checking.
         if (suppressed)
@@ -2880,7 +2948,7 @@ PropertyTypes TypeChecker2::lookupProp(
 
     if (normValid)
     {
-        for (const auto& [ty, _negations] : norm->classes.classes)
+        for (const auto& [ty, _negations] : norm->externTypes.externTypes)
         {
             fetch(ty);
 
@@ -2975,10 +3043,10 @@ void TypeChecker2::checkIndexTypeFromType(
         if (propTypes.foundOneProp())
             reportError(MissingUnionProperty{tableTy, propTypes.missingProp, prop}, location);
         // For class LValues, we don't want to report an extension error,
-        // because classes come into being with full knowledge of their
+        // because extern types come into being with full knowledge of their
         // shape. We instead want to report the unknown property error of
         // the `else` branch.
-        else if (context == ValueContext::LValue && !get<ClassType>(tableTy))
+        else if (context == ValueContext::LValue && !get<ExternType>(tableTy))
         {
             const auto lvPropTypes = lookupProp(norm.get(), prop, ValueContext::RValue, location, astIndexExprType, dummy);
             if (lvPropTypes.foundOneProp() && lvPropTypes.noneMissingProp())
@@ -2988,7 +3056,7 @@ void TypeChecker2::checkIndexTypeFromType(
             else
                 reportError(CannotExtendTable{tableTy, CannotExtendTable::Property, prop}, location);
         }
-        else if (context == ValueContext::RValue && !get<ClassType>(tableTy))
+        else if (context == ValueContext::RValue && !get<ExternType>(tableTy))
         {
             const auto rvPropTypes = lookupProp(norm.get(), prop, ValueContext::LValue, location, astIndexExprType, dummy);
             if (rvPropTypes.foundOneProp() && rvPropTypes.noneMissingProp())
@@ -3041,19 +3109,25 @@ PropertyType TypeChecker2::hasIndexTypeFromType(
                 return {NormalizationResult::True, {tt->indexer->indexResultType}};
         }
 
-
-        // if we are in a conditional context, we treat the property as present and `unknown` because
-        // we may be _refining_ `tableTy` to include that property. we will want to revisit this a bit
-        // in the future once luau has support for exact tables since this only applies when inexact.
-        return {inConditional(typeContext) ? NormalizationResult::True : NormalizationResult::False, {builtinTypes->unknownType}};
+        if (FFlag::LuauTypeCheckerStricterIndexCheck)
+        {
+            return {NormalizationResult::False, {builtinTypes->unknownType}};
+        }
+        else
+        {
+            // if we are in a conditional context, we treat the property as present and `unknown` because
+            // we may be _refining_ `tableTy` to include that property. we will want to revisit this a bit
+            // in the future once luau has support for exact tables since this only applies when inexact.
+            return {inConditional(typeContext) ? NormalizationResult::True : NormalizationResult::False, {builtinTypes->unknownType}};
+        }
     }
-    else if (const ClassType* cls = get<ClassType>(ty))
+    else if (const ExternType* cls = get<ExternType>(ty))
     {
         // If the property doesn't exist on the class, we consult the indexer
         // We need to check if the type of the index expression foo (x[foo])
         // is compatible with the indexer's indexType
         // Construct the intersection and test inhabitedness!
-        if (auto property = lookupClassProp(cls, prop))
+        if (auto property = lookupExternTypeProp(cls, prop))
             return {NormalizationResult::True, context == ValueContext::LValue ? property->writeTy : property->readTy};
         if (cls->indexer)
         {
@@ -3126,17 +3200,17 @@ void TypeChecker2::diagnoseMissingTableKey(UnknownProperty* utk, TypeErrorData&
 
     if (auto ttv = getTableType(utk->table))
         accumulate(ttv->props);
-    else if (auto ctv = get<ClassType>(follow(utk->table)))
+    else if (auto etv = get<ExternType>(follow(utk->table)))
     {
-        while (ctv)
+        while (etv)
         {
-            accumulate(ctv->props);
+            accumulate(etv->props);
 
-            if (!ctv->parent)
+            if (!etv->parent)
                 break;
 
-            ctv = get<ClassType>(*ctv->parent);
-            LUAU_ASSERT(ctv);
+            etv = get<ExternType>(*etv->parent);
+            LUAU_ASSERT(etv);
         }
     }
 

Analysis/src/TypeFunctionReductionGuesser.cpp

@@ -46,7 +46,7 @@ struct InstanceCollector2 : TypeOnceVisitor
             cyclicInstance.insert(t);
     }
 
-    bool visit(TypeId ty, const ClassType&) override
+    bool visit(TypeId ty, const ExternType&) override
     {
         return false;
     }

Analysis/src/TypeFunctionRuntime.cpp

@@ -13,12 +13,9 @@
 #include <set>
 #include <vector>
 
-LUAU_FASTFLAGVARIABLE(LuauTypeFunFixHydratedClasses)
 LUAU_DYNAMIC_FASTINT(LuauTypeFunctionSerdeIterationLimit)
-LUAU_FASTFLAGVARIABLE(LuauTypeFunSingletonEquality)
-LUAU_FASTFLAGVARIABLE(LuauUserTypeFunTypeofReturnsType)
-LUAU_FASTFLAGVARIABLE(LuauTypeFunPrintFix)
 LUAU_FASTFLAGVARIABLE(LuauTypeFunReadWriteParents)
+LUAU_FASTFLAGVARIABLE(LuauTypeFunOptional)
 
 namespace Luau
 {
@@ -158,7 +155,7 @@ static std::string getTag(lua_State* L, TypeFunctionTypeId ty)
         return "table";
     else if (get<TypeFunctionFunctionType>(ty))
         return "function";
-    else if (get<TypeFunctionClassType>(ty))
+    else if (get<TypeFunctionExternType>(ty))
         return "class";
     else if (get<TypeFunctionGenericType>(ty))
         return "generic";
@@ -319,6 +316,38 @@ static int getSingletonValue(lua_State* L)
     luaL_error(L, "type.value: can't call `value` method on `%s` type", getTag(L, self).c_str());
 }
 
+// Luau: `types.optional(ty: type) -> type`
+// Returns the type instance representing an optional version of `ty`.
+// If `ty` is a union, this adds `nil` to the components of the union.
+// Otherwise, makes a union of the two things.
+static int createOptional(lua_State* L)
+{
+    LUAU_ASSERT(FFlag::LuauTypeFunOptional);
+
+    int argumentCount = lua_gettop(L);
+    if (argumentCount != 1)
+        luaL_error(L, "types.optional: expected 1 argument, but got %d", argumentCount);
+
+    TypeFunctionTypeId argument = getTypeUserData(L, 1);
+
+    std::vector<TypeFunctionTypeId> components;
+
+    if (auto unionTy = get<TypeFunctionUnionType>(argument))
+    {
+        components.reserve(unionTy->components.size() + 1);
+
+        components.insert(components.begin(), unionTy->components.begin(), unionTy->components.end());
+    }
+    else
+        components.emplace_back(argument);
+
+    components.emplace_back(allocateTypeFunctionType(L, TypeFunctionPrimitiveType(TypeFunctionPrimitiveType::NilType)));
+
+    allocTypeUserData(L, TypeFunctionUnionType{components});
+
+    return 1;
+}
+
 // Luau: `types.unionof(...: type) -> type`
 // Returns the type instance representing union
 static int createUnion(lua_State* L)
@@ -1118,7 +1147,7 @@ static int getClassParent_DEPRECATED(lua_State* L)
         luaL_error(L, "type.parent: expected 1 arguments, but got %d", argumentCount);
 
     TypeFunctionTypeId self = getTypeUserData(L, 1);
-    auto tfct = get<TypeFunctionClassType>(self);
+    auto tfct = get<TypeFunctionExternType>(self);
     if (!tfct)
         luaL_error(L, "type.parent: expected self to be a class, but got %s instead", getTag(L, self).c_str());
 
@@ -1140,7 +1169,7 @@ static int getReadParent(lua_State* L)
         luaL_error(L, "type.parent: expected 1 arguments, but got %d", argumentCount);
 
     TypeFunctionTypeId self = getTypeUserData(L, 1);
-    auto tfct = get<TypeFunctionClassType>(self);
+    auto tfct = get<TypeFunctionExternType>(self);
     if (!tfct)
         luaL_error(L, "type.parent: expected self to be a class, but got %s instead", getTag(L, self).c_str());
 
@@ -1162,7 +1191,7 @@ static int getWriteParent(lua_State* L)
         luaL_error(L, "type.parent: expected 1 arguments, but got %d", argumentCount);
 
     TypeFunctionTypeId self = getTypeUserData(L, 1);
-    auto tfct = get<TypeFunctionClassType>(self);
+    auto tfct = get<TypeFunctionExternType>(self);
     if (!tfct)
         luaL_error(L, "type.parent: expected self to be a class, but got %s instead", getTag(L, self).c_str());
 
@@ -1246,7 +1275,7 @@ static int getProps(lua_State* L)
         return 1;
     }
 
-    if (auto tfct = get<TypeFunctionClassType>(self))
+    if (auto tfct = get<TypeFunctionExternType>(self))
     {
         lua_createtable(L, int(tfct->props.size()), 0);
         for (auto& [name, prop] : tfct->props)
@@ -1309,7 +1338,7 @@ static int getIndexer(lua_State* L)
         return 1;
     }
 
-    if (auto tfct = get<TypeFunctionClassType>(self))
+    if (auto tfct = get<TypeFunctionExternType>(self))
     {
         // if the indexer does not exist, we should return nil
         if (!tfct->indexer.has_value())
@@ -1357,7 +1386,7 @@ static int getReadIndexer(lua_State* L)
         return 1;
     }
 
-    if (auto tfct = get<TypeFunctionClassType>(self))
+    if (auto tfct = get<TypeFunctionExternType>(self))
     {
         // if the indexer does not exist, we should return nil
         if (!tfct->indexer.has_value())
@@ -1403,7 +1432,7 @@ static int getWriteIndexer(lua_State* L)
         return 1;
     }
 
-    if (auto tfct = get<TypeFunctionClassType>(self))
+    if (auto tfct = get<TypeFunctionExternType>(self))
     {
         // if the indexer does not exist, we should return nil
         if (!tfct->indexer.has_value())
@@ -1443,7 +1472,7 @@ static int getMetatable(lua_State* L)
         return 1;
     }
 
-    if (auto tfct = get<TypeFunctionClassType>(self))
+    if (auto tfct = get<TypeFunctionExternType>(self))
     {
         // if the metatable does not exist, we should return nil
         if (!tfct->metatable.has_value())
@@ -1528,6 +1557,7 @@ void registerTypesLibrary(lua_State* L)
         {"copy", deepCopy},
         {"generic", createGeneric},
 
+        {(FFlag::LuauTypeFunOptional) ? "optional" : nullptr, (FFlag::LuauTypeFunOptional) ? createOptional : nullptr},
         {nullptr, nullptr}
     };
 
@@ -1597,7 +1627,7 @@ void registerTypeUserData(lua_State* L)
         // Union and Intersection type methods
         {"components", getComponents},
 
-        // Class type methods
+        //  Extern type methods
         {FFlag::LuauTypeFunReadWriteParents ? "readparent" : "parent", FFlag::LuauTypeFunReadWriteParents ? getReadParent : getClassParent_DEPRECATED},
 
         // Function type methods (cont.)
@@ -1608,7 +1638,7 @@ void registerTypeUserData(lua_State* L)
         {"name", getGenericName},
         {"ispack", getGenericIsPack},
 
-        // move this under Class type methods when removing FFlagLuauTypeFunReadWriteParents
+        // move this under extern type methods when removing FFlagLuauTypeFunReadWriteParents
         {FFlag::LuauTypeFunReadWriteParents ? "writeparent" : nullptr, FFlag::LuauTypeFunReadWriteParents ? getWriteParent : nullptr},
 
         {nullptr, nullptr}
@@ -1617,11 +1647,8 @@ void registerTypeUserData(lua_State* L)
     // Create and register metatable for type userdata
     luaL_newmetatable(L, "type");
 
-    if (FFlag::LuauUserTypeFunTypeofReturnsType)
-    {
-        lua_pushstring(L, "type");
-        lua_setfield(L, -2, "__type");
-    }
+    lua_pushstring(L, "type");
+    lua_setfield(L, -2, "__type");
 
     // Protect metatable from being changed
     lua_pushstring(L, "The metatable is locked");
@@ -1662,10 +1689,7 @@ static int print(lua_State* L)
         const char* s = luaL_tolstring(L, i, &l); // convert to string using __tostring et al
         if (i > 1)
         {
-            if (FFlag::LuauTypeFunPrintFix)
-                result.append(1, '\t');
-            else
-                result.append('\t', 1);
+            result.append(1, '\t');
         }
         result.append(s, l);
         lua_pop(L, 1);
@@ -1758,14 +1782,14 @@ bool areEqual(SeenSet& seen, const TypeFunctionSingletonType& lhs, const TypeFun
 
     {
         const TypeFunctionBooleanSingleton* lp = get<TypeFunctionBooleanSingleton>(&lhs);
-        const TypeFunctionBooleanSingleton* rp = get<TypeFunctionBooleanSingleton>(FFlag::LuauTypeFunSingletonEquality ? &rhs : &lhs);
+        const TypeFunctionBooleanSingleton* rp = get<TypeFunctionBooleanSingleton>(&rhs);
         if (lp && rp)
             return lp->value == rp->value;
     }
 
     {
         const TypeFunctionStringSingleton* lp = get<TypeFunctionStringSingleton>(&lhs);
-        const TypeFunctionStringSingleton* rp = get<TypeFunctionStringSingleton>(FFlag::LuauTypeFunSingletonEquality ? &rhs : &lhs);
+        const TypeFunctionStringSingleton* rp = get<TypeFunctionStringSingleton>(&rhs);
         if (lp && rp)
             return lp->value == rp->value;
     }
@@ -1913,15 +1937,12 @@ bool areEqual(SeenSet& seen, const TypeFunctionFunctionType& lhs, const TypeFunc
     return true;
 }
 
-bool areEqual(SeenSet& seen, const TypeFunctionClassType& lhs, const TypeFunctionClassType& rhs)
+bool areEqual(SeenSet& seen, const TypeFunctionExternType& lhs, const TypeFunctionExternType& rhs)
 {
     if (seenSetContains(seen, &lhs, &rhs))
         return true;
 
-    if (FFlag::LuauTypeFunFixHydratedClasses)
-        return lhs.classTy == rhs.classTy;
-    else
-        return lhs.name_DEPRECATED == rhs.name_DEPRECATED;
+    return lhs.externTy == rhs.externTy;
 }
 
 bool areEqual(SeenSet& seen, const TypeFunctionType& lhs, const TypeFunctionType& rhs)
@@ -1989,8 +2010,8 @@ bool areEqual(SeenSet& seen, const TypeFunctionType& lhs, const TypeFunctionType
     }
 
     {
-        const TypeFunctionClassType* lf = get<TypeFunctionClassType>(&lhs);
-        const TypeFunctionClassType* rf = get<TypeFunctionClassType>(&rhs);
+        const TypeFunctionExternType* lf = get<TypeFunctionExternType>(&lhs);
+        const TypeFunctionExternType* rf = get<TypeFunctionExternType>(&rhs);
         if (lf && rf)
             return areEqual(seen, *lf, *rf);
     }
@@ -2279,7 +2300,7 @@ private:
             TypeFunctionTypePackId emptyTypePack = typeFunctionRuntime->typePackArena.allocate(TypeFunctionTypePack{});
             target = typeFunctionRuntime->typeArena.allocate(TypeFunctionFunctionType{{}, {}, emptyTypePack, emptyTypePack});
         }
-        else if (auto c = get<TypeFunctionClassType>(ty))
+        else if (auto c = get<TypeFunctionExternType>(ty))
             target = ty; // Don't copy a class since they are immutable
         else if (auto g = get<TypeFunctionGenericType>(ty))
             target = typeFunctionRuntime->typeArena.allocate(TypeFunctionGenericType{g->isNamed, g->isPack, g->name});
@@ -2334,7 +2355,7 @@ private:
             cloneChildren(t1, t2);
         else if (auto [f1, f2] = std::tuple{getMutable<TypeFunctionFunctionType>(ty), getMutable<TypeFunctionFunctionType>(tfti)}; f1 && f2)
             cloneChildren(f1, f2);
-        else if (auto [c1, c2] = std::tuple{getMutable<TypeFunctionClassType>(ty), getMutable<TypeFunctionClassType>(tfti)}; c1 && c2)
+        else if (auto [c1, c2] = std::tuple{getMutable<TypeFunctionExternType>(ty), getMutable<TypeFunctionExternType>(tfti)}; c1 && c2)
             cloneChildren(c1, c2);
         else if (auto [g1, g2] = std::tuple{getMutable<TypeFunctionGenericType>(ty), getMutable<TypeFunctionGenericType>(tfti)}; g1 && g2)
             cloneChildren(g1, g2);
@@ -2444,7 +2465,7 @@ private:
         f2->retTypes = shallowClone(f1->retTypes);
     }
 
-    void cloneChildren(TypeFunctionClassType* c1, TypeFunctionClassType* c2)
+    void cloneChildren(TypeFunctionExternType* c1, TypeFunctionExternType* c2)
     {
         // noop.
     }

Analysis/src/TypeFunctionRuntimeBuilder.cpp

@@ -19,7 +19,6 @@
 // used to control the recursion limit of any operations done by user-defined type functions
 // currently, controls serialization, deserialization, and `type.copy`
 LUAU_DYNAMIC_FASTINTVARIABLE(LuauTypeFunctionSerdeIterationLimit, 100'000);
-LUAU_FASTFLAG(LuauTypeFunFixHydratedClasses)
 LUAU_FASTFLAG(LuauTypeFunReadWriteParents)
 
 namespace Luau
@@ -207,21 +206,13 @@ private:
             TypeFunctionTypePackId emptyTypePack = typeFunctionRuntime->typePackArena.allocate(TypeFunctionTypePack{});
             target = typeFunctionRuntime->typeArena.allocate(TypeFunctionFunctionType{{}, {}, emptyTypePack, emptyTypePack});
         }
-        else if (auto c = get<ClassType>(ty))
+        else if (auto c = get<ExternType>(ty))
         {
-            if (FFlag::LuauTypeFunFixHydratedClasses)
-            {
-                // Since there aren't any new class types being created in type functions, we will deserialize by using a direct reference to the
-                // original class
-                target = typeFunctionRuntime->typeArena.allocate(TypeFunctionClassType{{}, std::nullopt, std::nullopt, std::nullopt, std::nullopt, std::nullopt, ty});
-            }
-            else
-            {
-                state->classesSerialized_DEPRECATED[c->name] = ty;
-                target = typeFunctionRuntime->typeArena.allocate(
-                    TypeFunctionClassType{{}, std::nullopt, std::nullopt, std::nullopt, std::nullopt, std::nullopt, /* classTy */ nullptr, c->name}
-                );
-            }
+            // Since there aren't any new class types being created in type functions, we will deserialize by using a direct reference to the original
+            // class
+            target = typeFunctionRuntime->typeArena.allocate(
+                TypeFunctionExternType{{}, std::nullopt, std::nullopt, std::nullopt, std::nullopt, std::nullopt, ty}
+            );
         }
         else if (auto g = get<GenericType>(ty))
         {
@@ -300,7 +291,7 @@ private:
             serializeChildren(m1, m2);
         else if (auto [f1, f2] = std::tuple{get<FunctionType>(ty), getMutable<TypeFunctionFunctionType>(tfti)}; f1 && f2)
             serializeChildren(f1, f2);
-        else if (auto [c1, c2] = std::tuple{get<ClassType>(ty), getMutable<TypeFunctionClassType>(tfti)}; c1 && c2)
+        else if (auto [c1, c2] = std::tuple{get<ExternType>(ty), getMutable<TypeFunctionExternType>(tfti)}; c1 && c2)
             serializeChildren(c1, c2);
         else if (auto [g1, g2] = std::tuple{get<GenericType>(ty), getMutable<TypeFunctionGenericType>(tfti)}; g1 && g2)
             serializeChildren(g1, g2);
@@ -420,7 +411,7 @@ private:
         f2->retTypes = shallowSerialize(f1->retTypes);
     }
 
-    void serializeChildren(const ClassType* c1, TypeFunctionClassType* c2)
+    void serializeChildren(const ExternType* c1, TypeFunctionExternType* c2)
     {
         for (const auto& [k, p] : c1->props)
         {
@@ -711,19 +702,9 @@ private:
             TypePackId emptyTypePack = state->ctx->arena->addTypePack(TypePack{});
             target = state->ctx->arena->addType(FunctionType{emptyTypePack, emptyTypePack, {}, false});
         }
-        else if (auto c = get<TypeFunctionClassType>(ty))
+        else if (auto c = get<TypeFunctionExternType>(ty))
         {
-            if (FFlag::LuauTypeFunFixHydratedClasses)
-            {
-                target = c->classTy;
-            }
-            else
-            {
-                if (auto result = state->classesSerialized_DEPRECATED.find(c->name_DEPRECATED))
-                    target = *result;
-                else
-                    state->ctx->ice->ice("Deserializing user defined type function arguments: mysterious class type is being deserialized");
-            }
+            target = c->externTy;
         }
         else if (auto g = get<TypeFunctionGenericType>(ty))
         {
@@ -830,7 +811,7 @@ private:
             deserializeChildren(m2, m1);
         else if (auto [f1, f2] = std::tuple{getMutable<FunctionType>(ty), getMutable<TypeFunctionFunctionType>(tfti)}; f1 && f2)
             deserializeChildren(f2, f1);
-        else if (auto [c1, c2] = std::tuple{getMutable<ClassType>(ty), getMutable<TypeFunctionClassType>(tfti)}; c1 && c2)
+        else if (auto [c1, c2] = std::tuple{getMutable<ExternType>(ty), getMutable<TypeFunctionExternType>(tfti)}; c1 && c2)
             deserializeChildren(c2, c1);
         else if (auto [g1, g2] = std::tuple{getMutable<GenericType>(ty), getMutable<TypeFunctionGenericType>(tfti)}; g1 && g2)
             deserializeChildren(g2, g1);
@@ -991,7 +972,7 @@ private:
             f1->retTypes = shallowDeserialize(f2->retTypes);
     }
 
-    void deserializeChildren(TypeFunctionClassType* c2, ClassType* c1)
+    void deserializeChildren(TypeFunctionExternType* c2, ExternType* c1)
     {
         // noop.
     }