.clang-format

@@ -16,14 +16,10 @@ SortIncludes: false
 IndentWidth: 4
 TabWidth: 4
 ObjCBlockIndentWidth: 4
+AlignAfterOpenBracket: DontAlign
 UseTab: Never
 PointerAlignment: Left
 SpaceAfterTemplateKeyword: false
 AlignEscapedNewlines: DontAlign
 AlwaysBreakTemplateDeclarations: Yes
 MaxEmptyLinesToKeep: 10
-AllowAllParametersOfDeclarationOnNextLine: false
-AlignAfterOpenBracket: BlockIndent
-BinPackArguments: false
-BinPackParameters: false
-PenaltyReturnTypeOnItsOwnLine: 10000

.github/ISSUE_TEMPLATE/config.yml

@@ -1,5 +1,5 @@
 blank_issues_enabled: false
 contact_links:
   - name: Questions
-    url: https://github.com/luau-lang/luau/discussions
+    url: https://github.com/Roblox/luau/discussions
     about: Please use GitHub Discussions if you have questions or need help.

.github/codecov.yml

@@ -1,7 +0,0 @@
-comment: false
-coverage:
-  status:
-    patch: false
-    project:
-      default:
-        informational: true

.github/workflows/benchmark.yml

@@ -1,145 +0,0 @@
-name: benchmark
-
-on:
-  push:
-    branches:
-      - master
-    paths-ignore:
-      - "docs/**"
-      - "papers/**"
-      - "rfcs/**"
-      - "*.md"
-
-jobs:
-  callgrind:
-    strategy:
-      matrix:
-        os: [ubuntu-22.04]
-        benchResultsRepo:
-          - { name: "luau-lang/benchmark-data", branch: "main" }
-
-    runs-on: ${{ matrix.os }}
-    steps:
-      - name: Checkout Luau repository
-        uses: actions/checkout@v3
-
-      - name: Install valgrind
-        run: |
-          sudo apt-get update
-          sudo apt-get install valgrind
-
-      - name: Build Luau (gcc)
-        run: |
-          CXX=g++ make config=profile luau
-          cp luau luau-gcc
-
-      - name: Build Luau (codegen)
-        run: |
-          make config=profile clean
-          CXX=clang++ make config=profile native=1 luau
-          cp luau luau-codegen
-
-      - name: Build Luau (clang)
-        run: |
-          make config=profile clean
-          CXX=clang++ make config=profile luau luau-analyze luau-compile
-
-      - name: Run benchmark (bench-gcc)
-        run: |
-          python bench/bench.py --callgrind --vm "./luau-gcc -O2" | tee -a bench-gcc-output.txt
-
-      - name: Run benchmark (bench)
-        run: |
-          python bench/bench.py --callgrind --vm "./luau -O2" | tee -a bench-output.txt
-
-      - name: Run benchmark (bench-codegen)
-        run: |
-          python bench/bench.py --callgrind --vm "./luau-codegen --codegen -O2" | tee -a bench-codegen-output.txt
-
-      - name: Run benchmark (analyze)
-        run: |
-          filter() {
-            awk '/.*I\s+refs:\s+[0-9,]+/ {gsub(",", "", $4); X=$4} END {print "SUCCESS: '$1' : " X/1e7 "ms +/- 0% on luau-analyze"}'
-          }
-          valgrind --tool=callgrind ./luau-analyze --mode=nonstrict bench/other/LuauPolyfillMap.lua 2>&1 | filter map-nonstrict | tee -a analyze-output.txt
-          valgrind --tool=callgrind ./luau-analyze --mode=strict bench/other/LuauPolyfillMap.lua 2>&1 | filter map-strict | tee -a analyze-output.txt
-          valgrind --tool=callgrind ./luau-analyze --mode=strict --fflags=LuauSolverV2 bench/other/LuauPolyfillMap.lua 2>&1 | filter map-dcr | tee -a analyze-output.txt
-          valgrind --tool=callgrind ./luau-analyze --mode=nonstrict bench/other/regex.lua 2>&1 | filter regex-nonstrict | tee -a analyze-output.txt
-          valgrind --tool=callgrind ./luau-analyze --mode=strict bench/other/regex.lua 2>&1 | filter regex-strict | tee -a analyze-output.txt
-          valgrind --tool=callgrind ./luau-analyze --mode=strict --fflags=LuauSolverV2 bench/other/regex.lua 2>&1 | filter regex-dcr | tee -a analyze-output.txt
-
-      - name: Run benchmark (compile)
-        run: |
-          filter() {
-            awk '/.*I\s+refs:\s+[0-9,]+/ {gsub(",", "", $4); X=$4} END {print "SUCCESS: '$1' : " X/1e7 "ms +/- 0% on luau-compile"}'
-          }
-          valgrind --tool=callgrind ./luau-compile --null -O0 bench/other/LuauPolyfillMap.lua 2>&1 | filter map-O0 | tee -a compile-output.txt
-          valgrind --tool=callgrind ./luau-compile --null -O1 bench/other/LuauPolyfillMap.lua 2>&1 | filter map-O1 | tee -a compile-output.txt
-          valgrind --tool=callgrind ./luau-compile --null -O2 bench/other/LuauPolyfillMap.lua 2>&1 | filter map-O2 | tee -a compile-output.txt
-          valgrind --tool=callgrind ./luau-compile --codegennull -O2 bench/other/LuauPolyfillMap.lua 2>&1 | filter map-O2-codegen | tee -a compile-output.txt
-          valgrind --tool=callgrind ./luau-compile --codegennull -O2 -t1 bench/other/LuauPolyfillMap.lua 2>&1 | filter map-O2-t1-codegen | tee -a compile-output.txt
-          valgrind --tool=callgrind ./luau-compile --null -O0 bench/other/regex.lua 2>&1 | filter regex-O0 | tee -a compile-output.txt
-          valgrind --tool=callgrind ./luau-compile --null -O1 bench/other/regex.lua 2>&1 | filter regex-O1 | tee -a compile-output.txt
-          valgrind --tool=callgrind ./luau-compile --null -O2 bench/other/regex.lua 2>&1 | filter regex-O2 | tee -a compile-output.txt
-          valgrind --tool=callgrind ./luau-compile --codegennull -O2 bench/other/regex.lua 2>&1 | filter regex-O2-codegen | tee -a compile-output.txt
-          valgrind --tool=callgrind ./luau-compile --codegennull -O2 -t1 bench/other/regex.lua 2>&1 | filter regex-O2-t1-codegen | tee -a compile-output.txt
-
-      - name: Checkout benchmark results
-        uses: actions/checkout@v3
-        with:
-          repository: ${{ matrix.benchResultsRepo.name }}
-          ref: ${{ matrix.benchResultsRepo.branch }}
-          token: ${{ secrets.BENCH_GITHUB_TOKEN }}
-          path: "./gh-pages"
-
-      - name: Store results (bench)
-        uses: Roblox/rhysd-github-action-benchmark@v-luau
-        with:
-          name: callgrind clang
-          tool: "benchmarkluau"
-          output-file-path: ./bench-output.txt
-          external-data-json-path: ./gh-pages/bench.json
-
-      - name: Store results (bench-codegen)
-        uses: Roblox/rhysd-github-action-benchmark@v-luau
-        with:
-          name: callgrind codegen
-          tool: "benchmarkluau"
-          output-file-path: ./bench-codegen-output.txt
-          external-data-json-path: ./gh-pages/bench-codegen.json
-
-      - name: Store results (bench-gcc)
-        uses: Roblox/rhysd-github-action-benchmark@v-luau
-        with:
-          name: callgrind gcc
-          tool: "benchmarkluau"
-          output-file-path: ./bench-gcc-output.txt
-          external-data-json-path: ./gh-pages/bench-gcc.json
-
-      - name: Store results (analyze)
-        uses: Roblox/rhysd-github-action-benchmark@v-luau
-        with:
-          name: luau-analyze
-          tool: "benchmarkluau"
-          output-file-path: ./analyze-output.txt
-          external-data-json-path: ./gh-pages/analyze.json
-
-      - name: Store results (compile)
-        uses: Roblox/rhysd-github-action-benchmark@v-luau
-        with:
-          name: luau-compile
-          tool: "benchmarkluau"
-          output-file-path: ./compile-output.txt
-          external-data-json-path: ./gh-pages/compile.json
-
-      - name: Push benchmark results
-        if: github.event_name == 'push'
-        run: |
-          echo "Pushing benchmark results..."
-          cd gh-pages
-          git config user.name github-actions
-          git config user.email github@users.noreply.github.com
-          git add *.json
-          git commit -m "Add benchmarks results for ${{ github.sha }}"
-          git push
-          cd ..

.github/workflows/build.yml

@@ -20,35 +20,22 @@ jobs:
   unix:
     strategy:
       matrix:
-        os: [{name: ubuntu, version: ubuntu-latest}, {name: macos, version: macos-latest}, {name: macos-arm, version: macos-14}]
-    name: ${{matrix.os.name}}
-    runs-on: ${{matrix.os.version}}
+        os: [ubuntu, macos]
+    name: ${{matrix.os}}
+    runs-on: ${{matrix.os}}-latest
     steps:
     - uses: actions/checkout@v1
-    - name: work around ASLR+ASAN compatibility
-      run: sudo sysctl -w vm.mmap_rnd_bits=28
-      if: matrix.os.name == 'ubuntu'
-    - name: make tests
+    - name: make test
       run: |
-        make -j2 config=sanitize werror=1 native=1 luau-tests
-    - name: run tests
+        make -j2 config=sanitize werror=1 test
+    - name: make test w/flags
       run: |
-        ./luau-tests
-        ./luau-tests --fflags=true
-    - name: run extra conformance tests
-      run: |
-        ./luau-tests -ts=Conformance -O2
-        ./luau-tests -ts=Conformance -O2 --fflags=true
-        ./luau-tests -ts=Conformance --codegen
-        ./luau-tests -ts=Conformance --codegen --fflags=true
-        ./luau-tests -ts=Conformance --codegen -O2
-        ./luau-tests -ts=Conformance --codegen -O2 --fflags=true
+        make -j2 config=sanitize werror=1 flags=true test
     - 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
+         make -j2 config=sanitize werror=1 luau luau-analyze # match config with tests to improve build time
+         ./luau tests/conformance/assert.lua
+         ./luau-analyze tests/conformance/assert.lua
 
   windows:
     runs-on: windows-latest
@@ -58,35 +45,27 @@ jobs:
     steps:
     - uses: actions/checkout@v1
     - name: cmake configure
-      run: cmake . -A ${{matrix.arch}} -DLUAU_WERROR=ON -DLUAU_NATIVE=ON
-    - name: cmake build
-      run: cmake --build . --target Luau.UnitTest Luau.Conformance --config Debug
-    - name: run tests
+      run: cmake . -A ${{matrix.arch}} -DLUAU_WERROR=ON
+    - name: cmake test
       shell: bash # necessary for fail-fast
       run: |
+        cmake --build . --target Luau.UnitTest Luau.Conformance --config Debug
         Debug/Luau.UnitTest.exe
         Debug/Luau.Conformance.exe
-        Debug/Luau.UnitTest.exe --fflags=true
-        Debug/Luau.Conformance.exe --fflags=true
-    - name: run extra conformance tests
+    - name: cmake test w/flags
       shell: bash # necessary for fail-fast
       run: |
-        Debug/Luau.Conformance.exe -O2
-        Debug/Luau.Conformance.exe -O2 --fflags=true
-        Debug/Luau.Conformance.exe --codegen
-        Debug/Luau.Conformance.exe --codegen --fflags=true
-        Debug/Luau.Conformance.exe --codegen -O2
-        Debug/Luau.Conformance.exe --codegen -O2 --fflags=true
+        Debug/Luau.UnitTest.exe --fflags=true
+        Debug/Luau.Conformance.exe --fflags=true
     - name: cmake cli
       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
+        cmake --build . --target Luau.Repl.CLI Luau.Analyze.CLI --config Debug # match config with tests to improve build time
+        Debug/luau tests/conformance/assert.lua
+        Debug/luau-analyze tests/conformance/assert.lua
 
   coverage:
-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-latest
     steps:
     - uses: actions/checkout@v2
     - name: install
@@ -94,12 +73,21 @@ 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 coverage
+    - name: debug coverage
+      run: |
+        git status
+        git log -5
+        echo SHA: $GITHUB_SHA
     - name: upload coverage
-      uses: codecov/codecov-action@v3
+      uses: coverallsapp/github-action@master
       with:
-        files: ./coverage.info
-        token: ${{ secrets.CODECOV_TOKEN }}
+        path-to-lcov: ./coverage.info
+        github-token: ${{ secrets.GITHUB_TOKEN }}
+    - uses: actions/upload-artifact@v2
+      with:
+        name: coverage
+        path: coverage
 
   web:
     runs-on: ubuntu-latest

.github/workflows/new-release.yml

@@ -1,83 +0,0 @@
-name: new-release
-
-on:
-  workflow_dispatch:
-    inputs:
-      version:
-        required: true
-        description: Release version including 0.
-
-permissions:
-  contents: write
-
-jobs:
-  create-release:
-    runs-on: ubuntu-latest
-    outputs:
-      upload_url: ${{ steps.create_release.outputs.upload_url }}
-    steps:
-      - name: create release
-        id: create_release
-        uses: actions/create-release@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          tag_name: ${{ github.event.inputs.version }}
-          release_name: ${{ github.event.inputs.version }}
-          draft: true
-
-  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}]
-    name: ${{matrix.os.name}}
-    runs-on: ${{matrix.os.version}}
-    steps:
-    - uses: actions/checkout@v1
-    - name: configure
-      run: cmake . -DCMAKE_BUILD_TYPE=Release
-    - name: build
-      run: cmake --build . --target Luau.Repl.CLI Luau.Analyze.CLI Luau.Compile.CLI Luau.Ast.CLI --config Release -j 2
-    - name: pack
-      if: matrix.os.name != 'windows'
-      run: zip luau-${{matrix.os.name}}.zip luau*
-    - name: pack
-      if: matrix.os.name == 'windows'
-      run: 7z a luau-${{matrix.os.name}}.zip .\Release\luau*.exe
-    - uses: actions/upload-release-asset@v1
-      env:
-        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-      with:
-        upload_url: ${{ needs.create-release.outputs.upload_url }}
-        asset_path: luau-${{matrix.os.name}}.zip
-        asset_name: luau-${{matrix.os.name}}.zip
-        asset_content_type: application/octet-stream
-
-  web:
-    needs: ["create-release"]
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v1
-    - uses: actions/checkout@v2
-      with:
-        repository: emscripten-core/emsdk
-        path: emsdk
-    - name: emsdk install
-      run: |
-        cd emsdk
-        ./emsdk install latest
-        ./emsdk activate latest
-    - name: make
-      run: |
-        source emsdk/emsdk_env.sh
-        emcmake cmake . -DLUAU_BUILD_WEB=ON -DCMAKE_BUILD_TYPE=Release
-        make -j2 Luau.Web
-    - uses: actions/upload-release-asset@v1
-      env:
-        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-      with:
-        upload_url: ${{ needs.create-release.outputs.upload_url }}
-        asset_path: Luau.Web.js
-        asset_name: Luau.Web.js
-        asset_content_type: application/octet-stream

.github/workflows/release.yml

@@ -13,28 +13,27 @@ 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}]
-    name: ${{matrix.os.name}}
-    runs-on: ${{matrix.os.version}}
+      matrix:
+        os: [ubuntu, macos, windows]
+    name: ${{matrix.os}}
+    runs-on: ${{matrix.os}}-latest
     steps:
     - uses: actions/checkout@v1
     - name: configure
       run: cmake . -DCMAKE_BUILD_TYPE=Release
     - name: build
-      run: cmake --build . --target Luau.Repl.CLI Luau.Analyze.CLI Luau.Compile.CLI --config Release -j 2
-    - uses: actions/upload-artifact@v4
-      if: matrix.os.name != 'windows'
+      run: cmake --build . --target Luau.Repl.CLI Luau.Analyze.CLI --config Release
+    - uses: actions/upload-artifact@v2
+      if: matrix.os != 'windows'
       with:
-        name: luau-${{matrix.os.name}}
+        name: luau-${{matrix.os}}
         path: luau*
-        overwrite: true
-    - uses: actions/upload-artifact@v4
-      if: matrix.os.name == 'windows'
+    - uses: actions/upload-artifact@v2
+      if: matrix.os == 'windows'
       with:
-        name: luau-${{matrix.os.name}}
+        name: luau-${{matrix.os}}
         path: Release\luau*.exe
-        overwrite: true
+
   web:
     runs-on: ubuntu-latest
     steps:
@@ -53,8 +52,7 @@ jobs:
         source emsdk/emsdk_env.sh
         emcmake cmake . -DLUAU_BUILD_WEB=ON -DCMAKE_BUILD_TYPE=Release
         make -j2 Luau.Web
-    - uses: actions/upload-artifact@v4
+    - uses: actions/upload-artifact@v2
       with:
         name: Luau.Web.js
         path: Luau.Web.js
-        overwrite: true

.gitignore

@@ -1,20 +1,8 @@
-/build/
-/build[.-]*/
-/out
-/cmake/
-/cmake[.-]*/
-/coverage/
-/.vs/
-/.vscode/
-/fuzz/luau.pb.*
-/crash-*
-/default.prof*
-/fuzz-*
-/luau
-/luau-tests
-/luau-analyze
-/luau-bytecode
-/luau-compile
-__pycache__
-.cache
-.clangd
+^build/
+^coverage/
+^fuzz/luau.pb.*
+^crash-*
+^default.prof*
+^fuzz-*
+^luau$
+/.vs

Analysis/include/Luau/Anyification.h

@@ -1,54 +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/NotNull.h"
-#include "Luau/Substitution.h"
-#include "Luau/TypeFwd.h"
-
-#include <memory>
-
-namespace Luau
-{
-
-struct TypeArena;
-struct Scope;
-struct InternalErrorReporter;
-using ScopePtr = std::shared_ptr<Scope>;
-
-// A substitution which replaces free types by any
-struct Anyification : Substitution
-{
-    Anyification(
-        TypeArena* arena,
-        NotNull<Scope> scope,
-        NotNull<BuiltinTypes> builtinTypes,
-        InternalErrorReporter* iceHandler,
-        TypeId anyType,
-        TypePackId anyTypePack
-    );
-    Anyification(
-        TypeArena* arena,
-        const ScopePtr& scope,
-        NotNull<BuiltinTypes> builtinTypes,
-        InternalErrorReporter* iceHandler,
-        TypeId anyType,
-        TypePackId anyTypePack
-    );
-    NotNull<Scope> scope;
-    NotNull<BuiltinTypes> builtinTypes;
-    InternalErrorReporter* iceHandler;
-
-    TypeId anyType;
-    TypePackId anyTypePack;
-    bool normalizationTooComplex = false;
-    bool isDirty(TypeId ty) override;
-    bool isDirty(TypePackId tp) override;
-    TypeId clean(TypeId ty) override;
-    TypePackId clean(TypePackId tp) override;
-
-    bool ignoreChildren(TypeId ty) override;
-    bool ignoreChildren(TypePackId ty) override;
-};
-
-} // namespace Luau

Analysis/include/Luau/ApplyTypeFunction.h

@@ -1,32 +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/Substitution.h"
-#include "Luau/TxnLog.h"
-#include "Luau/TypeFwd.h"
-
-namespace Luau
-{
-
-// A substitution which replaces the type parameters of a type function by arguments
-struct ApplyTypeFunction : Substitution
-{
-    ApplyTypeFunction(TypeArena* arena)
-        : Substitution(TxnLog::empty(), arena)
-        , encounteredForwardedType(false)
-    {
-    }
-
-    // Never set under deferred constraint resolution.
-    bool encounteredForwardedType;
-    std::unordered_map<TypeId, TypeId> typeArguments;
-    std::unordered_map<TypePackId, TypePackId> typePackArguments;
-    bool ignoreChildren(TypeId ty) override;
-    bool ignoreChildren(TypePackId tp) override;
-    bool isDirty(TypeId ty) override;
-    bool isDirty(TypePackId tp) override;
-    TypeId clean(TypeId ty) override;
-    TypePackId clean(TypePackId tp) override;
-};
-
-} // namespace Luau

Analysis/include/Luau/AstQuery.h

@@ -3,7 +3,6 @@
 
 #include "Luau/Ast.h"
 #include "Luau/Documentation.h"
-#include "Luau/TypeFwd.h"
 
 #include <memory>
 
@@ -14,6 +13,9 @@ struct Binding;
 struct SourceModule;
 struct Module;
 
+struct TypeVar;
+using TypeId = const TypeVar*;
+
 using ScopePtr = std::shared_ptr<struct Scope>;
 
 struct ExprOrLocal
@@ -40,49 +42,14 @@ struct ExprOrLocal
     {
         return expr ? expr->location : (local ? local->location : std::optional<Location>{});
     }
-    std::optional<AstName> getName()
-    {
-        if (expr)
-        {
-            if (AstName name = getIdentifier(expr); name.value)
-            {
-                return name;
-            }
-        }
-        else if (local)
-        {
-            return local->name;
-        }
-        return std::nullopt;
-    }
 
 private:
     AstExpr* expr = nullptr;
     AstLocal* local = nullptr;
 };
 
-struct FindFullAncestry final : public AstVisitor
-{
-    std::vector<AstNode*> nodes;
-    Position pos;
-    Position documentEnd;
-    bool includeTypes = false;
-
-    explicit FindFullAncestry(Position pos, Position documentEnd, bool includeTypes = false);
-
-    bool visit(AstType* type) override;
-
-    bool visit(AstStatFunction* node) override;
-
-    bool visit(AstNode* node) override;
-};
-
-std::vector<AstNode*> findAncestryAtPositionForAutocomplete(const SourceModule& source, Position pos);
-std::vector<AstNode*> findAncestryAtPositionForAutocomplete(AstStatBlock* root, Position pos);
-std::vector<AstNode*> findAstAncestryOfPosition(const SourceModule& source, Position pos, bool includeTypes = false);
-std::vector<AstNode*> findAstAncestryOfPosition(AstStatBlock* root, Position pos, bool includeTypes = false);
+std::vector<AstNode*> findAstAncestryOfPosition(const SourceModule& source, Position pos);
 AstNode* findNodeAtPosition(const SourceModule& source, Position pos);
-AstNode* findNodeAtPosition(AstStatBlock* root, Position pos);
 AstExpr* findExprAtPosition(const SourceModule& source, Position pos);
 ScopePtr findScopeAtPosition(const Module& module, Position pos);
 std::optional<Binding> findBindingAtPosition(const Module& module, const SourceModule& source, Position pos);

Analysis/include/Luau/Autocomplete.h

@@ -1,10 +1,10 @@
 // This file is part of the Luau programming language and is licensed under MIT License; see LICENSE.txt for details
 #pragma once
 
-#include "Luau/AutocompleteTypes.h"
 #include "Luau/Location.h"
-#include "Luau/Type.h"
+#include "Luau/TypeVar.h"
 
+#include <unordered_map>
 #include <string>
 #include <memory>
 #include <optional>
@@ -16,8 +16,76 @@ struct Frontend;
 struct SourceModule;
 struct Module;
 struct TypeChecker;
-struct FileResolver;
+
+using ModulePtr = std::shared_ptr<Module>;
+
+enum class AutocompleteEntryKind
+{
+    Property,
+    Binding,
+    Keyword,
+    String,
+    Type,
+    Module,
+};
+
+enum class ParenthesesRecommendation
+{
+    None,
+    CursorAfter,
+    CursorInside,
+};
+
+enum class TypeCorrectKind
+{
+    None,
+    Correct,
+    CorrectFunctionResult,
+};
+
+struct AutocompleteEntry
+{
+    AutocompleteEntryKind kind = AutocompleteEntryKind::Property;
+    // Nullopt if kind is Keyword
+    std::optional<TypeId> type = std::nullopt;
+    bool deprecated = false;
+    // Only meaningful if kind is Property.
+    bool wrongIndexType = false;
+    // Set if this suggestion matches the type expected in the context
+    TypeCorrectKind typeCorrect = TypeCorrectKind::None;
+
+    std::optional<const ClassTypeVar*> containingClass = std::nullopt;
+    std::optional<const Property*> prop = std::nullopt;
+    std::optional<std::string> documentationSymbol = std::nullopt;
+    Tags tags;
+    ParenthesesRecommendation parens = ParenthesesRecommendation::None;
+};
+
+using AutocompleteEntryMap = std::unordered_map<std::string, AutocompleteEntry>;
+struct AutocompleteResult
+{
+    AutocompleteEntryMap entryMap;
+    std::vector<AstNode*> ancestry;
+
+    AutocompleteResult() = default;
+    AutocompleteResult(AutocompleteEntryMap entryMap, std::vector<AstNode*> ancestry)
+        : entryMap(std::move(entryMap))
+        , ancestry(std::move(ancestry))
+    {
+    }
+};
+
+using ModuleName = std::string;
+using StringCompletionCallback = std::function<std::optional<AutocompleteEntryMap>(std::string tag, std::optional<const ClassTypeVar*> ctx)>;
+
+struct OwningAutocompleteResult
+{
+    AutocompleteResult result;
+    ModulePtr module;
+    std::unique_ptr<SourceModule> sourceModule;
+};
 
 AutocompleteResult autocomplete(Frontend& frontend, const ModuleName& moduleName, Position position, StringCompletionCallback callback);
+OwningAutocompleteResult autocompleteSource(Frontend& frontend, std::string_view source, Position position, StringCompletionCallback callback);
 
 } // namespace Luau

Analysis/include/Luau/AutocompleteTypes.h

@@ -1,92 +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/Ast.h"
-#include "Luau/Type.h"
-
-#include <unordered_map>
-
-namespace Luau
-{
-
-enum class AutocompleteContext
-{
-    Unknown,
-    Expression,
-    Statement,
-    Property,
-    Type,
-    Keyword,
-    String,
-};
-
-enum class AutocompleteEntryKind
-{
-    Property,
-    Binding,
-    Keyword,
-    String,
-    Type,
-    Module,
-    GeneratedFunction,
-    RequirePath,
-};
-
-enum class ParenthesesRecommendation
-{
-    None,
-    CursorAfter,
-    CursorInside,
-};
-
-enum class TypeCorrectKind
-{
-    None,
-    Correct,
-    CorrectFunctionResult,
-};
-
-struct AutocompleteEntry
-{
-    AutocompleteEntryKind kind = AutocompleteEntryKind::Property;
-    // Nullopt if kind is Keyword
-    std::optional<TypeId> type = std::nullopt;
-    bool deprecated = false;
-    // Only meaningful if kind is Property.
-    bool wrongIndexType = false;
-    // Set if this suggestion matches the type expected in the context
-    TypeCorrectKind typeCorrect = TypeCorrectKind::None;
-
-    std::optional<const ExternType*> containingExternType = std::nullopt;
-    std::optional<const Property*> prop = std::nullopt;
-    std::optional<std::string> documentationSymbol = std::nullopt;
-    Tags tags;
-    ParenthesesRecommendation parens = ParenthesesRecommendation::None;
-    std::optional<std::string> insertText;
-
-    // Only meaningful if kind is Property.
-    bool indexedWithSelf = false;
-};
-
-using AutocompleteEntryMap = std::unordered_map<std::string, AutocompleteEntry>;
-struct AutocompleteResult
-{
-    AutocompleteEntryMap entryMap;
-    std::vector<AstNode*> ancestry;
-    AutocompleteContext context = AutocompleteContext::Unknown;
-
-    AutocompleteResult() = default;
-    AutocompleteResult(AutocompleteEntryMap entryMap, std::vector<AstNode*> ancestry, AutocompleteContext context)
-        : entryMap(std::move(entryMap))
-        , ancestry(std::move(ancestry))
-        , context(context)
-    {
-    }
-};
-
-using StringCompletionCallback =
-    std::function<std::optional<AutocompleteEntryMap>(std::string tag, std::optional<const ExternType*> ctx, std::optional<std::string> contents)>;
-
-constexpr char kGeneratedAnonymousFunctionEntryName[] = "function (anonymous autofilled)";
-
-} // namespace Luau

Analysis/include/Luau/BuiltinDefinitions.h

@@ -2,94 +2,50 @@
 #pragma once
 
 #include "Luau/Scope.h"
-#include "Luau/Type.h"
-
-#include <optional>
+#include "Luau/TypeInfer.h"
 
 namespace Luau
 {
 
-static constexpr char kRequireTagName[] = "require";
+void registerBuiltinTypes(TypeChecker& typeChecker);
 
-struct Frontend;
-struct GlobalTypes;
-struct TypeChecker;
-struct TypeArena;
-struct Subtyping;
-
-void registerBuiltinGlobals(Frontend& frontend, GlobalTypes& globals, bool typeCheckForAutocomplete = false);
 TypeId makeUnion(TypeArena& arena, std::vector<TypeId>&& types);
 TypeId makeIntersection(TypeArena& arena, std::vector<TypeId>&& types);
 
 /** Build an optional 't'
  */
-TypeId makeOption(NotNull<BuiltinTypes> builtinTypes, TypeArena& arena, TypeId t);
+TypeId makeOption(TypeChecker& typeChecker, TypeArena& arena, TypeId t);
 
 /** Small utility function for building up type definitions from C++.
  */
 TypeId makeFunction( // Monomorphic
-    TypeArena& arena,
-    std::optional<TypeId> selfType,
-    std::initializer_list<TypeId> paramTypes,
-    std::initializer_list<TypeId> retTypes,
-    bool checked = false
-);
+    TypeArena& arena, std::optional<TypeId> selfType, std::initializer_list<TypeId> paramTypes, std::initializer_list<TypeId> retTypes);
 
 TypeId makeFunction( // Polymorphic
-    TypeArena& arena,
-    std::optional<TypeId> selfType,
-    std::initializer_list<TypeId> generics,
-    std::initializer_list<TypePackId> genericPacks,
-    std::initializer_list<TypeId> paramTypes,
-    std::initializer_list<TypeId> retTypes,
-    bool checked = false
-);
+    TypeArena& arena, std::optional<TypeId> selfType, std::initializer_list<TypeId> generics, std::initializer_list<TypePackId> genericPacks,
+    std::initializer_list<TypeId> paramTypes, std::initializer_list<TypeId> retTypes);
 
 TypeId makeFunction( // Monomorphic
-    TypeArena& arena,
-    std::optional<TypeId> selfType,
-    std::initializer_list<TypeId> paramTypes,
-    std::initializer_list<std::string> paramNames,
-    std::initializer_list<TypeId> retTypes,
-    bool checked = false
-);
+    TypeArena& arena, std::optional<TypeId> selfType, std::initializer_list<TypeId> paramTypes, std::initializer_list<std::string> paramNames,
+    std::initializer_list<TypeId> retTypes);
 
 TypeId makeFunction( // Polymorphic
-    TypeArena& arena,
-    std::optional<TypeId> selfType,
-    std::initializer_list<TypeId> generics,
-    std::initializer_list<TypePackId> genericPacks,
-    std::initializer_list<TypeId> paramTypes,
-    std::initializer_list<std::string> paramNames,
-    std::initializer_list<TypeId> retTypes,
-    bool checked = false
-);
+    TypeArena& arena, std::optional<TypeId> selfType, std::initializer_list<TypeId> generics, std::initializer_list<TypePackId> genericPacks,
+    std::initializer_list<TypeId> paramTypes, std::initializer_list<std::string> paramNames, std::initializer_list<TypeId> retTypes);
+
+void attachMagicFunction(TypeId ty, MagicFunction fn);
 
-void attachMagicFunction(TypeId ty, std::shared_ptr<MagicFunction> fn);
 Property makeProperty(TypeId ty, std::optional<std::string> documentationSymbol = std::nullopt);
-void assignPropDocumentationSymbols(TableType::Props& props, const std::string& baseName);
+void assignPropDocumentationSymbols(TableTypeVar::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);
-void addGlobalBinding(GlobalTypes& globals, const ScopePtr& scope, const std::string& name, TypeId ty, const std::string& packageName);
-void addGlobalBinding(GlobalTypes& globals, const ScopePtr& scope, const std::string& name, Binding binding);
-std::optional<Binding> tryGetGlobalBinding(GlobalTypes& globals, const std::string& name);
-Binding* tryGetGlobalBindingRef(GlobalTypes& globals, const std::string& name);
-TypeId getGlobalBinding(GlobalTypes& globals, const std::string& name);
-
-
-/** A number of built-in functions are magical enough that we need to match on them specifically by
- * name when they are called. These are listed here to be used whenever necessary, instead of duplicating this logic repeatedly.
- */
-
-bool matchSetMetatable(const AstExprCall& call);
-bool matchTableFreeze(const AstExprCall& call);
-bool matchAssert(const AstExprCall& call);
-
-// Returns `true` if the function should introduce typestate for its first argument.
-bool shouldTypestateForFirstArgument(const AstExprCall& call);
+void addGlobalBinding(TypeChecker& typeChecker, const std::string& name, TypeId ty, const std::string& packageName);
+void addGlobalBinding(TypeChecker& typeChecker, const std::string& name, Binding binding);
+void addGlobalBinding(TypeChecker& typeChecker, const ScopePtr& scope, const std::string& name, TypeId ty, const std::string& packageName);
+void addGlobalBinding(TypeChecker& typeChecker, const ScopePtr& scope, const std::string& name, Binding binding);
+std::optional<Binding> tryGetGlobalBinding(TypeChecker& typeChecker, const std::string& name);
+Binding* tryGetGlobalBindingRef(TypeChecker& typeChecker, const std::string& name);
+TypeId getGlobalBinding(TypeChecker& typeChecker, const std::string& name);
 
 } // namespace Luau

Analysis/include/Luau/Cancellation.h

@@ -1,24 +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 <atomic>
-
-namespace Luau
-{
-
-struct FrontendCancellationToken
-{
-    void cancel()
-    {
-        cancelled.store(true);
-    }
-
-    bool requested()
-    {
-        return cancelled.load();
-    }
-
-    std::atomic<bool> cancelled;
-};
-
-} // namespace Luau

Analysis/include/Luau/Clone.h

@@ -1,48 +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/NotNull.h>
-#include "Luau/TypeArena.h"
-#include "Luau/Type.h"
-#include "Luau/Scope.h"
-
-#include <unordered_map>
-
-namespace Luau
-{
-
-// Only exposed so they can be unit tested.
-using SeenTypes = std::unordered_map<TypeId, TypeId>;
-using SeenTypePacks = std::unordered_map<TypePackId, TypePackId>;
-
-struct CloneState
-{
-    NotNull<BuiltinTypes> builtinTypes;
-
-    SeenTypes seenTypes;
-    SeenTypePacks seenTypePacks;
-};
-
-/** `shallowClone` will make a copy of only the _top level_ constructor of the type,
- * 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 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/Config.h

@@ -0,0 +1,58 @@
+// This file is part of the Luau programming language and is licensed under MIT License; see LICENSE.txt for details
+#pragma once
+
+#include "Luau/Linter.h"
+#include "Luau/ParseOptions.h"
+
+#include <string>
+#include <optional>
+#include <vector>
+
+namespace Luau
+{
+
+using ModuleName = std::string;
+
+constexpr const char* kConfigName = ".luaurc";
+
+struct Config
+{
+    Config()
+    {
+        enabledLint.setDefaults();
+    }
+
+    Mode mode = Mode::NoCheck;
+
+    ParseOptions parseOptions;
+
+    LintOptions enabledLint;
+    LintOptions fatalLint;
+
+    bool lintErrors = false;
+    bool typeErrors = true;
+
+    std::vector<std::string> globals;
+};
+
+struct ConfigResolver
+{
+    virtual ~ConfigResolver() {}
+
+    virtual const Config& getConfig(const ModuleName& name) const = 0;
+};
+
+struct NullConfigResolver : ConfigResolver
+{
+    Config defaultConfig;
+
+    virtual const Config& getConfig(const ModuleName& name) const override;
+};
+
+std::optional<std::string> parseModeString(Mode& mode, const std::string& modeString, bool compat = false);
+std::optional<std::string> parseLintRuleString(
+    LintOptions& enabledLints, LintOptions& fatalLints, const std::string& warningName, const std::string& value, bool compat = false);
+
+std::optional<std::string> parseConfig(const std::string& contents, Config& config, bool compat = false);
+
+} // namespace Luau

Analysis/include/Luau/Constraint.h

@@ -1,332 +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/Ast.h" // Used for some of the enumerations
-#include "Luau/DenseHash.h"
-#include "Luau/NotNull.h"
-#include "Luau/Variant.h"
-#include "Luau/TypeFwd.h"
-
-#include <string>
-#include <memory>
-#include <vector>
-
-namespace Luau
-{
-
-enum class ValueContext;
-struct Scope;
-
-// if resultType is a freeType, assignmentType <: freeType <: resultType bounds
-struct EqualityConstraint
-{
-    TypeId resultType;
-    TypeId assignmentType;
-};
-
-// subType <: superType
-struct SubtypeConstraint
-{
-    TypeId subType;
-    TypeId superType;
-};
-
-// subPack <: superPack
-struct PackSubtypeConstraint
-{
-    TypePackId subPack;
-    TypePackId superPack;
-
-    // HACK!! TODO clip.
-    // We need to know which of `PackSubtypeConstraint` are emitted from `AstStatReturn` vs any others.
-    // Then we force these specific `PackSubtypeConstraint` to only dispatch in the order of the `return`s.
-    bool returns = false;
-};
-
-// generalizedType ~ gen sourceType
-struct GeneralizationConstraint
-{
-    TypeId generalizedType;
-    TypeId sourceType;
-
-    std::vector<TypeId> interiorTypes;
-    bool hasDeprecatedAttribute = false;
-};
-
-// variables ~ iterate iterator
-// Unpack the iterator, figure out what types it iterates over, and bind those types to variables.
-struct IterableConstraint
-{
-    TypePackId iterator;
-    std::vector<TypeId> variables;
-
-    const AstNode* nextAstFragment;
-    DenseHashMap<const AstNode*, TypeId>* astForInNextTypes;
-};
-
-// name(namedType) = name
-struct NameConstraint
-{
-    TypeId namedType;
-    std::string name;
-    bool synthetic = false;
-    std::vector<TypeId> typeParameters;
-    std::vector<TypePackId> typePackParameters;
-};
-
-// target ~ inst target
-struct TypeAliasExpansionConstraint
-{
-    // Must be a PendingExpansionType.
-    TypeId target;
-};
-
-struct FunctionCallConstraint
-{
-    TypeId fn;
-    TypePackId argsPack;
-    TypePackId result;
-    class AstExprCall* callSite = nullptr;
-    std::vector<std::optional<TypeId>> discriminantTypes;
-
-    // When we dispatch this constraint, we update the key at this map to record
-    // the overload that we selected.
-    DenseHashMap<const AstNode*, TypeId>* astOverloadResolvedTypes = nullptr;
-};
-
-// function_check fn argsPack
-//
-// If fn is a function type and argsPack is a partially solved
-// pack of arguments to be supplied to the function, propagate the argument
-// types of fn into the types of argsPack. This is used to implement
-// bidirectional inference of lambda arguments.
-struct FunctionCheckConstraint
-{
-    TypeId fn;
-    TypePackId argsPack;
-
-    class AstExprCall* callSite = nullptr;
-    NotNull<DenseHashMap<const AstExpr*, TypeId>> astTypes;
-    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
-// initially. When this constraint is resolved, it will check that the bounds
-// of the free type are well-formed by subtyping.
-//
-// If they are not well-formed, then FreeType is replaced by its lower bound
-//
-// If they are well-formed and ExpectedType is potentially a singleton (an
-// actual singleton or a union that contains a singleton),
-// then FreeType is replaced by its lower bound
-//
-// else FreeType is replaced by PrimitiveType
-struct PrimitiveTypeConstraint
-{
-    TypeId freeType;
-
-    // potentially gets used to force the lower bound?
-    std::optional<TypeId> expectedType;
-
-    // the primitive type to check against
-    TypeId primitiveType;
-};
-
-// result ~ hasProp type "prop_name"
-//
-// If the subject is a table, bind the result to the named prop.  If the table
-// has an indexer, bind it to the index result type. If the subject is a union,
-// bind the result to the union of its constituents' properties.
-//
-// It would be nice to get rid of this constraint and someday replace it with
-//
-// T <: {p: X}
-//
-// Where {} describes an inexact shape type.
-struct HasPropConstraint
-{
-    TypeId resultType;
-    TypeId subjectType;
-    std::string prop;
-    ValueContext context;
-
-    // We want to track if this `HasPropConstraint` comes from a conditional.
-    // If it does, we're going to change the behavior of property look-up a bit.
-    // In particular, we're going to return `unknownType` for property lookups
-    // on `table` or inexact table types where the property is not present.
-    //
-    // This allows us to refine table types to have additional properties
-    // without reporting errors in typechecking on the property tests.
-    bool inConditional = false;
-
-    // HACK: We presently need types like true|false or string|"hello" when
-    // deciding whether a particular literal expression should have a singleton
-    // type.  This boolean is set to true when extracting the property type of a
-    // value that may be a union of tables.
-    //
-    // For example, in the following code fragment, we want the lookup of the
-    // success property to yield true|false when extracting an expectedType in
-    // this expression:
-    //
-    // type Result<T, E> = {success:true, result: T} | {success:false, error: E}
-    //
-    // local r: Result<number, string> = {success=true, result=9}
-    //
-    // If we naively simplify the expectedType to boolean, we will erroneously
-    // compute the type boolean for the success property of the table literal.
-    // This causes type checking to fail.
-    bool suppressSimplification = false;
-};
-
-// resultType ~ hasIndexer subjectType indexType
-//
-// If the subject type is a table or table-like thing that supports indexing,
-// populate the type result with the result type of such an index operation.
-//
-// If the subject is not indexable, resultType is bound to errorType.
-struct HasIndexerConstraint
-{
-    TypeId resultType;
-    TypeId subjectType;
-    TypeId indexType;
-};
-
-// assignProp lhsType propName rhsType
-//
-// Assign a value of type rhsType into the named property of lhsType.
-
-struct AssignPropConstraint
-{
-    TypeId lhsType;
-    std::string propName;
-    TypeId rhsType;
-
-    /// If a new property is to be inserted into a table type, it will be
-    /// ascribed this location.
-    std::optional<Location> propLocation;
-
-    /// The canonical write type of the property.  It is _solely_ used to
-    /// populate astTypes during constraint resolution.  Nothing should ever
-    /// block on it.
-    TypeId propType;
-
-    // When we generate constraints, we increment the remaining prop count on
-    // the table if we are able. This flag informs the solver as to whether or
-    // not it should in turn decrement the prop count when this constraint is
-    // dispatched.
-    bool decrementPropCount = false;
-};
-
-struct AssignIndexConstraint
-{
-    TypeId lhsType;
-    TypeId indexType;
-    TypeId rhsType;
-
-    /// The canonical write type of the property.  It is _solely_ used to
-    /// populate astTypes during constraint resolution.  Nothing should ever
-    /// block on it.
-    TypeId propType;
-};
-
-// resultTypes ~ unpack sourceTypePack
-//
-// Similar to PackSubtypeConstraint, but with one important difference: If the
-// sourcePack is blocked, this constraint blocks.
-struct UnpackConstraint
-{
-    std::vector<TypeId> resultPack;
-    TypePackId sourcePack;
-};
-
-// ty ~ reduce ty
-//
-// Try to reduce ty, if it is a TypeFunctionInstanceType. Otherwise, do nothing.
-struct ReduceConstraint
-{
-    TypeId ty;
-};
-
-// tp ~ reduce tp
-//
-// Analogous to ReduceConstraint, but for type packs.
-struct ReducePackConstraint
-{
-    TypePackId tp;
-};
-
-using ConstraintV = Variant<
-    SubtypeConstraint,
-    PackSubtypeConstraint,
-    GeneralizationConstraint,
-    IterableConstraint,
-    NameConstraint,
-    TypeAliasExpansionConstraint,
-    FunctionCallConstraint,
-    FunctionCheckConstraint,
-    PrimitiveTypeConstraint,
-    HasPropConstraint,
-    HasIndexerConstraint,
-    AssignPropConstraint,
-    AssignIndexConstraint,
-    UnpackConstraint,
-    ReduceConstraint,
-    ReducePackConstraint,
-    EqualityConstraint,
-    TableCheckConstraint>;
-
-struct Constraint
-{
-    Constraint(NotNull<Scope> scope, const Location& location, ConstraintV&& c);
-
-    Constraint(const Constraint&) = delete;
-    Constraint& operator=(const Constraint&) = delete;
-
-    NotNull<Scope> scope;
-    Location location;
-    ConstraintV c;
-
-    std::vector<NotNull<Constraint>> dependencies;
-
-    DenseHashSet<TypeId> getMaybeMutatedFreeTypes() const;
-};
-
-using ConstraintPtr = std::unique_ptr<Constraint>;
-
-bool isReferenceCountedType(const TypeId typ);
-
-inline Constraint& asMutable(const Constraint& c)
-{
-    return const_cast<Constraint&>(c);
-}
-
-template<typename T>
-T* getMutable(Constraint& c)
-{
-    return ::Luau::get_if<T>(&c.c);
-}
-
-template<typename T>
-const T* get(const Constraint& c)
-{
-    return getMutable<T>(asMutable(c));
-}
-
-} // namespace Luau

Analysis/include/Luau/ConstraintGenerator.h

@@ -1,487 +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/Ast.h"
-#include "Luau/Constraint.h"
-#include "Luau/ConstraintSet.h"
-#include "Luau/ControlFlow.h"
-#include "Luau/DataFlowGraph.h"
-#include "Luau/EqSatSimplification.h"
-#include "Luau/InsertionOrderedMap.h"
-#include "Luau/Module.h"
-#include "Luau/ModuleResolver.h"
-#include "Luau/Normalize.h"
-#include "Luau/NotNull.h"
-#include "Luau/Polarity.h"
-#include "Luau/Refinement.h"
-#include "Luau/Symbol.h"
-#include "Luau/TypeFwd.h"
-#include "Luau/TypeUtils.h"
-
-#include <memory>
-#include <vector>
-
-namespace Luau
-{
-
-struct Scope;
-using ScopePtr = std::shared_ptr<Scope>;
-
-struct DcrLogger;
-struct TypeFunctionRuntime;
-
-struct Inference
-{
-    TypeId ty = nullptr;
-    RefinementId refinement = nullptr;
-
-    Inference() = default;
-
-    explicit Inference(TypeId ty, RefinementId refinement = nullptr)
-        : ty(ty)
-        , refinement(refinement)
-    {
-    }
-};
-
-struct InferencePack
-{
-    TypePackId tp = nullptr;
-    std::vector<RefinementId> refinements;
-
-    InferencePack() = default;
-
-    explicit InferencePack(TypePackId tp, const std::vector<RefinementId>& refinements = {})
-        : tp(tp)
-        , refinements(refinements)
-    {
-    }
-};
-
-struct ConstraintGenerator
-{
-    // A list of all the scopes in the module. This vector holds ownership of the
-    // scope pointers; the scopes themselves borrow pointers to other scopes to
-    // define the scope hierarchy.
-    std::vector<std::pair<Location, ScopePtr>> scopes;
-
-    ModulePtr module;
-    NotNull<BuiltinTypes> builtinTypes;
-    const NotNull<TypeArena> arena;
-    // The root scope of the module we're generating constraints for.
-    // This is null when the CG is initially constructed.
-    Scope* rootScope;
-
-    TypeContext typeContext = TypeContext::Default;
-
-    struct InferredBinding
-    {
-        Scope* scope;
-        Location location;
-        TypeIds types;
-    };
-
-    // Some locals have multiple type states.  We wish for Scope::bindings to
-    // map each local name onto the union of every type that the local can have
-    // over its lifetime, so we use this map to accumulate the set of types it
-    // might have.
-    //
-    // See the functions recordInferredBinding and fillInInferredBindings.
-    DenseHashMap<Symbol, InferredBinding> inferredBindings{{}};
-
-    // Constraints that go straight to the solver.
-    std::vector<ConstraintPtr> constraints;
-
-    // The set of all free types introduced during constraint generation.
-    DenseHashSet<TypeId> freeTypes{nullptr};
-
-    // Map a function's signature scope back to its signature type.
-    DenseHashMap<Scope*, TypeId> scopeToFunction{nullptr};
-
-    // The private scope of type aliases for which the type parameters belong to.
-    DenseHashMap<const AstStatTypeAlias*, ScopePtr> astTypeAliasDefiningScopes{nullptr};
-
-    NotNull<const DataFlowGraph> dfg;
-    RefinementArena refinementArena;
-
-    int recursionCount = 0;
-
-    // It is pretty uncommon for constraint generation to itself produce errors, but it can happen.
-    std::vector<TypeError> errors;
-
-    // Needed to be able to enable error-suppression preservation for immediate refinements.
-    NotNull<Normalizer> normalizer;
-
-    NotNull<Simplifier> simplifier;
-
-    // Needed to register all available type functions for execution at later stages.
-    NotNull<TypeFunctionRuntime> typeFunctionRuntime;
-    DenseHashMap<const AstStatTypeFunction*, ScopePtr> astTypeFunctionEnvironmentScopes{nullptr};
-
-    // Needed to resolve modules to make 'require' import types properly.
-    NotNull<ModuleResolver> moduleResolver;
-    // Occasionally constraint generation needs to produce an ICE.
-    const NotNull<InternalErrorReporter> ice;
-
-    ScopePtr globalScope;
-    ScopePtr typeFunctionScope;
-
-    std::function<void(const ModuleName&, const ScopePtr&)> prepareModuleScope;
-    std::vector<RequireCycle> requireCycles;
-
-    DenseHashMap<TypeId, TypeIds> localTypes{nullptr};
-
-    DenseHashMap<AstExpr*, Inference> inferredExprCache{nullptr};
-
-    DcrLogger* logger;
-
-    ConstraintGenerator(
-        ModulePtr module,
-        NotNull<Normalizer> normalizer,
-        NotNull<Simplifier> simplifier,
-        NotNull<TypeFunctionRuntime> typeFunctionRuntime,
-        NotNull<ModuleResolver> moduleResolver,
-        NotNull<BuiltinTypes> builtinTypes,
-        NotNull<InternalErrorReporter> ice,
-        const ScopePtr& globalScope,
-        const ScopePtr& typeFunctionScope,
-        std::function<void(const ModuleName&, const ScopePtr&)> prepareModuleScope,
-        DcrLogger* logger,
-        NotNull<DataFlowGraph> dfg,
-        std::vector<RequireCycle> requireCycles
-    );
-
-    ConstraintSet run(AstStatBlock* block);
-    ConstraintSet runOnFragment(const ScopePtr& resumeScope, AstStatBlock* block);
-
-    /**
-     * The entry point to the ConstraintGenerator. This will construct a set
-     * of scopes, constraints, and free types that can be solved later.
-     * @param block the root block to generate constraints for.
-     */
-    void visitModuleRoot(AstStatBlock* block);
-
-    void visitFragmentRoot(const ScopePtr& resumeScope, AstStatBlock* block);
-
-private:
-    struct InteriorFreeTypes
-    {
-        std::vector<TypeId> types;
-        std::vector<TypePackId> typePacks;
-    };
-
-    std::vector<std::vector<TypeId>> DEPRECATED_interiorTypes;
-    std::vector<InteriorFreeTypes> interiorFreeTypes;
-
-    /**
-     * Fabricates a new free type belonging to a given scope.
-     * @param scope the scope the free type belongs to.
-     */
-    TypeId freshType(const ScopePtr& scope, Polarity polarity = Polarity::Unknown);
-
-    /**
-     * Fabricates a new free type pack belonging to a given scope.
-     * @param scope the scope the free type pack belongs to.
-     */
-    TypePackId freshTypePack(const ScopePtr& scope, Polarity polarity = Polarity::Unknown);
-
-    /**
-     * Allocate a new TypePack with the given head and tail.
-     *
-     * Avoids allocating 0-length type packs:
-     *
-     * If the head is non-empty, allocate and return a type pack with the given
-     * head and tail.
-     * If the head is empty and tail is non-empty, return *tail.
-     * If both the head and tail are empty, return an empty type pack.
-     */
-    TypePackId addTypePack(std::vector<TypeId> head, std::optional<TypePackId> tail);
-
-    /**
-     * 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.
-     */
-    ScopePtr childScope(AstNode* node, const ScopePtr& parent);
-
-    std::optional<TypeId> lookup(const ScopePtr& scope, Location location, DefId def, bool prototype = true);
-
-    /**
-     * Adds a new constraint with no dependencies to a given scope.
-     * @param scope the scope to add the constraint to.
-     * @param cv the constraint variant to add.
-     * @return the pointer to the inserted constraint
-     */
-    NotNull<Constraint> addConstraint(const ScopePtr& scope, const Location& location, ConstraintV cv);
-
-    /**
-     * Adds a constraint to a given scope.
-     * @param scope the scope to add the constraint to. Must not be null.
-     * @param c the constraint to add.
-     * @return the pointer to the inserted constraint
-     */
-    NotNull<Constraint> addConstraint(const ScopePtr& scope, std::unique_ptr<Constraint> c);
-
-    struct RefinementPartition
-    {
-        // Types that we want to intersect against the type of the expression.
-        std::vector<TypeId> discriminantTypes;
-
-        // Sometimes the type we're discriminating against is implicitly nil.
-        bool shouldAppendNilType = false;
-    };
-
-    using RefinementContext = InsertionOrderedMap<DefId, RefinementPartition>;
-    void unionRefinements(
-        const ScopePtr& scope,
-        Location location,
-        const RefinementContext& lhs,
-        const RefinementContext& rhs,
-        RefinementContext& dest,
-        std::vector<ConstraintV>* constraints
-    );
-    void computeRefinement(
-        const ScopePtr& scope,
-        Location location,
-        RefinementId refinement,
-        RefinementContext* refis,
-        bool sense,
-        bool eq,
-        std::vector<ConstraintV>* constraints
-    );
-    void applyRefinements(const ScopePtr& scope, Location location, RefinementId refinement);
-
-    LUAU_NOINLINE void checkAliases(const ScopePtr& scope, AstStatBlock* block);
-
-    ControlFlow visitBlockWithoutChildScope(const ScopePtr& scope, AstStatBlock* block);
-    ControlFlow visitBlockWithoutChildScope_DEPRECATED(const ScopePtr& scope, AstStatBlock* block);
-
-    ControlFlow visit(const ScopePtr& scope, AstStat* stat);
-    ControlFlow visit(const ScopePtr& scope, AstStatBlock* block);
-    ControlFlow visit(const ScopePtr& scope, AstStatLocal* local);
-    ControlFlow visit(const ScopePtr& scope, AstStatFor* for_);
-    ControlFlow visit(const ScopePtr& scope, AstStatForIn* forIn);
-    ControlFlow visit(const ScopePtr& scope, AstStatWhile* while_);
-    ControlFlow visit(const ScopePtr& scope, AstStatRepeat* repeat);
-    ControlFlow visit(const ScopePtr& scope, AstStatLocalFunction* function);
-    ControlFlow visit(const ScopePtr& scope, AstStatFunction* function);
-    ControlFlow visit(const ScopePtr& scope, AstStatReturn* ret);
-    ControlFlow visit(const ScopePtr& scope, AstStatAssign* assign);
-    ControlFlow visit(const ScopePtr& scope, AstStatCompoundAssign* assign);
-    ControlFlow visit(const ScopePtr& scope, AstStatIf* ifStatement);
-    ControlFlow visit(const ScopePtr& scope, AstStatTypeAlias* alias);
-    ControlFlow visit(const ScopePtr& scope, AstStatTypeFunction* function);
-    ControlFlow visit(const ScopePtr& scope, AstStatDeclareGlobal* declareGlobal);
-    ControlFlow visit(const ScopePtr& scope, AstStatDeclareExternType* declareExternType);
-    ControlFlow visit(const ScopePtr& scope, AstStatDeclareFunction* declareFunction);
-    ControlFlow visit(const ScopePtr& scope, AstStatError* error);
-
-    InferencePack checkPack(const ScopePtr& scope, AstArray<AstExpr*> exprs, const std::vector<std::optional<TypeId>>& expectedTypes = {});
-    InferencePack checkPack(
-        const ScopePtr& scope,
-        AstExpr* expr,
-        const std::vector<std::optional<TypeId>>& expectedTypes = {},
-        bool generalize = true
-    );
-
-    InferencePack checkPack(const ScopePtr& scope, AstExprCall* call);
-
-    /**
-     * Checks an expression that is expected to evaluate to one type.
-     * @param scope the scope the expression is contained within.
-     * @param expr the expression to check.
-     * @param expectedType the type of the expression that is expected from its
-     *      surrounding context.  Used to implement bidirectional type checking.
-     * @param generalize If true, generalize any lambdas that are encountered.
-     * @return the type of the expression.
-     */
-    Inference check(
-        const ScopePtr& scope,
-        AstExpr* expr,
-        std::optional<TypeId> expectedType = {},
-        bool forceSingleton = false,
-        bool generalize = true
-    );
-
-    Inference check(const ScopePtr& scope, AstExprConstantString* string, std::optional<TypeId> expectedType, bool forceSingleton);
-    Inference check(const ScopePtr& scope, AstExprConstantBool* boolExpr, std::optional<TypeId> expectedType, bool forceSingleton);
-    Inference check(const ScopePtr& scope, AstExprLocal* local);
-    Inference check(const ScopePtr& scope, AstExprGlobal* global);
-    Inference checkIndexName(const ScopePtr& scope, const RefinementKey* key, AstExpr* indexee, const std::string& index, Location indexLocation);
-    Inference check(const ScopePtr& scope, AstExprIndexName* indexName);
-    Inference check(const ScopePtr& scope, AstExprIndexExpr* indexExpr);
-    Inference check(const ScopePtr& scope, AstExprFunction* func, std::optional<TypeId> expectedType, bool generalize);
-    Inference check(const ScopePtr& scope, AstExprUnary* unary);
-    Inference check(const ScopePtr& scope, AstExprBinary* binary, std::optional<TypeId> expectedType);
-    Inference checkAstExprBinary(
-        const ScopePtr& scope,
-        const Location& location,
-        AstExprBinary::Op op,
-        AstExpr* left,
-        AstExpr* right,
-        std::optional<TypeId> expectedType
-    );
-    Inference check(const ScopePtr& scope, AstExprIfElse* ifElse, std::optional<TypeId> expectedType);
-    Inference check(const ScopePtr& scope, AstExprTypeAssertion* typeAssert);
-    Inference check(const ScopePtr& scope, AstExprInterpString* interpString);
-    Inference check(const ScopePtr& scope, AstExprTable* expr, std::optional<TypeId> expectedType);
-    std::tuple<TypeId, TypeId, RefinementId> checkBinary(
-        const ScopePtr& scope,
-        AstExprBinary::Op op,
-        AstExpr* left,
-        AstExpr* right,
-        std::optional<TypeId> expectedType
-    );
-
-    void visitLValue(const ScopePtr& scope, AstExpr* expr, TypeId rhsType);
-    void visitLValue(const ScopePtr& scope, AstExprLocal* local, TypeId rhsType);
-    void visitLValue(const ScopePtr& scope, AstExprGlobal* global, TypeId rhsType);
-    void visitLValue(const ScopePtr& scope, AstExprIndexName* indexName, TypeId rhsType);
-    void visitLValue(const ScopePtr& scope, AstExprIndexExpr* indexExpr, TypeId rhsType);
-
-    struct FunctionSignature
-    {
-        // The type of the function.
-        TypeId signature;
-        // The scope that encompasses the function's signature. May be nullptr
-        // if there was no need for a signature scope (the function has no
-        // generics).
-        ScopePtr signatureScope;
-        // The scope that encompasses the function's body. Is a child scope of
-        // signatureScope, if present.
-        ScopePtr bodyScope;
-    };
-
-    FunctionSignature checkFunctionSignature(
-        const ScopePtr& parent,
-        AstExprFunction* fn,
-        std::optional<TypeId> expectedType = {},
-        std::optional<Location> originalName = {}
-    );
-
-    /**
-     * Checks the body of a function expression.
-     * @param scope the interior scope of the body of the function.
-     * @param fn the function expression to check.
-     */
-    void checkFunctionBody(const ScopePtr& scope, AstExprFunction* fn);
-
-    // Specializations of 'resolveType' below
-    TypeId resolveReferenceType(const ScopePtr& scope, AstType* ty, AstTypeReference* ref, bool inTypeArguments, bool replaceErrorWithFresh);
-    TypeId resolveTableType(const ScopePtr& scope, AstType* ty, AstTypeTable* tab, bool inTypeArguments, bool replaceErrorWithFresh);
-    TypeId resolveFunctionType(const ScopePtr& scope, AstType* ty, AstTypeFunction* fn, bool inTypeArguments, bool replaceErrorWithFresh);
-
-    /**
-     * Resolves a type from its AST annotation.
-     * @param scope the scope that the type annotation appears within.
-     * @param ty the AST annotation to resolve.
-     * @param inTypeArguments whether we are resolving a type that's contained within type arguments, `<...>`.
-     * @return the type of the AST annotation.
-     **/
-    TypeId resolveType(const ScopePtr& scope, AstType* ty, bool inTypeArguments, bool replaceErrorWithFresh = false);
-
-    // resolveType() is recursive, but we only want to invoke
-    // inferGenericPolarities() once at the very end.  We thus isolate the
-    // recursive part of the algorithm to this internal helper.
-    TypeId resolveType_(const ScopePtr& scope, AstType* ty, bool inTypeArguments, bool replaceErrorWithFresh = false);
-
-    /**
-     * Resolves a type pack from its AST annotation.
-     * @param scope the scope that the type annotation appears within.
-     * @param tp the AST annotation to resolve.
-     * @param inTypeArguments whether we are resolving a type that's contained within type arguments, `<...>`.
-     * @return the type pack of the AST annotation.
-     **/
-    TypePackId resolveTypePack(const ScopePtr& scope, AstTypePack* tp, bool inTypeArguments, bool replaceErrorWithFresh = false);
-
-    // Inner hepler for resolveTypePack
-    TypePackId resolveTypePack_(const ScopePtr& scope, AstTypePack* tp, bool inTypeArguments, bool replaceErrorWithFresh = false);
-
-    /**
-     * Resolves a type pack from its AST annotation.
-     * @param scope the scope that the type annotation appears within.
-     * @param list the AST annotation to resolve.
-     * @param inTypeArguments whether we are resolving a type that's contained within type arguments, `<...>`.
-     * @return the type pack of the AST annotation.
-     **/
-    TypePackId resolveTypePack(const ScopePtr& scope, const AstTypeList& list, bool inTypeArguments, bool replaceErrorWithFresh = false);
-
-    /**
-     * Creates generic types given a list of AST definitions, resolving default
-     * types as required.
-     * @param scope the scope that the generics should belong to.
-     * @param generics the AST generics to create types for.
-     * @param useCache whether to use the generic type cache for the given
-     * scope.
-     * @param addTypes whether to add the types to the scope's
-     * privateTypeBindings map.
-     **/
-    std::vector<std::pair<Name, GenericTypeDefinition>> createGenerics(
-        const ScopePtr& scope,
-        AstArray<AstGenericType*> generics,
-        bool useCache = false,
-        bool addTypes = true
-    );
-
-    /**
-     * Creates generic type packs given a list of AST definitions, resolving
-     * default type packs as required.
-     * @param scope the scope that the generic packs should belong to.
-     * @param generics the AST generics to create type packs for.
-     * @param useCache whether to use the generic type pack cache for the given
-     * scope.
-     * @param addTypes whether to add the types to the scope's
-     * privateTypePackBindings map.
-     **/
-    std::vector<std::pair<Name, GenericTypePackDefinition>> createGenericPacks(
-        const ScopePtr& scope,
-        AstArray<AstGenericTypePack*> generics,
-        bool useCache = false,
-        bool addTypes = true
-    );
-
-    Inference flattenPack(const ScopePtr& scope, Location location, InferencePack pack);
-
-    void reportError(Location location, TypeErrorData err);
-    void reportCodeTooComplex(Location location);
-
-    // make a union type function of these two types
-    TypeId makeUnion(const ScopePtr& scope, Location location, TypeId lhs, TypeId rhs);
-    // make an intersect type function of these two types
-    TypeId makeIntersect(const ScopePtr& scope, Location location, TypeId lhs, TypeId rhs);
-    void prepopulateGlobalScopeForFragmentTypecheck(const ScopePtr& globalScope, const ScopePtr& resumeScope, AstStatBlock* program);
-
-    /** Scan the program for global definitions.
-     *
-     * ConstraintGenerator needs to differentiate between globals and accesses to undefined symbols. Doing this "for
-     * real" in a general way is going to be pretty hard, so we are choosing not to tackle that yet. For now, we do an
-     * initial scan of the AST and note what globals are defined.
-     */
-    void prepopulateGlobalScope(const ScopePtr& globalScope, AstStatBlock* program);
-
-    bool recordPropertyAssignment(TypeId ty);
-
-    // Record the fact that a particular local has a particular type in at least
-    // one of its states.
-    void recordInferredBinding(AstLocal* local, TypeId ty);
-
-    void fillInInferredBindings(const ScopePtr& globalScope, AstStatBlock* block);
-
-    /** Given a function type annotation, return a vector describing the expected types of the calls to the function
-     *  For example, calling a function with annotation ((number) -> string & ((string) -> number))
-     *  yields a vector of size 1, with value: [number | string]
-     */
-    std::vector<std::optional<TypeId>> getExpectedCallTypesForFunctionOverloads(const TypeId fnType);
-
-    TypeId createTypeFunctionInstance(
-        const TypeFunction& function,
-        std::vector<TypeId> typeArguments,
-        std::vector<TypePackId> packArguments,
-        const ScopePtr& scope,
-        Location location
-    );
-
-    TypeId simplifyUnion(const ScopePtr& scope, Location location, TypeId left, TypeId right);
-};
-
-} // namespace Luau

Analysis/include/Luau/ConstraintSet.h

@@ -1,32 +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/Constraint.h"
-#include "Luau/DenseHash.h"
-#include "Luau/Error.h"
-
-#include <vector>
-
-namespace Luau
-{
-
-struct ConstraintSet
-{
-    NotNull<Scope> rootScope;
-
-    std::vector<ConstraintPtr> constraints;
-
-    // The set of all free types created during constraint generation
-    DenseHashSet<TypeId> freeTypes{nullptr};
-
-    // Map a function's signature scope back to its signature type.   Once we've
-    // dispatched all of the constraints pertaining to a particular free type,
-    // we use this mapping to generalize that free type.
-    DenseHashMap<Scope*, TypeId> scopeToFunction{nullptr};
-
-    // It is pretty uncommon for constraint generation to itself produce errors, but it can happen.
-    std::vector<TypeError> errors;
-};
-
-}

Analysis/include/Luau/ConstraintSolver.h

@@ -1,459 +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/Constraint.h"
-#include "Luau/ConstraintSet.h"
-#include "Luau/DataFlowGraph.h"
-#include "Luau/DenseHash.h"
-#include "Luau/EqSatSimplification.h"
-#include "Luau/Error.h"
-#include "Luau/Location.h"
-#include "Luau/Module.h"
-#include "Luau/Normalize.h"
-#include "Luau/Substitution.h"
-#include "Luau/ToString.h"
-#include "Luau/Type.h"
-#include "Luau/TypeCheckLimits.h"
-#include "Luau/TypeFunction.h"
-#include "Luau/TypeFwd.h"
-#include "Luau/Variant.h"
-
-#include <utility>
-#include <vector>
-
-namespace Luau
-{
-
-enum class ValueContext;
-
-struct DcrLogger;
-
-class AstExpr;
-
-// TypeId, TypePackId, or Constraint*. It is impossible to know which, but we
-// never dereference this pointer.
-using BlockedConstraintId = Variant<TypeId, TypePackId, const Constraint*>;
-
-struct HashBlockedConstraintId
-{
-    size_t operator()(const BlockedConstraintId& bci) const;
-};
-
-struct ModuleResolver;
-
-struct InstantiationSignature
-{
-    TypeFun fn;
-    std::vector<TypeId> arguments;
-    std::vector<TypePackId> packArguments;
-
-    bool operator==(const InstantiationSignature& rhs) const;
-    bool operator!=(const InstantiationSignature& rhs) const
-    {
-        return !((*this) == rhs);
-    }
-};
-
-struct HashInstantiationSignature
-{
-    size_t operator()(const InstantiationSignature& signature) const;
-};
-
-
-struct TablePropLookupResult
-{
-    // What types are we blocked on for determining this type?
-    std::vector<TypeId> blockedTypes;
-    // The type of the property (if we were able to determine it).
-    std::optional<TypeId> propType;
-    // Whether or not this is _definitely_ derived as the result of an indexer.
-    // We use this to determine whether or not code like:
-    //
-    //   t.lol = nil;
-    //
-    // ... is legal. If `t: { [string]: ~nil }` then this is legal as
-    // there's no guarantee on whether "lol" specifically exists.
-    // However, if `t: { lol: ~nil }`, then we cannot allow assignment as
-    // that would remove "lol" from the table entirely.
-    bool isIndex = false;
-};
-
-struct ConstraintSolver
-{
-    NotNull<TypeArena> arena;
-    NotNull<BuiltinTypes> builtinTypes;
-    InternalErrorReporter iceReporter;
-    NotNull<Normalizer> normalizer;
-    NotNull<Simplifier> simplifier;
-    NotNull<TypeFunctionRuntime> typeFunctionRuntime;
-    // The entire set of constraints that the solver is trying to resolve.
-    ConstraintSet constraintSet;
-    std::vector<NotNull<Constraint>> constraints;
-    NotNull<DenseHashMap<Scope*, TypeId>> scopeToFunction;
-    NotNull<Scope> rootScope;
-    ModuleName currentModuleName;
-
-    // The dataflow graph of the program, used in constraint generation and for magic functions.
-    NotNull<const DataFlowGraph> dfg;
-
-    // Constraints that the solver has generated, rather than sourcing from the
-    // scope tree.
-    std::vector<std::unique_ptr<Constraint>> solverConstraints;
-
-    // This includes every constraint that has not been fully solved.
-    // A constraint can be both blocked and unsolved, for instance.
-    std::vector<NotNull<const Constraint>> unsolvedConstraints;
-
-    // A mapping of constraint pointer to how many things the constraint is
-    // blocked on. Can be empty or 0 for constraints that are not blocked on
-    // anything.
-    std::unordered_map<NotNull<const Constraint>, size_t> blockedConstraints;
-    // A mapping of type/pack pointers to the constraints they block.
-    std::unordered_map<BlockedConstraintId, DenseHashSet<const Constraint*>, HashBlockedConstraintId> blocked;
-    // Memoized instantiations of type aliases.
-    DenseHashMap<InstantiationSignature, TypeId, HashInstantiationSignature> instantiatedAliases{{}};
-    // Breadcrumbs for where a free type's upper bound was expanded. We use
-    // these to provide more helpful error messages when a free type is solved
-    // as never unexpectedly.
-    DenseHashMap<TypeId, std::vector<std::pair<Location, TypeId>>> upperBoundContributors{nullptr};
-
-    // 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{{}};
-
-    // The set of types that will definitely be unchanged by generalization.
-    DenseHashSet<TypeId> generalizedTypes_{nullptr};
-    const NotNull<DenseHashSet<TypeId>> generalizedTypes{&generalizedTypes_};
-
-    // Recorded errors that take place within the solver.
-    ErrorVec errors;
-
-    NotNull<ModuleResolver> moduleResolver;
-    std::vector<RequireCycle> requireCycles;
-
-    DcrLogger* logger;
-    TypeCheckLimits limits;
-
-    DenseHashMap<TypeId, const Constraint*> typeFunctionsToFinalize{nullptr};
-
-    explicit ConstraintSolver(
-        NotNull<Normalizer> normalizer,
-        NotNull<Simplifier> simplifier,
-        NotNull<TypeFunctionRuntime> typeFunctionRuntime,
-        ModuleName moduleName,
-        NotNull<ModuleResolver> moduleResolver,
-        std::vector<RequireCycle> requireCycles,
-        DcrLogger* logger,
-        NotNull<const DataFlowGraph> dfg,
-        TypeCheckLimits limits,
-        ConstraintSet constraintSet
-    );
-
-    explicit ConstraintSolver(
-        NotNull<Normalizer> normalizer,
-        NotNull<Simplifier> simplifier,
-        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,
-        DcrLogger* logger,
-        NotNull<const DataFlowGraph> dfg,
-        TypeCheckLimits limits
-    );
-
-    // Randomize the order in which to dispatch constraints
-    void randomize(unsigned seed);
-
-    /**
-     * Attempts to dispatch all pending constraints and reach a type solution
-     * that satisfies all of the constraints.
-     **/
-    void run();
-
-
-    /**
-     * Attempts to perform one final reduction on type functions after every constraint has been completed
-     *
-     **/
-    void finalizeTypeFunctions();
-
-    bool isDone() const;
-
-private:
-    /// A helper that does most of the setup work that is shared between the two constructors.
-    void initFreeTypeTracking();
-
-    void generalizeOneType(TypeId ty);
-
-    /**
-     * Bind a type variable to another type.
-     *
-     * A constraint is required and will validate that blockedTy is owned by this
-     * constraint. This prevents one constraint from interfering with another's
-     * blocked types.
-     *
-     * Bind will also unblock the type variable for you.
-     */
-    void bind(NotNull<const Constraint> constraint, TypeId ty, TypeId boundTo);
-    void bind(NotNull<const Constraint> constraint, TypePackId tp, TypePackId boundTo);
-
-    template<typename T, typename... Args>
-    void emplace(NotNull<const Constraint> constraint, TypeId ty, Args&&... args);
-
-    template<typename T, typename... Args>
-    void emplace(NotNull<const Constraint> constraint, TypePackId tp, Args&&... args);
-
-public:
-    /** Attempt to dispatch a constraint.  Returns true if it was successful. If
-     * tryDispatch() returns false, the constraint remains in the unsolved set
-     * and will be retried later.
-     */
-    bool tryDispatch(NotNull<const Constraint> c, bool force);
-
-    bool tryDispatch(const SubtypeConstraint& c, NotNull<const Constraint> constraint);
-    bool tryDispatch(const PackSubtypeConstraint& c, NotNull<const Constraint> constraint);
-    bool tryDispatch(const GeneralizationConstraint& c, NotNull<const Constraint> constraint);
-    bool tryDispatch(const IterableConstraint& c, NotNull<const Constraint> constraint, bool force);
-    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);
-
-
-    bool tryDispatchHasIndexer(
-        int& recursionDepth,
-        NotNull<const Constraint> constraint,
-        TypeId subjectType,
-        TypeId indexType,
-        TypeId resultType,
-        Set<TypeId>& seen
-    );
-    bool tryDispatch(const HasIndexerConstraint& c, NotNull<const Constraint> constraint);
-
-    bool tryDispatch(const AssignPropConstraint& c, NotNull<const Constraint> constraint);
-    bool tryDispatch(const AssignIndexConstraint& c, NotNull<const Constraint> constraint);
-    bool tryDispatch(const UnpackConstraint& c, NotNull<const Constraint> constraint);
-    bool tryDispatch(const ReduceConstraint& c, NotNull<const Constraint> constraint, bool force);
-    bool tryDispatch(const ReducePackConstraint& c, NotNull<const Constraint> constraint, bool force);
-    bool tryDispatch(const EqualityConstraint& c, NotNull<const Constraint> constraint);
-
-    // for a, ... in some_table do
-    // also handles __iter metamethod
-    bool tryDispatchIterableTable(TypeId iteratorTy, const IterableConstraint& c, NotNull<const Constraint> constraint, bool force);
-
-    // for a, ... in next_function, t, ... do
-    bool tryDispatchIterableFunction(TypeId nextTy, TypeId tableTy, const IterableConstraint& c, NotNull<const Constraint> constraint);
-
-    TablePropLookupResult lookupTableProp(
-        NotNull<const Constraint> constraint,
-        TypeId subjectType,
-        const std::string& propName,
-        ValueContext context,
-        bool inConditional = false,
-        bool suppressSimplification = false
-    );
-
-    TablePropLookupResult lookupTableProp(
-        NotNull<const Constraint> constraint,
-        TypeId subjectType,
-        const std::string& propName,
-        ValueContext context,
-        bool inConditional,
-        bool suppressSimplification,
-        DenseHashSet<TypeId>& seen
-    );
-
-    /**
-     * Generate constraints to unpack the types of srcTypes and assign each
-     * value to the corresponding BlockedType in destTypes.
-     *
-     * This function also overwrites the owners of each BlockedType.  This is
-     * okay because this function is only used to decompose IterableConstraint
-     * into an UnpackConstraint.
-     *
-     * @param destTypes A vector of types comprised of BlockedTypes.
-     * @param srcTypes A TypePack that represents rvalues to be assigned.
-     * @returns The underlying UnpackConstraint.  There's a bit of code in
-     * iteration that needs to pass blocks on to this constraint.
-     */
-    NotNull<const Constraint> unpackAndAssign(const std::vector<TypeId> destTypes, TypePackId srcTypes, NotNull<const Constraint> constraint);
-
-    void block(NotNull<const Constraint> target, NotNull<const Constraint> constraint);
-    /**
-     * Block a constraint on the resolution of a Type.
-     * @returns false always.  This is just to allow tryDispatch to return the result of block()
-     */
-    bool block(TypeId target, NotNull<const Constraint> constraint);
-    bool block(TypePackId target, NotNull<const Constraint> constraint);
-
-    // Block on every target
-    template<typename T>
-    bool block(const T& targets, NotNull<const Constraint> constraint)
-    {
-        for (TypeId target : targets)
-            block(target, constraint);
-
-        return false;
-    }
-
-    /**
-     * For all constraints that are blocked on one constraint, make them block
-     * on a new constraint.
-     * @param source the constraint to copy blocks from.
-     * @param addition the constraint that other constraints should now block on.
-     */
-    void inheritBlocks(NotNull<const Constraint> source, NotNull<const Constraint> addition);
-
-    // Traverse the type.  If any pending types are found, block the constraint
-    // on them.
-    //
-    // Returns false if a type blocks the constraint.
-    //
-    // FIXME: This use of a boolean for the return result is an appalling
-    // interface.
-    bool blockOnPendingTypes(TypeId target, NotNull<const Constraint> constraint);
-    bool blockOnPendingTypes(TypePackId targetPack, NotNull<const Constraint> constraint);
-
-    void unblock(NotNull<const Constraint> progressed);
-    void unblock(TypeId ty, Location location);
-    void unblock(TypePackId progressed, Location location);
-    void unblock(const std::vector<TypeId>& types, Location location);
-    void unblock(const std::vector<TypePackId>& packs, Location location);
-
-    /**
-     * @returns true if the TypeId is in a blocked state.
-     */
-    bool isBlocked(TypeId ty) const;
-
-    /**
-     * @returns true if the TypePackId is in a blocked state.
-     */
-    bool isBlocked(TypePackId tp) const;
-
-    /**
-     * Returns whether the constraint is blocked on anything.
-     * @param constraint the constraint to check.
-     */
-    bool isBlocked(NotNull<const Constraint> constraint) const;
-
-    /** Pushes a new solver constraint to the solver.
-     * @param cv the body of the constraint.
-     **/
-    NotNull<Constraint> pushConstraint(NotNull<Scope> scope, const Location& location, ConstraintV cv);
-
-    /**
-     * Attempts to resolve a module from its module information. Returns the
-     * module-level return type of the module, or the error type if one cannot
-     * be found. Reports errors to the solver if the module cannot be found or
-     * the require is illegal.
-     * @param module the module information to look up.
-     * @param location the location where the require is taking place; used for
-     * error locations.
-     **/
-    TypeId resolveModule(const ModuleInfo& info, const Location& location);
-
-    void reportError(TypeErrorData&& data, const Location& location);
-    void reportError(TypeError e);
-
-    /**
-     * Shifts the count of references from `source` to `target`. This should be paired
-     * with any instance of binding a free type in order to maintain accurate refcounts.
-     * If `target` is not a free type, this is a noop.
-     * @param source the free type which is being bound
-     * @param target the type which the free type is being bound to
-     */
-    void shiftReferences(TypeId source, TypeId target);
-
-    /**
-     * Generalizes the given free type if the reference counting allows it.
-     * @param the scope to generalize in
-     * @param type the free type we want to generalize
-     * @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);
-
-    /**
-     * Checks the existing set of constraints to see if there exist any that contain
-     * the provided free type, indicating that it is not yet ready to be replaced by
-     * one of its bounds.
-     * @param ty the free type that to check for related constraints
-     * @returns whether or not it is unsafe to replace the free type by one of its bounds
-     */
-    bool hasUnresolvedConstraints(TypeId ty);
-
-    /** Attempts to unify subTy with superTy.  If doing so would require unifying
-     * BlockedTypes, fail and block the constraint on those BlockedTypes.
-     *
-     * Note: TID can only be TypeId or TypePackId.
-     *
-     * If unification fails, replace all free types with errorType.
-     *
-     * If unification succeeds, unblock every type changed by the unification.
-     *
-     * @returns true if the unification succeeded.  False if the unification was
-     * too complex.
-     */
-    template<typename TID>
-    bool unify(NotNull<const Constraint> constraint, TID subTy, TID superTy);
-
-    /**
-     * Marks a constraint as being blocked on a type or type pack. The constraint
-     * solver will not attempt to dispatch blocked constraints until their
-     * dependencies have made progress.
-     * @param target the type or type pack pointer that the constraint is blocked on.
-     * @param constraint the constraint to block.
-     **/
-    bool block_(BlockedConstraintId target, NotNull<const Constraint> constraint);
-
-    /**
-     * Informs the solver that progress has been made on a type or type pack. The
-     * solver will wake up all constraints that are blocked on the type or type pack,
-     * and will resume attempting to dispatch them.
-     * @param progressed the type or type pack pointer that has progressed.
-     **/
-    void unblock_(BlockedConstraintId progressed);
-
-    /**
-     * Reproduces any constraints necessary for new types that are copied when applying a substitution.
-     * At the time of writing, this pertains only to type functions.
-     * @param subst the substitution that was applied
-     **/
-    void reproduceConstraints(NotNull<Scope> scope, const Location& location, const Substitution& subst);
-
-    TypeId simplifyIntersection(NotNull<Scope> scope, Location location, TypeId left, TypeId right);
-    TypeId simplifyIntersection(NotNull<Scope> scope, Location location, std::set<TypeId> parts);
-    TypeId simplifyUnion(NotNull<Scope> scope, Location location, TypeId left, TypeId right);
-
-    TypeId errorRecoveryType() const;
-    TypePackId errorRecoveryTypePack() const;
-
-    TypePackId anyifyModuleReturnTypePackGenerics(TypePackId tp);
-
-    void throwTimeLimitError() const;
-    void throwUserCancelError() const;
-
-    ToStringOptions opts;
-
-    void fillInDiscriminantTypes(NotNull<const Constraint> constraint, const std::vector<std::optional<TypeId>>& discriminantTypes);
-};
-
-/** Borrow a vector of pointers from a vector of owning pointers to constraints.
- */
-std::vector<NotNull<Constraint>> borrowConstraints(const std::vector<ConstraintPtr>& constraints);
-
-void dump(NotNull<Scope> rootScope, struct ToStringOptions& opts);
-
-} // namespace Luau

Analysis/include/Luau/ControlFlow.h

@@ -1,36 +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 <memory>
-
-namespace Luau
-{
-
-struct Scope;
-using ScopePtr = std::shared_ptr<Scope>;
-
-enum class ControlFlow
-{
-    None = 0b00001,
-    Returns = 0b00010,
-    Throws = 0b00100,
-    Breaks = 0b01000,
-    Continues = 0b10000,
-};
-
-inline ControlFlow operator&(ControlFlow a, ControlFlow b)
-{
-    return ControlFlow(int(a) & int(b));
-}
-
-inline ControlFlow operator|(ControlFlow a, ControlFlow b)
-{
-    return ControlFlow(int(a) | int(b));
-}
-
-inline bool matches(ControlFlow a, ControlFlow b)
-{
-    return (a & b) != ControlFlow(0);
-}
-
-} // namespace Luau

Analysis/include/Luau/DataFlowGraph.h

@@ -1,222 +0,0 @@
-// This file is part of the Luau programming language and is licensed under MIT License; see LICENSE.txt for details
-#pragma once
-
-// Do not include LValue. It should never be used here.
-#include "Luau/Ast.h"
-#include "Luau/ControlFlow.h"
-#include "Luau/DenseHash.h"
-#include "Luau/Def.h"
-#include "Luau/NotNull.h"
-#include "Luau/Symbol.h"
-#include "Luau/TypedAllocator.h"
-
-#include <unordered_map>
-
-namespace Luau
-{
-
-struct RefinementKey
-{
-    const RefinementKey* parent = nullptr;
-    DefId def;
-    std::optional<std::string> propName;
-};
-
-struct RefinementKeyArena
-{
-    TypedAllocator<RefinementKey> allocator;
-
-    const RefinementKey* leaf(DefId def);
-    const RefinementKey* node(const RefinementKey* parent, DefId def, const std::string& propName);
-};
-
-struct DataFlowGraph
-{
-    DataFlowGraph(DataFlowGraph&&) = default;
-    DataFlowGraph& operator=(DataFlowGraph&&) = default;
-
-    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;
-
-    DefId getDef(const AstLocal* local) const;
-
-    DefId getDef(const AstStatDeclareGlobal* global) const;
-    DefId getDef(const AstStatDeclareFunction* func) const;
-
-    const RefinementKey* getRefinementKey(const AstExpr* expr) const;
-
-private:
-    DataFlowGraph(NotNull<DefArena> defArena, NotNull<RefinementKeyArena> keyArena);
-
-    DataFlowGraph(const DataFlowGraph&) = delete;
-    DataFlowGraph& operator=(const DataFlowGraph&) = delete;
-
-    NotNull<DefArena> defArena;
-    NotNull<RefinementKeyArena> keyArena;
-
-    DenseHashMap<const AstExpr*, const Def*> astDefs{nullptr};
-
-    // Sometimes we don't have the AstExprLocal* but we have AstLocal*, and sometimes we need to extract that DefId.
-    DenseHashMap<const AstLocal*, const Def*> localDefs{nullptr};
-
-    // There's no AstStatDeclaration, and it feels useless to introduce it just to enforce an invariant in one place.
-    // All keys in this maps are really only statements that ambiently declares a symbol.
-    DenseHashMap<const AstStat*, const Def*> declaredDefs{nullptr};
-
-    DenseHashMap<const AstExpr*, const RefinementKey*> astRefinementKeys{nullptr};
-    friend struct DataFlowGraphBuilder;
-};
-
-struct DfgScope
-{
-    enum ScopeType
-    {
-        Linear,
-        Loop,
-        Function,
-    };
-
-    DfgScope* parent;
-    ScopeType scopeType;
-
-    using Bindings = DenseHashMap<Symbol, const Def*>;
-    using Props = DenseHashMap<const Def*, std::unordered_map<std::string, const Def*>>;
-
-    Bindings bindings{Symbol{}};
-    Props props{nullptr};
-
-    std::optional<DefId> lookup(Symbol symbol) const;
-    std::optional<DefId> lookup(DefId def, const std::string& key) const;
-
-    void inherit(const DfgScope* childScope);
-
-    bool canUpdateDefinition(Symbol symbol) const;
-    bool canUpdateDefinition(DefId def, const std::string& key) const;
-};
-
-struct DataFlowResult
-{
-    DefId def;
-    const RefinementKey* parent = nullptr;
-};
-
-using ScopeStack = std::vector<DfgScope*>;
-
-struct DataFlowGraphBuilder
-{
-    static DataFlowGraph build(
-        AstStatBlock* block,
-        NotNull<DefArena> defArena,
-        NotNull<RefinementKeyArena> keyArena,
-        NotNull<struct InternalErrorReporter> handle
-    );
-
-private:
-    DataFlowGraphBuilder(NotNull<DefArena> defArena, NotNull<RefinementKeyArena> keyArena);
-
-    DataFlowGraphBuilder(const DataFlowGraphBuilder&) = delete;
-    DataFlowGraphBuilder& operator=(const DataFlowGraphBuilder&) = delete;
-
-    DataFlowGraph graph;
-    NotNull<DefArena> defArena;
-    NotNull<RefinementKeyArena> keyArena;
-
-    struct InternalErrorReporter* handle = nullptr;
-
-    /// The arena owning all of the scope allocations for the dataflow graph being built.
-    std::vector<std::unique_ptr<DfgScope>> scopes;
-
-    /// A stack of scopes used by the visitor to see where we are.
-    ScopeStack scopeStack;
-    NotNull<DfgScope> currentScope();
-    DfgScope* currentScope_DEPRECATED();
-
-    struct FunctionCapture
-    {
-        std::vector<DefId> captureDefs;
-        std::vector<DefId> allVersions;
-        size_t versionOffset = 0;
-    };
-
-    DenseHashMap<Symbol, FunctionCapture> captures{Symbol{}};
-    void resolveCaptures();
-
-    DfgScope* makeChildScope(DfgScope::ScopeType scopeType = DfgScope::Linear);
-
-    void join(DfgScope* p, DfgScope* a, DfgScope* b);
-    void joinBindings(DfgScope* p, const DfgScope& a, const DfgScope& b);
-    void joinProps(DfgScope* p, const DfgScope& a, const DfgScope& b);
-
-    DefId lookup(Symbol symbol, Location location);
-    DefId lookup(DefId def, const std::string& key, Location location);
-
-    ControlFlow visit(AstStatBlock* b);
-    ControlFlow visitBlockWithoutChildScope(AstStatBlock* b);
-
-    ControlFlow visit(AstStat* s);
-    ControlFlow visit(AstStatIf* i);
-    ControlFlow visit(AstStatWhile* w);
-    ControlFlow visit(AstStatRepeat* r);
-    ControlFlow visit(AstStatBreak* b);
-    ControlFlow visit(AstStatContinue* c);
-    ControlFlow visit(AstStatReturn* r);
-    ControlFlow visit(AstStatExpr* e);
-    ControlFlow visit(AstStatLocal* l);
-    ControlFlow visit(AstStatFor* f);
-    ControlFlow visit(AstStatForIn* f);
-    ControlFlow visit(AstStatAssign* a);
-    ControlFlow visit(AstStatCompoundAssign* c);
-    ControlFlow visit(AstStatFunction* f);
-    ControlFlow visit(AstStatLocalFunction* l);
-    ControlFlow visit(AstStatTypeAlias* t);
-    ControlFlow visit(AstStatTypeFunction* f);
-    ControlFlow visit(AstStatDeclareGlobal* d);
-    ControlFlow visit(AstStatDeclareFunction* d);
-    ControlFlow visit(AstStatDeclareExternType* d);
-    ControlFlow visit(AstStatError* error);
-
-    DataFlowResult visitExpr(AstExpr* e);
-    DataFlowResult visitExpr(AstExprGroup* group);
-    DataFlowResult visitExpr(AstExprLocal* l);
-    DataFlowResult visitExpr(AstExprGlobal* g);
-    DataFlowResult visitExpr(AstExprCall* c);
-    DataFlowResult visitExpr(AstExprIndexName* i);
-    DataFlowResult visitExpr(AstExprIndexExpr* i);
-    DataFlowResult visitExpr(AstExprFunction* f);
-    DataFlowResult visitExpr(AstExprTable* t);
-    DataFlowResult visitExpr(AstExprUnary* u);
-    DataFlowResult visitExpr(AstExprBinary* b);
-    DataFlowResult visitExpr(AstExprTypeAssertion* t);
-    DataFlowResult visitExpr(AstExprIfElse* i);
-    DataFlowResult visitExpr(AstExprInterpString* i);
-    DataFlowResult visitExpr(AstExprError* error);
-
-    void visitLValue(AstExpr* e, DefId incomingDef);
-    DefId visitLValue(AstExprLocal* l, DefId incomingDef);
-    DefId visitLValue(AstExprGlobal* g, DefId incomingDef);
-    DefId visitLValue(AstExprIndexName* i, DefId incomingDef);
-    DefId visitLValue(AstExprIndexExpr* i, DefId incomingDef);
-    DefId visitLValue(AstExprError* e, DefId incomingDef);
-
-    void visitType(AstType* t);
-    void visitType(AstTypeReference* r);
-    void visitType(AstTypeTable* t);
-    void visitType(AstTypeFunction* f);
-    void visitType(AstTypeTypeof* t);
-    void visitType(AstTypeUnion* u);
-    void visitType(AstTypeIntersection* i);
-    void visitType(AstTypeError* error);
-
-    void visitTypePack(AstTypePack* p);
-    void visitTypePack(AstTypePackExplicit* e);
-    void visitTypePack(AstTypePackVariadic* v);
-    void visitTypePack(AstTypePackGeneric* g);
-
-    void visitTypeList(AstTypeList l);
-
-    void visitGenerics(AstArray<AstGenericType*> g);
-    void visitGenericPacks(AstArray<AstGenericTypePack*> g);
-};
-
-} // namespace Luau

Analysis/include/Luau/DcrLogger.h

@@ -1,151 +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/Constraint.h"
-#include "Luau/NotNull.h"
-#include "Luau/Scope.h"
-#include "Luau/Module.h"
-#include "Luau/ToString.h"
-#include "Luau/Error.h"
-#include "Luau/Variant.h"
-
-#include <optional>
-#include <string>
-#include <vector>
-
-namespace Luau
-{
-
-struct ErrorSnapshot
-{
-    std::string message;
-    Location location;
-};
-
-struct BindingSnapshot
-{
-    std::string typeId;
-    std::string typeString;
-    Location location;
-};
-
-struct TypeBindingSnapshot
-{
-    std::string typeId;
-    std::string typeString;
-};
-
-struct ExprTypesAtLocation
-{
-    Location location;
-    TypeId ty;
-    std::optional<TypeId> expectedTy;
-};
-
-struct AnnotationTypesAtLocation
-{
-    Location location;
-    TypeId resolvedTy;
-};
-
-struct ConstraintGenerationLog
-{
-    std::string source;
-    std::vector<ErrorSnapshot> errors;
-
-    std::vector<ExprTypesAtLocation> exprTypeLocations;
-    std::vector<AnnotationTypesAtLocation> annotationTypeLocations;
-};
-
-struct ScopeSnapshot
-{
-    std::unordered_map<Name, BindingSnapshot> bindings;
-    std::unordered_map<Name, TypeBindingSnapshot> typeBindings;
-    std::unordered_map<Name, TypeBindingSnapshot> typePackBindings;
-    std::vector<ScopeSnapshot> children;
-};
-
-using ConstraintBlockTarget = Variant<TypeId, TypePackId, NotNull<const Constraint>>;
-
-struct ConstraintBlock
-{
-    ConstraintBlockTarget target;
-    std::string stringification;
-};
-
-struct ConstraintSnapshot
-{
-    std::string stringification;
-    Location location;
-    std::vector<ConstraintBlock> blocks;
-};
-
-struct BoundarySnapshot
-{
-    DenseHashMap<const Constraint*, ConstraintSnapshot> unsolvedConstraints{nullptr};
-    ScopeSnapshot rootScope;
-    DenseHashMap<const void*, std::string> typeStrings{nullptr};
-};
-
-struct StepSnapshot
-{
-    const Constraint* currentConstraint;
-    bool forced;
-    DenseHashMap<const Constraint*, ConstraintSnapshot> unsolvedConstraints{nullptr};
-    ScopeSnapshot rootScope;
-    DenseHashMap<const void*, std::string> typeStrings{nullptr};
-};
-
-struct TypeSolveLog
-{
-    BoundarySnapshot initialState;
-    std::vector<StepSnapshot> stepStates;
-    BoundarySnapshot finalState;
-};
-
-struct TypeCheckLog
-{
-    std::vector<ErrorSnapshot> errors;
-};
-
-struct DcrLogger
-{
-    std::string compileOutput();
-
-    void captureSource(std::string source);
-    void captureGenerationError(const TypeError& error);
-    void captureConstraintLocation(NotNull<const Constraint> constraint, Location location);
-    void captureGenerationModule(const ModulePtr& module);
-
-    void pushBlock(NotNull<const Constraint> constraint, TypeId block);
-    void pushBlock(NotNull<const Constraint> constraint, TypePackId block);
-    void pushBlock(NotNull<const Constraint> constraint, NotNull<const Constraint> block);
-    void popBlock(TypeId block);
-    void popBlock(TypePackId block);
-    void popBlock(NotNull<const Constraint> block);
-
-    void captureInitialSolverState(const Scope* rootScope, const std::vector<NotNull<const Constraint>>& unsolvedConstraints);
-    StepSnapshot prepareStepSnapshot(
-        const Scope* rootScope,
-        NotNull<const Constraint> current,
-        bool force,
-        const std::vector<NotNull<const Constraint>>& unsolvedConstraints
-    );
-    void commitStepSnapshot(StepSnapshot snapshot);
-    void captureFinalSolverState(const Scope* rootScope, const std::vector<NotNull<const Constraint>>& unsolvedConstraints);
-
-    void captureTypeCheckError(const TypeError& error);
-
-private:
-    ConstraintGenerationLog generationLog;
-    std::unordered_map<NotNull<const Constraint>, std::vector<ConstraintBlockTarget>> constraintBlocks;
-    TypeSolveLog solveLog;
-    TypeCheckLog checkLog;
-
-    ToStringOptions opts{true};
-
-    std::vector<ConstraintBlock> snapshotBlocks(NotNull<const Constraint> constraint);
-    void captureBoundaryState(BoundarySnapshot& target, const Scope* rootScope, const std::vector<NotNull<const Constraint>>& unsolvedConstraints);
-};
-
-} // namespace Luau

Analysis/include/Luau/Def.h

@@ -1,91 +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/NotNull.h"
-#include "Luau/TypedAllocator.h"
-#include "Luau/Variant.h"
-#include "Luau/Location.h"
-#include "Luau/Symbol.h"
-#include <string>
-#include <optional>
-
-namespace Luau
-{
-
-struct Def;
-using DefId = NotNull<const Def>;
-struct AstLocal;
-
-/**
- * A cell is a "single-object" value.
- *
- * Leaky implementation note: sometimes "multiple-object" values, but none of which were interesting enough to warrant creating a phi node instead.
- * That can happen because there's no point in creating a phi node that points to either resultant in `if math.random() > 0.5 then 5 else "hello"`.
- * This might become of utmost importance if we wanted to do some backward reasoning, e.g. if `5` is taken, then `cond` must be `truthy`.
- */
-struct Cell
-{
-    bool subscripted = false;
-};
-
-/**
- * A phi node is a union of cells.
- *
- * We need this because we're statically evaluating a program, and sometimes a place may be assigned with
- * different cells, and when that happens, we need a special data type that merges in all the cells
- * that will flow into that specific place. For example, consider this simple program:
- *
- * ```
- * x-1
- * if cond() then
- *   x-2 = 5
- * else
- *   x-3 = "hello"
- * end
- * x-4 : {x-2, x-3}
- * ```
- *
- * At x-4, we know for a fact statically that either `5` or `"hello"` can flow into the variable `x` after the branch, but
- * we cannot make any definitive decisions about which one, so we just take in both.
- */
-struct Phi
-{
-    std::vector<DefId> operands;
-};
-
-/**
- * We statically approximate a value at runtime using a symbolic value, which we call a Def.
- *
- * DataFlowGraphBuilder will allocate these defs as a stand-in for some Luau values, and bind them to places that
- * can hold a Luau value, and then observes how those defs will commute as it statically evaluate the program.
- *
- * It must also be noted that defs are a cyclic graph, so it is not safe to recursively traverse into it expecting it to terminate.
- */
-struct Def
-{
-    using V = Variant<struct Cell, struct Phi>;
-
-    V v;
-    Symbol name;
-    Location location;
-};
-
-template<typename T>
-const T* get(DefId def)
-{
-    return get_if<T>(&def->v);
-}
-
-bool containsSubscriptedDefinition(DefId def);
-void collectOperands(DefId def, std::vector<DefId>* operands);
-
-struct DefArena
-{
-    TypedAllocator<Def> allocator;
-
-    DefId freshCell(Symbol sym, Location location, bool subscripted = false);
-    DefId phi(DefId a, DefId b);
-    DefId phi(const std::vector<DefId>& defs);
-};
-
-} // namespace Luau

Analysis/include/Luau/Differ.h

@@ -1,208 +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/DenseHash.h"
-#include "Luau/TypeFwd.h"
-#include "Luau/UnifierSharedState.h"
-
-#include <optional>
-#include <string>
-#include <unordered_set>
-
-namespace Luau
-{
-struct DiffPathNode
-{
-    // TODO: consider using Variants to simplify toString implementation
-    enum Kind
-    {
-        TableProperty,
-        FunctionArgument,
-        FunctionReturn,
-        Union,
-        Intersection,
-        Negation,
-    };
-    Kind kind;
-    // non-null when TableProperty
-    std::optional<Name> tableProperty;
-    // non-null when FunctionArgument (unless variadic arg), FunctionReturn (unless variadic arg), Union, or Intersection (i.e. anonymous fields)
-    std::optional<size_t> index;
-
-    /**
-     * Do not use for leaf nodes
-     */
-    DiffPathNode(Kind kind)
-        : kind(kind)
-    {
-    }
-
-    DiffPathNode(Kind kind, std::optional<Name> tableProperty, std::optional<size_t> index)
-        : kind(kind)
-        , tableProperty(tableProperty)
-        , index(index)
-    {
-    }
-
-    std::string toString() const;
-
-    static DiffPathNode constructWithTableProperty(Name tableProperty);
-
-    static DiffPathNode constructWithKindAndIndex(Kind kind, size_t index);
-
-    static DiffPathNode constructWithKind(Kind kind);
-};
-
-struct DiffPathNodeLeaf
-{
-    std::optional<TypeId> ty;
-    std::optional<Name> tableProperty;
-    std::optional<int> minLength;
-    bool isVariadic;
-    // TODO: Rename to anonymousIndex, for both union and Intersection
-    std::optional<size_t> unionIndex;
-    DiffPathNodeLeaf(
-        std::optional<TypeId> ty,
-        std::optional<Name> tableProperty,
-        std::optional<int> minLength,
-        bool isVariadic,
-        std::optional<size_t> unionIndex
-    )
-        : ty(ty)
-        , tableProperty(tableProperty)
-        , minLength(minLength)
-        , isVariadic(isVariadic)
-        , unionIndex(unionIndex)
-    {
-    }
-
-    static DiffPathNodeLeaf detailsNormal(TypeId ty);
-
-    static DiffPathNodeLeaf detailsTableProperty(TypeId ty, Name tableProperty);
-
-    static DiffPathNodeLeaf detailsUnionIndex(TypeId ty, size_t index);
-
-    static DiffPathNodeLeaf detailsLength(int minLength, bool isVariadic);
-
-    static DiffPathNodeLeaf nullopts();
-};
-
-struct DiffPath
-{
-    std::vector<DiffPathNode> path;
-
-    std::string toString(bool prependDot) const;
-};
-struct DiffError
-{
-    enum Kind
-    {
-        Normal,
-        MissingTableProperty,
-        MissingUnionMember,
-        MissingIntersectionMember,
-        IncompatibleGeneric,
-        LengthMismatchInFnArgs,
-        LengthMismatchInFnRets,
-    };
-    Kind kind;
-
-    DiffPath diffPath;
-    DiffPathNodeLeaf left;
-    DiffPathNodeLeaf right;
-
-    std::string leftRootName;
-    std::string rightRootName;
-
-    DiffError(Kind kind, DiffPathNodeLeaf left, DiffPathNodeLeaf right, std::string leftRootName, std::string rightRootName)
-        : kind(kind)
-        , left(left)
-        , right(right)
-        , leftRootName(leftRootName)
-        , rightRootName(rightRootName)
-    {
-        checkValidInitialization(left, right);
-    }
-    DiffError(Kind kind, DiffPath diffPath, DiffPathNodeLeaf left, DiffPathNodeLeaf right, std::string leftRootName, std::string rightRootName)
-        : kind(kind)
-        , diffPath(diffPath)
-        , left(left)
-        , right(right)
-        , leftRootName(leftRootName)
-        , rightRootName(rightRootName)
-    {
-        checkValidInitialization(left, right);
-    }
-
-    std::string toString(bool multiLine = false) const;
-
-private:
-    std::string toStringALeaf(std::string rootName, const DiffPathNodeLeaf& leaf, const DiffPathNodeLeaf& otherLeaf, bool multiLine) const;
-    void checkValidInitialization(const DiffPathNodeLeaf& left, const DiffPathNodeLeaf& right);
-    void checkNonMissingPropertyLeavesHaveNulloptTableProperty() const;
-};
-
-struct DifferResult
-{
-    std::optional<DiffError> diffError;
-
-    DifferResult() {}
-    DifferResult(DiffError diffError)
-        : diffError(diffError)
-    {
-    }
-
-    void wrapDiffPath(DiffPathNode node);
-};
-struct DifferEnvironment
-{
-    TypeId rootLeft;
-    TypeId rootRight;
-    std::optional<std::string> externalSymbolLeft;
-    std::optional<std::string> externalSymbolRight;
-    DenseHashMap<TypeId, TypeId> genericMatchedPairs;
-    DenseHashMap<TypePackId, TypePackId> genericTpMatchedPairs;
-
-    DifferEnvironment(
-        TypeId rootLeft,
-        TypeId rootRight,
-        std::optional<std::string> externalSymbolLeft,
-        std::optional<std::string> externalSymbolRight
-    )
-        : rootLeft(rootLeft)
-        , rootRight(rootRight)
-        , externalSymbolLeft(externalSymbolLeft)
-        , externalSymbolRight(externalSymbolRight)
-        , genericMatchedPairs(nullptr)
-        , genericTpMatchedPairs(nullptr)
-    {
-    }
-
-    bool isProvenEqual(TypeId left, TypeId right) const;
-    bool isAssumedEqual(TypeId left, TypeId right) const;
-    void recordProvenEqual(TypeId left, TypeId right);
-    void pushVisiting(TypeId left, TypeId right);
-    void popVisiting();
-    std::vector<std::pair<TypeId, TypeId>>::const_reverse_iterator visitingBegin() const;
-    std::vector<std::pair<TypeId, TypeId>>::const_reverse_iterator visitingEnd() const;
-    std::string getDevFixFriendlyNameLeft() const;
-    std::string getDevFixFriendlyNameRight() const;
-
-private:
-    // TODO: consider using DenseHashSet
-    std::unordered_set<std::pair<TypeId, TypeId>, TypeIdPairHash> provenEqual;
-    // Ancestors of current types
-    std::unordered_set<std::pair<TypeId, TypeId>, TypeIdPairHash> visiting;
-    std::vector<std::pair<TypeId, TypeId>> visitingStack;
-};
-DifferResult diff(TypeId ty1, TypeId ty2);
-DifferResult diffWithSymbols(TypeId ty1, TypeId ty2, std::optional<std::string> symbol1, std::optional<std::string> symbol2);
-
-/**
- * True if ty is a "simple" type, i.e. cannot contain types.
- * string, number, boolean are simple types.
- * function and table are not simple types.
- */
-bool isSimple(TypeId ty);
-
-} // namespace Luau

Analysis/include/Luau/Documentation.h

@@ -1,4 +1,3 @@
-// This file is part of the Luau programming language and is licensed under MIT License; see LICENSE.txt for details
 #pragma once
 
 #include "Luau/DenseHash.h"
@@ -22,7 +21,6 @@ struct BasicDocumentation
 {
     std::string documentation;
     std::string learnMoreLink;
-    std::string codeSample;
 };
 
 struct FunctionParameterDocumentation
@@ -39,7 +37,6 @@ struct FunctionDocumentation
     std::vector<FunctionParameterDocumentation> parameters;
     std::vector<DocumentationSymbol> returns;
     std::string learnMoreLink;
-    std::string codeSample;
 };
 
 struct OverloadedFunctionDocumentation
@@ -55,7 +52,6 @@ struct TableDocumentation
     std::string documentation;
     Luau::DenseHashMap<std::string, DocumentationSymbol> keys;
     std::string learnMoreLink;
-    std::string codeSample;
 };
 
 using DocumentationDatabase = Luau::DenseHashMap<DocumentationSymbol, Documentation>;

Analysis/include/Luau/EqSatSimplification.h

@@ -1,50 +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/TypeFwd.h"
-#include "Luau/NotNull.h"
-#include "Luau/DenseHash.h"
-
-#include <memory>
-#include <optional>
-#include <vector>
-
-namespace Luau
-{
-struct TypeArena;
-}
-
-// The EqSat stuff is pretty template heavy, so we go to some lengths to prevent
-// the complexity from leaking outside its implementation sources.
-namespace Luau::EqSatSimplification
-{
-
-struct Simplifier;
-
-using SimplifierPtr = std::unique_ptr<Simplifier, void (*)(Simplifier*)>;
-
-SimplifierPtr newSimplifier(NotNull<TypeArena> arena, NotNull<BuiltinTypes> builtinTypes);
-
-} // namespace Luau::EqSatSimplification
-
-namespace Luau
-{
-
-struct EqSatSimplificationResult
-{
-    TypeId result;
-
-    // New type function applications that were created by the reduction phase.
-    // We return these so that the ConstraintSolver can know to try to reduce
-    // them.
-    std::vector<TypeId> newTypeFunctions;
-};
-
-using EqSatSimplification::newSimplifier;    // NOLINT: clang-tidy thinks these are unused.  It is incorrect.
-using Luau::EqSatSimplification::Simplifier; // NOLINT
-using Luau::EqSatSimplification::SimplifierPtr;
-
-std::optional<EqSatSimplificationResult> eqSatSimplify(NotNull<Simplifier> simplifier, TypeId ty);
-
-} // namespace Luau

Analysis/include/Luau/EqSatSimplificationImpl.h

@@ -1,376 +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/EGraph.h"
-#include "Luau/Id.h"
-#include "Luau/Language.h"
-#include "Luau/Lexer.h" // For Allocator
-#include "Luau/NotNull.h"
-#include "Luau/TypeArena.h"
-#include "Luau/TypeFwd.h"
-
-namespace Luau
-{
-struct TypeFunction;
-}
-
-namespace Luau::EqSatSimplification
-{
-
-using StringId = uint32_t;
-using Id = Luau::EqSat::Id;
-
-LUAU_EQSAT_UNIT(TNil);
-LUAU_EQSAT_UNIT(TBoolean);
-LUAU_EQSAT_UNIT(TNumber);
-LUAU_EQSAT_UNIT(TString);
-LUAU_EQSAT_UNIT(TThread);
-LUAU_EQSAT_UNIT(TTopFunction);
-LUAU_EQSAT_UNIT(TTopTable);
-LUAU_EQSAT_UNIT(TTopClass);
-LUAU_EQSAT_UNIT(TBuffer);
-
-// Used for any type that eqsat can't do anything interesting with.
-LUAU_EQSAT_ATOM(TOpaque, TypeId);
-
-LUAU_EQSAT_ATOM(SBoolean, bool);
-LUAU_EQSAT_ATOM(SString, StringId);
-
-LUAU_EQSAT_ATOM(TFunction, TypeId);
-
-LUAU_EQSAT_ATOM(TImportedTable, TypeId);
-
-LUAU_EQSAT_ATOM(TClass, TypeId);
-
-LUAU_EQSAT_UNIT(TAny);
-LUAU_EQSAT_UNIT(TError);
-LUAU_EQSAT_UNIT(TUnknown);
-LUAU_EQSAT_UNIT(TNever);
-
-LUAU_EQSAT_NODE_SET(Union);
-LUAU_EQSAT_NODE_SET(Intersection);
-
-LUAU_EQSAT_NODE_ARRAY(Negation, 1);
-
-LUAU_EQSAT_NODE_ATOM_WITH_VECTOR(TTypeFun, std::shared_ptr<const TypeFunctionInstanceType>);
-
-LUAU_EQSAT_UNIT(TNoRefine);
-LUAU_EQSAT_UNIT(Invalid);
-
-// enodes are immutable, but types are cyclic.  We need a way to tie the knot.
-// We handle this by generating TBound nodes at points where we encounter cycles.
-// Each TBound has an ordinal that we later map onto the type.
-// We use a substitution rule to replace all TBound nodes with their referrent.
-LUAU_EQSAT_ATOM(TBound, size_t);
-
-// Tables are sufficiently unlike other enodes that the Language.h macros won't cut it.
-struct TTable
-{
-    explicit TTable(Id basis);
-    TTable(Id basis, std::vector<StringId> propNames_, std::vector<Id> propTypes_);
-
-    // All TTables extend some other table.  This may be TTopTable.
-    //
-    // It will frequently be a TImportedTable, in which case we can reuse things
-    // like source location and documentation info.
-    Id getBasis() const;
-    EqSat::Slice<const Id> propTypes() const;
-    // TODO: Also support read-only table props
-    // TODO: Indexer type, index result type.
-
-    std::vector<StringId> propNames;
-
-    // The enode interface
-    EqSat::Slice<Id> mutableOperands();
-    EqSat::Slice<const Id> operands() const;
-    bool operator==(const TTable& rhs) const;
-    bool operator!=(const TTable& rhs) const
-    {
-        return !(*this == rhs);
-    }
-
-    struct Hash
-    {
-        size_t operator()(const TTable& value) const;
-    };
-
-private:
-    // The first element of this vector is the basis.  Subsequent elements are
-    // property types. As we add other things like read-only properties and
-    // indexers, the structure of this array is likely to change.
-    //
-    // We encode our data in this way so that the operands() method can properly
-    // return a Slice<Id>.
-    std::vector<Id> storage;
-};
-
-template<typename L>
-using Node = EqSat::Node<L>;
-
-using EType = EqSat::Language<
-    TNil,
-    TBoolean,
-    TNumber,
-    TString,
-    TThread,
-    TTopFunction,
-    TTopTable,
-    TTopClass,
-    TBuffer,
-
-    TOpaque,
-
-    SBoolean,
-    SString,
-
-    TFunction,
-    TTable,
-    TImportedTable,
-    TClass,
-
-    TAny,
-    TError,
-    TUnknown,
-    TNever,
-
-    Union,
-    Intersection,
-
-    Negation,
-
-    TTypeFun,
-
-    Invalid,
-    TNoRefine,
-    TBound>;
-
-
-struct StringCache
-{
-    Allocator allocator;
-    DenseHashMap<std::string_view, StringId> strings{{}};
-    std::vector<std::string_view> views;
-
-    StringId add(std::string_view s);
-    std::string_view asStringView(StringId id) const;
-    std::string asString(StringId id) const;
-};
-
-using EGraph = Luau::EqSat::EGraph<EType, struct Simplify>;
-
-struct Simplify
-{
-    using Data = bool;
-
-    template<typename T>
-    Data make(const EGraph&, const T&) const;
-
-    void join(Data& left, const Data& right) const;
-};
-
-struct Subst
-{
-    Id eclass;
-    Id newClass;
-
-    // The node into eclass which is boring, if any
-    std::optional<size_t> boringIndex;
-
-    std::string desc;
-
-    Subst(Id eclass, Id newClass, std::string desc = "");
-};
-
-struct Simplifier
-{
-    NotNull<TypeArena> arena;
-    NotNull<BuiltinTypes> builtinTypes;
-    EGraph egraph;
-    StringCache stringCache;
-
-    // enodes are immutable but types can be cyclic, so we need some way to
-    // encode the cycle. This map is used to connect TBound nodes to the right
-    // eclass.
-    //
-    // The cyclicIntersection rewrite rule uses this to sense when a cycle can
-    // be deleted from an intersection or union.
-    std::unordered_map<size_t, Id> mappingIdToClass;
-
-    std::vector<Subst> substs;
-
-    using RewriteRuleFn = void (Simplifier::*)(Id id);
-
-    Simplifier(NotNull<TypeArena> arena, NotNull<BuiltinTypes> builtinTypes);
-
-    // Utilities
-    const EqSat::EClass<EType, Simplify::Data>& get(Id id) const;
-    Id find(Id id) const;
-    Id add(EType enode);
-
-    template<typename Tag>
-    const Tag* isTag(Id id) const;
-
-    template<typename Tag>
-    const Tag* isTag(const EType& enode) const;
-
-    void subst(Id from, Id to);
-    void subst(Id from, Id to, const std::string& ruleName);
-    void subst(Id from, Id to, const std::string& ruleName, const std::unordered_map<Id, size_t>& forceNodes);
-    void subst(Id from, size_t boringIndex, Id to, const std::string& ruleName, const std::unordered_map<Id, size_t>& forceNodes);
-
-    void unionClasses(std::vector<Id>& hereParts, Id there);
-
-    // Rewrite rules
-    void simplifyUnion(Id id);
-    void uninhabitedIntersection(Id id);
-    void intersectWithNegatedClass(Id id);
-    void intersectWithNegatedAtom(Id id);
-    void intersectWithNoRefine(Id id);
-    void cyclicIntersectionOfUnion(Id id);
-    void cyclicUnionOfIntersection(Id id);
-    void expandNegation(Id id);
-    void intersectionOfUnion(Id id);
-    void intersectTableProperty(Id id);
-    void uninhabitedTable(Id id);
-    void unneededTableModification(Id id);
-    void builtinTypeFunctions(Id id);
-    void iffyTypeFunctions(Id id);
-    void strictMetamethods(Id id);
-};
-
-template<typename Tag>
-struct QueryIterator
-{
-    QueryIterator();
-    QueryIterator(EGraph* egraph, Id eclass);
-
-    bool operator==(const QueryIterator& other) const;
-    bool operator!=(const QueryIterator& other) const;
-
-    std::pair<const Tag*, size_t> operator*() const;
-
-    QueryIterator& operator++();
-    QueryIterator& operator++(int);
-
-private:
-    EGraph* egraph = nullptr;
-    Id eclass;
-    size_t index = 0;
-};
-
-template<typename Tag>
-struct Query
-{
-    EGraph* egraph;
-    Id eclass;
-
-    Query(EGraph* egraph, Id eclass)
-        : egraph(egraph)
-        , eclass(eclass)
-    {
-    }
-
-    QueryIterator<Tag> begin()
-    {
-        return QueryIterator<Tag>{egraph, eclass};
-    }
-
-    QueryIterator<Tag> end()
-    {
-        return QueryIterator<Tag>{};
-    }
-};
-
-template<typename Tag>
-QueryIterator<Tag>::QueryIterator()
-    : egraph(nullptr)
-    , eclass(Id{0})
-    , index(0)
-{
-}
-
-template<typename Tag>
-QueryIterator<Tag>::QueryIterator(EGraph* egraph_, Id eclass)
-    : egraph(egraph_)
-    , eclass(eclass)
-    , index(0)
-{
-    const auto& ecl = (*egraph)[eclass];
-
-    static constexpr const int idx = EType::VariantTy::getTypeId<Tag>();
-
-    for (const auto& enode : ecl.nodes)
-    {
-        if (enode.node.index() < idx)
-            ++index;
-        else
-            break;
-    }
-
-    if (index >= ecl.nodes.size() || ecl.nodes[index].node.index() != idx)
-    {
-        egraph = nullptr;
-        index = 0;
-    }
-}
-
-template<typename Tag>
-bool QueryIterator<Tag>::operator==(const QueryIterator<Tag>& rhs) const
-{
-    if (egraph == nullptr && rhs.egraph == nullptr)
-        return true;
-
-    return egraph == rhs.egraph && eclass == rhs.eclass && index == rhs.index;
-}
-
-template<typename Tag>
-bool QueryIterator<Tag>::operator!=(const QueryIterator<Tag>& rhs) const
-{
-    return !(*this == rhs);
-}
-
-template<typename Tag>
-std::pair<const Tag*, size_t> QueryIterator<Tag>::operator*() const
-{
-    LUAU_ASSERT(egraph != nullptr);
-
-    EGraph::EClassT& ecl = (*egraph)[eclass];
-
-    LUAU_ASSERT(index < ecl.nodes.size());
-    auto& enode = ecl.nodes[index].node;
-    Tag* result = enode.template get<Tag>();
-    LUAU_ASSERT(result);
-    return {result, index};
-}
-
-// pre-increment
-template<typename Tag>
-QueryIterator<Tag>& QueryIterator<Tag>::operator++()
-{
-    const auto& ecl = (*egraph)[eclass];
-
-    do
-    {
-        ++index;
-        if (index >= ecl.nodes.size() || ecl.nodes[index].node.index() != EType::VariantTy::getTypeId<Tag>())
-        {
-            egraph = nullptr;
-            index = 0;
-            break;
-        }
-    } while (ecl.nodes[index].boring);
-
-    return *this;
-}
-
-// post-increment
-template<typename Tag>
-QueryIterator<Tag>& QueryIterator<Tag>::operator++(int)
-{
-    QueryIterator<Tag> res = *this;
-    ++res;
-    return res;
-}
-
-} // namespace Luau::EqSatSimplification

Analysis/include/Luau/Error.h

@@ -1,41 +1,24 @@
 // This file is part of the Luau programming language and is licensed under MIT License; see LICENSE.txt for details
 #pragma once
 
+#include "Luau/FileResolver.h"
 #include "Luau/Location.h"
-#include "Luau/NotNull.h"
-#include "Luau/Type.h"
+#include "Luau/TypeVar.h"
 #include "Luau/Variant.h"
-#include "Luau/Ast.h"
-
-#include <set>
 
 namespace Luau
 {
-
-struct FileResolver;
-struct TypeArena;
 struct TypeError;
 
 struct TypeMismatch
 {
-    enum Context
-    {
-        CovariantContext,
-        InvariantContext
-    };
-
     TypeMismatch() = default;
     TypeMismatch(TypeId wantedType, TypeId givenType);
     TypeMismatch(TypeId wantedType, TypeId givenType, std::string reason);
-    TypeMismatch(TypeId wantedType, TypeId givenType, std::string reason, std::optional<TypeError> error);
-
-    TypeMismatch(TypeId wantedType, TypeId givenType, Context context);
-    TypeMismatch(TypeId wantedType, TypeId givenType, std::string reason, Context context);
-    TypeMismatch(TypeId wantedType, TypeId givenType, std::string reason, std::optional<TypeError> error, Context context);
+    TypeMismatch(TypeId wantedType, TypeId givenType, std::string reason, TypeError error);
 
     TypeId wantedType = nullptr;
     TypeId givenType = nullptr;
-    Context context = CovariantContext;
 
     std::string reason;
     std::shared_ptr<TypeError> error;
@@ -49,6 +32,7 @@ struct UnknownSymbol
     {
         Binding,
         Type,
+        Generic
     };
     Name name;
     Context context;
@@ -96,7 +80,7 @@ struct OnlyTablesCanHaveMethods
 struct DuplicateTypeDefinition
 {
     Name name;
-    std::optional<Location> previousLocation;
+    Location previousLocation;
 
     bool operator==(const DuplicateTypeDefinition& rhs) const;
 };
@@ -106,16 +90,12 @@ struct CountMismatch
     enum Context
     {
         Arg,
-        FunctionResult,
-        ExprListResult,
+        Result,
         Return,
     };
     size_t expected;
-    std::optional<size_t> maximum;
     size_t actual;
     Context context = Arg;
-    bool isVariadic = false;
-    std::string function;
 
     bool operator==(const CountMismatch& rhs) const;
 };
@@ -127,6 +107,8 @@ struct FunctionDoesNotTakeSelf
 
 struct FunctionRequiresSelf
 {
+    int requiredExtraNils = 0;
+
     bool operator==(const FunctionRequiresSelf& rhs) const;
 };
 
@@ -187,18 +169,6 @@ struct GenericError
     bool operator==(const GenericError& rhs) const;
 };
 
-struct InternalError
-{
-    std::string message;
-
-    bool operator==(const InternalError& rhs) const;
-};
-
-struct ConstraintSolvingIncompleteError
-{
-    bool operator==(const ConstraintSolvingIncompleteError& rhs) const;
-};
-
 struct CannotCallNonFunction
 {
     TypeId ty;
@@ -315,218 +285,12 @@ struct TypesAreUnrelated
     bool operator==(const TypesAreUnrelated& rhs) const;
 };
 
-struct NormalizationTooComplex
-{
-    bool operator==(const NormalizationTooComplex&) const
-    {
-        return true;
-    }
-};
-
-struct TypePackMismatch
-{
-    TypePackId wantedTp;
-    TypePackId givenTp;
-    std::string reason;
-
-    bool operator==(const TypePackMismatch& rhs) const;
-};
-
-struct DynamicPropertyLookupOnExternTypesUnsafe
-{
-    TypeId ty;
-
-    bool operator==(const DynamicPropertyLookupOnExternTypesUnsafe& rhs) const;
-};
-
-struct UninhabitedTypeFunction
-{
-    TypeId ty;
-
-    bool operator==(const UninhabitedTypeFunction& rhs) const;
-};
-
-struct ExplicitFunctionAnnotationRecommended
-{
-    std::vector<std::pair<std::string, TypeId>> recommendedArgs;
-    TypeId recommendedReturn;
-    bool operator==(const ExplicitFunctionAnnotationRecommended& rhs) const;
-};
-
-struct UninhabitedTypePackFunction
-{
-    TypePackId tp;
-
-    bool operator==(const UninhabitedTypePackFunction& rhs) const;
-};
-
-struct WhereClauseNeeded
-{
-    TypeId ty;
-
-    bool operator==(const WhereClauseNeeded& rhs) const;
-};
-
-struct PackWhereClauseNeeded
-{
-    TypePackId tp;
-
-    bool operator==(const PackWhereClauseNeeded& rhs) const;
-};
-
-struct CheckedFunctionCallError
-{
-    TypeId expected;
-    TypeId passed;
-    std::string checkedFunctionName;
-    // TODO: make this a vector<argumentIndices>
-    size_t argumentIndex;
-    bool operator==(const CheckedFunctionCallError& rhs) const;
-};
-
-struct NonStrictFunctionDefinitionError
-{
-    std::string functionName;
-    std::string argument;
-    TypeId argumentType;
-    bool operator==(const NonStrictFunctionDefinitionError& rhs) const;
-};
-
-struct PropertyAccessViolation
-{
-    TypeId table;
-    Name key;
-
-    enum
-    {
-        CannotRead,
-        CannotWrite
-    } context;
-
-    bool operator==(const PropertyAccessViolation& rhs) const;
-};
-
-struct CheckedFunctionIncorrectArgs
-{
-    std::string functionName;
-    size_t expected;
-    size_t actual;
-    bool operator==(const CheckedFunctionIncorrectArgs& rhs) const;
-};
-
-struct CannotAssignToNever
-{
-    // type of the rvalue being assigned
-    TypeId rhsType;
-
-    // Originating type.
-    std::vector<TypeId> cause;
-
-    enum class Reason
-    {
-        // when assigning to a property in a union of tables, the properties type
-        // is narrowed to the intersection of its type in each variant.
-        PropertyNarrowed,
-    };
-
-    Reason reason;
-
-    bool operator==(const CannotAssignToNever& rhs) const;
-};
-
-struct UnexpectedTypeInSubtyping
-{
-    TypeId ty;
-
-    bool operator==(const UnexpectedTypeInSubtyping& rhs) const;
-};
-
-struct UnexpectedTypePackInSubtyping
-{
-    TypePackId tp;
-
-    bool operator==(const UnexpectedTypePackInSubtyping& rhs) const;
-};
-
-struct UserDefinedTypeFunctionError
-{
-    std::string message;
-
-    bool operator==(const UserDefinedTypeFunctionError& rhs) const;
-};
-
-struct ReservedIdentifier
-{
-    std::string name;
-
-    bool operator==(const ReservedIdentifier& rhs) const;
-};
-
-using TypeErrorData = Variant<
-    TypeMismatch,
-    UnknownSymbol,
-    UnknownProperty,
-    NotATable,
-    CannotExtendTable,
-    OnlyTablesCanHaveMethods,
-    DuplicateTypeDefinition,
-    CountMismatch,
-    FunctionDoesNotTakeSelf,
-    FunctionRequiresSelf,
-    OccursCheckFailed,
-    UnknownRequire,
-    IncorrectGenericParameterCount,
-    SyntaxError,
-    CodeTooComplex,
-    UnificationTooComplex,
-    UnknownPropButFoundLikeProp,
-    GenericError,
-    InternalError,
-    ConstraintSolvingIncompleteError,
-    CannotCallNonFunction,
-    ExtraInformation,
-    DeprecatedApiUsed,
-    ModuleHasCyclicDependency,
-    IllegalRequire,
-    FunctionExitsWithoutReturning,
-    DuplicateGenericParameter,
-    CannotAssignToNever,
-    CannotInferBinaryOperation,
-    MissingProperties,
-    SwappedGenericTypeParameter,
-    OptionalValueAccess,
-    MissingUnionProperty,
-    TypesAreUnrelated,
-    NormalizationTooComplex,
-    TypePackMismatch,
-    DynamicPropertyLookupOnExternTypesUnsafe,
-    UninhabitedTypeFunction,
-    UninhabitedTypePackFunction,
-    WhereClauseNeeded,
-    PackWhereClauseNeeded,
-    CheckedFunctionCallError,
-    NonStrictFunctionDefinitionError,
-    PropertyAccessViolation,
-    CheckedFunctionIncorrectArgs,
-    UnexpectedTypeInSubtyping,
-    UnexpectedTypePackInSubtyping,
-    ExplicitFunctionAnnotationRecommended,
-    UserDefinedTypeFunctionError,
-    ReservedIdentifier>;
-
-struct TypeErrorSummary
-{
-    Location location;
-    ModuleName moduleName;
-    int code;
-
-    TypeErrorSummary(const Location& location, const ModuleName& moduleName, int code)
-        : location(location)
-        , moduleName(moduleName)
-        , code(code)
-    {
-    }
-};
+using TypeErrorData = Variant<TypeMismatch, UnknownSymbol, UnknownProperty, NotATable, CannotExtendTable, OnlyTablesCanHaveMethods,
+    DuplicateTypeDefinition, CountMismatch, FunctionDoesNotTakeSelf, FunctionRequiresSelf, OccursCheckFailed, UnknownRequire,
+    IncorrectGenericParameterCount, SyntaxError, CodeTooComplex, UnificationTooComplex, UnknownPropButFoundLikeProp, GenericError,
+    CannotCallNonFunction, ExtraInformation, DeprecatedApiUsed, ModuleHasCyclicDependency, IllegalRequire, FunctionExitsWithoutReturning,
+    DuplicateGenericParameter, CannotInferBinaryOperation, MissingProperties, SwappedGenericTypeParameter, OptionalValueAccess, MissingUnionProperty,
+    TypesAreUnrelated>;
 
 struct TypeError
 {
@@ -534,7 +298,6 @@ struct TypeError
     ModuleName moduleName;
     TypeErrorData data;
 
-    static int minCode();
     int code() const;
 
     TypeError() = default;
@@ -552,8 +315,6 @@ struct TypeError
     }
 
     bool operator==(const TypeError& rhs) const;
-
-    TypeErrorSummary summary() const;
 };
 
 template<typename T>
@@ -570,18 +331,12 @@ T* get(TypeError& e)
 
 using ErrorVec = std::vector<TypeError>;
 
-struct TypeErrorToStringOptions
-{
-    FileResolver* fileResolver = nullptr;
-};
-
 std::string toString(const TypeError& error);
-std::string toString(const TypeError& error, TypeErrorToStringOptions options);
 
 bool containsParseErrorName(const TypeError& error);
 
 // Copy any types named in the error into destArena.
-void copyErrors(ErrorVec& errors, struct TypeArena& destArena, NotNull<BuiltinTypes> builtinTypes);
+void copyErrors(ErrorVec& errors, struct TypeArena& destArena);
 
 // Internal Compiler Error
 struct InternalErrorReporter
@@ -589,33 +344,8 @@ struct InternalErrorReporter
     std::function<void(const char*)> onInternalError;
     std::string moduleName;
 
-    [[noreturn]] void ice(const std::string& message, const Location& location) const;
-    [[noreturn]] void ice(const std::string& message) const;
-};
-
-class InternalCompilerError : public std::exception
-{
-public:
-    explicit InternalCompilerError(const std::string& message)
-        : message(message)
-    {
-    }
-    explicit InternalCompilerError(const std::string& message, const std::string& moduleName)
-        : message(message)
-        , moduleName(moduleName)
-    {
-    }
-    explicit InternalCompilerError(const std::string& message, const std::string& moduleName, const Location& location)
-        : message(message)
-        , moduleName(moduleName)
-        , location(location)
-    {
-    }
-    virtual const char* what() const throw();
-
-    const std::string message;
-    const std::optional<std::string> moduleName;
-    const std::optional<Location> location;
+    [[noreturn]] void ice(const std::string& message, const Location& location);
+    [[noreturn]] void ice(const std::string& message);
 };
 
 } // namespace Luau

Analysis/include/Luau/FileResolver.h

@@ -1,10 +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 <vector>
+#include <optional>
 
 namespace Luau
 {
@@ -20,7 +18,7 @@ struct SourceCode
         None,
         Module,
         Script,
-        Local_DEPRECATED
+        Local
     };
 
     std::string source;
@@ -33,71 +31,8 @@ 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;
@@ -116,10 +51,6 @@ struct FileResolver
     {
         return std::nullopt;
     }
-
-    std::optional<RequireSuggestions> getRequireSuggestions(const ModuleName& requirer, const std::optional<std::string>& pathString) const;
-
-    std::shared_ptr<RequireSuggester> requireSuggester;
 };
 
 struct NullFileResolver : FileResolver

Analysis/include/Luau/FragmentAutocomplete.h

@@ -1,196 +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/Ast.h"
-#include "Luau/Parser.h"
-#include "Luau/AutocompleteTypes.h"
-#include "Luau/DenseHash.h"
-#include "Luau/Module.h"
-#include "Luau/Frontend.h"
-
-#include <memory>
-#include <vector>
-
-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,
-    Success,
-};
-
-struct FragmentAutocompleteAncestryResult
-{
-    DenseHashMap<AstName, AstLocal*> localMap{AstName()};
-    std::vector<AstLocal*> localStack;
-    std::vector<AstNode*> ancestry;
-    AstStat* nearestStatement = nullptr;
-    AstStatBlock* parentBlock = nullptr;
-    Location fragmentSelectionRegion;
-};
-
-struct FragmentParseResult
-{
-    std::string fragmentToParse;
-    AstStatBlock* root = nullptr;
-    std::vector<AstNode*> ancestry;
-    AstStat* nearestStatement = nullptr;
-    std::vector<Comment> commentLocations;
-    std::unique_ptr<Allocator> alloc = std::make_unique<Allocator>();
-    Position scopePos{0, 0};
-};
-
-struct FragmentTypeCheckResult
-{
-    ModulePtr incrementalModule = nullptr;
-    ScopePtr freshScope;
-    std::vector<AstNode*> ancestry;
-};
-
-struct FragmentAutocompleteResult
-{
-    ModulePtr incrementalModule;
-    Scope* freshScope;
-    TypeArena arenaForAutocomplete_DEPRECATED;
-    AutocompleteResult acResults;
-};
-
-struct FragmentRegion
-{
-    Location fragmentLocation;
-    AstStat* nearestStatement = nullptr; // used for tests
-    AstStatBlock* parentBlock = nullptr; // used for scope detection
-};
-
-std::optional<Position> blockDiffStart(AstStatBlock* blockOld, AstStatBlock* blockNew, AstStat* nearestStatementNewAst);
-FragmentRegion getFragmentRegion(AstStatBlock* root, const Position& cursorPosition);
-FragmentAutocompleteAncestryResult findAncestryForFragmentParse(AstStatBlock* stale, const Position& cursorPos, AstStatBlock* lastGoodParse);
-FragmentAutocompleteAncestryResult findAncestryForFragmentParse_DEPRECATED(AstStatBlock* root, const Position& cursorPos);
-
-std::optional<FragmentParseResult> parseFragment_DEPRECATED(
-    AstStatBlock* root,
-    AstNameTable* names,
-    std::string_view src,
-    const Position& cursorPos,
-    std::optional<Position> fragmentEndPosition
-);
-
-std::optional<FragmentParseResult> parseFragment(
-    AstStatBlock* stale,
-    AstStatBlock* mostRecentParse,
-    AstNameTable* names,
-    std::string_view src,
-    const Position& cursorPos,
-    std::optional<Position> fragmentEndPosition
-);
-
-std::pair<FragmentTypeCheckStatus, FragmentTypeCheckResult> typecheckFragment(
-    Frontend& frontend,
-    const ModuleName& moduleName,
-    const Position& cursorPos,
-    std::optional<FrontendOptions> opts,
-    std::string_view src,
-    std::optional<Position> fragmentEndPosition,
-    AstStatBlock* recentParse = nullptr,
-    IFragmentAutocompleteReporter* reporter = nullptr
-);
-
-FragmentAutocompleteResult fragmentAutocomplete(
-    Frontend& frontend,
-    std::string_view src,
-    const ModuleName& moduleName,
-    Position cursorPosition,
-    std::optional<FrontendOptions> opts,
-    StringCompletionCallback callback,
-    std::optional<Position> fragmentEndPosition = std::nullopt,
-    AstStatBlock* recentParse = nullptr,
-    IFragmentAutocompleteReporter* reporter = nullptr
-);
-
-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

@@ -2,16 +2,12 @@
 #pragma once
 
 #include "Luau/Config.h"
-#include "Luau/GlobalTypes.h"
 #include "Luau/Module.h"
 #include "Luau/ModuleResolver.h"
 #include "Luau/RequireTracer.h"
-#include "Luau/Scope.h"
-#include "Luau/Set.h"
-#include "Luau/TypeCheckLimits.h"
+#include "Luau/TypeInfer.h"
 #include "Luau/Variant.h"
 
-#include <mutex>
 #include <string>
 #include <vector>
 #include <optional>
@@ -24,65 +20,44 @@ class ParseError;
 struct Frontend;
 struct TypeError;
 struct LintWarning;
-struct GlobalTypes;
 struct TypeChecker;
 struct FileResolver;
 struct ModuleResolver;
 struct ParseResult;
-struct HotComment;
-struct BuildQueueItem;
-struct BuildQueueWorkState;
-struct FrontendCancellationToken;
 
 struct LoadDefinitionFileResult
 {
     bool success;
     ParseResult parseResult;
-    SourceModule sourceModule;
     ModulePtr module;
 };
 
-std::optional<Mode> parseMode(const std::vector<HotComment>& hotcomments);
+LoadDefinitionFileResult loadDefinitionFile(
+    TypeChecker& typeChecker, ScopePtr targetScope, std::string_view definition, const std::string& packageName);
+
+std::optional<Mode> parseMode(const std::vector<std::string>& hotcomments);
+
+std::vector<std::string_view> parsePathExpr(const AstExpr& pathExpr);
+
+// Exported only for convenient testing.
+std::optional<ModuleName> pathExprToModuleName(const ModuleName& currentModuleName, const std::vector<std::string_view>& expr);
+
+/** Try to convert an AST fragment into a ModuleName.
+ * Returns std::nullopt if the expression cannot be resolved.  This will most likely happen in cases where
+ * the import path involves some dynamic computation that we cannot see into at typechecking time.
+ *
+ * Unintuitively, weirdly-formulated modules (like game.Parent.Parent.Parent.Foo) will successfully produce a ModuleName
+ * as long as it falls within the permitted syntax.  This is ok because we will fail to find the module and produce an
+ * error when we try during typechecking.
+ */
+std::optional<ModuleName> pathExprToModuleName(const ModuleName& currentModuleName, const AstExpr& expr);
 
 struct SourceNode
 {
-    bool hasDirtySourceModule() const
-    {
-        return dirtySourceModule;
-    }
-
-    bool hasDirtyModule(bool forAutocomplete) const
-    {
-        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::unordered_set<ModuleName> requires;
     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;
+    bool dirty = true;
 };
 
 struct FrontendOptions
@@ -93,38 +68,14 @@ struct FrontendOptions
     // is complete.
     bool retainFullTypeGraphs = false;
 
-    // Run typechecking only in mode required for autocomplete (strict mode in
-    // order to get more precise type information)
-    bool forAutocomplete = false;
-
-    bool runLintChecks = false;
-
-    // If not empty, randomly shuffle the constraint set before attempting to
-    // solve.  Use this value to seed the random number generator.
-    std::optional<unsigned> randomizeConstraintResolutionSeed;
-
-    std::optional<LintOptions> enabledLintWarnings;
-
-    std::shared_ptr<FrontendCancellationToken> cancellationToken;
-
-    // Time limit for typechecking a single module
-    std::optional<double> moduleTimeLimitSec;
-
-    // When true, some internal complexity limits will be scaled down for modules that miss the limit set by moduleTimeLimitSec
-    bool applyInternalLimitScaling = false;
-
-    // An optional callback which is called for every *dirty* module was checked
-    // Is multi-threaded typechecking is used, this callback might be called from multiple threads and has to be thread-safe
-    std::function<void(const SourceModule& sourceModule, const Luau::Module& module)> customModuleCheck;
+    // When true, we run typechecking twice, one in the regular mode, ond once in strict mode
+    // in order to get more precise type information (e.g. for autocomplete).
+    bool typecheckTwice = false;
 };
 
 struct CheckResult
 {
     std::vector<TypeError> errors;
-
-    LintResult lintResult;
-
-    std::vector<ModuleName> timeoutHits;
 };
 
 struct FrontendModuleResolver : ModuleResolver
@@ -136,13 +87,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 clearModules();
-
-private:
     Frontend* frontend;
-
-    mutable std::mutex moduleMutex;
     std::unordered_map<ModuleName, ModulePtr> modules;
 };
 
@@ -164,19 +109,22 @@ struct Frontend
 
     Frontend(FileResolver* fileResolver, ConfigResolver* configResolver, const FrontendOptions& options = {});
 
-    // Parse module graph and prepare SourceNode/SourceModule data, including required dependencies without running typechecking
-    void parse(const ModuleName& name);
+    CheckResult check(const ModuleName& name); // new shininess
+    LintResult lint(const ModuleName& name, std::optional<Luau::LintOptions> enabledLintWarnings = {});
 
-    // Parse and typecheck module graph
-    CheckResult check(const ModuleName& name, std::optional<FrontendOptions> optionOverride = {}); // new shininess
+    /** Lint some code that has no associated DataModel object
+     *
+     * Since this source fragment has no name, we cannot cache its AST.  Instead,
+     * we return it to the caller to use as they wish.
+     */
+    std::pair<SourceModule, LintResult> lintFragment(std::string_view source, std::optional<Luau::LintOptions> enabledLintWarnings = {});
 
-    bool allModuleDependenciesValid(const ModuleName& name, bool forAutocomplete = false) const;
+    CheckResult check(const SourceModule& module); // OLD.  TODO KILL
+    LintResult lint(const SourceModule& module, std::optional<Luau::LintOptions> enabledLintWarnings = {});
 
-    bool isDirty(const ModuleName& name, bool forAutocomplete = false) const;
+    bool isDirty(const ModuleName& name) 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
@@ -192,133 +140,40 @@ struct Frontend
     void clear();
 
     ScopePtr addEnvironment(const std::string& environmentName);
-    ScopePtr getEnvironmentScope(const std::string& environmentName) const;
+    ScopePtr getEnvironmentScope(const std::string& environmentName);
 
-    void registerBuiltinDefinition(const std::string& name, std::function<void(Frontend&, GlobalTypes&, ScopePtr)>);
+    void registerBuiltinDefinition(const std::string& name, std::function<void(TypeChecker&, ScopePtr)>);
     void applyBuiltinDefinitionToEnvironment(const std::string& environmentName, const std::string& definitionName);
 
-    LoadDefinitionFileResult loadDefinitionFile(
-        GlobalTypes& globals,
-        ScopePtr targetScope,
-        std::string_view source,
-        const std::string& packageName,
-        bool captureComments,
-        bool typeCheckForAutocomplete = false
-    );
-
-    // Batch module checking. Queue modules and check them together, retrieve results with 'getCheckResult'
-    // If provided, 'executeTask' function is allowed to call the 'task' function on any thread and return without waiting for 'task' to complete
-    void queueModuleCheck(const std::vector<ModuleName>& names);
-    void queueModuleCheck(const ModuleName& name);
-    std::vector<ModuleName> checkQueuedModules(
-        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);
-
 private:
-    ModulePtr check(
-        const SourceModule& sourceModule,
-        Mode mode,
-        std::vector<RequireCycle> requireCycles,
-        std::optional<ScopePtr> environmentScope,
-        bool forAutocomplete,
-        bool recordJsonLog,
-        TypeCheckLimits typeCheckLimits
-    );
-
-    std::pair<SourceNode*, SourceModule*> getSourceNode(const ModuleName& name);
+    std::pair<SourceNode*, SourceModule*> getSourceNode(CheckResult& checkResult, const ModuleName& name);
     SourceModule parse(const ModuleName& name, std::string_view src, const ParseOptions& parseOptions);
 
-    bool parseGraph(
-        std::vector<ModuleName>& buildQueue,
-        const ModuleName& root,
-        bool forAutocomplete,
-        std::function<bool(const ModuleName&)> canSkip = {}
-    );
-
-    void addBuildQueueItems(
-        std::vector<BuildQueueItem>& items,
-        std::vector<ModuleName>& buildQueue,
-        bool cycleDetected,
-        DenseHashSet<Luau::ModuleName>& seen,
-        const FrontendOptions& frontendOptions
-    );
-    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);
+    bool parseGraph(std::vector<ModuleName>& buildQueue, CheckResult& checkResult, const ModuleName& root);
 
     static LintResult classifyLints(const std::vector<LintWarning>& warnings, const Config& config);
 
-    ScopePtr getModuleEnvironment(const SourceModule& module, const Config& config, bool forAutocomplete) const;
+    ScopePtr getModuleEnvironment(const SourceModule& module, const Config& config);
 
     std::unordered_map<std::string, ScopePtr> environments;
-    std::unordered_map<std::string, std::function<void(Frontend&, GlobalTypes&, ScopePtr)>> builtinDefinitions;
-
-    BuiltinTypes builtinTypes_;
+    std::unordered_map<std::string, std::function<void(TypeChecker&, ScopePtr)>> builtinDefinitions;
 
 public:
-    const NotNull<BuiltinTypes> builtinTypes;
-
     FileResolver* fileResolver;
-
     FrontendModuleResolver moduleResolver;
     FrontendModuleResolver moduleResolverForAutocomplete;
-
-    GlobalTypes globals;
-    GlobalTypes globalsForAutocomplete;
-
+    TypeChecker typeChecker;
+    TypeChecker typeCheckerForAutocomplete;
     ConfigResolver* configResolver;
     FrontendOptions options;
     InternalErrorReporter iceHandler;
-    std::function<void(const ModuleName& name, const ScopePtr& scope, bool forAutocomplete)> prepareModuleScope;
-    std::function<void(const ModuleName& name, std::string log)> writeJsonLog = {};
+    TypeArena arenaForAutocomplete;
 
-    std::unordered_map<ModuleName, std::shared_ptr<SourceNode>> sourceNodes;
-    std::unordered_map<ModuleName, std::shared_ptr<SourceModule>> sourceModules;
-    std::unordered_map<ModuleName, RequireTraceResult> requireTrace;
+    std::unordered_map<ModuleName, SourceNode> sourceNodes;
+    std::unordered_map<ModuleName, SourceModule> sourceModules;
+    std::unordered_map<ModuleName, RequireTraceResult> requires;
 
     Stats stats = {};
-
-    std::vector<ModuleName> moduleQueue;
 };
 
-ModulePtr check(
-    const SourceModule& sourceModule,
-    Mode mode,
-    const std::vector<RequireCycle>& requireCycles,
-    NotNull<BuiltinTypes> builtinTypes,
-    NotNull<InternalErrorReporter> iceHandler,
-    NotNull<ModuleResolver> moduleResolver,
-    NotNull<FileResolver> fileResolver,
-    const ScopePtr& globalScope,
-    const ScopePtr& typeFunctionScope,
-    std::function<void(const ModuleName&, const ScopePtr&)> prepareModuleScope,
-    FrontendOptions options,
-    TypeCheckLimits limits
-);
-
-ModulePtr check(
-    const SourceModule& sourceModule,
-    Mode mode,
-    const std::vector<RequireCycle>& requireCycles,
-    NotNull<BuiltinTypes> builtinTypes,
-    NotNull<InternalErrorReporter> iceHandler,
-    NotNull<ModuleResolver> moduleResolver,
-    NotNull<FileResolver> fileResolver,
-    const ScopePtr& globalScope,
-    const ScopePtr& typeFunctionScope,
-    std::function<void(const ModuleName&, const ScopePtr&)> prepareModuleScope,
-    FrontendOptions options,
-    TypeCheckLimits limits,
-    bool recordJsonLog,
-    std::function<void(const ModuleName&, std::string)> writeJsonLog
-);
-
 } // namespace Luau

Analysis/include/Luau/Generalization.h

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

Analysis/include/Luau/GlobalTypes.h

@@ -1,27 +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/Module.h"
-#include "Luau/NotNull.h"
-#include "Luau/Scope.h"
-#include "Luau/TypeArena.h"
-#include "Luau/TypeFwd.h"
-
-namespace Luau
-{
-
-struct GlobalTypes
-{
-    explicit GlobalTypes(NotNull<BuiltinTypes> builtinTypes);
-
-    NotNull<BuiltinTypes> builtinTypes; // Global types are based on builtin types
-
-    TypeArena globalTypes;
-    SourceModule globalNames; // names for symbols entered into globalScope
-
-    ScopePtr globalScope;     // shared by all modules
-    ScopePtr globalTypeFunctionScope; // shared by all modules
-};
-
-} // namespace Luau

Analysis/include/Luau/InferPolarity.h

@@ -1,16 +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/NotNull.h"
-#include "Luau/TypeFwd.h"
-
-namespace Luau
-{
-
-struct Scope;
-struct TypeArena;
-
-void inferGenericPolarities(NotNull<TypeArena> arena, NotNull<Scope> scope, TypeId ty);
-void inferGenericPolarities(NotNull<TypeArena> arena, NotNull<Scope> scope, TypePackId tp);
-
-} // namespace Luau

Analysis/include/Luau/InsertionOrderedMap.h

@@ -1,147 +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/Common.h"
-
-#include <unordered_map>
-#include <vector>
-#include <type_traits>
-#include <iterator>
-
-namespace Luau
-{
-
-template<typename K, typename V>
-struct InsertionOrderedMap
-{
-    static_assert(std::is_trivially_copyable_v<K>, "key must be trivially copyable");
-
-private:
-    using vec = std::vector<std::pair<K, V>>;
-
-public:
-    using iterator = typename vec::iterator;
-    using const_iterator = typename vec::const_iterator;
-
-    void insert(K k, V v)
-    {
-        if (indices.count(k) != 0)
-            return;
-
-        pairs.push_back(std::make_pair(k, std::move(v)));
-        indices[k] = pairs.size() - 1;
-    }
-
-    void clear()
-    {
-        pairs.clear();
-        indices.clear();
-    }
-
-    size_t size() const
-    {
-        LUAU_ASSERT(pairs.size() == indices.size());
-        return pairs.size();
-    }
-
-    bool contains(const K& k) const
-    {
-        return indices.count(k) > 0;
-    }
-
-    const V* get(const K& k) const
-    {
-        auto it = indices.find(k);
-        if (it == indices.end())
-            return nullptr;
-        else
-            return &pairs.at(it->second).second;
-    }
-
-    V* get(const K& k)
-    {
-        auto it = indices.find(k);
-        if (it == indices.end())
-            return nullptr;
-        else
-            return &pairs.at(it->second).second;
-    }
-
-    V& operator[](const K& k)
-    {
-        auto it = indices.find(k);
-        if (it == indices.end())
-        {
-            pairs.push_back(std::make_pair(k, V()));
-            indices[k] = pairs.size() - 1;
-            return pairs.back().second;
-        }
-        else
-            return pairs.at(it->second).second;
-    }
-
-    const_iterator begin() const
-    {
-        return pairs.begin();
-    }
-
-    const_iterator end() const
-    {
-        return pairs.end();
-    }
-
-    iterator begin()
-    {
-        return pairs.begin();
-    }
-
-    iterator end()
-    {
-        return pairs.end();
-    }
-
-    const_iterator find(K k) const
-    {
-        auto indicesIt = indices.find(k);
-        if (indicesIt == indices.end())
-            return end();
-        else
-            return begin() + indicesIt->second;
-    }
-
-    iterator find(K k)
-    {
-        auto indicesIt = indices.find(k);
-        if (indicesIt == indices.end())
-            return end();
-        else
-            return begin() + indicesIt->second;
-    }
-
-    void erase(iterator it)
-    {
-        if (it == pairs.end())
-            return;
-
-        K k = it->first;
-        auto indexIt = indices.find(k);
-        if (indexIt == indices.end())
-            return;
-
-        size_t removed = indexIt->second;
-        indices.erase(indexIt);
-        pairs.erase(it);
-
-        for (auto& [_, index] : indices)
-        {
-            if (index > removed)
-                --index;
-        }
-    }
-
-private:
-    vec pairs;
-    std::unordered_map<K, size_t> indices;
-};
-
-} // namespace Luau

Analysis/include/Luau/Instantiation.h

@@ -1,165 +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/NotNull.h"
-#include "Luau/Substitution.h"
-#include "Luau/TypeFwd.h"
-#include "Luau/Unifiable.h"
-#include "Luau/VisitType.h"
-
-namespace Luau
-{
-
-struct TxnLog;
-struct TypeArena;
-struct TypeCheckLimits;
-
-// A substitution which replaces generic types in a given set by free types.
-struct ReplaceGenerics : Substitution
-{
-    ReplaceGenerics(
-        const TxnLog* log,
-        TypeArena* arena,
-        NotNull<BuiltinTypes> builtinTypes,
-        TypeLevel level,
-        Scope* scope,
-        const std::vector<TypeId>& generics,
-        const std::vector<TypePackId>& genericPacks
-    )
-        : Substitution(log, arena)
-        , builtinTypes(builtinTypes)
-        , level(level)
-        , scope(scope)
-        , generics(generics)
-        , genericPacks(genericPacks)
-    {
-    }
-
-    void resetState(
-        const TxnLog* log,
-        TypeArena* arena,
-        NotNull<BuiltinTypes> builtinTypes,
-        TypeLevel level,
-        Scope* scope,
-        const std::vector<TypeId>& generics,
-        const std::vector<TypePackId>& genericPacks
-    );
-
-    NotNull<BuiltinTypes> builtinTypes;
-
-    TypeLevel level;
-    Scope* scope;
-    std::vector<TypeId> generics;
-    std::vector<TypePackId> genericPacks;
-
-    bool ignoreChildren(TypeId ty) override;
-    bool isDirty(TypeId ty) override;
-    bool isDirty(TypePackId tp) override;
-    TypeId clean(TypeId ty) override;
-    TypePackId clean(TypePackId tp) override;
-};
-
-// A substitution which replaces generic functions by monomorphic functions
-struct Instantiation final : Substitution
-{
-    Instantiation(const TxnLog* log, TypeArena* arena, NotNull<BuiltinTypes> builtinTypes, TypeLevel level, Scope* scope)
-        : Substitution(log, arena)
-        , builtinTypes(builtinTypes)
-        , level(level)
-        , scope(scope)
-        , reusableReplaceGenerics(log, arena, builtinTypes, level, scope, {}, {})
-    {
-    }
-
-    void resetState(const TxnLog* log, TypeArena* arena, NotNull<BuiltinTypes> builtinTypes, TypeLevel level, Scope* scope);
-
-    NotNull<BuiltinTypes> builtinTypes;
-
-    TypeLevel level;
-    Scope* scope;
-
-    ReplaceGenerics reusableReplaceGenerics;
-
-    bool ignoreChildren(TypeId ty) override;
-    bool isDirty(TypeId ty) override;
-    bool isDirty(TypePackId tp) override;
-    TypeId clean(TypeId ty) override;
-    TypePackId clean(TypePackId tp) override;
-};
-
-// Used to find if a FunctionType requires generic type cleanup during instantiation
-struct GenericTypeFinder : TypeOnceVisitor
-{
-    bool found = false;
-
-    bool visit(TypeId ty) override
-    {
-        return !found;
-    }
-
-    bool visit(TypePackId ty) override
-    {
-        return !found;
-    }
-
-    bool visit(TypeId ty, const Luau::FunctionType& ftv) override
-    {
-        if (ftv.hasNoFreeOrGenericTypes)
-            return false;
-
-        if (!ftv.generics.empty() || !ftv.genericPacks.empty())
-            found = true;
-
-        return !found;
-    }
-
-    bool visit(TypeId ty, const Luau::TableType& ttv) override
-    {
-        if (ttv.state == Luau::TableState::Generic)
-            found = true;
-
-        return !found;
-    }
-
-    bool visit(TypeId ty, const Luau::GenericType&) override
-    {
-        found = true;
-        return false;
-    }
-
-    bool visit(TypePackId ty, const Luau::GenericTypePack&) override
-    {
-        found = true;
-        return false;
-    }
-
-    bool visit(TypeId ty, const Luau::ExternType&) override
-    {
-        // During function instantiation, extern types are not traversed even if they have generics
-        return false;
-    }
-};
-
-/** Attempt to instantiate a type.  Only used under local type inference.
- *
- * When given a generic function type, instantiate() will return a copy with the
- * generics replaced by fresh types.  Instantiation will return the same TypeId
- * back if the function does not have any generics.
- *
- * All higher order generics are left as-is.  For example, instantiation of
- * <X>(<Y>(Y) -> (X, Y)) -> (X, Y) is (<Y>(Y) -> ('x, Y)) -> ('x, Y)
- *
- * We substitute the generic X for the free 'x, but leave the generic Y alone.
- *
- * Instantiation fails only when processing the type causes internal recursion
- * limits to be exceeded.
- */
-std::optional<TypeId> instantiate(
-    NotNull<BuiltinTypes> builtinTypes,
-    NotNull<TypeArena> arena,
-    NotNull<TypeCheckLimits> limits,
-    NotNull<Scope> scope,
-    TypeId ty
-);
-
-} // namespace Luau

Analysis/include/Luau/Instantiation2.h

@@ -1,90 +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/NotNull.h"
-#include "Luau/Substitution.h"
-#include "Luau/TxnLog.h"
-#include "Luau/TypeFwd.h"
-#include "Luau/Unifiable.h"
-
-namespace Luau
-{
-
-struct TypeArena;
-struct TypeCheckLimits;
-
-struct Replacer : Substitution
-{
-    DenseHashMap<TypeId, TypeId> replacements;
-    DenseHashMap<TypePackId, TypePackId> replacementPacks;
-
-    Replacer(NotNull<TypeArena> arena, DenseHashMap<TypeId, TypeId> replacements, DenseHashMap<TypePackId, TypePackId> replacementPacks)
-        : Substitution(TxnLog::empty(), arena)
-        , replacements(std::move(replacements))
-        , replacementPacks(std::move(replacementPacks))
-    {
-    }
-
-    bool isDirty(TypeId ty) override
-    {
-        return replacements.find(ty) != nullptr;
-    }
-
-    bool isDirty(TypePackId tp) override
-    {
-        return replacementPacks.find(tp) != nullptr;
-    }
-
-    TypeId clean(TypeId ty) override
-    {
-        TypeId res = replacements[ty];
-        LUAU_ASSERT(res);
-        dontTraverseInto(res);
-        return res;
-    }
-
-    TypePackId clean(TypePackId tp) override
-    {
-        TypePackId res = replacementPacks[tp];
-        LUAU_ASSERT(res);
-        dontTraverseInto(res);
-        return res;
-    }
-};
-
-// A substitution which replaces generic functions by monomorphic functions
-struct Instantiation2 final : Substitution
-{
-    // Mapping from generic types to free types to be used in instantiation.
-    DenseHashMap<TypeId, TypeId> genericSubstitutions{nullptr};
-    // Mapping from generic type packs to `TypePack`s of free types to be used in instantiation.
-    DenseHashMap<TypePackId, TypePackId> genericPackSubstitutions{nullptr};
-
-    Instantiation2(TypeArena* arena, DenseHashMap<TypeId, TypeId> genericSubstitutions, DenseHashMap<TypePackId, TypePackId> genericPackSubstitutions)
-        : Substitution(TxnLog::empty(), arena)
-        , genericSubstitutions(std::move(genericSubstitutions))
-        , genericPackSubstitutions(std::move(genericPackSubstitutions))
-    {
-    }
-
-    bool ignoreChildren(TypeId ty) override;
-    bool isDirty(TypeId ty) override;
-    bool isDirty(TypePackId tp) override;
-    TypeId clean(TypeId ty) override;
-    TypePackId clean(TypePackId tp) override;
-};
-
-std::optional<TypeId> instantiate2(
-    TypeArena* arena,
-    DenseHashMap<TypeId, TypeId> genericSubstitutions,
-    DenseHashMap<TypePackId, TypePackId> genericPackSubstitutions,
-    TypeId ty
-);
-std::optional<TypePackId> instantiate2(
-    TypeArena* arena,
-    DenseHashMap<TypeId, TypeId> genericSubstitutions,
-    DenseHashMap<TypePackId, TypePackId> genericPackSubstitutions,
-    TypePackId tp
-);
-
-} // namespace Luau

Analysis/include/Luau/IostreamHelpers.h

@@ -3,9 +3,8 @@
 
 #include "Luau/Error.h"
 #include "Luau/Location.h"
-#include "Luau/Type.h"
+#include "Luau/TypeVar.h"
 #include "Luau/Ast.h"
-#include "Luau/TypePath.h"
 
 #include <ostream>
 
@@ -31,7 +30,6 @@ std::ostream& operator<<(std::ostream& lhs, const OccursCheckFailed& error);
 std::ostream& operator<<(std::ostream& lhs, const UnknownRequire& error);
 std::ostream& operator<<(std::ostream& lhs, const UnknownPropButFoundLikeProp& e);
 std::ostream& operator<<(std::ostream& lhs, const GenericError& error);
-std::ostream& operator<<(std::ostream& lhs, const InternalError& error);
 std::ostream& operator<<(std::ostream& lhs, const FunctionExitsWithoutReturning& error);
 std::ostream& operator<<(std::ostream& lhs, const MissingProperties& error);
 std::ostream& operator<<(std::ostream& lhs, const IllegalRequire& error);
@@ -44,19 +42,9 @@ std::ostream& operator<<(std::ostream& lhs, const MissingUnionProperty& error);
 std::ostream& operator<<(std::ostream& lhs, const TypesAreUnrelated& error);
 
 std::ostream& operator<<(std::ostream& lhs, const TableState& tv);
-std::ostream& operator<<(std::ostream& lhs, const Type& tv);
+std::ostream& operator<<(std::ostream& lhs, const TypeVar& tv);
 std::ostream& operator<<(std::ostream& lhs, const TypePackVar& tv);
 
 std::ostream& operator<<(std::ostream& lhs, const TypeErrorData& ted);
 
-std::ostream& operator<<(std::ostream& lhs, TypeId ty);
-std::ostream& operator<<(std::ostream& lhs, TypePackId tp);
-
-namespace TypePath
-{
-
-std::ostream& operator<<(std::ostream& lhs, const Path& path);
-
-}; // namespace TypePath
-
 } // namespace Luau

Analysis/include/Luau/JsonEmitter.h

@@ -1,247 +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 <type_traits>
-#include <string>
-#include <optional>
-#include <unordered_map>
-#include <vector>
-
-#include "Luau/NotNull.h"
-
-namespace Luau::Json
-{
-
-struct JsonEmitter;
-
-/// Writes a value to the JsonEmitter. Note that this can produce invalid JSON
-/// if you do not insert commas or appropriate object / array syntax.
-template<typename T>
-void write(JsonEmitter&, T) = delete;
-
-/// Writes a boolean to a JsonEmitter.
-/// @param emitter the emitter to write to.
-/// @param b the boolean to write.
-void write(JsonEmitter& emitter, bool b);
-
-/// Writes an integer to a JsonEmitter.
-/// @param emitter the emitter to write to.
-/// @param i the integer to write.
-void write(JsonEmitter& emitter, int i);
-
-/// Writes an integer to a JsonEmitter.
-/// @param emitter the emitter to write to.
-/// @param i the integer to write.
-void write(JsonEmitter& emitter, long i);
-
-/// Writes an integer to a JsonEmitter.
-/// @param emitter the emitter to write to.
-/// @param i the integer to write.
-void write(JsonEmitter& emitter, long long i);
-
-/// Writes an integer to a JsonEmitter.
-/// @param emitter the emitter to write to.
-/// @param i the integer to write.
-void write(JsonEmitter& emitter, unsigned int i);
-
-/// Writes an integer to a JsonEmitter.
-/// @param emitter the emitter to write to.
-/// @param i the integer to write.
-void write(JsonEmitter& emitter, unsigned long i);
-
-/// Writes an integer to a JsonEmitter.
-/// @param emitter the emitter to write to.
-/// @param i the integer to write.
-void write(JsonEmitter& emitter, unsigned long long i);
-
-/// Writes a double to a JsonEmitter.
-/// @param emitter the emitter to write to.
-/// @param d the double to write.
-void write(JsonEmitter& emitter, double d);
-
-/// Writes a string to a JsonEmitter. The string will be escaped.
-/// @param emitter the emitter to write to.
-/// @param sv the string to write.
-void write(JsonEmitter& emitter, std::string_view sv);
-
-/// Writes a character to a JsonEmitter as a single-character string. The
-/// character will be escaped.
-/// @param emitter the emitter to write to.
-/// @param c the string to write.
-void write(JsonEmitter& emitter, char c);
-
-/// Writes a string to a JsonEmitter. The string will be escaped.
-/// @param emitter the emitter to write to.
-/// @param str the string to write.
-void write(JsonEmitter& emitter, const char* str);
-
-/// Writes a string to a JsonEmitter. The string will be escaped.
-/// @param emitter the emitter to write to.
-/// @param str the string to write.
-void write(JsonEmitter& emitter, const std::string& str);
-
-/// Writes null to a JsonEmitter.
-/// @param emitter the emitter to write to.
-void write(JsonEmitter& emitter, std::nullptr_t);
-
-/// Writes null to a JsonEmitter.
-/// @param emitter the emitter to write to.
-void write(JsonEmitter& emitter, std::nullopt_t);
-
-struct ObjectEmitter;
-struct ArrayEmitter;
-
-struct JsonEmitter
-{
-    JsonEmitter();
-
-    /// Converts the current contents of the JsonEmitter to a string value. This
-    /// does not invalidate the emitter, but it does not clear it either.
-    std::string str();
-
-    /// Returns the current comma state and resets it to false. Use popComma to
-    /// restore the old state.
-    /// @returns the previous comma state.
-    bool pushComma();
-
-    /// Restores a previous comma state.
-    /// @param c the comma state to restore.
-    void popComma(bool c);
-
-    /// Writes a raw sequence of characters to the buffer, without escaping or
-    /// other processing.
-    /// @param sv the character sequence to write.
-    void writeRaw(std::string_view sv);
-
-    /// Writes a character to the buffer, without escaping or other processing.
-    /// @param c the character to write.
-    void writeRaw(char c);
-
-    /// Writes a comma if this wasn't the first time writeComma has been
-    /// invoked. Otherwise, sets the comma state to true.
-    /// @see pushComma
-    /// @see popComma
-    void writeComma();
-
-    /// Begins writing an object to the emitter.
-    /// @returns an ObjectEmitter that can be used to write key-value pairs.
-    ObjectEmitter writeObject();
-
-    /// Begins writing an array to the emitter.
-    /// @returns an ArrayEmitter that can be used to write values.
-    ArrayEmitter writeArray();
-
-private:
-    bool comma = false;
-    std::vector<std::string> chunks;
-
-    void newChunk();
-};
-
-/// An interface for writing an object into a JsonEmitter instance.
-/// @see JsonEmitter::writeObject
-struct ObjectEmitter
-{
-    ObjectEmitter(NotNull<JsonEmitter> emitter);
-    ~ObjectEmitter();
-
-    NotNull<JsonEmitter> emitter;
-    bool comma;
-    bool finished;
-
-    /// Writes a key-value pair to the associated JsonEmitter. Keys will be escaped.
-    /// @param name the name of the key-value pair.
-    /// @param value the value to write.
-    template<typename T>
-    void writePair(std::string_view name, T value)
-    {
-        if (finished)
-        {
-            return;
-        }
-
-        emitter->writeComma();
-        write(*emitter, name);
-        emitter->writeRaw(':');
-        write(*emitter, value);
-    }
-
-    /// Finishes writing the object, appending a closing `}` character and
-    /// resetting the comma state of the associated emitter. This can only be
-    /// called once, and once called will render the emitter unusable. This
-    /// method is also called when the ObjectEmitter is destructed.
-    void finish();
-};
-
-/// An interface for writing an array into a JsonEmitter instance. Array values
-/// do not need to be the same type.
-/// @see JsonEmitter::writeArray
-struct ArrayEmitter
-{
-    ArrayEmitter(NotNull<JsonEmitter> emitter);
-    ~ArrayEmitter();
-
-    NotNull<JsonEmitter> emitter;
-    bool comma;
-    bool finished;
-
-    /// Writes a value to the array.
-    /// @param value the value to write.
-    template<typename T>
-    void writeValue(T value)
-    {
-        if (finished)
-        {
-            return;
-        }
-
-        emitter->writeComma();
-        write(*emitter, value);
-    }
-
-    /// Finishes writing the object, appending a closing `]` character and
-    /// resetting the comma state of the associated emitter. This can only be
-    /// called once, and once called will render the emitter unusable. This
-    /// method is also called when the ArrayEmitter is destructed.
-    void finish();
-};
-
-/// Writes a vector as an array to a JsonEmitter.
-/// @param emitter the emitter to write to.
-/// @param vec the vector to write.
-template<typename T>
-void write(JsonEmitter& emitter, const std::vector<T>& vec)
-{
-    ArrayEmitter a = emitter.writeArray();
-
-    for (const T& value : vec)
-        a.writeValue(value);
-
-    a.finish();
-}
-
-/// Writes an optional to a JsonEmitter. Will write the contained value, if
-/// present, or null, if no value is present.
-/// @param emitter the emitter to write to.
-/// @param v the value to write.
-template<typename T>
-void write(JsonEmitter& emitter, const std::optional<T>& v)
-{
-    if (v.has_value())
-        write(emitter, *v);
-    else
-        emitter.writeRaw("null");
-}
-
-template<typename T>
-void write(JsonEmitter& emitter, const std::unordered_map<std::string, T>& map)
-{
-    ObjectEmitter o = emitter.writeObject();
-
-    for (const auto& [k, v] : map)
-        o.writePair(k, v);
-
-    o.finish();
-}
-
-} // namespace Luau::Json

Analysis/include/Luau/JsonEncoder.h

@@ -2,15 +2,12 @@
 #pragma once
 
 #include <string>
-#include <vector>
 
 namespace Luau
 {
 
 class AstNode;
-struct Comment;
 
 std::string toJson(AstNode* node);
-std::string toJson(AstNode* node, const std::vector<Comment>& commentLocations);
 
 } // namespace Luau

Analysis/include/Luau/LValue.h

@@ -1,51 +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/Variant.h"
-#include "Luau/Symbol.h"
-#include "Luau/TypeFwd.h"
-
-#include <memory>
-#include <unordered_map>
-
-namespace Luau
-{
-
-struct Field;
-
-// Deprecated. Do not use in new work.
-using LValue = Variant<Symbol, Field>;
-
-struct Field
-{
-    std::shared_ptr<LValue> parent;
-    std::string key;
-
-    bool operator==(const Field& rhs) const;
-    bool operator!=(const Field& rhs) const;
-};
-
-struct LValueHasher
-{
-    size_t operator()(const LValue& lvalue) const;
-};
-
-const LValue* baseof(const LValue& lvalue);
-
-std::optional<LValue> tryGetLValue(const class AstExpr& expr);
-
-// Utility function: breaks down an LValue to get at the Symbol
-Symbol getBaseSymbol(const LValue& lvalue);
-
-template<typename T>
-const T* get(const LValue& lvalue)
-{
-    return get_if<T>(&lvalue);
-}
-
-using RefinementMap = std::unordered_map<LValue, TypeId, LValueHasher>;
-
-void merge(RefinementMap& l, const RefinementMap& r, std::function<TypeId(TypeId, TypeId)> f);
-void addRefinement(RefinementMap& refis, const LValue& lvalue, TypeId ty);
-
-} // namespace Luau

Analysis/include/Luau/Linter.h

@@ -1,11 +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/LinterConfig.h"
 #include "Luau/Location.h"
 
 #include <memory>
-#include <string>
 #include <vector>
 
 namespace Luau
@@ -19,20 +17,79 @@ struct Module;
 
 using ScopePtr = std::shared_ptr<struct Scope>;
 
+struct LintWarning
+{
+    // Make sure any new lint codes are documented here: https://luau-lang.org/lint
+    // Note that in Studio, the active set of lint warnings is determined by FStringStudioLuauLints
+    enum Code
+    {
+        Code_Unknown = 0,
+
+        Code_UnknownGlobal = 1, // superseded by type checker
+        Code_DeprecatedGlobal = 2,
+        Code_GlobalUsedAsLocal = 3,
+        Code_LocalShadow = 4,       // disabled in Studio
+        Code_SameLineStatement = 5, // disabled in Studio
+        Code_MultiLineStatement = 6,
+        Code_LocalUnused = 7,    // disabled in Studio
+        Code_FunctionUnused = 8, // disabled in Studio
+        Code_ImportUnused = 9,   // disabled in Studio
+        Code_BuiltinGlobalWrite = 10,
+        Code_PlaceholderRead = 11,
+        Code_UnreachableCode = 12,
+        Code_UnknownType = 13,
+        Code_ForRange = 14,
+        Code_UnbalancedAssignment = 15,
+        Code_ImplicitReturn = 16, // disabled in Studio, superseded by type checker in strict mode
+        Code_DuplicateLocal = 17,
+        Code_FormatString = 18,
+        Code_TableLiteral = 19,
+        Code_UninitializedLocal = 20,
+        Code_DuplicateFunction = 21,
+        Code_DeprecatedApi = 22,
+        Code_TableOperations = 23,
+        Code_DuplicateCondition = 24,
+
+        Code__Count
+    };
+
+    Code code;
+    Location location;
+    std::string text;
+
+    static const char* getName(Code code);
+    static Code parseName(const char* name);
+    static uint64_t parseMask(const std::vector<std::string>& hotcomments);
+};
+
 struct LintResult
 {
     std::vector<LintWarning> errors;
     std::vector<LintWarning> warnings;
 };
 
-std::vector<LintWarning> lint(
-    AstStat* root,
-    const AstNameTable& names,
-    const ScopePtr& env,
-    const Module* module,
-    const std::vector<HotComment>& hotcomments,
-    const LintOptions& options
-);
+struct LintOptions
+{
+    uint64_t warningMask = 0;
+
+    void enableWarning(LintWarning::Code code)
+    {
+        warningMask |= 1ull << code;
+    }
+    void disableWarning(LintWarning::Code code)
+    {
+        warningMask &= ~(1ull << code);
+    }
+
+    bool isEnabled(LintWarning::Code code) const
+    {
+        return 0 != (warningMask & (1ull << code));
+    }
+
+    void setDefaults();
+};
+
+std::vector<LintWarning> lint(AstStat* root, const AstNameTable& names, const ScopePtr& env, const Module* module, const LintOptions& options);
 
 std::vector<AstName> getDeprecatedGlobals(const AstNameTable& names);
 

Analysis/include/Luau/Metamethods.h

@@ -1,33 +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/Ast.h"
-
-#include <unordered_map>
-
-namespace Luau
-{
-
-static const std::unordered_map<AstExprBinary::Op, const char*> kBinaryOpMetamethods{
-    {AstExprBinary::Op::CompareEq, "__eq"},
-    {AstExprBinary::Op::CompareNe, "__eq"},
-    {AstExprBinary::Op::CompareGe, "__lt"},
-    {AstExprBinary::Op::CompareGt, "__le"},
-    {AstExprBinary::Op::CompareLe, "__le"},
-    {AstExprBinary::Op::CompareLt, "__lt"},
-    {AstExprBinary::Op::Add, "__add"},
-    {AstExprBinary::Op::Sub, "__sub"},
-    {AstExprBinary::Op::Mul, "__mul"},
-    {AstExprBinary::Op::Div, "__div"},
-    {AstExprBinary::Op::FloorDiv, "__idiv"},
-    {AstExprBinary::Op::Pow, "__pow"},
-    {AstExprBinary::Op::Mod, "__mod"},
-    {AstExprBinary::Op::Concat, "__concat"},
-};
-
-static const std::unordered_map<AstExprUnary::Op, const char*> kUnaryOpMetamethods{
-    {AstExprUnary::Op::Minus, "__unm"},
-    {AstExprUnary::Op::Len, "__len"},
-};
-
-} // namespace Luau

Analysis/include/Luau/Module.h

@@ -1,14 +1,12 @@
 // This file is part of the Luau programming language and is licensed under MIT License; see LICENSE.txt for details
 #pragma once
 
-#include "Luau/Error.h"
-#include "Luau/Linter.h"
 #include "Luau/FileResolver.h"
+#include "Luau/TypePack.h"
+#include "Luau/TypedAllocator.h"
 #include "Luau/ParseOptions.h"
-#include "Luau/ParseResult.h"
-#include "Luau/Scope.h"
-#include "Luau/TypeArena.h"
-#include "Luau/DataFlowGraph.h"
+#include "Luau/Error.h"
+#include "Luau/Parser.h"
 
 #include <memory>
 #include <vector>
@@ -18,38 +16,27 @@
 namespace Luau
 {
 
-using LogLuauProc = void (*)(std::string_view, std::string_view);
-extern LogLuauProc logLuau;
-
-void setLogLuau(LogLuauProc ll);
-void resetLogLuauProc();
-
 struct Module;
 
 using ScopePtr = std::shared_ptr<struct Scope>;
 using ModulePtr = std::shared_ptr<Module>;
 
-class AstType;
-class AstTypePack;
-
 /// Root of the AST of a parsed source file
 struct SourceModule
 {
-    ModuleName name; // Module identifier or a filename
-    std::string humanReadableName;
-
+    ModuleName name; // DataModel path if possible.  Filename if not.
     SourceCode::Type type = SourceCode::None;
     std::optional<std::string> environmentName;
     bool cyclic = false;
 
-    std::shared_ptr<Allocator> allocator;
-    std::shared_ptr<AstNameTable> names;
+    std::unique_ptr<Allocator> allocator;
+    std::unique_ptr<AstNameTable> names;
     std::vector<ParseError> parseErrors;
 
     AstStatBlock* root = nullptr;
     std::optional<Mode> mode;
+    uint64_t ignoreLints = 0;
 
-    std::vector<HotComment> hotcomments;
     std::vector<Comment> commentLocations;
 
     SourceModule()
@@ -59,97 +46,74 @@ struct SourceModule
     }
 };
 
-bool isWithinComment(const std::vector<Comment>& commentLocations, Position pos);
 bool isWithinComment(const SourceModule& sourceModule, Position pos);
-bool isWithinComment(const ParseResult& result, Position pos);
 
-struct RequireCycle
+struct TypeArena
 {
-    Location location;
-    std::vector<ModuleName> path; // one of the paths for a require() to go all the way back to the originating module
+    TypedAllocator<TypeVar> typeVars;
+    TypedAllocator<TypePackVar> typePacks;
+
+    void clear();
+
+    template<typename T>
+    TypeId addType(T tv)
+    {
+        return addTV(TypeVar(std::move(tv)));
+    }
+
+    TypeId addTV(TypeVar&& tv);
+
+    TypeId freshType(TypeLevel level);
+
+    TypePackId addTypePack(std::initializer_list<TypeId> types);
+    TypePackId addTypePack(std::vector<TypeId> types);
+    TypePackId addTypePack(TypePack pack);
+    TypePackId addTypePack(TypePackVar pack);
 };
 
+void freeze(TypeArena& arena);
+void unfreeze(TypeArena& arena);
+
+// Only exposed so they can be unit tested.
+using SeenTypes = std::unordered_map<TypeId, TypeId>;
+using SeenTypePacks = std::unordered_map<TypePackId, TypePackId>;
+
+struct CloneState
+{
+    int recursionCount = 0;
+    bool encounteredFreeType = false;
+};
+
+TypePackId clone(TypePackId tp, TypeArena& dest, SeenTypes& seenTypes, SeenTypePacks& seenTypePacks, CloneState& cloneState);
+TypeId clone(TypeId tp, TypeArena& dest, SeenTypes& seenTypes, SeenTypePacks& seenTypePacks, CloneState& cloneState);
+TypeFun clone(const TypeFun& typeFun, TypeArena& dest, SeenTypes& seenTypes, SeenTypePacks& seenTypePacks, CloneState& cloneState);
+
 struct Module
 {
     ~Module();
 
-    // TODO: Clip this when we clip FFlagLuauSolverV2
-    bool checkedInNewSolver = false;
-
-    ModuleName name;
-    std::string humanReadableName;
-
     TypeArena interfaceTypes;
     TypeArena internalTypes;
 
-    // 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
 
     DenseHashMap<const AstExpr*, TypeId> astTypes{nullptr};
-    DenseHashMap<const AstExpr*, TypePackId> astTypePacks{nullptr};
     DenseHashMap<const AstExpr*, TypeId> astExpectedTypes{nullptr};
-
-    // For AST nodes that are function calls, this map provides the
-    // unspecialized type of the function that was called. If a function call
-    // resolves to a __call metamethod application, this map will point at that
-    // metamethod.
-    //
-    // This is useful for type checking and Signature Help.
-    DenseHashMap<const AstNode*, TypeId> astOriginalCallTypes{nullptr};
-
-    // The specialization of a function that was selected.  If the function is
-    // generic, those generic type parameters will be replaced with the actual
-    // types that were passed.  If the function is an overload, this map will
-    // point at the specific overloads that were selected.
-    DenseHashMap<const AstNode*, TypeId> astOverloadResolvedTypes{nullptr};
-
-    // Only used with for...in loops.  The computed type of the next() function
-    // is kept here for type checking.
-    DenseHashMap<const AstNode*, TypeId> astForInNextTypes{nullptr};
-
-    DenseHashMap<const AstType*, TypeId> astResolvedTypes{nullptr};
-    DenseHashMap<const AstTypePack*, TypePackId> astResolvedTypePacks{nullptr};
-
-    // The computed result type of a compound assignment. (eg foo += 1)
-    //
-    // Type checking uses this to check that the result of such an operation is
-    // actually compatible with the left-side operand.
-    DenseHashMap<const AstStat*, TypeId> astCompoundAssignResultTypes{nullptr};
-
-    DenseHashMap<TypeId, std::vector<std::pair<Location, TypeId>>> upperBoundContributors{nullptr};
-
-    // Map AST nodes to the scope they create.  Cannot be NotNull<Scope> because
-    // we need a sentinel value for the map.
-    DenseHashMap<const AstNode*, Scope*> astScopes{nullptr};
+    DenseHashMap<const AstExpr*, TypeId> astOriginalCallTypes{nullptr};
+    DenseHashMap<const AstExpr*, TypeId> astOverloadResolvedTypes{nullptr};
 
     std::unordered_map<Name, TypeId> declaredGlobals;
     ErrorVec errors;
-    LintResult lintResult;
     Mode mode;
     SourceCode::Type type;
-    double checkDurationSec = 0.0;
-    bool timeout = false;
-    bool cancelled = false;
 
-    TypePackId returnType = nullptr;
-    std::unordered_map<Name, TypeFun> exportedTypeBindings;
-
-    // Arenas related to the DFG must persist after the DFG no longer exists, as
-    // Module objects maintain raw pointers to objects in these arenas.
-    DefArena defArena;
-    RefinementKeyArena keyArena;
-
-    bool hasModuleScope() const;
     ScopePtr getModuleScope() const;
 
-    // Once a module has been typechecked, we clone its public interface into a
-    // separate arena. This helps us to force Type ownership into a DAG rather
-    // than a DCG.
-    void clonePublicInterface(NotNull<BuiltinTypes> builtinTypes, InternalErrorReporter& ice);
+    // Once a module has been typechecked, we clone its public interface into a separate arena.
+    // This helps us to force TypeVar ownership into a DAG rather than a DCG.
+    // Returns true if there were any free types encountered in the public interface. This
+    // indicates a bug in the type checker that we want to surface.
+    bool clonePublicInterface();
 };
 
 } // namespace Luau

Analysis/include/Luau/ModuleResolver.h

@@ -20,6 +20,8 @@ struct ModuleResolver
     virtual ~ModuleResolver() {}
 
     /** Compute a ModuleName from an AST fragment.  This AST fragment is generally the argument to the require() function.
+     *
+     * You probably want to implement this with some variation of pathExprToModuleName.
      *
      * @returns The ModuleInfo if the expression is a syntactically legal path.
      * @returns std::nullopt if we are unable to determine whether or not the expression is a valid path.  Type inference will

Analysis/include/Luau/NonStrictTypeChecker.h

@@ -1,30 +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/DataFlowGraph.h"
-#include "Luau/EqSatSimplification.h"
-#include "Luau/Module.h"
-#include "Luau/NotNull.h"
-
-namespace Luau
-{
-
-struct BuiltinTypes;
-struct TypeFunctionRuntime;
-struct UnifierSharedState;
-struct TypeCheckLimits;
-
-void checkNonStrict(
-    NotNull<BuiltinTypes> builtinTypes,
-    NotNull<Simplifier> simplifier,
-    NotNull<TypeFunctionRuntime> typeFunctionRuntime,
-    NotNull<InternalErrorReporter> ice,
-    NotNull<UnifierSharedState> unifierState,
-    NotNull<const DataFlowGraph> dfg,
-    NotNull<TypeCheckLimits> limits,
-    const SourceModule& sourceModule,
-    Module* module
-);
-
-
-} // namespace Luau

Analysis/include/Luau/Normalize.h

@@ -1,465 +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/EqSatSimplification.h"
-#include "Luau/NotNull.h"
-#include "Luau/Set.h"
-#include "Luau/TypeFwd.h"
-#include "Luau/UnifierSharedState.h"
-
-#include <initializer_list>
-#include <map>
-#include <memory>
-#include <unordered_map>
-#include <vector>
-
-namespace Luau
-{
-
-struct InternalErrorReporter;
-struct Module;
-struct Scope;
-
-using ModulePtr = std::shared_ptr<Module>;
-
-bool isSubtype(
-    TypeId subTy,
-    TypeId superTy,
-    NotNull<Scope> scope,
-    NotNull<BuiltinTypes> builtinTypes,
-    NotNull<Simplifier> simplifier,
-    InternalErrorReporter& ice
-);
-bool isSubtype(
-    TypePackId subPack,
-    TypePackId superPack,
-    NotNull<Scope> scope,
-    NotNull<BuiltinTypes> builtinTypes,
-    NotNull<Simplifier> simplifier,
-    InternalErrorReporter& ice
-);
-
-class TypeIds
-{
-private:
-    DenseHashMap<TypeId, bool> types{nullptr};
-    std::vector<TypeId> order;
-    std::size_t hash = 0;
-
-public:
-    using iterator = std::vector<TypeId>::iterator;
-    using const_iterator = std::vector<TypeId>::const_iterator;
-
-    TypeIds() = default;
-    ~TypeIds() = default;
-
-    TypeIds(std::initializer_list<TypeId> tys);
-
-    TypeIds(const TypeIds&) = default;
-    TypeIds& operator=(const TypeIds&) = default;
-
-    TypeIds(TypeIds&&) = default;
-    TypeIds& operator=(TypeIds&&) = default;
-
-    void insert(TypeId ty);
-    /// Erase every element that does not also occur in tys
-    void retain(const TypeIds& tys);
-    void clear();
-
-    TypeId front() const;
-    iterator begin();
-    iterator end();
-    const_iterator begin() const;
-    const_iterator end() const;
-    iterator erase(const_iterator it);
-    void erase(TypeId ty);
-
-    size_t size() const;
-    bool empty() const;
-    size_t count(TypeId ty) const;
-
-    template<class Iterator>
-    void insert(Iterator begin, Iterator end)
-    {
-        for (Iterator it = begin; it != end; ++it)
-            insert(*it);
-    }
-
-    bool operator==(const TypeIds& there) const;
-    size_t getHash() const;
-    bool isNever() const;
-};
-
-} // namespace Luau
-
-template<>
-struct std::hash<Luau::TypeIds>
-{
-    std::size_t operator()(const Luau::TypeIds& tys) const
-    {
-        return tys.getHash();
-    }
-};
-
-template<>
-struct std::hash<const Luau::TypeIds*>
-{
-    std::size_t operator()(const Luau::TypeIds* tys) const
-    {
-        return tys->getHash();
-    }
-};
-
-template<>
-struct std::equal_to<Luau::TypeIds>
-{
-    bool operator()(const Luau::TypeIds& here, const Luau::TypeIds& there) const
-    {
-        return here == there;
-    }
-};
-
-template<>
-struct std::equal_to<const Luau::TypeIds*>
-{
-    bool operator()(const Luau::TypeIds* here, const Luau::TypeIds* there) const
-    {
-        return *here == *there;
-    }
-};
-
-namespace Luau
-{
-
-/** A normalized string type is either `string` (represented by `nullopt`) or a
- * union of string singletons.
- *
- * The representation is as follows:
- *
- * * A union of string singletons is finite and includes the singletons named by
- *   the `singletons` field.
- * * An intersection of negated string singletons is cofinite and includes the
- *   singletons excluded by the `singletons` field.  It is implied that cofinite
- *   values are exclusions from `string` itself.
- * * The `string` data type is a cofinite set minus zero elements.
- * * The `never` data type is a finite set plus zero elements.
- */
-struct NormalizedStringType
-{
-    // When false, this type represents a union of singleton string types.
-    // eg "a" | "b" | "c"
-    //
-    // When true, this type represents string intersected with negated string
-    // singleton types.
-    // eg string & ~"a" & ~"b" & ...
-    bool isCofinite = false;
-
-    std::map<std::string, TypeId> singletons;
-
-    void resetToString();
-    void resetToNever();
-
-    bool isNever() const;
-    bool isString() const;
-
-    /// Returns true if the string has finite domain.
-    ///
-    /// Important subtlety: This method returns true for `never`.  The empty set
-    /// is indeed an empty set.
-    bool isUnion() const;
-
-    /// Returns true if the string has infinite domain.
-    bool isIntersection() const;
-
-    bool includes(const std::string& str) const;
-
-    static const NormalizedStringType never;
-
-    NormalizedStringType();
-    NormalizedStringType(bool isCofinite, std::map<std::string, TypeId> singletons);
-};
-
-bool isSubtype(const NormalizedStringType& subStr, const NormalizedStringType& superStr);
-
-struct NormalizedExternType
-{
-    /** Has the following structure:
-     *
-     * (C1 & ~N11 & ... & ~Nn) | (C2 & ~N21 & ... & ~N2n) | ...
-     *
-     * C2 is either not a subtype of any other Cm, or it is and is also a
-     * subtype of one of Nmn types within the same cluster.
-     *
-     * Each TypeId is a class type.
-     */
-    std::unordered_map<TypeId, TypeIds> externTypes;
-
-    /**
-     * In order to maintain a consistent insertion order, we use this vector to
-     * keep track of it. An ordered std::map will sort by pointer identity,
-     * which is undesirable.
-     */
-    std::vector<TypeId> ordering;
-
-    void pushPair(TypeId ty, TypeIds negations);
-
-    void resetToNever();
-    bool isNever() const;
-};
-
-// A normalized function type can be `never`, the top function type `function`,
-// or an intersection of function types.
-//
-// NOTE: type normalization can fail on function types with generics (e.g.
-// because we do not support unions and intersections of generic type packs), so
-// this type may contain `error`.
-struct NormalizedFunctionType
-{
-    bool isTop = false;
-    TypeIds parts;
-
-    void resetToNever();
-    void resetToTop();
-
-    bool isNever() const;
-};
-
-// A normalized generic/free type is a union, where each option is of the form (X & T) where
-// * X is either a free type, a generic or a blocked type.
-// * T is a normalized type.
-struct NormalizedType;
-using NormalizedTyvars = std::unordered_map<TypeId, std::unique_ptr<NormalizedType>>;
-
-// Operations provided by `Normalizer` can have ternary results:
-//   1. The operation returned true.
-//   2. The operation returned false.
-//   3. They can hit resource limitations, which invalidates _all normalized types_.
-enum class NormalizationResult
-{
-    // The operation returned true or succeeded.
-    True,
-    // The operation returned false or failed.
-    False,
-    // Resource limits were hit, invalidating all normalized types.
-    HitLimits,
-};
-
-// A normalized type is either any, unknown, or one of the form P | T | F | G where
-// * P is a union of primitive types (including singletons, extern types and the error type)
-// * T is a union of table types
-// * F is a union of an intersection of function types
-// * G is a union of generic/free/blocked types, intersected with a normalized type
-struct NormalizedType
-{
-    // The top part of the type.
-    // This type is either never, unknown, or any.
-    // If this type is not never, all the other fields are null.
-    TypeId tops;
-
-    // The boolean part of the type.
-    // This type is either never, boolean type, or a boolean singleton.
-    TypeId booleans;
-
-    NormalizedExternType externTypes;
-
-    // The error part of the type.
-    // This type is either never or the error type.
-    TypeId errors;
-
-    // The nil part of the type.
-    // This type is either never or nil.
-    TypeId nils;
-
-    // The number part of the type.
-    // This type is either never or number.
-    TypeId numbers;
-
-    // The string part of the type.
-    // This may be the `string` type, or a union of singletons.
-    NormalizedStringType strings;
-
-    // The thread part of the type.
-    // This type is either never or thread.
-    TypeId threads;
-
-    // The buffer part of the type.
-    // This type is either never or buffer.
-    TypeId buffers;
-
-    // The (meta)table part of the type.
-    // Each element of this set is a (meta)table type, or the top `table` type.
-    // An empty set denotes never.
-    TypeIds tables;
-
-    // The function part of the type.
-    NormalizedFunctionType functions;
-
-    // The generic/free part of the type.
-    NormalizedTyvars tyvars;
-
-    // Free types, blocked types, and certain other types change shape as type
-    // inference is done. If we were to cache the normalization of these types,
-    // we'd be reusing bad, stale data.
-    bool isCacheable = true;
-
-    NormalizedType(NotNull<BuiltinTypes> builtinTypes);
-
-    NormalizedType() = delete;
-    ~NormalizedType() = default;
-
-    NormalizedType(const NormalizedType&) = delete;
-    NormalizedType& operator=(const NormalizedType&) = delete;
-
-    NormalizedType(NormalizedType&&) = default;
-    NormalizedType& operator=(NormalizedType&&) = default;
-
-    // IsType functions
-    bool isUnknown() const;
-    /// Returns true if the type is exactly a number. Behaves like Type::isNumber()
-    bool isExactlyNumber() const;
-
-    /// Returns true if the type is a subtype of string(it could be a singleton). Behaves like Type::isString()
-    bool isSubtypeOfString() const;
-
-    /// Returns true if the type is a subtype of boolean(it could be a singleton). Behaves like Type::isBoolean()
-    bool isSubtypeOfBooleans() const;
-
-    /// Returns true if this type should result in error suppressing behavior.
-    bool shouldSuppressErrors() const;
-
-    /// Returns true if this type contains the primitve top table type, `table`.
-    bool hasTopTable() const;
-
-    // Helpers that improve readability of the above (they just say if the component is present)
-    bool hasTops() const;
-    bool hasBooleans() const;
-    bool hasExternTypes() const;
-    bool hasErrors() const;
-    bool hasNils() const;
-    bool hasNumbers() const;
-    bool hasStrings() const;
-    bool hasThreads() const;
-    bool hasBuffers() const;
-    bool hasTables() const;
-    bool hasFunctions() const;
-    bool hasTyvars() const;
-
-    bool isFalsy() const;
-    bool isTruthy() const;
-};
-
-
-using SeenTablePropPairs = Set<std::pair<TypeId, TypeId>, TypeIdPairHash>;
-
-class Normalizer
-{
-    std::unordered_map<TypeId, std::shared_ptr<NormalizedType>> cachedNormals;
-    std::unordered_map<const TypeIds*, TypeId> cachedIntersections;
-    std::unordered_map<const TypeIds*, TypeId> cachedUnions;
-    std::unordered_map<const TypeIds*, std::unique_ptr<TypeIds>> cachedTypeIds;
-
-    DenseHashMap<TypeId, bool> cachedIsInhabited{nullptr};
-    DenseHashMap<std::pair<TypeId, TypeId>, bool, TypeIdPairHash> cachedIsInhabitedIntersection{{nullptr, nullptr}};
-
-    bool withinResourceLimits();
-
-public:
-    TypeArena* arena;
-    NotNull<BuiltinTypes> builtinTypes;
-    NotNull<UnifierSharedState> sharedState;
-    bool cacheInhabitance = false;
-
-    Normalizer(TypeArena* arena, NotNull<BuiltinTypes> builtinTypes, NotNull<UnifierSharedState> sharedState, bool cacheInhabitance = false);
-    Normalizer(const Normalizer&) = delete;
-    Normalizer(Normalizer&&) = delete;
-    Normalizer() = delete;
-    ~Normalizer() = default;
-    Normalizer& operator=(Normalizer&&) = delete;
-    Normalizer& operator=(Normalizer&) = delete;
-
-    // If this returns null, the typechecker should emit a "too complex" error
-    std::shared_ptr<const NormalizedType> normalize(TypeId ty);
-    void clearNormal(NormalizedType& norm);
-
-    // ------- Cached TypeIds
-    TypeId unionType(TypeId here, TypeId there);
-    TypeId intersectionType(TypeId here, TypeId there);
-    const TypeIds* cacheTypeIds(TypeIds tys);
-    void clearCaches();
-
-    // ------- Normalizing unions
-    void unionTysWithTy(TypeIds& here, TypeId there);
-    TypeId unionOfTops(TypeId here, TypeId there);
-    TypeId unionOfBools(TypeId here, TypeId there);
-    void unionExternTypesWithExternType(TypeIds& heres, TypeId there);
-    void unionExternTypes(TypeIds& heres, const TypeIds& theres);
-    void unionExternTypesWithExternType(NormalizedExternType& heres, TypeId there);
-    void unionExternTypes(NormalizedExternType& heres, const NormalizedExternType& theres);
-    void unionStrings(NormalizedStringType& here, const NormalizedStringType& there);
-    std::optional<TypePackId> unionOfTypePacks(TypePackId here, TypePackId there);
-    std::optional<TypeId> unionOfFunctions(TypeId here, TypeId there);
-    std::optional<TypeId> unionSaturatedFunctions(TypeId here, TypeId there);
-    void unionFunctionsWithFunction(NormalizedFunctionType& heress, TypeId there);
-    void unionFunctions(NormalizedFunctionType& heress, const NormalizedFunctionType& theress);
-    void unionTablesWithTable(TypeIds& heres, TypeId there);
-    void unionTables(TypeIds& heres, const TypeIds& theres);
-    NormalizationResult unionNormals(NormalizedType& here, const NormalizedType& there, int ignoreSmallerTyvars = -1);
-    NormalizationResult unionNormalWithTy(
-        NormalizedType& here,
-        TypeId there,
-        SeenTablePropPairs& seenTablePropPairs,
-        Set<TypeId>& seenSetTypes,
-        int ignoreSmallerTyvars = -1
-    );
-
-    // ------- Negations
-    std::optional<NormalizedType> negateNormal(const NormalizedType& here);
-    TypeIds negateAll(const TypeIds& theres);
-    TypeId negate(TypeId there);
-    void subtractPrimitive(NormalizedType& here, TypeId ty);
-    void subtractSingleton(NormalizedType& here, TypeId ty);
-    NormalizationResult intersectNormalWithNegationTy(TypeId toNegate, NormalizedType& intersect);
-
-    // ------- Normalizing intersections
-    TypeId intersectionOfTops(TypeId here, TypeId there);
-    TypeId intersectionOfBools(TypeId here, TypeId there);
-    void intersectExternTypes(NormalizedExternType& heres, const NormalizedExternType& theres);
-    void intersectExternTypesWithExternType(NormalizedExternType& heres, TypeId there);
-    void intersectStrings(NormalizedStringType& here, const NormalizedStringType& there);
-    std::optional<TypePackId> intersectionOfTypePacks(TypePackId here, TypePackId there);
-    std::optional<TypeId> intersectionOfTables(TypeId here, TypeId there, SeenTablePropPairs& seenTablePropPairs, Set<TypeId>& seenSet);
-    void intersectTablesWithTable(TypeIds& heres, TypeId there, SeenTablePropPairs& seenTablePropPairs, Set<TypeId>& seenSetTypes);
-    void intersectTables(TypeIds& heres, const TypeIds& theres);
-    std::optional<TypeId> intersectionOfFunctions(TypeId here, TypeId there);
-    void intersectFunctionsWithFunction(NormalizedFunctionType& heress, TypeId there);
-    void intersectFunctions(NormalizedFunctionType& heress, const NormalizedFunctionType& theress);
-    NormalizationResult intersectTyvarsWithTy(
-        NormalizedTyvars& here,
-        TypeId there,
-        SeenTablePropPairs& seenTablePropPairs,
-        Set<TypeId>& seenSetTypes
-    );
-    NormalizationResult intersectNormals(NormalizedType& here, const NormalizedType& there, int ignoreSmallerTyvars = -1);
-    NormalizationResult intersectNormalWithTy(NormalizedType& here, TypeId there, SeenTablePropPairs& seenTablePropPairs, Set<TypeId>& seenSetTypes);
-    NormalizationResult normalizeIntersections(
-        const std::vector<TypeId>& intersections,
-        NormalizedType& outType,
-        SeenTablePropPairs& seenTablePropPairs,
-        Set<TypeId>& seenSet
-    );
-
-    // Check for inhabitance
-    NormalizationResult isInhabited(TypeId ty);
-    NormalizationResult isInhabited(TypeId ty, Set<TypeId>& seen);
-    NormalizationResult isInhabited(const NormalizedType* norm);
-    NormalizationResult isInhabited(const NormalizedType* norm, Set<TypeId>& seen);
-
-    // Check for intersections being inhabited
-    NormalizationResult isIntersectionInhabited(TypeId left, TypeId right);
-    NormalizationResult isIntersectionInhabited(TypeId left, TypeId right, SeenTablePropPairs& seenTablePropPairs, Set<TypeId>& seenSet);
-
-    // -------- Convert back from a normalized type to a type
-    TypeId typeFromNormal(const NormalizedType& norm);
-};
-
-} // namespace Luau

Analysis/include/Luau/NotNull.h

@@ -1,104 +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/Common.h"
-
-#include <functional>
-
-namespace Luau
-{
-
-/** A non-owning, non-null pointer to a T.
- *
- * A NotNull<T> is notionally identical to a T* with the added restriction that
- * it can never store nullptr.
- *
- * The sole conversion rule from T* to NotNull<T> is the single-argument
- * constructor, which is intentionally marked explicit. This constructor
- * performs a runtime test to verify that the passed pointer is never nullptr.
- *
- * Pointer arithmetic, increment, decrement, and array indexing are all
- * forbidden.
- *
- * An implicit coersion from NotNull<T> to T* is afforded, as are the pointer
- * indirection and member access operators. (*p and p->prop)
- *
- * The explicit delete statement is permitted (but not recommended) on a
- * NotNull<T> through this implicit conversion.
- */
-template<typename T>
-struct NotNull
-{
-    explicit NotNull(T* t)
-        : ptr(t)
-    {
-        LUAU_ASSERT(t);
-    }
-
-    explicit NotNull(std::nullptr_t) = delete;
-    void operator=(std::nullptr_t) = delete;
-
-    template<typename U>
-    NotNull(NotNull<U> other)
-        : ptr(other.get())
-    {
-    }
-
-    operator T*() const noexcept
-    {
-        return ptr;
-    }
-
-    T& operator*() const noexcept
-    {
-        return *ptr;
-    }
-
-    T* operator->() const noexcept
-    {
-        return ptr;
-    }
-
-    template<typename U>
-    bool operator==(NotNull<U> other) const noexcept
-    {
-        return get() == other.get();
-    }
-
-    template<typename U>
-    bool operator!=(NotNull<U> other) const noexcept
-    {
-        return get() != other.get();
-    }
-
-    operator bool() const noexcept = delete;
-
-    T& operator[](int) = delete;
-
-    T& operator+(int) = delete;
-    T& operator-(int) = delete;
-
-    T* get() const noexcept
-    {
-        return ptr;
-    }
-
-private:
-    T* ptr;
-};
-
-} // namespace Luau
-
-namespace std
-{
-
-template<typename T>
-struct hash<Luau::NotNull<T>>
-{
-    size_t operator()(const Luau::NotNull<T>& p) const
-    {
-        return std::hash<T*>()(p.get());
-    }
-};
-
-} // namespace std

Analysis/include/Luau/OverloadResolution.h

@@ -1,127 +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/Ast.h"
-#include "Luau/EqSatSimplification.h"
-#include "Luau/Error.h"
-#include "Luau/InsertionOrderedMap.h"
-#include "Luau/Location.h"
-#include "Luau/NotNull.h"
-#include "Luau/Subtyping.h"
-#include "Luau/TypeFwd.h"
-
-namespace Luau
-{
-
-struct BuiltinTypes;
-struct TypeArena;
-struct Scope;
-struct InternalErrorReporter;
-struct TypeCheckLimits;
-struct Subtyping;
-
-class Normalizer;
-
-struct OverloadResolver
-{
-    enum Analysis
-    {
-        Ok,
-        TypeIsNotAFunction,
-        ArityMismatch,
-        OverloadIsNonviable, // Arguments were incompatible with the overloads parameters but were otherwise compatible by arity
-    };
-
-    OverloadResolver(
-        NotNull<BuiltinTypes> builtinTypes,
-        NotNull<TypeArena> arena,
-        NotNull<Simplifier> simplifier,
-        NotNull<Normalizer> normalizer,
-        NotNull<TypeFunctionRuntime> typeFunctionRuntime,
-        NotNull<Scope> scope,
-        NotNull<InternalErrorReporter> reporter,
-        NotNull<TypeCheckLimits> limits,
-        Location callLocation
-    );
-
-    NotNull<BuiltinTypes> builtinTypes;
-    NotNull<TypeArena> arena;
-    NotNull<Simplifier> simplifier;
-    NotNull<Normalizer> normalizer;
-    NotNull<TypeFunctionRuntime> typeFunctionRuntime;
-    NotNull<Scope> scope;
-    NotNull<InternalErrorReporter> ice;
-    NotNull<TypeCheckLimits> limits;
-    Subtyping subtyping;
-    Location callLoc;
-
-    // Resolver results
-    std::vector<TypeId> ok;
-    std::vector<TypeId> nonFunctions;
-    std::vector<std::pair<TypeId, ErrorVec>> arityMismatches;
-    std::vector<std::pair<TypeId, ErrorVec>> nonviableOverloads;
-    InsertionOrderedMap<TypeId, std::pair<OverloadResolver::Analysis, size_t>> resolution;
-
-
-    std::pair<OverloadResolver::Analysis, TypeId> selectOverload(TypeId ty, TypePackId args);
-    void resolve(TypeId fnTy, const TypePack* args, AstExpr* selfExpr, const std::vector<AstExpr*>* argExprs);
-
-private:
-    std::optional<ErrorVec> testIsSubtype(const Location& location, TypeId subTy, TypeId superTy);
-    std::optional<ErrorVec> testIsSubtype(const Location& location, TypePackId subTy, TypePackId superTy);
-    std::pair<Analysis, ErrorVec> checkOverload(
-        TypeId fnTy,
-        const TypePack* args,
-        AstExpr* fnLoc,
-        const std::vector<AstExpr*>* argExprs,
-        bool callMetamethodOk = true
-    );
-    static bool isLiteral(AstExpr* expr);
-    LUAU_NOINLINE
-    std::pair<Analysis, ErrorVec> checkOverload_(
-        TypeId fnTy,
-        const FunctionType* fn,
-        const TypePack* args,
-        AstExpr* fnExpr,
-        const std::vector<AstExpr*>* argExprs
-    );
-    size_t indexof(Analysis analysis);
-    void add(Analysis analysis, TypeId ty, ErrorVec&& errors);
-};
-
-struct SolveResult
-{
-    enum OverloadCallResult
-    {
-        Ok,
-        CodeTooComplex,
-        OccursCheckFailed,
-        NoMatchingOverload,
-    };
-
-    OverloadCallResult result;
-    std::optional<TypePackId> typePackId; // nullopt if result != Ok
-
-    TypeId overloadToUse = nullptr;
-    TypeId inferredTy = nullptr;
-    DenseHashMap<TypeId, std::vector<TypeId>> expandedFreeTypes{nullptr};
-};
-
-// Helper utility, presently used for binary operator type functions.
-//
-// Given a function and a set of arguments, select a suitable overload.
-SolveResult solveFunctionCall(
-    NotNull<TypeArena> arena,
-    NotNull<BuiltinTypes> builtinTypes,
-    NotNull<Simplifier> simplifier,
-    NotNull<Normalizer> normalizer,
-    NotNull<TypeFunctionRuntime> typeFunctionRuntime,
-    NotNull<InternalErrorReporter> iceReporter,
-    NotNull<TypeCheckLimits> limits,
-    NotNull<Scope> scope,
-    const Location& location,
-    TypeId fn,
-    TypePackId argsPack
-);
-
-} // namespace Luau

Analysis/include/Luau/Polarity.h

@@ -1,68 +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 <cstdint>
-
-namespace Luau
-{
-
-enum struct Polarity : uint8_t
-{
-    None = 0b000,
-    Positive = 0b001,
-    Negative = 0b010,
-    Mixed = 0b011,
-    Unknown = 0b100,
-};
-
-inline Polarity operator|(Polarity lhs, Polarity rhs)
-{
-    return Polarity(uint8_t(lhs) | uint8_t(rhs));
-}
-
-inline Polarity& operator|=(Polarity& lhs, Polarity rhs)
-{
-    lhs = lhs | rhs;
-    return lhs;
-}
-
-inline Polarity operator&(Polarity lhs, Polarity rhs)
-{
-    return Polarity(uint8_t(lhs) & uint8_t(rhs));
-}
-
-inline Polarity& operator&=(Polarity& lhs, Polarity rhs)
-{
-    lhs = lhs & rhs;
-    return lhs;
-}
-
-inline bool isPositive(Polarity p)
-{
-    return bool(p & Polarity::Positive);
-}
-
-inline bool isNegative(Polarity p)
-{
-    return bool(p & Polarity::Negative);
-}
-
-inline bool isKnown(Polarity p)
-{
-    return p != Polarity::Unknown;
-}
-
-inline Polarity invert(Polarity p)
-{
-    switch (p)
-    {
-    case Polarity::Positive:
-        return Polarity::Negative;
-    case Polarity::Negative:
-        return Polarity::Positive;
-    default:
-        return p;
-    }
-}
-
-} // namespace Luau

Analysis/include/Luau/Predicate.h

@@ -1,16 +1,48 @@
 // 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 "Luau/LValue.h"
 #include "Luau/Variant.h"
-#include "Luau/TypeFwd.h"
+#include "Luau/Location.h"
+#include "Luau/Symbol.h"
 
+#include <map>
+#include <memory>
 #include <vector>
 
 namespace Luau
 {
 
+struct TypeVar;
+using TypeId = const TypeVar*;
+
+struct Field;
+using LValue = Variant<Symbol, Field>;
+
+struct Field
+{
+    std::shared_ptr<LValue> parent; // TODO: Eventually use unique_ptr to enforce non-copyable trait.
+    std::string key;
+};
+
+std::optional<LValue> tryGetLValue(const class AstExpr& expr);
+
+// Utility function: breaks down an LValue to get at the Symbol, and reverses the vector of keys.
+std::pair<Symbol, std::vector<std::string>> getFullName(const LValue& lvalue);
+
+std::string toString(const LValue& lvalue);
+
+template<typename T>
+const T* get(const LValue& lvalue)
+{
+    return get_if<T>(&lvalue);
+}
+
+// Key is a stringified encoding of an LValue.
+using RefinementMap = std::map<std::string, TypeId>;
+
+void merge(RefinementMap& l, const RefinementMap& r, std::function<TypeId(TypeId, TypeId)> f);
+void addRefinement(RefinementMap& refis, const LValue& lvalue, TypeId ty);
+
 struct TruthyPredicate;
 struct IsAPredicate;
 struct TypeGuardPredicate;
@@ -55,7 +87,11 @@ struct AndPredicate
     PredicateVec lhs;
     PredicateVec rhs;
 
-    AndPredicate(PredicateVec&& lhs, PredicateVec&& rhs);
+    AndPredicate(PredicateVec&& lhs, PredicateVec&& rhs)
+        : lhs(std::move(lhs))
+        , rhs(std::move(rhs))
+    {
+    }
 };
 
 struct OrPredicate
@@ -63,7 +99,11 @@ struct OrPredicate
     PredicateVec lhs;
     PredicateVec rhs;
 
-    OrPredicate(PredicateVec&& lhs, PredicateVec&& rhs);
+    OrPredicate(PredicateVec&& lhs, PredicateVec&& rhs)
+        : lhs(std::move(lhs))
+        , rhs(std::move(rhs))
+    {
+    }
 };
 
 struct NotPredicate
@@ -71,19 +111,6 @@ struct NotPredicate
     PredicateVec predicates;
 };
 
-// Outside definition works around clang 15 issue where vector instantiation is triggered while Predicate is still incomplete
-inline AndPredicate::AndPredicate(PredicateVec&& lhs, PredicateVec&& rhs)
-    : lhs(std::move(lhs))
-    , rhs(std::move(rhs))
-{
-}
-
-inline OrPredicate::OrPredicate(PredicateVec&& lhs, PredicateVec&& rhs)
-    : lhs(std::move(lhs))
-    , rhs(std::move(rhs))
-{
-}
-
 template<typename T>
 const T* get(const Predicate& predicate)
 {

Analysis/include/Luau/Quantify.h

@@ -1,34 +1,14 @@
 // This file is part of the Luau programming language and is licensed under MIT License; see LICENSE.txt for details
 #pragma once
 
-#include "Luau/TypeFwd.h"
-#include "Luau/DenseHash.h"
-#include "Luau/Unifiable.h"
-
-#include <vector>
-#include <optional>
+#include "Luau/TypeVar.h"
 
 namespace Luau
 {
 
-struct TypeArena;
-struct Scope;
+struct Module;
+using ModulePtr = std::shared_ptr<Module>;
 
-void quantify(TypeId ty, TypeLevel level);
-
-// TODO: This is eerily similar to the pattern that NormalizedExternType
-// implements. We could, and perhaps should, merge them together.
-template<typename K, typename V>
-struct OrderedMap
-{
-    std::vector<K> keys;
-    DenseHashMap<K, V> pairings{nullptr};
-
-    void push(K k, V v)
-    {
-        keys.push_back(k);
-        pairings[k] = v;
-    }
-};
+void quantify(ModulePtr module, TypeId ty, TypeLevel level);
 
 } // namespace Luau

Analysis/include/Luau/RecursionCounter.h

@@ -2,22 +2,12 @@
 #pragma once
 
 #include "Luau/Common.h"
-#include "Luau/Error.h"
 
 #include <stdexcept>
-#include <exception>
 
 namespace Luau
 {
 
-struct RecursionLimitException : public InternalCompilerError
-{
-    RecursionLimitException()
-        : InternalCompilerError("Internal recursion counter limit exceeded")
-    {
-    }
-};
-
 struct RecursionCounter
 {
     RecursionCounter(int* count)
@@ -32,7 +22,7 @@ struct RecursionCounter
         --(*count);
     }
 
-protected:
+private:
     int* count;
 };
 
@@ -42,9 +32,7 @@ struct RecursionLimiter : RecursionCounter
         : RecursionCounter(count)
     {
         if (limit > 0 && *count > limit)
-        {
-            throw RecursionLimitException();
-        }
+            throw std::runtime_error("Internal recursion counter limit exceeded");
     }
 };
 

Analysis/include/Luau/Refinement.h

@@ -1,79 +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/NotNull.h"
-#include "Luau/TypedAllocator.h"
-#include "Luau/Variant.h"
-#include "Luau/TypeFwd.h"
-
-namespace Luau
-{
-
-struct RefinementKey;
-using DefId = NotNull<const struct Def>;
-
-struct Variadic;
-struct Negation;
-struct Conjunction;
-struct Disjunction;
-struct Equivalence;
-struct Proposition;
-using Refinement = Variant<Variadic, Negation, Conjunction, Disjunction, Equivalence, Proposition>;
-using RefinementId = Refinement*; // Can and most likely is nullptr.
-
-struct Variadic
-{
-    std::vector<RefinementId> refinements;
-};
-
-struct Negation
-{
-    RefinementId refinement;
-};
-
-struct Conjunction
-{
-    RefinementId lhs;
-    RefinementId rhs;
-};
-
-struct Disjunction
-{
-    RefinementId lhs;
-    RefinementId rhs;
-};
-
-struct Equivalence
-{
-    RefinementId lhs;
-    RefinementId rhs;
-};
-
-struct Proposition
-{
-    const RefinementKey* key;
-    TypeId discriminantTy;
-    bool implicitFromCall;
-};
-
-template<typename T>
-const T* get(RefinementId refinement)
-{
-    return get_if<T>(refinement);
-}
-
-struct RefinementArena
-{
-    RefinementId variadic(const std::vector<RefinementId>& refis);
-    RefinementId negation(RefinementId refinement);
-    RefinementId conjunction(RefinementId lhs, RefinementId rhs);
-    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;
-};
-
-} // namespace Luau

Analysis/include/Luau/RequireTracer.h

@@ -6,19 +6,20 @@
 #include "Luau/Location.h"
 
 #include <string>
-#include <vector>
 
 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;
+    std::vector<std::pair<ModuleName, Location>> requires;
 };
 
 RequireTraceResult traceRequires(FileResolver* fileResolver, AstStatBlock* root, const ModuleName& currentModuleName);

Analysis/include/Luau/Scope.h

@@ -1,14 +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 "Luau/Def.h"
-#include "Luau/LValue.h"
 #include "Luau/Location.h"
-#include "Luau/NotNull.h"
-#include "Luau/Type.h"
-#include "Luau/DenseHash.h"
-#include "Luau/Symbol.h"
-#include "Luau/Unifiable.h"
+#include "Luau/TypeVar.h"
 
 #include <unordered_map>
 #include <optional>
@@ -35,89 +29,39 @@ 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
-
-    // All the children of this scope.
-    std::vector<NotNull<Scope>> children;
+    const ScopePtr parent; // null for the root
     std::unordered_map<Symbol, Binding> bindings;
-    TypePackId returnType = nullptr;
+    TypePackId returnType;
+    bool breakOk = false;
     std::optional<TypePackId> varargPack;
 
     TypeLevel level;
 
-    Location location; // the spanning location associated with this scope
-
     std::unordered_map<Name, TypeFun> exportedTypeBindings;
     std::unordered_map<Name, TypeFun> privateTypeBindings;
     std::unordered_map<Name, Location> typeAliasLocations;
-    std::unordered_map<Name, Location> typeAliasNameLocations;
-    std::unordered_map<Name, ModuleName> importedModules; // Mapping from the name in the require statement to the internal moduleName.
+
     std::unordered_map<Name, std::unordered_map<Name, TypeFun>> importedTypeBindings;
 
-    DenseHashSet<Name> builtinTypeNames{""};
-    void addBuiltinTypeBinding(const Name& name, const TypeFun& tyFun);
+    std::optional<TypeId> lookup(const Symbol& name);
 
-    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);
-
-    std::optional<TypeFun> lookupType(const Name& name) const;
-    std::optional<TypeFun> lookupImportedType(const Name& moduleAlias, const Name& name) const;
+    std::optional<TypeFun> lookupType(const Name& name);
+    std::optional<TypeFun> lookupImportedType(const Name& moduleAlias, const Name& name);
 
     std::unordered_map<Name, TypePackId> privateTypePackBindings;
-    std::optional<TypePackId> lookupPack(const Name& name) const;
+    std::optional<TypePackId> lookupPack(const Name& name);
 
     // 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;
+    std::optional<Binding> linearSearchForBinding(const std::string& name, bool traverseScopeChain = true);
 
     RefinementMap refinements;
 
-    // This can be viewed as the "unrefined" type of each binding.
-    DenseHashMap<const Def*, TypeId> lvalueTypes{nullptr};
-
-    // Luau values are routinely refined more narrowly than their actual
-    // inferred type through control flow statements.  We retain those refined
-    // types here.
-    DenseHashMap<const Def*, TypeId> rvalueRefinements{nullptr};
-
-    void inheritAssignments(const ScopePtr& childScope);
-    void inheritRefinements(const ScopePtr& childScope);
-
-    // Track globals that should emit warnings during type checking.
-    DenseHashSet<std::string> globalsToWarn{""};
-    bool shouldWarnGlobal(std::string name) const;
-
     // For mutually recursive type aliases, it's important that
     // they use the same types for the same names.
     // For instance, in `type Tree<T> { data: T, children: Forest<T> } type Forest<T> = {Tree<T>}`
     // we need that the generic type `T` in both cases is the same, so we use a cache.
     std::unordered_map<Name, TypeId> typeAliasTypeParameters;
     std::unordered_map<Name, TypePackId> typeAliasTypePackParameters;
-
-    std::optional<std::vector<TypeId>> interiorFreeTypes;
-    std::optional<std::vector<TypePackId>> interiorFreeTypePacks;
 };
 
-// Returns true iff the left scope encloses the right scope.  A Scope* equal to
-// nullptr is considered to be the outermost-possible scope.
-bool subsumesStrict(Scope* left, Scope* right);
-
-// Returns true if the left scope encloses the right scope, or if they are the
-// same scope.  As in subsumesStrict(), nullptr is considered to be the
-// outermost-possible scope.
-bool subsumes(Scope* left, Scope* right);
-
-inline Scope* max(Scope* left, Scope* right)
-{
-    if (subsumes(left, right))
-        return right;
-    else
-        return left;
-}
-
 } // namespace Luau

Analysis/include/Luau/Set.h

@@ -1,194 +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/Common.h"
-#include "Luau/DenseHash.h"
-
-LUAU_FASTFLAG(LuauSolverV2)
-
-namespace Luau
-{
-
-template<typename T>
-using SetHashDefault = std::conditional_t<std::is_pointer_v<T>, DenseHashPointer, std::hash<T>>;
-
-// This is an implementation of `unordered_set` using `DenseHashMap<T, bool>` to support erasure.
-// This lets us work around `DenseHashSet` limitations and get a more traditional set interface.
-template<typename T, typename Hash = SetHashDefault<T>>
-class Set
-{
-private:
-    using Impl = DenseHashMap<T, bool, Hash>;
-    Impl mapping;
-    size_t entryCount = 0;
-
-public:
-    class const_iterator;
-    using iterator = const_iterator;
-
-    Set(const T& empty_key)
-        : mapping{empty_key}
-    {
-    }
-
-    bool insert(const T& element)
-    {
-        bool& entry = mapping[element];
-        bool fresh = !entry;
-
-        if (fresh)
-        {
-            entry = true;
-            entryCount++;
-        }
-
-        return fresh;
-    }
-
-    template<class Iterator>
-    void insert(Iterator begin, Iterator end)
-    {
-        for (Iterator it = begin; it != end; ++it)
-            insert(*it);
-    }
-
-    void erase(T&& element)
-    {
-        bool& entry = mapping[element];
-
-        if (entry)
-        {
-            entry = false;
-            entryCount--;
-        }
-    }
-
-    void erase(const T& element)
-    {
-        bool& entry = mapping[element];
-
-        if (entry)
-        {
-            entry = false;
-            entryCount--;
-        }
-    }
-
-    void clear()
-    {
-        mapping.clear();
-        entryCount = 0;
-    }
-
-    size_t size() const
-    {
-        return entryCount;
-    }
-
-    bool empty() const
-    {
-        return entryCount == 0;
-    }
-
-    size_t count(const T& element) const
-    {
-        const bool* entry = mapping.find(element);
-        return (entry && *entry) ? 1 : 0;
-    }
-
-    bool contains(const T& element) const
-    {
-        return count(element) != 0;
-    }
-
-    const_iterator begin() const
-    {
-        return const_iterator(mapping.begin(), mapping.end());
-    }
-
-    const_iterator end() const
-    {
-        return const_iterator(mapping.end(), mapping.end());
-    }
-
-    bool operator==(const Set<T>& there) const
-    {
-        // if the sets are unequal sizes, then they cannot possibly be equal.
-        if (size() != there.size())
-            return false;
-
-        // otherwise, we'll need to check that every element we have here is in `there`.
-        for (auto [elem, present] : mapping)
-        {
-            // if it's not, we'll return `false`
-            if (present && there.contains(elem))
-                return false;
-        }
-
-        // otherwise, we've proven the two equal!
-        return true;
-    }
-
-    class const_iterator
-    {
-    public:
-        using value_type = T;
-        using reference = T&;
-        using pointer = T*;
-        using difference_type = ptrdiff_t;
-        using iterator_category = std::forward_iterator_tag;
-
-        const_iterator(typename Impl::const_iterator impl_, typename Impl::const_iterator end_)
-            : impl(impl_)
-            , end(end_)
-        {
-            while (impl != end && impl->second == false)
-                ++impl;
-        }
-
-        const T& operator*() const
-        {
-            return impl->first;
-        }
-
-        const T* operator->() const
-        {
-            return &impl->first;
-        }
-
-        bool operator==(const const_iterator& other) const
-        {
-            return impl == other.impl;
-        }
-
-        bool operator!=(const const_iterator& other) const
-        {
-            return impl != other.impl;
-        }
-
-
-        const_iterator& operator++()
-        {
-            do
-            {
-                impl++;
-            } while (impl != end && impl->second == false);
-            // keep iterating past pairs where the value is `false`
-
-            return *this;
-        }
-
-        const_iterator operator++(int)
-        {
-            const_iterator res = *this;
-            ++*this;
-            return res;
-        }
-
-    private:
-        typename Impl::const_iterator impl;
-        typename Impl::const_iterator end;
-    };
-};
-
-} // namespace Luau

Analysis/include/Luau/Simplify.h

@@ -1,41 +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/DenseHash.h"
-#include "Luau/NotNull.h"
-#include "Luau/TypeFwd.h"
-#include <set>
-
-namespace Luau
-{
-
-struct TypeArena;
-
-struct SimplifyResult
-{
-    TypeId result;
-
-    DenseHashSet<TypeId> blockedTypes;
-};
-
-SimplifyResult simplifyIntersection(NotNull<BuiltinTypes> builtinTypes, NotNull<TypeArena> arena, TypeId left, TypeId right);
-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 simplifyIntersectWithTruthy(NotNull<BuiltinTypes> builtinTypes, NotNull<TypeArena> arena, TypeId target);
-SimplifyResult simplifyIntersectWithFalsy(NotNull<BuiltinTypes> builtinTypes, NotNull<TypeArena> arena, TypeId target);
-
-enum class Relation
-{
-    Disjoint,   // No A is a B or vice versa
-    Coincident, // Every A is in B and vice versa
-    Intersects, // Some As are in B and some Bs are in A.  ex (number | string) <-> (string | boolean)
-    Subset,     // Every A is in B
-    Superset,   // Every B is in A
-};
-
-Relation relate(TypeId left, TypeId right);
-
-} // namespace Luau

Analysis/include/Luau/Substitution.h

@@ -1,8 +1,10 @@
 // This file is part of the Luau programming language and is licensed under MIT License; see LICENSE.txt for details
 #pragma once
 
-#include "Luau/TypeArena.h"
-#include "Luau/TypeFwd.h"
+#include "Luau/Module.h"
+#include "Luau/ModuleResolver.h"
+#include "Luau/TypePack.h"
+#include "Luau/TypeVar.h"
 #include "Luau/DenseHash.h"
 
 // We provide an implementation of substitution on types,
@@ -53,8 +55,6 @@
 namespace Luau
 {
 
-struct TxnLog;
-
 enum class TarjanResult
 {
     TooManyChildren,
@@ -68,50 +68,36 @@ struct TarjanWorklistVertex
     int lastEdge;
 };
 
-struct TarjanNode
-{
-    TypeId ty;
-    TypePackId tp;
-
-    bool onStack;
-    bool dirty;
-
-    // Tarjan calculates the lowlink for each vertex,
-    // which is the lowest ancestor index reachable from the vertex.
-    int lowlink;
-};
-
 // Tarjan's algorithm for finding the SCCs in a cyclic structure.
 // https://en.wikipedia.org/wiki/Tarjan%27s_strongly_connected_components_algorithm
 struct Tarjan
 {
-    Tarjan();
-    virtual ~Tarjan() = default;
-
     // Vertices (types and type packs) are indexed, using pre-order traversal.
     DenseHashMap<TypeId, int> typeToIndex{nullptr};
     DenseHashMap<TypePackId, int> packToIndex{nullptr};
-
-    std::vector<TarjanNode> nodes;
+    std::vector<TypeId> indexToType;
+    std::vector<TypePackId> indexToPack;
 
     // Tarjan keeps a stack of vertices where we're still in the process
     // of finding their SCC.
     std::vector<int> stack;
+    std::vector<bool> onStack;
+
+    // Tarjan calculates the lowlink for each vertex,
+    // which is the lowest ancestor index reachable from the vertex.
+    std::vector<int> lowlink;
 
     int childCount = 0;
-    int childLimit = 0;
-
-    // This should never be null; ensure you initialize it before calling
-    // substitution methods.
-    const TxnLog* log = nullptr;
 
     std::vector<TypeId> edgesTy;
     std::vector<TypePackId> edgesTp;
     std::vector<TarjanWorklistVertex> worklist;
-
     // This is hot code, so we optimize recursion to a stack.
     TarjanResult loop();
 
+    // Clear the state
+    void clear();
+
     // Find or create the index for a vertex.
     // Return a boolean which is `true` if it's a freshly created index.
     std::pair<int, bool> indexify(TypeId ty);
@@ -122,21 +108,33 @@ struct Tarjan
     void visitChildren(TypePackId tp, int index);
 
     void visitChild(TypeId ty);
-    void visitChild(TypePackId tp);
-
-    template<typename Ty>
-    void visitChild(std::optional<Ty> ty)
-    {
-        if (ty)
-            visitChild(*ty);
-    }
+    void visitChild(TypePackId ty);
 
     // Visit the root vertex.
     TarjanResult visitRoot(TypeId ty);
-    TarjanResult visitRoot(TypePackId tp);
+    TarjanResult visitRoot(TypePackId ty);
 
-    // Used to reuse the object for a new operation
-    void clearTarjan(const TxnLog* log);
+    // Each subclass gets called back once for each edge,
+    // and once for each SCC.
+    virtual void visitEdge(int index, int parentIndex) {}
+    virtual void visitSCC(int index) {}
+
+    // Each subclass can decide to ignore some nodes.
+    virtual bool ignoreChildren(TypeId ty)
+    {
+        return false;
+    }
+    virtual bool ignoreChildren(TypePackId ty)
+    {
+        return false;
+    }
+};
+
+// We use Tarjan to calculate dirty bits. We set `dirty[i]` true
+// if the vertex with index `i` can reach a dirty vertex.
+struct FindDirty : Tarjan
+{
+    std::vector<bool> dirty;
 
     // Get/set the dirty bit for an index (grows the vector if needed)
     bool getDirty(int index);
@@ -147,16 +145,8 @@ struct Tarjan
     TarjanResult findDirty(TypePackId t);
 
     // We find dirty vertices using Tarjan
-    void visitEdge(int index, int parentIndex);
-    void visitSCC(int index);
-
-    // Each subclass can decide to ignore some nodes.
-    virtual bool ignoreChildren(TypeId ty);
-    virtual bool ignoreChildren(TypePackId ty);
-
-    // Some subclasses might ignore children visit, but not other actions like replacing the children
-    virtual bool ignoreChildrenVisit(TypeId ty);
-    virtual bool ignoreChildrenVisit(TypePackId ty);
+    void visitEdge(int index, int parentIndex) override;
+    void visitSCC(int index) override;
 
     // Subclasses should say which vertices are dirty,
     // and what to do with dirty vertices.
@@ -168,47 +158,19 @@ struct Tarjan
 
 // And finally substitution, which finds all the reachable dirty vertices
 // and replaces them with clean ones.
-struct Substitution : Tarjan
+struct Substitution : FindDirty
 {
-protected:
-    explicit Substitution(TypeArena* arena);
-    Substitution(const TxnLog* log_, TypeArena* arena);
-
-    /*
-     * By default, Substitution assumes that the types produced by clean() are
-     * freshly allocated types that are safe to mutate.
-     *
-     * If your clean() implementation produces a type that is not safe to
-     * mutate, you must call dontTraverseInto on this type (or type pack) to
-     * prevent Substitution from attempting to perform substitutions within the
-     * cleaned type.
-     *
-     * See the test weird_cyclic_instantiation for an example.
-     */
-    void dontTraverseInto(TypeId ty);
-    void dontTraverseInto(TypePackId tp);
-
-public:
-    TypeArena* arena;
+    ModulePtr currentModule;
     DenseHashMap<TypeId, TypeId> newTypes{nullptr};
     DenseHashMap<TypePackId, TypePackId> newPacks{nullptr};
-    DenseHashSet<TypeId> replacedTypes{nullptr};
-    DenseHashSet<TypePackId> replacedTypePacks{nullptr};
-
-    DenseHashSet<TypeId> noTraverseTypes{nullptr};
-    DenseHashSet<TypePackId> noTraverseTypePacks{nullptr};
 
     std::optional<TypeId> substitute(TypeId ty);
     std::optional<TypePackId> substitute(TypePackId tp);
 
-    void resetState(const TxnLog* log, TypeArena* arena);
-
     TypeId replace(TypeId ty);
     TypePackId replace(TypePackId tp);
-
     void replaceChildren(TypeId ty);
     void replaceChildren(TypePackId tp);
-
     TypeId clone(TypeId ty);
     TypePackId clone(TypePackId tp);
 
@@ -220,23 +182,17 @@ public:
     virtual TypeId clean(TypeId ty) = 0;
     virtual TypePackId clean(TypePackId tp) = 0;
 
-protected:
     // Helper functions to create new types (used by subclasses)
     template<typename T>
-    TypeId addType(T tv)
+    TypeId addType(const T& tv)
     {
-        return arena->addType(std::move(tv));
+        return currentModule->internalTypes.addType(tv);
     }
-
     template<typename T>
-    TypePackId addTypePack(T tp)
+    TypePackId addTypePack(const T& tp)
     {
-        return arena->addTypePack(TypePackVar{std::move(tp)});
+        return currentModule->internalTypes.addTypePack(TypePackVar{tp});
     }
-
-private:
-    template<typename Ty>
-    std::optional<Ty> replace(std::optional<Ty> ty);
 };
 
 } // namespace Luau

Analysis/include/Luau/Subtyping.h

@@ -1,313 +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/DenseHash.h"
-#include "Luau/EqSatSimplification.h"
-#include "Luau/Set.h"
-#include "Luau/TypeCheckLimits.h"
-#include "Luau/TypeFunction.h"
-#include "Luau/TypeFwd.h"
-#include "Luau/TypePairHash.h"
-#include "Luau/TypePath.h"
-
-#include <vector>
-#include <optional>
-
-namespace Luau
-{
-
-template<typename A, typename B>
-struct TryPair;
-struct InternalErrorReporter;
-
-class TypeIds;
-class Normalizer;
-struct NormalizedExternType;
-struct NormalizedFunctionType;
-struct NormalizedStringType;
-struct NormalizedType;
-struct Property;
-struct Scope;
-struct TableIndexer;
-struct TypeArena;
-struct TypeCheckLimits;
-
-enum class SubtypingVariance
-{
-    // Used for an empty key. Should never appear in actual code.
-    Invalid,
-    Covariant,
-    // This is used to identify cases where we have a covariant + a
-    // contravariant reason and we need to merge them.
-    Contravariant,
-    Invariant,
-};
-
-struct SubtypingReasoning
-{
-    // The path, relative to the _root subtype_, where subtyping failed.
-    Path subPath;
-    // The path, relative to the _root supertype_, where subtyping failed.
-    Path superPath;
-    SubtypingVariance variance = SubtypingVariance::Covariant;
-
-    bool operator==(const SubtypingReasoning& other) const;
-};
-
-struct SubtypingReasoningHash
-{
-    size_t operator()(const SubtypingReasoning& r) const;
-};
-
-using SubtypingReasonings = DenseHashSet<SubtypingReasoning, SubtypingReasoningHash>;
-static const SubtypingReasoning kEmptyReasoning = SubtypingReasoning{TypePath::kEmpty, TypePath::kEmpty, SubtypingVariance::Invalid};
-
-struct SubtypingResult
-{
-    bool isSubtype = false;
-    bool normalizationTooComplex = false;
-    bool isCacheable = true;
-    ErrorVec errors;
-    /// The reason for isSubtype to be false. May not be present even if
-    /// isSubtype is false, depending on the input types.
-    SubtypingReasonings reasoning{kEmptyReasoning};
-
-    SubtypingResult& andAlso(const SubtypingResult& other);
-    SubtypingResult& orElse(const SubtypingResult& other);
-    SubtypingResult& withBothComponent(TypePath::Component component);
-    SubtypingResult& withSuperComponent(TypePath::Component component);
-    SubtypingResult& withSubComponent(TypePath::Component component);
-    SubtypingResult& withBothPath(TypePath::Path path);
-    SubtypingResult& withSubPath(TypePath::Path path);
-    SubtypingResult& withSuperPath(TypePath::Path path);
-    SubtypingResult& withErrors(ErrorVec& err);
-    SubtypingResult& withError(TypeError err);
-
-    // Only negates the `isSubtype`.
-    static SubtypingResult negate(const SubtypingResult& result);
-    static SubtypingResult all(const std::vector<SubtypingResult>& results);
-    static SubtypingResult any(const std::vector<SubtypingResult>& results);
-};
-
-struct SubtypingEnvironment
-{
-    struct GenericBounds
-    {
-        DenseHashSet<TypeId> lowerBound{nullptr};
-        DenseHashSet<TypeId> upperBound{nullptr};
-    };
-
-    /* For nested subtyping relationship tests of mapped generic bounds, we keep the outer environment immutable */
-    SubtypingEnvironment* parent = nullptr;
-
-    /// Applies `mappedGenerics` to the given type.
-    /// This is used specifically to substitute for generics in type function instances.
-    std::optional<TypeId> applyMappedGenerics(NotNull<BuiltinTypes> builtinTypes, NotNull<TypeArena> arena, TypeId ty);
-
-    const TypeId* tryFindSubstitution(TypeId ty) const;
-    const SubtypingResult* tryFindSubtypingResult(std::pair<TypeId, TypeId> subAndSuper) const;
-
-    bool containsMappedType(TypeId ty) const;
-    bool containsMappedPack(TypePackId tp) const;
-
-    GenericBounds& getMappedTypeBounds(TypeId ty);
-    TypePackId* getMappedPackBounds(TypePackId tp);
-
-    /*
-     * When we encounter a generic over the course of a subtyping test, we need
-     * to tentatively map that generic onto a type on the other side.
-     */
-    DenseHashMap<TypeId, GenericBounds> mappedGenerics{nullptr};
-    DenseHashMap<TypePackId, TypePackId> mappedGenericPacks{nullptr};
-
-    /*
-     * See the test cyclic_tables_are_assumed_to_be_compatible_with_extern_types for
-     * details.
-     *
-     * An empty value is equivalent to a nonexistent key.
-     */
-    DenseHashMap<TypeId, TypeId> substitutions{nullptr};
-
-    DenseHashMap<std::pair<TypeId, TypeId>, SubtypingResult, TypePairHash> ephemeralCache{{}};
-};
-
-struct Subtyping
-{
-    NotNull<BuiltinTypes> builtinTypes;
-    NotNull<TypeArena> arena;
-    NotNull<Simplifier> simplifier;
-    NotNull<Normalizer> normalizer;
-    NotNull<TypeFunctionRuntime> typeFunctionRuntime;
-    NotNull<InternalErrorReporter> iceReporter;
-
-    TypeCheckLimits limits;
-
-    enum class Variance
-    {
-        Covariant,
-        Contravariant
-    };
-
-    Variance variance = Variance::Covariant;
-
-    using SeenSet = Set<std::pair<TypeId, TypeId>, TypePairHash>;
-
-    SeenSet seenTypes{{}};
-
-    Subtyping(
-        NotNull<BuiltinTypes> builtinTypes,
-        NotNull<TypeArena> typeArena,
-        NotNull<Simplifier> simplifier,
-        NotNull<Normalizer> normalizer,
-        NotNull<TypeFunctionRuntime> typeFunctionRuntime,
-        NotNull<InternalErrorReporter> iceReporter
-    );
-
-    Subtyping(const Subtyping&) = delete;
-    Subtyping& operator=(const Subtyping&) = delete;
-
-    Subtyping(Subtyping&&) = default;
-    Subtyping& operator=(Subtyping&&) = default;
-
-    // Only used by unit tests to test that the cache works.
-    const DenseHashMap<std::pair<TypeId, TypeId>, SubtypingResult, TypePairHash>& peekCache() const
-    {
-        return resultCache;
-    }
-
-    // TODO cache
-    // TODO cyclic types
-    // TODO recursion limits
-
-    SubtypingResult isSubtype(TypeId subTy, TypeId superTy, NotNull<Scope> scope);
-    SubtypingResult isSubtype(TypePackId subTy, TypePackId superTy, NotNull<Scope> scope);
-
-private:
-    DenseHashMap<std::pair<TypeId, TypeId>, SubtypingResult, TypePairHash> resultCache{{}};
-
-    SubtypingResult cache(SubtypingEnvironment& env, SubtypingResult res, TypeId subTy, TypeId superTy);
-
-    SubtypingResult isCovariantWith(SubtypingEnvironment& env, TypeId subTy, TypeId superTy, NotNull<Scope> scope);
-    SubtypingResult isCovariantWith(SubtypingEnvironment& env, TypePackId subTp, TypePackId superTp, NotNull<Scope> scope);
-
-    template<typename SubTy, typename SuperTy>
-    SubtypingResult isContravariantWith(SubtypingEnvironment& env, SubTy&& subTy, SuperTy&& superTy, NotNull<Scope> scope);
-
-    template<typename SubTy, typename SuperTy>
-    SubtypingResult isInvariantWith(SubtypingEnvironment& env, SubTy&& subTy, SuperTy&& superTy, NotNull<Scope> scope);
-
-    template<typename SubTy, typename SuperTy>
-    SubtypingResult isCovariantWith(SubtypingEnvironment& env, const TryPair<const SubTy*, const SuperTy*>& pair, NotNull<Scope> scope);
-
-    template<typename SubTy, typename SuperTy>
-    SubtypingResult isContravariantWith(SubtypingEnvironment& env, const TryPair<const SubTy*, const SuperTy*>& pair, NotNull<Scope>);
-
-    template<typename SubTy, typename SuperTy>
-    SubtypingResult isInvariantWith(SubtypingEnvironment& env, const TryPair<const SubTy*, const SuperTy*>& pair, NotNull<Scope>);
-
-    SubtypingResult isCovariantWith(SubtypingEnvironment& env, TypeId subTy, const UnionType* superUnion, NotNull<Scope> scope);
-    SubtypingResult isCovariantWith(SubtypingEnvironment& env, const UnionType* subUnion, TypeId superTy, NotNull<Scope> scope);
-    SubtypingResult isCovariantWith(SubtypingEnvironment& env, TypeId subTy, const IntersectionType* superIntersection, NotNull<Scope> scope);
-    SubtypingResult isCovariantWith(SubtypingEnvironment& env, const IntersectionType* subIntersection, TypeId superTy, NotNull<Scope> scope);
-
-    SubtypingResult isCovariantWith(SubtypingEnvironment& env, const NegationType* subNegation, TypeId superTy, NotNull<Scope> scope);
-    SubtypingResult isCovariantWith(SubtypingEnvironment& env, const TypeId subTy, const NegationType* superNegation, NotNull<Scope> scope);
-
-    SubtypingResult isCovariantWith(SubtypingEnvironment& env, const PrimitiveType* subPrim, const PrimitiveType* superPrim, NotNull<Scope> scope);
-    SubtypingResult isCovariantWith(
-        SubtypingEnvironment& env,
-        const SingletonType* subSingleton,
-        const PrimitiveType* superPrim,
-        NotNull<Scope> scope
-    );
-    SubtypingResult isCovariantWith(
-        SubtypingEnvironment& env,
-        const SingletonType* subSingleton,
-        const SingletonType* superSingleton,
-        NotNull<Scope> scope
-    );
-    SubtypingResult isCovariantWith(SubtypingEnvironment& env, const TableType* subTable, const TableType* superTable, NotNull<Scope> scope);
-    SubtypingResult isCovariantWith(SubtypingEnvironment& env, const MetatableType* subMt, const MetatableType* superMt, NotNull<Scope> scope);
-    SubtypingResult isCovariantWith(SubtypingEnvironment& env, const MetatableType* subMt, const TableType* superTable, NotNull<Scope> scope);
-    SubtypingResult isCovariantWith(SubtypingEnvironment& env, const ExternType* subExternType, const ExternType* superExternType, NotNull<Scope> scope);
-    SubtypingResult isCovariantWith(SubtypingEnvironment& env, TypeId subTy, const ExternType* subExternType, TypeId superTy, const TableType* superTable, NotNull<Scope>);
-    SubtypingResult isCovariantWith(
-        SubtypingEnvironment& env,
-        const FunctionType* subFunction,
-        const FunctionType* superFunction,
-        NotNull<Scope> scope
-    );
-    SubtypingResult isCovariantWith(SubtypingEnvironment& env, const TableType* subTable, const PrimitiveType* superPrim, NotNull<Scope> scope);
-    SubtypingResult isCovariantWith(SubtypingEnvironment& env, const PrimitiveType* subPrim, const TableType* superTable, NotNull<Scope> scope);
-    SubtypingResult isCovariantWith(SubtypingEnvironment& env, const SingletonType* subSingleton, const TableType* superTable, NotNull<Scope> scope);
-
-    SubtypingResult isCovariantWith(
-        SubtypingEnvironment& env,
-        const TableIndexer& subIndexer,
-        const TableIndexer& superIndexer,
-        NotNull<Scope> scope
-    );
-    SubtypingResult
-    isCovariantWith(SubtypingEnvironment& env, const Property& subProperty, const Property& superProperty, const std::string& name, NotNull<Scope>);
-
-    SubtypingResult isCovariantWith(
-        SubtypingEnvironment& env,
-        const std::shared_ptr<const NormalizedType>& subNorm,
-        const std::shared_ptr<const NormalizedType>& superNorm,
-        NotNull<Scope> scope
-    );
-    SubtypingResult isCovariantWith(
-        SubtypingEnvironment& env,
-        const NormalizedExternType& subExternType,
-        const NormalizedExternType& superExternType,
-        NotNull<Scope> scope
-    );
-    SubtypingResult isCovariantWith(SubtypingEnvironment& env, const NormalizedExternType& subExternType, const TypeIds& superTables, NotNull<Scope> scope);
-    SubtypingResult isCovariantWith(
-        SubtypingEnvironment& env,
-        const NormalizedStringType& subString,
-        const NormalizedStringType& superString,
-        NotNull<Scope> scope
-    );
-    SubtypingResult isCovariantWith(
-        SubtypingEnvironment& env,
-        const NormalizedStringType& subString,
-        const TypeIds& superTables,
-        NotNull<Scope> scope
-    );
-    SubtypingResult
-    isCovariantWith(SubtypingEnvironment& env, const NormalizedFunctionType& subFunction, const NormalizedFunctionType& superFunction, NotNull<Scope>);
-    SubtypingResult isCovariantWith(SubtypingEnvironment& env, const TypeIds& subTypes, const TypeIds& superTypes, NotNull<Scope> scope);
-
-    SubtypingResult isCovariantWith(
-        SubtypingEnvironment& env,
-        const VariadicTypePack* subVariadic,
-        const VariadicTypePack* superVariadic,
-        NotNull<Scope> scope
-    );
-    SubtypingResult isCovariantWith(
-        SubtypingEnvironment& env,
-        const TypeFunctionInstanceType* subFunctionInstance,
-        const TypeId superTy,
-        NotNull<Scope> scope
-    );
-    SubtypingResult isCovariantWith(
-        SubtypingEnvironment& env,
-        const TypeId subTy,
-        const TypeFunctionInstanceType* superFunctionInstance,
-        NotNull<Scope> scope
-    );
-
-    bool bindGeneric(SubtypingEnvironment& env, TypeId subTp, TypeId superTp);
-    bool bindGeneric(SubtypingEnvironment& env, TypePackId subTp, TypePackId superTp);
-
-    template<typename T, typename Container>
-    TypeId makeAggregateType(const Container& container, TypeId orElse);
-
-    std::pair<TypeId, ErrorVec> handleTypeFunctionReductionResult(const TypeFunctionInstanceType* functionInstance, NotNull<Scope> scope);
-
-    [[noreturn]] void unexpected(TypeId ty);
-    [[noreturn]] void unexpected(TypePackId tp);
-};
-
-} // namespace Luau

Analysis/include/Luau/Symbol.h

@@ -9,6 +9,7 @@
 namespace Luau
 {
 
+// TODO Rename this to Name once the old type alias is gone.
 struct Symbol
 {
     Symbol()
@@ -29,19 +30,18 @@ struct Symbol
     {
     }
 
-    template<typename T>
-    Symbol(const T&) = delete;
-
     AstLocal* local;
     AstName global;
 
-    explicit operator bool() const
+    bool operator==(const Symbol& rhs) const
     {
-        return local != nullptr || global.value != nullptr;
+        if (local)
+            return local == rhs.local;
+        if (global.value)
+            return rhs.global.value && global == rhs.global.value; // Subtlety: AstName::operator==(const char*) uses strcmp, not pointer identity.
+        return false;
     }
 
-    bool operator==(const Symbol& rhs) const;
-
     bool operator!=(const Symbol& rhs) const
     {
         return !(*this == rhs);
@@ -55,8 +55,8 @@ struct Symbol
             return global < rhs.global;
         else if (local)
             return true;
-
-        return false;
+        else
+            return false;
     }
 
     AstName astName() const

Analysis/include/Luau/TableLiteralInference.h

@@ -1,32 +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/DenseHash.h"
-#include "Luau/NotNull.h"
-#include "Luau/TypeFwd.h"
-
-#include <vector>
-
-namespace Luau
-{
-
-struct TypeArena;
-struct BuiltinTypes;
-struct Unifier2;
-struct Subtyping;
-class AstExpr;
-
-TypeId matchLiteralType(
-    NotNull<DenseHashMap<const AstExpr*, TypeId>> astTypes,
-    NotNull<DenseHashMap<const AstExpr*, TypeId>> astExpectedTypes,
-    NotNull<BuiltinTypes> builtinTypes,
-    NotNull<TypeArena> arena,
-    NotNull<Unifier2> unifier,
-    NotNull<Subtyping> subtyping,
-    TypeId expectedType,
-    TypeId exprType,
-    const AstExpr* expr,
-    std::vector<TypeId>& toBlock
-);
-} // namespace Luau

Analysis/include/Luau/ToDot.h

@@ -2,12 +2,16 @@
 #pragma once
 
 #include "Luau/Common.h"
-#include "Luau/TypeFwd.h"
 
 #include <string>
 
 namespace Luau
 {
+struct TypeVar;
+using TypeId = const TypeVar*;
+
+struct TypePackVar;
+using TypePackId = const TypePackVar*;
 
 struct ToDotOptions
 {

Analysis/include/Luau/ToString.h

@@ -2,13 +2,12 @@
 #pragma once
 
 #include "Luau/Common.h"
-#include "Luau/TypeFwd.h"
+#include "Luau/TypeVar.h"
 
-#include <memory>
-#include <optional>
-#include <string>
 #include <unordered_map>
-#include <vector>
+#include <optional>
+#include <memory>
+#include <string>
 
 LUAU_FASTINT(LuauTableTypeMaximumStringifierLength)
 LUAU_FASTINT(LuauTypeMaximumStringifierLength)
@@ -16,47 +15,29 @@ LUAU_FASTINT(LuauTypeMaximumStringifierLength)
 namespace Luau
 {
 
-class AstExpr;
-
-struct Scope;
-
-struct Constraint;
-
-struct Position;
-struct Location;
-
 struct ToStringNameMap
 {
-    std::unordered_map<TypeId, std::string> types;
+    std::unordered_map<TypeId, std::string> typeVars;
     std::unordered_map<TypePackId, std::string> typePacks;
 };
 
 struct ToStringOptions
 {
-    ToStringOptions(bool exhaustive = false)
-        : exhaustive(exhaustive)
-    {
-    }
-
     bool exhaustive = false;                      // If true, we produce complete output rather than comprehensible output
     bool useLineBreaks = false;                   // If true, we insert new lines to separate long results such as table entries/metatable.
     bool functionTypeArguments = false;           // If true, output function type argument names when they are available
     bool hideTableKind = false;                   // If true, all tables will be surrounded with plain '{}'
     bool hideNamedFunctionTypeParameters = false; // If true, type parameters of functions will be hidden at top-level.
-    bool hideFunctionSelfArgument = false;        // If true, `self: X` will be omitted from the function signature if the function has self
-    bool hideTableAliasExpansions = false;        // If true, all table aliases will not be expanded
-    bool useQuestionMarks = true;                 // If true, use a postfix ? for options, else write them out as unions that include nil.
-    size_t maxTableLength = size_t(FInt::LuauTableTypeMaximumStringifierLength); // Only applied to TableTypes
+    size_t maxTableLength = size_t(FInt::LuauTableTypeMaximumStringifierLength); // Only applied to TableTypeVars
     size_t maxTypeLength = size_t(FInt::LuauTypeMaximumStringifierLength);
-    size_t compositeTypesSingleLineLimit = 5; // The number of type elements permitted on a single line when printing type unions/intersections
-    ToStringNameMap nameMap;
+    std::optional<ToStringNameMap> nameMap;
     std::shared_ptr<Scope> scope; // If present, module names will be added and types that are not available in scope will be marked as 'invalid'
-    std::vector<std::string> namedFunctionOverrideArgNames; // If present, named function argument names will be overridden
 };
 
 struct ToStringResult
 {
     std::string name;
+    ToStringNameMap nameMap;
 
     bool invalid = false;
     bool error = false;
@@ -64,24 +45,11 @@ struct ToStringResult
     bool truncated = false;
 };
 
-ToStringResult toStringDetailed(TypeId ty, ToStringOptions& opts);
-ToStringResult toStringDetailed(TypePackId ty, ToStringOptions& opts);
+ToStringResult toStringDetailed(TypeId ty, const ToStringOptions& opts = {});
+ToStringResult toStringDetailed(TypePackId ty, const ToStringOptions& opts = {});
 
-std::string toString(TypeId ty, ToStringOptions& opts);
-std::string toString(TypePackId ty, ToStringOptions& opts);
-
-// These overloads are selected when a temporary ToStringOptions is passed. (eg
-// via an initializer list)
-inline std::string toString(TypePackId ty, ToStringOptions&& opts)
-{
-    // Delegate to the overload (TypePackId, ToStringOptions&)
-    return toString(ty, opts);
-}
-inline std::string toString(TypeId ty, ToStringOptions&& opts)
-{
-    // Delegate to the overload (TypeId, ToStringOptions&)
-    return toString(ty, opts);
-}
+std::string toString(TypeId ty, const ToStringOptions& opts);
+std::string toString(TypePackId ty, const ToStringOptions& opts);
 
 // These are offered as overloads rather than a default parameter so that they can be easily invoked from within the MSVC debugger.
 // You can use them in watch expressions!
@@ -94,63 +62,16 @@ inline std::string toString(TypePackId ty)
     return toString(ty, ToStringOptions{});
 }
 
-std::string toString(const Constraint& c, ToStringOptions& opts);
+std::string toString(const TypeVar& tv, const ToStringOptions& opts = {});
+std::string toString(const TypePackVar& tp, const ToStringOptions& opts = {});
 
-inline std::string toString(const Constraint& c, ToStringOptions&& opts)
-{
-    return toString(c, opts);
-}
-
-std::string toString(const Constraint& c);
-
-std::string toString(const Type& tv, ToStringOptions& opts);
-std::string toString(const TypePackVar& tp, ToStringOptions& opts);
-
-inline std::string toString(const Type& tv)
-{
-    ToStringOptions opts;
-    return toString(tv, opts);
-}
-
-inline std::string toString(const TypePackVar& tp)
-{
-    ToStringOptions opts;
-    return toString(tp, opts);
-}
-
-std::string toStringNamedFunction(const std::string& funcName, const FunctionType& ftv, ToStringOptions& opts);
-
-inline std::string toStringNamedFunction(const std::string& funcName, const FunctionType& ftv)
-{
-    ToStringOptions opts;
-    return toStringNamedFunction(funcName, ftv, opts);
-}
-
-std::optional<std::string> getFunctionNameAsString(const AstExpr& expr);
+std::string toStringNamedFunction(const std::string& prefix, const FunctionTypeVar& ftv, ToStringOptions opts = {});
 
 // It could be useful to see the text representation of a type during a debugging session instead of exploring the content of the class
 // These functions will dump the type to stdout and can be evaluated in Watch/Immediate windows or as gdb/lldb expression
 std::string dump(TypeId ty);
-std::string dump(const std::optional<TypeId>& ty);
 std::string dump(TypePackId ty);
-std::string dump(const std::optional<TypePackId>& ty);
-std::string dump(const Constraint& c);
-
-std::string dump(const std::shared_ptr<Scope>& scope, const char* name);
 
 std::string generateName(size_t n);
 
-std::string toString(const Position& position);
-std::string toString(const Location& location, int offset = 0, bool useBegin = true);
-
-std::string toString(const TypeOrPack& tyOrTp, ToStringOptions& opts);
-
-inline std::string toString(const TypeOrPack& tyOrTp)
-{
-    ToStringOptions opts{};
-    return toString(tyOrTp, opts);
-}
-
-std::string dump(const TypeOrPack& tyOrTp);
-
 } // namespace Luau

Analysis/include/Luau/TxnLog.h

@@ -1,96 +1,26 @@
 // This file is part of the Luau programming language and is licensed under MIT License; see LICENSE.txt for details
 #pragma once
 
-#include "Luau/Type.h"
-#include "Luau/TypePack.h"
+#include "Luau/TypeVar.h"
 
-#include <memory>
-#include <unordered_map>
+LUAU_FASTFLAG(LuauShareTxnSeen);
 
 namespace Luau
 {
 
-using TypeOrPackId = const void*;
-
-// Pending state for a Type. Generated by a TxnLog and committed via
-// TxnLog::commit.
-struct PendingType
-{
-    // The pending Type state.
-    Type pending;
-
-    // On very rare occasions, we need to delete an entry from the TxnLog.
-    // DenseHashMap does not afford that so we note its deadness here.
-    bool dead = false;
-
-    explicit PendingType(Type state)
-        : pending(std::move(state))
-    {
-    }
-};
-
-std::string toString(PendingType* pending);
-std::string dump(PendingType* pending);
-
-// Pending state for a TypePackVar. Generated by a TxnLog and committed via
-// TxnLog::commit.
-struct PendingTypePack
-{
-    // The pending TypePackVar state.
-    TypePackVar pending;
-
-    explicit PendingTypePack(TypePackVar state)
-        : pending(std::move(state))
-    {
-    }
-};
-
-std::string toString(PendingTypePack* pending);
-std::string dump(PendingTypePack* pending);
-
-template<typename T>
-T* getMutable(PendingType* pending)
-{
-    // We use getMutable here because this state is intended to be mutated freely.
-    return getMutable<T>(&pending->pending);
-}
-
-template<typename T>
-T* getMutable(PendingTypePack* pending)
-{
-    // We use getMutable here because this state is intended to be mutated freely.
-    return getMutable<T>(&pending->pending);
-}
-
-// Log of what TypeIds we are rebinding, to be committed later.
+// Log of where what TypeIds we are rebinding and what they used to be
 struct TxnLog
 {
-    explicit TxnLog()
-        : typeVarChanges(nullptr)
-        , typePackChanges(nullptr)
+    TxnLog()
+        : originalSeenSize(0)
         , ownedSeen()
         , sharedSeen(&ownedSeen)
     {
     }
 
-    explicit TxnLog(TxnLog* parent)
-        : typeVarChanges(nullptr)
-        , typePackChanges(nullptr)
-        , parent(parent)
-    {
-        if (parent)
-        {
-            sharedSeen = parent->sharedSeen;
-        }
-        else
-        {
-            sharedSeen = &ownedSeen;
-        }
-    }
-
-    explicit TxnLog(std::vector<std::pair<TypeOrPackId, TypeOrPackId>>* sharedSeen)
-        : typeVarChanges(nullptr)
-        , typePackChanges(nullptr)
+    explicit TxnLog(std::vector<std::pair<TypeId, TypeId>>* sharedSeen)
+        : originalSeenSize(sharedSeen->size())
+        , ownedSeen()
         , sharedSeen(sharedSeen)
     {
     }
@@ -101,211 +31,27 @@ struct TxnLog
     TxnLog(TxnLog&&) = default;
     TxnLog& operator=(TxnLog&&) = default;
 
-    // Gets an empty TxnLog pointer. This is useful for constructs that
-    // take a TxnLog, like TypePackIterator - use the empty log if you
-    // don't have a TxnLog to give it.
-    static const TxnLog* empty();
+    void operator()(TypeId a);
+    void operator()(TypePackId a);
+    void operator()(TableTypeVar* a);
+
+    void rollback();
 
-    // Joins another TxnLog onto this one. You should use std::move to avoid
-    // copying the rhs TxnLog.
-    //
-    // If both logs talk about the same type, pack, or table, the rhs takes
-    // priority.
     void concat(TxnLog rhs);
-    void concatAsIntersections(TxnLog rhs, NotNull<TypeArena> arena);
-    void concatAsUnion(TxnLog rhs, NotNull<TypeArena> arena);
 
-    // Commits the TxnLog, rebinding all type pointers to their pending states.
-    // Clears the TxnLog afterwards.
-    void commit();
-
-    // Clears the TxnLog without committing any pending changes.
-    void clear();
-
-    // Computes an inverse of this TxnLog at the current time.
-    // This method should be called before commit is called in order to give an
-    // accurate result. Committing the inverse of a TxnLog will undo the changes
-    // made by commit, assuming the inverse log is accurate.
-    TxnLog inverse();
-
-    bool haveSeen(TypeId lhs, TypeId rhs) const;
+    bool haveSeen(TypeId lhs, TypeId rhs);
     void pushSeen(TypeId lhs, TypeId rhs);
     void popSeen(TypeId lhs, TypeId rhs);
 
-    bool haveSeen(TypePackId lhs, TypePackId rhs) const;
-    void pushSeen(TypePackId lhs, TypePackId rhs);
-    void popSeen(TypePackId lhs, TypePackId rhs);
-
-    // Queues a type for modification. The original type will not change until commit
-    // is called. Use pending to get the pending state.
-    //
-    // The pointer returned lives until `commit` or `clear` is called.
-    PendingType* queue(TypeId ty);
-
-    // Queues a type pack for modification. The original type pack will not change
-    // until commit is called. Use pending to get the pending state.
-    //
-    // The pointer returned lives until `commit` or `clear` is called.
-    PendingTypePack* queue(TypePackId tp);
-
-    // Returns the pending state of a type, or nullptr if there isn't any. It is important
-    // to note that this pending state is not transitive: the pending state may reference
-    // non-pending types freely, so you may need to call pending multiple times to view the
-    // entire pending state of a type graph.
-    //
-    // The pointer returned lives until `commit` or `clear` is called.
-    PendingType* pending(TypeId ty) const;
-
-    // Returns the pending state of a type pack, or nullptr if there isn't any. It is
-    // important to note that this pending state is not transitive: the pending state may
-    // reference non-pending types freely, so you may need to call pending multiple times
-    // to view the entire pending state of a type graph.
-    //
-    // The pointer returned lives until `commit` or `clear` is called.
-    PendingTypePack* pending(TypePackId tp) const;
-
-    // Queues a replacement of a type with another type.
-    //
-    // The pointer returned lives until `commit` or `clear` is called.
-    PendingType* replace(TypeId ty, Type replacement);
-
-    // Queues a replacement of a type pack with another type pack.
-    //
-    // The pointer returned lives until `commit` or `clear` is called.
-    PendingTypePack* replace(TypePackId tp, TypePackVar replacement);
-
-    // Queues a replacement of a table type with another table type that is bound
-    // to a specific value.
-    //
-    // The pointer returned lives until `commit` or `clear` is called.
-    PendingType* bindTable(TypeId ty, std::optional<TypeId> newBoundTo);
-
-    // Queues a replacement of a type with a level with a duplicate of that type
-    // with a new type level.
-    //
-    // The pointer returned lives until `commit` or `clear` is called.
-    PendingType* changeLevel(TypeId ty, TypeLevel newLevel);
-
-    // Queues a replacement of a type pack with a level with a duplicate of that
-    // type pack with a new type level.
-    //
-    // The pointer returned lives until `commit` or `clear` is called.
-    PendingTypePack* changeLevel(TypePackId tp, TypeLevel newLevel);
-
-    // Queues a replacement of a table type with another table type with a new
-    // indexer.
-    //
-    // The pointer returned lives until `commit` or `clear` is called.
-    PendingType* changeIndexer(TypeId ty, std::optional<TableIndexer> indexer);
-
-    // Returns the type level of the pending state of the type, or the level of that
-    // type, if no pending state exists. If the type doesn't have a notion of a level,
-    // returns nullopt. If the pending state doesn't have a notion of a level, but the
-    // original state does, returns nullopt.
-    std::optional<TypeLevel> getLevel(TypeId ty) const;
-
-    // Follows a type, accounting for pending type states. The returned type may have
-    // pending state; you should use `pending` or `get` to find out.
-    TypeId follow(TypeId ty) const;
-
-    // Follows a type pack, accounting for pending type states. The returned type pack
-    // may have pending state; you should use `pending` or `get` to find out.
-    TypePackId follow(TypePackId tp) const;
-
-    // Replaces a given type's state with a new variant. Returns the new pending state
-    // of that type.
-    //
-    // The pointer returned lives until `commit` or `clear` is called.
-    template<typename T>
-    PendingType* replace(TypeId ty, T replacement)
-    {
-        return replace(ty, Type(replacement));
-    }
-
-    // Replaces a given type pack's state with a new variant. Returns the new
-    // pending state of that type pack.
-    //
-    // The pointer returned lives until `commit` or `clear` is called.
-    template<typename T>
-    PendingTypePack* replace(TypePackId tp, T replacement)
-    {
-        return replace(tp, TypePackVar(replacement));
-    }
-
-    // Returns T if a given type or type pack is this variant, respecting the
-    // log's pending state.
-    //
-    // Do not retain this pointer; it has the potential to be invalidated when
-    // commit or clear is called.
-    template<typename T, typename TID>
-    T* getMutable(TID ty) const
-    {
-        auto* pendingTy = pending(ty);
-        if (pendingTy)
-            return Luau::getMutable<T>(pendingTy);
-
-        return Luau::getMutable<T>(ty);
-    }
-
-    template<typename T, typename TID>
-    const T* get(TID ty) const
-    {
-        return this->getMutable<T>(ty);
-    }
-
-    // Returns whether a given type or type pack is a given state, respecting the
-    // log's pending state.
-    //
-    // This method will not assert if called on a BoundType or BoundTypePack.
-    template<typename T, typename TID>
-    bool is(TID ty) const
-    {
-        // We do not use getMutable here because this method can be called on
-        // BoundTypes, which triggers an assertion.
-        auto* pendingTy = pending(ty);
-        if (pendingTy)
-            return Luau::get_if<T>(&pendingTy->pending.ty) != nullptr;
-
-        return Luau::get_if<T>(&ty->ty) != nullptr;
-    }
-
-    std::pair<std::vector<TypeId>, std::vector<TypePackId>> getChanges() const;
-
 private:
-    // unique_ptr is used to give us stable pointers across insertions into the
-    // map. Otherwise, it would be really easy to accidentally invalidate the
-    // pointers returned from queue/pending.
-    DenseHashMap<TypeId, std::unique_ptr<PendingType>> typeVarChanges;
-    DenseHashMap<TypePackId, std::unique_ptr<PendingTypePack>> typePackChanges;
-
-    TxnLog* parent = nullptr;
-
-    // Owned version of sharedSeen. This should not be accessed directly in
-    // TxnLogs; use sharedSeen instead. This field exists because in the tree
-    // of TxnLogs, the root must own its seen set. In all descendant TxnLogs,
-    // this is an empty vector.
-    std::vector<std::pair<TypeOrPackId, TypeOrPackId>> ownedSeen;
-
-    bool haveSeen(TypeOrPackId lhs, TypeOrPackId rhs) const;
-    void pushSeen(TypeOrPackId lhs, TypeOrPackId rhs);
-    void popSeen(TypeOrPackId lhs, TypeOrPackId rhs);
+    std::vector<std::pair<TypeId, TypeVar>> typeVarChanges;
+    std::vector<std::pair<TypePackId, TypePackVar>> typePackChanges;
+    std::vector<std::pair<TableTypeVar*, std::optional<TypeId>>> tableChanges;
+    size_t originalSeenSize;
 
 public:
-    // There is one spot in the code where TxnLog has to reconcile collisions
-    // between parallel logs. In that codepath, we have to work out which of two
-    // FreeTypes subsumes the other. If useScopes is false, the TypeLevel is
-    // used.  Else we use the embedded Scope*.
-    bool useScopes = false;
-
-    // It is sometimes the case under DCR that we speculatively rebind
-    // GenericTypes to other types as though they were free.  We mark logs that
-    // contain these kinds of substitutions as radioactive so that we know that
-    // we must never commit one.
-    bool radioactive = false;
-
-    // Used to avoid infinite recursion when types are cyclic.
-    // Shared with all the descendent TxnLogs.
-    std::vector<std::pair<TypeOrPackId, TypeOrPackId>>* sharedSeen;
+    std::vector<std::pair<TypeId, TypeId>> ownedSeen;   // used to avoid infinite recursion when types are cyclic
+    std::vector<std::pair<TypeId, TypeId>>* sharedSeen; // shared with all the descendent logs
 };
 
 } // namespace Luau

Analysis/include/Luau/TypeArena.h

@@ -1,62 +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/Polarity.h"
-#include "Luau/TypedAllocator.h"
-#include "Luau/Type.h"
-#include "Luau/TypePack.h"
-
-#include <vector>
-
-namespace Luau
-{
-struct Module;
-
-struct TypeArena
-{
-    TypedAllocator<Type> types;
-    TypedAllocator<TypePackVar> typePacks;
-
-    // Owning module, if any
-    Module* owningModule = nullptr;
-
-    void clear();
-
-    template<typename T>
-    TypeId addType(T tv)
-    {
-        if constexpr (std::is_same_v<T, UnionType>)
-            LUAU_ASSERT(tv.options.size() >= 2);
-
-        return addTV(Type(std::move(tv)));
-    }
-
-    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);
-
-    TypePackId freshTypePack(Scope* scope, Polarity polarity = Polarity::Unknown);
-
-    TypePackId addTypePack(std::initializer_list<TypeId> types);
-    TypePackId addTypePack(std::vector<TypeId> types, std::optional<TypePackId> tail = {});
-    TypePackId addTypePack(TypePack pack);
-    TypePackId addTypePack(TypePackVar pack);
-
-    template<typename T>
-    TypePackId addTypePack(T tp)
-    {
-        return addTypePack(TypePackVar(std::move(tp)));
-    }
-
-    TypeId addTypeFunction(const TypeFunction& function, std::initializer_list<TypeId> types);
-    TypeId addTypeFunction(const TypeFunction& function, std::vector<TypeId> typeArguments, std::vector<TypePackId> packArguments = {});
-    TypePackId addTypePackFunction(const TypePackFunction& function, std::initializer_list<TypeId> types);
-    TypePackId addTypePackFunction(const TypePackFunction& function, std::vector<TypeId> typeArguments, std::vector<TypePackId> packArguments = {});
-};
-
-void freeze(TypeArena& arena);
-void unfreeze(TypeArena& arena);
-
-} // namespace Luau

Analysis/include/Luau/TypeAttach.h

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

Analysis/include/Luau/TypeCheckLimits.h

@@ -1,41 +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/Cancellation.h"
-#include "Luau/Error.h"
-
-#include <memory>
-#include <optional>
-#include <string>
-
-namespace Luau
-{
-
-class TimeLimitError : public InternalCompilerError
-{
-public:
-    explicit TimeLimitError(const std::string& moduleName)
-        : InternalCompilerError("Typeinfer failed to complete in allotted time", moduleName)
-    {
-    }
-};
-
-class UserCancelError : public InternalCompilerError
-{
-public:
-    explicit UserCancelError(const std::string& moduleName)
-        : InternalCompilerError("Analysis has been cancelled by user", moduleName)
-    {
-    }
-};
-
-struct TypeCheckLimits
-{
-    std::optional<double> finishTime;
-    std::optional<int> instantiationChildLimit;
-    std::optional<int> unifierIterationLimit;
-
-    std::shared_ptr<FrontendCancellationToken> cancellationToken;
-};
-
-} // namespace Luau

Analysis/include/Luau/TypeChecker2.h

@@ -1,243 +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/Common.h"
-#include "Luau/EqSatSimplification.h"
-#include "Luau/Error.h"
-#include "Luau/Normalize.h"
-#include "Luau/NotNull.h"
-#include "Luau/Subtyping.h"
-#include "Luau/Type.h"
-#include "Luau/TypeFwd.h"
-#include "Luau/TypeOrPack.h"
-#include "Luau/TypeUtils.h"
-
-LUAU_FASTFLAG(LuauImproveTypePathsInErrors)
-
-namespace Luau
-{
-
-struct BuiltinTypes;
-struct DcrLogger;
-struct TypeCheckLimits;
-struct UnifierSharedState;
-struct SourceModule;
-struct Module;
-struct InternalErrorReporter;
-struct Scope;
-struct PropertyType;
-struct PropertyTypes;
-struct StackPusher;
-
-struct Reasonings
-{
-    // the list of reasons
-    std::vector<std::string> reasons;
-
-    // this should be true if _all_ of the reasons have an error suppressing type, and false otherwise.
-    bool suppressed;
-
-    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 " : "";
-        bool first = true;
-        for (const std::string& reason : reasons)
-        {
-            if (FFlag::LuauImproveTypePathsInErrors)
-            {
-                if (reasons.size() > 1)
-                    allReasons += "\n\t * ";
-            }
-            else
-            {
-                if (first)
-                    first = false;
-                else
-                    allReasons += "\n\t";
-            }
-
-            allReasons += reason;
-        }
-
-        return allReasons;
-    }
-};
-
-
-void check(
-    NotNull<BuiltinTypes> builtinTypes,
-    NotNull<Simplifier> simplifier,
-    NotNull<TypeFunctionRuntime> typeFunctionRuntime,
-    NotNull<UnifierSharedState> unifierState,
-    NotNull<TypeCheckLimits> limits,
-    DcrLogger* logger,
-    const SourceModule& sourceModule,
-    Module* module
-);
-
-struct TypeChecker2
-{
-    NotNull<BuiltinTypes> builtinTypes;
-    NotNull<Simplifier> simplifier;
-    NotNull<TypeFunctionRuntime> typeFunctionRuntime;
-    DcrLogger* logger;
-    const NotNull<TypeCheckLimits> limits;
-    const NotNull<InternalErrorReporter> ice;
-    const SourceModule* sourceModule;
-    Module* module;
-
-    TypeContext typeContext = TypeContext::Default;
-    std::vector<NotNull<Scope>> stack;
-    std::vector<TypeId> functionDeclStack;
-
-    DenseHashSet<TypeId> seenTypeFunctionInstances{nullptr};
-
-    Normalizer normalizer;
-    Subtyping _subtyping;
-    NotNull<Subtyping> subtyping;
-
-    TypeChecker2(
-        NotNull<BuiltinTypes> builtinTypes,
-        NotNull<Simplifier> simplifier,
-        NotNull<TypeFunctionRuntime> typeFunctionRuntime,
-        NotNull<UnifierSharedState> unifierState,
-        NotNull<TypeCheckLimits> limits,
-        DcrLogger* logger,
-        const SourceModule* sourceModule,
-        Module* module
-    );
-
-    void visit(AstStatBlock* block);
-    void reportError(TypeErrorData data, const Location& location);
-    Reasonings explainReasonings(TypeId subTy, TypeId superTy, Location location, const SubtypingResult& r);
-    Reasonings explainReasonings(TypePackId subTp, TypePackId superTp, Location location, const SubtypingResult& r);
-
-private:
-    static bool allowsNoReturnValues(const TypePackId tp);
-    static Location getEndLocation(const AstExprFunction* function);
-    bool isErrorCall(const AstExprCall* call);
-    bool hasBreak(AstStat* node);
-    const AstStat* getFallthrough(const AstStat* node);
-    std::optional<StackPusher> pushStack(AstNode* node);
-    void checkForInternalTypeFunction(TypeId ty, Location location);
-    TypeId checkForTypeFunctionInhabitance(TypeId instance, Location location);
-    TypePackId lookupPack(AstExpr* expr) const;
-    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;
-    TypePackId reconstructPack(AstArray<AstExpr*> exprs, TypeArena& arena);
-    Scope* findInnermostScope(Location location) const;
-    void visit(AstStat* stat);
-    void visit(AstStatIf* ifStatement);
-    void visit(AstStatWhile* whileStatement);
-    void visit(AstStatRepeat* repeatStatement);
-    void visit(AstStatBreak*);
-    void visit(AstStatContinue*);
-    void visit(AstStatReturn* ret);
-    void visit(AstStatExpr* expr);
-    void visit(AstStatLocal* local);
-    void visit(AstStatFor* forStatement);
-    void visit(AstStatForIn* forInStatement);
-    std::optional<TypeId> getBindingType(AstExpr* expr);
-    void reportErrorsFromAssigningToNever(AstExpr* lhs, TypeId rhsType);
-    void visit(AstStatAssign* assign);
-    void visit(AstStatCompoundAssign* stat);
-    void visit(AstStatFunction* stat);
-    void visit(AstStatLocalFunction* stat);
-    void visit(const AstTypeList* typeList);
-    void visit(AstStatTypeAlias* stat);
-    void visit(AstStatTypeFunction* stat);
-    void visit(AstTypeList types);
-    void visit(AstStatDeclareFunction* stat);
-    void visit(AstStatDeclareGlobal* stat);
-    void visit(AstStatDeclareExternType* stat);
-    void visit(AstStatError* stat);
-    void visit(AstExpr* expr, ValueContext context);
-    void visit(AstExprGroup* expr, ValueContext context);
-    void visit(AstExprConstantNil* expr);
-    void visit(AstExprConstantBool* expr);
-    void visit(AstExprConstantNumber* expr);
-    void visit(AstExprConstantString* expr);
-    void visit(AstExprLocal* expr);
-    void visit(AstExprGlobal* expr);
-    void visit(AstExprVarargs* expr);
-    void visitCall(AstExprCall* call);
-    void visit(AstExprCall* call);
-    std::optional<TypeId> tryStripUnionFromNil(TypeId ty) const;
-    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);
-    void indexExprMetatableHelper(AstExprIndexExpr* indexExpr, const MetatableType* metaTable, TypeId exprType, TypeId indexType);
-    void visit(AstExprIndexExpr* indexExpr, ValueContext context);
-    void visit(AstExprFunction* fn);
-    void visit(AstExprTable* expr);
-    void visit(AstExprUnary* expr);
-    TypeId visit(AstExprBinary* expr, AstNode* overrideKey = nullptr);
-    void visit(AstExprTypeAssertion* expr);
-    void visit(AstExprIfElse* expr);
-    void visit(AstExprInterpString* interpString);
-    void visit(AstExprError* expr);
-    TypeId flattenPack(TypePackId pack);
-    void visitGenerics(AstArray<AstGenericType*> generics, AstArray<AstGenericTypePack*> genericPacks);
-    void visit(AstType* ty);
-    void visit(AstTypeReference* ty);
-    void visit(AstTypeTable* table);
-    void visit(AstTypeFunction* ty);
-    void visit(AstTypeTypeof* ty);
-    void visit(AstTypeUnion* ty);
-    void visit(AstTypeIntersection* ty);
-    void visit(AstTypePack* pack);
-    void visit(AstTypePackExplicit* tp);
-    void visit(AstTypePackVariadic* tp);
-    void visit(AstTypePackGeneric* tp);
-
-    template<typename TID>
-    Reasonings explainReasonings_(TID subTy, TID superTy, Location location, const SubtypingResult& r);
-
-    void explainError(TypeId subTy, TypeId superTy, Location location, const SubtypingResult& result);
-    void explainError(TypePackId subTy, TypePackId superTy, Location location, const SubtypingResult& result);
-    bool testIsSubtype(TypeId subTy, TypeId superTy, Location location);
-    bool testIsSubtype(TypePackId subTy, TypePackId superTy, Location location);
-    void reportError(TypeError e);
-    void reportErrors(ErrorVec errors);
-    PropertyTypes lookupProp(
-        const NormalizedType* norm,
-        const std::string& prop,
-        ValueContext context,
-        const Location& location,
-        TypeId astIndexExprType,
-        std::vector<TypeError>& errors
-    );
-    // If the provided type does not have the named property, report an error.
-    void checkIndexTypeFromType(TypeId tableTy, const std::string& prop, ValueContext context, const Location& location, TypeId astIndexExprType);
-    PropertyType hasIndexTypeFromType(
-        TypeId ty,
-        const std::string& prop,
-        ValueContext context,
-        const Location& location,
-        DenseHashSet<TypeId>& seen,
-        TypeId astIndexExprType,
-        std::vector<TypeError>& errors
-    );
-
-    // Avoid duplicate warnings being emitted for the same global variable.
-    DenseHashSet<std::string> warnedGlobals{""};
-
-    void diagnoseMissingTableKey(UnknownProperty* utk, TypeErrorData& data) const;
-    bool isErrorSuppressing(Location loc, TypeId ty);
-    bool isErrorSuppressing(Location loc1, TypeId ty1, Location loc2, TypeId ty2);
-    bool isErrorSuppressing(Location loc, TypePackId tp);
-    bool isErrorSuppressing(Location loc1, TypePackId tp1, Location loc2, TypePackId tp2);
-};
-
-} // namespace Luau

Analysis/include/Luau/TypeFunction.h

@@ -1,264 +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/Constraint.h"
-#include "Luau/EqSatSimplification.h"
-#include "Luau/Error.h"
-#include "Luau/NotNull.h"
-#include "Luau/TypeCheckLimits.h"
-#include "Luau/TypeFunctionRuntime.h"
-#include "Luau/TypeFwd.h"
-
-#include <functional>
-#include <string>
-#include <optional>
-
-struct lua_State;
-
-namespace Luau
-{
-
-struct TypeArena;
-struct TxnLog;
-struct ConstraintSolver;
-class Normalizer;
-
-using StateRef = std::unique_ptr<lua_State, void (*)(lua_State*)>;
-
-struct TypeFunctionRuntime
-{
-    TypeFunctionRuntime(NotNull<InternalErrorReporter> ice, NotNull<TypeCheckLimits> limits);
-    ~TypeFunctionRuntime();
-
-    // Return value is an error message if registration failed
-    std::optional<std::string> registerFunction(AstStatTypeFunction* function);
-
-    // For user-defined type functions, we store all generated types and packs for the duration of the typecheck
-    TypedAllocator<TypeFunctionType> typeArena;
-    TypedAllocator<TypeFunctionTypePackVar> typePackArena;
-
-    NotNull<InternalErrorReporter> ice;
-    NotNull<TypeCheckLimits> limits;
-
-    StateRef state;
-
-    // Set of functions which have their environment table initialized
-    DenseHashSet<AstStatTypeFunction*> initialized{nullptr};
-
-    // 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;
-
-private:
-    void prepareState();
-};
-
-struct TypeFunctionContext
-{
-    NotNull<TypeArena> arena;
-    NotNull<BuiltinTypes> builtins;
-    NotNull<Scope> scope;
-    NotNull<Simplifier> simplifier;
-    NotNull<Normalizer> normalizer;
-    NotNull<TypeFunctionRuntime> typeFunctionRuntime;
-    NotNull<InternalErrorReporter> ice;
-    NotNull<TypeCheckLimits> limits;
-
-    // nullptr if the type function is being reduced outside of the constraint solver.
-    ConstraintSolver* solver;
-    // The constraint being reduced in this run of the reduction
-    const Constraint* constraint;
-
-    std::optional<AstName> userFuncName; // Name of the user-defined type function; only available for UDTFs
-
-    TypeFunctionContext(NotNull<ConstraintSolver> cs, NotNull<Scope> scope, NotNull<const Constraint> constraint);
-
-    TypeFunctionContext(
-        NotNull<TypeArena> arena,
-        NotNull<BuiltinTypes> builtins,
-        NotNull<Scope> scope,
-        NotNull<Simplifier> simplifier,
-        NotNull<Normalizer> normalizer,
-        NotNull<TypeFunctionRuntime> typeFunctionRuntime,
-        NotNull<InternalErrorReporter> ice,
-        NotNull<TypeCheckLimits> limits
-    )
-        : arena(arena)
-        , builtins(builtins)
-        , scope(scope)
-        , simplifier(simplifier)
-        , normalizer(normalizer)
-        , typeFunctionRuntime(typeFunctionRuntime)
-        , ice(ice)
-        , limits(limits)
-        , solver(nullptr)
-        , constraint(nullptr)
-    {
-    }
-
-    NotNull<Constraint> pushConstraint(ConstraintV&& c) const;
-};
-
-enum class Reduction
-{
-    // The type function is either known to be reducible or the determination is blocked.
-    MaybeOk,
-    // The type function is known to be irreducible, but maybe not be erroneous, e.g. when it's over generics or free types.
-    Irreducible,
-    // The type function is known to be irreducible, and is definitely erroneous.
-    Erroneous,
-};
-
-/// Represents a reduction result, which may have successfully reduced the type,
-/// may have concretely failed to reduce the type, or may simply be stuck
-/// without more information.
-template<typename Ty>
-struct TypeFunctionReductionResult
-{
-
-    /// The result of the reduction, if any. If this is nullopt, the type function
-    /// could not be reduced.
-    std::optional<Ty> result;
-    /// Indicates the status of this reduction: is `Reduction::Irreducible` if
-    /// the this result indicates the type function is irreducible, and
-    /// `Reduction::Erroneous` if this result indicates the type function is
-    /// erroneous. `Reduction::MaybeOk` otherwise.
-    Reduction reductionStatus;
-    /// Any types that need to be progressed or mutated before the reduction may
-    /// proceed.
-    std::vector<TypeId> blockedTypes;
-    /// Any type packs that need to be progressed or mutated before the
-    /// reduction may proceed.
-    std::vector<TypePackId> blockedPacks;
-    /// A runtime error message from user-defined type functions
-    std::optional<std::string> error;
-    /// Messages printed out from user-defined type functions
-    std::vector<std::string> messages;
-};
-
-template<typename T>
-using ReducerFunction =
-    std::function<TypeFunctionReductionResult<T>(T, const std::vector<TypeId>&, const std::vector<TypePackId>&, NotNull<TypeFunctionContext>)>;
-
-/// Represents a type function that may be applied to map a series of types and
-/// type packs to a single output type.
-struct TypeFunction
-{
-    /// The human-readable name of the type function. Used to stringify instance
-    /// types.
-    std::string name;
-
-    /// The reducer function for the type function.
-    ReducerFunction<TypeId> reducer;
-
-    /// If true, this type function can reduce even if it is parameterized on a generic.
-    bool canReduceGenerics = false;
-};
-
-/// Represents a type function that may be applied to map a series of types and
-/// type packs to a single output type pack.
-struct TypePackFunction
-{
-    /// The human-readable name of the type pack function. Used to stringify
-    /// instance packs.
-    std::string name;
-
-    /// The reducer function for the type pack function.
-    ReducerFunction<TypePackId> reducer;
-
-    /// If true, this type function can reduce even if it is parameterized on a generic.
-    bool canReduceGenerics = false;
-};
-
-struct FunctionGraphReductionResult
-{
-    ErrorVec errors;
-    ErrorVec messages;
-    DenseHashSet<TypeId> blockedTypes{nullptr};
-    DenseHashSet<TypePackId> blockedPacks{nullptr};
-    DenseHashSet<TypeId> reducedTypes{nullptr};
-    DenseHashSet<TypePackId> reducedPacks{nullptr};
-    DenseHashSet<TypeId> irreducibleTypes{nullptr};
-};
-
-/**
- * Attempt to reduce all instances of any type or type pack functions in the type
- * graph provided.
- *
- * @param entrypoint the entry point to the type graph.
- * @param location the location the reduction is occurring at; used to populate
- * type errors.
- * @param arena an arena to allocate types into.
- * @param builtins the built-in types.
- * @param normalizer the normalizer to use when normalizing types
- * @param ice the internal error reporter to use for ICEs
- */
-FunctionGraphReductionResult reduceTypeFunctions(TypeId entrypoint, Location location, TypeFunctionContext, bool force = false);
-
-/**
- * Attempt to reduce all instances of any type or type pack functions in the type
- * graph provided.
- *
- * @param entrypoint the entry point to the type graph.
- * @param location the location the reduction is occurring at; used to populate
- * type errors.
- * @param arena an arena to allocate types into.
- * @param builtins the built-in types.
- * @param normalizer the normalizer to use when normalizing types
- * @param ice the internal error reporter to use for ICEs
- */
-FunctionGraphReductionResult reduceTypeFunctions(TypePackId entrypoint, Location location, TypeFunctionContext, bool force = false);
-
-struct BuiltinTypeFunctions
-{
-    BuiltinTypeFunctions();
-
-    TypeFunction userFunc;
-
-    TypeFunction notFunc;
-    TypeFunction lenFunc;
-    TypeFunction unmFunc;
-
-    TypeFunction addFunc;
-    TypeFunction subFunc;
-    TypeFunction mulFunc;
-    TypeFunction divFunc;
-    TypeFunction idivFunc;
-    TypeFunction powFunc;
-    TypeFunction modFunc;
-
-    TypeFunction concatFunc;
-
-    TypeFunction andFunc;
-    TypeFunction orFunc;
-
-    TypeFunction ltFunc;
-    TypeFunction leFunc;
-    TypeFunction eqFunc;
-
-    TypeFunction refineFunc;
-    TypeFunction singletonFunc;
-    TypeFunction unionFunc;
-    TypeFunction intersectFunc;
-
-    TypeFunction keyofFunc;
-    TypeFunction rawkeyofFunc;
-    TypeFunction indexFunc;
-    TypeFunction rawgetFunc;
-
-    TypeFunction setmetatableFunc;
-    TypeFunction getmetatableFunc;
-
-    TypeFunction weakoptionalFunc;
-
-    void addToScope(NotNull<TypeArena> arena, NotNull<Scope> scope) const;
-};
-
-const BuiltinTypeFunctions& builtinTypeFunctions();
-
-} // namespace Luau

Analysis/include/Luau/TypeFunctionReductionGuesser.h

@@ -1,85 +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/Ast.h"
-#include "Luau/VecDeque.h"
-#include "Luau/DenseHash.h"
-#include "Luau/TypeFunction.h"
-#include "Luau/Type.h"
-#include "Luau/TypePack.h"
-#include "Luau/TypeUtils.h"
-#include "Luau/Normalize.h"
-#include "Luau/TypeFwd.h"
-#include "Luau/VisitType.h"
-#include "Luau/NotNull.h"
-#include "TypeArena.h"
-
-namespace Luau
-{
-
-struct TypeFunctionReductionGuessResult
-{
-    std::vector<std::pair<std::string, TypeId>> guessedFunctionAnnotations;
-    TypeId guessedReturnType;
-    bool shouldRecommendAnnotation = true;
-};
-
-// An Inference result for a type function is a list of types corresponding to the guessed argument types, followed by a type for the result
-struct TypeFunctionInferenceResult
-{
-    std::vector<TypeId> operandInference;
-    TypeId functionResultInference;
-};
-
-struct TypeFunctionReductionGuesser
-{
-    // Tracks our hypothesis about what a type function reduces to
-    DenseHashMap<TypeId, TypeId> functionReducesTo{nullptr};
-    // Tracks our constraints on type function operands
-    DenseHashMap<TypeId, TypeId> substitutable{nullptr};
-    // List of instances to try progress
-    VecDeque<TypeId> toInfer;
-    DenseHashSet<TypeId> cyclicInstances{nullptr};
-
-    // Utilities
-    NotNull<TypeArena> arena;
-    NotNull<BuiltinTypes> builtins;
-    NotNull<Normalizer> normalizer;
-
-    TypeFunctionReductionGuesser(NotNull<TypeArena> arena, NotNull<BuiltinTypes> builtins, NotNull<Normalizer> normalizer);
-
-    std::optional<TypeId> guess(TypeId typ);
-    std::optional<TypePackId> guess(TypePackId typ);
-    TypeFunctionReductionGuessResult guessTypeFunctionReductionForFunctionExpr(const AstExprFunction& expr, const FunctionType* ftv, TypeId retTy);
-
-private:
-    std::optional<TypeId> guessType(TypeId arg);
-    void dumpGuesses();
-
-    bool isNumericBinopFunction(const TypeFunctionInstanceType& instance);
-    bool isComparisonFunction(const TypeFunctionInstanceType& instance);
-    bool isOrAndFunction(const TypeFunctionInstanceType& instance);
-    bool isNotFunction(const TypeFunctionInstanceType& instance);
-    bool isLenFunction(const TypeFunctionInstanceType& instance);
-    bool isUnaryMinus(const TypeFunctionInstanceType& instance);
-
-    // Operand is assignable if it looks like a cyclic type function instance, or a generic type
-    bool operandIsAssignable(TypeId ty);
-    std::optional<TypeId> tryAssignOperandType(TypeId ty);
-
-    std::shared_ptr<const NormalizedType> normalize(TypeId ty);
-    void step();
-    void infer();
-    bool done();
-
-    bool isFunctionGenericsSaturated(const FunctionType& ftv, DenseHashSet<TypeId>& instanceArgs);
-    void inferTypeFunctionSubstitutions(TypeId ty, const TypeFunctionInstanceType* instance);
-    TypeFunctionInferenceResult inferNumericBinopFunction(const TypeFunctionInstanceType* instance);
-    TypeFunctionInferenceResult inferComparisonFunction(const TypeFunctionInstanceType* instance);
-    TypeFunctionInferenceResult inferOrAndFunction(const TypeFunctionInstanceType* instance);
-    TypeFunctionInferenceResult inferNotFunction(const TypeFunctionInstanceType* instance);
-    TypeFunctionInferenceResult inferLenFunction(const TypeFunctionInstanceType* instance);
-    TypeFunctionInferenceResult inferUnaryMinusFunction(const TypeFunctionInstanceType* instance);
-};
-} // namespace Luau

Analysis/include/Luau/TypeFunctionRuntime.h

@@ -1,296 +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/Common.h"
-#include "Luau/Variant.h"
-#include "Luau/TypeFwd.h"
-
-#include <optional>
-#include <string>
-#include <map>
-#include <vector>
-
-using lua_State = struct lua_State;
-
-namespace Luau
-{
-
-void* typeFunctionAlloc(void* ud, void* ptr, size_t osize, size_t nsize);
-
-// Replica of types from Type.h
-struct TypeFunctionType;
-using TypeFunctionTypeId = const TypeFunctionType*;
-
-struct TypeFunctionTypePackVar;
-using TypeFunctionTypePackId = const TypeFunctionTypePackVar*;
-
-struct TypeFunctionPrimitiveType
-{
-    enum Type
-    {
-        NilType,
-        Boolean,
-        Number,
-        String,
-        Thread,
-        Buffer,
-    };
-
-    Type type;
-
-    TypeFunctionPrimitiveType(Type type)
-        : type(type)
-    {
-    }
-};
-
-struct TypeFunctionBooleanSingleton
-{
-    bool value = false;
-};
-
-struct TypeFunctionStringSingleton
-{
-    std::string value;
-};
-
-using TypeFunctionSingletonVariant = Variant<TypeFunctionBooleanSingleton, TypeFunctionStringSingleton>;
-
-struct TypeFunctionSingletonType
-{
-    TypeFunctionSingletonVariant variant;
-
-    explicit TypeFunctionSingletonType(TypeFunctionSingletonVariant variant)
-        : variant(std::move(variant))
-    {
-    }
-};
-
-template<typename T>
-const T* get(const TypeFunctionSingletonType* tv)
-{
-    LUAU_ASSERT(tv);
-
-    return tv ? get_if<T>(&tv->variant) : nullptr;
-}
-
-template<typename T>
-T* getMutable(const TypeFunctionSingletonType* tv)
-{
-    LUAU_ASSERT(tv);
-
-    return tv ? get_if<T>(&const_cast<TypeFunctionSingletonType*>(tv)->variant) : nullptr;
-}
-
-struct TypeFunctionUnionType
-{
-    std::vector<TypeFunctionTypeId> components;
-};
-
-struct TypeFunctionIntersectionType
-{
-    std::vector<TypeFunctionTypeId> components;
-};
-
-struct TypeFunctionAnyType
-{
-};
-
-struct TypeFunctionUnknownType
-{
-};
-
-struct TypeFunctionNeverType
-{
-};
-
-struct TypeFunctionNegationType
-{
-    TypeFunctionTypeId type;
-};
-
-struct TypeFunctionTypePack
-{
-    std::vector<TypeFunctionTypeId> head;
-    std::optional<TypeFunctionTypePackId> tail;
-};
-
-struct TypeFunctionVariadicTypePack
-{
-    TypeFunctionTypeId type;
-};
-
-struct TypeFunctionGenericTypePack
-{
-    bool isNamed = false;
-
-    std::string name;
-};
-
-using TypeFunctionTypePackVariant = Variant<TypeFunctionTypePack, TypeFunctionVariadicTypePack, TypeFunctionGenericTypePack>;
-
-struct TypeFunctionTypePackVar
-{
-    TypeFunctionTypePackVariant type;
-
-    TypeFunctionTypePackVar(TypeFunctionTypePackVariant type)
-        : type(std::move(type))
-    {
-    }
-
-    bool operator==(const TypeFunctionTypePackVar& rhs) const;
-};
-
-struct TypeFunctionFunctionType
-{
-    std::vector<TypeFunctionTypeId> generics;
-    std::vector<TypeFunctionTypePackId> genericPacks;
-
-    TypeFunctionTypePackId argTypes;
-    TypeFunctionTypePackId retTypes;
-};
-
-template<typename T>
-const T* get(TypeFunctionTypePackId tv)
-{
-    LUAU_ASSERT(tv);
-
-    return tv ? get_if<T>(&tv->type) : nullptr;
-}
-
-template<typename T>
-T* getMutable(TypeFunctionTypePackId tv)
-{
-    LUAU_ASSERT(tv);
-
-    return tv ? get_if<T>(&const_cast<TypeFunctionTypePackVar*>(tv)->type) : nullptr;
-}
-
-struct TypeFunctionTableIndexer
-{
-    TypeFunctionTableIndexer(TypeFunctionTypeId keyType, TypeFunctionTypeId valueType)
-        : keyType(keyType)
-        , valueType(valueType)
-    {
-    }
-
-    TypeFunctionTypeId keyType;
-    TypeFunctionTypeId valueType;
-};
-
-struct TypeFunctionProperty
-{
-    static TypeFunctionProperty readonly(TypeFunctionTypeId ty);
-    static TypeFunctionProperty writeonly(TypeFunctionTypeId ty);
-    static TypeFunctionProperty rw(TypeFunctionTypeId ty);                             // Shared read-write type.
-    static TypeFunctionProperty rw(TypeFunctionTypeId read, TypeFunctionTypeId write); // Separate read-write type.
-
-    bool isReadOnly() const;
-    bool isWriteOnly() const;
-
-    std::optional<TypeFunctionTypeId> readTy;
-    std::optional<TypeFunctionTypeId> writeTy;
-};
-
-struct TypeFunctionTableType
-{
-    using Name = std::string;
-    using Props = std::map<Name, TypeFunctionProperty>;
-
-    Props props;
-
-    std::optional<TypeFunctionTableIndexer> indexer;
-
-    // Should always be a TypeFunctionTableType
-    std::optional<TypeFunctionTypeId> metatable;
-};
-
-struct TypeFunctionExternType
-{
-    using Name = std::string;
-    using Props = std::map<Name, TypeFunctionProperty>;
-
-    Props props;
-
-    std::optional<TypeFunctionTableIndexer> indexer;
-
-    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> readParent;
-    std::optional<TypeFunctionTypeId> writeParent;
-
-    TypeId externTy;
-};
-
-struct TypeFunctionGenericType
-{
-    bool isNamed = false;
-    bool isPack = false;
-
-    std::string name;
-};
-
-using TypeFunctionTypeVariant = Luau::Variant<
-    TypeFunctionPrimitiveType,
-    TypeFunctionAnyType,
-    TypeFunctionUnknownType,
-    TypeFunctionNeverType,
-    TypeFunctionSingletonType,
-    TypeFunctionUnionType,
-    TypeFunctionIntersectionType,
-    TypeFunctionNegationType,
-    TypeFunctionFunctionType,
-    TypeFunctionTableType,
-    TypeFunctionExternType,
-    TypeFunctionGenericType>;
-
-struct TypeFunctionType
-{
-    TypeFunctionTypeVariant type;
-
-    TypeFunctionType(TypeFunctionTypeVariant type)
-        : type(std::move(type))
-    {
-    }
-
-    bool operator==(const TypeFunctionType& rhs) const;
-};
-
-template<typename T>
-const T* get(TypeFunctionTypeId tv)
-{
-    LUAU_ASSERT(tv);
-
-    return tv ? Luau::get_if<T>(&tv->type) : nullptr;
-}
-
-template<typename T>
-T* getMutable(TypeFunctionTypeId tv)
-{
-    LUAU_ASSERT(tv);
-
-    return tv ? Luau::get_if<T>(&const_cast<TypeFunctionType*>(tv)->type) : nullptr;
-}
-
-std::optional<std::string> checkResultForError(lua_State* L, const char* typeFunctionName, int luaResult);
-
-TypeFunctionType* allocateTypeFunctionType(lua_State* L, TypeFunctionTypeVariant type);
-TypeFunctionTypePackVar* allocateTypeFunctionTypePack(lua_State* L, TypeFunctionTypePackVariant type);
-
-void allocTypeUserData(lua_State* L, TypeFunctionTypeVariant type);
-
-bool isTypeUserData(lua_State* L, int idx);
-TypeFunctionTypeId getTypeUserData(lua_State* L, int idx);
-std::optional<TypeFunctionTypeId> optionalTypeUserData(lua_State* L, int idx);
-
-void registerTypesLibrary(lua_State* L);
-void registerTypeUserData(lua_State* L);
-
-void setTypeFunctionEnvironment(lua_State* L);
-
-void resetTypeFunctionState(lua_State* L);
-
-} // namespace Luau

Analysis/include/Luau/TypeFunctionRuntimeBuilder.h

@@ -1,44 +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/Type.h"
-#include "Luau/TypeFunction.h"
-#include "Luau/TypeFunctionRuntime.h"
-
-namespace Luau
-{
-
-using Kind = Variant<TypeId, TypePackId>;
-
-template<typename T>
-const T* get(const Kind& kind)
-{
-    return get_if<T>(&kind);
-}
-
-using TypeFunctionKind = Variant<TypeFunctionTypeId, TypeFunctionTypePackId>;
-
-template<typename T>
-const T* get(const TypeFunctionKind& tfkind)
-{
-    return get_if<T>(&tfkind);
-}
-
-struct TypeFunctionRuntimeBuilderState
-{
-    NotNull<TypeFunctionContext> ctx;
-
-    // List of errors that occur during serialization/deserialization
-    // At every iteration of serialization/deserialization, if this list.size() != 0, we halt the process
-    std::vector<std::string> errors{};
-
-    TypeFunctionRuntimeBuilderState(NotNull<TypeFunctionContext> ctx)
-        : ctx(ctx)
-    {
-    }
-};
-
-TypeFunctionTypeId serialize(TypeId ty, TypeFunctionRuntimeBuilderState* state);
-TypeId deserialize(TypeFunctionTypeId ty, TypeFunctionRuntimeBuilderState* state);
-
-} // namespace Luau

Analysis/include/Luau/TypeFwd.h

@@ -1,59 +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/Variant.h"
-
-#include <string>
-
-namespace Luau
-{
-
-// So... why `const T*` here rather than `T*`?
-// It's because we've had problems caused by the type graph being mutated
-// in ways it shouldn't be, for example mutating types from other modules.
-// To try to control this, we make the use of types immutable by default,
-// then provide explicit mutable access via getMutable and asMutable.
-// This means we can grep for all the places we're mutating the type graph,
-// and it makes it possible to provide other APIs (e.g. the txn log)
-// which control mutable access to the type graph.
-
-struct Type;
-using TypeId = const Type*;
-
-struct FreeType;
-struct GenericType;
-struct PrimitiveType;
-struct BlockedType;
-struct PendingExpansionType;
-struct SingletonType;
-struct FunctionType;
-struct TableType;
-struct MetatableType;
-struct ExternType;
-struct AnyType;
-struct UnionType;
-struct IntersectionType;
-struct LazyType;
-struct UnknownType;
-struct NeverType;
-struct NegationType;
-struct TypeFunctionInstanceType;
-
-struct TypePackVar;
-using TypePackId = const TypePackVar*;
-
-struct FreeTypePack;
-struct GenericTypePack;
-struct TypePack;
-struct VariadicTypePack;
-struct BlockedTypePack;
-struct TypeFunctionInstanceTypePack;
-
-using Name = std::string;
-using ModuleName = std::string;
-
-struct BuiltinTypes;
-
-using TypeOrPack = Variant<TypeId, TypePackId>;
-
-} // namespace Luau

Analysis/include/Luau/TypeInfer.h

@@ -1,18 +1,15 @@
 // This file is part of the Luau programming language and is licensed under MIT License; see LICENSE.txt for details
 #pragma once
 
-#include "Luau/Anyification.h"
-#include "Luau/ControlFlow.h"
-#include "Luau/Error.h"
-#include "Luau/Instantiation.h"
-#include "Luau/Module.h"
 #include "Luau/Predicate.h"
-#include "Luau/Substitution.h"
+#include "Luau/Error.h"
+#include "Luau/Module.h"
 #include "Luau/Symbol.h"
+#include "Luau/Parser.h"
+#include "Luau/Substitution.h"
 #include "Luau/TxnLog.h"
-#include "Luau/TypeFwd.h"
-#include "Luau/TypeCheckLimits.h"
-#include "Luau/TypeUtils.h"
+#include "Luau/TypePack.h"
+#include "Luau/TypeVar.h"
 #include "Luau/Unifier.h"
 #include "Luau/UnifierSharedState.h"
 
@@ -26,207 +23,169 @@ namespace Luau
 struct Scope;
 struct TypeChecker;
 struct ModuleResolver;
-struct FrontendCancellationToken;
 
 using Name = std::string;
 using ScopePtr = std::shared_ptr<Scope>;
-
-struct OverloadErrorEntry
-{
-    TxnLog log;
-    ErrorVec errors;
-    std::vector<TypeId> arguments;
-    const FunctionType* fnTy;
-};
+using OverloadErrorEntry = std::tuple<std::vector<TypeError>, std::vector<TypeId>, const FunctionTypeVar*>;
 
 bool doesCallError(const AstExprCall* call);
 bool hasBreak(AstStat* node);
 const AstStat* getFallthrough(const AstStat* node);
 
-struct UnifierOptions;
 struct Unifier;
 
-struct GenericTypeDefinitions
+// A substitution which replaces generic types in a given set by free types.
+struct ReplaceGenerics : Substitution
 {
-    std::vector<GenericTypeDefinition> genericTypes;
-    std::vector<GenericTypePackDefinition> genericPacks;
+    TypeLevel level;
+    std::vector<TypeId> generics;
+    std::vector<TypePackId> genericPacks;
+    bool ignoreChildren(TypeId ty) override;
+    bool isDirty(TypeId ty) override;
+    bool isDirty(TypePackId tp) override;
+    TypeId clean(TypeId ty) override;
+    TypePackId clean(TypePackId tp) override;
 };
 
-struct HashBoolNamePair
+// A substitution which replaces generic functions by monomorphic functions
+struct Instantiation : Substitution
 {
-    size_t operator()(const std::pair<bool, Name>& pair) const;
+    TypeLevel level;
+    ReplaceGenerics replaceGenerics;
+    bool ignoreChildren(TypeId ty) override;
+    bool isDirty(TypeId ty) override;
+    bool isDirty(TypePackId tp) override;
+    TypeId clean(TypeId ty) override;
+    TypePackId clean(TypePackId tp) override;
 };
 
-// All Types are retained via Environment::types.  All TypeIds
+// A substitution which replaces free types by generic types.
+struct Quantification : Substitution
+{
+    TypeLevel level;
+    std::vector<TypeId> generics;
+    std::vector<TypePackId> genericPacks;
+    bool isDirty(TypeId ty) override;
+    bool isDirty(TypePackId tp) override;
+    TypeId clean(TypeId ty) override;
+    TypePackId clean(TypePackId tp) override;
+};
+
+// A substitution which replaces free types by any
+struct Anyification : Substitution
+{
+    TypeId anyType;
+    TypePackId anyTypePack;
+    bool isDirty(TypeId ty) override;
+    bool isDirty(TypePackId tp) override;
+    TypeId clean(TypeId ty) override;
+    TypePackId clean(TypePackId tp) override;
+};
+
+// A substitution which replaces the type parameters of a type function by arguments
+struct ApplyTypeFunction : Substitution
+{
+    TypeLevel level;
+    bool encounteredForwardedType;
+    std::unordered_map<TypeId, TypeId> typeArguments;
+    std::unordered_map<TypePackId, TypePackId> typePackArguments;
+    bool ignoreChildren(TypeId ty) override;
+    bool ignoreChildren(TypePackId tp) override;
+    bool isDirty(TypeId ty) override;
+    bool isDirty(TypePackId tp) override;
+    TypeId clean(TypeId ty) override;
+    TypePackId clean(TypePackId tp) override;
+};
+
+// All TypeVars are retained via Environment::typeVars.  All TypeIds
 // within a program are borrowed pointers into this set.
 struct TypeChecker
 {
-    explicit TypeChecker(
-        const ScopePtr& globalScope,
-        ModuleResolver* resolver,
-        NotNull<BuiltinTypes> builtinTypes,
-        InternalErrorReporter* iceHandler
-    );
+    explicit TypeChecker(ModuleResolver* resolver, InternalErrorReporter* iceHandler);
     TypeChecker(const TypeChecker&) = delete;
     TypeChecker& operator=(const TypeChecker&) = delete;
 
     ModulePtr check(const SourceModule& module, Mode mode, std::optional<ScopePtr> environmentScope = std::nullopt);
-    ModulePtr checkWithoutRecursionCheck(const SourceModule& module, Mode mode, std::optional<ScopePtr> environmentScope = std::nullopt);
 
     std::vector<std::pair<Location, ScopePtr>> getScopes() const;
 
-    ControlFlow check(const ScopePtr& scope, const AstStat& statement);
-    ControlFlow check(const ScopePtr& scope, const AstStatBlock& statement);
-    ControlFlow check(const ScopePtr& scope, const AstStatIf& statement);
-    ControlFlow check(const ScopePtr& scope, const AstStatWhile& statement);
-    ControlFlow check(const ScopePtr& scope, const AstStatRepeat& statement);
-    ControlFlow check(const ScopePtr& scope, const AstStatReturn& return_);
-    ControlFlow check(const ScopePtr& scope, const AstStatAssign& assign);
-    ControlFlow check(const ScopePtr& scope, const AstStatCompoundAssign& assign);
-    ControlFlow check(const ScopePtr& scope, const AstStatLocal& local);
-    ControlFlow check(const ScopePtr& scope, const AstStatFor& local);
-    ControlFlow check(const ScopePtr& scope, const AstStatForIn& forin);
-    ControlFlow check(const ScopePtr& scope, TypeId ty, const ScopePtr& funScope, const AstStatFunction& function);
-    ControlFlow check(const ScopePtr& scope, TypeId ty, const ScopePtr& funScope, const AstStatLocalFunction& function);
-    ControlFlow check(const ScopePtr& scope, const AstStatTypeAlias& typealias);
-    ControlFlow check(const ScopePtr& scope, const AstStatTypeFunction& typefunction);
-    ControlFlow check(const ScopePtr& scope, const AstStatDeclareExternType& declaredExternType);
-    ControlFlow check(const ScopePtr& scope, const AstStatDeclareFunction& declaredFunction);
+    void check(const ScopePtr& scope, const AstStat& statement);
+    void check(const ScopePtr& scope, const AstStatBlock& statement);
+    void check(const ScopePtr& scope, const AstStatIf& statement);
+    void check(const ScopePtr& scope, const AstStatWhile& statement);
+    void check(const ScopePtr& scope, const AstStatRepeat& statement);
+    void check(const ScopePtr& scope, const AstStatReturn& return_);
+    void check(const ScopePtr& scope, const AstStatAssign& assign);
+    void check(const ScopePtr& scope, const AstStatCompoundAssign& assign);
+    void check(const ScopePtr& scope, const AstStatLocal& local);
+    void check(const ScopePtr& scope, const AstStatFor& local);
+    void check(const ScopePtr& scope, const AstStatForIn& forin);
+    void check(const ScopePtr& scope, TypeId ty, const ScopePtr& funScope, const AstStatFunction& function);
+    void check(const ScopePtr& scope, TypeId ty, const ScopePtr& funScope, const AstStatLocalFunction& function);
+    void check(const ScopePtr& scope, const AstStatTypeAlias& typealias, int subLevel = 0, bool forwardDeclare = false);
+    void check(const ScopePtr& scope, const AstStatDeclareClass& declaredClass);
+    void check(const ScopePtr& scope, const AstStatDeclareFunction& declaredFunction);
 
-    void prototype(const ScopePtr& scope, const AstStatTypeAlias& typealias, int subLevel = 0);
-    void prototype(const ScopePtr& scope, const AstStatDeclareExternType& declaredExternType);
-
-    ControlFlow checkBlock(const ScopePtr& scope, const AstStatBlock& statement);
-    ControlFlow checkBlockWithoutRecursionCheck(const ScopePtr& scope, const AstStatBlock& statement);
+    void checkBlock(const ScopePtr& scope, const AstStatBlock& statement);
     void checkBlockTypeAliases(const ScopePtr& scope, std::vector<AstStat*>& sorted);
 
-    WithPredicate<TypeId> checkExpr(
-        const ScopePtr& scope,
-        const AstExpr& expr,
-        std::optional<TypeId> expectedType = std::nullopt,
-        bool forceSingleton = false
-    );
-    WithPredicate<TypeId> checkExpr(const ScopePtr& scope, const AstExprLocal& expr);
-    WithPredicate<TypeId> checkExpr(const ScopePtr& scope, const AstExprGlobal& expr);
-    WithPredicate<TypeId> checkExpr(const ScopePtr& scope, const AstExprVarargs& expr);
-    WithPredicate<TypeId> checkExpr(const ScopePtr& scope, const AstExprCall& expr);
-    WithPredicate<TypeId> checkExpr(const ScopePtr& scope, const AstExprIndexName& expr);
-    WithPredicate<TypeId> checkExpr(const ScopePtr& scope, const AstExprIndexExpr& expr);
-    WithPredicate<TypeId> checkExpr(const ScopePtr& scope, const AstExprFunction& expr, std::optional<TypeId> expectedType = std::nullopt);
-    WithPredicate<TypeId> checkExpr(const ScopePtr& scope, const AstExprTable& expr, std::optional<TypeId> expectedType = std::nullopt);
-    WithPredicate<TypeId> checkExpr(const ScopePtr& scope, const AstExprUnary& expr);
+    ExprResult<TypeId> checkExpr(const ScopePtr& scope, const AstExpr& expr, std::optional<TypeId> expectedType = std::nullopt);
+    ExprResult<TypeId> checkExpr(const ScopePtr& scope, const AstExprLocal& expr);
+    ExprResult<TypeId> checkExpr(const ScopePtr& scope, const AstExprGlobal& expr);
+    ExprResult<TypeId> checkExpr(const ScopePtr& scope, const AstExprVarargs& expr);
+    ExprResult<TypeId> checkExpr(const ScopePtr& scope, const AstExprCall& expr);
+    ExprResult<TypeId> checkExpr(const ScopePtr& scope, const AstExprIndexName& expr);
+    ExprResult<TypeId> checkExpr(const ScopePtr& scope, const AstExprIndexExpr& expr);
+    ExprResult<TypeId> checkExpr(const ScopePtr& scope, const AstExprFunction& expr, std::optional<TypeId> expectedType = std::nullopt);
+    ExprResult<TypeId> checkExpr(const ScopePtr& scope, const AstExprTable& expr, std::optional<TypeId> expectedType = std::nullopt);
+    ExprResult<TypeId> checkExpr(const ScopePtr& scope, const AstExprUnary& expr);
     TypeId checkRelationalOperation(
-        const ScopePtr& scope,
-        const AstExprBinary& expr,
-        TypeId lhsType,
-        TypeId rhsType,
-        const PredicateVec& predicates = {}
-    );
+        const ScopePtr& scope, const AstExprBinary& expr, TypeId lhsType, TypeId rhsType, const PredicateVec& predicates = {});
     TypeId checkBinaryOperation(
-        const ScopePtr& scope,
-        const AstExprBinary& expr,
-        TypeId lhsType,
-        TypeId rhsType,
-        const PredicateVec& predicates = {}
-    );
-    WithPredicate<TypeId> checkExpr(const ScopePtr& scope, const AstExprBinary& expr, std::optional<TypeId> expectedType = std::nullopt);
-    WithPredicate<TypeId> checkExpr_DEPRECATED(const ScopePtr& scope, const AstExprBinary& expr, std::optional<TypeId> expectedType = std::nullopt);
-    WithPredicate<TypeId> checkExpr(const ScopePtr& scope, const AstExprTypeAssertion& expr);
-    WithPredicate<TypeId> checkExpr(const ScopePtr& scope, const AstExprError& expr);
-    WithPredicate<TypeId> checkExpr(const ScopePtr& scope, const AstExprIfElse& expr, std::optional<TypeId> expectedType = std::nullopt);
-    WithPredicate<TypeId> checkExpr(const ScopePtr& scope, const AstExprInterpString& expr);
+        const ScopePtr& scope, const AstExprBinary& expr, TypeId lhsType, TypeId rhsType, const PredicateVec& predicates = {});
+    ExprResult<TypeId> checkExpr(const ScopePtr& scope, const AstExprBinary& expr);
+    ExprResult<TypeId> checkExpr(const ScopePtr& scope, const AstExprTypeAssertion& expr);
+    ExprResult<TypeId> checkExpr(const ScopePtr& scope, const AstExprError& expr);
+    ExprResult<TypeId> checkExpr(const ScopePtr& scope, const AstExprIfElse& expr);
 
-    TypeId checkExprTable(
-        const ScopePtr& scope,
-        const AstExprTable& expr,
-        const std::vector<std::pair<TypeId, TypeId>>& fieldTypes,
-        std::optional<TypeId> expectedType
-    );
+    TypeId checkExprTable(const ScopePtr& scope, const AstExprTable& expr, const std::vector<std::pair<TypeId, TypeId>>& fieldTypes,
+        std::optional<TypeId> expectedType);
 
     // Returns the type of the lvalue.
-    TypeId checkLValue(const ScopePtr& scope, const AstExpr& expr, ValueContext ctx);
+    TypeId checkLValue(const ScopePtr& scope, const AstExpr& expr);
 
-    // Returns the type of the lvalue.
-    TypeId checkLValueBinding(const ScopePtr& scope, const AstExpr& expr, ValueContext ctx);
-    TypeId checkLValueBinding(const ScopePtr& scope, const AstExprLocal& expr);
-    TypeId checkLValueBinding(const ScopePtr& scope, const AstExprGlobal& expr);
-    TypeId checkLValueBinding(const ScopePtr& scope, const AstExprIndexName& expr, ValueContext ctx);
-    TypeId checkLValueBinding(const ScopePtr& scope, const AstExprIndexExpr& expr, ValueContext ctx);
+    // Returns both the type of the lvalue and its binding (if the caller wants to mutate the binding).
+    // Note: the binding may be null.
+    // TODO: remove second return value with FFlagLuauUpdateFunctionNameBinding
+    std::pair<TypeId, TypeId*> checkLValueBinding(const ScopePtr& scope, const AstExpr& expr);
+    std::pair<TypeId, TypeId*> checkLValueBinding(const ScopePtr& scope, const AstExprLocal& expr);
+    std::pair<TypeId, TypeId*> checkLValueBinding(const ScopePtr& scope, const AstExprGlobal& expr);
+    std::pair<TypeId, TypeId*> checkLValueBinding(const ScopePtr& scope, const AstExprIndexName& expr);
+    std::pair<TypeId, TypeId*> checkLValueBinding(const ScopePtr& scope, const AstExprIndexExpr& expr);
 
     TypeId checkFunctionName(const ScopePtr& scope, AstExpr& funName, TypeLevel level);
-    std::pair<TypeId, ScopePtr> checkFunctionSignature(
-        const ScopePtr& scope,
-        int subLevel,
-        const AstExprFunction& expr,
-        std::optional<Location> originalNameLoc,
-        std::optional<TypeId> selfType,
-        std::optional<TypeId> expectedType
-    );
+    std::pair<TypeId, ScopePtr> checkFunctionSignature(const ScopePtr& scope, int subLevel, const AstExprFunction& expr,
+        std::optional<Location> originalNameLoc, std::optional<TypeId> expectedType);
     void checkFunctionBody(const ScopePtr& scope, TypeId type, const AstExprFunction& function);
 
     void checkArgumentList(
-        const ScopePtr& scope,
-        const AstExpr& funName,
-        Unifier& state,
-        TypePackId paramPack,
-        TypePackId argPack,
-        const std::vector<Location>& argLocations
-    );
-
-    WithPredicate<TypePackId> checkExprPack(const ScopePtr& scope, const AstExpr& expr);
-
-    WithPredicate<TypePackId> checkExprPackHelper(const ScopePtr& scope, const AstExpr& expr);
-    WithPredicate<TypePackId> checkExprPackHelper(const ScopePtr& scope, const AstExprCall& expr);
-    WithPredicate<TypePackId> checkExprPackHelper2(
-        const ScopePtr& scope,
-        const AstExprCall& expr,
-        TypeId selfType,
-        TypeId actualFunctionType,
-        TypeId functionType,
-        TypePackId retPack
-    );
+        const ScopePtr& scope, Unifier& state, TypePackId paramPack, TypePackId argPack, const std::vector<Location>& argLocations);
 
+    ExprResult<TypePackId> checkExprPack(const ScopePtr& scope, const AstExpr& expr);
+    ExprResult<TypePackId> checkExprPack(const ScopePtr& scope, const AstExprCall& expr);
     std::vector<std::optional<TypeId>> getExpectedTypesForCall(const std::vector<TypeId>& overloads, size_t argumentCount, bool selfCall);
+    std::optional<ExprResult<TypePackId>> checkCallOverload(const ScopePtr& scope, const AstExprCall& expr, TypeId fn, TypePackId retPack,
+        TypePackId argPack, TypePack* args, const std::vector<Location>* argLocations, const ExprResult<TypePackId>& argListResult,
+        std::vector<TypeId>& overloadsThatMatchArgCount, std::vector<TypeId>& overloadsThatDont, std::vector<OverloadErrorEntry>& errors);
+    bool handleSelfCallMismatch(const ScopePtr& scope, const AstExprCall& expr, TypePack* args, const std::vector<Location>& argLocations,
+        const std::vector<OverloadErrorEntry>& errors);
+    void reportOverloadResolutionError(const ScopePtr& scope, const AstExprCall& expr, TypePackId retPack, TypePackId argPack,
+        const std::vector<Location>& argLocations, const std::vector<TypeId>& overloads, const std::vector<TypeId>& overloadsThatMatchArgCount,
+        const std::vector<OverloadErrorEntry>& errors);
 
-    std::unique_ptr<WithPredicate<TypePackId>> checkCallOverload(
-        const ScopePtr& scope,
-        const AstExprCall& expr,
-        TypeId fn,
-        TypePackId retPack,
-        TypePackId argPack,
-        TypePack* args,
-        const std::vector<Location>* argLocations,
-        const WithPredicate<TypePackId>& argListResult,
-        std::vector<TypeId>& overloadsThatMatchArgCount,
-        std::vector<TypeId>& overloadsThatDont,
-        std::vector<OverloadErrorEntry>& errors
-    );
-    bool handleSelfCallMismatch(
-        const ScopePtr& scope,
-        const AstExprCall& expr,
-        TypePack* args,
-        const std::vector<Location>& argLocations,
-        const std::vector<OverloadErrorEntry>& errors
-    );
-    void reportOverloadResolutionError(
-        const ScopePtr& scope,
-        const AstExprCall& expr,
-        TypePackId retPack,
-        TypePackId argPack,
-        const std::vector<Location>& argLocations,
-        const std::vector<TypeId>& overloads,
-        const std::vector<TypeId>& overloadsThatMatchArgCount,
-        std::vector<OverloadErrorEntry>& errors
-    );
-
-    WithPredicate<TypePackId> checkExprList(
-        const ScopePtr& scope,
-        const Location& location,
-        const AstArray<AstExpr*>& exprs,
-        bool substituteFreeForNil = false,
-        const std::vector<bool>& lhsAnnotations = {},
-        const std::vector<std::optional<TypeId>>& expectedTypes = {}
-    );
+    ExprResult<TypePackId> checkExprList(const ScopePtr& scope, const Location& location, const AstArray<AstExpr*>& exprs,
+        bool substituteFreeForNil = false, const std::vector<bool>& lhsAnnotations = {},
+        const std::vector<std::optional<TypeId>>& expectedTypes = {});
 
     static std::optional<AstExpr*> matchRequire(const AstExprCall& call);
     TypeId checkRequire(const ScopePtr& scope, const ModuleInfo& moduleInfo, const Location& location);
@@ -235,53 +194,55 @@ struct TypeChecker
     // Reports an error if the type is already some kind of non-table.
     void tablify(TypeId type);
 
-    /** In nonstrict mode, many types need to be replaced by any.
+    /** In nonstrict mode, many typevars need to be replaced by any.
      */
     TypeId anyIfNonstrict(TypeId ty) const;
 
-    /** Attempt to unify the types.
-     * Treat any failures as type errors in the final typecheck report.
+    /** Attempt to unify the types left and right.  Treat any failures as type errors
+     * in the final typecheck report.
      */
-    bool unify(TypeId subTy, TypeId superTy, const ScopePtr& scope, const Location& location);
-    bool unify(TypeId subTy, TypeId superTy, const ScopePtr& scope, const Location& location, const UnifierOptions& options);
-    bool unify(
-        TypePackId subTy,
-        TypePackId superTy,
-        const ScopePtr& scope,
-        const Location& location,
-        CountMismatch::Context ctx = CountMismatch::Context::Arg
-    );
+    bool unify(TypeId left, TypeId right, const Location& location);
+    bool unify(TypePackId left, TypePackId right, const Location& location, CountMismatch::Context ctx = CountMismatch::Context::Arg);
 
-    /** Attempt to unify the types.
-     * If this fails, and the subTy type can be instantiated, do so and try unification again.
+    /** Attempt to unify the types left and right.
+     * If this fails, and the right type can be instantiated, do so and try unification again.
      */
-    bool unifyWithInstantiationIfNeeded(TypeId subTy, TypeId superTy, const ScopePtr& scope, const Location& location);
-    void unifyWithInstantiationIfNeeded(TypeId subTy, TypeId superTy, const ScopePtr& scope, Unifier& state);
+    bool unifyWithInstantiationIfNeeded(const ScopePtr& scope, TypeId left, TypeId right, const Location& location);
+    void unifyWithInstantiationIfNeeded(const ScopePtr& scope, TypeId left, TypeId right, Unifier& state);
 
-    /** Attempt to unify.
+    /** Attempt to unify left with right.
      * If there are errors, undo everything and return the errors.
      * If there are no errors, commit and return an empty error vector.
      */
-    template<typename Id>
-    ErrorVec tryUnify_(Id subTy, Id superTy, const ScopePtr& scope, const Location& location);
-    ErrorVec tryUnify(TypeId subTy, TypeId superTy, const ScopePtr& scope, const Location& location);
-    ErrorVec tryUnify(TypePackId subTy, TypePackId superTy, const ScopePtr& scope, const Location& location);
+    ErrorVec tryUnify(TypeId left, TypeId right, const Location& location);
+    ErrorVec tryUnify(TypePackId left, TypePackId right, const Location& location);
 
     // Test whether the two type vars unify.  Never commits the result.
-    template<typename Id>
-    ErrorVec canUnify_(Id subTy, Id superTy, const ScopePtr& scope, const Location& location);
-    ErrorVec canUnify(TypeId subTy, TypeId superTy, const ScopePtr& scope, const Location& location);
-    ErrorVec canUnify(TypePackId subTy, TypePackId superTy, const ScopePtr& scope, const Location& location);
+    ErrorVec canUnify(TypeId superTy, TypeId subTy, const Location& location);
+    ErrorVec canUnify(TypePackId superTy, TypePackId subTy, const Location& location);
 
-    std::optional<TypeId> findMetatableEntry(TypeId type, std::string entry, const Location& location, bool addErrors);
-    std::optional<TypeId> findTablePropertyRespectingMeta(TypeId lhsType, Name name, const Location& location, bool addErrors);
+    // Variant that takes a preexisting 'seen' set.  We need this in certain cases to avoid infinitely recursing
+    // into cyclic types.
+    ErrorVec canUnify(const std::vector<std::pair<TypeId, TypeId>>& seen, TypeId left, TypeId right, const Location& location);
+
+    std::optional<TypeId> findMetatableEntry(TypeId type, std::string entry, const Location& location);
+    std::optional<TypeId> findTablePropertyRespectingMeta(TypeId lhsType, Name name, const Location& location);
 
     std::optional<TypeId> getIndexTypeFromType(const ScopePtr& scope, TypeId type, const Name& name, const Location& location, bool addErrors);
-    std::optional<TypeId> getIndexTypeFromTypeImpl(const ScopePtr& scope, TypeId type, const Name& name, const Location& location, bool addErrors);
+
+    // Reduces the union to its simplest possible shape.
+    // (A | B) | B | C yields A | B | C
+    std::vector<TypeId> reduceUnion(const std::vector<TypeId>& types);
 
     std::optional<TypeId> tryStripUnionFromNil(TypeId ty);
     TypeId stripFromNilAndReport(TypeId ty, const Location& location);
 
+    template<typename Id>
+    ErrorVec tryUnify_(Id left, Id right, const Location& location);
+
+    template<typename Id>
+    ErrorVec canUnify_(Id left, Id right, const Location& location);
+
 public:
     /*
      * Convert monotype into a a polytype, by replacing any metavariables in descendant scopes
@@ -302,23 +263,19 @@ public:
      *     {method: ({method: (<CYCLE>) -> a}) -> a}
      *
      */
-    TypeId instantiate(const ScopePtr& scope, TypeId ty, Location location, const TxnLog* log = TxnLog::empty());
+    TypeId instantiate(const ScopePtr& scope, TypeId ty, Location location);
 
     // Replace any free types or type packs by `any`.
     // This is used when exporting types from modules, to make sure free types don't leak.
     TypeId anyify(const ScopePtr& scope, TypeId ty, Location location);
     TypePackId anyify(const ScopePtr& scope, TypePackId ty, Location location);
 
-    TypePackId anyifyModuleReturnTypePackGenerics(TypePackId ty);
-
     void reportError(const TypeError& error);
     void reportError(const Location& location, TypeErrorData error);
     void reportErrors(const ErrorVec& errors);
 
     [[noreturn]] void ice(const std::string& message, const Location& location);
     [[noreturn]] void ice(const std::string& message);
-    [[noreturn]] void throwTimeLimitError();
-    [[noreturn]] void throwUserCancelError();
 
     ScopePtr childFunctionScope(const ScopePtr& parent, const Location& location, int subLevel = 0);
     ScopePtr childScope(const ScopePtr& parent, const Location& location);
@@ -340,7 +297,7 @@ private:
     void reportErrorCodeTooComplex(const Location& location);
 
 private:
-    Unifier mkUnifier(const ScopePtr& scope, const Location& location);
+    Unifier mkUnifier(const Location& location);
 
     // These functions are only safe to call when we are in the process of typechecking a module.
 
@@ -352,27 +309,22 @@ private:
     TypeId singletonType(bool value);
     TypeId singletonType(std::string value);
 
-    TypeIdPredicate mkTruthyPredicate(bool sense, TypeId emptySetTy);
+    // Returns nullopt if the predicate filters down the TypeId to 0 options.
+    std::optional<TypeId> filterMap(TypeId type, TypeIdPredicate predicate);
 
-    // TODO: Return TypeId only.
-    std::optional<TypeId> filterMapImpl(TypeId type, TypeIdPredicate predicate);
-    std::pair<std::optional<TypeId>, bool> filterMap(TypeId type, TypeIdPredicate predicate);
-
-public:
-    std::pair<std::optional<TypeId>, bool> pickTypesFromSense(TypeId type, bool sense, TypeId emptySetTy);
-
-private:
-    TypeId unionOfTypes(TypeId a, TypeId b, const ScopePtr& scope, const Location& location, bool unifyFreeTypes = true);
+    TypeId unionOfTypes(TypeId a, TypeId b, const Location& location, bool unifyFreeTypes = true);
 
     // ex
-    //      TypeId id = addType(FreeType());
+    //      TypeId id = addType(FreeTypeVar());
     template<typename T>
     TypeId addType(const T& tv)
     {
-        return addTV(Type(tv));
+        return addTV(TypeVar(tv));
     }
 
-    TypeId addTV(Type&& tv);
+    TypeId addType(const UnionTypeVar& utv);
+
+    TypeId addTV(TypeVar&& tv);
 
     TypePackId addTypePack(TypePackVar&& tp);
     TypePackId addTypePack(TypePack&& tp);
@@ -384,47 +336,32 @@ private:
     TypePackId freshTypePack(TypeLevel level);
 
     TypeId resolveType(const ScopePtr& scope, const AstType& annotation);
-    TypeId resolveTypeWorker(const ScopePtr& scope, const AstType& annotation);
     TypePackId resolveTypePack(const ScopePtr& scope, const AstTypeList& types);
     TypePackId resolveTypePack(const ScopePtr& scope, const AstTypePack& annotation);
-    TypeId instantiateTypeFun(
-        const ScopePtr& scope,
-        const TypeFun& tf,
-        const std::vector<TypeId>& typeParams,
-        const std::vector<TypePackId>& typePackParams,
-        const Location& location
-    );
+    TypeId instantiateTypeFun(const ScopePtr& scope, const TypeFun& tf, const std::vector<TypeId>& typeParams,
+        const std::vector<TypePackId>& typePackParams, const Location& location);
 
     // Note: `scope` must be a fresh scope.
-    GenericTypeDefinitions createGenericTypes(
-        const ScopePtr& scope,
-        std::optional<TypeLevel> levelOpt,
-        const AstNode& node,
-        const AstArray<AstGenericType*>& genericNames,
-        const AstArray<AstGenericTypePack*>& genericPackNames,
-        bool useCache = false
-    );
+    std::pair<std::vector<TypeId>, std::vector<TypePackId>> createGenericTypes(const ScopePtr& scope, std::optional<TypeLevel> levelOpt,
+        const AstNode& node, const AstArray<AstName>& genericNames, const AstArray<AstName>& genericPackNames);
 
 public:
-    void resolve(const PredicateVec& predicates, const ScopePtr& scope, bool sense);
+    ErrorVec resolve(const PredicateVec& predicates, const ScopePtr& scope, bool sense);
 
 private:
-    void refineLValue(const LValue& lvalue, RefinementMap& refis, const ScopePtr& scope, TypeIdPredicate predicate);
-
     std::optional<TypeId> resolveLValue(const ScopePtr& scope, const LValue& lvalue);
     std::optional<TypeId> resolveLValue(const RefinementMap& refis, const ScopePtr& scope, const LValue& lvalue);
 
-    void resolve(const PredicateVec& predicates, RefinementMap& refis, const ScopePtr& scope, bool sense, bool fromOr = false);
-    void resolve(const Predicate& predicate, RefinementMap& refis, const ScopePtr& scope, bool sense, bool fromOr);
-    void resolve(const TruthyPredicate& truthyP, RefinementMap& refis, const ScopePtr& scope, bool sense, bool fromOr);
-    void resolve(const AndPredicate& andP, RefinementMap& refis, const ScopePtr& scope, bool sense);
-    void resolve(const OrPredicate& orP, RefinementMap& refis, const ScopePtr& scope, bool sense);
-    void resolve(const IsAPredicate& isaP, RefinementMap& refis, const ScopePtr& scope, bool sense);
-    void resolve(const TypeGuardPredicate& typeguardP, RefinementMap& refis, const ScopePtr& scope, bool sense);
-    void resolve(const EqPredicate& eqP, RefinementMap& refis, const ScopePtr& scope, bool sense);
+    void resolve(const PredicateVec& predicates, ErrorVec& errVec, RefinementMap& refis, const ScopePtr& scope, bool sense, bool fromOr = false);
+    void resolve(const Predicate& predicate, ErrorVec& errVec, RefinementMap& refis, const ScopePtr& scope, bool sense, bool fromOr);
+    void resolve(const TruthyPredicate& truthyP, ErrorVec& errVec, RefinementMap& refis, const ScopePtr& scope, bool sense, bool fromOr);
+    void resolve(const AndPredicate& andP, ErrorVec& errVec, RefinementMap& refis, const ScopePtr& scope, bool sense);
+    void resolve(const OrPredicate& orP, ErrorVec& errVec, RefinementMap& refis, const ScopePtr& scope, bool sense);
+    void resolve(const IsAPredicate& isaP, ErrorVec& errVec, RefinementMap& refis, const ScopePtr& scope, bool sense);
+    void resolve(const TypeGuardPredicate& typeguardP, ErrorVec& errVec, RefinementMap& refis, const ScopePtr& scope, bool sense);
+    void resolve(const EqPredicate& eqP, ErrorVec& errVec, RefinementMap& refis, const ScopePtr& scope, bool sense);
 
     bool isNonstrictMode() const;
-    bool useConstrainedIntersections() const;
 
 public:
     /** Extract the types in a type pack, given the assumption that the pack must have some exact length.
@@ -432,32 +369,27 @@ public:
      * Calling this function means submitting evidence that the pack must have the length provided.
      * If the pack is known not to have the correct length, an error will be reported.
      * The return vector is always of the exact requested length.  In the event that the pack's length does
-     * not match up, excess TypeIds will be ErrorTypes.
+     * not match up, excess TypeIds will be ErrorTypeVars.
      */
     std::vector<TypeId> unTypePack(const ScopePtr& scope, TypePackId pack, size_t expectedLength, const Location& location);
 
-    const ScopePtr& globalScope;
+    TypeArena globalTypes;
 
     ModuleResolver* resolver;
+    SourceModule globalNames; // names for symbols entered into globalScope
+    ScopePtr globalScope;     // shared by all modules
     ModulePtr currentModule;
+    ModuleName currentModuleName;
+
+    Instantiation instantiation;
+    Quantification quantification;
+    Anyification anyification;
+    ApplyTypeFunction applyTypeFunction;
 
     std::function<void(const ModuleName&, const ScopePtr&)> prepareModuleScope;
-    NotNull<BuiltinTypes> builtinTypes;
     InternalErrorReporter* iceHandler;
 
     UnifierSharedState unifierState;
-    Normalizer normalizer;
-
-    Instantiation reusableInstantiation;
-
-    std::vector<RequireCycle> requireCycles;
-
-    // Type inference limits
-    std::optional<double> finishTime;
-    std::optional<int> instantiationChildLimit;
-    std::optional<int> unifierIterationLimit;
-
-    std::shared_ptr<FrontendCancellationToken> cancellationToken;
 
 public:
     const TypeId nilType;
@@ -465,39 +397,18 @@ public:
     const TypeId stringType;
     const TypeId booleanType;
     const TypeId threadType;
-    const TypeId bufferType;
     const TypeId anyType;
-    const TypeId unknownType;
-    const TypeId neverType;
+    const TypeId optionalNumberType;
 
     const TypePackId anyTypePack;
-    const TypePackId neverTypePack;
-    const TypePackId uninhabitableTypePack;
 
 private:
     int checkRecursionCount = 0;
     int recursionCount = 0;
-
-    /**
-     * We use this to avoid doing second-pass analysis of type aliases that are duplicates. We record a pair
-     * (exported, name) to properly deal with the case where the two duplicates do not have the same export status.
-     */
-    DenseHashSet<std::pair<bool, Name>, HashBoolNamePair> duplicateTypeAliases;
-
-    /**
-     * A set of incorrect class definitions which is used to avoid a second-pass analysis.
-     */
-    DenseHashSet<const AstStatDeclareExternType*> incorrectExternTypeDefinitions{nullptr};
-
-    std::vector<std::pair<TypeId, ScopePtr>> deferredQuantification;
 };
 
-using PrintLineProc = void (*)(const std::string&);
-
-extern PrintLineProc luauPrintLine;
-
 // Unit test hook
-void setPrintLine(PrintLineProc pl);
+void setPrintLine(void (*pl)(const std::string& s));
 void resetPrintLine();
 
 } // namespace Luau

Analysis/include/Luau/TypeOrPack.h

@@ -1,41 +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/Type.h"
-#include "Luau/TypePack.h"
-#include "Luau/Variant.h"
-
-#include <type_traits>
-
-namespace Luau
-{
-
-const void* ptr(TypeOrPack ty);
-
-template<typename T, typename std::enable_if_t<TypeOrPack::is_part_of_v<T>, bool> = true>
-const T* get(const TypeOrPack& tyOrTp)
-{
-    return tyOrTp.get_if<T>();
-}
-
-template<typename T, typename std::enable_if_t<TypeVariant::is_part_of_v<T>, bool> = true>
-const T* get(const TypeOrPack& tyOrTp)
-{
-    if (const TypeId* ty = get<TypeId>(tyOrTp))
-        return get<T>(*ty);
-    else
-        return nullptr;
-}
-
-template<typename T, typename std::enable_if_t<TypePackVariant::is_part_of_v<T>, bool> = true>
-const T* get(const TypeOrPack& tyOrTp)
-{
-    if (const TypePackId* tp = get<TypePackId>(tyOrTp))
-        return get<T>(*tp);
-    else
-        return nullptr;
-}
-
-TypeOrPack follow(TypeOrPack ty);
-
-} // namespace Luau

Analysis/include/Luau/TypePack.h

@@ -1,66 +1,28 @@
 // This file is part of the Luau programming language and is licensed under MIT License; see LICENSE.txt for details
 #pragma once
 
-#include "Luau/Common.h"
-#include "Luau/NotNull.h"
-#include "Luau/Polarity.h"
-#include "Luau/TypeFwd.h"
+#include "Luau/TypeVar.h"
 #include "Luau/Unifiable.h"
 #include "Luau/Variant.h"
 
 #include <optional>
 #include <set>
-#include <vector>
 
 namespace Luau
 {
 
 struct TypeArena;
-struct TypePackFunction;
-struct TxnLog;
 
 struct TypePack;
 struct VariadicTypePack;
-struct BlockedTypePack;
-struct TypeFunctionInstanceTypePack;
 
-struct FreeTypePack
-{
-    explicit FreeTypePack(TypeLevel level);
-    explicit FreeTypePack(Scope* scope, Polarity polarity = Polarity::Unknown);
-    FreeTypePack(Scope* scope, TypeLevel level);
-
-    int index;
-    TypeLevel level;
-    Scope* scope = nullptr;
-
-    Polarity polarity = Polarity::Unknown;
-};
-
-struct GenericTypePack
-{
-    // By default, generics are global, with a synthetic name
-    GenericTypePack();
-    explicit GenericTypePack(TypeLevel level);
-    explicit GenericTypePack(const Name& name);
-    explicit GenericTypePack(Scope* scope, Polarity polarity = Polarity::Unknown);
-    GenericTypePack(TypeLevel level, const Name& name);
-    GenericTypePack(Scope* scope, const Name& name);
-
-    int index;
-    TypeLevel level;
-    Scope* scope = nullptr;
-    Name name;
-    bool explicitName = false;
-
-    Polarity polarity = Polarity::Unknown;
-};
+struct TypePackVar;
 
+using TypePackId = const TypePackVar*;
+using FreeTypePack = Unifiable::Free;
 using BoundTypePack = Unifiable::Bound<TypePackId>;
-using ErrorTypePack = Unifiable::Error<TypePackId>;
-
-using TypePackVariant =
-    Unifiable::Variant<TypePackId, FreeTypePack, GenericTypePack, TypePack, VariadicTypePack, BlockedTypePack, TypeFunctionInstanceTypePack>;
+using GenericTypePack = Unifiable::Generic;
+using TypePackVariant = Unifiable::Variant<TypePackId, TypePack, VariadicTypePack>;
 
 /* A TypePack is a rope-like string of TypeIds.  We use this structure to encode
  * notions like packs of unknown length and packs of any length, as well as more
@@ -76,62 +38,29 @@ struct TypePack
 struct VariadicTypePack
 {
     TypeId ty;
-    bool hidden = false; // if true, we don't display this when toString()ing a pack with this variadic as its tail.
-};
-
-/**
- * Analogous to a BlockedType.
- */
-struct BlockedTypePack
-{
-    BlockedTypePack();
-    size_t index;
-
-    struct Constraint* owner = nullptr;
-
-    static size_t nextIndex;
-};
-
-/**
- * Analogous to a TypeFunctionInstanceType.
- */
-struct TypeFunctionInstanceTypePack
-{
-    NotNull<const TypePackFunction> function;
-
-    std::vector<TypeId> typeArguments;
-    std::vector<TypePackId> packArguments;
 };
 
 struct TypePackVar
 {
-    explicit TypePackVar(const TypePackVariant& tp);
-    explicit TypePackVar(TypePackVariant&& tp);
-    TypePackVar(TypePackVariant&& tp, bool persistent);
-
+    explicit TypePackVar(const TypePackVariant& ty);
+    explicit TypePackVar(TypePackVariant&& ty);
+    TypePackVar(TypePackVariant&& ty, bool persistent);
     bool operator==(const TypePackVar& rhs) const;
-
     TypePackVar& operator=(TypePackVariant&& tp);
 
-    TypePackVar& operator=(const TypePackVar& rhs);
-
-    // Re-assignes the content of the pack, but doesn't change the owning arena and can't make pack persistent.
-    void reassign(const TypePackVar& rhs)
-    {
-        ty = rhs.ty;
-    }
-
     TypePackVariant ty;
-
     bool persistent = false;
 
-    // Pointer to the type arena that allocated this pack.
+    // Pointer to the type arena that allocated this type.
+    // Do not depend on the value of this under any circumstances. This is for
+    // debugging purposes only. This is only set in debug builds; it is nullptr
+    // in all other environments.
     TypeArena* owningArena = nullptr;
 };
 
 /* Walk the set of TypeIds in a TypePack.
  *
- * Like Types, individual TypePacks can be free, generic, or any.
+ * Like TypeVars, individual TypePacks can be free, generic, or any.
  *
  * We afford the ability to work with these kinds of packs by giving the
  * iterator a .tail() property that yields the tail-most TypePack in the
@@ -155,7 +84,6 @@ struct TypePackIterator
 
     TypePackIterator() = default;
     explicit TypePackIterator(TypePackId tp);
-    TypePackIterator(TypePackId tp, const TxnLog* log);
 
     TypePackIterator& operator++();
     TypePackIterator operator++(int);
@@ -174,30 +102,23 @@ struct TypePackIterator
 
 private:
     TypePackId currentTypePack = nullptr;
-    TypePackId tailCycleCheck = nullptr;
     const TypePack* tp = nullptr;
     size_t currentIndex = 0;
-
-    const TxnLog* log;
 };
 
 TypePackIterator begin(TypePackId tp);
-TypePackIterator begin(TypePackId tp, const TxnLog* log);
 TypePackIterator end(TypePackId tp);
 
-TypePackId getTail(TypePackId tp);
-
-using SeenSet = std::set<std::pair<const void*, const void*>>;
+using SeenSet = std::set<std::pair<void*, void*>>;
 
 bool areEqual(SeenSet& seen, const TypePackVar& lhs, const TypePackVar& rhs);
 
 TypePackId follow(TypePackId tp);
-TypePackId follow(TypePackId t, const void* context, TypePackId (*mapper)(const void*, TypePackId));
 
-size_t size(TypePackId tp, TxnLog* log = nullptr);
-bool finite(TypePackId tp, TxnLog* log = nullptr);
-size_t size(const TypePack& tp, TxnLog* log = nullptr);
-std::optional<TypeId> first(TypePackId tp, bool ignoreHiddenVariadics = true);
+size_t size(TypePackId tp);
+bool finite(TypePackId tp);
+size_t size(const TypePack& tp);
+std::optional<TypeId> first(TypePackId tp);
 
 TypePackVar* asMutable(TypePackId tp);
 TypePack* asMutable(const TypePack* tp);
@@ -229,30 +150,5 @@ bool isEmpty(TypePackId tp);
 
 /// Flattens out a type pack.  Also returns a valid TypePackId tail if the type pack's full size is not known
 std::pair<std::vector<TypeId>, std::optional<TypePackId>> flatten(TypePackId tp);
-std::pair<std::vector<TypeId>, std::optional<TypePackId>> flatten(TypePackId tp, const TxnLog& log);
-
-/// Returs true if the type pack arose from a function that is declared to be variadic.
-/// Returns *false* for function argument packs that are inferred to be safe to oversaturate!
-bool isVariadic(TypePackId tp);
-bool isVariadic(TypePackId tp, const TxnLog& log);
-
-// Returns true if the TypePack is Generic or Variadic.  Does not walk TypePacks!!
-bool isVariadicTail(TypePackId tp, const TxnLog& log, bool includeHiddenVariadics = false);
-
-bool containsNever(TypePackId tp);
-
-/*
- * Use this to change the kind of a particular type pack.
- *
- * LUAU_NOINLINE so that the calling frame doesn't have to pay the stack storage for the new variant.
- */
-template<typename T, typename... Args>
-LUAU_NOINLINE T* emplaceTypePack(TypePackVar* ty, Args&&... args)
-{
-    return &ty->ty.emplace<T>(std::forward<Args>(args)...);
-}
-
-template<>
-LUAU_NOINLINE Unifiable::Bound<TypePackId>* emplaceTypePack<BoundTypePack>(TypePackVar* ty, TypePackId& tyArg);
 
 } // namespace Luau

Analysis/include/Luau/TypePairHash.h

@@ -1,35 +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/TypeFwd.h"
-
-#include <stdint.h>
-#include <utility>
-
-namespace Luau
-{
-
-struct TypePairHash
-{
-    size_t hashOne(TypeId key) const
-    {
-        return (uintptr_t(key) >> 4) ^ (uintptr_t(key) >> 9);
-    }
-
-    size_t hashOne(TypePackId key) const
-    {
-        return (uintptr_t(key) >> 4) ^ (uintptr_t(key) >> 9);
-    }
-
-    size_t operator()(const std::pair<TypeId, TypeId>& x) const
-    {
-        return hashOne(x.first) ^ (hashOne(x.second) << 1);
-    }
-
-    size_t operator()(const std::pair<TypePackId, TypePackId>& x) const
-    {
-        return hashOne(x.first) ^ (hashOne(x.second) << 1);
-    }
-};
-
-} // namespace Luau

Analysis/include/Luau/TypePath.h

@@ -1,252 +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/TypeFwd.h"
-#include "Luau/Variant.h"
-#include "Luau/NotNull.h"
-
-#include <optional>
-#include <string>
-#include <vector>
-
-namespace Luau
-{
-
-namespace TypePath
-{
-
-/// Represents a property of a class, table, or anything else with a concept of
-/// a named property.
-struct Property
-{
-    /// The name of the property.
-    std::string name;
-    /// Whether to look at the read or the write type.
-    bool isRead = true;
-
-    explicit Property(std::string name);
-    Property(std::string name, bool read)
-        : name(std::move(name))
-        , isRead(read)
-    {
-    }
-
-    static Property read(std::string name);
-    static Property write(std::string name);
-
-    bool operator==(const Property& other) const;
-};
-
-/// Represents an index into a type or a pack. For a type, this indexes into a
-/// union or intersection's list. For a pack, this indexes into the pack's nth
-/// 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;
-};
-
-/// Represents fields of a type or pack that contain a type.
-enum class TypeField
-{
-    /// The table of a metatable type.
-    Table,
-    /// The metatable of a type. This could be a metatable type, a primitive
-    /// type, a class type, or perhaps even a string singleton type.
-    Metatable,
-    /// The lower bound of this type, if one is present.
-    LowerBound,
-    /// The upper bound of this type, if present.
-    UpperBound,
-    /// The index type.
-    IndexLookup,
-    /// The indexer result type.
-    IndexResult,
-    /// The negated type, for negations.
-    Negated,
-    /// The variadic type for a type pack.
-    Variadic,
-};
-
-/// Represents fields of a type or type pack that contain a type pack.
-enum class PackField
-{
-    /// What arguments this type accepts.
-    Arguments,
-    /// What this type returns when called.
-    Returns,
-    /// The tail of a type pack.
-    Tail,
-};
-
-/// Component that represents the result of a reduction
-/// `resultType` is `never` if the reduction could not proceed
-struct Reduction
-{
-    TypeId resultType;
-
-    bool operator==(const Reduction& other) const;
-};
-
-/// A single component of a path, representing one inner type or type pack to
-/// traverse into.
-using Component = Luau::Variant<Property, Index, TypeField, PackField, Reduction>;
-
-/// A path through a type or type pack accessing a particular type or type pack
-/// contained within.
-///
-/// Paths are always relative; to make use of a Path, you need to specify an
-/// entry point. They are not canonicalized; two Paths may not compare equal but
-/// may point to the same result, depending on the layout of the entry point.
-///
-/// Paths always descend through an entry point. This doesn't mean that they
-/// cannot reach "upwards" in the actual type hierarchy in some cases, but it
-/// does mean that there is no equivalent to `../` in file system paths. This is
-/// intentional and unavoidable, because types and type packs don't have a
-/// concept of a parent - they are a directed cyclic graph, with no hierarchy
-/// that actually holds in all cases.
-struct Path
-{
-    /// The Components of this Path.
-    std::vector<Component> components;
-
-    /// Creates a new empty Path.
-    Path() {}
-
-    /// Creates a new Path from a list of components.
-    explicit Path(std::vector<Component> components)
-        : components(std::move(components))
-    {
-    }
-
-    /// Creates a new single-component Path.
-    explicit Path(Component component)
-        : components({component})
-    {
-    }
-
-    /// Creates a new Path by appending another Path to this one.
-    /// @param suffix the Path to append
-    /// @return a new Path representing `this + suffix`
-    Path append(const Path& suffix) const;
-
-    /// Creates a new Path by appending a Component to this Path.
-    /// @param component the Component to append
-    /// @return a new Path with `component` appended to it.
-    Path push(Component component) const;
-
-    /// Creates a new Path by prepending a Component to this Path.
-    /// @param component the Component to prepend
-    /// @return a new Path with `component` prepended to it.
-    Path push_front(Component component) const;
-
-    /// Creates a new Path by removing the last Component of this Path.
-    /// If the Path is empty, this is a no-op.
-    /// @return a Path with the last component removed.
-    Path pop() const;
-
-    /// Returns the last Component of this Path, if present.
-    std::optional<Component> last() const;
-
-    /// Returns whether this Path is empty, meaning it has no components at all.
-    /// Traversing an empty Path results in the type you started with.
-    bool empty() const;
-
-    bool operator==(const Path& other) const;
-    bool operator!=(const Path& other) const
-    {
-        return !(*this == other);
-    }
-};
-
-struct PathHash
-{
-    size_t operator()(const Property& prop) const;
-    size_t operator()(const Index& idx) const;
-    size_t operator()(const TypeField& field) const;
-    size_t operator()(const PackField& field) const;
-    size_t operator()(const Reduction& reduction) const;
-    size_t operator()(const Component& component) const;
-    size_t operator()(const Path& path) const;
-};
-
-/// The canonical "empty" Path, meaning a Path with no components.
-static const Path kEmpty{};
-
-struct PathBuilder
-{
-    std::vector<Component> components;
-
-    Path build();
-
-    PathBuilder& readProp(std::string name);
-    PathBuilder& writeProp(std::string name);
-    PathBuilder& prop(std::string name);
-    PathBuilder& index(size_t i);
-    PathBuilder& mt();
-    PathBuilder& lb();
-    PathBuilder& ub();
-    PathBuilder& indexKey();
-    PathBuilder& indexValue();
-    PathBuilder& negated();
-    PathBuilder& variadic();
-    PathBuilder& args();
-    PathBuilder& rets();
-    PathBuilder& tail();
-};
-
-} // namespace TypePath
-
-using Path = TypePath::Path;
-
-/// Converts a Path to a string for debugging purposes. This output may not be
-/// 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);
-
-/// Traverses a path from a type to its end point, which must be a type.
-/// @param root the entry point of the traversal
-/// @param path the path to traverse
-/// @param builtinTypes the built-in types in use (used to acquire the string metatable)
-/// @returns the TypeId at the end of the path, or nullopt if the traversal failed.
-std::optional<TypeId> traverseForType(TypeId root, const Path& path, NotNull<BuiltinTypes> builtinTypes);
-
-/// Traverses a path from a type pack to its end point, which must be a type.
-/// @param root the entry point of the traversal
-/// @param path the path to traverse
-/// @param builtinTypes the built-in types in use (used to acquire the string metatable)
-/// @returns the TypeId at the end of the path, or nullopt if the traversal failed.
-std::optional<TypeId> traverseForType(TypePackId root, const Path& path, NotNull<BuiltinTypes> builtinTypes);
-
-/// Traverses a path from a type to its end point, which must be a type pack.
-/// @param root the entry point of the traversal
-/// @param path the path to traverse
-/// @param builtinTypes the built-in types in use (used to acquire the string metatable)
-/// @returns the TypePackId at the end of the path, or nullopt if the traversal failed.
-std::optional<TypePackId> traverseForPack(TypeId root, const Path& path, NotNull<BuiltinTypes> builtinTypes);
-
-/// Traverses a path from a type pack to its end point, which must be a type pack.
-/// @param root the entry point of the traversal
-/// @param path the path to traverse
-/// @param builtinTypes the built-in types in use (used to acquire the string metatable)
-/// @returns the TypePackId at the end of the path, or nullopt if the traversal failed.
-std::optional<TypePackId> traverseForPack(TypePackId root, const Path& path, NotNull<BuiltinTypes> builtinTypes);
-
-} // namespace Luau

Analysis/include/Luau/TypeUtils.h

@@ -3,8 +3,7 @@
 
 #include "Luau/Error.h"
 #include "Luau/Location.h"
-#include "Luau/Type.h"
-#include "Luau/TypePack.h"
+#include "Luau/TypeVar.h"
 
 #include <memory>
 #include <optional>
@@ -12,283 +11,9 @@
 namespace Luau
 {
 
-struct TxnLog;
-struct TypeArena;
-class Normalizer;
-
-enum class ValueContext
-{
-    LValue,
-    RValue
-};
-
-/// the current context of the type checker
-enum class TypeContext
-{
-    /// the default context
-    Default,
-    /// inside of a condition
-    Condition,
-};
-
-bool inConditional(const TypeContext& context);
-
-// sets the given type context to `Condition` and restores it to its original
-// value when the struct drops out of scope
-struct InConditionalContext
-{
-    TypeContext* typeContext;
-    TypeContext oldValue;
-
-    explicit InConditionalContext(TypeContext* c)
-        : typeContext(c)
-        , oldValue(*c)
-    {
-        *typeContext = TypeContext::Condition;
-    }
-
-    ~InConditionalContext()
-    {
-        *typeContext = oldValue;
-    }
-};
-
 using ScopePtr = std::shared_ptr<struct Scope>;
 
-std::optional<Property> findTableProperty(
-    NotNull<BuiltinTypes> builtinTypes,
-    ErrorVec& errors,
-    TypeId ty,
-    const std::string& name,
-    Location location
-);
-
-std::optional<TypeId> findMetatableEntry(
-    NotNull<BuiltinTypes> builtinTypes,
-    ErrorVec& errors,
-    TypeId type,
-    const std::string& entry,
-    Location location
-);
-std::optional<TypeId> findTablePropertyRespectingMeta(
-    NotNull<BuiltinTypes> builtinTypes,
-    ErrorVec& errors,
-    TypeId ty,
-    const std::string& name,
-    Location location
-);
-std::optional<TypeId> findTablePropertyRespectingMeta(
-    NotNull<BuiltinTypes> builtinTypes,
-    ErrorVec& errors,
-    TypeId ty,
-    const std::string& name,
-    ValueContext context,
-    Location location
-);
-
-bool occursCheck(TypeId needle, TypeId haystack);
-
-// Returns the minimum and maximum number of types the argument list can accept.
-std::pair<size_t, std::optional<size_t>> getParameterExtents(const TxnLog* log, TypePackId tp, bool includeHiddenVariadics = false);
-
-// Extend the provided pack to at least `length` types.
-// Returns a temporary TypePack that contains those types plus a tail.
-TypePack extendTypePack(
-    TypeArena& arena,
-    NotNull<BuiltinTypes> builtinTypes,
-    TypePackId pack,
-    size_t length,
-    std::vector<std::optional<TypeId>> overrides = {}
-);
-
-/**
- * Reduces a union by decomposing to the any/error type if it appears in the
- * type list, and by merging child unions. Also strips out duplicate (by pointer
- * identity) types.
- * @param types the input type list to reduce.
- * @returns the reduced type list.
- */
-std::vector<TypeId> reduceUnion(const std::vector<TypeId>& types);
-
-/**
- * Tries to remove nil from a union type, if there's another option. T | nil
- * reduces to T, but nil itself does not reduce.
- * @param builtinTypes the singleton types to use
- * @param arena the type arena to allocate the new type in, if necessary
- * @param ty the type to remove nil from
- * @returns a type with nil removed, or nil itself if that were the only option.
- */
-TypeId stripNil(NotNull<BuiltinTypes> builtinTypes, TypeArena& arena, TypeId ty);
-
-struct ErrorSuppression
-{
-    enum Value
-    {
-        Suppress,
-        DoNotSuppress,
-        NormalizationFailed,
-    };
-
-    ErrorSuppression() = default;
-    constexpr ErrorSuppression(Value enumValue)
-        : value(enumValue)
-    {
-    }
-
-    constexpr operator Value() const
-    {
-        return value;
-    }
-    explicit operator bool() const = delete;
-
-    ErrorSuppression orElse(const ErrorSuppression& other) const
-    {
-        switch (value)
-        {
-        case DoNotSuppress:
-            return other;
-        default:
-            return *this;
-        }
-    }
-
-private:
-    Value value;
-};
-
-/**
- * Normalizes the given type using the normalizer to determine if the type
- * should suppress any errors that would be reported involving it.
- * @param normalizer the normalizer to use
- * @param ty the type to check for error suppression
- * @returns an enum indicating whether or not to suppress the error or to signal a normalization failure
- */
-ErrorSuppression shouldSuppressErrors(NotNull<Normalizer> normalizer, TypeId ty);
-
-/**
- * Flattens and normalizes the given typepack using the normalizer to determine if the type
- * should suppress any errors that would be reported involving it.
- * @param normalizer the normalizer to use
- * @param tp the typepack to check for error suppression
- * @returns an enum indicating whether or not to suppress the error or to signal a normalization failure
- */
-ErrorSuppression shouldSuppressErrors(NotNull<Normalizer> normalizer, TypePackId tp);
-
-/**
- * Normalizes the two given type using the normalizer to determine if either type
- * should suppress any errors that would be reported involving it.
- * @param normalizer the normalizer to use
- * @param ty1 the first type to check for error suppression
- * @param ty2 the second type to check for error suppression
- * @returns an enum indicating whether or not to suppress the error or to signal a normalization failure
- */
-ErrorSuppression shouldSuppressErrors(NotNull<Normalizer> normalizer, TypeId ty1, TypeId ty2);
-
-/**
- * Flattens and normalizes the two given typepacks using the normalizer to determine if either type
- * should suppress any errors that would be reported involving it.
- * @param normalizer the normalizer to use
- * @param tp1 the first typepack to check for error suppression
- * @param tp2 the second typepack to check for error suppression
- * @returns an enum indicating whether or not to suppress the error or to signal a normalization failure
- */
-ErrorSuppression shouldSuppressErrors(NotNull<Normalizer> normalizer, TypePackId tp1, TypePackId tp2);
-
-// Similar to `std::optional<std::pair<A, B>>`, but whose `sizeof()` is the same as `std::pair<A, B>`
-// and cooperates with C++'s `if (auto p = ...)` syntax without the extra fatness of `std::optional`.
-template<typename A, typename B>
-struct TryPair
-{
-    A first;
-    B second;
-
-    explicit operator bool() const
-    {
-        return bool(first) && bool(second);
-    }
-};
-
-template<typename A, typename B, typename Ty>
-TryPair<const A*, const B*> get2(Ty one, Ty two)
-{
-    static_assert(std::is_pointer_v<Ty>, "argument must be a pointer type");
-
-    const A* a = get<A>(one);
-    const B* b = get<B>(two);
-    if (a && b)
-        return {a, b};
-    else
-        return {nullptr, nullptr};
-}
-
-template<typename T, typename Ty>
-const T* get(std::optional<Ty> ty)
-{
-    if (ty)
-        return get<T>(*ty);
-    else
-        return nullptr;
-}
-
-template<typename T, typename Ty>
-T* getMutable(std::optional<Ty> ty)
-{
-    if (ty)
-        return getMutable<T>(*ty);
-    else
-        return nullptr;
-}
-
-template<typename Ty>
-std::optional<Ty> follow(std::optional<Ty> ty)
-{
-    if (ty)
-        return follow(*ty);
-    else
-        return std::nullopt;
-}
-
-/**
- * Returns whether or not expr is a literal expression, for example:
- * - Scalar literals (numbers, booleans, strings, nil)
- * - Table literals
- * - Lambdas (a "function literal")
- */
-bool isLiteral(const AstExpr* expr);
-
-/**
- * Given a table literal and a mapping from expression to type, determine
- * whether any literal expression in this table depends on any blocked types.
- * This is used as a precondition for bidirectional inference: be warned that
- * the behavior of this algorithm is tightly coupled to that of bidirectional
- * inference.
- * @param expr Expression to search
- * @param astTypes Mapping from AST node to TypeID
- * @returns A vector of blocked types
- */
-std::vector<TypeId> findBlockedTypesIn(AstExprTable* expr, NotNull<DenseHashMap<const AstExpr*, TypeId>> astTypes);
-
-/**
- * Given a function call and a mapping from expression to type, determine
- * whether the type of any argument in said call in depends on a blocked types.
- * This is used as a precondition for bidirectional inference: be warned that
- * the behavior of this algorithm is tightly coupled to that of bidirectional
- * inference.
- * @param expr Expression to search
- * @param astTypes Mapping from AST node to TypeID
- * @returns A vector of blocked types
- */
-std::vector<TypeId> findBlockedArgTypesIn(AstExprCall* expr, NotNull<DenseHashMap<const AstExpr*, TypeId>> astTypes);
-
-/**
- * Given a scope and a free type, find the closest parent that has a present
- * `interiorFreeTypes` and append the given type to said list. This list will
- * be generalized when the requiste `GeneralizationConstraint` is resolved.
- * @param scope Initial scope this free type was attached to
- * @param ty Free type to track.
- */
-void trackInteriorFreeType(Scope* scope, TypeId ty);
-
-void trackInteriorFreeTypePack(Scope* scope, TypePackId tp);
+std::optional<TypeId> findMetatableEntry(ErrorVec& errors, const ScopePtr& globalScope, TypeId type, std::string entry, Location location);
+std::optional<TypeId> findTablePropertyRespectingMeta(ErrorVec& errors, const ScopePtr& globalScope, TypeId ty, Name name, Location location);
 
 } // namespace Luau

Analysis/include/Luau/TypeVar.h

@@ -0,0 +1,603 @@
+// This file is part of the Luau programming language and is licensed under MIT License; see LICENSE.txt for details
+#pragma once
+
+#include "Luau/Predicate.h"
+#include "Luau/Unifiable.h"
+#include "Luau/Variant.h"
+#include "Luau/Common.h"
+
+#include <set>
+#include <string>
+#include <map>
+#include <unordered_set>
+#include <unordered_map>
+#include <vector>
+#include <deque>
+#include <memory>
+#include <optional>
+
+LUAU_FASTINT(LuauTableTypeMaximumStringifierLength)
+LUAU_FASTINT(LuauTypeMaximumStringifierLength)
+
+namespace Luau
+{
+
+struct TypeArena;
+
+/**
+ * There are three kinds of type variables:
+ * - `Free` variables are metavariables, which stand for unconstrained types.
+ * - `Bound` variables are metavariables that have an equality constraint.
+ * - `Generic` variables are type variables that are bound by generic functions.
+ *
+ * For example, consider the program:
+ * ```
+ * function(x, y) x.f = y end
+ * ```
+ * To typecheck this, we first introduce free metavariables for the types of `x` and `y`:
+ * ```
+ * function(x: X, y: Y) x.f = y end
+ * ```
+ * Type inference for the function body then produces the constraint:
+ * ```
+ * X = { f: Y }
+ * ```
+ * so `X` is now a bound metavariable. We can then quantify the metavariables,
+ * which replaces any bound metavariables by their binding, and free metavariables
+ * by bound generic variables:
+ * ```
+ * function<a>(x: { f: a }, y: a) x.f = y end
+ * ```
+ */
+
+// So... why `const T*` here rather than `T*`?
+// It's because we've had problems caused by the type graph being mutated
+// in ways it shouldn't be, for example mutating types from other modules.
+// To try to control this, we make the use of types immutable by default,
+// then provide explicit mutable access via getMutable and asMutable.
+// This means we can grep for all the places we're mutating the type graph,
+// and it makes it possible to provide other APIs (e.g. the txn log)
+// which control mutable access to the type graph.
+struct TypePackVar;
+using TypePackId = const TypePackVar*;
+
+// TODO: rename to Type? CLI-39100
+struct TypeVar;
+
+// Should never be null
+using TypeId = const TypeVar*;
+
+using Name = std::string;
+
+// A free type var is one whose exact shape has yet to be fully determined.
+using FreeTypeVar = Unifiable::Free;
+
+// When a free type var is unified with any other, it is then "bound"
+// to that type var, indicating that the two types are actually the same type.
+using BoundTypeVar = Unifiable::Bound<TypeId>;
+
+using GenericTypeVar = Unifiable::Generic;
+
+using Tags = std::vector<std::string>;
+
+using ModuleName = std::string;
+
+struct PrimitiveTypeVar
+{
+    enum Type
+    {
+        NilType, // ObjC #defines Nil :(
+        Boolean,
+        Number,
+        String,
+        Thread,
+    };
+
+    Type type;
+    std::optional<TypeId> metatable; // string has a metatable
+
+    explicit PrimitiveTypeVar(Type type)
+        : type(type)
+    {
+    }
+
+    explicit PrimitiveTypeVar(Type type, TypeId metatable)
+        : type(type)
+        , metatable(metatable)
+    {
+    }
+};
+
+// Singleton types https://github.com/Roblox/luau/blob/master/rfcs/syntax-singleton-types.md
+// Types for true and false
+struct BoolSingleton
+{
+    bool value;
+
+    bool operator==(const BoolSingleton& rhs) const
+    {
+        return value == rhs.value;
+    }
+
+    bool operator!=(const BoolSingleton& rhs) const
+    {
+        return !(*this == rhs);
+    }
+};
+
+// Types for "foo", "bar" etc.
+struct StringSingleton
+{
+    std::string value;
+
+    bool operator==(const StringSingleton& rhs) const
+    {
+        return value == rhs.value;
+    }
+
+    bool operator!=(const StringSingleton& rhs) const
+    {
+        return !(*this == rhs);
+    }
+};
+
+// No type for float singletons, partly because === isn't any equalivalence on floats
+// (NaN != NaN).
+
+using SingletonVariant = Luau::Variant<BoolSingleton, StringSingleton>;
+
+struct SingletonTypeVar
+{
+    explicit SingletonTypeVar(const SingletonVariant& variant)
+        : variant(variant)
+    {
+    }
+
+    explicit SingletonTypeVar(SingletonVariant&& variant)
+        : variant(std::move(variant))
+    {
+    }
+
+    // Default operator== is C++20.
+    bool operator==(const SingletonTypeVar& rhs) const
+    {
+        return variant == rhs.variant;
+    }
+
+    bool operator!=(const SingletonTypeVar& rhs) const
+    {
+        return !(*this == rhs);
+    }
+
+    SingletonVariant variant;
+};
+
+template<typename T>
+const T* get(const SingletonTypeVar* stv)
+{
+    if (stv)
+        return get_if<T>(&stv->variant);
+    else
+        return nullptr;
+}
+
+struct FunctionArgument
+{
+    Name name;
+    Location location;
+};
+
+struct FunctionDefinition
+{
+    std::optional<ModuleName> definitionModuleName;
+    Location definitionLocation;
+    std::optional<Location> varargLocation;
+    Location originalNameLocation;
+};
+
+// TODO: Come up with a better name.
+// TODO: Do we actually need this? We'll find out later if we can delete this.
+// Does not exactly belong in TypeVar.h, but this is the only way to appease the compiler.
+template<typename T>
+struct ExprResult
+{
+    T type;
+    PredicateVec predicates;
+};
+
+using MagicFunction = std::function<std::optional<ExprResult<TypePackId>>(
+    struct TypeChecker&, const std::shared_ptr<struct Scope>&, const class AstExprCall&, ExprResult<TypePackId>)>;
+
+struct FunctionTypeVar
+{
+    // Global monomorphic function
+    FunctionTypeVar(TypePackId argTypes, TypePackId retType, std::optional<FunctionDefinition> defn = {}, bool hasSelf = false);
+
+    // Global polymorphic function
+    FunctionTypeVar(std::vector<TypeId> generics, std::vector<TypePackId> genericPacks, TypePackId argTypes, TypePackId retType,
+        std::optional<FunctionDefinition> defn = {}, bool hasSelf = false);
+
+    // Local monomorphic function
+    FunctionTypeVar(TypeLevel level, TypePackId argTypes, TypePackId retType, std::optional<FunctionDefinition> defn = {}, bool hasSelf = false);
+
+    // Local polymorphic function
+    FunctionTypeVar(TypeLevel level, std::vector<TypeId> generics, std::vector<TypePackId> genericPacks, TypePackId argTypes, TypePackId retType,
+        std::optional<FunctionDefinition> defn = {}, bool hasSelf = false);
+
+    TypeLevel level;
+    /// These should all be generic
+    std::vector<TypeId> generics;
+    std::vector<TypePackId> genericPacks;
+    TypePackId argTypes;
+    std::vector<std::optional<FunctionArgument>> argNames;
+    TypePackId retType;
+    std::optional<FunctionDefinition> definition;
+    MagicFunction magicFunction = nullptr; // Function pointer, can be nullptr.
+    bool hasSelf;
+    Tags tags;
+};
+
+enum class TableState
+{
+    // Sealed tables have an exact, known shape
+    Sealed,
+
+    // An unsealed table can have extra properties added to it
+    Unsealed,
+
+    // Tables which are not yet fully understood.  We are still in the process of learning its shape.
+    Free,
+
+    // A table which is a generic parameter to a function.  We know that certain properties are required,
+    // but we don't care about the full shape.
+    Generic,
+};
+
+struct TableIndexer
+{
+    TableIndexer(TypeId indexType, TypeId indexResultType)
+        : indexType(indexType)
+        , indexResultType(indexResultType)
+    {
+    }
+
+    TypeId indexType;
+    TypeId indexResultType;
+};
+
+struct Property
+{
+    TypeId type;
+    bool deprecated = false;
+    std::string deprecatedSuggestion;
+    std::optional<Location> location = std::nullopt;
+    Tags tags;
+    std::optional<std::string> documentationSymbol;
+};
+
+struct TableTypeVar
+{
+    // We choose std::map over unordered_map here just because we have unit tests that compare
+    // textual outputs.  I don't want to spend the effort making them resilient in the case where
+    // random events cause the iteration order of the map elements to change.
+    // If this shows up in a profile, we can revisit it.
+    using Props = std::map<Name, Property>;
+
+    TableTypeVar() = default;
+    explicit TableTypeVar(TableState state, TypeLevel level);
+    TableTypeVar(const Props& props, const std::optional<TableIndexer>& indexer, TypeLevel level, TableState state = TableState::Unsealed);
+
+    Props props;
+    std::optional<TableIndexer> indexer;
+
+    TableState state = TableState::Unsealed;
+    TypeLevel level;
+    std::optional<std::string> name;
+
+    // Sometimes we throw a type on a name to make for nicer error messages, but without creating any entry in the type namespace
+    // We need to know which is which when we stringify types.
+    std::optional<std::string> syntheticName;
+
+    std::map<Name, Location> methodDefinitionLocations;
+    std::vector<TypeId> instantiatedTypeParams;
+    std::vector<TypePackId> instantiatedTypePackParams;
+    ModuleName definitionModuleName;
+
+    std::optional<TypeId> boundTo;
+    Tags tags;
+};
+
+// Represents a metatable attached to a table typevar. Somewhat analogous to a bound typevar.
+struct MetatableTypeVar
+{
+    // Always points to a TableTypeVar.
+    TypeId table;
+    // Always points to either a TableTypeVar or a MetatableTypeVar.
+    TypeId metatable;
+
+    std::optional<std::string> syntheticName;
+};
+
+// Custom userdata of a class type
+struct ClassUserData
+{
+    virtual ~ClassUserData() {}
+};
+
+/** The type of a class.
+ *
+ * Classes behave like tables in many ways, but there are some important differences:
+ *
+ * The properties of a class are always exactly known.
+ * Classes optionally have a parent class.
+ * Two different classes that share the same properties are nevertheless distinct and mutually incompatible.
+ */
+struct ClassTypeVar
+{
+    using Props = TableTypeVar::Props;
+
+    Name name;
+    Props props;
+    std::optional<TypeId> parent;
+    std::optional<TypeId> metatable; // metaclass?
+    Tags tags;
+    std::shared_ptr<ClassUserData> userData;
+
+    ClassTypeVar(
+        Name name, Props props, std::optional<TypeId> parent, std::optional<TypeId> metatable, Tags tags, std::shared_ptr<ClassUserData> userData)
+        : name(name)
+        , props(props)
+        , parent(parent)
+        , metatable(metatable)
+        , tags(tags)
+        , userData(userData)
+    {
+    }
+};
+
+struct TypeFun
+{
+    // These should all be generic
+    std::vector<TypeId> typeParams;
+    std::vector<TypePackId> typePackParams;
+
+    /** The underlying type.
+     *
+     * WARNING!  This is not safe to use as a type if typeParams is not empty!!
+     * You must first use TypeChecker::instantiateTypeFun to turn it into a real type.
+     */
+    TypeId type;
+
+    TypeFun() = default;
+    TypeFun(std::vector<TypeId> typeParams, TypeId type)
+        : typeParams(std::move(typeParams))
+        , type(type)
+    {
+    }
+
+    TypeFun(std::vector<TypeId> typeParams, std::vector<TypePackId> typePackParams, TypeId type)
+        : typeParams(std::move(typeParams))
+        , typePackParams(std::move(typePackParams))
+        , type(type)
+    {
+    }
+};
+
+// Anything!  All static checking is off.
+struct AnyTypeVar
+{
+};
+
+struct UnionTypeVar
+{
+    std::vector<TypeId> options;
+};
+
+struct IntersectionTypeVar
+{
+    std::vector<TypeId> parts;
+};
+
+struct LazyTypeVar
+{
+    std::function<TypeId()> thunk;
+};
+
+using ErrorTypeVar = Unifiable::Error;
+
+using TypeVariant = Unifiable::Variant<TypeId, PrimitiveTypeVar, SingletonTypeVar, FunctionTypeVar, TableTypeVar, MetatableTypeVar, ClassTypeVar,
+    AnyTypeVar, UnionTypeVar, IntersectionTypeVar, LazyTypeVar>;
+
+struct TypeVar final
+{
+    explicit TypeVar(const TypeVariant& ty)
+        : ty(ty)
+    {
+    }
+
+    explicit TypeVar(TypeVariant&& ty)
+        : ty(std::move(ty))
+    {
+    }
+
+    TypeVar(const TypeVariant& ty, bool persistent)
+        : ty(ty)
+        , persistent(persistent)
+    {
+    }
+
+    TypeVariant ty;
+
+    // Kludge: A persistent TypeVar is one that belongs to the global scope.
+    // Global type bindings are immutable but are reused many times.
+    // Persistent TypeVars do not get cloned.
+    bool persistent = false;
+
+    std::optional<std::string> documentationSymbol;
+
+    // Pointer to the type arena that allocated this type.
+    // Do not depend on the value of this under any circumstances. This is for
+    // debugging purposes only. This is only set in debug builds; it is nullptr
+    // in all other environments.
+    TypeArena* owningArena = nullptr;
+
+    bool operator==(const TypeVar& rhs) const;
+    bool operator!=(const TypeVar& rhs) const;
+
+    TypeVar& operator=(const TypeVariant& rhs);
+    TypeVar& operator=(TypeVariant&& rhs);
+};
+
+using SeenSet = std::set<std::pair<void*, void*>>;
+bool areEqual(SeenSet& seen, const TypeVar& lhs, const TypeVar& rhs);
+
+// Follow BoundTypeVars until we get to something real
+TypeId follow(TypeId t);
+
+std::vector<TypeId> flattenIntersection(TypeId ty);
+
+bool isPrim(TypeId ty, PrimitiveTypeVar::Type primType);
+bool isNil(TypeId ty);
+bool isBoolean(TypeId ty);
+bool isNumber(TypeId ty);
+bool isString(TypeId ty);
+bool isThread(TypeId ty);
+bool isOptional(TypeId ty);
+bool isTableIntersection(TypeId ty);
+bool isOverloadedFunction(TypeId ty);
+
+std::optional<TypeId> getMetatable(TypeId type);
+TableTypeVar* getMutableTableType(TypeId type);
+const TableTypeVar* getTableType(TypeId type);
+
+// If the type has a name, return that.  Else if it has a synthetic name, return that.
+// Returns nullptr if the type has no name.
+const std::string* getName(TypeId type);
+
+// Checks whether a union contains all types of another union.
+bool isSubset(const UnionTypeVar& super, const UnionTypeVar& sub);
+
+// Checks if a type contains generic type binders
+bool isGeneric(const TypeId ty);
+
+// Checks if a type may be instantiated to one containing generic type binders
+bool maybeGeneric(const TypeId ty);
+
+// Checks if a type is of the form T1|...|Tn where one of the Ti is a singleton
+bool maybeSingleton(TypeId ty);
+
+struct SingletonTypes
+{
+    const TypeId nilType;
+    const TypeId numberType;
+    const TypeId stringType;
+    const TypeId booleanType;
+    const TypeId threadType;
+    const TypeId anyType;
+    const TypeId optionalNumberType;
+
+    const TypePackId anyTypePack;
+
+    SingletonTypes();
+    ~SingletonTypes();
+    SingletonTypes(const SingletonTypes&) = delete;
+    void operator=(const SingletonTypes&) = delete;
+
+    TypeId errorRecoveryType(TypeId guess);
+    TypePackId errorRecoveryTypePack(TypePackId guess);
+    TypeId errorRecoveryType();
+    TypePackId errorRecoveryTypePack();
+
+private:
+    std::unique_ptr<struct TypeArena> arena;
+    bool debugFreezeArena = false;
+
+    TypeId makeStringMetatable();
+};
+
+SingletonTypes& getSingletonTypes();
+
+void persist(TypeId ty);
+void persist(TypePackId tp);
+
+const TypeLevel* getLevel(TypeId ty);
+TypeLevel* getMutableLevel(TypeId ty);
+
+const Property* lookupClassProp(const ClassTypeVar* cls, const Name& name);
+bool isSubclass(const ClassTypeVar* cls, const ClassTypeVar* parent);
+
+TypeVar* asMutable(TypeId ty);
+
+template<typename T>
+const T* get(TypeId tv)
+{
+    LUAU_ASSERT(tv);
+
+    if constexpr (!std::is_same_v<T, BoundTypeVar>)
+        LUAU_ASSERT(get_if<BoundTypeVar>(&tv->ty) == nullptr);
+
+    return get_if<T>(&tv->ty);
+}
+
+template<typename T>
+T* getMutable(TypeId tv)
+{
+    LUAU_ASSERT(tv);
+
+    if constexpr (!std::is_same_v<T, BoundTypeVar>)
+        LUAU_ASSERT(get_if<BoundTypeVar>(&tv->ty) == nullptr);
+
+    return get_if<T>(&asMutable(tv)->ty);
+}
+
+/* Traverses the UnionTypeVar yielding each TypeId.
+ * If the iterator encounters a nested UnionTypeVar, it will instead yield each TypeId within.
+ *
+ * Beware: the iterator does not currently filter for unique TypeIds. This may change in the future.
+ */
+struct UnionTypeVarIterator
+{
+    using value_type = Luau::TypeId;
+    using pointer = value_type*;
+    using reference = value_type&;
+    using difference_type = size_t;
+    using iterator_category = std::input_iterator_tag;
+
+    explicit UnionTypeVarIterator(const UnionTypeVar* utv);
+
+    UnionTypeVarIterator& operator++();
+    UnionTypeVarIterator operator++(int);
+    bool operator!=(const UnionTypeVarIterator& rhs);
+    bool operator==(const UnionTypeVarIterator& rhs);
+
+    const TypeId& operator*();
+
+    friend UnionTypeVarIterator end(const UnionTypeVar* utv);
+
+private:
+    UnionTypeVarIterator() = default;
+
+    // (UnionTypeVar* utv, size_t currentIndex)
+    using SavedIterInfo = std::pair<const UnionTypeVar*, size_t>;
+
+    std::deque<SavedIterInfo> stack;
+    std::unordered_set<const UnionTypeVar*> seen; // Only needed to protect the iterator from hanging the thread.
+
+    void advance();
+    void descend();
+};
+
+UnionTypeVarIterator begin(const UnionTypeVar* utv);
+UnionTypeVarIterator end(const UnionTypeVar* utv);
+
+using TypeIdPredicate = std::function<std::optional<TypeId>(TypeId)>;
+std::vector<TypeId> filterMap(TypeId type, TypeIdPredicate predicate);
+
+void attachTag(TypeId ty, const std::string& tagName);
+void attachTag(Property& prop, const std::string& tagName);
+
+bool hasTag(TypeId ty, const std::string& tagName);
+bool hasTag(const Property& prop, const std::string& tagName);
+bool hasTag(const Tags& tags, const std::string& tagName); // Do not use in new work.
+
+} // namespace Luau

Analysis/include/Luau/TypedAllocator.h

@@ -10,7 +10,7 @@ namespace Luau
 {
 
 void* pagedAllocate(size_t size);
-void pagedDeallocate(void* ptr, size_t size);
+void pagedDeallocate(void* ptr);
 void pagedFreeze(void* ptr, size_t size);
 void pagedUnfreeze(void* ptr, size_t size);
 
@@ -20,15 +20,9 @@ class TypedAllocator
 public:
     TypedAllocator()
     {
-        currentBlockSize = kBlockSize;
+        appendBlock();
     }
 
-    TypedAllocator(const TypedAllocator&) = delete;
-    TypedAllocator& operator=(const TypedAllocator&) = delete;
-
-    TypedAllocator(TypedAllocator&&) = default;
-    TypedAllocator& operator=(TypedAllocator&&) = default;
-
     ~TypedAllocator()
     {
         if (frozen)
@@ -65,12 +59,12 @@ public:
 
     bool empty() const
     {
-        return stuff.empty();
+        return stuff.size() == 1 && currentBlockSize == 0;
     }
 
     size_t size() const
     {
-        return stuff.empty() ? 0 : kBlockSize * (stuff.size() - 1) + currentBlockSize;
+        return kBlockSize * (stuff.size() - 1) + currentBlockSize;
     }
 
     void clear()
@@ -78,8 +72,7 @@ public:
         if (frozen)
             unfreeze();
         free();
-
-        currentBlockSize = kBlockSize;
+        appendBlock();
     }
 
     void freeze()
@@ -113,7 +106,7 @@ private:
             for (size_t i = 0; i < blockSize; ++i)
                 block[i].~T();
 
-            pagedDeallocate(block, kBlockSizeBytes);
+            pagedDeallocate(block);
         }
 
         stuff.clear();

Analysis/include/Luau/Unifiable.h

@@ -3,16 +3,13 @@
 
 #include "Luau/Variant.h"
 
-#include <optional>
 #include <string>
 
 namespace Luau
 {
 
-struct Scope;
-
 /**
- * The 'level' of a Type is an indirect way to talk about the scope that it 'belongs' too.
+ * The 'level' of a TypeVar is an indirect way to talk about the scope that it 'belongs' too.
  * To start, read http://okmij.org/ftp/ML/generalization.html
  *
  * We extend the idea by adding a "sub-level" which helps us to differentiate sibling scopes
@@ -59,14 +56,6 @@ struct TypeLevel
     }
 };
 
-inline TypeLevel max(const TypeLevel& a, const TypeLevel& b)
-{
-    if (a.subsumes(b))
-        return b;
-    else
-        return a;
-}
-
 inline TypeLevel min(const TypeLevel& a, const TypeLevel& b)
 {
     if (a.subsumes(b))
@@ -75,14 +64,25 @@ inline TypeLevel min(const TypeLevel& a, const TypeLevel& b)
         return b;
 }
 
-} // namespace Luau
-
-namespace Luau::Unifiable
+namespace Unifiable
 {
 
 using Name = std::string;
 
-int freshIndex();
+struct Free
+{
+    explicit Free(TypeLevel level);
+
+    int index;
+    TypeLevel level;
+    // True if this free type variable is part of a mutually
+    // recursive type alias whose definitions haven't been
+    // resolved yet.
+    bool forwardedTypeAlias = false;
+
+private:
+    static int nextIndex;
+};
 
 template<typename Id>
 struct Bound
@@ -95,29 +95,37 @@ struct Bound
     Id boundTo;
 };
 
-template<typename Id>
-struct Error
+struct Generic
 {
-    // This constructor has to be public, since it's used in Type and TypePack,
-    // but shouldn't be called directly. Please use errorRecoveryType() instead.
-    explicit Error();
-
-    explicit Error(Id synthetic)
-        : synthetic{synthetic}
-    {
-    }
+    // By default, generics are global, with a synthetic name
+    Generic();
+    explicit Generic(TypeLevel level);
+    explicit Generic(const Name& name);
+    Generic(TypeLevel level, const Name& name);
 
     int index;
+    TypeLevel level;
+    Name name;
+    bool explicitName;
 
-    // This is used to create an error that can be rendered out using this field
-    // as appropriate metadata for communicating it to the user.
-    std::optional<Id> synthetic;
+private:
+    static int nextIndex;
+};
+
+struct Error
+{
+    // This constructor has to be public, since it's used in TypeVar and TypePack,
+    // but shouldn't be called directly. Please use errorRecoveryType() instead.
+    Error();
+
+    int index;
 
 private:
     static int nextIndex;
 };
 
 template<typename Id, typename... Value>
-using Variant = Luau::Variant<Bound<Id>, Error<Id>, Value...>;
+using Variant = Variant<Free, Bound<Id>, Generic, Error, Value...>;
 
-} // namespace Luau::Unifiable
+} // namespace Unifiable
+} // namespace Luau

Analysis/include/Luau/Unifier.h

@@ -3,13 +3,10 @@
 
 #include "Luau/Error.h"
 #include "Luau/Location.h"
-#include "Luau/ParseOptions.h"
-#include "Luau/Scope.h"
-#include "Luau/Substitution.h"
 #include "Luau/TxnLog.h"
-#include "Luau/TypeArena.h"
+#include "Luau/TypeInfer.h"
+#include "Luau/Module.h" // FIXME: For TypeArena.  It merits breaking out into its own header.
 #include "Luau/UnifierSharedState.h"
-#include "Luau/Normalize.h"
 
 #include <unordered_set>
 
@@ -22,165 +19,72 @@ enum Variance
     Invariant
 };
 
-// A substitution which replaces singleton types by their wider types
-struct Widen : Substitution
-{
-    Widen(TypeArena* arena, NotNull<BuiltinTypes> builtinTypes)
-        : Substitution(TxnLog::empty(), arena)
-        , builtinTypes(builtinTypes)
-    {
-    }
-
-    NotNull<BuiltinTypes> builtinTypes;
-
-    bool isDirty(TypeId ty) override;
-    bool isDirty(TypePackId ty) override;
-    TypeId clean(TypeId ty) override;
-    TypePackId clean(TypePackId ty) override;
-    bool ignoreChildren(TypeId ty) override;
-
-    TypeId operator()(TypeId ty);
-    TypePackId operator()(TypePackId ty);
-};
-
-/**
- * Normally, when we unify table properties, we must do so invariantly, but we
- * can introduce a special exception: If the table property in the subtype
- * position arises from a literal expression, it is safe to instead perform a
- * covariant check.
- *
- * This is very useful for typechecking cases where table literals (and trees of
- * table literals) are passed directly to functions.
- *
- * In this case, we know that the property has no other name referring to it and
- * so it is perfectly safe for the function to mutate the table any way it
- * wishes.
- */
-using LiteralProperties = DenseHashSet<Name>;
-
-// TODO: Use this more widely.
-struct UnifierOptions
-{
-    bool isFunctionCall = false;
-};
-
 struct Unifier
 {
     TypeArena* const types;
-    NotNull<BuiltinTypes> builtinTypes;
-    NotNull<Normalizer> normalizer;
+    Mode mode;
+    ScopePtr globalScope; // sigh.  Needed solely to get at string's metatable.
 
-    NotNull<Scope> scope; // const Scope maybe
     TxnLog log;
-    bool failure = false;
     ErrorVec errors;
     Location location;
     Variance variance = Covariant;
-    bool normalize = true;      // Normalize unions and intersections if necessary
-    bool checkInhabited = true; // Normalize types to check if they are inhabited
     CountMismatch::Context ctx = CountMismatch::Arg;
 
-    // If true, generics act as free types when unifying.
-    bool hideousFixMeGenericsAreActuallyFree = false;
-
     UnifierSharedState& sharedState;
 
-    // When the Unifier is forced to unify two blocked types (or packs), they
-    // get added to these vectors.  The ConstraintSolver can use this to know
-    // when it is safe to reattempt dispatching a constraint.
-    std::vector<TypeId> blockedTypes;
-    std::vector<TypePackId> blockedTypePacks;
-
-    Unifier(NotNull<Normalizer> normalizer, NotNull<Scope> scope, const Location& location, Variance variance, TxnLog* parentLog = nullptr);
+    Unifier(TypeArena* types, Mode mode, ScopePtr globalScope, const Location& location, Variance variance, UnifierSharedState& sharedState);
+    Unifier(TypeArena* types, Mode mode, ScopePtr globalScope, std::vector<std::pair<TypeId, TypeId>>* sharedSeen, const Location& location,
+        Variance variance, UnifierSharedState& sharedState);
 
     // 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);
+    ErrorVec canUnify(TypeId superTy, TypeId subTy);
+    ErrorVec canUnify(TypePackId superTy, TypePackId subTy, bool isFunctionCall = false);
 
-    /** Attempt to unify.
+    /** Attempt to unify left with right.
      * Populate the vector errors with any type errors that may arise.
      * Populate the transaction log with the set of TypeIds that need to be reset to undo the unification attempt.
      */
-    void tryUnify(
-        TypeId subTy,
-        TypeId superTy,
-        bool isFunctionCall = false,
-        bool isIntersection = false,
-        const LiteralProperties* aliasableMap = nullptr
-    );
+    void tryUnify(TypeId superTy, TypeId subTy, bool isFunctionCall = false, bool isIntersection = false);
 
 private:
-    void tryUnify_(
-        TypeId subTy,
-        TypeId superTy,
-        bool isFunctionCall = false,
-        bool isIntersection = false,
-        const LiteralProperties* aliasableMap = nullptr
-    );
-    void tryUnifyUnionWithType(TypeId subTy, const UnionType* uv, TypeId superTy);
-
-    // Traverse the two types provided and block on any BlockedTypes we find.
-    // Returns true if any types were blocked on.
-    bool DEPRECATED_blockOnBlockedTypes(TypeId subTy, TypeId superTy);
-
-    void tryUnifyTypeWithUnion(TypeId subTy, TypeId superTy, const UnionType* uv, bool cacheEnabled, bool isFunctionCall);
-    void tryUnifyTypeWithIntersection(TypeId subTy, TypeId superTy, const IntersectionType* uv);
-    void tryUnifyIntersectionWithType(TypeId subTy, const IntersectionType* uv, TypeId superTy, bool cacheEnabled, bool isFunctionCall);
-    void tryUnifyNormalizedTypes(
-        TypeId subTy,
-        TypeId superTy,
-        const NormalizedType& subNorm,
-        const NormalizedType& superNorm,
-        std::string reason,
-        std::optional<TypeError> error = std::nullopt
-    );
-    void tryUnifyPrimitives(TypeId subTy, TypeId superTy);
-    void tryUnifySingletons(TypeId subTy, TypeId superTy);
-    void tryUnifyFunctions(TypeId subTy, TypeId superTy, bool isFunctionCall = false);
-    void tryUnifyTables(TypeId subTy, TypeId superTy, bool isIntersection = false, const LiteralProperties* aliasableMap = nullptr);
-    void tryUnifyScalarShape(TypeId subTy, TypeId superTy, bool reversed);
-    void tryUnifyWithMetatable(TypeId subTy, TypeId superTy, bool reversed);
-    void tryUnifyWithExternType(TypeId subTy, TypeId superTy, bool reversed);
-    void tryUnifyNegations(TypeId subTy, TypeId superTy);
-
-    TypePackId tryApplyOverloadedFunction(TypeId function, const NormalizedFunctionType& overloads, TypePackId args);
-
-    TypeId widen(TypeId ty);
-    TypePackId widen(TypePackId tp);
-
+    void tryUnify_(TypeId superTy, TypeId subTy, bool isFunctionCall = false, bool isIntersection = false);
+    void tryUnifyPrimitives(TypeId superTy, TypeId subTy);
+    void tryUnifySingletons(TypeId superTy, TypeId subTy);
+    void tryUnifyFunctions(TypeId superTy, TypeId subTy, bool isFunctionCall = false);
+    void tryUnifyTables(TypeId left, TypeId right, bool isIntersection = false);
+    void DEPRECATED_tryUnifyTables(TypeId left, TypeId right, bool isIntersection = false);
+    void tryUnifyFreeTable(TypeId free, TypeId other);
+    void tryUnifySealedTables(TypeId left, TypeId right, bool isIntersection);
+    void tryUnifyWithMetatable(TypeId metatable, TypeId other, bool reversed);
+    void tryUnifyWithClass(TypeId superTy, TypeId subTy, bool reversed);
+    void tryUnify(const TableIndexer& superIndexer, const TableIndexer& subIndexer);
     TypeId deeplyOptional(TypeId ty, std::unordered_map<TypeId, TypeId> seen = {});
-
-    bool canCacheResult(TypeId subTy, TypeId superTy);
-    void cacheResult(TypeId subTy, TypeId superTy, size_t prevErrorCount);
+    void cacheResult(TypeId superTy, TypeId subTy);
 
 public:
-    void tryUnify(TypePackId subTy, TypePackId superTy, bool isFunctionCall = false);
+    void tryUnify(TypePackId superTy, TypePackId subTy, bool isFunctionCall = false);
 
 private:
-    void tryUnify_(TypePackId subTy, TypePackId superTy, bool isFunctionCall = false);
-    void tryUnifyVariadics(TypePackId subTy, TypePackId superTy, bool reversed, int subOffset = 0);
+    void tryUnify_(TypePackId superTy, TypePackId subTy, bool isFunctionCall = false);
+    void tryUnifyVariadics(TypePackId superTy, TypePackId subTy, bool reversed, int subOffset = 0);
 
-    void tryUnifyWithAny(TypeId subTy, TypeId anyTy);
-    void tryUnifyWithAny(TypePackId subTy, TypePackId anyTp);
+    void tryUnifyWithAny(TypeId any, TypeId ty);
+    void tryUnifyWithAny(TypePackId any, TypePackId ty);
 
     std::optional<TypeId> findTablePropertyRespectingMeta(TypeId lhsType, Name name);
 
-    TxnLog combineLogsIntoUnion(std::vector<TxnLog> logs);
-
 public:
-    // Returns true if the type "needle" already occurs within "haystack" and reports an "infinite type error"
-    bool occursCheck(TypeId needle, TypeId haystack, bool reversed);
-    bool occursCheck(DenseHashSet<TypeId>& seen, TypeId needle, TypeId haystack);
-    bool occursCheck(TypePackId needle, TypePackId haystack, bool reversed);
-    bool occursCheck(DenseHashSet<TypePackId>& seen, TypePackId needle, TypePackId haystack);
+    // Report an "infinite type error" if the type "needle" already occurs within "haystack"
+    void occursCheck(TypeId needle, TypeId haystack);
+    void occursCheck(DenseHashSet<TypeId>& seen, TypeId needle, TypeId haystack);
+    void occursCheck(TypePackId needle, TypePackId haystack);
+    void occursCheck(DenseHashSet<TypePackId>& seen, TypePackId needle, TypePackId haystack);
 
-    std::unique_ptr<Unifier> makeChildUnifier();
-
-    void reportError(TypeError err);
-    LUAU_NOINLINE void reportError(Location location, TypeErrorData data);
+    Unifier makeChildUnifier();
 
 private:
-    TypeMismatch::Context mismatchContext();
+    bool isNonstrictMode() const;
 
     void checkChildUnifierTypeMismatch(const ErrorVec& innerErrors, TypeId wantedType, TypeId givenType);
     void checkChildUnifierTypeMismatch(const ErrorVec& innerErrors, const std::string& prop, TypeId wantedType, TypeId givenType);
@@ -192,8 +96,4 @@ private:
     std::optional<int> firstPackErrorPos;
 };
 
-void promoteTypeLevels(TxnLog& log, const TypeArena* arena, TypeLevel minLevel, Scope* outerScope, bool useScope, TypePackId tp);
-std::optional<TypeError> hasUnificationTooComplex(const ErrorVec& errors);
-std::optional<TypeError> hasCountMismatch(const ErrorVec& errors);
-
 } // namespace Luau

Analysis/include/Luau/Unifier2.h

@@ -1,127 +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/Constraint.h"
-#include "Luau/DenseHash.h"
-#include "Luau/NotNull.h"
-#include "Luau/TypeCheckLimits.h"
-#include "Luau/TypeFwd.h"
-#include "Luau/TypePairHash.h"
-
-#include <optional>
-#include <vector>
-#include <utility>
-
-namespace Luau
-{
-
-struct InternalErrorReporter;
-struct Scope;
-struct TypeArena;
-
-enum class OccursCheckResult
-{
-    Pass,
-    Fail
-};
-
-struct Unifier2
-{
-    NotNull<TypeArena> arena;
-    NotNull<BuiltinTypes> builtinTypes;
-    NotNull<Scope> scope;
-    NotNull<InternalErrorReporter> ice;
-    TypeCheckLimits limits;
-
-    DenseHashSet<std::pair<TypeId, TypeId>, TypePairHash> seenTypePairings{{nullptr, nullptr}};
-    DenseHashSet<std::pair<TypePackId, TypePackId>, TypePairHash> seenTypePackPairings{{nullptr, nullptr}};
-
-    DenseHashMap<TypeId, std::vector<TypeId>> expandedFreeTypes{nullptr};
-
-    // Mapping from generic types to free types to be used in instantiation.
-    DenseHashMap<TypeId, TypeId> genericSubstitutions{nullptr};
-    // Mapping from generic type packs to `TypePack`s of free types to be used in instantiation.
-    DenseHashMap<TypePackId, TypePackId> genericPackSubstitutions{nullptr};
-
-    // Unification sometimes results in the creation of new free types.
-    // We collect them here so that other systems can perform necessary
-    // bookkeeping.
-    std::vector<TypeId> newFreshTypes;
-    std::vector<TypePackId> newFreshTypePacks;
-
-    int recursionCount = 0;
-    int recursionLimit = 0;
-
-    std::vector<ConstraintV> incompleteSubtypes;
-    // null if not in a constraint solving context
-    DenseHashSet<const void*>* uninhabitedTypeFunctions;
-
-    Unifier2(NotNull<TypeArena> arena, NotNull<BuiltinTypes> builtinTypes, NotNull<Scope> scope, NotNull<InternalErrorReporter> ice);
-    Unifier2(
-        NotNull<TypeArena> arena,
-        NotNull<BuiltinTypes> builtinTypes,
-        NotNull<Scope> scope,
-        NotNull<InternalErrorReporter> ice,
-        DenseHashSet<const void*>* uninhabitedTypeFunctions
-    );
-
-    /** Attempt to commit the subtype relation subTy <: superTy to the type
-     * graph.
-     *
-     * @returns true if successful.
-     *
-     * Note that incoherent types can and will successfully be unified.  We stop
-     * when we *cannot know* how to relate the provided types, not when doing so
-     * would narrow something down to never or broaden it to unknown.
-     *
-     * Presently, the only way unification can fail is if we attempt to bind one
-     * free TypePack to another and encounter an occurs check violation.
-     */
-    bool unify(TypeId subTy, TypeId superTy);
-    bool unifyFreeWithType(TypeId subTy, TypeId superTy);
-    bool unify(TypeId subTy, const FunctionType* superFn);
-    bool unify(const UnionType* subUnion, TypeId superTy);
-    bool unify(TypeId subTy, const UnionType* superUnion);
-    bool unify(const IntersectionType* subIntersection, TypeId superTy);
-    bool unify(TypeId subTy, const IntersectionType* superIntersection);
-    bool unify(TableType* subTable, const TableType* superTable);
-    bool unify(const MetatableType* subMetatable, const MetatableType* superMetatable);
-
-    bool unify(const AnyType* subAny, const FunctionType* superFn);
-    bool unify(const FunctionType* subFn, const AnyType* superAny);
-    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);
-
-    std::optional<TypeId> generalize(TypeId ty);
-
-private:
-    /**
-     * @returns simplify(left | right)
-     */
-    TypeId mkUnion(TypeId left, TypeId right);
-
-    /**
-     * @returns simplify(left & right)
-     */
-    TypeId mkIntersection(TypeId left, TypeId right);
-
-    // Returns true if needle occurs within haystack already.  ie if we bound
-    // needle to haystack, would a cyclic type result?
-    OccursCheckResult occursCheck(DenseHashSet<TypeId>& seen, TypeId needle, TypeId haystack);
-
-    // Returns true if needle occurs within haystack already.  ie if we bound
-    // needle to haystack, would a cyclic TypePack result?
-    OccursCheckResult occursCheck(DenseHashSet<TypePackId>& seen, TypePackId needle, TypePackId haystack);
-
-    TypeId freshType(NotNull<Scope> scope, Polarity polarity);
-    TypePackId freshTypePack(NotNull<Scope> scope, Polarity polarity);
-};
-
-} // namespace Luau

Analysis/include/Luau/UnifierSharedState.h

@@ -2,8 +2,8 @@
 #pragma once
 
 #include "Luau/DenseHash.h"
-#include "Luau/Error.h"
-#include "Luau/TypeFwd.h"
+#include "Luau/TypeVar.h"
+#include "Luau/TypePack.h"
 
 #include <utility>
 
@@ -27,9 +27,7 @@ struct TypeIdPairHash
 struct UnifierCounters
 {
     int recursionCount = 0;
-    int recursionLimit = 0;
     int iterationCount = 0;
-    int iterationLimit = 0;
 };
 
 struct UnifierSharedState
@@ -41,34 +39,14 @@ struct UnifierSharedState
 
     InternalErrorReporter* iceHandler;
 
+    DenseHashSet<void*> seenAny{nullptr};
     DenseHashMap<TypeId, bool> skipCacheForType{nullptr};
     DenseHashSet<std::pair<TypeId, TypeId>, TypeIdPairHash> cachedUnify{{nullptr, nullptr}};
-    DenseHashMap<std::pair<TypeId, TypeId>, TypeErrorData, TypeIdPairHash> cachedUnifyError{{nullptr, nullptr}};
 
     DenseHashSet<TypeId> tempSeenTy{nullptr};
     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/include/Luau/Variant.h

@@ -1,16 +1,46 @@
 // This file is part of the Luau programming language and is licensed under MIT License; see LICENSE.txt for details
 #pragma once
 
-#include <initializer_list>
+#include "Luau/Common.h"
+
+#ifndef LUAU_USE_STD_VARIANT
+#define LUAU_USE_STD_VARIANT 0
+#endif
+
+#if LUAU_USE_STD_VARIANT
+#include <variant>
+#else
 #include <new>
 #include <type_traits>
-#include <utility>
-
+#include <initializer_list>
 #include <stddef.h>
+#endif
 
 namespace Luau
 {
 
+#if LUAU_USE_STD_VARIANT
+template<typename... Ts>
+using Variant = std::variant<Ts...>;
+
+template<class Visitor, class Variant>
+auto visit(Visitor&& vis, Variant&& var)
+{
+    // This change resolves the ABI issues with std::variant on libc++; std::visit normally throws bad_variant_access
+    // but it requires an update to libc++.dylib which ships with macOS 10.14. To work around this, we assert on valueless
+    // variants since we will never generate them and call into a libc++ function that doesn't throw.
+    LUAU_ASSERT(!var.valueless_by_exception());
+
+#ifdef __APPLE__
+    // See https://stackoverflow.com/a/53868971/503215
+    return std::__variant_detail::__visitation::__variant::__visit_value(vis, var);
+#else
+    return std::visit(vis, var);
+#endif
+}
+
+using std::get_if;
+#else
 template<typename... Ts>
 class Variant
 {
@@ -19,7 +49,7 @@ class Variant
     static_assert(std::disjunction_v<std::is_reference<Ts>...> == false, "variant does not allow references as an alternative type");
     static_assert(std::disjunction_v<std::is_array<Ts>...> == false, "variant does not allow arrays as an alternative type");
 
-public:
+private:
     template<typename T>
     static constexpr int getTypeId()
     {
@@ -35,7 +65,6 @@ public:
         return -1;
     }
 
-private:
     template<typename T, typename... Tail>
     struct First
     {
@@ -45,9 +74,6 @@ private:
 public:
     using first_alternative = typename First<Ts...>::type;
 
-    template<typename T>
-    static constexpr bool is_part_of_v = std::disjunction_v<typename std::is_same<std::decay_t<Ts>, T>...>;
-
     Variant()
     {
         static_assert(std::is_default_constructible_v<first_alternative>, "first alternative type must be default constructible");
@@ -62,15 +88,13 @@ public:
 
         constexpr int tid = getTypeId<T>();
         typeId = tid;
-        new (&storage) TT(std::forward<T>(value));
+        new (&storage) TT(value);
     }
 
     Variant(const Variant& other)
     {
-        static constexpr FnCopy table[sizeof...(Ts)] = {&fnCopy<Ts>...};
-
         typeId = other.typeId;
-        table[typeId](&storage, &other.storage);
+        tableCopy[typeId](&storage, &other.storage);
     }
 
     Variant(Variant&& other)
@@ -102,20 +126,6 @@ public:
         return *this;
     }
 
-    template<typename T, typename... Args>
-    T& emplace(Args&&... args)
-    {
-        using TT = std::decay_t<T>;
-        constexpr int tid = getTypeId<T>();
-        static_assert(tid >= 0, "unsupported T");
-
-        tableDtor[typeId](&storage);
-        typeId = tid;
-        new (&storage) TT{std::forward<Args>(args)...};
-
-        return *reinterpret_cast<T*>(&storage);
-    }
-
     template<typename T>
     const T* get_if() const
     {
@@ -198,6 +208,7 @@ private:
         return *static_cast<const T*>(lhs) == *static_cast<const T*>(rhs);
     }
 
+    static constexpr FnCopy tableCopy[sizeof...(Ts)] = {&fnCopy<Ts>...};
     static constexpr FnMove tableMove[sizeof...(Ts)] = {&fnMove<Ts>...};
     static constexpr FnDtor tableDtor[sizeof...(Ts)] = {&fnDtor<Ts>...};
 
@@ -237,12 +248,9 @@ static void fnVisitV(Visitor& vis, std::conditional_t<std::is_const_v<T>, const
 template<class Visitor, typename... Ts>
 auto visit(Visitor&& vis, const Variant<Ts...>& var)
 {
-    static_assert(std::conjunction_v<std::is_invocable<Visitor, Ts>...>, "visitor must accept every alternative as an argument");
-
     using Result = std::invoke_result_t<Visitor, typename Variant<Ts...>::first_alternative>;
-    static_assert(
-        std::conjunction_v<std::is_same<Result, std::invoke_result_t<Visitor, Ts>>...>, "visitor result type must be consistent between alternatives"
-    );
+    static_assert(std::conjunction_v<std::is_same<Result, std::invoke_result_t<Visitor, Ts>>...>,
+        "visitor result type must be consistent between alternatives");
 
     if constexpr (std::is_same_v<Result, void>)
     {
@@ -265,12 +273,9 @@ auto visit(Visitor&& vis, const Variant<Ts...>& var)
 template<class Visitor, typename... Ts>
 auto visit(Visitor&& vis, Variant<Ts...>& var)
 {
-    static_assert(std::conjunction_v<std::is_invocable<Visitor, Ts&>...>, "visitor must accept every alternative as an argument");
-
     using Result = std::invoke_result_t<Visitor, typename Variant<Ts...>::first_alternative&>;
-    static_assert(
-        std::conjunction_v<std::is_same<Result, std::invoke_result_t<Visitor, Ts&>>...>, "visitor result type must be consistent between alternatives"
-    );
+    static_assert(std::conjunction_v<std::is_same<Result, std::invoke_result_t<Visitor, Ts&>>...>,
+        "visitor result type must be consistent between alternatives");
 
     if constexpr (std::is_same_v<Result, void>)
     {
@@ -289,6 +294,7 @@ auto visit(Visitor&& vis, Variant<Ts...>& var)
         return res;
     }
 }
+#endif
 
 template<class>
 inline constexpr bool always_false_v = false;

Analysis/include/Luau/VisitType.h

@@ -1,531 +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 <unordered_set>
-
-#include "Luau/DenseHash.h"
-#include "Luau/RecursionCounter.h"
-#include "Luau/TypePack.h"
-#include "Luau/Type.h"
-#include "Type.h"
-
-LUAU_FASTINT(LuauVisitRecursionLimit)
-LUAU_FASTFLAG(LuauSolverV2)
-
-namespace Luau
-{
-
-namespace visit_detail
-{
-/**
- * Apply f(tid, t, seen) if doing so would pass type checking, else apply f(tid, t)
- *
- * We do this to permit (but not require) Type visitors to accept the seen set as an argument.
- */
-template<typename F, typename A, typename B, typename C>
-auto apply(A tid, const B& t, C& c, F& f) -> decltype(f(tid, t, c))
-{
-    return f(tid, t, c);
-}
-
-template<typename A, typename B, typename C, typename F>
-auto apply(A tid, const B& t, C&, F& f) -> decltype(f(tid, t))
-{
-    return f(tid, t);
-}
-
-inline bool hasSeen(std::unordered_set<void*>& seen, const void* tv)
-{
-    void* ttv = const_cast<void*>(tv);
-    return !seen.insert(ttv).second;
-}
-
-inline bool hasSeen(DenseHashSet<void*>& seen, const void* tv)
-{
-    void* ttv = const_cast<void*>(tv);
-
-    if (seen.contains(ttv))
-        return true;
-
-    seen.insert(ttv);
-    return false;
-}
-
-inline void unsee(std::unordered_set<void*>& seen, const void* tv)
-{
-    void* ttv = const_cast<void*>(tv);
-    seen.erase(ttv);
-}
-
-inline void unsee(DenseHashSet<void*>& seen, const void* tv)
-{
-    // When DenseHashSet is used for 'visitTypeOnce', where don't forget visited elements
-}
-
-} // namespace visit_detail
-
-// recursion counter is equivalent here, but we'd like a better name to express the intent.
-using TypeFunctionDepthCounter = RecursionCounter;
-
-template<typename S>
-struct GenericTypeVisitor
-{
-    using Set = S;
-
-    Set seen;
-    bool skipBoundTypes = false;
-    int recursionCounter = 0;
-    int typeFunctionDepth = 0;
-
-    GenericTypeVisitor() = default;
-
-    explicit GenericTypeVisitor(Set seen, bool skipBoundTypes = false)
-        : seen(std::move(seen))
-        , skipBoundTypes(skipBoundTypes)
-    {
-    }
-
-    virtual ~GenericTypeVisitor() {}
-
-    virtual void cycle(TypeId) {}
-    virtual void cycle(TypePackId) {}
-
-    virtual bool visit(TypeId ty)
-    {
-        return true;
-    }
-    virtual bool visit(TypeId ty, const BoundType& btv)
-    {
-        return visit(ty);
-    }
-    virtual bool visit(TypeId ty, const FreeType& ftv)
-    {
-        return visit(ty);
-    }
-    virtual bool visit(TypeId ty, const GenericType& gtv)
-    {
-        return visit(ty);
-    }
-    virtual bool visit(TypeId ty, const ErrorType& etv)
-    {
-        return visit(ty);
-    }
-    virtual bool visit(TypeId ty, const PrimitiveType& ptv)
-    {
-        return visit(ty);
-    }
-    virtual bool visit(TypeId ty, const FunctionType& ftv)
-    {
-        return visit(ty);
-    }
-    virtual bool visit(TypeId ty, const TableType& ttv)
-    {
-        return visit(ty);
-    }
-    virtual bool visit(TypeId ty, const MetatableType& mtv)
-    {
-        return visit(ty);
-    }
-    virtual bool visit(TypeId ty, const ExternType& etv)
-    {
-        return visit(ty);
-    }
-    virtual bool visit(TypeId ty, const AnyType& atv)
-    {
-        return visit(ty);
-    }
-    virtual bool visit(TypeId ty, const NoRefineType& nrt)
-    {
-        return visit(ty);
-    }
-    virtual bool visit(TypeId ty, const UnknownType& utv)
-    {
-        return visit(ty);
-    }
-    virtual bool visit(TypeId ty, const NeverType& ntv)
-    {
-        return visit(ty);
-    }
-    virtual bool visit(TypeId ty, const UnionType& utv)
-    {
-        return visit(ty);
-    }
-    virtual bool visit(TypeId ty, const IntersectionType& itv)
-    {
-        return visit(ty);
-    }
-    virtual bool visit(TypeId ty, const BlockedType& btv)
-    {
-        return visit(ty);
-    }
-    virtual bool visit(TypeId ty, const PendingExpansionType& petv)
-    {
-        return visit(ty);
-    }
-    virtual bool visit(TypeId ty, const SingletonType& stv)
-    {
-        return visit(ty);
-    }
-    virtual bool visit(TypeId ty, const NegationType& ntv)
-    {
-        return visit(ty);
-    }
-    virtual bool visit(TypeId ty, const TypeFunctionInstanceType& tfit)
-    {
-        return visit(ty);
-    }
-
-    virtual bool visit(TypePackId tp)
-    {
-        return true;
-    }
-    virtual bool visit(TypePackId tp, const BoundTypePack& btp)
-    {
-        return visit(tp);
-    }
-    virtual bool visit(TypePackId tp, const FreeTypePack& ftp)
-    {
-        return visit(tp);
-    }
-    virtual bool visit(TypePackId tp, const GenericTypePack& gtp)
-    {
-        return visit(tp);
-    }
-    virtual bool visit(TypePackId tp, const ErrorTypePack& etp)
-    {
-        return visit(tp);
-    }
-    virtual bool visit(TypePackId tp, const TypePack& pack)
-    {
-        return visit(tp);
-    }
-    virtual bool visit(TypePackId tp, const VariadicTypePack& vtp)
-    {
-        return visit(tp);
-    }
-    virtual bool visit(TypePackId tp, const BlockedTypePack& btp)
-    {
-        return visit(tp);
-    }
-    virtual bool visit(TypePackId tp, const TypeFunctionInstanceTypePack& tfitp)
-    {
-        return visit(tp);
-    }
-
-    void traverse(TypeId ty)
-    {
-        RecursionLimiter limiter{&recursionCounter, FInt::LuauVisitRecursionLimit};
-
-        if (visit_detail::hasSeen(seen, ty))
-        {
-            cycle(ty);
-            return;
-        }
-
-        if (auto btv = get<BoundType>(ty))
-        {
-            if (skipBoundTypes)
-                traverse(btv->boundTo);
-            else if (visit(ty, *btv))
-                traverse(btv->boundTo);
-        }
-        else if (auto ftv = get<FreeType>(ty))
-        {
-            if (FFlag::LuauSolverV2)
-            {
-                if (visit(ty, *ftv))
-                {
-                    // TODO: Replace these if statements with assert()s when we
-                    // delete FFlag::LuauSolverV2.
-                    //
-                    // When the old solver is used, these pointers are always
-                    // unused. When the new solver is used, they are never null.
-                    if (ftv->lowerBound)
-                        traverse(ftv->lowerBound);
-
-                    if (ftv->upperBound)
-                        traverse(ftv->upperBound);
-                }
-            }
-            else
-                visit(ty, *ftv);
-        }
-        else if (auto gtv = get<GenericType>(ty))
-            visit(ty, *gtv);
-        else if (auto etv = get<ErrorType>(ty))
-            visit(ty, *etv);
-        else if (auto ptv = get<PrimitiveType>(ty))
-            visit(ty, *ptv);
-        else if (auto ftv = get<FunctionType>(ty))
-        {
-            if (visit(ty, *ftv))
-            {
-                traverse(ftv->argTypes);
-                traverse(ftv->retTypes);
-            }
-        }
-        else if (auto ttv = get<TableType>(ty))
-        {
-            // Some visitors want to see bound tables, that's why we traverse the original type
-            if (skipBoundTypes && ttv->boundTo)
-            {
-                traverse(*ttv->boundTo);
-            }
-            else if (visit(ty, *ttv))
-            {
-                if (ttv->boundTo)
-                {
-                    traverse(*ttv->boundTo);
-                }
-                else
-                {
-                    for (auto& [_name, prop] : ttv->props)
-                    {
-                        if (FFlag::LuauSolverV2)
-                        {
-                            if (auto ty = prop.readTy)
-                                traverse(*ty);
-
-                            // In the case that the readType and the writeType
-                            // are the same pointer, just traverse once.
-                            // Traversing each property twice has pretty
-                            // significant performance consequences.
-                            if (auto ty = prop.writeTy; ty && !prop.isShared())
-                                traverse(*ty);
-                        }
-                        else
-                            traverse(prop.type());
-                    }
-
-                    if (ttv->indexer)
-                    {
-                        traverse(ttv->indexer->indexType);
-                        traverse(ttv->indexer->indexResultType);
-                    }
-                }
-            }
-        }
-        else if (auto mtv = get<MetatableType>(ty))
-        {
-            if (visit(ty, *mtv))
-            {
-                traverse(mtv->table);
-                traverse(mtv->metatable);
-            }
-        }
-        else if (auto etv = get<ExternType>(ty))
-        {
-            if (visit(ty, *etv))
-            {
-                for (const auto& [name, prop] : etv->props)
-                {
-                    if (FFlag::LuauSolverV2)
-                    {
-                        if (auto ty = prop.readTy)
-                            traverse(*ty);
-
-                        // In the case that the readType and the writeType are
-                        // the same pointer, just traverse once. Traversing each
-                        // property twice would have pretty significant
-                        // performance consequences.
-                        if (auto ty = prop.writeTy; ty && !prop.isShared())
-                            traverse(*ty);
-                    }
-                    else
-                        traverse(prop.type());
-                }
-
-                if (etv->parent)
-                    traverse(*etv->parent);
-
-                if (etv->metatable)
-                    traverse(*etv->metatable);
-
-                if (etv->indexer)
-                {
-                    traverse(etv->indexer->indexType);
-                    traverse(etv->indexer->indexResultType);
-                }
-            }
-        }
-        else if (auto atv = get<AnyType>(ty))
-            visit(ty, *atv);
-        else if (auto nrt = get<NoRefineType>(ty))
-            visit(ty, *nrt);
-        else if (auto utv = get<UnionType>(ty))
-        {
-            if (visit(ty, *utv))
-            {
-                bool unionChanged = false;
-                for (TypeId optTy : utv->options)
-                {
-                    traverse(optTy);
-                    if (!get<UnionType>(follow(ty)))
-                    {
-                        unionChanged = true;
-                        break;
-                    }
-                }
-
-                if (unionChanged)
-                    traverse(ty);
-            }
-        }
-        else if (auto itv = get<IntersectionType>(ty))
-        {
-            if (visit(ty, *itv))
-            {
-                bool intersectionChanged = false;
-                for (TypeId partTy : itv->parts)
-                {
-                    traverse(partTy);
-                    if (!get<IntersectionType>(follow(ty)))
-                    {
-                        intersectionChanged = true;
-                        break;
-                    }
-                }
-
-                if (intersectionChanged)
-                    traverse(ty);
-            }
-        }
-        else if (auto ltv = get<LazyType>(ty))
-        {
-            if (TypeId unwrapped = ltv->unwrapped)
-                traverse(unwrapped);
-
-            // Visiting into LazyType that hasn't been unwrapped may necessarily cause infinite expansion, so we don't do that on purpose.
-            // Asserting also makes no sense, because the type _will_ happen here, most likely as a property of some ExternType
-            // that doesn't need to be expanded.
-        }
-        else if (auto stv = get<SingletonType>(ty))
-            visit(ty, *stv);
-        else if (auto btv = get<BlockedType>(ty))
-            visit(ty, *btv);
-        else if (auto utv = get<UnknownType>(ty))
-            visit(ty, *utv);
-        else if (auto ntv = get<NeverType>(ty))
-            visit(ty, *ntv);
-        else if (auto petv = get<PendingExpansionType>(ty))
-        {
-            if (visit(ty, *petv))
-            {
-                for (TypeId a : petv->typeArguments)
-                    traverse(a);
-
-                for (TypePackId a : petv->packArguments)
-                    traverse(a);
-            }
-        }
-        else if (auto ntv = get<NegationType>(ty))
-        {
-            if (visit(ty, *ntv))
-                traverse(ntv->ty);
-        }
-        else if (auto tfit = get<TypeFunctionInstanceType>(ty))
-        {
-            TypeFunctionDepthCounter tfdc{&typeFunctionDepth};
-
-            if (visit(ty, *tfit))
-            {
-                for (TypeId p : tfit->typeArguments)
-                    traverse(p);
-
-                for (TypePackId p : tfit->packArguments)
-                    traverse(p);
-            }
-        }
-        else
-            LUAU_ASSERT(!"GenericTypeVisitor::traverse(TypeId) is not exhaustive!");
-
-        visit_detail::unsee(seen, ty);
-    }
-
-    void traverse(TypePackId tp)
-    {
-        if (visit_detail::hasSeen(seen, tp))
-        {
-            cycle(tp);
-            return;
-        }
-
-        if (auto btv = get<BoundTypePack>(tp))
-        {
-            if (visit(tp, *btv))
-                traverse(btv->boundTo);
-        }
-
-        else if (auto ftv = get<FreeTypePack>(tp))
-            visit(tp, *ftv);
-
-        else if (auto gtv = get<GenericTypePack>(tp))
-            visit(tp, *gtv);
-
-        else if (auto etv = get<ErrorTypePack>(tp))
-            visit(tp, *etv);
-
-        else if (auto pack = get<TypePack>(tp))
-        {
-            bool res = visit(tp, *pack);
-            if (res)
-            {
-                for (TypeId ty : pack->head)
-                    traverse(ty);
-
-                if (pack->tail)
-                    traverse(*pack->tail);
-            }
-        }
-        else if (auto pack = get<VariadicTypePack>(tp))
-        {
-            bool res = visit(tp, *pack);
-            if (res)
-                traverse(pack->ty);
-        }
-        else if (auto btp = get<BlockedTypePack>(tp))
-            visit(tp, *btp);
-        else if (auto tfitp = get<TypeFunctionInstanceTypePack>(tp))
-        {
-            TypeFunctionDepthCounter tfdc{&typeFunctionDepth};
-
-            if (visit(tp, *tfitp))
-            {
-                for (TypeId t : tfitp->typeArguments)
-                    traverse(t);
-
-                for (TypePackId t : tfitp->packArguments)
-                    traverse(t);
-            }
-        }
-
-        else
-            LUAU_ASSERT(!"GenericTypeVisitor::traverse(TypePackId) is not exhaustive!");
-
-        visit_detail::unsee(seen, tp);
-    }
-};
-
-/** Visit each type under a given type.  Skips over cycles and keeps recursion depth under control.
- *
- * The same type may be visited multiple times if there are multiple distinct paths to it.  If this is undesirable, use
- * TypeOnceVisitor.
- */
-struct TypeVisitor : GenericTypeVisitor<std::unordered_set<void*>>
-{
-    explicit TypeVisitor(bool skipBoundTypes = false)
-        : GenericTypeVisitor{{}, skipBoundTypes}
-    {
-    }
-};
-
-/// Visit each type under a given type.  Each type will only be checked once even if there are multiple paths to it.
-struct TypeOnceVisitor : GenericTypeVisitor<DenseHashSet<void*>>
-{
-    explicit TypeOnceVisitor(bool skipBoundTypes = false)
-        : GenericTypeVisitor{DenseHashSet<void*>{nullptr}, skipBoundTypes}
-    {
-    }
-};
-
-} // namespace Luau

Analysis/include/Luau/VisitTypeVar.h

@@ -0,0 +1,233 @@
+// This file is part of the Luau programming language and is licensed under MIT License; see LICENSE.txt for details
+#pragma once
+
+#include "Luau/DenseHash.h"
+#include "Luau/TypeVar.h"
+#include "Luau/TypePack.h"
+
+namespace Luau
+{
+
+namespace visit_detail
+{
+/**
+ * Apply f(tid, t, seen) if doing so would pass type checking, else apply f(tid, t)
+ *
+ * We do this to permit (but not require) TypeVar visitors to accept the seen set as an argument.
+ */
+template<typename F, typename A, typename B, typename C>
+auto apply(A tid, const B& t, C& c, F& f) -> decltype(f(tid, t, c))
+{
+    return f(tid, t, c);
+}
+
+template<typename A, typename B, typename C, typename F>
+auto apply(A tid, const B& t, C&, F& f) -> decltype(f(tid, t))
+{
+    return f(tid, t);
+}
+
+inline bool hasSeen(std::unordered_set<void*>& seen, const void* tv)
+{
+    void* ttv = const_cast<void*>(tv);
+    return !seen.insert(ttv).second;
+}
+
+inline bool hasSeen(DenseHashSet<void*>& seen, const void* tv)
+{
+    void* ttv = const_cast<void*>(tv);
+
+    if (seen.contains(ttv))
+        return true;
+
+    seen.insert(ttv);
+    return false;
+}
+
+inline void unsee(std::unordered_set<void*>& seen, const void* tv)
+{
+    void* ttv = const_cast<void*>(tv);
+    seen.erase(ttv);
+}
+
+inline void unsee(DenseHashSet<void*>& seen, const void* tv)
+{
+    // When DenseHashSet is used for 'visitOnce', where don't forget visited elements
+}
+
+template<typename F, typename Set>
+void visit(TypePackId tp, F& f, Set& seen);
+
+template<typename F, typename Set>
+void visit(TypeId ty, F& f, Set& seen)
+{
+    if (visit_detail::hasSeen(seen, ty))
+    {
+        f.cycle(ty);
+        return;
+    }
+
+    if (auto btv = get<BoundTypeVar>(ty))
+    {
+        if (apply(ty, *btv, seen, f))
+            visit(btv->boundTo, f, seen);
+    }
+
+    else if (auto ftv = get<FreeTypeVar>(ty))
+        apply(ty, *ftv, seen, f);
+
+    else if (auto gtv = get<GenericTypeVar>(ty))
+        apply(ty, *gtv, seen, f);
+
+    else if (auto etv = get<ErrorTypeVar>(ty))
+        apply(ty, *etv, seen, f);
+
+    else if (auto ptv = get<PrimitiveTypeVar>(ty))
+        apply(ty, *ptv, seen, f);
+
+    else if (auto ftv = get<FunctionTypeVar>(ty))
+    {
+        if (apply(ty, *ftv, seen, f))
+        {
+            visit(ftv->argTypes, f, seen);
+            visit(ftv->retType, f, seen);
+        }
+    }
+
+    else if (auto ttv = get<TableTypeVar>(ty))
+    {
+        // Some visitors want to see bound tables, that's why we visit the original type
+        if (apply(ty, *ttv, seen, f))
+        {
+            if (ttv->boundTo)
+            {
+                visit(*ttv->boundTo, f, seen);
+            }
+            else
+            {
+                for (auto& [_name, prop] : ttv->props)
+                    visit(prop.type, f, seen);
+
+                if (ttv->indexer)
+                {
+                    visit(ttv->indexer->indexType, f, seen);
+                    visit(ttv->indexer->indexResultType, f, seen);
+                }
+            }
+        }
+    }
+
+    else if (auto mtv = get<MetatableTypeVar>(ty))
+    {
+        if (apply(ty, *mtv, seen, f))
+        {
+            visit(mtv->table, f, seen);
+            visit(mtv->metatable, f, seen);
+        }
+    }
+
+    else if (auto ctv = get<ClassTypeVar>(ty))
+    {
+        if (apply(ty, *ctv, seen, f))
+        {
+            for (const auto& [name, prop] : ctv->props)
+                visit(prop.type, f, seen);
+
+            if (ctv->parent)
+                visit(*ctv->parent, f, seen);
+
+            if (ctv->metatable)
+                visit(*ctv->metatable, f, seen);
+        }
+    }
+
+    else if (auto atv = get<AnyTypeVar>(ty))
+        apply(ty, *atv, seen, f);
+
+    else if (auto utv = get<UnionTypeVar>(ty))
+    {
+        if (apply(ty, *utv, seen, f))
+        {
+            for (TypeId optTy : utv->options)
+                visit(optTy, f, seen);
+        }
+    }
+
+    else if (auto itv = get<IntersectionTypeVar>(ty))
+    {
+        if (apply(ty, *itv, seen, f))
+        {
+            for (TypeId partTy : itv->parts)
+                visit(partTy, f, seen);
+        }
+    }
+
+    visit_detail::unsee(seen, ty);
+}
+
+template<typename F, typename Set>
+void visit(TypePackId tp, F& f, Set& seen)
+{
+    if (visit_detail::hasSeen(seen, tp))
+    {
+        f.cycle(tp);
+        return;
+    }
+
+    if (auto btv = get<BoundTypePack>(tp))
+    {
+        if (apply(tp, *btv, seen, f))
+            visit(btv->boundTo, f, seen);
+    }
+
+    else if (auto ftv = get<Unifiable::Free>(tp))
+        apply(tp, *ftv, seen, f);
+
+    else if (auto gtv = get<Unifiable::Generic>(tp))
+        apply(tp, *gtv, seen, f);
+
+    else if (auto etv = get<Unifiable::Error>(tp))
+        apply(tp, *etv, seen, f);
+
+    else if (auto pack = get<TypePack>(tp))
+    {
+        apply(tp, *pack, seen, f);
+
+        for (TypeId ty : pack->head)
+            visit(ty, f, seen);
+
+        if (pack->tail)
+            visit(*pack->tail, f, seen);
+    }
+    else if (auto pack = get<VariadicTypePack>(tp))
+    {
+        apply(tp, *pack, seen, f);
+        visit(pack->ty, f, seen);
+    }
+
+    visit_detail::unsee(seen, tp);
+}
+
+} // namespace visit_detail
+
+template<typename TID, typename F>
+void visitTypeVar(TID ty, F& f, std::unordered_set<void*>& seen)
+{
+    visit_detail::visit(ty, f, seen);
+}
+
+template<typename TID, typename F>
+void visitTypeVar(TID ty, F& f)
+{
+    std::unordered_set<void*> seen;
+    visit_detail::visit(ty, f, seen);
+}
+
+template<typename TID, typename F>
+void visitTypeVarOnce(TID ty, F& f, DenseHashSet<void*>& seen)
+{
+    seen.clear();
+    visit_detail::visit(ty, f, seen);
+}
+
+} // namespace Luau

Analysis/src/Anyification.cpp

@@ -1,101 +0,0 @@
-// This file is part of the Luau programming language and is licensed under MIT License; see LICENSE.txt for details
-
-#include "Luau/Anyification.h"
-
-#include "Luau/Common.h"
-#include "Luau/Normalize.h"
-#include "Luau/TxnLog.h"
-
-namespace Luau
-{
-
-Anyification::Anyification(
-    TypeArena* arena,
-    NotNull<Scope> scope,
-    NotNull<BuiltinTypes> builtinTypes,
-    InternalErrorReporter* iceHandler,
-    TypeId anyType,
-    TypePackId anyTypePack
-)
-    : Substitution(TxnLog::empty(), arena)
-    , scope(scope)
-    , builtinTypes(builtinTypes)
-    , iceHandler(iceHandler)
-    , anyType(anyType)
-    , anyTypePack(anyTypePack)
-{
-}
-
-Anyification::Anyification(
-    TypeArena* arena,
-    const ScopePtr& scope,
-    NotNull<BuiltinTypes> builtinTypes,
-    InternalErrorReporter* iceHandler,
-    TypeId anyType,
-    TypePackId anyTypePack
-)
-    : Anyification(arena, NotNull{scope.get()}, builtinTypes, iceHandler, anyType, anyTypePack)
-{
-}
-
-bool Anyification::isDirty(TypeId ty)
-{
-    if (ty->persistent)
-        return false;
-
-    if (const TableType* ttv = log->getMutable<TableType>(ty))
-        return (ttv->state == TableState::Free || ttv->state == TableState::Unsealed);
-    else if (log->getMutable<FreeType>(ty))
-        return true;
-    else
-        return false;
-}
-
-bool Anyification::isDirty(TypePackId tp)
-{
-    if (tp->persistent)
-        return false;
-
-    if (log->getMutable<FreeTypePack>(tp))
-        return true;
-    else
-        return false;
-}
-
-TypeId Anyification::clean(TypeId ty)
-{
-    LUAU_ASSERT(isDirty(ty));
-    if (const TableType* ttv = log->getMutable<TableType>(ty))
-    {
-        TableType clone = TableType{ttv->props, ttv->indexer, ttv->level, TableState::Sealed};
-        clone.definitionModuleName = ttv->definitionModuleName;
-        clone.definitionLocation = ttv->definitionLocation;
-        clone.name = ttv->name;
-        clone.syntheticName = ttv->syntheticName;
-        clone.tags = ttv->tags;
-        TypeId res = addType(std::move(clone));
-        return res;
-    }
-    else
-        return anyType;
-}
-
-TypePackId Anyification::clean(TypePackId tp)
-{
-    LUAU_ASSERT(isDirty(tp));
-    return anyTypePack;
-}
-
-bool Anyification::ignoreChildren(TypeId ty)
-{
-    if (get<ExternType>(ty))
-        return true;
-
-    return ty->persistent;
-}
-bool Anyification::ignoreChildren(TypePackId ty)
-{
-    return ty->persistent;
-}
-
-} // namespace Luau

Analysis/src/ApplyTypeFunction.cpp

@@ -1,62 +0,0 @@
-// This file is part of the Luau programming language and is licensed under MIT License; see LICENSE.txt for details
-
-#include "Luau/ApplyTypeFunction.h"
-
-namespace Luau
-{
-
-bool ApplyTypeFunction::isDirty(TypeId ty)
-{
-    if (typeArguments.count(ty))
-        return true;
-    else if (const FreeType* ftv = get<FreeType>(ty))
-    {
-        if (ftv->forwardedTypeAlias)
-            encounteredForwardedType = true;
-        return false;
-    }
-    else
-        return false;
-}
-
-bool ApplyTypeFunction::isDirty(TypePackId tp)
-{
-    if (typePackArguments.count(tp))
-        return true;
-    else
-        return false;
-}
-
-bool ApplyTypeFunction::ignoreChildren(TypeId ty)
-{
-    if (get<GenericType>(ty))
-        return true;
-    else if (get<ExternType>(ty))
-        return true;
-    else
-        return false;
-}
-
-bool ApplyTypeFunction::ignoreChildren(TypePackId tp)
-{
-    if (get<GenericTypePack>(tp))
-        return true;
-    else
-        return false;
-}
-
-TypeId ApplyTypeFunction::clean(TypeId ty)
-{
-    TypeId& arg = typeArguments[ty];
-    LUAU_ASSERT(arg);
-    return arg;
-}
-
-TypePackId ApplyTypeFunction::clean(TypePackId tp)
-{
-    TypePackId& arg = typePackArguments[tp];
-    LUAU_ASSERT(arg);
-    return arg;
-}
-
-} // namespace Luau

Analysis/src/AstQuery.cpp

@@ -4,122 +4,19 @@
 #include "Luau/Module.h"
 #include "Luau/Scope.h"
 #include "Luau/TypeInfer.h"
-#include "Luau/Type.h"
+#include "Luau/TypeVar.h"
 #include "Luau/ToString.h"
 
 #include "Luau/Common.h"
 
 #include <algorithm>
 
-LUAU_FASTFLAG(LuauSolverV2)
-
 namespace Luau
 {
 
 namespace
 {
 
-struct AutocompleteNodeFinder : public AstVisitor
-{
-    const Position pos;
-    std::vector<AstNode*> ancestry;
-
-    explicit AutocompleteNodeFinder(Position pos, AstNode* root)
-        : pos(pos)
-    {
-    }
-
-    bool visit(AstExpr* expr) override
-    {
-        if (expr->location.begin <= pos && pos <= expr->location.end)
-        {
-            ancestry.push_back(expr);
-            return true;
-        }
-        return false;
-    }
-
-    bool visit(AstStat* stat) override
-    {
-        // Consider 'local myLocal = 4;|' and 'local myLocal = 4', where '|' is the cursor position. In both cases, the cursor position is equal
-        // to `AstStatLocal.location.end`. However, in the first case (semicolon), we are starting a new statement, whilst in the second case
-        // (no semicolon) we are still part of the AstStatLocal, hence the different comparison check.
-        if (stat->location.begin < pos && (stat->hasSemicolon ? pos < stat->location.end : pos <= stat->location.end))
-        {
-            ancestry.push_back(stat);
-            return true;
-        }
-
-        return false;
-    }
-
-    bool visit(AstType* type) override
-    {
-        if (type->location.begin < pos && pos <= type->location.end)
-        {
-            ancestry.push_back(type);
-            return true;
-        }
-        return false;
-    }
-
-    bool visit(AstTypeError* type) override
-    {
-        // For a missing type, match the whole range including the start position
-        if (type->isMissing && type->location.containsClosed(pos))
-        {
-            ancestry.push_back(type);
-            return true;
-        }
-        return false;
-    }
-
-    bool visit(class AstTypePack* typePack) override
-    {
-        return true;
-    }
-
-    bool visit(AstStatBlock* block) override
-    {
-        // If ancestry is empty, we are inspecting the root of the AST.  Its extent is considered to be infinite.
-        if (ancestry.empty())
-        {
-            ancestry.push_back(block);
-            return true;
-        }
-
-        // AstExprIndexName nodes are nested outside-in, so we want the outermost node in the case of nested nodes.
-        // ex foo.bar.baz is represented in the AST as IndexName{ IndexName {foo, bar}, baz}
-        if (!ancestry.empty() && ancestry.back()->is<AstExprIndexName>())
-            return false;
-
-        // Type annotation error might intersect the block statement when the function header is being written,
-        // annotation takes priority
-        if (!ancestry.empty() && ancestry.back()->is<AstTypeError>())
-            return false;
-
-        // If the cursor is at the end of an expression or type and simultaneously at the beginning of a block,
-        // the expression or type wins out.
-        // The exception to this is if we are in a block under an AstExprFunction.  In this case, we consider the position to
-        // be within the block.
-        if (block->location.begin == pos && !ancestry.empty())
-        {
-            if (ancestry.back()->asExpr() && !ancestry.back()->is<AstExprFunction>())
-                return false;
-
-            if (ancestry.back()->asType())
-                return false;
-        }
-
-        if (block->location.begin <= pos && pos <= block->location.end)
-        {
-            ancestry.push_back(block);
-            return true;
-        }
-        return false;
-    }
-};
-
 struct FindNode : public AstVisitor
 {
     const Position pos;
@@ -152,16 +49,6 @@ struct FindNode : public AstVisitor
         return false;
     }
 
-    bool visit(AstStatFunction* node) override
-    {
-        visit(static_cast<AstNode*>(node));
-        if (node->name->location.contains(pos))
-            node->name->visit(this);
-        else if (node->func->location.contains(pos))
-            node->func->visit(this);
-        return false;
-    }
-
     bool visit(AstStatBlock* block) override
     {
         visit(static_cast<AstNode*>(block));
@@ -180,97 +67,47 @@ struct FindNode : public AstVisitor
     }
 };
 
+struct FindFullAncestry final : public AstVisitor
+{
+    std::vector<AstNode*> nodes;
+    Position pos;
+
+    explicit FindFullAncestry(Position pos)
+        : pos(pos)
+    {
+    }
+
+    bool visit(AstNode* node)
+    {
+        if (node->location.contains(pos))
+        {
+            nodes.push_back(node);
+            return true;
+        }
+        return false;
+    }
+};
+
 } // namespace
 
-FindFullAncestry::FindFullAncestry(Position pos, Position documentEnd, bool includeTypes)
-    : pos(pos)
-    , documentEnd(documentEnd)
-    , includeTypes(includeTypes)
+std::vector<AstNode*> findAstAncestryOfPosition(const SourceModule& source, Position pos)
 {
-}
-
-bool FindFullAncestry::visit(AstType* type)
-{
-    if (includeTypes)
-        return visit(static_cast<AstNode*>(type));
-    else
-        return false;
-}
-
-bool FindFullAncestry::visit(AstStatFunction* node)
-{
-    visit(static_cast<AstNode*>(node));
-    if (node->name->location.contains(pos))
-        node->name->visit(this);
-    else if (node->func->location.contains(pos))
-        node->func->visit(this);
-    return false;
-}
-
-bool FindFullAncestry::visit(AstNode* node)
-{
-    if (node->location.contains(pos))
-    {
-        nodes.push_back(node);
-        return true;
-    }
-
-    // Edge case: If we ask for the node at the position that is the very end of the document
-    // return the innermost AST element that ends at that position.
-
-    if (node->location.end == documentEnd && pos >= documentEnd)
-    {
-        nodes.push_back(node);
-        return true;
-    }
-
-    return false;
-}
-
-std::vector<AstNode*> findAncestryAtPositionForAutocomplete(const SourceModule& source, Position pos)
-{
-    return findAncestryAtPositionForAutocomplete(source.root, pos);
-}
-
-std::vector<AstNode*> findAncestryAtPositionForAutocomplete(AstStatBlock* root, Position pos)
-{
-    AutocompleteNodeFinder finder{pos, root};
-    root->visit(&finder);
-    return finder.ancestry;
-}
-
-std::vector<AstNode*> findAstAncestryOfPosition(const SourceModule& source, Position pos, bool includeTypes)
-{
-    return findAstAncestryOfPosition(source.root, pos, includeTypes);
-}
-
-std::vector<AstNode*> findAstAncestryOfPosition(AstStatBlock* root, Position pos, bool includeTypes)
-{
-    const Position end = root->location.end;
-    if (pos > end)
-        pos = end;
-
-    FindFullAncestry finder(pos, end, includeTypes);
-    root->visit(&finder);
-    return finder.nodes;
+    FindFullAncestry finder(pos);
+    source.root->visit(&finder);
+    return std::move(finder.nodes);
 }
 
 AstNode* findNodeAtPosition(const SourceModule& source, Position pos)
 {
-    return findNodeAtPosition(source.root, pos);
-}
-
-AstNode* findNodeAtPosition(AstStatBlock* root, Position pos)
-{
-    const Position end = root->location.end;
-    if (pos < root->location.begin)
-        return root;
+    const Position end = source.root->location.end;
+    if (pos < source.root->location.begin)
+        return source.root;
 
     if (pos > end)
         pos = end;
 
     FindNode findNode{pos, end};
-    findNode.visit(root);
+    findNode.visit(source.root);
     return findNode.best;
 }
 
@@ -285,8 +122,7 @@ AstExpr* findExprAtPosition(const SourceModule& source, Position pos)
 
 ScopePtr findScopeAtPosition(const Module& module, Position pos)
 {
-    if (module.scopes.empty())
-        return nullptr;
+    LUAU_ASSERT(!module.scopes.empty());
 
     Location scopeLocation = module.scopes.front().first;
     ScopePtr scope = module.scopes.front().second;
@@ -328,20 +164,10 @@ std::optional<TypeId> findExpectedTypeAtPosition(const Module& module, const Sou
 
 static std::optional<AstStatLocal*> findBindingLocalStatement(const SourceModule& source, const Binding& binding)
 {
-    // Bindings coming from global sources (e.g., definition files) have a zero position.
-    // They cannot be defined from a local statement
-    if (binding.location == Location{{0, 0}, {0, 0}})
-        return std::nullopt;
-
     std::vector<AstNode*> nodes = findAstAncestryOfPosition(source, binding.location.begin);
-    auto iter = std::find_if(
-        nodes.rbegin(),
-        nodes.rend(),
-        [](AstNode* node)
-        {
-            return node->is<AstStatLocal>();
-        }
-    );
+    auto iter = std::find_if(nodes.rbegin(), nodes.rend(), [](AstNode* node) {
+        return node->is<AstStatLocal>();
+    });
     return iter != nodes.rend() ? std::make_optional((*iter)->as<AstStatLocal>()) : std::nullopt;
 }
 
@@ -360,13 +186,14 @@ std::optional<Binding> findBindingAtPosition(const Module& module, const SourceM
         return std::nullopt;
 
     ScopePtr currentScope = findScopeAtPosition(module, pos);
+    LUAU_ASSERT(currentScope);
 
     while (currentScope)
     {
         auto iter = currentScope->bindings.find(name);
         if (iter != currentScope->bindings.end() && iter->second.location.begin <= pos)
         {
-            // Ignore this binding if we're inside its definition. e.g. local abc = abc -- Will take the definition of abc from outer scope
+            /* Ignore this binding if we're inside its definition. e.g. local abc = abc -- Will take the definition of abc from outer scope */
             std::optional<AstStatLocal*> bindingStatement = findBindingLocalStatement(source, iter->second);
             if (!bindingStatement || !(*bindingStatement)->location.contains(pos))
                 return iter->second;
@@ -479,71 +306,6 @@ ExprOrLocal findExprOrLocalAtPosition(const SourceModule& source, Position pos)
     return findVisitor.result;
 }
 
-static std::optional<DocumentationSymbol> checkOverloadedDocumentationSymbol(
-    const Module& module,
-    const TypeId ty,
-    const AstExpr* parentExpr,
-    const std::optional<DocumentationSymbol> documentationSymbol
-)
-{
-    if (!documentationSymbol)
-        return std::nullopt;
-
-    // This might be an overloaded function.
-    if (get<IntersectionType>(follow(ty)))
-    {
-        TypeId matchingOverload = nullptr;
-        if (parentExpr && parentExpr->is<AstExprCall>())
-        {
-            if (auto it = module.astOverloadResolvedTypes.find(parentExpr))
-            {
-                matchingOverload = *it;
-            }
-        }
-
-        if (matchingOverload)
-        {
-            std::string overloadSymbol = *documentationSymbol + "/overload/";
-            // Default toString options are fine for this purpose.
-            overloadSymbol += toString(matchingOverload);
-            return overloadSymbol;
-        }
-    }
-
-    return documentationSymbol;
-}
-
-static std::optional<DocumentationSymbol> getMetatableDocumentation(
-    const Module& module,
-    AstExpr* parentExpr,
-    const TableType* mtable,
-    const AstName& index
-)
-{
-    auto indexIt = mtable->props.find("__index");
-    if (indexIt == mtable->props.end())
-        return std::nullopt;
-
-    TypeId followed = follow(indexIt->second.type());
-    const TableType* ttv = get<TableType>(followed);
-    if (!ttv)
-        return std::nullopt;
-
-    auto propIt = ttv->props.find(index.value);
-    if (propIt == ttv->props.end())
-        return std::nullopt;
-
-    if (FFlag::LuauSolverV2)
-    {
-        if (auto ty = propIt->second.readTy)
-            return checkOverloadedDocumentationSymbol(module, *ty, parentExpr, propIt->second.documentationSymbol);
-    }
-    else
-        return checkOverloadedDocumentationSymbol(module, propIt->second.type(), parentExpr, propIt->second.documentationSymbol);
-
-    return std::nullopt;
-}
-
 std::optional<DocumentationSymbol> getDocumentationSymbolAtPosition(const SourceModule& source, const Module& module, Position position)
 {
     std::vector<AstNode*> ancestry = findAstAncestryOfPosition(source, position);
@@ -552,7 +314,33 @@ std::optional<DocumentationSymbol> getDocumentationSymbolAtPosition(const Source
     AstExpr* parentExpr = ancestry.size() >= 2 ? ancestry[ancestry.size() - 2]->asExpr() : nullptr;
 
     if (std::optional<Binding> binding = findBindingAtPosition(module, source, position))
-        return checkOverloadedDocumentationSymbol(module, binding->typeId, parentExpr, binding->documentationSymbol);
+    {
+        if (binding->documentationSymbol)
+        {
+            // This might be an overloaded function binding.
+            if (get<IntersectionTypeVar>(follow(binding->typeId)))
+            {
+                TypeId matchingOverload = nullptr;
+                if (parentExpr && parentExpr->is<AstExprCall>())
+                {
+                    if (auto it = module.astOverloadResolvedTypes.find(parentExpr))
+                    {
+                        matchingOverload = *it;
+                    }
+                }
+
+                if (matchingOverload)
+                {
+                    std::string overloadSymbol = *binding->documentationSymbol + "/overload/";
+                    // Default toString options are fine for this purpose.
+                    overloadSymbol += toString(matchingOverload);
+                    return overloadSymbol;
+                }
+            }
+        }
+
+        return binding->documentationSymbol;
+    }
 
     if (targetExpr)
     {
@@ -561,44 +349,18 @@ std::optional<DocumentationSymbol> getDocumentationSymbolAtPosition(const Source
             if (auto it = module.astTypes.find(indexName->expr))
             {
                 TypeId parentTy = follow(*it);
-                if (const TableType* ttv = get<TableType>(parentTy))
+                if (const TableTypeVar* ttv = get<TableTypeVar>(parentTy))
                 {
                     if (auto propIt = ttv->props.find(indexName->index.value); propIt != ttv->props.end())
                     {
-                        if (FFlag::LuauSolverV2)
-                        {
-                            if (auto ty = propIt->second.readTy)
-                                return checkOverloadedDocumentationSymbol(module, *ty, parentExpr, propIt->second.documentationSymbol);
-                        }
-                        else
-                            return checkOverloadedDocumentationSymbol(module, propIt->second.type(), parentExpr, propIt->second.documentationSymbol);
+                        return propIt->second.documentationSymbol;
                     }
                 }
-                else if (const ExternType* etv = get<ExternType>(parentTy))
+                else if (const ClassTypeVar* ctv = get<ClassTypeVar>(parentTy))
                 {
-                    while (etv)
+                    if (auto propIt = ctv->props.find(indexName->index.value); propIt != ctv->props.end())
                     {
-                        if (auto propIt = etv->props.find(indexName->index.value); propIt != etv->props.end())
-                        {
-                            if (FFlag::LuauSolverV2)
-                            {
-                                if (auto ty = propIt->second.readTy)
-                                    return checkOverloadedDocumentationSymbol(module, *ty, parentExpr, propIt->second.documentationSymbol);
-                            }
-                            else
-                                return checkOverloadedDocumentationSymbol(
-                                    module, propIt->second.type(), parentExpr, propIt->second.documentationSymbol
-                                );
-                        }
-                        etv = etv->parent ? Luau::get<Luau::ExternType>(*etv->parent) : nullptr;
-                    }
-                }
-                else if (const PrimitiveType* ptv = get<PrimitiveType>(parentTy); ptv && ptv->metatable)
-                {
-                    if (auto mtable = get<TableType>(*ptv->metatable))
-                    {
-                        if (std::optional<std::string> docSymbol = getMetatableDocumentation(module, parentExpr, mtable, indexName->index))
-                            return docSymbol;
+                        return propIt->second.documentationSymbol;
                     }
                 }
             }

Analysis/src/AutocompleteCore.h

@@ -1,27 +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/AutocompleteTypes.h"
-
-namespace Luau
-{
-struct Module;
-struct FileResolver;
-
-using ModulePtr = std::shared_ptr<Module>;
-using ModuleName = std::string;
-
-
-AutocompleteResult autocomplete_(
-    const ModulePtr& module,
-    NotNull<BuiltinTypes> builtinTypes,
-    TypeArena* typeArena,
-    std::vector<AstNode*>& ancestry,
-    Scope* globalScope,
-    const ScopePtr& scopeAtPosition,
-    Position position,
-    FileResolver* fileResolver,
-    StringCompletionCallback callback
-);
-
-} // namespace Luau