sorbet · Feb 18, 2025 · Feb 18, 2025 · Feb 18, 2025 · Feb 18, 2025 · Feb 18, 2025
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
@@ -0,0 +1,34 @@
+name: CI
+
+on:
+  push:
+    branches: [prism, prism-squashed]
+  pull_request:
+    branches: [prism, prism-squashed]
+jobs:
+  tests:
+    runs-on: ubuntu-latest
+    name: Prism Parser Regression Tests
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: 3.3.0
+      - name: Set up Bazel
+        uses: bazel-contrib/setup-bazel@0.9.0
+        with:
+          # Avoid downloading Bazel every time.
+          bazelisk-cache: true
+          # Store build cache per workflow.
+          disk-cache: ${{ github.workflow }}
+          # Share repository cache between workflows.
+          repository-cache: true
+      - name: Verify parse trees
+        run: ./tools/scripts/verify_prism_regression_tests.sh
+      - name: Run tests
+        run: ./bazel test //test:prism_regression --config=dbg --test_output=errors
+      - name: Run location tests
+        run: ./bazel test //test:prism_location_tests --config=dbg --test_output=errors
+      - name: Run corpus tests
+        run: ./bazel test //test:test_corpus_prism --config=dbg --test_output=errors
diff --git a/.vscode/extensions.json b/.vscode/extensions.json
@@ -1,7 +1,9 @@
 {
   "recommendations": [
     // C++ intellisense with clangd.
-    "llvm-vs-code-extensions.vscode-clangd"
+    "llvm-vs-code-extensions.vscode-clangd",
+    // TODO: remove this before upstreaming
+    "vadimcn.vscode-lldb",
   ],
   "unwantedRecommendations": [
     // Microsoft C++ intellisense (doesn't work properly with Sorbet)

diff --git a/.vscode/launch.json b/.vscode/launch.json
@@ -22,6 +22,43 @@
                     "ignoreFailures": false
                 }
             ]
+        },
+        {
+            "type": "lldb",
+            "request": "launch",
+            "name": "Debug Prism test in LLDB",
+            "program": "${workspaceFolder}/bazel-bin/test/test_PosTests/prism_regression/${input:prism_regression_test_name}_prism.runfiles/com_stripe_ruby_typer/test/pipeline_test_runner",
+            "args": ["--single_test=${workspaceFolder}/test/prism_regression/${input:prism_regression_test_name}.rb", "--parser=prism"],
+            // We need to run all tests to generate the pipeline_test_runner files, which are needed by the LLDB debugger to execute the tests.
+            "preLaunchTask": "Run all Prism regression tests",
+            "stopOnEntry": false,
+            "sourceMap": {
+                "": "${workspaceFolder}",
+            },
+        },
+        {
+            "type": "lldb",
+            "request": "launch",
+            "name": "Debug Sorbet pipeline in LLDB",
+            "program": "${workspaceFolder}/bazel-bin/main/sorbet",
+            "args": ["--parser=prism", "${input:file_path}"],
+            "preLaunchTask": "Build with Prism",
+            "stopOnEntry": false,
+            "sourceMap": {
+                "": "${workspaceFolder}",
+            },
+        },
+    ],
+    "inputs": [
+        {
+            "id": "prism_regression_test_name",
+            "type": "promptString",
+            "description": "Enter the test name, e.g. case for running test/prism_regression/case.rb",
+        },
+        {
+            "id": "file_path",
+            "type": "promptString",
+            "description": "Enter the path to the file to typecheck, e.g. test/prism_regression/case.rb",
         }
     ]
-}
+}
diff --git a/.vscode/tasks.json b/.vscode/tasks.json
@@ -0,0 +1,136 @@
+{
+    // See https://go.microsoft.com/fwlink/?LinkId=733558
+    // for the documentation about the tasks.json format
+    "version": "2.0.0",
+    "tasks": [
+        {
+            "label": "Build with Prism",
+            "type": "shell",
+            "command": "./bazel build //main:sorbet --config=dbg",
+            "group": {
+                "kind": "build",
+                "isDefault": true
+            },
+            "presentation": {
+                "reveal": "always"
+            }
+        },
+        {
+            "label": "(Re)Generate Prism test",
+            "type": "shell",
+            "command": "TEST_NAME=${input:prism_regression_test_name}; $EDITOR -w test/prism_regression/$TEST_NAME.rb; ./bazel-bin/main/sorbet --stop-after=parser --print=parse-tree test/prism_regression/$TEST_NAME.rb > test/prism_regression/$TEST_NAME.parse-tree.exp; $EDITOR test/prism_regression/$TEST_NAME.parse-tree.exp test/prism_regression/$TEST_NAME.rb",
+            "group": {
+                "kind": "test",
+                "isDefault": true
+            },
+            "presentation": {
+                "reveal": "always"
+            }
+        },
+        {
+            "label": "Run a single Prism regression test",
+            "type": "shell",
+            "command": "./bazel test //test:test_PosTests/prism_regression/${input:prism_regression_test_name}_prism //test:prism_regression/${input:prism_regression_test_name}_location_test --config=dbg  --test_output=all",
+            "group": {
+                "kind": "test",
+                "isDefault": true
+            },
+            "presentation": {
+                "reveal": "always"
+            },
+            // With this option, when running this task with the `Tasks: Rerun Last Test` command, it'll
+            // reuse the previous run's input, rather than prompting for it again
+            "runOptions": {
+                "reevaluateOnRerun": false
+            }
+        },
+        {
+            "label": "Run all Prism regression tests",
+            "type": "shell",
+            "command": "./bazel test //test:prism_regression //test:prism_location_tests --config=dbg  --test_output=all",
+            "group": {
+                "kind": "test",
+                "isDefault": true
+            },
+            "presentation": {
+                "reveal": "always"
+            }
+        },
+        {
+            "label": "Run all Prism corpus tests",
+            "type": "shell",
+            "command": "./bazel test //test:test_corpus_prism --config=dbg  --test_output=all",
+            "group": {
+                "kind": "test",
+                "isDefault": true
+            },
+            "presentation": {
+                "reveal": "always"
+            }
+        },
+        {
+            "label": "Run a single Prism corpus test",
+            "type": "shell",
+            "command": "./bazel test //test:test_PosTests/testdata/${input:prism_corpus_test_name}_prism --config=dbg  --test_output=all",
+            "group": {
+                "kind": "test",
+                "isDefault": true
+            },
+            "presentation": {
+                "reveal": "always"
+            },
+            // With this option, when running this task with the `Tasks: Rerun Last Test` command, it'll
+            // reuse the previous run's input, rather than prompting for it again
+            "runOptions": {
+                "reevaluateOnRerun": false
+            }
+        },
+        {
+            "label": "Typecheck with Prism",
+            "type": "shell",
+            "command": "bazel-bin/main/sorbet --parser=prism ${input:file_path}",
+            "group": {
+                "kind": "build",
+                "isDefault": true
+            },
+            "dependsOn": ["Build with Prism"],
+            "presentation": {
+                "reveal": "always"
+            }
+        },
+        {
+            "label": "Display Prism parse tree & errors for Ruby file",
+            "type": "shell",
+            "command": "tools/scripts/inspect_parsing_errors.rb ${file}",
+            "presentation": {
+                "reveal": "always"
+            },
+            "options": {
+                // Makes sure the shell can find the correct Ruby version
+                "shell": {
+                    "executable": "${env:SHELL}",
+                    "args": ["-c"]
+                }
+            },
+            "problemMatcher": []
+        }
+    ],
+    "inputs": [
+        {
+            "id": "prism_corpus_test_name",
+            "type": "promptString",
+            "description": "Enter the test name, e.g. parser/and_and_bug for running test/testdata/parser/and_and_bug.rb",
+        },
+        {
+            "id": "prism_regression_test_name",
+            "type": "promptString",
+            "description": "Enter the test name, e.g. case for running test/prism_regression/case.rb",
+        },
+        {
+            "id": "file_path",
+            "type": "promptString",
+            "default": "test.rb",
+            "description": "Enter the file path to typecheck, e.g. test.rb",
+        }
+    ]
+}
diff --git a/Gemfile b/Gemfile
@@ -0,0 +1 @@
+source "https://rubygems.org"
diff --git a/Gemfile.lock b/Gemfile.lock
@@ -0,0 +1,12 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+
+PLATFORMS
+  arm64-darwin-23
+  ruby
+
+DEPENDENCIES
+
+BUNDLED WITH
+   2.5.17
diff --git a/break.rb b/break.rb
diff --git a/main/options/options.cc b/main/options/options.cc
@@ -725,6 +725,9 @@ buildOptions(const vector<pipeline::semantic_extension::SemanticExtensionProvide
                                  cxxopts::value<vector<string>>()->implicit_value("all"), "SECTION");
     // }}}
 
+    options.add_options("dev")("parser", "Which parser to use", cxxopts::value<string>()->default_value("sorbet"),
+                               "{sorbet, prism}");
+
     for (auto &provider : semanticExtensionProviders) {
         provider->injectOptions(options);
     }
@@ -793,6 +796,22 @@ Phase extractStopAfter(cxxopts::ParseResult &raw, shared_ptr<spdlog::logger> log
     return Phase::INIT;
 }
 
+Parser extractParser(cxxopts::ParseResult &raw, shared_ptr<spdlog::logger> logger) {
+    string opt = raw["parser"].as<string>();
+    for (auto &known : parser_options) {
+        if (known.option == opt) {
+            return known.flag;
+        }
+    }
+    vector<string_view> allOptions;
+    for (auto &known : parser_options) {
+        allOptions.emplace_back(known.option);
+    }
+
+    logger->error("Unknown --parser option: {}\nValid values: {}", opt, fmt::join(allOptions, ", "));
+    return Parser::SORBET;
+}
+
 // Given a path, strips any trailing forward slashes (/) at the end of the path.
 string_view stripTrailingSlashes(string_view path) {
     while (path.back() == '/') {
@@ -956,6 +975,7 @@ void readOptions(Options &opts,
             throw EarlyReturnWithCode(1);
         }
         opts.stopAfterPhase = extractStopAfter(raw, logger);
+        opts.parser = extractParser(raw, logger);
 
         opts.silenceErrors = raw["quiet"].as<bool>();
         opts.autocorrect = raw["autocorrect"].as<bool>();
@@ -1356,6 +1376,7 @@ void readOptions(Options &opts,
             fmt::print("Sorbet typechecker {}\n", sorbet_full_version_string);
             throw EarlyReturnWithCode(0);
         }
+
     } catch (cxxopts::OptionParseException &e) {
         logger->info("{}. To see all available options pass `--help`.", e.what());
         throw EarlyReturnWithCode(1);

diff --git a/main/options/options.h b/main/options/options.h
@@ -106,6 +106,21 @@ enum class Phase {
     INFERENCER,
 };
 
+enum class Parser {
+    PRISM,
+    SORBET,
+};
+
+struct ParserOptions {
+    std::string option;
+    Parser flag;
+};
+
+const std::vector<ParserOptions> parser_options({
+    {"sorbet", Parser::SORBET},
+    {"prism", Parser::PRISM},
+});
+
 namespace {
 
 #if !defined(EMSCRIPTEN)
@@ -120,6 +135,7 @@ constexpr size_t MAX_CACHE_SIZE_BYTES = 1L * 1024 * 1024 * 1024; // 1 GiB
 struct Options {
     Printers print;
     Phase stopAfterPhase = Phase::INFERENCER;
+    Parser parser = Parser::SORBET;
     bool noStdlib = false;
 
     // Should we monitor STDOUT for HUP and exit if it hangs up. This is a

diff --git a/main/pipeline/BUILD b/main/pipeline/BUILD
@@ -32,6 +32,7 @@ cc_library(
         "//namer",
         "//packager",
         "//parser",
+        "//parser/prism",
         "//payload/binary",
         "//payload/text",
         "//resolver",
@@ -70,6 +71,7 @@ cc_library(
         "//main/options",
         "//namer",
         "//parser",
+        "//parser/prism",
         "//payload/binary",
         "//payload/text",
         "//resolver",

diff --git a/main/pipeline/pipeline.cc b/main/pipeline/pipeline.cc
@@ -37,11 +37,14 @@
 #include "main/pipeline/semantic_extension/SemanticExtension.h"
 #include "namer/namer.h"
 #include "parser/parser.h"
+#include "parser/prism/Parser.h"
+#include "parser/prism/Translator.h"
 #include "pipeline.h"
 #include "resolver/resolver.h"
 #include "rewriter/rewriter.h"
 
 using namespace std;
+namespace Prism = sorbet::parser::Prism;
 
 namespace sorbet::realmain::pipeline {
 
@@ -112,6 +115,7 @@ unique_ptr<parser::Node> runParser(core::GlobalState &gs, core::FileRef file, co
         auto settings = parser::Parser::Settings{traceLexer, traceParser, indentationAware};
         nodes = parser::Parser::run(gs, file, settings);
     }
+
     if (print.ParseTree.enabled) {
         print.ParseTree.fmt("{}\n", nodes->toStringWithTabs(gs, 0));
     }
@@ -127,6 +131,37 @@ unique_ptr<parser::Node> runParser(core::GlobalState &gs, core::FileRef file, co
     return nodes;
 }
 
+unique_ptr<parser::Node> runPrismParser(core::GlobalState &gs, core::FileRef file, bool stopAfterParser,
+                                        const options::Printers &print) {
+    auto source = file.data(gs).source();
+
+    core::UnfreezeNameTable nameTableAccess(gs);
+
+    Prism::Parser parser{source};
+    Prism::ParseResult parseResult = parser.parse_root();
+
+    if (stopAfterParser) {
+        return std::unique_ptr<parser::Node>();
+    }
+
+    auto nodes = Prism::Translator(parser, gs, file).translate(std::move(parseResult));
+
+    if (print.ParseTree.enabled) {
+        print.ParseTree.fmt("{}\n", nodes->toStringWithTabs(gs, 0));
+    }
+    if (print.ParseTreeJson.enabled) {
+        print.ParseTreeJson.fmt("{}\n", nodes->toJSON(gs, 0));
+    }
+    if (print.ParseTreeJsonWithLocs.enabled) {
+        print.ParseTreeJson.fmt("{}\n", nodes->toJSONWithLocs(gs, file, 0));
+    }
+    if (print.ParseTreeWhitequark.enabled) {
+        print.ParseTreeWhitequark.fmt("{}\n", nodes->toWhitequark(gs, 0));
+    }
+
+    return nodes;
+}
+
 ast::ExpressionPtr runDesugar(core::GlobalState &gs, core::FileRef file, unique_ptr<parser::Node> parseTree,
                               const options::Printers &print, bool preserveConcreteSyntax = false) {
     Timer timeit(gs.tracer(), "runDesugar", {{"file", string(file.data(gs).path())}});
@@ -186,6 +221,8 @@ ast::ExpressionPtr desugarOne(const options::Options &opts, core::GlobalState &g
 ast::ParsedFile indexOne(const options::Options &opts, core::GlobalState &lgs, core::FileRef file,
                          ast::ExpressionPtr tree) {
     auto &print = opts.print;
+    auto &parser = opts.parser;
+
     ast::ParsedFile rewritten{nullptr, file};
 
     Timer timeit(lgs.tracer(), "indexOne", {{"file", string(file.data(lgs).path())}});
@@ -195,8 +232,21 @@ ast::ParsedFile indexOne(const options::Options &opts, core::GlobalState &lgs, c
             if (file.data(lgs).strictLevel == core::StrictLevel::Ignore) {
                 return emptyParsedFile(file);
             }
-            auto parseTree = runParser(lgs, file, print, opts.traceLexer, opts.traceParser);
-            if (opts.stopAfterPhase == options::Phase::PARSER) {
+
+            unique_ptr<parser::Node> parseTree;
+
+            bool stopAfterParser = opts.stopAfterPhase == options::Phase::PARSER;
+
+            switch (parser) {
+                case options::Parser::SORBET:
+                    parseTree = runParser(lgs, file, print, opts.traceLexer, opts.traceParser);
+                    break;
+                case options::Parser::PRISM:
+                    parseTree = runPrismParser(lgs, file, stopAfterParser, print);
+                    break;
+            }
+
+            if (stopAfterParser) {
                 return emptyParsedFile(file);
             }
             tree = runDesugar(lgs, file, move(parseTree), print);

diff --git a/main/pipeline/pipeline.h b/main/pipeline/pipeline.h
@@ -7,6 +7,7 @@
 #include "common/kvstore/KeyValueStore.h"
 #include "core/FileHash.h"
 #include "main/options/options.h"
+#include "parser/parser.h"
 
 namespace sorbet::core::lsp {
 class PreemptionTaskManager;
@@ -25,6 +26,8 @@ std::vector<core::FileRef> reserveFiles(std::unique_ptr<core::GlobalState> &gs,
 std::vector<ast::ParsedFile> index(core::GlobalState &gs, absl::Span<core::FileRef> files, const options::Options &opts,
                                    WorkerPool &workers, const std::unique_ptr<const OwnedKeyValueStore> &kvstore);
 
+std::unique_ptr<parser::Node> runPrismParser(core::GlobalState &gs, core::FileRef file, bool stopAfterParser,
+                                             const options::Printers &print);
 size_t partitionPackageFiles(const core::GlobalState &gs, absl::Span<core::FileRef> files);
 void unpartitionPackageFiles(std::vector<ast::ParsedFile> &packageFiles,
                              std::vector<ast::ParsedFile> &&nonPackageFiles);

diff --git a/parser/prism/BUILD b/parser/prism/BUILD
@@ -0,0 +1,22 @@
+cc_library(
+    name = "prism",
+    srcs = [
+        "Parser.cc",
+        "Translator.cc",
+    ],
+    hdrs = [
+        "Parser.h",
+        "Translator.h",
+        "Helpers.h",
+    ],
+    linkstatic = select({
+        "//tools/config:linkshared": 0,
+        "//conditions:default": 1,
+    }),
+    visibility = ["//visibility:public"],
+    deps = [
+        "//core",
+        "//parser", # Legacy parser, needed for translating to its nodes defined in `parser/Node_gen.h`
+        "@prism",
+    ],
+)
diff --git a/parser/prism/Helpers.h b/parser/prism/Helpers.h
diff --git a/parser/prism/Parser.cc b/parser/prism/Parser.cc
@@ -0,0 +1,49 @@
+#include "parser/prism/Parser.h"
+
+namespace sorbet::parser::Prism {
+
+pm_parser_t *Parser::getRawParserPointer() {
+    return &storage->parser;
+}
+
+ParseResult Parser::parse_root() {
+    pm_node_t *root = pm_parse(getRawParserPointer());
+    return ParseResult{*this, root, collectErrors()};
+};
+
+core::LocOffsets Parser::translateLocation(pm_location_t location) {
+    uint32_t start = static_cast<uint32_t>(location.start - storage->parser.start);
+    uint32_t end = static_cast<uint32_t>(location.end - storage->parser.start);
+
+    return core::LocOffsets{start, end};
+}
+
+std::string_view Parser::resolveConstant(pm_constant_id_t constant_id) {
+    pm_constant_t *constant = pm_constant_pool_id_to_constant(&storage->parser.constant_pool, constant_id);
+
+    return std::string_view(reinterpret_cast<const char *>(constant->start), constant->length);
+}
+
+std::string_view Parser::extractString(pm_string_t *string) {
+    return std::string_view(reinterpret_cast<const char *>(pm_string_source(string)), pm_string_length(string));
+}
+
+std::vector<ParseError> Parser::collectErrors() {
+    std::vector<ParseError> parseErrors;
+    parseErrors.reserve(storage->parser.error_list.size);
+
+    auto error_list = storage->parser.error_list;
+
+    for (auto *node = error_list.head; node != nullptr; node = node->next) {
+        auto *error = reinterpret_cast<pm_diagnostic_t *>(node);
+        auto level = static_cast<pm_error_level_t>(error->level);
+
+        ParseError parseError(error->diag_id, std::string(reinterpret_cast<const char *>(error->message)),
+                              error->location, level);
+
+        parseErrors.push_back(parseError);
+    }
+
+    return parseErrors;
+}
+}; // namespace sorbet::parser::Prism
diff --git a/parser/prism/Parser.h b/parser/prism/Parser.h
@@ -0,0 +1,103 @@
+#ifndef SORBET_PARSER_PRISM_PARSER_H
+#define SORBET_PARSER_PRISM_PARSER_H
+
+#include <memory>
+#include <string>
+#include <vector>
+
+extern "C" {
+#include "prism.h"
+}
+
+#include "core/LocOffsets.h"
+
+namespace sorbet::parser::Prism {
+
+class ParseResult;
+
+class ParseError {
+public:
+    ParseError(pm_diagnostic_id_t id, const std::string &message, pm_location_t location, pm_error_level_t level)
+        : id(id), message(message), location(location), level(level) {}
+
+    pm_diagnostic_id_t id;
+    std::string message;
+    pm_location_t location;
+    pm_error_level_t level;
+};
+
+// A backing implemenation detail of `Parser`, which stores a Prism parser and its options in a single allocation.
+struct ParserStorage {
+    // The version of Ruby syntax that we're parsing with Prism. This determines what syntax is supported or not.
+    static constexpr std::string_view ParsedRubyVersion = "3.3.0";
+    pm_parser_t parser;
+    pm_options_t options;
+
+    ParserStorage(std::string_view source_code) : parser{}, options{} {
+        pm_options_version_set(&options, ParsedRubyVersion.data(), ParsedRubyVersion.size());
+
+        pm_parser_init(&parser, reinterpret_cast<const uint8_t *>(source_code.data()), source_code.size(), &options);
+    }
+
+    ~ParserStorage() {
+        pm_parser_free(&parser);
+        pm_options_free(&options);
+    }
+
+    ParserStorage(const ParserStorage &) = delete;
+    ParserStorage &operator=(const ParserStorage &) = delete;
+    ParserStorage(ParserStorage &&) = delete;
+    ParserStorage &operator=(ParserStorage &&) = delete;
+};
+
+class Parser final {
+    friend class ParseResult;
+    friend struct NodeDeleter;
+
+    std::shared_ptr<ParserStorage> storage;
+
+public:
+    Parser(std::string_view source_code) : storage(std::make_shared<ParserStorage>(source_code)) {}
+
+    Parser(const Parser &) = default;
+    Parser &operator=(const Parser &) = default;
+
+    ParseResult parse_root();
+    core::LocOffsets translateLocation(pm_location_t location);
+    std::string_view resolveConstant(pm_constant_id_t constant_id);
+    std::string_view extractString(pm_string_t *string);
+
+private:
+    std::vector<ParseError> collectErrors();
+    pm_parser_t *getRawParserPointer();
+};
+
+class ParseResult final {
+    struct NodeDeleter {
+        Parser parser;
+
+        void operator()(pm_node_t *node) {
+            pm_node_destroy(parser.getRawParserPointer(), node);
+        }
+    };
+
+    friend class Parser;
+    friend class Translator;
+
+    Parser parser;
+    std::unique_ptr<pm_node_t, NodeDeleter> node;
+    std::vector<ParseError> parseErrors;
+
+    ParseResult(Parser parser, pm_node_t *node, std::vector<ParseError> parseErrors)
+        : parser{parser}, node{node, NodeDeleter{parser}}, parseErrors{parseErrors} {}
+
+    ParseResult(const ParseResult &) = delete;            // Copy constructor
+    ParseResult &operator=(const ParseResult &) = delete; // Copy assignment
+
+    pm_node_t *getRawNodePointer() const {
+        return node.get();
+    }
+};
+
+} // namespace sorbet::parser::Prism
+#endif // SORBET_PARSER_PRISM_PARSER_H
diff --git a/parser/prism/Translator.cc b/parser/prism/Translator.cc
diff --git a/parser/prism/Translator.h b/parser/prism/Translator.h
@@ -0,0 +1,110 @@
+#ifndef SORBET_PARSER_PRISM_TRANSLATOR_H
+#define SORBET_PARSER_PRISM_TRANSLATOR_H
+
+#include "core/errors/parser.h"
+#include "parser/Node.h" // To clarify: these are Sorbet Parser nodes, not Prism ones.
+#include "parser/prism/Parser.h"
+#include <memory>
+
+extern "C" {
+#include "prism.h"
+}
+
+namespace sorbet::parser::Prism {
+
+class Translator final {
+    Parser parser;
+
+    // The functions in Pipeline.cc pass around a reference to the global state as a parameter,
+    // but don't have explicit ownership over it. We take a temporary reference to it, but we can't
+    // escape that scope, which is why Translator objects can't be copied, or even moved.
+    core::GlobalState &gs;
+
+    // Needed for reporting diagnostics
+    core::FileRef file;
+
+    // The parse errors that occurred while parsing the root node
+    std::vector<ParseError> parseErrors;
+
+    // Context variables
+    bool isInMethodDef = false;
+
+    // Keep track of the unique ID counter
+    // uniqueCounterStorage is the source of truth maintained by the parent Translator
+    // uniqueCounter is a pointer to uniqueCounterStorage and is passed down to child Translators
+    int uniqueCounterStorage;
+    int *uniqueCounter;
+
+    Translator(Translator &&) = delete;                 // Move constructor
+    Translator(const Translator &) = delete;            // Copy constructor
+    Translator &operator=(Translator &&) = delete;      // Move assignment
+    Translator &operator=(const Translator &) = delete; // Copy assignment
+public:
+    Translator(Parser parser, core::GlobalState &gs, core::FileRef file)
+        : parser(std::move(parser)), gs(gs), file(file), uniqueCounterStorage(1),
+          uniqueCounter(&this->uniqueCounterStorage) {}
+
+    int nextUniqueID() {
+        return *uniqueCounter += 1;
+    }
+
+    // Translates the given AST from Prism's node types into the equivalent AST in Sorbet's legacy parser node types.
+    std::unique_ptr<parser::Node> translate(pm_node_t *node);
+    std::unique_ptr<parser::Node> translate(const ParseResult &parseResult);
+
+private:
+    // Private constructor used only for creating child translators
+    // uniqueCounterStorage is passed as the minimum integer value and is never used
+    Translator(Parser parser, core::GlobalState &gs, core::FileRef file, std::vector<ParseError> parseErrors,
+               bool isInMethodDef, int *uniqueCounter)
+        : parser(parser), gs(gs), file(file), parseErrors(parseErrors), isInMethodDef(isInMethodDef),
+          uniqueCounterStorage(std::numeric_limits<int>::min()), uniqueCounter(uniqueCounter) {}
+    void reportError(core::LocOffsets loc, const std::string &message);
+
+    core::LocOffsets translateLoc(pm_location_t loc);
+
+    parser::NodeVec translateMulti(pm_node_list prismNodes);
+    void translateMultiInto(NodeVec &sorbetNodes, absl::Span<pm_node_t *> prismNodes);
+
+    NodeVec translateArguments(pm_arguments_node *node, pm_node *blockArgumentNode = nullptr);
+    parser::NodeVec translateKeyValuePairs(pm_node_list_t elements);
+    static bool isKeywordHashElement(sorbet::parser::Node *nd);
+    std::unique_ptr<parser::Node> translateCallWithBlock(pm_node_t *prismBlockOrLambdaNode,
+                                                         std::unique_ptr<parser::Node> sendNode);
+    std::unique_ptr<parser::Node> translateRescue(pm_rescue_node *prismRescueNode,
+                                                  std::unique_ptr<parser::Node> beginNode,
+                                                  std::unique_ptr<parser::Node> elseNode);
+    std::unique_ptr<parser::Node> translateStatements(pm_statements_node *stmtsNode, bool inlineIfSingle);
+
+    template <typename SorbetNode> std::unique_ptr<SorbetNode> translateSimpleKeyword(pm_node_t *untypedNode);
+
+    std::unique_ptr<parser::Regopt> translateRegexpOptions(pm_location_t closingLoc);
+    std::unique_ptr<parser::Regexp> translateRegexp(pm_string_t unescaped, core::LocOffsets location,
+                                                    pm_location_t closingLoc);
+
+    template <typename PrismNode> std::unique_ptr<parser::Mlhs> translateMultiTargetLhs(PrismNode *);
+
+    template <typename PrismAssignmentNode, typename SorbetLHSNode>
+    std::unique_ptr<parser::Assign> translateAssignment(pm_node_t *node);
+
+    template <typename PrismAssignmentNode, typename SorbetAssignmentNode, typename SorbetLHSNode>
+    std::unique_ptr<SorbetAssignmentNode> translateOpAssignment(pm_node_t *node);
+
+    template <typename PrismLhsNode, typename SorbetLHSNode>
+    std::unique_ptr<parser::Node> translateConst(PrismLhsNode *node, bool replaceWithDynamicConstAssign = false);
+    core::NameRef translateConstantName(pm_constant_id_t constant_id);
+
+    // Pattern-matching
+    // ... variations of the main translation functions for pattern-matching related nodes.
+    std::unique_ptr<parser::Node> patternTranslate(pm_node_t *node);
+    parser::NodeVec patternTranslateMulti(pm_node_list prismNodes);
+    void patternTranslateMultiInto(NodeVec &sorbetNodes, absl::Span<pm_node_t *> prismNodes);
+
+    std::string_view sliceLocation(pm_location_t loc);
+
+    // Context management helpers. These return a copy of `this` with some change to the context.
+    Translator enterMethodDef();
+};
+
+} // namespace sorbet::parser::Prism
+#endif // SORBET_PARSER_PRISM_TRANSLATOR_H
diff --git a/prism_benchmarks/memory/data/parser/shopify/2024-08-22-0739d1462.txt b/prism_benchmarks/memory/data/parser/shopify/2024-08-22-0739d1462.txt
@@ -0,0 +1,49 @@
+	Command being timed: "bazel-bin/main/sorbet --parser=prism --stop-after=parser ../../Shopify/shopify"
+	User time (seconds): 308.82
+	System time (seconds): 10.04
+	Percent of CPU this job got: 113%
+	Elapsed (wall clock) time (h:mm:ss or m:ss): 4:40.27
+	Average shared text size (kbytes): 0
+	Average unshared data size (kbytes): 0
+	Average stack size (kbytes): 0
+	Average total size (kbytes): 0
+	Maximum resident set size (kbytes): 881064
+	Average resident set size (kbytes): 0
+	Major (requiring I/O) page faults: 0
+	Minor (reclaiming a frame) page faults: 226461
+	Voluntary context switches: 14702
+	Involuntary context switches: 80406
+	Swaps: 0
+	File system inputs: 0
+	File system outputs: 0
+	Socket messages sent: 0
+	Socket messages received: 0
+	Signals delivered: 0
+	Page size (bytes): 16384
+	Exit status: 0
+
+Command exited with non-zero status 100
+	Command being timed: "bazel-bin/main/sorbet --parser=sorbet --stop-after=parser ../../Shopify/shopify"
+	User time (seconds): 476.12
+	System time (seconds): 9.49
+	Percent of CPU this job got: 160%
+	Elapsed (wall clock) time (h:mm:ss or m:ss): 5:02.08
+	Average shared text size (kbytes): 0
+	Average unshared data size (kbytes): 0
+	Average stack size (kbytes): 0
+	Average total size (kbytes): 0
+	Maximum resident set size (kbytes): 1355112
+	Average resident set size (kbytes): 0
+	Major (requiring I/O) page faults: 0
+	Minor (reclaiming a frame) page faults: 343679
+	Voluntary context switches: 231
+	Involuntary context switches: 77417
+	Swaps: 0
+	File system inputs: 0
+	File system outputs: 0
+	Socket messages sent: 0
+	Socket messages received: 0
+	Signals delivered: 0
+	Page size (bytes): 16384
+	Exit status: 100
+
diff --git a/prism_benchmarks/memory/data/parser/shopify/2024-09-18-5df44846d.txt b/prism_benchmarks/memory/data/parser/shopify/2024-09-18-5df44846d.txt
@@ -0,0 +1,49 @@
+	Command being timed: "bazel-bin/main/sorbet --parser=prism --stop-after=parser ../../Shopify/shopify"
+	User time (seconds): 311.65
+	System time (seconds): 30.33
+	Percent of CPU this job got: 123%
+	Elapsed (wall clock) time (h:mm:ss or m:ss): 4:36.99
+	Average shared text size (kbytes): 0
+	Average unshared data size (kbytes): 0
+	Average stack size (kbytes): 0
+	Average total size (kbytes): 0
+	Maximum resident set size (kbytes): 877296
+	Average resident set size (kbytes): 0
+	Major (requiring I/O) page faults: 0
+	Minor (reclaiming a frame) page faults: 225456
+	Voluntary context switches: 89208
+	Involuntary context switches: 354071
+	Swaps: 0
+	File system inputs: 0
+	File system outputs: 0
+	Socket messages sent: 0
+	Socket messages received: 0
+	Signals delivered: 0
+	Page size (bytes): 16384
+	Exit status: 0
+
+Command exited with non-zero status 100
+	Command being timed: "bazel-bin/main/sorbet --parser=sorbet --stop-after=parser ../../Shopify/shopify"
+	User time (seconds): 771.97
+	System time (seconds): 27.98
+	Percent of CPU this job got: 239%
+	Elapsed (wall clock) time (h:mm:ss or m:ss): 5:34.40
+	Average shared text size (kbytes): 0
+	Average unshared data size (kbytes): 0
+	Average stack size (kbytes): 0
+	Average total size (kbytes): 0
+	Maximum resident set size (kbytes): 1349328
+	Average resident set size (kbytes): 0
+	Major (requiring I/O) page faults: 0
+	Minor (reclaiming a frame) page faults: 342514
+	Voluntary context switches: 20
+	Involuntary context switches: 147120
+	Swaps: 0
+	File system inputs: 0
+	File system outputs: 0
+	Socket messages sent: 0
+	Socket messages received: 0
+	Signals delivered: 0
+	Page size (bytes): 16384
+	Exit status: 100
+
diff --git a/prism_benchmarks/memory/data/parser/yjit-bench/2024-08-22-0739d1462.txt b/prism_benchmarks/memory/data/parser/yjit-bench/2024-08-22-0739d1462.txt
@@ -0,0 +1,48 @@
+	Command being timed: "bazel-bin/main/sorbet --parser=prism --stop-after=parser ../yjit-bench/benchmarks"
+	User time (seconds): 1.41
+	System time (seconds): 0.11
+	Percent of CPU this job got: 115%
+	Elapsed (wall clock) time (h:mm:ss or m:ss): 0:01.31
+	Average shared text size (kbytes): 0
+	Average unshared data size (kbytes): 0
+	Average stack size (kbytes): 0
+	Average total size (kbytes): 0
+	Maximum resident set size (kbytes): 137440
+	Average resident set size (kbytes): 0
+	Major (requiring I/O) page faults: 24
+	Minor (reclaiming a frame) page faults: 38722
+	Voluntary context switches: 406
+	Involuntary context switches: 2968
+	Swaps: 0
+	File system inputs: 0
+	File system outputs: 0
+	Socket messages sent: 0
+	Socket messages received: 0
+	Signals delivered: 0
+	Page size (bytes): 16384
+	Exit status: 0
+
+	Command being timed: "bazel-bin/main/sorbet --parser=sorbet --stop-after=parser ../yjit-bench/benchmarks"
+	User time (seconds): 4.07
+	System time (seconds): 0.08
+	Percent of CPU this job got: 198%
+	Elapsed (wall clock) time (h:mm:ss or m:ss): 0:02.09
+	Average shared text size (kbytes): 0
+	Average unshared data size (kbytes): 0
+	Average stack size (kbytes): 0
+	Average total size (kbytes): 0
+	Maximum resident set size (kbytes): 197452
+	Average resident set size (kbytes): 0
+	Major (requiring I/O) page faults: 0
+	Minor (reclaiming a frame) page faults: 51716
+	Voluntary context switches: 0
+	Involuntary context switches: 1299
+	Swaps: 0
+	File system inputs: 0
+	File system outputs: 0
+	Socket messages sent: 0
+	Socket messages received: 0
+	Signals delivered: 0
+	Page size (bytes): 16384
+	Exit status: 0
+
diff --git a/prism_benchmarks/memory/data/parser/yjit-bench/2024-09-18-5df44846d.txt b/prism_benchmarks/memory/data/parser/yjit-bench/2024-09-18-5df44846d.txt
@@ -0,0 +1,48 @@
+	Command being timed: "bazel-bin/main/sorbet --parser=prism --stop-after=parser ../yjit-bench/benchmarks"
+	User time (seconds): 1.81
+	System time (seconds): 0.18
+	Percent of CPU this job got: 35%
+	Elapsed (wall clock) time (h:mm:ss or m:ss): 0:05.69
+	Average shared text size (kbytes): 0
+	Average unshared data size (kbytes): 0
+	Average stack size (kbytes): 0
+	Average total size (kbytes): 0
+	Maximum resident set size (kbytes): 135876
+	Average resident set size (kbytes): 0
+	Major (requiring I/O) page faults: 0
+	Minor (reclaiming a frame) page faults: 38705
+	Voluntary context switches: 383
+	Involuntary context switches: 2705
+	Swaps: 0
+	File system inputs: 0
+	File system outputs: 0
+	Socket messages sent: 0
+	Socket messages received: 0
+	Signals delivered: 0
+	Page size (bytes): 16384
+	Exit status: 0
+
+	Command being timed: "bazel-bin/main/sorbet --parser=sorbet --stop-after=parser ../yjit-bench/benchmarks"
+	User time (seconds): 10.03
+	System time (seconds): 0.09
+	Percent of CPU this job got: 181%
+	Elapsed (wall clock) time (h:mm:ss or m:ss): 0:05.57
+	Average shared text size (kbytes): 0
+	Average unshared data size (kbytes): 0
+	Average stack size (kbytes): 0
+	Average total size (kbytes): 0
+	Maximum resident set size (kbytes): 205288
+	Average resident set size (kbytes): 0
+	Major (requiring I/O) page faults: 0
+	Minor (reclaiming a frame) page faults: 53938
+	Voluntary context switches: 0
+	Involuntary context switches: 1746
+	Swaps: 0
+	File system inputs: 0
+	File system outputs: 0
+	Socket messages sent: 0
+	Socket messages received: 0
+	Signals delivered: 0
+	Page size (bytes): 16384
+	Exit status: 0
+
diff --git a/prism_benchmarks/memory/data/pipeline/prism_regression/2024-08-22-0739d1462.txt b/prism_benchmarks/memory/data/pipeline/prism_regression/2024-08-22-0739d1462.txt
@@ -0,0 +1,50 @@
+Command exited with non-zero status 100
+	Command being timed: "bazel-bin/main/sorbet --parser=prism test/prism_regression"
+	User time (seconds): 1.07
+	System time (seconds): 0.03
+	Percent of CPU this job got: 117%
+	Elapsed (wall clock) time (h:mm:ss or m:ss): 0:00.93
+	Average shared text size (kbytes): 0
+	Average unshared data size (kbytes): 0
+	Average stack size (kbytes): 0
+	Average total size (kbytes): 0
+	Maximum resident set size (kbytes): 64996
+	Average resident set size (kbytes): 0
+	Major (requiring I/O) page faults: 0
+	Minor (reclaiming a frame) page faults: 18361
+	Voluntary context switches: 0
+	Involuntary context switches: 893
+	Swaps: 0
+	File system inputs: 0
+	File system outputs: 0
+	Socket messages sent: 0
+	Socket messages received: 0
+	Signals delivered: 0
+	Page size (bytes): 16384
+	Exit status: 100
+
+Command exited with non-zero status 100
+	Command being timed: "bazel-bin/main/sorbet --parser=sorbet test/prism_regression"
+	User time (seconds): 1.06
+	System time (seconds): 0.03
+	Percent of CPU this job got: 119%
+	Elapsed (wall clock) time (h:mm:ss or m:ss): 0:00.91
+	Average shared text size (kbytes): 0
+	Average unshared data size (kbytes): 0
+	Average stack size (kbytes): 0
+	Average total size (kbytes): 0
+	Maximum resident set size (kbytes): 65492
+	Average resident set size (kbytes): 0
+	Major (requiring I/O) page faults: 0
+	Minor (reclaiming a frame) page faults: 18334
+	Voluntary context switches: 0
+	Involuntary context switches: 997
+	Swaps: 0
+	File system inputs: 0
+	File system outputs: 0
+	Socket messages sent: 0
+	Socket messages received: 0
+	Signals delivered: 0
+	Page size (bytes): 16384
+	Exit status: 100
+
diff --git a/prism_benchmarks/memory/data/pipeline/prism_regression/2024-09-18-5df44846d.txt b/prism_benchmarks/memory/data/pipeline/prism_regression/2024-09-18-5df44846d.txt
@@ -0,0 +1,50 @@
+Command exited with non-zero status 100
+	Command being timed: "bazel-bin/main/sorbet --parser=prism test/prism_regression"
+	User time (seconds): 1.65
+	System time (seconds): 0.03
+	Percent of CPU this job got: 121%
+	Elapsed (wall clock) time (h:mm:ss or m:ss): 0:01.39
+	Average shared text size (kbytes): 0
+	Average unshared data size (kbytes): 0
+	Average stack size (kbytes): 0
+	Average total size (kbytes): 0
+	Maximum resident set size (kbytes): 69820
+	Average resident set size (kbytes): 0
+	Major (requiring I/O) page faults: 0
+	Minor (reclaiming a frame) page faults: 19420
+	Voluntary context switches: 0
+	Involuntary context switches: 1327
+	Swaps: 0
+	File system inputs: 0
+	File system outputs: 0
+	Socket messages sent: 0
+	Socket messages received: 0
+	Signals delivered: 0
+	Page size (bytes): 16384
+	Exit status: 100
+
+Command exited with non-zero status 100
+	Command being timed: "bazel-bin/main/sorbet --parser=sorbet test/prism_regression"
+	User time (seconds): 1.66
+	System time (seconds): 0.03
+	Percent of CPU this job got: 122%
+	Elapsed (wall clock) time (h:mm:ss or m:ss): 0:01.38
+	Average shared text size (kbytes): 0
+	Average unshared data size (kbytes): 0
+	Average stack size (kbytes): 0
+	Average total size (kbytes): 0
+	Maximum resident set size (kbytes): 70564
+	Average resident set size (kbytes): 0
+	Major (requiring I/O) page faults: 0
+	Minor (reclaiming a frame) page faults: 19407
+	Voluntary context switches: 0
+	Involuntary context switches: 939
+	Swaps: 0
+	File system inputs: 0
+	File system outputs: 0
+	Socket messages sent: 0
+	Socket messages received: 0
+	Signals delivered: 0
+	Page size (bytes): 16384
+	Exit status: 100
+
diff --git a/prism_benchmarks/memory/data/pipeline/rbi/2024-09-18-5df44846d.txt b/prism_benchmarks/memory/data/pipeline/rbi/2024-09-18-5df44846d.txt
@@ -0,0 +1,49 @@
+Command exited with non-zero status 100
+	Command being timed: "bazel-bin/main/sorbet --parser=prism ../../Shopify/rbi"
+	User time (seconds): 22.53
+	System time (seconds): 0.14
+	Percent of CPU this job got: 349%
+	Elapsed (wall clock) time (h:mm:ss or m:ss): 0:06.48
+	Average shared text size (kbytes): 0
+	Average unshared data size (kbytes): 0
+	Average stack size (kbytes): 0
+	Average total size (kbytes): 0
+	Maximum resident set size (kbytes): 125744
+	Average resident set size (kbytes): 0
+	Major (requiring I/O) page faults: 0
+	Minor (reclaiming a frame) page faults: 33529
+	Voluntary context switches: 164
+	Involuntary context switches: 6882
+	Swaps: 0
+	File system inputs: 0
+	File system outputs: 0
+	Socket messages sent: 0
+	Socket messages received: 0
+	Signals delivered: 0
+	Page size (bytes): 16384
+	Exit status: 100
+
+	Command being timed: "bazel-bin/main/sorbet --parser=sorbet ../../Shopify/rbi"
+	User time (seconds): 24.78
+	System time (seconds): 0.17
+	Percent of CPU this job got: 364%
+	Elapsed (wall clock) time (h:mm:ss or m:ss): 0:06.85
+	Average shared text size (kbytes): 0
+	Average unshared data size (kbytes): 0
+	Average stack size (kbytes): 0
+	Average total size (kbytes): 0
+	Maximum resident set size (kbytes): 134156
+	Average resident set size (kbytes): 0
+	Major (requiring I/O) page faults: 0
+	Minor (reclaiming a frame) page faults: 35155
+	Voluntary context switches: 0
+	Involuntary context switches: 5745
+	Swaps: 0
+	File system inputs: 0
+	File system outputs: 0
+	Socket messages sent: 0
+	Socket messages received: 0
+	Signals delivered: 0
+	Page size (bytes): 16384
+	Exit status: 0
+
diff --git a/prism_benchmarks/memory/run_benchmarks.sh b/prism_benchmarks/memory/run_benchmarks.sh
@@ -0,0 +1,67 @@
+#!/bin/bash
+
+# This script runs memory comparisons for the Prism parser in the Sorbet type checker.
+# It assumes the presence of a few directories and tools:
+# - The yjit-bench directory, which contains the benchmarks for YJIT (https://github.com/Shopify/yjit-bench)
+# - The Shopify directory, which contains the Shopify codebase (https://github.com/Shopify/shopify)
+# - gtime, a command-line time and memory analysis tool (https://www.gnu.org/software/time/)
+
+# ----- Setup -----
+
+YJIT_BENCH_DIR="../yjit-bench"
+SHOPIFY_DIR="../../Shopify/shopify"
+RBI_DIR="../../Shopify/rbi"
+
+export SORBET_SILENCE_DEV_MESSAGE=1
+
+# Check if required directories exist
+for dir in "$YJIT_BENCH_DIR" "$SHOPIFY_DIR" "$RBI_DIR"; do
+    if [ ! -d "$dir" ]; then
+        echo "Please clone the required directories before running this script."
+        exit 1
+    fi
+done
+
+# Check and install gtime if necessary
+if ! command -v gtime &> /dev/null; then
+    echo "Installing gtime..."
+    if [[ "$OSTYPE" == "darwin"* ]]; then
+        brew install gnu-time
+    else
+        echo "Please install gtime: https://www.gnu.org/software/time/"
+        exit 1
+    fi
+fi
+
+output_file_name="$(date '+%Y-%m-%d')-$(git rev-parse --short HEAD).txt"
+parsers=("prism" "sorbet")
+
+# ----- Run Benchmarks -----
+
+run_benchmark() {
+    local title="$1"
+    local output_dir="$2"
+    local command="$3"
+
+    echo "#### $title ####"
+    output_file="prism_benchmarks/memory/data/$output_dir/${output_file_name}"
+
+    for parser in "${parsers[@]}"; do
+        gtime --verbose --output="$output_file" --append \
+            bazel-bin/main/sorbet --parser=$parser $command &> /dev/null
+        echo "" >> "$output_file"
+        # Calculate peak memory usage:
+        # - Search for lines that contain peak memory usage info
+        # - Take the last one
+        # - Extract the memory usage value
+        # - Convert it to MB
+        peak_memory=$(grep "Maximum resident set size (kbytes):" "$output_file" | tail -n 1 | awk '{print $6/1024 " MB"}')
+        echo "-> Peak Memory Usage with $parser parser: $peak_memory"
+    done
+    echo ""
+}
+
+run_benchmark "Memory Check 1: yjit-bench, parser only" "parser/yjit-bench" "--stop-after=parser $YJIT_BENCH_DIR/benchmarks"
+run_benchmark "Memory Check 2: shopify, parser only" "parser/shopify" "--stop-after=parser $SHOPIFY_DIR"
+run_benchmark "Memory Check 3: prism regression tests, whole pipeline" "pipeline/prism_regression" "test/prism_regression"
+run_benchmark "Memory Check 4: RBI gem, whole pipeline" "pipeline/rbi" $RBI_DIR
diff --git a/prism_benchmarks/time/data/parser/sorbet-tests/2024-07-18-f75db5824.json b/prism_benchmarks/time/data/parser/sorbet-tests/2024-07-18-f75db5824.json
@@ -0,0 +1,78 @@
+{
+  "results": [
+    {
+      "command": "bazel-bin/main/sorbet --parser=sorbet --stop-after=parser test/testdata",
+      "mean": 10.0427811339,
+      "stddev": 0.025126222846626647,
+      "median": 10.0368188785,
+      "user": 15.975400439999998,
+      "system": 1.0591082200000002,
+      "min": 10.0078213055,
+      "max": 10.0817527725,
+      "times": [
+        10.0276461275,
+        10.0627562915,
+        10.0649185675,
+        10.0174194365,
+        10.0078213055,
+        10.0817527725,
+        10.0454906105,
+        10.0242698005,
+        10.0281471465,
+        10.0675892805
+      ],
+      "exit_codes": [
+        100,
+        100,
+        100,
+        100,
+        100,
+        100,
+        100,
+        100,
+        100,
+        100
+      ],
+      "parameters": {
+        "parser": "sorbet"
+      }
+    },
+    {
+      "command": "bazel-bin/main/sorbet --parser=prism --stop-after=parser test/testdata",
+      "mean": 9.028913599900001,
+      "stddev": 0.1174086729884074,
+      "median": 8.991058692,
+      "user": 12.66185554,
+      "system": 1.9508827199999998,
+      "min": 8.9338502675,
+      "max": 9.2513346015,
+      "times": [
+        8.9816991245,
+        9.041188655500001,
+        9.0004182595,
+        9.0065693535,
+        9.2513346015,
+        8.9599665045,
+        8.9354991625,
+        8.9459703115,
+        9.2326397585,
+        8.9338502675
+      ],
+      "exit_codes": [
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0
+      ],
+      "parameters": {
+        "parser": "prism"
+      }
+    }
+  ]
+}
diff --git a/prism_benchmarks/time/data/parser/sorbet-tests/2024-09-18-fe802b67a.json b/prism_benchmarks/time/data/parser/sorbet-tests/2024-09-18-fe802b67a.json
@@ -0,0 +1,78 @@
+{
+  "results": [
+    {
+      "command": "bazel-bin/main/sorbet --parser=sorbet --stop-after=parser test/testdata",
+      "mean": 5.30816793542,
+      "stddev": 0.008554918806646472,
+      "median": 5.30728540082,
+      "user": 11.338379319999998,
+      "system": 0.9336967399999999,
+      "min": 5.29577648882,
+      "max": 5.32004709582,
+      "times": [
+        5.30104430882,
+        5.30434597482,
+        5.29893825782,
+        5.31593376782,
+        5.31993879882,
+        5.30577622782,
+        5.29577648882,
+        5.32004709582,
+        5.30879457382,
+        5.31108385982
+      ],
+      "exit_codes": [
+        100,
+        100,
+        100,
+        100,
+        100,
+        100,
+        100,
+        100,
+        100,
+        100
+      ],
+      "parameters": {
+        "parser": "sorbet"
+      }
+    },
+    {
+      "command": "bazel-bin/main/sorbet --parser=prism --stop-after=parser test/testdata",
+      "mean": 4.86590450502,
+      "stddev": 0.011452274879975811,
+      "median": 4.86448913132,
+      "user": 8.30477872,
+      "system": 1.13498544,
+      "min": 4.85319106082,
+      "max": 4.89339179082,
+      "times": [
+        4.86646737282,
+        4.86645828082,
+        4.85319106082,
+        4.86291949182,
+        4.89339179082,
+        4.85785923482,
+        4.85783726082,
+        4.87515050282,
+        4.8660587708200005,
+        4.85971128382
+      ],
+      "exit_codes": [
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0
+      ],
+      "parameters": {
+        "parser": "prism"
+      }
+    }
+  ]
+}
diff --git a/prism_benchmarks/time/data/parser/yjit-bench/2024-07-18-f75db5824.json b/prism_benchmarks/time/data/parser/yjit-bench/2024-07-18-f75db5824.json
@@ -0,0 +1,78 @@
+{
+  "results": [
+    {
+      "command": "bazel-bin/main/sorbet --parser=sorbet --stop-after=parser ../yjit-bench/benchmarks",
+      "mean": 13.983836266140003,
+      "stddev": 0.3753695726271287,
+      "median": 13.88645245584,
+      "user": 22.976926319999997,
+      "system": 0.73527856,
+      "min": 13.451897627840001,
+      "max": 14.83432713384,
+      "times": [
+        13.451897627840001,
+        13.78587580584,
+        13.92110683084,
+        13.83593312984,
+        13.85179808084,
+        14.83432713384,
+        14.35947390984,
+        14.01668414084,
+        13.99022805084,
+        13.79103795084
+      ],
+      "exit_codes": [
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0
+      ],
+      "parameters": {
+        "parser": "sorbet"
+      }
+    },
+    {
+      "command": "bazel-bin/main/sorbet --parser=prism --stop-after=parser ../yjit-bench/benchmarks",
+      "mean": 8.63029390654,
+      "stddev": 0.1018242999685836,
+      "median": 8.59375904684,
+      "user": 11.002803519999997,
+      "system": 0.9380242599999999,
+      "min": 8.504474396840001,
+      "max": 8.85641065884,
+      "times": [
+        8.57078804984,
+        8.85641065884,
+        8.56780114184,
+        8.69831273484,
+        8.57807582284,
+        8.70291158584,
+        8.60944227084,
+        8.504474396840001,
+        8.65632465784,
+        8.55839774584
+      ],
+      "exit_codes": [
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0
+      ],
+      "parameters": {
+        "parser": "prism"
+      }
+    }
+  ]
+}
diff --git a/prism_benchmarks/time/data/parser/yjit-bench/2024-09-18-fe802b67a.json b/prism_benchmarks/time/data/parser/yjit-bench/2024-09-18-fe802b67a.json
@@ -0,0 +1,78 @@
+{
+  "results": [
+    {
+      "command": "bazel-bin/main/sorbet --parser=sorbet --stop-after=parser ../yjit-bench/benchmarks",
+      "mean": 6.25072342584,
+      "stddev": 0.1073974255052388,
+      "median": 6.19560604254,
+      "user": 16.251893579999994,
+      "system": 0.69604118,
+      "min": 6.16291310254,
+      "max": 6.44517373554,
+      "times": [
+        6.16291310254,
+        6.2626671075399996,
+        6.18448813654,
+        6.18419261454,
+        6.18531723254,
+        6.44517373554,
+        6.1749147535399995,
+        6.25796427854,
+        6.4437084445399995,
+        6.20589485254
+      ],
+      "exit_codes": [
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0
+      ],
+      "parameters": {
+        "parser": "sorbet"
+      }
+    },
+    {
+      "command": "bazel-bin/main/sorbet --parser=prism --stop-after=parser ../yjit-bench/benchmarks",
+      "mean": 4.478415396640001,
+      "stddev": 0.006773926630539733,
+      "median": 4.47716277004,
+      "user": 6.40941108,
+      "system": 0.7607843799999999,
+      "min": 4.47000373854,
+      "max": 4.49072622954,
+      "times": [
+        4.47028990954,
+        4.48113160654,
+        4.4784504395399996,
+        4.47585923954,
+        4.48715721954,
+        4.49072622954,
+        4.47000373854,
+        4.47375967154,
+        4.47587510054,
+        4.48090081154
+      ],
+      "exit_codes": [
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0
+      ],
+      "parameters": {
+        "parser": "prism"
+      }
+    }
+  ]
+}
diff --git a/prism_benchmarks/time/data/pipeline/prism_regression/2024-07-18-f75db5824.json b/prism_benchmarks/time/data/pipeline/prism_regression/2024-07-18-f75db5824.json
@@ -0,0 +1,78 @@
+{
+  "results": [
+    {
+      "command": "bazel-bin/main/sorbet --parser=sorbet test/prism_regression",
+      "mean": 0.84178919584,
+      "stddev": 0.008118653707744158,
+      "median": 0.83854312314,
+      "user": 1.59382048,
+      "system": 0.11926071999999999,
+      "min": 0.83163896114,
+      "max": 0.85557230614,
+      "times": [
+        0.83945907614,
+        0.83682301814,
+        0.85210590814,
+        0.83473545814,
+        0.85557230614,
+        0.83762717014,
+        0.83645661814,
+        0.84983627314,
+        0.84363716914,
+        0.83163896114
+      ],
+      "exit_codes": [
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0
+      ],
+      "parameters": {
+        "parser": "sorbet"
+      }
+    },
+    {
+      "command": "bazel-bin/main/sorbet --parser=prism test/prism_regression",
+      "mean": 0.8412279621400002,
+      "stddev": 0.007882902400181078,
+      "median": 0.83984855864,
+      "user": 1.61844638,
+      "system": 0.10229632,
+      "min": 0.8312792881400001,
+      "max": 0.85482773714,
+      "times": [
+        0.84042653414,
+        0.8312792881400001,
+        0.83306462914,
+        0.85482773714,
+        0.85185022614,
+        0.84023890714,
+        0.83664591814,
+        0.8480770171400001,
+        0.83945821014,
+        0.83641115414
+      ],
+      "exit_codes": [
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0
+      ],
+      "parameters": {
+        "parser": "prism"
+      }
+    }
+  ]
+}
diff --git a/prism_benchmarks/time/data/pipeline/prism_regression/2024-09-18-fe802b67a.json b/prism_benchmarks/time/data/pipeline/prism_regression/2024-09-18-fe802b67a.json
@@ -0,0 +1,78 @@
+{
+  "results": [
+    {
+      "command": "bazel-bin/main/sorbet --parser=sorbet test/prism_regression",
+      "mean": 1.74419526482,
+      "stddev": 0.069048868040311,
+      "median": 1.73331423512,
+      "user": 2.73193046,
+      "system": 0.13378163999999998,
+      "min": 1.6378026806200001,
+      "max": 1.84798413862,
+      "times": [
+        1.72125983862,
+        1.84798413862,
+        1.64443633762,
+        1.79690505062,
+        1.72480685162,
+        1.80412130462,
+        1.7226981556199998,
+        1.80011667162,
+        1.74182161862,
+        1.6378026806200001
+      ],
+      "exit_codes": [
+        100,
+        100,
+        100,
+        100,
+        100,
+        100,
+        100,
+        100,
+        100,
+        100
+      ],
+      "parameters": {
+        "parser": "sorbet"
+      }
+    },
+    {
+      "command": "bazel-bin/main/sorbet --parser=prism test/prism_regression",
+      "mean": 1.6491571758199997,
+      "stddev": 0.2075739536981031,
+      "median": 1.7204806501199998,
+      "user": 2.5753856599999994,
+      "system": 0.11331144,
+      "min": 1.07299557962,
+      "max": 1.80577517662,
+      "times": [
+        1.80577517662,
+        1.07299557962,
+        1.7247325946199998,
+        1.71462417062,
+        1.64513017262,
+        1.7240551876199999,
+        1.72276719362,
+        1.64053038262,
+        1.72107253662,
+        1.71988876362
+      ],
+      "exit_codes": [
+        100,
+        100,
+        100,
+        100,
+        100,
+        100,
+        100,
+        100,
+        100,
+        100
+      ],
+      "parameters": {
+        "parser": "prism"
+      }
+    }
+  ]
+}
diff --git a/prism_benchmarks/time/data/pipeline/rbi/2024-09-18-5df44846d.json b/prism_benchmarks/time/data/pipeline/rbi/2024-09-18-5df44846d.json
@@ -0,0 +1,78 @@
+{
+  "results": [
+    {
+      "command": "bazel-bin/main/sorbet --parser=sorbet ../rbi",
+      "mean": 6.16736409352,
+      "stddev": 0.06774821106573646,
+      "median": 6.15982815322,
+      "user": 21.81549374,
+      "system": 0.20507438000000003,
+      "min": 6.083021132720001,
+      "max": 6.28290752972,
+      "times": [
+        6.16744417972,
+        6.12050154872,
+        6.28290752972,
+        6.251253995720001,
+        6.11700055272,
+        6.15221212672,
+        6.083021132720001,
+        6.23237357272,
+        6.16752112172,
+        6.09940517472
+      ],
+      "exit_codes": [
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0
+      ],
+      "parameters": {
+        "parser": "sorbet"
+      }
+    },
+    {
+      "command": "bazel-bin/main/sorbet --parser=prism ../rbi",
+      "mean": 6.18529064662,
+      "stddev": 0.04775460831234028,
+      "median": 6.17915380222,
+      "user": 19.401574840000002,
+      "system": 0.18767527999999994,
+      "min": 6.12177066272,
+      "max": 6.282041295720001,
+      "times": [
+        6.12177066272,
+        6.13718851672,
+        6.282041295720001,
+        6.153297766720001,
+        6.15942091572,
+        6.22498076072,
+        6.19488676172,
+        6.221012181720001,
+        6.171952952720001,
+        6.18635465172
+      ],
+      "exit_codes": [
+        100,
+        100,
+        100,
+        100,
+        100,
+        100,
+        100,
+        100,
+        100,
+        100
+      ],
+      "parameters": {
+        "parser": "prism"
+      }
+    }
+  ]
+}
diff --git a/prism_benchmarks/time/run_benchmarks.sh b/prism_benchmarks/time/run_benchmarks.sh
@@ -0,0 +1,60 @@
+#!/bin/bash
+
+# This script runs the benchmarks for the Prism parser in the Sorbet type checker.
+# It assumes the presence of a few directories and tools:
+# - The yjit-bench directory, which contains the benchmarks for YJIT (https://github.com/Shopify/yjit-bench)
+# - The rbi directory, which contains the RBI gem (https://github.com/Shopify/rbi)
+# - Hyperfine, a command-line benchmarking tool (https://github.com/sharkdp/hyperfine)
+
+# ----- Setup -----
+
+YJIT_BENCH_DIR="../yjit-bench"
+RBI_DIR="../rbi"
+
+export SORBET_SILENCE_DEV_MESSAGE=1
+
+# Check if required directories exist
+for dir in "$YJIT_BENCH_DIR" "$RBI_DIR"; do
+  if [ ! -d "$dir" ]; then
+    echo "Please clone the required directories before running this script."
+    exit 1
+  fi
+done
+
+# Check if hyperfine is installed
+if [! command -v hyperfine >/dev/null 2>&1 ]; then
+  echo "Please install hyperfine before running this script: https://github.com/sharkdp/hyperfine"
+  exit 1
+fi
+
+# Enable globstar for recursive directory listing
+# This is for Bash 4.0 and later, which does not have recursive globbing enabled by default
+shopt -s globstar
+
+# Read all files in the benchmarks directory to warm up the file system cache
+for i in {1..10}; do
+  cat ../yjit-bench/benchmarks/**/*.rb > /dev/null
+  cat test/testdata/**/*.rb > /dev/null
+done
+
+output_file_name="$(date '+%Y-%m-%d')-$(git rev-parse --short HEAD).json"
+
+# ----- Run Benchmarks -----
+
+run_benchmark() {
+  local title="$1"
+  local output_dir="$2"
+  local command="$3"
+
+  echo "#### $title ####"
+  output_file="prism_benchmarks/time/data/$output_dir/${output_file_name}"
+
+  hyperfine \
+    --warmup=10 --export-json="$output_file" --parameter-list parser sorbet,prism \
+    "bazel-bin/main/sorbet --parser={parser} $command" --ignore-failure
+}
+
+run_benchmark "Benchmark 1: yjit-bench, parser only" "parser/yjit-bench" "--stop-after=parser $YJIT_BENCH_DIR/benchmarks"
+run_benchmark "Benchmark 2: sorbet-test, parser only" "parser/sorbet-tests" "--stop-after=parser test/testdata"
+run_benchmark "Benchmark 3: prism regression tests, whole pipeline" "pipeline/prism_regression" "test/prism_regression"
+run_benchmark "Benchmark 4: RBI gem, whole pipeline" "pipeline/rbi" "$RBI_DIR"
diff --git a/test/BUILD b/test/BUILD
@@ -121,6 +121,21 @@ sh_test(
     ],
 )
 
+# Load the macro that creates a test for every file in the prism_regression folder
+load("//test:prism_location_test.bzl", "prism_test_suite")
+
+# Run the macro
+prism_test_suite(
+    name = "prism_location_tests",
+    srcs = glob(["prism_regression/**/*.rb"]),
+)
+
+# Create a test suite to run all the location tests
+test_suite(
+    name = "prism_location_tests",
+    tags = ["prism_location_test"],
+)
+
 cc_test(
     name = "hello-test",
     size = "small",
@@ -240,6 +255,49 @@ pipeline_tests(
     "PosTests",
 )
 
+pipeline_tests(
+    "test_corpus_prism",
+    glob(
+        [
+            # Replace [parser] with other phases to test Prism at that level
+            # Phases: https://github.com/Shopify/sorbet/blob/prism/docs/internals.md#phases
+            "testdata/**/*.rb",
+            "testdata/**/*.exp",
+        ],
+        exclude = [
+            # Tests having to do with tree differences in invalid Ruby code; will address later
+            "testdata/parser/error_recovery/**",
+            "testdata/parser/crash_block_pass_suggestion.rb",
+            "testdata/parser/invalid_fatal.rb",
+            "testdata/parser/invalid_syntax_error.rb",
+            "testdata/parser/kwargs_missing_comma.rb",
+            "testdata/parser/kwnil_errors.rb", # See https://github.com/Shopify/sorbet/issues/393
+            "testdata/parser/misc.rb",
+            "testdata/parser/offset0.rb",
+            "testdata/parser/ruby_25.rb",
+            "testdata/parser/kwargs.rb",
+            "testdata/lsp/completion/bad_arguments.rb",
+            "testdata/lsp/completion/bad_list_elems.rb",
+            "testdata/lsp/completion/case_1.rb",
+            "testdata/lsp/completion/case_2.rb",
+            "testdata/lsp/completion/eof.rb",
+            "testdata/lsp/completion/missing_const_name.rb",
+            "testdata/lsp/completion/missing_fun.rb",
+            "testdata/lsp/completion/self_receiver.rb",
+            "testdata/lsp/duplicate_kwarg.rb",
+            "testdata/namer/fuzz_repeated_kwarg.rb",
+            "testdata/deviations/keyword_method_names.rb",
+            "testdata/rewriter/minitest_empty_test_each.rb",
+            "testdata/infer/crash_after_parse_errors.rb",
+
+            # Sorbets' parser incorrectly accepts invalid syntax
+            "testdata/desugar/pattern_matching_hash.rb", # See https://github.com/Shopify/sorbet/issues/362
+        ],
+    ),
+    "PosTests",
+    parser = "prism",
+)
+
 pipeline_tests(
     "whitequark_parser_corpus",
     glob([
@@ -262,16 +320,36 @@ pipeline_tests(
     extra_files = ["testdata/lsp/rubyfmt-stub/rubyfmt"],
 )
 
+pipeline_tests(
+    "prism_regression_corpus",
+    glob([
+        "prism_regression/**/*.rb",
+        "prism_regression/**/*.exp",
+    ]),
+    "PosTests",
+    parser = "prism",
+)
+
 test_suite(
     name = "test",
     tests = ["test_corpus"],
 )
 
+test_suite(
+    name = "test_prism",
+    tests = ["test_corpus_prism"],
+)
+
 test_suite(
     name = "whitequark_parser_tests",
     tests = ["whitequark_parser_corpus"],
 )
 
+test_suite(
+    name = "prism_regression",
+    tests = ["prism_regression_corpus"],
+)
+
 sh_binary(
     name = "single_package_runner",
     srcs = ["test_single_package_runner.sh"],

diff --git a/test/helpers/position_assertions.cc b/test/helpers/position_assertions.cc
@@ -58,6 +58,11 @@ template <typename T> bool isDuplicateDiagnostic(string_view filename, T *assert
 template <typename T>
 void reportMissingError(const string &filename, const T &assertion, string_view sourceLine, string_view errorPrefix,
                         bool missingDuplicate = false) {
+    // Skip error message checking when running with Prism.
+    if (sorbet::test::parser == realmain::options::Parser::PRISM) {
+        return;
+    }
+
     auto coreMessage = missingDuplicate ? "Error was not duplicated" : "Did not find expected error";
     auto messagePostfix = missingDuplicate ? "\nYou can fix this error by changing the assertion to `error:`." : "";
     ADD_FAIL_CHECK_AT(filename.c_str(), assertion.range->start->line + 1,
@@ -68,9 +73,15 @@ void reportMissingError(const string &filename, const T &assertion, string_view
 
 void reportUnexpectedError(const string &filename, const Diagnostic &diagnostic, string_view sourceLine,
                            string_view errorPrefix) {
+    // Skip error message checking when running with Prism.
+    if (sorbet::test::parser == realmain::options::Parser::PRISM) {
+        return;
+    }
+
     auto diagnosticMessage = (diagnostic.severity == DiagnosticSeverity::Information)
                                  ? fmt::format("untyped: {}", diagnostic.message)
                                  : fmt::format("error: {}", diagnostic.message);
+
     ADD_FAIL_CHECK_AT(
         filename.c_str(), diagnostic.range->start->line + 1,
         fmt::format(
@@ -482,6 +493,10 @@ string ErrorAssertion::toString() const {
 }
 
 bool ErrorAssertion::check(const Diagnostic &diagnostic, string_view sourceLine, string_view errorPrefix) {
+    // Skip error message checking when running with Prism.
+    if (sorbet::test::parser == realmain::options::Parser::PRISM) {
+        return true;
+    }
     // The error message must contain `message`.
     if (diagnostic.message.find(message) == string::npos) {
         ADD_FAIL_CHECK_AT(filename.c_str(), range->start->line + 1,

diff --git a/test/helpers/position_assertions.h b/test/helpers/position_assertions.h
@@ -9,6 +9,10 @@
 namespace sorbet::test {
 using namespace sorbet::realmain::lsp;
 
+// TODO: Remove this before upstreaming
+// This is needed to skip error assertions when running under Prism
+extern realmain::options::Parser parser;
+
 class ErrorAssertion;
 class UntypedAssertion;
 

diff --git a/test/pipeline_test.bzl b/test/pipeline_test.bzl
@@ -15,7 +15,7 @@ def dropExtension(p):
 _TEST_SCRIPT = """#!/usr/bin/env bash
 export ASAN_SYMBOLIZER_PATH=`pwd`/external/llvm_toolchain_15_0_7/bin/llvm-symbolizer
 set -x
-exec {runner} --single_test="{test}"
+exec {runner} --single_test="{test}" --parser="{parser}"
 """
 
 def _exp_test_impl(ctx):
@@ -24,6 +24,7 @@ def _exp_test_impl(ctx):
         content = _TEST_SCRIPT.format(
             runner = ctx.executable.runner.short_path,
             test = ctx.file.test.path,
+            parser = ctx.attr.parser,
         ),
     )
 
@@ -50,6 +51,7 @@ exp_test = rule(
         "_llvm_symbolizer": attr.label(
             default = "//test:llvm-symbolizer",
         ),
+        "parser": attr.string(default="sorbet"),
     },
 )
 
@@ -112,7 +114,7 @@ _TEST_RUNNERS = {
     "PackagerTests": ":pipeline_test_runner",
 }
 
-def pipeline_tests(suite_name, all_paths, test_name_prefix, extra_files = [], tags = []):
+def pipeline_tests(suite_name, all_paths, test_name_prefix, extra_files = [], tags = [], parser = "sorbet"):
     tests = {}  # test_name-> {"path": String, "prefix": String, "sentinel": String, "isPackage": bool}
 
     # The packager step needs folder-based steps since folder structure dictates package membership.
@@ -140,6 +142,14 @@ def pipeline_tests(suite_name, all_paths, test_name_prefix, extra_files = [], ta
                         "disabled": "disabled" in test_name,
                         "isPackage": True,
                     }
+
+                    # Tests that run with Prism parser need to have "_prism" appended to their name
+                    # to differentiate them from the tests that run with Sorbet parser.
+                    # The condition here is only for the packager tests
+                    # Other tests are handled below.
+                    if parser == "prism":
+                        test_name = test_name + "_prism"
+
                     tests[test_name] = data
                 continue
 
@@ -148,6 +158,11 @@ def pipeline_tests(suite_name, all_paths, test_name_prefix, extra_files = [], ta
 
         test_name = dirname(path) + "/" + prefix
 
+        # Tests that run with Prism parser need to have "_prism" appended to their name
+        # to differentiate them from the tests that run with Sorbet parser.
+        if parser == "prism":
+            test_name = test_name + "_prism"
+
         current = tests.get(test_name)
         if None == current:
             data = {
@@ -205,6 +220,7 @@ def pipeline_tests(suite_name, all_paths, test_name_prefix, extra_files = [], ta
             test = sentinel,
             size = "small",
             tags = tags + extra_tags,
+            parser = parser,
         )
 
     native.test_suite(

diff --git a/test/pipeline_test_runner.cc b/test/pipeline_test_runner.cc
@@ -59,6 +59,7 @@ namespace sorbet::test {
 using namespace std;
 
 string singleTest;
+realmain::options::Parser parser;
 
 constexpr string_view whitelistedTypedNoneTest = "missing_typed_sigil.rb"sv;
 constexpr string_view packageFileName = "__package.rb"sv;
@@ -84,15 +85,34 @@ class CFGCollectorAndTyper {
     }
 };
 
-UnorderedSet<string> knownExpectations = {"parse-tree",       "parse-tree-json",  "parse-tree-whitequark",
-                                          "desugar-tree",     "desugar-tree-raw", "rewrite-tree",
-                                          "rewrite-tree-raw", "index-tree",       "index-tree-raw",
-                                          "symbol-table",     "symbol-table-raw", "name-tree",
-                                          "name-tree-raw",    "resolve-tree",     "resolve-tree-raw",
-                                          "flatten-tree",     "flatten-tree-raw", "cfg",
-                                          "cfg-raw",          "cfg-text",         "autogen",
-                                          "document-symbols", "package-tree",     "document-formatting-rubyfmt",
-                                          "autocorrects",     "minimized-rbi",    "rbi-gen"};
+UnorderedSet<string> knownExpectations = {"parse-tree",
+                                          "parse-tree-json",
+                                          "parse-tree-json-with-locs",
+                                          "parse-tree-whitequark",
+                                          "desugar-tree",
+                                          "desugar-tree-raw",
+                                          "rewrite-tree",
+                                          "rewrite-tree-raw",
+                                          "index-tree",
+                                          "index-tree-raw",
+                                          "symbol-table",
+                                          "symbol-table-raw",
+                                          "name-tree",
+                                          "name-tree-raw",
+                                          "resolve-tree",
+                                          "resolve-tree-raw",
+                                          "flatten-tree",
+                                          "flatten-tree-raw",
+                                          "cfg",
+                                          "cfg-raw",
+                                          "cfg-text",
+                                          "autogen",
+                                          "document-symbols",
+                                          "package-tree",
+                                          "document-formatting-rubyfmt",
+                                          "autocorrects",
+                                          "minimized-rbi",
+                                          "rbi-gen"};
 
 ast::ParsedFile testSerialize(core::GlobalState &gs, ast::ParsedFile expr) {
     auto &savedFile = expr.file.data(gs);
@@ -202,17 +222,26 @@ vector<ast::ParsedFile> index(unique_ptr<core::GlobalState> &gs, absl::Span<core
         }
 
         unique_ptr<parser::Node> nodes;
-        {
-            core::UnfreezeNameTable nameTableAccess(*gs); // enters original strings
+        switch (parser) {
+            case realmain::options::Parser::SORBET: {
+                std::cout << "Parsing with sorbet" << std::endl;
+                core::UnfreezeNameTable nameTableAccess(*gs); // enters original strings
 
-            auto settings = parser::Parser::Settings{};
-            nodes = parser::Parser::run(*gs, file, settings);
+                auto settings = parser::Parser::Settings{};
+                nodes = parser::Parser::run(*gs, file, settings);
+                break;
+            }
+            case realmain::options::Parser::PRISM:
+                std::cout << "Parsing with prism" << std::endl;
+                nodes = realmain::pipeline::runPrismParser(*gs, file, false, {});
+                break;
         }
 
         handler.drainErrors(*gs);
         handler.addObserved(*gs, "parse-tree", [&]() { return nodes->toString(*gs); });
         handler.addObserved(*gs, "parse-tree-whitequark", [&]() { return nodes->toWhitequark(*gs); });
         handler.addObserved(*gs, "parse-tree-json", [&]() { return nodes->toJSON(*gs); });
+        handler.addObserved(*gs, "parse-tree-json-with-locs", [&]() { return nodes->toJSONWithLocs(*gs, file); });
 
         // Desugarer
         ast::ParsedFile desugared;
@@ -778,8 +807,15 @@ TEST_CASE("PerPhaseTest") { // NOLINT
         gs->replaceFile(f.file, move(newFile));
 
         // this replicates the logic of pipeline::indexOne
-        auto settings = parser::Parser::Settings{};
-        auto nodes = parser::Parser::run(*gs, f.file, settings);
+        unique_ptr<parser::Node> nodes;
+
+        if (parser == realmain::options::Parser::SORBET) {
+            auto settings = parser::Parser::Settings{};
+            nodes = parser::Parser::run(*gs, f.file, settings);
+        } else if (parser == realmain::options::Parser::PRISM) {
+            nodes = realmain::pipeline::runPrismParser(*gs, f.file, false, {});
+        }
+
         handler.addObserved(*gs, "parse-tree", [&]() { return nodes->toString(*gs); });
         handler.addObserved(*gs, "parse-tree-json", [&]() { return nodes->toJSON(*gs); });
 
@@ -870,6 +906,9 @@ int main(int argc, char *argv[]) {
     cxxopts::Options options("test_corpus", "Test corpus for Sorbet typechecker");
     options.allow_unrecognised_options().add_options()("single_test", "run over single test.",
                                                        cxxopts::value<std::string>()->default_value(""), "testpath");
+    options.allow_unrecognised_options().add_options()("parser", "The parser to use while testing.",
+                                                       cxxopts::value<std::string>()->default_value("sorbet"),
+                                                       "{prism, sorbet}");
     auto res = options.parse(argc, argv);
 
     if (res.count("single_test") != 1) {
@@ -879,6 +918,14 @@ int main(int argc, char *argv[]) {
 
     sorbet::test::singleTest = res["single_test"].as<std::string>();
 
+    std::string parserOpt = res["parser"].as<std::string>();
+    for (auto &known : sorbet::realmain::options::parser_options) {
+        if (known.option == parserOpt) {
+            sorbet::test::parser = known.flag;
+            break;
+        }
+    }
+
     doctest::Context context(argc, argv);
     return context.run();
 }
diff --git a/test/prism_location_test.bzl b/test/prism_location_test.bzl
@@ -0,0 +1,14 @@
+def prism_test_suite(name, srcs):
+    for src in srcs:
+        test_name = src.replace(".rb", "") + "_location_test"
+        native.sh_test(
+            name = test_name,
+            srcs = ["prism_location_test.sh"],
+            args = [src],
+            tags = ["prism_location_test"],
+            data = [
+                "//main:sorbet",
+                "@bazel_tools//tools/bash/runfiles",
+                src,
+            ],
+        )
diff --git a/test/prism_location_test.sh b/test/prism_location_test.sh
@@ -0,0 +1,42 @@
+#!/bin/bash
+
+set -euo pipefail
+
+# Set up the runfiles
+# shellcheck disable=SC1090
+source "${RUNFILES_DIR:-/dev/null}/bazel_tools/tools/bash/runfiles/runfiles.bash"
+if [[ ! -d "${RUNFILES_DIR:-/dev/null}" ]]; then
+  echo >&2 "ERROR: could not find runfiles directory"
+  exit 1
+fi
+
+# Locate the Sorbet binary
+SORBET_BIN="$(rlocation com_stripe_ruby_typer/main/sorbet)"
+TEST_DIR="$(rlocation com_stripe_ruby_typer/test)"
+
+# The Ruby file to test is passed as the first argument
+TEST_FILE="$1"
+
+# Temporary files to hold parser outputs
+sorbet_output_prism=$(mktemp)
+sorbet_output_sorbet=$(mktemp)
+
+set +e  # Temporarily disable exit on error
+# Run Sorbet with default parser
+"$SORBET_BIN" --print=parse-tree-json-with-locs --parser=sorbet "$TEST_DIR/$TEST_FILE" > "$sorbet_output_sorbet" 2>/dev/null
+# Run Sorbet with Prism parser
+"$SORBET_BIN" --print=parse-tree-json-with-locs --parser=prism "$TEST_DIR/$TEST_FILE" > "$sorbet_output_prism" 2>/dev/null
+set -e  # Re-enable exit on error
+
+# Compare outputs
+if ! diff -q "$sorbet_output_prism" "$sorbet_output_sorbet" >/dev/null 2>&1; then
+    echo "Test failed for $TEST_FILE"
+    echo "Differences:"
+    diff -u "$sorbet_output_sorbet" "$sorbet_output_prism"
+    rm "$sorbet_output_prism" "$sorbet_output_sorbet"
+    exit 1
+fi
+
+# Clean up temporary files
+rm "$sorbet_output_prism" "$sorbet_output_sorbet"
+echo "Test passed for $TEST_FILE"
diff --git a/test/prism_regression/alias.parse-tree.exp b/test/prism_regression/alias.parse-tree.exp
@@ -0,0 +1,28 @@
+Begin {
+  stmts = [
+    Alias {
+      from = Symbol {
+        val = <U new_method1>
+      }
+      to = Symbol {
+        val = <U new_method1>
+      }
+    }
+    Alias {
+      from = Symbol {
+        val = <U new_method2>
+      }
+      to = Symbol {
+        val = <U new_method2>
+      }
+    }
+    Alias {
+      from = GVar {
+        name = <U $new_global>
+      }
+      to = GVar {
+        name = <U $old_global>
+      }
+    }
+  ]
+}
diff --git a/test/prism_regression/alias.rb b/test/prism_regression/alias.rb
@@ -0,0 +1,10 @@
+# typed: false
+
+alias new_method1 new_method1 # Works with bare references
+
+alias :new_method2 :new_method2 # Works with Symbols
+
+# `alias` can't be used with instance and class variables
+# alias @new_ivar @old_ivar
+# alias @@new_cvar @@old_cvar
+alias $new_global $old_global # Works with global variables
diff --git a/test/prism_regression/assign_to_class_variable.parse-tree.exp b/test/prism_regression/assign_to_class_variable.parse-tree.exp
@@ -0,0 +1,140 @@
+Begin {
+  stmts = [
+    Assign {
+      lhs = CVarLhs {
+        name = <U @@regular>
+      }
+      rhs = Integer {
+        val = "1"
+      }
+    }
+    OpAsgn {
+      left = CVarLhs {
+        name = <U @@bitwise_and>
+      }
+      op = <U &>
+      right = Integer {
+        val = "2"
+      }
+    }
+    OpAsgn {
+      left = CVarLhs {
+        name = <U @@bitwise_xor>
+      }
+      op = <U ^>
+      right = Integer {
+        val = "4"
+      }
+    }
+    OpAsgn {
+      left = CVarLhs {
+        name = <U @@shift_right>
+      }
+      op = <U >>>
+      right = Integer {
+        val = "5"
+      }
+    }
+    OpAsgn {
+      left = CVarLhs {
+        name = <U @@shift_left>
+      }
+      op = <U <<>
+      right = Integer {
+        val = "6"
+      }
+    }
+    OpAsgn {
+      left = CVarLhs {
+        name = <U @@subtract_assign>
+      }
+      op = <U ->
+      right = Integer {
+        val = "7"
+      }
+    }
+    OpAsgn {
+      left = CVarLhs {
+        name = <U @@module_assign>
+      }
+      op = <U %>
+      right = Integer {
+        val = "8"
+      }
+    }
+    OpAsgn {
+      left = CVarLhs {
+        name = <U @@bitwise_or>
+      }
+      op = <U |>
+      right = Integer {
+        val = "9"
+      }
+    }
+    OpAsgn {
+      left = CVarLhs {
+        name = <U @@divide_assign>
+      }
+      op = <U />
+      right = Integer {
+        val = "10"
+      }
+    }
+    OpAsgn {
+      left = CVarLhs {
+        name = <U @@multiply_assign>
+      }
+      op = <U *>
+      right = Integer {
+        val = "11"
+      }
+    }
+    OpAsgn {
+      left = CVarLhs {
+        name = <U @@exponentiate_assign>
+      }
+      op = <U **>
+      right = Integer {
+        val = "12"
+      }
+    }
+    AndAsgn {
+      left = CVarLhs {
+        name = <U @@lazy_and_assign>
+      }
+      right = Integer {
+        val = "13"
+      }
+    }
+    OrAsgn {
+      left = CVarLhs {
+        name = <U @@lazy_or_assgin>
+      }
+      right = Integer {
+        val = "14"
+      }
+    }
+    Masgn {
+      lhs = Mlhs {
+        exprs = [
+          CVarLhs {
+            name = <U @@target1>
+          }
+          CVarLhs {
+            name = <U @@target2>
+          }
+        ]
+      }
+      rhs = Array {
+        elts = [
+          Integer {
+            val = "15"
+          }
+          Integer {
+            val = "16"
+          }
+        ]
+      }
+    }
+  ]
+}
diff --git a/test/prism_regression/assign_to_class_variable.rb b/test/prism_regression/assign_to_class_variable.rb
@@ -0,0 +1,23 @@
+# typed: false
+
+# Regular assignment
+@@regular = 1
+
+# Compound assignment operators
+@@bitwise_and &= 2
+@@bitwise_xor ^= 4
+@@shift_right >>= 5
+@@shift_left <<= 6
+@@subtract_assign -= 7
+@@module_assign %= 8
+@@bitwise_or |= 9
+@@divide_assign /= 10
+@@multiply_assign *= 11
+@@exponentiate_assign **= 12
+
+# Special cases
+@@lazy_and_assign &&= 13
+@@lazy_or_assgin ||= 14
+
+# Multi-target assignment
+@@target1, @@target2 = 15, 16
diff --git a/test/prism_regression/assign_to_constant.parse-tree.exp b/test/prism_regression/assign_to_constant.parse-tree.exp
diff --git a/test/prism_regression/assign_to_constant.rb b/test/prism_regression/assign_to_constant.rb
@@ -0,0 +1,96 @@
+# typed: false
+
+# Regular assignment
+REGULAR = 1
+
+# Compound assignment operators
+BITWISE_AND &= 2
+BITWISE_XOR ^= 4
+SHIFT_RIGHT >>= 5
+SHIFT_LEFT <<= 6
+SUBTRACT_ASSIGN -= 7
+MODULE_ASSIGN %= 8
+BITWISE_OR |= 9
+DIVIDE_ASSIGN /= 10
+MULTIPLY_ASSIGN *= 11
+EXPONENTIATE_ASSIGN **= 12
+
+# Special cases
+LAZY_AND_ASSIGN &&= 13
+LAZY_OR_ASSGIN ||= 14
+
+# Multi-target assignment
+TARGET1, TARGET2 = 29, 30
+
+### Constant paths
+
+# Regular assignment
+ConstantPath::REGULAR = 15
+::FullyQualified::ConstantPath::REGULAR = 16
+
+# # Compound assignment operators
+ConstantPath::BITWISE_AND &= 17
+ConstantPath::BITWISE_XOR ^= 18
+ConstantPath::SHIFT_RIGHT >>= 19
+ConstantPath::SHIFT_LEFT <<= 20
+ConstantPath::SUBTRACT_ASSIGN -= 21
+ConstantPath::MODULE_ASSIGN %= 22
+ConstantPath::BITWISE_OR |= 23
+ConstantPath::DIVIDE_ASSIGN /= 24
+ConstantPath::MULTIPLY_ASSIGN *= 25
+ConstantPath::EXPONENTIATE_ASSIGN **= 26
+
+# Special cases
+ConstantPath::LAZY_AND_ASSIGN &&= 27
+ConstantPath::LAZY_OR_ASSGIN ||= 28
+
+# Multi-target assignment
+ConstantPath::TARGET1, ConstantPath::TARGET2 = 31, 32
+::ConstantPath::TARGET1, ::ConstantPath::TARGET2 = 33, 34
+
+# Dynamic constant assignments
+
+def method1
+  DynamicConstant = "These should all raise SyntaxErrors at runtime"
+
+  DynamicConstantBitwiseAnd &= 2
+  DynamicConstantBitwiseXor ^= 4
+  DynamicConstantShiftRight >>= 5
+  DynamicConstantShiftLeft <<= 6
+  DynamicConstantSubtractAssign -= 7
+  DynamicConstantModuleAssign %= 8
+  DynamicConstantBitwiseOr |= 9
+  DynamicConstantDivideAssign /= 10
+  DynamicConstantMultiplyAssign *= 11
+  DynamicConstantExponentiateAssign **= 12
+
+  # Special cases
+  DynamicConstantLazyAndAssign &&= 13
+  DynamicConstantLazyOrAssgin ||= 14
+
+  # Sorbet doesn't do the dynamic constant workaround for multi-target assignments
+  # DynamicConstantTarget1, DynamicConstantTarget2 = 35, 36
+end
+
+def method2
+  ConstantPath::DynamicConstant2 = "This should raise a SyntaxError at runtime"
+
+  # These should *NOT* raise a SyntaxError at runtime
+  ConstantPath::DynamicConstantBitwiseAnd &= 2
+  ConstantPath::DynamicConstantBitwiseXor ^= 4
+  ConstantPath::DynamicConstantShiftRight >>= 5
+  ConstantPath::DynamicConstantShiftLeft <<= 6
+  ConstantPath::DynamicConstantSubtractAssign -= 7
+  ConstantPath::DynamicConstantModuleAssign %= 8
+  ConstantPath::DynamicConstantBitwiseOr |= 9
+  ConstantPath::DynamicConstantDivideAssign /= 10
+  ConstantPath::DynamicConstantMultiplyAssign *= 11
+  ConstantPath::DynamicConstantExponentiateAssign **= 12
+
+  # And / Or assignment; still should not raise a syntax error
+  ConstantPath::DynamicConstantLazyAndAssign &&= 13
+  ConstantPath::DynamicConstantLazyOrAssgin ||= 14
+
+  # Sorbet doesn't do the dynamic constant workaround for multi-target assignments
+  # ConstantPath::DynamicConstantTarget1, ConstantPath::DynamicConstantTarget2 = 35, 36
+end
diff --git a/test/prism_regression/assign_to_global_variable.parse-tree.exp b/test/prism_regression/assign_to_global_variable.parse-tree.exp
@@ -0,0 +1,140 @@
+Begin {
+  stmts = [
+    Assign {
+      lhs = GVarLhs {
+        name = <U $regular>
+      }
+      rhs = Integer {
+        val = "1"
+      }
+    }
+    OpAsgn {
+      left = GVarLhs {
+        name = <U $bitwise_and>
+      }
+      op = <U &>
+      right = Integer {
+        val = "2"
+      }
+    }
+    OpAsgn {
+      left = GVarLhs {
+        name = <U $bitwise_xor>
+      }
+      op = <U ^>
+      right = Integer {
+        val = "4"
+      }
+    }
+    OpAsgn {
+      left = GVarLhs {
+        name = <U $shift_right>
+      }
+      op = <U >>>
+      right = Integer {
+        val = "5"
+      }
+    }
+    OpAsgn {
+      left = GVarLhs {
+        name = <U $shift_left>
+      }
+      op = <U <<>
+      right = Integer {
+        val = "6"
+      }
+    }
+    OpAsgn {
+      left = GVarLhs {
+        name = <U $subtract_assign>
+      }
+      op = <U ->
+      right = Integer {
+        val = "7"
+      }
+    }
+    OpAsgn {
+      left = GVarLhs {
+        name = <U $module_assign>
+      }
+      op = <U %>
+      right = Integer {
+        val = "8"
+      }
+    }
+    OpAsgn {
+      left = GVarLhs {
+        name = <U $bitwise_or>
+      }
+      op = <U |>
+      right = Integer {
+        val = "9"
+      }
+    }
+    OpAsgn {
+      left = GVarLhs {
+        name = <U $divide_assign>
+      }
+      op = <U />
+      right = Integer {
+        val = "10"
+      }
+    }
+    OpAsgn {
+      left = GVarLhs {
+        name = <U $multiply_assign>
+      }
+      op = <U *>
+      right = Integer {
+        val = "11"
+      }
+    }
+    OpAsgn {
+      left = GVarLhs {
+        name = <U $exponentiate_assign>
+      }
+      op = <U **>
+      right = Integer {
+        val = "12"
+      }
+    }
+    AndAsgn {
+      left = GVarLhs {
+        name = <U $lazy_and_assign>
+      }
+      right = Integer {
+        val = "13"
+      }
+    }
+    OrAsgn {
+      left = GVarLhs {
+        name = <U $lazy_or_assgin>
+      }
+      right = Integer {
+        val = "14"
+      }
+    }
+    Masgn {
+      lhs = Mlhs {
+        exprs = [
+          GVarLhs {
+            name = <U $target1>
+          }
+          GVarLhs {
+            name = <U $target2>
+          }
+        ]
+      }
+      rhs = Array {
+        elts = [
+          Integer {
+            val = "15"
+          }
+          Integer {
+            val = "16"
+          }
+        ]
+      }
+    }
+  ]
+}
diff --git a/test/prism_regression/assign_to_global_variable.rb b/test/prism_regression/assign_to_global_variable.rb
@@ -0,0 +1,23 @@
+# typed: false
+
+# Regular assignment
+$regular = 1
+
+# Compound assignment operators
+$bitwise_and &= 2
+$bitwise_xor ^= 4
+$shift_right >>= 5
+$shift_left <<= 6
+$subtract_assign -= 7
+$module_assign %= 8
+$bitwise_or |= 9
+$divide_assign /= 10
+$multiply_assign *= 11
+$exponentiate_assign **= 12
+
+# Special cases
+$lazy_and_assign &&= 13
+$lazy_or_assgin ||= 14
+
+# Multi-target assignment
+$target1, $target2 = 15, 16
diff --git a/test/prism_regression/assign_to_index.parse-tree.exp b/test/prism_regression/assign_to_index.parse-tree.exp
diff --git a/test/prism_regression/assign_to_index.rb b/test/prism_regression/assign_to_index.rb
@@ -0,0 +1,45 @@
+# typed: false
+
+# Regular assignment
+regular[0] = 1
+
+# Compound assignment operators
+bitwise_and[0] &= 2
+bitwise_xor[0] ^= 4
+shift_right[0] >>= 5
+shift_left[0] <<= 6
+subtract_assign[0] -= 7
+module_assign[0] %= 8
+bitwise_or[0] |= 9
+divide_assign[0] /= 10
+multiply_assign[0] *= 11
+exponentiate_assign[0] **= 12
+
+# Special cases
+lazy_and_assign[0] &&= 13
+lazy_or_assign[0] ||= 14
+
+# Multi-target assignment
+target[0], target[1] = 15, 16
+target[2, 3], target[4, 5] = 17, 18, 19, 20
+target[] = 21 # Yes, this is valid. You can have `def []=(only_one_param)`.
+
+# Assign to index with a block
+# Note: this is technically not valid Ruby, but Prism allows it.
+
+bitwise_and[&blk] &= 2
+bitwise_xor[&blk] ^= 4
+shift_right[&blk] >>= 5
+shift_left[&blk] <<= 6
+subtract_assign[&blk] -= 7
+module_assign[&blk] %= 8
+bitwise_or[&blk] |= 9
+divide_assign[&blk] /= 10
+multiply_assign[&blk] *= 11
+exponentiate_assign[&blk] **= 12
+
+lazy_and_assign[&blk] &&= 13
+lazy_or_assign[&blk] ||= 14
+
+
+target[&blk], target[1] = 4
diff --git a/test/prism_regression/assign_to_instance_variable.parse-tree.exp b/test/prism_regression/assign_to_instance_variable.parse-tree.exp
@@ -0,0 +1,140 @@
+Begin {
+  stmts = [
+    Assign {
+      lhs = IVarLhs {
+        name = <U @regular>
+      }
+      rhs = Integer {
+        val = "1"
+      }
+    }
+    OpAsgn {
+      left = IVarLhs {
+        name = <U @bitwise_and>
+      }
+      op = <U &>
+      right = Integer {
+        val = "2"
+      }
+    }
+    OpAsgn {
+      left = IVarLhs {
+        name = <U @bitwise_xor>
+      }
+      op = <U ^>
+      right = Integer {
+        val = "4"
+      }
+    }
+    OpAsgn {
+      left = IVarLhs {
+        name = <U @shift_right>
+      }
+      op = <U >>>
+      right = Integer {
+        val = "5"
+      }
+    }
+    OpAsgn {
+      left = IVarLhs {
+        name = <U @shift_left>
+      }
+      op = <U <<>
+      right = Integer {
+        val = "6"
+      }
+    }
+    OpAsgn {
+      left = IVarLhs {
+        name = <U @subtract_assign>
+      }
+      op = <U ->
+      right = Integer {
+        val = "7"
+      }
+    }
+    OpAsgn {
+      left = IVarLhs {
+        name = <U @module_assign>
+      }
+      op = <U %>
+      right = Integer {
+        val = "8"
+      }
+    }
+    OpAsgn {
+      left = IVarLhs {
+        name = <U @bitwise_or>
+      }
+      op = <U |>
+      right = Integer {
+        val = "9"
+      }
+    }
+    OpAsgn {
+      left = IVarLhs {
+        name = <U @divide_assign>
+      }
+      op = <U />
+      right = Integer {
+        val = "10"
+      }
+    }
+    OpAsgn {
+      left = IVarLhs {
+        name = <U @multiply_assign>
+      }
+      op = <U *>
+      right = Integer {
+        val = "11"
+      }
+    }
+    OpAsgn {
+      left = IVarLhs {
+        name = <U @exponentiate_assign>
+      }
+      op = <U **>
+      right = Integer {
+        val = "12"
+      }
+    }
+    AndAsgn {
+      left = IVarLhs {
+        name = <U @lazy_and_assign>
+      }
+      right = Integer {
+        val = "13"
+      }
+    }
+    OrAsgn {
+      left = IVarLhs {
+        name = <U @lazy_or_assgin>
+      }
+      right = Integer {
+        val = "14"
+      }
+    }
+    Masgn {
+      lhs = Mlhs {
+        exprs = [
+          IVarLhs {
+            name = <U @target1>
+          }
+          IVarLhs {
+            name = <U @target2>
+          }
+        ]
+      }
+      rhs = Array {
+        elts = [
+          Integer {
+            val = "15"
+          }
+          Integer {
+            val = "16"
+          }
+        ]
+      }
+    }
+  ]
+}
diff --git a/test/prism_regression/assign_to_instance_variable.rb b/test/prism_regression/assign_to_instance_variable.rb
@@ -0,0 +1,23 @@
+# typed: false
+
+# Regular assignment
+@regular = 1
+
+# Compound assignment operators
+@bitwise_and &= 2
+@bitwise_xor ^= 4
+@shift_right >>= 5
+@shift_left <<= 6
+@subtract_assign -= 7
+@module_assign %= 8
+@bitwise_or |= 9
+@divide_assign /= 10
+@multiply_assign *= 11
+@exponentiate_assign **= 12
+
+# Special cases
+@lazy_and_assign &&= 13
+@lazy_or_assgin ||= 14
+
+# Multi-target assignment
+@target1, @target2 = 15, 16
diff --git a/test/prism_regression/assign_to_local_variable.parse-tree.exp b/test/prism_regression/assign_to_local_variable.parse-tree.exp
@@ -0,0 +1,140 @@
+Begin {
+  stmts = [
+    Assign {
+      lhs = LVarLhs {
+        name = <U regular>
+      }
+      rhs = Integer {
+        val = "1"
+      }
+    }
+    OpAsgn {
+      left = LVarLhs {
+        name = <U bitwise_and>
+      }
+      op = <U &>
+      right = Integer {
+        val = "2"
+      }
+    }
+    OpAsgn {
+      left = LVarLhs {
+        name = <U bitwise_xor>
+      }
+      op = <U ^>
+      right = Integer {
+        val = "4"
+      }
+    }
+    OpAsgn {
+      left = LVarLhs {
+        name = <U shift_right>
+      }
+      op = <U >>>
+      right = Integer {
+        val = "5"
+      }
+    }
+    OpAsgn {
+      left = LVarLhs {
+        name = <U shift_left>
+      }
+      op = <U <<>
+      right = Integer {
+        val = "6"
+      }
+    }
+    OpAsgn {
+      left = LVarLhs {
+        name = <U subtract_assign>
+      }
+      op = <U ->
+      right = Integer {
+        val = "7"
+      }
+    }
+    OpAsgn {
+      left = LVarLhs {
+        name = <U module_assign>
+      }
+      op = <U %>
+      right = Integer {
+        val = "8"
+      }
+    }
+    OpAsgn {
+      left = LVarLhs {
+        name = <U bitwise_or>
+      }
+      op = <U |>
+      right = Integer {
+        val = "9"
+      }
+    }
+    OpAsgn {
+      left = LVarLhs {
+        name = <U divide_assign>
+      }
+      op = <U />
+      right = Integer {
+        val = "10"
+      }
+    }
+    OpAsgn {
+      left = LVarLhs {
+        name = <U multiply_assign>
+      }
+      op = <U *>
+      right = Integer {
+        val = "11"
+      }
+    }
+    OpAsgn {
+      left = LVarLhs {
+        name = <U exponentiate_assign>
+      }
+      op = <U **>
+      right = Integer {
+        val = "12"
+      }
+    }
+    AndAsgn {
+      left = LVarLhs {
+        name = <U lazy_and_assign>
+      }
+      right = Integer {
+        val = "13"
+      }
+    }
+    OrAsgn {
+      left = LVarLhs {
+        name = <U lazy_or_assgin>
+      }
+      right = Integer {
+        val = "14"
+      }
+    }
+    Masgn {
+      lhs = Mlhs {
+        exprs = [
+          LVarLhs {
+            name = <U target1>
+          }
+          LVarLhs {
+            name = <U target2>
+          }
+        ]
+      }
+      rhs = Array {
+        elts = [
+          Integer {
+            val = "15"
+          }
+          Integer {
+            val = "16"
+          }
+        ]
+      }
+    }
+  ]
+}
diff --git a/test/prism_regression/assign_to_local_variable.rb b/test/prism_regression/assign_to_local_variable.rb
@@ -0,0 +1,23 @@
+# typed: false
+
+# Regular assignment
+regular = 1
+
+# Compound assignment operators
+bitwise_and &= 2
+bitwise_xor ^= 4
+shift_right >>= 5
+shift_left <<= 6
+subtract_assign -= 7
+module_assign %= 8
+bitwise_or |= 9
+divide_assign /= 10
+multiply_assign *= 11
+exponentiate_assign **= 12
+
+# Special cases
+lazy_and_assign &&= 13
+lazy_or_assgin ||= 14
+
+# Multi-target assignment
+target1, target2 = 15, 16
diff --git a/test/prism_regression/assign_to_method_result.parse-tree.exp b/test/prism_regression/assign_to_method_result.parse-tree.exp
@@ -0,0 +1,228 @@
+Begin {
+  stmts = [
+    Send {
+      receiver = Self {
+      }
+      method = <U m=>
+      args = [
+        Integer {
+          val = "1"
+        }
+      ]
+    }
+    OpAsgn {
+      left = Send {
+        receiver = Self {
+        }
+        method = <U m>
+        args = [
+        ]
+      }
+      op = <U &>
+      right = Integer {
+        val = "2"
+      }
+    }
+    OpAsgn {
+      left = Send {
+        receiver = Self {
+        }
+        method = <U m>
+        args = [
+        ]
+      }
+      op = <U ^>
+      right = Integer {
+        val = "4"
+      }
+    }
+    OpAsgn {
+      left = Send {
+        receiver = Self {
+        }
+        method = <U m>
+        args = [
+        ]
+      }
+      op = <U >>>
+      right = Integer {
+        val = "5"
+      }
+    }
+    OpAsgn {
+      left = Send {
+        receiver = Self {
+        }
+        method = <U m>
+        args = [
+        ]
+      }
+      op = <U <<>
+      right = Integer {
+        val = "6"
+      }
+    }
+    OpAsgn {
+      left = Send {
+        receiver = Self {
+        }
+        method = <U m>
+        args = [
+        ]
+      }
+      op = <U ->
+      right = Integer {
+        val = "7"
+      }
+    }
+    OpAsgn {
+      left = Send {
+        receiver = Self {
+        }
+        method = <U m>
+        args = [
+        ]
+      }
+      op = <U %>
+      right = Integer {
+        val = "8"
+      }
+    }
+    OpAsgn {
+      left = Send {
+        receiver = Self {
+        }
+        method = <U m>
+        args = [
+        ]
+      }
+      op = <U |>
+      right = Integer {
+        val = "9"
+      }
+    }
+    OpAsgn {
+      left = Send {
+        receiver = Self {
+        }
+        method = <U m>
+        args = [
+        ]
+      }
+      op = <U />
+      right = Integer {
+        val = "10"
+      }
+    }
+    OpAsgn {
+      left = Send {
+        receiver = Self {
+        }
+        method = <U m>
+        args = [
+        ]
+      }
+      op = <U *>
+      right = Integer {
+        val = "11"
+      }
+    }
+    OpAsgn {
+      left = Send {
+        receiver = Self {
+        }
+        method = <U m>
+        args = [
+        ]
+      }
+      op = <U **>
+      right = Integer {
+        val = "12"
+      }
+    }
+    AndAsgn {
+      left = Send {
+        receiver = Self {
+        }
+        method = <U m>
+        args = [
+        ]
+      }
+      right = Integer {
+        val = "13"
+      }
+    }
+    OrAsgn {
+      left = Send {
+        receiver = Self {
+        }
+        method = <U m>
+        args = [
+        ]
+      }
+      right = Integer {
+        val = "14"
+      }
+    }
+    Masgn {
+      lhs = Mlhs {
+        exprs = [
+          Send {
+            receiver = Self {
+            }
+            method = <U target1=>
+            args = [
+            ]
+          }
+          Send {
+            receiver = Self {
+            }
+            method = <U target2=>
+            args = [
+            ]
+          }
+        ]
+      }
+      rhs = Array {
+        elts = [
+          Integer {
+            val = "15"
+          }
+          Integer {
+            val = "16"
+          }
+        ]
+      }
+    }
+    Masgn {
+      lhs = Mlhs {
+        exprs = [
+          CSend {
+            receiver = Self {
+            }
+            method = <U target1=>
+            args = [
+            ]
+          }
+          CSend {
+            receiver = Self {
+            }
+            method = <U target2=>
+            args = [
+            ]
+          }
+        ]
+      }
+      rhs = Array {
+        elts = [
+          Integer {
+            val = "17"
+          }
+          Integer {
+            val = "18"
+          }
+        ]
+      }
+    }
+  ]
+}
diff --git a/test/prism_regression/assign_to_method_result.rb b/test/prism_regression/assign_to_method_result.rb
@@ -0,0 +1,24 @@
+# typed: false
+
+# Regular assignment
+self.m = 1
+
+# Compound assignment operators
+self.m &= 2
+self.m ^= 4
+self.m >>= 5
+self.m <<= 6
+self.m -= 7
+self.m %= 8
+self.m |= 9
+self.m /= 10
+self.m *= 11
+self.m **= 12
+
+# Special cases
+self.m &&= 13
+self.m ||= 14
+
+# Multi-target assignment
+self.target1, self.target2 = 15, 16
+self&.target1, self&.target2 = 17, 18 # Not valid Ruby, but the parser needs to support it for the diagnostics to work
diff --git a/test/prism_regression/assoc_splat.parse-tree.exp b/test/prism_regression/assoc_splat.parse-tree.exp
@@ -0,0 +1,59 @@
+Begin {
+  stmts = [
+    Hash {
+      kwargs = false
+      pairs = [
+        Kwsplat {
+          expr = Send {
+            receiver = NULL
+            method = <U foo>
+            args = [
+            ]
+          }
+        }
+      ]
+    }
+    Hash {
+      kwargs = false
+      pairs = [
+        Pair {
+          key = Symbol {
+            val = <U a>
+          }
+          value = Integer {
+            val = "1"
+          }
+        }
+        Kwsplat {
+          expr = Send {
+            receiver = NULL
+            method = <U foo>
+            args = [
+            ]
+          }
+        }
+      ]
+    }
+    Hash {
+      kwargs = false
+      pairs = [
+        Kwsplat {
+          expr = Send {
+            receiver = NULL
+            method = <U foo>
+            args = [
+            ]
+          }
+        }
+        Pair {
+          key = Symbol {
+            val = <U a>
+          }
+          value = Integer {
+            val = "1"
+          }
+        }
+      ]
+    }
+  ]
+}
diff --git a/test/prism_regression/assoc_splat.rb b/test/prism_regression/assoc_splat.rb
@@ -0,0 +1,7 @@
+# typed: false
+
+{ **foo }
+
+# with other hash keys
+{ a: 1, **foo }
+{ **foo, a: 1 }
@@ -0,0 +1,57 @@
+Begin {
+  stmts = [
+    Backref {
+      name = <U $&>
+    }
+    Backref {
+      name = <U $`>
+    }
+    Backref {
+      name = <U $'>
+    }
+    Backref {
+      name = <U $+>
+    }
+    If {
+      condition = Send {
+        receiver = String {
+          val = <U foobar>
+        }
+        method = <U =~>
+        args = [
+          Regexp {
+            regex = [
+              String {
+                val = <U foo(.*)>
+              }
+            ]
+            opts = Regopt {
+              opts = ""
+            }
+          }
+        ]
+      }
+      then_ = Send {
+        receiver = NULL
+        method = <U puts>
+        args = [
+          DString {
+            nodes = [
+              String {
+                val = <U The last matching word was >
+              }
+              Begin {
+                stmts = [
+                  Backref {
+                    name = <U $+>
+                  }
+                ]
+              }
+            ]
+          }
+        ]
+      }
+      else_ = NULL
+    }
+  ]
+}
@@ -0,0 +1,18 @@
+# typed: false
+
+# The result of the last match
+$&
+
+# The string preceding the match in the last match
+$`
+
+# The string following the match in the last match
+$'
+
+# The results of the highest-numbered group matched
+$+
+
+# In context
+if "foobar" =~ /foo(.*)/ then
+  puts "The last matching word was #{$+}"
+end
@@ -0,0 +1,21 @@
+Begin {
+  stmts = [
+    Kwbegin {
+      stmts = [
+        Integer {
+          val = "1"
+        }
+        Integer {
+          val = "2"
+        }
+        Integer {
+          val = "3"
+        }
+      ]
+    }
+    Kwbegin {
+      stmts = [
+      ]
+    }
+  ]
+}
@@ -0,0 +1,10 @@
+# typed: false
+
+begin
+  1
+  2
+  3
+end
+
+begin
+end
@@ -0,0 +1,26 @@
+Begin {
+  stmts = [
+    While {
+      cond = True {
+      }
+      body = Break {
+        exprs = [
+          Send {
+            receiver = NULL
+            method = <U foo>
+            args = [
+            ]
+          }
+        ]
+      }
+    }
+    While {
+      cond = True {
+      }
+      body = Break {
+        exprs = [
+        ]
+      }
+    }
+  ]
+}
@@ -0,0 +1,11 @@
+# typed: false
+
+# with arguments
+while true
+  break foo
+end
+
+# without arguments
+while true
+  break
+end
@@ -0,0 +1,58 @@
+Begin {
+  stmts = [
+    Send {
+      receiver = NULL
+      method = <U foo>
+      args = [
+      ]
+    }
+    Send {
+      receiver = NULL
+      method = <U foo>
+      args = [
+      ]
+    }
+    Send {
+      receiver = Send {
+        receiver = NULL
+        method = <U foo>
+        args = [
+        ]
+      }
+      method = <U call>
+      args = [
+      ]
+    }
+    Send {
+      receiver = Send {
+        receiver = NULL
+        method = <U foo>
+        args = [
+        ]
+      }
+      method = <U []>
+      args = [
+        Symbol {
+          val = <U bar>
+        }
+      ]
+    }
+    Send {
+      receiver = Send {
+        receiver = NULL
+        method = <U foo>
+        args = [
+        ]
+      }
+      method = <U []=>
+      args = [
+        Symbol {
+          val = <U baz>
+        }
+        Integer {
+          val = "1"
+        }
+      ]
+    }
+  ]
+}
@@ -0,0 +1,7 @@
+# typed: false
+
+foo
+foo()
+foo.()
+foo[:bar]
+foo[:baz] = 1
@@ -0,0 +1,237 @@
+Begin {
+  stmts = [
+    Send {
+      receiver = Send {
+        receiver = NULL
+        method = <U receiver>
+        args = [
+        ]
+      }
+      method = <U foo>
+      args = [
+        Integer {
+          val = "1"
+        }
+        Integer {
+          val = "2"
+        }
+        Splat {
+          var = Array {
+            elts = [
+              Integer {
+                val = "3"
+              }
+            ]
+          }
+        }
+        Hash {
+          kwargs = true
+          pairs = [
+            Pair {
+              key = Symbol {
+                val = <U d>
+              }
+              value = Integer {
+                val = "4"
+              }
+            }
+            Pair {
+              key = Symbol {
+                val = <U e>
+              }
+              value = Integer {
+                val = "5"
+              }
+            }
+            Pair {
+              key = Symbol {
+                val = <U f>
+              }
+              value = Integer {
+                val = "6"
+              }
+            }
+          ]
+        }
+        BlockPass {
+          block = Send {
+            receiver = NULL
+            method = <U forwarded_block>
+            args = [
+            ]
+          }
+        }
+      ]
+    }
+    Block {
+      send = Send {
+        receiver = Send {
+          receiver = NULL
+          method = <U receiver>
+          args = [
+          ]
+        }
+        method = <U foo>
+        args = [
+          Integer {
+            val = "1"
+          }
+          Integer {
+            val = "2"
+          }
+          Splat {
+            var = Array {
+              elts = [
+                Integer {
+                  val = "3"
+                }
+              ]
+            }
+          }
+          Hash {
+            kwargs = true
+            pairs = [
+              Pair {
+                key = Symbol {
+                  val = <U d>
+                }
+                value = Integer {
+                  val = "4"
+                }
+              }
+              Pair {
+                key = Symbol {
+                  val = <U e>
+                }
+                value = Integer {
+                  val = "5"
+                }
+              }
+              Pair {
+                key = Symbol {
+                  val = <U f>
+                }
+                value = Integer {
+                  val = "6"
+                }
+              }
+            ]
+          }
+        ]
+      }
+      args = Args {
+        args = [
+          Arg {
+            name = <U a>
+          }
+          Arg {
+            name = <U b>
+          }
+          Arg {
+            name = <U c>
+          }
+          Kwarg {
+            name = <U d>
+          }
+          Kwarg {
+            name = <U e>
+          }
+          Kwarg {
+            name = <U f>
+          }
+          Blockarg {
+            name = <U block>
+          }
+        ]
+      }
+      body = String {
+        val = <U inline block>
+      }
+    }
+    Block {
+      send = Send {
+        receiver = Send {
+          receiver = NULL
+          method = <U receiver>
+          args = [
+          ]
+        }
+        method = <U foo>
+        args = [
+          Integer {
+            val = "1"
+          }
+          Integer {
+            val = "2"
+          }
+          Splat {
+            var = Array {
+              elts = [
+                Integer {
+                  val = "3"
+                }
+              ]
+            }
+          }
+          Hash {
+            kwargs = true
+            pairs = [
+              Pair {
+                key = Symbol {
+                  val = <U d>
+                }
+                value = Integer {
+                  val = "4"
+                }
+              }
+              Pair {
+                key = Symbol {
+                  val = <U e>
+                }
+                value = Integer {
+                  val = "5"
+                }
+              }
+              Pair {
+                key = Symbol {
+                  val = <U f>
+                }
+                value = Integer {
+                  val = "6"
+                }
+              }
+            ]
+          }
+        ]
+      }
+      args = Args {
+        args = [
+          Arg {
+            name = <U a>
+          }
+          Arg {
+            name = <U b>
+          }
+          Arg {
+            name = <U c>
+          }
+          Kwarg {
+            name = <U d>
+          }
+          Kwarg {
+            name = <U e>
+          }
+          Kwarg {
+            name = <U f>
+          }
+          Blockarg {
+            name = <U block>
+          }
+        ]
+      }
+      body = String {
+        val = <U do-end block>
+      }
+    }
+  ]
+}
@@ -0,0 +1,9 @@
+# typed: false
+
+ receiver.foo(1, 2, *[3], d: 4, e: 5, f: 6, &forwarded_block)
+
+ receiver.foo(1, 2, *[3], d: 4, e: 5, f: 6) { |a, b, c, d:, e:, f:, &block| "inline block" }
+
+ receiver.foo(1, 2, *[3], d: 4, e: 5, f: 6) do |a, b, c, d:, e:, f:, &block|
+  "do-end block"
+ end
@@ -0,0 +1,296 @@
+Begin {
+  stmts = [
+    Block {
+      send = Send {
+        receiver = NULL
+        method = <U foo>
+        args = [
+        ]
+      }
+      args = NULL
+      body = NULL
+    }
+    Block {
+      send = Send {
+        receiver = NULL
+        method = <U foo>
+        args = [
+        ]
+      }
+      args = NULL
+      body = NULL
+    }
+    Block {
+      send = Send {
+        receiver = NULL
+        method = <U foo>
+        args = [
+        ]
+      }
+      args = NULL
+      body = String {
+        val = <U inline block>
+      }
+    }
+    Block {
+      send = Send {
+        receiver = NULL
+        method = <U foo>
+        args = [
+        ]
+      }
+      args = NULL
+      body = String {
+        val = <U do-end block>
+      }
+    }
+    Block {
+      send = Send {
+        receiver = NULL
+        method = <U foo>
+        args = [
+        ]
+      }
+      args = Args {
+        args = [
+          Arg {
+            name = <U positional>
+          }
+          Kwarg {
+            name = <U kwarg>
+          }
+          Blockarg {
+            name = <U block>
+          }
+        ]
+      }
+      body = String {
+        val = <U inline block with params>
+      }
+    }
+    Block {
+      send = Send {
+        receiver = NULL
+        method = <U foo>
+        args = [
+        ]
+      }
+      args = Args {
+        args = [
+          Arg {
+            name = <U positional>
+          }
+          Kwarg {
+            name = <U kwarg>
+          }
+          Blockarg {
+            name = <U block>
+          }
+        ]
+      }
+      body = String {
+        val = <U inline block with params>
+      }
+    }
+    Block {
+      send = Send {
+        receiver = NULL
+        method = <U foo>
+        args = [
+        ]
+      }
+      args = Args {
+        args = [
+          Arg {
+            name = <U positional>
+          }
+          Mlhs {
+            exprs = [
+              Arg {
+                name = <U multi>
+              }
+              Arg {
+                name = <U target>
+              }
+            ]
+          }
+        ]
+      }
+      body = String {
+        val = <U block with multi-target node in parameter list>
+      }
+    }
+    Block {
+      send = Send {
+        receiver = NULL
+        method = <U foo>
+        args = [
+        ]
+      }
+      args = Args {
+        args = [
+          Arg {
+            name = <U bar>
+          }
+          Shadowarg {
+            name = <U baz>
+          }
+          Shadowarg {
+            name = <U qux>
+          }
+        ]
+      }
+      body = NULL
+    }
+    Block {
+      send = Send {
+        receiver = NULL
+        method = <U foo>
+        args = [
+        ]
+      }
+      args = Args {
+        args = [
+          Arg {
+            name = <U positional>
+          }
+          Mlhs {
+            exprs = [
+              Arg {
+                name = <U multi>
+              }
+              Arg {
+                name = <U target>
+              }
+            ]
+          }
+          Shadowarg {
+            name = <U baz>
+          }
+          Shadowarg {
+            name = <U qux>
+          }
+        ]
+      }
+      body = String {
+        val = <U block with multi-target node in parameter list and block locals>
+      }
+    }
+    Block {
+      send = Send {
+        receiver = NULL
+        method = <U foo>
+        args = [
+        ]
+      }
+      args = Args {
+        args = [
+          Arg {
+            name = <U bar>
+          }
+          Shadowarg {
+            name = <U baz>
+          }
+          Shadowarg {
+            name = <U qux>
+          }
+        ]
+      }
+      body = NULL
+    }
+    Send {
+      receiver = NULL
+      method = <U foo>
+      args = [
+        BlockPass {
+          block = Send {
+            receiver = NULL
+            method = <U forwarded_block>
+            args = [
+            ]
+          }
+        }
+      ]
+    }
+    Block {
+      send = CSend {
+        receiver = Send {
+          receiver = NULL
+          method = <U foo>
+          args = [
+          ]
+        }
+        method = <U bar>
+        args = [
+        ]
+      }
+      args = NULL
+      body = NULL
+    }
+    Block {
+      send = Send {
+        receiver = NULL
+        method = <U foo>
+        args = [
+        ]
+      }
+      args = Args {
+        args = [
+          Mlhs {
+            exprs = [
+              Restarg {
+                name = <U args>
+              }
+            ]
+          }
+        ]
+      }
+      body = String {
+        val = <U block with multi-target rest args>
+      }
+    }
+    Block {
+      send = Send {
+        receiver = NULL
+        method = <U foo>
+        args = [
+        ]
+      }
+      args = Args {
+        args = [
+          Restarg {
+            name = <U args>
+          }
+        ]
+      }
+      body = String {
+        val = <U block with rest args>
+      }
+    }
+    Send {
+      receiver = NULL
+      method = <U def_delegators>
+      args = [
+        Symbol {
+          val = <U foo>
+        }
+        Hash {
+          kwargs = false
+          pairs = [
+            Pair {
+              key = Send {
+                receiver = NULL
+                method = <U local>
+                args = [
+                ]
+              }
+              value = Symbol {
+                val = <U thing>
+              }
+            }
+          ]
+        }
+      ]
+    }
+  ]
+}
@@ -0,0 +1,45 @@
+# typed: false
+
+foo {} # empty inline block
+
+foo do # empty do-end block
+end
+
+foo { "inline block" }
+
+foo do
+  "do-end block"
+end
+
+foo { |positional, kwarg:, &block| "inline block with params" }
+
+foo do |positional, kwarg:, &block|
+  "inline block with params"
+end
+
+foo do |positional, (multi, target)|
+  "block with multi-target node in parameter list"
+end
+
+# block with parameter `bar` and block locals `baz` and `qux`
+foo { |bar; baz, qux| }
+
+foo do |positional, (multi, target); baz, qux|
+  "block with multi-target node in parameter list and block locals"
+end
+
+foo { |bar; baz, qux| }
+
+foo(&forwarded_block)
+
+foo&.bar {}
+
+foo do |(*args)|
+  "block with multi-target rest args"
+end
+
+foo do |*args|
+  "block with rest args"
+end
+
+def_delegators :foo, local => :thing
@@ -0,0 +1,17 @@
+DefMethod {
+  name = <U foo>
+  args = Args {
+    args = [
+      ForwardArg {
+      }
+    ]
+  }
+  body = Send {
+    receiver = NULL
+    method = <U bar>
+    args = [
+      ForwardedArgs {
+      }
+    ]
+  }
+}
@@ -0,0 +1,6 @@
+
+# typed: false
+
+def foo(...)
+  bar(...)
+end
@@ -0,0 +1,53 @@
+Begin {
+  stmts = [
+    DefMethod {
+      name = <U has_named_kwargs>
+      args = Args {
+        args = [
+          Kwrestarg {
+            name = <U kwargs>
+          }
+        ]
+      }
+      body = Send {
+        receiver = NULL
+        method = <U delegate>
+        args = [
+          Hash {
+            kwargs = true
+            pairs = [
+              Kwsplat {
+                expr = LVar {
+                  name = <U kwargs>
+                }
+              }
+            ]
+          }
+        ]
+      }
+    }
+    DefMethod {
+      name = <U has_anonymous_kwargs>
+      args = Args {
+        args = [
+          Kwrestarg {
+            name = <P <U **> $2>
+          }
+        ]
+      }
+      body = Send {
+        receiver = NULL
+        method = <U delegate>
+        args = [
+          Hash {
+            kwargs = true
+            pairs = [
+              ForwardedKwrestArg {
+              }
+            ]
+          }
+        ]
+      }
+    }
+  ]
+}
@@ -0,0 +1,9 @@
+# typed: false
+
+def has_named_kwargs(**kwargs)
+  delegate(**kwargs)
+end
+
+def has_anonymous_kwargs(**)
+  delegate(**)
+end
@@ -0,0 +1,96 @@
+Begin {
+  stmts = [
+    Send {
+      receiver = NULL
+      method = <U foo>
+      args = [
+        Hash {
+          kwargs = true
+          pairs = [
+            Pair {
+              key = Symbol {
+                val = <U a>
+              }
+              value = Integer {
+                val = "1"
+              }
+            }
+          ]
+        }
+      ]
+    }
+    Send {
+      receiver = NULL
+      method = <U foo>
+      args = [
+        Hash {
+          kwargs = true
+          pairs = [
+            Pair {
+              key = Symbol {
+                val = <U a>
+              }
+              value = Integer {
+                val = "1"
+              }
+            }
+          ]
+        }
+      ]
+    }
+    Send {
+      receiver = NULL
+      method = <U bar>
+      args = [
+        Hash {
+          kwargs = true
+          pairs = [
+            Pair {
+              key = Symbol {
+                val = <U a>
+              }
+              value = Integer {
+                val = "2"
+              }
+            }
+            Pair {
+              key = Symbol {
+                val = <U b>
+              }
+              value = Integer {
+                val = "3"
+              }
+            }
+          ]
+        }
+      ]
+    }
+    Send {
+      receiver = NULL
+      method = <U bar>
+      args = [
+        Hash {
+          kwargs = true
+          pairs = [
+            Pair {
+              key = Symbol {
+                val = <U a>
+              }
+              value = Integer {
+                val = "2"
+              }
+            }
+            Pair {
+              key = Symbol {
+                val = <U b>
+              }
+              value = Integer {
+                val = "3"
+              }
+            }
+          ]
+        }
+      ]
+    }
+  ]
+}
@@ -0,0 +1,9 @@
+# typed: false
+
+ foo(a: 1)
+
+ foo a: 1
+
+ bar(a: 2, b: 3)
+
+ bar a: 2, b: 3
@@ -0,0 +1,46 @@
+Begin {
+  stmts = [
+    Send {
+      receiver = NULL
+      method = <U foo>
+      args = [
+        Integer {
+          val = "1"
+        }
+      ]
+    }
+    Send {
+      receiver = NULL
+      method = <U foo>
+      args = [
+        Integer {
+          val = "1"
+        }
+      ]
+    }
+    Send {
+      receiver = NULL
+      method = <U bar>
+      args = [
+        Integer {
+          val = "2"
+        }
+        Integer {
+          val = "3"
+        }
+      ]
+    }
+    Send {
+      receiver = NULL
+      method = <U bar>
+      args = [
+        Integer {
+          val = "2"
+        }
+        Integer {
+          val = "3"
+        }
+      ]
+    }
+  ]
+}
@@ -0,0 +1,9 @@
+# typed: false
+
+ foo(1)
+
+ foo 1
+
+ bar(2, 3)
+
+ bar 2, 3
@@ -0,0 +1,43 @@
+Begin {
+  stmts = [
+    DefMethod {
+      name = <U has_named_rest_args>
+      args = Args {
+        args = [
+          Restarg {
+            name = <U args>
+          }
+        ]
+      }
+      body = Send {
+        receiver = NULL
+        method = <U delegate>
+        args = [
+          Splat {
+            var = LVar {
+              name = <U args>
+            }
+          }
+        ]
+      }
+    }
+    DefMethod {
+      name = <U has_anonymous_rest_args>
+      args = Args {
+        args = [
+          Restarg {
+            name = <U *>
+          }
+        ]
+      }
+      body = Send {
+        receiver = NULL
+        method = <U delegate>
+        args = [
+          ForwardedRestArg {
+          }
+        ]
+      }
+    }
+  ]
+}
@@ -0,0 +1,10 @@
+
+# typed: false
+
+def has_named_rest_args(*args)
+  delegate(*args)
+end
+
+def has_anonymous_rest_args(*)
+  delegate(*)
+end
@@ -0,0 +1,48 @@
+Begin {
+  stmts = [
+    Send {
+      receiver = Send {
+        receiver = NULL
+        method = <U receiver>
+        args = [
+        ]
+      }
+      method = <U foo>
+      args = [
+      ]
+    }
+    Send {
+      receiver = Send {
+        receiver = NULL
+        method = <U receiver>
+        args = [
+        ]
+      }
+      method = <U foo>
+      args = [
+      ]
+    }
+    CSend {
+      receiver = Send {
+        receiver = NULL
+        method = <U receiver>
+        args = [
+        ]
+      }
+      method = <U foo>
+      args = [
+      ]
+    }
+    CSend {
+      receiver = Send {
+        receiver = NULL
+        method = <U receiver>
+        args = [
+        ]
+      }
+      method = <U foo>
+      args = [
+      ]
+    }
+  ]
+}
@@ -0,0 +1,7 @@
+# typed: false
+
+ receiver.foo
+ receiver.foo()
+
+ receiver&.foo
+ receiver&.foo()
@@ -0,0 +1,93 @@
+Begin {
+  stmts = [
+    Case {
+      condition = Send {
+        receiver = NULL
+        method = <U foo>
+        args = [
+        ]
+      }
+      whens = [
+        When {
+          patterns = [
+            Integer {
+              val = "1"
+            }
+          ]
+          body = Send {
+            receiver = NULL
+            method = <U puts>
+            args = [
+              String {
+                val = <U one!>
+              }
+            ]
+          }
+        }
+        When {
+          patterns = [
+            Integer {
+              val = "2"
+            }
+            Integer {
+              val = "3"
+            }
+          ]
+          body = Send {
+            receiver = NULL
+            method = <U puts>
+            args = [
+              String {
+                val = <U two or three!>
+              }
+            ]
+          }
+        }
+      ]
+      else_ = Send {
+        receiver = NULL
+        method = <U puts>
+        args = [
+          String {
+            val = <U Who knows!>
+          }
+        ]
+      }
+    }
+    Case {
+      condition = Send {
+        receiver = NULL
+        method = <U foo>
+        args = [
+        ]
+      }
+      whens = [
+        When {
+          patterns = [
+            Const {
+              scope = NULL
+              name = <C <U Integer>>
+            }
+          ]
+          body = Begin {
+            stmts = [
+              Integer {
+                val = "4"
+              }
+              Send {
+                receiver = NULL
+                method = <U puts>
+                args = [
+                  String {
+                    val = <U surprise, multi-line!>
+                  }
+                ]
+              }
+            ]
+          }
+        }
+      ]
+      else_ = NULL
+    }
+  ]
+}
@@ -0,0 +1,17 @@
+# typed: false
+
+case foo
+when 1
+  puts "one!"
+when 2, 3
+  puts "two or three!"
+else
+  puts "Who knows!"
+end
+
+# no else
+case foo
+when Integer
+  4
+  puts "surprise, multi-line!"
+end
@@ -0,0 +1,83 @@
+# typed: false
+
+case foo
+in 1
+  puts "one!"
+in 2
+  puts "two!"
+in 3 | 4
+  puts "three or four!"
+else
+  puts "Who knows!"
+end
+
+case array_like_thing
+in [] => a
+  puts "empty!"
+in [1, 2]
+  puts "one and two!"
+in 3, 4 # An array pattern without [], but otherwise similar to the one above
+  puts "three and four!"
+in [5, *]
+  puts "starts with five!"
+in [*, 6]
+  puts "ends with six!"
+in [*, 7, *] # A "find pattern"
+  puts "contains a seven!"
+in Array[first, second] # Requires the `array_like_thing` to be an `Array` specifically
+  puts "An Array with first: #{first} and second: #{second}"
+in Point[x, y]          # Requires the `array_like_thing` to be a `Point` specifically
+  puts "A Point with x: #{x} and y: #{y}"
+in [i,]
+  puts "An array with an element and maybe other stuff"
+end
+
+case hash_like_thing
+in {}
+  puts "empty!"
+in { a: 1, b: 2 } => h
+  puts "#{h} contains a and b, and maybe other stuff!"
+in { c: 3, ** } => h
+  puts "#{h} has c, and maybe other stuff!"
+in { d: 4, **nil } => h
+  puts "#{h} has d and nothing else!"
+in {"kj": j} | {"kh": l} => m
+  puts "#{m} has j or l!"
+in {"n1":, n2:, "n3":} => n4
+  puts "#{n4} has n1, n2, and n3!"
+in Hash[e: 5 => e]             # Requires the `hash_like_thing` to be a `Hash` specifically
+  puts "A Hash with e: #{e}"
+in Point[x: 6 => x, y: 7 => y] # Requires the `hash_like_thing` to be a `Point` specifically
+  puts "A Point with x: #{x} and y: #{y}"
+in **o
+  puts "splat!"
+in **nil
+  puts "splat nil!"
+end
+
+# no else
+case foo
+in 1
+  "one!"
+  puts "surprise, multi-line!"
+end
+
+# pattern matching with if guards
+case bar
+in x if x == 1
+  "in with if"
+in a, b if b == 2
+  "in with 2 args and if"
+in c, d; c if c == 3
+  "in with 2 args, semicolon, and if"
+end
+
+# pattern matching with unless guards
+case baz
+in x unless x == 1
+  "in with unless"
+in a, b unless b == 2
+  "in with 2 args and unless"
+in c, d; c unless c == 3
+  "in with 2 args, semicolon, and unless"
+end
@@ -0,0 +1,284 @@
+Begin {
+  stmts = [
+    Assign {
+      lhs = LVarLhs {
+        name = <U lvar>
+      }
+      rhs = Integer {
+        val = "1"
+      }
+    }
+    CaseMatch {
+      expr = Send {
+        receiver = NULL
+        method = <U foo>
+        args = [
+        ]
+      }
+      inBodies = [
+        InPattern {
+          pattern = ArrayPattern {
+            elts = [
+              MatchVar {
+                name = <U x>
+              }
+            ]
+          }
+          guard = NULL
+          body = DString {
+            nodes = [
+              String {
+                val = <U An Array-like thing that only contains >
+              }
+              Begin {
+                stmts = [
+                  LVar {
+                    name = <U x>
+                  }
+                ]
+              }
+            ]
+          }
+        }
+        InPattern {
+          pattern = HashPattern {
+            pairs = [
+              Pair {
+                key = Symbol {
+                  val = <U k>
+                }
+                value = MatchVar {
+                  name = <U x>
+                }
+              }
+            ]
+          }
+          guard = NULL
+          body = DString {
+            nodes = [
+              String {
+                val = <U A Hash-like whose key `:k` has value >
+              }
+              Begin {
+                stmts = [
+                  LVar {
+                    name = <U x>
+                  }
+                ]
+              }
+            ]
+          }
+        }
+        InPattern {
+          pattern = ArrayPattern {
+            elts = [
+              ArrayPattern {
+                elts = [
+                  MatchVar {
+                    name = <U value>
+                  }
+                ]
+              }
+              MatchRest {
+                var = MatchVar {
+                  name = <U tail>
+                }
+              }
+            ]
+          }
+          guard = NULL
+          body = DString {
+            nodes = [
+              String {
+                val = <U An array-like thing that starts with a one-element Array containing >
+              }
+              Begin {
+                stmts = [
+                  LVar {
+                    name = <U value>
+                  }
+                ]
+              }
+              String {
+                val = <U , and ends with >
+              }
+              Begin {
+                stmts = [
+                  LVar {
+                    name = <U tail>
+                  }
+                ]
+              }
+            ]
+          }
+        }
+        InPattern {
+          pattern = HashPattern {
+            pairs = [
+              Pair {
+                key = Symbol {
+                  val = <U k>
+                }
+                value = ArrayPattern {
+                  elts = [
+                    MatchVar {
+                      name = <U value>
+                    }
+                  ]
+                }
+              }
+            ]
+          }
+          guard = NULL
+          body = DString {
+            nodes = [
+              String {
+                val = <U A hash-like whose key `:k` has a one-element Array value containing >
+              }
+              Begin {
+                stmts = [
+                  LVar {
+                    name = <U value>
+                  }
+                ]
+              }
+            ]
+          }
+        }
+        InPattern {
+          pattern = ArrayPattern {
+            elts = [
+              HashPattern {
+                pairs = [
+                  Pair {
+                    key = Symbol {
+                      val = <U k>
+                    }
+                    value = MatchVar {
+                      name = <U value>
+                    }
+                  }
+                ]
+              }
+              MatchRest {
+                var = MatchVar {
+                  name = <U tail>
+                }
+              }
+            ]
+          }
+          guard = NULL
+          body = DString {
+            nodes = [
+              String {
+                val = <U An array-like thing that starts with a one-element Hash containing >
+              }
+              Begin {
+                stmts = [
+                  LVar {
+                    name = <U value>
+                  }
+                ]
+              }
+              String {
+                val = <U , and ends with >
+              }
+              Begin {
+                stmts = [
+                  LVar {
+                    name = <U tail>
+                  }
+                ]
+              }
+            ]
+          }
+        }
+        InPattern {
+          pattern = HashPattern {
+            pairs = [
+              Pair {
+                key = Symbol {
+                  val = <U k>
+                }
+                value = HashPattern {
+                  pairs = [
+                    Pair {
+                      key = Symbol {
+                        val = <U k2>
+                      }
+                      value = MatchVar {
+                        name = <U value>
+                      }
+                    }
+                  ]
+                }
+              }
+            ]
+          }
+          guard = NULL
+          body = DString {
+            nodes = [
+              String {
+                val = <U A hash-like whose key `:k` has a one-element Hash value containing k2: >
+              }
+              Begin {
+                stmts = [
+                  LVar {
+                    name = <U value>
+                  }
+                ]
+              }
+            ]
+          }
+        }
+        InPattern {
+          pattern = MatchAs {
+            value = Const {
+              scope = NULL
+              name = <C <U Integer>>
+            }
+            as = MatchVar {
+              name = <U i>
+            }
+          }
+          guard = NULL
+          body = DString {
+            nodes = [
+              String {
+                val = <U An Integer: >
+              }
+              Begin {
+                stmts = [
+                  LVar {
+                    name = <U i>
+                  }
+                ]
+              }
+            ]
+          }
+        }
+        InPattern {
+          pattern = MatchVar {
+            name = <U x>
+          }
+          guard = NULL
+          body = DString {
+            nodes = [
+              String {
+                val = <U Some other value: >
+              }
+              Begin {
+                stmts = [
+                  LVar {
+                    name = <U x>
+                  }
+                ]
+              }
+            ]
+          }
+        }
+      ]
+      elseBody = NULL
+    }
+  ]
+}
@@ -0,0 +1,26 @@
+# typed: false
+
+lvar = 1
+
+case foo
+in [x]      # Variable binding nested in an Array pattern
+  "An Array-like thing that only contains #{x}"
+in { k: x } # Variable binding nested in a Hash pattern
+  "A Hash-like whose key `:k` has value #{x}"
+
+in [[value], *tail] # Array pattern inside an Array pattern
+  "An array-like thing that starts with a one-element Array containing #{value}, and ends with #{tail}"
+in { k: [value] }   # Array pattern inside a Hash pattern
+  "A hash-like whose key `:k` has a one-element Array value containing #{value}"
+
+in [{ k: value }, *tail] # A Hash pattern inside an Array pattern
+  "An array-like thing that starts with a one-element Hash containing #{value}, and ends with #{tail}"
+in { k: { k2: value } }  # A Hash pattern inside a Hash pattern
+  "A hash-like whose key `:k` has a one-element Hash value containing k2: #{value}"
+
+in Integer => i # Pattern that also binds a variable
+  "An Integer: #{i}"
+
+in x # Binds any value to a new variable `x`.
+  "Some other value: #{x}"
+end
@@ -0,0 +1,110 @@
+Begin {
+  stmts = [
+    Assign {
+      lhs = LVarLhs {
+        name = <U lvar>
+      }
+      rhs = Integer {
+        val = "1"
+      }
+    }
+    CaseMatch {
+      expr = Send {
+        receiver = NULL
+        method = <U foo>
+        args = [
+        ]
+      }
+      inBodies = [
+        InPattern {
+          pattern = Pin {
+            var = LVar {
+              name = <U lvar>
+            }
+          }
+          guard = NULL
+          body = String {
+            val = <U Has the same value as the preexisting variable `x`>
+          }
+        }
+        InPattern {
+          pattern = Pin {
+            var = IVar {
+              name = <U @ivar>
+            }
+          }
+          guard = NULL
+          body = String {
+            val = <U Has the same value as `@ivar`>
+          }
+        }
+        InPattern {
+          pattern = Pin {
+            var = CVar {
+              name = <U @@cvar>
+            }
+          }
+          guard = NULL
+          body = String {
+            val = <U Has the same value as `@@cvar`>
+          }
+        }
+        InPattern {
+          pattern = Pin {
+            var = GVar {
+              name = <U $global>
+            }
+          }
+          guard = NULL
+          body = String {
+            val = <U Has the same value as `$global`>
+          }
+        }
+        InPattern {
+          pattern = Pin {
+            var = Begin {
+              stmts = [
+                Send {
+                  receiver = Integer {
+                    val = "1"
+                  }
+                  method = <U +>
+                  args = [
+                    Integer {
+                      val = "2"
+                    }
+                  ]
+                }
+              ]
+            }
+          }
+          guard = NULL
+          body = String {
+            val = <U Has the same value as `1 + 2`>
+          }
+        }
+        InPattern {
+          pattern = MatchVar {
+            name = <U x>
+          }
+          guard = NULL
+          body = DString {
+            nodes = [
+              String {
+                val = <U Some other value: >
+              }
+              Begin {
+                stmts = [
+                  LVar {
+                    name = <U x>
+                  }
+                ]
+              }
+            ]
+          }
+        }
+      ]
+      elseBody = NULL
+    }
+  ]
+}
@@ -0,0 +1,23 @@
+# typed: false
+
+lvar = 1
+
+case foo
+
+# "Variable pinning", which matches against the value of that variable
+in ^lvar # `lvar` must already exist. Does *not* bind a new variable `lvar`, like `in x` below.
+  "Has the same value as the preexisting variable `x`"
+in ^@ivar
+  "Has the same value as `@ivar`"
+in ^@@cvar
+  "Has the same value as `@@cvar`"
+in ^$global
+  "Has the same value as `$global`"
+
+# "Expression pinning", which match the result of the expression
+in ^(1 + 2)
+  "Has the same value as `1 + 2`"
+
+in x # Binds any value to a new variable `x`.
+  "Some other value: #{x}"
+end
@@ -0,0 +1,59 @@
+Begin {
+  stmts = [
+    Class {
+      name = Const {
+        scope = NULL
+        name = <C <U Parent>>
+      }
+      superclass = NULL
+      body = Begin {
+        stmts = [
+          Integer {
+            val = "1"
+          }
+          Integer {
+            val = "2"
+          }
+          Integer {
+            val = "3"
+          }
+        ]
+      }
+    }
+    Class {
+      name = Const {
+        scope = NULL
+        name = <C <U Child>>
+      }
+      superclass = Const {
+        scope = NULL
+        name = <C <U Parent>>
+      }
+      body = NULL
+    }
+    SClass {
+      expr = Self {
+      }
+      body = Begin {
+        stmts = [
+          Integer {
+            val = "4"
+          }
+          Integer {
+            val = "5"
+          }
+          Integer {
+            val = "6"
+          }
+        ]
+      }
+    }
+    SClass {
+      expr = Const {
+        scope = NULL
+        name = <C <U Parent>>
+      }
+      body = NULL
+    }
+  ]
+}
@@ -0,0 +1,17 @@
+# typed: false
+
+class Parent
+  1
+  2
+  3
+end
+
+class Child < Parent; end
+
+class << self
+  4
+  5
+  6
+end
+
+class << Parent; end
@@ -0,0 +1,28 @@
+Begin {
+  stmts = [
+    Const {
+      scope = NULL
+      name = <C <U SimpleConstant>>
+    }
+    Const {
+      scope = Const {
+        scope = NULL
+        name = <C <U Nested>>
+      }
+      name = <C <U Constant>>
+    }
+    Const {
+      scope = Cbase {
+      }
+      name = <C <U FullyQualifiedConstant>>
+    }
+    Const {
+      scope = Const {
+        scope = Cbase {
+        }
+        name = <C <U FullyQualified>>
+      }
+      name = <C <U NestedConstant>>
+    }
+  ]
+}
@@ -0,0 +1,13 @@
+# typed: false
+
+ SimpleConstant
+#^^^^^^^^^^^^^^ error: Unable to resolve constant `SimpleConstant`
+
+ Nested::Constant
+#^^^^^^ error: Unable to resolve constant `Nested`
+
+ ::FullyQualifiedConstant
+#^^^^^^^^^^^^^^^^^^^^^^^^ error: Unable to resolve constant `FullyQualifiedConstant`
+
+ ::FullyQualified::NestedConstant
+#^^^^^^^^^^^^^^^^ error: Unable to resolve constant `FullyQualified`
@@ -0,0 +1,45 @@
+Begin {
+  stmts = [
+    DefMethod {
+      name = <U foo>
+      args = NULL
+      body = NULL
+    }
+    DefMethod {
+      name = <U bar>
+      args = NULL
+      body = Begin {
+        stmts = [
+          String {
+            val = <U string1>
+          }
+          String {
+            val = <U string2>
+          }
+        ]
+      }
+    }
+    DefMethod {
+      name = <U baz>
+      args = NULL
+      body = Kwbegin {
+        stmts = [
+          String {
+            val = <U string1>
+          }
+          String {
+            val = <U string2>
+          }
+        ]
+      }
+    }
+    DefMethod {
+      name = <U qux>
+      args = Args {
+        args = [
+        ]
+      }
+      body = NULL
+    }
+  ]
+}
@@ -0,0 +1,17 @@
+# typed: false
+
+def foo; end
+
+def bar
+  "string1"
+  "string2"
+end
+
+def baz
+  begin
+  "string1"
+  "string2"
+  end
+end
+
+def qux(); end
@@ -0,0 +1,56 @@
+Begin {
+  stmts = [
+    DefMethod {
+      name = <U foo>
+      args = Args {
+        args = [
+          Arg {
+            name = <U a>
+          }
+          Optarg {
+            name = <U b>
+            default_ = Integer {
+              val = "2"
+            }
+          }
+          Restarg {
+            name = <U c>
+          }
+          Kwarg {
+            name = <U d>
+          }
+          Kwoptarg {
+            name = <U e>
+            default_ = Integer {
+              val = "5"
+            }
+          }
+          Kwrestarg {
+            name = <U f>
+          }
+          Blockarg {
+            name = <U blk>
+          }
+        ]
+      }
+      body = NULL
+    }
+    DefMethod {
+      name = <U foo>
+      args = Args {
+        args = [
+          Restarg {
+            name = <U *>
+          }
+          Kwrestarg {
+            name = <P <U **> $2>
+          }
+          Blockarg {
+            name = <P <U &> $3>
+          }
+        ]
+      }
+      body = NULL
+    }
+  ]
+}
@@ -0,0 +1,5 @@
+# typed: false
+
+def foo(a, b = 2, *c, d:, e: 5, **f, &blk); end
+
+def foo(*, **, &); end
@@ -0,0 +1,45 @@
+Begin {
+  stmts = [
+    DefMethod {
+      name = <U foo>
+      args = Args {
+        args = [
+          Blockarg {
+            name = <U blk>
+          }
+        ]
+      }
+      body = NULL
+    }
+    DefMethod {
+      name = <U foo>
+      args = Args {
+        args = [
+          Blockarg {
+            name = <P <U &> $2>
+          }
+        ]
+      }
+      body = NULL
+    }
+    DefMethod {
+      name = <U foo>
+      args = Args {
+        args = [
+          Blockarg {
+            name = <U blk>
+          }
+        ]
+      }
+      body = Super {
+        args = [
+          BlockPass {
+            block = LVar {
+              name = <U blk>
+            }
+          }
+        ]
+      }
+    }
+  ]
+}
@@ -0,0 +1,9 @@
+# typed: false
+
+def foo(&blk); end
+
+def foo(&); end
+
+def foo(&blk)
+  super(&blk)
+end
@@ -0,0 +1,10 @@
+DefMethod {
+  name = <U foo>
+  args = Args {
+    args = [
+      ForwardArg {
+      }
+    ]
+  }
+  body = NULL
+}
@@ -0,0 +1,4 @@
+# typed: false
+
+def foo(...)
+end
@@ -0,0 +1,36 @@
+Begin {
+  stmts = [
+    DefMethod {
+      name = <U foo>
+      args = Args {
+        args = [
+          Kwrestarg {
+            name = <U a>
+          }
+        ]
+      }
+      body = NULL
+    }
+    DefMethod {
+      name = <U foo>
+      args = Args {
+        args = [
+          Kwrestarg {
+            name = <P <U **> $2>
+          }
+        ]
+      }
+      body = NULL
+    }
+    DefMethod {
+      name = <U foo>
+      args = Args {
+        args = [
+          Kwnilarg {
+          }
+        ]
+      }
+      body = NULL
+    }
+  ]
+}
@@ -0,0 +1,7 @@
+# typed: false
+
+def foo(**a); end
+
+def foo(**); end
+
+def foo(**nil); end # Disallows keyword params, which is now the default in Ruby 3. Ruby 2 could might still have this.
@@ -0,0 +1,38 @@
+Begin {
+  stmts = [
+    DefMethod {
+      name = <U foo>
+      args = Args {
+        args = [
+          Kwoptarg {
+            name = <U a>
+            default_ = Integer {
+              val = "1"
+            }
+          }
+        ]
+      }
+      body = NULL
+    }
+    DefMethod {
+      name = <U bar>
+      args = Args {
+        args = [
+          Kwoptarg {
+            name = <U a>
+            default_ = Integer {
+              val = "1"
+            }
+          }
+          Kwoptarg {
+            name = <U b>
+            default_ = Integer {
+              val = "2"
+            }
+          }
+        ]
+      }
+      body = NULL
+    }
+  ]
+}
@@ -0,0 +1,4 @@
+# typed: false
+
+def foo(a: 1); end
+def bar(a: 1, b: 2); end
@@ -0,0 +1,38 @@
+Begin {
+  stmts = [
+    DefMethod {
+      name = <U foo>
+      args = Args {
+        args = [
+          Optarg {
+            name = <U a>
+            default_ = Integer {
+              val = "1"
+            }
+          }
+        ]
+      }
+      body = NULL
+    }
+    DefMethod {
+      name = <U bar>
+      args = Args {
+        args = [
+          Optarg {
+            name = <U a>
+            default_ = Integer {
+              val = "1"
+            }
+          }
+          Optarg {
+            name = <U b>
+            default_ = Integer {
+              val = "2"
+            }
+          }
+        ]
+      }
+      body = NULL
+    }
+  ]
+}
@@ -0,0 +1,4 @@
+# typed: false
+
+def foo(a = 1); end
+def bar(a = 1, b = 2); end
@@ -0,0 +1,29 @@
+Begin {
+  stmts = [
+    DefMethod {
+      name = <U foo>
+      args = Args {
+        args = [
+          Kwarg {
+            name = <U a>
+          }
+        ]
+      }
+      body = NULL
+    }
+    DefMethod {
+      name = <U bar>
+      args = Args {
+        args = [
+          Kwarg {
+            name = <U a>
+          }
+          Kwarg {
+            name = <U b>
+          }
+        ]
+      }
+      body = NULL
+    }
+  ]
+}
@@ -0,0 +1,4 @@
+# typed: false
+
+def foo(a:); end
+def bar(a:, b:); end
@@ -0,0 +1,29 @@
+Begin {
+  stmts = [
+    DefMethod {
+      name = <U foo>
+      args = Args {
+        args = [
+          Arg {
+            name = <U a>
+          }
+        ]
+      }
+      body = NULL
+    }
+    DefMethod {
+      name = <U bar>
+      args = Args {
+        args = [
+          Arg {
+            name = <U a>
+          }
+          Arg {
+            name = <U b>
+          }
+        ]
+      }
+      body = NULL
+    }
+  ]
+}
@@ -0,0 +1,4 @@
+# typed: false
+
+def foo(a); end
+def bar(a, b); end
@@ -0,0 +1,43 @@
+Begin {
+  stmts = [
+    DefMethod {
+      name = <U foo>
+      args = Args {
+        args = [
+          Restarg {
+            name = <U a>
+          }
+        ]
+      }
+      body = NULL
+    }
+    DefMethod {
+      name = <U foo>
+      args = Args {
+        args = [
+          Restarg {
+            name = <U *>
+          }
+        ]
+      }
+      body = NULL
+    }
+    DefMethod {
+      name = <U foo>
+      args = Args {
+        args = [
+          Restarg {
+            name = <U a>
+          }
+          Arg {
+            name = <U b>
+          }
+          Arg {
+            name = <U c>
+          }
+        ]
+      }
+      body = NULL
+    }
+  ]
+}
@@ -0,0 +1,8 @@
+# typed: false
+
+def foo(*a); end
+
+def foo(*); end
+
+# Rest with posts
+def foo(*a, b, c); end
@@ -0,0 +1,43 @@
+Begin {
+  stmts = [
+    DefS {
+      singleton = Self {
+      }
+      name = <U foo>
+      args = NULL
+      body = NULL
+    }
+    DefS {
+      singleton = Send {
+        receiver = NULL
+        method = <U x>
+        args = [
+        ]
+      }
+      name = <U foo>
+      args = NULL
+      body = NULL
+    }
+    DefS {
+      singleton = Self {
+      }
+      name = <U foo>
+      args = Args {
+        args = [
+          Blockarg {
+            name = <U blk>
+          }
+        ]
+      }
+      body = Super {
+        args = [
+          BlockPass {
+            block = LVar {
+              name = <U blk>
+            }
+          }
+        ]
+      }
+    }
+  ]
+}
@@ -0,0 +1,8 @@
+# typed: false
+
+def self.foo; end
+def x.foo; end # This is invalid
+
+def self.foo(&blk)
+  super(&blk)
+end
@@ -0,0 +1,7 @@
+DefMethod {
+  name = <U foo>
+  args = NULL
+  body = Integer {
+    val = "5"
+  }
+}
@@ -0,0 +1,5 @@
+# typed: false
+
+def foo
+  5
+end
@@ -0,0 +1,72 @@
+Begin {
+  stmts = [
+    Assign {
+      lhs = LVarLhs {
+        name = <U local_var>
+      }
+      rhs = Integer {
+        val = "1"
+      }
+    }
+    Defined {
+      value = Const {
+        scope = Const {
+          scope = NULL
+          name = <C <U Constant>>
+        }
+        name = <C <U Path>>
+      }
+    }
+    Defined {
+      value = Const {
+        scope = Const {
+          scope = Const {
+            scope = Cbase {
+            }
+            name = <C <U FullyQualified>>
+          }
+          name = <C <U Constant>>
+        }
+        name = <C <U Path>>
+      }
+    }
+    Defined {
+      value = Send {
+        receiver = NULL
+        method = <U method_or_local_var>
+        args = [
+        ]
+      }
+    }
+    Defined {
+      value = LVar {
+        name = <U local_var>
+      }
+    }
+    Defined {
+      value = IVar {
+        name = <U @ivar>
+      }
+    }
+    Defined {
+      value = CVar {
+        name = <U @@cvar>
+      }
+    }
+    Defined {
+      value = GVar {
+        name = <U $gvar>
+      }
+    }
+    Defined {
+      value = Yield {
+        exprs = [
+        ]
+      }
+    }
+    Defined {
+      value = ZSuper {
+      }
+    }
+  ]
+}
@@ -0,0 +1,12 @@
+# typed: false
+local_var = 1
+
+defined?(Constant::Path)
+defined?(::FullyQualified::Constant::Path)
+defined?(method_or_local_var)
+defined?(local_var)
+defined?(@ivar)
+defined?(@@cvar)
+defined?($gvar)
+defined?(yield)
+defined?(super)
@@ -0,0 +1,133 @@
+Begin {
+  stmts = [
+    Kwbegin {
+      stmts = [
+        Ensure {
+          body = Send {
+            receiver = NULL
+            method = <U foo>
+            args = [
+            ]
+          }
+          ensure = Send {
+            receiver = NULL
+            method = <U bar>
+            args = [
+            ]
+          }
+        }
+      ]
+    }
+    DefMethod {
+      name = <U method_with_ensure>
+      args = NULL
+      body = Ensure {
+        body = Begin {
+          stmts = [
+            String {
+              val = <U string1>
+            }
+            String {
+              val = <U string2>
+            }
+          ]
+        }
+        ensure = String {
+          val = <U ensured>
+        }
+      }
+    }
+    DefMethod {
+      name = <U empty_method_with_ensure>
+      args = NULL
+      body = Ensure {
+        body = NULL
+        ensure = String {
+          val = <U ensured>
+        }
+      }
+    }
+    DefMethod {
+      name = <U method_with_begin_and_ensure>
+      args = NULL
+      body = Kwbegin {
+        stmts = [
+          Ensure {
+            body = Begin {
+              stmts = [
+                String {
+                  val = <U string1>
+                }
+                String {
+                  val = <U string2>
+                }
+              ]
+            }
+            ensure = String {
+              val = <U ensured>
+            }
+          }
+        ]
+      }
+    }
+    Kwbegin {
+      stmts = [
+        Ensure {
+          body = Begin {
+            stmts = [
+              String {
+                val = <U string1>
+              }
+              String {
+                val = <U string2>
+              }
+            ]
+          }
+          ensure = Begin {
+            stmts = [
+              String {
+                val = <U ensured1>
+              }
+              String {
+                val = <U ensured2>
+              }
+            ]
+          }
+        }
+      ]
+    }
+    Kwbegin {
+      stmts = [
+        Ensure {
+          body = Rescue {
+            body = Begin {
+              stmts = [
+                String {
+                  val = <U string1>
+                }
+                String {
+                  val = <U string2>
+                }
+              ]
+            }
+            rescue = [
+              Resbody {
+                exception = NULL
+                var = NULL
+                body = String {
+                  val = <U rescued rescue>
+                }
+              }
+            ]
+            else_ = String {
+              val = <U rescued else>
+            }
+          }
+          ensure = String {
+            val = <U ensure>
+          }
+        }
+      ]
+    }
+  ]
+}
@@ -0,0 +1,53 @@
+# typed: false
+
+# Testing an ensure clause without a rescue or else clause
+begin
+  foo
+ensure
+  bar
+end
+
+# Testing an ensure clause in a method definition
+def method_with_ensure
+  "string1"
+  "string2"
+ensure
+  "ensured"
+end
+
+# Testing an ensure clause in an empty method definition
+def empty_method_with_ensure
+ensure
+  "ensured"
+end
+
+# Testing an ensure clause in a begin block in a method definition
+def method_with_begin_and_ensure
+  begin
+    "string1"
+    "string2"
+  ensure
+    "ensured"
+  end
+end
+
+# Testing an ensure clause with multiple methods
+begin
+  "string1"
+  "string2"
+ensure
+  "ensured1"
+  "ensured2"
+end
+
+# Testing a rescue clause with an else and ensure clause
+begin
+  "string1"
+  "string2"
+rescue
+  "rescued rescue"
+else
+  "rescued else"
+ensure
+  "ensure"
+end
@@ -0,0 +1,19 @@
+DefMethod {
+  name = <U test_bad_assign>
+  args = Args {
+    args = [
+      Arg {
+        name = <U x>
+      }
+    ]
+  }
+  body = Assign {
+    lhs = LVarLhs {
+      name = <U x>
+    }
+    rhs = Const {
+      scope = NULL
+      name = <C <U <ErrorNode>>>
+    }
+  }
+}
@@ -0,0 +1,6 @@
+# typed: false
+# Should still see at least method def (not body)
+def test_bad_assign(x)
+  x =
+  # ^ error: expected an expression after `=`
+end
@@ -0,0 +1,96 @@
+Begin {
+  stmts = [
+    If {
+      condition = IFlipflop {
+        left = String {
+          val = <U flip>
+        }
+        right = String {
+          val = <U flop>
+        }
+      }
+      then_ = String {
+        val = <U body 1>
+      }
+      else_ = NULL
+    }
+    If {
+      condition = EFlipflop {
+        left = String {
+          val = <U flip>
+        }
+        right = String {
+          val = <U flop>
+        }
+      }
+      then_ = String {
+        val = <U body 2>
+      }
+      else_ = NULL
+    }
+    If {
+      condition = IFlipflop {
+        left = String {
+          val = <U flip>
+        }
+        right = String {
+          val = <U flop>
+        }
+      }
+      then_ = String {
+        val = <U body 3>
+      }
+      else_ = NULL
+    }
+    If {
+      condition = IFlipflop {
+        left = String {
+          val = <U flip>
+        }
+        right = String {
+          val = <U flop>
+        }
+      }
+      then_ = NULL
+      else_ = String {
+        val = <U body 4>
+      }
+    }
+    If {
+      condition = IFlipflop {
+        left = String {
+          val = <U flip>
+        }
+        right = String {
+          val = <U flop>
+        }
+      }
+      then_ = NULL
+      else_ = String {
+        val = <U body 5>
+      }
+    }
+    Assign {
+      lhs = LVarLhs {
+        name = <U b>
+      }
+      rhs = Send {
+        receiver = Begin {
+          stmts = [
+            IFlipflop {
+              left = String {
+                val = <U flip>
+              }
+              right = String {
+                val = <U flop>
+              }
+            }
+          ]
+        }
+        method = <U !>
+        args = [
+        ]
+      }
+    }
+  ]
+}
@@ -0,0 +1,26 @@
+# typed: false
+
+if "flip".."flop" # 2 dots
+  #^^^^^^^^^^^^^^ error: Unsupported node type `IFlipflop`
+  "body 1"
+end
+
+if "flip"..."flop" # 3 dots
+  #^^^^^^^^^^^^^^^ error: Unsupported node type `EFlipflop`
+  "body 2"
+end
+
+"body 3" if "flip".."flop" # In a modifier
+#           ^^^^^^^^^^^^^^ error: Unsupported node type `IFlipflop`
+
+unless "flip".."flop"
+  #    ^^^^^^^^^^^^^^ error: Unsupported node type `IFlipflop`
+  "body 4"
+end
+
+"body 5" unless "flip".."flop" # In a modifier
+#               ^^^^^^^^^^^^^^ error: Unsupported node type `IFlipflop`
+
+# In a boolean expression
+b = !("flip".."flop")
+#     ^^^^^^^^^^^^^^ error: Unsupported node type `IFlipflop`
@@ -0,0 +1,76 @@
+Begin {
+  stmts = [
+    Float {
+      val = "-0.001"
+    }
+    Float {
+      val = "-1.602176634e-19"
+    }
+    Float {
+      val = "-1.732"
+    }
+    Float {
+      val = "-100.0"
+    }
+    Float {
+      val = "-2.71"
+    }
+    Float {
+      val = "-2.99792458e8"
+    }
+    Float {
+      val = "-42.01"
+    }
+    Float {
+      val = "-6.02"
+    }
+    Float {
+      val = "-9.81"
+    }
+    Float {
+      val = "-987.654"
+    }
+    Float {
+      val = "+0.577"
+    }
+    Float {
+      val = "+1.602176634e-19"
+    }
+    Float {
+      val = "+123.456"
+    }
+    Float {
+      val = "+3.14"
+    }
+    Float {
+      val = "+42.01"
+    }
+    Float {
+      val = "+42.123"
+    }
+    Float {
+      val = "+42.195"
+    }
+    Float {
+      val = "+6.67430e-11"
+    }
+    Float {
+      val = "0.0"
+    }
+    Float {
+      val = "1.618"
+    }
+    Float {
+      val = "2.71828"
+    }
+    Float {
+      val = "3.14159265359"
+    }
+    Float {
+      val = "3.333"
+    }
+    Float {
+      val = "5.333333"
+    }
+  ]
+}
@@ -0,0 +1,26 @@
+# typed: false
+
+-0.001
+-1.602176634e-19
+-1.732
+-100.0
+-2.71
+-2.99792458e8
+-42.01
+-6.02
+-9.81
+-987.654
++0.577
++1.602176634e-19
++123.456
++3.14
++42.01
++42.123
++42.195
++6.67430e-11
+0.0
+1.618
+2.71828
+3.14159265359
+3.333
+5.333333