.github/workflows/build.yml

@@ -46,9 +46,9 @@ jobs:
     - name: make cli
       run: |
          make -j2 config=sanitize werror=1 luau luau-analyze luau-compile # match config with tests to improve build time
-         ./luau tests/conformance/assert.luau
-         ./luau-analyze tests/conformance/assert.luau
-         ./luau-compile tests/conformance/assert.luau
+         ./luau tests/conformance/assert.lua
+         ./luau-analyze tests/conformance/assert.lua
+         ./luau-compile tests/conformance/assert.lua
 
   windows:
     runs-on: windows-latest
@@ -81,12 +81,12 @@ jobs:
       shell: bash # necessary for fail-fast
       run: |
         cmake --build . --target Luau.Repl.CLI Luau.Analyze.CLI Luau.Compile.CLI --config Debug # match config with tests to improve build time
-        Debug/luau tests/conformance/assert.luau
-        Debug/luau-analyze tests/conformance/assert.luau
-        Debug/luau-compile tests/conformance/assert.luau
+        Debug/luau tests/conformance/assert.lua
+        Debug/luau-analyze tests/conformance/assert.lua
+        Debug/luau-compile tests/conformance/assert.lua
 
   coverage:
-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-20.04 # needed for clang++-10 to avoid gcov compatibility issues
     steps:
     - uses: actions/checkout@v2
     - name: install
@@ -94,7 +94,7 @@ jobs:
         sudo apt install llvm
     - name: make coverage
       run: |
-        CXX=clang++ make -j2 config=coverage native=1 coverage
+        CXX=clang++-10 make -j2 config=coverage native=1 coverage
     - name: upload coverage
       uses: codecov/codecov-action@v3
       with:

.github/workflows/new-release.yml

@@ -29,8 +29,8 @@ jobs:
   build:
     needs: ["create-release"]
     strategy:
-      matrix: # not using ubuntu-latest to improve compatibility
-        os: [{name: ubuntu, version: ubuntu-22.04}, {name: macos, version: macos-latest}, {name: windows, version: windows-latest}]
+      matrix: # using ubuntu-20.04 to build a Linux binary targeting older glibc to improve compatibility
+        os: [{name: ubuntu, version: ubuntu-20.04}, {name: macos, version: macos-latest}, {name: windows, version: windows-latest}]
     name: ${{matrix.os.name}}
     runs-on: ${{matrix.os.version}}
     steps:

.github/workflows/release.yml

@@ -13,8 +13,8 @@ on:
 jobs:
   build:
     strategy:
-      matrix: # not using ubuntu-latest to improve compatibility
-        os: [{name: ubuntu, version: ubuntu-22.04}, {name: macos, version: macos-latest}, {name: windows, version: windows-latest}]
+      matrix: # using ubuntu-20.04 to build a Linux binary targeting older glibc to improve compatibility
+        os: [{name: ubuntu, version: ubuntu-20.04}, {name: macos, version: macos-latest}, {name: windows, version: windows-latest}]
     name: ${{matrix.os.name}}
     runs-on: ${{matrix.os.version}}
     steps:

Analysis/include/Luau/AnyTypeSummary.h

@@ -0,0 +1,148 @@
+// 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/BuiltinDefinitions.h

@@ -70,7 +70,6 @@ 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

@@ -4,7 +4,6 @@
 #include <Luau/NotNull.h>
 #include "Luau/TypeArena.h"
 #include "Luau/Type.h"
-#include "Luau/Scope.h"
 
 #include <unordered_map>
 
@@ -27,22 +26,13 @@ struct CloneState
  * while `clone` will make a deep copy of the entire type and its every component.
  *
  * Be mindful about which behavior you actually _want_.
- *
- * Persistent types are not cloned as an optimization.
- * If a type is cloned in order to mutate it, 'ignorePersistent' has to be set
  */
 
-TypePackId shallowClone(TypePackId tp, TypeArena& dest, CloneState& cloneState, bool ignorePersistent = false);
-TypeId shallowClone(TypeId typeId, TypeArena& dest, CloneState& cloneState, bool ignorePersistent = false);
+TypePackId shallowClone(TypePackId tp, TypeArena& dest, CloneState& cloneState);
+TypeId shallowClone(TypeId typeId, TypeArena& dest, CloneState& cloneState);
 
 TypePackId clone(TypePackId tp, TypeArena& dest, CloneState& cloneState);
 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,7 +50,6 @@ struct GeneralizationConstraint
     TypeId sourceType;
 
     std::vector<TypeId> interiorTypes;
-    bool hasDeprecatedAttribute = false;
 };
 
 // variables ~ iterate iterator
@@ -110,21 +109,6 @@ struct FunctionCheckConstraint
     NotNull<DenseHashMap<const AstExpr*, TypeId>> astExpectedTypes;
 };
 
-// table_check expectedType exprType
-//
-// If `expectedType` is a table type and `exprType` is _also_ a table type,
-// propogate the member types of `expectedType` into the types of `exprType`.
-// This is used to implement bidirectional inference on table assignment.
-// Also see: FunctionCheckConstraint.
-struct TableCheckConstraint
-{
-    TypeId expectedType;
-    TypeId exprType;
-    AstExprTable* table = nullptr;
-    NotNull<DenseHashMap<const AstExpr*, TypeId>> astTypes;
-    NotNull<DenseHashMap<const AstExpr*, TypeId>> astExpectedTypes;
-};
-
 // prim FreeType ExpectedType PrimitiveType
 //
 // FreeType is bounded below by the singleton type and above by PrimitiveType
@@ -289,8 +273,7 @@ using ConstraintV = Variant<
     UnpackConstraint,
     ReduceConstraint,
     ReducePackConstraint,
-    EqualityConstraint,
-    TableCheckConstraint>;
+    EqualityConstraint>;
 
 struct Constraint
 {

Analysis/include/Luau/ConstraintGenerator.h

@@ -96,9 +96,6 @@ struct ConstraintGenerator
     // will enqueue them during solving.
     std::vector<ConstraintPtr> unqueuedConstraints;
 
-    // Map a function's signature scope back to its signature type.
-    DenseHashMap<Scope*, TypeId> scopeToFunction{nullptr};
-
     // The private scope of type aliases for which the type parameters belong to.
     DenseHashMap<const AstStatTypeAlias*, ScopePtr> astTypeAliasDefiningScopes{nullptr};
 
@@ -117,15 +114,12 @@ 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;
@@ -143,7 +137,6 @@ 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,
@@ -399,7 +392,7 @@ private:
      **/
     std::vector<std::pair<Name, GenericTypeDefinition>> createGenerics(
         const ScopePtr& scope,
-        AstArray<AstGenericType*> generics,
+        AstArray<AstGenericType> generics,
         bool useCache = false,
         bool addTypes = true
     );
@@ -416,7 +409,7 @@ private:
      **/
     std::vector<std::pair<Name, GenericTypePackDefinition>> createGenericPacks(
         const ScopePtr& scope,
-        AstArray<AstGenericTypePack*> packs,
+        AstArray<AstGenericTypePack> packs,
         bool useCache = false,
         bool addTypes = true
     );

Analysis/include/Luau/ConstraintSolver.h

@@ -88,7 +88,6 @@ struct ConstraintSolver
     NotNull<TypeFunctionRuntime> typeFunctionRuntime;
     // The entire set of constraints that the solver is trying to resolve.
     std::vector<NotNull<Constraint>> constraints;
-    NotNull<DenseHashMap<Scope*, TypeId>> scopeToFunction;
     NotNull<Scope> rootScope;
     ModuleName currentModuleName;
 
@@ -119,9 +118,6 @@ struct ConstraintSolver
     // A mapping from free types to the number of unresolved constraints that mention them.
     DenseHashMap<TypeId, size_t> unresolvedConstraints{{}};
 
-    std::unordered_map<NotNull<const Constraint>, DenseHashSet<TypeId>> maybeMutatedFreeTypes;
-    std::unordered_map<TypeId, DenseHashSet<const Constraint*>> mutatedFreeTypeToConstraint;
-
     // Irreducible/uninhabited type functions or type pack functions.
     DenseHashSet<const void*> uninhabitedTypeFunctions{{}};
 
@@ -146,7 +142,6 @@ struct ConstraintSolver
         NotNull<TypeFunctionRuntime> typeFunctionRuntime,
         NotNull<Scope> rootScope,
         std::vector<NotNull<Constraint>> constraints,
-        NotNull<DenseHashMap<Scope*, TypeId>> scopeToFunction,
         ModuleName moduleName,
         NotNull<ModuleResolver> moduleResolver,
         std::vector<RequireCycle> requireCycles,
@@ -174,8 +169,6 @@ struct ConstraintSolver
     bool isDone() const;
 
 private:
-    void generalizeOneType(TypeId ty);
-
     /**
      * Bind a type variable to another type.
      *
@@ -208,7 +201,6 @@ public:
     bool tryDispatch(const NameConstraint& c, NotNull<const Constraint> constraint);
     bool tryDispatch(const TypeAliasExpansionConstraint& c, NotNull<const Constraint> constraint);
     bool tryDispatch(const FunctionCallConstraint& c, NotNull<const Constraint> constraint);
-    bool tryDispatch(const TableCheckConstraint& c, NotNull<const Constraint> constraint);
     bool tryDispatch(const FunctionCheckConstraint& c, NotNull<const Constraint> constraint);
     bool tryDispatch(const PrimitiveTypeConstraint& c, NotNull<const Constraint> constraint);
     bool tryDispatch(const HasPropConstraint& c, NotNull<const Constraint> constraint);
@@ -365,7 +357,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);
+    std::optional<TypeId> generalizeFreeType(NotNull<Scope> scope, TypeId type, bool avoidSealingTables = false);
 
     /**
      * Checks the existing set of constraints to see if there exist any that contain
@@ -429,7 +421,10 @@ public:
 
     ToStringOptions opts;
 
-    void fillInDiscriminantTypes(NotNull<const Constraint> constraint, const std::vector<std::optional<TypeId>>& discriminantTypes);
+    void fillInDiscriminantTypes(
+        NotNull<const Constraint> constraint,
+        const std::vector<std::optional<TypeId>>& discriminantTypes
+    );
 };
 
 void dump(NotNull<Scope> rootScope, struct ToStringOptions& opts);

Analysis/include/Luau/DataFlowGraph.h

@@ -38,6 +38,8 @@ 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;
 
@@ -64,6 +66,10 @@ 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;
 };
@@ -215,8 +221,8 @@ private:
 
     void visitTypeList(AstTypeList l);
 
-    void visitGenerics(AstArray<AstGenericType*> g);
-    void visitGenericPacks(AstArray<AstGenericTypePack*> g);
+    void visitGenerics(AstArray<AstGenericType> g);
+    void visitGenericPacks(AstArray<AstGenericTypePack> g);
 };
 
 } // namespace Luau

Analysis/include/Luau/EqSatSimplificationImpl.h

@@ -105,7 +105,7 @@ private:
     std::vector<Id> storage;
 };
 
-template<typename L>
+template <typename L>
 using Node = EqSat::Node<L>;
 
 using EType = EqSat::Language<
@@ -149,7 +149,7 @@ using EType = EqSat::Language<
 struct StringCache
 {
     Allocator allocator;
-    DenseHashMap<std::string_view, StringId> strings{{}};
+    DenseHashMap<size_t, StringId> strings{{}};
     std::vector<std::string_view> views;
 
     StringId add(std::string_view s);

Analysis/include/Luau/FileResolver.h

@@ -1,9 +1,8 @@
 // This file is part of the Luau programming language and is licensed under MIT License; see LICENSE.txt for details
 #pragma once
 
-#include <memory>
-#include <optional>
 #include <string>
+#include <optional>
 #include <vector>
 
 namespace Luau
@@ -33,71 +32,15 @@ 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;
@@ -117,10 +60,10 @@ struct FileResolver
         return std::nullopt;
     }
 
-    // Make non-virtual when removing FFlagLuauImproveRequireByStringAutocomplete.
-    virtual std::optional<RequireSuggestions> getRequireSuggestions(const ModuleName& requirer, const std::optional<std::string>& pathString) const;
-
-    std::shared_ptr<RequireSuggester> requireSuggester;
+    virtual std::optional<RequireSuggestions> getRequireSuggestions(const ModuleName& requirer, const std::optional<std::string>& pathString) const
+    {
+        return std::nullopt;
+    }
 };
 
 struct NullFileResolver : FileResolver

Analysis/include/Luau/FragmentAutocomplete.h

@@ -15,28 +15,6 @@ 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,
@@ -49,8 +27,6 @@ struct FragmentAutocompleteAncestryResult
     std::vector<AstLocal*> localStack;
     std::vector<AstNode*> ancestry;
     AstStat* nearestStatement = nullptr;
-    AstStatBlock* parentBlock = nullptr;
-    Location fragmentSelectionRegion;
 };
 
 struct FragmentParseResult
@@ -61,7 +37,6 @@ struct FragmentParseResult
     AstStat* nearestStatement = nullptr;
     std::vector<Comment> commentLocations;
     std::unique_ptr<Allocator> alloc = std::make_unique<Allocator>();
-    Position scopePos{0, 0};
 };
 
 struct FragmentTypeCheckResult
@@ -79,29 +54,10 @@ struct FragmentAutocompleteResult
     AutocompleteResult acResults;
 };
 
-struct FragmentRegion
-{
-    Location fragmentLocation;
-    AstStat* nearestStatement = nullptr; // used for tests
-    AstStatBlock* parentBlock = nullptr; // used for scope detection
-};
-
-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
-);
+FragmentAutocompleteAncestryResult findAncestryForFragmentParse(AstStatBlock* root, const Position& cursorPos);
 
 std::optional<FragmentParseResult> parseFragment(
-    AstStatBlock* stale,
-    AstStatBlock* mostRecentParse,
-    AstNameTable* names,
+    const SourceModule& srcModule,
     std::string_view src,
     const Position& cursorPos,
     std::optional<Position> fragmentEndPosition
@@ -113,9 +69,7 @@ std::pair<FragmentTypeCheckStatus, FragmentTypeCheckResult> typecheckFragment(
     const Position& cursorPos,
     std::optional<FrontendOptions> opts,
     std::string_view src,
-    std::optional<Position> fragmentEndPosition,
-    AstStatBlock* recentParse = nullptr,
-    IFragmentAutocompleteReporter* reporter = nullptr
+    std::optional<Position> fragmentEndPosition
 );
 
 FragmentAutocompleteResult fragmentAutocomplete(
@@ -125,71 +79,8 @@ FragmentAutocompleteResult fragmentAutocomplete(
     Position cursorPosition,
     std::optional<FrontendOptions> opts,
     StringCompletionCallback callback,
-    std::optional<Position> fragmentEndPosition = std::nullopt,
-    AstStatBlock* recentParse = nullptr,
-    IFragmentAutocompleteReporter* reporter = nullptr
+    std::optional<Position> fragmentEndPosition = std::nullopt
 );
 
-enum class FragmentAutocompleteStatus
-{
-    Success,
-    FragmentTypeCheckFail,
-    InternalIce
-};
-
-struct FragmentAutocompleteStatusResult
-{
-    FragmentAutocompleteStatus status;
-    std::optional<FragmentAutocompleteResult> result;
-};
-
-struct FragmentContext
-{
-    std::string_view newSrc;
-    const ParseResult& freshParse;
-    std::optional<FrontendOptions> opts;
-    std::optional<Position> DEPRECATED_fragmentEndPosition;
-    IFragmentAutocompleteReporter* reporter = nullptr;
-};
-
-/**
- * @brief Attempts to compute autocomplete suggestions from the fragment context.
- *
- * This function computes autocomplete suggestions using outdated frontend typechecking data
- * by patching the fragment context of the new script source content.
- *
- * @param frontend The Luau Frontend data structure, which may contain outdated typechecking data.
- *
- * @param moduleName The name of the target module, specifying which script the caller wants to request autocomplete for.
- *
- * @param cursorPosition The position in the script where the caller wants to trigger autocomplete.
- *
- * @param context The fragment context that this API will use to patch the outdated typechecking data.
- *
- * @param stringCompletionCB A callback function that provides autocomplete suggestions for string contexts.
- *
- * @return
- * The status indicating whether `fragmentAutocomplete` ran successfully or failed, along with the reason for failure.
- * Also includes autocomplete suggestions if the status is successful.
- *
- * @usage
- * FragmentAutocompleteStatusResult acStatusResult;
- * if (shouldFragmentAC)
- *     acStatusResult = Luau::tryFragmentAutocomplete(...);
- *
- * if (acStatusResult.status != Successful)
- * {
- *     frontend.check(moduleName, options);
- *     acStatusResult.acResult = Luau::autocomplete(...);
- * }
- * return convertResultWithContext(acStatusResult.acResult);
- */
-FragmentAutocompleteStatusResult tryFragmentAutocomplete(
-    Frontend& frontend,
-    const ModuleName& moduleName,
-    Position cursorPosition,
-    FragmentContext context,
-    StringCompletionCallback stringCompletionCB
-);
 
 } // namespace Luau

Analysis/include/Luau/Frontend.h

@@ -7,9 +7,9 @@
 #include "Luau/ModuleResolver.h"
 #include "Luau/RequireTracer.h"
 #include "Luau/Scope.h"
-#include "Luau/Set.h"
 #include "Luau/TypeCheckLimits.h"
 #include "Luau/Variant.h"
+#include "Luau/AnyTypeSummary.h"
 
 #include <mutex>
 #include <string>
@@ -31,8 +31,8 @@ struct ModuleResolver;
 struct ParseResult;
 struct HotComment;
 struct BuildQueueItem;
-struct BuildQueueWorkState;
 struct FrontendCancellationToken;
+struct AnyTypeSummary;
 
 struct LoadDefinitionFileResult
 {
@@ -56,32 +56,13 @@ struct SourceNode
         return forAutocomplete ? dirtyModuleForAutocomplete : dirtyModule;
     }
 
-    bool hasInvalidModuleDependency(bool forAutocomplete) const
-    {
-        return forAutocomplete ? invalidModuleDependencyForAutocomplete : invalidModuleDependency;
-    }
-
-    void setInvalidModuleDependency(bool value, bool forAutocomplete)
-    {
-        if (forAutocomplete)
-            invalidModuleDependencyForAutocomplete = value;
-        else
-            invalidModuleDependency = value;
-    }
-
     ModuleName name;
     std::string humanReadableName;
     DenseHashSet<ModuleName> requireSet{{}};
     std::vector<std::pair<ModuleName, Location>> requireLocations;
-    Set<ModuleName> dependents{{}};
-
     bool dirtySourceModule = true;
     bool dirtyModule = true;
     bool dirtyModuleForAutocomplete = true;
-
-    bool invalidModuleDependency = true;
-    bool invalidModuleDependencyForAutocomplete = true;
-
     double autocompleteLimitsMult = 1.0;
 };
 
@@ -136,7 +117,7 @@ struct FrontendModuleResolver : ModuleResolver
     std::optional<ModuleInfo> resolveModuleInfo(const ModuleName& currentModuleName, const AstExpr& pathExpr) override;
     std::string getHumanReadableModuleName(const ModuleName& moduleName) const override;
 
-    bool setModule(const ModuleName& moduleName, ModulePtr module);
+    void setModule(const ModuleName& moduleName, ModulePtr module);
     void clearModules();
 
 private:
@@ -170,13 +151,9 @@ struct Frontend
     // Parse and typecheck module graph
     CheckResult check(const ModuleName& name, std::optional<FrontendOptions> optionOverride = {}); // new shininess
 
-    bool allModuleDependenciesValid(const ModuleName& name, bool forAutocomplete = false) const;
-
     bool isDirty(const ModuleName& name, bool forAutocomplete = false) const;
     void markDirty(const ModuleName& name, std::vector<ModuleName>* markedDirty = nullptr);
 
-    void traverseDependents(const ModuleName& name, std::function<bool(SourceNode&)> processSubtree);
-
     /** Borrow a pointer into the SourceModule cache.
      *
      * Returns nullptr if we don't have it.  This could mean that the script
@@ -215,11 +192,6 @@ struct Frontend
         std::function<void(std::function<void()> task)> executeTask = {},
         std::function<bool(size_t done, size_t total)> progress = {}
     );
-    std::vector<ModuleName> checkQueuedModules_DEPRECATED(
-        std::optional<FrontendOptions> optionOverride = {},
-        std::function<void(std::function<void()> task)> executeTask = {},
-        std::function<bool(size_t done, size_t total)> progress = {}
-    );
 
     std::optional<CheckResult> getCheckResult(const ModuleName& name, bool accumulateNested, bool forAutocomplete = false);
     std::vector<ModuleName> getRequiredScripts(const ModuleName& name);
@@ -255,9 +227,6 @@ 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);
 
@@ -303,7 +272,6 @@ 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
@@ -318,7 +286,6 @@ 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

@@ -12,8 +12,8 @@ std::optional<TypeId> generalize(
     NotNull<TypeArena> arena,
     NotNull<BuiltinTypes> builtinTypes,
     NotNull<Scope> scope,
-    NotNull<DenseHashSet<TypeId>> cachedTypes,
-    TypeId ty
+    NotNull<DenseHashSet<TypeId>> bakedTypes,
+    TypeId ty,
+    /* avoid sealing tables*/ bool avoidSealingTables = false
 );
-
 }

Analysis/include/Luau/GlobalTypes.h

@@ -19,9 +19,7 @@ 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/Module.h

@@ -8,6 +8,7 @@
 #include "Luau/ParseResult.h"
 #include "Luau/Scope.h"
 #include "Luau/TypeArena.h"
+#include "Luau/AnyTypeSummary.h"
 #include "Luau/DataFlowGraph.h"
 
 #include <memory>
@@ -20,13 +21,8 @@ LUAU_FASTFLAG(LuauIncrementalAutocompleteCommentDetection)
 namespace Luau
 {
 
-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>;
@@ -84,10 +80,13 @@ 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,10 +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 "Luau/DataFlowGraph.h"
-#include "Luau/EqSatSimplification.h"
 #include "Luau/Module.h"
 #include "Luau/NotNull.h"
+#include "Luau/DataFlowGraph.h"
 
 namespace Luau
 {

Analysis/include/Luau/Quantify.h

@@ -31,4 +31,13 @@ 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,7 +53,6 @@ struct Proposition
 {
     const RefinementKey* key;
     TypeId discriminantTy;
-    bool implicitFromCall;
 };
 
 template<typename T>
@@ -70,7 +69,6 @@ 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/RequireTracer.h

@@ -11,12 +11,14 @@
 namespace Luau
 {
 
-class AstNode;
+class AstStat;
+class AstExpr;
 class AstStatBlock;
+struct AstLocal;
 
 struct RequireTraceResult
 {
-    DenseHashMap<const AstNode*, ModuleInfo> exprs{nullptr};
+    DenseHashMap<const AstExpr*, ModuleInfo> exprs{nullptr};
 
     std::vector<std::pair<ModuleName, Location>> requireList;
 };

Analysis/include/Luau/Scope.h

@@ -35,7 +35,7 @@ struct Scope
     explicit Scope(TypePackId returnType);                    // root scope
     explicit Scope(const ScopePtr& parent, int subLevel = 0); // child scope.  Parent must not be nullptr.
 
-    ScopePtr parent; // null for the root
+    const ScopePtr parent; // null for the root
 
     // All the children of this scope.
     std::vector<NotNull<Scope>> children;
@@ -59,8 +59,6 @@ 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);
@@ -73,7 +71,6 @@ 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;
 

Analysis/include/Luau/Simplify.h

@@ -19,10 +19,10 @@ struct SimplifyResult
     DenseHashSet<TypeId> blockedTypes;
 };
 
-SimplifyResult simplifyIntersection(NotNull<BuiltinTypes> builtinTypes, NotNull<TypeArena> arena, TypeId left, TypeId right);
+SimplifyResult simplifyIntersection(NotNull<BuiltinTypes> builtinTypes, NotNull<TypeArena> arena, TypeId ty, TypeId discriminant);
 SimplifyResult simplifyIntersection(NotNull<BuiltinTypes> builtinTypes, NotNull<TypeArena> arena, std::set<TypeId> parts);
 
-SimplifyResult simplifyUnion(NotNull<BuiltinTypes> builtinTypes, NotNull<TypeArena> arena, TypeId left, TypeId right);
+SimplifyResult simplifyUnion(NotNull<BuiltinTypes> builtinTypes, NotNull<TypeArena> arena, TypeId ty, TypeId discriminant);
 
 enum class Relation
 {

Analysis/include/Luau/TableLiteralInference.h

@@ -6,15 +6,12 @@
 #include "Luau/NotNull.h"
 #include "Luau/TypeFwd.h"
 
-#include <vector>
-
 namespace Luau
 {
 
 struct TypeArena;
 struct BuiltinTypes;
 struct Unifier2;
-struct Subtyping;
 class AstExpr;
 
 TypeId matchLiteralType(
@@ -23,7 +20,6 @@ TypeId matchLiteralType(
     NotNull<BuiltinTypes> builtinTypes,
     NotNull<TypeArena> arena,
     NotNull<Unifier2> unifier,
-    NotNull<Subtyping> subtyping,
     TypeId expectedType,
     TypeId exprType,
     const AstExpr* expr,

Analysis/include/Luau/TxnLog.h

@@ -65,10 +65,11 @@ T* getMutable(PendingTypePack* pending)
 // Log of what TypeIds we are rebinding, to be committed later.
 struct TxnLog
 {
-    explicit TxnLog()
+    explicit TxnLog(bool useScopes = false)
         : typeVarChanges(nullptr)
         , typePackChanges(nullptr)
         , ownedSeen()
+        , useScopes(useScopes)
         , sharedSeen(&ownedSeen)
     {
     }

Analysis/include/Luau/Type.h

@@ -19,6 +19,7 @@
 #include <optional>
 #include <set>
 #include <string>
+#include <unordered_map>
 #include <vector>
 
 LUAU_FASTINT(LuauTableTypeMaximumStringifierLength)
@@ -37,15 +38,6 @@ struct Constraint;
 struct Subtyping;
 struct TypeChecker2;
 
-enum struct Polarity : uint8_t
-{
-    None = 0b000,
-    Positive = 0b001,
-    Negative = 0b010,
-    Mixed = 0b011,
-    Unknown = 0b100,
-};
-
 /**
  * There are three kinds of type variables:
  * - `Free` variables are metavariables, which stand for unconstrained types.
@@ -77,16 +69,12 @@ using Name = std::string;
 // A free type is one whose exact shape has yet to be fully determined.
 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, TypeLevel level, TypeId lowerBound, TypeId upperBound);
-    // Old constructors
     explicit FreeType(TypeLevel level);
     explicit FreeType(Scope* scope);
     FreeType(Scope* scope, TypeLevel level);
 
+    FreeType(Scope* scope, TypeId lowerBound, TypeId upperBound);
+
     int index;
     TypeLevel level;
     Scope* scope = nullptr;
@@ -318,8 +306,7 @@ struct MagicFunctionTypeCheckContext
 
 struct MagicFunction
 {
-    virtual std::optional<WithPredicate<TypePackId>>
-    handleOldSolver(struct TypeChecker&, const std::shared_ptr<struct Scope>&, const class AstExprCall&, WithPredicate<TypePackId>) = 0;
+    virtual std::optional<WithPredicate<TypePackId>> handleOldSolver(struct TypeChecker&, const std::shared_ptr<struct Scope>&, const class AstExprCall&, WithPredicate<TypePackId>) = 0;
 
     // Callback to allow custom typechecking of builtin function calls whose argument types
     // will only be resolved after constraint solving. For example, the arguments to string.format
@@ -404,7 +391,6 @@ 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
@@ -631,6 +617,7 @@ struct UserDefinedFunctionData
     AstStatTypeFunction* definition = nullptr;
 
     DenseHashMap<Name, std::pair<AstStatTypeFunction*, size_t>> environment{""};
+    DenseHashMap<Name, AstStatTypeFunction*> environment_DEPRECATED{""};
 };
 
 /**

Analysis/include/Luau/TypeArena.h

@@ -32,13 +32,9 @@ struct TypeArena
 
     TypeId addTV(Type&& tv);
 
-    TypeId freshType(NotNull<BuiltinTypes> builtins, TypeLevel level);
-    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);
+    TypeId freshType(TypeLevel level);
+    TypeId freshType(Scope* scope);
+    TypeId freshType(Scope* scope, TypeLevel level);
 
     TypePackId freshTypePack(Scope* scope);
 

Analysis/include/Luau/TypeChecker2.h

@@ -13,8 +13,6 @@
 #include "Luau/TypeOrPack.h"
 #include "Luau/TypeUtils.h"
 
-LUAU_FASTFLAG(LuauImproveTypePathsInErrors)
-
 namespace Luau
 {
 
@@ -40,29 +38,18 @@ 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 = FFlag::LuauImproveTypePathsInErrors ? "\nthis is because " : "";
+        std::string allReasons;
         bool first = true;
         for (const std::string& reason : reasons)
         {
-            if (FFlag::LuauImproveTypePathsInErrors)
-            {
-                if (reasons.size() > 1)
-                    allReasons += "\n\t * ";
-            }
+            if (first)
+                first = false;
             else
-            {
-                if (first)
-                    first = false;
-                else
-                    allReasons += "\n\t";
-            }
+                allReasons += "\n\t";
 
             allReasons += reason;
         }
@@ -76,7 +63,7 @@ void check(
     NotNull<BuiltinTypes> builtinTypes,
     NotNull<Simplifier> simplifier,
     NotNull<TypeFunctionRuntime> typeFunctionRuntime,
-    NotNull<UnifierSharedState> unifierState,
+    NotNull<UnifierSharedState> sharedState,
     NotNull<TypeCheckLimits> limits,
     DcrLogger* logger,
     const SourceModule& sourceModule,
@@ -129,14 +116,14 @@ private:
     std::optional<StackPusher> pushStack(AstNode* node);
     void checkForInternalTypeFunction(TypeId ty, Location location);
     TypeId checkForTypeFunctionInhabitance(TypeId instance, Location location);
-    TypePackId lookupPack(AstExpr* expr) const;
+    TypePackId lookupPack(AstExpr* expr);
     TypeId lookupType(AstExpr* expr);
     TypeId lookupAnnotation(AstType* annotation);
-    std::optional<TypePackId> lookupPackAnnotation(AstTypePack* annotation) const;
-    TypeId lookupExpectedType(AstExpr* expr) const;
-    TypePackId lookupExpectedPack(AstExpr* expr, TypeArena& arena) const;
+    std::optional<TypePackId> lookupPackAnnotation(AstTypePack* annotation);
+    TypeId lookupExpectedType(AstExpr* expr);
+    TypePackId lookupExpectedPack(AstExpr* expr, TypeArena& arena);
     TypePackId reconstructPack(AstArray<AstExpr*> exprs, TypeArena& arena);
-    Scope* findInnermostScope(Location location) const;
+    Scope* findInnermostScope(Location location);
     void visit(AstStat* stat);
     void visit(AstStatIf* ifStatement);
     void visit(AstStatWhile* whileStatement);
@@ -173,7 +160,7 @@ private:
     void visit(AstExprVarargs* expr);
     void visitCall(AstExprCall* call);
     void visit(AstExprCall* call);
-    std::optional<TypeId> tryStripUnionFromNil(TypeId ty) const;
+    std::optional<TypeId> tryStripUnionFromNil(TypeId ty);
     TypeId stripFromNilAndReport(TypeId ty, const Location& location);
     void visitExprName(AstExpr* expr, Location location, const std::string& propName, ValueContext context, TypeId astIndexExprTy);
     void visit(AstExprIndexName* indexName, ValueContext context);
@@ -188,7 +175,7 @@ private:
     void visit(AstExprInterpString* interpString);
     void visit(AstExprError* expr);
     TypeId flattenPack(TypePackId pack);
-    void visitGenerics(AstArray<AstGenericType*> generics, AstArray<AstGenericTypePack*> genericPacks);
+    void visitGenerics(AstArray<AstGenericType> generics, AstArray<AstGenericTypePack> genericPacks);
     void visit(AstType* ty);
     void visit(AstTypeReference* ty);
     void visit(AstTypeTable* table);

Analysis/include/Luau/TypeFunction.h

@@ -48,9 +48,6 @@ 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;
 
@@ -177,7 +174,6 @@ struct FunctionGraphReductionResult
     DenseHashSet<TypePackId> blockedPacks{nullptr};
     DenseHashSet<TypeId> reducedTypes{nullptr};
     DenseHashSet<TypePackId> reducedPacks{nullptr};
-    DenseHashSet<TypeId> irreducibleTypes{nullptr};
 };
 
 /**
@@ -245,9 +241,6 @@ struct BuiltinTypeFunctions
     TypeFunction indexFunc;
     TypeFunction rawgetFunc;
 
-    TypeFunction setmetatableFunc;
-    TypeFunction getmetatableFunc;
-
     void addToScope(NotNull<TypeArena> arena, NotNull<Scope> scope) const;
 };
 

Analysis/include/Luau/TypeFunctionRuntime.h

@@ -3,7 +3,6 @@
 
 #include "Luau/Common.h"
 #include "Luau/Variant.h"
-#include "Luau/TypeFwd.h"
 
 #include <optional>
 #include <string>
@@ -216,13 +215,9 @@ struct TypeFunctionClassType
 
     std::optional<TypeFunctionTypeId> metatable; // metaclass?
 
-    // this was mistaken, and we should actually be keeping separate read/write types here.
-    std::optional<TypeFunctionTypeId> parent_DEPRECATED;
+    std::optional<TypeFunctionTypeId> parent;
 
-    std::optional<TypeFunctionTypeId> readParent;
-    std::optional<TypeFunctionTypeId> writeParent;
-
-    TypeId classTy;
+    std::string name;
 };
 
 struct TypeFunctionGenericType

Analysis/include/Luau/TypeFunctionRuntimeBuilder.h

@@ -28,12 +28,20 @@ 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{{}};
+
     // List of errors that occur during serialization/deserialization
-    // At every iteration of serialization/deserialization, if this list.size() != 0, we halt the process
+    // At every iteration of serialization/deserialzation, if this list.size() != 0, we halt the process
     std::vector<std::string> errors{};
 
     TypeFunctionRuntimeBuilderState(NotNull<TypeFunctionContext> ctx)
         : ctx(ctx)
+        , classesSerialized({})
+        , errors({})
     {
     }
 };

Analysis/include/Luau/TypeInfer.h

@@ -399,8 +399,8 @@ private:
         const ScopePtr& scope,
         std::optional<TypeLevel> levelOpt,
         const AstNode& node,
-        const AstArray<AstGenericType*>& genericNames,
-        const AstArray<AstGenericTypePack*>& genericPackNames,
+        const AstArray<AstGenericType>& genericNames,
+        const AstArray<AstGenericTypePack>& genericPackNames,
         bool useCache = false
     );
 

Analysis/include/Luau/TypePath.h

@@ -42,19 +42,9 @@ 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;
 };
 
@@ -215,9 +205,6 @@ 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

@@ -40,7 +40,7 @@ struct InConditionalContext
     TypeContext* typeContext;
     TypeContext oldValue;
 
-    explicit InConditionalContext(TypeContext* c)
+    InConditionalContext(TypeContext* c)
         : typeContext(c)
         , oldValue(*c)
     {

Analysis/include/Luau/Unifier.h

@@ -93,6 +93,10 @@ struct Unifier
 
     Unifier(NotNull<Normalizer> normalizer, NotNull<Scope> scope, const Location& location, Variance variance, TxnLog* parentLog = nullptr);
 
+    // Configure the Unifier to test for scope subsumption via embedded Scope
+    // pointers rather than TypeLevels.
+    void enableNewSolver();
+
     // Test whether the two type vars unify.  Never commits the result.
     ErrorVec canUnify(TypeId subTy, TypeId superTy);
     ErrorVec canUnify(TypePackId subTy, TypePackId superTy, bool isFunctionCall = false);
@@ -165,6 +169,7 @@ private:
 
     std::optional<TypeId> findTablePropertyRespectingMeta(TypeId lhsType, Name name);
 
+    TxnLog combineLogsIntoIntersection(std::vector<TxnLog> logs);
     TxnLog combineLogsIntoUnion(std::vector<TxnLog> logs);
 
 public:
@@ -190,6 +195,11 @@ private:
 
     // Available after regular type pack unification errors
     std::optional<int> firstPackErrorPos;
+
+    // If true, we do a bunch of small things differently to work better with
+    // the new type inference engine. Most notably, we use the Scope hierarchy
+    // directly rather than using TypeLevels.
+    bool useNewSolver = false;
 };
 
 void promoteTypeLevels(TxnLog& log, const TypeArena* arena, TypeLevel minLevel, Scope* outerScope, bool useScope, TypePackId tp);

Analysis/include/Luau/Unifier2.h

@@ -87,9 +87,6 @@ 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);
 

Analysis/include/Luau/UnifierSharedState.h

@@ -49,26 +49,6 @@ struct UnifierSharedState
     DenseHashSet<TypePackId> tempSeenTp{nullptr};
 
     UnifierCounters counters;
-
-    bool reentrantTypeReduction = false;
-};
-
-struct TypeReductionRentrancyGuard final
-{
-    explicit TypeReductionRentrancyGuard(NotNull<UnifierSharedState> sharedState)
-        : sharedState{sharedState}
-    {
-        sharedState->reentrantTypeReduction = true;
-    }
-    ~TypeReductionRentrancyGuard()
-    {
-        sharedState->reentrantTypeReduction = false;
-    }
-    TypeReductionRentrancyGuard(const TypeReductionRentrancyGuard&) = delete;
-    TypeReductionRentrancyGuard(TypeReductionRentrancyGuard&&) = delete;
-
-private:
-    NotNull<UnifierSharedState> sharedState;
 };
 
 } // namespace Luau

Analysis/src/AnyTypeSummary.cpp

@@ -0,0 +1,902 @@
+// 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/AstJsonEncoder.cpp

@@ -1065,11 +1065,6 @@ struct AstJsonEncoder : public AstVisitor
         );
     }
 
-    void write(class AstTypeOptional* node)
-    {
-        writeNode(node, "AstTypeOptional", [&]() {});
-    }
-
     void write(class AstTypeUnion* node)
     {
         writeNode(
@@ -1151,8 +1146,6 @@ struct AstJsonEncoder : public AstVisitor
             return writeString("checked");
         case AstAttr::Type::Native:
             return writeString("native");
-        case AstAttr::Type::Deprecated:
-            return writeString("deprecated");
         }
     }
 
@@ -1168,19 +1161,6 @@ struct AstJsonEncoder : public AstVisitor
         );
     }
 
-    bool visit(class AstTypeGroup* node) override
-    {
-        writeNode(
-            node,
-            "AstTypeGroup",
-            [&]()
-            {
-                write("inner", node->type);
-            }
-        );
-        return false;
-    }
-
     bool visit(class AstTypeSingletonBool* node) override
     {
         writeNode(

Analysis/src/Autocomplete.cpp

@@ -2,7 +2,6 @@
 #include "Luau/Autocomplete.h"
 
 #include "Luau/AstQuery.h"
-#include "Luau/TimeTrace.h"
 #include "Luau/TypeArena.h"
 #include "Luau/Module.h"
 #include "Luau/Frontend.h"
@@ -16,9 +15,6 @@ namespace Luau
 
 AutocompleteResult autocomplete(Frontend& frontend, const ModuleName& moduleName, Position position, StringCompletionCallback callback)
 {
-    LUAU_TIMETRACE_SCOPE("Luau::autocomplete", "Autocomplete");
-    LUAU_TIMETRACE_ARGUMENT("name", moduleName.c_str());
-
     const SourceModule* sourceModule = frontend.getSourceModule(moduleName);
     if (!sourceModule)
         return {};

Analysis/src/AutocompleteCore.cpp

@@ -10,7 +10,6 @@
 #include "Luau/Common.h"
 #include "Luau/FileResolver.h"
 #include "Luau/Frontend.h"
-#include "Luau/TimeTrace.h"
 #include "Luau/ToString.h"
 #include "Luau/Subtyping.h"
 #include "Luau/TypeInfer.h"
@@ -21,16 +20,12 @@
 #include <utility>
 
 LUAU_FASTFLAG(LuauSolverV2)
+LUAU_FASTFLAGVARIABLE(AutocompleteRequirePathSuggestions2)
 LUAU_FASTINT(LuauTypeInferIterationLimit)
 LUAU_FASTINT(LuauTypeInferRecursionLimit)
-LUAU_FASTFLAGVARIABLE(DebugLuauMagicVariableNames)
-
-LUAU_FASTFLAG(LuauExposeRequireByStringAutocomplete)
 
 LUAU_FASTFLAGVARIABLE(LuauAutocompleteRefactorsForIncrementalAutocomplete)
-
-LUAU_FASTFLAGVARIABLE(LuauAutocompleteUsesModuleForTypeCompatibility)
-LUAU_FASTFLAGVARIABLE(LuauAutocompleteUnionCopyPreviousSeen)
+LUAU_FASTFLAGVARIABLE(LuauAutocompleteUseLimits)
 
 static const std::unordered_set<std::string> kStatementStartingKeywords =
     {"while", "if", "local", "repeat", "function", "do", "for", "return", "break", "continue", "type", "export"};
@@ -152,91 +147,44 @@ static std::optional<TypeId> findExpectedTypeAt(const Module& module, AstNode* n
     return *it;
 }
 
-static bool checkTypeMatch(
-    const Module& module,
-    TypeId subTy,
-    TypeId superTy,
-    NotNull<Scope> scope,
-    TypeArena* typeArena,
-    NotNull<BuiltinTypes> builtinTypes
-)
+static bool checkTypeMatch(TypeId subTy, TypeId superTy, NotNull<Scope> scope, TypeArena* typeArena, NotNull<BuiltinTypes> builtinTypes)
 {
     InternalErrorReporter iceReporter;
     UnifierSharedState unifierState(&iceReporter);
     SimplifierPtr simplifier = newSimplifier(NotNull{typeArena}, builtinTypes);
     Normalizer normalizer{typeArena, builtinTypes, NotNull{&unifierState}};
-    if (FFlag::LuauAutocompleteUsesModuleForTypeCompatibility)
+
+    if (FFlag::LuauSolverV2)
     {
-        if (module.checkedInNewSolver)
-        {
-            TypeCheckLimits limits;
-            TypeFunctionRuntime typeFunctionRuntime{
-                NotNull{&iceReporter}, NotNull{&limits}
-            }; // TODO: maybe subtyping checks should not invoke user-defined type function runtime
+        TypeCheckLimits limits;
+        TypeFunctionRuntime typeFunctionRuntime{
+            NotNull{&iceReporter}, NotNull{&limits}
+        }; // TODO: maybe subtyping checks should not invoke user-defined type function runtime
 
-            unifierState.counters.recursionLimit = FInt::LuauTypeInferRecursionLimit;
-            unifierState.counters.iterationLimit = FInt::LuauTypeInferIterationLimit;
+        unifierState.counters.recursionLimit = FInt::LuauTypeInferRecursionLimit;
+        unifierState.counters.iterationLimit = FInt::LuauTypeInferIterationLimit;
 
-            Subtyping subtyping{
-                builtinTypes,
-                NotNull{typeArena},
-                NotNull{simplifier.get()},
-                NotNull{&normalizer},
-                NotNull{&typeFunctionRuntime},
-                NotNull{&iceReporter}
-            };
+        Subtyping subtyping{
+            builtinTypes, NotNull{typeArena}, NotNull{simplifier.get()}, NotNull{&normalizer}, NotNull{&typeFunctionRuntime}, NotNull{&iceReporter}
+        };
 
-            return subtyping.isSubtype(subTy, superTy, scope).isSubtype;
-        }
-        else
-        {
-            Unifier unifier(NotNull<Normalizer>{&normalizer}, scope, Location(), Variance::Covariant);
-
-            // Cost of normalization can be too high for autocomplete response time requirements
-            unifier.normalize = false;
-            unifier.checkInhabited = false;
-
-            unifierState.counters.recursionLimit = FInt::LuauTypeInferRecursionLimit;
-            unifierState.counters.iterationLimit = FInt::LuauTypeInferIterationLimit;
-
-            return unifier.canUnify(subTy, superTy).empty();
-        }
+        return subtyping.isSubtype(subTy, superTy, scope).isSubtype;
     }
     else
     {
-        if (FFlag::LuauSolverV2)
-        {
-            TypeCheckLimits limits;
-            TypeFunctionRuntime typeFunctionRuntime{
-                NotNull{&iceReporter}, NotNull{&limits}
-            }; // TODO: maybe subtyping checks should not invoke user-defined type function runtime
+        Unifier unifier(NotNull<Normalizer>{&normalizer}, scope, Location(), Variance::Covariant);
 
+        // Cost of normalization can be too high for autocomplete response time requirements
+        unifier.normalize = false;
+        unifier.checkInhabited = false;
+
+        if (FFlag::LuauAutocompleteUseLimits)
+        {
             unifierState.counters.recursionLimit = FInt::LuauTypeInferRecursionLimit;
             unifierState.counters.iterationLimit = FInt::LuauTypeInferIterationLimit;
-
-            Subtyping subtyping{
-                builtinTypes,
-                NotNull{typeArena},
-                NotNull{simplifier.get()},
-                NotNull{&normalizer},
-                NotNull{&typeFunctionRuntime},
-                NotNull{&iceReporter}
-            };
-
-            return subtyping.isSubtype(subTy, superTy, scope).isSubtype;
         }
-        else
-        {
-            Unifier unifier(NotNull<Normalizer>{&normalizer}, scope, Location(), Variance::Covariant);
 
-            // Cost of normalization can be too high for autocomplete response time requirements
-            unifier.normalize = false;
-            unifier.checkInhabited = false;
-            unifierState.counters.recursionLimit = FInt::LuauTypeInferRecursionLimit;
-            unifierState.counters.iterationLimit = FInt::LuauTypeInferIterationLimit;
-
-            return unifier.canUnify(subTy, superTy).empty();
-        }
+        return unifier.canUnify(subTy, superTy).empty();
     }
 }
 
@@ -262,10 +210,10 @@ static TypeCorrectKind checkTypeCorrectKind(
 
     TypeId expectedType = follow(*typeAtPosition);
 
-    auto checkFunctionType = [typeArena, builtinTypes, moduleScope, &expectedType, &module](const FunctionType* ftv)
+    auto checkFunctionType = [typeArena, builtinTypes, moduleScope, &expectedType](const FunctionType* ftv)
     {
         if (std::optional<TypeId> firstRetTy = first(ftv->retTypes))
-            return checkTypeMatch(module, *firstRetTy, expectedType, moduleScope, typeArena, builtinTypes);
+            return checkTypeMatch(*firstRetTy, expectedType, moduleScope, typeArena, builtinTypes);
 
         return false;
     };
@@ -288,7 +236,7 @@ static TypeCorrectKind checkTypeCorrectKind(
         }
     }
 
-    return checkTypeMatch(module, ty, expectedType, moduleScope, typeArena, builtinTypes) ? TypeCorrectKind::Correct : TypeCorrectKind::None;
+    return checkTypeMatch(ty, expectedType, moduleScope, typeArena, builtinTypes) ? TypeCorrectKind::Correct : TypeCorrectKind::None;
 }
 
 enum class PropIndexType
@@ -339,7 +287,7 @@ static void autocompleteProps(
             // When called with '.', but declared with 'self', it is considered invalid if first argument is compatible
             if (std::optional<TypeId> firstArgTy = first(ftv->argTypes))
             {
-                if (checkTypeMatch(module, rootTy, *firstArgTy, NotNull{module.getModuleScope().get()}, typeArena, builtinTypes))
+                if (checkTypeMatch(rootTy, *firstArgTy, NotNull{module.getModuleScope().get()}, typeArena, builtinTypes))
                     return calledWithSelf;
             }
 
@@ -485,21 +433,6 @@ 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 | Class
-            //
-            // 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;
@@ -1362,15 +1295,6 @@ 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()))
@@ -1537,14 +1461,10 @@ static std::optional<AutocompleteEntryMap> convertRequireSuggestionsToAutocomple
         return std::nullopt;
 
     AutocompleteEntryMap result;
-    for (RequireSuggestion& suggestion : *suggestions)
+    for (const RequireSuggestion& suggestion : *suggestions)
     {
         AutocompleteEntry entry = {AutocompleteEntryKind::RequirePath};
         entry.insertText = std::move(suggestion.fullPath);
-        if (FFlag::LuauExposeRequireByStringAutocomplete)
-        {
-            entry.tags = std::move(suggestion.tags);
-        }
         result[std::move(suggestion.label)] = std::move(entry);
     }
     return result;
@@ -1601,9 +1521,12 @@ static std::optional<AutocompleteEntryMap> autocompleteStringParams(
     {
         for (const std::string& tag : funcType->tags)
         {
-            if (tag == kRequireTagName && fileResolver)
+            if (FFlag::AutocompleteRequirePathSuggestions2)
             {
-                return convertRequireSuggestionsToAutocompleteEntryMap(fileResolver->getRequireSuggestions(module->name, candidateString));
+                if (tag == kRequireTagName && fileResolver)
+                {
+                    return convertRequireSuggestionsToAutocompleteEntryMap(fileResolver->getRequireSuggestions(module->name, candidateString));
+                }
             }
             if (std::optional<AutocompleteEntryMap> ret = callback(tag, getMethodContainingClass(module, candidate->func), candidateString))
             {
@@ -1795,7 +1718,6 @@ AutocompleteResult autocomplete_(
     StringCompletionCallback callback
 )
 {
-    LUAU_TIMETRACE_SCOPE("Luau::autocomplete_", "AutocompleteCore");
     AstNode* node = ancestry.back();
 
     AstExprConstantNil dummy{Location{}};

Analysis/src/BuiltinDefinitions.cpp

@@ -29,90 +29,81 @@
  */
 
 LUAU_FASTFLAG(LuauSolverV2)
+LUAU_FASTFLAGVARIABLE(LuauTypestateBuiltins2)
+LUAU_FASTFLAGVARIABLE(LuauStringFormatArityFix)
 LUAU_FASTFLAGVARIABLE(LuauStringFormatErrorSuppression)
-LUAU_FASTFLAGVARIABLE(LuauTableCloneClonesType3)
+LUAU_FASTFLAG(AutocompleteRequirePathSuggestions2)
+LUAU_FASTFLAG(LuauVectorDefinitionsExtra)
+LUAU_FASTFLAGVARIABLE(LuauTableCloneClonesType)
 LUAU_FASTFLAG(LuauTrackInteriorFreeTypesOnScope)
-LUAU_FASTFLAGVARIABLE(LuauFollowTableFreeze)
-LUAU_FASTFLAGVARIABLE(LuauUserTypeFunTypecheck)
 
 namespace Luau
 {
 
 struct MagicSelect final : MagicFunction
 {
-    std::optional<WithPredicate<TypePackId>>
-    handleOldSolver(struct TypeChecker&, const std::shared_ptr<struct Scope>&, const class AstExprCall&, WithPredicate<TypePackId>) override;
+    std::optional<WithPredicate<TypePackId>> handleOldSolver(struct TypeChecker&, const std::shared_ptr<struct Scope>&, const class AstExprCall&, WithPredicate<TypePackId>) override;
     bool infer(const MagicFunctionCallContext& ctx) override;
 };
 
 struct MagicSetMetatable final : MagicFunction
 {
-    std::optional<WithPredicate<TypePackId>>
-    handleOldSolver(struct TypeChecker&, const std::shared_ptr<struct Scope>&, const class AstExprCall&, WithPredicate<TypePackId>) override;
+    std::optional<WithPredicate<TypePackId>> handleOldSolver(struct TypeChecker&, const std::shared_ptr<struct Scope>&, const class AstExprCall&, WithPredicate<TypePackId>) override;
     bool infer(const MagicFunctionCallContext& ctx) override;
 };
 
 struct MagicAssert final : MagicFunction
 {
-    std::optional<WithPredicate<TypePackId>>
-    handleOldSolver(struct TypeChecker&, const std::shared_ptr<struct Scope>&, const class AstExprCall&, WithPredicate<TypePackId>) override;
+    std::optional<WithPredicate<TypePackId>> handleOldSolver(struct TypeChecker&, const std::shared_ptr<struct Scope>&, const class AstExprCall&, WithPredicate<TypePackId>) override;
     bool infer(const MagicFunctionCallContext& ctx) override;
 };
 
 struct MagicPack final : MagicFunction
 {
-    std::optional<WithPredicate<TypePackId>>
-    handleOldSolver(struct TypeChecker&, const std::shared_ptr<struct Scope>&, const class AstExprCall&, WithPredicate<TypePackId>) override;
+    std::optional<WithPredicate<TypePackId>> handleOldSolver(struct TypeChecker&, const std::shared_ptr<struct Scope>&, const class AstExprCall&, WithPredicate<TypePackId>) override;
     bool infer(const MagicFunctionCallContext& ctx) override;
 };
 
 struct MagicRequire final : MagicFunction
 {
-    std::optional<WithPredicate<TypePackId>>
-    handleOldSolver(struct TypeChecker&, const std::shared_ptr<struct Scope>&, const class AstExprCall&, WithPredicate<TypePackId>) override;
+    std::optional<WithPredicate<TypePackId>> handleOldSolver(struct TypeChecker&, const std::shared_ptr<struct Scope>&, const class AstExprCall&, WithPredicate<TypePackId>) override;
     bool infer(const MagicFunctionCallContext& ctx) override;
 };
 
 struct MagicClone final : MagicFunction
 {
-    std::optional<WithPredicate<TypePackId>>
-    handleOldSolver(struct TypeChecker&, const std::shared_ptr<struct Scope>&, const class AstExprCall&, WithPredicate<TypePackId>) override;
+    std::optional<WithPredicate<TypePackId>> handleOldSolver(struct TypeChecker&, const std::shared_ptr<struct Scope>&, const class AstExprCall&, WithPredicate<TypePackId>) override;
     bool infer(const MagicFunctionCallContext& ctx) override;
 };
 
 struct MagicFreeze final : MagicFunction
 {
-    std::optional<WithPredicate<TypePackId>>
-    handleOldSolver(struct TypeChecker&, const std::shared_ptr<struct Scope>&, const class AstExprCall&, WithPredicate<TypePackId>) override;
+    std::optional<WithPredicate<TypePackId>> handleOldSolver(struct TypeChecker&, const std::shared_ptr<struct Scope>&, const class AstExprCall&, WithPredicate<TypePackId>) override;
     bool infer(const MagicFunctionCallContext& ctx) override;
 };
 
 struct MagicFormat final : MagicFunction
 {
-    std::optional<WithPredicate<TypePackId>>
-    handleOldSolver(struct TypeChecker&, const std::shared_ptr<struct Scope>&, const class AstExprCall&, WithPredicate<TypePackId>) override;
+    std::optional<WithPredicate<TypePackId>> handleOldSolver(struct TypeChecker&, const std::shared_ptr<struct Scope>&, const class AstExprCall&, WithPredicate<TypePackId>) override;
     bool infer(const MagicFunctionCallContext& ctx) override;
     bool typeCheck(const MagicFunctionTypeCheckContext& ctx) override;
 };
 
 struct MagicMatch final : MagicFunction
 {
-    std::optional<WithPredicate<TypePackId>>
-    handleOldSolver(struct TypeChecker&, const std::shared_ptr<struct Scope>&, const class AstExprCall&, WithPredicate<TypePackId>) override;
+    std::optional<WithPredicate<TypePackId>> handleOldSolver(struct TypeChecker&, const std::shared_ptr<struct Scope>&, const class AstExprCall&, WithPredicate<TypePackId>) override;
     bool infer(const MagicFunctionCallContext& ctx) override;
 };
 
 struct MagicGmatch final : MagicFunction
 {
-    std::optional<WithPredicate<TypePackId>>
-    handleOldSolver(struct TypeChecker&, const std::shared_ptr<struct Scope>&, const class AstExprCall&, WithPredicate<TypePackId>) override;
+    std::optional<WithPredicate<TypePackId>> handleOldSolver(struct TypeChecker&, const std::shared_ptr<struct Scope>&, const class AstExprCall&, WithPredicate<TypePackId>) override;
     bool infer(const MagicFunctionCallContext& ctx) override;
 };
 
 struct MagicFind final : MagicFunction
 {
-    std::optional<WithPredicate<TypePackId>>
-    handleOldSolver(struct TypeChecker&, const std::shared_ptr<struct Scope>&, const class AstExprCall&, WithPredicate<TypePackId>) override;
+    std::optional<WithPredicate<TypePackId>> handleOldSolver(struct TypeChecker&, const std::shared_ptr<struct Scope>&, const class AstExprCall&, WithPredicate<TypePackId>) override;
     bool infer(const MagicFunctionCallContext& ctx) override;
 };
 
@@ -288,22 +279,6 @@ 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());
@@ -335,25 +310,28 @@ void registerBuiltinGlobals(Frontend& frontend, GlobalTypes& globals, bool typeC
     addGlobalBinding(globals, "string", it->second.type(), "@luau");
 
     // Setup 'vector' metatable
-    if (auto it = globals.globalScope->exportedTypeBindings.find("vector"); it != globals.globalScope->exportedTypeBindings.end())
+    if (FFlag::LuauVectorDefinitionsExtra)
     {
-        TypeId vectorTy = it->second.type;
-        ClassType* vectorCls = getMutable<ClassType>(vectorTy);
+        if (auto it = globals.globalScope->exportedTypeBindings.find("vector"); it != globals.globalScope->exportedTypeBindings.end())
+        {
+            TypeId vectorTy = it->second.type;
+            ClassType* vectorCls = getMutable<ClassType>(vectorTy);
 
-        vectorCls->metatable = arena.addType(TableType{{}, std::nullopt, TypeLevel{}, TableState::Sealed});
-        TableType* metatableTy = Luau::getMutable<TableType>(vectorCls->metatable);
+            vectorCls->metatable = arena.addType(TableType{{}, std::nullopt, TypeLevel{}, TableState::Sealed});
+            TableType* metatableTy = Luau::getMutable<TableType>(vectorCls->metatable);
 
-        metatableTy->props["__add"] = {makeFunction(arena, vectorTy, {vectorTy}, {vectorTy})};
-        metatableTy->props["__sub"] = {makeFunction(arena, vectorTy, {vectorTy}, {vectorTy})};
-        metatableTy->props["__unm"] = {makeFunction(arena, vectorTy, {}, {vectorTy})};
+            metatableTy->props["__add"] = {makeFunction(arena, vectorTy, {vectorTy}, {vectorTy})};
+            metatableTy->props["__sub"] = {makeFunction(arena, vectorTy, {vectorTy}, {vectorTy})};
+            metatableTy->props["__unm"] = {makeFunction(arena, vectorTy, {}, {vectorTy})};
 
-        std::initializer_list<TypeId> mulOverloads{
-            makeFunction(arena, vectorTy, {vectorTy}, {vectorTy}),
-            makeFunction(arena, vectorTy, {builtinTypes->numberType}, {vectorTy}),
-        };
-        metatableTy->props["__mul"] = {makeIntersection(arena, mulOverloads)};
-        metatableTy->props["__div"] = {makeIntersection(arena, mulOverloads)};
-        metatableTy->props["__idiv"] = {makeIntersection(arena, mulOverloads)};
+            std::initializer_list<TypeId> mulOverloads{
+                makeFunction(arena, vectorTy, {vectorTy}, {vectorTy}),
+                makeFunction(arena, vectorTy, {builtinTypes->numberType}, {vectorTy}),
+            };
+            metatableTy->props["__mul"] = {makeIntersection(arena, mulOverloads)};
+            metatableTy->props["__div"] = {makeIntersection(arena, mulOverloads)};
+            metatableTy->props["__idiv"] = {makeIntersection(arena, mulOverloads)};
+        }
     }
 
     // next<K, V>(t: Table<K, V>, i: K?) -> (K?, V)
@@ -415,21 +393,14 @@ void registerBuiltinGlobals(Frontend& frontend, GlobalTypes& globals, bool typeC
         // clang-format on
     }
 
-    if (FFlag::LuauUserTypeFunTypecheck)
+    for (const auto& pair : globals.globalScope->bindings)
     {
-        finalizeGlobalBindings(globals.globalScope);
-    }
-    else
-    {
-        for (const auto& pair : globals.globalScope->bindings)
-        {
-            persist(pair.second.typeId);
+        persist(pair.second.typeId);
 
-            if (TableType* ttv = getMutable<TableType>(pair.second.typeId))
-            {
-                if (!ttv->name)
-                    ttv->name = "typeof(" + toString(pair.first) + ")";
-            }
+        if (TableType* ttv = getMutable<TableType>(pair.second.typeId))
+        {
+            if (!ttv->name)
+                ttv->name = "typeof(" + toString(pair.first) + ")";
         }
     }
 
@@ -482,66 +453,21 @@ void registerBuiltinGlobals(Frontend& frontend, GlobalTypes& globals, bool typeC
         ttv->props["foreachi"].deprecated = true;
 
         attachMagicFunction(ttv->props["pack"].type(), std::make_shared<MagicPack>());
-        if (FFlag::LuauTableCloneClonesType3)
+        if (FFlag::LuauTableCloneClonesType)
             attachMagicFunction(ttv->props["clone"].type(), std::make_shared<MagicClone>());
-        attachMagicFunction(ttv->props["freeze"].type(), std::make_shared<MagicFreeze>());
+        if (FFlag::LuauTypestateBuiltins2)
+            attachMagicFunction(ttv->props["freeze"].type(), std::make_shared<MagicFreeze>());
     }
 
-    TypeId requireTy = getGlobalBinding(globals, "require");
-    attachTag(requireTy, kRequireTagName);
-    attachMagicFunction(requireTy, std::make_shared<MagicRequire>());
-
-    if (FFlag::LuauUserTypeFunTypecheck)
+    if (FFlag::AutocompleteRequirePathSuggestions2)
     {
-        // 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);
+        TypeId requireTy = getGlobalBinding(globals, "require");
+        attachTag(requireTy, kRequireTagName);
+        attachMagicFunction(requireTy, std::make_shared<MagicRequire>());
+    }
+    else
+    {
+        attachMagicFunction(getGlobalBinding(globals, "require"), std::make_shared<MagicRequire>());
     }
 }
 
@@ -691,7 +617,10 @@ bool MagicFormat::typeCheck(const MagicFunctionTypeCheckContext& context)
 
     if (!fmt)
     {
-        context.typechecker->reportError(CountMismatch{1, std::nullopt, 0, CountMismatch::Arg, true, "string.format"}, context.callSite->location);
+        if (FFlag::LuauStringFormatArityFix)
+            context.typechecker->reportError(
+                CountMismatch{1, std::nullopt, 0, CountMismatch::Arg, true, "string.format"}, context.callSite->location
+            );
         return true;
     }
 
@@ -716,15 +645,15 @@ bool MagicFormat::typeCheck(const MagicFunctionTypeCheckContext& context)
             {
                 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);
+                    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);
+                        if (!reasonings.suppressed)
+                            context.typechecker->reportError(TypeMismatch{expectedTy, actualTy, reasonings.toString()}, location);
                 }
             }
             else
@@ -1476,7 +1405,7 @@ std::optional<WithPredicate<TypePackId>> MagicClone::handleOldSolver(
     WithPredicate<TypePackId> withPredicate
 )
 {
-    LUAU_ASSERT(FFlag::LuauTableCloneClonesType3);
+    LUAU_ASSERT(FFlag::LuauTableCloneClonesType);
 
     auto [paramPack, _predicates] = withPredicate;
 
@@ -1491,9 +1420,6 @@ std::optional<WithPredicate<TypePackId>> MagicClone::handleOldSolver(
 
     TypeId inputType = follow(paramTypes[0]);
 
-    if (!get<TableType>(inputType))
-        return std::nullopt;
-
     CloneState cloneState{typechecker.builtinTypes};
     TypeId resultType = shallowClone(inputType, arena, cloneState);
 
@@ -1503,7 +1429,7 @@ std::optional<WithPredicate<TypePackId>> MagicClone::handleOldSolver(
 
 bool MagicClone::infer(const MagicFunctionCallContext& context)
 {
-    LUAU_ASSERT(FFlag::LuauTableCloneClonesType3);
+    LUAU_ASSERT(FFlag::LuauTableCloneClonesType);
 
     TypeArena* arena = context.solver->arena;
 
@@ -1516,11 +1442,8 @@ bool MagicClone::infer(const MagicFunctionCallContext& context)
 
     TypeId inputType = follow(paramTypes[0]);
 
-    if (!get<TableType>(inputType))
-        return false;
-
     CloneState cloneState{context.solver->builtinTypes};
-    TypeId resultType = shallowClone(inputType, *arena, cloneState, /* ignorePersistent */ true);
+    TypeId resultType = shallowClone(inputType, *arena, cloneState);
 
     if (auto tableType = getMutable<TableType>(resultType))
     {
@@ -1539,8 +1462,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);
+
     if (auto mt = get<MetatableType>(inputType))
     {
         std::optional<TypeId> frozenTable = freezeTable(mt->table, context);
@@ -1557,7 +1479,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 */ true);
+        TypeId resultType = shallowClone(inputType, *arena, cloneState);
         auto tableTy = getMutable<TableType>(resultType);
         // `clone` should not break this.
         LUAU_ASSERT(tableTy);
@@ -1582,14 +1504,15 @@ static std::optional<TypeId> freezeTable(TypeId inputType, const MagicFunctionCa
     return std::nullopt;
 }
 
-std::optional<WithPredicate<TypePackId>> MagicFreeze::
-    handleOldSolver(struct TypeChecker&, const std::shared_ptr<struct Scope>&, const class AstExprCall&, WithPredicate<TypePackId>)
+std::optional<WithPredicate<TypePackId>> MagicFreeze::handleOldSolver(struct TypeChecker &, const std::shared_ptr<struct Scope> &, const class AstExprCall &, WithPredicate<TypePackId>)
 {
     return std::nullopt;
 }
 
 bool MagicFreeze::infer(const MagicFunctionCallContext& context)
 {
+    LUAU_ASSERT(FFlag::LuauTypestateBuiltins2);
+
     TypeArena* arena = context.solver->arena;
     const DataFlowGraph* dfg = context.solver->dfg.get();
     Scope* scope = context.constraint->scope.get();

Analysis/src/Clone.cpp

@@ -1,20 +1,16 @@
 // 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)
 
 // 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
 {
 
@@ -31,8 +27,6 @@ const T* get(const Kind& kind)
 
 class TypeCloner
 {
-
-protected:
     NotNull<TypeArena> arena;
     NotNull<BuiltinTypes> builtinTypes;
 
@@ -44,31 +38,17 @@ protected:
     NotNull<SeenTypes> types;
     NotNull<SeenTypePacks> packs;
 
-    TypeId forceTy = nullptr;
-    TypePackId forceTp = nullptr;
-
     int steps = 0;
 
 public:
-    TypeCloner(
-        NotNull<TypeArena> arena,
-        NotNull<BuiltinTypes> builtinTypes,
-        NotNull<SeenTypes> types,
-        NotNull<SeenTypePacks> packs,
-        TypeId forceTy,
-        TypePackId forceTp
-    )
+    TypeCloner(NotNull<TypeArena> arena, NotNull<BuiltinTypes> builtinTypes, NotNull<SeenTypes> types, NotNull<SeenTypePacks> packs)
         : arena(arena)
         , builtinTypes(builtinTypes)
         , types(types)
         , packs(packs)
-        , forceTy(forceTy)
-        , forceTp(forceTp)
     {
     }
 
-    virtual ~TypeCloner() = default;
-
     TypeId clone(TypeId ty)
     {
         shallowClone(ty);
@@ -127,13 +107,12 @@ 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 && ty != forceTy)
+        else if (ty->persistent)
             return ty;
         return std::nullopt;
     }
@@ -143,7 +122,7 @@ protected:
         tp = follow(tp);
         if (auto it = packs->find(tp); it != packs->end())
             return it->second;
-        else if (tp->persistent && tp != forceTp)
+        else if (tp->persistent)
             return tp;
         return std::nullopt;
     }
@@ -162,14 +141,14 @@ protected:
     }
 
 public:
-    virtual TypeId shallowClone(TypeId ty)
+    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 && ty != forceTy)
+        else if (ty->persistent)
             return ty;
 
         TypeId target = arena->addType(ty->ty);
@@ -189,13 +168,13 @@ public:
         return target;
     }
 
-    virtual TypePackId shallowClone(TypePackId tp)
+    TypePackId shallowClone(TypePackId tp)
     {
         tp = follow(tp);
 
         if (auto clone = find(tp))
             return *clone;
-        else if (tp->persistent && tp != forceTp)
+        else if (tp->persistent)
             return tp;
 
         TypePackId target = arena->addTypePack(tp->ty);
@@ -397,7 +376,7 @@ private:
             ty = shallowClone(ty);
     }
 
-    virtual void cloneChildren(LazyType* t)
+    void cloneChildren(LazyType* t)
     {
         if (auto unwrapped = t->unwrapped.load())
             t->unwrapped.store(shallowClone(unwrapped));
@@ -477,127 +456,23 @@ 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;
-        }
-        else if (auto fn = getMutable<FunctionType>(target))
-        {
-            if (FFlag::LuauClonedTableAndFunctionTypesMustHaveScopes)
-                fn->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)
+TypePackId shallowClone(TypePackId tp, TypeArena& dest, CloneState& cloneState)
 {
-    if (tp->persistent && !ignorePersistent)
+    if (tp->persistent)
         return tp;
 
-    TypeCloner cloner{
-        NotNull{&dest},
-        cloneState.builtinTypes,
-        NotNull{&cloneState.seenTypes},
-        NotNull{&cloneState.seenTypePacks},
-        nullptr,
-        ignorePersistent ? tp : nullptr
-    };
-
+    TypeCloner cloner{NotNull{&dest}, cloneState.builtinTypes, NotNull{&cloneState.seenTypes}, NotNull{&cloneState.seenTypePacks}};
     return cloner.shallowClone(tp);
 }
 
-TypeId shallowClone(TypeId typeId, TypeArena& dest, CloneState& cloneState, bool ignorePersistent)
+TypeId shallowClone(TypeId typeId, TypeArena& dest, CloneState& cloneState)
 {
-    if (typeId->persistent && !ignorePersistent)
+    if (typeId->persistent)
         return typeId;
 
-    TypeCloner cloner{
-        NotNull{&dest},
-        cloneState.builtinTypes,
-        NotNull{&cloneState.seenTypes},
-        NotNull{&cloneState.seenTypePacks},
-        ignorePersistent ? typeId : nullptr,
-        nullptr
-    };
-
+    TypeCloner cloner{NotNull{&dest}, cloneState.builtinTypes, NotNull{&cloneState.seenTypes}, NotNull{&cloneState.seenTypePacks}};
     return cloner.shallowClone(typeId);
 }
 
@@ -606,7 +481,7 @@ TypePackId clone(TypePackId tp, TypeArena& dest, CloneState& cloneState)
     if (tp->persistent)
         return tp;
 
-    TypeCloner cloner{NotNull{&dest}, cloneState.builtinTypes, NotNull{&cloneState.seenTypes}, NotNull{&cloneState.seenTypePacks}, nullptr, nullptr};
+    TypeCloner cloner{NotNull{&dest}, cloneState.builtinTypes, NotNull{&cloneState.seenTypes}, NotNull{&cloneState.seenTypePacks}};
     return cloner.clone(tp);
 }
 
@@ -615,13 +490,13 @@ TypeId clone(TypeId typeId, TypeArena& dest, CloneState& cloneState)
     if (typeId->persistent)
         return typeId;
 
-    TypeCloner cloner{NotNull{&dest}, cloneState.builtinTypes, NotNull{&cloneState.seenTypes}, NotNull{&cloneState.seenTypePacks}, nullptr, nullptr};
+    TypeCloner cloner{NotNull{&dest}, cloneState.builtinTypes, NotNull{&cloneState.seenTypes}, NotNull{&cloneState.seenTypePacks}};
     return cloner.clone(typeId);
 }
 
 TypeFun clone(const TypeFun& typeFun, TypeArena& dest, CloneState& cloneState)
 {
-    TypeCloner cloner{NotNull{&dest}, cloneState.builtinTypes, NotNull{&cloneState.seenTypes}, NotNull{&cloneState.seenTypePacks}, nullptr, nullptr};
+    TypeCloner cloner{NotNull{&dest}, cloneState.builtinTypes, NotNull{&cloneState.seenTypes}, NotNull{&cloneState.seenTypePacks}};
 
     TypeFun copy = typeFun;
 
@@ -646,110 +521,4 @@ TypeFun clone(const TypeFun& typeFun, TypeArena& dest, CloneState& cloneState)
     return copy;
 }
 
-Binding clone(const Binding& binding, TypeArena& dest, CloneState& cloneState)
-{
-    TypeCloner cloner{NotNull{&dest}, cloneState.builtinTypes, NotNull{&cloneState.seenTypes}, NotNull{&cloneState.seenTypePacks}, nullptr, nullptr};
-
-    Binding b;
-    b.deprecated = binding.deprecated;
-    b.deprecatedSuggestion = binding.deprecatedSuggestion;
-    b.documentationSymbol = binding.documentationSymbol;
-    b.location = binding.location;
-    b.typeId = cloner.clone(binding.typeId);
-
-    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

@@ -3,8 +3,6 @@
 #include "Luau/Constraint.h"
 #include "Luau/VisitType.h"
 
-LUAU_FASTFLAG(DebugLuauGreedyGeneralization)
-
 namespace Luau
 {
 
@@ -113,11 +111,6 @@ DenseHashSet<TypeId> Constraint::getMaybeMutatedFreeTypes() const
     {
         rci.traverse(fchc->argsPack);
     }
-    else if (auto fcc = get<FunctionCallConstraint>(*this); fcc && FFlag::DebugLuauGreedyGeneralization)
-    {
-        rci.traverse(fcc->fn);
-        rci.traverse(fcc->argsPack);
-    }
     else if (auto ptc = get<PrimitiveTypeConstraint>(*this))
     {
         rci.traverse(ptc->freeType);
@@ -125,8 +118,7 @@ DenseHashSet<TypeId> Constraint::getMaybeMutatedFreeTypes() const
     else if (auto hpc = get<HasPropConstraint>(*this))
     {
         rci.traverse(hpc->resultType);
-        if (FFlag::DebugLuauGreedyGeneralization)
-            rci.traverse(hpc->subjectType);
+        // `HasPropConstraints` should not mutate `subjectType`.
     }
     else if (auto hic = get<HasIndexerConstraint>(*this))
     {
@@ -154,10 +146,6 @@ DenseHashSet<TypeId> Constraint::getMaybeMutatedFreeTypes() const
     {
         rci.traverse(rpc->tp);
     }
-    else if (auto tcc = get<TableCheckConstraint>(*this))
-    {
-        rci.traverse(tcc->exprType);
-    }
 
     return types;
 }

Analysis/src/ConstraintSolver.cpp

@@ -27,20 +27,17 @@
 #include <algorithm>
 #include <utility>
 
-LUAU_FASTFLAGVARIABLE(DebugLuauAssertOnForcedConstraint)
 LUAU_FASTFLAGVARIABLE(DebugLuauLogSolver)
 LUAU_FASTFLAGVARIABLE(DebugLuauLogSolverIncludeDependencies)
 LUAU_FASTFLAGVARIABLE(DebugLuauLogBindings)
 LUAU_FASTINTVARIABLE(LuauSolverRecursionLimit, 500)
+LUAU_FASTFLAGVARIABLE(LuauRemoveNotAnyHack)
 LUAU_FASTFLAGVARIABLE(DebugLuauEqSatSimplification)
+LUAU_FASTFLAG(LuauNewSolverPopulateTableLocations)
+LUAU_FASTFLAGVARIABLE(LuauAllowNilAssignmentToIndexer)
+LUAU_FASTFLAG(LuauUserTypeFunNoExtraConstraint)
 LUAU_FASTFLAG(LuauTrackInteriorFreeTypesOnScope)
-LUAU_FASTFLAGVARIABLE(LuauTrackInteriorFreeTablesOnScope)
-LUAU_FASTFLAGVARIABLE(LuauPrecalculateMutatedFreeTypes2)
-LUAU_FASTFLAGVARIABLE(DebugLuauGreedyGeneralization)
-LUAU_FASTFLAG(LuauSearchForRefineableType)
-LUAU_FASTFLAG(LuauDeprecatedAttribute)
-LUAU_FASTFLAG(LuauBidirectionalInferenceCollectIndexerTypes)
-LUAU_FASTFLAG(LuauNewTypeFunReductionChecks2)
+LUAU_FASTFLAGVARIABLE(LuauAlwaysFillInFunctionCallDiscriminantTypes)
 
 namespace Luau
 {
@@ -331,7 +328,6 @@ ConstraintSolver::ConstraintSolver(
     NotNull<TypeFunctionRuntime> typeFunctionRuntime,
     NotNull<Scope> rootScope,
     std::vector<NotNull<Constraint>> constraints,
-    NotNull<DenseHashMap<Scope*, TypeId>> scopeToFunction,
     ModuleName moduleName,
     NotNull<ModuleResolver> moduleResolver,
     std::vector<RequireCycle> requireCycles,
@@ -345,7 +341,6 @@ ConstraintSolver::ConstraintSolver(
     , simplifier(simplifier)
     , typeFunctionRuntime(typeFunctionRuntime)
     , constraints(std::move(constraints))
-    , scopeToFunction(scopeToFunction)
     , rootScope(rootScope)
     , currentModuleName(std::move(moduleName))
     , dfg(dfg)
@@ -360,33 +355,13 @@ ConstraintSolver::ConstraintSolver(
     {
         unsolvedConstraints.emplace_back(c);
 
-        if (FFlag::LuauPrecalculateMutatedFreeTypes2)
+        // initialize the reference counts for the free types in this constraint.
+        for (auto ty : c->getMaybeMutatedFreeTypes())
         {
-            auto maybeMutatedTypesPerConstraint = c->getMaybeMutatedFreeTypes();
-            for (auto ty : maybeMutatedTypesPerConstraint)
-            {
-                auto [refCount, _] = unresolvedConstraints.try_insert(ty, 0);
-                refCount += 1;
-
-                if (FFlag::DebugLuauGreedyGeneralization)
-                {
-                    auto [it, fresh] = mutatedFreeTypeToConstraint.try_emplace(ty, DenseHashSet<const Constraint*>{nullptr});
-                    it->second.insert(c.get());
-                }
-            }
-            maybeMutatedFreeTypes.emplace(c, maybeMutatedTypesPerConstraint);
+            // increment the reference count for `ty`
+            auto [refCount, _] = unresolvedConstraints.try_insert(ty, 0);
+            refCount += 1;
         }
-        else
-        {
-            // initialize the reference counts for the free types in this constraint.
-            for (auto ty : c->getMaybeMutatedFreeTypes())
-            {
-                // increment the reference count for `ty`
-                auto [refCount, _] = unresolvedConstraints.try_insert(ty, 0);
-                refCount += 1;
-            }
-        }
-
 
         for (NotNull<const Constraint> dep : c->dependencies)
         {
@@ -464,9 +439,6 @@ void ConstraintSolver::run()
                 snapshot = logger->prepareStepSnapshot(rootScope, c, force, unsolvedConstraints);
             }
 
-            if (FFlag::DebugLuauAssertOnForcedConstraint)
-                LUAU_ASSERT(!force);
-
             bool success = tryDispatch(c, force);
 
             progress |= success;
@@ -476,60 +448,20 @@ void ConstraintSolver::run()
                 unblock(c);
                 unsolvedConstraints.erase(unsolvedConstraints.begin() + ptrdiff_t(i));
 
-                if (FFlag::LuauPrecalculateMutatedFreeTypes2)
+                // decrement the referenced free types for this constraint if we dispatched successfully!
+                for (auto ty : c->getMaybeMutatedFreeTypes())
                 {
-                    const auto maybeMutated = maybeMutatedFreeTypes.find(c);
-                    if (maybeMutated != maybeMutatedFreeTypes.end())
-                    {
-                        DenseHashSet<TypeId> seen{nullptr};
-                        for (auto ty : maybeMutated->second)
-                        {
-                            // There is a high chance that this type has been rebound
-                            // across blocked types, rebound free types, pending
-                            // expansion types, etc, so we need to follow it.
-                            ty = follow(ty);
+                    size_t& refCount = unresolvedConstraints[ty];
+                    if (refCount > 0)
+                        refCount -= 1;
 
-                            if (FFlag::DebugLuauGreedyGeneralization)
-                            {
-                                if (seen.contains(ty))
-                                    continue;
-                                seen.insert(ty);
-                            }
-
-                            size_t& refCount = unresolvedConstraints[ty];
-                            if (refCount > 0)
-                                refCount -= 1;
-
-                            // We have two constraints that are designed to wait for the
-                            // refCount on a free type to be equal to 1: the
-                            // PrimitiveTypeConstraint and ReduceConstraint. We
-                            // therefore wake any constraint waiting for a free type's
-                            // refcount to be 1 or 0.
-                            if (refCount <= 1)
-                                unblock(ty, Location{});
-
-                            if (FFlag::DebugLuauGreedyGeneralization && refCount == 0)
-                                generalizeOneType(ty);
-                        }
-                    }
-                }
-                else
-                {
-                    // decrement the referenced free types for this constraint if we dispatched successfully!
-                    for (auto ty : c->getMaybeMutatedFreeTypes())
-                    {
-                        size_t& refCount = unresolvedConstraints[ty];
-                        if (refCount > 0)
-                            refCount -= 1;
-
-                        // We have two constraints that are designed to wait for the
-                        // refCount on a free type to be equal to 1: the
-                        // PrimitiveTypeConstraint and ReduceConstraint. We
-                        // therefore wake any constraint waiting for a free type's
-                        // refcount to be 1 or 0.
-                        if (refCount <= 1)
-                            unblock(ty, Location{});
-                    }
+                    // We have two constraints that are designed to wait for the
+                    // refCount on a free type to be equal to 1: the
+                    // PrimitiveTypeConstraint and ReduceConstraint. We
+                    // therefore wake any constraint waiting for a free type's
+                    // refcount to be 1 or 0.
+                    if (refCount <= 1)
+                        unblock(ty, Location{});
                 }
 
                 if (logger)
@@ -626,152 +558,16 @@ bool ConstraintSolver::isDone() const
     return unsolvedConstraints.empty();
 }
 
-struct TypeSearcher : TypeVisitor
+namespace
 {
-    TypeId needle;
-    Polarity current = Polarity::Positive;
 
-    size_t count = 0;
-    Polarity result = Polarity::None;
-
-    explicit TypeSearcher(TypeId needle)
-        : TypeSearcher(needle, Polarity::Positive)
-    {}
-
-    explicit TypeSearcher(TypeId needle, Polarity initialPolarity)
-        : needle(needle)
-        , current(initialPolarity)
-    {}
-
-    bool visit(TypeId ty) override
-    {
-        if (ty == needle)
-        {
-            ++count;
-            result = Polarity(size_t(result) | size_t(current));
-        }
-
-        return true;
-    }
-
-    void flip()
-    {
-        switch (current)
-        {
-            case Polarity::Positive:
-                current = Polarity::Negative;
-                break;
-            case Polarity::Negative:
-                current = Polarity::Positive;
-                break;
-            default:
-                break;
-        }
-    }
-
-    bool visit(TypeId ty, const FunctionType& ft) override
-    {
-        flip();
-        traverse(ft.argTypes);
-
-        flip();
-        traverse(ft.retTypes);
-
-        return false;
-    }
-
-    // bool visit(TypeId ty, const TableType& tt) override
-    // {
-
-    // }
-
-    bool visit(TypeId ty, const ClassType&) override
-    {
-        return false;
-    }
+struct TypeAndLocation
+{
+    TypeId typeId;
+    Location location;
 };
 
-void ConstraintSolver::generalizeOneType(TypeId ty)
-{
-    ty = follow(ty);
-    const FreeType* freeTy = get<FreeType>(ty);
-
-    std::string saveme = toString(ty, opts);
-
-    // Some constraints (like prim) will also replace a free type with something
-    // concrete. If so, our work is already done.
-    if (!freeTy)
-        return;
-
-    NotNull<Scope> tyScope{freeTy->scope};
-
-    // TODO: If freeTy occurs within the enclosing function's type, we need to
-    // check to see whether this type should instead be generic.
-
-    TypeId newBound = follow(freeTy->upperBound);
-
-    TypeId* functionTyPtr = nullptr;
-    while (true)
-    {
-        functionTyPtr = scopeToFunction->find(tyScope);
-        if (functionTyPtr || !tyScope->parent)
-            break;
-        else if (tyScope->parent)
-            tyScope = NotNull{tyScope->parent.get()};
-        else
-            break;
-    }
-
-    if (ty == newBound)
-        ty = builtinTypes->unknownType;
-
-    if (!functionTyPtr)
-    {
-        asMutable(ty)->reassign(Type{BoundType{follow(freeTy->upperBound)}});
-    }
-    else
-    {
-        const TypeId functionTy = follow(*functionTyPtr);
-        FunctionType* const function = getMutable<FunctionType>(functionTy);
-        LUAU_ASSERT(function);
-
-        TypeSearcher ts{ty};
-        ts.traverse(functionTy);
-
-        const TypeId upperBound = follow(freeTy->upperBound);
-        const TypeId lowerBound = follow(freeTy->lowerBound);
-
-        switch (ts.result)
-        {
-            case Polarity::None:
-                asMutable(ty)->reassign(Type{BoundType{upperBound}});
-                break;
-
-            case Polarity::Negative:
-            case Polarity::Mixed:
-                if (get<UnknownType>(upperBound) && ts.count > 1)
-                {
-                    asMutable(ty)->reassign(Type{GenericType{tyScope}});
-                    function->generics.emplace_back(ty);
-                }
-                else
-                    asMutable(ty)->reassign(Type{BoundType{upperBound}});
-                break;
-
-            case Polarity::Positive:
-                if (get<UnknownType>(lowerBound) && ts.count > 1)
-                {
-                    asMutable(ty)->reassign(Type{GenericType{tyScope}});
-                    function->generics.emplace_back(ty);
-                }
-                else
-                    asMutable(ty)->reassign(Type{BoundType{lowerBound}});
-                break;
-            default:
-                LUAU_ASSERT(!"Unreachable");
-        }
-    }
-}
+} // namespace
 
 void ConstraintSolver::bind(NotNull<const Constraint> constraint, TypeId ty, TypeId boundTo)
 {
@@ -846,8 +642,6 @@ bool ConstraintSolver::tryDispatch(NotNull<const Constraint> constraint, bool fo
         success = tryDispatch(*fcc, constraint);
     else if (auto fcc = get<FunctionCheckConstraint>(*constraint))
         success = tryDispatch(*fcc, constraint);
-    else if (auto tcc = get<TableCheckConstraint>(*constraint))
-        success = tryDispatch(*tcc, constraint);
     else if (auto fcc = get<PrimitiveTypeConstraint>(*constraint))
         success = tryDispatch(*fcc, constraint);
     else if (auto hpc = get<HasPropConstraint>(*constraint))
@@ -905,25 +699,26 @@ bool ConstraintSolver::tryDispatch(const GeneralizationConstraint& c, NotNull<co
     else if (get<PendingExpansionType>(generalizedType))
         return block(generalizedType, constraint);
 
+    std::optional<QuantifierResult> generalized;
+
     std::optional<TypeId> generalizedTy = generalize(NotNull{arena}, builtinTypes, constraint->scope, generalizedTypes, c.sourceType);
-    if (!generalizedTy)
+    if (generalizedTy)
+        generalized = QuantifierResult{*generalizedTy}; // FIXME insertedGenerics and insertedGenericPacks
+    else
         reportError(CodeTooComplex{}, constraint->location);
 
-    if (generalizedTy)
+    if (generalized)
     {
         if (get<BlockedType>(generalizedType))
-            bind(constraint, generalizedType, *generalizedTy);
+            bind(constraint, generalizedType, generalized->result);
         else
-            unify(constraint, generalizedType, *generalizedTy);
+            unify(constraint, generalizedType, generalized->result);
 
-        if (FFlag::LuauDeprecatedAttribute)
-        {
-            if (FunctionType* fty = getMutable<FunctionType>(follow(generalizedType)))
-            {
-                if (c.hasDeprecatedAttribute)
-                    fty->isDeprecatedFunction = true;
-            }
-        }
+        for (auto [free, gen] : generalized->insertedGenerics.pairings)
+            unify(constraint, free, gen);
+
+        for (auto [free, gen] : generalized->insertedGenericPacks.pairings)
+            unify(constraint, free, gen);
     }
     else
     {
@@ -937,12 +732,12 @@ bool ConstraintSolver::tryDispatch(const GeneralizationConstraint& c, NotNull<co
         // clang-tidy doesn't understand this is safe.
         if (constraint->scope->interiorFreeTypes)
             for (TypeId ty : *constraint->scope->interiorFreeTypes) // NOLINT(bugprone-unchecked-optional-access)
-                generalize(NotNull{arena}, builtinTypes, constraint->scope, generalizedTypes, ty);
+                generalize(NotNull{arena}, builtinTypes, constraint->scope, generalizedTypes, ty, /* avoidSealingTables */ false);
     }
     else
     {
         for (TypeId ty : c.interiorTypes)
-            generalize(NotNull{arena}, builtinTypes, constraint->scope, generalizedTypes, ty);
+            generalize(NotNull{arena}, builtinTypes, constraint->scope, generalizedTypes, ty, /* avoidSealingTables */ false);
     }
 
 
@@ -1028,9 +823,6 @@ bool ConstraintSolver::tryDispatch(const IterableConstraint& c, NotNull<const Co
         TypeId tableTy =
             arena->addType(TableType{TableType::Props{}, TableIndexer{keyTy, valueTy}, TypeLevel{}, constraint->scope, TableState::Free});
 
-        if (FFlag::LuauTrackInteriorFreeTypesOnScope && FFlag::LuauTrackInteriorFreeTablesOnScope)
-            trackInteriorFreeType(constraint->scope, tableTy);
-
         unify(constraint, nextTy, tableTy);
 
         auto it = begin(c.variables);
@@ -1167,6 +959,16 @@ bool ConstraintSolver::tryDispatch(const TypeAliasExpansionConstraint& c, NotNul
     if (auto typeFn = get<TypeFunctionInstanceType>(follow(tf->type)))
         pushConstraint(NotNull(constraint->scope.get()), constraint->location, ReduceConstraint{tf->type});
 
+    if (!FFlag::LuauUserTypeFunNoExtraConstraint)
+    {
+        // If there are no parameters to the type function we can just use the type directly
+        if (tf->typeParams.empty() && tf->typePackParams.empty())
+        {
+            bindResult(tf->type);
+            return true;
+        }
+    }
+
     // Due to how pending expansion types and TypeFun's are created
     // If this check passes, we have created a cyclic / corecursive type alias
     // of size 0
@@ -1179,11 +981,14 @@ bool ConstraintSolver::tryDispatch(const TypeAliasExpansionConstraint& c, NotNul
         return true;
     }
 
-    // If there are no parameters to the type function we can just use the type directly
-    if (tf->typeParams.empty() && tf->typePackParams.empty())
+    if (FFlag::LuauUserTypeFunNoExtraConstraint)
     {
-        bindResult(tf->type);
-        return true;
+        // If there are no parameters to the type function we can just use the type directly
+        if (tf->typeParams.empty() && tf->typePackParams.empty())
+        {
+            bindResult(tf->type);
+            return true;
+        }
     }
 
     auto [typeArguments, packArguments] = saturateArguments(arena, builtinTypes, *tf, petv->typeArguments, petv->packArguments);
@@ -1331,9 +1136,12 @@ bool ConstraintSolver::tryDispatch(const TypeAliasExpansionConstraint& c, NotNul
             target = follow(instantiated);
         }
 
-        // This is a new type - redefine the location.
-        ttv->definitionLocation = constraint->location;
-        ttv->definitionModuleName = currentModuleName;
+        if (FFlag::LuauNewSolverPopulateTableLocations)
+        {
+            // This is a new type - redefine the location.
+            ttv->definitionLocation = constraint->location;
+            ttv->definitionModuleName = currentModuleName;
+        }
 
         ttv->instantiatedTypeParams = typeArguments;
         ttv->instantiatedTypePackParams = packArguments;
@@ -1346,35 +1154,38 @@ bool ConstraintSolver::tryDispatch(const TypeAliasExpansionConstraint& c, NotNul
     return true;
 }
 
-void ConstraintSolver::fillInDiscriminantTypes(NotNull<const Constraint> constraint, const std::vector<std::optional<TypeId>>& discriminantTypes)
+void ConstraintSolver::fillInDiscriminantTypes(
+    NotNull<const Constraint> constraint,
+    const std::vector<std::optional<TypeId>>& discriminantTypes
+)
 {
     for (std::optional<TypeId> ty : discriminantTypes)
     {
         if (!ty)
             continue;
 
-        if (FFlag::LuauSearchForRefineableType)
+        // If the discriminant type has been transmuted, we need to unblock them.
+        if (!isBlocked(*ty))
         {
-            if (isBlocked(*ty))
-                // We bind any unused discriminants to the `*no-refine*` type indicating that it can be safely ignored.
-                emplaceType<BoundType>(asMutable(follow(*ty)), builtinTypes->noRefineType);
-
-            // We also need to unconditionally unblock these types, otherwise
-            // you end up with funky looking "Blocked on *no-refine*."
             unblock(*ty, constraint->location);
+            continue;
+        }
+
+        if (FFlag::LuauRemoveNotAnyHack)
+        {
+            // We bind any unused discriminants to the `*no-refine*` type indicating that it can be safely ignored.
+            emplaceType<BoundType>(asMutable(follow(*ty)), builtinTypes->noRefineType);
         }
         else
         {
-
-            // If the discriminant type has been transmuted, we need to unblock them.
-            if (!isBlocked(*ty))
-            {
-                unblock(*ty, constraint->location);
-                continue;
-            }
-
-            // We bind any unused discriminants to the `*no-refine*` type indicating that it can be safely ignored.
-            emplaceType<BoundType>(asMutable(follow(*ty)), builtinTypes->noRefineType);
+            // We use `any` here because the discriminant type may be pointed at by both branches,
+            // where the discriminant type is not negated, and the other where it is negated, i.e.
+            // `unknown ~ unknown` and `~unknown ~ never`, so `T & unknown ~ T` and `T & ~unknown ~ never`
+            // v.s.
+            // `any ~ any` and `~any ~ any`, so `T & any ~ T` and `T & ~any ~ T`
+            //
+            // In practice, users cannot negate `any`, so this is an implementation detail we can always change.
+            emplaceType<BoundType>(asMutable(follow(*ty)), builtinTypes->anyType);
         }
     }
 }
@@ -1385,24 +1196,17 @@ bool ConstraintSolver::tryDispatch(const FunctionCallConstraint& c, NotNull<cons
     TypePackId argsPack = follow(c.argsPack);
     TypePackId result = follow(c.result);
 
-    if (FFlag::DebugLuauGreedyGeneralization)
+    if (isBlocked(fn) || hasUnresolvedConstraints(fn))
     {
-        if (isBlocked(fn))
-            return block(c.fn, constraint);
-    }
-    else
-    {
-        if (isBlocked(fn) || hasUnresolvedConstraints(fn))
-        {
-            return block(c.fn, constraint);
-        }
+        return block(c.fn, constraint);
     }
 
     if (get<AnyType>(fn))
     {
         emplaceTypePack<BoundTypePack>(asMutable(c.result), builtinTypes->anyTypePack);
         unblock(c.result, constraint->location);
-        fillInDiscriminantTypes(constraint, c.discriminantTypes);
+        if (FFlag::LuauAlwaysFillInFunctionCallDiscriminantTypes)
+            fillInDiscriminantTypes(constraint, c.discriminantTypes);
         return true;
     }
 
@@ -1410,14 +1214,16 @@ bool ConstraintSolver::tryDispatch(const FunctionCallConstraint& c, NotNull<cons
     if (get<ErrorType>(fn))
     {
         bind(constraint, c.result, builtinTypes->errorRecoveryTypePack());
-        fillInDiscriminantTypes(constraint, c.discriminantTypes);
+        if (FFlag::LuauAlwaysFillInFunctionCallDiscriminantTypes)
+            fillInDiscriminantTypes(constraint, c.discriminantTypes);
         return true;
     }
 
     if (get<NeverType>(fn))
     {
         bind(constraint, c.result, builtinTypes->neverTypePack);
-        fillInDiscriminantTypes(constraint, c.discriminantTypes);
+        if (FFlag::LuauAlwaysFillInFunctionCallDiscriminantTypes)
+            fillInDiscriminantTypes(constraint, c.discriminantTypes);
         return true;
     }
 
@@ -1498,7 +1304,44 @@ bool ConstraintSolver::tryDispatch(const FunctionCallConstraint& c, NotNull<cons
             emplace<FreeTypePack>(constraint, c.result, constraint->scope);
     }
 
-    fillInDiscriminantTypes(constraint, c.discriminantTypes);
+    if (FFlag::LuauAlwaysFillInFunctionCallDiscriminantTypes)
+    {
+        fillInDiscriminantTypes(constraint, c.discriminantTypes);
+    }
+    else
+    {
+        // NOTE: This is the body of the `fillInDiscriminantTypes` helper.
+        for (std::optional<TypeId> ty : c.discriminantTypes)
+        {
+            if (!ty)
+                continue;
+
+            // If the discriminant type has been transmuted, we need to unblock them.
+            if (!isBlocked(*ty))
+            {
+                unblock(*ty, constraint->location);
+                continue;
+            }
+
+            if (FFlag::LuauRemoveNotAnyHack)
+            {
+                // We bind any unused discriminants to the `*no-refine*` type indicating that it can be safely ignored.
+                emplaceType<BoundType>(asMutable(follow(*ty)), builtinTypes->noRefineType);
+            }
+            else
+            {
+                // We use `any` here because the discriminant type may be pointed at by both branches,
+                // where the discriminant type is not negated, and the other where it is negated, i.e.
+                // `unknown ~ unknown` and `~unknown ~ never`, so `T & unknown ~ T` and `T & ~unknown ~ never`
+                // v.s.
+                // `any ~ any` and `~any ~ any`, so `T & any ~ T` and `T & ~any ~ T`
+                //
+                // In practice, users cannot negate `any`, so this is an implementation detail we can always change.
+                emplaceType<BoundType>(asMutable(follow(*ty)), builtinTypes->anyType);
+            }
+        }
+    }
+
 
     OverloadResolver resolver{
         builtinTypes,
@@ -1564,43 +1407,6 @@ static AstExpr* unwrapGroup(AstExpr* expr)
     return expr;
 }
 
-struct ContainsGenerics : public TypeOnceVisitor
-{
-    DenseHashSet<const void*> generics{nullptr};
-
-    bool found = false;
-
-    bool visit(TypeId ty) override
-    {
-        return !found;
-    }
-
-    bool visit(TypeId ty, const GenericType&) override
-    {
-        found |= generics.contains(ty);
-        return true;
-    }
-
-    bool visit(TypeId ty, const TypeFunctionInstanceType&) override
-    {
-        return !found;
-    }
-
-    bool visit(TypePackId tp, const GenericTypePack&) override
-    {
-        found |= generics.contains(tp);
-        return !found;
-    }
-
-    bool hasGeneric(TypeId ty)
-    {
-        traverse(ty);
-        auto ret = found;
-        found = false;
-        return ret;
-    }
-};
-
 bool ConstraintSolver::tryDispatch(const FunctionCheckConstraint& c, NotNull<const Constraint> constraint)
 {
     TypeId fn = follow(c.fn);
@@ -1643,49 +1449,36 @@ bool ConstraintSolver::tryDispatch(const FunctionCheckConstraint& c, NotNull<con
     DenseHashMap<TypeId, TypeId> replacements{nullptr};
     DenseHashMap<TypePackId, TypePackId> replacementPacks{nullptr};
 
-    ContainsGenerics containsGenerics;
-
     for (auto generic : ftv->generics)
-    {
         replacements[generic] = builtinTypes->unknownType;
-        if (FFlag::LuauBidirectionalInferenceCollectIndexerTypes)
-            containsGenerics.generics.insert(generic);
-    }
 
     for (auto genericPack : ftv->genericPacks)
-    {
         replacementPacks[genericPack] = builtinTypes->unknownTypePack;
-        if (FFlag::LuauBidirectionalInferenceCollectIndexerTypes)
-            containsGenerics.generics.insert(genericPack);
-    }
 
     // If the type of the function has generics, we don't actually want to push any of the generics themselves
     // into the argument types as expected types because this creates an unnecessary loop. Instead, we want to
     // replace these types with `unknown` (and `...unknown`) to keep any structure but not create the cycle.
-    if (!FFlag::LuauBidirectionalInferenceCollectIndexerTypes)
+    if (!replacements.empty() || !replacementPacks.empty())
     {
-        if (!replacements.empty() || !replacementPacks.empty())
+        Replacer replacer{arena, std::move(replacements), std::move(replacementPacks)};
+
+        std::optional<TypeId> res = replacer.substitute(fn);
+        if (res)
         {
-            Replacer replacer{arena, std::move(replacements), std::move(replacementPacks)};
-
-            std::optional<TypeId> res = replacer.substitute(fn);
-            if (res)
+            if (*res != fn)
             {
-                if (*res != fn)
-                {
-                    FunctionType* ftvMut = getMutable<FunctionType>(*res);
-                    LUAU_ASSERT(ftvMut);
-                    ftvMut->generics.clear();
-                    ftvMut->genericPacks.clear();
-                }
-
-                fn = *res;
-                ftv = get<FunctionType>(*res);
-                LUAU_ASSERT(ftv);
-
-                // we've potentially copied type functions here, so we need to reproduce their reduce constraint.
-                reproduceConstraints(constraint->scope, constraint->location, replacer);
+                FunctionType* ftvMut = getMutable<FunctionType>(*res);
+                LUAU_ASSERT(ftvMut);
+                ftvMut->generics.clear();
+                ftvMut->genericPacks.clear();
             }
+
+            fn = *res;
+            ftv = get<FunctionType>(*res);
+            LUAU_ASSERT(ftv);
+
+            // we've potentially copied type functions here, so we need to reproduce their reduce constraint.
+            reproduceConstraints(constraint->scope, constraint->location, replacer);
         }
     }
 
@@ -1704,10 +1497,6 @@ bool ConstraintSolver::tryDispatch(const FunctionCheckConstraint& c, NotNull<con
 
         (*c.astExpectedTypes)[expr] = expectedArgTy;
 
-        // Generic types are skipped over entirely, for now.
-        if (FFlag::LuauBidirectionalInferenceCollectIndexerTypes && containsGenerics.hasGeneric(expectedArgTy))
-            continue;
-
         const FunctionType* expectedLambdaTy = get<FunctionType>(expectedArgTy);
         const FunctionType* lambdaTy = get<FunctionType>(actualArgTy);
         const AstExprFunction* lambdaExpr = expr->as<AstExprFunction>();
@@ -1735,11 +1524,8 @@ bool ConstraintSolver::tryDispatch(const FunctionCheckConstraint& c, NotNull<con
         else if (expr->is<AstExprTable>())
         {
             Unifier2 u2{arena, builtinTypes, constraint->scope, NotNull{&iceReporter}};
-            Subtyping sp{builtinTypes, arena, simplifier, normalizer, typeFunctionRuntime, NotNull{&iceReporter}};
             std::vector<TypeId> toBlock;
-            (void)matchLiteralType(
-                c.astTypes, c.astExpectedTypes, builtinTypes, arena, NotNull{&u2}, NotNull{&sp}, expectedArgTy, actualArgTy, expr, toBlock
-            );
+            (void)matchLiteralType(c.astTypes, c.astExpectedTypes, builtinTypes, arena, NotNull{&u2}, expectedArgTy, actualArgTy, expr, toBlock);
             LUAU_ASSERT(toBlock.empty());
         }
     }
@@ -1747,29 +1533,6 @@ bool ConstraintSolver::tryDispatch(const FunctionCheckConstraint& c, NotNull<con
     return true;
 }
 
-bool ConstraintSolver::tryDispatch(const TableCheckConstraint& c, NotNull<const Constraint> constraint)
-{
-    // This is expensive as we need to traverse a (potentially large)
-    // literal up front in order to determine if there are any blocked
-    // types, otherwise we may run `matchTypeLiteral` multiple times,
-    // which right now may fail due to being non-idempotent (it
-    // destructively updates the underlying literal type).
-    auto blockedTypes = findBlockedTypesIn(c.table, c.astTypes);
-    for (const auto ty : blockedTypes)
-    {
-        block(ty, constraint);
-    }
-    if (!blockedTypes.empty())
-        return false;
-
-    Unifier2 u2{arena, builtinTypes, constraint->scope, NotNull{&iceReporter}};
-    Subtyping sp{builtinTypes, arena, simplifier, normalizer, typeFunctionRuntime, NotNull{&iceReporter}};
-    std::vector<TypeId> toBlock;
-    (void)matchLiteralType(c.astTypes, c.astExpectedTypes, builtinTypes, arena, NotNull{&u2}, NotNull{&sp}, c.expectedType, c.exprType, c.table, toBlock);
-    LUAU_ASSERT(toBlock.empty());
-    return true;
-}
-
 bool ConstraintSolver::tryDispatch(const PrimitiveTypeConstraint& c, NotNull<const Constraint> constraint)
 {
     std::optional<TypeId> expectedType = c.expectedType ? std::make_optional<TypeId>(follow(*c.expectedType)) : std::nullopt;
@@ -2091,10 +1854,6 @@ bool ConstraintSolver::tryDispatch(const AssignPropConstraint& c, NotNull<const
         else
         {
             TypeId newUpperBound = arena->addType(TableType{TableState::Free, TypeLevel{}, constraint->scope});
-
-            if (FFlag::LuauTrackInteriorFreeTypesOnScope && FFlag::LuauTrackInteriorFreeTablesOnScope)
-                trackInteriorFreeType(constraint->scope, newUpperBound);
-
             TableType* upperTable = getMutable<TableType>(newUpperBound);
             LUAU_ASSERT(upperTable);
 
@@ -2124,7 +1883,7 @@ bool ConstraintSolver::tryDispatch(const AssignPropConstraint& c, NotNull<const
         bind(
             constraint,
             c.propType,
-            isIndex ? arena->addType(UnionType{{propTy, builtinTypes->nilType}}) : propTy
+            isIndex && FFlag::LuauAllowNilAssignmentToIndexer ? arena->addType(UnionType{{propTy, builtinTypes->nilType}}) : propTy
         );
         unify(constraint, rhsType, propTy);
         return true;
@@ -2222,7 +1981,8 @@ bool ConstraintSolver::tryDispatch(const AssignIndexConstraint& c, NotNull<const
             bind(
                 constraint,
                 c.propType,
-                arena->addType(UnionType{{lhsTable->indexer->indexResultType, builtinTypes->nilType}})
+                FFlag::LuauAllowNilAssignmentToIndexer ? arena->addType(UnionType{{lhsTable->indexer->indexResultType, builtinTypes->nilType}})
+                                                       : lhsTable->indexer->indexResultType
             );
             return true;
         }
@@ -2275,7 +2035,8 @@ bool ConstraintSolver::tryDispatch(const AssignIndexConstraint& c, NotNull<const
                 bind(
                     constraint,
                     c.propType,
-                    arena->addType(UnionType{{lhsClass->indexer->indexResultType, builtinTypes->nilType}})
+                    FFlag::LuauAllowNilAssignmentToIndexer ? arena->addType(UnionType{{lhsClass->indexer->indexResultType, builtinTypes->nilType}})
+                                                           : lhsClass->indexer->indexResultType
                 );
                 return true;
             }
@@ -2419,18 +2180,11 @@ bool ConstraintSolver::tryDispatch(const ReduceConstraint& c, NotNull<const Cons
     for (TypePackId r : result.reducedPacks)
         unblock(r, constraint->location);
 
-    if (FFlag::LuauNewTypeFunReductionChecks2)
-    {
-        for (TypeId ity : result.irreducibleTypes)
-            uninhabitedTypeFunctions.insert(ity);
-    }
-
     bool reductionFinished = result.blockedTypes.empty() && result.blockedPacks.empty();
 
     ty = follow(ty);
-
     // If we couldn't reduce this type function, stick it in the set!
-    if (get<TypeFunctionInstanceType>(ty) && (!FFlag::LuauNewTypeFunReductionChecks2 || !result.irreducibleTypes.find(ty)))
+    if (get<TypeFunctionInstanceType>(ty))
         typeFunctionsToFinalize[ty] = constraint;
 
     if (force || reductionFinished)
@@ -2883,10 +2637,6 @@ TablePropLookupResult ConstraintSolver::lookupTableProp(
         NotNull<Scope> scope{ft->scope};
 
         const TypeId newUpperBound = arena->addType(TableType{TableState::Free, TypeLevel{}, scope});
-
-        if (FFlag::LuauTrackInteriorFreeTypesOnScope && FFlag::LuauTrackInteriorFreeTablesOnScope)
-            trackInteriorFreeType(constraint->scope, newUpperBound);
-
         TableType* tt = getMutable<TableType>(newUpperBound);
         LUAU_ASSERT(tt);
         TypeId propType = freshType(arena, builtinTypes, scope);
@@ -3330,27 +3080,9 @@ void ConstraintSolver::shiftReferences(TypeId source, TypeId target)
 
     auto [targetRefs, _] = unresolvedConstraints.try_insert(target, 0);
     targetRefs += count;
-
-    // Any constraint that might have mutated source may now mutate target
-
-    if (FFlag::DebugLuauGreedyGeneralization)
-    {
-        auto it = mutatedFreeTypeToConstraint.find(source);
-        if (it != mutatedFreeTypeToConstraint.end())
-        {
-            auto [it2, fresh] = mutatedFreeTypeToConstraint.try_emplace(target, DenseHashSet<const Constraint*>{nullptr});
-            for (const Constraint* constraint : it->second)
-            {
-                it2->second.insert(constraint);
-
-                auto [it3, fresh2] = maybeMutatedFreeTypes.try_emplace(NotNull{constraint}, DenseHashSet<TypeId>{nullptr});
-                it3->second.insert(target);
-            }
-        }
-    }
 }
 
-std::optional<TypeId> ConstraintSolver::generalizeFreeType(NotNull<Scope> scope, TypeId type)
+std::optional<TypeId> ConstraintSolver::generalizeFreeType(NotNull<Scope> scope, TypeId type, bool avoidSealingTables)
 {
     TypeId t = follow(type);
     if (get<FreeType>(t))
@@ -3365,7 +3097,7 @@ std::optional<TypeId> ConstraintSolver::generalizeFreeType(NotNull<Scope> scope,
         // that until all constraint generation is complete.
     }
 
-    return generalize(NotNull{arena}, builtinTypes, scope, generalizedTypes, type);
+    return generalize(NotNull{arena}, builtinTypes, scope, generalizedTypes, type, avoidSealingTables);
 }
 
 bool ConstraintSolver::hasUnresolvedConstraints(TypeId ty)

Analysis/src/DataFlowGraph.cpp

@@ -13,6 +13,7 @@
 
 LUAU_FASTFLAG(DebugLuauFreezeArena)
 LUAU_FASTFLAG(LuauSolverV2)
+LUAU_FASTFLAG(LuauTypestateBuiltins2)
 
 namespace Luau
 {
@@ -82,6 +83,12 @@ 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);
@@ -872,7 +879,7 @@ DataFlowResult DataFlowGraphBuilder::visitExpr(AstExprCall* c)
 {
     visitExpr(c->func);
 
-    if (shouldTypestateForFirstArgument(*c) && c->args.size > 1 && isLValue(*c->args.begin()))
+    if (FFlag::LuauTypestateBuiltins2 && shouldTypestateForFirstArgument(*c) && c->args.size > 1 && isLValue(*c->args.begin()))
     {
         AstExpr* firstArg = *c->args.begin();
 
@@ -905,17 +912,8 @@ DataFlowResult DataFlowGraphBuilder::visitExpr(AstExprCall* c)
     for (AstExpr* arg : c->args)
         visitExpr(arg);
 
-    // 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(/*subscripted=*/true)};
+    // calls should be treated as subscripted.
+    return {defArena->freshCell(/* subscripted */ true), nullptr};
 }
 
 DataFlowResult DataFlowGraphBuilder::visitExpr(AstExprIndexName* i)
@@ -1162,8 +1160,6 @@ 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>())
@@ -1174,8 +1170,6 @@ void DataFlowGraphBuilder::visitType(AstType* t)
         return; // ok
     else if (auto s = t->as<AstTypeSingletonString>())
         return; // ok
-    else if (auto g = t->as<AstTypeGroup>())
-        return visitType(g->type);
     else
         handle->ice("Unknown AstType in DataFlowGraphBuilder::visitType");
 }
@@ -1265,21 +1259,21 @@ void DataFlowGraphBuilder::visitTypeList(AstTypeList l)
         visitTypePack(l.tailType);
 }
 
-void DataFlowGraphBuilder::visitGenerics(AstArray<AstGenericType*> g)
+void DataFlowGraphBuilder::visitGenerics(AstArray<AstGenericType> g)
 {
-    for (AstGenericType* generic : g)
+    for (AstGenericType generic : g)
     {
-        if (generic->defaultValue)
-            visitType(generic->defaultValue);
+        if (generic.defaultValue)
+            visitType(generic.defaultValue);
     }
 }
 
-void DataFlowGraphBuilder::visitGenericPacks(AstArray<AstGenericTypePack*> g)
+void DataFlowGraphBuilder::visitGenericPacks(AstArray<AstGenericTypePack> g)
 {
-    for (AstGenericTypePack* generic : g)
+    for (AstGenericTypePack generic : g)
     {
-        if (generic->defaultValue)
-            visitTypePack(generic->defaultValue);
+        if (generic.defaultValue)
+            visitTypePack(generic.defaultValue);
     }
 }
 

Analysis/src/EmbeddedBuiltinDefinitions.cpp

@@ -1,9 +1,207 @@
 // 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(LuauVectorDefinitionsExtra)
+LUAU_FASTFLAG(LuauBufferBitMethods2)
+LUAU_FASTFLAGVARIABLE(LuauMathMapDefinition)
+LUAU_FASTFLAG(LuauVector2Constructor)
+
 namespace Luau
 {
 
+static const std::string kBuiltinDefinitionLuaSrcChecked_DEPRECATED = R"BUILTIN_SRC(
+
+declare bit32: {
+    band: @checked (...number) -> number,
+    bor: @checked (...number) -> number,
+    bxor: @checked (...number) -> number,
+    btest: @checked (number, ...number) -> boolean,
+    rrotate: @checked (x: number, disp: number) -> number,
+    lrotate: @checked (x: number, disp: number) -> number,
+    lshift: @checked (x: number, disp: number) -> number,
+    arshift: @checked (x: number, disp: number) -> number,
+    rshift: @checked (x: number, disp: number) -> number,
+    bnot: @checked (x: number) -> number,
+    extract: @checked (n: number, field: number, width: number?) -> number,
+    replace: @checked (n: number, v: number, field: number, width: number?) -> number,
+    countlz: @checked (n: number) -> number,
+    countrz: @checked (n: number) -> number,
+    byteswap: @checked (n: number) -> number,
+}
+
+declare math: {
+    frexp: @checked (n: number) -> (number, number),
+    ldexp: @checked (s: number, e: number) -> number,
+    fmod: @checked (x: number, y: number) -> number,
+    modf: @checked (n: number) -> (number, number),
+    pow: @checked (x: number, y: number) -> number,
+    exp: @checked (n: number) -> number,
+
+    ceil: @checked (n: number) -> number,
+    floor: @checked (n: number) -> number,
+    abs: @checked (n: number) -> number,
+    sqrt: @checked (n: number) -> number,
+
+    log: @checked (n: number, base: number?) -> number,
+    log10: @checked (n: number) -> number,
+
+    rad: @checked (n: number) -> number,
+    deg: @checked (n: number) -> number,
+
+    sin: @checked (n: number) -> number,
+    cos: @checked (n: number) -> number,
+    tan: @checked (n: number) -> number,
+    sinh: @checked (n: number) -> number,
+    cosh: @checked (n: number) -> number,
+    tanh: @checked (n: number) -> number,
+    atan: @checked (n: number) -> number,
+    acos: @checked (n: number) -> number,
+    asin: @checked (n: number) -> number,
+    atan2: @checked (y: number, x: number) -> number,
+
+    min: @checked (number, ...number) -> number,
+    max: @checked (number, ...number) -> number,
+
+    pi: number,
+    huge: number,
+
+    randomseed: @checked (seed: number) -> (),
+    random: @checked (number?, number?) -> number,
+
+    sign: @checked (n: number) -> number,
+    clamp: @checked (n: number, min: number, max: number) -> number,
+    noise: @checked (x: number, y: number?, z: number?) -> number,
+    round: @checked (n: number) -> number,
+    map: @checked (x: number, inmin: number, inmax: number, outmin: number, outmax: number) -> number,
+}
+
+type DateTypeArg = {
+    year: number,
+    month: number,
+    day: number,
+    hour: number?,
+    min: number?,
+    sec: number?,
+    isdst: boolean?,
+}
+
+type DateTypeResult = {
+    year: number,
+    month: number,
+    wday: number,
+    yday: number,
+    day: number,
+    hour: number,
+    min: number,
+    sec: number,
+    isdst: boolean,
+}
+
+declare os: {
+    time: (time: DateTypeArg?) -> number,
+    date: ((formatString: "*t" | "!*t", time: number?) -> DateTypeResult) & ((formatString: string?, time: number?) -> string),
+    difftime: (t2: DateTypeResult | number, t1: DateTypeResult | number) -> number,
+    clock: () -> number,
+}
+
+@checked declare function require(target: any): any
+
+@checked declare function getfenv(target: any): { [string]: any }
+
+declare _G: any
+declare _VERSION: string
+
+declare function gcinfo(): number
+
+declare function print<T...>(...: T...)
+
+declare function type<T>(value: T): string
+declare function typeof<T>(value: T): string
+
+-- `assert` has a magic function attached that will give more detailed type information
+declare function assert<T>(value: T, errorMessage: string?): T
+declare function error<T>(message: T, level: number?): never
+
+declare function tostring<T>(value: T): string
+declare function tonumber<T>(value: T, radix: number?): number?
+
+declare function rawequal<T1, T2>(a: T1, b: T2): boolean
+declare function rawget<K, V>(tab: {[K]: V}, k: K): V
+declare function rawset<K, V>(tab: {[K]: V}, k: K, v: V): {[K]: V}
+declare function rawlen<K, V>(obj: {[K]: V} | string): number
+
+declare function setfenv<T..., R...>(target: number | (T...) -> R..., env: {[string]: any}): ((T...) -> R...)?
+
+declare function ipairs<V>(tab: {V}): (({V}, number) -> (number?, V), {V}, number)
+
+declare function pcall<A..., R...>(f: (A...) -> R..., ...: A...): (boolean, R...)
+
+-- FIXME: The actual type of `xpcall` is:
+-- <E, A..., R1..., R2...>(f: (A...) -> R1..., err: (E) -> R2..., A...) -> (true, R1...) | (false, R2...)
+-- Since we can't represent the return value, we use (boolean, R1...).
+declare function xpcall<E, A..., R1..., R2...>(f: (A...) -> R1..., err: (E) -> R2..., ...: A...): (boolean, R1...)
+
+-- `select` has a magic function attached to provide more detailed type information
+declare function select<A...>(i: string | number, ...: A...): ...any
+
+-- FIXME: This type is not entirely correct - `loadstring` returns a function or
+-- (nil, string).
+declare function loadstring<A...>(src: string, chunkname: string?): (((A...) -> any)?, string?)
+
+@checked declare function newproxy(mt: boolean?): any
+
+declare coroutine: {
+    create: <A..., R...>(f: (A...) -> R...) -> thread,
+    resume: <A..., R...>(co: thread, A...) -> (boolean, R...),
+    running: () -> thread,
+    status: @checked (co: thread) -> "dead" | "running" | "normal" | "suspended",
+    wrap: <A..., R...>(f: (A...) -> R...) -> ((A...) -> R...),
+    yield: <A..., R...>(A...) -> R...,
+    isyieldable: () -> boolean,
+    close: @checked (co: thread) -> (boolean, any)
+}
+
+declare table: {
+    concat: <V>(t: {V}, sep: string?, i: number?, j: number?) -> string,
+    insert: (<V>(t: {V}, value: V) -> ()) & (<V>(t: {V}, pos: number, value: V) -> ()),
+    maxn: <V>(t: {V}) -> number,
+    remove: <V>(t: {V}, number?) -> V?,
+    sort: <V>(t: {V}, comp: ((V, V) -> boolean)?) -> (),
+    create: <V>(count: number, value: V?) -> {V},
+    find: <V>(haystack: {V}, needle: V, init: number?) -> number?,
+
+    unpack: <V>(list: {V}, i: number?, j: number?) -> ...V,
+    pack: <V>(...V) -> { n: number, [number]: V },
+
+    getn: <V>(t: {V}) -> number,
+    foreach: <K, V>(t: {[K]: V}, f: (K, V) -> ()) -> (),
+    foreachi: <V>({V}, (number, V) -> ()) -> (),
+
+    move: <V>(src: {V}, a: number, b: number, t: number, dst: {V}?) -> {V},
+    clear: <K, V>(table: {[K]: V}) -> (),
+
+    isfrozen: <K, V>(t: {[K]: V}) -> boolean,
+}
+
+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),
+}
+
+declare utf8: {
+    char: @checked (...number) -> string,
+    charpattern: string,
+    codes: @checked (str: string) -> ((string, number) -> (number, number), string, number),
+    codepoint: @checked (str: string, i: number?, j: number?) -> ...number,
+    len: @checked (s: string, i: number?, j: number?) -> (number?, number?),
+    offset: @checked (s: string, n: number?, i: number?) -> number,
+}
+
+-- Cannot use `typeof` here because it will produce a polytype when we expect a monotype.
+declare function unpack<V>(tab: {V}, i: number?, j: number?): ...V
+
+)BUILTIN_SRC";
+
 static const std::string kBuiltinDefinitionBaseSrc = R"BUILTIN_SRC(
 
 @checked declare function require(target: any): any
@@ -207,7 +405,7 @@ declare table: {
 static const std::string kBuiltinDefinitionDebugSrc = R"BUILTIN_SRC(
 
 declare debug: {
-    info: ((thread: thread, level: number, options: string) -> ...any) & ((level: number, options: string) -> ...any) & (<A..., R1...>(func: (A...) -> R1..., options: string) -> ...any),
+    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),
 }
 
@@ -226,6 +424,37 @@ declare utf8: {
 
 )BUILTIN_SRC";
 
+static const std::string kBuiltinDefinitionBufferSrc_DEPRECATED = R"BUILTIN_SRC(
+--- Buffer API
+declare buffer: {
+    create: @checked (size: number) -> buffer,
+    fromstring: @checked (str: string) -> buffer,
+    tostring: @checked (b: buffer) -> string,
+    len: @checked (b: buffer) -> number,
+    copy: @checked (target: buffer, targetOffset: number, source: buffer, sourceOffset: number?, count: number?) -> (),
+    fill: @checked (b: buffer, offset: number, value: number, count: number?) -> (),
+    readi8: @checked (b: buffer, offset: number) -> number,
+    readu8: @checked (b: buffer, offset: number) -> number,
+    readi16: @checked (b: buffer, offset: number) -> number,
+    readu16: @checked (b: buffer, offset: number) -> number,
+    readi32: @checked (b: buffer, offset: number) -> number,
+    readu32: @checked (b: buffer, offset: number) -> number,
+    readf32: @checked (b: buffer, offset: number) -> number,
+    readf64: @checked (b: buffer, offset: number) -> number,
+    writei8: @checked (b: buffer, offset: number, value: number) -> (),
+    writeu8: @checked (b: buffer, offset: number, value: number) -> (),
+    writei16: @checked (b: buffer, offset: number, value: number) -> (),
+    writeu16: @checked (b: buffer, offset: number, value: number) -> (),
+    writei32: @checked (b: buffer, offset: number, value: number) -> (),
+    writeu32: @checked (b: buffer, offset: number, value: number) -> (),
+    writef32: @checked (b: buffer, offset: number, value: number) -> (),
+    writef64: @checked (b: buffer, offset: number, value: number) -> (),
+    readstring: @checked (b: buffer, offset: number, count: number) -> string,
+    writestring: @checked (b: buffer, offset: number, value: string, count: number?) -> (),
+}
+
+)BUILTIN_SRC";
+
 static const std::string kBuiltinDefinitionBufferSrc = R"BUILTIN_SRC(
 --- Buffer API
 declare buffer: {
@@ -259,6 +488,88 @@ declare buffer: {
 
 )BUILTIN_SRC";
 
+static const std::string kBuiltinDefinitionVectorSrc_NoExtra_NoVector2Ctor_DEPRECATED = R"BUILTIN_SRC(
+
+-- TODO: this will be replaced with a built-in primitive type
+declare class vector 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";
+
+static const std::string kBuiltinDefinitionVectorSrc_NoExtra_DEPRECATED = R"BUILTIN_SRC(
+
+-- TODO: this will be replaced with a built-in primitive type
+declare class vector 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";
+
+static const std::string kBuiltinDefinitionVectorSrc_NoVector2Ctor_DEPRECATED = 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
+    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";
+
 static const std::string kBuiltinDefinitionVectorSrc = 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
@@ -291,98 +602,37 @@ declare vector: {
 
 std::string getBuiltinDefinitionSource()
 {
-    std::string result = kBuiltinDefinitionBaseSrc;
+    std::string result = FFlag::LuauMathMapDefinition ? kBuiltinDefinitionBaseSrc : kBuiltinDefinitionLuaSrcChecked_DEPRECATED;
 
-    result += kBuiltinDefinitionBit32Src;
-    result += kBuiltinDefinitionMathSrc;
-    result += kBuiltinDefinitionOsSrc;
-    result += kBuiltinDefinitionCoroutineSrc;
-    result += kBuiltinDefinitionTableSrc;
-    result += kBuiltinDefinitionDebugSrc;
-    result += kBuiltinDefinitionUtf8Src;
-    result += kBuiltinDefinitionBufferSrc;
-    result += kBuiltinDefinitionVectorSrc;
+    if (FFlag::LuauMathMapDefinition)
+    {
+        result += kBuiltinDefinitionBit32Src;
+        result += kBuiltinDefinitionMathSrc;
+        result += kBuiltinDefinitionOsSrc;
+        result += kBuiltinDefinitionCoroutineSrc;
+        result += kBuiltinDefinitionTableSrc;
+        result += kBuiltinDefinitionDebugSrc;
+        result += kBuiltinDefinitionUtf8Src;
+    }
+
+    result += FFlag::LuauBufferBitMethods2 ? kBuiltinDefinitionBufferSrc : kBuiltinDefinitionBufferSrc_DEPRECATED;
+
+    if (FFlag::LuauVectorDefinitionsExtra)
+    {
+        if (FFlag::LuauVector2Constructor)
+            result += kBuiltinDefinitionVectorSrc;
+        else
+            result += kBuiltinDefinitionVectorSrc_NoVector2Ctor_DEPRECATED;
+    }
+    else
+    {
+        if (FFlag::LuauVector2Constructor)
+            result += kBuiltinDefinitionVectorSrc_NoExtra_DEPRECATED;
+        else
+            result += kBuiltinDefinitionVectorSrc_NoExtra_NoVector2Ctor_DEPRECATED;
+    }
 
     return result;
 }
 
-// TODO: split into separate tagged unions when the new solver can appropriately handle that.
-static const std::string kBuiltinDefinitionTypesSrc = R"BUILTIN_SRC(
-
-export type type = {
-    tag: "nil" | "unknown" | "never" | "any" | "boolean" | "number" | "string" | "buffer" | "thread" |
-         "singleton" | "negation" | "union" | "intesection" | "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,
-}
-
-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";
-
-std::string getTypeFunctionDefinitionSource()
-{
-    return kBuiltinDefinitionTypesSrc;
-}
-
 } // namespace Luau

Analysis/src/EqSatSimplification.cpp

@@ -92,24 +92,18 @@ size_t TTable::Hash::operator()(const TTable& value) const
     return hash;
 }
 
-StringId StringCache::add(std::string_view s)
+uint32_t StringCache::add(std::string_view s)
 {
-    /* Important subtlety: This use of DenseHashMap<std::string_view, StringId>
-     * is okay because std::hash<std::string_view> works solely on the bytes
-     * referred by the string_view.
-     *
-     * In other words, two string views which contain the same bytes will have
-     * the same hash whether or not their addresses are the same.
-     */
-    if (StringId* it = strings.find(s))
+    size_t hash = std::hash<std::string_view>()(s);
+    if (uint32_t* it = strings.find(hash))
         return *it;
 
     char* storage = static_cast<char*>(allocator.allocate(s.size()));
     memcpy(storage, s.data(), s.size());
 
-    StringId result = StringId(views.size());
+    uint32_t result = uint32_t(views.size());
     views.emplace_back(storage, s.size());
-    strings[s] = result;
+    strings[hash] = result;
     return result;
 }
 
@@ -396,17 +390,6 @@ Id toId(
     {
         LUAU_ASSERT(tfun->packArguments.empty());
 
-        if (tfun->userFuncName)
-        {
-            // TODO: User defined type functions are pseudo-effectful: error
-            // reporting is done via the `print` statement, so running a
-            // UDTF multiple times may end up double erroring. egraphs
-            // currently may induce type functions to be reduced multiple
-            // times. We should probably opt _not_ to process user defined
-            // type functions at all.
-            return egraph.add(TOpaque{ty});
-        }
-
         std::vector<Id> parts;
         parts.reserve(tfun->typeArguments.size());
         for (TypeId part : tfun->typeArguments)

Analysis/src/Error.cpp

@@ -8,7 +8,6 @@
 #include "Luau/StringUtils.h"
 #include "Luau/ToString.h"
 #include "Luau/Type.h"
-#include "Luau/TypeChecker2.h"
 #include "Luau/TypeFunction.h"
 
 #include <optional>
@@ -18,7 +17,6 @@
 #include <unordered_set>
 
 LUAU_FASTINTVARIABLE(LuauIndentTypeMismatchMaxTypeLength, 10)
-LUAU_FASTFLAG(LuauNonStrictFuncDefErrorFix)
 
 static std::string wrongNumberOfArgsString(
     size_t expectedCount,
@@ -118,10 +116,7 @@ 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;
-            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;
+            return "Type\n    " + given + "\ncould not be converted into\n    " + wanted;
         };
 
         if (givenTypeName == wantedTypeName)
@@ -756,15 +751,8 @@ struct ErrorConverter
 
     std::string operator()(const NonStrictFunctionDefinitionError& e) const
     {
-        if (FFlag::LuauNonStrictFuncDefErrorFix && 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";
-        }
+        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

Analysis/src/FileResolver.cpp

@@ -1,172 +0,0 @@
-// 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>
-
-LUAU_FASTFLAGVARIABLE(LuauExposeRequireByStringAutocomplete)
-LUAU_FASTFLAGVARIABLE(LuauEscapeCharactersInRequireSuggestions)
-LUAU_FASTFLAGVARIABLE(LuauHideImpossibleRequireSuggestions)
-
-namespace Luau
-{
-
-static std::optional<RequireSuggestions> processRequireSuggestions(std::optional<RequireSuggestions> suggestions)
-{
-    if (!suggestions)
-        return suggestions;
-
-    if (FFlag::LuauEscapeCharactersInRequireSuggestions)
-    {
-        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 (FFlag::LuauHideImpossibleRequireSuggestions)
-        {
-            // 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
-{
-    if (!FFlag::LuauExposeRequireByStringAutocomplete)
-        return std::nullopt;
-
-    return requireSuggester ? requireSuggester->getRequireSuggestions(requirer, path) : std::nullopt;
-}
-
-} // namespace Luau

Analysis/src/Frontend.cpp

@@ -1,6 +1,7 @@
 // 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"
@@ -38,6 +39,7 @@ LUAU_FASTINT(LuauTypeInferRecursionLimit)
 LUAU_FASTINT(LuauTarjanChildLimit)
 LUAU_FASTFLAG(LuauInferInNoCheckMode)
 LUAU_FASTFLAGVARIABLE(LuauKnowsTheDataModel3)
+LUAU_FASTFLAGVARIABLE(LuauStoreCommentsForDefinitionFiles)
 LUAU_FASTFLAG(LuauSolverV2)
 LUAU_FASTFLAGVARIABLE(DebugLuauLogSolverToJson)
 LUAU_FASTFLAGVARIABLE(DebugLuauLogSolverToJsonFile)
@@ -46,12 +48,10 @@ LUAU_FASTFLAGVARIABLE(DebugLuauForceStrictMode)
 LUAU_FASTFLAGVARIABLE(DebugLuauForceNonStrictMode)
 LUAU_DYNAMIC_FASTFLAGVARIABLE(LuauRunCustomModuleChecks, false)
 
-LUAU_FASTFLAGVARIABLE(LuauModuleHoldsAstRoot)
+LUAU_FASTFLAG(StudioReportLuauAny2)
+LUAU_FASTFLAGVARIABLE(LuauStoreSolverTypeOnModule)
 
-LUAU_FASTFLAGVARIABLE(LuauFixMultithreadTypecheck)
-
-LUAU_FASTFLAGVARIABLE(LuauSelectivelyRetainDFGArena)
-LUAU_FASTFLAG(LuauTypeFunResultInAutocomplete)
+LUAU_FASTFLAGVARIABLE(LuauReferenceAllocatorInNewSolver)
 
 namespace Luau
 {
@@ -81,20 +81,6 @@ 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)
@@ -152,7 +138,7 @@ static ParseResult parseSourceForModule(std::string_view source, Luau::SourceMod
     sourceModule.root = parseResult.root;
     sourceModule.mode = Mode::Definition;
 
-    if (options.captureComments)
+    if (FFlag::LuauStoreCommentsForDefinitionFiles && options.captureComments)
     {
         sourceModule.hotcomments = parseResult.hotcomments;
         sourceModule.commentLocations = parseResult.commentLocations;
@@ -459,6 +445,20 @@ 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;
@@ -480,203 +480,6 @@ std::vector<ModuleName> Frontend::checkQueuedModules(
     std::function<bool(size_t done, size_t total)> progress
 )
 {
-    if (!FFlag::LuauFixMultithreadTypecheck)
-    {
-        return checkQueuedModules_DEPRECATED(optionOverride, executeTask, progress);
-    }
-
-    FrontendOptions frontendOptions = optionOverride.value_or(options);
-    if (FFlag::LuauSolverV2)
-        frontendOptions.forAutocomplete = false;
-
-    // By taking data into locals, we make sure queue is cleared at the end, even if an ICE or a different exception is thrown
-    std::vector<ModuleName> currModuleQueue;
-    std::swap(currModuleQueue, moduleQueue);
-
-    DenseHashSet<Luau::ModuleName> seen{{}};
-
-    std::shared_ptr<BuildQueueWorkState> state = std::make_shared<BuildQueueWorkState>();
-
-    for (const ModuleName& name : currModuleQueue)
-    {
-        if (seen.contains(name))
-            continue;
-
-        if (!isDirty(name, frontendOptions.forAutocomplete))
-        {
-            seen.insert(name);
-            continue;
-        }
-
-        std::vector<ModuleName> queue;
-        bool cycleDetected = parseGraph(
-            queue,
-            name,
-            frontendOptions.forAutocomplete,
-            [&seen](const ModuleName& name)
-            {
-                return seen.contains(name);
-            }
-        );
-
-        addBuildQueueItems(state->buildQueueItems, queue, cycleDetected, seen, frontendOptions);
-    }
-
-    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 < state->buildQueueItems.size(); i++)
-    {
-        BuildQueueItem& item = state->buildQueueItems[i];
-        moduleNameToQueue[item.name] = i;
-    }
-
-    // Default task execution is single-threaded and immediate
-    if (!executeTask)
-    {
-        executeTask = [](std::function<void()> task)
-        {
-            task();
-        };
-    }
-
-    state->executeTask = executeTask;
-    state->remaining = state->buildQueueItems.size();
-
-    // Record dependencies between modules
-    for (size_t i = 0; i < state->buildQueueItems.size(); i++)
-    {
-        BuildQueueItem& item = state->buildQueueItems[i];
-
-        for (const ModuleName& dep : item.sourceNode->requireSet)
-        {
-            if (auto it = sourceNodes.find(dep); it != sourceNodes.end())
-            {
-                if (it->second->hasDirtyModule(frontendOptions.forAutocomplete))
-                {
-                    item.dirtyDependencies++;
-
-                    state->buildQueueItems[moduleNameToQueue[dep]].reverseDeps.push_back(i);
-                }
-            }
-        }
-    }
-
-    // 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 (state->remaining != 0)
-    {
-        {
-            std::unique_lock guard(state->mtx);
-
-            // If nothing is ready yet, wait
-            state->cv.wait(
-                guard,
-                [state]
-                {
-                    return !state->readyQueueItems.empty();
-                }
-            );
-
-            // Handle checked items
-            for (size_t i : state->readyQueueItems)
-            {
-                const BuildQueueItem& item = state->buildQueueItems[i];
-
-                // If exception was thrown, stop adding new items and wait for processing items to complete
-                if (item.exception)
-                    itemWithException = i;
-
-                if (item.module && item.module->cancelled)
-                    cancelled = true;
-
-                if (itemWithException || cancelled)
-                    break;
-
-                recordItemResult(item);
-
-                // Notify items that were waiting for this dependency
-                for (size_t reverseDep : item.reverseDeps)
-                {
-                    BuildQueueItem& reverseDepItem = state->buildQueueItems[reverseDep];
-
-                    LUAU_ASSERT(reverseDepItem.dirtyDependencies != 0);
-                    reverseDepItem.dirtyDependencies--;
-
-                    // In case of a module cycle earlier, check if unlocked an item that was already processed
-                    if (!reverseDepItem.processing && reverseDepItem.dirtyDependencies == 0)
-                        nextItems.push_back(reverseDep);
-                }
-            }
-
-            LUAU_ASSERT(state->processing >= state->readyQueueItems.size());
-            state->processing -= state->readyQueueItems.size();
-
-            LUAU_ASSERT(state->remaining >= state->readyQueueItems.size());
-            state->remaining -= state->readyQueueItems.size();
-            state->readyQueueItems.clear();
-        }
-
-        if (progress)
-        {
-            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)
-            sendQueueItemTask(state, i);
-        nextItems.clear();
-
-        if (state->processing == 0)
-        {
-            // Typechecking might have been cancelled by user, don't return partial results
-            if (cancelled)
-                return {};
-
-            // We might have stopped because of a pending exception
-            if (itemWithException)
-                recordItemResult(state->buildQueueItems[*itemWithException]);
-        }
-
-        // If we aren't done, but don't have anything processing, we hit a cycle
-        if (state->remaining != 0 && state->processing == 0)
-            sendQueueCycleItemTask(state);
-    }
-
-    std::vector<ModuleName> checkedModules;
-    checkedModules.reserve(state->buildQueueItems.size());
-
-    for (size_t i = 0; i < state->buildQueueItems.size(); i++)
-        checkedModules.push_back(std::move(state->buildQueueItems[i].name));
-
-    return checkedModules;
-}
-
-std::vector<ModuleName> Frontend::checkQueuedModules_DEPRECATED(
-    std::optional<FrontendOptions> optionOverride,
-    std::function<void(std::function<void()> task)> executeTask,
-    std::function<bool(size_t done, size_t total)> progress
-)
-{
-    LUAU_ASSERT(!FFlag::LuauFixMultithreadTypecheck);
-
     FrontendOptions frontendOptions = optionOverride.value_or(options);
     if (FFlag::LuauSolverV2)
         frontendOptions.forAutocomplete = false;
@@ -1017,13 +820,6 @@ bool Frontend::parseGraph(
             topseen = Permanent;
 
             buildQueue.push_back(top->name);
-
-            // 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);
-            }
         }
         else
         {
@@ -1253,11 +1049,6 @@ void Frontend::checkBuildQueueItem(BuildQueueItem& item)
         freeze(module->interfaceTypes);
 
         module->internalTypes.clear();
-        if (FFlag::LuauSelectivelyRetainDFGArena)
-        {
-            module->defArena.allocator.clear();
-            module->keyArena.allocator.clear();
-        }
 
         module->astTypes.clear();
         module->astTypePacks.clear();
@@ -1311,35 +1102,17 @@ void Frontend::recordItemResult(const BuildQueueItem& item)
     if (item.exception)
         std::rethrow_exception(item.exception);
 
-    bool replacedModule = false;
     if (item.options.forAutocomplete)
     {
-        replacedModule = moduleResolverForAutocomplete.setModule(item.name, item.module);
+        moduleResolverForAutocomplete.setModule(item.name, item.module);
         item.sourceNode->dirtyModuleForAutocomplete = false;
     }
     else
     {
-        replacedModule = moduleResolver.setModule(item.name, item.module);
+        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;
 
@@ -1347,58 +1120,6 @@ 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];
-
-    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;
@@ -1426,12 +1147,6 @@ ScopePtr Frontend::getModuleEnvironment(const SourceModule& module, const Config
     return result;
 }
 
-bool Frontend::allModuleDependenciesValid(const ModuleName& name, bool forAutocomplete) const
-{
-    auto it = sourceNodes.find(name);
-    return it != sourceNodes.end() && !it->second->hasInvalidModuleDependency(forAutocomplete);
-}
-
 bool Frontend::isDirty(const ModuleName& name, bool forAutocomplete) const
 {
     auto it = sourceNodes.find(name);
@@ -1446,35 +1161,16 @@ bool Frontend::isDirty(const ModuleName& name, bool forAutocomplete) const
  */
 void Frontend::markDirty(const ModuleName& name, std::vector<ModuleName>* markedDirty)
 {
-    LUAU_TIMETRACE_SCOPE("Frontend::markDirty", "Frontend");
-    LUAU_TIMETRACE_ARGUMENT("name", name.c_str());
-
-    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;
-        }
-    );
-}
-
-void Frontend::traverseDependents(const ModuleName& name, std::function<bool(SourceNode&)> processSubtree)
-{
-    LUAU_TIMETRACE_SCOPE("Frontend::traverseDependents", "Frontend");
-
     if (sourceNodes.count(name) == 0)
         return;
 
+    std::unordered_map<ModuleName, std::vector<ModuleName>> reverseDeps;
+    for (const auto& module : sourceNodes)
+    {
+        for (const auto& dep : module.second->requireSet)
+            reverseDeps[dep].push_back(module.first);
+    }
+
     std::vector<ModuleName> queue{name};
 
     while (!queue.empty())
@@ -1485,10 +1181,22 @@ void Frontend::traverseDependents(const ModuleName& name, std::function<bool(Sou
         LUAU_ASSERT(sourceNodes.count(next) > 0);
         SourceNode& sourceNode = *sourceNodes[next];
 
-        if (!processSubtree(sourceNode))
+        if (markedDirty)
+            markedDirty->push_back(next);
+
+        if (sourceNode.dirtySourceModule && sourceNode.dirtyModule && sourceNode.dirtyModuleForAutocomplete)
             continue;
 
-        const Set<ModuleName>& dependents = sourceNode.dependents;
+        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());
     }
 }
@@ -1516,7 +1224,6 @@ 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,
@@ -1533,7 +1240,6 @@ ModulePtr check(
         moduleResolver,
         fileResolver,
         parentScope,
-        typeFunctionScope,
         std::move(prepareModuleScope),
         options,
         limits,
@@ -1595,7 +1301,6 @@ 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,
@@ -1608,16 +1313,18 @@ ModulePtr check(
     LUAU_TIMETRACE_ARGUMENT("name", sourceModule.humanReadableName.c_str());
 
     ModulePtr result = std::make_shared<Module>();
-    result->checkedInNewSolver = true;
+    if (FFlag::LuauStoreSolverTypeOnModule)
+        result->checkedInNewSolver = true;
     result->name = sourceModule.name;
     result->humanReadableName = sourceModule.humanReadableName;
     result->mode = mode;
     result->internalTypes.owningModule = result.get();
     result->interfaceTypes.owningModule = result.get();
-    result->allocator = sourceModule.allocator;
-    result->names = sourceModule.names;
-    if (FFlag::LuauModuleHoldsAstRoot)
-        result->root = sourceModule.root;
+    if (FFlag::LuauReferenceAllocatorInNewSolver)
+    {
+        result->allocator = sourceModule.allocator;
+        result->names = sourceModule.names;
+    }
 
     iceHandler->moduleName = sourceModule.name;
 
@@ -1642,7 +1349,7 @@ ModulePtr check(
     SimplifierPtr simplifier = newSimplifier(NotNull{&result->internalTypes}, builtinTypes);
     TypeFunctionRuntime typeFunctionRuntime{iceHandler, NotNull{&limits}};
 
-    typeFunctionRuntime.allowEvaluation = FFlag::LuauTypeFunResultInAutocomplete || sourceModule.parseErrors.empty();
+    typeFunctionRuntime.allowEvaluation = sourceModule.parseErrors.empty();
 
     ConstraintGenerator cg{
         result,
@@ -1653,7 +1360,6 @@ ModulePtr check(
         builtinTypes,
         iceHandler,
         parentScope,
-        typeFunctionScope,
         std::move(prepareModuleScope),
         logger.get(),
         NotNull{&dfg},
@@ -1669,7 +1375,6 @@ ModulePtr check(
         NotNull{&typeFunctionRuntime},
         NotNull(cg.rootScope),
         borrowConstraints(cg.constraints),
-        NotNull{&cg.scopeToFunction},
         result->name,
         moduleResolver,
         requireCycles,
@@ -1836,7 +1541,6 @@ ModulePtr Frontend::check(
                 NotNull{forAutocomplete ? &moduleResolverForAutocomplete : &moduleResolver},
                 NotNull{fileResolver},
                 environmentScope ? *environmentScope : globals.globalScope,
-                globals.globalTypeFunctionScope,
                 prepareModuleScopeWrap,
                 options,
                 typeCheckLimits,
@@ -1934,14 +1638,6 @@ std::pair<SourceNode*, SourceModule*> Frontend::getSourceNode(const ModuleName&
 
     sourceNode->name = sourceModule->name;
     sourceNode->humanReadableName = sourceModule->humanReadableName;
-
-    // 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);
-    }
-
     sourceNode->requireSet.clear();
     sourceNode->requireLocations.clear();
     sourceNode->dirtySourceModule = false;
@@ -2063,13 +1759,11 @@ std::string FrontendModuleResolver::getHumanReadableModuleName(const ModuleName&
     return frontend->fileResolver->getHumanReadableModuleName(moduleName);
 }
 
-bool FrontendModuleResolver::setModule(const ModuleName& moduleName, ModulePtr module)
+void FrontendModuleResolver::setModule(const ModuleName& moduleName, ModulePtr module)
 {
     std::scoped_lock lock(moduleMutex);
 
-    bool replaced = modules.count(moduleName) > 0;
     modules[moduleName] = std::move(module);
-    return replaced;
 }
 
 void FrontendModuleResolver::clearModules()

Analysis/src/Generalization.cpp

@@ -2,8 +2,6 @@
 
 #include "Luau/Generalization.h"
 
-#include "Luau/Common.h"
-#include "Luau/DenseHash.h"
 #include "Luau/Scope.h"
 #include "Luau/Type.h"
 #include "Luau/ToString.h"
@@ -12,7 +10,7 @@
 #include "Luau/VisitType.h"
 
 LUAU_FASTFLAG(LuauAutocompleteRefactorsForIncrementalAutocomplete)
-LUAU_FASTFLAGVARIABLE(LuauGeneralizationRemoveRecursiveUpperBound2)
+LUAU_FASTFLAGVARIABLE(LuauGeneralizationRemoveRecursiveUpperBound)
 
 namespace Luau
 {
@@ -30,6 +28,7 @@ struct MutatingGeneralizer : TypeOnceVisitor
     std::vector<TypePackId> genericPacks;
 
     bool isWithinFunction = false;
+    bool avoidSealingTables = false;
 
     MutatingGeneralizer(
         NotNull<TypeArena> arena,
@@ -37,7 +36,8 @@ struct MutatingGeneralizer : TypeOnceVisitor
         NotNull<Scope> scope,
         NotNull<DenseHashSet<TypeId>> cachedTypes,
         DenseHashMap<const void*, size_t> positiveTypes,
-        DenseHashMap<const void*, size_t> negativeTypes
+        DenseHashMap<const void*, size_t> negativeTypes,
+        bool avoidSealingTables
     )
         : TypeOnceVisitor(/* skipBoundTypes */ true)
         , arena(arena)
@@ -46,10 +46,11 @@ struct MutatingGeneralizer : TypeOnceVisitor
         , cachedTypes(cachedTypes)
         , positiveTypes(std::move(positiveTypes))
         , negativeTypes(std::move(negativeTypes))
+        , avoidSealingTables(avoidSealingTables)
     {
     }
 
-    void replace(DenseHashSet<TypeId>& seen, TypeId haystack, TypeId needle, TypeId replacement)
+    static void replace(DenseHashSet<TypeId>& seen, TypeId haystack, TypeId needle, TypeId replacement)
     {
         haystack = follow(haystack);
 
@@ -96,10 +97,6 @@ struct MutatingGeneralizer : TypeOnceVisitor
                 LUAU_ASSERT(onlyType != haystack);
                 emplaceType<BoundType>(asMutable(haystack), onlyType);
             }
-            else if (FFlag::LuauGeneralizationRemoveRecursiveUpperBound2 && ut->options.empty())
-            {
-                emplaceType<BoundType>(asMutable(haystack), builtinTypes->neverType);
-            }
 
             return;
         }
@@ -143,10 +140,6 @@ struct MutatingGeneralizer : TypeOnceVisitor
                 LUAU_ASSERT(onlyType != needle);
                 emplaceType<BoundType>(asMutable(needle), onlyType);
             }
-            else if (FFlag::LuauGeneralizationRemoveRecursiveUpperBound2 && it->parts.empty())
-            {
-                emplaceType<BoundType>(asMutable(needle), builtinTypes->unknownType);
-            }
 
             return;
         }
@@ -240,6 +233,53 @@ struct MutatingGeneralizer : TypeOnceVisitor
         else
         {
             TypeId ub = follow(ft->upperBound);
+            if (FFlag::LuauGeneralizationRemoveRecursiveUpperBound)
+            {
+
+                // If the upper bound is a union type or an intersection type,
+                // and one of it's members is the free type we're
+                // generalizing, don't include it in the upper bound. For a
+                // free type such as:
+                //
+                //  t1 where t1 = D <: 'a <: (A | B | C | t1)
+                //
+                // Naively replacing it with it's upper bound creates:
+                //
+                //  t1 where t1 = A | B | C | t1
+                //
+                // It makes sense to just optimize this and exclude the
+                // recursive component by semantic subtyping rules.
+
+                if (auto itv = get<IntersectionType>(ub))
+                {
+                    std::vector<TypeId> newIds;
+                    newIds.reserve(itv->parts.size());
+                    for (auto part : itv)
+                    {
+                        if (part != ty)
+                            newIds.push_back(part);
+                    }
+                    if (newIds.size() == 1)
+                        ub = newIds[0];
+                    else if (newIds.size() > 0)
+                        ub = arena->addType(IntersectionType{std::move(newIds)});
+                }
+                else if (auto utv = get<UnionType>(ub))
+                {
+                    std::vector<TypeId> newIds;
+                    newIds.reserve(utv->options.size());
+                    for (auto part : utv)
+                    {
+                        if (part != ty)
+                            newIds.push_back(part);
+                    }
+                    if (newIds.size() == 1)
+                        ub = newIds[0];
+                    else if (newIds.size() > 0)
+                        ub = arena->addType(UnionType{std::move(newIds)});
+                }
+            }
+
             if (FreeType* upperFree = getMutable<FreeType>(ub); upperFree && upperFree->lowerBound == ty)
                 upperFree->lowerBound = builtinTypes->neverType;
             else
@@ -289,7 +329,8 @@ struct MutatingGeneralizer : TypeOnceVisitor
         TableType* tt = getMutable<TableType>(ty);
         LUAU_ASSERT(tt);
 
-        tt->state = TableState::Sealed;
+        if (!avoidSealingTables)
+            tt->state = TableState::Sealed;
 
         return true;
     }
@@ -328,19 +369,26 @@ struct FreeTypeSearcher : TypeVisitor
     {
     }
 
-    Polarity polarity = Polarity::Positive;
+    enum Polarity
+    {
+        Positive,
+        Negative,
+        Both,
+    };
+
+    Polarity polarity = Positive;
 
     void flip()
     {
         switch (polarity)
         {
-        case Polarity::Positive:
-            polarity = Polarity::Negative;
+        case Positive:
+            polarity = Negative;
             break;
-        case Polarity::Negative:
-            polarity = Polarity::Positive;
+        case Negative:
+            polarity = Positive;
             break;
-        default:
+        case Both:
             break;
         }
     }
@@ -348,11 +396,11 @@ struct FreeTypeSearcher : TypeVisitor
     DenseHashSet<const void*> seenPositive{nullptr};
     DenseHashSet<const void*> seenNegative{nullptr};
 
-    bool seenWithCurrentPolarity(const void* ty)
+    bool seenWithPolarity(const void* ty)
     {
         switch (polarity)
         {
-        case Polarity::Positive:
+        case Positive:
         {
             if (seenPositive.contains(ty))
                 return true;
@@ -360,7 +408,7 @@ struct FreeTypeSearcher : TypeVisitor
             seenPositive.insert(ty);
             return false;
         }
-        case Polarity::Negative:
+        case Negative:
         {
             if (seenNegative.contains(ty))
                 return true;
@@ -368,7 +416,7 @@ struct FreeTypeSearcher : TypeVisitor
             seenNegative.insert(ty);
             return false;
         }
-        case Polarity::Mixed:
+        case Both:
         {
             if (seenPositive.contains(ty) && seenNegative.contains(ty))
                 return true;
@@ -377,8 +425,6 @@ struct FreeTypeSearcher : TypeVisitor
             seenNegative.insert(ty);
             return false;
         }
-        default:
-            LUAU_ASSERT(!"Unreachable");
         }
 
         return false;
@@ -392,7 +438,7 @@ struct FreeTypeSearcher : TypeVisitor
 
     bool visit(TypeId ty) override
     {
-        if (cachedTypes->contains(ty) || seenWithCurrentPolarity(ty))
+        if (cachedTypes->contains(ty) || seenWithPolarity(ty))
             return false;
 
         LUAU_ASSERT(ty);
@@ -401,7 +447,7 @@ struct FreeTypeSearcher : TypeVisitor
 
     bool visit(TypeId ty, const FreeType& ft) override
     {
-        if (cachedTypes->contains(ty) || seenWithCurrentPolarity(ty))
+        if (cachedTypes->contains(ty) || seenWithPolarity(ty))
             return false;
 
         if (!subsumes(scope, ft.scope))
@@ -409,18 +455,16 @@ struct FreeTypeSearcher : TypeVisitor
 
         switch (polarity)
         {
-        case Polarity::Positive:
+        case Positive:
             positiveTypes[ty]++;
             break;
-        case Polarity::Negative:
+        case Negative:
             negativeTypes[ty]++;
             break;
-        case Polarity::Mixed:
+        case Both:
             positiveTypes[ty]++;
             negativeTypes[ty]++;
             break;
-        default:
-            LUAU_ASSERT(!"Unreachable");
         }
 
         return true;
@@ -428,25 +472,23 @@ struct FreeTypeSearcher : TypeVisitor
 
     bool visit(TypeId ty, const TableType& tt) override
     {
-        if (cachedTypes->contains(ty) || seenWithCurrentPolarity(ty))
+        if (cachedTypes->contains(ty) || seenWithPolarity(ty))
             return false;
 
         if ((tt.state == TableState::Free || tt.state == TableState::Unsealed) && subsumes(scope, tt.scope))
         {
             switch (polarity)
             {
-            case Polarity::Positive:
+            case Positive:
                 positiveTypes[ty]++;
                 break;
-            case Polarity::Negative:
+            case Negative:
                 negativeTypes[ty]++;
                 break;
-            case Polarity::Mixed:
+            case Both:
                 positiveTypes[ty]++;
                 negativeTypes[ty]++;
                 break;
-            default:
-                LUAU_ASSERT(!"Unreachable");
             }
         }
 
@@ -459,7 +501,7 @@ struct FreeTypeSearcher : TypeVisitor
                 LUAU_ASSERT(prop.isShared() || FFlag::LuauAutocompleteRefactorsForIncrementalAutocomplete);
 
                 Polarity p = polarity;
-                polarity = Polarity::Mixed;
+                polarity = Both;
                 traverse(prop.type());
                 polarity = p;
             }
@@ -476,7 +518,7 @@ struct FreeTypeSearcher : TypeVisitor
 
     bool visit(TypeId ty, const FunctionType& ft) override
     {
-        if (cachedTypes->contains(ty) || seenWithCurrentPolarity(ty))
+        if (cachedTypes->contains(ty) || seenWithPolarity(ty))
             return false;
 
         flip();
@@ -495,7 +537,7 @@ struct FreeTypeSearcher : TypeVisitor
 
     bool visit(TypePackId tp, const FreeTypePack& ftp) override
     {
-        if (seenWithCurrentPolarity(tp))
+        if (seenWithPolarity(tp))
             return false;
 
         if (!subsumes(scope, ftp.scope))
@@ -503,18 +545,16 @@ struct FreeTypeSearcher : TypeVisitor
 
         switch (polarity)
         {
-        case Polarity::Positive:
+        case Positive:
             positiveTypes[tp]++;
             break;
-        case Polarity::Negative:
+        case Negative:
             negativeTypes[tp]++;
             break;
-        case Polarity::Mixed:
+        case Both:
             positiveTypes[tp]++;
             negativeTypes[tp]++;
             break;
-        default:
-            LUAU_ASSERT(!"Unreachable");
         }
 
         return true;
@@ -544,7 +584,7 @@ struct TypeCacher : TypeOnceVisitor
     {
     }
 
-    void cache(TypeId ty) const
+    void cache(TypeId ty)
     {
         cachedTypes->insert(ty);
     }
@@ -969,7 +1009,8 @@ std::optional<TypeId> generalize(
     NotNull<BuiltinTypes> builtinTypes,
     NotNull<Scope> scope,
     NotNull<DenseHashSet<TypeId>> cachedTypes,
-    TypeId ty
+    TypeId ty,
+    bool avoidSealingTables
 )
 {
     ty = follow(ty);
@@ -980,7 +1021,7 @@ std::optional<TypeId> generalize(
     FreeTypeSearcher fts{scope, cachedTypes};
     fts.traverse(ty);
 
-    MutatingGeneralizer gen{arena, builtinTypes, scope, cachedTypes, std::move(fts.positiveTypes), std::move(fts.negativeTypes)};
+    MutatingGeneralizer gen{arena, builtinTypes, scope, cachedTypes, std::move(fts.positiveTypes), std::move(fts.negativeTypes), avoidSealingTables};
 
     gen.traverse(ty);
 

Analysis/src/GlobalTypes.cpp

@@ -9,7 +9,6 @@ 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/Instantiation.cpp

@@ -11,7 +11,6 @@
 #include <algorithm>
 
 LUAU_FASTFLAG(LuauSolverV2)
-LUAU_FASTFLAG(LuauFreeTypesMustHaveBounds)
 
 namespace Luau
 {
@@ -164,7 +163,7 @@ TypeId ReplaceGenerics::clean(TypeId ty)
     }
     else
     {
-        return FFlag::LuauFreeTypesMustHaveBounds ? arena->freshType(builtinTypes, scope, level) : addType(FreeType{scope, level});
+        return addType(FreeType{scope, level});
     }
 }
 

Analysis/src/Linter.cpp

@@ -19,8 +19,6 @@ LUAU_FASTFLAG(LuauSolverV2)
 LUAU_FASTFLAG(LuauAttribute)
 LUAU_FASTFLAGVARIABLE(LintRedundantNativeAttribute)
 
-LUAU_FASTFLAG(LuauDeprecatedAttribute)
-
 namespace Luau
 {
 
@@ -2282,57 +2280,6 @@ 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))
@@ -2378,59 +2325,18 @@ private:
 
             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())
+            if (prop != tty->props.end() && prop->second.deprecated)
             {
-                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);
-                        }
-                    }
-                }
+                // 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);
             }
         }
     }
@@ -2449,26 +2355,6 @@ 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());
@@ -2478,63 +2364,6 @@ 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

@@ -20,26 +20,6 @@ LUAU_FASTFLAGVARIABLE(LuauIncrementalAutocompleteCommentDetection)
 namespace Luau
 {
 
-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.
-}
-
-Luau::LogLuauProc logLuau = &defaultLogLuau;
-
-void setLogLuau(LogLuauProc ll)
-{
-    logLuau = ll;
-}
-
-void resetLogLuauProc()
-{
-    logLuau = &defaultLogLuau;
-}
-
-
-
 static bool contains_DEPRECATED(Position pos, Comment comment)
 {
     if (comment.location.contains(pos))

Analysis/src/NonStrictTypeChecker.cpp

@@ -2,7 +2,6 @@
 #include "Luau/NonStrictTypeChecker.h"
 
 #include "Luau/Ast.h"
-#include "Luau/AstQuery.h"
 #include "Luau/Common.h"
 #include "Luau/Simplify.h"
 #include "Luau/Type.h"
@@ -15,15 +14,12 @@
 #include "Luau/TypeFunction.h"
 #include "Luau/Def.h"
 #include "Luau/ToString.h"
-#include "Luau/TypeUtils.h"
+#include "Luau/TypeFwd.h"
 
 #include <iostream>
 #include <iterator>
 
-LUAU_FASTFLAG(LuauFreeTypesMustHaveBounds)
-LUAU_FASTFLAGVARIABLE(LuauNonStrictVisitorImprovements)
-LUAU_FASTFLAGVARIABLE(LuauNewNonStrictWarnOnUnknownGlobals)
-LUAU_FASTFLAGVARIABLE(LuauNonStrictFuncDefErrorFix)
+LUAU_FASTFLAGVARIABLE(LuauCountSelfCallsNonstrict)
 
 namespace Luau
 {
@@ -215,7 +211,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->addType(FreeType{ftp->scope});
             TypePackId freeTail = arena->addTypePack(FreeTypePack{ftp->scope});
 
             TypePack* resultPack = emplaceTypePack<TypePack>(asMutable(pack));
@@ -345,9 +341,8 @@ struct NonStrictTypeChecker
 
     NonStrictContext visit(AstStatIf* ifStatement)
     {
-        NonStrictContext condB = visit(ifStatement->condition, ValueContext::RValue);
+        NonStrictContext condB = visit(ifStatement->condition);
         NonStrictContext branchContext;
-
         // If there is no else branch, don't bother generating warnings for the then branch - we can't prove there is an error
         if (ifStatement->elsebody)
         {
@@ -355,32 +350,17 @@ struct NonStrictTypeChecker
             NonStrictContext elseBody = visit(ifStatement->elsebody);
             branchContext = NonStrictContext::conjunction(builtinTypes, arena, thenBody, elseBody);
         }
-
         return NonStrictContext::disjunction(builtinTypes, arena, condB, branchContext);
     }
 
     NonStrictContext visit(AstStatWhile* whileStatement)
     {
-        if (FFlag::LuauNonStrictVisitorImprovements)
-        {
-            NonStrictContext condition = visit(whileStatement->condition, ValueContext::RValue);
-            NonStrictContext body = visit(whileStatement->body);
-            return NonStrictContext::disjunction(builtinTypes, arena, condition, body);
-        }
-        else
-            return {};
+        return {};
     }
 
     NonStrictContext visit(AstStatRepeat* repeatStatement)
     {
-        if (FFlag::LuauNonStrictVisitorImprovements)
-        {
-            NonStrictContext body = visit(repeatStatement->body);
-            NonStrictContext condition = visit(repeatStatement->condition, ValueContext::RValue);
-            return NonStrictContext::disjunction(builtinTypes, arena, body, condition);
-        }
-        else
-            return {};
+        return {};
     }
 
     NonStrictContext visit(AstStatBreak* breakStatement)
@@ -395,94 +375,49 @@ struct NonStrictTypeChecker
 
     NonStrictContext visit(AstStatReturn* returnStatement)
     {
-        if (FFlag::LuauNonStrictVisitorImprovements)
-        {
-            // TODO: this is believing existing code, but i'm not sure if this makes sense
-            // for how the contexts are handled
-            for (AstExpr* expr : returnStatement->list)
-                visit(expr, ValueContext::RValue);
-        }
-
         return {};
     }
 
     NonStrictContext visit(AstStatExpr* expr)
     {
-        return visit(expr->expr, ValueContext::RValue);
+        return visit(expr->expr);
     }
 
     NonStrictContext visit(AstStatLocal* local)
     {
         for (AstExpr* rhs : local->values)
-            visit(rhs, ValueContext::RValue);
+            visit(rhs);
         return {};
     }
 
     NonStrictContext visit(AstStatFor* forStatement)
     {
-        if (FFlag::LuauNonStrictVisitorImprovements)
-        {
-            // TODO: throwing out context based on same principle as existing code?
-            if (forStatement->from)
-                visit(forStatement->from, ValueContext::RValue);
-            if (forStatement->to)
-                visit(forStatement->to, ValueContext::RValue);
-            if (forStatement->step)
-                visit(forStatement->step, ValueContext::RValue);
-            return visit(forStatement->body);
-        }
-        else
-        {
-            return {};
-        }
+        return {};
     }
 
     NonStrictContext visit(AstStatForIn* forInStatement)
     {
-        if (FFlag::LuauNonStrictVisitorImprovements)
-        {
-            for (AstExpr* rhs : forInStatement->values)
-                visit(rhs, ValueContext::RValue);
-            return visit(forInStatement->body);
-        }
-        else
-        {
-            return {};
-        }
+        return {};
     }
 
     NonStrictContext visit(AstStatAssign* assign)
     {
-        if (FFlag::LuauNonStrictVisitorImprovements)
-        {
-            for (AstExpr* lhs : assign->vars)
-                visit(lhs, ValueContext::LValue);
-            for (AstExpr* rhs : assign->values)
-                visit(rhs, ValueContext::RValue);
-        }
-
         return {};
     }
 
     NonStrictContext visit(AstStatCompoundAssign* compoundAssign)
     {
-        if (FFlag::LuauNonStrictVisitorImprovements)
-        {
-            visit(compoundAssign->var, ValueContext::LValue);
-            visit(compoundAssign->value, ValueContext::RValue);
-        }
-
         return {};
     }
 
     NonStrictContext visit(AstStatFunction* statFn)
     {
-        return visit(statFn->func, ValueContext::RValue);
+        return visit(statFn->func);
     }
 
     NonStrictContext visit(AstStatLocalFunction* localFn)
     {
-        return visit(localFn->func, ValueContext::RValue);
+        return visit(localFn->func);
     }
 
     NonStrictContext visit(AstStatTypeAlias* typeAlias)
@@ -512,22 +447,14 @@ struct NonStrictTypeChecker
 
     NonStrictContext visit(AstStatError* error)
     {
-        if (FFlag::LuauNonStrictVisitorImprovements)
-        {
-            for (AstStat* stat : error->statements)
-                visit(stat);
-            for (AstExpr* expr : error->expressions)
-                visit(expr, ValueContext::RValue);
-        }
-
         return {};
     }
 
-    NonStrictContext visit(AstExpr* expr, ValueContext context)
+    NonStrictContext visit(AstExpr* expr)
     {
         auto pusher = pushStack(expr);
         if (auto e = expr->as<AstExprGroup>())
-            return visit(e, context);
+            return visit(e);
         else if (auto e = expr->as<AstExprConstantNil>())
             return visit(e);
         else if (auto e = expr->as<AstExprConstantBool>())
@@ -537,17 +464,17 @@ struct NonStrictTypeChecker
         else if (auto e = expr->as<AstExprConstantString>())
             return visit(e);
         else if (auto e = expr->as<AstExprLocal>())
-            return visit(e, context);
+            return visit(e);
         else if (auto e = expr->as<AstExprGlobal>())
-            return visit(e, context);
+            return visit(e);
         else if (auto e = expr->as<AstExprVarargs>())
             return visit(e);
         else if (auto e = expr->as<AstExprCall>())
             return visit(e);
         else if (auto e = expr->as<AstExprIndexName>())
-            return visit(e, context);
+            return visit(e);
         else if (auto e = expr->as<AstExprIndexExpr>())
-            return visit(e, context);
+            return visit(e);
         else if (auto e = expr->as<AstExprFunction>())
             return visit(e);
         else if (auto e = expr->as<AstExprTable>())
@@ -571,12 +498,9 @@ struct NonStrictTypeChecker
         }
     }
 
-    NonStrictContext visit(AstExprGroup* group, ValueContext context)
+    NonStrictContext visit(AstExprGroup* group)
     {
-        if (FFlag::LuauNonStrictVisitorImprovements)
-            return visit(group->expr, context);
-        else
-            return {};
+        return {};
     }
 
     NonStrictContext visit(AstExprConstantNil* expr)
@@ -599,36 +523,34 @@ struct NonStrictTypeChecker
         return {};
     }
 
-    NonStrictContext visit(AstExprLocal* local, ValueContext context)
+    NonStrictContext visit(AstExprLocal* local)
     {
         return {};
     }
 
-    NonStrictContext visit(AstExprGlobal* global, ValueContext context)
+    NonStrictContext visit(AstExprGlobal* global)
     {
-        if (FFlag::LuauNewNonStrictWarnOnUnknownGlobals)
-        {
-            // We don't file unknown symbols for LValues.
-            if (context == ValueContext::LValue)
-                return {};
-
-            NotNull<Scope> scope = stack.back();
-            if (!scope->lookup(global->name))
-            {
-                reportError(UnknownSymbol{global->name.value, UnknownSymbol::Binding}, global->location);
-            }
-        }
-
         return {};
     }
 
-    NonStrictContext visit(AstExprVarargs* varargs)
+    NonStrictContext visit(AstExprVarargs* global)
     {
         return {};
     }
 
     NonStrictContext visit(AstExprCall* call)
     {
+        if (FFlag::LuauCountSelfCallsNonstrict)
+            return visitCall(call);
+        else
+            return visitCall_DEPRECATED(call);
+    }
+
+    // rename this to `visit` when `FFlag::LuauCountSelfCallsNonstrict` is removed, and clean up above `visit`.
+    NonStrictContext visitCall(AstExprCall* call)
+    {
+        LUAU_ASSERT(FFlag::LuauCountSelfCallsNonstrict);
+
         NonStrictContext fresh{};
         TypeId* originalCallTy = module->astOriginalCallTypes.find(call->func);
         if (!originalCallTy)
@@ -737,24 +659,117 @@ struct NonStrictTypeChecker
         return fresh;
     }
 
-    NonStrictContext visit(AstExprIndexName* indexName, ValueContext context)
+    // Remove with `FFlag::LuauCountSelfCallsNonstrict` clean up.
+    NonStrictContext visitCall_DEPRECATED(AstExprCall* call)
     {
-        if (FFlag::LuauNonStrictVisitorImprovements)
-            return visit(indexName->expr, context);
-        else
-            return {};
+        LUAU_ASSERT(!FFlag::LuauCountSelfCallsNonstrict);
+
+        NonStrictContext fresh{};
+        TypeId* originalCallTy = module->astOriginalCallTypes.find(call->func);
+        if (!originalCallTy)
+            return fresh;
+
+        TypeId fnTy = *originalCallTy;
+        if (auto fn = get<FunctionType>(follow(fnTy)))
+        {
+            if (fn->isCheckedFunction)
+            {
+                // We know fn is a checked function, which means it looks like:
+                // (S1, ... SN) -> T &
+                // (~S1, unknown^N-1) -> error &
+                // (unknown, ~S2, unknown^N-2) -> error
+                // ...
+                // ...
+                // (unknown^N-1, ~S_N) -> error
+                std::vector<TypeId> argTypes;
+                argTypes.reserve(call->args.size);
+                // Pad out the arg types array with the types you would expect to see
+                TypePackIterator curr = begin(fn->argTypes);
+                TypePackIterator fin = end(fn->argTypes);
+                while (curr != fin)
+                {
+                    argTypes.push_back(*curr);
+                    ++curr;
+                }
+                if (auto argTail = curr.tail())
+                {
+                    if (const VariadicTypePack* vtp = get<VariadicTypePack>(follow(*argTail)))
+                    {
+                        while (argTypes.size() < call->args.size)
+                        {
+                            argTypes.push_back(vtp->ty);
+                        }
+                    }
+                }
+
+                std::string functionName = getFunctionNameAsString(*call->func).value_or("");
+                if (call->args.size > argTypes.size())
+                {
+                    // We are passing more arguments than we expect, so we should error
+                    reportError(CheckedFunctionIncorrectArgs{functionName, argTypes.size(), call->args.size}, call->location);
+                    return fresh;
+                }
+
+                for (size_t i = 0; i < call->args.size; i++)
+                {
+                    // For example, if the arg is "hi"
+                    // The actual arg type is string
+                    // The expected arg type is number
+                    // The type of the argument in the overload is ~number
+                    // We will compare arg and ~number
+                    AstExpr* arg = call->args.data[i];
+                    TypeId expectedArgType = argTypes[i];
+                    std::shared_ptr<const NormalizedType> norm = normalizer.normalize(expectedArgType);
+                    DefId def = dfg->getDef(arg);
+                    TypeId runTimeErrorTy;
+                    // If we're dealing with any, negating any will cause all subtype tests to fail
+                    // However, when someone calls this function, they're going to want to be able to pass it anything,
+                    // for that reason, we manually inject never into the context so that the runtime test will always pass.
+                    if (!norm)
+                        reportError(NormalizationTooComplex{}, arg->location);
+
+                    if (norm && get<AnyType>(norm->tops))
+                        runTimeErrorTy = builtinTypes->neverType;
+                    else
+                        runTimeErrorTy = getOrCreateNegation(expectedArgType);
+                    fresh.addContext(def, runTimeErrorTy);
+                }
+
+                // Populate the context and now iterate through each of the arguments to the call to find out if we satisfy the types
+                for (size_t i = 0; i < call->args.size; i++)
+                {
+                    AstExpr* arg = call->args.data[i];
+                    if (auto runTimeFailureType = willRunTimeError(arg, fresh))
+                        reportError(CheckedFunctionCallError{argTypes[i], *runTimeFailureType, functionName, i}, arg->location);
+                }
+
+                if (call->args.size < argTypes.size())
+                {
+                    // We are passing fewer arguments than we expect
+                    // so we need to ensure that the rest of the args are optional.
+                    bool remainingArgsOptional = true;
+                    for (size_t i = call->args.size; i < argTypes.size(); i++)
+                        remainingArgsOptional = remainingArgsOptional && isOptional(argTypes[i]);
+                    if (!remainingArgsOptional)
+                    {
+                        reportError(CheckedFunctionIncorrectArgs{functionName, argTypes.size(), call->args.size}, call->location);
+                        return fresh;
+                    }
+                }
+            }
+        }
+
+        return fresh;
     }
 
-    NonStrictContext visit(AstExprIndexExpr* indexExpr, ValueContext context)
+    NonStrictContext visit(AstExprIndexName* indexName)
     {
-        if (FFlag::LuauNonStrictVisitorImprovements)
-        {
-            NonStrictContext expr = visit(indexExpr->expr, context);
-            NonStrictContext index = visit(indexExpr->index, ValueContext::RValue);
-            return NonStrictContext::disjunction(builtinTypes, arena, expr, index);
-        }
-        else
-            return {};
+        return {};
+    }
+
+    NonStrictContext visit(AstExprIndexExpr* indexExpr)
+    {
+        return {};
     }
 
     NonStrictContext visit(AstExprFunction* exprFn)
@@ -765,17 +780,7 @@ struct NonStrictTypeChecker
         for (AstLocal* local : exprFn->args)
         {
             if (std::optional<TypeId> ty = willRunTimeErrorFunctionDefinition(local, remainder))
-            {
-                if (FFlag::LuauNonStrictFuncDefErrorFix)
-                {
-                    const char* debugname = exprFn->debugname.value;
-                    reportError(NonStrictFunctionDefinitionError{debugname ? debugname : "", local->name.value, *ty}, local->location);
-                }
-                else
-                {
-                    reportError(NonStrictFunctionDefinitionError{exprFn->debugname.value, local->name.value, *ty}, local->location);
-                }
-            }
+                reportError(NonStrictFunctionDefinitionError{exprFn->debugname.value, local->name.value, *ty}, local->location);
             remainder.remove(dfg->getDef(local));
         }
         return remainder;
@@ -783,74 +788,39 @@ struct NonStrictTypeChecker
 
     NonStrictContext visit(AstExprTable* table)
     {
-        if (FFlag::LuauNonStrictVisitorImprovements)
-        {
-            for (auto [_, key, value] : table->items)
-            {
-                if (key)
-                    visit(key, ValueContext::RValue);
-                visit(value, ValueContext::RValue);
-            }
-        }
-
         return {};
     }
 
     NonStrictContext visit(AstExprUnary* unary)
     {
-        if (FFlag::LuauNonStrictVisitorImprovements)
-            return visit(unary->expr, ValueContext::RValue);
-        else
-            return {};
+        return {};
     }
 
     NonStrictContext visit(AstExprBinary* binary)
     {
-        if (FFlag::LuauNonStrictVisitorImprovements)
-        {
-            NonStrictContext lhs = visit(binary->left, ValueContext::RValue);
-            NonStrictContext rhs = visit(binary->right, ValueContext::RValue);
-            return NonStrictContext::disjunction(builtinTypes, arena, lhs, rhs);
-        }
-        else
-            return {};
+        return {};
     }
 
     NonStrictContext visit(AstExprTypeAssertion* typeAssertion)
     {
-        if (FFlag::LuauNonStrictVisitorImprovements)
-            return visit(typeAssertion->expr, ValueContext::RValue);
-        else
-            return {};
+        return {};
     }
 
     NonStrictContext visit(AstExprIfElse* ifElse)
     {
-        NonStrictContext condB = visit(ifElse->condition, ValueContext::RValue);
-        NonStrictContext thenB = visit(ifElse->trueExpr, ValueContext::RValue);
-        NonStrictContext elseB = visit(ifElse->falseExpr, ValueContext::RValue);
+        NonStrictContext condB = visit(ifElse->condition);
+        NonStrictContext thenB = visit(ifElse->trueExpr);
+        NonStrictContext elseB = visit(ifElse->falseExpr);
         return NonStrictContext::disjunction(builtinTypes, arena, condB, NonStrictContext::conjunction(builtinTypes, arena, thenB, elseB));
     }
 
     NonStrictContext visit(AstExprInterpString* interpString)
     {
-        if (FFlag::LuauNonStrictVisitorImprovements)
-        {
-            for (AstExpr* expr : interpString->expressions)
-                visit(expr, ValueContext::RValue);
-        }
-
         return {};
     }
 
     NonStrictContext visit(AstExprError* error)
     {
-        if (FFlag::LuauNonStrictVisitorImprovements)
-        {
-            for (AstExpr* expr : error->expressions)
-                visit(expr, ValueContext::RValue);
-        }
-
         return {};
     }
 

Analysis/src/Normalize.cpp

@@ -17,15 +17,12 @@
 
 LUAU_FASTFLAGVARIABLE(DebugLuauCheckNormalizeInvariant)
 
-LUAU_FASTFLAGVARIABLE(LuauNormalizeNegatedErrorToAnError)
-LUAU_FASTFLAGVARIABLE(LuauNormalizeIntersectErrorToAnError)
-LUAU_FASTINTVARIABLE(LuauNormalizeCacheLimit, 100000)
+LUAU_FASTINTVARIABLE(LuauNormalizeCacheLimit, 100000);
+LUAU_FASTFLAG(LuauSolverV2);
+
 LUAU_FASTINTVARIABLE(LuauNormalizeIntersectionLimit, 200)
-LUAU_FASTINTVARIABLE(LuauNormalizeUnionLimit, 100)
-LUAU_FASTFLAG(LuauSolverV2)
-LUAU_FASTFLAGVARIABLE(LuauFixInfiniteRecursionInNormalization)
-LUAU_FASTFLAGVARIABLE(LuauNormalizedBufferIsNotUnknown)
-LUAU_FASTFLAGVARIABLE(LuauNormalizeLimitFunctionSet)
+LUAU_FASTFLAGVARIABLE(LuauNormalizationTracksCyclicPairsThroughInhabitance);
+LUAU_FASTFLAGVARIABLE(LuauIntersectNormalsNeedsToTrackResourceLimits);
 
 namespace Luau
 {
@@ -307,9 +304,7 @@ bool NormalizedType::isUnknown() const
 
     // Otherwise, we can still be unknown!
     bool hasAllPrimitives = isPrim(booleans, PrimitiveType::Boolean) && isPrim(nils, PrimitiveType::NilType) && isNumber(numbers) &&
-                            strings.isString() &&
-                            (FFlag::LuauNormalizedBufferIsNotUnknown ? isThread(threads) && isBuffer(buffers)
-                                                                     : isPrim(threads, PrimitiveType::Thread) && isThread(threads));
+                            strings.isString() && isPrim(threads, PrimitiveType::Thread) && isThread(threads);
 
     // Check is class
     bool isTopClass = false;
@@ -584,7 +579,7 @@ NormalizationResult Normalizer::isIntersectionInhabited(TypeId left, TypeId righ
 {
     left = follow(left);
     right = follow(right);
-    // We're asking if intersection is inhabited between left and right but we've already seen them ....
+    // We're asking if intersection is inahbited between left and right but we've already seen them ....
 
     if (cacheInhabitance)
     {
@@ -1690,13 +1685,6 @@ NormalizationResult Normalizer::unionNormals(NormalizedType& here, const Normali
             return res;
     }
 
-    if (FFlag::LuauNormalizeLimitFunctionSet)
-    {
-        // 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);
 
@@ -1708,7 +1696,6 @@ 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;
 }
 
@@ -1748,7 +1735,7 @@ NormalizationResult Normalizer::intersectNormalWithNegationTy(TypeId toNegate, N
     return NormalizationResult::True;
 }
 
-// See above for an explanation of `ignoreSmallerTyvars`.
+// See above for an explaination of `ignoreSmallerTyvars`.
 NormalizationResult Normalizer::unionNormalWithTy(
     NormalizedType& here,
     TypeId there,
@@ -2298,24 +2285,9 @@ void Normalizer::intersectClassesWithClass(NormalizedClassType& heres, TypeId th
         else if (isSubclass(there, hereTy))
         {
             TypeIds negations = std::move(hereNegations);
-            bool emptyIntersectWithNegation = false;
 
             for (auto nIt = negations.begin(); nIt != negations.end();)
             {
-                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
-                    // superclass of this type, e.g.:
-                    //
-                    //  Dog & ~Animal
-                    //
-                    // Clearly this intersects to never, so we mark this class as
-                    // being removed from the normalized class type.
-                    emptyIntersectWithNegation = true;
-                    break;
-                }
-
                 if (!isSubclass(*nIt, there))
                 {
                     nIt = negations.erase(nIt);
@@ -2328,8 +2300,7 @@ void Normalizer::intersectClassesWithClass(NormalizedClassType& heres, TypeId th
 
             it = heres.ordering.erase(it);
             heres.classes.erase(hereTy);
-            if (!emptyIntersectWithNegation)
-                heres.pushPair(there, std::move(negations));
+            heres.pushPair(there, std::move(negations));
             break;
         }
         // If the incoming class is a superclass of the current class, we don't
@@ -2614,31 +2585,11 @@ std::optional<TypeId> Normalizer::intersectionOfTables(TypeId here, TypeId there
                 {
                     if (tprop.readTy.has_value())
                     {
-                        if (FFlag::LuauFixInfiniteRecursionInNormalization)
+                        // if the intersection of the read types of a property is uninhabited, the whole table is `never`.
+                        // We've seen these table prop elements before and we're about to ask if their intersection
+                        // is inhabited
+                        if (FFlag::LuauNormalizationTracksCyclicPairsThroughInhabitance)
                         {
-                            TypeId ty = simplifyIntersection(builtinTypes, NotNull{arena}, *hprop.readTy, *tprop.readTy).result;
-
-                            // If any property is going to get mapped to `never`, we can just call the entire table `never`.
-                            // Since this check is syntactic, we may sometimes miss simplifying tables with complex uninhabited properties.
-                            // Prior versions of this code attempted to do this semantically using the normalization machinery, but this
-                            // mistakenly causes infinite loops when giving more complex recursive table types. As it stands, this approach
-                            // will continue to scale as simplification is improved, but we may wish to reintroduce the semantic approach
-                            // once we have revisited the usage of seen sets systematically (and possibly with some additional guarding to recognize
-                            // when types are infinitely-recursive with non-pointer identical instances of them, or some guard to prevent that
-                            // construction altogether). See also: `gh1632_no_infinite_recursion_in_normalization`
-                            if (get<NeverType>(ty))
-                                return {builtinTypes->neverType};
-
-                            prop.readTy = ty;
-                            hereSubThere &= (ty == hprop.readTy);
-                            thereSubHere &= (ty == tprop.readTy);
-                        }
-                        else
-                        {
-                            // if the intersection of the read types of a property is uninhabited, the whole table is `never`.
-                            // We've seen these table prop elements before and we're about to ask if their intersection
-                            // is inhabited
-
                             auto pair1 = std::pair{*hprop.readTy, *tprop.readTy};
                             auto pair2 = std::pair{*tprop.readTy, *hprop.readTy};
                             if (seenTablePropPairs.contains(pair1) || seenTablePropPairs.contains(pair2))
@@ -2653,8 +2604,6 @@ std::optional<TypeId> Normalizer::intersectionOfTables(TypeId here, TypeId there
                                 seenTablePropPairs.insert(pair2);
                             }
 
-                            // FIXME(ariel): this is being added in a flag removal, so not changing the semantics here, but worth noting that this
-                            // fresh `seenSet` is definitely a bug. we already have `seenSet` from the parameter that _should_ have been used here.
                             Set<TypeId> seenSet{nullptr};
                             NormalizationResult res = isIntersectionInhabited(*hprop.readTy, *tprop.readTy, seenTablePropPairs, seenSet);
 
@@ -2668,6 +2617,34 @@ std::optional<TypeId> Normalizer::intersectionOfTables(TypeId here, TypeId there
                             hereSubThere &= (ty == hprop.readTy);
                             thereSubHere &= (ty == tprop.readTy);
                         }
+                        else
+                        {
+
+                            if (seenSet.contains(*hprop.readTy) && seenSet.contains(*tprop.readTy))
+                            {
+                                seenSet.erase(*hprop.readTy);
+                                seenSet.erase(*tprop.readTy);
+                                return {builtinTypes->neverType};
+                            }
+                            else
+                            {
+                                seenSet.insert(*hprop.readTy);
+                                seenSet.insert(*tprop.readTy);
+                            }
+
+                            NormalizationResult res = isIntersectionInhabited(*hprop.readTy, *tprop.readTy);
+
+                            seenSet.erase(*hprop.readTy);
+                            seenSet.erase(*tprop.readTy);
+
+                            if (NormalizationResult::True != res)
+                                return {builtinTypes->neverType};
+
+                            TypeId ty = simplifyIntersection(builtinTypes, NotNull{arena}, *hprop.readTy, *tprop.readTy).result;
+                            prop.readTy = ty;
+                            hereSubThere &= (ty == hprop.readTy);
+                            thereSubHere &= (ty == tprop.readTy);
+                        }
                     }
                     else
                     {
@@ -3063,12 +3040,15 @@ NormalizationResult Normalizer::intersectTyvarsWithTy(
     return NormalizationResult::True;
 }
 
-// See above for an explanation of `ignoreSmallerTyvars`.
+// See above for an explaination of `ignoreSmallerTyvars`.
 NormalizationResult Normalizer::intersectNormals(NormalizedType& here, const NormalizedType& there, int ignoreSmallerTyvars)
 {
-    RecursionCounter _rc(&sharedState->counters.recursionCount);
-    if (!withinResourceLimits())
-        return NormalizationResult::HitLimits;
+    if (FFlag::LuauIntersectNormalsNeedsToTrackResourceLimits)
+    {
+        RecursionCounter _rc(&sharedState->counters.recursionCount);
+        if (!withinResourceLimits())
+            return NormalizationResult::HitLimits;
+    }
 
     if (!get<NeverType>(there.tops))
     {
@@ -3081,17 +3061,11 @@ NormalizationResult Normalizer::intersectNormals(NormalizedType& here, const Nor
         return unionNormals(here, there, ignoreSmallerTyvars);
     }
 
-    // Limit based on worst-case expansion of the table/function intersections
+    // Limit based on worst-case expansion of the table intersection
     // 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 (FFlag::LuauNormalizeLimitFunctionSet)
-    {
-        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);
@@ -3227,7 +3201,7 @@ NormalizationResult Normalizer::intersectNormalWithTy(
     {
         TypeId errors = here.errors;
         clearNormal(here);
-        here.errors = FFlag::LuauNormalizeIntersectErrorToAnError && get<ErrorType>(errors) ? errors : there;
+        here.errors = errors;
     }
     else if (const PrimitiveType* ptv = get<PrimitiveType>(there))
     {
@@ -3324,18 +3298,8 @@ NormalizationResult Normalizer::intersectNormalWithTy(
             clearNormal(here);
             return NormalizationResult::True;
         }
-        else if (FFlag::LuauNormalizeNegatedErrorToAnError && 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 = FFlag::LuauNormalizeIntersectErrorToAnError && 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.

Analysis/src/Quantify.cpp

@@ -107,4 +107,134 @@ 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,15 +54,7 @@ RefinementId RefinementArena::proposition(const RefinementKey* key, TypeId discr
     if (!key)
         return nullptr;
 
-    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})};
+    return NotNull{allocator.allocate(Proposition{key, discriminantTy})};
 }
 
 } // namespace Luau

Analysis/src/RequireTracer.cpp

@@ -65,7 +65,7 @@ struct RequireTracer : AstVisitor
         return true;
     }
 
-    AstExpr* getDependent_DEPRECATED(AstExpr* node)
+    AstExpr* getDependent(AstExpr* node)
     {
         if (AstExprLocal* expr = node->as<AstExprLocal>())
             return locals[expr->local];
@@ -78,27 +78,6 @@ struct RequireTracer : AstVisitor
         else
             return nullptr;
     }
-    AstNode* getDependent(AstNode* node)
-    {
-        if (AstExprLocal* expr = node->as<AstExprLocal>())
-            return locals[expr->local];
-        else if (AstExprIndexName* expr = node->as<AstExprIndexName>())
-            return expr->expr;
-        else if (AstExprIndexExpr* expr = node->as<AstExprIndexExpr>())
-            return expr->expr;
-        else if (AstExprCall* expr = node->as<AstExprCall>(); expr && expr->self)
-            return expr->func->as<AstExprIndexName>()->expr;
-        else if (AstExprGroup* expr = node->as<AstExprGroup>())
-            return expr->expr;
-        else if (AstExprTypeAssertion* expr = node->as<AstExprTypeAssertion>())
-            return expr->annotation;
-        else if (AstTypeGroup* expr = node->as<AstTypeGroup>())
-            return expr->type;
-        else if (AstTypeTypeof* expr = node->as<AstTypeTypeof>())
-            return expr->expr;
-        else
-            return nullptr;
-    }
 
     void process()
     {
@@ -112,15 +91,13 @@ struct RequireTracer : AstVisitor
 
         // 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]))
+            if (AstExpr* 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];
+            AstExpr* 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))
@@ -128,22 +105,19 @@ struct RequireTracer : AstVisitor
 
             std::optional<ModuleInfo> info;
 
-            if (AstNode* dep = getDependent(expr))
+            if (AstExpr* 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);
+                // 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 if (AstExpr* asExpr = expr->asExpr())
+            else
             {
-                info = fileResolver->resolveModule(&moduleContext, asExpr);
+                info = fileResolver->resolveModule(&moduleContext, expr);
             }
 
             if (info)
@@ -176,7 +150,7 @@ struct RequireTracer : AstVisitor
     ModuleName currentModuleName;
 
     DenseHashMap<AstLocal*, AstExpr*> locals;
-    std::vector<AstNode*> work;
+    std::vector<AstExpr*> work;
     std::vector<AstExprCall*> requireCalls;
 };
 

Analysis/src/Scope.cpp

@@ -84,17 +84,6 @@ 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())
@@ -192,29 +181,6 @@ 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

@@ -31,16 +31,16 @@ struct TypeSimplifier
 
     int recursionDepth = 0;
 
-    TypeId mkNegation(TypeId ty) const;
+    TypeId mkNegation(TypeId ty);
 
     TypeId intersectFromParts(std::set<TypeId> parts);
 
-    TypeId intersectUnionWithType(TypeId left, TypeId right);
+    TypeId intersectUnionWithType(TypeId unionTy, TypeId right);
     TypeId intersectUnions(TypeId left, TypeId right);
-    TypeId intersectNegatedUnion(TypeId left, TypeId right);
+    TypeId intersectNegatedUnion(TypeId unionTy, TypeId right);
 
-    TypeId intersectTypeWithNegation(TypeId left, TypeId right);
-    TypeId intersectNegations(TypeId left, TypeId right);
+    TypeId intersectTypeWithNegation(TypeId a, TypeId b);
+    TypeId intersectNegations(TypeId a, TypeId b);
 
     TypeId intersectIntersectionWithType(TypeId left, TypeId right);
 
@@ -48,8 +48,8 @@ struct TypeSimplifier
     // unions, intersections, or negations.
     std::optional<TypeId> basicIntersect(TypeId left, TypeId right);
 
-    TypeId intersect(TypeId left, TypeId right);
-    TypeId union_(TypeId left, TypeId right);
+    TypeId intersect(TypeId ty, TypeId discriminant);
+    TypeId union_(TypeId ty, TypeId discriminant);
 
     TypeId simplify(TypeId ty);
     TypeId simplify(TypeId ty, DenseHashSet<TypeId>& seen);
@@ -573,7 +573,7 @@ Relation relate(TypeId left, TypeId right)
     return relate(left, right, seen);
 }
 
-TypeId TypeSimplifier::mkNegation(TypeId ty) const
+TypeId TypeSimplifier::mkNegation(TypeId ty)
 {
     TypeId result = nullptr;
 

Analysis/src/Substitution.cpp

@@ -13,7 +13,6 @@ LUAU_FASTINTVARIABLE(LuauTarjanChildLimit, 10000)
 LUAU_FASTFLAG(LuauSolverV2)
 LUAU_FASTINTVARIABLE(LuauTarjanPreallocationSize, 256)
 LUAU_FASTFLAG(LuauSyntheticErrors)
-LUAU_FASTFLAG(LuauDeprecatedAttribute)
 
 namespace Luau
 {
@@ -103,8 +102,6 @@ static TypeId shallowClone(TypeId ty, TypeArena& dest, const TxnLog* log, bool a
             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>)

Analysis/src/Subtyping.cpp

@@ -22,7 +22,7 @@
 #include <algorithm>
 
 LUAU_FASTFLAGVARIABLE(DebugLuauSubtypingCheckPathValidity)
-LUAU_FASTFLAGVARIABLE(LuauSubtypingStopAtNormFail)
+LUAU_FASTFLAGVARIABLE(LuauRetrySubtypingWithoutHiddenPack)
 
 namespace Luau
 {
@@ -416,14 +416,6 @@ SubtypingResult Subtyping::isSubtype(TypeId subTy, TypeId superTy, NotNull<Scope
 
     SubtypingResult result = isCovariantWith(env, subTy, superTy, scope);
 
-    if (FFlag::LuauSubtypingStopAtNormFail && result.normalizationTooComplex)
-    {
-        if (result.isCacheable)
-            resultCache[{subTy, superTy}] = result;
-
-        return result;
-    }
-
     for (const auto& [subTy, bounds] : env.mappedGenerics)
     {
         const auto& lb = bounds.lowerBound;
@@ -601,12 +593,7 @@ SubtypingResult Subtyping::isCovariantWith(SubtypingEnvironment& env, TypeId sub
         if (!result.isSubtype && !result.normalizationTooComplex)
         {
             SubtypingResult semantic = isCovariantWith(env, normalizer->normalize(subTy), normalizer->normalize(superTy), scope);
-
-            if (FFlag::LuauSubtypingStopAtNormFail && semantic.normalizationTooComplex)
-            {
-                result = semantic;
-            }
-            else if (semantic.isSubtype)
+            if (semantic.isSubtype)
             {
                 semantic.reasoning.clear();
                 result = semantic;
@@ -621,12 +608,7 @@ SubtypingResult Subtyping::isCovariantWith(SubtypingEnvironment& env, TypeId sub
         if (!result.isSubtype && !result.normalizationTooComplex)
         {
             SubtypingResult semantic = isCovariantWith(env, normalizer->normalize(subTy), normalizer->normalize(superTy), scope);
-
-            if (FFlag::LuauSubtypingStopAtNormFail && semantic.normalizationTooComplex)
-            {
-                result = semantic;
-            }
-            else if (semantic.isSubtype)
+            if (semantic.isSubtype)
             {
                 // Clear the semantic reasoning, as any reasonings within
                 // potentially contain invalid paths.
@@ -772,8 +754,7 @@ 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, TypePath::Index::Variant::Pack})
-        );
+        results.push_back(isCovariantWith(env, subHead[i], superHead[i], scope).withBothComponent(TypePath::Index{i}));
 
     // Handle mismatched head sizes
 
@@ -786,7 +767,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, TypePath::Index::Variant::Pack}));
+                                          .withSuperComponent(TypePath::Index{i}));
             }
             else if (auto gt = get<GenericTypePack>(*subTail))
             {
@@ -840,7 +821,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, TypePath::Index::Variant::Pack})
+                                          .withSubComponent(TypePath::Index{i})
                                           .withSuperPath(TypePath::PathBuilder().tail().variadic().build()));
             }
             else if (auto gt = get<GenericTypePack>(*superTail))
@@ -878,7 +859,7 @@ SubtypingResult Subtyping::isCovariantWith(SubtypingEnvironment& env, TypePackId
             else
                 return SubtypingResult{false}
                     .withSuperComponent(TypePath::PackField::Tail)
-                    .withError({scope->location, UnexpectedTypePackInSubtyping{*superTail}});
+                    .withError({scope->location, UnexpectedTypePackInSubtyping{*subTail}});
         }
         else
             return {false};
@@ -1101,10 +1082,6 @@ SubtypingResult Subtyping::isCovariantWith(SubtypingEnvironment& env, TypeId sub
     for (TypeId ty : superUnion)
     {
         SubtypingResult next = isCovariantWith(env, subTy, ty, scope);
-
-        if (FFlag::LuauSubtypingStopAtNormFail && next.normalizationTooComplex)
-            return SubtypingResult{false, /* normalizationTooComplex */ true};
-
         if (next.isSubtype)
             return SubtypingResult{true};
     }
@@ -1123,13 +1100,7 @@ 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++, TypePath::Index::Variant::Union}));
-
-        if (FFlag::LuauSubtypingStopAtNormFail && subtypings.back().normalizationTooComplex)
-            return SubtypingResult{false, /* normalizationTooComplex */ true};
-    }
-
+        subtypings.push_back(isCovariantWith(env, ty, superTy, scope).withSubComponent(TypePath::Index{i++}));
     return SubtypingResult::all(subtypings);
 }
 
@@ -1139,13 +1110,7 @@ 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++, TypePath::Index::Variant::Intersection}));
-
-        if (FFlag::LuauSubtypingStopAtNormFail && subtypings.back().normalizationTooComplex)
-            return SubtypingResult{false, /* normalizationTooComplex */ true};
-    }
-
+        subtypings.push_back(isCovariantWith(env, subTy, ty, scope).withSuperComponent(TypePath::Index{i++}));
     return SubtypingResult::all(subtypings);
 }
 
@@ -1155,13 +1120,7 @@ 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++, TypePath::Index::Variant::Intersection}));
-
-        if (FFlag::LuauSubtypingStopAtNormFail && subtypings.back().normalizationTooComplex)
-            return SubtypingResult{false, /* normalizationTooComplex */ true};
-    }
-
+        subtypings.push_back(isCovariantWith(env, ty, superTy, scope).withSubComponent(TypePath::Index{i++}));
     return SubtypingResult::any(subtypings);
 }
 
@@ -1451,7 +1410,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 erroneously say
+        // field that would satisfy the subtyping relationship, we'll erronously 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.
@@ -1515,7 +1474,7 @@ SubtypingResult Subtyping::isCovariantWith(
 
         // If subtyping failed in the argument packs, we should check if there's a hidden variadic tail and try ignoring it.
         // This might cause subtyping correctly because the sub type here may not have a hidden variadic tail or equivalent.
-        if (!result.isSubtype)
+        if (FFlag::LuauRetrySubtypingWithoutHiddenPack && !result.isSubtype)
         {
             auto [arguments, tail] = flatten(superFunction->argTypes);
 
@@ -1801,12 +1760,7 @@ SubtypingResult Subtyping::isCovariantWith(SubtypingEnvironment& env, const Type
     {
         results.emplace_back();
         for (TypeId superTy : superTypes)
-        {
             results.back().orElse(isCovariantWith(env, subTy, superTy, scope));
-
-            if (FFlag::LuauSubtypingStopAtNormFail && results.back().normalizationTooComplex)
-                return SubtypingResult{false, /* normalizationTooComplex */ true};
-        }
     }
 
     return SubtypingResult::all(results);

Analysis/src/Symbol.cpp

@@ -4,6 +4,7 @@
 #include "Luau/Common.h"
 
 LUAU_FASTFLAG(LuauSolverV2)
+LUAU_FASTFLAGVARIABLE(LuauSymbolEquality)
 
 namespace Luau
 {
@@ -14,8 +15,10 @@ 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
+    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;
 }
 
 std::string toString(const Symbol& name)

Analysis/src/TableLiteralInference.cpp

@@ -1,22 +1,14 @@
 // 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(LuauBidirectionalInferenceUpcast)
-LUAU_FASTFLAGVARIABLE(LuauBidirectionalInferenceCollectIndexerTypes)
-LUAU_FASTFLAGVARIABLE(LuauBidirectionalFailsafe)
-
 namespace Luau
 {
 
@@ -117,7 +109,6 @@ TypeId matchLiteralType(
     NotNull<BuiltinTypes> builtinTypes,
     NotNull<TypeArena> arena,
     NotNull<Unifier2> unifier,
-    NotNull<Subtyping> subtyping,
     TypeId expectedType,
     TypeId exprType,
     const AstExpr* expr,
@@ -138,38 +129,17 @@ TypeId matchLiteralType(
      * things like replace explicit named properties with indexers as required
      * by the expected type.
      */
-
     if (!isLiteral(expr))
-    {
-        if (FFlag::LuauBidirectionalInferenceUpcast)
-        {
-            auto result = subtyping->isSubtype(/*subTy=*/exprType, /*superTy=*/expectedType, unifier->scope);
-            return result.isSubtype ? expectedType : exprType;
-        }
-        else
-            return exprType;
-    }
+        return exprType;
 
     expectedType = follow(expectedType);
     exprType = follow(exprType);
 
-    if (FFlag::LuauBidirectionalInferenceCollectIndexerTypes)
+    if (get<AnyType>(expectedType) || get<UnknownType>(expectedType))
     {
-        // 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;
+        // "Narrowing" to unknown or any is not going to do anything useful.
+        return exprType;
     }
-    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>())
     {
@@ -237,29 +207,11 @@ TypeId matchLiteralType(
         return exprType;
     }
 
-
-    if (FFlag::LuauBidirectionalInferenceUpcast && 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;
-    }
+    // TODO: lambdas
 
     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);
@@ -274,7 +226,7 @@ TypeId matchLiteralType(
 
                 if (tt)
                 {
-                    TypeId res = matchLiteralType(astTypes, astExpectedTypes, builtinTypes, arena, unifier, subtyping, *tt, exprType, expr, toBlock);
+                    TypeId res = matchLiteralType(astTypes, astExpectedTypes, builtinTypes, arena, unifier, *tt, exprType, expr, toBlock);
 
                     parts.push_back(res);
                     return arena->addType(UnionType{std::move(parts)});
@@ -284,11 +236,6 @@ TypeId matchLiteralType(
             return exprType;
         }
 
-        DenseHashSet<AstExprConstantString*> keysToDelete{nullptr};
-
-        DenseHashSet<TypeId> indexerKeyTypes{nullptr};
-        DenseHashSet<TypeId> indexerValueTypes{nullptr};
-
         for (const AstExprTable::Item& item : exprTable->items)
         {
             if (isRecord(item))
@@ -296,20 +243,12 @@ 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 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());
+                // Table literals always initially result in shared read-write types
+                LUAU_ASSERT(prop.isShared());
                 TypeId propTy = *prop.readTy;
 
                 auto it2 = expectedTableTy->props.find(keyStr);
@@ -330,28 +269,18 @@ TypeId matchLiteralType(
                             builtinTypes,
                             arena,
                             unifier,
-                            subtyping,
                             expectedTableTy->indexer->indexResultType,
                             propTy,
                             item.value,
                             toBlock
                         );
 
-                        if (FFlag::LuauBidirectionalInferenceCollectIndexerTypes)
-                        {
-                            indexerKeyTypes.insert(arena->addType(SingletonType{StringSingleton{keyStr}}));
-                            indexerValueTypes.insert(matchedType);
-                        }
+                        if (tableTy->indexer)
+                            unifier->unify(matchedType, tableTy->indexer->indexResultType);
                         else
-                        {
-                            if (tableTy->indexer)
-                                unifier->unify(matchedType, tableTy->indexer->indexResultType);
-                            else
-                                tableTy->indexer = TableIndexer{expectedTableTy->indexer->indexType, matchedType};
-                        }
-
-                        keysToDelete.insert(item.key->as<AstExprConstantString>());
+                            tableTy->indexer = TableIndexer{expectedTableTy->indexer->indexType, matchedType};
 
+                        tableTy->props.erase(keyStr);
                     }
 
                     // If it's just an extra property and the expected type
@@ -375,21 +304,21 @@ TypeId matchLiteralType(
                 if (expectedProp.isShared())
                 {
                     matchedType =
-                        matchLiteralType(astTypes, astExpectedTypes, builtinTypes, arena, unifier, subtyping, *expectedReadTy, propTy, item.value, toBlock);
+                        matchLiteralType(astTypes, astExpectedTypes, builtinTypes, arena, unifier, *expectedReadTy, propTy, item.value, toBlock);
                     prop.readTy = matchedType;
                     prop.writeTy = matchedType;
                 }
                 else if (expectedReadTy)
                 {
                     matchedType =
-                        matchLiteralType(astTypes, astExpectedTypes, builtinTypes, arena, unifier, subtyping, *expectedReadTy, propTy, item.value, toBlock);
+                        matchLiteralType(astTypes, astExpectedTypes, builtinTypes, arena, unifier, *expectedReadTy, propTy, item.value, toBlock);
                     prop.readTy = matchedType;
                     prop.writeTy.reset();
                 }
                 else if (expectedWriteTy)
                 {
                     matchedType =
-                        matchLiteralType(astTypes, astExpectedTypes, builtinTypes, arena, unifier, subtyping, *expectedWriteTy, propTy, item.value, toBlock);
+                        matchLiteralType(astTypes, astExpectedTypes, builtinTypes, arena, unifier, *expectedWriteTy, propTy, item.value, toBlock);
                     prop.readTy.reset();
                     prop.writeTy = matchedType;
                 }
@@ -406,11 +335,6 @@ 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)
             {
@@ -428,25 +352,15 @@ TypeId matchLiteralType(
                         builtinTypes,
                         arena,
                         unifier,
-                        subtyping,
                         expectedTableTy->indexer->indexResultType,
                         *propTy,
                         item.value,
                         toBlock
                     );
 
-                    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;
-                    }
-
+                    // 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)
@@ -468,25 +382,11 @@ 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");
         }
 
-        for (const auto& key : keysToDelete)
-        {
-            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
         // specified by the AST fragment.
         //
@@ -536,39 +436,9 @@ 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 (FFlag::LuauBidirectionalInferenceCollectIndexerTypes && expectedTableTy->indexer)
+        if (expectedTableTy->indexer && !tableTy->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;
-            }
+            tableTy->indexer = expectedTableTy->indexer;
         }
     }
 

Analysis/src/ToString.cpp

@@ -1865,8 +1865,6 @@ std::string toString(const Constraint& constraint, ToStringOptions& opts)
         }
         else if constexpr (std::is_same_v<T, EqualityConstraint>)
             return "equality: " + tos(c.resultType) + " ~ " + tos(c.assignmentType);
-        else if constexpr (std::is_same_v<T, TableCheckConstraint>)
-            return "table_check " + tos(c.expectedType) + " :> " + tos(c.exprType);
         else
             static_assert(always_false_v<T>, "Non-exhaustive constraint switch");
     };

Analysis/src/Type.cpp

@@ -27,7 +27,6 @@ LUAU_FASTINTVARIABLE(LuauTypeMaximumStringifierLength, 500)
 LUAU_FASTINTVARIABLE(LuauTableTypeMaximumStringifierLength, 0)
 LUAU_FASTINT(LuauTypeInferRecursionLimit)
 LUAU_FASTFLAG(LuauInstantiateInSubtyping)
-LUAU_FASTFLAGVARIABLE(LuauFreeTypesMustHaveBounds)
 
 namespace Luau
 {
@@ -479,12 +478,24 @@ bool hasLength(TypeId ty, DenseHashSet<TypeId>& seen, int* recursionCount)
     return false;
 }
 
-// New constructors
-FreeType::FreeType(TypeLevel level, TypeId lowerBound, TypeId upperBound)
+FreeType::FreeType(TypeLevel level)
     : index(Unifiable::freshIndex())
     , level(level)
-    , lowerBound(lowerBound)
-    , upperBound(upperBound)
+    , scope(nullptr)
+{
+}
+
+FreeType::FreeType(Scope* scope)
+    : index(Unifiable::freshIndex())
+    , level{}
+    , scope(scope)
+{
+}
+
+FreeType::FreeType(Scope* scope, TypeLevel level)
+    : index(Unifiable::freshIndex())
+    , level(level)
+    , scope(scope)
 {
 }
 
@@ -496,40 +507,6 @@ FreeType::FreeType(Scope* scope, TypeId lowerBound, TypeId upperBound)
 {
 }
 
-FreeType::FreeType(Scope* scope, TypeLevel level, TypeId lowerBound, TypeId upperBound)
-    : index(Unifiable::freshIndex())
-    , level(level)
-    , scope(scope)
-    , lowerBound(lowerBound)
-    , upperBound(upperBound)
-{
-}
-
-// 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))

Analysis/src/TypeArena.cpp

@@ -3,7 +3,6 @@
 #include "Luau/TypeArena.h"
 
 LUAU_FASTFLAGVARIABLE(DebugLuauFreezeArena);
-LUAU_FASTFLAG(LuauFreeTypesMustHaveBounds)
 
 namespace Luau
 {
@@ -23,34 +22,7 @@ TypeId TypeArena::addTV(Type&& tv)
     return allocated;
 }
 
-TypeId TypeArena::freshType(NotNull<BuiltinTypes> builtins, TypeLevel level)
-{
-    TypeId allocated = types.allocate(FreeType{level, builtins->neverType, builtins->unknownType});
-
-    asMutable(allocated)->owningArena = this;
-
-    return allocated;
-}
-
-TypeId TypeArena::freshType(NotNull<BuiltinTypes> builtins, Scope* scope)
-{
-    TypeId allocated = types.allocate(FreeType{scope, builtins->neverType, builtins->unknownType});
-
-    asMutable(allocated)->owningArena = this;
-
-    return allocated;
-}
-
-TypeId TypeArena::freshType(NotNull<BuiltinTypes> builtins, Scope* scope, TypeLevel level)
-{
-    TypeId allocated = types.allocate(FreeType{scope, level, builtins->neverType, builtins->unknownType});
-
-    asMutable(allocated)->owningArena = this;
-
-    return allocated;
-}
-
-TypeId TypeArena::freshType_DEPRECATED(TypeLevel level)
+TypeId TypeArena::freshType(TypeLevel level)
 {
     TypeId allocated = types.allocate(FreeType{level});
 
@@ -59,7 +31,7 @@ TypeId TypeArena::freshType_DEPRECATED(TypeLevel level)
     return allocated;
 }
 
-TypeId TypeArena::freshType_DEPRECATED(Scope* scope)
+TypeId TypeArena::freshType(Scope* scope)
 {
     TypeId allocated = types.allocate(FreeType{scope});
 
@@ -68,7 +40,7 @@ TypeId TypeArena::freshType_DEPRECATED(Scope* scope)
     return allocated;
 }
 
-TypeId TypeArena::freshType_DEPRECATED(Scope* scope, TypeLevel level)
+TypeId TypeArena::freshType(Scope* scope, TypeLevel level)
 {
     TypeId allocated = types.allocate(FreeType{scope, level});
 

Analysis/src/TypeAttach.cpp

@@ -13,8 +13,6 @@
 
 #include <string>
 
-LUAU_FASTFLAG(LuauStoreCSTData2)
-
 static char* allocateString(Luau::Allocator& allocator, std::string_view contents)
 {
     char* result = (char*)allocator.allocate(contents.size() + 1);
@@ -263,24 +261,24 @@ public:
         if (hasSeen(&ftv))
             return allocator->alloc<AstTypeReference>(Location(), std::nullopt, AstName("<Cycle>"), std::nullopt, Location());
 
-        AstArray<AstGenericType*> generics;
+        AstArray<AstGenericType> generics;
         generics.size = ftv.generics.size();
-        generics.data = static_cast<AstGenericType**>(allocator->allocate(sizeof(AstGenericType) * generics.size));
+        generics.data = static_cast<AstGenericType*>(allocator->allocate(sizeof(AstGenericType) * generics.size));
         size_t numGenerics = 0;
         for (auto it = ftv.generics.begin(); it != ftv.generics.end(); ++it)
         {
             if (auto gtv = get<GenericType>(*it))
-                generics.data[numGenerics++] = allocator->alloc<AstGenericType>(Location(), AstName(gtv->name.c_str()), nullptr);
+                generics.data[numGenerics++] = {AstName(gtv->name.c_str()), Location(), nullptr};
         }
 
-        AstArray<AstGenericTypePack*> genericPacks;
+        AstArray<AstGenericTypePack> genericPacks;
         genericPacks.size = ftv.genericPacks.size();
-        genericPacks.data = static_cast<AstGenericTypePack**>(allocator->allocate(sizeof(AstGenericTypePack) * genericPacks.size));
+        genericPacks.data = static_cast<AstGenericTypePack*>(allocator->allocate(sizeof(AstGenericTypePack) * genericPacks.size));
         size_t numGenericPacks = 0;
         for (auto it = ftv.genericPacks.begin(); it != ftv.genericPacks.end(); ++it)
         {
             if (auto gtv = get<GenericTypePack>(*it))
-                genericPacks.data[numGenericPacks++] = allocator->alloc<AstGenericTypePack>(Location(), AstName(gtv->name.c_str()), nullptr);
+                genericPacks.data[numGenericPacks++] = {AstName(gtv->name.c_str()), Location(), nullptr};
         }
 
         AstArray<AstType*> argTypes;
@@ -307,8 +305,7 @@ public:
             std::optional<AstArgumentName>* arg = &argNames.data[i++];
 
             if (el)
-                new (arg)
-                    std::optional<AstArgumentName>(AstArgumentName(AstName(el->name.c_str()), FFlag::LuauStoreCSTData2 ? Location() : el->location));
+                new (arg) std::optional<AstArgumentName>(AstArgumentName(AstName(el->name.c_str()), el->location));
             else
                 new (arg) std::optional<AstArgumentName>();
         }

Analysis/src/TypeChecker2.cpp

@@ -7,6 +7,7 @@
 #include "Luau/DcrLogger.h"
 #include "Luau/DenseHash.h"
 #include "Luau/Error.h"
+#include "Luau/InsertionOrderedMap.h"
 #include "Luau/Instantiation.h"
 #include "Luau/Metamethods.h"
 #include "Luau/Normalize.h"
@@ -26,14 +27,13 @@
 #include "Luau/VisitType.h"
 
 #include <algorithm>
-#include <sstream>
+#include <iostream>
+#include <ostream>
 
 LUAU_FASTFLAG(DebugLuauMagicTypes)
 
-LUAU_FASTFLAG(LuauFreeTypesMustHaveBounds)
-LUAU_FASTFLAGVARIABLE(LuauImproveTypePathsInErrors)
-LUAU_FASTFLAG(LuauUserTypeFunTypecheck)
-LUAU_FASTFLAGVARIABLE(LuauTypeCheckerAcceptNumberConcats)
+LUAU_FASTFLAG(InferGlobalTypes)
+LUAU_FASTFLAGVARIABLE(LuauTableKeysAreRValues)
 
 namespace Luau
 {
@@ -176,7 +176,7 @@ struct InternalTypeFunctionFinder : TypeOnceVisitor
     DenseHashSet<TypeId> mentionedFunctions{nullptr};
     DenseHashSet<TypePackId> mentionedFunctionPacks{nullptr};
 
-    explicit InternalTypeFunctionFinder(std::vector<TypeId>& declStack)
+    InternalTypeFunctionFinder(std::vector<TypeId>& declStack)
     {
         TypeFunctionFinder f;
         for (TypeId fn : declStack)
@@ -507,7 +507,7 @@ TypeId TypeChecker2::checkForTypeFunctionInhabitance(TypeId instance, Location l
     return instance;
 }
 
-TypePackId TypeChecker2::lookupPack(AstExpr* expr) const
+TypePackId TypeChecker2::lookupPack(AstExpr* expr)
 {
     // If a type isn't in the type graph, it probably means that a recursion limit was exceeded.
     // We'll just return anyType in these cases.  Typechecking against any is very fast and this
@@ -557,7 +557,7 @@ TypeId TypeChecker2::lookupAnnotation(AstType* annotation)
     return checkForTypeFunctionInhabitance(follow(*ty), annotation->location);
 }
 
-std::optional<TypePackId> TypeChecker2::lookupPackAnnotation(AstTypePack* annotation) const
+std::optional<TypePackId> TypeChecker2::lookupPackAnnotation(AstTypePack* annotation)
 {
     TypePackId* tp = module->astResolvedTypePacks.find(annotation);
     if (tp != nullptr)
@@ -565,7 +565,7 @@ std::optional<TypePackId> TypeChecker2::lookupPackAnnotation(AstTypePack* annota
     return {};
 }
 
-TypeId TypeChecker2::lookupExpectedType(AstExpr* expr) const
+TypeId TypeChecker2::lookupExpectedType(AstExpr* expr)
 {
     if (TypeId* ty = module->astExpectedTypes.find(expr))
         return follow(*ty);
@@ -573,7 +573,7 @@ TypeId TypeChecker2::lookupExpectedType(AstExpr* expr) const
     return builtinTypes->anyType;
 }
 
-TypePackId TypeChecker2::lookupExpectedPack(AstExpr* expr, TypeArena& arena) const
+TypePackId TypeChecker2::lookupExpectedPack(AstExpr* expr, TypeArena& arena)
 {
     if (TypeId* ty = module->astExpectedTypes.find(expr))
         return arena.addTypePack(TypePack{{follow(*ty)}, std::nullopt});
@@ -597,7 +597,7 @@ TypePackId TypeChecker2::reconstructPack(AstArray<AstExpr*> exprs, TypeArena& ar
     return arena.addTypePack(TypePack{head, tail});
 }
 
-Scope* TypeChecker2::findInnermostScope(Location location) const
+Scope* TypeChecker2::findInnermostScope(Location location)
 {
     Scope* bestScope = module->getModuleScope().get();
 
@@ -1205,8 +1205,7 @@ void TypeChecker2::visit(AstStatTypeAlias* stat)
 
 void TypeChecker2::visit(AstStatTypeFunction* stat)
 {
-    if (FFlag::LuauUserTypeFunTypecheck)
-        visit(stat->body);
+    // TODO: add type checking for user-defined type functions
 }
 
 void TypeChecker2::visit(AstTypeList types)
@@ -1360,7 +1359,7 @@ void TypeChecker2::visit(AstExprGlobal* expr)
     {
         reportError(UnknownSymbol{expr->name.value, UnknownSymbol::Binding}, expr->location);
     }
-    else
+    else if (FFlag::InferGlobalTypes)
     {
         if (scope->shouldWarnGlobal(expr->name.value) && !warnedGlobals.contains(expr->name.value))
         {
@@ -1565,7 +1564,7 @@ void TypeChecker2::visit(AstExprCall* call)
     visitCall(call);
 }
 
-std::optional<TypeId> TypeChecker2::tryStripUnionFromNil(TypeId ty) const
+std::optional<TypeId> TypeChecker2::tryStripUnionFromNil(TypeId ty)
 {
     if (const UnionType* utv = get<UnionType>(ty))
     {
@@ -1852,8 +1851,16 @@ void TypeChecker2::visit(AstExprTable* expr)
 {
     for (const AstExprTable::Item& item : expr->items)
     {
-        if (item.key)
-            visit(item.key, ValueContext::RValue);
+        if (FFlag::LuauTableKeysAreRValues)
+        {
+            if (item.key)
+                visit(item.key, ValueContext::RValue);
+        }
+        else
+        {
+            if (item.key)
+                visit(item.key, ValueContext::LValue);
+        }
         visit(item.value, ValueContext::RValue);
     }
 }
@@ -2101,10 +2108,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(scope, TypeLevel{})});
                 }
 
                 TypeId expectedTy = module->internalTypes.addType(FunctionType(expectedArgs, expectedRets));
@@ -2230,21 +2234,10 @@ TypeId TypeChecker2::visit(AstExprBinary* expr, AstNode* overrideKey)
 
         return builtinTypes->numberType;
     case AstExprBinary::Op::Concat:
-    {
-        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);
-        }
+        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:
@@ -2367,8 +2360,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.addType(FreeType{ftp->scope});
         TypePackId freeTail = module->internalTypes.addTypePack(FreeTypePack{ftp->scope});
 
         TypePack* resultPack = emplaceTypePack<TypePack>(asMutable(pack));
@@ -2385,30 +2377,30 @@ TypeId TypeChecker2::flattenPack(TypePackId pack)
         ice->ice("flattenPack got a weird pack!");
 }
 
-void TypeChecker2::visitGenerics(AstArray<AstGenericType*> generics, AstArray<AstGenericTypePack*> genericPacks)
+void TypeChecker2::visitGenerics(AstArray<AstGenericType> generics, AstArray<AstGenericTypePack> genericPacks)
 {
     DenseHashSet<AstName> seen{AstName{}};
 
-    for (const auto* g : generics)
+    for (const auto& g : generics)
     {
-        if (seen.contains(g->name))
-            reportError(DuplicateGenericParameter{g->name.value}, g->location);
+        if (seen.contains(g.name))
+            reportError(DuplicateGenericParameter{g.name.value}, g.location);
         else
-            seen.insert(g->name);
+            seen.insert(g.name);
 
-        if (g->defaultValue)
-            visit(g->defaultValue);
+        if (g.defaultValue)
+            visit(g.defaultValue);
     }
 
-    for (const auto* g : genericPacks)
+    for (const auto& g : genericPacks)
     {
-        if (seen.contains(g->name))
-            reportError(DuplicateGenericParameter{g->name.value}, g->location);
+        if (seen.contains(g.name))
+            reportError(DuplicateGenericParameter{g.name.value}, g.location);
         else
-            seen.insert(g->name);
+            seen.insert(g.name);
 
-        if (g->defaultValue)
-            visit(g->defaultValue);
+        if (g.defaultValue)
+            visit(g.defaultValue);
     }
 }
 
@@ -2430,8 +2422,6 @@ void TypeChecker2::visit(AstType* ty)
         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 TypeChecker2::visit(AstTypeReference* ty)
@@ -2717,61 +2707,20 @@ 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);
 
-        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 relation = "a subtype of";
+        if (reasoning.variance == SubtypingVariance::Invariant)
+            relation = "exactly";
+        else if (reasoning.variance == SubtypingVariance::Contravariant)
+            relation = "a supertype of";
 
-            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());
-        }
+        std::string reason;
+        if (reasoning.subPath == reasoning.superPath)
+            reason = "at " + toString(reasoning.subPath) + ", " + toString(subLeaf) + " is not " + relation + " " + toString(superLeaf);
         else
-        {
-            std::string relation = "a subtype of";
-            if (reasoning.variance == SubtypingVariance::Invariant)
-                relation = "exactly";
-            else if (reasoning.variance == SubtypingVariance::Contravariant)
-                relation = "a supertype of";
+            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 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);
-        }
+        reasons.push_back(reason);
 
         // if we haven't already proved this isn't suppressing, we have to keep checking.
         if (suppressed)

Analysis/src/TypeFunctionRuntime.cpp

@@ -14,7 +14,12 @@
 #include <vector>
 
 LUAU_DYNAMIC_FASTINT(LuauTypeFunctionSerdeIterationLimit)
-LUAU_FASTFLAGVARIABLE(LuauTypeFunReadWriteParents)
+LUAU_FASTFLAGVARIABLE(LuauUserTypeFunFixInner)
+LUAU_FASTFLAGVARIABLE(LuauUserTypeFunPrintToError)
+LUAU_FASTFLAGVARIABLE(LuauUserTypeFunFixNoReadWrite)
+LUAU_FASTFLAGVARIABLE(LuauUserTypeFunThreadBuffer)
+LUAU_FASTFLAGVARIABLE(LuauUserTypeFunGenerics)
+LUAU_FASTFLAGVARIABLE(LuauUserTypeFunCloneTail)
 
 namespace Luau
 {
@@ -132,9 +137,11 @@ static std::string getTag(lua_State* L, TypeFunctionTypeId ty)
         return "number";
     else if (auto s = get<TypeFunctionPrimitiveType>(ty); s && s->type == TypeFunctionPrimitiveType::Type::String)
         return "string";
-    else if (auto s = get<TypeFunctionPrimitiveType>(ty); s && s->type == TypeFunctionPrimitiveType::Type::Thread)
+    else if (auto s = get<TypeFunctionPrimitiveType>(ty);
+             FFlag::LuauUserTypeFunThreadBuffer && s && s->type == TypeFunctionPrimitiveType::Type::Thread)
         return "thread";
-    else if (auto s = get<TypeFunctionPrimitiveType>(ty); s && s->type == TypeFunctionPrimitiveType::Type::Buffer)
+    else if (auto s = get<TypeFunctionPrimitiveType>(ty);
+             FFlag::LuauUserTypeFunThreadBuffer && s && s->type == TypeFunctionPrimitiveType::Type::Buffer)
         return "buffer";
     else if (get<TypeFunctionUnknownType>(ty))
         return "unknown";
@@ -156,7 +163,7 @@ static std::string getTag(lua_State* L, TypeFunctionTypeId ty)
         return "function";
     else if (get<TypeFunctionClassType>(ty))
         return "class";
-    else if (get<TypeFunctionGenericType>(ty))
+    else if (FFlag::LuauUserTypeFunGenerics && get<TypeFunctionGenericType>(ty))
         return "generic";
 
     LUAU_UNREACHABLE();
@@ -425,11 +432,21 @@ static int getNegatedValue(lua_State* L)
         luaL_error(L, "type.inner: expected 1 argument, but got %d", argumentCount);
 
     TypeFunctionTypeId self = getTypeUserData(L, 1);
-
-    if (auto tfnt = get<TypeFunctionNegationType>(self); tfnt)
-        allocTypeUserData(L, tfnt->type->type);
+    
+    if (FFlag::LuauUserTypeFunFixInner)
+    {
+        if (auto tfnt = get<TypeFunctionNegationType>(self); tfnt)
+            allocTypeUserData(L, tfnt->type->type);
+        else
+            luaL_error(L, "type.inner: cannot call inner method on non-negation type: `%s` type", getTag(L, self).c_str());
+    }
     else
-        luaL_error(L, "type.inner: cannot call inner method on non-negation type: `%s` type", getTag(L, self).c_str());
+    {
+        if (auto tfnt = get<TypeFunctionNegationType>(self); !tfnt)
+            allocTypeUserData(L, tfnt->type->type);
+        else
+            luaL_error(L, "type.inner: cannot call inner method on non-negation type: `%s` type", getTag(L, self).c_str());
+    }
 
     return 1;
 }
@@ -670,8 +687,10 @@ static int readTableProp(lua_State* L)
     auto prop = tftt->props.at(tfsst->value);
     if (prop.readTy)
         allocTypeUserData(L, (*prop.readTy)->type);
-    else
+    else if (FFlag::LuauUserTypeFunFixNoReadWrite)
         lua_pushnil(L);
+    else
+        luaL_error(L, "type.readproperty: property %s is write-only, and therefore does not have a read type.", tfsst->value.c_str());
 
     return 1;
 }
@@ -708,8 +727,10 @@ static int writeTableProp(lua_State* L)
     auto prop = tftt->props.at(tfsst->value);
     if (prop.writeTy)
         allocTypeUserData(L, (*prop.writeTy)->type);
-    else
+    else if (FFlag::LuauUserTypeFunFixNoReadWrite)
         lua_pushnil(L);
+    else
+        luaL_error(L, "type.writeproperty: property %s is read-only, and therefore does not have a write type.", tfsst->value.c_str());
 
     return 1;
 }
@@ -929,6 +950,99 @@ static void pushTypePack(lua_State* L, TypeFunctionTypePackId tp)
     }
 }
 
+static int createFunction_DEPRECATED(lua_State* L)
+{
+    int argumentCount = lua_gettop(L);
+    if (argumentCount > 2)
+        luaL_error(L, "types.newfunction: expected 0-2 arguments, but got %d", argumentCount);
+
+    TypeFunctionTypePackId argTypes = allocateTypeFunctionTypePack(L, TypeFunctionTypePack{});
+    if (lua_istable(L, 1))
+    {
+        std::vector<TypeFunctionTypeId> head{};
+        lua_getfield(L, 1, "head");
+        if (lua_istable(L, -1))
+        {
+            int argSize = lua_objlen(L, -1);
+            for (int i = 1; i <= argSize; i++)
+            {
+                lua_pushinteger(L, i);
+                lua_gettable(L, -2);
+
+                if (lua_isnil(L, -1))
+                {
+                    lua_pop(L, 1);
+                    break;
+                }
+
+                TypeFunctionTypeId ty = getTypeUserData(L, -1);
+                head.push_back(ty);
+
+                lua_pop(L, 1); // Remove `ty` from stack
+            }
+        }
+        lua_pop(L, 1); // Pop the "head" field
+
+        std::optional<TypeFunctionTypePackId> tail;
+        lua_getfield(L, 1, "tail");
+        if (auto type = optionalTypeUserData(L, -1))
+            tail = allocateTypeFunctionTypePack(L, TypeFunctionVariadicTypePack{*type});
+        lua_pop(L, 1); // Pop the "tail" field
+
+        if (head.size() == 0 && tail.has_value())
+            argTypes = *tail;
+        else
+            argTypes = allocateTypeFunctionTypePack(L, TypeFunctionTypePack{head, tail});
+    }
+    else if (!lua_isnoneornil(L, 1))
+        luaL_typeerrorL(L, 1, "table");
+
+    TypeFunctionTypePackId retTypes = allocateTypeFunctionTypePack(L, TypeFunctionTypePack{});
+    if (lua_istable(L, 2))
+    {
+        std::vector<TypeFunctionTypeId> head{};
+        lua_getfield(L, 2, "head");
+        if (lua_istable(L, -1))
+        {
+            int argSize = lua_objlen(L, -1);
+            for (int i = 1; i <= argSize; i++)
+            {
+                lua_pushinteger(L, i);
+                lua_gettable(L, -2);
+
+                if (lua_isnil(L, -1))
+                {
+                    lua_pop(L, 1);
+                    break;
+                }
+
+                TypeFunctionTypeId ty = getTypeUserData(L, -1);
+                head.push_back(ty);
+
+                lua_pop(L, 1); // Remove `ty` from stack
+            }
+        }
+        lua_pop(L, 1); // Pop the "head" field
+
+        std::optional<TypeFunctionTypePackId> tail;
+        lua_getfield(L, 2, "tail");
+        if (auto type = optionalTypeUserData(L, -1))
+            tail = allocateTypeFunctionTypePack(L, TypeFunctionVariadicTypePack{*type});
+        lua_pop(L, 1); // Pop the "tail" field
+
+        if (head.size() == 0 && tail.has_value())
+            retTypes = *tail;
+        else
+            retTypes = allocateTypeFunctionTypePack(L, TypeFunctionTypePack{head, tail});
+    }
+    else if (!lua_isnoneornil(L, 2))
+        luaL_typeerrorL(L, 2, "table");
+
+    allocTypeUserData(L, TypeFunctionFunctionType{{}, {}, argTypes, retTypes});
+
+    return 1;
+}
+
 // Luau: `types.newfunction(parameters: {head: {type}?, tail: type?}, returns: {head: {type}?, tail: type?}, generics: {type}?) -> type`
 // Returns the type instance representing a function
 static int createFunction(lua_State* L)
@@ -997,7 +1111,45 @@ static int setFunctionParameters(lua_State* L)
     if (!tfft)
         luaL_error(L, "type.setparameters: expected self to be a function, but got %s instead", getTag(L, self).c_str());
 
-    tfft->argTypes = getTypePack(L, 2, 3);
+    if (FFlag::LuauUserTypeFunGenerics)
+    {
+        tfft->argTypes = getTypePack(L, 2, 3);
+    }
+    else
+    {
+        std::vector<TypeFunctionTypeId> head{};
+        if (lua_istable(L, 2))
+        {
+            int argSize = lua_objlen(L, 2);
+            for (int i = 1; i <= argSize; i++)
+            {
+                lua_pushinteger(L, i);
+                lua_gettable(L, 2);
+
+                if (lua_isnil(L, -1))
+                {
+                    lua_pop(L, 1);
+                    break;
+                }
+
+                TypeFunctionTypeId ty = getTypeUserData(L, -1);
+                head.push_back(ty);
+
+                lua_pop(L, 1); // Remove `ty` from stack
+            }
+        }
+        else if (!lua_isnoneornil(L, 2))
+            luaL_typeerrorL(L, 2, "table");
+
+        std::optional<TypeFunctionTypePackId> tail;
+        if (auto type = optionalTypeUserData(L, 3))
+            tail = allocateTypeFunctionTypePack(L, TypeFunctionVariadicTypePack{*type});
+
+        if (head.size() == 0 && tail.has_value()) // Make argTypes a variadic type pack
+            tfft->argTypes = *tail;
+        else // Make argTypes a type pack
+            tfft->argTypes = allocateTypeFunctionTypePack(L, TypeFunctionTypePack{head, tail});
+    }
 
     return 0;
 }
@@ -1015,7 +1167,59 @@ static int getFunctionParameters(lua_State* L)
     if (!tfft)
         luaL_error(L, "type.parameters: expected self to be a function, but got %s instead", getTag(L, self).c_str());
 
-    pushTypePack(L, tfft->argTypes);
+    if (FFlag::LuauUserTypeFunGenerics)
+    {
+        pushTypePack(L, tfft->argTypes);
+    }
+    else
+    {
+        if (auto tftp = get<TypeFunctionTypePack>(tfft->argTypes))
+        {
+            int size = 0;
+            if (tftp->head.size() > 0)
+                size++;
+            if (tftp->tail.has_value())
+                size++;
+
+            lua_createtable(L, 0, size);
+
+            int argSize = (int)tftp->head.size();
+            if (argSize > 0)
+            {
+                lua_createtable(L, argSize, 0);
+                for (int i = 0; i < argSize; i++)
+                {
+                    allocTypeUserData(L, tftp->head[i]->type);
+                    lua_rawseti(L, -2, i + 1); // Luau is 1-indexed while C++ is 0-indexed
+                }
+                lua_setfield(L, -2, "head");
+            }
+
+            if (tftp->tail.has_value())
+            {
+                auto tfvp = get<TypeFunctionVariadicTypePack>(*tftp->tail);
+                if (!tfvp)
+                    LUAU_ASSERT(!"We should only be supporting variadic packs as TypeFunctionTypePack.tail at the moment");
+
+                allocTypeUserData(L, tfvp->type->type);
+                lua_setfield(L, -2, "tail");
+            }
+
+            return 1;
+        }
+
+        if (auto tfvp = get<TypeFunctionVariadicTypePack>(tfft->argTypes))
+        {
+            lua_createtable(L, 0, 1);
+
+            allocTypeUserData(L, tfvp->type->type);
+            lua_setfield(L, -2, "tail");
+
+            return 1;
+        }
+
+        lua_createtable(L, 0, 0);
+    }
 
     return 1;
 }
@@ -1033,7 +1237,45 @@ static int setFunctionReturns(lua_State* L)
     if (!tfft)
         luaL_error(L, "type.setreturns: expected self to be a function, but got %s instead", getTag(L, self).c_str());
 
-    tfft->retTypes = getTypePack(L, 2, 3);
+    if (FFlag::LuauUserTypeFunGenerics)
+    {
+        tfft->retTypes = getTypePack(L, 2, 3);
+    }
+    else
+    {
+        std::vector<TypeFunctionTypeId> head{};
+        if (lua_istable(L, 2))
+        {
+            int argSize = lua_objlen(L, 2);
+            for (int i = 1; i <= argSize; i++)
+            {
+                lua_pushinteger(L, i);
+                lua_gettable(L, 2);
+
+                if (lua_isnil(L, -1))
+                {
+                    lua_pop(L, 1);
+                    break;
+                }
+
+                TypeFunctionTypeId ty = getTypeUserData(L, -1);
+                head.push_back(ty);
+
+                lua_pop(L, 1); // Remove `ty` from stack
+            }
+        }
+        else if (!lua_isnoneornil(L, 2))
+            luaL_typeerrorL(L, 2, "table");
+
+        std::optional<TypeFunctionTypePackId> tail;
+        if (auto type = optionalTypeUserData(L, 3))
+            tail = allocateTypeFunctionTypePack(L, TypeFunctionVariadicTypePack{*type});
+
+        if (head.size() == 0 && tail.has_value()) // Make retTypes a variadic type pack
+            tfft->retTypes = *tail;
+        else // Make retTypes a type pack
+            tfft->retTypes = allocateTypeFunctionTypePack(L, TypeFunctionTypePack{head, tail});
+    }
 
     return 0;
 }
@@ -1051,7 +1293,59 @@ static int getFunctionReturns(lua_State* L)
     if (!tfft)
         luaL_error(L, "type.returns: expected self to be a function, but got %s instead", getTag(L, self).c_str());
 
-    pushTypePack(L, tfft->retTypes);
+    if (FFlag::LuauUserTypeFunGenerics)
+    {
+        pushTypePack(L, tfft->retTypes);
+    }
+    else
+    {
+        if (auto tftp = get<TypeFunctionTypePack>(tfft->retTypes))
+        {
+            int size = 0;
+            if (tftp->head.size() > 0)
+                size++;
+            if (tftp->tail.has_value())
+                size++;
+
+            lua_createtable(L, 0, size);
+
+            int argSize = (int)tftp->head.size();
+            if (argSize > 0)
+            {
+                lua_createtable(L, argSize, 0);
+                for (int i = 0; i < argSize; i++)
+                {
+                    allocTypeUserData(L, tftp->head[i]->type);
+                    lua_rawseti(L, -2, i + 1); // Luau is 1-indexed while C++ is 0-indexed
+                }
+                lua_setfield(L, -2, "head");
+            }
+
+            if (tftp->tail.has_value())
+            {
+                auto tfvp = get<TypeFunctionVariadicTypePack>(*tftp->tail);
+                if (!tfvp)
+                    LUAU_ASSERT(!"We should only be supporting variadic packs as TypeFunctionTypePack.tail at the moment");
+
+                allocTypeUserData(L, tfvp->type->type);
+                lua_setfield(L, -2, "tail");
+            }
+
+            return 1;
+        }
+
+        if (auto tfvp = get<TypeFunctionVariadicTypePack>(tfft->retTypes))
+        {
+            lua_createtable(L, 0, 1);
+
+            allocTypeUserData(L, tfvp->type->type);
+            lua_setfield(L, -2, "tail");
+
+            return 1;
+        }
+
+        lua_createtable(L, 0, 0);
+    }
 
     return 1;
 }
@@ -1107,7 +1401,7 @@ static int getFunctionGenerics(lua_State* L)
 
 // Luau: `self:parent() -> type`
 // Returns the parent of a class type
-static int getClassParent_DEPRECATED(lua_State* L)
+static int getClassParent(lua_State* L)
 {
     int argumentCount = lua_gettop(L);
     if (argumentCount != 1)
@@ -1119,54 +1413,10 @@ static int getClassParent_DEPRECATED(lua_State* L)
         luaL_error(L, "type.parent: expected self to be a class, but got %s instead", getTag(L, self).c_str());
 
     // If the parent does not exist, we should return nil
-    if (!tfct->parent_DEPRECATED)
+    if (!tfct->parent)
         lua_pushnil(L);
     else
-        allocTypeUserData(L, (*tfct->parent_DEPRECATED)->type);
-
-    return 1;
-}
-
-// Luau: `self:readparent() -> type`
-// Returns the read type of the class' parent
-static int getReadParent(lua_State* L)
-{
-    int argumentCount = lua_gettop(L);
-    if (argumentCount != 1)
-        luaL_error(L, "type.parent: expected 1 arguments, but got %d", argumentCount);
-
-    TypeFunctionTypeId self = getTypeUserData(L, 1);
-    auto tfct = get<TypeFunctionClassType>(self);
-    if (!tfct)
-        luaL_error(L, "type.parent: expected self to be a class, but got %s instead", getTag(L, self).c_str());
-
-    // If the parent does not exist, we should return nil
-    if (!tfct->readParent)
-        lua_pushnil(L);
-    else
-        allocTypeUserData(L, (*tfct->readParent)->type);
-
-    return 1;
-}
-//
-// Luau: `self:writeparent() -> type`
-// Returns the write type of the class' parent
-static int getWriteParent(lua_State* L)
-{
-    int argumentCount = lua_gettop(L);
-    if (argumentCount != 1)
-        luaL_error(L, "type.parent: expected 1 arguments, but got %d", argumentCount);
-
-    TypeFunctionTypeId self = getTypeUserData(L, 1);
-    auto tfct = get<TypeFunctionClassType>(self);
-    if (!tfct)
-        luaL_error(L, "type.parent: expected self to be a class, but got %s instead", getTag(L, self).c_str());
-
-    // If the parent does not exist, we should return nil
-    if (!tfct->writeParent)
-        lua_pushnil(L);
-    else
-        allocTypeUserData(L, (*tfct->writeParent)->type);
+        allocTypeUserData(L, (*tfct->parent)->type);
 
     return 1;
 }
@@ -1509,8 +1759,8 @@ void registerTypesLibrary(lua_State* L)
         {"boolean", createBoolean},
         {"number", createNumber},
         {"string", createString},
-        {"thread", createThread},
-        {"buffer", createBuffer},
+        {FFlag::LuauUserTypeFunThreadBuffer ? "thread" : nullptr, FFlag::LuauUserTypeFunThreadBuffer ? createThread : nullptr},
+        {FFlag::LuauUserTypeFunThreadBuffer ? "buffer" : nullptr, FFlag::LuauUserTypeFunThreadBuffer ? createBuffer : nullptr},
         {nullptr, nullptr}
     };
 
@@ -1520,9 +1770,9 @@ void registerTypesLibrary(lua_State* L)
         {"unionof", createUnion},
         {"intersectionof", createIntersection},
         {"newtable", createTable},
-        {"newfunction", createFunction},
+        {"newfunction", FFlag::LuauUserTypeFunGenerics ? createFunction : createFunction_DEPRECATED},
         {"copy", deepCopy},
-        {"generic", createGeneric},
+        {FFlag::LuauUserTypeFunGenerics ? "generic" : nullptr, FFlag::LuauUserTypeFunGenerics ? createGeneric : nullptr},
 
         {nullptr, nullptr}
     };
@@ -1594,18 +1844,15 @@ void registerTypeUserData(lua_State* L)
         {"components", getComponents},
 
         // Class type methods
-        {FFlag::LuauTypeFunReadWriteParents ? "readparent" : "parent", FFlag::LuauTypeFunReadWriteParents ? getReadParent : getClassParent_DEPRECATED},
+        {"parent", getClassParent},
 
         // Function type methods (cont.)
-        {"setgenerics", setFunctionGenerics},
-        {"generics", getFunctionGenerics},
+        {FFlag::LuauUserTypeFunGenerics ? "setgenerics" : nullptr, FFlag::LuauUserTypeFunGenerics ? setFunctionGenerics : nullptr},
+        {FFlag::LuauUserTypeFunGenerics ? "generics" : nullptr, FFlag::LuauUserTypeFunGenerics ? getFunctionGenerics : nullptr},
 
         // Generic type methods
-        {"name", getGenericName},
-        {"ispack", getGenericIsPack},
-
-        // move this under Class type methods when removing FFlagLuauTypeFunReadWriteParents
-        {FFlag::LuauTypeFunReadWriteParents ? "writeparent" : nullptr, FFlag::LuauTypeFunReadWriteParents ? getWriteParent : nullptr},
+        {FFlag::LuauUserTypeFunGenerics ? "name" : nullptr, FFlag::LuauUserTypeFunGenerics ? getGenericName : nullptr},
+        {FFlag::LuauUserTypeFunGenerics ? "ispack" : nullptr, FFlag::LuauUserTypeFunGenerics ? getGenericIsPack : nullptr},
 
         {nullptr, nullptr}
     };
@@ -1613,9 +1860,6 @@ void registerTypeUserData(lua_State* L)
     // Create and register metatable for type userdata
     luaL_newmetatable(L, "type");
 
-    lua_pushstring(L, "type");
-    lua_setfield(L, -2, "__type");
-
     // Protect metatable from being changed
     lua_pushstring(L, "The metatable is locked");
     lua_setfield(L, -2, "__metatable");
@@ -1654,9 +1898,7 @@ static int print(lua_State* L)
         size_t l = 0;
         const char* s = luaL_tolstring(L, i, &l); // convert to string using __tostring et al
         if (i > 1)
-        {
-            result.append(1, '\t');
-        }
+            result.append('\t', 1);
         result.append(s, l);
         lua_pop(L, 1);
     }
@@ -1699,16 +1941,29 @@ void setTypeFunctionEnvironment(lua_State* L)
     luaopen_base(L);
     lua_pop(L, 1);
 
-    // Remove certain global functions from the base library
-    static const char* unavailableGlobals[] = {"gcinfo", "getfenv", "newproxy", "setfenv", "pcall", "xpcall"};
-    for (auto& name : unavailableGlobals)
+    if (FFlag::LuauUserTypeFunPrintToError)
     {
-        lua_pushcfunction(L, unsupportedFunction, name);
-        lua_setglobal(L, name);
-    }
+        // Remove certain global functions from the base library
+        static const char* unavailableGlobals[] = {"gcinfo", "getfenv", "newproxy", "setfenv", "pcall", "xpcall"};
+        for (auto& name : unavailableGlobals)
+        {
+            lua_pushcfunction(L, unsupportedFunction, name);
+            lua_setglobal(L, name);
+        }
 
-    lua_pushcfunction(L, print, "print");
-    lua_setglobal(L, "print");
+        lua_pushcfunction(L, print, "print");
+        lua_setglobal(L, "print");
+    }
+    else
+    {
+        // Remove certain global functions from the base library
+        static const std::string unavailableGlobals[] = {"gcinfo", "getfenv", "newproxy", "setfenv", "pcall", "xpcall"};
+        for (auto& name : unavailableGlobals)
+        {
+            lua_pushcfunction(L, unsupportedFunction, "Removing global function from type function environment");
+            lua_setglobal(L, name.c_str());
+        }
+    }
 }
 
 void resetTypeFunctionState(lua_State* L)
@@ -1748,14 +2003,14 @@ bool areEqual(SeenSet& seen, const TypeFunctionSingletonType& lhs, const TypeFun
 
     {
         const TypeFunctionBooleanSingleton* lp = get<TypeFunctionBooleanSingleton>(&lhs);
-        const TypeFunctionBooleanSingleton* rp = get<TypeFunctionBooleanSingleton>(&rhs);
+        const TypeFunctionBooleanSingleton* rp = get<TypeFunctionBooleanSingleton>(&lhs);
         if (lp && rp)
             return lp->value == rp->value;
     }
 
     {
         const TypeFunctionStringSingleton* lp = get<TypeFunctionStringSingleton>(&lhs);
-        const TypeFunctionStringSingleton* rp = get<TypeFunctionStringSingleton>(&rhs);
+        const TypeFunctionStringSingleton* rp = get<TypeFunctionStringSingleton>(&lhs);
         if (lp && rp)
             return lp->value == rp->value;
     }
@@ -1864,22 +2119,25 @@ bool areEqual(SeenSet& seen, const TypeFunctionFunctionType& lhs, const TypeFunc
     if (seenSetContains(seen, &lhs, &rhs))
         return true;
 
-    if (lhs.generics.size() != rhs.generics.size())
-        return false;
-
-    for (auto l = lhs.generics.begin(), r = rhs.generics.begin(); l != lhs.generics.end() && r != rhs.generics.end(); ++l, ++r)
+    if (FFlag::LuauUserTypeFunGenerics)
     {
-        if (!areEqual(seen, **l, **r))
+        if (lhs.generics.size() != rhs.generics.size())
             return false;
-    }
 
-    if (lhs.genericPacks.size() != rhs.genericPacks.size())
-        return false;
+        for (auto l = lhs.generics.begin(), r = rhs.generics.begin(); l != lhs.generics.end() && r != rhs.generics.end(); ++l, ++r)
+        {
+            if (!areEqual(seen, **l, **r))
+                return false;
+        }
 
-    for (auto l = lhs.genericPacks.begin(), r = rhs.genericPacks.begin(); l != lhs.genericPacks.end() && r != rhs.genericPacks.end(); ++l, ++r)
-    {
-        if (!areEqual(seen, **l, **r))
+        if (lhs.genericPacks.size() != rhs.genericPacks.size())
             return false;
+
+        for (auto l = lhs.genericPacks.begin(), r = rhs.genericPacks.begin(); l != lhs.genericPacks.end() && r != rhs.genericPacks.end(); ++l, ++r)
+        {
+            if (!areEqual(seen, **l, **r))
+                return false;
+        }
     }
 
     if (bool(lhs.argTypes) != bool(rhs.argTypes))
@@ -1908,7 +2166,7 @@ bool areEqual(SeenSet& seen, const TypeFunctionClassType& lhs, const TypeFunctio
     if (seenSetContains(seen, &lhs, &rhs))
         return true;
 
-    return lhs.classTy == rhs.classTy;
+    return lhs.name == rhs.name;
 }
 
 bool areEqual(SeenSet& seen, const TypeFunctionType& lhs, const TypeFunctionType& rhs)
@@ -1982,11 +2240,14 @@ bool areEqual(SeenSet& seen, const TypeFunctionType& lhs, const TypeFunctionType
             return areEqual(seen, *lf, *rf);
     }
 
+    if (FFlag::LuauUserTypeFunGenerics)
     {
-        const TypeFunctionGenericType* lg = get<TypeFunctionGenericType>(&lhs);
-        const TypeFunctionGenericType* rg = get<TypeFunctionGenericType>(&rhs);
-        if (lg && rg)
-            return lg->isNamed == rg->isNamed && lg->isPack == rg->isPack && lg->name == rg->name;
+        {
+            const TypeFunctionGenericType* lg = get<TypeFunctionGenericType>(&lhs);
+            const TypeFunctionGenericType* rg = get<TypeFunctionGenericType>(&rhs);
+            if (lg && rg)
+                return lg->isNamed == rg->isNamed && lg->isPack == rg->isPack && lg->name == rg->name;
+        }
     }
 
     return false;
@@ -2035,11 +2296,14 @@ bool areEqual(SeenSet& seen, const TypeFunctionTypePackVar& lhs, const TypeFunct
             return areEqual(seen, *lv, *rv);
     }
 
+    if (FFlag::LuauUserTypeFunGenerics)
     {
-        const TypeFunctionGenericTypePack* lg = get<TypeFunctionGenericTypePack>(&lhs);
-        const TypeFunctionGenericTypePack* rg = get<TypeFunctionGenericTypePack>(&rhs);
-        if (lg && rg)
-            return lg->isNamed == rg->isNamed && lg->name == rg->name;
+        {
+            const TypeFunctionGenericTypePack* lg = get<TypeFunctionGenericTypePack>(&lhs);
+            const TypeFunctionGenericTypePack* rg = get<TypeFunctionGenericTypePack>(&rhs);
+            if (lg && rg)
+                return lg->isNamed == rg->isNamed && lg->name == rg->name;
+        }
     }
 
     return false;
@@ -2231,10 +2495,12 @@ private:
                 target = typeFunctionRuntime->typeArena.allocate(TypeFunctionPrimitiveType(TypeFunctionPrimitiveType::String));
                 break;
             case TypeFunctionPrimitiveType::Thread:
-                target = typeFunctionRuntime->typeArena.allocate(TypeFunctionPrimitiveType(TypeFunctionPrimitiveType::Thread));
+                if (FFlag::LuauUserTypeFunThreadBuffer)
+                    target = typeFunctionRuntime->typeArena.allocate(TypeFunctionPrimitiveType(TypeFunctionPrimitiveType::Thread));
                 break;
             case TypeFunctionPrimitiveType::Buffer:
-                target = typeFunctionRuntime->typeArena.allocate(TypeFunctionPrimitiveType(TypeFunctionPrimitiveType::Buffer));
+                if (FFlag::LuauUserTypeFunThreadBuffer)
+                    target = typeFunctionRuntime->typeArena.allocate(TypeFunctionPrimitiveType(TypeFunctionPrimitiveType::Buffer));
                 break;
             default:
                 break;
@@ -2268,7 +2534,7 @@ private:
         }
         else if (auto c = get<TypeFunctionClassType>(ty))
             target = ty; // Don't copy a class since they are immutable
-        else if (auto g = get<TypeFunctionGenericType>(ty))
+        else if (auto g = get<TypeFunctionGenericType>(ty); FFlag::LuauUserTypeFunGenerics && g)
             target = typeFunctionRuntime->typeArena.allocate(TypeFunctionGenericType{g->isNamed, g->isPack, g->name});
         else
             LUAU_ASSERT(!"Unknown type");
@@ -2289,7 +2555,7 @@ private:
             target = typeFunctionRuntime->typePackArena.allocate(TypeFunctionTypePack{{}});
         else if (auto vPack = get<TypeFunctionVariadicTypePack>(tp))
             target = typeFunctionRuntime->typePackArena.allocate(TypeFunctionVariadicTypePack{});
-        else if (auto gPack = get<TypeFunctionGenericTypePack>(tp))
+        else if (auto gPack = get<TypeFunctionGenericTypePack>(tp); gPack && FFlag::LuauUserTypeFunGenerics)
             target = typeFunctionRuntime->typePackArena.allocate(TypeFunctionGenericTypePack{gPack->isNamed, gPack->name});
         else
             LUAU_ASSERT(!"Unknown type");
@@ -2323,7 +2589,8 @@ private:
             cloneChildren(f1, f2);
         else if (auto [c1, c2] = std::tuple{getMutable<TypeFunctionClassType>(ty), getMutable<TypeFunctionClassType>(tfti)}; c1 && c2)
             cloneChildren(c1, c2);
-        else if (auto [g1, g2] = std::tuple{getMutable<TypeFunctionGenericType>(ty), getMutable<TypeFunctionGenericType>(tfti)}; g1 && g2)
+        else if (auto [g1, g2] = std::tuple{getMutable<TypeFunctionGenericType>(ty), getMutable<TypeFunctionGenericType>(tfti)};
+                 FFlag::LuauUserTypeFunGenerics && g1 && g2)
             cloneChildren(g1, g2);
         else
             LUAU_ASSERT(!"Unknown pair?"); // First and argument should always represent the same types
@@ -2337,7 +2604,7 @@ private:
                  vPack1 && vPack2)
             cloneChildren(vPack1, vPack2);
         else if (auto [gPack1, gPack2] = std::tuple{getMutable<TypeFunctionGenericTypePack>(tp), getMutable<TypeFunctionGenericTypePack>(tftp)};
-                 gPack1 && gPack2)
+                 FFlag::LuauUserTypeFunGenerics && gPack1 && gPack2)
             cloneChildren(gPack1, gPack2);
         else
             LUAU_ASSERT(!"Unknown pair?"); // First and argument should always represent the same types
@@ -2419,13 +2686,16 @@ private:
 
     void cloneChildren(TypeFunctionFunctionType* f1, TypeFunctionFunctionType* f2)
     {
-        f2->generics.reserve(f1->generics.size());
-        for (auto ty : f1->generics)
-            f2->generics.push_back(shallowClone(ty));
+        if (FFlag::LuauUserTypeFunGenerics)
+        {
+            f2->generics.reserve(f1->generics.size());
+            for (auto ty : f1->generics)
+                f2->generics.push_back(shallowClone(ty));
 
-        f2->genericPacks.reserve(f1->genericPacks.size());
-        for (auto tp : f1->genericPacks)
-            f2->genericPacks.push_back(shallowClone(tp));
+            f2->genericPacks.reserve(f1->genericPacks.size());
+            for (auto tp : f1->genericPacks)
+                f2->genericPacks.push_back(shallowClone(tp));
+        }
 
         f2->argTypes = shallowClone(f1->argTypes);
         f2->retTypes = shallowClone(f1->retTypes);
@@ -2446,8 +2716,11 @@ private:
         for (TypeFunctionTypeId& ty : t1->head)
             t2->head.push_back(shallowClone(ty));
 
-        if (t1->tail)
-            t2->tail = shallowClone(*t1->tail);
+        if (FFlag::LuauUserTypeFunCloneTail)
+        {
+            if (t1->tail)
+                t2->tail = shallowClone(*t1->tail);
+        }
     }
 
     void cloneChildren(TypeFunctionVariadicTypePack* v1, TypeFunctionVariadicTypePack* v2)

Analysis/src/TypeFunctionRuntimeBuilder.cpp

@@ -19,7 +19,9 @@
 // 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(LuauTypeFunReadWriteParents)
+
+LUAU_FASTFLAG(LuauUserTypeFunThreadBuffer)
+LUAU_FASTFLAG(LuauUserTypeFunGenerics)
 
 namespace Luau
 {
@@ -159,10 +161,26 @@ private:
                 target = typeFunctionRuntime->typeArena.allocate(TypeFunctionPrimitiveType(TypeFunctionPrimitiveType::String));
                 break;
             case PrimitiveType::Thread:
-                target = typeFunctionRuntime->typeArena.allocate(TypeFunctionPrimitiveType(TypeFunctionPrimitiveType::Thread));
+                if (FFlag::LuauUserTypeFunThreadBuffer)
+                {
+                    target = typeFunctionRuntime->typeArena.allocate(TypeFunctionPrimitiveType(TypeFunctionPrimitiveType::Thread));
+                }
+                else
+                {
+                    std::string error = format("Argument of primitive type %s is not currently serializable by type functions", toString(ty).c_str());
+                    state->errors.push_back(error);
+                }
                 break;
             case PrimitiveType::Buffer:
-                target = typeFunctionRuntime->typeArena.allocate(TypeFunctionPrimitiveType(TypeFunctionPrimitiveType::Buffer));
+                if (FFlag::LuauUserTypeFunThreadBuffer)
+                {
+                    target = typeFunctionRuntime->typeArena.allocate(TypeFunctionPrimitiveType(TypeFunctionPrimitiveType::Buffer));
+                }
+                else
+                {
+                    std::string error = format("Argument of primitive type %s is not currently serializable by type functions", toString(ty).c_str());
+                    state->errors.push_back(error);
+                }
                 break;
             case PrimitiveType::Function:
             case PrimitiveType::Table:
@@ -208,13 +226,10 @@ private:
         }
         else if (auto c = get<ClassType>(ty))
         {
-            // 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}
-            );
+            state->classesSerialized[c->name] = ty;
+            target = typeFunctionRuntime->typeArena.allocate(TypeFunctionClassType{{}, std::nullopt, std::nullopt, std::nullopt, c->name});
         }
-        else if (auto g = get<GenericType>(ty))
+        else if (auto g = get<GenericType>(ty); FFlag::LuauUserTypeFunGenerics && g)
         {
             Name name = g->name;
 
@@ -247,7 +262,7 @@ private:
             target = typeFunctionRuntime->typePackArena.allocate(TypeFunctionTypePack{{}});
         else if (auto vPack = get<VariadicTypePack>(tp))
             target = typeFunctionRuntime->typePackArena.allocate(TypeFunctionVariadicTypePack{});
-        else if (auto gPack = get<GenericTypePack>(tp))
+        else if (auto gPack = get<GenericTypePack>(tp); FFlag::LuauUserTypeFunGenerics && gPack)
         {
             Name name = gPack->name;
 
@@ -293,7 +308,8 @@ private:
             serializeChildren(f1, f2);
         else if (auto [c1, c2] = std::tuple{get<ClassType>(ty), getMutable<TypeFunctionClassType>(tfti)}; c1 && c2)
             serializeChildren(c1, c2);
-        else if (auto [g1, g2] = std::tuple{get<GenericType>(ty), getMutable<TypeFunctionGenericType>(tfti)}; g1 && g2)
+        else if (auto [g1, g2] = std::tuple{get<GenericType>(ty), getMutable<TypeFunctionGenericType>(tfti)};
+                 FFlag::LuauUserTypeFunGenerics && g1 && g2)
             serializeChildren(g1, g2);
         else
         { // Either this or ty and tfti do not represent the same type
@@ -308,7 +324,8 @@ private:
             serializeChildren(tPack1, tPack2);
         else if (auto [vPack1, vPack2] = std::tuple{get<VariadicTypePack>(tp), getMutable<TypeFunctionVariadicTypePack>(tftp)}; vPack1 && vPack2)
             serializeChildren(vPack1, vPack2);
-        else if (auto [gPack1, gPack2] = std::tuple{get<GenericTypePack>(tp), getMutable<TypeFunctionGenericTypePack>(tftp)}; gPack1 && gPack2)
+        else if (auto [gPack1, gPack2] = std::tuple{get<GenericTypePack>(tp), getMutable<TypeFunctionGenericTypePack>(tftp)};
+                 FFlag::LuauUserTypeFunGenerics && gPack1 && gPack2)
             serializeChildren(gPack1, gPack2);
         else
         { // Either this or ty and tfti do not represent the same type
@@ -399,13 +416,16 @@ private:
 
     void serializeChildren(const FunctionType* f1, TypeFunctionFunctionType* f2)
     {
-        f2->generics.reserve(f1->generics.size());
-        for (auto ty : f1->generics)
-            f2->generics.push_back(shallowSerialize(ty));
+        if (FFlag::LuauUserTypeFunGenerics)
+        {
+            f2->generics.reserve(f1->generics.size());
+            for (auto ty : f1->generics)
+                f2->generics.push_back(shallowSerialize(ty));
 
-        f2->genericPacks.reserve(f1->genericPacks.size());
-        for (auto tp : f1->genericPacks)
-            f2->genericPacks.push_back(shallowSerialize(tp));
+            f2->genericPacks.reserve(f1->genericPacks.size());
+            for (auto tp : f1->genericPacks)
+                f2->genericPacks.push_back(shallowSerialize(tp));
+        }
 
         f2->argTypes = shallowSerialize(f1->argTypes);
         f2->retTypes = shallowSerialize(f1->retTypes);
@@ -433,20 +453,7 @@ private:
             c2->metatable = shallowSerialize(*c1->metatable);
 
         if (c1->parent)
-        {
-            TypeFunctionTypeId parent = shallowSerialize(*c1->parent);
-
-            if (FFlag::LuauTypeFunReadWriteParents)
-            {
-                // we don't yet have read/write parents in the type inference engine.
-                c2->readParent = parent;
-                c2->writeParent = parent;
-            }
-            else
-            {
-                c2->parent_DEPRECATED = parent;
-            }
-        }
+            c2->parent = shallowSerialize(*c1->parent);
     }
 
     void serializeChildren(const GenericType* g1, TypeFunctionGenericType* g2)
@@ -583,11 +590,14 @@ private:
 
             deserializeChildren(tfti, ty);
 
-            // If we have completed working on all children of a function, remove the generic parameters from scope
-            if (!functionScopes.empty() && queue.size() == functionScopes.back().oldQueueSize && state->errors.empty())
+            if (FFlag::LuauUserTypeFunGenerics)
             {
-                closeFunctionScope(functionScopes.back().function);
-                functionScopes.pop_back();
+                // If we have completed working on all children of a function, remove the generic parameters from scope
+                if (!functionScopes.empty() && queue.size() == functionScopes.back().oldQueueSize && state->errors.empty())
+                {
+                    closeFunctionScope(functionScopes.back().function);
+                    functionScopes.pop_back();
+                }
             }
         }
     }
@@ -660,10 +670,16 @@ private:
                 target = state->ctx->builtins->stringType;
                 break;
             case TypeFunctionPrimitiveType::Type::Thread:
-                target = state->ctx->builtins->threadType;
+                if (FFlag::LuauUserTypeFunThreadBuffer)
+                    target = state->ctx->builtins->threadType;
+                else
+                    state->ctx->ice->ice("Deserializing user defined type function arguments: mysterious type is being deserialized");
                 break;
             case TypeFunctionPrimitiveType::Type::Buffer:
-                target = state->ctx->builtins->bufferType;
+                if (FFlag::LuauUserTypeFunThreadBuffer)
+                    target = state->ctx->builtins->bufferType;
+                else
+                    state->ctx->ice->ice("Deserializing user defined type function arguments: mysterious type is being deserialized");
                 break;
             default:
                 state->ctx->ice->ice("Deserializing user defined type function arguments: mysterious type is being deserialized");
@@ -704,9 +720,12 @@ private:
         }
         else if (auto c = get<TypeFunctionClassType>(ty))
         {
-            target = c->classTy;
+            if (auto result = state->classesSerialized.find(c->name))
+                target = *result;
+            else
+                state->ctx->ice->ice("Deserializing user defined type function arguments: mysterious class type is being deserialized");
         }
-        else if (auto g = get<TypeFunctionGenericType>(ty))
+        else if (auto g = get<TypeFunctionGenericType>(ty); FFlag::LuauUserTypeFunGenerics && g)
         {
             if (g->isPack)
             {
@@ -756,7 +775,7 @@ private:
         {
             target = state->ctx->arena->addTypePack(VariadicTypePack{});
         }
-        else if (auto gPack = get<TypeFunctionGenericTypePack>(tp))
+        else if (auto gPack = get<TypeFunctionGenericTypePack>(tp); FFlag::LuauUserTypeFunGenerics && gPack)
         {
             auto it = std::find_if(
                 genericPacks.rbegin(),
@@ -813,7 +832,8 @@ private:
             deserializeChildren(f2, f1);
         else if (auto [c1, c2] = std::tuple{getMutable<ClassType>(ty), getMutable<TypeFunctionClassType>(tfti)}; c1 && c2)
             deserializeChildren(c2, c1);
-        else if (auto [g1, g2] = std::tuple{getMutable<GenericType>(ty), getMutable<TypeFunctionGenericType>(tfti)}; g1 && g2)
+        else if (auto [g1, g2] = std::tuple{getMutable<GenericType>(ty), getMutable<TypeFunctionGenericType>(tfti)};
+                 FFlag::LuauUserTypeFunGenerics && g1 && g2)
             deserializeChildren(g2, g1);
         else
             state->ctx->ice->ice("Deserializing user defined type function arguments: mysterious type is being deserialized");
@@ -826,7 +846,8 @@ private:
         else if (auto [vPack1, vPack2] = std::tuple{getMutable<VariadicTypePack>(tp), getMutable<TypeFunctionVariadicTypePack>(tftp)};
                  vPack1 && vPack2)
             deserializeChildren(vPack2, vPack1);
-        else if (auto [gPack1, gPack2] = std::tuple{getMutable<GenericTypePack>(tp), getMutable<TypeFunctionGenericTypePack>(tftp)}; gPack1 && gPack2)
+        else if (auto [gPack1, gPack2] = std::tuple{getMutable<GenericTypePack>(tp), getMutable<TypeFunctionGenericTypePack>(tftp)};
+                 FFlag::LuauUserTypeFunGenerics && gPack1 && gPack2)
             deserializeChildren(gPack2, gPack1);
         else
             state->ctx->ice->ice("Deserializing user defined type function arguments: mysterious type is being deserialized");
@@ -911,60 +932,64 @@ private:
 
     void deserializeChildren(TypeFunctionFunctionType* f2, FunctionType* f1)
     {
-        functionScopes.push_back({queue.size(), f2});
-
-        std::set<std::pair<bool, std::string>> genericNames;
-
-        // Introduce generic function parameters into scope
-        for (auto ty : f2->generics)
+        if (FFlag::LuauUserTypeFunGenerics)
         {
-            auto gty = get<TypeFunctionGenericType>(ty);
-            LUAU_ASSERT(gty && !gty->isPack);
+            functionScopes.push_back({queue.size(), f2});
 
-            std::pair<bool, std::string> nameKey = std::make_pair(gty->isNamed, gty->name);
+            std::set<std::pair<bool, std::string>> genericNames;
 
-            // Duplicates are not allowed
-            if (genericNames.find(nameKey) != genericNames.end())
+            // Introduce generic function parameters into scope
+            for (auto ty : f2->generics)
             {
-                state->errors.push_back(format("Duplicate type parameter '%s'", gty->name.c_str()));
-                return;
+                auto gty = get<TypeFunctionGenericType>(ty);
+                LUAU_ASSERT(gty && !gty->isPack);
+
+                std::pair<bool, std::string> nameKey = std::make_pair(gty->isNamed, gty->name);
+
+                // Duplicates are not allowed
+                if (genericNames.find(nameKey) != genericNames.end())
+                {
+                    state->errors.push_back(format("Duplicate type parameter '%s'", gty->name.c_str()));
+                    return;
+                }
+
+                genericNames.insert(nameKey);
+
+                TypeId mapping = state->ctx->arena->addTV(Type(gty->isNamed ? GenericType{state->ctx->scope.get(), gty->name} : GenericType{}));
+                genericTypes.push_back({gty->isNamed, gty->name, mapping});
             }
 
-            genericNames.insert(nameKey);
-
-            TypeId mapping = state->ctx->arena->addTV(Type(gty->isNamed ? GenericType{state->ctx->scope.get(), gty->name} : GenericType{}));
-            genericTypes.push_back({gty->isNamed, gty->name, mapping});
-        }
-
-        for (auto tp : f2->genericPacks)
-        {
-            auto gtp = get<TypeFunctionGenericTypePack>(tp);
-            LUAU_ASSERT(gtp);
-
-            std::pair<bool, std::string> nameKey = std::make_pair(gtp->isNamed, gtp->name);
-
-            // Duplicates are not allowed
-            if (genericNames.find(nameKey) != genericNames.end())
+            for (auto tp : f2->genericPacks)
             {
-                state->errors.push_back(format("Duplicate type parameter '%s'", gtp->name.c_str()));
-                return;
+                auto gtp = get<TypeFunctionGenericTypePack>(tp);
+                LUAU_ASSERT(gtp);
+
+                std::pair<bool, std::string> nameKey = std::make_pair(gtp->isNamed, gtp->name);
+
+                // Duplicates are not allowed
+                if (genericNames.find(nameKey) != genericNames.end())
+                {
+                    state->errors.push_back(format("Duplicate type parameter '%s'", gtp->name.c_str()));
+                    return;
+                }
+
+                genericNames.insert(nameKey);
+
+                TypePackId mapping =
+                    state->ctx->arena->addTypePack(TypePackVar(gtp->isNamed ? GenericTypePack{state->ctx->scope.get(), gtp->name} : GenericTypePack{})
+                    );
+                genericPacks.push_back({gtp->isNamed, gtp->name, mapping});
             }
 
-            genericNames.insert(nameKey);
+            f1->generics.reserve(f2->generics.size());
+            for (auto ty : f2->generics)
+                f1->generics.push_back(shallowDeserialize(ty));
 
-            TypePackId mapping =
-                state->ctx->arena->addTypePack(TypePackVar(gtp->isNamed ? GenericTypePack{state->ctx->scope.get(), gtp->name} : GenericTypePack{}));
-            genericPacks.push_back({gtp->isNamed, gtp->name, mapping});
+            f1->genericPacks.reserve(f2->genericPacks.size());
+            for (auto tp : f2->genericPacks)
+                f1->genericPacks.push_back(shallowDeserialize(tp));
         }
 
-        f1->generics.reserve(f2->generics.size());
-        for (auto ty : f2->generics)
-            f1->generics.push_back(shallowDeserialize(ty));
-
-        f1->genericPacks.reserve(f2->genericPacks.size());
-        for (auto tp : f2->genericPacks)
-            f1->genericPacks.push_back(shallowDeserialize(tp));
-
         if (f2->argTypes)
             f1->argTypes = shallowDeserialize(f2->argTypes);
 

Analysis/src/TypeInfer.cpp

@@ -32,10 +32,7 @@ LUAU_FASTINTVARIABLE(LuauVisitRecursionLimit, 500)
 LUAU_FASTFLAG(LuauKnowsTheDataModel3)
 LUAU_FASTFLAGVARIABLE(DebugLuauFreezeDuringUnification)
 LUAU_FASTFLAG(LuauInstantiateInSubtyping)
-LUAU_FASTFLAG(LuauPreserveUnionIntersectionNodeForLeadingTokenSingleType)
-LUAU_FASTFLAG(LuauFreeTypesMustHaveBounds)
-
-LUAU_FASTFLAG(LuauModuleHoldsAstRoot)
+LUAU_FASTFLAGVARIABLE(LuauOldSolverCreatesChildScopePointers)
 
 namespace Luau
 {
@@ -256,8 +253,6 @@ ModulePtr TypeChecker::checkWithoutRecursionCheck(const SourceModule& module, Mo
     currentModule->type = module.type;
     currentModule->allocator = module.allocator;
     currentModule->names = module.names;
-    if (FFlag::LuauModuleHoldsAstRoot)
-        currentModule->root = module.root;
 
     iceHandler->moduleName = module.name;
     normalizer.arena = &currentModule->internalTypes;
@@ -766,12 +761,8 @@ ControlFlow TypeChecker::check(const ScopePtr& scope, const AstStatRepeat& state
 
 struct Demoter : Substitution
 {
-    TypeArena* arena = nullptr;
-    NotNull<BuiltinTypes> builtins;
-    Demoter(TypeArena* arena, NotNull<BuiltinTypes> builtins)
+    Demoter(TypeArena* arena)
         : Substitution(TxnLog::empty(), arena)
-        , arena(arena)
-        , builtins(builtins)
     {
     }
 
@@ -797,8 +788,7 @@ struct Demoter : Substitution
     {
         auto ftv = get<FreeType>(ty);
         LUAU_ASSERT(ftv);
-        return FFlag::LuauFreeTypesMustHaveBounds ? arena->freshType(builtins, demotedLevel(ftv->level))
-                                                  : addType(FreeType{demotedLevel(ftv->level)});
+        return addType(FreeType{demotedLevel(ftv->level)});
     }
 
     TypePackId clean(TypePackId tp) override
@@ -845,7 +835,7 @@ ControlFlow TypeChecker::check(const ScopePtr& scope, const AstStatReturn& retur
         }
     }
 
-    Demoter demoter{&currentModule->internalTypes, builtinTypes};
+    Demoter demoter{&currentModule->internalTypes};
     demoter.demote(expectedTypes);
 
     TypePackId retPack = checkExprList(scope, return_.location, return_.list, false, {}, expectedTypes).type;
@@ -4418,7 +4408,7 @@ std::vector<std::optional<TypeId>> TypeChecker::getExpectedTypesForCall(const st
         }
     }
 
-    Demoter demoter{&currentModule->internalTypes, builtinTypes};
+    Demoter demoter{&currentModule->internalTypes};
     demoter.demote(expectedTypes);
 
     return expectedTypes;
@@ -5215,9 +5205,12 @@ LUAU_NOINLINE void TypeChecker::reportErrorCodeTooComplex(const Location& locati
 ScopePtr TypeChecker::childFunctionScope(const ScopePtr& parent, const Location& location, int subLevel)
 {
     ScopePtr scope = std::make_shared<Scope>(parent, subLevel);
-    scope->location = location;
-    scope->returnType = parent->returnType;
-    parent->children.emplace_back(scope.get());
+    if (FFlag::LuauOldSolverCreatesChildScopePointers)
+    {
+        scope->location = location;
+        scope->returnType = parent->returnType;
+        parent->children.emplace_back(scope.get());
+    }
 
     currentModule->scopes.push_back(std::make_pair(location, scope));
     return scope;
@@ -5229,9 +5222,12 @@ ScopePtr TypeChecker::childScope(const ScopePtr& parent, const Location& locatio
     ScopePtr scope = std::make_shared<Scope>(parent);
     scope->level = parent->level;
     scope->varargPack = parent->varargPack;
-    scope->location = location;
-    scope->returnType = parent->returnType;
-    parent->children.emplace_back(scope.get());
+    if (FFlag::LuauOldSolverCreatesChildScopePointers)
+    {
+        scope->location = location;
+        scope->returnType = parent->returnType;
+        parent->children.emplace_back(scope.get());
+    }
 
     currentModule->scopes.push_back(std::make_pair(location, scope));
     return scope;
@@ -5277,8 +5273,7 @@ TypeId TypeChecker::freshType(const ScopePtr& scope)
 
 TypeId TypeChecker::freshType(TypeLevel level)
 {
-    return FFlag::LuauFreeTypesMustHaveBounds ? currentModule->internalTypes.freshType(builtinTypes, level)
-                                              : currentModule->internalTypes.addType(Type(FreeType(level)));
+    return currentModule->internalTypes.addType(Type(FreeType(level)));
 }
 
 TypeId TypeChecker::singletonType(bool value)
@@ -5721,18 +5716,8 @@ TypeId TypeChecker::resolveTypeWorker(const ScopePtr& scope, const AstType& anno
         TypeId ty = checkExpr(scope, *typeOf->expr).type;
         return ty;
     }
-    else if (annotation.is<AstTypeOptional>())
-    {
-        return builtinTypes->nilType;
-    }
     else if (const auto& un = annotation.as<AstTypeUnion>())
     {
-        if (FFlag::LuauPreserveUnionIntersectionNodeForLeadingTokenSingleType)
-        {
-            if (un->types.size == 1)
-                return resolveType(scope, *un->types.data[0]);
-        }
-
         std::vector<TypeId> types;
         for (AstType* ann : un->types)
             types.push_back(resolveType(scope, *ann));
@@ -5741,22 +5726,12 @@ TypeId TypeChecker::resolveTypeWorker(const ScopePtr& scope, const AstType& anno
     }
     else if (const auto& un = annotation.as<AstTypeIntersection>())
     {
-        if (FFlag::LuauPreserveUnionIntersectionNodeForLeadingTokenSingleType)
-        {
-            if (un->types.size == 1)
-                return resolveType(scope, *un->types.data[0]);
-        }
-
         std::vector<TypeId> types;
         for (AstType* ann : un->types)
             types.push_back(resolveType(scope, *ann));
 
         return addType(IntersectionType{types});
     }
-    else if (const auto& g = annotation.as<AstTypeGroup>())
-    {
-        return resolveType(scope, *g->type);
-    }
     else if (const auto& tsb = annotation.as<AstTypeSingletonBool>())
     {
         return singletonType(tsb->value);
@@ -5914,8 +5889,8 @@ GenericTypeDefinitions TypeChecker::createGenericTypes(
     const ScopePtr& scope,
     std::optional<TypeLevel> levelOpt,
     const AstNode& node,
-    const AstArray<AstGenericType*>& genericNames,
-    const AstArray<AstGenericTypePack*>& genericPackNames,
+    const AstArray<AstGenericType>& genericNames,
+    const AstArray<AstGenericTypePack>& genericPackNames,
     bool useCache
 )
 {
@@ -5925,14 +5900,14 @@ GenericTypeDefinitions TypeChecker::createGenericTypes(
 
     std::vector<GenericTypeDefinition> generics;
 
-    for (const AstGenericType* generic : genericNames)
+    for (const AstGenericType& generic : genericNames)
     {
         std::optional<TypeId> defaultValue;
 
-        if (generic->defaultValue)
-            defaultValue = resolveType(scope, *generic->defaultValue);
+        if (generic.defaultValue)
+            defaultValue = resolveType(scope, *generic.defaultValue);
 
-        Name n = generic->name.value;
+        Name n = generic.name.value;
 
         // These generics are the only thing that will ever be added to scope, so we can be certain that
         // a collision can only occur when two generic types have the same name.
@@ -5961,14 +5936,14 @@ GenericTypeDefinitions TypeChecker::createGenericTypes(
 
     std::vector<GenericTypePackDefinition> genericPacks;
 
-    for (const AstGenericTypePack* genericPack : genericPackNames)
+    for (const AstGenericTypePack& genericPack : genericPackNames)
     {
         std::optional<TypePackId> defaultValue;
 
-        if (genericPack->defaultValue)
-            defaultValue = resolveTypePack(scope, *genericPack->defaultValue);
+        if (genericPack.defaultValue)
+            defaultValue = resolveTypePack(scope, *genericPack.defaultValue);
 
-        Name n = genericPack->name.value;
+        Name n = genericPack.name.value;
 
         // These generics are the only thing that will ever be added to scope, so we can be certain that
         // a collision can only occur when two generic types have the same name.

Analysis/src/TypePath.cpp

@@ -14,7 +14,6 @@
 #include <type_traits>
 
 LUAU_FASTFLAG(LuauSolverV2);
-LUAU_FASTFLAGVARIABLE(LuauDisableNewSolverAssertsInMixedMode)
 
 // Maximum number of steps to follow when traversing a path. May not always
 // equate to the number of components in a path, depending on the traversal
@@ -157,16 +156,14 @@ Path PathBuilder::build()
 
 PathBuilder& PathBuilder::readProp(std::string name)
 {
-    if (!FFlag::LuauDisableNewSolverAssertsInMixedMode)
-        LUAU_ASSERT(FFlag::LuauSolverV2);
+    LUAU_ASSERT(FFlag::LuauSolverV2);
     components.push_back(Property{std::move(name), true});
     return *this;
 }
 
 PathBuilder& PathBuilder::writeProp(std::string name)
 {
-    if (!FFlag::LuauDisableNewSolverAssertsInMixedMode)
-        LUAU_ASSERT(FFlag::LuauSolverV2);
+    LUAU_ASSERT(FFlag::LuauSolverV2);
     components.push_back(Property{std::move(name), false});
     return *this;
 }
@@ -639,247 +636,6 @@ std::string toString(const TypePath::Path& path, bool prefixDot)
     return result.str();
 }
 
-std::string toStringHuman(const TypePath::Path& path)
-{
-    LUAU_ASSERT(FFlag::LuauSolverV2);
-
-    enum class State
-    {
-        Initial,
-        Normal,
-        Property,
-        PendingIs,
-        PendingAs,
-        PendingWhich,
-    };
-
-    std::stringstream result;
-    State state = State::Initial;
-    bool last = false;
-
-    auto strComponent = [&](auto&& c)
-    {
-        using T = std::decay_t<decltype(c)>;
-        if constexpr (std::is_same_v<T, TypePath::Property>)
-        {
-            if (state == State::PendingIs)
-                result << ", ";
-
-            switch (state)
-            {
-            case State::Initial:
-            case State::PendingIs:
-                if (c.isRead)
-                    result << "accessing `";
-                else
-                    result << "writing to `";
-                break;
-            case State::Property:
-                // if the previous state was a property, then we're doing a sequence of indexing
-                result << '.';
-                break;
-            default:
-                break;
-            }
-
-            result << c.name;
-
-            state = State::Property;
-        }
-        else if constexpr (std::is_same_v<T, TypePath::Index>)
-        {
-            size_t humanIndex = c.index + 1;
-
-            if (state == State::Initial && !last)
-                result << "in" << ' ';
-            else if (state == State::PendingIs)
-                result << ' ' << "has" << ' ';
-            else if (state == State::Property)
-                result << '`' << ' ' << "has" << ' ';
-
-            result << "the " << humanIndex;
-            switch (humanIndex)
-            {
-            case 1:
-                result << "st";
-                break;
-            case 2:
-                result << "nd";
-                break;
-            case 3:
-                result << "rd";
-                break;
-            default:
-                result << "th";
-            }
-
-            switch (c.variant)
-            {
-            case TypePath::Index::Variant::Pack:
-                result << ' ' << "entry in the type pack";
-                break;
-            case TypePath::Index::Variant::Union:
-                result << ' ' << "component of the union";
-                break;
-            case TypePath::Index::Variant::Intersection:
-                result << ' ' << "component of the intersection";
-                break;
-            }
-
-            if (state == State::PendingWhich)
-                result << ' ' << "which";
-
-            if (state == State::PendingIs || state == State::Property)
-                state = State::PendingAs;
-            else
-                state = State::PendingIs;
-        }
-        else if constexpr (std::is_same_v<T, TypePath::TypeField>)
-        {
-            if (state == State::Initial && !last)
-                result << "in" << ' ';
-            else if (state == State::PendingIs)
-                result << ", ";
-            else if (state == State::Property)
-                result << '`' << ' ' << "has" << ' ';
-
-            switch (c)
-            {
-            case TypePath::TypeField::Table:
-                result << "the table portion";
-                if (state == State::Property)
-                    state = State::PendingAs;
-                else
-                    state = State::PendingIs;
-                break;
-            case TypePath::TypeField::Metatable:
-                result << "the metatable portion";
-                if (state == State::Property)
-                    state = State::PendingAs;
-                else
-                    state = State::PendingIs;
-                break;
-            case TypePath::TypeField::LowerBound:
-                result << "the lower bound of" << ' ';
-                state = State::Normal;
-                break;
-            case TypePath::TypeField::UpperBound:
-                result << "the upper bound of" << ' ';
-                state = State::Normal;
-                break;
-            case TypePath::TypeField::IndexLookup:
-                result << "the index type";
-                if (state == State::Property)
-                    state = State::PendingAs;
-                else
-                    state = State::PendingIs;
-                break;
-            case TypePath::TypeField::IndexResult:
-                result << "the result of indexing";
-                if (state == State::Property)
-                    state = State::PendingAs;
-                else
-                    state = State::PendingIs;
-                break;
-            case TypePath::TypeField::Negated:
-                result << "the negation" << ' ';
-                state = State::Normal;
-                break;
-            case TypePath::TypeField::Variadic:
-                result << "the variadic" << ' ';
-                state = State::Normal;
-                break;
-            }
-        }
-        else if constexpr (std::is_same_v<T, TypePath::PackField>)
-        {
-            if (state == State::PendingIs)
-                result << ", ";
-            else if (state == State::Property)
-                result << "`, ";
-
-            switch (c)
-            {
-            case TypePath::PackField::Arguments:
-                if (state == State::Initial)
-                    result << "it" << ' ';
-                else if (state == State::PendingIs)
-                    result << "the function" << ' ';
-
-                result << "takes";
-                break;
-            case TypePath::PackField::Returns:
-                if (state == State::Initial)
-                    result << "it" << ' ';
-                else if (state == State::PendingIs)
-                    result << "the function" << ' ';
-
-                result << "returns";
-                break;
-            case TypePath::PackField::Tail:
-                if (state == State::Initial)
-                    result << "it has" << ' ';
-                result << "a tail of";
-                break;
-            }
-
-            if (state == State::PendingIs)
-            {
-                result << ' ';
-                state = State::PendingWhich;
-            }
-            else
-            {
-                result << ' ';
-                state = State::Normal;
-            }
-        }
-        else if constexpr (std::is_same_v<T, TypePath::Reduction>)
-        {
-            if (state == State::Initial)
-                result << "it" << ' ';
-            result << "reduces to" << ' ';
-            state = State::Normal;
-        }
-        else
-        {
-            static_assert(always_false_v<T>, "Unhandled Component variant");
-        }
-    };
-
-    size_t count = 0;
-
-    for (const TypePath::Component& component : path.components)
-    {
-        count++;
-        if (count == path.components.size())
-            last = true;
-
-        Luau::visit(strComponent, component);
-    }
-
-    switch (state)
-    {
-    case State::Property:
-        result << "` results in ";
-        break;
-    case State::PendingWhich:
-        // pending `which` becomes `is` if it's at the end
-        result << "is" << ' ';
-        break;
-    case State::PendingIs:
-        result << ' ' << "is" << ' ';
-        break;
-    case State::PendingAs:
-        result << ' ' << "as" << ' ';
-        break;
-    default:
-        break;
-    }
-
-    return result.str();
-}
-
 static bool traverse(TraversalState& state, const Path& path)
 {
     auto step = [&state](auto&& c)

Analysis/src/TypeUtils.cpp

@@ -5,7 +5,6 @@
 #include "Luau/Normalize.h"
 #include "Luau/Scope.h"
 #include "Luau/ToString.h"
-#include "Luau/Type.h"
 #include "Luau/TypeInfer.h"
 
 #include <algorithm>
@@ -13,8 +12,7 @@
 LUAU_FASTFLAG(LuauSolverV2);
 LUAU_FASTFLAG(LuauAutocompleteRefactorsForIncrementalAutocomplete);
 LUAU_FASTFLAG(LuauTrackInteriorFreeTypesOnScope);
-LUAU_FASTFLAG(LuauFreeTypesMustHaveBounds)
-LUAU_FASTFLAG(LuauDisableNewSolverAssertsInMixedMode)
+
 namespace Luau
 {
 
@@ -325,7 +323,7 @@ TypePack extendTypePack(
                             trackInteriorFreeType(ftp->scope, t);
                     }
                     else
-                        t = FFlag::LuauFreeTypesMustHaveBounds ? arena.freshType(builtinTypes, ftp->scope) : arena.freshType_DEPRECATED(ftp->scope);
+                        t = arena.freshType(ftp->scope);
                 }
 
                 newPack.head.push_back(t);
@@ -550,10 +548,7 @@ std::vector<TypeId> findBlockedArgTypesIn(AstExprCall* expr, NotNull<DenseHashMa
 
 void trackInteriorFreeType(Scope* scope, TypeId ty)
 {
-    if (FFlag::LuauDisableNewSolverAssertsInMixedMode)
-        LUAU_ASSERT(FFlag::LuauTrackInteriorFreeTypesOnScope);
-    else
-        LUAU_ASSERT(FFlag::LuauSolverV2 && FFlag::LuauTrackInteriorFreeTypesOnScope);
+    LUAU_ASSERT(FFlag::LuauSolverV2 && FFlag::LuauTrackInteriorFreeTypesOnScope);
     for (; scope; scope = scope->parent.get())
     {
         if (scope->interiorFreeTypes)

Analysis/src/TypedAllocator.cpp

@@ -24,7 +24,6 @@ const size_t kPageSize = sysconf(_SC_PAGESIZE);
 #endif
 #endif
 
-#include <stdint.h>
 #include <stdlib.h>
 
 LUAU_FASTFLAG(DebugLuauFreezeArena)

Analysis/src/Unifier.cpp

@@ -22,7 +22,6 @@ LUAU_FASTFLAGVARIABLE(LuauTransitiveSubtyping)
 LUAU_FASTFLAG(LuauSolverV2)
 LUAU_FASTFLAGVARIABLE(LuauFixIndexerSubtypingOrdering)
 LUAU_FASTFLAGVARIABLE(LuauUnifierRecursionOnRestart)
-LUAU_FASTFLAG(LuauFreeTypesMustHaveBounds)
 
 namespace Luau
 {
@@ -33,20 +32,38 @@ struct PromoteTypeLevels final : TypeOnceVisitor
     const TypeArena* typeArena = nullptr;
     TypeLevel minLevel;
 
-    PromoteTypeLevels(TxnLog& log, const TypeArena* typeArena, TypeLevel minLevel)
+    Scope* outerScope = nullptr;
+    bool useScopes;
+
+    PromoteTypeLevels(TxnLog& log, const TypeArena* typeArena, TypeLevel minLevel, Scope* outerScope, bool useScopes)
         : log(log)
         , typeArena(typeArena)
         , minLevel(minLevel)
+        , outerScope(outerScope)
+        , useScopes(useScopes)
     {
     }
 
     template<typename TID, typename T>
     void promote(TID ty, T* t)
     {
+        if (useScopes && !t)
+            return;
+
         LUAU_ASSERT(t);
 
-        if (minLevel.subsumesStrict(t->level))
-            log.changeLevel(ty, minLevel);
+        if (useScopes)
+        {
+            if (subsumesStrict(outerScope, t->scope))
+                log.changeScope(ty, NotNull{outerScope});
+        }
+        else
+        {
+            if (minLevel.subsumesStrict(t->level))
+            {
+                log.changeLevel(ty, minLevel);
+            }
+        }
     }
 
     bool visit(TypeId ty) override
@@ -123,23 +140,23 @@ struct PromoteTypeLevels final : TypeOnceVisitor
     }
 };
 
-static void promoteTypeLevels(TxnLog& log, const TypeArena* typeArena, TypeLevel minLevel, TypeId ty)
+static void promoteTypeLevels(TxnLog& log, const TypeArena* typeArena, TypeLevel minLevel, Scope* outerScope, bool useScopes, TypeId ty)
 {
     // Type levels of types from other modules are already global, so we don't need to promote anything inside
     if (ty->owningArena != typeArena)
         return;
 
-    PromoteTypeLevels ptl{log, typeArena, minLevel};
+    PromoteTypeLevels ptl{log, typeArena, minLevel, outerScope, useScopes};
     ptl.traverse(ty);
 }
 
-void promoteTypeLevels(TxnLog& log, const TypeArena* typeArena, TypeLevel minLevel, TypePackId tp)
+void promoteTypeLevels(TxnLog& log, const TypeArena* typeArena, TypeLevel minLevel, Scope* outerScope, bool useScopes, TypePackId tp)
 {
     // Type levels of types from other modules are already global, so we don't need to promote anything inside
     if (tp->owningArena != typeArena)
         return;
 
-    PromoteTypeLevels ptl{log, typeArena, minLevel};
+    PromoteTypeLevels ptl{log, typeArena, minLevel, outerScope, useScopes};
     ptl.traverse(tp);
 }
 
@@ -352,9 +369,12 @@ static std::optional<std::pair<Luau::Name, const SingletonType*>> getTableMatchT
 }
 
 template<typename TY_A, typename TY_B>
-static bool subsumes(TY_A* left, TY_B* right)
+static bool subsumes(bool useScopes, TY_A* left, TY_B* right)
 {
-    return left->level.subsumes(right->level);
+    if (useScopes)
+        return subsumes(left->scope, right->scope);
+    else
+        return left->level.subsumes(right->level);
 }
 
 TypeMismatch::Context Unifier::mismatchContext()
@@ -443,7 +463,7 @@ void Unifier::tryUnify_(TypeId subTy, TypeId superTy, bool isFunctionCall, bool
     auto superFree = log.getMutable<FreeType>(superTy);
     auto subFree = log.getMutable<FreeType>(subTy);
 
-    if (superFree && subFree && subsumes(superFree, subFree))
+    if (superFree && subFree && subsumes(useNewSolver, superFree, subFree))
     {
         if (!occursCheck(subTy, superTy, /* reversed = */ false))
             log.replace(subTy, BoundType(superTy));
@@ -454,7 +474,7 @@ void Unifier::tryUnify_(TypeId subTy, TypeId superTy, bool isFunctionCall, bool
     {
         if (!occursCheck(superTy, subTy, /* reversed = */ true))
         {
-            if (subsumes(superFree, subFree))
+            if (subsumes(useNewSolver, superFree, subFree))
             {
                 log.changeLevel(subTy, superFree->level);
             }
@@ -468,7 +488,7 @@ void Unifier::tryUnify_(TypeId subTy, TypeId superTy, bool isFunctionCall, bool
     {
         // Unification can't change the level of a generic.
         auto subGeneric = log.getMutable<GenericType>(subTy);
-        if (subGeneric && !subsumes(subGeneric, superFree))
+        if (subGeneric && !subsumes(useNewSolver, subGeneric, superFree))
         {
             // TODO: a more informative error message? CLI-39912
             reportError(location, GenericError{"Generic subtype escaping scope"});
@@ -477,7 +497,7 @@ void Unifier::tryUnify_(TypeId subTy, TypeId superTy, bool isFunctionCall, bool
 
         if (!occursCheck(superTy, subTy, /* reversed = */ true))
         {
-            promoteTypeLevels(log, types, superFree->level, subTy);
+            promoteTypeLevels(log, types, superFree->level, superFree->scope, useNewSolver, subTy);
 
             Widen widen{types, builtinTypes};
             log.replace(superTy, BoundType(widen(subTy)));
@@ -494,7 +514,7 @@ void Unifier::tryUnify_(TypeId subTy, TypeId superTy, bool isFunctionCall, bool
 
         // Unification can't change the level of a generic.
         auto superGeneric = log.getMutable<GenericType>(superTy);
-        if (superGeneric && !subsumes(superGeneric, subFree))
+        if (superGeneric && !subsumes(useNewSolver, superGeneric, subFree))
         {
             // TODO: a more informative error message? CLI-39912
             reportError(location, GenericError{"Generic supertype escaping scope"});
@@ -503,7 +523,7 @@ void Unifier::tryUnify_(TypeId subTy, TypeId superTy, bool isFunctionCall, bool
 
         if (!occursCheck(subTy, superTy, /* reversed = */ false))
         {
-            promoteTypeLevels(log, types, subFree->level, superTy);
+            promoteTypeLevels(log, types, subFree->level, subFree->scope, useNewSolver, superTy);
             log.replace(subTy, BoundType(superTy));
         }
 
@@ -515,7 +535,7 @@ void Unifier::tryUnify_(TypeId subTy, TypeId superTy, bool isFunctionCall, bool
         auto superGeneric = log.getMutable<GenericType>(superTy);
         auto subGeneric = log.getMutable<GenericType>(subTy);
 
-        if (superGeneric && subGeneric && subsumes(superGeneric, subGeneric))
+        if (superGeneric && subGeneric && subsumes(useNewSolver, superGeneric, subGeneric))
         {
             if (!occursCheck(subTy, superTy, /* reversed = */ false))
                 log.replace(subTy, BoundType(superTy));
@@ -732,6 +752,9 @@ void Unifier::tryUnifyUnionWithType(TypeId subTy, const UnionType* subUnion, Typ
         std::unique_ptr<Unifier> innerState = makeChildUnifier();
         innerState->tryUnify_(type, superTy);
 
+        if (useNewSolver)
+            logs.push_back(std::move(innerState->log));
+
         if (auto e = hasUnificationTooComplex(innerState->errors))
             unificationTooComplex = e;
         else if (innerState->failure)
@@ -846,8 +869,13 @@ void Unifier::tryUnifyTypeWithUnion(TypeId subTy, TypeId superTy, const UnionTyp
         if (!innerState->failure)
         {
             found = true;
-            log.concat(std::move(innerState->log));
-            break;
+            if (useNewSolver)
+                logs.push_back(std::move(innerState->log));
+            else
+            {
+                log.concat(std::move(innerState->log));
+                break;
+            }
         }
         else if (innerState->errors.empty())
         {
@@ -866,6 +894,9 @@ void Unifier::tryUnifyTypeWithUnion(TypeId subTy, TypeId superTy, const UnionTyp
         }
     }
 
+    if (useNewSolver)
+        log.concatAsUnion(combineLogsIntoUnion(std::move(logs)), NotNull{types});
+
     if (unificationTooComplex)
     {
         reportError(*unificationTooComplex);
@@ -943,10 +974,16 @@ void Unifier::tryUnifyTypeWithIntersection(TypeId subTy, TypeId superTy, const I
                 firstFailedOption = {innerState->errors.front()};
         }
 
-        log.concat(std::move(innerState->log));
+        if (useNewSolver)
+            logs.push_back(std::move(innerState->log));
+        else
+            log.concat(std::move(innerState->log));
         failure |= innerState->failure;
     }
 
+    if (useNewSolver)
+        log.concat(combineLogsIntoIntersection(std::move(logs)));
+
     if (unificationTooComplex)
         reportError(*unificationTooComplex);
     else if (firstFailedOption)
@@ -994,6 +1031,28 @@ void Unifier::tryUnifyIntersectionWithType(TypeId subTy, const IntersectionType*
         }
     }
 
+    if (useNewSolver && normalize)
+    {
+        // Sometimes a negation type is inside one of the types, e.g. { p: number } & { p: ~number }.
+        NegationTypeFinder finder;
+        finder.traverse(subTy);
+
+        if (finder.found)
+        {
+            // It is possible that A & B <: T even though A </: T and B </: T
+            // for example (string?) & ~nil <: string.
+            // We deal with this by type normalization.
+            std::shared_ptr<const NormalizedType> subNorm = normalizer->normalize(subTy);
+            std::shared_ptr<const NormalizedType> superNorm = normalizer->normalize(superTy);
+            if (subNorm && superNorm)
+                tryUnifyNormalizedTypes(subTy, superTy, *subNorm, *superNorm, "none of the intersection parts are compatible");
+            else
+                reportError(location, NormalizationTooComplex{});
+
+            return;
+        }
+    }
+
     std::vector<TxnLog> logs;
 
     for (size_t i = 0; i < uv->parts.size(); ++i)
@@ -1010,7 +1069,7 @@ void Unifier::tryUnifyIntersectionWithType(TypeId subTy, const IntersectionType*
         {
             found = true;
             errorsSuppressed = innerState->failure;
-            if (innerState->failure)
+            if (useNewSolver || innerState->failure)
                 logs.push_back(std::move(innerState->log));
             else
             {
@@ -1025,7 +1084,9 @@ void Unifier::tryUnifyIntersectionWithType(TypeId subTy, const IntersectionType*
         }
     }
 
-    if (errorsSuppressed)
+    if (useNewSolver)
+        log.concat(combineLogsIntoIntersection(std::move(logs)));
+    else if (errorsSuppressed)
         log.concat(std::move(logs.front()));
 
     if (unificationTooComplex)
@@ -1139,6 +1200,24 @@ void Unifier::tryUnifyNormalizedTypes(
             }
         }
 
+        if (useNewSolver)
+        {
+            for (TypeId superTable : superNorm.tables)
+            {
+                std::unique_ptr<Unifier> innerState = makeChildUnifier();
+                innerState->tryUnify(subClass, superTable);
+
+                if (innerState->errors.empty())
+                {
+                    found = true;
+                    log.concat(std::move(innerState->log));
+                    break;
+                }
+                else if (auto e = hasUnificationTooComplex(innerState->errors))
+                    return reportError(*e);
+            }
+        }
+
         if (!found)
         {
             return reportError(location, TypeMismatch{superTy, subTy, reason, error, mismatchContext()});
@@ -1423,6 +1502,12 @@ struct WeirdIter
     }
 };
 
+void Unifier::enableNewSolver()
+{
+    useNewSolver = true;
+    log.useScopes = true;
+}
+
 ErrorVec Unifier::canUnify(TypeId subTy, TypeId superTy)
 {
     std::unique_ptr<Unifier> s = makeChildUnifier();
@@ -1502,6 +1587,8 @@ void Unifier::tryUnify_(TypePackId subTp, TypePackId superTp, bool isFunctionCal
         if (!occursCheck(superTp, subTp, /* reversed = */ true))
         {
             Widen widen{types, builtinTypes};
+            if (useNewSolver)
+                promoteTypeLevels(log, types, superFree->level, superFree->scope, /*useScopes*/ true, subTp);
             log.replace(superTp, Unifiable::Bound<TypePackId>(widen(subTp)));
         }
     }
@@ -1509,6 +1596,8 @@ void Unifier::tryUnify_(TypePackId subTp, TypePackId superTp, bool isFunctionCal
     {
         if (!occursCheck(subTp, superTp, /* reversed = */ false))
         {
+            if (useNewSolver)
+                promoteTypeLevels(log, types, subFree->level, subFree->scope, /*useScopes*/ true, superTp);
             log.replace(subTp, Unifiable::Bound<TypePackId>(superTp));
         }
     }
@@ -1559,7 +1648,7 @@ void Unifier::tryUnify_(TypePackId subTp, TypePackId superTp, bool isFunctionCal
             if (FFlag::LuauSolverV2)
                 return freshType(NotNull{types}, builtinTypes, scope);
             else
-                return FFlag::LuauFreeTypesMustHaveBounds ? types->freshType(builtinTypes, scope, level) : types->freshType_DEPRECATED(scope, level);
+                return types->freshType(scope, level);
         };
 
         const TypePackId emptyTp = types->addTypePack(TypePack{{}, std::nullopt});
@@ -1598,28 +1687,74 @@ void Unifier::tryUnify_(TypePackId subTp, TypePackId superTp, bool isFunctionCal
             // If both are at the end, we're done
             if (!superIter.good() && !subIter.good())
             {
-                const bool lFreeTail = superTpv->tail && log.getMutable<FreeTypePack>(log.follow(*superTpv->tail)) != nullptr;
-                const bool rFreeTail = subTpv->tail && log.getMutable<FreeTypePack>(log.follow(*subTpv->tail)) != nullptr;
-                if (lFreeTail && rFreeTail)
+                if (useNewSolver)
                 {
-                    tryUnify_(*subTpv->tail, *superTpv->tail);
-                }
-                else if (lFreeTail)
-                {
-                    tryUnify_(emptyTp, *superTpv->tail);
-                }
-                else if (rFreeTail)
-                {
-                    tryUnify_(emptyTp, *subTpv->tail);
-                }
-                else if (subTpv->tail && superTpv->tail)
-                {
-                    if (log.getMutable<VariadicTypePack>(superIter.packId))
-                        tryUnifyVariadics(subIter.packId, superIter.packId, false, int(subIter.index));
-                    else if (log.getMutable<VariadicTypePack>(subIter.packId))
-                        tryUnifyVariadics(superIter.packId, subIter.packId, true, int(superIter.index));
+                    if (subIter.tail() && superIter.tail())
+                        tryUnify_(*subIter.tail(), *superIter.tail());
+                    else if (subIter.tail())
+                    {
+                        const TypePackId subTail = log.follow(*subIter.tail());
+
+                        if (log.get<FreeTypePack>(subTail))
+                            tryUnify_(subTail, emptyTp);
+                        else if (log.get<GenericTypePack>(subTail))
+                            reportError(location, TypePackMismatch{subTail, emptyTp});
+                        else if (log.get<VariadicTypePack>(subTail) || log.get<ErrorTypePack>(subTail))
+                        {
+                            // Nothing.  This is ok.
+                        }
+                        else
+                        {
+                            ice("Unexpected subtype tail pack " + toString(subTail), location);
+                        }
+                    }
+                    else if (superIter.tail())
+                    {
+                        const TypePackId superTail = log.follow(*superIter.tail());
+
+                        if (log.get<FreeTypePack>(superTail))
+                            tryUnify_(emptyTp, superTail);
+                        else if (log.get<GenericTypePack>(superTail))
+                            reportError(location, TypePackMismatch{emptyTp, superTail});
+                        else if (log.get<VariadicTypePack>(superTail) || log.get<ErrorTypePack>(superTail))
+                        {
+                            // Nothing.  This is ok.
+                        }
+                        else
+                        {
+                            ice("Unexpected supertype tail pack " + toString(superTail), location);
+                        }
+                    }
                     else
+                    {
+                        // Nothing.  This is ok.
+                    }
+                }
+                else
+                {
+                    const bool lFreeTail = superTpv->tail && log.getMutable<FreeTypePack>(log.follow(*superTpv->tail)) != nullptr;
+                    const bool rFreeTail = subTpv->tail && log.getMutable<FreeTypePack>(log.follow(*subTpv->tail)) != nullptr;
+                    if (lFreeTail && rFreeTail)
+                    {
                         tryUnify_(*subTpv->tail, *superTpv->tail);
+                    }
+                    else if (lFreeTail)
+                    {
+                        tryUnify_(emptyTp, *superTpv->tail);
+                    }
+                    else if (rFreeTail)
+                    {
+                        tryUnify_(emptyTp, *subTpv->tail);
+                    }
+                    else if (subTpv->tail && superTpv->tail)
+                    {
+                        if (log.getMutable<VariadicTypePack>(superIter.packId))
+                            tryUnifyVariadics(subIter.packId, superIter.packId, false, int(subIter.index));
+                        else if (log.getMutable<VariadicTypePack>(subIter.packId))
+                            tryUnifyVariadics(superIter.packId, subIter.packId, true, int(superIter.index));
+                        else
+                            tryUnify_(*subTpv->tail, *superTpv->tail);
+                    }
                 }
 
                 break;
@@ -2076,7 +2211,7 @@ void Unifier::tryUnifyTables(TypeId subTy, TypeId superTy, bool isIntersection,
                 variance = Invariant;
 
             std::unique_ptr<Unifier> innerState = makeChildUnifier();
-            if (FFlag::LuauFixIndexerSubtypingOrdering)
+            if (useNewSolver || FFlag::LuauFixIndexerSubtypingOrdering)
                 innerState->tryUnify_(prop.type(), superTable->indexer->indexResultType);
             else
             {
@@ -2361,8 +2496,49 @@ void Unifier::tryUnifyWithMetatable(TypeId subTy, TypeId superTy, bool reversed)
         {
         case TableState::Free:
         {
-            tryUnify_(subTy, superMetatable->table);
-            log.bindTable(subTy, superTy);
+            if (useNewSolver)
+            {
+                std::unique_ptr<Unifier> innerState = makeChildUnifier();
+                bool missingProperty = false;
+
+                for (const auto& [propName, prop] : subTable->props)
+                {
+                    if (std::optional<TypeId> mtPropTy = findTablePropertyRespectingMeta(superTy, propName))
+                    {
+                        innerState->tryUnify(prop.type(), *mtPropTy);
+                    }
+                    else
+                    {
+                        reportError(mismatchError);
+                        missingProperty = true;
+                        break;
+                    }
+                }
+
+                if (const TableType* superTable = log.get<TableType>(log.follow(superMetatable->table)))
+                {
+                    // TODO: Unify indexers.
+                }
+
+                if (auto e = hasUnificationTooComplex(innerState->errors))
+                    reportError(*e);
+                else if (!innerState->errors.empty())
+                    reportError(TypeError{
+                        location,
+                        TypeMismatch{reversed ? subTy : superTy, reversed ? superTy : subTy, "", innerState->errors.front(), mismatchContext()}
+                    });
+                else if (!missingProperty)
+                {
+                    log.concat(std::move(innerState->log));
+                    log.bindTable(subTy, superTy);
+                    failure |= innerState->failure;
+                }
+            }
+            else
+            {
+                tryUnify_(subTy, superMetatable->table);
+                log.bindTable(subTy, superTy);
+            }
 
             break;
         }
@@ -2688,9 +2864,18 @@ std::optional<TypeId> Unifier::findTablePropertyRespectingMeta(TypeId lhsType, N
     return Luau::findTablePropertyRespectingMeta(builtinTypes, errors, lhsType, name, location);
 }
 
+TxnLog Unifier::combineLogsIntoIntersection(std::vector<TxnLog> logs)
+{
+    LUAU_ASSERT(useNewSolver);
+    TxnLog result(useNewSolver);
+    for (TxnLog& log : logs)
+        result.concatAsIntersections(std::move(log), NotNull{types});
+    return result;
+}
+
 TxnLog Unifier::combineLogsIntoUnion(std::vector<TxnLog> logs)
 {
-    TxnLog result;
+    TxnLog result(useNewSolver);
     for (TxnLog& log : logs)
         result.concatAsUnion(std::move(log), NotNull{types});
     return result;
@@ -2835,6 +3020,9 @@ std::unique_ptr<Unifier> Unifier::makeChildUnifier()
     u->normalize = normalize;
     u->checkInhabited = checkInhabited;
 
+    if (useNewSolver)
+        u->enableNewSolver();
+
     return u;
 }
 

Analysis/src/Unifier2.cpp

@@ -18,8 +18,6 @@
 #include <optional>
 
 LUAU_FASTINT(LuauTypeInferRecursionLimit)
-LUAU_FASTFLAGVARIABLE(LuauUnifyMetatableWithAny)
-LUAU_FASTFLAG(LuauExtraFollows)
 
 namespace Luau
 {
@@ -237,10 +235,6 @@ bool Unifier2::unify(TypeId subTy, TypeId superTy)
     auto superMetatable = get<MetatableType>(superTy);
     if (subMetatable && superMetatable)
         return unify(subMetatable, superMetatable);
-    else if (FFlag::LuauUnifyMetatableWithAny && subMetatable && superAny)
-        return unify(subMetatable, superAny);
-    else if (FFlag::LuauUnifyMetatableWithAny && subAny && superMetatable)
-        return unify(subAny, superMetatable);
     else if (subMetatable) // if we only have one metatable, unify with the inner table
         return unify(subMetatable->table, superTy);
     else if (superMetatable) // if we only have one metatable, unify with the inner table
@@ -283,7 +277,7 @@ bool Unifier2::unifyFreeWithType(TypeId subTy, TypeId superTy)
     if (superArgTail)
         return doDefault();
 
-    const IntersectionType* upperBoundIntersection = get<IntersectionType>(FFlag::LuauExtraFollows ? upperBound : subFree->upperBound);
+    const IntersectionType* upperBoundIntersection = get<IntersectionType>(subFree->upperBound);
     if (!upperBoundIntersection)
         return doDefault();
 
@@ -530,16 +524,6 @@ bool Unifier2::unify(const TableType* subTable, const AnyType* superAny)
     return true;
 }
 
-bool Unifier2::unify(const MetatableType* subMetatable, const AnyType*)
-{
-    return unify(subMetatable->metatable, builtinTypes->anyType) && unify(subMetatable->table, builtinTypes->anyType);
-}
-
-bool Unifier2::unify(const AnyType*, const MetatableType* superMetatable)
-{
-    return unify(builtinTypes->anyType, superMetatable->metatable) && unify(builtinTypes->anyType, superMetatable->table);
-}
-
 // FIXME?  This should probably return an ErrorVec or an optional<TypeError>
 // rather than a boolean to signal an occurs check failure.
 bool Unifier2::unify(TypePackId subTp, TypePackId superTp)
@@ -650,33 +634,38 @@ struct FreeTypeSearcher : TypeVisitor
     {
     }
 
-    Polarity polarity = Polarity::Positive;
+    enum Polarity
+    {
+        Positive,
+        Negative,
+        Both,
+    };
+
+    Polarity polarity = Positive;
 
     void flip()
     {
         switch (polarity)
         {
-        case Polarity::Positive:
-            polarity = Polarity::Negative;
+        case Positive:
+            polarity = Negative;
             break;
-        case Polarity::Negative:
-            polarity = Polarity::Positive;
+        case Negative:
+            polarity = Positive;
             break;
-        case Polarity::Mixed:
+        case Both:
             break;
-        default:
-            LUAU_ASSERT(!"Unreachable");
         }
     }
 
     DenseHashSet<const void*> seenPositive{nullptr};
     DenseHashSet<const void*> seenNegative{nullptr};
 
-    bool seenWithCurrentPolarity(const void* ty)
+    bool seenWithPolarity(const void* ty)
     {
         switch (polarity)
         {
-        case Polarity::Positive:
+        case Positive:
         {
             if (seenPositive.contains(ty))
                 return true;
@@ -684,7 +673,7 @@ struct FreeTypeSearcher : TypeVisitor
             seenPositive.insert(ty);
             return false;
         }
-        case Polarity::Negative:
+        case Negative:
         {
             if (seenNegative.contains(ty))
                 return true;
@@ -692,7 +681,7 @@ struct FreeTypeSearcher : TypeVisitor
             seenNegative.insert(ty);
             return false;
         }
-        case Polarity::Mixed:
+        case Both:
         {
             if (seenPositive.contains(ty) && seenNegative.contains(ty))
                 return true;
@@ -701,8 +690,6 @@ struct FreeTypeSearcher : TypeVisitor
             seenNegative.insert(ty);
             return false;
         }
-        default:
-            LUAU_ASSERT(!"Unreachable");
         }
 
         return false;
@@ -716,7 +703,7 @@ struct FreeTypeSearcher : TypeVisitor
 
     bool visit(TypeId ty) override
     {
-        if (seenWithCurrentPolarity(ty))
+        if (seenWithPolarity(ty))
             return false;
 
         LUAU_ASSERT(ty);
@@ -725,7 +712,7 @@ struct FreeTypeSearcher : TypeVisitor
 
     bool visit(TypeId ty, const FreeType& ft) override
     {
-        if (seenWithCurrentPolarity(ty))
+        if (seenWithPolarity(ty))
             return false;
 
         if (!subsumes(scope, ft.scope))
@@ -733,18 +720,16 @@ struct FreeTypeSearcher : TypeVisitor
 
         switch (polarity)
         {
-        case Polarity::Positive:
+        case Positive:
             positiveTypes[ty]++;
             break;
-        case Polarity::Negative:
+        case Negative:
             negativeTypes[ty]++;
             break;
-        case Polarity::Mixed:
+        case Both:
             positiveTypes[ty]++;
             negativeTypes[ty]++;
             break;
-        default:
-            LUAU_ASSERT(!"Unreachable");
         }
 
         return true;
@@ -752,25 +737,23 @@ struct FreeTypeSearcher : TypeVisitor
 
     bool visit(TypeId ty, const TableType& tt) override
     {
-        if (seenWithCurrentPolarity(ty))
+        if (seenWithPolarity(ty))
             return false;
 
         if ((tt.state == TableState::Free || tt.state == TableState::Unsealed) && subsumes(scope, tt.scope))
         {
             switch (polarity)
             {
-            case Polarity::Positive:
+            case Positive:
                 positiveTypes[ty]++;
                 break;
-            case Polarity::Negative:
+            case Negative:
                 negativeTypes[ty]++;
                 break;
-            case Polarity::Mixed:
+            case Both:
                 positiveTypes[ty]++;
                 negativeTypes[ty]++;
                 break;
-            default:
-                LUAU_ASSERT(!"Unreachable");
             }
         }
 
@@ -783,7 +766,7 @@ struct FreeTypeSearcher : TypeVisitor
                 LUAU_ASSERT(prop.isShared());
 
                 Polarity p = polarity;
-                polarity = Polarity::Mixed;
+                polarity = Both;
                 traverse(prop.type());
                 polarity = p;
             }
@@ -800,7 +783,7 @@ struct FreeTypeSearcher : TypeVisitor
 
     bool visit(TypeId ty, const FunctionType& ft) override
     {
-        if (seenWithCurrentPolarity(ty))
+        if (seenWithPolarity(ty))
             return false;
 
         flip();
@@ -819,7 +802,7 @@ struct FreeTypeSearcher : TypeVisitor
 
     bool visit(TypePackId tp, const FreeTypePack& ftp) override
     {
-        if (seenWithCurrentPolarity(tp))
+        if (seenWithPolarity(tp))
             return false;
 
         if (!subsumes(scope, ftp.scope))
@@ -827,18 +810,16 @@ struct FreeTypeSearcher : TypeVisitor
 
         switch (polarity)
         {
-        case Polarity::Positive:
+        case Positive:
             positiveTypes[tp]++;
             break;
-        case Polarity::Negative:
+        case Negative:
             negativeTypes[tp]++;
             break;
-        case Polarity::Mixed:
+        case Both:
             positiveTypes[tp]++;
             negativeTypes[tp]++;
             break;
-        default:
-            LUAU_ASSERT(!"Unreachable");
         }
 
         return true;

Ast/include/Luau/Allocator.h

@@ -38,7 +38,7 @@ private:
     {
         Page* next;
 
-        alignas(8) char data[8192];
+        char data[8192];
     };
 
     Page* root;

Ast/include/Luau/Ast.h

@@ -120,6 +120,20 @@ struct AstTypeList
 
 using AstArgumentName = std::pair<AstName, Location>; // TODO: remove and replace when we get a common struct for this pair instead of AstName
 
+struct AstGenericType
+{
+    AstName name;
+    Location location;
+    AstType* defaultValue = nullptr;
+};
+
+struct AstGenericTypePack
+{
+    AstName name;
+    Location location;
+    AstTypePack* defaultValue = nullptr;
+};
+
 extern int gAstRttiIndex;
 
 template<typename T>
@@ -194,7 +208,6 @@ public:
     {
         Checked,
         Native,
-        Deprecated,
     };
 
     AstAttr(const Location& location, Type type);
@@ -240,32 +253,6 @@ public:
     bool hasSemicolon;
 };
 
-class AstGenericType : public AstNode
-{
-public:
-    LUAU_RTTI(AstGenericType)
-
-    explicit AstGenericType(const Location& location, AstName name, AstType* defaultValue = nullptr);
-
-    void visit(AstVisitor* visitor) override;
-
-    AstName name;
-    AstType* defaultValue = nullptr;
-};
-
-class AstGenericTypePack : public AstNode
-{
-public:
-    LUAU_RTTI(AstGenericTypePack)
-
-    explicit AstGenericTypePack(const Location& location, AstName name, AstTypePack* defaultValue = nullptr);
-
-    void visit(AstVisitor* visitor) override;
-
-    AstName name;
-    AstTypePack* defaultValue = nullptr;
-};
-
 class AstExprGroup : public AstExpr
 {
 public:
@@ -437,8 +424,8 @@ public:
     AstExprFunction(
         const Location& location,
         const AstArray<AstAttr*>& attributes,
-        const AstArray<AstGenericType*>& generics,
-        const AstArray<AstGenericTypePack*>& genericPacks,
+        const AstArray<AstGenericType>& generics,
+        const AstArray<AstGenericTypePack>& genericPacks,
         AstLocal* self,
         const AstArray<AstLocal*>& args,
         bool vararg,
@@ -454,11 +441,10 @@ public:
     void visit(AstVisitor* visitor) override;
 
     bool hasNativeAttribute() const;
-    bool hasAttribute(AstAttr::Type attributeType) const;
 
     AstArray<AstAttr*> attributes;
-    AstArray<AstGenericType*> generics;
-    AstArray<AstGenericTypePack*> genericPacks;
+    AstArray<AstGenericType> generics;
+    AstArray<AstGenericTypePack> genericPacks;
     AstLocal* self;
     AstArray<AstLocal*> args;
     std::optional<AstTypeList> returnAnnotation;
@@ -871,8 +857,8 @@ public:
         const Location& location,
         const AstName& name,
         const Location& nameLocation,
-        const AstArray<AstGenericType*>& generics,
-        const AstArray<AstGenericTypePack*>& genericPacks,
+        const AstArray<AstGenericType>& generics,
+        const AstArray<AstGenericTypePack>& genericPacks,
         AstType* type,
         bool exported
     );
@@ -881,8 +867,8 @@ public:
 
     AstName name;
     Location nameLocation;
-    AstArray<AstGenericType*> generics;
-    AstArray<AstGenericTypePack*> genericPacks;
+    AstArray<AstGenericType> generics;
+    AstArray<AstGenericTypePack> genericPacks;
     AstType* type;
     bool exported;
 };
@@ -892,22 +878,14 @@ class AstStatTypeFunction : public AstStat
 public:
     LUAU_RTTI(AstStatTypeFunction);
 
-    AstStatTypeFunction(
-        const Location& location,
-        const AstName& name,
-        const Location& nameLocation,
-        AstExprFunction* body,
-        bool exported,
-        bool hasErrors
-    );
+    AstStatTypeFunction(const Location& location, const AstName& name, const Location& nameLocation, AstExprFunction* body, bool exported);
 
     void visit(AstVisitor* visitor) override;
 
     AstName name;
     Location nameLocation;
-    AstExprFunction* body = nullptr;
-    bool exported = false;
-    bool hasErrors = false;
+    AstExprFunction* body;
+    bool exported;
 };
 
 class AstStatDeclareGlobal : public AstStat
@@ -933,8 +911,8 @@ public:
         const Location& location,
         const AstName& name,
         const Location& nameLocation,
-        const AstArray<AstGenericType*>& generics,
-        const AstArray<AstGenericTypePack*>& genericPacks,
+        const AstArray<AstGenericType>& generics,
+        const AstArray<AstGenericTypePack>& genericPacks,
         const AstTypeList& params,
         const AstArray<AstArgumentName>& paramNames,
         bool vararg,
@@ -947,8 +925,8 @@ public:
         const AstArray<AstAttr*>& attributes,
         const AstName& name,
         const Location& nameLocation,
-        const AstArray<AstGenericType*>& generics,
-        const AstArray<AstGenericTypePack*>& genericPacks,
+        const AstArray<AstGenericType>& generics,
+        const AstArray<AstGenericTypePack>& genericPacks,
         const AstTypeList& params,
         const AstArray<AstArgumentName>& paramNames,
         bool vararg,
@@ -960,13 +938,12 @@ public:
     void visit(AstVisitor* visitor) override;
 
     bool isCheckedFunction() const;
-    bool hasAttribute(AstAttr::Type attributeType) const;
 
     AstArray<AstAttr*> attributes;
     AstName name;
     Location nameLocation;
-    AstArray<AstGenericType*> generics;
-    AstArray<AstGenericTypePack*> genericPacks;
+    AstArray<AstGenericType> generics;
+    AstArray<AstGenericTypePack> genericPacks;
     AstTypeList params;
     AstArray<AstArgumentName> paramNames;
     bool vararg = false;
@@ -1097,8 +1074,8 @@ public:
 
     AstTypeFunction(
         const Location& location,
-        const AstArray<AstGenericType*>& generics,
-        const AstArray<AstGenericTypePack*>& genericPacks,
+        const AstArray<AstGenericType>& generics,
+        const AstArray<AstGenericTypePack>& genericPacks,
         const AstTypeList& argTypes,
         const AstArray<std::optional<AstArgumentName>>& argNames,
         const AstTypeList& returnTypes
@@ -1107,8 +1084,8 @@ public:
     AstTypeFunction(
         const Location& location,
         const AstArray<AstAttr*>& attributes,
-        const AstArray<AstGenericType*>& generics,
-        const AstArray<AstGenericTypePack*>& genericPacks,
+        const AstArray<AstGenericType>& generics,
+        const AstArray<AstGenericTypePack>& genericPacks,
         const AstTypeList& argTypes,
         const AstArray<std::optional<AstArgumentName>>& argNames,
         const AstTypeList& returnTypes
@@ -1117,11 +1094,10 @@ public:
     void visit(AstVisitor* visitor) override;
 
     bool isCheckedFunction() const;
-    bool hasAttribute(AstAttr::Type attributeType) const;
 
     AstArray<AstAttr*> attributes;
-    AstArray<AstGenericType*> generics;
-    AstArray<AstGenericTypePack*> genericPacks;
+    AstArray<AstGenericType> generics;
+    AstArray<AstGenericTypePack> genericPacks;
     AstTypeList argTypes;
     AstArray<std::optional<AstArgumentName>> argNames;
     AstTypeList returnTypes;
@@ -1139,16 +1115,6 @@ public:
     AstExpr* expr;
 };
 
-class AstTypeOptional : public AstType
-{
-public:
-    LUAU_RTTI(AstTypeOptional)
-
-    AstTypeOptional(const Location& location);
-
-    void visit(AstVisitor* visitor) override;
-};
-
 class AstTypeUnion : public AstType
 {
 public:
@@ -1238,18 +1204,6 @@ public:
     const AstArray<char> value;
 };
 
-class AstTypeGroup : public AstType
-{
-public:
-    LUAU_RTTI(AstTypeGroup)
-
-    explicit AstTypeGroup(const Location& location, AstType* type);
-
-    void visit(AstVisitor* visitor) override;
-
-    AstType* type;
-};
-
 class AstTypePack : public AstNode
 {
 public:
@@ -1310,16 +1264,6 @@ public:
         return visit(static_cast<AstNode*>(node));
     }
 
-    virtual bool visit(class AstGenericType* node)
-    {
-        return visit(static_cast<AstNode*>(node));
-    }
-
-    virtual bool visit(class AstGenericTypePack* node)
-    {
-        return visit(static_cast<AstNode*>(node));
-    }
-
     virtual bool visit(class AstExpr* node)
     {
         return visit(static_cast<AstNode*>(node));
@@ -1471,10 +1415,6 @@ public:
     {
         return visit(static_cast<AstStat*>(node));
     }
-    virtual bool visit(class AstStatTypeFunction* node)
-    {
-        return visit(static_cast<AstStat*>(node));
-    }
     virtual bool visit(class AstStatDeclareFunction* node)
     {
         return visit(static_cast<AstStat*>(node));
@@ -1514,10 +1454,6 @@ public:
     {
         return visit(static_cast<AstType*>(node));
     }
-    virtual bool visit(class AstTypeOptional* node)
-    {
-        return visit(static_cast<AstType*>(node));
-    }
     virtual bool visit(class AstTypeUnion* node)
     {
         return visit(static_cast<AstType*>(node));
@@ -1534,10 +1470,6 @@ public:
     {
         return visit(static_cast<AstType*>(node));
     }
-    virtual bool visit(class AstTypeGroup* node)
-    {
-        return visit(static_cast<AstType*>(node));
-    }
     virtual bool visit(class AstTypeError* node)
     {
         return visit(static_cast<AstType*>(node));

Ast/include/Luau/Cst.h

@@ -1,492 +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/Location.h"
-
-#include <string>
-
-namespace Luau
-{
-
-extern int gCstRttiIndex;
-
-template<typename T>
-struct CstRtti
-{
-    static const int value;
-};
-
-template<typename T>
-const int CstRtti<T>::value = ++gCstRttiIndex;
-
-#define LUAU_CST_RTTI(Class) \
-    static int CstClassIndex() \
-    { \
-        return CstRtti<Class>::value; \
-    }
-
-class CstNode
-{
-public:
-    explicit CstNode(int classIndex)
-        : classIndex(classIndex)
-    {
-    }
-
-    template<typename T>
-    bool is() const
-    {
-        return classIndex == T::CstClassIndex();
-    }
-    template<typename T>
-    T* as()
-    {
-        return classIndex == T::CstClassIndex() ? static_cast<T*>(this) : nullptr;
-    }
-    template<typename T>
-    const T* as() const
-    {
-        return classIndex == T::CstClassIndex() ? static_cast<const T*>(this) : nullptr;
-    }
-
-    const int classIndex;
-};
-
-class CstExprConstantNumber : public CstNode
-{
-public:
-    LUAU_CST_RTTI(CstExprConstantNumber)
-
-    explicit CstExprConstantNumber(const AstArray<char>& value);
-
-    AstArray<char> value;
-};
-
-class CstExprConstantString : public CstNode
-{
-public:
-    LUAU_CST_RTTI(CstExprConstantNumber)
-
-    enum QuoteStyle
-    {
-        QuotedSingle,
-        QuotedDouble,
-        QuotedRaw,
-        QuotedInterp,
-    };
-
-    CstExprConstantString(AstArray<char> sourceString, QuoteStyle quoteStyle, unsigned int blockDepth);
-
-    AstArray<char> sourceString;
-    QuoteStyle quoteStyle;
-    unsigned int blockDepth;
-};
-
-class CstExprCall : public CstNode
-{
-public:
-    LUAU_CST_RTTI(CstExprCall)
-
-    CstExprCall(std::optional<Position> openParens, std::optional<Position> closeParens, AstArray<Position> commaPositions);
-
-    std::optional<Position> openParens;
-    std::optional<Position> closeParens;
-    AstArray<Position> commaPositions;
-};
-
-class CstExprIndexExpr : public CstNode
-{
-public:
-    LUAU_CST_RTTI(CstExprIndexExpr)
-
-    CstExprIndexExpr(Position openBracketPosition, Position closeBracketPosition);
-
-    Position openBracketPosition;
-    Position closeBracketPosition;
-};
-
-class CstExprFunction : public CstNode
-{
-public:
-    LUAU_CST_RTTI(CstExprFunction)
-
-    CstExprFunction();
-
-    Position functionKeywordPosition{0, 0};
-    Position openGenericsPosition{0,0};
-    AstArray<Position> genericsCommaPositions;
-    Position closeGenericsPosition{0,0};
-    AstArray<Position> argsCommaPositions;
-    Position returnSpecifierPosition{0,0};
-};
-
-class CstExprTable : public CstNode
-{
-public:
-    LUAU_CST_RTTI(CstExprTable)
-
-    enum Separator
-    {
-        Comma,
-        Semicolon,
-    };
-
-    struct Item
-    {
-        std::optional<Position> indexerOpenPosition;  // '[', only if Kind == General
-        std::optional<Position> indexerClosePosition; // ']', only if Kind == General
-        std::optional<Position> equalsPosition;       // only if Kind != List
-        std::optional<Separator> separator;           // may be missing for last Item
-        std::optional<Position> separatorPosition;
-    };
-
-    explicit CstExprTable(const AstArray<Item>& items);
-
-    AstArray<Item> items;
-};
-
-// TODO: Shared between unary and binary, should we split?
-class CstExprOp : public CstNode
-{
-public:
-    LUAU_CST_RTTI(CstExprOp)
-
-    explicit CstExprOp(Position opPosition);
-
-    Position opPosition;
-};
-
-class CstExprTypeAssertion : public CstNode
-{
-public:
-    LUAU_CST_RTTI(CstExprTypeAssertion)
-
-    explicit CstExprTypeAssertion(Position opPosition);
-
-    Position opPosition;
-};
-
-class CstExprIfElse : public CstNode
-{
-public:
-    LUAU_CST_RTTI(CstExprIfElse)
-
-    CstExprIfElse(Position thenPosition, Position elsePosition, bool isElseIf);
-
-    Position thenPosition;
-    Position elsePosition;
-    bool isElseIf;
-};
-
-class CstExprInterpString : public CstNode
-{
-public:
-    LUAU_CST_RTTI(CstExprInterpString)
-
-    explicit CstExprInterpString(AstArray<AstArray<char>> sourceStrings, AstArray<Position> stringPositions);
-
-    AstArray<AstArray<char>> sourceStrings;
-    AstArray<Position> stringPositions;
-};
-
-class CstStatDo : public CstNode
-{
-public:
-    LUAU_CST_RTTI(CstStatDo)
-
-    explicit CstStatDo(Position endPosition);
-
-    Position endPosition;
-};
-
-class CstStatRepeat : public CstNode
-{
-public:
-    LUAU_CST_RTTI(CstStatRepeat)
-
-    explicit CstStatRepeat(Position untilPosition);
-
-    Position untilPosition;
-};
-
-class CstStatReturn : public CstNode
-{
-public:
-    LUAU_CST_RTTI(CstStatReturn)
-
-    explicit CstStatReturn(AstArray<Position> commaPositions);
-
-    AstArray<Position> commaPositions;
-};
-
-class CstStatLocal : public CstNode
-{
-public:
-    LUAU_CST_RTTI(CstStatLocal)
-
-    CstStatLocal(AstArray<Position> varsCommaPositions, AstArray<Position> valuesCommaPositions);
-
-    AstArray<Position> varsCommaPositions;
-    AstArray<Position> valuesCommaPositions;
-};
-
-class CstStatFor : public CstNode
-{
-public:
-    LUAU_CST_RTTI(CstStatFor)
-
-    CstStatFor(Position equalsPosition, Position endCommaPosition, std::optional<Position> stepCommaPosition);
-
-    Position equalsPosition;
-    Position endCommaPosition;
-    std::optional<Position> stepCommaPosition;
-};
-
-class CstStatForIn : public CstNode
-{
-public:
-    LUAU_CST_RTTI(CstStatForIn)
-
-    CstStatForIn(AstArray<Position> varsCommaPositions, AstArray<Position> valuesCommaPositions);
-
-    AstArray<Position> varsCommaPositions;
-    AstArray<Position> valuesCommaPositions;
-};
-
-class CstStatAssign : public CstNode
-{
-public:
-    LUAU_CST_RTTI(CstStatAssign)
-
-    CstStatAssign(AstArray<Position> varsCommaPositions, Position equalsPosition, AstArray<Position> valuesCommaPositions);
-
-    AstArray<Position> varsCommaPositions;
-    Position equalsPosition;
-    AstArray<Position> valuesCommaPositions;
-};
-
-class CstStatCompoundAssign : public CstNode
-{
-public:
-    LUAU_CST_RTTI(CstStatCompoundAssign)
-
-    explicit CstStatCompoundAssign(Position opPosition);
-
-    Position opPosition;
-};
-
-class CstStatFunction : public CstNode
-{
-public:
-    LUAU_CST_RTTI(CstStatFunction)
-
-    explicit CstStatFunction(Position functionKeywordPosition);
-
-    Position functionKeywordPosition;
-};
-
-class CstStatLocalFunction : public CstNode
-{
-public:
-    LUAU_CST_RTTI(CstStatLocalFunction)
-
-    explicit CstStatLocalFunction(Position localKeywordPosition, Position functionKeywordPosition);
-
-    Position localKeywordPosition;
-    Position functionKeywordPosition;
-};
-
-class CstGenericType : public CstNode
-{
-public:
-    LUAU_CST_RTTI(CstGenericType)
-
-    CstGenericType(std::optional<Position> defaultEqualsPosition);
-
-    std::optional<Position> defaultEqualsPosition;
-};
-
-class CstGenericTypePack : public CstNode
-{
-public:
-    LUAU_CST_RTTI(CstGenericTypePack)
-
-    CstGenericTypePack(Position ellipsisPosition, std::optional<Position> defaultEqualsPosition);
-
-    Position ellipsisPosition;
-    std::optional<Position> defaultEqualsPosition;
-};
-
-class CstStatTypeAlias : public CstNode
-{
-public:
-    LUAU_CST_RTTI(CstStatTypeAlias)
-
-    CstStatTypeAlias(
-        Position typeKeywordPosition,
-        Position genericsOpenPosition,
-        AstArray<Position> genericsCommaPositions,
-        Position genericsClosePosition,
-        Position equalsPosition
-    );
-
-    Position typeKeywordPosition;
-    Position genericsOpenPosition;
-    AstArray<Position> genericsCommaPositions;
-    Position genericsClosePosition;
-    Position equalsPosition;
-};
-
-class CstStatTypeFunction : public CstNode
-{
-public:
-    LUAU_CST_RTTI(CstStatTypeFunction)
-
-    CstStatTypeFunction(Position typeKeywordPosition, Position functionKeywordPosition);
-
-    Position typeKeywordPosition;
-    Position functionKeywordPosition;
-};
-
-class CstTypeReference : public CstNode
-{
-public:
-    LUAU_CST_RTTI(CstTypeReference)
-
-    CstTypeReference(
-        std::optional<Position> prefixPointPosition,
-        Position openParametersPosition,
-        AstArray<Position> parametersCommaPositions,
-        Position closeParametersPosition
-    );
-
-    std::optional<Position> prefixPointPosition;
-    Position openParametersPosition;
-    AstArray<Position> parametersCommaPositions;
-    Position closeParametersPosition;
-};
-
-class CstTypeTable : public CstNode
-{
-public:
-    LUAU_CST_RTTI(CstTypeTable)
-
-    struct Item
-    {
-        enum struct Kind
-        {
-            Indexer,
-            Property,
-            StringProperty,
-        };
-
-        Kind kind;
-        Position indexerOpenPosition;  // '[', only if Kind != Property
-        Position indexerClosePosition; // ']' only if Kind != Property
-        Position colonPosition;
-        std::optional<CstExprTable::Separator> separator; // may be missing for last Item
-        std::optional<Position> separatorPosition;
-
-        CstExprConstantString* stringInfo = nullptr; // only if Kind == StringProperty
-    };
-
-    CstTypeTable(AstArray<Item> items, bool isArray);
-
-    AstArray<Item> items;
-    bool isArray = false;
-};
-
-class CstTypeFunction : public CstNode
-{
-public:
-    LUAU_CST_RTTI(CstTypeFunction)
-
-    CstTypeFunction(
-        Position openGenericsPosition,
-        AstArray<Position> genericsCommaPositions,
-        Position closeGenericsPosition,
-        Position openArgsPosition,
-        AstArray<std::optional<Position>> argumentNameColonPositions,
-        AstArray<Position> argumentsCommaPositions,
-        Position closeArgsPosition,
-        Position returnArrowPosition
-    );
-
-    Position openGenericsPosition;
-    AstArray<Position> genericsCommaPositions;
-    Position closeGenericsPosition;
-    Position openArgsPosition;
-    AstArray<std::optional<Position>> argumentNameColonPositions;
-    AstArray<Position> argumentsCommaPositions;
-    Position closeArgsPosition;
-    Position returnArrowPosition;
-};
-
-class CstTypeTypeof : public CstNode
-{
-public:
-    LUAU_CST_RTTI(CstTypeTypeof)
-
-    CstTypeTypeof(Position openPosition, Position closePosition);
-
-    Position openPosition;
-    Position closePosition;
-};
-
-class CstTypeUnion : public CstNode
-{
-public:
-    LUAU_CST_RTTI(CstTypeUnion)
-
-    CstTypeUnion(std::optional<Position> leadingPosition, AstArray<Position> separatorPositions);
-
-    std::optional<Position> leadingPosition;
-    AstArray<Position> separatorPositions;
-};
-
-class CstTypeIntersection : public CstNode
-{
-public:
-    LUAU_CST_RTTI(CstTypeIntersection)
-
-    explicit CstTypeIntersection(std::optional<Position> leadingPosition, AstArray<Position> separatorPositions);
-
-    std::optional<Position> leadingPosition;
-    AstArray<Position> separatorPositions;
-};
-
-class CstTypeSingletonString : public CstNode
-{
-public:
-    LUAU_CST_RTTI(CstTypeSingletonString)
-
-    CstTypeSingletonString(AstArray<char> sourceString, CstExprConstantString::QuoteStyle quoteStyle, unsigned int blockDepth);
-
-    AstArray<char> sourceString;
-    CstExprConstantString::QuoteStyle quoteStyle;
-    unsigned int blockDepth;
-};
-
-class CstTypePackExplicit : public CstNode
-{
-public:
-    LUAU_CST_RTTI(CstTypePackExplicit)
-
-    CstTypePackExplicit(Position openParenthesesPosition, Position closeParenthesesPosition, AstArray<Position> commaPositions);
-
-    Position openParenthesesPosition;
-    Position closeParenthesesPosition;
-    AstArray<Position> commaPositions;
-};
-
-class CstTypePackGeneric : public CstNode
-{
-public:
-    LUAU_CST_RTTI(CstTypePackGeneric)
-
-    explicit CstTypePackGeneric(Position ellipsisPosition);
-
-    Position ellipsisPosition;
-};
-
-} // namespace Luau

Ast/include/Luau/Lexer.h

@@ -87,12 +87,6 @@ struct Lexeme
         Reserved_END
     };
 
-    enum struct QuoteStyle
-    {
-        Single,
-        Double,
-    };
-
     Type type;
     Location location;
 
@@ -117,8 +111,6 @@ public:
     Lexeme(const Location& location, Type type, const char* name);
 
     unsigned int getLength() const;
-    unsigned int getBlockDepth() const;
-    QuoteStyle getQuoteStyle() const;
 
     std::string toString() const;
 };
@@ -187,11 +179,6 @@ public:
     static bool fixupQuotedString(std::string& data);
     static void fixupMultilineString(std::string& data);
 
-    unsigned int getOffset() const
-    {
-        return offset;
-    }
-
 private:
     char peekch() const;
     char peekch(unsigned int lookahead) const;

Ast/include/Luau/ParseOptions.h

@@ -29,8 +29,6 @@ struct ParseOptions
     bool allowDeclarationSyntax = false;
     bool captureComments = false;
     std::optional<FragmentParseResumeSettings> parseFragment = std::nullopt;
-    bool storeCstData = false;
-    bool noErrorLimit = false;
 };
 
 } // namespace Luau

Ast/include/Luau/ParseResult.h

@@ -10,7 +10,6 @@ namespace Luau
 {
 
 class AstStatBlock;
-class CstNode;
 
 class ParseError : public std::exception
 {
@@ -56,8 +55,6 @@ struct Comment
     Location location;
 };
 
-using CstNodeMap = DenseHashMap<AstNode*, CstNode*>;
-
 struct ParseResult
 {
     AstStatBlock* root;
@@ -67,21 +64,6 @@ struct ParseResult
     std::vector<ParseError> errors;
 
     std::vector<Comment> commentLocations;
-
-    CstNodeMap cstNodeMap{nullptr};
-};
-
-struct ParseExprResult
-{
-    AstExpr* expr;
-    size_t lines = 0;
-
-    std::vector<HotComment> hotcomments;
-    std::vector<ParseError> errors;
-
-    std::vector<Comment> commentLocations;
-
-    CstNodeMap cstNodeMap{nullptr};
 };
 
 static constexpr const char* kParseNameError = "%error-id%";

Ast/include/Luau/Parser.h

@@ -8,7 +8,6 @@
 #include "Luau/StringUtils.h"
 #include "Luau/DenseHash.h"
 #include "Luau/Common.h"
-#include "Luau/Cst.h"
 
 #include <initializer_list>
 #include <optional>
@@ -63,14 +62,6 @@ public:
         ParseOptions options = ParseOptions()
     );
 
-    static ParseExprResult parseExpr(
-        const char* buffer,
-        std::size_t bufferSize,
-        AstNameTable& names,
-        Allocator& allocator,
-        ParseOptions options = ParseOptions()
-    );
-
 private:
     struct Name;
     struct Binding;
@@ -125,7 +116,7 @@ private:
     AstStat* parseFor();
 
     // funcname ::= Name {`.' Name} [`:' Name]
-    AstExpr* parseFunctionName(bool& hasself, AstName& debugname);
+    AstExpr* parseFunctionName(Location start_DEPRECATED, bool& hasself, AstName& debugname);
 
     // function funcname funcbody
     LUAU_FORCEINLINE AstStat* parseFunctionStat(const AstArray<AstAttr*>& attributes = {nullptr, 0});
@@ -152,14 +143,12 @@ private:
     AstStat* parseReturn();
 
     // type Name `=' Type
-    AstStat* parseTypeAlias(const Location& start, bool exported, Position typeKeywordPosition);
+    AstStat* parseTypeAlias(const Location& start, bool exported);
 
     // type function Name ... end
-    AstStat* parseTypeFunction(const Location& start, bool exported, Position typeKeywordPosition);
-
-    AstDeclaredClassProp parseDeclaredClassMethod(const AstArray<AstAttr*>& attributes);
-    AstDeclaredClassProp parseDeclaredClassMethod_DEPRECATED();
+    AstStat* parseTypeFunction(const Location& start, bool exported);
 
+    AstDeclaredClassProp parseDeclaredClassMethod();
 
     // `declare global' Name: Type |
     // `declare function' Name`(' [parlist] `)' [`:` Type]
@@ -184,19 +173,14 @@ private:
     );
 
     // explist ::= {exp `,'} exp
-    void parseExprList(TempVector<AstExpr*>& result, TempVector<Position>* commaPositions = nullptr);
+    void parseExprList(TempVector<AstExpr*>& result);
 
     // binding ::= Name [`:` Type]
     Binding parseBinding();
 
     // bindinglist ::= (binding | `...') {`,' bindinglist}
     // Returns the location of the vararg ..., or std::nullopt if the function is not vararg.
-    std::tuple<bool, Location, AstTypePack*> parseBindingList(
-        TempVector<Binding>& result,
-        bool allowDot3 = false,
-        AstArray<Position>* commaPositions = nullptr,
-        std::optional<Position> initialCommaPosition = std::nullopt
-    );
+    std::tuple<bool, Location, AstTypePack*> parseBindingList(TempVector<Binding>& result, bool allowDot3 = false);
 
     AstType* parseOptionalType();
 
@@ -212,34 +196,19 @@ private:
     //      |   `(' [TypeList] `)' `->` ReturnType
 
     // Returns the variadic annotation, if it exists.
-    AstTypePack* parseTypeList(
-        TempVector<AstType*>& result,
-        TempVector<std::optional<AstArgumentName>>& resultNames,
-        TempVector<Position>* commaPositions = nullptr,
-        TempVector<std::optional<Position>>* nameColonPositions = nullptr
-    );
+    AstTypePack* parseTypeList(TempVector<AstType*>& result, TempVector<std::optional<AstArgumentName>>& resultNames);
 
-    std::optional<AstTypeList> parseOptionalReturnType(Position* returnSpecifierPosition = nullptr);
+    std::optional<AstTypeList> parseOptionalReturnType();
     std::pair<Location, AstTypeList> parseReturnType();
 
-    struct TableIndexerResult
-    {
-        AstTableIndexer* node;
-        Position indexerOpenPosition;
-        Position indexerClosePosition;
-        Position colonPosition;
-    };
-
-    TableIndexerResult parseTableIndexer(AstTableAccess access, std::optional<Location> accessLocation, Lexeme begin);
-    // Remove with FFlagLuauStoreCSTData2
-    AstTableIndexer* parseTableIndexer_DEPRECATED(AstTableAccess access, std::optional<Location> accessLocation, Lexeme begin);
+    AstTableIndexer* parseTableIndexer(AstTableAccess access, std::optional<Location> accessLocation);
 
     AstTypeOrPack parseFunctionType(bool allowPack, const AstArray<AstAttr*>& attributes);
     AstType* parseFunctionTypeTail(
         const Lexeme& begin,
         const AstArray<AstAttr*>& attributes,
-        AstArray<AstGenericType*> generics,
-        AstArray<AstGenericTypePack*> genericPacks,
+        AstArray<AstGenericType> generics,
+        AstArray<AstGenericTypePack> genericPacks,
         AstArray<AstType*> params,
         AstArray<std::optional<AstArgumentName>> paramNames,
         AstTypePack* varargAnnotation
@@ -290,8 +259,6 @@ private:
     // args ::=  `(' [explist] `)' | tableconstructor | String
     AstExpr* parseFunctionArgs(AstExpr* func, bool self);
 
-    std::optional<CstExprTable::Separator> tableSeparator();
-
     // tableconstructor ::= `{' [fieldlist] `}'
     // fieldlist ::= field {fieldsep field} [fieldsep]
     // field ::= `[' exp `]' `=' exp | Name `=' exp | exp
@@ -310,21 +277,12 @@ private:
     Name parseIndexName(const char* context, const Position& previous);
 
     // `<' namelist `>'
-    std::pair<AstArray<AstGenericType*>, AstArray<AstGenericTypePack*>> parseGenericTypeList(
-        bool withDefaultValues,
-        Position* openPosition = nullptr,
-        AstArray<Position>* commaPositions = nullptr,
-        Position* closePosition = nullptr
-    );
+    std::pair<AstArray<AstGenericType>, AstArray<AstGenericTypePack>> parseGenericTypeList(bool withDefaultValues);
 
     // `<' Type[, ...] `>'
-    AstArray<AstTypeOrPack> parseTypeParams(
-        Position* openingPosition = nullptr,
-        TempVector<Position>* commaPositions = nullptr,
-        Position* closingPosition = nullptr
-    );
+    AstArray<AstTypeOrPack> parseTypeParams();
 
-    std::optional<AstArray<char>> parseCharArray(AstArray<char>* originalString = nullptr);
+    std::optional<AstArray<char>> parseCharArray();
     AstExpr* parseString();
     AstExpr* parseNumber();
 
@@ -334,9 +292,6 @@ private:
 
     void restoreLocals(unsigned int offset);
 
-    /// Returns string quote style and block depth
-    std::pair<CstExprConstantString::QuoteStyle, unsigned int> extractStringDetails();
-
     // check that parser is at lexeme/symbol, move to next lexeme/symbol on success, report failure and continue on failure
     bool expectAndConsume(char value, const char* context = nullptr);
     bool expectAndConsume(Lexeme::Type type, const char* context = nullptr);
@@ -480,7 +435,6 @@ private:
     std::vector<AstAttr*> scratchAttr;
     std::vector<AstStat*> scratchStat;
     std::vector<AstArray<char>> scratchString;
-    std::vector<AstArray<char>> scratchString2;
     std::vector<AstExpr*> scratchExpr;
     std::vector<AstExpr*> scratchExprAux;
     std::vector<AstName> scratchName;
@@ -488,21 +442,15 @@ private:
     std::vector<Binding> scratchBinding;
     std::vector<AstLocal*> scratchLocal;
     std::vector<AstTableProp> scratchTableTypeProps;
-    std::vector<CstTypeTable::Item> scratchCstTableTypeProps;
     std::vector<AstType*> scratchType;
     std::vector<AstTypeOrPack> scratchTypeOrPack;
     std::vector<AstDeclaredClassProp> scratchDeclaredClassProps;
     std::vector<AstExprTable::Item> scratchItem;
-    std::vector<CstExprTable::Item> scratchCstItem;
     std::vector<AstArgumentName> scratchArgName;
-    std::vector<AstGenericType*> scratchGenericTypes;
-    std::vector<AstGenericTypePack*> scratchGenericTypePacks;
+    std::vector<AstGenericType> scratchGenericTypes;
+    std::vector<AstGenericTypePack> scratchGenericTypePacks;
     std::vector<std::optional<AstArgumentName>> scratchOptArgName;
-    std::vector<Position> scratchPosition;
-    std::vector<std::optional<Position>> scratchOptPosition;
     std::string scratchData;
-
-    CstNodeMap cstNodeMap;
 };
 
 } // namespace Luau

Ast/src/Ast.cpp

@@ -3,24 +3,9 @@
 
 #include "Luau/Common.h"
 
-LUAU_FASTFLAG(LuauDeprecatedAttribute);
-
 namespace Luau
 {
 
-static bool hasAttributeInArray(const AstArray<AstAttr*> attributes, AstAttr::Type attributeType)
-{
-    LUAU_ASSERT(FFlag::LuauDeprecatedAttribute);
-
-    for (const auto attribute : attributes)
-    {
-        if (attribute->type == attributeType)
-            return true;
-    }
-
-    return false;
-}
-
 static void visitTypeList(AstVisitor* visitor, const AstTypeList& list)
 {
     for (AstType* ty : list.types)
@@ -43,38 +28,6 @@ void AstAttr::visit(AstVisitor* visitor)
 
 int gAstRttiIndex = 0;
 
-AstGenericType::AstGenericType(const Location& location, AstName name, AstType* defaultValue)
-    : AstNode(ClassIndex(), location)
-    , name(name)
-    , defaultValue(defaultValue)
-{
-}
-
-void AstGenericType::visit(AstVisitor* visitor)
-{
-    if (visitor->visit(this))
-    {
-        if (defaultValue)
-            defaultValue->visit(visitor);
-    }
-}
-
-AstGenericTypePack::AstGenericTypePack(const Location& location, AstName name, AstTypePack* defaultValue)
-    : AstNode(ClassIndex(), location)
-    , name(name)
-    , defaultValue(defaultValue)
-{
-}
-
-void AstGenericTypePack::visit(AstVisitor* visitor)
-{
-    if (visitor->visit(this))
-    {
-        if (defaultValue)
-            defaultValue->visit(visitor);
-    }
-}
-
 AstExprGroup::AstExprGroup(const Location& location, AstExpr* expr)
     : AstExpr(ClassIndex(), location)
     , expr(expr)
@@ -232,8 +185,8 @@ void AstExprIndexExpr::visit(AstVisitor* visitor)
 AstExprFunction::AstExprFunction(
     const Location& location,
     const AstArray<AstAttr*>& attributes,
-    const AstArray<AstGenericType*>& generics,
-    const AstArray<AstGenericTypePack*>& genericPacks,
+    const AstArray<AstGenericType>& generics,
+    const AstArray<AstGenericTypePack>& genericPacks,
     AstLocal* self,
     const AstArray<AstLocal*>& args,
     bool vararg,
@@ -292,13 +245,6 @@ bool AstExprFunction::hasNativeAttribute() const
     return false;
 }
 
-bool AstExprFunction::hasAttribute(const AstAttr::Type attributeType) const
-{
-    LUAU_ASSERT(FFlag::LuauDeprecatedAttribute);
-
-    return hasAttributeInArray(attributes, attributeType);
-}
-
 AstExprTable::AstExprTable(const Location& location, const AstArray<Item>& items)
     : AstExpr(ClassIndex(), location)
     , items(items)
@@ -775,8 +721,8 @@ AstStatTypeAlias::AstStatTypeAlias(
     const Location& location,
     const AstName& name,
     const Location& nameLocation,
-    const AstArray<AstGenericType*>& generics,
-    const AstArray<AstGenericTypePack*>& genericPacks,
+    const AstArray<AstGenericType>& generics,
+    const AstArray<AstGenericTypePack>& genericPacks,
     AstType* type,
     bool exported
 )
@@ -794,14 +740,16 @@ void AstStatTypeAlias::visit(AstVisitor* visitor)
 {
     if (visitor->visit(this))
     {
-        for (AstGenericType* el : generics)
+        for (const AstGenericType& el : generics)
         {
-            el->visit(visitor);
+            if (el.defaultValue)
+                el.defaultValue->visit(visitor);
         }
 
-        for (AstGenericTypePack* el : genericPacks)
+        for (const AstGenericTypePack& el : genericPacks)
         {
-            el->visit(visitor);
+            if (el.defaultValue)
+                el.defaultValue->visit(visitor);
         }
 
         type->visit(visitor);
@@ -813,15 +761,13 @@ AstStatTypeFunction::AstStatTypeFunction(
     const AstName& name,
     const Location& nameLocation,
     AstExprFunction* body,
-    bool exported,
-    bool hasErrors
+    bool exported
 )
     : AstStat(ClassIndex(), location)
     , name(name)
     , nameLocation(nameLocation)
     , body(body)
     , exported(exported)
-    , hasErrors(hasErrors)
 {
 }
 
@@ -849,8 +795,8 @@ AstStatDeclareFunction::AstStatDeclareFunction(
     const Location& location,
     const AstName& name,
     const Location& nameLocation,
-    const AstArray<AstGenericType*>& generics,
-    const AstArray<AstGenericTypePack*>& genericPacks,
+    const AstArray<AstGenericType>& generics,
+    const AstArray<AstGenericTypePack>& genericPacks,
     const AstTypeList& params,
     const AstArray<AstArgumentName>& paramNames,
     bool vararg,
@@ -876,8 +822,8 @@ AstStatDeclareFunction::AstStatDeclareFunction(
     const AstArray<AstAttr*>& attributes,
     const AstName& name,
     const Location& nameLocation,
-    const AstArray<AstGenericType*>& generics,
-    const AstArray<AstGenericTypePack*>& genericPacks,
+    const AstArray<AstGenericType>& generics,
+    const AstArray<AstGenericTypePack>& genericPacks,
     const AstTypeList& params,
     const AstArray<AstArgumentName>& paramNames,
     bool vararg,
@@ -918,13 +864,6 @@ bool AstStatDeclareFunction::isCheckedFunction() const
     return false;
 }
 
-bool AstStatDeclareFunction::hasAttribute(AstAttr::Type attributeType) const
-{
-    LUAU_ASSERT(FFlag::LuauDeprecatedAttribute);
-
-    return hasAttributeInArray(attributes, attributeType);
-}
-
 AstStatDeclareClass::AstStatDeclareClass(
     const Location& location,
     const AstName& name,
@@ -1031,8 +970,8 @@ void AstTypeTable::visit(AstVisitor* visitor)
 
 AstTypeFunction::AstTypeFunction(
     const Location& location,
-    const AstArray<AstGenericType*>& generics,
-    const AstArray<AstGenericTypePack*>& genericPacks,
+    const AstArray<AstGenericType>& generics,
+    const AstArray<AstGenericTypePack>& genericPacks,
     const AstTypeList& argTypes,
     const AstArray<std::optional<AstArgumentName>>& argNames,
     const AstTypeList& returnTypes
@@ -1051,8 +990,8 @@ AstTypeFunction::AstTypeFunction(
 AstTypeFunction::AstTypeFunction(
     const Location& location,
     const AstArray<AstAttr*>& attributes,
-    const AstArray<AstGenericType*>& generics,
-    const AstArray<AstGenericTypePack*>& genericPacks,
+    const AstArray<AstGenericType>& generics,
+    const AstArray<AstGenericTypePack>& genericPacks,
     const AstTypeList& argTypes,
     const AstArray<std::optional<AstArgumentName>>& argNames,
     const AstTypeList& returnTypes
@@ -1088,13 +1027,6 @@ bool AstTypeFunction::isCheckedFunction() const
     return false;
 }
 
-bool AstTypeFunction::hasAttribute(AstAttr::Type attributeType) const
-{
-    LUAU_ASSERT(FFlag::LuauDeprecatedAttribute);
-
-    return hasAttributeInArray(attributes, attributeType);
-}
-
 AstTypeTypeof::AstTypeTypeof(const Location& location, AstExpr* expr)
     : AstType(ClassIndex(), location)
     , expr(expr)
@@ -1107,16 +1039,6 @@ void AstTypeTypeof::visit(AstVisitor* visitor)
         expr->visit(visitor);
 }
 
-AstTypeOptional::AstTypeOptional(const Location& location)
-    : AstType(ClassIndex(), location)
-{
-}
-
-void AstTypeOptional::visit(AstVisitor* visitor)
-{
-    visitor->visit(this);
-}
-
 AstTypeUnion::AstTypeUnion(const Location& location, const AstArray<AstType*>& types)
     : AstType(ClassIndex(), location)
     , types(types)
@@ -1169,18 +1091,6 @@ void AstTypeSingletonString::visit(AstVisitor* visitor)
     visitor->visit(this);
 }
 
-AstTypeGroup::AstTypeGroup(const Location& location, AstType* type)
-    : AstType(ClassIndex(), location)
-    , type(type)
-{
-}
-
-void AstTypeGroup::visit(AstVisitor* visitor)
-{
-    if (visitor->visit(this))
-        type->visit(visitor);
-}
-
 AstTypeError::AstTypeError(const Location& location, const AstArray<AstType*>& types, bool isMissing, unsigned messageIndex)
     : AstType(ClassIndex(), location)
     , types(types)

Ast/src/Cst.cpp

@@ -1,268 +0,0 @@
-// This file is part of the Luau programming language and is licensed under MIT License; see LICENSE.txt for details
-#include "Luau/Ast.h"
-#include "Luau/Cst.h"
-#include "Luau/Common.h"
-
-namespace Luau
-{
-
-int gCstRttiIndex = 0;
-
-CstExprConstantNumber::CstExprConstantNumber(const AstArray<char>& value)
-    : CstNode(CstClassIndex())
-    , value(value)
-{
-}
-
-CstExprConstantString::CstExprConstantString(AstArray<char> sourceString, QuoteStyle quoteStyle, unsigned int blockDepth)
-    : CstNode(CstClassIndex())
-    , sourceString(sourceString)
-    , quoteStyle(quoteStyle)
-    , blockDepth(blockDepth)
-{
-    LUAU_ASSERT(blockDepth == 0 || quoteStyle == QuoteStyle::QuotedRaw);
-}
-
-CstExprCall::CstExprCall(std::optional<Position> openParens, std::optional<Position> closeParens, AstArray<Position> commaPositions)
-    : CstNode(CstClassIndex())
-    , openParens(openParens)
-    , closeParens(closeParens)
-    , commaPositions(commaPositions)
-{
-}
-
-CstExprIndexExpr::CstExprIndexExpr(Position openBracketPosition, Position closeBracketPosition)
-    : CstNode(CstClassIndex())
-    , openBracketPosition(openBracketPosition)
-    , closeBracketPosition(closeBracketPosition)
-{
-}
-
-CstExprFunction::CstExprFunction() : CstNode(CstClassIndex())
-{
-}
-
-CstExprTable::CstExprTable(const AstArray<Item>& items)
-    : CstNode(CstClassIndex())
-    , items(items)
-{
-}
-
-CstExprOp::CstExprOp(Position opPosition)
-    : CstNode(CstClassIndex())
-    , opPosition(opPosition)
-{
-}
-
-CstExprTypeAssertion::CstExprTypeAssertion(Position opPosition)
-    : CstNode(CstClassIndex())
-    , opPosition(opPosition)
-{
-}
-
-CstExprIfElse::CstExprIfElse(Position thenPosition, Position elsePosition, bool isElseIf)
-    : CstNode(CstClassIndex())
-    , thenPosition(thenPosition)
-    , elsePosition(elsePosition)
-    , isElseIf(isElseIf)
-{
-}
-
-CstExprInterpString::CstExprInterpString(AstArray<AstArray<char>> sourceStrings, AstArray<Position> stringPositions)
-    : CstNode(CstClassIndex())
-    , sourceStrings(sourceStrings)
-    , stringPositions(stringPositions)
-{
-}
-
-CstStatDo::CstStatDo(Position endPosition)
-    : CstNode(CstClassIndex())
-    , endPosition(endPosition)
-{
-}
-
-CstStatRepeat::CstStatRepeat(Position untilPosition)
-    : CstNode(CstClassIndex())
-    , untilPosition(untilPosition)
-{
-}
-
-CstStatReturn::CstStatReturn(AstArray<Position> commaPositions)
-    : CstNode(CstClassIndex())
-    , commaPositions(commaPositions)
-{
-}
-
-CstStatLocal::CstStatLocal(AstArray<Position> varsCommaPositions, AstArray<Position> valuesCommaPositions)
-    : CstNode(CstClassIndex())
-    , varsCommaPositions(varsCommaPositions)
-    , valuesCommaPositions(valuesCommaPositions)
-{
-}
-
-CstStatFor::CstStatFor(Position equalsPosition, Position endCommaPosition, std::optional<Position> stepCommaPosition)
-    : CstNode(CstClassIndex())
-    , equalsPosition(equalsPosition)
-    , endCommaPosition(endCommaPosition)
-    , stepCommaPosition(stepCommaPosition)
-{
-}
-
-CstStatForIn::CstStatForIn(AstArray<Position> varsCommaPositions, AstArray<Position> valuesCommaPositions)
-    : CstNode(CstClassIndex())
-    , varsCommaPositions(varsCommaPositions)
-    , valuesCommaPositions(valuesCommaPositions)
-{
-}
-
-CstStatAssign::CstStatAssign(AstArray<Position> varsCommaPositions, Position equalsPosition, AstArray<Position> valuesCommaPositions)
-    : CstNode(CstClassIndex())
-    , varsCommaPositions(varsCommaPositions)
-    , equalsPosition(equalsPosition)
-    , valuesCommaPositions(valuesCommaPositions)
-{
-}
-
-CstStatCompoundAssign::CstStatCompoundAssign(Position opPosition)
-    : CstNode(CstClassIndex())
-    , opPosition(opPosition)
-{
-}
-
-CstStatFunction::CstStatFunction(Position functionKeywordPosition)
-    : CstNode(CstClassIndex())
-    , functionKeywordPosition(functionKeywordPosition)
-{
-}
-
-CstStatLocalFunction::CstStatLocalFunction(Position localKeywordPosition, Position functionKeywordPosition)
-    : CstNode(CstClassIndex())
-    , localKeywordPosition(localKeywordPosition)
-    , functionKeywordPosition(functionKeywordPosition)
-{
-}
-
-CstGenericType::CstGenericType(std::optional<Position> defaultEqualsPosition)
-    : CstNode(CstClassIndex())
-    , defaultEqualsPosition(defaultEqualsPosition)
-{
-}
-
-CstGenericTypePack::CstGenericTypePack(Position ellipsisPosition, std::optional<Position> defaultEqualsPosition)
-    : CstNode(CstClassIndex())
-    , ellipsisPosition(ellipsisPosition)
-    , defaultEqualsPosition(defaultEqualsPosition)
-{
-}
-
-CstStatTypeAlias::CstStatTypeAlias(
-    Position typeKeywordPosition,
-    Position genericsOpenPosition,
-    AstArray<Position> genericsCommaPositions,
-    Position genericsClosePosition,
-    Position equalsPosition
-)
-    : CstNode(CstClassIndex())
-    , typeKeywordPosition(typeKeywordPosition)
-    , genericsOpenPosition(genericsOpenPosition)
-    , genericsCommaPositions(genericsCommaPositions)
-    , genericsClosePosition(genericsClosePosition)
-    , equalsPosition(equalsPosition)
-{
-}
-
-CstStatTypeFunction::CstStatTypeFunction(Position typeKeywordPosition, Position functionKeywordPosition)
-    : CstNode(CstClassIndex())
-    , typeKeywordPosition(typeKeywordPosition)
-    , functionKeywordPosition(functionKeywordPosition)
-{
-}
-
-CstTypeReference::CstTypeReference(
-    std::optional<Position> prefixPointPosition,
-    Position openParametersPosition,
-    AstArray<Position> parametersCommaPositions,
-    Position closeParametersPosition
-)
-    : CstNode(CstClassIndex())
-    , prefixPointPosition(prefixPointPosition)
-    , openParametersPosition(openParametersPosition)
-    , parametersCommaPositions(parametersCommaPositions)
-    , closeParametersPosition(closeParametersPosition)
-{
-}
-
-CstTypeTable::CstTypeTable(AstArray<Item> items, bool isArray)
-    : CstNode(CstClassIndex())
-    , items(items)
-    , isArray(isArray)
-{
-}
-
-CstTypeFunction::CstTypeFunction(
-    Position openGenericsPosition,
-    AstArray<Position> genericsCommaPositions,
-    Position closeGenericsPosition,
-    Position openArgsPosition,
-    AstArray<std::optional<Position>> argumentNameColonPositions,
-    AstArray<Position> argumentsCommaPositions,
-    Position closeArgsPosition,
-    Position returnArrowPosition
-)
-    : CstNode(CstClassIndex())
-    , openGenericsPosition(openGenericsPosition)
-    , genericsCommaPositions(genericsCommaPositions)
-    , closeGenericsPosition(closeGenericsPosition)
-    , openArgsPosition(openArgsPosition)
-    , argumentNameColonPositions(argumentNameColonPositions)
-    , argumentsCommaPositions(argumentsCommaPositions)
-    , closeArgsPosition(closeArgsPosition)
-    , returnArrowPosition(returnArrowPosition)
-{
-}
-
-CstTypeTypeof::CstTypeTypeof(Position openPosition, Position closePosition)
-    : CstNode(CstClassIndex())
-    , openPosition(openPosition)
-    , closePosition(closePosition)
-{
-}
-
-CstTypeUnion::CstTypeUnion(std::optional<Position> leadingPosition, AstArray<Position> separatorPositions)
-    : CstNode(CstClassIndex())
-    , leadingPosition(leadingPosition)
-    , separatorPositions(separatorPositions)
-{
-}
-
-CstTypeIntersection::CstTypeIntersection(std::optional<Position> leadingPosition, AstArray<Position> separatorPositions)
-    : CstNode(CstClassIndex())
-    , leadingPosition(leadingPosition)
-    , separatorPositions(separatorPositions)
-{
-}
-
-CstTypeSingletonString::CstTypeSingletonString(AstArray<char> sourceString, CstExprConstantString::QuoteStyle quoteStyle, unsigned int blockDepth)
-    : CstNode(CstClassIndex())
-    , sourceString(sourceString)
-    , quoteStyle(quoteStyle)
-    , blockDepth(blockDepth)
-{
-    LUAU_ASSERT(quoteStyle != CstExprConstantString::QuotedInterp);
-}
-
-CstTypePackExplicit::CstTypePackExplicit(Position openParenthesesPosition, Position closeParenthesesPosition, AstArray<Position> commaPositions)
-    : CstNode(CstClassIndex())
-    , openParenthesesPosition(openParenthesesPosition)
-    , closeParenthesesPosition(closeParenthesesPosition)
-    , commaPositions(commaPositions)
-{
-}
-
-CstTypePackGeneric::CstTypePackGeneric(Position ellipsisPosition)
-    : CstNode(CstClassIndex())
-    , ellipsisPosition(ellipsisPosition)
-{
-}
-
-} // namespace Luau

Ast/src/Lexer.cpp

@@ -8,6 +8,9 @@
 
 #include <limits.h>
 
+LUAU_FASTFLAGVARIABLE(LexerResumesFromPosition2)
+LUAU_FASTFLAGVARIABLE(LexerFixInterpStringStart)
+
 namespace Luau
 {
 
@@ -303,45 +306,16 @@ static char unescape(char ch)
     }
 }
 
-unsigned int Lexeme::getBlockDepth() const
-{
-    LUAU_ASSERT(type == Lexeme::RawString || type == Lexeme::BlockComment);
-
-    // If we have a well-formed string, we are guaranteed to see 2 `]` characters after the end of the string contents
-    LUAU_ASSERT(*(data + length) == ']');
-    unsigned int depth = 0;
-    do
-    {
-        depth++;
-    } while (*(data + length + depth) != ']');
-
-    return depth - 1;
-}
-
-Lexeme::QuoteStyle Lexeme::getQuoteStyle() const
-{
-    LUAU_ASSERT(type == Lexeme::QuotedString);
-
-    // If we have a well-formed string, we are guaranteed to see a closing delimiter after the string
-    LUAU_ASSERT(data);
-
-    char quote = *(data + length);
-    if (quote == '\'')
-        return Lexeme::QuoteStyle::Single;
-    else if (quote == '"')
-        return Lexeme::QuoteStyle::Double;
-
-    LUAU_ASSERT(!"Unknown quote style");
-    return Lexeme::QuoteStyle::Double; // unreachable, but required due to compiler warning
-}
-
 Lexer::Lexer(const char* buffer, size_t bufferSize, AstNameTable& names, Position startPosition)
     : buffer(buffer)
     , bufferSize(bufferSize)
     , offset(0)
-    , line(startPosition.line)
-    , lineOffset(0u - startPosition.column)
-    , lexeme((Location(Position(startPosition.line, startPosition.column), 0)), Lexeme::Eof)
+    , line(FFlag::LexerResumesFromPosition2 ? startPosition.line : 0)
+    , lineOffset(FFlag::LexerResumesFromPosition2 ? 0u - startPosition.column : 0)
+    , lexeme(
+          (FFlag::LexerResumesFromPosition2 ? Location(Position(startPosition.line, startPosition.column), 0) : Location(Position(0, 0), 0)),
+          Lexeme::Eof
+      )
     , names(names)
     , skipComments(false)
     , readNames(true)
@@ -787,7 +761,7 @@ Lexeme Lexer::readNext()
             return Lexeme(Location(start, 1), '}');
         }
 
-        return readInterpolatedStringSection(start, Lexeme::InterpStringMid, Lexeme::InterpStringEnd);
+        return readInterpolatedStringSection(FFlag::LexerFixInterpStringStart ? start : position(), Lexeme::InterpStringMid, Lexeme::InterpStringEnd);
     }
 
     case '=':

CLI/include/Luau/FileUtils.h

@@ -10,7 +10,7 @@
 std::optional<std::string> getCurrentWorkingDirectory();
 
 std::string normalizePath(std::string_view path);
-std::optional<std::string> resolvePath(std::string_view relativePath, std::string_view baseFilePath);
+std::string resolvePath(std::string_view relativePath, std::string_view baseFilePath);
 
 std::optional<std::string> readFile(const std::string& name);
 std::optional<std::string> readStdin();
@@ -23,7 +23,7 @@ bool isDirectory(const std::string& path);
 bool traverseDirectory(const std::string& path, const std::function<void(const std::string& name)>& callback);
 
 std::vector<std::string_view> splitPath(std::string_view path);
-std::string joinPaths(std::string_view lhs, std::string_view rhs);
-std::optional<std::string> getParentPath(std::string_view path);
+std::string joinPaths(const std::string& lhs, const std::string& rhs);
+std::optional<std::string> getParentPath(const std::string& path);
 
 std::vector<std::string> getSourceFiles(int argc, char** argv);

CLI/src/FileUtils.cpp

@@ -20,7 +20,6 @@
 #endif
 
 #include <string.h>
-#include <string_view>
 
 #ifdef _WIN32
 static std::wstring fromUtf8(const std::string& path)
@@ -91,76 +90,108 @@ std::optional<std::string> getCurrentWorkingDirectory()
     return std::nullopt;
 }
 
+// Returns the normal/canonical form of a path (e.g. "../subfolder/../module.luau" -> "../module.luau")
 std::string normalizePath(std::string_view path)
 {
-    const std::vector<std::string_view> components = splitPath(path);
-    std::vector<std::string_view> normalizedComponents;
-
-    const bool isAbsolute = isAbsolutePath(path);
-
-    // 1. Normalize path components
-    const size_t startIndex = isAbsolute ? 1 : 0;
-    for (size_t i = startIndex; i < components.size(); i++)
-    {
-        std::string_view component = components[i];
-        if (component == "..")
-        {
-            if (normalizedComponents.empty())
-            {
-                if (!isAbsolute)
-                {
-                    normalizedComponents.emplace_back("..");
-                }
-            }
-            else if (normalizedComponents.back() == "..")
-            {
-                normalizedComponents.emplace_back("..");
-            }
-            else
-            {
-                normalizedComponents.pop_back();
-            }
-        }
-        else if (!component.empty() && component != ".")
-        {
-            normalizedComponents.emplace_back(component);
-        }
-    }
-
-    std::string normalizedPath;
-
-    // 2. Add correct prefix to formatted path
-    if (isAbsolute)
-    {
-        normalizedPath += components[0];
-        normalizedPath += "/";
-    }
-    else if (normalizedComponents.empty() || normalizedComponents[0] != "..")
-    {
-        normalizedPath += "./";
-    }
-
-    // 3. Join path components to form the normalized path
-    for (auto iter = normalizedComponents.begin(); iter != normalizedComponents.end(); ++iter)
-    {
-        if (iter != normalizedComponents.begin())
-            normalizedPath += "/";
-
-        normalizedPath += *iter;
-    }
-    if (normalizedPath.size() >= 2 && normalizedPath[normalizedPath.size() - 1] == '.' && normalizedPath[normalizedPath.size() - 2] == '.')
-        normalizedPath += "/";
-
-    return normalizedPath;
+    return resolvePath(path, "");
 }
 
-std::optional<std::string> resolvePath(std::string_view path, std::string_view baseFilePath)
+// Takes a path that is relative to the file at baseFilePath and returns the path explicitly rebased onto baseFilePath.
+// For absolute paths, baseFilePath will be ignored, and this function will resolve the path to a canonical path:
+// (e.g. "/Users/.././Users/johndoe" -> "/Users/johndoe").
+std::string resolvePath(std::string_view path, std::string_view baseFilePath)
 {
-    std::optional<std::string> baseFilePathParent = getParentPath(baseFilePath);
-    if (!baseFilePathParent)
-        return std::nullopt;
+    std::vector<std::string_view> pathComponents;
+    std::vector<std::string_view> baseFilePathComponents;
 
-    return normalizePath(joinPaths(*baseFilePathParent, path));
+    // Dependent on whether the final resolved path is absolute or relative
+    // - if relative (when path and baseFilePath are both relative), resolvedPathPrefix remains empty
+    // - if absolute (if either path or baseFilePath are absolute), resolvedPathPrefix is "C:\", "/", etc.
+    std::string resolvedPathPrefix;
+    bool isResolvedPathRelative = false;
+
+    if (isAbsolutePath(path))
+    {
+        // path is absolute, we use path's prefix and ignore baseFilePath
+        size_t afterPrefix = path.find_first_of("\\/") + 1;
+        resolvedPathPrefix = path.substr(0, afterPrefix);
+        pathComponents = splitPath(path.substr(afterPrefix));
+    }
+    else
+    {
+        size_t afterPrefix = baseFilePath.find_first_of("\\/") + 1;
+        baseFilePathComponents = splitPath(baseFilePath.substr(afterPrefix));
+        if (isAbsolutePath(baseFilePath))
+        {
+            // path is relative and baseFilePath is absolute, we use baseFilePath's prefix
+            resolvedPathPrefix = baseFilePath.substr(0, afterPrefix);
+        }
+        else
+        {
+            // path and baseFilePath are both relative, we do not set a prefix (resolved path will be relative)
+            isResolvedPathRelative = true;
+        }
+        pathComponents = splitPath(path);
+    }
+
+    // Remove filename from components
+    if (!baseFilePathComponents.empty())
+        baseFilePathComponents.pop_back();
+
+    // Resolve the path by applying pathComponents to baseFilePathComponents
+    int numPrependedParents = 0;
+    for (std::string_view component : pathComponents)
+    {
+        if (component == "..")
+        {
+            if (baseFilePathComponents.empty())
+            {
+                if (isResolvedPathRelative)
+                    numPrependedParents++; // "../" will later be added to the beginning of the resolved path
+            }
+            else if (baseFilePathComponents.back() != "..")
+            {
+                baseFilePathComponents.pop_back(); // Resolve cases like "folder/subfolder/../../file" to "file"
+            }
+        }
+        else if (component != "." && !component.empty())
+        {
+            baseFilePathComponents.push_back(component);
+        }
+    }
+
+    // Create resolved path prefix for relative paths
+    if (isResolvedPathRelative)
+    {
+        if (numPrependedParents > 0)
+        {
+            resolvedPathPrefix.reserve(numPrependedParents * 3);
+            for (int i = 0; i < numPrependedParents; i++)
+            {
+                resolvedPathPrefix += "../";
+            }
+        }
+        else
+        {
+            resolvedPathPrefix = "./";
+        }
+    }
+
+    // Join baseFilePathComponents to form the resolved path
+    std::string resolvedPath = resolvedPathPrefix;
+    for (auto iter = baseFilePathComponents.begin(); iter != baseFilePathComponents.end(); ++iter)
+    {
+        if (iter != baseFilePathComponents.begin())
+            resolvedPath += "/";
+
+        resolvedPath += *iter;
+    }
+    if (resolvedPath.size() > resolvedPathPrefix.size() && resolvedPath.back() == '/')
+    {
+        // Remove trailing '/' if present
+        resolvedPath.pop_back();
+    }
+    return resolvedPath;
 }
 
 bool hasFileExtension(std::string_view name, const std::vector<std::string>& extensions)
@@ -385,16 +416,16 @@ std::vector<std::string_view> splitPath(std::string_view path)
     return components;
 }
 
-std::string joinPaths(std::string_view lhs, std::string_view rhs)
+std::string joinPaths(const std::string& lhs, const std::string& rhs)
 {
-    std::string result = std::string(lhs);
+    std::string result = lhs;
     if (!result.empty() && result.back() != '/' && result.back() != '\\')
         result += '/';
     result += rhs;
     return result;
 }
 
-std::optional<std::string> getParentPath(std::string_view path)
+std::optional<std::string> getParentPath(const std::string& path)
 {
     if (path == "" || path == "." || path == "/")
         return std::nullopt;
@@ -410,7 +441,7 @@ std::optional<std::string> getParentPath(std::string_view path)
         return "/";
 
     if (slash != std::string::npos)
-        return std::string(path.substr(0, slash));
+        return path.substr(0, slash);
 
     return "";
 }
@@ -440,12 +471,10 @@ std::vector<std::string> getSourceFiles(int argc, char** argv)
         if (argv[i][0] == '-' && argv[i][1] != '\0')
             continue;
 
-        std::string normalized = normalizePath(argv[i]);
-
-        if (isDirectory(normalized))
+        if (isDirectory(argv[i]))
         {
             traverseDirectory(
-                normalized,
+                argv[i],
                 [&](const std::string& name)
                 {
                     std::string ext = getExtension(name);
@@ -457,7 +486,7 @@ std::vector<std::string> getSourceFiles(int argc, char** argv)
         }
         else
         {
-            files.push_back(normalized);
+            files.push_back(argv[i]);
         }
     }
 

CLI/src/Flags.cpp

@@ -31,7 +31,7 @@ static void setLuauFlags(bool state)
 void setLuauFlagsDefault()
 {
     for (Luau::FValue<bool>* flag = Luau::FValue<bool>::list; flag; flag = flag->next)
-        if (strncmp(flag->name, "Luau", 4) == 0 && !Luau::isAnalysisFlagExperimental(flag->name))
+        if (strncmp(flag->name, "Luau", 4) == 0 && !Luau::isFlagExperimental(flag->name))
             flag->value = true;
 }
 

CLI/src/Repl.cpp

@@ -791,6 +791,8 @@ int replMain(int argc, char** argv)
 {
     Luau::assertHandler() = assertionHandler;
 
+    setLuauFlagsDefault();
+
 #ifdef _WIN32
     SetConsoleOutputCP(CP_UTF8);
 #endif

CLI/src/ReplEntry.cpp

@@ -1,10 +1,7 @@
 // This file is part of the Luau programming language and is licensed under MIT License; see LICENSE.txt for details
 #include "Luau/Repl.h"
-#include "Luau/Flags.h"
 
 int main(int argc, char** argv)
 {
-    setLuauFlagsDefault();
-
     return replMain(argc, argv);
 }