Sync to upstream/release/672 (#1800)

# What's Changed?

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

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

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

# New Type Solver

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

# Internal Contributors

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

---------

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

.clang-format

@@ -16,10 +16,14 @@ 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/Roblox/luau/discussions
+    url: https://github.com/luau-lang/luau/discussions
     about: Please use GitHub Discussions if you have questions or need help.

.github/codecov.yml

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

.github/workflows/benchmark.yml

@@ -0,0 +1,145 @@
+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,22 +20,35 @@ jobs:
   unix:
     strategy:
       matrix:
-        os: [ubuntu, macos]
-    name: ${{matrix.os}}
-    runs-on: ${{matrix.os}}-latest
+        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}}
     steps:
     - uses: actions/checkout@v1
-    - name: make test
+    - name: work around ASLR+ASAN compatibility
+      run: sudo sysctl -w vm.mmap_rnd_bits=28
+      if: matrix.os.name == 'ubuntu'
+    - name: make tests
       run: |
-        make -j2 config=sanitize werror=1 test
-    - name: make test w/flags
+        make -j2 config=sanitize werror=1 native=1 luau-tests
+    - name: run tests
       run: |
-        make -j2 config=sanitize werror=1 flags=true test
+        ./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
     - name: make cli
       run: |
-         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
+         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
 
   windows:
     runs-on: windows-latest
@@ -45,41 +58,64 @@ jobs:
     steps:
     - uses: actions/checkout@v1
     - name: cmake configure
-      run: cmake . -A ${{matrix.arch}} -DLUAU_WERROR=ON
-    - name: cmake test
+      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
       shell: bash # necessary for fail-fast
       run: |
-        cmake --build . --target Luau.UnitTest Luau.Conformance --config Debug
         Debug/Luau.UnitTest.exe
         Debug/Luau.Conformance.exe
-    - name: cmake test w/flags
-      shell: bash # necessary for fail-fast
-      run: |
         Debug/Luau.UnitTest.exe --fflags=true
         Debug/Luau.Conformance.exe --fflags=true
+    - name: run extra conformance tests
+      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
     - name: cmake cli
       shell: bash # necessary for fail-fast
       run: |
-        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
+        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
 
   coverage:
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
     steps:
-    - uses: actions/checkout@v1
+    - uses: actions/checkout@v2
     - name: install
       run: |
         sudo apt install llvm
     - name: make coverage
       run: |
-        CXX=clang++-10 make -j2 config=coverage coverage
+        CXX=clang++ make -j2 config=coverage native=1 coverage
     - name: upload coverage
-      uses: coverallsapp/github-action@master
+      uses: codecov/codecov-action@v3
       with:
-        path-to-lcov: ./coverage.info
-        github-token: ${{ secrets.GITHUB_TOKEN }}
-    - uses: actions/upload-artifact@v2
+        files: ./coverage.info
+        token: ${{ secrets.CODECOV_TOKEN }}
+
+  web:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v1
+    - uses: actions/checkout@v2
       with:
-        name: coverage
-        path: coverage
+        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

.github/workflows/new-release.yml

@@ -0,0 +1,83 @@
+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,23 +13,48 @@ on:
 jobs:
   build:
     strategy:
-      matrix:
-        os: [ubuntu, macos, windows]
-    name: ${{matrix.os}}
-    runs-on: ${{matrix.os}}-latest
+      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 --config Release
-    - uses: actions/upload-artifact@v2
-      if: matrix.os != 'windows'
+      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'
       with:
-        name: luau-${{matrix.os}}
+        name: luau-${{matrix.os.name}}
         path: luau*
-    - uses: actions/upload-artifact@v2
-      if: matrix.os == 'windows'
+        overwrite: true
+    - uses: actions/upload-artifact@v4
+      if: matrix.os.name == 'windows'
       with:
-        name: luau-${{matrix.os}}
+        name: luau-${{matrix.os.name}}
         path: Release\luau*.exe
+        overwrite: true
+  web:
+    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-artifact@v4
+      with:
+        name: Luau.Web.js
+        path: Luau.Web.js
+        overwrite: true

.gitignore

@@ -1,8 +1,20 @@
-^build/
-^coverage/
-^fuzz/luau.pb.*
-^crash-*
-^default.prof*
-^fuzz-*
-^luau$
-/.vs
+/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

Analysis/include/Luau/Anyification.h

@@ -0,0 +1,54 @@
+// 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

@@ -0,0 +1,32 @@
+// This file is part of the Luau programming language and is licensed under MIT License; see LICENSE.txt for details
+#pragma once
+
+#include "Luau/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/AstJsonEncoder.h

@@ -2,12 +2,15 @@
 #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/AstQuery.h

@@ -3,6 +3,7 @@
 
 #include "Luau/Ast.h"
 #include "Luau/Documentation.h"
+#include "Luau/TypeFwd.h"
 
 #include <memory>
 
@@ -13,9 +14,6 @@ struct Binding;
 struct SourceModule;
 struct Module;
 
-struct TypeVar;
-using TypeId = const TypeVar*;
-
 using ScopePtr = std::shared_ptr<struct Scope>;
 
 struct ExprOrLocal
@@ -42,14 +40,49 @@ 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;
 };
 
-std::vector<AstNode*> findAstAncestryOfPosition(const SourceModule& source, Position pos);
+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);
 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/TypeVar.h"
+#include "Luau/Type.h"
 
-#include <unordered_map>
 #include <string>
 #include <memory>
 #include <optional>
@@ -16,76 +16,8 @@ struct Frontend;
 struct SourceModule;
 struct Module;
 struct TypeChecker;
-
-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;
-};
+struct FileResolver;
 
 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

@@ -0,0 +1,92 @@
+// 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,50 +2,94 @@
 #pragma once
 
 #include "Luau/Scope.h"
-#include "Luau/TypeInfer.h"
+#include "Luau/Type.h"
+
+#include <optional>
 
 namespace Luau
 {
 
-void registerBuiltinTypes(TypeChecker& typeChecker);
+static constexpr char kRequireTagName[] = "require";
 
+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(TypeChecker& typeChecker, TypeArena& arena, TypeId t);
+TypeId makeOption(NotNull<BuiltinTypes> builtinTypes, 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);
+    TypeArena& arena,
+    std::optional<TypeId> selfType,
+    std::initializer_list<TypeId> paramTypes,
+    std::initializer_list<TypeId> retTypes,
+    bool checked = false
+);
 
 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);
+    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
+);
 
 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);
+    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
+);
 
 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);
-
-void attachMagicFunction(TypeId ty, MagicFunction fn);
+    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
+);
 
+void attachMagicFunction(TypeId ty, std::shared_ptr<MagicFunction> fn);
 Property makeProperty(TypeId ty, std::optional<std::string> documentationSymbol = std::nullopt);
-void assignPropDocumentationSymbols(TableTypeVar::Props& props, const std::string& baseName);
+void assignPropDocumentationSymbols(TableType::Props& props, const std::string& baseName);
 
 std::string getBuiltinDefinitionSource();
+std::string getTypeFunctionDefinitionSource();
 
-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);
+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);
 
 } // namespace Luau

Analysis/include/Luau/Cancellation.h

@@ -0,0 +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 <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

@@ -0,0 +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/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

@@ -1,58 +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/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

@@ -0,0 +1,332 @@
+// 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

@@ -0,0 +1,487 @@
+// 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

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

Analysis/include/Luau/ConstraintSolver.h

@@ -0,0 +1,459 @@
+// 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

@@ -0,0 +1,36 @@
+// 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

@@ -0,0 +1,222 @@
+// 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

@@ -0,0 +1,151 @@
+// 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

@@ -0,0 +1,91 @@
+// 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

@@ -0,0 +1,208 @@
+// 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,3 +1,4 @@
+// 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"
@@ -21,6 +22,7 @@ struct BasicDocumentation
 {
     std::string documentation;
     std::string learnMoreLink;
+    std::string codeSample;
 };
 
 struct FunctionParameterDocumentation
@@ -37,6 +39,7 @@ struct FunctionDocumentation
     std::vector<FunctionParameterDocumentation> parameters;
     std::vector<DocumentationSymbol> returns;
     std::string learnMoreLink;
+    std::string codeSample;
 };
 
 struct OverloadedFunctionDocumentation
@@ -52,6 +55,7 @@ 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

@@ -0,0 +1,50 @@
+// 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

@@ -0,0 +1,376 @@
+// 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,24 +1,41 @@
 // 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/TypeVar.h"
+#include "Luau/NotNull.h"
+#include "Luau/Type.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, TypeError error);
+    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);
 
     TypeId wantedType = nullptr;
     TypeId givenType = nullptr;
+    Context context = CovariantContext;
 
     std::string reason;
     std::shared_ptr<TypeError> error;
@@ -32,7 +49,6 @@ struct UnknownSymbol
     {
         Binding,
         Type,
-        Generic
     };
     Name name;
     Context context;
@@ -80,7 +96,7 @@ struct OnlyTablesCanHaveMethods
 struct DuplicateTypeDefinition
 {
     Name name;
-    Location previousLocation;
+    std::optional<Location> previousLocation;
 
     bool operator==(const DuplicateTypeDefinition& rhs) const;
 };
@@ -90,12 +106,16 @@ struct CountMismatch
     enum Context
     {
         Arg,
-        Result,
+        FunctionResult,
+        ExprListResult,
         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;
 };
@@ -107,8 +127,6 @@ struct FunctionDoesNotTakeSelf
 
 struct FunctionRequiresSelf
 {
-    int requiredExtraNils = 0;
-
     bool operator==(const FunctionRequiresSelf& rhs) const;
 };
 
@@ -169,6 +187,18 @@ 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;
@@ -277,11 +307,226 @@ struct MissingUnionProperty
     bool operator==(const MissingUnionProperty& rhs) const;
 };
 
-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>;
+struct TypesAreUnrelated
+{
+    TypeId left;
+    TypeId right;
+
+    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)
+    {
+    }
+};
 
 struct TypeError
 {
@@ -289,6 +534,7 @@ struct TypeError
     ModuleName moduleName;
     TypeErrorData data;
 
+    static int minCode();
     int code() const;
 
     TypeError() = default;
@@ -306,6 +552,8 @@ struct TypeError
     }
 
     bool operator==(const TypeError& rhs) const;
+
+    TypeErrorSummary summary() const;
 };
 
 template<typename T>
@@ -322,12 +570,18 @@ 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);
+void copyErrors(ErrorVec& errors, struct TypeArena& destArena, NotNull<BuiltinTypes> builtinTypes);
 
 // Internal Compiler Error
 struct InternalErrorReporter
@@ -335,8 +589,33 @@ struct InternalErrorReporter
     std::function<void(const char*)> onInternalError;
     std::string moduleName;
 
-    [[noreturn]] void ice(const std::string& message, const Location& location);
-    [[noreturn]] void ice(const std::string& message);
+    [[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;
 };
 
 } // namespace Luau

Analysis/include/Luau/FileResolver.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 <string>
+#include <memory>
 #include <optional>
+#include <string>
+#include <vector>
 
 namespace Luau
 {
@@ -18,7 +20,7 @@ struct SourceCode
         None,
         Module,
         Script,
-        Local
+        Local_DEPRECATED
     };
 
     std::string source;
@@ -31,8 +33,71 @@ struct ModuleInfo
     bool optional = false;
 };
 
+struct RequireAlias
+{
+    std::string alias; // Unprefixed alias name (no leading `@`).
+    std::vector<std::string> tags = {};
+};
+
+struct RequireNode
+{
+    virtual ~RequireNode() {}
+
+    // Get the path component representing this node.
+    virtual std::string getPathComponent() const = 0;
+
+    // Get the displayed user-facing label for this node, defaults to getPathComponent()
+    virtual std::string getLabel() const
+    {
+        return getPathComponent();
+    }
+
+    // Get tags to attach to this node's RequireSuggestion (defaults to none).
+    virtual std::vector<std::string> getTags() const
+    {
+        return {};
+    }
+
+    // TODO: resolvePathToNode() can ultimately be replaced with a call into
+    // require-by-string's path resolution algorithm. This will first require
+    // generalizing that algorithm to work with a virtual file system.
+    virtual std::unique_ptr<RequireNode> resolvePathToNode(const std::string& path) const = 0;
+
+    // Get children of this node, if any (if this node represents a directory).
+    virtual std::vector<std::unique_ptr<RequireNode>> getChildren() const = 0;
+
+    // A list of the aliases available to this node.
+    virtual std::vector<RequireAlias> getAvailableAliases() const = 0;
+};
+
+struct RequireSuggestion
+{
+    std::string label;
+    std::string fullPath;
+    std::vector<std::string> tags;
+};
+using RequireSuggestions = std::vector<RequireSuggestion>;
+
+struct RequireSuggester
+{
+    virtual ~RequireSuggester() {}
+    std::optional<RequireSuggestions> getRequireSuggestions(const ModuleName& requirer, const std::optional<std::string>& pathString) const;
+
+protected:
+    virtual std::unique_ptr<RequireNode> getNode(const ModuleName& name) const = 0;
+
+private:
+    std::optional<RequireSuggestions> getRequireSuggestionsImpl(const ModuleName& requirer, const std::optional<std::string>& path) const;
+};
+
 struct FileResolver
 {
+    FileResolver() = default;
+    FileResolver(std::shared_ptr<RequireSuggester> requireSuggester)
+        : requireSuggester(std::move(requireSuggester))
+    {
+    }
+
     virtual ~FileResolver() {}
 
     virtual std::optional<SourceCode> readSource(const ModuleName& name) = 0;
@@ -52,12 +117,9 @@ struct FileResolver
         return std::nullopt;
     }
 
-    // DEPRECATED APIS
-    // These are going to be removed with LuauNewRequireTrace2
-    virtual bool moduleExists(const ModuleName& name) const = 0;
-    virtual std::optional<ModuleName> fromAstFragment(AstExpr* expr) const = 0;
-    virtual ModuleName concat(const ModuleName& lhs, std::string_view rhs) const = 0;
-    virtual std::optional<ModuleName> getParentModuleName(const ModuleName& name) const = 0;
+    std::optional<RequireSuggestions> getRequireSuggestions(const ModuleName& requirer, const std::optional<std::string>& pathString) const;
+
+    std::shared_ptr<RequireSuggester> requireSuggester;
 };
 
 struct NullFileResolver : FileResolver
@@ -66,22 +128,6 @@ struct NullFileResolver : FileResolver
     {
         return std::nullopt;
     }
-    bool moduleExists(const ModuleName& name) const override
-    {
-        return false;
-    }
-    std::optional<ModuleName> fromAstFragment(AstExpr* expr) const override
-    {
-        return std::nullopt;
-    }
-    ModuleName concat(const ModuleName& lhs, std::string_view rhs) const override
-    {
-        return lhs;
-    }
-    std::optional<ModuleName> getParentModuleName(const ModuleName& name) const override
-    {
-        return std::nullopt;
-    }
 };
 
 } // namespace Luau

Analysis/include/Luau/FragmentAutocomplete.h

@@ -0,0 +1,196 @@
+// 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,12 +2,16 @@
 #pragma once
 
 #include "Luau/Config.h"
+#include "Luau/GlobalTypes.h"
 #include "Luau/Module.h"
 #include "Luau/ModuleResolver.h"
 #include "Luau/RequireTracer.h"
-#include "Luau/TypeInfer.h"
+#include "Luau/Scope.h"
+#include "Luau/Set.h"
+#include "Luau/TypeCheckLimits.h"
 #include "Luau/Variant.h"
 
+#include <mutex>
 #include <string>
 #include <vector>
 #include <optional>
@@ -20,44 +24,65 @@ 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;
 };
 
-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);
+std::optional<Mode> parseMode(const std::vector<HotComment>& hotcomments);
 
 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::unordered_set<ModuleName> requires;
+    std::string humanReadableName;
+    DenseHashSet<ModuleName> requireSet{{}};
     std::vector<std::pair<ModuleName, Location>> requireLocations;
-    bool dirty = true;
+    Set<ModuleName> dependents{{}};
+
+    bool dirtySourceModule = true;
+    bool dirtyModule = true;
+    bool dirtyModuleForAutocomplete = true;
+
+    bool invalidModuleDependency = true;
+    bool invalidModuleDependencyForAutocomplete = true;
+
+    double autocompleteLimitsMult = 1.0;
 };
 
 struct FrontendOptions
@@ -68,14 +93,38 @@ struct FrontendOptions
     // is complete.
     bool retainFullTypeGraphs = false;
 
-    // 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;
+    // 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;
 };
 
 struct CheckResult
 {
     std::vector<TypeError> errors;
+
+    LintResult lintResult;
+
+    std::vector<ModuleName> timeoutHits;
 };
 
 struct FrontendModuleResolver : ModuleResolver
@@ -87,7 +136,13 @@ 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;
 };
 
@@ -109,22 +164,19 @@ struct Frontend
 
     Frontend(FileResolver* fileResolver, ConfigResolver* configResolver, const FrontendOptions& options = {});
 
-    CheckResult check(const ModuleName& name); // new shininess
-    LintResult lint(const ModuleName& name, std::optional<Luau::LintOptions> enabledLintWarnings = {});
+    // Parse module graph and prepare SourceNode/SourceModule data, including required dependencies without running typechecking
+    void parse(const ModuleName& name);
 
-    /** 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 = {});
+    // Parse and typecheck module graph
+    CheckResult check(const ModuleName& name, std::optional<FrontendOptions> optionOverride = {}); // new shininess
 
-    CheckResult check(const SourceModule& module); // OLD.  TODO KILL
-    LintResult lint(const SourceModule& module, std::optional<Luau::LintOptions> enabledLintWarnings = {});
+    bool allModuleDependenciesValid(const ModuleName& name, bool forAutocomplete = false) const;
 
-    bool isDirty(const ModuleName& name) const;
+    bool isDirty(const ModuleName& name, bool forAutocomplete = false) const;
     void markDirty(const ModuleName& name, std::vector<ModuleName>* markedDirty = nullptr);
 
+    void traverseDependents(const ModuleName& name, std::function<bool(SourceNode&)> processSubtree);
+
     /** Borrow a pointer into the SourceModule cache.
      *
      * Returns nullptr if we don't have it.  This could mean that the script
@@ -140,40 +192,133 @@ struct Frontend
     void clear();
 
     ScopePtr addEnvironment(const std::string& environmentName);
-    ScopePtr getEnvironmentScope(const std::string& environmentName);
+    ScopePtr getEnvironmentScope(const std::string& environmentName) const;
 
-    void registerBuiltinDefinition(const std::string& name, std::function<void(TypeChecker&, ScopePtr)>);
+    void registerBuiltinDefinition(const std::string& name, std::function<void(Frontend&, GlobalTypes&, 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:
-    std::pair<SourceNode*, SourceModule*> getSourceNode(CheckResult& checkResult, const ModuleName& name);
+    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);
     SourceModule parse(const ModuleName& name, std::string_view src, const ParseOptions& parseOptions);
 
-    bool parseGraph(std::vector<ModuleName>& buildQueue, CheckResult& checkResult, const ModuleName& root);
+    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);
 
     static LintResult classifyLints(const std::vector<LintWarning>& warnings, const Config& config);
 
-    ScopePtr getModuleEnvironment(const SourceModule& module, const Config& config);
+    ScopePtr getModuleEnvironment(const SourceModule& module, const Config& config, bool forAutocomplete) const;
 
     std::unordered_map<std::string, ScopePtr> environments;
-    std::unordered_map<std::string, std::function<void(TypeChecker&, ScopePtr)>> builtinDefinitions;
+    std::unordered_map<std::string, std::function<void(Frontend&, GlobalTypes&, ScopePtr)>> builtinDefinitions;
+
+    BuiltinTypes builtinTypes_;
 
 public:
+    const NotNull<BuiltinTypes> builtinTypes;
+
     FileResolver* fileResolver;
+
     FrontendModuleResolver moduleResolver;
     FrontendModuleResolver moduleResolverForAutocomplete;
-    TypeChecker typeChecker;
-    TypeChecker typeCheckerForAutocomplete;
+
+    GlobalTypes globals;
+    GlobalTypes globalsForAutocomplete;
+
     ConfigResolver* configResolver;
     FrontendOptions options;
     InternalErrorReporter iceHandler;
-    TypeArena arenaForAutocomplete;
+    std::function<void(const ModuleName& name, const ScopePtr& scope, bool forAutocomplete)> prepareModuleScope;
+    std::function<void(const ModuleName& name, std::string log)> writeJsonLog = {};
 
-    std::unordered_map<ModuleName, SourceNode> sourceNodes;
-    std::unordered_map<ModuleName, SourceModule> sourceModules;
-    std::unordered_map<ModuleName, RequireTraceResult> requires;
+    std::unordered_map<ModuleName, std::shared_ptr<SourceNode>> sourceNodes;
+    std::unordered_map<ModuleName, std::shared_ptr<SourceModule>> sourceModules;
+    std::unordered_map<ModuleName, RequireTraceResult> requireTrace;
 
     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

@@ -0,0 +1,82 @@
+// 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

@@ -0,0 +1,27 @@
+// 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

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

Analysis/include/Luau/InsertionOrderedMap.h

@@ -0,0 +1,147 @@
+// 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

@@ -0,0 +1,165 @@
+// 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

@@ -0,0 +1,90 @@
+// 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,8 +3,9 @@
 
 #include "Luau/Error.h"
 #include "Luau/Location.h"
-#include "Luau/TypeVar.h"
+#include "Luau/Type.h"
 #include "Luau/Ast.h"
+#include "Luau/TypePath.h"
 
 #include <ostream>
 
@@ -30,17 +31,32 @@ 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);
 std::ostream& operator<<(std::ostream& lhs, const ModuleHasCyclicDependency& error);
 std::ostream& operator<<(std::ostream& lhs, const DuplicateGenericParameter& error);
 std::ostream& operator<<(std::ostream& lhs, const CannotInferBinaryOperation& error);
+std::ostream& operator<<(std::ostream& lhs, const SwappedGenericTypeParameter& error);
+std::ostream& operator<<(std::ostream& lhs, const OptionalValueAccess& error);
+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 TypeVar& tv);
+std::ostream& operator<<(std::ostream& lhs, const Type& 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

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

@@ -0,0 +1,51 @@
+// 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,9 +1,11 @@
 // This file is part of the Luau programming language and is licensed under MIT License; see LICENSE.txt for details
 #pragma once
 
+#include "Luau/LinterConfig.h"
 #include "Luau/Location.h"
 
 #include <memory>
+#include <string>
 #include <vector>
 
 namespace Luau
@@ -17,79 +19,20 @@ 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;
 };
 
-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<LintWarning> lint(
+    AstStat* root,
+    const AstNameTable& names,
+    const ScopePtr& env,
+    const Module* module,
+    const std::vector<HotComment>& hotcomments,
+    const LintOptions& options
+);
 
 std::vector<AstName> getDeprecatedGlobals(const AstNameTable& names);
 

Analysis/include/Luau/Metamethods.h

@@ -0,0 +1,33 @@
+// 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,12 +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/FileResolver.h"
-#include "Luau/TypePack.h"
-#include "Luau/TypedAllocator.h"
-#include "Luau/ParseOptions.h"
 #include "Luau/Error.h"
-#include "Luau/Parser.h"
+#include "Luau/Linter.h"
+#include "Luau/FileResolver.h"
+#include "Luau/ParseOptions.h"
+#include "Luau/ParseResult.h"
+#include "Luau/Scope.h"
+#include "Luau/TypeArena.h"
+#include "Luau/DataFlowGraph.h"
 
 #include <memory>
 #include <vector>
@@ -16,27 +18,38 @@
 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; // DataModel path if possible.  Filename if not.
+    ModuleName name; // Module identifier or a filename
+    std::string humanReadableName;
+
     SourceCode::Type type = SourceCode::None;
     std::optional<std::string> environmentName;
     bool cyclic = false;
 
-    std::unique_ptr<Allocator> allocator;
-    std::unique_ptr<AstNameTable> names;
+    std::shared_ptr<Allocator> allocator;
+    std::shared_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()
@@ -46,68 +59,97 @@ 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 TypeArena
+struct RequireCycle
 {
-    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);
+    Location location;
+    std::vector<ModuleName> path; // one of the paths for a require() to go all the way back to the originating module
 };
 
-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>;
-
-TypePackId clone(TypePackId tp, TypeArena& dest, SeenTypes& seenTypes, SeenTypePacks& seenTypePacks, bool* encounteredFreeType = nullptr);
-TypeId clone(TypeId tp, TypeArena& dest, SeenTypes& seenTypes, SeenTypePacks& seenTypePacks, bool* encounteredFreeType = nullptr);
-TypeFun clone(const TypeFun& typeFun, TypeArena& dest, SeenTypes& seenTypes, SeenTypePacks& seenTypePacks, bool* encounteredFreeType = nullptr);
-
 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};
-    DenseHashMap<const AstExpr*, TypeId> astOriginalCallTypes{nullptr};
-    DenseHashMap<const AstExpr*, TypeId> astOverloadResolvedTypes{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};
 
     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 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();
+    // 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);
 };
 
 } // namespace Luau

Analysis/include/Luau/ModuleResolver.h

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

@@ -0,0 +1,30 @@
+// 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

@@ -0,0 +1,465 @@
+// 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

@@ -0,0 +1,104 @@
+// 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

@@ -0,0 +1,127 @@
+// 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

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

Analysis/include/Luau/Predicate.h

@@ -1,48 +1,16 @@
 // This file is part of the Luau programming language and is licensed under MIT License; see LICENSE.txt for details
 #pragma once
 
-#include "Luau/Variant.h"
 #include "Luau/Location.h"
-#include "Luau/Symbol.h"
+#include "Luau/LValue.h"
+#include "Luau/Variant.h"
+#include "Luau/TypeFwd.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;
@@ -87,11 +55,7 @@ struct AndPredicate
     PredicateVec lhs;
     PredicateVec rhs;
 
-    AndPredicate(PredicateVec&& lhs, PredicateVec&& rhs)
-        : lhs(std::move(lhs))
-        , rhs(std::move(rhs))
-    {
-    }
+    AndPredicate(PredicateVec&& lhs, PredicateVec&& rhs);
 };
 
 struct OrPredicate
@@ -99,11 +63,7 @@ struct OrPredicate
     PredicateVec lhs;
     PredicateVec rhs;
 
-    OrPredicate(PredicateVec&& lhs, PredicateVec&& rhs)
-        : lhs(std::move(lhs))
-        , rhs(std::move(rhs))
-    {
-    }
+    OrPredicate(PredicateVec&& lhs, PredicateVec&& rhs);
 };
 
 struct NotPredicate
@@ -111,6 +71,19 @@ 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,14 +1,34 @@
 // This file is part of the Luau programming language and is licensed under MIT License; see LICENSE.txt for details
 #pragma once
 
-#include "Luau/TypeVar.h"
+#include "Luau/TypeFwd.h"
+#include "Luau/DenseHash.h"
+#include "Luau/Unifiable.h"
+
+#include <vector>
+#include <optional>
 
 namespace Luau
 {
 
-struct Module;
-using ModulePtr = std::shared_ptr<Module>;
+struct TypeArena;
+struct Scope;
 
-void quantify(ModulePtr module, TypeId ty, TypeLevel level);
+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;
+    }
+};
 
 } // namespace Luau

Analysis/include/Luau/RecursionCounter.h

@@ -2,12 +2,22 @@
 #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)
@@ -22,7 +32,7 @@ struct RecursionCounter
         --(*count);
     }
 
-private:
+protected:
     int* count;
 };
 
@@ -32,7 +42,9 @@ struct RecursionLimiter : RecursionCounter
         : RecursionCounter(count)
     {
         if (limit > 0 && *count > limit)
-            throw std::runtime_error("Internal recursion counter limit exceeded");
+        {
+            throw RecursionLimitException();
+        }
     }
 };
 

Analysis/include/Luau/Refinement.h

@@ -0,0 +1,79 @@
+// 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,20 +6,19 @@
 #include "Luau/Location.h"
 
 #include <string>
+#include <vector>
 
 namespace Luau
 {
 
-class AstStat;
-class AstExpr;
+class AstNode;
 class AstStatBlock;
-struct AstLocal;
 
 struct RequireTraceResult
 {
-    DenseHashMap<const AstExpr*, ModuleInfo> exprs{nullptr};
+    DenseHashMap<const AstNode*, ModuleInfo> exprs{nullptr};
 
-    std::vector<std::pair<ModuleName, Location>> requires;
+    std::vector<std::pair<ModuleName, Location>> requireList;
 };
 
 RequireTraceResult traceRequires(FileResolver* fileResolver, AstStatBlock* root, const ModuleName& currentModuleName);

Analysis/include/Luau/Scope.h

@@ -1,8 +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/Def.h"
+#include "Luau/LValue.h"
 #include "Luau/Location.h"
-#include "Luau/TypeVar.h"
+#include "Luau/NotNull.h"
+#include "Luau/Type.h"
+#include "Luau/DenseHash.h"
+#include "Luau/Symbol.h"
+#include "Luau/Unifiable.h"
 
 #include <unordered_map>
 #include <optional>
@@ -29,39 +35,89 @@ struct Scope
     explicit Scope(TypePackId returnType);                    // root scope
     explicit Scope(const ScopePtr& parent, int subLevel = 0); // child scope.  Parent must not be nullptr.
 
-    const ScopePtr parent; // null for the root
+    ScopePtr parent; // null for the root
+
+    // All the children of this scope.
+    std::vector<NotNull<Scope>> children;
     std::unordered_map<Symbol, Binding> bindings;
-    TypePackId returnType;
-    bool breakOk = false;
+    TypePackId returnType = nullptr;
     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;
 
-    std::optional<TypeId> lookup(const Symbol& name);
+    DenseHashSet<Name> builtinTypeNames{""};
+    void addBuiltinTypeBinding(const Name& name, const TypeFun& tyFun);
 
-    std::optional<TypeFun> lookupType(const Name& name);
-    std::optional<TypeFun> lookupImportedType(const Name& moduleAlias, const Name& 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::unordered_map<Name, TypePackId> privateTypePackBindings;
-    std::optional<TypePackId> lookupPack(const Name& name);
+    std::optional<TypePackId> lookupPack(const Name& name) const;
 
     // 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);
+    std::optional<Binding> linearSearchForBinding(const std::string& name, bool traverseScopeChain = true) const;
+    std::optional<std::pair<Symbol, Binding>> linearSearchForBindingPair(const std::string& name, bool traverseScopeChain) const;
 
     RefinementMap refinements;
 
+    // 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

@@ -0,0 +1,194 @@
+// 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

@@ -0,0 +1,41 @@
+// 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,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 "Luau/Module.h"
-#include "Luau/ModuleResolver.h"
-#include "Luau/TypePack.h"
-#include "Luau/TypeVar.h"
+#include "Luau/TypeArena.h"
+#include "Luau/TypeFwd.h"
 #include "Luau/DenseHash.h"
 
 // We provide an implementation of substitution on types,
@@ -55,6 +53,8 @@
 namespace Luau
 {
 
+struct TxnLog;
+
 enum class TarjanResult
 {
     TooManyChildren,
@@ -68,36 +68,50 @@ 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<TypeId> indexToType;
-    std::vector<TypePackId> indexToPack;
+
+    std::vector<TarjanNode> nodes;
 
     // 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);
@@ -108,33 +122,21 @@ struct Tarjan
     void visitChildren(TypePackId tp, int index);
 
     void visitChild(TypeId ty);
-    void visitChild(TypePackId ty);
+    void visitChild(TypePackId tp);
+
+    template<typename Ty>
+    void visitChild(std::optional<Ty> ty)
+    {
+        if (ty)
+            visitChild(*ty);
+    }
 
     // Visit the root vertex.
     TarjanResult visitRoot(TypeId ty);
-    TarjanResult visitRoot(TypePackId ty);
+    TarjanResult visitRoot(TypePackId tp);
 
-    // 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;
+    // Used to reuse the object for a new operation
+    void clearTarjan(const TxnLog* log);
 
     // Get/set the dirty bit for an index (grows the vector if needed)
     bool getDirty(int index);
@@ -145,8 +147,16 @@ struct FindDirty : Tarjan
     TarjanResult findDirty(TypePackId t);
 
     // We find dirty vertices using Tarjan
-    void visitEdge(int index, int parentIndex) override;
-    void visitSCC(int index) override;
+    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);
 
     // Subclasses should say which vertices are dirty,
     // and what to do with dirty vertices.
@@ -158,19 +168,47 @@ struct FindDirty : Tarjan
 
 // And finally substitution, which finds all the reachable dirty vertices
 // and replaces them with clean ones.
-struct Substitution : FindDirty
+struct Substitution : Tarjan
 {
-    ModulePtr currentModule;
+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;
     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);
 
@@ -182,17 +220,23 @@ struct Substitution : FindDirty
     virtual TypeId clean(TypeId ty) = 0;
     virtual TypePackId clean(TypePackId tp) = 0;
 
+protected:
     // Helper functions to create new types (used by subclasses)
     template<typename T>
-    TypeId addType(const T& tv)
+    TypeId addType(T tv)
     {
-        return currentModule->internalTypes.addType(tv);
+        return arena->addType(std::move(tv));
     }
+
     template<typename T>
-    TypePackId addTypePack(const T& tp)
+    TypePackId addTypePack(T tp)
     {
-        return currentModule->internalTypes.addTypePack(TypePackVar{tp});
+        return arena->addTypePack(TypePackVar{std::move(tp)});
     }
+
+private:
+    template<typename Ty>
+    std::optional<Ty> replace(std::optional<Ty> ty);
 };
 
 } // namespace Luau

Analysis/include/Luau/Subtyping.h

@@ -0,0 +1,313 @@
+// 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,7 +9,6 @@
 namespace Luau
 {
 
-// TODO Rename this to Name once the old type alias is gone.
 struct Symbol
 {
     Symbol()
@@ -30,18 +29,19 @@ struct Symbol
     {
     }
 
+    template<typename T>
+    Symbol(const T&) = delete;
+
     AstLocal* local;
     AstName global;
 
-    bool operator==(const Symbol& rhs) const
+    explicit operator bool() const
     {
-        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;
+        return local != nullptr || global.value != nullptr;
     }
 
+    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;
-        else
-            return false;
+
+        return false;
     }
 
     AstName astName() const

Analysis/include/Luau/TableLiteralInference.h

@@ -0,0 +1,32 @@
+// This file is part of the Luau programming language and is licensed under MIT License; see LICENSE.txt for details
+
+#pragma once
+
+#include "Luau/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

@@ -0,0 +1,27 @@
+// 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/TypeFwd.h"
+
+#include <string>
+
+namespace Luau
+{
+
+struct ToDotOptions
+{
+    bool showPointers = true;        // Show pointer value in the node label
+    bool duplicatePrimitives = true; // Display primitive types and 'any' as separate nodes
+};
+
+std::string toDot(TypeId ty, const ToDotOptions& opts);
+std::string toDot(TypePackId tp, const ToDotOptions& opts);
+
+std::string toDot(TypeId ty);
+std::string toDot(TypePackId tp);
+
+void dumpDot(TypeId ty);
+void dumpDot(TypePackId tp);
+
+} // namespace Luau

Analysis/include/Luau/ToString.h

@@ -2,12 +2,13 @@
 #pragma once
 
 #include "Luau/Common.h"
-#include "Luau/TypeVar.h"
+#include "Luau/TypeFwd.h"
 
-#include <unordered_map>
-#include <optional>
 #include <memory>
+#include <optional>
 #include <string>
+#include <unordered_map>
+#include <vector>
 
 LUAU_FASTINT(LuauTableTypeMaximumStringifierLength)
 LUAU_FASTINT(LuauTypeMaximumStringifierLength)
@@ -15,29 +16,47 @@ LUAU_FASTINT(LuauTypeMaximumStringifierLength)
 namespace Luau
 {
 
+class AstExpr;
+
+struct Scope;
+
+struct Constraint;
+
+struct Position;
+struct Location;
+
 struct ToStringNameMap
 {
-    std::unordered_map<TypeId, std::string> typeVars;
+    std::unordered_map<TypeId, std::string> types;
     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.
-    size_t maxTableLength = size_t(FInt::LuauTableTypeMaximumStringifierLength); // Only applied to TableTypeVars
+    bool hideFunctionSelfArgument = false;        // If true, `self: X` will be omitted from the function signature if the function has self
+    bool hideTableAliasExpansions = false;        // If true, all table aliases will not be expanded
+    bool useQuestionMarks = true;                 // If true, use a postfix ? for options, else write them out as unions that include nil.
+    size_t maxTableLength = size_t(FInt::LuauTableTypeMaximumStringifierLength); // Only applied to TableTypes
     size_t maxTypeLength = size_t(FInt::LuauTypeMaximumStringifierLength);
-    std::optional<ToStringNameMap> nameMap;
+    size_t compositeTypesSingleLineLimit = 5; // The number of type elements permitted on a single line when printing type unions/intersections
+    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;
@@ -45,11 +64,24 @@ struct ToStringResult
     bool truncated = false;
 };
 
-ToStringResult toStringDetailed(TypeId ty, const ToStringOptions& opts = {});
-ToStringResult toStringDetailed(TypePackId ty, const ToStringOptions& opts = {});
+ToStringResult toStringDetailed(TypeId ty, ToStringOptions& opts);
+ToStringResult toStringDetailed(TypePackId ty, ToStringOptions& opts);
 
-std::string toString(TypeId ty, const ToStringOptions& opts);
-std::string toString(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);
+}
 
 // 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!
@@ -62,16 +94,63 @@ inline std::string toString(TypePackId ty)
     return toString(ty, ToStringOptions{});
 }
 
-std::string toString(const TypeVar& tv, const ToStringOptions& opts = {});
-std::string toString(const TypePackVar& tp, const ToStringOptions& opts = {});
+std::string toString(const Constraint& c, ToStringOptions& opts);
 
-std::string toStringNamedFunction(const std::string& prefix, const FunctionTypeVar& ftv, 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);
 
 // 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
-void dump(TypeId ty);
-void dump(TypePackId ty);
+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,37 +1,98 @@
 // This file is part of the Luau programming language and is licensed under MIT License; see LICENSE.txt for details
 #pragma once
 
-#include "Luau/TypeVar.h"
+#include "Luau/Type.h"
+#include "Luau/TypePack.h"
 
-LUAU_FASTFLAG(LuauShareTxnSeen);
+#include <memory>
+#include <unordered_map>
 
 namespace Luau
 {
 
-// Log of where what TypeIds we are rebinding and what they used to be
+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.
 struct TxnLog
 {
-    TxnLog()
-        : originalSeenSize(0)
+    explicit TxnLog()
+        : typeVarChanges(nullptr)
+        , typePackChanges(nullptr)
         , ownedSeen()
         , sharedSeen(&ownedSeen)
     {
     }
 
-    explicit TxnLog(std::vector<std::pair<TypeId, TypeId>>* sharedSeen)
-        : originalSeenSize(sharedSeen->size())
-        , ownedSeen()
-        , sharedSeen(sharedSeen)
+    explicit TxnLog(TxnLog* parent)
+        : typeVarChanges(nullptr)
+        , typePackChanges(nullptr)
+        , parent(parent)
     {
+        if (parent)
+        {
+            sharedSeen = parent->sharedSeen;
+        }
+        else
+        {
+            sharedSeen = &ownedSeen;
+        }
     }
 
-    explicit TxnLog(const std::vector<std::pair<TypeId, TypeId>>& ownedSeen)
-        : originalSeenSize(ownedSeen.size())
-        , ownedSeen(ownedSeen)
-        , sharedSeen(nullptr)
+    explicit TxnLog(std::vector<std::pair<TypeOrPackId, TypeOrPackId>>* sharedSeen)
+        : typeVarChanges(nullptr)
+        , typePackChanges(nullptr)
+        , sharedSeen(sharedSeen)
     {
-        // This is deprecated!
-        LUAU_ASSERT(!FFlag::LuauShareTxnSeen);
     }
 
     TxnLog(const TxnLog&) = delete;
@@ -40,27 +101,211 @@ struct TxnLog
     TxnLog(TxnLog&&) = default;
     TxnLog& operator=(TxnLog&&) = default;
 
-    void operator()(TypeId a);
-    void operator()(TypePackId a);
-    void operator()(TableTypeVar* a);
-
-    void rollback();
+    // 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();
 
+    // 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);
 
-    bool haveSeen(TypeId lhs, TypeId rhs);
+    // 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;
     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:
-    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;
+    // 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);
 
 public:
-    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
+    // 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;
 };
 
 } // namespace Luau

Analysis/include/Luau/TypeArena.h

@@ -0,0 +1,62 @@
+// 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 expandClassProps = false;
+    bool expandExternTypeProps = false;
 };
 
 void attachTypeData(SourceModule& source, Module& result);

Analysis/include/Luau/TypeCheckLimits.h

@@ -0,0 +1,41 @@
+// 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

@@ -0,0 +1,243 @@
+// 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

@@ -0,0 +1,264 @@
+// 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

@@ -0,0 +1,85 @@
+// 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

@@ -0,0 +1,296 @@
+// 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

@@ -0,0 +1,44 @@
+// 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

@@ -0,0 +1,59 @@
+// 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,15 +1,18 @@
 // 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/Anyification.h"
+#include "Luau/ControlFlow.h"
 #include "Luau/Error.h"
+#include "Luau/Instantiation.h"
 #include "Luau/Module.h"
-#include "Luau/Symbol.h"
-#include "Luau/Parser.h"
+#include "Luau/Predicate.h"
 #include "Luau/Substitution.h"
+#include "Luau/Symbol.h"
 #include "Luau/TxnLog.h"
-#include "Luau/TypePack.h"
-#include "Luau/TypeVar.h"
+#include "Luau/TypeFwd.h"
+#include "Luau/TypeCheckLimits.h"
+#include "Luau/TypeUtils.h"
 #include "Luau/Unifier.h"
 #include "Luau/UnifierSharedState.h"
 
@@ -23,168 +26,207 @@ namespace Luau
 struct Scope;
 struct TypeChecker;
 struct ModuleResolver;
+struct FrontendCancellationToken;
 
 using Name = std::string;
 using ScopePtr = std::shared_ptr<Scope>;
-using OverloadErrorEntry = std::tuple<std::vector<TypeError>, std::vector<TypeId>, const FunctionTypeVar*>;
+
+struct OverloadErrorEntry
+{
+    TxnLog log;
+    ErrorVec errors;
+    std::vector<TypeId> arguments;
+    const FunctionType* fnTy;
+};
 
 bool doesCallError(const AstExprCall* call);
 bool hasBreak(AstStat* node);
 const AstStat* getFallthrough(const AstStat* node);
 
+struct UnifierOptions;
 struct Unifier;
 
-// A substitution which replaces generic types in a given set by free types.
-struct ReplaceGenerics : Substitution
+struct GenericTypeDefinitions
 {
-    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;
+    std::vector<GenericTypeDefinition> genericTypes;
+    std::vector<GenericTypePackDefinition> genericPacks;
 };
 
-// A substitution which replaces generic functions by monomorphic functions
-struct Instantiation : Substitution
+struct HashBoolNamePair
 {
-    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;
+    size_t operator()(const std::pair<bool, Name>& pair) const;
 };
 
-// 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
+// All Types are retained via Environment::types.  All TypeIds
 // within a program are borrowed pointers into this set.
 struct TypeChecker
 {
-    explicit TypeChecker(ModuleResolver* resolver, InternalErrorReporter* iceHandler);
+    explicit TypeChecker(
+        const ScopePtr& globalScope,
+        ModuleResolver* resolver,
+        NotNull<BuiltinTypes> builtinTypes,
+        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;
 
-    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);
+    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 checkBlock(const ScopePtr& scope, const AstStatBlock& statement);
+    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 checkBlockTypeAliases(const ScopePtr& scope, std::vector<AstStat*>& sorted);
 
-    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);
+    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);
     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 = {});
-    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);
+        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);
 
-    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);
+    TypeId checkLValue(const ScopePtr& scope, const AstExpr& 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.
-    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);
+    // 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);
 
-    TypeId checkFunctionName(const ScopePtr& scope, AstExpr& funName);
-    std::pair<TypeId, ScopePtr> checkFunctionSignature(const ScopePtr& scope, int subLevel, const AstExprFunction& expr,
-        std::optional<Location> originalNameLoc, std::optional<TypeId> expectedType);
+    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
+    );
     void checkFunctionBody(const ScopePtr& scope, TypeId type, const AstExprFunction& function);
 
     void checkArgumentList(
-        const ScopePtr& scope, Unifier& state, TypePackId paramPack, TypePackId argPack, const std::vector<Location>& argLocations);
+        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
+    );
 
-    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);
 
-    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 = {});
+    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 = {}
+    );
 
     static std::optional<AstExpr*> matchRequire(const AstExprCall& call);
     TypeId checkRequire(const ScopePtr& scope, const ModuleInfo& moduleInfo, const Location& location);
@@ -193,55 +235,53 @@ struct TypeChecker
     // Reports an error if the type is already some kind of non-table.
     void tablify(TypeId type);
 
-    /** In nonstrict mode, many typevars need to be replaced by any.
+    /** In nonstrict mode, many types need to be replaced by any.
      */
     TypeId anyIfNonstrict(TypeId ty) const;
 
-    /** Attempt to unify the types left and right.  Treat any failures as type errors
-     * in the final typecheck report.
+    /** Attempt to unify the types.
+     * Treat any failures as type errors in the final typecheck report.
      */
-    bool unify(TypeId left, TypeId right, const Location& location);
-    bool unify(TypePackId left, TypePackId right, const Location& location, CountMismatch::Context ctx = CountMismatch::Context::Arg);
+    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
+    );
 
-    /** Attempt to unify the types left and right.
-     * If this fails, and the right type can be instantiated, do so and try unification again.
+    /** Attempt to unify the types.
+     * If this fails, and the subTy type can be instantiated, do so and try unification again.
      */
-    bool unifyWithInstantiationIfNeeded(const ScopePtr& scope, TypeId left, TypeId right, const Location& location);
-    void unifyWithInstantiationIfNeeded(const ScopePtr& scope, TypeId left, TypeId right, Unifier& state);
+    bool unifyWithInstantiationIfNeeded(TypeId subTy, TypeId superTy, const ScopePtr& scope, const Location& location);
+    void unifyWithInstantiationIfNeeded(TypeId subTy, TypeId superTy, const ScopePtr& scope, Unifier& state);
 
-    /** Attempt to unify left with right.
+    /** Attempt to unify.
      * If there are errors, undo everything and return the errors.
      * If there are no errors, commit and return an empty error vector.
      */
-    ErrorVec tryUnify(TypeId left, TypeId right, const Location& location);
-    ErrorVec tryUnify(TypePackId left, TypePackId right, const Location& location);
+    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);
 
     // Test whether the two type vars unify.  Never commits the result.
-    ErrorVec canUnify(TypeId superTy, TypeId subTy, const Location& location);
-    ErrorVec canUnify(TypePackId superTy, TypePackId subTy, const Location& location);
+    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);
 
-    // 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> findMetatableEntry(TypeId type, std::string entry, const Location& location, bool addErrors);
+    std::optional<TypeId> findTablePropertyRespectingMeta(TypeId lhsType, Name name, const Location& location, bool addErrors);
 
     std::optional<TypeId> getIndexTypeFromType(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> getIndexTypeFromTypeImpl(const ScopePtr& scope, TypeId type, const Name& name, const Location& location, bool addErrors);
 
     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
@@ -262,22 +302,26 @@ public:
      *     {method: ({method: (<CYCLE>) -> a}) -> a}
      *
      */
-    TypeId instantiate(const ScopePtr& scope, TypeId ty, Location location);
+    TypeId instantiate(const ScopePtr& scope, TypeId ty, Location location, const TxnLog* log = TxnLog::empty());
 
     // 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, int subLevel = 0);
+    ScopePtr childScope(const ScopePtr& parent, const Location& location);
 
     // Wrapper for merge(l, r, toUnion) but without the lambda junk.
     void merge(RefinementMap& l, const RefinementMap& r);
@@ -296,8 +340,7 @@ private:
     void reportErrorCodeTooComplex(const Location& location);
 
 private:
-    Unifier mkUnifier(const Location& location);
-    Unifier mkUnifier(const std::vector<std::pair<TypeId, TypeId>>& seen, const Location& location);
+    Unifier mkUnifier(const ScopePtr& scope, const Location& location);
 
     // These functions are only safe to call when we are in the process of typechecking a module.
 
@@ -309,22 +352,27 @@ private:
     TypeId singletonType(bool value);
     TypeId singletonType(std::string value);
 
-    // Returns nullopt if the predicate filters down the TypeId to 0 options.
-    std::optional<TypeId> filterMap(TypeId type, TypeIdPredicate predicate);
+    TypeIdPredicate mkTruthyPredicate(bool sense, TypeId emptySetTy);
 
-    TypeId unionOfTypes(TypeId a, TypeId b, const Location& location, bool unifyFreeTypes = true);
+    // 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);
 
     // ex
-    //      TypeId id = addType(FreeTypeVar());
+    //      TypeId id = addType(FreeType());
     template<typename T>
     TypeId addType(const T& tv)
     {
-        return addTV(TypeVar(tv));
+        return addTV(Type(tv));
     }
 
-    TypeId addType(const UnionTypeVar& utv);
-
-    TypeId addTV(TypeVar&& tv);
+    TypeId addTV(Type&& tv);
 
     TypePackId addTypePack(TypePackVar&& tp);
     TypePackId addTypePack(TypePack&& tp);
@@ -336,32 +384,47 @@ 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.
-    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);
+    GenericTypeDefinitions createGenericTypes(
+        const ScopePtr& scope,
+        std::optional<TypeLevel> levelOpt,
+        const AstNode& node,
+        const AstArray<AstGenericType*>& genericNames,
+        const AstArray<AstGenericTypePack*>& genericPackNames,
+        bool useCache = false
+    );
 
 public:
-    ErrorVec resolve(const PredicateVec& predicates, const ScopePtr& scope, bool sense);
+    void 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, 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);
+    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);
 
     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.
@@ -369,27 +432,32 @@ 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 ErrorTypeVars.
+     * not match up, excess TypeIds will be ErrorTypes.
      */
     std::vector<TypeId> unTypePack(const ScopePtr& scope, TypePackId pack, size_t expectedLength, const Location& location);
 
-    TypeArena globalTypes;
+    const ScopePtr& globalScope;
 
     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;
@@ -397,18 +465,39 @@ public:
     const TypeId stringType;
     const TypeId booleanType;
     const TypeId threadType;
+    const TypeId bufferType;
     const TypeId anyType;
-    const TypeId optionalNumberType;
+    const TypeId unknownType;
+    const TypeId neverType;
 
     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(void (*pl)(const std::string& s));
+void setPrintLine(PrintLineProc pl);
 void resetPrintLine();
 
 } // namespace Luau

Analysis/include/Luau/TypeOrPack.h

@@ -0,0 +1,41 @@
+// 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,28 +1,66 @@
 // This file is part of the Luau programming language and is licensed under MIT License; see LICENSE.txt for details
 #pragma once
 
-#include "Luau/TypeVar.h"
+#include "Luau/Common.h"
+#include "Luau/NotNull.h"
+#include "Luau/Polarity.h"
+#include "Luau/TypeFwd.h"
 #include "Luau/Unifiable.h"
 #include "Luau/Variant.h"
 
 #include <optional>
 #include <set>
+#include <vector>
 
 namespace Luau
 {
 
 struct TypeArena;
+struct TypePackFunction;
+struct TxnLog;
 
 struct TypePack;
 struct VariadicTypePack;
+struct BlockedTypePack;
+struct TypeFunctionInstanceTypePack;
 
-struct TypePackVar;
+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;
+};
 
-using TypePackId = const TypePackVar*;
-using FreeTypePack = Unifiable::Free;
 using BoundTypePack = Unifiable::Bound<TypePackId>;
-using GenericTypePack = Unifiable::Generic;
-using TypePackVariant = Unifiable::Variant<TypePackId, TypePack, VariadicTypePack>;
+using ErrorTypePack = Unifiable::Error<TypePackId>;
+
+using TypePackVariant =
+    Unifiable::Variant<TypePackId, FreeTypePack, GenericTypePack, TypePack, VariadicTypePack, BlockedTypePack, TypeFunctionInstanceTypePack>;
 
 /* 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
@@ -38,29 +76,62 @@ 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& ty);
-    explicit TypePackVar(TypePackVariant&& ty);
-    TypePackVar(TypePackVariant&& ty, bool persistent);
+    explicit TypePackVar(const TypePackVariant& tp);
+    explicit TypePackVar(TypePackVariant&& tp);
+    TypePackVar(TypePackVariant&& tp, bool persistent);
+
     bool operator==(const TypePackVar& rhs) const;
+
     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 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.
+    // Pointer to the type arena that allocated this pack.
     TypeArena* owningArena = nullptr;
 };
 
 /* Walk the set of TypeIds in a TypePack.
  *
- * Like TypeVars, individual TypePacks can be free, generic, or any.
+ * Like Types, 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
@@ -84,6 +155,7 @@ struct TypePackIterator
 
     TypePackIterator() = default;
     explicit TypePackIterator(TypePackId tp);
+    TypePackIterator(TypePackId tp, const TxnLog* log);
 
     TypePackIterator& operator++();
     TypePackIterator operator++(int);
@@ -102,23 +174,30 @@ 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);
 
-using SeenSet = std::set<std::pair<void*, void*>>;
+TypePackId getTail(TypePackId tp);
+
+using SeenSet = std::set<std::pair<const void*, const 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);
-bool finite(TypePackId tp);
-size_t size(const TypePack& tp);
-std::optional<TypeId> first(TypePackId tp);
+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);
 
 TypePackVar* asMutable(TypePackId tp);
 TypePack* asMutable(const TypePack* tp);
@@ -150,5 +229,30 @@ 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

@@ -0,0 +1,35 @@
+// 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

@@ -0,0 +1,252 @@
+// 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,7 +3,8 @@
 
 #include "Luau/Error.h"
 #include "Luau/Location.h"
-#include "Luau/TypeVar.h"
+#include "Luau/Type.h"
+#include "Luau/TypePack.h"
 
 #include <memory>
 #include <optional>
@@ -11,9 +12,283 @@
 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<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);
+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);
 
 } // namespace Luau

Analysis/include/Luau/TypeVar.h

@@ -1,618 +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/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(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;
-    TypeId makeStringMetatable();
-};
-
-extern SingletonTypes singletonTypes;
-
-void persist(TypeId ty);
-void persist(TypePackId tp);
-
-struct ToDotOptions
-{
-    bool showPointers = true;        // Show pointer value in the node label
-    bool duplicatePrimitives = true; // Display primitive types and 'any' as separate nodes
-};
-
-std::string toDot(TypeId ty, const ToDotOptions& opts);
-std::string toDot(TypePackId tp, const ToDotOptions& opts);
-
-std::string toDot(TypeId ty);
-std::string toDot(TypePackId tp);
-
-void dumpDot(TypeId ty);
-void dumpDot(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);
-
-bool hasGeneric(TypeId ty);
-bool hasGeneric(TypePackId tp);
-
-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);
+void pagedDeallocate(void* ptr, size_t size);
 void pagedFreeze(void* ptr, size_t size);
 void pagedUnfreeze(void* ptr, size_t size);
 
@@ -20,9 +20,15 @@ class TypedAllocator
 public:
     TypedAllocator()
     {
-        appendBlock();
+        currentBlockSize = kBlockSize;
     }
 
+    TypedAllocator(const TypedAllocator&) = delete;
+    TypedAllocator& operator=(const TypedAllocator&) = delete;
+
+    TypedAllocator(TypedAllocator&&) = default;
+    TypedAllocator& operator=(TypedAllocator&&) = default;
+
     ~TypedAllocator()
     {
         if (frozen)
@@ -59,12 +65,12 @@ public:
 
     bool empty() const
     {
-        return stuff.size() == 1 && currentBlockSize == 0;
+        return stuff.empty();
     }
 
     size_t size() const
     {
-        return kBlockSize * (stuff.size() - 1) + currentBlockSize;
+        return stuff.empty() ? 0 : kBlockSize * (stuff.size() - 1) + currentBlockSize;
     }
 
     void clear()
@@ -72,7 +78,8 @@ public:
         if (frozen)
             unfreeze();
         free();
-        appendBlock();
+
+        currentBlockSize = kBlockSize;
     }
 
     void freeze()
@@ -106,7 +113,7 @@ private:
             for (size_t i = 0; i < blockSize; ++i)
                 block[i].~T();
 
-            pagedDeallocate(block);
+            pagedDeallocate(block, kBlockSizeBytes);
         }
 
         stuff.clear();

Analysis/include/Luau/Unifiable.h

@@ -3,13 +3,16 @@
 
 #include "Luau/Variant.h"
 
+#include <optional>
 #include <string>
 
 namespace Luau
 {
 
+struct Scope;
+
 /**
- * The 'level' of a TypeVar is an indirect way to talk about the scope that it 'belongs' too.
+ * The 'level' of a Type 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
@@ -24,7 +27,7 @@ struct TypeLevel
     int level = 0;
     int subLevel = 0;
 
-    // Returns true if the typelevel "this" is "bigger" than rhs
+    // Returns true if the level of "this" belongs to an equal or larger scope than that of rhs
     bool subsumes(const TypeLevel& rhs) const
     {
         if (level < rhs.level)
@@ -38,6 +41,15 @@ struct TypeLevel
         return false;
     }
 
+    // Returns true if the level of "this" belongs to a larger (not equal) scope than that of rhs
+    bool subsumesStrict(const TypeLevel& rhs) const
+    {
+        if (level == rhs.level && subLevel == rhs.subLevel)
+            return false;
+        else
+            return subsumes(rhs);
+    }
+
     TypeLevel incr() const
     {
         TypeLevel result;
@@ -47,6 +59,14 @@ 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))
@@ -55,25 +75,14 @@ inline TypeLevel min(const TypeLevel& a, const TypeLevel& b)
         return b;
 }
 
-namespace Unifiable
+} // namespace Luau
+
+namespace Luau::Unifiable
 {
 
 using Name = std::string;
 
-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;
-};
+int freshIndex();
 
 template<typename Id>
 struct Bound
@@ -86,37 +95,29 @@ struct Bound
     Id boundTo;
 };
 
-struct Generic
-{
-    // 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;
-
-private:
-    static int nextIndex;
-};
-
+template<typename Id>
 struct Error
 {
-    // This constructor has to be public, since it's used in TypeVar and TypePack,
+    // This constructor has to be public, since it's used in Type and TypePack,
     // but shouldn't be called directly. Please use errorRecoveryType() instead.
-    Error();
+    explicit Error();
+
+    explicit Error(Id synthetic)
+        : synthetic{synthetic}
+    {
+    }
 
     int index;
 
+    // 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;
 };
 
 template<typename Id, typename... Value>
-using Variant = Variant<Free, Bound<Id>, Generic, Error, Value...>;
+using Variant = Luau::Variant<Bound<Id>, Error<Id>, Value...>;
 
-} // namespace Unifiable
-} // namespace Luau
+} // namespace Luau::Unifiable

Analysis/include/Luau/Unifier.h

@@ -3,10 +3,13 @@
 
 #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/TypeInfer.h"
-#include "Luau/Module.h" // FIXME: For TypeArena.  It merits breaking out into its own header.
+#include "Luau/TypeArena.h"
 #include "Luau/UnifierSharedState.h"
+#include "Luau/Normalize.h"
 
 #include <unordered_set>
 
@@ -19,87 +22,165 @@ enum Variance
     Invariant
 };
 
-struct UnifierCounters
+// A substitution which replaces singleton types by their wider types
+struct Widen : Substitution
 {
-    int recursionCount = 0;
-    int iterationCount = 0;
+    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;
-    Mode mode;
-    ScopePtr globalScope; // sigh.  Needed solely to get at string's metatable.
+    NotNull<BuiltinTypes> builtinTypes;
+    NotNull<Normalizer> normalizer;
 
+    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;
 
-    UnifierCounters* counters;
-    UnifierCounters countersData;
-
-    std::shared_ptr<UnifierCounters> counters_DEPRECATED;
+    // If true, generics act as free types when unifying.
+    bool hideousFixMeGenericsAreActuallyFree = false;
 
     UnifierSharedState& sharedState;
 
-    Unifier(TypeArena* types, Mode mode, ScopePtr globalScope, const Location& location, Variance variance, UnifierSharedState& sharedState);
-    Unifier(TypeArena* types, Mode mode, ScopePtr globalScope, const std::vector<std::pair<TypeId, TypeId>>& ownedSeen, const Location& location,
-        Variance variance, UnifierSharedState& sharedState, const std::shared_ptr<UnifierCounters>& counters_DEPRECATED = nullptr,
-        UnifierCounters* counters = nullptr);
-    Unifier(TypeArena* types, Mode mode, ScopePtr globalScope, std::vector<std::pair<TypeId, TypeId>>* sharedSeen, const Location& location,
-        Variance variance, UnifierSharedState& sharedState, const std::shared_ptr<UnifierCounters>& counters_DEPRECATED = nullptr,
-        UnifierCounters* counters = nullptr);
+    // 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);
 
     // Test whether the two type vars unify.  Never commits the result.
-    ErrorVec canUnify(TypeId superTy, TypeId subTy);
-    ErrorVec canUnify(TypePackId superTy, TypePackId subTy, bool isFunctionCall = false);
+    ErrorVec canUnify(TypeId subTy, TypeId superTy);
+    ErrorVec canUnify(TypePackId subTy, TypePackId superTy, bool isFunctionCall = false);
 
-    /** Attempt to unify left with right.
+    /** Attempt to unify.
      * 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 superTy, TypeId subTy, bool isFunctionCall = false, bool isIntersection = false);
+    void tryUnify(
+        TypeId subTy,
+        TypeId superTy,
+        bool isFunctionCall = false,
+        bool isIntersection = false,
+        const LiteralProperties* aliasableMap = nullptr
+    );
 
 private:
-    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);
+    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);
+
     TypeId deeplyOptional(TypeId ty, std::unordered_map<TypeId, TypeId> seen = {});
-    void cacheResult(TypeId superTy, TypeId subTy);
+
+    bool canCacheResult(TypeId subTy, TypeId superTy);
+    void cacheResult(TypeId subTy, TypeId superTy, size_t prevErrorCount);
 
 public:
-    void tryUnify(TypePackId superTy, TypePackId subTy, bool isFunctionCall = false);
+    void tryUnify(TypePackId subTy, TypePackId superTy, bool isFunctionCall = false);
 
 private:
-    void tryUnify_(TypePackId superTy, TypePackId subTy, bool isFunctionCall = false);
-    void tryUnifyVariadics(TypePackId superTy, TypePackId subTy, bool reversed, int subOffset = 0);
+    void tryUnify_(TypePackId subTy, TypePackId superTy, bool isFunctionCall = false);
+    void tryUnifyVariadics(TypePackId subTy, TypePackId superTy, bool reversed, int subOffset = 0);
 
-    void tryUnifyWithAny(TypeId any, TypeId ty);
-    void tryUnifyWithAny(TypePackId any, TypePackId ty);
+    void tryUnifyWithAny(TypeId subTy, TypeId anyTy);
+    void tryUnifyWithAny(TypePackId subTy, TypePackId anyTp);
 
     std::optional<TypeId> findTablePropertyRespectingMeta(TypeId lhsType, Name name);
 
-public:
-    // Report an "infinite type error" if the type "needle" already occurs within "haystack"
-    void occursCheck(TypeId needle, TypeId haystack);
-    void occursCheck(std::unordered_set<TypeId>& seen_DEPRECATED, DenseHashSet<TypeId>& seen, TypeId needle, TypeId haystack);
-    void occursCheck(TypePackId needle, TypePackId haystack);
-    void occursCheck(std::unordered_set<TypePackId>& seen_DEPRECATED, DenseHashSet<TypePackId>& seen, TypePackId needle, TypePackId haystack);
+    TxnLog combineLogsIntoUnion(std::vector<TxnLog> logs);
 
-    Unifier makeChildUnifier();
+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);
+
+    std::unique_ptr<Unifier> makeChildUnifier();
+
+    void reportError(TypeError err);
+    LUAU_NOINLINE void reportError(Location location, TypeErrorData data);
 
 private:
-    bool isNonstrictMode() const;
+    TypeMismatch::Context mismatchContext();
 
     void checkChildUnifierTypeMismatch(const ErrorVec& innerErrors, TypeId wantedType, TypeId givenType);
     void checkChildUnifierTypeMismatch(const ErrorVec& innerErrors, const std::string& prop, TypeId wantedType, TypeId givenType);
@@ -107,9 +188,12 @@ private:
     [[noreturn]] void ice(const std::string& message, const Location& location);
     [[noreturn]] void ice(const std::string& message);
 
-    // Remove with FFlagLuauCacheUnifyTableResults
-    DenseHashSet<TypeId> tempSeenTy_DEPRECATED{nullptr};
-    DenseHashSet<TypePackId> tempSeenTp_DEPRECATED{nullptr};
+    // Available after regular type pack unification errors
+    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

@@ -0,0 +1,127 @@
+// 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/TypeVar.h"
-#include "Luau/TypePack.h"
+#include "Luau/Error.h"
+#include "Luau/TypeFwd.h"
 
 #include <utility>
 
@@ -24,6 +24,14 @@ struct TypeIdPairHash
     }
 };
 
+struct UnifierCounters
+{
+    int recursionCount = 0;
+    int recursionLimit = 0;
+    int iterationCount = 0;
+    int iterationLimit = 0;
+};
+
 struct UnifierSharedState
 {
     UnifierSharedState(InternalErrorReporter* iceHandler)
@@ -33,12 +41,34 @@ 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/VisitType.h

@@ -0,0 +1,531 @@
+// 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

@@ -1,235 +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/TypeVar.h"
-#include "Luau/TypePack.h"
-
-LUAU_FASTFLAG(LuauCacheUnifyTableResults)
-
-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 (FFlag::LuauCacheUnifyTableResults && 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

@@ -0,0 +1,101 @@
+// 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

@@ -0,0 +1,62 @@
+// 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,19 +4,122 @@
 #include "Luau/Module.h"
 #include "Luau/Scope.h"
 #include "Luau/TypeInfer.h"
-#include "Luau/TypeVar.h"
+#include "Luau/Type.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;
@@ -49,6 +152,16 @@ 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));
@@ -67,47 +180,97 @@ 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
 
-std::vector<AstNode*> findAstAncestryOfPosition(const SourceModule& source, Position pos)
+FindFullAncestry::FindFullAncestry(Position pos, Position documentEnd, bool includeTypes)
+    : pos(pos)
+    , documentEnd(documentEnd)
+    , includeTypes(includeTypes)
 {
-    FindFullAncestry finder(pos);
-    source.root->visit(&finder);
-    return std::move(finder.nodes);
+}
+
+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;
 }
 
 AstNode* findNodeAtPosition(const SourceModule& source, Position pos)
 {
-    const Position end = source.root->location.end;
-    if (pos < source.root->location.begin)
-        return source.root;
+    return findNodeAtPosition(source.root, pos);
+}
+
+AstNode* findNodeAtPosition(AstStatBlock* root, Position pos)
+{
+    const Position end = root->location.end;
+    if (pos < root->location.begin)
+        return root;
 
     if (pos > end)
         pos = end;
 
     FindNode findNode{pos, end};
-    findNode.visit(source.root);
+    findNode.visit(root);
     return findNode.best;
 }
 
@@ -122,7 +285,8 @@ AstExpr* findExprAtPosition(const SourceModule& source, Position pos)
 
 ScopePtr findScopeAtPosition(const Module& module, Position pos)
 {
-    LUAU_ASSERT(!module.scopes.empty());
+    if (module.scopes.empty())
+        return nullptr;
 
     Location scopeLocation = module.scopes.front().first;
     ScopePtr scope = module.scopes.front().second;
@@ -164,10 +328,20 @@ 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;
 }
 
@@ -186,14 +360,13 @@ 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;
@@ -306,6 +479,71 @@ 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);
@@ -314,33 +552,7 @@ 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))
-    {
-        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;
-    }
+        return checkOverloadedDocumentationSymbol(module, binding->typeId, parentExpr, binding->documentationSymbol);
 
     if (targetExpr)
     {
@@ -349,18 +561,44 @@ std::optional<DocumentationSymbol> getDocumentationSymbolAtPosition(const Source
             if (auto it = module.astTypes.find(indexName->expr))
             {
                 TypeId parentTy = follow(*it);
-                if (const TableTypeVar* ttv = get<TableTypeVar>(parentTy))
+                if (const TableType* ttv = get<TableType>(parentTy))
                 {
                     if (auto propIt = ttv->props.find(indexName->index.value); propIt != ttv->props.end())
                     {
-                        return propIt->second.documentationSymbol;
+                        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);
                     }
                 }
-                else if (const ClassTypeVar* ctv = get<ClassTypeVar>(parentTy))
+                else if (const ExternType* etv = get<ExternType>(parentTy))
                 {
-                    if (auto propIt = ctv->props.find(indexName->index.value); propIt != ctv->props.end())
+                    while (etv)
                     {
-                        return propIt->second.documentationSymbol;
+                        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;
                     }
                 }
             }

Analysis/src/AutocompleteCore.h

@@ -0,0 +1,27 @@
+// 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

Analysis/src/Clone.cpp

@@ -0,0 +1,748 @@
+// This file is part of the Luau programming language and is licensed under MIT License; see LICENSE.txt for details
+#include "Luau/Clone.h"
+
+#include "Luau/Common.h"
+#include "Luau/NotNull.h"
+#include "Luau/Type.h"
+#include "Luau/TypePack.h"
+#include "Luau/Unifiable.h"
+#include "Luau/VisitType.h"
+
+LUAU_FASTFLAG(LuauSolverV2)
+
+// For each `Luau::clone` call, we will clone only up to N amount of types _and_ packs, as controlled by this limit.
+LUAU_FASTINTVARIABLE(LuauTypeCloneIterationLimit, 100'000)
+LUAU_FASTFLAGVARIABLE(LuauClonedTableAndFunctionTypesMustHaveScopes)
+LUAU_FASTFLAGVARIABLE(LuauDoNotClonePersistentBindings)
+LUAU_FASTFLAG(LuauIncrementalAutocompleteDemandBasedCloning)
+namespace Luau
+{
+
+namespace
+{
+
+using Kind = Variant<TypeId, TypePackId>;
+
+template<typename T>
+const T* get(const Kind& kind)
+{
+    return get_if<T>(&kind);
+}
+
+class TypeCloner
+{
+
+protected:
+    NotNull<TypeArena> arena;
+    NotNull<BuiltinTypes> builtinTypes;
+
+    // A queue of kinds where we cloned it, but whose interior types hasn't
+    // been updated to point to new clones. Once all of its interior types
+    // has been updated, it gets removed from the queue.
+    std::vector<Kind> queue;
+
+    NotNull<SeenTypes> types;
+    NotNull<SeenTypePacks> packs;
+
+    TypeId forceTy = nullptr;
+    TypePackId forceTp = nullptr;
+
+    int steps = 0;
+
+public:
+    TypeCloner(
+        NotNull<TypeArena> arena,
+        NotNull<BuiltinTypes> builtinTypes,
+        NotNull<SeenTypes> types,
+        NotNull<SeenTypePacks> packs,
+        TypeId forceTy,
+        TypePackId forceTp
+    )
+        : arena(arena)
+        , builtinTypes(builtinTypes)
+        , types(types)
+        , packs(packs)
+        , forceTy(forceTy)
+        , forceTp(forceTp)
+    {
+    }
+
+    virtual ~TypeCloner() = default;
+
+    TypeId clone(TypeId ty)
+    {
+        shallowClone(ty);
+        run();
+
+        if (hasExceededIterationLimit())
+        {
+            TypeId error = builtinTypes->errorRecoveryType();
+            (*types)[ty] = error;
+            return error;
+        }
+
+        return find(ty).value_or(builtinTypes->errorRecoveryType());
+    }
+
+    TypePackId clone(TypePackId tp)
+    {
+        shallowClone(tp);
+        run();
+
+        if (hasExceededIterationLimit())
+        {
+            TypePackId error = builtinTypes->errorRecoveryTypePack();
+            (*packs)[tp] = error;
+            return error;
+        }
+
+        return find(tp).value_or(builtinTypes->errorRecoveryTypePack());
+    }
+
+private:
+    bool hasExceededIterationLimit() const
+    {
+        if (FInt::LuauTypeCloneIterationLimit == 0)
+            return false;
+
+        return steps + queue.size() >= size_t(FInt::LuauTypeCloneIterationLimit);
+    }
+
+    void run()
+    {
+        while (!queue.empty())
+        {
+            ++steps;
+
+            if (hasExceededIterationLimit())
+                break;
+
+            Kind kind = queue.back();
+            queue.pop_back();
+
+            if (find(kind))
+                continue;
+
+            cloneChildren(kind);
+        }
+    }
+
+protected:
+    std::optional<TypeId> find(TypeId ty) const
+    {
+        ty = follow(ty, FollowOption::DisableLazyTypeThunks);
+        if (auto it = types->find(ty); it != types->end())
+            return it->second;
+        else if (ty->persistent && ty != forceTy)
+            return ty;
+        return std::nullopt;
+    }
+
+    std::optional<TypePackId> find(TypePackId tp) const
+    {
+        tp = follow(tp);
+        if (auto it = packs->find(tp); it != packs->end())
+            return it->second;
+        else if (tp->persistent && tp != forceTp)
+            return tp;
+        return std::nullopt;
+    }
+
+    std::optional<Kind> find(Kind kind) const
+    {
+        if (auto ty = get<TypeId>(kind))
+            return find(*ty);
+        else if (auto tp = get<TypePackId>(kind))
+            return find(*tp);
+        else
+        {
+            LUAU_ASSERT(!"Unknown kind?");
+            return std::nullopt;
+        }
+    }
+
+public:
+    virtual TypeId shallowClone(TypeId ty)
+    {
+        // We want to [`Luau::follow`] but without forcing the expansion of [`LazyType`]s.
+        ty = follow(ty, FollowOption::DisableLazyTypeThunks);
+
+        if (auto clone = find(ty))
+            return *clone;
+        else if (ty->persistent && ty != forceTy)
+            return ty;
+
+        TypeId target = arena->addType(ty->ty);
+        asMutable(target)->documentationSymbol = ty->documentationSymbol;
+
+        if (auto generic = getMutable<GenericType>(target))
+            generic->scope = nullptr;
+        else if (auto free = getMutable<FreeType>(target))
+            free->scope = nullptr;
+        else if (auto table = getMutable<TableType>(target))
+            table->scope = nullptr;
+
+        (*types)[ty] = target;
+        queue.push_back(target);
+        return target;
+    }
+
+    virtual TypePackId shallowClone(TypePackId tp)
+    {
+        tp = follow(tp);
+
+        if (auto clone = find(tp))
+            return *clone;
+        else if (tp->persistent && tp != forceTp)
+            return tp;
+
+        TypePackId target = arena->addTypePack(tp->ty);
+
+        if (auto generic = getMutable<GenericTypePack>(target))
+            generic->scope = nullptr;
+        else if (auto free = getMutable<FreeTypePack>(target))
+            free->scope = nullptr;
+
+        (*packs)[tp] = target;
+        queue.push_back(target);
+        return target;
+    }
+
+private:
+    Property shallowClone(const Property& p)
+    {
+        if (FFlag::LuauSolverV2)
+        {
+            std::optional<TypeId> cloneReadTy;
+            if (auto ty = p.readTy)
+                cloneReadTy = shallowClone(*ty);
+
+            std::optional<TypeId> cloneWriteTy;
+            if (auto ty = p.writeTy)
+                cloneWriteTy = shallowClone(*ty);
+
+            Property cloned = Property::create(cloneReadTy, cloneWriteTy);
+            cloned.deprecated = p.deprecated;
+            cloned.deprecatedSuggestion = p.deprecatedSuggestion;
+            cloned.location = p.location;
+            cloned.tags = p.tags;
+            cloned.documentationSymbol = p.documentationSymbol;
+            cloned.typeLocation = p.typeLocation;
+            return cloned;
+        }
+        else
+        {
+            return Property{
+                shallowClone(p.type()),
+                p.deprecated,
+                p.deprecatedSuggestion,
+                p.location,
+                p.tags,
+                p.documentationSymbol,
+                p.typeLocation,
+            };
+        }
+    }
+
+    void cloneChildren(TypeId ty)
+    {
+        return visit(
+            [&](auto&& t)
+            {
+                return cloneChildren(&t);
+            },
+            asMutable(ty)->ty
+        );
+    }
+
+    void cloneChildren(TypePackId tp)
+    {
+        return visit(
+            [&](auto&& t)
+            {
+                return cloneChildren(&t);
+            },
+            asMutable(tp)->ty
+        );
+    }
+
+    void cloneChildren(Kind kind)
+    {
+        if (auto ty = get<TypeId>(kind))
+            return cloneChildren(*ty);
+        else if (auto tp = get<TypePackId>(kind))
+            return cloneChildren(*tp);
+        else
+            LUAU_ASSERT(!"Item holds neither TypeId nor TypePackId when enqueuing its children?");
+    }
+
+    void cloneChildren(ErrorType* t)
+    {
+        // noop.
+    }
+
+    void cloneChildren(BoundType* t)
+    {
+        t->boundTo = shallowClone(t->boundTo);
+    }
+
+    void cloneChildren(FreeType* t)
+    {
+        if (t->lowerBound)
+            t->lowerBound = shallowClone(t->lowerBound);
+        if (t->upperBound)
+            t->upperBound = shallowClone(t->upperBound);
+    }
+
+    void cloneChildren(GenericType* t)
+    {
+        // TOOD: clone upper bounds.
+    }
+
+    void cloneChildren(PrimitiveType* t)
+    {
+        // noop.
+    }
+
+    void cloneChildren(BlockedType* t)
+    {
+        // TODO: In the new solver, we should ice.
+    }
+
+    void cloneChildren(PendingExpansionType* t)
+    {
+        // TODO: In the new solver, we should ice.
+    }
+
+    void cloneChildren(SingletonType* t)
+    {
+        // noop.
+    }
+
+    void cloneChildren(FunctionType* t)
+    {
+        for (TypeId& g : t->generics)
+            g = shallowClone(g);
+
+        for (TypePackId& gp : t->genericPacks)
+            gp = shallowClone(gp);
+
+        t->argTypes = shallowClone(t->argTypes);
+        t->retTypes = shallowClone(t->retTypes);
+    }
+
+    void cloneChildren(TableType* t)
+    {
+        if (t->indexer)
+        {
+            t->indexer->indexType = shallowClone(t->indexer->indexType);
+            t->indexer->indexResultType = shallowClone(t->indexer->indexResultType);
+        }
+
+        for (auto& [_, p] : t->props)
+            p = shallowClone(p);
+
+        for (TypeId& ty : t->instantiatedTypeParams)
+            ty = shallowClone(ty);
+
+        for (TypePackId& tp : t->instantiatedTypePackParams)
+            tp = shallowClone(tp);
+    }
+
+    void cloneChildren(MetatableType* t)
+    {
+        t->table = shallowClone(t->table);
+        t->metatable = shallowClone(t->metatable);
+    }
+
+    void cloneChildren(ExternType* t)
+    {
+        for (auto& [_, p] : t->props)
+            p = shallowClone(p);
+
+        if (t->parent)
+            t->parent = shallowClone(*t->parent);
+
+        if (t->metatable)
+            t->metatable = shallowClone(*t->metatable);
+
+        if (t->indexer)
+        {
+            t->indexer->indexType = shallowClone(t->indexer->indexType);
+            t->indexer->indexResultType = shallowClone(t->indexer->indexResultType);
+        }
+    }
+
+    void cloneChildren(AnyType* t)
+    {
+        // noop.
+    }
+
+    void cloneChildren(NoRefineType* t)
+    {
+        // noop.
+    }
+
+    void cloneChildren(UnionType* t)
+    {
+        for (TypeId& ty : t->options)
+            ty = shallowClone(ty);
+    }
+
+    void cloneChildren(IntersectionType* t)
+    {
+        for (TypeId& ty : t->parts)
+            ty = shallowClone(ty);
+    }
+
+    virtual void cloneChildren(LazyType* t)
+    {
+        if (auto unwrapped = t->unwrapped.load())
+            t->unwrapped.store(shallowClone(unwrapped));
+    }
+
+    void cloneChildren(UnknownType* t)
+    {
+        // noop.
+    }
+
+    void cloneChildren(NeverType* t)
+    {
+        // noop.
+    }
+
+    void cloneChildren(NegationType* t)
+    {
+        t->ty = shallowClone(t->ty);
+    }
+
+    void cloneChildren(TypeFunctionInstanceType* t)
+    {
+        for (TypeId& ty : t->typeArguments)
+            ty = shallowClone(ty);
+
+        for (TypePackId& tp : t->packArguments)
+            tp = shallowClone(tp);
+    }
+
+    void cloneChildren(FreeTypePack* t)
+    {
+        // TODO: clone lower and upper bounds.
+        // TODO: In the new solver, we should ice.
+    }
+
+    void cloneChildren(GenericTypePack* t)
+    {
+        // TOOD: clone upper bounds.
+    }
+
+    void cloneChildren(BlockedTypePack* t)
+    {
+        // TODO: In the new solver, we should ice.
+    }
+
+    void cloneChildren(BoundTypePack* t)
+    {
+        t->boundTo = shallowClone(t->boundTo);
+    }
+
+    void cloneChildren(ErrorTypePack* t)
+    {
+        // noop.
+    }
+
+    void cloneChildren(VariadicTypePack* t)
+    {
+        t->ty = shallowClone(t->ty);
+    }
+
+    void cloneChildren(TypePack* t)
+    {
+        for (TypeId& ty : t->head)
+            ty = shallowClone(ty);
+
+        if (t->tail)
+            t->tail = shallowClone(*t->tail);
+    }
+
+    void cloneChildren(TypeFunctionInstanceTypePack* t)
+    {
+        for (TypeId& ty : t->typeArguments)
+            ty = shallowClone(ty);
+
+        for (TypePackId& tp : t->packArguments)
+            tp = shallowClone(tp);
+    }
+};
+
+class FragmentAutocompleteTypeCloner final : public TypeCloner
+{
+    Scope* replacementForNullScope = nullptr;
+
+public:
+    FragmentAutocompleteTypeCloner(
+        NotNull<TypeArena> arena,
+        NotNull<BuiltinTypes> builtinTypes,
+        NotNull<SeenTypes> types,
+        NotNull<SeenTypePacks> packs,
+        TypeId forceTy,
+        TypePackId forceTp,
+        Scope* replacementForNullScope
+    )
+        : TypeCloner(arena, builtinTypes, types, packs, forceTy, forceTp)
+        , replacementForNullScope(replacementForNullScope)
+    {
+        LUAU_ASSERT(replacementForNullScope);
+    }
+
+    TypeId shallowClone(TypeId ty) override
+    {
+        // We want to [`Luau::follow`] but without forcing the expansion of [`LazyType`]s.
+        ty = follow(ty, FollowOption::DisableLazyTypeThunks);
+
+        if (auto clone = find(ty))
+            return *clone;
+        else if (ty->persistent && ty != forceTy)
+            return ty;
+
+        TypeId target = arena->addType(ty->ty);
+        asMutable(target)->documentationSymbol = ty->documentationSymbol;
+
+        if (auto generic = getMutable<GenericType>(target))
+            generic->scope = nullptr;
+        else if (auto free = getMutable<FreeType>(target))
+        {
+            free->scope = replacementForNullScope;
+        }
+        else if (auto tt = getMutable<TableType>(target))
+        {
+            if (FFlag::LuauClonedTableAndFunctionTypesMustHaveScopes)
+                tt->scope = replacementForNullScope;
+        }
+
+        (*types)[ty] = target;
+        queue.emplace_back(target);
+        return target;
+    }
+
+    TypePackId shallowClone(TypePackId tp) override
+    {
+        tp = follow(tp);
+
+        if (auto clone = find(tp))
+            return *clone;
+        else if (tp->persistent && tp != forceTp)
+            return tp;
+
+        TypePackId target = arena->addTypePack(tp->ty);
+
+        if (auto generic = getMutable<GenericTypePack>(target))
+            generic->scope = nullptr;
+        else if (auto free = getMutable<FreeTypePack>(target))
+            free->scope = replacementForNullScope;
+
+        (*packs)[tp] = target;
+        queue.emplace_back(target);
+        return target;
+    }
+
+    void cloneChildren(LazyType* t) override
+    {
+        // Do not clone lazy types
+        if (!FFlag::LuauIncrementalAutocompleteDemandBasedCloning)
+        {
+            if (auto unwrapped = t->unwrapped.load())
+                t->unwrapped.store(shallowClone(unwrapped));
+        }
+    }
+};
+
+
+} // namespace
+
+TypePackId shallowClone(TypePackId tp, TypeArena& dest, CloneState& cloneState, bool ignorePersistent)
+{
+    if (tp->persistent && !ignorePersistent)
+        return tp;
+
+    TypeCloner cloner{
+        NotNull{&dest},
+        cloneState.builtinTypes,
+        NotNull{&cloneState.seenTypes},
+        NotNull{&cloneState.seenTypePacks},
+        nullptr,
+        ignorePersistent ? tp : nullptr
+    };
+
+    return cloner.shallowClone(tp);
+}
+
+TypeId shallowClone(TypeId typeId, TypeArena& dest, CloneState& cloneState, bool ignorePersistent)
+{
+    if (typeId->persistent && !ignorePersistent)
+        return typeId;
+
+    TypeCloner cloner{
+        NotNull{&dest},
+        cloneState.builtinTypes,
+        NotNull{&cloneState.seenTypes},
+        NotNull{&cloneState.seenTypePacks},
+        ignorePersistent ? typeId : nullptr,
+        nullptr
+    };
+
+    return cloner.shallowClone(typeId);
+}
+
+TypePackId clone(TypePackId tp, TypeArena& dest, CloneState& cloneState)
+{
+    if (tp->persistent)
+        return tp;
+
+    TypeCloner cloner{NotNull{&dest}, cloneState.builtinTypes, NotNull{&cloneState.seenTypes}, NotNull{&cloneState.seenTypePacks}, nullptr, nullptr};
+    return cloner.clone(tp);
+}
+
+TypeId clone(TypeId typeId, TypeArena& dest, CloneState& cloneState)
+{
+    if (typeId->persistent)
+        return typeId;
+
+    TypeCloner cloner{NotNull{&dest}, cloneState.builtinTypes, NotNull{&cloneState.seenTypes}, NotNull{&cloneState.seenTypePacks}, nullptr, nullptr};
+    return cloner.clone(typeId);
+}
+
+TypeFun clone(const TypeFun& typeFun, TypeArena& dest, CloneState& cloneState)
+{
+    TypeCloner cloner{NotNull{&dest}, cloneState.builtinTypes, NotNull{&cloneState.seenTypes}, NotNull{&cloneState.seenTypePacks}, nullptr, nullptr};
+
+    TypeFun copy = typeFun;
+
+    for (auto& param : copy.typeParams)
+    {
+        param.ty = cloner.clone(param.ty);
+
+        if (param.defaultValue)
+            param.defaultValue = cloner.clone(*param.defaultValue);
+    }
+
+    for (auto& param : copy.typePackParams)
+    {
+        param.tp = cloner.clone(param.tp);
+
+        if (param.defaultValue)
+            param.defaultValue = cloner.clone(*param.defaultValue);
+    }
+
+    copy.type = cloner.clone(copy.type);
+
+    return copy;
+}
+
+Binding clone(const Binding& binding, TypeArena& dest, CloneState& cloneState)
+{
+    TypeCloner cloner{NotNull{&dest}, cloneState.builtinTypes, NotNull{&cloneState.seenTypes}, NotNull{&cloneState.seenTypePacks}, nullptr, nullptr};
+
+    Binding b;
+    b.deprecated = binding.deprecated;
+    b.deprecatedSuggestion = binding.deprecatedSuggestion;
+    b.documentationSymbol = binding.documentationSymbol;
+    b.location = binding.location;
+    b.typeId = cloner.clone(binding.typeId);
+
+    return b;
+}
+
+TypePackId cloneIncremental(TypePackId tp, TypeArena& dest, CloneState& cloneState, Scope* freshScopeForFreeTypes)
+{
+    if (tp->persistent)
+        return tp;
+
+    FragmentAutocompleteTypeCloner cloner{
+        NotNull{&dest},
+        cloneState.builtinTypes,
+        NotNull{&cloneState.seenTypes},
+        NotNull{&cloneState.seenTypePacks},
+        nullptr,
+        nullptr,
+        freshScopeForFreeTypes
+    };
+    return cloner.clone(tp);
+}
+
+TypeId cloneIncremental(TypeId typeId, TypeArena& dest, CloneState& cloneState, Scope* freshScopeForFreeTypes)
+{
+    if (typeId->persistent)
+        return typeId;
+
+    FragmentAutocompleteTypeCloner cloner{
+        NotNull{&dest},
+        cloneState.builtinTypes,
+        NotNull{&cloneState.seenTypes},
+        NotNull{&cloneState.seenTypePacks},
+        nullptr,
+        nullptr,
+        freshScopeForFreeTypes
+    };
+    return cloner.clone(typeId);
+}
+
+TypeFun cloneIncremental(const TypeFun& typeFun, TypeArena& dest, CloneState& cloneState, Scope* freshScopeForFreeTypes)
+{
+    FragmentAutocompleteTypeCloner cloner{
+        NotNull{&dest},
+        cloneState.builtinTypes,
+        NotNull{&cloneState.seenTypes},
+        NotNull{&cloneState.seenTypePacks},
+        nullptr,
+        nullptr,
+        freshScopeForFreeTypes
+    };
+
+    TypeFun copy = typeFun;
+
+    for (auto& param : copy.typeParams)
+    {
+        param.ty = cloner.clone(param.ty);
+
+        if (param.defaultValue)
+            param.defaultValue = cloner.clone(*param.defaultValue);
+    }
+
+    for (auto& param : copy.typePackParams)
+    {
+        param.tp = cloner.clone(param.tp);
+
+        if (param.defaultValue)
+            param.defaultValue = cloner.clone(*param.defaultValue);
+    }
+
+    copy.type = cloner.clone(copy.type);
+
+    return copy;
+}
+
+Binding cloneIncremental(const Binding& binding, TypeArena& dest, CloneState& cloneState, Scope* freshScopeForFreeTypes)
+{
+    FragmentAutocompleteTypeCloner cloner{
+        NotNull{&dest},
+        cloneState.builtinTypes,
+        NotNull{&cloneState.seenTypes},
+        NotNull{&cloneState.seenTypePacks},
+        nullptr,
+        nullptr,
+        freshScopeForFreeTypes
+    };
+
+    Binding b;
+    b.deprecated = binding.deprecated;
+    b.deprecatedSuggestion = binding.deprecatedSuggestion;
+    b.documentationSymbol = binding.documentationSymbol;
+    b.location = binding.location;
+    b.typeId = FFlag::LuauDoNotClonePersistentBindings && binding.typeId->persistent ? binding.typeId : cloner.clone(binding.typeId);
+
+    return b;
+}
+
+
+} // namespace Luau